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 
19 struct 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 
28 struct 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 
clock_board_calc_nslots(struct clock_board * p)37 static 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 
clock_board_probe(struct platform_device * op)64 static 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;
124 out:
125 	return err;
126 
127 out_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 
132 out_unmap_clock_regs:
133 	of_iounmap(&op->resource[1], p->clock_regs,
134 		   resource_size(&op->resource[1]));
135 
136 out_unmap_clock_freq_regs:
137 	of_iounmap(&op->resource[0], p->clock_freq_regs,
138 		   resource_size(&op->resource[0]));
139 
140 out_free:
141 	kfree(p);
142 	goto out;
143 }
144 
145 static const struct of_device_id clock_board_match[] = {
146 	{
147 		.name = "clock-board",
148 	},
149 	{},
150 };
151 
152 static 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 
fhc_probe(struct platform_device * op)160 static 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 (of_node_name_eq(op->dev.of_node->parent, "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 
238 out:
239 	return err;
240 
241 out_unmap_pregs:
242 	of_iounmap(&op->resource[0], p->pregs, resource_size(&op->resource[0]));
243 
244 out_free:
245 	kfree(p);
246 	goto out;
247 }
248 
249 static const struct of_device_id fhc_match[] = {
250 	{
251 		.name = "fhc",
252 	},
253 	{},
254 };
255 
256 static struct platform_driver fhc_driver = {
257 	.probe		= fhc_probe,
258 	.driver = {
259 		.name = "fhc",
260 		.of_match_table = fhc_match,
261 	},
262 };
263 
sunfire_init(void)264 static 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 
271 fs_initcall(sunfire_init);
272