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, int error);
623
624
625static void show_command(struct scsi_cmnd * ptr);
626static void show_queues(struct Scsi_Host *shpnt);
627static void disp_enintr(struct Scsi_Host *shpnt);
628
629
630
631
632
633
634static inline void append_SC(struct scsi_cmnd **SC, struct scsi_cmnd *new_SC)
635{
636 struct scsi_cmnd *end;
637
638 SCNEXT(new_SC) = NULL;
639 if (!*SC)
640 *SC = new_SC;
641 else {
642 for (end = *SC; SCNEXT(end); end = SCNEXT(end))
643 ;
644 SCNEXT(end) = new_SC;
645 }
646}
647
648static inline struct scsi_cmnd *remove_first_SC(struct scsi_cmnd ** SC)
649{
650 struct scsi_cmnd *ptr;
651
652 ptr = *SC;
653 if (ptr) {
654 *SC = SCNEXT(*SC);
655 SCNEXT(ptr)=NULL;
656 }
657 return ptr;
658}
659
660static inline struct scsi_cmnd *remove_lun_SC(struct scsi_cmnd ** SC,
661 int target, int lun)
662{
663 struct scsi_cmnd *ptr, *prev;
664
665 for (ptr = *SC, prev = NULL;
666 ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
667 prev = ptr, ptr = SCNEXT(ptr))
668 ;
669
670 if (ptr) {
671 if (prev)
672 SCNEXT(prev) = SCNEXT(ptr);
673 else
674 *SC = SCNEXT(ptr);
675
676 SCNEXT(ptr)=NULL;
677 }
678
679 return ptr;
680}
681
682static inline struct scsi_cmnd *remove_SC(struct scsi_cmnd **SC,
683 struct scsi_cmnd *SCp)
684{
685 struct scsi_cmnd *ptr, *prev;
686
687 for (ptr = *SC, prev = NULL;
688 ptr && SCp!=ptr;
689 prev = ptr, ptr = SCNEXT(ptr))
690 ;
691
692 if (ptr) {
693 if (prev)
694 SCNEXT(prev) = SCNEXT(ptr);
695 else
696 *SC = SCNEXT(ptr);
697
698 SCNEXT(ptr)=NULL;
699 }
700
701 return ptr;
702}
703
704static irqreturn_t swintr(int irqno, void *dev_id)
705{
706 struct Scsi_Host *shpnt = dev_id;
707
708 HOSTDATA(shpnt)->swint++;
709
710 SETPORT(DMACNTRL0, INTEN);
711 return IRQ_HANDLED;
712}
713
714struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
715{
716 struct Scsi_Host *shpnt;
717
718 shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
719 if (!shpnt) {
720 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
721 return NULL;
722 }
723
724 memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
725 INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
726
727
728 list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
729
730 shpnt->io_port = setup->io_port;
731 shpnt->n_io_port = IO_RANGE;
732 shpnt->irq = setup->irq;
733
734 if (!setup->tc1550) {
735 HOSTIOPORT0 = setup->io_port;
736 HOSTIOPORT1 = setup->io_port;
737 } else {
738 HOSTIOPORT0 = setup->io_port+0x10;
739 HOSTIOPORT1 = setup->io_port-0x10;
740 }
741
742 spin_lock_init(&QLOCK);
743 RECONNECT = setup->reconnect;
744 SYNCHRONOUS = setup->synchronous;
745 PARITY = setup->parity;
746 DELAY = setup->delay;
747 EXT_TRANS = setup->ext_trans;
748
749 SETPORT(SCSIID, setup->scsiid << 4);
750 shpnt->this_id = setup->scsiid;
751
752 if (setup->reconnect)
753 shpnt->can_queue = AHA152X_MAXQUEUE;
754
755
756 printk("aha152x: resetting bus...\n");
757 SETPORT(SCSISEQ, SCSIRSTO);
758 mdelay(256);
759 SETPORT(SCSISEQ, 0);
760 mdelay(DELAY);
761
762 reset_ports(shpnt);
763
764 printk(KERN_INFO
765 "aha152x%d%s: "
766 "vital data: rev=%x, "
767 "io=0x%03lx (0x%03lx/0x%03lx), "
768 "irq=%d, "
769 "scsiid=%d, "
770 "reconnect=%s, "
771 "parity=%s, "
772 "synchronous=%s, "
773 "delay=%d, "
774 "extended translation=%s\n",
775 shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
776 GETPORT(REV) & 0x7,
777 shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
778 shpnt->irq,
779 shpnt->this_id,
780 RECONNECT ? "enabled" : "disabled",
781 PARITY ? "enabled" : "disabled",
782 SYNCHRONOUS ? "enabled" : "disabled",
783 DELAY,
784 EXT_TRANS ? "enabled" : "disabled");
785
786
787 SETPORT(SIMODE0, 0);
788 SETPORT(SIMODE1, 0);
789
790 if (request_irq(shpnt->irq, swintr, IRQF_SHARED, "aha152x", shpnt)) {
791 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
792 goto out_host_put;
793 }
794
795 HOSTDATA(shpnt)->swint = 0;
796
797 printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
798
799 mb();
800 SETPORT(DMACNTRL0, SWINT|INTEN);
801 mdelay(1000);
802 free_irq(shpnt->irq, shpnt);
803
804 if (!HOSTDATA(shpnt)->swint) {
805 if (TESTHI(DMASTAT, INTSTAT)) {
806 printk("lost.\n");
807 } else {
808 printk("failed.\n");
809 }
810
811 SETPORT(DMACNTRL0, INTEN);
812
813 printk(KERN_ERR "aha152x%d: irq %d possibly wrong. "
814 "Please verify.\n", shpnt->host_no, shpnt->irq);
815 goto out_host_put;
816 }
817 printk("ok.\n");
818
819
820
821 SETPORT(SSTAT0, 0x7f);
822 SETPORT(SSTAT1, 0xef);
823
824 if (request_irq(shpnt->irq, intr, IRQF_SHARED, "aha152x", shpnt)) {
825 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
826 goto out_host_put;
827 }
828
829 if( scsi_add_host(shpnt, NULL) ) {
830 free_irq(shpnt->irq, shpnt);
831 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
832 goto out_host_put;
833 }
834
835 scsi_scan_host(shpnt);
836
837 return shpnt;
838
839out_host_put:
840 list_del(&HOSTDATA(shpnt)->host_list);
841 scsi_host_put(shpnt);
842
843 return NULL;
844}
845
846void aha152x_release(struct Scsi_Host *shpnt)
847{
848 if (!shpnt)
849 return;
850
851 scsi_remove_host(shpnt);
852 if (shpnt->irq)
853 free_irq(shpnt->irq, shpnt);
854
855#if !defined(AHA152X_PCMCIA)
856 if (shpnt->io_port)
857 release_region(shpnt->io_port, IO_RANGE);
858#endif
859
860#ifdef __ISAPNP__
861 if (HOSTDATA(shpnt)->pnpdev)
862 pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
863#endif
864
865 list_del(&HOSTDATA(shpnt)->host_list);
866 scsi_host_put(shpnt);
867}
868
869
870
871
872
873
874
875static int setup_expected_interrupts(struct Scsi_Host *shpnt)
876{
877 if(CURRENT_SC) {
878 CURRENT_SC->SCp.phase |= 1 << 16;
879
880 if(CURRENT_SC->SCp.phase & selecting) {
881 SETPORT(SSTAT1, SELTO);
882 SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
883 SETPORT(SIMODE1, ENSELTIMO);
884 } else {
885 SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
886 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
887 }
888 } else if(STATE==seldi) {
889 SETPORT(SIMODE0, 0);
890 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
891 } else {
892 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
893 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
894 }
895
896 if(!HOSTDATA(shpnt)->in_intr)
897 SETBITS(DMACNTRL0, INTEN);
898
899 return TESTHI(DMASTAT, INTSTAT);
900}
901
902
903
904
905
906static int aha152x_internal_queue(struct scsi_cmnd *SCpnt,
907 struct completion *complete,
908 int phase, void (*done)(struct scsi_cmnd *))
909{
910 struct Scsi_Host *shpnt = SCpnt->device->host;
911 unsigned long flags;
912
913 SCpnt->scsi_done = done;
914 SCpnt->SCp.phase = not_issued | phase;
915 SCpnt->SCp.Status = 0x1;
916 SCpnt->SCp.Message = 0;
917 SCpnt->SCp.have_data_in = 0;
918 SCpnt->SCp.sent_command = 0;
919
920 if(SCpnt->SCp.phase & (resetting|check_condition)) {
921 if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
922 scmd_printk(KERN_ERR, SCpnt, "cannot reuse command\n");
923 return FAILED;
924 }
925 } else {
926 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
927 if(!SCpnt->host_scribble) {
928 scmd_printk(KERN_ERR, SCpnt, "allocation failed\n");
929 return FAILED;
930 }
931 }
932
933 SCNEXT(SCpnt) = NULL;
934 SCSEM(SCpnt) = complete;
935
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 SCpnt->SCp.buffers_residual = 0;
949 } else {
950 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
951 SCpnt->SCp.buffer = scsi_sglist(SCpnt);
952 SCpnt->SCp.ptr = SG_ADDRESS(SCpnt->SCp.buffer);
953 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
954 SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1;
955 }
956
957 DO_LOCK(flags);
958
959#if defined(AHA152X_STAT)
960 HOSTDATA(shpnt)->total_commands++;
961#endif
962
963
964 HOSTDATA(shpnt)->commands++;
965 if (HOSTDATA(shpnt)->commands==1)
966 SETPORT(PORTA, 1);
967
968 append_SC(&ISSUE_SC, SCpnt);
969
970 if(!HOSTDATA(shpnt)->in_intr)
971 setup_expected_interrupts(shpnt);
972
973 DO_UNLOCK(flags);
974
975 return 0;
976}
977
978
979
980
981
982static int aha152x_queue_lck(struct scsi_cmnd *SCpnt,
983 void (*done)(struct scsi_cmnd *))
984{
985 return aha152x_internal_queue(SCpnt, NULL, 0, done);
986}
987
988static DEF_SCSI_QCMD(aha152x_queue)
989
990
991
992
993
994static void reset_done(struct scsi_cmnd *SCpnt)
995{
996 if(SCSEM(SCpnt)) {
997 complete(SCSEM(SCpnt));
998 } else {
999 printk(KERN_ERR "aha152x: reset_done w/o completion\n");
1000 }
1001}
1002
1003
1004
1005
1006
1007static int aha152x_abort(struct scsi_cmnd *SCpnt)
1008{
1009 struct Scsi_Host *shpnt = SCpnt->device->host;
1010 struct scsi_cmnd *ptr;
1011 unsigned long flags;
1012
1013 DO_LOCK(flags);
1014
1015 ptr=remove_SC(&ISSUE_SC, SCpnt);
1016
1017 if(ptr) {
1018 HOSTDATA(shpnt)->commands--;
1019 if (!HOSTDATA(shpnt)->commands)
1020 SETPORT(PORTA, 0);
1021 DO_UNLOCK(flags);
1022
1023 kfree(SCpnt->host_scribble);
1024 SCpnt->host_scribble=NULL;
1025
1026 return SUCCESS;
1027 }
1028
1029 DO_UNLOCK(flags);
1030
1031
1032
1033
1034
1035
1036
1037
1038 scmd_printk(KERN_ERR, SCpnt,
1039 "cannot abort running or disconnected command\n");
1040
1041 return FAILED;
1042}
1043
1044
1045
1046
1047
1048static int aha152x_device_reset(struct scsi_cmnd * SCpnt)
1049{
1050 struct Scsi_Host *shpnt = SCpnt->device->host;
1051 DECLARE_COMPLETION(done);
1052 int ret, issued, disconnected;
1053 unsigned char old_cmd_len = SCpnt->cmd_len;
1054 unsigned long flags;
1055 unsigned long timeleft;
1056
1057 if(CURRENT_SC==SCpnt) {
1058 scmd_printk(KERN_ERR, SCpnt, "cannot reset current device\n");
1059 return FAILED;
1060 }
1061
1062 DO_LOCK(flags);
1063 issued = remove_SC(&ISSUE_SC, SCpnt) == NULL;
1064 disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1065 DO_UNLOCK(flags);
1066
1067 SCpnt->cmd_len = 0;
1068
1069 aha152x_internal_queue(SCpnt, &done, resetting, reset_done);
1070
1071 timeleft = wait_for_completion_timeout(&done, 100*HZ);
1072 if (!timeleft) {
1073
1074 DO_LOCK(flags);
1075 remove_SC(&ISSUE_SC, SCpnt);
1076 DO_UNLOCK(flags);
1077 }
1078
1079 SCpnt->cmd_len = old_cmd_len;
1080
1081 DO_LOCK(flags);
1082
1083 if(SCpnt->SCp.phase & resetted) {
1084 HOSTDATA(shpnt)->commands--;
1085 if (!HOSTDATA(shpnt)->commands)
1086 SETPORT(PORTA, 0);
1087 kfree(SCpnt->host_scribble);
1088 SCpnt->host_scribble=NULL;
1089
1090 ret = SUCCESS;
1091 } else {
1092
1093 if(!issued) {
1094 append_SC(&ISSUE_SC, SCpnt);
1095 } else if(disconnected) {
1096 append_SC(&DISCONNECTED_SC, SCpnt);
1097 }
1098
1099 ret = FAILED;
1100 }
1101
1102 DO_UNLOCK(flags);
1103 return ret;
1104}
1105
1106static void free_hard_reset_SCs(struct Scsi_Host *shpnt,
1107 struct scsi_cmnd **SCs)
1108{
1109 struct scsi_cmnd *ptr;
1110
1111 ptr=*SCs;
1112 while(ptr) {
1113 struct scsi_cmnd *next;
1114
1115 if(SCDATA(ptr)) {
1116 next = SCNEXT(ptr);
1117 } else {
1118 scmd_printk(KERN_DEBUG, ptr,
1119 "queue corrupted at %p\n", ptr);
1120 next = NULL;
1121 }
1122
1123 if (!ptr->device->soft_reset) {
1124 remove_SC(SCs, ptr);
1125 HOSTDATA(shpnt)->commands--;
1126 kfree(ptr->host_scribble);
1127 ptr->host_scribble=NULL;
1128 }
1129
1130 ptr = next;
1131 }
1132}
1133
1134
1135
1136
1137
1138
1139
1140
1141static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1142{
1143 unsigned long flags;
1144
1145 DO_LOCK(flags);
1146
1147 free_hard_reset_SCs(shpnt, &ISSUE_SC);
1148 free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1149
1150 SETPORT(SCSISEQ, SCSIRSTO);
1151 mdelay(256);
1152 SETPORT(SCSISEQ, 0);
1153 mdelay(DELAY);
1154
1155 setup_expected_interrupts(shpnt);
1156 if(HOSTDATA(shpnt)->commands==0)
1157 SETPORT(PORTA, 0);
1158
1159 DO_UNLOCK(flags);
1160
1161 return SUCCESS;
1162}
1163
1164
1165
1166
1167
1168static int aha152x_bus_reset(struct scsi_cmnd *SCpnt)
1169{
1170 return aha152x_bus_reset_host(SCpnt->device->host);
1171}
1172
1173
1174
1175
1176
1177static void reset_ports(struct Scsi_Host *shpnt)
1178{
1179 unsigned long flags;
1180
1181
1182 SETPORT(DMACNTRL0, RSTFIFO);
1183
1184 SETPORT(SCSISEQ, 0);
1185
1186 SETPORT(SXFRCTL1, 0);
1187 SETPORT(SCSISIG, 0);
1188 SETRATE(0);
1189
1190
1191 SETPORT(SSTAT0, 0x7f);
1192 SETPORT(SSTAT1, 0xef);
1193
1194 SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1195
1196 SETPORT(DMACNTRL0, 0);
1197 SETPORT(DMACNTRL1, 0);
1198
1199 SETPORT(BRSTCNTRL, 0xf1);
1200
1201
1202 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1203 SETPORT(SXFRCTL0, CH1);
1204
1205 DO_LOCK(flags);
1206 setup_expected_interrupts(shpnt);
1207 DO_UNLOCK(flags);
1208}
1209
1210
1211
1212
1213
1214int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1215{
1216 aha152x_bus_reset_host(shpnt);
1217 reset_ports(shpnt);
1218
1219 return SUCCESS;
1220}
1221
1222
1223
1224
1225
1226static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1227 sector_t capacity, int *info_array)
1228{
1229 struct Scsi_Host *shpnt = sdev->host;
1230
1231
1232 info_array[0] = 64;
1233 info_array[1] = 32;
1234 info_array[2] = (unsigned long)capacity / (64 * 32);
1235
1236
1237 if (info_array[2] >= 1024) {
1238 int info[3];
1239
1240
1241 if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1242 !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1243 if (EXT_TRANS) {
1244 printk(KERN_NOTICE
1245 "aha152x: unable to verify geometry for disk with >1GB.\n"
1246 " using extended translation.\n");
1247 info_array[0] = 255;
1248 info_array[1] = 63;
1249 info_array[2] = (unsigned long)capacity / (255 * 63);
1250 } else {
1251 printk(KERN_NOTICE
1252 "aha152x: unable to verify geometry for disk with >1GB.\n"
1253 " Using default translation. Please verify yourself.\n"
1254 " Perhaps you need to enable extended translation in the driver.\n"
1255 " See Documentation/scsi/aha152x.txt for details.\n");
1256 }
1257 } else {
1258 info_array[0] = info[0];
1259 info_array[1] = info[1];
1260 info_array[2] = info[2];
1261
1262 if (info[0] == 255 && !EXT_TRANS) {
1263 printk(KERN_NOTICE
1264 "aha152x: current partition table is using extended translation.\n"
1265 " using it also, although it's not explicitly enabled.\n");
1266 }
1267 }
1268 }
1269
1270 return 0;
1271}
1272
1273
1274
1275
1276
1277static void done(struct Scsi_Host *shpnt, int error)
1278{
1279 if (CURRENT_SC) {
1280 if(DONE_SC)
1281 scmd_printk(KERN_ERR, CURRENT_SC,
1282 "there's already a completed command %p "
1283 "- will cause abort\n", DONE_SC);
1284
1285 DONE_SC = CURRENT_SC;
1286 CURRENT_SC = NULL;
1287 DONE_SC->result = error;
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 & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1383
1384 } else if(CURRENT_SC->SCp.phase & aborted) {
1385 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1386
1387 } else if(CURRENT_SC->SCp.phase & resetted) {
1388 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
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, DID_ERROR << 16);
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, DID_NO_CONNECT << 16);
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, DID_ABORT << 16);
1559 else if (TESTLO(SSTAT0, SELINGO))
1560 done(shpnt, DID_BUS_BUSY << 16);
1561 else
1562
1563 done(shpnt, DID_NO_CONNECT << 16);
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, DID_ERROR << 16);
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 CURRENT_SC->SCp.buffers_residual > 0) {
2023
2024 CURRENT_SC->SCp.buffers_residual--;
2025 CURRENT_SC->SCp.buffer++;
2026 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2027 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2028 }
2029 }
2030 } else if (fifodata > 0) {
2031 scmd_printk(KERN_ERR, CURRENT_SC,
2032 "no buffers left for %d(%d) bytes"
2033 " (data overrun!?)\n",
2034 fifodata, GETPORT(FIFOSTAT));
2035 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2036 while(fifodata>0) {
2037 int data;
2038 data=GETPORT(DATAPORT);
2039 fifodata--;
2040 DATA_LEN++;
2041 }
2042 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2043 }
2044 }
2045
2046 if(TESTLO(DMASTAT, INTSTAT) ||
2047 TESTLO(DMASTAT, DFIFOEMP) ||
2048 TESTLO(SSTAT2, SEMPTY) ||
2049 GETPORT(FIFOSTAT)>0) {
2050
2051
2052
2053
2054 scmd_printk(KERN_ERR, CURRENT_SC,
2055 "fifos should be empty and phase should have changed\n");
2056 }
2057
2058 if(DATA_LEN!=GETSTCNT()) {
2059 scmd_printk(KERN_ERR, CURRENT_SC,
2060 "manual transfer count differs from automatic "
2061 "(count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2062 DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN,
2063 GETPORT(FIFOSTAT));
2064 mdelay(10000);
2065 }
2066}
2067
2068static void datai_end(struct Scsi_Host *shpnt)
2069{
2070 CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
2071
2072 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2073 SETPORT(DMACNTRL0, 0);
2074}
2075
2076
2077
2078
2079
2080static void datao_init(struct Scsi_Host *shpnt)
2081{
2082 SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2083 SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2084
2085 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2086 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2087
2088 SETPORT(SIMODE0, 0);
2089 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2090
2091 DATA_LEN = scsi_get_resid(CURRENT_SC);
2092}
2093
2094static void datao_run(struct Scsi_Host *shpnt)
2095{
2096 unsigned long the_time;
2097 int data_count;
2098
2099
2100 while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2101 data_count = 128;
2102 if(data_count > CURRENT_SC->SCp.this_residual)
2103 data_count=CURRENT_SC->SCp.this_residual;
2104
2105 if(TESTLO(DMASTAT, DFIFOEMP)) {
2106 scmd_printk(KERN_ERR, CURRENT_SC,
2107 "datao fifo not empty (%d)",
2108 GETPORT(FIFOSTAT));
2109 break;
2110 }
2111
2112 if(data_count & 1) {
2113 SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2114 SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2115 CURRENT_SC->SCp.this_residual--;
2116 CMD_INC_RESID(CURRENT_SC, -1);
2117 SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2118 }
2119
2120 if(data_count > 1) {
2121 data_count >>= 1;
2122 outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2123 CURRENT_SC->SCp.ptr += 2 * data_count;
2124 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2125 CMD_INC_RESID(CURRENT_SC, -2 * data_count);
2126 }
2127
2128 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2129
2130 CURRENT_SC->SCp.buffers_residual--;
2131 CURRENT_SC->SCp.buffer++;
2132 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2133 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2134 }
2135
2136 the_time=jiffies + 100*HZ;
2137 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2138 barrier();
2139
2140 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2141 scmd_printk(KERN_ERR, CURRENT_SC, "dataout timeout\n");
2142 break;
2143 }
2144 }
2145}
2146
2147static void datao_end(struct Scsi_Host *shpnt)
2148{
2149 if(TESTLO(DMASTAT, DFIFOEMP)) {
2150 int data_count = (DATA_LEN - scsi_get_resid(CURRENT_SC)) -
2151 GETSTCNT();
2152
2153 CMD_INC_RESID(CURRENT_SC, data_count);
2154
2155 data_count -= CURRENT_SC->SCp.ptr -
2156 SG_ADDRESS(CURRENT_SC->SCp.buffer);
2157 while(data_count>0) {
2158 CURRENT_SC->SCp.buffer--;
2159 CURRENT_SC->SCp.buffers_residual++;
2160 data_count -= CURRENT_SC->SCp.buffer->length;
2161 }
2162 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) -
2163 data_count;
2164 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length +
2165 data_count;
2166 }
2167
2168 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2169 SETPORT(SXFRCTL0, CH1);
2170
2171 SETPORT(DMACNTRL0, 0);
2172}
2173
2174
2175
2176
2177
2178static int update_state(struct Scsi_Host *shpnt)
2179{
2180 int dataphase=0;
2181 unsigned int stat0 = GETPORT(SSTAT0);
2182 unsigned int stat1 = GETPORT(SSTAT1);
2183
2184 PREVSTATE = STATE;
2185 STATE=unknown;
2186
2187 if(stat1 & SCSIRSTI) {
2188 STATE=rsti;
2189 SETPORT(SCSISEQ,0);
2190 SETPORT(SSTAT1,SCSIRSTI);
2191 } else if (stat0 & SELDI && PREVSTATE == busfree) {
2192 STATE=seldi;
2193 } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2194 STATE=seldo;
2195 } else if(stat1 & SELTO) {
2196 STATE=selto;
2197 } else if(stat1 & BUSFREE) {
2198 STATE=busfree;
2199 SETPORT(SSTAT1,BUSFREE);
2200 } else if(stat1 & SCSIPERR) {
2201 STATE=parerr;
2202 SETPORT(SSTAT1,SCSIPERR);
2203 } else if(stat1 & REQINIT) {
2204 switch(GETPORT(SCSISIG) & P_MASK) {
2205 case P_MSGI: STATE=msgi; break;
2206 case P_MSGO: STATE=msgo; break;
2207 case P_DATAO: STATE=datao; break;
2208 case P_DATAI: STATE=datai; break;
2209 case P_STATUS: STATE=status; break;
2210 case P_CMD: STATE=cmd; break;
2211 }
2212 dataphase=1;
2213 }
2214
2215 if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2216 scmd_printk(KERN_INFO, CURRENT_SC, "reselection missed?");
2217 }
2218
2219 if(STATE!=PREVSTATE) {
2220 LASTSTATE=PREVSTATE;
2221 }
2222
2223 return dataphase;
2224}
2225
2226
2227
2228
2229
2230
2231
2232static void parerr_run(struct Scsi_Host *shpnt)
2233{
2234 scmd_printk(KERN_ERR, CURRENT_SC, "parity error\n");
2235 done(shpnt, DID_PARITY << 16);
2236}
2237
2238
2239
2240
2241
2242static void rsti_run(struct Scsi_Host *shpnt)
2243{
2244 struct scsi_cmnd *ptr;
2245
2246 shost_printk(KERN_NOTICE, shpnt, "scsi reset in\n");
2247
2248 ptr=DISCONNECTED_SC;
2249 while(ptr) {
2250 struct scsi_cmnd *next = SCNEXT(ptr);
2251
2252 if (!ptr->device->soft_reset) {
2253 remove_SC(&DISCONNECTED_SC, ptr);
2254
2255 kfree(ptr->host_scribble);
2256 ptr->host_scribble=NULL;
2257
2258 ptr->result = DID_RESET << 16;
2259 ptr->scsi_done(ptr);
2260 }
2261
2262 ptr = next;
2263 }
2264
2265 if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2266 done(shpnt, DID_RESET << 16 );
2267}
2268
2269
2270
2271
2272
2273
2274static void is_complete(struct Scsi_Host *shpnt)
2275{
2276 int dataphase;
2277 unsigned long flags;
2278 int pending;
2279
2280 if(!shpnt)
2281 return;
2282
2283 DO_LOCK(flags);
2284
2285 if( HOSTDATA(shpnt)->service==0 ) {
2286 DO_UNLOCK(flags);
2287 return;
2288 }
2289
2290 HOSTDATA(shpnt)->service = 0;
2291
2292 if(HOSTDATA(shpnt)->in_intr) {
2293 DO_UNLOCK(flags);
2294
2295 aha152x_error(shpnt, "bottom-half already running!?");
2296 }
2297 HOSTDATA(shpnt)->in_intr++;
2298
2299
2300
2301
2302
2303 do {
2304 unsigned long start = jiffies;
2305 DO_UNLOCK(flags);
2306
2307 dataphase=update_state(shpnt);
2308
2309
2310
2311
2312
2313 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2314 states[PREVSTATE].end(shpnt);
2315
2316
2317
2318
2319
2320
2321 if(states[PREVSTATE].spio && !states[STATE].spio) {
2322 SETPORT(SXFRCTL0, CH1);
2323 SETPORT(DMACNTRL0, 0);
2324 if(CURRENT_SC)
2325 CURRENT_SC->SCp.phase &= ~spiordy;
2326 }
2327
2328
2329
2330
2331
2332 if(dataphase) {
2333 SETPORT(SSTAT0, REQINIT);
2334 SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2335 SETPORT(SSTAT1, PHASECHG);
2336 }
2337
2338
2339
2340
2341
2342
2343 if(!states[PREVSTATE].spio && states[STATE].spio) {
2344 SETPORT(DMACNTRL0, 0);
2345 SETPORT(SXFRCTL0, CH1|SPIOEN);
2346 if(CURRENT_SC)
2347 CURRENT_SC->SCp.phase |= spiordy;
2348 }
2349
2350
2351
2352
2353
2354 if(PREVSTATE!=STATE && states[STATE].init)
2355 states[STATE].init(shpnt);
2356
2357
2358
2359
2360
2361 if(states[STATE].run)
2362 states[STATE].run(shpnt);
2363 else
2364 scmd_printk(KERN_ERR, CURRENT_SC,
2365 "unexpected state (%x)\n", STATE);
2366
2367
2368
2369
2370
2371
2372
2373 DO_LOCK(flags);
2374 pending=setup_expected_interrupts(shpnt);
2375#if defined(AHA152X_STAT)
2376 HOSTDATA(shpnt)->count[STATE]++;
2377 if(PREVSTATE!=STATE)
2378 HOSTDATA(shpnt)->count_trans[STATE]++;
2379 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2380#endif
2381
2382 } while(pending);
2383
2384
2385
2386
2387
2388 HOSTDATA(shpnt)->in_intr--;
2389 SETBITS(DMACNTRL0, INTEN);
2390 DO_UNLOCK(flags);
2391}
2392
2393
2394
2395
2396
2397static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2398{
2399 shost_printk(KERN_EMERG, shpnt, "%s\n", msg);
2400 show_queues(shpnt);
2401 panic("aha152x panic\n");
2402}
2403
2404
2405
2406
2407static void disp_enintr(struct Scsi_Host *shpnt)
2408{
2409 int s0, s1;
2410
2411 s0 = GETPORT(SIMODE0);
2412 s1 = GETPORT(SIMODE1);
2413
2414 shost_printk(KERN_DEBUG, shpnt,
2415 "enabled interrupts (%s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
2416 (s0 & ENSELDO) ? "ENSELDO " : "",
2417 (s0 & ENSELDI) ? "ENSELDI " : "",
2418 (s0 & ENSELINGO) ? "ENSELINGO " : "",
2419 (s0 & ENSWRAP) ? "ENSWRAP " : "",
2420 (s0 & ENSDONE) ? "ENSDONE " : "",
2421 (s0 & ENSPIORDY) ? "ENSPIORDY " : "",
2422 (s0 & ENDMADONE) ? "ENDMADONE " : "",
2423 (s1 & ENSELTIMO) ? "ENSELTIMO " : "",
2424 (s1 & ENATNTARG) ? "ENATNTARG " : "",
2425 (s1 & ENPHASEMIS) ? "ENPHASEMIS " : "",
2426 (s1 & ENBUSFREE) ? "ENBUSFREE " : "",
2427 (s1 & ENSCSIPERR) ? "ENSCSIPERR " : "",
2428 (s1 & ENPHASECHG) ? "ENPHASECHG " : "",
2429 (s1 & ENREQINIT) ? "ENREQINIT " : "");
2430}
2431
2432
2433
2434
2435static void show_command(struct scsi_cmnd *ptr)
2436{
2437 scsi_print_command(ptr);
2438 scmd_printk(KERN_DEBUG, ptr,
2439 "request_bufflen=%d; resid=%d; "
2440 "phase |%s%s%s%s%s%s%s%s%s; next=0x%p",
2441 scsi_bufflen(ptr), scsi_get_resid(ptr),
2442 (ptr->SCp.phase & not_issued) ? "not issued|" : "",
2443 (ptr->SCp.phase & selecting) ? "selecting|" : "",
2444 (ptr->SCp.phase & identified) ? "identified|" : "",
2445 (ptr->SCp.phase & disconnected) ? "disconnected|" : "",
2446 (ptr->SCp.phase & completed) ? "completed|" : "",
2447 (ptr->SCp.phase & spiordy) ? "spiordy|" : "",
2448 (ptr->SCp.phase & syncneg) ? "syncneg|" : "",
2449 (ptr->SCp.phase & aborted) ? "aborted|" : "",
2450 (ptr->SCp.phase & resetted) ? "resetted|" : "",
2451 (SCDATA(ptr)) ? SCNEXT(ptr) : NULL);
2452}
2453
2454
2455
2456
2457static void show_queues(struct Scsi_Host *shpnt)
2458{
2459 struct scsi_cmnd *ptr;
2460 unsigned long flags;
2461
2462 DO_LOCK(flags);
2463 printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2464 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2465 show_command(ptr);
2466 DO_UNLOCK(flags);
2467
2468 printk(KERN_DEBUG "current_SC:\n");
2469 if (CURRENT_SC)
2470 show_command(CURRENT_SC);
2471 else
2472 printk(KERN_DEBUG "none\n");
2473
2474 printk(KERN_DEBUG "disconnected_SC:\n");
2475 for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2476 show_command(ptr);
2477
2478 disp_enintr(shpnt);
2479}
2480
2481static void get_command(struct seq_file *m, struct scsi_cmnd * ptr)
2482{
2483 int i;
2484
2485 seq_printf(m, "%p: target=%d; lun=%d; cmnd=( ",
2486 ptr, ptr->device->id, (u8)ptr->device->lun);
2487
2488 for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2489 seq_printf(m, "0x%02x ", ptr->cmnd[i]);
2490
2491 seq_printf(m, "); resid=%d; residual=%d; buffers=%d; phase |",
2492 scsi_get_resid(ptr), ptr->SCp.this_residual,
2493 ptr->SCp.buffers_residual);
2494
2495 if (ptr->SCp.phase & not_issued)
2496 seq_puts(m, "not issued|");
2497 if (ptr->SCp.phase & selecting)
2498 seq_puts(m, "selecting|");
2499 if (ptr->SCp.phase & disconnected)
2500 seq_puts(m, "disconnected|");
2501 if (ptr->SCp.phase & aborted)
2502 seq_puts(m, "aborted|");
2503 if (ptr->SCp.phase & identified)
2504 seq_puts(m, "identified|");
2505 if (ptr->SCp.phase & completed)
2506 seq_puts(m, "completed|");
2507 if (ptr->SCp.phase & spiordy)
2508 seq_puts(m, "spiordy|");
2509 if (ptr->SCp.phase & syncneg)
2510 seq_puts(m, "syncneg|");
2511 seq_printf(m, "; next=0x%p\n", SCNEXT(ptr));
2512}
2513
2514static void get_ports(struct seq_file *m, struct Scsi_Host *shpnt)
2515{
2516 int s;
2517
2518 seq_printf(m, "\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
2519
2520 s = GETPORT(SCSISEQ);
2521 seq_puts(m, "SCSISEQ( ");
2522 if (s & TEMODEO)
2523 seq_puts(m, "TARGET MODE ");
2524 if (s & ENSELO)
2525 seq_puts(m, "SELO ");
2526 if (s & ENSELI)
2527 seq_puts(m, "SELI ");
2528 if (s & ENRESELI)
2529 seq_puts(m, "RESELI ");
2530 if (s & ENAUTOATNO)
2531 seq_puts(m, "AUTOATNO ");
2532 if (s & ENAUTOATNI)
2533 seq_puts(m, "AUTOATNI ");
2534 if (s & ENAUTOATNP)
2535 seq_puts(m, "AUTOATNP ");
2536 if (s & SCSIRSTO)
2537 seq_puts(m, "SCSIRSTO ");
2538 seq_puts(m, ");");
2539
2540 seq_puts(m, " SCSISIG(");
2541 s = GETPORT(SCSISIG);
2542 switch (s & P_MASK) {
2543 case P_DATAO:
2544 seq_puts(m, "DATA OUT");
2545 break;
2546 case P_DATAI:
2547 seq_puts(m, "DATA IN");
2548 break;
2549 case P_CMD:
2550 seq_puts(m, "COMMAND");
2551 break;
2552 case P_STATUS:
2553 seq_puts(m, "STATUS");
2554 break;
2555 case P_MSGO:
2556 seq_puts(m, "MESSAGE OUT");
2557 break;
2558 case P_MSGI:
2559 seq_puts(m, "MESSAGE IN");
2560 break;
2561 default:
2562 seq_puts(m, "*invalid*");
2563 break;
2564 }
2565
2566 seq_puts(m, "); ");
2567
2568 seq_printf(m, "INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2569
2570 seq_puts(m, "SSTAT( ");
2571 s = GETPORT(SSTAT0);
2572 if (s & TARGET)
2573 seq_puts(m, "TARGET ");
2574 if (s & SELDO)
2575 seq_puts(m, "SELDO ");
2576 if (s & SELDI)
2577 seq_puts(m, "SELDI ");
2578 if (s & SELINGO)
2579 seq_puts(m, "SELINGO ");
2580 if (s & SWRAP)
2581 seq_puts(m, "SWRAP ");
2582 if (s & SDONE)
2583 seq_puts(m, "SDONE ");
2584 if (s & SPIORDY)
2585 seq_puts(m, "SPIORDY ");
2586 if (s & DMADONE)
2587 seq_puts(m, "DMADONE ");
2588
2589 s = GETPORT(SSTAT1);
2590 if (s & SELTO)
2591 seq_puts(m, "SELTO ");
2592 if (s & ATNTARG)
2593 seq_puts(m, "ATNTARG ");
2594 if (s & SCSIRSTI)
2595 seq_puts(m, "SCSIRSTI ");
2596 if (s & PHASEMIS)
2597 seq_puts(m, "PHASEMIS ");
2598 if (s & BUSFREE)
2599 seq_puts(m, "BUSFREE ");
2600 if (s & SCSIPERR)
2601 seq_puts(m, "SCSIPERR ");
2602 if (s & PHASECHG)
2603 seq_puts(m, "PHASECHG ");
2604 if (s & REQINIT)
2605 seq_puts(m, "REQINIT ");
2606 seq_puts(m, "); ");
2607
2608
2609 seq_puts(m, "SSTAT( ");
2610
2611 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2612
2613 if (s & TARGET)
2614 seq_puts(m, "TARGET ");
2615 if (s & SELDO)
2616 seq_puts(m, "SELDO ");
2617 if (s & SELDI)
2618 seq_puts(m, "SELDI ");
2619 if (s & SELINGO)
2620 seq_puts(m, "SELINGO ");
2621 if (s & SWRAP)
2622 seq_puts(m, "SWRAP ");
2623 if (s & SDONE)
2624 seq_puts(m, "SDONE ");
2625 if (s & SPIORDY)
2626 seq_puts(m, "SPIORDY ");
2627 if (s & DMADONE)
2628 seq_puts(m, "DMADONE ");
2629
2630 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2631
2632 if (s & SELTO)
2633 seq_puts(m, "SELTO ");
2634 if (s & ATNTARG)
2635 seq_puts(m, "ATNTARG ");
2636 if (s & SCSIRSTI)
2637 seq_puts(m, "SCSIRSTI ");
2638 if (s & PHASEMIS)
2639 seq_puts(m, "PHASEMIS ");
2640 if (s & BUSFREE)
2641 seq_puts(m, "BUSFREE ");
2642 if (s & SCSIPERR)
2643 seq_puts(m, "SCSIPERR ");
2644 if (s & PHASECHG)
2645 seq_puts(m, "PHASECHG ");
2646 if (s & REQINIT)
2647 seq_puts(m, "REQINIT ");
2648 seq_puts(m, "); ");
2649
2650 seq_puts(m, "SXFRCTL0( ");
2651
2652 s = GETPORT(SXFRCTL0);
2653 if (s & SCSIEN)
2654 seq_puts(m, "SCSIEN ");
2655 if (s & DMAEN)
2656 seq_puts(m, "DMAEN ");
2657 if (s & CH1)
2658 seq_puts(m, "CH1 ");
2659 if (s & CLRSTCNT)
2660 seq_puts(m, "CLRSTCNT ");
2661 if (s & SPIOEN)
2662 seq_puts(m, "SPIOEN ");
2663 if (s & CLRCH1)
2664 seq_puts(m, "CLRCH1 ");
2665 seq_puts(m, "); ");
2666
2667 seq_puts(m, "SIGNAL( ");
2668
2669 s = GETPORT(SCSISIG);
2670 if (s & SIG_ATNI)
2671 seq_puts(m, "ATNI ");
2672 if (s & SIG_SELI)
2673 seq_puts(m, "SELI ");
2674 if (s & SIG_BSYI)
2675 seq_puts(m, "BSYI ");
2676 if (s & SIG_REQI)
2677 seq_puts(m, "REQI ");
2678 if (s & SIG_ACKI)
2679 seq_puts(m, "ACKI ");
2680 seq_puts(m, "); ");
2681
2682 seq_printf(m, "SELID(%02x), ", GETPORT(SELID));
2683
2684 seq_printf(m, "STCNT(%d), ", GETSTCNT());
2685
2686 seq_puts(m, "SSTAT2( ");
2687
2688 s = GETPORT(SSTAT2);
2689 if (s & SOFFSET)
2690 seq_puts(m, "SOFFSET ");
2691 if (s & SEMPTY)
2692 seq_puts(m, "SEMPTY ");
2693 if (s & SFULL)
2694 seq_puts(m, "SFULL ");
2695 seq_printf(m, "); SFCNT (%d); ", s & (SFULL | SFCNT));
2696
2697 s = GETPORT(SSTAT3);
2698 seq_printf(m, "SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2699
2700 seq_puts(m, "SSTAT4( ");
2701 s = GETPORT(SSTAT4);
2702 if (s & SYNCERR)
2703 seq_puts(m, "SYNCERR ");
2704 if (s & FWERR)
2705 seq_puts(m, "FWERR ");
2706 if (s & FRERR)
2707 seq_puts(m, "FRERR ");
2708 seq_puts(m, "); ");
2709
2710 seq_puts(m, "DMACNTRL0( ");
2711 s = GETPORT(DMACNTRL0);
2712 seq_printf(m, "%s ", s & _8BIT ? "8BIT" : "16BIT");
2713 seq_printf(m, "%s ", s & DMA ? "DMA" : "PIO");
2714 seq_printf(m, "%s ", s & WRITE_READ ? "WRITE" : "READ");
2715 if (s & ENDMA)
2716 seq_puts(m, "ENDMA ");
2717 if (s & INTEN)
2718 seq_puts(m, "INTEN ");
2719 if (s & RSTFIFO)
2720 seq_puts(m, "RSTFIFO ");
2721 if (s & SWINT)
2722 seq_puts(m, "SWINT ");
2723 seq_puts(m, "); ");
2724
2725 seq_puts(m, "DMASTAT( ");
2726 s = GETPORT(DMASTAT);
2727 if (s & ATDONE)
2728 seq_puts(m, "ATDONE ");
2729 if (s & WORDRDY)
2730 seq_puts(m, "WORDRDY ");
2731 if (s & DFIFOFULL)
2732 seq_puts(m, "DFIFOFULL ");
2733 if (s & DFIFOEMP)
2734 seq_puts(m, "DFIFOEMP ");
2735 seq_puts(m, ")\n");
2736
2737 seq_puts(m, "enabled interrupts( ");
2738
2739 s = GETPORT(SIMODE0);
2740 if (s & ENSELDO)
2741 seq_puts(m, "ENSELDO ");
2742 if (s & ENSELDI)
2743 seq_puts(m, "ENSELDI ");
2744 if (s & ENSELINGO)
2745 seq_puts(m, "ENSELINGO ");
2746 if (s & ENSWRAP)
2747 seq_puts(m, "ENSWRAP ");
2748 if (s & ENSDONE)
2749 seq_puts(m, "ENSDONE ");
2750 if (s & ENSPIORDY)
2751 seq_puts(m, "ENSPIORDY ");
2752 if (s & ENDMADONE)
2753 seq_puts(m, "ENDMADONE ");
2754
2755 s = GETPORT(SIMODE1);
2756 if (s & ENSELTIMO)
2757 seq_puts(m, "ENSELTIMO ");
2758 if (s & ENATNTARG)
2759 seq_puts(m, "ENATNTARG ");
2760 if (s & ENPHASEMIS)
2761 seq_puts(m, "ENPHASEMIS ");
2762 if (s & ENBUSFREE)
2763 seq_puts(m, "ENBUSFREE ");
2764 if (s & ENSCSIPERR)
2765 seq_puts(m, "ENSCSIPERR ");
2766 if (s & ENPHASECHG)
2767 seq_puts(m, "ENPHASECHG ");
2768 if (s & ENREQINIT)
2769 seq_puts(m, "ENREQINIT ");
2770 seq_puts(m, ")\n");
2771}
2772
2773static int aha152x_set_info(struct Scsi_Host *shpnt, char *buffer, int length)
2774{
2775 if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
2776 return -EINVAL;
2777
2778#if defined(AHA152X_STAT)
2779 if(length>13 && strncmp("reset", buffer+8, 5)==0) {
2780 int i;
2781
2782 HOSTDATA(shpnt)->total_commands=0;
2783 HOSTDATA(shpnt)->disconnections=0;
2784 HOSTDATA(shpnt)->busfree_without_any_action=0;
2785 HOSTDATA(shpnt)->busfree_without_old_command=0;
2786 HOSTDATA(shpnt)->busfree_without_new_command=0;
2787 HOSTDATA(shpnt)->busfree_without_done_command=0;
2788 HOSTDATA(shpnt)->busfree_with_check_condition=0;
2789 for (i = idle; i<maxstate; i++) {
2790 HOSTDATA(shpnt)->count[i]=0;
2791 HOSTDATA(shpnt)->count_trans[i]=0;
2792 HOSTDATA(shpnt)->time[i]=0;
2793 }
2794
2795 shost_printk(KERN_INFO, shpnt, "aha152x: stats reset.\n");
2796
2797 } else
2798#endif
2799 {
2800 return -EINVAL;
2801 }
2802
2803
2804 return length;
2805}
2806
2807static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
2808{
2809 int i;
2810 struct scsi_cmnd *ptr;
2811 unsigned long flags;
2812
2813 seq_puts(m, AHA152X_REVID "\n");
2814
2815 seq_printf(m, "ioports 0x%04lx to 0x%04lx\n",
2816 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
2817 seq_printf(m, "interrupt 0x%02x\n", shpnt->irq);
2818 seq_printf(m, "disconnection/reconnection %s\n",
2819 RECONNECT ? "enabled" : "disabled");
2820 seq_printf(m, "parity checking %s\n",
2821 PARITY ? "enabled" : "disabled");
2822 seq_printf(m, "synchronous transfers %s\n",
2823 SYNCHRONOUS ? "enabled" : "disabled");
2824 seq_printf(m, "%d commands currently queued\n", HOSTDATA(shpnt)->commands);
2825
2826 if(SYNCHRONOUS) {
2827 seq_puts(m, "synchronously operating targets (tick=50 ns):\n");
2828 for (i = 0; i < 8; i++)
2829 if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
2830 seq_printf(m, "target %d: period %dT/%dns; req/ack offset %d\n",
2831 i,
2832 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
2833 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
2834 HOSTDATA(shpnt)->syncrate[i] & 0x0f);
2835 }
2836 seq_puts(m, "\nqueue status:\n");
2837 DO_LOCK(flags);
2838 if (ISSUE_SC) {
2839 seq_puts(m, "not yet issued commands:\n");
2840 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2841 get_command(m, ptr);
2842 } else
2843 seq_puts(m, "no not yet issued commands\n");
2844 DO_UNLOCK(flags);
2845
2846 if (CURRENT_SC) {
2847 seq_puts(m, "current command:\n");
2848 get_command(m, CURRENT_SC);
2849 } else
2850 seq_puts(m, "no current command\n");
2851
2852 if (DISCONNECTED_SC) {
2853 seq_puts(m, "disconnected commands:\n");
2854 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
2855 get_command(m, ptr);
2856 } else
2857 seq_puts(m, "no disconnected commands\n");
2858
2859 get_ports(m, shpnt);
2860
2861#if defined(AHA152X_STAT)
2862 seq_printf(m, "statistics:\n"
2863 "total commands: %d\n"
2864 "disconnections: %d\n"
2865 "busfree with check condition: %d\n"
2866 "busfree without old command: %d\n"
2867 "busfree without new command: %d\n"
2868 "busfree without done command: %d\n"
2869 "busfree without any action: %d\n"
2870 "state "
2871 "transitions "
2872 "count "
2873 "time\n",
2874 HOSTDATA(shpnt)->total_commands,
2875 HOSTDATA(shpnt)->disconnections,
2876 HOSTDATA(shpnt)->busfree_with_check_condition,
2877 HOSTDATA(shpnt)->busfree_without_old_command,
2878 HOSTDATA(shpnt)->busfree_without_new_command,
2879 HOSTDATA(shpnt)->busfree_without_done_command,
2880 HOSTDATA(shpnt)->busfree_without_any_action);
2881 for(i=0; i<maxstate; i++) {
2882 seq_printf(m, "%-10s %-12d %-12d %-12ld\n",
2883 states[i].name,
2884 HOSTDATA(shpnt)->count_trans[i],
2885 HOSTDATA(shpnt)->count[i],
2886 HOSTDATA(shpnt)->time[i]);
2887 }
2888#endif
2889 return 0;
2890}
2891
2892static int aha152x_adjust_queue(struct scsi_device *device)
2893{
2894 blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
2895 return 0;
2896}
2897
2898static struct scsi_host_template aha152x_driver_template = {
2899 .module = THIS_MODULE,
2900 .name = AHA152X_REVID,
2901 .proc_name = "aha152x",
2902 .show_info = aha152x_show_info,
2903 .write_info = aha152x_set_info,
2904 .queuecommand = aha152x_queue,
2905 .eh_abort_handler = aha152x_abort,
2906 .eh_device_reset_handler = aha152x_device_reset,
2907 .eh_bus_reset_handler = aha152x_bus_reset,
2908 .bios_param = aha152x_biosparam,
2909 .can_queue = 1,
2910 .this_id = 7,
2911 .sg_tablesize = SG_ALL,
2912 .dma_boundary = PAGE_SIZE - 1,
2913 .slave_alloc = aha152x_adjust_queue,
2914};
2915
2916#if !defined(AHA152X_PCMCIA)
2917static int setup_count;
2918static struct aha152x_setup setup[2];
2919
2920
2921static unsigned short ports[] = { 0x340, 0x140 };
2922
2923#if !defined(SKIP_BIOSTEST)
2924
2925static unsigned int addresses[] =
2926{
2927 0xdc000,
2928 0xc8000,
2929 0xcc000,
2930 0xd0000,
2931 0xd4000,
2932 0xd8000,
2933 0xe0000,
2934 0xeb800,
2935 0xf0000,
2936};
2937
2938
2939
2940
2941
2942
2943
2944
2945static struct signature {
2946 unsigned char *signature;
2947 int sig_offset;
2948 int sig_length;
2949} signatures[] =
2950{
2951 { "Adaptec AHA-1520 BIOS", 0x102e, 21 },
2952
2953 { "Adaptec AHA-1520B", 0x000b, 17 },
2954
2955 { "Adaptec AHA-1520B", 0x0026, 17 },
2956
2957 { "Adaptec ASW-B626 BIOS", 0x1029, 21 },
2958
2959 { "Adaptec BIOS: ASW-B626", 0x000f, 22 },
2960
2961 { "Adaptec ASW-B626 S2", 0x2e6c, 19 },
2962
2963 { "Adaptec BIOS:AIC-6360", 0x000c, 21 },
2964
2965 { "ScsiPro SP-360 BIOS", 0x2873, 19 },
2966
2967 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
2968
2969 { "Adaptec BIOS:AVA-282X", 0x000c, 21 },
2970
2971 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 },
2972
2973 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 },
2974
2975 { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
2976
2977};
2978#endif
2979
2980
2981
2982
2983
2984static int aha152x_porttest(int io_port)
2985{
2986 int i;
2987
2988 SETPORT(io_port + O_DMACNTRL1, 0);
2989 for (i = 0; i < 16; i++)
2990 SETPORT(io_port + O_STACK, i);
2991
2992 SETPORT(io_port + O_DMACNTRL1, 0);
2993 for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
2994 ;
2995
2996 return (i == 16);
2997}
2998
2999static int tc1550_porttest(int io_port)
3000{
3001 int i;
3002
3003 SETPORT(io_port + O_TC_DMACNTRL1, 0);
3004 for (i = 0; i < 16; i++)
3005 SETPORT(io_port + O_STACK, i);
3006
3007 SETPORT(io_port + O_TC_DMACNTRL1, 0);
3008 for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3009 ;
3010
3011 return (i == 16);
3012}
3013
3014
3015static int checksetup(struct aha152x_setup *setup)
3016{
3017 int i;
3018 for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3019 ;
3020
3021 if (i == ARRAY_SIZE(ports))
3022 return 0;
3023
3024 if (!request_region(setup->io_port, IO_RANGE, "aha152x")) {
3025 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3026 return 0;
3027 }
3028
3029 if( aha152x_porttest(setup->io_port) ) {
3030 setup->tc1550=0;
3031 } else if( tc1550_porttest(setup->io_port) ) {
3032 setup->tc1550=1;
3033 } else {
3034 release_region(setup->io_port, IO_RANGE);
3035 return 0;
3036 }
3037
3038 release_region(setup->io_port, IO_RANGE);
3039
3040 if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3041 return 0;
3042
3043 if ((setup->scsiid < 0) || (setup->scsiid > 7))
3044 return 0;
3045
3046 if ((setup->reconnect < 0) || (setup->reconnect > 1))
3047 return 0;
3048
3049 if ((setup->parity < 0) || (setup->parity > 1))
3050 return 0;
3051
3052 if ((setup->synchronous < 0) || (setup->synchronous > 1))
3053 return 0;
3054
3055 if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3056 return 0;
3057
3058
3059 return 1;
3060}
3061
3062
3063static int __init aha152x_init(void)
3064{
3065 int i, j, ok;
3066#if defined(AUTOCONF)
3067 aha152x_config conf;
3068#endif
3069#ifdef __ISAPNP__
3070 struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3071#endif
3072
3073 if ( setup_count ) {
3074 printk(KERN_INFO "aha152x: processing commandline: ");
3075
3076 for (i = 0; i<setup_count; i++) {
3077 if (!checksetup(&setup[i])) {
3078 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3079 printk(KERN_ERR "aha152x: invalid line\n");
3080 }
3081 }
3082 printk("ok\n");
3083 }
3084
3085#if defined(SETUP0)
3086 if (setup_count < ARRAY_SIZE(setup)) {
3087 struct aha152x_setup override = SETUP0;
3088
3089 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3090 if (!checksetup(&override)) {
3091 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3092 override.io_port,
3093 override.irq,
3094 override.scsiid,
3095 override.reconnect,
3096 override.parity,
3097 override.synchronous,
3098 override.delay,
3099 override.ext_trans);
3100 } else
3101 setup[setup_count++] = override;
3102 }
3103 }
3104#endif
3105
3106#if defined(SETUP1)
3107 if (setup_count < ARRAY_SIZE(setup)) {
3108 struct aha152x_setup override = SETUP1;
3109
3110 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3111 if (!checksetup(&override)) {
3112 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3113 override.io_port,
3114 override.irq,
3115 override.scsiid,
3116 override.reconnect,
3117 override.parity,
3118 override.synchronous,
3119 override.delay,
3120 override.ext_trans);
3121 } else
3122 setup[setup_count++] = override;
3123 }
3124 }
3125#endif
3126
3127#if defined(MODULE)
3128 if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3129 if(aha152x[0]!=0) {
3130 setup[setup_count].conf = "";
3131 setup[setup_count].io_port = aha152x[0];
3132 setup[setup_count].irq = aha152x[1];
3133 setup[setup_count].scsiid = aha152x[2];
3134 setup[setup_count].reconnect = aha152x[3];
3135 setup[setup_count].parity = aha152x[4];
3136 setup[setup_count].synchronous = aha152x[5];
3137 setup[setup_count].delay = aha152x[6];
3138 setup[setup_count].ext_trans = aha152x[7];
3139 } else if (io[0] != 0 || irq[0] != 0) {
3140 if(io[0]!=0) setup[setup_count].io_port = io[0];
3141 if(irq[0]!=0) setup[setup_count].irq = irq[0];
3142
3143 setup[setup_count].scsiid = scsiid[0];
3144 setup[setup_count].reconnect = reconnect[0];
3145 setup[setup_count].parity = parity[0];
3146 setup[setup_count].synchronous = sync[0];
3147 setup[setup_count].delay = delay[0];
3148 setup[setup_count].ext_trans = exttrans[0];
3149 }
3150
3151 if (checksetup(&setup[setup_count]))
3152 setup_count++;
3153 else
3154 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",
3155 setup[setup_count].io_port,
3156 setup[setup_count].irq,
3157 setup[setup_count].scsiid,
3158 setup[setup_count].reconnect,
3159 setup[setup_count].parity,
3160 setup[setup_count].synchronous,
3161 setup[setup_count].delay,
3162 setup[setup_count].ext_trans);
3163 }
3164
3165 if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3166 if(aha152x1[0]!=0) {
3167 setup[setup_count].conf = "";
3168 setup[setup_count].io_port = aha152x1[0];
3169 setup[setup_count].irq = aha152x1[1];
3170 setup[setup_count].scsiid = aha152x1[2];
3171 setup[setup_count].reconnect = aha152x1[3];
3172 setup[setup_count].parity = aha152x1[4];
3173 setup[setup_count].synchronous = aha152x1[5];
3174 setup[setup_count].delay = aha152x1[6];
3175 setup[setup_count].ext_trans = aha152x1[7];
3176 } else if (io[1] != 0 || irq[1] != 0) {
3177 if(io[1]!=0) setup[setup_count].io_port = io[1];
3178 if(irq[1]!=0) setup[setup_count].irq = irq[1];
3179
3180 setup[setup_count].scsiid = scsiid[1];
3181 setup[setup_count].reconnect = reconnect[1];
3182 setup[setup_count].parity = parity[1];
3183 setup[setup_count].synchronous = sync[1];
3184 setup[setup_count].delay = delay[1];
3185 setup[setup_count].ext_trans = exttrans[1];
3186 }
3187 if (checksetup(&setup[setup_count]))
3188 setup_count++;
3189 else
3190 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",
3191 setup[setup_count].io_port,
3192 setup[setup_count].irq,
3193 setup[setup_count].scsiid,
3194 setup[setup_count].reconnect,
3195 setup[setup_count].parity,
3196 setup[setup_count].synchronous,
3197 setup[setup_count].delay,
3198 setup[setup_count].ext_trans);
3199 }
3200#endif
3201
3202#ifdef __ISAPNP__
3203 for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3204 while ( setup_count<ARRAY_SIZE(setup) &&
3205 (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3206 if (pnp_device_attach(dev) < 0)
3207 continue;
3208
3209 if (pnp_activate_dev(dev) < 0) {
3210 pnp_device_detach(dev);
3211 continue;
3212 }
3213
3214 if (!pnp_port_valid(dev, 0)) {
3215 pnp_device_detach(dev);
3216 continue;
3217 }
3218
3219 if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3220 pnp_device_detach(dev);
3221 continue;
3222 }
3223
3224 setup[setup_count].io_port = pnp_port_start(dev, 0);
3225 setup[setup_count].irq = pnp_irq(dev, 0);
3226 setup[setup_count].scsiid = 7;
3227 setup[setup_count].reconnect = 1;
3228 setup[setup_count].parity = 1;
3229 setup[setup_count].synchronous = 1;
3230 setup[setup_count].delay = DELAY_DEFAULT;
3231 setup[setup_count].ext_trans = 0;
3232#if defined(__ISAPNP__)
3233 pnpdev[setup_count] = dev;
3234#endif
3235 printk (KERN_INFO
3236 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3237 setup[setup_count].io_port, setup[setup_count].irq);
3238 setup_count++;
3239 }
3240 }
3241#endif
3242
3243#if defined(AUTOCONF)
3244 if (setup_count<ARRAY_SIZE(setup)) {
3245#if !defined(SKIP_BIOSTEST)
3246 ok = 0;
3247 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3248 void __iomem *p = ioremap(addresses[i], 0x4000);
3249 if (!p)
3250 continue;
3251 for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3252 ok = check_signature(p + signatures[j].sig_offset,
3253 signatures[j].signature, signatures[j].sig_length);
3254 iounmap(p);
3255 }
3256 if (!ok && setup_count == 0)
3257 return -ENODEV;
3258
3259 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3260#else
3261 printk(KERN_INFO "aha152x: ");
3262#endif
3263
3264 ok = 0;
3265 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3266 if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3267 continue;
3268
3269 if (!request_region(ports[i], IO_RANGE, "aha152x")) {
3270 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3271 continue;
3272 }
3273
3274 if (aha152x_porttest(ports[i])) {
3275 setup[setup_count].tc1550 = 0;
3276
3277 conf.cf_port =
3278 (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3279 } else if (tc1550_porttest(ports[i])) {
3280 setup[setup_count].tc1550 = 1;
3281
3282 conf.cf_port =
3283 (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3284 } else {
3285 release_region(ports[i], IO_RANGE);
3286 continue;
3287 }
3288
3289 release_region(ports[i], IO_RANGE);
3290
3291 ok++;
3292 setup[setup_count].io_port = ports[i];
3293 setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3294 setup[setup_count].scsiid = conf.cf_id;
3295 setup[setup_count].reconnect = conf.cf_tardisc;
3296 setup[setup_count].parity = !conf.cf_parity;
3297 setup[setup_count].synchronous = conf.cf_syncneg;
3298 setup[setup_count].delay = DELAY_DEFAULT;
3299 setup[setup_count].ext_trans = 0;
3300 setup_count++;
3301
3302 }
3303
3304 if (ok)
3305 printk("auto configuration: ok, ");
3306 }
3307#endif
3308
3309 printk("%d controller(s) configured\n", setup_count);
3310
3311 for (i=0; i<setup_count; i++) {
3312 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3313 struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3314
3315 if( !shpnt ) {
3316 release_region(setup[i].io_port, IO_RANGE);
3317#if defined(__ISAPNP__)
3318 } else if( pnpdev[i] ) {
3319 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3320 pnpdev[i]=NULL;
3321#endif
3322 }
3323 } else {
3324 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3325 }
3326
3327#if defined(__ISAPNP__)
3328 if( pnpdev[i] )
3329 pnp_device_detach(pnpdev[i]);
3330#endif
3331 }
3332
3333 return 0;
3334}
3335
3336static void __exit aha152x_exit(void)
3337{
3338 struct aha152x_hostdata *hd, *tmp;
3339
3340 list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) {
3341 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3342
3343 aha152x_release(shost);
3344 }
3345}
3346
3347module_init(aha152x_init);
3348module_exit(aha152x_exit);
3349
3350#if !defined(MODULE)
3351static int __init aha152x_setup(char *str)
3352{
3353 int ints[10];
3354
3355 get_options(str, ARRAY_SIZE(ints), ints);
3356
3357 if(setup_count>=ARRAY_SIZE(setup)) {
3358 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3359 return 1;
3360 }
3361
3362 setup[setup_count].conf = str;
3363 setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340;
3364 setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11;
3365 setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7;
3366 setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1;
3367 setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1;
3368 setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3369 setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3370 setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0;
3371 if (ints[0] > 8) {
3372 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3373 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3374 } else {
3375 setup_count++;
3376 return 0;
3377 }
3378
3379 return 1;
3380}
3381__setup("aha152x=", aha152x_setup);
3382#endif
3383
3384#endif
3385