dm crypt: fix async split
[linux-2.6] / arch / sparc64 / 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/string.h>
9 #include <linux/init.h>
10 #include <linux/of_device.h>
11 #include <linux/platform_device.h>
12
13 #include <asm/fhc.h>
14 #include <asm/upa.h>
15
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
25 struct fhc {
26         void __iomem            *pregs;
27         bool                    central;
28         bool                    jtag_master;
29         int                     board_num;
30         struct resource         leds_resource;
31         struct platform_device  leds_pdev;
32 };
33
34 static int __devinit clock_board_calc_nslots(struct clock_board *p)
35 {
36         u8 reg = upa_readb(p->clock_regs + CLOCK_STAT1) & 0xc0;
37
38         switch (reg) {
39         case 0x40:
40                 return 16;
41
42         case 0xc0:
43                 return 8;
44
45         case 0x80:
46                 reg = 0;
47                 if (p->clock_ver_reg)
48                         reg = upa_readb(p->clock_ver_reg);
49                 if (reg) {
50                         if (reg & 0x80)
51                                 return 4;
52                         else
53                                 return 5;
54                 }
55                 /* Fallthrough */
56         default:
57                 return 4;
58         }
59 }
60
61 static int __devinit clock_board_probe(struct of_device *op,
62                                        const struct of_device_id *match)
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.end;
103         p->leds_resource.name = "leds";
104
105         p->leds_pdev.name = "sunfire-clockboard-leds";
106         p->leds_pdev.resource = &p->leds_resource;
107         p->leds_pdev.num_resources = 1;
108         p->leds_pdev.dev.parent = &op->dev;
109
110         err = platform_device_register(&p->leds_pdev);
111         if (err) {
112                 printk(KERN_ERR "clock_board: Could not register LEDS "
113                        "platform device\n");
114                 goto out_unmap_clock_ver_reg;
115         }
116
117         printk(KERN_INFO "clock_board: Detected %d slot Enterprise system.\n",
118                p->num_slots);
119
120         err = 0;
121 out:
122         return err;
123
124 out_unmap_clock_ver_reg:
125         if (p->clock_ver_reg)
126                 of_iounmap(&op->resource[2], p->clock_ver_reg,
127                            resource_size(&op->resource[2]));
128
129 out_unmap_clock_regs:
130         of_iounmap(&op->resource[1], p->clock_regs,
131                    resource_size(&op->resource[1]));
132
133 out_unmap_clock_freq_regs:
134         of_iounmap(&op->resource[0], p->clock_freq_regs,
135                    resource_size(&op->resource[0]));
136
137 out_free:
138         kfree(p);
139         goto out;
140 }
141
142 static struct of_device_id __initdata clock_board_match[] = {
143         {
144                 .name = "clock-board",
145         },
146         {},
147 };
148
149 static struct of_platform_driver clock_board_driver = {
150         .match_table    = clock_board_match,
151         .probe          = clock_board_probe,
152         .driver         = {
153                 .name   = "clock_board",
154         },
155 };
156
157 static int __devinit fhc_probe(struct of_device *op,
158                                const struct of_device_id *match)
159 {
160         struct fhc *p = kzalloc(sizeof(*p), GFP_KERNEL);
161         int err = -ENOMEM;
162         u32 reg;
163
164         if (!p) {
165                 printk(KERN_ERR "fhc: Cannot allocate struct fhc\n");
166                 goto out;
167         }
168
169         if (!strcmp(op->node->parent->name, "central"))
170                 p->central = true;
171
172         p->pregs = of_ioremap(&op->resource[0], 0,
173                               resource_size(&op->resource[0]),
174                               "fhc_pregs");
175         if (!p->pregs) {
176                 printk(KERN_ERR "fhc: Cannot map pregs\n");
177                 goto out_free;
178         }
179
180         if (p->central) {
181                 reg = upa_readl(p->pregs + FHC_PREGS_BSR);
182                 p->board_num = ((reg >> 16) & 1) | ((reg >> 12) & 0x0e);
183         } else {
184                 p->board_num = of_getintprop_default(op->node, "board#", -1);
185                 if (p->board_num == -1) {
186                         printk(KERN_ERR "fhc: No board# property\n");
187                         goto out_unmap_pregs;
188                 }
189                 if (upa_readl(p->pregs + FHC_PREGS_JCTRL) & FHC_JTAG_CTRL_MENAB)
190                         p->jtag_master = true;
191         }
192
193         if (!p->central) {
194                 p->leds_resource.start = (unsigned long)
195                         (p->pregs + FHC_PREGS_CTRL);
196                 p->leds_resource.end = p->leds_resource.end;
197                 p->leds_resource.name = "leds";
198
199                 p->leds_pdev.name = "sunfire-fhc-leds";
200                 p->leds_pdev.resource = &p->leds_resource;
201                 p->leds_pdev.num_resources = 1;
202                 p->leds_pdev.dev.parent = &op->dev;
203
204                 err = platform_device_register(&p->leds_pdev);
205                 if (err) {
206                         printk(KERN_ERR "fhc: Could not register LEDS "
207                                "platform device\n");
208                         goto out_unmap_pregs;
209                 }
210         }
211         reg = upa_readl(p->pregs + FHC_PREGS_CTRL);
212
213         if (!p->central)
214                 reg |= FHC_CONTROL_IXIST;
215
216         reg &= ~(FHC_CONTROL_AOFF |
217                  FHC_CONTROL_BOFF |
218                  FHC_CONTROL_SLINE);
219
220         upa_writel(reg, p->pregs + FHC_PREGS_CTRL);
221         upa_readl(p->pregs + FHC_PREGS_CTRL);
222
223         reg = upa_readl(p->pregs + FHC_PREGS_ID);
224         printk(KERN_INFO "fhc: Board #%d, Version[%x] PartID[%x] Manuf[%x] %s\n",
225                p->board_num,
226                (reg & FHC_ID_VERS) >> 28,
227                (reg & FHC_ID_PARTID) >> 12,
228                (reg & FHC_ID_MANUF) >> 1,
229                (p->jtag_master ?
230                 "(JTAG Master)" :
231                 (p->central ? "(Central)" : "")));
232
233         err = 0;
234
235 out:
236         return err;
237
238 out_unmap_pregs:
239         of_iounmap(&op->resource[0], p->pregs, resource_size(&op->resource[0]));
240
241 out_free:
242         kfree(p);
243         goto out;
244 }
245
246 static struct of_device_id __initdata fhc_match[] = {
247         {
248                 .name = "fhc",
249         },
250         {},
251 };
252
253 static struct of_platform_driver fhc_driver = {
254         .match_table    = fhc_match,
255         .probe          = fhc_probe,
256         .driver         = {
257                 .name   = "fhc",
258         },
259 };
260
261 static int __init sunfire_init(void)
262 {
263         (void) of_register_driver(&fhc_driver, &of_platform_bus_type);
264         (void) of_register_driver(&clock_board_driver, &of_platform_bus_type);
265         return 0;
266 }
267
268 subsys_initcall(sunfire_init);