drivers/memstick/core/memstick.c

   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                               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, struct device_driver *drv)
  42 {
  43         struct memstick_dev *card = container_of(dev, struct memstick_dev,
  44                                                  dev);
  45         struct memstick_driver *ms_drv = container_of(drv,
  46                                                       struct memstick_driver,
  47                                                       driver);
  48         struct memstick_device_id *ids = ms_drv->id_table;
  49
  50         if (ids) {
  51                 while (ids->match_flags) {
  52                         if (memstick_dev_match(card, ids))
  53                                 return 1;
  54                         ++ids;
  55                 }
  56         }
  57         return 0;
  58 }
  59
  60 static int memstick_uevent(struct device *dev, struct kobj_uevent_env *env)
  61 {
  62         struct memstick_dev *card = container_of(dev, struct memstick_dev,
  63                                                   dev);
  64
  65         if (add_uevent_var(env, "MEMSTICK_TYPE=%02X", card->id.type))
  66                 return -ENOMEM;
  67
  68         if (add_uevent_var(env, "MEMSTICK_CATEGORY=%02X", card->id.category))
  69                 return -ENOMEM;
  70
  71         if (add_uevent_var(env, "MEMSTICK_CLASS=%02X", card->id.class))
  72                 return -ENOMEM;
  73
  74         return 0;
  75 }
  76
  77 static int memstick_device_probe(struct device *dev)
  78 {
  79         struct memstick_dev *card = container_of(dev, struct memstick_dev,
  80                                                  dev);
  81         struct memstick_driver *drv = container_of(dev->driver,
  82                                                    struct memstick_driver,
  83                                                    driver);
  84         int rc = -ENODEV;
  85
  86         if (dev->driver && drv->probe) {
  87                 rc = drv->probe(card);
  88                 if (!rc)
  89                         get_device(dev);
  90         }
  91         return rc;
  92 }
  93
  94 static int memstick_device_remove(struct device *dev)
  95 {
  96         struct memstick_dev *card = container_of(dev, struct memstick_dev,
  97                                                   dev);
  98         struct memstick_driver *drv = container_of(dev->driver,
  99                                                    struct memstick_driver,
 100                                                    driver);
 101
 102         if (dev->driver && drv->remove) {
 103                 drv->remove(card);
 104                 card->dev.driver = NULL;
 105         }
 106
 107         put_device(dev);
 108         return 0;
 109 }
 110
 111 #ifdef CONFIG_PM
 112
 113 static int memstick_device_suspend(struct device *dev, pm_message_t state)
 114 {
 115         struct memstick_dev *card = container_of(dev, struct memstick_dev,
 116                                                   dev);
 117         struct memstick_driver *drv = container_of(dev->driver,
 118                                                    struct memstick_driver,
 119                                                    driver);
 120
 121         if (dev->driver && drv->suspend)
 122                 return drv->suspend(card, state);
 123         return 0;
 124 }
 125
 126 static int memstick_device_resume(struct device *dev)
 127 {
 128         struct memstick_dev *card = container_of(dev, struct memstick_dev,
 129                                                   dev);
 130         struct memstick_driver *drv = container_of(dev->driver,
 131                                                    struct memstick_driver,
 132                                                    driver);
 133
 134         if (dev->driver && drv->resume)
 135                 return drv->resume(card);
 136         return 0;
 137 }
 138
 139 #else
 140
 141 #define memstick_device_suspend NULL
 142 #define memstick_device_resume NULL
 143
 144 #endif /* CONFIG_PM */
 145
 146 #define MEMSTICK_ATTR(name, format)                                           \
 147 static ssize_t name##_show(struct device *dev, struct device_attribute *attr, \
 148                             char *buf)                                        \
 149 {                                                                             \
 150         struct memstick_dev *card = container_of(dev, struct memstick_dev,    \
 151                                                  dev);                        \
 152         return sprintf(buf, format, card->id.name);                           \
 153 }                                                                             \
 154 static DEVICE_ATTR_RO(name);
 155
 156 MEMSTICK_ATTR(type, "%02X");
 157 MEMSTICK_ATTR(category, "%02X");
 158 MEMSTICK_ATTR(class, "%02X");
 159
 160 static struct attribute *memstick_dev_attrs[] = {
 161         &dev_attr_type.attr,
 162         &dev_attr_category.attr,
 163         &dev_attr_class.attr,
 164         NULL,
 165 };
 166 ATTRIBUTE_GROUPS(memstick_dev);
 167
 168 static struct bus_type memstick_bus_type = {
 169         .name           = "memstick",
 170         .dev_groups     = memstick_dev_groups,
 171         .match          = memstick_bus_match,
 172         .uevent         = memstick_uevent,
 173         .probe          = memstick_device_probe,
 174         .remove         = memstick_device_remove,
 175         .suspend        = memstick_device_suspend,
 176         .resume         = memstick_device_resume
 177 };
 178
 179 static void memstick_free(struct device *dev)
 180 {
 181         struct memstick_host *host = container_of(dev, struct memstick_host,
 182                                                   dev);
 183         kfree(host);
 184 }
 185
 186 static struct class memstick_host_class = {
 187         .name        = "memstick_host",
 188         .dev_release = memstick_free
 189 };
 190
 191 static void memstick_free_card(struct device *dev)
 192 {
 193         struct memstick_dev *card = container_of(dev, struct memstick_dev,
 194                                                  dev);
 195         kfree(card);
 196 }
 197
 198 static int memstick_dummy_check(struct memstick_dev *card)
 199 {
 200         return 0;
 201 }
 202
 203 /**
 204  * memstick_detect_change - schedule media detection on memstick host
 205  * @host - host to use
 206  */
 207 void memstick_detect_change(struct memstick_host *host)
 208 {
 209         queue_work(workqueue, &host->media_checker);
 210 }
 211 EXPORT_SYMBOL(memstick_detect_change);
 212
 213 /**
 214  * memstick_next_req - called by host driver to obtain next request to process
 215  * @host - host to use
 216  * @mrq - pointer to stick the request to
 217  *
 218  * Host calls this function from idle state (*mrq == NULL) or after finishing
 219  * previous request (*mrq should point to it). If previous request was
 220  * unsuccessful, it is retried for predetermined number of times. Return value
 221  * of 0 means that new request was assigned to the host.
 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         } else {
 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
 348 static int h_memstick_set_rw_addr(struct memstick_dev *card,
 349                                   struct memstick_request **mrq)
 350 {
 351         if (!(*mrq)) {
 352                 memstick_init_req(&card->current_mrq, MS_TPC_SET_RW_REG_ADRS,
 353                                   (char *)&card->reg_addr,
 354                                   sizeof(card->reg_addr));
 355                 *mrq = &card->current_mrq;
 356                 return 0;
 357         } else {
 358                 complete(&card->mrq_complete);
 359                 return -EAGAIN;
 360         }
 361 }
 362
 363 /**
 364  * memstick_set_rw_addr - issue SET_RW_REG_ADDR request and wait for it to
 365  *                        complete
 366  * @card - media device to use
 367  */
 368 int memstick_set_rw_addr(struct memstick_dev *card)
 369 {
 370         card->next_request = h_memstick_set_rw_addr;
 371         memstick_new_req(card->host);
 372         wait_for_completion(&card->mrq_complete);
 373
 374         return card->current_mrq.error;
 375 }
 376 EXPORT_SYMBOL(memstick_set_rw_addr);
 377
 378 static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
 379 {
 380         struct memstick_dev *card = kzalloc(sizeof(struct memstick_dev),
 381                                             GFP_KERNEL);
 382         struct memstick_dev *old_card = host->card;
 383         struct ms_id_register id_reg;
 384
 385         if (card) {
 386                 card->host = host;
 387                 dev_set_name(&card->dev, "%s", dev_name(&host->dev));
 388                 card->dev.parent = &host->dev;
 389                 card->dev.bus = &memstick_bus_type;
 390                 card->dev.release = memstick_free_card;
 391                 card->check = memstick_dummy_check;
 392
 393                 card->reg_addr.r_offset = offsetof(struct ms_register, id);
 394                 card->reg_addr.r_length = sizeof(id_reg);
 395                 card->reg_addr.w_offset = offsetof(struct ms_register, id);
 396                 card->reg_addr.w_length = sizeof(id_reg);
 397
 398                 init_completion(&card->mrq_complete);
 399
 400                 host->card = card;
 401                 if (memstick_set_rw_addr(card))
 402                         goto err_out;
 403
 404                 card->next_request = h_memstick_read_dev_id;
 405                 memstick_new_req(host);
 406                 wait_for_completion(&card->mrq_complete);
 407
 408                 if (card->current_mrq.error)
 409                         goto err_out;
 410         }
 411         host->card = old_card;
 412         return card;
 413 err_out:
 414         host->card = old_card;
 415         kfree_const(card->dev.kobj.name);
 416         kfree(card);
 417         return NULL;
 418 }
 419
 420 static int memstick_power_on(struct memstick_host *host)
 421 {
 422         int rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
 423
 424         if (!rc)
 425                 rc = host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);
 426
 427         return rc;
 428 }
 429
 430 static void memstick_check(struct work_struct *work)
 431 {
 432         struct memstick_host *host = container_of(work, struct memstick_host,
 433                                                   media_checker);
 434         struct memstick_dev *card;
 435
 436         dev_dbg(&host->dev, "memstick_check started\n");
 437         pm_runtime_get_noresume(host->dev.parent);
 438         mutex_lock(&host->lock);
 439         if (!host->card) {
 440                 if (memstick_power_on(host))
 441                         goto out_power_off;
 442         } else if (host->card->stop)
 443                 host->card->stop(host->card);
 444
 445         if (host->removing)
 446                 goto out_power_off;
 447
 448         card = memstick_alloc_card(host);
 449
 450         if (!card) {
 451                 if (host->card) {
 452                         device_unregister(&host->card->dev);
 453                         host->card = NULL;
 454                 }
 455         } else {
 456                 dev_dbg(&host->dev, "new card %02x, %02x, %02x\n",
 457                         card->id.type, card->id.category, card->id.class);
 458                 if (host->card) {
 459                         if (memstick_set_rw_addr(host->card)
 460                             || !memstick_dev_match(host->card, &card->id)
 461                             || !(host->card->check(host->card))) {
 462                                 device_unregister(&host->card->dev);
 463                                 host->card = NULL;
 464                         } else if (host->card->start)
 465                                 host->card->start(host->card);
 466                 }
 467
 468                 if (!host->card) {
 469                         host->card = card;
 470                         if (device_register(&card->dev)) {
 471                                 put_device(&card->dev);
 472                                 host->card = NULL;
 473                         }
 474                 } else {
 475                         kfree_const(card->dev.kobj.name);
 476                         kfree(card);
 477                 }
 478         }
 479
 480 out_power_off:
 481         if (!host->card)
 482                 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
 483
 484         mutex_unlock(&host->lock);
 485         pm_runtime_put(host->dev.parent);
 486         dev_dbg(&host->dev, "memstick_check finished\n");
 487 }
 488
 489 /**
 490  * memstick_alloc_host - allocate a memstick_host structure
 491  * @extra: size of the user private data to allocate
 492  * @dev: parent device of the host
 493  */
 494 struct memstick_host *memstick_alloc_host(unsigned int extra,
 495                                           struct device *dev)
 496 {
 497         struct memstick_host *host;
 498
 499         host = kzalloc(sizeof(struct memstick_host) + extra, GFP_KERNEL);
 500         if (host) {
 501                 mutex_init(&host->lock);
 502                 INIT_WORK(&host->media_checker, memstick_check);
 503                 host->dev.class = &memstick_host_class;
 504                 host->dev.parent = dev;
 505                 device_initialize(&host->dev);
 506         }
 507         return host;
 508 }
 509 EXPORT_SYMBOL(memstick_alloc_host);
 510
 511 /**
 512  * memstick_add_host - start request processing on memstick host
 513  * @host - host to use
 514  */
 515 int memstick_add_host(struct memstick_host *host)
 516 {
 517         int rc;
 518
 519         idr_preload(GFP_KERNEL);
 520         spin_lock(&memstick_host_lock);
 521
 522         rc = idr_alloc(&memstick_host_idr, host, 0, 0, GFP_NOWAIT);
 523         if (rc >= 0)
 524                 host->id = rc;
 525
 526         spin_unlock(&memstick_host_lock);
 527         idr_preload_end();
 528         if (rc < 0)
 529                 return rc;
 530
 531         dev_set_name(&host->dev, "memstick%u", host->id);
 532
 533         rc = device_add(&host->dev);
 534         if (rc) {
 535                 spin_lock(&memstick_host_lock);
 536                 idr_remove(&memstick_host_idr, host->id);
 537                 spin_unlock(&memstick_host_lock);
 538                 return rc;
 539         }
 540
 541         host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
 542         memstick_detect_change(host);
 543         return 0;
 544 }
 545 EXPORT_SYMBOL(memstick_add_host);
 546
 547 /**
 548  * memstick_remove_host - stop request processing on memstick host
 549  * @host - host to use
 550  */
 551 void memstick_remove_host(struct memstick_host *host)
 552 {
 553         host->removing = 1;
 554         flush_workqueue(workqueue);
 555         mutex_lock(&host->lock);
 556         if (host->card)
 557                 device_unregister(&host->card->dev);
 558         host->card = NULL;
 559         host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
 560         mutex_unlock(&host->lock);
 561
 562         spin_lock(&memstick_host_lock);
 563         idr_remove(&memstick_host_idr, host->id);
 564         spin_unlock(&memstick_host_lock);
 565         device_del(&host->dev);
 566 }
 567 EXPORT_SYMBOL(memstick_remove_host);
 568
 569 /**
 570  * memstick_free_host - free memstick host
 571  * @host - host to use
 572  */
 573 void memstick_free_host(struct memstick_host *host)
 574 {
 575         mutex_destroy(&host->lock);
 576         put_device(&host->dev);
 577 }
 578 EXPORT_SYMBOL(memstick_free_host);
 579
 580 /**
 581  * memstick_suspend_host - notify bus driver of host suspension
 582  * @host - host to use
 583  */
 584 void memstick_suspend_host(struct memstick_host *host)
 585 {
 586         mutex_lock(&host->lock);
 587         host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
 588         mutex_unlock(&host->lock);
 589 }
 590 EXPORT_SYMBOL(memstick_suspend_host);
 591
 592 /**
 593  * memstick_resume_host - notify bus driver of host resumption
 594  * @host - host to use
 595  */
 596 void memstick_resume_host(struct memstick_host *host)
 597 {
 598         int rc = 0;
 599
 600         mutex_lock(&host->lock);
 601         if (host->card)
 602                 rc = memstick_power_on(host);
 603         mutex_unlock(&host->lock);
 604
 605         if (!rc)
 606                 memstick_detect_change(host);
 607 }
 608 EXPORT_SYMBOL(memstick_resume_host);
 609
 610 int memstick_register_driver(struct memstick_driver *drv)
 611 {
 612         drv->driver.bus = &memstick_bus_type;
 613
 614         return driver_register(&drv->driver);
 615 }
 616 EXPORT_SYMBOL(memstick_register_driver);
 617
 618 void memstick_unregister_driver(struct memstick_driver *drv)
 619 {
 620         driver_unregister(&drv->driver);
 621 }
 622 EXPORT_SYMBOL(memstick_unregister_driver);
 623
 624
 625 static int __init memstick_init(void)
 626 {
 627         int rc;
 628
 629         workqueue = create_freezable_workqueue("kmemstick");
 630         if (!workqueue)
 631                 return -ENOMEM;
 632
 633         rc = bus_register(&memstick_bus_type);
 634         if (rc)
 635                 goto error_destroy_workqueue;
 636
 637         rc = class_register(&memstick_host_class);
 638         if (rc)
 639                 goto error_bus_unregister;
 640
 641         return 0;
 642
 643 error_bus_unregister:
 644         bus_unregister(&memstick_bus_type);
 645 error_destroy_workqueue:
 646         destroy_workqueue(workqueue);
 647
 648         return rc;
 649 }
 650
 651 static void __exit memstick_exit(void)
 652 {
 653         class_unregister(&memstick_host_class);
 654         bus_unregister(&memstick_bus_type);
 655         destroy_workqueue(workqueue);
 656         idr_destroy(&memstick_host_idr);
 657 }
 658
 659 module_init(memstick_init);
 660 module_exit(memstick_exit);
 661
 662 MODULE_AUTHOR("Alex Dubov");
 663 MODULE_LICENSE("GPL");
 664 MODULE_DESCRIPTION("Sony MemoryStick core driver");