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
15static struct bus_type gio_bus_type;
16
17static 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
31static void gio_bus_release(struct device *dev)
32{
33	kfree(dev);
34}
35
36static 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 */
50static const struct gio_device_id *
51gio_match_device(const struct gio_device_id *match,
52		 const struct gio_device *dev)
53{
54	const struct gio_device_id *ids;
55
56	for (ids = match; ids->id != 0xff; ids++)
57		if (ids->id == dev->id.id)
58			return ids;
59
60	return NULL;
61}
62
63struct 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}
75EXPORT_SYMBOL_GPL(gio_dev_get);
76
77void gio_dev_put(struct gio_device *dev)
78{
79	if (dev)
80		put_device(&dev->dev);
81}
82EXPORT_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 */
91void gio_release_dev(struct device *dev)
92{
93	struct gio_device *giodev;
94
95	giodev = to_gio_device(dev);
96	kfree(giodev);
97}
98EXPORT_SYMBOL_GPL(gio_release_dev);
99
100int 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}
106EXPORT_SYMBOL_GPL(gio_device_register);
107
108void gio_device_unregister(struct gio_device *giodev)
109{
110	device_unregister(&giodev->dev);
111}
112EXPORT_SYMBOL_GPL(gio_device_unregister);
113
114static 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
122static 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
146static 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
156static 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
165static 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}
173static DEVICE_ATTR_RO(modalias);
174
175static 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}
183static DEVICE_ATTR_RO(name);
184
185static 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}
193static DEVICE_ATTR_RO(id);
194
195static struct attribute *gio_dev_attrs[] = {
196	&dev_attr_modalias.attr,
197	&dev_attr_name.attr,
198	&dev_attr_id.attr,
199	NULL,
200};
201ATTRIBUTE_GROUPS(gio_dev);
202
203static 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
211int 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}
223EXPORT_SYMBOL_GPL(gio_register_driver);
224
225void gio_unregister_driver(struct gio_driver *drv)
226{
227	driver_unregister(&drv->driver);
228}
229EXPORT_SYMBOL_GPL(gio_unregister_driver);
230
231void 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}
248EXPORT_SYMBOL_GPL(gio_set_master);
249
250void 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
268static 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
313static 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
328static 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
380static 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
390static 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
397int __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
431subsys_initcall(ip22_gio_init);
432