This source file includes following definitions.
- usbhs_read
- usbhs_write
- usbhs_bset
- usbhs_pdev_to_priv
- usbhs_get_id_as_gadget
- usbhs_sys_clock_ctrl
- usbhs_sys_host_ctrl
- usbhs_sys_function_ctrl
- usbhs_sys_function_pullup
- usbhs_sys_set_test_mode
- usbhs_frame_get_num
- usbhs_usbreq_get_val
- usbhs_usbreq_set_val
- usbhs_bus_send_sof_enable
- usbhs_bus_send_reset
- usbhs_bus_get_speed
- usbhs_vbus_ctrl
- usbhsc_bus_init
- usbhs_set_device_config
- usbhs_xxxsts_clear
- usbhsc_set_buswait
- usbhsc_is_multi_clks
- usbhsc_clk_get
- usbhsc_clk_put
- usbhsc_clk_prepare_enable
- usbhsc_clk_disable_unprepare
- usbhsc_power_ctrl
- usbhsc_hotplug
- usbhsc_notify_hotplug
- usbhsc_schedule_notify_hotplug
- usbhs_probe
- usbhs_remove
- usbhsc_suspend
- usbhsc_resume
1
2
3
4
5
6
7
8
9 #include <linux/clk.h>
10 #include <linux/err.h>
11 #include <linux/gpio.h>
12 #include <linux/io.h>
13 #include <linux/module.h>
14 #include <linux/of_device.h>
15 #include <linux/of_gpio.h>
16 #include <linux/pm_runtime.h>
17 #include <linux/reset.h>
18 #include <linux/slab.h>
19 #include <linux/sysfs.h>
20 #include "common.h"
21 #include "rcar2.h"
22 #include "rcar3.h"
23 #include "rza.h"
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54 #define usbhs_platform_call(priv, func, args...)\
55 (!(priv) ? -ENODEV : \
56 !((priv)->pfunc->func) ? 0 : \
57 (priv)->pfunc->func(args))
58
59
60
61
62 u16 usbhs_read(struct usbhs_priv *priv, u32 reg)
63 {
64 return ioread16(priv->base + reg);
65 }
66
67 void usbhs_write(struct usbhs_priv *priv, u32 reg, u16 data)
68 {
69 iowrite16(data, priv->base + reg);
70 }
71
72 void usbhs_bset(struct usbhs_priv *priv, u32 reg, u16 mask, u16 data)
73 {
74 u16 val = usbhs_read(priv, reg);
75
76 val &= ~mask;
77 val |= data & mask;
78
79 usbhs_write(priv, reg, val);
80 }
81
82 struct usbhs_priv *usbhs_pdev_to_priv(struct platform_device *pdev)
83 {
84 return dev_get_drvdata(&pdev->dev);
85 }
86
87 int usbhs_get_id_as_gadget(struct platform_device *pdev)
88 {
89 return USBHS_GADGET;
90 }
91
92
93
94
95 static void usbhs_sys_clock_ctrl(struct usbhs_priv *priv, int enable)
96 {
97 usbhs_bset(priv, SYSCFG, SCKE, enable ? SCKE : 0);
98 }
99
100 void usbhs_sys_host_ctrl(struct usbhs_priv *priv, int enable)
101 {
102 u16 mask = DCFM | DRPD | DPRPU | HSE | USBE;
103 u16 val = DCFM | DRPD | HSE | USBE;
104
105
106
107
108
109
110
111 usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
112 }
113
114 void usbhs_sys_function_ctrl(struct usbhs_priv *priv, int enable)
115 {
116 u16 mask = DCFM | DRPD | DPRPU | HSE | USBE;
117 u16 val = HSE | USBE;
118
119
120 if (usbhs_get_dparam(priv, has_cnen)) {
121 mask |= CNEN;
122 val |= CNEN;
123 }
124
125
126
127
128
129
130
131
132
133 usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
134 }
135
136 void usbhs_sys_function_pullup(struct usbhs_priv *priv, int enable)
137 {
138 usbhs_bset(priv, SYSCFG, DPRPU, enable ? DPRPU : 0);
139 }
140
141 void usbhs_sys_set_test_mode(struct usbhs_priv *priv, u16 mode)
142 {
143 usbhs_write(priv, TESTMODE, mode);
144 }
145
146
147
148
149 int usbhs_frame_get_num(struct usbhs_priv *priv)
150 {
151 return usbhs_read(priv, FRMNUM) & FRNM_MASK;
152 }
153
154
155
156
157 void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
158 {
159 u16 val;
160
161 val = usbhs_read(priv, USBREQ);
162 req->bRequest = (val >> 8) & 0xFF;
163 req->bRequestType = (val >> 0) & 0xFF;
164
165 req->wValue = cpu_to_le16(usbhs_read(priv, USBVAL));
166 req->wIndex = cpu_to_le16(usbhs_read(priv, USBINDX));
167 req->wLength = cpu_to_le16(usbhs_read(priv, USBLENG));
168 }
169
170 void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
171 {
172 usbhs_write(priv, USBREQ, (req->bRequest << 8) | req->bRequestType);
173 usbhs_write(priv, USBVAL, le16_to_cpu(req->wValue));
174 usbhs_write(priv, USBINDX, le16_to_cpu(req->wIndex));
175 usbhs_write(priv, USBLENG, le16_to_cpu(req->wLength));
176
177 usbhs_bset(priv, DCPCTR, SUREQ, SUREQ);
178 }
179
180
181
182
183 void usbhs_bus_send_sof_enable(struct usbhs_priv *priv)
184 {
185 u16 status = usbhs_read(priv, DVSTCTR) & (USBRST | UACT);
186
187 if (status != USBRST) {
188 struct device *dev = usbhs_priv_to_dev(priv);
189 dev_err(dev, "usbhs should be reset\n");
190 }
191
192 usbhs_bset(priv, DVSTCTR, (USBRST | UACT), UACT);
193 }
194
195 void usbhs_bus_send_reset(struct usbhs_priv *priv)
196 {
197 usbhs_bset(priv, DVSTCTR, (USBRST | UACT), USBRST);
198 }
199
200 int usbhs_bus_get_speed(struct usbhs_priv *priv)
201 {
202 u16 dvstctr = usbhs_read(priv, DVSTCTR);
203
204 switch (RHST & dvstctr) {
205 case RHST_LOW_SPEED:
206 return USB_SPEED_LOW;
207 case RHST_FULL_SPEED:
208 return USB_SPEED_FULL;
209 case RHST_HIGH_SPEED:
210 return USB_SPEED_HIGH;
211 }
212
213 return USB_SPEED_UNKNOWN;
214 }
215
216 int usbhs_vbus_ctrl(struct usbhs_priv *priv, int enable)
217 {
218 struct platform_device *pdev = usbhs_priv_to_pdev(priv);
219
220 return usbhs_platform_call(priv, set_vbus, pdev, enable);
221 }
222
223 static void usbhsc_bus_init(struct usbhs_priv *priv)
224 {
225 usbhs_write(priv, DVSTCTR, 0);
226
227 usbhs_vbus_ctrl(priv, 0);
228 }
229
230
231
232
233 int usbhs_set_device_config(struct usbhs_priv *priv, int devnum,
234 u16 upphub, u16 hubport, u16 speed)
235 {
236 struct device *dev = usbhs_priv_to_dev(priv);
237 u16 usbspd = 0;
238 u32 reg = DEVADD0 + (2 * devnum);
239
240 if (devnum > 10) {
241 dev_err(dev, "cannot set speed to unknown device %d\n", devnum);
242 return -EIO;
243 }
244
245 if (upphub > 0xA) {
246 dev_err(dev, "unsupported hub number %d\n", upphub);
247 return -EIO;
248 }
249
250 switch (speed) {
251 case USB_SPEED_LOW:
252 usbspd = USBSPD_SPEED_LOW;
253 break;
254 case USB_SPEED_FULL:
255 usbspd = USBSPD_SPEED_FULL;
256 break;
257 case USB_SPEED_HIGH:
258 usbspd = USBSPD_SPEED_HIGH;
259 break;
260 default:
261 dev_err(dev, "unsupported speed %d\n", speed);
262 return -EIO;
263 }
264
265 usbhs_write(priv, reg, UPPHUB(upphub) |
266 HUBPORT(hubport)|
267 USBSPD(usbspd));
268
269 return 0;
270 }
271
272
273
274
275 void usbhs_xxxsts_clear(struct usbhs_priv *priv, u16 sts_reg, u16 bit)
276 {
277 u16 pipe_mask = (u16)GENMASK(usbhs_get_dparam(priv, pipe_size), 0);
278
279 usbhs_write(priv, sts_reg, ~(1 << bit) & pipe_mask);
280 }
281
282
283
284
285 static void usbhsc_set_buswait(struct usbhs_priv *priv)
286 {
287 int wait = usbhs_get_dparam(priv, buswait_bwait);
288
289
290 if (wait)
291 usbhs_bset(priv, BUSWAIT, 0x000F, wait);
292 }
293
294 static bool usbhsc_is_multi_clks(struct usbhs_priv *priv)
295 {
296 return priv->dparam.multi_clks;
297 }
298
299 static int usbhsc_clk_get(struct device *dev, struct usbhs_priv *priv)
300 {
301 if (!usbhsc_is_multi_clks(priv))
302 return 0;
303
304
305 priv->clks[0] = of_clk_get(dev_of_node(dev), 0);
306 if (IS_ERR(priv->clks[0]))
307 return PTR_ERR(priv->clks[0]);
308
309
310
311
312
313 priv->clks[1] = of_clk_get(dev_of_node(dev), 1);
314 if (PTR_ERR(priv->clks[1]) == -ENOENT)
315 priv->clks[1] = NULL;
316 else if (IS_ERR(priv->clks[1]))
317 return PTR_ERR(priv->clks[1]);
318
319 return 0;
320 }
321
322 static void usbhsc_clk_put(struct usbhs_priv *priv)
323 {
324 int i;
325
326 if (!usbhsc_is_multi_clks(priv))
327 return;
328
329 for (i = 0; i < ARRAY_SIZE(priv->clks); i++)
330 clk_put(priv->clks[i]);
331 }
332
333 static int usbhsc_clk_prepare_enable(struct usbhs_priv *priv)
334 {
335 int i, ret;
336
337 if (!usbhsc_is_multi_clks(priv))
338 return 0;
339
340 for (i = 0; i < ARRAY_SIZE(priv->clks); i++) {
341 ret = clk_prepare_enable(priv->clks[i]);
342 if (ret) {
343 while (--i >= 0)
344 clk_disable_unprepare(priv->clks[i]);
345 return ret;
346 }
347 }
348
349 return ret;
350 }
351
352 static void usbhsc_clk_disable_unprepare(struct usbhs_priv *priv)
353 {
354 int i;
355
356 if (!usbhsc_is_multi_clks(priv))
357 return;
358
359 for (i = 0; i < ARRAY_SIZE(priv->clks); i++)
360 clk_disable_unprepare(priv->clks[i]);
361 }
362
363
364
365
366
367
368 static struct renesas_usbhs_driver_pipe_config usbhsc_default_pipe[] = {
369 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_CONTROL, 64, 0x00, false),
370 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_ISOC, 1024, 0x08, false),
371 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_ISOC, 1024, 0x18, false),
372 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x28, true),
373 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x38, true),
374 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x48, true),
375 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x04, false),
376 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x05, false),
377 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x06, false),
378 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x07, false),
379 };
380
381
382 static struct renesas_usbhs_driver_pipe_config usbhsc_new_pipe[] = {
383 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_CONTROL, 64, 0x00, false),
384 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_ISOC, 1024, 0x08, true),
385 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_ISOC, 1024, 0x28, true),
386 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x48, true),
387 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x58, true),
388 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x68, true),
389 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x04, false),
390 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x05, false),
391 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x06, false),
392 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x78, true),
393 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x88, true),
394 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x98, true),
395 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0xa8, true),
396 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0xb8, true),
397 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0xc8, true),
398 RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0xd8, true),
399 };
400
401
402
403
404 static void usbhsc_power_ctrl(struct usbhs_priv *priv, int enable)
405 {
406 struct platform_device *pdev = usbhs_priv_to_pdev(priv);
407 struct device *dev = usbhs_priv_to_dev(priv);
408
409 if (enable) {
410
411 pm_runtime_get_sync(dev);
412
413
414 if (usbhsc_clk_prepare_enable(priv))
415 return;
416
417
418 usbhs_platform_call(priv, power_ctrl, pdev, priv->base, enable);
419
420
421 usbhs_sys_clock_ctrl(priv, enable);
422 } else {
423
424 usbhs_sys_clock_ctrl(priv, enable);
425
426
427 usbhs_platform_call(priv, power_ctrl, pdev, priv->base, enable);
428
429
430 usbhsc_clk_disable_unprepare(priv);
431
432
433 pm_runtime_put_sync(dev);
434 }
435 }
436
437
438
439
440 static void usbhsc_hotplug(struct usbhs_priv *priv)
441 {
442 struct platform_device *pdev = usbhs_priv_to_pdev(priv);
443 struct usbhs_mod *mod = usbhs_mod_get_current(priv);
444 int id;
445 int enable;
446 int cable;
447 int ret;
448
449
450
451
452 enable = usbhs_mod_info_call(priv, get_vbus, pdev);
453
454
455
456
457 id = usbhs_platform_call(priv, get_id, pdev);
458
459 if (enable && !mod) {
460 if (priv->edev) {
461 cable = extcon_get_state(priv->edev, EXTCON_USB_HOST);
462 if ((cable > 0 && id != USBHS_HOST) ||
463 (!cable && id != USBHS_GADGET)) {
464 dev_info(&pdev->dev,
465 "USB cable plugged in doesn't match the selected role!\n");
466 return;
467 }
468 }
469
470 ret = usbhs_mod_change(priv, id);
471 if (ret < 0)
472 return;
473
474 dev_dbg(&pdev->dev, "%s enable\n", __func__);
475
476
477 if (usbhs_get_dparam(priv, runtime_pwctrl))
478 usbhsc_power_ctrl(priv, enable);
479
480
481 usbhsc_set_buswait(priv);
482 usbhsc_bus_init(priv);
483
484
485 usbhs_mod_call(priv, start, priv);
486
487 } else if (!enable && mod) {
488 dev_dbg(&pdev->dev, "%s disable\n", __func__);
489
490
491 usbhs_mod_call(priv, stop, priv);
492
493
494 usbhsc_bus_init(priv);
495
496
497 if (usbhs_get_dparam(priv, runtime_pwctrl))
498 usbhsc_power_ctrl(priv, enable);
499
500 usbhs_mod_change(priv, -1);
501
502
503 usbhs_platform_call(priv, phy_reset, pdev);
504 }
505 }
506
507
508
509
510 static void usbhsc_notify_hotplug(struct work_struct *work)
511 {
512 struct usbhs_priv *priv = container_of(work,
513 struct usbhs_priv,
514 notify_hotplug_work.work);
515 usbhsc_hotplug(priv);
516 }
517
518 int usbhsc_schedule_notify_hotplug(struct platform_device *pdev)
519 {
520 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
521 int delay = usbhs_get_dparam(priv, detection_delay);
522
523
524
525
526
527
528 schedule_delayed_work(&priv->notify_hotplug_work,
529 msecs_to_jiffies(delay));
530 return 0;
531 }
532
533
534
535
536 static const struct of_device_id usbhs_of_match[] = {
537 {
538 .compatible = "renesas,usbhs-r8a774c0",
539 .data = &usbhs_rcar_gen3_with_pll_plat_info,
540 },
541 {
542 .compatible = "renesas,usbhs-r8a7790",
543 .data = &usbhs_rcar_gen2_plat_info,
544 },
545 {
546 .compatible = "renesas,usbhs-r8a7791",
547 .data = &usbhs_rcar_gen2_plat_info,
548 },
549 {
550 .compatible = "renesas,usbhs-r8a7794",
551 .data = &usbhs_rcar_gen2_plat_info,
552 },
553 {
554 .compatible = "renesas,usbhs-r8a7795",
555 .data = &usbhs_rcar_gen3_plat_info,
556 },
557 {
558 .compatible = "renesas,usbhs-r8a7796",
559 .data = &usbhs_rcar_gen3_plat_info,
560 },
561 {
562 .compatible = "renesas,usbhs-r8a77990",
563 .data = &usbhs_rcar_gen3_with_pll_plat_info,
564 },
565 {
566 .compatible = "renesas,usbhs-r8a77995",
567 .data = &usbhs_rcar_gen3_with_pll_plat_info,
568 },
569 {
570 .compatible = "renesas,rcar-gen2-usbhs",
571 .data = &usbhs_rcar_gen2_plat_info,
572 },
573 {
574 .compatible = "renesas,rcar-gen3-usbhs",
575 .data = &usbhs_rcar_gen3_plat_info,
576 },
577 {
578 .compatible = "renesas,rza1-usbhs",
579 .data = &usbhs_rza1_plat_info,
580 },
581 {
582 .compatible = "renesas,rza2-usbhs",
583 .data = &usbhs_rza2_plat_info,
584 },
585 { },
586 };
587 MODULE_DEVICE_TABLE(of, usbhs_of_match);
588
589 static int usbhs_probe(struct platform_device *pdev)
590 {
591 const struct renesas_usbhs_platform_info *info;
592 struct usbhs_priv *priv;
593 struct resource *res, *irq_res;
594 struct device *dev = &pdev->dev;
595 int ret, gpio;
596 u32 tmp;
597
598
599 if (dev_of_node(dev))
600 info = of_device_get_match_data(dev);
601 else
602 info = renesas_usbhs_get_info(pdev);
603
604
605 if (!info) {
606 dev_err(dev, "no platform information\n");
607 return -EINVAL;
608 }
609
610
611 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
612 if (!irq_res) {
613 dev_err(dev, "Not enough Renesas USB platform resources.\n");
614 return -ENODEV;
615 }
616
617
618 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
619 if (!priv)
620 return -ENOMEM;
621
622 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
623 priv->base = devm_ioremap_resource(&pdev->dev, res);
624 if (IS_ERR(priv->base))
625 return PTR_ERR(priv->base);
626
627 if (of_property_read_bool(dev_of_node(dev), "extcon")) {
628 priv->edev = extcon_get_edev_by_phandle(dev, 0);
629 if (IS_ERR(priv->edev))
630 return PTR_ERR(priv->edev);
631 }
632
633 priv->rsts = devm_reset_control_array_get_optional_shared(dev);
634 if (IS_ERR(priv->rsts))
635 return PTR_ERR(priv->rsts);
636
637
638
639
640
641 priv->dparam = info->driver_param;
642
643 if (!info->platform_callback.get_id) {
644 dev_err(dev, "no platform callbacks\n");
645 return -EINVAL;
646 }
647 priv->pfunc = &info->platform_callback;
648
649
650 if (usbhs_get_dparam(priv, has_new_pipe_configs)) {
651 priv->dparam.pipe_configs = usbhsc_new_pipe;
652 priv->dparam.pipe_size = ARRAY_SIZE(usbhsc_new_pipe);
653 } else if (!priv->dparam.pipe_configs) {
654 priv->dparam.pipe_configs = usbhsc_default_pipe;
655 priv->dparam.pipe_size = ARRAY_SIZE(usbhsc_default_pipe);
656 }
657 if (!priv->dparam.pio_dma_border)
658 priv->dparam.pio_dma_border = 64;
659 if (!of_property_read_u32(dev_of_node(dev), "renesas,buswait", &tmp))
660 priv->dparam.buswait_bwait = tmp;
661 gpio = of_get_named_gpio_flags(dev_of_node(dev), "renesas,enable-gpio",
662 0, NULL);
663 if (gpio > 0)
664 priv->dparam.enable_gpio = gpio;
665
666
667
668 if (priv->pfunc->get_vbus)
669 usbhs_get_dparam(priv, runtime_pwctrl) = 1;
670
671
672
673
674 priv->irq = irq_res->start;
675 if (irq_res->flags & IORESOURCE_IRQ_SHAREABLE)
676 priv->irqflags = IRQF_SHARED;
677 priv->pdev = pdev;
678 INIT_DELAYED_WORK(&priv->notify_hotplug_work, usbhsc_notify_hotplug);
679 spin_lock_init(usbhs_priv_to_lock(priv));
680
681
682 ret = usbhs_pipe_probe(priv);
683 if (ret < 0)
684 return ret;
685
686 ret = usbhs_fifo_probe(priv);
687 if (ret < 0)
688 goto probe_end_pipe_exit;
689
690 ret = usbhs_mod_probe(priv);
691 if (ret < 0)
692 goto probe_end_fifo_exit;
693
694
695 platform_set_drvdata(pdev, priv);
696
697 ret = reset_control_deassert(priv->rsts);
698 if (ret)
699 goto probe_fail_rst;
700
701 ret = usbhsc_clk_get(dev, priv);
702 if (ret)
703 goto probe_fail_clks;
704
705
706
707
708
709 usbhs_sys_clock_ctrl(priv, 0);
710
711
712 if (priv->dparam.enable_gpio) {
713 gpio_request_one(priv->dparam.enable_gpio, GPIOF_IN, NULL);
714 ret = !gpio_get_value(priv->dparam.enable_gpio);
715 gpio_free(priv->dparam.enable_gpio);
716 if (ret) {
717 dev_warn(dev, "USB function not selected (GPIO %d)\n",
718 priv->dparam.enable_gpio);
719 ret = -ENOTSUPP;
720 goto probe_end_mod_exit;
721 }
722 }
723
724
725
726
727
728
729
730
731 ret = usbhs_platform_call(priv, hardware_init, pdev);
732 if (ret < 0) {
733 dev_err(dev, "platform init failed.\n");
734 goto probe_end_mod_exit;
735 }
736
737
738 usbhs_platform_call(priv, phy_reset, pdev);
739
740
741 pm_runtime_enable(dev);
742 if (!usbhs_get_dparam(priv, runtime_pwctrl)) {
743 usbhsc_power_ctrl(priv, 1);
744 usbhs_mod_autonomy_mode(priv);
745 } else {
746 usbhs_mod_non_autonomy_mode(priv);
747 }
748
749
750
751
752 usbhsc_schedule_notify_hotplug(pdev);
753
754 dev_info(dev, "probed\n");
755
756 return ret;
757
758 probe_end_mod_exit:
759 usbhsc_clk_put(priv);
760 probe_fail_clks:
761 reset_control_assert(priv->rsts);
762 probe_fail_rst:
763 usbhs_mod_remove(priv);
764 probe_end_fifo_exit:
765 usbhs_fifo_remove(priv);
766 probe_end_pipe_exit:
767 usbhs_pipe_remove(priv);
768
769 dev_info(dev, "probe failed (%d)\n", ret);
770
771 return ret;
772 }
773
774 static int usbhs_remove(struct platform_device *pdev)
775 {
776 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
777
778 dev_dbg(&pdev->dev, "usb remove\n");
779
780
781 if (!usbhs_get_dparam(priv, runtime_pwctrl))
782 usbhsc_power_ctrl(priv, 0);
783
784 pm_runtime_disable(&pdev->dev);
785
786 usbhs_platform_call(priv, hardware_exit, pdev);
787 usbhsc_clk_put(priv);
788 reset_control_assert(priv->rsts);
789 usbhs_mod_remove(priv);
790 usbhs_fifo_remove(priv);
791 usbhs_pipe_remove(priv);
792
793 return 0;
794 }
795
796 static __maybe_unused int usbhsc_suspend(struct device *dev)
797 {
798 struct usbhs_priv *priv = dev_get_drvdata(dev);
799 struct usbhs_mod *mod = usbhs_mod_get_current(priv);
800
801 if (mod) {
802 usbhs_mod_call(priv, stop, priv);
803 usbhs_mod_change(priv, -1);
804 }
805
806 if (mod || !usbhs_get_dparam(priv, runtime_pwctrl))
807 usbhsc_power_ctrl(priv, 0);
808
809 return 0;
810 }
811
812 static __maybe_unused int usbhsc_resume(struct device *dev)
813 {
814 struct usbhs_priv *priv = dev_get_drvdata(dev);
815 struct platform_device *pdev = usbhs_priv_to_pdev(priv);
816
817 if (!usbhs_get_dparam(priv, runtime_pwctrl)) {
818 usbhsc_power_ctrl(priv, 1);
819 usbhs_mod_autonomy_mode(priv);
820 }
821
822 usbhs_platform_call(priv, phy_reset, pdev);
823
824 usbhsc_schedule_notify_hotplug(pdev);
825
826 return 0;
827 }
828
829 static SIMPLE_DEV_PM_OPS(usbhsc_pm_ops, usbhsc_suspend, usbhsc_resume);
830
831 static struct platform_driver renesas_usbhs_driver = {
832 .driver = {
833 .name = "renesas_usbhs",
834 .pm = &usbhsc_pm_ops,
835 .of_match_table = of_match_ptr(usbhs_of_match),
836 },
837 .probe = usbhs_probe,
838 .remove = usbhs_remove,
839 };
840
841 module_platform_driver(renesas_usbhs_driver);
842
843 MODULE_LICENSE("GPL");
844 MODULE_DESCRIPTION("Renesas USB driver");
845 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");