1
2
3
4
5
6
7
8
9
10#ifndef __MUSB_CORE_H__
11#define __MUSB_CORE_H__
12
13#include <linux/slab.h>
14#include <linux/list.h>
15#include <linux/interrupt.h>
16#include <linux/errno.h>
17#include <linux/timer.h>
18#include <linux/device.h>
19#include <linux/usb/ch9.h>
20#include <linux/usb/gadget.h>
21#include <linux/usb.h>
22#include <linux/usb/otg.h>
23#include <linux/usb/musb.h>
24#include <linux/phy/phy.h>
25#include <linux/workqueue.h>
26
27struct musb;
28struct musb_hw_ep;
29struct musb_ep;
30
31
32#define MUSB_HWVERS_MAJOR(x) ((x >> 10) & 0x1f)
33#define MUSB_HWVERS_MINOR(x) (x & 0x3ff)
34#define MUSB_HWVERS_RC 0x8000
35#define MUSB_HWVERS_1300 0x52C
36#define MUSB_HWVERS_1400 0x590
37#define MUSB_HWVERS_1800 0x720
38#define MUSB_HWVERS_1900 0x784
39#define MUSB_HWVERS_2000 0x800
40
41#include "musb_debug.h"
42#include "musb_dma.h"
43
44#include "musb_io.h"
45
46#include "musb_gadget.h"
47#include <linux/usb/hcd.h>
48#include "musb_host.h"
49
50
51
52
53#define is_peripheral_active(m) (!(m)->is_host)
54#define is_host_active(m) ((m)->is_host)
55
56enum {
57 MUSB_PORT_MODE_HOST = 1,
58 MUSB_PORT_MODE_GADGET,
59 MUSB_PORT_MODE_DUAL_ROLE,
60};
61
62
63
64#ifndef MUSB_C_NUM_EPS
65#define MUSB_C_NUM_EPS ((u8)16)
66#endif
67
68#ifndef MUSB_MAX_END0_PACKET
69#define MUSB_MAX_END0_PACKET ((u16)MUSB_EP0_FIFOSIZE)
70#endif
71
72
73enum musb_h_ep0_state {
74 MUSB_EP0_IDLE,
75 MUSB_EP0_START,
76 MUSB_EP0_IN,
77 MUSB_EP0_OUT,
78 MUSB_EP0_STATUS,
79} __attribute__ ((packed));
80
81
82enum musb_g_ep0_state {
83 MUSB_EP0_STAGE_IDLE,
84 MUSB_EP0_STAGE_SETUP,
85 MUSB_EP0_STAGE_TX,
86 MUSB_EP0_STAGE_RX,
87 MUSB_EP0_STAGE_STATUSIN,
88 MUSB_EP0_STAGE_STATUSOUT,
89 MUSB_EP0_STAGE_ACKWAIT,
90} __attribute__ ((packed));
91
92
93
94
95
96#define OTG_TIME_A_WAIT_VRISE 100
97#define OTG_TIME_A_WAIT_BCON 1100
98#define OTG_TIME_A_AIDL_BDIS 200
99#define OTG_TIME_B_ASE0_BRST 100
100
101
102
103#define MUSB_HST_MODE(_musb)\
104 { (_musb)->is_host = true; }
105#define MUSB_DEV_MODE(_musb) \
106 { (_musb)->is_host = false; }
107
108#define test_devctl_hst_mode(_x) \
109 (musb_readb((_x)->mregs, MUSB_DEVCTL)&MUSB_DEVCTL_HM)
110
111#define MUSB_MODE(musb) ((musb)->is_host ? "Host" : "Peripheral")
112
113
114
115struct musb_io;
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148struct musb_platform_ops {
149
150#define MUSB_G_NO_SKB_RESERVE BIT(9)
151#define MUSB_DA8XX BIT(8)
152#define MUSB_PRESERVE_SESSION BIT(7)
153#define MUSB_DMA_UX500 BIT(6)
154#define MUSB_DMA_CPPI41 BIT(5)
155#define MUSB_DMA_CPPI BIT(4)
156#define MUSB_DMA_TUSB_OMAP BIT(3)
157#define MUSB_DMA_INVENTRA BIT(2)
158#define MUSB_IN_TUSB BIT(1)
159#define MUSB_INDEXED_EP BIT(0)
160 u32 quirks;
161
162 int (*init)(struct musb *musb);
163 int (*exit)(struct musb *musb);
164
165 void (*enable)(struct musb *musb);
166 void (*disable)(struct musb *musb);
167
168 u32 (*ep_offset)(u8 epnum, u16 offset);
169 void (*ep_select)(void __iomem *mbase, u8 epnum);
170 u16 fifo_mode;
171 u32 (*fifo_offset)(u8 epnum);
172 u32 (*busctl_offset)(u8 epnum, u16 offset);
173 u8 (*readb)(const void __iomem *addr, unsigned offset);
174 void (*writeb)(void __iomem *addr, unsigned offset, u8 data);
175 u16 (*readw)(const void __iomem *addr, unsigned offset);
176 void (*writew)(void __iomem *addr, unsigned offset, u16 data);
177 u32 (*readl)(const void __iomem *addr, unsigned offset);
178 void (*writel)(void __iomem *addr, unsigned offset, u32 data);
179 void (*read_fifo)(struct musb_hw_ep *hw_ep, u16 len, u8 *buf);
180 void (*write_fifo)(struct musb_hw_ep *hw_ep, u16 len, const u8 *buf);
181 struct dma_controller *
182 (*dma_init) (struct musb *musb, void __iomem *base);
183 void (*dma_exit)(struct dma_controller *c);
184 int (*set_mode)(struct musb *musb, u8 mode);
185 void (*try_idle)(struct musb *musb, unsigned long timeout);
186 int (*recover)(struct musb *musb);
187
188 int (*vbus_status)(struct musb *musb);
189 void (*set_vbus)(struct musb *musb, int on);
190
191 int (*adjust_channel_params)(struct dma_channel *channel,
192 u16 packet_sz, u8 *mode,
193 dma_addr_t *dma_addr, u32 *len);
194 void (*pre_root_reset_end)(struct musb *musb);
195 void (*post_root_reset_end)(struct musb *musb);
196 int (*phy_callback)(enum musb_vbus_id_status status);
197 void (*clear_ep_rxintr)(struct musb *musb, int epnum);
198};
199
200
201
202
203
204
205struct musb_hw_ep {
206 struct musb *musb;
207 void __iomem *fifo;
208 void __iomem *regs;
209
210#if IS_ENABLED(CONFIG_USB_MUSB_TUSB6010)
211 void __iomem *conf;
212#endif
213
214
215 u8 epnum;
216
217
218 bool is_shared_fifo;
219 bool tx_double_buffered;
220 bool rx_double_buffered;
221 u16 max_packet_sz_tx;
222 u16 max_packet_sz_rx;
223
224 struct dma_channel *tx_channel;
225 struct dma_channel *rx_channel;
226
227#if IS_ENABLED(CONFIG_USB_MUSB_TUSB6010)
228
229 dma_addr_t fifo_async;
230 dma_addr_t fifo_sync;
231 void __iomem *fifo_sync_va;
232#endif
233
234
235 struct musb_qh *in_qh;
236 struct musb_qh *out_qh;
237
238 u8 rx_reinit;
239 u8 tx_reinit;
240
241
242 struct musb_ep ep_in;
243 struct musb_ep ep_out;
244};
245
246static inline struct musb_request *next_in_request(struct musb_hw_ep *hw_ep)
247{
248 return next_request(&hw_ep->ep_in);
249}
250
251static inline struct musb_request *next_out_request(struct musb_hw_ep *hw_ep)
252{
253 return next_request(&hw_ep->ep_out);
254}
255
256struct musb_csr_regs {
257
258 u16 txmaxp, txcsr, rxmaxp, rxcsr;
259 u16 rxfifoadd, txfifoadd;
260 u8 txtype, txinterval, rxtype, rxinterval;
261 u8 rxfifosz, txfifosz;
262 u8 txfunaddr, txhubaddr, txhubport;
263 u8 rxfunaddr, rxhubaddr, rxhubport;
264};
265
266struct musb_context_registers {
267
268 u8 power;
269 u8 intrusbe;
270 u16 frame;
271 u8 index, testmode;
272
273 u8 devctl, busctl, misc;
274 u32 otg_interfsel;
275
276 struct musb_csr_regs index_regs[MUSB_C_NUM_EPS];
277};
278
279
280
281
282struct musb {
283
284 spinlock_t lock;
285 spinlock_t list_lock;
286
287 struct musb_io io;
288 const struct musb_platform_ops *ops;
289 struct musb_context_registers context;
290
291 irqreturn_t (*isr)(int, void *);
292 struct delayed_work irq_work;
293 struct delayed_work deassert_reset_work;
294 struct delayed_work finish_resume_work;
295 struct delayed_work gadget_work;
296 u16 hwvers;
297
298 u16 intrrxe;
299 u16 intrtxe;
300
301#define MUSB_PORT_STAT_RESUME (1 << 31)
302
303 u32 port1_status;
304
305 unsigned long rh_timer;
306
307 enum musb_h_ep0_state ep0_stage;
308
309
310
311
312
313
314
315 struct musb_hw_ep *bulk_ep;
316
317 struct list_head control;
318 struct list_head in_bulk;
319 struct list_head out_bulk;
320 struct list_head pending_list;
321
322 struct timer_list otg_timer;
323 struct timer_list dev_timer;
324 struct notifier_block nb;
325
326 struct dma_controller *dma_controller;
327
328 struct device *controller;
329 void __iomem *ctrl_base;
330 void __iomem *mregs;
331
332#if IS_ENABLED(CONFIG_USB_MUSB_TUSB6010)
333 dma_addr_t async;
334 dma_addr_t sync;
335 void __iomem *sync_va;
336 u8 tusb_revision;
337#endif
338
339
340 u8 int_usb;
341 u16 int_rx;
342 u16 int_tx;
343
344 struct usb_phy *xceiv;
345 struct phy *phy;
346
347 int nIrq;
348 unsigned irq_wake:1;
349
350 struct musb_hw_ep endpoints[MUSB_C_NUM_EPS];
351#define control_ep endpoints
352
353#define VBUSERR_RETRY_COUNT 3
354 u16 vbuserr_retry;
355 u16 epmask;
356 u8 nr_endpoints;
357
358 int (*board_set_power)(int state);
359
360 u8 min_power;
361
362 int port_mode;
363 bool session;
364 unsigned long quirk_retries;
365 bool is_host;
366
367 int a_wait_bcon;
368 unsigned long idle_timeout;
369
370 unsigned is_initialized:1;
371 unsigned is_runtime_suspended:1;
372
373
374 unsigned is_active:1;
375
376 unsigned is_multipoint:1;
377
378 unsigned hb_iso_rx:1;
379 unsigned hb_iso_tx:1;
380 unsigned dyn_fifo:1;
381
382 unsigned bulk_split:1;
383#define can_bulk_split(musb,type) \
384 (((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_split)
385
386 unsigned bulk_combine:1;
387#define can_bulk_combine(musb,type) \
388 (((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_combine)
389
390
391 unsigned is_suspended:1;
392
393
394 unsigned may_wakeup:1;
395
396
397
398
399
400 unsigned is_self_powered:1;
401 unsigned is_bus_powered:1;
402
403 unsigned set_address:1;
404 unsigned test_mode:1;
405 unsigned softconnect:1;
406
407 unsigned flush_irq_work:1;
408
409 u8 address;
410 u8 test_mode_nr;
411 u16 ackpend;
412 enum musb_g_ep0_state ep0_state;
413 struct usb_gadget g;
414 struct usb_gadget_driver *gadget_driver;
415 struct usb_hcd *hcd;
416
417
418
419
420
421
422
423
424
425
426
427
428 unsigned double_buffer_not_ok:1;
429
430 const struct musb_hdrc_config *config;
431
432 int xceiv_old_state;
433#ifdef CONFIG_DEBUG_FS
434 struct dentry *debugfs_root;
435#endif
436};
437
438
439#include "musb_regs.h"
440
441static inline struct musb *gadget_to_musb(struct usb_gadget *g)
442{
443 return container_of(g, struct musb, g);
444}
445
446static inline char *musb_ep_xfertype_string(u8 type)
447{
448 char *s;
449
450 switch (type) {
451 case USB_ENDPOINT_XFER_CONTROL:
452 s = "ctrl";
453 break;
454 case USB_ENDPOINT_XFER_ISOC:
455 s = "iso";
456 break;
457 case USB_ENDPOINT_XFER_BULK:
458 s = "bulk";
459 break;
460 case USB_ENDPOINT_XFER_INT:
461 s = "int";
462 break;
463 default:
464 s = "";
465 break;
466 }
467 return s;
468}
469
470#ifdef CONFIG_BLACKFIN
471static inline int musb_read_fifosize(struct musb *musb,
472 struct musb_hw_ep *hw_ep, u8 epnum)
473{
474 musb->nr_endpoints++;
475 musb->epmask |= (1 << epnum);
476
477 if (epnum < 5) {
478 hw_ep->max_packet_sz_tx = 128;
479 hw_ep->max_packet_sz_rx = 128;
480 } else {
481 hw_ep->max_packet_sz_tx = 1024;
482 hw_ep->max_packet_sz_rx = 1024;
483 }
484 hw_ep->is_shared_fifo = false;
485
486 return 0;
487}
488
489static inline void musb_configure_ep0(struct musb *musb)
490{
491 musb->endpoints[0].max_packet_sz_tx = MUSB_EP0_FIFOSIZE;
492 musb->endpoints[0].max_packet_sz_rx = MUSB_EP0_FIFOSIZE;
493 musb->endpoints[0].is_shared_fifo = true;
494}
495
496#else
497
498static inline int musb_read_fifosize(struct musb *musb,
499 struct musb_hw_ep *hw_ep, u8 epnum)
500{
501 void __iomem *mbase = musb->mregs;
502 u8 reg = 0;
503
504
505 reg = musb_readb(mbase, musb->io.ep_offset(epnum, MUSB_FIFOSIZE));
506
507 if (!reg)
508 return -ENODEV;
509
510 musb->nr_endpoints++;
511 musb->epmask |= (1 << epnum);
512
513 hw_ep->max_packet_sz_tx = 1 << (reg & 0x0f);
514
515
516 if ((reg & 0xf0) == 0xf0) {
517 hw_ep->max_packet_sz_rx = hw_ep->max_packet_sz_tx;
518 hw_ep->is_shared_fifo = true;
519 return 0;
520 } else {
521 hw_ep->max_packet_sz_rx = 1 << ((reg & 0xf0) >> 4);
522 hw_ep->is_shared_fifo = false;
523 }
524
525 return 0;
526}
527
528static inline void musb_configure_ep0(struct musb *musb)
529{
530 musb->endpoints[0].max_packet_sz_tx = MUSB_EP0_FIFOSIZE;
531 musb->endpoints[0].max_packet_sz_rx = MUSB_EP0_FIFOSIZE;
532 musb->endpoints[0].is_shared_fifo = true;
533}
534#endif
535
536
537
538
539extern const char musb_driver_name[];
540
541extern void musb_stop(struct musb *musb);
542extern void musb_start(struct musb *musb);
543
544extern void musb_write_fifo(struct musb_hw_ep *ep, u16 len, const u8 *src);
545extern void musb_read_fifo(struct musb_hw_ep *ep, u16 len, u8 *dst);
546
547extern void musb_load_testpacket(struct musb *);
548
549extern irqreturn_t musb_interrupt(struct musb *);
550
551extern void musb_hnp_stop(struct musb *musb);
552
553int musb_queue_resume_work(struct musb *musb,
554 int (*callback)(struct musb *musb, void *data),
555 void *data);
556
557static inline void musb_platform_set_vbus(struct musb *musb, int is_on)
558{
559 if (musb->ops->set_vbus)
560 musb->ops->set_vbus(musb, is_on);
561}
562
563static inline void musb_platform_enable(struct musb *musb)
564{
565 if (musb->ops->enable)
566 musb->ops->enable(musb);
567}
568
569static inline void musb_platform_disable(struct musb *musb)
570{
571 if (musb->ops->disable)
572 musb->ops->disable(musb);
573}
574
575static inline int musb_platform_set_mode(struct musb *musb, u8 mode)
576{
577 if (!musb->ops->set_mode)
578 return 0;
579
580 return musb->ops->set_mode(musb, mode);
581}
582
583static inline void musb_platform_try_idle(struct musb *musb,
584 unsigned long timeout)
585{
586 if (musb->ops->try_idle)
587 musb->ops->try_idle(musb, timeout);
588}
589
590static inline int musb_platform_recover(struct musb *musb)
591{
592 if (!musb->ops->recover)
593 return 0;
594
595 return musb->ops->recover(musb);
596}
597
598static inline int musb_platform_get_vbus_status(struct musb *musb)
599{
600 if (!musb->ops->vbus_status)
601 return -EINVAL;
602
603 return musb->ops->vbus_status(musb);
604}
605
606static inline int musb_platform_init(struct musb *musb)
607{
608 if (!musb->ops->init)
609 return -EINVAL;
610
611 return musb->ops->init(musb);
612}
613
614static inline int musb_platform_exit(struct musb *musb)
615{
616 if (!musb->ops->exit)
617 return -EINVAL;
618
619 return musb->ops->exit(musb);
620}
621
622static inline void musb_platform_pre_root_reset_end(struct musb *musb)
623{
624 if (musb->ops->pre_root_reset_end)
625 musb->ops->pre_root_reset_end(musb);
626}
627
628static inline void musb_platform_post_root_reset_end(struct musb *musb)
629{
630 if (musb->ops->post_root_reset_end)
631 musb->ops->post_root_reset_end(musb);
632}
633
634static inline void musb_platform_clear_ep_rxintr(struct musb *musb, int epnum)
635{
636 if (musb->ops->clear_ep_rxintr)
637 musb->ops->clear_ep_rxintr(musb, epnum);
638}
639
640
641
642
643
644extern enum musb_mode musb_get_mode(struct device *dev);
645
646#endif
647