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