[USB] OHCI now works on bare metal. Device probing a bit buggy though.
[people/balajirrao/gpxe.git] / src / drivers / bus / usb / ohci.h
1 /*
2  * OHCI HCD (Host Controller Driver) for USB.
3  *
4  * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
5  * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net>
6  *
7  * This file is licenced under the GPL.
8  */
9
10 /*
11  * __hc32 and __hc16 are "Host Controller" types, they may be equivalent to
12  * __leXX (normally) or __beXX (given OHCI_BIG_ENDIAN), depending on the
13  * host controller implementation.
14  */
15
16 #include <byteswap.h>
17 #include <little_bswap.h>
18
19 typedef uint32_t  __hc32;
20 typedef uint16_t  __hc16;
21
22 /* OHCI CONTROL AND STATUS REGISTER MASKS */
23
24 /*
25  * HcControl (control) register masks
26  */
27 #define OHCI_CTRL_CBSR  (3 << 0)        /* control/bulk service ratio */
28 #define OHCI_CTRL_PLE   (1 << 2)        /* periodic list enable */
29 #define OHCI_CTRL_IE    (1 << 3)        /* isochronous enable */
30 #define OHCI_CTRL_CLE   (1 << 4)        /* control list enable */
31 #define OHCI_CTRL_BLE   (1 << 5)        /* bulk list enable */
32 #define OHCI_CTRL_HCFS  (3 << 6)        /* host controller functional state */
33 #define OHCI_CTRL_IR    (1 << 8)        /* interrupt routing */
34 #define OHCI_CTRL_RWC   (1 << 9)        /* remote wakeup connected */
35 #define OHCI_CTRL_RWE   (1 << 10)       /* remote wakeup enable */
36
37 /* pre-shifted values for HCFS */
38 #       define OHCI_USB_RESET   (0 << 6)
39 #       define OHCI_USB_RESUME  (1 << 6)
40 #       define OHCI_USB_OPER    (2 << 6)
41 #       define OHCI_USB_SUSPEND (3 << 6)
42
43 /*
44  * HcCommandStatus (cmdstatus) register masks
45  */
46 #define OHCI_HCR        (1 << 0)        /* host controller reset */
47 #define OHCI_CLF        (1 << 1)        /* control list filled */
48 #define OHCI_BLF        (1 << 2)        /* bulk list filled */
49 #define OHCI_OCR        (1 << 3)        /* ownership change request */
50 #define OHCI_SOC        (3 << 16)       /* scheduling overrun count */
51
52 /*
53  * masks used with interrupt registers:
54  * HcInterruptStatus (intrstatus)
55  * HcInterruptEnable (intrenable)
56  * HcInterruptDisable (intrdisable)
57  */
58 #define OHCI_INTR_SO    (1 << 0)        /* scheduling overrun */
59 #define OHCI_INTR_WDH   (1 << 1)        /* writeback of done_head */
60 #define OHCI_INTR_SF    (1 << 2)        /* start frame */
61 #define OHCI_INTR_RD    (1 << 3)        /* resume detect */
62 #define OHCI_INTR_UE    (1 << 4)        /* unrecoverable error */
63 #define OHCI_INTR_FNO   (1 << 5)        /* frame number overflow */
64 #define OHCI_INTR_RHSC  (1 << 6)        /* root hub status change */
65 #define OHCI_INTR_OC    (1 << 30)       /* ownership change */
66 #define OHCI_INTR_MIE   (1 << 31)       /* master interrupt enable */
67
68
69 /* OHCI ROOT HUB REGISTER MASKS */
70
71 /* roothub.portstatus [i] bits */
72 #define RH_PS_CCS            0x00000001         /* current connect status */
73 #define RH_PS_PES            0x00000002         /* port enable status*/
74 #define RH_PS_PSS            0x00000004         /* port suspend status */
75 #define RH_PS_POCI           0x00000008         /* port over current indicator */
76 #define RH_PS_PRS            0x00000010         /* port reset status */
77 #define RH_PS_PPS            0x00000100         /* port power status */
78 #define RH_PS_LSDA           0x00000200         /* low speed device attached */
79 #define RH_PS_CSC            0x00010000         /* connect status change */
80 #define RH_PS_PESC           0x00020000         /* port enable status change */
81 #define RH_PS_PSSC           0x00040000         /* port suspend status change */
82 #define RH_PS_OCIC           0x00080000         /* over current indicator change */
83 #define RH_PS_PRSC           0x00100000         /* port reset status change */
84
85 /* roothub.status bits */
86 #define RH_HS_LPS            0x00000001         /* local power status */
87 #define RH_HS_OCI            0x00000002         /* over current indicator */
88 #define RH_HS_DRWE           0x00008000         /* device remote wakeup enable */
89 #define RH_HS_LPSC           0x00010000         /* local power status change */
90 #define RH_HS_OCIC           0x00020000         /* over current indicator change */
91 #define RH_HS_CRWE           0x80000000         /* clear remote wakeup enable */
92
93 /* roothub.b masks */
94 #define RH_B_DR         0x0000ffff              /* device removable flags */
95 #define RH_B_PPCM       0xffff0000              /* port power control mask */
96
97 /* roothub.a masks */
98 #define RH_A_NDP        (0xff << 0)             /* number of downstream ports */
99 #define RH_A_PSM        (1 << 8)                /* power switching mode */
100 #define RH_A_NPS        (1 << 9)                /* no power switching */
101 #define RH_A_DT         (1 << 10)               /* device type (mbz) */
102 #define RH_A_OCPM       (1 << 11)               /* over current protection mode */
103 #define RH_A_NOCP       (1 << 12)               /* no over current protection */
104 #define RH_A_POTPGT     (0xff << 24)            /* power on to power good time */
105
106 /*
107  * OHCI Endpoint Descriptor (ED) ... holds TD queue
108  * See OHCI spec, section 4.2
109  *
110  * This is a "Queue Head" for those transfers, which is why
111  * both EHCI and UHCI call similar structures a "QH".
112  */
113 struct ohci_ed {
114         /* first fields are hardware-specified */
115         __hc32                  hwINFO;      /* endpoint config bitmap */
116         /* info bits defined by hcd */
117 #define ED_DEQUEUE      (1 << 27)
118         /* info bits defined by the hardware */
119 #define ED_ISO          (1 << 15)
120 #define ED_SKIP         (1 << 14)
121 #define ED_LOWSPEED     (1 << 13)
122 #define ED_OUT          (0x01 << 11)
123 #define ED_IN           (0x02 << 11)
124         __hc32                  hwTailP;        /* tail of TD list */
125         __hc32                  hwHeadP;        /* head of TD list (hc r/w) */
126 #define ED_C            (0x02)                  /* toggle carry */
127 #define ED_H            (0x01)                  /* halted */
128         __hc32                  hwNextED;       /* next ED in list */
129
130         /* rest are purely for the driver's use */
131         unsigned long           dma;            /* addr of ED */
132         struct ohci_td          *dummy_td;              /* next TD to activate */
133
134         struct list_head        urbp_list;
135         
136         uint8_t                 state;          /* ED_{IDLE,UNLINK,OPER} */
137 #define ED_IDLE         0x00            /* NOT linked to HC */
138 #define ED_UNLINK       0x01            /* being unlinked from hc */
139 #define ED_OPER         0x02            /* IS linked to hc */
140 } __attribute__ ((aligned(16)));
141
142 struct ohci_td {
143         /* first fields are hardware-specified */
144         __hc32          hwINFO;         /* transfer info bitmask */
145
146         /* hwINFO bits for both general and iso tds: */
147 #define TD_CC       0xf0000000                  /* condition code */
148 #define TD_CC_GET(td_p) ((td_p >>28) & 0x0f)
149 //#define TD_CC_SET(td_p, cc) (td_p) = ((td_p) & 0x0fffffff) | (((cc) & 0x0f) << 28)
150 #define TD_DI       0x00E00000                  /* frames before interrupt */
151 #define TD_DI_SET(X) (((X) & 0x07)<< 21)
152         /* these two bits are available for definition/use by HCDs in both
153          * general and iso tds ... others are available for only one type
154          */
155 #define TD_DONE     0x00020000                  /* retired to donelist */
156 #define TD_ISO      0x00010000                  /* copy of ED_ISO */
157
158         /* hwINFO bits for general tds: */
159 #define TD_EC       0x0C000000                  /* error count */
160 #define TD_T        0x03000000                  /* data toggle state */
161 #define TD_T_DATA0  0x02000000                          /* DATA0 */
162 #define TD_T_DATA1  0x03000000                          /* DATA1 */
163 #define TD_T_TOGGLE 0x00000000                          /* uses ED_C */
164 #define TD_DP       0x00180000                  /* direction/pid */
165 #define TD_DP_SETUP 0x00000000                  /* SETUP pid */
166 #define TD_DP_IN    0x00100000                          /* IN pid */
167 #define TD_DP_OUT   0x00080000                          /* OUT pid */
168                                                         /* 0x00180000 rsvd */
169 #define TD_R        0x00040000                  /* round: short packets OK? */
170
171         /* (no hwINFO #defines yet for iso tds) */
172
173         __hc32          hwCBP;          /* Current Buffer Pointer (or 0) */
174         __hc32          hwNextTD;       /* Next TD Pointer */
175         __hc32          hwBE;           /* Memory Buffer End Pointer */
176
177         /* PSW is only for ISO.  Only 1 PSW entry is used, but on
178          * big-endian PPC hardware that's the second entry.
179          */
180 #define MAXPSW  2
181         __hc16          hwPSW [MAXPSW];
182
183         /* For driver's use */
184         struct list_head        list;
185         unsigned long           dma;
186         struct ohci_ed          *ed;
187         unsigned int            len;
188
189 } __attribute__ ((aligned(32)));        /* c/b/i need 16; only iso needs 32 */
190
191 /*
192  * The HCCA (Host Controller Communications Area) is a 256 byte
193  * structure defined section 4.4.1 of the OHCI spec. The HC is
194  * told the base address of it.  It must be 256-byte aligned.
195  */
196 struct ohci_hcca {
197 #define NUM_INTS 32
198         __hc32  int_table [NUM_INTS];   /* periodic schedule */
199
200         /*
201          * OHCI defines u16 frame_no, followed by u16 zero pad.
202          * Since some processors can't do 16 bit bus accesses,
203          * portable access must be a 32 bits wide.
204          */
205         __hc32  frame_no;               /* current frame number */
206         __hc32  done_head;              /* info returned for an interrupt */
207         uint8_t reserved_for_hc [116];
208         uint8_t what [4];               /* spec only identifies 252 bytes :) */
209 } __attribute__ ((aligned(256)));
210
211
212 struct ohci_regs {
213         /* control and status registers (section 7.1) */
214         __hc32  revision;
215         __hc32  control;
216         __hc32  cmdstatus;
217         __hc32  intrstatus;
218         __hc32  intrenable;
219         __hc32  intrdisable;
220
221         /* memory pointers (section 7.2) */
222         __hc32  hcca;
223         __hc32  ed_periodcurrent;
224         __hc32  ed_controlhead;
225         __hc32  ed_controlcurrent;
226         __hc32  ed_bulkhead;
227         __hc32  ed_bulkcurrent;
228         __hc32  donehead;
229
230         /* frame counters (section 7.3) */
231         __hc32  fminterval;
232         __hc32  fmremaining;
233         __hc32  fmnumber;
234         __hc32  periodicstart;
235         __hc32  lsthresh;
236
237         /* Root hub ports (section 7.4) */
238         struct  ohci_roothub_regs {
239                 __hc32  a;
240                 __hc32  b;
241                 __hc32  status;
242 #define MAX_ROOT_PORTS  15      /* maximum OHCI root hub ports (RH_A_NDP) */
243                 __hc32  portstatus [MAX_ROOT_PORTS];
244         } roothub;
245
246         /* and optional "legacy support" registers (appendix B) at 0x0100 */
247
248 } __attribute__ ((aligned(32)));
249
250 struct ohci_urb_priv {
251         struct list_head        list;
252         struct list_head        td_list;
253
254         struct ohci_td  *first_td, *last_td;
255 };
256
257 /*
258  * This is the full ohci controller description
259  *
260  * Note how the "proper" USB information is just
261  * a subset of what the full implementation needs. (Linus)
262  */
263
264 struct ohci_hcd {
265         struct ohci_regs        *regs;
266
267         uint32_t                hc_control;
268         uint16_t                num_ports;
269
270         struct ohci_hcca        *hcca;
271         uint32_t                fminterval;
272
273         struct ohci_ed          *last_bulk_ed;
274         struct ohci_ed          *last_control_ed;
275 };
276
277 static inline struct ohci_hcd *hcd_to_ohci (struct usb_hcd *hcd)
278 {
279         return (struct ohci_hcd *) (hcd->hcpriv);
280 }
281
282 #define FI                      0x2edf          /* 12000 bits per frame (-1) */
283 #define FSMP(fi)                (0x7fff & ((6 * ((fi) - 210)) / 7))
284 #define FIT                     (1 << 31)
285 #define LSTHRESH                0x628           /* lowspeed bit threshold */
286
287 static inline void periodic_reinit (struct ohci_hcd *ohci)
288 {
289         u32     fi = ohci->fminterval & 0x03fff;
290         u32     fit = readl(&ohci->regs->fminterval) & FIT;
291
292         writel ((fit ^ FIT) | ohci->fminterval,
293                                                 &ohci->regs->fminterval);
294         writel (((1 * fi) / 10) & 0x3fff,
295                                                 &ohci->regs->periodicstart);
296 }
297
298 #define read_roothub(hc, register, mask) (readl (&hc->regs->roothub.register))
299
300
301 static inline u32 roothub_a (struct ohci_hcd *hc)
302         { return read_roothub (hc, a, 0xfc0fe000); }
303 static inline u32 roothub_b (struct ohci_hcd *hc)
304         { return readl (&hc->regs->roothub.b); }
305 static inline u32 roothub_status (struct ohci_hcd *hc)
306         { return readl (&hc->regs->roothub.status); }
307 static inline u32 roothub_portstatus (struct ohci_hcd *hc, int i)
308         { return read_roothub (hc, portstatus [i], 0xffe0fce0); }
309
310 /*-------------------------------------------------------------------------*/
311
312 /* We support only little endian HC descs at the moment. */
313 #define big_endian_desc(ohci) 0
314
315 /* cpu to ohci */
316 static inline __hc16 cpu_to_hc16 (const struct ohci_hcd *ohci __unused, const u16 x)
317 {
318         return big_endian_desc(ohci) ?
319                 (__hc16)cpu_to_be16(x) :
320                 (__hc16)cpu_to_le16(x);
321 }
322
323 static inline __hc32 cpu_to_hc32 (const struct ohci_hcd *ohci __unused, const u32 x)
324 {
325         return big_endian_desc(ohci) ?
326                 (__hc32)cpu_to_be32(x) :
327                 (__hc32)cpu_to_le32(x);
328 }
329
330 static inline u16 hc16_to_cpu (const struct ohci_hcd *ohci __unused, const __hc16 x)
331 {
332         return big_endian_desc(ohci) ?
333                 be16_to_cpu(x) :
334                 le16_to_cpu(x);
335 }
336
337 static inline u32 hc32_to_cpu (const struct ohci_hcd *ohci __unused, const __hc32 x)
338 {
339         return big_endian_desc(ohci) ?
340                 be32_to_cpu(x) :
341                 le32_to_cpu(x);
342 }