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