[linux-2.6-block.git] / drivers / scsi / arm / arxescsi.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * linux/drivers/scsi/arm/arxescsi.c
 *
 * Copyright (C) 1997-2000 Russell King, Stefan Hanske
 *
 * This driver is based on experimentation.  Hence, it may have made
 * assumptions about the particular card that I have available, and
 * may not be reliable!
 *
 * Changelog:
 *  30-08-1997	RMK	0.0.0	Created, READONLY version as cumana_2.c
 *  22-01-1998	RMK	0.0.1	Updated to 2.1.80
 *  15-04-1998	RMK	0.0.1	Only do PIO if FAS216 will allow it.
 *  11-06-1998 	SH	0.0.2   Changed to support ARXE 16-bit SCSI card
 *				enabled writing
 *  01-01-2000	SH	0.1.0   Added *real* pseudo dma writing
 *				(arxescsi_pseudo_dma_write)
 *  02-04-2000	RMK	0.1.1	Updated for new error handling code.
 *  22-10-2000  SH		Updated for new registering scheme.
 */
#include <linux/module.h>
#include <linux/blkdev.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/ioport.h>
#include <linux/proc_fs.h>
#include <linux/unistd.h>
#include <linux/stat.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/interrupt.h>

#include <asm/dma.h>
#include <asm/io.h>
#include <asm/ecard.h>

#include "../scsi.h"
#include <scsi/scsi_host.h>
#include "fas216.h"

struct arxescsi_info {
	FAS216_Info		info;
	struct expansion_card	*ec;
	void __iomem		*base;
};

#define DMADATA_OFFSET	(0x200)

#define DMASTAT_OFFSET	(0x600)
#define DMASTAT_DRQ	(1 << 0)

#define CSTATUS_IRQ	(1 << 0)

#define VERSION "1.10 (23/01/2003 2.5.57)"

/*
 * Function: int arxescsi_dma_setup(host, SCpnt, direction, min_type)
 * Purpose : initialises DMA/PIO
 * Params  : host      - host
 *	     SCpnt     - command
 *	     direction - DMA on to/off of card
 *	     min_type  - minimum DMA support that we must have for this transfer
 * Returns : 0 if we should not set CMD_WITHDMA for transfer info command
 */
static fasdmatype_t
arxescsi_dma_setup(struct Scsi_Host *host, struct scsi_pointer *SCp,
		       fasdmadir_t direction, fasdmatype_t min_type)
{
	/*
	 * We don't do real DMA
	 */
	return fasdma_pseudo;
}

static void arxescsi_pseudo_dma_write(unsigned char *addr, void __iomem *base)
{
       __asm__ __volatile__(
       "               stmdb   sp!, {r0-r12}\n"
       "               mov     r3, %0\n"
       "               mov     r1, %1\n"
       "               add     r2, r1, #512\n"
       "               mov     r4, #256\n"
       ".loop_1:       ldmia   r3!, {r6, r8, r10, r12}\n"
       "               mov     r5, r6, lsl #16\n"
       "               mov     r7, r8, lsl #16\n"
       ".loop_2:       ldrb    r0, [r1, #1536]\n"
       "               tst     r0, #1\n"
       "               beq     .loop_2\n"
       "               stmia   r2, {r5-r8}\n\t"
       "               mov     r9, r10, lsl #16\n"
       "               mov     r11, r12, lsl #16\n"
       ".loop_3:       ldrb    r0, [r1, #1536]\n"
       "               tst     r0, #1\n"
       "               beq     .loop_3\n"
       "               stmia   r2, {r9-r12}\n"
       "               subs    r4, r4, #16\n"
       "               bne     .loop_1\n"
       "               ldmia   sp!, {r0-r12}\n"
       :
       : "r" (addr), "r" (base));
}

/*
 * Function: int arxescsi_dma_pseudo(host, SCpnt, direction, transfer)
 * Purpose : handles pseudo DMA
 * Params  : host      - host
 *	     SCpnt     - command
 *	     direction - DMA on to/off of card
 *	     transfer  - minimum number of bytes we expect to transfer
 */
