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