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