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