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