[linux-2.6-block.git] / drivers / dio / dio.c

// SPDX-License-Identifier: GPL-2.0
/* Code to support devices on the DIO and DIO-II bus
 * Copyright (C) 05/1998 Peter Maydell <pmaydell@chiark.greenend.org.uk>
 * Copyright (C) 2004 Jochen Friedrich <jochen@scram.de>
 *
 * This code has basically these routines at the moment:
 * int dio_find(u_int deviceid)
 *    Search the list of DIO devices and return the select code
 *    of the next unconfigured device found that matches the given device ID.
 *    Note that the deviceid parameter should be the encoded ID.
 *    This means that framebuffers should pass it as
 *    DIO_ENCODE_ID(DIO_ID_FBUFFER,DIO_ID2_TOPCAT)
 *    (or whatever); everybody else just uses DIO_ID_FOOBAR.
 * unsigned long dio_scodetophysaddr(int scode)
 *    Return the physical address corresponding to the given select code.
 * int dio_scodetoipl(int scode)
 *    Every DIO card has a fixed interrupt priority level. This function
 *    returns it, whatever it is.
 * const char *dio_scodetoname(int scode)
 *    Return a character string describing this board [might be "" if
 *    not CONFIG_DIO_CONSTANTS]
 * void dio_config_board(int scode)     mark board as configured in the list
 * void dio_unconfig_board(int scode)   mark board as no longer configured
 *
 * This file is based on the way the Amiga port handles Zorro II cards,
 * although we aren't so complicated...
 */
#include <linux/module.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/dio.h>
#include <linux/slab.h>                         /* kmalloc() */
#include <linux/uaccess.h>
#include <linux/io.h>                           /* readb() */

struct dio_bus dio_bus = {
	.resources = {
		/* DIO range */
		{ .name = "DIO mem", .start = 0x00600000, .end = 0x007fffff },
		/* DIO-II range */
		{ .name = "DIO-II mem", .start = 0x01000000, .end = 0x1fffffff }
	},
	.name = "DIO bus"
};

/* not a real config option yet! */
#define CONFIG_DIO_CONSTANTS

#ifdef CONFIG_DIO_CONSTANTS
/* We associate each numeric ID with an appropriate descriptive string
 * using a constant array of these structs.
 * FIXME: we should be able to arrange to throw away most of the strings
 * using the initdata stuff. Then we wouldn't need to worry about
 * carrying them around...
 * I think we do this by copying them into newly kmalloc()ed memory and
 * marking the names[] array as .initdata ?
 */
struct dioname {
	int id;
	const char *name;
};

/* useful macro */
#define DIONAME(x) { DIO_ID_##x, DIO_DESC_##x }
#define DIOFBNAME(x) { DIO_ENCODE_ID(DIO_ID_FBUFFER, DIO_ID2_##x), DIO_DESC2_##x }

static struct dioname names[] = {
	DIONAME(DCA0), DIONAME(DCA0REM), DIONAME(DCA1), DIONAME(DCA1REM),
	DIONAME(DCM), DIONAME(DCMREM),
	DIONAME(LAN),
	DIONAME(FHPIB), DIONAME(NHPIB),
	DIONAME(SCSI0), DIONAME(SCSI1), DIONAME(SCSI2), DIONAME(SCSI3),
	DIONAME(FBUFFER),
	DIONAME(PARALLEL), DIONAME(VME), DIONAME(DCL), DIONAME(DCLREM),
	DIONAME(MISC0), DIONAME(MISC1), DIONAME(MISC2), DIONAME(MISC3),
	DIONAME(MISC4), DIONAME(MISC5), DIONAME(MISC6), DIONAME(MISC7),
	DIONAME(MISC8), DIONAME(MISC9), DIONAME(MISC10), DIONAME(MISC11),
	DIONAME(MISC12), DIONAME(MISC13),
	DIOFBNAME(GATORBOX), DIOFBNAME(TOPCAT), DIOFBNAME(RENAISSANCE),
	DIOFBNAME(LRCATSEYE), DIOFBNAME(HRCCATSEYE), DIOFBNAME(HRMCATSEYE),
	DIOFBNAME(DAVINCI), DIOFBNAME(XXXCATSEYE), DIOFBNAME(HYPERION),
	DIOFBNAME(XGENESIS), DIOFBNAME(TIGER), DIOFBNAME(YGENESIS)
};

#undef DIONAME
#undef DIOFBNAME

static const char unknowndioname[]
	= "unknown DIO board, please email linux-m68k@lists.linux-m68k.org";

