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