LUFA/Drivers/USB/Class/Host/Printer.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 #define  __INCLUDE_FROM_USB_DRIVER
  32 #include "../../HighLevel/USBMode.h"
  33 #if defined(USB_CAN_BE_HOST)
  34
  35 #define  __INCLUDE_FROM_PRINTER_DRIVER
  36 #define  __INCLUDE_FROM_PRINTER_HOST_C
  37 #include "Printer.h"
  38
  39 uint8_t PRNT_Host_ConfigurePipes(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
  40                                  uint16_t ConfigDescriptorSize,
  41                                                              void* DeviceConfigDescriptor)
  42 {
  43         USB_Descriptor_Endpoint_t*  DataINEndpoint   = NULL;
  44         USB_Descriptor_Endpoint_t*  DataOUTEndpoint  = NULL;
  45         USB_Descriptor_Interface_t* PrinterInterface = NULL;
  46
  47         memset(&PRNTInterfaceInfo->State, 0x00, sizeof(PRNTInterfaceInfo->State));
  48
  49         if (DESCRIPTOR_TYPE(DeviceConfigDescriptor) != DTYPE_Configuration)
  50           return PRNT_ENUMERROR_InvalidConfigDescriptor;
  51
  52         while (!(DataINEndpoint) || !(DataOUTEndpoint))
  53         {
  54                 if (!(PrinterInterface) ||
  55                     USB_GetNextDescriptorComp(&ConfigDescriptorSize, &DeviceConfigDescriptor,
  56                                               DCOMP_PRNT_Host_NextPRNTInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  57                 {
  58                         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &DeviceConfigDescriptor,
  59                                                       DCOMP_PRNT_Host_NextPRNTInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  60                         {
  61                                 return PRNT_ENUMERROR_NoCompatibleInterfaceFound;
  62                         }
  63
  64                         PrinterInterface = DESCRIPTOR_PCAST(DeviceConfigDescriptor, USB_Descriptor_Interface_t);
  65
  66                         DataINEndpoint  = NULL;
  67                         DataOUTEndpoint = NULL;
  68
  69                         continue;
  70                 }
  71
  72                 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(DeviceConfigDescriptor, USB_Descriptor_Endpoint_t);
  73
  74                 if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
  75                   DataINEndpoint  = EndpointData;
  76                 else
  77                   DataOUTEndpoint = EndpointData;
  78         }
  79
  80         for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
  81         {
  82                 if (PipeNum == PRNTInterfaceInfo->Config.DataINPipeNumber)
  83                 {
  84                         Pipe_ConfigurePipe(PipeNum, EP_TYPE_BULK, PIPE_TOKEN_IN,
  85                                            DataINEndpoint->EndpointAddress, DataINEndpoint->EndpointSize,
  86                                            PRNTInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  87
  88                         PRNTInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
  89                 }
  90                 else if (PipeNum == PRNTInterfaceInfo->Config.DataOUTPipeNumber)
  91                 {
  92                         Pipe_ConfigurePipe(PipeNum, EP_TYPE_BULK, PIPE_TOKEN_OUT,
  93                                            DataOUTEndpoint->EndpointAddress, DataOUTEndpoint->EndpointSize,
  94                                            PRNTInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  95
  96                         PRNTInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
  97                 }
  98         }
  99
 100         PRNTInterfaceInfo->State.InterfaceNumber  = PrinterInterface->InterfaceNumber;
 101         PRNTInterfaceInfo->State.AlternateSetting = PrinterInterface->AlternateSetting;
 102         PRNTInterfaceInfo->State.IsActive = true;
 103
 104         return PRNT_ENUMERROR_NoError;
 105 }
 106
 107 static uint8_t DCOMP_PRNT_Host_NextPRNTInterface(void* CurrentDescriptor)
 108 {
 109         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 110         {
 111                 USB_Descriptor_Interface_t* CurrentInterface = DESCRIPTOR_PCAST(CurrentDescriptor,
 112                                                                                 USB_Descriptor_Interface_t);
 113
 114                 if ((CurrentInterface->Class    == PRNT_CSCP_PrinterClass)    &&
 115                     (CurrentInterface->SubClass == PRNT_CSCP_PrinterSubclass) &&
 116                     (CurrentInterface->Protocol == PRNT_CSCP_BidirectionalProtocol))
 117                 {
 118                         return DESCRIPTOR_SEARCH_Found;
 119                 }
 120         }
 121
 122         return DESCRIPTOR_SEARCH_NotFound;
 123 }
 124
 125 static uint8_t DCOMP_PRNT_Host_NextPRNTInterfaceEndpoint(void* CurrentDescriptor)
 126 {
 127         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)
 128         {
 129                 uint8_t EndpointType = (DESCRIPTOR_CAST(CurrentDescriptor,
 130                                                         USB_Descriptor_Endpoint_t).Attributes & EP_TYPE_MASK);
 131
 132                 if (EndpointType == EP_TYPE_BULK)
 133                   return DESCRIPTOR_SEARCH_Found;
 134         }
 135         else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 136         {
 137                 return DESCRIPTOR_SEARCH_Fail;
 138         }
 139
 140         return DESCRIPTOR_SEARCH_NotFound;
 141 }
 142
 143 void PRNT_Host_USBTask(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 144 {
 145         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 146           return;
 147
 148         #if !defined(NO_CLASS_DRIVER_AUTOFLUSH)
 149         PRNT_Host_Flush(PRNTInterfaceInfo);
 150         #endif
 151 }
 152
 153 uint8_t PRNT_Host_SetBidirectionalMode(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 154 {
 155         if (PRNTInterfaceInfo->State.AlternateSetting)
 156         {
 157                 uint8_t ErrorCode;
 158
 159                 USB_ControlRequest = (USB_Request_Header_t)
 160                         {
 161                                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_INTERFACE),
 162                                 .bRequest      = REQ_SetInterface,
 163                                 .wValue        = PRNTInterfaceInfo->State.AlternateSetting,
 164                                 .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 165                                 .wLength       = 0,
 166                         };
 167
 168                 Pipe_SelectPipe(PIPE_CONTROLPIPE);
 169
 170                 if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
 171                   return ErrorCode;
 172         }
 173
 174         return HOST_SENDCONTROL_Successful;
 175 }
 176
 177 uint8_t PRNT_Host_GetPortStatus(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 178                                 uint8_t* const PortStatus)
 179 {
 180         USB_ControlRequest = (USB_Request_Header_t)
 181                 {
 182                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 183                         .bRequest      = PRNT_REQ_GetPortStatus,
 184                         .wValue        = 0,
 185                         .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 186                         .wLength       = sizeof(uint8_t),
 187                 };
 188
 189         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 190
 191         return USB_Host_SendControlRequest(PortStatus);
 192 }
 193
 194 uint8_t PRNT_Host_SoftReset(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 195 {
 196         USB_ControlRequest = (USB_Request_Header_t)
 197                 {
 198                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 199                         .bRequest      = PRNT_REQ_SoftReset,
 200                         .wValue        = 0,
 201                         .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 202                         .wLength       = 0,
 203                 };
 204
 205         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 206
 207         return USB_Host_SendControlRequest(NULL);
 208 }
 209
 210 uint8_t PRNT_Host_Flush(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 211 {
 212         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 213           return PIPE_READYWAIT_DeviceDisconnected;
 214
 215         uint8_t ErrorCode;
 216
 217         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 218         Pipe_Unfreeze();
 219
 220         if (!(Pipe_BytesInPipe()))
 221           return PIPE_READYWAIT_NoError;
 222
 223         bool BankFull = !(Pipe_IsReadWriteAllowed());
 224
 225         Pipe_ClearOUT();
 226
 227         if (BankFull)
 228         {
 229                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 230                   return ErrorCode;
 231
 232                 Pipe_ClearOUT();
 233         }
 234
 235         Pipe_Freeze();
 236
 237         return PIPE_READYWAIT_NoError;
 238 }
 239
 240 uint8_t PRNT_Host_SendByte(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 241                            const uint8_t Data)
 242 {
 243         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 244           return PIPE_READYWAIT_DeviceDisconnected;
 245
 246         uint8_t ErrorCode;
 247
 248         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 249         Pipe_Unfreeze();
 250
 251         if (!(Pipe_IsReadWriteAllowed()))
 252         {
 253                 Pipe_ClearOUT();
 254
 255                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 256                   return ErrorCode;
 257         }
 258
 259         Pipe_Write_Byte(Data);
 260         Pipe_Freeze();
 261
 262         return PIPE_READYWAIT_NoError;
 263 }
 264
 265 uint8_t PRNT_Host_SendString(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 266                              void* Buffer,
 267                              const uint16_t Length)
 268 {
 269         uint8_t ErrorCode;
 270
 271         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 272           return PIPE_RWSTREAM_DeviceDisconnected;
 273
 274         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 275         Pipe_Unfreeze();
 276
 277         if ((ErrorCode = Pipe_Write_Stream_LE(Buffer, Length, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 278           return ErrorCode;
 279
 280         Pipe_ClearOUT();
 281
 282         ErrorCode = Pipe_WaitUntilReady();
 283
 284         Pipe_Freeze();
 285
 286         return ErrorCode;
 287 }
 288
 289 uint16_t PRNT_Host_BytesReceived(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 290 {
 291         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 292           return 0;
 293
 294         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataINPipeNumber);
 295         Pipe_Unfreeze();
 296
 297         if (Pipe_IsINReceived())
 298         {
 299                 if (!(Pipe_BytesInPipe()))
 300                 {
 301                         Pipe_ClearIN();
 302                         Pipe_Freeze();
 303                         return 0;
 304                 }
 305                 else
 306                 {
 307                         Pipe_Freeze();
 308                         return Pipe_BytesInPipe();
 309                 }
 310         }
 311         else
 312         {
 313                 Pipe_Freeze();
 314
 315                 return 0;
 316         }
 317 }
 318
 319 int16_t PRNT_Host_ReceiveByte(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 320 {
 321         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 322           return PIPE_RWSTREAM_DeviceDisconnected;
 323
 324         int16_t ReceivedByte = -1;
 325
 326         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataINPipeNumber);
 327         Pipe_Unfreeze();
 328
 329         if (Pipe_IsINReceived())
 330         {
 331                 if (Pipe_BytesInPipe())
 332                   ReceivedByte = Pipe_Read_Byte();
 333
 334                 if (!(Pipe_BytesInPipe()))
 335                   Pipe_ClearIN();
 336         }
 337
 338         Pipe_Freeze();
 339
 340         return ReceivedByte;
 341 }
 342
 343 uint8_t PRNT_Host_GetDeviceID(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 344                               char* const DeviceIDString,
 345                               const uint16_t BufferSize)
 346 {
 347         uint8_t  ErrorCode = HOST_SENDCONTROL_Successful;
 348         uint16_t DeviceIDStringLength = 0;
 349
 350         USB_ControlRequest = (USB_Request_Header_t)
 351                 {
 352                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 353                         .bRequest      = PRNT_REQ_GetDeviceID,
 354                         .wValue        = 0,
 355                         .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 356                         .wLength       = sizeof(DeviceIDStringLength),
 357                 };
 358
 359         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 360
 361         if ((ErrorCode = USB_Host_SendControlRequest(&DeviceIDStringLength)) != HOST_SENDCONTROL_Successful)
 362           return ErrorCode;
 363
 364         if (!(DeviceIDStringLength))
 365         {
 366                 DeviceIDString[0] = 0x00;
 367                 return HOST_SENDCONTROL_Successful;
 368         }
 369
 370         DeviceIDStringLength = SwapEndian_16(DeviceIDStringLength);
 371
 372         if (DeviceIDStringLength > BufferSize)
 373           DeviceIDStringLength = BufferSize;
 374
 375         USB_ControlRequest.wLength = DeviceIDStringLength;
 376
 377         if ((ErrorCode = USB_Host_SendControlRequest(DeviceIDString)) != HOST_SENDCONTROL_Successful)
 378           return ErrorCode;
 379
 380         memmove(&DeviceIDString[0], &DeviceIDString[2], DeviceIDStringLength - 2);
 381
 382         DeviceIDString[DeviceIDStringLength - 2] = 0x00;
 383
 384         return HOST_SENDCONTROL_Successful;
 385 }
 386
 387 #endif
 388