static const char *dio_getname(int id)
{
	/* return pointer to a constant string describing the board with given ID */
	unsigned int i;
	for (i = 0; i < ARRAY_SIZE(names); i++)
		if (names[i].id == id)
			return names[i].name;

	return unknowndioname;
}

#else

static char dio_no_name[] = { 0 };
#define dio_getname(_id)	(dio_no_name)

#endif /* CONFIG_DIO_CONSTANTS */

int __init dio_find(int deviceid)
{
	/* Called to find a DIO device before the full bus scan has run.
	 * Only used by the console driver.
	 */
	int scode, id;
	u_char prid, secid, i;

	for (scode = 0; scode < DIO_SCMAX; scode++) {
		void *va;
		unsigned long pa;

		if (DIO_SCINHOLE(scode))
			continue;

		pa = dio_scodetophysaddr(scode);

		if (!pa)
			continue;

		if (scode < DIOII_SCBASE)
			va = (void *)(pa + DIO_VIRADDRBASE);
		else
			va = ioremap(pa, PAGE_SIZE);

		if (copy_from_kernel_nofault(&i,
				(unsigned char *)va + DIO_IDOFF, 1)) {
			if (scode >= DIOII_SCBASE)
				iounmap(va);
			continue;	     /* no board present at that select code */
		}

		prid = DIO_ID(va);

		if (DIO_NEEDSSECID(prid)) {
			secid = DIO_SECID(va);
			id = DIO_ENCODE_ID(prid, secid);
		} else
			id = prid;

		if (id == deviceid) {
			if (scode >= DIOII_SCBASE)
				iounmap(va);
			return scode;
		}
	}

	return -1;
}

/* This is the function that scans the DIO space and works out what
 * hardware is actually present.
 */
static int __init dio_init(void)
{
	int scode;
	int i;
	struct dio_dev *dev;
	int error;

	if (!MACH_IS_HP300)
		return 0;

        printk(KERN_INFO "Scanning for DIO devices...\n");

	/* Initialize the DIO bus */
	INIT_LIST_HEAD(&dio_bus.devices);
	dev_set_name(&dio_bus.dev, "dio");
	error = device_register(&dio_bus.dev);
	if (error) {
		pr_err("DIO: Error registering dio_bus\n");
		return error;
	}

	/* Request all resources */
	dio_bus.num_resources = (hp300_model == HP_320 ? 1 : 2);
	for (i = 0; i < dio_bus.num_resources; i++)
		request_resource(&iomem_resource, &dio_bus.resources[i]);

	/* Register all devices */
	for (scode = 0; scode < DIO_SCMAX; ++scode) {
		u_char prid, secid = 0;	/* primary, secondary ID bytes */
		u_char *va;
		unsigned long pa;

		if (DIO_SCINHOLE(scode))
			continue;

		pa = dio_scodetophysaddr(scode);

		if (!pa)
			continue;

		if (scode < DIOII_SCBASE)
			va = (void *)(pa + DIO_VIRADDRBASE);
		else
			va = ioremap(pa, PAGE_SIZE);

		if (copy_from_kernel_nofault(&i,
				(unsigned char *)va + DIO_IDOFF, 1)) {
			if (scode >= DIOII_SCBASE)
				iounmap(va);
			continue;	      /* no board present at that select code */
		}

		/* Found a board, allocate it an entry in the list */
		dev = kzalloc(sizeof(struct dio_dev), GFP_KERNEL);
		if (!dev)
			return -ENOMEM;

		dev->bus = &dio_bus;
		dev->dev.parent = &dio_bus.dev;
		dev->dev.bus = &dio_bus_type;
		dev->scode = scode;
		dev->resource.start = pa;
		dev->resource.end = pa + DIO_SIZE(scode, va);
		dev_set_name(&dev->dev, "%02x", scode);

		/* read the ID byte(s) and encode if necessary. */
		prid = DIO_ID(va);

		if (DIO_NEEDSSECID(prid)) {
			secid = DIO_SECID(va);
			dev->id = DIO_ENCODE_ID(prid, secid);
		} else
			dev->id = prid;

		dev->ipl = DIO_IPL(va);
		strcpy(dev->name, dio_getname(dev->id));
                printk(KERN_INFO "select code %3d: ipl %d: ID %02X", dev->scode, dev->ipl, prid);
		if (DIO_NEEDSSECID(prid))
                        printk(":%02X", secid);
                printk(": %s\n", dev->name);

		if (scode >= DIOII_SCBASE)
			iounmap(va);
		error = device_register(&dev->dev);
		if (error) {
			pr_err("DIO: Error registering device %s\n",
			       dev->name);
			continue;
		}
		error = dio_create_sysfs_dev_files(dev);
		if (error)
			dev_err(&dev->dev, "Error creating sysfs files\n");
	}
	return 0;
}

