2 * core.c - ChipIdea USB IP core family device controller
4 * Copyright (C) 2008 Chipidea - MIPS Technologies, Inc. All rights reserved.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
14 * Description: ChipIdea USB IP core family device controller
16 * This driver is composed of several blocks:
17 * - HW: hardware interface
18 * - DBG: debug facilities (optional)
20 * - ISR: interrupts handling
21 * - ENDPT: endpoint operations (Gadget API)
22 * - GADGET: gadget operations (Gadget API)
23 * - BUS: bus glue code, bus abstraction layer
26 * - CONFIG_USB_GADGET_DEBUG_FILES: enable debug facilities
27 * - STALL_IN: non-empty bulk-in pipes cannot be halted
28 * if defined mass storage compliance succeeds but with warnings
32 * if undefined usbtest 13 fails
33 * - TRACE: enable function tracing (depends on DEBUG)
36 * - Chapter 9 & Mass Storage Compliance with Gadget File Storage
37 * - Chapter 9 Compliance with Gadget Zero (STALL_IN undefined)
38 * - Normal & LPM support
41 * - OK: 0-12, 13 (STALL_IN defined) & 14
42 * - Not Supported: 15 & 16 (ISO)
46 * - Isochronous & Interrupt Traffic
47 * - Handle requests which spawns into several TDs
48 * - GET_STATUS(device) - always reports 0
49 * - Gadget API (majority of optional features)
50 * - Suspend & Remote Wakeup
52 #include <linux/delay.h>
53 #include <linux/device.h>
54 #include <linux/dma-mapping.h>
55 #include <linux/platform_device.h>
56 #include <linux/module.h>
57 #include <linux/idr.h>
58 #include <linux/interrupt.h>
60 #include <linux/kernel.h>
61 #include <linux/slab.h>
62 #include <linux/pm_runtime.h>
63 #include <linux/usb/ch9.h>
64 #include <linux/usb/gadget.h>
65 #include <linux/usb/otg.h>
66 #include <linux/usb/chipidea.h>
74 /* Controller register map */
75 static uintptr_t ci_regs_nolpm
[] = {
76 [CAP_CAPLENGTH
] = 0x000UL
,
77 [CAP_HCCPARAMS
] = 0x008UL
,
78 [CAP_DCCPARAMS
] = 0x024UL
,
79 [CAP_TESTMODE
] = 0x038UL
,
80 [OP_USBCMD
] = 0x000UL
,
81 [OP_USBSTS
] = 0x004UL
,
82 [OP_USBINTR
] = 0x008UL
,
83 [OP_DEVICEADDR
] = 0x014UL
,
84 [OP_ENDPTLISTADDR
] = 0x018UL
,
85 [OP_PORTSC
] = 0x044UL
,
88 [OP_USBMODE
] = 0x068UL
,
89 [OP_ENDPTSETUPSTAT
] = 0x06CUL
,
90 [OP_ENDPTPRIME
] = 0x070UL
,
91 [OP_ENDPTFLUSH
] = 0x074UL
,
92 [OP_ENDPTSTAT
] = 0x078UL
,
93 [OP_ENDPTCOMPLETE
] = 0x07CUL
,
94 [OP_ENDPTCTRL
] = 0x080UL
,
97 static uintptr_t ci_regs_lpm
[] = {
98 [CAP_CAPLENGTH
] = 0x000UL
,
99 [CAP_HCCPARAMS
] = 0x008UL
,
100 [CAP_DCCPARAMS
] = 0x024UL
,
101 [CAP_TESTMODE
] = 0x0FCUL
,
102 [OP_USBCMD
] = 0x000UL
,
103 [OP_USBSTS
] = 0x004UL
,
104 [OP_USBINTR
] = 0x008UL
,
105 [OP_DEVICEADDR
] = 0x014UL
,
106 [OP_ENDPTLISTADDR
] = 0x018UL
,
107 [OP_PORTSC
] = 0x044UL
,
108 [OP_DEVLC
] = 0x084UL
,
109 [OP_OTGSC
] = 0x0C4UL
,
110 [OP_USBMODE
] = 0x0C8UL
,
111 [OP_ENDPTSETUPSTAT
] = 0x0D8UL
,
112 [OP_ENDPTPRIME
] = 0x0DCUL
,
113 [OP_ENDPTFLUSH
] = 0x0E0UL
,
114 [OP_ENDPTSTAT
] = 0x0E4UL
,
115 [OP_ENDPTCOMPLETE
] = 0x0E8UL
,
116 [OP_ENDPTCTRL
] = 0x0ECUL
,
119 static int hw_alloc_regmap(struct ci13xxx
*ci
, bool is_lpm
)
123 kfree(ci
->hw_bank
.regmap
);
125 ci
->hw_bank
.regmap
= kzalloc((OP_LAST
+ 1) * sizeof(void *),
127 if (!ci
->hw_bank
.regmap
)
130 for (i
= 0; i
< OP_ENDPTCTRL
; i
++)
131 ci
->hw_bank
.regmap
[i
] =
132 (i
<= CAP_LAST
? ci
->hw_bank
.cap
: ci
->hw_bank
.op
) +
133 (is_lpm
? ci_regs_lpm
[i
] : ci_regs_nolpm
[i
]);
135 for (; i
<= OP_LAST
; i
++)
136 ci
->hw_bank
.regmap
[i
] = ci
->hw_bank
.op
+
137 4 * (i
- OP_ENDPTCTRL
) +
139 ? ci_regs_lpm
[OP_ENDPTCTRL
]
140 : ci_regs_nolpm
[OP_ENDPTCTRL
]);
146 * hw_port_test_set: writes port test mode (execute without interruption)
149 * This function returns an error code
151 int hw_port_test_set(struct ci13xxx
*ci
, u8 mode
)
153 const u8 TEST_MODE_MAX
= 7;
155 if (mode
> TEST_MODE_MAX
)
158 hw_write(ci
, OP_PORTSC
, PORTSC_PTC
, mode
<< __ffs(PORTSC_PTC
));
163 * hw_port_test_get: reads port test mode value
165 * This function returns port test mode value
167 u8
hw_port_test_get(struct ci13xxx
*ci
)
169 return hw_read(ci
, OP_PORTSC
, PORTSC_PTC
) >> __ffs(PORTSC_PTC
);
172 static int hw_device_init(struct ci13xxx
*ci
, void __iomem
*base
)
176 /* bank is a module variable */
177 ci
->hw_bank
.abs
= base
;
179 ci
->hw_bank
.cap
= ci
->hw_bank
.abs
;
180 ci
->hw_bank
.cap
+= ci
->platdata
->capoffset
;
181 ci
->hw_bank
.op
= ci
->hw_bank
.cap
+ (ioread32(ci
->hw_bank
.cap
) & 0xff);
183 hw_alloc_regmap(ci
, false);
184 reg
= hw_read(ci
, CAP_HCCPARAMS
, HCCPARAMS_LEN
) >>
185 __ffs(HCCPARAMS_LEN
);
186 ci
->hw_bank
.lpm
= reg
;
187 hw_alloc_regmap(ci
, !!reg
);
188 ci
->hw_bank
.size
= ci
->hw_bank
.op
- ci
->hw_bank
.abs
;
189 ci
->hw_bank
.size
+= OP_LAST
;
190 ci
->hw_bank
.size
/= sizeof(u32
);
192 reg
= hw_read(ci
, CAP_DCCPARAMS
, DCCPARAMS_DEN
) >>
193 __ffs(DCCPARAMS_DEN
);
194 ci
->hw_ep_max
= reg
* 2; /* cache hw ENDPT_MAX */
196 if (ci
->hw_ep_max
> ENDPT_MAX
)
199 dev_dbg(ci
->dev
, "ChipIdea HDRC found, lpm: %d; cap: %p op: %p\n",
200 ci
->hw_bank
.lpm
, ci
->hw_bank
.cap
, ci
->hw_bank
.op
);
202 /* setup lock mode ? */
204 /* ENDPTSETUPSTAT is '0' by default */
206 /* HCSPARAMS.bf.ppc SHOULD BE zero for device */
212 * hw_device_reset: resets chip (execute without interruption)
213 * @ci: the controller
215 * This function returns an error code
217 int hw_device_reset(struct ci13xxx
*ci
, u32 mode
)
219 /* should flush & stop before reset */
220 hw_write(ci
, OP_ENDPTFLUSH
, ~0, ~0);
221 hw_write(ci
, OP_USBCMD
, USBCMD_RS
, 0);
223 hw_write(ci
, OP_USBCMD
, USBCMD_RST
, USBCMD_RST
);
224 while (hw_read(ci
, OP_USBCMD
, USBCMD_RST
))
225 udelay(10); /* not RTOS friendly */
228 if (ci
->platdata
->notify_event
)
229 ci
->platdata
->notify_event(ci
,
230 CI13XXX_CONTROLLER_RESET_EVENT
);
232 if (ci
->platdata
->flags
& CI13XXX_DISABLE_STREAMING
)
233 hw_write(ci
, OP_USBMODE
, USBMODE_CI_SDIS
, USBMODE_CI_SDIS
);
235 /* USBMODE should be configured step by step */
236 hw_write(ci
, OP_USBMODE
, USBMODE_CM
, USBMODE_CM_IDLE
);
237 hw_write(ci
, OP_USBMODE
, USBMODE_CM
, mode
);
239 hw_write(ci
, OP_USBMODE
, USBMODE_SLOM
, USBMODE_SLOM
);
241 if (hw_read(ci
, OP_USBMODE
, USBMODE_CM
) != mode
) {
242 pr_err("cannot enter in %s mode", ci_role(ci
)->name
);
243 pr_err("lpm = %i", ci
->hw_bank
.lpm
);
251 * ci_otg_role - pick role based on ID pin state
252 * @ci: the controller
254 static enum ci_role
ci_otg_role(struct ci13xxx
*ci
)
256 u32 sts
= hw_read(ci
, OP_OTGSC
, ~0);
257 enum ci_role role
= sts
& OTGSC_ID
265 * ci_role_work - perform role changing based on ID pin
268 static void ci_role_work(struct work_struct
*work
)
270 struct ci13xxx
*ci
= container_of(work
, struct ci13xxx
, work
);
271 enum ci_role role
= ci_otg_role(ci
);
273 if (role
!= ci
->role
) {
274 dev_dbg(ci
->dev
, "switching from %s to %s\n",
275 ci_role(ci
)->name
, ci
->roles
[role
]->name
);
278 ci_role_start(ci
, role
);
283 static irqreturn_t
ci_irq(int irq
, void *data
)
285 struct ci13xxx
*ci
= data
;
286 irqreturn_t ret
= IRQ_NONE
;
290 otgsc
= hw_read(ci
, OP_OTGSC
, ~0);
292 if (ci
->role
!= CI_ROLE_END
)
293 ret
= ci_role(ci
)->irq(ci
);
295 if (ci
->is_otg
&& (otgsc
& OTGSC_IDIS
)) {
296 hw_write(ci
, OP_OTGSC
, OTGSC_IDIS
, OTGSC_IDIS
);
297 disable_irq_nosync(ci
->irq
);
298 queue_work(ci
->wq
, &ci
->work
);
305 static DEFINE_IDA(ci_ida
);
307 struct platform_device
*ci13xxx_add_device(struct device
*dev
,
308 struct resource
*res
, int nres
,
309 struct ci13xxx_platform_data
*platdata
)
311 struct platform_device
*pdev
;
314 id
= ida_simple_get(&ci_ida
, 0, 0, GFP_KERNEL
);
318 pdev
= platform_device_alloc("ci_hdrc", id
);
324 pdev
->dev
.parent
= dev
;
325 pdev
->dev
.dma_mask
= dev
->dma_mask
;
326 pdev
->dev
.dma_parms
= dev
->dma_parms
;
327 dma_set_coherent_mask(&pdev
->dev
, dev
->coherent_dma_mask
);
329 ret
= platform_device_add_resources(pdev
, res
, nres
);
333 ret
= platform_device_add_data(pdev
, platdata
, sizeof(*platdata
));
337 ret
= platform_device_add(pdev
);
344 platform_device_put(pdev
);
346 ida_simple_remove(&ci_ida
, id
);
349 EXPORT_SYMBOL_GPL(ci13xxx_add_device
);
351 void ci13xxx_remove_device(struct platform_device
*pdev
)
354 platform_device_unregister(pdev
);
355 ida_simple_remove(&ci_ida
, id
);
357 EXPORT_SYMBOL_GPL(ci13xxx_remove_device
);
359 static int ci_hdrc_probe(struct platform_device
*pdev
)
361 struct device
*dev
= &pdev
->dev
;
363 struct resource
*res
;
367 if (!dev
->platform_data
) {
368 dev_err(dev
, "platform data missing\n");
372 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
374 dev_err(dev
, "missing resource\n");
378 base
= devm_ioremap_resource(dev
, res
);
380 return PTR_ERR(base
);
382 ci
= devm_kzalloc(dev
, sizeof(*ci
), GFP_KERNEL
);
384 dev_err(dev
, "can't allocate device\n");
389 ci
->platdata
= dev
->platform_data
;
390 if (ci
->platdata
->phy
)
391 ci
->transceiver
= ci
->platdata
->phy
;
393 ci
->global_phy
= true;
395 ret
= hw_device_init(ci
, base
);
397 dev_err(dev
, "can't initialize hardware\n");
401 ci
->hw_bank
.phys
= res
->start
;
403 ci
->irq
= platform_get_irq(pdev
, 0);
405 dev_err(dev
, "missing IRQ\n");
409 INIT_WORK(&ci
->work
, ci_role_work
);
410 ci
->wq
= create_singlethread_workqueue("ci_otg");
412 dev_err(dev
, "can't create workqueue\n");
416 /* initialize role(s) before the interrupt is requested */
417 ret
= ci_hdrc_host_init(ci
);
419 dev_info(dev
, "doesn't support host\n");
421 ret
= ci_hdrc_gadget_init(ci
);
423 dev_info(dev
, "doesn't support gadget\n");
425 if (!ci
->roles
[CI_ROLE_HOST
] && !ci
->roles
[CI_ROLE_GADGET
]) {
426 dev_err(dev
, "no supported roles\n");
431 if (ci
->roles
[CI_ROLE_HOST
] && ci
->roles
[CI_ROLE_GADGET
]) {
433 /* ID pin needs 1ms debouce time, we delay 2ms for safe */
435 ci
->role
= ci_otg_role(ci
);
437 ci
->role
= ci
->roles
[CI_ROLE_HOST
]
442 ret
= ci_role_start(ci
, ci
->role
);
444 dev_err(dev
, "can't start %s role\n", ci_role(ci
)->name
);
449 platform_set_drvdata(pdev
, ci
);
450 ret
= request_irq(ci
->irq
, ci_irq
, IRQF_SHARED
, ci
->platdata
->name
,
456 hw_write(ci
, OP_OTGSC
, OTGSC_IDIE
, OTGSC_IDIE
);
458 ret
= dbg_create_files(ci
);
462 free_irq(ci
->irq
, ci
);
466 flush_workqueue(ci
->wq
);
467 destroy_workqueue(ci
->wq
);
472 static int ci_hdrc_remove(struct platform_device
*pdev
)
474 struct ci13xxx
*ci
= platform_get_drvdata(pdev
);
476 dbg_remove_files(ci
);
477 flush_workqueue(ci
->wq
);
478 destroy_workqueue(ci
->wq
);
479 free_irq(ci
->irq
, ci
);
485 static struct platform_driver ci_hdrc_driver
= {
486 .probe
= ci_hdrc_probe
,
487 .remove
= ci_hdrc_remove
,
493 module_platform_driver(ci_hdrc_driver
);
495 MODULE_ALIAS("platform:ci_hdrc");
496 MODULE_ALIAS("platform:ci13xxx");
497 MODULE_LICENSE("GPL v2");
498 MODULE_AUTHOR("David Lopo <dlopo@chipidea.mips.com>");
499 MODULE_DESCRIPTION("ChipIdea HDRC Driver");