[linux.git] / drivers / tc / tc.c

/*
 *	TURBOchannel bus services.
 *
 *	Copyright (c) Harald Koerfgen, 1998
 *	Copyright (c) 2001, 2003, 2005, 2006  Maciej W. Rozycki
 *	Copyright (c) 2005  James Simmons
 *
 *	This file is subject to the terms and conditions of the GNU
 *	General Public License.  See the file "COPYING" in the main
 *	directory of this archive for more details.
 */
#include <linux/compiler.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/ioport.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/tc.h>
#include <linux/types.h>

#include <asm/io.h>

static struct tc_bus tc_bus = {
	.name = "TURBOchannel",
};

/*
 * Probing for TURBOchannel modules.
 */
static void __init tc_bus_add_devices(struct tc_bus *tbus)
{
	resource_size_t slotsize = tbus->info.slot_size << 20;
	resource_size_t extslotsize = tbus->ext_slot_size;
	resource_size_t slotaddr;
	resource_size_t extslotaddr;
	resource_size_t devsize;
	void __iomem *module;
	struct tc_dev *tdev;
	int i, slot, err;
	u8 pattern[4];
	long offset;

	for (slot = 0; slot < tbus->num_tcslots; slot++) {
		slotaddr = tbus->slot_base + slot * slotsize;
		extslotaddr = tbus->ext_slot_base + slot * extslotsize;
		module = ioremap_nocache(slotaddr, slotsize);
		BUG_ON(!module);

		offset = TC_OLDCARD;

		err = 0;
		err |= tc_preadb(pattern + 0, module + offset + TC_PATTERN0);
		err |= tc_preadb(pattern + 1, module + offset + TC_PATTERN1);
		err |= tc_preadb(pattern + 2, module + offset + TC_PATTERN2);
		err |= tc_preadb(pattern + 3, module + offset + TC_PATTERN3);
		if (err)
			goto out_err;

		if (pattern[0] != 0x55 || pattern[1] != 0x00 ||
		    pattern[2] != 0xaa || pattern[3] != 0xff) {
			offset = TC_NEWCARD;

			err = 0;
			err |= tc_preadb(pattern + 0,
					 module + offset + TC_PATTERN0);
			err |= tc_preadb(pattern + 1,
					 module + offset + TC_PATTERN1);
			err |= tc_preadb(pattern + 2,
					 module + offset + TC_PATTERN2);
			err |= tc_preadb(pattern + 3,
					 module + offset + TC_PATTERN3);
			if (err)
				goto out_err;
		}

		if (pattern[0] != 0x55 || pattern[1] != 0x00 ||
		    pattern[2] != 0xaa || pattern[3] != 0xff)
			goto out_err;

		/* Found a board, allocate it an entry in the list */
		tdev = kzalloc(sizeof(*tdev), GFP_KERNEL);
		if (!tdev) {
			printk(KERN_ERR "tc%x: unable to allocate tc_dev\n",
			       slot);
			goto out_err;
		}
		dev_set_name(&tdev->dev, "tc%x", slot);
		tdev->bus = tbus;
		tdev->dev.parent = &tbus->dev;
		tdev->dev.bus = &tc_bus_type;
		tdev->slot = slot;

		for (i = 0; i < 8; i++) {
			tdev->firmware[i] =
				readb(module + offset + TC_FIRM_VER + 4 * i);
			tdev->vendor[i] =
				readb(module + offset + TC_VENDOR + 4 * i);
			tdev->name[i] =
				readb(module + offset + TC_MODULE + 4 * i);
		}
		tdev->firmware[8] = 0;
		tdev->vendor[8] = 0;
		tdev->name[8] = 0;

		pr_info("%s: %s %s %s\n", dev_name(&tdev->dev), tdev->vendor,
			tdev->name, tdev->firmware);

		devsize = readb(module + offset + TC_SLOT_SIZE);
		devsize <<= 22;
		if (devsize <= slotsize) {
			tdev->resource.start = slotaddr;
			tdev->resource.end = slotaddr + devsize - 1;
		} else if (devsize <= extslotsize) {
			tdev->resource.start = extslotaddr;
			tdev->resource.end = extslotaddr + devsize - 1;
		} else {
			printk(KERN_ERR "%s: Cannot provide slot space "
			       "(%dMiB required, up to %dMiB supported)\n",
			       dev_name(&tdev->dev), devsize >> 20,
			       max(slotsize, extslotsize) >> 20);
			kfree(tdev);
			goto out_err;
		}
		tdev->resource.name = tdev->name;
		tdev->resource.flags = IORESOURCE_MEM;

		tc_device_get_irq(tdev);

		device_register(&tdev->dev);
		list_add_tail(&tdev->node, &tbus->devices);

out_err:
		iounmap(module);
	}
}

