1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Sony MemoryStick support 4 * 5 * Copyright (C) 2007 Alex Dubov <oakad@yahoo.com> 6 * 7 * Special thanks to Carlos Corbacho for providing various MemoryStick cards 8 * that made this driver possible. 9 */ 10 11 #include <linux/memstick.h> 12 #include <linux/idr.h> 13 #include <linux/fs.h> 14 #include <linux/delay.h> 15 #include <linux/slab.h> 16 #include <linux/module.h> 17 #include <linux/pm_runtime.h> 18 19 #define DRIVER_NAME "memstick" 20 21 static unsigned int cmd_retries = 3; 22 module_param(cmd_retries, uint, 0644); 23 24 static struct workqueue_struct *workqueue; 25 static DEFINE_IDR(memstick_host_idr); 26 static DEFINE_SPINLOCK(memstick_host_lock); 27 28 static int memstick_dev_match(struct memstick_dev *card, 29 const struct memstick_device_id *id) 30 { 31 if (id->match_flags & MEMSTICK_MATCH_ALL) { 32 if ((id->type == card->id.type) 33 && (id->category == card->id.category) 34 && (id->class == card->id.class)) 35 return 1; 36 } 37 38 return 0; 39 } 40 41 static int memstick_bus_match(struct device *dev, const struct device_driver *drv) 42 { 43 struct memstick_dev *card = container_of(dev, struct memstick_dev, 44 dev); 45 const struct memstick_driver *ms_drv = container_of_const(drv, struct memstick_driver, 46 driver); 47 const struct memstick_device_id *ids = ms_drv->id_table; 48 49 if (ids) { 50 while (ids->match_flags) { 51 if (memstick_dev_match(card, ids)) 52 return 1; 53 ++ids; 54 } 55 } 56 return 0; 57 } 58 59 static int memstick_uevent(const struct device *dev, struct kobj_uevent_env *env) 60 { 61 const struct memstick_dev *card = container_of_const(dev, struct memstick_dev, 62 dev); 63 64 if (add_uevent_var(env, "MEMSTICK_TYPE=%02X", card->id.type)) 65 return -ENOMEM; 66 67 if (add_uevent_var(env, "MEMSTICK_CATEGORY=%02X", card->id.category)) 68 return -ENOMEM; 69 70 if (add_uevent_var(env, "MEMSTICK_CLASS=%02X", card->id.class)) 71 return -ENOMEM; 72 73 return 0; 74 } 75 76 static int memstick_device_probe(struct device *dev) 77 { 78 struct memstick_dev *card = container_of(dev, struct memstick_dev, 79 dev); 80 struct memstick_driver *drv = container_of(dev->driver, 81 struct memstick_driver, 82 driver); 83 int rc = -ENODEV; 84 85 if (dev->driver && drv->probe) { 86 rc = drv->probe(card); 87 if (!rc) 88 get_device(dev); 89 } 90 return rc; 91 } 92 93 static void memstick_device_remove(struct device *dev) 94 { 95 struct memstick_dev *card = container_of(dev, struct memstick_dev, 96 dev); 97 struct memstick_driver *drv = container_of(dev->driver, 98 struct memstick_driver, 99 driver); 100 101 if (dev->driver && drv->remove) { 102 drv->remove(card); 103 card->dev.driver = NULL; 104 } 105 106 put_device(dev); 107 } 108 109 #ifdef CONFIG_PM 110 111 static int memstick_device_suspend(struct device *dev, pm_message_t state) 112 { 113 struct memstick_dev *card = container_of(dev, struct memstick_dev, 114 dev); 115 struct memstick_driver *drv = container_of(dev->driver, 116 struct memstick_driver, 117 driver); 118 119 if (dev->driver && drv->suspend) 120 return drv->suspend(card, state); 121 return 0; 122 } 123 124 static int memstick_device_resume(struct device *dev) 125 { 126 struct memstick_dev *card = container_of(dev, struct memstick_dev, 127 dev); 128 struct memstick_driver *drv = container_of(dev->driver, 129 struct memstick_driver, 130 driver); 131 132 if (dev->driver && drv->resume) 133 return drv->resume(card); 134 return 0; 135 } 136 137 #else 138 139 #define memstick_device_suspend NULL 140 #define memstick_device_resume NULL 141 142 #endif /* CONFIG_PM */ 143 144 #define MEMSTICK_ATTR(name, format) \ 145 static ssize_t name##_show(struct device *dev, struct device_attribute *attr, \ 146 char *buf) \ 147 { \ 148 struct memstick_dev *card = container_of(dev, struct memstick_dev, \ 149 dev); \ 150 return sprintf(buf, format, card->id.name); \ 151 } \ 152 static DEVICE_ATTR_RO(name); 153 154 MEMSTICK_ATTR(type, "%02X"); 155 MEMSTICK_ATTR(category, "%02X"); 156 MEMSTICK_ATTR(class, "%02X"); 157 158 static struct attribute *memstick_dev_attrs[] = { 159 &dev_attr_type.attr, 160 &dev_attr_category.attr, 161 &dev_attr_class.attr, 162 NULL, 163 }; 164 ATTRIBUTE_GROUPS(memstick_dev); 165 166 static const struct bus_type memstick_bus_type = { 167 .name = "memstick", 168 .dev_groups = memstick_dev_groups, 169 .match = memstick_bus_match, 170 .uevent = memstick_uevent, 171 .probe = memstick_device_probe, 172 .remove = memstick_device_remove, 173 .suspend = memstick_device_suspend, 174 .resume = memstick_device_resume 175 }; 176 177 static void memstick_free(struct device *dev) 178 { 179 struct memstick_host *host = container_of(dev, struct memstick_host, 180 dev); 181 kfree(host); 182 } 183 184 static struct class memstick_host_class = { 185 .name = "memstick_host", 186 .dev_release = memstick_free 187 }; 188 189 static void memstick_free_card(struct device *dev) 190 { 191 struct memstick_dev *card = container_of(dev, struct memstick_dev, 192 dev); 193 kfree(card); 194 } 195 196 static int memstick_dummy_check(struct memstick_dev *card) 197 { 198 return 0; 199 } 200 201 /** 202 * memstick_detect_change - schedule media detection on memstick host 203 * @host: host to use 204 */ 205 void memstick_detect_change(struct memstick_host *host) 206 { 207 queue_work(workqueue, &host->media_checker); 208 } 209 EXPORT_SYMBOL(memstick_detect_change); 210 211 /** 212 * memstick_next_req - called by host driver to obtain next request to process 213 * @host: host to use 214 * @mrq: pointer to stick the request to 215 * 216 * Host calls this function from idle state (*mrq == NULL) or after finishing 217 * previous request (*mrq should point to it). If previous request was 218 * unsuccessful, it is retried for predetermined number of times. 219 * 220 * Returns: value of 0 means that new request was assigned to the host. 221 * Otherwise a negative error code is returned. 222 */ 223 int memstick_next_req(struct memstick_host *host, struct memstick_request **mrq) 224 { 225 int rc = -ENXIO; 226 227 if ((*mrq) && (*mrq)->error && host->retries) { 228 (*mrq)->error = rc; 229 host->retries--; 230 return 0; 231 } 232 233 if (host->card && host->card->next_request) 234 rc = host->card->next_request(host->card, mrq); 235 236 if (!rc) 237 host->retries = cmd_retries > 1 ? cmd_retries - 1 : 1; 238 else 239 *mrq = NULL; 240 241 return rc; 242 } 243 EXPORT_SYMBOL(memstick_next_req); 244 245 /** 246 * memstick_new_req - notify the host that some requests are pending 247 * @host: host to use 248 */ 249 void memstick_new_req(struct memstick_host *host) 250 { 251 if (host->card) { 252 host->retries = cmd_retries; 253 reinit_completion(&host->card->mrq_complete); 254 host->request(host); 255 } 256 } 257 EXPORT_SYMBOL(memstick_new_req); 258 259 /** 260 * memstick_init_req_sg - set request fields needed for bulk data transfer 261 * @mrq: request to use 262 * @tpc: memstick Transport Protocol Command 263 * @sg: TPC argument 264 */ 265 void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc, 266 const struct scatterlist *sg) 267 { 268 mrq->tpc = tpc; 269 if (tpc & 8) 270 mrq->data_dir = WRITE; 271 else 272 mrq->data_dir = READ; 273 274 mrq->sg = *sg; 275 mrq->long_data = 1; 276 277 if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD) 278 mrq->need_card_int = 1; 279 else 280 mrq->need_card_int = 0; 281 } 282 EXPORT_SYMBOL(memstick_init_req_sg); 283 284 /** 285 * memstick_init_req - set request fields needed for short data transfer 286 * @mrq: request to use 287 * @tpc: memstick Transport Protocol Command 288 * @buf: TPC argument buffer 289 * @length: TPC argument size 290 * 291 * The intended use of this function (transfer of data items several bytes 292 * in size) allows us to just copy the value between request structure and 293 * user supplied buffer. 294 */ 295 void memstick_init_req(struct memstick_request *mrq, unsigned char tpc, 296 const void *buf, size_t length) 297 { 298 mrq->tpc = tpc; 299 if (tpc & 8) 300 mrq->data_dir = WRITE; 301 else 302 mrq->data_dir = READ; 303 304 mrq->data_len = length > sizeof(mrq->data) ? sizeof(mrq->data) : length; 305 if (mrq->data_dir == WRITE) 306 memcpy(mrq->data, buf, mrq->data_len); 307 308 mrq->long_data = 0; 309 310 if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD) 311 mrq->need_card_int = 1; 312 else 313 mrq->need_card_int = 0; 314 } 315 EXPORT_SYMBOL(memstick_init_req); 316 317 /* 318 * Functions prefixed with "h_" are protocol callbacks. They can be called from 319 * interrupt context. Return value of 0 means that request processing is still 320 * ongoing, while special error value of -EAGAIN means that current request is 321 * finished (and request processor should come back some time later). 322 */ 323 324 static int h_memstick_read_dev_id(struct memstick_dev *card, 325 struct memstick_request **mrq) 326 { 327 struct ms_id_register id_reg = {}; 328 329 if (!(*mrq)) { 330 memstick_init_req(&card->current_mrq, MS_TPC_READ_REG, &id_reg, 331 sizeof(struct ms_id_register)); 332 *mrq = &card->current_mrq; 333 return 0; 334 } 335 if (!(*mrq)->error) { 336 memcpy(&id_reg, (*mrq)->data, sizeof(id_reg)); 337 card->id.match_flags = MEMSTICK_MATCH_ALL; 338 card->id.type = id_reg.type; 339 card->id.category = id_reg.category; 340 card->id.class = id_reg.class; 341 dev_dbg(&card->dev, "if_mode = %02x\n", id_reg.if_mode); 342 } 343 complete(&card->mrq_complete); 344 return -EAGAIN; 345 } 346 347 static int h_memstick_set_rw_addr(struct memstick_dev *card, 348 struct memstick_request **mrq) 349 { 350 if (!(*mrq)) { 351 memstick_init_req(&card->current_mrq, MS_TPC_SET_RW_REG_ADRS, 352 (char *)&card->reg_addr, 353 sizeof(card->reg_addr)); 354 *mrq = &card->current_mrq; 355 return 0; 356 } else { 357 complete(&card->mrq_complete); 358 return -EAGAIN; 359 } 360 } 361 362 /** 363 * memstick_set_rw_addr - issue SET_RW_REG_ADDR request and wait for it to 364 * complete 365 * @card: media device to use 366 * 367 * Returns: error setting for the current request 368 */ 369 int memstick_set_rw_addr(struct memstick_dev *card) 370 { 371 card->next_request = h_memstick_set_rw_addr; 372 memstick_new_req(card->host); 373 if (!wait_for_completion_timeout(&card->mrq_complete, 374 msecs_to_jiffies(500))) 375 card->current_mrq.error = -ETIMEDOUT; 376 377 return card->current_mrq.error; 378 } 379 EXPORT_SYMBOL(memstick_set_rw_addr); 380 381 static struct memstick_dev *memstick_alloc_card(struct memstick_host *host) 382 { 383 struct memstick_dev *card = kzalloc_obj(struct memstick_dev, GFP_KERNEL); 384 struct memstick_dev *old_card = host->card; 385 struct ms_id_register id_reg; 386 387 if (card) { 388 card->host = host; 389 dev_set_name(&card->dev, "%s", dev_name(&host->dev)); 390 card->dev.parent = &host->dev; 391 card->dev.bus = &memstick_bus_type; 392 card->dev.release = memstick_free_card; 393 card->check = memstick_dummy_check; 394 395 card->reg_addr.r_offset = offsetof(struct ms_register, id); 396 card->reg_addr.r_length = sizeof(id_reg); 397 card->reg_addr.w_offset = offsetof(struct ms_register, id); 398 card->reg_addr.w_length = sizeof(id_reg); 399 400 init_completion(&card->mrq_complete); 401 402 host->card = card; 403 if (memstick_set_rw_addr(card)) 404 goto err_out; 405 406 card->next_request = h_memstick_read_dev_id; 407 memstick_new_req(host); 408 if (!wait_for_completion_timeout(&card->mrq_complete, 409 msecs_to_jiffies(500))) 410 card->current_mrq.error = -ETIMEDOUT; 411 412 if (card->current_mrq.error) 413 goto err_out; 414 } 415 host->card = old_card; 416 return card; 417 err_out: 418 host->card = old_card; 419 kfree_const(card->dev.kobj.name); 420 kfree(card); 421 return NULL; 422 } 423 424 static int memstick_power_on(struct memstick_host *host) 425 { 426 int rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON); 427 428 if (!rc) 429 rc = host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL); 430 431 return rc; 432 } 433 434 static void memstick_check(struct work_struct *work) 435 { 436 struct memstick_host *host = container_of(work, struct memstick_host, 437 media_checker); 438 struct memstick_dev *card; 439 440 dev_dbg(&host->dev, "memstick_check started\n"); 441 pm_runtime_get_noresume(host->dev.parent); 442 mutex_lock(&host->lock); 443 if (!host->card) { 444 if (memstick_power_on(host)) 445 goto out_power_off; 446 } else if (host->card->stop) 447 host->card->stop(host->card); 448 449 if (host->removing) 450 goto out_power_off; 451 452 card = memstick_alloc_card(host); 453 454 if (!card) { 455 if (host->card) { 456 device_unregister(&host->card->dev); 457 host->card = NULL; 458 } 459 } else { 460 dev_dbg(&host->dev, "new card %02x, %02x, %02x\n", 461 card->id.type, card->id.category, card->id.class); 462 if (host->card) { 463 if (memstick_set_rw_addr(host->card) 464 || !memstick_dev_match(host->card, &card->id) 465 || !(host->card->check(host->card))) { 466 device_unregister(&host->card->dev); 467 host->card = NULL; 468 } else if (host->card->start) 469 host->card->start(host->card); 470 } 471 472 if (!host->card) { 473 host->card = card; 474 if (device_register(&card->dev)) { 475 put_device(&card->dev); 476 host->card = NULL; 477 } 478 } else { 479 kfree_const(card->dev.kobj.name); 480 kfree(card); 481 } 482 } 483 484 out_power_off: 485 if (!host->card) 486 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF); 487 488 mutex_unlock(&host->lock); 489 pm_runtime_put(host->dev.parent); 490 dev_dbg(&host->dev, "memstick_check finished\n"); 491 } 492 493 /** 494 * memstick_alloc_host - allocate a memstick_host structure 495 * @extra: size of the user private data to allocate 496 * @dev: parent device of the host 497 * 498 * Returns: %NULL on failure or the allocated &memstick_host pointer on success 499 */ 500 struct memstick_host *memstick_alloc_host(unsigned int extra, 501 struct device *dev) 502 { 503 struct memstick_host *host; 504 505 host = kzalloc(sizeof(struct memstick_host) + extra, GFP_KERNEL); 506 if (host) { 507 mutex_init(&host->lock); 508 INIT_WORK(&host->media_checker, memstick_check); 509 host->dev.class = &memstick_host_class; 510 host->dev.parent = dev; 511 device_initialize(&host->dev); 512 } 513 return host; 514 } 515 EXPORT_SYMBOL(memstick_alloc_host); 516 517 /** 518 * memstick_add_host - start request processing on memstick host 519 * @host: host to use 520 * 521 * Returns: %0 on success or a negative error code on failure 522 */ 523 int memstick_add_host(struct memstick_host *host) 524 { 525 int rc; 526 527 idr_preload(GFP_KERNEL); 528 spin_lock(&memstick_host_lock); 529 530 rc = idr_alloc(&memstick_host_idr, host, 0, 0, GFP_NOWAIT); 531 if (rc >= 0) 532 host->id = rc; 533 534 spin_unlock(&memstick_host_lock); 535 idr_preload_end(); 536 if (rc < 0) 537 return rc; 538 539 dev_set_name(&host->dev, "memstick%u", host->id); 540 541 rc = device_add(&host->dev); 542 if (rc) { 543 spin_lock(&memstick_host_lock); 544 idr_remove(&memstick_host_idr, host->id); 545 spin_unlock(&memstick_host_lock); 546 return rc; 547 } 548 549 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF); 550 memstick_detect_change(host); 551 return 0; 552 } 553 EXPORT_SYMBOL(memstick_add_host); 554 555 /** 556 * memstick_remove_host - stop request processing on memstick host 557 * @host: host to use 558 */ 559 void memstick_remove_host(struct memstick_host *host) 560 { 561 flush_workqueue(workqueue); 562 mutex_lock(&host->lock); 563 if (host->card) 564 device_unregister(&host->card->dev); 565 host->card = NULL; 566 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF); 567 mutex_unlock(&host->lock); 568 569 spin_lock(&memstick_host_lock); 570 idr_remove(&memstick_host_idr, host->id); 571 spin_unlock(&memstick_host_lock); 572 device_del(&host->dev); 573 } 574 EXPORT_SYMBOL(memstick_remove_host); 575 576 /** 577 * memstick_free_host - free memstick host 578 * @host: host to use 579 */ 580 void memstick_free_host(struct memstick_host *host) 581 { 582 mutex_destroy(&host->lock); 583 put_device(&host->dev); 584 } 585 EXPORT_SYMBOL(memstick_free_host); 586 587 /** 588 * memstick_suspend_host - notify bus driver of host suspension 589 * @host: host to use 590 */ 591 void memstick_suspend_host(struct memstick_host *host) 592 { 593 mutex_lock(&host->lock); 594 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF); 595 mutex_unlock(&host->lock); 596 } 597 EXPORT_SYMBOL(memstick_suspend_host); 598 599 /** 600 * memstick_resume_host - notify bus driver of host resumption 601 * @host: host to use 602 */ 603 void memstick_resume_host(struct memstick_host *host) 604 { 605 int rc = 0; 606 607 mutex_lock(&host->lock); 608 if (host->card) 609 rc = memstick_power_on(host); 610 mutex_unlock(&host->lock); 611 612 if (!rc) 613 memstick_detect_change(host); 614 } 615 EXPORT_SYMBOL(memstick_resume_host); 616 617 int memstick_register_driver(struct memstick_driver *drv) 618 { 619 drv->driver.bus = &memstick_bus_type; 620 621 return driver_register(&drv->driver); 622 } 623 EXPORT_SYMBOL(memstick_register_driver); 624 625 void memstick_unregister_driver(struct memstick_driver *drv) 626 { 627 driver_unregister(&drv->driver); 628 } 629 EXPORT_SYMBOL(memstick_unregister_driver); 630 631 632 static int __init memstick_init(void) 633 { 634 int rc; 635 636 workqueue = create_freezable_workqueue("kmemstick"); 637 if (!workqueue) 638 return -ENOMEM; 639 640 rc = bus_register(&memstick_bus_type); 641 if (rc) 642 goto error_destroy_workqueue; 643 644 rc = class_register(&memstick_host_class); 645 if (rc) 646 goto error_bus_unregister; 647 648 return 0; 649 650 error_bus_unregister: 651 bus_unregister(&memstick_bus_type); 652 error_destroy_workqueue: 653 destroy_workqueue(workqueue); 654 655 return rc; 656 } 657 658 static void __exit memstick_exit(void) 659 { 660 class_unregister(&memstick_host_class); 661 bus_unregister(&memstick_bus_type); 662 destroy_workqueue(workqueue); 663 idr_destroy(&memstick_host_idr); 664 } 665 666 module_init(memstick_init); 667 module_exit(memstick_exit); 668 669 MODULE_AUTHOR("Alex Dubov"); 670 MODULE_LICENSE("GPL"); 671 MODULE_DESCRIPTION("Sony MemoryStick core driver"); 672