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