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