?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* better
[mascara-docs.git] / i386 / linux-2.3.21 / drivers / scsi / qlogicfc.c
blobcfaa96e5c329b54f645854c3f31218cbda2897c3
1 /*
2 * QLogic ISP2x00 SCSI-FCP
3 * Written by Erik H. Moe, ehm@cris.com
4 * Copyright 1995, Erik H. Moe
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
9 * later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 */
16
17 /* Renamed and updated to 1.3.x by Michael Griffith <grif@cs.ucr.edu> */
18
19 /* This is a version of the isp1020 driver which was modified by
20 * Chris Loveland <cwl@iol.unh.edu> to support the isp2100 and isp2200
21 */
22
23 /*
24 * $Date: 1995/09/22 02:23:15 $
25 * $Revision: 0.5 $
26 *
27 * $Log: isp1020.c,v $
28 * Revision 0.5 1995/09/22 02:23:15 root
29 * do auto request sense
30 *
31 * Revision 0.4 1995/08/07 04:44:33 root
32 * supply firmware with driver.
33 * numerous bug fixes/general cleanup of code.
34 *
35 * Revision 0.3 1995/07/16 16:15:39 root
36 * added reset/abort code.
37 *
38 * Revision 0.2 1995/06/29 03:14:19 root
39 * fixed biosparam.
40 * added queue protocol.
41 *
42 * Revision 0.1 1995/06/25 01:55:45 root
43 * Initial release.
44 *
45 */
46
47 #include <linux/blk.h>
48 #include <linux/kernel.h>
49 #include <linux/string.h>
50 #include <linux/ioport.h>
51 #include <linux/sched.h>
52 #include <linux/types.h>
53 #include <linux/pci.h>
54 #include <linux/delay.h>
55 #include <linux/unistd.h>
56 #include <linux/spinlock.h>
57 #include <asm/io.h>
58 #include <asm/irq.h>
59
60 #include "sd.h"
61 #include "hosts.h"
62 #include "qlogicfc.h"
63
64 /* Configuration section **************************************************** */
65
66 /* Set the following macro to 1 to reload the ISP2x00's firmware. This is
67 version 1.15.37 of the isp2100's firmware and version 2.00.16 of the
68 isp2200's firmware.
69 */
70
71 #define RELOAD_FIRMWARE 1
72
73 #define USE_NVRAM_DEFAULTS 1
74
75 #define ISP2x00_PORTDB 1
76
77 /* Set the following to 1 to include fabric support, fabric support is
78 * currently not as well tested as the other aspects of the driver */
79
80 #define ISP2x00_FABRIC 0
81
82 /* Macros used for debugging */
83 /*
84 #define DEBUG_ISP2x00 1
85 #define DEBUG_ISP2x00_INT 1
86 #define DEBUG_ISP2x00_INTR 1
87 #define DEBUG_ISP2x00_SETUP 1
88
89 #define DEBUG_ISP2x00_FABRIC 1
90 */
91 /* #define TRACE_ISP 1 */
92
93
94 #define DEFAULT_LOOP_COUNT 10000000
95
96 /* End Configuration section ************************************************ */
97
98 #include <linux/module.h>
99
100 #if TRACE_ISP
101
102 #define TRACE_BUF_LEN (32*1024)
103
104 struct {
105 u_long next;
106 struct {
107 u_long time;
108 u_int index;
109 u_int addr;
110 u_char *name;
111 } buf[TRACE_BUF_LEN];
112 } trace;
113
114 #define TRACE(w, i, a) \
115 { \
116 unsigned long flags; \
117 \
118 save_flags(flags); \
119 cli(); \
120 trace.buf[trace.next].name = (w); \
121 trace.buf[trace.next].time = jiffies; \
122 trace.buf[trace.next].index = (i); \
123 trace.buf[trace.next].addr = (long) (a); \
124 trace.next = (trace.next + 1) & (TRACE_BUF_LEN - 1); \
125 restore_flags(flags); \
126 }
127
128 #else
129 #define TRACE(w, i, a)
130 #endif
131
132 #if DEBUG_ISP2x00_FABRIC
133 #define DEBUG_FABRIC(x) x
134 #else
135 #define DEBUG_FABRIC(x)
136 #endif /* DEBUG_ISP2x00_FABRIC */
137
138
139 #if DEBUG_ISP2x00
140 #define ENTER(x) printk("isp2x00 : entering %s()\n", x);
141 #define LEAVE(x) printk("isp2x00 : leaving %s()\n", x);
142 #define DEBUG(x) x
143 #else
144 #define ENTER(x)
145 #define LEAVE(x)
146 #define DEBUG(x)
147 #endif /* DEBUG_ISP2x00 */
148
149 #if DEBUG_ISP2x00_INTR
150 #define ENTER_INTR(x) printk("isp2x00 : entering %s()\n", x);
151 #define LEAVE_INTR(x) printk("isp2x00 : leaving %s()\n", x);
152 #define DEBUG_INTR(x) x
153 #else
154 #define ENTER_INTR(x)
155 #define LEAVE_INTR(x)
156 #define DEBUG_INTR(x)
157 #endif /* DEBUG ISP2x00_INTR */
158
159
160 #if BITS_PER_LONG > 32
161 #define virt_to_bus_low32(x) ((u32) (0xffffffff & virt_to_bus(x)))
162 #define virt_to_bus_high32(x) ((u32) (0xffffffff & (virt_to_bus(x)>>32)))
163 #define bus_to_virt_low32(x) ((u32) (0xffffffff & bus_to_virt(x)))
164 #define bus_to_virt_high32(x) ((u32) (0xffffffff & (bus_to_virt(x)>>32)))
165 #else
166 #define virt_to_bus_low32(x) virt_to_bus(x)
167 #define virt_to_bus_high32(x) 0x0
168 #define bus_to_virt_low32(x) bus_to_virt(x)
169 #define bus_to_virt_high32(x) 0x0
170 #endif
171
172 #define ISP2100_REV_ID1 1
173 #define ISP2100_REV_ID3 3
174 #define ISP2200_REV_ID5 5
175
176 /* host configuration and control registers */
177 #define HOST_HCCR 0xc0 /* host command and control */
178
179 /* pci bus interface registers */
180 #define FLASH_BIOS_ADDR 0x00
181 #define FLASH_BIOS_DATA 0x02
182 #define ISP_CTRL_STATUS 0x06 /* configuration register #1 */
183 #define PCI_INTER_CTL 0x08 /* pci interupt control */
184 #define PCI_INTER_STS 0x0a /* pci interupt status */
185 #define PCI_SEMAPHORE 0x0c /* pci semaphore */
186 #define PCI_NVRAM 0x0e /* pci nvram interface */
187
188 /* mailbox registers */
189 #define MBOX0 0x10 /* mailbox 0 */
190 #define MBOX1 0x12 /* mailbox 1 */
191 #define MBOX2 0x14 /* mailbox 2 */
192 #define MBOX3 0x16 /* mailbox 3 */
193 #define MBOX4 0x18 /* mailbox 4 */
194 #define MBOX5 0x1a /* mailbox 5 */
195 #define MBOX6 0x1c /* mailbox 6 */
196 #define MBOX7 0x1e /* mailbox 7 */
197
198 /* mailbox command complete status codes */
199 #define MBOX_COMMAND_COMPLETE 0x4000
200 #define INVALID_COMMAND 0x4001
201 #define HOST_INTERFACE_ERROR 0x4002
202 #define TEST_FAILED 0x4003
203 #define COMMAND_ERROR 0x4005
204 #define COMMAND_PARAM_ERROR 0x4006
205 #define PORT_ID_USED 0x4007
206 #define LOOP_ID_USED 0x4008
207 #define ALL_IDS_USED 0x4009
208
209 /* async event status codes */
210 #define RESET_DETECTED 0x8001
211 #define SYSTEM_ERROR 0x8002
212 #define REQUEST_TRANSFER_ERROR 0x8003
213 #define RESPONSE_TRANSFER_ERROR 0x8004
214 #define REQUEST_QUEUE_WAKEUP 0x8005
215 #define LIP_OCCURED 0x8010
216 #define LOOP_UP 0x8011
217 #define LOOP_DOWN 0x8012
218 #define LIP_RECEIVED 0x8013
219 #define PORT_DB_CHANGED 0x8014
220 #define CHANGE_NOTIFICATION 0x8015
221 #define SCSI_COMMAND_COMPLETE 0x8020
222 #define POINT_TO_POINT_UP 0x8030
223 #define CONNECTION_MODE 0x8036
224
225 struct Entry_header {
226 u_char entry_type;
227 u_char entry_cnt;
228 u_char sys_def_1;
229 u_char flags;
230 };
231
232 /* entry header type commands */
233 #if BITS_PER_LONG > 32
234 #define ENTRY_COMMAND 0x19
235 #define ENTRY_CONTINUATION 0x0a
236 #else
237 #define ENTRY_COMMAND 0x11
238 #define ENTRY_CONTINUATION 0x02
239 #endif
240
241 #define ENTRY_STATUS 0x03
242 #define ENTRY_MARKER 0x04
243
244
245 /* entry header flag definitions */
246 #define EFLAG_BUSY 2
247 #define EFLAG_BAD_HEADER 4
248 #define EFLAG_BAD_PAYLOAD 8
249
250 #if BITS_PER_LONG > 32
251 struct dataseg {
252 u_int d_base;
253 u_int d_base_hi;
254 u_int d_count;
255 };
256
257 struct Command_Entry {
258 struct Entry_header hdr;
259 u_int handle;
260 u_char target_lun;
261 u_char target_id;
262 u_short expanded_lun;
263 u_short control_flags;
264 u_short rsvd2;
265 u_short time_out;
266 u_short segment_cnt;
267 u_char cdb[16];
268 u_int total_byte_cnt;
269 struct dataseg dataseg[DATASEGS_PER_COMMAND];
270 };
271
272 #else
273 struct dataseg {
274 u_int d_base;
275 u_int d_count;
276 };
277
278 struct Command_Entry {
279 struct Entry_header hdr;
280 u_int handle;
281 u_char target_lun;
282 u_char target_id;
283 u_short expanded_lun;
284 u_short control_flags;
285 u_short rsvd2;
286 u_short time_out;
287 u_short segment_cnt;
288 u_char cdb[16];
289 u_int total_byte_cnt;
290 struct dataseg dataseg[DATASEGS_PER_COMMAND];
291 };
292
293 #endif
294
295
296 /* command entry control flag definitions */
297 #define CFLAG_NODISC 0x01
298 #define CFLAG_HEAD_TAG 0x02
299 #define CFLAG_ORDERED_TAG 0x04
300 #define CFLAG_SIMPLE_TAG 0x08
301 #define CFLAG_TAR_RTN 0x10
302 #define CFLAG_READ 0x20
303 #define CFLAG_WRITE 0x40
304
305 #if BITS_PER_LONG > 32
306 struct Continuation_Entry {
307 struct Entry_header hdr;
308 struct dataseg dataseg[DATASEGS_PER_CONT];
309 };
310 #else
311 struct Continuation_Entry {
312 struct Entry_header hdr;
313 u32 rsvd;
314 struct dataseg dataseg[DATASEGS_PER_CONT];
315 };
316 #endif
317
318 struct Marker_Entry {
319 struct Entry_header hdr;
320 u_int reserved;
321 u_char target_lun;
322 u_char target_id;
323 u_char modifier;
324 u_char expanded_lun;
325 u_char rsvds[52];
326 };
327
328 /* marker entry modifier definitions */
329 #define SYNC_DEVICE 0
330 #define SYNC_TARGET 1
331 #define SYNC_ALL 2
332
333 struct Status_Entry {
334 struct Entry_header hdr;
335 u_int handle;
336 u_short scsi_status;
337 u_short completion_status;
338 u_short state_flags;
339 u_short status_flags;
340 u_short res_info_len;
341 u_short req_sense_len;
342 u_int residual;
343 u_char res_info[8];
344 u_char req_sense_data[32];
345 };
346
347 /* status entry completion status definitions */
348 #define CS_COMPLETE 0x0000
349 #define CS_DMA_ERROR 0x0002
350 #define CS_RESET_OCCURRED 0x0004
351 #define CS_ABORTED 0x0005
352 #define CS_TIMEOUT 0x0006
353 #define CS_DATA_OVERRUN 0x0007
354 #define CS_DATA_UNDERRUN 0x0015
355 #define CS_QUEUE_FULL 0x001c
356 #define CS_PORT_UNAVAILABLE 0x0028
357 #define CS_PORT_LOGGED_OUT 0x0029
358 #define CS_PORT_CONFIG_CHANGED 0x002a
359
360 /* status entry state flag definitions */
361 #define SF_SENT_CDB 0x0400
362 #define SF_TRANSFERRED_DATA 0x0800
363 #define SF_GOT_STATUS 0x1000
364
365 /* status entry status flag definitions */
366 #define STF_BUS_RESET 0x0008
367 #define STF_DEVICE_RESET 0x0010
368 #define STF_ABORTED 0x0020
369 #define STF_TIMEOUT 0x0040
370
371 /* interupt control commands */
372 #define ISP_EN_INT 0x8000
373 #define ISP_EN_RISC 0x0008
374
375 /* host control commands */
376 #define HCCR_NOP 0x0000
377 #define HCCR_RESET 0x1000
378 #define HCCR_PAUSE 0x2000
379 #define HCCR_RELEASE 0x3000
380 #define HCCR_SINGLE_STEP 0x4000
381 #define HCCR_SET_HOST_INTR 0x5000
382 #define HCCR_CLEAR_HOST_INTR 0x6000
383 #define HCCR_CLEAR_RISC_INTR 0x7000
384 #define HCCR_BP_ENABLE 0x8000
385 #define HCCR_BIOS_DISABLE 0x9000
386 #define HCCR_TEST_MODE 0xf000
387
388 #define RISC_BUSY 0x0004
389
390 /* mailbox commands */
391 #define MBOX_NO_OP 0x0000
392 #define MBOX_LOAD_RAM 0x0001
393 #define MBOX_EXEC_FIRMWARE 0x0002
394 #define MBOX_DUMP_RAM 0x0003
395 #define MBOX_WRITE_RAM_WORD 0x0004
396 #define MBOX_READ_RAM_WORD 0x0005
397 #define MBOX_MAILBOX_REG_TEST 0x0006
398 #define MBOX_VERIFY_CHECKSUM 0x0007
399 #define MBOX_ABOUT_FIRMWARE 0x0008
400 #define MBOX_LOAD_RISC_RAM 0x0009
401 #define MBOX_DUMP_RISC_RAM 0x000a
402 #define MBOX_CHECK_FIRMWARE 0x000e
403 #define MBOX_INIT_REQ_QUEUE 0x0010
404 #define MBOX_INIT_RES_QUEUE 0x0011
405 #define MBOX_EXECUTE_IOCB 0x0012
406 #define MBOX_WAKE_UP 0x0013
407 #define MBOX_STOP_FIRMWARE 0x0014
408 #define MBOX_ABORT_IOCB 0x0015
409 #define MBOX_ABORT_DEVICE 0x0016
410 #define MBOX_ABORT_TARGET 0x0017
411 #define MBOX_BUS_RESET 0x0018
412 #define MBOX_STOP_QUEUE 0x0019
413 #define MBOX_START_QUEUE 0x001a
414 #define MBOX_SINGLE_STEP_QUEUE 0x001b
415 #define MBOX_ABORT_QUEUE 0x001c
416 #define MBOX_GET_DEV_QUEUE_STATUS 0x001d
417 #define MBOX_GET_FIRMWARE_STATUS 0x001f
418 #define MBOX_GET_INIT_SCSI_ID 0x0020
419 #define MBOX_GET_RETRY_COUNT 0x0022
420 #define MBOX_GET_TARGET_PARAMS 0x0028
421 #define MBOX_GET_DEV_QUEUE_PARAMS 0x0029
422 #define MBOX_SET_RETRY_COUNT 0x0032
423 #define MBOX_SET_TARGET_PARAMS 0x0038
424 #define MBOX_SET_DEV_QUEUE_PARAMS 0x0039
425 #define MBOX_EXECUTE_IOCB64 0x0054
426 #define MBOX_INIT_FIRMWARE 0x0060
427 #define MBOX_GET_INIT_CB 0x0061
428 #define MBOX_INIT_LIP 0x0062
429 #define MBOX_GET_POS_MAP 0x0063
430 #define MBOX_GET_PORT_DB 0x0064
431 #define MBOX_CLEAR_ACA 0x0065
432 #define MBOX_TARGET_RESET 0x0066
433 #define MBOX_CLEAR_TASK_SET 0x0067
434 #define MBOX_ABORT_TASK_SET 0x0068
435 #define MBOX_GET_FIRMWARE_STATE 0x0069
436 #define MBOX_GET_PORT_NAME 0x006a
437 #define MBOX_SEND_SNS 0x006e
438 #define MBOX_PORT_LOGIN 0x006f
439 #define MBOX_SEND_CHANGE_REQUEST 0x0070
440 #define MBOX_PORT_LOGOUT 0x0071
441
442 #include "qlogicfc_asm.c"
443
444 /* Each element in mbox_param is an 8 bit bitmap where each bit indicates
445 if that mbox should be copied as input. For example 0x2 would mean
446 only copy mbox1. */
447
448 const u_char mbox_param[] =
449 {
450 0x01, /* MBOX_NO_OP */
451 0x1f, /* MBOX_LOAD_RAM */
452 0x03, /* MBOX_EXEC_FIRMWARE */
453 0x1f, /* MBOX_DUMP_RAM */
454 0x07, /* MBOX_WRITE_RAM_WORD */
455 0x03, /* MBOX_READ_RAM_WORD */
456 0xff, /* MBOX_MAILBOX_REG_TEST */
457 0x03, /* MBOX_VERIFY_CHECKSUM */
458 0x01, /* MBOX_ABOUT_FIRMWARE */
459 0xff, /* MBOX_LOAD_RISC_RAM */
460 0xff, /* MBOX_DUMP_RISC_RAM */
461 0x00, /* 0x000b */
462 0x00, /* 0x000c */
463 0x00, /* 0x000d */
464 0x01, /* MBOX_CHECK_FIRMWARE */
465 0x00, /* 0x000f */
466 0x1f, /* MBOX_INIT_REQ_QUEUE */
467 0x2f, /* MBOX_INIT_RES_QUEUE */
468 0x0f, /* MBOX_EXECUTE_IOCB */
469 0x03, /* MBOX_WAKE_UP */
470 0x01, /* MBOX_STOP_FIRMWARE */
471 0x0f, /* MBOX_ABORT_IOCB */
472 0x03, /* MBOX_ABORT_DEVICE */
473 0x07, /* MBOX_ABORT_TARGET */
474 0x03, /* MBOX_BUS_RESET */
475 0x03, /* MBOX_STOP_QUEUE */
476 0x03, /* MBOX_START_QUEUE */
477 0x03, /* MBOX_SINGLE_STEP_QUEUE */
478 0x03, /* MBOX_ABORT_QUEUE */
479 0x03, /* MBOX_GET_DEV_QUEUE_STATUS */
480 0x00, /* 0x001e */
481 0x01, /* MBOX_GET_FIRMWARE_STATUS */
482 0x01, /* MBOX_GET_INIT_SCSI_ID */
483 0x00, /* 0x0021 */
484 0x01, /* MBOX_GET_RETRY_COUNT */
485 0x00, /* 0x0023 */
486 0x00, /* 0x0024 */
487 0x00, /* 0x0025 */
488 0x00, /* 0x0026 */
489 0x00, /* 0x0027 */
490 0x03, /* MBOX_GET_TARGET_PARAMS */
491 0x03, /* MBOX_GET_DEV_QUEUE_PARAMS */
492 0x00, /* 0x002a */
493 0x00, /* 0x002b */
494 0x00, /* 0x002c */
495 0x00, /* 0x002d */
496 0x00, /* 0x002e */
497 0x00, /* 0x002f */
498 0x00, /* 0x0030 */
499 0x00, /* 0x0031 */
500 0x07, /* MBOX_SET_RETRY_COUNT */
501 0x00, /* 0x0033 */
502 0x00, /* 0x0034 */
503 0x00, /* 0x0035 */
504 0x00, /* 0x0036 */
505 0x00, /* 0x0037 */
506 0x0f, /* MBOX_SET_TARGET_PARAMS */
507 0x0f, /* MBOX_SET_DEV_QUEUE_PARAMS */
508 0x00, /* 0x003a */
509 0x00, /* 0x003b */
510 0x00, /* 0x003c */
511 0x00, /* 0x003d */
512 0x00, /* 0x003e */
513 0x00, /* 0x003f */
514 0x00, /* 0x0040 */
515 0x00, /* 0x0041 */
516 0x00, /* 0x0042 */
517 0x00, /* 0x0043 */
518 0x00, /* 0x0044 */
519 0x00, /* 0x0045 */
520 0x00, /* 0x0046 */
521 0x00, /* 0x0047 */
522 0x00, /* 0x0048 */
523 0x00, /* 0x0049 */
524 0x00, /* 0x004a */
525 0x00, /* 0x004b */
526 0x00, /* 0x004c */
527 0x00, /* 0x004d */
528 0x00, /* 0x004e */
529 0x00, /* 0x004f */
530 0x00, /* 0x0050 */
531 0x00, /* 0x0051 */
532 0x00, /* 0x0052 */
533 0x00, /* 0x0053 */
534 0xcf, /* MBOX_EXECUTE_IOCB64 */
535 0x00, /* 0x0055 */
536 0x00, /* 0x0056 */
537 0x00, /* 0x0057 */
538 0x00, /* 0x0058 */
539 0x00, /* 0x0059 */
540 0x00, /* 0x005a */
541 0x00, /* 0x005b */
542 0x00, /* 0x005c */
543 0x00, /* 0x005d */
544 0x00, /* 0x005e */
545 0x00, /* 0x005f */
546 0xff, /* MBOX_INIT_FIRMWARE */
547 0xcd, /* MBOX_GET_INIT_CB */
548 0x01, /* MBOX_INIT_LIP */
549 0xcd, /* MBOX_GET_POS_MAP */
550 0xcf, /* MBOX_GET_PORT_DB */
551 0x03, /* MBOX_CLEAR_ACA */
552 0x03, /* MBOX_TARGET_RESET */
553 0x03, /* MBOX_CLEAR_TASK_SET */
554 0x03, /* MBOX_ABORT_TASK_SET */
555 0x01, /* MBOX_GET_FIRMWARE_STATE */
556 0x03, /* MBOX_GET_PORT_NAME */
557 0x00, /* 0x006b */
558 0x00, /* 0x006c */
559 0x00, /* 0x006d */
560 0xcf, /* MBOX_SEND_SNS */
561 0x0f, /* MBOX_PORT_LOGIN */
562 0x03, /* MBOX_SEND_CHANGE_REQUEST */
563 0x03, /* MBOX_PORT_LOGOUT */
564 };
565
566 #define MAX_MBOX_COMMAND (sizeof(mbox_param)/sizeof(u_short))
567
568
569 struct id_name_map {
570 u64 wwn;
571 u_char loop_id;
572 };
573
574 struct sns_cb {
575 u_short len;
576 u_short res1;
577 u_int response_low;
578 u_int response_high;
579 u_short sub_len;
580 u_short res2;
581 u_char data[44];
582 };
583
584 /* address of instance of this struct is passed to adapter to initialize things
585 */
586 struct init_cb {
587 u_char version;
588 u_char reseverd1[1];
589 u_short firm_opts;
590 u_short max_frame_len;
591 u_short max_iocb;
592 u_short exec_throttle;
593 u_char retry_cnt;
594 u_char retry_delay;
595 u_short node_name[4];
596 u_short hard_addr;
597 u_char reserved2[10];
598 u_short req_queue_out;
599 u_short res_queue_in;
600 u_short req_queue_len;
601 u_short res_queue_len;
602 u_int req_queue_addr_lo;
603 u_int req_queue_addr_high;
604 u_int res_queue_addr_lo;
605 u_int res_queue_addr_high;
606 /* the rest of this structure only applies to the isp2200 */
607 u_short lun_enables;
608 u_char cmd_resource_cnt;
609 u_char notify_resource_cnt;
610 u_short timeout;
611 u_short reserved3;
612 u_short add_firm_opts;
613 u_char res_accum_timer;
614 u_char irq_delay_timer;
615 u_short special_options;
616 u_short reserved4[13];
617 };
618
619 /*
620 * The result queue can be quite a bit smaller since continuation entries
621 * do not show up there:
622 */
623 #define RES_QUEUE_LEN ((QLOGICFC_REQ_QUEUE_LEN + 1) / 8 - 1)
624 #define QUEUE_ENTRY_LEN 64
625
626 #if ISP2x00_FABRIC
627 #define QLOGICFC_MAX_ID 0xff
628 #else
629 #define QLOGICFC_MAX_ID 0x7d
630 #endif
631
632 #define QLOGICFC_MAX_LUN 128
633 #define QLOGICFC_MAX_LOOP_ID 0x7d
634
635 /* adapter_state values */
636 #define AS_FIRMWARE_DEAD -1
637 #define AS_LOOP_DOWN 0
638 #define AS_LOOP_GOOD 1
639 #define AS_REDO_FABRIC_PORTDB 2
640 #define AS_REDO_LOOP_PORTDB 4
641
642 struct isp2x00_hostdata {
643 u_char revision;
644 struct pci_dev *pci_dev;
645 /* result and request queues (shared with isp2x00): */
646 u_int req_in_ptr; /* index of next request slot */
647 u_int res_out_ptr; /* index of next result slot */
648
649 /* this is here so the queues are nicely aligned */
650 long send_marker; /* do we need to send a marker? */
651
652 char res[RES_QUEUE_LEN + 1][QUEUE_ENTRY_LEN];
653 char req[QLOGICFC_REQ_QUEUE_LEN + 1][QUEUE_ENTRY_LEN];
654 struct init_cb control_block;
655 int adapter_state;
656 unsigned long int tag_ages[126];
657 Scsi_Cmnd *handle_ptrs[QLOGICFC_REQ_QUEUE_LEN + 1];
658 unsigned long handle_serials[QLOGICFC_REQ_QUEUE_LEN + 1];
659 struct id_name_map port_db[QLOGICFC_MAX_ID + 1];
660 u_char mbox_done;
661 u64 wwn;
662 u_int port_id;
663 u_char queued;
664 u_char host_id;
665 };
666
667
668 /* queue length's _must_ be power of two: */
669 #define QUEUE_DEPTH(in, out, ql) ((in - out) & (ql))
670 #define REQ_QUEUE_DEPTH(in, out) QUEUE_DEPTH(in, out, \
671 QLOGICFC_REQ_QUEUE_LEN)
672 #define RES_QUEUE_DEPTH(in, out) QUEUE_DEPTH(in, out, RES_QUEUE_LEN)
673
674 static void isp2x00_enable_irqs(struct Scsi_Host *);
675 static void isp2x00_disable_irqs(struct Scsi_Host *);
676 static int isp2x00_init(struct Scsi_Host *);
677 static int isp2x00_reset_hardware(struct Scsi_Host *);
678 static int isp2x00_mbox_command(struct Scsi_Host *, u_short[]);
679 static int isp2x00_return_status(struct Status_Entry *);
680 static void isp2x00_intr_handler(int, void *, struct pt_regs *);
681 static void do_isp2x00_intr_handler(int, void *, struct pt_regs *);
682 static int isp2x00_make_portdb(struct Scsi_Host *);
683
684 #if ISP2x00_FABRIC
685 static int isp2x00_init_fabric(struct Scsi_Host *, struct id_name_map *, int);
686 #endif
687
688 #if USE_NVRAM_DEFAULTS
689 static int isp2x00_get_nvram_defaults(struct Scsi_Host *, struct init_cb *);
690 static u_short isp2x00_read_nvram_word(struct Scsi_Host *, u_short);
691 #endif
692
693 #if DEBUG_ISP2x00
694 static void isp2x00_print_scsi_cmd(Scsi_Cmnd *);
695 #endif
696
697 #if DEBUG_ISP2x00_INTR
698 static void isp2x00_print_status_entry(struct Status_Entry *);
699 #endif
700
701 static struct proc_dir_entry proc_scsi_isp2x00 =
702 {
703 PROC_SCSI_QLOGICFC, 7, "isp2x00",
704 S_IFDIR | S_IRUGO | S_IXUGO, 2
705 };
706
707
708 static inline void isp2x00_enable_irqs(struct Scsi_Host *host)
709 {
710 outw(ISP_EN_INT | ISP_EN_RISC, host->io_port + PCI_INTER_CTL);
711 }
712
713
714 static inline void isp2x00_disable_irqs(struct Scsi_Host *host)
715 {
716 outw(0x0, host->io_port + PCI_INTER_CTL);
717 }
718
719
720 int isp2x00_detect(Scsi_Host_Template * tmpt)
721 {
722 int hosts = 0;
723 int wait_time;
724 struct Scsi_Host *host = NULL;
725 struct isp2x00_hostdata *hostdata;
726 struct pci_dev *pdev = NULL;
727 unsigned short device_ids[2];
728 int i;
729
730
731 ENTER("isp2x00_detect");
732
733 device_ids[0] = PCI_DEVICE_ID_QLOGIC_ISP2100;
734 device_ids[1] = PCI_DEVICE_ID_QLOGIC_ISP2200;
735
736 tmpt->proc_dir = &proc_scsi_isp2x00;
737
738 if (pci_present() == 0) {
739 printk("qlogicfc : PCI not present\n");
740 return 0;
741 }
742
743 for (i=0; i<2; i++){
744 while ((pdev = pci_find_device(PCI_VENDOR_ID_QLOGIC, device_ids[i], pdev))) {
745
746 host = scsi_register(tmpt, sizeof(struct isp2x00_hostdata));
747 host->max_id = QLOGICFC_MAX_ID + 1;
748 host->max_lun = QLOGICFC_MAX_LUN;
749 host->hostt->use_new_eh_code = 1;
750 hostdata = (struct isp2x00_hostdata *) host->hostdata;
751
752 memset(hostdata, 0, sizeof(struct isp2x00_hostdata));
753 hostdata->pci_dev = pdev;
754
755 hostdata->queued = 0;
756 /* set up the control block */
757 hostdata->control_block.version = 0x1;
758 hostdata->control_block.firm_opts = 0x0108;
759 hostdata->control_block.max_frame_len = 2048;
760 hostdata->control_block.max_iocb = 256;
761 hostdata->control_block.exec_throttle = 8;
762 hostdata->control_block.retry_delay = 5;
763 hostdata->control_block.retry_cnt = 1;
764 hostdata->control_block.node_name[0] = 0x0020;
765 hostdata->control_block.node_name[1] = 0xE000;
766 hostdata->control_block.node_name[2] = 0x008B;
767 hostdata->control_block.node_name[3] = 0x0000;
768 hostdata->control_block.hard_addr = 0x0003;
769 hostdata->control_block.req_queue_len = QLOGICFC_REQ_QUEUE_LEN + 1;
770 hostdata->control_block.res_queue_len = RES_QUEUE_LEN + 1;
771 hostdata->control_block.res_queue_addr_lo = virt_to_bus_low32(&hostdata->res);
772 hostdata->control_block.res_queue_addr_high = virt_to_bus_high32(&hostdata->res);
773 hostdata->control_block.req_queue_addr_lo = virt_to_bus_low32(&hostdata->req);
774 hostdata->control_block.req_queue_addr_high = virt_to_bus_high32(&hostdata->req);
775
776
777 hostdata->adapter_state = AS_LOOP_DOWN;
778 hostdata->host_id = hosts;
779
780 if (isp2x00_init(host) || isp2x00_reset_hardware(host)) {
781 scsi_unregister(host);
782 continue;
783 }
784 host->this_id = 0;
785
786 if (request_irq(host->irq, do_isp2x00_intr_handler, SA_INTERRUPT | SA_SHIRQ, "qlogicfc", host)) {
787 printk("qlogicfc%d : interrupt %d already in use\n",
788 hostdata->host_id, host->irq);
789 scsi_unregister(host);
790 continue;
791 }
792 if (check_region(host->io_port, 0xff)) {
793 printk("qlogicfc%d : i/o region 0x%lx-0x%lx already "
794 "in use\n",
795 hostdata->host_id, host->io_port, host->io_port + 0xff);
796 free_irq(host->irq, host);
797 scsi_unregister(host);
798 continue;
799 }
800 request_region(host->io_port, 0xff, "qlogicfc");
801
802 outw(0x0, host->io_port + PCI_SEMAPHORE);
803 outw(HCCR_CLEAR_RISC_INTR, host->io_port + HOST_HCCR);
804 isp2x00_enable_irqs(host);
805 /* wait for the loop to come up */
806 for (wait_time = jiffies + 10 * HZ; wait_time > jiffies && hostdata->adapter_state == AS_LOOP_DOWN;)
807 barrier();
808
809 if (hostdata->adapter_state == AS_LOOP_DOWN) {
810 printk("qlogicfc%d : link is not up\n", hostdata->host_id);
811 }
812 hosts++;
813 }
814 }
815
816
817 /* this busy loop should not be needed but the isp2x00 seems to need
818 some time before recognizing it is attached to a fabric */
819
820 #if ISP2x00_FABRIC
821 for (wait_time = jiffies + 5 * HZ; wait_time > jiffies;)
822 barrier();
823 #endif
824
825 LEAVE("isp2x00_detect");
826
827 return hosts;
828 }
829
830
831 static int isp2x00_make_portdb(struct Scsi_Host *host)
832 {
833
834 short param[8];
835 int i, j;
836 struct id_name_map temp[QLOGICFC_MAX_ID + 1];
837 struct isp2x00_hostdata *hostdata;
838
839 isp2x00_disable_irqs(host);
840
841 memset(temp, 0, sizeof(temp));
842 hostdata = (struct isp2x00_hostdata *) host->hostdata;
843
844 #if ISP2x00_FABRIC
845 for (i = 0x81; i < QLOGICFC_MAX_ID; i++) {
846 param[0] = MBOX_PORT_LOGOUT;
847 param[1] = i << 8;
848 param[2] = 0;
849 param[3] = 0;
850
851 isp2x00_mbox_command(host, param);
852
853 if (param[0] != MBOX_COMMAND_COMPLETE) {
854
855 DEBUG_FABRIC(printk("qlogicfc%d : logout failed %x %x\n", hostdata->host_id, i, param[0]));
856 }
857 }
858 #endif
859
860
861 param[0] = MBOX_GET_INIT_SCSI_ID;
862
863 isp2x00_mbox_command(host, param);
864
865 if (param[0] == MBOX_COMMAND_COMPLETE) {
866 hostdata->port_id = ((u_int) param[3]) << 16;
867 hostdata->port_id |= param[2];
868 temp[0].loop_id = param[1];
869 temp[0].wwn = hostdata->wwn;
870 }
871 else {
872 printk("qlogicfc%d : error getting scsi id.\n", hostdata->host_id);
873 }
874
875 for (i = 0; i <=QLOGICFC_MAX_ID; i++)
876 temp[i].loop_id = temp[0].loop_id;
877
878 for (i = 0, j = 1; i <= QLOGICFC_MAX_LOOP_ID; i++) {
879 param[0] = MBOX_GET_PORT_NAME;
880 param[1] = (i << 8) & 0xff00;
881
882 isp2x00_mbox_command(host, param);
883
884 if (param[0] == MBOX_COMMAND_COMPLETE) {
885 temp[j].loop_id = i;
886 temp[j].wwn = ((u64) (param[2] & 0xff)) << 56;
887 temp[j].wwn |= ((u64) ((param[2] >> 8) & 0xff)) << 48;
888 temp[j].wwn |= ((u64) (param[3] & 0xff)) << 40;
889 temp[j].wwn |= ((u64) ((param[3] >> 8) & 0xff)) << 32;
890 temp[j].wwn |= ((u64) (param[6] & 0xff)) << 24;
891 temp[j].wwn |= ((u64) ((param[6] >> 8) & 0xff)) << 16;
892 temp[j].wwn |= ((u64) (param[7] & 0xff)) << 8;
893 temp[j].wwn |= ((u64) ((param[7] >> 8) & 0xff));
894
895 j++;
896
897 }
898 }
899
900
901 #if ISP2x00_FABRIC
902 isp2x00_init_fabric(host, temp, j);
903 #endif
904
905 for (i = 0; i <= QLOGICFC_MAX_ID; i++) {
906 if (temp[i].wwn != hostdata->port_db[i].wwn) {
907 for (j = 0; j <= QLOGICFC_MAX_ID; j++) {
908 if (temp[j].wwn == hostdata->port_db[i].wwn) {
909 hostdata->port_db[i].loop_id = temp[j].loop_id;
910 break;
911 }
912 }
913 if (j == QLOGICFC_MAX_ID + 1)
914 hostdata->port_db[i].loop_id = temp[0].loop_id;
915
916 for (j = 0; j <= QLOGICFC_MAX_ID; j++) {
917 if (hostdata->port_db[j].wwn == temp[i].wwn || !hostdata->port_db[j].wwn) {
918 break;
919 }
920 }
921 if (j == QLOGICFC_MAX_ID + 1)
922 printk("qlogicfc%d : Too many scsi devices, no more room in port map.\n", hostdata->host_id);
923 if (!hostdata->port_db[j].wwn) {
924 hostdata->port_db[j].loop_id = temp[i].loop_id;
925 hostdata->port_db[j].wwn = temp[i].wwn;
926 }
927 } else
928 hostdata->port_db[i].loop_id = temp[i].loop_id;
929
930 }
931
932 isp2x00_enable_irqs(host);
933
934 return 0;
935 }
936
937
938 #if ISP2x00_FABRIC
939
940 #define FABRIC_PORT 0x7e
941 #define FABRIC_CONTROLLER 0x7f
942 #define FABRIC_SNS 0x80
943
944 int isp2x00_init_fabric(struct Scsi_Host *host, struct id_name_map *port_db, int cur_scsi_id)
945 {
946
947 u_short param[8];
948 u64 wwn;
949 int done = 0;
950 u_short loop_id = 0x81;
951 u_short scsi_id = cur_scsi_id;
952 u_int port_id;
953 struct sns_cb req;
954 u_char sns_response[608];
955 struct isp2x00_hostdata *hostdata;
956
957 hostdata = (struct isp2x00_hostdata *) host->hostdata;
958
959 DEBUG_FABRIC(printk("qlogicfc%d : Checking for a fabric.\n", hostdata->host_id));
960 param[0] = MBOX_GET_PORT_NAME;
961 param[1] = (u16)FABRIC_PORT << 8;
962
963 isp2x00_mbox_command(host, param);
964
965 if (param[0] != MBOX_COMMAND_COMPLETE) {
966 DEBUG_FABRIC(printk("qlogicfc%d : fabric check result %x\n", hostdata->host_id, param[0]));
967 return 0;
968 }
969 printk("qlogicfc%d : Fabric found.\n", hostdata->host_id);
970
971 if (hostdata->adapter_state & AS_REDO_LOOP_PORTDB){
972 memset(&req, 0, sizeof(req));
973
974 req.len = 8;
975 req.response_low = virt_to_bus_low32(sns_response);
976 req.response_high = virt_to_bus_high32(sns_response);
977 req.sub_len = 22;
978 req.data[0] = 0x17;
979 req.data[1] = 0x02;
980 req.data[8] = (u_char) (hostdata->port_id & 0xff);
981 req.data[9] = (u_char) (hostdata->port_id >> 8 & 0xff);
982 req.data[10] = (u_char) (hostdata->port_id >> 16 & 0xff);
983 req.data[13] = 0x01;
984 param[0] = MBOX_SEND_SNS;
985 param[1] = 30;
986 param[2] = virt_to_bus_low32(&req) >> 16;
987 param[3] = virt_to_bus_low32(&req);
988 param[6] = virt_to_bus_high32(&req) >> 16;
989 param[7] = virt_to_bus_high32(&req);
990
991 isp2x00_mbox_command(host, param);
992
993 if (param[0] != MBOX_COMMAND_COMPLETE)
994 printk("qlogicfc%d : error sending RFC-4\n", hostdata->host_id);
995 }
996
997 port_id = hostdata->port_id;
998 while (!done) {
999 memset(&req, 0, sizeof(req));
1000
1001 req.len = 304;
1002 req.response_low = virt_to_bus_low32(sns_response);
1003 req.response_high = virt_to_bus_high32(sns_response);
1004 req.sub_len = 6;
1005 req.data[0] = 0x00;
1006 req.data[1] = 0x01;
1007 req.data[8] = (u_char) (port_id & 0xff);
1008 req.data[9] = (u_char) (port_id >> 8 & 0xff);
1009 req.data[10] = (u_char) (port_id >> 16 & 0xff);
1010
1011 param[0] = MBOX_SEND_SNS;
1012 param[1] = 14;
1013 param[2] = virt_to_bus_low32(&req) >> 16;
1014 param[3] = virt_to_bus_low32(&req);
1015 param[6] = virt_to_bus_high32(&req) >> 16;
1016 param[7] = virt_to_bus_high32(&req);
1017
1018 isp2x00_mbox_command(host, param);
1019
1020 if (param[0] == MBOX_COMMAND_COMPLETE) {
1021 DEBUG_FABRIC(printk("qlogicfc%d : found node %02x%02x%02x%02x%02x%02x%02x%02x ", hostdata->host_id, sns_response[20], sns_response[21], sns_response[22], sns_response[23], sns_response[24], sns_response[25], sns_response[26], sns_response[27]));
1022 DEBUG_FABRIC(printk(" port id: %02x%02x%02x\n", sns_response[17], sns_response[18], sns_response[19]));
1023 port_id = ((u_int) sns_response[17]) << 16;
1024 port_id |= ((u_int) sns_response[18]) << 8;
1025 port_id |= ((u_int) sns_response[19]);
1026 wwn = ((u64) sns_response[20]) << 56;
1027 wwn |= ((u64) sns_response[21]) << 48;
1028 wwn |= ((u64) sns_response[22]) << 40;
1029 wwn |= ((u64) sns_response[23]) << 32;
1030 wwn |= ((u64) sns_response[24]) << 24;
1031 wwn |= ((u64) sns_response[25]) << 16;
1032 wwn |= ((u64) sns_response[26]) << 8;
1033 wwn |= ((u64) sns_response[27]);
1034 if (hostdata->port_id >> 8 != port_id >> 8) {
1035 DEBUG_FABRIC(printk("qlogicfc%d : adding a fabric port: %x\n", hostdata->host_id, port_id));
1036 param[0] = MBOX_PORT_LOGIN;
1037 param[1] = loop_id << 8;
1038 param[2] = (u_short) (port_id >> 16);
1039 param[3] = (u_short) (port_id);
1040
1041 isp2x00_mbox_command(host, param);
1042
1043 if (param[0] == MBOX_COMMAND_COMPLETE) {
1044 port_db[scsi_id].wwn = wwn;
1045 port_db[scsi_id].loop_id = loop_id;
1046 loop_id++;
1047 scsi_id++;
1048 } else {
1049 printk("qlogicfc%d : Error performing port login %x\n", hostdata->host_id, param[0]);
1050 DEBUG_FABRIC(printk("qlogicfc%d : loop_id: %x\n", hostdata->host_id, loop_id));
1051 param[0] = MBOX_PORT_LOGOUT;
1052 param[1] = loop_id << 8;
1053 param[2] = 0;
1054 param[3] = 0;
1055
1056 isp2x00_mbox_command(host, param);
1057
1058 }
1059
1060 }
1061 if (hostdata->port_id == port_id)
1062 done = 1;
1063 } else {
1064 printk("qlogicfc%d : Get All Next failed %x.\n", hostdata->host_id, param[0]);
1065 return 0;
1066 }
1067 }
1068
1069 return 1;
1070 }
1071
1072 #endif /* ISP2x00_FABRIC */
1073
1074
1075 int isp2x00_release(struct Scsi_Host *host)
1076 {
1077 struct isp2x00_hostdata *hostdata;
1078
1079 ENTER("isp2x00_release");
1080
1081 hostdata = (struct isp2x00_hostdata *) host->hostdata;
1082
1083 outw(0x0, host->io_port + PCI_INTER_CTL);
1084 free_irq(host->irq, host);
1085
1086 release_region(host->io_port, 0xff);
1087
1088 LEAVE("isp2x00_release");
1089
1090 return 0;
1091 }
1092
1093
1094 const char *isp2x00_info(struct Scsi_Host *host)
1095 {
1096 static char buf[80];
1097 struct isp2x00_hostdata *hostdata;
1098 ENTER("isp2x00_info");
1099
1100 hostdata = (struct isp2x00_hostdata *) host->hostdata;
1101 sprintf(buf,
1102 "QLogic ISP%04x SCSI on PCI bus %02x device %02x irq %d base 0x%lx",
1103 hostdata->pci_dev->device, hostdata->pci_dev->bus->number, hostdata->pci_dev->devfn, host->irq,
1104 host->io_port);
1105
1106
1107 LEAVE("isp2x00_info");
1108
1109 return buf;
1110 }
1111
1112
1113 /*
1114 * The middle SCSI layer ensures that queuecommand never gets invoked
1115 * concurrently with itself or the interrupt handler (though the
1116 * interrupt handler may call this routine as part of
1117 * request-completion handling).
1118 */
1119 int isp2x00_queuecommand(Scsi_Cmnd * Cmnd, void (*done) (Scsi_Cmnd *))
1120 {
1121 int i, sg_count, n, num_free;
1122 u_int in_ptr, out_ptr;
1123 struct dataseg *ds;
1124 struct scatterlist *sg;
1125 struct Command_Entry *cmd;
1126 struct Continuation_Entry *cont;
1127 struct Scsi_Host *host;
1128 struct isp2x00_hostdata *hostdata;
1129
1130 ENTER("isp2x00_queuecommand");
1131
1132 host = Cmnd->host;
1133 hostdata = (struct isp2x00_hostdata *) host->hostdata;
1134 Cmnd->scsi_done = done;
1135
1136 DEBUG(isp2x00_print_scsi_cmd(Cmnd));
1137
1138 if (hostdata->adapter_state & AS_REDO_FABRIC_PORTDB || hostdata->adapter_state & AS_REDO_LOOP_PORTDB) {
1139 isp2x00_make_portdb(host);
1140 hostdata->adapter_state = AS_LOOP_GOOD;
1141 printk("qlogicfc%d : Port Database\n", hostdata->host_id);
1142 for (i = 0; hostdata->port_db[i].wwn != 0; i++) {
1143 printk("wwn: %08x%08x scsi_id: %x loop_id: %x\n", (u_int) (hostdata->port_db[i].wwn >> 32), (u_int) hostdata->port_db[i].wwn, i, hostdata->port_db[i].loop_id);
1144 }
1145 }
1146 if (hostdata->adapter_state == AS_FIRMWARE_DEAD) {
1147 printk("qlogicfc%d : The firmware is dead, just return.\n", hostdata->host_id);
1148 host->max_id = 0;
1149 return 0;
1150 }
1151
1152 out_ptr = inw(host->io_port + MBOX4);
1153 in_ptr = hostdata->req_in_ptr;
1154
1155 DEBUG(printk("qlogicfc%d : request queue depth %d\n", hostdata->host_id,
1156 REQ_QUEUE_DEPTH(in_ptr, out_ptr)));
1157
1158 cmd = (struct Command_Entry *) &hostdata->req[in_ptr][0];
1159 in_ptr = (in_ptr + 1) & QLOGICFC_REQ_QUEUE_LEN;
1160 if (in_ptr == out_ptr) {
1161 DEBUG(printk("qlogicfc%d : request queue overflow\n", hostdata->host_id));
1162 return 1;
1163 }
1164 if (hostdata->send_marker) {
1165 struct Marker_Entry *marker;
1166
1167 TRACE("queue marker", in_ptr, 0);
1168
1169 DEBUG(printk("qlogicfc%d : adding marker entry\n", hostdata->host_id));
1170 marker = (struct Marker_Entry *) cmd;
1171 memset(marker, 0, sizeof(struct Marker_Entry));
1172
1173 marker->hdr.entry_type = ENTRY_MARKER;
1174 marker->hdr.entry_cnt = 1;
1175 marker->modifier = SYNC_ALL;
1176
1177 hostdata->send_marker = 0;
1178
1179 if (((in_ptr + 1) & QLOGICFC_REQ_QUEUE_LEN) == out_ptr) {
1180 outw(in_ptr, host->io_port + MBOX4);
1181 hostdata->req_in_ptr = in_ptr;
1182 DEBUG(printk("qlogicfc%d : request queue overflow\n", hostdata->host_id));
1183 return 1;
1184 }
1185 cmd = (struct Command_Entry *) &hostdata->req[in_ptr][0];
1186 in_ptr = (in_ptr + 1) & QLOGICFC_REQ_QUEUE_LEN;
1187 }
1188 TRACE("queue command", in_ptr, Cmnd);
1189
1190 memset(cmd, 0, sizeof(struct Command_Entry));
1191
1192 /* find a free handle mapping slot */
1193 for (i = in_ptr; i != (in_ptr - 1) && hostdata->handle_ptrs[i]; i = ((i + 1) % (QLOGICFC_REQ_QUEUE_LEN + 1)));
1194
1195 if (!hostdata->handle_ptrs[i]) {
1196 cmd->handle = i;
1197 hostdata->handle_ptrs[i] = Cmnd;
1198 hostdata->handle_serials[i] = Cmnd->serial_number;
1199 } else {
1200 printk("qlogicfc%d : no handle slots, this should not happen.\n", hostdata->host_id);
1201 printk("hostdata->queued is %x, in_ptr: %x\n", hostdata->queued, in_ptr);
1202 for (i = 0; i <= QLOGICFC_REQ_QUEUE_LEN; i++){
1203 if (!hostdata->handle_ptrs[i]){
1204 printk("slot %d has %p\n", i, hostdata->handle_ptrs[i]);
1205 }
1206 }
1207 }
1208
1209 cmd->hdr.entry_type = ENTRY_COMMAND;
1210 cmd->hdr.entry_cnt = 1;
1211 cmd->target_lun = Cmnd->lun;
1212 cmd->expanded_lun = Cmnd->lun;
1213 #if ISP2x00_PORTDB
1214 cmd->target_id = hostdata->port_db[Cmnd->target].loop_id;
1215 #else
1216 cmd->target_id = Cmnd->target;
1217 #endif
1218 cmd->total_byte_cnt = (u_int) Cmnd->request_bufflen;
1219 cmd->time_out = 0;
1220 memcpy(cmd->cdb, Cmnd->cmnd, Cmnd->cmd_len);
1221
1222 if (Cmnd->use_sg) {
1223 cmd->segment_cnt = sg_count = Cmnd->use_sg;
1224 sg = (struct scatterlist *) Cmnd->request_buffer;
1225 ds = cmd->dataseg;
1226 /* fill in first two sg entries: */
1227 n = sg_count;
1228 if (n > DATASEGS_PER_COMMAND)
1229 n = DATASEGS_PER_COMMAND;
1230
1231 for (i = 0; i < n; i++) {
1232 ds[i].d_base = virt_to_bus_low32(sg->address);
1233 #if BITS_PER_LONG > 32
1234 ds[i].d_base_hi = virt_to_bus_high32(sg->address);
1235 #endif
1236 ds[i].d_count = sg->length;
1237 ++sg;
1238 }
1239 sg_count -= DATASEGS_PER_COMMAND;
1240
1241 while (sg_count > 0) {
1242 ++cmd->hdr.entry_cnt;
1243 cont = (struct Continuation_Entry *)
1244 &hostdata->req[in_ptr][0];
1245 memset(cont, 0, sizeof(struct Continuation_Entry));
1246 in_ptr = (in_ptr + 1) & QLOGICFC_REQ_QUEUE_LEN;
1247 if (in_ptr == out_ptr) {
1248 DEBUG(printk("qlogicfc%d : unexpected request queue overflow\n", hostdata->host_id));
1249 return 1;
1250 }
1251 TRACE("queue continuation", in_ptr, 0);
1252 cont->hdr.entry_type = ENTRY_CONTINUATION;
1253 ds = cont->dataseg;
1254 n = sg_count;
1255 if (n > DATASEGS_PER_CONT)
1256 n = DATASEGS_PER_CONT;
1257 for (i = 0; i < n; ++i) {
1258 ds[i].d_base = virt_to_bus_low32(sg->address);
1259 #if BITS_PER_LONG > 32
1260 ds[i].d_base_hi = virt_to_bus_high32(sg->address);
1261 #endif
1262 ds[i].d_count = sg->length;
1263 ++sg;
1264 }
1265 sg_count -= n;
1266 }
1267 } else {
1268 cmd->dataseg[0].d_base = virt_to_bus_low32(Cmnd->request_buffer);
1269 #if BITS_PER_LONG > 32
1270 cmd->dataseg[0].d_base_hi = virt_to_bus_high32(Cmnd->request_buffer);
1271 #endif
1272 cmd->dataseg[0].d_count = (u_int) Cmnd->request_bufflen;
1273 cmd->segment_cnt = 1;
1274 }
1275
1276 switch (Cmnd->cmnd[0]) {
1277 case TEST_UNIT_READY:
1278 case START_STOP:
1279 break;
1280 case WRITE_10:
1281 case WRITE_6:
1282 case WRITE_BUFFER:
1283 case MODE_SELECT:
1284 cmd->control_flags = CFLAG_WRITE;
1285 break;
1286 case REQUEST_SENSE:
1287 /* scsi.c expects sense info in a different buffer */
1288 cmd->dataseg[0].d_base = virt_to_bus_low32(Cmnd->sense_buffer);
1289 #if BITS_PER_LONG > 32
1290 cmd->dataseg[0].d_base_hi = virt_to_bus_high32(Cmnd->request_buffer);
1291 #endif
1292 cmd->segment_cnt = 1;
1293 cmd->control_flags = CFLAG_READ;
1294 break;
1295 default:
1296 cmd->control_flags = CFLAG_READ;
1297 break;
1298 }
1299
1300
1301 if (Cmnd->device->tagged_supported) {
1302 if ((jiffies - hostdata->tag_ages[Cmnd->target]) > (2 * SCSI_TIMEOUT)) {
1303 cmd->control_flags |= CFLAG_ORDERED_TAG;
1304 hostdata->tag_ages[Cmnd->target] = jiffies;
1305 } else
1306 switch (Cmnd->tag) {
1307 case HEAD_OF_QUEUE_TAG:
1308 cmd->control_flags |= CFLAG_HEAD_TAG;
1309 break;
1310 case ORDERED_QUEUE_TAG:
1311 cmd->control_flags |= CFLAG_ORDERED_TAG;
1312 break;
1313 default:
1314 cmd->control_flags |= CFLAG_SIMPLE_TAG;
1315 break;
1316 }
1317 }
1318 outw(in_ptr, host->io_port + MBOX4);
1319 hostdata->req_in_ptr = in_ptr;
1320
1321 hostdata->queued++;
1322
1323 num_free = QLOGICFC_REQ_QUEUE_LEN - REQ_QUEUE_DEPTH(in_ptr, out_ptr);
1324 num_free = (num_free > 2) ? num_free - 2 : 0;
1325 host->can_queue = hostdata->queued + num_free;
1326 if (host->can_queue > QLOGICFC_REQ_QUEUE_LEN)
1327 host->can_queue = QLOGICFC_REQ_QUEUE_LEN;
1328 host->sg_tablesize = QLOGICFC_MAX_SG(num_free);
1329
1330 /* this is really gross */
1331 if (host->can_queue <= host->host_busy){
1332 if (host->can_queue+2 < host->host_busy)
1333 DEBUG(printk("qlogicfc%d.c crosses its fingers.\n", hostdata->host_id));
1334 host->can_queue = host->host_busy + 1;
1335 }
1336
1337 LEAVE("isp2x00_queuecommand");
1338
1339 return 0;
1340 }
1341
1342
1343 #define ASYNC_EVENT_INTERRUPT 0x01
1344
1345
1346 void do_isp2x00_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
1347 {
1348 unsigned long flags;
1349
1350 spin_lock_irqsave(&io_request_lock, flags);
1351 isp2x00_intr_handler(irq, dev_id, regs);
1352 spin_unlock_irqrestore(&io_request_lock, flags);
1353 }
1354
1355 void isp2x00_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
1356 {
1357 Scsi_Cmnd *Cmnd;
1358 struct Status_Entry *sts;
1359 struct Scsi_Host *host = dev_id;
1360 struct isp2x00_hostdata *hostdata;
1361 u_int in_ptr, out_ptr, handle, num_free;
1362 u_short status;
1363
1364 ENTER_INTR("isp2x00_intr_handler");
1365
1366 hostdata = (struct isp2x00_hostdata *) host->hostdata;
1367
1368 DEBUG_INTR(printk("qlogicfc%d : interrupt on line %d\n", hostdata->host_id, irq));
1369
1370 if (!(inw(host->io_port + PCI_INTER_STS) & 0x08)) {
1371 /* spurious interrupts can happen legally */
1372 DEBUG_INTR(printk("qlogicfc%d : got spurious interrupt\n", hostdata->host_id));
1373 return;
1374 }
1375 in_ptr = inw(host->io_port + MBOX5);
1376 out_ptr = hostdata->res_out_ptr;
1377
1378 if ((inw(host->io_port + PCI_SEMAPHORE) & ASYNC_EVENT_INTERRUPT)) {
1379 status = inw(host->io_port + MBOX0);
1380
1381 DEBUG_INTR(printk("qlogicfc%d : mbox completion status: %x\n",
1382 hostdata->host_id, status));
1383
1384 switch (status) {
1385 case LOOP_UP:
1386 case POINT_TO_POINT_UP:
1387 printk("qlogicfc%d : link is up\n", hostdata->host_id);
1388 hostdata->adapter_state = AS_REDO_FABRIC_PORTDB | AS_REDO_LOOP_PORTDB;
1389 break;
1390 case LOOP_DOWN:
1391 printk("qlogicfc%d : link is down\n", hostdata->host_id);
1392 hostdata->adapter_state = AS_LOOP_DOWN;
1393 break;
1394 case CONNECTION_MODE:
1395 printk("received CONNECTION_MODE irq %x\n", inw(host->io_port + MBOX1));
1396 break;
1397 case CHANGE_NOTIFICATION:
1398 if (hostdata->adapter_state == AS_LOOP_GOOD)
1399 hostdata->adapter_state = AS_REDO_FABRIC_PORTDB;
1400 break;
1401 case LIP_OCCURED:
1402 case PORT_DB_CHANGED:
1403 case LIP_RECEIVED:
1404 if (hostdata->adapter_state == AS_LOOP_GOOD)
1405 hostdata->adapter_state = AS_REDO_LOOP_PORTDB;
1406 break;
1407 case SYSTEM_ERROR:
1408 printk("qlogicfc%d : The firmware just choked.\n", hostdata->host_id);
1409 hostdata->adapter_state = AS_FIRMWARE_DEAD;
1410 break;
1411 case SCSI_COMMAND_COMPLETE:
1412 handle = inw(host->io_port + MBOX1) | (inw(host->io_port + MBOX2) << 16);
1413 Cmnd = hostdata->handle_ptrs[handle];
1414 hostdata->handle_ptrs[handle] = NULL;
1415 hostdata->handle_serials[handle] = 0;
1416 hostdata->queued--;
1417 if (Cmnd != NULL) {
1418 Cmnd->result = 0x0;
1419 (*Cmnd->scsi_done) (Cmnd);
1420 } else
1421 printk("qlogicfc%d.c : got a null value out of handle_ptrs, this sucks\n", hostdata->host_id);
1422 break;
1423 case MBOX_COMMAND_COMPLETE:
1424 case INVALID_COMMAND:
1425 case HOST_INTERFACE_ERROR:
1426 case TEST_FAILED:
1427 case COMMAND_ERROR:
1428 case COMMAND_PARAM_ERROR:
1429 case PORT_ID_USED:
1430 case LOOP_ID_USED:
1431 case ALL_IDS_USED:
1432 hostdata->mbox_done = 1;
1433 outw(HCCR_CLEAR_RISC_INTR, host->io_port + HOST_HCCR);
1434 return;
1435 default:
1436 printk("qlogicfc%d : got an unknown status? %x\n", hostdata->host_id, status);
1437 }
1438 outw(0x0, host->io_port + PCI_SEMAPHORE);
1439 } else {
1440 DEBUG_INTR(printk("qlogicfc%d : response queue update\n", hostdata->host_id));
1441 DEBUG_INTR(printk("qlogicfc%d : response queue depth %d\n", hostdata->host_id, RES_QUEUE_DEPTH(in_ptr, out_ptr)));
1442
1443 while (out_ptr != in_ptr) {
1444 sts = (struct Status_Entry *) &hostdata->res[out_ptr][0];
1445 out_ptr = (out_ptr + 1) & RES_QUEUE_LEN;
1446
1447 TRACE("done", out_ptr, Cmnd);
1448 DEBUG_INTR(isp2x00_print_status_entry(sts));
1449 if (sts->hdr.entry_type == ENTRY_STATUS && (Cmnd = hostdata->handle_ptrs[sts->handle])) {
1450 Cmnd->result = isp2x00_return_status(sts);
1451 hostdata->handle_ptrs[sts->handle] = NULL;
1452 hostdata->queued--;
1453
1454 /*
1455 * if any of the following are true we do not
1456 * call scsi_done. if the status is CS_ABORTED
1457 * we dont have to call done because the upper
1458 * level should already know its aborted.
1459 */
1460 if (hostdata->handle_serials[sts->handle] != Cmnd->serial_number
1461 || sts->completion_status == CS_ABORTED){
1462 hostdata->handle_serials[sts->handle] = 0;
1463 outw(out_ptr, host->io_port + MBOX5);
1464 continue;
1465 }
1466 /*
1467 * if we get back an error indicating the port
1468 * is not there or if the link is down and
1469 * this is a device that used to be there
1470 * allow the command to timeout.
1471 * the device may well be back in a couple of
1472 * seconds.
1473 */
1474 if ((hostdata->adapter_state == AS_LOOP_DOWN || sts->completion_status == CS_PORT_UNAVAILABLE || sts->completion_status == CS_PORT_LOGGED_OUT || sts->completion_status == CS_PORT_CONFIG_CHANGED) && hostdata->port_db[Cmnd->target].wwn){
1475 outw(out_ptr, host->io_port + MBOX5);
1476 continue;
1477 }
1478 } else {
1479 outw(out_ptr, host->io_port + MBOX5);
1480 continue;
1481 }
1482
1483 if (sts->completion_status == CS_RESET_OCCURRED
1484 || (sts->status_flags & STF_BUS_RESET))
1485 hostdata->send_marker = 1;
1486
1487 memset(Cmnd->sense_buffer, 0, sizeof(Cmnd->sense_buffer));
1488 if (sts->scsi_status & 0x0200)
1489 memcpy(Cmnd->sense_buffer, sts->req_sense_data,
1490 sizeof(Cmnd->sense_buffer));
1491
1492 outw(out_ptr, host->io_port + MBOX5);
1493
1494 if (Cmnd->scsi_done != NULL) {
1495 (*Cmnd->scsi_done) (Cmnd);
1496 } else
1497 printk("qlogicfc%d : Ouch, scsi done is NULL\n", hostdata->host_id);
1498 }
1499 hostdata->res_out_ptr = out_ptr;
1500 }
1501
1502
1503 out_ptr = inw(host->io_port + MBOX4);
1504 in_ptr = hostdata->req_in_ptr;
1505
1506 num_free = QLOGICFC_REQ_QUEUE_LEN - REQ_QUEUE_DEPTH(in_ptr, out_ptr);
1507 num_free = (num_free > 2) ? num_free - 2 : 0;
1508 host->can_queue = hostdata->queued + num_free;
1509 if (host->can_queue > QLOGICFC_REQ_QUEUE_LEN)
1510 host->can_queue = QLOGICFC_REQ_QUEUE_LEN;
1511 host->sg_tablesize = QLOGICFC_MAX_SG(num_free);
1512
1513 if (host->can_queue <= host->host_busy){
1514 if (host->can_queue+2 < host->host_busy)
1515 DEBUG(printk("qlogicfc%d : crosses its fingers.\n", hostdata->host_id));
1516 host->can_queue = host->host_busy + 1;
1517 }
1518
1519 outw(HCCR_CLEAR_RISC_INTR, host->io_port + HOST_HCCR);
1520 LEAVE_INTR("isp2x00_intr_handler");
1521 }
1522
1523
1524 static int isp2x00_return_status(struct Status_Entry *sts)
1525 {
1526 int host_status = DID_ERROR;
1527 #if DEBUG_ISP2x00_INTR
1528 static char *reason[] =
1529 {
1530 "DID_OK",
1531 "DID_NO_CONNECT",
1532 "DID_BUS_BUSY",
1533 "DID_TIME_OUT",
1534 "DID_BAD_TARGET",
1535 "DID_ABORT",
1536 "DID_PARITY",
1537 "DID_ERROR",
1538 "DID_RESET",
1539 "DID_BAD_INTR"
1540 };
1541 #endif /* DEBUG_ISP2x00_INTR */
1542
1543 ENTER("isp2x00_return_status");
1544
1545 DEBUG(printk("qlogicfc : completion status = 0x%04x\n",
1546 sts->completion_status));
1547
1548 switch (sts->completion_status) {
1549 case CS_COMPLETE:
1550 host_status = DID_OK;
1551 break;
1552 case CS_DMA_ERROR:
1553 host_status = DID_ERROR;
1554 break;
1555 case CS_RESET_OCCURRED:
1556 host_status = DID_RESET;
1557 break;
1558 case CS_ABORTED:
1559 host_status = DID_ABORT;
1560 break;
1561 case CS_TIMEOUT:
1562 host_status = DID_TIME_OUT;
1563 break;
1564 case CS_DATA_OVERRUN:
1565 host_status = DID_ERROR;
1566 break;
1567 case CS_DATA_UNDERRUN:
1568 host_status = DID_OK;
1569 break;
1570 case CS_PORT_UNAVAILABLE:
1571 case CS_PORT_LOGGED_OUT:
1572 case CS_PORT_CONFIG_CHANGED:
1573 host_status = DID_BAD_TARGET;
1574 break;
1575 case CS_QUEUE_FULL:
1576 host_status = DID_ERROR;
1577 break;
1578 default:
1579 printk("qlogicfc : unknown completion status 0x%04x\n",
1580 sts->completion_status);
1581 host_status = DID_ERROR;
1582 break;
1583 }
1584
1585 DEBUG_INTR(printk("qlogicfc : host status (%s) scsi status %x\n",
1586 reason[host_status], sts->scsi_status));
1587
1588 LEAVE("isp2x00_return_status");
1589
1590 return (sts->scsi_status & STATUS_MASK) | (host_status << 16);
1591 }
1592
1593
1594 int isp2x00_abort(Scsi_Cmnd * Cmnd)
1595 {
1596 u_short param[8];
1597 int i;
1598 struct Scsi_Host *host;
1599 struct isp2x00_hostdata *hostdata;
1600 int return_status = SUCCESS;
1601
1602 ENTER("isp2x00_abort");
1603
1604 host = Cmnd->host;
1605 hostdata = (struct isp2x00_hostdata *) host->hostdata;
1606
1607 for (i = 0; i < QLOGICFC_REQ_QUEUE_LEN; i++)
1608 if (hostdata->handle_ptrs[i] == Cmnd)
1609 break;
1610
1611 if (i == QLOGICFC_REQ_QUEUE_LEN){
1612 return SUCCESS;
1613 }
1614
1615 isp2x00_disable_irqs(host);
1616
1617 param[0] = MBOX_ABORT_IOCB;
1618 #if ISP2x00_PORTDB
1619 param[1] = (((u_short) hostdata->port_db[Cmnd->target].loop_id) << 8) | Cmnd->lun;
1620 #else
1621 param[1] = (((u_short) Cmnd->target) << 8) | Cmnd->lun;
1622 #endif
1623 param[2] = i & 0xffff;
1624 param[3] = i >> 16;
1625
1626 isp2x00_mbox_command(host, param);
1627
1628 if (param[0] != MBOX_COMMAND_COMPLETE) {
1629 printk("qlogicfc%d : scsi abort failure: %x\n", hostdata->host_id, param[0]);
1630 if (param[0] == 0x4005)
1631 Cmnd->result = DID_ERROR << 16;
1632 if (param[0] == 0x4006)
1633 Cmnd->result = DID_BAD_TARGET << 16;
1634 return_status = FAILED;
1635 }
1636
1637 if (return_status != SUCCESS){
1638 param[0] = MBOX_GET_FIRMWARE_STATE;
1639 isp2x00_mbox_command(host, param);
1640 printk("qlogicfc%d : abort failed\n", hostdata->host_id);
1641 printk("qlogicfc%d : firmware status is %x %x\n", hostdata->host_id, param[0], param[1]);
1642 }
1643
1644 isp2x00_enable_irqs(host);
1645
1646 LEAVE("isp2x00_abort");
1647
1648 return return_status;
1649 }
1650
1651
1652 int isp2x00_reset(Scsi_Cmnd * Cmnd, unsigned int reset_flags)
1653 {
1654 u_short param[8];
1655 struct Scsi_Host *host;
1656 struct isp2x00_hostdata *hostdata;
1657 int return_status = SCSI_RESET_SUCCESS;
1658
1659 ENTER("isp2x00_reset");
1660
1661 host = Cmnd->host;
1662 hostdata = (struct isp2x00_hostdata *) host->hostdata;
1663 param[0] = MBOX_BUS_RESET;
1664 param[1] = 3;
1665
1666 isp2x00_disable_irqs(host);
1667
1668 isp2x00_mbox_command(host, param);
1669
1670 if (param[0] != MBOX_COMMAND_COMPLETE) {
1671 printk("qlogicfc%d : scsi bus reset failure: %x\n", hostdata->host_id, param[0]);
1672 return_status = SCSI_RESET_ERROR;
1673 }
1674 isp2x00_enable_irqs(host);
1675
1676 LEAVE("isp2x00_reset");
1677
1678 return return_status;;
1679 }
1680
1681
1682 int isp2x00_biosparam(Disk * disk, kdev_t n, int ip[])
1683 {
1684 int size = disk->capacity;
1685
1686 ENTER("isp2x00_biosparam");
1687
1688 ip[0] = 64;
1689 ip[1] = 32;
1690 ip[2] = size >> 11;
1691 if (ip[2] > 1024) {
1692 ip[0] = 255;
1693 ip[1] = 63;
1694 ip[2] = size / (ip[0] * ip[1]);
1695 }
1696 LEAVE("isp2x00_biosparam");
1697
1698 return 0;
1699 }
1700
1701
1702 static int isp2x00_reset_hardware(struct Scsi_Host *host)
1703 {
1704 u_short param[8];
1705 struct isp2x00_hostdata *hostdata;
1706 int loop_count;
1707
1708 ENTER("isp2x00_reset_hardware");
1709
1710 hostdata = (struct isp2x00_hostdata *) host->hostdata;
1711
1712 outw(0x01, host->io_port + ISP_CTRL_STATUS);
1713 outw(HCCR_RESET, host->io_port + HOST_HCCR);
1714 outw(HCCR_RELEASE, host->io_port + HOST_HCCR);
1715 outw(HCCR_BIOS_DISABLE, host->io_port + HOST_HCCR);
1716
1717 loop_count = DEFAULT_LOOP_COUNT;
1718 while (--loop_count && inw(host->io_port + HOST_HCCR) == RISC_BUSY)
1719 barrier();
1720 if (!loop_count)
1721 printk("qlogicfc%d : reset_hardware loop timeout\n", hostdata->host_id);
1722
1723
1724
1725 #if DEBUG_ISP2x00
1726 printk("qlogicfc%d : mbox 0 0x%04x \n", hostdata->host_id, inw(host->io_port + MBOX0));
1727 printk("qlogicfc%d : mbox 1 0x%04x \n", hostdata->host_id, inw(host->io_port + MBOX1));
1728 printk("qlogicfc%d : mbox 2 0x%04x \n", hostdata->host_id, inw(host->io_port + MBOX2));
1729 printk("qlogicfc%d : mbox 3 0x%04x \n", hostdata->host_id, inw(host->io_port + MBOX3));
1730 printk("qlogicfc%d : mbox 4 0x%04x \n", hostdata->host_id, inw(host->io_port + MBOX4));
1731 printk("qlogicfc%d : mbox 5 0x%04x \n", hostdata->host_id, inw(host->io_port + MBOX5));
1732 printk("qlogicfc%d : mbox 6 0x%04x \n", hostdata->host_id, inw(host->io_port + MBOX6));
1733 printk("qlogicfc%d : mbox 7 0x%04x \n", hostdata->host_id, inw(host->io_port + MBOX7));
1734 #endif /* DEBUG_ISP2x00 */
1735
1736 DEBUG(printk("qlogicfc%d : verifying checksum\n", hostdata->host_id));
1737
1738 #if RELOAD_FIRMWARE
1739 {
1740 int i;
1741 unsigned short * risc_code = NULL;
1742 unsigned short risc_code_len = 0;
1743 if (hostdata->pci_dev->device == PCI_DEVICE_ID_QLOGIC_ISP2100){
1744 risc_code = risc_code2100;
1745 risc_code_len = risc_code_length2100;
1746 }
1747 else if (hostdata->pci_dev->device == PCI_DEVICE_ID_QLOGIC_ISP2200){
1748 risc_code = risc_code2200;
1749 risc_code_len = risc_code_length2200;
1750 }
1751
1752 for (i = 0; i < risc_code_len; i++) {
1753 param[0] = MBOX_WRITE_RAM_WORD;
1754 param[1] = risc_code_addr01 + i;
1755 param[2] = risc_code[i];
1756
1757 isp2x00_mbox_command(host, param);
1758
1759 if (param[0] != MBOX_COMMAND_COMPLETE) {
1760 printk("qlogicfc%d : firmware load failure\n", hostdata->host_id);
1761 return 1;
1762 }
1763 }
1764 }
1765 #endif /* RELOAD_FIRMWARE */
1766
1767 param[0] = MBOX_VERIFY_CHECKSUM;
1768 param[1] = risc_code_addr01;
1769
1770 isp2x00_mbox_command(host, param);
1771
1772 if (param[0] != MBOX_COMMAND_COMPLETE) {
1773 printk("qlogicfc%d : ram checksum failure\n", hostdata->host_id);
1774 return 1;
1775 }
1776 DEBUG(printk("qlogicfc%d : executing firmware\n", hostdata->host_id));
1777
1778 param[0] = MBOX_EXEC_FIRMWARE;
1779 param[1] = risc_code_addr01;
1780
1781 isp2x00_mbox_command(host, param);
1782
1783 param[0] = MBOX_ABOUT_FIRMWARE;
1784
1785 isp2x00_mbox_command(host, param);
1786
1787 if (param[0] != MBOX_COMMAND_COMPLETE) {
1788 printk("qlogicfc%d : about firmware failure\n", hostdata->host_id);
1789 return 1;
1790 }
1791 DEBUG(printk("qlogicfc%d : firmware major revision %d\n", hostdata->host_id, param[1]));
1792 DEBUG(printk("qlogicfc%d : firmware minor revision %d\n", hostdata->host_id, param[2]));
1793
1794 #ifdef USE_NVRAM_DEFAULTS
1795
1796 if (isp2x00_get_nvram_defaults(host, &hostdata->control_block) != 0) {
1797 printk("qlogicfc%d : Could not read from NVRAM\n", hostdata->host_id);
1798 }
1799 #endif
1800
1801 hostdata->wwn = (u64) (hostdata->control_block.node_name[0]) << 56;
1802 hostdata->wwn |= (u64) (hostdata->control_block.node_name[0] & 0xff00) << 48;
1803 hostdata->wwn |= (u64) (hostdata->control_block.node_name[1] & 0xff00) << 24;
1804 hostdata->wwn |= (u64) (hostdata->control_block.node_name[1] & 0x00ff) << 48;
1805 hostdata->wwn |= (u64) (hostdata->control_block.node_name[2] & 0x00ff) << 24;
1806 hostdata->wwn |= (u64) (hostdata->control_block.node_name[2] & 0xff00) << 8;
1807 hostdata->wwn |= (u64) (hostdata->control_block.node_name[3] & 0x00ff) << 8;
1808 hostdata->wwn |= (u64) (hostdata->control_block.node_name[3] & 0xff00) >> 8;
1809
1810 param[0] = MBOX_INIT_FIRMWARE;
1811 param[2] = (u_short) (virt_to_bus_low32(&hostdata->control_block) >> 16);
1812 param[3] = (u_short) (virt_to_bus_low32(&hostdata->control_block) & 0xffff);
1813 param[4] = 0;
1814 param[5] = 0;
1815 param[6] = (u_short) (virt_to_bus_high32(&hostdata->control_block) >> 16);
1816 param[7] = (u_short) (virt_to_bus_high32(&hostdata->control_block) & 0xffff);
1817 isp2x00_mbox_command(host, param);
1818 if (param[0] != MBOX_COMMAND_COMPLETE) {
1819 printk("qlogicfc%d.c: Ouch 0x%04x\n", hostdata->host_id, param[0]);
1820 return 1;
1821 }
1822 param[0] = MBOX_GET_FIRMWARE_STATE;
1823 isp2x00_mbox_command(host, param);
1824 if (param[0] != MBOX_COMMAND_COMPLETE) {
1825 printk("qlogicfc%d.c: 0x%04x\n", hostdata->host_id, param[0]);
1826 return 1;
1827 }
1828
1829 LEAVE("isp2x00_reset_hardware");
1830
1831 return 0;
1832 }
1833
1834 #ifdef USE_NVRAM_DEFAULTS
1835
1836 static int isp2x00_get_nvram_defaults(struct Scsi_Host *host, struct init_cb *control_block)
1837 {
1838
1839 u_short value;
1840 if (isp2x00_read_nvram_word(host, 0) != 0x5349)
1841 return 1;
1842
1843 value = isp2x00_read_nvram_word(host, 8);
1844 control_block->node_name[0] = isp2x00_read_nvram_word(host, 9);
1845 control_block->node_name[1] = isp2x00_read_nvram_word(host, 10);
1846 control_block->node_name[2] = isp2x00_read_nvram_word(host, 11);
1847 control_block->node_name[3] = isp2x00_read_nvram_word(host, 12);
1848 control_block->hard_addr = isp2x00_read_nvram_word(host, 13);
1849
1850 return 0;
1851
1852 }
1853
1854 #endif
1855
1856 static int isp2x00_init(struct Scsi_Host *sh)
1857 {
1858 u_int io_base;
1859 struct isp2x00_hostdata *hostdata;
1860 u_char revision;
1861 u_int irq;
1862 u_short command;
1863 struct pci_dev *pdev;
1864
1865
1866 ENTER("isp2x00_init");
1867
1868 hostdata = (struct isp2x00_hostdata *) sh->hostdata;
1869 pdev = hostdata->pci_dev;
1870
1871 if (pci_read_config_word(pdev, PCI_COMMAND, &command)
1872 || pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision)) {
1873 printk("qlogicfc%d : error reading PCI configuration\n", hostdata->host_id);
1874 return 1;
1875 }
1876 io_base = pdev->resource[0].start;
1877 irq = pdev->irq;
1878
1879
1880 if (pdev->vendor != PCI_VENDOR_ID_QLOGIC) {
1881 printk("qlogicfc%d : 0x%04x is not QLogic vendor ID\n", hostdata->host_id,
1882 pdev->vendor);
1883 return 1;
1884 }
1885 if (pdev->device != PCI_DEVICE_ID_QLOGIC_ISP2100 && pdev->device != PCI_DEVICE_ID_QLOGIC_ISP2200) {
1886 printk("qlogicfc%d : 0x%04x does not match ISP2100 or ISP2200 device id\n", hostdata->host_id,
1887 pdev->device);
1888 return 1;
1889 }
1890 if (!(command & PCI_COMMAND_IO) ||
1891 !(pdev->resource[0].flags & IORESOURCE_IO)) {
1892 printk("qlogicfc%d : i/o mapping is disabled\n", hostdata->host_id);
1893 return 1;
1894 }
1895
1896 if (!(command & PCI_COMMAND_MASTER)) {
1897 printk("qlogicfc%d : bus mastering is disabled\n", hostdata->host_id);
1898 return 1;
1899 }
1900 if (revision != ISP2100_REV_ID1 && revision != ISP2100_REV_ID3 && revision != ISP2200_REV_ID5)
1901 printk("qlogicfc%d : new isp2x00 revision ID (%d)\n", hostdata->host_id, revision);
1902
1903
1904 hostdata->revision = revision;
1905
1906 sh->irq = irq;
1907 sh->io_port = io_base;
1908
1909 LEAVE("isp2x00_init");
1910
1911 return 0;
1912 }
1913
1914 #if USE_NVRAM_DEFAULTS
1915
1916 #define NVRAM_DELAY() udelay(10) /* 10 microsecond delay */
1917
1918
1919 u_short isp2x00_read_nvram_word(struct Scsi_Host * host, u_short byte)
1920 {
1921 int i;
1922 u_short value, output, input;
1923
1924 outw(0x2, host->io_port + PCI_NVRAM);
1925 NVRAM_DELAY();
1926 outw(0x3, host->io_port + PCI_NVRAM);
1927 NVRAM_DELAY();
1928
1929 byte &= 0xff;
1930 byte |= 0x0600;
1931 for (i = 10; i >= 0; i--) {
1932 output = ((byte >> i) & 0x1) ? 0x4 : 0x0;
1933 outw(output | 0x2, host->io_port + PCI_NVRAM);
1934 NVRAM_DELAY();
1935 outw(output | 0x3, host->io_port + PCI_NVRAM);
1936 NVRAM_DELAY();
1937 outw(output | 0x2, host->io_port + PCI_NVRAM);
1938 NVRAM_DELAY();
1939 }
1940
1941 for (i = 0xf, value = 0; i >= 0; i--) {
1942 value <<= 1;
1943 outw(0x3, host->io_port + PCI_NVRAM);
1944 NVRAM_DELAY();
1945 input = inw(host->io_port + PCI_NVRAM);
1946 NVRAM_DELAY();
1947 outw(0x2, host->io_port + PCI_NVRAM);
1948 NVRAM_DELAY();
1949 if (input & 0x8)
1950 value |= 1;
1951 }
1952
1953 outw(0x0, host->io_port + PCI_NVRAM);
1954 NVRAM_DELAY();
1955
1956 return value;
1957 }
1958
1959
1960 #endif /* USE_NVRAM_DEFAULTS */
1961
1962
1963
1964 /*
1965 * currently, this is only called during initialization or abort/reset,
1966 * at which times interrupts are disabled, so polling is OK, I guess...
1967 */
1968 static int isp2x00_mbox_command(struct Scsi_Host *host, u_short param[])
1969 {
1970 int loop_count;
1971 struct isp2x00_hostdata *hostdata = (struct isp2x00_hostdata *) host->hostdata;
1972
1973 if (mbox_param[param[0]] == 0 || hostdata->adapter_state == AS_FIRMWARE_DEAD)
1974 return 1;
1975
1976 loop_count = DEFAULT_LOOP_COUNT;
1977 while (--loop_count && inw(host->io_port + HOST_HCCR) & 0x0080)
1978 barrier();
1979 if (!loop_count) {
1980 printk("qlogicfc%d : mbox_command loop timeout #1\n", hostdata->host_id);
1981 param[0] = 0x4006;
1982 hostdata->adapter_state = AS_FIRMWARE_DEAD;
1983 return 1;
1984 }
1985 hostdata->mbox_done = 0;
1986
1987 if (mbox_param[param[0]] == 0)
1988 printk("qlogicfc%d : invalid mbox command\n", hostdata->host_id);
1989
1990 if (mbox_param[param[0]] & 0x80)
1991 outw(param[7], host->io_port + MBOX7);
1992 if (mbox_param[param[0]] & 0x40)
1993 outw(param[6], host->io_port + MBOX6);
1994 if (mbox_param[param[0]] & 0x20)
1995 outw(param[5], host->io_port + MBOX5);
1996 if (mbox_param[param[0]] & 0x10)
1997 outw(param[4], host->io_port + MBOX4);
1998 if (mbox_param[param[0]] & 0x08)
1999 outw(param[3], host->io_port + MBOX3);
2000 if (mbox_param[param[0]] & 0x04)
2001 outw(param[2], host->io_port + MBOX2);
2002 if (mbox_param[param[0]] & 0x02)
2003 outw(param[1], host->io_port + MBOX1);
2004 if (mbox_param[param[0]] & 0x01)
2005 outw(param[0], host->io_port + MBOX0);
2006
2007
2008 outw(HCCR_SET_HOST_INTR, host->io_port + HOST_HCCR);
2009
2010 while (1) {
2011 loop_count = DEFAULT_LOOP_COUNT;
2012 while (--loop_count && !(inw(host->io_port + PCI_INTER_STS) & 0x08)) {
2013 barrier();
2014 }
2015
2016 if (!loop_count) {
2017 hostdata->adapter_state = AS_FIRMWARE_DEAD;
2018 printk("qlogicfc%d : mbox_command loop timeout #2\n", hostdata->host_id);
2019 break;
2020 }
2021 isp2x00_intr_handler(host->irq, host, NULL);
2022
2023 if (hostdata->mbox_done == 1)
2024 break;
2025
2026 }
2027
2028 loop_count = DEFAULT_LOOP_COUNT;
2029 while (--loop_count && inw(host->io_port + MBOX0) == 0x04) {
2030 barrier();
2031 }
2032 if (!loop_count)
2033 printk("qlogicfc%d : mbox_command loop timeout #3\n", hostdata->host_id);
2034
2035 param[7] = inw(host->io_port + MBOX7);
2036 param[6] = inw(host->io_port + MBOX6);
2037 param[5] = inw(host->io_port + MBOX5);
2038 param[4] = inw(host->io_port + MBOX4);
2039 param[3] = inw(host->io_port + MBOX3);
2040 param[2] = inw(host->io_port + MBOX2);
2041 param[1] = inw(host->io_port + MBOX1);
2042 param[0] = inw(host->io_port + MBOX0);
2043
2044
2045 outw(0x0, host->io_port + PCI_SEMAPHORE);
2046
2047 if (inw(host->io_port + HOST_HCCR) & 0x0080) {
2048 hostdata->adapter_state = AS_FIRMWARE_DEAD;
2049 printk("qlogicfc%d : mbox op is still pending\n", hostdata->host_id);
2050 }
2051 return 0;
2052 }
2053
2054 #if DEBUG_ISP2x00_INTR
2055
2056 void isp2x00_print_status_entry(struct Status_Entry *status)
2057 {
2058 printk("qlogicfc : entry count = 0x%02x, type = 0x%02x, flags = 0x%02x\n",
2059 status->hdr.entry_cnt, status->hdr.entry_type, status->hdr.flags);
2060 printk("qlogicfc : scsi status = 0x%04x, completion status = 0x%04x\n",
2061 status->scsi_status, status->completion_status);
2062 printk("qlogicfc : state flags = 0x%04x, status flags = 0x%04x\n",
2063 status->state_flags, status->status_flags);
2064 printk("qlogicfc : response info length = 0x%04x, request sense length = 0x%04x\n",
2065 status->res_info_len, status->req_sense_len);
2066 printk("qlogicfc : residual transfer length = 0x%08x, response = 0x%02x\n", status->residual, status->res_info[3]);
2067
2068 }
2069
2070 #endif /* DEBUG_ISP2x00_INTR */
2071
2072
2073 #if DEBUG_ISP2x00
2074
2075 void isp2x00_print_scsi_cmd(Scsi_Cmnd * cmd)
2076 {
2077 int i;
2078
2079 printk("qlogicfc : target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
2080 cmd->target, cmd->lun, cmd->cmd_len);
2081 printk("qlogicfc : command = ");
2082 for (i = 0; i < cmd->cmd_len; i++)
2083 printk("0x%02x ", cmd->cmnd[i]);
2084 printk("\n");
2085 }
2086
2087 #endif /* DEBUG_ISP2x00 */
2088
2089
2090 #ifdef MODULE
2091
2092 Scsi_Host_Template driver_template = QLOGICFC;
2093
2094 #include "scsi_module.c"
2095
2096 #endif