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