1 /* 2 * tifm_core.c - TI FlashMedia driver 3 * 4 * Copyright (C) 2006 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 */ 11 12 #include <linux/tifm.h> 13 #include <linux/slab.h> 14 #include <linux/init.h> 15 #include <linux/idr.h> 16 #include <linux/module.h> 17 18 #define DRIVER_NAME "tifm_core" 19 #define DRIVER_VERSION "0.8" 20 21 static struct workqueue_struct *workqueue; 22 static DEFINE_IDR(tifm_adapter_idr); 23 static DEFINE_SPINLOCK(tifm_adapter_lock); 24 25 static const char *tifm_media_type_name(unsigned char type, unsigned char nt) 26 { 27 const char *card_type_name[3][3] = { 28 { "SmartMedia/xD", "MemoryStick", "MMC/SD" }, 29 { "XD", "MS", "SD"}, 30 { "xd", "ms", "sd"} 31 }; 32 33 if (nt > 2 || type < 1 || type > 3) 34 return NULL; 35 return card_type_name[nt][type - 1]; 36 } 37 38 static int tifm_dev_match(struct tifm_dev *sock, struct tifm_device_id *id) 39 { 40 if (sock->type == id->type) 41 return 1; 42 return 0; 43 } 44 45 static int tifm_bus_match(struct device *dev, struct device_driver *drv) 46 { 47 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 48 struct tifm_driver *fm_drv = container_of(drv, struct tifm_driver, 49 driver); 50 struct tifm_device_id *ids = fm_drv->id_table; 51 52 if (ids) { 53 while (ids->type) { 54 if (tifm_dev_match(sock, ids)) 55 return 1; 56 ++ids; 57 } 58 } 59 return 0; 60 } 61 62 static int tifm_uevent(struct device *dev, struct kobj_uevent_env *env) 63 { 64 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 65 66 if (add_uevent_var(env, "TIFM_CARD_TYPE=%s", tifm_media_type_name(sock->type, 1))) 67 return -ENOMEM; 68 69 return 0; 70 } 71 72 static int tifm_device_probe(struct device *dev) 73 { 74 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 75 struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, 76 driver); 77 int rc = -ENODEV; 78 79 get_device(dev); 80 if (dev->driver && drv->probe) { 81 rc = drv->probe(sock); 82 if (!rc) 83 return 0; 84 } 85 put_device(dev); 86 return rc; 87 } 88 89 static void tifm_dummy_event(struct tifm_dev *sock) 90 { 91 return; 92 } 93 94 static int tifm_device_remove(struct device *dev) 95 { 96 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 97 struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, 98 driver); 99 100 if (dev->driver && drv->remove) { 101 sock->card_event = tifm_dummy_event; 102 sock->data_event = tifm_dummy_event; 103 drv->remove(sock); 104 sock->dev.driver = NULL; 105 } 106 107 put_device(dev); 108 return 0; 109 } 110 111 #ifdef CONFIG_PM 112 113 static int tifm_device_suspend(struct device *dev, pm_message_t state) 114 { 115 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 116 struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, 117 driver); 118 119 if (dev->driver && drv->suspend) 120 return drv->suspend(sock, state); 121 return 0; 122 } 123 124 static int tifm_device_resume(struct device *dev) 125 { 126 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 127 struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, 128 driver); 129 130 if (dev->driver && drv->resume) 131 return drv->resume(sock); 132 return 0; 133 } 134 135 #else 136 137 #define tifm_device_suspend NULL 138 #define tifm_device_resume NULL 139 140 #endif /* CONFIG_PM */ 141 142 static ssize_t type_show(struct device *dev, struct device_attribute *attr, 143 char *buf) 144 { 145 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 146 return sprintf(buf, "%x", sock->type); 147 } 148 149 static struct device_attribute tifm_dev_attrs[] = { 150 __ATTR(type, S_IRUGO, type_show, NULL), 151 __ATTR_NULL 152 }; 153 154 static struct bus_type tifm_bus_type = { 155 .name = "tifm", 156 .dev_attrs = tifm_dev_attrs, 157 .match = tifm_bus_match, 158 .uevent = tifm_uevent, 159 .probe = tifm_device_probe, 160 .remove = tifm_device_remove, 161 .suspend = tifm_device_suspend, 162 .resume = tifm_device_resume 163 }; 164 165 static void tifm_free(struct device *dev) 166 { 167 struct tifm_adapter *fm = container_of(dev, struct tifm_adapter, dev); 168 169 kfree(fm); 170 } 171 172 static struct class tifm_adapter_class = { 173 .name = "tifm_adapter", 174 .dev_release = tifm_free 175 }; 176 177 struct tifm_adapter *tifm_alloc_adapter(unsigned int num_sockets, 178 struct device *dev) 179 { 180 struct tifm_adapter *fm; 181 182 fm = kzalloc(sizeof(struct tifm_adapter) 183 + sizeof(struct tifm_dev*) * num_sockets, GFP_KERNEL); 184 if (fm) { 185 fm->dev.class = &tifm_adapter_class; 186 fm->dev.parent = dev; 187 device_initialize(&fm->dev); 188 spin_lock_init(&fm->lock); 189 fm->num_sockets = num_sockets; 190 } 191 return fm; 192 } 193 EXPORT_SYMBOL(tifm_alloc_adapter); 194 195 int tifm_add_adapter(struct tifm_adapter *fm) 196 { 197 int rc; 198 199 idr_preload(GFP_KERNEL); 200 spin_lock(&tifm_adapter_lock); 201 rc = idr_alloc(&tifm_adapter_idr, fm, 0, 0, GFP_NOWAIT); 202 if (rc >= 0) 203 fm->id = rc; 204 spin_unlock(&tifm_adapter_lock); 205 idr_preload_end(); 206 if (rc < 0) 207 return rc; 208 209 dev_set_name(&fm->dev, "tifm%u", fm->id); 210 rc = device_add(&fm->dev); 211 if (rc) { 212 spin_lock(&tifm_adapter_lock); 213 idr_remove(&tifm_adapter_idr, fm->id); 214 spin_unlock(&tifm_adapter_lock); 215 } 216 217 return rc; 218 } 219 EXPORT_SYMBOL(tifm_add_adapter); 220 221 void tifm_remove_adapter(struct tifm_adapter *fm) 222 { 223 unsigned int cnt; 224 225 flush_workqueue(workqueue); 226 for (cnt = 0; cnt < fm->num_sockets; ++cnt) { 227 if (fm->sockets[cnt]) 228 device_unregister(&fm->sockets[cnt]->dev); 229 } 230 231 spin_lock(&tifm_adapter_lock); 232 idr_remove(&tifm_adapter_idr, fm->id); 233 spin_unlock(&tifm_adapter_lock); 234 device_del(&fm->dev); 235 } 236 EXPORT_SYMBOL(tifm_remove_adapter); 237 238 void tifm_free_adapter(struct tifm_adapter *fm) 239 { 240 put_device(&fm->dev); 241 } 242 EXPORT_SYMBOL(tifm_free_adapter); 243 244 void tifm_free_device(struct device *dev) 245 { 246 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 247 kfree(sock); 248 } 249 EXPORT_SYMBOL(tifm_free_device); 250 251 struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm, unsigned int id, 252 unsigned char type) 253 { 254 struct tifm_dev *sock = NULL; 255 256 if (!tifm_media_type_name(type, 0)) 257 return sock; 258 259 sock = kzalloc(sizeof(struct tifm_dev), GFP_KERNEL); 260 if (sock) { 261 spin_lock_init(&sock->lock); 262 sock->type = type; 263 sock->socket_id = id; 264 sock->card_event = tifm_dummy_event; 265 sock->data_event = tifm_dummy_event; 266 267 sock->dev.parent = fm->dev.parent; 268 sock->dev.bus = &tifm_bus_type; 269 sock->dev.dma_mask = fm->dev.parent->dma_mask; 270 sock->dev.release = tifm_free_device; 271 272 dev_set_name(&sock->dev, "tifm_%s%u:%u", 273 tifm_media_type_name(type, 2), fm->id, id); 274 printk(KERN_INFO DRIVER_NAME 275 ": %s card detected in socket %u:%u\n", 276 tifm_media_type_name(type, 0), fm->id, id); 277 } 278 return sock; 279 } 280 EXPORT_SYMBOL(tifm_alloc_device); 281 282 void tifm_eject(struct tifm_dev *sock) 283 { 284 struct tifm_adapter *fm = dev_get_drvdata(sock->dev.parent); 285 fm->eject(fm, sock); 286 } 287 EXPORT_SYMBOL(tifm_eject); 288 289 int tifm_has_ms_pif(struct tifm_dev *sock) 290 { 291 struct tifm_adapter *fm = dev_get_drvdata(sock->dev.parent); 292 return fm->has_ms_pif(fm, sock); 293 } 294 EXPORT_SYMBOL(tifm_has_ms_pif); 295 296 int tifm_map_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents, 297 int direction) 298 { 299 return pci_map_sg(to_pci_dev(sock->dev.parent), sg, nents, direction); 300 } 301 EXPORT_SYMBOL(tifm_map_sg); 302 303 void tifm_unmap_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents, 304 int direction) 305 { 306 pci_unmap_sg(to_pci_dev(sock->dev.parent), sg, nents, direction); 307 } 308 EXPORT_SYMBOL(tifm_unmap_sg); 309 310 void tifm_queue_work(struct work_struct *work) 311 { 312 queue_work(workqueue, work); 313 } 314 EXPORT_SYMBOL(tifm_queue_work); 315 316 int tifm_register_driver(struct tifm_driver *drv) 317 { 318 drv->driver.bus = &tifm_bus_type; 319 320 return driver_register(&drv->driver); 321 } 322 EXPORT_SYMBOL(tifm_register_driver); 323 324 void tifm_unregister_driver(struct tifm_driver *drv) 325 { 326 driver_unregister(&drv->driver); 327 } 328 EXPORT_SYMBOL(tifm_unregister_driver); 329 330 static int __init tifm_init(void) 331 { 332 int rc; 333 334 workqueue = create_freezable_workqueue("tifm"); 335 if (!workqueue) 336 return -ENOMEM; 337 338 rc = bus_register(&tifm_bus_type); 339 340 if (rc) 341 goto err_out_wq; 342 343 rc = class_register(&tifm_adapter_class); 344 if (!rc) 345 return 0; 346 347 bus_unregister(&tifm_bus_type); 348 349 err_out_wq: 350 destroy_workqueue(workqueue); 351 352 return rc; 353 } 354 355 static void __exit tifm_exit(void) 356 { 357 class_unregister(&tifm_adapter_class); 358 bus_unregister(&tifm_bus_type); 359 destroy_workqueue(workqueue); 360 } 361 362 subsys_initcall(tifm_init); 363 module_exit(tifm_exit); 364 365 MODULE_LICENSE("GPL"); 366 MODULE_AUTHOR("Alex Dubov"); 367 MODULE_DESCRIPTION("TI FlashMedia core driver"); 368 MODULE_LICENSE("GPL"); 369 MODULE_VERSION(DRIVER_VERSION); 370