CARPLAY版本整理
This commit is contained in:
@ -0,0 +1,65 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* (C) Copyright 2007
|
||||
* Stelian Pop <stelian@popies.net>
|
||||
* Lead Tech Design <www.leadtechdesign.com>
|
||||
*/
|
||||
#ifndef __ASM_ARM_DMA_MAPPING_H
|
||||
#define __ASM_ARM_DMA_MAPPING_H
|
||||
|
||||
#include <linux/dma-direction.h>
|
||||
|
||||
#define dma_mapping_error(x, y) 0
|
||||
struct device;
|
||||
|
||||
static inline void *dma_alloc_coherent(struct device *dev, size_t len, dma_addr_t *handle, gfp_t flag)
|
||||
{
|
||||
(void)flag;
|
||||
//*handle = (unsigned long)memalign(ARCH_DMA_MINALIGN, len);
|
||||
*handle = (unsigned long)malloc(len + ARCH_DMA_MINALIGN);
|
||||
return (void *)*handle;
|
||||
}
|
||||
|
||||
static inline void dma_free_coherent(struct device *dev, size_t size, void *addr, dma_addr_t handle)
|
||||
{
|
||||
free(addr);
|
||||
}
|
||||
|
||||
static inline void *dmam_alloc_coherent(struct device *dev, size_t len, dma_addr_t *handle, gfp_t flag)
|
||||
{
|
||||
(void)flag;
|
||||
(void)dev;
|
||||
*handle = (dma_addr_t)malloc(len + ARCH_DMA_MINALIGN);
|
||||
return (void *)*handle;
|
||||
}
|
||||
|
||||
static inline void dmam_free_coherent(struct device *dev, size_t len, void *vaddr, dma_addr_t handle)
|
||||
{
|
||||
free(vaddr);
|
||||
}
|
||||
|
||||
|
||||
|
||||
static inline unsigned long dma_map_single(volatile void *vaddr, size_t len,
|
||||
enum dma_data_direction dir)
|
||||
{
|
||||
return (unsigned long)vaddr;
|
||||
}
|
||||
|
||||
static inline void dma_unmap_single(volatile void *vaddr, size_t len,
|
||||
unsigned long paddr)
|
||||
{
|
||||
}
|
||||
|
||||
static inline void dma_sync_single_for_device(struct device *dev,
|
||||
dma_addr_t addr, size_t size, enum dma_data_direction dir)
|
||||
{
|
||||
}
|
||||
|
||||
static inline void dma_sync_single_for_cpu(struct device *dev,
|
||||
dma_addr_t addr, size_t size, enum dma_data_direction dir)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
#endif /* __ASM_ARM_DMA_MAPPING_H */
|
||||
@ -0,0 +1,13 @@
|
||||
#ifndef _LINUX_DMA_DIRECTION_H
|
||||
#define _LINUX_DMA_DIRECTION_H
|
||||
/*
|
||||
* These definitions mirror those in pci.h, so they can be used
|
||||
* interchangeably with their PCI_ counterparts.
|
||||
*/
|
||||
enum dma_data_direction {
|
||||
DMA_BIDIRECTIONAL = 0,
|
||||
DMA_TO_DEVICE = 1,
|
||||
DMA_FROM_DEVICE = 2,
|
||||
DMA_NONE = 3,
|
||||
};
|
||||
#endif
|
||||
@ -0,0 +1,168 @@
|
||||
#ifndef _LINUX_ERRNO_H
|
||||
#define _LINUX_ERRNO_H
|
||||
|
||||
#define EPERM 1 /* Operation not permitted */
|
||||
#define ENOENT 2 /* No such file or directory */
|
||||
#define ESRCH 3 /* No such process */
|
||||
#define EINTR 4 /* Interrupted system call */
|
||||
#define EIO 5 /* I/O error */
|
||||
#define ENXIO 6 /* No such device or address */
|
||||
#define E2BIG 7 /* Argument list too long */
|
||||
#define ENOEXEC 8 /* Exec format error */
|
||||
#define EBADF 9 /* Bad file number */
|
||||
#define ECHILD 10 /* No child processes */
|
||||
#define EAGAIN 11 /* Try again */
|
||||
#define ENOMEM 12 /* Out of memory */
|
||||
#define EACCES 13 /* Permission denied */
|
||||
#define EFAULT 14 /* Bad address */
|
||||
#define ENOTBLK 15 /* Block device required */
|
||||
#define EBUSY 16 /* Device or resource busy */
|
||||
#define EEXIST 17 /* File exists */
|
||||
#define EXDEV 18 /* Cross-device link */
|
||||
#define ENODEV 19 /* No such device */
|
||||
#define ENOTDIR 20 /* Not a directory */
|
||||
#define EISDIR 21 /* Is a directory */
|
||||
#define EINVAL 22 /* Invalid argument */
|
||||
#define ENFILE 23 /* File table overflow */
|
||||
#define EMFILE 24 /* Too many open files */
|
||||
#define ENOTTY 25 /* Not a typewriter */
|
||||
#define ETXTBSY 26 /* Text file busy */
|
||||
#define EFBIG 27 /* File too large */
|
||||
#define ENOSPC 28 /* No space left on device */
|
||||
#define ESPIPE 29 /* Illegal seek */
|
||||
#define EROFS 30 /* Read-only file system */
|
||||
#define EMLINK 31 /* Too many links */
|
||||
#define EPIPE 32 /* Broken pipe */
|
||||
#define EDOM 33 /* Math argument out of domain of func */
|
||||
#define ERANGE 34 /* Math result not representable */
|
||||
|
||||
#define EDEADLK 35 /* Resource deadlock would occur */
|
||||
#define ENAMETOOLONG 36 /* File name too long */
|
||||
#define ENOLCK 37 /* No record locks available */
|
||||
|
||||
#define ENOSYS 38 /* Invalid system call number */
|
||||
|
||||
#define ENOTEMPTY 39 /* Directory not empty */
|
||||
#define ELOOP 40 /* Too many symbolic links encountered */
|
||||
#define EWOULDBLOCK EAGAIN /* Operation would block */
|
||||
#define ENOMSG 42 /* No message of desired type */
|
||||
#define EIDRM 43 /* Identifier removed */
|
||||
#define ECHRNG 44 /* Channel number out of range */
|
||||
#define EL2NSYNC 45 /* Level 2 not synchronized */
|
||||
#define EL3HLT 46 /* Level 3 halted */
|
||||
#define EL3RST 47 /* Level 3 reset */
|
||||
#define ELNRNG 48 /* Link number out of range */
|
||||
#define EUNATCH 49 /* Protocol driver not attached */
|
||||
#define ENOCSI 50 /* No CSI structure available */
|
||||
#define EL2HLT 51 /* Level 2 halted */
|
||||
#define EBADE 52 /* Invalid exchange */
|
||||
#define EBADR 53 /* Invalid request descriptor */
|
||||
#define EXFULL 54 /* Exchange full */
|
||||
#define ENOANO 55 /* No anode */
|
||||
#define EBADRQC 56 /* Invalid request code */
|
||||
#define EBADSLT 57 /* Invalid slot */
|
||||
|
||||
#define EDEADLOCK EDEADLK
|
||||
|
||||
#define EBFONT 59 /* Bad font file format */
|
||||
#define ENOSTR 60 /* Device not a stream */
|
||||
#define ENODATA 61 /* No data available */
|
||||
#define ETIME 62 /* Timer expired */
|
||||
#define ENOSR 63 /* Out of streams resources */
|
||||
#define ENONET 64 /* Machine is not on the network */
|
||||
#define ENOPKG 65 /* Package not installed */
|
||||
#define EREMOTE 66 /* Object is remote */
|
||||
#define ENOLINK 67 /* Link has been severed */
|
||||
#define EADV 68 /* Advertise error */
|
||||
#define ESRMNT 69 /* Srmount error */
|
||||
#define ECOMM 70 /* Communication error on send */
|
||||
#define EPROTO 71 /* Protocol error */
|
||||
#define EMULTIHOP 72 /* Multihop attempted */
|
||||
#define EDOTDOT 73 /* RFS specific error */
|
||||
#define EBADMSG 74 /* Not a data message */
|
||||
#define EOVERFLOW 75 /* Value too large for defined data type */
|
||||
#define ENOTUNIQ 76 /* Name not unique on network */
|
||||
#define EBADFD 77 /* File descriptor in bad state */
|
||||
#define EREMCHG 78 /* Remote address changed */
|
||||
#define ELIBACC 79 /* Can not access a needed shared library */
|
||||
#define ELIBBAD 80 /* Accessing a corrupted shared library */
|
||||
#define ELIBSCN 81 /* .lib section in a.out corrupted */
|
||||
#define ELIBMAX 82 /* Attempting to link in too many shared libraries */
|
||||
#define ELIBEXEC 83 /* Cannot exec a shared library directly */
|
||||
#define EILSEQ 84 /* Illegal byte sequence */
|
||||
#define ERESTART 85 /* Interrupted system call should be restarted */
|
||||
#define ESTRPIPE 86 /* Streams pipe error */
|
||||
#define EUSERS 87 /* Too many users */
|
||||
#define ENOTSOCK 88 /* Socket operation on non-socket */
|
||||
#define EDESTADDRREQ 89 /* Destination address required */
|
||||
#define EMSGSIZE 90 /* Message too long */
|
||||
#define EPROTOTYPE 91 /* Protocol wrong type for socket */
|
||||
#define ENOPROTOOPT 92 /* Protocol not available */
|
||||
#define EPROTONOSUPPORT 93 /* Protocol not supported */
|
||||
#define ESOCKTNOSUPPORT 94 /* Socket type not supported */
|
||||
#define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */
|
||||
#define EPFNOSUPPORT 96 /* Protocol family not supported */
|
||||
#define EAFNOSUPPORT 97 /* Address family not supported by protocol */
|
||||
#define EADDRINUSE 98 /* Address already in use */
|
||||
#define EADDRNOTAVAIL 99 /* Cannot assign requested address */
|
||||
#define ENETDOWN 100 /* Network is down */
|
||||
#define ENETUNREACH 101 /* Network is unreachable */
|
||||
#define ENETRESET 102 /* Network dropped connection because of reset */
|
||||
#define ECONNABORTED 103 /* Software caused connection abort */
|
||||
#define ECONNRESET 104 /* Connection reset by peer */
|
||||
#define ENOBUFS 105 /* No buffer space available */
|
||||
#define EISCONN 106 /* Transport endpoint is already connected */
|
||||
#define ENOTCONN 107 /* Transport endpoint is not connected */
|
||||
#define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */
|
||||
#define ETOOMANYREFS 109 /* Too many references: cannot splice */
|
||||
#define ETIMEDOUT 110 /* Connection timed out */
|
||||
#define ECONNREFUSED 111 /* Connection refused */
|
||||
#define EHOSTDOWN 112 /* Host is down */
|
||||
#define EHOSTUNREACH 113 /* No route to host */
|
||||
#define EALREADY 114 /* Operation already in progress */
|
||||
#define EINPROGRESS 115 /* Operation now in progress */
|
||||
#define ESTALE 116 /* Stale file handle */
|
||||
#define EUCLEAN 117 /* Structure needs cleaning */
|
||||
#define ENOTNAM 118 /* Not a XENIX named type file */
|
||||
#define ENAVAIL 119 /* No XENIX semaphores available */
|
||||
#define EISNAM 120 /* Is a named type file */
|
||||
#define EREMOTEIO 121 /* Remote I/O error */
|
||||
#define EDQUOT 122 /* Quota exceeded */
|
||||
|
||||
#define ENOMEDIUM 123 /* No medium found */
|
||||
#define EMEDIUMTYPE 124 /* Wrong medium type */
|
||||
#define ECANCELED 125 /* Operation Canceled */
|
||||
#define ENOKEY 126 /* Required key not available */
|
||||
#define EKEYEXPIRED 127 /* Key has expired */
|
||||
#define EKEYREVOKED 128 /* Key has been revoked */
|
||||
#define EKEYREJECTED 129 /* Key was rejected by service */
|
||||
|
||||
/* for robust mutexes */
|
||||
#define EOWNERDEAD 130 /* Owner died */
|
||||
#define ENOTRECOVERABLE 131 /* State not recoverable */
|
||||
|
||||
#define ERFKILL 132 /* Operation not possible due to RF-kill */
|
||||
|
||||
#define EHWPOISON 133 /* Memory page has hardware error */
|
||||
|
||||
#define ERESTARTSYS 512
|
||||
#define ERESTARTNOINTR 513
|
||||
#define ERESTARTNOHAND 514 /* restart if no handler.. */
|
||||
#define ENOIOCTLCMD 515 /* No ioctl command */
|
||||
#define ERESTART_RESTARTBLOCK 516 /* restart by calling sys_restart_syscall */
|
||||
#define EPROBE_DEFER 517 /* Driver requests probe retry */
|
||||
#define EOPENSTALE 518 /* open found a stale dentry */
|
||||
|
||||
/* Defined for the NFSv3 protocol */
|
||||
#define EBADHANDLE 521 /* Illegal NFS file handle */
|
||||
#define ENOTSYNC 522 /* Update synchronization mismatch */
|
||||
#define EBADCOOKIE 523 /* Cookie is stale */
|
||||
#define ENOTSUPP 524 /* Operation is not supported */
|
||||
#define ETOOSMALL 525 /* Buffer or request is too small */
|
||||
#define ESERVERFAULT 526 /* An untranslatable error occurred */
|
||||
#define EBADTYPE 527 /* Type not supported by server */
|
||||
#define EJUKEBOX 528 /* Request initiated, but will not complete before timeout */
|
||||
#define EIOCBQUEUED 529 /* iocb queued, will get completion event */
|
||||
#define ERECALLCONFLICT 530 /* conflict with recalled state */
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,454 @@
|
||||
/*
|
||||
* USB Communications Device Class (CDC) definitions
|
||||
*
|
||||
* CDC says how to talk to lots of different types of network adapters,
|
||||
* notably ethernet adapters and various modems. It's used mostly with
|
||||
* firmware based USB peripherals.
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_USB_CDC_H
|
||||
#define __LINUX_USB_CDC_H
|
||||
#include "usb_os_adapter.h"
|
||||
#define USB_CDC_SUBCLASS_ACM 0x02
|
||||
#define USB_CDC_SUBCLASS_ETHERNET 0x06
|
||||
#define USB_CDC_SUBCLASS_WHCM 0x08
|
||||
#define USB_CDC_SUBCLASS_DMM 0x09
|
||||
#define USB_CDC_SUBCLASS_MDLM 0x0a
|
||||
#define USB_CDC_SUBCLASS_OBEX 0x0b
|
||||
#define USB_CDC_SUBCLASS_EEM 0x0c
|
||||
#define USB_CDC_SUBCLASS_NCM 0x0d
|
||||
|
||||
#define USB_CDC_PROTO_NONE 0
|
||||
|
||||
#define USB_CDC_ACM_PROTO_AT_V25TER 1
|
||||
#define USB_CDC_ACM_PROTO_AT_PCCA101 2
|
||||
#define USB_CDC_ACM_PROTO_AT_PCCA101_WAKE 3
|
||||
#define USB_CDC_ACM_PROTO_AT_GSM 4
|
||||
#define USB_CDC_ACM_PROTO_AT_3G 5
|
||||
#define USB_CDC_ACM_PROTO_AT_CDMA 6
|
||||
#define USB_CDC_ACM_PROTO_VENDOR 0xff
|
||||
|
||||
#define USB_CDC_PROTO_EEM 7
|
||||
|
||||
#define USB_CDC_NCM_PROTO_NTB 1
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Class-Specific descriptors ... there are a couple dozen of them
|
||||
*/
|
||||
|
||||
#define USB_CDC_HEADER_TYPE 0x00 /* header_desc */
|
||||
#define USB_CDC_CALL_MANAGEMENT_TYPE 0x01 /* call_mgmt_descriptor */
|
||||
#define USB_CDC_ACM_TYPE 0x02 /* acm_descriptor */
|
||||
#define USB_CDC_UNION_TYPE 0x06 /* union_desc */
|
||||
#define USB_CDC_COUNTRY_TYPE 0x07
|
||||
#define USB_CDC_NETWORK_TERMINAL_TYPE 0x0a /* network_terminal_desc */
|
||||
#define USB_CDC_ETHERNET_TYPE 0x0f /* ether_desc */
|
||||
#define USB_CDC_WHCM_TYPE 0x11
|
||||
#define USB_CDC_MDLM_TYPE 0x12 /* mdlm_desc */
|
||||
#define USB_CDC_MDLM_DETAIL_TYPE 0x13 /* mdlm_detail_desc */
|
||||
#define USB_CDC_DMM_TYPE 0x14
|
||||
#define USB_CDC_OBEX_TYPE 0x15
|
||||
#define USB_CDC_NCM_TYPE 0x1a
|
||||
|
||||
/* "Header Functional Descriptor" from CDC spec 5.2.3.1 */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_header_desc {
|
||||
__u8 bLength;
|
||||
__u8 bDescriptorType;
|
||||
__u8 bDescriptorSubType;
|
||||
|
||||
__le16 bcdCDC;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
#define USB_CDC_CALL_MGMT_CAP_CALL_MGMT 0x01
|
||||
#define USB_CDC_CALL_MGMT_CAP_DATA_INTF 0x02
|
||||
|
||||
/* "Call Management Descriptor" from CDC spec 5.2.3.2 */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_call_mgmt_descriptor {
|
||||
__u8 bLength;
|
||||
__u8 bDescriptorType;
|
||||
__u8 bDescriptorSubType;
|
||||
|
||||
__u8 bmCapabilities;
|
||||
|
||||
__u8 bDataInterface;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* "Abstract Control Management Descriptor" from CDC spec 5.2.3.3 */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_acm_descriptor {
|
||||
__u8 bLength;
|
||||
__u8 bDescriptorType;
|
||||
__u8 bDescriptorSubType;
|
||||
|
||||
__u8 bmCapabilities;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* capabilities from 5.2.3.3 */
|
||||
|
||||
#define USB_CDC_COMM_FEATURE 0x01
|
||||
#define USB_CDC_CAP_LINE 0x02
|
||||
#define USB_CDC_CAP_BRK 0x04
|
||||
#define USB_CDC_CAP_NOTIFY 0x08
|
||||
|
||||
/* "Union Functional Descriptor" from CDC spec 5.2.3.8 */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_union_desc {
|
||||
__u8 bLength;
|
||||
__u8 bDescriptorType;
|
||||
__u8 bDescriptorSubType;
|
||||
|
||||
__u8 bMasterInterface0;
|
||||
__u8 bSlaveInterface0;
|
||||
/* ... and there could be other slave interfaces */
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* "Country Selection Functional Descriptor" from CDC spec 5.2.3.9 */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_country_functional_desc {
|
||||
__u8 bLength;
|
||||
__u8 bDescriptorType;
|
||||
__u8 bDescriptorSubType;
|
||||
|
||||
__u8 iCountryCodeRelDate;
|
||||
__le16 wCountyCode0;
|
||||
/* ... and there can be a lot of country codes */
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* "Network Channel Terminal Functional Descriptor" from CDC spec 5.2.3.11 */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_network_terminal_desc {
|
||||
__u8 bLength;
|
||||
__u8 bDescriptorType;
|
||||
__u8 bDescriptorSubType;
|
||||
|
||||
__u8 bEntityId;
|
||||
__u8 iName;
|
||||
__u8 bChannelIndex;
|
||||
__u8 bPhysicalInterface;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* "Ethernet Networking Functional Descriptor" from CDC spec 5.2.3.16 */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_ether_desc {
|
||||
__u8 bLength;
|
||||
__u8 bDescriptorType;
|
||||
__u8 bDescriptorSubType;
|
||||
|
||||
__u8 iMACAddress;
|
||||
__le32 bmEthernetStatistics;
|
||||
__le16 wMaxSegmentSize;
|
||||
__le16 wNumberMCFilters;
|
||||
__u8 bNumberPowerFilters;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* "Telephone Control Model Functional Descriptor" from CDC WMC spec 6.3..3 */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_dmm_desc {
|
||||
__u8 bFunctionLength;
|
||||
__u8 bDescriptorType;
|
||||
__u8 bDescriptorSubtype;
|
||||
__u16 bcdVersion;
|
||||
__le16 wMaxCommand;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* "MDLM Functional Descriptor" from CDC WMC spec 6.7.2.3 */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_mdlm_desc {
|
||||
__u8 bLength;
|
||||
__u8 bDescriptorType;
|
||||
__u8 bDescriptorSubType;
|
||||
|
||||
__le16 bcdVersion;
|
||||
__u8 bGUID[16];
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* "MDLM Detail Functional Descriptor" from CDC WMC spec 6.7.2.4 */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_mdlm_detail_desc {
|
||||
__u8 bLength;
|
||||
__u8 bDescriptorType;
|
||||
__u8 bDescriptorSubType;
|
||||
|
||||
/* type is associated with mdlm_desc.bGUID */
|
||||
__u8 bGuidDescriptorType;
|
||||
__u8 bDetailData[0];
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* "OBEX Control Model Functional Descriptor" */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_obex_desc {
|
||||
__u8 bLength;
|
||||
__u8 bDescriptorType;
|
||||
__u8 bDescriptorSubType;
|
||||
|
||||
__le16 bcdVersion;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* "NCM Control Model Functional Descriptor" */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_ncm_desc {
|
||||
__u8 bLength;
|
||||
__u8 bDescriptorType;
|
||||
__u8 bDescriptorSubType;
|
||||
|
||||
__le16 bcdNcmVersion;
|
||||
__u8 bmNetworkCapabilities;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Class-Specific Control Requests (6.2)
|
||||
*
|
||||
* section 3.6.2.1 table 4 has the ACM profile, for modems.
|
||||
* section 3.8.2 table 10 has the ethernet profile.
|
||||
*
|
||||
* Microsoft's RNDIS stack for Ethernet is a vendor-specific CDC ACM variant,
|
||||
* heavily dependent on the encapsulated (proprietary) command mechanism.
|
||||
*/
|
||||
|
||||
#define USB_CDC_SEND_ENCAPSULATED_COMMAND 0x00
|
||||
#define USB_CDC_GET_ENCAPSULATED_RESPONSE 0x01
|
||||
#define USB_CDC_REQ_SET_LINE_CODING 0x20
|
||||
#define USB_CDC_REQ_GET_LINE_CODING 0x21
|
||||
#define USB_CDC_REQ_SET_CONTROL_LINE_STATE 0x22
|
||||
#define USB_CDC_REQ_SEND_BREAK 0x23
|
||||
#define USB_CDC_SET_ETHERNET_MULTICAST_FILTERS 0x40
|
||||
#define USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER 0x41
|
||||
#define USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER 0x42
|
||||
#define USB_CDC_SET_ETHERNET_PACKET_FILTER 0x43
|
||||
#define USB_CDC_GET_ETHERNET_STATISTIC 0x44
|
||||
#define USB_CDC_GET_NTB_PARAMETERS 0x80
|
||||
#define USB_CDC_GET_NET_ADDRESS 0x81
|
||||
#define USB_CDC_SET_NET_ADDRESS 0x82
|
||||
#define USB_CDC_GET_NTB_FORMAT 0x83
|
||||
#define USB_CDC_SET_NTB_FORMAT 0x84
|
||||
#define USB_CDC_GET_NTB_INPUT_SIZE 0x85
|
||||
#define USB_CDC_SET_NTB_INPUT_SIZE 0x86
|
||||
#define USB_CDC_GET_MAX_DATAGRAM_SIZE 0x87
|
||||
#define USB_CDC_SET_MAX_DATAGRAM_SIZE 0x88
|
||||
#define USB_CDC_GET_CRC_MODE 0x89
|
||||
#define USB_CDC_SET_CRC_MODE 0x8a
|
||||
|
||||
/* Line Coding Structure from CDC spec 6.2.13 */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_line_coding {
|
||||
__le32 dwDTERate;
|
||||
__u8 bCharFormat;
|
||||
#define USB_CDC_1_STOP_BITS 0
|
||||
#define USB_CDC_1_5_STOP_BITS 1
|
||||
#define USB_CDC_2_STOP_BITS 2
|
||||
|
||||
__u8 bParityType;
|
||||
#define USB_CDC_NO_PARITY 0
|
||||
#define USB_CDC_ODD_PARITY 1
|
||||
#define USB_CDC_EVEN_PARITY 2
|
||||
#define USB_CDC_MARK_PARITY 3
|
||||
#define USB_CDC_SPACE_PARITY 4
|
||||
|
||||
__u8 bDataBits;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* table 62; bits in multicast filter */
|
||||
#define USB_CDC_PACKET_TYPE_PROMISCUOUS (1 << 0)
|
||||
#define USB_CDC_PACKET_TYPE_ALL_MULTICAST (1 << 1) /* no filter */
|
||||
#define USB_CDC_PACKET_TYPE_DIRECTED (1 << 2)
|
||||
#define USB_CDC_PACKET_TYPE_BROADCAST (1 << 3)
|
||||
#define USB_CDC_PACKET_TYPE_MULTICAST (1 << 4) /* filtered */
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Class-Specific Notifications (6.3) sent by interrupt transfers
|
||||
*
|
||||
* section 3.8.2 table 11 of the CDC spec lists Ethernet notifications
|
||||
* section 3.6.2.1 table 5 specifies ACM notifications, accepted by RNDIS
|
||||
* RNDIS also defines its own bit-incompatible notifications
|
||||
*/
|
||||
|
||||
#define USB_CDC_NOTIFY_NETWORK_CONNECTION 0x00
|
||||
#define USB_CDC_NOTIFY_RESPONSE_AVAILABLE 0x01
|
||||
#define USB_CDC_NOTIFY_SERIAL_STATE 0x20
|
||||
#define USB_CDC_NOTIFY_SPEED_CHANGE 0x2a
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_notification {
|
||||
__u8 bmRequestType;
|
||||
__u8 bNotificationType;
|
||||
__le16 wValue;
|
||||
__le16 wIndex;
|
||||
__le16 wLength;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_speed_change {
|
||||
__le32 DLBitRRate; /* contains the downlink bit rate (IN pipe) */
|
||||
__le32 ULBitRate; /* contains the uplink bit rate (OUT pipe) */
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Class Specific structures and constants
|
||||
*
|
||||
* CDC NCM NTB parameters structure, CDC NCM subclass 6.2.1
|
||||
*
|
||||
*/
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_ncm_ntb_parameters {
|
||||
__le16 wLength;
|
||||
__le16 bmNtbFormatsSupported;
|
||||
__le32 dwNtbInMaxSize;
|
||||
__le16 wNdpInDivisor;
|
||||
__le16 wNdpInPayloadRemainder;
|
||||
__le16 wNdpInAlignment;
|
||||
__le16 wPadding1;
|
||||
__le32 dwNtbOutMaxSize;
|
||||
__le16 wNdpOutDivisor;
|
||||
__le16 wNdpOutPayloadRemainder;
|
||||
__le16 wNdpOutAlignment;
|
||||
__le16 wNtbOutMaxDatagrams;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/*
|
||||
* CDC NCM transfer headers, CDC NCM subclass 3.2
|
||||
*/
|
||||
|
||||
#define USB_CDC_NCM_NTH16_SIGN 0x484D434E /* NCMH */
|
||||
#define USB_CDC_NCM_NTH32_SIGN 0x686D636E /* ncmh */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_ncm_nth16 {
|
||||
__le32 dwSignature;
|
||||
__le16 wHeaderLength;
|
||||
__le16 wSequence;
|
||||
__le16 wBlockLength;
|
||||
__le16 wNdpIndex;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_ncm_nth32 {
|
||||
__le32 dwSignature;
|
||||
__le16 wHeaderLength;
|
||||
__le16 wSequence;
|
||||
__le32 dwBlockLength;
|
||||
__le32 dwNdpIndex;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/*
|
||||
* CDC NCM datagram pointers, CDC NCM subclass 3.3
|
||||
*/
|
||||
|
||||
#define USB_CDC_NCM_NDP16_CRC_SIGN 0x314D434E /* NCM1 */
|
||||
#define USB_CDC_NCM_NDP16_NOCRC_SIGN 0x304D434E /* NCM0 */
|
||||
#define USB_CDC_NCM_NDP32_CRC_SIGN 0x316D636E /* ncm1 */
|
||||
#define USB_CDC_NCM_NDP32_NOCRC_SIGN 0x306D636E /* ncm0 */
|
||||
|
||||
/* 16-bit NCM Datagram Pointer Entry */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_ncm_dpe16 {
|
||||
__le16 wDatagramIndex;
|
||||
__le16 wDatagramLength;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* 16-bit NCM Datagram Pointer Table */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_ncm_ndp16 {
|
||||
__le32 dwSignature;
|
||||
__le16 wLength;
|
||||
__le16 wNextNdpIndex;
|
||||
struct usb_cdc_ncm_dpe16 dpe16[0];
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* 32-bit NCM Datagram Pointer Entry */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_ncm_dpe32 {
|
||||
__le32 dwDatagramIndex;
|
||||
__le32 dwDatagramLength;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* 32-bit NCM Datagram Pointer Table */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_ncm_ndp32 {
|
||||
__le32 dwSignature;
|
||||
__le16 wLength;
|
||||
__le16 wReserved6;
|
||||
__le32 dwNextNdpIndex;
|
||||
__le32 dwReserved12;
|
||||
struct usb_cdc_ncm_dpe32 dpe32[0];
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* CDC NCM subclass 3.2.1 and 3.2.2 */
|
||||
#define USB_CDC_NCM_NDP16_INDEX_MIN 0x000C
|
||||
#define USB_CDC_NCM_NDP32_INDEX_MIN 0x0010
|
||||
|
||||
/* CDC NCM subclass 3.3.3 Datagram Formatting */
|
||||
#define USB_CDC_NCM_DATAGRAM_FORMAT_CRC 0x30
|
||||
#define USB_CDC_NCM_DATAGRAM_FORMAT_NOCRC 0X31
|
||||
|
||||
/* CDC NCM subclass 4.2 NCM Communications Interface Protocol Code */
|
||||
#define USB_CDC_NCM_PROTO_CODE_NO_ENCAP_COMMANDS 0x00
|
||||
#define USB_CDC_NCM_PROTO_CODE_EXTERN_PROTO 0xFE
|
||||
|
||||
/* CDC NCM subclass 5.2.1 NCM Functional Descriptor, bmNetworkCapabilities */
|
||||
#define USB_CDC_NCM_NCAP_ETH_FILTER (1 << 0)
|
||||
#define USB_CDC_NCM_NCAP_NET_ADDRESS (1 << 1)
|
||||
#define USB_CDC_NCM_NCAP_ENCAP_COMMAND (1 << 2)
|
||||
#define USB_CDC_NCM_NCAP_MAX_DATAGRAM_SIZE (1 << 3)
|
||||
#define USB_CDC_NCM_NCAP_CRC_MODE (1 << 4)
|
||||
#define USB_CDC_NCM_NCAP_NTB_INPUT_SIZE (1 << 5)
|
||||
|
||||
/* CDC NCM subclass Table 6-3: NTB Parameter Structure */
|
||||
#define USB_CDC_NCM_NTB16_SUPPORTED (1 << 0)
|
||||
#define USB_CDC_NCM_NTB32_SUPPORTED (1 << 1)
|
||||
|
||||
/* CDC NCM subclass Table 6-3: NTB Parameter Structure */
|
||||
#define USB_CDC_NCM_NDP_ALIGN_MIN_SIZE 0x04
|
||||
#define USB_CDC_NCM_NTB_MAX_LENGTH 0x1C
|
||||
|
||||
/* CDC NCM subclass 6.2.5 SetNtbFormat */
|
||||
#define USB_CDC_NCM_NTB16_FORMAT 0x00
|
||||
#define USB_CDC_NCM_NTB32_FORMAT 0x01
|
||||
|
||||
/* CDC NCM subclass 6.2.7 SetNtbInputSize */
|
||||
#define USB_CDC_NCM_NTB_MIN_IN_SIZE 2048
|
||||
#define USB_CDC_NCM_NTB_MIN_OUT_SIZE 2048
|
||||
|
||||
/* NTB Input Size Structure */
|
||||
#include "pack_struct_start.h"
|
||||
struct usb_cdc_ncm_ndp_input_size {
|
||||
__le32 dwNtbInMaxSize;
|
||||
__le16 wNtbInMaxDatagrams;
|
||||
__le16 wReserved;
|
||||
};
|
||||
#include "pack_struct_end.h"
|
||||
|
||||
/* CDC NCM subclass 6.2.11 SetCrcMode */
|
||||
#define USB_CDC_NCM_CRC_NOT_APPENDED 0x00
|
||||
#define USB_CDC_NCM_CRC_APPENDED 0x01
|
||||
|
||||
#endif /* __LINUX_USB_CDC_H */
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,352 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* composite.h -- framework for usb gadgets which are composite devices
|
||||
*
|
||||
* Copyright (C) 2006-2008 David Brownell
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_USB_COMPOSITE_H
|
||||
#define __LINUX_USB_COMPOSITE_H
|
||||
|
||||
/*
|
||||
* This framework is an optional layer on top of the USB Gadget interface,
|
||||
* making it easier to build (a) Composite devices, supporting multiple
|
||||
* functions within any single configuration, and (b) Multi-configuration
|
||||
* devices, also supporting multiple functions but without necessarily
|
||||
* having more than one function per configuration.
|
||||
*
|
||||
* Example: a device with a single configuration supporting both network
|
||||
* link and mass storage functions is a composite device. Those functions
|
||||
* might alternatively be packaged in individual configurations, but in
|
||||
* the composite model the host can use both functions at the same time.
|
||||
*/
|
||||
|
||||
|
||||
#include <linux/usb/ch9.h>
|
||||
#include <linux/usb/gadget.h>
|
||||
//#include <usb/lin_gadget_compat.h>
|
||||
|
||||
/*
|
||||
* USB function drivers should return USB_GADGET_DELAYED_STATUS if they
|
||||
* wish to delay the data/status stages of the control transfer till they
|
||||
* are ready. The control transfer will then be kept from completing till
|
||||
* all the function drivers that requested for USB_GADGET_DELAYED_STAUS
|
||||
* invoke usb_composite_setup_continue().
|
||||
*/
|
||||
#define USB_GADGET_DELAYED_STATUS 0x7fff /* Impossibly large value */
|
||||
|
||||
struct usb_configuration;
|
||||
|
||||
/**
|
||||
* struct usb_function - describes one function of a configuration
|
||||
* @name: For diagnostics, identifies the function.
|
||||
* @strings: tables of strings, keyed by identifiers assigned during bind()
|
||||
* and by language IDs provided in control requests
|
||||
* @descriptors: Table of full (or low) speed descriptors, using interface and
|
||||
* string identifiers assigned during @bind(). If this pointer is null,
|
||||
* the function will not be available at full speed (or at low speed).
|
||||
* @hs_descriptors: Table of high speed descriptors, using interface and
|
||||
* string identifiers assigned during @bind(). If this pointer is null,
|
||||
* the function will not be available at high speed.
|
||||
* @config: assigned when @usb_add_function() is called; this is the
|
||||
* configuration with which this function is associated.
|
||||
* @bind: Before the gadget can register, all of its functions bind() to the
|
||||
* available resources including string and interface identifiers used
|
||||
* in interface or class descriptors; endpoints; I/O buffers; and so on.
|
||||
* @unbind: Reverses @bind; called as a side effect of unregistering the
|
||||
* driver which added this function.
|
||||
* @set_alt: (REQUIRED) Reconfigures altsettings; function drivers may
|
||||
* initialize usb_ep.driver data at this time (when it is used).
|
||||
* Note that setting an interface to its current altsetting resets
|
||||
* interface state, and that all interfaces have a disabled state.
|
||||
* @get_alt: Returns the active altsetting. If this is not provided,
|
||||
* then only altsetting zero is supported.
|
||||
* @disable: (REQUIRED) Indicates the function should be disabled. Reasons
|
||||
* include host resetting or reconfiguring the gadget, and disconnection.
|
||||
* @setup: Used for interface-specific control requests.
|
||||
* @suspend: Notifies functions when the host stops sending USB traffic.
|
||||
* @resume: Notifies functions when the host restarts USB traffic.
|
||||
*
|
||||
* A single USB function uses one or more interfaces, and should in most
|
||||
* cases support operation at both full and high speeds. Each function is
|
||||
* associated by @usb_add_function() with a one configuration; that function
|
||||
* causes @bind() to be called so resources can be allocated as part of
|
||||
* setting up a gadget driver. Those resources include endpoints, which
|
||||
* should be allocated using @usb_ep_autoconfig().
|
||||
*
|
||||
* To support dual speed operation, a function driver provides descriptors
|
||||
* for both high and full speed operation. Except in rare cases that don't
|
||||
* involve bulk endpoints, each speed needs different endpoint descriptors.
|
||||
*
|
||||
* Function drivers choose their own strategies for managing instance data.
|
||||
* The simplest strategy just declares it "static', which means the function
|
||||
* can only be activated once. If the function needs to be exposed in more
|
||||
* than one configuration at a given speed, it needs to support multiple
|
||||
* usb_function structures (one for each configuration).
|
||||
*
|
||||
* A more complex strategy might encapsulate a @usb_function structure inside
|
||||
* a driver-specific instance structure to allows multiple activations. An
|
||||
* example of multiple activations might be a CDC ACM function that supports
|
||||
* two or more distinct instances within the same configuration, providing
|
||||
* several independent logical data links to a USB host.
|
||||
*/
|
||||
struct usb_function {
|
||||
const char *name;
|
||||
struct usb_gadget_strings **strings;
|
||||
struct usb_descriptor_header **descriptors;
|
||||
struct usb_descriptor_header **hs_descriptors;
|
||||
|
||||
struct usb_configuration *config;
|
||||
|
||||
/* REVISIT: bind() functions can be marked __init, which
|
||||
* makes trouble for section mismatch analysis. See if
|
||||
* we can't restructure things to avoid mismatching.
|
||||
* Related: unbind() may kfree() but bind() won't...
|
||||
*/
|
||||
|
||||
/* configuration management: bind/unbind */
|
||||
int (*bind)(struct usb_configuration *,
|
||||
struct usb_function *);
|
||||
void (*unbind)(struct usb_configuration *,
|
||||
struct usb_function *);
|
||||
|
||||
/* runtime state management */
|
||||
int (*set_alt)(struct usb_function *,
|
||||
unsigned interface, unsigned alt);
|
||||
int (*get_alt)(struct usb_function *,
|
||||
unsigned interface);
|
||||
void (*disable)(struct usb_function *);
|
||||
int (*setup)(struct usb_function *,
|
||||
const struct usb_ctrlrequest *);
|
||||
void (*suspend)(struct usb_function *);
|
||||
void (*resume)(struct usb_function *);
|
||||
|
||||
/* private: */
|
||||
/* internals */
|
||||
ListItem_t list;
|
||||
void* powner;
|
||||
DECLARE_BITMAP(endpoints, 32);
|
||||
};
|
||||
|
||||
int usb_add_function(struct usb_configuration *, struct usb_function *);
|
||||
|
||||
int usb_function_deactivate(struct usb_function *);
|
||||
int usb_function_activate(struct usb_function *);
|
||||
|
||||
int usb_interface_id(struct usb_configuration *, struct usb_function *);
|
||||
|
||||
/**
|
||||
* ep_choose - select descriptor endpoint at current device speed
|
||||
* @g: gadget, connected and running at some speed
|
||||
* @hs: descriptor to use for high speed operation
|
||||
* @fs: descriptor to use for full or low speed operation
|
||||
*/
|
||||
static inline struct usb_endpoint_descriptor *
|
||||
ep_choose(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
|
||||
struct usb_endpoint_descriptor *fs)
|
||||
{
|
||||
if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
|
||||
return hs;
|
||||
return fs;
|
||||
}
|
||||
|
||||
#define MAX_CONFIG_INTERFACES 16 /* arbitrary; max 255 */
|
||||
|
||||
/**
|
||||
* struct usb_configuration - represents one gadget configuration
|
||||
* @label: For diagnostics, describes the configuration.
|
||||
* @strings: Tables of strings, keyed by identifiers assigned during @bind()
|
||||
* and by language IDs provided in control requests.
|
||||
* @descriptors: Table of descriptors preceding all function descriptors.
|
||||
* Examples include OTG and vendor-specific descriptors.
|
||||
* @bind: Called from @usb_add_config() to allocate resources unique to this
|
||||
* configuration and to call @usb_add_function() for each function used.
|
||||
* @unbind: Reverses @bind; called as a side effect of unregistering the
|
||||
* driver which added this configuration.
|
||||
* @setup: Used to delegate control requests that aren't handled by standard
|
||||
* device infrastructure or directed at a specific interface.
|
||||
* @bConfigurationValue: Copied into configuration descriptor.
|
||||
* @iConfiguration: Copied into configuration descriptor.
|
||||
* @bmAttributes: Copied into configuration descriptor.
|
||||
* @bMaxPower: Copied into configuration descriptor.
|
||||
* @cdev: assigned by @usb_add_config() before calling @bind(); this is
|
||||
* the device associated with this configuration.
|
||||
*
|
||||
* Configurations are building blocks for gadget drivers structured around
|
||||
* function drivers. Simple USB gadgets require only one function and one
|
||||
* configuration, and handle dual-speed hardware by always providing the same
|
||||
* functionality. Slightly more complex gadgets may have more than one
|
||||
* single-function configuration at a given speed; or have configurations
|
||||
* that only work at one speed.
|
||||
*
|
||||
* Composite devices are, by definition, ones with configurations which
|
||||
* include more than one function.
|
||||
*
|
||||
* The lifecycle of a usb_configuration includes allocation, initialization
|
||||
* of the fields described above, and calling @usb_add_config() to set up
|
||||
* internal data and bind it to a specific device. The configuration's
|
||||
* @bind() method is then used to initialize all the functions and then
|
||||
* call @usb_add_function() for them.
|
||||
*
|
||||
* Those functions would normally be independant of each other, but that's
|
||||
* not mandatory. CDC WMC devices are an example where functions often
|
||||
* depend on other functions, with some functions subsidiary to others.
|
||||
* Such interdependency may be managed in any way, so long as all of the
|
||||
* descriptors complete by the time the composite driver returns from
|
||||
* its bind() routine.
|
||||
*/
|
||||
struct usb_configuration {
|
||||
const char *label;
|
||||
struct usb_gadget_strings **strings;
|
||||
const struct usb_descriptor_header **descriptors;
|
||||
|
||||
/* REVISIT: bind() functions can be marked __init, which
|
||||
* makes trouble for section mismatch analysis. See if
|
||||
* we can't restructure things to avoid mismatching...
|
||||
*/
|
||||
|
||||
/* configuration management: bind/unbind */
|
||||
int (*bind)(struct usb_configuration *);
|
||||
void (*unbind)(struct usb_configuration *);
|
||||
int (*setup)(struct usb_configuration *,
|
||||
const struct usb_ctrlrequest *);
|
||||
|
||||
/* fields in the config descriptor */
|
||||
u8 bConfigurationValue;
|
||||
u8 iConfiguration;
|
||||
u8 bmAttributes;
|
||||
u8 bMaxPower;
|
||||
|
||||
struct usb_composite_dev *cdev;
|
||||
|
||||
/* private: */
|
||||
/* internals */
|
||||
ListItem_t list;
|
||||
List_t functions;
|
||||
u8 next_interface_id;
|
||||
unsigned highspeed:1;
|
||||
unsigned fullspeed:1;
|
||||
struct usb_function *interface[MAX_CONFIG_INTERFACES];
|
||||
};
|
||||
|
||||
int usb_add_config(struct usb_composite_dev *,
|
||||
struct usb_configuration *);
|
||||
|
||||
/**
|
||||
* struct usb_composite_driver - groups configurations into a gadget
|
||||
* @name: For diagnostics, identifies the driver.
|
||||
* @dev: Template descriptor for the device, including default device
|
||||
* identifiers.
|
||||
* @strings: tables of strings, keyed by identifiers assigned during bind()
|
||||
* and language IDs provided in control requests
|
||||
* @bind: (REQUIRED) Used to allocate resources that are shared across the
|
||||
* whole device, such as string IDs, and add its configurations using
|
||||
* @usb_add_config(). This may fail by returning a negative errno
|
||||
* value; it should return zero on successful initialization.
|
||||
* @unbind: Reverses @bind(); called as a side effect of unregistering
|
||||
* this driver.
|
||||
* @disconnect: optional driver disconnect method
|
||||
* @suspend: Notifies when the host stops sending USB traffic,
|
||||
* after function notifications
|
||||
* @resume: Notifies configuration when the host restarts USB traffic,
|
||||
* before function notifications
|
||||
*
|
||||
* Devices default to reporting self powered operation. Devices which rely
|
||||
* on bus powered operation should report this in their @bind() method.
|
||||
*
|
||||
* Before returning from @bind, various fields in the template descriptor
|
||||
* may be overridden. These include the idVendor/idProduct/bcdDevice values
|
||||
* normally to bind the appropriate host side driver, and the three strings
|
||||
* (iManufacturer, iProduct, iSerialNumber) normally used to provide user
|
||||
* meaningful device identifiers. (The strings will not be defined unless
|
||||
* they are defined in @dev and @strings.) The correct ep0 maxpacket size
|
||||
* is also reported, as defined by the underlying controller driver.
|
||||
*/
|
||||
struct usb_composite_driver {
|
||||
const char *name;
|
||||
const struct usb_device_descriptor *dev;
|
||||
struct usb_gadget_strings **strings;
|
||||
|
||||
/* REVISIT: bind() functions can be marked __init, which
|
||||
* makes trouble for section mismatch analysis. See if
|
||||
* we can't restructure things to avoid mismatching...
|
||||
*/
|
||||
|
||||
int (*bind)(struct usb_composite_dev *);
|
||||
int (*unbind)(struct usb_composite_dev *);
|
||||
|
||||
void (*disconnect)(struct usb_composite_dev *);
|
||||
|
||||
/* global suspend hooks */
|
||||
void (*suspend)(struct usb_composite_dev *);
|
||||
void (*resume)(struct usb_composite_dev *);
|
||||
};
|
||||
|
||||
extern int usb_composite_register(struct usb_composite_driver *);
|
||||
extern void usb_composite_unregister(struct usb_composite_driver *);
|
||||
|
||||
|
||||
/**
|
||||
* struct usb_composite_device - represents one composite usb gadget
|
||||
* @gadget: read-only, abstracts the gadget's usb peripheral controller
|
||||
* @req: used for control responses; buffer is pre-allocated
|
||||
* @bufsiz: size of buffer pre-allocated in @req
|
||||
* @config: the currently active configuration
|
||||
*
|
||||
* One of these devices is allocated and initialized before the
|
||||
* associated device driver's bind() is called.
|
||||
*
|
||||
* OPEN ISSUE: it appears that some WUSB devices will need to be
|
||||
* built by combining a normal (wired) gadget with a wireless one.
|
||||
* This revision of the gadget framework should probably try to make
|
||||
* sure doing that won't hurt too much.
|
||||
*
|
||||
* One notion for how to handle Wireless USB devices involves:
|
||||
* (a) a second gadget here, discovery mechanism TBD, but likely
|
||||
* needing separate "register/unregister WUSB gadget" calls;
|
||||
* (b) updates to usb_gadget to include flags "is it wireless",
|
||||
* "is it wired", plus (presumably in a wrapper structure)
|
||||
* bandgroup and PHY info;
|
||||
* (c) presumably a wireless_ep wrapping a usb_ep, and reporting
|
||||
* wireless-specific parameters like maxburst and maxsequence;
|
||||
* (d) configurations that are specific to wireless links;
|
||||
* (e) function drivers that understand wireless configs and will
|
||||
* support wireless for (additional) function instances;
|
||||
* (f) a function to support association setup (like CBAF), not
|
||||
* necessarily requiring a wireless adapter;
|
||||
* (g) composite device setup that can create one or more wireless
|
||||
* configs, including appropriate association setup support;
|
||||
* (h) more, TBD.
|
||||
*/
|
||||
struct usb_composite_dev {
|
||||
struct usb_gadget *gadget;
|
||||
struct usb_request *req;
|
||||
unsigned bufsiz;
|
||||
|
||||
struct usb_configuration *config;
|
||||
|
||||
/* private: */
|
||||
/* internals */
|
||||
unsigned int suspended:1;
|
||||
struct usb_device_descriptor desc;
|
||||
List_t configs;
|
||||
struct usb_composite_driver *driver;
|
||||
u8 next_string_id;
|
||||
|
||||
/* the gadget driver won't enable the data pullup
|
||||
* while the deactivation count is nonzero.
|
||||
*/
|
||||
unsigned deactivations;
|
||||
};
|
||||
|
||||
extern int usb_string_id(struct usb_composite_dev *c);
|
||||
extern int usb_string_ids_tab(struct usb_composite_dev *c,
|
||||
struct usb_string *str);
|
||||
extern int usb_string_ids_n(struct usb_composite_dev *c, unsigned n);
|
||||
struct usb_endpoint_descriptor *
|
||||
get_ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *fs,
|
||||
struct usb_endpoint_descriptor *hs);
|
||||
struct usb_descriptor_header **
|
||||
usb_copy_descriptors(struct usb_descriptor_header **src);
|
||||
void usb_free_descriptors(struct usb_descriptor_header **v);
|
||||
#endif /* __LINUX_USB_COMPOSITE_H */
|
||||
@ -0,0 +1,56 @@
|
||||
#ifndef __ETHER_H
|
||||
#define __ETHER_H
|
||||
#include "FreeRTOS_IP.h"
|
||||
|
||||
//typedef struct NetworkBufferDescriptor_t *(*ncm_wrap)(struct gether *port, NetworkBufferDescriptor_t* pxBufferDescriptor);
|
||||
//typedef int (*ncm_unwrap)(struct gether *port, NetworkBufferDescriptor_t* pxBufferDescriptor, List_t *frames);
|
||||
|
||||
struct gether {
|
||||
struct usb_function func;
|
||||
/* endpoints handle full and/or high speeds */
|
||||
struct usb_ep *in_ep;
|
||||
struct usb_ep *out_ep;
|
||||
const struct usb_endpoint_descriptor *in, *out;
|
||||
|
||||
bool connected;
|
||||
|
||||
bool is_zlp_ok;
|
||||
|
||||
u16 cdc_filter;
|
||||
|
||||
/* hooks for added framing, as needed for RNDIS and EEM. */
|
||||
u32 header_len;
|
||||
/* NCM requires fixed size bundles */
|
||||
bool is_fixed;
|
||||
u32 fixed_out_len;
|
||||
u32 fixed_in_len;
|
||||
|
||||
NetworkBufferDescriptor_t *(*wrap)(struct gether *port, NetworkBufferDescriptor_t* pxBufferDescriptor);
|
||||
void *(*wrap_ext)(struct gether *port, void* bufferDescHandle);
|
||||
int (*unwrap)(struct gether *port, uint8_t* data_buf, int len, List_t *frames);
|
||||
void (*disconnect_cb)(struct gether *port);
|
||||
|
||||
void (*open)(struct gether *);
|
||||
void (*close)(struct gether *);
|
||||
|
||||
void* ctx;
|
||||
};
|
||||
|
||||
#ifndef ETH_FRAME_LEN
|
||||
#define ETH_FRAME_LEN 1514
|
||||
#endif
|
||||
#ifndef ETH_ALEN
|
||||
#define ETH_ALEN 6
|
||||
#endif
|
||||
#ifndef NET_IP_ALIGN
|
||||
#define NET_IP_ALIGN 4
|
||||
#endif
|
||||
|
||||
void gether_send(NetworkBufferDescriptor_t * const pxDescriptor);
|
||||
void gether_send_ext(void * const pxDescriptor);
|
||||
void gether_disconnect(struct gether *link);
|
||||
int gether_connect(struct gether *link);
|
||||
void gether_cleanup(void);
|
||||
int gether_setup(struct usb_gadget *g, u8 ethaddr[ETH_ALEN]);
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,948 @@
|
||||
/*
|
||||
* <linux/usb/gadget.h>
|
||||
*
|
||||
* We call the USB code inside a Linux-based peripheral device a "gadget"
|
||||
* driver, except for the hardware-specific bus glue. One USB host can
|
||||
* master many USB gadgets, but the gadgets are only slaved to one host.
|
||||
*
|
||||
*
|
||||
* (C) Copyright 2002-2004 by David Brownell
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* This software is licensed under the GNU GPL version 2.
|
||||
*
|
||||
* Ported to U-Boot by: Thomas Smits <ts.smits@gmail.com> and
|
||||
* Remy Bohmer <linux@bohmer.net>
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_USB_GADGET_H
|
||||
#define __LINUX_USB_GADGET_H
|
||||
/*
|
||||
#include <errno.h>
|
||||
#include <linux/compat.h>
|
||||
#include <linux/list.h>*/
|
||||
#include "usb_os_adapter.h"
|
||||
#include <linux/errno.h>
|
||||
#include <stdbool.h>
|
||||
#define CONFIG_USB_GADGET_DUALSPEED 1
|
||||
struct usb_ep;
|
||||
|
||||
/**
|
||||
* struct usb_request - describes one i/o request
|
||||
* @buf: Buffer used for data. Always provide this; some controllers
|
||||
* only use PIO, or don't use DMA for some endpoints.
|
||||
* @dma: DMA address corresponding to 'buf'. If you don't set this
|
||||
* field, and the usb controller needs one, it is responsible
|
||||
* for mapping and unmapping the buffer.
|
||||
* @stream_id: The stream id, when USB3.0 bulk streams are being used
|
||||
* @length: Length of that data
|
||||
* @no_interrupt: If true, hints that no completion irq is needed.
|
||||
* Helpful sometimes with deep request queues that are handled
|
||||
* directly by DMA controllers.
|
||||
* @zero: If true, when writing data, makes the last packet be "short"
|
||||
* by adding a zero length packet as needed;
|
||||
* @short_not_ok: When reading data, makes short packets be
|
||||
* treated as errors (queue stops advancing till cleanup).
|
||||
* @complete: Function called when request completes, so this request and
|
||||
* its buffer may be re-used.
|
||||
* Reads terminate with a short packet, or when the buffer fills,
|
||||
* whichever comes first. When writes terminate, some data bytes
|
||||
* will usually still be in flight (often in a hardware fifo).
|
||||
* Errors (for reads or writes) stop the queue from advancing
|
||||
* until the completion function returns, so that any transfers
|
||||
* invalidated by the error may first be dequeued.
|
||||
* @context: For use by the completion callback
|
||||
* @list: For use by the gadget driver.
|
||||
* @status: Reports completion code, zero or a negative errno.
|
||||
* Normally, faults block the transfer queue from advancing until
|
||||
* the completion callback returns.
|
||||
* Code "-ESHUTDOWN" indicates completion caused by device disconnect,
|
||||
* or when the driver disabled the endpoint.
|
||||
* @actual: Reports bytes transferred to/from the buffer. For reads (OUT
|
||||
* transfers) this may be less than the requested length. If the
|
||||
* short_not_ok flag is set, short reads are treated as errors
|
||||
* even when status otherwise indicates successful completion.
|
||||
* Note that for writes (IN transfers) some data bytes may still
|
||||
* reside in a device-side FIFO when the request is reported as
|
||||
* complete.
|
||||
*
|
||||
* These are allocated/freed through the endpoint they're used with. The
|
||||
* hardware's driver can add extra per-request data to the memory it returns,
|
||||
* which often avoids separate memory allocations (potential failures),
|
||||
* later when the request is queued.
|
||||
*
|
||||
* Request flags affect request handling, such as whether a zero length
|
||||
* packet is written (the "zero" flag), whether a short read should be
|
||||
* treated as an error (blocking request queue advance, the "short_not_ok"
|
||||
* flag), or hinting that an interrupt is not required (the "no_interrupt"
|
||||
* flag, for use with deep request queues).
|
||||
*
|
||||
* Bulk endpoints can use any size buffers, and can also be used for interrupt
|
||||
* transfers. interrupt-only endpoints can be much less functional.
|
||||
*
|
||||
* NOTE: this is analagous to 'struct urb' on the host side, except that
|
||||
* it's thinner and promotes more pre-allocation.
|
||||
*/
|
||||
|
||||
struct usb_request {
|
||||
void *buf;
|
||||
unsigned length;
|
||||
dma_addr_t dma;
|
||||
|
||||
unsigned stream_id:16;
|
||||
unsigned no_interrupt:1;
|
||||
unsigned zero:1;
|
||||
unsigned short_not_ok:1;
|
||||
|
||||
void (*complete)(struct usb_ep *ep,
|
||||
struct usb_request *req);
|
||||
void *context;
|
||||
#ifndef NO_GNU
|
||||
struct list_head list;
|
||||
#else
|
||||
ListItem_t list;
|
||||
void* powner;
|
||||
#endif
|
||||
|
||||
int status;
|
||||
unsigned actual;
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/* endpoint-specific parts of the api to the usb controller hardware.
|
||||
* unlike the urb model, (de)multiplexing layers are not required.
|
||||
* (so this api could slash overhead if used on the host side...)
|
||||
*
|
||||
* note that device side usb controllers commonly differ in how many
|
||||
* endpoints they support, as well as their capabilities.
|
||||
*/
|
||||
struct usb_ep_ops {
|
||||
int (*enable) (struct usb_ep *ep,
|
||||
const struct usb_endpoint_descriptor *desc);
|
||||
int (*disable) (struct usb_ep *ep);
|
||||
|
||||
struct usb_request *(*alloc_request) (struct usb_ep *ep,
|
||||
gfp_t gfp_flags);
|
||||
void (*free_request) (struct usb_ep *ep, struct usb_request *req);
|
||||
|
||||
int (*queue) (struct usb_ep *ep, struct usb_request *req,
|
||||
gfp_t gfp_flags);
|
||||
int (*dequeue) (struct usb_ep *ep, struct usb_request *req);
|
||||
|
||||
int (*set_halt) (struct usb_ep *ep, int value);
|
||||
int (*set_wedge)(struct usb_ep *ep);
|
||||
int (*fifo_status) (struct usb_ep *ep);
|
||||
void (*fifo_flush) (struct usb_ep *ep);
|
||||
};
|
||||
|
||||
/**
|
||||
* struct usb_ep - device side representation of USB endpoint
|
||||
* @name:identifier for the endpoint, such as "ep-a" or "ep9in-bulk"
|
||||
* @ops: Function pointers used to access hardware-specific operations.
|
||||
* @ep_list:the gadget's ep_list holds all of its endpoints
|
||||
* @maxpacket:The maximum packet size used on this endpoint. The initial
|
||||
* value can sometimes be reduced (hardware allowing), according to
|
||||
* the endpoint descriptor used to configure the endpoint.
|
||||
* @maxpacket_limit:The maximum packet size value which can be handled by this
|
||||
* endpoint. It's set once by UDC driver when endpoint is initialized, and
|
||||
* should not be changed. Should not be confused with maxpacket.
|
||||
* @max_streams: The maximum number of streams supported
|
||||
* by this EP (0 - 16, actual number is 2^n)
|
||||
* @maxburst: the maximum number of bursts supported by this EP (for usb3)
|
||||
* @driver_data:for use by the gadget driver. all other fields are
|
||||
* read-only to gadget drivers.
|
||||
* @desc: endpoint descriptor. This pointer is set before the endpoint is
|
||||
* enabled and remains valid until the endpoint is disabled.
|
||||
* @comp_desc: In case of SuperSpeed support, this is the endpoint companion
|
||||
* descriptor that is used to configure the endpoint
|
||||
*
|
||||
* the bus controller driver lists all the general purpose endpoints in
|
||||
* gadget->ep_list. the control endpoint (gadget->ep0) is not in that list,
|
||||
* and is accessed only in response to a driver setup() callback.
|
||||
*/
|
||||
struct usb_ep {
|
||||
void *driver_data;
|
||||
const char *name;
|
||||
const struct usb_ep_ops *ops;
|
||||
#ifndef NO_GNU
|
||||
struct list_head ep_list;
|
||||
#else
|
||||
ListItem_t ep_list;
|
||||
void* powner;
|
||||
#endif
|
||||
unsigned maxpacket:16;
|
||||
unsigned maxpacket_limit:16;
|
||||
unsigned max_streams:16;
|
||||
unsigned maxburst:5;
|
||||
const struct usb_endpoint_descriptor *desc;
|
||||
const struct usb_ss_ep_comp_descriptor *comp_desc;
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* usb_ep_set_maxpacket_limit - set maximum packet size limit for endpoint
|
||||
* @ep:the endpoint being configured
|
||||
* @maxpacket_limit:value of maximum packet size limit
|
||||
*
|
||||
* This function shoud be used only in UDC drivers to initialize endpoint
|
||||
* (usually in probe function).
|
||||
*/
|
||||
static inline void usb_ep_set_maxpacket_limit(struct usb_ep *ep,
|
||||
unsigned maxpacket_limit)
|
||||
{
|
||||
ep->maxpacket_limit = maxpacket_limit;
|
||||
ep->maxpacket = maxpacket_limit;
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_ep_enable - configure endpoint, making it usable
|
||||
* @ep:the endpoint being configured. may not be the endpoint named "ep0".
|
||||
* drivers discover endpoints through the ep_list of a usb_gadget.
|
||||
* @desc:descriptor for desired behavior. caller guarantees this pointer
|
||||
* remains valid until the endpoint is disabled; the data byte order
|
||||
* is little-endian (usb-standard).
|
||||
*
|
||||
* when configurations are set, or when interface settings change, the driver
|
||||
* will enable or disable the relevant endpoints. while it is enabled, an
|
||||
* endpoint may be used for i/o until the driver receives a disconnect() from
|
||||
* the host or until the endpoint is disabled.
|
||||
*
|
||||
* the ep0 implementation (which calls this routine) must ensure that the
|
||||
* hardware capabilities of each endpoint match the descriptor provided
|
||||
* for it. for example, an endpoint named "ep2in-bulk" would be usable
|
||||
* for interrupt transfers as well as bulk, but it likely couldn't be used
|
||||
* for iso transfers or for endpoint 14. some endpoints are fully
|
||||
* configurable, with more generic names like "ep-a". (remember that for
|
||||
* USB, "in" means "towards the USB master".)
|
||||
*
|
||||
* returns zero, or a negative error code.
|
||||
*/
|
||||
static inline int usb_ep_enable(struct usb_ep *ep,
|
||||
const struct usb_endpoint_descriptor *desc)
|
||||
{
|
||||
return ep->ops->enable(ep, desc);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_ep_disable - endpoint is no longer usable
|
||||
* @ep:the endpoint being unconfigured. may not be the endpoint named "ep0".
|
||||
*
|
||||
* no other task may be using this endpoint when this is called.
|
||||
* any pending and uncompleted requests will complete with status
|
||||
* indicating disconnect (-ESHUTDOWN) before this call returns.
|
||||
* gadget drivers must call usb_ep_enable() again before queueing
|
||||
* requests to the endpoint.
|
||||
*
|
||||
* returns zero, or a negative error code.
|
||||
*/
|
||||
static inline int usb_ep_disable(struct usb_ep *ep)
|
||||
{
|
||||
return ep->ops->disable(ep);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_ep_alloc_request - allocate a request object to use with this endpoint
|
||||
* @ep:the endpoint to be used with with the request
|
||||
* @gfp_flags:GFP_* flags to use
|
||||
*
|
||||
* Request objects must be allocated with this call, since they normally
|
||||
* need controller-specific setup and may even need endpoint-specific
|
||||
* resources such as allocation of DMA descriptors.
|
||||
* Requests may be submitted with usb_ep_queue(), and receive a single
|
||||
* completion callback. Free requests with usb_ep_free_request(), when
|
||||
* they are no longer needed.
|
||||
*
|
||||
* Returns the request, or null if one could not be allocated.
|
||||
*/
|
||||
static inline struct usb_request *usb_ep_alloc_request(struct usb_ep *ep,
|
||||
gfp_t gfp_flags)
|
||||
{
|
||||
return ep->ops->alloc_request(ep, gfp_flags);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_ep_free_request - frees a request object
|
||||
* @ep:the endpoint associated with the request
|
||||
* @req:the request being freed
|
||||
*
|
||||
* Reverses the effect of usb_ep_alloc_request().
|
||||
* Caller guarantees the request is not queued, and that it will
|
||||
* no longer be requeued (or otherwise used).
|
||||
*/
|
||||
static inline void usb_ep_free_request(struct usb_ep *ep,
|
||||
struct usb_request *req)
|
||||
{
|
||||
ep->ops->free_request(ep, req);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_ep_queue - queues (submits) an I/O request to an endpoint.
|
||||
* @ep:the endpoint associated with the request
|
||||
* @req:the request being submitted
|
||||
* @gfp_flags: GFP_* flags to use in case the lower level driver couldn't
|
||||
* pre-allocate all necessary memory with the request.
|
||||
*
|
||||
* This tells the device controller to perform the specified request through
|
||||
* that endpoint (reading or writing a buffer). When the request completes,
|
||||
* including being canceled by usb_ep_dequeue(), the request's completion
|
||||
* routine is called to return the request to the driver. Any endpoint
|
||||
* (except control endpoints like ep0) may have more than one transfer
|
||||
* request queued; they complete in FIFO order. Once a gadget driver
|
||||
* submits a request, that request may not be examined or modified until it
|
||||
* is given back to that driver through the completion callback.
|
||||
*
|
||||
* Each request is turned into one or more packets. The controller driver
|
||||
* never merges adjacent requests into the same packet. OUT transfers
|
||||
* will sometimes use data that's already buffered in the hardware.
|
||||
* Drivers can rely on the fact that the first byte of the request's buffer
|
||||
* always corresponds to the first byte of some USB packet, for both
|
||||
* IN and OUT transfers.
|
||||
*
|
||||
* Bulk endpoints can queue any amount of data; the transfer is packetized
|
||||
* automatically. The last packet will be short if the request doesn't fill it
|
||||
* out completely. Zero length packets (ZLPs) should be avoided in portable
|
||||
* protocols since not all usb hardware can successfully handle zero length
|
||||
* packets. (ZLPs may be explicitly written, and may be implicitly written if
|
||||
* the request 'zero' flag is set.) Bulk endpoints may also be used
|
||||
* for interrupt transfers; but the reverse is not true, and some endpoints
|
||||
* won't support every interrupt transfer. (Such as 768 byte packets.)
|
||||
*
|
||||
* Interrupt-only endpoints are less functional than bulk endpoints, for
|
||||
* example by not supporting queueing or not handling buffers that are
|
||||
* larger than the endpoint's maxpacket size. They may also treat data
|
||||
* toggle differently.
|
||||
*
|
||||
* Control endpoints ... after getting a setup() callback, the driver queues
|
||||
* one response (even if it would be zero length). That enables the
|
||||
* status ack, after transfering data as specified in the response. Setup
|
||||
* functions may return negative error codes to generate protocol stalls.
|
||||
* (Note that some USB device controllers disallow protocol stall responses
|
||||
* in some cases.) When control responses are deferred (the response is
|
||||
* written after the setup callback returns), then usb_ep_set_halt() may be
|
||||
* used on ep0 to trigger protocol stalls.
|
||||
*
|
||||
* For periodic endpoints, like interrupt or isochronous ones, the usb host
|
||||
* arranges to poll once per interval, and the gadget driver usually will
|
||||
* have queued some data to transfer at that time.
|
||||
*
|
||||
* Returns zero, or a negative error code. Endpoints that are not enabled
|
||||
* report errors; errors will also be
|
||||
* reported when the usb peripheral is disconnected.
|
||||
*/
|
||||
static inline int usb_ep_queue(struct usb_ep *ep,
|
||||
struct usb_request *req, gfp_t gfp_flags)
|
||||
{
|
||||
return ep->ops->queue(ep, req, gfp_flags);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_ep_dequeue - dequeues (cancels, unlinks) an I/O request from an endpoint
|
||||
* @ep:the endpoint associated with the request
|
||||
* @req:the request being canceled
|
||||
*
|
||||
* if the request is still active on the endpoint, it is dequeued and its
|
||||
* completion routine is called (with status -ECONNRESET); else a negative
|
||||
* error code is returned.
|
||||
*
|
||||
* note that some hardware can't clear out write fifos (to unlink the request
|
||||
* at the head of the queue) except as part of disconnecting from usb. such
|
||||
* restrictions prevent drivers from supporting configuration changes,
|
||||
* even to configuration zero (a "chapter 9" requirement).
|
||||
*/
|
||||
static inline int usb_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
|
||||
{
|
||||
return ep->ops->dequeue(ep, req);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_ep_set_halt - sets the endpoint halt feature.
|
||||
* @ep: the non-isochronous endpoint being stalled
|
||||
*
|
||||
* Use this to stall an endpoint, perhaps as an error report.
|
||||
* Except for control endpoints,
|
||||
* the endpoint stays halted (will not stream any data) until the host
|
||||
* clears this feature; drivers may need to empty the endpoint's request
|
||||
* queue first, to make sure no inappropriate transfers happen.
|
||||
*
|
||||
* Note that while an endpoint CLEAR_FEATURE will be invisible to the
|
||||
* gadget driver, a SET_INTERFACE will not be. To reset endpoints for the
|
||||
* current altsetting, see usb_ep_clear_halt(). When switching altsettings,
|
||||
* it's simplest to use usb_ep_enable() or usb_ep_disable() for the endpoints.
|
||||
*
|
||||
* Returns zero, or a negative error code. On success, this call sets
|
||||
* underlying hardware state that blocks data transfers.
|
||||
* Attempts to halt IN endpoints will fail (returning -EAGAIN) if any
|
||||
* transfer requests are still queued, or if the controller hardware
|
||||
* (usually a FIFO) still holds bytes that the host hasn't collected.
|
||||
*/
|
||||
static inline int usb_ep_set_halt(struct usb_ep *ep)
|
||||
{
|
||||
return ep->ops->set_halt(ep, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_ep_clear_halt - clears endpoint halt, and resets toggle
|
||||
* @ep:the bulk or interrupt endpoint being reset
|
||||
*
|
||||
* Use this when responding to the standard usb "set interface" request,
|
||||
* for endpoints that aren't reconfigured, after clearing any other state
|
||||
* in the endpoint's i/o queue.
|
||||
*
|
||||
* Returns zero, or a negative error code. On success, this call clears
|
||||
* the underlying hardware state reflecting endpoint halt and data toggle.
|
||||
* Note that some hardware can't support this request (like pxa2xx_udc),
|
||||
* and accordingly can't correctly implement interface altsettings.
|
||||
*/
|
||||
static inline int usb_ep_clear_halt(struct usb_ep *ep)
|
||||
{
|
||||
return ep->ops->set_halt(ep, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_ep_fifo_status - returns number of bytes in fifo, or error
|
||||
* @ep: the endpoint whose fifo status is being checked.
|
||||
*
|
||||
* FIFO endpoints may have "unclaimed data" in them in certain cases,
|
||||
* such as after aborted transfers. Hosts may not have collected all
|
||||
* the IN data written by the gadget driver (and reported by a request
|
||||
* completion). The gadget driver may not have collected all the data
|
||||
* written OUT to it by the host. Drivers that need precise handling for
|
||||
* fault reporting or recovery may need to use this call.
|
||||
*
|
||||
* This returns the number of such bytes in the fifo, or a negative
|
||||
* errno if the endpoint doesn't use a FIFO or doesn't support such
|
||||
* precise handling.
|
||||
*/
|
||||
static inline int usb_ep_fifo_status(struct usb_ep *ep)
|
||||
{
|
||||
if (ep->ops->fifo_status)
|
||||
return ep->ops->fifo_status(ep);
|
||||
else
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_ep_fifo_flush - flushes contents of a fifo
|
||||
* @ep: the endpoint whose fifo is being flushed.
|
||||
*
|
||||
* This call may be used to flush the "unclaimed data" that may exist in
|
||||
* an endpoint fifo after abnormal transaction terminations. The call
|
||||
* must never be used except when endpoint is not being used for any
|
||||
* protocol translation.
|
||||
*/
|
||||
static inline void usb_ep_fifo_flush(struct usb_ep *ep)
|
||||
{
|
||||
if (ep->ops->fifo_flush)
|
||||
ep->ops->fifo_flush(ep);
|
||||
}
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
struct usb_gadget;
|
||||
struct usb_gadget_driver;
|
||||
|
||||
/* the rest of the api to the controller hardware: device operations,
|
||||
* which don't involve endpoints (or i/o).
|
||||
*/
|
||||
struct usb_gadget_ops {
|
||||
int (*get_frame)(struct usb_gadget *);
|
||||
int (*wakeup)(struct usb_gadget *);
|
||||
int (*set_selfpowered) (struct usb_gadget *, int is_selfpowered);
|
||||
int (*vbus_session) (struct usb_gadget *, int is_active);
|
||||
int (*vbus_draw) (struct usb_gadget *, unsigned mA);
|
||||
int (*pullup) (struct usb_gadget *, int is_on);
|
||||
int (*ioctl)(struct usb_gadget *,
|
||||
unsigned code, unsigned long param);
|
||||
int (*udc_start)(struct usb_gadget *,
|
||||
struct usb_gadget_driver *);
|
||||
int (*udc_stop)(struct usb_gadget *);
|
||||
};
|
||||
|
||||
/**
|
||||
* struct usb_gadget - represents a usb slave device
|
||||
* @ops: Function pointers used to access hardware-specific operations.
|
||||
* @ep0: Endpoint zero, used when reading or writing responses to
|
||||
* driver setup() requests
|
||||
* @ep_list: List of other endpoints supported by the device.
|
||||
* @speed: Speed of current connection to USB host.
|
||||
* @max_speed: Maximal speed the UDC can handle. UDC must support this
|
||||
* and all slower speeds.
|
||||
* @is_dualspeed: true if the controller supports both high and full speed
|
||||
* operation. If it does, the gadget driver must also support both.
|
||||
* @is_otg: true if the USB device port uses a Mini-AB jack, so that the
|
||||
* gadget driver must provide a USB OTG descriptor.
|
||||
* @is_a_peripheral: false unless is_otg, the "A" end of a USB cable
|
||||
* is in the Mini-AB jack, and HNP has been used to switch roles
|
||||
* so that the "A" device currently acts as A-Peripheral, not A-Host.
|
||||
* @a_hnp_support: OTG device feature flag, indicating that the A-Host
|
||||
* supports HNP at this port.
|
||||
* @a_alt_hnp_support: OTG device feature flag, indicating that the A-Host
|
||||
* only supports HNP on a different root port.
|
||||
* @b_hnp_enable: OTG device feature flag, indicating that the A-Host
|
||||
* enabled HNP support.
|
||||
* @name: Identifies the controller hardware type. Used in diagnostics
|
||||
* and sometimes configuration.
|
||||
* @dev: Driver model state for this abstract device.
|
||||
* @quirk_ep_out_aligned_size: epout requires buffer size to be aligned to
|
||||
* MaxPacketSize.
|
||||
*
|
||||
* Gadgets have a mostly-portable "gadget driver" implementing device
|
||||
* functions, handling all usb configurations and interfaces. Gadget
|
||||
* drivers talk to hardware-specific code indirectly, through ops vectors.
|
||||
* That insulates the gadget driver from hardware details, and packages
|
||||
* the hardware endpoints through generic i/o queues. The "usb_gadget"
|
||||
* and "usb_ep" interfaces provide that insulation from the hardware.
|
||||
*
|
||||
* Except for the driver data, all fields in this structure are
|
||||
* read-only to the gadget driver. That driver data is part of the
|
||||
* "driver model" infrastructure in 2.6 (and later) kernels, and for
|
||||
* earlier systems is grouped in a similar structure that's not known
|
||||
* to the rest of the kernel.
|
||||
*
|
||||
* Values of the three OTG device feature flags are updated before the
|
||||
* setup() call corresponding to USB_REQ_SET_CONFIGURATION, and before
|
||||
* driver suspend() calls. They are valid only when is_otg, and when the
|
||||
* device is acting as a B-Peripheral (so is_a_peripheral is false).
|
||||
*/
|
||||
struct usb_gadget {
|
||||
/* readonly to gadget driver */
|
||||
const struct usb_gadget_ops *ops;
|
||||
struct usb_ep *ep0;
|
||||
#ifndef NO_GNU
|
||||
struct list_head ep_list; /* of usb_ep */
|
||||
#else
|
||||
List_t ep_list;
|
||||
void* powner;
|
||||
void* dev_pri;
|
||||
#endif
|
||||
enum usb_device_speed speed;
|
||||
enum usb_device_speed max_speed;
|
||||
enum usb_device_state state;
|
||||
unsigned is_dualspeed:1;
|
||||
unsigned is_otg:1;
|
||||
unsigned is_a_peripheral:1;
|
||||
unsigned b_hnp_enable:1;
|
||||
unsigned a_hnp_support:1;
|
||||
unsigned a_alt_hnp_support:1;
|
||||
const char *name;
|
||||
//struct device dev;
|
||||
unsigned quirk_ep_out_aligned_size:1;
|
||||
};
|
||||
|
||||
static inline void set_gadget_data(struct usb_gadget *gadget, void *data)
|
||||
{
|
||||
gadget->dev_pri = data;
|
||||
}
|
||||
|
||||
static inline void *get_gadget_data(struct usb_gadget *gadget)
|
||||
{
|
||||
return gadget->dev_pri;
|
||||
}
|
||||
#if 0
|
||||
static inline struct usb_gadget *dev_to_usb_gadget(struct device *dev)
|
||||
{
|
||||
return container_of(dev, struct usb_gadget, dev);
|
||||
}
|
||||
#endif
|
||||
/* iterates the non-control endpoints; 'tmp' is a struct usb_ep pointer */
|
||||
#define gadget_for_each_ep(tmp, gadget) \
|
||||
list_for_each_entry(tmp, &(gadget)->ep_list, ep_list)
|
||||
|
||||
|
||||
/**
|
||||
* gadget_is_dualspeed - return true iff the hardware handles high speed
|
||||
* @g: controller that might support both high and full speeds
|
||||
*/
|
||||
static inline int gadget_is_dualspeed(struct usb_gadget *g)
|
||||
{
|
||||
#ifdef CONFIG_USB_GADGET_DUALSPEED
|
||||
/* runtime test would check "g->is_dualspeed" ... that might be
|
||||
* useful to work around hardware bugs, but is mostly pointless
|
||||
*/
|
||||
return 1;
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* gadget_is_otg - return true iff the hardware is OTG-ready
|
||||
* @g: controller that might have a Mini-AB connector
|
||||
*
|
||||
* This is a runtime test, since kernels with a USB-OTG stack sometimes
|
||||
* run on boards which only have a Mini-B (or Mini-A) connector.
|
||||
*/
|
||||
static inline int gadget_is_otg(struct usb_gadget *g)
|
||||
{
|
||||
#ifdef CONFIG_USB_OTG
|
||||
return g->is_otg;
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_gadget_frame_number - returns the current frame number
|
||||
* @gadget: controller that reports the frame number
|
||||
*
|
||||
* Returns the usb frame number, normally eleven bits from a SOF packet,
|
||||
* or negative errno if this device doesn't support this capability.
|
||||
*/
|
||||
static inline int usb_gadget_frame_number(struct usb_gadget *gadget)
|
||||
{
|
||||
return gadget->ops->get_frame(gadget);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_gadget_wakeup - tries to wake up the host connected to this gadget
|
||||
* @gadget: controller used to wake up the host
|
||||
*
|
||||
* Returns zero on success, else negative error code if the hardware
|
||||
* doesn't support such attempts, or its support has not been enabled
|
||||
* by the usb host. Drivers must return device descriptors that report
|
||||
* their ability to support this, or hosts won't enable it.
|
||||
*
|
||||
* This may also try to use SRP to wake the host and start enumeration,
|
||||
* even if OTG isn't otherwise in use. OTG devices may also start
|
||||
* remote wakeup even when hosts don't explicitly enable it.
|
||||
*/
|
||||
static inline int usb_gadget_wakeup(struct usb_gadget *gadget)
|
||||
{
|
||||
if (!gadget->ops->wakeup)
|
||||
return -EOPNOTSUPP;
|
||||
return gadget->ops->wakeup(gadget);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_gadget_set_selfpowered - sets the device selfpowered feature.
|
||||
* @gadget:the device being declared as self-powered
|
||||
*
|
||||
* this affects the device status reported by the hardware driver
|
||||
* to reflect that it now has a local power supply.
|
||||
*
|
||||
* returns zero on success, else negative errno.
|
||||
*/
|
||||
static inline int usb_gadget_set_selfpowered(struct usb_gadget *gadget)
|
||||
{
|
||||
if (!gadget->ops->set_selfpowered)
|
||||
return -EOPNOTSUPP;
|
||||
return gadget->ops->set_selfpowered(gadget, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_gadget_clear_selfpowered - clear the device selfpowered feature.
|
||||
* @gadget:the device being declared as bus-powered
|
||||
*
|
||||
* this affects the device status reported by the hardware driver.
|
||||
* some hardware may not support bus-powered operation, in which
|
||||
* case this feature's value can never change.
|
||||
*
|
||||
* returns zero on success, else negative errno.
|
||||
*/
|
||||
static inline int usb_gadget_clear_selfpowered(struct usb_gadget *gadget)
|
||||
{
|
||||
if (!gadget->ops->set_selfpowered)
|
||||
return -EOPNOTSUPP;
|
||||
return gadget->ops->set_selfpowered(gadget, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_gadget_vbus_connect - Notify controller that VBUS is powered
|
||||
* @gadget:The device which now has VBUS power.
|
||||
*
|
||||
* This call is used by a driver for an external transceiver (or GPIO)
|
||||
* that detects a VBUS power session starting. Common responses include
|
||||
* resuming the controller, activating the D+ (or D-) pullup to let the
|
||||
* host detect that a USB device is attached, and starting to draw power
|
||||
* (8mA or possibly more, especially after SET_CONFIGURATION).
|
||||
*
|
||||
* Returns zero on success, else negative errno.
|
||||
*/
|
||||
static inline int usb_gadget_vbus_connect(struct usb_gadget *gadget)
|
||||
{
|
||||
if (!gadget->ops->vbus_session)
|
||||
return -EOPNOTSUPP;
|
||||
return gadget->ops->vbus_session(gadget, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_gadget_vbus_draw - constrain controller's VBUS power usage
|
||||
* @gadget:The device whose VBUS usage is being described
|
||||
* @mA:How much current to draw, in milliAmperes. This should be twice
|
||||
* the value listed in the configuration descriptor bMaxPower field.
|
||||
*
|
||||
* This call is used by gadget drivers during SET_CONFIGURATION calls,
|
||||
* reporting how much power the device may consume. For example, this
|
||||
* could affect how quickly batteries are recharged.
|
||||
*
|
||||
* Returns zero on success, else negative errno.
|
||||
*/
|
||||
static inline int usb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA)
|
||||
{
|
||||
if (!gadget->ops->vbus_draw)
|
||||
return -EOPNOTSUPP;
|
||||
return gadget->ops->vbus_draw(gadget, mA);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_gadget_vbus_disconnect - notify controller about VBUS session end
|
||||
* @gadget:the device whose VBUS supply is being described
|
||||
*
|
||||
* This call is used by a driver for an external transceiver (or GPIO)
|
||||
* that detects a VBUS power session ending. Common responses include
|
||||
* reversing everything done in usb_gadget_vbus_connect().
|
||||
*
|
||||
* Returns zero on success, else negative errno.
|
||||
*/
|
||||
static inline int usb_gadget_vbus_disconnect(struct usb_gadget *gadget)
|
||||
{
|
||||
if (!gadget->ops->vbus_session)
|
||||
return -EOPNOTSUPP;
|
||||
return gadget->ops->vbus_session(gadget, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_gadget_connect - software-controlled connect to USB host
|
||||
* @gadget:the peripheral being connected
|
||||
*
|
||||
* Enables the D+ (or potentially D-) pullup. The host will start
|
||||
* enumerating this gadget when the pullup is active and a VBUS session
|
||||
* is active (the link is powered). This pullup is always enabled unless
|
||||
* usb_gadget_disconnect() has been used to disable it.
|
||||
*
|
||||
* Returns zero on success, else negative errno.
|
||||
*/
|
||||
static inline int usb_gadget_connect(struct usb_gadget *gadget)
|
||||
{
|
||||
if (!gadget->ops->pullup)
|
||||
return -EOPNOTSUPP;
|
||||
return gadget->ops->pullup(gadget, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* usb_gadget_disconnect - software-controlled disconnect from USB host
|
||||
* @gadget:the peripheral being disconnected
|
||||
*
|
||||
* Disables the D+ (or potentially D-) pullup, which the host may see
|
||||
* as a disconnect (when a VBUS session is active). Not all systems
|
||||
* support software pullup controls.
|
||||
*
|
||||
* This routine may be used during the gadget driver bind() call to prevent
|
||||
* the peripheral from ever being visible to the USB host, unless later
|
||||
* usb_gadget_connect() is called. For example, user mode components may
|
||||
* need to be activated before the system can talk to hosts.
|
||||
*
|
||||
* Returns zero on success, else negative errno.
|
||||
*/
|
||||
static inline int usb_gadget_disconnect(struct usb_gadget *gadget)
|
||||
{
|
||||
if (!gadget->ops->pullup)
|
||||
return -EOPNOTSUPP;
|
||||
return gadget->ops->pullup(gadget, 0);
|
||||
}
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* struct usb_gadget_driver - driver for usb 'slave' devices
|
||||
* @function: String describing the gadget's function
|
||||
* @speed: Highest speed the driver handles.
|
||||
* @bind: Invoked when the driver is bound to a gadget, usually
|
||||
* after registering the driver.
|
||||
* At that point, ep0 is fully initialized, and ep_list holds
|
||||
* the currently-available endpoints.
|
||||
* Called in a context that permits sleeping.
|
||||
* @setup: Invoked for ep0 control requests that aren't handled by
|
||||
* the hardware level driver. Most calls must be handled by
|
||||
* the gadget driver, including descriptor and configuration
|
||||
* management. The 16 bit members of the setup data are in
|
||||
* USB byte order. Called in_interrupt; this may not sleep. Driver
|
||||
* queues a response to ep0, or returns negative to stall.
|
||||
* @disconnect: Invoked after all transfers have been stopped,
|
||||
* when the host is disconnected. May be called in_interrupt; this
|
||||
* may not sleep. Some devices can't detect disconnect, so this might
|
||||
* not be called except as part of controller shutdown.
|
||||
* @unbind: Invoked when the driver is unbound from a gadget,
|
||||
* usually from rmmod (after a disconnect is reported).
|
||||
* Called in a context that permits sleeping.
|
||||
* @suspend: Invoked on USB suspend. May be called in_interrupt.
|
||||
* @resume: Invoked on USB resume. May be called in_interrupt.
|
||||
* @reset: Invoked on USB bus reset. It is mandatory for all gadget drivers
|
||||
* and should be called in_interrupt.
|
||||
*
|
||||
* Devices are disabled till a gadget driver successfully bind()s, which
|
||||
* means the driver will handle setup() requests needed to enumerate (and
|
||||
* meet "chapter 9" requirements) then do some useful work.
|
||||
*
|
||||
* If gadget->is_otg is true, the gadget driver must provide an OTG
|
||||
* descriptor during enumeration, or else fail the bind() call. In such
|
||||
* cases, no USB traffic may flow until both bind() returns without
|
||||
* having called usb_gadget_disconnect(), and the USB host stack has
|
||||
* initialized.
|
||||
*
|
||||
* Drivers use hardware-specific knowledge to configure the usb hardware.
|
||||
* endpoint addressing is only one of several hardware characteristics that
|
||||
* are in descriptors the ep0 implementation returns from setup() calls.
|
||||
*
|
||||
* Except for ep0 implementation, most driver code shouldn't need change to
|
||||
* run on top of different usb controllers. It'll use endpoints set up by
|
||||
* that ep0 implementation.
|
||||
*
|
||||
* The usb controller driver handles a few standard usb requests. Those
|
||||
* include set_address, and feature flags for devices, interfaces, and
|
||||
* endpoints (the get_status, set_feature, and clear_feature requests).
|
||||
*
|
||||
* Accordingly, the driver's setup() callback must always implement all
|
||||
* get_descriptor requests, returning at least a device descriptor and
|
||||
* a configuration descriptor. Drivers must make sure the endpoint
|
||||
* descriptors match any hardware constraints. Some hardware also constrains
|
||||
* other descriptors. (The pxa250 allows only configurations 1, 2, or 3).
|
||||
*
|
||||
* The driver's setup() callback must also implement set_configuration,
|
||||
* and should also implement set_interface, get_configuration, and
|
||||
* get_interface. Setting a configuration (or interface) is where
|
||||
* endpoints should be activated or (config 0) shut down.
|
||||
*
|
||||
* (Note that only the default control endpoint is supported. Neither
|
||||
* hosts nor devices generally support control traffic except to ep0.)
|
||||
*
|
||||
* Most devices will ignore USB suspend/resume operations, and so will
|
||||
* not provide those callbacks. However, some may need to change modes
|
||||
* when the host is not longer directing those activities. For example,
|
||||
* local controls (buttons, dials, etc) may need to be re-enabled since
|
||||
* the (remote) host can't do that any longer; or an error state might
|
||||
* be cleared, to make the device behave identically whether or not
|
||||
* power is maintained.
|
||||
*/
|
||||
struct usb_gadget_driver {
|
||||
char *function;
|
||||
enum usb_device_speed speed;
|
||||
int (*bind)(struct usb_gadget *);
|
||||
void (*unbind)(struct usb_gadget *);
|
||||
int (*setup)(struct usb_gadget *,
|
||||
const struct usb_ctrlrequest *);
|
||||
void (*disconnect)(struct usb_gadget *);
|
||||
void (*suspend)(struct usb_gadget *);
|
||||
void (*resume)(struct usb_gadget *);
|
||||
void (*reset)(struct usb_gadget *);
|
||||
};
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/* driver modules register and unregister, as usual.
|
||||
* these calls must be made in a context that can sleep.
|
||||
*
|
||||
* these will usually be implemented directly by the hardware-dependent
|
||||
* usb bus interface driver, which will only support a single driver.
|
||||
*/
|
||||
|
||||
/**
|
||||
* usb_gadget_register_driver - register a gadget driver
|
||||
* @driver:the driver being registered
|
||||
*
|
||||
* Call this in your gadget driver's module initialization function,
|
||||
* to tell the underlying usb controller driver about your driver.
|
||||
* The driver's bind() function will be called to bind it to a
|
||||
* gadget before this registration call returns. It's expected that
|
||||
* the bind() functions will be in init sections.
|
||||
* This function must be called in a context that can sleep.
|
||||
*/
|
||||
int usb_gadget_register_driver(struct usb_gadget_driver *driver);
|
||||
|
||||
/**
|
||||
* usb_gadget_unregister_driver - unregister a gadget driver
|
||||
* @driver:the driver being unregistered
|
||||
*
|
||||
* Call this in your gadget driver's module cleanup function,
|
||||
* to tell the underlying usb controller that your driver is
|
||||
* going away. If the controller is connected to a USB host,
|
||||
* it will first disconnect(). The driver is also requested
|
||||
* to unbind() and clean up any device state, before this procedure
|
||||
* finally returns. It's expected that the unbind() functions
|
||||
* will in in exit sections, so may not be linked in some kernels.
|
||||
* This function must be called in a context that can sleep.
|
||||
*/
|
||||
int usb_gadget_unregister_driver(struct usb_gadget_driver *driver);
|
||||
|
||||
int usb_add_gadget_udc_release(struct device *parent,
|
||||
struct usb_gadget *gadget, void (*release)(struct device *dev));
|
||||
int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget);
|
||||
void usb_del_gadget_udc(struct usb_gadget *gadget);
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/* utility to simplify dealing with string descriptors */
|
||||
|
||||
/**
|
||||
* struct usb_gadget_strings - a set of USB strings in a given language
|
||||
* @language:identifies the strings' language (0x0409 for en-us)
|
||||
* @strings:array of strings with their ids
|
||||
*
|
||||
* If you're using usb_gadget_get_string(), use this to wrap all the
|
||||
* strings for a given language.
|
||||
*/
|
||||
struct usb_gadget_strings {
|
||||
u16 language; /* 0x0409 for en-us */
|
||||
struct usb_string *strings;
|
||||
};
|
||||
|
||||
/* put descriptor for string with that id into buf (buflen >= 256) */
|
||||
int usb_gadget_get_string(struct usb_gadget_strings *table, int id, u8 *buf);
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/* utility to simplify managing config descriptors */
|
||||
|
||||
/* write vector of descriptors into buffer */
|
||||
int usb_descriptor_fillbuf(void *, unsigned,
|
||||
const struct usb_descriptor_header **);
|
||||
|
||||
/* build config descriptor from single descriptor vector */
|
||||
int usb_gadget_config_buf(const struct usb_config_descriptor *config,
|
||||
void *buf, unsigned buflen, const struct usb_descriptor_header **desc);
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
/* utility to simplify map/unmap of usb_requests to/from DMA */
|
||||
|
||||
extern int usb_gadget_map_request(struct usb_gadget *gadget,
|
||||
struct usb_request *req, int is_in);
|
||||
|
||||
extern void usb_gadget_unmap_request(struct usb_gadget *gadget,
|
||||
struct usb_request *req, int is_in);
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/* utility to set gadget state properly */
|
||||
|
||||
extern void usb_gadget_set_state(struct usb_gadget *gadget,
|
||||
enum usb_device_state state);
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/* utility to tell udc core that the bus reset occurs */
|
||||
extern void usb_gadget_udc_reset(struct usb_gadget *gadget,
|
||||
struct usb_gadget_driver *driver);
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/* utility to give requests back to the gadget layer */
|
||||
|
||||
extern void usb_gadget_giveback_request(struct usb_ep *ep,
|
||||
struct usb_request *req);
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/* utility wrapping a simple endpoint selection policy */
|
||||
|
||||
extern struct usb_ep *usb_ep_autoconfig(struct usb_gadget *,
|
||||
struct usb_endpoint_descriptor *);
|
||||
|
||||
extern void usb_ep_autoconfig_reset(struct usb_gadget *);
|
||||
|
||||
extern int usb_gadget_handle_interrupts(int index);
|
||||
|
||||
#endif /* __LINUX_USB_GADGET_H */
|
||||
@ -0,0 +1,37 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/* include/linux/usb/otg.h
|
||||
*
|
||||
* Copyright (c) 2015 Texas Instruments Incorporated - http://www.ti.com
|
||||
*
|
||||
* USB OTG (On The Go) defines
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_USB_OTG_H
|
||||
#define __LINUX_USB_OTG_H
|
||||
|
||||
enum usb_dr_mode {
|
||||
USB_DR_MODE_UNKNOWN,
|
||||
USB_DR_MODE_HOST,
|
||||
USB_DR_MODE_PERIPHERAL,
|
||||
USB_DR_MODE_OTG,
|
||||
};
|
||||
|
||||
/**
|
||||
* usb_get_dr_mode() - Get dual role mode for given device
|
||||
* @node: Node offset to the given device
|
||||
*
|
||||
* The function gets phy interface string from property 'dr_mode',
|
||||
* and returns the correspondig enum usb_dr_mode
|
||||
*/
|
||||
enum usb_dr_mode usb_get_dr_mode(int node);
|
||||
|
||||
/**
|
||||
* usb_get_maximum_speed() - Get maximum speed for given device
|
||||
* @node: Node offset to the given device
|
||||
*
|
||||
* The function gets phy interface string from property 'maximum-speed',
|
||||
* and returns the correspondig enum usb_device_speed
|
||||
*/
|
||||
enum usb_device_speed usb_get_maximum_speed(int node);
|
||||
|
||||
#endif /* __LINUX_USB_OTG_H */
|
||||
@ -0,0 +1,244 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* (C) Copyright 2001
|
||||
* Denis Peter, MPL AG Switzerland
|
||||
*/
|
||||
#ifndef _SCSI_H
|
||||
#define _SCSI_H
|
||||
|
||||
struct scsi_cmd {
|
||||
unsigned char cmd[16]; /* command */
|
||||
/* for request sense */
|
||||
#pragma pack(ARCH_DMA_MINALIGN)
|
||||
unsigned char sense_buf[64];
|
||||
unsigned char status; /* SCSI Status */
|
||||
unsigned char target; /* Target ID */
|
||||
unsigned char lun; /* Target LUN */
|
||||
unsigned char cmdlen; /* command len */
|
||||
unsigned long datalen; /* Total data length */
|
||||
unsigned char * pdata; /* pointer to data */
|
||||
unsigned char msgout[12]; /* Messge out buffer (NOT USED) */
|
||||
unsigned char msgin[12]; /* Message in buffer */
|
||||
unsigned char sensecmdlen; /* Sense command len */
|
||||
unsigned long sensedatalen; /* Sense data len */
|
||||
unsigned char sensecmd[6]; /* Sense command */
|
||||
unsigned long contr_stat; /* Controller Status */
|
||||
unsigned long trans_bytes; /* tranfered bytes */
|
||||
|
||||
unsigned int priv;
|
||||
};
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
**
|
||||
** SCSI constants.
|
||||
**
|
||||
**-----------------------------------------------------------
|
||||
*/
|
||||
|
||||
/*
|
||||
** Messages
|
||||
*/
|
||||
|
||||
#define M_COMPLETE (0x00)
|
||||
#define M_EXTENDED (0x01)
|
||||
#define M_SAVE_DP (0x02)
|
||||
#define M_RESTORE_DP (0x03)
|
||||
#define M_DISCONNECT (0x04)
|
||||
#define M_ID_ERROR (0x05)
|
||||
#define M_ABORT (0x06)
|
||||
#define M_REJECT (0x07)
|
||||
#define M_NOOP (0x08)
|
||||
#define M_PARITY (0x09)
|
||||
#define M_LCOMPLETE (0x0a)
|
||||
#define M_FCOMPLETE (0x0b)
|
||||
#define M_RESET (0x0c)
|
||||
#define M_ABORT_TAG (0x0d)
|
||||
#define M_CLEAR_QUEUE (0x0e)
|
||||
#define M_INIT_REC (0x0f)
|
||||
#define M_REL_REC (0x10)
|
||||
#define M_TERMINATE (0x11)
|
||||
#define M_SIMPLE_TAG (0x20)
|
||||
#define M_HEAD_TAG (0x21)
|
||||
#define M_ORDERED_TAG (0x22)
|
||||
#define M_IGN_RESIDUE (0x23)
|
||||
#define M_IDENTIFY (0x80)
|
||||
|
||||
#define M_X_MODIFY_DP (0x00)
|
||||
#define M_X_SYNC_REQ (0x01)
|
||||
#define M_X_WIDE_REQ (0x03)
|
||||
#define M_X_PPR_REQ (0x04)
|
||||
|
||||
|
||||
/*
|
||||
** Status
|
||||
*/
|
||||
|
||||
#define S_GOOD (0x00)
|
||||
#define S_CHECK_COND (0x02)
|
||||
#define S_COND_MET (0x04)
|
||||
#define S_BUSY (0x08)
|
||||
#define S_INT (0x10)
|
||||
#define S_INT_COND_MET (0x14)
|
||||
#define S_CONFLICT (0x18)
|
||||
#define S_TERMINATED (0x20)
|
||||
#define S_QUEUE_FULL (0x28)
|
||||
#define S_ILLEGAL (0xff)
|
||||
#define S_SENSE (0x80)
|
||||
|
||||
/*
|
||||
* Sense_keys
|
||||
*/
|
||||
|
||||
#define SENSE_NO_SENSE 0x0
|
||||
#define SENSE_RECOVERED_ERROR 0x1
|
||||
#define SENSE_NOT_READY 0x2
|
||||
#define SENSE_MEDIUM_ERROR 0x3
|
||||
#define SENSE_HARDWARE_ERROR 0x4
|
||||
#define SENSE_ILLEGAL_REQUEST 0x5
|
||||
#define SENSE_UNIT_ATTENTION 0x6
|
||||
#define SENSE_DATA_PROTECT 0x7
|
||||
#define SENSE_BLANK_CHECK 0x8
|
||||
#define SENSE_VENDOR_SPECIFIC 0x9
|
||||
#define SENSE_COPY_ABORTED 0xA
|
||||
#define SENSE_ABORTED_COMMAND 0xB
|
||||
#define SENSE_VOLUME_OVERFLOW 0xD
|
||||
#define SENSE_MISCOMPARE 0xE
|
||||
|
||||
|
||||
#define SCSI_CHANGE_DEF 0x40 /* Change Definition (Optional) */
|
||||
#define SCSI_COMPARE 0x39 /* Compare (O) */
|
||||
#define SCSI_COPY 0x18 /* Copy (O) */
|
||||
#define SCSI_COP_VERIFY 0x3A /* Copy and Verify (O) */
|
||||
#define SCSI_INQUIRY 0x12 /* Inquiry (MANDATORY) */
|
||||
#define SCSI_LOG_SELECT 0x4C /* Log Select (O) */
|
||||
#define SCSI_LOG_SENSE 0x4D /* Log Sense (O) */
|
||||
#define SCSI_MODE_SEL6 0x15 /* Mode Select 6-byte (Device Specific) */
|
||||
#define SCSI_MODE_SEL10 0x55 /* Mode Select 10-byte (Device Specific) */
|
||||
#define SCSI_MODE_SEN6 0x1A /* Mode Sense 6-byte (Device Specific) */
|
||||
#define SCSI_MODE_SEN10 0x5A /* Mode Sense 10-byte (Device Specific) */
|
||||
#define SCSI_READ_BUFF 0x3C /* Read Buffer (O) */
|
||||
#define SCSI_REQ_SENSE 0x03 /* Request Sense (MANDATORY) */
|
||||
#define SCSI_SEND_DIAG 0x1D /* Send Diagnostic (O) */
|
||||
#define SCSI_TST_U_RDY 0x00 /* Test Unit Ready (MANDATORY) */
|
||||
#define SCSI_WRITE_BUFF 0x3B /* Write Buffer (O) */
|
||||
/***************************************************************************
|
||||
* %%% Commands Unique to Direct Access Devices %%%
|
||||
***************************************************************************/
|
||||
#define SCSI_COMPARE 0x39 /* Compare (O) */
|
||||
#define SCSI_FORMAT 0x04 /* Format Unit (MANDATORY) */
|
||||
#define SCSI_LCK_UN_CAC 0x36 /* Lock Unlock Cache (O) */
|
||||
#define SCSI_PREFETCH 0x34 /* Prefetch (O) */
|
||||
#define SCSI_MED_REMOVL 0x1E /* Prevent/Allow medium Removal (O) */
|
||||
#define SCSI_READ6 0x08 /* Read 6-byte (MANDATORY) */
|
||||
#define SCSI_READ10 0x28 /* Read 10-byte (MANDATORY) */
|
||||
#define SCSI_READ16 0x48
|
||||
#define SCSI_RD_CAPAC 0x25 /* Read Capacity (MANDATORY) */
|
||||
#define SCSI_RD_CAPAC10 SCSI_RD_CAPAC /* Read Capacity (10) */
|
||||
#define SCSI_RD_CAPAC16 0x9e /* Read Capacity (16) */
|
||||
#define SCSI_RD_DEFECT 0x37 /* Read Defect Data (O) */
|
||||
#define SCSI_READ_LONG 0x3E /* Read Long (O) */
|
||||
#define SCSI_REASS_BLK 0x07 /* Reassign Blocks (O) */
|
||||
#define SCSI_RCV_DIAG 0x1C /* Receive Diagnostic Results (O) */
|
||||
#define SCSI_RELEASE 0x17 /* Release Unit (MANDATORY) */
|
||||
#define SCSI_REZERO 0x01 /* Rezero Unit (O) */
|
||||
#define SCSI_SRCH_DAT_E 0x31 /* Search Data Equal (O) */
|
||||
#define SCSI_SRCH_DAT_H 0x30 /* Search Data High (O) */
|
||||
#define SCSI_SRCH_DAT_L 0x32 /* Search Data Low (O) */
|
||||
#define SCSI_SEEK6 0x0B /* Seek 6-Byte (O) */
|
||||
#define SCSI_SEEK10 0x2B /* Seek 10-Byte (O) */
|
||||
#define SCSI_SEND_DIAG 0x1D /* Send Diagnostics (MANDATORY) */
|
||||
#define SCSI_SET_LIMIT 0x33 /* Set Limits (O) */
|
||||
#define SCSI_START_STP 0x1B /* Start/Stop Unit (O) */
|
||||
#define SCSI_SYNC_CACHE 0x35 /* Synchronize Cache (O) */
|
||||
#define SCSI_VERIFY 0x2F /* Verify (O) */
|
||||
#define SCSI_WRITE6 0x0A /* Write 6-Byte (MANDATORY) */
|
||||
#define SCSI_WRITE10 0x2A /* Write 10-Byte (MANDATORY) */
|
||||
#define SCSI_WRT_VERIFY 0x2E /* Write and Verify (O) */
|
||||
#define SCSI_WRITE_LONG 0x3F /* Write Long (O) */
|
||||
#define SCSI_WRITE_SAME 0x41 /* Write Same (O) */
|
||||
|
||||
/**
|
||||
* struct scsi_platdata - stores information about SCSI controller
|
||||
*
|
||||
* @base: Controller base address
|
||||
* @max_lun: Maximum number of logical units
|
||||
* @max_id: Maximum number of target ids
|
||||
*/
|
||||
struct scsi_platdata {
|
||||
unsigned long base;
|
||||
unsigned long max_lun;
|
||||
unsigned long max_id;
|
||||
};
|
||||
|
||||
#if 0
|
||||
/* Operations for SCSI */
|
||||
struct scsi_ops {
|
||||
/**
|
||||
* exec() - execute a command
|
||||
*
|
||||
* @dev: SCSI bus
|
||||
* @cmd: Command to execute
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int (*exec)(struct udevice *dev, struct scsi_cmd *cmd);
|
||||
|
||||
/**
|
||||
* bus_reset() - reset the bus
|
||||
*
|
||||
* @dev: SCSI bus to reset
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int (*bus_reset)(struct udevice *dev);
|
||||
};
|
||||
|
||||
#define scsi_get_ops(dev) ((struct scsi_ops *)(dev)->driver->ops)
|
||||
|
||||
extern struct scsi_ops scsi_ops;
|
||||
|
||||
/**
|
||||
* scsi_exec() - execute a command
|
||||
*
|
||||
* @dev: SCSI bus
|
||||
* @cmd: Command to execute
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int scsi_exec(struct udevice *dev, struct scsi_cmd *cmd);
|
||||
|
||||
/**
|
||||
* scsi_bus_reset() - reset the bus
|
||||
*
|
||||
* @dev: SCSI bus to reset
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int scsi_bus_reset(struct udevice *dev);
|
||||
|
||||
/**
|
||||
* scsi_scan() - Scan all SCSI controllers for available devices
|
||||
*
|
||||
* @vebose: true to show information about each device found
|
||||
*/
|
||||
int scsi_scan(bool verbose);
|
||||
|
||||
/**
|
||||
* scsi_scan_dev() - scan a SCSI bus and create devices
|
||||
*
|
||||
* @dev: SCSI bus
|
||||
* @verbose: true to show information about each device found
|
||||
*/
|
||||
int scsi_scan_dev(struct udevice *dev, bool verbose);
|
||||
#endif
|
||||
|
||||
void scsi_low_level_init(int busdevfunc);
|
||||
void scsi_init(void);
|
||||
|
||||
#define SCSI_IDENTIFY 0xC0 /* not used */
|
||||
|
||||
/* Hardware errors */
|
||||
#define SCSI_SEL_TIME_OUT 0x00000101 /* Selection time out */
|
||||
#define SCSI_HNS_TIME_OUT 0x00000102 /* Handshake */
|
||||
#define SCSI_MA_TIME_OUT 0x00000103 /* Phase error */
|
||||
#define SCSI_UNEXP_DIS 0x00000104 /* unexpected disconnect */
|
||||
|
||||
#define SCSI_INT_STATE 0x00010000 /* unknown Interrupt number is stored in 16 LSB */
|
||||
|
||||
#endif /* _SCSI_H */
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,380 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* (C) Copyright 2001
|
||||
* Denis Peter, MPL AG Switzerland
|
||||
*
|
||||
* Note: Part of this code has been derived from linux
|
||||
*/
|
||||
#ifndef _USB_DEFS_H_
|
||||
#define _USB_DEFS_H_
|
||||
|
||||
/* USB constants */
|
||||
|
||||
/* Device and/or Interface Class codes */
|
||||
#define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */
|
||||
#define USB_CLASS_AUDIO 1
|
||||
#define USB_CLASS_COMM 2
|
||||
#define USB_CLASS_HID 3
|
||||
#define USB_CLASS_PRINTER 7
|
||||
#define USB_CLASS_MASS_STORAGE 8
|
||||
#define USB_CLASS_HUB 9
|
||||
#define USB_CLASS_DATA 10
|
||||
#define USB_CLASS_VENDOR_SPEC 0xff
|
||||
|
||||
/* some HID sub classes */
|
||||
#define USB_SUB_HID_NONE 0
|
||||
#define USB_SUB_HID_BOOT 1
|
||||
|
||||
/* some UID Protocols */
|
||||
#define USB_PROT_HID_NONE 0
|
||||
#define USB_PROT_HID_KEYBOARD 1
|
||||
#define USB_PROT_HID_MOUSE 2
|
||||
|
||||
|
||||
/* Sub STORAGE Classes */
|
||||
#define US_SC_RBC 1 /* Typically, flash devices */
|
||||
#define US_SC_8020 2 /* CD-ROM */
|
||||
#define US_SC_QIC 3 /* QIC-157 Tapes */
|
||||
#define US_SC_UFI 4 /* Floppy */
|
||||
#define US_SC_8070 5 /* Removable media */
|
||||
#define US_SC_SCSI 6 /* Transparent */
|
||||
#define US_SC_MIN US_SC_RBC
|
||||
#define US_SC_MAX US_SC_SCSI
|
||||
|
||||
/* STORAGE Protocols */
|
||||
#define US_PR_CB 1 /* Control/Bulk w/o interrupt */
|
||||
#define US_PR_CBI 0 /* Control/Bulk/Interrupt */
|
||||
#define US_PR_BULK 0x50 /* bulk only */
|
||||
|
||||
/* USB types */
|
||||
#define USB_TYPE_STANDARD (0x00 << 5)
|
||||
#define USB_TYPE_CLASS (0x01 << 5)
|
||||
#define USB_TYPE_VENDOR (0x02 << 5)
|
||||
#define USB_TYPE_RESERVED (0x03 << 5)
|
||||
|
||||
/* USB recipients */
|
||||
#define USB_RECIP_DEVICE 0x00
|
||||
#define USB_RECIP_INTERFACE 0x01
|
||||
#define USB_RECIP_ENDPOINT 0x02
|
||||
#define USB_RECIP_OTHER 0x03
|
||||
|
||||
/* USB directions */
|
||||
#define USB_DIR_OUT 0
|
||||
#define USB_DIR_IN 0x80
|
||||
|
||||
/*
|
||||
* bmRequestType: USB Device Requests, table 9.2 USB 2.0 spec.
|
||||
* (shifted) direction/type/recipient.
|
||||
*/
|
||||
#define DeviceRequest \
|
||||
((USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE) << 8)
|
||||
|
||||
#define DeviceOutRequest \
|
||||
((USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE) << 8)
|
||||
|
||||
#define InterfaceRequest \
|
||||
((USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_INTERFACE) << 8)
|
||||
|
||||
#define EndpointRequest \
|
||||
((USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_INTERFACE) << 8)
|
||||
|
||||
#define EndpointOutRequest \
|
||||
((USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_INTERFACE) << 8)
|
||||
|
||||
/* Descriptor types */
|
||||
#define USB_DT_DEVICE 0x01
|
||||
#define USB_DT_CONFIG 0x02
|
||||
#define USB_DT_STRING 0x03
|
||||
#define USB_DT_INTERFACE 0x04
|
||||
#define USB_DT_ENDPOINT 0x05
|
||||
|
||||
#define USB_DT_HID (USB_TYPE_CLASS | 0x01)
|
||||
#define USB_DT_REPORT (USB_TYPE_CLASS | 0x02)
|
||||
#define USB_DT_PHYSICAL (USB_TYPE_CLASS | 0x03)
|
||||
#define USB_DT_HUB (USB_TYPE_CLASS | 0x09)
|
||||
#define USB_DT_SS_HUB (USB_TYPE_CLASS | 0x0a)
|
||||
|
||||
/* Descriptor sizes per descriptor type */
|
||||
#define USB_DT_DEVICE_SIZE 18
|
||||
#define USB_DT_CONFIG_SIZE 9
|
||||
#define USB_DT_INTERFACE_SIZE 9
|
||||
#define USB_DT_ENDPOINT_SIZE 7
|
||||
#define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */
|
||||
#define USB_DT_HUB_NONVAR_SIZE 7
|
||||
#define USB_DT_HID_SIZE 9
|
||||
|
||||
/* Endpoints */
|
||||
#define USB_ENDPOINT_NUMBER_MASK 0x0f /* in bEndpointAddress */
|
||||
#define USB_ENDPOINT_DIR_MASK 0x80
|
||||
|
||||
#define USB_ENDPOINT_XFERTYPE_MASK 0x03 /* in bmAttributes */
|
||||
#define USB_ENDPOINT_XFER_CONTROL 0
|
||||
#define USB_ENDPOINT_XFER_ISOC 1
|
||||
#define USB_ENDPOINT_XFER_BULK 2
|
||||
#define USB_ENDPOINT_XFER_INT 3
|
||||
|
||||
/* USB Packet IDs (PIDs) */
|
||||
#define USB_PID_UNDEF_0 0xf0
|
||||
#define USB_PID_OUT 0xe1
|
||||
#define USB_PID_ACK 0xd2
|
||||
#define USB_PID_DATA0 0xc3
|
||||
#define USB_PID_UNDEF_4 0xb4
|
||||
#define USB_PID_SOF 0xa5
|
||||
#define USB_PID_UNDEF_6 0x96
|
||||
#define USB_PID_UNDEF_7 0x87
|
||||
#define USB_PID_UNDEF_8 0x78
|
||||
#define USB_PID_IN 0x69
|
||||
#define USB_PID_NAK 0x5a
|
||||
#define USB_PID_DATA1 0x4b
|
||||
#define USB_PID_PREAMBLE 0x3c
|
||||
#define USB_PID_SETUP 0x2d
|
||||
#define USB_PID_STALL 0x1e
|
||||
#define USB_PID_UNDEF_F 0x0f
|
||||
|
||||
/* Standard requests */
|
||||
#define USB_REQ_GET_STATUS 0x00
|
||||
#define USB_REQ_CLEAR_FEATURE 0x01
|
||||
#define USB_REQ_SET_FEATURE 0x03
|
||||
#define USB_REQ_SET_ADDRESS 0x05
|
||||
#define USB_REQ_GET_DESCRIPTOR 0x06
|
||||
#define USB_REQ_SET_DESCRIPTOR 0x07
|
||||
#define USB_REQ_GET_CONFIGURATION 0x08
|
||||
#define USB_REQ_SET_CONFIGURATION 0x09
|
||||
#define USB_REQ_GET_INTERFACE 0x0A
|
||||
#define USB_REQ_SET_INTERFACE 0x0B
|
||||
#define USB_REQ_SYNCH_FRAME 0x0C
|
||||
|
||||
/* HID requests */
|
||||
#define USB_REQ_GET_REPORT 0x01
|
||||
#define USB_REQ_GET_IDLE 0x02
|
||||
#define USB_REQ_GET_PROTOCOL 0x03
|
||||
#define USB_REQ_SET_REPORT 0x09
|
||||
#define USB_REQ_SET_IDLE 0x0A
|
||||
#define USB_REQ_SET_PROTOCOL 0x0B
|
||||
|
||||
/* Device features */
|
||||
#define USB_FEAT_HALT 0x00
|
||||
#define USB_FEAT_WAKEUP 0x01
|
||||
#define USB_FEAT_TEST 0x02
|
||||
|
||||
/* Test modes */
|
||||
#define USB_TEST_MODE_J 0x01
|
||||
#define USB_TEST_MODE_K 0x02
|
||||
#define USB_TEST_MODE_SE0_NAK 0x03
|
||||
#define USB_TEST_MODE_PACKET 0x04
|
||||
#define USB_TEST_MODE_FORCE_ENABLE 0x05
|
||||
|
||||
|
||||
/*
|
||||
* "pipe" definitions, use unsigned so we can compare reliably, since this
|
||||
* value is shifted up to bits 30/31.
|
||||
*/
|
||||
#define PIPE_ISOCHRONOUS 0U
|
||||
#define PIPE_INTERRUPT 1U
|
||||
#define PIPE_CONTROL 2U
|
||||
#define PIPE_BULK 3U
|
||||
#define PIPE_DEVEP_MASK 0x0007ff00
|
||||
|
||||
#define USB_ISOCHRONOUS 0
|
||||
#define USB_INTERRUPT 1
|
||||
#define USB_CONTROL 2
|
||||
#define USB_BULK 3
|
||||
|
||||
#define USB_PIPE_TYPE_SHIFT 30
|
||||
#define USB_PIPE_TYPE_MASK (3 << USB_PIPE_TYPE_SHIFT)
|
||||
|
||||
#define USB_PIPE_DEV_SHIFT 8
|
||||
#define USB_PIPE_DEV_MASK (0x7f << USB_PIPE_DEV_SHIFT)
|
||||
|
||||
#define USB_PIPE_EP_SHIFT 15
|
||||
#define USB_PIPE_EP_MASK (0xf << USB_PIPE_EP_SHIFT)
|
||||
|
||||
/* USB-status codes: */
|
||||
#define USB_ST_ACTIVE 0x1 /* TD is active */
|
||||
#define USB_ST_STALLED 0x2 /* TD is stalled */
|
||||
#define USB_ST_BUF_ERR 0x4 /* buffer error */
|
||||
#define USB_ST_BABBLE_DET 0x8 /* Babble detected */
|
||||
#define USB_ST_NAK_REC 0x10 /* NAK Received*/
|
||||
#define USB_ST_CRC_ERR 0x20 /* CRC/timeout Error */
|
||||
#define USB_ST_BIT_ERR 0x40 /* Bitstuff error */
|
||||
#define USB_ST_NOT_PROC 0x80000000L /* Not yet processed */
|
||||
|
||||
|
||||
/*************************************************************************
|
||||
* Hub defines
|
||||
*/
|
||||
|
||||
/*
|
||||
* Hub request types
|
||||
*/
|
||||
|
||||
#define USB_RT_HUB (USB_TYPE_CLASS | USB_RECIP_DEVICE)
|
||||
#define USB_RT_PORT (USB_TYPE_CLASS | USB_RECIP_OTHER)
|
||||
|
||||
/*
|
||||
* Hub Class feature numbers
|
||||
*/
|
||||
#define C_HUB_LOCAL_POWER 0
|
||||
#define C_HUB_OVER_CURRENT 1
|
||||
|
||||
/*
|
||||
* Port feature numbers
|
||||
*/
|
||||
#define USB_PORT_FEAT_CONNECTION 0
|
||||
#define USB_PORT_FEAT_ENABLE 1
|
||||
#define USB_PORT_FEAT_SUSPEND 2
|
||||
#define USB_PORT_FEAT_OVER_CURRENT 3
|
||||
#define USB_PORT_FEAT_RESET 4
|
||||
#define USB_PORT_FEAT_POWER 8
|
||||
#define USB_PORT_FEAT_LOWSPEED 9
|
||||
#define USB_PORT_FEAT_HIGHSPEED 10
|
||||
#define USB_PORT_FEAT_C_CONNECTION 16
|
||||
#define USB_PORT_FEAT_C_ENABLE 17
|
||||
#define USB_PORT_FEAT_C_SUSPEND 18
|
||||
#define USB_PORT_FEAT_C_OVER_CURRENT 19
|
||||
#define USB_PORT_FEAT_C_RESET 20
|
||||
#define USB_PORT_FEAT_TEST 21
|
||||
|
||||
/*
|
||||
* Changes to Port feature numbers for Super speed,
|
||||
* from USB 3.0 spec Table 10-8
|
||||
*/
|
||||
#define USB_SS_PORT_FEAT_U1_TIMEOUT 23
|
||||
#define USB_SS_PORT_FEAT_U2_TIMEOUT 24
|
||||
#define USB_SS_PORT_FEAT_C_LINK_STATE 25
|
||||
#define USB_SS_PORT_FEAT_C_CONFIG_ERROR 26
|
||||
#define USB_SS_PORT_FEAT_BH_RESET 28
|
||||
#define USB_SS_PORT_FEAT_C_BH_RESET 29
|
||||
|
||||
/* wPortStatus bits */
|
||||
#define USB_PORT_STAT_CONNECTION 0x0001
|
||||
#define USB_PORT_STAT_ENABLE 0x0002
|
||||
#define USB_PORT_STAT_SUSPEND 0x0004
|
||||
#define USB_PORT_STAT_OVERCURRENT 0x0008
|
||||
#define USB_PORT_STAT_RESET 0x0010
|
||||
#define USB_PORT_STAT_POWER 0x0100
|
||||
#define USB_PORT_STAT_LOW_SPEED 0x0200
|
||||
#define USB_PORT_STAT_HIGH_SPEED 0x0400 /* support for EHCI */
|
||||
#define USB_PORT_STAT_SUPER_SPEED 0x0600 /* faking support to XHCI */
|
||||
#define USB_PORT_STAT_SPEED_MASK \
|
||||
(USB_PORT_STAT_LOW_SPEED | USB_PORT_STAT_HIGH_SPEED)
|
||||
|
||||
/*
|
||||
* Changes to wPortStatus bit field in USB 3.0
|
||||
* See USB 3.0 spec Table 10-10
|
||||
*/
|
||||
#define USB_SS_PORT_STAT_LINK_STATE 0x01e0
|
||||
#define USB_SS_PORT_STAT_POWER 0x0200
|
||||
#define USB_SS_PORT_STAT_SPEED 0x1c00
|
||||
#define USB_SS_PORT_STAT_SPEED_5GBPS 0x0000
|
||||
/* Bits that are the same from USB 2.0 */
|
||||
#define USB_SS_PORT_STAT_MASK (USB_PORT_STAT_CONNECTION | \
|
||||
USB_PORT_STAT_ENABLE | \
|
||||
USB_PORT_STAT_OVERCURRENT | \
|
||||
USB_PORT_STAT_RESET)
|
||||
|
||||
/* wPortChange bits */
|
||||
#define USB_PORT_STAT_C_CONNECTION 0x0001
|
||||
#define USB_PORT_STAT_C_ENABLE 0x0002
|
||||
#define USB_PORT_STAT_C_SUSPEND 0x0004
|
||||
#define USB_PORT_STAT_C_OVERCURRENT 0x0008
|
||||
#define USB_PORT_STAT_C_RESET 0x0010
|
||||
|
||||
/*
|
||||
* Changes to wPortChange bit fields in USB 3.0
|
||||
* See USB 3.0 spec Table 10-12
|
||||
*/
|
||||
#define USB_SS_PORT_STAT_C_BH_RESET 0x0020
|
||||
#define USB_SS_PORT_STAT_C_LINK_STATE 0x0040
|
||||
#define USB_SS_PORT_STAT_C_CONFIG_ERROR 0x0080
|
||||
|
||||
/* wHubCharacteristics (masks) */
|
||||
#define HUB_CHAR_LPSM 0x0003
|
||||
#define HUB_CHAR_COMPOUND 0x0004
|
||||
#define HUB_CHAR_OCPM 0x0018
|
||||
#define HUB_CHAR_TTTT 0x0060 /* TT Think Time mask */
|
||||
|
||||
/*
|
||||
* Hub Status & Hub Change bit masks
|
||||
*/
|
||||
#define HUB_STATUS_LOCAL_POWER 0x0001
|
||||
#define HUB_STATUS_OVERCURRENT 0x0002
|
||||
|
||||
#define HUB_CHANGE_LOCAL_POWER 0x0001
|
||||
#define HUB_CHANGE_OVERCURRENT 0x0002
|
||||
|
||||
/* Mask for wIndex in get/set port feature */
|
||||
#define USB_HUB_PORT_MASK 0xf
|
||||
|
||||
/* Hub class request codes */
|
||||
#define USB_REQ_SET_HUB_DEPTH 0x0c
|
||||
|
||||
/*
|
||||
* As of USB 2.0, full/low speed devices are segregated into trees.
|
||||
* One type grows from USB 1.1 host controllers (OHCI, UHCI etc).
|
||||
* The other type grows from high speed hubs when they connect to
|
||||
* full/low speed devices using "Transaction Translators" (TTs).
|
||||
*/
|
||||
#if 0
|
||||
struct usb_tt {
|
||||
bool multi; /* true means one TT per port */
|
||||
unsigned think_time; /* think time in ns */
|
||||
};
|
||||
#else
|
||||
struct usb_device;
|
||||
struct usb_tt {
|
||||
struct usb_device *hub; /* upstream highspeed hub */
|
||||
int multi; /* true means one TT per port */
|
||||
unsigned think_time; /* think time in ns */
|
||||
void *hcpriv; /* HCD private data */
|
||||
|
||||
/* for control/bulk error recovery (CLEAR_TT_BUFFER) */
|
||||
spinlock_t lock;
|
||||
//struct list_head clear_list; /* of usb_tt_clear */
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* CBI style
|
||||
*/
|
||||
|
||||
#define US_CBI_ADSC 0
|
||||
|
||||
/* Command Block Wrapper */
|
||||
struct umass_bbb_cbw {
|
||||
__u32 dCBWSignature;
|
||||
# define CBWSIGNATURE 0x43425355
|
||||
__u32 dCBWTag;
|
||||
__u32 dCBWDataTransferLength;
|
||||
__u8 bCBWFlags;
|
||||
# define CBWFLAGS_OUT 0x00
|
||||
# define CBWFLAGS_IN 0x80
|
||||
# define CBWFLAGS_SBZ 0x7f
|
||||
__u8 bCBWLUN;
|
||||
__u8 bCDBLength;
|
||||
# define CBWCDBLENGTH 16
|
||||
__u8 CBWCDB[CBWCDBLENGTH];
|
||||
};
|
||||
#define UMASS_BBB_CBW_SIZE 31
|
||||
|
||||
/* Command Status Wrapper */
|
||||
struct umass_bbb_csw {
|
||||
__u32 dCSWSignature;
|
||||
# define CSWSIGNATURE 0x53425355
|
||||
__u32 dCSWTag;
|
||||
__u32 dCSWDataResidue;
|
||||
__u8 bCSWStatus;
|
||||
# define CSWSTATUS_GOOD 0x0
|
||||
# define CSWSTATUS_FAILED 0x1
|
||||
# define CSWSTATUS_PHASE 0x2
|
||||
};
|
||||
#define UMASS_BBB_CSW_SIZE 13
|
||||
|
||||
/*
|
||||
* BULK only
|
||||
*/
|
||||
#define US_BBB_RESET 0xff
|
||||
#define US_BBB_GET_MAX_LUN 0xfe
|
||||
|
||||
#endif /*_USB_DEFS_H_ */
|
||||
@ -0,0 +1,534 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* (C) Copyright 2003
|
||||
* Gerry Hamel, geh@ti.com, Texas Instruments
|
||||
*
|
||||
* Based on
|
||||
* linux/drivers/usbd/usb-function.h - USB Function
|
||||
*
|
||||
* Copyright (c) 2000, 2001, 2002 Lineo
|
||||
* Copyright (c) 2001 Hewlett Packard
|
||||
*
|
||||
* By:
|
||||
* Stuart Lynne <sl@lineo.com>,
|
||||
* Tom Rushworth <tbr@lineo.com>,
|
||||
* Bruce Balden <balden@lineo.com>
|
||||
*/
|
||||
|
||||
/* USB Descriptors - Create a complete description of all of the
|
||||
* function driver capabilities. These map directly to the USB descriptors.
|
||||
*
|
||||
* This heirarchy is created by the functions drivers and is passed to the
|
||||
* usb-device driver when the function driver is registered.
|
||||
*
|
||||
* device
|
||||
* configuration
|
||||
* interface
|
||||
* alternate
|
||||
* class
|
||||
* class
|
||||
* alternate
|
||||
* endpoint
|
||||
* endpoint
|
||||
* interface
|
||||
* alternate
|
||||
* endpoint
|
||||
* endpoint
|
||||
* configuration
|
||||
* interface
|
||||
* alternate
|
||||
* endpoint
|
||||
* endpoint
|
||||
*
|
||||
*
|
||||
* The configuration structures refer to the USB Configurations that will be
|
||||
* made available to a USB HOST during the enumeration process.
|
||||
*
|
||||
* The USB HOST will select a configuration and optionally an interface with
|
||||
* the usb set configuration and set interface commands.
|
||||
*
|
||||
* The selected interface (or the default interface if not specifically
|
||||
* selected) will define the list of endpoints that will be used.
|
||||
*
|
||||
* The configuration and interfaces are stored in an array that is indexed
|
||||
* by the specified configuratin or interface number minus one.
|
||||
*
|
||||
* A configuration number of zero is used to specify a return to the unconfigured
|
||||
* state.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __USBDESCRIPTORS_H__
|
||||
#define __USBDESCRIPTORS_H__
|
||||
|
||||
#include <asm/types.h>
|
||||
|
||||
/*
|
||||
* communications class types
|
||||
*
|
||||
* c.f. CDC USB Class Definitions for Communications Devices
|
||||
* c.f. WMCD USB CDC Subclass Specification for Wireless Mobile Communications Devices
|
||||
*
|
||||
*/
|
||||
|
||||
#define CLASS_BCD_VERSION 0x0110
|
||||
|
||||
/* c.f. CDC 4.1 Table 14 */
|
||||
#define COMMUNICATIONS_DEVICE_CLASS 0x02
|
||||
|
||||
/* c.f. CDC 4.2 Table 15 */
|
||||
#define COMMUNICATIONS_INTERFACE_CLASS_CONTROL 0x02
|
||||
#define COMMUNICATIONS_INTERFACE_CLASS_DATA 0x0A
|
||||
#define COMMUNICATIONS_INTERFACE_CLASS_VENDOR 0x0FF
|
||||
|
||||
/* c.f. CDC 4.3 Table 16 */
|
||||
#define COMMUNICATIONS_NO_SUBCLASS 0x00
|
||||
#define COMMUNICATIONS_DLCM_SUBCLASS 0x01
|
||||
#define COMMUNICATIONS_ACM_SUBCLASS 0x02
|
||||
#define COMMUNICATIONS_TCM_SUBCLASS 0x03
|
||||
#define COMMUNICATIONS_MCCM_SUBCLASS 0x04
|
||||
#define COMMUNICATIONS_CCM_SUBCLASS 0x05
|
||||
#define COMMUNICATIONS_ENCM_SUBCLASS 0x06
|
||||
#define COMMUNICATIONS_ANCM_SUBCLASS 0x07
|
||||
|
||||
/* c.f. WMCD 5.1 */
|
||||
#define COMMUNICATIONS_WHCM_SUBCLASS 0x08
|
||||
#define COMMUNICATIONS_DMM_SUBCLASS 0x09
|
||||
#define COMMUNICATIONS_MDLM_SUBCLASS 0x0a
|
||||
#define COMMUNICATIONS_OBEX_SUBCLASS 0x0b
|
||||
|
||||
/* c.f. CDC 4.4 Table 17 */
|
||||
#define COMMUNICATIONS_NO_PROTOCOL 0x00
|
||||
#define COMMUNICATIONS_V25TER_PROTOCOL 0x01 /*Common AT Hayes compatible*/
|
||||
|
||||
/* c.f. CDC 4.5 Table 18 */
|
||||
#define DATA_INTERFACE_CLASS 0x0a
|
||||
|
||||
/* c.f. CDC 4.6 No Table */
|
||||
#define DATA_INTERFACE_SUBCLASS_NONE 0x00 /* No subclass pertinent */
|
||||
|
||||
/* c.f. CDC 4.7 Table 19 */
|
||||
#define DATA_INTERFACE_PROTOCOL_NONE 0x00 /* No class protcol required */
|
||||
|
||||
|
||||
/* c.f. CDC 5.2.3 Table 24 */
|
||||
#define CS_INTERFACE 0x24
|
||||
#define CS_ENDPOINT 0x25
|
||||
|
||||
/*
|
||||
* bDescriptorSubtypes
|
||||
*
|
||||
* c.f. CDC 5.2.3 Table 25
|
||||
* c.f. WMCD 5.3 Table 5.3
|
||||
*/
|
||||
|
||||
#define USB_ST_HEADER 0x00
|
||||
#define USB_ST_CMF 0x01
|
||||
#define USB_ST_ACMF 0x02
|
||||
#define USB_ST_DLMF 0x03
|
||||
#define USB_ST_TRF 0x04
|
||||
#define USB_ST_TCLF 0x05
|
||||
#define USB_ST_UF 0x06
|
||||
#define USB_ST_CSF 0x07
|
||||
#define USB_ST_TOMF 0x08
|
||||
#define USB_ST_USBTF 0x09
|
||||
#define USB_ST_NCT 0x0a
|
||||
#define USB_ST_PUF 0x0b
|
||||
#define USB_ST_EUF 0x0c
|
||||
#define USB_ST_MCMF 0x0d
|
||||
#define USB_ST_CCMF 0x0e
|
||||
#define USB_ST_ENF 0x0f
|
||||
#define USB_ST_ATMNF 0x10
|
||||
|
||||
#define USB_ST_WHCM 0x11
|
||||
#define USB_ST_MDLM 0x12
|
||||
#define USB_ST_MDLMD 0x13
|
||||
#define USB_ST_DMM 0x14
|
||||
#define USB_ST_OBEX 0x15
|
||||
#define USB_ST_CS 0x16
|
||||
#define USB_ST_CSD 0x17
|
||||
#define USB_ST_TCM 0x18
|
||||
|
||||
/* endpoint modifiers
|
||||
* static struct usb_endpoint_description function_default_A_1[] = {
|
||||
*
|
||||
* {this_endpoint: 0, attributes: CONTROL, max_size: 8, polling_interval: 0 },
|
||||
* {this_endpoint: 1, attributes: BULK, max_size: 64, polling_interval: 0, direction: IN},
|
||||
* {this_endpoint: 2, attributes: BULK, max_size: 64, polling_interval: 0, direction: OUT},
|
||||
* {this_endpoint: 3, attributes: INTERRUPT, max_size: 8, polling_interval: 0},
|
||||
*
|
||||
*
|
||||
*/
|
||||
#define OUT 0x00
|
||||
#define IN 0x80
|
||||
|
||||
#define CONTROL 0x00
|
||||
#define ISOCHRONOUS 0x01
|
||||
#define BULK 0x02
|
||||
#define INTERRUPT 0x03
|
||||
|
||||
|
||||
/* configuration modifiers
|
||||
*/
|
||||
#define BMATTRIBUTE_RESERVED 0x80
|
||||
#define BMATTRIBUTE_SELF_POWERED 0x40
|
||||
|
||||
/*
|
||||
* standard usb descriptor structures
|
||||
*/
|
||||
|
||||
struct usb_endpoint_descriptor {
|
||||
u8 bLength;
|
||||
u8 bDescriptorType; /* 0x5 */
|
||||
u8 bEndpointAddress;
|
||||
u8 bmAttributes;
|
||||
u16 wMaxPacketSize;
|
||||
u8 bInterval;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_interface_descriptor {
|
||||
u8 bLength;
|
||||
u8 bDescriptorType; /* 0x04 */
|
||||
u8 bInterfaceNumber;
|
||||
u8 bAlternateSetting;
|
||||
u8 bNumEndpoints;
|
||||
u8 bInterfaceClass;
|
||||
u8 bInterfaceSubClass;
|
||||
u8 bInterfaceProtocol;
|
||||
u8 iInterface;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_configuration_descriptor {
|
||||
u8 bLength;
|
||||
u8 bDescriptorType; /* 0x2 */
|
||||
u16 wTotalLength;
|
||||
u8 bNumInterfaces;
|
||||
u8 bConfigurationValue;
|
||||
u8 iConfiguration;
|
||||
u8 bmAttributes;
|
||||
u8 bMaxPower;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_device_descriptor {
|
||||
u8 bLength;
|
||||
u8 bDescriptorType; /* 0x01 */
|
||||
u16 bcdUSB;
|
||||
u8 bDeviceClass;
|
||||
u8 bDeviceSubClass;
|
||||
u8 bDeviceProtocol;
|
||||
u8 bMaxPacketSize0;
|
||||
u16 idVendor;
|
||||
u16 idProduct;
|
||||
u16 bcdDevice;
|
||||
u8 iManufacturer;
|
||||
u8 iProduct;
|
||||
u8 iSerialNumber;
|
||||
u8 bNumConfigurations;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
#if defined(CONFIG_USBD_HS)
|
||||
struct usb_qualifier_descriptor {
|
||||
u8 bLength;
|
||||
u8 bDescriptorType;
|
||||
|
||||
u16 bcdUSB;
|
||||
u8 bDeviceClass;
|
||||
u8 bDeviceSubClass;
|
||||
u8 bDeviceProtocol;
|
||||
u8 bMaxPacketSize0;
|
||||
u8 bNumConfigurations;
|
||||
u8 breserved;
|
||||
} __attribute__ ((packed));
|
||||
#endif
|
||||
|
||||
struct usb_string_descriptor {
|
||||
u8 bLength;
|
||||
u8 bDescriptorType; /* 0x03 */
|
||||
u16 wData[0];
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_generic_descriptor {
|
||||
u8 bLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
|
||||
/*
|
||||
* communications class descriptor structures
|
||||
*
|
||||
* c.f. CDC 5.2 Table 25c
|
||||
*/
|
||||
|
||||
struct usb_class_function_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_function_descriptor_generic {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype;
|
||||
u8 bmCapabilities;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_header_function_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x00 */
|
||||
u16 bcdCDC;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_call_management_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x01 */
|
||||
u8 bmCapabilities;
|
||||
u8 bDataInterface;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_abstract_control_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x02 */
|
||||
u8 bmCapabilities;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_direct_line_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x03 */
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_telephone_ringer_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x04 */
|
||||
u8 bRingerVolSeps;
|
||||
u8 bNumRingerPatterns;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_telephone_call_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x05 */
|
||||
u8 bmCapabilities;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_union_function_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x06 */
|
||||
u8 bMasterInterface;
|
||||
/* u8 bSlaveInterface0[0]; */
|
||||
u8 bSlaveInterface0;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_country_selection_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x07 */
|
||||
u8 iCountryCodeRelDate;
|
||||
u16 wCountryCode0[0];
|
||||
} __attribute__ ((packed));
|
||||
|
||||
|
||||
struct usb_class_telephone_operational_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x08 */
|
||||
u8 bmCapabilities;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
|
||||
struct usb_class_usb_terminal_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x09 */
|
||||
u8 bEntityId;
|
||||
u8 bInterfaceNo;
|
||||
u8 bOutInterfaceNo;
|
||||
u8 bmOptions;
|
||||
u8 bChild0[0];
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_network_channel_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x0a */
|
||||
u8 bEntityId;
|
||||
u8 iName;
|
||||
u8 bChannelIndex;
|
||||
u8 bPhysicalInterface;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_protocol_unit_function_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x0b */
|
||||
u8 bEntityId;
|
||||
u8 bProtocol;
|
||||
u8 bChild0[0];
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_extension_unit_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x0c */
|
||||
u8 bEntityId;
|
||||
u8 bExtensionCode;
|
||||
u8 iName;
|
||||
u8 bChild0[0];
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_multi_channel_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x0d */
|
||||
u8 bmCapabilities;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_capi_control_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x0e */
|
||||
u8 bmCapabilities;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_ethernet_networking_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x0f */
|
||||
u8 iMACAddress;
|
||||
u32 bmEthernetStatistics;
|
||||
u16 wMaxSegmentSize;
|
||||
u16 wNumberMCFilters;
|
||||
u8 bNumberPowerFilters;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_atm_networking_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x10 */
|
||||
u8 iEndSystermIdentifier;
|
||||
u8 bmDataCapabilities;
|
||||
u8 bmATMDeviceStatistics;
|
||||
u16 wType2MaxSegmentSize;
|
||||
u16 wType3MaxSegmentSize;
|
||||
u16 wMaxVC;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
|
||||
struct usb_class_mdlm_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x12 */
|
||||
u16 bcdVersion;
|
||||
u8 bGUID[16];
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_mdlmd_descriptor {
|
||||
u8 bFunctionLength;
|
||||
u8 bDescriptorType;
|
||||
u8 bDescriptorSubtype; /* 0x13 */
|
||||
u8 bGuidDescriptorType;
|
||||
u8 bDetailData[0];
|
||||
|
||||
} __attribute__ ((packed));
|
||||
|
||||
/*
|
||||
* HID class descriptor structures
|
||||
*
|
||||
* c.f. HID 6.2.1
|
||||
*/
|
||||
|
||||
struct usb_class_hid_descriptor {
|
||||
u8 bLength;
|
||||
u8 bDescriptorType;
|
||||
u16 bcdCDC;
|
||||
u8 bCountryCode;
|
||||
u8 bNumDescriptors; /* 0x01 */
|
||||
u8 bDescriptorType0;
|
||||
u16 wDescriptorLength0;
|
||||
/* optional descriptors are not supported. */
|
||||
} __attribute__((packed));
|
||||
|
||||
struct usb_class_report_descriptor {
|
||||
u8 bLength; /* dummy */
|
||||
u8 bDescriptorType;
|
||||
u16 wLength;
|
||||
u8 bData[0];
|
||||
} __attribute__((packed));
|
||||
|
||||
/*
|
||||
* descriptor union structures
|
||||
*/
|
||||
|
||||
struct usb_descriptor {
|
||||
union {
|
||||
struct usb_generic_descriptor generic;
|
||||
struct usb_endpoint_descriptor endpoint;
|
||||
struct usb_interface_descriptor interface;
|
||||
struct usb_configuration_descriptor configuration;
|
||||
struct usb_device_descriptor device;
|
||||
struct usb_string_descriptor string;
|
||||
} descriptor;
|
||||
|
||||
} __attribute__ ((packed));
|
||||
|
||||
struct usb_class_descriptor {
|
||||
union {
|
||||
struct usb_class_function_descriptor function;
|
||||
struct usb_class_function_descriptor_generic generic;
|
||||
struct usb_class_header_function_descriptor header_function;
|
||||
struct usb_class_call_management_descriptor call_management;
|
||||
struct usb_class_abstract_control_descriptor abstract_control;
|
||||
struct usb_class_direct_line_descriptor direct_line;
|
||||
struct usb_class_telephone_ringer_descriptor telephone_ringer;
|
||||
struct usb_class_telephone_operational_descriptor telephone_operational;
|
||||
struct usb_class_telephone_call_descriptor telephone_call;
|
||||
struct usb_class_union_function_descriptor union_function;
|
||||
struct usb_class_country_selection_descriptor country_selection;
|
||||
struct usb_class_usb_terminal_descriptor usb_terminal;
|
||||
struct usb_class_network_channel_descriptor network_channel;
|
||||
struct usb_class_extension_unit_descriptor extension_unit;
|
||||
struct usb_class_multi_channel_descriptor multi_channel;
|
||||
struct usb_class_capi_control_descriptor capi_control;
|
||||
struct usb_class_ethernet_networking_descriptor ethernet_networking;
|
||||
struct usb_class_atm_networking_descriptor atm_networking;
|
||||
struct usb_class_mdlm_descriptor mobile_direct;
|
||||
struct usb_class_mdlmd_descriptor mobile_direct_detail;
|
||||
struct usb_class_hid_descriptor hid;
|
||||
} descriptor;
|
||||
|
||||
} __attribute__ ((packed));
|
||||
|
||||
#ifdef DEBUG
|
||||
static inline void print_device_descriptor(struct usb_device_descriptor *d)
|
||||
{
|
||||
serial_printf("usb device descriptor \n");
|
||||
serial_printf("\tbLength %2.2x\n", d->bLength);
|
||||
serial_printf("\tbDescriptorType %2.2x\n", d->bDescriptorType);
|
||||
serial_printf("\tbcdUSB %4.4x\n", d->bcdUSB);
|
||||
serial_printf("\tbDeviceClass %2.2x\n", d->bDeviceClass);
|
||||
serial_printf("\tbDeviceSubClass %2.2x\n", d->bDeviceSubClass);
|
||||
serial_printf("\tbDeviceProtocol %2.2x\n", d->bDeviceProtocol);
|
||||
serial_printf("\tbMaxPacketSize0 %2.2x\n", d->bMaxPacketSize0);
|
||||
serial_printf("\tidVendor %4.4x\n", d->idVendor);
|
||||
serial_printf("\tidProduct %4.4x\n", d->idProduct);
|
||||
serial_printf("\tbcdDevice %4.4x\n", d->bcdDevice);
|
||||
serial_printf("\tiManufacturer %2.2x\n", d->iManufacturer);
|
||||
serial_printf("\tiProduct %2.2x\n", d->iProduct);
|
||||
serial_printf("\tiSerialNumber %2.2x\n", d->iSerialNumber);
|
||||
serial_printf("\tbNumConfigurations %2.2x\n", d->bNumConfigurations);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* stubs */
|
||||
#define print_device_descriptor(d)
|
||||
|
||||
#endif /* DEBUG */
|
||||
#endif
|
||||
@ -0,0 +1,777 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* (C) Copyright 2003
|
||||
* Gerry Hamel, geh@ti.com, Texas Instruments
|
||||
*
|
||||
* Based on linux/drivers/usbd/usbd.h
|
||||
*
|
||||
* Copyright (c) 2000, 2001, 2002 Lineo
|
||||
* Copyright (c) 2001 Hewlett Packard
|
||||
*
|
||||
* By:
|
||||
* Stuart Lynne <sl@lineo.com>,
|
||||
* Tom Rushworth <tbr@lineo.com>,
|
||||
* Bruce Balden <balden@lineo.com>
|
||||
*/
|
||||
|
||||
#ifndef __USBDCORE_H__
|
||||
#define __USBDCORE_H__
|
||||
|
||||
#include <common.h>
|
||||
#include "usbdescriptors.h"
|
||||
|
||||
|
||||
#define MAX_URBS_QUEUED 5
|
||||
|
||||
|
||||
#if 1
|
||||
#define usberr(fmt,args...) serial_printf("ERROR: %s(), %d: "fmt"\n",__FUNCTION__,__LINE__,##args)
|
||||
#else
|
||||
#define usberr(fmt,args...) do{}while(0)
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
#define usbdbg(fmt,args...) serial_printf("debug: %s(), %d: "fmt"\n",__FUNCTION__,__LINE__,##args)
|
||||
#else
|
||||
#define usbdbg(fmt,args...) do{}while(0)
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
#define usbinfo(fmt,args...) serial_printf("info: %s(), %d: "fmt"\n",__FUNCTION__,__LINE__,##args)
|
||||
#else
|
||||
#define usbinfo(fmt,args...) do{}while(0)
|
||||
#endif
|
||||
|
||||
#ifndef le16_to_cpu
|
||||
#define le16_to_cpu(x) (x)
|
||||
#endif
|
||||
|
||||
#ifndef inb
|
||||
#define inb(p) (*(volatile u8*)(p))
|
||||
#endif
|
||||
|
||||
#ifndef outb
|
||||
#define outb(val,p) (*(volatile u8*)(p) = (val))
|
||||
#endif
|
||||
|
||||
#ifndef inw
|
||||
#define inw(p) (*(volatile u16*)(p))
|
||||
#endif
|
||||
|
||||
#ifndef outw
|
||||
#define outw(val,p) (*(volatile u16*)(p) = (val))
|
||||
#endif
|
||||
|
||||
#ifndef inl
|
||||
#define inl(p) (*(volatile u32*)(p))
|
||||
#endif
|
||||
|
||||
#ifndef outl
|
||||
#define outl(val,p) (*(volatile u32*)(p) = (val))
|
||||
#endif
|
||||
|
||||
#ifndef insw
|
||||
#define insw(p,to,len) mmio_insw(p,to,len)
|
||||
#endif
|
||||
|
||||
#ifndef outsw
|
||||
#define outsw(p,from,len) mmio_outsw(p,from,len)
|
||||
#endif
|
||||
|
||||
#ifndef insb
|
||||
#define insb(p,to,len) mmio_insb(p,to,len)
|
||||
#endif
|
||||
|
||||
#ifndef mmio_insw
|
||||
#define mmio_insw(r,b,l) ({ int __i ; \
|
||||
u16 *__b2; \
|
||||
__b2 = (u16 *) b; \
|
||||
for (__i = 0; __i < l; __i++) { \
|
||||
*(__b2 + __i) = inw(r); \
|
||||
}; \
|
||||
})
|
||||
#endif
|
||||
|
||||
#ifndef mmio_outsw
|
||||
#define mmio_outsw(r,b,l) ({ int __i; \
|
||||
u16 *__b2; \
|
||||
__b2 = (u16 *) b; \
|
||||
for (__i = 0; __i < l; __i++) { \
|
||||
outw( *(__b2 + __i), r); \
|
||||
} \
|
||||
})
|
||||
#endif
|
||||
|
||||
#ifndef mmio_insb
|
||||
#define mmio_insb(r,b,l) ({ int __i ; \
|
||||
u8 *__b2; \
|
||||
__b2 = (u8 *) b; \
|
||||
for (__i = 0; __i < l; __i++) { \
|
||||
*(__b2 + __i) = inb(r); \
|
||||
}; \
|
||||
})
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Structure member address manipulation macros.
|
||||
* These are used by client code (code using the urb_link routines), since
|
||||
* the urb_link structure is embedded in the client data structures.
|
||||
*
|
||||
* Note: a macro offsetof equivalent to member_offset is defined in stddef.h
|
||||
* but this is kept here for the sake of portability.
|
||||
*
|
||||
* p2surround returns a pointer to the surrounding structure given
|
||||
* type of the surrounding structure, the name memb of the structure
|
||||
* member pointed at by ptr. For example, if you have:
|
||||
*
|
||||
* struct foo {
|
||||
* int x;
|
||||
* float y;
|
||||
* char z;
|
||||
* } thingy;
|
||||
*
|
||||
* char *cp = &thingy.z;
|
||||
*
|
||||
* then
|
||||
*
|
||||
* &thingy == p2surround(struct foo, z, cp)
|
||||
*
|
||||
* Clear?
|
||||
*/
|
||||
#define _cv_(ptr) ((char*)(void*)(ptr))
|
||||
#define member_offset(type,memb) (_cv_(&(((type*)0)->memb))-(char*)0)
|
||||
#define p2surround(type,memb,ptr) ((type*)(void*)(_cv_(ptr)-member_offset(type,memb)))
|
||||
|
||||
struct urb;
|
||||
|
||||
struct usb_endpoint_instance;
|
||||
struct usb_interface_instance;
|
||||
struct usb_configuration_instance;
|
||||
struct usb_device_instance;
|
||||
struct usb_bus_instance;
|
||||
|
||||
/*
|
||||
* Device and/or Interface Class codes
|
||||
*/
|
||||
#define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */
|
||||
#define USB_CLASS_AUDIO 1
|
||||
#define USB_CLASS_COMM 2
|
||||
#define USB_CLASS_HID 3
|
||||
#define USB_CLASS_PHYSICAL 5
|
||||
#define USB_CLASS_PRINTER 7
|
||||
#define USB_CLASS_MASS_STORAGE 8
|
||||
#define USB_CLASS_HUB 9
|
||||
#define USB_CLASS_DATA 10
|
||||
#define USB_CLASS_APP_SPEC 0xfe
|
||||
#define USB_CLASS_VENDOR_SPEC 0xff
|
||||
|
||||
/*
|
||||
* USB types
|
||||
*/
|
||||
#define USB_TYPE_STANDARD (0x00 << 5)
|
||||
#define USB_TYPE_CLASS (0x01 << 5)
|
||||
#define USB_TYPE_VENDOR (0x02 << 5)
|
||||
#define USB_TYPE_RESERVED (0x03 << 5)
|
||||
|
||||
/*
|
||||
* USB recipients
|
||||
*/
|
||||
#define USB_RECIP_DEVICE 0x00
|
||||
#define USB_RECIP_INTERFACE 0x01
|
||||
#define USB_RECIP_ENDPOINT 0x02
|
||||
#define USB_RECIP_OTHER 0x03
|
||||
|
||||
/*
|
||||
* USB directions
|
||||
*/
|
||||
#define USB_DIR_OUT 0
|
||||
#define USB_DIR_IN 0x80
|
||||
|
||||
/*
|
||||
* Descriptor types
|
||||
*/
|
||||
#define USB_DT_DEVICE 0x01
|
||||
#define USB_DT_CONFIG 0x02
|
||||
#define USB_DT_STRING 0x03
|
||||
#define USB_DT_INTERFACE 0x04
|
||||
#define USB_DT_ENDPOINT 0x05
|
||||
|
||||
#if defined(CONFIG_USBD_HS)
|
||||
#define USB_DT_QUAL 0x06
|
||||
#endif
|
||||
|
||||
#define USB_DT_HID (USB_TYPE_CLASS | 0x01)
|
||||
#define USB_DT_REPORT (USB_TYPE_CLASS | 0x02)
|
||||
#define USB_DT_PHYSICAL (USB_TYPE_CLASS | 0x03)
|
||||
#define USB_DT_HUB (USB_TYPE_CLASS | 0x09)
|
||||
|
||||
/*
|
||||
* Descriptor sizes per descriptor type
|
||||
*/
|
||||
#define USB_DT_DEVICE_SIZE 18
|
||||
#define USB_DT_CONFIG_SIZE 9
|
||||
#define USB_DT_INTERFACE_SIZE 9
|
||||
#define USB_DT_ENDPOINT_SIZE 7
|
||||
#define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */
|
||||
#define USB_DT_HUB_NONVAR_SIZE 7
|
||||
#define USB_DT_HID_SIZE 9
|
||||
|
||||
/*
|
||||
* Endpoints
|
||||
*/
|
||||
#define USB_ENDPOINT_NUMBER_MASK 0x0f /* in bEndpointAddress */
|
||||
#define USB_ENDPOINT_DIR_MASK 0x80
|
||||
|
||||
#define USB_ENDPOINT_XFERTYPE_MASK 0x03 /* in bmAttributes */
|
||||
#define USB_ENDPOINT_XFER_CONTROL 0
|
||||
#define USB_ENDPOINT_XFER_ISOC 1
|
||||
#define USB_ENDPOINT_XFER_BULK 2
|
||||
#define USB_ENDPOINT_XFER_INT 3
|
||||
|
||||
/*
|
||||
* USB Packet IDs (PIDs)
|
||||
*/
|
||||
#define USB_PID_UNDEF_0 0xf0
|
||||
#define USB_PID_OUT 0xe1
|
||||
#define USB_PID_ACK 0xd2
|
||||
#define USB_PID_DATA0 0xc3
|
||||
#define USB_PID_PING 0xb4 /* USB 2.0 */
|
||||
#define USB_PID_SOF 0xa5
|
||||
#define USB_PID_NYET 0x96 /* USB 2.0 */
|
||||
#define USB_PID_DATA2 0x87 /* USB 2.0 */
|
||||
#define USB_PID_SPLIT 0x78 /* USB 2.0 */
|
||||
#define USB_PID_IN 0x69
|
||||
#define USB_PID_NAK 0x5a
|
||||
#define USB_PID_DATA1 0x4b
|
||||
#define USB_PID_PREAMBLE 0x3c /* Token mode */
|
||||
#define USB_PID_ERR 0x3c /* USB 2.0: handshake mode */
|
||||
#define USB_PID_SETUP 0x2d
|
||||
#define USB_PID_STALL 0x1e
|
||||
#define USB_PID_MDATA 0x0f /* USB 2.0 */
|
||||
|
||||
/*
|
||||
* Standard requests
|
||||
*/
|
||||
#define USB_REQ_GET_STATUS 0x00
|
||||
#define USB_REQ_CLEAR_FEATURE 0x01
|
||||
#define USB_REQ_SET_FEATURE 0x03
|
||||
#define USB_REQ_SET_ADDRESS 0x05
|
||||
#define USB_REQ_GET_DESCRIPTOR 0x06
|
||||
#define USB_REQ_SET_DESCRIPTOR 0x07
|
||||
#define USB_REQ_GET_CONFIGURATION 0x08
|
||||
#define USB_REQ_SET_CONFIGURATION 0x09
|
||||
#define USB_REQ_GET_INTERFACE 0x0A
|
||||
#define USB_REQ_SET_INTERFACE 0x0B
|
||||
#define USB_REQ_SYNCH_FRAME 0x0C
|
||||
|
||||
#define USBD_DEVICE_REQUESTS(x) (((unsigned int)x <= USB_REQ_SYNCH_FRAME) ? usbd_device_requests[x] : "UNKNOWN")
|
||||
|
||||
/*
|
||||
* HID requests
|
||||
*/
|
||||
#define USB_REQ_GET_REPORT 0x01
|
||||
#define USB_REQ_GET_IDLE 0x02
|
||||
#define USB_REQ_GET_PROTOCOL 0x03
|
||||
#define USB_REQ_SET_REPORT 0x09
|
||||
#define USB_REQ_SET_IDLE 0x0A
|
||||
#define USB_REQ_SET_PROTOCOL 0x0B
|
||||
|
||||
|
||||
/*
|
||||
* USB Spec Release number
|
||||
*/
|
||||
|
||||
#if defined(CONFIG_USBD_HS)
|
||||
#define USB_BCD_VERSION 0x0200
|
||||
#else
|
||||
#define USB_BCD_VERSION 0x0110
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Device Requests (c.f Table 9-2)
|
||||
*/
|
||||
|
||||
#define USB_REQ_DIRECTION_MASK 0x80
|
||||
#define USB_REQ_TYPE_MASK 0x60
|
||||
#define USB_REQ_RECIPIENT_MASK 0x1f
|
||||
|
||||
#define USB_REQ_DEVICE2HOST 0x80
|
||||
#define USB_REQ_HOST2DEVICE 0x00
|
||||
|
||||
#define USB_REQ_TYPE_STANDARD 0x00
|
||||
#define USB_REQ_TYPE_CLASS 0x20
|
||||
#define USB_REQ_TYPE_VENDOR 0x40
|
||||
|
||||
#define USB_REQ_RECIPIENT_DEVICE 0x00
|
||||
#define USB_REQ_RECIPIENT_INTERFACE 0x01
|
||||
#define USB_REQ_RECIPIENT_ENDPOINT 0x02
|
||||
#define USB_REQ_RECIPIENT_OTHER 0x03
|
||||
|
||||
/*
|
||||
* get status bits
|
||||
*/
|
||||
|
||||
#define USB_STATUS_SELFPOWERED 0x01
|
||||
#define USB_STATUS_REMOTEWAKEUP 0x02
|
||||
|
||||
#define USB_STATUS_HALT 0x01
|
||||
|
||||
/*
|
||||
* descriptor types
|
||||
*/
|
||||
|
||||
#define USB_DESCRIPTOR_TYPE_DEVICE 0x01
|
||||
#define USB_DESCRIPTOR_TYPE_CONFIGURATION 0x02
|
||||
#define USB_DESCRIPTOR_TYPE_STRING 0x03
|
||||
#define USB_DESCRIPTOR_TYPE_INTERFACE 0x04
|
||||
#define USB_DESCRIPTOR_TYPE_ENDPOINT 0x05
|
||||
#define USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER 0x06
|
||||
#define USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION 0x07
|
||||
#define USB_DESCRIPTOR_TYPE_INTERFACE_POWER 0x08
|
||||
#define USB_DESCRIPTOR_TYPE_HID 0x21
|
||||
#define USB_DESCRIPTOR_TYPE_REPORT 0x22
|
||||
|
||||
#define USBD_DEVICE_DESCRIPTORS(x) (((unsigned int)x <= USB_DESCRIPTOR_TYPE_INTERFACE_POWER) ? \
|
||||
usbd_device_descriptors[x] : "UNKNOWN")
|
||||
|
||||
/*
|
||||
* standard feature selectors
|
||||
*/
|
||||
#define USB_ENDPOINT_HALT 0x00
|
||||
#define USB_DEVICE_REMOTE_WAKEUP 0x01
|
||||
#define USB_TEST_MODE 0x02
|
||||
|
||||
|
||||
/* USB Requests
|
||||
*
|
||||
*/
|
||||
|
||||
struct usb_device_request {
|
||||
u8 bmRequestType;
|
||||
u8 bRequest;
|
||||
u16 wValue;
|
||||
u16 wIndex;
|
||||
u16 wLength;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
|
||||
/* USB Status
|
||||
*
|
||||
*/
|
||||
typedef enum urb_send_status {
|
||||
SEND_IN_PROGRESS,
|
||||
SEND_FINISHED_OK,
|
||||
SEND_FINISHED_ERROR,
|
||||
RECV_READY,
|
||||
RECV_OK,
|
||||
RECV_ERROR
|
||||
} urb_send_status_t;
|
||||
|
||||
/*
|
||||
* Device State (c.f USB Spec 2.0 Figure 9-1)
|
||||
*
|
||||
* What state the usb device is in.
|
||||
*
|
||||
* Note the state does not change if the device is suspended, we simply set a
|
||||
* flag to show that it is suspended.
|
||||
*
|
||||
*/
|
||||
typedef enum usb_device_state {
|
||||
STATE_INIT, /* just initialized */
|
||||
STATE_CREATED, /* just created */
|
||||
STATE_ATTACHED, /* we are attached */
|
||||
STATE_POWERED, /* we have seen power indication (electrical bus signal) */
|
||||
STATE_DEFAULT, /* we been reset */
|
||||
STATE_ADDRESSED, /* we have been addressed (in default configuration) */
|
||||
STATE_CONFIGURED, /* we have seen a set configuration device command */
|
||||
STATE_UNKNOWN, /* destroyed */
|
||||
} usb_device_state_t;
|
||||
|
||||
#define USBD_DEVICE_STATE(x) (((unsigned int)x <= STATE_UNKNOWN) ? usbd_device_states[x] : "UNKNOWN")
|
||||
|
||||
/*
|
||||
* Device status
|
||||
*
|
||||
* Overall state
|
||||
*/
|
||||
typedef enum usb_device_status {
|
||||
USBD_OPENING, /* we are currently opening */
|
||||
USBD_OK, /* ok to use */
|
||||
USBD_SUSPENDED, /* we are currently suspended */
|
||||
USBD_CLOSING, /* we are currently closing */
|
||||
} usb_device_status_t;
|
||||
|
||||
#define USBD_DEVICE_STATUS(x) (((unsigned int)x <= USBD_CLOSING) ? usbd_device_status[x] : "UNKNOWN")
|
||||
|
||||
/*
|
||||
* Device Events
|
||||
*
|
||||
* These are defined in the USB Spec (c.f USB Spec 2.0 Figure 9-1).
|
||||
*
|
||||
* There are additional events defined to handle some extra actions we need
|
||||
* to have handled.
|
||||
*
|
||||
*/
|
||||
typedef enum usb_device_event {
|
||||
|
||||
DEVICE_UNKNOWN, /* bi - unknown event */
|
||||
DEVICE_INIT, /* bi - initialize */
|
||||
DEVICE_CREATE, /* bi - */
|
||||
DEVICE_HUB_CONFIGURED, /* bi - bus has been plugged int */
|
||||
DEVICE_RESET, /* bi - hub has powered our port */
|
||||
|
||||
DEVICE_ADDRESS_ASSIGNED, /* ep0 - set address setup received */
|
||||
DEVICE_CONFIGURED, /* ep0 - set configure setup received */
|
||||
DEVICE_SET_INTERFACE, /* ep0 - set interface setup received */
|
||||
|
||||
DEVICE_SET_FEATURE, /* ep0 - set feature setup received */
|
||||
DEVICE_CLEAR_FEATURE, /* ep0 - clear feature setup received */
|
||||
|
||||
DEVICE_DE_CONFIGURED, /* ep0 - set configure setup received for ?? */
|
||||
|
||||
DEVICE_BUS_INACTIVE, /* bi - bus in inactive (no SOF packets) */
|
||||
DEVICE_BUS_ACTIVITY, /* bi - bus is active again */
|
||||
|
||||
DEVICE_POWER_INTERRUPTION, /* bi - hub has depowered our port */
|
||||
DEVICE_HUB_RESET, /* bi - bus has been unplugged */
|
||||
DEVICE_DESTROY, /* bi - device instance should be destroyed */
|
||||
|
||||
DEVICE_HOTPLUG, /* bi - a hotplug event has occurred */
|
||||
|
||||
DEVICE_FUNCTION_PRIVATE, /* function - private */
|
||||
|
||||
} usb_device_event_t;
|
||||
|
||||
|
||||
typedef struct urb_link {
|
||||
struct urb_link *next;
|
||||
struct urb_link *prev;
|
||||
} urb_link;
|
||||
|
||||
/* USB Data structure - for passing data around.
|
||||
*
|
||||
* This is used for both sending and receiving data.
|
||||
*
|
||||
* The callback function is used to let the function driver know when
|
||||
* transmitted data has been sent.
|
||||
*
|
||||
* The callback function is set by the alloc_recv function when an urb is
|
||||
* allocated for receiving data for an endpoint and used to call the
|
||||
* function driver to inform it that data has arrived.
|
||||
*/
|
||||
|
||||
/* in linux we'd malloc this, but in u-boot we prefer static data */
|
||||
#define URB_BUF_SIZE 512
|
||||
|
||||
struct urb {
|
||||
|
||||
struct usb_endpoint_instance *endpoint;
|
||||
struct usb_device_instance *device;
|
||||
|
||||
struct usb_device_request device_request; /* contents of received SETUP packet */
|
||||
|
||||
struct urb_link link; /* embedded struct for circular doubly linked list of urbs */
|
||||
|
||||
u8* buffer;
|
||||
unsigned int buffer_length;
|
||||
unsigned int actual_length;
|
||||
|
||||
urb_send_status_t status;
|
||||
int data;
|
||||
|
||||
u16 buffer_data[URB_BUF_SIZE]; /* data received (OUT) or being sent (IN) */
|
||||
};
|
||||
|
||||
/* Endpoint configuration
|
||||
*
|
||||
* Per endpoint configuration data. Used to track which function driver owns
|
||||
* an endpoint.
|
||||
*
|
||||
*/
|
||||
struct usb_endpoint_instance {
|
||||
int endpoint_address; /* logical endpoint address */
|
||||
|
||||
/* control */
|
||||
int status; /* halted */
|
||||
int state; /* available for use by bus interface driver */
|
||||
|
||||
/* receive side */
|
||||
struct urb_link rcv; /* received urbs */
|
||||
struct urb_link rdy; /* empty urbs ready to receive */
|
||||
struct urb *rcv_urb; /* active urb */
|
||||
int rcv_attributes; /* copy of bmAttributes from endpoint descriptor */
|
||||
int rcv_packetSize; /* maximum packet size from endpoint descriptor */
|
||||
int rcv_transferSize; /* maximum transfer size from function driver */
|
||||
int rcv_queue;
|
||||
|
||||
/* transmit side */
|
||||
struct urb_link tx; /* urbs ready to transmit */
|
||||
struct urb_link done; /* transmitted urbs */
|
||||
struct urb *tx_urb; /* active urb */
|
||||
int tx_attributes; /* copy of bmAttributes from endpoint descriptor */
|
||||
int tx_packetSize; /* maximum packet size from endpoint descriptor */
|
||||
int tx_transferSize; /* maximum transfer size from function driver */
|
||||
int tx_queue;
|
||||
|
||||
int sent; /* data already sent */
|
||||
int last; /* data sent in last packet XXX do we need this */
|
||||
};
|
||||
|
||||
struct usb_alternate_instance {
|
||||
struct usb_interface_descriptor *interface_descriptor;
|
||||
|
||||
int endpoints;
|
||||
int *endpoint_transfersize_array;
|
||||
struct usb_endpoint_descriptor **endpoints_descriptor_array;
|
||||
};
|
||||
|
||||
struct usb_interface_instance {
|
||||
int alternates;
|
||||
struct usb_alternate_instance *alternates_instance_array;
|
||||
};
|
||||
|
||||
struct usb_configuration_instance {
|
||||
int interfaces;
|
||||
struct usb_configuration_descriptor *configuration_descriptor;
|
||||
struct usb_interface_instance *interface_instance_array;
|
||||
};
|
||||
|
||||
|
||||
/* USB Device Instance
|
||||
*
|
||||
* For each physical bus interface we create a logical device structure. This
|
||||
* tracks all of the required state to track the USB HOST's view of the device.
|
||||
*
|
||||
* Keep track of the device configuration for a real physical bus interface,
|
||||
* this includes the bus interface, multiple function drivers, the current
|
||||
* configuration and the current state.
|
||||
*
|
||||
* This will show:
|
||||
* the specific bus interface driver
|
||||
* the default endpoint 0 driver
|
||||
* the configured function driver
|
||||
* device state
|
||||
* device status
|
||||
* endpoint list
|
||||
*/
|
||||
|
||||
struct usb_device_instance {
|
||||
|
||||
/* generic */
|
||||
char *name;
|
||||
struct usb_device_descriptor *device_descriptor; /* per device descriptor */
|
||||
#if defined(CONFIG_USBD_HS)
|
||||
struct usb_qualifier_descriptor *qualifier_descriptor;
|
||||
#endif
|
||||
|
||||
void (*event) (struct usb_device_instance *device, usb_device_event_t event, int data);
|
||||
|
||||
/* Do cdc device specific control requests */
|
||||
int (*cdc_recv_setup)(struct usb_device_request *request, struct urb *urb);
|
||||
|
||||
/* bus interface */
|
||||
struct usb_bus_instance *bus; /* which bus interface driver */
|
||||
|
||||
/* configuration descriptors */
|
||||
int configurations;
|
||||
struct usb_configuration_instance *configuration_instance_array;
|
||||
|
||||
/* device state */
|
||||
usb_device_state_t device_state; /* current USB Device state */
|
||||
usb_device_state_t device_previous_state; /* current USB Device state */
|
||||
|
||||
u8 address; /* current address (zero is default) */
|
||||
u8 configuration; /* current show configuration (zero is default) */
|
||||
u8 interface; /* current interface (zero is default) */
|
||||
u8 alternate; /* alternate flag */
|
||||
|
||||
usb_device_status_t status; /* device status */
|
||||
|
||||
int urbs_queued; /* number of submitted urbs */
|
||||
|
||||
/* Shouldn't need to make this atomic, all we need is a change indicator */
|
||||
unsigned long usbd_rxtx_timestamp;
|
||||
unsigned long usbd_last_rxtx_timestamp;
|
||||
|
||||
};
|
||||
|
||||
/* Bus Interface configuration structure
|
||||
*
|
||||
* This is allocated for each configured instance of a bus interface driver.
|
||||
*
|
||||
* The privdata pointer may be used by the bus interface driver to store private
|
||||
* per instance state information.
|
||||
*/
|
||||
struct usb_bus_instance {
|
||||
|
||||
struct usb_device_instance *device;
|
||||
struct usb_endpoint_instance *endpoint_array; /* array of available configured endpoints */
|
||||
|
||||
int max_endpoints; /* maximimum number of rx enpoints */
|
||||
unsigned char maxpacketsize;
|
||||
|
||||
unsigned int serial_number;
|
||||
char *serial_number_str;
|
||||
void *privdata; /* private data for the bus interface */
|
||||
|
||||
};
|
||||
|
||||
extern char *usbd_device_events[];
|
||||
extern char *usbd_device_states[];
|
||||
extern char *usbd_device_status[];
|
||||
extern char *usbd_device_requests[];
|
||||
extern char *usbd_device_descriptors[];
|
||||
|
||||
void urb_link_init (urb_link * ul);
|
||||
void urb_detach (struct urb *urb);
|
||||
urb_link *first_urb_link (urb_link * hd);
|
||||
struct urb *first_urb (urb_link * hd);
|
||||
struct urb *first_urb_detached (urb_link * hd);
|
||||
void urb_append (urb_link * hd, struct urb *urb);
|
||||
|
||||
struct urb *usbd_alloc_urb (struct usb_device_instance *device, struct usb_endpoint_instance *endpoint);
|
||||
void usbd_dealloc_urb (struct urb *urb);
|
||||
|
||||
/*
|
||||
* usbd_device_event is used by bus interface drivers to tell the higher layers that
|
||||
* certain events have taken place.
|
||||
*/
|
||||
void usbd_device_event_irq (struct usb_device_instance *conf, usb_device_event_t, int);
|
||||
void usbd_device_event (struct usb_device_instance *conf, usb_device_event_t, int);
|
||||
|
||||
/* descriptors
|
||||
*
|
||||
* Various ways of finding descriptors based on the current device and any
|
||||
* possible configuration / interface / endpoint for it.
|
||||
*/
|
||||
struct usb_configuration_descriptor *usbd_device_configuration_descriptor (struct usb_device_instance *, int, int);
|
||||
struct usb_function_instance *usbd_device_function_instance (struct usb_device_instance *, unsigned int);
|
||||
struct usb_interface_instance *usbd_device_interface_instance (struct usb_device_instance *, int, int, int);
|
||||
struct usb_alternate_instance *usbd_device_alternate_instance (struct usb_device_instance *, int, int, int, int);
|
||||
struct usb_interface_descriptor *usbd_device_interface_descriptor (struct usb_device_instance *, int, int, int, int);
|
||||
struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor_index (struct usb_device_instance *, int, int, int, int, int);
|
||||
struct usb_class_descriptor *usbd_device_class_descriptor_index (struct usb_device_instance *, int, int, int, int, int);
|
||||
struct usb_class_report_descriptor *usbd_device_class_report_descriptor_index( struct usb_device_instance *, int , int , int , int , int );
|
||||
struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor (struct usb_device_instance *, int, int, int, int, int);
|
||||
int usbd_device_endpoint_transfersize (struct usb_device_instance *, int, int, int, int, int);
|
||||
struct usb_string_descriptor *usbd_get_string (u8);
|
||||
struct usb_device_descriptor *usbd_device_device_descriptor(struct
|
||||
usb_device_instance *, int);
|
||||
|
||||
#if defined(CONFIG_USBD_HS)
|
||||
/*
|
||||
* is_usbd_high_speed routine needs to be defined by specific gadget driver
|
||||
* It returns true if device enumerates at High speed
|
||||
* Retuns false otherwise
|
||||
*/
|
||||
int is_usbd_high_speed(void);
|
||||
#endif
|
||||
int usbd_endpoint_halted (struct usb_device_instance *device, int endpoint);
|
||||
void usbd_rcv_complete(struct usb_endpoint_instance *endpoint, int len, int urb_bad);
|
||||
void usbd_tx_complete (struct usb_endpoint_instance *endpoint);
|
||||
|
||||
/* These are macros used in debugging */
|
||||
#ifdef DEBUG
|
||||
static inline void print_urb(struct urb *u)
|
||||
{
|
||||
serial_printf("urb %p\n", (u));
|
||||
serial_printf("\tendpoint %p\n", u->endpoint);
|
||||
serial_printf("\tdevice %p\n", u->device);
|
||||
serial_printf("\tbuffer %p\n", u->buffer);
|
||||
serial_printf("\tbuffer_length %d\n", u->buffer_length);
|
||||
serial_printf("\tactual_length %d\n", u->actual_length);
|
||||
serial_printf("\tstatus %d\n", u->status);
|
||||
serial_printf("\tdata %d\n", u->data);
|
||||
}
|
||||
|
||||
static inline void print_usb_device_request(struct usb_device_request *r)
|
||||
{
|
||||
serial_printf("usb request\n");
|
||||
serial_printf("\tbmRequestType 0x%2.2x\n", r->bmRequestType);
|
||||
if ((r->bmRequestType & USB_REQ_DIRECTION_MASK) == 0)
|
||||
serial_printf("\t\tDirection : To device\n");
|
||||
else
|
||||
serial_printf("\t\tDirection : To host\n");
|
||||
if ((r->bmRequestType & USB_TYPE_STANDARD) == USB_TYPE_STANDARD)
|
||||
serial_printf("\t\tType : Standard\n");
|
||||
if ((r->bmRequestType & USB_TYPE_CLASS) == USB_TYPE_CLASS)
|
||||
serial_printf("\t\tType : Standard\n");
|
||||
if ((r->bmRequestType & USB_TYPE_VENDOR) == USB_TYPE_VENDOR)
|
||||
serial_printf("\t\tType : Standard\n");
|
||||
if ((r->bmRequestType & USB_TYPE_RESERVED) == USB_TYPE_RESERVED)
|
||||
serial_printf("\t\tType : Standard\n");
|
||||
if ((r->bmRequestType & USB_REQ_RECIPIENT_MASK) ==
|
||||
USB_REQ_RECIPIENT_DEVICE)
|
||||
serial_printf("\t\tRecipient : Device\n");
|
||||
if ((r->bmRequestType & USB_REQ_RECIPIENT_MASK) ==
|
||||
USB_REQ_RECIPIENT_INTERFACE)
|
||||
serial_printf("\t\tRecipient : Interface\n");
|
||||
if ((r->bmRequestType & USB_REQ_RECIPIENT_MASK) ==
|
||||
USB_REQ_RECIPIENT_ENDPOINT)
|
||||
serial_printf("\t\tRecipient : Endpoint\n");
|
||||
if ((r->bmRequestType & USB_REQ_RECIPIENT_MASK) ==
|
||||
USB_REQ_RECIPIENT_OTHER)
|
||||
serial_printf("\t\tRecipient : Other\n");
|
||||
serial_printf("\tbRequest 0x%2.2x\n", r->bRequest);
|
||||
if (r->bRequest == USB_REQ_GET_STATUS)
|
||||
serial_printf("\t\tGET_STATUS\n");
|
||||
else if (r->bRequest == USB_REQ_SET_ADDRESS)
|
||||
serial_printf("\t\tSET_ADDRESS\n");
|
||||
else if (r->bRequest == USB_REQ_SET_FEATURE)
|
||||
serial_printf("\t\tSET_FEATURE\n");
|
||||
else if (r->bRequest == USB_REQ_GET_DESCRIPTOR)
|
||||
serial_printf("\t\tGET_DESCRIPTOR\n");
|
||||
else if (r->bRequest == USB_REQ_SET_CONFIGURATION)
|
||||
serial_printf("\t\tSET_CONFIGURATION\n");
|
||||
else if (r->bRequest == USB_REQ_SET_INTERFACE)
|
||||
serial_printf("\t\tUSB_REQ_SET_INTERFACE\n");
|
||||
else
|
||||
serial_printf("\tUNKNOWN %d\n", r->bRequest);
|
||||
serial_printf("\twValue 0x%4.4x\n", r->wValue);
|
||||
if (r->bRequest == USB_REQ_GET_DESCRIPTOR) {
|
||||
switch (r->wValue >> 8) {
|
||||
case USB_DESCRIPTOR_TYPE_DEVICE:
|
||||
serial_printf("\tDEVICE\n");
|
||||
break;
|
||||
case USB_DESCRIPTOR_TYPE_CONFIGURATION:
|
||||
serial_printf("\tCONFIGURATION\n");
|
||||
break;
|
||||
case USB_DESCRIPTOR_TYPE_STRING:
|
||||
serial_printf("\tSTRING\n");
|
||||
break;
|
||||
case USB_DESCRIPTOR_TYPE_INTERFACE:
|
||||
serial_printf("\tINTERFACE\n");
|
||||
break;
|
||||
case USB_DESCRIPTOR_TYPE_ENDPOINT:
|
||||
serial_printf("\tENDPOINT\n");
|
||||
break;
|
||||
case USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER:
|
||||
serial_printf("\tDEVICE_QUALIFIER\n");
|
||||
break;
|
||||
case USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION:
|
||||
serial_printf("\tOTHER_SPEED_CONFIGURATION\n");
|
||||
break;
|
||||
case USB_DESCRIPTOR_TYPE_INTERFACE_POWER:
|
||||
serial_printf("\tINTERFACE_POWER\n");
|
||||
break;
|
||||
case USB_DESCRIPTOR_TYPE_HID:
|
||||
serial_printf("\tHID\n");
|
||||
break;
|
||||
case USB_DESCRIPTOR_TYPE_REPORT:
|
||||
serial_printf("\tREPORT\n");
|
||||
break;
|
||||
default:
|
||||
serial_printf("\tUNKNOWN TYPE\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
serial_printf("\twIndex 0x%4.4x\n", r->wIndex);
|
||||
serial_printf("\twLength 0x%4.4x\n", r->wLength);
|
||||
}
|
||||
#else
|
||||
/* stubs */
|
||||
#define print_urb(u)
|
||||
#define print_usb_device_request(r)
|
||||
#endif /* DEBUG */
|
||||
#endif
|
||||
@ -0,0 +1,128 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* USB virtual root hub descriptors
|
||||
*
|
||||
* (C) Copyright 2014
|
||||
* Stephen Warren swarren@wwwdotorg.org
|
||||
*
|
||||
* Based on ohci-hcd.c
|
||||
*/
|
||||
|
||||
#ifndef __USBROOTHUBDES_H__
|
||||
#define __USBROOTHUBDES_H__
|
||||
|
||||
/* Device descriptor */
|
||||
static __u8 root_hub_dev_des[] = {
|
||||
0x12, /* __u8 bLength; */
|
||||
0x01, /* __u8 bDescriptorType; Device */
|
||||
0x10, /* __u16 bcdUSB; v1.1 */
|
||||
0x01,
|
||||
0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
|
||||
0x00, /* __u8 bDeviceSubClass; */
|
||||
0x00, /* __u8 bDeviceProtocol; */
|
||||
0x08, /* __u8 bMaxPacketSize0; 8 Bytes */
|
||||
0x00, /* __u16 idVendor; */
|
||||
0x00,
|
||||
0x00, /* __u16 idProduct; */
|
||||
0x00,
|
||||
0x00, /* __u16 bcdDevice; */
|
||||
0x00,
|
||||
0x00, /* __u8 iManufacturer; */
|
||||
0x01, /* __u8 iProduct; */
|
||||
0x00, /* __u8 iSerialNumber; */
|
||||
0x01, /* __u8 bNumConfigurations; */
|
||||
};
|
||||
|
||||
/* Configuration descriptor */
|
||||
static __u8 root_hub_config_des[] = {
|
||||
0x09, /* __u8 bLength; */
|
||||
0x02, /* __u8 bDescriptorType; Configuration */
|
||||
0x19, /* __u16 wTotalLength; */
|
||||
0x00,
|
||||
0x01, /* __u8 bNumInterfaces; */
|
||||
0x01, /* __u8 bConfigurationValue; */
|
||||
0x00, /* __u8 iConfiguration; */
|
||||
0x40, /* __u8 bmAttributes;
|
||||
* Bit 7: Bus-powered
|
||||
* 6: Self-powered,
|
||||
* 5 Remote-wakwup,
|
||||
* 4..0: resvd
|
||||
*/
|
||||
0x00, /* __u8 MaxPower; */
|
||||
/* interface */
|
||||
0x09, /* __u8 if_bLength; */
|
||||
0x04, /* __u8 if_bDescriptorType; Interface */
|
||||
0x00, /* __u8 if_bInterfaceNumber; */
|
||||
0x00, /* __u8 if_bAlternateSetting; */
|
||||
0x01, /* __u8 if_bNumEndpoints; */
|
||||
0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
|
||||
0x00, /* __u8 if_bInterfaceSubClass; */
|
||||
0x00, /* __u8 if_bInterfaceProtocol; */
|
||||
0x00, /* __u8 if_iInterface; */
|
||||
/* endpoint */
|
||||
0x07, /* __u8 ep_bLength; */
|
||||
0x05, /* __u8 ep_bDescriptorType; Endpoint */
|
||||
0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
|
||||
0x03, /* __u8 ep_bmAttributes; Interrupt */
|
||||
0x02, /* __u16 ep_wMaxPacketSize; ((MAX_ROOT_PORTS + 1) / 8 */
|
||||
0x00,
|
||||
0xff, /* __u8 ep_bInterval; 255 ms */
|
||||
};
|
||||
|
||||
#ifdef WANT_USB_ROOT_HUB_HUB_DES
|
||||
static unsigned char root_hub_hub_des[] = {
|
||||
0x09, /* __u8 bLength; */
|
||||
0x29, /* __u8 bDescriptorType; Hub-descriptor */
|
||||
0x02, /* __u8 bNbrPorts; */
|
||||
0x00, /* __u16 wHubCharacteristics; */
|
||||
0x00,
|
||||
0x01, /* __u8 bPwrOn2pwrGood; 2ms */
|
||||
0x00, /* __u8 bHubContrCurrent; 0 mA */
|
||||
0x00, /* __u8 DeviceRemovable; *** 7 Ports max *** */
|
||||
0xff, /* __u8 PortPwrCtrlMask; *** 7 ports max *** */
|
||||
};
|
||||
#endif
|
||||
|
||||
static unsigned char root_hub_str_index0[] = {
|
||||
0x04, /* __u8 bLength; */
|
||||
0x03, /* __u8 bDescriptorType; String-descriptor */
|
||||
0x09, /* __u8 lang ID */
|
||||
0x04, /* __u8 lang ID */
|
||||
};
|
||||
|
||||
static unsigned char root_hub_str_index1[] = {
|
||||
32, /* __u8 bLength; */
|
||||
0x03, /* __u8 bDescriptorType; String-descriptor */
|
||||
'U', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
'-', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
'B', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
'o', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
'o', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
't', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
' ', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
'R', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
'o', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
'o', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
't', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
' ', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
'H', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
'u', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
'b', /* __u8 Unicode */
|
||||
0, /* __u8 Unicode */
|
||||
};
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user