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