2 * USB SD Host Controller (USHC) controller driver.
4 * Copyright (C) 2010 Cambridge Silicon Radio Ltd.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or (at
9 * your option) any later version.
12 * - Only version 2 devices are supported.
13 * - Version 2 devices only support SDIO cards/devices (R2 response is
17 * [USHC] USB SD Host Controller specification (CS-118793-SP)
19 #include <linux/module.h>
20 #include <linux/usb.h>
21 #include <linux/kernel.h>
22 #include <linux/usb.h>
23 #include <linux/slab.h>
24 #include <linux/dma-mapping.h>
25 #include <linux/mmc/host.h>
29 USHC_HOST_CTRL
= 0x01,
33 USHC_READ_RESP
= 0x05,
37 enum ushc_request_type
{
38 USHC_GET_CAPS_TYPE
= USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
39 USHC_HOST_CTRL_TYPE
= USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
40 USHC_PWR_CTRL_TYPE
= USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
41 USHC_CLK_FREQ_TYPE
= USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
42 USHC_EXEC_CMD_TYPE
= USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
43 USHC_READ_RESP_TYPE
= USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
44 USHC_RESET_TYPE
= USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
47 #define USHC_GET_CAPS_VERSION_MASK 0xff
48 #define USHC_GET_CAPS_3V3 (1 << 8)
49 #define USHC_GET_CAPS_3V0 (1 << 9)
50 #define USHC_GET_CAPS_1V8 (1 << 10)
51 #define USHC_GET_CAPS_HIGH_SPD (1 << 16)
53 #define USHC_HOST_CTRL_4BIT (1 << 1)
54 #define USHC_HOST_CTRL_HIGH_SPD (1 << 0)
56 #define USHC_PWR_CTRL_OFF 0x00
57 #define USHC_PWR_CTRL_3V3 0x01
58 #define USHC_PWR_CTRL_3V0 0x02
59 #define USHC_PWR_CTRL_1V8 0x03
61 #define USHC_READ_RESP_BUSY (1 << 4)
62 #define USHC_READ_RESP_ERR_TIMEOUT (1 << 3)
63 #define USHC_READ_RESP_ERR_CRC (1 << 2)
64 #define USHC_READ_RESP_ERR_DAT (1 << 1)
65 #define USHC_READ_RESP_ERR_CMD (1 << 0)
66 #define USHC_READ_RESP_ERR_MASK 0x0f
73 } __attribute__((packed
));
75 #define USHC_CBW_SIGNATURE 'C'
81 } __attribute__((packed
));
83 #define USHC_CSW_SIGNATURE 'S'
85 struct ushc_int_data
{
90 #define USHC_INT_STATUS_SDIO_INT (1 << 1)
91 #define USHC_INT_STATUS_CARD_PRESENT (1 << 0)
95 struct usb_device
*usb_dev
;
99 struct ushc_int_data
*int_data
;
102 struct ushc_cbw
*cbw
;
104 struct urb
*data_urb
;
107 struct ushc_csw
*csw
;
110 struct mmc_request
*current_req
;
118 #define DISCONNECTED 0
120 #define IGNORE_NEXT_INT 2
122 static void data_callback(struct urb
*urb
);
124 static int ushc_hw_reset(struct ushc_data
*ushc
)
126 return usb_control_msg(ushc
->usb_dev
, usb_sndctrlpipe(ushc
->usb_dev
, 0),
127 USHC_RESET
, USHC_RESET_TYPE
,
131 static int ushc_hw_get_caps(struct ushc_data
*ushc
)
136 ret
= usb_control_msg(ushc
->usb_dev
, usb_rcvctrlpipe(ushc
->usb_dev
, 0),
137 USHC_GET_CAPS
, USHC_GET_CAPS_TYPE
,
138 0, 0, &ushc
->caps
, sizeof(ushc
->caps
), 100);
142 ushc
->caps
= le32_to_cpu(ushc
->caps
);
144 version
= ushc
->caps
& USHC_GET_CAPS_VERSION_MASK
;
145 if (version
!= 0x02) {
146 dev_err(&ushc
->usb_dev
->dev
, "controller version %d is not supported\n", version
);
153 static int ushc_hw_set_host_ctrl(struct ushc_data
*ushc
, u16 mask
, u16 val
)
158 host_ctrl
= (ushc
->host_ctrl
& ~mask
) | val
;
159 ret
= usb_control_msg(ushc
->usb_dev
, usb_sndctrlpipe(ushc
->usb_dev
, 0),
160 USHC_HOST_CTRL
, USHC_HOST_CTRL_TYPE
,
161 host_ctrl
, 0, NULL
, 0, 100);
164 ushc
->host_ctrl
= host_ctrl
;
168 static void int_callback(struct urb
*urb
)
170 struct ushc_data
*ushc
= urb
->context
;
171 u8 status
, last_status
;
176 status
= ushc
->int_data
->status
;
177 last_status
= ushc
->last_status
;
178 ushc
->last_status
= status
;
181 * Ignore the card interrupt status on interrupt transfers that
182 * were submitted while card interrupts where disabled.
184 * This avoid occasional spurious interrupts when enabling
185 * interrupts immediately after clearing the source on the card.
188 if (!test_and_clear_bit(IGNORE_NEXT_INT
, &ushc
->flags
)
189 && test_bit(INT_EN
, &ushc
->flags
)
190 && status
& USHC_INT_STATUS_SDIO_INT
) {
191 mmc_signal_sdio_irq(ushc
->mmc
);
194 if ((status
^ last_status
) & USHC_INT_STATUS_CARD_PRESENT
)
195 mmc_detect_change(ushc
->mmc
, msecs_to_jiffies(100));
197 if (!test_bit(INT_EN
, &ushc
->flags
))
198 set_bit(IGNORE_NEXT_INT
, &ushc
->flags
);
199 usb_submit_urb(ushc
->int_urb
, GFP_ATOMIC
);
202 static void cbw_callback(struct urb
*urb
)
204 struct ushc_data
*ushc
= urb
->context
;
206 if (urb
->status
!= 0) {
207 usb_unlink_urb(ushc
->data_urb
);
208 usb_unlink_urb(ushc
->csw_urb
);
212 static void data_callback(struct urb
*urb
)
214 struct ushc_data
*ushc
= urb
->context
;
216 if (urb
->status
!= 0)
217 usb_unlink_urb(ushc
->csw_urb
);
220 static void csw_callback(struct urb
*urb
)
222 struct ushc_data
*ushc
= urb
->context
;
223 struct mmc_request
*req
= ushc
->current_req
;
226 status
= ushc
->csw
->status
;
228 if (urb
->status
!= 0) {
229 req
->cmd
->error
= urb
->status
;
230 } else if (status
& USHC_READ_RESP_ERR_CMD
) {
231 if (status
& USHC_READ_RESP_ERR_CRC
)
232 req
->cmd
->error
= -EIO
;
234 req
->cmd
->error
= -ETIMEDOUT
;
237 if (status
& USHC_READ_RESP_ERR_DAT
) {
238 if (status
& USHC_READ_RESP_ERR_CRC
)
239 req
->data
->error
= -EIO
;
241 req
->data
->error
= -ETIMEDOUT
;
242 req
->data
->bytes_xfered
= 0;
244 req
->data
->bytes_xfered
= req
->data
->blksz
* req
->data
->blocks
;
248 req
->cmd
->resp
[0] = le32_to_cpu(ushc
->csw
->response
);
250 mmc_request_done(ushc
->mmc
, req
);
253 static void ushc_request(struct mmc_host
*mmc
, struct mmc_request
*req
)
255 struct ushc_data
*ushc
= mmc_priv(mmc
);
259 spin_lock_irqsave(&ushc
->lock
, flags
);
261 if (test_bit(DISCONNECTED
, &ushc
->flags
)) {
266 /* Version 2 firmware doesn't support the R2 response format. */
267 if (req
->cmd
->flags
& MMC_RSP_136
) {
272 /* The Astoria's data FIFOs don't work with clock speeds < 5MHz so
273 limit commands with data to 6MHz or more. */
274 if (req
->data
&& ushc
->clock_freq
< 6000000) {
279 ushc
->current_req
= req
;
281 /* Start cmd with CBW. */
282 ushc
->cbw
->cmd_idx
= cpu_to_le16(req
->cmd
->opcode
);
284 ushc
->cbw
->block_size
= cpu_to_le16(req
->data
->blksz
);
286 ushc
->cbw
->block_size
= 0;
287 ushc
->cbw
->arg
= cpu_to_le32(req
->cmd
->arg
);
289 ret
= usb_submit_urb(ushc
->cbw_urb
, GFP_ATOMIC
);
293 /* Submit data (if any). */
295 struct mmc_data
*data
= req
->data
;
298 if (data
->flags
& MMC_DATA_READ
)
299 pipe
= usb_rcvbulkpipe(ushc
->usb_dev
, 6);
301 pipe
= usb_sndbulkpipe(ushc
->usb_dev
, 2);
303 usb_fill_bulk_urb(ushc
->data_urb
, ushc
->usb_dev
, pipe
,
304 sg_virt(data
->sg
), data
->sg
->length
,
305 data_callback
, ushc
);
306 ret
= usb_submit_urb(ushc
->data_urb
, GFP_ATOMIC
);
312 ret
= usb_submit_urb(ushc
->csw_urb
, GFP_ATOMIC
);
317 spin_unlock_irqrestore(&ushc
->lock
, flags
);
319 usb_unlink_urb(ushc
->cbw_urb
);
320 usb_unlink_urb(ushc
->data_urb
);
321 req
->cmd
->error
= ret
;
322 mmc_request_done(mmc
, req
);
326 static int ushc_set_power(struct ushc_data
*ushc
, unsigned char power_mode
)
330 switch (power_mode
) {
332 voltage
= USHC_PWR_CTRL_OFF
;
336 voltage
= USHC_PWR_CTRL_3V3
;
342 return usb_control_msg(ushc
->usb_dev
, usb_sndctrlpipe(ushc
->usb_dev
, 0),
343 USHC_PWR_CTRL
, USHC_PWR_CTRL_TYPE
,
344 voltage
, 0, NULL
, 0, 100);
347 static int ushc_set_bus_width(struct ushc_data
*ushc
, int bus_width
)
349 return ushc_hw_set_host_ctrl(ushc
, USHC_HOST_CTRL_4BIT
,
350 bus_width
== 4 ? USHC_HOST_CTRL_4BIT
: 0);
353 static int ushc_set_bus_freq(struct ushc_data
*ushc
, int clk
, bool enable_hs
)
357 /* Hardware can't detect interrupts while the clock is off. */
361 ret
= ushc_hw_set_host_ctrl(ushc
, USHC_HOST_CTRL_HIGH_SPD
,
362 enable_hs
? USHC_HOST_CTRL_HIGH_SPD
: 0);
366 ret
= usb_control_msg(ushc
->usb_dev
, usb_sndctrlpipe(ushc
->usb_dev
, 0),
367 USHC_CLK_FREQ
, USHC_CLK_FREQ_TYPE
,
368 clk
& 0xffff, (clk
>> 16) & 0xffff, NULL
, 0, 100);
372 ushc
->clock_freq
= clk
;
376 static void ushc_set_ios(struct mmc_host
*mmc
, struct mmc_ios
*ios
)
378 struct ushc_data
*ushc
= mmc_priv(mmc
);
380 ushc_set_power(ushc
, ios
->power_mode
);
381 ushc_set_bus_width(ushc
, 1 << ios
->bus_width
);
382 ushc_set_bus_freq(ushc
, ios
->clock
, ios
->timing
== MMC_TIMING_SD_HS
);
385 static int ushc_get_cd(struct mmc_host
*mmc
)
387 struct ushc_data
*ushc
= mmc_priv(mmc
);
389 return !!(ushc
->last_status
& USHC_INT_STATUS_CARD_PRESENT
);
392 static void ushc_enable_sdio_irq(struct mmc_host
*mmc
, int enable
)
394 struct ushc_data
*ushc
= mmc_priv(mmc
);
397 set_bit(INT_EN
, &ushc
->flags
);
399 clear_bit(INT_EN
, &ushc
->flags
);
402 static void ushc_clean_up(struct ushc_data
*ushc
)
404 usb_free_urb(ushc
->int_urb
);
405 usb_free_urb(ushc
->csw_urb
);
406 usb_free_urb(ushc
->data_urb
);
407 usb_free_urb(ushc
->cbw_urb
);
409 kfree(ushc
->int_data
);
413 mmc_free_host(ushc
->mmc
);
416 static const struct mmc_host_ops ushc_ops
= {
417 .request
= ushc_request
,
418 .set_ios
= ushc_set_ios
,
419 .get_cd
= ushc_get_cd
,
420 .enable_sdio_irq
= ushc_enable_sdio_irq
,
423 static int ushc_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
425 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
426 struct mmc_host
*mmc
;
427 struct ushc_data
*ushc
;
430 mmc
= mmc_alloc_host(sizeof(struct ushc_data
), &intf
->dev
);
433 ushc
= mmc_priv(mmc
);
434 usb_set_intfdata(intf
, ushc
);
436 ushc
->usb_dev
= usb_dev
;
439 spin_lock_init(&ushc
->lock
);
441 ret
= ushc_hw_reset(ushc
);
445 /* Read capabilities. */
446 ret
= ushc_hw_get_caps(ushc
);
450 mmc
->ops
= &ushc_ops
;
453 mmc
->f_max
= 50000000;
454 mmc
->ocr_avail
= MMC_VDD_32_33
| MMC_VDD_33_34
;
455 mmc
->caps
= MMC_CAP_4_BIT_DATA
| MMC_CAP_SDIO_IRQ
;
456 mmc
->caps
|= (ushc
->caps
& USHC_GET_CAPS_HIGH_SPD
) ? MMC_CAP_SD_HIGHSPEED
: 0;
458 mmc
->max_seg_size
= 512*511;
460 mmc
->max_req_size
= 512*511;
461 mmc
->max_blk_size
= 512;
462 mmc
->max_blk_count
= 511;
464 ushc
->int_urb
= usb_alloc_urb(0, GFP_KERNEL
);
465 if (ushc
->int_urb
== NULL
)
467 ushc
->int_data
= kzalloc(sizeof(struct ushc_int_data
), GFP_KERNEL
);
468 if (ushc
->int_data
== NULL
)
470 usb_fill_int_urb(ushc
->int_urb
, ushc
->usb_dev
,
471 usb_rcvintpipe(usb_dev
,
472 intf
->cur_altsetting
->endpoint
[0].desc
.bEndpointAddress
),
473 ushc
->int_data
, sizeof(struct ushc_int_data
),
475 intf
->cur_altsetting
->endpoint
[0].desc
.bInterval
);
477 ushc
->cbw_urb
= usb_alloc_urb(0, GFP_KERNEL
);
478 if (ushc
->cbw_urb
== NULL
)
480 ushc
->cbw
= kzalloc(sizeof(struct ushc_cbw
), GFP_KERNEL
);
481 if (ushc
->cbw
== NULL
)
483 ushc
->cbw
->signature
= USHC_CBW_SIGNATURE
;
485 usb_fill_bulk_urb(ushc
->cbw_urb
, ushc
->usb_dev
, usb_sndbulkpipe(usb_dev
, 2),
486 ushc
->cbw
, sizeof(struct ushc_cbw
),
489 ushc
->data_urb
= usb_alloc_urb(0, GFP_KERNEL
);
490 if (ushc
->data_urb
== NULL
)
493 ushc
->csw_urb
= usb_alloc_urb(0, GFP_KERNEL
);
494 if (ushc
->csw_urb
== NULL
)
496 ushc
->csw
= kzalloc(sizeof(struct ushc_cbw
), GFP_KERNEL
);
497 if (ushc
->csw
== NULL
)
499 usb_fill_bulk_urb(ushc
->csw_urb
, ushc
->usb_dev
, usb_rcvbulkpipe(usb_dev
, 6),
500 ushc
->csw
, sizeof(struct ushc_csw
),
503 ret
= mmc_add_host(ushc
->mmc
);
507 ret
= usb_submit_urb(ushc
->int_urb
, GFP_KERNEL
);
509 mmc_remove_host(ushc
->mmc
);
520 static void ushc_disconnect(struct usb_interface
*intf
)
522 struct ushc_data
*ushc
= usb_get_intfdata(intf
);
524 spin_lock_irq(&ushc
->lock
);
525 set_bit(DISCONNECTED
, &ushc
->flags
);
526 spin_unlock_irq(&ushc
->lock
);
528 usb_kill_urb(ushc
->int_urb
);
529 usb_kill_urb(ushc
->cbw_urb
);
530 usb_kill_urb(ushc
->data_urb
);
531 usb_kill_urb(ushc
->csw_urb
);
533 mmc_remove_host(ushc
->mmc
);
538 static struct usb_device_id ushc_id_table
[] = {
539 /* CSR USB SD Host Controller */
540 { USB_DEVICE(0x0a12, 0x5d10) },
543 MODULE_DEVICE_TABLE(usb
, ushc_id_table
);
545 static struct usb_driver ushc_driver
= {
547 .id_table
= ushc_id_table
,
549 .disconnect
= ushc_disconnect
,
552 static int __init
ushc_init(void)
554 return usb_register(&ushc_driver
);
556 module_init(ushc_init
);
558 static void __exit
ushc_exit(void)
560 usb_deregister(&ushc_driver
);
562 module_exit(ushc_exit
);
564 MODULE_DESCRIPTION("USB SD Host Controller driver");
565 MODULE_AUTHOR("David Vrabel <david.vrabel@csr.com>");
566 MODULE_LICENSE("GPL");