Lines Matching refs:priv
62 #define usbhs_platform_call(priv, func, args...)\
63 (!(priv) ? -ENODEV : \
64 !((priv)->pfunc.func) ? 0 : \
65 (priv)->pfunc.func(args))
70 u16 usbhs_read(struct usbhs_priv *priv, u32 reg)
72 return ioread16(priv->base + reg);
75 void usbhs_write(struct usbhs_priv *priv, u32 reg, u16 data)
77 iowrite16(data, priv->base + reg);
80 void usbhs_bset(struct usbhs_priv *priv, u32 reg, u16 mask, u16 data)
82 u16 val = usbhs_read(priv, reg);
87 usbhs_write(priv, reg, val);
98 static void usbhs_sys_clock_ctrl(struct usbhs_priv *priv, int enable)
100 usbhs_bset(priv, SYSCFG, SCKE, enable ? SCKE : 0);
103 void usbhs_sys_host_ctrl(struct usbhs_priv *priv, int enable)
107 int has_otg = usbhs_get_dparam(priv, has_otg);
110 usbhs_bset(priv, DVSTCTR, (EXTLP | PWEN), (EXTLP | PWEN));
118 usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
121 void usbhs_sys_function_ctrl(struct usbhs_priv *priv, int enable)
132 usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
135 void usbhs_sys_set_test_mode(struct usbhs_priv *priv, u16 mode)
137 usbhs_write(priv, TESTMODE, mode);
143 int usbhs_frame_get_num(struct usbhs_priv *priv)
145 return usbhs_read(priv, FRMNUM) & FRNM_MASK;
151 void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
155 val = usbhs_read(priv, USBREQ);
159 req->wValue = usbhs_read(priv, USBVAL);
160 req->wIndex = usbhs_read(priv, USBINDX);
161 req->wLength = usbhs_read(priv, USBLENG);
164 void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
166 usbhs_write(priv, USBREQ, (req->bRequest << 8) | req->bRequestType);
167 usbhs_write(priv, USBVAL, req->wValue);
168 usbhs_write(priv, USBINDX, req->wIndex);
169 usbhs_write(priv, USBLENG, req->wLength);
171 usbhs_bset(priv, DCPCTR, SUREQ, SUREQ);
177 void usbhs_bus_send_sof_enable(struct usbhs_priv *priv)
179 u16 status = usbhs_read(priv, DVSTCTR) & (USBRST | UACT);
182 struct device *dev = usbhs_priv_to_dev(priv);
186 usbhs_bset(priv, DVSTCTR, (USBRST | UACT), UACT);
189 void usbhs_bus_send_reset(struct usbhs_priv *priv)
191 usbhs_bset(priv, DVSTCTR, (USBRST | UACT), USBRST);
194 int usbhs_bus_get_speed(struct usbhs_priv *priv)
196 u16 dvstctr = usbhs_read(priv, DVSTCTR);
210 int usbhs_vbus_ctrl(struct usbhs_priv *priv, int enable)
212 struct platform_device *pdev = usbhs_priv_to_pdev(priv);
214 return usbhs_platform_call(priv, set_vbus, pdev, enable);
217 static void usbhsc_bus_init(struct usbhs_priv *priv)
219 usbhs_write(priv, DVSTCTR, 0);
221 usbhs_vbus_ctrl(priv, 0);
227 int usbhs_set_device_config(struct usbhs_priv *priv, int devnum,
230 struct device *dev = usbhs_priv_to_dev(priv);
259 usbhs_write(priv, reg, UPPHUB(upphub) |
269 static void usbhsc_set_buswait(struct usbhs_priv *priv)
271 int wait = usbhs_get_dparam(priv, buswait_bwait);
275 usbhs_bset(priv, BUSWAIT, 0x000F, wait);
297 static void usbhsc_power_ctrl(struct usbhs_priv *priv, int enable)
299 struct platform_device *pdev = usbhs_priv_to_pdev(priv);
300 struct device *dev = usbhs_priv_to_dev(priv);
307 usbhs_platform_call(priv, power_ctrl, pdev, priv->base, enable);
310 usbhs_sys_clock_ctrl(priv, enable);
313 usbhs_sys_clock_ctrl(priv, enable);
316 usbhs_platform_call(priv, power_ctrl, pdev, priv->base, enable);
326 static void usbhsc_hotplug(struct usbhs_priv *priv)
328 struct platform_device *pdev = usbhs_priv_to_pdev(priv);
329 struct usbhs_mod *mod = usbhs_mod_get_current(priv);
337 enable = usbhs_platform_call(priv, get_vbus, pdev);
342 id = usbhs_platform_call(priv, get_id, pdev);
345 ret = usbhs_mod_change(priv, id);
352 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
353 usbhsc_power_ctrl(priv, enable);
356 usbhsc_set_buswait(priv);
357 usbhsc_bus_init(priv);
360 usbhs_mod_call(priv, start, priv);
366 usbhs_mod_call(priv, stop, priv);
369 usbhsc_bus_init(priv);
372 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
373 usbhsc_power_ctrl(priv, enable);
375 usbhs_mod_change(priv, -1);
378 usbhs_platform_call(priv, phy_reset, pdev);
387 struct usbhs_priv *priv = container_of(work,
390 usbhsc_hotplug(priv);
395 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
396 int delay = usbhs_get_dparam(priv, detection_delay);
403 schedule_delayed_work(&priv->notify_hotplug_work,
415 struct usbhs_priv *priv;
435 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
436 if (!priv) {
437 dev_err(&pdev->dev, "Could not allocate priv\n");
441 priv->base = ioremap_nocache(res->start, resource_size(res));
442 if (!priv->base) {
451 memcpy(&priv->pfunc,
454 memcpy(&priv->dparam,
463 if (!priv->dparam.pipe_type) {
464 priv->dparam.pipe_type = usbhsc_default_pipe_type;
465 priv->dparam.pipe_size = ARRAY_SIZE(usbhsc_default_pipe_type);
467 if (!priv->dparam.pio_dma_border)
468 priv->dparam.pio_dma_border = 64; /* 64byte */
472 if (priv->pfunc.get_vbus)
473 usbhsc_flags_set(priv, USBHSF_RUNTIME_PWCTRL);
476 * priv settings
478 priv->irq = irq_res->start;
480 priv->irqflags = IRQF_SHARED;
481 priv->pdev = pdev;
482 INIT_DELAYED_WORK(&priv->notify_hotplug_work, usbhsc_notify_hotplug);
483 spin_lock_init(usbhs_priv_to_lock(priv));
486 ret = usbhs_pipe_probe(priv);
490 ret = usbhs_fifo_probe(priv);
494 ret = usbhs_mod_probe(priv);
499 dev_set_drvdata(&pdev->dev, priv);
505 usbhs_sys_clock_ctrl(priv, 0);
514 ret = usbhs_platform_call(priv, hardware_init, pdev);
521 usbhs_platform_call(priv, phy_reset, pdev);
525 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) {
526 usbhsc_power_ctrl(priv, 1);
527 usbhs_mod_autonomy_mode(priv);
542 usbhs_platform_call(priv, hardware_exit, pdev);
544 usbhs_mod_remove(priv);
546 usbhs_fifo_remove(priv);
548 usbhs_pipe_remove(priv);
550 iounmap(priv->base);
552 kfree(priv);
561 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
570 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
571 usbhsc_power_ctrl(priv, 0);
575 usbhs_platform_call(priv, hardware_exit, pdev);
576 usbhs_mod_remove(priv);
577 usbhs_fifo_remove(priv);
578 usbhs_pipe_remove(priv);
579 iounmap(priv->base);
580 kfree(priv);
587 struct usbhs_priv *priv = dev_get_drvdata(dev);
588 struct usbhs_mod *mod = usbhs_mod_get_current(priv);
591 usbhs_mod_call(priv, stop, priv);
592 usbhs_mod_change(priv, -1);
595 if (mod || !usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
596 usbhsc_power_ctrl(priv, 0);
603 struct usbhs_priv *priv = dev_get_drvdata(dev);
604 struct platform_device *pdev = usbhs_priv_to_pdev(priv);
606 usbhs_platform_call(priv, phy_reset, pdev);
608 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
609 usbhsc_power_ctrl(priv, 1);
611 usbhsc_hotplug(priv);