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