phy-cpcap-usb.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736
  1. /*
  2. * Motorola CPCAP PMIC USB PHY driver
  3. * Copyright (C) 2017 Tony Lindgren <tony@atomide.com>
  4. *
  5. * Some parts based on earlier Motorola Linux kernel tree code in
  6. * board-mapphone-usb.c and cpcap-usb-det.c:
  7. * Copyright (C) 2007 - 2011 Motorola, Inc.
  8. *
  9. * This program is free software; you can redistribute it and/or
  10. * modify it under the terms of the GNU General Public License as
  11. * published by the Free Software Foundation version 2.
  12. *
  13. * This program is distributed "as is" WITHOUT ANY WARRANTY of any
  14. * kind, whether express or implied; without even the implied warranty
  15. * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. */
  18. #include <linux/atomic.h>
  19. #include <linux/clk.h>
  20. #include <linux/delay.h>
  21. #include <linux/err.h>
  22. #include <linux/io.h>
  23. #include <linux/module.h>
  24. #include <linux/of.h>
  25. #include <linux/of_platform.h>
  26. #include <linux/iio/consumer.h>
  27. #include <linux/pinctrl/consumer.h>
  28. #include <linux/platform_device.h>
  29. #include <linux/regmap.h>
  30. #include <linux/slab.h>
  31. #include <linux/gpio/consumer.h>
  32. #include <linux/mfd/motorola-cpcap.h>
  33. #include <linux/phy/omap_usb.h>
  34. #include <linux/phy/phy.h>
  35. #include <linux/regulator/consumer.h>
  36. #include <linux/usb/musb.h>
  37. /* CPCAP_REG_USBC1 register bits */
  38. #define CPCAP_BIT_IDPULSE BIT(15)
  39. #define CPCAP_BIT_ID100KPU BIT(14)
  40. #define CPCAP_BIT_IDPUCNTRL BIT(13)
  41. #define CPCAP_BIT_IDPU BIT(12)
  42. #define CPCAP_BIT_IDPD BIT(11)
  43. #define CPCAP_BIT_VBUSCHRGTMR3 BIT(10)
  44. #define CPCAP_BIT_VBUSCHRGTMR2 BIT(9)
  45. #define CPCAP_BIT_VBUSCHRGTMR1 BIT(8)
  46. #define CPCAP_BIT_VBUSCHRGTMR0 BIT(7)
  47. #define CPCAP_BIT_VBUSPU BIT(6)
  48. #define CPCAP_BIT_VBUSPD BIT(5)
  49. #define CPCAP_BIT_DMPD BIT(4)
  50. #define CPCAP_BIT_DPPD BIT(3)
  51. #define CPCAP_BIT_DM1K5PU BIT(2)
  52. #define CPCAP_BIT_DP1K5PU BIT(1)
  53. #define CPCAP_BIT_DP150KPU BIT(0)
  54. /* CPCAP_REG_USBC2 register bits */
  55. #define CPCAP_BIT_ZHSDRV1 BIT(15)
  56. #define CPCAP_BIT_ZHSDRV0 BIT(14)
  57. #define CPCAP_BIT_DPLLCLKREQ BIT(13)
  58. #define CPCAP_BIT_SE0CONN BIT(12)
  59. #define CPCAP_BIT_UARTTXTRI BIT(11)
  60. #define CPCAP_BIT_UARTSWAP BIT(10)
  61. #define CPCAP_BIT_UARTMUX1 BIT(9)
  62. #define CPCAP_BIT_UARTMUX0 BIT(8)
  63. #define CPCAP_BIT_ULPISTPLOW BIT(7)
  64. #define CPCAP_BIT_TXENPOL BIT(6)
  65. #define CPCAP_BIT_USBXCVREN BIT(5)
  66. #define CPCAP_BIT_USBCNTRL BIT(4)
  67. #define CPCAP_BIT_USBSUSPEND BIT(3)
  68. #define CPCAP_BIT_EMUMODE2 BIT(2)
  69. #define CPCAP_BIT_EMUMODE1 BIT(1)
  70. #define CPCAP_BIT_EMUMODE0 BIT(0)
  71. /* CPCAP_REG_USBC3 register bits */
  72. #define CPCAP_BIT_SPARE_898_15 BIT(15)
  73. #define CPCAP_BIT_IHSTX03 BIT(14)
  74. #define CPCAP_BIT_IHSTX02 BIT(13)
  75. #define CPCAP_BIT_IHSTX01 BIT(12)
  76. #define CPCAP_BIT_IHSTX0 BIT(11)
  77. #define CPCAP_BIT_IDPU_SPI BIT(10)
  78. #define CPCAP_BIT_UNUSED_898_9 BIT(9)
  79. #define CPCAP_BIT_VBUSSTBY_EN BIT(8)
  80. #define CPCAP_BIT_VBUSEN_SPI BIT(7)
  81. #define CPCAP_BIT_VBUSPU_SPI BIT(6)
  82. #define CPCAP_BIT_VBUSPD_SPI BIT(5)
  83. #define CPCAP_BIT_DMPD_SPI BIT(4)
  84. #define CPCAP_BIT_DPPD_SPI BIT(3)
  85. #define CPCAP_BIT_SUSPEND_SPI BIT(2)
  86. #define CPCAP_BIT_PU_SPI BIT(1)
  87. #define CPCAP_BIT_ULPI_SPI_SEL BIT(0)
  88. struct cpcap_usb_ints_state {
  89. bool id_ground;
  90. bool id_float;
  91. bool chrg_det;
  92. bool rvrs_chrg;
  93. bool vbusov;
  94. bool chrg_se1b;
  95. bool se0conn;
  96. bool rvrs_mode;
  97. bool chrgcurr1;
  98. bool vbusvld;
  99. bool sessvld;
  100. bool sessend;
  101. bool se1;
  102. bool battdetb;
  103. bool dm;
  104. bool dp;
  105. };
  106. enum cpcap_gpio_mode {
  107. CPCAP_DM_DP,
  108. CPCAP_MDM_RX_TX,
  109. CPCAP_UNKNOWN_DISABLED, /* Seems to disable USB lines */
  110. CPCAP_OTG_DM_DP,
  111. };
  112. struct cpcap_phy_ddata {
  113. struct regmap *reg;
  114. struct device *dev;
  115. struct usb_phy phy;
  116. struct delayed_work detect_work;
  117. struct pinctrl *pins;
  118. struct pinctrl_state *pins_ulpi;
  119. struct pinctrl_state *pins_utmi;
  120. struct pinctrl_state *pins_uart;
  121. struct gpio_desc *gpio[2];
  122. struct iio_channel *vbus;
  123. struct iio_channel *id;
  124. struct regulator *vusb;
  125. atomic_t active;
  126. unsigned int vbus_provider:1;
  127. unsigned int docked:1;
  128. };
  129. static bool cpcap_usb_vbus_valid(struct cpcap_phy_ddata *ddata)
  130. {
  131. int error, value = 0;
  132. error = iio_read_channel_processed(ddata->vbus, &value);
  133. if (error >= 0)
  134. return value > 3900 ? true : false;
  135. dev_err(ddata->dev, "error reading VBUS: %i\n", error);
  136. return false;
  137. }
  138. static int cpcap_usb_phy_set_host(struct usb_otg *otg, struct usb_bus *host)
  139. {
  140. otg->host = host;
  141. if (!host)
  142. otg->state = OTG_STATE_UNDEFINED;
  143. return 0;
  144. }
  145. static int cpcap_usb_phy_set_peripheral(struct usb_otg *otg,
  146. struct usb_gadget *gadget)
  147. {
  148. otg->gadget = gadget;
  149. if (!gadget)
  150. otg->state = OTG_STATE_UNDEFINED;
  151. return 0;
  152. }
  153. static const struct phy_ops ops = {
  154. .owner = THIS_MODULE,
  155. };
  156. static int cpcap_phy_get_ints_state(struct cpcap_phy_ddata *ddata,
  157. struct cpcap_usb_ints_state *s)
  158. {
  159. int val, error;
  160. error = regmap_read(ddata->reg, CPCAP_REG_INTS1, &val);
  161. if (error)
  162. return error;
  163. s->id_ground = val & BIT(15);
  164. s->id_float = val & BIT(14);
  165. s->vbusov = val & BIT(11);
  166. error = regmap_read(ddata->reg, CPCAP_REG_INTS2, &val);
  167. if (error)
  168. return error;
  169. s->vbusvld = val & BIT(3);
  170. s->sessvld = val & BIT(2);
  171. s->sessend = val & BIT(1);
  172. s->se1 = val & BIT(0);
  173. error = regmap_read(ddata->reg, CPCAP_REG_INTS4, &val);
  174. if (error)
  175. return error;
  176. s->dm = val & BIT(1);
  177. s->dp = val & BIT(0);
  178. return 0;
  179. }
  180. static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata);
  181. static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata);
  182. static void cpcap_usb_try_musb_mailbox(struct cpcap_phy_ddata *ddata,
  183. enum musb_vbus_id_status status)
  184. {
  185. int error;
  186. error = musb_mailbox(status);
  187. if (!error)
  188. return;
  189. dev_dbg(ddata->dev, "%s: musb_mailbox failed: %i\n",
  190. __func__, error);
  191. }
  192. static void cpcap_usb_detect(struct work_struct *work)
  193. {
  194. struct cpcap_phy_ddata *ddata;
  195. struct cpcap_usb_ints_state s;
  196. bool vbus = false;
  197. int error;
  198. ddata = container_of(work, struct cpcap_phy_ddata, detect_work.work);
  199. error = cpcap_phy_get_ints_state(ddata, &s);
  200. if (error)
  201. return;
  202. vbus = cpcap_usb_vbus_valid(ddata);
  203. /* We need to kick the VBUS as USB A-host */
  204. if (s.id_ground && ddata->vbus_provider) {
  205. dev_dbg(ddata->dev, "still in USB A-host mode, kicking VBUS\n");
  206. cpcap_usb_try_musb_mailbox(ddata, MUSB_ID_GROUND);
  207. error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
  208. CPCAP_BIT_VBUSSTBY_EN |
  209. CPCAP_BIT_VBUSEN_SPI,
  210. CPCAP_BIT_VBUSEN_SPI);
  211. if (error)
  212. goto out_err;
  213. return;
  214. }
  215. if (vbus && s.id_ground && ddata->docked) {
  216. dev_dbg(ddata->dev, "still docked as A-host, signal ID down\n");
  217. cpcap_usb_try_musb_mailbox(ddata, MUSB_ID_GROUND);
  218. return;
  219. }
  220. /* No VBUS needed with docks */
  221. if (vbus && s.id_ground && !ddata->vbus_provider) {
  222. dev_dbg(ddata->dev, "connected to a dock\n");
  223. ddata->docked = true;
  224. error = cpcap_usb_set_usb_mode(ddata);
  225. if (error)
  226. goto out_err;
  227. cpcap_usb_try_musb_mailbox(ddata, MUSB_ID_GROUND);
  228. /*
  229. * Force check state again after musb has reoriented,
  230. * otherwise devices won't enumerate after loading PHY
  231. * driver.
  232. */
  233. schedule_delayed_work(&ddata->detect_work,
  234. msecs_to_jiffies(1000));
  235. return;
  236. }
  237. if (s.id_ground && !ddata->docked) {
  238. dev_dbg(ddata->dev, "id ground, USB host mode\n");
  239. ddata->vbus_provider = true;
  240. error = cpcap_usb_set_usb_mode(ddata);
  241. if (error)
  242. goto out_err;
  243. cpcap_usb_try_musb_mailbox(ddata, MUSB_ID_GROUND);
  244. error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
  245. CPCAP_BIT_VBUSSTBY_EN |
  246. CPCAP_BIT_VBUSEN_SPI,
  247. CPCAP_BIT_VBUSEN_SPI);
  248. if (error)
  249. goto out_err;
  250. return;
  251. }
  252. error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
  253. CPCAP_BIT_VBUSSTBY_EN |
  254. CPCAP_BIT_VBUSEN_SPI, 0);
  255. if (error)
  256. goto out_err;
  257. vbus = cpcap_usb_vbus_valid(ddata);
  258. /* Otherwise assume we're connected to a USB host */
  259. if (vbus) {
  260. dev_dbg(ddata->dev, "connected to USB host\n");
  261. error = cpcap_usb_set_usb_mode(ddata);
  262. if (error)
  263. goto out_err;
  264. cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_VALID);
  265. return;
  266. }
  267. ddata->vbus_provider = false;
  268. ddata->docked = false;
  269. cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_OFF);
  270. /* Default to debug UART mode */
  271. error = cpcap_usb_set_uart_mode(ddata);
  272. if (error)
  273. goto out_err;
  274. dev_dbg(ddata->dev, "set UART mode\n");
  275. return;
  276. out_err:
  277. dev_err(ddata->dev, "error setting cable state: %i\n", error);
  278. }
  279. static irqreturn_t cpcap_phy_irq_thread(int irq, void *data)
  280. {
  281. struct cpcap_phy_ddata *ddata = data;
  282. if (!atomic_read(&ddata->active))
  283. return IRQ_NONE;
  284. schedule_delayed_work(&ddata->detect_work, msecs_to_jiffies(1));
  285. return IRQ_HANDLED;
  286. }
  287. static int cpcap_usb_init_irq(struct platform_device *pdev,
  288. struct cpcap_phy_ddata *ddata,
  289. const char *name)
  290. {
  291. int irq, error;
  292. irq = platform_get_irq_byname(pdev, name);
  293. if (irq < 0)
  294. return -ENODEV;
  295. error = devm_request_threaded_irq(ddata->dev, irq, NULL,
  296. cpcap_phy_irq_thread,
  297. IRQF_SHARED |
  298. IRQF_ONESHOT,
  299. name, ddata);
  300. if (error) {
  301. dev_err(ddata->dev, "could not get irq %s: %i\n",
  302. name, error);
  303. return error;
  304. }
  305. return 0;
  306. }
  307. static const char * const cpcap_phy_irqs[] = {
  308. /* REG_INT_0 */
  309. "id_ground", "id_float",
  310. /* REG_INT1 */
  311. "se0conn", "vbusvld", "sessvld", "sessend", "se1",
  312. /* REG_INT_3 */
  313. "dm", "dp",
  314. };
  315. static int cpcap_usb_init_interrupts(struct platform_device *pdev,
  316. struct cpcap_phy_ddata *ddata)
  317. {
  318. int i, error;
  319. for (i = 0; i < ARRAY_SIZE(cpcap_phy_irqs); i++) {
  320. error = cpcap_usb_init_irq(pdev, ddata, cpcap_phy_irqs[i]);
  321. if (error)
  322. return error;
  323. }
  324. return 0;
  325. }
  326. /*
  327. * Optional pins and modes. At least Motorola mapphone devices
  328. * are using two GPIOs and dynamic pinctrl to multiplex PHY pins
  329. * to UART, ULPI or UTMI mode.
  330. */
  331. static int cpcap_usb_gpio_set_mode(struct cpcap_phy_ddata *ddata,
  332. enum cpcap_gpio_mode mode)
  333. {
  334. if (!ddata->gpio[0] || !ddata->gpio[1])
  335. return 0;
  336. gpiod_set_value(ddata->gpio[0], mode & 1);
  337. gpiod_set_value(ddata->gpio[1], mode >> 1);
  338. return 0;
  339. }
  340. static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata)
  341. {
  342. int error;
  343. /* Disable lines to prevent glitches from waking up mdm6600 */
  344. error = cpcap_usb_gpio_set_mode(ddata, CPCAP_UNKNOWN_DISABLED);
  345. if (error)
  346. goto out_err;
  347. if (ddata->pins_uart) {
  348. error = pinctrl_select_state(ddata->pins, ddata->pins_uart);
  349. if (error)
  350. goto out_err;
  351. }
  352. error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC1,
  353. CPCAP_BIT_VBUSPD,
  354. CPCAP_BIT_VBUSPD);
  355. if (error)
  356. goto out_err;
  357. error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
  358. 0xffff, CPCAP_BIT_UARTMUX0 |
  359. CPCAP_BIT_EMUMODE0);
  360. if (error)
  361. goto out_err;
  362. error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3, 0x7fff,
  363. CPCAP_BIT_IDPU_SPI);
  364. if (error)
  365. goto out_err;
  366. /* Enable UART mode */
  367. error = cpcap_usb_gpio_set_mode(ddata, CPCAP_DM_DP);
  368. if (error)
  369. goto out_err;
  370. return 0;
  371. out_err:
  372. dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
  373. return error;
  374. }
  375. static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata)
  376. {
  377. int error;
  378. /* Disable lines to prevent glitches from waking up mdm6600 */
  379. error = cpcap_usb_gpio_set_mode(ddata, CPCAP_UNKNOWN_DISABLED);
  380. if (error)
  381. return error;
  382. if (ddata->pins_utmi) {
  383. error = pinctrl_select_state(ddata->pins, ddata->pins_utmi);
  384. if (error) {
  385. dev_err(ddata->dev, "could not set usb mode: %i\n",
  386. error);
  387. return error;
  388. }
  389. }
  390. error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC1,
  391. CPCAP_BIT_VBUSPD, 0);
  392. if (error)
  393. goto out_err;
  394. error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
  395. CPCAP_BIT_PU_SPI |
  396. CPCAP_BIT_DMPD_SPI |
  397. CPCAP_BIT_DPPD_SPI |
  398. CPCAP_BIT_SUSPEND_SPI |
  399. CPCAP_BIT_ULPI_SPI_SEL, 0);
  400. if (error)
  401. goto out_err;
  402. error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
  403. CPCAP_BIT_USBXCVREN,
  404. CPCAP_BIT_USBXCVREN);
  405. if (error)
  406. goto out_err;
  407. /* Enable USB mode */
  408. error = cpcap_usb_gpio_set_mode(ddata, CPCAP_OTG_DM_DP);
  409. if (error)
  410. goto out_err;
  411. return 0;
  412. out_err:
  413. dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
  414. return error;
  415. }
  416. static int cpcap_usb_init_optional_pins(struct cpcap_phy_ddata *ddata)
  417. {
  418. ddata->pins = devm_pinctrl_get(ddata->dev);
  419. if (IS_ERR(ddata->pins)) {
  420. dev_info(ddata->dev, "default pins not configured: %ld\n",
  421. PTR_ERR(ddata->pins));
  422. ddata->pins = NULL;
  423. return 0;
  424. }
  425. ddata->pins_ulpi = pinctrl_lookup_state(ddata->pins, "ulpi");
  426. if (IS_ERR(ddata->pins_ulpi)) {
  427. dev_info(ddata->dev, "ulpi pins not configured\n");
  428. ddata->pins_ulpi = NULL;
  429. }
  430. ddata->pins_utmi = pinctrl_lookup_state(ddata->pins, "utmi");
  431. if (IS_ERR(ddata->pins_utmi)) {
  432. dev_info(ddata->dev, "utmi pins not configured\n");
  433. ddata->pins_utmi = NULL;
  434. }
  435. ddata->pins_uart = pinctrl_lookup_state(ddata->pins, "uart");
  436. if (IS_ERR(ddata->pins_uart)) {
  437. dev_info(ddata->dev, "uart pins not configured\n");
  438. ddata->pins_uart = NULL;
  439. }
  440. if (ddata->pins_uart)
  441. return pinctrl_select_state(ddata->pins, ddata->pins_uart);
  442. return 0;
  443. }
  444. static void cpcap_usb_init_optional_gpios(struct cpcap_phy_ddata *ddata)
  445. {
  446. int i;
  447. for (i = 0; i < 2; i++) {
  448. ddata->gpio[i] = devm_gpiod_get_index(ddata->dev, "mode",
  449. i, GPIOD_OUT_HIGH);
  450. if (IS_ERR(ddata->gpio[i])) {
  451. dev_info(ddata->dev, "no mode change GPIO%i: %li\n",
  452. i, PTR_ERR(ddata->gpio[i]));
  453. ddata->gpio[i] = NULL;
  454. }
  455. }
  456. }
  457. static int cpcap_usb_init_iio(struct cpcap_phy_ddata *ddata)
  458. {
  459. enum iio_chan_type type;
  460. int error;
  461. ddata->vbus = devm_iio_channel_get(ddata->dev, "vbus");
  462. if (IS_ERR(ddata->vbus)) {
  463. error = PTR_ERR(ddata->vbus);
  464. goto out_err;
  465. }
  466. if (!ddata->vbus->indio_dev) {
  467. error = -ENXIO;
  468. goto out_err;
  469. }
  470. error = iio_get_channel_type(ddata->vbus, &type);
  471. if (error < 0)
  472. goto out_err;
  473. if (type != IIO_VOLTAGE) {
  474. error = -EINVAL;
  475. goto out_err;
  476. }
  477. return 0;
  478. out_err:
  479. dev_err(ddata->dev, "could not initialize VBUS or ID IIO: %i\n",
  480. error);
  481. return error;
  482. }
  483. #ifdef CONFIG_OF
  484. static const struct of_device_id cpcap_usb_phy_id_table[] = {
  485. {
  486. .compatible = "motorola,cpcap-usb-phy",
  487. },
  488. {
  489. .compatible = "motorola,mapphone-cpcap-usb-phy",
  490. },
  491. {},
  492. };
  493. MODULE_DEVICE_TABLE(of, cpcap_usb_phy_id_table);
  494. #endif
  495. static int cpcap_usb_phy_probe(struct platform_device *pdev)
  496. {
  497. struct cpcap_phy_ddata *ddata;
  498. struct phy *generic_phy;
  499. struct phy_provider *phy_provider;
  500. struct usb_otg *otg;
  501. const struct of_device_id *of_id;
  502. int error;
  503. of_id = of_match_device(of_match_ptr(cpcap_usb_phy_id_table),
  504. &pdev->dev);
  505. if (!of_id)
  506. return -EINVAL;
  507. ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
  508. if (!ddata)
  509. return -ENOMEM;
  510. ddata->reg = dev_get_regmap(pdev->dev.parent, NULL);
  511. if (!ddata->reg)
  512. return -ENODEV;
  513. otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL);
  514. if (!otg)
  515. return -ENOMEM;
  516. ddata->dev = &pdev->dev;
  517. ddata->phy.dev = ddata->dev;
  518. ddata->phy.label = "cpcap_usb_phy";
  519. ddata->phy.otg = otg;
  520. ddata->phy.type = USB_PHY_TYPE_USB2;
  521. otg->set_host = cpcap_usb_phy_set_host;
  522. otg->set_peripheral = cpcap_usb_phy_set_peripheral;
  523. otg->usb_phy = &ddata->phy;
  524. INIT_DELAYED_WORK(&ddata->detect_work, cpcap_usb_detect);
  525. platform_set_drvdata(pdev, ddata);
  526. ddata->vusb = devm_regulator_get(&pdev->dev, "vusb");
  527. if (IS_ERR(ddata->vusb))
  528. return PTR_ERR(ddata->vusb);
  529. error = regulator_enable(ddata->vusb);
  530. if (error)
  531. return error;
  532. generic_phy = devm_phy_create(ddata->dev, NULL, &ops);
  533. if (IS_ERR(generic_phy)) {
  534. error = PTR_ERR(generic_phy);
  535. goto out_reg_disable;
  536. }
  537. phy_set_drvdata(generic_phy, ddata);
  538. phy_provider = devm_of_phy_provider_register(ddata->dev,
  539. of_phy_simple_xlate);
  540. if (IS_ERR(phy_provider)) {
  541. error = PTR_ERR(phy_provider);
  542. goto out_reg_disable;
  543. }
  544. error = cpcap_usb_init_optional_pins(ddata);
  545. if (error)
  546. goto out_reg_disable;
  547. cpcap_usb_init_optional_gpios(ddata);
  548. error = cpcap_usb_init_iio(ddata);
  549. if (error)
  550. goto out_reg_disable;
  551. error = cpcap_usb_init_interrupts(pdev, ddata);
  552. if (error)
  553. goto out_reg_disable;
  554. usb_add_phy_dev(&ddata->phy);
  555. atomic_set(&ddata->active, 1);
  556. schedule_delayed_work(&ddata->detect_work, msecs_to_jiffies(1));
  557. return 0;
  558. out_reg_disable:
  559. regulator_disable(ddata->vusb);
  560. return error;
  561. }
  562. static int cpcap_usb_phy_remove(struct platform_device *pdev)
  563. {
  564. struct cpcap_phy_ddata *ddata = platform_get_drvdata(pdev);
  565. int error;
  566. atomic_set(&ddata->active, 0);
  567. error = cpcap_usb_set_uart_mode(ddata);
  568. if (error)
  569. dev_err(ddata->dev, "could not set UART mode\n");
  570. cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_OFF);
  571. usb_remove_phy(&ddata->phy);
  572. cancel_delayed_work_sync(&ddata->detect_work);
  573. regulator_disable(ddata->vusb);
  574. return 0;
  575. }
  576. static struct platform_driver cpcap_usb_phy_driver = {
  577. .probe = cpcap_usb_phy_probe,
  578. .remove = cpcap_usb_phy_remove,
  579. .driver = {
  580. .name = "cpcap-usb-phy",
  581. .of_match_table = of_match_ptr(cpcap_usb_phy_id_table),
  582. },
  583. };
  584. module_platform_driver(cpcap_usb_phy_driver);
  585. MODULE_ALIAS("platform:cpcap_usb");
  586. MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
  587. MODULE_DESCRIPTION("CPCAP usb phy driver");
  588. MODULE_LICENSE("GPL v2");