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
  46         memset(&PRNTInterfaceInfo->State, 0x00, sizeof(PRNTInterfaceInfo->State));
  47
  48         if (DESCRIPTOR_TYPE(DeviceConfigDescriptor) != DTYPE_Configuration)
  49           return PRNT_ENUMERROR_InvalidConfigDescriptor;
  50
  51         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &DeviceConfigDescriptor,
  52                                       DCOMP_PRNT_NextPRNTInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  53         {
  54                 return PRNT_ENUMERROR_NoCompatibleInterfaceFound;
  55         }
  56
  57         PRNTInterfaceInfo->State.InterfaceNumber  = DESCRIPTOR_PCAST(DeviceConfigDescriptor,
  58                                                                      USB_Descriptor_Interface_t)->InterfaceNumber;
  59         PRNTInterfaceInfo->State.AlternateSetting = DESCRIPTOR_PCAST(DeviceConfigDescriptor,
  60                                                                      USB_Descriptor_Interface_t)->AlternateSetting;
  61
  62         while (!(DataINEndpoint) || !(DataOUTEndpoint))
  63         {
  64                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &DeviceConfigDescriptor,
  65                                               DCOMP_PRNT_NextPRNTInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  66                 {
  67                         DataINEndpoint  = NULL;
  68                         DataOUTEndpoint = NULL;
  69
  70                         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &DeviceConfigDescriptor,
  71                                                                                   DCOMP_PRNT_NextPRNTInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  72                         {
  73                                 return PRNT_ENUMERROR_NoCompatibleInterfaceFound;
  74                         }
  75
  76                         PRNTInterfaceInfo->State.InterfaceNumber  = DESCRIPTOR_PCAST(DeviceConfigDescriptor,
  77                                                                                      USB_Descriptor_Interface_t)->InterfaceNumber;
  78                         PRNTInterfaceInfo->State.AlternateSetting = DESCRIPTOR_PCAST(DeviceConfigDescriptor,
  79                                                                                      USB_Descriptor_Interface_t)->AlternateSetting;
  80
  81                         continue;
  82                 }
  83
  84                 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(DeviceConfigDescriptor, USB_Descriptor_Endpoint_t);
  85
  86                 if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
  87                   DataINEndpoint  = EndpointData;
  88                 else
  89                   DataOUTEndpoint = EndpointData;
  90         }
  91
  92         for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
  93         {
  94                 if (PipeNum == PRNTInterfaceInfo->Config.DataINPipeNumber)
  95                 {
  96                         Pipe_ConfigurePipe(PipeNum, EP_TYPE_BULK, PIPE_TOKEN_IN,
  97                                                            DataINEndpoint->EndpointAddress, DataINEndpoint->EndpointSize,
  98                                                            PRNTInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  99
 100                         PRNTInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
 101                 }
 102                 else if (PipeNum == PRNTInterfaceInfo->Config.DataOUTPipeNumber)
 103                 {
 104                         Pipe_ConfigurePipe(PipeNum, EP_TYPE_BULK, PIPE_TOKEN_OUT,
 105                                                            DataOUTEndpoint->EndpointAddress, DataOUTEndpoint->EndpointSize,
 106                                                            PRNTInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
 107
 108                         PRNTInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
 109                 }
 110         }
 111
 112         PRNTInterfaceInfo->State.IsActive = true;
 113
 114         return PRNT_ENUMERROR_NoError;
 115 }
 116
 117 static uint8_t DCOMP_PRNT_NextPRNTInterface(void* CurrentDescriptor)
 118 {
 119         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 120         {
 121                 if ((DESCRIPTOR_CAST(CurrentDescriptor, USB_Descriptor_Interface_t).Class    == PRINTER_CLASS)    &&
 122                     (DESCRIPTOR_CAST(CurrentDescriptor, USB_Descriptor_Interface_t).SubClass == PRINTER_SUBCLASS) &&
 123                         (DESCRIPTOR_CAST(CurrentDescriptor, USB_Descriptor_Interface_t).Protocol == PRINTER_PROTOCOL))
 124                 {
 125                         return DESCRIPTOR_SEARCH_Found;
 126                 }
 127         }
 128
 129         return DESCRIPTOR_SEARCH_NotFound;
 130 }
 131
 132 static uint8_t DCOMP_PRNT_NextPRNTInterfaceEndpoint(void* CurrentDescriptor)
 133 {
 134         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)
 135         {
 136                 uint8_t EndpointType = (DESCRIPTOR_CAST(CurrentDescriptor,
 137                                                         USB_Descriptor_Endpoint_t).Attributes & EP_TYPE_MASK);
 138
 139                 if (EndpointType == EP_TYPE_BULK)
 140                   return DESCRIPTOR_SEARCH_Found;
 141         }
 142         else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 143         {
 144                 return DESCRIPTOR_SEARCH_Fail;
 145         }
 146
 147         return DESCRIPTOR_SEARCH_NotFound;
 148 }
 149
 150 void PRNT_Host_USBTask(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 151 {
 152         PRNT_Host_Flush(PRNTInterfaceInfo);
 153 }
 154
 155 uint8_t PRNT_Host_SetBidirectionalMode(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 156 {
 157         if (PRNTInterfaceInfo->State.AlternateSetting)
 158         {
 159                 uint8_t ErrorCode;
 160
 161                 USB_ControlRequest = (USB_Request_Header_t)
 162                         {
 163                                 .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_INTERFACE),
 164                                 .bRequest      = REQ_SetInterface,
 165                                 .wValue        = PRNTInterfaceInfo->State.AlternateSetting,
 166                                 .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 167                                 .wLength       = 0,
 168                         };
 169
 170                 Pipe_SelectPipe(PIPE_CONTROLPIPE);
 171
 172                 if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
 173                   return ErrorCode;
 174         }
 175
 176         return HOST_SENDCONTROL_Successful;
 177 }
 178
 179 uint8_t PRNT_Host_GetPortStatus(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 180                                 uint8_t* const PortStatus)
 181 {
 182         USB_ControlRequest = (USB_Request_Header_t)
 183                 {
 184                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 185                         .bRequest      = REQ_GetPortStatus,
 186                         .wValue        = 0,
 187                         .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 188                         .wLength       = sizeof(uint8_t),
 189                 };
 190
 191         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 192
 193         return USB_Host_SendControlRequest(PortStatus);
 194 }
 195
 196 uint8_t PRNT_Host_SoftReset(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 197 {
 198         USB_ControlRequest = (USB_Request_Header_t)
 199                 {
 200                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 201                         .bRequest      = REQ_SoftReset,
 202                         .wValue        = 0,
 203                         .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 204                         .wLength       = 0,
 205                 };
 206
 207         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 208
 209         return USB_Host_SendControlRequest(NULL);
 210 }
 211
 212 uint8_t PRNT_Host_Flush(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 213 {
 214         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 215           return PIPE_READYWAIT_DeviceDisconnected;
 216
 217         uint8_t ErrorCode;
 218
 219         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 220         Pipe_Unfreeze();
 221
 222         if (!(Pipe_BytesInPipe()))
 223           return PIPE_READYWAIT_NoError;
 224
 225         bool BankFull = !(Pipe_IsReadWriteAllowed());
 226
 227         Pipe_ClearOUT();
 228
 229         if (BankFull)
 230         {
 231                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 232                   return ErrorCode;
 233
 234                 Pipe_ClearOUT();
 235         }
 236
 237         Pipe_Freeze();
 238
 239         return PIPE_READYWAIT_NoError;
 240 }
 241
 242 uint8_t PRNT_Host_SendByte(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 243                            const uint8_t Data)
 244 {
 245         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 246           return PIPE_READYWAIT_DeviceDisconnected;
 247
 248         uint8_t ErrorCode;
 249
 250         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 251         Pipe_Unfreeze();
 252
 253         if (!(Pipe_IsReadWriteAllowed()))
 254         {
 255                 Pipe_ClearOUT();
 256
 257                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 258                   return ErrorCode;
 259         }
 260
 261         Pipe_Write_Byte(Data);
 262         Pipe_Freeze();
 263
 264         return PIPE_READYWAIT_NoError;
 265 }
 266
 267 uint8_t PRNT_Host_SendString(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 268                              void* Buffer,
 269                              const uint16_t Length)
 270 {
 271         uint8_t ErrorCode;
 272
 273         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 274           return PIPE_RWSTREAM_DeviceDisconnected;
 275
 276         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 277         Pipe_Unfreeze();
 278
 279         if ((ErrorCode = Pipe_Write_Stream_LE(Buffer, Length, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 280           return ErrorCode;
 281
 282         Pipe_ClearOUT();
 283
 284         ErrorCode = Pipe_WaitUntilReady();
 285
 286         Pipe_Freeze();
 287
 288         return ErrorCode;
 289 }
 290
 291 uint16_t PRNT_Host_BytesReceived(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 292 {
 293         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 294           return 0;
 295
 296         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataINPipeNumber);
 297         Pipe_Unfreeze();
 298
 299         if (Pipe_IsINReceived())
 300         {
 301                 if (!(Pipe_BytesInPipe()))
 302                 {
 303                         Pipe_ClearIN();
 304                         Pipe_Freeze();
 305                         return 0;
 306                 }
 307                 else
 308                 {
 309                         Pipe_Freeze();
 310                         return Pipe_BytesInPipe();
 311                 }
 312         }
 313         else
 314         {
 315                 Pipe_Freeze();
 316
 317                 return 0;
 318         }
 319 }
 320
 321 int16_t PRNT_Host_ReceiveByte(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 322 {
 323         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 324           return PIPE_RWSTREAM_DeviceDisconnected;
 325
 326         int16_t ReceivedByte = -1;
 327
 328         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataINPipeNumber);
 329         Pipe_Unfreeze();
 330
 331         if (Pipe_IsINReceived())
 332         {
 333                 if (Pipe_BytesInPipe())
 334                   ReceivedByte = Pipe_Read_Byte();
 335
 336                 if (!(Pipe_BytesInPipe()))
 337                   Pipe_ClearIN();
 338         }
 339
 340         Pipe_Freeze();
 341
 342         return ReceivedByte;
 343 }
 344
 345 uint8_t PRNT_Host_GetDeviceID(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 346                               char* const DeviceIDString,
 347                               const uint16_t BufferSize)
 348 {
 349         uint8_t  ErrorCode = HOST_SENDCONTROL_Successful;
 350         uint16_t DeviceIDStringLength = 0;
 351
 352         USB_ControlRequest = (USB_Request_Header_t)
 353                 {
 354                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 355                         .bRequest      =  REQ_GetDeviceID,
 356                         .wValue        = 0,
 357                         .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 358                         .wLength       = sizeof(DeviceIDStringLength),
 359                 };
 360
 361         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 362
 363         if ((ErrorCode = USB_Host_SendControlRequest(&DeviceIDStringLength)) != HOST_SENDCONTROL_Successful)
 364           return ErrorCode;
 365
 366         if (!(DeviceIDStringLength))
 367         {
 368                 DeviceIDString[0] = 0x00;
 369                 return HOST_SENDCONTROL_Successful;
 370         }
 371
 372         DeviceIDStringLength = SwapEndian_16(DeviceIDStringLength);
 373
 374         if (DeviceIDStringLength > BufferSize)
 375           DeviceIDStringLength = BufferSize;
 376
 377         USB_ControlRequest.wLength = DeviceIDStringLength;
 378
 379         if ((ErrorCode = USB_Host_SendControlRequest(DeviceIDString)) != HOST_SENDCONTROL_Successful)
 380           return ErrorCode;
 381
 382         memmove(&DeviceIDString[0], &DeviceIDString[2], DeviceIDStringLength - 2);
 383
 384         DeviceIDString[DeviceIDStringLength - 2] = 0x00;
 385
 386         return HOST_SENDCONTROL_Successful;
 387 }
 388
 389 #endif