MIPS: GIO bus support for SGI IP22/28 (e84de0c6) · Commits · e / devices / android_kernel_xiaomi_markw

arch/mips/include/asm/gio_device.h

0 → 100644

+56 −0

Original line number	Diff line number	Diff line
		#include <linux/device.h>
		#include <linux/mod_devicetable.h>

		struct gio_device_id {
		__u8 id;
		};

		struct gio_device {
		struct device dev;
		struct resource resource;
		unsigned int irq;
		unsigned int slotno;

		const char *name;
		struct gio_device_id id;
		unsigned id32:1;
		unsigned gio64:1;
		};
		#define to_gio_device(d) container_of(d, struct gio_device, dev)

		struct gio_driver {
		const char *name;
		struct module *owner;
		const struct gio_device_id *id_table;

		int (probe)(struct gio_device , const struct gio_device_id *);
		void (remove)(struct gio_device );
		int (suspend)(struct gio_device , pm_message_t);
		int (resume)(struct gio_device );
		void (shutdown)(struct gio_device );

		struct device_driver driver;
		};
		#define to_gio_driver(drv) container_of(drv, struct gio_driver, driver)

		extern const struct gio_device_id gio_match_device(const struct gio_device_id ,
		const struct gio_device *);
		extern struct gio_device gio_dev_get(struct gio_device );
		extern void gio_dev_put(struct gio_device *);

		extern int gio_device_register(struct gio_device *);
		extern void gio_device_unregister(struct gio_device *);
		extern void gio_release_dev(struct device *);

		static inline void gio_device_free(struct gio_device *dev)
		{
		gio_release_dev(&dev->dev);
		}

		extern int gio_register_driver(struct gio_driver *);
		extern void gio_unregister_driver(struct gio_driver *);

		#define gio_get_drvdata(_dev) drv_get_drvdata(&(_dev)->dev)
		#define gio_set_drvdata(_dev, data) drv_set_drvdata(&(_dev)->dev, (data))

		extern void gio_set_master(struct gio_device *);

arch/mips/sgi-ip22/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -4,7 +4,7 @@
		#

		obj-y += ip22-mc.o ip22-hpc.o ip22-int.o ip22-time.o ip22-nvram.o \
		ip22-platform.o ip22-reset.o ip22-setup.o
		ip22-platform.o ip22-reset.o ip22-setup.o ip22-gio.o

		obj-$(CONFIG_SGI_IP22) += ip22-berr.o
		obj-$(CONFIG_SGI_IP28) += ip28-berr.o

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

0 → 100644

+428 −0

