musb_core.h 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593
  1. /*
  2. * MUSB OTG driver defines
  3. *
  4. * Copyright 2005 Mentor Graphics Corporation
  5. * Copyright (C) 2005-2006 by Texas Instruments
  6. * Copyright (C) 2006-2007 Nokia Corporation
  7. *
  8. * This program is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU General Public License
  10. * version 2 as published by the Free Software Foundation.
  11. *
  12. * This program is distributed in the hope that it will be useful, but
  13. * WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15. * General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU General Public License
  18. * along with this program; if not, write to the Free Software
  19. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20. * 02110-1301 USA
  21. *
  22. * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
  23. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  24. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
  25. * NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26. * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  27. * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  28. * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  29. * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  31. * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32. *
  33. */
  34. #ifndef __MUSB_CORE_H__
  35. #define __MUSB_CORE_H__
  36. #include <linux/slab.h>
  37. #include <linux/list.h>
  38. #include <linux/interrupt.h>
  39. #include <linux/errno.h>
  40. #include <linux/timer.h>
  41. #include <linux/device.h>
  42. #include <linux/usb/ch9.h>
  43. #include <linux/usb/gadget.h>
  44. #include <linux/usb.h>
  45. #include <linux/usb/otg.h>
  46. #include <linux/usb/musb.h>
  47. struct musb;
  48. struct musb_hw_ep;
  49. struct musb_ep;
  50. /* Helper defines for struct musb->hwvers */
  51. #define MUSB_HWVERS_MAJOR(x) ((x >> 10) & 0x1f)
  52. #define MUSB_HWVERS_MINOR(x) (x & 0x3ff)
  53. #define MUSB_HWVERS_RC 0x8000
  54. #define MUSB_HWVERS_1300 0x52C
  55. #define MUSB_HWVERS_1400 0x590
  56. #define MUSB_HWVERS_1800 0x720
  57. #define MUSB_HWVERS_1900 0x784
  58. #define MUSB_HWVERS_2000 0x800
  59. #include "musb_debug.h"
  60. #include "musb_dma.h"
  61. #include "musb_io.h"
  62. #include "musb_regs.h"
  63. #include "musb_gadget.h"
  64. #include <linux/usb/hcd.h>
  65. #include "musb_host.h"
  66. /* NOTE: otg and peripheral-only state machines start at B_IDLE.
  67. * OTG or host-only go to A_IDLE when ID is sensed.
  68. */
  69. #define is_peripheral_active(m) (!(m)->is_host)
  70. #define is_host_active(m) ((m)->is_host)
  71. #ifdef CONFIG_PROC_FS
  72. #include <linux/fs.h>
  73. #define MUSB_CONFIG_PROC_FS
  74. #endif
  75. /****************************** PERIPHERAL ROLE *****************************/
  76. extern irqreturn_t musb_g_ep0_irq(struct musb *);
  77. extern void musb_g_tx(struct musb *, u8);
  78. extern void musb_g_rx(struct musb *, u8);
  79. extern void musb_g_reset(struct musb *);
  80. extern void musb_g_suspend(struct musb *);
  81. extern void musb_g_resume(struct musb *);
  82. extern void musb_g_wakeup(struct musb *);
  83. extern void musb_g_disconnect(struct musb *);
  84. /****************************** HOST ROLE ***********************************/
  85. extern irqreturn_t musb_h_ep0_irq(struct musb *);
  86. extern void musb_host_tx(struct musb *, u8);
  87. extern void musb_host_rx(struct musb *, u8);
  88. /****************************** CONSTANTS ********************************/
  89. #ifndef MUSB_C_NUM_EPS
  90. #define MUSB_C_NUM_EPS ((u8)16)
  91. #endif
  92. #ifndef MUSB_MAX_END0_PACKET
  93. #define MUSB_MAX_END0_PACKET ((u16)MUSB_EP0_FIFOSIZE)
  94. #endif
  95. /* host side ep0 states */
  96. enum musb_h_ep0_state {
  97. MUSB_EP0_IDLE,
  98. MUSB_EP0_START, /* expect ack of setup */
  99. MUSB_EP0_IN, /* expect IN DATA */
  100. MUSB_EP0_OUT, /* expect ack of OUT DATA */
  101. MUSB_EP0_STATUS, /* expect ack of STATUS */
  102. } __attribute__ ((packed));
  103. /* peripheral side ep0 states */
  104. enum musb_g_ep0_state {
  105. MUSB_EP0_STAGE_IDLE, /* idle, waiting for SETUP */
  106. MUSB_EP0_STAGE_SETUP, /* received SETUP */
  107. MUSB_EP0_STAGE_TX, /* IN data */
  108. MUSB_EP0_STAGE_RX, /* OUT data */
  109. MUSB_EP0_STAGE_STATUSIN, /* (after OUT data) */
  110. MUSB_EP0_STAGE_STATUSOUT, /* (after IN data) */
  111. MUSB_EP0_STAGE_ACKWAIT, /* after zlp, before statusin */
  112. } __attribute__ ((packed));
  113. /*
  114. * OTG protocol constants. See USB OTG 1.3 spec,
  115. * sections 5.5 "Device Timings" and 6.6.5 "Timers".
  116. */
  117. #define OTG_TIME_A_WAIT_VRISE 100 /* msec (max) */
  118. #define OTG_TIME_A_WAIT_BCON 1100 /* min 1 second */
  119. #define OTG_TIME_A_AIDL_BDIS 200 /* min 200 msec */
  120. #define OTG_TIME_B_ASE0_BRST 100 /* min 3.125 ms */
  121. /*************************** REGISTER ACCESS ********************************/
  122. /* Endpoint registers (other than dynfifo setup) can be accessed either
  123. * directly with the "flat" model, or after setting up an index register.
  124. */
  125. #if defined(CONFIG_ARCH_DAVINCI) || defined(CONFIG_SOC_OMAP2430) \
  126. || defined(CONFIG_SOC_OMAP3430) || defined(CONFIG_BLACKFIN) \
  127. || defined(CONFIG_ARCH_OMAP4)
  128. /* REVISIT indexed access seemed to
  129. * misbehave (on DaVinci) for at least peripheral IN ...
  130. */
  131. #define MUSB_FLAT_REG
  132. #endif
  133. /* TUSB mapping: "flat" plus ep0 special cases */
  134. #if defined(CONFIG_USB_MUSB_TUSB6010) || \
  135. defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
  136. #define musb_ep_select(_mbase, _epnum) \
  137. musb_writeb((_mbase), MUSB_INDEX, (_epnum))
  138. #define MUSB_EP_OFFSET MUSB_TUSB_OFFSET
  139. /* "flat" mapping: each endpoint has its own i/o address */
  140. #elif defined(MUSB_FLAT_REG)
  141. #define musb_ep_select(_mbase, _epnum) (((void)(_mbase)), ((void)(_epnum)))
  142. #define MUSB_EP_OFFSET MUSB_FLAT_OFFSET
  143. /* "indexed" mapping: INDEX register controls register bank select */
  144. #else
  145. #define musb_ep_select(_mbase, _epnum) \
  146. musb_writeb((_mbase), MUSB_INDEX, (_epnum))
  147. #define MUSB_EP_OFFSET MUSB_INDEXED_OFFSET
  148. #endif
  149. /****************************** FUNCTIONS ********************************/
  150. #define MUSB_HST_MODE(_musb)\
  151. { (_musb)->is_host = true; }
  152. #define MUSB_DEV_MODE(_musb) \
  153. { (_musb)->is_host = false; }
  154. #define test_devctl_hst_mode(_x) \
  155. (musb_readb((_x)->mregs, MUSB_DEVCTL)&MUSB_DEVCTL_HM)
  156. #define MUSB_MODE(musb) ((musb)->is_host ? "Host" : "Peripheral")
  157. /******************************** TYPES *************************************/
  158. /**
  159. * struct musb_platform_ops - Operations passed to musb_core by HW glue layer
  160. * @init: turns on clocks, sets up platform-specific registers, etc
  161. * @exit: undoes @init
  162. * @set_mode: forcefully changes operating mode
  163. * @try_ilde: tries to idle the IP
  164. * @vbus_status: returns vbus status if possible
  165. * @set_vbus: forces vbus status
  166. * @adjust_channel_params: pre check for standard dma channel_program func
  167. */
  168. struct musb_platform_ops {
  169. int (*init)(struct musb *musb);
  170. int (*exit)(struct musb *musb);
  171. void (*enable)(struct musb *musb);
  172. void (*disable)(struct musb *musb);
  173. int (*set_mode)(struct musb *musb, u8 mode);
  174. void (*try_idle)(struct musb *musb, unsigned long timeout);
  175. int (*vbus_status)(struct musb *musb);
  176. void (*set_vbus)(struct musb *musb, int on);
  177. int (*adjust_channel_params)(struct dma_channel *channel,
  178. u16 packet_sz, u8 *mode,
  179. dma_addr_t *dma_addr, u32 *len);
  180. };
  181. /*
  182. * struct musb_hw_ep - endpoint hardware (bidirectional)
  183. *
  184. * Ordered slightly for better cacheline locality.
  185. */
  186. struct musb_hw_ep {
  187. struct musb *musb;
  188. void __iomem *fifo;
  189. void __iomem *regs;
  190. #if defined(CONFIG_USB_MUSB_TUSB6010) || \
  191. defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
  192. void __iomem *conf;
  193. #endif
  194. /* index in musb->endpoints[] */
  195. u8 epnum;
  196. /* hardware configuration, possibly dynamic */
  197. bool is_shared_fifo;
  198. bool tx_double_buffered;
  199. bool rx_double_buffered;
  200. u16 max_packet_sz_tx;
  201. u16 max_packet_sz_rx;
  202. struct dma_channel *tx_channel;
  203. struct dma_channel *rx_channel;
  204. #if defined(CONFIG_USB_MUSB_TUSB6010) || \
  205. defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
  206. /* TUSB has "asynchronous" and "synchronous" dma modes */
  207. dma_addr_t fifo_async;
  208. dma_addr_t fifo_sync;
  209. void __iomem *fifo_sync_va;
  210. #endif
  211. void __iomem *target_regs;
  212. /* currently scheduled peripheral endpoint */
  213. struct musb_qh *in_qh;
  214. struct musb_qh *out_qh;
  215. u8 rx_reinit;
  216. u8 tx_reinit;
  217. /* peripheral side */
  218. struct musb_ep ep_in; /* TX */
  219. struct musb_ep ep_out; /* RX */
  220. };
  221. static inline struct musb_request *next_in_request(struct musb_hw_ep *hw_ep)
  222. {
  223. return next_request(&hw_ep->ep_in);
  224. }
  225. static inline struct musb_request *next_out_request(struct musb_hw_ep *hw_ep)
  226. {
  227. return next_request(&hw_ep->ep_out);
  228. }
  229. struct musb_csr_regs {
  230. /* FIFO registers */
  231. u16 txmaxp, txcsr, rxmaxp, rxcsr;
  232. u16 rxfifoadd, txfifoadd;
  233. u8 txtype, txinterval, rxtype, rxinterval;
  234. u8 rxfifosz, txfifosz;
  235. u8 txfunaddr, txhubaddr, txhubport;
  236. u8 rxfunaddr, rxhubaddr, rxhubport;
  237. };
  238. struct musb_context_registers {
  239. u8 power;
  240. u16 intrtxe, intrrxe;
  241. u8 intrusbe;
  242. u16 frame;
  243. u8 index, testmode;
  244. u8 devctl, busctl, misc;
  245. u32 otg_interfsel;
  246. struct musb_csr_regs index_regs[MUSB_C_NUM_EPS];
  247. };
  248. /*
  249. * struct musb - Driver instance data.
  250. */
  251. struct musb {
  252. /* device lock */
  253. spinlock_t lock;
  254. const struct musb_platform_ops *ops;
  255. struct musb_context_registers context;
  256. irqreturn_t (*isr)(int, void *);
  257. struct work_struct irq_work;
  258. u16 hwvers;
  259. /* this hub status bit is reserved by USB 2.0 and not seen by usbcore */
  260. #define MUSB_PORT_STAT_RESUME (1 << 31)
  261. u32 port1_status;
  262. unsigned long rh_timer;
  263. enum musb_h_ep0_state ep0_stage;
  264. /* bulk traffic normally dedicates endpoint hardware, and each
  265. * direction has its own ring of host side endpoints.
  266. * we try to progress the transfer at the head of each endpoint's
  267. * queue until it completes or NAKs too much; then we try the next
  268. * endpoint.
  269. */
  270. struct musb_hw_ep *bulk_ep;
  271. struct list_head control; /* of musb_qh */
  272. struct list_head in_bulk; /* of musb_qh */
  273. struct list_head out_bulk; /* of musb_qh */
  274. struct timer_list otg_timer;
  275. struct notifier_block nb;
  276. struct dma_controller *dma_controller;
  277. struct device *controller;
  278. void __iomem *ctrl_base;
  279. void __iomem *mregs;
  280. #if defined(CONFIG_USB_MUSB_TUSB6010) || \
  281. defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
  282. dma_addr_t async;
  283. dma_addr_t sync;
  284. void __iomem *sync_va;
  285. #endif
  286. /* passed down from chip/board specific irq handlers */
  287. u8 int_usb;
  288. u16 int_rx;
  289. u16 int_tx;
  290. struct usb_phy *xceiv;
  291. int nIrq;
  292. unsigned irq_wake:1;
  293. struct musb_hw_ep endpoints[MUSB_C_NUM_EPS];
  294. #define control_ep endpoints
  295. #define VBUSERR_RETRY_COUNT 3
  296. u16 vbuserr_retry;
  297. u16 epmask;
  298. u8 nr_endpoints;
  299. int (*board_set_power)(int state);
  300. u8 min_power; /* vbus for periph, in mA/2 */
  301. bool is_host;
  302. int a_wait_bcon; /* VBUS timeout in msecs */
  303. unsigned long idle_timeout; /* Next timeout in jiffies */
  304. /* active means connected and not suspended */
  305. unsigned is_active:1;
  306. unsigned is_multipoint:1;
  307. unsigned ignore_disconnect:1; /* during bus resets */
  308. unsigned hb_iso_rx:1; /* high bandwidth iso rx? */
  309. unsigned hb_iso_tx:1; /* high bandwidth iso tx? */
  310. unsigned dyn_fifo:1; /* dynamic FIFO supported? */
  311. unsigned bulk_split:1;
  312. #define can_bulk_split(musb,type) \
  313. (((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_split)
  314. unsigned bulk_combine:1;
  315. #define can_bulk_combine(musb,type) \
  316. (((type) == USB_ENDPOINT_XFER_BULK) && (musb)->bulk_combine)
  317. /* is_suspended means USB B_PERIPHERAL suspend */
  318. unsigned is_suspended:1;
  319. /* may_wakeup means remote wakeup is enabled */
  320. unsigned may_wakeup:1;
  321. /* is_self_powered is reported in device status and the
  322. * config descriptor. is_bus_powered means B_PERIPHERAL
  323. * draws some VBUS current; both can be true.
  324. */
  325. unsigned is_self_powered:1;
  326. unsigned is_bus_powered:1;
  327. unsigned set_address:1;
  328. unsigned test_mode:1;
  329. unsigned softconnect:1;
  330. u8 address;
  331. u8 test_mode_nr;
  332. u16 ackpend; /* ep0 */
  333. enum musb_g_ep0_state ep0_state;
  334. struct usb_gadget g; /* the gadget */
  335. struct usb_gadget_driver *gadget_driver; /* its driver */
  336. /*
  337. * FIXME: Remove this flag.
  338. *
  339. * This is only added to allow Blackfin to work
  340. * with current driver. For some unknown reason
  341. * Blackfin doesn't work with double buffering
  342. * and that's enabled by default.
  343. *
  344. * We added this flag to forcefully disable double
  345. * buffering until we get it working.
  346. */
  347. unsigned double_buffer_not_ok:1;
  348. struct musb_hdrc_config *config;
  349. #ifdef MUSB_CONFIG_PROC_FS
  350. struct proc_dir_entry *proc_entry;
  351. #endif
  352. int xceiv_old_state;
  353. #ifdef CONFIG_DEBUG_FS
  354. struct dentry *debugfs_root;
  355. #endif
  356. };
  357. static inline struct musb *gadget_to_musb(struct usb_gadget *g)
  358. {
  359. return container_of(g, struct musb, g);
  360. }
  361. #ifdef CONFIG_BLACKFIN
  362. static inline int musb_read_fifosize(struct musb *musb,
  363. struct musb_hw_ep *hw_ep, u8 epnum)
  364. {
  365. musb->nr_endpoints++;
  366. musb->epmask |= (1 << epnum);
  367. if (epnum < 5) {
  368. hw_ep->max_packet_sz_tx = 128;
  369. hw_ep->max_packet_sz_rx = 128;
  370. } else {
  371. hw_ep->max_packet_sz_tx = 1024;
  372. hw_ep->max_packet_sz_rx = 1024;
  373. }
  374. hw_ep->is_shared_fifo = false;
  375. return 0;
  376. }
  377. static inline void musb_configure_ep0(struct musb *musb)
  378. {
  379. musb->endpoints[0].max_packet_sz_tx = MUSB_EP0_FIFOSIZE;
  380. musb->endpoints[0].max_packet_sz_rx = MUSB_EP0_FIFOSIZE;
  381. musb->endpoints[0].is_shared_fifo = true;
  382. }
  383. #else
  384. static inline int musb_read_fifosize(struct musb *musb,
  385. struct musb_hw_ep *hw_ep, u8 epnum)
  386. {
  387. void __iomem *mbase = musb->mregs;
  388. u8 reg = 0;
  389. /* read from core using indexed model */
  390. reg = musb_readb(mbase, MUSB_EP_OFFSET(epnum, MUSB_FIFOSIZE));
  391. /* 0's returned when no more endpoints */
  392. if (!reg)
  393. return -ENODEV;
  394. musb->nr_endpoints++;
  395. musb->epmask |= (1 << epnum);
  396. hw_ep->max_packet_sz_tx = 1 << (reg & 0x0f);
  397. /* shared TX/RX FIFO? */
  398. if ((reg & 0xf0) == 0xf0) {
  399. hw_ep->max_packet_sz_rx = hw_ep->max_packet_sz_tx;
  400. hw_ep->is_shared_fifo = true;
  401. return 0;
  402. } else {
  403. hw_ep->max_packet_sz_rx = 1 << ((reg & 0xf0) >> 4);
  404. hw_ep->is_shared_fifo = false;
  405. }
  406. return 0;
  407. }
  408. static inline void musb_configure_ep0(struct musb *musb)
  409. {
  410. musb->endpoints[0].max_packet_sz_tx = MUSB_EP0_FIFOSIZE;
  411. musb->endpoints[0].max_packet_sz_rx = MUSB_EP0_FIFOSIZE;
  412. musb->endpoints[0].is_shared_fifo = true;
  413. }
  414. #endif /* CONFIG_BLACKFIN */
  415. /***************************** Glue it together *****************************/
  416. extern const char musb_driver_name[];
  417. extern void musb_start(struct musb *musb);
  418. extern void musb_stop(struct musb *musb);
  419. extern int musb_get_id(struct device *dev, gfp_t gfp_mask);
  420. extern void musb_put_id(struct device *dev, int id);
  421. extern void musb_write_fifo(struct musb_hw_ep *ep, u16 len, const u8 *src);
  422. extern void musb_read_fifo(struct musb_hw_ep *ep, u16 len, u8 *dst);
  423. extern void musb_load_testpacket(struct musb *);
  424. extern irqreturn_t musb_interrupt(struct musb *);
  425. extern void musb_hnp_stop(struct musb *musb);
  426. static inline void musb_platform_set_vbus(struct musb *musb, int is_on)
  427. {
  428. if (musb->ops->set_vbus)
  429. musb->ops->set_vbus(musb, is_on);
  430. }
  431. static inline void musb_platform_enable(struct musb *musb)
  432. {
  433. if (musb->ops->enable)
  434. musb->ops->enable(musb);
  435. }
  436. static inline void musb_platform_disable(struct musb *musb)
  437. {
  438. if (musb->ops->disable)
  439. musb->ops->disable(musb);
  440. }
  441. static inline int musb_platform_set_mode(struct musb *musb, u8 mode)
  442. {
  443. if (!musb->ops->set_mode)
  444. return 0;
  445. return musb->ops->set_mode(musb, mode);
  446. }
  447. static inline void musb_platform_try_idle(struct musb *musb,
  448. unsigned long timeout)
  449. {
  450. if (musb->ops->try_idle)
  451. musb->ops->try_idle(musb, timeout);
  452. }
  453. static inline int musb_platform_get_vbus_status(struct musb *musb)
  454. {
  455. if (!musb->ops->vbus_status)
  456. return 0;
  457. return musb->ops->vbus_status(musb);
  458. }
  459. static inline int musb_platform_init(struct musb *musb)
  460. {
  461. if (!musb->ops->init)
  462. return -EINVAL;
  463. return musb->ops->init(musb);
  464. }
  465. static inline int musb_platform_exit(struct musb *musb)
  466. {
  467. if (!musb->ops->exit)
  468. return -EINVAL;
  469. return musb->ops->exit(musb);
  470. }
  471. #endif /* __MUSB_CORE_H__ */