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);