On Wed, May 23, 2012 at 11:13:38AM +0800, Richard Zhao wrote:
> struct ci13xxx represent the controller, which may be device or host,
> so name its variables as ci.
>
> Signed-off-by: Richard Zhao <richard.zhao@xxxxxxxxxxxxx>
Reviewed-by: Felipe Balbi <balbi@xxxxxx>
> ---
> drivers/usb/chipidea/ci.h | 26 +-
> drivers/usb/chipidea/ci13xxx_msm.c | 12 +-
> drivers/usb/chipidea/debug.c | 146 ++++----
> drivers/usb/chipidea/udc.c | 632 ++++++++++++++++++------------------
> include/linux/usb/chipidea.h | 2 +-
> 5 files changed, 409 insertions(+), 409 deletions(-)
>
> diff --git a/drivers/usb/chipidea/ci.h b/drivers/usb/chipidea/ci.h
> index 0b09330..9655e35 100644
> --- a/drivers/usb/chipidea/ci.h
> +++ b/drivers/usb/chipidea/ci.h
> @@ -36,7 +36,7 @@
> * @name: string description of the endpoint
> * @qh: queue head for this endpoint
> * @wedge: is the endpoint wedged
> - * @udc: pointer to the controller
> + * @ci: pointer to the controller
> * @lock: pointer to controller's spinlock
> * @td_pool: pointer to controller's TD pool
> */
> @@ -54,7 +54,7 @@ struct ci13xxx_ep {
> int wedge;
>
> /* global resources */
> - struct ci13xxx *udc;
> + struct ci13xxx *ci;
> spinlock_t *lock;
> struct dma_pool *td_pool;
> };
> @@ -250,9 +250,9 @@ static inline int ffs_nr(u32 x)
> *
> * This function returns register contents
> */
> -static inline u32 hw_read(struct ci13xxx *udc, enum ci13xxx_regs reg, u32 mask)
> +static inline u32 hw_read(struct ci13xxx *ci, enum ci13xxx_regs reg, u32 mask)
> {
> - return ioread32(udc->hw_bank.regmap[reg]) & mask;
> + return ioread32(ci->hw_bank.regmap[reg]) & mask;
> }
>
> /**
> @@ -261,14 +261,14 @@ static inline u32 hw_read(struct ci13xxx *udc, enum ci13xxx_regs reg, u32 mask)
> * @mask: bitfield mask
> * @data: new value
> */
> -static inline void hw_write(struct ci13xxx *udc, enum ci13xxx_regs reg,
> +static inline void hw_write(struct ci13xxx *ci, enum ci13xxx_regs reg,
> u32 mask, u32 data)
> {
> if (~mask)
> - data = (ioread32(udc->hw_bank.regmap[reg]) & ~mask)
> + data = (ioread32(ci->hw_bank.regmap[reg]) & ~mask)
> | (data & mask);
>
> - iowrite32(data, udc->hw_bank.regmap[reg]);
> + iowrite32(data, ci->hw_bank.regmap[reg]);
> }
>
> /**
> @@ -278,12 +278,12 @@ static inline void hw_write(struct ci13xxx *udc, enum ci13xxx_regs reg,
> *
> * This function returns register contents
> */
> -static inline u32 hw_test_and_clear(struct ci13xxx *udc, enum ci13xxx_regs reg,
> +static inline u32 hw_test_and_clear(struct ci13xxx *ci, enum ci13xxx_regs reg,
> u32 mask)
> {
> - u32 val = ioread32(udc->hw_bank.regmap[reg]) & mask;
> + u32 val = ioread32(ci->hw_bank.regmap[reg]) & mask;
>
> - iowrite32(val, udc->hw_bank.regmap[reg]);
> + iowrite32(val, ci->hw_bank.regmap[reg]);
> return val;
> }
>
> @@ -295,12 +295,12 @@ static inline u32 hw_test_and_clear(struct ci13xxx *udc, enum ci13xxx_regs reg,
> *
> * This function returns register contents
> */
> -static inline u32 hw_test_and_write(struct ci13xxx *udc, enum ci13xxx_regs reg,
> +static inline u32 hw_test_and_write(struct ci13xxx *ci, enum ci13xxx_regs reg,
> u32 mask, u32 data)
> {
> - u32 val = hw_read(udc, reg, ~0);
> + u32 val = hw_read(ci, reg, ~0);
>
> - hw_write(udc, reg, mask, data);
> + hw_write(ci, reg, mask, data);
> return (val & mask) >> ffs_nr(mask);
> }
>
> diff --git a/drivers/usb/chipidea/ci13xxx_msm.c b/drivers/usb/chipidea/ci13xxx_msm.c
> index 6c8c88b..07c6b73 100644
> --- a/drivers/usb/chipidea/ci13xxx_msm.c
> +++ b/drivers/usb/chipidea/ci13xxx_msm.c
> @@ -15,11 +15,11 @@
>
> #include "ci.h"
>
> -#define MSM_USB_BASE (udc->hw_bank.abs)
> +#define MSM_USB_BASE (ci->hw_bank.abs)
>
> -static void ci13xxx_msm_notify_event(struct ci13xxx *udc, unsigned event)
> +static void ci13xxx_msm_notify_event(struct ci13xxx *ci, unsigned event)
> {
> - struct device *dev = udc->gadget.dev.parent;
> + struct device *dev = ci->gadget.dev.parent;
> int val;
>
> switch (event) {
> @@ -34,13 +34,13 @@ static void ci13xxx_msm_notify_event(struct ci13xxx *udc, unsigned event)
> * Put the transceiver in non-driving mode. Otherwise host
> * may not detect soft-disconnection.
> */
> - val = usb_phy_io_read(udc->transceiver, ULPI_FUNC_CTRL);
> + val = usb_phy_io_read(ci->transceiver, ULPI_FUNC_CTRL);
> val &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
> val |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
> - usb_phy_io_write(udc->transceiver, val, ULPI_FUNC_CTRL);
> + usb_phy_io_write(ci->transceiver, val, ULPI_FUNC_CTRL);
> break;
> default:
> - dev_dbg(dev, "unknown ci13xxx_udc event\n");
> + dev_dbg(dev, "unknown ci13xxx event\n");
> break;
> }
> }
> diff --git a/drivers/usb/chipidea/debug.c b/drivers/usb/chipidea/debug.c
> index c4b3e15..c6f50a2 100644
> --- a/drivers/usb/chipidea/debug.c
> +++ b/drivers/usb/chipidea/debug.c
> @@ -68,15 +68,15 @@ void dbg_interrupt(u32 intmask)
> *
> * This function returns number of registers read
> */
> -static size_t hw_register_read(struct ci13xxx *udc, u32 *buf, size_t size)
> +static size_t hw_register_read(struct ci13xxx *ci, u32 *buf, size_t size)
> {
> unsigned i;
>
> - if (size > udc->hw_bank.size)
> - size = udc->hw_bank.size;
> + if (size > ci->hw_bank.size)
> + size = ci->hw_bank.size;
>
> for (i = 0; i < size; i++)
> - buf[i] = hw_read(udc, i * sizeof(u32), ~0);
> + buf[i] = hw_read(ci, i * sizeof(u32), ~0);
>
> return size;
> }
> @@ -88,18 +88,18 @@ static size_t hw_register_read(struct ci13xxx *udc, u32 *buf, size_t size)
> *
> * This function returns an error code
> */
> -static int hw_register_write(struct ci13xxx *udc, u16 addr, u32 data)
> +static int hw_register_write(struct ci13xxx *ci, u16 addr, u32 data)
> {
> /* align */
> addr /= sizeof(u32);
>
> - if (addr >= udc->hw_bank.size)
> + if (addr >= ci->hw_bank.size)
> return -EINVAL;
>
> /* align */
> addr *= sizeof(u32);
>
> - hw_write(udc, addr, ~0, data);
> + hw_write(ci, addr, ~0, data);
> return 0;
> }
>
> @@ -110,13 +110,13 @@ static int hw_register_write(struct ci13xxx *udc, u16 addr, u32 data)
> *
> * This function returns an error code
> */
> -static int hw_intr_clear(struct ci13xxx *udc, int n)
> +static int hw_intr_clear(struct ci13xxx *ci, int n)
> {
> if (n >= REG_BITS)
> return -EINVAL;
>
> - hw_write(udc, OP_USBINTR, BIT(n), 0);
> - hw_write(udc, OP_USBSTS, BIT(n), BIT(n));
> + hw_write(ci, OP_USBINTR, BIT(n), 0);
> + hw_write(ci, OP_USBSTS, BIT(n), BIT(n));
> return 0;
> }
>
> @@ -127,15 +127,15 @@ static int hw_intr_clear(struct ci13xxx *udc, int n)
> *
> * This function returns an error code
> */
> -static int hw_intr_force(struct ci13xxx *udc, int n)
> +static int hw_intr_force(struct ci13xxx *ci, int n)
> {
> if (n >= REG_BITS)
> return -EINVAL;
>
> - hw_write(udc, CAP_TESTMODE, TESTMODE_FORCE, TESTMODE_FORCE);
> - hw_write(udc, OP_USBINTR, BIT(n), BIT(n));
> - hw_write(udc, OP_USBSTS, BIT(n), BIT(n));
> - hw_write(udc, CAP_TESTMODE, TESTMODE_FORCE, 0);
> + hw_write(ci, CAP_TESTMODE, TESTMODE_FORCE, TESTMODE_FORCE);
> + hw_write(ci, OP_USBINTR, BIT(n), BIT(n));
> + hw_write(ci, OP_USBSTS, BIT(n), BIT(n));
> + hw_write(ci, CAP_TESTMODE, TESTMODE_FORCE, 0);
> return 0;
> }
>
> @@ -147,12 +147,12 @@ static int hw_intr_force(struct ci13xxx *udc, int n)
> static ssize_t show_device(struct device *dev, struct device_attribute *attr,
> char *buf)
> {
> - struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
> - struct usb_gadget *gadget = &udc->gadget;
> + struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
> + struct usb_gadget *gadget = &ci->gadget;
> int n = 0;
>
> if (attr == NULL || buf == NULL) {
> - dev_err(udc->dev, "[%s] EINVAL\n", __func__);
> + dev_err(ci->dev, "[%s] EINVAL\n", __func__);
> return 0;
> }
>
> @@ -188,8 +188,8 @@ static DEVICE_ATTR(device, S_IRUSR, show_device, NULL);
> static ssize_t show_driver(struct device *dev, struct device_attribute *attr,
> char *buf)
> {
> - struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
> - struct usb_gadget_driver *driver = udc->driver;
> + struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
> + struct usb_gadget_driver *driver = ci->driver;
> int n = 0;
>
> if (attr == NULL || buf == NULL) {
> @@ -412,22 +412,22 @@ static DEVICE_ATTR(events, S_IRUSR | S_IWUSR, show_events, store_events);
> static ssize_t show_inters(struct device *dev, struct device_attribute *attr,
> char *buf)
> {
> - struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
> + struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
> unsigned long flags;
> u32 intr;
> unsigned i, j, n = 0;
>
> if (attr == NULL || buf == NULL) {
> - dev_err(udc->dev, "[%s] EINVAL\n", __func__);
> + dev_err(ci->dev, "[%s] EINVAL\n", __func__);
> return 0;
> }
>
> - spin_lock_irqsave(&udc->lock, flags);
> + spin_lock_irqsave(&ci->lock, flags);
>
> /*n += scnprintf(buf + n, PAGE_SIZE - n,
> - "status = %08x\n", hw_read_intr_status(udc));
> + "status = %08x\n", hw_read_intr_status(ci));
> n += scnprintf(buf + n, PAGE_SIZE - n,
> - "enable = %08x\n", hw_read_intr_enable(udc));*/
> + "enable = %08x\n", hw_read_intr_enable(ci));*/
>
> n += scnprintf(buf + n, PAGE_SIZE - n, "*test = %d\n",
> isr_statistics.test);
> @@ -471,7 +471,7 @@ static ssize_t show_inters(struct device *dev, struct device_attribute *attr,
> n += scnprintf(buf + n, PAGE_SIZE - n, "\n");
> }
>
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_unlock_irqrestore(&ci->lock, flags);
>
> return n;
> }
> @@ -485,31 +485,31 @@ static ssize_t show_inters(struct device *dev, struct device_attribute *attr,
> static ssize_t store_inters(struct device *dev, struct device_attribute *attr,
> const char *buf, size_t count)
> {
> - struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
> + struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
> unsigned long flags;
> unsigned en, bit;
>
> if (attr == NULL || buf == NULL) {
> - dev_err(udc->dev, "EINVAL\n");
> + dev_err(ci->dev, "EINVAL\n");
> goto done;
> }
>
> if (sscanf(buf, "%u %u", &en, &bit) != 2 || en > 1) {
> - dev_err(udc->dev, "<1|0> <bit>: enable|disable interrupt\n");
> + dev_err(ci->dev, "<1|0> <bit>: enable|disable interrupt\n");
> goto done;
> }
>
> - spin_lock_irqsave(&udc->lock, flags);
> + spin_lock_irqsave(&ci->lock, flags);
> if (en) {
> - if (hw_intr_force(udc, bit))
> + if (hw_intr_force(ci, bit))
> dev_err(dev, "invalid bit number\n");
> else
> isr_statistics.test++;
> } else {
> - if (hw_intr_clear(udc, bit))
> + if (hw_intr_clear(ci, bit))
> dev_err(dev, "invalid bit number\n");
> }
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_unlock_irqrestore(&ci->lock, flags);
>
> done:
> return count;
> @@ -524,18 +524,18 @@ static DEVICE_ATTR(inters, S_IRUSR | S_IWUSR, show_inters, store_inters);
> static ssize_t show_port_test(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> - struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
> + struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
> unsigned long flags;
> unsigned mode;
>
> if (attr == NULL || buf == NULL) {
> - dev_err(udc->dev, "EINVAL\n");
> + dev_err(ci->dev, "EINVAL\n");
> return 0;
> }
>
> - spin_lock_irqsave(&udc->lock, flags);
> - mode = hw_port_test_get(udc);
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_lock_irqsave(&ci->lock, flags);
> + mode = hw_port_test_get(ci);
> + spin_unlock_irqrestore(&ci->lock, flags);
>
> return scnprintf(buf, PAGE_SIZE, "mode = %u\n", mode);
> }
> @@ -549,24 +549,24 @@ static ssize_t store_port_test(struct device *dev,
> struct device_attribute *attr,
> const char *buf, size_t count)
> {
> - struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
> + struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
> unsigned long flags;
> unsigned mode;
>
> if (attr == NULL || buf == NULL) {
> - dev_err(udc->dev, "[%s] EINVAL\n", __func__);
> + dev_err(ci->dev, "[%s] EINVAL\n", __func__);
> goto done;
> }
>
> if (sscanf(buf, "%u", &mode) != 1) {
> - dev_err(udc->dev, "<mode>: set port test mode");
> + dev_err(ci->dev, "<mode>: set port test mode");
> goto done;
> }
>
> - spin_lock_irqsave(&udc->lock, flags);
> - if (hw_port_test_set(udc, mode))
> - dev_err(udc->dev, "invalid mode\n");
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_lock_irqsave(&ci->lock, flags);
> + if (hw_port_test_set(ci, mode))
> + dev_err(ci->dev, "invalid mode\n");
> + spin_unlock_irqrestore(&ci->lock, flags);
>
> done:
> return count;
> @@ -582,20 +582,20 @@ static DEVICE_ATTR(port_test, S_IRUSR | S_IWUSR,
> static ssize_t show_qheads(struct device *dev, struct device_attribute *attr,
> char *buf)
> {
> - struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
> + struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
> unsigned long flags;
> unsigned i, j, n = 0;
>
> if (attr == NULL || buf == NULL) {
> - dev_err(udc->dev, "[%s] EINVAL\n", __func__);
> + dev_err(ci->dev, "[%s] EINVAL\n", __func__);
> return 0;
> }
>
> - spin_lock_irqsave(&udc->lock, flags);
> - for (i = 0; i < udc->hw_ep_max/2; i++) {
> - struct ci13xxx_ep *mEpRx = &udc->ci13xxx_ep[i];
> + spin_lock_irqsave(&ci->lock, flags);
> + for (i = 0; i < ci->hw_ep_max/2; i++) {
> + struct ci13xxx_ep *mEpRx = &ci->ci13xxx_ep[i];
> struct ci13xxx_ep *mEpTx =
> - &udc->ci13xxx_ep[i + udc->hw_ep_max/2];
> + &ci->ci13xxx_ep[i + ci->hw_ep_max/2];
> n += scnprintf(buf + n, PAGE_SIZE - n,
> "EP=%02i: RX=%08X TX=%08X\n",
> i, (u32)mEpRx->qh.dma, (u32)mEpTx->qh.dma);
> @@ -606,7 +606,7 @@ static ssize_t show_qheads(struct device *dev, struct device_attribute *attr,
> *((u32 *)mEpTx->qh.ptr + j));
> }
> }
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_unlock_irqrestore(&ci->lock, flags);
>
> return n;
> }
> @@ -621,25 +621,25 @@ static DEVICE_ATTR(qheads, S_IRUSR, show_qheads, NULL);
> static ssize_t show_registers(struct device *dev,
> struct device_attribute *attr, char *buf)
> {
> - struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
> + struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
> unsigned long flags;
> u32 *dump;
> unsigned i, k, n = 0;
>
> if (attr == NULL || buf == NULL) {
> - dev_err(udc->dev, "[%s] EINVAL\n", __func__);
> + dev_err(ci->dev, "[%s] EINVAL\n", __func__);
> return 0;
> }
>
> dump = kmalloc(sizeof(u32) * DUMP_ENTRIES, GFP_KERNEL);
> if (!dump) {
> - dev_err(udc->dev, "%s: out of memory\n", __func__);
> + dev_err(ci->dev, "%s: out of memory\n", __func__);
> return 0;
> }
>
> - spin_lock_irqsave(&udc->lock, flags);
> - k = hw_register_read(udc, dump, DUMP_ENTRIES);
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_lock_irqsave(&ci->lock, flags);
> + k = hw_register_read(ci, dump, DUMP_ENTRIES);
> + spin_unlock_irqrestore(&ci->lock, flags);
>
> for (i = 0; i < k; i++) {
> n += scnprintf(buf + n, PAGE_SIZE - n,
> @@ -660,24 +660,24 @@ static ssize_t store_registers(struct device *dev,
> struct device_attribute *attr,
> const char *buf, size_t count)
> {
> - struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
> + struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
> unsigned long addr, data, flags;
>
> if (attr == NULL || buf == NULL) {
> - dev_err(udc->dev, "[%s] EINVAL\n", __func__);
> + dev_err(ci->dev, "[%s] EINVAL\n", __func__);
> goto done;
> }
>
> if (sscanf(buf, "%li %li", &addr, &data) != 2) {
> - dev_err(udc->dev,
> + dev_err(ci->dev,
> "<addr> <data>: write data to register address\n");
> goto done;
> }
>
> - spin_lock_irqsave(&udc->lock, flags);
> - if (hw_register_write(udc, addr, data))
> - dev_err(udc->dev, "invalid address range\n");
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_lock_irqsave(&ci->lock, flags);
> + if (hw_register_write(ci, addr, data))
> + dev_err(ci->dev, "invalid address range\n");
> + spin_unlock_irqrestore(&ci->lock, flags);
>
> done:
> return count;
> @@ -693,34 +693,34 @@ static DEVICE_ATTR(registers, S_IRUSR | S_IWUSR,
> static ssize_t show_requests(struct device *dev, struct device_attribute *attr,
> char *buf)
> {
> - struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
> + struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
> unsigned long flags;
> struct list_head *ptr = NULL;
> struct ci13xxx_req *req = NULL;
> unsigned i, j, n = 0, qSize = sizeof(struct ci13xxx_td)/sizeof(u32);
>
> if (attr == NULL || buf == NULL) {
> - dev_err(udc->dev, "[%s] EINVAL\n", __func__);
> + dev_err(ci->dev, "[%s] EINVAL\n", __func__);
> return 0;
> }
>
> - spin_lock_irqsave(&udc->lock, flags);
> - for (i = 0; i < udc->hw_ep_max; i++)
> - list_for_each(ptr, &udc->ci13xxx_ep[i].qh.queue)
> + spin_lock_irqsave(&ci->lock, flags);
> + for (i = 0; i < ci->hw_ep_max; i++)
> + list_for_each(ptr, &ci->ci13xxx_ep[i].qh.queue)
> {
> req = list_entry(ptr, struct ci13xxx_req, queue);
>
> n += scnprintf(buf + n, PAGE_SIZE - n,
> "EP=%02i: TD=%08X %s\n",
> - i % udc->hw_ep_max/2, (u32)req->dma,
> - ((i < udc->hw_ep_max/2) ? "RX" : "TX"));
> + i % ci->hw_ep_max/2, (u32)req->dma,
> + ((i < ci->hw_ep_max/2) ? "RX" : "TX"));
>
> for (j = 0; j < qSize; j++)
> n += scnprintf(buf + n, PAGE_SIZE - n,
> " %04X: %08X\n", j,
> *((u32 *)req->ptr + j));
> }
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_unlock_irqrestore(&ci->lock, flags);
>
> return n;
> }
> diff --git a/drivers/usb/chipidea/udc.c b/drivers/usb/chipidea/udc.c
> index cbec685..5160750 100644
> --- a/drivers/usb/chipidea/udc.c
> +++ b/drivers/usb/chipidea/udc.c
> @@ -1,5 +1,5 @@
> /*
> - * udc.c - ChipIdea UDC driver
> + * ci.c - ChipIdea UDC driver
> *
> * Copyright (C) 2008 Chipidea - MIPS Technologies, Inc. All rights reserved.
> *
> @@ -66,11 +66,11 @@ static inline int hw_ep_bit(int num, int dir)
> return num + (dir ? 16 : 0);
> }
>
> -static inline int ep_to_bit(struct ci13xxx *udc, int n)
> +static inline int ep_to_bit(struct ci13xxx *ci, int n)
> {
> - int fill = 16 - udc->hw_ep_max / 2;
> + int fill = 16 - ci->hw_ep_max / 2;
>
> - if (n >= udc->hw_ep_max / 2)
> + if (n >= ci->hw_ep_max / 2)
> n += fill;
>
> return n;
> @@ -83,17 +83,17 @@ static inline int ep_to_bit(struct ci13xxx *udc, int n)
> *
> * This function returns an error code
> */
> -static int hw_device_state(struct ci13xxx *udc, u32 dma)
> +static int hw_device_state(struct ci13xxx *ci, u32 dma)
> {
> if (dma) {
> - hw_write(udc, OP_ENDPTLISTADDR, ~0, dma);
> + hw_write(ci, OP_ENDPTLISTADDR, ~0, dma);
> /* interrupt, error, port change, reset, sleep/suspend */
> - hw_write(udc, OP_USBINTR, ~0,
> + hw_write(ci, OP_USBINTR, ~0,
> USBi_UI|USBi_UEI|USBi_PCI|USBi_URI|USBi_SLI);
> - hw_write(udc, OP_USBCMD, USBCMD_RS, USBCMD_RS);
> + hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS);
> } else {
> - hw_write(udc, OP_USBCMD, USBCMD_RS, 0);
> - hw_write(udc, OP_USBINTR, ~0, 0);
> + hw_write(ci, OP_USBCMD, USBCMD_RS, 0);
> + hw_write(ci, OP_USBINTR, ~0, 0);
> }
> return 0;
> }
> @@ -105,16 +105,16 @@ static int hw_device_state(struct ci13xxx *udc, u32 dma)
> *
> * This function returns an error code
> */
> -static int hw_ep_flush(struct ci13xxx *udc, int num, int dir)
> +static int hw_ep_flush(struct ci13xxx *ci, int num, int dir)
> {
> int n = hw_ep_bit(num, dir);
>
> do {
> /* flush any pending transfer */
> - hw_write(udc, OP_ENDPTFLUSH, BIT(n), BIT(n));
> - while (hw_read(udc, OP_ENDPTFLUSH, BIT(n)))
> + hw_write(ci, OP_ENDPTFLUSH, BIT(n), BIT(n));
> + while (hw_read(ci, OP_ENDPTFLUSH, BIT(n)))
> cpu_relax();
> - } while (hw_read(udc, OP_ENDPTSTAT, BIT(n)));
> + } while (hw_read(ci, OP_ENDPTSTAT, BIT(n)));
>
> return 0;
> }
> @@ -126,10 +126,10 @@ static int hw_ep_flush(struct ci13xxx *udc, int num, int dir)
> *
> * This function returns an error code
> */
> -static int hw_ep_disable(struct ci13xxx *udc, int num, int dir)
> +static int hw_ep_disable(struct ci13xxx *ci, int num, int dir)
> {
> - hw_ep_flush(udc, num, dir);
> - hw_write(udc, OP_ENDPTCTRL + num,
> + hw_ep_flush(ci, num, dir);
> + hw_write(ci, OP_ENDPTCTRL + num,
> dir ? ENDPTCTRL_TXE : ENDPTCTRL_RXE, 0);
> return 0;
> }
> @@ -142,7 +142,7 @@ static int hw_ep_disable(struct ci13xxx *udc, int num, int dir)
> *
> * This function returns an error code
> */
> -static int hw_ep_enable(struct ci13xxx *udc, int num, int dir, int type)
> +static int hw_ep_enable(struct ci13xxx *ci, int num, int dir, int type)
> {
> u32 mask, data;
>
> @@ -165,7 +165,7 @@ static int hw_ep_enable(struct ci13xxx *udc, int num, int dir, int type)
> mask |= ENDPTCTRL_RXE; /* enable */
> data |= ENDPTCTRL_RXE;
> }
> - hw_write(udc, OP_ENDPTCTRL + num, mask, data);
> + hw_write(ci, OP_ENDPTCTRL + num, mask, data);
> return 0;
> }
>
> @@ -176,11 +176,11 @@ static int hw_ep_enable(struct ci13xxx *udc, int num, int dir, int type)
> *
> * This function returns 1 if endpoint halted
> */
> -static int hw_ep_get_halt(struct ci13xxx *udc, int num, int dir)
> +static int hw_ep_get_halt(struct ci13xxx *ci, int num, int dir)
> {
> u32 mask = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
>
> - return hw_read(udc, OP_ENDPTCTRL + num, mask) ? 1 : 0;
> + return hw_read(ci, OP_ENDPTCTRL + num, mask) ? 1 : 0;
> }
>
> /**
> @@ -190,10 +190,10 @@ static int hw_ep_get_halt(struct ci13xxx *udc, int num, int dir)
> *
> * This function returns setup status
> */
> -static int hw_test_and_clear_setup_status(struct ci13xxx *udc, int n)
> +static int hw_test_and_clear_setup_status(struct ci13xxx *ci, int n)
> {
> - n = ep_to_bit(udc, n);
> - return hw_test_and_clear(udc, OP_ENDPTSETUPSTAT, BIT(n));
> + n = ep_to_bit(ci, n);
> + return hw_test_and_clear(ci, OP_ENDPTSETUPSTAT, BIT(n));
> }
>
> /**
> @@ -204,18 +204,18 @@ static int hw_test_and_clear_setup_status(struct ci13xxx *udc, int n)
> *
> * This function returns an error code
> */
> -static int hw_ep_prime(struct ci13xxx *udc, int num, int dir, int is_ctrl)
> +static int hw_ep_prime(struct ci13xxx *ci, int num, int dir, int is_ctrl)
> {
> int n = hw_ep_bit(num, dir);
>
> - if (is_ctrl && dir == RX && hw_read(udc, OP_ENDPTSETUPSTAT, BIT(num)))
> + if (is_ctrl && dir == RX && hw_read(ci, OP_ENDPTSETUPSTAT, BIT(num)))
> return -EAGAIN;
>
> - hw_write(udc, OP_ENDPTPRIME, BIT(n), BIT(n));
> + hw_write(ci, OP_ENDPTPRIME, BIT(n), BIT(n));
>
> - while (hw_read(udc, OP_ENDPTPRIME, BIT(n)))
> + while (hw_read(ci, OP_ENDPTPRIME, BIT(n)))
> cpu_relax();
> - if (is_ctrl && dir == RX && hw_read(udc, OP_ENDPTSETUPSTAT, BIT(num)))
> + if (is_ctrl && dir == RX && hw_read(ci, OP_ENDPTSETUPSTAT, BIT(num)))
> return -EAGAIN;
>
> /* status shoult be tested according with manual but it doesn't work */
> @@ -231,7 +231,7 @@ static int hw_ep_prime(struct ci13xxx *udc, int num, int dir, int is_ctrl)
> *
> * This function returns an error code
> */
> -static int hw_ep_set_halt(struct ci13xxx *udc, int num, int dir, int value)
> +static int hw_ep_set_halt(struct ci13xxx *ci, int num, int dir, int value)
> {
> if (value != 0 && value != 1)
> return -EINVAL;
> @@ -242,9 +242,9 @@ static int hw_ep_set_halt(struct ci13xxx *udc, int num, int dir, int value)
> u32 mask_xr = dir ? ENDPTCTRL_TXR : ENDPTCTRL_RXR;
>
> /* data toggle - reserved for EP0 but it's in ESS */
> - hw_write(udc, reg, mask_xs|mask_xr,
> + hw_write(ci, reg, mask_xs|mask_xr,
> value ? mask_xs : mask_xr);
> - } while (value != hw_ep_get_halt(udc, num, dir));
> + } while (value != hw_ep_get_halt(ci, num, dir));
>
> return 0;
> }
> @@ -254,10 +254,10 @@ static int hw_ep_set_halt(struct ci13xxx *udc, int num, int dir, int value)
> *
> * This function returns true if high speed port
> */
> -static int hw_port_is_high_speed(struct ci13xxx *udc)
> +static int hw_port_is_high_speed(struct ci13xxx *ci)
> {
> - return udc->hw_bank.lpm ? hw_read(udc, OP_DEVLC, DEVLC_PSPD) :
> - hw_read(udc, OP_PORTSC, PORTSC_HSP);
> + return ci->hw_bank.lpm ? hw_read(ci, OP_DEVLC, DEVLC_PSPD) :
> + hw_read(ci, OP_PORTSC, PORTSC_HSP);
> }
>
> /**
> @@ -265,9 +265,9 @@ static int hw_port_is_high_speed(struct ci13xxx *udc)
> *
> * This function returns register data
> */
> -static u32 hw_read_intr_enable(struct ci13xxx *udc)
> +static u32 hw_read_intr_enable(struct ci13xxx *ci)
> {
> - return hw_read(udc, OP_USBINTR, ~0);
> + return hw_read(ci, OP_USBINTR, ~0);
> }
>
> /**
> @@ -275,9 +275,9 @@ static u32 hw_read_intr_enable(struct ci13xxx *udc)
> *
> * This function returns register data
> */
> -static u32 hw_read_intr_status(struct ci13xxx *udc)
> +static u32 hw_read_intr_status(struct ci13xxx *ci)
> {
> - return hw_read(udc, OP_USBSTS, ~0);
> + return hw_read(ci, OP_USBSTS, ~0);
> }
>
> /**
> @@ -287,10 +287,10 @@ static u32 hw_read_intr_status(struct ci13xxx *udc)
> *
> * This function returns complete status
> */
> -static int hw_test_and_clear_complete(struct ci13xxx *udc, int n)
> +static int hw_test_and_clear_complete(struct ci13xxx *ci, int n)
> {
> - n = ep_to_bit(udc, n);
> - return hw_test_and_clear(udc, OP_ENDPTCOMPLETE, BIT(n));
> + n = ep_to_bit(ci, n);
> + return hw_test_and_clear(ci, OP_ENDPTCOMPLETE, BIT(n));
> }
>
> /**
> @@ -299,11 +299,11 @@ static int hw_test_and_clear_complete(struct ci13xxx *udc, int n)
> *
> * This function returns active interrutps
> */
> -static u32 hw_test_and_clear_intr_active(struct ci13xxx *udc)
> +static u32 hw_test_and_clear_intr_active(struct ci13xxx *ci)
> {
> - u32 reg = hw_read_intr_status(udc) & hw_read_intr_enable(udc);
> + u32 reg = hw_read_intr_status(ci) & hw_read_intr_enable(ci);
>
> - hw_write(udc, OP_USBSTS, ~0, reg);
> + hw_write(ci, OP_USBSTS, ~0, reg);
> return reg;
> }
>
> @@ -313,9 +313,9 @@ static u32 hw_test_and_clear_intr_active(struct ci13xxx *udc)
> *
> * This function returns guard value
> */
> -static int hw_test_and_clear_setup_guard(struct ci13xxx *udc)
> +static int hw_test_and_clear_setup_guard(struct ci13xxx *ci)
> {
> - return hw_test_and_write(udc, OP_USBCMD, USBCMD_SUTW, 0);
> + return hw_test_and_write(ci, OP_USBCMD, USBCMD_SUTW, 0);
> }
>
> /**
> @@ -324,9 +324,9 @@ static int hw_test_and_clear_setup_guard(struct ci13xxx *udc)
> *
> * This function returns guard value
> */
> -static int hw_test_and_set_setup_guard(struct ci13xxx *udc)
> +static int hw_test_and_set_setup_guard(struct ci13xxx *ci)
> {
> - return hw_test_and_write(udc, OP_USBCMD, USBCMD_SUTW, USBCMD_SUTW);
> + return hw_test_and_write(ci, OP_USBCMD, USBCMD_SUTW, USBCMD_SUTW);
> }
>
> /**
> @@ -336,9 +336,9 @@ static int hw_test_and_set_setup_guard(struct ci13xxx *udc)
> * This function explicitly sets the address, without the "USBADRA" (advance)
> * feature, which is not supported by older versions of the controller.
> */
> -static void hw_usb_set_address(struct ci13xxx *udc, u8 value)
> +static void hw_usb_set_address(struct ci13xxx *ci, u8 value)
> {
> - hw_write(udc, OP_DEVICEADDR, DEVICEADDR_USBADR,
> + hw_write(ci, OP_DEVICEADDR, DEVICEADDR_USBADR,
> value << ffs_nr(DEVICEADDR_USBADR));
> }
>
> @@ -348,21 +348,21 @@ static void hw_usb_set_address(struct ci13xxx *udc, u8 value)
> *
> * This function returns an error code
> */
> -static int hw_usb_reset(struct ci13xxx *udc)
> +static int hw_usb_reset(struct ci13xxx *ci)
> {
> - hw_usb_set_address(udc, 0);
> + hw_usb_set_address(ci, 0);
>
> /* ESS flushes only at end?!? */
> - hw_write(udc, OP_ENDPTFLUSH, ~0, ~0);
> + hw_write(ci, OP_ENDPTFLUSH, ~0, ~0);
>
> /* clear setup token semaphores */
> - hw_write(udc, OP_ENDPTSETUPSTAT, 0, 0);
> + hw_write(ci, OP_ENDPTSETUPSTAT, 0, 0);
>
> /* clear complete status */
> - hw_write(udc, OP_ENDPTCOMPLETE, 0, 0);
> + hw_write(ci, OP_ENDPTCOMPLETE, 0, 0);
>
> /* wait until all bits cleared */
> - while (hw_read(udc, OP_ENDPTPRIME, ~0))
> + while (hw_read(ci, OP_ENDPTPRIME, ~0))
> udelay(10); /* not RTOS friendly */
>
> /* reset all endpoints ? */
> @@ -394,7 +394,7 @@ static inline u8 _usb_addr(struct ci13xxx_ep *ep)
> */
> static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
> {
> - struct ci13xxx *udc = mEp->udc;
> + struct ci13xxx *ci = mEp->ci;
> unsigned i;
> int ret = 0;
> unsigned length = mReq->req.length;
> @@ -417,7 +417,7 @@ static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
> if (!mReq->req.no_interrupt)
> mReq->zptr->token |= TD_IOC;
> }
> - ret = usb_gadget_map_request(&udc->gadget, &mReq->req, mEp->dir);
> + ret = usb_gadget_map_request(&ci->gadget, &mReq->req, mEp->dir);
> if (ret)
> return ret;
>
> @@ -453,13 +453,13 @@ static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
> else
> mReqPrev->ptr->next = mReq->dma & TD_ADDR_MASK;
> wmb();
> - if (hw_read(udc, OP_ENDPTPRIME, BIT(n)))
> + if (hw_read(ci, OP_ENDPTPRIME, BIT(n)))
> goto done;
> do {
> - hw_write(udc, OP_USBCMD, USBCMD_ATDTW, USBCMD_ATDTW);
> - tmp_stat = hw_read(udc, OP_ENDPTSTAT, BIT(n));
> - } while (!hw_read(udc, OP_USBCMD, USBCMD_ATDTW));
> - hw_write(udc, OP_USBCMD, USBCMD_ATDTW, 0);
> + hw_write(ci, OP_USBCMD, USBCMD_ATDTW, USBCMD_ATDTW);
> + tmp_stat = hw_read(ci, OP_ENDPTSTAT, BIT(n));
> + } while (!hw_read(ci, OP_USBCMD, USBCMD_ATDTW));
> + hw_write(ci, OP_USBCMD, USBCMD_ATDTW, 0);
> if (tmp_stat)
> goto done;
> }
> @@ -471,7 +471,7 @@ static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
>
> wmb(); /* synchronize before ep prime */
>
> - ret = hw_ep_prime(udc, mEp->num, mEp->dir,
> + ret = hw_ep_prime(ci, mEp->num, mEp->dir,
> mEp->type == USB_ENDPOINT_XFER_CONTROL);
> done:
> return ret;
> @@ -501,7 +501,7 @@ static int _hardware_dequeue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
>
> mReq->req.status = 0;
>
> - usb_gadget_unmap_request(&mEp->udc->gadget, &mReq->req, mEp->dir);
> + usb_gadget_unmap_request(&mEp->ci->gadget, &mReq->req, mEp->dir);
>
> mReq->req.status = mReq->ptr->token & TD_STATUS;
> if ((TD_STATUS_HALTED & mReq->req.status) != 0)
> @@ -533,7 +533,7 @@ __acquires(mEp->lock)
> if (mEp == NULL)
> return -EINVAL;
>
> - hw_ep_flush(mEp->udc, mEp->num, mEp->dir);
> + hw_ep_flush(mEp->ci, mEp->num, mEp->dir);
>
> while (!list_empty(&mEp->qh.queue)) {
>
> @@ -562,33 +562,33 @@ __acquires(mEp->lock)
> static int _gadget_stop_activity(struct usb_gadget *gadget)
> {
> struct usb_ep *ep;
> - struct ci13xxx *udc = container_of(gadget, struct ci13xxx, gadget);
> + struct ci13xxx *ci = container_of(gadget, struct ci13xxx, gadget);
> unsigned long flags;
>
> - spin_lock_irqsave(&udc->lock, flags);
> - udc->gadget.speed = USB_SPEED_UNKNOWN;
> - udc->remote_wakeup = 0;
> - udc->suspended = 0;
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_lock_irqsave(&ci->lock, flags);
> + ci->gadget.speed = USB_SPEED_UNKNOWN;
> + ci->remote_wakeup = 0;
> + ci->suspended = 0;
> + spin_unlock_irqrestore(&ci->lock, flags);
>
> /* flush all endpoints */
> gadget_for_each_ep(ep, gadget) {
> usb_ep_fifo_flush(ep);
> }
> - usb_ep_fifo_flush(&udc->ep0out->ep);
> - usb_ep_fifo_flush(&udc->ep0in->ep);
> + usb_ep_fifo_flush(&ci->ep0out->ep);
> + usb_ep_fifo_flush(&ci->ep0in->ep);
>
> - if (udc->driver)
> - udc->driver->disconnect(gadget);
> + if (ci->driver)
> + ci->driver->disconnect(gadget);
>
> /* make sure to disable all endpoints */
> gadget_for_each_ep(ep, gadget) {
> usb_ep_disable(ep);
> }
>
> - if (udc->status != NULL) {
> - usb_ep_free_request(&udc->ep0in->ep, udc->status);
> - udc->status = NULL;
> + if (ci->status != NULL) {
> + usb_ep_free_request(&ci->ep0in->ep, ci->status);
> + ci->status = NULL;
> }
>
> return 0;
> @@ -599,36 +599,36 @@ static int _gadget_stop_activity(struct usb_gadget *gadget)
> *****************************************************************************/
> /**
> * isr_reset_handler: USB reset interrupt handler
> - * @udc: UDC device
> + * @ci: UDC device
> *
> * This function resets USB engine after a bus reset occurred
> */
> -static void isr_reset_handler(struct ci13xxx *udc)
> -__releases(udc->lock)
> -__acquires(udc->lock)
> +static void isr_reset_handler(struct ci13xxx *ci)
> +__releases(ci->lock)
> +__acquires(ci->lock)
> {
> int retval;
>
> dbg_event(0xFF, "BUS RST", 0);
>
> - spin_unlock(&udc->lock);
> - retval = _gadget_stop_activity(&udc->gadget);
> + spin_unlock(&ci->lock);
> + retval = _gadget_stop_activity(&ci->gadget);
> if (retval)
> goto done;
>
> - retval = hw_usb_reset(udc);
> + retval = hw_usb_reset(ci);
> if (retval)
> goto done;
>
> - udc->status = usb_ep_alloc_request(&udc->ep0in->ep, GFP_ATOMIC);
> - if (udc->status == NULL)
> + ci->status = usb_ep_alloc_request(&ci->ep0in->ep, GFP_ATOMIC);
> + if (ci->status == NULL)
> retval = -ENOMEM;
>
> done:
> - spin_lock(&udc->lock);
> + spin_lock(&ci->lock);
>
> if (retval)
> - dev_err(udc->dev, "error: %i\n", retval);
> + dev_err(ci->dev, "error: %i\n", retval);
> }
>
> /**
> @@ -649,17 +649,17 @@ static void isr_get_status_complete(struct usb_ep *ep, struct usb_request *req)
>
> /**
> * isr_get_status_response: get_status request response
> - * @udc: udc struct
> + * @ci: ci struct
> * @setup: setup request packet
> *
> * This function returns an error code
> */
> -static int isr_get_status_response(struct ci13xxx *udc,
> +static int isr_get_status_response(struct ci13xxx *ci,
> struct usb_ctrlrequest *setup)
> __releases(mEp->lock)
> __acquires(mEp->lock)
> {
> - struct ci13xxx_ep *mEp = udc->ep0in;
> + struct ci13xxx_ep *mEp = ci->ep0in;
> struct usb_request *req = NULL;
> gfp_t gfp_flags = GFP_ATOMIC;
> int dir, num, retval;
> @@ -683,14 +683,14 @@ __acquires(mEp->lock)
>
> if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
> /* Assume that device is bus powered for now. */
> - *(u16 *)req->buf = udc->remote_wakeup << 1;
> + *(u16 *)req->buf = ci->remote_wakeup << 1;
> retval = 0;
> } else if ((setup->bRequestType & USB_RECIP_MASK) \
> == USB_RECIP_ENDPOINT) {
> dir = (le16_to_cpu(setup->wIndex) & USB_ENDPOINT_DIR_MASK) ?
> TX : RX;
> num = le16_to_cpu(setup->wIndex) & USB_ENDPOINT_NUMBER_MASK;
> - *(u16 *)req->buf = hw_ep_get_halt(udc, num, dir);
> + *(u16 *)req->buf = hw_ep_get_halt(ci, num, dir);
> }
> /* else do nothing; reserved for future use */
>
> @@ -722,39 +722,39 @@ __acquires(mEp->lock)
> static void
> isr_setup_status_complete(struct usb_ep *ep, struct usb_request *req)
> {
> - struct ci13xxx *udc = req->context;
> + struct ci13xxx *ci = req->context;
> unsigned long flags;
>
> - if (udc->setaddr) {
> - hw_usb_set_address(udc, udc->address);
> - udc->setaddr = false;
> + if (ci->setaddr) {
> + hw_usb_set_address(ci, ci->address);
> + ci->setaddr = false;
> }
>
> - spin_lock_irqsave(&udc->lock, flags);
> - if (udc->test_mode)
> - hw_port_test_set(udc, udc->test_mode);
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_lock_irqsave(&ci->lock, flags);
> + if (ci->test_mode)
> + hw_port_test_set(ci, ci->test_mode);
> + spin_unlock_irqrestore(&ci->lock, flags);
> }
>
> /**
> * isr_setup_status_phase: queues the status phase of a setup transation
> - * @udc: udc struct
> + * @ci: ci struct
> *
> * This function returns an error code
> */
> -static int isr_setup_status_phase(struct ci13xxx *udc)
> +static int isr_setup_status_phase(struct ci13xxx *ci)
> __releases(mEp->lock)
> __acquires(mEp->lock)
> {
> int retval;
> struct ci13xxx_ep *mEp;
>
> - mEp = (udc->ep0_dir == TX) ? udc->ep0out : udc->ep0in;
> - udc->status->context = udc;
> - udc->status->complete = isr_setup_status_complete;
> + mEp = (ci->ep0_dir == TX) ? ci->ep0out : ci->ep0in;
> + ci->status->context = ci;
> + ci->status->complete = isr_setup_status_complete;
>
> spin_unlock(mEp->lock);
> - retval = usb_ep_queue(&mEp->ep, udc->status, GFP_ATOMIC);
> + retval = usb_ep_queue(&mEp->ep, ci->status, GFP_ATOMIC);
> spin_lock(mEp->lock);
>
> return retval;
> @@ -789,7 +789,7 @@ __acquires(mEp->lock)
> spin_unlock(mEp->lock);
> if ((mEp->type == USB_ENDPOINT_XFER_CONTROL) &&
> mReq->req.length)
> - mEpTemp = mEp->udc->ep0in;
> + mEpTemp = mEp->ci->ep0in;
> mReq->req.complete(&mEpTemp->ep, &mReq->req);
> spin_lock(mEp->lock);
> }
> @@ -805,48 +805,48 @@ __acquires(mEp->lock)
>
> /**
> * isr_tr_complete_handler: transaction complete interrupt handler
> - * @udc: UDC descriptor
> + * @ci: UDC descriptor
> *
> * This function handles traffic events
> */
> -static void isr_tr_complete_handler(struct ci13xxx *udc)
> -__releases(udc->lock)
> -__acquires(udc->lock)
> +static void isr_tr_complete_handler(struct ci13xxx *ci)
> +__releases(ci->lock)
> +__acquires(ci->lock)
> {
> unsigned i;
> u8 tmode = 0;
>
> - for (i = 0; i < udc->hw_ep_max; i++) {
> - struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
> + for (i = 0; i < ci->hw_ep_max; i++) {
> + struct ci13xxx_ep *mEp = &ci->ci13xxx_ep[i];
> int type, num, dir, err = -EINVAL;
> struct usb_ctrlrequest req;
>
> if (mEp->ep.desc == NULL)
> continue; /* not configured */
>
> - if (hw_test_and_clear_complete(udc, i)) {
> + if (hw_test_and_clear_complete(ci, i)) {
> err = isr_tr_complete_low(mEp);
> if (mEp->type == USB_ENDPOINT_XFER_CONTROL) {
> if (err > 0) /* needs status phase */
> - err = isr_setup_status_phase(udc);
> + err = isr_setup_status_phase(ci);
> if (err < 0) {
> dbg_event(_usb_addr(mEp),
> "ERROR", err);
> - spin_unlock(&udc->lock);
> + spin_unlock(&ci->lock);
> if (usb_ep_set_halt(&mEp->ep))
> - dev_err(udc->dev,
> + dev_err(ci->dev,
> "error: ep_set_halt\n");
> - spin_lock(&udc->lock);
> + spin_lock(&ci->lock);
> }
> }
> }
>
> if (mEp->type != USB_ENDPOINT_XFER_CONTROL ||
> - !hw_test_and_clear_setup_status(udc, i))
> + !hw_test_and_clear_setup_status(ci, i))
> continue;
>
> if (i != 0) {
> - dev_warn(udc->dev, "ctrl traffic at endpoint %d\n", i);
> + dev_warn(ci->dev, "ctrl traffic at endpoint %d\n", i);
> continue;
> }
>
> @@ -854,18 +854,18 @@ __acquires(udc->lock)
> * Flush data and handshake transactions of previous
> * setup packet.
> */
> - _ep_nuke(udc->ep0out);
> - _ep_nuke(udc->ep0in);
> + _ep_nuke(ci->ep0out);
> + _ep_nuke(ci->ep0in);
>
> /* read_setup_packet */
> do {
> - hw_test_and_set_setup_guard(udc);
> + hw_test_and_set_setup_guard(ci);
> memcpy(&req, &mEp->qh.ptr->setup, sizeof(req));
> - } while (!hw_test_and_clear_setup_guard(udc));
> + } while (!hw_test_and_clear_setup_guard(ci));
>
> type = req.bRequestType;
>
> - udc->ep0_dir = (type & USB_DIR_IN) ? TX : RX;
> + ci->ep0_dir = (type & USB_DIR_IN) ? TX : RX;
>
> dbg_setup(_usb_addr(mEp), &req);
>
> @@ -880,23 +880,23 @@ __acquires(udc->lock)
> dir = num & USB_ENDPOINT_DIR_MASK;
> num &= USB_ENDPOINT_NUMBER_MASK;
> if (dir) /* TX */
> - num += udc->hw_ep_max/2;
> - if (!udc->ci13xxx_ep[num].wedge) {
> - spin_unlock(&udc->lock);
> + num += ci->hw_ep_max/2;
> + if (!ci->ci13xxx_ep[num].wedge) {
> + spin_unlock(&ci->lock);
> err = usb_ep_clear_halt(
> - &udc->ci13xxx_ep[num].ep);
> - spin_lock(&udc->lock);
> + &ci->ci13xxx_ep[num].ep);
> + spin_lock(&ci->lock);
> if (err)
> break;
> }
> - err = isr_setup_status_phase(udc);
> + err = isr_setup_status_phase(ci);
> } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE) &&
> le16_to_cpu(req.wValue) ==
> USB_DEVICE_REMOTE_WAKEUP) {
> if (req.wLength != 0)
> break;
> - udc->remote_wakeup = 0;
> - err = isr_setup_status_phase(udc);
> + ci->remote_wakeup = 0;
> + err = isr_setup_status_phase(ci);
> } else {
> goto delegate;
> }
> @@ -909,7 +909,7 @@ __acquires(udc->lock)
> if (le16_to_cpu(req.wLength) != 2 ||
> le16_to_cpu(req.wValue) != 0)
> break;
> - err = isr_get_status_response(udc, &req);
> + err = isr_get_status_response(ci, &req);
> break;
> case USB_REQ_SET_ADDRESS:
> if (type != (USB_DIR_OUT|USB_RECIP_DEVICE))
> @@ -917,9 +917,9 @@ __acquires(udc->lock)
> if (le16_to_cpu(req.wLength) != 0 ||
> le16_to_cpu(req.wIndex) != 0)
> break;
> - udc->address = (u8)le16_to_cpu(req.wValue);
> - udc->setaddr = true;
> - err = isr_setup_status_phase(udc);
> + ci->address = (u8)le16_to_cpu(req.wValue);
> + ci->setaddr = true;
> + err = isr_setup_status_phase(ci);
> break;
> case USB_REQ_SET_FEATURE:
> if (type == (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
> @@ -931,20 +931,20 @@ __acquires(udc->lock)
> dir = num & USB_ENDPOINT_DIR_MASK;
> num &= USB_ENDPOINT_NUMBER_MASK;
> if (dir) /* TX */
> - num += udc->hw_ep_max/2;
> + num += ci->hw_ep_max/2;
>
> - spin_unlock(&udc->lock);
> - err = usb_ep_set_halt(&udc->ci13xxx_ep[num].ep);
> - spin_lock(&udc->lock);
> + spin_unlock(&ci->lock);
> + err = usb_ep_set_halt(&ci->ci13xxx_ep[num].ep);
> + spin_lock(&ci->lock);
> if (!err)
> - isr_setup_status_phase(udc);
> + isr_setup_status_phase(ci);
> } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE)) {
> if (req.wLength != 0)
> break;
> switch (le16_to_cpu(req.wValue)) {
> case USB_DEVICE_REMOTE_WAKEUP:
> - udc->remote_wakeup = 1;
> - err = isr_setup_status_phase(udc);
> + ci->remote_wakeup = 1;
> + err = isr_setup_status_phase(ci);
> break;
> case USB_DEVICE_TEST_MODE:
> tmode = le16_to_cpu(req.wIndex) >> 8;
> @@ -954,9 +954,9 @@ __acquires(udc->lock)
> case TEST_SE0_NAK:
> case TEST_PACKET:
> case TEST_FORCE_EN:
> - udc->test_mode = tmode;
> + ci->test_mode = tmode;
> err = isr_setup_status_phase(
> - udc);
> + ci);
> break;
> default:
> break;
> @@ -971,21 +971,21 @@ __acquires(udc->lock)
> default:
> delegate:
> if (req.wLength == 0) /* no data phase */
> - udc->ep0_dir = TX;
> + ci->ep0_dir = TX;
>
> - spin_unlock(&udc->lock);
> - err = udc->driver->setup(&udc->gadget, &req);
> - spin_lock(&udc->lock);
> + spin_unlock(&ci->lock);
> + err = ci->driver->setup(&ci->gadget, &req);
> + spin_lock(&ci->lock);
> break;
> }
>
> if (err < 0) {
> dbg_event(_usb_addr(mEp), "ERROR", err);
>
> - spin_unlock(&udc->lock);
> + spin_unlock(&ci->lock);
> if (usb_ep_set_halt(&mEp->ep))
> - dev_err(udc->dev, "error: ep_set_halt\n");
> - spin_lock(&udc->lock);
> + dev_err(ci->dev, "error: ep_set_halt\n");
> + spin_lock(&ci->lock);
> }
> }
> }
> @@ -1015,7 +1015,7 @@ static int ep_enable(struct usb_ep *ep,
> mEp->ep.desc = desc;
>
> if (!list_empty(&mEp->qh.queue))
> - dev_warn(mEp->udc->dev, "enabling a non-empty endpoint!\n");
> + dev_warn(mEp->ci->dev, "enabling a non-empty endpoint!\n");
>
> mEp->dir = usb_endpoint_dir_in(desc) ? TX : RX;
> mEp->num = usb_endpoint_num(desc);
> @@ -1043,7 +1043,7 @@ static int ep_enable(struct usb_ep *ep,
> * is always enabled
> */
> if (mEp->num)
> - retval |= hw_ep_enable(mEp->udc, mEp->num, mEp->dir, mEp->type);
> + retval |= hw_ep_enable(mEp->ci, mEp->num, mEp->dir, mEp->type);
>
> spin_unlock_irqrestore(mEp->lock, flags);
> return retval;
> @@ -1074,7 +1074,7 @@ static int ep_disable(struct usb_ep *ep)
> dbg_event(_usb_addr(mEp), "DISABLE", 0);
>
> retval |= _ep_nuke(mEp);
> - retval |= hw_ep_disable(mEp->udc, mEp->num, mEp->dir);
> + retval |= hw_ep_disable(mEp->ci, mEp->num, mEp->dir);
>
> if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
> mEp->dir = (mEp->dir == TX) ? RX : TX;
> @@ -1131,7 +1131,7 @@ static void ep_free_request(struct usb_ep *ep, struct usb_request *req)
> if (ep == NULL || req == NULL) {
> return;
> } else if (!list_empty(&mReq->queue)) {
> - dev_err(mEp->udc->dev, "freeing queued request\n");
> + dev_err(mEp->ci->dev, "freeing queued request\n");
> return;
> }
>
> @@ -1156,7 +1156,7 @@ static int ep_queue(struct usb_ep *ep, struct usb_request *req,
> {
> struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
> struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
> - struct ci13xxx *udc = mEp->udc;
> + struct ci13xxx *ci = mEp->ci;
> int retval = 0;
> unsigned long flags;
>
> @@ -1167,12 +1167,12 @@ static int ep_queue(struct usb_ep *ep, struct usb_request *req,
>
> if (mEp->type == USB_ENDPOINT_XFER_CONTROL) {
> if (req->length)
> - mEp = (udc->ep0_dir == RX) ?
> - udc->ep0out : udc->ep0in;
> + mEp = (ci->ep0_dir == RX) ?
> + ci->ep0out : ci->ep0in;
> if (!list_empty(&mEp->qh.queue)) {
> _ep_nuke(mEp);
> retval = -EOVERFLOW;
> - dev_warn(mEp->udc->dev, "endpoint ctrl %X nuked\n",
> + dev_warn(mEp->ci->dev, "endpoint ctrl %X nuked\n",
> _usb_addr(mEp));
> }
> }
> @@ -1180,14 +1180,14 @@ static int ep_queue(struct usb_ep *ep, struct usb_request *req,
> /* first nuke then test link, e.g. previous status has not sent */
> if (!list_empty(&mReq->queue)) {
> retval = -EBUSY;
> - dev_err(mEp->udc->dev, "request already in queue\n");
> + dev_err(mEp->ci->dev, "request already in queue\n");
> goto done;
> }
>
> if (req->length > 4 * CI13XXX_PAGE_SIZE) {
> req->length = 4 * CI13XXX_PAGE_SIZE;
> retval = -EMSGSIZE;
> - dev_warn(mEp->udc->dev, "request length truncated\n");
> + dev_warn(mEp->ci->dev, "request length truncated\n");
> }
>
> dbg_queue(_usb_addr(mEp), req, retval);
> @@ -1230,12 +1230,12 @@ static int ep_dequeue(struct usb_ep *ep, struct usb_request *req)
>
> dbg_event(_usb_addr(mEp), "DEQUEUE", 0);
>
> - hw_ep_flush(mEp->udc, mEp->num, mEp->dir);
> + hw_ep_flush(mEp->ci, mEp->num, mEp->dir);
>
> /* pop request */
> list_del_init(&mReq->queue);
>
> - usb_gadget_unmap_request(&mEp->udc->gadget, req, mEp->dir);
> + usb_gadget_unmap_request(&mEp->ci->gadget, req, mEp->dir);
>
> req->status = -ECONNRESET;
>
> @@ -1277,7 +1277,7 @@ static int ep_set_halt(struct usb_ep *ep, int value)
> direction = mEp->dir;
> do {
> dbg_event(_usb_addr(mEp), "HALT", value);
> - retval |= hw_ep_set_halt(mEp->udc, mEp->num, mEp->dir, value);
> + retval |= hw_ep_set_halt(mEp->ci, mEp->num, mEp->dir, value);
>
> if (!value)
> mEp->wedge = 0;
> @@ -1325,14 +1325,14 @@ static void ep_fifo_flush(struct usb_ep *ep)
> unsigned long flags;
>
> if (ep == NULL) {
> - dev_err(mEp->udc->dev, "%02X: -EINVAL\n", _usb_addr(mEp));
> + dev_err(mEp->ci->dev, "%02X: -EINVAL\n", _usb_addr(mEp));
> return;
> }
>
> spin_lock_irqsave(mEp->lock, flags);
>
> dbg_event(_usb_addr(mEp), "FFLUSH", 0);
> - hw_ep_flush(mEp->udc, mEp->num, mEp->dir);
> + hw_ep_flush(mEp->ci, mEp->num, mEp->dir);
>
> spin_unlock_irqrestore(mEp->lock, flags);
> }
> @@ -1358,30 +1358,30 @@ static const struct usb_ep_ops usb_ep_ops = {
> *****************************************************************************/
> static int ci13xxx_vbus_session(struct usb_gadget *_gadget, int is_active)
> {
> - struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget);
> + struct ci13xxx *ci = container_of(_gadget, struct ci13xxx, gadget);
> unsigned long flags;
> int gadget_ready = 0;
>
> - if (!(udc->platdata->flags & CI13XXX_PULLUP_ON_VBUS))
> + if (!(ci->platdata->flags & CI13XXX_PULLUP_ON_VBUS))
> return -EOPNOTSUPP;
>
> - spin_lock_irqsave(&udc->lock, flags);
> - udc->vbus_active = is_active;
> - if (udc->driver)
> + spin_lock_irqsave(&ci->lock, flags);
> + ci->vbus_active = is_active;
> + if (ci->driver)
> gadget_ready = 1;
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_unlock_irqrestore(&ci->lock, flags);
>
> if (gadget_ready) {
> if (is_active) {
> pm_runtime_get_sync(&_gadget->dev);
> - hw_device_reset(udc, USBMODE_CM_DC);
> - hw_device_state(udc, udc->ep0out->qh.dma);
> + hw_device_reset(ci, USBMODE_CM_DC);
> + hw_device_state(ci, ci->ep0out->qh.dma);
> } else {
> - hw_device_state(udc, 0);
> - if (udc->platdata->notify_event)
> - udc->platdata->notify_event(udc,
> + hw_device_state(ci, 0);
> + if (ci->platdata->notify_event)
> + ci->platdata->notify_event(ci,
> CI13XXX_CONTROLLER_STOPPED_EVENT);
> - _gadget_stop_activity(&udc->gadget);
> + _gadget_stop_activity(&ci->gadget);
> pm_runtime_put_sync(&_gadget->dev);
> }
> }
> @@ -1391,31 +1391,31 @@ static int ci13xxx_vbus_session(struct usb_gadget *_gadget, int is_active)
>
> static int ci13xxx_wakeup(struct usb_gadget *_gadget)
> {
> - struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget);
> + struct ci13xxx *ci = container_of(_gadget, struct ci13xxx, gadget);
> unsigned long flags;
> int ret = 0;
>
> - spin_lock_irqsave(&udc->lock, flags);
> - if (!udc->remote_wakeup) {
> + spin_lock_irqsave(&ci->lock, flags);
> + if (!ci->remote_wakeup) {
> ret = -EOPNOTSUPP;
> goto out;
> }
> - if (!hw_read(udc, OP_PORTSC, PORTSC_SUSP)) {
> + if (!hw_read(ci, OP_PORTSC, PORTSC_SUSP)) {
> ret = -EINVAL;
> goto out;
> }
> - hw_write(udc, OP_PORTSC, PORTSC_FPR, PORTSC_FPR);
> + hw_write(ci, OP_PORTSC, PORTSC_FPR, PORTSC_FPR);
> out:
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_unlock_irqrestore(&ci->lock, flags);
> return ret;
> }
>
> static int ci13xxx_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
> {
> - struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget);
> + struct ci13xxx *ci = container_of(_gadget, struct ci13xxx, gadget);
>
> - if (udc->transceiver)
> - return usb_phy_set_power(udc->transceiver, mA);
> + if (ci->transceiver)
> + return usb_phy_set_power(ci->transceiver, mA);
> return -ENOTSUPP;
> }
>
> @@ -1436,28 +1436,28 @@ static const struct usb_gadget_ops usb_gadget_ops = {
> .udc_stop = ci13xxx_stop,
> };
>
> -static int init_eps(struct ci13xxx *udc)
> +static int init_eps(struct ci13xxx *ci)
> {
> int retval = 0, i, j;
>
> - for (i = 0; i < udc->hw_ep_max/2; i++)
> + for (i = 0; i < ci->hw_ep_max/2; i++)
> for (j = RX; j <= TX; j++) {
> - int k = i + j * udc->hw_ep_max/2;
> - struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[k];
> + int k = i + j * ci->hw_ep_max/2;
> + struct ci13xxx_ep *mEp = &ci->ci13xxx_ep[k];
>
> scnprintf(mEp->name, sizeof(mEp->name), "ep%i%s", i,
> (j == TX) ? "in" : "out");
>
> - mEp->udc = udc;
> - mEp->lock = &udc->lock;
> - mEp->td_pool = udc->td_pool;
> + mEp->ci = ci;
> + mEp->lock = &ci->lock;
> + mEp->td_pool = ci->td_pool;
>
> mEp->ep.name = mEp->name;
> mEp->ep.ops = &usb_ep_ops;
> mEp->ep.maxpacket = CTRL_PAYLOAD_MAX;
>
> INIT_LIST_HEAD(&mEp->qh.queue);
> - mEp->qh.ptr = dma_pool_alloc(udc->qh_pool, GFP_KERNEL,
> + mEp->qh.ptr = dma_pool_alloc(ci->qh_pool, GFP_KERNEL,
> &mEp->qh.dma);
> if (mEp->qh.ptr == NULL)
> retval = -ENOMEM;
> @@ -1470,14 +1470,14 @@ static int init_eps(struct ci13xxx *udc)
> */
> if (i == 0) {
> if (j == RX)
> - udc->ep0out = mEp;
> + ci->ep0out = mEp;
> else
> - udc->ep0in = mEp;
> + ci->ep0in = mEp;
>
> continue;
> }
>
> - list_add_tail(&mEp->ep.ep_list, &udc->gadget.ep_list);
> + list_add_tail(&mEp->ep.ep_list, &ci->gadget.ep_list);
> }
>
> return retval;
> @@ -1493,7 +1493,7 @@ static int init_eps(struct ci13xxx *udc)
> static int ci13xxx_start(struct usb_gadget *gadget,
> struct usb_gadget_driver *driver)
> {
> - struct ci13xxx *udc = container_of(gadget, struct ci13xxx, gadget);
> + struct ci13xxx *ci = container_of(gadget, struct ci13xxx, gadget);
> unsigned long flags;
> int retval = -ENOMEM;
>
> @@ -1501,35 +1501,35 @@ static int ci13xxx_start(struct usb_gadget *gadget,
> return -EINVAL;
>
>
> - udc->ep0out->ep.desc = &ctrl_endpt_out_desc;
> - retval = usb_ep_enable(&udc->ep0out->ep);
> + ci->ep0out->ep.desc = &ctrl_endpt_out_desc;
> + retval = usb_ep_enable(&ci->ep0out->ep);
> if (retval)
> return retval;
>
> - udc->ep0in->ep.desc = &ctrl_endpt_in_desc;
> - retval = usb_ep_enable(&udc->ep0in->ep);
> + ci->ep0in->ep.desc = &ctrl_endpt_in_desc;
> + retval = usb_ep_enable(&ci->ep0in->ep);
> if (retval)
> return retval;
> - spin_lock_irqsave(&udc->lock, flags);
> -
> - udc->driver = driver;
> - pm_runtime_get_sync(&udc->gadget.dev);
> - if (udc->platdata->flags & CI13XXX_PULLUP_ON_VBUS) {
> - if (udc->vbus_active) {
> - if (udc->platdata->flags & CI13XXX_REGS_SHARED)
> - hw_device_reset(udc, USBMODE_CM_DC);
> + spin_lock_irqsave(&ci->lock, flags);
> +
> + ci->driver = driver;
> + pm_runtime_get_sync(&ci->gadget.dev);
> + if (ci->platdata->flags & CI13XXX_PULLUP_ON_VBUS) {
> + if (ci->vbus_active) {
> + if (ci->platdata->flags & CI13XXX_REGS_SHARED)
> + hw_device_reset(ci, USBMODE_CM_DC);
> } else {
> - pm_runtime_put_sync(&udc->gadget.dev);
> + pm_runtime_put_sync(&ci->gadget.dev);
> goto done;
> }
> }
>
> - retval = hw_device_state(udc, udc->ep0out->qh.dma);
> + retval = hw_device_state(ci, ci->ep0out->qh.dma);
> if (retval)
> - pm_runtime_put_sync(&udc->gadget.dev);
> + pm_runtime_put_sync(&ci->gadget.dev);
>
> done:
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_unlock_irqrestore(&ci->lock, flags);
> return retval;
> }
>
> @@ -1539,25 +1539,25 @@ static int ci13xxx_start(struct usb_gadget *gadget,
> static int ci13xxx_stop(struct usb_gadget *gadget,
> struct usb_gadget_driver *driver)
> {
> - struct ci13xxx *udc = container_of(gadget, struct ci13xxx, gadget);
> + struct ci13xxx *ci = container_of(gadget, struct ci13xxx, gadget);
> unsigned long flags;
>
> - spin_lock_irqsave(&udc->lock, flags);
> + spin_lock_irqsave(&ci->lock, flags);
>
> - if (!(udc->platdata->flags & CI13XXX_PULLUP_ON_VBUS) ||
> - udc->vbus_active) {
> - hw_device_state(udc, 0);
> - if (udc->platdata->notify_event)
> - udc->platdata->notify_event(udc,
> + if (!(ci->platdata->flags & CI13XXX_PULLUP_ON_VBUS) ||
> + ci->vbus_active) {
> + hw_device_state(ci, 0);
> + if (ci->platdata->notify_event)
> + ci->platdata->notify_event(ci,
> CI13XXX_CONTROLLER_STOPPED_EVENT);
> - udc->driver = NULL;
> - spin_unlock_irqrestore(&udc->lock, flags);
> - _gadget_stop_activity(&udc->gadget);
> - spin_lock_irqsave(&udc->lock, flags);
> - pm_runtime_put(&udc->gadget.dev);
> + ci->driver = NULL;
> + spin_unlock_irqrestore(&ci->lock, flags);
> + _gadget_stop_activity(&ci->gadget);
> + spin_lock_irqsave(&ci->lock, flags);
> + pm_runtime_put(&ci->gadget.dev);
> }
>
> - spin_unlock_irqrestore(&udc->lock, flags);
> + spin_unlock_irqrestore(&ci->lock, flags);
>
> return 0;
> }
> @@ -1566,64 +1566,64 @@ static int ci13xxx_stop(struct usb_gadget *gadget,
> * BUS block
> *****************************************************************************/
> /**
> - * udc_irq: udc interrupt handler
> + * udc_irq: ci interrupt handler
> *
> * This function returns IRQ_HANDLED if the IRQ has been handled
> * It locks access to registers
> */
> -static irqreturn_t udc_irq(struct ci13xxx *udc)
> +static irqreturn_t udc_irq(struct ci13xxx *ci)
> {
> irqreturn_t retval;
> u32 intr;
>
> - if (udc == NULL)
> + if (ci == NULL)
> return IRQ_HANDLED;
>
> - spin_lock(&udc->lock);
> + spin_lock(&ci->lock);
>
> - if (udc->platdata->flags & CI13XXX_REGS_SHARED) {
> - if (hw_read(udc, OP_USBMODE, USBMODE_CM) !=
> + if (ci->platdata->flags & CI13XXX_REGS_SHARED) {
> + if (hw_read(ci, OP_USBMODE, USBMODE_CM) !=
> USBMODE_CM_DC) {
> - spin_unlock(&udc->lock);
> + spin_unlock(&ci->lock);
> return IRQ_NONE;
> }
> }
> - intr = hw_test_and_clear_intr_active(udc);
> + intr = hw_test_and_clear_intr_active(ci);
> dbg_interrupt(intr);
>
> if (intr) {
> /* order defines priority - do NOT change it */
> if (USBi_URI & intr)
> - isr_reset_handler(udc);
> + isr_reset_handler(ci);
>
> if (USBi_PCI & intr) {
> - udc->gadget.speed = hw_port_is_high_speed(udc) ?
> + ci->gadget.speed = hw_port_is_high_speed(ci) ?
> USB_SPEED_HIGH : USB_SPEED_FULL;
> - if (udc->suspended && udc->driver->resume) {
> - spin_unlock(&udc->lock);
> - udc->driver->resume(&udc->gadget);
> - spin_lock(&udc->lock);
> - udc->suspended = 0;
> + if (ci->suspended && ci->driver->resume) {
> + spin_unlock(&ci->lock);
> + ci->driver->resume(&ci->gadget);
> + spin_lock(&ci->lock);
> + ci->suspended = 0;
> }
> }
>
> if (USBi_UI & intr)
> - isr_tr_complete_handler(udc);
> + isr_tr_complete_handler(ci);
>
> if (USBi_SLI & intr) {
> - if (udc->gadget.speed != USB_SPEED_UNKNOWN &&
> - udc->driver->suspend) {
> - udc->suspended = 1;
> - spin_unlock(&udc->lock);
> - udc->driver->suspend(&udc->gadget);
> - spin_lock(&udc->lock);
> + if (ci->gadget.speed != USB_SPEED_UNKNOWN &&
> + ci->driver->suspend) {
> + ci->suspended = 1;
> + spin_unlock(&ci->lock);
> + ci->driver->suspend(&ci->gadget);
> + spin_lock(&ci->lock);
> }
> }
> retval = IRQ_HANDLED;
> } else {
> retval = IRQ_NONE;
> }
> - spin_unlock(&udc->lock);
> + spin_unlock(&ci->lock);
>
> return retval;
> }
> @@ -1640,112 +1640,112 @@ static void udc_release(struct device *dev)
>
> /**
> * udc_start: initialize gadget role
> - * @udc: chipidea controller
> + * @ci: chipidea controller
> */
> -static int udc_start(struct ci13xxx *udc)
> +static int udc_start(struct ci13xxx *ci)
> {
> - struct device *dev = udc->dev;
> + struct device *dev = ci->dev;
> int retval = 0;
>
> - if (!udc)
> + if (!ci)
> return -EINVAL;
>
> - spin_lock_init(&udc->lock);
> + spin_lock_init(&ci->lock);
>
> - udc->gadget.ops = &usb_gadget_ops;
> - udc->gadget.speed = USB_SPEED_UNKNOWN;
> - udc->gadget.max_speed = USB_SPEED_HIGH;
> - udc->gadget.is_otg = 0;
> - udc->gadget.name = udc->platdata->name;
> + ci->gadget.ops = &usb_gadget_ops;
> + ci->gadget.speed = USB_SPEED_UNKNOWN;
> + ci->gadget.max_speed = USB_SPEED_HIGH;
> + ci->gadget.is_otg = 0;
> + ci->gadget.name = ci->platdata->name;
>
> - INIT_LIST_HEAD(&udc->gadget.ep_list);
> + INIT_LIST_HEAD(&ci->gadget.ep_list);
>
> - dev_set_name(&udc->gadget.dev, "gadget");
> - udc->gadget.dev.dma_mask = dev->dma_mask;
> - udc->gadget.dev.coherent_dma_mask = dev->coherent_dma_mask;
> - udc->gadget.dev.parent = dev;
> - udc->gadget.dev.release = udc_release;
> + dev_set_name(&ci->gadget.dev, "gadget");
> + ci->gadget.dev.dma_mask = dev->dma_mask;
> + ci->gadget.dev.coherent_dma_mask = dev->coherent_dma_mask;
> + ci->gadget.dev.parent = dev;
> + ci->gadget.dev.release = udc_release;
>
> /* alloc resources */
> - udc->qh_pool = dma_pool_create("ci13xxx_qh", dev,
> + ci->qh_pool = dma_pool_create("ci13xxx_qh", dev,
> sizeof(struct ci13xxx_qh),
> 64, CI13XXX_PAGE_SIZE);
> - if (udc->qh_pool == NULL)
> + if (ci->qh_pool == NULL)
> return -ENOMEM;
>
> - udc->td_pool = dma_pool_create("ci13xxx_td", dev,
> + ci->td_pool = dma_pool_create("ci13xxx_td", dev,
> sizeof(struct ci13xxx_td),
> 64, CI13XXX_PAGE_SIZE);
> - if (udc->td_pool == NULL) {
> + if (ci->td_pool == NULL) {
> retval = -ENOMEM;
> goto free_qh_pool;
> }
>
> - retval = init_eps(udc);
> + retval = init_eps(ci);
> if (retval)
> goto free_pools;
>
> - udc->gadget.ep0 = &udc->ep0in->ep;
> + ci->gadget.ep0 = &ci->ep0in->ep;
>
> - udc->transceiver = usb_get_transceiver();
> + ci->transceiver = usb_get_transceiver();
>
> - if (udc->platdata->flags & CI13XXX_REQUIRE_TRANSCEIVER) {
> - if (udc->transceiver == NULL) {
> + if (ci->platdata->flags & CI13XXX_REQUIRE_TRANSCEIVER) {
> + if (ci->transceiver == NULL) {
> retval = -ENODEV;
> goto free_pools;
> }
> }
>
> - if (!(udc->platdata->flags & CI13XXX_REGS_SHARED)) {
> - retval = hw_device_reset(udc, USBMODE_CM_DC);
> + if (!(ci->platdata->flags & CI13XXX_REGS_SHARED)) {
> + retval = hw_device_reset(ci, USBMODE_CM_DC);
> if (retval)
> goto put_transceiver;
> }
>
> - retval = device_register(&udc->gadget.dev);
> + retval = device_register(&ci->gadget.dev);
> if (retval) {
> - put_device(&udc->gadget.dev);
> + put_device(&ci->gadget.dev);
> goto put_transceiver;
> }
>
> - retval = dbg_create_files(&udc->gadget.dev);
> + retval = dbg_create_files(&ci->gadget.dev);
> if (retval)
> goto unreg_device;
>
> - if (udc->transceiver) {
> - retval = otg_set_peripheral(udc->transceiver->otg,
> - &udc->gadget);
> + if (ci->transceiver) {
> + retval = otg_set_peripheral(ci->transceiver->otg,
> + &ci->gadget);
> if (retval)
> goto remove_dbg;
> }
>
> - retval = usb_add_gadget_udc(dev, &udc->gadget);
> + retval = usb_add_gadget_udc(dev, &ci->gadget);
> if (retval)
> goto remove_trans;
>
> - pm_runtime_no_callbacks(&udc->gadget.dev);
> - pm_runtime_enable(&udc->gadget.dev);
> + pm_runtime_no_callbacks(&ci->gadget.dev);
> + pm_runtime_enable(&ci->gadget.dev);
>
> return retval;
>
> remove_trans:
> - if (udc->transceiver) {
> - otg_set_peripheral(udc->transceiver->otg, &udc->gadget);
> - usb_put_transceiver(udc->transceiver);
> + if (ci->transceiver) {
> + otg_set_peripheral(ci->transceiver->otg, &ci->gadget);
> + usb_put_transceiver(ci->transceiver);
> }
>
> dev_err(dev, "error = %i\n", retval);
> remove_dbg:
> - dbg_remove_files(&udc->gadget.dev);
> + dbg_remove_files(&ci->gadget.dev);
> unreg_device:
> - device_unregister(&udc->gadget.dev);
> + device_unregister(&ci->gadget.dev);
> put_transceiver:
> - if (udc->transceiver)
> - usb_put_transceiver(udc->transceiver);
> + if (ci->transceiver)
> + usb_put_transceiver(ci->transceiver);
> free_pools:
> - dma_pool_destroy(udc->td_pool);
> + dma_pool_destroy(ci->td_pool);
> free_qh_pool:
> - dma_pool_destroy(udc->qh_pool);
> + dma_pool_destroy(ci->qh_pool);
> return retval;
> }
>
> @@ -1754,32 +1754,32 @@ free_qh_pool:
> *
> * No interrupts active, the IRQ has been released
> */
> -static void udc_stop(struct ci13xxx *udc)
> +static void udc_stop(struct ci13xxx *ci)
> {
> int i;
>
> - if (udc == NULL)
> + if (ci == NULL)
> return;
>
> - usb_del_gadget_udc(&udc->gadget);
> + usb_del_gadget_udc(&ci->gadget);
>
> - for (i = 0; i < udc->hw_ep_max; i++) {
> - struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
> + for (i = 0; i < ci->hw_ep_max; i++) {
> + struct ci13xxx_ep *mEp = &ci->ci13xxx_ep[i];
>
> - dma_pool_free(udc->qh_pool, mEp->qh.ptr, mEp->qh.dma);
> + dma_pool_free(ci->qh_pool, mEp->qh.ptr, mEp->qh.dma);
> }
>
> - dma_pool_destroy(udc->td_pool);
> - dma_pool_destroy(udc->qh_pool);
> + dma_pool_destroy(ci->td_pool);
> + dma_pool_destroy(ci->qh_pool);
>
> - if (udc->transceiver) {
> - otg_set_peripheral(udc->transceiver->otg, NULL);
> - usb_put_transceiver(udc->transceiver);
> + if (ci->transceiver) {
> + otg_set_peripheral(ci->transceiver->otg, NULL);
> + usb_put_transceiver(ci->transceiver);
> }
> - dbg_remove_files(&udc->gadget.dev);
> - device_unregister(&udc->gadget.dev);
> + dbg_remove_files(&ci->gadget.dev);
> + device_unregister(&ci->gadget.dev);
> /* my kobject is dynamic, I swear! */
> - memset(&udc->gadget, 0, sizeof(udc->gadget));
> + memset(&ci->gadget, 0, sizeof(ci->gadget));
> }
>
> /**
> diff --git a/include/linux/usb/chipidea.h b/include/linux/usb/chipidea.h
> index d4cf9706..d2f7e49 100644
> --- a/include/linux/usb/chipidea.h
> +++ b/include/linux/usb/chipidea.h
> @@ -19,7 +19,7 @@ struct ci13xxx_platform_data {
>
> #define CI13XXX_CONTROLLER_RESET_EVENT 0
> #define CI13XXX_CONTROLLER_STOPPED_EVENT 1
> - void (*notify_event) (struct ci13xxx *udc, unsigned event);
> + void (*notify_event) (struct ci13xxx *ci, unsigned event);
> };
>
> /* Default offset of capability registers */
> --
> 1.7.5.4
>
>
--
balbi
Attachment:
signature.asc
Description: Digital signature
