2 * drivers/usb/host/ohci-pnx4008.c
4 * driver for Philips PNX4008 USB Host
6 * Authors: Dmitry Chigirev <source@mvista.com>
7 * Vitaly Wool <vitalywool@gmail.com>
9 * register initialization is based on code examples provided by Philips
10 * Copyright (c) 2005 Koninklijke Philips Electronics N.V.
12 * NOTE: This driver does not have suspend/resume functionality
13 * This driver is intended for engineering development purposes only
15 * 2005-2006 (c) MontaVista Software, Inc. This file is licensed under
16 * the terms of the GNU General Public License version 2. This program
17 * is licensed "as is" without any warranty of any kind, whether express
20 #include <linux/clk.h>
21 #include <linux/platform_device.h>
22 #include <linux/i2c.h>
24 #include <asm/arch/hardware.h>
27 #include <asm/arch/platform.h>
28 #include <asm/arch/irqs.h>
29 #include <asm/arch/gpio.h>
31 #define USB_CTRL IO_ADDRESS(PNX4008_PWRMAN_BASE + 0x64)
33 /* USB_CTRL bit defines */
34 #define USB_SLAVE_HCLK_EN (1 << 24)
35 #define USB_HOST_NEED_CLK_EN (1 << 21)
37 #define USB_OTG_CLK_CTRL IO_ADDRESS(PNX4008_USB_CONFIG_BASE + 0xFF4)
38 #define USB_OTG_CLK_STAT IO_ADDRESS(PNX4008_USB_CONFIG_BASE + 0xFF8)
40 /* USB_OTG_CLK_CTRL bit defines */
41 #define AHB_M_CLOCK_ON (1 << 4)
42 #define OTG_CLOCK_ON (1 << 3)
43 #define I2C_CLOCK_ON (1 << 2)
44 #define DEV_CLOCK_ON (1 << 1)
45 #define HOST_CLOCK_ON (1 << 0)
47 #define USB_OTG_STAT_CONTROL IO_ADDRESS(PNX4008_USB_CONFIG_BASE + 0x110)
49 /* USB_OTG_STAT_CONTROL bit defines */
50 #define TRANSPARENT_I2C_EN (1 << 7)
51 #define HOST_EN (1 << 0)
53 /* ISP1301 USB transceiver I2C registers */
54 #define ISP1301_MODE_CONTROL_1 0x04 /* u8 read, set, +1 clear */
56 #define MC1_SPEED_REG (1 << 0)
57 #define MC1_SUSPEND_REG (1 << 1)
58 #define MC1_DAT_SE0 (1 << 2)
59 #define MC1_TRANSPARENT (1 << 3)
60 #define MC1_BDIS_ACON_EN (1 << 4)
61 #define MC1_OE_INT_EN (1 << 5)
62 #define MC1_UART_EN (1 << 6)
65 #define ISP1301_MODE_CONTROL_2 0x12 /* u8 read, set, +1 clear */
67 #define MC2_GLOBAL_PWR_DN (1 << 0)
68 #define MC2_SPD_SUSP_CTRL (1 << 1)
69 #define MC2_BI_DI (1 << 2)
70 #define MC2_TRANSP_BDIR0 (1 << 3)
71 #define MC2_TRANSP_BDIR1 (1 << 4)
72 #define MC2_AUDIO_EN (1 << 5)
73 #define MC2_PSW_EN (1 << 6)
74 #define MC2_EN2V7 (1 << 7)
76 #define ISP1301_OTG_CONTROL_1 0x06 /* u8 read, set, +1 clear */
77 # define OTG1_DP_PULLUP (1 << 0)
78 # define OTG1_DM_PULLUP (1 << 1)
79 # define OTG1_DP_PULLDOWN (1 << 2)
80 # define OTG1_DM_PULLDOWN (1 << 3)
81 # define OTG1_ID_PULLDOWN (1 << 4)
82 # define OTG1_VBUS_DRV (1 << 5)
83 # define OTG1_VBUS_DISCHRG (1 << 6)
84 # define OTG1_VBUS_CHRG (1 << 7)
85 #define ISP1301_OTG_STATUS 0x10 /* u8 readonly */
86 # define OTG_B_SESS_END (1 << 6)
87 # define OTG_B_SESS_VLD (1 << 7)
89 #define ISP1301_I2C_ADDR 0x2C
91 #define ISP1301_I2C_MODE_CONTROL_1 0x4
92 #define ISP1301_I2C_MODE_CONTROL_2 0x12
93 #define ISP1301_I2C_OTG_CONTROL_1 0x6
94 #define ISP1301_I2C_OTG_CONTROL_2 0x10
95 #define ISP1301_I2C_INTERRUPT_SOURCE 0x8
96 #define ISP1301_I2C_INTERRUPT_LATCH 0xA
97 #define ISP1301_I2C_INTERRUPT_FALLING 0xC
98 #define ISP1301_I2C_INTERRUPT_RISING 0xE
99 #define ISP1301_I2C_REG_CLEAR_ADDR 1
101 struct i2c_driver isp1301_driver
;
102 struct i2c_client
*isp1301_i2c_client
;
104 extern int usb_disabled(void);
105 extern int ocpi_enable(void);
107 static struct clk
*usb_clk
;
109 static int isp1301_probe(struct i2c_adapter
*adap
);
110 static int isp1301_detach(struct i2c_client
*client
);
112 static const unsigned short normal_i2c
[] =
113 { ISP1301_I2C_ADDR
, ISP1301_I2C_ADDR
+ 1, I2C_CLIENT_END
};
114 static const unsigned short dummy_i2c_addrlist
[] = { I2C_CLIENT_END
};
116 static struct i2c_client_address_data addr_data
= {
117 .normal_i2c
= normal_i2c
,
118 .probe
= dummy_i2c_addrlist
,
119 .ignore
= dummy_i2c_addrlist
,
122 struct i2c_driver isp1301_driver
= {
124 .name
= "isp1301_pnx",
126 .attach_adapter
= isp1301_probe
,
127 .detach_client
= isp1301_detach
,
130 static int isp1301_attach(struct i2c_adapter
*adap
, int addr
, int kind
)
132 struct i2c_client
*c
;
135 c
= kzalloc(sizeof(*c
), GFP_KERNEL
);
139 strlcpy(c
->name
, "isp1301_pnx", I2C_NAME_SIZE
);
143 c
->driver
= &isp1301_driver
;
145 err
= i2c_attach_client(c
);
151 isp1301_i2c_client
= c
;
156 static int isp1301_probe(struct i2c_adapter
*adap
)
158 return i2c_probe(adap
, &addr_data
, isp1301_attach
);
161 static int isp1301_detach(struct i2c_client
*client
)
163 i2c_detach_client(client
);
164 kfree(isp1301_i2c_client
);
168 static void i2c_write(u8 buf
, u8 subaddr
)
172 tmpbuf
[0] = subaddr
; /*register number */
173 tmpbuf
[1] = buf
; /*register data */
174 i2c_master_send(isp1301_i2c_client
, &tmpbuf
[0], 2);
177 static void isp1301_configure(void)
179 /* PNX4008 only supports DAT_SE0 USB mode */
180 /* PNX4008 R2A requires setting the MAX603 to output 3.6V */
181 /* Power up externel charge-pump */
183 i2c_write(MC1_DAT_SE0
| MC1_SPEED_REG
, ISP1301_I2C_MODE_CONTROL_1
);
184 i2c_write(~(MC1_DAT_SE0
| MC1_SPEED_REG
),
185 ISP1301_I2C_MODE_CONTROL_1
| ISP1301_I2C_REG_CLEAR_ADDR
);
186 i2c_write(MC2_BI_DI
| MC2_PSW_EN
| MC2_SPD_SUSP_CTRL
,
187 ISP1301_I2C_MODE_CONTROL_2
);
188 i2c_write(~(MC2_BI_DI
| MC2_PSW_EN
| MC2_SPD_SUSP_CTRL
),
189 ISP1301_I2C_MODE_CONTROL_2
| ISP1301_I2C_REG_CLEAR_ADDR
);
190 i2c_write(OTG1_DM_PULLDOWN
| OTG1_DP_PULLDOWN
,
191 ISP1301_I2C_OTG_CONTROL_1
);
192 i2c_write(~(OTG1_DM_PULLDOWN
| OTG1_DP_PULLDOWN
),
193 ISP1301_I2C_OTG_CONTROL_1
| ISP1301_I2C_REG_CLEAR_ADDR
);
195 ISP1301_I2C_INTERRUPT_LATCH
| ISP1301_I2C_REG_CLEAR_ADDR
);
197 ISP1301_I2C_INTERRUPT_FALLING
| ISP1301_I2C_REG_CLEAR_ADDR
);
199 ISP1301_I2C_INTERRUPT_RISING
| ISP1301_I2C_REG_CLEAR_ADDR
);
203 static inline void isp1301_vbus_on(void)
205 i2c_write(OTG1_VBUS_DRV
, ISP1301_I2C_OTG_CONTROL_1
);
208 static inline void isp1301_vbus_off(void)
210 i2c_write(OTG1_VBUS_DRV
,
211 ISP1301_I2C_OTG_CONTROL_1
| ISP1301_I2C_REG_CLEAR_ADDR
);
214 static void pnx4008_start_hc(void)
216 unsigned long tmp
= __raw_readl(USB_OTG_STAT_CONTROL
) | HOST_EN
;
217 __raw_writel(tmp
, USB_OTG_STAT_CONTROL
);
221 static void pnx4008_stop_hc(void)
225 tmp
= __raw_readl(USB_OTG_STAT_CONTROL
) & ~HOST_EN
;
226 __raw_writel(tmp
, USB_OTG_STAT_CONTROL
);
229 static int __devinit
ohci_pnx4008_start(struct usb_hcd
*hcd
)
231 struct ohci_hcd
*ohci
= hcd_to_ohci(hcd
);
234 if ((ret
= ohci_init(ohci
)) < 0)
237 if ((ret
= ohci_run(ohci
)) < 0) {
238 dev_err(hcd
->self
.controller
, "can't start\n");
245 static const struct hc_driver ohci_pnx4008_hc_driver
= {
246 .description
= hcd_name
,
247 .product_desc
= "pnx4008 OHCI",
250 * generic hardware linkage
253 .flags
= HCD_USB11
| HCD_MEMORY
,
255 .hcd_priv_size
= sizeof(struct ohci_hcd
),
257 * basic lifecycle operations
259 .start
= ohci_pnx4008_start
,
261 .shutdown
= ohci_shutdown
,
264 * managing i/o requests and associated device resources
266 .urb_enqueue
= ohci_urb_enqueue
,
267 .urb_dequeue
= ohci_urb_dequeue
,
268 .endpoint_disable
= ohci_endpoint_disable
,
273 .get_frame_number
= ohci_get_frame
,
278 .hub_status_data
= ohci_hub_status_data
,
279 .hub_control
= ohci_hub_control
,
280 .hub_irq_enable
= ohci_rhsc_enable
,
282 .bus_suspend
= ohci_bus_suspend
,
283 .bus_resume
= ohci_bus_resume
,
285 .start_port_reset
= ohci_start_port_reset
,
288 #define USB_CLOCK_MASK (AHB_M_CLOCK_ON| OTG_CLOCK_ON | HOST_CLOCK_ON | I2C_CLOCK_ON)
290 static void pnx4008_set_usb_bits(void)
292 start_int_set_falling_edge(SE_USB_OTG_ATX_INT_N
);
293 start_int_ack(SE_USB_OTG_ATX_INT_N
);
294 start_int_umask(SE_USB_OTG_ATX_INT_N
);
296 start_int_set_rising_edge(SE_USB_OTG_TIMER_INT
);
297 start_int_ack(SE_USB_OTG_TIMER_INT
);
298 start_int_umask(SE_USB_OTG_TIMER_INT
);
300 start_int_set_rising_edge(SE_USB_I2C_INT
);
301 start_int_ack(SE_USB_I2C_INT
);
302 start_int_umask(SE_USB_I2C_INT
);
304 start_int_set_rising_edge(SE_USB_INT
);
305 start_int_ack(SE_USB_INT
);
306 start_int_umask(SE_USB_INT
);
308 start_int_set_rising_edge(SE_USB_NEED_CLK_INT
);
309 start_int_ack(SE_USB_NEED_CLK_INT
);
310 start_int_umask(SE_USB_NEED_CLK_INT
);
312 start_int_set_rising_edge(SE_USB_AHB_NEED_CLK_INT
);
313 start_int_ack(SE_USB_AHB_NEED_CLK_INT
);
314 start_int_umask(SE_USB_AHB_NEED_CLK_INT
);
317 static void pnx4008_unset_usb_bits(void)
319 start_int_mask(SE_USB_OTG_ATX_INT_N
);
320 start_int_mask(SE_USB_OTG_TIMER_INT
);
321 start_int_mask(SE_USB_I2C_INT
);
322 start_int_mask(SE_USB_INT
);
323 start_int_mask(SE_USB_NEED_CLK_INT
);
324 start_int_mask(SE_USB_AHB_NEED_CLK_INT
);
327 static int __devinit
usb_hcd_pnx4008_probe(struct platform_device
*pdev
)
329 struct usb_hcd
*hcd
= 0;
330 struct ohci_hcd
*ohci
;
331 const struct hc_driver
*driver
= &ohci_pnx4008_hc_driver
;
335 dev_dbg(&pdev
->dev
, "%s: " DRIVER_INFO
" (pnx4008)\n", hcd_name
);
336 if (usb_disabled()) {
337 err("USB is disabled");
342 if (pdev
->num_resources
!= 2
343 || pdev
->resource
[0].flags
!= IORESOURCE_MEM
344 || pdev
->resource
[1].flags
!= IORESOURCE_IRQ
) {
345 err("Invalid resource configuration");
350 /* Enable AHB slave USB clock, needed for further USB clock control */
351 __raw_writel(USB_SLAVE_HCLK_EN
| (1 << 19), USB_CTRL
);
353 ret
= i2c_add_driver(&isp1301_driver
);
355 err("failed to connect I2C to ISP1301 USB Transceiver");
362 usb_clk
= clk_get(&pdev
->dev
, "ck_pll5");
363 if (IS_ERR(usb_clk
)) {
364 err("failed to acquire USB PLL");
365 ret
= PTR_ERR(usb_clk
);
369 ret
= clk_enable(usb_clk
);
371 err("failed to start USB PLL");
375 ret
= clk_set_rate(usb_clk
, 48000);
377 err("failed to set USB clock rate");
381 __raw_writel(__raw_readl(USB_CTRL
) | USB_HOST_NEED_CLK_EN
, USB_CTRL
);
383 /* Set to enable all needed USB clocks */
384 __raw_writel(USB_CLOCK_MASK
, USB_OTG_CLK_CTRL
);
386 while ((__raw_readl(USB_OTG_CLK_STAT
) & USB_CLOCK_MASK
) !=
389 hcd
= usb_create_hcd (driver
, &pdev
->dev
, dev_name(&pdev
->dev
));
391 err("Failed to allocate HC buffer");
396 /* Set all USB bits in the Start Enable register */
397 pnx4008_set_usb_bits();
399 hcd
->rsrc_start
= pdev
->resource
[0].start
;
400 hcd
->rsrc_len
= pdev
->resource
[0].end
- pdev
->resource
[0].start
+ 1;
401 if (!request_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
, hcd_name
)) {
402 dev_dbg(&pdev
->dev
, "request_mem_region failed\n");
406 hcd
->regs
= (void __iomem
*)pdev
->resource
[0].start
;
408 irq
= platform_get_irq(pdev
, 0);
415 platform_set_drvdata(pdev
, hcd
);
416 ohci
= hcd_to_ohci(hcd
);
419 dev_info(&pdev
->dev
, "at 0x%p, irq %d\n", hcd
->regs
, hcd
->irq
);
420 ret
= usb_add_hcd(hcd
, irq
, IRQF_DISABLED
);
426 pnx4008_unset_usb_bits();
429 clk_disable(usb_clk
);
433 i2c_del_driver(&isp1301_driver
);
438 static int usb_hcd_pnx4008_remove(struct platform_device
*pdev
)
440 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
444 release_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
446 pnx4008_unset_usb_bits();
447 clk_disable(usb_clk
);
449 i2c_del_driver(&isp1301_driver
);
451 platform_set_drvdata(pdev
, NULL
);
456 /* work with hotplug and coldplug */
457 MODULE_ALIAS("platform:usb-ohci");
459 static struct platform_driver usb_hcd_pnx4008_driver
= {
462 .owner
= THIS_MODULE
,
464 .probe
= usb_hcd_pnx4008_probe
,
465 .remove
= usb_hcd_pnx4008_remove
,