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