LUFA/Drivers/USB/Class/Device/PrinterClassDevice.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2013.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2013  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 disclaims 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_DEVICE)
  35
  36 #define  __INCLUDE_FROM_PRINTER_DRIVER
  37 #define  __INCLUDE_FROM_PRINTER_DEVICE_C
  38 #include "PrinterClassDevice.h"
  39
  40 void PRNT_Device_ProcessControlRequest(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo)
  41 {
  42         if (!(Endpoint_IsSETUPReceived()))
  43           return;
  44
  45         if (USB_ControlRequest.wIndex != PRNTInterfaceInfo->Config.InterfaceNumber)
  46           return;
  47
  48         switch (USB_ControlRequest.bRequest)
  49         {
  50                 case PRNT_REQ_GetDeviceID:
  51                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
  52                         {
  53                                 Endpoint_ClearSETUP();
  54
  55                                 while (!(Endpoint_IsINReady()))
  56                                 {
  57                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
  58                                           return;
  59                                 }
  60
  61                                 uint16_t IEEEStringLen = strlen(PRNTInterfaceInfo->Config.IEEE1284String);
  62                                 Endpoint_Write_16_BE(IEEEStringLen + 1);
  63                                 Endpoint_Write_Control_Stream_LE(PRNTInterfaceInfo->Config.IEEE1284String, IEEEStringLen);
  64                                 Endpoint_ClearStatusStage();
  65                         }
  66
  67                         break;
  68                 case PRNT_REQ_GetPortStatus:
  69                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
  70                         {
  71                                 Endpoint_ClearSETUP();
  72
  73                                 while (!(Endpoint_IsINReady()))
  74                                 {
  75                                         if (USB_DeviceState == DEVICE_STATE_Unattached)
  76                                           return;
  77                                 }
  78
  79                                 Endpoint_Write_8(PRNTInterfaceInfo->State.PortStatus);
  80                                 Endpoint_ClearStatusStage();
  81                         }
  82
  83                         break;
  84                 case PRNT_REQ_SoftReset:
  85                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
  86                         {
  87                                 Endpoint_ClearSETUP();
  88                                 Endpoint_ClearStatusStage();
  89
  90                                 EVENT_PRNT_Device_SoftReset(PRNTInterfaceInfo);
  91                         }
  92
  93                         break;
  94         }
  95 }
  96
  97 bool PRNT_Device_ConfigureEndpoints(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo)
  98 {
  99         memset(&PRNTInterfaceInfo->State, 0x00, sizeof(PRNTInterfaceInfo->State));
 100         PRNTInterfaceInfo->State.PortStatus = PRNT_PORTSTATUS_NOTERROR | PRNT_PORTSTATUS_SELECT;
 101
 102         PRNTInterfaceInfo->Config.DataINEndpoint.Type  = EP_TYPE_BULK;
 103         PRNTInterfaceInfo->Config.DataOUTEndpoint.Type = EP_TYPE_BULK;
 104
 105         if (!(Endpoint_ConfigureEndpointTable(&PRNTInterfaceInfo->Config.DataINEndpoint, 1)))
 106           return false;
 107
 108         if (!(Endpoint_ConfigureEndpointTable(&PRNTInterfaceInfo->Config.DataOUTEndpoint, 1)))
 109           return false;
 110
 111         return true;
 112 }
 113
 114 void PRNT_Device_USBTask(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo)
 115 {
 116         if (USB_DeviceState != DEVICE_STATE_Configured)
 117           return;
 118
 119         #if !defined(NO_CLASS_DRIVER_AUTOFLUSH)
 120         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
 121
 122         if (Endpoint_IsINReady())
 123           PRNT_Device_Flush(PRNTInterfaceInfo);
 124         #endif
 125 }
 126
 127 uint8_t PRNT_Device_SendString(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo,
 128                                const char* const String)
 129 {
 130         if (USB_DeviceState != DEVICE_STATE_Configured)
 131           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 132
 133         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
 134         return Endpoint_Write_Stream_LE(String, strlen(String), NULL);
 135 }
 136
 137 uint8_t PRNT_Device_SendData(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo,
 138                              const void* const Buffer,
 139                              const uint16_t Length)
 140 {
 141         if (USB_DeviceState != DEVICE_STATE_Configured)
 142           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 143
 144         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
 145         return Endpoint_Write_Stream_LE(Buffer, Length, NULL);
 146 }
 147
 148 uint8_t PRNT_Device_SendByte(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo,
 149                              const uint8_t Data)
 150 {
 151         if (USB_DeviceState != DEVICE_STATE_Configured)
 152           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 153
 154         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
 155
 156         if (!(Endpoint_IsReadWriteAllowed()))
 157         {
 158                 Endpoint_ClearIN();
 159
 160                 uint8_t ErrorCode;
 161
 162                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 163                   return ErrorCode;
 164         }
 165
 166         Endpoint_Write_8(Data);
 167         return ENDPOINT_READYWAIT_NoError;
 168 }
 169
 170 uint8_t PRNT_Device_Flush(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo)
 171 {
 172         if (USB_DeviceState != DEVICE_STATE_Configured)
 173           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 174
 175         uint8_t ErrorCode;
 176
 177         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
 178
 179         if (!(Endpoint_BytesInEndpoint()))
 180           return ENDPOINT_READYWAIT_NoError;
 181
 182         bool BankFull = !(Endpoint_IsReadWriteAllowed());
 183
 184         Endpoint_ClearIN();
 185
 186         if (BankFull)
 187         {
 188                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 189                   return ErrorCode;
 190
 191                 Endpoint_ClearIN();
 192         }
 193
 194         return ENDPOINT_READYWAIT_NoError;
 195 }
 196
 197 uint16_t PRNT_Device_BytesReceived(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo)
 198 {
 199         if (USB_DeviceState != DEVICE_STATE_Configured)
 200           return 0;
 201
 202         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataOUTEndpoint.Address);
 203
 204         if (Endpoint_IsOUTReceived())
 205         {
 206                 if (!(Endpoint_BytesInEndpoint()))
 207                 {
 208                         Endpoint_ClearOUT();
 209                         return 0;
 210                 }
 211                 else
 212                 {
 213                         return Endpoint_BytesInEndpoint();
 214                 }
 215         }
 216         else
 217         {
 218                 return 0;
 219         }
 220 }
 221
 222 int16_t PRNT_Device_ReceiveByte(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo)
 223 {
 224         if (USB_DeviceState != DEVICE_STATE_Configured)
 225           return -1;
 226
 227         int16_t ReceivedByte = -1;
 228
 229         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataOUTEndpoint.Address);
 230
 231         if (Endpoint_IsOUTReceived())
 232         {
 233                 if (Endpoint_BytesInEndpoint())
 234                   ReceivedByte = Endpoint_Read_8();
 235
 236                 if (!(Endpoint_BytesInEndpoint()))
 237                   Endpoint_ClearOUT();
 238         }
 239
 240         return ReceivedByte;
 241 }
 242
 243 #if defined(FDEV_SETUP_STREAM)
 244 void PRNT_Device_CreateStream(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo,
 245                               FILE* const Stream)
 246 {
 247         *Stream = (FILE)FDEV_SETUP_STREAM(PRNT_Device_putchar, PRNT_Device_getchar, _FDEV_SETUP_RW);
 248         fdev_set_udata(Stream, PRNTInterfaceInfo);
 249 }
 250
 251 void PRNT_Device_CreateBlockingStream(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo,
 252                                       FILE* const Stream)
 253 {
 254         *Stream = (FILE)FDEV_SETUP_STREAM(PRNT_Device_putchar, PRNT_Device_getchar_Blocking, _FDEV_SETUP_RW);
 255         fdev_set_udata(Stream, PRNTInterfaceInfo);
 256 }
 257
 258 static int PRNT_Device_putchar(char c,
 259                                FILE* Stream)
 260 {
 261         return PRNT_Device_SendByte((USB_ClassInfo_PRNT_Device_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0;
 262 }
 263
 264 static int PRNT_Device_getchar(FILE* Stream)
 265 {
 266         int16_t ReceivedByte = PRNT_Device_ReceiveByte((USB_ClassInfo_PRNT_Device_t*)fdev_get_udata(Stream));
 267
 268         if (ReceivedByte < 0)
 269           return _FDEV_EOF;
 270
 271         return ReceivedByte;
 272 }
 273
 274 static int PRNT_Device_getchar_Blocking(FILE* Stream)
 275 {
 276         int16_t ReceivedByte;
 277
 278         while ((ReceivedByte = PRNT_Device_ReceiveByte((USB_ClassInfo_PRNT_Device_t*)fdev_get_udata(Stream))) < 0)
 279         {
 280                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 281                   return _FDEV_EOF;
 282
 283                 PRNT_Device_USBTask((USB_ClassInfo_PRNT_Device_t*)fdev_get_udata(Stream));
 284                 USB_USBTask();
 285         }
 286
 287         return ReceivedByte;
 288 }
 289 #endif
 290
 291 void PRNT_Device_Event_Stub(void)
 292 {
 293
 294 }
 295
 296 #endif
 297