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 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
 137static 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);
 168static inline void
 169imm_fail_func(imm_struct *dev, int error_code)
 170#else
 171static inline void
 172imm_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 */
 189static 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
 234static 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 */
 285static 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 */
 297static 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
 314static 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
 329static 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
 348static 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
 364static 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
 413static 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
 468static 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
 538static 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
 552static void imm_disconnect(imm_struct *dev)
 553{
 554	imm_cpp(dev->base, 0x30);	/* Disconnect all devices */
 555}
 556
 557static 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
 606static 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
 617static 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 */
 637static 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 */
 735static 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
 793static 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
 929static 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
 952static 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 */
 960static 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
 974static 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
 994static 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
1006static 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
1022static 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 */
1112static 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
1118static 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
1140static LIST_HEAD(imm_hosts);
1141
1142static 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
1236out2:
1237	list_del_init(&dev->list);
1238	scsi_host_put(host);
1239out1:
1240	parport_unregister_device(dev->dev);
1241out:
1242	kfree(dev);
1243	return err;
1244}
1245
1246static void imm_attach(struct parport *pb)
1247{
1248	__imm_attach(pb);
1249}
1250
1251static 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
1266static struct parport_driver imm_driver = {
1267	.name	= "imm",
1268	.attach	= imm_attach,
1269	.detach	= imm_detach,
1270};
1271
1272static int __init imm_driver_init(void)
1273{
1274	printk("imm: Version %s\n", IMM_VERSION);
1275	return parport_register_driver(&imm_driver);
1276}
1277
1278static void __exit imm_driver_exit(void)
1279{
1280	parport_unregister_driver(&imm_driver);
1281}
1282
1283module_init(imm_driver_init);
1284module_exit(imm_driver_exit);
1285
1286MODULE_LICENSE("GPL");