static void
arxescsi_dma_pseudo(struct Scsi_Host *host, struct scsi_pointer *SCp,
		    fasdmadir_t direction, int transfer)
{
	struct arxescsi_info *info = (struct arxescsi_info *)host->hostdata;
	unsigned int length, error = 0;
	void __iomem *base = info->info.scsi.io_base;
	unsigned char *addr;

	length = SCp->this_residual;
	addr = SCp->ptr;

	if (direction == DMA_OUT) {
		unsigned int word;
		while (length > 256) {
			if (readb(base + 0x80) & STAT_INT) {
				error = 1;
				break;
			}
			arxescsi_pseudo_dma_write(addr, base);
			addr += 256;
			length -= 256;
		}

		if (!error)
			while (length > 0) {
				if (readb(base + 0x80) & STAT_INT)
					break;
	 
				if (!(readb(base + DMASTAT_OFFSET) & DMASTAT_DRQ))
					continue;

				word = *addr | *(addr + 1) << 8;

				writew(word, base + DMADATA_OFFSET);
				if (length > 1) {
					addr += 2;
					length -= 2;
				} else {
					addr += 1;
					length -= 1;
				}
			}
	}
	else {
		if (transfer && (transfer & 255)) {
			while (length >= 256) {
				if (readb(base + 0x80) & STAT_INT) {
					error = 1;
					break;
				}
	    
				if (!(readb(base + DMASTAT_OFFSET) & DMASTAT_DRQ))
					continue;

				readsw(base + DMADATA_OFFSET, addr, 256 >> 1);
				addr += 256;
				length -= 256;
			}
		}

		if (!(error))
			while (length > 0) {
				unsigned long word;

				if (readb(base + 0x80) & STAT_INT)
					break;

				if (!(readb(base + DMASTAT_OFFSET) & DMASTAT_DRQ))
					continue;

				word = readw(base + DMADATA_OFFSET);
				*addr++ = word;
				if (--length > 0) {
					*addr++ = word >> 8;
					length --;
				}
			}
	}
}

/*
 * Function: int arxescsi_dma_stop(host, SCpnt)
 * Purpose : stops DMA/PIO
 * Params  : host  - host
 *	     SCpnt - command
 */
static void arxescsi_dma_stop(struct Scsi_Host *host, struct scsi_pointer *SCp)
{
	/*
	 * no DMA to stop
	 */
}

/*
 * Function: const char *arxescsi_info(struct Scsi_Host * host)
 * Purpose : returns a descriptive string about this interface,
 * Params  : host - driver host structure to return info for.
 * Returns : pointer to a static buffer containing null terminated string.
 */
static const char *arxescsi_info(struct Scsi_Host *host)
{
	struct arxescsi_info *info = (struct arxescsi_info *)host->hostdata;
	static char string[150];

	sprintf(string, "%s (%s) in slot %d v%s",
		host->hostt->name, info->info.scsi.type, info->ec->slot_no,
		VERSION);

	return string;
}

static int
arxescsi_show_info(struct seq_file *m, struct Scsi_Host *host)
{
	struct arxescsi_info *info;
	info = (struct arxescsi_info *)host->hostdata;

	seq_printf(m, "ARXE 16-bit SCSI driver v%s\n", VERSION);
	fas216_print_host(&info->info, m);
	fas216_print_stats(&info->info, m);
	fas216_print_devices(&info->info, m);
	return 0;
}

static struct scsi_host_template arxescsi_template = {
	.show_info			= arxescsi_show_info,
	.name				= "ARXE SCSI card",
	.info				= arxescsi_info,
	.queuecommand			= fas216_noqueue_command,
	.eh_host_reset_handler		= fas216_eh_host_reset,
	.eh_bus_reset_handler		= fas216_eh_bus_reset,
	.eh_device_reset_handler	= fas216_eh_device_reset,
	.eh_abort_handler		= fas216_eh_abort,
	.can_queue			= 0,
	.this_id			= 7,
	.sg_tablesize			= SG_ALL,
	.dma_boundary			= PAGE_SIZE - 1,
	.proc_name			= "arxescsi",
};

