arch/mips/sgi-ip22/ip22-gio.c

   1 #include <linux/export.h>
   2 #include <linux/kernel.h>
   3 #include <linux/init.h>
   4 #include <linux/slab.h>
   5
   6 #include <asm/addrspace.h>
   7 #include <asm/paccess.h>
   8 #include <asm/gio_device.h>
   9 #include <asm/sgi/gio.h>
  10 #include <asm/sgi/hpc3.h>
  11 #include <asm/sgi/mc.h>
  12 #include <asm/sgi/ip22.h>
  13
  14 static struct bus_type gio_bus_type;
  15
  16 static struct {
  17         const char *name;
  18         __u8       id;
  19 } gio_name_table[] = {
  20         { .name = "SGI Impact", .id = 0x10 },
  21         { .name = "Phobos G160", .id = 0x35 },
  22         /* fake IDs */
  23         { .name = "SGI Newport", .id = 0x7e },
  24         { .name = "SGI GR2/GR3", .id = 0x7f },
  25 };
  26
  27 static struct device gio_bus = {
  28         .init_name = "gio",
  29 };
  30
  31 /**
  32  * gio_match_device - Tell if an of_device structure has a matching
  33  * gio_match structure
  34  * @ids: array of of device match structures to search in
  35  * @dev: the of device structure to match against
  36  *
  37  * Used by a driver to check whether an of_device present in the
  38  * system is in its list of supported devices.
  39  */
  40 const struct gio_device_id *gio_match_device(const struct gio_device_id *match,
  41                      const struct gio_device *dev)
  42 {
  43         const struct gio_device_id *ids;
  44
  45         for (ids = match; ids->id != 0xff; ids++)
  46                 if (ids->id == dev->id.id)
  47                         return ids;
  48
  49         return NULL;
  50 }
  51 EXPORT_SYMBOL_GPL(gio_match_device);
  52
  53 struct gio_device *gio_dev_get(struct gio_device *dev)
  54 {
  55         struct device *tmp;
  56
  57         if (!dev)
  58                 return NULL;
  59         tmp = get_device(&dev->dev);
  60         if (tmp)
  61                 return to_gio_device(tmp);
  62         else
  63                 return NULL;
  64 }
  65 EXPORT_SYMBOL_GPL(gio_dev_get);
  66
  67 void gio_dev_put(struct gio_device *dev)
  68 {
  69         if (dev)
  70                 put_device(&dev->dev);
  71 }
  72 EXPORT_SYMBOL_GPL(gio_dev_put);
  73
  74 /**
  75  * gio_release_dev - free an gio device structure when all users of it are finished.
  76  * @dev: device that's been disconnected
  77  *
  78  * Will be called only by the device core when all users of this gio device are
  79  * done.
  80  */
  81 void gio_release_dev(struct device *dev)
  82 {
  83         struct gio_device *giodev;
  84
  85         giodev = to_gio_device(dev);
  86         kfree(giodev);
  87 }
  88 EXPORT_SYMBOL_GPL(gio_release_dev);
  89
  90 int gio_device_register(struct gio_device *giodev)
  91 {
  92         giodev->dev.bus = &gio_bus_type;
  93         giodev->dev.parent = &gio_bus;
  94         return device_register(&giodev->dev);
  95 }
  96 EXPORT_SYMBOL_GPL(gio_device_register);
  97
  98 void gio_device_unregister(struct gio_device *giodev)
  99 {
 100         device_unregister(&giodev->dev);
 101 }
 102 EXPORT_SYMBOL_GPL(gio_device_unregister);
 103
 104 static int gio_bus_match(struct device *dev, struct device_driver *drv)
 105 {
 106         struct gio_device *gio_dev = to_gio_device(dev);
 107         struct gio_driver *gio_drv = to_gio_driver(drv);
 108
 109         return gio_match_device(gio_drv->id_table, gio_dev) != NULL;
 110 }
 111
 112 static int gio_device_probe(struct device *dev)
 113 {
 114         int error = -ENODEV;
 115         struct gio_driver *drv;
 116         struct gio_device *gio_dev;
 117         const struct gio_device_id *match;
 118
 119         drv = to_gio_driver(dev->driver);
 120         gio_dev = to_gio_device(dev);
 121
 122         if (!drv->probe)
 123                 return error;
 124
 125         gio_dev_get(gio_dev);
 126
 127         match = gio_match_device(drv->id_table, gio_dev);
 128         if (match)
 129                 error = drv->probe(gio_dev, match);
 130         if (error)
 131                 gio_dev_put(gio_dev);
 132
 133         return error;
 134 }
 135
 136 static int gio_device_remove(struct device *dev)
 137 {
 138         struct gio_device *gio_dev = to_gio_device(dev);
 139         struct gio_driver *drv = to_gio_driver(dev->driver);
 140
 141         if (dev->driver && drv->remove)
 142                 drv->remove(gio_dev);
 143         return 0;
 144 }
 145
 146 static int gio_device_suspend(struct device *dev, pm_message_t state)
 147 {
 148         struct gio_device *gio_dev = to_gio_device(dev);
 149         struct gio_driver *drv = to_gio_driver(dev->driver);
 150         int error = 0;
 151
 152         if (dev->driver && drv->suspend)
 153                 error = drv->suspend(gio_dev, state);
 154         return error;
 155 }
 156
 157 static int gio_device_resume(struct device *dev)
 158 {
 159         struct gio_device *gio_dev = to_gio_device(dev);
 160         struct gio_driver *drv = to_gio_driver(dev->driver);
 161         int error = 0;
 162
 163         if (dev->driver && drv->resume)
 164                 error = drv->resume(gio_dev);
 165         return error;
 166 }
 167
 168 static void gio_device_shutdown(struct device *dev)
 169 {
 170         struct gio_device *gio_dev = to_gio_device(dev);
 171         struct gio_driver *drv = to_gio_driver(dev->driver);
 172
 173         if (dev->driver && drv->shutdown)
 174                 drv->shutdown(gio_dev);
 175 }
 176
 177 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
 178                              char *buf)
 179 {
 180         struct gio_device *gio_dev = to_gio_device(dev);
 181         int len = snprintf(buf, PAGE_SIZE, "gio:%x\n", gio_dev->id.id);
 182
 183         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
 184 }
 185
 186 static ssize_t name_show(struct device *dev,
 187                          struct device_attribute *attr, char *buf)
 188 {
 189         struct gio_device *giodev;
 190
 191         giodev = to_gio_device(dev);
 192         return sprintf(buf, "%s", giodev->name);
 193 }
 194
 195 static ssize_t id_show(struct device *dev,
 196                        struct device_attribute *attr, char *buf)
 197 {
 198         struct gio_device *giodev;
 199
 200         giodev = to_gio_device(dev);
 201         return sprintf(buf, "%x", giodev->id.id);
 202 }
 203
 204 static struct device_attribute gio_dev_attrs[] = {
 205         __ATTR_RO(modalias),
 206         __ATTR_RO(name),
 207         __ATTR_RO(id),
 208         __ATTR_NULL,
 209 };
 210
 211 static int gio_device_uevent(struct device *dev, struct kobj_uevent_env *env)
 212 {
 213         struct gio_device *gio_dev = to_gio_device(dev);
 214
 215         add_uevent_var(env, "MODALIAS=gio:%x", gio_dev->id.id);
 216         return 0;
 217 }
 218
 219 int gio_register_driver(struct gio_driver *drv)
 220 {
 221         /* initialize common driver fields */
 222         if (!drv->driver.name)
 223                 drv->driver.name = drv->name;
 224         if (!drv->driver.owner)
 225                 drv->driver.owner = drv->owner;
 226         drv->driver.bus = &gio_bus_type;
 227
 228         /* register with core */
 229         return driver_register(&drv->driver);
 230 }
 231 EXPORT_SYMBOL_GPL(gio_register_driver);
 232
 233 void gio_unregister_driver(struct gio_driver *drv)
 234 {
 235         driver_unregister(&drv->driver);
 236 }
 237 EXPORT_SYMBOL_GPL(gio_unregister_driver);
 238
 239 void gio_set_master(struct gio_device *dev)
 240 {
 241         u32 tmp = sgimc->giopar;
 242
 243         switch (dev->slotno) {
 244         case 0:
 245                 tmp |= SGIMC_GIOPAR_MASTERGFX;
 246                 break;
 247         case 1:
 248                 tmp |= SGIMC_GIOPAR_MASTEREXP0;
 249                 break;
 250         case 2:
 251                 tmp |= SGIMC_GIOPAR_MASTEREXP1;
 252                 break;
 253         }
 254         sgimc->giopar = tmp;
 255 }
 256 EXPORT_SYMBOL_GPL(gio_set_master);
 257
 258 void ip22_gio_set_64bit(int slotno)
 259 {
 260         u32 tmp = sgimc->giopar;
 261
 262         switch (slotno) {
 263         case 0:
 264                 tmp |= SGIMC_GIOPAR_GFX64;
 265                 break;
 266         case 1:
 267                 tmp |= SGIMC_GIOPAR_EXP064;
 268                 break;
 269         case 2:
 270                 tmp |= SGIMC_GIOPAR_EXP164;
 271                 break;
 272         }
 273         sgimc->giopar = tmp;
 274 }
 275
 276 static int ip22_gio_id(unsigned long addr, u32 *res)
 277 {
 278         u8 tmp8;
 279         u8 tmp16;
 280         u32 tmp32;
 281         u8 *ptr8;
 282         u16 *ptr16;
 283         u32 *ptr32;
 284
 285         ptr32 = (void *)CKSEG1ADDR(addr);
 286         if (!get_dbe(tmp32, ptr32)) {
 287                 /*
 288                  * We got no DBE, but this doesn't mean anything.
 289                  * If GIO is pipelined (which can't be disabled
 290                  * for GFX slot) we don't get a DBE, but we see
 291                  * the transfer size as data. So we do an 8bit
 292                  * and a 16bit access and check whether the common
 293                  * data matches
 294                  */
 295                 ptr8 = (void *)CKSEG1ADDR(addr + 3);
 296                 get_dbe(tmp8, ptr8);
 297                 ptr16 = (void *)CKSEG1ADDR(addr + 2);
 298                 get_dbe(tmp16, ptr16);
 299                 if (tmp8 == (tmp16 & 0xff) &&
 300                     tmp8 == (tmp32 & 0xff) &&
 301                     tmp16 == (tmp32 & 0xffff)) {
 302                         *res = tmp32;
 303                         return 1;
 304                 }
 305         }
 306         return 0; /* nothing here */
 307 }
 308
 309 #define HQ2_MYSTERY_OFFS       0x6A07C
 310 #define NEWPORT_USTATUS_OFFS   0xF133C
 311
 312 static int ip22_is_gr2(unsigned long addr)
 313 {
 314         u32 tmp;
 315         u32 *ptr;
 316
 317         /* HQ2 only allows 32bit accesses */
 318         ptr = (void *)CKSEG1ADDR(addr + HQ2_MYSTERY_OFFS);
 319         if (!get_dbe(tmp, ptr)) {
 320                 if (tmp == 0xdeadbeef)
 321                         return 1;
 322         }
 323         return 0;
 324 }
 325
 326
 327 static void ip22_check_gio(int slotno, unsigned long addr)
 328 {
 329         const char *name = "Unknown";
 330         struct gio_device *gio_dev;
 331         u32 tmp;
 332         __u8 id;
 333         int i;
 334
 335         /* first look for GR2/GR3 by checking mystery register */
 336         if (ip22_is_gr2(addr))
 337                 tmp = 0x7f;
 338         else {
 339                 if (!ip22_gio_id(addr, &tmp)) {
 340                         /*
 341                          * no GIO signature at start address of slot, but
 342                          * Newport doesn't have one, so let's check usea
 343                          * status register
 344                          */
 345                         if (ip22_gio_id(addr + NEWPORT_USTATUS_OFFS, &tmp))
 346                                 tmp = 0x7e;
 347                         else
 348                                 tmp = 0;
 349                 }
 350         }
 351         if (tmp) {
 352                 id = GIO_ID(tmp);
 353                 if (tmp & GIO_32BIT_ID) {
 354                         if (tmp & GIO_64BIT_IFACE)
 355                                 ip22_gio_set_64bit(slotno);
 356                 }
 357                 for (i = 0; i < ARRAY_SIZE(gio_name_table); i++) {
 358                         if (id == gio_name_table[i].id) {
 359                                 name = gio_name_table[i].name;
 360                                 break;
 361                         }
 362                 }
 363                 printk(KERN_INFO "GIO: slot %d : %s (id %x)\n",
 364                        slotno, name, id);
 365                 gio_dev = kzalloc(sizeof *gio_dev, GFP_KERNEL);
 366                 gio_dev->name = name;
 367                 gio_dev->slotno = slotno;
 368                 gio_dev->id.id = id;
 369                 gio_dev->resource.start = addr;
 370                 gio_dev->resource.end = addr + 0x3fffff;
 371                 gio_dev->resource.flags = IORESOURCE_MEM;
 372                 dev_set_name(&gio_dev->dev, "%d", slotno);
 373                 gio_device_register(gio_dev);
 374         } else
 375                 printk(KERN_INFO "GIO: slot %d : Empty\n", slotno);
 376 }
 377
 378 static struct bus_type gio_bus_type = {
 379         .name      = "gio",
 380         .dev_attrs = gio_dev_attrs,
 381         .match     = gio_bus_match,
 382         .probe     = gio_device_probe,
 383         .remove    = gio_device_remove,
 384         .suspend   = gio_device_suspend,
 385         .resume    = gio_device_resume,
 386         .shutdown  = gio_device_shutdown,
 387         .uevent    = gio_device_uevent,
 388 };
 389
 390 static struct resource gio_bus_resource = {
 391         .start = GIO_SLOT_GFX_BASE,
 392         .end   = GIO_SLOT_GFX_BASE + 0x9fffff,
 393         .name  = "GIO Bus",
 394         .flags = IORESOURCE_MEM,
 395 };
 396
 397 int __init ip22_gio_init(void)
 398 {
 399         unsigned int pbdma __maybe_unused;
 400         int ret;
 401
 402         ret = device_register(&gio_bus);
 403         if (ret)
 404                 return ret;
 405
 406         ret = bus_register(&gio_bus_type);
 407         if (!ret) {
 408                 request_resource(&iomem_resource, &gio_bus_resource);
 409                 printk(KERN_INFO "GIO: Probing bus...\n");
 410
 411                 if (ip22_is_fullhouse() ||
 412                     !get_dbe(pbdma, (unsigned int *)&hpc3c1->pbdma[1])) {
 413                         /* Indigo2 and ChallengeS */
 414                         ip22_check_gio(0, GIO_SLOT_GFX_BASE);
 415                         ip22_check_gio(1, GIO_SLOT_EXP0_BASE);
 416                 } else {
 417                         /* Indy */
 418                         ip22_check_gio(0, GIO_SLOT_GFX_BASE);
 419                         ip22_check_gio(1, GIO_SLOT_EXP0_BASE);
 420                         ip22_check_gio(2, GIO_SLOT_EXP1_BASE);
 421                 }
 422         } else
 423                 device_unregister(&gio_bus);
 424
 425         return ret;
 426 }
 427
 428 subsys_initcall(ip22_gio_init);