kernel/drivers/memstick/core/memstick.c

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