1
2
3
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
57 default:
58 return 4;
59 }
60}
61
62static int __devinit clock_board_probe(struct platform_device *op,
63 const struct of_device_id *match)
64{
65 struct clock_board *p = kzalloc(sizeof(*p), GFP_KERNEL);
66 int err = -ENOMEM;
67
68 if (!p) {
69 printk(KERN_ERR "clock_board: Cannot allocate struct clock_board\n");
70 goto out;
71 }
72
73 p->clock_freq_regs = of_ioremap(&op->resource[0], 0,
74 resource_size(&op->resource[0]),
75 "clock_board_freq");
76 if (!p->clock_freq_regs) {
77 printk(KERN_ERR "clock_board: Cannot map clock_freq_regs\n");
78 goto out_free;
79 }
80
81 p->clock_regs = of_ioremap(&op->resource[1], 0,
82 resource_size(&op->resource[1]),
83 "clock_board_regs");
84 if (!p->clock_regs) {
85 printk(KERN_ERR "clock_board: Cannot map clock_regs\n");
86 goto out_unmap_clock_freq_regs;
87 }
88
89 if (op->resource[2].flags) {
90 p->clock_ver_reg = of_ioremap(&op->resource[2], 0,
91 resource_size(&op->resource[2]),
92 "clock_ver_reg");
93 if (!p->clock_ver_reg) {
94 printk(KERN_ERR "clock_board: Cannot map clock_ver_reg\n");
95 goto out_unmap_clock_regs;
96 }
97 }
98
99 p->num_slots = clock_board_calc_nslots(p);
100
101 p->leds_resource.start = (unsigned long)
102 (p->clock_regs + CLOCK_CTRL);
103 p->leds_resource.end = p->leds_resource.start;
104 p->leds_resource.name = "leds";
105
106 p->leds_pdev.name = "sunfire-clockboard-leds";
107 p->leds_pdev.id = -1;
108 p->leds_pdev.resource = &p->leds_resource;
109 p->leds_pdev.num_resources = 1;
110 p->leds_pdev.dev.parent = &op->dev;
111
112 err = platform_device_register(&p->leds_pdev);
113 if (err) {
114 printk(KERN_ERR "clock_board: Could not register LEDS "
115 "platform device\n");
116 goto out_unmap_clock_ver_reg;
117 }
118
119 printk(KERN_INFO "clock_board: Detected %d slot Enterprise system.\n",
120 p->num_slots);
121
122 err = 0;
123out:
124 return err;
125
126out_unmap_clock_ver_reg:
127 if (p->clock_ver_reg)
128 of_iounmap(&op->resource[2], p->clock_ver_reg,
129 resource_size(&op->resource[2]));
130
131out_unmap_clock_regs:
132 of_iounmap(&op->resource[1], p->clock_regs,
133 resource_size(&op->resource[1]));
134
135out_unmap_clock_freq_regs:
136 of_iounmap(&op->resource[0], p->clock_freq_regs,
137 resource_size(&op->resource[0]));
138
139out_free:
140 kfree(p);
141 goto out;
142}
143
144static struct of_device_id __initdata clock_board_match[] = {
145 {
146 .name = "clock-board",
147 },
148 {},
149};
150
151static struct of_platform_driver clock_board_driver = {
152 .probe = clock_board_probe,
153 .driver = {
154 .name = "clock_board",
155 .owner = THIS_MODULE,
156 .of_match_table = clock_board_match,
157 },
158};
159
160static int __devinit fhc_probe(struct platform_device *op,
161 const struct of_device_id *match)
162{
163 struct fhc *p = kzalloc(sizeof(*p), GFP_KERNEL);
164 int err = -ENOMEM;
165 u32 reg;
166
167 if (!p) {
168 printk(KERN_ERR "fhc: Cannot allocate struct fhc\n");
169 goto out;
170 }
171
172 if (!strcmp(op->dev.of_node->parent->name, "central"))
173 p->central = true;
174
175 p->pregs = of_ioremap(&op->resource[0], 0,
176 resource_size(&op->resource[0]),
177 "fhc_pregs");
178 if (!p->pregs) {
179 printk(KERN_ERR "fhc: Cannot map pregs\n");
180 goto out_free;
181 }
182
183 if (p->central) {
184 reg = upa_readl(p->pregs + FHC_PREGS_BSR);
185 p->board_num = ((reg >> 16) & 1) | ((reg >> 12) & 0x0e);
186 } else {
187 p->board_num = of_getintprop_default(op->dev.of_node, "board#", -1);
188 if (p->board_num == -1) {
189 printk(KERN_ERR "fhc: No board# property\n");
190 goto out_unmap_pregs;
191 }
192 if (upa_readl(p->pregs + FHC_PREGS_JCTRL) & FHC_JTAG_CTRL_MENAB)
193 p->jtag_master = true;
194 }
195
196 if (!p->central) {
197 p->leds_resource.start = (unsigned long)
198 (p->pregs + FHC_PREGS_CTRL);
199 p->leds_resource.end = p->leds_resource.start;
200 p->leds_resource.name = "leds";
201
202 p->leds_pdev.name = "sunfire-fhc-leds";
203 p->leds_pdev.id = p->board_num;
204 p->leds_pdev.resource = &p->leds_resource;
205 p->leds_pdev.num_resources = 1;
206 p->leds_pdev.dev.parent = &op->dev;
207
208 err = platform_device_register(&p->leds_pdev);
209 if (err) {
210 printk(KERN_ERR "fhc: Could not register LEDS "
211 "platform device\n");
212 goto out_unmap_pregs;
213 }
214 }
215 reg = upa_readl(p->pregs + FHC_PREGS_CTRL);
216
217 if (!p->central)
218 reg |= FHC_CONTROL_IXIST;
219
220 reg &= ~(FHC_CONTROL_AOFF |
221 FHC_CONTROL_BOFF |
222 FHC_CONTROL_SLINE);
223
224 upa_writel(reg, p->pregs + FHC_PREGS_CTRL);
225 upa_readl(p->pregs + FHC_PREGS_CTRL);
226
227 reg = upa_readl(p->pregs + FHC_PREGS_ID);
228 printk(KERN_INFO "fhc: Board #%d, Version[%x] PartID[%x] Manuf[%x] %s\n",
229 p->board_num,
230 (reg & FHC_ID_VERS) >> 28,
231 (reg & FHC_ID_PARTID) >> 12,
232 (reg & FHC_ID_MANUF) >> 1,
233 (p->jtag_master ?
234 "(JTAG Master)" :
235 (p->central ? "(Central)" : "")));
236
237 err = 0;
238
239out:
240 return err;
241
242out_unmap_pregs:
243 of_iounmap(&op->resource[0], p->pregs, resource_size(&op->resource[0]));
244
245out_free:
246 kfree(p);
247 goto out;
248}
249
250static struct of_device_id __initdata fhc_match[] = {
251 {
252 .name = "fhc",
253 },
254 {},
255};
256
257static struct of_platform_driver fhc_driver = {
258 .probe = fhc_probe,
259 .driver = {
260 .name = "fhc",
261 .owner = THIS_MODULE,
262 .of_match_table = fhc_match,
263 },
264};
265
266static int __init sunfire_init(void)
267{
268 (void) of_register_platform_driver(&fhc_driver);
269 (void) of_register_platform_driver(&clock_board_driver);
270 return 0;
271}
272
273subsys_initcall(sunfire_init);
274
