1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68#include <linux/module.h>
69#include <linux/errno.h>
70#include <linux/delay.h>
71#include <linux/pci.h>
72#include <linux/init.h>
73#include <linux/blkdev.h>
74#include <linux/spinlock.h>
75#include <linux/stat.h>
76#include <linux/kernel.h>
77#include <linux/proc_fs.h>
78#include <linux/string.h>
79#include <linux/interrupt.h>
80#include <linux/ioport.h>
81#include <linux/slab.h>
82#include <linux/jiffies.h>
83#include <linux/dma-mapping.h>
84#include <asm/io.h>
85
86#include <scsi/scsi.h>
87#include <scsi/scsi_cmnd.h>
88#include <scsi/scsi_device.h>
89#include <scsi/scsi_host.h>
90#include <scsi/scsi_tcq.h>
91
92#include "initio.h"
93
94#define SENSE_SIZE 14
95
96#define i91u_MAXQUEUE 2
97#define i91u_REVID "Initio INI-9X00U/UW SCSI device driver; Revision: 1.04a"
98
99#ifdef DEBUG_i91u
100static unsigned int i91u_debug = DEBUG_DEFAULT;
101#endif
102
103static int initio_tag_enable = 1;
104
105#ifdef DEBUG_i91u
106static int setup_debug = 0;
107#endif
108
109static void i91uSCBPost(u8 * pHcb, u8 * pScb);
110
111#define DEBUG_INTERRUPT 0
112#define DEBUG_QUEUE 0
113#define DEBUG_STATE 0
114#define INT_DISC 0
115
116
117static struct scsi_ctrl_blk *initio_find_busy_scb(struct initio_host * host, u16 tarlun);
118static struct scsi_ctrl_blk *initio_find_done_scb(struct initio_host * host);
119
120static int tulip_main(struct initio_host * host);
121
122static int initio_next_state(struct initio_host * host);
123static int initio_state_1(struct initio_host * host);
124static int initio_state_2(struct initio_host * host);
125static int initio_state_3(struct initio_host * host);
126static int initio_state_4(struct initio_host * host);
127static int initio_state_5(struct initio_host * host);
128static int initio_state_6(struct initio_host * host);
129static int initio_state_7(struct initio_host * host);
130static int initio_xfer_data_in(struct initio_host * host);
131static int initio_xfer_data_out(struct initio_host * host);
132static int initio_xpad_in(struct initio_host * host);
133static int initio_xpad_out(struct initio_host * host);
134static int initio_status_msg(struct initio_host * host);
135
136static int initio_msgin(struct initio_host * host);
137static int initio_msgin_sync(struct initio_host * host);
138static int initio_msgin_accept(struct initio_host * host);
139static int initio_msgout_reject(struct initio_host * host);
140static int initio_msgin_extend(struct initio_host * host);
141
142static int initio_msgout_ide(struct initio_host * host);
143static int initio_msgout_abort_targ(struct initio_host * host);
144static int initio_msgout_abort_tag(struct initio_host * host);
145
146static int initio_bus_device_reset(struct initio_host * host);
147static void initio_select_atn(struct initio_host * host, struct scsi_ctrl_blk * scb);
148static void initio_select_atn3(struct initio_host * host, struct scsi_ctrl_blk * scb);
149static void initio_select_atn_stop(struct initio_host * host, struct scsi_ctrl_blk * scb);
150static int int_initio_busfree(struct initio_host * host);
151static int int_initio_scsi_rst(struct initio_host * host);
152static int int_initio_bad_seq(struct initio_host * host);
153static int int_initio_resel(struct initio_host * host);
154static int initio_sync_done(struct initio_host * host);
155static int wdtr_done(struct initio_host * host);
156static int wait_tulip(struct initio_host * host);
157static int initio_wait_done_disc(struct initio_host * host);
158static int initio_wait_disc(struct initio_host * host);
159static void tulip_scsi(struct initio_host * host);
160static int initio_post_scsi_rst(struct initio_host * host);
161
162static void initio_se2_ew_en(unsigned long base);
163static void initio_se2_ew_ds(unsigned long base);
164static int initio_se2_rd_all(unsigned long base);
165static void initio_se2_update_all(unsigned long base);
166static void initio_read_eeprom(unsigned long base);
167
168
169
170static NVRAM i91unvram;
171static NVRAM *i91unvramp;
172
173static u8 i91udftNvRam[64] =
174{
175
176 0x25, 0xc9,
177 0x40,
178 0x01,
179
180 0x95,
181 0x00,
182 0x00,
183 0x01,
184 NBC1_DEFAULT,
185 0,
186 0,
187 0,
188
189 7,
190 NCC1_DEFAULT,
191 0,
192 0x10,
193
194 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
195 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
196 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
197 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
198
199
200 7,
201 NCC1_DEFAULT,
202 0,
203 0x10,
204
205 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
206 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
207 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
208 NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
209 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
210 0, 0};
211
212
213static u8 initio_rate_tbl[8] =
214{
215
216 12,
217 18,
218 25,
219 31,
220 37,
221 43,
222 50,
223 62
224};
225
226static void initio_do_pause(unsigned amount)
227{
228
229 unsigned long the_time = jiffies + amount;
230
231 while (time_before_eq(jiffies, the_time))
232 cpu_relax();
233}
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276static void initio_se2_instr(unsigned long base, u8 instr)
277{
278 int i;
279 u8 b;
280
281 outb(SE2CS | SE2DO, base + TUL_NVRAM);
282 udelay(30);
283 outb(SE2CS | SE2CLK | SE2DO, base + TUL_NVRAM);
284 udelay(30);
285
286 for (i = 0; i < 8; i++) {
287 if (instr & 0x80)
288 b = SE2CS | SE2DO;
289 else
290 b = SE2CS;
291 outb(b, base + TUL_NVRAM);
292 udelay(30);
293 outb(b | SE2CLK, base + TUL_NVRAM);
294 udelay(30);
295 instr <<= 1;
296 }
297 outb(SE2CS, base + TUL_NVRAM);
298 udelay(30);
299}
300
301
302
303
304
305
306
307
308void initio_se2_ew_en(unsigned long base)
309{
310 initio_se2_instr(base, 0x30);
311 outb(0, base + TUL_NVRAM);
312 udelay(30);
313}
314
315
316
317
318
319
320
321
322void initio_se2_ew_ds(unsigned long base)
323{
324 initio_se2_instr(base, 0);
325 outb(0, base + TUL_NVRAM);
326 udelay(30);
327}
328
329
330
331
332
333
334
335
336
337static u16 initio_se2_rd(unsigned long base, u8 addr)
338{
339 u8 instr, rb;
340 u16 val = 0;
341 int i;
342
343 instr = (u8) (addr | 0x80);
344 initio_se2_instr(base, instr);
345
346 for (i = 15; i >= 0; i--) {
347 outb(SE2CS | SE2CLK, base + TUL_NVRAM);
348 udelay(30);
349 outb(SE2CS, base + TUL_NVRAM);
350
351
352 rb = inb(base + TUL_NVRAM);
353 rb &= SE2DI;
354 val += (rb << i);
355 udelay(30);
356 }
357
358 outb(0, base + TUL_NVRAM);
359 udelay(30);
360 return val;
361}
362
363
364
365
366
367
368
369
370
371
372static void initio_se2_wr(unsigned long base, u8 addr, u16 val)
373{
374 u8 rb;
375 u8 instr;
376 int i;
377
378 instr = (u8) (addr | 0x40);
379 initio_se2_instr(base, instr);
380 for (i = 15; i >= 0; i--) {
381 if (val & 0x8000)
382 outb(SE2CS | SE2DO, base + TUL_NVRAM);
383 else
384 outb(SE2CS, base + TUL_NVRAM);
385 udelay(30);
386 outb(SE2CS | SE2CLK, base + TUL_NVRAM);
387 udelay(30);
388 val <<= 1;
389 }
390 outb(SE2CS, base + TUL_NVRAM);
391 udelay(30);
392 outb(0, base + TUL_NVRAM);
393 udelay(30);
394
395 outb(SE2CS, base + TUL_NVRAM);
396 udelay(30);
397
398 for (;;) {
399 outb(SE2CS | SE2CLK, base + TUL_NVRAM);
400 udelay(30);
401 outb(SE2CS, base + TUL_NVRAM);
402 udelay(30);
403 if ((rb = inb(base + TUL_NVRAM)) & SE2DI)
404 break;
405 }
406 outb(0, base + TUL_NVRAM);
407}
408
409
410
411
412
413
414
415
416
417static int initio_se2_rd_all(unsigned long base)
418{
419 int i;
420 u16 chksum = 0;
421 u16 *np;
422
423 i91unvramp = &i91unvram;
424 np = (u16 *) i91unvramp;
425 for (i = 0; i < 32; i++)
426 *np++ = initio_se2_rd(base, i);
427
428
429 if (i91unvramp->NVM_Signature != INI_SIGNATURE)
430 return -1;
431
432 np = (u16 *) i91unvramp;
433 for (i = 0; i < 31; i++)
434 chksum += *np++;
435 if (i91unvramp->NVM_CheckSum != chksum)
436 return -1;
437 return 1;
438}
439
440
441
442
443
444
445
446
447static void initio_se2_update_all(unsigned long base)
448{
449 int i;
450 u16 chksum = 0;
451 u16 *np, *np1;
452
453 i91unvramp = &i91unvram;
454
455 np = (u16 *) i91udftNvRam;
456 for (i = 0; i < 31; i++)
457 chksum += *np++;
458 *np = chksum;
459 initio_se2_ew_en(base);
460
461 np = (u16 *) i91udftNvRam;
462 np1 = (u16 *) i91unvramp;
463 for (i = 0; i < 32; i++, np++, np1++) {
464 if (*np != *np1)
465 initio_se2_wr(base, i, *np);
466 }
467 initio_se2_ew_ds(base);
468}
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483static void initio_read_eeprom(unsigned long base)
484{
485 u8 gctrl;
486
487 i91unvramp = &i91unvram;
488
489 gctrl = inb(base + TUL_GCTRL);
490 outb(gctrl | TUL_GCTRL_EEPROM_BIT, base + TUL_GCTRL);
491 if (initio_se2_rd_all(base) != 1) {
492 initio_se2_update_all(base);
493 initio_se2_rd_all(base);
494 }
495
496 gctrl = inb(base + TUL_GCTRL);
497 outb(gctrl & ~TUL_GCTRL_EEPROM_BIT, base + TUL_GCTRL);
498}
499
500
501
502
503
504
505
506
507static void initio_stop_bm(struct initio_host * host)
508{
509
510 if (inb(host->addr + TUL_XStatus) & XPEND) {
511 outb(TAX_X_ABT | TAX_X_CLR_FIFO, host->addr + TUL_XCmd);
512
513 while ((inb(host->addr + TUL_Int) & XABT) == 0)
514 cpu_relax();
515 }
516 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
517}
518
519
520
521
522
523
524
525
526
527static int initio_reset_scsi(struct initio_host * host, int seconds)
528{
529 outb(TSC_RST_BUS, host->addr + TUL_SCtrl0);
530
531 while (!((host->jsint = inb(host->addr + TUL_SInt)) & TSS_SCSIRST_INT))
532 cpu_relax();
533
534
535 outb(0, host->addr + TUL_SSignal);
536
537
538
539
540 initio_do_pause(seconds * HZ);
541
542 inb(host->addr + TUL_SInt);
543 return SCSI_RESET_SUCCESS;
544}
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559static void initio_init(struct initio_host * host, u8 *bios_addr)
560{
561 int i;
562 u8 *flags;
563 u8 *heads;
564
565
566 initio_read_eeprom(host->addr);
567 if (i91unvramp->NVM_SCSIInfo[0].NVM_NumOfTarg == 8)
568 host->max_tar = 8;
569 else
570 host->max_tar = 16;
571
572 host->config = i91unvramp->NVM_SCSIInfo[0].NVM_ChConfig1;
573
574 host->scsi_id = i91unvramp->NVM_SCSIInfo[0].NVM_ChSCSIID;
575 host->idmask = ~(1 << host->scsi_id);
576
577#ifdef CHK_PARITY
578
579 outb(inb(host->addr + TUL_PCMD) | 0x40, host->addr + TUL_PCMD);
580#endif
581
582
583 outb(0x1F, host->addr + TUL_Mask);
584
585 initio_stop_bm(host);
586
587 outb(TSC_RST_CHIP, host->addr + TUL_SCtrl0);
588
589
590 outb(host->scsi_id << 4, host->addr + TUL_SScsiId);
591
592
593
594 if (host->config & HCC_EN_PAR)
595 host->sconf1 = (TSC_INITDEFAULT | TSC_EN_SCSI_PAR);
596 else
597 host->sconf1 = (TSC_INITDEFAULT);
598 outb(host->sconf1, host->addr + TUL_SConfig);
599
600
601 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
602
603 outb(0, host->addr + TUL_SPeriod);
604
605
606 outb(153, host->addr + TUL_STimeOut);
607
608
609 outb((host->config & (HCC_ACT_TERM1 | HCC_ACT_TERM2)),
610 host->addr + TUL_XCtrl);
611 outb(((host->config & HCC_AUTO_TERM) >> 4) |
612 (inb(host->addr + TUL_GCTRL1) & 0xFE),
613 host->addr + TUL_GCTRL1);
614
615 for (i = 0,
616 flags = & (i91unvramp->NVM_SCSIInfo[0].NVM_Targ0Config),
617 heads = bios_addr + 0x180;
618 i < host->max_tar;
619 i++, flags++) {
620 host->targets[i].flags = *flags & ~(TCF_SYNC_DONE | TCF_WDTR_DONE);
621 if (host->targets[i].flags & TCF_EN_255)
622 host->targets[i].drv_flags = TCF_DRV_255_63;
623 else
624 host->targets[i].drv_flags = 0;
625 host->targets[i].js_period = 0;
626 host->targets[i].sconfig0 = host->sconf1;
627 host->targets[i].heads = *heads++;
628 if (host->targets[i].heads == 255)
629 host->targets[i].drv_flags = TCF_DRV_255_63;
630 else
631 host->targets[i].drv_flags = 0;
632 host->targets[i].sectors = *heads++;
633 host->targets[i].flags &= ~TCF_BUSY;
634 host->act_tags[i] = 0;
635 host->max_tags[i] = 0xFF;
636 }
637 printk("i91u: PCI Base=0x%04X, IRQ=%d, BIOS=0x%04X0, SCSI ID=%d\n",
638 host->addr, host->pci_dev->irq,
639 host->bios_addr, host->scsi_id);
640
641 if (host->config & HCC_SCSI_RESET) {
642 printk(KERN_INFO "i91u: Reset SCSI Bus ... \n");
643 initio_reset_scsi(host, 10);
644 }
645 outb(0x17, host->addr + TUL_SCFG1);
646 outb(0xE9, host->addr + TUL_SIntEnable);
647}
648
649
650
651
652
653
654
655
656static struct scsi_ctrl_blk *initio_alloc_scb(struct initio_host *host)
657{
658 struct scsi_ctrl_blk *scb;
659 unsigned long flags;
660
661 spin_lock_irqsave(&host->avail_lock, flags);
662 if ((scb = host->first_avail) != NULL) {
663#if DEBUG_QUEUE
664 printk("find scb at %p\n", scb);
665#endif
666 if ((host->first_avail = scb->next) == NULL)
667 host->last_avail = NULL;
668 scb->next = NULL;
669 scb->status = SCB_RENT;
670 }
671 spin_unlock_irqrestore(&host->avail_lock, flags);
672 return scb;
673}
674
675
676
677
678
679
680
681
682
683static void initio_release_scb(struct initio_host * host, struct scsi_ctrl_blk * cmnd)
684{
685 unsigned long flags;
686
687#if DEBUG_QUEUE
688 printk("Release SCB %p; ", cmnd);
689#endif
690 spin_lock_irqsave(&(host->avail_lock), flags);
691 cmnd->srb = NULL;
692 cmnd->status = 0;
693 cmnd->next = NULL;
694 if (host->last_avail != NULL) {
695 host->last_avail->next = cmnd;
696 host->last_avail = cmnd;
697 } else {
698 host->first_avail = cmnd;
699 host->last_avail = cmnd;
700 }
701 spin_unlock_irqrestore(&(host->avail_lock), flags);
702}
703
704
705static void initio_append_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp)
706{
707
708#if DEBUG_QUEUE
709 printk("Append pend SCB %p; ", scbp);
710#endif
711 scbp->status = SCB_PEND;
712 scbp->next = NULL;
713 if (host->last_pending != NULL) {
714 host->last_pending->next = scbp;
715 host->last_pending = scbp;
716 } else {
717 host->first_pending = scbp;
718 host->last_pending = scbp;
719 }
720}
721
722
723static void initio_push_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp)
724{
725
726#if DEBUG_QUEUE
727 printk("Push pend SCB %p; ", scbp);
728#endif
729 scbp->status = SCB_PEND;
730 if ((scbp->next = host->first_pending) != NULL) {
731 host->first_pending = scbp;
732 } else {
733 host->first_pending = scbp;
734 host->last_pending = scbp;
735 }
736}
737
738static struct scsi_ctrl_blk *initio_find_first_pend_scb(struct initio_host * host)
739{
740 struct scsi_ctrl_blk *first;
741
742
743 first = host->first_pending;
744 while (first != NULL) {
745 if (first->opcode != ExecSCSI)
746 return first;
747 if (first->tagmsg == 0) {
748 if ((host->act_tags[first->target] == 0) &&
749 !(host->targets[first->target].flags & TCF_BUSY))
750 return first;
751 } else {
752 if ((host->act_tags[first->target] >=
753 host->max_tags[first->target]) |
754 (host->targets[first->target].flags & TCF_BUSY)) {
755 first = first->next;
756 continue;
757 }
758 return first;
759 }
760 first = first->next;
761 }
762 return first;
763}
764
765static void initio_unlink_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scb)
766{
767 struct scsi_ctrl_blk *tmp, *prev;
768
769#if DEBUG_QUEUE
770 printk("unlink pend SCB %p; ", scb);
771#endif
772
773 prev = tmp = host->first_pending;
774 while (tmp != NULL) {
775 if (scb == tmp) {
776 if (tmp == host->first_pending) {
777 if ((host->first_pending = tmp->next) == NULL)
778 host->last_pending = NULL;
779 } else {
780 prev->next = tmp->next;
781 if (tmp == host->last_pending)
782 host->last_pending = prev;
783 }
784 tmp->next = NULL;
785 break;
786 }
787 prev = tmp;
788 tmp = tmp->next;
789 }
790}
791
792static void initio_append_busy_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp)
793{
794
795#if DEBUG_QUEUE
796 printk("append busy SCB %p; ", scbp);
797#endif
798 if (scbp->tagmsg)
799 host->act_tags[scbp->target]++;
800 else
801 host->targets[scbp->target].flags |= TCF_BUSY;
802 scbp->status = SCB_BUSY;
803 scbp->next = NULL;
804 if (host->last_busy != NULL) {
805 host->last_busy->next = scbp;
806 host->last_busy = scbp;
807 } else {
808 host->first_busy = scbp;
809 host->last_busy = scbp;
810 }
811}
812
813
814static struct scsi_ctrl_blk *initio_pop_busy_scb(struct initio_host * host)
815{
816 struct scsi_ctrl_blk *tmp;
817
818
819 if ((tmp = host->first_busy) != NULL) {
820 if ((host->first_busy = tmp->next) == NULL)
821 host->last_busy = NULL;
822 tmp->next = NULL;
823 if (tmp->tagmsg)
824 host->act_tags[tmp->target]--;
825 else
826 host->targets[tmp->target].flags &= ~TCF_BUSY;
827 }
828#if DEBUG_QUEUE
829 printk("Pop busy SCB %p; ", tmp);
830#endif
831 return tmp;
832}
833
834
835static void initio_unlink_busy_scb(struct initio_host * host, struct scsi_ctrl_blk * scb)
836{
837 struct scsi_ctrl_blk *tmp, *prev;
838
839#if DEBUG_QUEUE
840 printk("unlink busy SCB %p; ", scb);
841#endif
842
843 prev = tmp = host->first_busy;
844 while (tmp != NULL) {
845 if (scb == tmp) {
846 if (tmp == host->first_busy) {
847 if ((host->first_busy = tmp->next) == NULL)
848 host->last_busy = NULL;
849 } else {
850 prev->next = tmp->next;
851 if (tmp == host->last_busy)
852 host->last_busy = prev;
853 }
854 tmp->next = NULL;
855 if (tmp->tagmsg)
856 host->act_tags[tmp->target]--;
857 else
858 host->targets[tmp->target].flags &= ~TCF_BUSY;
859 break;
860 }
861 prev = tmp;
862 tmp = tmp->next;
863 }
864 return;
865}
866
867struct scsi_ctrl_blk *initio_find_busy_scb(struct initio_host * host, u16 tarlun)
868{
869 struct scsi_ctrl_blk *tmp, *prev;
870 u16 scbp_tarlun;
871
872
873 prev = tmp = host->first_busy;
874 while (tmp != NULL) {
875 scbp_tarlun = (tmp->lun << 8) | (tmp->target);
876 if (scbp_tarlun == tarlun) {
877 break;
878 }
879 prev = tmp;
880 tmp = tmp->next;
881 }
882#if DEBUG_QUEUE
883 printk("find busy SCB %p; ", tmp);
884#endif
885 return tmp;
886}
887
888static void initio_append_done_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp)
889{
890#if DEBUG_QUEUE
891 printk("append done SCB %p; ", scbp);
892#endif
893
894 scbp->status = SCB_DONE;
895 scbp->next = NULL;
896 if (host->last_done != NULL) {
897 host->last_done->next = scbp;
898 host->last_done = scbp;
899 } else {
900 host->first_done = scbp;
901 host->last_done = scbp;
902 }
903}
904
905struct scsi_ctrl_blk *initio_find_done_scb(struct initio_host * host)
906{
907 struct scsi_ctrl_blk *tmp;
908
909 if ((tmp = host->first_done) != NULL) {
910 if ((host->first_done = tmp->next) == NULL)
911 host->last_done = NULL;
912 tmp->next = NULL;
913 }
914#if DEBUG_QUEUE
915 printk("find done SCB %p; ",tmp);
916#endif
917 return tmp;
918}
919
920static int initio_abort_srb(struct initio_host * host, struct scsi_cmnd *srbp)
921{
922 unsigned long flags;
923 struct scsi_ctrl_blk *tmp, *prev;
924
925 spin_lock_irqsave(&host->semaph_lock, flags);
926
927 if ((host->semaph == 0) && (host->active == NULL)) {
928
929 outb(0x1F, host->addr + TUL_Mask);
930 spin_unlock_irqrestore(&host->semaph_lock, flags);
931
932 tulip_main(host);
933 spin_lock_irqsave(&host->semaph_lock, flags);
934 host->semaph = 1;
935 outb(0x0F, host->addr + TUL_Mask);
936 spin_unlock_irqrestore(&host->semaph_lock, flags);
937 return SCSI_ABORT_SNOOZE;
938 }
939 prev = tmp = host->first_pending;
940 while (tmp != NULL) {
941
942 if (tmp->srb == srbp) {
943 if (tmp == host->active) {
944 spin_unlock_irqrestore(&host->semaph_lock, flags);
945 return SCSI_ABORT_BUSY;
946 } else if (tmp == host->first_pending) {
947 if ((host->first_pending = tmp->next) == NULL)
948 host->last_pending = NULL;
949 } else {
950 prev->next = tmp->next;
951 if (tmp == host->last_pending)
952 host->last_pending = prev;
953 }
954 tmp->hastat = HOST_ABORTED;
955 tmp->flags |= SCF_DONE;
956 if (tmp->flags & SCF_POST)
957 (*tmp->post) ((u8 *) host, (u8 *) tmp);
958 spin_unlock_irqrestore(&host->semaph_lock, flags);
959 return SCSI_ABORT_SUCCESS;
960 }
961 prev = tmp;
962 tmp = tmp->next;
963 }
964
965 prev = tmp = host->first_busy;
966 while (tmp != NULL) {
967 if (tmp->srb == srbp) {
968 if (tmp == host->active) {
969 spin_unlock_irqrestore(&host->semaph_lock, flags);
970 return SCSI_ABORT_BUSY;
971 } else if (tmp->tagmsg == 0) {
972 spin_unlock_irqrestore(&host->semaph_lock, flags);
973 return SCSI_ABORT_BUSY;
974 } else {
975 host->act_tags[tmp->target]--;
976 if (tmp == host->first_busy) {
977 if ((host->first_busy = tmp->next) == NULL)
978 host->last_busy = NULL;
979 } else {
980 prev->next = tmp->next;
981 if (tmp == host->last_busy)
982 host->last_busy = prev;
983 }
984 tmp->next = NULL;
985
986
987 tmp->hastat = HOST_ABORTED;
988 tmp->flags |= SCF_DONE;
989 if (tmp->flags & SCF_POST)
990 (*tmp->post) ((u8 *) host, (u8 *) tmp);
991 spin_unlock_irqrestore(&host->semaph_lock, flags);
992 return SCSI_ABORT_SUCCESS;
993 }
994 }
995 prev = tmp;
996 tmp = tmp->next;
997 }
998 spin_unlock_irqrestore(&host->semaph_lock, flags);
999 return SCSI_ABORT_NOT_RUNNING;
1000}
1001
1002
1003static int initio_bad_seq(struct initio_host * host)
1004{
1005 struct scsi_ctrl_blk *scb;
1006
1007 printk("initio_bad_seg c=%d\n", host->index);
1008
1009 if ((scb = host->active) != NULL) {
1010 initio_unlink_busy_scb(host, scb);
1011 scb->hastat = HOST_BAD_PHAS;
1012 scb->tastat = 0;
1013 initio_append_done_scb(host, scb);
1014 }
1015 initio_stop_bm(host);
1016 initio_reset_scsi(host, 8);
1017 return initio_post_scsi_rst(host);
1018}
1019
1020
1021
1022static void initio_exec_scb(struct initio_host * host, struct scsi_ctrl_blk * scb)
1023{
1024 unsigned long flags;
1025
1026 scb->mode = 0;
1027
1028 scb->sgidx = 0;
1029 scb->sgmax = scb->sglen;
1030
1031 spin_lock_irqsave(&host->semaph_lock, flags);
1032
1033 initio_append_pend_scb(host, scb);
1034
1035
1036 if (host->semaph == 1) {
1037
1038 outb(0x1F, host->addr + TUL_Mask);
1039 host->semaph = 0;
1040 spin_unlock_irqrestore(&host->semaph_lock, flags);
1041
1042 tulip_main(host);
1043
1044 spin_lock_irqsave(&host->semaph_lock, flags);
1045 host->semaph = 1;
1046 outb(0x0F, host->addr + TUL_Mask);
1047 }
1048 spin_unlock_irqrestore(&host->semaph_lock, flags);
1049 return;
1050}
1051
1052
1053static int initio_isr(struct initio_host * host)
1054{
1055 if (inb(host->addr + TUL_Int) & TSS_INT_PENDING) {
1056 if (host->semaph == 1) {
1057 outb(0x1F, host->addr + TUL_Mask);
1058
1059 host->semaph = 0;
1060
1061 tulip_main(host);
1062
1063 host->semaph = 1;
1064 outb(0x0F, host->addr + TUL_Mask);
1065 return 1;
1066 }
1067 }
1068 return 0;
1069}
1070
1071static int tulip_main(struct initio_host * host)
1072{
1073 struct scsi_ctrl_blk *scb;
1074
1075 for (;;) {
1076 tulip_scsi(host);
1077
1078
1079 while ((scb = initio_find_done_scb(host)) != NULL) {
1080 if (scb->tastat == INI_QUEUE_FULL) {
1081 host->max_tags[scb->target] =
1082 host->act_tags[scb->target] - 1;
1083 scb->tastat = 0;
1084 initio_append_pend_scb(host, scb);
1085 continue;
1086 }
1087 if (!(scb->mode & SCM_RSENS)) {
1088 if (scb->tastat == 2) {
1089
1090
1091
1092 if (scb->flags & SCF_SENSE) {
1093 u8 len;
1094 len = scb->senselen;
1095 if (len == 0)
1096 len = 1;
1097 scb->buflen = scb->senselen;
1098 scb->bufptr = scb->senseptr;
1099 scb->flags &= ~(SCF_SG | SCF_DIR);
1100
1101
1102 scb->mode = SCM_RSENS;
1103 scb->ident &= 0xBF;
1104 scb->tagmsg = 0;
1105 scb->tastat = 0;
1106 scb->cdblen = 6;
1107 scb->cdb[0] = SCSICMD_RequestSense;
1108 scb->cdb[1] = 0;
1109 scb->cdb[2] = 0;
1110 scb->cdb[3] = 0;
1111 scb->cdb[4] = len;
1112 scb->cdb[5] = 0;
1113 initio_push_pend_scb(host, scb);
1114 break;
1115 }
1116 }
1117 } else {
1118
1119 if (scb->tastat == 2) {
1120
1121 scb->hastat = HOST_BAD_PHAS;
1122 }
1123 scb->tastat = 2;
1124 }
1125 scb->flags |= SCF_DONE;
1126 if (scb->flags & SCF_POST) {
1127
1128 (*scb->post) ((u8 *) host, (u8 *) scb);
1129 }
1130 }
1131
1132 if (inb(host->addr + TUL_SStatus0) & TSS_INT_PENDING)
1133 continue;
1134 if (host->active)
1135 return 1;
1136
1137 if (initio_find_first_pend_scb(host) == NULL)
1138 return 1;
1139 }
1140
1141}
1142
1143static void tulip_scsi(struct initio_host * host)
1144{
1145 struct scsi_ctrl_blk *scb;
1146 struct target_control *active_tc;
1147
1148
1149 if ((host->jsstatus0 = inb(host->addr + TUL_SStatus0)) & TSS_INT_PENDING) {
1150 host->phase = host->jsstatus0 & TSS_PH_MASK;
1151 host->jsstatus1 = inb(host->addr + TUL_SStatus1);
1152 host->jsint = inb(host->addr + TUL_SInt);
1153 if (host->jsint & TSS_SCSIRST_INT) {
1154 int_initio_scsi_rst(host);
1155 return;
1156 }
1157 if (host->jsint & TSS_RESEL_INT) {
1158 if (int_initio_resel(host) == 0)
1159 initio_next_state(host);
1160 return;
1161 }
1162 if (host->jsint & TSS_SEL_TIMEOUT) {
1163 int_initio_busfree(host);
1164 return;
1165 }
1166 if (host->jsint & TSS_DISC_INT) {
1167 int_initio_busfree(host);
1168 return;
1169 }
1170 if (host->jsint & (TSS_FUNC_COMP | TSS_BUS_SERV)) {
1171 if ((scb = host->active) != NULL)
1172 initio_next_state(host);
1173 return;
1174 }
1175 }
1176 if (host->active != NULL)
1177 return;
1178
1179 if ((scb = initio_find_first_pend_scb(host)) == NULL)
1180 return;
1181
1182
1183 outb((host->scsi_id << 4) | (scb->target & 0x0F),
1184 host->addr + TUL_SScsiId);
1185 if (scb->opcode == ExecSCSI) {
1186 active_tc = &host->targets[scb->target];
1187
1188 if (scb->tagmsg)
1189 active_tc->drv_flags |= TCF_DRV_EN_TAG;
1190 else
1191 active_tc->drv_flags &= ~TCF_DRV_EN_TAG;
1192
1193 outb(active_tc->js_period, host->addr + TUL_SPeriod);
1194 if ((active_tc->flags & (TCF_WDTR_DONE | TCF_NO_WDTR)) == 0) {
1195 initio_select_atn_stop(host, scb);
1196 } else {
1197 if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) {
1198 initio_select_atn_stop(host, scb);
1199 } else {
1200 if (scb->tagmsg)
1201 initio_select_atn3(host, scb);
1202 else
1203 initio_select_atn(host, scb);
1204 }
1205 }
1206 if (scb->flags & SCF_POLL) {
1207 while (wait_tulip(host) != -1) {
1208 if (initio_next_state(host) == -1)
1209 break;
1210 }
1211 }
1212 } else if (scb->opcode == BusDevRst) {
1213 initio_select_atn_stop(host, scb);
1214 scb->next_state = 8;
1215 if (scb->flags & SCF_POLL) {
1216 while (wait_tulip(host) != -1) {
1217 if (initio_next_state(host) == -1)
1218 break;
1219 }
1220 }
1221 } else if (scb->opcode == AbortCmd) {
1222 if (initio_abort_srb(host, scb->srb) != 0) {
1223 initio_unlink_pend_scb(host, scb);
1224 initio_release_scb(host, scb);
1225 } else {
1226 scb->opcode = BusDevRst;
1227 initio_select_atn_stop(host, scb);
1228 scb->next_state = 8;
1229 }
1230 } else {
1231 initio_unlink_pend_scb(host, scb);
1232 scb->hastat = 0x16;
1233 initio_append_done_scb(host, scb);
1234 }
1235 return;
1236}
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248static int initio_next_state(struct initio_host * host)
1249{
1250 int next;
1251
1252 next = host->active->next_state;
1253 for (;;) {
1254 switch (next) {
1255 case 1:
1256 next = initio_state_1(host);
1257 break;
1258 case 2:
1259 next = initio_state_2(host);
1260 break;
1261 case 3:
1262 next = initio_state_3(host);
1263 break;
1264 case 4:
1265 next = initio_state_4(host);
1266 break;
1267 case 5:
1268 next = initio_state_5(host);
1269 break;
1270 case 6:
1271 next = initio_state_6(host);
1272 break;
1273 case 7:
1274 next = initio_state_7(host);
1275 break;
1276 case 8:
1277 return initio_bus_device_reset(host);
1278 default:
1279 return initio_bad_seq(host);
1280 }
1281 if (next <= 0)
1282 return next;
1283 }
1284}
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294static int initio_state_1(struct initio_host * host)
1295{
1296 struct scsi_ctrl_blk *scb = host->active;
1297 struct target_control *active_tc = host->active_tc;
1298#if DEBUG_STATE
1299 printk("-s1-");
1300#endif
1301
1302
1303 initio_unlink_pend_scb(host, scb);
1304 initio_append_busy_scb(host, scb);
1305
1306 outb(active_tc->sconfig0, host->addr + TUL_SConfig );
1307
1308 if (host->phase == MSG_OUT) {
1309 outb(TSC_EN_BUS_IN | TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
1310 outb(scb->ident, host->addr + TUL_SFifo);
1311
1312 if (scb->tagmsg) {
1313 outb(scb->tagmsg, host->addr + TUL_SFifo);
1314 outb(scb->tagid, host->addr + TUL_SFifo);
1315 }
1316 if ((active_tc->flags & (TCF_WDTR_DONE | TCF_NO_WDTR)) == 0) {
1317 active_tc->flags |= TCF_WDTR_DONE;
1318 outb(MSG_EXTEND, host->addr + TUL_SFifo);
1319 outb(2, host->addr + TUL_SFifo);
1320 outb(3, host->addr + TUL_SFifo);
1321 outb(1, host->addr + TUL_SFifo);
1322 } else if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) {
1323 active_tc->flags |= TCF_SYNC_DONE;
1324 outb(MSG_EXTEND, host->addr + TUL_SFifo);
1325 outb(3, host->addr + TUL_SFifo);
1326 outb(1, host->addr + TUL_SFifo);
1327 outb(initio_rate_tbl[active_tc->flags & TCF_SCSI_RATE], host->addr + TUL_SFifo);
1328 outb(MAX_OFFSET, host->addr + TUL_SFifo);
1329 }
1330 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1331 if (wait_tulip(host) == -1)
1332 return -1;
1333 }
1334 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1335 outb((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)), host->addr + TUL_SSignal);
1336
1337 return 3;
1338}
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349static int initio_state_2(struct initio_host * host)
1350{
1351 struct scsi_ctrl_blk *scb = host->active;
1352 struct target_control *active_tc = host->active_tc;
1353#if DEBUG_STATE
1354 printk("-s2-");
1355#endif
1356
1357 initio_unlink_pend_scb(host, scb);
1358 initio_append_busy_scb(host, scb);
1359
1360 outb(active_tc->sconfig0, host->addr + TUL_SConfig);
1361
1362 if (host->jsstatus1 & TSS_CMD_PH_CMP)
1363 return 4;
1364
1365 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1366 outb((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)), host->addr + TUL_SSignal);
1367
1368 return 3;
1369}
1370
1371
1372
1373
1374
1375
1376
1377
1378static int initio_state_3(struct initio_host * host)
1379{
1380 struct scsi_ctrl_blk *scb = host->active;
1381 struct target_control *active_tc = host->active_tc;
1382 int i;
1383
1384#if DEBUG_STATE
1385 printk("-s3-");
1386#endif
1387 for (;;) {
1388 switch (host->phase) {
1389 case CMD_OUT:
1390 for (i = 0; i < (int) scb->cdblen; i++)
1391 outb(scb->cdb[i], host->addr + TUL_SFifo);
1392 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1393 if (wait_tulip(host) == -1)
1394 return -1;
1395 if (host->phase == CMD_OUT)
1396 return initio_bad_seq(host);
1397 return 4;
1398
1399 case MSG_IN:
1400 scb->next_state = 3;
1401 if (initio_msgin(host) == -1)
1402 return -1;
1403 break;
1404
1405 case STATUS_IN:
1406 if (initio_status_msg(host) == -1)
1407 return -1;
1408 break;
1409
1410 case MSG_OUT:
1411 if (active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) {
1412 outb(MSG_NOP, host->addr + TUL_SFifo);
1413 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1414 if (wait_tulip(host) == -1)
1415 return -1;
1416 } else {
1417 active_tc->flags |= TCF_SYNC_DONE;
1418
1419 outb(MSG_EXTEND, host->addr + TUL_SFifo);
1420 outb(3, host->addr + TUL_SFifo);
1421 outb(1, host->addr + TUL_SFifo);
1422 outb(initio_rate_tbl[active_tc->flags & TCF_SCSI_RATE], host->addr + TUL_SFifo);
1423 outb(MAX_OFFSET, host->addr + TUL_SFifo);
1424 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1425 if (wait_tulip(host) == -1)
1426 return -1;
1427 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1428 outb(inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7), host->addr + TUL_SSignal);
1429
1430 }
1431 break;
1432 default:
1433 return initio_bad_seq(host);
1434 }
1435 }
1436}
1437
1438
1439
1440
1441
1442
1443
1444
1445static int initio_state_4(struct initio_host * host)
1446{
1447 struct scsi_ctrl_blk *scb = host->active;
1448
1449#if DEBUG_STATE
1450 printk("-s4-");
1451#endif
1452 if ((scb->flags & SCF_DIR) == SCF_NO_XF) {
1453 return 6;
1454 }
1455 for (;;) {
1456 if (scb->buflen == 0)
1457 return 6;
1458
1459 switch (host->phase) {
1460
1461 case STATUS_IN:
1462 if ((scb->flags & SCF_DIR) != 0)
1463 scb->hastat = HOST_DO_DU;
1464 if ((initio_status_msg(host)) == -1)
1465 return -1;
1466 break;
1467
1468 case MSG_IN:
1469 scb->next_state = 0x4;
1470 if (initio_msgin(host) == -1)
1471 return -1;
1472 break;
1473
1474 case MSG_OUT:
1475 if (host->jsstatus0 & TSS_PAR_ERROR) {
1476 scb->buflen = 0;
1477 scb->hastat = HOST_DO_DU;
1478 if (initio_msgout_ide(host) == -1)
1479 return -1;
1480 return 6;
1481 } else {
1482 outb(MSG_NOP, host->addr + TUL_SFifo);
1483 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1484 if (wait_tulip(host) == -1)
1485 return -1;
1486 }
1487 break;
1488
1489 case DATA_IN:
1490 return initio_xfer_data_in(host);
1491
1492 case DATA_OUT:
1493 return initio_xfer_data_out(host);
1494
1495 default:
1496 return initio_bad_seq(host);
1497 }
1498 }
1499}
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509static int initio_state_5(struct initio_host * host)
1510{
1511 struct scsi_ctrl_blk *scb = host->active;
1512 long cnt, xcnt;
1513
1514#if DEBUG_STATE
1515 printk("-s5-");
1516#endif
1517
1518 cnt = inl(host->addr + TUL_SCnt0) & 0x0FFFFFF;
1519
1520 if (inb(host->addr + TUL_XCmd) & 0x20) {
1521
1522
1523 if (host->jsstatus0 & TSS_PAR_ERROR)
1524 scb->hastat = HOST_DO_DU;
1525 if (inb(host->addr + TUL_XStatus) & XPEND) {
1526
1527 outb(inb(host->addr + TUL_XCtrl) | 0x80, host->addr + TUL_XCtrl);
1528
1529 while (inb(host->addr + TUL_XStatus) & XPEND)
1530 cpu_relax();
1531 }
1532 } else {
1533
1534 if ((inb(host->addr + TUL_SStatus1) & TSS_XFER_CMP) == 0) {
1535 if (host->active_tc->js_period & TSC_WIDE_SCSI)
1536 cnt += (inb(host->addr + TUL_SFifoCnt) & 0x1F) << 1;
1537 else
1538 cnt += (inb(host->addr + TUL_SFifoCnt) & 0x1F);
1539 }
1540 if (inb(host->addr + TUL_XStatus) & XPEND) {
1541 outb(TAX_X_ABT, host->addr + TUL_XCmd);
1542
1543 while ((inb(host->addr + TUL_Int) & XABT) == 0)
1544 cpu_relax();
1545 }
1546 if ((cnt == 1) && (host->phase == DATA_OUT)) {
1547 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1548 if (wait_tulip(host) == -1)
1549 return -1;
1550 cnt = 0;
1551 } else {
1552 if ((inb(host->addr + TUL_SStatus1) & TSS_XFER_CMP) == 0)
1553 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1554 }
1555 }
1556 if (cnt == 0) {
1557 scb->buflen = 0;
1558 return 6;
1559 }
1560
1561 xcnt = (long) scb->buflen - cnt;
1562 scb->buflen = (u32) cnt;
1563 if (scb->flags & SCF_SG) {
1564 struct sg_entry *sgp;
1565 unsigned long i;
1566
1567 sgp = &scb->sglist[scb->sgidx];
1568 for (i = scb->sgidx; i < scb->sgmax; sgp++, i++) {
1569 xcnt -= (long) sgp->len;
1570 if (xcnt < 0) {
1571 xcnt += (long) sgp->len;
1572 sgp->data += (u32) xcnt;
1573 sgp->len -= (u32) xcnt;
1574 scb->bufptr += ((u32) (i - scb->sgidx) << 3);
1575
1576 scb->sglen = (u8) (scb->sgmax - i);
1577
1578 scb->sgidx = (u16) i;
1579
1580 return 4;
1581 }
1582
1583 }
1584 return 6;
1585 } else {
1586 scb->bufptr += (u32) xcnt;
1587 }
1588 return 4;
1589}
1590
1591
1592
1593
1594
1595
1596
1597
1598static int initio_state_6(struct initio_host * host)
1599{
1600 struct scsi_ctrl_blk *scb = host->active;
1601
1602#if DEBUG_STATE
1603 printk("-s6-");
1604#endif
1605 for (;;) {
1606 switch (host->phase) {
1607 case STATUS_IN:
1608 if ((initio_status_msg(host)) == -1)
1609 return -1;
1610 break;
1611
1612 case MSG_IN:
1613 scb->next_state = 6;
1614 if ((initio_msgin(host)) == -1)
1615 return -1;
1616 break;
1617
1618 case MSG_OUT:
1619 outb(MSG_NOP, host->addr + TUL_SFifo);
1620 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1621 if (wait_tulip(host) == -1)
1622 return -1;
1623 break;
1624
1625 case DATA_IN:
1626 return initio_xpad_in(host);
1627
1628 case DATA_OUT:
1629 return initio_xpad_out(host);
1630
1631 default:
1632 return initio_bad_seq(host);
1633 }
1634 }
1635}
1636
1637
1638
1639
1640
1641
1642
1643int initio_state_7(struct initio_host * host)
1644{
1645 int cnt, i;
1646
1647#if DEBUG_STATE
1648 printk("-s7-");
1649#endif
1650
1651 cnt = inb(host->addr + TUL_SFifoCnt) & 0x1F;
1652 if (cnt) {
1653 for (i = 0; i < cnt; i++)
1654 inb(host->addr + TUL_SFifo);
1655 }
1656 switch (host->phase) {
1657 case DATA_IN:
1658 case DATA_OUT:
1659 return initio_bad_seq(host);
1660 default:
1661 return 6;
1662 }
1663}
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673static int initio_xfer_data_in(struct initio_host * host)
1674{
1675 struct scsi_ctrl_blk *scb = host->active;
1676
1677 if ((scb->flags & SCF_DIR) == SCF_DOUT)
1678 return 6;
1679
1680 outl(scb->buflen, host->addr + TUL_SCnt0);
1681 outb(TSC_XF_DMA_IN, host->addr + TUL_SCmd);
1682
1683 if (scb->flags & SCF_SG) {
1684 outl(((u32) scb->sglen) << 3, host->addr + TUL_XCntH);
1685 outl(scb->bufptr, host->addr + TUL_XAddH);
1686 outb(TAX_SG_IN, host->addr + TUL_XCmd);
1687 } else {
1688 outl(scb->buflen, host->addr + TUL_XCntH);
1689 outl(scb->bufptr, host->addr + TUL_XAddH);
1690 outb(TAX_X_IN, host->addr + TUL_XCmd);
1691 }
1692 scb->next_state = 0x5;
1693 return 0;
1694}
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705static int initio_xfer_data_out(struct initio_host * host)
1706{
1707 struct scsi_ctrl_blk *scb = host->active;
1708
1709 if ((scb->flags & SCF_DIR) == SCF_DIN)
1710 return 6;
1711
1712 outl(scb->buflen, host->addr + TUL_SCnt0);
1713 outb(TSC_XF_DMA_OUT, host->addr + TUL_SCmd);
1714
1715 if (scb->flags & SCF_SG) {
1716 outl(((u32) scb->sglen) << 3, host->addr + TUL_XCntH);
1717 outl(scb->bufptr, host->addr + TUL_XAddH);
1718 outb(TAX_SG_OUT, host->addr + TUL_XCmd);
1719 } else {
1720 outl(scb->buflen, host->addr + TUL_XCntH);
1721 outl(scb->bufptr, host->addr + TUL_XAddH);
1722 outb(TAX_X_OUT, host->addr + TUL_XCmd);
1723 }
1724
1725 scb->next_state = 0x5;
1726 return 0;
1727}
1728
1729int initio_xpad_in(struct initio_host * host)
1730{
1731 struct scsi_ctrl_blk *scb = host->active;
1732 struct target_control *active_tc = host->active_tc;
1733
1734 if ((scb->flags & SCF_DIR) != SCF_NO_DCHK)
1735 scb->hastat = HOST_DO_DU;
1736 for (;;) {
1737 if (active_tc->js_period & TSC_WIDE_SCSI)
1738 outl(2, host->addr + TUL_SCnt0);
1739 else
1740 outl(1, host->addr + TUL_SCnt0);
1741
1742 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
1743 if (wait_tulip(host) == -1)
1744 return -1;
1745 if (host->phase != DATA_IN) {
1746 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1747 return 6;
1748 }
1749 inb(host->addr + TUL_SFifo);
1750 }
1751}
1752
1753int initio_xpad_out(struct initio_host * host)
1754{
1755 struct scsi_ctrl_blk *scb = host->active;
1756 struct target_control *active_tc = host->active_tc;
1757
1758 if ((scb->flags & SCF_DIR) != SCF_NO_DCHK)
1759 scb->hastat = HOST_DO_DU;
1760 for (;;) {
1761 if (active_tc->js_period & TSC_WIDE_SCSI)
1762 outl(2, host->addr + TUL_SCnt0);
1763 else
1764 outl(1, host->addr + TUL_SCnt0);
1765
1766 outb(0, host->addr + TUL_SFifo);
1767 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1768 if ((wait_tulip(host)) == -1)
1769 return -1;
1770 if (host->phase != DATA_OUT) {
1771 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
1772 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1773 return 6;
1774 }
1775 }
1776}
1777
1778int initio_status_msg(struct initio_host * host)
1779{
1780 struct scsi_ctrl_blk *scb = host->active;
1781 u8 msg;
1782
1783 outb(TSC_CMD_COMP, host->addr + TUL_SCmd);
1784 if (wait_tulip(host) == -1)
1785 return -1;
1786
1787
1788 scb->tastat = inb(host->addr + TUL_SFifo);
1789
1790 if (host->phase == MSG_OUT) {
1791 if (host->jsstatus0 & TSS_PAR_ERROR)
1792 outb(MSG_PARITY, host->addr + TUL_SFifo);
1793 else
1794 outb(MSG_NOP, host->addr + TUL_SFifo);
1795 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1796 return wait_tulip(host);
1797 }
1798 if (host->phase == MSG_IN) {
1799 msg = inb(host->addr + TUL_SFifo);
1800 if (host->jsstatus0 & TSS_PAR_ERROR) {
1801 if ((initio_msgin_accept(host)) == -1)
1802 return -1;
1803 if (host->phase != MSG_OUT)
1804 return initio_bad_seq(host);
1805 outb(MSG_PARITY, host->addr + TUL_SFifo);
1806 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1807 return wait_tulip(host);
1808 }
1809 if (msg == 0) {
1810
1811 if ((scb->tastat & 0x18) == 0x10)
1812 return initio_bad_seq(host);
1813 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1814 outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd);
1815 return initio_wait_done_disc(host);
1816
1817 }
1818 if (msg == MSG_LINK_COMP || msg == MSG_LINK_FLAG) {
1819 if ((scb->tastat & 0x18) == 0x10)
1820 return initio_msgin_accept(host);
1821 }
1822 }
1823 return initio_bad_seq(host);
1824}
1825
1826
1827
1828int int_initio_busfree(struct initio_host * host)
1829{
1830 struct scsi_ctrl_blk *scb = host->active;
1831
1832 if (scb != NULL) {
1833 if (scb->status & SCB_SELECT) {
1834 initio_unlink_pend_scb(host, scb);
1835 scb->hastat = HOST_SEL_TOUT;
1836 initio_append_done_scb(host, scb);
1837 } else {
1838 initio_unlink_busy_scb(host, scb);
1839 scb->hastat = HOST_BUS_FREE;
1840 initio_append_done_scb(host, scb);
1841 }
1842 host->active = NULL;
1843 host->active_tc = NULL;
1844 }
1845 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1846 outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
1847 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
1848 return -1;
1849}
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862static int int_initio_scsi_rst(struct initio_host * host)
1863{
1864 struct scsi_ctrl_blk *scb;
1865 int i;
1866
1867
1868 if (inb(host->addr + TUL_XStatus) & 0x01) {
1869 outb(TAX_X_ABT | TAX_X_CLR_FIFO, host->addr + TUL_XCmd);
1870
1871 while ((inb(host->addr + TUL_Int) & 0x04) == 0)
1872 cpu_relax();
1873 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1874 }
1875
1876 while ((scb = initio_pop_busy_scb(host)) != NULL) {
1877 scb->hastat = HOST_BAD_PHAS;
1878 initio_append_done_scb(host, scb);
1879 }
1880 host->active = NULL;
1881 host->active_tc = NULL;
1882
1883
1884 for (i = 0; i < host->max_tar; i++)
1885 host->targets[i].flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE);
1886 return -1;
1887}
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898int int_initio_resel(struct initio_host * host)
1899{
1900 struct scsi_ctrl_blk *scb;
1901 struct target_control *active_tc;
1902 u8 tag, msg = 0;
1903 u8 tar, lun;
1904
1905 if ((scb = host->active) != NULL) {
1906
1907 if (scb->status & SCB_SELECT)
1908 scb->status &= ~SCB_SELECT;
1909 host->active = NULL;
1910 }
1911
1912 tar = inb(host->addr + TUL_SBusId);
1913
1914 lun = inb(host->addr + TUL_SIdent) & 0x0F;
1915
1916 active_tc = &host->targets[tar];
1917 host->active_tc = active_tc;
1918 outb(active_tc->sconfig0, host->addr + TUL_SConfig);
1919 outb(active_tc->js_period, host->addr + TUL_SPeriod);
1920
1921
1922 if (active_tc->drv_flags & TCF_DRV_EN_TAG) {
1923 if ((initio_msgin_accept(host)) == -1)
1924 return -1;
1925 if (host->phase != MSG_IN)
1926 goto no_tag;
1927 outl(1, host->addr + TUL_SCnt0);
1928 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
1929 if (wait_tulip(host) == -1)
1930 return -1;
1931 msg = inb(host->addr + TUL_SFifo);
1932
1933 if (msg < MSG_STAG || msg > MSG_OTAG)
1934 goto no_tag;
1935
1936 if (initio_msgin_accept(host) == -1)
1937 return -1;
1938
1939 if (host->phase != MSG_IN)
1940 goto no_tag;
1941
1942 outl(1, host->addr + TUL_SCnt0);
1943 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
1944 if (wait_tulip(host) == -1)
1945 return -1;
1946 tag = inb(host->addr + TUL_SFifo);
1947 scb = host->scb + tag;
1948 if (scb->target != tar || scb->lun != lun) {
1949 return initio_msgout_abort_tag(host);
1950 }
1951 if (scb->status != SCB_BUSY) {
1952 return initio_msgout_abort_tag(host);
1953 }
1954 host->active = scb;
1955 if ((initio_msgin_accept(host)) == -1)
1956 return -1;
1957 } else {
1958 no_tag:
1959 if ((scb = initio_find_busy_scb(host, tar | (lun << 8))) == NULL) {
1960 return initio_msgout_abort_targ(host);
1961 }
1962 host->active = scb;
1963 if (!(active_tc->drv_flags & TCF_DRV_EN_TAG)) {
1964 if ((initio_msgin_accept(host)) == -1)
1965 return -1;
1966 }
1967 }
1968 return 0;
1969}
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979static int int_initio_bad_seq(struct initio_host * host)
1980{
1981 struct scsi_ctrl_blk *scb;
1982 int i;
1983
1984 initio_reset_scsi(host, 10);
1985
1986 while ((scb = initio_pop_busy_scb(host)) != NULL) {
1987 scb->hastat = HOST_BAD_PHAS;
1988 initio_append_done_scb(host, scb);
1989 }
1990 for (i = 0; i < host->max_tar; i++)
1991 host->targets[i].flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE);
1992 return -1;
1993}
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004static int initio_msgout_abort_targ(struct initio_host * host)
2005{
2006
2007 outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2008 if (initio_msgin_accept(host) == -1)
2009 return -1;
2010 if (host->phase != MSG_OUT)
2011 return initio_bad_seq(host);
2012
2013 outb(MSG_ABORT, host->addr + TUL_SFifo);
2014 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2015
2016 return initio_wait_disc(host);
2017}
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027static int initio_msgout_abort_tag(struct initio_host * host)
2028{
2029
2030 outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2031 if (initio_msgin_accept(host) == -1)
2032 return -1;
2033 if (host->phase != MSG_OUT)
2034 return initio_bad_seq(host);
2035
2036 outb(MSG_ABORT_TAG, host->addr + TUL_SFifo);
2037 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2038
2039 return initio_wait_disc(host);
2040
2041}
2042
2043
2044
2045
2046
2047
2048
2049static int initio_msgin(struct initio_host * host)
2050{
2051 struct target_control *active_tc;
2052
2053 for (;;) {
2054 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
2055
2056 outl(1, host->addr + TUL_SCnt0);
2057 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
2058 if (wait_tulip(host) == -1)
2059 return -1;
2060
2061 switch (inb(host->addr + TUL_SFifo)) {
2062 case MSG_DISC:
2063 outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd);
2064 return initio_wait_disc(host);
2065 case MSG_SDP:
2066 case MSG_RESTORE:
2067 case MSG_NOP:
2068 initio_msgin_accept(host);
2069 break;
2070 case MSG_REJ:
2071 outb((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)),
2072 host->addr + TUL_SSignal);
2073 active_tc = host->active_tc;
2074 if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0)
2075 outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN),
2076 host->addr + TUL_SSignal);
2077 initio_msgin_accept(host);
2078 break;
2079 case MSG_EXTEND:
2080 initio_msgin_extend(host);
2081 break;
2082 case MSG_IGNOREWIDE:
2083 initio_msgin_accept(host);
2084 break;
2085 case MSG_COMP:
2086 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
2087 outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd);
2088 return initio_wait_done_disc(host);
2089 default:
2090 initio_msgout_reject(host);
2091 break;
2092 }
2093 if (host->phase != MSG_IN)
2094 return host->phase;
2095 }
2096
2097}
2098
2099static int initio_msgout_reject(struct initio_host * host)
2100{
2101 outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2102
2103 if (initio_msgin_accept(host) == -1)
2104 return -1;
2105
2106 if (host->phase == MSG_OUT) {
2107 outb(MSG_REJ, host->addr + TUL_SFifo);
2108 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2109 return wait_tulip(host);
2110 }
2111 return host->phase;
2112}
2113
2114static int initio_msgout_ide(struct initio_host * host)
2115{
2116 outb(MSG_IDE, host->addr + TUL_SFifo);
2117 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2118 return wait_tulip(host);
2119}
2120
2121static int initio_msgin_extend(struct initio_host * host)
2122{
2123 u8 len, idx;
2124
2125 if (initio_msgin_accept(host) != MSG_IN)
2126 return host->phase;
2127
2128
2129 outl(1, host->addr + TUL_SCnt0);
2130 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
2131 if (wait_tulip(host) == -1)
2132 return -1;
2133
2134 len = inb(host->addr + TUL_SFifo);
2135 host->msg[0] = len;
2136 for (idx = 1; len != 0; len--) {
2137
2138 if ((initio_msgin_accept(host)) != MSG_IN)
2139 return host->phase;
2140 outl(1, host->addr + TUL_SCnt0);
2141 outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
2142 if (wait_tulip(host) == -1)
2143 return -1;
2144 host->msg[idx++] = inb(host->addr + TUL_SFifo);
2145 }
2146 if (host->msg[1] == 1) {
2147 u8 r;
2148 if (host->msg[0] != 3)
2149 return initio_msgout_reject(host);
2150 if (host->active_tc->flags & TCF_NO_SYNC_NEGO) {
2151 host->msg[3] = 0;
2152 } else {
2153 if (initio_msgin_sync(host) == 0 &&
2154 (host->active_tc->flags & TCF_SYNC_DONE)) {
2155 initio_sync_done(host);
2156 return initio_msgin_accept(host);
2157 }
2158 }
2159
2160 r = inb(host->addr + TUL_SSignal);
2161 outb((r & (TSC_SET_ACK | 7)) | TSC_SET_ATN,
2162 host->addr + TUL_SSignal);
2163 if (initio_msgin_accept(host) != MSG_OUT)
2164 return host->phase;
2165
2166 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
2167
2168 initio_sync_done(host);
2169
2170 outb(MSG_EXTEND, host->addr + TUL_SFifo);
2171 outb(3, host->addr + TUL_SFifo);
2172 outb(1, host->addr + TUL_SFifo);
2173 outb(host->msg[2], host->addr + TUL_SFifo);
2174 outb(host->msg[3], host->addr + TUL_SFifo);
2175 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2176 return wait_tulip(host);
2177 }
2178 if (host->msg[0] != 2 || host->msg[1] != 3)
2179 return initio_msgout_reject(host);
2180
2181 if (host->active_tc->flags & TCF_NO_WDTR) {
2182 host->msg[2] = 0;
2183 } else {
2184 if (host->msg[2] > 2)
2185 return initio_msgout_reject(host);
2186 if (host->msg[2] == 2) {
2187 host->msg[2] = 1;
2188 } else {
2189 if ((host->active_tc->flags & TCF_NO_WDTR) == 0) {
2190 wdtr_done(host);
2191 if ((host->active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0)
2192 outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2193 return initio_msgin_accept(host);
2194 }
2195 }
2196 }
2197 outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2198
2199 if (initio_msgin_accept(host) != MSG_OUT)
2200 return host->phase;
2201
2202 outb(MSG_EXTEND, host->addr + TUL_SFifo);
2203 outb(2, host->addr + TUL_SFifo);
2204 outb(3, host->addr + TUL_SFifo);
2205 outb(host->msg[2], host->addr + TUL_SFifo);
2206 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2207 return wait_tulip(host);
2208}
2209
2210static int initio_msgin_sync(struct initio_host * host)
2211{
2212 char default_period;
2213
2214 default_period = initio_rate_tbl[host->active_tc->flags & TCF_SCSI_RATE];
2215 if (host->msg[3] > MAX_OFFSET) {
2216 host->msg[3] = MAX_OFFSET;
2217 if (host->msg[2] < default_period) {
2218 host->msg[2] = default_period;
2219 return 1;
2220 }
2221 if (host->msg[2] >= 59)
2222 host->msg[3] = 0;
2223 return 1;
2224 }
2225
2226 if (host->msg[3] == 0) {
2227 return 0;
2228 }
2229 if (host->msg[2] < default_period) {
2230 host->msg[2] = default_period;
2231 return 1;
2232 }
2233 if (host->msg[2] >= 59) {
2234 host->msg[3] = 0;
2235 return 1;
2236 }
2237 return 0;
2238}
2239
2240static int wdtr_done(struct initio_host * host)
2241{
2242 host->active_tc->flags &= ~TCF_SYNC_DONE;
2243 host->active_tc->flags |= TCF_WDTR_DONE;
2244
2245 host->active_tc->js_period = 0;
2246 if (host->msg[2])
2247 host->active_tc->js_period |= TSC_WIDE_SCSI;
2248 host->active_tc->sconfig0 &= ~TSC_ALT_PERIOD;
2249 outb(host->active_tc->sconfig0, host->addr + TUL_SConfig);
2250 outb(host->active_tc->js_period, host->addr + TUL_SPeriod);
2251
2252 return 1;
2253}
2254
2255static int initio_sync_done(struct initio_host * host)
2256{
2257 int i;
2258
2259 host->active_tc->flags |= TCF_SYNC_DONE;
2260
2261 if (host->msg[3]) {
2262 host->active_tc->js_period |= host->msg[3];
2263 for (i = 0; i < 8; i++) {
2264 if (initio_rate_tbl[i] >= host->msg[2])
2265 break;
2266 }
2267 host->active_tc->js_period |= (i << 4);
2268 host->active_tc->sconfig0 |= TSC_ALT_PERIOD;
2269 }
2270 outb(host->active_tc->sconfig0, host->addr + TUL_SConfig);
2271 outb(host->active_tc->js_period, host->addr + TUL_SPeriod);
2272
2273 return -1;
2274}
2275
2276
2277static int initio_post_scsi_rst(struct initio_host * host)
2278{
2279 struct scsi_ctrl_blk *scb;
2280 struct target_control *active_tc;
2281 int i;
2282
2283 host->active = NULL;
2284 host->active_tc = NULL;
2285 host->flags = 0;
2286
2287 while ((scb = initio_pop_busy_scb(host)) != NULL) {
2288 scb->hastat = HOST_BAD_PHAS;
2289 initio_append_done_scb(host, scb);
2290 }
2291
2292 active_tc = &host->targets[0];
2293 for (i = 0; i < host->max_tar; active_tc++, i++) {
2294 active_tc->flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE);
2295
2296 active_tc->js_period = 0;
2297 active_tc->sconfig0 = host->sconf1;
2298 host->act_tags[0] = 0;
2299 host->targets[i].flags &= ~TCF_BUSY;
2300 }
2301
2302 return -1;
2303}
2304
2305static void initio_select_atn_stop(struct initio_host * host, struct scsi_ctrl_blk * scb)
2306{
2307 scb->status |= SCB_SELECT;
2308 scb->next_state = 0x1;
2309 host->active = scb;
2310 host->active_tc = &host->targets[scb->target];
2311 outb(TSC_SELATNSTOP, host->addr + TUL_SCmd);
2312}
2313
2314
2315static void initio_select_atn(struct initio_host * host, struct scsi_ctrl_blk * scb)
2316{
2317 int i;
2318
2319 scb->status |= SCB_SELECT;
2320 scb->next_state = 0x2;
2321
2322 outb(scb->ident, host->addr + TUL_SFifo);
2323 for (i = 0; i < (int) scb->cdblen; i++)
2324 outb(scb->cdb[i], host->addr + TUL_SFifo);
2325 host->active_tc = &host->targets[scb->target];
2326 host->active = scb;
2327 outb(TSC_SEL_ATN, host->addr + TUL_SCmd);
2328}
2329
2330static void initio_select_atn3(struct initio_host * host, struct scsi_ctrl_blk * scb)
2331{
2332 int i;
2333
2334 scb->status |= SCB_SELECT;
2335 scb->next_state = 0x2;
2336
2337 outb(scb->ident, host->addr + TUL_SFifo);
2338 outb(scb->tagmsg, host->addr + TUL_SFifo);
2339 outb(scb->tagid, host->addr + TUL_SFifo);
2340 for (i = 0; i < scb->cdblen; i++)
2341 outb(scb->cdb[i], host->addr + TUL_SFifo);
2342 host->active_tc = &host->targets[scb->target];
2343 host->active = scb;
2344 outb(TSC_SEL_ATN3, host->addr + TUL_SCmd);
2345}
2346
2347
2348
2349
2350
2351
2352
2353
2354int initio_bus_device_reset(struct initio_host * host)
2355{
2356 struct scsi_ctrl_blk *scb = host->active;
2357 struct target_control *active_tc = host->active_tc;
2358 struct scsi_ctrl_blk *tmp, *prev;
2359 u8 tar;
2360
2361 if (host->phase != MSG_OUT)
2362 return int_initio_bad_seq(host);
2363
2364 initio_unlink_pend_scb(host, scb);
2365 initio_release_scb(host, scb);
2366
2367
2368 tar = scb->target;
2369 active_tc->flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE | TCF_BUSY);
2370
2371
2372
2373 prev = tmp = host->first_busy;
2374 while (tmp != NULL) {
2375 if (tmp->target == tar) {
2376
2377 if (tmp == host->first_busy) {
2378 if ((host->first_busy = tmp->next) == NULL)
2379 host->last_busy = NULL;
2380 } else {
2381 prev->next = tmp->next;
2382 if (tmp == host->last_busy)
2383 host->last_busy = prev;
2384 }
2385 tmp->hastat = HOST_ABORTED;
2386 initio_append_done_scb(host, tmp);
2387 }
2388
2389 else {
2390 prev = tmp;
2391 }
2392 tmp = tmp->next;
2393 }
2394 outb(MSG_DEVRST, host->addr + TUL_SFifo);
2395 outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2396 return initio_wait_disc(host);
2397
2398}
2399
2400static int initio_msgin_accept(struct initio_host * host)
2401{
2402 outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd);
2403 return wait_tulip(host);
2404}
2405
2406static int wait_tulip(struct initio_host * host)
2407{
2408
2409 while (!((host->jsstatus0 = inb(host->addr + TUL_SStatus0))
2410 & TSS_INT_PENDING))
2411 cpu_relax();
2412
2413 host->jsint = inb(host->addr + TUL_SInt);
2414 host->phase = host->jsstatus0 & TSS_PH_MASK;
2415 host->jsstatus1 = inb(host->addr + TUL_SStatus1);
2416
2417 if (host->jsint & TSS_RESEL_INT)
2418 return int_initio_resel(host);
2419 if (host->jsint & TSS_SEL_TIMEOUT)
2420 return int_initio_busfree(host);
2421 if (host->jsint & TSS_SCSIRST_INT)
2422 return int_initio_scsi_rst(host);
2423
2424 if (host->jsint & TSS_DISC_INT) {
2425 if (host->flags & HCF_EXPECT_DONE_DISC) {
2426 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
2427 initio_unlink_busy_scb(host, host->active);
2428 host->active->hastat = 0;
2429 initio_append_done_scb(host, host->active);
2430 host->active = NULL;
2431 host->active_tc = NULL;
2432 host->flags &= ~HCF_EXPECT_DONE_DISC;
2433 outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
2434 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
2435 return -1;
2436 }
2437 if (host->flags & HCF_EXPECT_DISC) {
2438 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
2439 host->active = NULL;
2440 host->active_tc = NULL;
2441 host->flags &= ~HCF_EXPECT_DISC;
2442 outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
2443 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
2444 return -1;
2445 }
2446 return int_initio_busfree(host);
2447 }
2448
2449 if (host->jsint & (TSS_FUNC_COMP | TSS_BUS_SERV))
2450 return host->phase;
2451 return host->phase;
2452}
2453
2454static int initio_wait_disc(struct initio_host * host)
2455{
2456 while (!((host->jsstatus0 = inb(host->addr + TUL_SStatus0)) & TSS_INT_PENDING))
2457 cpu_relax();
2458
2459 host->jsint = inb(host->addr + TUL_SInt);
2460
2461 if (host->jsint & TSS_SCSIRST_INT)
2462 return int_initio_scsi_rst(host);
2463 if (host->jsint & TSS_DISC_INT) {
2464 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
2465 outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
2466 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
2467 host->active = NULL;
2468 return -1;
2469 }
2470 return initio_bad_seq(host);
2471}
2472
2473static int initio_wait_done_disc(struct initio_host * host)
2474{
2475 while (!((host->jsstatus0 = inb(host->addr + TUL_SStatus0))
2476 & TSS_INT_PENDING))
2477 cpu_relax();
2478
2479 host->jsint = inb(host->addr + TUL_SInt);
2480
2481 if (host->jsint & TSS_SCSIRST_INT)
2482 return int_initio_scsi_rst(host);
2483 if (host->jsint & TSS_DISC_INT) {
2484 outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
2485 outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
2486 outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
2487 initio_unlink_busy_scb(host, host->active);
2488
2489 initio_append_done_scb(host, host->active);
2490 host->active = NULL;
2491 return -1;
2492 }
2493 return initio_bad_seq(host);
2494}
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505static irqreturn_t i91u_intr(int irqno, void *dev_id)
2506{
2507 struct Scsi_Host *dev = dev_id;
2508 unsigned long flags;
2509 int r;
2510
2511 spin_lock_irqsave(dev->host_lock, flags);
2512 r = initio_isr((struct initio_host *)dev->hostdata);
2513 spin_unlock_irqrestore(dev->host_lock, flags);
2514 if (r)
2515 return IRQ_HANDLED;
2516 else
2517 return IRQ_NONE;
2518}
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532static void initio_build_scb(struct initio_host * host, struct scsi_ctrl_blk * cblk, struct scsi_cmnd * cmnd)
2533{
2534 struct scatterlist *sglist;
2535 struct sg_entry *sg;
2536 int i, nseg;
2537 long total_len;
2538 dma_addr_t dma_addr;
2539
2540
2541 cblk->post = i91uSCBPost;
2542 cblk->srb = cmnd;
2543 cblk->opcode = ExecSCSI;
2544 cblk->flags = SCF_POST;
2545 cblk->target = cmnd->device->id;
2546 cblk->lun = cmnd->device->lun;
2547 cblk->ident = cmnd->device->lun | DISC_ALLOW;
2548
2549 cblk->flags |= SCF_SENSE;
2550
2551
2552 dma_addr = dma_map_single(&host->pci_dev->dev, cmnd->sense_buffer,
2553 SENSE_SIZE, DMA_FROM_DEVICE);
2554 cblk->senseptr = (u32)dma_addr;
2555 cblk->senselen = SENSE_SIZE;
2556 cmnd->SCp.ptr = (char *)(unsigned long)dma_addr;
2557 cblk->cdblen = cmnd->cmd_len;
2558
2559
2560 cblk->hastat = 0;
2561 cblk->tastat = 0;
2562
2563 memcpy(cblk->cdb, cmnd->cmnd, cmnd->cmd_len);
2564
2565
2566 if (cmnd->device->tagged_supported) {
2567 cblk->tagmsg = SIMPLE_QUEUE_TAG;
2568 } else {
2569 cblk->tagmsg = 0;
2570 }
2571
2572
2573 nseg = scsi_dma_map(cmnd);
2574 BUG_ON(nseg < 0);
2575 if (nseg) {
2576 dma_addr = dma_map_single(&host->pci_dev->dev, &cblk->sglist[0],
2577 sizeof(struct sg_entry) * TOTAL_SG_ENTRY,
2578 DMA_BIDIRECTIONAL);
2579 cblk->bufptr = (u32)dma_addr;
2580 cmnd->SCp.dma_handle = dma_addr;
2581
2582 cblk->sglen = nseg;
2583
2584 cblk->flags |= SCF_SG;
2585 total_len = 0;
2586 sg = &cblk->sglist[0];
2587 scsi_for_each_sg(cmnd, sglist, cblk->sglen, i) {
2588 sg->data = cpu_to_le32((u32)sg_dma_address(sglist));
2589 sg->len = cpu_to_le32((u32)sg_dma_len(sglist));
2590 total_len += sg_dma_len(sglist);
2591 ++sg;
2592 }
2593
2594 cblk->buflen = (scsi_bufflen(cmnd) > total_len) ?
2595 total_len : scsi_bufflen(cmnd);
2596 } else {
2597 cblk->buflen = 0;
2598 cblk->sglen = 0;
2599 }
2600}
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612static int i91u_queuecommand_lck(struct scsi_cmnd *cmd,
2613 void (*done)(struct scsi_cmnd *))
2614{
2615 struct initio_host *host = (struct initio_host *) cmd->device->host->hostdata;
2616 struct scsi_ctrl_blk *cmnd;
2617
2618 cmd->scsi_done = done;
2619
2620 cmnd = initio_alloc_scb(host);
2621 if (!cmnd)
2622 return SCSI_MLQUEUE_HOST_BUSY;
2623
2624 initio_build_scb(host, cmnd, cmd);
2625 initio_exec_scb(host, cmnd);
2626 return 0;
2627}
2628
2629static DEF_SCSI_QCMD(i91u_queuecommand)
2630
2631
2632
2633
2634
2635
2636
2637
2638static int i91u_bus_reset(struct scsi_cmnd * cmnd)
2639{
2640 struct initio_host *host;
2641
2642 host = (struct initio_host *) cmnd->device->host->hostdata;
2643
2644 spin_lock_irq(cmnd->device->host->host_lock);
2645 initio_reset_scsi(host, 0);
2646 spin_unlock_irq(cmnd->device->host->host_lock);
2647
2648 return SUCCESS;
2649}
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664static int i91u_biosparam(struct scsi_device *sdev, struct block_device *dev,
2665 sector_t capacity, int *info_array)
2666{
2667 struct initio_host *host;
2668 struct target_control *tc;
2669
2670 host = (struct initio_host *) sdev->host->hostdata;
2671 tc = &host->targets[sdev->id];
2672
2673 if (tc->heads) {
2674 info_array[0] = tc->heads;
2675 info_array[1] = tc->sectors;
2676 info_array[2] = (unsigned long)capacity / tc->heads / tc->sectors;
2677 } else {
2678 if (tc->drv_flags & TCF_DRV_255_63) {
2679 info_array[0] = 255;
2680 info_array[1] = 63;
2681 info_array[2] = (unsigned long)capacity / 255 / 63;
2682 } else {
2683 info_array[0] = 64;
2684 info_array[1] = 32;
2685 info_array[2] = (unsigned long)capacity >> 11;
2686 }
2687 }
2688
2689#if defined(DEBUG_BIOSPARAM)
2690 if (i91u_debug & debug_biosparam) {
2691 printk("bios geometry: head=%d, sec=%d, cyl=%d\n",
2692 info_array[0], info_array[1], info_array[2]);
2693 printk("WARNING: check, if the bios geometry is correct.\n");
2694 }
2695#endif
2696
2697 return 0;
2698}
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709static void i91u_unmap_scb(struct pci_dev *pci_dev, struct scsi_cmnd *cmnd)
2710{
2711
2712 if (cmnd->SCp.ptr) {
2713 dma_unmap_single(&pci_dev->dev,
2714 (dma_addr_t)((unsigned long)cmnd->SCp.ptr),
2715 SENSE_SIZE, DMA_FROM_DEVICE);
2716 cmnd->SCp.ptr = NULL;
2717 }
2718
2719
2720 if (scsi_sg_count(cmnd)) {
2721 dma_unmap_single(&pci_dev->dev, cmnd->SCp.dma_handle,
2722 sizeof(struct sg_entry) * TOTAL_SG_ENTRY,
2723 DMA_BIDIRECTIONAL);
2724
2725 scsi_dma_unmap(cmnd);
2726 }
2727}
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738static void i91uSCBPost(u8 * host_mem, u8 * cblk_mem)
2739{
2740 struct scsi_cmnd *cmnd;
2741 struct initio_host *host;
2742 struct scsi_ctrl_blk *cblk;
2743
2744 host = (struct initio_host *) host_mem;
2745 cblk = (struct scsi_ctrl_blk *) cblk_mem;
2746 if ((cmnd = cblk->srb) == NULL) {
2747 printk(KERN_ERR "i91uSCBPost: SRB pointer is empty\n");
2748 WARN_ON(1);
2749 initio_release_scb(host, cblk);
2750 return;
2751 }
2752
2753
2754
2755
2756 switch (cblk->hastat) {
2757 case 0x0:
2758 case 0xa:
2759 case 0xb:
2760 cblk->hastat = 0;
2761 break;
2762
2763 case 0x11:
2764
2765 cblk->hastat = DID_TIME_OUT;
2766 break;
2767
2768 case 0x14:
2769
2770
2771
2772 cblk->hastat = DID_RESET;
2773 break;
2774
2775 case 0x1a:
2776 cblk->hastat = DID_ABORT;
2777 break;
2778
2779 case 0x12:
2780
2781
2782 case 0x13:
2783 case 0x16:
2784
2785 default:
2786 printk("ini9100u: %x %x\n", cblk->hastat, cblk->tastat);
2787 cblk->hastat = DID_ERROR;
2788 break;
2789 }
2790
2791 cmnd->result = cblk->tastat | (cblk->hastat << 16);
2792 i91u_unmap_scb(host->pci_dev, cmnd);
2793 cmnd->scsi_done(cmnd);
2794 initio_release_scb(host, cblk);
2795}
2796
2797static struct scsi_host_template initio_template = {
2798 .proc_name = "INI9100U",
2799 .name = "Initio INI-9X00U/UW SCSI device driver",
2800 .queuecommand = i91u_queuecommand,
2801 .eh_bus_reset_handler = i91u_bus_reset,
2802 .bios_param = i91u_biosparam,
2803 .can_queue = MAX_TARGETS * i91u_MAXQUEUE,
2804 .this_id = 1,
2805 .sg_tablesize = SG_ALL,
2806};
2807
2808static int initio_probe_one(struct pci_dev *pdev,
2809 const struct pci_device_id *id)
2810{
2811 struct Scsi_Host *shost;
2812 struct initio_host *host;
2813 u32 reg;
2814 u16 bios_seg;
2815 struct scsi_ctrl_blk *scb, *tmp, *prev = NULL ;
2816 int num_scb, i, error;
2817
2818 error = pci_enable_device(pdev);
2819 if (error)
2820 return error;
2821
2822 pci_read_config_dword(pdev, 0x44, (u32 *) & reg);
2823 bios_seg = (u16) (reg & 0xFF);
2824 if (((reg & 0xFF00) >> 8) == 0xFF)
2825 reg = 0;
2826 bios_seg = (bios_seg << 8) + ((u16) ((reg & 0xFF00) >> 8));
2827
2828 if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
2829 printk(KERN_WARNING "i91u: Could not set 32 bit DMA mask\n");
2830 error = -ENODEV;
2831 goto out_disable_device;
2832 }
2833 shost = scsi_host_alloc(&initio_template, sizeof(struct initio_host));
2834 if (!shost) {
2835 printk(KERN_WARNING "initio: Could not allocate host structure.\n");
2836 error = -ENOMEM;
2837 goto out_disable_device;
2838 }
2839 host = (struct initio_host *)shost->hostdata;
2840 memset(host, 0, sizeof(struct initio_host));
2841 host->addr = pci_resource_start(pdev, 0);
2842 host->bios_addr = bios_seg;
2843
2844 if (!request_region(host->addr, 256, "i91u")) {
2845 printk(KERN_WARNING "initio: I/O port range 0x%x is busy.\n", host->addr);
2846 error = -ENODEV;
2847 goto out_host_put;
2848 }
2849
2850 if (initio_tag_enable)
2851 num_scb = MAX_TARGETS * i91u_MAXQUEUE;
2852 else
2853 num_scb = MAX_TARGETS + 3;
2854
2855 for (; num_scb >= MAX_TARGETS + 3; num_scb--) {
2856 i = num_scb * sizeof(struct scsi_ctrl_blk);
2857 if ((scb = kzalloc(i, GFP_DMA)) != NULL)
2858 break;
2859 }
2860
2861 if (!scb) {
2862 printk(KERN_WARNING "initio: Cannot allocate SCB array.\n");
2863 error = -ENOMEM;
2864 goto out_release_region;
2865 }
2866
2867 host->pci_dev = pdev;
2868
2869 host->semaph = 1;
2870 spin_lock_init(&host->semaph_lock);
2871 host->num_scbs = num_scb;
2872 host->scb = scb;
2873 host->next_pending = scb;
2874 host->next_avail = scb;
2875 for (i = 0, tmp = scb; i < num_scb; i++, tmp++) {
2876 tmp->tagid = i;
2877 if (i != 0)
2878 prev->next = tmp;
2879 prev = tmp;
2880 }
2881 prev->next = NULL;
2882 host->scb_end = tmp;
2883 host->first_avail = scb;
2884 host->last_avail = prev;
2885 spin_lock_init(&host->avail_lock);
2886
2887 initio_init(host, phys_to_virt(((u32)bios_seg << 4)));
2888
2889 host->jsstatus0 = 0;
2890
2891 shost->io_port = host->addr;
2892 shost->n_io_port = 0xff;
2893 shost->can_queue = num_scb;
2894 shost->unique_id = host->addr;
2895 shost->max_id = host->max_tar;
2896 shost->max_lun = 32;
2897 shost->irq = pdev->irq;
2898 shost->this_id = host->scsi_id;
2899 shost->base = host->addr;
2900 shost->sg_tablesize = TOTAL_SG_ENTRY;
2901
2902 error = request_irq(pdev->irq, i91u_intr, IRQF_SHARED, "i91u", shost);
2903 if (error < 0) {
2904 printk(KERN_WARNING "initio: Unable to request IRQ %d\n", pdev->irq);
2905 goto out_free_scbs;
2906 }
2907
2908 pci_set_drvdata(pdev, shost);
2909
2910 error = scsi_add_host(shost, &pdev->dev);
2911 if (error)
2912 goto out_free_irq;
2913 scsi_scan_host(shost);
2914 return 0;
2915out_free_irq:
2916 free_irq(pdev->irq, shost);
2917out_free_scbs:
2918 kfree(host->scb);
2919out_release_region:
2920 release_region(host->addr, 256);
2921out_host_put:
2922 scsi_host_put(shost);
2923out_disable_device:
2924 pci_disable_device(pdev);
2925 return error;
2926}
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936static void initio_remove_one(struct pci_dev *pdev)
2937{
2938 struct Scsi_Host *host = pci_get_drvdata(pdev);
2939 struct initio_host *s = (struct initio_host *)host->hostdata;
2940 scsi_remove_host(host);
2941 free_irq(pdev->irq, host);
2942 release_region(s->addr, 256);
2943 scsi_host_put(host);
2944 pci_disable_device(pdev);
2945}
2946
2947MODULE_LICENSE("GPL");
2948
2949static struct pci_device_id initio_pci_tbl[] = {
2950 {PCI_VENDOR_ID_INIT, 0x9500, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2951 {PCI_VENDOR_ID_INIT, 0x9400, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2952 {PCI_VENDOR_ID_INIT, 0x9401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2953 {PCI_VENDOR_ID_INIT, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2954 {PCI_VENDOR_ID_DOMEX, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2955 {0,}
2956};
2957MODULE_DEVICE_TABLE(pci, initio_pci_tbl);
2958
2959static struct pci_driver initio_pci_driver = {
2960 .name = "initio",
2961 .id_table = initio_pci_tbl,
2962 .probe = initio_probe_one,
2963 .remove = initio_remove_one,
2964};
2965
2966static int __init initio_init_driver(void)
2967{
2968 return pci_register_driver(&initio_pci_driver);
2969}
2970
2971static void __exit initio_exit_driver(void)
2972{
2973 pci_unregister_driver(&initio_pci_driver);
2974}
2975
2976MODULE_DESCRIPTION("Initio INI-9X00U/UW SCSI device driver");
2977MODULE_AUTHOR("Initio Corporation");
2978MODULE_LICENSE("GPL");
2979
2980module_init(initio_init_driver);
2981module_exit(initio_exit_driver);
2982
