Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
central.c
Go to the documentation of this file.
1 /* central.c: Central FHC driver for Sunfire/Starfire/Wildfire.
2  *
3  * Copyright (C) 1997, 1999, 2008 David S. Miller ([email protected])
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 {
22  int num_slots;
25 };
26 
27 struct fhc {
28  void __iomem *pregs;
29  bool central;
31  int board_num;
34 };
35 
36 static int __devinit 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 __devinit 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 
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 __devinit 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 
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 |
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);