4 * Copyright (C) 2011 Renesas Solutions Corp.
5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
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.
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
18 #include <linux/module.h>
19 #include <linux/pm_runtime.h>
20 #include <linux/slab.h>
21 #include <linux/sysfs.h>
25 * image of renesas_usbhs
31 * mod_host.c pipe.c fifo.c
33 * +-------+ +-----------+
34 * | pipe0 |------>| fifo pio |
35 * +------------+ +-------+ +-----------+
36 * | mod_gadget |=====> | pipe1 |--+
37 * +------------+ +-------+ | +-----------+
38 * | pipe2 | | +-| fifo dma0 |
39 * +------------+ +-------+ | | +-----------+
40 * | mod_host | | pipe3 |<-|--+
41 * +------------+ +-------+ | +-----------+
42 * | .... | +--->| fifo dma1 |
43 * | .... | +-----------+
47 #define USBHSF_RUNTIME_PWCTRL (1 << 0)
50 #define usbhsc_flags_init(p) do {(p)->flags = 0; } while (0)
51 #define usbhsc_flags_set(p, b) ((p)->flags |= (b))
52 #define usbhsc_flags_clr(p, b) ((p)->flags &= ~(b))
53 #define usbhsc_flags_has(p, b) ((p)->flags & (b))
58 * renesas usb support platform callback function.
59 * Below macro call it.
60 * if platform doesn't have callback, it return 0 (no error)
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
);
90 struct usbhs_priv
*usbhs_pdev_to_priv(struct platform_device
*pdev
)
92 return dev_get_drvdata(&pdev
->dev
);
98 void usbhs_sys_clock_ctrl(struct usbhs_priv
*priv
, int enable
)
100 usbhs_bset(priv
, SYSCFG
, SCKE
, enable
? SCKE
: 0);
103 void usbhs_sys_hispeed_ctrl(struct usbhs_priv
*priv
, int enable
)
105 usbhs_bset(priv
, SYSCFG
, HSE
, enable
? HSE
: 0);
108 void usbhs_sys_usb_ctrl(struct usbhs_priv
*priv
, int enable
)
110 usbhs_bset(priv
, SYSCFG
, USBE
, enable
? USBE
: 0);
113 void usbhs_sys_host_ctrl(struct usbhs_priv
*priv
, int enable
)
115 u16 mask
= DCFM
| DRPD
| DPRPU
;
116 u16 val
= DCFM
| DRPD
;
122 * - D+ Line/D- Line Pull-down
124 usbhs_bset(priv
, SYSCFG
, mask
, enable
? val
: 0);
127 void usbhs_sys_function_ctrl(struct usbhs_priv
*priv
, int enable
)
129 u16 mask
= DCFM
| DRPD
| DPRPU
;
135 * - select Function mode
138 usbhs_bset(priv
, SYSCFG
, mask
, enable
? val
: 0);
144 int usbhs_frame_get_num(struct usbhs_priv
*priv
)
146 return usbhs_read(priv
, FRMNUM
) & FRNM_MASK
;
152 static void usbhsc_bus_ctrl(struct usbhs_priv
*priv
, int enable
)
154 int wait
= usbhs_get_dparam(priv
, buswait_bwait
);
158 /* set bus wait if platform have */
160 usbhs_bset(priv
, BUSWAIT
, 0x000F, wait
);
162 usbhs_write(priv
, DVSTCTR
, data
);
166 * platform default param
168 static u32 usbhsc_default_pipe_type
[] = {
169 USB_ENDPOINT_XFER_CONTROL
,
170 USB_ENDPOINT_XFER_ISOC
,
171 USB_ENDPOINT_XFER_ISOC
,
172 USB_ENDPOINT_XFER_BULK
,
173 USB_ENDPOINT_XFER_BULK
,
174 USB_ENDPOINT_XFER_BULK
,
175 USB_ENDPOINT_XFER_INT
,
176 USB_ENDPOINT_XFER_INT
,
177 USB_ENDPOINT_XFER_INT
,
178 USB_ENDPOINT_XFER_INT
,
184 static void usbhsc_power_ctrl(struct usbhs_priv
*priv
, int enable
)
186 struct device
*dev
= usbhs_priv_to_dev(priv
);
190 pm_runtime_get_sync(dev
);
193 usbhs_sys_clock_ctrl(priv
, enable
);
194 usbhsc_bus_ctrl(priv
, enable
);
197 usbhsc_bus_ctrl(priv
, enable
);
198 usbhs_sys_clock_ctrl(priv
, enable
);
201 pm_runtime_put_sync(dev
);
208 static void usbhsc_notify_hotplug(struct work_struct
*work
)
210 struct usbhs_priv
*priv
= container_of(work
,
212 notify_hotplug_work
.work
);
213 struct platform_device
*pdev
= usbhs_priv_to_pdev(priv
);
214 struct usbhs_mod
*mod
= usbhs_mod_get_current(priv
);
220 * get vbus status from platform
222 enable
= usbhs_platform_call(priv
, get_vbus
, pdev
);
225 * get id from platform
227 id
= usbhs_platform_call(priv
, get_id
, pdev
);
229 if (enable
&& !mod
) {
230 ret
= usbhs_mod_change(priv
, id
);
234 dev_dbg(&pdev
->dev
, "%s enable\n", __func__
);
237 if (usbhsc_flags_has(priv
, USBHSF_RUNTIME_PWCTRL
))
238 usbhsc_power_ctrl(priv
, enable
);
241 usbhs_mod_call(priv
, start
, priv
);
243 } else if (!enable
&& mod
) {
244 dev_dbg(&pdev
->dev
, "%s disable\n", __func__
);
247 usbhs_mod_call(priv
, stop
, priv
);
250 if (usbhsc_flags_has(priv
, USBHSF_RUNTIME_PWCTRL
))
251 usbhsc_power_ctrl(priv
, enable
);
253 usbhs_mod_change(priv
, -1);
255 /* reset phy for next connection */
256 usbhs_platform_call(priv
, phy_reset
, pdev
);
260 int usbhsc_drvcllbck_notify_hotplug(struct platform_device
*pdev
)
262 struct usbhs_priv
*priv
= usbhs_pdev_to_priv(pdev
);
263 int delay
= usbhs_get_dparam(priv
, detection_delay
);
266 * This functions will be called in interrupt.
267 * To make sure safety context,
268 * use workqueue for usbhs_notify_hotplug
270 schedule_delayed_work(&priv
->notify_hotplug_work
, delay
);
277 static int __devinit
usbhs_probe(struct platform_device
*pdev
)
279 struct renesas_usbhs_platform_info
*info
= pdev
->dev
.platform_data
;
280 struct renesas_usbhs_driver_callback
*dfunc
;
281 struct usbhs_priv
*priv
;
282 struct resource
*res
;
286 /* check platform information */
288 !info
->platform_callback
.get_id
) {
289 dev_err(&pdev
->dev
, "no platform information\n");
294 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
295 irq
= platform_get_irq(pdev
, 0);
296 if (!res
|| (int)irq
<= 0) {
297 dev_err(&pdev
->dev
, "Not enough Renesas USB platform resources.\n");
301 /* usb private data */
302 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
304 dev_err(&pdev
->dev
, "Could not allocate priv\n");
308 priv
->base
= ioremap_nocache(res
->start
, resource_size(res
));
310 dev_err(&pdev
->dev
, "ioremap error.\n");
312 goto probe_end_kfree
;
318 priv
->pfunc
= &info
->platform_callback
;
319 priv
->dparam
= &info
->driver_param
;
321 /* set driver callback functions for platform */
322 dfunc
= &info
->driver_callback
;
323 dfunc
->notify_hotplug
= usbhsc_drvcllbck_notify_hotplug
;
325 /* set default param if platform doesn't have */
326 if (!priv
->dparam
->pipe_type
) {
327 priv
->dparam
->pipe_type
= usbhsc_default_pipe_type
;
328 priv
->dparam
->pipe_size
= ARRAY_SIZE(usbhsc_default_pipe_type
);
330 if (!priv
->dparam
->pio_dma_border
)
331 priv
->dparam
->pio_dma_border
= 64; /* 64byte */
334 /* runtime power control ? */
335 if (priv
->pfunc
->get_vbus
)
336 usbhsc_flags_set(priv
, USBHSF_RUNTIME_PWCTRL
);
343 INIT_DELAYED_WORK(&priv
->notify_hotplug_work
, usbhsc_notify_hotplug
);
344 spin_lock_init(usbhs_priv_to_lock(priv
));
346 /* call pipe and module init */
347 ret
= usbhs_pipe_probe(priv
);
349 goto probe_end_iounmap
;
351 ret
= usbhs_fifo_probe(priv
);
353 goto probe_end_pipe_exit
;
355 ret
= usbhs_mod_probe(priv
);
357 goto probe_end_fifo_exit
;
359 /* dev_set_drvdata should be called after usbhs_mod_init */
360 dev_set_drvdata(&pdev
->dev
, priv
);
363 * deviece reset here because
364 * USB device might be used in boot loader.
366 usbhs_sys_clock_ctrl(priv
, 0);
371 * USB phy setup might depend on CPU/Board.
372 * If platform has its callback functions,
375 ret
= usbhs_platform_call(priv
, hardware_init
, pdev
);
377 dev_err(&pdev
->dev
, "platform prove failed.\n");
378 goto probe_end_mod_exit
;
381 /* reset phy for connection */
382 usbhs_platform_call(priv
, phy_reset
, pdev
);
385 pm_runtime_enable(&pdev
->dev
);
386 if (!usbhsc_flags_has(priv
, USBHSF_RUNTIME_PWCTRL
)) {
387 usbhsc_power_ctrl(priv
, 1);
388 usbhs_mod_autonomy_mode(priv
);
392 * manual call notify_hotplug for cold plug
394 ret
= usbhsc_drvcllbck_notify_hotplug(pdev
);
396 goto probe_end_call_remove
;
398 dev_info(&pdev
->dev
, "probed\n");
402 probe_end_call_remove
:
403 usbhs_platform_call(priv
, hardware_exit
, pdev
);
405 usbhs_mod_remove(priv
);
407 usbhs_fifo_remove(priv
);
409 usbhs_pipe_remove(priv
);
415 dev_info(&pdev
->dev
, "probe failed\n");
420 static int __devexit
usbhs_remove(struct platform_device
*pdev
)
422 struct usbhs_priv
*priv
= usbhs_pdev_to_priv(pdev
);
423 struct renesas_usbhs_platform_info
*info
= pdev
->dev
.platform_data
;
424 struct renesas_usbhs_driver_callback
*dfunc
= &info
->driver_callback
;
426 dev_dbg(&pdev
->dev
, "usb remove\n");
428 dfunc
->notify_hotplug
= NULL
;
431 if (!usbhsc_flags_has(priv
, USBHSF_RUNTIME_PWCTRL
))
432 usbhsc_power_ctrl(priv
, 0);
434 pm_runtime_disable(&pdev
->dev
);
436 usbhs_platform_call(priv
, hardware_exit
, pdev
);
437 usbhs_mod_remove(priv
);
438 usbhs_fifo_remove(priv
);
439 usbhs_pipe_remove(priv
);
446 static struct platform_driver renesas_usbhs_driver
= {
448 .name
= "renesas_usbhs",
450 .probe
= usbhs_probe
,
451 .remove
= __devexit_p(usbhs_remove
),
454 static int __init
usbhs_init(void)
456 return platform_driver_register(&renesas_usbhs_driver
);
459 static void __exit
usbhs_exit(void)
461 platform_driver_unregister(&renesas_usbhs_driver
);
464 module_init(usbhs_init
);
465 module_exit(usbhs_exit
);
467 MODULE_LICENSE("GPL");
468 MODULE_DESCRIPTION("Renesas USB driver");
469 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");