/*
 * The main entry.
 */
static int __init tc_init(void)
{
	/* Initialize the TURBOchannel bus */
	if (tc_bus_get_info(&tc_bus))
		return 0;

	INIT_LIST_HEAD(&tc_bus.devices);
	dev_set_name(&tc_bus.dev, "tc");
	device_register(&tc_bus.dev);

	if (tc_bus.info.slot_size) {
		unsigned int tc_clock = tc_get_speed(&tc_bus) / 100000;

		pr_info("tc: TURBOchannel rev. %d at %d.%d MHz "
			"(with%s parity)\n", tc_bus.info.revision,
			tc_clock / 10, tc_clock % 10,
			tc_bus.info.parity ? "" : "out");

		tc_bus.resource[0].start = tc_bus.slot_base;
		tc_bus.resource[0].end = tc_bus.slot_base +
					 (tc_bus.info.slot_size << 20) *
					 tc_bus.num_tcslots - 1;
		tc_bus.resource[0].name = tc_bus.name;
		tc_bus.resource[0].flags = IORESOURCE_MEM;
		if (request_resource(&iomem_resource,
				     &tc_bus.resource[0]) < 0) {
			printk(KERN_ERR "tc: Cannot reserve resource\n");
			return 0;
		}
		if (tc_bus.ext_slot_size) {
			tc_bus.resource[1].start = tc_bus.ext_slot_base;
			tc_bus.resource[1].end = tc_bus.ext_slot_base +
						 tc_bus.ext_slot_size *
						 tc_bus.num_tcslots - 1;
			tc_bus.resource[1].name = tc_bus.name;
			tc_bus.resource[1].flags = IORESOURCE_MEM;
			if (request_resource(&iomem_resource,
					     &tc_bus.resource[1]) < 0) {
				printk(KERN_ERR
				       "tc: Cannot reserve resource\n");
				release_resource(&tc_bus.resource[0]);
				return 0;
			}
		}

		tc_bus_add_devices(&tc_bus);
	}

	return 0;
}

subsys_initcall(tc_init);
Commit	Line	Data
1da177e4	1	/*
b454cc66	2	* TURBOchannel bus services.
1da177e4	3	*
b454cc66 MR	4	* Copyright (c) Harald Koerfgen, 1998
	5	* Copyright (c) 2001, 2003, 2005, 2006 Maciej W. Rozycki
	6	* Copyright (c) 2005 James Simmons
1da177e4	7	*
b454cc66 MR	8	* This file is subject to the terms and conditions of the GNU
	9	* General Public License. See the file "COPYING" in the main
	10	* directory of this archive for more details.
1da177e4	11	*/
b454cc66 MR	12	#include <linux/compiler.h>
b454cc66 MR	13	#include <linux/errno.h>
1da177e4	14	#include <linux/init.h>
b454cc66	15	#include <linux/ioport.h>
1da177e4	16	#include <linux/kernel.h>
b454cc66	17	#include <linux/list.h>
1da177e4	18	#include <linux/module.h>
5a0e3ad6	19	#include <linux/slab.h>
a5fc9c0b	20	#include <linux/string.h>
b454cc66	21	#include <linux/tc.h>
a5fc9c0b	22	#include <linux/types.h>
1da177e4	23
a5fc9c0b	24	#include <asm/io.h>
a5fc9c0b	25
b454cc66 MR	26	static struct tc_bus tc_bus = {
	27	.name = "TURBOchannel",
	28	};
