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