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

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2011.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2011  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 "../../Core/USBMode.h"
  33
  34 #if defined(USB_CAN_BE_HOST)
  35
  36 #define  __INCLUDE_FROM_PRINTER_DRIVER
  37 #define  __INCLUDE_FROM_PRINTER_HOST_C
  38 #include "Printer.h"
  39
  40 uint8_t PRNT_Host_ConfigurePipes(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
  41                                  uint16_t ConfigDescriptorSize,
  42                                                              void* ConfigDescriptorData)
  43 {
  44         USB_Descriptor_Endpoint_t*  DataINEndpoint   = NULL;
  45         USB_Descriptor_Endpoint_t*  DataOUTEndpoint  = NULL;
  46         USB_Descriptor_Interface_t* PrinterInterface = NULL;
  47
  48         memset(&PRNTInterfaceInfo->State, 0x00, sizeof(PRNTInterfaceInfo->State));
  49
  50         if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
  51           return PRNT_ENUMERROR_InvalidConfigDescriptor;
  52
  53         while (!(DataINEndpoint) || !(DataOUTEndpoint))
  54         {
  55                 if (!(PrinterInterface) ||
  56                     USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  57                                               DCOMP_PRNT_Host_NextPRNTInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  58                 {
  59                         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  60                                                       DCOMP_PRNT_Host_NextPRNTInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  61                         {
  62                                 return PRNT_ENUMERROR_NoCompatibleInterfaceFound;
  63                         }
  64
  65                         PrinterInterface = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Interface_t);
  66
  67                         DataINEndpoint  = NULL;
  68                         DataOUTEndpoint = NULL;
  69
  70                         continue;
  71                 }
  72
  73                 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Endpoint_t);
  74
  75                 if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
  76                   DataINEndpoint  = EndpointData;
  77                 else
  78                   DataOUTEndpoint = EndpointData;
  79         }
  80
  81         for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
  82         {
  83                 uint16_t Size;
  84                 uint8_t  Type;
  85                 uint8_t  Token;
  86                 uint8_t  EndpointAddress;
  87                 bool     DoubleBanked;
  88
  89                 if (PipeNum == PRNTInterfaceInfo->Config.DataINPipeNumber)
  90                 {
  91                         Size            = DataINEndpoint->EndpointSize;
  92                         EndpointAddress = DataINEndpoint->EndpointAddress;
  93                         Token           = PIPE_TOKEN_IN;
  94                         Type            = EP_TYPE_BULK;
  95                         DoubleBanked    = PRNTInterfaceInfo->Config.DataINPipeDoubleBank;
  96
  97                         PRNTInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
  98                 }
  99                 else if (PipeNum == PRNTInterfaceInfo->Config.DataOUTPipeNumber)
 100                 {
 101                         Size            = DataOUTEndpoint->EndpointSize;
 102                         EndpointAddress = DataOUTEndpoint->EndpointAddress;
 103                         Token           = PIPE_TOKEN_OUT;
 104                         Type            = EP_TYPE_BULK;
 105                         DoubleBanked    = PRNTInterfaceInfo->Config.DataOUTPipeDoubleBank;
 106
 107                         PRNTInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
 108                 }
 109                 else
 110                 {
 111                         continue;
 112                 }
 113
 114                 if (!(Pipe_ConfigurePipe(PipeNum, Type, Token, EndpointAddress, Size,
 115                                          DoubleBanked ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE)))
 116                 {
 117                         return PRNT_ENUMERROR_PipeConfigurationFailed;
 118                 }
 119         }
 120
 121         PRNTInterfaceInfo->State.InterfaceNumber  = PrinterInterface->InterfaceNumber;
 122         PRNTInterfaceInfo->State.AlternateSetting = PrinterInterface->AlternateSetting;
 123         PRNTInterfaceInfo->State.IsActive = true;
 124
 125         return PRNT_ENUMERROR_NoError;
 126 }
 127
 128 static uint8_t DCOMP_PRNT_Host_NextPRNTInterface(void* CurrentDescriptor)
 129 {
 130         USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
 131
 132         if (Header->Type == DTYPE_Interface)
 133         {
 134                 USB_Descriptor_Interface_t* Interface = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Interface_t);
 135
 136                 if ((Interface->Class    == PRNT_CSCP_PrinterClass)    &&
 137                     (Interface->SubClass == PRNT_CSCP_PrinterSubclass) &&
 138                     (Interface->Protocol == PRNT_CSCP_BidirectionalProtocol))
 139                 {
 140                         return DESCRIPTOR_SEARCH_Found;
 141                 }
 142         }
 143
 144         return DESCRIPTOR_SEARCH_NotFound;
 145 }
 146
 147 static uint8_t DCOMP_PRNT_Host_NextPRNTInterfaceEndpoint(void* CurrentDescriptor)
 148 {
 149         USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
 150
 151         if (Header->Type == DTYPE_Endpoint)
 152         {
 153                 USB_Descriptor_Endpoint_t* Endpoint = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Endpoint_t);
 154
 155                 uint8_t EndpointType = (Endpoint->Attributes & EP_TYPE_MASK);
 156
 157                 if (EndpointType == EP_TYPE_BULK)
 158                   return DESCRIPTOR_SEARCH_Found;
 159         }
 160         else if (Header->Type == DTYPE_Interface)
 161         {
 162                 return DESCRIPTOR_SEARCH_Fail;
 163         }
 164
 165         return DESCRIPTOR_SEARCH_NotFound;
 166 }
 167
 168 void PRNT_Host_USBTask(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 169 {
 170         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 171           return;
 172
 173         #if !defined(NO_CLASS_DRIVER_AUTOFLUSH)
 174         PRNT_Host_Flush(PRNTInterfaceInfo);
 175         #endif
 176 }
 177
 178 uint8_t PRNT_Host_SetBidirectionalMode(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 179 {
 180         if (PRNTInterfaceInfo->State.AlternateSetting)
 181         {
 182                 uint8_t ErrorCode;
 183
 184                 if ((ErrorCode = USB_Host_SetInterfaceAltSetting(PRNTInterfaceInfo->State.InterfaceNumber,
 185                                                                  PRNTInterfaceInfo->State.AlternateSetting)) != HOST_SENDCONTROL_Successful)
 186                 {
 187                         return ErrorCode;
 188                 }
 189         }
 190
 191         return HOST_SENDCONTROL_Successful;
 192 }
 193
 194 uint8_t PRNT_Host_GetPortStatus(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 195                                 uint8_t* const PortStatus)
 196 {
 197         USB_ControlRequest = (USB_Request_Header_t)
 198                 {
 199                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 200                         .bRequest      = PRNT_REQ_GetPortStatus,
 201                         .wValue        = 0,
 202                         .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 203                         .wLength       = sizeof(uint8_t),
 204                 };
 205
 206         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 207
 208         return USB_Host_SendControlRequest(PortStatus);
 209 }
 210
 211 uint8_t PRNT_Host_SoftReset(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 212 {
 213         USB_ControlRequest = (USB_Request_Header_t)
 214                 {
 215                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 216                         .bRequest      = PRNT_REQ_SoftReset,
 217                         .wValue        = 0,
 218                         .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 219                         .wLength       = 0,
 220                 };
 221
 222         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 223
 224         return USB_Host_SendControlRequest(NULL);
 225 }
 226
 227 uint8_t PRNT_Host_Flush(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 228 {
 229         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 230           return PIPE_READYWAIT_DeviceDisconnected;
 231
 232         uint8_t ErrorCode;
 233
 234         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 235         Pipe_Unfreeze();
 236
 237         if (!(Pipe_BytesInPipe()))
 238           return PIPE_READYWAIT_NoError;
 239
 240         bool BankFull = !(Pipe_IsReadWriteAllowed());
 241
 242         Pipe_ClearOUT();
 243
 244         if (BankFull)
 245         {
 246                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 247                   return ErrorCode;
 248
 249                 Pipe_ClearOUT();
 250         }
 251
 252         Pipe_Freeze();
 253
 254         return PIPE_READYWAIT_NoError;
 255 }
 256
 257 uint8_t PRNT_Host_SendByte(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 258                            const uint8_t Data)
 259 {
 260         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 261           return PIPE_READYWAIT_DeviceDisconnected;
 262
 263         uint8_t ErrorCode;
 264
 265         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 266         Pipe_Unfreeze();
 267
 268         if (!(Pipe_IsReadWriteAllowed()))
 269         {
 270                 Pipe_ClearOUT();
 271
 272                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 273                   return ErrorCode;
 274         }
 275
 276         Pipe_Write_8(Data);
 277         Pipe_Freeze();
 278
 279         return PIPE_READYWAIT_NoError;
 280 }
 281
 282 uint8_t PRNT_Host_SendString(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 283                              void* String)
 284 {
 285         uint8_t ErrorCode;
 286
 287         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 288           return PIPE_RWSTREAM_DeviceDisconnected;
 289
 290         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 291         Pipe_Unfreeze();
 292
 293         if ((ErrorCode = Pipe_Write_Stream_LE(String, strlen(String), NULL)) != PIPE_RWSTREAM_NoError)
 294           return ErrorCode;
 295
 296         Pipe_ClearOUT();
 297
 298         ErrorCode = Pipe_WaitUntilReady();
 299
 300         Pipe_Freeze();
 301
 302         return ErrorCode;
 303 }
 304
 305 uint8_t PRNT_Host_SendData(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 306                            void* Buffer,
 307                            const uint16_t Length)
 308 {
 309         uint8_t ErrorCode;
 310
 311         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 312           return PIPE_RWSTREAM_DeviceDisconnected;
 313
 314         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 315         Pipe_Unfreeze();
 316
 317         if ((ErrorCode = Pipe_Write_Stream_LE(Buffer, Length, NULL)) != PIPE_RWSTREAM_NoError)
 318           return ErrorCode;
 319
 320         Pipe_ClearOUT();
 321
 322         ErrorCode = Pipe_WaitUntilReady();
 323
 324         Pipe_Freeze();
 325
 326         return ErrorCode;
 327 }
 328
 329 uint16_t PRNT_Host_BytesReceived(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 330 {
 331         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 332           return 0;
 333
 334         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataINPipeNumber);
 335         Pipe_Unfreeze();
 336
 337         if (Pipe_IsINReceived())
 338         {
 339                 if (!(Pipe_BytesInPipe()))
 340                 {
 341                         Pipe_ClearIN();
 342                         Pipe_Freeze();
 343                         return 0;
 344                 }
 345                 else
 346                 {
 347                         Pipe_Freeze();
 348                         return Pipe_BytesInPipe();
 349                 }
 350         }
 351         else
 352         {
 353                 Pipe_Freeze();
 354
 355                 return 0;
 356         }
 357 }
 358
 359 int16_t PRNT_Host_ReceiveByte(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 360 {
 361         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 362           return PIPE_RWSTREAM_DeviceDisconnected;
 363
 364         int16_t ReceivedByte = -1;
 365
 366         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataINPipeNumber);
 367         Pipe_Unfreeze();
 368
 369         if (Pipe_IsINReceived())
 370         {
 371                 if (Pipe_BytesInPipe())
 372                   ReceivedByte = Pipe_Read_8();
 373
 374                 if (!(Pipe_BytesInPipe()))
 375                   Pipe_ClearIN();
 376         }
 377
 378         Pipe_Freeze();
 379
 380         return ReceivedByte;
 381 }
 382
 383 uint8_t PRNT_Host_GetDeviceID(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo,
 384                               char* const DeviceIDString,
 385                               const uint16_t BufferSize)
 386 {
 387         uint8_t  ErrorCode = HOST_SENDCONTROL_Successful;
 388         uint16_t DeviceIDStringLength = 0;
 389
 390         USB_ControlRequest = (USB_Request_Header_t)
 391                 {
 392                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 393                         .bRequest      = PRNT_REQ_GetDeviceID,
 394                         .wValue        = 0,
 395                         .wIndex        = PRNTInterfaceInfo->State.InterfaceNumber,
 396                         .wLength       = sizeof(DeviceIDStringLength),
 397                 };
 398
 399         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 400
 401         if ((ErrorCode = USB_Host_SendControlRequest(&DeviceIDStringLength)) != HOST_SENDCONTROL_Successful)
 402           return ErrorCode;
 403
 404         if (!(DeviceIDStringLength))
 405         {
 406                 DeviceIDString[0] = 0x00;
 407                 return HOST_SENDCONTROL_Successful;
 408         }
 409
 410         DeviceIDStringLength = SwapEndian_16(DeviceIDStringLength);
 411
 412         if (DeviceIDStringLength > BufferSize)
 413           DeviceIDStringLength = BufferSize;
 414
 415         USB_ControlRequest.wLength = DeviceIDStringLength;
 416
 417         if ((ErrorCode = USB_Host_SendControlRequest(DeviceIDString)) != HOST_SENDCONTROL_Successful)
 418           return ErrorCode;
 419
 420         memmove(&DeviceIDString[0], &DeviceIDString[2], DeviceIDStringLength - 2);
 421
 422         DeviceIDString[DeviceIDStringLength - 2] = 0x00;
 423
 424         return HOST_SENDCONTROL_Successful;
 425 }
 426
 427 #endif
 428