1 /*======================================================================
2
3 NinjaSCSI-3 / NinjaSCSI-32Bi PCMCIA SCSI host adapter card driver
4 By: YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp>
5
6 Ver.2.8 Support 32bit MMIO mode
7 Support Synchronous Data Transfer Request (SDTR) mode
8 Ver.2.0 Support 32bit PIO mode
9 Ver.1.1.2 Fix for scatter list buffer exceeds
10 Ver.1.1 Support scatter list
11 Ver.0.1 Initial version
12
13 This software may be used and distributed according to the terms of
14 the GNU General Public License.
15
16 ======================================================================*/
17
18 /***********************************************************************
19 This driver is for these PCcards.
20
21 I-O DATA PCSC-F (Workbit NinjaSCSI-3)
22 "WBT", "NinjaSCSI-3", "R1.0"
23 I-O DATA CBSC-II (Workbit NinjaSCSI-32Bi in 16bit mode)
24 "IO DATA", "CBSC16 ", "1"
25
26 ***********************************************************************/
27
28 #include <linux/module.h>
29 #include <linux/kernel.h>
30 #include <linux/init.h>
31 #include <linux/slab.h>
32 #include <linux/string.h>
33 #include <linux/timer.h>
34 #include <linux/ioport.h>
35 #include <linux/delay.h>
36 #include <linux/interrupt.h>
37 #include <linux/major.h>
38 #include <linux/blkdev.h>
39 #include <linux/stat.h>
40
41 #include <asm/io.h>
42 #include <asm/irq.h>
43
44 #include <../drivers/scsi/scsi.h>
45 #include <scsi/scsi_host.h>
46
47 #include <scsi/scsi.h>
48 #include <scsi/scsi_ioctl.h>
49
50 #include <pcmcia/cistpl.h>
51 #include <pcmcia/cisreg.h>
52 #include <pcmcia/ds.h>
53
54 #include "nsp_cs.h"
55
56 MODULE_AUTHOR("YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp>");
57 MODULE_DESCRIPTION("WorkBit NinjaSCSI-3 / NinjaSCSI-32Bi(16bit) PCMCIA SCSI host adapter module");
58 MODULE_LICENSE("GPL");
59
60 #include "nsp_io.h"
61
62 /*====================================================================*/
63 /* Parameters that can be set with 'insmod' */
64
65 static int nsp_burst_mode = BURST_MEM32;
66 module_param(nsp_burst_mode, int, 0);
67 MODULE_PARM_DESC(nsp_burst_mode, "Burst transfer mode (0=io8, 1=io32, 2=mem32(default))");
68
69 /* Release IO ports after configuration? */
70 static bool free_ports = 0;
71 module_param(free_ports, bool, 0);
72 MODULE_PARM_DESC(free_ports, "Release IO ports after configuration? (default: 0 (=no))");
73
74 static struct scsi_host_template nsp_driver_template = {
75 .proc_name = "nsp_cs",
76 .show_info = nsp_show_info,
77 .name = "WorkBit NinjaSCSI-3/32Bi(16bit)",
78 .info = nsp_info,
79 .queuecommand = nsp_queuecommand,
80 /* .eh_abort_handler = nsp_eh_abort,*/
81 .eh_bus_reset_handler = nsp_eh_bus_reset,
82 .eh_host_reset_handler = nsp_eh_host_reset,
83 .can_queue = 1,
84 .this_id = NSP_INITIATOR_ID,
85 .sg_tablesize = SG_ALL,
86 .dma_boundary = PAGE_SIZE - 1,
87 };
88
89 static nsp_hw_data nsp_data_base; /* attach <-> detect glue */
90
91
92
93 /*
94 * debug, error print
95 */
96 #ifndef NSP_DEBUG
97 # define NSP_DEBUG_MASK 0x000000
98 # define nsp_msg(type, args...) nsp_cs_message("", 0, (type), args)
99 # define nsp_dbg(mask, args...) /* */
100 #else
101 # define NSP_DEBUG_MASK 0xffffff
102 # define nsp_msg(type, args...) \
103 nsp_cs_message (__func__, __LINE__, (type), args)
104 # define nsp_dbg(mask, args...) \
105 nsp_cs_dmessage(__func__, __LINE__, (mask), args)
106 #endif
107
108 #define NSP_DEBUG_QUEUECOMMAND BIT(0)
109 #define NSP_DEBUG_REGISTER BIT(1)
110 #define NSP_DEBUG_AUTOSCSI BIT(2)
111 #define NSP_DEBUG_INTR BIT(3)
112 #define NSP_DEBUG_SGLIST BIT(4)
113 #define NSP_DEBUG_BUSFREE BIT(5)
114 #define NSP_DEBUG_CDB_CONTENTS BIT(6)
115 #define NSP_DEBUG_RESELECTION BIT(7)
116 #define NSP_DEBUG_MSGINOCCUR BIT(8)
117 #define NSP_DEBUG_EEPROM BIT(9)
118 #define NSP_DEBUG_MSGOUTOCCUR BIT(10)
119 #define NSP_DEBUG_BUSRESET BIT(11)
120 #define NSP_DEBUG_RESTART BIT(12)
121 #define NSP_DEBUG_SYNC BIT(13)
122 #define NSP_DEBUG_WAIT BIT(14)
123 #define NSP_DEBUG_TARGETFLAG BIT(15)
124 #define NSP_DEBUG_PROC BIT(16)
125 #define NSP_DEBUG_INIT BIT(17)
126 #define NSP_DEBUG_DATA_IO BIT(18)
127 #define NSP_SPECIAL_PRINT_REGISTER BIT(20)
128
129 #define NSP_DEBUG_BUF_LEN 150
130
nsp_inc_resid(struct scsi_cmnd * SCpnt,int residInc)131 static inline void nsp_inc_resid(struct scsi_cmnd *SCpnt, int residInc)
132 {
133 scsi_set_resid(SCpnt, scsi_get_resid(SCpnt) + residInc);
134 }
135
136 __printf(4, 5)
nsp_cs_message(const char * func,int line,char * type,char * fmt,...)137 static void nsp_cs_message(const char *func, int line, char *type, char *fmt, ...)
138 {
139 va_list args;
140 char buf[NSP_DEBUG_BUF_LEN];
141
142 va_start(args, fmt);
143 vsnprintf(buf, sizeof(buf), fmt, args);
144 va_end(args);
145
146 #ifndef NSP_DEBUG
147 printk("%snsp_cs: %s\n", type, buf);
148 #else
149 printk("%snsp_cs: %s (%d): %s\n", type, func, line, buf);
150 #endif
151 }
152
153 #ifdef NSP_DEBUG
nsp_cs_dmessage(const char * func,int line,int mask,char * fmt,...)154 static void nsp_cs_dmessage(const char *func, int line, int mask, char *fmt, ...)
155 {
156 va_list args;
157 char buf[NSP_DEBUG_BUF_LEN];
158
159 va_start(args, fmt);
160 vsnprintf(buf, sizeof(buf), fmt, args);
161 va_end(args);
162
163 if (mask & NSP_DEBUG_MASK) {
164 printk("nsp_cs-debug: 0x%x %s (%d): %s\n", mask, func, line, buf);
165 }
166 }
167 #endif
168
169 /***********************************************************/
170
171 /*====================================================
172 * Clenaup parameters and call done() functions.
173 * You must be set SCpnt->result before call this function.
174 */
nsp_scsi_done(struct scsi_cmnd * SCpnt)175 static void nsp_scsi_done(struct scsi_cmnd *SCpnt)
176 {
177 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
178
179 data->CurrentSC = NULL;
180
181 scsi_done(SCpnt);
182 }
183
nsp_queuecommand_lck(struct scsi_cmnd * SCpnt)184 static int nsp_queuecommand_lck(struct scsi_cmnd *SCpnt)
185 {
186 #ifdef NSP_DEBUG
187 /*unsigned int host_id = SCpnt->device->host->this_id;*/
188 /*unsigned int base = SCpnt->device->host->io_port;*/
189 unsigned char target = scmd_id(SCpnt);
190 #endif
191 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
192
193 nsp_dbg(NSP_DEBUG_QUEUECOMMAND,
194 "SCpnt=0x%p target=%d lun=%llu sglist=0x%p bufflen=%d sg_count=%d",
195 SCpnt, target, SCpnt->device->lun, scsi_sglist(SCpnt),
196 scsi_bufflen(SCpnt), scsi_sg_count(SCpnt));
197 //nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "before CurrentSC=0x%p", data->CurrentSC);
198
199 if (data->CurrentSC != NULL) {
200 nsp_msg(KERN_DEBUG, "CurrentSC!=NULL this can't be happen");
201 SCpnt->result = DID_BAD_TARGET << 16;
202 nsp_scsi_done(SCpnt);
203 return 0;
204 }
205
206 #if 0
207 /* XXX: pcmcia-cs generates SCSI command with "scsi_info" utility.
208 This makes kernel crash when suspending... */
209 if (data->ScsiInfo->stop != 0) {
210 nsp_msg(KERN_INFO, "suspending device. reject command.");
211 SCpnt->result = DID_BAD_TARGET << 16;
212 nsp_scsi_done(SCpnt);
213 return SCSI_MLQUEUE_HOST_BUSY;
214 }
215 #endif
216
217 show_command(SCpnt);
218
219 data->CurrentSC = SCpnt;
220
221 SCpnt->SCp.Status = SAM_STAT_CHECK_CONDITION;
222 SCpnt->SCp.Message = 0;
223 SCpnt->SCp.have_data_in = IO_UNKNOWN;
224 SCpnt->SCp.sent_command = 0;
225 SCpnt->SCp.phase = PH_UNDETERMINED;
226 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
227
228 /* setup scratch area
229 SCp.ptr : buffer pointer
230 SCp.this_residual : buffer length
231 SCp.buffer : next buffer
232 SCp.buffers_residual : left buffers in list
233 SCp.phase : current state of the command */
234 if (scsi_bufflen(SCpnt)) {
235 SCpnt->SCp.buffer = scsi_sglist(SCpnt);
236 SCpnt->SCp.ptr = BUFFER_ADDR;
237 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
238 SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1;
239 } else {
240 SCpnt->SCp.ptr = NULL;
241 SCpnt->SCp.this_residual = 0;
242 SCpnt->SCp.buffer = NULL;
243 SCpnt->SCp.buffers_residual = 0;
244 }
245
246 if (nsphw_start_selection(SCpnt) == FALSE) {
247 nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "selection fail");
248 SCpnt->result = DID_BUS_BUSY << 16;
249 nsp_scsi_done(SCpnt);
250 return 0;
251 }
252
253
254 //nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "out");
255 #ifdef NSP_DEBUG
256 data->CmdId++;
257 #endif
258 return 0;
259 }
260
DEF_SCSI_QCMD(nsp_queuecommand)261 static DEF_SCSI_QCMD(nsp_queuecommand)
262
263 /*
264 * setup PIO FIFO transfer mode and enable/disable to data out
265 */
266 static void nsp_setup_fifo(nsp_hw_data *data, int enabled)
267 {
268 unsigned int base = data->BaseAddress;
269 unsigned char transfer_mode_reg;
270
271 //nsp_dbg(NSP_DEBUG_DATA_IO, "enabled=%d", enabled);
272
273 if (enabled != FALSE) {
274 transfer_mode_reg = TRANSFER_GO | BRAIND;
275 } else {
276 transfer_mode_reg = 0;
277 }
278
279 transfer_mode_reg |= data->TransferMode;
280
281 nsp_index_write(base, TRANSFERMODE, transfer_mode_reg);
282 }
283
nsphw_init_sync(nsp_hw_data * data)284 static void nsphw_init_sync(nsp_hw_data *data)
285 {
286 sync_data tmp_sync = { .SyncNegotiation = SYNC_NOT_YET,
287 .SyncPeriod = 0,
288 .SyncOffset = 0
289 };
290 int i;
291
292 /* setup sync data */
293 for ( i = 0; i < ARRAY_SIZE(data->Sync); i++ ) {
294 data->Sync[i] = tmp_sync;
295 }
296 }
297
298 /*
299 * Initialize Ninja hardware
300 */
nsphw_init(nsp_hw_data * data)301 static int nsphw_init(nsp_hw_data *data)
302 {
303 unsigned int base = data->BaseAddress;
304
305 nsp_dbg(NSP_DEBUG_INIT, "in base=0x%x", base);
306
307 data->ScsiClockDiv = CLOCK_40M | FAST_20;
308 data->CurrentSC = NULL;
309 data->FifoCount = 0;
310 data->TransferMode = MODE_IO8;
311
312 nsphw_init_sync(data);
313
314 /* block all interrupts */
315 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLMASK);
316
317 /* setup SCSI interface */
318 nsp_write(base, IFSELECT, IF_IFSEL);
319
320 nsp_index_write(base, SCSIIRQMODE, 0);
321
322 nsp_index_write(base, TRANSFERMODE, MODE_IO8);
323 nsp_index_write(base, CLOCKDIV, data->ScsiClockDiv);
324
325 nsp_index_write(base, PARITYCTRL, 0);
326 nsp_index_write(base, POINTERCLR, POINTER_CLEAR |
327 ACK_COUNTER_CLEAR |
328 REQ_COUNTER_CLEAR |
329 HOST_COUNTER_CLEAR);
330
331 /* setup fifo asic */
332 nsp_write(base, IFSELECT, IF_REGSEL);
333 nsp_index_write(base, TERMPWRCTRL, 0);
334 if ((nsp_index_read(base, OTHERCONTROL) & TPWR_SENSE) == 0) {
335 nsp_msg(KERN_INFO, "terminator power on");
336 nsp_index_write(base, TERMPWRCTRL, POWER_ON);
337 }
338
339 nsp_index_write(base, TIMERCOUNT, 0);
340 nsp_index_write(base, TIMERCOUNT, 0); /* requires 2 times!! */
341
342 nsp_index_write(base, SYNCREG, 0);
343 nsp_index_write(base, ACKWIDTH, 0);
344
345 /* enable interrupts and ack them */
346 nsp_index_write(base, SCSIIRQMODE, SCSI_PHASE_CHANGE_EI |
347 RESELECT_EI |
348 SCSI_RESET_IRQ_EI );
349 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLCLEAR);
350
351 nsp_setup_fifo(data, FALSE);
352
353 return TRUE;
354 }
355
356 /*
357 * Start selection phase
358 */
nsphw_start_selection(struct scsi_cmnd * SCpnt)359 static int nsphw_start_selection(struct scsi_cmnd *SCpnt)
360 {
361 unsigned int host_id = SCpnt->device->host->this_id;
362 unsigned int base = SCpnt->device->host->io_port;
363 unsigned char target = scmd_id(SCpnt);
364 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
365 int time_out;
366 unsigned char phase, arbit;
367
368 //nsp_dbg(NSP_DEBUG_RESELECTION, "in");
369
370 phase = nsp_index_read(base, SCSIBUSMON);
371 if(phase != BUSMON_BUS_FREE) {
372 //nsp_dbg(NSP_DEBUG_RESELECTION, "bus busy");
373 return FALSE;
374 }
375
376 /* start arbitration */
377 //nsp_dbg(NSP_DEBUG_RESELECTION, "start arbit");
378 SCpnt->SCp.phase = PH_ARBSTART;
379 nsp_index_write(base, SETARBIT, ARBIT_GO);
380
381 time_out = 1000;
382 do {
383 /* XXX: what a stupid chip! */
384 arbit = nsp_index_read(base, ARBITSTATUS);
385 //nsp_dbg(NSP_DEBUG_RESELECTION, "arbit=%d, wait_count=%d", arbit, wait_count);
386 udelay(1); /* hold 1.2us */
387 } while((arbit & (ARBIT_WIN | ARBIT_FAIL)) == 0 &&
388 (time_out-- != 0));
389
390 if (!(arbit & ARBIT_WIN)) {
391 //nsp_dbg(NSP_DEBUG_RESELECTION, "arbit fail");
392 nsp_index_write(base, SETARBIT, ARBIT_FLAG_CLEAR);
393 return FALSE;
394 }
395
396 /* assert select line */
397 //nsp_dbg(NSP_DEBUG_RESELECTION, "assert SEL line");
398 SCpnt->SCp.phase = PH_SELSTART;
399 udelay(3); /* wait 2.4us */
400 nsp_index_write(base, SCSIDATALATCH, BIT(host_id) | BIT(target));
401 nsp_index_write(base, SCSIBUSCTRL, SCSI_SEL | SCSI_BSY | SCSI_ATN);
402 udelay(2); /* wait >1.2us */
403 nsp_index_write(base, SCSIBUSCTRL, SCSI_SEL | SCSI_BSY | SCSI_DATAOUT_ENB | SCSI_ATN);
404 nsp_index_write(base, SETARBIT, ARBIT_FLAG_CLEAR);
405 /*udelay(1);*/ /* wait >90ns */
406 nsp_index_write(base, SCSIBUSCTRL, SCSI_SEL | SCSI_DATAOUT_ENB | SCSI_ATN);
407
408 /* check selection timeout */
409 nsp_start_timer(SCpnt, 1000/51);
410 data->SelectionTimeOut = 1;
411
412 return TRUE;
413 }
414
415 struct nsp_sync_table {
416 unsigned int min_period;
417 unsigned int max_period;
418 unsigned int chip_period;
419 unsigned int ack_width;
420 };
421
422 static struct nsp_sync_table nsp_sync_table_40M[] = {
423 {0x0c, 0x0c, 0x1, 0}, /* 20MB 50ns*/
424 {0x19, 0x19, 0x3, 1}, /* 10MB 100ns*/
425 {0x1a, 0x25, 0x5, 2}, /* 7.5MB 150ns*/
426 {0x26, 0x32, 0x7, 3}, /* 5MB 200ns*/
427 { 0, 0, 0, 0},
428 };
429
430 static struct nsp_sync_table nsp_sync_table_20M[] = {
431 {0x19, 0x19, 0x1, 0}, /* 10MB 100ns*/
432 {0x1a, 0x25, 0x2, 0}, /* 7.5MB 150ns*/
433 {0x26, 0x32, 0x3, 1}, /* 5MB 200ns*/
434 { 0, 0, 0, 0},
435 };
436
437 /*
438 * setup synchronous data transfer mode
439 */
nsp_analyze_sdtr(struct scsi_cmnd * SCpnt)440 static int nsp_analyze_sdtr(struct scsi_cmnd *SCpnt)
441 {
442 unsigned char target = scmd_id(SCpnt);
443 // unsigned char lun = SCpnt->device->lun;
444 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
445 sync_data *sync = &(data->Sync[target]);
446 struct nsp_sync_table *sync_table;
447 unsigned int period, offset;
448 int i;
449
450
451 nsp_dbg(NSP_DEBUG_SYNC, "in");
452
453 period = sync->SyncPeriod;
454 offset = sync->SyncOffset;
455
456 nsp_dbg(NSP_DEBUG_SYNC, "period=0x%x, offset=0x%x", period, offset);
457
458 if ((data->ScsiClockDiv & (BIT(0)|BIT(1))) == CLOCK_20M) {
459 sync_table = nsp_sync_table_20M;
460 } else {
461 sync_table = nsp_sync_table_40M;
462 }
463
464 for ( i = 0; sync_table->max_period != 0; i++, sync_table++) {
465 if ( period >= sync_table->min_period &&
466 period <= sync_table->max_period ) {
467 break;
468 }
469 }
470
471 if (period != 0 && sync_table->max_period == 0) {
472 /*
473 * No proper period/offset found
474 */
475 nsp_dbg(NSP_DEBUG_SYNC, "no proper period/offset");
476
477 sync->SyncPeriod = 0;
478 sync->SyncOffset = 0;
479 sync->SyncRegister = 0;
480 sync->AckWidth = 0;
481
482 return FALSE;
483 }
484
485 sync->SyncRegister = (sync_table->chip_period << SYNCREG_PERIOD_SHIFT) |
486 (offset & SYNCREG_OFFSET_MASK);
487 sync->AckWidth = sync_table->ack_width;
488
489 nsp_dbg(NSP_DEBUG_SYNC, "sync_reg=0x%x, ack_width=0x%x", sync->SyncRegister, sync->AckWidth);
490
491 return TRUE;
492 }
493
494
495 /*
496 * start ninja hardware timer
497 */
nsp_start_timer(struct scsi_cmnd * SCpnt,int time)498 static void nsp_start_timer(struct scsi_cmnd *SCpnt, int time)
499 {
500 unsigned int base = SCpnt->device->host->io_port;
501 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
502
503 //nsp_dbg(NSP_DEBUG_INTR, "in SCpnt=0x%p, time=%d", SCpnt, time);
504 data->TimerCount = time;
505 nsp_index_write(base, TIMERCOUNT, time);
506 }
507
508 /*
509 * wait for bus phase change
510 */
nsp_negate_signal(struct scsi_cmnd * SCpnt,unsigned char mask,char * str)511 static int nsp_negate_signal(struct scsi_cmnd *SCpnt, unsigned char mask,
512 char *str)
513 {
514 unsigned int base = SCpnt->device->host->io_port;
515 unsigned char reg;
516 int time_out;
517
518 //nsp_dbg(NSP_DEBUG_INTR, "in");
519
520 time_out = 100;
521
522 do {
523 reg = nsp_index_read(base, SCSIBUSMON);
524 if (reg == 0xff) {
525 break;
526 }
527 } while ((--time_out != 0) && (reg & mask) != 0);
528
529 if (time_out == 0) {
530 nsp_msg(KERN_DEBUG, " %s signal off timeout", str);
531 }
532
533 return 0;
534 }
535
536 /*
537 * expect Ninja Irq
538 */
nsp_expect_signal(struct scsi_cmnd * SCpnt,unsigned char current_phase,unsigned char mask)539 static int nsp_expect_signal(struct scsi_cmnd *SCpnt,
540 unsigned char current_phase,
541 unsigned char mask)
542 {
543 unsigned int base = SCpnt->device->host->io_port;
544 int time_out;
545 unsigned char phase, i_src;
546
547 //nsp_dbg(NSP_DEBUG_INTR, "current_phase=0x%x, mask=0x%x", current_phase, mask);
548
549 time_out = 100;
550 do {
551 phase = nsp_index_read(base, SCSIBUSMON);
552 if (phase == 0xff) {
553 //nsp_dbg(NSP_DEBUG_INTR, "ret -1");
554 return -1;
555 }
556 i_src = nsp_read(base, IRQSTATUS);
557 if (i_src & IRQSTATUS_SCSI) {
558 //nsp_dbg(NSP_DEBUG_INTR, "ret 0 found scsi signal");
559 return 0;
560 }
561 if ((phase & mask) != 0 && (phase & BUSMON_PHASE_MASK) == current_phase) {
562 //nsp_dbg(NSP_DEBUG_INTR, "ret 1 phase=0x%x", phase);
563 return 1;
564 }
565 } while(time_out-- != 0);
566
567 //nsp_dbg(NSP_DEBUG_INTR, "timeout");
568 return -1;
569 }
570
571 /*
572 * transfer SCSI message
573 */
nsp_xfer(struct scsi_cmnd * SCpnt,int phase)574 static int nsp_xfer(struct scsi_cmnd *SCpnt, int phase)
575 {
576 unsigned int base = SCpnt->device->host->io_port;
577 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
578 char *buf = data->MsgBuffer;
579 int len = min(MSGBUF_SIZE, data->MsgLen);
580 int ptr;
581 int ret;
582
583 //nsp_dbg(NSP_DEBUG_DATA_IO, "in");
584 for (ptr = 0; len > 0; len--, ptr++) {
585
586 ret = nsp_expect_signal(SCpnt, phase, BUSMON_REQ);
587 if (ret <= 0) {
588 nsp_dbg(NSP_DEBUG_DATA_IO, "xfer quit");
589 return 0;
590 }
591
592 /* if last byte, negate ATN */
593 if (len == 1 && SCpnt->SCp.phase == PH_MSG_OUT) {
594 nsp_index_write(base, SCSIBUSCTRL, AUTODIRECTION | ACKENB);
595 }
596
597 /* read & write message */
598 if (phase & BUSMON_IO) {
599 nsp_dbg(NSP_DEBUG_DATA_IO, "read msg");
600 buf[ptr] = nsp_index_read(base, SCSIDATAWITHACK);
601 } else {
602 nsp_dbg(NSP_DEBUG_DATA_IO, "write msg");
603 nsp_index_write(base, SCSIDATAWITHACK, buf[ptr]);
604 }
605 nsp_negate_signal(SCpnt, BUSMON_ACK, "xfer<ack>");
606
607 }
608 return len;
609 }
610
611 /*
612 * get extra SCSI data from fifo
613 */
nsp_dataphase_bypass(struct scsi_cmnd * SCpnt)614 static int nsp_dataphase_bypass(struct scsi_cmnd *SCpnt)
615 {
616 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
617 unsigned int count;
618
619 //nsp_dbg(NSP_DEBUG_DATA_IO, "in");
620
621 if (SCpnt->SCp.have_data_in != IO_IN) {
622 return 0;
623 }
624
625 count = nsp_fifo_count(SCpnt);
626 if (data->FifoCount == count) {
627 //nsp_dbg(NSP_DEBUG_DATA_IO, "not use bypass quirk");
628 return 0;
629 }
630
631 /*
632 * XXX: NSP_QUIRK
633 * data phase skip only occures in case of SCSI_LOW_READ
634 */
635 nsp_dbg(NSP_DEBUG_DATA_IO, "use bypass quirk");
636 SCpnt->SCp.phase = PH_DATA;
637 nsp_pio_read(SCpnt);
638 nsp_setup_fifo(data, FALSE);
639
640 return 0;
641 }
642
643 /*
644 * accept reselection
645 */
nsp_reselected(struct scsi_cmnd * SCpnt)646 static int nsp_reselected(struct scsi_cmnd *SCpnt)
647 {
648 unsigned int base = SCpnt->device->host->io_port;
649 unsigned int host_id = SCpnt->device->host->this_id;
650 //nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
651 unsigned char bus_reg;
652 unsigned char id_reg, tmp;
653 int target;
654
655 nsp_dbg(NSP_DEBUG_RESELECTION, "in");
656
657 id_reg = nsp_index_read(base, RESELECTID);
658 tmp = id_reg & (~BIT(host_id));
659 target = 0;
660 while(tmp != 0) {
661 if (tmp & BIT(0)) {
662 break;
663 }
664 tmp >>= 1;
665 target++;
666 }
667
668 if (scmd_id(SCpnt) != target) {
669 nsp_msg(KERN_ERR, "XXX: reselect ID must be %d in this implementation.", target);
670 }
671
672 nsp_negate_signal(SCpnt, BUSMON_SEL, "reselect<SEL>");
673
674 nsp_nexus(SCpnt);
675 bus_reg = nsp_index_read(base, SCSIBUSCTRL) & ~(SCSI_BSY | SCSI_ATN);
676 nsp_index_write(base, SCSIBUSCTRL, bus_reg);
677 nsp_index_write(base, SCSIBUSCTRL, bus_reg | AUTODIRECTION | ACKENB);
678
679 return TRUE;
680 }
681
682 /*
683 * count how many data transferd
684 */
nsp_fifo_count(struct scsi_cmnd * SCpnt)685 static int nsp_fifo_count(struct scsi_cmnd *SCpnt)
686 {
687 unsigned int base = SCpnt->device->host->io_port;
688 unsigned int count;
689 unsigned int l, m, h;
690
691 nsp_index_write(base, POINTERCLR, POINTER_CLEAR | ACK_COUNTER);
692
693 l = nsp_index_read(base, TRANSFERCOUNT);
694 m = nsp_index_read(base, TRANSFERCOUNT);
695 h = nsp_index_read(base, TRANSFERCOUNT);
696 nsp_index_read(base, TRANSFERCOUNT); /* required this! */
697
698 count = (h << 16) | (m << 8) | (l << 0);
699
700 //nsp_dbg(NSP_DEBUG_DATA_IO, "count=0x%x", count);
701
702 return count;
703 }
704
705 /* fifo size */
706 #define RFIFO_CRIT 64
707 #define WFIFO_CRIT 64
708
709 /*
710 * read data in DATA IN phase
711 */
nsp_pio_read(struct scsi_cmnd * SCpnt)712 static void nsp_pio_read(struct scsi_cmnd *SCpnt)
713 {
714 unsigned int base = SCpnt->device->host->io_port;
715 unsigned long mmio_base = SCpnt->device->host->base;
716 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
717 long time_out;
718 int ocount, res;
719 unsigned char stat, fifo_stat;
720
721 ocount = data->FifoCount;
722
723 nsp_dbg(NSP_DEBUG_DATA_IO, "in SCpnt=0x%p resid=%d ocount=%d ptr=0x%p this_residual=%d buffers=0x%p nbuf=%d",
724 SCpnt, scsi_get_resid(SCpnt), ocount, SCpnt->SCp.ptr,
725 SCpnt->SCp.this_residual, SCpnt->SCp.buffer,
726 SCpnt->SCp.buffers_residual);
727
728 time_out = 1000;
729
730 while ((time_out-- != 0) &&
731 (SCpnt->SCp.this_residual > 0 || SCpnt->SCp.buffers_residual > 0 ) ) {
732
733 stat = nsp_index_read(base, SCSIBUSMON);
734 stat &= BUSMON_PHASE_MASK;
735
736
737 res = nsp_fifo_count(SCpnt) - ocount;
738 //nsp_dbg(NSP_DEBUG_DATA_IO, "ptr=0x%p this=0x%x ocount=0x%x res=0x%x", SCpnt->SCp.ptr, SCpnt->SCp.this_residual, ocount, res);
739 if (res == 0) { /* if some data available ? */
740 if (stat == BUSPHASE_DATA_IN) { /* phase changed? */
741 //nsp_dbg(NSP_DEBUG_DATA_IO, " wait for data this=%d", SCpnt->SCp.this_residual);
742 continue;
743 } else {
744 nsp_dbg(NSP_DEBUG_DATA_IO, "phase changed stat=0x%x", stat);
745 break;
746 }
747 }
748
749 fifo_stat = nsp_read(base, FIFOSTATUS);
750 if ((fifo_stat & FIFOSTATUS_FULL_EMPTY) == 0 &&
751 stat == BUSPHASE_DATA_IN) {
752 continue;
753 }
754
755 res = min(res, SCpnt->SCp.this_residual);
756
757 switch (data->TransferMode) {
758 case MODE_IO32:
759 res &= ~(BIT(1)|BIT(0)); /* align 4 */
760 nsp_fifo32_read(base, SCpnt->SCp.ptr, res >> 2);
761 break;
762 case MODE_IO8:
763 nsp_fifo8_read (base, SCpnt->SCp.ptr, res );
764 break;
765
766 case MODE_MEM32:
767 res &= ~(BIT(1)|BIT(0)); /* align 4 */
768 nsp_mmio_fifo32_read(mmio_base, SCpnt->SCp.ptr, res >> 2);
769 break;
770
771 default:
772 nsp_dbg(NSP_DEBUG_DATA_IO, "unknown read mode");
773 return;
774 }
775
776 nsp_inc_resid(SCpnt, -res);
777 SCpnt->SCp.ptr += res;
778 SCpnt->SCp.this_residual -= res;
779 ocount += res;
780 //nsp_dbg(NSP_DEBUG_DATA_IO, "ptr=0x%p this_residual=0x%x ocount=0x%x", SCpnt->SCp.ptr, SCpnt->SCp.this_residual, ocount);
781
782 /* go to next scatter list if available */
783 if (SCpnt->SCp.this_residual == 0 &&
784 SCpnt->SCp.buffers_residual != 0 ) {
785 //nsp_dbg(NSP_DEBUG_DATA_IO, "scatterlist next timeout=%d", time_out);
786 SCpnt->SCp.buffers_residual--;
787 SCpnt->SCp.buffer = sg_next(SCpnt->SCp.buffer);
788 SCpnt->SCp.ptr = BUFFER_ADDR;
789 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
790 time_out = 1000;
791
792 //nsp_dbg(NSP_DEBUG_DATA_IO, "page: 0x%p, off: 0x%x", SCpnt->SCp.buffer->page, SCpnt->SCp.buffer->offset);
793 }
794 }
795
796 data->FifoCount = ocount;
797
798 if (time_out < 0) {
799 nsp_msg(KERN_DEBUG, "pio read timeout resid=%d this_residual=%d buffers_residual=%d",
800 scsi_get_resid(SCpnt), SCpnt->SCp.this_residual,
801 SCpnt->SCp.buffers_residual);
802 }
803 nsp_dbg(NSP_DEBUG_DATA_IO, "read ocount=0x%x", ocount);
804 nsp_dbg(NSP_DEBUG_DATA_IO, "r cmd=%d resid=0x%x\n", data->CmdId,
805 scsi_get_resid(SCpnt));
806 }
807
808 /*
809 * write data in DATA OUT phase
810 */
nsp_pio_write(struct scsi_cmnd * SCpnt)811 static void nsp_pio_write(struct scsi_cmnd *SCpnt)
812 {
813 unsigned int base = SCpnt->device->host->io_port;
814 unsigned long mmio_base = SCpnt->device->host->base;
815 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
816 int time_out;
817 int ocount, res;
818 unsigned char stat;
819
820 ocount = data->FifoCount;
821
822 nsp_dbg(NSP_DEBUG_DATA_IO, "in fifocount=%d ptr=0x%p this_residual=%d buffers=0x%p nbuf=%d resid=0x%x",
823 data->FifoCount, SCpnt->SCp.ptr, SCpnt->SCp.this_residual,
824 SCpnt->SCp.buffer, SCpnt->SCp.buffers_residual,
825 scsi_get_resid(SCpnt));
826
827 time_out = 1000;
828
829 while ((time_out-- != 0) &&
830 (SCpnt->SCp.this_residual > 0 || SCpnt->SCp.buffers_residual > 0)) {
831 stat = nsp_index_read(base, SCSIBUSMON);
832 stat &= BUSMON_PHASE_MASK;
833
834 if (stat != BUSPHASE_DATA_OUT) {
835 res = ocount - nsp_fifo_count(SCpnt);
836
837 nsp_dbg(NSP_DEBUG_DATA_IO, "phase changed stat=0x%x, res=%d\n", stat, res);
838 /* Put back pointer */
839 nsp_inc_resid(SCpnt, res);
840 SCpnt->SCp.ptr -= res;
841 SCpnt->SCp.this_residual += res;
842 ocount -= res;
843
844 break;
845 }
846
847 res = ocount - nsp_fifo_count(SCpnt);
848 if (res > 0) { /* write all data? */
849 nsp_dbg(NSP_DEBUG_DATA_IO, "wait for all data out. ocount=0x%x res=%d", ocount, res);
850 continue;
851 }
852
853 res = min(SCpnt->SCp.this_residual, WFIFO_CRIT);
854
855 //nsp_dbg(NSP_DEBUG_DATA_IO, "ptr=0x%p this=0x%x res=0x%x", SCpnt->SCp.ptr, SCpnt->SCp.this_residual, res);
856 switch (data->TransferMode) {
857 case MODE_IO32:
858 res &= ~(BIT(1)|BIT(0)); /* align 4 */
859 nsp_fifo32_write(base, SCpnt->SCp.ptr, res >> 2);
860 break;
861 case MODE_IO8:
862 nsp_fifo8_write (base, SCpnt->SCp.ptr, res );
863 break;
864
865 case MODE_MEM32:
866 res &= ~(BIT(1)|BIT(0)); /* align 4 */
867 nsp_mmio_fifo32_write(mmio_base, SCpnt->SCp.ptr, res >> 2);
868 break;
869
870 default:
871 nsp_dbg(NSP_DEBUG_DATA_IO, "unknown write mode");
872 break;
873 }
874
875 nsp_inc_resid(SCpnt, -res);
876 SCpnt->SCp.ptr += res;
877 SCpnt->SCp.this_residual -= res;
878 ocount += res;
879
880 /* go to next scatter list if available */
881 if (SCpnt->SCp.this_residual == 0 &&
882 SCpnt->SCp.buffers_residual != 0 ) {
883 //nsp_dbg(NSP_DEBUG_DATA_IO, "scatterlist next");
884 SCpnt->SCp.buffers_residual--;
885 SCpnt->SCp.buffer = sg_next(SCpnt->SCp.buffer);
886 SCpnt->SCp.ptr = BUFFER_ADDR;
887 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
888 time_out = 1000;
889 }
890 }
891
892 data->FifoCount = ocount;
893
894 if (time_out < 0) {
895 nsp_msg(KERN_DEBUG, "pio write timeout resid=0x%x",
896 scsi_get_resid(SCpnt));
897 }
898 nsp_dbg(NSP_DEBUG_DATA_IO, "write ocount=0x%x", ocount);
899 nsp_dbg(NSP_DEBUG_DATA_IO, "w cmd=%d resid=0x%x\n", data->CmdId,
900 scsi_get_resid(SCpnt));
901 }
902 #undef RFIFO_CRIT
903 #undef WFIFO_CRIT
904
905 /*
906 * setup synchronous/asynchronous data transfer mode
907 */
nsp_nexus(struct scsi_cmnd * SCpnt)908 static int nsp_nexus(struct scsi_cmnd *SCpnt)
909 {
910 unsigned int base = SCpnt->device->host->io_port;
911 unsigned char target = scmd_id(SCpnt);
912 // unsigned char lun = SCpnt->device->lun;
913 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
914 sync_data *sync = &(data->Sync[target]);
915
916 //nsp_dbg(NSP_DEBUG_DATA_IO, "in SCpnt=0x%p", SCpnt);
917
918 /* setup synch transfer registers */
919 nsp_index_write(base, SYNCREG, sync->SyncRegister);
920 nsp_index_write(base, ACKWIDTH, sync->AckWidth);
921
922 if (scsi_get_resid(SCpnt) % 4 != 0 ||
923 scsi_get_resid(SCpnt) <= PAGE_SIZE ) {
924 data->TransferMode = MODE_IO8;
925 } else if (nsp_burst_mode == BURST_MEM32) {
926 data->TransferMode = MODE_MEM32;
927 } else if (nsp_burst_mode == BURST_IO32) {
928 data->TransferMode = MODE_IO32;
929 } else {
930 data->TransferMode = MODE_IO8;
931 }
932
933 /* setup pdma fifo */
934 nsp_setup_fifo(data, TRUE);
935
936 /* clear ack counter */
937 data->FifoCount = 0;
938 nsp_index_write(base, POINTERCLR, POINTER_CLEAR |
939 ACK_COUNTER_CLEAR |
940 REQ_COUNTER_CLEAR |
941 HOST_COUNTER_CLEAR);
942
943 return 0;
944 }
945
946 #include "nsp_message.c"
947 /*
948 * interrupt handler
949 */
nspintr(int irq,void * dev_id)950 static irqreturn_t nspintr(int irq, void *dev_id)
951 {
952 unsigned int base;
953 unsigned char irq_status, irq_phase, phase;
954 struct scsi_cmnd *tmpSC;
955 unsigned char target, lun;
956 unsigned int *sync_neg;
957 int i, tmp;
958 nsp_hw_data *data;
959
960
961 //nsp_dbg(NSP_DEBUG_INTR, "dev_id=0x%p", dev_id);
962 //nsp_dbg(NSP_DEBUG_INTR, "host=0x%p", ((scsi_info_t *)dev_id)->host);
963
964 if ( dev_id != NULL &&
965 ((scsi_info_t *)dev_id)->host != NULL ) {
966 scsi_info_t *info = (scsi_info_t *)dev_id;
967
968 data = (nsp_hw_data *)info->host->hostdata;
969 } else {
970 nsp_dbg(NSP_DEBUG_INTR, "host data wrong");
971 return IRQ_NONE;
972 }
973
974 //nsp_dbg(NSP_DEBUG_INTR, "&nsp_data_base=0x%p, dev_id=0x%p", &nsp_data_base, dev_id);
975
976 base = data->BaseAddress;
977 //nsp_dbg(NSP_DEBUG_INTR, "base=0x%x", base);
978
979 /*
980 * interrupt check
981 */
982 nsp_write(base, IRQCONTROL, IRQCONTROL_IRQDISABLE);
983 irq_status = nsp_read(base, IRQSTATUS);
984 //nsp_dbg(NSP_DEBUG_INTR, "irq_status=0x%x", irq_status);
985 if ((irq_status == 0xff) || ((irq_status & IRQSTATUS_MASK) == 0)) {
986 nsp_write(base, IRQCONTROL, 0);
987 //nsp_dbg(NSP_DEBUG_INTR, "no irq/shared irq");
988 return IRQ_NONE;
989 }
990
991 /* XXX: IMPORTANT
992 * Do not read an irq_phase register if no scsi phase interrupt.
993 * Unless, you should lose a scsi phase interrupt.
994 */
995 phase = nsp_index_read(base, SCSIBUSMON);
996 if((irq_status & IRQSTATUS_SCSI) != 0) {
997 irq_phase = nsp_index_read(base, IRQPHASESENCE);
998 } else {
999 irq_phase = 0;
1000 }
1001
1002 //nsp_dbg(NSP_DEBUG_INTR, "irq_phase=0x%x", irq_phase);
1003
1004 /*
1005 * timer interrupt handler (scsi vs timer interrupts)
1006 */
1007 //nsp_dbg(NSP_DEBUG_INTR, "timercount=%d", data->TimerCount);
1008 if (data->TimerCount != 0) {
1009 //nsp_dbg(NSP_DEBUG_INTR, "stop timer");
1010 nsp_index_write(base, TIMERCOUNT, 0);
1011 nsp_index_write(base, TIMERCOUNT, 0);
1012 data->TimerCount = 0;
1013 }
1014
1015 if ((irq_status & IRQSTATUS_MASK) == IRQSTATUS_TIMER &&
1016 data->SelectionTimeOut == 0) {
1017 //nsp_dbg(NSP_DEBUG_INTR, "timer start");
1018 nsp_write(base, IRQCONTROL, IRQCONTROL_TIMER_CLEAR);
1019 return IRQ_HANDLED;
1020 }
1021
1022 nsp_write(base, IRQCONTROL, IRQCONTROL_TIMER_CLEAR | IRQCONTROL_FIFO_CLEAR);
1023
1024 if ((irq_status & IRQSTATUS_SCSI) &&
1025 (irq_phase & SCSI_RESET_IRQ)) {
1026 nsp_msg(KERN_ERR, "bus reset (power off?)");
1027
1028 nsphw_init(data);
1029 nsp_bus_reset(data);
1030
1031 if(data->CurrentSC != NULL) {
1032 tmpSC = data->CurrentSC;
1033 tmpSC->result = (DID_RESET << 16) |
1034 ((tmpSC->SCp.Message & 0xff) << 8) |
1035 ((tmpSC->SCp.Status & 0xff) << 0);
1036 nsp_scsi_done(tmpSC);
1037 }
1038 return IRQ_HANDLED;
1039 }
1040
1041 if (data->CurrentSC == NULL) {
1042 nsp_msg(KERN_ERR, "CurrentSC==NULL irq_status=0x%x phase=0x%x irq_phase=0x%x this can't be happen. reset everything", irq_status, phase, irq_phase);
1043 nsphw_init(data);
1044 nsp_bus_reset(data);
1045 return IRQ_HANDLED;
1046 }
1047
1048 tmpSC = data->CurrentSC;
1049 target = tmpSC->device->id;
1050 lun = tmpSC->device->lun;
1051 sync_neg = &(data->Sync[target].SyncNegotiation);
1052
1053 /*
1054 * parse hardware SCSI irq reasons register
1055 */
1056 if (irq_status & IRQSTATUS_SCSI) {
1057 if (irq_phase & RESELECT_IRQ) {
1058 nsp_dbg(NSP_DEBUG_INTR, "reselect");
1059 nsp_write(base, IRQCONTROL, IRQCONTROL_RESELECT_CLEAR);
1060 if (nsp_reselected(tmpSC) != FALSE) {
1061 return IRQ_HANDLED;
1062 }
1063 }
1064
1065 if ((irq_phase & (PHASE_CHANGE_IRQ | LATCHED_BUS_FREE)) == 0) {
1066 return IRQ_HANDLED;
1067 }
1068 }
1069
1070 //show_phase(tmpSC);
1071
1072 switch(tmpSC->SCp.phase) {
1073 case PH_SELSTART:
1074 // *sync_neg = SYNC_NOT_YET;
1075 if ((phase & BUSMON_BSY) == 0) {
1076 //nsp_dbg(NSP_DEBUG_INTR, "selection count=%d", data->SelectionTimeOut);
1077 if (data->SelectionTimeOut >= NSP_SELTIMEOUT) {
1078 nsp_dbg(NSP_DEBUG_INTR, "selection time out");
1079 data->SelectionTimeOut = 0;
1080 nsp_index_write(base, SCSIBUSCTRL, 0);
1081
1082 tmpSC->result = DID_TIME_OUT << 16;
1083 nsp_scsi_done(tmpSC);
1084
1085 return IRQ_HANDLED;
1086 }
1087 data->SelectionTimeOut += 1;
1088 nsp_start_timer(tmpSC, 1000/51);
1089 return IRQ_HANDLED;
1090 }
1091
1092 /* attention assert */
1093 //nsp_dbg(NSP_DEBUG_INTR, "attention assert");
1094 data->SelectionTimeOut = 0;
1095 tmpSC->SCp.phase = PH_SELECTED;
1096 nsp_index_write(base, SCSIBUSCTRL, SCSI_ATN);
1097 udelay(1);
1098 nsp_index_write(base, SCSIBUSCTRL, SCSI_ATN | AUTODIRECTION | ACKENB);
1099 return IRQ_HANDLED;
1100
1101 case PH_RESELECT:
1102 //nsp_dbg(NSP_DEBUG_INTR, "phase reselect");
1103 // *sync_neg = SYNC_NOT_YET;
1104 if ((phase & BUSMON_PHASE_MASK) != BUSPHASE_MESSAGE_IN) {
1105
1106 tmpSC->result = DID_ABORT << 16;
1107 nsp_scsi_done(tmpSC);
1108 return IRQ_HANDLED;
1109 }
1110 fallthrough;
1111 default:
1112 if ((irq_status & (IRQSTATUS_SCSI | IRQSTATUS_FIFO)) == 0) {
1113 return IRQ_HANDLED;
1114 }
1115 break;
1116 }
1117
1118 /*
1119 * SCSI sequencer
1120 */
1121 //nsp_dbg(NSP_DEBUG_INTR, "start scsi seq");
1122
1123 /* normal disconnect */
1124 if (((tmpSC->SCp.phase == PH_MSG_IN) || (tmpSC->SCp.phase == PH_MSG_OUT)) &&
1125 (irq_phase & LATCHED_BUS_FREE) != 0 ) {
1126 nsp_dbg(NSP_DEBUG_INTR, "normal disconnect irq_status=0x%x, phase=0x%x, irq_phase=0x%x", irq_status, phase, irq_phase);
1127
1128 //*sync_neg = SYNC_NOT_YET;
1129
1130 /* all command complete and return status */
1131 if (tmpSC->SCp.Message == COMMAND_COMPLETE) {
1132 tmpSC->result = (DID_OK << 16) |
1133 ((tmpSC->SCp.Message & 0xff) << 8) |
1134 ((tmpSC->SCp.Status & 0xff) << 0);
1135 nsp_dbg(NSP_DEBUG_INTR, "command complete result=0x%x", tmpSC->result);
1136 nsp_scsi_done(tmpSC);
1137
1138 return IRQ_HANDLED;
1139 }
1140
1141 return IRQ_HANDLED;
1142 }
1143
1144
1145 /* check unexpected bus free state */
1146 if (phase == 0) {
1147 nsp_msg(KERN_DEBUG, "unexpected bus free. irq_status=0x%x, phase=0x%x, irq_phase=0x%x", irq_status, phase, irq_phase);
1148
1149 *sync_neg = SYNC_NG;
1150 tmpSC->result = DID_ERROR << 16;
1151 nsp_scsi_done(tmpSC);
1152 return IRQ_HANDLED;
1153 }
1154
1155 switch (phase & BUSMON_PHASE_MASK) {
1156 case BUSPHASE_COMMAND:
1157 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_COMMAND");
1158 if ((phase & BUSMON_REQ) == 0) {
1159 nsp_dbg(NSP_DEBUG_INTR, "REQ == 0");
1160 return IRQ_HANDLED;
1161 }
1162
1163 tmpSC->SCp.phase = PH_COMMAND;
1164
1165 nsp_nexus(tmpSC);
1166
1167 /* write scsi command */
1168 nsp_dbg(NSP_DEBUG_INTR, "cmd_len=%d", tmpSC->cmd_len);
1169 nsp_index_write(base, COMMANDCTRL, CLEAR_COMMAND_POINTER);
1170 for (i = 0; i < tmpSC->cmd_len; i++) {
1171 nsp_index_write(base, COMMANDDATA, tmpSC->cmnd[i]);
1172 }
1173 nsp_index_write(base, COMMANDCTRL, CLEAR_COMMAND_POINTER | AUTO_COMMAND_GO);
1174 break;
1175
1176 case BUSPHASE_DATA_OUT:
1177 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_DATA_OUT");
1178
1179 tmpSC->SCp.phase = PH_DATA;
1180 tmpSC->SCp.have_data_in = IO_OUT;
1181
1182 nsp_pio_write(tmpSC);
1183
1184 break;
1185
1186 case BUSPHASE_DATA_IN:
1187 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_DATA_IN");
1188
1189 tmpSC->SCp.phase = PH_DATA;
1190 tmpSC->SCp.have_data_in = IO_IN;
1191
1192 nsp_pio_read(tmpSC);
1193
1194 break;
1195
1196 case BUSPHASE_STATUS:
1197 nsp_dataphase_bypass(tmpSC);
1198 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_STATUS");
1199
1200 tmpSC->SCp.phase = PH_STATUS;
1201
1202 tmpSC->SCp.Status = nsp_index_read(base, SCSIDATAWITHACK);
1203 nsp_dbg(NSP_DEBUG_INTR, "message=0x%x status=0x%x", tmpSC->SCp.Message, tmpSC->SCp.Status);
1204
1205 break;
1206
1207 case BUSPHASE_MESSAGE_OUT:
1208 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_MESSAGE_OUT");
1209 if ((phase & BUSMON_REQ) == 0) {
1210 goto timer_out;
1211 }
1212
1213 tmpSC->SCp.phase = PH_MSG_OUT;
1214
1215 //*sync_neg = SYNC_NOT_YET;
1216
1217 data->MsgLen = i = 0;
1218 data->MsgBuffer[i] = IDENTIFY(TRUE, lun); i++;
1219
1220 if (*sync_neg == SYNC_NOT_YET) {
1221 data->Sync[target].SyncPeriod = 0;
1222 data->Sync[target].SyncOffset = 0;
1223
1224 /**/
1225 data->MsgBuffer[i] = EXTENDED_MESSAGE; i++;
1226 data->MsgBuffer[i] = 3; i++;
1227 data->MsgBuffer[i] = EXTENDED_SDTR; i++;
1228 data->MsgBuffer[i] = 0x0c; i++;
1229 data->MsgBuffer[i] = 15; i++;
1230 /**/
1231 }
1232 data->MsgLen = i;
1233
1234 nsp_analyze_sdtr(tmpSC);
1235 show_message(data);
1236 nsp_message_out(tmpSC);
1237 break;
1238
1239 case BUSPHASE_MESSAGE_IN:
1240 nsp_dataphase_bypass(tmpSC);
1241 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_MESSAGE_IN");
1242 if ((phase & BUSMON_REQ) == 0) {
1243 goto timer_out;
1244 }
1245
1246 tmpSC->SCp.phase = PH_MSG_IN;
1247 nsp_message_in(tmpSC);
1248
1249 /**/
1250 if (*sync_neg == SYNC_NOT_YET) {
1251 //nsp_dbg(NSP_DEBUG_INTR, "sync target=%d,lun=%d",target,lun);
1252
1253 if (data->MsgLen >= 5 &&
1254 data->MsgBuffer[0] == EXTENDED_MESSAGE &&
1255 data->MsgBuffer[1] == 3 &&
1256 data->MsgBuffer[2] == EXTENDED_SDTR ) {
1257 data->Sync[target].SyncPeriod = data->MsgBuffer[3];
1258 data->Sync[target].SyncOffset = data->MsgBuffer[4];
1259 //nsp_dbg(NSP_DEBUG_INTR, "sync ok, %d %d", data->MsgBuffer[3], data->MsgBuffer[4]);
1260 *sync_neg = SYNC_OK;
1261 } else {
1262 data->Sync[target].SyncPeriod = 0;
1263 data->Sync[target].SyncOffset = 0;
1264 *sync_neg = SYNC_NG;
1265 }
1266 nsp_analyze_sdtr(tmpSC);
1267 }
1268 /**/
1269
1270 /* search last messeage byte */
1271 tmp = -1;
1272 for (i = 0; i < data->MsgLen; i++) {
1273 tmp = data->MsgBuffer[i];
1274 if (data->MsgBuffer[i] == EXTENDED_MESSAGE) {
1275 i += (1 + data->MsgBuffer[i+1]);
1276 }
1277 }
1278 tmpSC->SCp.Message = tmp;
1279
1280 nsp_dbg(NSP_DEBUG_INTR, "message=0x%x len=%d", tmpSC->SCp.Message, data->MsgLen);
1281 show_message(data);
1282
1283 break;
1284
1285 case BUSPHASE_SELECT:
1286 default:
1287 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE other");
1288
1289 break;
1290 }
1291
1292 //nsp_dbg(NSP_DEBUG_INTR, "out");
1293 return IRQ_HANDLED;
1294
1295 timer_out:
1296 nsp_start_timer(tmpSC, 1000/102);
1297 return IRQ_HANDLED;
1298 }
1299
1300 #ifdef NSP_DEBUG
1301 #include "nsp_debug.c"
1302 #endif /* NSP_DEBUG */
1303
1304 /*----------------------------------------------------------------*/
1305 /* look for ninja3 card and init if found */
1306 /*----------------------------------------------------------------*/
nsp_detect(struct scsi_host_template * sht)1307 static struct Scsi_Host *nsp_detect(struct scsi_host_template *sht)
1308 {
1309 struct Scsi_Host *host; /* registered host structure */
1310 nsp_hw_data *data_b = &nsp_data_base, *data;
1311
1312 nsp_dbg(NSP_DEBUG_INIT, "this_id=%d", sht->this_id);
1313 host = scsi_host_alloc(&nsp_driver_template, sizeof(nsp_hw_data));
1314 if (host == NULL) {
1315 nsp_dbg(NSP_DEBUG_INIT, "host failed");
1316 return NULL;
1317 }
1318
1319 memcpy(host->hostdata, data_b, sizeof(nsp_hw_data));
1320 data = (nsp_hw_data *)host->hostdata;
1321 data->ScsiInfo->host = host;
1322 #ifdef NSP_DEBUG
1323 data->CmdId = 0;
1324 #endif
1325
1326 nsp_dbg(NSP_DEBUG_INIT, "irq=%d,%d", data_b->IrqNumber, ((nsp_hw_data *)host->hostdata)->IrqNumber);
1327
1328 host->unique_id = data->BaseAddress;
1329 host->io_port = data->BaseAddress;
1330 host->n_io_port = data->NumAddress;
1331 host->irq = data->IrqNumber;
1332 host->base = data->MmioAddress;
1333
1334 spin_lock_init(&(data->Lock));
1335
1336 snprintf(data->nspinfo,
1337 sizeof(data->nspinfo),
1338 "NinjaSCSI-3/32Bi Driver $Revision: 1.23 $ IO:0x%04lx-0x%04lx MMIO(virt addr):0x%04lx IRQ:%02d",
1339 host->io_port, host->io_port + host->n_io_port - 1,
1340 host->base,
1341 host->irq);
1342 sht->name = data->nspinfo;
1343
1344 nsp_dbg(NSP_DEBUG_INIT, "end");
1345
1346
1347 return host; /* detect done. */
1348 }
1349
1350 /*----------------------------------------------------------------*/
1351 /* return info string */
1352 /*----------------------------------------------------------------*/
nsp_info(struct Scsi_Host * shpnt)1353 static const char *nsp_info(struct Scsi_Host *shpnt)
1354 {
1355 nsp_hw_data *data = (nsp_hw_data *)shpnt->hostdata;
1356
1357 return data->nspinfo;
1358 }
1359
nsp_show_info(struct seq_file * m,struct Scsi_Host * host)1360 static int nsp_show_info(struct seq_file *m, struct Scsi_Host *host)
1361 {
1362 int id;
1363 int speed;
1364 unsigned long flags;
1365 nsp_hw_data *data;
1366 int hostno;
1367
1368 hostno = host->host_no;
1369 data = (nsp_hw_data *)host->hostdata;
1370
1371 seq_puts(m, "NinjaSCSI status\n\n"
1372 "Driver version: $Revision: 1.23 $\n");
1373 seq_printf(m, "SCSI host No.: %d\n", hostno);
1374 seq_printf(m, "IRQ: %d\n", host->irq);
1375 seq_printf(m, "IO: 0x%lx-0x%lx\n", host->io_port, host->io_port + host->n_io_port - 1);
1376 seq_printf(m, "MMIO(virtual address): 0x%lx-0x%lx\n", host->base, host->base + data->MmioLength - 1);
1377 seq_printf(m, "sg_tablesize: %d\n", host->sg_tablesize);
1378
1379 seq_puts(m, "burst transfer mode: ");
1380 switch (nsp_burst_mode) {
1381 case BURST_IO8:
1382 seq_puts(m, "io8");
1383 break;
1384 case BURST_IO32:
1385 seq_puts(m, "io32");
1386 break;
1387 case BURST_MEM32:
1388 seq_puts(m, "mem32");
1389 break;
1390 default:
1391 seq_puts(m, "???");
1392 break;
1393 }
1394 seq_putc(m, '\n');
1395
1396
1397 spin_lock_irqsave(&(data->Lock), flags);
1398 seq_printf(m, "CurrentSC: 0x%p\n\n", data->CurrentSC);
1399 spin_unlock_irqrestore(&(data->Lock), flags);
1400
1401 seq_puts(m, "SDTR status\n");
1402 for(id = 0; id < ARRAY_SIZE(data->Sync); id++) {
1403
1404 seq_printf(m, "id %d: ", id);
1405
1406 if (id == host->this_id) {
1407 seq_puts(m, "----- NinjaSCSI-3 host adapter\n");
1408 continue;
1409 }
1410
1411 switch(data->Sync[id].SyncNegotiation) {
1412 case SYNC_OK:
1413 seq_puts(m, " sync");
1414 break;
1415 case SYNC_NG:
1416 seq_puts(m, "async");
1417 break;
1418 case SYNC_NOT_YET:
1419 seq_puts(m, " none");
1420 break;
1421 default:
1422 seq_puts(m, "?????");
1423 break;
1424 }
1425
1426 if (data->Sync[id].SyncPeriod != 0) {
1427 speed = 1000000 / (data->Sync[id].SyncPeriod * 4);
1428
1429 seq_printf(m, " transfer %d.%dMB/s, offset %d",
1430 speed / 1000,
1431 speed % 1000,
1432 data->Sync[id].SyncOffset
1433 );
1434 }
1435 seq_putc(m, '\n');
1436 }
1437 return 0;
1438 }
1439
1440 /*---------------------------------------------------------------*/
1441 /* error handler */
1442 /*---------------------------------------------------------------*/
1443
1444 /*
1445 static int nsp_eh_abort(struct scsi_cmnd *SCpnt)
1446 {
1447 nsp_dbg(NSP_DEBUG_BUSRESET, "SCpnt=0x%p", SCpnt);
1448
1449 return nsp_eh_bus_reset(SCpnt);
1450 }*/
1451
nsp_bus_reset(nsp_hw_data * data)1452 static int nsp_bus_reset(nsp_hw_data *data)
1453 {
1454 unsigned int base = data->BaseAddress;
1455 int i;
1456
1457 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLMASK);
1458
1459 nsp_index_write(base, SCSIBUSCTRL, SCSI_RST);
1460 mdelay(100); /* 100ms */
1461 nsp_index_write(base, SCSIBUSCTRL, 0);
1462 for(i = 0; i < 5; i++) {
1463 nsp_index_read(base, IRQPHASESENCE); /* dummy read */
1464 }
1465
1466 nsphw_init_sync(data);
1467
1468 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLCLEAR);
1469
1470 return SUCCESS;
1471 }
1472
nsp_eh_bus_reset(struct scsi_cmnd * SCpnt)1473 static int nsp_eh_bus_reset(struct scsi_cmnd *SCpnt)
1474 {
1475 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
1476
1477 nsp_dbg(NSP_DEBUG_BUSRESET, "SCpnt=0x%p", SCpnt);
1478
1479 return nsp_bus_reset(data);
1480 }
1481
nsp_eh_host_reset(struct scsi_cmnd * SCpnt)1482 static int nsp_eh_host_reset(struct scsi_cmnd *SCpnt)
1483 {
1484 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
1485
1486 nsp_dbg(NSP_DEBUG_BUSRESET, "in");
1487
1488 nsphw_init(data);
1489
1490 return SUCCESS;
1491 }
1492
1493
1494 /**********************************************************************
1495 PCMCIA functions
1496 **********************************************************************/
1497
nsp_cs_probe(struct pcmcia_device * link)1498 static int nsp_cs_probe(struct pcmcia_device *link)
1499 {
1500 scsi_info_t *info;
1501 nsp_hw_data *data = &nsp_data_base;
1502 int ret;
1503
1504 nsp_dbg(NSP_DEBUG_INIT, "in");
1505
1506 /* Create new SCSI device */
1507 info = kzalloc(sizeof(*info), GFP_KERNEL);
1508 if (info == NULL) { return -ENOMEM; }
1509 info->p_dev = link;
1510 link->priv = info;
1511 data->ScsiInfo = info;
1512
1513 nsp_dbg(NSP_DEBUG_INIT, "info=0x%p", info);
1514
1515 ret = nsp_cs_config(link);
1516
1517 nsp_dbg(NSP_DEBUG_INIT, "link=0x%p", link);
1518 return ret;
1519 } /* nsp_cs_attach */
1520
1521
nsp_cs_detach(struct pcmcia_device * link)1522 static void nsp_cs_detach(struct pcmcia_device *link)
1523 {
1524 nsp_dbg(NSP_DEBUG_INIT, "in, link=0x%p", link);
1525
1526 ((scsi_info_t *)link->priv)->stop = 1;
1527 nsp_cs_release(link);
1528
1529 kfree(link->priv);
1530 link->priv = NULL;
1531 } /* nsp_cs_detach */
1532
1533
nsp_cs_config_check(struct pcmcia_device * p_dev,void * priv_data)1534 static int nsp_cs_config_check(struct pcmcia_device *p_dev, void *priv_data)
1535 {
1536 nsp_hw_data *data = priv_data;
1537
1538 if (p_dev->config_index == 0)
1539 return -ENODEV;
1540
1541 /* This reserves IO space but doesn't actually enable it */
1542 if (pcmcia_request_io(p_dev) != 0)
1543 goto next_entry;
1544
1545 if (resource_size(p_dev->resource[2])) {
1546 p_dev->resource[2]->flags |= (WIN_DATA_WIDTH_16 |
1547 WIN_MEMORY_TYPE_CM |
1548 WIN_ENABLE);
1549 if (p_dev->resource[2]->end < 0x1000)
1550 p_dev->resource[2]->end = 0x1000;
1551 if (pcmcia_request_window(p_dev, p_dev->resource[2], 0) != 0)
1552 goto next_entry;
1553 if (pcmcia_map_mem_page(p_dev, p_dev->resource[2],
1554 p_dev->card_addr) != 0)
1555 goto next_entry;
1556
1557 data->MmioAddress = (unsigned long)
1558 ioremap(p_dev->resource[2]->start,
1559 resource_size(p_dev->resource[2]));
1560 data->MmioLength = resource_size(p_dev->resource[2]);
1561 }
1562 /* If we got this far, we're cool! */
1563 return 0;
1564
1565 next_entry:
1566 nsp_dbg(NSP_DEBUG_INIT, "next");
1567 pcmcia_disable_device(p_dev);
1568 return -ENODEV;
1569 }
1570
nsp_cs_config(struct pcmcia_device * link)1571 static int nsp_cs_config(struct pcmcia_device *link)
1572 {
1573 int ret;
1574 scsi_info_t *info = link->priv;
1575 struct Scsi_Host *host;
1576 nsp_hw_data *data = &nsp_data_base;
1577
1578 nsp_dbg(NSP_DEBUG_INIT, "in");
1579
1580 link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_CHECK_VCC |
1581 CONF_AUTO_SET_VPP | CONF_AUTO_AUDIO | CONF_AUTO_SET_IOMEM |
1582 CONF_AUTO_SET_IO;
1583
1584 ret = pcmcia_loop_config(link, nsp_cs_config_check, data);
1585 if (ret)
1586 goto cs_failed;
1587
1588 if (pcmcia_request_irq(link, nspintr))
1589 goto cs_failed;
1590
1591 ret = pcmcia_enable_device(link);
1592 if (ret)
1593 goto cs_failed;
1594
1595 if (free_ports) {
1596 if (link->resource[0]) {
1597 release_region(link->resource[0]->start,
1598 resource_size(link->resource[0]));
1599 }
1600 if (link->resource[1]) {
1601 release_region(link->resource[1]->start,
1602 resource_size(link->resource[1]));
1603 }
1604 }
1605
1606 /* Set port and IRQ */
1607 data->BaseAddress = link->resource[0]->start;
1608 data->NumAddress = resource_size(link->resource[0]);
1609 data->IrqNumber = link->irq;
1610
1611 nsp_dbg(NSP_DEBUG_INIT, "I/O[0x%x+0x%x] IRQ %d",
1612 data->BaseAddress, data->NumAddress, data->IrqNumber);
1613
1614 if(nsphw_init(data) == FALSE) {
1615 goto cs_failed;
1616 }
1617
1618 host = nsp_detect(&nsp_driver_template);
1619
1620 if (host == NULL) {
1621 nsp_dbg(NSP_DEBUG_INIT, "detect failed");
1622 goto cs_failed;
1623 }
1624
1625
1626 ret = scsi_add_host (host, NULL);
1627 if (ret)
1628 goto cs_failed;
1629
1630 scsi_scan_host(host);
1631
1632 info->host = host;
1633
1634 return 0;
1635
1636 cs_failed:
1637 nsp_dbg(NSP_DEBUG_INIT, "config fail");
1638 nsp_cs_release(link);
1639
1640 return -ENODEV;
1641 } /* nsp_cs_config */
1642
1643
nsp_cs_release(struct pcmcia_device * link)1644 static void nsp_cs_release(struct pcmcia_device *link)
1645 {
1646 scsi_info_t *info = link->priv;
1647 nsp_hw_data *data = NULL;
1648
1649 if (info->host == NULL) {
1650 nsp_msg(KERN_DEBUG, "unexpected card release call.");
1651 } else {
1652 data = (nsp_hw_data *)info->host->hostdata;
1653 }
1654
1655 nsp_dbg(NSP_DEBUG_INIT, "link=0x%p", link);
1656
1657 /* Unlink the device chain */
1658 if (info->host != NULL) {
1659 scsi_remove_host(info->host);
1660 }
1661
1662 if (resource_size(link->resource[2])) {
1663 if (data != NULL) {
1664 iounmap((void *)(data->MmioAddress));
1665 }
1666 }
1667 pcmcia_disable_device(link);
1668
1669 if (info->host != NULL) {
1670 scsi_host_put(info->host);
1671 }
1672 } /* nsp_cs_release */
1673
nsp_cs_suspend(struct pcmcia_device * link)1674 static int nsp_cs_suspend(struct pcmcia_device *link)
1675 {
1676 scsi_info_t *info = link->priv;
1677 nsp_hw_data *data;
1678
1679 nsp_dbg(NSP_DEBUG_INIT, "event: suspend");
1680
1681 if (info->host != NULL) {
1682 nsp_msg(KERN_INFO, "clear SDTR status");
1683
1684 data = (nsp_hw_data *)info->host->hostdata;
1685
1686 nsphw_init_sync(data);
1687 }
1688
1689 info->stop = 1;
1690
1691 return 0;
1692 }
1693
nsp_cs_resume(struct pcmcia_device * link)1694 static int nsp_cs_resume(struct pcmcia_device *link)
1695 {
1696 scsi_info_t *info = link->priv;
1697 nsp_hw_data *data;
1698
1699 nsp_dbg(NSP_DEBUG_INIT, "event: resume");
1700
1701 info->stop = 0;
1702
1703 if (info->host != NULL) {
1704 nsp_msg(KERN_INFO, "reset host and bus");
1705
1706 data = (nsp_hw_data *)info->host->hostdata;
1707
1708 nsphw_init (data);
1709 nsp_bus_reset(data);
1710 }
1711
1712 return 0;
1713 }
1714
1715 /*======================================================================*
1716 * module entry point
1717 *====================================================================*/
1718 static const struct pcmcia_device_id nsp_cs_ids[] = {
1719 PCMCIA_DEVICE_PROD_ID123("IO DATA", "CBSC16 ", "1", 0x547e66dc, 0x0d63a3fd, 0x51de003a),
1720 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-001", "1", 0x534c02bc, 0x52008408, 0x51de003a),
1721 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-002", "1", 0x534c02bc, 0xcb09d5b2, 0x51de003a),
1722 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-003", "1", 0x534c02bc, 0xbc0ee524, 0x51de003a),
1723 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-004", "1", 0x534c02bc, 0x226a7087, 0x51de003a),
1724 PCMCIA_DEVICE_PROD_ID123("WBT", "NinjaSCSI-3", "R1.0", 0xc7ba805f, 0xfdc7c97d, 0x6973710e),
1725 PCMCIA_DEVICE_PROD_ID123("WORKBIT", "UltraNinja-16", "1", 0x28191418, 0xb70f4b09, 0x51de003a),
1726 PCMCIA_DEVICE_NULL
1727 };
1728 MODULE_DEVICE_TABLE(pcmcia, nsp_cs_ids);
1729
1730 static struct pcmcia_driver nsp_driver = {
1731 .owner = THIS_MODULE,
1732 .name = "nsp_cs",
1733 .probe = nsp_cs_probe,
1734 .remove = nsp_cs_detach,
1735 .id_table = nsp_cs_ids,
1736 .suspend = nsp_cs_suspend,
1737 .resume = nsp_cs_resume,
1738 };
1739 module_pcmcia_driver(nsp_driver);
1740
1741 /* end */
1742