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