xref: /openbmc/linux/drivers/scsi/ppa.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /* ppa.c   --  low level driver for the IOMEGA PPA3
2  * parallel port SCSI host adapter.
3  *
4  * (The PPA3 is the embedded controller in the ZIP drive.)
5  *
6  * (c) 1995,1996 Grant R. Guenther, grant@torque.net,
7  * under the terms of the GNU General Public License.
8  *
9  * Current Maintainer: David Campbell (Perth, Western Australia, GMT+0800)
10  *                     campbell@torque.net
11  */
12 
13 #include <linux/config.h>
14 #include <linux/init.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/blkdev.h>
18 #include <linux/parport.h>
19 #include <linux/workqueue.h>
20 #include <linux/delay.h>
21 #include <asm/io.h>
22 
23 #include <scsi/scsi.h>
24 #include <scsi/scsi_cmnd.h>
25 #include <scsi/scsi_device.h>
26 #include <scsi/scsi_host.h>
27 
28 
29 static void ppa_reset_pulse(unsigned int base);
30 
31 typedef struct {
32 	struct pardevice *dev;	/* Parport device entry         */
33 	int base;		/* Actual port address          */
34 	int mode;		/* Transfer mode                */
35 	struct scsi_cmnd *cur_cmd;	/* Current queued command       */
36 	struct work_struct ppa_tq;	/* Polling interrupt stuff       */
37 	unsigned long jstart;	/* Jiffies at start             */
38 	unsigned long recon_tmo;	/* How many usecs to wait for reconnection (6th bit) */
39 	unsigned int failed:1;	/* Failure flag                 */
40 	unsigned wanted:1;	/* Parport sharing busy flag    */
41 	wait_queue_head_t *waiting;
42 	struct Scsi_Host *host;
43 	struct list_head list;
44 } ppa_struct;
45 
46 #include  "ppa.h"
47 
48 static inline ppa_struct *ppa_dev(struct Scsi_Host *host)
49 {
50 	return *(ppa_struct **)&host->hostdata;
51 }
52 
53 static DEFINE_SPINLOCK(arbitration_lock);
54 
55 static void got_it(ppa_struct *dev)
56 {
57 	dev->base = dev->dev->port->base;
58 	if (dev->cur_cmd)
59 		dev->cur_cmd->SCp.phase = 1;
60 	else
61 		wake_up(dev->waiting);
62 }
63 
64 static void ppa_wakeup(void *ref)
65 {
66 	ppa_struct *dev = (ppa_struct *) ref;
67 	unsigned long flags;
68 
69 	spin_lock_irqsave(&arbitration_lock, flags);
70 	if (dev->wanted) {
71 		parport_claim(dev->dev);
72 		got_it(dev);
73 		dev->wanted = 0;
74 	}
75 	spin_unlock_irqrestore(&arbitration_lock, flags);
76 	return;
77 }
78 
79 static int ppa_pb_claim(ppa_struct *dev)
80 {
81 	unsigned long flags;
82 	int res = 1;
83 	spin_lock_irqsave(&arbitration_lock, flags);
84 	if (parport_claim(dev->dev) == 0) {
85 		got_it(dev);
86 		res = 0;
87 	}
88 	dev->wanted = res;
89 	spin_unlock_irqrestore(&arbitration_lock, flags);
90 	return res;
91 }
92 
93 static void ppa_pb_dismiss(ppa_struct *dev)
94 {
95 	unsigned long flags;
96 	int wanted;
97 	spin_lock_irqsave(&arbitration_lock, flags);
98 	wanted = dev->wanted;
99 	dev->wanted = 0;
100 	spin_unlock_irqrestore(&arbitration_lock, flags);
101 	if (!wanted)
102 		parport_release(dev->dev);
103 }
104 
105 static inline void ppa_pb_release(ppa_struct *dev)
106 {
107 	parport_release(dev->dev);
108 }
109 
110 /*
111  * Start of Chipset kludges
112  */
113 
114 /* This is to give the ppa driver a way to modify the timings (and other
115  * parameters) by writing to the /proc/scsi/ppa/0 file.
116  * Very simple method really... (To simple, no error checking :( )
117  * Reason: Kernel hackers HATE having to unload and reload modules for
118  * testing...
119  * Also gives a method to use a script to obtain optimum timings (TODO)
120  */
121 
122 static inline int ppa_proc_write(ppa_struct *dev, char *buffer, int length)
123 {
124 	unsigned long x;
125 
126 	if ((length > 5) && (strncmp(buffer, "mode=", 5) == 0)) {
127 		x = simple_strtoul(buffer + 5, NULL, 0);
128 		dev->mode = x;
129 		return length;
130 	}
131 	if ((length > 10) && (strncmp(buffer, "recon_tmo=", 10) == 0)) {
132 		x = simple_strtoul(buffer + 10, NULL, 0);
133 		dev->recon_tmo = x;
134 		printk("ppa: recon_tmo set to %ld\n", x);
135 		return length;
136 	}
137 	printk("ppa /proc: invalid variable\n");
138 	return (-EINVAL);
139 }
140 
141 static int ppa_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset, int length, int inout)
142 {
143 	int len = 0;
144 	ppa_struct *dev = ppa_dev(host);
145 
146 	if (inout)
147 		return ppa_proc_write(dev, buffer, length);
148 
149 	len += sprintf(buffer + len, "Version : %s\n", PPA_VERSION);
150 	len +=
151 	    sprintf(buffer + len, "Parport : %s\n",
152 		    dev->dev->port->name);
153 	len +=
154 	    sprintf(buffer + len, "Mode    : %s\n",
155 		    PPA_MODE_STRING[dev->mode]);
156 #if PPA_DEBUG > 0
157 	len +=
158 	    sprintf(buffer + len, "recon_tmo : %lu\n", dev->recon_tmo);
159 #endif
160 
161 	/* Request for beyond end of buffer */
162 	if (offset > length)
163 		return 0;
164 
165 	*start = buffer + offset;
166 	len -= offset;
167 	if (len > length)
168 		len = length;
169 	return len;
170 }
171 
172 static int device_check(ppa_struct *dev);
173 
174 #if PPA_DEBUG > 0
175 #define ppa_fail(x,y) printk("ppa: ppa_fail(%i) from %s at line %d\n",\
176 	   y, __FUNCTION__, __LINE__); ppa_fail_func(x,y);
177 static inline void ppa_fail_func(ppa_struct *dev, int error_code)
178 #else
179 static inline void ppa_fail(ppa_struct *dev, int error_code)
180 #endif
181 {
182 	/* If we fail a device then we trash status / message bytes */
183 	if (dev->cur_cmd) {
184 		dev->cur_cmd->result = error_code << 16;
185 		dev->failed = 1;
186 	}
187 }
188 
189 /*
190  * Wait for the high bit to be set.
191  *
192  * In principle, this could be tied to an interrupt, but the adapter
193  * doesn't appear to be designed to support interrupts.  We spin on
194  * the 0x80 ready bit.
195  */
196 static unsigned char ppa_wait(ppa_struct *dev)
197 {
198 	int k;
199 	unsigned short ppb = dev->base;
200 	unsigned char r;
201 
202 	k = PPA_SPIN_TMO;
203 	/* Wait for bit 6 and 7 - PJC */
204 	for (r = r_str(ppb); ((r & 0xc0) != 0xc0) && (k); k--) {
205 		udelay(1);
206 		r = r_str(ppb);
207 	}
208 
209 	/*
210 	 * return some status information.
211 	 * Semantics: 0xc0 = ZIP wants more data
212 	 *            0xd0 = ZIP wants to send more data
213 	 *            0xe0 = ZIP is expecting SCSI command data
214 	 *            0xf0 = end of transfer, ZIP is sending status
215 	 */
216 	if (k)
217 		return (r & 0xf0);
218 
219 	/* Counter expired - Time out occurred */
220 	ppa_fail(dev, DID_TIME_OUT);
221 	printk("ppa timeout in ppa_wait\n");
222 	return 0;		/* command timed out */
223 }
224 
225 /*
226  * Clear EPP Timeout Bit
227  */
228 static inline void epp_reset(unsigned short ppb)
229 {
230 	int i;
231 
232 	i = r_str(ppb);
233 	w_str(ppb, i);
234 	w_str(ppb, i & 0xfe);
235 }
236 
237 /*
238  * Wait for empty ECP fifo (if we are in ECP fifo mode only)
239  */
240 static inline void ecp_sync(ppa_struct *dev)
241 {
242 	int i, ppb_hi = dev->dev->port->base_hi;
243 
244 	if (ppb_hi == 0)
245 		return;
246 
247 	if ((r_ecr(ppb_hi) & 0xe0) == 0x60) {	/* mode 011 == ECP fifo mode */
248 		for (i = 0; i < 100; i++) {
249 			if (r_ecr(ppb_hi) & 0x01)
250 				return;
251 			udelay(5);
252 		}
253 		printk("ppa: ECP sync failed as data still present in FIFO.\n");
254 	}
255 }
256 
257 static int ppa_byte_out(unsigned short base, const char *buffer, int len)
258 {
259 	int i;
260 
261 	for (i = len; i; i--) {
262 		w_dtr(base, *buffer++);
263 		w_ctr(base, 0xe);
264 		w_ctr(base, 0xc);
265 	}
266 	return 1;		/* All went well - we hope! */
267 }
268 
269 static int ppa_byte_in(unsigned short base, char *buffer, int len)
270 {
271 	int i;
272 
273 	for (i = len; i; i--) {
274 		*buffer++ = r_dtr(base);
275 		w_ctr(base, 0x27);
276 		w_ctr(base, 0x25);
277 	}
278 	return 1;		/* All went well - we hope! */
279 }
280 
281 static int ppa_nibble_in(unsigned short base, char *buffer, int len)
282 {
283 	for (; len; len--) {
284 		unsigned char h;
285 
286 		w_ctr(base, 0x4);
287 		h = r_str(base) & 0xf0;
288 		w_ctr(base, 0x6);
289 		*buffer++ = h | ((r_str(base) & 0xf0) >> 4);
290 	}
291 	return 1;		/* All went well - we hope! */
292 }
293 
294 static int ppa_out(ppa_struct *dev, char *buffer, int len)
295 {
296 	int r;
297 	unsigned short ppb = dev->base;
298 
299 	r = ppa_wait(dev);
300 
301 	if ((r & 0x50) != 0x40) {
302 		ppa_fail(dev, DID_ERROR);
303 		return 0;
304 	}
305 	switch (dev->mode) {
306 	case PPA_NIBBLE:
307 	case PPA_PS2:
308 		/* 8 bit output, with a loop */
309 		r = ppa_byte_out(ppb, buffer, len);
310 		break;
311 
312 	case PPA_EPP_32:
313 	case PPA_EPP_16:
314 	case PPA_EPP_8:
315 		epp_reset(ppb);
316 		w_ctr(ppb, 0x4);
317 #ifdef CONFIG_SCSI_IZIP_EPP16
318 		if (!(((long) buffer | len) & 0x01))
319 			outsw(ppb + 4, buffer, len >> 1);
320 #else
321 		if (!(((long) buffer | len) & 0x03))
322 			outsl(ppb + 4, buffer, len >> 2);
323 #endif
324 		else
325 			outsb(ppb + 4, buffer, len);
326 		w_ctr(ppb, 0xc);
327 		r = !(r_str(ppb) & 0x01);
328 		w_ctr(ppb, 0xc);
329 		ecp_sync(dev);
330 		break;
331 
332 	default:
333 		printk("PPA: bug in ppa_out()\n");
334 		r = 0;
335 	}
336 	return r;
337 }
338 
339 static int ppa_in(ppa_struct *dev, char *buffer, int len)
340 {
341 	int r;
342 	unsigned short ppb = dev->base;
343 
344 	r = ppa_wait(dev);
345 
346 	if ((r & 0x50) != 0x50) {
347 		ppa_fail(dev, DID_ERROR);
348 		return 0;
349 	}
350 	switch (dev->mode) {
351 	case PPA_NIBBLE:
352 		/* 4 bit input, with a loop */
353 		r = ppa_nibble_in(ppb, buffer, len);
354 		w_ctr(ppb, 0xc);
355 		break;
356 
357 	case PPA_PS2:
358 		/* 8 bit input, with a loop */
359 		w_ctr(ppb, 0x25);
360 		r = ppa_byte_in(ppb, buffer, len);
361 		w_ctr(ppb, 0x4);
362 		w_ctr(ppb, 0xc);
363 		break;
364 
365 	case PPA_EPP_32:
366 	case PPA_EPP_16:
367 	case PPA_EPP_8:
368 		epp_reset(ppb);
369 		w_ctr(ppb, 0x24);
370 #ifdef CONFIG_SCSI_IZIP_EPP16
371 		if (!(((long) buffer | len) & 0x01))
372 			insw(ppb + 4, buffer, len >> 1);
373 #else
374 		if (!(((long) buffer | len) & 0x03))
375 			insl(ppb + 4, buffer, len >> 2);
376 #endif
377 		else
378 			insb(ppb + 4, buffer, len);
379 		w_ctr(ppb, 0x2c);
380 		r = !(r_str(ppb) & 0x01);
381 		w_ctr(ppb, 0x2c);
382 		ecp_sync(dev);
383 		break;
384 
385 	default:
386 		printk("PPA: bug in ppa_ins()\n");
387 		r = 0;
388 		break;
389 	}
390 	return r;
391 }
392 
393 /* end of ppa_io.h */
394 static inline void ppa_d_pulse(unsigned short ppb, unsigned char b)
395 {
396 	w_dtr(ppb, b);
397 	w_ctr(ppb, 0xc);
398 	w_ctr(ppb, 0xe);
399 	w_ctr(ppb, 0xc);
400 	w_ctr(ppb, 0x4);
401 	w_ctr(ppb, 0xc);
402 }
403 
404 static void ppa_disconnect(ppa_struct *dev)
405 {
406 	unsigned short ppb = dev->base;
407 
408 	ppa_d_pulse(ppb, 0);
409 	ppa_d_pulse(ppb, 0x3c);
410 	ppa_d_pulse(ppb, 0x20);
411 	ppa_d_pulse(ppb, 0xf);
412 }
413 
414 static inline void ppa_c_pulse(unsigned short ppb, unsigned char b)
415 {
416 	w_dtr(ppb, b);
417 	w_ctr(ppb, 0x4);
418 	w_ctr(ppb, 0x6);
419 	w_ctr(ppb, 0x4);
420 	w_ctr(ppb, 0xc);
421 }
422 
423 static inline void ppa_connect(ppa_struct *dev, int flag)
424 {
425 	unsigned short ppb = dev->base;
426 
427 	ppa_c_pulse(ppb, 0);
428 	ppa_c_pulse(ppb, 0x3c);
429 	ppa_c_pulse(ppb, 0x20);
430 	if ((flag == CONNECT_EPP_MAYBE) && IN_EPP_MODE(dev->mode))
431 		ppa_c_pulse(ppb, 0xcf);
432 	else
433 		ppa_c_pulse(ppb, 0x8f);
434 }
435 
436 static int ppa_select(ppa_struct *dev, int target)
437 {
438 	int k;
439 	unsigned short ppb = dev->base;
440 
441 	/*
442 	 * Bit 6 (0x40) is the device selected bit.
443 	 * First we must wait till the current device goes off line...
444 	 */
445 	k = PPA_SELECT_TMO;
446 	do {
447 		k--;
448 		udelay(1);
449 	} while ((r_str(ppb) & 0x40) && (k));
450 	if (!k)
451 		return 0;
452 
453 	w_dtr(ppb, (1 << target));
454 	w_ctr(ppb, 0xe);
455 	w_ctr(ppb, 0xc);
456 	w_dtr(ppb, 0x80);	/* This is NOT the initator */
457 	w_ctr(ppb, 0x8);
458 
459 	k = PPA_SELECT_TMO;
460 	do {
461 		k--;
462 		udelay(1);
463 	}
464 	while (!(r_str(ppb) & 0x40) && (k));
465 	if (!k)
466 		return 0;
467 
468 	return 1;
469 }
470 
471 /*
472  * This is based on a trace of what the Iomega DOS 'guest' driver does.
473  * I've tried several different kinds of parallel ports with guest and
474  * coded this to react in the same ways that it does.
475  *
476  * The return value from this function is just a hint about where the
477  * handshaking failed.
478  *
479  */
480 static int ppa_init(ppa_struct *dev)
481 {
482 	int retv;
483 	unsigned short ppb = dev->base;
484 
485 	ppa_disconnect(dev);
486 	ppa_connect(dev, CONNECT_NORMAL);
487 
488 	retv = 2;		/* Failed */
489 
490 	w_ctr(ppb, 0xe);
491 	if ((r_str(ppb) & 0x08) == 0x08)
492 		retv--;
493 
494 	w_ctr(ppb, 0xc);
495 	if ((r_str(ppb) & 0x08) == 0x00)
496 		retv--;
497 
498 	if (!retv)
499 		ppa_reset_pulse(ppb);
500 	udelay(1000);		/* Allow devices to settle down */
501 	ppa_disconnect(dev);
502 	udelay(1000);		/* Another delay to allow devices to settle */
503 
504 	if (retv)
505 		return -EIO;
506 
507 	return device_check(dev);
508 }
509 
510 static inline int ppa_send_command(struct scsi_cmnd *cmd)
511 {
512 	ppa_struct *dev = ppa_dev(cmd->device->host);
513 	int k;
514 
515 	w_ctr(dev->base, 0x0c);
516 
517 	for (k = 0; k < cmd->cmd_len; k++)
518 		if (!ppa_out(dev, &cmd->cmnd[k], 1))
519 			return 0;
520 	return 1;
521 }
522 
523 /*
524  * The bulk flag enables some optimisations in the data transfer loops,
525  * it should be true for any command that transfers data in integral
526  * numbers of sectors.
527  *
528  * The driver appears to remain stable if we speed up the parallel port
529  * i/o in this function, but not elsewhere.
530  */
531 static int ppa_completion(struct scsi_cmnd *cmd)
532 {
533 	/* Return codes:
534 	 * -1     Error
535 	 *  0     Told to schedule
536 	 *  1     Finished data transfer
537 	 */
538 	ppa_struct *dev = ppa_dev(cmd->device->host);
539 	unsigned short ppb = dev->base;
540 	unsigned long start_jiffies = jiffies;
541 
542 	unsigned char r, v;
543 	int fast, bulk, status;
544 
545 	v = cmd->cmnd[0];
546 	bulk = ((v == READ_6) ||
547 		(v == READ_10) || (v == WRITE_6) || (v == WRITE_10));
548 
549 	/*
550 	 * We only get here if the drive is ready to comunicate,
551 	 * hence no need for a full ppa_wait.
552 	 */
553 	r = (r_str(ppb) & 0xf0);
554 
555 	while (r != (unsigned char) 0xf0) {
556 		/*
557 		 * If we have been running for more than a full timer tick
558 		 * then take a rest.
559 		 */
560 		if (time_after(jiffies, start_jiffies + 1))
561 			return 0;
562 
563 		if ((cmd->SCp.this_residual <= 0)) {
564 			ppa_fail(dev, DID_ERROR);
565 			return -1;	/* ERROR_RETURN */
566 		}
567 
568 		/* On some hardware we have SCSI disconnected (6th bit low)
569 		 * for about 100usecs. It is too expensive to wait a
570 		 * tick on every loop so we busy wait for no more than
571 		 * 500usecs to give the drive a chance first. We do not
572 		 * change things for "normal" hardware since generally
573 		 * the 6th bit is always high.
574 		 * This makes the CPU load higher on some hardware
575 		 * but otherwise we can not get more than 50K/secs
576 		 * on this problem hardware.
577 		 */
578 		if ((r & 0xc0) != 0xc0) {
579 			/* Wait for reconnection should be no more than
580 			 * jiffy/2 = 5ms = 5000 loops
581 			 */
582 			unsigned long k = dev->recon_tmo;
583 			for (; k && ((r = (r_str(ppb) & 0xf0)) & 0xc0) != 0xc0;
584 			     k--)
585 				udelay(1);
586 
587 			if (!k)
588 				return 0;
589 		}
590 
591 		/* determine if we should use burst I/O */
592 		fast = (bulk && (cmd->SCp.this_residual >= PPA_BURST_SIZE))
593 		    ? PPA_BURST_SIZE : 1;
594 
595 		if (r == (unsigned char) 0xc0)
596 			status = ppa_out(dev, cmd->SCp.ptr, fast);
597 		else
598 			status = ppa_in(dev, cmd->SCp.ptr, fast);
599 
600 		cmd->SCp.ptr += fast;
601 		cmd->SCp.this_residual -= fast;
602 
603 		if (!status) {
604 			ppa_fail(dev, DID_BUS_BUSY);
605 			return -1;	/* ERROR_RETURN */
606 		}
607 		if (cmd->SCp.buffer && !cmd->SCp.this_residual) {
608 			/* if scatter/gather, advance to the next segment */
609 			if (cmd->SCp.buffers_residual--) {
610 				cmd->SCp.buffer++;
611 				cmd->SCp.this_residual =
612 				    cmd->SCp.buffer->length;
613 				cmd->SCp.ptr =
614 				    page_address(cmd->SCp.buffer->page) +
615 				    cmd->SCp.buffer->offset;
616 			}
617 		}
618 		/* Now check to see if the drive is ready to comunicate */
619 		r = (r_str(ppb) & 0xf0);
620 		/* If not, drop back down to the scheduler and wait a timer tick */
621 		if (!(r & 0x80))
622 			return 0;
623 	}
624 	return 1;		/* FINISH_RETURN */
625 }
626 
627 /*
628  * Since the PPA itself doesn't generate interrupts, we use
629  * the scheduler's task queue to generate a stream of call-backs and
630  * complete the request when the drive is ready.
631  */
632 static void ppa_interrupt(void *data)
633 {
634 	ppa_struct *dev = (ppa_struct *) data;
635 	struct scsi_cmnd *cmd = dev->cur_cmd;
636 
637 	if (!cmd) {
638 		printk("PPA: bug in ppa_interrupt\n");
639 		return;
640 	}
641 	if (ppa_engine(dev, cmd)) {
642 		dev->ppa_tq.data = (void *) dev;
643 		schedule_delayed_work(&dev->ppa_tq, 1);
644 		return;
645 	}
646 	/* Command must of completed hence it is safe to let go... */
647 #if PPA_DEBUG > 0
648 	switch ((cmd->result >> 16) & 0xff) {
649 	case DID_OK:
650 		break;
651 	case DID_NO_CONNECT:
652 		printk("ppa: no device at SCSI ID %i\n", cmd->device->target);
653 		break;
654 	case DID_BUS_BUSY:
655 		printk("ppa: BUS BUSY - EPP timeout detected\n");
656 		break;
657 	case DID_TIME_OUT:
658 		printk("ppa: unknown timeout\n");
659 		break;
660 	case DID_ABORT:
661 		printk("ppa: told to abort\n");
662 		break;
663 	case DID_PARITY:
664 		printk("ppa: parity error (???)\n");
665 		break;
666 	case DID_ERROR:
667 		printk("ppa: internal driver error\n");
668 		break;
669 	case DID_RESET:
670 		printk("ppa: told to reset device\n");
671 		break;
672 	case DID_BAD_INTR:
673 		printk("ppa: bad interrupt (???)\n");
674 		break;
675 	default:
676 		printk("ppa: bad return code (%02x)\n",
677 		       (cmd->result >> 16) & 0xff);
678 	}
679 #endif
680 
681 	if (cmd->SCp.phase > 1)
682 		ppa_disconnect(dev);
683 
684 	ppa_pb_dismiss(dev);
685 
686 	dev->cur_cmd = NULL;
687 
688 	cmd->scsi_done(cmd);
689 }
690 
691 static int ppa_engine(ppa_struct *dev, struct scsi_cmnd *cmd)
692 {
693 	unsigned short ppb = dev->base;
694 	unsigned char l = 0, h = 0;
695 	int retv;
696 
697 	/* First check for any errors that may of occurred
698 	 * Here we check for internal errors
699 	 */
700 	if (dev->failed)
701 		return 0;
702 
703 	switch (cmd->SCp.phase) {
704 	case 0:		/* Phase 0 - Waiting for parport */
705 		if (time_after(jiffies, dev->jstart + HZ)) {
706 			/*
707 			 * We waited more than a second
708 			 * for parport to call us
709 			 */
710 			ppa_fail(dev, DID_BUS_BUSY);
711 			return 0;
712 		}
713 		return 1;	/* wait until ppa_wakeup claims parport */
714 	case 1:		/* Phase 1 - Connected */
715 		{		/* Perform a sanity check for cable unplugged */
716 			int retv = 2;	/* Failed */
717 
718 			ppa_connect(dev, CONNECT_EPP_MAYBE);
719 
720 			w_ctr(ppb, 0xe);
721 			if ((r_str(ppb) & 0x08) == 0x08)
722 				retv--;
723 
724 			w_ctr(ppb, 0xc);
725 			if ((r_str(ppb) & 0x08) == 0x00)
726 				retv--;
727 
728 			if (retv) {
729 				if ((jiffies - dev->jstart) > (1 * HZ)) {
730 					printk
731 					    ("ppa: Parallel port cable is unplugged!!\n");
732 					ppa_fail(dev, DID_BUS_BUSY);
733 					return 0;
734 				} else {
735 					ppa_disconnect(dev);
736 					return 1;	/* Try again in a jiffy */
737 				}
738 			}
739 			cmd->SCp.phase++;
740 		}
741 
742 	case 2:		/* Phase 2 - We are now talking to the scsi bus */
743 		if (!ppa_select(dev, scmd_id(cmd))) {
744 			ppa_fail(dev, DID_NO_CONNECT);
745 			return 0;
746 		}
747 		cmd->SCp.phase++;
748 
749 	case 3:		/* Phase 3 - Ready to accept a command */
750 		w_ctr(ppb, 0x0c);
751 		if (!(r_str(ppb) & 0x80))
752 			return 1;
753 
754 		if (!ppa_send_command(cmd))
755 			return 0;
756 		cmd->SCp.phase++;
757 
758 	case 4:		/* Phase 4 - Setup scatter/gather buffers */
759 		if (cmd->use_sg) {
760 			/* if many buffers are available, start filling the first */
761 			cmd->SCp.buffer =
762 			    (struct scatterlist *) cmd->request_buffer;
763 			cmd->SCp.this_residual = cmd->SCp.buffer->length;
764 			cmd->SCp.ptr =
765 			    page_address(cmd->SCp.buffer->page) +
766 			    cmd->SCp.buffer->offset;
767 		} else {
768 			/* else fill the only available buffer */
769 			cmd->SCp.buffer = NULL;
770 			cmd->SCp.this_residual = cmd->request_bufflen;
771 			cmd->SCp.ptr = cmd->request_buffer;
772 		}
773 		cmd->SCp.buffers_residual = cmd->use_sg - 1;
774 		cmd->SCp.phase++;
775 
776 	case 5:		/* Phase 5 - Data transfer stage */
777 		w_ctr(ppb, 0x0c);
778 		if (!(r_str(ppb) & 0x80))
779 			return 1;
780 
781 		retv = ppa_completion(cmd);
782 		if (retv == -1)
783 			return 0;
784 		if (retv == 0)
785 			return 1;
786 		cmd->SCp.phase++;
787 
788 	case 6:		/* Phase 6 - Read status/message */
789 		cmd->result = DID_OK << 16;
790 		/* Check for data overrun */
791 		if (ppa_wait(dev) != (unsigned char) 0xf0) {
792 			ppa_fail(dev, DID_ERROR);
793 			return 0;
794 		}
795 		if (ppa_in(dev, &l, 1)) {	/* read status byte */
796 			/* Check for optional message byte */
797 			if (ppa_wait(dev) == (unsigned char) 0xf0)
798 				ppa_in(dev, &h, 1);
799 			cmd->result =
800 			    (DID_OK << 16) + (h << 8) + (l & STATUS_MASK);
801 		}
802 		return 0;	/* Finished */
803 		break;
804 
805 	default:
806 		printk("ppa: Invalid scsi phase\n");
807 	}
808 	return 0;
809 }
810 
811 static int ppa_queuecommand(struct scsi_cmnd *cmd,
812 		void (*done) (struct scsi_cmnd *))
813 {
814 	ppa_struct *dev = ppa_dev(cmd->device->host);
815 
816 	if (dev->cur_cmd) {
817 		printk("PPA: bug in ppa_queuecommand\n");
818 		return 0;
819 	}
820 	dev->failed = 0;
821 	dev->jstart = jiffies;
822 	dev->cur_cmd = cmd;
823 	cmd->scsi_done = done;
824 	cmd->result = DID_ERROR << 16;	/* default return code */
825 	cmd->SCp.phase = 0;	/* bus free */
826 
827 	dev->ppa_tq.data = dev;
828 	schedule_work(&dev->ppa_tq);
829 
830 	ppa_pb_claim(dev);
831 
832 	return 0;
833 }
834 
835 /*
836  * Apparently the disk->capacity attribute is off by 1 sector
837  * for all disk drives.  We add the one here, but it should really
838  * be done in sd.c.  Even if it gets fixed there, this will still
839  * work.
840  */
841 static int ppa_biosparam(struct scsi_device *sdev, struct block_device *dev,
842 	      sector_t capacity, int ip[])
843 {
844 	ip[0] = 0x40;
845 	ip[1] = 0x20;
846 	ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);
847 	if (ip[2] > 1024) {
848 		ip[0] = 0xff;
849 		ip[1] = 0x3f;
850 		ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);
851 		if (ip[2] > 1023)
852 			ip[2] = 1023;
853 	}
854 	return 0;
855 }
856 
857 static int ppa_abort(struct scsi_cmnd *cmd)
858 {
859 	ppa_struct *dev = ppa_dev(cmd->device->host);
860 	/*
861 	 * There is no method for aborting commands since Iomega
862 	 * have tied the SCSI_MESSAGE line high in the interface
863 	 */
864 
865 	switch (cmd->SCp.phase) {
866 	case 0:		/* Do not have access to parport */
867 	case 1:		/* Have not connected to interface */
868 		dev->cur_cmd = NULL;	/* Forget the problem */
869 		return SUCCESS;
870 		break;
871 	default:		/* SCSI command sent, can not abort */
872 		return FAILED;
873 		break;
874 	}
875 }
876 
877 static void ppa_reset_pulse(unsigned int base)
878 {
879 	w_dtr(base, 0x40);
880 	w_ctr(base, 0x8);
881 	udelay(30);
882 	w_ctr(base, 0xc);
883 }
884 
885 static int ppa_reset(struct scsi_cmnd *cmd)
886 {
887 	ppa_struct *dev = ppa_dev(cmd->device->host);
888 
889 	if (cmd->SCp.phase)
890 		ppa_disconnect(dev);
891 	dev->cur_cmd = NULL;	/* Forget the problem */
892 
893 	ppa_connect(dev, CONNECT_NORMAL);
894 	ppa_reset_pulse(dev->base);
895 	mdelay(1);		/* device settle delay */
896 	ppa_disconnect(dev);
897 	mdelay(1);		/* device settle delay */
898 	return SUCCESS;
899 }
900 
901 static int device_check(ppa_struct *dev)
902 {
903 	/* This routine looks for a device and then attempts to use EPP
904 	   to send a command. If all goes as planned then EPP is available. */
905 
906 	static char cmd[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
907 	int loop, old_mode, status, k, ppb = dev->base;
908 	unsigned char l;
909 
910 	old_mode = dev->mode;
911 	for (loop = 0; loop < 8; loop++) {
912 		/* Attempt to use EPP for Test Unit Ready */
913 		if ((ppb & 0x0007) == 0x0000)
914 			dev->mode = PPA_EPP_32;
915 
916 	      second_pass:
917 		ppa_connect(dev, CONNECT_EPP_MAYBE);
918 		/* Select SCSI device */
919 		if (!ppa_select(dev, loop)) {
920 			ppa_disconnect(dev);
921 			continue;
922 		}
923 		printk("ppa: Found device at ID %i, Attempting to use %s\n",
924 		       loop, PPA_MODE_STRING[dev->mode]);
925 
926 		/* Send SCSI command */
927 		status = 1;
928 		w_ctr(ppb, 0x0c);
929 		for (l = 0; (l < 6) && (status); l++)
930 			status = ppa_out(dev, cmd, 1);
931 
932 		if (!status) {
933 			ppa_disconnect(dev);
934 			ppa_connect(dev, CONNECT_EPP_MAYBE);
935 			w_dtr(ppb, 0x40);
936 			w_ctr(ppb, 0x08);
937 			udelay(30);
938 			w_ctr(ppb, 0x0c);
939 			udelay(1000);
940 			ppa_disconnect(dev);
941 			udelay(1000);
942 			if (dev->mode == PPA_EPP_32) {
943 				dev->mode = old_mode;
944 				goto second_pass;
945 			}
946 			return -EIO;
947 		}
948 		w_ctr(ppb, 0x0c);
949 		k = 1000000;	/* 1 Second */
950 		do {
951 			l = r_str(ppb);
952 			k--;
953 			udelay(1);
954 		} while (!(l & 0x80) && (k));
955 
956 		l &= 0xf0;
957 
958 		if (l != 0xf0) {
959 			ppa_disconnect(dev);
960 			ppa_connect(dev, CONNECT_EPP_MAYBE);
961 			ppa_reset_pulse(ppb);
962 			udelay(1000);
963 			ppa_disconnect(dev);
964 			udelay(1000);
965 			if (dev->mode == PPA_EPP_32) {
966 				dev->mode = old_mode;
967 				goto second_pass;
968 			}
969 			return -EIO;
970 		}
971 		ppa_disconnect(dev);
972 		printk("ppa: Communication established with ID %i using %s\n",
973 		       loop, PPA_MODE_STRING[dev->mode]);
974 		ppa_connect(dev, CONNECT_EPP_MAYBE);
975 		ppa_reset_pulse(ppb);
976 		udelay(1000);
977 		ppa_disconnect(dev);
978 		udelay(1000);
979 		return 0;
980 	}
981 	return -ENODEV;
982 }
983 
984 static struct scsi_host_template ppa_template = {
985 	.module			= THIS_MODULE,
986 	.proc_name		= "ppa",
987 	.proc_info		= ppa_proc_info,
988 	.name			= "Iomega VPI0 (ppa) interface",
989 	.queuecommand		= ppa_queuecommand,
990 	.eh_abort_handler	= ppa_abort,
991 	.eh_bus_reset_handler	= ppa_reset,
992 	.eh_host_reset_handler	= ppa_reset,
993 	.bios_param		= ppa_biosparam,
994 	.this_id		= -1,
995 	.sg_tablesize		= SG_ALL,
996 	.cmd_per_lun		= 1,
997 	.use_clustering		= ENABLE_CLUSTERING,
998 	.can_queue		= 1,
999 };
1000 
1001 /***************************************************************************
1002  *                   Parallel port probing routines                        *
1003  ***************************************************************************/
1004 
1005 static LIST_HEAD(ppa_hosts);
1006 
1007 static int __ppa_attach(struct parport *pb)
1008 {
1009 	struct Scsi_Host *host;
1010 	DECLARE_WAIT_QUEUE_HEAD(waiting);
1011 	DEFINE_WAIT(wait);
1012 	ppa_struct *dev;
1013 	int ports;
1014 	int modes, ppb, ppb_hi;
1015 	int err = -ENOMEM;
1016 
1017 	dev = kmalloc(sizeof(ppa_struct), GFP_KERNEL);
1018 	if (!dev)
1019 		return -ENOMEM;
1020 	memset(dev, 0, sizeof(ppa_struct));
1021 	dev->base = -1;
1022 	dev->mode = PPA_AUTODETECT;
1023 	dev->recon_tmo = PPA_RECON_TMO;
1024 	init_waitqueue_head(&waiting);
1025 	dev->dev = parport_register_device(pb, "ppa", NULL, ppa_wakeup,
1026 					    NULL, 0, dev);
1027 
1028 	if (!dev->dev)
1029 		goto out;
1030 
1031 	/* Claim the bus so it remembers what we do to the control
1032 	 * registers. [ CTR and ECP ]
1033 	 */
1034 	err = -EBUSY;
1035 	dev->waiting = &waiting;
1036 	prepare_to_wait(&waiting, &wait, TASK_UNINTERRUPTIBLE);
1037 	if (ppa_pb_claim(dev))
1038 		schedule_timeout(3 * HZ);
1039 	if (dev->wanted) {
1040 		printk(KERN_ERR "ppa%d: failed to claim parport because "
1041 				"a pardevice is owning the port for too long "
1042 				"time!\n", pb->number);
1043 		ppa_pb_dismiss(dev);
1044 		dev->waiting = NULL;
1045 		finish_wait(&waiting, &wait);
1046 		goto out1;
1047 	}
1048 	dev->waiting = NULL;
1049 	finish_wait(&waiting, &wait);
1050 	ppb = dev->base = dev->dev->port->base;
1051 	ppb_hi = dev->dev->port->base_hi;
1052 	w_ctr(ppb, 0x0c);
1053 	modes = dev->dev->port->modes;
1054 
1055 	/* Mode detection works up the chain of speed
1056 	 * This avoids a nasty if-then-else-if-... tree
1057 	 */
1058 	dev->mode = PPA_NIBBLE;
1059 
1060 	if (modes & PARPORT_MODE_TRISTATE)
1061 		dev->mode = PPA_PS2;
1062 
1063 	if (modes & PARPORT_MODE_ECP) {
1064 		w_ecr(ppb_hi, 0x20);
1065 		dev->mode = PPA_PS2;
1066 	}
1067 	if ((modes & PARPORT_MODE_EPP) && (modes & PARPORT_MODE_ECP))
1068 		w_ecr(ppb_hi, 0x80);
1069 
1070 	/* Done configuration */
1071 
1072 	err = ppa_init(dev);
1073 	ppa_pb_release(dev);
1074 
1075 	if (err)
1076 		goto out1;
1077 
1078 	/* now the glue ... */
1079 	if (dev->mode == PPA_NIBBLE || dev->mode == PPA_PS2)
1080 		ports = 3;
1081 	else
1082 		ports = 8;
1083 
1084 	INIT_WORK(&dev->ppa_tq, ppa_interrupt, dev);
1085 
1086 	err = -ENOMEM;
1087 	host = scsi_host_alloc(&ppa_template, sizeof(ppa_struct *));
1088 	if (!host)
1089 		goto out1;
1090 	host->io_port = pb->base;
1091 	host->n_io_port = ports;
1092 	host->dma_channel = -1;
1093 	host->unique_id = pb->number;
1094 	*(ppa_struct **)&host->hostdata = dev;
1095 	dev->host = host;
1096 	list_add_tail(&dev->list, &ppa_hosts);
1097 	err = scsi_add_host(host, NULL);
1098 	if (err)
1099 		goto out2;
1100 	scsi_scan_host(host);
1101 	return 0;
1102 out2:
1103 	list_del_init(&dev->list);
1104 	scsi_host_put(host);
1105 out1:
1106 	parport_unregister_device(dev->dev);
1107 out:
1108 	kfree(dev);
1109 	return err;
1110 }
1111 
1112 static void ppa_attach(struct parport *pb)
1113 {
1114 	__ppa_attach(pb);
1115 }
1116 
1117 static void ppa_detach(struct parport *pb)
1118 {
1119 	ppa_struct *dev;
1120 	list_for_each_entry(dev, &ppa_hosts, list) {
1121 		if (dev->dev->port == pb) {
1122 			list_del_init(&dev->list);
1123 			scsi_remove_host(dev->host);
1124 			scsi_host_put(dev->host);
1125 			parport_unregister_device(dev->dev);
1126 			kfree(dev);
1127 			break;
1128 		}
1129 	}
1130 }
1131 
1132 static struct parport_driver ppa_driver = {
1133 	.name	= "ppa",
1134 	.attach	= ppa_attach,
1135 	.detach	= ppa_detach,
1136 };
1137 
1138 static int __init ppa_driver_init(void)
1139 {
1140 	printk("ppa: Version %s\n", PPA_VERSION);
1141 	return parport_register_driver(&ppa_driver);
1142 }
1143 
1144 static void __exit ppa_driver_exit(void)
1145 {
1146 	parport_unregister_driver(&ppa_driver);
1147 }
1148 
1149 module_init(ppa_driver_init);
1150 module_exit(ppa_driver_exit);
1151 MODULE_LICENSE("GPL");
1152