static int arxescsi_probe(struct expansion_card *ec, const struct ecard_id *id)
{
	struct Scsi_Host *host;
	struct arxescsi_info *info;
	void __iomem *base;
	int ret;

	ret = ecard_request_resources(ec);
	if (ret)
		goto out;

	base = ecardm_iomap(ec, ECARD_RES_MEMC, 0, 0);
	if (!base) {
		ret = -ENOMEM;
		goto out_region;
	}

	host = scsi_host_alloc(&arxescsi_template, sizeof(struct arxescsi_info));
	if (!host) {
		ret = -ENOMEM;
		goto out_region;
	}

	info = (struct arxescsi_info *)host->hostdata;
	info->ec = ec;
	info->base = base;

	info->info.scsi.io_base		= base + 0x2000;
	info->info.scsi.irq		= 0;
	info->info.scsi.dma		= NO_DMA;
	info->info.scsi.io_shift	= 5;
	info->info.ifcfg.clockrate	= 24; /* MHz */
	info->info.ifcfg.select_timeout = 255;
	info->info.ifcfg.asyncperiod	= 200; /* ns */
	info->info.ifcfg.sync_max_depth	= 0;
	info->info.ifcfg.cntl3		= CNTL3_FASTSCSI | CNTL3_FASTCLK;
	info->info.ifcfg.disconnect_ok	= 0;
	info->info.ifcfg.wide_max_size	= 0;
	info->info.ifcfg.capabilities	= FASCAP_PSEUDODMA;
	info->info.dma.setup		= arxescsi_dma_setup;
	info->info.dma.pseudo		= arxescsi_dma_pseudo;
	info->info.dma.stop		= arxescsi_dma_stop;
		
	ec->irqaddr = base;
	ec->irqmask = CSTATUS_IRQ;

	ret = fas216_init(host);
	if (ret)
		goto out_unregister;

	ret = fas216_add(host, &ec->dev);
	if (ret == 0)
		goto out;

	fas216_release(host);
 out_unregister:
	scsi_host_put(host);
 out_region:
	ecard_release_resources(ec);
 out:
	return ret;
}

static void arxescsi_remove(struct expansion_card *ec)
{
	struct Scsi_Host *host = ecard_get_drvdata(ec);

	ecard_set_drvdata(ec, NULL);
	fas216_remove(host);

	fas216_release(host);
	scsi_host_put(host);
	ecard_release_resources(ec);
}

static const struct ecard_id arxescsi_cids[] = {
	{ MANU_ARXE, PROD_ARXE_SCSI },
	{ 0xffff, 0xffff },
};

static struct ecard_driver arxescsi_driver = {
	.probe		= arxescsi_probe,
	.remove		= arxescsi_remove,
	.id_table	= arxescsi_cids,
	.drv = {
		.name		= "arxescsi",
	},
};

static int __init init_arxe_scsi_driver(void)
{
	return ecard_register_driver(&arxescsi_driver);
}

static void __exit exit_arxe_scsi_driver(void)
{
	ecard_remove_driver(&arxescsi_driver);
}

module_init(init_arxe_scsi_driver);
module_exit(exit_arxe_scsi_driver);

MODULE_AUTHOR("Stefan Hanske");
MODULE_DESCRIPTION("ARXESCSI driver for Acorn machines");
MODULE_LICENSE("GPL");
Commit	Line	Data
09c434b8	1	// SPDX-License-Identifier: GPL-2.0-only
1da177e4	2	/*
f30c2269	3	* linux/drivers/scsi/arm/arxescsi.c
1da177e4 LT	4	*
	5	* Copyright (C) 1997-2000 Russell King, Stefan Hanske
	6	*
	7	* This driver is based on experimentation. Hence, it may have made
	8	* assumptions about the particular card that I have available, and
	9	* may not be reliable!
	10	*
	11	* Changelog:
	12	* 30-08-1997 RMK 0.0.0 Created, READONLY version as cumana_2.c
	13	* 22-01-1998 RMK 0.0.1 Updated to 2.1.80
	14	* 15-04-1998 RMK 0.0.1 Only do PIO if FAS216 will allow it.
	15	* 11-06-1998 SH 0.0.2 Changed to support ARXE 16-bit SCSI card
	16	* enabled writing
	17	* 01-01-2000 SH 0.1.0 Added real pseudo dma writing
	18	* (arxescsi_pseudo_dma_write)
	19	* 02-04-2000 RMK 0.1.1 Updated for new error handling code.
	20	* 22-10-2000 SH Updated for new registering scheme.
	21	*/
	22	#include <linux/module.h>
	23	#include <linux/blkdev.h>
	24	#include <linux/kernel.h>
	25	#include <linux/string.h>
	26	#include <linux/ioport.h>
