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/usb.h>
  23 #include <linux/slab.h>
  24 #include <linux/dma-mapping.h>
  25 #include <linux/mmc/host.h>
  26
  27 enum ushc_request {
  28         USHC_GET_CAPS  = 0x00,
  29         USHC_HOST_CTRL = 0x01,
  30         USHC_PWR_CTRL  = 0x02,
  31         USHC_CLK_FREQ  = 0x03,
  32         USHC_EXEC_CMD  = 0x04,
  33         USHC_READ_RESP = 0x05,
  34         USHC_RESET     = 0x06,
  35 };
  36
  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,
  45 };
  46
  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)
  52
  53 #define USHC_HOST_CTRL_4BIT     (1 << 1)
  54 #define USHC_HOST_CTRL_HIGH_SPD (1 << 0)
  55
  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
  60
  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
  67
  68 struct ushc_cbw {
  69         __u8 signature;
  70         __u8 cmd_idx;
  71         __le16 block_size;
  72         __le32 arg;
  73 } __attribute__((packed));
  74
  75 #define USHC_CBW_SIGNATURE 'C'
  76
  77 struct ushc_csw {
  78         __u8 signature;
  79         __u8 status;
  80         __le32 response;
  81 } __attribute__((packed));
  82
  83 #define USHC_CSW_SIGNATURE 'S'
  84
  85 struct ushc_int_data {
  86         u8 status;
  87         u8 reserved[3];
  88 };
  89
  90 #define USHC_INT_STATUS_SDIO_INT     (1 << 1)
  91 #define USHC_INT_STATUS_CARD_PRESENT (1 << 0)
  92
  93
  94 struct ushc_data {
  95         struct usb_device *usb_dev;
  96         struct mmc_host *mmc;
  97
  98         struct urb *int_urb;
  99         struct ushc_int_data *int_data;
 100
 101         struct urb *cbw_urb;
 102         struct ushc_cbw *cbw;
 103
 104         struct urb *data_urb;
 105
 106         struct urb *csw_urb;
 107         struct ushc_csw *csw;
 108
 109         spinlock_t lock;
 110         struct mmc_request *current_req;
 111         u32 caps;
 112         u16 host_ctrl;
 113         unsigned long flags;
 114         u8 last_status;
 115         int clock_freq;
 116 };
 117
 118 #define DISCONNECTED    0
 119 #define INT_EN          1
 120 #define IGNORE_NEXT_INT 2
 121
 122 static void data_callback(struct urb *urb);
 123
 124 static int ushc_hw_reset(struct ushc_data *ushc)
 125 {
 126         return usb_control_msg(ushc->usb_dev, usb_sndctrlpipe(ushc->usb_dev, 0),
 127                                USHC_RESET, USHC_RESET_TYPE,
 128                                0, 0, NULL, 0, 100);
 129 }
 130
 131 static int ushc_hw_get_caps(struct ushc_data *ushc)
 132 {
 133         int ret;
 134         int version;
 135
 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);
 139         if (ret < 0)
 140                 return ret;
 141
 142         ushc->caps = le32_to_cpu(ushc->caps);
 143
 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);
 147                 return -EINVAL;
 148         }
 149
 150         return 0;
 151 }
 152
 153 static int ushc_hw_set_host_ctrl(struct ushc_data *ushc, u16 mask, u16 val)
 154 {
 155         u16 host_ctrl;
 156         int ret;
 157
 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);
 162         if (ret < 0)
 163                 return ret;
 164         ushc->host_ctrl = host_ctrl;
 165         return 0;
 166 }
 167
 168 static void int_callback(struct urb *urb)
 169 {
 170         struct ushc_data *ushc = urb->context;
 171         u8 status, last_status;
 172
 173         if (urb->status < 0)
 174                 return;
 175
 176         status = ushc->int_data->status;
 177         last_status = ushc->last_status;
 178         ushc->last_status = status;
 179
 180         /*
 181          * Ignore the card interrupt status on interrupt transfers that
 182          * were submitted while card interrupts where disabled.
 183          *
 184          * This avoid occasional spurious interrupts when enabling
 185          * interrupts immediately after clearing the source on the card.
 186          */
 187
 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);
 192         }
 193
 194         if ((status ^ last_status) & USHC_INT_STATUS_CARD_PRESENT)
 195                 mmc_detect_change(ushc->mmc, msecs_to_jiffies(100));
 196
 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);
 200 }
 201
 202 static void cbw_callback(struct urb *urb)
 203 {
 204         struct ushc_data *ushc = urb->context;
 205
 206         if (urb->status != 0) {
 207                 usb_unlink_urb(ushc->data_urb);
 208                 usb_unlink_urb(ushc->csw_urb);
 209         }
 210 }
 211
 212 static void data_callback(struct urb *urb)
 213 {
 214         struct ushc_data *ushc = urb->context;
 215
 216         if (urb->status != 0)
 217                 usb_unlink_urb(ushc->csw_urb);
 218 }
 219
 220 static void csw_callback(struct urb *urb)
 221 {
 222         struct ushc_data *ushc = urb->context;
 223         struct mmc_request *req = ushc->current_req;
 224         int status;
 225
 226         status = ushc->csw->status;
 227
 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;
 233                 else
 234                         req->cmd->error = -ETIMEDOUT;
 235         }
 236         if (req->data) {
 237                 if (status & USHC_READ_RESP_ERR_DAT) {
 238                         if (status & USHC_READ_RESP_ERR_CRC)
 239                                 req->data->error = -EIO;
 240                         else
 241                                 req->data->error = -ETIMEDOUT;
 242                         req->data->bytes_xfered = 0;
 243                 } else {
 244                         req->data->bytes_xfered = req->data->blksz * req->data->blocks;
 245                 }
 246         }
 247
 248         req->cmd->resp[0] = le32_to_cpu(ushc->csw->response);
 249
 250         mmc_request_done(ushc->mmc, req);
 251 }
 252
 253 static void ushc_request(struct mmc_host *mmc, struct mmc_request *req)
 254 {
 255         struct ushc_data *ushc = mmc_priv(mmc);
 256         int ret;
 257         unsigned long flags;
 258
 259         spin_lock_irqsave(&ushc->lock, flags);
 260
 261         if (test_bit(DISCONNECTED, &ushc->flags)) {
 262                 ret = -ENODEV;
 263                 goto out;
 264         }
 265
 266         /* Version 2 firmware doesn't support the R2 response format. */
 267         if (req->cmd->flags & MMC_RSP_136) {
 268                 ret = -EINVAL;
 269                 goto out;
 270         }
 271
 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) {
 275                 ret = -EINVAL;
 276                 goto out;
 277         }
 278
 279         ushc->current_req = req;
 280
 281         /* Start cmd with CBW. */
 282         ushc->cbw->cmd_idx = cpu_to_le16(req->cmd->opcode);
 283         if (req->data)
 284                 ushc->cbw->block_size = cpu_to_le16(req->data->blksz);
 285         else
 286                 ushc->cbw->block_size = 0;
 287         ushc->cbw->arg = cpu_to_le32(req->cmd->arg);
 288
 289         ret = usb_submit_urb(ushc->cbw_urb, GFP_ATOMIC);
 290         if (ret < 0)
 291                 goto out;
 292
 293         /* Submit data (if any). */
 294         if (req->data) {
 295                 struct mmc_data *data = req->data;
 296                 int pipe;
 297
 298                 if (data->flags & MMC_DATA_READ)
 299                         pipe = usb_rcvbulkpipe(ushc->usb_dev, 6);
 300                 else
 301                         pipe = usb_sndbulkpipe(ushc->usb_dev, 2);
 302
 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);
 307                 if (ret < 0)
 308                         goto out;
 309         }
 310
 311         /* Submit CSW. */
 312         ret = usb_submit_urb(ushc->csw_urb, GFP_ATOMIC);
 313         if (ret < 0)
 314                 goto out;
 315
 316 out:
 317         spin_unlock_irqrestore(&ushc->lock, flags);
 318         if (ret < 0) {
 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);
 323         }
 324 }
 325
 326 static int ushc_set_power(struct ushc_data *ushc, unsigned char power_mode)
 327 {
 328         u16 voltage;
 329
 330         switch (power_mode) {
 331         case MMC_POWER_OFF:
 332                 voltage = USHC_PWR_CTRL_OFF;
 333                 break;
 334         case MMC_POWER_UP:
 335         case MMC_POWER_ON:
 336                 voltage = USHC_PWR_CTRL_3V3;
 337                 break;
 338         default:
 339                 return -EINVAL;
 340         }
 341
 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);
 345 }
 346
 347 static int ushc_set_bus_width(struct ushc_data *ushc, int bus_width)
 348 {
 349         return ushc_hw_set_host_ctrl(ushc, USHC_HOST_CTRL_4BIT,
 350                                      bus_width == 4 ? USHC_HOST_CTRL_4BIT : 0);
 351 }
 352
 353 static int ushc_set_bus_freq(struct ushc_data *ushc, int clk, bool enable_hs)
 354 {
 355         int ret;
 356
 357         /* Hardware can't detect interrupts while the clock is off. */
 358         if (clk == 0)
 359                 clk = 400000;
 360
 361         ret = ushc_hw_set_host_ctrl(ushc, USHC_HOST_CTRL_HIGH_SPD,
 362                                     enable_hs ? USHC_HOST_CTRL_HIGH_SPD : 0);
 363         if (ret < 0)
 364                 return ret;
 365
 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);
 369         if (ret < 0)
 370                 return ret;
 371
 372         ushc->clock_freq = clk;
 373         return 0;
 374 }
 375
 376 static void ushc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 377 {
 378         struct ushc_data *ushc = mmc_priv(mmc);
 379
 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);
 383 }
 384
 385 static int ushc_get_cd(struct mmc_host *mmc)
 386 {
 387         struct ushc_data *ushc = mmc_priv(mmc);
 388
 389         return !!(ushc->last_status & USHC_INT_STATUS_CARD_PRESENT);
 390 }
 391
 392 static void ushc_enable_sdio_irq(struct mmc_host *mmc, int enable)
 393 {
 394         struct ushc_data *ushc = mmc_priv(mmc);
 395
 396         if (enable)
 397                 set_bit(INT_EN, &ushc->flags);
 398         else
 399                 clear_bit(INT_EN, &ushc->flags);
 400 }
 401
 402 static void ushc_clean_up(struct ushc_data *ushc)
 403 {
 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);
 408
 409         kfree(ushc->int_data);
 410         kfree(ushc->cbw);
 411         kfree(ushc->csw);
 412
 413         mmc_free_host(ushc->mmc);
 414 }
 415
 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,
 421 };
 422
 423 static int ushc_probe(struct usb_interface *intf, const struct usb_device_id *id)
 424 {
 425         struct usb_device *usb_dev = interface_to_usbdev(intf);
 426         struct mmc_host *mmc;
 427         struct ushc_data *ushc;
 428         int ret;
 429
 430         mmc = mmc_alloc_host(sizeof(struct ushc_data), &intf->dev);
 431         if (mmc == NULL)
 432                 return -ENOMEM;
 433         ushc = mmc_priv(mmc);
 434         usb_set_intfdata(intf, ushc);
 435
 436         ushc->usb_dev = usb_dev;
 437         ushc->mmc = mmc;
 438
 439         spin_lock_init(&ushc->lock);
 440
 441         ret = ushc_hw_reset(ushc);
 442         if (ret < 0)
 443                 goto err;
 444
 445         /* Read capabilities. */
 446         ret = ushc_hw_get_caps(ushc);
 447         if (ret < 0)
 448                 goto err;
 449
 450         mmc->ops = &ushc_ops;
 451
 452         mmc->f_min = 400000;
 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;
 457
 458         mmc->max_seg_size  = 512*511;
 459         mmc->max_segs      = 1;
 460         mmc->max_req_size  = 512*511;
 461         mmc->max_blk_size  = 512;
 462         mmc->max_blk_count = 511;
 463
 464         ushc->int_urb = usb_alloc_urb(0, GFP_KERNEL);
 465         if (ushc->int_urb == NULL) {
 466                 ret = -ENOMEM;
 467                 goto err;
 468         }
 469         ushc->int_data = kzalloc(sizeof(struct ushc_int_data), GFP_KERNEL);
 470         if (ushc->int_data == NULL) {
 471                 ret = -ENOMEM;
 472                 goto err;
 473         }
 474         usb_fill_int_urb(ushc->int_urb, ushc->usb_dev,
 475                          usb_rcvintpipe(usb_dev,
 476                                         intf->cur_altsetting->endpoint[0].desc.bEndpointAddress),
 477                          ushc->int_data, sizeof(struct ushc_int_data),
 478                          int_callback, ushc,
 479                          intf->cur_altsetting->endpoint[0].desc.bInterval);
 480
 481         ushc->cbw_urb = usb_alloc_urb(0, GFP_KERNEL);
 482         if (ushc->cbw_urb == NULL) {
 483                 ret = -ENOMEM;
 484                 goto err;
 485         }
 486         ushc->cbw = kzalloc(sizeof(struct ushc_cbw), GFP_KERNEL);
 487         if (ushc->cbw == NULL) {
 488                 ret = -ENOMEM;
 489                 goto err;
 490         }
 491         ushc->cbw->signature = USHC_CBW_SIGNATURE;
 492
 493         usb_fill_bulk_urb(ushc->cbw_urb, ushc->usb_dev, usb_sndbulkpipe(usb_dev, 2),
 494                           ushc->cbw, sizeof(struct ushc_cbw),
 495                           cbw_callback, ushc);
 496
 497         ushc->data_urb = usb_alloc_urb(0, GFP_KERNEL);
 498         if (ushc->data_urb == NULL) {
 499                 ret = -ENOMEM;
 500                 goto err;
 501         }
 502
 503         ushc->csw_urb = usb_alloc_urb(0, GFP_KERNEL);
 504         if (ushc->csw_urb == NULL) {
 505                 ret = -ENOMEM;
 506                 goto err;
 507         }
 508         ushc->csw = kzalloc(sizeof(struct ushc_cbw), GFP_KERNEL);
 509         if (ushc->csw == NULL) {
 510                 ret = -ENOMEM;
 511                 goto err;
 512         }
 513         usb_fill_bulk_urb(ushc->csw_urb, ushc->usb_dev, usb_rcvbulkpipe(usb_dev, 6),
 514                           ushc->csw, sizeof(struct ushc_csw),
 515                           csw_callback, ushc);
 516
 517         ret = mmc_add_host(ushc->mmc);
 518         if (ret)
 519                 goto err;
 520
 521         ret = usb_submit_urb(ushc->int_urb, GFP_KERNEL);
 522         if (ret < 0) {
 523                 mmc_remove_host(ushc->mmc);
 524                 goto err;
 525         }
 526
 527         return 0;
 528
 529 err:
 530         ushc_clean_up(ushc);
 531         return ret;
 532 }
 533
 534 static void ushc_disconnect(struct usb_interface *intf)
 535 {
 536         struct ushc_data *ushc = usb_get_intfdata(intf);
 537
 538         spin_lock_irq(&ushc->lock);
 539         set_bit(DISCONNECTED, &ushc->flags);
 540         spin_unlock_irq(&ushc->lock);
 541
 542         usb_kill_urb(ushc->int_urb);
 543         usb_kill_urb(ushc->cbw_urb);
 544         usb_kill_urb(ushc->data_urb);
 545         usb_kill_urb(ushc->csw_urb);
 546
 547         mmc_remove_host(ushc->mmc);
 548
 549         ushc_clean_up(ushc);
 550 }
 551
 552 static struct usb_device_id ushc_id_table[] = {
 553         /* CSR USB SD Host Controller */
 554         { USB_DEVICE(0x0a12, 0x5d10) },
 555         { },
 556 };
 557 MODULE_DEVICE_TABLE(usb, ushc_id_table);
 558
 559 static struct usb_driver ushc_driver = {
 560         .name       = "ushc",
 561         .id_table   = ushc_id_table,
 562         .probe      = ushc_probe,
 563         .disconnect = ushc_disconnect,
 564 };
 565
 566 static int __init ushc_init(void)
 567 {
 568         return usb_register(&ushc_driver);
 569 }
 570 module_init(ushc_init);
 571
 572 static void __exit ushc_exit(void)
 573 {
 574         usb_deregister(&ushc_driver);
 575 }
 576 module_exit(ushc_exit);
 577
 578 MODULE_DESCRIPTION("USB SD Host Controller driver");
 579 MODULE_AUTHOR("David Vrabel <david.vrabel@csr.com>");
 580 MODULE_LICENSE("GPL");