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 delayed_work 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	w_dtr(ppb, b);
493	udelay(2);		/* 1 usec - infinite */
494	w_ctr(ppb, 0x0c);
495	udelay(10);		/* 7 usec - infinite */
496	w_ctr(ppb, 0x0d);
497	udelay(2);		/* 1 usec - infinite */
498	w_ctr(ppb, 0x0c);
499	udelay(10);		/* 7 usec - infinite */
500	w_dtr(ppb, 0xff);
501	udelay(10);		/* 7 usec - infinite */
502
503	/*
504	 * The following table is electrical pin values.
505	 * (BSY is inverted at the CTR register)
506	 *
507	 *       BSY  ACK  POut SEL  Fault
508	 * S1    0    X    1    1    1
509	 * S2    1    X    0    1    1
510	 * S3    L    X    1    1    S
511	 *
512	 * L => Last device in chain
513	 * S => Selected
514	 *
515	 * Observered values for S1,S2,S3 are:
516	 * Disconnect => f8/58/78
517	 * Connect    => f8/58/70
518	 */
519	if ((s1 == 0xb8) && (s2 == 0x18) && (s3 == 0x30))
520		return 1;	/* Connected */
521	if ((s1 == 0xb8) && (s2 == 0x18) && (s3 == 0x38))
522		return 0;	/* Disconnected */
523
524	return -1;		/* No device present */
525}
526
527static inline int imm_connect(imm_struct *dev, int flag)
528{
529	unsigned short ppb = dev->base;
530
531	imm_cpp(ppb, 0xe0);	/* Select device 0 in compatible mode */
532	imm_cpp(ppb, 0x30);	/* Disconnect all devices */
533
534	if ((dev->mode == IMM_EPP_8) ||
535	    (dev->mode == IMM_EPP_16) ||
536	    (dev->mode == IMM_EPP_32))
537		return imm_cpp(ppb, 0x28);	/* Select device 0 in EPP mode */
538	return imm_cpp(ppb, 0xe0);	/* Select device 0 in compatible mode */
539}
540
541static void imm_disconnect(imm_struct *dev)
542{
543	imm_cpp(dev->base, 0x30);	/* Disconnect all devices */
544}
545
546static int imm_select(imm_struct *dev, int target)
547{
548	int k;
549	unsigned short ppb = dev->base;
550
551	/*
552	 * Firstly we want to make sure there is nothing
553	 * holding onto the SCSI bus.
554	 */
555	w_ctr(ppb, 0xc);
556
557	k = IMM_SELECT_TMO;
558	do {
559		k--;
560	} while ((r_str(ppb) & 0x08) && (k));
561
562	if (!k)
563		return 0;
564
565	/*
566	 * Now assert the SCSI ID (HOST and TARGET) on the data bus
567	 */
568	w_ctr(ppb, 0x4);
569	w_dtr(ppb, 0x80 | (1 << target));
570	udelay(1);
571
572	/*
573	 * Deassert SELIN first followed by STROBE
574	 */
575	w_ctr(ppb, 0xc);
576	w_ctr(ppb, 0xd);
577
578	/*
579	 * ACK should drop low while SELIN is deasserted.
580	 * FAULT should drop low when the SCSI device latches the bus.
581	 */
582	k = IMM_SELECT_TMO;
583	do {
584		k--;
585	}
586	while (!(r_str(ppb) & 0x08) && (k));
587
588	/*
589	 * Place the interface back into a sane state (status mode)
590	 */
591	w_ctr(ppb, 0xc);
592	return (k) ? 1 : 0;
593}
594
595static int imm_init(imm_struct *dev)
596{
597	if (imm_connect(dev, 0) != 1)
598		return -EIO;
599	imm_reset_pulse(dev->base);
600	mdelay(1);	/* Delay to allow devices to settle */
601	imm_disconnect(dev);
602	mdelay(1);	/* Another delay to allow devices to settle */
603	return device_check(dev);
604}
605
606static inline int imm_send_command(struct scsi_cmnd *cmd)
607{
608	imm_struct *dev = imm_dev(cmd->device->host);
609	int k;
610
611	/* NOTE: IMM uses byte pairs */
612	for (k = 0; k < cmd->cmd_len; k += 2)
613		if (!imm_out(dev, &cmd->cmnd[k], 2))
614			return 0;
615	return 1;
616}
617
618/*
619 * The bulk flag enables some optimisations in the data transfer loops,
620 * it should be true for any command that transfers data in integral
621 * numbers of sectors.
622 *
623 * The driver appears to remain stable if we speed up the parallel port
624 * i/o in this function, but not elsewhere.
625 */
626static int imm_completion(struct scsi_cmnd *cmd)
627{
628	/* Return codes:
629	 * -1     Error
630	 *  0     Told to schedule
631	 *  1     Finished data transfer
632	 */
633	imm_struct *dev = imm_dev(cmd->device->host);
634	unsigned short ppb = dev->base;
635	unsigned long start_jiffies = jiffies;
636
637	unsigned char r, v;
638	int fast, bulk, status;
639
640	v = cmd->cmnd[0];
641	bulk = ((v == READ_6) ||
642		(v == READ_10) || (v == WRITE_6) || (v == WRITE_10));
643
644	/*
645	 * We only get here if the drive is ready to comunicate,
646	 * hence no need for a full imm_wait.
647	 */
648	w_ctr(ppb, 0x0c);
649	r = (r_str(ppb) & 0xb8);
650
651	/*
652	 * while (device is not ready to send status byte)
653	 *     loop;
654	 */
655	while (r != (unsigned char) 0xb8) {
656		/*
657		 * If we have been running for more than a full timer tick
658		 * then take a rest.
659		 */
660		if (time_after(jiffies, start_jiffies + 1))
661			return 0;
662
663		/*
664		 * FAIL if:
665		 * a) Drive status is screwy (!ready && !present)
666		 * b) Drive is requesting/sending more data than expected
667		 */
668		if (((r & 0x88) != 0x88) || (cmd->SCp.this_residual <= 0)) {
669			imm_fail(dev, DID_ERROR);
670			return -1;	/* ERROR_RETURN */
671		}
672		/* determine if we should use burst I/O */
673		if (dev->rd == 0) {
674			fast = (bulk
675				&& (cmd->SCp.this_residual >=
676				    IMM_BURST_SIZE)) ? IMM_BURST_SIZE : 2;
677			status = imm_out(dev, cmd->SCp.ptr, fast);
678		} else {
679			fast = (bulk
680				&& (cmd->SCp.this_residual >=
681				    IMM_BURST_SIZE)) ? IMM_BURST_SIZE : 1;
682			status = imm_in(dev, cmd->SCp.ptr, fast);
683		}
684
685		cmd->SCp.ptr += fast;
686		cmd->SCp.this_residual -= fast;
687
688		if (!status) {
689			imm_fail(dev, DID_BUS_BUSY);
690			return -1;	/* ERROR_RETURN */
691		}
692		if (cmd->SCp.buffer && !cmd->SCp.this_residual) {
693			/* if scatter/gather, advance to the next segment */
694			if (cmd->SCp.buffers_residual--) {
695				cmd->SCp.buffer++;
696				cmd->SCp.this_residual =
697				    cmd->SCp.buffer->length;
698				cmd->SCp.ptr =
699				    page_address(cmd->SCp.buffer->page) +
700				    cmd->SCp.buffer->offset;
701
702				/*
703				 * Make sure that we transfer even number of bytes
704				 * otherwise it makes imm_byte_out() messy.
705				 */
706				if (cmd->SCp.this_residual & 0x01)
707					cmd->SCp.this_residual++;
708			}
709		}
710		/* Now check to see if the drive is ready to comunicate */
711		w_ctr(ppb, 0x0c);
712		r = (r_str(ppb) & 0xb8);
713
714		/* If not, drop back down to the scheduler and wait a timer tick */
715		if (!(r & 0x80))
716			return 0;
717	}
718	return 1;		/* FINISH_RETURN */
719}
720
721/*
722 * Since the IMM itself doesn't generate interrupts, we use
723 * the scheduler's task queue to generate a stream of call-backs and
724 * complete the request when the drive is ready.
725 */
726static void imm_interrupt(struct work_struct *work)
727{
728	imm_struct *dev = container_of(work, imm_struct, imm_tq.work);
729	struct scsi_cmnd *cmd = dev->cur_cmd;
730	struct Scsi_Host *host = cmd->device->host;
731	unsigned long flags;
732
733	if (!cmd) {
734		printk("IMM: bug in imm_interrupt\n");
735		return;
736	}
737	if (imm_engine(dev, cmd)) {
738		schedule_delayed_work(&dev->imm_tq, 1);
739		return;
740	}
741	/* Command must of completed hence it is safe to let go... */
742#if IMM_DEBUG > 0
743	switch ((cmd->result >> 16) & 0xff) {
744	case DID_OK:
745		break;
746	case DID_NO_CONNECT:
747		printk("imm: no device at SCSI ID %i\n", cmd->device->id);
748		break;
749	case DID_BUS_BUSY:
750		printk("imm: BUS BUSY - EPP timeout detected\n");
751		break;
752	case DID_TIME_OUT:
753		printk("imm: unknown timeout\n");
754		break;
755	case DID_ABORT:
756		printk("imm: told to abort\n");
757		break;
758	case DID_PARITY:
759		printk("imm: parity error (???)\n");
760		break;
761	case DID_ERROR:
762		printk("imm: internal driver error\n");
763		break;
764	case DID_RESET:
765		printk("imm: told to reset device\n");
766		break;
767	case DID_BAD_INTR:
768		printk("imm: bad interrupt (???)\n");
769		break;
770	default:
771		printk("imm: bad return code (%02x)\n",
772		       (cmd->result >> 16) & 0xff);
773	}
774#endif
775
776	if (cmd->SCp.phase > 1)
777		imm_disconnect(dev);
778
779	imm_pb_dismiss(dev);
780
781	spin_lock_irqsave(host->host_lock, flags);
782	dev->cur_cmd = NULL;
783	cmd->scsi_done(cmd);
784	spin_unlock_irqrestore(host->host_lock, flags);
785	return;
786}
787
788static int imm_engine(imm_struct *dev, struct scsi_cmnd *cmd)
789{
790	unsigned short ppb = dev->base;
791	unsigned char l = 0, h = 0;
792	int retv, x;
793
794	/* First check for any errors that may have occurred
795	 * Here we check for internal errors
796	 */
797	if (dev->failed)
798		return 0;
799
800	switch (cmd->SCp.phase) {
801	case 0:		/* Phase 0 - Waiting for parport */
802		if (time_after(jiffies, dev->jstart + HZ)) {
803			/*
804			 * We waited more than a second
805			 * for parport to call us
806			 */
807			imm_fail(dev, DID_BUS_BUSY);
808			return 0;
809		}
810		return 1;	/* wait until imm_wakeup claims parport */
811		/* Phase 1 - Connected */
812	case 1:
813		imm_connect(dev, CONNECT_EPP_MAYBE);
814		cmd->SCp.phase++;
815
816		/* Phase 2 - We are now talking to the scsi bus */
817	case 2:
818		if (!imm_select(dev, scmd_id(cmd))) {
819			imm_fail(dev, DID_NO_CONNECT);
820			return 0;
821		}
822		cmd->SCp.phase++;
823
824		/* Phase 3 - Ready to accept a command */
825	case 3:
826		w_ctr(ppb, 0x0c);
827		if (!(r_str(ppb) & 0x80))
828			return 1;
829
830		if (!imm_send_command(cmd))
831			return 0;
832		cmd->SCp.phase++;
833
834		/* Phase 4 - Setup scatter/gather buffers */
835	case 4:
836		if (cmd->use_sg) {
837			/* if many buffers are available, start filling the first */
838			cmd->SCp.buffer =
839			    (struct scatterlist *) cmd->request_buffer;
840			cmd->SCp.this_residual = cmd->SCp.buffer->length;
841			cmd->SCp.ptr =
842			    page_address(cmd->SCp.buffer->page) +
843			    cmd->SCp.buffer->offset;
844		} else {
845			/* else fill the only available buffer */
846			cmd->SCp.buffer = NULL;
847			cmd->SCp.this_residual = cmd->request_bufflen;
848			cmd->SCp.ptr = cmd->request_buffer;
849		}
850		cmd->SCp.buffers_residual = cmd->use_sg - 1;
851		cmd->SCp.phase++;
852		if (cmd->SCp.this_residual & 0x01)
853			cmd->SCp.this_residual++;
854		/* Phase 5 - Pre-Data transfer stage */
855	case 5:
856		/* Spin lock for BUSY */
857		w_ctr(ppb, 0x0c);
858		if (!(r_str(ppb) & 0x80))
859			return 1;
860
861		/* Require negotiation for read requests */
862		x = (r_str(ppb) & 0xb8);
863		dev->rd = (x & 0x10) ? 1 : 0;
864		dev->dp = (x & 0x20) ? 0 : 1;
865
866		if ((dev->dp) && (dev->rd))
867			if (imm_negotiate(dev))
868				return 0;
869		cmd->SCp.phase++;
870
871		/* Phase 6 - Data transfer stage */
872	case 6:
873		/* Spin lock for BUSY */
874		w_ctr(ppb, 0x0c);
875		if (!(r_str(ppb) & 0x80))
876			return 1;
877
878		if (dev->dp) {
879			retv = imm_completion(cmd);
880			if (retv == -1)
881				return 0;
882			if (retv == 0)
883				return 1;
884		}
885		cmd->SCp.phase++;
886
887		/* Phase 7 - Post data transfer stage */
888	case 7:
889		if ((dev->dp) && (dev->rd)) {
890			if ((dev->mode == IMM_NIBBLE) || (dev->mode == IMM_PS2)) {
891				w_ctr(ppb, 0x4);
892				w_ctr(ppb, 0xc);
893				w_ctr(ppb, 0xe);
894				w_ctr(ppb, 0x4);
895			}
896		}
897		cmd->SCp.phase++;
898
899		/* Phase 8 - Read status/message */
900	case 8:
901		/* Check for data overrun */
902		if (imm_wait(dev) != (unsigned char) 0xb8) {
903			imm_fail(dev, DID_ERROR);
904			return 0;
905		}
906		if (imm_negotiate(dev))
907			return 0;
908		if (imm_in(dev, &l, 1)) {	/* read status byte */
909			/* Check for optional message byte */
910			if (imm_wait(dev) == (unsigned char) 0xb8)
911				imm_in(dev, &h, 1);
912			cmd->result = (DID_OK << 16) + (l & STATUS_MASK);
913		}
914		if ((dev->mode == IMM_NIBBLE) || (dev->mode == IMM_PS2)) {
915			w_ctr(ppb, 0x4);
916			w_ctr(ppb, 0xc);
917			w_ctr(ppb, 0xe);
918			w_ctr(ppb, 0x4);
919		}
920		return 0;	/* Finished */
921		break;
922
923	default:
924		printk("imm: Invalid scsi phase\n");
925	}
926	return 0;
927}
928
929static int imm_queuecommand(struct scsi_cmnd *cmd,
930		void (*done)(struct scsi_cmnd *))
931{
932	imm_struct *dev = imm_dev(cmd->device->host);
933
934	if (dev->cur_cmd) {
935		printk("IMM: bug in imm_queuecommand\n");
936		return 0;
937	}
938	dev->failed = 0;
939	dev->jstart = jiffies;
940	dev->cur_cmd = cmd;
941	cmd->scsi_done = done;
942	cmd->result = DID_ERROR << 16;	/* default return code */
943	cmd->SCp.phase = 0;	/* bus free */
944
945	schedule_delayed_work(&dev->imm_tq, 0);
946
947	imm_pb_claim(dev);
948
949	return 0;
950}
951
952/*
953 * Apparently the disk->capacity attribute is off by 1 sector
954 * for all disk drives.  We add the one here, but it should really
955 * be done in sd.c.  Even if it gets fixed there, this will still
956 * work.
957 */
958static int imm_biosparam(struct scsi_device *sdev, struct block_device *dev,
959			 sector_t capacity, int ip[])
960{
961	ip[0] = 0x40;
962	ip[1] = 0x20;
963	ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);
964	if (ip[2] > 1024) {
965		ip[0] = 0xff;
966		ip[1] = 0x3f;
967		ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);
968	}
969	return 0;
970}
971
972static int imm_abort(struct scsi_cmnd *cmd)
973{
974	imm_struct *dev = imm_dev(cmd->device->host);
975	/*
976	 * There is no method for aborting commands since Iomega
977	 * have tied the SCSI_MESSAGE line high in the interface
978	 */
979
980	switch (cmd->SCp.phase) {
981	case 0:		/* Do not have access to parport */
982	case 1:		/* Have not connected to interface */
983		dev->cur_cmd = NULL;	/* Forget the problem */
984		return SUCCESS;
985		break;
986	default:		/* SCSI command sent, can not abort */
987		return FAILED;
988		break;
989	}
990}
991
992static void imm_reset_pulse(unsigned int base)
993{
994	w_ctr(base, 0x04);
995	w_dtr(base, 0x40);
996	udelay(1);
997	w_ctr(base, 0x0c);
998	w_ctr(base, 0x0d);
999	udelay(50);
1000	w_ctr(base, 0x0c);
1001	w_ctr(base, 0x04);
1002}
1003
1004static int imm_reset(struct scsi_cmnd *cmd)
1005{
1006	imm_struct *dev = imm_dev(cmd->device->host);
1007
1008	if (cmd->SCp.phase)
1009		imm_disconnect(dev);
1010	dev->cur_cmd = NULL;	/* Forget the problem */
1011
1012	imm_connect(dev, CONNECT_NORMAL);
1013	imm_reset_pulse(dev->base);
1014	mdelay(1);		/* device settle delay */
1015	imm_disconnect(dev);
1016	mdelay(1);		/* device settle delay */
1017	return SUCCESS;
1018}
1019
1020static int device_check(imm_struct *dev)
1021{
1022	/* This routine looks for a device and then attempts to use EPP
1023	   to send a command. If all goes as planned then EPP is available. */
1024
1025	static char cmd[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
1026	int loop, old_mode, status, k, ppb = dev->base;
1027	unsigned char l;
1028
1029	old_mode = dev->mode;
1030	for (loop = 0; loop < 8; loop++) {
1031		/* Attempt to use EPP for Test Unit Ready */
1032		if ((ppb & 0x0007) == 0x0000)
1033			dev->mode = IMM_EPP_32;
1034
1035	      second_pass:
1036		imm_connect(dev, CONNECT_EPP_MAYBE);
1037		/* Select SCSI device */
1038		if (!imm_select(dev, loop)) {
1039			imm_disconnect(dev);
1040			continue;
1041		}
1042		printk("imm: Found device at ID %i, Attempting to use %s\n",
1043		       loop, IMM_MODE_STRING[dev->mode]);
1044
1045		/* Send SCSI command */
1046		status = 1;
1047		w_ctr(ppb, 0x0c);
1048		for (l = 0; (l < 3) && (status); l++)
1049			status = imm_out(dev, &cmd[l << 1], 2);
1050
1051		if (!status) {
1052			imm_disconnect(dev);
1053			imm_connect(dev, CONNECT_EPP_MAYBE);
1054			imm_reset_pulse(dev->base);
1055			udelay(1000);
1056			imm_disconnect(dev);
1057			udelay(1000);
1058			if (dev->mode == IMM_EPP_32) {
1059				dev->mode = old_mode;
1060				goto second_pass;
1061			}
1062			printk("imm: Unable to establish communication\n");
1063			return -EIO;
1064		}
1065		w_ctr(ppb, 0x0c);
1066
1067		k = 1000000;	/* 1 Second */
1068		do {
1069			l = r_str(ppb);
1070			k--;
1071			udelay(1);
1072		} while (!(l & 0x80) && (k));
1073
1074		l &= 0xb8;
1075
1076		if (l != 0xb8) {
1077			imm_disconnect(dev);
1078			imm_connect(dev, CONNECT_EPP_MAYBE);
1079			imm_reset_pulse(dev->base);
1080			udelay(1000);
1081			imm_disconnect(dev);
1082			udelay(1000);
1083			if (dev->mode == IMM_EPP_32) {
1084				dev->mode = old_mode;
1085				goto second_pass;
1086			}
1087			printk
1088			    ("imm: Unable to establish communication\n");
1089			return -EIO;
1090		}
1091		imm_disconnect(dev);
1092		printk
1093		    ("imm: Communication established at 0x%x with ID %i using %s\n",
1094		     ppb, loop, IMM_MODE_STRING[dev->mode]);
1095		imm_connect(dev, CONNECT_EPP_MAYBE);
1096		imm_reset_pulse(dev->base);
1097		udelay(1000);
1098		imm_disconnect(dev);
1099		udelay(1000);
1100		return 0;
1101	}
1102	printk("imm: No devices found\n");
1103	return -ENODEV;
1104}
1105
1106/*
1107 * imm cannot deal with highmem, so this causes all IO pages for this host
1108 * to reside in low memory (hence mapped)
1109 */
1110static int imm_adjust_queue(struct scsi_device *device)
1111{
1112	blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
1113	return 0;
1114}
1115
1116static struct scsi_host_template imm_template = {
1117	.module			= THIS_MODULE,
1118	.proc_name		= "imm",
1119	.proc_info		= imm_proc_info,
1120	.name			= "Iomega VPI2 (imm) interface",
1121	.queuecommand		= imm_queuecommand,
1122	.eh_abort_handler	= imm_abort,
1123	.eh_bus_reset_handler	= imm_reset,
1124	.eh_host_reset_handler	= imm_reset,
1125	.bios_param		= imm_biosparam,
1126	.this_id		= 7,
1127	.sg_tablesize		= SG_ALL,
1128	.cmd_per_lun		= 1,
1129	.use_clustering		= ENABLE_CLUSTERING,
1130	.can_queue		= 1,
1131	.slave_alloc		= imm_adjust_queue,
1132};
1133
1134/***************************************************************************
1135 *                   Parallel port probing routines                        *
1136 ***************************************************************************/
1137
1138static LIST_HEAD(imm_hosts);
1139
1140static int __imm_attach(struct parport *pb)
1141{
1142	struct Scsi_Host *host;
1143	imm_struct *dev;
1144	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waiting);
1145	DEFINE_WAIT(wait);
1146	int ports;
1147	int modes, ppb;
1148	int err = -ENOMEM;
1149
1150	init_waitqueue_head(&waiting);
1151
1152	dev = kmalloc(sizeof(imm_struct), GFP_KERNEL);
1153	if (!dev)
1154		return -ENOMEM;
1155
1156	memset(dev, 0, sizeof(imm_struct));
1157
1158	dev->base = -1;
1159	dev->mode = IMM_AUTODETECT;
1160	INIT_LIST_HEAD(&dev->list);
1161
1162	dev->dev = parport_register_device(pb, "imm", NULL, imm_wakeup,
1163						NULL, 0, dev);
1164
1165	if (!dev->dev)
1166		goto out;
1167
1168
1169	/* Claim the bus so it remembers what we do to the control
1170	 * registers. [ CTR and ECP ]
1171	 */
1172	err = -EBUSY;
1173	dev->waiting = &waiting;
1174	prepare_to_wait(&waiting, &wait, TASK_UNINTERRUPTIBLE);
1175	if (imm_pb_claim(dev))
1176		schedule_timeout(3 * HZ);
1177	if (dev->wanted) {
1178		printk(KERN_ERR "imm%d: failed to claim parport because "
1179			"a pardevice is owning the port for too long "
1180			"time!\n", pb->number);
1181		imm_pb_dismiss(dev);
1182		dev->waiting = NULL;
1183		finish_wait(&waiting, &wait);
1184		goto out1;
1185	}
1186	dev->waiting = NULL;
1187	finish_wait(&waiting, &wait);
1188	ppb = dev->base = dev->dev->port->base;
1189	dev->base_hi = dev->dev->port->base_hi;
1190	w_ctr(ppb, 0x0c);
1191	modes = dev->dev->port->modes;
1192
1193	/* Mode detection works up the chain of speed
1194	 * This avoids a nasty if-then-else-if-... tree
1195	 */
1196	dev->mode = IMM_NIBBLE;
1197
1198	if (modes & PARPORT_MODE_TRISTATE)
1199		dev->mode = IMM_PS2;
1200
1201	/* Done configuration */
1202
1203	err = imm_init(dev);
1204
1205	imm_pb_release(dev);
1206
1207	if (err)
1208		goto out1;
1209
1210	/* now the glue ... */
1211	if (dev->mode == IMM_NIBBLE || dev->mode == IMM_PS2)
1212		ports = 3;
1213	else
1214		ports = 8;
1215
1216	INIT_DELAYED_WORK(&dev->imm_tq, imm_interrupt);
1217
1218	err = -ENOMEM;
1219	host = scsi_host_alloc(&imm_template, sizeof(imm_struct *));
1220	if (!host)
1221		goto out1;
1222	host->io_port = pb->base;
1223	host->n_io_port = ports;
1224	host->dma_channel = -1;
1225	host->unique_id = pb->number;
1226	*(imm_struct **)&host->hostdata = dev;
1227	dev->host = host;
1228	list_add_tail(&dev->list, &imm_hosts);
1229	err = scsi_add_host(host, NULL);
1230	if (err)
1231		goto out2;
1232	scsi_scan_host(host);
1233	return 0;
1234
1235out2:
1236	list_del_init(&dev->list);
1237	scsi_host_put(host);
1238out1:
1239	parport_unregister_device(dev->dev);
1240out:
1241	kfree(dev);
1242	return err;
1243}
1244
1245static void imm_attach(struct parport *pb)
1246{
1247	__imm_attach(pb);
1248}
1249
1250static void imm_detach(struct parport *pb)
1251{
1252	imm_struct *dev;
1253	list_for_each_entry(dev, &imm_hosts, list) {
1254		if (dev->dev->port == pb) {
1255			list_del_init(&dev->list);
1256			scsi_remove_host(dev->host);
1257			scsi_host_put(dev->host);
1258			parport_unregister_device(dev->dev);
1259			kfree(dev);
1260			break;
1261		}
1262	}
1263}
1264
1265static struct parport_driver imm_driver = {
1266	.name	= "imm",
1267	.attach	= imm_attach,
1268	.detach	= imm_detach,
1269};
1270
1271static int __init imm_driver_init(void)
1272{
1273	printk("imm: Version %s\n", IMM_VERSION);
1274	return parport_register_driver(&imm_driver);
1275}
1276
1277static void __exit imm_driver_exit(void)
1278{
1279	parport_unregister_driver(&imm_driver);
1280}
1281
1282module_init(imm_driver_init);
1283module_exit(imm_driver_exit);
1284
1285MODULE_LICENSE("GPL");
1286