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