Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/mmc/host/ushc.c

  1 /*
  2  * USB SD Host Controller (USHC) controller driver.
  3  *
  4  * Copyright (C) 2010 Cambridge Silicon Radio Ltd.
  5  *
  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.
 10  *
 11  * Notes:
 12  *   - Only version 2 devices are supported.
 13  *   - Version 2 devices only support SDIO cards/devices (R2 response is
 14  *     unsupported).
 15  *
 16  * References:
 17  *   [USHC] USB SD Host Controller specification (CS-118793-SP)
 18  */
 19 #include <linux/module.h>
 20 #include <linux/usb.h>
 21 #include <linux/kernel.h>
 22 #include <linux/slab.h>
 23 #include <linux/dma-mapping.h>
 24 #include <linux/mmc/host.h>
 25 
 26 enum ushc_request {
 27         USHC_GET_CAPS  = 0x00,
 28         USHC_HOST_CTRL = 0x01,
 29         USHC_PWR_CTRL  = 0x02,
 30         USHC_CLK_FREQ  = 0x03,
 31         USHC_EXEC_CMD  = 0x04,
 32         USHC_READ_RESP = 0x05,
 33         USHC_RESET     = 0x06,
 34 };
 35 
 36 enum ushc_request_type {
 37         USHC_GET_CAPS_TYPE  = USB_DIR_IN  | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 38         USHC_HOST_CTRL_TYPE = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 39         USHC_PWR_CTRL_TYPE  = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 40         USHC_CLK_FREQ_TYPE  = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 41         USHC_EXEC_CMD_TYPE  = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 42         USHC_READ_RESP_TYPE = USB_DIR_IN  | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 43         USHC_RESET_TYPE     = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 44 };
 45 
 46 #define USHC_GET_CAPS_VERSION_MASK 0xff
 47 #define USHC_GET_CAPS_3V3      (1 << 8)
 48 #define USHC_GET_CAPS_3V0      (1 << 9)
 49 #define USHC_GET_CAPS_1V8      (1 << 10)
 50 #define USHC_GET_CAPS_HIGH_SPD (1 << 16)
 51 
 52 #define USHC_HOST_CTRL_4BIT     (1 << 1)
 53 #define USHC_HOST_CTRL_HIGH_SPD (1 << 0)
 54 
 55 #define USHC_PWR_CTRL_OFF 0x00
 56 #define USHC_PWR_CTRL_3V3 0x01
 57 #define USHC_PWR_CTRL_3V0 0x02
 58 #define USHC_PWR_CTRL_1V8 0x03
 59 
 60 #define USHC_READ_RESP_BUSY        (1 << 4)
 61 #define USHC_READ_RESP_ERR_TIMEOUT (1 << 3)
 62 #define USHC_READ_RESP_ERR_CRC     (1 << 2)
 63 #define USHC_READ_RESP_ERR_DAT     (1 << 1)
 64 #define USHC_READ_RESP_ERR_CMD     (1 << 0)
 65 #define USHC_READ_RESP_ERR_MASK    0x0f
 66 
 67 struct ushc_cbw {
 68         __u8 signature;
 69         __u8 cmd_idx;
 70         __le16 block_size;
 71         __le32 arg;
 72 } __attribute__((packed));
 73 
 74 #define USHC_CBW_SIGNATURE 'C'
 75 
 76 struct ushc_csw {
 77         __u8 signature;
 78         __u8 status;
 79         __le32 response;
 80 } __attribute__((packed));
 81 
 82 #define USHC_CSW_SIGNATURE 'S'
 83 
 84 struct ushc_int_data {
 85         u8 status;
 86         u8 reserved[3];
 87 };
 88 
 89 #define USHC_INT_STATUS_SDIO_INT     (1 << 1)
 90 #define USHC_INT_STATUS_CARD_PRESENT (1 << 0)
 91 
 92 
 93 struct ushc_data {
 94         struct usb_device *usb_dev;
 95         struct mmc_host *mmc;
 96 
 97         struct urb *int_urb;
 98         struct ushc_int_data *int_data;
 99 
100         struct urb *cbw_urb;
101         struct ushc_cbw *cbw;
102 
103         struct urb *data_urb;
104 
105         struct urb *csw_urb;
106         struct ushc_csw *csw;
107 
108         spinlock_t lock;
109         struct mmc_request *current_req;
110         u32 caps;
111         u16 host_ctrl;
112         unsigned long flags;
113         u8 last_status;
114         int clock_freq;
115 };
116 
117 #define DISCONNECTED    0
118 #define INT_EN          1
119 #define IGNORE_NEXT_INT 2
120 
121 static void data_callback(struct urb *urb);
122 
123 static int ushc_hw_reset(struct ushc_data *ushc)
124 {
125         return usb_control_msg(ushc->usb_dev, usb_sndctrlpipe(ushc->usb_dev, 0),
126                                USHC_RESET, USHC_RESET_TYPE,
127                                0, 0, NULL, 0, 100);
128 }
129 
130 static int ushc_hw_get_caps(struct ushc_data *ushc)
131 {
132         int ret;
133         int version;
134 
135         ret = usb_control_msg(ushc->usb_dev, usb_rcvctrlpipe(ushc->usb_dev, 0),
136                               USHC_GET_CAPS, USHC_GET_CAPS_TYPE,
137                               0, 0, &ushc->caps, sizeof(ushc->caps), 100);
138         if (ret < 0)
139                 return ret;
140 
141         ushc->caps = le32_to_cpu(ushc->caps);
142 
143         version = ushc->caps & USHC_GET_CAPS_VERSION_MASK;
144         if (version != 0x02) {
145                 dev_err(&ushc->usb_dev->dev, "controller version %d is not supported\n", version);
146                 return -EINVAL;
147         }
148 
149         return 0;
150 }
151 
152 static int ushc_hw_set_host_ctrl(struct ushc_data *ushc, u16 mask, u16 val)
153 {
154         u16 host_ctrl;
155         int ret;
156 
157         host_ctrl = (ushc->host_ctrl & ~mask) | val;
158         ret = usb_control_msg(ushc->usb_dev, usb_sndctrlpipe(ushc->usb_dev, 0),
159                               USHC_HOST_CTRL, USHC_HOST_CTRL_TYPE,
160                               host_ctrl, 0, NULL, 0, 100);
161         if (ret < 0)
162                 return ret;
163         ushc->host_ctrl = host_ctrl;
164         return 0;
165 }
166 
167 static void int_callback(struct urb *urb)
168 {
169         struct ushc_data *ushc = urb->context;
170         u8 status, last_status;
171 
172         if (urb->status < 0)
173                 return;
174 
175         status = ushc->int_data->status;
176         last_status = ushc->last_status;
177         ushc->last_status = status;
178 
179         /*
180          * Ignore the card interrupt status on interrupt transfers that
181          * were submitted while card interrupts where disabled.
182          *
183          * This avoid occasional spurious interrupts when enabling
184          * interrupts immediately after clearing the source on the card.
185          */
186 
187         if (!test_and_clear_bit(IGNORE_NEXT_INT, &ushc->flags)
188             && test_bit(INT_EN, &ushc->flags)
189             && status & USHC_INT_STATUS_SDIO_INT) {
190                 mmc_signal_sdio_irq(ushc->mmc);
191         }
192 
193         if ((status ^ last_status) & USHC_INT_STATUS_CARD_PRESENT)
194                 mmc_detect_change(ushc->mmc, msecs_to_jiffies(100));
195 
196         if (!test_bit(INT_EN, &ushc->flags))
197                 set_bit(IGNORE_NEXT_INT, &ushc->flags);
198         usb_submit_urb(ushc->int_urb, GFP_ATOMIC);
199 }
200 
201 static void cbw_callback(struct urb *urb)
202 {
203         struct ushc_data *ushc = urb->context;
204 
205         if (urb->status != 0) {
206                 usb_unlink_urb(ushc->data_urb);
207                 usb_unlink_urb(ushc->csw_urb);
208         }
209 }
210 
211 static void data_callback(struct urb *urb)
212 {
213         struct ushc_data *ushc = urb->context;
214 
215         if (urb->status != 0)
216                 usb_unlink_urb(ushc->csw_urb);
217 }
218 
219 static void csw_callback(struct urb *urb)
220 {
221         struct ushc_data *ushc = urb->context;
222         struct mmc_request *req = ushc->current_req;
223         int status;
224 
225         status = ushc->csw->status;
226 
227         if (urb->status != 0) {
228                 req->cmd->error = urb->status;
229         } else if (status & USHC_READ_RESP_ERR_CMD) {
230                 if (status & USHC_READ_RESP_ERR_CRC)
231                         req->cmd->error = -EIO;
232                 else
233                         req->cmd->error = -ETIMEDOUT;
234         }
235         if (req->data) {
236                 if (status & USHC_READ_RESP_ERR_DAT) {
237                         if (status & USHC_READ_RESP_ERR_CRC)
238                                 req->data->error = -EIO;
239                         else
240                                 req->data->error = -ETIMEDOUT;
241                         req->data->bytes_xfered = 0;
242                 } else {
243                         req->data->bytes_xfered = req->data->blksz * req->data->blocks;
244                 }
245         }
246 
247         req->cmd->resp[0] = le32_to_cpu(ushc->csw->response);
248 
249         mmc_request_done(ushc->mmc, req);
250 }
251 
252 static void ushc_request(struct mmc_host *mmc, struct mmc_request *req)
253 {
254         struct ushc_data *ushc = mmc_priv(mmc);
255         int ret;
256         unsigned long flags;
257 
258         spin_lock_irqsave(&ushc->lock, flags);
259 
260         if (test_bit(DISCONNECTED, &ushc->flags)) {
261                 ret = -ENODEV;
262                 goto out;
263         }
264 
265         /* Version 2 firmware doesn't support the R2 response format. */
266         if (req->cmd->flags & MMC_RSP_136) {
267                 ret = -EINVAL;
268                 goto out;
269         }
270 
271         /* The Astoria's data FIFOs don't work with clock speeds < 5MHz so
272            limit commands with data to 6MHz or more. */
273         if (req->data && ushc->clock_freq < 6000000) {
274                 ret = -EINVAL;
275                 goto out;
276         }
277 
278         ushc->current_req = req;
279 
280         /* Start cmd with CBW. */
281         ushc->cbw->cmd_idx = cpu_to_le16(req->cmd->opcode);
282         if (req->data)
283                 ushc->cbw->block_size = cpu_to_le16(req->data->blksz);
284         else
285                 ushc->cbw->block_size = 0;
286         ushc->cbw->arg = cpu_to_le32(req->cmd->arg);
287 
288         ret = usb_submit_urb(ushc->cbw_urb, GFP_ATOMIC);
289         if (ret < 0)
290                 goto out;
291 
292         /* Submit data (if any). */
293         if (req->data) {
294                 struct mmc_data *data = req->data;
295                 int pipe;
296 
297                 if (data->flags & MMC_DATA_READ)
298                         pipe = usb_rcvbulkpipe(ushc->usb_dev, 6);
299                 else
300                         pipe = usb_sndbulkpipe(ushc->usb_dev, 2);
301 
302                 usb_fill_bulk_urb(ushc->data_urb, ushc->usb_dev, pipe,
303                                   sg_virt(data->sg), data->sg->length,
304                                   data_callback, ushc);
305                 ret = usb_submit_urb(ushc->data_urb, GFP_ATOMIC);
306                 if (ret < 0)
307                         goto out;
308         }
309 
310         /* Submit CSW. */
311         ret = usb_submit_urb(ushc->csw_urb, GFP_ATOMIC);
312         if (ret < 0)
313                 goto out;
314 
315 out:
316         spin_unlock_irqrestore(&ushc->lock, flags);
317         if (ret < 0) {
318                 usb_unlink_urb(ushc->cbw_urb);
319                 usb_unlink_urb(ushc->data_urb);
320                 req->cmd->error = ret;
321                 mmc_request_done(mmc, req);
322         }
323 }
324 
325 static int ushc_set_power(struct ushc_data *ushc, unsigned char power_mode)
326 {
327         u16 voltage;
328 
329         switch (power_mode) {
330         case MMC_POWER_OFF:
331                 voltage = USHC_PWR_CTRL_OFF;
332                 break;
333         case MMC_POWER_UP:
334         case MMC_POWER_ON:
335                 voltage = USHC_PWR_CTRL_3V3;
336                 break;
337         default:
338                 return -EINVAL;
339         }
340 
341         return usb_control_msg(ushc->usb_dev, usb_sndctrlpipe(ushc->usb_dev, 0),
342                                USHC_PWR_CTRL, USHC_PWR_CTRL_TYPE,
343                                voltage, 0, NULL, 0, 100);
344 }
345 
346 static int ushc_set_bus_width(struct ushc_data *ushc, int bus_width)
347 {
348         return ushc_hw_set_host_ctrl(ushc, USHC_HOST_CTRL_4BIT,
349                                      bus_width == 4 ? USHC_HOST_CTRL_4BIT : 0);
350 }
351 
352 static int ushc_set_bus_freq(struct ushc_data *ushc, int clk, bool enable_hs)
353 {
354         int ret;
355 
356         /* Hardware can't detect interrupts while the clock is off. */
357         if (clk == 0)
358                 clk = 400000;
359 
360         ret = ushc_hw_set_host_ctrl(ushc, USHC_HOST_CTRL_HIGH_SPD,
361                                     enable_hs ? USHC_HOST_CTRL_HIGH_SPD : 0);
362         if (ret < 0)
363                 return ret;
364 
365         ret = usb_control_msg(ushc->usb_dev, usb_sndctrlpipe(ushc->usb_dev, 0),
366                               USHC_CLK_FREQ, USHC_CLK_FREQ_TYPE,
367                               clk & 0xffff, (clk >> 16) & 0xffff, NULL, 0, 100);
368         if (ret < 0)
369                 return ret;
370 
371         ushc->clock_freq = clk;
372         return 0;
373 }
374 
375 static void ushc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
376 {
377         struct ushc_data *ushc = mmc_priv(mmc);
378 
379         ushc_set_power(ushc, ios->power_mode);
380         ushc_set_bus_width(ushc, 1 << ios->bus_width);
381         ushc_set_bus_freq(ushc, ios->clock, ios->timing == MMC_TIMING_SD_HS);
382 }
383 
384 static int ushc_get_cd(struct mmc_host *mmc)
385 {
386         struct ushc_data *ushc = mmc_priv(mmc);
387 
388         return !!(ushc->last_status & USHC_INT_STATUS_CARD_PRESENT);
389 }
390 
391 static void ushc_enable_sdio_irq(struct mmc_host *mmc, int enable)
392 {
393         struct ushc_data *ushc = mmc_priv(mmc);
394 
395         if (enable)
396                 set_bit(INT_EN, &ushc->flags);
397         else
398                 clear_bit(INT_EN, &ushc->flags);
399 }
400 
401 static void ushc_clean_up(struct ushc_data *ushc)
402 {
403         usb_free_urb(ushc->int_urb);
404         usb_free_urb(ushc->csw_urb);
405         usb_free_urb(ushc->data_urb);
406         usb_free_urb(ushc->cbw_urb);
407 
408         kfree(ushc->int_data);
409         kfree(ushc->cbw);
410         kfree(ushc->csw);
411 
412         mmc_free_host(ushc->mmc);
413 }
414 
415 static const struct mmc_host_ops ushc_ops = {
416         .request         = ushc_request,
417         .set_ios         = ushc_set_ios,
418         .get_cd          = ushc_get_cd,
419         .enable_sdio_irq = ushc_enable_sdio_irq,
420 };
421 
422 static int ushc_probe(struct usb_interface *intf, const struct usb_device_id *id)
423 {
424         struct usb_device *usb_dev = interface_to_usbdev(intf);
425         struct mmc_host *mmc;
426         struct ushc_data *ushc;
427         int ret;
428 
429         mmc = mmc_alloc_host(sizeof(struct ushc_data), &intf->dev);
430         if (mmc == NULL)
431                 return -ENOMEM;
432         ushc = mmc_priv(mmc);
433         usb_set_intfdata(intf, ushc);
434 
435         ushc->usb_dev = usb_dev;
436         ushc->mmc = mmc;
437 
438         spin_lock_init(&ushc->lock);
439 
440         ret = ushc_hw_reset(ushc);
441         if (ret < 0)
442                 goto err;
443 
444         /* Read capabilities. */
445         ret = ushc_hw_get_caps(ushc);
446         if (ret < 0)
447                 goto err;
448 
449         mmc->ops = &ushc_ops;
450 
451         mmc->f_min = 400000;
452         mmc->f_max = 50000000;
453         mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
454         mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ;
455         mmc->caps |= (ushc->caps & USHC_GET_CAPS_HIGH_SPD) ? MMC_CAP_SD_HIGHSPEED : 0;
456 
457         mmc->max_seg_size  = 512*511;
458         mmc->max_segs      = 1;
459         mmc->max_req_size  = 512*511;
460         mmc->max_blk_size  = 512;
461         mmc->max_blk_count = 511;
462 
463         ushc->int_urb = usb_alloc_urb(0, GFP_KERNEL);
464         if (ushc->int_urb == NULL) {
465                 ret = -ENOMEM;
466                 goto err;
467         }
468         ushc->int_data = kzalloc(sizeof(struct ushc_int_data), GFP_KERNEL);
469         if (ushc->int_data == NULL) {
470                 ret = -ENOMEM;
471                 goto err;
472         }
473         usb_fill_int_urb(ushc->int_urb, ushc->usb_dev,
474                          usb_rcvintpipe(usb_dev,
475                                         intf->cur_altsetting->endpoint[0].desc.bEndpointAddress),
476                          ushc->int_data, sizeof(struct ushc_int_data),
477                          int_callback, ushc,
478                          intf->cur_altsetting->endpoint[0].desc.bInterval);
479 
480         ushc->cbw_urb = usb_alloc_urb(0, GFP_KERNEL);
481         if (ushc->cbw_urb == NULL) {
482                 ret = -ENOMEM;
483                 goto err;
484         }
485         ushc->cbw = kzalloc(sizeof(struct ushc_cbw), GFP_KERNEL);
486         if (ushc->cbw == NULL) {
487                 ret = -ENOMEM;
488                 goto err;
489         }
490         ushc->cbw->signature = USHC_CBW_SIGNATURE;
491 
492         usb_fill_bulk_urb(ushc->cbw_urb, ushc->usb_dev, usb_sndbulkpipe(usb_dev, 2),
493                           ushc->cbw, sizeof(struct ushc_cbw),
494                           cbw_callback, ushc);
495 
496         ushc->data_urb = usb_alloc_urb(0, GFP_KERNEL);
497         if (ushc->data_urb == NULL) {
498                 ret = -ENOMEM;
499                 goto err;
500         }
501 
502         ushc->csw_urb = usb_alloc_urb(0, GFP_KERNEL);
503         if (ushc->csw_urb == NULL) {
504                 ret = -ENOMEM;
505                 goto err;
506         }
507         ushc->csw = kzalloc(sizeof(struct ushc_csw), GFP_KERNEL);
508         if (ushc->csw == NULL) {
509                 ret = -ENOMEM;
510                 goto err;
511         }
512         usb_fill_bulk_urb(ushc->csw_urb, ushc->usb_dev, usb_rcvbulkpipe(usb_dev, 6),
513                           ushc->csw, sizeof(struct ushc_csw),
514                           csw_callback, ushc);
515 
516         ret = mmc_add_host(ushc->mmc);
517         if (ret)
518                 goto err;
519 
520         ret = usb_submit_urb(ushc->int_urb, GFP_KERNEL);
521         if (ret < 0) {
522                 mmc_remove_host(ushc->mmc);
523                 goto err;
524         }
525 
526         return 0;
527 
528 err:
529         ushc_clean_up(ushc);
530         return ret;
531 }
532 
533 static void ushc_disconnect(struct usb_interface *intf)
534 {
535         struct ushc_data *ushc = usb_get_intfdata(intf);
536 
537         spin_lock_irq(&ushc->lock);
538         set_bit(DISCONNECTED, &ushc->flags);
539         spin_unlock_irq(&ushc->lock);
540 
541         usb_kill_urb(ushc->int_urb);
542         usb_kill_urb(ushc->cbw_urb);
543         usb_kill_urb(ushc->data_urb);
544         usb_kill_urb(ushc->csw_urb);
545 
546         mmc_remove_host(ushc->mmc);
547 
548         ushc_clean_up(ushc);
549 }
550 
551 static struct usb_device_id ushc_id_table[] = {
552         /* CSR USB SD Host Controller */
553         { USB_DEVICE(0x0a12, 0x5d10) },
554         { },
555 };
556 MODULE_DEVICE_TABLE(usb, ushc_id_table);
557 
558 static struct usb_driver ushc_driver = {
559         .name       = "ushc",
560         .id_table   = ushc_id_table,
561         .probe      = ushc_probe,
562         .disconnect = ushc_disconnect,
563 };
564 
565 module_usb_driver(ushc_driver);
566 
567 MODULE_DESCRIPTION("USB SD Host Controller driver");
568 MODULE_AUTHOR("David Vrabel <david.vrabel@csr.com>");
569 MODULE_LICENSE("GPL");
570 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us