1da177e4	29
1da177e4	30	/*
b454cc66	31	* Probing for TURBOchannel modules.
1da177e4	32	*/
b454cc66	33	static void __init tc_bus_add_devices(struct tc_bus *tbus)
1da177e4	34	{
b454cc66 MR	35	resource_size_t slotsize = tbus->info.slot_size << 20;
	36	resource_size_t extslotsize = tbus->ext_slot_size;
	37	resource_size_t slotaddr;
	38	resource_size_t extslotaddr;
	39	resource_size_t devsize;
	40	void __iomem *module;
	41	struct tc_dev *tdev;
1da177e4	42	int i, slot, err;
a5fc9c0b	43	u8 pattern[4];
b454cc66	44	long offset;
1da177e4	45
b454cc66 MR	46	for (slot = 0; slot < tbus->num_tcslots; slot++) {
	47	slotaddr = tbus->slot_base + slot * slotsize;
	48	extslotaddr = tbus->ext_slot_base + slot * extslotsize;
	49	module = ioremap_nocache(slotaddr, slotsize);
a5fc9c0b	50	BUG_ON(!module);
1da177e4	51
b454cc66	52	offset = TC_OLDCARD;
1da177e4 LT	53
1da177e4 LT	54	err = 0;
b454cc66 MR	55	err \|= tc_preadb(pattern + 0, module + offset + TC_PATTERN0);
	56	err \|= tc_preadb(pattern + 1, module + offset + TC_PATTERN1);
	57	err \|= tc_preadb(pattern + 2, module + offset + TC_PATTERN2);
	58	err \|= tc_preadb(pattern + 3, module + offset + TC_PATTERN3);
	59	if (err)
	60	goto out_err;
1da177e4 LT	61
	62	if (pattern[0] != 0x55 \|\| pattern[1] != 0x00 \|\|
	63	pattern[2] != 0xaa \|\| pattern[3] != 0xff) {
b454cc66	64	offset = TC_NEWCARD;
1da177e4 LT	65
1da177e4 LT	66	err = 0;
b454cc66 MR	67	err \|= tc_preadb(pattern + 0,
	68	module + offset + TC_PATTERN0);
	69	err \|= tc_preadb(pattern + 1,
	70	module + offset + TC_PATTERN1);
	71	err \|= tc_preadb(pattern + 2,
	72	module + offset + TC_PATTERN2);
	73	err \|= tc_preadb(pattern + 3,
	74	module + offset + TC_PATTERN3);
	75	if (err)
	76	goto out_err;
1da177e4 LT	77	}
	78
	79	if (pattern[0] != 0x55 \|\| pattern[1] != 0x00 \|\|
b454cc66 MR	80	pattern[2] != 0xaa \|\| pattern[3] != 0xff)
	81	goto out_err;
	82
	83	/* Found a board, allocate it an entry in the list */
	84	tdev = kzalloc(sizeof(*tdev), GFP_KERNEL);
	85	if (!tdev) {
	86	printk(KERN_ERR "tc%x: unable to allocate tc_dev\n",
	87	slot);
	88	goto out_err;
a5fc9c0b	89	}
df388556	90	dev_set_name(&tdev->dev, "tc%x", slot);
b454cc66 MR	91	tdev->bus = tbus;
	92	tdev->dev.parent = &tbus->dev;
	93	tdev->dev.bus = &tc_bus_type;
	94	tdev->slot = slot;
1da177e4	95
a5fc9c0b	96	for (i = 0; i < 8; i++) {
b454cc66 MR	97	tdev->firmware[i] =
	98	readb(module + offset + TC_FIRM_VER + 4 * i);
	99	tdev->vendor[i] =
	100	readb(module + offset + TC_VENDOR + 4 * i);
	101	tdev->name[i] =
	102	readb(module + offset + TC_MODULE + 4 * i);
1da177e4	103	}
b454cc66 MR	104	tdev->firmware[8] = 0;
	105	tdev->vendor[8] = 0;
	106	tdev->name[8] = 0;
	107
df388556	108	pr_info("%s: %s %s %s\n", dev_name(&tdev->dev), tdev->vendor,
b454cc66 MR	109	tdev->name, tdev->firmware);
	110
	111	devsize = readb(module + offset + TC_SLOT_SIZE);
	112	devsize <<= 22;
	113	if (devsize <= slotsize) {
	114	tdev->resource.start = slotaddr;
	115	tdev->resource.end = slotaddr + devsize - 1;
	116	} else if (devsize <= extslotsize) {
	117	tdev->resource.start = extslotaddr;
	118	tdev->resource.end = extslotaddr + devsize - 1;
	119	} else {
	120	printk(KERN_ERR "%s: Cannot provide slot space "
	121	"(%dMiB required, up to %dMiB supported)\n",
df388556	122	dev_name(&tdev->dev), devsize >> 20,
b454cc66 MR	123	max(slotsize, extslotsize) >> 20);
	124	kfree(tdev);
	125	goto out_err;
1da177e4	126	}
b454cc66 MR	127	tdev->resource.name = tdev->name;
	128	tdev->resource.flags = IORESOURCE_MEM;
	129
	130	tc_device_get_irq(tdev);
a5fc9c0b	131
b454cc66 MR	132	device_register(&tdev->dev);
	133	list_add_tail(&tdev->node, &tbus->devices);
	134
	135	out_err:
a5fc9c0b	136	iounmap(module);
1da177e4 LT	137	}
	138	}
	139
	140	/*
b454cc66	141	* The main entry.
1da177e4	142	*/
778220f7	143	static int __init tc_init(void)
1da177e4	144	{
b454cc66 MR	145	/* Initialize the TURBOchannel bus */
b454cc66 MR	146	if (tc_bus_get_info(&tc_bus))
778220f7	147	return 0;
1da177e4	148
b454cc66	149	INIT_LIST_HEAD(&tc_bus.devices);
df388556	150	dev_set_name(&tc_bus.dev, "tc");
b454cc66 MR	151	device_register(&tc_bus.dev);
	152
	153	if (tc_bus.info.slot_size) {
	154	unsigned int tc_clock = tc_get_speed(&tc_bus) / 100000;
	155
	156	pr_info("tc: TURBOchannel rev. %d at %d.%d MHz "
	157	"(with%s parity)\n", tc_bus.info.revision,
	158	tc_clock / 10, tc_clock % 10,
	159	tc_bus.info.parity ? "" : "out");
	160
	161	tc_bus.resource[0].start = tc_bus.slot_base;
	162	tc_bus.resource[0].end = tc_bus.slot_base +
	163	(tc_bus.info.slot_size << 20) *
56a47da1	164	tc_bus.num_tcslots - 1;
b454cc66 MR	165	tc_bus.resource[0].name = tc_bus.name;
	166	tc_bus.resource[0].flags = IORESOURCE_MEM;
	167	if (request_resource(&iomem_resource,
	168	&tc_bus.resource[0]) < 0) {
	169	printk(KERN_ERR "tc: Cannot reserve resource\n");
	170	return 0;
	171	}
	172	if (tc_bus.ext_slot_size) {
	173	tc_bus.resource[1].start = tc_bus.ext_slot_base;
	174	tc_bus.resource[1].end = tc_bus.ext_slot_base +
	175	tc_bus.ext_slot_size *
56a47da1	176	tc_bus.num_tcslots - 1;
b454cc66 MR	177	tc_bus.resource[1].name = tc_bus.name;
	178	tc_bus.resource[1].flags = IORESOURCE_MEM;
	179	if (request_resource(&iomem_resource,
	180	&tc_bus.resource[1]) < 0) {
	181	printk(KERN_ERR
	182	"tc: Cannot reserve resource\n");
	183	release_resource(&tc_bus.resource[0]);
	184	return 0;
	185	}
a5fc9c0b	186	}
b454cc66 MR	187
b454cc66 MR	188	tc_bus_add_devices(&tc_bus);
1da177e4	189	}
778220f7 MR	190
778220f7 MR	191	return 0;
1da177e4 LT	192	}
	193
	194	subsys_initcall(tc_init);