2 * QLogic ISP2x00 SCSI-FCP
3 * Written by Erik H. Moe, ehm@cris.com
4 * Copyright 1995, Erik H. Moe
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
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.
17 /* Renamed and updated to 1.3.x by Michael Griffith <grif@cs.ucr.edu> */
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
22 * Big endian support and dynamic DMA mapping added
23 * by Jakub Jelinek <jakub@redhat.com>.
25 * Conversion to final pci64 DMA interfaces
26 * by David S. Miller <davem@redhat.com>.
30 * $Date: 1995/09/22 02:23:15 $
34 * Revision 0.5 1995/09/22 02:23:15 root
35 * do auto request sense
37 * Revision 0.4 1995/08/07 04:44:33 root
38 * supply firmware with driver.
39 * numerous bug fixes/general cleanup of code.
41 * Revision 0.3 1995/07/16 16:15:39 root
42 * added reset/abort code.
44 * Revision 0.2 1995/06/29 03:14:19 root
46 * added queue protocol.
48 * Revision 0.1 1995/06/25 01:55:45 root
53 #include <linux/blkdev.h>
54 #include <linux/kernel.h>
55 #include <linux/string.h>
56 #include <linux/ioport.h>
57 #include <linux/sched.h>
58 #include <linux/types.h>
59 #include <linux/pci.h>
60 #include <linux/delay.h>
61 #include <linux/unistd.h>
62 #include <linux/spinlock.h>
63 #include <linux/interrupt.h>
64 #include <linux/dma-mapping.h>
65 #include <linux/jiffies.h>
69 #include <scsi/scsi_host.h>
71 #define pci64_dma_hi32(a) ((u32) (0xffffffff & (((u64)(a))>>32)))
72 #define pci64_dma_lo32(a) ((u32) (0xffffffff & (((u64)(a)))))
73 #define pci64_dma_build(hi,lo) \
74 ((dma_addr_t)(((u64)(lo))|(((u64)(hi))<<32)))
77 * With the qlogic interface, every queue slot can hold a SCSI
78 * command with up to 2 scatter/gather entries. If we need more
79 * than 2 entries, continuation entries can be used that hold
80 * another 5 entries each. Unlike for other drivers, this means
81 * that the maximum number of scatter/gather entries we can
82 * support at any given time is a function of the number of queue
83 * slots available. That is, host->can_queue and host->sg_tablesize
84 * are dynamic and _not_ independent. This all works fine because
85 * requests are queued serially and the scatter/gather limit is
86 * determined for each queue request anew.
89 #define DATASEGS_PER_COMMAND 2
90 #define DATASEGS_PER_CONT 5
92 #define QLOGICFC_REQ_QUEUE_LEN 255 /* must be power of two - 1 */
93 #define QLOGICFC_MAX_SG(ql) (DATASEGS_PER_COMMAND + (((ql) > 0) ? DATASEGS_PER_CONT*((ql) - 1) : 0))
94 #define QLOGICFC_CMD_PER_LUN 8
96 /* Configuration section **************************************************** */
98 /* Set the following macro to 1 to reload the ISP2x00's firmware. This is
99 version 1.17.30 of the isp2100's firmware and version 2.00.40 of the
103 #define USE_NVRAM_DEFAULTS 1
105 #define ISP2x00_PORTDB 1
107 /* Set the following to 1 to include fabric support, fabric support is
108 * currently not as well tested as the other aspects of the driver */
110 #define ISP2x00_FABRIC 1
112 /* Macros used for debugging */
113 #define DEBUG_ISP2x00 0
114 #define DEBUG_ISP2x00_INT 0
115 #define DEBUG_ISP2x00_INTR 0
116 #define DEBUG_ISP2x00_SETUP 0
117 #define DEBUG_ISP2x00_FABRIC 0
121 #define DEFAULT_LOOP_COUNT 1000000000
123 #define ISP_TIMEOUT (2*HZ)
124 /* End Configuration section ************************************************ */
126 #include <linux/module.h>
130 #define TRACE_BUF_LEN (32*1024)
139 } buf
[TRACE_BUF_LEN
];
142 #define TRACE(w, i, a) \
144 unsigned long flags; \
148 trace.buf[trace.next].name = (w); \
149 trace.buf[trace.next].time = jiffies; \
150 trace.buf[trace.next].index = (i); \
151 trace.buf[trace.next].addr = (long) (a); \
152 trace.next = (trace.next + 1) & (TRACE_BUF_LEN - 1); \
153 restore_flags(flags); \
157 #define TRACE(w, i, a)
160 #if DEBUG_ISP2x00_FABRIC
161 #define DEBUG_FABRIC(x) x
163 #define DEBUG_FABRIC(x)
164 #endif /* DEBUG_ISP2x00_FABRIC */
168 #define ENTER(x) printk("isp2x00 : entering %s()\n", x);
169 #define LEAVE(x) printk("isp2x00 : leaving %s()\n", x);
175 #endif /* DEBUG_ISP2x00 */
177 #if DEBUG_ISP2x00_INTR
178 #define ENTER_INTR(x) printk("isp2x00 : entering %s()\n", x);
179 #define LEAVE_INTR(x) printk("isp2x00 : leaving %s()\n", x);
180 #define DEBUG_INTR(x) x
182 #define ENTER_INTR(x)
183 #define LEAVE_INTR(x)
184 #define DEBUG_INTR(x)
185 #endif /* DEBUG ISP2x00_INTR */
188 #define ISP2100_REV_ID1 1
189 #define ISP2100_REV_ID3 3
190 #define ISP2200_REV_ID5 5
192 /* host configuration and control registers */
193 #define HOST_HCCR 0xc0 /* host command and control */
195 /* pci bus interface registers */
196 #define FLASH_BIOS_ADDR 0x00
197 #define FLASH_BIOS_DATA 0x02
198 #define ISP_CTRL_STATUS 0x06 /* configuration register #1 */
199 #define PCI_INTER_CTL 0x08 /* pci interrupt control */
200 #define PCI_INTER_STS 0x0a /* pci interrupt status */
201 #define PCI_SEMAPHORE 0x0c /* pci semaphore */
202 #define PCI_NVRAM 0x0e /* pci nvram interface */
204 /* mailbox registers */
205 #define MBOX0 0x10 /* mailbox 0 */
206 #define MBOX1 0x12 /* mailbox 1 */
207 #define MBOX2 0x14 /* mailbox 2 */
208 #define MBOX3 0x16 /* mailbox 3 */
209 #define MBOX4 0x18 /* mailbox 4 */
210 #define MBOX5 0x1a /* mailbox 5 */
211 #define MBOX6 0x1c /* mailbox 6 */
212 #define MBOX7 0x1e /* mailbox 7 */
214 /* mailbox command complete status codes */
215 #define MBOX_COMMAND_COMPLETE 0x4000
216 #define INVALID_COMMAND 0x4001
217 #define HOST_INTERFACE_ERROR 0x4002
218 #define TEST_FAILED 0x4003
219 #define COMMAND_ERROR 0x4005
220 #define COMMAND_PARAM_ERROR 0x4006
221 #define PORT_ID_USED 0x4007
222 #define LOOP_ID_USED 0x4008
223 #define ALL_IDS_USED 0x4009
225 /* async event status codes */
226 #define RESET_DETECTED 0x8001
227 #define SYSTEM_ERROR 0x8002
228 #define REQUEST_TRANSFER_ERROR 0x8003
229 #define RESPONSE_TRANSFER_ERROR 0x8004
230 #define REQUEST_QUEUE_WAKEUP 0x8005
231 #define LIP_OCCURRED 0x8010
232 #define LOOP_UP 0x8011
233 #define LOOP_DOWN 0x8012
234 #define LIP_RECEIVED 0x8013
235 #define PORT_DB_CHANGED 0x8014
236 #define CHANGE_NOTIFICATION 0x8015
237 #define SCSI_COMMAND_COMPLETE 0x8020
238 #define POINT_TO_POINT_UP 0x8030
239 #define CONNECTION_MODE 0x8036
241 struct Entry_header
{
248 /* entry header type commands */
249 #define ENTRY_COMMAND 0x19
250 #define ENTRY_CONTINUATION 0x0a
252 #define ENTRY_STATUS 0x03
253 #define ENTRY_MARKER 0x04
256 /* entry header flag definitions */
258 #define EFLAG_BAD_HEADER 4
259 #define EFLAG_BAD_PAYLOAD 8
267 struct Command_Entry
{
268 struct Entry_header hdr
;
272 u_short expanded_lun
;
273 u_short control_flags
;
278 u_int total_byte_cnt
;
279 struct dataseg dataseg
[DATASEGS_PER_COMMAND
];
282 /* command entry control flag definitions */
283 #define CFLAG_NODISC 0x01
284 #define CFLAG_HEAD_TAG 0x02
285 #define CFLAG_ORDERED_TAG 0x04
286 #define CFLAG_SIMPLE_TAG 0x08
287 #define CFLAG_TAR_RTN 0x10
288 #define CFLAG_READ 0x20
289 #define CFLAG_WRITE 0x40
291 struct Continuation_Entry
{
292 struct Entry_header hdr
;
293 struct dataseg dataseg
[DATASEGS_PER_CONT
];
296 struct Marker_Entry
{
297 struct Entry_header hdr
;
306 /* marker entry modifier definitions */
307 #define SYNC_DEVICE 0
308 #define SYNC_TARGET 1
311 struct Status_Entry
{
312 struct Entry_header hdr
;
315 u_short completion_status
;
317 u_short status_flags
;
318 u_short res_info_len
;
319 u_short req_sense_len
;
322 u_char req_sense_data
[32];
325 /* status entry completion status definitions */
326 #define CS_COMPLETE 0x0000
327 #define CS_DMA_ERROR 0x0002
328 #define CS_RESET_OCCURRED 0x0004
329 #define CS_ABORTED 0x0005
330 #define CS_TIMEOUT 0x0006
331 #define CS_DATA_OVERRUN 0x0007
332 #define CS_DATA_UNDERRUN 0x0015
333 #define CS_QUEUE_FULL 0x001c
334 #define CS_PORT_UNAVAILABLE 0x0028
335 #define CS_PORT_LOGGED_OUT 0x0029
336 #define CS_PORT_CONFIG_CHANGED 0x002a
338 /* status entry state flag definitions */
339 #define SF_SENT_CDB 0x0400
340 #define SF_TRANSFERRED_DATA 0x0800
341 #define SF_GOT_STATUS 0x1000
343 /* status entry status flag definitions */
344 #define STF_BUS_RESET 0x0008
345 #define STF_DEVICE_RESET 0x0010
346 #define STF_ABORTED 0x0020
347 #define STF_TIMEOUT 0x0040
349 /* interrupt control commands */
350 #define ISP_EN_INT 0x8000
351 #define ISP_EN_RISC 0x0008
353 /* host control commands */
354 #define HCCR_NOP 0x0000
355 #define HCCR_RESET 0x1000
356 #define HCCR_PAUSE 0x2000
357 #define HCCR_RELEASE 0x3000
358 #define HCCR_SINGLE_STEP 0x4000
359 #define HCCR_SET_HOST_INTR 0x5000
360 #define HCCR_CLEAR_HOST_INTR 0x6000
361 #define HCCR_CLEAR_RISC_INTR 0x7000
362 #define HCCR_BP_ENABLE 0x8000
363 #define HCCR_BIOS_DISABLE 0x9000
364 #define HCCR_TEST_MODE 0xf000
366 #define RISC_BUSY 0x0004
368 /* mailbox commands */
369 #define MBOX_NO_OP 0x0000
370 #define MBOX_LOAD_RAM 0x0001
371 #define MBOX_EXEC_FIRMWARE 0x0002
372 #define MBOX_DUMP_RAM 0x0003
373 #define MBOX_WRITE_RAM_WORD 0x0004
374 #define MBOX_READ_RAM_WORD 0x0005
375 #define MBOX_MAILBOX_REG_TEST 0x0006
376 #define MBOX_VERIFY_CHECKSUM 0x0007
377 #define MBOX_ABOUT_FIRMWARE 0x0008
378 #define MBOX_LOAD_RISC_RAM 0x0009
379 #define MBOX_DUMP_RISC_RAM 0x000a
380 #define MBOX_CHECK_FIRMWARE 0x000e
381 #define MBOX_INIT_REQ_QUEUE 0x0010
382 #define MBOX_INIT_RES_QUEUE 0x0011
383 #define MBOX_EXECUTE_IOCB 0x0012
384 #define MBOX_WAKE_UP 0x0013
385 #define MBOX_STOP_FIRMWARE 0x0014
386 #define MBOX_ABORT_IOCB 0x0015
387 #define MBOX_ABORT_DEVICE 0x0016
388 #define MBOX_ABORT_TARGET 0x0017
389 #define MBOX_BUS_RESET 0x0018
390 #define MBOX_STOP_QUEUE 0x0019
391 #define MBOX_START_QUEUE 0x001a
392 #define MBOX_SINGLE_STEP_QUEUE 0x001b
393 #define MBOX_ABORT_QUEUE 0x001c
394 #define MBOX_GET_DEV_QUEUE_STATUS 0x001d
395 #define MBOX_GET_FIRMWARE_STATUS 0x001f
396 #define MBOX_GET_INIT_SCSI_ID 0x0020
397 #define MBOX_GET_RETRY_COUNT 0x0022
398 #define MBOX_GET_TARGET_PARAMS 0x0028
399 #define MBOX_GET_DEV_QUEUE_PARAMS 0x0029
400 #define MBOX_SET_RETRY_COUNT 0x0032
401 #define MBOX_SET_TARGET_PARAMS 0x0038
402 #define MBOX_SET_DEV_QUEUE_PARAMS 0x0039
403 #define MBOX_EXECUTE_IOCB64 0x0054
404 #define MBOX_INIT_FIRMWARE 0x0060
405 #define MBOX_GET_INIT_CB 0x0061
406 #define MBOX_INIT_LIP 0x0062
407 #define MBOX_GET_POS_MAP 0x0063
408 #define MBOX_GET_PORT_DB 0x0064
409 #define MBOX_CLEAR_ACA 0x0065
410 #define MBOX_TARGET_RESET 0x0066
411 #define MBOX_CLEAR_TASK_SET 0x0067
412 #define MBOX_ABORT_TASK_SET 0x0068
413 #define MBOX_GET_FIRMWARE_STATE 0x0069
414 #define MBOX_GET_PORT_NAME 0x006a
415 #define MBOX_SEND_SNS 0x006e
416 #define MBOX_PORT_LOGIN 0x006f
417 #define MBOX_SEND_CHANGE_REQUEST 0x0070
418 #define MBOX_PORT_LOGOUT 0x0071
421 * Firmware if needed (note this is a hack, it belongs in a separate
425 #ifdef CONFIG_SCSI_QLOGIC_FC_FIRMWARE
426 #include "qlogicfc_asm.c"
428 static unsigned short risc_code_addr01
= 0x1000 ;
431 /* Each element in mbox_param is an 8 bit bitmap where each bit indicates
432 if that mbox should be copied as input. For example 0x2 would mean
435 static const u_char mbox_param
[] =
437 0x01, /* MBOX_NO_OP */
438 0x1f, /* MBOX_LOAD_RAM */
439 0x03, /* MBOX_EXEC_FIRMWARE */
440 0x1f, /* MBOX_DUMP_RAM */
441 0x07, /* MBOX_WRITE_RAM_WORD */
442 0x03, /* MBOX_READ_RAM_WORD */
443 0xff, /* MBOX_MAILBOX_REG_TEST */
444 0x03, /* MBOX_VERIFY_CHECKSUM */
445 0x01, /* MBOX_ABOUT_FIRMWARE */
446 0xff, /* MBOX_LOAD_RISC_RAM */
447 0xff, /* MBOX_DUMP_RISC_RAM */
451 0x01, /* MBOX_CHECK_FIRMWARE */
453 0x1f, /* MBOX_INIT_REQ_QUEUE */
454 0x2f, /* MBOX_INIT_RES_QUEUE */
455 0x0f, /* MBOX_EXECUTE_IOCB */
456 0x03, /* MBOX_WAKE_UP */
457 0x01, /* MBOX_STOP_FIRMWARE */
458 0x0f, /* MBOX_ABORT_IOCB */
459 0x03, /* MBOX_ABORT_DEVICE */
460 0x07, /* MBOX_ABORT_TARGET */
461 0x03, /* MBOX_BUS_RESET */
462 0x03, /* MBOX_STOP_QUEUE */
463 0x03, /* MBOX_START_QUEUE */
464 0x03, /* MBOX_SINGLE_STEP_QUEUE */
465 0x03, /* MBOX_ABORT_QUEUE */
466 0x03, /* MBOX_GET_DEV_QUEUE_STATUS */
468 0x01, /* MBOX_GET_FIRMWARE_STATUS */
469 0x01, /* MBOX_GET_INIT_SCSI_ID */
471 0x01, /* MBOX_GET_RETRY_COUNT */
477 0x03, /* MBOX_GET_TARGET_PARAMS */
478 0x03, /* MBOX_GET_DEV_QUEUE_PARAMS */
487 0x07, /* MBOX_SET_RETRY_COUNT */
493 0x0f, /* MBOX_SET_TARGET_PARAMS */
494 0x0f, /* MBOX_SET_DEV_QUEUE_PARAMS */
521 0xcf, /* MBOX_EXECUTE_IOCB64 */
533 0xff, /* MBOX_INIT_FIRMWARE */
534 0xcd, /* MBOX_GET_INIT_CB */
535 0x01, /* MBOX_INIT_LIP */
536 0xcd, /* MBOX_GET_POS_MAP */
537 0xcf, /* MBOX_GET_PORT_DB */
538 0x03, /* MBOX_CLEAR_ACA */
539 0x03, /* MBOX_TARGET_RESET */
540 0x03, /* MBOX_CLEAR_TASK_SET */
541 0x03, /* MBOX_ABORT_TASK_SET */
542 0x01, /* MBOX_GET_FIRMWARE_STATE */
543 0x03, /* MBOX_GET_PORT_NAME */
547 0xcf, /* MBOX_SEND_SNS */
548 0x0f, /* MBOX_PORT_LOGIN */
549 0x03, /* MBOX_SEND_CHANGE_REQUEST */
550 0x03, /* MBOX_PORT_LOGOUT */
553 #define MAX_MBOX_COMMAND (sizeof(mbox_param)/sizeof(u_short))
571 /* address of instance of this struct is passed to adapter to initialize things
577 u_short max_frame_len
;
579 u_short exec_throttle
;
582 u_short node_name
[4];
584 u_char reserved2
[10];
585 u_short req_queue_out
;
586 u_short res_queue_in
;
587 u_short req_queue_len
;
588 u_short res_queue_len
;
589 u_int req_queue_addr_lo
;
590 u_int req_queue_addr_high
;
591 u_int res_queue_addr_lo
;
592 u_int res_queue_addr_high
;
593 /* the rest of this structure only applies to the isp2200 */
595 u_char cmd_resource_cnt
;
596 u_char notify_resource_cnt
;
599 u_short add_firm_opts
;
600 u_char res_accum_timer
;
601 u_char irq_delay_timer
;
602 u_short special_options
;
603 u_short reserved4
[13];
607 * The result queue can be quite a bit smaller since continuation entries
608 * do not show up there:
610 #define RES_QUEUE_LEN ((QLOGICFC_REQ_QUEUE_LEN + 1) / 8 - 1)
611 #define QUEUE_ENTRY_LEN 64
614 #define QLOGICFC_MAX_ID 0xff
616 #define QLOGICFC_MAX_ID 0x7d
619 #define QLOGICFC_MAX_LUN 128
620 #define QLOGICFC_MAX_LOOP_ID 0x7d
622 /* the following connection options only apply to the 2200. i have only
623 * had success with LOOP_ONLY and P2P_ONLY.
628 #define LOOP_PREFERED 2
629 #define P2P_PREFERED 3
631 #define CONNECTION_PREFERENCE LOOP_ONLY
633 /* adapter_state values */
634 #define AS_FIRMWARE_DEAD -1
635 #define AS_LOOP_DOWN 0
636 #define AS_LOOP_GOOD 1
637 #define AS_REDO_FABRIC_PORTDB 2
638 #define AS_REDO_LOOP_PORTDB 4
640 #define RES_SIZE ((RES_QUEUE_LEN + 1)*QUEUE_ENTRY_LEN)
641 #define REQ_SIZE ((QLOGICFC_REQ_QUEUE_LEN + 1)*QUEUE_ENTRY_LEN)
643 struct isp2x00_hostdata
{
645 struct pci_dev
*pci_dev
;
646 /* result and request queues (shared with isp2x00): */
647 u_int req_in_ptr
; /* index of next request slot */
648 u_int res_out_ptr
; /* index of next result slot */
650 /* this is here so the queues are nicely aligned */
651 long send_marker
; /* do we need to send a marker? */
655 struct init_cb control_block
;
657 unsigned long int tag_ages
[QLOGICFC_MAX_ID
+ 1];
658 Scsi_Cmnd
*handle_ptrs
[QLOGICFC_REQ_QUEUE_LEN
+ 1];
659 unsigned long handle_serials
[QLOGICFC_REQ_QUEUE_LEN
+ 1];
660 struct id_name_map port_db
[QLOGICFC_MAX_ID
+ 1];
666 struct timer_list explore_timer
;
667 struct id_name_map tempmap
[QLOGICFC_MAX_ID
+ 1];
671 /* queue length's _must_ be power of two: */
672 #define QUEUE_DEPTH(in, out, ql) ((in - out) & (ql))
673 #define REQ_QUEUE_DEPTH(in, out) QUEUE_DEPTH(in, out, \
674 QLOGICFC_REQ_QUEUE_LEN)
675 #define RES_QUEUE_DEPTH(in, out) QUEUE_DEPTH(in, out, RES_QUEUE_LEN)
677 static void isp2x00_enable_irqs(struct Scsi_Host
*);
678 static void isp2x00_disable_irqs(struct Scsi_Host
*);
679 static int isp2x00_init(struct Scsi_Host
*);
680 static int isp2x00_reset_hardware(struct Scsi_Host
*);
681 static int isp2x00_mbox_command(struct Scsi_Host
*, u_short
[]);
682 static int isp2x00_return_status(Scsi_Cmnd
*, struct Status_Entry
*);
683 static void isp2x00_intr_handler(int, void *, struct pt_regs
*);
684 static irqreturn_t
do_isp2x00_intr_handler(int, void *, struct pt_regs
*);
685 static int isp2x00_make_portdb(struct Scsi_Host
*);
688 static int isp2x00_init_fabric(struct Scsi_Host
*, struct id_name_map
*, int);
691 #if USE_NVRAM_DEFAULTS
692 static int isp2x00_get_nvram_defaults(struct Scsi_Host
*, struct init_cb
*);
693 static u_short
isp2x00_read_nvram_word(struct Scsi_Host
*, u_short
);
697 static void isp2x00_print_scsi_cmd(Scsi_Cmnd
*);
700 #if DEBUG_ISP2x00_INTR
701 static void isp2x00_print_status_entry(struct Status_Entry
*);
704 static inline void isp2x00_enable_irqs(struct Scsi_Host
*host
)
706 outw(ISP_EN_INT
| ISP_EN_RISC
, host
->io_port
+ PCI_INTER_CTL
);
710 static inline void isp2x00_disable_irqs(struct Scsi_Host
*host
)
712 outw(0x0, host
->io_port
+ PCI_INTER_CTL
);
716 static int isp2x00_detect(struct scsi_host_template
* tmpt
)
719 unsigned long wait_time
;
720 struct Scsi_Host
*host
= NULL
;
721 struct isp2x00_hostdata
*hostdata
;
722 struct pci_dev
*pdev
;
723 unsigned short device_ids
[2];
728 ENTER("isp2x00_detect");
730 device_ids
[0] = PCI_DEVICE_ID_QLOGIC_ISP2100
;
731 device_ids
[1] = PCI_DEVICE_ID_QLOGIC_ISP2200
;
733 tmpt
->proc_name
= "isp2x00";
737 while ((pdev
= pci_find_device(PCI_VENDOR_ID_QLOGIC
, device_ids
[i
], pdev
))) {
738 if (pci_enable_device(pdev
))
741 /* Try to configure DMA attributes. */
742 if (pci_set_dma_mask(pdev
, DMA_64BIT_MASK
) &&
743 pci_set_dma_mask(pdev
, DMA_32BIT_MASK
))
746 host
= scsi_register(tmpt
, sizeof(struct isp2x00_hostdata
));
748 printk("qlogicfc%d : could not register host.\n", hosts
);
751 host
->max_id
= QLOGICFC_MAX_ID
+ 1;
752 host
->max_lun
= QLOGICFC_MAX_LUN
;
753 hostdata
= (struct isp2x00_hostdata
*) host
->hostdata
;
755 memset(hostdata
, 0, sizeof(struct isp2x00_hostdata
));
756 hostdata
->pci_dev
= pdev
;
757 hostdata
->res
= pci_alloc_consistent(pdev
, RES_SIZE
+ REQ_SIZE
, &busaddr
);
760 printk("qlogicfc%d : could not allocate memory for request and response queue.\n", hosts
);
761 scsi_unregister(host
);
764 hostdata
->req
= hostdata
->res
+ (RES_QUEUE_LEN
+ 1)*QUEUE_ENTRY_LEN
;
765 hostdata
->queued
= 0;
766 /* set up the control block */
767 hostdata
->control_block
.version
= 0x1;
768 hostdata
->control_block
.firm_opts
= cpu_to_le16(0x800e);
769 hostdata
->control_block
.max_frame_len
= cpu_to_le16(2048);
770 hostdata
->control_block
.max_iocb
= cpu_to_le16(QLOGICFC_REQ_QUEUE_LEN
);
771 hostdata
->control_block
.exec_throttle
= cpu_to_le16(QLOGICFC_CMD_PER_LUN
);
772 hostdata
->control_block
.retry_delay
= 5;
773 hostdata
->control_block
.retry_cnt
= 1;
774 hostdata
->control_block
.node_name
[0] = cpu_to_le16(0x0020);
775 hostdata
->control_block
.node_name
[1] = cpu_to_le16(0xE000);
776 hostdata
->control_block
.node_name
[2] = cpu_to_le16(0x008B);
777 hostdata
->control_block
.node_name
[3] = cpu_to_le16(0x0000);
778 hostdata
->control_block
.hard_addr
= cpu_to_le16(0x0003);
779 hostdata
->control_block
.req_queue_len
= cpu_to_le16(QLOGICFC_REQ_QUEUE_LEN
+ 1);
780 hostdata
->control_block
.res_queue_len
= cpu_to_le16(RES_QUEUE_LEN
+ 1);
781 hostdata
->control_block
.res_queue_addr_lo
= cpu_to_le32(pci64_dma_lo32(busaddr
));
782 hostdata
->control_block
.res_queue_addr_high
= cpu_to_le32(pci64_dma_hi32(busaddr
));
783 hostdata
->control_block
.req_queue_addr_lo
= cpu_to_le32(pci64_dma_lo32(busaddr
+ RES_SIZE
));
784 hostdata
->control_block
.req_queue_addr_high
= cpu_to_le32(pci64_dma_hi32(busaddr
+ RES_SIZE
));
787 hostdata
->control_block
.add_firm_opts
|= cpu_to_le16(CONNECTION_PREFERENCE
<<4);
788 hostdata
->adapter_state
= AS_LOOP_DOWN
;
789 hostdata
->explore_timer
.data
= 1;
790 hostdata
->host_id
= hosts
;
792 if (isp2x00_init(host
) || isp2x00_reset_hardware(host
)) {
793 pci_free_consistent (pdev
, RES_SIZE
+ REQ_SIZE
, hostdata
->res
, busaddr
);
794 scsi_unregister(host
);
799 if (request_irq(host
->irq
, do_isp2x00_intr_handler
, SA_INTERRUPT
| SA_SHIRQ
, "qlogicfc", host
)) {
800 printk("qlogicfc%d : interrupt %d already in use\n",
801 hostdata
->host_id
, host
->irq
);
802 pci_free_consistent (pdev
, RES_SIZE
+ REQ_SIZE
, hostdata
->res
, busaddr
);
803 scsi_unregister(host
);
806 if (!request_region(host
->io_port
, 0xff, "qlogicfc")) {
807 printk("qlogicfc%d : i/o region 0x%lx-0x%lx already "
809 hostdata
->host_id
, host
->io_port
, host
->io_port
+ 0xff);
810 free_irq(host
->irq
, host
);
811 pci_free_consistent (pdev
, RES_SIZE
+ REQ_SIZE
, hostdata
->res
, busaddr
);
812 scsi_unregister(host
);
816 outw(0x0, host
->io_port
+ PCI_SEMAPHORE
);
817 outw(HCCR_CLEAR_RISC_INTR
, host
->io_port
+ HOST_HCCR
);
818 isp2x00_enable_irqs(host
);
819 /* wait for the loop to come up */
820 for (wait_time
= jiffies
+ 10 * HZ
; time_before(jiffies
, wait_time
) && hostdata
->adapter_state
== AS_LOOP_DOWN
;) {
824 if (hostdata
->adapter_state
== AS_LOOP_DOWN
) {
825 printk("qlogicfc%d : link is not up\n", hostdata
->host_id
);
828 hostdata
->explore_timer
.data
= 0;
833 /* this busy loop should not be needed but the isp2x00 seems to need
834 some time before recognizing it is attached to a fabric */
838 for (wait_time
= jiffies
+ 5 * HZ
; time_before(jiffies
, wait_time
);) {
845 LEAVE("isp2x00_detect");
851 static int isp2x00_make_portdb(struct Scsi_Host
*host
)
856 struct isp2x00_hostdata
*hostdata
;
858 isp2x00_disable_irqs(host
);
860 hostdata
= (struct isp2x00_hostdata
*) host
->hostdata
;
861 memset(hostdata
->tempmap
, 0, sizeof(hostdata
->tempmap
));
864 for (i
= 0x81; i
< QLOGICFC_MAX_ID
; i
++) {
865 param
[0] = MBOX_PORT_LOGOUT
;
870 isp2x00_mbox_command(host
, param
);
872 if (param
[0] != MBOX_COMMAND_COMPLETE
) {
874 DEBUG_FABRIC(printk("qlogicfc%d : logout failed %x %x\n", hostdata
->host_id
, i
, param
[0]));
880 param
[0] = MBOX_GET_INIT_SCSI_ID
;
882 isp2x00_mbox_command(host
, param
);
884 if (param
[0] == MBOX_COMMAND_COMPLETE
) {
885 hostdata
->port_id
= ((u_int
) param
[3]) << 16;
886 hostdata
->port_id
|= param
[2];
887 hostdata
->tempmap
[0].loop_id
= param
[1];
888 hostdata
->tempmap
[0].wwn
= hostdata
->wwn
;
891 printk("qlogicfc%d : error getting scsi id.\n", hostdata
->host_id
);
894 for (i
= 0; i
<=QLOGICFC_MAX_ID
; i
++)
895 hostdata
->tempmap
[i
].loop_id
= hostdata
->tempmap
[0].loop_id
;
897 for (i
= 0, j
= 1; i
<= QLOGICFC_MAX_LOOP_ID
; i
++) {
898 param
[0] = MBOX_GET_PORT_NAME
;
899 param
[1] = (i
<< 8) & 0xff00;
901 isp2x00_mbox_command(host
, param
);
903 if (param
[0] == MBOX_COMMAND_COMPLETE
) {
904 hostdata
->tempmap
[j
].loop_id
= i
;
905 hostdata
->tempmap
[j
].wwn
= ((u64
) (param
[2] & 0xff)) << 56;
906 hostdata
->tempmap
[j
].wwn
|= ((u64
) ((param
[2] >> 8) & 0xff)) << 48;
907 hostdata
->tempmap
[j
].wwn
|= ((u64
) (param
[3] & 0xff)) << 40;
908 hostdata
->tempmap
[j
].wwn
|= ((u64
) ((param
[3] >> 8) & 0xff)) << 32;
909 hostdata
->tempmap
[j
].wwn
|= ((u64
) (param
[6] & 0xff)) << 24;
910 hostdata
->tempmap
[j
].wwn
|= ((u64
) ((param
[6] >> 8) & 0xff)) << 16;
911 hostdata
->tempmap
[j
].wwn
|= ((u64
) (param
[7] & 0xff)) << 8;
912 hostdata
->tempmap
[j
].wwn
|= ((u64
) ((param
[7] >> 8) & 0xff));
921 isp2x00_init_fabric(host
, hostdata
->tempmap
, j
);
924 for (i
= 0; i
<= QLOGICFC_MAX_ID
; i
++) {
925 if (hostdata
->tempmap
[i
].wwn
!= hostdata
->port_db
[i
].wwn
) {
926 for (j
= 0; j
<= QLOGICFC_MAX_ID
; j
++) {
927 if (hostdata
->tempmap
[j
].wwn
== hostdata
->port_db
[i
].wwn
) {
928 hostdata
->port_db
[i
].loop_id
= hostdata
->tempmap
[j
].loop_id
;
932 if (j
== QLOGICFC_MAX_ID
+ 1)
933 hostdata
->port_db
[i
].loop_id
= hostdata
->tempmap
[0].loop_id
;
935 for (j
= 0; j
<= QLOGICFC_MAX_ID
; j
++) {
936 if (hostdata
->port_db
[j
].wwn
== hostdata
->tempmap
[i
].wwn
|| !hostdata
->port_db
[j
].wwn
) {
940 if (j
== QLOGICFC_MAX_ID
+ 1)
941 printk("qlogicfc%d : Too many scsi devices, no more room in port map.\n", hostdata
->host_id
);
942 if (!hostdata
->port_db
[j
].wwn
) {
943 hostdata
->port_db
[j
].loop_id
= hostdata
->tempmap
[i
].loop_id
;
944 hostdata
->port_db
[j
].wwn
= hostdata
->tempmap
[i
].wwn
;
947 hostdata
->port_db
[i
].loop_id
= hostdata
->tempmap
[i
].loop_id
;
951 isp2x00_enable_irqs(host
);
959 #define FABRIC_PORT 0x7e
960 #define FABRIC_CONTROLLER 0x7f
961 #define FABRIC_SNS 0x80
963 int isp2x00_init_fabric(struct Scsi_Host
*host
, struct id_name_map
*port_db
, int cur_scsi_id
)
969 u_short loop_id
= 0x81;
970 u_short scsi_id
= cur_scsi_id
;
973 u_char
*sns_response
;
975 struct isp2x00_hostdata
*hostdata
;
977 hostdata
= (struct isp2x00_hostdata
*) host
->hostdata
;
979 DEBUG_FABRIC(printk("qlogicfc%d : Checking for a fabric.\n", hostdata
->host_id
));
980 param
[0] = MBOX_GET_PORT_NAME
;
981 param
[1] = (u16
)FABRIC_PORT
<< 8;
983 isp2x00_mbox_command(host
, param
);
985 if (param
[0] != MBOX_COMMAND_COMPLETE
) {
986 DEBUG_FABRIC(printk("qlogicfc%d : fabric check result %x\n", hostdata
->host_id
, param
[0]));
989 printk("qlogicfc%d : Fabric found.\n", hostdata
->host_id
);
991 req
= (struct sns_cb
*)pci_alloc_consistent(hostdata
->pci_dev
, sizeof(*req
) + 608, &busaddr
);
994 printk("qlogicfc%d : Could not allocate DMA resources for fabric initialization\n", hostdata
->host_id
);
997 sns_response
= (u_char
*)(req
+ 1);
999 if (hostdata
->adapter_state
& AS_REDO_LOOP_PORTDB
){
1000 memset(req
, 0, sizeof(*req
));
1002 req
->len
= cpu_to_le16(8);
1003 req
->response_low
= cpu_to_le32(pci64_dma_lo32(busaddr
+ sizeof(*req
)));
1004 req
->response_high
= cpu_to_le32(pci64_dma_hi32(busaddr
+ sizeof(*req
)));
1005 req
->sub_len
= cpu_to_le16(22);
1006 req
->data
[0] = 0x17;
1007 req
->data
[1] = 0x02;
1008 req
->data
[8] = (u_char
) (hostdata
->port_id
& 0xff);
1009 req
->data
[9] = (u_char
) (hostdata
->port_id
>> 8 & 0xff);
1010 req
->data
[10] = (u_char
) (hostdata
->port_id
>> 16 & 0xff);
1011 req
->data
[13] = 0x01;
1012 param
[0] = MBOX_SEND_SNS
;
1014 param
[2] = pci64_dma_lo32(busaddr
) >> 16;
1015 param
[3] = pci64_dma_lo32(busaddr
);
1016 param
[6] = pci64_dma_hi32(busaddr
) >> 16;
1017 param
[7] = pci64_dma_hi32(busaddr
);
1019 isp2x00_mbox_command(host
, param
);
1021 if (param
[0] != MBOX_COMMAND_COMPLETE
)
1022 printk("qlogicfc%d : error sending RFC-4\n", hostdata
->host_id
);
1025 port_id
= hostdata
->port_id
;
1027 memset(req
, 0, sizeof(*req
));
1029 req
->len
= cpu_to_le16(304);
1030 req
->response_low
= cpu_to_le32(pci64_dma_lo32(busaddr
+ sizeof(*req
)));
1031 req
->response_high
= cpu_to_le32(pci64_dma_hi32(busaddr
+ sizeof(*req
)));
1032 req
->sub_len
= cpu_to_le16(6);
1033 req
->data
[0] = 0x00;
1034 req
->data
[1] = 0x01;
1035 req
->data
[8] = (u_char
) (port_id
& 0xff);
1036 req
->data
[9] = (u_char
) (port_id
>> 8 & 0xff);
1037 req
->data
[10] = (u_char
) (port_id
>> 16 & 0xff);
1039 param
[0] = MBOX_SEND_SNS
;
1041 param
[2] = pci64_dma_lo32(busaddr
) >> 16;
1042 param
[3] = pci64_dma_lo32(busaddr
);
1043 param
[6] = pci64_dma_hi32(busaddr
) >> 16;
1044 param
[7] = pci64_dma_hi32(busaddr
);
1046 isp2x00_mbox_command(host
, param
);
1048 if (param
[0] == MBOX_COMMAND_COMPLETE
) {
1049 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]));
1050 DEBUG_FABRIC(printk(" port id: %02x%02x%02x\n", sns_response
[17], sns_response
[18], sns_response
[19]));
1051 port_id
= ((u_int
) sns_response
[17]) << 16;
1052 port_id
|= ((u_int
) sns_response
[18]) << 8;
1053 port_id
|= ((u_int
) sns_response
[19]);
1054 wwn
= ((u64
) sns_response
[20]) << 56;
1055 wwn
|= ((u64
) sns_response
[21]) << 48;
1056 wwn
|= ((u64
) sns_response
[22]) << 40;
1057 wwn
|= ((u64
) sns_response
[23]) << 32;
1058 wwn
|= ((u64
) sns_response
[24]) << 24;
1059 wwn
|= ((u64
) sns_response
[25]) << 16;
1060 wwn
|= ((u64
) sns_response
[26]) << 8;
1061 wwn
|= ((u64
) sns_response
[27]);
1062 if (hostdata
->port_id
>> 8 != port_id
>> 8) {
1063 DEBUG_FABRIC(printk("qlogicfc%d : adding a fabric port: %x\n", hostdata
->host_id
, port_id
));
1064 param
[0] = MBOX_PORT_LOGIN
;
1065 param
[1] = loop_id
<< 8;
1066 param
[2] = (u_short
) (port_id
>> 16);
1067 param
[3] = (u_short
) (port_id
);
1069 isp2x00_mbox_command(host
, param
);
1071 if (param
[0] == MBOX_COMMAND_COMPLETE
) {
1072 port_db
[scsi_id
].wwn
= wwn
;
1073 port_db
[scsi_id
].loop_id
= loop_id
;
1077 printk("qlogicfc%d : Error performing port login %x\n", hostdata
->host_id
, param
[0]);
1078 DEBUG_FABRIC(printk("qlogicfc%d : loop_id: %x\n", hostdata
->host_id
, loop_id
));
1079 param
[0] = MBOX_PORT_LOGOUT
;
1080 param
[1] = loop_id
<< 8;
1084 isp2x00_mbox_command(host
, param
);
1089 if (hostdata
->port_id
== port_id
)
1092 printk("qlogicfc%d : Get All Next failed %x.\n", hostdata
->host_id
, param
[0]);
1093 pci_free_consistent(hostdata
->pci_dev
, sizeof(*req
) + 608, req
, busaddr
);
1098 pci_free_consistent(hostdata
->pci_dev
, sizeof(*req
) + 608, req
, busaddr
);
1102 #endif /* ISP2x00_FABRIC */
1105 static int isp2x00_release(struct Scsi_Host
*host
)
1107 struct isp2x00_hostdata
*hostdata
;
1110 ENTER("isp2x00_release");
1112 hostdata
= (struct isp2x00_hostdata
*) host
->hostdata
;
1114 outw(0x0, host
->io_port
+ PCI_INTER_CTL
);
1115 free_irq(host
->irq
, host
);
1117 release_region(host
->io_port
, 0xff);
1119 busaddr
= pci64_dma_build(le32_to_cpu(hostdata
->control_block
.res_queue_addr_high
),
1120 le32_to_cpu(hostdata
->control_block
.res_queue_addr_lo
));
1121 pci_free_consistent(hostdata
->pci_dev
, RES_SIZE
+ REQ_SIZE
, hostdata
->res
, busaddr
);
1123 LEAVE("isp2x00_release");
1129 static const char *isp2x00_info(struct Scsi_Host
*host
)
1131 static char buf
[80];
1132 struct isp2x00_hostdata
*hostdata
;
1133 ENTER("isp2x00_info");
1135 hostdata
= (struct isp2x00_hostdata
*) host
->hostdata
;
1137 "QLogic ISP%04x SCSI on PCI bus %02x device %02x irq %d base 0x%lx",
1138 hostdata
->pci_dev
->device
, hostdata
->pci_dev
->bus
->number
, hostdata
->pci_dev
->devfn
, host
->irq
,
1142 LEAVE("isp2x00_info");
1149 * The middle SCSI layer ensures that queuecommand never gets invoked
1150 * concurrently with itself or the interrupt handler (though the
1151 * interrupt handler may call this routine as part of
1152 * request-completion handling).
1154 static int isp2x00_queuecommand(Scsi_Cmnd
* Cmnd
, void (*done
) (Scsi_Cmnd
*))
1156 int i
, sg_count
, n
, num_free
;
1157 u_int in_ptr
, out_ptr
;
1159 struct scatterlist
*sg
;
1160 struct Command_Entry
*cmd
;
1161 struct Continuation_Entry
*cont
;
1162 struct Scsi_Host
*host
;
1163 struct isp2x00_hostdata
*hostdata
;
1165 ENTER("isp2x00_queuecommand");
1167 host
= Cmnd
->device
->host
;
1168 hostdata
= (struct isp2x00_hostdata
*) host
->hostdata
;
1169 Cmnd
->scsi_done
= done
;
1171 DEBUG(isp2x00_print_scsi_cmd(Cmnd
));
1173 if (hostdata
->adapter_state
& AS_REDO_FABRIC_PORTDB
|| hostdata
->adapter_state
& AS_REDO_LOOP_PORTDB
) {
1174 isp2x00_make_portdb(host
);
1175 hostdata
->adapter_state
= AS_LOOP_GOOD
;
1176 printk("qlogicfc%d : Port Database\n", hostdata
->host_id
);
1177 for (i
= 0; hostdata
->port_db
[i
].wwn
!= 0; i
++) {
1178 printk("wwn: %08x%08x scsi_id: %x loop_id: ", (u_int
) (hostdata
->port_db
[i
].wwn
>> 32), (u_int
) hostdata
->port_db
[i
].wwn
, i
);
1179 if (hostdata
->port_db
[i
].loop_id
!= hostdata
->port_db
[0].loop_id
|| i
== 0)
1180 printk("%x", hostdata
->port_db
[i
].loop_id
);
1182 printk("Not Available");
1186 if (hostdata
->adapter_state
== AS_FIRMWARE_DEAD
) {
1187 printk("qlogicfc%d : The firmware is dead, just return.\n", hostdata
->host_id
);
1192 out_ptr
= inw(host
->io_port
+ MBOX4
);
1193 in_ptr
= hostdata
->req_in_ptr
;
1195 DEBUG(printk("qlogicfc%d : request queue depth %d\n", hostdata
->host_id
,
1196 REQ_QUEUE_DEPTH(in_ptr
, out_ptr
)));
1198 cmd
= (struct Command_Entry
*) &hostdata
->req
[in_ptr
*QUEUE_ENTRY_LEN
];
1199 in_ptr
= (in_ptr
+ 1) & QLOGICFC_REQ_QUEUE_LEN
;
1200 if (in_ptr
== out_ptr
) {
1201 DEBUG(printk("qlogicfc%d : request queue overflow\n", hostdata
->host_id
));
1204 if (hostdata
->send_marker
) {
1205 struct Marker_Entry
*marker
;
1207 TRACE("queue marker", in_ptr
, 0);
1209 DEBUG(printk("qlogicfc%d : adding marker entry\n", hostdata
->host_id
));
1210 marker
= (struct Marker_Entry
*) cmd
;
1211 memset(marker
, 0, sizeof(struct Marker_Entry
));
1213 marker
->hdr
.entry_type
= ENTRY_MARKER
;
1214 marker
->hdr
.entry_cnt
= 1;
1215 marker
->modifier
= SYNC_ALL
;
1217 hostdata
->send_marker
= 0;
1219 if (((in_ptr
+ 1) & QLOGICFC_REQ_QUEUE_LEN
) == out_ptr
) {
1220 outw(in_ptr
, host
->io_port
+ MBOX4
);
1221 hostdata
->req_in_ptr
= in_ptr
;
1222 DEBUG(printk("qlogicfc%d : request queue overflow\n", hostdata
->host_id
));
1225 cmd
= (struct Command_Entry
*) &hostdata
->req
[in_ptr
*QUEUE_ENTRY_LEN
];
1226 in_ptr
= (in_ptr
+ 1) & QLOGICFC_REQ_QUEUE_LEN
;
1228 TRACE("queue command", in_ptr
, Cmnd
);
1230 memset(cmd
, 0, sizeof(struct Command_Entry
));
1232 /* find a free handle mapping slot */
1233 for (i
= in_ptr
; i
!= (in_ptr
- 1) && hostdata
->handle_ptrs
[i
]; i
= ((i
+ 1) % (QLOGICFC_REQ_QUEUE_LEN
+ 1)));
1235 if (!hostdata
->handle_ptrs
[i
]) {
1236 cmd
->handle
= cpu_to_le32(i
);
1237 hostdata
->handle_ptrs
[i
] = Cmnd
;
1238 hostdata
->handle_serials
[i
] = Cmnd
->serial_number
;
1240 printk("qlogicfc%d : no handle slots, this should not happen.\n", hostdata
->host_id
);
1241 printk("hostdata->queued is %x, in_ptr: %x\n", hostdata
->queued
, in_ptr
);
1242 for (i
= 0; i
<= QLOGICFC_REQ_QUEUE_LEN
; i
++){
1243 if (!hostdata
->handle_ptrs
[i
]){
1244 printk("slot %d has %p\n", i
, hostdata
->handle_ptrs
[i
]);
1250 cmd
->hdr
.entry_type
= ENTRY_COMMAND
;
1251 cmd
->hdr
.entry_cnt
= 1;
1252 cmd
->target_lun
= Cmnd
->device
->lun
;
1253 cmd
->expanded_lun
= cpu_to_le16(Cmnd
->device
->lun
);
1255 cmd
->target_id
= hostdata
->port_db
[Cmnd
->device
->id
].loop_id
;
1257 cmd
->target_id
= Cmnd
->target
;
1259 cmd
->total_byte_cnt
= cpu_to_le32(Cmnd
->request_bufflen
);
1261 memcpy(cmd
->cdb
, Cmnd
->cmnd
, Cmnd
->cmd_len
);
1264 sg
= (struct scatterlist
*) Cmnd
->request_buffer
;
1265 sg_count
= pci_map_sg(hostdata
->pci_dev
, sg
, Cmnd
->use_sg
, Cmnd
->sc_data_direction
);
1266 cmd
->segment_cnt
= cpu_to_le16(sg_count
);
1268 /* fill in first two sg entries: */
1270 if (n
> DATASEGS_PER_COMMAND
)
1271 n
= DATASEGS_PER_COMMAND
;
1273 for (i
= 0; i
< n
; i
++) {
1274 ds
[i
].d_base
= cpu_to_le32(pci64_dma_lo32(sg_dma_address(sg
)));
1275 ds
[i
].d_base_hi
= cpu_to_le32(pci64_dma_hi32(sg_dma_address(sg
)));
1276 ds
[i
].d_count
= cpu_to_le32(sg_dma_len(sg
));
1279 sg_count
-= DATASEGS_PER_COMMAND
;
1281 while (sg_count
> 0) {
1282 ++cmd
->hdr
.entry_cnt
;
1283 cont
= (struct Continuation_Entry
*)
1284 &hostdata
->req
[in_ptr
*QUEUE_ENTRY_LEN
];
1285 memset(cont
, 0, sizeof(struct Continuation_Entry
));
1286 in_ptr
= (in_ptr
+ 1) & QLOGICFC_REQ_QUEUE_LEN
;
1287 if (in_ptr
== out_ptr
) {
1288 DEBUG(printk("qlogicfc%d : unexpected request queue overflow\n", hostdata
->host_id
));
1291 TRACE("queue continuation", in_ptr
, 0);
1292 cont
->hdr
.entry_type
= ENTRY_CONTINUATION
;
1295 if (n
> DATASEGS_PER_CONT
)
1296 n
= DATASEGS_PER_CONT
;
1297 for (i
= 0; i
< n
; ++i
) {
1298 ds
[i
].d_base
= cpu_to_le32(pci64_dma_lo32(sg_dma_address(sg
)));
1299 ds
[i
].d_base_hi
= cpu_to_le32(pci64_dma_hi32(sg_dma_address(sg
)));
1300 ds
[i
].d_count
= cpu_to_le32(sg_dma_len(sg
));
1305 } else if (Cmnd
->request_bufflen
&& Cmnd
->sc_data_direction
!= PCI_DMA_NONE
) {
1306 struct page
*page
= virt_to_page(Cmnd
->request_buffer
);
1307 unsigned long offset
= offset_in_page(Cmnd
->request_buffer
);
1308 dma_addr_t busaddr
= pci_map_page(hostdata
->pci_dev
,
1310 Cmnd
->request_bufflen
,
1311 Cmnd
->sc_data_direction
);
1312 Cmnd
->SCp
.dma_handle
= busaddr
;
1314 cmd
->dataseg
[0].d_base
= cpu_to_le32(pci64_dma_lo32(busaddr
));
1315 cmd
->dataseg
[0].d_base_hi
= cpu_to_le32(pci64_dma_hi32(busaddr
));
1316 cmd
->dataseg
[0].d_count
= cpu_to_le32(Cmnd
->request_bufflen
);
1317 cmd
->segment_cnt
= cpu_to_le16(1);
1319 cmd
->dataseg
[0].d_base
= 0;
1320 cmd
->dataseg
[0].d_base_hi
= 0;
1321 cmd
->segment_cnt
= cpu_to_le16(1); /* Shouldn't this be 0? */
1324 if (Cmnd
->sc_data_direction
== DMA_TO_DEVICE
)
1325 cmd
->control_flags
= cpu_to_le16(CFLAG_WRITE
);
1327 cmd
->control_flags
= cpu_to_le16(CFLAG_READ
);
1329 if (Cmnd
->device
->tagged_supported
) {
1330 if (time_after(jiffies
, hostdata
->tag_ages
[Cmnd
->device
->id
] + (2 * ISP_TIMEOUT
))) {
1331 cmd
->control_flags
|= cpu_to_le16(CFLAG_ORDERED_TAG
);
1332 hostdata
->tag_ages
[Cmnd
->device
->id
] = jiffies
;
1334 switch (Cmnd
->tag
) {
1335 case HEAD_OF_QUEUE_TAG
:
1336 cmd
->control_flags
|= cpu_to_le16(CFLAG_HEAD_TAG
);
1338 case ORDERED_QUEUE_TAG
:
1339 cmd
->control_flags
|= cpu_to_le16(CFLAG_ORDERED_TAG
);
1342 cmd
->control_flags
|= cpu_to_le16(CFLAG_SIMPLE_TAG
);
1347 * TEST_UNIT_READY commands from scsi_scan will fail due to "overlapped
1348 * commands attempted" unless we setup at least a simple queue (midlayer
1349 * will embelish this once it can do an INQUIRY command to the device)
1352 cmd
->control_flags
|= cpu_to_le16(CFLAG_SIMPLE_TAG
);
1353 outw(in_ptr
, host
->io_port
+ MBOX4
);
1354 hostdata
->req_in_ptr
= in_ptr
;
1358 num_free
= QLOGICFC_REQ_QUEUE_LEN
- REQ_QUEUE_DEPTH(in_ptr
, out_ptr
);
1359 num_free
= (num_free
> 2) ? num_free
- 2 : 0;
1360 host
->can_queue
= host
->host_busy
+ num_free
;
1361 if (host
->can_queue
> QLOGICFC_REQ_QUEUE_LEN
)
1362 host
->can_queue
= QLOGICFC_REQ_QUEUE_LEN
;
1363 host
->sg_tablesize
= QLOGICFC_MAX_SG(num_free
);
1365 LEAVE("isp2x00_queuecommand");
1371 /* we have received an event, such as a lip or an RSCN, which may mean that
1372 * our port database is incorrect so the port database must be recreated.
1374 static void redo_port_db(unsigned long arg
)
1377 struct Scsi_Host
* host
= (struct Scsi_Host
*) arg
;
1378 struct isp2x00_hostdata
* hostdata
;
1379 unsigned long flags
;
1382 hostdata
= (struct isp2x00_hostdata
*) host
->hostdata
;
1383 hostdata
->explore_timer
.data
= 0;
1384 del_timer(&hostdata
->explore_timer
);
1386 spin_lock_irqsave(host
->host_lock
, flags
);
1388 if (hostdata
->adapter_state
& AS_REDO_FABRIC_PORTDB
|| hostdata
->adapter_state
& AS_REDO_LOOP_PORTDB
) {
1389 isp2x00_make_portdb(host
);
1390 printk("qlogicfc%d : Port Database\n", hostdata
->host_id
);
1391 for (i
= 0; hostdata
->port_db
[i
].wwn
!= 0; i
++) {
1392 printk("wwn: %08x%08x scsi_id: %x loop_id: ", (u_int
) (hostdata
->port_db
[i
].wwn
>> 32), (u_int
) hostdata
->port_db
[i
].wwn
, i
);
1393 if (hostdata
->port_db
[i
].loop_id
!= hostdata
->port_db
[0].loop_id
|| i
== 0)
1394 printk("%x", hostdata
->port_db
[i
].loop_id
);
1396 printk("Not Available");
1400 for (i
= 0; i
< QLOGICFC_REQ_QUEUE_LEN
; i
++){
1401 if (hostdata
->handle_ptrs
[i
] && (hostdata
->port_db
[hostdata
->handle_ptrs
[i
]->device
->id
].loop_id
> QLOGICFC_MAX_LOOP_ID
|| hostdata
->adapter_state
& AS_REDO_LOOP_PORTDB
)){
1402 if (hostdata
->port_db
[hostdata
->handle_ptrs
[i
]->device
->id
].loop_id
!= hostdata
->port_db
[0].loop_id
){
1403 Scsi_Cmnd
*Cmnd
= hostdata
->handle_ptrs
[i
];
1406 pci_unmap_sg(hostdata
->pci_dev
,
1407 (struct scatterlist
*)Cmnd
->buffer
,
1409 Cmnd
->sc_data_direction
);
1410 else if (Cmnd
->request_bufflen
&&
1411 Cmnd
->sc_data_direction
!= PCI_DMA_NONE
) {
1412 pci_unmap_page(hostdata
->pci_dev
,
1413 Cmnd
->SCp
.dma_handle
,
1414 Cmnd
->request_bufflen
,
1415 Cmnd
->sc_data_direction
);
1418 hostdata
->handle_ptrs
[i
]->result
= DID_SOFT_ERROR
<< 16;
1420 if (hostdata
->handle_ptrs
[i
]->scsi_done
){
1421 (*hostdata
->handle_ptrs
[i
]->scsi_done
) (hostdata
->handle_ptrs
[i
]);
1423 else printk("qlogicfc%d : done is null?\n", hostdata
->host_id
);
1424 hostdata
->handle_ptrs
[i
] = NULL
;
1425 hostdata
->handle_serials
[i
] = 0;
1430 hostdata
->adapter_state
= AS_LOOP_GOOD
;
1433 spin_unlock_irqrestore(host
->host_lock
, flags
);
1437 #define ASYNC_EVENT_INTERRUPT 0x01
1439 irqreturn_t
do_isp2x00_intr_handler(int irq
, void *dev_id
, struct pt_regs
*regs
)
1441 struct Scsi_Host
*host
= dev_id
;
1442 unsigned long flags
;
1444 spin_lock_irqsave(host
->host_lock
, flags
);
1445 isp2x00_intr_handler(irq
, dev_id
, regs
);
1446 spin_unlock_irqrestore(host
->host_lock
, flags
);
1451 void isp2x00_intr_handler(int irq
, void *dev_id
, struct pt_regs
*regs
)
1454 struct Status_Entry
*sts
;
1455 struct Scsi_Host
*host
= dev_id
;
1456 struct isp2x00_hostdata
*hostdata
;
1457 u_int in_ptr
, out_ptr
, handle
, num_free
;
1460 ENTER_INTR("isp2x00_intr_handler");
1462 hostdata
= (struct isp2x00_hostdata
*) host
->hostdata
;
1464 DEBUG_INTR(printk("qlogicfc%d : interrupt on line %d\n", hostdata
->host_id
, irq
));
1466 if (!(inw(host
->io_port
+ PCI_INTER_STS
) & 0x08)) {
1467 /* spurious interrupts can happen legally */
1468 DEBUG_INTR(printk("qlogicfc%d : got spurious interrupt\n", hostdata
->host_id
));
1471 in_ptr
= inw(host
->io_port
+ MBOX5
);
1472 out_ptr
= hostdata
->res_out_ptr
;
1474 if ((inw(host
->io_port
+ PCI_SEMAPHORE
) & ASYNC_EVENT_INTERRUPT
)) {
1475 status
= inw(host
->io_port
+ MBOX0
);
1477 DEBUG_INTR(printk("qlogicfc%d : mbox completion status: %x\n",
1478 hostdata
->host_id
, status
));
1482 case POINT_TO_POINT_UP
:
1483 printk("qlogicfc%d : Link is Up\n", hostdata
->host_id
);
1484 hostdata
->adapter_state
= AS_REDO_FABRIC_PORTDB
| AS_REDO_LOOP_PORTDB
;
1487 printk("qlogicfc%d : Link is Down\n", hostdata
->host_id
);
1488 hostdata
->adapter_state
= AS_LOOP_DOWN
;
1490 case CONNECTION_MODE
:
1491 printk("received CONNECTION_MODE irq %x\n", inw(host
->io_port
+ MBOX1
));
1493 case CHANGE_NOTIFICATION
:
1494 printk("qlogicfc%d : RSCN Received\n", hostdata
->host_id
);
1495 if (hostdata
->adapter_state
== AS_LOOP_GOOD
)
1496 hostdata
->adapter_state
= AS_REDO_FABRIC_PORTDB
;
1500 printk("qlogicfc%d : Loop Reinitialized\n", hostdata
->host_id
);
1501 if (hostdata
->adapter_state
== AS_LOOP_GOOD
)
1502 hostdata
->adapter_state
= AS_REDO_LOOP_PORTDB
;
1505 printk("qlogicfc%d : The firmware just choked.\n", hostdata
->host_id
);
1506 hostdata
->adapter_state
= AS_FIRMWARE_DEAD
;
1508 case SCSI_COMMAND_COMPLETE
:
1509 handle
= inw(host
->io_port
+ MBOX1
) | (inw(host
->io_port
+ MBOX2
) << 16);
1510 Cmnd
= hostdata
->handle_ptrs
[handle
];
1511 hostdata
->handle_ptrs
[handle
] = NULL
;
1512 hostdata
->handle_serials
[handle
] = 0;
1516 pci_unmap_sg(hostdata
->pci_dev
,
1517 (struct scatterlist
*)Cmnd
->buffer
,
1519 Cmnd
->sc_data_direction
);
1520 else if (Cmnd
->request_bufflen
&&
1521 Cmnd
->sc_data_direction
!= PCI_DMA_NONE
)
1522 pci_unmap_page(hostdata
->pci_dev
,
1523 Cmnd
->SCp
.dma_handle
,
1524 Cmnd
->request_bufflen
,
1525 Cmnd
->sc_data_direction
);
1527 (*Cmnd
->scsi_done
) (Cmnd
);
1529 printk("qlogicfc%d.c : got a null value out of handle_ptrs, this sucks\n", hostdata
->host_id
);
1531 case MBOX_COMMAND_COMPLETE
:
1532 case INVALID_COMMAND
:
1533 case HOST_INTERFACE_ERROR
:
1536 case COMMAND_PARAM_ERROR
:
1540 hostdata
->mbox_done
= 1;
1541 outw(HCCR_CLEAR_RISC_INTR
, host
->io_port
+ HOST_HCCR
);
1544 printk("qlogicfc%d : got an unknown status? %x\n", hostdata
->host_id
, status
);
1546 if ((hostdata
->adapter_state
& AS_REDO_LOOP_PORTDB
|| hostdata
->adapter_state
& AS_REDO_FABRIC_PORTDB
) && hostdata
->explore_timer
.data
== 0){
1547 hostdata
->explore_timer
.function
= redo_port_db
;
1548 hostdata
->explore_timer
.data
= (unsigned long)host
;
1549 hostdata
->explore_timer
.expires
= jiffies
+ (HZ
/4);
1550 init_timer(&hostdata
->explore_timer
);
1551 add_timer(&hostdata
->explore_timer
);
1553 outw(0x0, host
->io_port
+ PCI_SEMAPHORE
);
1555 DEBUG_INTR(printk("qlogicfc%d : response queue update\n", hostdata
->host_id
));
1556 DEBUG_INTR(printk("qlogicfc%d : response queue depth %d\n", hostdata
->host_id
, RES_QUEUE_DEPTH(in_ptr
, out_ptr
)));
1558 while (out_ptr
!= in_ptr
) {
1560 sts
= (struct Status_Entry
*) &hostdata
->res
[out_ptr
*QUEUE_ENTRY_LEN
];
1561 out_ptr
= (out_ptr
+ 1) & RES_QUEUE_LEN
;
1563 TRACE("done", out_ptr
, Cmnd
);
1564 DEBUG_INTR(isp2x00_print_status_entry(sts
));
1565 le_hand
= le32_to_cpu(sts
->handle
);
1566 if (sts
->hdr
.entry_type
== ENTRY_STATUS
&& (Cmnd
= hostdata
->handle_ptrs
[le_hand
])) {
1567 Cmnd
->result
= isp2x00_return_status(Cmnd
, sts
);
1571 pci_unmap_sg(hostdata
->pci_dev
,
1572 (struct scatterlist
*)Cmnd
->buffer
, Cmnd
->use_sg
,
1573 Cmnd
->sc_data_direction
);
1574 else if (Cmnd
->request_bufflen
&& Cmnd
->sc_data_direction
!= PCI_DMA_NONE
)
1575 pci_unmap_page(hostdata
->pci_dev
,
1576 Cmnd
->SCp
.dma_handle
,
1577 Cmnd
->request_bufflen
,
1578 Cmnd
->sc_data_direction
);
1581 * if any of the following are true we do not
1582 * call scsi_done. if the status is CS_ABORTED
1583 * we don't have to call done because the upper
1584 * level should already know its aborted.
1586 if (hostdata
->handle_serials
[le_hand
] != Cmnd
->serial_number
1587 || le16_to_cpu(sts
->completion_status
) == CS_ABORTED
){
1588 hostdata
->handle_serials
[le_hand
] = 0;
1589 hostdata
->handle_ptrs
[le_hand
] = NULL
;
1590 outw(out_ptr
, host
->io_port
+ MBOX5
);
1594 * if we get back an error indicating the port
1595 * is not there or if the link is down and
1596 * this is a device that used to be there
1597 * allow the command to timeout.
1598 * the device may well be back in a couple of
1601 if ((hostdata
->adapter_state
== AS_LOOP_DOWN
|| sts
->completion_status
== cpu_to_le16(CS_PORT_UNAVAILABLE
) || sts
->completion_status
== cpu_to_le16(CS_PORT_LOGGED_OUT
) || sts
->completion_status
== cpu_to_le16(CS_PORT_CONFIG_CHANGED
)) && hostdata
->port_db
[Cmnd
->device
->id
].wwn
){
1602 outw(out_ptr
, host
->io_port
+ MBOX5
);
1606 outw(out_ptr
, host
->io_port
+ MBOX5
);
1610 hostdata
->handle_ptrs
[le_hand
] = NULL
;
1612 if (sts
->completion_status
== cpu_to_le16(CS_RESET_OCCURRED
)
1613 || (sts
->status_flags
& cpu_to_le16(STF_BUS_RESET
)))
1614 hostdata
->send_marker
= 1;
1616 if (le16_to_cpu(sts
->scsi_status
) & 0x0200)
1617 memcpy(Cmnd
->sense_buffer
, sts
->req_sense_data
,
1618 sizeof(Cmnd
->sense_buffer
));
1620 outw(out_ptr
, host
->io_port
+ MBOX5
);
1622 if (Cmnd
->scsi_done
!= NULL
) {
1623 (*Cmnd
->scsi_done
) (Cmnd
);
1625 printk("qlogicfc%d : Ouch, scsi done is NULL\n", hostdata
->host_id
);
1627 hostdata
->res_out_ptr
= out_ptr
;
1631 out_ptr
= inw(host
->io_port
+ MBOX4
);
1632 in_ptr
= hostdata
->req_in_ptr
;
1634 num_free
= QLOGICFC_REQ_QUEUE_LEN
- REQ_QUEUE_DEPTH(in_ptr
, out_ptr
);
1635 num_free
= (num_free
> 2) ? num_free
- 2 : 0;
1636 host
->can_queue
= host
->host_busy
+ num_free
;
1637 if (host
->can_queue
> QLOGICFC_REQ_QUEUE_LEN
)
1638 host
->can_queue
= QLOGICFC_REQ_QUEUE_LEN
;
1639 host
->sg_tablesize
= QLOGICFC_MAX_SG(num_free
);
1641 outw(HCCR_CLEAR_RISC_INTR
, host
->io_port
+ HOST_HCCR
);
1642 LEAVE_INTR("isp2x00_intr_handler");
1646 static int isp2x00_return_status(Scsi_Cmnd
*Cmnd
, struct Status_Entry
*sts
)
1648 int host_status
= DID_ERROR
;
1649 #if DEBUG_ISP2x00_INTR
1650 static char *reason
[] =
1663 #endif /* DEBUG_ISP2x00_INTR */
1665 ENTER("isp2x00_return_status");
1667 DEBUG(printk("qlogicfc : completion status = 0x%04x\n",
1668 le16_to_cpu(sts
->completion_status
)));
1670 switch (le16_to_cpu(sts
->completion_status
)) {
1672 host_status
= DID_OK
;
1675 host_status
= DID_ERROR
;
1677 case CS_RESET_OCCURRED
:
1678 host_status
= DID_RESET
;
1681 host_status
= DID_ABORT
;
1684 host_status
= DID_TIME_OUT
;
1686 case CS_DATA_OVERRUN
:
1687 host_status
= DID_ERROR
;
1689 case CS_DATA_UNDERRUN
:
1690 if (Cmnd
->underflow
<= (Cmnd
->request_bufflen
- le32_to_cpu(sts
->residual
)))
1691 host_status
= DID_OK
;
1693 host_status
= DID_ERROR
;
1695 case CS_PORT_UNAVAILABLE
:
1696 case CS_PORT_LOGGED_OUT
:
1697 case CS_PORT_CONFIG_CHANGED
:
1698 host_status
= DID_BAD_TARGET
;
1701 host_status
= DID_ERROR
;
1704 printk("qlogicfc : unknown completion status 0x%04x\n",
1705 le16_to_cpu(sts
->completion_status
));
1706 host_status
= DID_ERROR
;
1710 DEBUG_INTR(printk("qlogicfc : host status (%s) scsi status %x\n",
1711 reason
[host_status
], le16_to_cpu(sts
->scsi_status
)));
1713 LEAVE("isp2x00_return_status");
1715 return (le16_to_cpu(sts
->scsi_status
) & STATUS_MASK
) | (host_status
<< 16);
1719 static int isp2x00_abort(Scsi_Cmnd
* Cmnd
)
1723 struct Scsi_Host
*host
;
1724 struct isp2x00_hostdata
*hostdata
;
1725 int return_status
= SUCCESS
;
1727 ENTER("isp2x00_abort");
1729 host
= Cmnd
->device
->host
;
1730 hostdata
= (struct isp2x00_hostdata
*) host
->hostdata
;
1732 for (i
= 0; i
< QLOGICFC_REQ_QUEUE_LEN
; i
++)
1733 if (hostdata
->handle_ptrs
[i
] == Cmnd
)
1736 if (i
== QLOGICFC_REQ_QUEUE_LEN
){
1740 isp2x00_disable_irqs(host
);
1742 param
[0] = MBOX_ABORT_IOCB
;
1744 param
[1] = (((u_short
) hostdata
->port_db
[Cmnd
->device
->id
].loop_id
) << 8) | Cmnd
->device
->lun
;
1746 param
[1] = (((u_short
) Cmnd
->target
) << 8) | Cmnd
->lun
;
1748 param
[2] = i
& 0xffff;
1751 isp2x00_mbox_command(host
, param
);
1753 if (param
[0] != MBOX_COMMAND_COMPLETE
) {
1754 printk("qlogicfc%d : scsi abort failure: %x\n", hostdata
->host_id
, param
[0]);
1755 if (param
[0] == 0x4005)
1756 Cmnd
->result
= DID_ERROR
<< 16;
1757 if (param
[0] == 0x4006)
1758 Cmnd
->result
= DID_BAD_TARGET
<< 16;
1759 return_status
= FAILED
;
1762 if (return_status
!= SUCCESS
){
1763 param
[0] = MBOX_GET_FIRMWARE_STATE
;
1764 isp2x00_mbox_command(host
, param
);
1765 printk("qlogicfc%d : abort failed\n", hostdata
->host_id
);
1766 printk("qlogicfc%d : firmware status is %x %x\n", hostdata
->host_id
, param
[0], param
[1]);
1769 isp2x00_enable_irqs(host
);
1771 LEAVE("isp2x00_abort");
1773 return return_status
;
1777 static int isp2x00_biosparam(struct scsi_device
*sdev
, struct block_device
*n
,
1778 sector_t capacity
, int ip
[])
1780 int size
= capacity
;
1782 ENTER("isp2x00_biosparam");
1790 ip
[2] = size
/ (ip
[0] * ip
[1]);
1792 LEAVE("isp2x00_biosparam");
1797 static int isp2x00_reset_hardware(struct Scsi_Host
*host
)
1800 struct isp2x00_hostdata
*hostdata
;
1804 ENTER("isp2x00_reset_hardware");
1806 hostdata
= (struct isp2x00_hostdata
*) host
->hostdata
;
1809 * This cannot be right - PCI writes are posted
1810 * (apparently this is hardware design flaw not software ?)
1813 outw(0x01, host
->io_port
+ ISP_CTRL_STATUS
);
1815 outw(HCCR_RESET
, host
->io_port
+ HOST_HCCR
);
1817 outw(HCCR_RELEASE
, host
->io_port
+ HOST_HCCR
);
1818 outw(HCCR_BIOS_DISABLE
, host
->io_port
+ HOST_HCCR
);
1820 loop_count
= DEFAULT_LOOP_COUNT
;
1821 while (--loop_count
&& inw(host
->io_port
+ HOST_HCCR
) == RISC_BUSY
) {
1826 printk("qlogicfc%d : reset_hardware loop timeout\n", hostdata
->host_id
);
1831 printk("qlogicfc%d : mbox 0 0x%04x \n", hostdata
->host_id
, inw(host
->io_port
+ MBOX0
));
1832 printk("qlogicfc%d : mbox 1 0x%04x \n", hostdata
->host_id
, inw(host
->io_port
+ MBOX1
));
1833 printk("qlogicfc%d : mbox 2 0x%04x \n", hostdata
->host_id
, inw(host
->io_port
+ MBOX2
));
1834 printk("qlogicfc%d : mbox 3 0x%04x \n", hostdata
->host_id
, inw(host
->io_port
+ MBOX3
));
1835 printk("qlogicfc%d : mbox 4 0x%04x \n", hostdata
->host_id
, inw(host
->io_port
+ MBOX4
));
1836 printk("qlogicfc%d : mbox 5 0x%04x \n", hostdata
->host_id
, inw(host
->io_port
+ MBOX5
));
1837 printk("qlogicfc%d : mbox 6 0x%04x \n", hostdata
->host_id
, inw(host
->io_port
+ MBOX6
));
1838 printk("qlogicfc%d : mbox 7 0x%04x \n", hostdata
->host_id
, inw(host
->io_port
+ MBOX7
));
1839 #endif /* DEBUG_ISP2x00 */
1841 DEBUG(printk("qlogicfc%d : verifying checksum\n", hostdata
->host_id
));
1843 #if defined(CONFIG_SCSI_QLOGIC_FC_FIRMWARE)
1846 unsigned short * risc_code
= NULL
;
1847 unsigned short risc_code_len
= 0;
1848 if (hostdata
->pci_dev
->device
== PCI_DEVICE_ID_QLOGIC_ISP2100
){
1849 risc_code
= risc_code2100
;
1850 risc_code_len
= risc_code_length2100
;
1852 else if (hostdata
->pci_dev
->device
== PCI_DEVICE_ID_QLOGIC_ISP2200
){
1853 risc_code
= risc_code2200
;
1854 risc_code_len
= risc_code_length2200
;
1857 for (i
= 0; i
< risc_code_len
; i
++) {
1858 param
[0] = MBOX_WRITE_RAM_WORD
;
1859 param
[1] = risc_code_addr01
+ i
;
1860 param
[2] = risc_code
[i
];
1862 isp2x00_mbox_command(host
, param
);
1864 if (param
[0] != MBOX_COMMAND_COMPLETE
) {
1865 printk("qlogicfc%d : firmware load failure\n", hostdata
->host_id
);
1870 #endif /* RELOAD_FIRMWARE */
1872 param
[0] = MBOX_VERIFY_CHECKSUM
;
1873 param
[1] = risc_code_addr01
;
1875 isp2x00_mbox_command(host
, param
);
1877 if (param
[0] != MBOX_COMMAND_COMPLETE
) {
1878 printk("qlogicfc%d : ram checksum failure\n", hostdata
->host_id
);
1881 DEBUG(printk("qlogicfc%d : executing firmware\n", hostdata
->host_id
));
1883 param
[0] = MBOX_EXEC_FIRMWARE
;
1884 param
[1] = risc_code_addr01
;
1886 isp2x00_mbox_command(host
, param
);
1888 param
[0] = MBOX_ABOUT_FIRMWARE
;
1890 isp2x00_mbox_command(host
, param
);
1892 if (param
[0] != MBOX_COMMAND_COMPLETE
) {
1893 printk("qlogicfc%d : about firmware failure\n", hostdata
->host_id
);
1896 DEBUG(printk("qlogicfc%d : firmware major revision %d\n", hostdata
->host_id
, param
[1]));
1897 DEBUG(printk("qlogicfc%d : firmware minor revision %d\n", hostdata
->host_id
, param
[2]));
1899 #ifdef USE_NVRAM_DEFAULTS
1901 if (isp2x00_get_nvram_defaults(host
, &hostdata
->control_block
) != 0) {
1902 printk("qlogicfc%d : Could not read from NVRAM\n", hostdata
->host_id
);
1906 hostdata
->wwn
= (u64
) (cpu_to_le16(hostdata
->control_block
.node_name
[0])) << 56;
1907 hostdata
->wwn
|= (u64
) (cpu_to_le16(hostdata
->control_block
.node_name
[0]) & 0xff00) << 48;
1908 hostdata
->wwn
|= (u64
) (cpu_to_le16(hostdata
->control_block
.node_name
[1]) & 0xff00) << 24;
1909 hostdata
->wwn
|= (u64
) (cpu_to_le16(hostdata
->control_block
.node_name
[1]) & 0x00ff) << 48;
1910 hostdata
->wwn
|= (u64
) (cpu_to_le16(hostdata
->control_block
.node_name
[2]) & 0x00ff) << 24;
1911 hostdata
->wwn
|= (u64
) (cpu_to_le16(hostdata
->control_block
.node_name
[2]) & 0xff00) << 8;
1912 hostdata
->wwn
|= (u64
) (cpu_to_le16(hostdata
->control_block
.node_name
[3]) & 0x00ff) << 8;
1913 hostdata
->wwn
|= (u64
) (cpu_to_le16(hostdata
->control_block
.node_name
[3]) & 0xff00) >> 8;
1915 /* FIXME: If the DMA transfer goes one way only, this should use
1916 * PCI_DMA_TODEVICE and below as well.
1918 busaddr
= pci_map_page(hostdata
->pci_dev
,
1919 virt_to_page(&hostdata
->control_block
),
1920 offset_in_page(&hostdata
->control_block
),
1921 sizeof(hostdata
->control_block
),
1922 PCI_DMA_BIDIRECTIONAL
);
1924 param
[0] = MBOX_INIT_FIRMWARE
;
1925 param
[2] = (u_short
) (pci64_dma_lo32(busaddr
) >> 16);
1926 param
[3] = (u_short
) (pci64_dma_lo32(busaddr
) & 0xffff);
1929 param
[6] = (u_short
) (pci64_dma_hi32(busaddr
) >> 16);
1930 param
[7] = (u_short
) (pci64_dma_hi32(busaddr
) & 0xffff);
1931 isp2x00_mbox_command(host
, param
);
1932 if (param
[0] != MBOX_COMMAND_COMPLETE
) {
1933 printk("qlogicfc%d.c: Ouch 0x%04x\n", hostdata
->host_id
, param
[0]);
1934 pci_unmap_page(hostdata
->pci_dev
, busaddr
,
1935 sizeof(hostdata
->control_block
),
1936 PCI_DMA_BIDIRECTIONAL
);
1939 param
[0] = MBOX_GET_FIRMWARE_STATE
;
1940 isp2x00_mbox_command(host
, param
);
1941 if (param
[0] != MBOX_COMMAND_COMPLETE
) {
1942 printk("qlogicfc%d.c: 0x%04x\n", hostdata
->host_id
, param
[0]);
1943 pci_unmap_page(hostdata
->pci_dev
, busaddr
,
1944 sizeof(hostdata
->control_block
),
1945 PCI_DMA_BIDIRECTIONAL
);
1949 pci_unmap_page(hostdata
->pci_dev
, busaddr
,
1950 sizeof(hostdata
->control_block
),
1951 PCI_DMA_BIDIRECTIONAL
);
1952 LEAVE("isp2x00_reset_hardware");
1957 #ifdef USE_NVRAM_DEFAULTS
1959 static int isp2x00_get_nvram_defaults(struct Scsi_Host
*host
, struct init_cb
*control_block
)
1963 if (isp2x00_read_nvram_word(host
, 0) != 0x5349)
1966 value
= isp2x00_read_nvram_word(host
, 8);
1967 control_block
->node_name
[0] = cpu_to_le16(isp2x00_read_nvram_word(host
, 9));
1968 control_block
->node_name
[1] = cpu_to_le16(isp2x00_read_nvram_word(host
, 10));
1969 control_block
->node_name
[2] = cpu_to_le16(isp2x00_read_nvram_word(host
, 11));
1970 control_block
->node_name
[3] = cpu_to_le16(isp2x00_read_nvram_word(host
, 12));
1971 control_block
->hard_addr
= cpu_to_le16(isp2x00_read_nvram_word(host
, 13));
1979 static int isp2x00_init(struct Scsi_Host
*sh
)
1982 struct isp2x00_hostdata
*hostdata
;
1986 struct pci_dev
*pdev
;
1989 ENTER("isp2x00_init");
1991 hostdata
= (struct isp2x00_hostdata
*) sh
->hostdata
;
1992 pdev
= hostdata
->pci_dev
;
1994 if (pci_read_config_word(pdev
, PCI_COMMAND
, &command
)
1995 || pci_read_config_byte(pdev
, PCI_CLASS_REVISION
, &revision
)) {
1996 printk("qlogicfc%d : error reading PCI configuration\n", hostdata
->host_id
);
1999 io_base
= pci_resource_start(pdev
, 0);
2003 if (pdev
->vendor
!= PCI_VENDOR_ID_QLOGIC
) {
2004 printk("qlogicfc%d : 0x%04x is not QLogic vendor ID\n", hostdata
->host_id
,
2008 if (pdev
->device
!= PCI_DEVICE_ID_QLOGIC_ISP2100
&& pdev
->device
!= PCI_DEVICE_ID_QLOGIC_ISP2200
) {
2009 printk("qlogicfc%d : 0x%04x does not match ISP2100 or ISP2200 device id\n", hostdata
->host_id
,
2013 if (!(command
& PCI_COMMAND_IO
) ||
2014 !(pdev
->resource
[0].flags
& IORESOURCE_IO
)) {
2015 printk("qlogicfc%d : i/o mapping is disabled\n", hostdata
->host_id
);
2019 pci_set_master(pdev
);
2020 if (revision
!= ISP2100_REV_ID1
&& revision
!= ISP2100_REV_ID3
&& revision
!= ISP2200_REV_ID5
)
2021 printk("qlogicfc%d : new isp2x00 revision ID (%d)\n", hostdata
->host_id
, revision
);
2024 hostdata
->revision
= revision
;
2027 sh
->io_port
= io_base
;
2029 LEAVE("isp2x00_init");
2034 #if USE_NVRAM_DEFAULTS
2036 #define NVRAM_DELAY() udelay(10) /* 10 microsecond delay */
2039 u_short
isp2x00_read_nvram_word(struct Scsi_Host
* host
, u_short byte
)
2042 u_short value
, output
, input
;
2044 outw(0x2, host
->io_port
+ PCI_NVRAM
);
2046 outw(0x3, host
->io_port
+ PCI_NVRAM
);
2051 for (i
= 10; i
>= 0; i
--) {
2052 output
= ((byte
>> i
) & 0x1) ? 0x4 : 0x0;
2053 outw(output
| 0x2, host
->io_port
+ PCI_NVRAM
);
2055 outw(output
| 0x3, host
->io_port
+ PCI_NVRAM
);
2057 outw(output
| 0x2, host
->io_port
+ PCI_NVRAM
);
2061 for (i
= 0xf, value
= 0; i
>= 0; i
--) {
2063 outw(0x3, host
->io_port
+ PCI_NVRAM
);
2065 input
= inw(host
->io_port
+ PCI_NVRAM
);
2067 outw(0x2, host
->io_port
+ PCI_NVRAM
);
2073 outw(0x0, host
->io_port
+ PCI_NVRAM
);
2080 #endif /* USE_NVRAM_DEFAULTS */
2085 * currently, this is only called during initialization or abort/reset,
2086 * at which times interrupts are disabled, so polling is OK, I guess...
2088 static int isp2x00_mbox_command(struct Scsi_Host
*host
, u_short param
[])
2091 struct isp2x00_hostdata
*hostdata
= (struct isp2x00_hostdata
*) host
->hostdata
;
2093 if (mbox_param
[param
[0]] == 0 || hostdata
->adapter_state
== AS_FIRMWARE_DEAD
)
2096 loop_count
= DEFAULT_LOOP_COUNT
;
2097 while (--loop_count
&& inw(host
->io_port
+ HOST_HCCR
) & 0x0080) {
2102 printk("qlogicfc%d : mbox_command loop timeout #1\n", hostdata
->host_id
);
2104 hostdata
->adapter_state
= AS_FIRMWARE_DEAD
;
2107 hostdata
->mbox_done
= 0;
2109 if (mbox_param
[param
[0]] == 0)
2110 printk("qlogicfc%d : invalid mbox command\n", hostdata
->host_id
);
2112 if (mbox_param
[param
[0]] & 0x80)
2113 outw(param
[7], host
->io_port
+ MBOX7
);
2114 if (mbox_param
[param
[0]] & 0x40)
2115 outw(param
[6], host
->io_port
+ MBOX6
);
2116 if (mbox_param
[param
[0]] & 0x20)
2117 outw(param
[5], host
->io_port
+ MBOX5
);
2118 if (mbox_param
[param
[0]] & 0x10)
2119 outw(param
[4], host
->io_port
+ MBOX4
);
2120 if (mbox_param
[param
[0]] & 0x08)
2121 outw(param
[3], host
->io_port
+ MBOX3
);
2122 if (mbox_param
[param
[0]] & 0x04)
2123 outw(param
[2], host
->io_port
+ MBOX2
);
2124 if (mbox_param
[param
[0]] & 0x02)
2125 outw(param
[1], host
->io_port
+ MBOX1
);
2126 if (mbox_param
[param
[0]] & 0x01)
2127 outw(param
[0], host
->io_port
+ MBOX0
);
2130 outw(HCCR_SET_HOST_INTR
, host
->io_port
+ HOST_HCCR
);
2133 loop_count
= DEFAULT_LOOP_COUNT
;
2134 while (--loop_count
&& !(inw(host
->io_port
+ PCI_INTER_STS
) & 0x08)) {
2140 hostdata
->adapter_state
= AS_FIRMWARE_DEAD
;
2141 printk("qlogicfc%d : mbox_command loop timeout #2\n", hostdata
->host_id
);
2144 isp2x00_intr_handler(host
->irq
, host
, NULL
);
2146 if (hostdata
->mbox_done
== 1)
2151 loop_count
= DEFAULT_LOOP_COUNT
;
2152 while (--loop_count
&& inw(host
->io_port
+ MBOX0
) == 0x04) {
2157 printk("qlogicfc%d : mbox_command loop timeout #3\n", hostdata
->host_id
);
2159 param
[7] = inw(host
->io_port
+ MBOX7
);
2160 param
[6] = inw(host
->io_port
+ MBOX6
);
2161 param
[5] = inw(host
->io_port
+ MBOX5
);
2162 param
[4] = inw(host
->io_port
+ MBOX4
);
2163 param
[3] = inw(host
->io_port
+ MBOX3
);
2164 param
[2] = inw(host
->io_port
+ MBOX2
);
2165 param
[1] = inw(host
->io_port
+ MBOX1
);
2166 param
[0] = inw(host
->io_port
+ MBOX0
);
2169 outw(0x0, host
->io_port
+ PCI_SEMAPHORE
);
2171 if (inw(host
->io_port
+ HOST_HCCR
) & 0x0080) {
2172 hostdata
->adapter_state
= AS_FIRMWARE_DEAD
;
2173 printk("qlogicfc%d : mbox op is still pending\n", hostdata
->host_id
);
2178 #if DEBUG_ISP2x00_INTR
2180 void isp2x00_print_status_entry(struct Status_Entry
*status
)
2182 printk("qlogicfc : entry count = 0x%02x, type = 0x%02x, flags = 0x%02x\n",
2183 status
->hdr
.entry_cnt
, status
->hdr
.entry_type
, status
->hdr
.flags
);
2184 printk("qlogicfc : scsi status = 0x%04x, completion status = 0x%04x\n",
2185 le16_to_cpu(status
->scsi_status
), le16_to_cpu(status
->completion_status
));
2186 printk("qlogicfc : state flags = 0x%04x, status flags = 0x%04x\n",
2187 le16_to_cpu(status
->state_flags
), le16_to_cpu(status
->status_flags
));
2188 printk("qlogicfc : response info length = 0x%04x, request sense length = 0x%04x\n",
2189 le16_to_cpu(status
->res_info_len
), le16_to_cpu(status
->req_sense_len
));
2190 printk("qlogicfc : residual transfer length = 0x%08x, response = 0x%02x\n", le32_to_cpu(status
->residual
), status
->res_info
[3]);
2194 #endif /* DEBUG_ISP2x00_INTR */
2199 void isp2x00_print_scsi_cmd(Scsi_Cmnd
* cmd
)
2203 printk("qlogicfc : target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
2204 cmd
->target
, cmd
->lun
, cmd
->cmd_len
);
2205 printk("qlogicfc : command = ");
2206 for (i
= 0; i
< cmd
->cmd_len
; i
++)
2207 printk("0x%02x ", cmd
->cmnd
[i
]);
2211 #endif /* DEBUG_ISP2x00 */
2213 MODULE_LICENSE("GPL");
2215 static struct scsi_host_template driver_template
= {
2216 .detect
= isp2x00_detect
,
2217 .release
= isp2x00_release
,
2218 .info
= isp2x00_info
,
2219 .queuecommand
= isp2x00_queuecommand
,
2220 .eh_abort_handler
= isp2x00_abort
,
2221 .bios_param
= isp2x00_biosparam
,
2222 .can_queue
= QLOGICFC_REQ_QUEUE_LEN
,
2224 .sg_tablesize
= QLOGICFC_MAX_SG(QLOGICFC_REQ_QUEUE_LEN
),
2225 .cmd_per_lun
= QLOGICFC_CMD_PER_LUN
,
2226 .use_clustering
= ENABLE_CLUSTERING
,
2228 #include "scsi_module.c"