usb_printer_vendor_ch9.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
 
#include "ra8_usb.h"
 
/* =============================================================================
 * SETUP-envelope field constants (USB 2.0 sec 9.3 "USB Device Requests")
 * =============================================================================
 */

typedef enum : uint8_t {
  k_pv_bm_dir_mask      = 0x80U, 
  k_pv_bm_dir_in        = 0x80U, 
  k_pv_bm_type_mask     = 0x60U, 
  k_pv_bm_type_standard = 0x00U, 
  k_pv_bm_type_class    = 0x20U, 
  k_pv_bm_type_vendor   = 0x40U, 
  k_pv_bm_recip_mask    = 0x1FU, 
  k_pv_bm_recip_iface   = 0x01U, 
} pv_req_field_t;

typedef enum : uint8_t {
  k_pv_std_get_descriptor    = 0x06U, 
  k_pv_std_set_address       = 0x05U, 
  k_pv_std_set_configuration = 0x09U, 
} pv_std_request_t;

typedef enum : uint8_t {
  k_pv_dt_device = 0x01U, 
  k_pv_dt_config = 0x02U, 
  k_pv_dt_string = 0x03U, 
} pv_desc_type_t;

typedef enum : uint8_t {
  k_pv_pprn_get_device_id   = 0x00U, 
  k_pv_pprn_get_port_status = 0x01U, 
  k_pv_pprn_soft_reset      = 0x02U, 
} pv_printer_request_t;
 
/* =============================================================================
 * Router action
 * =============================================================================
 */

typedef enum : uint8_t {
  k_pv_action_stall             = 0U, 
  k_pv_action_get_device_desc   = 1U, 
  k_pv_action_get_config_desc   = 2U, 
  k_pv_action_get_string_desc   = 3U, 
  k_pv_action_set_address       = 4U, 
  k_pv_action_set_configuration = 5U, 
  k_pv_action_printer_class     = 6U, 
  k_pv_action_vendor_class      = 7U, 
} pv_action_t;
 
/* =============================================================================
 * Descriptor tables (USB 2.0 sec 9.6 "Standard USB Descriptor Definitions")
 * =============================================================================
 */

static const uint8_t g_pv_device_desc[] = {
  0x12U, /* bLength = 18             */
  0x01U, /* bDescriptorType = DEVICE */
  0x00U,
  0x02U, /* bcdUSB = 2.00                */
  0x00U, /* bDeviceClass = 0 (per-iface) */
  0x00U, /* bDeviceSubClass              */
  0x00U, /* bDeviceProtocol              */
  0x40U, /* bMaxPacketSize0 = 64         */
  0x09U,
  0x12U, /* idVendor  = 0x1209 (pid.codes) */
  0x01U,
  0x00U, /* idProduct = 0x0001 */
  0x00U,
  0x01U, /* bcdDevice = 1.00       */
  0x00U, /* iManufacturer = 0      */
  0x00U, /* iProduct = 0           */
  0x00U, /* iSerialNumber = 0      */
  0x01U, /* bNumConfigurations = 1 */
};

static const uint8_t g_pv_config_desc[] = {
  /* Configuration descriptor (USB 2.0 sec 9.6.3) -- 9 bytes. */
  0x09U, /* bLength                         */
  0x02U, /* bDescriptorType = CONFIGURATION */
  0x37U,
  0x00U, /* wTotalLength = 55          */
  0x02U, /* bNumInterfaces = 2         */
  0x01U, /* bConfigurationValue = 1    */
  0x00U, /* iConfiguration = 0         */
  0x80U, /* bmAttributes = bus-powered */
  0x32U, /* bMaxPower = 100 mA         */
  /* IF0 -- Printer, bi-directional (USB Printer Class 1.1 sec 4.1). */
  0x09U, /* bLength                       */
  0x04U, /* bDescriptorType = INTERFACE   */
  0x00U, /* bInterfaceNumber = 0          */
  0x00U, /* bAlternateSetting = 0         */
  0x02U, /* bNumEndpoints = 2             */
  0x07U, /* bInterfaceClass = Printer     */
  0x01U, /* bInterfaceSubClass = Printers */
  0x02U, /* bInterfaceProtocol = bi-dir   */
  0x00U, /* iInterface = 0                */
  /* Printer bulk OUT endpoint (print data). */
  0x07U, /* bLength                    */
  0x05U, /* bDescriptorType = ENDPOINT */
  0x01U, /* bEndpointAddress = EP1 OUT */
  0x02U, /* bmAttributes = bulk        */
  0x40U,
  0x00U, /* wMaxPacketSize = 64 */
  0x00U, /* bInterval = 0       */
  /* Printer bulk IN endpoint (status). */
  0x07U, /* bLength                    */
  0x05U, /* bDescriptorType = ENDPOINT */
  0x82U, /* bEndpointAddress = EP2 IN  */
  0x02U, /* bmAttributes = bulk        */
  0x40U,
  0x00U, /* wMaxPacketSize = 64 */
  0x00U, /* bInterval = 0       */
  /* IF1 -- Vendor specific (USB-IF class 0xFF). */
  0x09U, /* bLength                     */
  0x04U, /* bDescriptorType = INTERFACE */
  0x01U, /* bInterfaceNumber = 1        */
  0x00U, /* bAlternateSetting = 0       */
  0x02U, /* bNumEndpoints = 2           */
  0xFFU, /* bInterfaceClass = Vendor    */
  0x00U, /* bInterfaceSubClass          */
  0x00U, /* bInterfaceProtocol          */
  0x00U, /* iInterface = 0              */
  /* Vendor bulk IN endpoint. */
  0x07U, /* bLength                    */
  0x05U, /* bDescriptorType = ENDPOINT */
  0x81U, /* bEndpointAddress = EP1 IN  */
  0x02U, /* bmAttributes = bulk        */
  0x40U,
  0x00U, /* wMaxPacketSize = 64 */
  0x00U, /* bInterval = 0       */
  /* Vendor bulk OUT endpoint. */
  0x07U, /* bLength                    */
  0x05U, /* bDescriptorType = ENDPOINT */
  0x02U, /* bEndpointAddress = EP2 OUT */
  0x02U, /* bmAttributes = bulk        */
  0x40U,
  0x00U, /* wMaxPacketSize = 64 */
  0x00U, /* bInterval = 0       */
};

