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 if (!idr_pre_get(&tifm_adapter_idr, GFP_KERNEL)) 200 return -ENOMEM; 201 202 spin_lock(&tifm_adapter_lock); 203 rc = idr_get_new(&tifm_adapter_idr, fm, &fm->id); 204 spin_unlock(&tifm_adapter_lock); 205 if (rc) 206 return rc; 207 208 dev_set_name(&fm->dev, "tifm%u", fm->id); 209 rc = device_add(&fm->dev); 210 if (rc) { 211 spin_lock(&tifm_adapter_lock); 212 idr_remove(&tifm_adapter_idr, fm->id); 213 spin_unlock(&tifm_adapter_lock); 214 } 215 216 return rc; 217 } 218 EXPORT_SYMBOL(tifm_add_adapter); 219 220 void tifm_remove_adapter(struct tifm_adapter *fm) 221 { 222 unsigned int cnt; 223 224 flush_workqueue(workqueue); 225 for (cnt = 0; cnt < fm->num_sockets; ++cnt) { 226 if (fm->sockets[cnt]) 227 device_unregister(&fm->sockets[cnt]->dev); 228 } 229 230 spin_lock(&tifm_adapter_lock); 231 idr_remove(&tifm_adapter_idr, fm->id); 232 spin_unlock(&tifm_adapter_lock); 233 device_del(&fm->dev); 234 } 235 EXPORT_SYMBOL(tifm_remove_adapter); 236 237 void tifm_free_adapter(struct tifm_adapter *fm) 238 { 239 put_device(&fm->dev); 240 } 241 EXPORT_SYMBOL(tifm_free_adapter); 242 243 void tifm_free_device(struct device *dev) 244 { 245 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 246 kfree(sock); 247 } 248 EXPORT_SYMBOL(tifm_free_device); 249 250 struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm, unsigned int id, 251 unsigned char type) 252 { 253 struct tifm_dev *sock = NULL; 254 255 if (!tifm_media_type_name(type, 0)) 256 return sock; 257 258 sock = kzalloc(sizeof(struct tifm_dev), GFP_KERNEL); 259 if (sock) { 260 spin_lock_init(&sock->lock); 261 sock->type = type; 262 sock->socket_id = id; 263 sock->card_event = tifm_dummy_event; 264 sock->data_event = tifm_dummy_event; 265 266 sock->dev.parent = fm->dev.parent; 267 sock->dev.bus = &tifm_bus_type; 268 sock->dev.dma_mask = fm->dev.parent->dma_mask; 269 sock->dev.release = tifm_free_device; 270 271 dev_set_name(&sock->dev, "tifm_%s%u:%u", 272 tifm_media_type_name(type, 2), fm->id, id); 273 printk(KERN_INFO DRIVER_NAME 274 ": %s card detected in socket %u:%u\n", 275 tifm_media_type_name(type, 0), fm->id, id); 276 } 277 return sock; 278 } 279 EXPORT_SYMBOL(tifm_alloc_device); 280 281 void tifm_eject(struct tifm_dev *sock) 282 { 283 struct tifm_adapter *fm = dev_get_drvdata(sock->dev.parent); 284 fm->eject(fm, sock); 285 } 286 EXPORT_SYMBOL(tifm_eject); 287 288 int tifm_has_ms_pif(struct tifm_dev *sock) 289 { 290 struct tifm_adapter *fm = dev_get_drvdata(sock->dev.parent); 291 return fm->has_ms_pif(fm, sock); 292 } 293 EXPORT_SYMBOL(tifm_has_ms_pif); 294 295 int tifm_map_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents, 296 int direction) 297 { 298 return pci_map_sg(to_pci_dev(sock->dev.parent), sg, nents, direction); 299 } 300 EXPORT_SYMBOL(tifm_map_sg); 301 302 void tifm_unmap_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents, 303 int direction) 304 { 305 pci_unmap_sg(to_pci_dev(sock->dev.parent), sg, nents, direction); 306 } 307 EXPORT_SYMBOL(tifm_unmap_sg); 308 309 void tifm_queue_work(struct work_struct *work) 310 { 311 queue_work(workqueue, work); 312 } 313 EXPORT_SYMBOL(tifm_queue_work); 314 315 int tifm_register_driver(struct tifm_driver *drv) 316 { 317 drv->driver.bus = &tifm_bus_type; 318 319 return driver_register(&drv->driver); 320 } 321 EXPORT_SYMBOL(tifm_register_driver); 322 323 void tifm_unregister_driver(struct tifm_driver *drv) 324 { 325 driver_unregister(&drv->driver); 326 } 327 EXPORT_SYMBOL(tifm_unregister_driver); 328 329 static int __init tifm_init(void) 330 { 331 int rc; 332 333 workqueue = create_freezable_workqueue("tifm"); 334 if (!workqueue) 335 return -ENOMEM; 336 337 rc = bus_register(&tifm_bus_type); 338 339 if (rc) 340 goto err_out_wq; 341 342 rc = class_register(&tifm_adapter_class); 343 if (!rc) 344 return 0; 345 346 bus_unregister(&tifm_bus_type); 347 348 err_out_wq: 349 destroy_workqueue(workqueue); 350 351 return rc; 352 } 353 354 static void __exit tifm_exit(void) 355 { 356 class_unregister(&tifm_adapter_class); 357 bus_unregister(&tifm_bus_type); 358 destroy_workqueue(workqueue); 359 } 360 361 subsys_initcall(tifm_init); 362 module_exit(tifm_exit); 363 364 MODULE_LICENSE("GPL"); 365 MODULE_AUTHOR("Alex Dubov"); 366 MODULE_DESCRIPTION("TI FlashMedia core driver"); 367 MODULE_LICENSE("GPL"); 368 MODULE_VERSION(DRIVER_VERSION); 369