subsys_initcall(dio_init);

/* Bear in mind that this is called in the very early stages of initialisation
 * in order to get the address of the serial port for the console...
 */
unsigned long dio_scodetophysaddr(int scode)
{
	if (scode >= DIOII_SCBASE)
		return (DIOII_BASE + (scode - 132) * DIOII_DEVSIZE);
	else if (scode > DIO_SCMAX || scode < 0)
		return 0;
	else if (DIO_SCINHOLE(scode))
		return 0;

	return (DIO_BASE + scode * DIO_DEVSIZE);
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/* Code to support devices on the DIO and DIO-II bus
	3	* Copyright (C) 05/1998 Peter Maydell <pmaydell@chiark.greenend.org.uk>
	4	* Copyright (C) 2004 Jochen Friedrich <jochen@scram.de>
7649cb6f	5	*
1da177e4 LT	6	* This code has basically these routines at the moment:
	7	* int dio_find(u_int deviceid)
	8	* Search the list of DIO devices and return the select code
	9	* of the next unconfigured device found that matches the given device ID.
	10	* Note that the deviceid parameter should be the encoded ID.
7649cb6f	11	* This means that framebuffers should pass it as
1da177e4 LT	12	* DIO_ENCODE_ID(DIO_ID_FBUFFER,DIO_ID2_TOPCAT)
	13	* (or whatever); everybody else just uses DIO_ID_FOOBAR.
	14	* unsigned long dio_scodetophysaddr(int scode)
	15	* Return the physical address corresponding to the given select code.
	16	* int dio_scodetoipl(int scode)
7649cb6f	17	* Every DIO card has a fixed interrupt priority level. This function
1da177e4 LT	18	* returns it, whatever it is.
1da177e4 LT	19	* const char *dio_scodetoname(int scode)
7649cb6f	20	* Return a character string describing this board [might be "" if
1da177e4 LT	21	* not CONFIG_DIO_CONSTANTS]
	22	* void dio_config_board(int scode) mark board as configured in the list
	23	* void dio_unconfig_board(int scode) mark board as no longer configured
	24	*
7649cb6f	25	* This file is based on the way the Amiga port handles Zorro II cards,
1da177e4 LT	26	* although we aren't so complicated...
	27	*/
	28	#include <linux/module.h>
	29	#include <linux/string.h>
	30	#include <linux/types.h>
	31	#include <linux/kernel.h>
	32	#include <linux/init.h>
	33	#include <linux/dio.h>
	34	#include <linux/slab.h> /* kmalloc() */
7c0f6ba6	35	#include <linux/uaccess.h>
10f4629f	36	#include <linux/io.h> /* readb() */
1da177e4 LT	37
	38	struct dio_bus dio_bus = {
	39	.resources = {
	40	/* DIO range */
	41	{ .name = "DIO mem", .start = 0x00600000, .end = 0x007fffff },
	42	/* DIO-II range */
	43	{ .name = "DIO-II mem", .start = 0x01000000, .end = 0x1fffffff }
	44	},
	45	.name = "DIO bus"
	46	};
	47
	48	/* not a real config option yet! */
	49	#define CONFIG_DIO_CONSTANTS
	50
	51	#ifdef CONFIG_DIO_CONSTANTS
	52	/* We associate each numeric ID with an appropriate descriptive string
	53	* using a constant array of these structs.
	54	* FIXME: we should be able to arrange to throw away most of the strings
7649cb6f	55	* using the initdata stuff. Then we wouldn't need to worry about
1da177e4	56	* carrying them around...
7649cb6f	57	* I think we do this by copying them into newly kmalloc()ed memory and
1da177e4 LT	58	* marking the names[] array as .initdata ?
1da177e4 LT	59	*/
8a4606c6	60	struct dioname {
dffae938 AV	61	int id;
dffae938 AV	62	const char *name;
1da177e4 LT	63	};
	64
	65	/* useful macro */
	66	#define DIONAME(x) { DIO_ID_##x, DIO_DESC_##x }
c3c61385	67	#define DIOFBNAME(x) { DIO_ENCODE_ID(DIO_ID_FBUFFER, DIO_ID2_##x), DIO_DESC2_##x }
1da177e4	68
8a4606c6	69	static struct dioname names[] = {
dffae938 AV	70	DIONAME(DCA0), DIONAME(DCA0REM), DIONAME(DCA1), DIONAME(DCA1REM),
	71	DIONAME(DCM), DIONAME(DCMREM),
	72	DIONAME(LAN),
	73	DIONAME(FHPIB), DIONAME(NHPIB),
	74	DIONAME(SCSI0), DIONAME(SCSI1), DIONAME(SCSI2), DIONAME(SCSI3),
	75	DIONAME(FBUFFER),
	76	DIONAME(PARALLEL), DIONAME(VME), DIONAME(DCL), DIONAME(DCLREM),
	77	DIONAME(MISC0), DIONAME(MISC1), DIONAME(MISC2), DIONAME(MISC3),
	78	DIONAME(MISC4), DIONAME(MISC5), DIONAME(MISC6), DIONAME(MISC7),
7649cb6f	79	DIONAME(MISC8), DIONAME(MISC9), DIONAME(MISC10), DIONAME(MISC11),
dffae938 AV	80	DIONAME(MISC12), DIONAME(MISC13),
	81	DIOFBNAME(GATORBOX), DIOFBNAME(TOPCAT), DIOFBNAME(RENAISSANCE),
	82	DIOFBNAME(LRCATSEYE), DIOFBNAME(HRCCATSEYE), DIOFBNAME(HRMCATSEYE),
	83	DIOFBNAME(DAVINCI), DIOFBNAME(XXXCATSEYE), DIOFBNAME(HYPERION),
7649cb6f	84	DIOFBNAME(XGENESIS), DIOFBNAME(TIGER), DIOFBNAME(YGENESIS)
1da177e4 LT	85	};
	86
	87	#undef DIONAME
	88	#undef DIOFBNAME
	89
627f192d GU	90	static const char unknowndioname[]
627f192d GU	91	= "unknown DIO board, please email linux-m68k@lists.linux-m68k.org";
1da177e4 LT	92
	93	static const char *dio_getname(int id)
	94	{
dffae938	95	/* return pointer to a constant string describing the board with given ID */
1da177e4	96	unsigned int i;
0a8320b0	97	for (i = 0; i < ARRAY_SIZE(names); i++)
7649cb6f	98	if (names[i].id == id)
dffae938	99	return names[i].name;
1da177e4	100
dffae938	101	return unknowndioname;
1da177e4 LT	102	}
	103
	104	#else
	105
	106	static char dio_no_name[] = { 0 };
	107	#define dio_getname(_id) (dio_no_name)
	108
	109	#endif /* CONFIG_DIO_CONSTANTS */
	110
	111	int __init dio_find(int deviceid)
	112	{
	113	/* Called to find a DIO device before the full bus scan has run.
	114	* Only used by the console driver.
	115	*/
	116	int scode, id;
	117	u_char prid, secid, i;
1da177e4 LT	118
	119	for (scode = 0; scode < DIO_SCMAX; scode++) {
	120	void *va;
	121	unsigned long pa;
	122
dffae938 AV	123	if (DIO_SCINHOLE(scode))
dffae938 AV	124	continue;
1da177e4	125
dffae938	126	pa = dio_scodetophysaddr(scode);
1da177e4 LT	127
	128	if (!pa)
	129	continue;
	130
	131	if (scode < DIOII_SCBASE)
	132	va = (void *)(pa + DIO_VIRADDRBASE);
	133	else
	134	va = ioremap(pa, PAGE_SIZE);
	135
fe557319 CH	136	if (copy_from_kernel_nofault(&i,
fe557319 CH	137	(unsigned char *)va + DIO_IDOFF, 1)) {
1da177e4 LT	138	if (scode >= DIOII_SCBASE)
1da177e4 LT	139	iounmap(va);
dffae938	140	continue; /* no board present at that select code */
1da177e4 LT	141	}
1da177e4 LT	142
1da177e4 LT	143	prid = DIO_ID(va);
1da177e4 LT	144
dffae938 AV	145	if (DIO_NEEDSSECID(prid)) {
	146	secid = DIO_SECID(va);
	147	id = DIO_ENCODE_ID(prid, secid);
	148	} else
1da177e4 LT	149	id = prid;
	150
	151	if (id == deviceid) {
	152	if (scode >= DIOII_SCBASE)
	153	iounmap(va);
	154	return scode;
	155	}
	156	}
	157
	158	return -1;
	159	}
	160
	161	/* This is the function that scans the DIO space and works out what
	162	* hardware is actually present.
	163	*/
	164	static int __init dio_init(void)
	165	{
	166	int scode;
1da177e4 LT	167	int i;
1da177e4 LT	168	struct dio_dev *dev;
2e4c77be	169	int error;
1da177e4 LT	170
	171	if (!MACH_IS_HP300)
	172	return 0;
	173
	174	printk(KERN_INFO "Scanning for DIO devices...\n");
	175
7649cb6f	176	/* Initialize the DIO bus */
1da177e4	177	INIT_LIST_HEAD(&dio_bus.devices);
9591463a	178	dev_set_name(&dio_bus.dev, "dio");
2e4c77be GU	179	error = device_register(&dio_bus.dev);
	180	if (error) {
	181	pr_err("DIO: Error registering dio_bus\n");
	182	return error;
	183	}
1da177e4 LT	184
	185	/* Request all resources */
	186	dio_bus.num_resources = (hp300_model == HP_320 ? 1 : 2);
	187	for (i = 0; i < dio_bus.num_resources; i++)
	188	request_resource(&iomem_resource, &dio_bus.resources[i]);
	189
	190	/* Register all devices */
8a4606c6	191	for (scode = 0; scode < DIO_SCMAX; ++scode) {
dffae938 AV	192	u_char prid, secid = 0; /* primary, secondary ID bytes */
dffae938 AV	193	u_char *va;
1da177e4	194	unsigned long pa;
7649cb6f	195
dffae938 AV	196	if (DIO_SCINHOLE(scode))
dffae938 AV	197	continue;
1da177e4 LT	198
	199	pa = dio_scodetophysaddr(scode);
	200
	201	if (!pa)
	202	continue;
	203
	204	if (scode < DIOII_SCBASE)
	205	va = (void *)(pa + DIO_VIRADDRBASE);
	206	else
	207	va = ioremap(pa, PAGE_SIZE);
	208
fe557319 CH	209	if (copy_from_kernel_nofault(&i,
fe557319 CH	210	(unsigned char *)va + DIO_IDOFF, 1)) {
1da177e4 LT	211	if (scode >= DIOII_SCBASE)
1da177e4 LT	212	iounmap(va);
dffae938	213	continue; /* no board present at that select code */
1da177e4 LT	214	}
1da177e4 LT	215
dffae938	216	/* Found a board, allocate it an entry in the list */
e66860cb	217	dev = kzalloc(sizeof(struct dio_dev), GFP_KERNEL);
1da177e4	218	if (!dev)
d1d26f40	219	return -ENOMEM;
1da177e4	220
1da177e4 LT	221	dev->bus = &dio_bus;
	222	dev->dev.parent = &dio_bus.dev;
	223	dev->dev.bus = &dio_bus_type;
	224	dev->scode = scode;
	225	dev->resource.start = pa;
	226	dev->resource.end = pa + DIO_SIZE(scode, va);
9591463a	227	dev_set_name(&dev->dev, "%02x", scode);
1da177e4	228
dffae938	229	/* read the ID byte(s) and encode if necessary. */
1da177e4 LT	230	prid = DIO_ID(va);
1da177e4 LT	231
dffae938 AV	232	if (DIO_NEEDSSECID(prid)) {
	233	secid = DIO_SECID(va);
	234	dev->id = DIO_ENCODE_ID(prid, secid);
	235	} else
	236	dev->id = prid;
1da177e4	237
dffae938	238	dev->ipl = DIO_IPL(va);
f8b187c2	239	strcpy(dev->name, dio_getname(dev->id));
1da177e4	240	printk(KERN_INFO "select code %3d: ipl %d: ID %02X", dev->scode, dev->ipl, prid);
dffae938	241	if (DIO_NEEDSSECID(prid))
1da177e4 LT	242	printk(":%02X", secid);
	243	printk(": %s\n", dev->name);
	244
	245	if (scode >= DIOII_SCBASE)
	246	iounmap(va);
2e4c77be GU	247	error = device_register(&dev->dev);
	248	if (error) {
	249	pr_err("DIO: Error registering device %s\n",
	250	dev->name);
	251	continue;
	252	}
	253	error = dio_create_sysfs_dev_files(dev);
	254	if (error)
	255	dev_err(&dev->dev, "Error creating sysfs files\n");
dffae938	256	}
1da177e4 LT	257	return 0;
	258	}
	259
	260	subsys_initcall(dio_init);
	261
	262	/* Bear in mind that this is called in the very early stages of initialisation
	263	* in order to get the address of the serial port for the console...
	264	*/
	265	unsigned long dio_scodetophysaddr(int scode)
	266	{
8a4606c6	267	if (scode >= DIOII_SCBASE)
dffae938	268	return (DIOII_BASE + (scode - 132) * DIOII_DEVSIZE);
8a4606c6	269	else if (scode > DIO_SCMAX \|\| scode < 0)
dffae938 AV	270	return 0;
	271	else if (DIO_SCINHOLE(scode))
	272	return 0;
1da177e4	273
dffae938	274	return (DIO_BASE + scode * DIO_DEVSIZE);
1da177e4	275	}