Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/usb/renesas_usbhs/common.c

  1 /*
  2  * Renesas USB driver
  3  *
  4  * Copyright (C) 2011 Renesas Solutions Corp.
  5  * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
  6  *
  7  * This program is distributed in the hope that it will be useful,
  8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 10  * GNU General Public License for more details.
 11  *
 12  * You should have received a copy of the GNU General Public License
 13  * along with this program; if not, write to the Free Software
 14  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 15  *
 16  */
 17 #include <linux/err.h>
 18 #include <linux/gpio.h>
 19 #include <linux/io.h>
 20 #include <linux/module.h>
 21 #include <linux/of_device.h>
 22 #include <linux/of_gpio.h>
 23 #include <linux/pm_runtime.h>
 24 #include <linux/slab.h>
 25 #include <linux/sysfs.h>
 26 #include "common.h"
 27 #include "rcar2.h"
 28 
 29 /*
 30  *              image of renesas_usbhs
 31  *
 32  * ex) gadget case
 33 
 34  * mod.c
 35  * mod_gadget.c
 36  * mod_host.c           pipe.c          fifo.c
 37  *
 38  *                      +-------+       +-----------+
 39  *                      | pipe0 |------>| fifo pio  |
 40  * +------------+       +-------+       +-----------+
 41  * | mod_gadget |=====> | pipe1 |--+
 42  * +------------+       +-------+  |    +-----------+
 43  *                      | pipe2 |  |  +-| fifo dma0 |
 44  * +------------+       +-------+  |  | +-----------+
 45  * | mod_host   |       | pipe3 |<-|--+
 46  * +------------+       +-------+  |    +-----------+
 47  *                      | ....  |  +--->| fifo dma1 |
 48  *                      | ....  |       +-----------+
 49  */
 50 
 51 
 52 #define USBHSF_RUNTIME_PWCTRL   (1 << 0)
 53 
 54 /* status */
 55 #define usbhsc_flags_init(p)   do {(p)->flags = 0; } while (0)
 56 #define usbhsc_flags_set(p, b) ((p)->flags |=  (b))
 57 #define usbhsc_flags_clr(p, b) ((p)->flags &= ~(b))
 58 #define usbhsc_flags_has(p, b) ((p)->flags &   (b))
 59 
 60 /*
 61  * platform call back
 62  *
 63  * renesas usb support platform callback function.
 64  * Below macro call it.
 65  * if platform doesn't have callback, it return 0 (no error)
 66  */
 67 #define usbhs_platform_call(priv, func, args...)\
 68         (!(priv) ? -ENODEV :                    \
 69          !((priv)->pfunc.func) ? 0 :            \
 70          (priv)->pfunc.func(args))
 71 
 72 /*
 73  *              common functions
 74  */
 75 u16 usbhs_read(struct usbhs_priv *priv, u32 reg)
 76 {
 77         return ioread16(priv->base + reg);
 78 }
 79 
 80 void usbhs_write(struct usbhs_priv *priv, u32 reg, u16 data)
 81 {
 82         iowrite16(data, priv->base + reg);
 83 }
 84 
 85 void usbhs_bset(struct usbhs_priv *priv, u32 reg, u16 mask, u16 data)
 86 {
 87         u16 val = usbhs_read(priv, reg);
 88 
 89         val &= ~mask;
 90         val |= data & mask;
 91 
 92         usbhs_write(priv, reg, val);
 93 }
 94 
 95 struct usbhs_priv *usbhs_pdev_to_priv(struct platform_device *pdev)
 96 {
 97         return dev_get_drvdata(&pdev->dev);
 98 }
 99 
