1 #include <linux/export.h>
2 #include <linux/kernel.h>
3 #include <linux/init.h>
4 #include <linux/slab.h>
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>
14 static struct bus_type gio_bus_type;
19 } gio_name_table[] = {
20 { .name = "SGI Impact", .id = 0x10 },
21 { .name = "Phobos G160", .id = 0x35 },
22 { .name = "Phobos G130", .id = 0x36 },
23 { .name = "Phobos G100", .id = 0x37 },
24 { .name = "Set Engineering GFE", .id = 0x38 },
26 { .name = "SGI Newport", .id = 0x7e },
27 { .name = "SGI GR2/GR3", .id = 0x7f },
30 static void gio_bus_release(struct device *dev)
35 static struct device gio_bus = {
37 .release = &gio_bus_release,
41 * gio_match_device - Tell if an of_device structure has a matching
43 * @ids: array of of device match structures to search in
44 * @dev: the of device structure to match against
46 * Used by a driver to check whether an of_device present in the
47 * system is in its list of supported devices.
49 const struct gio_device_id *gio_match_device(const struct gio_device_id *match,
50 const struct gio_device *dev)
52 const struct gio_device_id *ids;
54 for (ids = match; ids->id != 0xff; ids++)
55 if (ids->id == dev->id.id)
60 EXPORT_SYMBOL_GPL(gio_match_device);
62 struct gio_device *gio_dev_get(struct gio_device *dev)
68 tmp = get_device(&dev->dev);
70 return to_gio_device(tmp);
74 EXPORT_SYMBOL_GPL(gio_dev_get);
76 void gio_dev_put(struct gio_device *dev)
79 put_device(&dev->dev);
81 EXPORT_SYMBOL_GPL(gio_dev_put);
84 * gio_release_dev - free an gio device structure when all users of it are finished.
85 * @dev: device that's been disconnected
87 * Will be called only by the device core when all users of this gio device are
90 void gio_release_dev(struct device *dev)
92 struct gio_device *giodev;
94 giodev = to_gio_device(dev);
97 EXPORT_SYMBOL_GPL(gio_release_dev);
99 int gio_device_register(struct gio_device *giodev)
101 giodev->dev.bus = &gio_bus_type;
102 giodev->dev.parent = &gio_bus;
103 return device_register(&giodev->dev);
105 EXPORT_SYMBOL_GPL(gio_device_register);
107 void gio_device_unregister(struct gio_device *giodev)
109 device_unregister(&giodev->dev);
111 EXPORT_SYMBOL_GPL(gio_device_unregister);
113 static int gio_bus_match(struct device *dev, struct device_driver *drv)
115 struct gio_device *gio_dev = to_gio_device(dev);
116 struct gio_driver *gio_drv = to_gio_driver(drv);
118 return gio_match_device(gio_drv->id_table, gio_dev) != NULL;
121 static int gio_device_probe(struct device *dev)
124 struct gio_driver *drv;
125 struct gio_device *gio_dev;
126 const struct gio_device_id *match;
128 drv = to_gio_driver(dev->driver);
129 gio_dev = to_gio_device(dev);
134 gio_dev_get(gio_dev);
136 match = gio_match_device(drv->id_table, gio_dev);
138 error = drv->probe(gio_dev, match);
140 gio_dev_put(gio_dev);
145 static int gio_device_remove(struct device *dev)
147 struct gio_device *gio_dev = to_gio_device(dev);
148 struct gio_driver *drv = to_gio_driver(dev->driver);
150 if (dev->driver && drv->remove)
151 drv->remove(gio_dev);
155 static int gio_device_suspend(struct device *dev, pm_message_t state)
157 struct gio_device *gio_dev = to_gio_device(dev);
158 struct gio_driver *drv = to_gio_driver(dev->driver);
161 if (dev->driver && drv->suspend)
162 error = drv->suspend(gio_dev, state);
166 static int gio_device_resume(struct device *dev)
168 struct gio_device *gio_dev = to_gio_device(dev);
169 struct gio_driver *drv = to_gio_driver(dev->driver);
172 if (dev->driver && drv->resume)
173 error = drv->resume(gio_dev);
177 static void gio_device_shutdown(struct device *dev)
179 struct gio_device *gio_dev = to_gio_device(dev);
180 struct gio_driver *drv = to_gio_driver(dev->driver);
182 if (dev->driver && drv->shutdown)
183 drv->shutdown(gio_dev);
186 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
189 struct gio_device *gio_dev = to_gio_device(dev);
190 int len = snprintf(buf, PAGE_SIZE, "gio:%x\n", gio_dev->id.id);
192 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
195 static ssize_t name_show(struct device *dev,
196 struct device_attribute *attr, char *buf)
198 struct gio_device *giodev;
200 giodev = to_gio_device(dev);
201 return sprintf(buf, "%s", giodev->name);
204 static ssize_t id_show(struct device *dev,
205 struct device_attribute *attr, char *buf)
207 struct gio_device *giodev;
209 giodev = to_gio_device(dev);
210 return sprintf(buf, "%x", giodev->id.id);
213 static struct device_attribute gio_dev_attrs[] = {
220 static int gio_device_uevent(struct device *dev, struct kobj_uevent_env *env)
222 struct gio_device *gio_dev = to_gio_device(dev);
224 add_uevent_var(env, "MODALIAS=gio:%x", gio_dev->id.id);
228 int gio_register_driver(struct gio_driver *drv)
230 /* initialize common driver fields */
231 if (!drv->driver.name)
232 drv->driver.name = drv->name;
233 if (!drv->driver.owner)
234 drv->driver.owner = drv->owner;
235 drv->driver.bus = &gio_bus_type;
237 /* register with core */
238 return driver_register(&drv->driver);
240 EXPORT_SYMBOL_GPL(gio_register_driver);
242 void gio_unregister_driver(struct gio_driver *drv)
244 driver_unregister(&drv->driver);
246 EXPORT_SYMBOL_GPL(gio_unregister_driver);
248 void gio_set_master(struct gio_device *dev)
250 u32 tmp = sgimc->giopar;
252 switch (dev->slotno) {
254 tmp |= SGIMC_GIOPAR_MASTERGFX;
257 tmp |= SGIMC_GIOPAR_MASTEREXP0;
260 tmp |= SGIMC_GIOPAR_MASTEREXP1;
265 EXPORT_SYMBOL_GPL(gio_set_master);
267 void ip22_gio_set_64bit(int slotno)
269 u32 tmp = sgimc->giopar;
273 tmp |= SGIMC_GIOPAR_GFX64;
276 tmp |= SGIMC_GIOPAR_EXP064;
279 tmp |= SGIMC_GIOPAR_EXP164;
285 static int ip22_gio_id(unsigned long addr, u32 *res)
294 ptr32 = (void *)CKSEG1ADDR(addr);
295 if (!get_dbe(tmp32, ptr32)) {
297 * We got no DBE, but this doesn't mean anything.
298 * If GIO is pipelined (which can't be disabled
299 * for GFX slot) we don't get a DBE, but we see
300 * the transfer size as data. So we do an 8bit
301 * and a 16bit access and check whether the common
304 ptr8 = (void *)CKSEG1ADDR(addr + 3);
305 if (get_dbe(tmp8, ptr8)) {
307 * 32bit access worked, but 8bit doesn't
308 * so we don't see phantom reads on
309 * a pipelined bus, but a real card which
310 * doesn't support 8 bit reads
315 ptr16 = (void *)CKSEG1ADDR(addr + 2);
316 get_dbe(tmp16, ptr16);
317 if (tmp8 == (tmp16 & 0xff) &&
318 tmp8 == (tmp32 & 0xff) &&
319 tmp16 == (tmp32 & 0xffff)) {
324 return 0; /* nothing here */
327 #define HQ2_MYSTERY_OFFS 0x6A07C
328 #define NEWPORT_USTATUS_OFFS 0xF133C
330 static int ip22_is_gr2(unsigned long addr)
335 /* HQ2 only allows 32bit accesses */
336 ptr = (void *)CKSEG1ADDR(addr + HQ2_MYSTERY_OFFS);
337 if (!get_dbe(tmp, ptr)) {
338 if (tmp == 0xdeadbeef)
345 static void ip22_check_gio(int slotno, unsigned long addr, int irq)
347 const char *name = "Unknown";
348 struct gio_device *gio_dev;
353 /* first look for GR2/GR3 by checking mystery register */
354 if (ip22_is_gr2(addr))
357 if (!ip22_gio_id(addr, &tmp)) {
359 * no GIO signature at start address of slot
360 * since Newport doesn't have one, we check if
361 * user status register is readable
363 if (ip22_gio_id(addr + NEWPORT_USTATUS_OFFS, &tmp))
371 if (tmp & GIO_32BIT_ID) {
372 if (tmp & GIO_64BIT_IFACE)
373 ip22_gio_set_64bit(slotno);
375 for (i = 0; i < ARRAY_SIZE(gio_name_table); i++) {
376 if (id == gio_name_table[i].id) {
377 name = gio_name_table[i].name;
381 printk(KERN_INFO "GIO: slot %d : %s (id %x)\n",
383 gio_dev = kzalloc(sizeof *gio_dev, GFP_KERNEL);
384 gio_dev->name = name;
385 gio_dev->slotno = slotno;
387 gio_dev->resource.start = addr;
388 gio_dev->resource.end = addr + 0x3fffff;
389 gio_dev->resource.flags = IORESOURCE_MEM;
391 dev_set_name(&gio_dev->dev, "%d", slotno);
392 gio_device_register(gio_dev);
394 printk(KERN_INFO "GIO: slot %d : Empty\n", slotno);
397 static struct bus_type gio_bus_type = {
399 .dev_attrs = gio_dev_attrs,
400 .match = gio_bus_match,
401 .probe = gio_device_probe,
402 .remove = gio_device_remove,
403 .suspend = gio_device_suspend,
404 .resume = gio_device_resume,
405 .shutdown = gio_device_shutdown,
406 .uevent = gio_device_uevent,
409 static struct resource gio_bus_resource = {
410 .start = GIO_SLOT_GFX_BASE,
411 .end = GIO_SLOT_GFX_BASE + 0x9fffff,
413 .flags = IORESOURCE_MEM,
416 int __init ip22_gio_init(void)
418 unsigned int pbdma __maybe_unused;
421 ret = device_register(&gio_bus);
423 put_device(&gio_bus);
427 ret = bus_register(&gio_bus_type);
429 request_resource(&iomem_resource, &gio_bus_resource);
430 printk(KERN_INFO "GIO: Probing bus...\n");
432 if (ip22_is_fullhouse()) {
434 ip22_check_gio(0, GIO_SLOT_GFX_BASE, SGI_GIO_1_IRQ);
435 ip22_check_gio(1, GIO_SLOT_EXP0_BASE, SGI_GIO_1_IRQ);
437 /* Indy/Challenge S */
438 if (get_dbe(pbdma, (unsigned int *)&hpc3c1->pbdma[1]))
439 ip22_check_gio(0, GIO_SLOT_GFX_BASE,
441 ip22_check_gio(1, GIO_SLOT_EXP0_BASE, SGI_GIOEXP0_IRQ);
442 ip22_check_gio(2, GIO_SLOT_EXP1_BASE, SGI_GIOEXP1_IRQ);
445 device_unregister(&gio_bus);
450 subsys_initcall(ip22_gio_init);