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

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2018.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2018  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);
  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                                 PRNTInterfaceInfo->State.IsPrinterReset = true;
  91
  92                                 EVENT_PRNT_Device_SoftReset(PRNTInterfaceInfo);
  93                         }
  94
  95                         break;
  96         }
  97 }
  98
  99 bool PRNT_Device_ConfigureEndpoints(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo)
 100 {
 101         memset(&PRNTInterfaceInfo->State, 0x00, sizeof(PRNTInterfaceInfo->State));
 102         PRNTInterfaceInfo->State.PortStatus = PRNT_PORTSTATUS_NOTERROR | PRNT_PORTSTATUS_SELECT;
 103
 104         PRNTInterfaceInfo->Config.DataINEndpoint.Type  = EP_TYPE_BULK;
 105         PRNTInterfaceInfo->Config.DataOUTEndpoint.Type = EP_TYPE_BULK;
 106
 107         if (!(Endpoint_ConfigureEndpointTable(&PRNTInterfaceInfo->Config.DataINEndpoint, 1)))
 108           return false;
 109
 110         if (!(Endpoint_ConfigureEndpointTable(&PRNTInterfaceInfo->Config.DataOUTEndpoint, 1)))
 111           return false;
 112
 113         return true;
 114 }
 115
 116 void PRNT_Device_USBTask(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo)
 117 {
 118         if (USB_DeviceState != DEVICE_STATE_Configured)
 119           return;
 120
 121         #if !defined(NO_CLASS_DRIVER_AUTOFLUSH)
 122         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
 123
 124         if (Endpoint_IsINReady())
 125           PRNT_Device_Flush(PRNTInterfaceInfo);
 126         #endif
 127
 128         if (PRNTInterfaceInfo->State.IsPrinterReset)
 129         {
 130                 Endpoint_ResetEndpoint(PRNTInterfaceInfo->Config.DataOUTEndpoint.Address);
 131                 Endpoint_ResetEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
 132
 133                 Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataOUTEndpoint.Address);
 134                 Endpoint_ClearStall();
 135                 Endpoint_ResetDataToggle();
 136                 Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
 137                 Endpoint_ClearStall();
 138                 Endpoint_ResetDataToggle();
 139
 140                 PRNTInterfaceInfo->State.IsPrinterReset = false;
 141         }
 142 }
 143
 144 uint8_t PRNT_Device_SendString(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo,
 145                                const char* const String)
 146 {
 147         if (USB_DeviceState != DEVICE_STATE_Configured)
 148           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 149
 150         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
 151         return Endpoint_Write_Stream_LE(String, strlen(String), NULL);
 152 }
 153
 154 uint8_t PRNT_Device_SendData(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo,
 155                              const void* const Buffer,
 156                              const uint16_t Length)
 157 {
 158         if (USB_DeviceState != DEVICE_STATE_Configured)
 159           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 160
 161         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
 162         return Endpoint_Write_Stream_LE(Buffer, Length, NULL);
 163 }
 164
 165 uint8_t PRNT_Device_SendByte(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo,
 166                              const uint8_t Data)
 167 {
 168         if (USB_DeviceState != DEVICE_STATE_Configured)
 169           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 170
 171         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
 172
 173         if (!(Endpoint_IsReadWriteAllowed()))
 174         {
 175                 Endpoint_ClearIN();
 176
 177                 uint8_t ErrorCode;
 178
 179                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 180                   return ErrorCode;
 181         }
 182
 183         Endpoint_Write_8(Data);
 184         return ENDPOINT_READYWAIT_NoError;
 185 }
 186
 187 uint8_t PRNT_Device_Flush(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo)
 188 {
 189         if (USB_DeviceState != DEVICE_STATE_Configured)
 190           return ENDPOINT_RWSTREAM_DeviceDisconnected;
 191
 192         uint8_t ErrorCode;
 193
 194         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
 195
 196         if (!(Endpoint_BytesInEndpoint()))
 197           return ENDPOINT_READYWAIT_NoError;
 198
 199         bool BankFull = !(Endpoint_IsReadWriteAllowed());
 200
 201         Endpoint_ClearIN();
 202
 203         if (BankFull)
 204         {
 205                 if ((ErrorCode = Endpoint_WaitUntilReady()) != ENDPOINT_READYWAIT_NoError)
 206                   return ErrorCode;
 207
 208                 Endpoint_ClearIN();
 209         }
 210
 211         return ENDPOINT_READYWAIT_NoError;
 212 }
 213
 214 uint16_t PRNT_Device_BytesReceived(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo)
 215 {
 216         if (USB_DeviceState != DEVICE_STATE_Configured)
 217           return 0;
 218
 219         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataOUTEndpoint.Address);
 220
 221         if (Endpoint_IsOUTReceived())
 222         {
 223                 if (!(Endpoint_BytesInEndpoint()))
 224                 {
 225                         Endpoint_ClearOUT();
 226                         return 0;
 227                 }
 228                 else
 229                 {
 230                         return Endpoint_BytesInEndpoint();
 231                 }
 232         }
 233         else
 234         {
 235                 return 0;
 236         }
 237 }
 238
 239 int16_t PRNT_Device_ReceiveByte(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo)
 240 {
 241         if (USB_DeviceState != DEVICE_STATE_Configured)
 242           return -1;
 243
 244         int16_t ReceivedByte = -1;
 245
 246         Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataOUTEndpoint.Address);
 247
 248         if (Endpoint_IsOUTReceived())
 249         {
 250                 if (Endpoint_BytesInEndpoint())
 251                   ReceivedByte = Endpoint_Read_8();
 252
 253                 if (!(Endpoint_BytesInEndpoint()))
 254                   Endpoint_ClearOUT();
 255         }
 256
 257         return ReceivedByte;
 258 }
 259
 260 #if defined(FDEV_SETUP_STREAM)
 261 void PRNT_Device_CreateStream(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo,
 262                               FILE* const Stream)
 263 {
 264         *Stream = (FILE)FDEV_SETUP_STREAM(PRNT_Device_putchar, PRNT_Device_getchar, _FDEV_SETUP_RW);
 265         fdev_set_udata(Stream, PRNTInterfaceInfo);
 266 }
 267
 268 void PRNT_Device_CreateBlockingStream(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo,
 269                                       FILE* const Stream)
 270 {
 271         *Stream = (FILE)FDEV_SETUP_STREAM(PRNT_Device_putchar, PRNT_Device_getchar_Blocking, _FDEV_SETUP_RW);
 272         fdev_set_udata(Stream, PRNTInterfaceInfo);
 273 }
 274
 275 static int PRNT_Device_putchar(char c,
 276                                FILE* Stream)
 277 {
 278         return PRNT_Device_SendByte((USB_ClassInfo_PRNT_Device_t*)fdev_get_udata(Stream), c) ? _FDEV_ERR : 0;
 279 }
 280
 281 static int PRNT_Device_getchar(FILE* Stream)
 282 {
 283         int16_t ReceivedByte = PRNT_Device_ReceiveByte((USB_ClassInfo_PRNT_Device_t*)fdev_get_udata(Stream));
 284
 285         if (ReceivedByte < 0)
 286           return _FDEV_EOF;
 287
 288         return ReceivedByte;
 289 }
 290
 291 static int PRNT_Device_getchar_Blocking(FILE* Stream)
 292 {
 293         int16_t ReceivedByte;
 294
 295         while ((ReceivedByte = PRNT_Device_ReceiveByte((USB_ClassInfo_PRNT_Device_t*)fdev_get_udata(Stream))) < 0)
 296         {
 297                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 298                   return _FDEV_EOF;
 299
 300                 PRNT_Device_USBTask((USB_ClassInfo_PRNT_Device_t*)fdev_get_udata(Stream));
 301                 USB_USBTask();
 302         }
 303
 304         return ReceivedByte;
 305 }
 306 #endif
 307
 308 void PRNT_Device_Event_Stub(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo)
 309 {
 310
 311 }
 312
 313 #endif
 314