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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238#include <linux/module.h>
239#include <asm/irq.h>
240#include <linux/io.h>
241#include <linux/blkdev.h>
242#include <asm/system.h>
243#include <linux/completion.h>
244#include <linux/errno.h>
245#include <linux/string.h>
246#include <linux/wait.h>
247#include <linux/ioport.h>
248#include <linux/delay.h>
249#include <linux/proc_fs.h>
250#include <linux/interrupt.h>
251#include <linux/init.h>
252#include <linux/kernel.h>
253#include <linux/isapnp.h>
254#include <linux/spinlock.h>
255#include <linux/workqueue.h>
256#include <linux/list.h>
257#include <scsi/scsicam.h>
258
259#include "scsi.h"
260#include <scsi/scsi_dbg.h>
261#include <scsi/scsi_host.h>
262#include <scsi/scsi_transport_spi.h>
263#include "aha152x.h"
264
265static LIST_HEAD(aha152x_host_list);
266
267
268
269
270
271#if defined(PCMCIA) || defined(MODULE)
272#if !defined(AUTOCONF)
273#define AUTOCONF
274#endif
275#endif
276
277#if !defined(AUTOCONF) && !defined(SETUP0)
278#error define AUTOCONF or SETUP0
279#endif
280
281#if defined(AHA152X_DEBUG)
282#define DEBUG_DEFAULT debug_eh
283
284#define DPRINTK(when,msgs...) \
285 do { if(HOSTDATA(shpnt)->debug & (when)) printk(msgs); } while(0)
286
287#define DO_LOCK(flags) \
288 do { \
289 if(spin_is_locked(&QLOCK)) { \
290 DPRINTK(debug_intr, DEBUG_LEAD "(%s:%d) already locked at %s:%d\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \
291 } \
292 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locking\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
293 spin_lock_irqsave(&QLOCK,flags); \
294 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
295 QLOCKER=__FUNCTION__; \
296 QLOCKERL=__LINE__; \
297 } while(0)
298
299#define DO_UNLOCK(flags) \
300 do { \
301 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocking (locked at %s:%d)\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \
302 spin_unlock_irqrestore(&QLOCK,flags); \
303 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
304 QLOCKER="(not locked)"; \
305 QLOCKERL=0; \
306 } while(0)
307
308#else
309#define DPRINTK(when,msgs...)
310#define DO_LOCK(flags) spin_lock_irqsave(&QLOCK,flags)
311#define DO_UNLOCK(flags) spin_unlock_irqrestore(&QLOCK,flags)
312#endif
313
314#define LEAD "(scsi%d:%d:%d) "
315#define WARN_LEAD KERN_WARNING LEAD
316#define INFO_LEAD KERN_INFO LEAD
317#define NOTE_LEAD KERN_NOTICE LEAD
318#define ERR_LEAD KERN_ERR LEAD
319#define DEBUG_LEAD KERN_DEBUG LEAD
320#define CMDINFO(cmd) \
321 (cmd) ? ((cmd)->device->host->host_no) : -1, \
322 (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
323 (cmd) ? ((cmd)->device->lun & 0x07) : -1
324
325static inline void
326CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
327{
328 scsi_set_resid(cmd, scsi_get_resid(cmd) + inc);
329}
330
331#define DELAY_DEFAULT 1000
332
333#if defined(PCMCIA)
334#define IRQ_MIN 0
335#define IRQ_MAX 16
336#else
337#define IRQ_MIN 9
338#if defined(__PPC)
339#define IRQ_MAX (NR_IRQS-1)
340#else
341#define IRQ_MAX 12
342#endif
343#endif
344
345enum {
346 not_issued = 0x0001,
347 selecting = 0x0002,
348 identified = 0x0004,
349 disconnected = 0x0008,
350 completed = 0x0010,
351 aborted = 0x0020,
352 resetted = 0x0040,
353 spiordy = 0x0080,
354 syncneg = 0x0100,
355 aborting = 0x0200,
356 resetting = 0x0400,
357 check_condition = 0x0800,
358};
359
360MODULE_AUTHOR("Jürgen Fischer");
361MODULE_DESCRIPTION(AHA152X_REVID);
362MODULE_LICENSE("GPL");
363
364#if !defined(PCMCIA)
365#if defined(MODULE)
366static int io[] = {0, 0};
367module_param_array(io, int, NULL, 0);
368MODULE_PARM_DESC(io,"base io address of controller");
369
370static int irq[] = {0, 0};
371module_param_array(irq, int, NULL, 0);
372MODULE_PARM_DESC(irq,"interrupt for controller");
373
374static int scsiid[] = {7, 7};
375module_param_array(scsiid, int, NULL, 0);
376MODULE_PARM_DESC(scsiid,"scsi id of controller");
377
378static int reconnect[] = {1, 1};
379module_param_array(reconnect, int, NULL, 0);
380MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
381
382static int parity[] = {1, 1};
383module_param_array(parity, int, NULL, 0);
384MODULE_PARM_DESC(parity,"use scsi parity");
385
386static int sync[] = {1, 1};
387module_param_array(sync, int, NULL, 0);
388MODULE_PARM_DESC(sync,"use synchronous transfers");
389
390static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
391module_param_array(delay, int, NULL, 0);
392MODULE_PARM_DESC(delay,"scsi reset delay");
393
394static int exttrans[] = {0, 0};
395module_param_array(exttrans, int, NULL, 0);
396MODULE_PARM_DESC(exttrans,"use extended translation");
397
398#if !defined(AHA152X_DEBUG)
399static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
400module_param_array(aha152x, int, NULL, 0);
401MODULE_PARM_DESC(aha152x, "parameters for first controller");
402
403static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
404module_param_array(aha152x1, int, NULL, 0);
405MODULE_PARM_DESC(aha152x1, "parameters for second controller");
406#else
407static int debug[] = {DEBUG_DEFAULT, DEBUG_DEFAULT};
408module_param_array(debug, int, NULL, 0);
409MODULE_PARM_DESC(debug, "flags for driver debugging");
410
411static int aha152x[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
412module_param_array(aha152x, int, NULL, 0);
413MODULE_PARM_DESC(aha152x, "parameters for first controller");
414
415static int aha152x1[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
416module_param_array(aha152x1, int, NULL, 0);
417MODULE_PARM_DESC(aha152x1, "parameters for second controller");
418#endif
419#endif
420
421#ifdef __ISAPNP__
422static struct isapnp_device_id id_table[] __devinitdata = {
423 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
424 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1505), 0 },
425 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
426 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1530), 0 },
427 { ISAPNP_DEVICE_SINGLE_END, }
428};
429MODULE_DEVICE_TABLE(isapnp, id_table);
430#endif
431
432#endif
433
434static struct scsi_host_template aha152x_driver_template;
435
436
437
438
439
440enum aha152x_state {
441 idle=0,
442 unknown,
443 seldo,
444 seldi,
445 selto,
446 busfree,
447 msgo,
448 cmd,
449 msgi,
450 status,
451 datai,
452 datao,
453 parerr,
454 rsti,
455 maxstate
456};
457
458
459
460
461
462struct aha152x_hostdata {
463 Scsi_Cmnd *issue_SC;
464
465
466 Scsi_Cmnd *current_SC;
467
468
469 Scsi_Cmnd *disconnected_SC;
470
471
472 Scsi_Cmnd *done_SC;
473
474
475 spinlock_t lock;
476
477
478#if defined(AHA152X_DEBUG)
479 const char *locker;
480
481 int lockerl;
482
483 int debug;
484#endif
485
486#if defined(AHA152X_STAT)
487 int total_commands;
488 int disconnections;
489 int busfree_without_any_action;
490 int busfree_without_old_command;
491 int busfree_without_new_command;
492 int busfree_without_done_command;
493 int busfree_with_check_condition;
494 int count[maxstate];
495 int count_trans[maxstate];
496 unsigned long time[maxstate];
497#endif
498
499 int commands;
500
501 int reconnect;
502 int parity;
503 int synchronous;
504 int delay;
505 int ext_trans;
506
507 int swint;
508 int service;
509 int in_intr;
510
511
512
513
514 enum aha152x_state state, prevstate, laststate;
515
516 int target;
517
518
519 unsigned char syncrate[8];
520
521
522 unsigned char syncneg[8];
523
524
525
526
527
528 int cmd_i;
529
530
531 int msgi_len;
532
533 unsigned char msgi[256];
534
535
536 int msgo_i, msgo_len;
537
538 unsigned char msgo[256];
539
540
541 int data_len;
542
543
544 unsigned long io_port0;
545 unsigned long io_port1;
546
547#ifdef __ISAPNP__
548 struct pnp_dev *pnpdev;
549#endif
550 struct list_head host_list;
551};
552
553
554
555
556
557
558struct aha152x_scdata {
559 Scsi_Cmnd *next;
560 struct completion *done;
561 unsigned char aha_orig_cmd_len;
562 unsigned char aha_orig_cmnd[MAX_COMMAND_SIZE];
563 int aha_orig_resid;
564};
565
566
567
568#define HOSTDATA(shpnt) ((struct aha152x_hostdata *) &shpnt->hostdata)
569
570#define HOSTNO ((shpnt)->host_no)
571
572#define CURRENT_SC (HOSTDATA(shpnt)->current_SC)
573#define DONE_SC (HOSTDATA(shpnt)->done_SC)
574#define ISSUE_SC (HOSTDATA(shpnt)->issue_SC)
575#define DISCONNECTED_SC (HOSTDATA(shpnt)->disconnected_SC)
576#define QLOCK (HOSTDATA(shpnt)->lock)
577#define QLOCKER (HOSTDATA(shpnt)->locker)
578#define QLOCKERL (HOSTDATA(shpnt)->lockerl)
579
580#define STATE (HOSTDATA(shpnt)->state)
581#define PREVSTATE (HOSTDATA(shpnt)->prevstate)
582#define LASTSTATE (HOSTDATA(shpnt)->laststate)
583
584#define RECONN_TARGET (HOSTDATA(shpnt)->target)
585
586#define CMD_I (HOSTDATA(shpnt)->cmd_i)
587
588#define MSGO(i) (HOSTDATA(shpnt)->msgo[i])
589#define MSGO_I (HOSTDATA(shpnt)->msgo_i)
590#define MSGOLEN (HOSTDATA(shpnt)->msgo_len)
591#define ADDMSGO(x) (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
592
593#define MSGI(i) (HOSTDATA(shpnt)->msgi[i])
594#define MSGILEN (HOSTDATA(shpnt)->msgi_len)
595#define ADDMSGI(x) (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
596
597#define DATA_LEN (HOSTDATA(shpnt)->data_len)
598
599#define SYNCRATE (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
600#define SYNCNEG (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
601
602#define DELAY (HOSTDATA(shpnt)->delay)
603#define EXT_TRANS (HOSTDATA(shpnt)->ext_trans)
604#define TC1550 (HOSTDATA(shpnt)->tc1550)
605#define RECONNECT (HOSTDATA(shpnt)->reconnect)
606#define PARITY (HOSTDATA(shpnt)->parity)
607#define SYNCHRONOUS (HOSTDATA(shpnt)->synchronous)
608
609#define HOSTIOPORT0 (HOSTDATA(shpnt)->io_port0)
610#define HOSTIOPORT1 (HOSTDATA(shpnt)->io_port1)
611
612#define SCDATA(SCpnt) ((struct aha152x_scdata *) (SCpnt)->host_scribble)
613#define SCNEXT(SCpnt) SCDATA(SCpnt)->next
614#define SCSEM(SCpnt) SCDATA(SCpnt)->done
615
616#define SG_ADDRESS(buffer) ((char *) sg_virt((buffer)))
617
618
619static void seldi_run(struct Scsi_Host *shpnt);
620static void seldo_run(struct Scsi_Host *shpnt);
621static void selto_run(struct Scsi_Host *shpnt);
622static void busfree_run(struct Scsi_Host *shpnt);
623
624static void msgo_init(struct Scsi_Host *shpnt);
625static void msgo_run(struct Scsi_Host *shpnt);
626static void msgo_end(struct Scsi_Host *shpnt);
627
628static void cmd_init(struct Scsi_Host *shpnt);
629static void cmd_run(struct Scsi_Host *shpnt);
630static void cmd_end(struct Scsi_Host *shpnt);
631
632static void datai_init(struct Scsi_Host *shpnt);
633static void datai_run(struct Scsi_Host *shpnt);
634static void datai_end(struct Scsi_Host *shpnt);
635
636static void datao_init(struct Scsi_Host *shpnt);
637static void datao_run(struct Scsi_Host *shpnt);
638static void datao_end(struct Scsi_Host *shpnt);
639
640static void status_run(struct Scsi_Host *shpnt);
641
642static void msgi_run(struct Scsi_Host *shpnt);
643static void msgi_end(struct Scsi_Host *shpnt);
644
645static void parerr_run(struct Scsi_Host *shpnt);
646static void rsti_run(struct Scsi_Host *shpnt);
647
648static void is_complete(struct Scsi_Host *shpnt);
649
650
651
652
653
654static struct {
655 char *name;
656 void (*init)(struct Scsi_Host *);
657 void (*run)(struct Scsi_Host *);
658 void (*end)(struct Scsi_Host *);
659 int spio;
660} states[] = {
661 { "idle", NULL, NULL, NULL, 0},
662 { "unknown", NULL, NULL, NULL, 0},
663 { "seldo", NULL, seldo_run, NULL, 0},
664 { "seldi", NULL, seldi_run, NULL, 0},
665 { "selto", NULL, selto_run, NULL, 0},
666 { "busfree", NULL, busfree_run, NULL, 0},
667 { "msgo", msgo_init, msgo_run, msgo_end, 1},
668 { "cmd", cmd_init, cmd_run, cmd_end, 1},
669 { "msgi", NULL, msgi_run, msgi_end, 1},
670 { "status", NULL, status_run, NULL, 1},
671 { "datai", datai_init, datai_run, datai_end, 0},
672 { "datao", datao_init, datao_run, datao_end, 0},
673 { "parerr", NULL, parerr_run, NULL, 0},
674 { "rsti", NULL, rsti_run, NULL, 0},
675};
676
677
678static irqreturn_t intr(int irq, void *dev_id);
679static void reset_ports(struct Scsi_Host *shpnt);
680static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
681static void done(struct Scsi_Host *shpnt, int error);
682
683
684static void disp_ports(struct Scsi_Host *shpnt);
685static void show_command(Scsi_Cmnd * ptr);
686static void show_queues(struct Scsi_Host *shpnt);
687static void disp_enintr(struct Scsi_Host *shpnt);
688
689
690
691
692
693
694static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)
695{
696 Scsi_Cmnd *end;
697
698 SCNEXT(new_SC) = NULL;
699 if (!*SC)
700 *SC = new_SC;
701 else {
702 for (end = *SC; SCNEXT(end); end = SCNEXT(end))
703 ;
704 SCNEXT(end) = new_SC;
705 }
706}
707
708static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC)
709{
710 Scsi_Cmnd *ptr;
711
712 ptr = *SC;
713 if (ptr) {
714 *SC = SCNEXT(*SC);
715 SCNEXT(ptr)=NULL;
716 }
717 return ptr;
718}
719
720static inline Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun)
721{
722 Scsi_Cmnd *ptr, *prev;
723
724 for (ptr = *SC, prev = NULL;
725 ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
726 prev = ptr, ptr = SCNEXT(ptr))
727 ;
728
729 if (ptr) {
730 if (prev)
731 SCNEXT(prev) = SCNEXT(ptr);
732 else
733 *SC = SCNEXT(ptr);
734
735 SCNEXT(ptr)=NULL;
736 }
737
738 return ptr;
739}
740
741static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp)
742{
743 Scsi_Cmnd *ptr, *prev;
744
745 for (ptr = *SC, prev = NULL;
746 ptr && SCp!=ptr;
747 prev = ptr, ptr = SCNEXT(ptr))
748 ;
749
750 if (ptr) {
751 if (prev)
752 SCNEXT(prev) = SCNEXT(ptr);
753 else
754 *SC = SCNEXT(ptr);
755
756 SCNEXT(ptr)=NULL;
757 }
758
759 return ptr;
760}
761
762static irqreturn_t swintr(int irqno, void *dev_id)
763{
764 struct Scsi_Host *shpnt = dev_id;
765
766 HOSTDATA(shpnt)->swint++;
767
768 SETPORT(DMACNTRL0, INTEN);
769 return IRQ_HANDLED;
770}
771
772struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
773{
774 struct Scsi_Host *shpnt;
775
776 shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
777 if (!shpnt) {
778 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
779 return NULL;
780 }
781
782 memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
783 INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
784
785
786 list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
787
788 shpnt->io_port = setup->io_port;
789 shpnt->n_io_port = IO_RANGE;
790 shpnt->irq = setup->irq;
791
792 if (!setup->tc1550) {
793 HOSTIOPORT0 = setup->io_port;
794 HOSTIOPORT1 = setup->io_port;
795 } else {
796 HOSTIOPORT0 = setup->io_port+0x10;
797 HOSTIOPORT1 = setup->io_port-0x10;
798 }
799
800 spin_lock_init(&QLOCK);
801 RECONNECT = setup->reconnect;
802 SYNCHRONOUS = setup->synchronous;
803 PARITY = setup->parity;
804 DELAY = setup->delay;
805 EXT_TRANS = setup->ext_trans;
806
807#if defined(AHA152X_DEBUG)
808 HOSTDATA(shpnt)->debug = setup->debug;
809#endif
810
811 SETPORT(SCSIID, setup->scsiid << 4);
812 shpnt->this_id = setup->scsiid;
813
814 if (setup->reconnect)
815 shpnt->can_queue = AHA152X_MAXQUEUE;
816
817
818 printk("aha152x: resetting bus...\n");
819 SETPORT(SCSISEQ, SCSIRSTO);
820 mdelay(256);
821 SETPORT(SCSISEQ, 0);
822 mdelay(DELAY);
823
824 reset_ports(shpnt);
825
826 printk(KERN_INFO
827 "aha152x%d%s: "
828 "vital data: rev=%x, "
829 "io=0x%03lx (0x%03lx/0x%03lx), "
830 "irq=%d, "
831 "scsiid=%d, "
832 "reconnect=%s, "
833 "parity=%s, "
834 "synchronous=%s, "
835 "delay=%d, "
836 "extended translation=%s\n",
837 shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
838 GETPORT(REV) & 0x7,
839 shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
840 shpnt->irq,
841 shpnt->this_id,
842 RECONNECT ? "enabled" : "disabled",
843 PARITY ? "enabled" : "disabled",
844 SYNCHRONOUS ? "enabled" : "disabled",
845 DELAY,
846 EXT_TRANS ? "enabled" : "disabled");
847
848
849 SETPORT(SIMODE0, 0);
850 SETPORT(SIMODE1, 0);
851
852 if( request_irq(shpnt->irq, swintr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
853 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
854 goto out_host_put;
855 }
856
857 HOSTDATA(shpnt)->swint = 0;
858
859 printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
860
861 mb();
862 SETPORT(DMACNTRL0, SWINT|INTEN);
863 mdelay(1000);
864 free_irq(shpnt->irq, shpnt);
865
866 if (!HOSTDATA(shpnt)->swint) {
867 if (TESTHI(DMASTAT, INTSTAT)) {
868 printk("lost.\n");
869 } else {
870 printk("failed.\n");
871 }
872
873 SETPORT(DMACNTRL0, INTEN);
874
875 printk(KERN_ERR "aha152x%d: irq %d possibly wrong. "
876 "Please verify.\n", shpnt->host_no, shpnt->irq);
877 goto out_host_put;
878 }
879 printk("ok.\n");
880
881
882
883 SETPORT(SSTAT0, 0x7f);
884 SETPORT(SSTAT1, 0xef);
885
886 if ( request_irq(shpnt->irq, intr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
887 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
888 goto out_host_put;
889 }
890
891 if( scsi_add_host(shpnt, NULL) ) {
892 free_irq(shpnt->irq, shpnt);
893 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
894 goto out_host_put;
895 }
896
897 scsi_scan_host(shpnt);
898
899 return shpnt;
900
901out_host_put:
902 list_del(&HOSTDATA(shpnt)->host_list);
903 scsi_host_put(shpnt);
904
905 return NULL;
906}
907
908void aha152x_release(struct Scsi_Host *shpnt)
909{
910 if (!shpnt)
911 return;
912
913 scsi_remove_host(shpnt);
914 if (shpnt->irq)
915 free_irq(shpnt->irq, shpnt);
916
917#if !defined(PCMCIA)
918 if (shpnt->io_port)
919 release_region(shpnt->io_port, IO_RANGE);
920#endif
921
922#ifdef __ISAPNP__
923 if (HOSTDATA(shpnt)->pnpdev)
924 pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
925#endif
926
927 list_del(&HOSTDATA(shpnt)->host_list);
928 scsi_host_put(shpnt);
929}
930
931
932
933
934
935
936
937static int setup_expected_interrupts(struct Scsi_Host *shpnt)
938{
939 if(CURRENT_SC) {
940 CURRENT_SC->SCp.phase |= 1 << 16;
941
942 if(CURRENT_SC->SCp.phase & selecting) {
943 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC));
944 SETPORT(SSTAT1, SELTO);
945 SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
946 SETPORT(SIMODE1, ENSELTIMO);
947 } else {
948 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.phase & spiordy ? "(spiordy)" : "");
949 SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
950 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
951 }
952 } else if(STATE==seldi) {
953 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC));
954 SETPORT(SIMODE0, 0);
955 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
956 } else {
957 DPRINTK(debug_intr, DEBUG_LEAD "expecting: %s %s\n",
958 CMDINFO(CURRENT_SC),
959 DISCONNECTED_SC ? "(reselection)" : "",
960 ISSUE_SC ? "(busfree)" : "");
961 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
962 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
963 }
964
965 if(!HOSTDATA(shpnt)->in_intr)
966 SETBITS(DMACNTRL0, INTEN);
967
968 return TESTHI(DMASTAT, INTSTAT);
969}
970
971
972
973
974
975static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete,
976 int phase, void (*done)(Scsi_Cmnd *))
977{
978 struct Scsi_Host *shpnt = SCpnt->device->host;
979 unsigned long flags;
980
981#if defined(AHA152X_DEBUG)
982 if (HOSTDATA(shpnt)->debug & debug_queue) {
983 printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
984 CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len,
985 scsi_sg_count(SCpnt), scsi_bufflen(SCpnt));
986 __scsi_print_command(SCpnt->cmnd);
987 }
988#endif
989
990 SCpnt->scsi_done = done;
991 SCpnt->SCp.phase = not_issued | phase;
992 SCpnt->SCp.Status = 0x1;
993 SCpnt->SCp.Message = 0;
994 SCpnt->SCp.have_data_in = 0;
995 SCpnt->SCp.sent_command = 0;
996
997 if(SCpnt->SCp.phase & (resetting|check_condition)) {
998 if(SCpnt->host_scribble==0 || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
999 printk(ERR_LEAD "cannot reuse command\n", CMDINFO(SCpnt));
1000 return FAILED;
1001 }
1002 } else {
1003 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
1004 if(SCpnt->host_scribble==0) {
1005 printk(ERR_LEAD "allocation failed\n", CMDINFO(SCpnt));
1006 return FAILED;
1007 }
1008 }
1009
1010 SCNEXT(SCpnt) = NULL;
1011 SCSEM(SCpnt) = complete;
1012
1013
1014
1015
1016
1017
1018
1019
1020 if ((phase & (check_condition|resetting)) || !scsi_sglist(SCpnt)) {
1021 if (phase & check_condition) {
1022 SCpnt->SCp.ptr = SCpnt->sense_buffer;
1023 SCpnt->SCp.this_residual = sizeof(SCpnt->sense_buffer);
1024 scsi_set_resid(SCpnt, sizeof(SCpnt->sense_buffer));
1025 } else {
1026 SCpnt->SCp.ptr = NULL;
1027 SCpnt->SCp.this_residual = 0;
1028 scsi_set_resid(SCpnt, 0);
1029 }
1030 SCpnt->SCp.buffer = NULL;
1031 SCpnt->SCp.buffers_residual = 0;
1032 } else {
1033 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
1034 SCpnt->SCp.buffer = scsi_sglist(SCpnt);
1035 SCpnt->SCp.ptr = SG_ADDRESS(SCpnt->SCp.buffer);
1036 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
1037 SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1;
1038 }
1039
1040 DO_LOCK(flags);
1041
1042#if defined(AHA152X_STAT)
1043 HOSTDATA(shpnt)->total_commands++;
1044#endif
1045
1046
1047 HOSTDATA(shpnt)->commands++;
1048 if (HOSTDATA(shpnt)->commands==1)
1049 SETPORT(PORTA, 1);
1050
1051 append_SC(&ISSUE_SC, SCpnt);
1052
1053 if(!HOSTDATA(shpnt)->in_intr)
1054 setup_expected_interrupts(shpnt);
1055
1056 DO_UNLOCK(flags);
1057
1058 return 0;
1059}
1060
1061
1062
1063
1064
1065static int aha152x_queue(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
1066{
1067#if 0
1068 if(*SCpnt->cmnd == REQUEST_SENSE) {
1069 SCpnt->result = 0;
1070 done(SCpnt);
1071
1072 return 0;
1073 }
1074#endif
1075
1076 return aha152x_internal_queue(SCpnt, NULL, 0, done);
1077}
1078
1079
1080
1081
1082
1083
1084static void reset_done(Scsi_Cmnd *SCpnt)
1085{
1086#if 0
1087 struct Scsi_Host *shpnt = SCpnt->host;
1088 DPRINTK(debug_eh, INFO_LEAD "reset_done called\n", CMDINFO(SCpnt));
1089#endif
1090 if(SCSEM(SCpnt)) {
1091 complete(SCSEM(SCpnt));
1092 } else {
1093 printk(KERN_ERR "aha152x: reset_done w/o completion\n");
1094 }
1095}
1096
1097
1098
1099
1100
1101static int aha152x_abort(Scsi_Cmnd *SCpnt)
1102{
1103 struct Scsi_Host *shpnt = SCpnt->device->host;
1104 Scsi_Cmnd *ptr;
1105 unsigned long flags;
1106
1107#if defined(AHA152X_DEBUG)
1108 if(HOSTDATA(shpnt)->debug & debug_eh) {
1109 printk(DEBUG_LEAD "abort(%p)", CMDINFO(SCpnt), SCpnt);
1110 show_queues(shpnt);
1111 }
1112#endif
1113
1114 DO_LOCK(flags);
1115
1116 ptr=remove_SC(&ISSUE_SC, SCpnt);
1117
1118 if(ptr) {
1119 DPRINTK(debug_eh, DEBUG_LEAD "not yet issued - SUCCESS\n", CMDINFO(SCpnt));
1120
1121 HOSTDATA(shpnt)->commands--;
1122 if (!HOSTDATA(shpnt)->commands)
1123 SETPORT(PORTA, 0);
1124 DO_UNLOCK(flags);
1125
1126 kfree(SCpnt->host_scribble);
1127 SCpnt->host_scribble=NULL;
1128
1129 return SUCCESS;
1130 }
1131
1132 DO_UNLOCK(flags);
1133
1134
1135
1136
1137
1138
1139
1140
1141 printk(ERR_LEAD "cannot abort running or disconnected command\n", CMDINFO(SCpnt));
1142
1143 return FAILED;
1144}
1145
1146
1147
1148
1149
1150static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
1151{
1152 struct Scsi_Host *shpnt = SCpnt->device->host;
1153 DECLARE_COMPLETION(done);
1154 int ret, issued, disconnected;
1155 unsigned char old_cmd_len = SCpnt->cmd_len;
1156 unsigned long flags;
1157 unsigned long timeleft;
1158
1159#if defined(AHA152X_DEBUG)
1160 if(HOSTDATA(shpnt)->debug & debug_eh) {
1161 printk(INFO_LEAD "aha152x_device_reset(%p)", CMDINFO(SCpnt), SCpnt);
1162 show_queues(shpnt);
1163 }
1164#endif
1165
1166 if(CURRENT_SC==SCpnt) {
1167 printk(ERR_LEAD "cannot reset current device\n", CMDINFO(SCpnt));
1168 return FAILED;
1169 }
1170
1171 DO_LOCK(flags);
1172 issued = remove_SC(&ISSUE_SC, SCpnt)==0;
1173 disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1174 DO_UNLOCK(flags);
1175
1176 SCpnt->cmd_len = 0;
1177
1178 aha152x_internal_queue(SCpnt, &done, resetting, reset_done);
1179
1180 timeleft = wait_for_completion_timeout(&done, 100*HZ);
1181 if (!timeleft) {
1182
1183 DO_LOCK(flags);
1184 remove_SC(&ISSUE_SC, SCpnt);
1185 DO_UNLOCK(flags);
1186 }
1187
1188 SCpnt->cmd_len = old_cmd_len;
1189
1190 DO_LOCK(flags);
1191
1192 if(SCpnt->SCp.phase & resetted) {
1193 HOSTDATA(shpnt)->commands--;
1194 if (!HOSTDATA(shpnt)->commands)
1195 SETPORT(PORTA, 0);
1196 kfree(SCpnt->host_scribble);
1197 SCpnt->host_scribble=NULL;
1198
1199 ret = SUCCESS;
1200 } else {
1201
1202 if(!issued) {
1203 append_SC(&ISSUE_SC, SCpnt);
1204 } else if(disconnected) {
1205 append_SC(&DISCONNECTED_SC, SCpnt);
1206 }
1207
1208 ret = FAILED;
1209 }
1210
1211 DO_UNLOCK(flags);
1212 return ret;
1213}
1214
1215static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
1216{
1217 Scsi_Cmnd *ptr;
1218
1219 ptr=*SCs;
1220 while(ptr) {
1221 Scsi_Cmnd *next;
1222
1223 if(SCDATA(ptr)) {
1224 next = SCNEXT(ptr);
1225 } else {
1226 printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr);
1227 next = NULL;
1228 }
1229
1230 if (!ptr->device->soft_reset) {
1231 DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr);
1232 remove_SC(SCs, ptr);
1233 HOSTDATA(shpnt)->commands--;
1234 kfree(ptr->host_scribble);
1235 ptr->host_scribble=NULL;
1236 }
1237
1238 ptr = next;
1239 }
1240}
1241
1242
1243
1244
1245
1246static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1247{
1248 unsigned long flags;
1249
1250 DO_LOCK(flags);
1251
1252#if defined(AHA152X_DEBUG)
1253 if(HOSTDATA(shpnt)->debug & debug_eh) {
1254 printk(KERN_DEBUG "scsi%d: bus reset", shpnt->host_no);
1255 show_queues(shpnt);
1256 }
1257#endif
1258
1259 free_hard_reset_SCs(shpnt, &ISSUE_SC);
1260 free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1261
1262 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting bus\n", shpnt->host_no);
1263
1264 SETPORT(SCSISEQ, SCSIRSTO);
1265 mdelay(256);
1266 SETPORT(SCSISEQ, 0);
1267 mdelay(DELAY);
1268
1269 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: bus resetted\n", shpnt->host_no);
1270
1271 setup_expected_interrupts(shpnt);
1272 if(HOSTDATA(shpnt)->commands==0)
1273 SETPORT(PORTA, 0);
1274
1275 DO_UNLOCK(flags);
1276
1277 return SUCCESS;
1278}
1279
1280
1281
1282
1283
1284static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1285{
1286 return aha152x_bus_reset_host(SCpnt->device->host);
1287}
1288
1289
1290
1291
1292
1293static void reset_ports(struct Scsi_Host *shpnt)
1294{
1295 unsigned long flags;
1296
1297
1298 SETPORT(DMACNTRL0, RSTFIFO);
1299
1300 SETPORT(SCSISEQ, 0);
1301
1302 SETPORT(SXFRCTL1, 0);
1303 SETPORT(SCSISIG, 0);
1304 SETRATE(0);
1305
1306
1307 SETPORT(SSTAT0, 0x7f);
1308 SETPORT(SSTAT1, 0xef);
1309
1310 SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1311
1312 SETPORT(DMACNTRL0, 0);
1313 SETPORT(DMACNTRL1, 0);
1314
1315 SETPORT(BRSTCNTRL, 0xf1);
1316
1317
1318 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1319 SETPORT(SXFRCTL0, CH1);
1320
1321 DO_LOCK(flags);
1322 setup_expected_interrupts(shpnt);
1323 DO_UNLOCK(flags);
1324}
1325
1326
1327
1328
1329
1330int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1331{
1332 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: host reset\n", shpnt->host_no);
1333
1334 aha152x_bus_reset_host(shpnt);
1335
1336 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting ports\n", shpnt->host_no);
1337 reset_ports(shpnt);
1338
1339 return SUCCESS;
1340}
1341
1342
1343
1344
1345
1346static int aha152x_host_reset(Scsi_Cmnd *SCpnt)
1347{
1348 return aha152x_host_reset_host(SCpnt->device->host);
1349}
1350
1351
1352
1353
1354
1355static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1356 sector_t capacity, int *info_array)
1357{
1358 struct Scsi_Host *shpnt = sdev->host;
1359
1360
1361 info_array[0] = 64;
1362 info_array[1] = 32;
1363 info_array[2] = (unsigned long)capacity / (64 * 32);
1364
1365
1366 if (info_array[2] >= 1024) {
1367 int info[3];
1368
1369
1370 if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1371 !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1372 if (EXT_TRANS) {
1373 printk(KERN_NOTICE
1374 "aha152x: unable to verify geometry for disk with >1GB.\n"
1375 " using extended translation.\n");
1376 info_array[0] = 255;
1377 info_array[1] = 63;
1378 info_array[2] = (unsigned long)capacity / (255 * 63);
1379 } else {
1380 printk(KERN_NOTICE
1381 "aha152x: unable to verify geometry for disk with >1GB.\n"
1382 " Using default translation. Please verify yourself.\n"
1383 " Perhaps you need to enable extended translation in the driver.\n"
1384 " See Documentation/scsi/aha152x.txt for details.\n");
1385 }
1386 } else {
1387 info_array[0] = info[0];
1388 info_array[1] = info[1];
1389 info_array[2] = info[2];
1390
1391 if (info[0] == 255 && !EXT_TRANS) {
1392 printk(KERN_NOTICE
1393 "aha152x: current partition table is using extended translation.\n"
1394 " using it also, although it's not explicitly enabled.\n");
1395 }
1396 }
1397 }
1398
1399 return 0;
1400}
1401
1402
1403
1404
1405
1406static void done(struct Scsi_Host *shpnt, int error)
1407{
1408 if (CURRENT_SC) {
1409 if(DONE_SC)
1410 printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC);
1411
1412 DONE_SC = CURRENT_SC;
1413 CURRENT_SC = NULL;
1414 DONE_SC->result = error;
1415 } else
1416 printk(KERN_ERR "aha152x: done() called outside of command\n");
1417}
1418
1419static struct work_struct aha152x_tq;
1420
1421
1422
1423
1424
1425static void run(struct work_struct *work)
1426{
1427 struct aha152x_hostdata *hd;
1428
1429 list_for_each_entry(hd, &aha152x_host_list, host_list) {
1430 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1431
1432 is_complete(shost);
1433 }
1434}
1435
1436
1437
1438
1439
1440static irqreturn_t intr(int irqno, void *dev_id)
1441{
1442 struct Scsi_Host *shpnt = (struct Scsi_Host *)dev_id;
1443 unsigned long flags;
1444 unsigned char rev, dmacntrl0;
1445
1446 if (!shpnt) {
1447 printk(KERN_ERR "aha152x: catched interrupt %d for unknown controller.\n", irqno);
1448 return IRQ_NONE;
1449 }
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464 rev = GETPORT(REV);
1465 dmacntrl0 = GETPORT(DMACNTRL0);
1466 if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1467 return IRQ_NONE;
1468
1469 if( TESTLO(DMASTAT, INTSTAT) )
1470 return IRQ_NONE;
1471
1472
1473
1474 CLRBITS(DMACNTRL0, INTEN);
1475
1476 DO_LOCK(flags);
1477 if( HOSTDATA(shpnt)->service==0 ) {
1478 HOSTDATA(shpnt)->service=1;
1479
1480
1481 INIT_WORK(&aha152x_tq, run);
1482 schedule_work(&aha152x_tq);
1483 }
1484 DO_UNLOCK(flags);
1485
1486 return IRQ_HANDLED;
1487}
1488
1489
1490
1491
1492
1493
1494static void busfree_run(struct Scsi_Host *shpnt)
1495{
1496 unsigned long flags;
1497#if defined(AHA152X_STAT)
1498 int action=0;
1499#endif
1500
1501 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1502 SETPORT(SXFRCTL0, CH1);
1503
1504 SETPORT(SSTAT1, CLRBUSFREE);
1505
1506 if(CURRENT_SC) {
1507#if defined(AHA152X_STAT)
1508 action++;
1509#endif
1510 CURRENT_SC->SCp.phase &= ~syncneg;
1511
1512 if(CURRENT_SC->SCp.phase & completed) {
1513
1514 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1515
1516 } else if(CURRENT_SC->SCp.phase & aborted) {
1517 DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC));
1518 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1519
1520 } else if(CURRENT_SC->SCp.phase & resetted) {
1521 DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC));
1522 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1523
1524 } else if(CURRENT_SC->SCp.phase & disconnected) {
1525
1526 DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n",
1527 CMDINFO(CURRENT_SC),
1528 scsi_get_resid(CURRENT_SC),
1529 scsi_bufflen(CURRENT_SC));
1530#if defined(AHA152X_STAT)
1531 HOSTDATA(shpnt)->disconnections++;
1532#endif
1533 append_SC(&DISCONNECTED_SC, CURRENT_SC);
1534 CURRENT_SC->SCp.phase |= 1 << 16;
1535 CURRENT_SC = NULL;
1536
1537 } else {
1538 done(shpnt, DID_ERROR << 16);
1539 }
1540#if defined(AHA152X_STAT)
1541 } else {
1542 HOSTDATA(shpnt)->busfree_without_old_command++;
1543#endif
1544 }
1545
1546 DO_LOCK(flags);
1547
1548 if(DONE_SC) {
1549#if defined(AHA152X_STAT)
1550 action++;
1551#endif
1552
1553 if(DONE_SC->SCp.phase & check_condition) {
1554 struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1555 struct aha152x_scdata *sc = SCDATA(cmd);
1556
1557#if 0
1558 if(HOSTDATA(shpnt)->debug & debug_eh) {
1559 printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
1560 scsi_print_sense("bh", DONE_SC);
1561 }
1562#endif
1563
1564
1565 memcpy(cmd->cmnd, sc->aha_orig_cmnd, sizeof(cmd->cmnd));
1566 cmd->cmd_len = sc->aha_orig_cmd_len;
1567 scsi_set_resid(cmd, sc->aha_orig_resid);
1568
1569 cmd->SCp.Status = SAM_STAT_CHECK_CONDITION;
1570
1571 HOSTDATA(shpnt)->commands--;
1572 if (!HOSTDATA(shpnt)->commands)
1573 SETPORT(PORTA, 0);
1574 } else if(DONE_SC->SCp.Status==SAM_STAT_CHECK_CONDITION) {
1575#if defined(AHA152X_STAT)
1576 HOSTDATA(shpnt)->busfree_with_check_condition++;
1577#endif
1578#if 0
1579 DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC));
1580#endif
1581
1582 if(!(DONE_SC->SCp.phase & not_issued)) {
1583 struct aha152x_scdata *sc;
1584 Scsi_Cmnd *ptr = DONE_SC;
1585 DONE_SC=NULL;
1586#if 0
1587 DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr));
1588#endif
1589
1590
1591 sc = SCDATA(ptr);
1592
1593 BUG_ON(!sc);
1594 memcpy(sc->aha_orig_cmnd, ptr->cmnd,
1595 sizeof(ptr->cmnd));
1596 sc->aha_orig_cmd_len = ptr->cmd_len;
1597 sc->aha_orig_resid = scsi_get_resid(ptr);
1598
1599 ptr->cmnd[0] = REQUEST_SENSE;
1600 ptr->cmnd[1] = 0;
1601 ptr->cmnd[2] = 0;
1602 ptr->cmnd[3] = 0;
1603 ptr->cmnd[4] = sizeof(ptr->sense_buffer);
1604 ptr->cmnd[5] = 0;
1605 ptr->cmd_len = 6;
1606
1607 DO_UNLOCK(flags);
1608 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1609 DO_LOCK(flags);
1610#if 0
1611 } else {
1612 DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC));
1613#endif
1614 }
1615 }
1616
1617 if(DONE_SC && DONE_SC->scsi_done) {
1618#if defined(AHA152X_DEBUG)
1619 int hostno=DONE_SC->device->host->host_no;
1620 int id=DONE_SC->device->id & 0xf;
1621 int lun=DONE_SC->device->lun & 0x7;
1622#endif
1623 Scsi_Cmnd *ptr = DONE_SC;
1624 DONE_SC=NULL;
1625
1626
1627 HOSTDATA(shpnt)->commands--;
1628 if (!HOSTDATA(shpnt)->commands)
1629 SETPORT(PORTA, 0);
1630
1631 if(ptr->scsi_done != reset_done) {
1632 kfree(ptr->host_scribble);
1633 ptr->host_scribble=NULL;
1634 }
1635
1636 DO_UNLOCK(flags);
1637 DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr);
1638 ptr->scsi_done(ptr);
1639 DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr);
1640 DO_LOCK(flags);
1641 }
1642
1643 DONE_SC=NULL;
1644#if defined(AHA152X_STAT)
1645 } else {
1646 HOSTDATA(shpnt)->busfree_without_done_command++;
1647#endif
1648 }
1649
1650 if(ISSUE_SC)
1651 CURRENT_SC = remove_first_SC(&ISSUE_SC);
1652
1653 DO_UNLOCK(flags);
1654
1655 if(CURRENT_SC) {
1656#if defined(AHA152X_STAT)
1657 action++;
1658#endif
1659 CURRENT_SC->SCp.phase |= selecting;
1660
1661 DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC));
1662
1663
1664 SETPORT(SSTAT1, SELTO);
1665
1666 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1667 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1668 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1669 } else {
1670#if defined(AHA152X_STAT)
1671 HOSTDATA(shpnt)->busfree_without_new_command++;
1672#endif
1673 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1674 }
1675
1676#if defined(AHA152X_STAT)
1677 if(!action)
1678 HOSTDATA(shpnt)->busfree_without_any_action++;
1679#endif
1680}
1681
1682
1683
1684
1685
1686
1687static void seldo_run(struct Scsi_Host *shpnt)
1688{
1689 SETPORT(SCSISIG, 0);
1690 SETPORT(SSTAT1, CLRBUSFREE);
1691 SETPORT(SSTAT1, CLRPHASECHG);
1692
1693 CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1694
1695 SETPORT(SCSISEQ, 0);
1696
1697 if (TESTLO(SSTAT0, SELDO)) {
1698 printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC));
1699 done(shpnt, DID_NO_CONNECT << 16);
1700 return;
1701 }
1702
1703 SETPORT(SSTAT0, CLRSELDO);
1704
1705 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1706
1707 if (CURRENT_SC->SCp.phase & aborting) {
1708 ADDMSGO(ABORT);
1709 } else if (CURRENT_SC->SCp.phase & resetting) {
1710 ADDMSGO(BUS_DEVICE_RESET);
1711 } else if (SYNCNEG==0 && SYNCHRONOUS) {
1712 CURRENT_SC->SCp.phase |= syncneg;
1713 MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1714 SYNCNEG=1;
1715 }
1716
1717 SETRATE(SYNCRATE);
1718}
1719
1720
1721
1722
1723
1724
1725static void selto_run(struct Scsi_Host *shpnt)
1726{
1727 SETPORT(SCSISEQ, 0);
1728 SETPORT(SSTAT1, CLRSELTIMO);
1729
1730 DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
1731
1732 if(!CURRENT_SC) {
1733 DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
1734 return;
1735 }
1736
1737 CURRENT_SC->SCp.phase &= ~selecting;
1738
1739 if (CURRENT_SC->SCp.phase & aborted) {
1740 DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
1741 done(shpnt, DID_ABORT << 16);
1742 } else if (TESTLO(SSTAT0, SELINGO)) {
1743 DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
1744 done(shpnt, DID_BUS_BUSY << 16);
1745 } else {
1746
1747 DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
1748 done(shpnt, DID_NO_CONNECT << 16);
1749 }
1750}
1751
1752
1753
1754
1755
1756
1757
1758
1759static void seldi_run(struct Scsi_Host *shpnt)
1760{
1761 int selid;
1762 int target;
1763 unsigned long flags;
1764
1765 SETPORT(SCSISIG, 0);
1766 SETPORT(SSTAT0, CLRSELDI);
1767 SETPORT(SSTAT1, CLRBUSFREE);
1768 SETPORT(SSTAT1, CLRPHASECHG);
1769
1770 if(CURRENT_SC) {
1771 if(!(CURRENT_SC->SCp.phase & not_issued))
1772 printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
1773
1774 DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
1775
1776 DO_LOCK(flags);
1777 append_SC(&ISSUE_SC, CURRENT_SC);
1778 DO_UNLOCK(flags);
1779
1780 CURRENT_SC = NULL;
1781 }
1782
1783 if(!DISCONNECTED_SC) {
1784 DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
1785 return;
1786 }
1787
1788 RECONN_TARGET=-1;
1789
1790 selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1791
1792 if (selid==0) {
1793 printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
1794 return;
1795 }
1796
1797 for(target=7; !(selid & (1 << target)); target--)
1798 ;
1799
1800 if(selid & ~(1 << target)) {
1801 printk("aha152x%d: multiple targets reconnected (%02x)\n",
1802 HOSTNO, selid);
1803 }
1804
1805
1806 SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1807 SETPORT(SCSISEQ, 0);
1808
1809 SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1810
1811 RECONN_TARGET=target;
1812 DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
1813}
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828static void msgi_run(struct Scsi_Host *shpnt)
1829{
1830 for(;;) {
1831 int sstat1 = GETPORT(SSTAT1);
1832
1833 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1834 return;
1835
1836 if(TESTLO(SSTAT0,SPIORDY)) {
1837 DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
1838 return;
1839 }
1840
1841 ADDMSGI(GETPORT(SCSIDAT));
1842
1843#if defined(AHA152X_DEBUG)
1844 if (HOSTDATA(shpnt)->debug & debug_msgi) {
1845 printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
1846 spi_print_msg(&MSGI(0));
1847 printk("\n");
1848 }
1849#endif
1850
1851 if(!CURRENT_SC) {
1852 if(LASTSTATE!=seldi) {
1853 printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
1854 }
1855
1856
1857
1858
1859 if(!(MSGI(0) & IDENTIFY_BASE)) {
1860 printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
1861 continue;
1862 }
1863
1864 CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1865
1866 if (!CURRENT_SC) {
1867 show_queues(shpnt);
1868 printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
1869 continue;
1870 }
1871
1872 DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
1873
1874 CURRENT_SC->SCp.Message = MSGI(0);
1875 CURRENT_SC->SCp.phase &= ~disconnected;
1876
1877 MSGILEN=0;
1878
1879
1880 continue;
1881 }
1882
1883 CURRENT_SC->SCp.Message = MSGI(0);
1884
1885 switch (MSGI(0)) {
1886 case DISCONNECT:
1887 if (!RECONNECT)
1888 printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
1889
1890 CURRENT_SC->SCp.phase |= disconnected;
1891 break;
1892
1893 case COMMAND_COMPLETE:
1894 if(CURRENT_SC->SCp.phase & completed)
1895 DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
1896
1897 CURRENT_SC->SCp.phase |= completed;
1898 break;
1899
1900 case MESSAGE_REJECT:
1901 if (SYNCNEG==1) {
1902 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
1903 SYNCNEG=2;
1904 } else
1905 printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC));
1906 break;
1907
1908 case SAVE_POINTERS:
1909 break;
1910
1911 case RESTORE_POINTERS:
1912 break;
1913
1914 case EXTENDED_MESSAGE:
1915 if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1916
1917 continue;
1918 }
1919
1920 switch (MSGI(2)) {
1921 case EXTENDED_SDTR:
1922 {
1923 long ticks;
1924
1925 if (MSGI(1) != 3) {
1926 printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC));
1927 break;
1928 }
1929
1930 if (!HOSTDATA(shpnt)->synchronous)
1931 break;
1932
1933 printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1934 spi_print_msg(&MSGI(0));
1935 printk("\n");
1936
1937 ticks = (MSGI(3) * 4 + 49) / 50;
1938
1939 if (syncneg) {
1940
1941 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1942 ADDMSGO(MESSAGE_REJECT);
1943 printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC));
1944 break;
1945 }
1946
1947 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1948 } else if (ticks <= 9 && MSGI(4) >= 1) {
1949 ADDMSGO(EXTENDED_MESSAGE);
1950 ADDMSGO(3);
1951 ADDMSGO(EXTENDED_SDTR);
1952 if (ticks < 4) {
1953 ticks = 4;
1954 ADDMSGO(50);
1955 } else
1956 ADDMSGO(MSGI(3));
1957
1958 if (MSGI(4) > 8)
1959 MSGI(4) = 8;
1960
1961 ADDMSGO(MSGI(4));
1962
1963 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1964 } else {
1965
1966 printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC));
1967 ADDMSGO(MESSAGE_REJECT);
1968 }
1969
1970 SYNCNEG=2;
1971 SETRATE(SYNCRATE);
1972 }
1973 break;
1974
1975 case BUS_DEVICE_RESET:
1976 {
1977 int i;
1978
1979 for(i=0; i<8; i++) {
1980 HOSTDATA(shpnt)->syncrate[i]=0;
1981 HOSTDATA(shpnt)->syncneg[i]=0;
1982 }
1983
1984 }
1985 break;
1986
1987 case EXTENDED_MODIFY_DATA_POINTER:
1988 case EXTENDED_EXTENDED_IDENTIFY:
1989 case EXTENDED_WDTR:
1990 default:
1991 ADDMSGO(MESSAGE_REJECT);
1992 break;
1993 }
1994 break;
1995 }
1996
1997 MSGILEN=0;
1998 }
1999}
2000
2001static void msgi_end(struct Scsi_Host *shpnt)
2002{
2003 if(MSGILEN>0)
2004 printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN);
2005
2006 if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) {
2007 DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC));
2008 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
2009 }
2010}
2011
2012
2013
2014
2015
2016static void msgo_init(struct Scsi_Host *shpnt)
2017{
2018 if(MSGOLEN==0) {
2019 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
2020 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
2021 } else {
2022 printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC));
2023 ADDMSGO(MESSAGE_REJECT);
2024 }
2025 }
2026
2027#if defined(AHA152X_DEBUG)
2028 if(HOSTDATA(shpnt)->debug & debug_msgo) {
2029 int i;
2030
2031 printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
2032 for (i=0; i<MSGOLEN; i+=spi_print_msg(&MSGO(i)), printk(" "))
2033 ;
2034 printk(")\n");
2035 }
2036#endif
2037}
2038
2039
2040
2041
2042
2043static void msgo_run(struct Scsi_Host *shpnt)
2044{
2045 if(MSGO_I==MSGOLEN)
2046 DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2047
2048 while(MSGO_I<MSGOLEN) {
2049 DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN);
2050
2051 if(TESTLO(SSTAT0, SPIORDY)) {
2052 DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2053 return;
2054 }
2055
2056 if (MSGO_I==MSGOLEN-1) {
2057
2058 SETPORT(SSTAT1, CLRATNO);
2059 }
2060
2061
2062 if (MSGO(MSGO_I) & IDENTIFY_BASE)
2063 CURRENT_SC->SCp.phase |= identified;
2064
2065 if (MSGO(MSGO_I)==ABORT)
2066 CURRENT_SC->SCp.phase |= aborted;
2067
2068 if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
2069 CURRENT_SC->SCp.phase |= resetted;
2070
2071 SETPORT(SCSIDAT, MSGO(MSGO_I++));
2072 }
2073}
2074
2075static void msgo_end(struct Scsi_Host *shpnt)
2076{
2077 if(MSGO_I<MSGOLEN) {
2078 printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2079 if(SYNCNEG==1) {
2080 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
2081 SYNCNEG=2;
2082 }
2083 }
2084
2085 MSGO_I = 0;
2086 MSGOLEN = 0;
2087}
2088
2089
2090
2091
2092
2093static void cmd_init(struct Scsi_Host *shpnt)
2094{
2095 if (CURRENT_SC->SCp.sent_command) {
2096 printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC));
2097 done(shpnt, DID_ERROR << 16);
2098 return;
2099 }
2100
2101#if defined(AHA152X_DEBUG)
2102 if (HOSTDATA(shpnt)->debug & debug_cmd) {
2103 printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
2104 __scsi_print_command(CURRENT_SC->cmnd);
2105 }
2106#endif
2107
2108 CMD_I=0;
2109}
2110
2111
2112
2113
2114
2115static void cmd_run(struct Scsi_Host *shpnt)
2116{
2117 if(CMD_I==CURRENT_SC->cmd_len) {
2118 DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2119 disp_ports(shpnt);
2120 }
2121
2122 while(CMD_I<CURRENT_SC->cmd_len) {
2123 DPRINTK(debug_cmd, DEBUG_LEAD "command byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), CURRENT_SC->cmnd[CMD_I], CMD_I, CURRENT_SC->cmd_len);
2124
2125 if(TESTLO(SSTAT0, SPIORDY)) {
2126 DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2127 return;
2128 }
2129
2130 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
2131 }
2132}
2133
2134static void cmd_end(struct Scsi_Host *shpnt)
2135{
2136 if(CMD_I<CURRENT_SC->cmd_len)
2137 printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2138 else
2139 CURRENT_SC->SCp.sent_command++;
2140}
2141
2142
2143
2144
2145
2146static void status_run(struct Scsi_Host *shpnt)
2147{
2148 if(TESTLO(SSTAT0,SPIORDY)) {
2149 DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2150 return;
2151 }
2152
2153 CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
2154
2155#if defined(AHA152X_DEBUG)
2156 if (HOSTDATA(shpnt)->debug & debug_status) {
2157 printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
2158 scsi_print_status(CURRENT_SC->SCp.Status);
2159 printk("\n");
2160 }
2161#endif
2162}
2163
2164
2165
2166
2167
2168static void datai_init(struct Scsi_Host *shpnt)
2169{
2170 SETPORT(DMACNTRL0, RSTFIFO);
2171 SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
2172
2173 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2174 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2175
2176 SETPORT(SIMODE0, 0);
2177 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
2178
2179 DATA_LEN=0;
2180 DPRINTK(debug_datai,
2181 DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n",
2182 CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2183 scsi_get_resid(CURRENT_SC));
2184}
2185
2186static void datai_run(struct Scsi_Host *shpnt)
2187{
2188 unsigned long the_time;
2189 int fifodata, data_count;
2190
2191
2192
2193
2194
2195 while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2196
2197
2198
2199
2200 the_time=jiffies + 100*HZ;
2201 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2202 barrier();
2203
2204 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2205 printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC));
2206 disp_ports(shpnt);
2207 break;
2208 }
2209
2210 if(TESTHI(DMASTAT, DFIFOFULL)) {
2211 fifodata = 128;
2212 } else {
2213 the_time=jiffies + 100*HZ;
2214 while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2215 barrier();
2216
2217 if(TESTLO(SSTAT2, SEMPTY)) {
2218 printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC));
2219 disp_ports(shpnt);
2220 break;
2221 }
2222
2223 fifodata = GETPORT(FIFOSTAT);
2224 }
2225
2226 if(CURRENT_SC->SCp.this_residual>0) {
2227 while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2228 data_count = fifodata>CURRENT_SC->SCp.this_residual ?
2229 CURRENT_SC->SCp.this_residual :
2230 fifodata;
2231 fifodata -= data_count;
2232
2233 if(data_count & 1) {
2234 DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC));
2235 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2236 *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2237 CURRENT_SC->SCp.this_residual--;
2238 DATA_LEN++;
2239 SETPORT(DMACNTRL0, ENDMA);
2240 }
2241
2242 if(data_count > 1) {
2243 DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count);
2244 data_count >>= 1;
2245 insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2246 CURRENT_SC->SCp.ptr += 2 * data_count;
2247 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2248 DATA_LEN += 2 * data_count;
2249 }
2250
2251 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2252
2253 CURRENT_SC->SCp.buffers_residual--;
2254 CURRENT_SC->SCp.buffer++;
2255 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2256 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2257 }
2258 }
2259 } else if(fifodata>0) {
2260 printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT));
2261 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2262 while(fifodata>0) {
2263 int data;
2264 data=GETPORT(DATAPORT);
2265 DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data);
2266 fifodata--;
2267 DATA_LEN++;
2268 }
2269 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2270 }
2271 }
2272
2273 if(TESTLO(DMASTAT, INTSTAT) ||
2274 TESTLO(DMASTAT, DFIFOEMP) ||
2275 TESTLO(SSTAT2, SEMPTY) ||
2276 GETPORT(FIFOSTAT)>0) {
2277
2278
2279
2280
2281 printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC));
2282 disp_ports(shpnt);
2283 }
2284
2285 if(DATA_LEN!=GETSTCNT()) {
2286 printk(ERR_LEAD
2287 "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2288 CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT));
2289 disp_ports(shpnt);
2290 mdelay(10000);
2291 }
2292}
2293
2294static void datai_end(struct Scsi_Host *shpnt)
2295{
2296 CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
2297
2298 DPRINTK(debug_datai,
2299 DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
2300 CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2301 scsi_get_resid(CURRENT_SC), GETSTCNT());
2302
2303 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2304 SETPORT(DMACNTRL0, 0);
2305}
2306
2307
2308
2309
2310
2311static void datao_init(struct Scsi_Host *shpnt)
2312{
2313 SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2314 SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2315
2316 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2317 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2318
2319 SETPORT(SIMODE0, 0);
2320 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2321
2322 DATA_LEN = scsi_get_resid(CURRENT_SC);
2323
2324 DPRINTK(debug_datao,
2325 DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n",
2326 CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2327 scsi_get_resid(CURRENT_SC));
2328}
2329
2330static void datao_run(struct Scsi_Host *shpnt)
2331{
2332 unsigned long the_time;
2333 int data_count;
2334
2335
2336 while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2337 data_count = 128;
2338 if(data_count > CURRENT_SC->SCp.this_residual)
2339 data_count=CURRENT_SC->SCp.this_residual;
2340
2341 if(TESTLO(DMASTAT, DFIFOEMP)) {
2342 printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT));
2343 disp_ports(shpnt);
2344 break;
2345 }
2346
2347 if(data_count & 1) {
2348 SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2349 SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2350 CURRENT_SC->SCp.this_residual--;
2351 CMD_INC_RESID(CURRENT_SC, -1);
2352 SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2353 }
2354
2355 if(data_count > 1) {
2356 data_count >>= 1;
2357 outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2358 CURRENT_SC->SCp.ptr += 2 * data_count;
2359 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2360 CMD_INC_RESID(CURRENT_SC, -2 * data_count);
2361 }
2362
2363 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2364
2365 CURRENT_SC->SCp.buffers_residual--;
2366 CURRENT_SC->SCp.buffer++;
2367 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2368 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2369 }
2370
2371 the_time=jiffies + 100*HZ;
2372 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2373 barrier();
2374
2375 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2376 printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC));
2377 disp_ports(shpnt);
2378 break;
2379 }
2380 }
2381}
2382
2383static void datao_end(struct Scsi_Host *shpnt)
2384{
2385 if(TESTLO(DMASTAT, DFIFOEMP)) {
2386 int data_count = (DATA_LEN - scsi_get_resid(CURRENT_SC)) -
2387 GETSTCNT();
2388
2389 DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n",
2390 CMDINFO(CURRENT_SC),
2391 data_count,
2392 DATA_LEN - scsi_get_resid(CURRENT_SC),
2393 GETSTCNT());
2394
2395 CMD_INC_RESID(CURRENT_SC, data_count);
2396
2397 data_count -= CURRENT_SC->SCp.ptr -
2398 SG_ADDRESS(CURRENT_SC->SCp.buffer);
2399 while(data_count>0) {
2400 CURRENT_SC->SCp.buffer--;
2401 CURRENT_SC->SCp.buffers_residual++;
2402 data_count -= CURRENT_SC->SCp.buffer->length;
2403 }
2404 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) -
2405 data_count;
2406 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length +
2407 data_count;
2408 }
2409
2410 DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
2411 CMDINFO(CURRENT_SC),
2412 scsi_bufflen(CURRENT_SC),
2413 scsi_get_resid(CURRENT_SC),
2414 GETSTCNT());
2415
2416 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2417 SETPORT(SXFRCTL0, CH1);
2418
2419 SETPORT(DMACNTRL0, 0);
2420}
2421
2422
2423
2424
2425
2426static int update_state(struct Scsi_Host *shpnt)
2427{
2428 int dataphase=0;
2429 unsigned int stat0 = GETPORT(SSTAT0);
2430 unsigned int stat1 = GETPORT(SSTAT1);
2431
2432 PREVSTATE = STATE;
2433 STATE=unknown;
2434
2435 if(stat1 & SCSIRSTI) {
2436 STATE=rsti;
2437 SETPORT(SCSISEQ,0);
2438 SETPORT(SSTAT1,SCSIRSTI);
2439 } else if(stat0 & SELDI && PREVSTATE==busfree) {
2440 STATE=seldi;
2441 } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2442 STATE=seldo;
2443 } else if(stat1 & SELTO) {
2444 STATE=selto;
2445 } else if(stat1 & BUSFREE) {
2446 STATE=busfree;
2447 SETPORT(SSTAT1,BUSFREE);
2448 } else if(stat1 & SCSIPERR) {
2449 STATE=parerr;
2450 SETPORT(SSTAT1,SCSIPERR);
2451 } else if(stat1 & REQINIT) {
2452 switch(GETPORT(SCSISIG) & P_MASK) {
2453 case P_MSGI: STATE=msgi; break;
2454 case P_MSGO: STATE=msgo; break;
2455 case P_DATAO: STATE=datao; break;
2456 case P_DATAI: STATE=datai; break;
2457 case P_STATUS: STATE=status; break;
2458 case P_CMD: STATE=cmd; break;
2459 }
2460 dataphase=1;
2461 }
2462
2463 if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2464 printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC));
2465 disp_ports(shpnt);
2466 }
2467
2468 if(STATE!=PREVSTATE) {
2469 LASTSTATE=PREVSTATE;
2470 }
2471
2472 return dataphase;
2473}
2474
2475
2476
2477
2478
2479
2480
2481static void parerr_run(struct Scsi_Host *shpnt)
2482{
2483 printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC));
2484 done(shpnt, DID_PARITY << 16);
2485}
2486
2487
2488
2489
2490
2491static void rsti_run(struct Scsi_Host *shpnt)
2492{
2493 Scsi_Cmnd *ptr;
2494
2495 printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO);
2496
2497 ptr=DISCONNECTED_SC;
2498 while(ptr) {
2499 Scsi_Cmnd *next = SCNEXT(ptr);
2500
2501 if (!ptr->device->soft_reset) {
2502 remove_SC(&DISCONNECTED_SC, ptr);
2503
2504 kfree(ptr->host_scribble);
2505 ptr->host_scribble=NULL;
2506
2507 ptr->result = DID_RESET << 16;
2508 ptr->scsi_done(ptr);
2509 }
2510
2511 ptr = next;
2512 }
2513
2514 if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2515 done(shpnt, DID_RESET << 16 );
2516}
2517
2518
2519
2520
2521
2522
2523static void is_complete(struct Scsi_Host *shpnt)
2524{
2525 int dataphase;
2526 unsigned long flags;
2527 int pending;
2528
2529 if(!shpnt)
2530 return;
2531
2532 DO_LOCK(flags);
2533
2534 if( HOSTDATA(shpnt)->service==0 ) {
2535 DO_UNLOCK(flags);
2536 return;
2537 }
2538
2539 HOSTDATA(shpnt)->service = 0;
2540
2541 if(HOSTDATA(shpnt)->in_intr) {
2542 DO_UNLOCK(flags);
2543
2544 aha152x_error(shpnt, "bottom-half already running!?");
2545 }
2546 HOSTDATA(shpnt)->in_intr++;
2547
2548
2549
2550
2551
2552 do {
2553 unsigned long start = jiffies;
2554 DO_UNLOCK(flags);
2555
2556 dataphase=update_state(shpnt);
2557
2558 DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2559
2560
2561
2562
2563
2564 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2565 states[PREVSTATE].end(shpnt);
2566
2567
2568
2569
2570
2571
2572 if(states[PREVSTATE].spio && !states[STATE].spio) {
2573 SETPORT(SXFRCTL0, CH1);
2574 SETPORT(DMACNTRL0, 0);
2575 if(CURRENT_SC)
2576 CURRENT_SC->SCp.phase &= ~spiordy;
2577 }
2578
2579
2580
2581
2582
2583 if(dataphase) {
2584 SETPORT(SSTAT0, REQINIT);
2585 SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2586 SETPORT(SSTAT1, PHASECHG);
2587 }
2588
2589
2590
2591
2592
2593
2594 if(!states[PREVSTATE].spio && states[STATE].spio) {
2595 SETPORT(DMACNTRL0, 0);
2596 SETPORT(SXFRCTL0, CH1|SPIOEN);
2597 if(CURRENT_SC)
2598 CURRENT_SC->SCp.phase |= spiordy;
2599 }
2600
2601
2602
2603
2604
2605 if(PREVSTATE!=STATE && states[STATE].init)
2606 states[STATE].init(shpnt);
2607
2608
2609
2610
2611
2612 if(states[STATE].run)
2613 states[STATE].run(shpnt);
2614 else
2615 printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE);
2616
2617
2618
2619
2620
2621
2622
2623 DO_LOCK(flags);
2624 pending=setup_expected_interrupts(shpnt);
2625#if defined(AHA152X_STAT)
2626 HOSTDATA(shpnt)->count[STATE]++;
2627 if(PREVSTATE!=STATE)
2628 HOSTDATA(shpnt)->count_trans[STATE]++;
2629 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2630#endif
2631
2632 DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2633 } while(pending);
2634
2635
2636
2637
2638
2639 HOSTDATA(shpnt)->in_intr--;
2640 SETBITS(DMACNTRL0, INTEN);
2641 DO_UNLOCK(flags);
2642}
2643
2644
2645
2646
2647
2648static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2649{
2650 printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg);
2651 show_queues(shpnt);
2652 panic("aha152x panic\n");
2653}
2654
2655
2656
2657
2658static void disp_ports(struct Scsi_Host *shpnt)
2659{
2660#if defined(AHA152X_DEBUG)
2661 int s;
2662
2663 printk("\n%s: %s(%s) ",
2664 CURRENT_SC ? "busy" : "waiting",
2665 states[STATE].name,
2666 states[PREVSTATE].name);
2667
2668 s = GETPORT(SCSISEQ);
2669 printk("SCSISEQ( ");
2670 if (s & TEMODEO)
2671 printk("TARGET MODE ");
2672 if (s & ENSELO)
2673 printk("SELO ");
2674 if (s & ENSELI)
2675 printk("SELI ");
2676 if (s & ENRESELI)
2677 printk("RESELI ");
2678 if (s & ENAUTOATNO)
2679 printk("AUTOATNO ");
2680 if (s & ENAUTOATNI)
2681 printk("AUTOATNI ");
2682 if (s & ENAUTOATNP)
2683 printk("AUTOATNP ");
2684 if (s & SCSIRSTO)
2685 printk("SCSIRSTO ");
2686 printk(");");
2687
2688 printk(" SCSISIG(");
2689 s = GETPORT(SCSISIG);
2690 switch (s & P_MASK) {
2691 case P_DATAO:
2692 printk("DATA OUT");
2693 break;
2694 case P_DATAI:
2695 printk("DATA IN");
2696 break;
2697 case P_CMD:
2698 printk("COMMAND");
2699 break;
2700 case P_STATUS:
2701 printk("STATUS");
2702 break;
2703 case P_MSGO:
2704 printk("MESSAGE OUT");
2705 break;
2706 case P_MSGI:
2707 printk("MESSAGE IN");
2708 break;
2709 default:
2710 printk("*invalid*");
2711 break;
2712 }
2713
2714 printk("); ");
2715
2716 printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2717
2718 printk("SSTAT( ");
2719 s = GETPORT(SSTAT0);
2720 if (s & TARGET)
2721 printk("TARGET ");
2722 if (s & SELDO)
2723 printk("SELDO ");
2724 if (s & SELDI)
2725 printk("SELDI ");
2726 if (s & SELINGO)
2727 printk("SELINGO ");
2728 if (s & SWRAP)
2729 printk("SWRAP ");
2730 if (s & SDONE)
2731 printk("SDONE ");
2732 if (s & SPIORDY)
2733 printk("SPIORDY ");
2734 if (s & DMADONE)
2735 printk("DMADONE ");
2736
2737 s = GETPORT(SSTAT1);
2738 if (s & SELTO)
2739 printk("SELTO ");
2740 if (s & ATNTARG)
2741 printk("ATNTARG ");
2742 if (s & SCSIRSTI)
2743 printk("SCSIRSTI ");
2744 if (s & PHASEMIS)
2745 printk("PHASEMIS ");
2746 if (s & BUSFREE)
2747 printk("BUSFREE ");
2748 if (s & SCSIPERR)
2749 printk("SCSIPERR ");
2750 if (s & PHASECHG)
2751 printk("PHASECHG ");
2752 if (s & REQINIT)
2753 printk("REQINIT ");
2754 printk("); ");
2755
2756
2757 printk("SSTAT( ");
2758
2759 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2760
2761 if (s & TARGET)
2762 printk("TARGET ");
2763 if (s & SELDO)
2764 printk("SELDO ");
2765 if (s & SELDI)
2766 printk("SELDI ");
2767 if (s & SELINGO)
2768 printk("SELINGO ");
2769 if (s & SWRAP)
2770 printk("SWRAP ");
2771 if (s & SDONE)
2772 printk("SDONE ");
2773 if (s & SPIORDY)
2774 printk("SPIORDY ");
2775 if (s & DMADONE)
2776 printk("DMADONE ");
2777
2778 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2779
2780 if (s & SELTO)
2781 printk("SELTO ");
2782 if (s & ATNTARG)
2783 printk("ATNTARG ");
2784 if (s & SCSIRSTI)
2785 printk("SCSIRSTI ");
2786 if (s & PHASEMIS)
2787 printk("PHASEMIS ");
2788 if (s & BUSFREE)
2789 printk("BUSFREE ");
2790 if (s & SCSIPERR)
2791 printk("SCSIPERR ");
2792 if (s & PHASECHG)
2793 printk("PHASECHG ");
2794 if (s & REQINIT)
2795 printk("REQINIT ");
2796 printk("); ");
2797
2798 printk("SXFRCTL0( ");
2799
2800 s = GETPORT(SXFRCTL0);
2801 if (s & SCSIEN)
2802 printk("SCSIEN ");
2803 if (s & DMAEN)
2804 printk("DMAEN ");
2805 if (s & CH1)
2806 printk("CH1 ");
2807 if (s & CLRSTCNT)
2808 printk("CLRSTCNT ");
2809 if (s & SPIOEN)
2810 printk("SPIOEN ");
2811 if (s & CLRCH1)
2812 printk("CLRCH1 ");
2813 printk("); ");
2814
2815 printk("SIGNAL( ");
2816
2817 s = GETPORT(SCSISIG);
2818 if (s & SIG_ATNI)
2819 printk("ATNI ");
2820 if (s & SIG_SELI)
2821 printk("SELI ");
2822 if (s & SIG_BSYI)
2823 printk("BSYI ");
2824 if (s & SIG_REQI)
2825 printk("REQI ");
2826 if (s & SIG_ACKI)
2827 printk("ACKI ");
2828 printk("); ");
2829
2830 printk("SELID (%02x), ", GETPORT(SELID));
2831
2832 printk("STCNT (%d), ", GETSTCNT());
2833
2834 printk("SSTAT2( ");
2835
2836 s = GETPORT(SSTAT2);
2837 if (s & SOFFSET)
2838 printk("SOFFSET ");
2839 if (s & SEMPTY)
2840 printk("SEMPTY ");
2841 if (s & SFULL)
2842 printk("SFULL ");
2843 printk("); SFCNT (%d); ", s & (SFULL | SFCNT));
2844
2845 s = GETPORT(SSTAT3);
2846 printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2847
2848 printk("SSTAT4( ");
2849 s = GETPORT(SSTAT4);
2850 if (s & SYNCERR)
2851 printk("SYNCERR ");
2852 if (s & FWERR)
2853 printk("FWERR ");
2854 if (s & FRERR)
2855 printk("FRERR ");
2856 printk("); ");
2857
2858 printk("DMACNTRL0( ");
2859 s = GETPORT(DMACNTRL0);
2860 printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
2861 printk("%s ", s & DMA ? "DMA" : "PIO");
2862 printk("%s ", s & WRITE_READ ? "WRITE" : "READ");
2863 if (s & ENDMA)
2864 printk("ENDMA ");
2865 if (s & INTEN)
2866 printk("INTEN ");
2867 if (s & RSTFIFO)
2868 printk("RSTFIFO ");
2869 if (s & SWINT)
2870 printk("SWINT ");
2871 printk("); ");
2872
2873 printk("DMASTAT( ");
2874 s = GETPORT(DMASTAT);
2875 if (s & ATDONE)
2876 printk("ATDONE ");
2877 if (s & WORDRDY)
2878 printk("WORDRDY ");
2879 if (s & DFIFOFULL)
2880 printk("DFIFOFULL ");
2881 if (s & DFIFOEMP)
2882 printk("DFIFOEMP ");
2883 printk(")\n");
2884#endif
2885}
2886
2887
2888
2889
2890static void disp_enintr(struct Scsi_Host *shpnt)
2891{
2892 int s;
2893
2894 printk(KERN_DEBUG "enabled interrupts ( ");
2895
2896 s = GETPORT(SIMODE0);
2897 if (s & ENSELDO)
2898 printk("ENSELDO ");
2899 if (s & ENSELDI)
2900 printk("ENSELDI ");
2901 if (s & ENSELINGO)
2902 printk("ENSELINGO ");
2903 if (s & ENSWRAP)
2904 printk("ENSWRAP ");
2905 if (s & ENSDONE)
2906 printk("ENSDONE ");
2907 if (s & ENSPIORDY)
2908 printk("ENSPIORDY ");
2909 if (s & ENDMADONE)
2910 printk("ENDMADONE ");
2911
2912 s = GETPORT(SIMODE1);
2913 if (s & ENSELTIMO)
2914 printk("ENSELTIMO ");
2915 if (s & ENATNTARG)
2916 printk("ENATNTARG ");
2917 if (s & ENPHASEMIS)
2918 printk("ENPHASEMIS ");
2919 if (s & ENBUSFREE)
2920 printk("ENBUSFREE ");
2921 if (s & ENSCSIPERR)
2922 printk("ENSCSIPERR ");
2923 if (s & ENPHASECHG)
2924 printk("ENPHASECHG ");
2925 if (s & ENREQINIT)
2926 printk("ENREQINIT ");
2927 printk(")\n");
2928}
2929
2930
2931
2932
2933static void show_command(Scsi_Cmnd *ptr)
2934{
2935 scmd_printk(KERN_DEBUG, ptr, "%p: cmnd=(", ptr);
2936
2937 __scsi_print_command(ptr->cmnd);
2938
2939 printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
2940 scsi_bufflen(ptr), scsi_get_resid(ptr));
2941
2942 if (ptr->SCp.phase & not_issued)
2943 printk("not issued|");
2944 if (ptr->SCp.phase & selecting)
2945 printk("selecting|");
2946 if (ptr->SCp.phase & identified)
2947 printk("identified|");
2948 if (ptr->SCp.phase & disconnected)
2949 printk("disconnected|");
2950 if (ptr->SCp.phase & completed)
2951 printk("completed|");
2952 if (ptr->SCp.phase & spiordy)
2953 printk("spiordy|");
2954 if (ptr->SCp.phase & syncneg)
2955 printk("syncneg|");
2956 if (ptr->SCp.phase & aborted)
2957 printk("aborted|");
2958 if (ptr->SCp.phase & resetted)
2959 printk("resetted|");
2960 if( SCDATA(ptr) ) {
2961 printk("; next=0x%p\n", SCNEXT(ptr));
2962 } else {
2963 printk("; next=(host scribble NULL)\n");
2964 }
2965}
2966
2967
2968
2969
2970static void show_queues(struct Scsi_Host *shpnt)
2971{
2972 Scsi_Cmnd *ptr;
2973 unsigned long flags;
2974
2975 DO_LOCK(flags);
2976 printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2977 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2978 show_command(ptr);
2979 DO_UNLOCK(flags);
2980
2981 printk(KERN_DEBUG "current_SC:\n");
2982 if (CURRENT_SC)
2983 show_command(CURRENT_SC);
2984 else
2985 printk(KERN_DEBUG "none\n");
2986
2987 printk(KERN_DEBUG "disconnected_SC:\n");
2988 for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2989 show_command(ptr);
2990
2991 disp_ports(shpnt);
2992 disp_enintr(shpnt);
2993}
2994
2995#undef SPRINTF
2996#define SPRINTF(args...) pos += sprintf(pos, ## args)
2997
2998static int get_command(char *pos, Scsi_Cmnd * ptr)
2999{
3000 char *start = pos;
3001 int i;
3002
3003 SPRINTF("0x%08x: target=%d; lun=%d; cmnd=( ",
3004 (unsigned int) ptr, ptr->device->id, ptr->device->lun);
3005
3006 for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
3007 SPRINTF("0x%02x ", ptr->cmnd[i]);
3008
3009 SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
3010 scsi_get_resid(ptr), ptr->SCp.this_residual,
3011 ptr->SCp.buffers_residual);
3012
3013 if (ptr->SCp.phase & not_issued)
3014 SPRINTF("not issued|");
3015 if (ptr->SCp.phase & selecting)
3016 SPRINTF("selecting|");
3017 if (ptr->SCp.phase & disconnected)
3018 SPRINTF("disconnected|");
3019 if (ptr->SCp.phase & aborted)
3020 SPRINTF("aborted|");
3021 if (ptr->SCp.phase & identified)
3022 SPRINTF("identified|");
3023 if (ptr->SCp.phase & completed)
3024 SPRINTF("completed|");
3025 if (ptr->SCp.phase & spiordy)
3026 SPRINTF("spiordy|");
3027 if (ptr->SCp.phase & syncneg)
3028 SPRINTF("syncneg|");
3029 SPRINTF("; next=0x%p\n", SCNEXT(ptr));
3030
3031 return (pos - start);
3032}
3033
3034static int get_ports(struct Scsi_Host *shpnt, char *pos)
3035{
3036 char *start = pos;
3037 int s;
3038
3039 SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
3040
3041 s = GETPORT(SCSISEQ);
3042 SPRINTF("SCSISEQ( ");
3043 if (s & TEMODEO)
3044 SPRINTF("TARGET MODE ");
3045 if (s & ENSELO)
3046 SPRINTF("SELO ");
3047 if (s & ENSELI)
3048 SPRINTF("SELI ");
3049 if (s & ENRESELI)
3050 SPRINTF("RESELI ");
3051 if (s & ENAUTOATNO)
3052 SPRINTF("AUTOATNO ");
3053 if (s & ENAUTOATNI)
3054 SPRINTF("AUTOATNI ");
3055 if (s & ENAUTOATNP)
3056 SPRINTF("AUTOATNP ");
3057 if (s & SCSIRSTO)
3058 SPRINTF("SCSIRSTO ");
3059 SPRINTF(");");
3060
3061 SPRINTF(" SCSISIG(");
3062 s = GETPORT(SCSISIG);
3063 switch (s & P_MASK) {
3064 case P_DATAO:
3065 SPRINTF("DATA OUT");
3066 break;
3067 case P_DATAI:
3068 SPRINTF("DATA IN");
3069 break;
3070 case P_CMD:
3071 SPRINTF("COMMAND");
3072 break;
3073 case P_STATUS:
3074 SPRINTF("STATUS");
3075 break;
3076 case P_MSGO:
3077 SPRINTF("MESSAGE OUT");
3078 break;
3079 case P_MSGI:
3080 SPRINTF("MESSAGE IN");
3081 break;
3082 default:
3083 SPRINTF("*invalid*");
3084 break;
3085 }
3086
3087 SPRINTF("); ");
3088
3089 SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
3090
3091 SPRINTF("SSTAT( ");
3092 s = GETPORT(SSTAT0);
3093 if (s & TARGET)
3094 SPRINTF("TARGET ");
3095 if (s & SELDO)
3096 SPRINTF("SELDO ");
3097 if (s & SELDI)
3098 SPRINTF("SELDI ");
3099 if (s & SELINGO)
3100 SPRINTF("SELINGO ");
3101 if (s & SWRAP)
3102 SPRINTF("SWRAP ");
3103 if (s & SDONE)
3104 SPRINTF("SDONE ");
3105 if (s & SPIORDY)
3106 SPRINTF("SPIORDY ");
3107 if (s & DMADONE)
3108 SPRINTF("DMADONE ");
3109
3110 s = GETPORT(SSTAT1);
3111 if (s & SELTO)
3112 SPRINTF("SELTO ");
3113 if (s & ATNTARG)
3114 SPRINTF("ATNTARG ");
3115 if (s & SCSIRSTI)
3116 SPRINTF("SCSIRSTI ");
3117 if (s & PHASEMIS)
3118 SPRINTF("PHASEMIS ");
3119 if (s & BUSFREE)
3120 SPRINTF("BUSFREE ");
3121 if (s & SCSIPERR)
3122 SPRINTF("SCSIPERR ");
3123 if (s & PHASECHG)
3124 SPRINTF("PHASECHG ");
3125 if (s & REQINIT)
3126 SPRINTF("REQINIT ");
3127 SPRINTF("); ");
3128
3129
3130 SPRINTF("SSTAT( ");
3131
3132 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
3133
3134 if (s & TARGET)
3135 SPRINTF("TARGET ");
3136 if (s & SELDO)
3137 SPRINTF("SELDO ");
3138 if (s & SELDI)
3139 SPRINTF("SELDI ");
3140 if (s & SELINGO)
3141 SPRINTF("SELINGO ");
3142 if (s & SWRAP)
3143 SPRINTF("SWRAP ");
3144 if (s & SDONE)
3145 SPRINTF("SDONE ");
3146 if (s & SPIORDY)
3147 SPRINTF("SPIORDY ");
3148 if (s & DMADONE)
3149 SPRINTF("DMADONE ");
3150
3151 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
3152
3153 if (s & SELTO)
3154 SPRINTF("SELTO ");
3155 if (s & ATNTARG)
3156 SPRINTF("ATNTARG ");
3157 if (s & SCSIRSTI)
3158 SPRINTF("SCSIRSTI ");
3159 if (s & PHASEMIS)
3160 SPRINTF("PHASEMIS ");
3161 if (s & BUSFREE)
3162 SPRINTF("BUSFREE ");
3163 if (s & SCSIPERR)
3164 SPRINTF("SCSIPERR ");
3165 if (s & PHASECHG)
3166 SPRINTF("PHASECHG ");
3167 if (s & REQINIT)
3168 SPRINTF("REQINIT ");
3169 SPRINTF("); ");
3170
3171 SPRINTF("SXFRCTL0( ");
3172
3173 s = GETPORT(SXFRCTL0);
3174 if (s & SCSIEN)
3175 SPRINTF("SCSIEN ");
3176 if (s & DMAEN)
3177 SPRINTF("DMAEN ");
3178 if (s & CH1)
3179 SPRINTF("CH1 ");
3180 if (s & CLRSTCNT)
3181 SPRINTF("CLRSTCNT ");
3182 if (s & SPIOEN)
3183 SPRINTF("SPIOEN ");
3184 if (s & CLRCH1)
3185 SPRINTF("CLRCH1 ");
3186 SPRINTF("); ");
3187
3188 SPRINTF("SIGNAL( ");
3189
3190 s = GETPORT(SCSISIG);
3191 if (s & SIG_ATNI)
3192 SPRINTF("ATNI ");
3193 if (s & SIG_SELI)
3194 SPRINTF("SELI ");
3195 if (s & SIG_BSYI)
3196 SPRINTF("BSYI ");
3197 if (s & SIG_REQI)
3198 SPRINTF("REQI ");
3199 if (s & SIG_ACKI)
3200 SPRINTF("ACKI ");
3201 SPRINTF("); ");
3202
3203 SPRINTF("SELID(%02x), ", GETPORT(SELID));
3204
3205 SPRINTF("STCNT(%d), ", GETSTCNT());
3206
3207 SPRINTF("SSTAT2( ");
3208
3209 s = GETPORT(SSTAT2);
3210 if (s & SOFFSET)
3211 SPRINTF("SOFFSET ");
3212 if (s & SEMPTY)
3213 SPRINTF("SEMPTY ");
3214 if (s & SFULL)
3215 SPRINTF("SFULL ");
3216 SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT));
3217
3218 s = GETPORT(SSTAT3);
3219 SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
3220
3221 SPRINTF("SSTAT4( ");
3222 s = GETPORT(SSTAT4);
3223 if (s & SYNCERR)
3224 SPRINTF("SYNCERR ");
3225 if (s & FWERR)
3226 SPRINTF("FWERR ");
3227 if (s & FRERR)
3228 SPRINTF("FRERR ");
3229 SPRINTF("); ");
3230
3231 SPRINTF("DMACNTRL0( ");
3232 s = GETPORT(DMACNTRL0);
3233 SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
3234 SPRINTF("%s ", s & DMA ? "DMA" : "PIO");
3235 SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ");
3236 if (s & ENDMA)
3237 SPRINTF("ENDMA ");
3238 if (s & INTEN)
3239 SPRINTF("INTEN ");
3240 if (s & RSTFIFO)
3241 SPRINTF("RSTFIFO ");
3242 if (s & SWINT)
3243 SPRINTF("SWINT ");
3244 SPRINTF("); ");
3245
3246 SPRINTF("DMASTAT( ");
3247 s = GETPORT(DMASTAT);
3248 if (s & ATDONE)
3249 SPRINTF("ATDONE ");
3250 if (s & WORDRDY)
3251 SPRINTF("WORDRDY ");
3252 if (s & DFIFOFULL)
3253 SPRINTF("DFIFOFULL ");
3254 if (s & DFIFOEMP)
3255 SPRINTF("DFIFOEMP ");
3256 SPRINTF(")\n");
3257
3258 SPRINTF("enabled interrupts( ");
3259
3260 s = GETPORT(SIMODE0);
3261 if (s & ENSELDO)
3262 SPRINTF("ENSELDO ");
3263 if (s & ENSELDI)
3264 SPRINTF("ENSELDI ");
3265 if (s & ENSELINGO)
3266 SPRINTF("ENSELINGO ");
3267 if (s & ENSWRAP)
3268 SPRINTF("ENSWRAP ");
3269 if (s & ENSDONE)
3270 SPRINTF("ENSDONE ");
3271 if (s & ENSPIORDY)
3272 SPRINTF("ENSPIORDY ");
3273 if (s & ENDMADONE)
3274 SPRINTF("ENDMADONE ");
3275
3276 s = GETPORT(SIMODE1);
3277 if (s & ENSELTIMO)
3278 SPRINTF("ENSELTIMO ");
3279 if (s & ENATNTARG)
3280 SPRINTF("ENATNTARG ");
3281 if (s & ENPHASEMIS)
3282 SPRINTF("ENPHASEMIS ");
3283 if (s & ENBUSFREE)
3284 SPRINTF("ENBUSFREE ");
3285 if (s & ENSCSIPERR)
3286 SPRINTF("ENSCSIPERR ");
3287 if (s & ENPHASECHG)
3288 SPRINTF("ENPHASECHG ");
3289 if (s & ENREQINIT)
3290 SPRINTF("ENREQINIT ");
3291 SPRINTF(")\n");
3292
3293 return (pos - start);
3294}
3295
3296static int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt)
3297{
3298 if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
3299 return -EINVAL;
3300
3301#if defined(AHA152X_DEBUG)
3302 if(length>14 && strncmp("debug ", buffer+8, 6)==0) {
3303 int debug = HOSTDATA(shpnt)->debug;
3304
3305 HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0);
3306
3307 printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug);
3308 } else
3309#endif
3310#if defined(AHA152X_STAT)
3311 if(length>13 && strncmp("reset", buffer+8, 5)==0) {
3312 int i;
3313
3314 HOSTDATA(shpnt)->total_commands=0;
3315 HOSTDATA(shpnt)->disconnections=0;
3316 HOSTDATA(shpnt)->busfree_without_any_action=0;
3317 HOSTDATA(shpnt)->busfree_without_old_command=0;
3318 HOSTDATA(shpnt)->busfree_without_new_command=0;
3319 HOSTDATA(shpnt)->busfree_without_done_command=0;
3320 HOSTDATA(shpnt)->busfree_with_check_condition=0;
3321 for (i = idle; i<maxstate; i++) {
3322 HOSTDATA(shpnt)->count[i]=0;
3323 HOSTDATA(shpnt)->count_trans[i]=0;
3324 HOSTDATA(shpnt)->time[i]=0;
3325 }
3326
3327 printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO);
3328
3329 } else
3330#endif
3331 {
3332 return -EINVAL;
3333 }
3334
3335
3336 return length;
3337}
3338
3339#undef SPRINTF
3340#define SPRINTF(args...) \
3341 do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0)
3342
3343static int aha152x_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start,
3344 off_t offset, int length, int inout)
3345{
3346 int i;
3347 char *pos = buffer;
3348 Scsi_Cmnd *ptr;
3349 unsigned long flags;
3350 int thislength;
3351
3352 DPRINTK(debug_procinfo,
3353 KERN_DEBUG "aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n",
3354 buffer, offset, length, shpnt->host_no, inout);
3355
3356
3357 if (inout)
3358 return aha152x_set_info(buffer, length, shpnt);
3359
3360 SPRINTF(AHA152X_REVID "\n");
3361
3362 SPRINTF("ioports 0x%04lx to 0x%04lx\n",
3363 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
3364 SPRINTF("interrupt 0x%02x\n", shpnt->irq);
3365 SPRINTF("disconnection/reconnection %s\n",
3366 RECONNECT ? "enabled" : "disabled");
3367 SPRINTF("parity checking %s\n",
3368 PARITY ? "enabled" : "disabled");
3369 SPRINTF("synchronous transfers %s\n",
3370 SYNCHRONOUS ? "enabled" : "disabled");
3371 SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands);
3372
3373 if(SYNCHRONOUS) {
3374 SPRINTF("synchronously operating targets (tick=50 ns):\n");
3375 for (i = 0; i < 8; i++)
3376 if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
3377 SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
3378 i,
3379 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
3380 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
3381 HOSTDATA(shpnt)->syncrate[i] & 0x0f);
3382 }
3383#if defined(AHA152X_DEBUG)
3384#define PDEBUG(flags,txt) \
3385 if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
3386
3387 SPRINTF("enabled debugging options: ");
3388
3389 PDEBUG(debug_procinfo, "procinfo");
3390 PDEBUG(debug_queue, "queue");
3391 PDEBUG(debug_intr, "interrupt");
3392 PDEBUG(debug_selection, "selection");
3393 PDEBUG(debug_msgo, "message out");
3394 PDEBUG(debug_msgi, "message in");
3395 PDEBUG(debug_status, "status");
3396 PDEBUG(debug_cmd, "command");
3397 PDEBUG(debug_datai, "data in");
3398 PDEBUG(debug_datao, "data out");
3399 PDEBUG(debug_eh, "eh");
3400 PDEBUG(debug_locking, "locks");
3401 PDEBUG(debug_phases, "phases");
3402
3403 SPRINTF("\n");
3404#endif
3405
3406 SPRINTF("\nqueue status:\n");
3407 DO_LOCK(flags);
3408 if (ISSUE_SC) {
3409 SPRINTF("not yet issued commands:\n");
3410 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
3411 pos += get_command(pos, ptr);
3412 } else
3413 SPRINTF("no not yet issued commands\n");
3414 DO_UNLOCK(flags);
3415
3416 if (CURRENT_SC) {
3417 SPRINTF("current command:\n");
3418 pos += get_command(pos, CURRENT_SC);
3419 } else
3420 SPRINTF("no current command\n");
3421
3422 if (DISCONNECTED_SC) {
3423 SPRINTF("disconnected commands:\n");
3424 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
3425 pos += get_command(pos, ptr);
3426 } else
3427 SPRINTF("no disconnected commands\n");
3428
3429 pos += get_ports(shpnt, pos);
3430
3431#if defined(AHA152X_STAT)
3432 SPRINTF("statistics:\n"
3433 "total commands: %d\n"
3434 "disconnections: %d\n"
3435 "busfree with check condition: %d\n"
3436 "busfree without old command: %d\n"
3437 "busfree without new command: %d\n"
3438 "busfree without done command: %d\n"
3439 "busfree without any action: %d\n"
3440 "state "
3441 "transitions "
3442 "count "
3443 "time\n",
3444 HOSTDATA(shpnt)->total_commands,
3445 HOSTDATA(shpnt)->disconnections,
3446 HOSTDATA(shpnt)->busfree_with_check_condition,
3447 HOSTDATA(shpnt)->busfree_without_old_command,
3448 HOSTDATA(shpnt)->busfree_without_new_command,
3449 HOSTDATA(shpnt)->busfree_without_done_command,
3450 HOSTDATA(shpnt)->busfree_without_any_action);
3451 for(i=0; i<maxstate; i++) {
3452 SPRINTF("%-10s %-12d %-12d %-12ld\n",
3453 states[i].name,
3454 HOSTDATA(shpnt)->count_trans[i],
3455 HOSTDATA(shpnt)->count[i],
3456 HOSTDATA(shpnt)->time[i]);
3457 }
3458#endif
3459
3460 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: pos=%p\n", pos);
3461
3462 thislength = pos - (buffer + offset);
3463 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: length=%d thislength=%d\n", length, thislength);
3464
3465 if(thislength<0) {
3466 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: output too short\n");
3467 *start = NULL;
3468 return 0;
3469 }
3470
3471 thislength = thislength<length ? thislength : length;
3472
3473 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: return %d\n", thislength);
3474
3475 *start = buffer + offset;
3476 return thislength < length ? thislength : length;
3477}
3478
3479static int aha152x_adjust_queue(struct scsi_device *device)
3480{
3481 blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
3482 return 0;
3483}
3484
3485static struct scsi_host_template aha152x_driver_template = {
3486 .module = THIS_MODULE,
3487 .name = AHA152X_REVID,
3488 .proc_name = "aha152x",
3489 .proc_info = aha152x_proc_info,
3490 .queuecommand = aha152x_queue,
3491 .eh_abort_handler = aha152x_abort,
3492 .eh_device_reset_handler = aha152x_device_reset,
3493 .eh_bus_reset_handler = aha152x_bus_reset,
3494 .eh_host_reset_handler = aha152x_host_reset,
3495 .bios_param = aha152x_biosparam,
3496 .can_queue = 1,
3497 .this_id = 7,
3498 .sg_tablesize = SG_ALL,
3499 .cmd_per_lun = 1,
3500 .use_clustering = DISABLE_CLUSTERING,
3501 .slave_alloc = aha152x_adjust_queue,
3502};
3503
3504#if !defined(PCMCIA)
3505static int setup_count;
3506static struct aha152x_setup setup[2];
3507
3508
3509static unsigned short ports[] = { 0x340, 0x140 };
3510
3511#if !defined(SKIP_BIOSTEST)
3512
3513static unsigned int addresses[] =
3514{
3515 0xdc000,
3516 0xc8000,
3517 0xcc000,
3518 0xd0000,
3519 0xd4000,
3520 0xd8000,
3521 0xe0000,
3522 0xeb800,
3523 0xf0000,
3524};
3525
3526
3527
3528
3529
3530
3531
3532
3533static struct signature {
3534 unsigned char *signature;
3535 int sig_offset;
3536 int sig_length;
3537} signatures[] =
3538{
3539 { "Adaptec AHA-1520 BIOS", 0x102e, 21 },
3540
3541 { "Adaptec AHA-1520B", 0x000b, 17 },
3542
3543 { "Adaptec AHA-1520B", 0x0026, 17 },
3544
3545 { "Adaptec ASW-B626 BIOS", 0x1029, 21 },
3546
3547 { "Adaptec BIOS: ASW-B626", 0x000f, 22 },
3548
3549 { "Adaptec ASW-B626 S2", 0x2e6c, 19 },
3550
3551 { "Adaptec BIOS:AIC-6360", 0x000c, 21 },
3552
3553 { "ScsiPro SP-360 BIOS", 0x2873, 19 },
3554
3555 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3556
3557 { "Adaptec BIOS:AVA-282X", 0x000c, 21 },
3558
3559 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 },
3560
3561 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 },
3562
3563 { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3564
3565};
3566#endif
3567
3568
3569
3570
3571
3572static int aha152x_porttest(int io_port)
3573{
3574 int i;
3575
3576 SETPORT(io_port + O_DMACNTRL1, 0);
3577 for (i = 0; i < 16; i++)
3578 SETPORT(io_port + O_STACK, i);
3579
3580 SETPORT(io_port + O_DMACNTRL1, 0);
3581 for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3582 ;
3583
3584 return (i == 16);
3585}
3586
3587static int tc1550_porttest(int io_port)
3588{
3589 int i;
3590
3591 SETPORT(io_port + O_TC_DMACNTRL1, 0);
3592 for (i = 0; i < 16; i++)
3593 SETPORT(io_port + O_STACK, i);
3594
3595 SETPORT(io_port + O_TC_DMACNTRL1, 0);
3596 for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3597 ;
3598
3599 return (i == 16);
3600}
3601
3602
3603static int checksetup(struct aha152x_setup *setup)
3604{
3605 int i;
3606 for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3607 ;
3608
3609 if (i == ARRAY_SIZE(ports))
3610 return 0;
3611
3612 if ( request_region(setup->io_port, IO_RANGE, "aha152x")==0 ) {
3613 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3614 return 0;
3615 }
3616
3617 if( aha152x_porttest(setup->io_port) ) {
3618 setup->tc1550=0;
3619 } else if( tc1550_porttest(setup->io_port) ) {
3620 setup->tc1550=1;
3621 } else {
3622 release_region(setup->io_port, IO_RANGE);
3623 return 0;
3624 }
3625
3626 release_region(setup->io_port, IO_RANGE);
3627
3628 if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3629 return 0;
3630
3631 if ((setup->scsiid < 0) || (setup->scsiid > 7))
3632 return 0;
3633
3634 if ((setup->reconnect < 0) || (setup->reconnect > 1))
3635 return 0;
3636
3637 if ((setup->parity < 0) || (setup->parity > 1))
3638 return 0;
3639
3640 if ((setup->synchronous < 0) || (setup->synchronous > 1))
3641 return 0;
3642
3643 if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3644 return 0;
3645
3646
3647 return 1;
3648}
3649
3650
3651static int __init aha152x_init(void)
3652{
3653 int i, j, ok;
3654#if defined(AUTOCONF)
3655 aha152x_config conf;
3656#endif
3657#ifdef __ISAPNP__
3658 struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3659#endif
3660
3661 if ( setup_count ) {
3662 printk(KERN_INFO "aha152x: processing commandline: ");
3663
3664 for (i = 0; i<setup_count; i++) {
3665 if (!checksetup(&setup[i])) {
3666 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3667 printk(KERN_ERR "aha152x: invalid line\n");
3668 }
3669 }
3670 printk("ok\n");
3671 }
3672
3673#if defined(SETUP0)
3674 if (setup_count < ARRAY_SIZE(setup)) {
3675 struct aha152x_setup override = SETUP0;
3676
3677 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3678 if (!checksetup(&override)) {
3679 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3680 override.io_port,
3681 override.irq,
3682 override.scsiid,
3683 override.reconnect,
3684 override.parity,
3685 override.synchronous,
3686 override.delay,
3687 override.ext_trans);
3688 } else
3689 setup[setup_count++] = override;
3690 }
3691 }
3692#endif
3693
3694#if defined(SETUP1)
3695 if (setup_count < ARRAY_SIZE(setup)) {
3696 struct aha152x_setup override = SETUP1;
3697
3698 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3699 if (!checksetup(&override)) {
3700 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3701 override.io_port,
3702 override.irq,
3703 override.scsiid,
3704 override.reconnect,
3705 override.parity,
3706 override.synchronous,
3707 override.delay,
3708 override.ext_trans);
3709 } else
3710 setup[setup_count++] = override;
3711 }
3712 }
3713#endif
3714
3715#if defined(MODULE)
3716 if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3717 if(aha152x[0]!=0) {
3718 setup[setup_count].conf = "";
3719 setup[setup_count].io_port = aha152x[0];
3720 setup[setup_count].irq = aha152x[1];
3721 setup[setup_count].scsiid = aha152x[2];
3722 setup[setup_count].reconnect = aha152x[3];
3723 setup[setup_count].parity = aha152x[4];
3724 setup[setup_count].synchronous = aha152x[5];
3725 setup[setup_count].delay = aha152x[6];
3726 setup[setup_count].ext_trans = aha152x[7];
3727#if defined(AHA152X_DEBUG)
3728 setup[setup_count].debug = aha152x[8];
3729#endif
3730 } else if(io[0]!=0 || irq[0]!=0) {
3731 if(io[0]!=0) setup[setup_count].io_port = io[0];
3732 if(irq[0]!=0) setup[setup_count].irq = irq[0];
3733
3734 setup[setup_count].scsiid = scsiid[0];
3735 setup[setup_count].reconnect = reconnect[0];
3736 setup[setup_count].parity = parity[0];
3737 setup[setup_count].synchronous = sync[0];
3738 setup[setup_count].delay = delay[0];
3739 setup[setup_count].ext_trans = exttrans[0];
3740#if defined(AHA152X_DEBUG)
3741 setup[setup_count].debug = debug[0];
3742#endif
3743 }
3744
3745 if (checksetup(&setup[setup_count]))
3746 setup_count++;
3747 else
3748 printk(KERN_ERR "aha152x: invalid module params io=0x%x, irq=%d,scsiid=%d,reconnect=%d,parity=%d,sync=%d,delay=%d,exttrans=%d\n",
3749 setup[setup_count].io_port,
3750 setup[setup_count].irq,
3751 setup[setup_count].scsiid,
3752 setup[setup_count].reconnect,
3753 setup[setup_count].parity,
3754 setup[setup_count].synchronous,
3755 setup[setup_count].delay,
3756 setup[setup_count].ext_trans);
3757 }
3758
3759 if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3760 if(aha152x1[0]!=0) {
3761 setup[setup_count].conf = "";
3762 setup[setup_count].io_port = aha152x1[0];
3763 setup[setup_count].irq = aha152x1[1];
3764 setup[setup_count].scsiid = aha152x1[2];
3765 setup[setup_count].reconnect = aha152x1[3];
3766 setup[setup_count].parity = aha152x1[4];
3767 setup[setup_count].synchronous = aha152x1[5];
3768 setup[setup_count].delay = aha152x1[6];
3769 setup[setup_count].ext_trans = aha152x1[7];
3770#if defined(AHA152X_DEBUG)
3771 setup[setup_count].debug = aha152x1[8];
3772#endif
3773 } else if(io[1]!=0 || irq[1]!=0) {
3774 if(io[1]!=0) setup[setup_count].io_port = io[1];
3775 if(irq[1]!=0) setup[setup_count].irq = irq[1];
3776
3777 setup[setup_count].scsiid = scsiid[1];
3778 setup[setup_count].reconnect = reconnect[1];
3779 setup[setup_count].parity = parity[1];
3780 setup[setup_count].synchronous = sync[1];
3781 setup[setup_count].delay = delay[1];
3782 setup[setup_count].ext_trans = exttrans[1];
3783#if defined(AHA152X_DEBUG)
3784 setup[setup_count].debug = debug[1];
3785#endif
3786 }
3787 if (checksetup(&setup[setup_count]))
3788 setup_count++;
3789 else
3790 printk(KERN_ERR "aha152x: invalid module params io=0x%x, irq=%d,scsiid=%d,reconnect=%d,parity=%d,sync=%d,delay=%d,exttrans=%d\n",
3791 setup[setup_count].io_port,
3792 setup[setup_count].irq,
3793 setup[setup_count].scsiid,
3794 setup[setup_count].reconnect,
3795 setup[setup_count].parity,
3796 setup[setup_count].synchronous,
3797 setup[setup_count].delay,
3798 setup[setup_count].ext_trans);
3799 }
3800#endif
3801
3802#ifdef __ISAPNP__
3803 for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3804 while ( setup_count<ARRAY_SIZE(setup) &&
3805 (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3806 if (pnp_device_attach(dev) < 0)
3807 continue;
3808
3809 if (pnp_activate_dev(dev) < 0) {
3810 pnp_device_detach(dev);
3811 continue;
3812 }
3813
3814 if (!pnp_port_valid(dev, 0)) {
3815 pnp_device_detach(dev);
3816 continue;
3817 }
3818
3819 if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3820 pnp_device_detach(dev);
3821 continue;
3822 }
3823
3824 setup[setup_count].io_port = pnp_port_start(dev, 0);
3825 setup[setup_count].irq = pnp_irq(dev, 0);
3826 setup[setup_count].scsiid = 7;
3827 setup[setup_count].reconnect = 1;
3828 setup[setup_count].parity = 1;
3829 setup[setup_count].synchronous = 1;
3830 setup[setup_count].delay = DELAY_DEFAULT;
3831 setup[setup_count].ext_trans = 0;
3832#if defined(AHA152X_DEBUG)
3833 setup[setup_count].debug = DEBUG_DEFAULT;
3834#endif
3835#if defined(__ISAPNP__)
3836 pnpdev[setup_count] = dev;
3837#endif
3838 printk (KERN_INFO
3839 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3840 setup[setup_count].io_port, setup[setup_count].irq);
3841 setup_count++;
3842 }
3843 }
3844#endif
3845
3846#if defined(AUTOCONF)
3847 if (setup_count<ARRAY_SIZE(setup)) {
3848#if !defined(SKIP_BIOSTEST)
3849 ok = 0;
3850 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3851 void __iomem *p = ioremap(addresses[i], 0x4000);
3852 if (!p)
3853 continue;
3854 for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3855 ok = check_signature(p + signatures[j].sig_offset,
3856 signatures[j].signature, signatures[j].sig_length);
3857 iounmap(p);
3858 }
3859 if (!ok && setup_count == 0)
3860 return 0;
3861
3862 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3863#else
3864 printk(KERN_INFO "aha152x: ");
3865#endif
3866
3867 ok = 0;
3868 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3869 if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3870 continue;
3871
3872 if ( request_region(ports[i], IO_RANGE, "aha152x")==0 ) {
3873 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3874 continue;
3875 }
3876
3877 if (aha152x_porttest(ports[i])) {
3878 setup[setup_count].tc1550 = 0;
3879
3880 conf.cf_port =
3881 (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3882 } else if (tc1550_porttest(ports[i])) {
3883 setup[setup_count].tc1550 = 1;
3884
3885 conf.cf_port =
3886 (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3887 } else {
3888 release_region(ports[i], IO_RANGE);
3889 continue;
3890 }
3891
3892 release_region(ports[i], IO_RANGE);
3893
3894 ok++;
3895 setup[setup_count].io_port = ports[i];
3896 setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3897 setup[setup_count].scsiid = conf.cf_id;
3898 setup[setup_count].reconnect = conf.cf_tardisc;
3899 setup[setup_count].parity = !conf.cf_parity;
3900 setup[setup_count].synchronous = conf.cf_syncneg;
3901 setup[setup_count].delay = DELAY_DEFAULT;
3902 setup[setup_count].ext_trans = 0;
3903#if defined(AHA152X_DEBUG)
3904 setup[setup_count].debug = DEBUG_DEFAULT;
3905#endif
3906 setup_count++;
3907
3908 }
3909
3910 if (ok)
3911 printk("auto configuration: ok, ");
3912 }
3913#endif
3914
3915 printk("%d controller(s) configured\n", setup_count);
3916
3917 for (i=0; i<setup_count; i++) {
3918 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3919 struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3920
3921 if( !shpnt ) {
3922 release_region(setup[i].io_port, IO_RANGE);
3923#if defined(__ISAPNP__)
3924 } else if( pnpdev[i] ) {
3925 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3926 pnpdev[i]=NULL;
3927#endif
3928 }
3929 } else {
3930 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3931 }
3932
3933#if defined(__ISAPNP__)
3934 if( pnpdev[i] )
3935 pnp_device_detach(pnpdev[i]);
3936#endif
3937 }
3938
3939 return 1;
3940}
3941
3942static void __exit aha152x_exit(void)
3943{
3944 struct aha152x_hostdata *hd;
3945
3946 list_for_each_entry(hd, &aha152x_host_list, host_list) {
3947 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3948
3949 aha152x_release(shost);
3950 }
3951}
3952
3953module_init(aha152x_init);
3954module_exit(aha152x_exit);
3955
3956#if !defined(MODULE)
3957static int __init aha152x_setup(char *str)
3958{
3959#if defined(AHA152X_DEBUG)
3960 int ints[11];
3961#else
3962 int ints[10];
3963#endif
3964 get_options(str, ARRAY_SIZE(ints), ints);
3965
3966 if(setup_count>=ARRAY_SIZE(setup)) {
3967 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3968 return 1;
3969 }
3970
3971 setup[setup_count].conf = str;
3972 setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340;
3973 setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11;
3974 setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7;
3975 setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1;
3976 setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1;
3977 setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3978 setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3979 setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0;
3980#if defined(AHA152X_DEBUG)
3981 setup[setup_count].debug = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT;
3982 if (ints[0] > 9) {
3983 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3984 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
3985#else
3986 if (ints[0] > 8) {
3987 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3988 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3989#endif
3990 } else {
3991 setup_count++;
3992 return 0;
3993 }
3994
3995 return 1;
3996}
3997__setup("aha152x=", aha152x_setup);
3998#endif
3999
4000#endif
4001
