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/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
  17 struct 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
  26 struct 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
  35 static 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
  62 static int __devinit clock_board_probe(struct of_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;
 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 struct of_device_id __initdata clock_board_match[] = {
 145         {
 146                 .name = "clock-board",
 147         },
 148         {},
 149 };
 150
 151 static 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
 160 static int __devinit fhc_probe(struct of_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
 239 out:
 240         return err;
 241
 242 out_unmap_pregs:
 243         of_iounmap(&op->resource[0], p->pregs, resource_size(&op->resource[0]));
 244
 245 out_free:
 246         kfree(p);
 247         goto out;
 248 }
 249
 250 static struct of_device_id __initdata fhc_match[] = {
 251         {
 252                 .name = "fhc",
 253         },
 254         {},
 255 };
 256
 257 static 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
 266 static int __init sunfire_init(void)
 267 {
 268         (void) of_register_driver(&fhc_driver, &of_platform_bus_type);
 269         (void) of_register_driver(&clock_board_driver, &of_platform_bus_type);
 270         return 0;
 271 }
 272
 273 subsys_initcall(sunfire_init);