[libata] LBA28/LBA48 off-by-one bug in ata.h
[linux-3.10.git] / 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                           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                        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                 snprintf(card->dev.bus_id, sizeof(card->dev.bus_id),
389                          "%s", host->dev.bus_id);
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                 wait_for_completion(&card->mrq_complete);
409
410                 if (card->current_mrq.error)
411                         goto err_out;
412         }
413         host->card = old_card;
414         return card;
415 err_out:
416         host->card = old_card;
417         kfree(card);
418         return NULL;
419 }
420
421 static int memstick_power_on(struct memstick_host *host)
422 {
423         int rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
424
425         if (!rc)
426                 rc = host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);
427
428         return rc;
429 }
430
431 static void memstick_check(struct work_struct *work)
432 {
433         struct memstick_host *host = container_of(work, struct memstick_host,
434                                                   media_checker);
435         struct memstick_dev *card;
436
437         dev_dbg(&host->dev, "memstick_check started\n");
438         mutex_lock(&host->lock);
439         if (!host->card) {
440                 if (memstick_power_on(host))
441                         goto out_power_off;
442         } else
443                 host->card->stop(host->card);
444
445         card = memstick_alloc_card(host);
446
447         if (!card) {
448                 if (host->card) {
449                         device_unregister(&host->card->dev);
450                         host->card = NULL;
451                 }
452         } else {
453                 dev_dbg(&host->dev, "new card %02x, %02x, %02x\n",
454                         card->id.type, card->id.category, card->id.class);
455                 if (host->card) {
456                         if (memstick_set_rw_addr(host->card)
457                             || !memstick_dev_match(host->card, &card->id)
458                             || !(host->card->check(host->card))) {
459                                 device_unregister(&host->card->dev);
460                                 host->card = NULL;
461                         } else
462                                 host->card->start(host->card);
463                 }
464
465                 if (!host->card) {
466                         host->card = card;
467                         if (device_register(&card->dev)) {
468                                 kfree(host->card);
469                                 host->card = NULL;
470                         }
471                 } else
472                         kfree(card);
473         }
474
475 out_power_off:
476         if (!host->card)
477                 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
478
479         mutex_unlock(&host->lock);
480         dev_dbg(&host->dev, "memstick_check finished\n");
481 }
482
483 /**
484  * memstick_alloc_host - allocate a memstick_host structure
485  * @extra: size of the user private data to allocate
486  * @dev: parent device of the host
487  */
488 struct memstick_host *memstick_alloc_host(unsigned int extra,
489                                           struct device *dev)
490 {
491         struct memstick_host *host;
492
493         host = kzalloc(sizeof(struct memstick_host) + extra, GFP_KERNEL);
494         if (host) {
495                 mutex_init(&host->lock);
496                 INIT_WORK(&host->media_checker, memstick_check);
497                 host->dev.class = &memstick_host_class;
498                 host->dev.parent = dev;
499                 device_initialize(&host->dev);
500         }
501         return host;
502 }
503 EXPORT_SYMBOL(memstick_alloc_host);
504
505 /**
506  * memstick_add_host - start request processing on memstick host
507  * @host - host to use
508  */
509 int memstick_add_host(struct memstick_host *host)
510 {
511         int rc;
512
513         if (!idr_pre_get(&memstick_host_idr, GFP_KERNEL))
514                 return -ENOMEM;
515
516         spin_lock(&memstick_host_lock);
517         rc = idr_get_new(&memstick_host_idr, host, &host->id);
518         spin_unlock(&memstick_host_lock);
519         if (rc)
520                 return rc;
521
522         snprintf(host->dev.bus_id, BUS_ID_SIZE, "memstick%u", host->id);
523
524         rc = device_add(&host->dev);
525         if (rc) {
526                 spin_lock(&memstick_host_lock);
527                 idr_remove(&memstick_host_idr, host->id);
528                 spin_unlock(&memstick_host_lock);
529                 return rc;
530         }
531
532         host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
533         memstick_detect_change(host);
534         return 0;
535 }
536 EXPORT_SYMBOL(memstick_add_host);
537
538 /**
539  * memstick_remove_host - stop request processing on memstick host
540  * @host - host to use
541  */
542 void memstick_remove_host(struct memstick_host *host)
543 {
544         flush_workqueue(workqueue);
545         mutex_lock(&host->lock);
546         if (host->card)
547                 device_unregister(&host->card->dev);
548         host->card = NULL;
549         host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
550         mutex_unlock(&host->lock);
551
552         spin_lock(&memstick_host_lock);
553         idr_remove(&memstick_host_idr, host->id);
554         spin_unlock(&memstick_host_lock);
555         device_del(&host->dev);
556 }
557 EXPORT_SYMBOL(memstick_remove_host);
558
559 /**
560  * memstick_free_host - free memstick host
561  * @host - host to use
562  */
563 void memstick_free_host(struct memstick_host *host)
564 {
565         mutex_destroy(&host->lock);
566         put_device(&host->dev);
567 }
568 EXPORT_SYMBOL(memstick_free_host);
569
570 /**
571  * memstick_suspend_host - notify bus driver of host suspension
572  * @host - host to use
573  */
574 void memstick_suspend_host(struct memstick_host *host)
575 {
576         mutex_lock(&host->lock);
577         host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
578         mutex_unlock(&host->lock);
579 }
580 EXPORT_SYMBOL(memstick_suspend_host);
581
582 /**
583  * memstick_resume_host - notify bus driver of host resumption
584  * @host - host to use
585  */
586 void memstick_resume_host(struct memstick_host *host)
587 {
588         int rc = 0;
589
590         mutex_lock(&host->lock);
591         if (host->card)
592                 rc = memstick_power_on(host);
593         mutex_unlock(&host->lock);
594
595         if (!rc)
596                 memstick_detect_change(host);
597 }
598 EXPORT_SYMBOL(memstick_resume_host);
599
600 int memstick_register_driver(struct memstick_driver *drv)
601 {
602         drv->driver.bus = &memstick_bus_type;
603
604         return driver_register(&drv->driver);
605 }
606 EXPORT_SYMBOL(memstick_register_driver);
607
608 void memstick_unregister_driver(struct memstick_driver *drv)
609 {
610         driver_unregister(&drv->driver);
611 }
612 EXPORT_SYMBOL(memstick_unregister_driver);
613
614
615 static int __init memstick_init(void)
616 {
617         int rc;
618
619         workqueue = create_freezeable_workqueue("kmemstick");
620         if (!workqueue)
621                 return -ENOMEM;
622
623         rc = bus_register(&memstick_bus_type);
624         if (!rc)
625                 rc = class_register(&memstick_host_class);
626
627         if (!rc)
628                 return 0;
629
630         bus_unregister(&memstick_bus_type);
631         destroy_workqueue(workqueue);
632
633         return rc;
634 }
635
636 static void __exit memstick_exit(void)
637 {
638         class_unregister(&memstick_host_class);
639         bus_unregister(&memstick_bus_type);
640         destroy_workqueue(workqueue);
641         idr_destroy(&memstick_host_idr);
642 }
643
644 module_init(memstick_init);
645 module_exit(memstick_exit);
646
647 MODULE_AUTHOR("Alex Dubov");
648 MODULE_LICENSE("GPL");
649 MODULE_DESCRIPTION("Sony MemoryStick core driver");