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