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.fourwalledcubicle.com
   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_CLASS_HOST_C
  36 #define  __INCLUDE_FROM_PRINTER_DRIVER
  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                 if ((DESCRIPTOR_CAST(CurrentDescriptor, USB_Descriptor_Interface_t).Class    == PRINTER_CLASS)    &&
 112                     (DESCRIPTOR_CAST(CurrentDescriptor, USB_Descriptor_Interface_t).SubClass == PRINTER_SUBCLASS) &&
 113                         (DESCRIPTOR_CAST(CurrentDescriptor, USB_Descriptor_Interface_t).Protocol == PRINTER_PROTOCOL))
 114                 {
 115                         return DESCRIPTOR_SEARCH_Found;
 116                 }
 117         }
 118
 119         return DESCRIPTOR_SEARCH_NotFound;
 120 }
 121
 122 static uint8_t DCOMP_PRNT_Host_NextPRNTInterfaceEndpoint(void* CurrentDescriptor)
 123 {
 124         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)
 125         {
 126                 uint8_t EndpointType = (DESCRIPTOR_CAST(CurrentDescriptor,
 127                                                         USB_Descriptor_Endpoint_t).Attributes & EP_TYPE_MASK);
 128
 129                 if (EndpointType == EP_TYPE_BULK)
 130                   return DESCRIPTOR_SEARCH_Found;
 131         }
 132         else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 133         {
 134                 return DESCRIPTOR_SEARCH_Fail;
 135         }
 136
 137         return DESCRIPTOR_SEARCH_NotFound;
 138 }
 139
 140 void PRNT_Host_USBTask(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 141 {
 142         PRNT_Host_Flush(PRNTInterfaceInfo);
 143 }
 144
 145 uint8_t PRNT_Host_SetBidirectionalMode(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 146 {
 147         if (PRNTInterfaceInfo->State.AlternateSetting)
 148         {
 149                 uint8_t ErrorCode;
 150
 151                 USB_ControlRequest = (USB_Request_Header_t)
 152                         {
 153                                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_INTERFACE),
 154                                 .bRequest      = REQ_SetInterface,
 155                                 .wValue        = PRNTInterfaceInfo->State.AlternateSetting,
 156                                 .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 157                                 .wLength       = 0,
 158                         };
 159
 160                 Pipe_SelectPipe(PIPE_CONTROLPIPE);
 161
 162                 if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
 163                   return ErrorCode;
 164         }
 165
 166         return HOST_SENDCONTROL_Successful;
 167 }
 168
 169 uint8_t PRNT_Host_GetPortStatus(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 170                                 uint8_t* const PortStatus)
 171 {
 172         USB_ControlRequest = (USB_Request_Header_t)
 173                 {
 174                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 175                         .bRequest      = REQ_GetPortStatus,
 176                         .wValue        = 0,
 177                         .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 178                         .wLength       = sizeof(uint8_t),
 179                 };
 180
 181         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 182
 183         return USB_Host_SendControlRequest(PortStatus);
 184 }
 185
 186 uint8_t PRNT_Host_SoftReset(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 187 {
 188         USB_ControlRequest = (USB_Request_Header_t)
 189                 {
 190                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 191                         .bRequest      = REQ_SoftReset,
 192                         .wValue        = 0,
 193                         .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 194                         .wLength       = 0,
 195                 };
 196
 197         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 198
 199         return USB_Host_SendControlRequest(NULL);
 200 }
 201
 202 uint8_t PRNT_Host_Flush(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 203 {
 204         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 205           return PIPE_READYWAIT_DeviceDisconnected;
 206
 207         uint8_t ErrorCode;
 208
 209         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 210         Pipe_Unfreeze();
 211
 212         if (!(Pipe_BytesInPipe()))
 213           return PIPE_READYWAIT_NoError;
 214
 215         bool BankFull = !(Pipe_IsReadWriteAllowed());
 216
 217         Pipe_ClearOUT();
 218
 219         if (BankFull)
 220         {
 221                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 222                   return ErrorCode;
 223
 224                 Pipe_ClearOUT();
 225         }
 226
 227         Pipe_Freeze();
 228
 229         return PIPE_READYWAIT_NoError;
 230 }
 231
 232 uint8_t PRNT_Host_SendByte(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 233                            const uint8_t Data)
 234 {
 235         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 236           return PIPE_READYWAIT_DeviceDisconnected;
 237
 238         uint8_t ErrorCode;
 239
 240         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 241         Pipe_Unfreeze();
 242
 243         if (!(Pipe_IsReadWriteAllowed()))
 244         {
 245                 Pipe_ClearOUT();
 246
 247                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 248                   return ErrorCode;
 249         }
 250
 251         Pipe_Write_Byte(Data);
 252         Pipe_Freeze();
 253
 254         return PIPE_READYWAIT_NoError;
 255 }
 256
 257 uint8_t PRNT_Host_SendString(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 258                              void* Buffer,
 259                              const uint16_t Length)
 260 {
 261         uint8_t ErrorCode;
 262
 263         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 264           return PIPE_RWSTREAM_DeviceDisconnected;
 265
 266         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 267         Pipe_Unfreeze();
 268
 269         if ((ErrorCode = Pipe_Write_Stream_LE(Buffer, Length, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 270           return ErrorCode;
 271
 272         Pipe_ClearOUT();
 273
 274         ErrorCode = Pipe_WaitUntilReady();
 275
 276         Pipe_Freeze();
 277
 278         return ErrorCode;
 279 }
 280
 281 uint16_t PRNT_Host_BytesReceived(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 282 {
 283         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 284           return 0;
 285
 286         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataINPipeNumber);
 287         Pipe_Unfreeze();
 288
 289         if (Pipe_IsINReceived())
 290         {
 291                 if (!(Pipe_BytesInPipe()))
 292                 {
 293                         Pipe_ClearIN();
 294                         Pipe_Freeze();
 295                         return 0;
 296                 }
 297                 else
 298                 {
 299                         Pipe_Freeze();
 300                         return Pipe_BytesInPipe();
 301                 }
 302         }
 303         else
 304         {
 305                 Pipe_Freeze();
 306
 307                 return 0;
 308         }
 309 }
 310
 311 int16_t PRNT_Host_ReceiveByte(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 312 {
 313         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 314           return PIPE_RWSTREAM_DeviceDisconnected;
 315
 316         int16_t ReceivedByte = -1;
 317
 318         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataINPipeNumber);
 319         Pipe_Unfreeze();
 320
 321         if (Pipe_IsINReceived())
 322         {
 323                 if (Pipe_BytesInPipe())
 324                   ReceivedByte = Pipe_Read_Byte();
 325
 326                 if (!(Pipe_BytesInPipe()))
 327                   Pipe_ClearIN();
 328         }
 329
 330         Pipe_Freeze();
 331
 332         return ReceivedByte;
 333 }
 334
 335 uint8_t PRNT_Host_GetDeviceID(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 336                               char* const DeviceIDString,
 337                               const uint16_t BufferSize)
 338 {
 339         uint8_t  ErrorCode = HOST_SENDCONTROL_Successful;
 340         uint16_t DeviceIDStringLength = 0;
 341
 342         USB_ControlRequest = (USB_Request_Header_t)
 343                 {
 344                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 345                         .bRequest      =  REQ_GetDeviceID,
 346                         .wValue        = 0,
 347                         .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 348                         .wLength       = sizeof(DeviceIDStringLength),
 349                 };
 350
 351         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 352
 353         if ((ErrorCode = USB_Host_SendControlRequest(&DeviceIDStringLength)) != HOST_SENDCONTROL_Successful)
 354           return ErrorCode;
 355
 356         if (!(DeviceIDStringLength))
 357         {
 358                 DeviceIDString[0] = 0x00;
 359                 return HOST_SENDCONTROL_Successful;
 360         }
 361
 362         DeviceIDStringLength = SwapEndian_16(DeviceIDStringLength);
 363
 364         if (DeviceIDStringLength > BufferSize)
 365           DeviceIDStringLength = BufferSize;
 366
 367         USB_ControlRequest.wLength = DeviceIDStringLength;
 368
 369         if ((ErrorCode = USB_Host_SendControlRequest(DeviceIDString)) != HOST_SENDCONTROL_Successful)
 370           return ErrorCode;
 371
 372         memmove(&DeviceIDString[0], &DeviceIDString[2], DeviceIDStringLength - 2);
 373
 374         DeviceIDString[DeviceIDStringLength - 2] = 0x00;
 375
 376         return HOST_SENDCONTROL_Successful;
 377 }
 378
 379 #endif