imm.c revision 7259f0d05d595b73ef312a082e628627c6414969 
1/* imm.c   --  low level driver for the IOMEGA MatchMaker
2 * parallel port SCSI host adapter.
3 *
4 * (The IMM is the embedded controller in the ZIP Plus drive.)
5 *
6 * My unoffical company acronym list is 21 pages long:
7 *      FLA:    Four letter acronym with built in facility for
8 *              future expansion to five letters.
9 */
10
11#include <linux/init.h>
12#include <linux/kernel.h>
13#include <linux/module.h>
14#include <linux/blkdev.h>
15#include <linux/parport.h>
16#include <linux/workqueue.h>
17#include <linux/delay.h>
18#include <asm/io.h>
19
20#include <scsi/scsi.h>
21#include <scsi/scsi_cmnd.h>
22#include <scsi/scsi_device.h>
23#include <scsi/scsi_host.h>
24
25/* The following #define is to avoid a clash with hosts.c */
26#define IMM_PROBE_SPP   0x0001
27#define IMM_PROBE_PS2   0x0002
28#define IMM_PROBE_ECR   0x0010
29#define IMM_PROBE_EPP17 0x0100
30#define IMM_PROBE_EPP19 0x0200
31
32
33typedef struct {
34	struct pardevice *dev;	/* Parport device entry         */
35	int base;		/* Actual port address          */
36	int base_hi;		/* Hi Base address for ECP-ISA chipset */
37	int mode;		/* Transfer mode                */
38	struct scsi_cmnd *cur_cmd;	/* Current queued command       */
39	struct work_struct imm_tq;	/* Polling interrupt stuff       */
40	unsigned long jstart;	/* Jiffies at start             */
41	unsigned failed:1;	/* Failure flag                 */
42	unsigned dp:1;		/* Data phase present           */
43	unsigned rd:1;		/* Read data in data phase      */
44	unsigned wanted:1;	/* Parport sharing busy flag    */
45	wait_queue_head_t *waiting;
46	struct Scsi_Host *host;
47	struct list_head list;
48} imm_struct;
49
50static void imm_reset_pulse(unsigned int base);
51static int device_check(imm_struct *dev);
52
53#include "imm.h"
54
55static inline imm_struct *imm_dev(struct Scsi_Host *host)
56{
57	return *(imm_struct **)&host->hostdata;
58}
59
60static DEFINE_SPINLOCK(arbitration_lock);
61
62static void got_it(imm_struct *dev)
63{
64	dev->base = dev->dev->port->base;
65	if (dev->cur_cmd)
66		dev->cur_cmd->SCp.phase = 1;
67	else
68		wake_up(dev->waiting);
69}
70
71static void imm_wakeup(void *ref)
72{
73	imm_struct *dev = (imm_struct *) ref;
74	unsigned long flags;
75
76	spin_lock_irqsave(&arbitration_lock, flags);
77	if (dev->wanted) {
78		parport_claim(dev->dev);
79		got_it(dev);
80		dev->wanted = 0;
81	}
82	spin_unlock_irqrestore(&arbitration_lock, flags);
83}
84
85static int imm_pb_claim(imm_struct *dev)
86{
87	unsigned long flags;
88	int res = 1;
89	spin_lock_irqsave(&arbitration_lock, flags);
90	if (parport_claim(dev->dev) == 0) {
91		got_it(dev);
92		res = 0;
93	}
94	dev->wanted = res;
95	spin_unlock_irqrestore(&arbitration_lock, flags);
96	return res;
97}
98
99static void imm_pb_dismiss(imm_struct *dev)
100{
101	unsigned long flags;
102	int wanted;
103	spin_lock_irqsave(&arbitration_lock, flags);
104	wanted = dev->wanted;
105	dev->wanted = 0;
106	spin_unlock_irqrestore(&arbitration_lock, flags);
107	if (!wanted)
108		parport_release(dev->dev);
109}
110
111static inline void imm_pb_release(imm_struct *dev)
112{
113	parport_release(dev->dev);
114}
115
116/* This is to give the imm driver a way to modify the timings (and other
117 * parameters) by writing to the /proc/scsi/imm/0 file.
118 * Very simple method really... (Too simple, no error checking :( )
119 * Reason: Kernel hackers HATE having to unload and reload modules for
120 * testing...
121 * Also gives a method to use a script to obtain optimum timings (TODO)
122 */
123static inline int imm_proc_write(imm_struct *dev, char *buffer, int length)
124{
125	unsigned long x;
126
127	if ((length > 5) && (strncmp(buffer, "mode=", 5) == 0)) {
128		x = simple_strtoul(buffer + 5, NULL, 0);
129		dev->mode = x;
130		return length;
131	}
132	printk("imm /proc: invalid variable\n");
133	return (-EINVAL);
134}
135
136static int imm_proc_info(struct Scsi_Host *host, char *buffer, char **start,
137			off_t offset, int length, int inout)
138{
139	imm_struct *dev = imm_dev(host);
140	int len = 0;
141
142	if (inout)
143		return imm_proc_write(dev, buffer, length);
144
145	len += sprintf(buffer + len, "Version : %s\n", IMM_VERSION);
146	len +=
147	    sprintf(buffer + len, "Parport : %s\n",
148		    dev->dev->port->name);
149	len +=
150	    sprintf(buffer + len, "Mode    : %s\n",
151		    IMM_MODE_STRING[dev->mode]);
152
153	/* Request for beyond end of buffer */
154	if (offset > len)
155		return 0;
156
157	*start = buffer + offset;
158	len -= offset;
159	if (len > length)
160		len = length;
161	return len;
162}
163
164#if IMM_DEBUG > 0
165#define imm_fail(x,y) printk("imm: imm_fail(%i) from %s at line %d\n",\
166	   y, __FUNCTION__, __LINE__); imm_fail_func(x,y);
167static inline void
168imm_fail_func(imm_struct *dev, int error_code)
169#else
170static inline void
171imm_fail(imm_struct *dev, int error_code)
172#endif
173{
174	/* If we fail a device then we trash status / message bytes */
175	if (dev->cur_cmd) {
176		dev->cur_cmd->result = error_code << 16;
177		dev->failed = 1;
178	}
179}
180
181/*
182 * Wait for the high bit to be set.
183 *
184 * In principle, this could be tied to an interrupt, but the adapter
185 * doesn't appear to be designed to support interrupts.  We spin on
186 * the 0x80 ready bit.
187 */
188static unsigned char imm_wait(imm_struct *dev)
189{
190	int k;
191	unsigned short ppb = dev->base;
192	unsigned char r;
193
194	w_ctr(ppb, 0x0c);
195
196	k = IMM_SPIN_TMO;
197	do {
198		r = r_str(ppb);
199		k--;
200		udelay(1);
201	}
202	while (!(r & 0x80) && (k));
203
204	/*
205	 * STR register (LPT base+1) to SCSI mapping:
206	 *
207	 * STR      imm     imm
208	 * ===================================
209	 * 0x80     S_REQ   S_REQ
210	 * 0x40     !S_BSY  (????)
211	 * 0x20     !S_CD   !S_CD
212	 * 0x10     !S_IO   !S_IO
213	 * 0x08     (????)  !S_BSY
214	 *
215	 * imm      imm     meaning
216	 * ==================================
217	 * 0xf0     0xb8    Bit mask
218	 * 0xc0     0x88    ZIP wants more data
219	 * 0xd0     0x98    ZIP wants to send more data
220	 * 0xe0     0xa8    ZIP is expecting SCSI command data
221	 * 0xf0     0xb8    end of transfer, ZIP is sending status
222	 */
223	w_ctr(ppb, 0x04);
224	if (k)
225		return (r & 0xb8);
226
227	/* Counter expired - Time out occurred */
228	imm_fail(dev, DID_TIME_OUT);
229	printk("imm timeout in imm_wait\n");
230	return 0;		/* command timed out */
231}
232
233static int imm_negotiate(imm_struct * tmp)
234{
235	/*
236	 * The following is supposedly the IEEE 1284-1994 negotiate
237	 * sequence. I have yet to obtain a copy of the above standard
238	 * so this is a bit of a guess...
239	 *
240	 * A fair chunk of this is based on the Linux parport implementation
241	 * of IEEE 1284.
242	 *
243	 * Return 0 if data available
244	 *        1 if no data available
245	 */
246
247	unsigned short base = tmp->base;
248	unsigned char a, mode;
249
250	switch (tmp->mode) {
251	case IMM_NIBBLE:
252		mode = 0x00;
253		break;
254	case IMM_PS2:
255		mode = 0x01;
256		break;
257	default:
258		return 0;
259	}
260
261	w_ctr(base, 0x04);
262	udelay(5);
263	w_dtr(base, mode);
264	udelay(100);
265	w_ctr(base, 0x06);
266	udelay(5);
267	a = (r_str(base) & 0x20) ? 0 : 1;
268	udelay(5);
269	w_ctr(base, 0x07);
270	udelay(5);
271	w_ctr(base, 0x06);
272
273	if (a) {
274		printk
275		    ("IMM: IEEE1284 negotiate indicates no data available.\n");
276		imm_fail(tmp, DID_ERROR);
277	}
278	return a;
279}
280
281/*
282 * Clear EPP timeout bit.
283 */
284static inline void epp_reset(unsigned short ppb)
285{
286	int i;
287
288	i = r_str(ppb);
289	w_str(ppb, i);
290	w_str(ppb, i & 0xfe);
291}
292
293/*
294 * Wait for empty ECP fifo (if we are in ECP fifo mode only)
295 */
296static inline void ecp_sync(imm_struct *dev)
297{
298	int i, ppb_hi = dev->base_hi;
299
300	if (ppb_hi == 0)
301		return;
302
303	if ((r_ecr(ppb_hi) & 0xe0) == 0x60) {	/* mode 011 == ECP fifo mode */
304		for (i = 0; i < 100; i++) {
305			if (r_ecr(ppb_hi) & 0x01)
306				return;
307			udelay(5);
308		}
309		printk("imm: ECP sync failed as data still present in FIFO.\n");
310	}
311}
312
313static int imm_byte_out(unsigned short base, const char *buffer, int len)
314{
315	int i;
316
317	w_ctr(base, 0x4);	/* apparently a sane mode */
318	for (i = len >> 1; i; i--) {
319		w_dtr(base, *buffer++);
320		w_ctr(base, 0x5);	/* Drop STROBE low */
321		w_dtr(base, *buffer++);
322		w_ctr(base, 0x0);	/* STROBE high + INIT low */
323	}
324	w_ctr(base, 0x4);	/* apparently a sane mode */
325	return 1;		/* All went well - we hope! */
326}
327
328static int imm_nibble_in(unsigned short base, char *buffer, int len)
329{
330	unsigned char l;
331	int i;
332
333	/*
334	 * The following is based on documented timing signals
335	 */
336	w_ctr(base, 0x4);
337	for (i = len; i; i--) {
338		w_ctr(base, 0x6);
339		l = (r_str(base) & 0xf0) >> 4;
340		w_ctr(base, 0x5);
341		*buffer++ = (r_str(base) & 0xf0) | l;
342		w_ctr(base, 0x4);
343	}
344	return 1;		/* All went well - we hope! */
345}
346
347static int imm_byte_in(unsigned short base, char *buffer, int len)
348{
349	int i;
350
351	/*
352	 * The following is based on documented timing signals
353	 */
354	w_ctr(base, 0x4);
355	for (i = len; i; i--) {
356		w_ctr(base, 0x26);
357		*buffer++ = r_dtr(base);
358		w_ctr(base, 0x25);
359	}
360	return 1;		/* All went well - we hope! */
361}
362
363static int imm_out(imm_struct *dev, char *buffer, int len)
364{
365	unsigned short ppb = dev->base;
366	int r = imm_wait(dev);
367
368	/*
369	 * Make sure that:
370	 * a) the SCSI bus is BUSY (device still listening)
371	 * b) the device is listening
372	 */
373	if ((r & 0x18) != 0x08) {
374		imm_fail(dev, DID_ERROR);
375		printk("IMM: returned SCSI status %2x\n", r);
376		return 0;
377	}
378	switch (dev->mode) {
379	case IMM_EPP_32:
380	case IMM_EPP_16:
381	case IMM_EPP_8:
382		epp_reset(ppb);
383		w_ctr(ppb, 0x4);
384#ifdef CONFIG_SCSI_IZIP_EPP16
385		if (!(((long) buffer | len) & 0x01))
386			outsw(ppb + 4, buffer, len >> 1);
387#else
388		if (!(((long) buffer | len) & 0x03))
389			outsl(ppb + 4, buffer, len >> 2);
390#endif
391		else
392			outsb(ppb + 4, buffer, len);
393		w_ctr(ppb, 0xc);
394		r = !(r_str(ppb) & 0x01);
395		w_ctr(ppb, 0xc);
396		ecp_sync(dev);
397		break;
398
399	case IMM_NIBBLE:
400	case IMM_PS2:
401		/* 8 bit output, with a loop */
402		r = imm_byte_out(ppb, buffer, len);
403		break;
404
405	default:
406		printk("IMM: bug in imm_out()\n");
407		r = 0;
408	}
409	return r;
410}
411
412static int imm_in(imm_struct *dev, char *buffer, int len)
413{
414	unsigned short ppb = dev->base;
415	int r = imm_wait(dev);
416
417	/*
418	 * Make sure that:
419	 * a) the SCSI bus is BUSY (device still listening)
420	 * b) the device is sending data
421	 */
422	if ((r & 0x18) != 0x18) {
423		imm_fail(dev, DID_ERROR);
424		return 0;
425	}
426	switch (dev->mode) {
427	case IMM_NIBBLE:
428		/* 4 bit input, with a loop */
429		r = imm_nibble_in(ppb, buffer, len);
430		w_ctr(ppb, 0xc);
431		break;
432
433	case IMM_PS2:
434		/* 8 bit input, with a loop */
435		r = imm_byte_in(ppb, buffer, len);
436		w_ctr(ppb, 0xc);
437		break;
438
439	case IMM_EPP_32:
440	case IMM_EPP_16:
441	case IMM_EPP_8:
442		epp_reset(ppb);
443		w_ctr(ppb, 0x24);
444#ifdef CONFIG_SCSI_IZIP_EPP16
445		if (!(((long) buffer | len) & 0x01))
446			insw(ppb + 4, buffer, len >> 1);
447#else
448		if (!(((long) buffer | len) & 0x03))
449			insl(ppb + 4, buffer, len >> 2);
450#endif
451		else
452			insb(ppb + 4, buffer, len);
453		w_ctr(ppb, 0x2c);
454		r = !(r_str(ppb) & 0x01);
455		w_ctr(ppb, 0x2c);
456		ecp_sync(dev);
457		break;
458
459	default:
460		printk("IMM: bug in imm_ins()\n");
461		r = 0;
462		break;
463	}
464	return r;
465}
466
467static int imm_cpp(unsigned short ppb, unsigned char b)
468{
469	/*
470	 * Comments on udelay values refer to the
471	 * Command Packet Protocol (CPP) timing diagram.
472	 */
473
474	unsigned char s1, s2, s3;
475	w_ctr(ppb, 0x0c);
476	udelay(2);		/* 1 usec - infinite */
477	w_dtr(ppb, 0xaa);
478	udelay(10);		/* 7 usec - infinite */
479	w_dtr(ppb, 0x55);
480	udelay(10);		/* 7 usec - infinite */
481	w_dtr(ppb, 0x00);
482	udelay(10);		/* 7 usec - infinite */
483	w_dtr(ppb, 0xff);
484	udelay(10);		/* 7 usec - infinite */
485	s1 = r_str(ppb) & 0xb8;
486	w_dtr(ppb, 0x87);
487	udelay(10);		/* 7 usec - infinite */
488	s2 = r_str(ppb) & 0xb8;
489	w_dtr(ppb, 0x78);
490	udelay(10);		/* 7 usec - infinite */
491	s3 = r_str(ppb) & 0x38;
492	/*
493	 * Values for b are:
494	 * 0000 00aa    Assign address aa to current device
495	 * 0010 00aa    Select device aa in EPP Winbond mode
496	 * 0010 10aa    Select device aa in EPP mode
497	 * 0011 xxxx    Deselect all devices
498	 * 0110 00aa    Test device aa
499	 * 1101 00aa    Select device aa in ECP mode
500	 * 1110 00aa    Select device aa in Compatible mode
501	 */
502	w_dtr(ppb, b);
503	udelay(2);		/* 1 usec - infinite */
504	w_ctr(ppb, 0x0c);
505	udelay(10);		/* 7 usec - infinite */
506	w_ctr(ppb, 0x0d);
507	udelay(2);		/* 1 usec - infinite */
508	w_ctr(ppb, 0x0c);
509	udelay(10);		/* 7 usec - infinite */
510	w_dtr(ppb, 0xff);
511	udelay(10);		/* 7 usec - infinite */
512
513	/*
514	 * The following table is electrical pin values.
515	 * (BSY is inverted at the CTR register)
516	 *
517	 *       BSY  ACK  POut SEL  Fault
518	 * S1    0    X    1    1    1
519	 * S2    1    X    0    1    1
520	 * S3    L    X    1    1    S
521	 *
522	 * L => Last device in chain
523	 * S => Selected
524	 *
525	 * Observered values for S1,S2,S3 are:
526	 * Disconnect => f8/58/78
527	 * Connect    => f8/58/70
528	 */
529	if ((s1 == 0xb8) && (s2 == 0x18) && (s3 == 0x30))
530		return 1;	/* Connected */
531	if ((s1 == 0xb8) && (s2 == 0x18) && (s3 == 0x38))
532		return 0;	/* Disconnected */
533
534	return -1;		/* No device present */
535}
536
537static inline int imm_connect(imm_struct *dev, int flag)
538{
539	unsigned short ppb = dev->base;
540
541	imm_cpp(ppb, 0xe0);	/* Select device 0 in compatible mode */
542	imm_cpp(ppb, 0x30);	/* Disconnect all devices */
543
544	if ((dev->mode == IMM_EPP_8) ||
545	    (dev->mode == IMM_EPP_16) ||
546	    (dev->mode == IMM_EPP_32))
547		return imm_cpp(ppb, 0x28);	/* Select device 0 in EPP mode */
548	return imm_cpp(ppb, 0xe0);	/* Select device 0 in compatible mode */
549}
550
551static void imm_disconnect(imm_struct *dev)
552{
553	imm_cpp(dev->base, 0x30);	/* Disconnect all devices */
554}
555
556static int imm_select(imm_struct *dev, int target)
557{
558	int k;
559	unsigned short ppb = dev->base;
560
561	/*
562	 * Firstly we want to make sure there is nothing
563	 * holding onto the SCSI bus.
564	 */
565	w_ctr(ppb, 0xc);
566
567	k = IMM_SELECT_TMO;
568	do {
569		k--;
570	} while ((r_str(ppb) & 0x08) && (k));
571
572	if (!k)
573		return 0;
574
575	/*
576	 * Now assert the SCSI ID (HOST and TARGET) on the data bus
577	 */
578	w_ctr(ppb, 0x4);
579	w_dtr(ppb, 0x80 | (1 << target));
580	udelay(1);
581
582	/*
583	 * Deassert SELIN first followed by STROBE
584	 */
585	w_ctr(ppb, 0xc);
586	w_ctr(ppb, 0xd);
587
588	/*
589	 * ACK should drop low while SELIN is deasserted.
590	 * FAULT should drop low when the SCSI device latches the bus.
591	 */
592	k = IMM_SELECT_TMO;
593	do {
594		k--;
595	}
596	while (!(r_str(ppb) & 0x08) && (k));
597
598	/*
599	 * Place the interface back into a sane state (status mode)
600	 */
601	w_ctr(ppb, 0xc);
602	return (k) ? 1 : 0;
603}
604
605static int imm_init(imm_struct *dev)
606{
607	if (imm_connect(dev, 0) != 1)
608		return -EIO;
609	imm_reset_pulse(dev->base);
610	mdelay(1);	/* Delay to allow devices to settle */
611	imm_disconnect(dev);
612	mdelay(1);	/* Another delay to allow devices to settle */
613	return device_check(dev);
614}
615
616static inline int imm_send_command(struct scsi_cmnd *cmd)
617{
618	imm_struct *dev = imm_dev(cmd->device->host);
619	int k;
620
621	/* NOTE: IMM uses byte pairs */
622	for (k = 0; k < cmd->cmd_len; k += 2)
623		if (!imm_out(dev, &cmd->cmnd[k], 2))
624			return 0;
625	return 1;
626}
627
628/*
629 * The bulk flag enables some optimisations in the data transfer loops,
630 * it should be true for any command that transfers data in integral
631 * numbers of sectors.
632 *
633 * The driver appears to remain stable if we speed up the parallel port
634 * i/o in this function, but not elsewhere.
635 */
636static int imm_completion(struct scsi_cmnd *cmd)
637{
638	/* Return codes:
639	 * -1     Error
640	 *  0     Told to schedule
641	 *  1     Finished data transfer
642	 */
643	imm_struct *dev = imm_dev(cmd->device->host);
644	unsigned short ppb = dev->base;
645	unsigned long start_jiffies = jiffies;
646
647	unsigned char r, v;
648	int fast, bulk, status;
649
650	v = cmd->cmnd[0];
651	bulk = ((v == READ_6) ||
652		(v == READ_10) || (v == WRITE_6) || (v == WRITE_10));
653
654	/*
655	 * We only get here if the drive is ready to comunicate,
656	 * hence no need for a full imm_wait.
657	 */
658	w_ctr(ppb, 0x0c);
659	r = (r_str(ppb) & 0xb8);
660
661	/*
662	 * while (device is not ready to send status byte)
663	 *     loop;
664	 */
665	while (r != (unsigned char) 0xb8) {
666		/*
667		 * If we have been running for more than a full timer tick
668		 * then take a rest.
669		 */
670		if (time_after(jiffies, start_jiffies + 1))
671			return 0;
672
673		/*
674		 * FAIL if:
675		 * a) Drive status is screwy (!ready && !present)
676		 * b) Drive is requesting/sending more data than expected
677		 */
678		if (((r & 0x88) != 0x88) || (cmd->SCp.this_residual <= 0)) {
679			imm_fail(dev, DID_ERROR);
680			return -1;	/* ERROR_RETURN */
681		}
682		/* determine if we should use burst I/O */
683		if (dev->rd == 0) {
684			fast = (bulk
685				&& (cmd->SCp.this_residual >=
686				    IMM_BURST_SIZE)) ? IMM_BURST_SIZE : 2;
687			status = imm_out(dev, cmd->SCp.ptr, fast);
688		} else {
689			fast = (bulk
690				&& (cmd->SCp.this_residual >=
691				    IMM_BURST_SIZE)) ? IMM_BURST_SIZE : 1;
692			status = imm_in(dev, cmd->SCp.ptr, fast);
693		}
694
695		cmd->SCp.ptr += fast;
696		cmd->SCp.this_residual -= fast;
697
698		if (!status) {
699			imm_fail(dev, DID_BUS_BUSY);
700			return -1;	/* ERROR_RETURN */
701		}
702		if (cmd->SCp.buffer && !cmd->SCp.this_residual) {
703			/* if scatter/gather, advance to the next segment */
704			if (cmd->SCp.buffers_residual--) {
705				cmd->SCp.buffer++;
706				cmd->SCp.this_residual =
707				    cmd->SCp.buffer->length;
708				cmd->SCp.ptr =
709				    page_address(cmd->SCp.buffer->page) +
710				    cmd->SCp.buffer->offset;
711
712				/*
713				 * Make sure that we transfer even number of bytes
714				 * otherwise it makes imm_byte_out() messy.
715				 */
716				if (cmd->SCp.this_residual & 0x01)
717					cmd->SCp.this_residual++;
718			}
719		}
720		/* Now check to see if the drive is ready to comunicate */
721		w_ctr(ppb, 0x0c);
722		r = (r_str(ppb) & 0xb8);
723
724		/* If not, drop back down to the scheduler and wait a timer tick */
725		if (!(r & 0x80))
726			return 0;
727	}
728	return 1;		/* FINISH_RETURN */
729}
730
731/*
732 * Since the IMM itself doesn't generate interrupts, we use
733 * the scheduler's task queue to generate a stream of call-backs and
734 * complete the request when the drive is ready.
735 */
736static void imm_interrupt(void *data)
737{
738	imm_struct *dev = (imm_struct *) data;
739	struct scsi_cmnd *cmd = dev->cur_cmd;
740	struct Scsi_Host *host = cmd->device->host;
741	unsigned long flags;
742
743	if (!cmd) {
744		printk("IMM: bug in imm_interrupt\n");
745		return;
746	}
747	if (imm_engine(dev, cmd)) {
748		INIT_WORK(&dev->imm_tq, imm_interrupt, (void *) dev);
749		schedule_delayed_work(&dev->imm_tq, 1);
750		return;
751	}
752	/* Command must of completed hence it is safe to let go... */
753#if IMM_DEBUG > 0
754	switch ((cmd->result >> 16) & 0xff) {
755	case DID_OK:
756		break;
757	case DID_NO_CONNECT:
758		printk("imm: no device at SCSI ID %i\n", cmd->device->id);
759		break;
760	case DID_BUS_BUSY:
761		printk("imm: BUS BUSY - EPP timeout detected\n");
762		break;
763	case DID_TIME_OUT:
764		printk("imm: unknown timeout\n");
765		break;
766	case DID_ABORT:
767		printk("imm: told to abort\n");
768		break;
769	case DID_PARITY:
770		printk("imm: parity error (???)\n");
771		break;
772	case DID_ERROR:
773		printk("imm: internal driver error\n");
774		break;
775	case DID_RESET:
776		printk("imm: told to reset device\n");
777		break;
778	case DID_BAD_INTR:
779		printk("imm: bad interrupt (???)\n");
780		break;
781	default:
782		printk("imm: bad return code (%02x)\n",
783		       (cmd->result >> 16) & 0xff);
784	}
785#endif
786
787	if (cmd->SCp.phase > 1)
788		imm_disconnect(dev);
789
790	imm_pb_dismiss(dev);
791
792	spin_lock_irqsave(host->host_lock, flags);
793	dev->cur_cmd = NULL;
794	cmd->scsi_done(cmd);
795	spin_unlock_irqrestore(host->host_lock, flags);
796	return;
797}
798
799static int imm_engine(imm_struct *dev, struct scsi_cmnd *cmd)
800{
801	unsigned short ppb = dev->base;
802	unsigned char l = 0, h = 0;
803	int retv, x;
804
805	/* First check for any errors that may have occurred
806	 * Here we check for internal errors
807	 */
808	if (dev->failed)
809		return 0;
810
811	switch (cmd->SCp.phase) {
812	case 0:		/* Phase 0 - Waiting for parport */
813		if (time_after(jiffies, dev->jstart + HZ)) {
814			/*
815			 * We waited more than a second
816			 * for parport to call us
817			 */
818			imm_fail(dev, DID_BUS_BUSY);
819			return 0;
820		}
821		return 1;	/* wait until imm_wakeup claims parport */
822		/* Phase 1 - Connected */
823	case 1:
824		imm_connect(dev, CONNECT_EPP_MAYBE);
825		cmd->SCp.phase++;
826
827		/* Phase 2 - We are now talking to the scsi bus */
828	case 2:
829		if (!imm_select(dev, scmd_id(cmd))) {
830			imm_fail(dev, DID_NO_CONNECT);
831			return 0;
832		}
833		cmd->SCp.phase++;
834
835		/* Phase 3 - Ready to accept a command */
836	case 3:
837		w_ctr(ppb, 0x0c);
838		if (!(r_str(ppb) & 0x80))
839			return 1;
840
841		if (!imm_send_command(cmd))
842			return 0;
843		cmd->SCp.phase++;
844
845		/* Phase 4 - Setup scatter/gather buffers */
846	case 4:
847		if (cmd->use_sg) {
848			/* if many buffers are available, start filling the first */
849			cmd->SCp.buffer =
850			    (struct scatterlist *) cmd->request_buffer;
851			cmd->SCp.this_residual = cmd->SCp.buffer->length;
852			cmd->SCp.ptr =
853			    page_address(cmd->SCp.buffer->page) +
854			    cmd->SCp.buffer->offset;
855		} else {
856			/* else fill the only available buffer */
857			cmd->SCp.buffer = NULL;
858			cmd->SCp.this_residual = cmd->request_bufflen;
859			cmd->SCp.ptr = cmd->request_buffer;
860		}
861		cmd->SCp.buffers_residual = cmd->use_sg - 1;
862		cmd->SCp.phase++;
863		if (cmd->SCp.this_residual & 0x01)
864			cmd->SCp.this_residual++;
865		/* Phase 5 - Pre-Data transfer stage */
866	case 5:
867		/* Spin lock for BUSY */
868		w_ctr(ppb, 0x0c);
869		if (!(r_str(ppb) & 0x80))
870			return 1;
871
872		/* Require negotiation for read requests */
873		x = (r_str(ppb) & 0xb8);
874		dev->rd = (x & 0x10) ? 1 : 0;
875		dev->dp = (x & 0x20) ? 0 : 1;
876
877		if ((dev->dp) && (dev->rd))
878			if (imm_negotiate(dev))
879				return 0;
880		cmd->SCp.phase++;
881
882		/* Phase 6 - Data transfer stage */
883	case 6:
884		/* Spin lock for BUSY */
885		w_ctr(ppb, 0x0c);
886		if (!(r_str(ppb) & 0x80))
887			return 1;
888
889		if (dev->dp) {
890			retv = imm_completion(cmd);
891			if (retv == -1)
892				return 0;
893			if (retv == 0)
894				return 1;
895		}
896		cmd->SCp.phase++;
897
898		/* Phase 7 - Post data transfer stage */
899	case 7:
900		if ((dev->dp) && (dev->rd)) {
901			if ((dev->mode == IMM_NIBBLE) || (dev->mode == IMM_PS2)) {
902				w_ctr(ppb, 0x4);
903				w_ctr(ppb, 0xc);
904				w_ctr(ppb, 0xe);
905				w_ctr(ppb, 0x4);
906			}
907		}
908		cmd->SCp.phase++;
909
910		/* Phase 8 - Read status/message */
911	case 8:
912		/* Check for data overrun */
913		if (imm_wait(dev) != (unsigned char) 0xb8) {
914			imm_fail(dev, DID_ERROR);
915			return 0;
916		}
917		if (imm_negotiate(dev))
918			return 0;
919		if (imm_in(dev, &l, 1)) {	/* read status byte */
920			/* Check for optional message byte */
921			if (imm_wait(dev) == (unsigned char) 0xb8)
922				imm_in(dev, &h, 1);
923			cmd->result = (DID_OK << 16) + (l & STATUS_MASK);
924		}
925		if ((dev->mode == IMM_NIBBLE) || (dev->mode == IMM_PS2)) {
926			w_ctr(ppb, 0x4);
927			w_ctr(ppb, 0xc);
928			w_ctr(ppb, 0xe);
929			w_ctr(ppb, 0x4);
930		}
931		return 0;	/* Finished */
932		break;
933
934	default:
935		printk("imm: Invalid scsi phase\n");
936	}
937	return 0;
938}
939
940static int imm_queuecommand(struct scsi_cmnd *cmd,
941		void (*done)(struct scsi_cmnd *))
942{
943	imm_struct *dev = imm_dev(cmd->device->host);
944
945	if (dev->cur_cmd) {
946		printk("IMM: bug in imm_queuecommand\n");
947		return 0;
948	}
949	dev->failed = 0;
950	dev->jstart = jiffies;
951	dev->cur_cmd = cmd;
952	cmd->scsi_done = done;
953	cmd->result = DID_ERROR << 16;	/* default return code */
954	cmd->SCp.phase = 0;	/* bus free */
955
956	INIT_WORK(&dev->imm_tq, imm_interrupt, dev);
957	schedule_work(&dev->imm_tq);
958
959	imm_pb_claim(dev);
960
961	return 0;
962}
963
964/*
965 * Apparently the disk->capacity attribute is off by 1 sector
966 * for all disk drives.  We add the one here, but it should really
967 * be done in sd.c.  Even if it gets fixed there, this will still
968 * work.
969 */
970static int imm_biosparam(struct scsi_device *sdev, struct block_device *dev,
971			 sector_t capacity, int ip[])
972{
973	ip[0] = 0x40;
974	ip[1] = 0x20;
975	ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);
976	if (ip[2] > 1024) {
977		ip[0] = 0xff;
978		ip[1] = 0x3f;
979		ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);
980	}
981	return 0;
982}
983
984static int imm_abort(struct scsi_cmnd *cmd)
985{
986	imm_struct *dev = imm_dev(cmd->device->host);
987	/*
988	 * There is no method for aborting commands since Iomega
989	 * have tied the SCSI_MESSAGE line high in the interface
990	 */
991
992	switch (cmd->SCp.phase) {
993	case 0:		/* Do not have access to parport */
994	case 1:		/* Have not connected to interface */
995		dev->cur_cmd = NULL;	/* Forget the problem */
996		return SUCCESS;
997		break;
998	default:		/* SCSI command sent, can not abort */
999		return FAILED;
1000		break;
1001	}
1002}
1003
1004static void imm_reset_pulse(unsigned int base)
1005{
1006	w_ctr(base, 0x04);
1007	w_dtr(base, 0x40);
1008	udelay(1);
1009	w_ctr(base, 0x0c);
1010	w_ctr(base, 0x0d);
1011	udelay(50);
1012	w_ctr(base, 0x0c);
1013	w_ctr(base, 0x04);
1014}
1015
1016static int imm_reset(struct scsi_cmnd *cmd)
1017{
1018	imm_struct *dev = imm_dev(cmd->device->host);
1019
1020	if (cmd->SCp.phase)
1021		imm_disconnect(dev);
1022	dev->cur_cmd = NULL;	/* Forget the problem */
1023
1024	imm_connect(dev, CONNECT_NORMAL);
1025	imm_reset_pulse(dev->base);
1026	mdelay(1);		/* device settle delay */
1027	imm_disconnect(dev);
1028	mdelay(1);		/* device settle delay */
1029	return SUCCESS;
1030}
1031
1032static int device_check(imm_struct *dev)
1033{
1034	/* This routine looks for a device and then attempts to use EPP
1035	   to send a command. If all goes as planned then EPP is available. */
1036
1037	static char cmd[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
1038	int loop, old_mode, status, k, ppb = dev->base;
1039	unsigned char l;
1040
1041	old_mode = dev->mode;
1042	for (loop = 0; loop < 8; loop++) {
1043		/* Attempt to use EPP for Test Unit Ready */
1044		if ((ppb & 0x0007) == 0x0000)
1045			dev->mode = IMM_EPP_32;
1046
1047	      second_pass:
1048		imm_connect(dev, CONNECT_EPP_MAYBE);
1049		/* Select SCSI device */
1050		if (!imm_select(dev, loop)) {
1051			imm_disconnect(dev);
1052			continue;
1053		}
1054		printk("imm: Found device at ID %i, Attempting to use %s\n",
1055		       loop, IMM_MODE_STRING[dev->mode]);
1056
1057		/* Send SCSI command */
1058		status = 1;
1059		w_ctr(ppb, 0x0c);
1060		for (l = 0; (l < 3) && (status); l++)
1061			status = imm_out(dev, &cmd[l << 1], 2);
1062
1063		if (!status) {
1064			imm_disconnect(dev);
1065			imm_connect(dev, CONNECT_EPP_MAYBE);
1066			imm_reset_pulse(dev->base);
1067			udelay(1000);
1068			imm_disconnect(dev);
1069			udelay(1000);
1070			if (dev->mode == IMM_EPP_32) {
1071				dev->mode = old_mode;
1072				goto second_pass;
1073			}
1074			printk("imm: Unable to establish communication\n");
1075			return -EIO;
1076		}
1077		w_ctr(ppb, 0x0c);
1078
1079		k = 1000000;	/* 1 Second */
1080		do {
1081			l = r_str(ppb);
1082			k--;
1083			udelay(1);
1084		} while (!(l & 0x80) && (k));
1085
1086		l &= 0xb8;
1087
1088		if (l != 0xb8) {
1089			imm_disconnect(dev);
1090			imm_connect(dev, CONNECT_EPP_MAYBE);
1091			imm_reset_pulse(dev->base);
1092			udelay(1000);
1093			imm_disconnect(dev);
1094			udelay(1000);
1095			if (dev->mode == IMM_EPP_32) {
1096				dev->mode = old_mode;
1097				goto second_pass;
1098			}
1099			printk
1100			    ("imm: Unable to establish communication\n");
1101			return -EIO;
1102		}
1103		imm_disconnect(dev);
1104		printk
1105		    ("imm: Communication established at 0x%x with ID %i using %s\n",
1106		     ppb, loop, IMM_MODE_STRING[dev->mode]);
1107		imm_connect(dev, CONNECT_EPP_MAYBE);
1108		imm_reset_pulse(dev->base);
1109		udelay(1000);
1110		imm_disconnect(dev);
1111		udelay(1000);
1112		return 0;
1113	}
1114	printk("imm: No devices found\n");
1115	return -ENODEV;
1116}
1117
1118/*
1119 * imm cannot deal with highmem, so this causes all IO pages for this host
1120 * to reside in low memory (hence mapped)
1121 */
1122static int imm_adjust_queue(struct scsi_device *device)
1123{
1124	blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
1125	return 0;
1126}
1127
1128static struct scsi_host_template imm_template = {
1129	.module			= THIS_MODULE,
1130	.proc_name		= "imm",
1131	.proc_info		= imm_proc_info,
1132	.name			= "Iomega VPI2 (imm) interface",
1133	.queuecommand		= imm_queuecommand,
1134	.eh_abort_handler	= imm_abort,
1135	.eh_bus_reset_handler	= imm_reset,
1136	.eh_host_reset_handler	= imm_reset,
1137	.bios_param		= imm_biosparam,
1138	.this_id		= 7,
1139	.sg_tablesize		= SG_ALL,
1140	.cmd_per_lun		= 1,
1141	.use_clustering		= ENABLE_CLUSTERING,
1142	.can_queue		= 1,
1143	.slave_alloc		= imm_adjust_queue,
1144};
1145
1146/***************************************************************************
1147 *                   Parallel port probing routines                        *
1148 ***************************************************************************/
1149
1150static LIST_HEAD(imm_hosts);
1151
1152static int __imm_attach(struct parport *pb)
1153{
1154	struct Scsi_Host *host;
1155	imm_struct *dev;
1156	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waiting);
1157	DEFINE_WAIT(wait);
1158	int ports;
1159	int modes, ppb;
1160	int err = -ENOMEM;
1161
1162	init_waitqueue_head(&waiting);
1163
1164	dev = kmalloc(sizeof(imm_struct), GFP_KERNEL);
1165	if (!dev)
1166		return -ENOMEM;
1167
1168	memset(dev, 0, sizeof(imm_struct));
1169
1170	dev->base = -1;
1171	dev->mode = IMM_AUTODETECT;
1172	INIT_LIST_HEAD(&dev->list);
1173
1174	dev->dev = parport_register_device(pb, "imm", NULL, imm_wakeup,
1175						NULL, 0, dev);
1176
1177	if (!dev->dev)
1178		goto out;
1179
1180
1181	/* Claim the bus so it remembers what we do to the control
1182	 * registers. [ CTR and ECP ]
1183	 */
1184	err = -EBUSY;
1185	dev->waiting = &waiting;
1186	prepare_to_wait(&waiting, &wait, TASK_UNINTERRUPTIBLE);
1187	if (imm_pb_claim(dev))
1188		schedule_timeout(3 * HZ);
1189	if (dev->wanted) {
1190		printk(KERN_ERR "imm%d: failed to claim parport because "
1191			"a pardevice is owning the port for too long "
1192			"time!\n", pb->number);
1193		imm_pb_dismiss(dev);
1194		dev->waiting = NULL;
1195		finish_wait(&waiting, &wait);
1196		goto out1;
1197	}
1198	dev->waiting = NULL;
1199	finish_wait(&waiting, &wait);
1200	ppb = dev->base = dev->dev->port->base;
1201	dev->base_hi = dev->dev->port->base_hi;
1202	w_ctr(ppb, 0x0c);
1203	modes = dev->dev->port->modes;
1204
1205	/* Mode detection works up the chain of speed
1206	 * This avoids a nasty if-then-else-if-... tree
1207	 */
1208	dev->mode = IMM_NIBBLE;
1209
1210	if (modes & PARPORT_MODE_TRISTATE)
1211		dev->mode = IMM_PS2;
1212
1213	/* Done configuration */
1214
1215	err = imm_init(dev);
1216
1217	imm_pb_release(dev);
1218
1219	if (err)
1220		goto out1;
1221
1222	/* now the glue ... */
1223	if (dev->mode == IMM_NIBBLE || dev->mode == IMM_PS2)
1224		ports = 3;
1225	else
1226		ports = 8;
1227
1228	INIT_WORK(&dev->imm_tq, imm_interrupt, dev);
1229
1230	err = -ENOMEM;
1231	host = scsi_host_alloc(&imm_template, sizeof(imm_struct *));
1232	if (!host)
1233		goto out1;
1234	host->io_port = pb->base;
1235	host->n_io_port = ports;
1236	host->dma_channel = -1;
1237	host->unique_id = pb->number;
1238	*(imm_struct **)&host->hostdata = dev;
1239	dev->host = host;
1240	list_add_tail(&dev->list, &imm_hosts);
1241	err = scsi_add_host(host, NULL);
1242	if (err)
1243		goto out2;
1244	scsi_scan_host(host);
1245	return 0;
1246
1247out2:
1248	list_del_init(&dev->list);
1249	scsi_host_put(host);
1250out1:
1251	parport_unregister_device(dev->dev);
1252out:
1253	kfree(dev);
1254	return err;
1255}
1256
1257static void imm_attach(struct parport *pb)
1258{
1259	__imm_attach(pb);
1260}
1261
1262static void imm_detach(struct parport *pb)
1263{
1264	imm_struct *dev;
1265	list_for_each_entry(dev, &imm_hosts, list) {
1266		if (dev->dev->port == pb) {
1267			list_del_init(&dev->list);
1268			scsi_remove_host(dev->host);
1269			scsi_host_put(dev->host);
1270			parport_unregister_device(dev->dev);
1271			kfree(dev);
1272			break;
1273		}
1274	}
1275}
1276
1277static struct parport_driver imm_driver = {
1278	.name	= "imm",
1279	.attach	= imm_attach,
1280	.detach	= imm_detach,
1281};
1282
1283static int __init imm_driver_init(void)
1284{
1285	printk("imm: Version %s\n", IMM_VERSION);
1286	return parport_register_driver(&imm_driver);
1287}
1288
1289static void __exit imm_driver_exit(void)
1290{
1291	parport_unregister_driver(&imm_driver);
1292}
1293
1294module_init(imm_driver_init);
1295module_exit(imm_driver_exit);
1296
1297MODULE_LICENSE("GPL");
1298