]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/usb/chipidea/ci.h
usb: chipidea: cast PORTSC_PTS and DEVLC_PTS macros
[karo-tx-linux.git] / 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  * STRUCTURES
30  *****************************************************************************/
31 /**
32  * struct ci_hw_ep - endpoint representation
33  * @ep: endpoint structure for gadget drivers
34  * @dir: endpoint direction (TX/RX)
35  * @num: endpoint number
36  * @type: endpoint type
37  * @name: string description of the endpoint
38  * @qh: queue head for this endpoint
39  * @wedge: is the endpoint wedged
40  * @ci: pointer to the controller
41  * @lock: pointer to controller's spinlock
42  * @td_pool: pointer to controller's TD pool
43  */
44 struct ci_hw_ep {
45         struct usb_ep                           ep;
46         u8                                      dir;
47         u8                                      num;
48         u8                                      type;
49         char                                    name[16];
50         struct {
51                 struct list_head        queue;
52                 struct ci_hw_qh         *ptr;
53                 dma_addr_t              dma;
54         }                                       qh;
55         int                                     wedge;
56
57         /* global resources */
58         struct ci_hdrc                          *ci;
59         spinlock_t                              *lock;
60         struct dma_pool                         *td_pool;
61         struct td_node                          *pending_td;
62 };
63
64 enum ci_role {
65         CI_ROLE_HOST = 0,
66         CI_ROLE_GADGET,
67         CI_ROLE_END,
68 };
69
70 /**
71  * struct ci_role_driver - host/gadget role driver
72  * start: start this role
73  * stop: stop this role
74  * irq: irq handler for this role
75  * name: role name string (host/gadget)
76  */
77 struct ci_role_driver {
78         int             (*start)(struct ci_hdrc *);
79         void            (*stop)(struct ci_hdrc *);
80         irqreturn_t     (*irq)(struct ci_hdrc *);
81         const char      *name;
82 };
83
84 /**
85  * struct hw_bank - hardware register mapping representation
86  * @lpm: set if the device is LPM capable
87  * @phys: physical address of the controller's registers
88  * @abs: absolute address of the beginning of register window
89  * @cap: capability registers
90  * @op: operational registers
91  * @size: size of the register window
92  * @regmap: register lookup table
93  */
94 struct hw_bank {
95         unsigned        lpm;
96         resource_size_t phys;
97         void __iomem    *abs;
98         void __iomem    *cap;
99         void __iomem    *op;
100         size_t          size;
101         void __iomem    **regmap;
102 };
103
104 /**
105  * struct ci_hdrc - chipidea device representation
106  * @dev: pointer to parent device
107  * @lock: access synchronization
108  * @hw_bank: hardware register mapping
109  * @irq: IRQ number
110  * @roles: array of supported roles for this controller
111  * @role: current role
112  * @is_otg: if the device is otg-capable
113  * @work: work for role changing
114  * @wq: workqueue thread
115  * @qh_pool: allocation pool for queue heads
116  * @td_pool: allocation pool for transfer descriptors
117  * @gadget: device side representation for peripheral controller
118  * @driver: gadget driver
119  * @hw_ep_max: total number of endpoints supported by hardware
120  * @ci_hw_ep: array of endpoints
121  * @ep0_dir: ep0 direction
122  * @ep0out: pointer to ep0 OUT endpoint
123  * @ep0in: pointer to ep0 IN endpoint
124  * @status: ep0 status request
125  * @setaddr: if we should set the address on status completion
126  * @address: usb address received from the host
127  * @remote_wakeup: host-enabled remote wakeup
128  * @suspended: suspended by host
129  * @test_mode: the selected test mode
130  * @platdata: platform specific information supplied by parent device
131  * @vbus_active: is VBUS active
132  * @transceiver: pointer to USB PHY, if any
133  * @hcd: pointer to usb_hcd for ehci host driver
134  * @debugfs: root dentry for this controller in debugfs
135  */
136 struct ci_hdrc {
137         struct device                   *dev;
138         spinlock_t                      lock;
139         struct hw_bank                  hw_bank;
140         int                             irq;
141         struct ci_role_driver           *roles[CI_ROLE_END];
142         enum ci_role                    role;
143         bool                            is_otg;
144         struct work_struct              work;
145         struct workqueue_struct         *wq;
146
147         struct dma_pool                 *qh_pool;
148         struct dma_pool                 *td_pool;
149
150         struct usb_gadget               gadget;
151         struct usb_gadget_driver        *driver;
152         unsigned                        hw_ep_max;
153         struct ci_hw_ep                 ci_hw_ep[ENDPT_MAX];
154         u32                             ep0_dir;
155         struct ci_hw_ep                 *ep0out, *ep0in;
156
157         struct usb_request              *status;
158         bool                            setaddr;
159         u8                              address;
160         u8                              remote_wakeup;
161         u8                              suspended;
162         u8                              test_mode;
163
164         struct ci_hdrc_platform_data    *platdata;
165         int                             vbus_active;
166         /* FIXME: some day, we'll not use global phy */
167         bool                            global_phy;
168         struct usb_phy                  *transceiver;
169         struct usb_hcd                  *hcd;
170         struct dentry                   *debugfs;
171 };
172
173 static inline struct ci_role_driver *ci_role(struct ci_hdrc *ci)
174 {
175         BUG_ON(ci->role >= CI_ROLE_END || !ci->roles[ci->role]);
176         return ci->roles[ci->role];
177 }
178
179 static inline int ci_role_start(struct ci_hdrc *ci, enum ci_role role)
180 {
181         int ret;
182
183         if (role >= CI_ROLE_END)
184                 return -EINVAL;
185
186         if (!ci->roles[role])
187                 return -ENXIO;
188
189         ret = ci->roles[role]->start(ci);
190         if (!ret)
191                 ci->role = role;
192         return ret;
193 }
194
195 static inline void ci_role_stop(struct ci_hdrc *ci)
196 {
197         enum ci_role role = ci->role;
198
199         if (role == CI_ROLE_END)
200                 return;
201
202         ci->role = CI_ROLE_END;
203
204         ci->roles[role]->stop(ci);
205 }
206
207 /******************************************************************************
208  * REGISTERS
209  *****************************************************************************/
210 /* register size */
211 #define REG_BITS   (32)
212
213 /* register indices */
214 enum ci_hw_regs {
215         CAP_CAPLENGTH,
216         CAP_HCCPARAMS,
217         CAP_DCCPARAMS,
218         CAP_TESTMODE,
219         CAP_LAST = CAP_TESTMODE,
220         OP_USBCMD,
221         OP_USBSTS,
222         OP_USBINTR,
223         OP_DEVICEADDR,
224         OP_ENDPTLISTADDR,
225         OP_PORTSC,
226         OP_DEVLC,
227         OP_OTGSC,
228         OP_USBMODE,
229         OP_ENDPTSETUPSTAT,
230         OP_ENDPTPRIME,
231         OP_ENDPTFLUSH,
232         OP_ENDPTSTAT,
233         OP_ENDPTCOMPLETE,
234         OP_ENDPTCTRL,
235         /* endptctrl1..15 follow */
236         OP_LAST = OP_ENDPTCTRL + ENDPT_MAX / 2,
237 };
238
239 /**
240  * hw_read: reads from a hw register
241  * @reg:  register index
242  * @mask: bitfield mask
243  *
244  * This function returns register contents
245  */
246 static inline u32 hw_read(struct ci_hdrc *ci, enum ci_hw_regs reg, u32 mask)
247 {
248         return ioread32(ci->hw_bank.regmap[reg]) & mask;
249 }
250
251 /**
252  * hw_write: writes to a hw register
253  * @reg:  register index
254  * @mask: bitfield mask
255  * @data: new value
256  */
257 static inline void hw_write(struct ci_hdrc *ci, enum ci_hw_regs reg,
258                             u32 mask, u32 data)
259 {
260         if (~mask)
261                 data = (ioread32(ci->hw_bank.regmap[reg]) & ~mask)
262                         | (data & mask);
263
264         iowrite32(data, ci->hw_bank.regmap[reg]);
265 }
266
267 /**
268  * hw_test_and_clear: tests & clears a hw register
269  * @reg:  register index
270  * @mask: bitfield mask
271  *
272  * This function returns register contents
273  */
274 static inline u32 hw_test_and_clear(struct ci_hdrc *ci, enum ci_hw_regs reg,
275                                     u32 mask)
276 {
277         u32 val = ioread32(ci->hw_bank.regmap[reg]) & mask;
278
279         iowrite32(val, ci->hw_bank.regmap[reg]);
280         return val;
281 }
282
283 /**
284  * hw_test_and_write: tests & writes a hw register
285  * @reg:  register index
286  * @mask: bitfield mask
287  * @data: new value
288  *
289  * This function returns register contents
290  */
291 static inline u32 hw_test_and_write(struct ci_hdrc *ci, enum ci_hw_regs reg,
292                                     u32 mask, u32 data)
293 {
294         u32 val = hw_read(ci, reg, ~0);
295
296         hw_write(ci, reg, mask, data);
297         return (val & mask) >> __ffs(mask);
298 }
299
300 int hw_device_reset(struct ci_hdrc *ci, u32 mode);
301
302 int hw_port_test_set(struct ci_hdrc *ci, u8 mode);
303
304 u8 hw_port_test_get(struct ci_hdrc *ci);
305
306 #endif  /* __DRIVERS_USB_CHIPIDEA_CI_H */