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