Original line number	Diff line number	Diff line
		#include <linux/export.h>
		#include <linux/kernel.h>
		#include <linux/init.h>
		#include <linux/slab.h>

		#include <asm/addrspace.h>
		#include <asm/paccess.h>
		#include <asm/gio_device.h>
		#include <asm/sgi/gio.h>
		#include <asm/sgi/hpc3.h>
		#include <asm/sgi/mc.h>
		#include <asm/sgi/ip22.h>

		static struct bus_type gio_bus_type;

		static struct {
		const char *name;
		__u8 id;
		} gio_name_table[] = {
		{ .name = "SGI Impact", .id = 0x10 },
		{ .name = "Phobos G160", .id = 0x35 },
		/* fake IDs */
		{ .name = "SGI Newport", .id = 0x7e },
		{ .name = "SGI GR2/GR3", .id = 0x7f },
		};

		static struct device gio_bus = {
		.init_name = "gio",
		};

		/**
		* gio_match_device - Tell if an of_device structure has a matching
		* gio_match structure
		* @ids: array of of device match structures to search in
		* @dev: the of device structure to match against
		*
		* Used by a driver to check whether an of_device present in the
		* system is in its list of supported devices.
		*/
		const struct gio_device_id gio_match_device(const struct gio_device_id match,
		const struct gio_device *dev)
		{
		const struct gio_device_id *ids;

		for (ids = match; ids->id != 0xff; ids++)
		if (ids->id == dev->id.id)
		return ids;

		return NULL;
		}
		EXPORT_SYMBOL_GPL(gio_match_device);

		struct gio_device gio_dev_get(struct gio_device dev)
		{
		struct device *tmp;

		if (!dev)
		return NULL;
		tmp = get_device(&dev->dev);
		if (tmp)
		return to_gio_device(tmp);
		else
		return NULL;
		}
		EXPORT_SYMBOL_GPL(gio_dev_get);

		void gio_dev_put(struct gio_device *dev)
		{
		if (dev)
		put_device(&dev->dev);
		}
		EXPORT_SYMBOL_GPL(gio_dev_put);

		/**
		* gio_release_dev - free an gio device structure when all users of it are finished.
		* @dev: device that's been disconnected
		*
		* Will be called only by the device core when all users of this gio device are
		* done.
		*/
		void gio_release_dev(struct device *dev)
		{
		struct gio_device *giodev;

		giodev = to_gio_device(dev);
		kfree(giodev);
		}
		EXPORT_SYMBOL_GPL(gio_release_dev);

		int gio_device_register(struct gio_device *giodev)
		{
		giodev->dev.bus = &gio_bus_type;
		giodev->dev.parent = &gio_bus;
		return device_register(&giodev->dev);
		}
		EXPORT_SYMBOL_GPL(gio_device_register);

		void gio_device_unregister(struct gio_device *giodev)
		{
		device_unregister(&giodev->dev);
		}
		EXPORT_SYMBOL_GPL(gio_device_unregister);

		static int gio_bus_match(struct device dev, struct device_driver drv)
		{
		struct gio_device *gio_dev = to_gio_device(dev);
		struct gio_driver *gio_drv = to_gio_driver(drv);

		return gio_match_device(gio_drv->id_table, gio_dev) != NULL;
		}

		static int gio_device_probe(struct device *dev)
		{
		int error = -ENODEV;
		struct gio_driver *drv;
		struct gio_device *gio_dev;
		const struct gio_device_id *match;

		drv = to_gio_driver(dev->driver);
		gio_dev = to_gio_device(dev);

		if (!drv->probe)
		return error;

		gio_dev_get(gio_dev);

		match = gio_match_device(drv->id_table, gio_dev);
		if (match)
		error = drv->probe(gio_dev, match);
		if (error)
		gio_dev_put(gio_dev);

		return error;
		}

		static int gio_device_remove(struct device *dev)
		{
		struct gio_device *gio_dev = to_gio_device(dev);
		struct gio_driver *drv = to_gio_driver(dev->driver);

		if (dev->driver && drv->remove)
		drv->remove(gio_dev);
		return 0;
		}

		static int gio_device_suspend(struct device *dev, pm_message_t state)
		{
		struct gio_device *gio_dev = to_gio_device(dev);
		struct gio_driver *drv = to_gio_driver(dev->driver);
		int error = 0;

		if (dev->driver && drv->suspend)
		error = drv->suspend(gio_dev, state);
		return error;
		}

		static int gio_device_resume(struct device *dev)
		{
		struct gio_device *gio_dev = to_gio_device(dev);
		struct gio_driver *drv = to_gio_driver(dev->driver);
		int error = 0;

		if (dev->driver && drv->resume)
		error = drv->resume(gio_dev);
		return error;
		}

		static void gio_device_shutdown(struct device *dev)
		{
		struct gio_device *gio_dev = to_gio_device(dev);
		struct gio_driver *drv = to_gio_driver(dev->driver);

		if (dev->driver && drv->shutdown)
		drv->shutdown(gio_dev);
		}

		static ssize_t modalias_show(struct device dev, struct device_attribute a,
		char *buf)
		{
		struct gio_device *gio_dev = to_gio_device(dev);
		int len = snprintf(buf, PAGE_SIZE, "gio:%x\n", gio_dev->id.id);

		return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
		}

		static ssize_t name_show(struct device *dev,
		struct device_attribute attr, char buf)
		{
		struct gio_device *giodev;

		giodev = to_gio_device(dev);
		return sprintf(buf, "%s", giodev->name);
		}

		static ssize_t id_show(struct device *dev,
		struct device_attribute attr, char buf)
		{
		struct gio_device *giodev;

		giodev = to_gio_device(dev);
		return sprintf(buf, "%x", giodev->id.id);
		}

		static struct device_attribute gio_dev_attrs[] = {
		__ATTR_RO(modalias),
		__ATTR_RO(name),
		__ATTR_RO(id),
		__ATTR_NULL,
		};

		static int gio_device_uevent(struct device dev, struct kobj_uevent_env env)
		{
		struct gio_device *gio_dev = to_gio_device(dev);

		add_uevent_var(env, "MODALIAS=gio:%x", gio_dev->id.id);
		return 0;
		}

		int gio_register_driver(struct gio_driver *drv)
		{
		/* initialize common driver fields */
		if (!drv->driver.name)
		drv->driver.name = drv->name;
		if (!drv->driver.owner)
		drv->driver.owner = drv->owner;
		drv->driver.bus = &gio_bus_type;

		/* register with core */
		return driver_register(&drv->driver);
		}
		EXPORT_SYMBOL_GPL(gio_register_driver);

		void gio_unregister_driver(struct gio_driver *drv)
		{
		driver_unregister(&drv->driver);
		}
		EXPORT_SYMBOL_GPL(gio_unregister_driver);

		void gio_set_master(struct gio_device *dev)
		{
		u32 tmp = sgimc->giopar;

		switch (dev->slotno) {
		case 0:
		tmp \|= SGIMC_GIOPAR_MASTERGFX;
		break;
		case 1:
		tmp \|= SGIMC_GIOPAR_MASTEREXP0;
		break;
		case 2:
		tmp \|= SGIMC_GIOPAR_MASTEREXP1;
		break;
		}
		sgimc->giopar = tmp;
		}
		EXPORT_SYMBOL_GPL(gio_set_master);

		void ip22_gio_set_64bit(int slotno)
		{
		u32 tmp = sgimc->giopar;

		switch (slotno) {
		case 0:
		tmp \|= SGIMC_GIOPAR_GFX64;
		break;
		case 1:
		tmp \|= SGIMC_GIOPAR_EXP064;
		break;
		case 2:
		tmp \|= SGIMC_GIOPAR_EXP164;
		break;
		}
		sgimc->giopar = tmp;
		}

		static int ip22_gio_id(unsigned long addr, u32 *res)
		{
		u8 tmp8;
		u8 tmp16;
		u32 tmp32;
		u8 *ptr8;
		u16 *ptr16;
		u32 *ptr32;

		ptr32 = (void *)CKSEG1ADDR(addr);
		if (!get_dbe(tmp32, ptr32)) {
		/*
		* We got no DBE, but this doesn't mean anything.
		* If GIO is pipelined (which can't be disabled
		* for GFX slot) we don't get a DBE, but we see
		* the transfer size as data. So we do an 8bit
		* and a 16bit access and check whether the common
		* data matches
		*/
		ptr8 = (void *)CKSEG1ADDR(addr + 3);
		get_dbe(tmp8, ptr8);
		ptr16 = (void *)CKSEG1ADDR(addr + 2);
		get_dbe(tmp16, ptr16);
		if (tmp8 == (tmp16 & 0xff) &&
		tmp8 == (tmp32 & 0xff) &&
		tmp16 == (tmp32 & 0xffff)) {
		*res = tmp32;
		return 1;
		}
		}
		return 0; /* nothing here */
		}

		#define HQ2_MYSTERY_OFFS 0x6A07C
		#define NEWPORT_USTATUS_OFFS 0xF133C

		static int ip22_is_gr2(unsigned long addr)
		{
		u32 tmp;
		u32 *ptr;

		/* HQ2 only allows 32bit accesses */
		ptr = (void *)CKSEG1ADDR(addr + HQ2_MYSTERY_OFFS);
		if (!get_dbe(tmp, ptr)) {
		if (tmp == 0xdeadbeef)
		return 1;
		}
		return 0;
		}


		static void ip22_check_gio(int slotno, unsigned long addr)
		{
		const char *name = "Unknown";
		struct gio_device *gio_dev;
		u32 tmp;
		__u8 id;
		int i;

		/* first look for GR2/GR3 by checking mystery register */
		if (ip22_is_gr2(addr))
		tmp = 0x7f;
		else {
		if (!ip22_gio_id(addr, &tmp)) {
		/*
		* no GIO signature at start address of slot, but
		* Newport doesn't have one, so let's check usea
		* status register
		*/
		if (ip22_gio_id(addr + NEWPORT_USTATUS_OFFS, &tmp))
		tmp = 0x7e;
		else
		tmp = 0;
		}
		}
		if (tmp) {
		id = GIO_ID(tmp);
		if (tmp & GIO_32BIT_ID) {
		if (tmp & GIO_64BIT_IFACE)
		ip22_gio_set_64bit(slotno);
		}
		for (i = 0; i < ARRAY_SIZE(gio_name_table); i++) {
		if (id == gio_name_table[i].id) {
		name = gio_name_table[i].name;
		break;
		}
		}
		printk(KERN_INFO "GIO: slot %d : %s (id %x)\n",
		slotno, name, id);
		gio_dev = kzalloc(sizeof *gio_dev, GFP_KERNEL);
		gio_dev->name = name;
		gio_dev->slotno = slotno;
		gio_dev->id.id = id;
		gio_dev->resource.start = addr;
		gio_dev->resource.end = addr + 0x3fffff;
		gio_dev->resource.flags = IORESOURCE_MEM;
		dev_set_name(&gio_dev->dev, "%d", slotno);
		gio_device_register(gio_dev);
		} else
		printk(KERN_INFO "GIO: slot %d : Empty\n", slotno);
		}

		static struct bus_type gio_bus_type = {
		.name = "gio",
		.dev_attrs = gio_dev_attrs,
		.match = gio_bus_match,
		.probe = gio_device_probe,
		.remove = gio_device_remove,
		.suspend = gio_device_suspend,
		.resume = gio_device_resume,
		.shutdown = gio_device_shutdown,
		.uevent = gio_device_uevent,
		};

		static struct resource gio_bus_resource = {
		.start = GIO_SLOT_GFX_BASE,
		.end = GIO_SLOT_GFX_BASE + 0x9fffff,
		.name = "GIO Bus",
		.flags = IORESOURCE_MEM,
		};

		int __init ip22_gio_init(void)
		{
		unsigned int pbdma __maybe_unused;
		int ret;

		ret = device_register(&gio_bus);
		if (ret)
		return ret;

		ret = bus_register(&gio_bus_type);
		if (!ret) {
		request_resource(&iomem_resource, &gio_bus_resource);
		printk(KERN_INFO "GIO: Probing bus...\n");

		if (ip22_is_fullhouse() \|\|
		!get_dbe(pbdma, (unsigned int *)&hpc3c1->pbdma[1])) {
		/* Indigo2 and ChallengeS */
		ip22_check_gio(0, GIO_SLOT_GFX_BASE);
		ip22_check_gio(1, GIO_SLOT_EXP0_BASE);
		} else {
		/* Indy */
		ip22_check_gio(0, GIO_SLOT_GFX_BASE);
		ip22_check_gio(1, GIO_SLOT_EXP0_BASE);
		ip22_check_gio(2, GIO_SLOT_EXP1_BASE);
		}
		} else
		device_unregister(&gio_bus);

		return ret;
		}

		subsys_initcall(ip22_gio_init);

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

