1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * tifm_core.c - TI FlashMedia driver 4 * 5 * Copyright (C) 2006 Alex Dubov <oakad@yahoo.com> 6 */ 7 8 #include <linux/tifm.h> 9 #include <linux/slab.h> 10 #include <linux/init.h> 11 #include <linux/idr.h> 12 #include <linux/module.h> 13 14 #define DRIVER_NAME "tifm_core" 15 #define DRIVER_VERSION "0.8" 16 17 static struct workqueue_struct *workqueue; 18 static DEFINE_IDR(tifm_adapter_idr); 19 static DEFINE_SPINLOCK(tifm_adapter_lock); 20 21 static const char *tifm_media_type_name(unsigned char type, unsigned char nt) 22 { 23 const char *card_type_name[3][3] = { 24 { "SmartMedia/xD", "MemoryStick", "MMC/SD" }, 25 { "XD", "MS", "SD"}, 26 { "xd", "ms", "sd"} 27 }; 28 29 if (nt > 2 || type < 1 || type > 3) 30 return NULL; 31 return card_type_name[nt][type - 1]; 32 } 33 34 static int tifm_dev_match(struct tifm_dev *sock, struct tifm_device_id *id) 35 { 36 if (sock->type == id->type) 37 return 1; 38 return 0; 39 } 40 41 static int tifm_bus_match(struct device *dev, struct device_driver *drv) 42 { 43 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 44 struct tifm_driver *fm_drv = container_of(drv, struct tifm_driver, 45 driver); 46 struct tifm_device_id *ids = fm_drv->id_table; 47 48 if (ids) { 49 while (ids->type) { 50 if (tifm_dev_match(sock, ids)) 51 return 1; 52 ++ids; 53 } 54 } 55 return 0; 56 } 57 58 static int tifm_uevent(struct device *dev, struct kobj_uevent_env *env) 59 { 60 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 61 62 if (add_uevent_var(env, "TIFM_CARD_TYPE=%s", tifm_media_type_name(sock->type, 1))) 63 return -ENOMEM; 64 65 return 0; 66 } 67 68 static int tifm_device_probe(struct device *dev) 69 { 70 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 71 struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, 72 driver); 73 int rc = -ENODEV; 74 75 get_device(dev); 76 if (dev->driver && drv->probe) { 77 rc = drv->probe(sock); 78 if (!rc) 79 return 0; 80 } 81 put_device(dev); 82 return rc; 83 } 84 85 static void tifm_dummy_event(struct tifm_dev *sock) 86 { 87 return; 88 } 89 90 static void tifm_device_remove(struct device *dev) 91 { 92 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 93 struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, 94 driver); 95 96 if (dev->driver && drv->remove) { 97 sock->card_event = tifm_dummy_event; 98 sock->data_event = tifm_dummy_event; 99 drv->remove(sock); 100 sock->dev.driver = NULL; 101 } 102 103 put_device(dev); 104 } 105 106 #ifdef CONFIG_PM 107 108 static int tifm_device_suspend(struct device *dev, pm_message_t state) 109 { 110 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 111 struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, 112 driver); 113 114 if (dev->driver && drv->suspend) 115 return drv->suspend(sock, state); 116 return 0; 117 } 118 119 static int tifm_device_resume(struct device *dev) 120 { 121 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 122 struct tifm_driver *drv = container_of(dev->driver, struct tifm_driver, 123 driver); 124 125 if (dev->driver && drv->resume) 126 return drv->resume(sock); 127 return 0; 128 } 129 130 #else 131 132 #define tifm_device_suspend NULL 133 #define tifm_device_resume NULL 134 135 #endif /* CONFIG_PM */ 136 137 static ssize_t type_show(struct device *dev, struct device_attribute *attr, 138 char *buf) 139 { 140 struct tifm_dev *sock = container_of(dev, struct tifm_dev, dev); 141 return sprintf(buf, "%x", sock->type); 142 } 143 static DEVICE_ATTR_RO(type); 144 145 static struct attribute *tifm_dev_attrs[] = { 146 &dev_attr_type.attr, 147 NULL, 148 }; 149 ATTRIBUTE_GROUPS(tifm_dev); 150 151 static struct bus_type tifm_bus_type = { 152 .name = "tifm", 153 .dev_groups = tifm_dev_groups, 154 .match = tifm_bus_match, 155 .uevent = tifm_uevent, 156 .probe = tifm_device_probe, 157 .remove = tifm_device_remove, 158 .suspend = tifm_device_suspend, 159 .resume = tifm_device_resume 160 }; 161 162 static void tifm_free(struct device *dev) 163 { 164 struct tifm_adapter *fm = container_of(dev, struct tifm_adapter, dev); 165 166 kfree(fm); 167 } 168 169 static struct class tifm_adapter_class = { 170 .name = "tifm_adapter", 171 .dev_release = tifm_free 172 }; 173 174 struct tifm_adapter *tifm_alloc_adapter(unsigned int num_sockets, 175 struct device *dev) 176 { 177 struct tifm_adapter *fm; 178 179 fm = kzalloc(sizeof(struct tifm_adapter) 180 + sizeof(struct tifm_dev*) * num_sockets, GFP_KERNEL); 181 if (fm) { 182 fm->dev.class = &tifm_adapter_class; 183 fm->dev.parent = dev; 184 device_initialize(&fm->dev); 185 spin_lock_init(&fm->lock); 186 fm->num_sockets = num_sockets; 187 } 188 return fm; 189 } 190 EXPORT_SYMBOL(tifm_alloc_adapter); 191 192 int tifm_add_adapter(struct tifm_adapter *fm) 193 { 194 int rc; 195 196 idr_preload(GFP_KERNEL); 197 spin_lock(&tifm_adapter_lock); 198 rc = idr_alloc(&tifm_adapter_idr, fm, 0, 0, GFP_NOWAIT); 199 if (rc >= 0) 200 fm->id = rc; 201 spin_unlock(&tifm_adapter_lock); 202 idr_preload_end(); 203 if (rc < 0) 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_freezable_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