?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] W1: Change the type 'unsigned long' member of 'struct w1_bus_master' to ...
[linux-2.6/verdex.git] / drivers / scsi / pcmcia / nsp_cs.c
blob9e3ab3fd53555528471ef7d489c877c001ffab58
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 /* $Id: nsp_cs.c,v 1.23 2003/08/18 11:09:19 elca Exp $ */
29
30 #include <linux/version.h>
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/init.h>
34 #include <linux/sched.h>
35 #include <linux/slab.h>
36 #include <linux/string.h>
37 #include <linux/timer.h>
38 #include <linux/ioport.h>
39 #include <linux/delay.h>
40 #include <linux/interrupt.h>
41 #include <linux/major.h>
42 #include <linux/blkdev.h>
43 #include <linux/stat.h>
44
45 #include <asm/io.h>
46 #include <asm/irq.h>
47
48 #include <../drivers/scsi/scsi.h>
49 #include <scsi/scsi_host.h>
50
51 #include <scsi/scsi.h>
52 #include <scsi/scsi_ioctl.h>
53
54 #include <pcmcia/cs_types.h>
55 #include <pcmcia/cs.h>
56 #include <pcmcia/cistpl.h>
57 #include <pcmcia/cisreg.h>
58 #include <pcmcia/ds.h>
59
60 #include "nsp_cs.h"
61
62 MODULE_AUTHOR("YOKOTA Hiroshi <yokota@netlab.is.tsukuba.ac.jp>");
63 MODULE_DESCRIPTION("WorkBit NinjaSCSI-3 / NinjaSCSI-32Bi(16bit) PCMCIA SCSI host adapter module $Revision: 1.23 $");
64 MODULE_SUPPORTED_DEVICE("sd,sr,sg,st");
65 #ifdef MODULE_LICENSE
66 MODULE_LICENSE("GPL");
67 #endif
68
69 #include "nsp_io.h"
70
71 /*====================================================================*/
72 /* Parameters that can be set with 'insmod' */
73
74 static int nsp_burst_mode = BURST_MEM32;
75 module_param(nsp_burst_mode, int, 0);
76 MODULE_PARM_DESC(nsp_burst_mode, "Burst transfer mode (0=io8, 1=io32, 2=mem32(default))");
77
78 /* Release IO ports after configuration? */
79 static int free_ports = 0;
80 module_param(free_ports, bool, 0);
81 MODULE_PARM_DESC(free_ports, "Release IO ports after configuration? (default: 0 (=no))");
82
83 /* /usr/src/linux/drivers/scsi/hosts.h */
84 static struct scsi_host_template nsp_driver_template = {
85 .proc_name = "nsp_cs",
86 .proc_info = nsp_proc_info,
87 .name = "WorkBit NinjaSCSI-3/32Bi(16bit)",
88 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
89 .detect = nsp_detect_old,
90 .release = nsp_release_old,
91 #endif
92 .info = nsp_info,
93 .queuecommand = nsp_queuecommand,
94 /* .eh_abort_handler = nsp_eh_abort,*/
95 .eh_bus_reset_handler = nsp_eh_bus_reset,
96 .eh_host_reset_handler = nsp_eh_host_reset,
97 .can_queue = 1,
98 .this_id = NSP_INITIATOR_ID,
99 .sg_tablesize = SG_ALL,
100 .cmd_per_lun = 1,
101 .use_clustering = DISABLE_CLUSTERING,
102 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,2))
103 .use_new_eh_code = 1,
104 #endif
105 };
106
107 static nsp_hw_data nsp_data_base; /* attach <-> detect glue */
108
109
110
111 /*
112 * debug, error print
113 */
114 #ifndef NSP_DEBUG
115 # define NSP_DEBUG_MASK 0x000000
116 # define nsp_msg(type, args...) nsp_cs_message("", 0, (type), args)
117 # define nsp_dbg(mask, args...) /* */
118 #else
119 # define NSP_DEBUG_MASK 0xffffff
120 # define nsp_msg(type, args...) \
121 nsp_cs_message (__FUNCTION__, __LINE__, (type), args)
122 # define nsp_dbg(mask, args...) \
123 nsp_cs_dmessage(__FUNCTION__, __LINE__, (mask), args)
124 #endif
125
126 #define NSP_DEBUG_QUEUECOMMAND BIT(0)
127 #define NSP_DEBUG_REGISTER BIT(1)
128 #define NSP_DEBUG_AUTOSCSI BIT(2)
129 #define NSP_DEBUG_INTR BIT(3)
130 #define NSP_DEBUG_SGLIST BIT(4)
131 #define NSP_DEBUG_BUSFREE BIT(5)
132 #define NSP_DEBUG_CDB_CONTENTS BIT(6)
133 #define NSP_DEBUG_RESELECTION BIT(7)
134 #define NSP_DEBUG_MSGINOCCUR BIT(8)
135 #define NSP_DEBUG_EEPROM BIT(9)
136 #define NSP_DEBUG_MSGOUTOCCUR BIT(10)
137 #define NSP_DEBUG_BUSRESET BIT(11)
138 #define NSP_DEBUG_RESTART BIT(12)
139 #define NSP_DEBUG_SYNC BIT(13)
140 #define NSP_DEBUG_WAIT BIT(14)
141 #define NSP_DEBUG_TARGETFLAG BIT(15)
142 #define NSP_DEBUG_PROC BIT(16)
143 #define NSP_DEBUG_INIT BIT(17)
144 #define NSP_DEBUG_DATA_IO BIT(18)
145 #define NSP_SPECIAL_PRINT_REGISTER BIT(20)
146
147 #define NSP_DEBUG_BUF_LEN 150
148
149 static void nsp_cs_message(const char *func, int line, char *type, char *fmt, ...)
150 {
151 va_list args;
152 char buf[NSP_DEBUG_BUF_LEN];
153
154 va_start(args, fmt);
155 vsnprintf(buf, sizeof(buf), fmt, args);
156 va_end(args);
157
158 #ifndef NSP_DEBUG
159 printk("%snsp_cs: %s\n", type, buf);
160 #else
161 printk("%snsp_cs: %s (%d): %s\n", type, func, line, buf);
162 #endif
163 }
164
165 #ifdef NSP_DEBUG
166 static void nsp_cs_dmessage(const char *func, int line, int mask, char *fmt, ...)
167 {
168 va_list args;
169 char buf[NSP_DEBUG_BUF_LEN];
170
171 va_start(args, fmt);
172 vsnprintf(buf, sizeof(buf), fmt, args);
173 va_end(args);
174
175 if (mask & NSP_DEBUG_MASK) {
176 printk("nsp_cs-debug: 0x%x %s (%d): %s\n", mask, func, line, buf);
177 }
178 }
179 #endif
180
181 /***********************************************************/
182
183 /*====================================================
184 * Clenaup parameters and call done() functions.
185 * You must be set SCpnt->result before call this function.
186 */
187 static void nsp_scsi_done(Scsi_Cmnd *SCpnt)
188 {
189 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
190
191 data->CurrentSC = NULL;
192
193 SCpnt->scsi_done(SCpnt);
194 }
195
196 static int nsp_queuecommand(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
197 {
198 #ifdef NSP_DEBUG
199 /*unsigned int host_id = SCpnt->device->host->this_id;*/
200 /*unsigned int base = SCpnt->device->host->io_port;*/
201 unsigned char target = scmd_id(SCpnt);
202 #endif
203 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
204
205 nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "SCpnt=0x%p target=%d lun=%d buff=0x%p bufflen=%d use_sg=%d",
206 SCpnt, target, SCpnt->device->lun, SCpnt->request_buffer, SCpnt->request_bufflen, SCpnt->use_sg);
207 //nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "before CurrentSC=0x%p", data->CurrentSC);
208
209 SCpnt->scsi_done = done;
210
211 if (data->CurrentSC != NULL) {
212 nsp_msg(KERN_DEBUG, "CurrentSC!=NULL this can't be happen");
213 SCpnt->result = DID_BAD_TARGET << 16;
214 nsp_scsi_done(SCpnt);
215 return 0;
216 }
217
218 #if 0
219 /* XXX: pcmcia-cs generates SCSI command with "scsi_info" utility.
220 This makes kernel crash when suspending... */
221 if (data->ScsiInfo->stop != 0) {
222 nsp_msg(KERN_INFO, "suspending device. reject command.");
223 SCpnt->result = DID_BAD_TARGET << 16;
224 nsp_scsi_done(SCpnt);
225 return SCSI_MLQUEUE_HOST_BUSY;
226 }
227 #endif
228
229 show_command(SCpnt);
230
231 data->CurrentSC = SCpnt;
232
233 SCpnt->SCp.Status = CHECK_CONDITION;
234 SCpnt->SCp.Message = 0;
235 SCpnt->SCp.have_data_in = IO_UNKNOWN;
236 SCpnt->SCp.sent_command = 0;
237 SCpnt->SCp.phase = PH_UNDETERMINED;
238 SCpnt->resid = SCpnt->request_bufflen;
239
240 /* setup scratch area
241 SCp.ptr : buffer pointer
242 SCp.this_residual : buffer length
243 SCp.buffer : next buffer
244 SCp.buffers_residual : left buffers in list
245 SCp.phase : current state of the command */
246 if (SCpnt->use_sg) {
247 SCpnt->SCp.buffer = (struct scatterlist *) SCpnt->request_buffer;
248 SCpnt->SCp.ptr = BUFFER_ADDR;
249 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
250 SCpnt->SCp.buffers_residual = SCpnt->use_sg - 1;
251 } else {
252 SCpnt->SCp.ptr = (char *) SCpnt->request_buffer;
253 SCpnt->SCp.this_residual = SCpnt->request_bufflen;
254 SCpnt->SCp.buffer = NULL;
255 SCpnt->SCp.buffers_residual = 0;
256 }
257
258 if (nsphw_start_selection(SCpnt) == FALSE) {
259 nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "selection fail");
260 SCpnt->result = DID_BUS_BUSY << 16;
261 nsp_scsi_done(SCpnt);
262 return 0;
263 }
264
265
266 //nsp_dbg(NSP_DEBUG_QUEUECOMMAND, "out");
267 #ifdef NSP_DEBUG
268 data->CmdId++;
269 #endif
270 return 0;
271 }
272
273 /*
274 * setup PIO FIFO transfer mode and enable/disable to data out
275 */
276 static void nsp_setup_fifo(nsp_hw_data *data, int enabled)
277 {
278 unsigned int base = data->BaseAddress;
279 unsigned char transfer_mode_reg;
280
281 //nsp_dbg(NSP_DEBUG_DATA_IO, "enabled=%d", enabled);
282
283 if (enabled != FALSE) {
284 transfer_mode_reg = TRANSFER_GO | BRAIND;
285 } else {
286 transfer_mode_reg = 0;
287 }
288
289 transfer_mode_reg |= data->TransferMode;
290
291 nsp_index_write(base, TRANSFERMODE, transfer_mode_reg);
292 }
293
294 static void nsphw_init_sync(nsp_hw_data *data)
295 {
296 sync_data tmp_sync = { .SyncNegotiation = SYNC_NOT_YET,
297 .SyncPeriod = 0,
298 .SyncOffset = 0
299 };
300 int i;
301
302 /* setup sync data */
303 for ( i = 0; i < ARRAY_SIZE(data->Sync); i++ ) {
304 data->Sync[i] = tmp_sync;
305 }
306 }
307
308 /*
309 * Initialize Ninja hardware
310 */
311 static int nsphw_init(nsp_hw_data *data)
312 {
313 unsigned int base = data->BaseAddress;
314
315 nsp_dbg(NSP_DEBUG_INIT, "in base=0x%x", base);
316
317 data->ScsiClockDiv = CLOCK_40M | FAST_20;
318 data->CurrentSC = NULL;
319 data->FifoCount = 0;
320 data->TransferMode = MODE_IO8;
321
322 nsphw_init_sync(data);
323
324 /* block all interrupts */
325 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLMASK);
326
327 /* setup SCSI interface */
328 nsp_write(base, IFSELECT, IF_IFSEL);
329
330 nsp_index_write(base, SCSIIRQMODE, 0);
331
332 nsp_index_write(base, TRANSFERMODE, MODE_IO8);
333 nsp_index_write(base, CLOCKDIV, data->ScsiClockDiv);
334
335 nsp_index_write(base, PARITYCTRL, 0);
336 nsp_index_write(base, POINTERCLR, POINTER_CLEAR |
337 ACK_COUNTER_CLEAR |
338 REQ_COUNTER_CLEAR |
339 HOST_COUNTER_CLEAR);
340
341 /* setup fifo asic */
342 nsp_write(base, IFSELECT, IF_REGSEL);
343 nsp_index_write(base, TERMPWRCTRL, 0);
344 if ((nsp_index_read(base, OTHERCONTROL) & TPWR_SENSE) == 0) {
345 nsp_msg(KERN_INFO, "terminator power on");
346 nsp_index_write(base, TERMPWRCTRL, POWER_ON);
347 }
348
349 nsp_index_write(base, TIMERCOUNT, 0);
350 nsp_index_write(base, TIMERCOUNT, 0); /* requires 2 times!! */
351
352 nsp_index_write(base, SYNCREG, 0);
353 nsp_index_write(base, ACKWIDTH, 0);
354
355 /* enable interrupts and ack them */
356 nsp_index_write(base, SCSIIRQMODE, SCSI_PHASE_CHANGE_EI |
357 RESELECT_EI |
358 SCSI_RESET_IRQ_EI );
359 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLCLEAR);
360
361 nsp_setup_fifo(data, FALSE);
362
363 return TRUE;
364 }
365
366 /*
367 * Start selection phase
368 */
369 static int nsphw_start_selection(Scsi_Cmnd *SCpnt)
370 {
371 unsigned int host_id = SCpnt->device->host->this_id;
372 unsigned int base = SCpnt->device->host->io_port;
373 unsigned char target = scmd_id(SCpnt);
374 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
375 int time_out;
376 unsigned char phase, arbit;
377
378 //nsp_dbg(NSP_DEBUG_RESELECTION, "in");
379
380 phase = nsp_index_read(base, SCSIBUSMON);
381 if(phase != BUSMON_BUS_FREE) {
382 //nsp_dbg(NSP_DEBUG_RESELECTION, "bus busy");
383 return FALSE;
384 }
385
386 /* start arbitration */
387 //nsp_dbg(NSP_DEBUG_RESELECTION, "start arbit");
388 SCpnt->SCp.phase = PH_ARBSTART;
389 nsp_index_write(base, SETARBIT, ARBIT_GO);
390
391 time_out = 1000;
392 do {
393 /* XXX: what a stupid chip! */
394 arbit = nsp_index_read(base, ARBITSTATUS);
395 //nsp_dbg(NSP_DEBUG_RESELECTION, "arbit=%d, wait_count=%d", arbit, wait_count);
396 udelay(1); /* hold 1.2us */
397 } while((arbit & (ARBIT_WIN | ARBIT_FAIL)) == 0 &&
398 (time_out-- != 0));
399
400 if (!(arbit & ARBIT_WIN)) {
401 //nsp_dbg(NSP_DEBUG_RESELECTION, "arbit fail");
402 nsp_index_write(base, SETARBIT, ARBIT_FLAG_CLEAR);
403 return FALSE;
404 }
405
406 /* assert select line */
407 //nsp_dbg(NSP_DEBUG_RESELECTION, "assert SEL line");
408 SCpnt->SCp.phase = PH_SELSTART;
409 udelay(3); /* wait 2.4us */
410 nsp_index_write(base, SCSIDATALATCH, BIT(host_id) | BIT(target));
411 nsp_index_write(base, SCSIBUSCTRL, SCSI_SEL | SCSI_BSY | SCSI_ATN);
412 udelay(2); /* wait >1.2us */
413 nsp_index_write(base, SCSIBUSCTRL, SCSI_SEL | SCSI_BSY | SCSI_DATAOUT_ENB | SCSI_ATN);
414 nsp_index_write(base, SETARBIT, ARBIT_FLAG_CLEAR);
415 /*udelay(1);*/ /* wait >90ns */
416 nsp_index_write(base, SCSIBUSCTRL, SCSI_SEL | SCSI_DATAOUT_ENB | SCSI_ATN);
417
418 /* check selection timeout */
419 nsp_start_timer(SCpnt, 1000/51);
420 data->SelectionTimeOut = 1;
421
422 return TRUE;
423 }
424
425 struct nsp_sync_table {
426 unsigned int min_period;
427 unsigned int max_period;
428 unsigned int chip_period;
429 unsigned int ack_width;
430 };
431
432 static struct nsp_sync_table nsp_sync_table_40M[] = {
433 {0x0c, 0x0c, 0x1, 0}, /* 20MB 50ns*/
434 {0x19, 0x19, 0x3, 1}, /* 10MB 100ns*/
435 {0x1a, 0x25, 0x5, 2}, /* 7.5MB 150ns*/
436 {0x26, 0x32, 0x7, 3}, /* 5MB 200ns*/
437 { 0, 0, 0, 0},
438 };
439
440 static struct nsp_sync_table nsp_sync_table_20M[] = {
441 {0x19, 0x19, 0x1, 0}, /* 10MB 100ns*/
442 {0x1a, 0x25, 0x2, 0}, /* 7.5MB 150ns*/
443 {0x26, 0x32, 0x3, 1}, /* 5MB 200ns*/
444 { 0, 0, 0, 0},
445 };
446
447 /*
448 * setup synchronous data transfer mode
449 */
450 static int nsp_analyze_sdtr(Scsi_Cmnd *SCpnt)
451 {
452 unsigned char target = scmd_id(SCpnt);
453 // unsigned char lun = SCpnt->device->lun;
454 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
455 sync_data *sync = &(data->Sync[target]);
456 struct nsp_sync_table *sync_table;
457 unsigned int period, offset;
458 int i;
459
460
461 nsp_dbg(NSP_DEBUG_SYNC, "in");
462
463 period = sync->SyncPeriod;
464 offset = sync->SyncOffset;
465
466 nsp_dbg(NSP_DEBUG_SYNC, "period=0x%x, offset=0x%x", period, offset);
467
468 if ((data->ScsiClockDiv & (BIT(0)|BIT(1))) == CLOCK_20M) {
469 sync_table = nsp_sync_table_20M;
470 } else {
471 sync_table = nsp_sync_table_40M;
472 }
473
474 for ( i = 0; sync_table->max_period != 0; i++, sync_table++) {
475 if ( period >= sync_table->min_period &&
476 period <= sync_table->max_period ) {
477 break;
478 }
479 }
480
481 if (period != 0 && sync_table->max_period == 0) {
482 /*
483 * No proper period/offset found
484 */
485 nsp_dbg(NSP_DEBUG_SYNC, "no proper period/offset");
486
487 sync->SyncPeriod = 0;
488 sync->SyncOffset = 0;
489 sync->SyncRegister = 0;
490 sync->AckWidth = 0;
491
492 return FALSE;
493 }
494
495 sync->SyncRegister = (sync_table->chip_period << SYNCREG_PERIOD_SHIFT) |
496 (offset & SYNCREG_OFFSET_MASK);
497 sync->AckWidth = sync_table->ack_width;
498
499 nsp_dbg(NSP_DEBUG_SYNC, "sync_reg=0x%x, ack_width=0x%x", sync->SyncRegister, sync->AckWidth);
500
501 return TRUE;
502 }
503
504
505 /*
506 * start ninja hardware timer
507 */
508 static void nsp_start_timer(Scsi_Cmnd *SCpnt, int time)
509 {
510 unsigned int base = SCpnt->device->host->io_port;
511 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
512
513 //nsp_dbg(NSP_DEBUG_INTR, "in SCpnt=0x%p, time=%d", SCpnt, time);
514 data->TimerCount = time;
515 nsp_index_write(base, TIMERCOUNT, time);
516 }
517
518 /*
519 * wait for bus phase change
520 */
521 static int nsp_negate_signal(Scsi_Cmnd *SCpnt, unsigned char mask, char *str)
522 {
523 unsigned int base = SCpnt->device->host->io_port;
524 unsigned char reg;
525 int time_out;
526
527 //nsp_dbg(NSP_DEBUG_INTR, "in");
528
529 time_out = 100;
530
531 do {
532 reg = nsp_index_read(base, SCSIBUSMON);
533 if (reg == 0xff) {
534 break;
535 }
536 } while ((time_out-- != 0) && (reg & mask) != 0);
537
538 if (time_out == 0) {
539 nsp_msg(KERN_DEBUG, " %s signal off timeut", str);
540 }
541
542 return 0;
543 }
544
545 /*
546 * expect Ninja Irq
547 */
548 static int nsp_expect_signal(Scsi_Cmnd *SCpnt,
549 unsigned char current_phase,
550 unsigned char mask)
551 {
552 unsigned int base = SCpnt->device->host->io_port;
553 int time_out;
554 unsigned char phase, i_src;
555
556 //nsp_dbg(NSP_DEBUG_INTR, "current_phase=0x%x, mask=0x%x", current_phase, mask);
557
558 time_out = 100;
559 do {
560 phase = nsp_index_read(base, SCSIBUSMON);
561 if (phase == 0xff) {
562 //nsp_dbg(NSP_DEBUG_INTR, "ret -1");
563 return -1;
564 }
565 i_src = nsp_read(base, IRQSTATUS);
566 if (i_src & IRQSTATUS_SCSI) {
567 //nsp_dbg(NSP_DEBUG_INTR, "ret 0 found scsi signal");
568 return 0;
569 }
570 if ((phase & mask) != 0 && (phase & BUSMON_PHASE_MASK) == current_phase) {
571 //nsp_dbg(NSP_DEBUG_INTR, "ret 1 phase=0x%x", phase);
572 return 1;
573 }
574 } while(time_out-- != 0);
575
576 //nsp_dbg(NSP_DEBUG_INTR, "timeout");
577 return -1;
578 }
579
580 /*
581 * transfer SCSI message
582 */
583 static int nsp_xfer(Scsi_Cmnd *SCpnt, int phase)
584 {
585 unsigned int base = SCpnt->device->host->io_port;
586 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
587 char *buf = data->MsgBuffer;
588 int len = min(MSGBUF_SIZE, data->MsgLen);
589 int ptr;
590 int ret;
591
592 //nsp_dbg(NSP_DEBUG_DATA_IO, "in");
593 for (ptr = 0; len > 0; len--, ptr++) {
594
595 ret = nsp_expect_signal(SCpnt, phase, BUSMON_REQ);
596 if (ret <= 0) {
597 nsp_dbg(NSP_DEBUG_DATA_IO, "xfer quit");
598 return 0;
599 }
600
601 /* if last byte, negate ATN */
602 if (len == 1 && SCpnt->SCp.phase == PH_MSG_OUT) {
603 nsp_index_write(base, SCSIBUSCTRL, AUTODIRECTION | ACKENB);
604 }
605
606 /* read & write message */
607 if (phase & BUSMON_IO) {
608 nsp_dbg(NSP_DEBUG_DATA_IO, "read msg");
609 buf[ptr] = nsp_index_read(base, SCSIDATAWITHACK);
610 } else {
611 nsp_dbg(NSP_DEBUG_DATA_IO, "write msg");
612 nsp_index_write(base, SCSIDATAWITHACK, buf[ptr]);
613 }
614 nsp_negate_signal(SCpnt, BUSMON_ACK, "xfer<ack>");
615
616 }
617 return len;
618 }
619
620 /*
621 * get extra SCSI data from fifo
622 */
623 static int nsp_dataphase_bypass(Scsi_Cmnd *SCpnt)
624 {
625 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
626 unsigned int count;
627
628 //nsp_dbg(NSP_DEBUG_DATA_IO, "in");
629
630 if (SCpnt->SCp.have_data_in != IO_IN) {
631 return 0;
632 }
633
634 count = nsp_fifo_count(SCpnt);
635 if (data->FifoCount == count) {
636 //nsp_dbg(NSP_DEBUG_DATA_IO, "not use bypass quirk");
637 return 0;
638 }
639
640 /*
641 * XXX: NSP_QUIRK
642 * data phase skip only occures in case of SCSI_LOW_READ
643 */
644 nsp_dbg(NSP_DEBUG_DATA_IO, "use bypass quirk");
645 SCpnt->SCp.phase = PH_DATA;
646 nsp_pio_read(SCpnt);
647 nsp_setup_fifo(data, FALSE);
648
649 return 0;
650 }
651
652 /*
653 * accept reselection
654 */
655 static int nsp_reselected(Scsi_Cmnd *SCpnt)
656 {
657 unsigned int base = SCpnt->device->host->io_port;
658 unsigned int host_id = SCpnt->device->host->this_id;
659 //nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
660 unsigned char bus_reg;
661 unsigned char id_reg, tmp;
662 int target;
663
664 nsp_dbg(NSP_DEBUG_RESELECTION, "in");
665
666 id_reg = nsp_index_read(base, RESELECTID);
667 tmp = id_reg & (~BIT(host_id));
668 target = 0;
669 while(tmp != 0) {
670 if (tmp & BIT(0)) {
671 break;
672 }
673 tmp >>= 1;
674 target++;
675 }
676
677 if (scmd_id(SCpnt) != target) {
678 nsp_msg(KERN_ERR, "XXX: reselect ID must be %d in this implementation.", target);
679 }
680
681 nsp_negate_signal(SCpnt, BUSMON_SEL, "reselect<SEL>");
682
683 nsp_nexus(SCpnt);
684 bus_reg = nsp_index_read(base, SCSIBUSCTRL) & ~(SCSI_BSY | SCSI_ATN);
685 nsp_index_write(base, SCSIBUSCTRL, bus_reg);
686 nsp_index_write(base, SCSIBUSCTRL, bus_reg | AUTODIRECTION | ACKENB);
687
688 return TRUE;
689 }
690
691 /*
692 * count how many data transferd
693 */
694 static int nsp_fifo_count(Scsi_Cmnd *SCpnt)
695 {
696 unsigned int base = SCpnt->device->host->io_port;
697 unsigned int count;
698 unsigned int l, m, h, dummy;
699
700 nsp_index_write(base, POINTERCLR, POINTER_CLEAR | ACK_COUNTER);
701
702 l = nsp_index_read(base, TRANSFERCOUNT);
703 m = nsp_index_read(base, TRANSFERCOUNT);
704 h = nsp_index_read(base, TRANSFERCOUNT);
705 dummy = nsp_index_read(base, TRANSFERCOUNT); /* required this! */
706
707 count = (h << 16) | (m << 8) | (l << 0);
708
709 //nsp_dbg(NSP_DEBUG_DATA_IO, "count=0x%x", count);
710
711 return count;
712 }
713
714 /* fifo size */
715 #define RFIFO_CRIT 64
716 #define WFIFO_CRIT 64
717
718 /*
719 * read data in DATA IN phase
720 */
721 static void nsp_pio_read(Scsi_Cmnd *SCpnt)
722 {
723 unsigned int base = SCpnt->device->host->io_port;
724 unsigned long mmio_base = SCpnt->device->host->base;
725 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
726 long time_out;
727 int ocount, res;
728 unsigned char stat, fifo_stat;
729
730 ocount = data->FifoCount;
731
732 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",
733 SCpnt, SCpnt->resid, ocount, SCpnt->SCp.ptr, SCpnt->SCp.this_residual, SCpnt->SCp.buffer, SCpnt->SCp.buffers_residual);
734
735 time_out = 1000;
736
737 while ((time_out-- != 0) &&
738 (SCpnt->SCp.this_residual > 0 || SCpnt->SCp.buffers_residual > 0 ) ) {
739
740 stat = nsp_index_read(base, SCSIBUSMON);
741 stat &= BUSMON_PHASE_MASK;
742
743
744 res = nsp_fifo_count(SCpnt) - ocount;
745 //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);
746 if (res == 0) { /* if some data avilable ? */
747 if (stat == BUSPHASE_DATA_IN) { /* phase changed? */
748 //nsp_dbg(NSP_DEBUG_DATA_IO, " wait for data this=%d", SCpnt->SCp.this_residual);
749 continue;
750 } else {
751 nsp_dbg(NSP_DEBUG_DATA_IO, "phase changed stat=0x%x", stat);
752 break;
753 }
754 }
755
756 fifo_stat = nsp_read(base, FIFOSTATUS);
757 if ((fifo_stat & FIFOSTATUS_FULL_EMPTY) == 0 &&
758 stat == BUSPHASE_DATA_IN) {
759 continue;
760 }
761
762 res = min(res, SCpnt->SCp.this_residual);
763
764 switch (data->TransferMode) {
765 case MODE_IO32:
766 res &= ~(BIT(1)|BIT(0)); /* align 4 */
767 nsp_fifo32_read(base, SCpnt->SCp.ptr, res >> 2);
768 break;
769 case MODE_IO8:
770 nsp_fifo8_read (base, SCpnt->SCp.ptr, res );
771 break;
772
773 case MODE_MEM32:
774 res &= ~(BIT(1)|BIT(0)); /* align 4 */
775 nsp_mmio_fifo32_read(mmio_base, SCpnt->SCp.ptr, res >> 2);
776 break;
777
778 default:
779 nsp_dbg(NSP_DEBUG_DATA_IO, "unknown read mode");
780 return;
781 }
782
783 SCpnt->resid -= res;
784 SCpnt->SCp.ptr += res;
785 SCpnt->SCp.this_residual -= res;
786 ocount += res;
787 //nsp_dbg(NSP_DEBUG_DATA_IO, "ptr=0x%p this_residual=0x%x ocount=0x%x", SCpnt->SCp.ptr, SCpnt->SCp.this_residual, ocount);
788
789 /* go to next scatter list if available */
790 if (SCpnt->SCp.this_residual == 0 &&
791 SCpnt->SCp.buffers_residual != 0 ) {
792 //nsp_dbg(NSP_DEBUG_DATA_IO, "scatterlist next timeout=%d", time_out);
793 SCpnt->SCp.buffers_residual--;
794 SCpnt->SCp.buffer++;
795 SCpnt->SCp.ptr = BUFFER_ADDR;
796 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
797 time_out = 1000;
798
799 //nsp_dbg(NSP_DEBUG_DATA_IO, "page: 0x%p, off: 0x%x", SCpnt->SCp.buffer->page, SCpnt->SCp.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 SCpnt->resid, SCpnt->SCp.this_residual, SCpnt->SCp.buffers_residual);
808 }
809 nsp_dbg(NSP_DEBUG_DATA_IO, "read ocount=0x%x", ocount);
810 nsp_dbg(NSP_DEBUG_DATA_IO, "r cmd=%d resid=0x%x\n", data->CmdId, SCpnt->resid);
811 }
812
813 /*
814 * write data in DATA OUT phase
815 */
816 static void nsp_pio_write(Scsi_Cmnd *SCpnt)
817 {
818 unsigned int base = SCpnt->device->host->io_port;
819 unsigned long mmio_base = SCpnt->device->host->base;
820 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
821 int time_out;
822 int ocount, res;
823 unsigned char stat;
824
825 ocount = data->FifoCount;
826
827 nsp_dbg(NSP_DEBUG_DATA_IO, "in fifocount=%d ptr=0x%p this_residual=%d buffers=0x%p nbuf=%d resid=0x%x",
828 data->FifoCount, SCpnt->SCp.ptr, SCpnt->SCp.this_residual, SCpnt->SCp.buffer, SCpnt->SCp.buffers_residual, SCpnt->resid);
829
830 time_out = 1000;
831
832 while ((time_out-- != 0) &&
833 (SCpnt->SCp.this_residual > 0 || SCpnt->SCp.buffers_residual > 0)) {
834 stat = nsp_index_read(base, SCSIBUSMON);
835 stat &= BUSMON_PHASE_MASK;
836
837 if (stat != BUSPHASE_DATA_OUT) {
838 res = ocount - nsp_fifo_count(SCpnt);
839
840 nsp_dbg(NSP_DEBUG_DATA_IO, "phase changed stat=0x%x, res=%d\n", stat, res);
841 /* Put back pointer */
842 SCpnt->resid += res;
843 SCpnt->SCp.ptr -= res;
844 SCpnt->SCp.this_residual += res;
845 ocount -= res;
846
847 break;
848 }
849
850 res = ocount - nsp_fifo_count(SCpnt);
851 if (res > 0) { /* write all data? */
852 nsp_dbg(NSP_DEBUG_DATA_IO, "wait for all data out. ocount=0x%x res=%d", ocount, res);
853 continue;
854 }
855
856 res = min(SCpnt->SCp.this_residual, WFIFO_CRIT);
857
858 //nsp_dbg(NSP_DEBUG_DATA_IO, "ptr=0x%p this=0x%x res=0x%x", SCpnt->SCp.ptr, SCpnt->SCp.this_residual, res);
859 switch (data->TransferMode) {
860 case MODE_IO32:
861 res &= ~(BIT(1)|BIT(0)); /* align 4 */
862 nsp_fifo32_write(base, SCpnt->SCp.ptr, res >> 2);
863 break;
864 case MODE_IO8:
865 nsp_fifo8_write (base, SCpnt->SCp.ptr, res );
866 break;
867
868 case MODE_MEM32:
869 res &= ~(BIT(1)|BIT(0)); /* align 4 */
870 nsp_mmio_fifo32_write(mmio_base, SCpnt->SCp.ptr, res >> 2);
871 break;
872
873 default:
874 nsp_dbg(NSP_DEBUG_DATA_IO, "unknown write mode");
875 break;
876 }
877
878 SCpnt->resid -= res;
879 SCpnt->SCp.ptr += res;
880 SCpnt->SCp.this_residual -= res;
881 ocount += res;
882
883 /* go to next scatter list if available */
884 if (SCpnt->SCp.this_residual == 0 &&
885 SCpnt->SCp.buffers_residual != 0 ) {
886 //nsp_dbg(NSP_DEBUG_DATA_IO, "scatterlist next");
887 SCpnt->SCp.buffers_residual--;
888 SCpnt->SCp.buffer++;
889 SCpnt->SCp.ptr = BUFFER_ADDR;
890 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
891 time_out = 1000;
892 }
893 }
894
895 data->FifoCount = ocount;
896
897 if (time_out == 0) {
898 nsp_msg(KERN_DEBUG, "pio write timeout resid=0x%x", SCpnt->resid);
899 }
900 nsp_dbg(NSP_DEBUG_DATA_IO, "write ocount=0x%x", ocount);
901 nsp_dbg(NSP_DEBUG_DATA_IO, "w cmd=%d resid=0x%x\n", data->CmdId, SCpnt->resid);
902 }
903 #undef RFIFO_CRIT
904 #undef WFIFO_CRIT
905
906 /*
907 * setup synchronous/asynchronous data transfer mode
908 */
909 static int nsp_nexus(Scsi_Cmnd *SCpnt)
910 {
911 unsigned int base = SCpnt->device->host->io_port;
912 unsigned char target = scmd_id(SCpnt);
913 // unsigned char lun = SCpnt->device->lun;
914 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
915 sync_data *sync = &(data->Sync[target]);
916
917 //nsp_dbg(NSP_DEBUG_DATA_IO, "in SCpnt=0x%p", SCpnt);
918
919 /* setup synch transfer registers */
920 nsp_index_write(base, SYNCREG, sync->SyncRegister);
921 nsp_index_write(base, ACKWIDTH, sync->AckWidth);
922
923 if (SCpnt->use_sg == 0 ||
924 SCpnt->resid % 4 != 0 ||
925 SCpnt->resid <= PAGE_SIZE ) {
926 data->TransferMode = MODE_IO8;
927 } else if (nsp_burst_mode == BURST_MEM32) {
928 data->TransferMode = MODE_MEM32;
929 } else if (nsp_burst_mode == BURST_IO32) {
930 data->TransferMode = MODE_IO32;
931 } else {
932 data->TransferMode = MODE_IO8;
933 }
934
935 /* setup pdma fifo */
936 nsp_setup_fifo(data, TRUE);
937
938 /* clear ack counter */
939 data->FifoCount = 0;
940 nsp_index_write(base, POINTERCLR, POINTER_CLEAR |
941 ACK_COUNTER_CLEAR |
942 REQ_COUNTER_CLEAR |
943 HOST_COUNTER_CLEAR);
944
945 return 0;
946 }
947
948 #include "nsp_message.c"
949 /*
950 * interrupt handler
951 */
952 static irqreturn_t nspintr(int irq, void *dev_id, struct pt_regs *regs)
953 {
954 unsigned int base;
955 unsigned char irq_status, irq_phase, phase;
956 Scsi_Cmnd *tmpSC;
957 unsigned char target, lun;
958 unsigned int *sync_neg;
959 int i, tmp;
960 nsp_hw_data *data;
961
962
963 //nsp_dbg(NSP_DEBUG_INTR, "dev_id=0x%p", dev_id);
964 //nsp_dbg(NSP_DEBUG_INTR, "host=0x%p", ((scsi_info_t *)dev_id)->host);
965
966 if ( dev_id != NULL &&
967 ((scsi_info_t *)dev_id)->host != NULL ) {
968 scsi_info_t *info = (scsi_info_t *)dev_id;
969
970 data = (nsp_hw_data *)info->host->hostdata;
971 } else {
972 nsp_dbg(NSP_DEBUG_INTR, "host data wrong");
973 return IRQ_NONE;
974 }
975
976 //nsp_dbg(NSP_DEBUG_INTR, "&nsp_data_base=0x%p, dev_id=0x%p", &nsp_data_base, dev_id);
977
978 base = data->BaseAddress;
979 //nsp_dbg(NSP_DEBUG_INTR, "base=0x%x", base);
980
981 /*
982 * interrupt check
983 */
984 nsp_write(base, IRQCONTROL, IRQCONTROL_IRQDISABLE);
985 irq_status = nsp_read(base, IRQSTATUS);
986 //nsp_dbg(NSP_DEBUG_INTR, "irq_status=0x%x", irq_status);
987 if ((irq_status == 0xff) || ((irq_status & IRQSTATUS_MASK) == 0)) {
988 nsp_write(base, IRQCONTROL, 0);
989 //nsp_dbg(NSP_DEBUG_INTR, "no irq/shared irq");
990 return IRQ_NONE;
991 }
992
993 /* XXX: IMPORTANT
994 * Do not read an irq_phase register if no scsi phase interrupt.
995 * Unless, you should lose a scsi phase interrupt.
996 */
997 phase = nsp_index_read(base, SCSIBUSMON);
998 if((irq_status & IRQSTATUS_SCSI) != 0) {
999 irq_phase = nsp_index_read(base, IRQPHASESENCE);
1000 } else {
1001 irq_phase = 0;
1002 }
1003
1004 //nsp_dbg(NSP_DEBUG_INTR, "irq_phase=0x%x", irq_phase);
1005
1006 /*
1007 * timer interrupt handler (scsi vs timer interrupts)
1008 */
1009 //nsp_dbg(NSP_DEBUG_INTR, "timercount=%d", data->TimerCount);
1010 if (data->TimerCount != 0) {
1011 //nsp_dbg(NSP_DEBUG_INTR, "stop timer");
1012 nsp_index_write(base, TIMERCOUNT, 0);
1013 nsp_index_write(base, TIMERCOUNT, 0);
1014 data->TimerCount = 0;
1015 }
1016
1017 if ((irq_status & IRQSTATUS_MASK) == IRQSTATUS_TIMER &&
1018 data->SelectionTimeOut == 0) {
1019 //nsp_dbg(NSP_DEBUG_INTR, "timer start");
1020 nsp_write(base, IRQCONTROL, IRQCONTROL_TIMER_CLEAR);
1021 return IRQ_HANDLED;
1022 }
1023
1024 nsp_write(base, IRQCONTROL, IRQCONTROL_TIMER_CLEAR | IRQCONTROL_FIFO_CLEAR);
1025
1026 if ((irq_status & IRQSTATUS_SCSI) &&
1027 (irq_phase & SCSI_RESET_IRQ)) {
1028 nsp_msg(KERN_ERR, "bus reset (power off?)");
1029
1030 nsphw_init(data);
1031 nsp_bus_reset(data);
1032
1033 if(data->CurrentSC != NULL) {
1034 tmpSC = data->CurrentSC;
1035 tmpSC->result = (DID_RESET << 16) |
1036 ((tmpSC->SCp.Message & 0xff) << 8) |
1037 ((tmpSC->SCp.Status & 0xff) << 0);
1038 nsp_scsi_done(tmpSC);
1039 }
1040 return IRQ_HANDLED;
1041 }
1042
1043 if (data->CurrentSC == NULL) {
1044 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);
1045 nsphw_init(data);
1046 nsp_bus_reset(data);
1047 return IRQ_HANDLED;
1048 }
1049
1050 tmpSC = data->CurrentSC;
1051 target = tmpSC->device->id;
1052 lun = tmpSC->device->lun;
1053 sync_neg = &(data->Sync[target].SyncNegotiation);
1054
1055 /*
1056 * parse hardware SCSI irq reasons register
1057 */
1058 if (irq_status & IRQSTATUS_SCSI) {
1059 if (irq_phase & RESELECT_IRQ) {
1060 nsp_dbg(NSP_DEBUG_INTR, "reselect");
1061 nsp_write(base, IRQCONTROL, IRQCONTROL_RESELECT_CLEAR);
1062 if (nsp_reselected(tmpSC) != FALSE) {
1063 return IRQ_HANDLED;
1064 }
1065 }
1066
1067 if ((irq_phase & (PHASE_CHANGE_IRQ | LATCHED_BUS_FREE)) == 0) {
1068 return IRQ_HANDLED;
1069 }
1070 }
1071
1072 //show_phase(tmpSC);
1073
1074 switch(tmpSC->SCp.phase) {
1075 case PH_SELSTART:
1076 // *sync_neg = SYNC_NOT_YET;
1077 if ((phase & BUSMON_BSY) == 0) {
1078 //nsp_dbg(NSP_DEBUG_INTR, "selection count=%d", data->SelectionTimeOut);
1079 if (data->SelectionTimeOut >= NSP_SELTIMEOUT) {
1080 nsp_dbg(NSP_DEBUG_INTR, "selection time out");
1081 data->SelectionTimeOut = 0;
1082 nsp_index_write(base, SCSIBUSCTRL, 0);
1083
1084 tmpSC->result = DID_TIME_OUT << 16;
1085 nsp_scsi_done(tmpSC);
1086
1087 return IRQ_HANDLED;
1088 }
1089 data->SelectionTimeOut += 1;
1090 nsp_start_timer(tmpSC, 1000/51);
1091 return IRQ_HANDLED;
1092 }
1093
1094 /* attention assert */
1095 //nsp_dbg(NSP_DEBUG_INTR, "attention assert");
1096 data->SelectionTimeOut = 0;
1097 tmpSC->SCp.phase = PH_SELECTED;
1098 nsp_index_write(base, SCSIBUSCTRL, SCSI_ATN);
1099 udelay(1);
1100 nsp_index_write(base, SCSIBUSCTRL, SCSI_ATN | AUTODIRECTION | ACKENB);
1101 return IRQ_HANDLED;
1102
1103 break;
1104
1105 case PH_RESELECT:
1106 //nsp_dbg(NSP_DEBUG_INTR, "phase reselect");
1107 // *sync_neg = SYNC_NOT_YET;
1108 if ((phase & BUSMON_PHASE_MASK) != BUSPHASE_MESSAGE_IN) {
1109
1110 tmpSC->result = DID_ABORT << 16;
1111 nsp_scsi_done(tmpSC);
1112 return IRQ_HANDLED;
1113 }
1114 /* fall thru */
1115 default:
1116 if ((irq_status & (IRQSTATUS_SCSI | IRQSTATUS_FIFO)) == 0) {
1117 return IRQ_HANDLED;
1118 }
1119 break;
1120 }
1121
1122 /*
1123 * SCSI sequencer
1124 */
1125 //nsp_dbg(NSP_DEBUG_INTR, "start scsi seq");
1126
1127 /* normal disconnect */
1128 if (((tmpSC->SCp.phase == PH_MSG_IN) || (tmpSC->SCp.phase == PH_MSG_OUT)) &&
1129 (irq_phase & LATCHED_BUS_FREE) != 0 ) {
1130 nsp_dbg(NSP_DEBUG_INTR, "normal disconnect irq_status=0x%x, phase=0x%x, irq_phase=0x%x", irq_status, phase, irq_phase);
1131
1132 //*sync_neg = SYNC_NOT_YET;
1133
1134 if ((tmpSC->SCp.Message == MSG_COMMAND_COMPLETE)) { /* all command complete and return status */
1135 tmpSC->result = (DID_OK << 16) |
1136 ((tmpSC->SCp.Message & 0xff) << 8) |
1137 ((tmpSC->SCp.Status & 0xff) << 0);
1138 nsp_dbg(NSP_DEBUG_INTR, "command complete result=0x%x", tmpSC->result);
1139 nsp_scsi_done(tmpSC);
1140
1141 return IRQ_HANDLED;
1142 }
1143
1144 return IRQ_HANDLED;
1145 }
1146
1147
1148 /* check unexpected bus free state */
1149 if (phase == 0) {
1150 nsp_msg(KERN_DEBUG, "unexpected bus free. irq_status=0x%x, phase=0x%x, irq_phase=0x%x", irq_status, phase, irq_phase);
1151
1152 *sync_neg = SYNC_NG;
1153 tmpSC->result = DID_ERROR << 16;
1154 nsp_scsi_done(tmpSC);
1155 return IRQ_HANDLED;
1156 }
1157
1158 switch (phase & BUSMON_PHASE_MASK) {
1159 case BUSPHASE_COMMAND:
1160 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_COMMAND");
1161 if ((phase & BUSMON_REQ) == 0) {
1162 nsp_dbg(NSP_DEBUG_INTR, "REQ == 0");
1163 return IRQ_HANDLED;
1164 }
1165
1166 tmpSC->SCp.phase = PH_COMMAND;
1167
1168 nsp_nexus(tmpSC);
1169
1170 /* write scsi command */
1171 nsp_dbg(NSP_DEBUG_INTR, "cmd_len=%d", tmpSC->cmd_len);
1172 nsp_index_write(base, COMMANDCTRL, CLEAR_COMMAND_POINTER);
1173 for (i = 0; i < tmpSC->cmd_len; i++) {
1174 nsp_index_write(base, COMMANDDATA, tmpSC->cmnd[i]);
1175 }
1176 nsp_index_write(base, COMMANDCTRL, CLEAR_COMMAND_POINTER | AUTO_COMMAND_GO);
1177 break;
1178
1179 case BUSPHASE_DATA_OUT:
1180 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_DATA_OUT");
1181
1182 tmpSC->SCp.phase = PH_DATA;
1183 tmpSC->SCp.have_data_in = IO_OUT;
1184
1185 nsp_pio_write(tmpSC);
1186
1187 break;
1188
1189 case BUSPHASE_DATA_IN:
1190 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_DATA_IN");
1191
1192 tmpSC->SCp.phase = PH_DATA;
1193 tmpSC->SCp.have_data_in = IO_IN;
1194
1195 nsp_pio_read(tmpSC);
1196
1197 break;
1198
1199 case BUSPHASE_STATUS:
1200 nsp_dataphase_bypass(tmpSC);
1201 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_STATUS");
1202
1203 tmpSC->SCp.phase = PH_STATUS;
1204
1205 tmpSC->SCp.Status = nsp_index_read(base, SCSIDATAWITHACK);
1206 nsp_dbg(NSP_DEBUG_INTR, "message=0x%x status=0x%x", tmpSC->SCp.Message, tmpSC->SCp.Status);
1207
1208 break;
1209
1210 case BUSPHASE_MESSAGE_OUT:
1211 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_MESSAGE_OUT");
1212 if ((phase & BUSMON_REQ) == 0) {
1213 goto timer_out;
1214 }
1215
1216 tmpSC->SCp.phase = PH_MSG_OUT;
1217
1218 //*sync_neg = SYNC_NOT_YET;
1219
1220 data->MsgLen = i = 0;
1221 data->MsgBuffer[i] = IDENTIFY(TRUE, lun); i++;
1222
1223 if (*sync_neg == SYNC_NOT_YET) {
1224 data->Sync[target].SyncPeriod = 0;
1225 data->Sync[target].SyncOffset = 0;
1226
1227 /**/
1228 data->MsgBuffer[i] = MSG_EXTENDED; i++;
1229 data->MsgBuffer[i] = 3; i++;
1230 data->MsgBuffer[i] = MSG_EXT_SDTR; i++;
1231 data->MsgBuffer[i] = 0x0c; i++;
1232 data->MsgBuffer[i] = 15; i++;
1233 /**/
1234 }
1235 data->MsgLen = i;
1236
1237 nsp_analyze_sdtr(tmpSC);
1238 show_message(data);
1239 nsp_message_out(tmpSC);
1240 break;
1241
1242 case BUSPHASE_MESSAGE_IN:
1243 nsp_dataphase_bypass(tmpSC);
1244 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE_MESSAGE_IN");
1245 if ((phase & BUSMON_REQ) == 0) {
1246 goto timer_out;
1247 }
1248
1249 tmpSC->SCp.phase = PH_MSG_IN;
1250 nsp_message_in(tmpSC);
1251
1252 /**/
1253 if (*sync_neg == SYNC_NOT_YET) {
1254 //nsp_dbg(NSP_DEBUG_INTR, "sync target=%d,lun=%d",target,lun);
1255
1256 if (data->MsgLen >= 5 &&
1257 data->MsgBuffer[0] == MSG_EXTENDED &&
1258 data->MsgBuffer[1] == 3 &&
1259 data->MsgBuffer[2] == MSG_EXT_SDTR ) {
1260 data->Sync[target].SyncPeriod = data->MsgBuffer[3];
1261 data->Sync[target].SyncOffset = data->MsgBuffer[4];
1262 //nsp_dbg(NSP_DEBUG_INTR, "sync ok, %d %d", data->MsgBuffer[3], data->MsgBuffer[4]);
1263 *sync_neg = SYNC_OK;
1264 } else {
1265 data->Sync[target].SyncPeriod = 0;
1266 data->Sync[target].SyncOffset = 0;
1267 *sync_neg = SYNC_NG;
1268 }
1269 nsp_analyze_sdtr(tmpSC);
1270 }
1271 /**/
1272
1273 /* search last messeage byte */
1274 tmp = -1;
1275 for (i = 0; i < data->MsgLen; i++) {
1276 tmp = data->MsgBuffer[i];
1277 if (data->MsgBuffer[i] == MSG_EXTENDED) {
1278 i += (1 + data->MsgBuffer[i+1]);
1279 }
1280 }
1281 tmpSC->SCp.Message = tmp;
1282
1283 nsp_dbg(NSP_DEBUG_INTR, "message=0x%x len=%d", tmpSC->SCp.Message, data->MsgLen);
1284 show_message(data);
1285
1286 break;
1287
1288 case BUSPHASE_SELECT:
1289 default:
1290 nsp_dbg(NSP_DEBUG_INTR, "BUSPHASE other");
1291
1292 break;
1293 }
1294
1295 //nsp_dbg(NSP_DEBUG_INTR, "out");
1296 return IRQ_HANDLED;
1297
1298 timer_out:
1299 nsp_start_timer(tmpSC, 1000/102);
1300 return IRQ_HANDLED;
1301 }
1302
1303 #ifdef NSP_DEBUG
1304 #include "nsp_debug.c"
1305 #endif /* NSP_DEBUG */
1306
1307 /*----------------------------------------------------------------*/
1308 /* look for ninja3 card and init if found */
1309 /*----------------------------------------------------------------*/
1310 static struct Scsi_Host *nsp_detect(struct scsi_host_template *sht)
1311 {
1312 struct Scsi_Host *host; /* registered host structure */
1313 nsp_hw_data *data_b = &nsp_data_base, *data;
1314
1315 nsp_dbg(NSP_DEBUG_INIT, "this_id=%d", sht->this_id);
1316 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,73))
1317 host = scsi_host_alloc(&nsp_driver_template, sizeof(nsp_hw_data));
1318 #else
1319 host = scsi_register(sht, sizeof(nsp_hw_data));
1320 #endif
1321 if (host == NULL) {
1322 nsp_dbg(NSP_DEBUG_INIT, "host failed");
1323 return NULL;
1324 }
1325
1326 memcpy(host->hostdata, data_b, sizeof(nsp_hw_data));
1327 data = (nsp_hw_data *)host->hostdata;
1328 data->ScsiInfo->host = host;
1329 #ifdef NSP_DEBUG
1330 data->CmdId = 0;
1331 #endif
1332
1333 nsp_dbg(NSP_DEBUG_INIT, "irq=%d,%d", data_b->IrqNumber, ((nsp_hw_data *)host->hostdata)->IrqNumber);
1334
1335 host->unique_id = data->BaseAddress;
1336 host->io_port = data->BaseAddress;
1337 host->n_io_port = data->NumAddress;
1338 host->irq = data->IrqNumber;
1339 host->base = data->MmioAddress;
1340
1341 spin_lock_init(&(data->Lock));
1342
1343 snprintf(data->nspinfo,
1344 sizeof(data->nspinfo),
1345 "NinjaSCSI-3/32Bi Driver $Revision: 1.23 $ IO:0x%04lx-0x%04lx MMIO(virt addr):0x%04lx IRQ:%02d",
1346 host->io_port, host->io_port + host->n_io_port - 1,
1347 host->base,
1348 host->irq);
1349 sht->name = data->nspinfo;
1350
1351 nsp_dbg(NSP_DEBUG_INIT, "end");
1352
1353
1354 return host; /* detect done. */
1355 }
1356
1357 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
1358 static int nsp_detect_old(struct scsi_host_template *sht)
1359 {
1360 if (nsp_detect(sht) == NULL) {
1361 return 0;
1362 } else {
1363 //MOD_INC_USE_COUNT;
1364 return 1;
1365 }
1366 }
1367
1368
1369 static int nsp_release_old(struct Scsi_Host *shpnt)
1370 {
1371 //nsp_hw_data *data = (nsp_hw_data *)shpnt->hostdata;
1372
1373 /* PCMCIA Card Service dose same things below. */
1374 /* So we do nothing. */
1375 //if (shpnt->irq) {
1376 // free_irq(shpnt->irq, data->ScsiInfo);
1377 //}
1378 //if (shpnt->io_port) {
1379 // release_region(shpnt->io_port, shpnt->n_io_port);
1380 //}
1381
1382 //MOD_DEC_USE_COUNT;
1383
1384 return 0;
1385 }
1386 #endif
1387
1388 /*----------------------------------------------------------------*/
1389 /* return info string */
1390 /*----------------------------------------------------------------*/
1391 static const char *nsp_info(struct Scsi_Host *shpnt)
1392 {
1393 nsp_hw_data *data = (nsp_hw_data *)shpnt->hostdata;
1394
1395 return data->nspinfo;
1396 }
1397
1398 #undef SPRINTF
1399 #define SPRINTF(args...) \
1400 do { \
1401 if(length > (pos - buffer)) { \
1402 pos += snprintf(pos, length - (pos - buffer) + 1, ## args); \
1403 nsp_dbg(NSP_DEBUG_PROC, "buffer=0x%p pos=0x%p length=%d %d\n", buffer, pos, length, length - (pos - buffer));\
1404 } \
1405 } while(0)
1406 static int
1407 nsp_proc_info(
1408 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,73))
1409 struct Scsi_Host *host,
1410 #endif
1411 char *buffer,
1412 char **start,
1413 off_t offset,
1414 int length,
1415 #if !(LINUX_VERSION_CODE > KERNEL_VERSION(2,5,73))
1416 int hostno,
1417 #endif
1418 int inout)
1419 {
1420 int id;
1421 char *pos = buffer;
1422 int thislength;
1423 int speed;
1424 unsigned long flags;
1425 nsp_hw_data *data;
1426 #if !(LINUX_VERSION_CODE > KERNEL_VERSION(2,5,73))
1427 struct Scsi_Host *host;
1428 #else
1429 int hostno;
1430 #endif
1431 if (inout) {
1432 return -EINVAL;
1433 }
1434
1435 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,73))
1436 hostno = host->host_no;
1437 #else
1438 /* search this HBA host */
1439 host = scsi_host_hn_get(hostno);
1440 if (host == NULL) {
1441 return -ESRCH;
1442 }
1443 #endif
1444 data = (nsp_hw_data *)host->hostdata;
1445
1446
1447 SPRINTF("NinjaSCSI status\n\n");
1448 SPRINTF("Driver version: $Revision: 1.23 $\n");
1449 SPRINTF("SCSI host No.: %d\n", hostno);
1450 SPRINTF("IRQ: %d\n", host->irq);
1451 SPRINTF("IO: 0x%lx-0x%lx\n", host->io_port, host->io_port + host->n_io_port - 1);
1452 SPRINTF("MMIO(virtual address): 0x%lx-0x%lx\n", host->base, host->base + data->MmioLength - 1);
1453 SPRINTF("sg_tablesize: %d\n", host->sg_tablesize);
1454
1455 SPRINTF("burst transfer mode: ");
1456 switch (nsp_burst_mode) {
1457 case BURST_IO8:
1458 SPRINTF("io8");
1459 break;
1460 case BURST_IO32:
1461 SPRINTF("io32");
1462 break;
1463 case BURST_MEM32:
1464 SPRINTF("mem32");
1465 break;
1466 default:
1467 SPRINTF("???");
1468 break;
1469 }
1470 SPRINTF("\n");
1471
1472
1473 spin_lock_irqsave(&(data->Lock), flags);
1474 SPRINTF("CurrentSC: 0x%p\n\n", data->CurrentSC);
1475 spin_unlock_irqrestore(&(data->Lock), flags);
1476
1477 SPRINTF("SDTR status\n");
1478 for(id = 0; id < ARRAY_SIZE(data->Sync); id++) {
1479
1480 SPRINTF("id %d: ", id);
1481
1482 if (id == host->this_id) {
1483 SPRINTF("----- NinjaSCSI-3 host adapter\n");
1484 continue;
1485 }
1486
1487 switch(data->Sync[id].SyncNegotiation) {
1488 case SYNC_OK:
1489 SPRINTF(" sync");
1490 break;
1491 case SYNC_NG:
1492 SPRINTF("async");
1493 break;
1494 case SYNC_NOT_YET:
1495 SPRINTF(" none");
1496 break;
1497 default:
1498 SPRINTF("?????");
1499 break;
1500 }
1501
1502 if (data->Sync[id].SyncPeriod != 0) {
1503 speed = 1000000 / (data->Sync[id].SyncPeriod * 4);
1504
1505 SPRINTF(" transfer %d.%dMB/s, offset %d",
1506 speed / 1000,
1507 speed % 1000,
1508 data->Sync[id].SyncOffset
1509 );
1510 }
1511 SPRINTF("\n");
1512 }
1513
1514 thislength = pos - (buffer + offset);
1515
1516 if(thislength < 0) {
1517 *start = NULL;
1518 return 0;
1519 }
1520
1521
1522 thislength = min(thislength, length);
1523 *start = buffer + offset;
1524
1525 return thislength;
1526 }
1527 #undef SPRINTF
1528
1529 /*---------------------------------------------------------------*/
1530 /* error handler */
1531 /*---------------------------------------------------------------*/
1532
1533 /*
1534 static int nsp_eh_abort(Scsi_Cmnd *SCpnt)
1535 {
1536 nsp_dbg(NSP_DEBUG_BUSRESET, "SCpnt=0x%p", SCpnt);
1537
1538 return nsp_eh_bus_reset(SCpnt);
1539 }*/
1540
1541 static int nsp_bus_reset(nsp_hw_data *data)
1542 {
1543 unsigned int base = data->BaseAddress;
1544 int i;
1545
1546 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLMASK);
1547
1548 nsp_index_write(base, SCSIBUSCTRL, SCSI_RST);
1549 mdelay(100); /* 100ms */
1550 nsp_index_write(base, SCSIBUSCTRL, 0);
1551 for(i = 0; i < 5; i++) {
1552 nsp_index_read(base, IRQPHASESENCE); /* dummy read */
1553 }
1554
1555 nsphw_init_sync(data);
1556
1557 nsp_write(base, IRQCONTROL, IRQCONTROL_ALLCLEAR);
1558
1559 return SUCCESS;
1560 }
1561
1562 static int nsp_eh_bus_reset(Scsi_Cmnd *SCpnt)
1563 {
1564 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
1565
1566 nsp_dbg(NSP_DEBUG_BUSRESET, "SCpnt=0x%p", SCpnt);
1567
1568 return nsp_bus_reset(data);
1569 }
1570
1571 static int nsp_eh_host_reset(Scsi_Cmnd *SCpnt)
1572 {
1573 nsp_hw_data *data = (nsp_hw_data *)SCpnt->device->host->hostdata;
1574
1575 nsp_dbg(NSP_DEBUG_BUSRESET, "in");
1576
1577 nsphw_init(data);
1578
1579 return SUCCESS;
1580 }
1581
1582
1583 /**********************************************************************
1584 PCMCIA functions
1585 **********************************************************************/
1586
1587 /*======================================================================
1588 nsp_cs_attach() creates an "instance" of the driver, allocating
1589 local data structures for one device. The device is registered
1590 with Card Services.
1591
1592 The dev_link structure is initialized, but we don't actually
1593 configure the card at this point -- we wait until we receive a
1594 card insertion event.
1595 ======================================================================*/
1596 static int nsp_cs_attach(struct pcmcia_device *p_dev)
1597 {
1598 scsi_info_t *info;
1599 dev_link_t *link;
1600 nsp_hw_data *data = &nsp_data_base;
1601
1602 nsp_dbg(NSP_DEBUG_INIT, "in");
1603
1604 /* Create new SCSI device */
1605 info = kmalloc(sizeof(*info), GFP_KERNEL);
1606 if (info == NULL) { return -ENOMEM; }
1607 memset(info, 0, sizeof(*info));
1608 link = &info->link;
1609 link->priv = info;
1610 data->ScsiInfo = info;
1611
1612 nsp_dbg(NSP_DEBUG_INIT, "info=0x%p", info);
1613
1614 /* The io structure describes IO port mapping */
1615 link->io.NumPorts1 = 0x10;
1616 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
1617 link->io.IOAddrLines = 10; /* not used */
1618
1619 /* Interrupt setup */
1620 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
1621 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
1622
1623 /* Interrupt handler */
1624 link->irq.Handler = &nspintr;
1625 link->irq.Instance = info;
1626 link->irq.Attributes |= (SA_SHIRQ | SA_SAMPLE_RANDOM);
1627
1628 /* General socket configuration */
1629 link->conf.Attributes = CONF_ENABLE_IRQ;
1630 link->conf.Vcc = 50;
1631 link->conf.IntType = INT_MEMORY_AND_IO;
1632 link->conf.Present = PRESENT_OPTION;
1633
1634 link->handle = p_dev;
1635 p_dev->instance = link;
1636
1637 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
1638 nsp_cs_config(link);
1639
1640 nsp_dbg(NSP_DEBUG_INIT, "link=0x%p", link);
1641 return 0;
1642 } /* nsp_cs_attach */
1643
1644
1645 /*======================================================================
1646 This deletes a driver "instance". The device is de-registered
1647 with Card Services. If it has been released, all local data
1648 structures are freed. Otherwise, the structures will be freed
1649 when the device is released.
1650 ======================================================================*/
1651 static void nsp_cs_detach(struct pcmcia_device *p_dev)
1652 {
1653 dev_link_t *link = dev_to_instance(p_dev);
1654
1655 nsp_dbg(NSP_DEBUG_INIT, "in, link=0x%p", link);
1656
1657 if (link->state & DEV_CONFIG) {
1658 ((scsi_info_t *)link->priv)->stop = 1;
1659 nsp_cs_release(link);
1660 }
1661
1662 kfree(link->priv);
1663 link->priv = NULL;
1664 } /* nsp_cs_detach */
1665
1666
1667 /*======================================================================
1668 nsp_cs_config() is scheduled to run after a CARD_INSERTION event
1669 is received, to configure the PCMCIA socket, and to make the
1670 ethernet device available to the system.
1671 ======================================================================*/
1672 #define CS_CHECK(fn, ret) \
1673 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
1674 /*====================================================================*/
1675 static void nsp_cs_config(dev_link_t *link)
1676 {
1677 client_handle_t handle = link->handle;
1678 scsi_info_t *info = link->priv;
1679 tuple_t tuple;
1680 cisparse_t parse;
1681 int last_ret, last_fn;
1682 unsigned char tuple_data[64];
1683 config_info_t conf;
1684 win_req_t req;
1685 memreq_t map;
1686 cistpl_cftable_entry_t dflt = { 0 };
1687 struct Scsi_Host *host;
1688 nsp_hw_data *data = &nsp_data_base;
1689 #if !(LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,74))
1690 struct scsi_device *dev;
1691 dev_node_t **tail, *node;
1692 #endif
1693
1694 nsp_dbg(NSP_DEBUG_INIT, "in");
1695
1696 tuple.DesiredTuple = CISTPL_CONFIG;
1697 tuple.Attributes = 0;
1698 tuple.TupleData = tuple_data;
1699 tuple.TupleDataMax = sizeof(tuple_data);
1700 tuple.TupleOffset = 0;
1701 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
1702 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
1703 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
1704 link->conf.ConfigBase = parse.config.base;
1705 link->conf.Present = parse.config.rmask[0];
1706
1707 /* Configure card */
1708 link->state |= DEV_CONFIG;
1709
1710 /* Look up the current Vcc */
1711 CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(handle, &conf));
1712 link->conf.Vcc = conf.Vcc;
1713
1714 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
1715 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
1716 while (1) {
1717 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
1718
1719 if (pcmcia_get_tuple_data(handle, &tuple) != 0 ||
1720 pcmcia_parse_tuple(handle, &tuple, &parse) != 0)
1721 goto next_entry;
1722
1723 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) { dflt = *cfg; }
1724 if (cfg->index == 0) { goto next_entry; }
1725 link->conf.ConfigIndex = cfg->index;
1726
1727 /* Does this card need audio output? */
1728 if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
1729 link->conf.Attributes |= CONF_ENABLE_SPKR;
1730 link->conf.Status = CCSR_AUDIO_ENA;
1731 }
1732
1733 /* Use power settings for Vcc and Vpp if present */
1734 /* Note that the CIS values need to be rescaled */
1735 if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) {
1736 if (conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM]/10000) {
1737 goto next_entry;
1738 }
1739 } else if (dflt.vcc.present & (1<<CISTPL_POWER_VNOM)) {
1740 if (conf.Vcc != dflt.vcc.param[CISTPL_POWER_VNOM]/10000) {
1741 goto next_entry;
1742 }
1743 }
1744
1745 if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM)) {
1746 link->conf.Vpp1 = link->conf.Vpp2 =
1747 cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
1748 } else if (dflt.vpp1.present & (1 << CISTPL_POWER_VNOM)) {
1749 link->conf.Vpp1 = link->conf.Vpp2 =
1750 dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000;
1751 }
1752
1753 /* Do we need to allocate an interrupt? */
1754 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1) {
1755 link->conf.Attributes |= CONF_ENABLE_IRQ;
1756 }
1757
1758 /* IO window settings */
1759 link->io.NumPorts1 = link->io.NumPorts2 = 0;
1760 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
1761 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
1762 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
1763 if (!(io->flags & CISTPL_IO_8BIT))
1764 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
1765 if (!(io->flags & CISTPL_IO_16BIT))
1766 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
1767 link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
1768 link->io.BasePort1 = io->win[0].base;
1769 link->io.NumPorts1 = io->win[0].len;
1770 if (io->nwin > 1) {
1771 link->io.Attributes2 = link->io.Attributes1;
1772 link->io.BasePort2 = io->win[1].base;
1773 link->io.NumPorts2 = io->win[1].len;
1774 }
1775 /* This reserves IO space but doesn't actually enable it */
1776 if (pcmcia_request_io(link->handle, &link->io) != 0)
1777 goto next_entry;
1778 }
1779
1780 if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) {
1781 cistpl_mem_t *mem =
1782 (cfg->mem.nwin) ? &cfg->mem : &dflt.mem;
1783 req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
1784 req.Attributes |= WIN_ENABLE;
1785 req.Base = mem->win[0].host_addr;
1786 req.Size = mem->win[0].len;
1787 if (req.Size < 0x1000) {
1788 req.Size = 0x1000;
1789 }
1790 req.AccessSpeed = 0;
1791 if (pcmcia_request_window(&link->handle, &req, &link->win) != 0)
1792 goto next_entry;
1793 map.Page = 0; map.CardOffset = mem->win[0].card_addr;
1794 if (pcmcia_map_mem_page(link->win, &map) != 0)
1795 goto next_entry;
1796
1797 data->MmioAddress = (unsigned long)ioremap_nocache(req.Base, req.Size);
1798 data->MmioLength = req.Size;
1799 }
1800 /* If we got this far, we're cool! */
1801 break;
1802
1803 next_entry:
1804 nsp_dbg(NSP_DEBUG_INIT, "next");
1805
1806 if (link->io.NumPorts1) {
1807 pcmcia_release_io(link->handle, &link->io);
1808 }
1809 CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
1810 }
1811
1812 if (link->conf.Attributes & CONF_ENABLE_IRQ) {
1813 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
1814 }
1815 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf));
1816
1817 if (free_ports) {
1818 if (link->io.BasePort1) {
1819 release_region(link->io.BasePort1, link->io.NumPorts1);
1820 }
1821 if (link->io.BasePort2) {
1822 release_region(link->io.BasePort2, link->io.NumPorts2);
1823 }
1824 }
1825
1826 /* Set port and IRQ */
1827 data->BaseAddress = link->io.BasePort1;
1828 data->NumAddress = link->io.NumPorts1;
1829 data->IrqNumber = link->irq.AssignedIRQ;
1830
1831 nsp_dbg(NSP_DEBUG_INIT, "I/O[0x%x+0x%x] IRQ %d",
1832 data->BaseAddress, data->NumAddress, data->IrqNumber);
1833
1834 if(nsphw_init(data) == FALSE) {
1835 goto cs_failed;
1836 }
1837
1838 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,2))
1839 host = nsp_detect(&nsp_driver_template);
1840 #else
1841 scsi_register_host(&nsp_driver_template);
1842 for (host = scsi_host_get_next(NULL); host != NULL;
1843 host = scsi_host_get_next(host)) {
1844 if (host->hostt == &nsp_driver_template) {
1845 break;
1846 }
1847 }
1848 #endif
1849
1850 if (host == NULL) {
1851 nsp_dbg(NSP_DEBUG_INIT, "detect failed");
1852 goto cs_failed;
1853 }
1854
1855
1856 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,74))
1857 scsi_add_host (host, NULL);
1858 scsi_scan_host(host);
1859
1860 snprintf(info->node.dev_name, sizeof(info->node.dev_name), "scsi%d", host->host_no);
1861 link->dev = &info->node;
1862 info->host = host;
1863
1864 #else
1865 nsp_dbg(NSP_DEBUG_INIT, "GET_SCSI_INFO");
1866 tail = &link->dev;
1867 info->ndev = 0;
1868
1869 nsp_dbg(NSP_DEBUG_INIT, "host=0x%p", host);
1870
1871 for (dev = host->host_queue; dev != NULL; dev = dev->next) {
1872 unsigned long id;
1873 id = (dev->id & 0x0f) + ((dev->lun & 0x0f) << 4) +
1874 ((dev->channel & 0x0f) << 8) +
1875 ((dev->host->host_no & 0x0f) << 12);
1876 node = &info->node[info->ndev];
1877 node->minor = 0;
1878 switch (dev->type) {
1879 case TYPE_TAPE:
1880 node->major = SCSI_TAPE_MAJOR;
1881 snprintf(node->dev_name, sizeof(node->dev_name), "st#%04lx", id);
1882 break;
1883 case TYPE_DISK:
1884 case TYPE_MOD:
1885 node->major = SCSI_DISK0_MAJOR;
1886 snprintf(node->dev_name, sizeof(node->dev_name), "sd#%04lx", id);
1887 break;
1888 case TYPE_ROM:
1889 case TYPE_WORM:
1890 node->major = SCSI_CDROM_MAJOR;
1891 snprintf(node->dev_name, sizeof(node->dev_name), "sr#%04lx", id);
1892 break;
1893 default:
1894 node->major = SCSI_GENERIC_MAJOR;
1895 snprintf(node->dev_name, sizeof(node->dev_name), "sg#%04lx", id);
1896 break;
1897 }
1898 *tail = node; tail = &node->next;
1899 info->ndev++;
1900 info->host = dev->host;
1901 }
1902
1903 *tail = NULL;
1904 if (info->ndev == 0) {
1905 nsp_msg(KERN_INFO, "no SCSI devices found");
1906 }
1907 nsp_dbg(NSP_DEBUG_INIT, "host=0x%p", host);
1908 #endif
1909
1910 /* Finally, report what we've done */
1911 printk(KERN_INFO "nsp_cs: index 0x%02x: Vcc %d.%d",
1912 link->conf.ConfigIndex,
1913 link->conf.Vcc/10, link->conf.Vcc%10);
1914 if (link->conf.Vpp1) {
1915 printk(", Vpp %d.%d", link->conf.Vpp1/10, link->conf.Vpp1%10);
1916 }
1917 if (link->conf.Attributes & CONF_ENABLE_IRQ) {
1918 printk(", irq %d", link->irq.AssignedIRQ);
1919 }
1920 if (link->io.NumPorts1) {
1921 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
1922 link->io.BasePort1+link->io.NumPorts1-1);
1923 }
1924 if (link->io.NumPorts2)
1925 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
1926 link->io.BasePort2+link->io.NumPorts2-1);
1927 if (link->win)
1928 printk(", mem 0x%06lx-0x%06lx", req.Base,
1929 req.Base+req.Size-1);
1930 printk("\n");
1931
1932 link->state &= ~DEV_CONFIG_PENDING;
1933 return;
1934
1935 cs_failed:
1936 nsp_dbg(NSP_DEBUG_INIT, "config fail");
1937 cs_error(link->handle, last_fn, last_ret);
1938 nsp_cs_release(link);
1939
1940 return;
1941 } /* nsp_cs_config */
1942 #undef CS_CHECK
1943
1944
1945 /*======================================================================
1946 After a card is removed, nsp_cs_release() will unregister the net
1947 device, and release the PCMCIA configuration. If the device is
1948 still open, this will be postponed until it is closed.
1949 ======================================================================*/
1950 static void nsp_cs_release(dev_link_t *link)
1951 {
1952 scsi_info_t *info = link->priv;
1953 nsp_hw_data *data = NULL;
1954
1955 if (info->host == NULL) {
1956 nsp_msg(KERN_DEBUG, "unexpected card release call.");
1957 } else {
1958 data = (nsp_hw_data *)info->host->hostdata;
1959 }
1960
1961 nsp_dbg(NSP_DEBUG_INIT, "link=0x%p", link);
1962
1963 /* Unlink the device chain */
1964 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,2))
1965 if (info->host != NULL) {
1966 scsi_remove_host(info->host);
1967 }
1968 #else
1969 scsi_unregister_host(&nsp_driver_template);
1970 #endif
1971 link->dev = NULL;
1972
1973 if (link->win) {
1974 if (data != NULL) {
1975 iounmap((void *)(data->MmioAddress));
1976 }
1977 pcmcia_release_window(link->win);
1978 }
1979 pcmcia_release_configuration(link->handle);
1980 if (link->io.NumPorts1) {
1981 pcmcia_release_io(link->handle, &link->io);
1982 }
1983 if (link->irq.AssignedIRQ) {
1984 pcmcia_release_irq(link->handle, &link->irq);
1985 }
1986 link->state &= ~DEV_CONFIG;
1987 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,2))
1988 if (info->host != NULL) {
1989 scsi_host_put(info->host);
1990 }
1991 #endif
1992 } /* nsp_cs_release */
1993
1994 static int nsp_cs_suspend(struct pcmcia_device *dev)
1995 {
1996 dev_link_t *link = dev_to_instance(dev);
1997 scsi_info_t *info = link->priv;
1998 nsp_hw_data *data;
1999
2000 link->state |= DEV_SUSPEND;
2001
2002 nsp_dbg(NSP_DEBUG_INIT, "event: suspend");
2003
2004 if (info->host != NULL) {
2005 nsp_msg(KERN_INFO, "clear SDTR status");
2006
2007 data = (nsp_hw_data *)info->host->hostdata;
2008
2009 nsphw_init_sync(data);
2010 }
2011
2012 info->stop = 1;
2013
2014 if (link->state & DEV_CONFIG)
2015 pcmcia_release_configuration(link->handle);
2016
2017 return 0;
2018 }
2019
2020 static int nsp_cs_resume(struct pcmcia_device *dev)
2021 {
2022 dev_link_t *link = dev_to_instance(dev);
2023 scsi_info_t *info = link->priv;
2024 nsp_hw_data *data;
2025
2026 nsp_dbg(NSP_DEBUG_INIT, "event: resume");
2027
2028 link->state &= ~DEV_SUSPEND;
2029
2030 if (link->state & DEV_CONFIG)
2031 pcmcia_request_configuration(link->handle, &link->conf);
2032
2033 info->stop = 0;
2034
2035 if (info->host != NULL) {
2036 nsp_msg(KERN_INFO, "reset host and bus");
2037
2038 data = (nsp_hw_data *)info->host->hostdata;
2039
2040 nsphw_init (data);
2041 nsp_bus_reset(data);
2042 }
2043
2044 return 0;
2045 }
2046
2047 /*======================================================================*
2048 * module entry point
2049 *====================================================================*/
2050 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,68))
2051 static struct pcmcia_device_id nsp_cs_ids[] = {
2052 PCMCIA_DEVICE_PROD_ID123("IO DATA", "CBSC16 ", "1", 0x547e66dc, 0x0d63a3fd, 0x51de003a),
2053 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-001", "1", 0x534c02bc, 0x52008408, 0x51de003a),
2054 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-002", "1", 0x534c02bc, 0xcb09d5b2, 0x51de003a),
2055 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-003", "1", 0x534c02bc, 0xbc0ee524, 0x51de003a),
2056 PCMCIA_DEVICE_PROD_ID123("KME ", "SCSI-CARD-004", "1", 0x534c02bc, 0x226a7087, 0x51de003a),
2057 PCMCIA_DEVICE_PROD_ID123("WBT", "NinjaSCSI-3", "R1.0", 0xc7ba805f, 0xfdc7c97d, 0x6973710e),
2058 PCMCIA_DEVICE_PROD_ID123("WORKBIT", "UltraNinja-16", "1", 0x28191418, 0xb70f4b09, 0x51de003a),
2059 PCMCIA_DEVICE_NULL
2060 };
2061 MODULE_DEVICE_TABLE(pcmcia, nsp_cs_ids);
2062
2063 static struct pcmcia_driver nsp_driver = {
2064 .owner = THIS_MODULE,
2065 .drv = {
2066 .name = "nsp_cs",
2067 },
2068 .probe = nsp_cs_attach,
2069 .remove = nsp_cs_detach,
2070 .id_table = nsp_cs_ids,
2071 .suspend = nsp_cs_suspend,
2072 .resume = nsp_cs_resume,
2073 };
2074 #endif
2075
2076 static int __init nsp_cs_init(void)
2077 {
2078 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,68))
2079 nsp_msg(KERN_INFO, "loading...");
2080
2081 return pcmcia_register_driver(&nsp_driver);
2082 #else
2083 servinfo_t serv;
2084
2085 nsp_msg(KERN_INFO, "loading...");
2086 pcmcia_get_card_services_info(&serv);
2087 if (serv.Revision != CS_RELEASE_CODE) {
2088 nsp_msg(KERN_DEBUG, "Card Services release does not match!");
2089 return -EINVAL;
2090 }
2091 register_pcmcia_driver(&dev_info, &nsp_cs_attach, &nsp_cs_detach);
2092
2093 nsp_dbg(NSP_DEBUG_INIT, "out");
2094 return 0;
2095 #endif
2096 }
2097
2098 static void __exit nsp_cs_exit(void)
2099 {
2100 nsp_msg(KERN_INFO, "unloading...");
2101
2102 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,68))
2103 pcmcia_unregister_driver(&nsp_driver);
2104 #else
2105 unregister_pcmcia_driver(&dev_info);
2106 /* XXX: this really needs to move into generic code.. */
2107 while (dev_list != NULL) {
2108 if (dev_list->state & DEV_CONFIG) {
2109 nsp_cs_release(dev_list);
2110 }
2111 nsp_cs_detach(dev_list);
2112 }
2113 #endif
2114 }
2115
2116
2117 module_init(nsp_cs_init)
2118 module_exit(nsp_cs_exit)
2119
2120 /* end */
Verdex Pro support