1da177e4 LT	27	#include <linux/proc_fs.h>
	28	#include <linux/unistd.h>
	29	#include <linux/stat.h>
	30	#include <linux/delay.h>
	31	#include <linux/init.h>
	32	#include <linux/interrupt.h>
	33
	34	#include <asm/dma.h>
	35	#include <asm/io.h>
1da177e4 LT	36	#include <asm/ecard.h>
	37
	38	#include "../scsi.h"
	39	#include <scsi/scsi_host.h>
	40	#include "fas216.h"
	41
	42	struct arxescsi_info {
	43	FAS216_Info info;
	44	struct expansion_card *ec;
	45	void __iomem *base;
	46	};
	47
	48	#define DMADATA_OFFSET (0x200)
	49
	50	#define DMASTAT_OFFSET (0x600)
	51	#define DMASTAT_DRQ (1 << 0)
	52
	53	#define CSTATUS_IRQ (1 << 0)
	54
	55	#define VERSION "1.10 (23/01/2003 2.5.57)"
	56
	57	/*
	58	* Function: int arxescsi_dma_setup(host, SCpnt, direction, min_type)
	59	* Purpose : initialises DMA/PIO
	60	* Params : host - host
	61	* SCpnt - command
	62	* direction - DMA on to/off of card
	63	* min_type - minimum DMA support that we must have for this transfer
	64	* Returns : 0 if we should not set CMD_WITHDMA for transfer info command
	65	*/
	66	static fasdmatype_t
0a04137e	67	arxescsi_dma_setup(struct Scsi_Host host, struct scsi_pointer SCp,
1da177e4 LT	68	fasdmadir_t direction, fasdmatype_t min_type)
	69	{
	70	/*
	71	* We don't do real DMA
	72	*/
	73	return fasdma_pseudo;
	74	}
	75
	76	static void arxescsi_pseudo_dma_write(unsigned char addr, void __iomem base)
	77	{
	78	__asm__ __volatile__(
	79	" stmdb sp!, {r0-r12}\n"
	80	" mov r3, %0\n"
	81	" mov r1, %1\n"
	82	" add r2, r1, #512\n"
	83	" mov r4, #256\n"
	84	".loop_1: ldmia r3!, {r6, r8, r10, r12}\n"
	85	" mov r5, r6, lsl #16\n"
	86	" mov r7, r8, lsl #16\n"
	87	".loop_2: ldrb r0, [r1, #1536]\n"
	88	" tst r0, #1\n"
	89	" beq .loop_2\n"
	90	" stmia r2, {r5-r8}\n\t"
	91	" mov r9, r10, lsl #16\n"
	92	" mov r11, r12, lsl #16\n"
	93	".loop_3: ldrb r0, [r1, #1536]\n"
	94	" tst r0, #1\n"
	95	" beq .loop_3\n"
	96	" stmia r2, {r9-r12}\n"
	97	" subs r4, r4, #16\n"
	98	" bne .loop_1\n"
	99	" ldmia sp!, {r0-r12}\n"
	100	:
	101	: "r" (addr), "r" (base));
	102	}
	103
	104	/*
	105	* Function: int arxescsi_dma_pseudo(host, SCpnt, direction, transfer)
	106	* Purpose : handles pseudo DMA
	107	* Params : host - host
	108	* SCpnt - command
	109	* direction - DMA on to/off of card
	110	* transfer - minimum number of bytes we expect to transfer
	111	*/
	112	static void