100 /*
101  *              syscfg functions
102  */
103 static void usbhs_sys_clock_ctrl(struct usbhs_priv *priv, int enable)
104 {
105         usbhs_bset(priv, SYSCFG, SCKE, enable ? SCKE : 0);
106 }
107 
108 void usbhs_sys_host_ctrl(struct usbhs_priv *priv, int enable)
109 {
110         u16 mask = DCFM | DRPD | DPRPU | HSE | USBE;
111         u16 val  = DCFM | DRPD | HSE | USBE;
112         int has_otg = usbhs_get_dparam(priv, has_otg);
113 
114         if (has_otg)
115                 usbhs_bset(priv, DVSTCTR, (EXTLP | PWEN), (EXTLP | PWEN));
116 
117         /*
118          * if enable
119          *
120          * - select Host mode
121          * - D+ Line/D- Line Pull-down
122          */
123         usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
124 }
125 
126 void usbhs_sys_function_ctrl(struct usbhs_priv *priv, int enable)
127 {
128         u16 mask = DCFM | DRPD | DPRPU | HSE | USBE;
129         u16 val  = DPRPU | HSE | USBE;
130 
131         /*
132          * if enable
133          *
134          * - select Function mode
135          * - D+ Line Pull-up
136          */
137         usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
138 }
139 
140 void usbhs_sys_function_pullup(struct usbhs_priv *priv, int enable)
141 {
142         usbhs_bset(priv, SYSCFG, DPRPU, enable ? DPRPU : 0);
143 }
144 
145 void usbhs_sys_set_test_mode(struct usbhs_priv *priv, u16 mode)
146 {
147         usbhs_write(priv, TESTMODE, mode);
148 }
149 
150 /*
151  *              frame functions
152  */
153 int usbhs_frame_get_num(struct usbhs_priv *priv)
154 {
155         return usbhs_read(priv, FRMNUM) & FRNM_MASK;
156 }
157 
158 /*
159  *              usb request functions
160  */
161 void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
162 {
163         u16 val;
164 
165         val = usbhs_read(priv, USBREQ);
166         req->bRequest           = (val >> 8) & 0xFF;
167         req->bRequestType       = (val >> 0) & 0xFF;
168 
169         req->wValue     = usbhs_read(priv, USBVAL);
170         req->wIndex     = usbhs_read(priv, USBINDX);
171         req->wLength    = usbhs_read(priv, USBLENG);
172 }
173 
174 void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
175 {
176         usbhs_write(priv, USBREQ,  (req->bRequest << 8) | req->bRequestType);
177         usbhs_write(priv, USBVAL,  req->wValue);
178         usbhs_write(priv, USBINDX, req->wIndex);
179         usbhs_write(priv, USBLENG, req->wLength);
180 
181         usbhs_bset(priv, DCPCTR, SUREQ, SUREQ);
182 }
183 
184 /*
185  *              bus/vbus functions
186  */
187 void usbhs_bus_send_sof_enable(struct usbhs_priv *priv)
188 {
189         u16 status = usbhs_read(priv, DVSTCTR) & (USBRST | UACT);
190 
191         if (status != USBRST) {
192                 struct device *dev = usbhs_priv_to_dev(priv);
193                 dev_err(dev, "usbhs should be reset\n");
194         }
195 
196         usbhs_bset(priv, DVSTCTR, (USBRST | UACT), UACT);
197 }
198 
199 void usbhs_bus_send_reset(struct usbhs_priv *priv)
200 {
201         usbhs_bset(priv, DVSTCTR, (USBRST | UACT), USBRST);
202 }
203 
204 int usbhs_bus_get_speed(struct usbhs_priv *priv)
205 {
206         u16 dvstctr = usbhs_read(priv, DVSTCTR);
207 
208         switch (RHST & dvstctr) {
209         case RHST_LOW_SPEED:
210                 return USB_SPEED_LOW;
211         case RHST_FULL_SPEED:
212                 return USB_SPEED_FULL;
213         case RHST_HIGH_SPEED:
214                 return USB_SPEED_HIGH;
215         }
216 
217         return USB_SPEED_UNKNOWN;
218 }
219 
220 int usbhs_vbus_ctrl(struct usbhs_priv *priv, int enable)
221 {
222         struct platform_device *pdev = usbhs_priv_to_pdev(priv);
223 
224         return usbhs_platform_call(priv, set_vbus, pdev, enable);
225 }
226 
227 static void usbhsc_bus_init(struct usbhs_priv *priv)
228 {
229         usbhs_write(priv, DVSTCTR, 0);
230 
231         usbhs_vbus_ctrl(priv, 0);
232 }
233 
234 /*
235  *              device configuration
236  */
237 int usbhs_set_device_config(struct usbhs_priv *priv, int devnum,
238                            u16 upphub, u16 hubport, u16 speed)
239 {
240         struct device *dev = usbhs_priv_to_dev(priv);
241         u16 usbspd = 0;
242         u32 reg = DEVADD0 + (2 * devnum);
243 
244         if (devnum > 10) {
245                 dev_err(dev, "cannot set speed to unknown device %d\n", devnum);
246                 return -EIO;
247         }
248 
249         if (upphub > 0xA) {
250                 dev_err(dev, "unsupported hub number %d\n", upphub);
251                 return -EIO;
252         }
253 
254         switch (speed) {
255         case USB_SPEED_LOW:
256                 usbspd = USBSPD_SPEED_LOW;
257                 break;
258         case USB_SPEED_FULL:
259                 usbspd = USBSPD_SPEED_FULL;
260                 break;
261         case USB_SPEED_HIGH:
262                 usbspd = USBSPD_SPEED_HIGH;
263                 break;
264         default:
265                 dev_err(dev, "unsupported speed %d\n", speed);
266                 return -EIO;
267         }
268 
269         usbhs_write(priv, reg,  UPPHUB(upphub)  |
270                                 HUBPORT(hubport)|
271                                 USBSPD(usbspd));
272 
273         return 0;
274 }
275 
276 /*
277  *              local functions
278  */
279 static void usbhsc_set_buswait(struct usbhs_priv *priv)
280 {
281         int wait = usbhs_get_dparam(priv, buswait_bwait);
282 
283         /* set bus wait if platform have */
284         if (wait)
285                 usbhs_bset(priv, BUSWAIT, 0x000F, wait);
286 }
287 
288 /*
289  *              platform default param
290  */
291 
292 /* commonly used on old SH-Mobile SoCs */
293 static u32 usbhsc_default_pipe_type[] = {
294                 USB_ENDPOINT_XFER_CONTROL,
295                 USB_ENDPOINT_XFER_ISOC,
296                 USB_ENDPOINT_XFER_ISOC,
297                 USB_ENDPOINT_XFER_BULK,
298                 USB_ENDPOINT_XFER_BULK,
299                 USB_ENDPOINT_XFER_BULK,
300                 USB_ENDPOINT_XFER_INT,
301                 USB_ENDPOINT_XFER_INT,
302                 USB_ENDPOINT_XFER_INT,
303                 USB_ENDPOINT_XFER_INT,
304 };
305 
306 /* commonly used on newer SH-Mobile and R-Car SoCs */
307 static u32 usbhsc_new_pipe_type[] = {
308                 USB_ENDPOINT_XFER_CONTROL,
309                 USB_ENDPOINT_XFER_ISOC,
310                 USB_ENDPOINT_XFER_ISOC,
311                 USB_ENDPOINT_XFER_BULK,
312                 USB_ENDPOINT_XFER_BULK,
313                 USB_ENDPOINT_XFER_BULK,
314                 USB_ENDPOINT_XFER_INT,
315                 USB_ENDPOINT_XFER_INT,
316                 USB_ENDPOINT_XFER_INT,
317                 USB_ENDPOINT_XFER_BULK,
318                 USB_ENDPOINT_XFER_BULK,
319                 USB_ENDPOINT_XFER_BULK,
320                 USB_ENDPOINT_XFER_BULK,
321                 USB_ENDPOINT_XFER_BULK,
322                 USB_ENDPOINT_XFER_BULK,
323                 USB_ENDPOINT_XFER_BULK,
324 };
325 
326 /*
327  *              power control
328  */
329 static void usbhsc_power_ctrl(struct usbhs_priv *priv, int enable)
330 {
331         struct platform_device *pdev = usbhs_priv_to_pdev(priv);
332         struct device *dev = usbhs_priv_to_dev(priv);
333 
334         if (enable) {
335                 /* enable PM */
336                 pm_runtime_get_sync(dev);
337 
338                 /* enable platform power */
339                 usbhs_platform_call(priv, power_ctrl, pdev, priv->base, enable);
340 
341                 /* USB on */
342                 usbhs_sys_clock_ctrl(priv, enable);
343         } else {
344                 /* USB off */
345                 usbhs_sys_clock_ctrl(priv, enable);
346 
347                 /* disable platform power */
348                 usbhs_platform_call(priv, power_ctrl, pdev, priv->base, enable);
349 
350                 /* disable PM */
351                 pm_runtime_put_sync(dev);
352         }
353 }
354 
355 /*
356  *              hotplug
357  */
358 static void usbhsc_hotplug(struct usbhs_priv *priv)
359 {
360         struct platform_device *pdev = usbhs_priv_to_pdev(priv);
361         struct usbhs_mod *mod = usbhs_mod_get_current(priv);
362         int id;
363         int enable;
364         int ret;
365 
366         /*
367          * get vbus status from platform
368          */
369         enable = usbhs_platform_call(priv, get_vbus, pdev);
370 
371         /*
372          * get id from platform
373          */
374         id = usbhs_platform_call(priv, get_id, pdev);
375 
376         if (enable && !mod) {
377                 ret = usbhs_mod_change(priv, id);
378                 if (ret < 0)
379                         return;
380 
381                 dev_dbg(&pdev->dev, "%s enable\n", __func__);
382 
383                 /* power on */
384                 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
385                         usbhsc_power_ctrl(priv, enable);
386 
387                 /* bus init */
388                 usbhsc_set_buswait(priv);
389                 usbhsc_bus_init(priv);
390 
391                 /* module start */
392                 usbhs_mod_call(priv, start, priv);
393 
394         } else if (!enable && mod) {
395                 dev_dbg(&pdev->dev, "%s disable\n", __func__);
396 
397                 /* module stop */
398                 usbhs_mod_call(priv, stop, priv);
399 
400                 /* bus init */
401                 usbhsc_bus_init(priv);
402 
403                 /* power off */
404                 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
405                         usbhsc_power_ctrl(priv, enable);
406 
407                 usbhs_mod_change(priv, -1);
408 
409                 /* reset phy for next connection */
410                 usbhs_platform_call(priv, phy_reset, pdev);
411         }
412 }
413 
414 /*
415  *              notify hotplug
416  */
417 static void usbhsc_notify_hotplug(struct work_struct *work)
418 {
419         struct usbhs_priv *priv = container_of(work,
420                                                struct usbhs_priv,
421                                                notify_hotplug_work.work);
422         usbhsc_hotplug(priv);
423 }
424 
425 static int usbhsc_drvcllbck_notify_hotplug(struct platform_device *pdev)
426 {
427         struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
428         int delay = usbhs_get_dparam(priv, detection_delay);
429 
430         /*
431          * This functions will be called in interrupt.
432          * To make sure safety context,
433          * use workqueue for usbhs_notify_hotplug
434          */
435         schedule_delayed_work(&priv->notify_hotplug_work,
436                               msecs_to_jiffies(delay));
437         return 0;
438 }
439 
440 /*
441  *              platform functions
442  */
443 static const struct of_device_id usbhs_of_match[] = {
444         {
445                 .compatible = "renesas,usbhs-r8a7790",
446                 .data = (void *)USBHS_TYPE_R8A7790,
447         },
448         {
449                 .compatible = "renesas,usbhs-r8a7791",
450                 .data = (void *)USBHS_TYPE_R8A7791,
451         },
452         { },
453 };
454 MODULE_DEVICE_TABLE(of, usbhs_of_match);
455 
456 static struct renesas_usbhs_platform_info *usbhs_parse_dt(struct device *dev)
457 {
458         struct renesas_usbhs_platform_info *info;
459         struct renesas_usbhs_driver_param *dparam;
460         const struct of_device_id *of_id = of_match_device(usbhs_of_match, dev);
461         u32 tmp;
462         int gpio;
463 
464         info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
465         if (!info)
466                 return NULL;
467 
468         dparam = &info->driver_param;
469         dparam->type = of_id ? (u32)of_id->data : 0;
470         if (!of_property_read_u32(dev->of_node, "renesas,buswait", &tmp))
471                 dparam->buswait_bwait = tmp;
472         gpio = of_get_named_gpio_flags(dev->of_node, "renesas,enable-gpio", 0,
473                                        NULL);
474         if (gpio > 0)
475                 dparam->enable_gpio = gpio;
476 
477         return info;
478 }
479 
480 static int usbhs_probe(struct platform_device *pdev)
481 {
482         struct renesas_usbhs_platform_info *info = dev_get_platdata(&pdev->dev);
483         struct renesas_usbhs_driver_callback *dfunc;
484         struct usbhs_priv *priv;
485         struct resource *res, *irq_res;
486         int ret;
487 
488         /* check device node */
489         if (pdev->dev.of_node)
490                 info = pdev->dev.platform_data = usbhs_parse_dt(&pdev->dev);
491 
492         /* check platform information */
493         if (!info) {
494                 dev_err(&pdev->dev, "no platform information\n");
495                 return -EINVAL;
496         }
497 
498         /* platform data */
499         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
500         irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
501         if (!res || !irq_res) {
502                 dev_err(&pdev->dev, "Not enough Renesas USB platform resources.\n");
503                 return -ENODEV;
504         }
505 
506         /* usb private data */
507         priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
508         if (!priv) {
509                 dev_err(&pdev->dev, "Could not allocate priv\n");
510                 return -ENOMEM;
511         }
512 
513         priv->base = devm_ioremap_resource(&pdev->dev, res);
514         if (IS_ERR(priv->base))
515                 return PTR_ERR(priv->base);
516 
517         /*
518          * care platform info
519          */
520 
521         memcpy(&priv->dparam,
522                &info->driver_param,
523                sizeof(struct renesas_usbhs_driver_param));
524 
525         switch (priv->dparam.type) {
526         case USBHS_TYPE_R8A7790:
527         case USBHS_TYPE_R8A7791:
528                 priv->pfunc = usbhs_rcar2_ops;
529                 if (!priv->dparam.pipe_type) {
530                         priv->dparam.pipe_type = usbhsc_new_pipe_type;
531                         priv->dparam.pipe_size =
532                                 ARRAY_SIZE(usbhsc_new_pipe_type);
533                 }
534                 break;
535         default:
536                 if (!info->platform_callback.get_id) {
537                         dev_err(&pdev->dev, "no platform callbacks");
538                         return -EINVAL;
539                 }
540                 memcpy(&priv->pfunc,
541                        &info->platform_callback,
542                        sizeof(struct renesas_usbhs_platform_callback));
543                 break;
544         }
545 
546         /* set driver callback functions for platform */
547         dfunc                   = &info->driver_callback;
548         dfunc->notify_hotplug   = usbhsc_drvcllbck_notify_hotplug;
549 
550         /* set default param if platform doesn't have */
551         if (!priv->dparam.pipe_type) {
552                 priv->dparam.pipe_type = usbhsc_default_pipe_type;
553                 priv->dparam.pipe_size = ARRAY_SIZE(usbhsc_default_pipe_type);
554         }
555         if (!priv->dparam.pio_dma_border)
556                 priv->dparam.pio_dma_border = 64; /* 64byte */
557 
558         /* FIXME */
559         /* runtime power control ? */
560         if (priv->pfunc.get_vbus)
561                 usbhsc_flags_set(priv, USBHSF_RUNTIME_PWCTRL);
562 
563         /*
564          * priv settings
565          */
566         priv->irq       = irq_res->start;
567         if (irq_res->flags & IORESOURCE_IRQ_SHAREABLE)
568                 priv->irqflags = IRQF_SHARED;
569         priv->pdev      = pdev;
570         INIT_DELAYED_WORK(&priv->notify_hotplug_work, usbhsc_notify_hotplug);
571         spin_lock_init(usbhs_priv_to_lock(priv));
572 
573         /* call pipe and module init */
574         ret = usbhs_pipe_probe(priv);
575         if (ret < 0)
576                 return ret;
577 
578         ret = usbhs_fifo_probe(priv);
579         if (ret < 0)
580                 goto probe_end_pipe_exit;
581 
582         ret = usbhs_mod_probe(priv);
583         if (ret < 0)
584                 goto probe_end_fifo_exit;
585 
586         /* dev_set_drvdata should be called after usbhs_mod_init */
587         platform_set_drvdata(pdev, priv);
588 
589         /*
590          * deviece reset here because
591          * USB device might be used in boot loader.
592          */
593         usbhs_sys_clock_ctrl(priv, 0);
594 
595         /* check GPIO determining if USB function should be enabled */
596         if (priv->dparam.enable_gpio) {
597                 gpio_request_one(priv->dparam.enable_gpio, GPIOF_IN, NULL);
598                 ret = !gpio_get_value(priv->dparam.enable_gpio);
599                 gpio_free(priv->dparam.enable_gpio);
600                 if (ret) {
601                         dev_warn(&pdev->dev,
602                                  "USB function not selected (GPIO %d)\n",
603                                  priv->dparam.enable_gpio);
604                         ret = -ENOTSUPP;
605                         goto probe_end_mod_exit;
606                 }
607         }
608 
609         /*
610          * platform call
611          *
612          * USB phy setup might depend on CPU/Board.
613          * If platform has its callback functions,
614          * call it here.
615          */
616         ret = usbhs_platform_call(priv, hardware_init, pdev);
617         if (ret < 0) {
618                 dev_err(&pdev->dev, "platform prove failed.\n");
619                 goto probe_end_mod_exit;
620         }
621 
622         /* reset phy for connection */
623         usbhs_platform_call(priv, phy_reset, pdev);
624 
625         /* power control */
626         pm_runtime_enable(&pdev->dev);
627         if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) {
628                 usbhsc_power_ctrl(priv, 1);
629                 usbhs_mod_autonomy_mode(priv);
630         }
631 
632         /*
633          * manual call notify_hotplug for cold plug
634          */
635         ret = usbhsc_drvcllbck_notify_hotplug(pdev);
636         if (ret < 0)
637                 goto probe_end_call_remove;
638 
639         dev_info(&pdev->dev, "probed\n");
640 
641         return ret;
642 
643 probe_end_call_remove:
644         usbhs_platform_call(priv, hardware_exit, pdev);
645 probe_end_mod_exit:
646         usbhs_mod_remove(priv);
647 probe_end_fifo_exit:
648         usbhs_fifo_remove(priv);
649 probe_end_pipe_exit:
650         usbhs_pipe_remove(priv);
651 
652         dev_info(&pdev->dev, "probe failed\n");
653 
654         return ret;
655 }
656 
657 static int usbhs_remove(struct platform_device *pdev)
658 {
659         struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
660         struct renesas_usbhs_platform_info *info = dev_get_platdata(&pdev->dev);
661         struct renesas_usbhs_driver_callback *dfunc = &info->driver_callback;
662 
663         dev_dbg(&pdev->dev, "usb remove\n");
664 
665         dfunc->notify_hotplug = NULL;
666 
667         /* power off */
668         if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
669                 usbhsc_power_ctrl(priv, 0);
670 
671         pm_runtime_disable(&pdev->dev);
672 
673         usbhs_platform_call(priv, hardware_exit, pdev);
674         usbhs_mod_remove(priv);
675         usbhs_fifo_remove(priv);
676         usbhs_pipe_remove(priv);
677 
678         return 0;
679 }
680 
681 static int usbhsc_suspend(struct device *dev)
682 {
683         struct usbhs_priv *priv = dev_get_drvdata(dev);
684         struct usbhs_mod *mod = usbhs_mod_get_current(priv);
685 
686         if (mod) {
687                 usbhs_mod_call(priv, stop, priv);
688                 usbhs_mod_change(priv, -1);
689         }
690 
691         if (mod || !usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
692                 usbhsc_power_ctrl(priv, 0);
693 
694         return 0;
695 }
696 
697 static int usbhsc_resume(struct device *dev)
698 {
699         struct usbhs_priv *priv = dev_get_drvdata(dev);
700         struct platform_device *pdev = usbhs_priv_to_pdev(priv);
701 
702         if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
703                 usbhsc_power_ctrl(priv, 1);
704 
705         usbhs_platform_call(priv, phy_reset, pdev);
706 
707         usbhsc_drvcllbck_notify_hotplug(pdev);
708 
709         return 0;
710 }
711 
712 static int usbhsc_runtime_nop(struct device *dev)
713 {
714         /* Runtime PM callback shared between ->runtime_suspend()
715          * and ->runtime_resume(). Simply returns success.
716          *
717          * This driver re-initializes all registers after
718          * pm_runtime_get_sync() anyway so there is no need
719          * to save and restore registers here.
720          */
721         return 0;
722 }
723 
724 static const struct dev_pm_ops usbhsc_pm_ops = {
725         .suspend                = usbhsc_suspend,
726         .resume                 = usbhsc_resume,
727         .runtime_suspend        = usbhsc_runtime_nop,
728         .runtime_resume         = usbhsc_runtime_nop,
729 };
730 
731 static struct platform_driver renesas_usbhs_driver = {
732         .driver         = {
733                 .name   = "renesas_usbhs",
734                 .pm     = &usbhsc_pm_ops,
735                 .of_match_table = of_match_ptr(usbhs_of_match),
736         },
737         .probe          = usbhs_probe,
738         .remove         = usbhs_remove,
739 };
740 
741 module_platform_driver(renesas_usbhs_driver);
742 
743 MODULE_LICENSE("GPL");
744 MODULE_DESCRIPTION("Renesas USB driver");
745 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
746 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us