usb-host.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684
  1. /*
  2. * usb-host.c - OMAP USB Host
  3. *
  4. * This file will contain the board specific details for the
  5. * Synopsys EHCI/OHCI host controller on OMAP3430 and onwards
  6. *
  7. * Copyright (C) 2007-2011 Texas Instruments
  8. * Author: Vikram Pandita <vikram.pandita@ti.com>
  9. * Author: Keshava Munegowda <keshava_mgowda@ti.com>
  10. *
  11. * Generalization by:
  12. * Felipe Balbi <balbi@ti.com>
  13. *
  14. * This program is free software; you can redistribute it and/or modify
  15. * it under the terms of the GNU General Public License version 2 as
  16. * published by the Free Software Foundation.
  17. */
  18. #include <linux/types.h>
  19. #include <linux/errno.h>
  20. #include <linux/delay.h>
  21. #include <linux/platform_device.h>
  22. #include <linux/slab.h>
  23. #include <linux/dma-mapping.h>
  24. #include <linux/regulator/machine.h>
  25. #include <linux/regulator/fixed.h>
  26. #include <linux/string.h>
  27. #include <linux/io.h>
  28. #include <linux/gpio.h>
  29. #include <linux/usb/phy.h>
  30. #include "soc.h"
  31. #include "omap_device.h"
  32. #include "mux.h"
  33. #include "usb.h"
  34. #ifdef CONFIG_MFD_OMAP_USB_HOST
  35. #define OMAP_USBHS_DEVICE "usbhs_omap"
  36. #define OMAP_USBTLL_DEVICE "usbhs_tll"
  37. #define USBHS_UHH_HWMODNAME "usb_host_hs"
  38. #define USBHS_TLL_HWMODNAME "usb_tll_hs"
  39. /* MUX settings for EHCI pins */
  40. /*
  41. * setup_ehci_io_mux - initialize IO pad mux for USBHOST
  42. */
  43. static void __init setup_ehci_io_mux(const enum usbhs_omap_port_mode *port_mode)
  44. {
  45. switch (port_mode[0]) {
  46. case OMAP_EHCI_PORT_MODE_PHY:
  47. omap_mux_init_signal("hsusb1_stp", OMAP_PIN_OUTPUT);
  48. omap_mux_init_signal("hsusb1_clk", OMAP_PIN_OUTPUT);
  49. omap_mux_init_signal("hsusb1_dir", OMAP_PIN_INPUT_PULLDOWN);
  50. omap_mux_init_signal("hsusb1_nxt", OMAP_PIN_INPUT_PULLDOWN);
  51. omap_mux_init_signal("hsusb1_data0", OMAP_PIN_INPUT_PULLDOWN);
  52. omap_mux_init_signal("hsusb1_data1", OMAP_PIN_INPUT_PULLDOWN);
  53. omap_mux_init_signal("hsusb1_data2", OMAP_PIN_INPUT_PULLDOWN);
  54. omap_mux_init_signal("hsusb1_data3", OMAP_PIN_INPUT_PULLDOWN);
  55. omap_mux_init_signal("hsusb1_data4", OMAP_PIN_INPUT_PULLDOWN);
  56. omap_mux_init_signal("hsusb1_data5", OMAP_PIN_INPUT_PULLDOWN);
  57. omap_mux_init_signal("hsusb1_data6", OMAP_PIN_INPUT_PULLDOWN);
  58. omap_mux_init_signal("hsusb1_data7", OMAP_PIN_INPUT_PULLDOWN);
  59. break;
  60. case OMAP_EHCI_PORT_MODE_TLL:
  61. omap_mux_init_signal("hsusb1_tll_stp",
  62. OMAP_PIN_INPUT_PULLUP);
  63. omap_mux_init_signal("hsusb1_tll_clk",
  64. OMAP_PIN_INPUT_PULLDOWN);
  65. omap_mux_init_signal("hsusb1_tll_dir",
  66. OMAP_PIN_INPUT_PULLDOWN);
  67. omap_mux_init_signal("hsusb1_tll_nxt",
  68. OMAP_PIN_INPUT_PULLDOWN);
  69. omap_mux_init_signal("hsusb1_tll_data0",
  70. OMAP_PIN_INPUT_PULLDOWN);
  71. omap_mux_init_signal("hsusb1_tll_data1",
  72. OMAP_PIN_INPUT_PULLDOWN);
  73. omap_mux_init_signal("hsusb1_tll_data2",
  74. OMAP_PIN_INPUT_PULLDOWN);
  75. omap_mux_init_signal("hsusb1_tll_data3",
  76. OMAP_PIN_INPUT_PULLDOWN);
  77. omap_mux_init_signal("hsusb1_tll_data4",
  78. OMAP_PIN_INPUT_PULLDOWN);
  79. omap_mux_init_signal("hsusb1_tll_data5",
  80. OMAP_PIN_INPUT_PULLDOWN);
  81. omap_mux_init_signal("hsusb1_tll_data6",
  82. OMAP_PIN_INPUT_PULLDOWN);
  83. omap_mux_init_signal("hsusb1_tll_data7",
  84. OMAP_PIN_INPUT_PULLDOWN);
  85. break;
  86. case OMAP_USBHS_PORT_MODE_UNUSED:
  87. /* FALLTHROUGH */
  88. default:
  89. break;
  90. }
  91. switch (port_mode[1]) {
  92. case OMAP_EHCI_PORT_MODE_PHY:
  93. omap_mux_init_signal("hsusb2_stp", OMAP_PIN_OUTPUT);
  94. omap_mux_init_signal("hsusb2_clk", OMAP_PIN_OUTPUT);
  95. omap_mux_init_signal("hsusb2_dir", OMAP_PIN_INPUT_PULLDOWN);
  96. omap_mux_init_signal("hsusb2_nxt", OMAP_PIN_INPUT_PULLDOWN);
  97. omap_mux_init_signal("hsusb2_data0",
  98. OMAP_PIN_INPUT_PULLDOWN);
  99. omap_mux_init_signal("hsusb2_data1",
  100. OMAP_PIN_INPUT_PULLDOWN);
  101. omap_mux_init_signal("hsusb2_data2",
  102. OMAP_PIN_INPUT_PULLDOWN);
  103. omap_mux_init_signal("hsusb2_data3",
  104. OMAP_PIN_INPUT_PULLDOWN);
  105. omap_mux_init_signal("hsusb2_data4",
  106. OMAP_PIN_INPUT_PULLDOWN);
  107. omap_mux_init_signal("hsusb2_data5",
  108. OMAP_PIN_INPUT_PULLDOWN);
  109. omap_mux_init_signal("hsusb2_data6",
  110. OMAP_PIN_INPUT_PULLDOWN);
  111. omap_mux_init_signal("hsusb2_data7",
  112. OMAP_PIN_INPUT_PULLDOWN);
  113. break;
  114. case OMAP_EHCI_PORT_MODE_TLL:
  115. omap_mux_init_signal("hsusb2_tll_stp",
  116. OMAP_PIN_INPUT_PULLUP);
  117. omap_mux_init_signal("hsusb2_tll_clk",
  118. OMAP_PIN_INPUT_PULLDOWN);
  119. omap_mux_init_signal("hsusb2_tll_dir",
  120. OMAP_PIN_INPUT_PULLDOWN);
  121. omap_mux_init_signal("hsusb2_tll_nxt",
  122. OMAP_PIN_INPUT_PULLDOWN);
  123. omap_mux_init_signal("hsusb2_tll_data0",
  124. OMAP_PIN_INPUT_PULLDOWN);
  125. omap_mux_init_signal("hsusb2_tll_data1",
  126. OMAP_PIN_INPUT_PULLDOWN);
  127. omap_mux_init_signal("hsusb2_tll_data2",
  128. OMAP_PIN_INPUT_PULLDOWN);
  129. omap_mux_init_signal("hsusb2_tll_data3",
  130. OMAP_PIN_INPUT_PULLDOWN);
  131. omap_mux_init_signal("hsusb2_tll_data4",
  132. OMAP_PIN_INPUT_PULLDOWN);
  133. omap_mux_init_signal("hsusb2_tll_data5",
  134. OMAP_PIN_INPUT_PULLDOWN);
  135. omap_mux_init_signal("hsusb2_tll_data6",
  136. OMAP_PIN_INPUT_PULLDOWN);
  137. omap_mux_init_signal("hsusb2_tll_data7",
  138. OMAP_PIN_INPUT_PULLDOWN);
  139. break;
  140. case OMAP_USBHS_PORT_MODE_UNUSED:
  141. /* FALLTHROUGH */
  142. default:
  143. break;
  144. }
  145. switch (port_mode[2]) {
  146. case OMAP_EHCI_PORT_MODE_PHY:
  147. printk(KERN_WARNING "Port3 can't be used in PHY mode\n");
  148. break;
  149. case OMAP_EHCI_PORT_MODE_TLL:
  150. omap_mux_init_signal("hsusb3_tll_stp",
  151. OMAP_PIN_INPUT_PULLUP);
  152. omap_mux_init_signal("hsusb3_tll_clk",
  153. OMAP_PIN_INPUT_PULLDOWN);
  154. omap_mux_init_signal("hsusb3_tll_dir",
  155. OMAP_PIN_INPUT_PULLDOWN);
  156. omap_mux_init_signal("hsusb3_tll_nxt",
  157. OMAP_PIN_INPUT_PULLDOWN);
  158. omap_mux_init_signal("hsusb3_tll_data0",
  159. OMAP_PIN_INPUT_PULLDOWN);
  160. omap_mux_init_signal("hsusb3_tll_data1",
  161. OMAP_PIN_INPUT_PULLDOWN);
  162. omap_mux_init_signal("hsusb3_tll_data2",
  163. OMAP_PIN_INPUT_PULLDOWN);
  164. omap_mux_init_signal("hsusb3_tll_data3",
  165. OMAP_PIN_INPUT_PULLDOWN);
  166. omap_mux_init_signal("hsusb3_tll_data4",
  167. OMAP_PIN_INPUT_PULLDOWN);
  168. omap_mux_init_signal("hsusb3_tll_data5",
  169. OMAP_PIN_INPUT_PULLDOWN);
  170. omap_mux_init_signal("hsusb3_tll_data6",
  171. OMAP_PIN_INPUT_PULLDOWN);
  172. omap_mux_init_signal("hsusb3_tll_data7",
  173. OMAP_PIN_INPUT_PULLDOWN);
  174. break;
  175. case OMAP_USBHS_PORT_MODE_UNUSED:
  176. /* FALLTHROUGH */
  177. default:
  178. break;
  179. }
  180. return;
  181. }
  182. static
  183. void __init setup_4430ehci_io_mux(const enum usbhs_omap_port_mode *port_mode)
  184. {
  185. switch (port_mode[0]) {
  186. case OMAP_EHCI_PORT_MODE_PHY:
  187. omap_mux_init_signal("usbb1_ulpiphy_stp",
  188. OMAP_PIN_OUTPUT);
  189. omap_mux_init_signal("usbb1_ulpiphy_clk",
  190. OMAP_PIN_INPUT_PULLDOWN);
  191. omap_mux_init_signal("usbb1_ulpiphy_dir",
  192. OMAP_PIN_INPUT_PULLDOWN);
  193. omap_mux_init_signal("usbb1_ulpiphy_nxt",
  194. OMAP_PIN_INPUT_PULLDOWN);
  195. omap_mux_init_signal("usbb1_ulpiphy_dat0",
  196. OMAP_PIN_INPUT_PULLDOWN);
  197. omap_mux_init_signal("usbb1_ulpiphy_dat1",
  198. OMAP_PIN_INPUT_PULLDOWN);
  199. omap_mux_init_signal("usbb1_ulpiphy_dat2",
  200. OMAP_PIN_INPUT_PULLDOWN);
  201. omap_mux_init_signal("usbb1_ulpiphy_dat3",
  202. OMAP_PIN_INPUT_PULLDOWN);
  203. omap_mux_init_signal("usbb1_ulpiphy_dat4",
  204. OMAP_PIN_INPUT_PULLDOWN);
  205. omap_mux_init_signal("usbb1_ulpiphy_dat5",
  206. OMAP_PIN_INPUT_PULLDOWN);
  207. omap_mux_init_signal("usbb1_ulpiphy_dat6",
  208. OMAP_PIN_INPUT_PULLDOWN);
  209. omap_mux_init_signal("usbb1_ulpiphy_dat7",
  210. OMAP_PIN_INPUT_PULLDOWN);
  211. break;
  212. case OMAP_EHCI_PORT_MODE_TLL:
  213. omap_mux_init_signal("usbb1_ulpitll_stp",
  214. OMAP_PIN_INPUT_PULLUP);
  215. omap_mux_init_signal("usbb1_ulpitll_clk",
  216. OMAP_PIN_INPUT_PULLDOWN);
  217. omap_mux_init_signal("usbb1_ulpitll_dir",
  218. OMAP_PIN_INPUT_PULLDOWN);
  219. omap_mux_init_signal("usbb1_ulpitll_nxt",
  220. OMAP_PIN_INPUT_PULLDOWN);
  221. omap_mux_init_signal("usbb1_ulpitll_dat0",
  222. OMAP_PIN_INPUT_PULLDOWN);
  223. omap_mux_init_signal("usbb1_ulpitll_dat1",
  224. OMAP_PIN_INPUT_PULLDOWN);
  225. omap_mux_init_signal("usbb1_ulpitll_dat2",
  226. OMAP_PIN_INPUT_PULLDOWN);
  227. omap_mux_init_signal("usbb1_ulpitll_dat3",
  228. OMAP_PIN_INPUT_PULLDOWN);
  229. omap_mux_init_signal("usbb1_ulpitll_dat4",
  230. OMAP_PIN_INPUT_PULLDOWN);
  231. omap_mux_init_signal("usbb1_ulpitll_dat5",
  232. OMAP_PIN_INPUT_PULLDOWN);
  233. omap_mux_init_signal("usbb1_ulpitll_dat6",
  234. OMAP_PIN_INPUT_PULLDOWN);
  235. omap_mux_init_signal("usbb1_ulpitll_dat7",
  236. OMAP_PIN_INPUT_PULLDOWN);
  237. break;
  238. case OMAP_USBHS_PORT_MODE_UNUSED:
  239. default:
  240. break;
  241. }
  242. switch (port_mode[1]) {
  243. case OMAP_EHCI_PORT_MODE_PHY:
  244. omap_mux_init_signal("usbb2_ulpiphy_stp",
  245. OMAP_PIN_OUTPUT);
  246. omap_mux_init_signal("usbb2_ulpiphy_clk",
  247. OMAP_PIN_INPUT_PULLDOWN);
  248. omap_mux_init_signal("usbb2_ulpiphy_dir",
  249. OMAP_PIN_INPUT_PULLDOWN);
  250. omap_mux_init_signal("usbb2_ulpiphy_nxt",
  251. OMAP_PIN_INPUT_PULLDOWN);
  252. omap_mux_init_signal("usbb2_ulpiphy_dat0",
  253. OMAP_PIN_INPUT_PULLDOWN);
  254. omap_mux_init_signal("usbb2_ulpiphy_dat1",
  255. OMAP_PIN_INPUT_PULLDOWN);
  256. omap_mux_init_signal("usbb2_ulpiphy_dat2",
  257. OMAP_PIN_INPUT_PULLDOWN);
  258. omap_mux_init_signal("usbb2_ulpiphy_dat3",
  259. OMAP_PIN_INPUT_PULLDOWN);
  260. omap_mux_init_signal("usbb2_ulpiphy_dat4",
  261. OMAP_PIN_INPUT_PULLDOWN);
  262. omap_mux_init_signal("usbb2_ulpiphy_dat5",
  263. OMAP_PIN_INPUT_PULLDOWN);
  264. omap_mux_init_signal("usbb2_ulpiphy_dat6",
  265. OMAP_PIN_INPUT_PULLDOWN);
  266. omap_mux_init_signal("usbb2_ulpiphy_dat7",
  267. OMAP_PIN_INPUT_PULLDOWN);
  268. break;
  269. case OMAP_EHCI_PORT_MODE_TLL:
  270. omap_mux_init_signal("usbb2_ulpitll_stp",
  271. OMAP_PIN_INPUT_PULLUP);
  272. omap_mux_init_signal("usbb2_ulpitll_clk",
  273. OMAP_PIN_INPUT_PULLDOWN);
  274. omap_mux_init_signal("usbb2_ulpitll_dir",
  275. OMAP_PIN_INPUT_PULLDOWN);
  276. omap_mux_init_signal("usbb2_ulpitll_nxt",
  277. OMAP_PIN_INPUT_PULLDOWN);
  278. omap_mux_init_signal("usbb2_ulpitll_dat0",
  279. OMAP_PIN_INPUT_PULLDOWN);
  280. omap_mux_init_signal("usbb2_ulpitll_dat1",
  281. OMAP_PIN_INPUT_PULLDOWN);
  282. omap_mux_init_signal("usbb2_ulpitll_dat2",
  283. OMAP_PIN_INPUT_PULLDOWN);
  284. omap_mux_init_signal("usbb2_ulpitll_dat3",
  285. OMAP_PIN_INPUT_PULLDOWN);
  286. omap_mux_init_signal("usbb2_ulpitll_dat4",
  287. OMAP_PIN_INPUT_PULLDOWN);
  288. omap_mux_init_signal("usbb2_ulpitll_dat5",
  289. OMAP_PIN_INPUT_PULLDOWN);
  290. omap_mux_init_signal("usbb2_ulpitll_dat6",
  291. OMAP_PIN_INPUT_PULLDOWN);
  292. omap_mux_init_signal("usbb2_ulpitll_dat7",
  293. OMAP_PIN_INPUT_PULLDOWN);
  294. break;
  295. case OMAP_USBHS_PORT_MODE_UNUSED:
  296. default:
  297. break;
  298. }
  299. }
  300. static void __init setup_ohci_io_mux(const enum usbhs_omap_port_mode *port_mode)
  301. {
  302. switch (port_mode[0]) {
  303. case OMAP_OHCI_PORT_MODE_PHY_6PIN_DATSE0:
  304. case OMAP_OHCI_PORT_MODE_PHY_6PIN_DPDM:
  305. case OMAP_OHCI_PORT_MODE_TLL_6PIN_DATSE0:
  306. case OMAP_OHCI_PORT_MODE_TLL_6PIN_DPDM:
  307. omap_mux_init_signal("mm1_rxdp",
  308. OMAP_PIN_INPUT_PULLDOWN);
  309. omap_mux_init_signal("mm1_rxdm",
  310. OMAP_PIN_INPUT_PULLDOWN);
  311. /* FALLTHROUGH */
  312. case OMAP_OHCI_PORT_MODE_PHY_4PIN_DPDM:
  313. case OMAP_OHCI_PORT_MODE_TLL_4PIN_DPDM:
  314. omap_mux_init_signal("mm1_rxrcv",
  315. OMAP_PIN_INPUT_PULLDOWN);
  316. /* FALLTHROUGH */
  317. case OMAP_OHCI_PORT_MODE_PHY_3PIN_DATSE0:
  318. case OMAP_OHCI_PORT_MODE_TLL_3PIN_DATSE0:
  319. omap_mux_init_signal("mm1_txen_n", OMAP_PIN_OUTPUT);
  320. /* FALLTHROUGH */
  321. case OMAP_OHCI_PORT_MODE_TLL_2PIN_DATSE0:
  322. case OMAP_OHCI_PORT_MODE_TLL_2PIN_DPDM:
  323. omap_mux_init_signal("mm1_txse0",
  324. OMAP_PIN_INPUT_PULLDOWN);
  325. omap_mux_init_signal("mm1_txdat",
  326. OMAP_PIN_INPUT_PULLDOWN);
  327. break;
  328. case OMAP_USBHS_PORT_MODE_UNUSED:
  329. /* FALLTHROUGH */
  330. default:
  331. break;
  332. }
  333. switch (port_mode[1]) {
  334. case OMAP_OHCI_PORT_MODE_PHY_6PIN_DATSE0:
  335. case OMAP_OHCI_PORT_MODE_PHY_6PIN_DPDM:
  336. case OMAP_OHCI_PORT_MODE_TLL_6PIN_DATSE0:
  337. case OMAP_OHCI_PORT_MODE_TLL_6PIN_DPDM:
  338. omap_mux_init_signal("mm2_rxdp",
  339. OMAP_PIN_INPUT_PULLDOWN);
  340. omap_mux_init_signal("mm2_rxdm",
  341. OMAP_PIN_INPUT_PULLDOWN);
  342. /* FALLTHROUGH */
  343. case OMAP_OHCI_PORT_MODE_PHY_4PIN_DPDM:
  344. case OMAP_OHCI_PORT_MODE_TLL_4PIN_DPDM:
  345. omap_mux_init_signal("mm2_rxrcv",
  346. OMAP_PIN_INPUT_PULLDOWN);
  347. /* FALLTHROUGH */
  348. case OMAP_OHCI_PORT_MODE_PHY_3PIN_DATSE0:
  349. case OMAP_OHCI_PORT_MODE_TLL_3PIN_DATSE0:
  350. omap_mux_init_signal("mm2_txen_n", OMAP_PIN_OUTPUT);
  351. /* FALLTHROUGH */
  352. case OMAP_OHCI_PORT_MODE_TLL_2PIN_DATSE0:
  353. case OMAP_OHCI_PORT_MODE_TLL_2PIN_DPDM:
  354. omap_mux_init_signal("mm2_txse0",
  355. OMAP_PIN_INPUT_PULLDOWN);
  356. omap_mux_init_signal("mm2_txdat",
  357. OMAP_PIN_INPUT_PULLDOWN);
  358. break;
  359. case OMAP_USBHS_PORT_MODE_UNUSED:
  360. /* FALLTHROUGH */
  361. default:
  362. break;
  363. }
  364. switch (port_mode[2]) {
  365. case OMAP_OHCI_PORT_MODE_PHY_6PIN_DATSE0:
  366. case OMAP_OHCI_PORT_MODE_PHY_6PIN_DPDM:
  367. case OMAP_OHCI_PORT_MODE_TLL_6PIN_DATSE0:
  368. case OMAP_OHCI_PORT_MODE_TLL_6PIN_DPDM:
  369. omap_mux_init_signal("mm3_rxdp",
  370. OMAP_PIN_INPUT_PULLDOWN);
  371. omap_mux_init_signal("mm3_rxdm",
  372. OMAP_PIN_INPUT_PULLDOWN);
  373. /* FALLTHROUGH */
  374. case OMAP_OHCI_PORT_MODE_PHY_4PIN_DPDM:
  375. case OMAP_OHCI_PORT_MODE_TLL_4PIN_DPDM:
  376. omap_mux_init_signal("mm3_rxrcv",
  377. OMAP_PIN_INPUT_PULLDOWN);
  378. /* FALLTHROUGH */
  379. case OMAP_OHCI_PORT_MODE_PHY_3PIN_DATSE0:
  380. case OMAP_OHCI_PORT_MODE_TLL_3PIN_DATSE0:
  381. omap_mux_init_signal("mm3_txen_n", OMAP_PIN_OUTPUT);
  382. /* FALLTHROUGH */
  383. case OMAP_OHCI_PORT_MODE_TLL_2PIN_DATSE0:
  384. case OMAP_OHCI_PORT_MODE_TLL_2PIN_DPDM:
  385. omap_mux_init_signal("mm3_txse0",
  386. OMAP_PIN_INPUT_PULLDOWN);
  387. omap_mux_init_signal("mm3_txdat",
  388. OMAP_PIN_INPUT_PULLDOWN);
  389. break;
  390. case OMAP_USBHS_PORT_MODE_UNUSED:
  391. /* FALLTHROUGH */
  392. default:
  393. break;
  394. }
  395. }
  396. static
  397. void __init setup_4430ohci_io_mux(const enum usbhs_omap_port_mode *port_mode)
  398. {
  399. switch (port_mode[0]) {
  400. case OMAP_OHCI_PORT_MODE_PHY_6PIN_DATSE0:
  401. case OMAP_OHCI_PORT_MODE_PHY_6PIN_DPDM:
  402. case OMAP_OHCI_PORT_MODE_TLL_6PIN_DATSE0:
  403. case OMAP_OHCI_PORT_MODE_TLL_6PIN_DPDM:
  404. omap_mux_init_signal("usbb1_mm_rxdp",
  405. OMAP_PIN_INPUT_PULLDOWN);
  406. omap_mux_init_signal("usbb1_mm_rxdm",
  407. OMAP_PIN_INPUT_PULLDOWN);
  408. case OMAP_OHCI_PORT_MODE_PHY_4PIN_DPDM:
  409. case OMAP_OHCI_PORT_MODE_TLL_4PIN_DPDM:
  410. omap_mux_init_signal("usbb1_mm_rxrcv",
  411. OMAP_PIN_INPUT_PULLDOWN);
  412. case OMAP_OHCI_PORT_MODE_PHY_3PIN_DATSE0:
  413. case OMAP_OHCI_PORT_MODE_TLL_3PIN_DATSE0:
  414. omap_mux_init_signal("usbb1_mm_txen",
  415. OMAP_PIN_INPUT_PULLDOWN);
  416. case OMAP_OHCI_PORT_MODE_TLL_2PIN_DATSE0:
  417. case OMAP_OHCI_PORT_MODE_TLL_2PIN_DPDM:
  418. omap_mux_init_signal("usbb1_mm_txdat",
  419. OMAP_PIN_INPUT_PULLDOWN);
  420. omap_mux_init_signal("usbb1_mm_txse0",
  421. OMAP_PIN_INPUT_PULLDOWN);
  422. break;
  423. case OMAP_USBHS_PORT_MODE_UNUSED:
  424. default:
  425. break;
  426. }
  427. switch (port_mode[1]) {
  428. case OMAP_OHCI_PORT_MODE_PHY_6PIN_DATSE0:
  429. case OMAP_OHCI_PORT_MODE_PHY_6PIN_DPDM:
  430. case OMAP_OHCI_PORT_MODE_TLL_6PIN_DATSE0:
  431. case OMAP_OHCI_PORT_MODE_TLL_6PIN_DPDM:
  432. omap_mux_init_signal("usbb2_mm_rxdp",
  433. OMAP_PIN_INPUT_PULLDOWN);
  434. omap_mux_init_signal("usbb2_mm_rxdm",
  435. OMAP_PIN_INPUT_PULLDOWN);
  436. case OMAP_OHCI_PORT_MODE_PHY_4PIN_DPDM:
  437. case OMAP_OHCI_PORT_MODE_TLL_4PIN_DPDM:
  438. omap_mux_init_signal("usbb2_mm_rxrcv",
  439. OMAP_PIN_INPUT_PULLDOWN);
  440. case OMAP_OHCI_PORT_MODE_PHY_3PIN_DATSE0:
  441. case OMAP_OHCI_PORT_MODE_TLL_3PIN_DATSE0:
  442. omap_mux_init_signal("usbb2_mm_txen",
  443. OMAP_PIN_INPUT_PULLDOWN);
  444. case OMAP_OHCI_PORT_MODE_TLL_2PIN_DATSE0:
  445. case OMAP_OHCI_PORT_MODE_TLL_2PIN_DPDM:
  446. omap_mux_init_signal("usbb2_mm_txdat",
  447. OMAP_PIN_INPUT_PULLDOWN);
  448. omap_mux_init_signal("usbb2_mm_txse0",
  449. OMAP_PIN_INPUT_PULLDOWN);
  450. break;
  451. case OMAP_USBHS_PORT_MODE_UNUSED:
  452. default:
  453. break;
  454. }
  455. }
  456. void __init usbhs_init(struct usbhs_omap_platform_data *pdata)
  457. {
  458. struct omap_hwmod *uhh_hwm, *tll_hwm;
  459. struct platform_device *pdev;
  460. int bus_id = -1;
  461. if (cpu_is_omap34xx()) {
  462. setup_ehci_io_mux(pdata->port_mode);
  463. setup_ohci_io_mux(pdata->port_mode);
  464. if (omap_rev() <= OMAP3430_REV_ES2_1)
  465. pdata->single_ulpi_bypass = true;
  466. } else if (cpu_is_omap44xx()) {
  467. setup_4430ehci_io_mux(pdata->port_mode);
  468. setup_4430ohci_io_mux(pdata->port_mode);
  469. }
  470. uhh_hwm = omap_hwmod_lookup(USBHS_UHH_HWMODNAME);
  471. if (!uhh_hwm) {
  472. pr_err("Could not look up %s\n", USBHS_UHH_HWMODNAME);
  473. return;
  474. }
  475. tll_hwm = omap_hwmod_lookup(USBHS_TLL_HWMODNAME);
  476. if (!tll_hwm) {
  477. pr_err("Could not look up %s\n", USBHS_TLL_HWMODNAME);
  478. return;
  479. }
  480. pdev = omap_device_build(OMAP_USBTLL_DEVICE, bus_id, tll_hwm,
  481. pdata, sizeof(*pdata));
  482. if (IS_ERR(pdev)) {
  483. pr_err("Could not build hwmod device %s\n",
  484. USBHS_TLL_HWMODNAME);
  485. return;
  486. }
  487. pdev = omap_device_build(OMAP_USBHS_DEVICE, bus_id, uhh_hwm,
  488. pdata, sizeof(*pdata));
  489. if (IS_ERR(pdev)) {
  490. pr_err("Could not build hwmod devices %s\n",
  491. USBHS_UHH_HWMODNAME);
  492. return;
  493. }
  494. }
  495. #else
  496. void __init usbhs_init(struct usbhs_omap_platform_data *pdata)
  497. {
  498. }
  499. #endif
  500. /* Template for PHY regulators */
  501. static struct fixed_voltage_config hsusb_reg_config = {
  502. /* .supply_name filled later */
  503. .microvolts = 3300000,
  504. .gpio = -1, /* updated later */
  505. .startup_delay = 70000, /* 70msec */
  506. .enable_high = 1, /* updated later */
  507. .enabled_at_boot = 0, /* keep in RESET */
  508. /* .init_data filled later */
  509. };
  510. static const char *nop_name = "nop_usb_xceiv"; /* NOP PHY driver */
  511. static const char *reg_name = "reg-fixed-voltage"; /* Regulator driver */
  512. /**
  513. * usbhs_add_regulator - Add a gpio based fixed voltage regulator device
  514. * @name: name for the regulator
  515. * @dev_id: device id of the device this regulator supplies power to
  516. * @dev_supply: supply name that the device expects
  517. * @gpio: GPIO number
  518. * @polarity: 1 - Active high, 0 - Active low
  519. */
  520. static int usbhs_add_regulator(char *name, char *dev_id, char *dev_supply,
  521. int gpio, int polarity)
  522. {
  523. struct regulator_consumer_supply *supplies;
  524. struct regulator_init_data *reg_data;
  525. struct fixed_voltage_config *config;
  526. struct platform_device *pdev;
  527. int ret;
  528. supplies = kzalloc(sizeof(*supplies), GFP_KERNEL);
  529. if (!supplies)
  530. return -ENOMEM;
  531. supplies->supply = dev_supply;
  532. supplies->dev_name = dev_id;
  533. reg_data = kzalloc(sizeof(*reg_data), GFP_KERNEL);
  534. if (!reg_data)
  535. return -ENOMEM;
  536. reg_data->constraints.valid_ops_mask = REGULATOR_CHANGE_STATUS;
  537. reg_data->consumer_supplies = supplies;
  538. reg_data->num_consumer_supplies = 1;
  539. config = kmemdup(&hsusb_reg_config, sizeof(hsusb_reg_config),
  540. GFP_KERNEL);
  541. if (!config)
  542. return -ENOMEM;
  543. config->supply_name = name;
  544. config->gpio = gpio;
  545. config->enable_high = polarity;
  546. config->init_data = reg_data;
  547. /* create a regulator device */
  548. pdev = kzalloc(sizeof(*pdev), GFP_KERNEL);
  549. if (!pdev)
  550. return -ENOMEM;
  551. pdev->id = PLATFORM_DEVID_AUTO;
  552. pdev->name = reg_name;
  553. pdev->dev.platform_data = config;
  554. ret = platform_device_register(pdev);
  555. if (ret)
  556. pr_err("%s: Failed registering regulator %s for %s\n",
  557. __func__, name, dev_id);
  558. return ret;
  559. }
  560. int usbhs_init_phys(struct usbhs_phy_data *phy, int num_phys)
  561. {
  562. char *rail_name;
  563. int i, len;
  564. struct platform_device *pdev;
  565. char *phy_id;
  566. /* the phy_id will be something like "nop_usb_xceiv.1" */
  567. len = strlen(nop_name) + 3; /* 3 -> ".1" and NULL terminator */
  568. for (i = 0; i < num_phys; i++) {
  569. if (!phy->port) {
  570. pr_err("%s: Invalid port 0. Must start from 1\n",
  571. __func__);
  572. continue;
  573. }
  574. /* do we need a NOP PHY device ? */
  575. if (!gpio_is_valid(phy->reset_gpio) &&
  576. !gpio_is_valid(phy->vcc_gpio))
  577. continue;
  578. /* create a NOP PHY device */
  579. pdev = kzalloc(sizeof(*pdev), GFP_KERNEL);
  580. if (!pdev)
  581. return -ENOMEM;
  582. pdev->id = phy->port;
  583. pdev->name = nop_name;
  584. pdev->dev.platform_data = phy->platform_data;
  585. phy_id = kmalloc(len, GFP_KERNEL);
  586. if (!phy_id)
  587. return -ENOMEM;
  588. scnprintf(phy_id, len, "nop_usb_xceiv.%d\n",
  589. pdev->id);
  590. if (platform_device_register(pdev)) {
  591. pr_err("%s: Failed to register device %s\n",
  592. __func__, phy_id);
  593. continue;
  594. }
  595. usb_bind_phy("ehci-omap.0", phy->port - 1, phy_id);
  596. /* Do we need RESET regulator ? */
  597. if (gpio_is_valid(phy->reset_gpio)) {
  598. rail_name = kmalloc(13, GFP_KERNEL);
  599. if (!rail_name)
  600. return -ENOMEM;
  601. scnprintf(rail_name, 13, "hsusb%d_reset", phy->port);
  602. usbhs_add_regulator(rail_name, phy_id, "reset",
  603. phy->reset_gpio, 1);
  604. }
  605. /* Do we need VCC regulator ? */
  606. if (gpio_is_valid(phy->vcc_gpio)) {
  607. rail_name = kmalloc(13, GFP_KERNEL);
  608. if (!rail_name)
  609. return -ENOMEM;
  610. scnprintf(rail_name, 13, "hsusb%d_vcc", phy->port);
  611. usbhs_add_regulator(rail_name, phy_id, "vcc",
  612. phy->vcc_gpio, phy->vcc_polarity);
  613. }
  614. phy++;
  615. }
  616. return 0;
  617. }