mcb-core.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * MEN Chameleon Bus.
  4. *
  5. * Copyright (C) 2013 MEN Mikroelektronik GmbH (www.men.de)
  6. * Author: Johannes Thumshirn <johannes.thumshirn@men.de>
  7. */
  8. #include <linux/kernel.h>
  9. #include <linux/module.h>
  10. #include <linux/slab.h>
  11. #include <linux/types.h>
  12. #include <linux/idr.h>
  13. #include <linux/mcb.h>
  14. static DEFINE_IDA(mcb_ida);
  15. static const struct mcb_device_id *mcb_match_id(const struct mcb_device_id *ids,
  16. struct mcb_device *dev)
  17. {
  18. if (ids) {
  19. while (ids->device) {
  20. if (ids->device == dev->id)
  21. return ids;
  22. ids++;
  23. }
  24. }
  25. return NULL;
  26. }
  27. static int mcb_match(struct device *dev, struct device_driver *drv)
  28. {
  29. struct mcb_driver *mdrv = to_mcb_driver(drv);
  30. struct mcb_device *mdev = to_mcb_device(dev);
  31. const struct mcb_device_id *found_id;
  32. found_id = mcb_match_id(mdrv->id_table, mdev);
  33. if (found_id)
  34. return 1;
  35. return 0;
  36. }
  37. static int mcb_uevent(struct device *dev, struct kobj_uevent_env *env)
  38. {
  39. struct mcb_device *mdev = to_mcb_device(dev);
  40. int ret;
  41. ret = add_uevent_var(env, "MODALIAS=mcb:16z%03d", mdev->id);
  42. if (ret)
  43. return -ENOMEM;
  44. return 0;
  45. }
  46. static int mcb_probe(struct device *dev)
  47. {
  48. struct mcb_driver *mdrv = to_mcb_driver(dev->driver);
  49. struct mcb_device *mdev = to_mcb_device(dev);
  50. const struct mcb_device_id *found_id;
  51. struct module *carrier_mod;
  52. int ret;
  53. found_id = mcb_match_id(mdrv->id_table, mdev);
  54. if (!found_id)
  55. return -ENODEV;
  56. carrier_mod = mdev->dev.parent->driver->owner;
  57. if (!try_module_get(carrier_mod))
  58. return -EINVAL;
  59. get_device(dev);
  60. ret = mdrv->probe(mdev, found_id);
  61. if (ret)
  62. module_put(carrier_mod);
  63. return ret;
  64. }
  65. static int mcb_remove(struct device *dev)
  66. {
  67. struct mcb_driver *mdrv = to_mcb_driver(dev->driver);
  68. struct mcb_device *mdev = to_mcb_device(dev);
  69. struct module *carrier_mod;
  70. mdrv->remove(mdev);
  71. carrier_mod = mdev->dev.parent->driver->owner;
  72. module_put(carrier_mod);
  73. put_device(&mdev->dev);
  74. return 0;
  75. }
  76. static void mcb_shutdown(struct device *dev)
  77. {
  78. struct mcb_driver *mdrv = to_mcb_driver(dev->driver);
  79. struct mcb_device *mdev = to_mcb_device(dev);
  80. if (mdrv && mdrv->shutdown)
  81. mdrv->shutdown(mdev);
  82. }
  83. static ssize_t revision_show(struct device *dev, struct device_attribute *attr,
  84. char *buf)
  85. {
  86. struct mcb_bus *bus = to_mcb_bus(dev);
  87. return scnprintf(buf, PAGE_SIZE, "%d\n", bus->revision);
  88. }
  89. static DEVICE_ATTR_RO(revision);
  90. static ssize_t model_show(struct device *dev, struct device_attribute *attr,
  91. char *buf)
  92. {
  93. struct mcb_bus *bus = to_mcb_bus(dev);
  94. return scnprintf(buf, PAGE_SIZE, "%c\n", bus->model);
  95. }
  96. static DEVICE_ATTR_RO(model);
  97. static ssize_t minor_show(struct device *dev, struct device_attribute *attr,
  98. char *buf)
  99. {
  100. struct mcb_bus *bus = to_mcb_bus(dev);
  101. return scnprintf(buf, PAGE_SIZE, "%d\n", bus->minor);
  102. }
  103. static DEVICE_ATTR_RO(minor);
  104. static ssize_t name_show(struct device *dev, struct device_attribute *attr,
  105. char *buf)
  106. {
  107. struct mcb_bus *bus = to_mcb_bus(dev);
  108. return scnprintf(buf, PAGE_SIZE, "%s\n", bus->name);
  109. }
  110. static DEVICE_ATTR_RO(name);
  111. static struct attribute *mcb_bus_attrs[] = {
  112. &dev_attr_revision.attr,
  113. &dev_attr_model.attr,
  114. &dev_attr_minor.attr,
  115. &dev_attr_name.attr,
  116. NULL,
  117. };
  118. static const struct attribute_group mcb_carrier_group = {
  119. .attrs = mcb_bus_attrs,
  120. };
  121. static const struct attribute_group *mcb_carrier_groups[] = {
  122. &mcb_carrier_group,
  123. NULL,
  124. };
  125. static struct bus_type mcb_bus_type = {
  126. .name = "mcb",
  127. .match = mcb_match,
  128. .uevent = mcb_uevent,
  129. .probe = mcb_probe,
  130. .remove = mcb_remove,
  131. .shutdown = mcb_shutdown,
  132. };
  133. static struct device_type mcb_carrier_device_type = {
  134. .name = "mcb-carrier",
  135. .groups = mcb_carrier_groups,
  136. };
  137. /**
  138. * __mcb_register_driver() - Register a @mcb_driver at the system
  139. * @drv: The @mcb_driver
  140. * @owner: The @mcb_driver's module
  141. * @mod_name: The name of the @mcb_driver's module
  142. *
  143. * Register a @mcb_driver at the system. Perform some sanity checks, if
  144. * the .probe and .remove methods are provided by the driver.
  145. */
  146. int __mcb_register_driver(struct mcb_driver *drv, struct module *owner,
  147. const char *mod_name)
  148. {
  149. if (!drv->probe || !drv->remove)
  150. return -EINVAL;
  151. drv->driver.owner = owner;
  152. drv->driver.bus = &mcb_bus_type;
  153. drv->driver.mod_name = mod_name;
  154. return driver_register(&drv->driver);
  155. }
  156. EXPORT_SYMBOL_NS_GPL(__mcb_register_driver, MCB);
  157. /**
  158. * mcb_unregister_driver() - Unregister a @mcb_driver from the system
  159. * @drv: The @mcb_driver
  160. *
  161. * Unregister a @mcb_driver from the system.
  162. */
  163. void mcb_unregister_driver(struct mcb_driver *drv)
  164. {
  165. driver_unregister(&drv->driver);
  166. }
  167. EXPORT_SYMBOL_NS_GPL(mcb_unregister_driver, MCB);
  168. static void mcb_release_dev(struct device *dev)
  169. {
  170. struct mcb_device *mdev = to_mcb_device(dev);
  171. mcb_bus_put(mdev->bus);
  172. kfree(mdev);
  173. }
  174. /**
  175. * mcb_device_register() - Register a mcb_device
  176. * @bus: The @mcb_bus of the device
  177. * @dev: The @mcb_device
  178. *
  179. * Register a specific @mcb_device at a @mcb_bus and the system itself.
  180. */
  181. int mcb_device_register(struct mcb_bus *bus, struct mcb_device *dev)
  182. {
  183. int ret;
  184. int device_id;
  185. device_initialize(&dev->dev);
  186. mcb_bus_get(bus);
  187. dev->dev.bus = &mcb_bus_type;
  188. dev->dev.parent = bus->dev.parent;
  189. dev->dev.release = mcb_release_dev;
  190. dev->dma_dev = bus->carrier;
  191. device_id = dev->id;
  192. dev_set_name(&dev->dev, "mcb%d-16z%03d-%d:%d:%d",
  193. bus->bus_nr, device_id, dev->inst, dev->group, dev->var);
  194. ret = device_add(&dev->dev);
  195. if (ret < 0) {
  196. pr_err("Failed registering device 16z%03d on bus mcb%d (%d)\n",
  197. device_id, bus->bus_nr, ret);
  198. goto out;
  199. }
  200. return 0;
  201. out:
  202. return ret;
  203. }
  204. EXPORT_SYMBOL_NS_GPL(mcb_device_register, MCB);
  205. static void mcb_free_bus(struct device *dev)
  206. {
  207. struct mcb_bus *bus = to_mcb_bus(dev);
  208. put_device(bus->carrier);
  209. ida_simple_remove(&mcb_ida, bus->bus_nr);
  210. kfree(bus);
  211. }
  212. /**
  213. * mcb_alloc_bus() - Allocate a new @mcb_bus
  214. *
  215. * Allocate a new @mcb_bus.
  216. */
  217. struct mcb_bus *mcb_alloc_bus(struct device *carrier)
  218. {
  219. struct mcb_bus *bus;
  220. int bus_nr;
  221. int rc;
  222. bus = kzalloc(sizeof(struct mcb_bus), GFP_KERNEL);
  223. if (!bus)
  224. return ERR_PTR(-ENOMEM);
  225. bus_nr = ida_simple_get(&mcb_ida, 0, 0, GFP_KERNEL);
  226. if (bus_nr < 0) {
  227. kfree(bus);
  228. return ERR_PTR(bus_nr);
  229. }
  230. bus->bus_nr = bus_nr;
  231. bus->carrier = get_device(carrier);
  232. device_initialize(&bus->dev);
  233. bus->dev.parent = carrier;
  234. bus->dev.bus = &mcb_bus_type;
  235. bus->dev.type = &mcb_carrier_device_type;
  236. bus->dev.release = &mcb_free_bus;
  237. dev_set_name(&bus->dev, "mcb:%d", bus_nr);
  238. rc = device_add(&bus->dev);
  239. if (rc)
  240. goto err_put;
  241. return bus;
  242. err_put:
  243. put_device(&bus->dev);
  244. return ERR_PTR(rc);
  245. }
  246. EXPORT_SYMBOL_NS_GPL(mcb_alloc_bus, MCB);
  247. static int __mcb_devices_unregister(struct device *dev, void *data)
  248. {
  249. device_unregister(dev);
  250. return 0;
  251. }
  252. static void mcb_devices_unregister(struct mcb_bus *bus)
  253. {
  254. bus_for_each_dev(&mcb_bus_type, NULL, NULL, __mcb_devices_unregister);
  255. }
  256. /**
  257. * mcb_release_bus() - Free a @mcb_bus
  258. * @bus: The @mcb_bus to release
  259. *
  260. * Release an allocated @mcb_bus from the system.
  261. */
  262. void mcb_release_bus(struct mcb_bus *bus)
  263. {
  264. mcb_devices_unregister(bus);
  265. }
  266. EXPORT_SYMBOL_NS_GPL(mcb_release_bus, MCB);
  267. /**
  268. * mcb_bus_put() - Increment refcnt
  269. * @bus: The @mcb_bus
  270. *
  271. * Get a @mcb_bus' ref
  272. */
  273. struct mcb_bus *mcb_bus_get(struct mcb_bus *bus)
  274. {
  275. if (bus)
  276. get_device(&bus->dev);
  277. return bus;
  278. }
  279. EXPORT_SYMBOL_NS_GPL(mcb_bus_get, MCB);
  280. /**
  281. * mcb_bus_put() - Decrement refcnt
  282. * @bus: The @mcb_bus
  283. *
  284. * Release a @mcb_bus' ref
  285. */
  286. void mcb_bus_put(struct mcb_bus *bus)
  287. {
  288. if (bus)
  289. put_device(&bus->dev);
  290. }
  291. EXPORT_SYMBOL_NS_GPL(mcb_bus_put, MCB);
  292. /**
  293. * mcb_alloc_dev() - Allocate a device
  294. * @bus: The @mcb_bus the device is part of
  295. *
  296. * Allocate a @mcb_device and add bus.
  297. */
  298. struct mcb_device *mcb_alloc_dev(struct mcb_bus *bus)
  299. {
  300. struct mcb_device *dev;
  301. dev = kzalloc(sizeof(struct mcb_device), GFP_KERNEL);
  302. if (!dev)
  303. return NULL;
  304. dev->bus = bus;
  305. return dev;
  306. }
  307. EXPORT_SYMBOL_NS_GPL(mcb_alloc_dev, MCB);
  308. /**
  309. * mcb_free_dev() - Free @mcb_device
  310. * @dev: The device to free
  311. *
  312. * Free a @mcb_device
  313. */
  314. void mcb_free_dev(struct mcb_device *dev)
  315. {
  316. kfree(dev);
  317. }
  318. EXPORT_SYMBOL_NS_GPL(mcb_free_dev, MCB);
  319. static int __mcb_bus_add_devices(struct device *dev, void *data)
  320. {
  321. struct mcb_device *mdev = to_mcb_device(dev);
  322. int retval;
  323. if (mdev->is_added)
  324. return 0;
  325. retval = device_attach(dev);
  326. if (retval < 0)
  327. dev_err(dev, "Error adding device (%d)\n", retval);
  328. mdev->is_added = true;
  329. return 0;
  330. }
  331. /**
  332. * mcb_bus_add_devices() - Add devices in the bus' internal device list
  333. * @bus: The @mcb_bus we add the devices
  334. *
  335. * Add devices in the bus' internal device list to the system.
  336. */
  337. void mcb_bus_add_devices(const struct mcb_bus *bus)
  338. {
  339. bus_for_each_dev(&mcb_bus_type, NULL, NULL, __mcb_bus_add_devices);
  340. }
  341. EXPORT_SYMBOL_NS_GPL(mcb_bus_add_devices, MCB);
  342. /**
  343. * mcb_get_resource() - get a resource for a mcb device
  344. * @dev: the mcb device
  345. * @type: the type of resource
  346. */
  347. struct resource *mcb_get_resource(struct mcb_device *dev, unsigned int type)
  348. {
  349. if (type == IORESOURCE_MEM)
  350. return &dev->mem;
  351. else if (type == IORESOURCE_IRQ)
  352. return &dev->irq;
  353. else
  354. return NULL;
  355. }
  356. EXPORT_SYMBOL_NS_GPL(mcb_get_resource, MCB);
  357. /**
  358. * mcb_request_mem() - Request memory
  359. * @dev: The @mcb_device the memory is for
  360. * @name: The name for the memory reference.
  361. *
  362. * Request memory for a @mcb_device. If @name is NULL the driver name will
  363. * be used.
  364. */
  365. struct resource *mcb_request_mem(struct mcb_device *dev, const char *name)
  366. {
  367. struct resource *mem;
  368. u32 size;
  369. if (!name)
  370. name = dev->dev.driver->name;
  371. size = resource_size(&dev->mem);
  372. mem = request_mem_region(dev->mem.start, size, name);
  373. if (!mem)
  374. return ERR_PTR(-EBUSY);
  375. return mem;
  376. }
  377. EXPORT_SYMBOL_NS_GPL(mcb_request_mem, MCB);
  378. /**
  379. * mcb_release_mem() - Release memory requested by device
  380. * @dev: The @mcb_device that requested the memory
  381. *
  382. * Release memory that was prior requested via @mcb_request_mem().
  383. */
  384. void mcb_release_mem(struct resource *mem)
  385. {
  386. u32 size;
  387. size = resource_size(mem);
  388. release_mem_region(mem->start, size);
  389. }
  390. EXPORT_SYMBOL_NS_GPL(mcb_release_mem, MCB);
  391. static int __mcb_get_irq(struct mcb_device *dev)
  392. {
  393. struct resource *irq;
  394. irq = mcb_get_resource(dev, IORESOURCE_IRQ);
  395. return irq->start;
  396. }
  397. /**
  398. * mcb_get_irq() - Get device's IRQ number
  399. * @dev: The @mcb_device the IRQ is for
  400. *
  401. * Get the IRQ number of a given @mcb_device.
  402. */
  403. int mcb_get_irq(struct mcb_device *dev)
  404. {
  405. struct mcb_bus *bus = dev->bus;
  406. if (bus->get_irq)
  407. return bus->get_irq(dev);
  408. return __mcb_get_irq(dev);
  409. }
  410. EXPORT_SYMBOL_NS_GPL(mcb_get_irq, MCB);
  411. static int mcb_init(void)
  412. {
  413. return bus_register(&mcb_bus_type);
  414. }
  415. static void mcb_exit(void)
  416. {
  417. ida_destroy(&mcb_ida);
  418. bus_unregister(&mcb_bus_type);
  419. }
  420. /* mcb must be initialized after PCI but before the chameleon drivers.
  421. * That means we must use some initcall between subsys_initcall and
  422. * device_initcall.
  423. */
  424. fs_initcall(mcb_init);
  425. module_exit(mcb_exit);
  426. MODULE_DESCRIPTION("MEN Chameleon Bus Driver");
  427. MODULE_AUTHOR("Johannes Thumshirn <johannes.thumshirn@men.de>");
  428. MODULE_LICENSE("GPL v2");