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

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2009.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, and distribute this software
  13   and its documentation for any purpose and without fee is hereby
  14   granted, provided that the above copyright notice appear in all
  15   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 #include "../../HighLevel/USBMode.h"
  32 #if defined(USB_CAN_BE_HOST)
  33
  34 #define INCLUDE_FROM_PRINTER_CLASS_HOST_C
  35 #include "Printer.h"
  36
  37 uint8_t PRNT_Host_ConfigurePipes(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo, uint16_t ConfigDescriptorSize,
  38                                                              void* DeviceConfigDescriptor)
  39 {
  40         uint8_t FoundEndpoints = 0;
  41
  42         memset(&PRNTInterfaceInfo->State, 0x00, sizeof(PRNTInterfaceInfo->State));
  43
  44         if (DESCRIPTOR_TYPE(DeviceConfigDescriptor) != DTYPE_Configuration)
  45           return PRNT_ENUMERROR_InvalidConfigDescriptor;
  46
  47         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &DeviceConfigDescriptor,
  48                                       DComp_NextPRNTInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  49         {
  50                 return PRNT_ENUMERROR_NoPrinterInterfaceFound;
  51         }
  52
  53         USB_Descriptor_Interface_t* PrinterInterface = DESCRIPTOR_PCAST(DeviceConfigDescriptor, USB_Descriptor_Interface_t);
  54
  55         PRNTInterfaceInfo->State.InterfaceNumber  = PrinterInterface->InterfaceNumber;
  56         PRNTInterfaceInfo->State.AlternateSetting = PrinterInterface->AlternateSetting;
  57
  58         while (FoundEndpoints != (PRNT_FOUND_DATAPIPE_IN | PRNT_FOUND_DATAPIPE_OUT))
  59         {
  60                 if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &DeviceConfigDescriptor,
  61                                               DComp_NextPRNTInterfaceEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  62                 {
  63                         return PRNT_ENUMERROR_EndpointsNotFound;
  64                 }
  65
  66                 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(DeviceConfigDescriptor, USB_Descriptor_Endpoint_t);
  67
  68                 if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
  69                 {
  70                         Pipe_ConfigurePipe(PRNTInterfaceInfo->Config.DataINPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_IN,
  71                                            EndpointData->EndpointAddress, EndpointData->EndpointSize,
  72                                            PRNTInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  73                         PRNTInterfaceInfo->State.DataINPipeSize = EndpointData->EndpointSize;
  74
  75                         FoundEndpoints |= PRNT_FOUND_DATAPIPE_IN;
  76                 }
  77                 else
  78                 {
  79                         Pipe_ConfigurePipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber, EP_TYPE_BULK, PIPE_TOKEN_OUT,
  80                                            EndpointData->EndpointAddress, EndpointData->EndpointSize,
  81                                            PRNTInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  82                         PRNTInterfaceInfo->State.DataOUTPipeSize = EndpointData->EndpointSize;
  83
  84                         FoundEndpoints |= PRNT_FOUND_DATAPIPE_OUT;
  85                 }
  86         }
  87
  88         PRNTInterfaceInfo->State.IsActive = true;
  89         return PRNT_ENUMERROR_NoError;
  90 }
  91
  92 static uint8_t DComp_NextPRNTInterface(void* CurrentDescriptor)
  93 {
  94         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
  95         {
  96                 if ((DESCRIPTOR_CAST(CurrentDescriptor, USB_Descriptor_Interface_t).Class    == PRINTER_CLASS)    &&
  97                     (DESCRIPTOR_CAST(CurrentDescriptor, USB_Descriptor_Interface_t).SubClass == PRINTER_SUBCLASS) &&
  98                         (DESCRIPTOR_CAST(CurrentDescriptor, USB_Descriptor_Interface_t).Protocol == PRINTER_PROTOCOL))
  99                 {
 100                         return DESCRIPTOR_SEARCH_Found;
 101                 }
 102         }
 103
 104         return DESCRIPTOR_SEARCH_NotFound;
 105 }
 106
 107 static uint8_t DComp_NextPRNTInterfaceEndpoint(void* CurrentDescriptor)
 108 {
 109         if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Endpoint)
 110         {
 111                 uint8_t EndpointType = (DESCRIPTOR_CAST(CurrentDescriptor,
 112                                                         USB_Descriptor_Endpoint_t).Attributes & EP_TYPE_MASK);
 113
 114                 if (EndpointType == EP_TYPE_BULK)
 115                   return DESCRIPTOR_SEARCH_Found;
 116         }
 117         else if (DESCRIPTOR_TYPE(CurrentDescriptor) == DTYPE_Interface)
 118         {
 119                 return DESCRIPTOR_SEARCH_Fail;
 120         }
 121
 122         return DESCRIPTOR_SEARCH_NotFound;
 123 }
 124
 125 void PRNT_Host_USBTask(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 126 {
 127
 128 }
 129
 130 uint8_t PRNT_Host_SetBidirectionalMode(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 131 {
 132         if (PRNTInterfaceInfo->State.AlternateSetting)
 133         {
 134                 uint8_t ErrorCode;
 135
 136                 USB_ControlRequest = (USB_Request_Header_t)
 137                         {
 138                                 bmRequestType: (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_INTERFACE),
 139                                 bRequest:      REQ_SetInterface,
 140                                 wValue:        PRNTInterfaceInfo->State.AlternateSetting,
 141                                 wIndex:        PRNTInterfaceInfo->State.InterfaceNumber,
 142                                 wLength:       0,
 143                         };
 144
 145                 Pipe_SelectPipe(PIPE_CONTROLPIPE);
 146
 147                 if ((ErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
 148                   return ErrorCode;
 149         }
 150
 151         return HOST_SENDCONTROL_Successful;
 152 }
 153
 154 uint8_t PRNT_Host_GetPortStatus(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo, uint8_t* const PortStatus)
 155 {
 156         USB_ControlRequest = (USB_Request_Header_t)
 157                 {
 158                         bmRequestType: (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 159                         bRequest:      REQ_GetPortStatus,
 160                         wValue:        0,
 161                         wIndex:        PRNTInterfaceInfo->State.InterfaceNumber,
 162                         wLength:       sizeof(uint8_t),
 163                 };
 164
 165         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 166
 167         return USB_Host_SendControlRequest(PortStatus);
 168 }
 169
 170 uint8_t PRNT_Host_SoftReset(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo)
 171 {
 172         USB_ControlRequest = (USB_Request_Header_t)
 173                 {
 174                         bmRequestType: (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE),
 175                         bRequest:      REQ_SoftReset,
 176                         wValue:        0,
 177                         wIndex:        PRNTInterfaceInfo->State.InterfaceNumber,
 178                         wLength:       0,
 179                 };
 180
 181         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 182
 183         return USB_Host_SendControlRequest(NULL);
 184 }
 185
 186 uint8_t PRNT_Host_SendData(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo, void* PrinterCommands, uint16_t CommandSize)
 187 {
 188         uint8_t ErrorCode;
 189
 190         if ((USB_HostState != HOST_STATE_Configured) || !(PRNTInterfaceInfo->State.IsActive))
 191           return PIPE_RWSTREAM_DeviceDisconnected;
 192
 193         Pipe_SelectPipe(PRNTInterfaceInfo->Config.DataOUTPipeNumber);
 194         Pipe_Unfreeze();
 195
 196         if ((ErrorCode = Pipe_Write_Stream_LE(PrinterCommands, CommandSize, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 197           return ErrorCode;
 198
 199         Pipe_ClearOUT();
 200         while (!(Pipe_IsOUTReady()))
 201         {
 202                 if (USB_HostState == HOST_STATE_Unattached)
 203                   return PIPE_RWSTREAM_DeviceDisconnected;
 204         }
 205
 206         Pipe_Freeze();
 207
 208         return PIPE_RWSTREAM_NoError;
 209 }
 210
 211 uint8_t PRNT_Host_GetDeviceID(USB_ClassInfo_PRNT_Host_t* const PRNTInterfaceInfo, char* DeviceIDString, uint16_t BufferSize)
 212 {
 213         uint8_t  ErrorCode = HOST_SENDCONTROL_Successful;
 214         uint16_t DeviceIDStringLength = 0;
 215
 216         USB_ControlRequest = (USB_Request_Header_t)
 217                 {
 218                         bmRequestType: (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
 219                         bRequest:      REQ_GetDeviceID,
 220                         wValue:        0,
 221                         wIndex:        PRNTInterfaceInfo->State.InterfaceNumber,
 222                         wLength:       sizeof(DeviceIDStringLength),
 223                 };
 224
 225         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 226
 227         if ((ErrorCode = USB_Host_SendControlRequest(&DeviceIDStringLength)) != HOST_SENDCONTROL_Successful)
 228           return ErrorCode;
 229
 230         if (!(DeviceIDStringLength))
 231         {
 232                 DeviceIDString[0] = 0x00;
 233                 return HOST_SENDCONTROL_Successful;
 234         }
 235
 236         DeviceIDStringLength = SwapEndian_16(DeviceIDStringLength);
 237
 238         if (DeviceIDStringLength > BufferSize)
 239           DeviceIDStringLength = BufferSize;
 240
 241         USB_ControlRequest.wLength = DeviceIDStringLength;
 242
 243         if ((ErrorCode = USB_Host_SendControlRequest(DeviceIDString)) != HOST_SENDCONTROL_Successful)
 244           return ErrorCode;
 245
 246         memmove(&DeviceIDString[0], &DeviceIDString[2], DeviceIDStringLength - 2);
 247
 248         DeviceIDString[DeviceIDStringLength - 2] = 0x00;
 249
 250         return HOST_SENDCONTROL_Successful;
 251 }
 252
 253 #endif