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