Pileus Git - ~andy/linux/blob - drivers/usb/chipidea/ci.h

   1 /*
   2  * ci.h - common structures, functions, and macros of the ChipIdea driver
   3  *
   4  * Copyright (C) 2008 Chipidea - MIPS Technologies, Inc. All rights reserved.
   5  *
   6  * Author: David Lopo
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #ifndef __DRIVERS_USB_CHIPIDEA_CI_H
  14 #define __DRIVERS_USB_CHIPIDEA_CI_H
  15
  16 #include <linux/list.h>
  17 #include <linux/irqreturn.h>
  18 #include <linux/usb.h>
  19 #include <linux/usb/gadget.h>
  20
  21 /******************************************************************************
  22  * DEFINE
  23  *****************************************************************************/
  24 #define TD_PAGE_COUNT      5
  25 #define CI_HDRC_PAGE_SIZE  4096ul /* page size for TD's */
  26 #define ENDPT_MAX          32
  27
  28 /******************************************************************************
  29  * REGISTERS
  30  *****************************************************************************/
  31 /* register indices */
  32 enum ci_hw_regs {
  33         CAP_CAPLENGTH,
  34         CAP_HCCPARAMS,
  35         CAP_DCCPARAMS,
  36         CAP_TESTMODE,
  37         CAP_LAST = CAP_TESTMODE,
  38         OP_USBCMD,
  39         OP_USBSTS,
  40         OP_USBINTR,
  41         OP_DEVICEADDR,
  42         OP_ENDPTLISTADDR,
  43         OP_PORTSC,
  44         OP_DEVLC,
  45         OP_OTGSC,
  46         OP_USBMODE,
  47         OP_ENDPTSETUPSTAT,
  48         OP_ENDPTPRIME,
  49         OP_ENDPTFLUSH,
  50         OP_ENDPTSTAT,
  51         OP_ENDPTCOMPLETE,
  52         OP_ENDPTCTRL,
  53         /* endptctrl1..15 follow */
  54         OP_LAST = OP_ENDPTCTRL + ENDPT_MAX / 2,
  55 };
  56
  57 /******************************************************************************
  58  * STRUCTURES
  59  *****************************************************************************/
  60 /**
  61  * struct ci_hw_ep - endpoint representation
  62  * @ep: endpoint structure for gadget drivers
  63  * @dir: endpoint direction (TX/RX)
  64  * @num: endpoint number
  65  * @type: endpoint type
  66  * @name: string description of the endpoint
  67  * @qh: queue head for this endpoint
  68  * @wedge: is the endpoint wedged
  69  * @ci: pointer to the controller
  70  * @lock: pointer to controller's spinlock
  71  * @td_pool: pointer to controller's TD pool
  72  */
  73 struct ci_hw_ep {
  74         struct usb_ep                           ep;
  75         u8                                      dir;
  76         u8                                      num;
  77         u8                                      type;
  78         char                                    name[16];
  79         struct {
  80                 struct list_head        queue;
  81                 struct ci_hw_qh         *ptr;
  82                 dma_addr_t              dma;
  83         }                                       qh;
  84         int                                     wedge;
  85
  86         /* global resources */
  87         struct ci_hdrc                          *ci;
  88         spinlock_t                              *lock;
  89         struct dma_pool                         *td_pool;
  90         struct td_node                          *pending_td;
  91 };
  92
  93 enum ci_role {
  94         CI_ROLE_HOST = 0,
  95         CI_ROLE_GADGET,
  96         CI_ROLE_END,
  97 };
  98
  99 /**
 100  * struct ci_role_driver - host/gadget role driver
 101  * start: start this role
 102  * stop: stop this role
 103  * irq: irq handler for this role
 104  * name: role name string (host/gadget)
 105  */
 106 struct ci_role_driver {
 107         int             (*start)(struct ci_hdrc *);
 108         void            (*stop)(struct ci_hdrc *);
 109         irqreturn_t     (*irq)(struct ci_hdrc *);
 110         const char      *name;
 111 };
 112
 113 /**
 114  * struct hw_bank - hardware register mapping representation
 115  * @lpm: set if the device is LPM capable
 116  * @phys: physical address of the controller's registers
 117  * @abs: absolute address of the beginning of register window
 118  * @cap: capability registers
 119  * @op: operational registers
 120  * @size: size of the register window
 121  * @regmap: register lookup table
 122  */
 123 struct hw_bank {
 124         unsigned        lpm;
 125         resource_size_t phys;
 126         void __iomem    *abs;
 127         void __iomem    *cap;
 128         void __iomem    *op;
 129         size_t          size;
 130         void __iomem    *regmap[OP_LAST + 1];
 131 };
 132
 133 /**
 134  * struct ci_hdrc - chipidea device representation
 135  * @dev: pointer to parent device
 136  * @lock: access synchronization
 137  * @hw_bank: hardware register mapping
 138  * @irq: IRQ number
 139  * @roles: array of supported roles for this controller
 140  * @role: current role
 141  * @is_otg: if the device is otg-capable
 142  * @work: work for role changing
 143  * @wq: workqueue thread
 144  * @qh_pool: allocation pool for queue heads
 145  * @td_pool: allocation pool for transfer descriptors
 146  * @gadget: device side representation for peripheral controller
 147  * @driver: gadget driver
 148  * @hw_ep_max: total number of endpoints supported by hardware
 149  * @ci_hw_ep: array of endpoints
 150  * @ep0_dir: ep0 direction
 151  * @ep0out: pointer to ep0 OUT endpoint
 152  * @ep0in: pointer to ep0 IN endpoint
 153  * @status: ep0 status request
 154  * @setaddr: if we should set the address on status completion
 155  * @address: usb address received from the host
 156  * @remote_wakeup: host-enabled remote wakeup
 157  * @suspended: suspended by host
 158  * @test_mode: the selected test mode
 159  * @platdata: platform specific information supplied by parent device
 160  * @vbus_active: is VBUS active
 161  * @transceiver: pointer to USB PHY, if any
 162  * @hcd: pointer to usb_hcd for ehci host driver
 163  * @debugfs: root dentry for this controller in debugfs
 164  * @id_event: indicates there is an id event, and handled at ci_otg_work
 165  * @b_sess_valid_event: indicates there is a vbus event, and handled
 166  * at ci_otg_work
 167  * @imx28_write_fix: Freescale imx28 needs swp instruction for writing
 168  */
 169 struct ci_hdrc {
 170         struct device                   *dev;
 171         spinlock_t                      lock;
 172         struct hw_bank                  hw_bank;
 173         int                             irq;
 174         struct ci_role_driver           *roles[CI_ROLE_END];
 175         enum ci_role                    role;
 176         bool                            is_otg;
 177         struct work_struct              work;
 178         struct workqueue_struct         *wq;
 179
 180         struct dma_pool                 *qh_pool;
 181         struct dma_pool                 *td_pool;
 182
 183         struct usb_gadget               gadget;
 184         struct usb_gadget_driver        *driver;
 185         unsigned                        hw_ep_max;
 186         struct ci_hw_ep                 ci_hw_ep[ENDPT_MAX];
 187         u32                             ep0_dir;
 188         struct ci_hw_ep                 *ep0out, *ep0in;
 189
 190         struct usb_request              *status;
 191         bool                            setaddr;
 192         u8                              address;
 193         u8                              remote_wakeup;
 194         u8                              suspended;
 195         u8                              test_mode;
 196
 197         struct ci_hdrc_platform_data    *platdata;
 198         int                             vbus_active;
 199         /* FIXME: some day, we'll not use global phy */
 200         bool                            global_phy;
 201         struct usb_phy                  *transceiver;
 202         struct usb_hcd                  *hcd;
 203         struct dentry                   *debugfs;
 204         bool                            id_event;
 205         bool                            b_sess_valid_event;
 206         bool                            imx28_write_fix;
 207 };
 208
 209 static inline struct ci_role_driver *ci_role(struct ci_hdrc *ci)
 210 {
 211         BUG_ON(ci->role >= CI_ROLE_END || !ci->roles[ci->role]);
 212         return ci->roles[ci->role];
 213 }
 214
 215 static inline int ci_role_start(struct ci_hdrc *ci, enum ci_role role)
 216 {
 217         int ret;
 218
 219         if (role >= CI_ROLE_END)
 220                 return -EINVAL;
 221
 222         if (!ci->roles[role])
 223                 return -ENXIO;
 224
 225         ret = ci->roles[role]->start(ci);
 226         if (!ret)
 227                 ci->role = role;
 228         return ret;
 229 }
 230
 231 static inline void ci_role_stop(struct ci_hdrc *ci)
 232 {
 233         enum ci_role role = ci->role;
 234
 235         if (role == CI_ROLE_END)
 236                 return;
 237
 238         ci->role = CI_ROLE_END;
 239
 240         ci->roles[role]->stop(ci);
 241 }
 242
 243 /**
 244  * hw_read: reads from a hw register
 245  * @reg:  register index
 246  * @mask: bitfield mask
 247  *
 248  * This function returns register contents
 249  */
 250 static inline u32 hw_read(struct ci_hdrc *ci, enum ci_hw_regs reg, u32 mask)
 251 {
 252         return ioread32(ci->hw_bank.regmap[reg]) & mask;
 253 }
 254
 255 #ifdef CONFIG_SOC_IMX28
 256 static inline void imx28_ci_writel(u32 val, volatile void __iomem *addr)
 257 {
 258         __asm__ ("swp %0, %0, [%1]" : : "r"(val), "r"(addr));
 259 }
 260 #else
 261 static inline void imx28_ci_writel(u32 val, volatile void __iomem *addr)
 262 {
 263 }
 264 #endif
 265
 266 static inline void __hw_write(struct ci_hdrc *ci, u32 val,
 267                 void __iomem *addr)
 268 {
 269         if (ci->imx28_write_fix)
 270                 imx28_ci_writel(val, addr);
 271         else
 272                 iowrite32(val, addr);
 273 }
 274
 275 /**
 276  * hw_write: writes to a hw register
 277  * @reg:  register index
 278  * @mask: bitfield mask
 279  * @data: new value
 280  */
 281 static inline void hw_write(struct ci_hdrc *ci, enum ci_hw_regs reg,
 282                             u32 mask, u32 data)
 283 {
 284         if (~mask)
 285                 data = (ioread32(ci->hw_bank.regmap[reg]) & ~mask)
 286                         | (data & mask);
 287
 288         __hw_write(ci, data, ci->hw_bank.regmap[reg]);
 289 }
 290
 291 /**
 292  * hw_test_and_clear: tests & clears a hw register
 293  * @reg:  register index
 294  * @mask: bitfield mask
 295  *
 296  * This function returns register contents
 297  */
 298 static inline u32 hw_test_and_clear(struct ci_hdrc *ci, enum ci_hw_regs reg,
 299                                     u32 mask)
 300 {
 301         u32 val = ioread32(ci->hw_bank.regmap[reg]) & mask;
 302
 303         __hw_write(ci, val, ci->hw_bank.regmap[reg]);
 304         return val;
 305 }
 306
 307 /**
 308  * hw_test_and_write: tests & writes a hw register
 309  * @reg:  register index
 310  * @mask: bitfield mask
 311  * @data: new value
 312  *
 313  * This function returns register contents
 314  */
 315 static inline u32 hw_test_and_write(struct ci_hdrc *ci, enum ci_hw_regs reg,
 316                                     u32 mask, u32 data)
 317 {
 318         u32 val = hw_read(ci, reg, ~0);
 319
 320         hw_write(ci, reg, mask, data);
 321         return (val & mask) >> __ffs(mask);
 322 }
 323
 324 int hw_device_reset(struct ci_hdrc *ci, u32 mode);
 325
 326 int hw_port_test_set(struct ci_hdrc *ci, u8 mode);
 327
 328 u8 hw_port_test_get(struct ci_hdrc *ci);
 329
 330 int hw_wait_reg(struct ci_hdrc *ci, enum ci_hw_regs reg, u32 mask,
 331                                 u32 value, unsigned int timeout_ms);
 332
 333 #endif  /* __DRIVERS_USB_CHIPIDEA_CI_H */