pic32.c 8.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Microchip PIC32 MUSB "glue layer"
  4. *
  5. * Copyright (C) 2015, Microchip Technology Inc.
  6. * Cristian Birsan <cristian.birsan@microchip.com>
  7. * Purna Chandra Mandal <purna.mandal@microchip.com>
  8. *
  9. * Based on the dsps "glue layer" code.
  10. */
  11. #include <common.h>
  12. #include <dm.h>
  13. #include <dm/device_compat.h>
  14. #include <linux/bitops.h>
  15. #include <linux/delay.h>
  16. #include <linux/usb/musb.h>
  17. #include "linux-compat.h"
  18. #include "musb_core.h"
  19. #include "musb_uboot.h"
  20. DECLARE_GLOBAL_DATA_PTR;
  21. #define PIC32_TX_EP_MASK 0x0f /* EP0 + 7 Tx EPs */
  22. #define PIC32_RX_EP_MASK 0x0e /* 7 Rx EPs */
  23. #define MUSB_SOFTRST 0x7f
  24. #define MUSB_SOFTRST_NRST BIT(0)
  25. #define MUSB_SOFTRST_NRSTX BIT(1)
  26. #define USBCRCON 0
  27. #define USBCRCON_USBWKUPEN BIT(0) /* Enable Wakeup Interrupt */
  28. #define USBCRCON_USBRIE BIT(1) /* Enable Remote resume Interrupt */
  29. #define USBCRCON_USBIE BIT(2) /* Enable USB General interrupt */
  30. #define USBCRCON_SENDMONEN BIT(3) /* Enable Session End VBUS monitoring */
  31. #define USBCRCON_BSVALMONEN BIT(4) /* Enable B-Device VBUS monitoring */
  32. #define USBCRCON_ASVALMONEN BIT(5) /* Enable A-Device VBUS monitoring */
  33. #define USBCRCON_VBUSMONEN BIT(6) /* Enable VBUS monitoring */
  34. #define USBCRCON_PHYIDEN BIT(7) /* PHY ID monitoring enable */
  35. #define USBCRCON_USBIDVAL BIT(8) /* USB ID value */
  36. #define USBCRCON_USBIDOVEN BIT(9) /* USB ID override enable */
  37. #define USBCRCON_USBWK BIT(24) /* USB Wakeup Status */
  38. #define USBCRCON_USBRF BIT(25) /* USB Resume Status */
  39. #define USBCRCON_USBIF BIT(26) /* USB General Interrupt Status */
  40. /* PIC32 controller data */
  41. struct pic32_musb_data {
  42. struct musb_host_data mdata;
  43. struct device dev;
  44. void __iomem *musb_glue;
  45. };
  46. #define to_pic32_musb_data(d) \
  47. container_of(d, struct pic32_musb_data, dev)
  48. static void pic32_musb_disable(struct musb *musb)
  49. {
  50. /* no way to shut the controller */
  51. }
  52. static int pic32_musb_enable(struct musb *musb)
  53. {
  54. /* soft reset by NRSTx */
  55. musb_writeb(musb->mregs, MUSB_SOFTRST, MUSB_SOFTRST_NRSTX);
  56. /* set mode */
  57. musb_platform_set_mode(musb, musb->board_mode);
  58. return 0;
  59. }
  60. static irqreturn_t pic32_interrupt(int irq, void *hci)
  61. {
  62. struct musb *musb = hci;
  63. irqreturn_t ret = IRQ_NONE;
  64. u32 epintr, usbintr;
  65. /* ack usb core interrupts */
  66. musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);
  67. if (musb->int_usb)
  68. musb_writeb(musb->mregs, MUSB_INTRUSB, musb->int_usb);
  69. /* ack endpoint interrupts */
  70. musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX) & PIC32_RX_EP_MASK;
  71. if (musb->int_rx)
  72. musb_writew(musb->mregs, MUSB_INTRRX, musb->int_rx);
  73. musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX) & PIC32_TX_EP_MASK;
  74. if (musb->int_tx)
  75. musb_writew(musb->mregs, MUSB_INTRTX, musb->int_tx);
  76. /* drop spurious RX and TX if device is disconnected */
  77. if (musb->int_usb & MUSB_INTR_DISCONNECT) {
  78. musb->int_tx = 0;
  79. musb->int_rx = 0;
  80. }
  81. if (musb->int_tx || musb->int_rx || musb->int_usb)
  82. ret = musb_interrupt(musb);
  83. return ret;
  84. }
  85. static int pic32_musb_set_mode(struct musb *musb, u8 mode)
  86. {
  87. struct device *dev = musb->controller;
  88. struct pic32_musb_data *pdata = to_pic32_musb_data(dev);
  89. switch (mode) {
  90. case MUSB_HOST:
  91. clrsetbits_le32(pdata->musb_glue + USBCRCON,
  92. USBCRCON_USBIDVAL, USBCRCON_USBIDOVEN);
  93. break;
  94. case MUSB_PERIPHERAL:
  95. setbits_le32(pdata->musb_glue + USBCRCON,
  96. USBCRCON_USBIDVAL | USBCRCON_USBIDOVEN);
  97. break;
  98. case MUSB_OTG:
  99. dev_err(dev, "support for OTG is unimplemented\n");
  100. break;
  101. default:
  102. dev_err(dev, "unsupported mode %d\n", mode);
  103. return -EINVAL;
  104. }
  105. return 0;
  106. }
  107. static int pic32_musb_init(struct musb *musb)
  108. {
  109. struct pic32_musb_data *pdata = to_pic32_musb_data(musb->controller);
  110. u32 ctrl, hwvers;
  111. u8 power;
  112. /* Returns zero if not clocked */
  113. hwvers = musb_read_hwvers(musb->mregs);
  114. if (!hwvers)
  115. return -ENODEV;
  116. /* Reset the musb */
  117. power = musb_readb(musb->mregs, MUSB_POWER);
  118. power = power | MUSB_POWER_RESET;
  119. musb_writeb(musb->mregs, MUSB_POWER, power);
  120. mdelay(100);
  121. /* Start the on-chip PHY and its PLL. */
  122. power = power & ~MUSB_POWER_RESET;
  123. musb_writeb(musb->mregs, MUSB_POWER, power);
  124. musb->isr = pic32_interrupt;
  125. ctrl = USBCRCON_USBIF | USBCRCON_USBRF |
  126. USBCRCON_USBWK | USBCRCON_USBIDOVEN |
  127. USBCRCON_PHYIDEN | USBCRCON_USBIE |
  128. USBCRCON_USBRIE | USBCRCON_USBWKUPEN |
  129. USBCRCON_VBUSMONEN;
  130. writel(ctrl, pdata->musb_glue + USBCRCON);
  131. return 0;
  132. }
  133. /* PIC32 supports only 32bit read operation */
  134. void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
  135. {
  136. void __iomem *fifo = hw_ep->fifo;
  137. u32 val, rem = len % 4;
  138. /* USB stack ensures dst is always 32bit aligned. */
  139. readsl(fifo, dst, len / 4);
  140. if (rem) {
  141. dst += len & ~0x03;
  142. val = musb_readl(fifo, 0);
  143. memcpy(dst, &val, rem);
  144. }
  145. }
  146. const struct musb_platform_ops pic32_musb_ops = {
  147. .init = pic32_musb_init,
  148. .set_mode = pic32_musb_set_mode,
  149. .disable = pic32_musb_disable,
  150. .enable = pic32_musb_enable,
  151. };
  152. /* PIC32 default FIFO config - fits in 8KB */
  153. static struct musb_fifo_cfg pic32_musb_fifo_config[] = {
  154. { .hw_ep_num = 1, .style = FIFO_TX, .maxpacket = 512, },
  155. { .hw_ep_num = 1, .style = FIFO_RX, .maxpacket = 512, },
  156. { .hw_ep_num = 2, .style = FIFO_TX, .maxpacket = 512, },
  157. { .hw_ep_num = 2, .style = FIFO_RX, .maxpacket = 512, },
  158. { .hw_ep_num = 3, .style = FIFO_TX, .maxpacket = 512, },
  159. { .hw_ep_num = 3, .style = FIFO_RX, .maxpacket = 512, },
  160. { .hw_ep_num = 4, .style = FIFO_TX, .maxpacket = 512, },
  161. { .hw_ep_num = 4, .style = FIFO_RX, .maxpacket = 512, },
  162. { .hw_ep_num = 5, .style = FIFO_TX, .maxpacket = 512, },
  163. { .hw_ep_num = 5, .style = FIFO_RX, .maxpacket = 512, },
  164. { .hw_ep_num = 6, .style = FIFO_TX, .maxpacket = 512, },
  165. { .hw_ep_num = 6, .style = FIFO_RX, .maxpacket = 512, },
  166. { .hw_ep_num = 7, .style = FIFO_TX, .maxpacket = 512, },
  167. { .hw_ep_num = 7, .style = FIFO_RX, .maxpacket = 512, },
  168. };
  169. static struct musb_hdrc_config pic32_musb_config = {
  170. .fifo_cfg = pic32_musb_fifo_config,
  171. .fifo_cfg_size = ARRAY_SIZE(pic32_musb_fifo_config),
  172. .multipoint = 1,
  173. .dyn_fifo = 1,
  174. .num_eps = 8,
  175. .ram_bits = 11,
  176. };
  177. /* PIC32 has one MUSB controller which can be host or gadget */
  178. static struct musb_hdrc_platform_data pic32_musb_plat = {
  179. .mode = MUSB_HOST,
  180. .config = &pic32_musb_config,
  181. .power = 250, /* 500mA */
  182. .platform_ops = &pic32_musb_ops,
  183. };
  184. static int musb_usb_probe(struct udevice *dev)
  185. {
  186. struct usb_bus_priv *priv = dev_get_uclass_priv(dev);
  187. struct pic32_musb_data *pdata = dev_get_priv(dev);
  188. struct musb_host_data *mdata = &pdata->mdata;
  189. struct fdt_resource mc, glue;
  190. void *fdt = (void *)gd->fdt_blob;
  191. int node = dev_of_offset(dev);
  192. void __iomem *mregs;
  193. int ret;
  194. priv->desc_before_addr = true;
  195. ret = fdt_get_named_resource(fdt, node, "reg", "reg-names",
  196. "mc", &mc);
  197. if (ret < 0) {
  198. printf("pic32-musb: resource \"mc\" not found\n");
  199. return ret;
  200. }
  201. ret = fdt_get_named_resource(fdt, node, "reg", "reg-names",
  202. "control", &glue);
  203. if (ret < 0) {
  204. printf("pic32-musb: resource \"control\" not found\n");
  205. return ret;
  206. }
  207. mregs = ioremap(mc.start, fdt_resource_size(&mc));
  208. pdata->musb_glue = ioremap(glue.start, fdt_resource_size(&glue));
  209. /* init controller */
  210. #ifdef CONFIG_USB_MUSB_HOST
  211. mdata->host = musb_init_controller(&pic32_musb_plat,
  212. &pdata->dev, mregs);
  213. if (!mdata->host)
  214. return -EIO;
  215. ret = musb_lowlevel_init(mdata);
  216. #else
  217. pic32_musb_plat.mode = MUSB_PERIPHERAL;
  218. mdata->host = musb_register(&pic32_musb_plat, &pdata->dev, mregs);
  219. if (!mdata->host)
  220. return -EIO;
  221. #endif
  222. if ((ret == 0) && mdata->host)
  223. printf("PIC32 MUSB OTG\n");
  224. return ret;
  225. }
  226. static int musb_usb_remove(struct udevice *dev)
  227. {
  228. struct pic32_musb_data *pdata = dev_get_priv(dev);
  229. musb_stop(pdata->mdata.host);
  230. return 0;
  231. }
  232. static const struct udevice_id pic32_musb_ids[] = {
  233. { .compatible = "microchip,pic32mzda-usb" },
  234. { }
  235. };
  236. U_BOOT_DRIVER(usb_musb) = {
  237. .name = "pic32-musb",
  238. .id = UCLASS_USB,
  239. .of_match = pic32_musb_ids,
  240. .probe = musb_usb_probe,
  241. .remove = musb_usb_remove,
  242. #ifdef CONFIG_USB_MUSB_HOST
  243. .ops = &musb_usb_ops,
  244. #endif
  245. .platdata_auto_alloc_size = sizeof(struct usb_platdata),
  246. .priv_auto_alloc_size = sizeof(struct pic32_musb_data),
  247. };