Adapt the usb-compat.h to uBoot.
Use #ifndef __UBOOT__ for code that is not applicable to uBoot. Use #ifdef __UBOOT__ to add code that is uBoot specific.
Create linux-compat.h - Linux kernel compatibility definitions that do not exist in the uBoot. Moved the compatibility definitions from lin_gadget_compat.h to this file as well.
Create usb-mod-devicetable.h - Is a partial back port of mod_devicetable.h in the linux kernel only taking the portion needed for USB
Already existing header files were modified to pick up the new header files.
Currently musb will not compile.
Signed-off-by: Dan Murphy dmurphy@ti.com --- drivers/usb/musb-new/musb_host.h | 1 + drivers/usb/musb-new/usb-compat.h | 30 ---- include/linux/usb/gadget.h | 184 +++++++++++++++++++----- include/linux/usb/linux-compat.h | 233 +++++++++++++++++++++++++++++++ include/linux/usb/usb-compat.h | 186 +++++++++++++++++++++--- include/linux/usb/usb-mod-devicetable.h | 131 +++++++++++++++++ include/usb.h | 119 +--------------- include/usb/lin_gadget_compat.h | 29 +--- 8 files changed, 684 insertions(+), 229 deletions(-) create mode 100644 include/linux/usb/linux-compat.h create mode 100644 include/linux/usb/usb-mod-devicetable.h
diff --git a/drivers/usb/musb-new/musb_host.h b/drivers/usb/musb-new/musb_host.h index ebebe0c..49cb094 100644 --- a/drivers/usb/musb-new/musb_host.h +++ b/drivers/usb/musb-new/musb_host.h @@ -35,6 +35,7 @@ #ifndef _MUSB_HOST_H #define _MUSB_HOST_H #ifdef __UBOOT__ +#include <linux/usb/usb-compat.h> #include "usb-compat.h" #endif
diff --git a/drivers/usb/musb-new/usb-compat.h b/drivers/usb/musb-new/usb-compat.h index 27f656f..bdb5f0e 100644 --- a/drivers/usb/musb-new/usb-compat.h +++ b/drivers/usb/musb-new/usb-compat.h @@ -6,13 +6,6 @@ struct usb_hcd { void *hcd_priv; }; - -struct usb_host_endpoint { - struct usb_endpoint_descriptor desc; - struct list_head urb_list; - void *hcpriv; -}; - /* * urb->transfer_flags: * @@ -20,29 +13,6 @@ struct usb_host_endpoint { */ #define URB_SHORT_NOT_OK 0x0001 /* report short reads as errors */ #define URB_ZERO_PACKET 0x0040 /* Finish bulk OUT with short packet */ - -struct urb; - -typedef void (*usb_complete_t)(struct urb *); - -struct urb { - void *hcpriv; /* private data for host controller */ - struct list_head urb_list; /* list head for use by the urb's - * current owner */ - struct usb_device *dev; /* (in) pointer to associated device */ - struct usb_host_endpoint *ep; /* (internal) pointer to endpoint */ - unsigned int pipe; /* (in) pipe information */ - int status; /* (return) non-ISO status */ - unsigned int transfer_flags; /* (in) URB_SHORT_NOT_OK | ...*/ - void *transfer_buffer; /* (in) associated data buffer */ - dma_addr_t transfer_dma; /* (in) dma addr for transfer_buffer */ - u32 transfer_buffer_length; /* (in) data buffer length */ - u32 actual_length; /* (return) actual transfer length */ - unsigned char *setup_packet; /* (in) setup packet (control only) */ - int start_frame; /* (modify) start frame (ISO) */ - usb_complete_t complete; /* (in) completion routine */ -}; - #define usb_hcd_link_urb_to_ep(hcd, urb) ({ \ int ret = 0; \ list_add_tail(&urb->urb_list, &urb->ep->urb_list); \ diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h index 220d068..f987ff2 100644 --- a/include/linux/usb/gadget.h +++ b/include/linux/usb/gadget.h @@ -18,7 +18,11 @@ #ifndef __LINUX_USB_GADGET_H #define __LINUX_USB_GADGET_H
+#include <common.h> #include <linux/list.h> +#include <linux/usb/linux-compat.h> + +#define USB_GADGET_DELAYED_STATUS 0x7fff /* Impossibly large value */
struct usb_ep;
@@ -83,6 +87,11 @@ struct usb_request { unsigned length; dma_addr_t dma;
+ struct scatterlist *sg; + unsigned num_sgs; + unsigned num_mapped_sgs; + + unsigned stream_id:16; unsigned no_interrupt:1; unsigned zero:1; unsigned short_not_ok:1; @@ -119,6 +128,8 @@ struct usb_ep_ops { 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); }; @@ -140,10 +151,17 @@ struct usb_ep_ops { */ struct usb_ep { void *driver_data; + const char *name; const struct usb_ep_ops *ops; struct list_head ep_list; unsigned maxpacket:16; + unsigned max_streams:16; + unsigned mult:2; + unsigned maxburst:5; + u8 address; + const struct usb_endpoint_descriptor *desc; + const struct usb_ss_ep_comp_descriptor *comp_desc; };
/*-------------------------------------------------------------------------*/ @@ -390,10 +408,120 @@ static inline void usb_ep_fifo_flush(struct usb_ep *ep) ep->ops->fifo_flush(ep); }
+/*-------------------------------------------------------------------------*/ + +struct usb_dcd_config_params { + __u8 bU1devExitLat; /* U1 Device exit Latency */ +#define USB_DEFAULT_U1_DEV_EXIT_LAT 0x01 /* Less then 1 microsec */ + __le16 bU2DevExitLat; /* U2 Device exit Latency */ +#define USB_DEFAULT_U2_DEV_EXIT_LAT 0x1F4 /* Less then 500 microsec */ +};
/*-------------------------------------------------------------------------*/
struct usb_gadget; +struct usb_gadget_driver; + +/*-------------------------------------------------------------------------*/ + +/* utility to simplify dealing with string descriptors */ + +/** + * struct usb_string - wraps a C string and its USB id + * @id:the (nonzero) ID for this string + * @s:the string, in UTF-8 encoding + * + * If you're using usb_gadget_get_string(), use this to wrap a string + * together with its ID. + */ +struct usb_string { + u8 id; + const char *s; +}; + +/** + * 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; +}; + +struct usb_gadget_string_container { + struct list_head list; + u8 *stash[0]; +}; + +/* 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); + +/* copy a NULL-terminated vector of descriptors */ +struct usb_descriptor_header **usb_copy_descriptors( + struct usb_descriptor_header **); + +/** + * usb_free_descriptors - free descriptors returned by usb_copy_descriptors() + * @v: vector of descriptors + */ +static inline void usb_free_descriptors(struct usb_descriptor_header **v) +{ + kfree(v); +} + +struct usb_function; +int usb_assign_descriptors(struct usb_function *f, + struct usb_descriptor_header **fs, + struct usb_descriptor_header **hs, + struct usb_descriptor_header **ss); +void usb_free_all_descriptors(struct usb_function *f); + +/*-------------------------------------------------------------------------*/ + +/* 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 wrapping a simple endpoint selection policy */ + +extern struct usb_ep *usb_ep_autoconfig(struct usb_gadget *, + struct usb_endpoint_descriptor *); + + +extern struct usb_ep *usb_ep_autoconfig_ss(struct usb_gadget *, + struct usb_endpoint_descriptor *, + struct usb_ss_ep_comp_descriptor *); + +extern void usb_ep_autoconfig_reset(struct usb_gadget *);
/* the rest of the api to the controller hardware: device operations, * which don't involve endpoints (or i/o). @@ -407,11 +535,11 @@ struct usb_gadget_ops { int (*pullup) (struct usb_gadget *, int is_on); int (*ioctl)(struct usb_gadget *, unsigned code, unsigned long param); -}; - -struct device { - void *driver_data; /* data private to the driver */ - void *device_data; /* data private to the device */ + void (*get_config_params)(struct usb_dcd_config_params *); + int (*udc_start)(struct usb_gadget *, + struct usb_gadget_driver *); + int (*udc_stop)(struct usb_gadget *, + struct usb_gadget_driver *); };
/** @@ -462,6 +590,9 @@ struct usb_gadget { struct usb_ep *ep0; struct list_head ep_list; /* of usb_ep */ enum usb_device_speed speed; + enum usb_device_speed max_speed; + enum usb_device_state state; + unsigned sg_supported:1; unsigned is_dualspeed:1; unsigned is_otg:1; unsigned is_a_peripheral:1; @@ -470,6 +601,9 @@ struct usb_gadget { unsigned a_alt_hnp_support:1; const char *name; struct device dev; + unsigned out_epnum; + unsigned in_epnum; + };
static inline void set_gadget_data(struct usb_gadget *gadget, void *data) @@ -756,16 +890,22 @@ static inline int usb_gadget_disconnect(struct usb_gadget *gadget) * power is maintained. */ struct usb_gadget_driver { - enum usb_device_speed speed; - int (*bind)(struct usb_gadget *); + char *function; + enum usb_device_speed max_speed; + int (*bind)(struct usb_gadget *gadget, + struct usb_gadget_driver *driver); 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 *); -};
+ /* FIXME support safe rmmod */ + struct device_driver driver; + enum usb_device_speed speed; + +};
/*-------------------------------------------------------------------------*/
@@ -806,34 +946,6 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver);
/*-------------------------------------------------------------------------*/
-/* utility to simplify dealing with string descriptors */ - -/** - * struct usb_string - wraps a C string and its USB id - * @id:the (nonzero) ID for this string - * @s:the string, in UTF-8 encoding - * - * If you're using usb_gadget_get_string(), use this to wrap a string - * together with its ID. - */ -struct usb_string { - u8 id; - const char *s; -}; - -/** - * 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);
diff --git a/include/linux/usb/linux-compat.h b/include/linux/usb/linux-compat.h new file mode 100644 index 0000000..9850f44 --- /dev/null +++ b/include/linux/usb/linux-compat.h @@ -0,0 +1,233 @@ +/* + * linux_compat.h -- linux compatibility header file + * + * Copyright (C) 2013 + * Texas Instruments Incorporated. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef __LINUX_COMPAT_H__ +#define __LINUX_COMPAT_H__ + +#include <common.h> +#include <malloc.h> +#include <linux/list.h> +#include <linux/compat.h> +#include <asm-generic/errno.h> + +#define __init +#define __devinit +#define __devinitdata +#define __devinitconst +#define __iomem + +struct unused {}; +typedef struct unused unused_t; + +typedef int irqreturn_t; +typedef unused_t spinlock_t; + +struct work_struct {}; + +struct timer_list {}; +struct notifier_block {}; + +typedef unsigned long dmaaddr_t; +#define BUS_ID_SIZE 20 + +struct device { + struct device *parent; + struct class *class; + char bus_id[BUS_ID_SIZE]; /* position on parent bus */ + dev_t devt; /* dev_t, creates the sysfs "dev" */ + void (*release)(struct device *dev); + void *driver_data; /* data private to the driver */ + void *device_data; /* data private to the device */ +}; + +/** + * struct device_driver - The basic device driver structure + * @name: Name of the device driver. + * @bus: The bus which the device of this driver belongs to. + * @suppress_bind_attrs: Disables bind/unbind via sysfs. + * + * The device driver-model tracks all of the drivers known to the system. + * The main reason for this tracking is to enable the driver core to match + * up drivers with new devices. Once drivers are known objects within the + * system, however, a number of other things become possible. Device drivers + * can export information and configuration variables that are independent + * of any specific device. + */ +struct device_driver { + const char *name; + struct bus_type *bus; + + bool suppress_bind_attrs; /* disables bind/unbind via sysfs */ + +}; + +/* + * Loop over each sg element, following the pointer to a new list if necessary + */ +#define for_each_sg(sglist, sg, nr, __i) \ + for (__i = 0, sg = (sglist); __i < (nr); __i++, sg = sg_next(sg)) + +/* Errors */ +#define EOPNOTSUPP 95 + +#define setup_timer(timer, func, data) do {} while (0) +#define del_timer_sync(timer) do {} while (0) +#define schedule_work(work) do {} while (0) +#define INIT_WORK(work, fun) do {} while (0) + +#define cpu_relax() do {} while (0) + +#define dev_dbg(dev, fmt, args...) \ + debug(fmt, ##args) +#define dev_vdbg(dev, fmt, args...) \ + debug(fmt, ##args) +#define dev_info(dev, fmt, args...) \ + printf(fmt, ##args) +#define dev_err(dev, fmt, args...) \ + printf(fmt, ##args) +#define printk printf + +#define WARN(condition, fmt, args...) ({ \ + int ret_warn = !!condition; \ + if (ret_warn) \ + printf(fmt, ##args); \ + ret_warn; }) + +#define KERN_DEBUG +#define KERN_NOTICE +#define KERN_WARNING +#define KERN_ERR +#define WARN_ON_ONCE WARN_ON +#define BUILD_BUG_ON_NOT_POWER_OF_2(n) (0) + +#define kfree(ptr) free(ptr) + +/* common */ +#define spin_lock_init(...) +#define spin_lock(...) +#define spin_lock_irqsave(lock, flags) do { debug("%lu\n", flags); } while (0) +#define spin_unlock(...) +#define spin_unlock_irqrestore(lock, flags) do {flags = 0; } while (0) +#define disable_irq(...) +#define enable_irq(...) + +#define mutex_init(...) +#define mutex_lock(...) +#define mutex_unlock(...) + +#define GFP_KERNEL 0 + +#define IRQ_HANDLED 1 + +#define EOPNOTSUPP 95 +#define ENOTSUPP 524 /* Operation is not supported */ + +#define BITS_PER_BYTE 8 +#define BITS_TO_LONGS(nr) \ + DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long)) +#define DECLARE_BITMAP(name, bits) \ + unsigned long name[BITS_TO_LONGS(bits)] + +#define small_const_nbits(nbits) \ + (__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG) + +/* TODO: Figure out these structs */ +static inline int pm_runtime_get_sync(struct device *dev) { return 0; } +#define pm_runtime_put(dev) do {} while (0) +#define pm_runtime_put_sync(dev) do {} while (0) +#define pm_runtime_use_autosuspend(dev) do {} while (0) +#define pm_runtime_set_autosuspend_delay(dev, delay) do {} while (0) +#define pm_runtime_enable(dev) do {} while (0) +#define pm_runtime_disable(dev) do {} while (0) + +#define MODULE_DESCRIPTION(desc) +#define MODULE_AUTHOR(author) +#define MODULE_LICENSE(license) +#define MODULE_ALIAS(alias) +#define module_param(name, type, perm) +#define MODULE_PARM_DESC(name, desc) +#define EXPORT_SYMBOL_GPL(name) +#define MODULE_DEVICE_TABLE(type, name) + +#define writesl(a, d, s) __raw_writesl((unsigned long)a, d, s) +#define readsl(a, d, s) __raw_readsl((unsigned long)a, d, s) +#define writesw(a, d, s) __raw_writesw((unsigned long)a, d, s) +#define readsw(a, d, s) __raw_readsw((unsigned long)a, d, s) +#define writesb(a, d, s) __raw_writesb((unsigned long)a, d, s) +#define readsb(a, d, s) __raw_readsb((unsigned long)a, d, s) + +/* IRQ */ +#define IRQ_NONE 0 +#define IRQ_WAKE_THREAD 0 +#define IRQF_SHARED 0 +#define IRQF_ONESHOT 0 +#define GFP_KERNEL 0 + +#define dev_set_drvdata(dev, data) do {} while (0) + +#define disable_irq_wake(irq) do {} while (0) +#define enable_irq_wake(irq) -EINVAL +#define free_irq(irq, data) do {} while (0) +#define request_irq(nr, f, flags, nm, data) 0 + +#define device_init_wakeup(dev, a) do {} while (0) + +#define platform_data device_data + +#ifndef wmb +#define wmb() asm volatile ("" : : : "memory") +#endif + +#define msleep(a) udelay(a * 1000) + +/* + * Map U-Boot config options to Linux ones + */ +#ifdef CONFIG_OMAP34XX +#define CONFIG_SOC_OMAP3430 +#endif + +/* TODO: Figure out these structs +static inline int IS_ENABLED(option) { return option; };*/ +#define lower_32_bits(n) ((u32)(n)) +#define upper_32_bits(n) ((u32)(((n) >> 16) >> 16)) +#define PTR_ALIGN(p, a) ((typeof(p))ALIGN((unsigned long)(p), (a))) +#define IS_ALIGNED(x, a) (((x) & ((typeof(x))(a) - 1)) == 0) +#define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1)) + + +static inline void *dma_alloc_coherent(void *dev, size_t size, + dma_addr_t *dma_handle, gfp_t gfp) +{ + void *p; + + p = malloc(size); + *dma_handle = (unsigned long)p; + return p; +} + +static inline void dma_free_coherent(struct device *dev, size_t size, + void *vaddr, dma_addr_t bus) +{ + free(vaddr); +} + +#endif /* __LINUX_COMPAT_H__ */ diff --git a/include/linux/usb/usb-compat.h b/include/linux/usb/usb-compat.h index a0bee5a..a46d1e6 100644 --- a/include/linux/usb/usb-compat.h +++ b/include/linux/usb/usb-compat.h @@ -1,15 +1,36 @@ +/* + * Copyright (C) 2013 + * Texas Instruments Incorporated. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * Note: This code has been backported from linux source include/linux/usb.h + * At the time of the backport the linux source did not contain a license + * nor a copyright. + * + */ + #ifndef __LINUX_USB_H #define __LINUX_USB_H
+#define __UBOOT__ + +#ifndef __UBOOT__ #include <linux/mod_devicetable.h> #include <linux/usb/ch9.h> - -#define USB_MAJOR 180 -#define USB_DEVICE_MAJOR 189 - - -#ifdef __KERNEL__ - #include <linux/errno.h> /* for -ENODEV */ #include <linux/delay.h> /* for mdelay() */ #include <linux/interrupt.h> /* for in_interrupt() */ @@ -22,6 +43,20 @@ #include <linux/mutex.h> /* for struct mutex */ #include <linux/pm_runtime.h> /* for runtime PM */
+#else + +#include <common.h> +#include <linux/list.h> /* for struct list_head */ +#include <linux/usb/ch9.h> +#include <linux/usb/linux-compat.h> + +#include "usb-mod-devicetable.h" + +#endif + +#define USB_MAJOR 180 +#define USB_DEVICE_MAJOR 189 + struct usb_device; struct usb_driver; struct wusb_dev; @@ -95,6 +130,16 @@ enum usb_interface_condition { USB_INTERFACE_UNBINDING, };
+#ifdef __UBOOT__ +enum { + /* Maximum packet size; encoded as 0,1,2,3 = 8,16,32,64 */ + PACKET_SIZE_8 = 0, + PACKET_SIZE_16 = 1, + PACKET_SIZE_32 = 2, + PACKET_SIZE_64 = 3, +}; +#endif + /** * struct usb_interface - what usb device drivers talk to * @altsetting: array of interface structures, one for each alternate @@ -169,7 +214,14 @@ struct usb_interface { /* If there is an interface association descriptor then it will list * the associated interfaces */ struct usb_interface_assoc_descriptor *intf_assoc; - +#ifdef __UBOOT__ +#define USB_MAXENDPOINTS 16 + struct usb_interface_descriptor desc; + struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS]; + unsigned char no_of_ep; + unsigned char act_altsetting; + struct usb_ss_ep_comp_descriptor ss_ep_comp_desc[USB_MAXENDPOINTS]; +#endif int minor; /* minor number this interface is * bound to */ enum usb_interface_condition condition; /* state of binding */ @@ -184,19 +236,31 @@ struct usb_interface {
struct device dev; /* interface specific device info */ struct device *usb_dev; +#ifndef __UBOOT__ atomic_t pm_usage_cnt; /* usage counter for autosuspend */ struct work_struct reset_ws; /* for resets in atomic context */ +#endif }; #define to_usb_interface(d) container_of(d, struct usb_interface, dev)
static inline void *usb_get_intfdata(struct usb_interface *intf) { +#ifndef __UBOOT__ return dev_get_drvdata(&intf->dev); +#else + /* TODO Need to implement this to return the correct pointer */ + return NULL; +#endif }
static inline void usb_set_intfdata(struct usb_interface *intf, void *data) { +#ifndef __UBOOT__ dev_set_drvdata(&intf->dev, data); +#else + /* TODO Need to implement this to return the correct pointer */ + return; +#endif }
struct usb_interface *usb_get_intf(struct usb_interface *intf); @@ -222,17 +286,29 @@ void usb_put_intf(struct usb_interface *intf); */ struct usb_interface_cache { unsigned num_altsetting; /* number of alternate settings */ +#ifndef __UBOOT__ struct kref ref; /* reference counter */ - +#endif /* variable-length array of alternate settings for this interface, * stored in no particular order */ struct usb_host_interface altsetting[0]; }; + #define ref_to_usb_interface_cache(r) \ container_of(r, struct usb_interface_cache, ref) #define altsetting_to_usb_interface_cache(a) \ container_of(a, struct usb_interface_cache, altsetting[0])
+#ifdef __UBOOT__ +/* Configuration information.. */ +struct usb_config { + struct usb_config_descriptor desc; + + unsigned char no_of_if; /* number of interfaces */ + struct usb_interface if_desc[USB_MAXINTERFACES]; +} __attribute__ ((packed)); +#endif + /** * struct usb_host_config - representation of a device's configuration * @desc: the device's configuration descriptor. @@ -501,6 +577,35 @@ struct usb3_lpm_parameters { struct usb_device { int devnum; char devpath[16]; +#ifdef __UBOOT__ + /* Legacy uBoot usb_device definitions */ + char mf[32]; /* manufacturer */ + char prod[32]; /* product */ + + struct usb_device *children[USB_MAXCHILDREN]; + struct usb_config config; /* config descriptor */ + + int epmaxpacketin[16]; /* INput endpoint specific maximums */ + int epmaxpacketout[16]; /* OUTput endpoint specific maximums */ + int configno; /* selected config number */ + int act_len; /* transfered bytes */ + int portnr; + /* Maximum packet size; one of: PACKET_SIZE_* */ + int maxpacketsize; + int irq_act_len; /* transfered bytes */ + int (*irq_handle)(struct usb_device *dev); + + /* endpoint halts; one bit per endpoint # & direction; + * [0] = IN, [1] = OUT + */ + unsigned int halted[2]; + unsigned long status; + unsigned long irq_status; + + void *controller; /* hardware controller private data */ + void *privptr; +#endif + u32 route; enum usb_device_state state; enum usb_device_speed speed; @@ -518,8 +623,13 @@ struct usb_device {
struct usb_device_descriptor descriptor; struct usb_host_bos *bos; - struct usb_host_config *config;
+#ifndef __UBOOT__ + /* This conflicts with legacy uBoot config */ + struct usb_host_config *config; +#else + struct usb_host_config *host_config; +#endif struct usb_host_config *actconfig; struct usb_host_endpoint *ep_in[16]; struct usb_host_endpoint *ep_out[16]; @@ -552,8 +662,9 @@ struct usb_device { int maxchild;
u32 quirks; +#ifndef __UBOOT__ atomic_t urbnum; - +#endif unsigned long active_duration;
#ifdef CONFIG_PM @@ -707,7 +818,11 @@ extern int usb_driver_claim_interface(struct usb_driver *driver, */ static inline int usb_interface_claimed(struct usb_interface *iface) { +#ifndef __UBOOT__ return (iface->dev.driver != NULL); +#else + return true; +#endif }
extern void usb_driver_release_interface(struct usb_driver *driver, @@ -1032,11 +1147,11 @@ struct usb_driver {
int (*unlocked_ioctl) (struct usb_interface *intf, unsigned int code, void *buf); - +#ifdef CONFIG_PM int (*suspend) (struct usb_interface *intf, pm_message_t message); int (*resume) (struct usb_interface *intf); int (*reset_resume)(struct usb_interface *intf); - +#endif int (*pre_reset)(struct usb_interface *intf); int (*post_reset)(struct usb_interface *intf);
@@ -1075,9 +1190,11 @@ struct usb_device_driver {
int (*probe) (struct usb_device *udev); void (*disconnect) (struct usb_device *udev); - +#ifdef CONFIG_PM int (*suspend) (struct usb_device *udev, pm_message_t message); int (*resume) (struct usb_device *udev, pm_message_t message); +#endif + struct usbdrv_wrap drvwrap; unsigned int supports_autosuspend:1; }; @@ -1104,7 +1221,7 @@ struct usb_class_driver { const struct file_operations *fops; int minor_base; }; - +#ifndef __UBOOT__ /* * use these in module_init()/module_exit() * and don't forget MODULE_DEVICE_TABLE(usb, ...) @@ -1140,6 +1257,7 @@ extern void usb_deregister_dev(struct usb_interface *intf, struct usb_class_driver *class_driver);
extern int usb_disabled(void); +#endif /* __UBOOT__ */
/* ----------------------------------------------------------------------- */
@@ -1187,7 +1305,9 @@ struct urb;
struct usb_anchor { struct list_head urb_list; +#ifndef __UBOOT__ wait_queue_head_t wait; +#endif spinlock_t lock; unsigned int poisoned:1; }; @@ -1195,7 +1315,9 @@ struct usb_anchor { static inline void init_usb_anchor(struct usb_anchor *anchor) { INIT_LIST_HEAD(&anchor->urb_list); +#ifndef __UBOOT__ init_waitqueue_head(&anchor->wait); +#endif spin_lock_init(&anchor->lock); }
@@ -1383,11 +1505,15 @@ typedef void (*usb_complete_t)(struct urb *); * usb_submit_urb() till the entry into the completion routine. */ struct urb { +#ifndef __UBOOT__ /* private: usb core and host controller only fields in the urb */ struct kref kref; /* reference count of the URB */ +#endif void *hcpriv; /* private data for host controller */ +#ifndef __UBOOT__ atomic_t use_count; /* concurrent submissions counter */ atomic_t reject; /* submissions will fail */ +#endif int unlinked; /* unlink error code */
/* public: documented fields in the urb that can be used by drivers */ @@ -1403,13 +1529,17 @@ struct urb { unsigned int transfer_flags; /* (in) URB_SHORT_NOT_OK | ...*/ void *transfer_buffer; /* (in) associated data buffer */ dma_addr_t transfer_dma; /* (in) dma addr for transfer_buffer */ +#ifndef __UBOOT__ struct scatterlist *sg; /* (in) scatter gather buffer list */ +#endif int num_mapped_sgs; /* (internal) mapped sg entries */ int num_sgs; /* (in) number of entries in the sg list */ u32 transfer_buffer_length; /* (in) data buffer length */ u32 actual_length; /* (return) actual transfer length */ unsigned char *setup_packet; /* (in) setup packet (control only) */ +#ifndef __UBOOT__ dma_addr_t setup_dma; /* (in) dma addr for setup_packet */ +#endif int start_frame; /* (modify) start frame (ISO) */ int number_of_packets; /* (in) number of ISO packets */ int interval; /* (modify) transfer interval @@ -1604,7 +1734,7 @@ void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in, /*-------------------------------------------------------------------* * SYNCHRONOUS CALL SUPPORT * *-------------------------------------------------------------------*/ - +#ifndef __UBOOT__ extern int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request, __u8 requesttype, __u16 value, __u16 index, void *data, __u16 size, int timeout); @@ -1630,6 +1760,7 @@ extern void usb_reset_endpoint(struct usb_device *dev, unsigned int epaddr);
/* this request isn't really synchronous, but it belongs with the others */ extern int usb_driver_set_configuration(struct usb_device *udev, int config); +#endif
/* * timeouts, in milliseconds, used for sending/receiving control messages @@ -1674,7 +1805,9 @@ struct usb_sg_request { struct urb **urbs;
int count; +#ifndef __UBOOT__ struct completion complete; +#endif };
int usb_sg_init( @@ -1762,7 +1895,7 @@ usb_pipe_endpoint(struct usb_device *dev, unsigned int pipe) }
/*-------------------------------------------------------------------------*/ - +#ifndef __UBOOT__ static inline __u16 usb_maxpacket(struct usb_device *udev, int pipe, int is_out) { @@ -1770,10 +1903,16 @@ usb_maxpacket(struct usb_device *udev, int pipe, int is_out) unsigned epnum = usb_pipeendpoint(pipe);
if (is_out) { +#ifndef __UBOOT__ + /* Fix this warning */ WARN_ON(usb_pipein(pipe)); +#endif ep = udev->ep_out[epnum]; } else { +#ifndef __UBOOT__ + /* Fix this warning */ WARN_ON(usb_pipeout(pipe)); +#endif ep = udev->ep_in[epnum]; } if (!ep) @@ -1782,6 +1921,7 @@ usb_maxpacket(struct usb_device *udev, int pipe, int is_out) /* NOTE: only 0x07ff bits are for packet size... */ return usb_endpoint_maxp(&ep->desc); } +#endif
/* ----------------------------------------------------------------------- */
@@ -1810,6 +1950,16 @@ extern void usb_unregister_notify(struct notifier_block *nb); /* debugfs stuff */ extern struct dentry *usb_debug_root;
-#endif /* __KERNEL__ */ +#ifdef __UBOOT__ +/* device request (setup) */ +struct devrequest { + unsigned char requesttype; + unsigned char request; + unsigned short value; + unsigned short index; + unsigned short length; +} __attribute__ ((packed));
#endif + +#endif /* __KERNEL__ */ diff --git a/include/linux/usb/usb-mod-devicetable.h b/include/linux/usb/usb-mod-devicetable.h new file mode 100644 index 0000000..c90691c --- /dev/null +++ b/include/linux/usb/usb-mod-devicetable.h @@ -0,0 +1,131 @@ +/* + * Copyright (C) 2013 + * Texas Instruments Incorporated. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * Note: This part of code has been derived from linux source mod_devicetable.h + * + */ + +#ifndef LINUX_MOD_DEVICETABLE_H +#define LINUX_MOD_DEVICETABLE_H + +#define __UBOOT__ +/** + * struct usb_device_id - identifies USB devices for probing and hotplugging + * @match_flags: Bit mask controlling of the other fields are used to match + * against new devices. Any field except for driver_info may be used, + * although some only make sense in conjunction with other fields. + * This is usually set by a USB_DEVICE_*() macro, which sets all + * other fields in this structure except for driver_info. + * @idVendor: USB vendor ID for a device; numbers are assigned + * by the USB forum to its members. + * @idProduct: Vendor-assigned product ID. + * @bcdDevice_lo: Low end of range of vendor-assigned product version numbers. + * This is also used to identify individual product versions, for + * a range consisting of a single device. + * @bcdDevice_hi: High end of version number range. The range of product + * versions is inclusive. + * @bDeviceClass: Class of device; numbers are assigned + * by the USB forum. Products may choose to implement classes, + * or be vendor-specific. Device classes specify behavior of all + * the interfaces on a devices. + * @bDeviceSubClass: Subclass of device; associated with bDeviceClass. + * @bDeviceProtocol: Protocol of device; associated with bDeviceClass. + * @bInterfaceClass: Class of interface; numbers are assigned + * by the USB forum. Products may choose to implement classes, + * or be vendor-specific. Interface classes specify behavior only + * of a given interface; other interfaces may support other classes. + * @bInterfaceSubClass: Subclass of interface; associated with bInterfaceClass. + * @bInterfaceProtocol: Protocol of interface; associated with bInterfaceClass. + * @bInterfaceNumber: Number of interface; composite devices may use + * fixed interface numbers to differentiate between vendor-specific + * interfaces. + * @driver_info: Holds information used by the driver. Usually it holds + * a pointer to a descriptor understood by the driver, or perhaps + * device flags. + * + * In most cases, drivers will create a table of device IDs by using + * USB_DEVICE(), or similar macros designed for that purpose. + * They will then export it to userspace using MODULE_DEVICE_TABLE(), + * and provide it to the USB core through their usb_driver structure. + * + * See the usb_match_id() function for information about how matches are + * performed. Briefly, you will normally use one of several macros to help + * construct these entries. Each entry you provide will either identify + * one or more specific products, or will identify a class of products + * which have agreed to behave the same. You should put the more specific + * matches towards the beginning of your table, so that driver_info can + * record quirks of specific products. + */ +struct usb_device_id { + /* which fields to match against? */ + __u16 match_flags; + + /* Used for product specific matches; range is inclusive */ + __u16 idVendor; + __u16 idProduct; + __u16 bcdDevice_lo; + __u16 bcdDevice_hi; + + /* Used for device class matches */ + __u8 bDeviceClass; + __u8 bDeviceSubClass; + __u8 bDeviceProtocol; + + /* Used for interface class matches */ + __u8 bInterfaceClass; + __u8 bInterfaceSubClass; + __u8 bInterfaceProtocol; + + /* Used for vendor-specific interface matches */ + __u8 bInterfaceNumber; +#ifndef __UBOOT__ + /* not matched against */ + kernel_ulong_t driver_info + __attribute__((aligned(sizeof(kernel_ulong_t)))); +#endif +}; + +/* Some useful macros to use to create struct usb_device_id */ +#define USB_DEVICE_ID_MATCH_VENDOR 0x0001 +#define USB_DEVICE_ID_MATCH_PRODUCT 0x0002 +#define USB_DEVICE_ID_MATCH_DEV_LO 0x0004 +#define USB_DEVICE_ID_MATCH_DEV_HI 0x0008 +#define USB_DEVICE_ID_MATCH_DEV_CLASS 0x0010 +#define USB_DEVICE_ID_MATCH_DEV_SUBCLASS 0x0020 +#define USB_DEVICE_ID_MATCH_DEV_PROTOCOL 0x0040 +#define USB_DEVICE_ID_MATCH_INT_CLASS 0x0080 +#define USB_DEVICE_ID_MATCH_INT_SUBCLASS 0x0100 +#define USB_DEVICE_ID_MATCH_INT_PROTOCOL 0x0200 +#define USB_DEVICE_ID_MATCH_INT_NUMBER 0x0400 + +#define HID_ANY_ID (~0) +#define HID_BUS_ANY 0xffff +#define HID_GROUP_ANY 0x0000 + +struct hid_device_id { + __u16 bus; + __u16 group; + __u32 vendor; + __u32 product; +#ifndef __UBOOT__ + kernel_ulong_t driver_data; +#endif +}; + +#endif /* LINUX_MOD_DEVICETABLE_H */ diff --git a/include/usb.h b/include/usb.h index d7b082d..0598972 100644 --- a/include/usb.h +++ b/include/usb.h @@ -28,6 +28,7 @@
#include <usb_defs.h> #include <linux/usb/ch9.h> +#include <linux/usb/usb-compat.h>
/* * The EHCI spec says that we must align to at least 32 bytes. However, @@ -45,9 +46,7 @@
#define USB_MAX_DEVICE 32 #define USB_MAXCONFIG 8 -#define USB_MAXINTERFACES 8 #define USB_MAXENDPOINTS 16 -#define USB_MAXCHILDREN 8 /* This is arbitrary */ #define USB_MAX_HUB 16
#define USB_CNTL_TIMEOUT 100 /* 100ms timeout */ @@ -58,92 +57,6 @@ */ #define USB_TIMEOUT_MS(pipe) (usb_pipebulk(pipe) ? 5000 : 1000)
-/* device request (setup) */ -struct devrequest { - unsigned char requesttype; - unsigned char request; - unsigned short value; - unsigned short index; - unsigned short length; -} __attribute__ ((packed)); - -/* Interface */ -struct usb_interface { - struct usb_interface_descriptor desc; - - unsigned char no_of_ep; - unsigned char num_altsetting; - unsigned char act_altsetting; - - struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS]; - /* - * Super Speed Device will have Super Speed Endpoint - * Companion Descriptor (section 9.6.7 of usb 3.0 spec) - * Revision 1.0 June 6th 2011 - */ - struct usb_ss_ep_comp_descriptor ss_ep_comp_desc[USB_MAXENDPOINTS]; -} __attribute__ ((packed)); - -/* Configuration information.. */ -struct usb_config { - struct usb_config_descriptor desc; - - unsigned char no_of_if; /* number of interfaces */ - struct usb_interface if_desc[USB_MAXINTERFACES]; -} __attribute__ ((packed)); - -enum { - /* Maximum packet size; encoded as 0,1,2,3 = 8,16,32,64 */ - PACKET_SIZE_8 = 0, - PACKET_SIZE_16 = 1, - PACKET_SIZE_32 = 2, - PACKET_SIZE_64 = 3, -}; - -struct usb_device { - int devnum; /* Device number on USB bus */ - int speed; /* full/low/high */ - char mf[32]; /* manufacturer */ - char prod[32]; /* product */ - char serial[32]; /* serial number */ - - /* Maximum packet size; one of: PACKET_SIZE_* */ - int maxpacketsize; - /* one bit for each endpoint ([0] = IN, [1] = OUT) */ - unsigned int toggle[2]; - /* endpoint halts; one bit per endpoint # & direction; - * [0] = IN, [1] = OUT - */ - unsigned int halted[2]; - int epmaxpacketin[16]; /* INput endpoint specific maximums */ - int epmaxpacketout[16]; /* OUTput endpoint specific maximums */ - - int configno; /* selected config number */ - /* Device Descriptor */ - struct usb_device_descriptor descriptor - __attribute__((aligned(ARCH_DMA_MINALIGN))); - struct usb_config config; /* config descriptor */ - - int have_langid; /* whether string_langid is valid yet */ - int string_langid; /* language ID for strings */ - int (*irq_handle)(struct usb_device *dev); - unsigned long irq_status; - int irq_act_len; /* transfered bytes */ - void *privptr; - /* - * Child devices - if this is a hub device - * Each instance needs its own set of data structures. - */ - unsigned long status; - int act_len; /* transfered bytes */ - int maxchild; /* Number of ports if hub */ - int portnr; - struct usb_device *parent; - struct usb_device *children[USB_MAXCHILDREN]; - - void *controller; /* hardware controller private data */ -}; - /********************************************************************** * this is how the lowlevel part communicate with the outer world */ @@ -155,7 +68,7 @@ struct usb_device { defined(CONFIG_USB_OMAP3) || defined(CONFIG_USB_DA8XX) || \ defined(CONFIG_USB_BLACKFIN) || defined(CONFIG_USB_AM35X) || \ defined(CONFIG_USB_MUSB_DSPS) || defined(CONFIG_USB_MUSB_AM35X) || \ - defined(CONFIG_USB_MUSB_OMAP2PLUS) + defined(CONFIG_USB_MUSB_OMAP2PLUS) || defined(CONFIG_USB_DWC3)
int usb_lowlevel_init(int index, void **controller); int usb_lowlevel_stop(int index); @@ -226,7 +139,6 @@ int usb_bulk_msg(struct usb_device *dev, unsigned int pipe, int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer, int transfer_len, int interval); int usb_disable_asynch(int disable); -int usb_maxpacket(struct usb_device *dev, unsigned long pipe); int usb_get_configuration_no(struct usb_device *dev, unsigned char *buffer, int cfgno); int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, @@ -295,32 +207,7 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate); * specification, so that much of the uhci driver can just mask the bits * appropriately. */ -/* Create various pipes... */ -#define create_pipe(dev,endpoint) \ - (((dev)->devnum << 8) | ((endpoint) << 15) | \ - (dev)->maxpacketsize) #define default_pipe(dev) ((dev)->speed << 26) - -#define usb_sndctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \ - create_pipe(dev, endpoint)) -#define usb_rcvctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) | \ - create_pipe(dev, endpoint) | \ - USB_DIR_IN) -#define usb_sndisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \ - create_pipe(dev, endpoint)) -#define usb_rcvisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) | \ - create_pipe(dev, endpoint) | \ - USB_DIR_IN) -#define usb_sndbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \ - create_pipe(dev, endpoint)) -#define usb_rcvbulkpipe(dev, endpoint) ((PIPE_BULK << 30) | \ - create_pipe(dev, endpoint) | \ - USB_DIR_IN) -#define usb_sndintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \ - create_pipe(dev, endpoint)) -#define usb_rcvintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) | \ - create_pipe(dev, endpoint) | \ - USB_DIR_IN) #define usb_snddefctrl(dev) ((PIPE_CONTROL << 30) | \ default_pipe(dev)) #define usb_rcvdefctrl(dev) ((PIPE_CONTROL << 30) | \ @@ -343,8 +230,6 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate); #define usb_packetid(pipe) (((pipe) & USB_DIR_IN) ? USB_PID_IN : \ USB_PID_OUT)
-#define usb_pipeout(pipe) ((((pipe) >> 7) & 1) ^ 1) -#define usb_pipein(pipe) (((pipe) >> 7) & 1) #define usb_pipedevice(pipe) (((pipe) >> 8) & 0x7f) #define usb_pipe_endpdev(pipe) (((pipe) >> 8) & 0x7ff) #define usb_pipeendpoint(pipe) (((pipe) >> 15) & 0xf) diff --git a/include/usb/lin_gadget_compat.h b/include/usb/lin_gadget_compat.h index 5bdcb8d..93305e0 100644 --- a/include/usb/lin_gadget_compat.h +++ b/include/usb/lin_gadget_compat.h @@ -24,34 +24,7 @@ #define __LIN_COMPAT_H__
#include <linux/compat.h> - -/* common */ -#define spin_lock_init(...) -#define spin_lock(...) -#define spin_lock_irqsave(lock, flags) do { debug("%lu\n", flags); } while (0) -#define spin_unlock(...) -#define spin_unlock_irqrestore(lock, flags) do {flags = 0; } while (0) -#define disable_irq(...) -#define enable_irq(...) - -#define mutex_init(...) -#define mutex_lock(...) -#define mutex_unlock(...) - -#define GFP_KERNEL 0 - -#define IRQ_HANDLED 1 - -#define ENOTSUPP 524 /* Operation is not supported */ - -#define BITS_PER_BYTE 8 -#define BITS_TO_LONGS(nr) \ - DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long)) -#define DECLARE_BITMAP(name, bits) \ - unsigned long name[BITS_TO_LONGS(bits)] - -#define small_const_nbits(nbits) \ - (__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG) +#include <linux/usb/linux-compat.h>
static inline void bitmap_zero(unsigned long *dst, int nbits) {