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 dev_set_name(&fm->dev, "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 dev_set_name(&sock->dev, "tifm_%s%u:%u", 270 tifm_media_type_name(type, 2), fm->id, id); 271 printk(KERN_INFO DRIVER_NAME 272 ": %s card detected in socket %u:%u\n", 273 tifm_media_type_name(type, 0), fm->id, id); 274 } 275 return sock; 276 } 277 EXPORT_SYMBOL(tifm_alloc_device); 278 279 void tifm_eject(struct tifm_dev *sock) 280 { 281 struct tifm_adapter *fm = dev_get_drvdata(sock->dev.parent); 282 fm->eject(fm, sock); 283 } 284 EXPORT_SYMBOL(tifm_eject); 285 286 int tifm_has_ms_pif(struct tifm_dev *sock) 287 { 288 struct tifm_adapter *fm = dev_get_drvdata(sock->dev.parent); 289 return fm->has_ms_pif(fm, sock); 290 } 291 EXPORT_SYMBOL(tifm_has_ms_pif); 292 293 int tifm_map_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents, 294 int direction) 295 { 296 return pci_map_sg(to_pci_dev(sock->dev.parent), sg, nents, direction); 297 } 298 EXPORT_SYMBOL(tifm_map_sg); 299 300 void tifm_unmap_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents, 301 int direction) 302 { 303 pci_unmap_sg(to_pci_dev(sock->dev.parent), sg, nents, direction); 304 } 305 EXPORT_SYMBOL(tifm_unmap_sg); 306 307 void tifm_queue_work(struct work_struct *work) 308 { 309 queue_work(workqueue, work); 310 } 311 EXPORT_SYMBOL(tifm_queue_work); 312 313 int tifm_register_driver(struct tifm_driver *drv) 314 { 315 drv->driver.bus = &tifm_bus_type; 316 317 return driver_register(&drv->driver); 318 } 319 EXPORT_SYMBOL(tifm_register_driver); 320 321 void tifm_unregister_driver(struct tifm_driver *drv) 322 { 323 driver_unregister(&drv->driver); 324 } 325 EXPORT_SYMBOL(tifm_unregister_driver); 326 327 static int __init tifm_init(void) 328 { 329 int rc; 330 331 workqueue = create_freezeable_workqueue("tifm"); 332 if (!workqueue) 333 return -ENOMEM; 334 335 rc = bus_register(&tifm_bus_type); 336 337 if (rc) 338 goto err_out_wq; 339 340 rc = class_register(&tifm_adapter_class); 341 if (!rc) 342 return 0; 343 344 bus_unregister(&tifm_bus_type); 345 346 err_out_wq: 347 destroy_workqueue(workqueue); 348 349 return rc; 350 } 351 352 static void __exit tifm_exit(void) 353 { 354 class_unregister(&tifm_adapter_class); 355 bus_unregister(&tifm_bus_type); 356 destroy_workqueue(workqueue); 357 } 358 359 subsys_initcall(tifm_init); 360 module_exit(tifm_exit); 361 362 MODULE_LICENSE("GPL"); 363 MODULE_AUTHOR("Alex Dubov"); 364 MODULE_DESCRIPTION("TI FlashMedia core driver"); 365 MODULE_LICENSE("GPL"); 366 MODULE_VERSION(DRIVER_VERSION); 367