cfa2624c5332ea43f20c9232555b80a3e95fde59
[linux-3.10.git] / arch / sparc / kernel / central.c
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
17 struct 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
26 struct 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
35 static 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
62 static 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;
123 out:
124         return err;
125
126 out_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
131 out_unmap_clock_regs:
132         of_iounmap(&op->resource[1], p->clock_regs,
133                    resource_size(&op->resource[1]));
134
135 out_unmap_clock_freq_regs:
136         of_iounmap(&op->resource[0], p->clock_freq_regs,
137                    resource_size(&op->resource[0]));
138
139 out_free:
140         kfree(p);
141         goto out;
142 }
143
144 static struct of_device_id __initdata clock_board_match[] = {
145         {
146                 .name = "clock-board",
147         },
148         {},
149 };
150
151 static 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
160 static 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
239 out:
240         return err;
241
242 out_unmap_pregs:
243         of_iounmap(&op->resource[0], p->pregs, resource_size(&op->resource[0]));
244
245 out_free:
246         kfree(p);
247         goto out;
248 }
249
250 static struct of_device_id __initdata fhc_match[] = {
251         {
252                 .name = "fhc",
253         },
254         {},
255 };
256
257 static 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
266 static 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
273 subsys_initcall(sunfire_init);