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 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 /* Fallthrough */ 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