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