2 * Sony MemoryStick support
4 * Copyright (C) 2007 Alex Dubov <oakad@yahoo.com>
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.
10 * Special thanks to Carlos Corbacho for providing various MemoryStick cards
11 * that made this driver possible.
15 #include <linux/memstick.h>
16 #include <linux/idr.h>
18 #include <linux/delay.h>
20 #define DRIVER_NAME "memstick"
21 #define DRIVER_VERSION "0.2"
23 static unsigned int cmd_retries = 3;
24 module_param(cmd_retries, uint, 0644);
26 static struct workqueue_struct *workqueue;
27 static DEFINE_IDR(memstick_host_idr);
28 static DEFINE_SPINLOCK(memstick_host_lock);
30 static int memstick_dev_match(struct memstick_dev *card,
31 struct memstick_device_id *id)
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))
43 static int memstick_bus_match(struct device *dev, struct device_driver *drv)
45 struct memstick_dev *card = container_of(dev, struct memstick_dev,
47 struct memstick_driver *ms_drv = container_of(drv,
48 struct memstick_driver,
50 struct memstick_device_id *ids = ms_drv->id_table;
53 while (ids->match_flags) {
54 if (memstick_dev_match(card, ids))
62 static int memstick_uevent(struct device *dev, struct kobj_uevent_env *env)
64 struct memstick_dev *card = container_of(dev, struct memstick_dev,
67 if (add_uevent_var(env, "MEMSTICK_TYPE=%02X", card->id.type))
70 if (add_uevent_var(env, "MEMSTICK_CATEGORY=%02X", card->id.category))
73 if (add_uevent_var(env, "MEMSTICK_CLASS=%02X", card->id.class))
79 static int memstick_device_probe(struct device *dev)
81 struct memstick_dev *card = container_of(dev, struct memstick_dev,
83 struct memstick_driver *drv = container_of(dev->driver,
84 struct memstick_driver,
88 if (dev->driver && drv->probe) {
89 rc = drv->probe(card);
96 static int memstick_device_remove(struct device *dev)
98 struct memstick_dev *card = container_of(dev, struct memstick_dev,
100 struct memstick_driver *drv = container_of(dev->driver,
101 struct memstick_driver,
104 if (dev->driver && drv->remove) {
106 card->dev.driver = NULL;
115 static int memstick_device_suspend(struct device *dev, pm_message_t state)
117 struct memstick_dev *card = container_of(dev, struct memstick_dev,
119 struct memstick_driver *drv = container_of(dev->driver,
120 struct memstick_driver,
123 if (dev->driver && drv->suspend)
124 return drv->suspend(card, state);
128 static int memstick_device_resume(struct device *dev)
130 struct memstick_dev *card = container_of(dev, struct memstick_dev,
132 struct memstick_driver *drv = container_of(dev->driver,
133 struct memstick_driver,
136 if (dev->driver && drv->resume)
137 return drv->resume(card);
143 #define memstick_device_suspend NULL
144 #define memstick_device_resume NULL
146 #endif /* CONFIG_PM */
148 #define MEMSTICK_ATTR(name, format) \
149 static ssize_t name##_show(struct device *dev, struct device_attribute *attr, \
152 struct memstick_dev *card = container_of(dev, struct memstick_dev, \
154 return sprintf(buf, format, card->id.name); \
157 MEMSTICK_ATTR(type, "%02X");
158 MEMSTICK_ATTR(category, "%02X");
159 MEMSTICK_ATTR(class, "%02X");
161 #define MEMSTICK_ATTR_RO(name) __ATTR(name, S_IRUGO, name##_show, NULL)
163 static struct device_attribute memstick_dev_attrs[] = {
164 MEMSTICK_ATTR_RO(type),
165 MEMSTICK_ATTR_RO(category),
166 MEMSTICK_ATTR_RO(class),
170 static struct bus_type memstick_bus_type = {
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
181 static void memstick_free(struct class_device *cdev)
183 struct memstick_host *host = container_of(cdev, struct memstick_host,
188 static struct class memstick_host_class = {
189 .name = "memstick_host",
190 .release = memstick_free
193 static void memstick_free_card(struct device *dev)
195 struct memstick_dev *card = container_of(dev, struct memstick_dev,
200 static int memstick_dummy_check(struct memstick_dev *card)
206 * memstick_detect_change - schedule media detection on memstick host
207 * @host - host to use
209 void memstick_detect_change(struct memstick_host *host)
211 queue_work(workqueue, &host->media_checker);
213 EXPORT_SYMBOL(memstick_detect_change);
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
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.
225 int memstick_next_req(struct memstick_host *host, struct memstick_request **mrq)
229 if ((*mrq) && (*mrq)->error && host->retries) {
235 if (host->card && host->card->next_request)
236 rc = host->card->next_request(host->card, mrq);
239 host->retries = cmd_retries;
245 EXPORT_SYMBOL(memstick_next_req);
248 * memstick_new_req - notify the host that some requests are pending
249 * @host - host to use
251 void memstick_new_req(struct memstick_host *host)
253 host->retries = cmd_retries;
256 EXPORT_SYMBOL(memstick_new_req);
259 * memstick_init_req_sg - set request fields needed for bulk data transfer
260 * @mrq - request to use
261 * @tpc - memstick Transport Protocol Command
264 void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
265 struct scatterlist *sg)
269 mrq->data_dir = WRITE;
271 mrq->data_dir = READ;
276 if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD)
277 mrq->need_card_int = 1;
279 mrq->need_card_int = 0;
281 mrq->get_int_reg = 0;
283 EXPORT_SYMBOL(memstick_init_req_sg);
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
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.
296 void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
297 void *buf, size_t length)
301 mrq->data_dir = WRITE;
303 mrq->data_dir = READ;
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);
311 if (tpc == MS_TPC_SET_CMD || tpc == MS_TPC_EX_SET_CMD)
312 mrq->need_card_int = 1;
314 mrq->need_card_int = 0;
316 mrq->get_int_reg = 0;
318 EXPORT_SYMBOL(memstick_init_req);
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).
327 static int h_memstick_read_dev_id(struct memstick_dev *card,
328 struct memstick_request **mrq)
330 struct ms_id_register id_reg;
333 memstick_init_req(&card->current_mrq, MS_TPC_READ_REG, NULL,
334 sizeof(struct ms_id_register));
335 *mrq = &card->current_mrq;
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;
345 complete(&card->mrq_complete);
350 static int h_memstick_set_rw_addr(struct memstick_dev *card,
351 struct memstick_request **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;
360 complete(&card->mrq_complete);
366 * memstick_set_rw_addr - issue SET_RW_REG_ADDR request and wait for it to
368 * @card - media device to use
370 int memstick_set_rw_addr(struct memstick_dev *card)
372 card->next_request = h_memstick_set_rw_addr;
373 memstick_new_req(card->host);
374 wait_for_completion(&card->mrq_complete);
376 return card->current_mrq.error;
378 EXPORT_SYMBOL(memstick_set_rw_addr);
380 static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
382 struct memstick_dev *card = kzalloc(sizeof(struct memstick_dev),
384 struct memstick_dev *old_card = host->card;
385 struct ms_id_register id_reg;
389 snprintf(card->dev.bus_id, sizeof(card->dev.bus_id),
390 "%s", host->cdev.class_id);
391 card->dev.parent = host->cdev.dev;
392 card->dev.bus = &memstick_bus_type;
393 card->dev.release = memstick_free_card;
394 card->check = memstick_dummy_check;
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);
401 init_completion(&card->mrq_complete);
404 if (memstick_set_rw_addr(card))
407 card->next_request = h_memstick_read_dev_id;
408 memstick_new_req(host);
409 wait_for_completion(&card->mrq_complete);
411 if (card->current_mrq.error)
414 host->card = old_card;
417 host->card = old_card;
422 static void memstick_power_on(struct memstick_host *host)
424 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
425 host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);
429 static void memstick_check(struct work_struct *work)
431 struct memstick_host *host = container_of(work, struct memstick_host,
433 struct memstick_dev *card;
435 dev_dbg(host->cdev.dev, "memstick_check started\n");
436 mutex_lock(&host->lock);
438 memstick_power_on(host);
440 card = memstick_alloc_card(host);
444 device_unregister(&host->card->dev);
448 dev_dbg(host->cdev.dev, "new card %02x, %02x, %02x\n",
449 card->id.type, card->id.category, card->id.class);
451 if (memstick_set_rw_addr(host->card)
452 || !memstick_dev_match(host->card, &card->id)
453 || !(host->card->check(host->card))) {
454 device_unregister(&host->card->dev);
461 if (device_register(&card->dev)) {
470 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
472 mutex_unlock(&host->lock);
473 dev_dbg(host->cdev.dev, "memstick_check finished\n");
477 * memstick_alloc_host - allocate a memstick_host structure
478 * @extra: size of the user private data to allocate
479 * @dev: parent device of the host
481 struct memstick_host *memstick_alloc_host(unsigned int extra,
484 struct memstick_host *host;
486 host = kzalloc(sizeof(struct memstick_host) + extra, GFP_KERNEL);
488 mutex_init(&host->lock);
489 INIT_WORK(&host->media_checker, memstick_check);
490 host->cdev.class = &memstick_host_class;
491 host->cdev.dev = dev;
492 class_device_initialize(&host->cdev);
496 EXPORT_SYMBOL(memstick_alloc_host);
499 * memstick_add_host - start request processing on memstick host
500 * @host - host to use
502 int memstick_add_host(struct memstick_host *host)
506 if (!idr_pre_get(&memstick_host_idr, GFP_KERNEL))
509 spin_lock(&memstick_host_lock);
510 rc = idr_get_new(&memstick_host_idr, host, &host->id);
511 spin_unlock(&memstick_host_lock);
515 snprintf(host->cdev.class_id, BUS_ID_SIZE,
516 "memstick%u", host->id);
518 rc = class_device_add(&host->cdev);
520 spin_lock(&memstick_host_lock);
521 idr_remove(&memstick_host_idr, host->id);
522 spin_unlock(&memstick_host_lock);
526 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
527 memstick_detect_change(host);
530 EXPORT_SYMBOL(memstick_add_host);
533 * memstick_remove_host - stop request processing on memstick host
534 * @host - host to use
536 void memstick_remove_host(struct memstick_host *host)
538 flush_workqueue(workqueue);
539 mutex_lock(&host->lock);
541 device_unregister(&host->card->dev);
543 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
544 mutex_unlock(&host->lock);
546 spin_lock(&memstick_host_lock);
547 idr_remove(&memstick_host_idr, host->id);
548 spin_unlock(&memstick_host_lock);
549 class_device_del(&host->cdev);
551 EXPORT_SYMBOL(memstick_remove_host);
554 * memstick_free_host - free memstick host
555 * @host - host to use
557 void memstick_free_host(struct memstick_host *host)
559 mutex_destroy(&host->lock);
560 class_device_put(&host->cdev);
562 EXPORT_SYMBOL(memstick_free_host);
565 * memstick_suspend_host - notify bus driver of host suspension
566 * @host - host to use
568 void memstick_suspend_host(struct memstick_host *host)
570 mutex_lock(&host->lock);
571 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
572 mutex_unlock(&host->lock);
574 EXPORT_SYMBOL(memstick_suspend_host);
577 * memstick_resume_host - notify bus driver of host resumption
578 * @host - host to use
580 void memstick_resume_host(struct memstick_host *host)
582 mutex_lock(&host->lock);
583 host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
584 mutex_unlock(&host->lock);
585 memstick_detect_change(host);
587 EXPORT_SYMBOL(memstick_resume_host);
589 int memstick_register_driver(struct memstick_driver *drv)
591 drv->driver.bus = &memstick_bus_type;
593 return driver_register(&drv->driver);
595 EXPORT_SYMBOL(memstick_register_driver);
597 void memstick_unregister_driver(struct memstick_driver *drv)
599 driver_unregister(&drv->driver);
601 EXPORT_SYMBOL(memstick_unregister_driver);
604 static int __init memstick_init(void)
608 workqueue = create_freezeable_workqueue("kmemstick");
612 rc = bus_register(&memstick_bus_type);
614 rc = class_register(&memstick_host_class);
619 bus_unregister(&memstick_bus_type);
620 destroy_workqueue(workqueue);
625 static void __exit memstick_exit(void)
627 class_unregister(&memstick_host_class);
628 bus_unregister(&memstick_bus_type);
629 destroy_workqueue(workqueue);
630 idr_destroy(&memstick_host_idr);
633 module_init(memstick_init);
634 module_exit(memstick_exit);
636 MODULE_AUTHOR("Alex Dubov");
637 MODULE_LICENSE("GPL");
638 MODULE_DESCRIPTION("Sony MemoryStick core driver");
639 MODULE_VERSION(DRIVER_VERSION);