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