+5 −5

Original line number	Diff line number	Diff line
		@@ -139,11 +139,11 @@ void __init sgimc_init(void)
		* zero.
		*/
		/* don't touch parity settings for IP28 */
		#ifndef CONFIG_SGI_IP28
		tmp = sgimc->cpuctrl0;
		tmp \|= (SGIMC_CCTRL0_EPERRGIO \| SGIMC_CCTRL0_EPERRMEM \|
		SGIMC_CCTRL0_R4KNOCHKPARR);
		#ifndef CONFIG_SGI_IP28
		tmp \|= SGIMC_CCTRL0_EPERRGIO \| SGIMC_CCTRL0_EPERRMEM;
		#endif
		tmp \|= SGIMC_CCTRL0_R4KNOCHKPARR;
		sgimc->cpuctrl0 = tmp;

		/* Step 3: Setup the MC write buffer depth, this is controlled
		@@ -178,7 +178,8 @@ void __init sgimc_init(void)
		*/

		/* First the basic invariants across all GIO64 implementations. */
		tmp = SGIMC_GIOPAR_HPC64; /* All 1st HPC's interface at 64bits */
		tmp = sgimc->giopar & SGIMC_GIOPAR_GFX64; /* keep gfx 64bit settings */
		tmp \|= SGIMC_GIOPAR_HPC64; /* All 1st HPC's interface at 64bits */
		tmp \|= SGIMC_GIOPAR_ONEBUS; /* Only one physical GIO bus exists */

		if (ip22_is_fullhouse()) {
		@@ -193,7 +194,6 @@ void __init sgimc_init(void)
		tmp \|= SGIMC_GIOPAR_PLINEEXP0; /* exp[01] pipelined */
		tmp \|= SGIMC_GIOPAR_PLINEEXP1;
		tmp \|= SGIMC_GIOPAR_MASTEREISA; /* EISA masters */
		tmp \|= SGIMC_GIOPAR_GFX64; /* GFX at 64 bits */
		}
		} else {
		/* Guiness specific settings. */

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

+0 −21

Original line number	Diff line number	Diff line
		@@ -26,9 +26,6 @@
		#include <asm/sgi/hpc3.h>
		#include <asm/sgi/ip22.h>

		unsigned long sgi_gfxaddr;
		EXPORT_SYMBOL_GPL(sgi_gfxaddr);

		extern void ip22_be_init(void) __init;

		void __init plat_mem_setup(void)
		@@ -78,22 +75,4 @@ void __init plat_mem_setup(void)
		prom_flags \|= PROM_FLAG_USE_AS_CONSOLE;
		add_preferred_console("arc", 0, NULL);
		}

		#if defined(CONFIG_VT) && defined(CONFIG_SGI_NEWPORT_CONSOLE)
		{
		ULONG *gfxinfo;
		ULONG * (__vec)(void) = (void ) (long)
		((_PULONG )(long)((PROMBLOCK)->pvector + 0x20));

		gfxinfo = __vec();
		sgi_gfxaddr = ((gfxinfo[1] >= 0xa0000000
		&& gfxinfo[1] <= 0xc0000000)
		? gfxinfo[1] - 0xa0000000 : 0);

		/* newport addresses? */
		if (sgi_gfxaddr == 0x1f0f0000 \|\| sgi_gfxaddr == 0x1f4f0000) {
		conswitchp = &newport_con;
		}
		}
		#endif
		}