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