central.c 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271
  1. // SPDX-License-Identifier: GPL-2.0
  2. /* central.c: Central FHC driver for Sunfire/Starfire/Wildfire.
  3. *
  4. * Copyright (C) 1997, 1999, 2008 David S. Miller (davem@davemloft.net)
  5. */
  6. #include <linux/kernel.h>
  7. #include <linux/types.h>
  8. #include <linux/slab.h>
  9. #include <linux/export.h>
  10. #include <linux/string.h>
  11. #include <linux/init.h>
  12. #include <linux/of_device.h>
  13. #include <linux/platform_device.h>
  14. #include <asm/fhc.h>
  15. #include <asm/upa.h>
  16. struct clock_board {
  17. void __iomem *clock_freq_regs;
  18. void __iomem *clock_regs;
  19. void __iomem *clock_ver_reg;
  20. int num_slots;
  21. struct resource leds_resource;
  22. struct platform_device leds_pdev;
  23. };
  24. struct fhc {
  25. void __iomem *pregs;
  26. bool central;
  27. bool jtag_master;
  28. int board_num;
  29. struct resource leds_resource;
  30. struct platform_device leds_pdev;
  31. };
  32. static int clock_board_calc_nslots(struct clock_board *p)
  33. {
  34. u8 reg = upa_readb(p->clock_regs + CLOCK_STAT1) & 0xc0;
  35. switch (reg) {
  36. case 0x40:
  37. return 16;
  38. case 0xc0:
  39. return 8;
  40. case 0x80:
  41. reg = 0;
  42. if (p->clock_ver_reg)
  43. reg = upa_readb(p->clock_ver_reg);
  44. if (reg) {
  45. if (reg & 0x80)
  46. return 4;
  47. else
  48. return 5;
  49. }
  50. fallthrough;
  51. default:
  52. return 4;
  53. }
  54. }
  55. static int clock_board_probe(struct platform_device *op)
  56. {
  57. struct clock_board *p = kzalloc(sizeof(*p), GFP_KERNEL);
  58. int err = -ENOMEM;
  59. if (!p) {
  60. printk(KERN_ERR "clock_board: Cannot allocate struct clock_board\n");
  61. goto out;
  62. }
  63. p->clock_freq_regs = of_ioremap(&op->resource[0], 0,
  64. resource_size(&op->resource[0]),
  65. "clock_board_freq");
  66. if (!p->clock_freq_regs) {
  67. printk(KERN_ERR "clock_board: Cannot map clock_freq_regs\n");
  68. goto out_free;
  69. }
  70. p->clock_regs = of_ioremap(&op->resource[1], 0,
  71. resource_size(&op->resource[1]),
  72. "clock_board_regs");
  73. if (!p->clock_regs) {
  74. printk(KERN_ERR "clock_board: Cannot map clock_regs\n");
  75. goto out_unmap_clock_freq_regs;
  76. }
  77. if (op->resource[2].flags) {
  78. p->clock_ver_reg = of_ioremap(&op->resource[2], 0,
  79. resource_size(&op->resource[2]),
  80. "clock_ver_reg");
  81. if (!p->clock_ver_reg) {
  82. printk(KERN_ERR "clock_board: Cannot map clock_ver_reg\n");
  83. goto out_unmap_clock_regs;
  84. }
  85. }
  86. p->num_slots = clock_board_calc_nslots(p);
  87. p->leds_resource.start = (unsigned long)
  88. (p->clock_regs + CLOCK_CTRL);
  89. p->leds_resource.end = p->leds_resource.start;
  90. p->leds_resource.name = "leds";
  91. p->leds_pdev.name = "sunfire-clockboard-leds";
  92. p->leds_pdev.id = -1;
  93. p->leds_pdev.resource = &p->leds_resource;
  94. p->leds_pdev.num_resources = 1;
  95. p->leds_pdev.dev.parent = &op->dev;
  96. err = platform_device_register(&p->leds_pdev);
  97. if (err) {
  98. printk(KERN_ERR "clock_board: Could not register LEDS "
  99. "platform device\n");
  100. goto out_unmap_clock_ver_reg;
  101. }
  102. printk(KERN_INFO "clock_board: Detected %d slot Enterprise system.\n",
  103. p->num_slots);
  104. err = 0;
  105. out:
  106. return err;
  107. out_unmap_clock_ver_reg:
  108. if (p->clock_ver_reg)
  109. of_iounmap(&op->resource[2], p->clock_ver_reg,
  110. resource_size(&op->resource[2]));
  111. out_unmap_clock_regs:
  112. of_iounmap(&op->resource[1], p->clock_regs,
  113. resource_size(&op->resource[1]));
  114. out_unmap_clock_freq_regs:
  115. of_iounmap(&op->resource[0], p->clock_freq_regs,
  116. resource_size(&op->resource[0]));
  117. out_free:
  118. kfree(p);
  119. goto out;
  120. }
  121. static const struct of_device_id clock_board_match[] = {
  122. {
  123. .name = "clock-board",
  124. },
  125. {},
  126. };
  127. static struct platform_driver clock_board_driver = {
  128. .probe = clock_board_probe,
  129. .driver = {
  130. .name = "clock_board",
  131. .of_match_table = clock_board_match,
  132. },
  133. };
  134. static int fhc_probe(struct platform_device *op)
  135. {
  136. struct fhc *p = kzalloc(sizeof(*p), GFP_KERNEL);
  137. int err = -ENOMEM;
  138. u32 reg;
  139. if (!p) {
  140. printk(KERN_ERR "fhc: Cannot allocate struct fhc\n");
  141. goto out;
  142. }
  143. if (of_node_name_eq(op->dev.of_node->parent, "central"))
  144. p->central = true;
  145. p->pregs = of_ioremap(&op->resource[0], 0,
  146. resource_size(&op->resource[0]),
  147. "fhc_pregs");
  148. if (!p->pregs) {
  149. printk(KERN_ERR "fhc: Cannot map pregs\n");
  150. goto out_free;
  151. }
  152. if (p->central) {
  153. reg = upa_readl(p->pregs + FHC_PREGS_BSR);
  154. p->board_num = ((reg >> 16) & 1) | ((reg >> 12) & 0x0e);
  155. } else {
  156. p->board_num = of_getintprop_default(op->dev.of_node, "board#", -1);
  157. if (p->board_num == -1) {
  158. printk(KERN_ERR "fhc: No board# property\n");
  159. goto out_unmap_pregs;
  160. }
  161. if (upa_readl(p->pregs + FHC_PREGS_JCTRL) & FHC_JTAG_CTRL_MENAB)
  162. p->jtag_master = true;
  163. }
  164. if (!p->central) {
  165. p->leds_resource.start = (unsigned long)
  166. (p->pregs + FHC_PREGS_CTRL);
  167. p->leds_resource.end = p->leds_resource.start;
  168. p->leds_resource.name = "leds";
  169. p->leds_pdev.name = "sunfire-fhc-leds";
  170. p->leds_pdev.id = p->board_num;
  171. p->leds_pdev.resource = &p->leds_resource;
  172. p->leds_pdev.num_resources = 1;
  173. p->leds_pdev.dev.parent = &op->dev;
  174. err = platform_device_register(&p->leds_pdev);
  175. if (err) {
  176. printk(KERN_ERR "fhc: Could not register LEDS "
  177. "platform device\n");
  178. goto out_unmap_pregs;
  179. }
  180. }
  181. reg = upa_readl(p->pregs + FHC_PREGS_CTRL);
  182. if (!p->central)
  183. reg |= FHC_CONTROL_IXIST;
  184. reg &= ~(FHC_CONTROL_AOFF |
  185. FHC_CONTROL_BOFF |
  186. FHC_CONTROL_SLINE);
  187. upa_writel(reg, p->pregs + FHC_PREGS_CTRL);
  188. upa_readl(p->pregs + FHC_PREGS_CTRL);
  189. reg = upa_readl(p->pregs + FHC_PREGS_ID);
  190. printk(KERN_INFO "fhc: Board #%d, Version[%x] PartID[%x] Manuf[%x] %s\n",
  191. p->board_num,
  192. (reg & FHC_ID_VERS) >> 28,
  193. (reg & FHC_ID_PARTID) >> 12,
  194. (reg & FHC_ID_MANUF) >> 1,
  195. (p->jtag_master ?
  196. "(JTAG Master)" :
  197. (p->central ? "(Central)" : "")));
  198. err = 0;
  199. out:
  200. return err;
  201. out_unmap_pregs:
  202. of_iounmap(&op->resource[0], p->pregs, resource_size(&op->resource[0]));
  203. out_free:
  204. kfree(p);
  205. goto out;
  206. }
  207. static const struct of_device_id fhc_match[] = {
  208. {
  209. .name = "fhc",
  210. },
  211. {},
  212. };
  213. static struct platform_driver fhc_driver = {
  214. .probe = fhc_probe,
  215. .driver = {
  216. .name = "fhc",
  217. .of_match_table = fhc_match,
  218. },
  219. };
  220. static int __init sunfire_init(void)
  221. {
  222. (void) platform_driver_register(&fhc_driver);
  223. (void) platform_driver_register(&clock_board_driver);
  224. return 0;
  225. }
  226. fs_initcall(sunfire_init);