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