0a04137e	113	arxescsi_dma_pseudo(struct Scsi_Host host, struct scsi_pointer SCp,
1da177e4 LT	114	fasdmadir_t direction, int transfer)
	115	{
	116	struct arxescsi_info info = (struct arxescsi_info )host->hostdata;
	117	unsigned int length, error = 0;
	118	void __iomem *base = info->info.scsi.io_base;
	119	unsigned char *addr;
	120
	121	length = SCp->this_residual;
	122	addr = SCp->ptr;
	123
	124	if (direction == DMA_OUT) {
	125	unsigned int word;
	126	while (length > 256) {
	127	if (readb(base + 0x80) & STAT_INT) {
	128	error = 1;
	129	break;
	130	}
	131	arxescsi_pseudo_dma_write(addr, base);
	132	addr += 256;
	133	length -= 256;
	134	}
	135
	136	if (!error)
	137	while (length > 0) {
	138	if (readb(base + 0x80) & STAT_INT)
	139	break;
	140
	141	if (!(readb(base + DMASTAT_OFFSET) & DMASTAT_DRQ))
	142	continue;
	143
	144	word = addr \| (addr + 1) << 8;
	145
	146	writew(word, base + DMADATA_OFFSET);
	147	if (length > 1) {
	148	addr += 2;
	149	length -= 2;
	150	} else {
	151	addr += 1;
	152	length -= 1;
	153	}
	154	}
	155	}
	156	else {
	157	if (transfer && (transfer & 255)) {
	158	while (length >= 256) {
	159	if (readb(base + 0x80) & STAT_INT) {
	160	error = 1;
	161	break;
	162	}
	163
	164	if (!(readb(base + DMASTAT_OFFSET) & DMASTAT_DRQ))
	165	continue;
	166
	167	readsw(base + DMADATA_OFFSET, addr, 256 >> 1);
	168	addr += 256;
	169	length -= 256;
	170	}
	171	}
	172
	173	if (!(error))
	174	while (length > 0) {
	175	unsigned long word;
	176
	177	if (readb(base + 0x80) & STAT_INT)
178	break;
179
180	if (!(readb(base + DMASTAT_OFFSET) & DMASTAT_DRQ))
181	continue;
182
183	word = readw(base + DMADATA_OFFSET);
184	*addr++ = word;
185	if (--length > 0) {
186	*addr++ = word >> 8;
187	length --;
188	}
189	}
190	}
191	}
192
193	/*
194	* Function: int arxescsi_dma_stop(host, SCpnt)
195	* Purpose : stops DMA/PIO
196	* Params : host - host
197	* SCpnt - command
198	*/
0a04137e	199	static void arxescsi_dma_stop(struct Scsi_Host host, struct scsi_pointer SCp)
1da177e4 LT	200	{
	201	/*
	202	* no DMA to stop
	203	*/
	204	}
	205
	206	/*
	207	* Function: const char arxescsi_info(struct Scsi_Host host)
	208	* Purpose : returns a descriptive string about this interface,
	209	* Params : host - driver host structure to return info for.
	210	* Returns : pointer to a static buffer containing null terminated string.
	211	*/
	212	static const char arxescsi_info(struct Scsi_Host host)
	213	{
	214	struct arxescsi_info info = (struct arxescsi_info )host->hostdata;
	215	static char string[150];
	216
	217	sprintf(string, "%s (%s) in slot %d v%s",
	218	host->hostt->name, info->info.scsi.type, info->ec->slot_no,
	219	VERSION);
	220
	221	return string;
	222	}
	223
1da177e4	224	static int
9d4e5c54	225	arxescsi_show_info(struct seq_file m, struct Scsi_Host host)
1da177e4 LT	226	{
1da177e4 LT	227	struct arxescsi_info *info;
1da177e4	228	info = (struct arxescsi_info *)host->hostdata;
1da177e4	229
9d4e5c54 AV	230	seq_printf(m, "ARXE 16-bit SCSI driver v%s\n", VERSION);
	231	fas216_print_host(&info->info, m);
	232	fas216_print_stats(&info->info, m);
	233	fas216_print_devices(&info->info, m);
	234	return 0;
1da177e4 LT	235	}
1da177e4 LT	236
d0be4a7d	237	static struct scsi_host_template arxescsi_template = {
9d4e5c54	238	.show_info = arxescsi_show_info,
1da177e4 LT	239	.name = "ARXE SCSI card",
	240	.info = arxescsi_info,
	241	.queuecommand = fas216_noqueue_command,
	242	.eh_host_reset_handler = fas216_eh_host_reset,
	243	.eh_bus_reset_handler = fas216_eh_bus_reset,
	244	.eh_device_reset_handler = fas216_eh_device_reset,
	245	.eh_abort_handler = fas216_eh_abort,
	246	.can_queue = 0,
	247	.this_id = 7,
	248	.sg_tablesize = SG_ALL,
4af14d11	249	.dma_boundary = PAGE_SIZE - 1,
1da177e4 LT	250	.proc_name = "arxescsi",
	251	};
	252