static const uint8_t g_pv_string0_desc[] = {
  0x04U, /* bLength = 4              */
  0x03U, /* bDescriptorType = STRING */
  0x09U,
  0x04U, /* wLANGID[0] = 0x0409 (en-US) */
};
 
/* =============================================================================
 * Router helpers
 * =============================================================================
 */

static inline pv_action_t pv_route_get_descriptor(const ra8_usb_setup_t* setup)
{
  const uint8_t desc_type = (uint8_t)(setup->w_value >> 8U);
  switch (desc_type) {
    case (uint8_t)k_pv_dt_device:
      return k_pv_action_get_device_desc;
    case (uint8_t)k_pv_dt_config:
      return k_pv_action_get_config_desc;
    case (uint8_t)k_pv_dt_string:
      return k_pv_action_get_string_desc;
    default:
      return k_pv_action_stall;
  }
}

static inline pv_action_t pv_route_standard(const ra8_usb_setup_t* setup)
{
  switch (setup->b_request) {
    case (uint8_t)k_pv_std_get_descriptor:
      return pv_route_get_descriptor(setup);
    case (uint8_t)k_pv_std_set_address:
      return k_pv_action_set_address;
    case (uint8_t)k_pv_std_set_configuration:
      return k_pv_action_set_configuration;
    default:
      return k_pv_action_stall;
  }
}
 
/* =============================================================================
 * Public router + accessors
 * =============================================================================
 */

static inline pv_action_t pv_route_setup(const ra8_usb_setup_t* setup)
{
  if (setup == nullptr) {
    return k_pv_action_stall;
  }
  const uint8_t req_type = (uint8_t)(setup->bm_request_type & (uint8_t)k_pv_bm_type_mask);
  switch (req_type) {
    case (uint8_t)k_pv_bm_type_standard:
      return pv_route_standard(setup);
    case (uint8_t)k_pv_bm_type_class:
      return k_pv_action_printer_class;
    case (uint8_t)k_pv_bm_type_vendor:
      return k_pv_action_vendor_class;
    default:
      return k_pv_action_stall;
  }
}

static inline bool pv_is_printer_class_request(const ra8_usb_setup_t* setup)
{
  if (setup == nullptr) {
    return false;
  }
  const bool is_iface =
    ((setup->bm_request_type & (uint8_t)k_pv_bm_recip_mask) == (uint8_t)k_pv_bm_recip_iface);
  const bool is_known = ((setup->b_request == (uint8_t)k_pv_pprn_get_device_id) ||
                         (setup->b_request == (uint8_t)k_pv_pprn_get_port_status) ||
                         (setup->b_request == (uint8_t)k_pv_pprn_soft_reset));
  return is_iface && is_known;
}

static inline bool pv_descriptor(pv_action_t action, const uint8_t** out_desc, uint16_t* out_len)
{
  if ((out_desc == nullptr) || (out_len == nullptr)) {
    return false;
  }
  switch (action) {
    case k_pv_action_get_device_desc:
      *out_desc = g_pv_device_desc;
      *out_len  = (uint16_t)sizeof(g_pv_device_desc);
      return true;
    case k_pv_action_get_config_desc:
      *out_desc = g_pv_config_desc;
      *out_len  = (uint16_t)sizeof(g_pv_config_desc);
      return true;
    case k_pv_action_get_string_desc:
      *out_desc = g_pv_string0_desc;
      *out_len  = (uint16_t)sizeof(g_pv_string0_desc);
      return true;
    default:
      return false;
  }
}

static inline uint16_t pv_clamp_len(uint16_t available, uint16_t requested)
{
  return (available < requested) ? available : requested;
}
 
#ifdef __cplusplus
}
#endif