mcb-parse.c 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. #include <linux/types.h>
  3. #include <linux/ioport.h>
  4. #include <linux/slab.h>
  5. #include <linux/export.h>
  6. #include <linux/io.h>
  7. #include <linux/mcb.h>
  8. #include "mcb-internal.h"
  9. struct mcb_parse_priv {
  10. phys_addr_t mapbase;
  11. void __iomem *base;
  12. };
  13. #define for_each_chameleon_cell(dtype, p) \
  14. for ((dtype) = get_next_dtype((p)); \
  15. (dtype) != CHAMELEON_DTYPE_END; \
  16. (dtype) = get_next_dtype((p)))
  17. static inline uint32_t get_next_dtype(void __iomem *p)
  18. {
  19. uint32_t dtype;
  20. dtype = readl(p);
  21. return dtype >> 28;
  22. }
  23. static int chameleon_parse_bdd(struct mcb_bus *bus,
  24. struct chameleon_bar *cb,
  25. void __iomem *base)
  26. {
  27. return 0;
  28. }
  29. static int chameleon_parse_gdd(struct mcb_bus *bus,
  30. struct chameleon_bar *cb,
  31. void __iomem *base, int bar_count)
  32. {
  33. struct chameleon_gdd __iomem *gdd =
  34. (struct chameleon_gdd __iomem *) base;
  35. struct mcb_device *mdev;
  36. u32 dev_mapbase;
  37. u32 offset;
  38. u32 size;
  39. int ret;
  40. __le32 reg1;
  41. __le32 reg2;
  42. mdev = mcb_alloc_dev(bus);
  43. if (!mdev)
  44. return -ENOMEM;
  45. reg1 = readl(&gdd->reg1);
  46. reg2 = readl(&gdd->reg2);
  47. offset = readl(&gdd->offset);
  48. size = readl(&gdd->size);
  49. mdev->id = GDD_DEV(reg1);
  50. mdev->rev = GDD_REV(reg1);
  51. mdev->var = GDD_VAR(reg1);
  52. mdev->bar = GDD_BAR(reg2);
  53. mdev->group = GDD_GRP(reg2);
  54. mdev->inst = GDD_INS(reg2);
  55. /*
  56. * If the BAR is missing, dev_mapbase is zero, or if the
  57. * device is IO mapped we just print a warning and go on with the
  58. * next device, instead of completely stop the gdd parser
  59. */
  60. if (mdev->bar > bar_count - 1) {
  61. pr_info("No BAR for 16z%03d\n", mdev->id);
  62. ret = 0;
  63. goto err;
  64. }
  65. dev_mapbase = cb[mdev->bar].addr;
  66. if (!dev_mapbase) {
  67. pr_info("BAR not assigned for 16z%03d\n", mdev->id);
  68. ret = 0;
  69. goto err;
  70. }
  71. if (dev_mapbase & 0x01) {
  72. pr_info("IO mapped Device (16z%03d) not yet supported\n",
  73. mdev->id);
  74. ret = 0;
  75. goto err;
  76. }
  77. pr_debug("Found a 16z%03d\n", mdev->id);
  78. mdev->irq.start = GDD_IRQ(reg1);
  79. mdev->irq.end = GDD_IRQ(reg1);
  80. mdev->irq.flags = IORESOURCE_IRQ;
  81. mdev->mem.start = dev_mapbase + offset;
  82. mdev->mem.end = mdev->mem.start + size - 1;
  83. mdev->mem.flags = IORESOURCE_MEM;
  84. ret = mcb_device_register(bus, mdev);
  85. if (ret < 0)
  86. goto err;
  87. return 0;
  88. err:
  89. mcb_free_dev(mdev);
  90. return ret;
  91. }
  92. static void chameleon_parse_bar(void __iomem *base,
  93. struct chameleon_bar *cb, int bar_count)
  94. {
  95. char __iomem *p = base;
  96. int i;
  97. /* skip reg1 */
  98. p += sizeof(__le32);
  99. for (i = 0; i < bar_count; i++) {
  100. cb[i].addr = readl(p);
  101. cb[i].size = readl(p + 4);
  102. p += sizeof(struct chameleon_bar);
  103. }
  104. }
  105. static int chameleon_get_bar(void __iomem **base, phys_addr_t mapbase,
  106. struct chameleon_bar **cb)
  107. {
  108. struct chameleon_bar *c;
  109. int bar_count;
  110. __le32 reg;
  111. u32 dtype;
  112. /*
  113. * For those devices which are not connected
  114. * to the PCI Bus (e.g. LPC) there is a bar
  115. * descriptor located directly after the
  116. * chameleon header. This header is comparable
  117. * to a PCI header.
  118. */
  119. dtype = get_next_dtype(*base);
  120. if (dtype == CHAMELEON_DTYPE_BAR) {
  121. reg = readl(*base);
  122. bar_count = BAR_CNT(reg);
  123. if (bar_count <= 0 || bar_count > CHAMELEON_BAR_MAX)
  124. return -ENODEV;
  125. c = kcalloc(bar_count, sizeof(struct chameleon_bar),
  126. GFP_KERNEL);
  127. if (!c)
  128. return -ENOMEM;
  129. chameleon_parse_bar(*base, c, bar_count);
  130. *base += BAR_DESC_SIZE(bar_count);
  131. } else {
  132. c = kzalloc(sizeof(struct chameleon_bar), GFP_KERNEL);
  133. if (!c)
  134. return -ENOMEM;
  135. bar_count = 1;
  136. c->addr = mapbase;
  137. }
  138. *cb = c;
  139. return bar_count;
  140. }
  141. int chameleon_parse_cells(struct mcb_bus *bus, phys_addr_t mapbase,
  142. void __iomem *base)
  143. {
  144. struct chameleon_fpga_header *header;
  145. struct chameleon_bar *cb;
  146. void __iomem *p = base;
  147. int num_cells = 0;
  148. uint32_t dtype;
  149. int bar_count;
  150. int ret;
  151. u32 hsize;
  152. u32 table_size;
  153. hsize = sizeof(struct chameleon_fpga_header);
  154. header = kzalloc(hsize, GFP_KERNEL);
  155. if (!header)
  156. return -ENOMEM;
  157. /* Extract header information */
  158. memcpy_fromio(header, p, hsize);
  159. /* We only support chameleon v2 at the moment */
  160. header->magic = le16_to_cpu(header->magic);
  161. if (header->magic != CHAMELEONV2_MAGIC) {
  162. pr_err("Unsupported chameleon version 0x%x\n",
  163. header->magic);
  164. ret = -ENODEV;
  165. goto free_header;
  166. }
  167. p += hsize;
  168. bus->revision = header->revision;
  169. bus->model = header->model;
  170. bus->minor = header->minor;
  171. snprintf(bus->name, CHAMELEON_FILENAME_LEN + 1, "%s",
  172. header->filename);
  173. bar_count = chameleon_get_bar(&p, mapbase, &cb);
  174. if (bar_count < 0) {
  175. ret = bar_count;
  176. goto free_header;
  177. }
  178. for_each_chameleon_cell(dtype, p) {
  179. switch (dtype) {
  180. case CHAMELEON_DTYPE_GENERAL:
  181. ret = chameleon_parse_gdd(bus, cb, p, bar_count);
  182. if (ret < 0)
  183. goto free_bar;
  184. p += sizeof(struct chameleon_gdd);
  185. break;
  186. case CHAMELEON_DTYPE_BRIDGE:
  187. chameleon_parse_bdd(bus, cb, p);
  188. p += sizeof(struct chameleon_bdd);
  189. break;
  190. case CHAMELEON_DTYPE_END:
  191. break;
  192. default:
  193. pr_err("Invalid chameleon descriptor type 0x%x\n",
  194. dtype);
  195. ret = -EINVAL;
  196. goto free_bar;
  197. }
  198. num_cells++;
  199. }
  200. if (num_cells == 0) {
  201. ret = -EINVAL;
  202. goto free_bar;
  203. }
  204. table_size = p - base;
  205. pr_debug("%d cell(s) found. Chameleon table size: 0x%04x bytes\n", num_cells, table_size);
  206. kfree(cb);
  207. kfree(header);
  208. return table_size;
  209. free_bar:
  210. kfree(cb);
  211. free_header:
  212. kfree(header);
  213. return ret;
  214. }
  215. EXPORT_SYMBOL_NS_GPL(chameleon_parse_cells, MCB);