6f039790	253	static int arxescsi_probe(struct expansion_card ec, const struct ecard_id id)
1da177e4 LT	254	{
	255	struct Scsi_Host *host;
	256	struct arxescsi_info *info;
1da177e4 LT	257	void __iomem *base;
	258	int ret;
	259
	260	ret = ecard_request_resources(ec);
	261	if (ret)
	262	goto out;
	263
10bdaaa0	264	base = ecardm_iomap(ec, ECARD_RES_MEMC, 0, 0);
1da177e4 LT	265	if (!base) {
	266	ret = -ENOMEM;
	267	goto out_region;
	268	}
	269
	270	host = scsi_host_alloc(&arxescsi_template, sizeof(struct arxescsi_info));
	271	if (!host) {
	272	ret = -ENOMEM;
10bdaaa0	273	goto out_region;
1da177e4 LT	274	}
	275
	276	info = (struct arxescsi_info *)host->hostdata;
	277	info->ec = ec;
	278	info->base = base;
	279
	280	info->info.scsi.io_base = base + 0x2000;
41569e37	281	info->info.scsi.irq = 0;
1da177e4 LT	282	info->info.scsi.dma = NO_DMA;
	283	info->info.scsi.io_shift = 5;
	284	info->info.ifcfg.clockrate = 24; /* MHz */
	285	info->info.ifcfg.select_timeout = 255;
	286	info->info.ifcfg.asyncperiod = 200; /* ns */
	287	info->info.ifcfg.sync_max_depth = 0;
	288	info->info.ifcfg.cntl3 = CNTL3_FASTSCSI \| CNTL3_FASTCLK;
	289	info->info.ifcfg.disconnect_ok = 0;
	290	info->info.ifcfg.wide_max_size = 0;
	291	info->info.ifcfg.capabilities = FASCAP_PSEUDODMA;
	292	info->info.dma.setup = arxescsi_dma_setup;
	293	info->info.dma.pseudo = arxescsi_dma_pseudo;
	294	info->info.dma.stop = arxescsi_dma_stop;
	295
	296	ec->irqaddr = base;
	297	ec->irqmask = CSTATUS_IRQ;
	298
	299	ret = fas216_init(host);
	300	if (ret)
	301	goto out_unregister;
	302
	303	ret = fas216_add(host, &ec->dev);
	304	if (ret == 0)
	305	goto out;
	306
	307	fas216_release(host);
	308	out_unregister:
	309	scsi_host_put(host);
1da177e4 LT	310	out_region:
	311	ecard_release_resources(ec);
	312	out:
	313	return ret;
	314	}
	315
6f039790	316	static void arxescsi_remove(struct expansion_card *ec)
1da177e4 LT	317	{
1da177e4 LT	318	struct Scsi_Host *host = ecard_get_drvdata(ec);
1da177e4 LT	319
	320	ecard_set_drvdata(ec, NULL);
	321	fas216_remove(host);
	322
1da177e4 LT	323	fas216_release(host);
	324	scsi_host_put(host);
	325	ecard_release_resources(ec);
	326	}
	327
	328	static const struct ecard_id arxescsi_cids[] = {
	329	{ MANU_ARXE, PROD_ARXE_SCSI },
	330	{ 0xffff, 0xffff },
	331	};
	332
	333	static struct ecard_driver arxescsi_driver = {
	334	.probe = arxescsi_probe,
6f039790	335	.remove = arxescsi_remove,
1da177e4 LT	336	.id_table = arxescsi_cids,
	337	.drv = {
	338	.name = "arxescsi",
	339	},
	340	};
	341
	342	static int __init init_arxe_scsi_driver(void)
	343	{
	344	return ecard_register_driver(&arxescsi_driver);
	345	}
	346
	347	static void __exit exit_arxe_scsi_driver(void)
	348	{
	349	ecard_remove_driver(&arxescsi_driver);
	350	}
	351
	352	module_init(init_arxe_scsi_driver);
	353	module_exit(exit_arxe_scsi_driver);
	354
	355	MODULE_AUTHOR("Stefan Hanske");
	356	MODULE_DESCRIPTION("ARXESCSI driver for Acorn machines");
	357	MODULE_LICENSE("GPL");
	358