ipack.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Industry-pack bus support functions.
  4. *
  5. * Copyright (C) 2011-2012 CERN (www.cern.ch)
  6. * Author: Samuel Iglesias Gonsalvez <siglesias@igalia.com>
  7. */
  8. #include <linux/module.h>
  9. #include <linux/slab.h>
  10. #include <linux/idr.h>
  11. #include <linux/io.h>
  12. #include <linux/ipack.h>
  13. #define to_ipack_dev(device) container_of(device, struct ipack_device, dev)
  14. #define to_ipack_driver(drv) container_of(drv, struct ipack_driver, driver)
  15. static DEFINE_IDA(ipack_ida);
  16. static void ipack_device_release(struct device *dev)
  17. {
  18. struct ipack_device *device = to_ipack_dev(dev);
  19. kfree(device->id);
  20. device->release(device);
  21. }
  22. static inline const struct ipack_device_id *
  23. ipack_match_one_device(const struct ipack_device_id *id,
  24. const struct ipack_device *device)
  25. {
  26. if ((id->format == IPACK_ANY_FORMAT ||
  27. id->format == device->id_format) &&
  28. (id->vendor == IPACK_ANY_ID || id->vendor == device->id_vendor) &&
  29. (id->device == IPACK_ANY_ID || id->device == device->id_device))
  30. return id;
  31. return NULL;
  32. }
  33. static const struct ipack_device_id *
  34. ipack_match_id(const struct ipack_device_id *ids, struct ipack_device *idev)
  35. {
  36. if (ids) {
  37. while (ids->vendor || ids->device) {
  38. if (ipack_match_one_device(ids, idev))
  39. return ids;
  40. ids++;
  41. }
  42. }
  43. return NULL;
  44. }
  45. static int ipack_bus_match(struct device *dev, struct device_driver *drv)
  46. {
  47. struct ipack_device *idev = to_ipack_dev(dev);
  48. struct ipack_driver *idrv = to_ipack_driver(drv);
  49. const struct ipack_device_id *found_id;
  50. found_id = ipack_match_id(idrv->id_table, idev);
  51. return found_id ? 1 : 0;
  52. }
  53. static int ipack_bus_probe(struct device *device)
  54. {
  55. struct ipack_device *dev = to_ipack_dev(device);
  56. struct ipack_driver *drv = to_ipack_driver(device->driver);
  57. if (!drv->ops->probe)
  58. return -EINVAL;
  59. return drv->ops->probe(dev);
  60. }
  61. static int ipack_bus_remove(struct device *device)
  62. {
  63. struct ipack_device *dev = to_ipack_dev(device);
  64. struct ipack_driver *drv = to_ipack_driver(device->driver);
  65. if (!drv->ops->remove)
  66. return -EINVAL;
  67. drv->ops->remove(dev);
  68. return 0;
  69. }
  70. static int ipack_uevent(struct device *dev, struct kobj_uevent_env *env)
  71. {
  72. struct ipack_device *idev;
  73. if (!dev)
  74. return -ENODEV;
  75. idev = to_ipack_dev(dev);
  76. if (add_uevent_var(env,
  77. "MODALIAS=ipack:f%02Xv%08Xd%08X", idev->id_format,
  78. idev->id_vendor, idev->id_device))
  79. return -ENOMEM;
  80. return 0;
  81. }
  82. #define ipack_device_attr(field, format_string) \
  83. static ssize_t \
  84. field##_show(struct device *dev, struct device_attribute *attr, \
  85. char *buf) \
  86. { \
  87. struct ipack_device *idev = to_ipack_dev(dev); \
  88. return sprintf(buf, format_string, idev->field); \
  89. }
  90. static ssize_t id_show(struct device *dev,
  91. struct device_attribute *attr, char *buf)
  92. {
  93. unsigned int i, c, l, s;
  94. struct ipack_device *idev = to_ipack_dev(dev);
  95. switch (idev->id_format) {
  96. case IPACK_ID_VERSION_1:
  97. l = 0x7; s = 1; break;
  98. case IPACK_ID_VERSION_2:
  99. l = 0xf; s = 2; break;
  100. default:
  101. return -EIO;
  102. }
  103. c = 0;
  104. for (i = 0; i < idev->id_avail; i++) {
  105. if (i > 0) {
  106. if ((i & l) == 0)
  107. buf[c++] = '\n';
  108. else if ((i & s) == 0)
  109. buf[c++] = ' ';
  110. }
  111. sprintf(&buf[c], "%02x", idev->id[i]);
  112. c += 2;
  113. }
  114. buf[c++] = '\n';
  115. return c;
  116. }
  117. static ssize_t
  118. id_vendor_show(struct device *dev, struct device_attribute *attr, char *buf)
  119. {
  120. struct ipack_device *idev = to_ipack_dev(dev);
  121. switch (idev->id_format) {
  122. case IPACK_ID_VERSION_1:
  123. return sprintf(buf, "0x%02x\n", idev->id_vendor);
  124. case IPACK_ID_VERSION_2:
  125. return sprintf(buf, "0x%06x\n", idev->id_vendor);
  126. default:
  127. return -EIO;
  128. }
  129. }
  130. static ssize_t
  131. id_device_show(struct device *dev, struct device_attribute *attr, char *buf)
  132. {
  133. struct ipack_device *idev = to_ipack_dev(dev);
  134. switch (idev->id_format) {
  135. case IPACK_ID_VERSION_1:
  136. return sprintf(buf, "0x%02x\n", idev->id_device);
  137. case IPACK_ID_VERSION_2:
  138. return sprintf(buf, "0x%04x\n", idev->id_device);
  139. default:
  140. return -EIO;
  141. }
  142. }
  143. static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
  144. char *buf)
  145. {
  146. struct ipack_device *idev = to_ipack_dev(dev);
  147. return sprintf(buf, "ipac:f%02Xv%08Xd%08X", idev->id_format,
  148. idev->id_vendor, idev->id_device);
  149. }
  150. ipack_device_attr(id_format, "0x%hhx\n");
  151. static DEVICE_ATTR_RO(id);
  152. static DEVICE_ATTR_RO(id_device);
  153. static DEVICE_ATTR_RO(id_format);
  154. static DEVICE_ATTR_RO(id_vendor);
  155. static DEVICE_ATTR_RO(modalias);
  156. static struct attribute *ipack_attrs[] = {
  157. &dev_attr_id.attr,
  158. &dev_attr_id_device.attr,
  159. &dev_attr_id_format.attr,
  160. &dev_attr_id_vendor.attr,
  161. &dev_attr_modalias.attr,
  162. NULL,
  163. };
  164. ATTRIBUTE_GROUPS(ipack);
  165. static struct bus_type ipack_bus_type = {
  166. .name = "ipack",
  167. .probe = ipack_bus_probe,
  168. .match = ipack_bus_match,
  169. .remove = ipack_bus_remove,
  170. .dev_groups = ipack_groups,
  171. .uevent = ipack_uevent,
  172. };
  173. struct ipack_bus_device *ipack_bus_register(struct device *parent, int slots,
  174. const struct ipack_bus_ops *ops,
  175. struct module *owner)
  176. {
  177. int bus_nr;
  178. struct ipack_bus_device *bus;
  179. bus = kzalloc(sizeof(*bus), GFP_KERNEL);
  180. if (!bus)
  181. return NULL;
  182. bus_nr = ida_simple_get(&ipack_ida, 0, 0, GFP_KERNEL);
  183. if (bus_nr < 0) {
  184. kfree(bus);
  185. return NULL;
  186. }
  187. bus->bus_nr = bus_nr;
  188. bus->parent = parent;
  189. bus->slots = slots;
  190. bus->ops = ops;
  191. bus->owner = owner;
  192. return bus;
  193. }
  194. EXPORT_SYMBOL_GPL(ipack_bus_register);
  195. static int ipack_unregister_bus_member(struct device *dev, void *data)
  196. {
  197. struct ipack_device *idev = to_ipack_dev(dev);
  198. struct ipack_bus_device *bus = data;
  199. if (idev->bus == bus)
  200. ipack_device_del(idev);
  201. return 1;
  202. }
  203. int ipack_bus_unregister(struct ipack_bus_device *bus)
  204. {
  205. bus_for_each_dev(&ipack_bus_type, NULL, bus,
  206. ipack_unregister_bus_member);
  207. ida_simple_remove(&ipack_ida, bus->bus_nr);
  208. kfree(bus);
  209. return 0;
  210. }
  211. EXPORT_SYMBOL_GPL(ipack_bus_unregister);
  212. int ipack_driver_register(struct ipack_driver *edrv, struct module *owner,
  213. const char *name)
  214. {
  215. edrv->driver.owner = owner;
  216. edrv->driver.name = name;
  217. edrv->driver.bus = &ipack_bus_type;
  218. return driver_register(&edrv->driver);
  219. }
  220. EXPORT_SYMBOL_GPL(ipack_driver_register);
  221. void ipack_driver_unregister(struct ipack_driver *edrv)
  222. {
  223. driver_unregister(&edrv->driver);
  224. }
  225. EXPORT_SYMBOL_GPL(ipack_driver_unregister);
  226. static u16 ipack_crc_byte(u16 crc, u8 c)
  227. {
  228. int i;
  229. crc ^= c << 8;
  230. for (i = 0; i < 8; i++)
  231. crc = (crc << 1) ^ ((crc & 0x8000) ? 0x1021 : 0);
  232. return crc;
  233. }
  234. /*
  235. * The algorithm in lib/crc-ccitt.c does not seem to apply since it uses the
  236. * opposite bit ordering.
  237. */
  238. static u8 ipack_calc_crc1(struct ipack_device *dev)
  239. {
  240. u8 c;
  241. u16 crc;
  242. unsigned int i;
  243. crc = 0xffff;
  244. for (i = 0; i < dev->id_avail; i++) {
  245. c = (i != 11) ? dev->id[i] : 0;
  246. crc = ipack_crc_byte(crc, c);
  247. }
  248. crc = ~crc;
  249. return crc & 0xff;
  250. }
  251. static u16 ipack_calc_crc2(struct ipack_device *dev)
  252. {
  253. u8 c;
  254. u16 crc;
  255. unsigned int i;
  256. crc = 0xffff;
  257. for (i = 0; i < dev->id_avail; i++) {
  258. c = ((i != 0x18) && (i != 0x19)) ? dev->id[i] : 0;
  259. crc = ipack_crc_byte(crc, c);
  260. }
  261. crc = ~crc;
  262. return crc;
  263. }
  264. static void ipack_parse_id1(struct ipack_device *dev)
  265. {
  266. u8 *id = dev->id;
  267. u8 crc;
  268. dev->id_vendor = id[4];
  269. dev->id_device = id[5];
  270. dev->speed_8mhz = 1;
  271. dev->speed_32mhz = (id[7] == 'H');
  272. crc = ipack_calc_crc1(dev);
  273. dev->id_crc_correct = (crc == id[11]);
  274. if (!dev->id_crc_correct) {
  275. dev_warn(&dev->dev, "ID CRC invalid found 0x%x, expected 0x%x.\n",
  276. id[11], crc);
  277. }
  278. }
  279. static void ipack_parse_id2(struct ipack_device *dev)
  280. {
  281. __be16 *id = (__be16 *) dev->id;
  282. u16 flags, crc;
  283. dev->id_vendor = ((be16_to_cpu(id[3]) & 0xff) << 16)
  284. + be16_to_cpu(id[4]);
  285. dev->id_device = be16_to_cpu(id[5]);
  286. flags = be16_to_cpu(id[10]);
  287. dev->speed_8mhz = !!(flags & 2);
  288. dev->speed_32mhz = !!(flags & 4);
  289. crc = ipack_calc_crc2(dev);
  290. dev->id_crc_correct = (crc == be16_to_cpu(id[12]));
  291. if (!dev->id_crc_correct) {
  292. dev_warn(&dev->dev, "ID CRC invalid found 0x%x, expected 0x%x.\n",
  293. id[11], crc);
  294. }
  295. }
  296. static int ipack_device_read_id(struct ipack_device *dev)
  297. {
  298. u8 __iomem *idmem;
  299. int i;
  300. int ret = 0;
  301. idmem = ioremap(dev->region[IPACK_ID_SPACE].start,
  302. dev->region[IPACK_ID_SPACE].size);
  303. if (!idmem) {
  304. dev_err(&dev->dev, "error mapping memory\n");
  305. return -ENOMEM;
  306. }
  307. /* Determine ID PROM Data Format. If we find the ids "IPAC" or "IPAH"
  308. * we are dealing with a IndustryPack format 1 device. If we detect
  309. * "VITA4 " (16 bit big endian formatted) we are dealing with a
  310. * IndustryPack format 2 device */
  311. if ((ioread8(idmem + 1) == 'I') &&
  312. (ioread8(idmem + 3) == 'P') &&
  313. (ioread8(idmem + 5) == 'A') &&
  314. ((ioread8(idmem + 7) == 'C') ||
  315. (ioread8(idmem + 7) == 'H'))) {
  316. dev->id_format = IPACK_ID_VERSION_1;
  317. dev->id_avail = ioread8(idmem + 0x15);
  318. if ((dev->id_avail < 0x0c) || (dev->id_avail > 0x40)) {
  319. dev_warn(&dev->dev, "invalid id size");
  320. dev->id_avail = 0x0c;
  321. }
  322. } else if ((ioread8(idmem + 0) == 'I') &&
  323. (ioread8(idmem + 1) == 'V') &&
  324. (ioread8(idmem + 2) == 'A') &&
  325. (ioread8(idmem + 3) == 'T') &&
  326. (ioread8(idmem + 4) == ' ') &&
  327. (ioread8(idmem + 5) == '4')) {
  328. dev->id_format = IPACK_ID_VERSION_2;
  329. dev->id_avail = ioread16be(idmem + 0x16);
  330. if ((dev->id_avail < 0x1a) || (dev->id_avail > 0x40)) {
  331. dev_warn(&dev->dev, "invalid id size");
  332. dev->id_avail = 0x1a;
  333. }
  334. } else {
  335. dev->id_format = IPACK_ID_VERSION_INVALID;
  336. dev->id_avail = 0;
  337. }
  338. if (!dev->id_avail) {
  339. ret = -ENODEV;
  340. goto out;
  341. }
  342. /* Obtain the amount of memory required to store a copy of the complete
  343. * ID ROM contents */
  344. dev->id = kmalloc(dev->id_avail, GFP_KERNEL);
  345. if (!dev->id) {
  346. ret = -ENOMEM;
  347. goto out;
  348. }
  349. for (i = 0; i < dev->id_avail; i++) {
  350. if (dev->id_format == IPACK_ID_VERSION_1)
  351. dev->id[i] = ioread8(idmem + (i << 1) + 1);
  352. else
  353. dev->id[i] = ioread8(idmem + i);
  354. }
  355. /* now we can finally work with the copy */
  356. switch (dev->id_format) {
  357. case IPACK_ID_VERSION_1:
  358. ipack_parse_id1(dev);
  359. break;
  360. case IPACK_ID_VERSION_2:
  361. ipack_parse_id2(dev);
  362. break;
  363. }
  364. out:
  365. iounmap(idmem);
  366. return ret;
  367. }
  368. int ipack_device_init(struct ipack_device *dev)
  369. {
  370. int ret;
  371. dev->dev.bus = &ipack_bus_type;
  372. dev->dev.release = ipack_device_release;
  373. dev->dev.parent = dev->bus->parent;
  374. dev_set_name(&dev->dev,
  375. "ipack-dev.%u.%u", dev->bus->bus_nr, dev->slot);
  376. device_initialize(&dev->dev);
  377. if (dev->bus->ops->set_clockrate(dev, 8))
  378. dev_warn(&dev->dev, "failed to switch to 8 MHz operation for reading of device ID.\n");
  379. if (dev->bus->ops->reset_timeout(dev))
  380. dev_warn(&dev->dev, "failed to reset potential timeout.");
  381. ret = ipack_device_read_id(dev);
  382. if (ret < 0) {
  383. dev_err(&dev->dev, "error reading device id section.\n");
  384. return ret;
  385. }
  386. /* if the device supports 32 MHz operation, use it. */
  387. if (dev->speed_32mhz) {
  388. ret = dev->bus->ops->set_clockrate(dev, 32);
  389. if (ret < 0)
  390. dev_err(&dev->dev, "failed to switch to 32 MHz operation.\n");
  391. }
  392. return 0;
  393. }
  394. EXPORT_SYMBOL_GPL(ipack_device_init);
  395. int ipack_device_add(struct ipack_device *dev)
  396. {
  397. return device_add(&dev->dev);
  398. }
  399. EXPORT_SYMBOL_GPL(ipack_device_add);
  400. void ipack_device_del(struct ipack_device *dev)
  401. {
  402. device_del(&dev->dev);
  403. ipack_put_device(dev);
  404. }
  405. EXPORT_SYMBOL_GPL(ipack_device_del);
  406. void ipack_get_device(struct ipack_device *dev)
  407. {
  408. get_device(&dev->dev);
  409. }
  410. EXPORT_SYMBOL_GPL(ipack_get_device);
  411. void ipack_put_device(struct ipack_device *dev)
  412. {
  413. put_device(&dev->dev);
  414. }
  415. EXPORT_SYMBOL_GPL(ipack_put_device);
  416. static int __init ipack_init(void)
  417. {
  418. ida_init(&ipack_ida);
  419. return bus_register(&ipack_bus_type);
  420. }
  421. static void __exit ipack_exit(void)
  422. {
  423. bus_unregister(&ipack_bus_type);
  424. ida_destroy(&ipack_ida);
  425. }
  426. module_init(ipack_init);
  427. module_exit(ipack_exit);
  428. MODULE_AUTHOR("Samuel Iglesias Gonsalvez <siglesias@igalia.com>");
  429. MODULE_LICENSE("GPL");
  430. MODULE_DESCRIPTION("Industry-pack bus core");