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