Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/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/export.h>
 10 #include <linux/string.h>
 11 #include <linux/init.h>
 12 #include <linux/of_device.h>
 13 #include <linux/platform_device.h>
 14 
 15 #include <asm/fhc.h>
 16 #include <asm/upa.h>
 17 
 18 struct clock_board {
 19         void __iomem            *clock_freq_regs;
 20         void __iomem            *clock_regs;
 21         void __iomem            *clock_ver_reg;
 22         int                     num_slots;
 23         struct resource         leds_resource;
 24         struct platform_device  leds_pdev;
 25 };
 26 
 27 struct fhc {
 28         void __iomem            *pregs;
 29         bool                    central;
 30         bool                    jtag_master;
 31         int                     board_num;
 32         struct resource         leds_resource;
 33         struct platform_device  leds_pdev;
 34 };
 35 
 36 static int clock_board_calc_nslots(struct clock_board *p)
 37 {
 38         u8 reg = upa_readb(p->clock_regs + CLOCK_STAT1) & 0xc0;
 39 
 40         switch (reg) {
 41         case 0x40:
 42                 return 16;
 43 
 44         case 0xc0:
 45                 return 8;
 46 
 47         case 0x80:
 48                 reg = 0;
 49                 if (p->clock_ver_reg)
 50                         reg = upa_readb(p->clock_ver_reg);
 51                 if (reg) {
 52                         if (reg & 0x80)
 53                                 return 4;
 54                         else
 55                                 return 5;
 56                 }
 57                 /* Fallthrough */
 58         default:
 59                 return 4;
 60         }
 61 }
 62 
 63 static int clock_board_probe(struct platform_device *op)
 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 const struct of_device_id clock_board_match[] = {
145         {
146                 .name = "clock-board",
147         },
148         {},
149 };
150 
151 static struct 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 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 
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                 .owner = THIS_MODULE,
261                 .of_match_table = fhc_match,
262         },
263 };
264 
265 static int __init sunfire_init(void)
266 {
267         (void) platform_driver_register(&fhc_driver);
268         (void) platform_driver_register(&clock_board_driver);
269         return 0;
270 }
271 
272 fs_initcall(sunfire_init);
273 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us