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