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