openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6 

* master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6: (39 commits)
  [SCSI] qla2xxx: Update version number to 8.02.00-k5.
  [SCSI] qla2xxx: Correct display of ISP serial-number.
  [SCSI] qla2xxx: Correct residual-count handling discrepancies during UNDERRUN handling.
  [SCSI] qla2xxx: Make driver (mostly) legacy I/O port free.
  [SCSI] qla2xxx: Fix issue where final flash-segment updates were falling into the slow-path write handler.
  [SCSI] qla2xxx: Handle unaligned sector writes during NVRAM/VPD updates.
  [SCSI] qla2xxx: Defer explicit interrupt-polling processing to init-time scenarios.
  [SCSI] qla2xxx: Resync with latest HBA SSID specification -- 2.2u.
  [SCSI] sym53c8xx: Remove sym_xpt_async_sent_bdr
  [SCSI] sym53c8xx: Remove pci_dev pointer from sym_shcb
  [SCSI] sym53c8xx: Make interrupt handler capable of returning IRQ_NONE
  [SCSI] sym53c8xx: Get rid of IRQ_FMT and IRQ_PRM
  [SCSI] sym53c8xx: Use scmd_printk where appropriate
  [SCSI] sym53c8xx: Simplify DAC DMA handling
  [SCSI] sym53c8xx: Remove tag_ctrl module parameter
  [SCSI] sym53c8xx: Remove io_ws, mmio_ws and ram_ws elements
  [SCSI] sym53c8xx: Remove ->device_id
  [SCSI] sym53c8xx: Use pdev->revision
  [SCSI] sym53c8xx: PCI Error Recovery support
  [SCSI] sym53c8xx: Stop overriding scsi_done
  ...
This commit is contained in:
Linus Torvalds 2007-10-23 16:37:29 -07:00
parent af76bbabbd af2709fd0d
commit 1212663fba
60 changed files with 675 additions and 5316 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Documentation/scsi/sym53c8xx_2.txt
View File

@ -449,25 +449,14 @@ options as above.
cmd_per_lun=#tags (#tags > 1) tagged command queuing enabled cmd_per_lun=#tags (#tags > 1) tagged command queuing enabled
#tags will be truncated to the max queued commands configuration parameter. #tags will be truncated to the max queued commands configuration parameter.
10.2.2 Detailed control of tagged commands 10.2.2 Burst max
This option allows you to specify a command queue depth for each device
that supports tagged command queueing.
Example:
tag_ctrl=10/t2t3q16-t5q24/t1u2q32
will set devices queue depth as follow:
- controller #0 target #2 and target #3 -> 16 commands,
- controller #0 target #5 -> 24 commands,
- controller #1 target #1 logical unit #2 -> 32 commands,
- all other logical units (all targets, all controllers) -> 10 commands.
10.2.3 Burst max
burst=0 burst disabled burst=0 burst disabled
burst=255 get burst length from initial IO register settings. burst=255 get burst length from initial IO register settings.
burst=#x burst enabled (1<<#x burst transfers max) burst=#x burst enabled (1<<#x burst transfers max)
#x is an integer value which is log base 2 of the burst transfers max. #x is an integer value which is log base 2 of the burst transfers max.
By default the driver uses the maximum value supported by the chip. By default the driver uses the maximum value supported by the chip.
10.2.4 LED support 10.2.3 LED support
led=1 enable LED support led=1 enable LED support
led=0 disable LED support led=0 disable LED support
Do not enable LED support if your scsi board does not use SDMS BIOS. Do not enable LED support if your scsi board does not use SDMS BIOS.
@ -560,9 +549,9 @@ Previously, the sym2 driver accepted arguments of the form
sym53c8xx=tags:4,sync:10,debug:0x200 sym53c8xx=tags:4,sync:10,debug:0x200
As a result of the new module parameters, this is no longer available. As a result of the new module parameters, this is no longer available.
Most of the options have remained the same, but tags has split into Most of the options have remained the same, but tags has become
cmd_per_lun and tag_ctrl for its two different purposes. The sample above cmd_per_lun to reflect its different purposes. The sample above would
would be specified as: be specified as:
modprobe sym53c8xx cmd_per_lun=4 sync=10 debug=0x200 modprobe sym53c8xx cmd_per_lun=4 sync=10 debug=0x200
or on the kernel boot line as: or on the kernel boot line as:

6
MAINTAINERS
View File

@ -325,6 +325,12 @@ M: Juergen Fischer <fischer@norbit.de>
L: linux-scsi@vger.kernel.org L: linux-scsi@vger.kernel.org
S: Maintained S: Maintained
AIC7XXX / AIC79XX SCSI DRIVER
P: Hannes Reinecke
M: hare@suse.de
L: linux-scsi@vger.kernel.org
S: Maintained
ALCATEL SPEEDTOUCH USB DRIVER ALCATEL SPEEDTOUCH USB DRIVER
P: Duncan Sands P: Duncan Sands
M: duncan.sands@free.fr M: duncan.sands@free.fr

2
arch/sparc64/Kconfig
View File

@ -460,8 +460,6 @@ source "drivers/Kconfig"
source "drivers/sbus/char/Kconfig" source "drivers/sbus/char/Kconfig"
source "drivers/fc4/Kconfig"
source "fs/Kconfig" source "fs/Kconfig"
source "kernel/Kconfig.instrumentation" source "kernel/Kconfig.instrumentation"

1
drivers/Makefile
View File

@ -34,7 +34,6 @@ obj-$(CONFIG_NUBUS) += nubus/
obj-$(CONFIG_ATM) += atm/ obj-$(CONFIG_ATM) += atm/
obj-y += macintosh/ obj-y += macintosh/
obj-$(CONFIG_IDE) += ide/ obj-$(CONFIG_IDE) += ide/
obj-$(CONFIG_FC4) += fc4/
obj-$(CONFIG_SCSI) += scsi/ obj-$(CONFIG_SCSI) += scsi/
obj-$(CONFIG_ATA) += ata/ obj-$(CONFIG_ATA) += ata/
obj-$(CONFIG_FUSION) += message/ obj-$(CONFIG_FUSION) += message/

81
drivers/fc4/Kconfig
View File

@ -1,81 +0,0 @@
#
# FC4 device configuration
#
menu "Fibre Channel support"
config FC4
tristate "Fibre Channel and FC4 SCSI support"
---help---
Fibre Channel is a high speed serial protocol mainly used to
connect large storage devices to the computer; it is compatible with
and intended to replace SCSI.
This is an experimental support for storage arrays connected to your
computer using optical fibre cables and the "X3.269-199X Fibre
Channel Protocol for SCSI" specification. If you want to use this,
you need to say Y here and to "SCSI support" as well as to the
drivers for the storage array itself and for the interface adapter
such as SOC or SOC+. This subsystem could even serve for IP
networking, with some code extensions.
If unsure, say N.
comment "FC4 drivers"
depends on FC4
config FC4_SOC
tristate "Sun SOC/Sbus"
depends on FC4!=n && SPARC
help
Serial Optical Channel is an interface card with one or two Fibre
Optic ports, each of which can be connected to a disk array. Note
that if you have older firmware in the card, you'll need the
microcode from the Solaris driver to make it work.
To compile this support as a module, choose M here: the module will
be called soc.
config FC4_SOCAL
tristate "Sun SOC+ (aka SOCAL)"
depends on FC4!=n && SPARC
---help---
Serial Optical Channel Plus is an interface card with up to two
Fibre Optic ports. This card supports FC Arbitrated Loop (usually
A5000 or internal FC disks in E[3-6]000 machines through the
Interface Board). You'll probably need the microcode from the
Solaris driver to make it work.
To compile this support as a module, choose M here: the module will
be called socal.
comment "FC4 targets"
depends on FC4
config SCSI_PLUTO
tristate "SparcSTORAGE Array 100 and 200 series"
depends on FC4!=n && SCSI
help
If you never bought a disk array made by Sun, go with N.
To compile this support as a module, choose M here: the module will
be called pluto.
config SCSI_FCAL
tristate "Sun Enterprise Network Array (A5000 and EX500)" if SPARC
depends on FC4!=n && SCSI
help
This driver drives FC-AL disks connected through a Fibre Channel
card using the drivers/fc4 layer (currently only SOCAL). The most
common is either A5000 array or internal disks in E[3-6]000
machines.
To compile this support as a module, choose M here: the module will
be called fcal.
config SCSI_FCAL
prompt "Generic FC-AL disk driver"
depends on FC4!=n && SCSI && !SPARC
endmenu

9
drivers/fc4/Makefile
View File

@ -1,9 +0,0 @@
#
# Makefile for the Linux Fibre Channel device drivers.
#
fc4-objs := fc.o fc_syms.o
obj-$(CONFIG_FC4) += fc4.o
obj-$(CONFIG_FC4_SOC) += soc.o
obj-$(CONFIG_FC4_SOCAL) += socal.o

27
drivers/fc4/fc-al.h
View File

@ -1,27 +0,0 @@
/* fc-al.h: Definitions for Fibre Channel Arbitrated Loop topology.
*
* Copyright (C) 1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
*
* Sources:
* Fibre Channel Arbitrated Loop (FC-AL), ANSI, Rev. 4.5, 1995
*/
#ifndef __FC_AL_H
#define __FC_AL_H
/* Loop initialization payloads */
#define FC_AL_LISM 0x11010000 /* Select Master, 12B payload */
#define FC_AL_LIFA 0x11020000 /* Fabric Assign AL_PA bitmap, 20B payload */
#define FC_AL_LIPA 0x11030000 /* Previously Acquired AL_PA bitmap, 20B payload */
#define FC_AL_LIHA 0x11040000 /* Hard Assigned AL_PA bitmap, 20B payload */
#define FC_AL_LISA 0x11050000 /* Soft Assigned AL_PA bitmap, 20B payload */
#define FC_AL_LIRP 0x11060000 /* Report AL_PA position map, 132B payload */
#define FC_AL_LILP 0x11070000 /* Loop AL_PA position map, 132B payload */
typedef struct {
u32 magic;
u8 len;
u8 alpa[127];
} fc_al_posmap;
#endif /* !(__FC_H) */

1146
drivers/fc4/fc.c
View File

File diff suppressed because it is too large Load Diff

230
drivers/fc4/fc.h
View File

@ -1,230 +0,0 @@
/* fc.h: Definitions for Fibre Channel Physical and Signaling Interface.
*
* Copyright (C) 1996-1997,1999 Jakub Jelinek (jj@ultra.linux.cz)
*
* Sources:
* Fibre Channel Physical & Signaling Interface (FC-PH), dpANS, 1994
* dpANS Fibre Channel Protocol for SCSI (X3.269-199X), Rev. 012, 1995
*/
#ifndef __FC_H
#define __FC_H
/* World Wide Name */
#define NAAID_IEEE 1
#define NAAID_IEEE_EXT 2
#define NAAID_LOCAL 3
#define NAAID_IP 4
#define NAAID_IEEE_REG 5
#define NAAID_IEEE_REG_EXT 6
#define NAAID_CCITT 12
#define NAAID_CCITT_GRP 14
/* This is NAAID_IEEE_EXT scheme */
typedef struct {
u32 naaid:4;
u32 nportid:12;
u32 hi:16;
u32 lo;
} fc_wwn;
/* Frame header for FC-PH frames */
/* r_ctl field */
#define R_CTL_DEVICE_DATA 0x00 /* FC4 Device_Data frame */
#define R_CTL_EXTENDED_SVC 0x20 /* Extended Link_Data frame */
#define R_CTL_FC4_SVC 0x30 /* FC4 Link_Data frame */
#define R_CTL_VIDEO 0x40 /* Video_Data frame */
#define R_CTL_BASIC_SVC 0x80 /* Basic Link_Data frame */
#define R_CTL_LINK_CTL 0xc0 /* Link_Control frame */
/* FC4 Device_Data frames */
#define R_CTL_UNCATEGORIZED 0x00
#define R_CTL_SOLICITED_DATA 0x01
#define R_CTL_UNSOL_CONTROL 0x02
#define R_CTL_SOLICITED_CONTROL 0x03
#define R_CTL_UNSOL_DATA 0x04
#define R_CTL_XFER_RDY 0x05
#define R_CTL_COMMAND 0x06
#define R_CTL_STATUS 0x07
/* Basic Link_Data frames */
#define R_CTL_LS_NOP 0x80
#define R_CTL_LS_ABTS 0x81
#define R_CTL_LS_RMC 0x82
#define R_CTL_LS_BA_ACC 0x84
#define R_CTL_LS_BA_RJT 0x85
/* Extended Link_Data frames */
#define R_CTL_ELS_REQ 0x22
#define R_CTL_ELS_RSP 0x23
/* Link_Control frames */
#define R_CTL_ACK_1 0xc0
#define R_CTL_ACK_N 0xc1
#define R_CTL_P_RJT 0xc2
#define R_CTL_F_RJT 0xc3
#define R_CTL_P_BSY 0xc4
#define R_CTL_F_BSY_DF 0xc5
#define R_CTL_F_BSY_LC 0xc6
#define R_CTL_LCR 0xc7
/* type field */
#define TYPE_BASIC_LS 0x00
#define TYPE_EXTENDED_LS 0x01
#define TYPE_IS8802 0x04
#define TYPE_IS8802_SNAP 0x05
#define TYPE_SCSI_FCP 0x08
#define TYPE_SCSI_GPP 0x09
#define TYPE_HIPP_FP 0x0a
#define TYPE_IPI3_MASTER 0x11
#define TYPE_IPI3_SLAVE 0x12
#define TYPE_IPI3_PEER 0x13
/* f_ctl field */
#define F_CTL_FILL_BYTES 0x000003
#define F_CTL_XCHG_REASSEMBLE 0x000004
#define F_CTL_RO_PRESENT 0x000008
#define F_CTL_ABORT_SEQ 0x000030
#define F_CTL_CONTINUE_SEQ 0x0000c0
#define F_CTL_INVALIDATE_XID 0x004000
#define F_CTL_XID_REASSIGNED 0x008000
#define F_CTL_SEQ_INITIATIVE 0x010000
#define F_CTL_CHAINED_SEQ 0x020000
#define F_CTL_END_CONNECT 0x040000
#define F_CTL_END_SEQ 0x080000
#define F_CTL_LAST_SEQ 0x100000
#define F_CTL_FIRST_SEQ 0x200000
#define F_CTL_SEQ_CONTEXT 0x400000
#define F_CTL_XCHG_CONTEXT 0x800000
typedef struct {
u32 r_ctl:8, did:24;
u32 xxx1:8, sid:24;
u32 type:8, f_ctl:24;
u32 seq_id:8, df_ctl:8, seq_cnt:16;
u16 ox_id, rx_id;
u32 param;
} fc_hdr;
/* The following are ugly macros to make setup of this structure faster */
#define FILL_FCHDR_RCTL_DID(fch, r_ctl, did) *(u32 *)(fch) = ((r_ctl) << 24) | (did);
#define FILL_FCHDR_SID(fch, sid) *((u32 *)(fch)+1) = (sid);
#define FILL_FCHDR_TYPE_FCTL(fch, type, f_ctl) *((u32 *)(fch)+2) = ((type) << 24) | (f_ctl);
#define FILL_FCHDR_SEQ_DF_SEQ(fch, seq_id, df_ctl, seq_cnt) *((u32 *)(fch)+3) = ((seq_id) << 24) | ((df_ctl) << 16) | (seq_cnt);
#define FILL_FCHDR_OXRX(fch, ox_id, rx_id) *((u32 *)(fch)+4) = ((ox_id) << 16) | (rx_id);
/* Well known addresses */
#define FS_GENERAL_MULTICAST 0xfffff7
#define FS_WELL_KNOWN_MULTICAST 0xfffff8
#define FS_HUNT_GROUP 0xfffff9
#define FS_MANAGEMENT_SERVER 0xfffffa
#define FS_TIME_SERVER 0xfffffb
#define FS_NAME_SERVER 0xfffffc
#define FS_FABRIC_CONTROLLER 0xfffffd
#define FS_FABRIC_F_PORT 0xfffffe
#define FS_BROADCAST 0xffffff
/* Reject frames */
/* The param field should be cast to this structure */
typedef struct {
u8 action;
u8 reason;
u8 xxx;
u8 vendor_unique;
} rjt_param;
/* Reject action codes */
#define RJT_RETRY 0x01
#define RJT_NONRETRY 0x02
/* Reject reason codes */
#define RJT_INVALID_DID 0x01
#define RJT_INVALID_SID 0x02
#define RJT_NPORT_NOT_AVAIL_TEMP 0x03
#define RJT_NPORT_NOT_AVAIL_PERM 0x04
#define RJT_CLASS_NOT_SUPPORTED 0x05
#define RJT_DELIMITER_ERROR 0x06
#define RJT_TYPE_NOT_SUPPORTED 0x07
#define RJT_INVALID_LINK_CONTROL 0x08
#define RJT_INVALID_R_CTL 0x09
#define RJT_INVALID_F_CTL 0x0a
#define RJT_INVALID_OX_ID 0x0b
#define RJT_INVALID_RX_ID 0x0c
#define RJT_INVALID_SEQ_ID 0x0d
#define RJT_INVALID_DF_CTL 0x0e
#define RJT_INVALID_SEQ_CNT 0x0f
#define RJT_INVALID_PARAMETER 0x10
#define RJT_EXCHANGE_ERROR 0x11
#define RJT_PROTOCOL_ERROR 0x12
#define RJT_INCORRECT_LENGTH 0x13
#define RJT_UNEXPECTED_ACK 0x14
#define RJT_UNEXPECTED_LINK_RESP 0x15
#define RJT_LOGIN_REQUIRED 0x16
#define RJT_EXCESSIVE_SEQUENCES 0x17
#define RJT_CANT_ESTABLISH_EXCHANGE 0x18
#define RJT_SECURITY_NOT_SUPPORTED 0x19
#define RJT_FABRIC_NA 0x1a
#define RJT_VENDOR_UNIQUE 0xff
#define SP_F_PORT_LOGIN 0x10
/* Extended SVC commands */
#define LS_RJT 0x01000000
#define LS_ACC 0x02000000
#define LS_PRLI_ACC 0x02100014
#define LS_PLOGI 0x03000000
#define LS_FLOGI 0x04000000
#define LS_LOGO 0x05000000
#define LS_ABTX 0x06000000
#define LS_RCS 0x07000000
#define LS_RES 0x08000000
#define LS_RSS 0x09000000
#define LS_RSI 0x0a000000
#define LS_ESTS 0x0b000000
#define LS_ESTC 0x0c000000
#define LS_ADVC 0x0d000000
#define LS_RTV 0x0e000000
#define LS_RLS 0x0f000000
#define LS_ECHO 0x10000000
#define LS_TEST 0x11000000
#define LS_RRQ 0x12000000
#define LS_IDENT 0x20000000
#define LS_PRLI 0x20100014
#define LS_DISPLAY 0x21000000
#define LS_PRLO 0x21100014
#define LS_PDISC 0x50000000
#define LS_ADISC 0x52000000
typedef struct {
u8 fcph_hi, fcph_lo;
u16 buf2buf_credit;
u8 common_features;
u8 xxx1;
u16 buf2buf_size;
u8 xxx2;
u8 total_concurrent;
u16 off_by_info;
u32 e_d_tov;
} common_svc_parm;
typedef struct {
u16 serv_opts;
u16 initiator_ctl;
u16 rcpt_ctl;
u16 recv_size;
u8 xxx1;
u8 concurrent_seqs;
u16 end2end_credit;
u16 open_seqs_per_xchg;
u16 xxx2;
} svc_parm;
/* Login */
typedef struct {
u32 code;
common_svc_parm common;
fc_wwn nport_wwn;
fc_wwn node_wwn;
svc_parm class1;
svc_parm class2;
svc_parm class3;
} logi;
#endif /* !(__FC_H) */

30
drivers/fc4/fc_syms.c
View File

@ -1,30 +0,0 @@
/*
* We should not even be trying to compile this if we are not doing
* a module.
*/
#include <linux/module.h>
#ifdef CONFIG_MODULES
#include <linux/types.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include "fcp_impl.h"
EXPORT_SYMBOL(fcp_init);
EXPORT_SYMBOL(fcp_release);
EXPORT_SYMBOL(fcp_queue_empty);
EXPORT_SYMBOL(fcp_receive_solicited);
EXPORT_SYMBOL(fc_channels);
EXPORT_SYMBOL(fcp_state_change);
EXPORT_SYMBOL(fc_do_plogi);
EXPORT_SYMBOL(fc_do_prli);
/* SCSI stuff */
EXPORT_SYMBOL(fcp_scsi_queuecommand);
EXPORT_SYMBOL(fcp_scsi_abort);
EXPORT_SYMBOL(fcp_scsi_dev_reset);
EXPORT_SYMBOL(fcp_scsi_host_reset);
#endif /* CONFIG_MODULES */

94
drivers/fc4/fcp.h
View File

@ -1,94 +0,0 @@
/* fcp.h: Definitions for Fibre Channel Protocol.
*
* Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
*
*/
#ifndef __FCP_H
#define __FCP_H
/* FCP addressing is hierarchical with up to 4 layers, MS first.
Exact meaning of the addresses is up to the vendor */
/* fcp_cntl field */
#define FCP_CNTL_WRITE 0x00000001 /* Initiator write */
#define FCP_CNTL_READ 0x00000002 /* Initiator read */
#define FCP_CNTL_ABORT_TSK 0x00000200 /* Abort task set */
#define FCP_CNTL_CLR_TASK 0x00000400 /* Clear task set */
#define FCP_CNTL_RESET 0x00002000 /* Reset */
#define FCP_CNTL_CLR_ACA 0x00004000 /* Clear ACA */
#define FCP_CNTL_KILL_TASK 0x00008000 /* Terminate task */
#define FCP_CNTL_QTYPE_MASK 0x00070000 /* Tagged queueing type */
#define FCP_CNTL_QTYPE_SIMPLE 0x00000000
#define FCP_CNTL_QTYPE_HEAD_OF_Q 0x00010000
#define FCP_CNTL_QTYPE_ORDERED 0x00020000
#define FCP_CNTL_QTYPE_ACA_Q_TAG 0x00040000
#define FCP_CNTL_QTYPE_UNTAGGED 0x00050000
typedef struct {
u16 fcp_addr[4];
u32 fcp_cntl;
u8 fcp_cdb[16];
u32 fcp_data_len;
} fcp_cmd;
/* fcp_status field */
#define FCP_STATUS_MASK 0x000000ff /* scsi status of command */
#define FCP_STATUS_RSP_LEN 0x00000100 /* response_len != 0 */
#define FCP_STATUS_SENSE_LEN 0x00000200 /* sense_len != 0 */
#define FCP_STATUS_RESID 0x00000400 /* resid != 0 */
typedef struct {
u32 xxx[2];
u32 fcp_status;
u32 fcp_resid;
u32 fcp_sense_len;
u32 fcp_response_len;
/* u8 fcp_sense[fcp_sense_len]; */
/* u8 fcp_response[fcp_response_len]; */
} fcp_rsp;
/* fcp errors */
/* rsp_info_type field */
#define FCP_RSP_SCSI_BUS_ERR 0x01
#define FCP_RSP_SCSI_PORT_ERR 0x02
#define FCP_RSP_CARD_ERR 0x03
/* isp_status field */
#define FCP_RSP_CMD_COMPLETE 0x0000
#define FCP_RSP_CMD_INCOMPLETE 0x0001
#define FCP_RSP_CMD_DMA_ERR 0x0002
#define FCP_RSP_CMD_TRAN_ERR 0x0003
#define FCP_RSP_CMD_RESET 0x0004
#define FCP_RSP_CMD_ABORTED 0x0005
#define FCP_RSP_CMD_TIMEOUT 0x0006
#define FCP_RSP_CMD_OVERRUN 0x0007
/* isp_state_flags field */
#define FCP_RSP_ST_GOT_BUS 0x0100
#define FCP_RSP_ST_GOT_TARGET 0x0200
#define FCP_RSP_ST_SENT_CMD 0x0400
#define FCP_RSP_ST_XFRD_DATA 0x0800
#define FCP_RSP_ST_GOT_STATUS 0x1000
#define FCP_RSP_ST_GOT_SENSE 0x2000
/* isp_stat_flags field */
#define FCP_RSP_STAT_DISC 0x0001
#define FCP_RSP_STAT_SYNC 0x0002
#define FCP_RSP_STAT_PERR 0x0004
#define FCP_RSP_STAT_BUS_RESET 0x0008
#define FCP_RSP_STAT_DEV_RESET 0x0010
#define FCP_RSP_STAT_ABORTED 0x0020
#define FCP_RSP_STAT_TIMEOUT 0x0040
#define FCP_RSP_STAT_NEGOTIATE 0x0080
typedef struct {
u8 rsp_info_type;
u8 xxx;
u16 isp_status;
u16 isp_state_flags;
u16 isp_stat_flags;
} fcp_scsi_err;
#endif /* !(__FCP_H) */

164
drivers/fc4/fcp_impl.h
View File

@ -1,164 +0,0 @@
/* fcp_impl.h: Generic SCSI on top of FC4 - our interface defines.
*
* Copyright (C) 1997-1999 Jakub Jelinek (jj@ultra.linux.cz)
* Copyright (C) 1998 Jirka Hanika (geo@ff.cuni.cz)
*/
#ifndef _FCP_SCSI_H
#define _FCP_SCSI_H
#include <linux/types.h>
#include "../scsi/scsi.h"
#include "fc.h"
#include "fcp.h"
#include "fc-al.h"
#include <asm/io.h>
#ifdef __sparc__
#include <asm/sbus.h>
#endif
/* 0 or 1 */
#define FCP_SCSI_USE_NEW_EH_CODE 0
#define FC_CLASS_OUTBOUND 0x01
#define FC_CLASS_INBOUND 0x02
#define FC_CLASS_SIMPLE 0x03
#define FC_CLASS_IO_WRITE 0x04
#define FC_CLASS_IO_READ 0x05
#define FC_CLASS_UNSOLICITED 0x06
#define FC_CLASS_OFFLINE 0x08
#define PROTO_OFFLINE 0x02
#define PROTO_REPORT_AL_MAP 0x03
#define PROTO_FORCE_LIP 0x06
struct _fc_channel;
typedef struct fcp_cmnd {
struct fcp_cmnd *next;
struct fcp_cmnd *prev;
void (*done)(struct scsi_cmnd *);
unsigned short proto;
unsigned short token;
unsigned int did;
/* FCP SCSI stuff */
dma_addr_t data;
/* From now on this cannot be touched for proto == TYPE_SCSI_FCP */
fc_hdr fch;
dma_addr_t cmd;
dma_addr_t rsp;
int cmdlen;
int rsplen;
int class;
int datalen;
/* This is just used as a verification during login */
struct _fc_channel *fc;
void *ls;
} fcp_cmnd;
typedef struct {
unsigned int len;
unsigned char list[0];
} fcp_posmap;
typedef struct _fc_channel {
struct _fc_channel *next;
int irq;
int state;
int sid;
int did;
char name[16];
void (*fcp_register)(struct _fc_channel *, u8, int);
void (*reset)(struct _fc_channel *);
int (*hw_enque)(struct _fc_channel *, fcp_cmnd *);
fc_wwn wwn_node;
fc_wwn wwn_nport;
fc_wwn wwn_dest;
common_svc_parm *common_svc;
svc_parm *class_svcs;
#ifdef __sparc__
struct sbus_dev *dev;
#else
struct pci_dev *dev;
#endif
struct module *module;
/* FCP SCSI stuff */
short can_queue;
short abort_count;
int rsp_size;
fcp_cmd *scsi_cmd_pool;
char *scsi_rsp_pool;
dma_addr_t dma_scsi_cmd, dma_scsi_rsp;
unsigned long *scsi_bitmap;
long scsi_bitmap_end;
int scsi_free;
int (*encode_addr)(struct scsi_cmnd *, u16 *, struct _fc_channel *, fcp_cmnd *);
fcp_cmnd *scsi_que;
char scsi_name[4];
fcp_cmnd **cmd_slots;
int channels;
int targets;
long *ages;
struct scsi_cmnd *rst_pkt;
fcp_posmap *posmap;
/* LOGIN stuff */
fcp_cmnd *login;
void *ls;
} fc_channel;
extern fc_channel *fc_channels;
#define FC_STATE_UNINITED 0
#define FC_STATE_ONLINE 1
#define FC_STATE_OFFLINE 2
#define FC_STATE_RESETING 3
#define FC_STATE_FPORT_OK 4
#define FC_STATE_MAYBEOFFLINE 5
#define FC_STATUS_OK 0
#define FC_STATUS_P_RJT 2
#define FC_STATUS_F_RJT 3
#define FC_STATUS_P_BSY 4
#define FC_STATUS_F_BSY 5
#define FC_STATUS_ERR_OFFLINE 0x11
#define FC_STATUS_TIMEOUT 0x12
#define FC_STATUS_ERR_OVERRUN 0x13
#define FC_STATUS_POINTTOPOINT 0x15
#define FC_STATUS_AL 0x16
#define FC_STATUS_UNKNOWN_CQ_TYPE 0x20
#define FC_STATUS_BAD_SEG_CNT 0x21
#define FC_STATUS_MAX_XCHG_EXCEEDED 0x22
#define FC_STATUS_BAD_XID 0x23
#define FC_STATUS_XCHG_BUSY 0x24
#define FC_STATUS_BAD_POOL_ID 0x25
#define FC_STATUS_INSUFFICIENT_CQES 0x26
#define FC_STATUS_ALLOC_FAIL 0x27
#define FC_STATUS_BAD_SID 0x28
#define FC_STATUS_NO_SEQ_INIT 0x29
#define FC_STATUS_TIMED_OUT -1
#define FC_STATUS_BAD_RSP -2
void fcp_queue_empty(fc_channel *);
int fcp_init(fc_channel *);
void fcp_release(fc_channel *fc_chain, int count);
void fcp_receive_solicited(fc_channel *, int, int, int, fc_hdr *);
void fcp_state_change(fc_channel *, int);
int fc_do_plogi(fc_channel *, unsigned char, fc_wwn *, fc_wwn *);
int fc_do_prli(fc_channel *, unsigned char);
#define for_each_fc_channel(fc) \
for (fc = fc_channels; fc; fc = fc->next)
#define for_each_online_fc_channel(fc) \
for_each_fc_channel(fc) \
if (fc->state == FC_STATE_ONLINE)
int fcp_scsi_queuecommand(struct scsi_cmnd *,
void (* done) (struct scsi_cmnd *));
int fcp_scsi_abort(struct scsi_cmnd *);
int fcp_scsi_dev_reset(struct scsi_cmnd *);
int fcp_scsi_host_reset(struct scsi_cmnd *);
#endif /* !(_FCP_SCSI_H) */

764
drivers/fc4/soc.c
View File

@ -1,764 +0,0 @@
/* soc.c: Sparc SUNW,soc (Serial Optical Channel) Fibre Channel Sbus adapter support.
*
* Copyright (C) 1996,1997,1999 Jakub Jelinek (jj@ultra.linux.cz)
* Copyright (C) 1997,1998 Jirka Hanika (geo@ff.cuni.cz)
*
* Sources:
* Fibre Channel Physical & Signaling Interface (FC-PH), dpANS, 1994
* dpANS Fibre Channel Protocol for SCSI (X3.269-199X), Rev. 012, 1995
*
* Supported hardware:
* Tested on SOC sbus card bought with SS1000 in Linux running on SS5 and Ultra1.
* For SOC sbus cards, you have to make sure your FCode is 1.52 or later.
* If you have older FCode, you should try to upgrade or get SOC microcode from Sun
* (the microcode is present in Solaris soc driver as well). In that case you need
* to #define HAVE_SOC_UCODE and format the microcode into soc_asm.c. For the exact
* format mail me and I will tell you. I cannot offer you the actual microcode though,
* unless Sun confirms they don't mind.
*/
static char *version =
"soc.c:v1.3 9/Feb/99 Jakub Jelinek (jj@ultra.linux.cz), Jirka Hanika (geo@ff.cuni.cz)\n";
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/interrupt.h>
#include <linux/ptrace.h>
#include <linux/ioport.h>
#include <linux/in.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/bitops.h>
#include <asm/io.h>
#include <asm/dma.h>
#include <linux/errno.h>
#include <asm/byteorder.h>
#include <asm/openprom.h>
#include <asm/oplib.h>
#include <asm/pgtable.h>
#include <asm/irq.h>
/* #define SOCDEBUG */
/* #define HAVE_SOC_UCODE */
#include "fcp_impl.h"
#include "soc.h"
#ifdef HAVE_SOC_UCODE
#include "soc_asm.h"
#endif
#define soc_printk printk ("soc%d: ", s->soc_no); printk
#ifdef SOCDEBUG
#define SOD(x) soc_printk x;
#else
#define SOD(x)
#endif
#define for_each_soc(s) for (s = socs; s; s = s->next)
struct soc *socs = NULL;
static inline void soc_disable(struct soc *s)
{
sbus_writel(0, s->regs + IMASK);
sbus_writel(SOC_CMD_SOFT_RESET, s->regs + CMD);
}
static inline void soc_enable(struct soc *s)
{
SOD(("enable %08x\n", s->cfg))
sbus_writel(0, s->regs + SAE);
sbus_writel(s->cfg, s->regs + CFG);
sbus_writel(SOC_CMD_RSP_QALL, s->regs + CMD);
SOC_SETIMASK(s, SOC_IMASK_RSP_QALL | SOC_IMASK_SAE);
SOD(("imask %08lx %08lx\n", s->imask, sbus_readl(s->regs + IMAK)));
}
static void soc_reset(fc_channel *fc)
{
soc_port *port = (soc_port *)fc;
struct soc *s = port->s;
/* FIXME */
soc_disable(s);
s->req[0].seqno = 1;
s->req[1].seqno = 1;
s->rsp[0].seqno = 1;
s->rsp[1].seqno = 1;
s->req[0].in = 0;
s->req[1].in = 0;
s->rsp[0].in = 0;
s->rsp[1].in = 0;
s->req[0].out = 0;
s->req[1].out = 0;
s->rsp[0].out = 0;
s->rsp[1].out = 0;
/* FIXME */
soc_enable(s);
}
static inline void soc_solicited (struct soc *s)
{
fc_hdr fchdr;
soc_rsp __iomem *hwrsp;
soc_cq_rsp *sw_cq;
int token;
int status;
fc_channel *fc;
sw_cq = &s->rsp[SOC_SOLICITED_RSP_Q];
if (sw_cq->pool == NULL)
sw_cq->pool = (soc_req __iomem *)
(s->xram + xram_get_32low ((xram_p)&sw_cq->hw_cq->address));
sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
SOD (("soc_solicited, %d pkts arrived\n", (sw_cq->in-sw_cq->out) & sw_cq->last))
for (;;) {
hwrsp = (soc_rsp __iomem *)sw_cq->pool + sw_cq->out;
token = xram_get_32low ((xram_p)&hwrsp->shdr.token);
status = xram_get_32low ((xram_p)&hwrsp->status);
fc = (fc_channel *)(&s->port[(token >> 11) & 1]);
if (status == SOC_OK) {
fcp_receive_solicited(fc, token >> 12,
token & ((1 << 11) - 1),
FC_STATUS_OK, NULL);
} else {
xram_copy_from(&fchdr, (xram_p)&hwrsp->fchdr, sizeof(fchdr));
/* We have intentionally defined FC_STATUS_* constants
* to match SOC_* constants, otherwise we'd have to
* translate status.
*/
fcp_receive_solicited(fc, token >> 12,
token & ((1 << 11) - 1),
status, &fchdr);
}
if (++sw_cq->out > sw_cq->last) {
sw_cq->seqno++;
sw_cq->out = 0;
}
if (sw_cq->out == sw_cq->in) {
sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
if (sw_cq->out == sw_cq->in) {
/* Tell the hardware about it */
sbus_writel((sw_cq->out << 24) |
(SOC_CMD_RSP_QALL &
~(SOC_CMD_RSP_Q0 << SOC_SOLICITED_RSP_Q)),
s->regs + CMD);
/* Read it, so that we're sure it has been updated */
sbus_readl(s->regs + CMD);
sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
if (sw_cq->out == sw_cq->in)
break;
}
}
}
}
static inline void soc_request (struct soc *s, u32 cmd)
{
SOC_SETIMASK(s, s->imask & ~(cmd & SOC_CMD_REQ_QALL));
SOD(("imask %08lx %08lx\n", s->imask, sbus_readl(s->regs + IMASK)));
SOD(("Queues available %08x OUT %X %X\n", cmd,
xram_get_8((xram_p)&s->req[0].hw_cq->out),
xram_get_8((xram_p)&s->req[0].hw_cq->out)))
if (s->port[s->curr_port].fc.state != FC_STATE_OFFLINE) {
fcp_queue_empty ((fc_channel *)&(s->port[s->curr_port]));
if (((s->req[1].in + 1) & s->req[1].last) != (s->req[1].out))
fcp_queue_empty ((fc_channel *)&(s->port[1 - s->curr_port]));
} else {
fcp_queue_empty ((fc_channel *)&(s->port[1 - s->curr_port]));
}
if (s->port[1 - s->curr_port].fc.state != FC_STATE_OFFLINE)
s->curr_port ^= 1;
}
static inline void soc_unsolicited (struct soc *s)
{
soc_rsp __iomem *hwrsp, *hwrspc;
soc_cq_rsp *sw_cq;
int count;
int status;
int flags;
fc_channel *fc;
sw_cq = &s->rsp[SOC_UNSOLICITED_RSP_Q];
if (sw_cq->pool == NULL)
sw_cq->pool = (soc_req __iomem *)
(s->xram + (xram_get_32low ((xram_p)&sw_cq->hw_cq->address)));
sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
SOD (("soc_unsolicited, %d packets arrived\n", (sw_cq->in - sw_cq->out) & sw_cq->last))
while (sw_cq->in != sw_cq->out) {
/* ...real work per entry here... */
hwrsp = (soc_rsp __iomem *)sw_cq->pool + sw_cq->out;
hwrspc = NULL;
flags = xram_get_16 ((xram_p)&hwrsp->shdr.flags);
count = xram_get_8 ((xram_p)&hwrsp->count);
fc = (fc_channel *)&s->port[flags & SOC_PORT_B];
SOD(("FC %08lx fcp_state_change %08lx\n",
(long)fc, (long)fc->fcp_state_change))
if (count != 1) {
/* Ugh, continuation entries */
u8 in;
if (count != 2) {
printk("%s: Too many continuations entries %d\n",
fc->name, count);
goto update_out;
}
in = sw_cq->in;
if (in < sw_cq->out) in += sw_cq->last + 1;
if (in < sw_cq->out + 2) {
/* Ask the hardware if they haven't arrived yet. */
sbus_writel((sw_cq->out << 24) |
(SOC_CMD_RSP_QALL &
~(SOC_CMD_RSP_Q0 << SOC_UNSOLICITED_RSP_Q)),
s->regs + CMD);
/* Read it, so that we're sure it has been updated */
sbus_readl(s->regs + CMD);
sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
in = sw_cq->in;
if (in < sw_cq->out)
in += sw_cq->last + 1;
if (in < sw_cq->out + 2) /* Nothing came, let us wait */
return;
}
if (sw_cq->out == sw_cq->last)
hwrspc = (soc_rsp __iomem *)sw_cq->pool;
else
hwrspc = hwrsp + 1;
}
switch (flags & ~SOC_PORT_B) {
case SOC_STATUS:
status = xram_get_32low ((xram_p)&hwrsp->status);
switch (status) {
case SOC_ONLINE:
SOD(("State change to ONLINE\n"));
fcp_state_change(fc, FC_STATE_ONLINE);
break;
case SOC_OFFLINE:
SOD(("State change to OFFLINE\n"));
fcp_state_change(fc, FC_STATE_OFFLINE);
break;
default:
printk ("%s: Unknown STATUS no %d\n",
fc->name, status);
break;
}
break;
case (SOC_UNSOLICITED|SOC_FC_HDR):
{
int r_ctl = xram_get_8 ((xram_p)&hwrsp->fchdr);
unsigned len;
char buf[64];
if ((r_ctl & 0xf0) == R_CTL_EXTENDED_SVC) {
len = xram_get_32 ((xram_p)&hwrsp->shdr.bytecnt);
if (len < 4 || !hwrspc) {
printk ("%s: Invalid R_CTL %02x "
"continuation entries\n",
fc->name, r_ctl);
} else {
if (len > 60)
len = 60;
xram_copy_from (buf, (xram_p)hwrspc,
(len + 3) & ~3);
if (*(u32 *)buf == LS_DISPLAY) {
int i;
for (i = 4; i < len; i++)
if (buf[i] == '\n')
buf[i] = ' ';
buf[len] = 0;
printk ("%s message: %s\n",
fc->name, buf + 4);
} else {
printk ("%s: Unknown LS_CMD "
"%02x\n", fc->name,
buf[0]);
}
}
} else {
printk ("%s: Unsolicited R_CTL %02x "
"not handled\n", fc->name, r_ctl);
}
}
break;
default:
printk ("%s: Unexpected flags %08x\n", fc->name, flags);
break;
};
update_out:
if (++sw_cq->out > sw_cq->last) {
sw_cq->seqno++;
sw_cq->out = 0;
}
if (hwrspc) {
if (++sw_cq->out > sw_cq->last) {
sw_cq->seqno++;
sw_cq->out = 0;
}
}
if (sw_cq->out == sw_cq->in) {
sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
if (sw_cq->out == sw_cq->in) {
/* Tell the hardware about it */
sbus_writel((sw_cq->out << 24) |
(SOC_CMD_RSP_QALL &
~(SOC_CMD_RSP_Q0 << SOC_UNSOLICITED_RSP_Q)),
s->regs + CMD);
/* Read it, so that we're sure it has been updated */
sbus_readl(s->regs + CMD);
sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
}
}
}
}
static irqreturn_t soc_intr(int irq, void *dev_id)
{
u32 cmd;
unsigned long flags;
register struct soc *s = (struct soc *)dev_id;
spin_lock_irqsave(&s->lock, flags);
cmd = sbus_readl(s->regs + CMD);
for (; (cmd = SOC_INTR (s, cmd)); cmd = sbus_readl(s->regs + CMD)) {
if (cmd & SOC_CMD_RSP_Q1) soc_unsolicited (s);
if (cmd & SOC_CMD_RSP_Q0) soc_solicited (s);
if (cmd & SOC_CMD_REQ_QALL) soc_request (s, cmd);
}
spin_unlock_irqrestore(&s->lock, flags);
return IRQ_HANDLED;
}
#define TOKEN(proto, port, token) (((proto)<<12)|(token)|(port))
static int soc_hw_enque (fc_channel *fc, fcp_cmnd *fcmd)
{
soc_port *port = (soc_port *)fc;
struct soc *s = port->s;
int qno;
soc_cq_req *sw_cq;
int cq_next_in;
soc_req *request;
fc_hdr *fch;
int i;
if (fcmd->proto == TYPE_SCSI_FCP)
qno = 1;
else
qno = 0;
SOD(("Putting a FCP packet type %d into hw queue %d\n", fcmd->proto, qno))
if (s->imask & (SOC_IMASK_REQ_Q0 << qno)) {
SOD(("EIO %08x\n", s->imask))
return -EIO;
}
sw_cq = s->req + qno;
cq_next_in = (sw_cq->in + 1) & sw_cq->last;
if (cq_next_in == sw_cq->out &&
cq_next_in == (sw_cq->out = xram_get_8((xram_p)&sw_cq->hw_cq->out))) {
SOD(("%d IN %d OUT %d LAST %d\n", qno, sw_cq->in, sw_cq->out, sw_cq->last))
SOC_SETIMASK(s, s->imask | (SOC_IMASK_REQ_Q0 << qno));
SOD(("imask %08lx %08lx\n", s->imask, sbus_readl(s->regs + IMASK)));
/* If queue is full, just say NO */
return -EBUSY;
}
request = sw_cq->pool + sw_cq->in;
fch = &request->fchdr;
switch (fcmd->proto) {
case TYPE_SCSI_FCP:
request->shdr.token = TOKEN(TYPE_SCSI_FCP, port->mask, fcmd->token);
request->data[0].base = fc->dma_scsi_cmd + fcmd->token * sizeof(fcp_cmd);
request->data[0].count = sizeof(fcp_cmd);
request->data[1].base = fc->dma_scsi_rsp + fcmd->token * fc->rsp_size;
request->data[1].count = fc->rsp_size;
if (fcmd->data) {
request->shdr.segcnt = 3;
i = fc->scsi_cmd_pool[fcmd->token].fcp_data_len;
request->shdr.bytecnt = i;
request->data[2].base = fcmd->data;
request->data[2].count = i;
request->type =
(fc->scsi_cmd_pool[fcmd->token].fcp_cntl & FCP_CNTL_WRITE) ?
SOC_CQTYPE_IO_WRITE : SOC_CQTYPE_IO_READ;
} else {
request->shdr.segcnt = 2;
request->shdr.bytecnt = 0;
request->data[2].base = 0;
request->data[2].count = 0;
request->type = SOC_CQTYPE_SIMPLE;
}
FILL_FCHDR_RCTL_DID(fch, R_CTL_COMMAND, fc->did);
FILL_FCHDR_SID(fch, fc->sid);
FILL_FCHDR_TYPE_FCTL(fch, TYPE_SCSI_FCP,
F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE);
FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0);
FILL_FCHDR_OXRX(fch, 0xffff, 0xffff);
fch->param = 0;
request->shdr.flags = port->flags;
request->shdr.class = 2;
break;
case PROTO_OFFLINE:
memset (request, 0, sizeof(*request));
request->shdr.token = TOKEN(PROTO_OFFLINE, port->mask, fcmd->token);
request->type = SOC_CQTYPE_OFFLINE;
FILL_FCHDR_RCTL_DID(fch, R_CTL_COMMAND, fc->did);
FILL_FCHDR_SID(fch, fc->sid);
FILL_FCHDR_TYPE_FCTL(fch, TYPE_SCSI_FCP,
F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE);
FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0);
FILL_FCHDR_OXRX(fch, 0xffff, 0xffff);
request->shdr.flags = port->flags;
break;
case PROTO_REPORT_AL_MAP:
/* SOC only supports Point-to-Point topology, no FC-AL, sorry... */
return -ENOSYS;
default:
request->shdr.token = TOKEN(fcmd->proto, port->mask, fcmd->token);
request->shdr.class = 2;
request->shdr.flags = port->flags;
memcpy (fch, &fcmd->fch, sizeof(fc_hdr));
request->data[0].count = fcmd->cmdlen;
request->data[1].count = fcmd->rsplen;
request->type = fcmd->class;
switch (fcmd->class) {
case FC_CLASS_OUTBOUND:
request->data[0].base = fcmd->cmd;
request->data[0].count = fcmd->cmdlen;
request->type = SOC_CQTYPE_OUTBOUND;
request->shdr.bytecnt = fcmd->cmdlen;
request->shdr.segcnt = 1;
break;
case FC_CLASS_INBOUND:
request->data[0].base = fcmd->rsp;
request->data[0].count = fcmd->rsplen;
request->type = SOC_CQTYPE_INBOUND;
request->shdr.bytecnt = 0;
request->shdr.segcnt = 1;
break;
case FC_CLASS_SIMPLE:
request->data[0].base = fcmd->cmd;
request->data[1].base = fcmd->rsp;
request->data[0].count = fcmd->cmdlen;
request->data[1].count = fcmd->rsplen;
request->type = SOC_CQTYPE_SIMPLE;
request->shdr.bytecnt = fcmd->cmdlen;
request->shdr.segcnt = 2;
break;
case FC_CLASS_IO_READ:
case FC_CLASS_IO_WRITE:
request->data[0].base = fcmd->cmd;
request->data[1].base = fcmd->rsp;
request->data[0].count = fcmd->cmdlen;
request->data[1].count = fcmd->rsplen;
request->type =
(fcmd->class == FC_CLASS_IO_READ) ?
SOC_CQTYPE_IO_READ : SOC_CQTYPE_IO_WRITE;
if (fcmd->data) {
request->data[2].base = fcmd->data;
request->data[2].count = fcmd->datalen;
request->shdr.bytecnt = fcmd->datalen;
request->shdr.segcnt = 3;
} else {
request->shdr.bytecnt = 0;
request->shdr.segcnt = 2;
}
break;
};
break;
};
request->count = 1;
request->flags = 0;
request->seqno = sw_cq->seqno;
/* And now tell the SOC about it */
if (++sw_cq->in > sw_cq->last) {
sw_cq->in = 0;
sw_cq->seqno++;
}
SOD(("Putting %08x into cmd\n",
SOC_CMD_RSP_QALL | (sw_cq->in << 24) | (SOC_CMD_REQ_Q0 << qno)))
sbus_writel(SOC_CMD_RSP_QALL | (sw_cq->in << 24) | (SOC_CMD_REQ_Q0 << qno),
s->regs + CMD);
/* Read so that command is completed. */
sbus_readl(s->regs + CMD);
return 0;
}
static inline void soc_download_fw(struct soc *s)
{
#ifdef HAVE_SOC_UCODE
xram_copy_to (s->xram, soc_ucode, sizeof(soc_ucode));
xram_bzero (s->xram + sizeof(soc_ucode), 32768 - sizeof(soc_ucode));
#endif
}
/* Check for what the best SBUS burst we can use happens
* to be on this machine.
*/
static inline void soc_init_bursts(struct soc *s, struct sbus_dev *sdev)
{
int bsizes, bsizes_more;
bsizes = (prom_getintdefault(sdev->prom_node,"burst-sizes",0xff) & 0xff);
bsizes_more = (prom_getintdefault(sdev->bus->prom_node, "burst-sizes", 0xff) & 0xff);
bsizes &= bsizes_more;
if ((bsizes & 0x7f) == 0x7f)
s->cfg = SOC_CFG_BURST_64;
else if ((bsizes & 0x3f) == 0x3f)
s->cfg = SOC_CFG_BURST_32;
else if ((bsizes & 0x1f) == 0x1f)
s->cfg = SOC_CFG_BURST_16;
else
s->cfg = SOC_CFG_BURST_4;
}
static inline void soc_init(struct sbus_dev *sdev, int no)
{
unsigned char tmp[60];
int propl;
struct soc *s;
static int version_printed = 0;
soc_hw_cq cq[8];
int size, i;
int irq;
s = kzalloc (sizeof (struct soc), GFP_KERNEL);
if (s == NULL)
return;
spin_lock_init(&s->lock);
s->soc_no = no;
SOD(("socs %08lx soc_intr %08lx soc_hw_enque %08x\n",
(long)socs, (long)soc_intr, (long)soc_hw_enque))
if (version_printed++ == 0)
printk (version);
s->port[0].fc.module = THIS_MODULE;
s->port[1].fc.module = THIS_MODULE;
s->next = socs;
socs = s;
s->port[0].fc.dev = sdev;
s->port[1].fc.dev = sdev;
s->port[0].s = s;
s->port[1].s = s;
s->port[0].fc.next = &s->port[1].fc;
/* World Wide Name of SOC */
propl = prom_getproperty (sdev->prom_node, "soc-wwn", tmp, sizeof(tmp));
if (propl != sizeof (fc_wwn)) {
s->wwn.naaid = NAAID_IEEE;
s->wwn.lo = 0x12345678;
} else
memcpy (&s->wwn, tmp, sizeof (fc_wwn));
propl = prom_getproperty (sdev->prom_node, "port-wwns", tmp, sizeof(tmp));
if (propl != 2 * sizeof (fc_wwn)) {
s->port[0].fc.wwn_nport.naaid = NAAID_IEEE_EXT;
s->port[0].fc.wwn_nport.hi = s->wwn.hi;
s->port[0].fc.wwn_nport.lo = s->wwn.lo;
s->port[1].fc.wwn_nport.naaid = NAAID_IEEE_EXT;
s->port[1].fc.wwn_nport.nportid = 1;
s->port[1].fc.wwn_nport.hi = s->wwn.hi;
s->port[1].fc.wwn_nport.lo = s->wwn.lo;
} else {
memcpy (&s->port[0].fc.wwn_nport, tmp, sizeof (fc_wwn));
memcpy (&s->port[1].fc.wwn_nport, tmp + sizeof (fc_wwn), sizeof (fc_wwn));
}
memcpy (&s->port[0].fc.wwn_node, &s->wwn, sizeof (fc_wwn));
memcpy (&s->port[1].fc.wwn_node, &s->wwn, sizeof (fc_wwn));
SOD(("Got wwns %08x%08x ports %08x%08x and %08x%08x\n",
*(u32 *)&s->port[0].fc.wwn_nport, s->port[0].fc.wwn_nport.lo,
*(u32 *)&s->port[0].fc.wwn_nport, s->port[0].fc.wwn_nport.lo,
*(u32 *)&s->port[1].fc.wwn_nport, s->port[1].fc.wwn_nport.lo))
s->port[0].fc.sid = 1;
s->port[1].fc.sid = 17;
s->port[0].fc.did = 2;
s->port[1].fc.did = 18;
s->port[0].fc.reset = soc_reset;
s->port[1].fc.reset = soc_reset;
if (sdev->num_registers == 1) {
/* Probably SunFire onboard SOC */
s->xram = sbus_ioremap(&sdev->resource[0], 0,
0x10000UL, "soc xram");
s->regs = sbus_ioremap(&sdev->resource[0], 0x10000UL,
0x10UL, "soc regs");
} else {
/* Probably SOC sbus card */
s->xram = sbus_ioremap(&sdev->resource[1], 0,
sdev->reg_addrs[1].reg_size, "soc xram");
s->regs = sbus_ioremap(&sdev->resource[2], 0,
sdev->reg_addrs[2].reg_size, "soc regs");
}
soc_init_bursts(s, sdev);
SOD(("Disabling SOC\n"))
soc_disable (s);
irq = sdev->irqs[0];
if (request_irq (irq, soc_intr, IRQF_SHARED, "SOC", (void *)s)) {
soc_printk ("Cannot order irq %d to go\n", irq);
socs = s->next;
return;
}
SOD(("SOC uses IRQ %d\n", irq))
s->port[0].fc.irq = irq;
s->port[1].fc.irq = irq;
sprintf (s->port[0].fc.name, "soc%d port A", no);
sprintf (s->port[1].fc.name, "soc%d port B", no);
s->port[0].flags = SOC_FC_HDR | SOC_PORT_A;
s->port[1].flags = SOC_FC_HDR | SOC_PORT_B;
s->port[1].mask = (1 << 11);
s->port[0].fc.hw_enque = soc_hw_enque;
s->port[1].fc.hw_enque = soc_hw_enque;
soc_download_fw (s);
SOD(("Downloaded firmware\n"))
/* Now setup xram circular queues */
memset (cq, 0, sizeof(cq));
size = (SOC_CQ_REQ0_SIZE + SOC_CQ_REQ1_SIZE) * sizeof(soc_req);
s->req_cpu = sbus_alloc_consistent(sdev, size, &s->req_dvma);
s->req[0].pool = s->req_cpu;
cq[0].address = s->req_dvma;
s->req[1].pool = s->req[0].pool + SOC_CQ_REQ0_SIZE;
s->req[0].hw_cq = (soc_hw_cq __iomem *)(s->xram + SOC_CQ_REQ_OFFSET);
s->req[1].hw_cq = (soc_hw_cq __iomem *)(s->xram + SOC_CQ_REQ_OFFSET + sizeof(soc_hw_cq));
s->rsp[0].hw_cq = (soc_hw_cq __iomem *)(s->xram + SOC_CQ_RSP_OFFSET);
s->rsp[1].hw_cq = (soc_hw_cq __iomem *)(s->xram + SOC_CQ_RSP_OFFSET + sizeof(soc_hw_cq));
cq[1].address = cq[0].address + (SOC_CQ_REQ0_SIZE * sizeof(soc_req));
cq[4].address = 1;
cq[5].address = 1;
cq[0].last = SOC_CQ_REQ0_SIZE - 1;
cq[1].last = SOC_CQ_REQ1_SIZE - 1;
cq[4].last = SOC_CQ_RSP0_SIZE - 1;
cq[5].last = SOC_CQ_RSP1_SIZE - 1;
for (i = 0; i < 8; i++)
cq[i].seqno = 1;
s->req[0].last = SOC_CQ_REQ0_SIZE - 1;
s->req[1].last = SOC_CQ_REQ1_SIZE - 1;
s->rsp[0].last = SOC_CQ_RSP0_SIZE - 1;
s->rsp[1].last = SOC_CQ_RSP1_SIZE - 1;
s->req[0].seqno = 1;
s->req[1].seqno = 1;
s->rsp[0].seqno = 1;
s->rsp[1].seqno = 1;
xram_copy_to (s->xram + SOC_CQ_REQ_OFFSET, cq, sizeof(cq));
/* Make our sw copy of SOC service parameters */
xram_copy_from (s->serv_params, s->xram + 0x140, sizeof (s->serv_params));
s->port[0].fc.common_svc = (common_svc_parm *)s->serv_params;
s->port[0].fc.class_svcs = (svc_parm *)(s->serv_params + 0x20);
s->port[1].fc.common_svc = (common_svc_parm *)&s->serv_params;
s->port[1].fc.class_svcs = (svc_parm *)(s->serv_params + 0x20);
soc_enable (s);
SOD(("Enabled SOC\n"))
}
static int __init soc_probe(void)
{
struct sbus_bus *sbus;
struct sbus_dev *sdev = NULL;
struct soc *s;
int cards = 0;
for_each_sbus(sbus) {
for_each_sbusdev(sdev, sbus) {
if(!strcmp(sdev->prom_name, "SUNW,soc")) {
soc_init(sdev, cards);
cards++;
}
}
}
if (!cards) return -EIO;
for_each_soc(s)
if (s->next)
s->port[1].fc.next = &s->next->port[0].fc;
fcp_init (&socs->port[0].fc);
return 0;
}
static void __exit soc_cleanup(void)
{
struct soc *s;
int irq;
struct sbus_dev *sdev;
for_each_soc(s) {
irq = s->port[0].fc.irq;
free_irq (irq, s);
fcp_release(&(s->port[0].fc), 2);
sdev = s->port[0].fc.dev;
if (sdev->num_registers == 1) {
sbus_iounmap(s->xram, 0x10000UL);
sbus_iounmap(s->regs, 0x10UL);
} else {
sbus_iounmap(s->xram, sdev->reg_addrs[1].reg_size);
sbus_iounmap(s->regs, sdev->reg_addrs[2].reg_size);
}
sbus_free_consistent(sdev,
(SOC_CQ_REQ0_SIZE+SOC_CQ_REQ1_SIZE)*sizeof(soc_req),
s->req_cpu, s->req_dvma);
}
}
module_init(soc_probe);
module_exit(soc_cleanup);
MODULE_LICENSE("GPL");

301
drivers/fc4/soc.h
View File

@ -1,301 +0,0 @@
/* soc.h: Definitions for Sparc SUNW,soc Fibre Channel Sbus driver.
*
* Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
*/
#ifndef __SOC_H
#define __SOC_H
#include "fc.h"
#include "fcp.h"
#include "fcp_impl.h"
/* Hardware register offsets and constants first {{{ */
#define CFG 0x00UL /* Config Register */
#define SAE 0x04UL /* Slave Access Error Register */
#define CMD 0x08UL /* Command and Status Register */
#define IMASK 0x0cUL /* Interrupt Mask Register */
/* Config Register */
#define SOC_CFG_EXT_RAM_BANK_MASK 0x07000000
#define SOC_CFG_EEPROM_BANK_MASK 0x00030000
#define SOC_CFG_BURST64_MASK 0x00000700
#define SOC_CFG_SBUS_PARITY_TEST 0x00000020
#define SOC_CFG_SBUS_PARITY_CHECK 0x00000010
#define SOC_CFG_SBUS_ENHANCED 0x00000008
#define SOC_CFG_BURST_MASK 0x00000007
/* Bursts */
#define SOC_CFG_BURST_4 0x00000000
#define SOC_CFG_BURST_16 0x00000004
#define SOC_CFG_BURST_32 0x00000005
#define SOC_CFG_BURST_64 0x00000006
/* Slave Access Error Register */
#define SOC_SAE_ALIGNMENT 0x00000004
#define SOC_SAE_UNSUPPORTED 0x00000002
#define SOC_SAE_PARITY 0x00000001
/* Command & Status Register */
#define SOC_CMD_RSP_QALL 0x000f0000
#define SOC_CMD_RSP_Q0 0x00010000
#define SOC_CMD_RSP_Q1 0x00020000
#define SOC_CMD_RSP_Q2 0x00040000
#define SOC_CMD_RSP_Q3 0x00080000
#define SOC_CMD_REQ_QALL 0x00000f00
#define SOC_CMD_REQ_Q0 0x00000100
#define SOC_CMD_REQ_Q1 0x00000200
#define SOC_CMD_REQ_Q2 0x00000400
#define SOC_CMD_REQ_Q3 0x00000800
#define SOC_CMD_SAE 0x00000080
#define SOC_CMD_INTR_PENDING 0x00000008
#define SOC_CMD_NON_QUEUED 0x00000004
#define SOC_CMD_IDLE 0x00000002
#define SOC_CMD_SOFT_RESET 0x00000001
/* Interrupt Mask Register */
#define SOC_IMASK_RSP_QALL 0x000f0000
#define SOC_IMASK_RSP_Q0 0x00010000
#define SOC_IMASK_RSP_Q1 0x00020000
#define SOC_IMASK_RSP_Q2 0x00040000
#define SOC_IMASK_RSP_Q3 0x00080000
#define SOC_IMASK_REQ_QALL 0x00000f00
#define SOC_IMASK_REQ_Q0 0x00000100
#define SOC_IMASK_REQ_Q1 0x00000200
#define SOC_IMASK_REQ_Q2 0x00000400
#define SOC_IMASK_REQ_Q3 0x00000800
#define SOC_IMASK_SAE 0x00000080
#define SOC_IMASK_NON_QUEUED 0x00000004
#define SOC_INTR(s, cmd) \
(((cmd & SOC_CMD_RSP_QALL) | ((~cmd) & SOC_CMD_REQ_QALL)) \
& s->imask)
#define SOC_SETIMASK(s, i) \
do { (s)->imask = (i); \
sbus_writel((i), (s)->regs + IMASK); \
} while(0)
/* XRAM
*
* This is a 64KB register area. It accepts only halfword access.
* That's why here are the following inline functions...
*/
typedef void __iomem *xram_p;
/* Get 32bit number from XRAM */
static inline u32 xram_get_32(xram_p x)
{
return ((sbus_readw(x + 0x00UL) << 16) |
(sbus_readw(x + 0x02UL)));
}
/* Like the above, but when we don't care about the high 16 bits */
static inline u32 xram_get_32low(xram_p x)
{
return (u32) sbus_readw(x + 0x02UL);
}
static inline u16 xram_get_16(xram_p x)
{
return sbus_readw(x);
}
static inline u8 xram_get_8(xram_p x)
{
if ((unsigned long)x & 0x1UL) {
x = x - 1;
return (u8) sbus_readw(x);
} else {
return (u8) (sbus_readw(x) >> 8);
}
}
static inline void xram_copy_from(void *p, xram_p x, int len)
{
for (len >>= 2; len > 0; len--, x += sizeof(u32)) {
u32 val, *p32 = p;
val = ((sbus_readw(x + 0x00UL) << 16) |
(sbus_readw(x + 0x02UL)));
*p32++ = val;
p = p32;
}
}
static inline void xram_copy_to(xram_p x, void *p, int len)
{
for (len >>= 2; len > 0; len--, x += sizeof(u32)) {
u32 tmp, *p32 = p;
tmp = *p32++;
p = p32;
sbus_writew(tmp >> 16, x + 0x00UL);
sbus_writew(tmp, x + 0x02UL);
}
}
static inline void xram_bzero(xram_p x, int len)
{
for (len >>= 1; len > 0; len--, x += sizeof(u16))
sbus_writew(0, x);
}
/* Circular Queue */
#define SOC_CQ_REQ_OFFSET (0x100 * sizeof(u16))
#define SOC_CQ_RSP_OFFSET (0x110 * sizeof(u16))
typedef struct {
u32 address;
u8 in;
u8 out;
u8 last;
u8 seqno;
} soc_hw_cq;
#define SOC_PORT_A 0x0000 /* From/To Port A */
#define SOC_PORT_B 0x0001 /* From/To Port A */
#define SOC_FC_HDR 0x0002 /* Contains FC Header */
#define SOC_NORSP 0x0004 /* Don't generate response nor interrupt */
#define SOC_NOINT 0x0008 /* Generate response but not interrupt */
#define SOC_XFERRDY 0x0010 /* Generate XFERRDY */
#define SOC_IGNOREPARAM 0x0020 /* Ignore PARAM field in the FC header */
#define SOC_COMPLETE 0x0040 /* Command completed */
#define SOC_UNSOLICITED 0x0080 /* For request this is the packet to establish unsolicited pools, */
/* for rsp this is unsolicited packet */
#define SOC_STATUS 0x0100 /* State change (on/off line) */
typedef struct {
u32 token;
u16 flags;
u8 class;
u8 segcnt;
u32 bytecnt;
} soc_hdr;
typedef struct {
u32 base;
u32 count;
} soc_data;
#define SOC_CQTYPE_OUTBOUND 0x01
#define SOC_CQTYPE_INBOUND 0x02
#define SOC_CQTYPE_SIMPLE 0x03
#define SOC_CQTYPE_IO_WRITE 0x04
#define SOC_CQTYPE_IO_READ 0x05
#define SOC_CQTYPE_UNSOLICITED 0x06
#define SOC_CQTYPE_DIAG 0x07
#define SOC_CQTYPE_OFFLINE 0x08
#define SOC_CQTYPE_RESPONSE 0x10
#define SOC_CQTYPE_INLINE 0x20
#define SOC_CQFLAGS_CONT 0x01
#define SOC_CQFLAGS_FULL 0x02
#define SOC_CQFLAGS_BADHDR 0x04
#define SOC_CQFLAGS_BADPKT 0x08
typedef struct {
soc_hdr shdr;
soc_data data[3];
fc_hdr fchdr;
u8 count;
u8 type;
u8 flags;
u8 seqno;
} soc_req;
#define SOC_OK 0
#define SOC_P_RJT 2
#define SOC_F_RJT 3
#define SOC_P_BSY 4
#define SOC_F_BSY 5
#define SOC_ONLINE 0x10
#define SOC_OFFLINE 0x11
#define SOC_TIMEOUT 0x12
#define SOC_OVERRUN 0x13
#define SOC_UNKOWN_CQ_TYPE 0x20
#define SOC_BAD_SEG_CNT 0x21
#define SOC_MAX_XCHG_EXCEEDED 0x22
#define SOC_BAD_XID 0x23
#define SOC_XCHG_BUSY 0x24
#define SOC_BAD_POOL_ID 0x25
#define SOC_INSUFFICIENT_CQES 0x26
#define SOC_ALLOC_FAIL 0x27
#define SOC_BAD_SID 0x28
#define SOC_NO_SEG_INIT 0x29
typedef struct {
soc_hdr shdr;
u32 status;
soc_data data;
u8 xxx1[12];
fc_hdr fchdr;
u8 count;
u8 type;
u8 flags;
u8 seqno;
} soc_rsp;
/* }}} */
/* Now our software structures and constants we use to drive the beast {{{ */
#define SOC_CQ_REQ0_SIZE 4
#define SOC_CQ_REQ1_SIZE 64
#define SOC_CQ_RSP0_SIZE 8
#define SOC_CQ_RSP1_SIZE 4
#define SOC_SOLICITED_RSP_Q 0
#define SOC_UNSOLICITED_RSP_Q 1
struct soc;
typedef struct {
/* This must come first */
fc_channel fc;
struct soc *s;
u16 flags;
u16 mask;
} soc_port;
typedef struct {
soc_hw_cq __iomem *hw_cq; /* Related XRAM cq */
soc_req __iomem *pool;
u8 in;
u8 out;
u8 last;
u8 seqno;
} soc_cq_rsp;
typedef struct {
soc_hw_cq __iomem *hw_cq; /* Related XRAM cq */
soc_req *pool;
u8 in;
u8 out;
u8 last;
u8 seqno;
} soc_cq_req;
struct soc {
spinlock_t lock;
soc_port port[2]; /* Every SOC has one or two FC ports */
soc_cq_req req[2]; /* Request CQs */
soc_cq_rsp rsp[2]; /* Response CQs */
int soc_no;
void __iomem *regs;
xram_p xram;
fc_wwn wwn;
u32 imask; /* Our copy of regs->imask */
u32 cfg; /* Our copy of regs->cfg */
char serv_params[80];
struct soc *next;
int curr_port; /* Which port will have priority to fcp_queue_empty */
soc_req *req_cpu;
u32 req_dvma;
};
/* }}} */
#endif /* !(__SOC_H) */

904
drivers/fc4/socal.c
View File

@ -1,904 +0,0 @@
/* socal.c: Sparc SUNW,socal (SOC+) Fibre Channel Sbus adapter support.
*
* Copyright (C) 1998,1999 Jakub Jelinek (jj@ultra.linux.cz)
*
* Sources:
* Fibre Channel Physical & Signaling Interface (FC-PH), dpANS, 1994
* dpANS Fibre Channel Protocol for SCSI (X3.269-199X), Rev. 012, 1995
* SOC+ Programming Guide 0.1
* Fibre Channel Arbitrated Loop (FC-AL), dpANS rev. 4.5, 1995
*
* Supported hardware:
* On-board SOC+ adapters of Ultra Enterprise servers and sun4d.
*/
static char *version =
"socal.c: SOC+ driver v1.1 9/Feb/99 Jakub Jelinek (jj@ultra.linux.cz)\n";
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/interrupt.h>
#include <linux/ptrace.h>
#include <linux/ioport.h>
#include <linux/in.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/bitops.h>
#include <asm/system.h>
#include <asm/io.h>
#include <asm/dma.h>
#include <linux/errno.h>
#include <asm/byteorder.h>
#include <asm/openprom.h>
#include <asm/oplib.h>
#include <asm/pgtable.h>
#include <asm/irq.h>
/* #define SOCALDEBUG */
/* #define HAVE_SOCAL_UCODE */
/* #define USE_64BIT_MODE */
#include "fcp_impl.h"
#include "socal.h"
#ifdef HAVE_SOCAL_UCODE
#include "socal_asm.h"
#endif
#define socal_printk printk ("socal%d: ", s->socal_no); printk
#ifdef SOCALDEBUG
#define SOD(x) socal_printk x;
#else
#define SOD(x)
#endif
#define for_each_socal(s) for (s = socals; s; s = s->next)
struct socal *socals = NULL;
static void socal_copy_from_xram(void *d, void __iomem *xram, long size)
{
u32 *dp = (u32 *) d;
while (size) {
*dp++ = sbus_readl(xram);
xram += sizeof(u32);
size -= sizeof(u32);
}
}
static void socal_copy_to_xram(void __iomem *xram, void *s, long size)
{
u32 *sp = (u32 *) s;
while (size) {
u32 val = *sp++;
sbus_writel(val, xram);
xram += sizeof(u32);
size -= sizeof(u32);
}
}
#ifdef HAVE_SOCAL_UCODE
static void socal_bzero(unsigned long xram, int size)
{
while (size) {
sbus_writel(0, xram);
xram += sizeof(u32);
size -= sizeof(u32);
}
}
#endif
static inline void socal_disable(struct socal *s)
{
sbus_writel(0, s->regs + IMASK);
sbus_writel(SOCAL_CMD_SOFT_RESET, s->regs + CMD);
}
static inline void socal_enable(struct socal *s)
{
SOD(("enable %08x\n", s->cfg))
sbus_writel(0, s->regs + SAE);
sbus_writel(s->cfg, s->regs + CFG);
sbus_writel(SOCAL_CMD_RSP_QALL, s->regs + CMD);
SOCAL_SETIMASK(s, SOCAL_IMASK_RSP_QALL | SOCAL_IMASK_SAE);
SOD(("imask %08x %08x\n", s->imask, sbus_readl(s->regs + IMASK)));
}
static void socal_reset(fc_channel *fc)
{
socal_port *port = (socal_port *)fc;
struct socal *s = port->s;
/* FIXME */
socal_disable(s);
s->req[0].seqno = 1;
s->req[1].seqno = 1;
s->rsp[0].seqno = 1;
s->rsp[1].seqno = 1;
s->req[0].in = 0;
s->req[1].in = 0;
s->rsp[0].in = 0;
s->rsp[1].in = 0;
s->req[0].out = 0;
s->req[1].out = 0;
s->rsp[0].out = 0;
s->rsp[1].out = 0;
/* FIXME */
socal_enable(s);
}
static inline void socal_solicited(struct socal *s, unsigned long qno)
{
socal_rsp *hwrsp;
socal_cq *sw_cq;
int token;
int status;
fc_channel *fc;
sw_cq = &s->rsp[qno];
/* Finally an improvement against old SOC :) */
sw_cq->in = sbus_readb(s->regs + RESP + qno);
SOD (("socal_solicited, %d packets arrived\n",
(sw_cq->in - sw_cq->out) & sw_cq->last))
for (;;) {
hwrsp = (socal_rsp *)sw_cq->pool + sw_cq->out;
SOD(("hwrsp %p out %d\n", hwrsp, sw_cq->out))
#if defined(SOCALDEBUG) && 0
{
u32 *u = (u32 *)hwrsp;
SOD(("%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n",
u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7]))
u += 8;
SOD(("%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n",
u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7]))
u = (u32 *)s->xram;
while (u < ((u32 *)s->regs)) {
if (sbus_readl(&u[0]) == 0x00003000 ||
sbus_readl(&u[0]) == 0x00003801) {
SOD(("Found at %04lx\n",
(unsigned long)u - (unsigned long)s->xram))
SOD((" %08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n",
sbus_readl(&u[0]), sbus_readl(&u[1]),
sbus_readl(&u[2]), sbus_readl(&u[3]),
sbus_readl(&u[4]), sbus_readl(&u[5]),
sbus_readl(&u[6]), sbus_readl(&u[7])))
u += 8;
SOD((" %08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n",
sbus_readl(&u[0]), sbus_readl(&u[1]),
sbus_readl(&u[2]), sbus_readl(&u[3]),
sbus_readl(&u[4]), sbus_readl(&u[5]),
sbus_readl(&u[6]), sbus_readl(&u[7])))
u -= 8;
}
u++;
}
}
#endif
token = hwrsp->shdr.token;
status = hwrsp->status;
fc = (fc_channel *)(&s->port[(token >> 11) & 1]);
SOD(("Solicited token %08x status %08x\n", token, status))
if (status == SOCAL_OK) {
fcp_receive_solicited(fc, token >> 12,
token & ((1 << 11) - 1),
FC_STATUS_OK, NULL);
} else {
/* We have intentionally defined FC_STATUS_* constants
* to match SOCAL_* constants, otherwise we'd have to
* translate status.
*/
fcp_receive_solicited(fc, token >> 12,
token & ((1 << 11) - 1), status, &hwrsp->fchdr);
}
if (++sw_cq->out > sw_cq->last) {
sw_cq->seqno++;
sw_cq->out = 0;
}
if (sw_cq->out == sw_cq->in) {
sw_cq->in = sbus_readb(s->regs + RESP + qno);
if (sw_cq->out == sw_cq->in) {
/* Tell the hardware about it */
sbus_writel((sw_cq->out << 24) |
(SOCAL_CMD_RSP_QALL &
~(SOCAL_CMD_RSP_Q0 << qno)),
s->regs + CMD);
/* Read it, so that we're sure it has been updated */
sbus_readl(s->regs + CMD);
sw_cq->in = sbus_readb(s->regs + RESP + qno);
if (sw_cq->out == sw_cq->in)
break;
}
}
}
}
static inline void socal_request (struct socal *s, u32 cmd)
{
SOCAL_SETIMASK(s, s->imask & ~(cmd & SOCAL_CMD_REQ_QALL));
SOD(("imask %08x %08x\n", s->imask, sbus_readl(s->regs + IMASK)));
SOD(("Queues available %08x OUT %X\n", cmd, s->regs->reqpr[0]))
if (s->port[s->curr_port].fc.state != FC_STATE_OFFLINE) {
fcp_queue_empty ((fc_channel *)&(s->port[s->curr_port]));
if (((s->req[1].in + 1) & s->req[1].last) != (s->req[1].out))
fcp_queue_empty ((fc_channel *)&(s->port[1 - s->curr_port]));
} else {
fcp_queue_empty ((fc_channel *)&(s->port[1 - s->curr_port]));
}
if (s->port[1 - s->curr_port].fc.state != FC_STATE_OFFLINE)
s->curr_port ^= 1;
}
static inline void socal_unsolicited (struct socal *s, unsigned long qno)
{
socal_rsp *hwrsp, *hwrspc;
socal_cq *sw_cq;
int count;
int status;
int flags;
fc_channel *fc;
sw_cq = &s->rsp[qno];
sw_cq->in = sbus_readb(s->regs + RESP + qno);
SOD (("socal_unsolicited, %d packets arrived, in %d\n",
(sw_cq->in - sw_cq->out) & sw_cq->last, sw_cq->in))
while (sw_cq->in != sw_cq->out) {
/* ...real work per entry here... */
hwrsp = (socal_rsp *)sw_cq->pool + sw_cq->out;
SOD(("hwrsp %p out %d\n", hwrsp, sw_cq->out))
#if defined(SOCALDEBUG) && 0
{
u32 *u = (u32 *)hwrsp;
SOD(("%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n",
u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7]))
u += 8;
SOD(("%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n",
u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7]))
}
#endif
hwrspc = NULL;
flags = hwrsp->shdr.flags;
count = hwrsp->count;
fc = (fc_channel *)&s->port[flags & SOCAL_PORT_B];
SOD(("FC %08lx\n", (long)fc))
if (count != 1) {
/* Ugh, continuation entries */
u8 in;
if (count != 2) {
printk("%s: Too many continuations entries %d\n",
fc->name, count);
goto update_out;
}
in = sw_cq->in;
if (in < sw_cq->out)
in += sw_cq->last + 1;
if (in < sw_cq->out + 2) {
/* Ask the hardware if they haven't arrived yet. */
sbus_writel((sw_cq->out << 24) |
(SOCAL_CMD_RSP_QALL &
~(SOCAL_CMD_RSP_Q0 << qno)),
s->regs + CMD);
/* Read it, so that we're sure it has been updated */
sbus_readl(s->regs + CMD);
sw_cq->in = sbus_readb(s->regs + RESP + qno);
in = sw_cq->in;
if (in < sw_cq->out)
in += sw_cq->last + 1;
if (in < sw_cq->out + 2) /* Nothing came, let us wait */
return;
}
if (sw_cq->out == sw_cq->last)
hwrspc = (socal_rsp *)sw_cq->pool;
else
hwrspc = hwrsp + 1;
}
switch (flags & ~SOCAL_PORT_B) {
case SOCAL_STATUS:
status = hwrsp->status;
switch (status) {
case SOCAL_ONLINE:
SOD(("State change to ONLINE\n"));
fcp_state_change(fc, FC_STATE_ONLINE);
break;
case SOCAL_ONLINE_LOOP:
SOD(("State change to ONLINE_LOOP\n"));
fcp_state_change(fc, FC_STATE_ONLINE);
break;
case SOCAL_OFFLINE:
SOD(("State change to OFFLINE\n"));
fcp_state_change(fc, FC_STATE_OFFLINE);
break;
default:
printk ("%s: Unknown STATUS no %d\n",
fc->name, status);
break;
};
break;
case (SOCAL_UNSOLICITED|SOCAL_FC_HDR):
{
int r_ctl = *((u8 *)&hwrsp->fchdr);
unsigned len;
if ((r_ctl & 0xf0) == R_CTL_EXTENDED_SVC) {
len = hwrsp->shdr.bytecnt;
if (len < 4 || !hwrspc) {
printk ("%s: Invalid R_CTL %02x "
"continuation entries\n",
fc->name, r_ctl);
} else {
if (len > 60)
len = 60;
if (*(u32 *)hwrspc == LS_DISPLAY) {
int i;
for (i = 4; i < len; i++)
if (((u8 *)hwrspc)[i] == '\n')
((u8 *)hwrspc)[i] = ' ';
((u8 *)hwrspc)[len] = 0;
printk ("%s message: %s\n",
fc->name, ((u8 *)hwrspc) + 4);
} else {
printk ("%s: Unknown LS_CMD "
"%08x\n", fc->name,
*(u32 *)hwrspc);
}
}
} else {
printk ("%s: Unsolicited R_CTL %02x "
"not handled\n", fc->name, r_ctl);
}
}
break;
default:
printk ("%s: Unexpected flags %08x\n", fc->name, flags);
break;
};
update_out:
if (++sw_cq->out > sw_cq->last) {
sw_cq->seqno++;
sw_cq->out = 0;
}
if (hwrspc) {
if (++sw_cq->out > sw_cq->last) {
sw_cq->seqno++;
sw_cq->out = 0;
}
}
if (sw_cq->out == sw_cq->in) {
sw_cq->in = sbus_readb(s->regs + RESP + qno);
if (sw_cq->out == sw_cq->in) {
/* Tell the hardware about it */
sbus_writel((sw_cq->out << 24) |
(SOCAL_CMD_RSP_QALL &
~(SOCAL_CMD_RSP_Q0 << qno)),
s->regs + CMD);
/* Read it, so that we're sure it has been updated */
sbus_readl(s->regs + CMD);
sw_cq->in = sbus_readb(s->regs + RESP + qno);
}
}
}
}
static irqreturn_t socal_intr(int irq, void *dev_id)
{
u32 cmd;
unsigned long flags;
register struct socal *s = (struct socal *)dev_id;
spin_lock_irqsave(&s->lock, flags);
cmd = sbus_readl(s->regs + CMD);
for (; (cmd = SOCAL_INTR (s, cmd)); cmd = sbus_readl(s->regs + CMD)) {
#ifdef SOCALDEBUG
static int cnt = 0;
if (cnt++ < 50)
printk("soc_intr %08x\n", cmd);
#endif
if (cmd & SOCAL_CMD_RSP_Q2)
socal_unsolicited (s, SOCAL_UNSOLICITED_RSP_Q);
if (cmd & SOCAL_CMD_RSP_Q1)
socal_unsolicited (s, SOCAL_SOLICITED_BAD_RSP_Q);
if (cmd & SOCAL_CMD_RSP_Q0)
socal_solicited (s, SOCAL_SOLICITED_RSP_Q);
if (cmd & SOCAL_CMD_REQ_QALL)
socal_request (s, cmd);
}
spin_unlock_irqrestore(&s->lock, flags);
return IRQ_HANDLED;
}
#define TOKEN(proto, port, token) (((proto)<<12)|(token)|(port))
static int socal_hw_enque (fc_channel *fc, fcp_cmnd *fcmd)
{
socal_port *port = (socal_port *)fc;
struct socal *s = port->s;
unsigned long qno;
socal_cq *sw_cq;
int cq_next_in;
socal_req *request;
fc_hdr *fch;
int i;
if (fcmd->proto == TYPE_SCSI_FCP)
qno = 1;
else
qno = 0;
SOD(("Putting a FCP packet type %d into hw queue %d\n", fcmd->proto, qno))
if (s->imask & (SOCAL_IMASK_REQ_Q0 << qno)) {
SOD(("EIO %08x\n", s->imask))
return -EIO;
}
sw_cq = s->req + qno;
cq_next_in = (sw_cq->in + 1) & sw_cq->last;
if (cq_next_in == sw_cq->out &&
cq_next_in == (sw_cq->out = sbus_readb(s->regs + REQP + qno))) {
SOD(("%d IN %d OUT %d LAST %d\n",
qno, sw_cq->in,
sw_cq->out, sw_cq->last))
SOCAL_SETIMASK(s, s->imask | (SOCAL_IMASK_REQ_Q0 << qno));
SOD(("imask %08x %08x\n", s->imask, sbus_readl(s->regs + IMASK)));
/* If queue is full, just say NO. */
return -EBUSY;
}
request = sw_cq->pool + sw_cq->in;
fch = &request->fchdr;
switch (fcmd->proto) {
case TYPE_SCSI_FCP:
request->shdr.token = TOKEN(TYPE_SCSI_FCP, port->mask, fcmd->token);
request->data[0].base = fc->dma_scsi_cmd + fcmd->token * sizeof(fcp_cmd);
request->data[0].count = sizeof(fcp_cmd);
request->data[1].base = fc->dma_scsi_rsp + fcmd->token * fc->rsp_size;
request->data[1].count = fc->rsp_size;
if (fcmd->data) {
request->shdr.segcnt = 3;
i = fc->scsi_cmd_pool[fcmd->token].fcp_data_len;
request->shdr.bytecnt = i;
request->data[2].base = fcmd->data;
request->data[2].count = i;
request->type = (fc->scsi_cmd_pool[fcmd->token].fcp_cntl & FCP_CNTL_WRITE) ?
SOCAL_CQTYPE_IO_WRITE : SOCAL_CQTYPE_IO_READ;
} else {
request->shdr.segcnt = 2;
request->shdr.bytecnt = 0;
request->data[2].base = 0;
request->data[2].count = 0;
request->type = SOCAL_CQTYPE_SIMPLE;
}
FILL_FCHDR_RCTL_DID(fch, R_CTL_COMMAND, fcmd->did);
FILL_FCHDR_SID(fch, fc->sid);
FILL_FCHDR_TYPE_FCTL(fch, TYPE_SCSI_FCP, F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE);
FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0);
FILL_FCHDR_OXRX(fch, 0xffff, 0xffff);
fch->param = 0;
request->shdr.flags = port->flags;
request->shdr.class = fc->posmap ? 3 : 2;
break;
case PROTO_OFFLINE:
memset (request, 0, sizeof(*request));
request->shdr.token = TOKEN(PROTO_OFFLINE, port->mask, fcmd->token);
request->type = SOCAL_CQTYPE_OFFLINE;
FILL_FCHDR_RCTL_DID(fch, R_CTL_COMMAND, fcmd->did);
FILL_FCHDR_SID(fch, fc->sid);
FILL_FCHDR_TYPE_FCTL(fch, TYPE_SCSI_FCP, F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE);
FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0);
FILL_FCHDR_OXRX(fch, 0xffff, 0xffff);
request->shdr.flags = port->flags;
break;
case PROTO_REPORT_AL_MAP:
memset (request, 0, sizeof(*request));
request->shdr.token = TOKEN(PROTO_REPORT_AL_MAP, port->mask, fcmd->token);
request->type = SOCAL_CQTYPE_REPORT_MAP;
request->shdr.flags = port->flags;
request->shdr.segcnt = 1;
request->shdr.bytecnt = sizeof(fc_al_posmap);
request->data[0].base = fcmd->cmd;
request->data[0].count = sizeof(fc_al_posmap);
break;
default:
request->shdr.token = TOKEN(fcmd->proto, port->mask, fcmd->token);
request->shdr.class = fc->posmap ? 3 : 2;
request->shdr.flags = port->flags;
memcpy (fch, &fcmd->fch, sizeof(fc_hdr));
request->data[0].count = fcmd->cmdlen;
request->data[1].count = fcmd->rsplen;
request->type = fcmd->class;
switch (fcmd->class) {
case FC_CLASS_OUTBOUND:
request->data[0].base = fcmd->cmd;
request->data[0].count = fcmd->cmdlen;
request->type = SOCAL_CQTYPE_OUTBOUND;
request->shdr.bytecnt = fcmd->cmdlen;
request->shdr.segcnt = 1;
break;
case FC_CLASS_INBOUND:
request->data[0].base = fcmd->rsp;
request->data[0].count = fcmd->rsplen;
request->type = SOCAL_CQTYPE_INBOUND;
request->shdr.bytecnt = 0;
request->shdr.segcnt = 1;
break;
case FC_CLASS_SIMPLE:
request->data[0].base = fcmd->cmd;
request->data[1].base = fcmd->rsp;
request->data[0].count = fcmd->cmdlen;
request->data[1].count = fcmd->rsplen;
request->type = SOCAL_CQTYPE_SIMPLE;
request->shdr.bytecnt = fcmd->cmdlen;
request->shdr.segcnt = 2;
break;
case FC_CLASS_IO_READ:
case FC_CLASS_IO_WRITE:
request->data[0].base = fcmd->cmd;
request->data[1].base = fcmd->rsp;
request->data[0].count = fcmd->cmdlen;
request->data[1].count = fcmd->rsplen;
request->type = (fcmd->class == FC_CLASS_IO_READ) ? SOCAL_CQTYPE_IO_READ : SOCAL_CQTYPE_IO_WRITE;
if (fcmd->data) {
request->data[2].base = fcmd->data;
request->data[2].count = fcmd->datalen;
request->shdr.bytecnt = fcmd->datalen;
request->shdr.segcnt = 3;
} else {
request->shdr.bytecnt = 0;
request->shdr.segcnt = 2;
}
break;
}
break;
}
request->count = 1;
request->flags = 0;
request->seqno = sw_cq->seqno;
SOD(("queueing token %08x\n", request->shdr.token))
/* And now tell the SOCAL about it */
if (++sw_cq->in > sw_cq->last) {
sw_cq->in = 0;
sw_cq->seqno++;
}
SOD(("Putting %08x into cmd\n", SOCAL_CMD_RSP_QALL | (sw_cq->in << 24) | (SOCAL_CMD_REQ_Q0 << qno)))
sbus_writel(SOCAL_CMD_RSP_QALL | (sw_cq->in << 24) | (SOCAL_CMD_REQ_Q0 << qno),
s->regs + CMD);
/* Read so that command is completed */
sbus_readl(s->regs + CMD);
return 0;
}
static inline void socal_download_fw(struct socal *s)
{
#ifdef HAVE_SOCAL_UCODE
SOD(("Loading %ld bytes from %p to %p\n", sizeof(socal_ucode), socal_ucode, s->xram))
socal_copy_to_xram(s->xram, socal_ucode, sizeof(socal_ucode));
SOD(("Clearing the rest of memory\n"))
socal_bzero (s->xram + sizeof(socal_ucode), 65536 - sizeof(socal_ucode));
SOD(("Done\n"))
#endif
}
/* Check for what the best SBUS burst we can use happens
* to be on this machine.
*/
static inline void socal_init_bursts(struct socal *s, struct sbus_dev *sdev)
{
int bsizes, bsizes_more;
u32 cfg;
bsizes = (prom_getintdefault(sdev->prom_node,"burst-sizes",0xff) & 0xff);
bsizes_more = (prom_getintdefault(sdev->bus->prom_node, "burst-sizes", 0xff) & 0xff);
bsizes &= bsizes_more;
#ifdef USE_64BIT_MODE
#ifdef __sparc_v9__
mmu_set_sbus64(sdev, bsizes >> 16);
#endif
#endif
if ((bsizes & 0x7f) == 0x7f)
cfg = SOCAL_CFG_BURST_64;
else if ((bsizes & 0x3f) == 0x3f)
cfg = SOCAL_CFG_BURST_32;
else if ((bsizes & 0x1f) == 0x1f)
cfg = SOCAL_CFG_BURST_16;
else
cfg = SOCAL_CFG_BURST_4;
#ifdef USE_64BIT_MODE
#ifdef __sparc_v9__
/* What is BURST_128? -jj */
if ((bsizes & 0x780000) == 0x780000)
cfg |= (SOCAL_CFG_BURST_64 << 8) | SOCAL_CFG_SBUS_ENHANCED;
else if ((bsizes & 0x380000) == 0x380000)
cfg |= (SOCAL_CFG_BURST_32 << 8) | SOCAL_CFG_SBUS_ENHANCED;
else if ((bsizes & 0x180000) == 0x180000)
cfg |= (SOCAL_CFG_BURST_16 << 8) | SOCAL_CFG_SBUS_ENHANCED;
else
cfg |= (SOCAL_CFG_BURST_8 << 8) | SOCAL_CFG_SBUS_ENHANCED;
#endif
#endif
s->cfg = cfg;
}
static inline void socal_init(struct sbus_dev *sdev, int no)
{
unsigned char tmp[60];
int propl;
struct socal *s;
static unsigned version_printed = 0;
socal_hw_cq cq[8];
int size, i;
int irq, node;
s = kzalloc (sizeof (struct socal), GFP_KERNEL);
if (!s) return;
spin_lock_init(&s->lock);
s->socal_no = no;
SOD(("socals %08lx socal_intr %08lx socal_hw_enque %08lx\n",
(long)socals, (long)socal_intr, (long)socal_hw_enque))
if (version_printed++ == 0)
printk (version);
s->port[0].fc.module = THIS_MODULE;
s->port[1].fc.module = THIS_MODULE;
s->next = socals;
socals = s;
s->port[0].fc.dev = sdev;
s->port[1].fc.dev = sdev;
s->port[0].s = s;
s->port[1].s = s;
s->port[0].fc.next = &s->port[1].fc;
/* World Wide Name of SOCAL */
propl = prom_getproperty (sdev->prom_node, "wwn", tmp, sizeof(tmp));
if (propl != sizeof (fc_wwn)) {
s->wwn.naaid = NAAID_IEEE_REG;
s->wwn.nportid = 0x123;
s->wwn.hi = 0x1234;
s->wwn.lo = 0x12345678;
} else
memcpy (&s->wwn, tmp, sizeof (fc_wwn));
memcpy (&s->port[0].fc.wwn_nport, &s->wwn, sizeof (fc_wwn));
s->port[0].fc.wwn_nport.lo++;
memcpy (&s->port[1].fc.wwn_nport, &s->wwn, sizeof (fc_wwn));
s->port[1].fc.wwn_nport.lo+=2;
node = prom_getchild (sdev->prom_node);
while (node && (node = prom_searchsiblings (node, "sf"))) {
int port;
port = prom_getintdefault(node, "port#", -1);
switch (port) {
case 0:
case 1:
if (prom_getproplen(node, "port-wwn") == sizeof (fc_wwn))
prom_getproperty (node, "port-wwn",
(char *)&s->port[port].fc.wwn_nport,
sizeof (fc_wwn));
break;
default:
break;
};
node = prom_getsibling(node);
}
memcpy (&s->port[0].fc.wwn_node, &s->wwn, sizeof (fc_wwn));
memcpy (&s->port[1].fc.wwn_node, &s->wwn, sizeof (fc_wwn));
SOD(("Got wwns %08x%08x ports %08x%08x and %08x%08x\n",
*(u32 *)&s->port[0].fc.wwn_node, s->port[0].fc.wwn_node.lo,
*(u32 *)&s->port[0].fc.wwn_nport, s->port[0].fc.wwn_nport.lo,
*(u32 *)&s->port[1].fc.wwn_nport, s->port[1].fc.wwn_nport.lo))
s->port[0].fc.sid = 1;
s->port[1].fc.sid = 17;
s->port[0].fc.did = 2;
s->port[1].fc.did = 18;
s->port[0].fc.reset = socal_reset;
s->port[1].fc.reset = socal_reset;
if (sdev->num_registers == 1) {
s->eeprom = sbus_ioremap(&sdev->resource[0], 0,
sdev->reg_addrs[0].reg_size, "socal xram");
if (sdev->reg_addrs[0].reg_size > 0x20000)
s->xram = s->eeprom + 0x10000UL;
else
s->xram = s->eeprom;
s->regs = (s->xram + 0x10000UL);
} else {
/* E.g. starfire presents 3 registers for SOCAL */
s->xram = sbus_ioremap(&sdev->resource[1], 0,
sdev->reg_addrs[1].reg_size, "socal xram");
s->regs = sbus_ioremap(&sdev->resource[2], 0,
sdev->reg_addrs[2].reg_size, "socal regs");
}
socal_init_bursts(s, sdev);
SOD(("Disabling SOCAL\n"))
socal_disable (s);
irq = sdev->irqs[0];
if (request_irq (irq, socal_intr, IRQF_SHARED, "SOCAL", (void *)s)) {
socal_printk ("Cannot order irq %d to go\n", irq);
socals = s->next;
return;
}
SOD(("SOCAL uses IRQ %d\n", irq))
s->port[0].fc.irq = irq;
s->port[1].fc.irq = irq;
sprintf (s->port[0].fc.name, "socal%d port A", no);
sprintf (s->port[1].fc.name, "socal%d port B", no);
s->port[0].flags = SOCAL_FC_HDR | SOCAL_PORT_A;
s->port[1].flags = SOCAL_FC_HDR | SOCAL_PORT_B;
s->port[1].mask = (1 << 11);
s->port[0].fc.hw_enque = socal_hw_enque;
s->port[1].fc.hw_enque = socal_hw_enque;
socal_download_fw (s);
SOD(("Downloaded firmware\n"))
/* Now setup xram circular queues */
memset (cq, 0, sizeof(cq));
size = (SOCAL_CQ_REQ0_SIZE + SOCAL_CQ_REQ1_SIZE +
SOCAL_CQ_RSP0_SIZE + SOCAL_CQ_RSP1_SIZE +
SOCAL_CQ_RSP2_SIZE) * sizeof(socal_req);
s->req_cpu = sbus_alloc_consistent(sdev, size, &s->req_dvma);
s->req[0].pool = s->req_cpu;
cq[0].address = s->req_dvma;
s->req[1].pool = s->req[0].pool + SOCAL_CQ_REQ0_SIZE;
s->rsp[0].pool = s->req[1].pool + SOCAL_CQ_REQ1_SIZE;
s->rsp[1].pool = s->rsp[0].pool + SOCAL_CQ_RSP0_SIZE;
s->rsp[2].pool = s->rsp[1].pool + SOCAL_CQ_RSP1_SIZE;
s->req[0].hw_cq = (socal_hw_cq __iomem *)(s->xram + SOCAL_CQ_REQ_OFFSET);
s->req[1].hw_cq = (socal_hw_cq __iomem *)(s->xram + SOCAL_CQ_REQ_OFFSET + sizeof(socal_hw_cq));
s->rsp[0].hw_cq = (socal_hw_cq __iomem *)(s->xram + SOCAL_CQ_RSP_OFFSET);
s->rsp[1].hw_cq = (socal_hw_cq __iomem *)(s->xram + SOCAL_CQ_RSP_OFFSET + sizeof(socal_hw_cq));
s->rsp[2].hw_cq = (socal_hw_cq __iomem *)(s->xram + SOCAL_CQ_RSP_OFFSET + 2 * sizeof(socal_hw_cq));
cq[1].address = cq[0].address + (SOCAL_CQ_REQ0_SIZE * sizeof(socal_req));
cq[4].address = cq[1].address + (SOCAL_CQ_REQ1_SIZE * sizeof(socal_req));
cq[5].address = cq[4].address + (SOCAL_CQ_RSP0_SIZE * sizeof(socal_req));
cq[6].address = cq[5].address + (SOCAL_CQ_RSP1_SIZE * sizeof(socal_req));
cq[0].last = SOCAL_CQ_REQ0_SIZE - 1;
cq[1].last = SOCAL_CQ_REQ1_SIZE - 1;
cq[4].last = SOCAL_CQ_RSP0_SIZE - 1;
cq[5].last = SOCAL_CQ_RSP1_SIZE - 1;
cq[6].last = SOCAL_CQ_RSP2_SIZE - 1;
for (i = 0; i < 8; i++)
cq[i].seqno = 1;
s->req[0].last = SOCAL_CQ_REQ0_SIZE - 1;
s->req[1].last = SOCAL_CQ_REQ1_SIZE - 1;
s->rsp[0].last = SOCAL_CQ_RSP0_SIZE - 1;
s->rsp[1].last = SOCAL_CQ_RSP1_SIZE - 1;
s->rsp[2].last = SOCAL_CQ_RSP2_SIZE - 1;
s->req[0].seqno = 1;
s->req[1].seqno = 1;
s->rsp[0].seqno = 1;
s->rsp[1].seqno = 1;
s->rsp[2].seqno = 1;
socal_copy_to_xram(s->xram + SOCAL_CQ_REQ_OFFSET, cq, sizeof(cq));
SOD(("Setting up params\n"))
/* Make our sw copy of SOCAL service parameters */
socal_copy_from_xram(s->serv_params, s->xram + 0x280, sizeof (s->serv_params));
s->port[0].fc.common_svc = (common_svc_parm *)s->serv_params;
s->port[0].fc.class_svcs = (svc_parm *)(s->serv_params + 0x20);
s->port[1].fc.common_svc = (common_svc_parm *)&s->serv_params;
s->port[1].fc.class_svcs = (svc_parm *)(s->serv_params + 0x20);
socal_enable (s);
SOD(("Enabled SOCAL\n"))
}
static int __init socal_probe(void)
{
struct sbus_bus *sbus;
struct sbus_dev *sdev = NULL;
struct socal *s;
int cards = 0;
for_each_sbus(sbus) {
for_each_sbusdev(sdev, sbus) {
if(!strcmp(sdev->prom_name, "SUNW,socal")) {
socal_init(sdev, cards);
cards++;
}
}
}
if (!cards)
return -EIO;
for_each_socal(s)
if (s->next)
s->port[1].fc.next = &s->next->port[0].fc;
fcp_init (&socals->port[0].fc);
return 0;
}
static void __exit socal_cleanup(void)
{
struct socal *s;
int irq;
struct sbus_dev *sdev;
for_each_socal(s) {
irq = s->port[0].fc.irq;
free_irq (irq, s);
fcp_release(&(s->port[0].fc), 2);
sdev = s->port[0].fc.dev;
if (sdev->num_registers == 1) {
sbus_iounmap(s->eeprom, sdev->reg_addrs[0].reg_size);
} else {
sbus_iounmap(s->xram, sdev->reg_addrs[1].reg_size);
sbus_iounmap(s->regs, sdev->reg_addrs[2].reg_size);
}
sbus_free_consistent(sdev,
(SOCAL_CQ_REQ0_SIZE + SOCAL_CQ_REQ1_SIZE +
SOCAL_CQ_RSP0_SIZE + SOCAL_CQ_RSP1_SIZE +
SOCAL_CQ_RSP2_SIZE) * sizeof(socal_req),
s->req_cpu, s->req_dvma);
}
}
module_init(socal_probe);
module_exit(socal_cleanup);
MODULE_LICENSE("GPL");

314
drivers/fc4/socal.h
View File

@ -1,314 +0,0 @@
/* socal.h: Definitions for Sparc SUNW,socal (SOC+) Fibre Channel Sbus driver.
*
* Copyright (C) 1998,1999 Jakub Jelinek (jj@ultra.linux.cz)
*/
#ifndef __SOCAL_H
#define __SOCAL_H
#include "fc.h"
#include "fcp.h"
#include "fcp_impl.h"
/* Hardware register offsets and constants first {{{ */
#define CFG 0x00UL
#define SAE 0x04UL
#define CMD 0x08UL
#define IMASK 0x0cUL
#define REQP 0x10UL
#define RESP 0x14UL
/* Config Register */
#define SOCAL_CFG_EXT_RAM_BANK_MASK 0x07000000
#define SOCAL_CFG_EEPROM_BANK_MASK 0x00030000
#define SOCAL_CFG_BURST64_MASK 0x00000700
#define SOCAL_CFG_SBUS_PARITY_TEST 0x00000020
#define SOCAL_CFG_SBUS_PARITY_CHECK 0x00000010
#define SOCAL_CFG_SBUS_ENHANCED 0x00000008
#define SOCAL_CFG_BURST_MASK 0x00000007
/* Bursts */
#define SOCAL_CFG_BURST_4 0x00000000
#define SOCAL_CFG_BURST_8 0x00000003
#define SOCAL_CFG_BURST_16 0x00000004
#define SOCAL_CFG_BURST_32 0x00000005
#define SOCAL_CFG_BURST_64 0x00000006
#define SOCAL_CFG_BURST_128 0x00000007
/* Slave Access Error Register */
#define SOCAL_SAE_ALIGNMENT 0x00000004
#define SOCAL_SAE_UNSUPPORTED 0x00000002
#define SOCAL_SAE_PARITY 0x00000001
/* Command & Status Register */
#define SOCAL_CMD_RSP_QALL 0x000f0000
#define SOCAL_CMD_RSP_Q0 0x00010000
#define SOCAL_CMD_RSP_Q1 0x00020000
#define SOCAL_CMD_RSP_Q2 0x00040000
#define SOCAL_CMD_RSP_Q3 0x00080000
#define SOCAL_CMD_REQ_QALL 0x00000f00
#define SOCAL_CMD_REQ_Q0 0x00000100
#define SOCAL_CMD_REQ_Q1 0x00000200
#define SOCAL_CMD_REQ_Q2 0x00000400
#define SOCAL_CMD_REQ_Q3 0x00000800
#define SOCAL_CMD_SAE 0x00000080
#define SOCAL_CMD_INTR_PENDING 0x00000008
#define SOCAL_CMD_NON_QUEUED 0x00000004
#define SOCAL_CMD_IDLE 0x00000002
#define SOCAL_CMD_SOFT_RESET 0x00000001
/* Interrupt Mask Register */
#define SOCAL_IMASK_RSP_QALL 0x000f0000
#define SOCAL_IMASK_RSP_Q0 0x00010000
#define SOCAL_IMASK_RSP_Q1 0x00020000
#define SOCAL_IMASK_RSP_Q2 0x00040000
#define SOCAL_IMASK_RSP_Q3 0x00080000
#define SOCAL_IMASK_REQ_QALL 0x00000f00
#define SOCAL_IMASK_REQ_Q0 0x00000100
#define SOCAL_IMASK_REQ_Q1 0x00000200
#define SOCAL_IMASK_REQ_Q2 0x00000400
#define SOCAL_IMASK_REQ_Q3 0x00000800
#define SOCAL_IMASK_SAE 0x00000080
#define SOCAL_IMASK_NON_QUEUED 0x00000004
#define SOCAL_INTR(s, cmd) \
(((cmd & SOCAL_CMD_RSP_QALL) | ((~cmd) & SOCAL_CMD_REQ_QALL)) \
& s->imask)
#define SOCAL_SETIMASK(s, i) \
do { (s)->imask = (i); \
sbus_writel((i), (s)->regs + IMASK); \
} while (0)
#define SOCAL_MAX_EXCHANGES 1024
/* XRAM
*
* This is a 64KB register area.
* From the documentation, it seems like it is finally able to cope
* at least with 1,2,4 byte accesses for read and 2,4 byte accesses for write.
*/
/* Circular Queue */
#define SOCAL_CQ_REQ_OFFSET 0x200
#define SOCAL_CQ_RSP_OFFSET 0x220
typedef struct {
u32 address;
u8 in;
u8 out;
u8 last;
u8 seqno;
} socal_hw_cq;
#define SOCAL_PORT_A 0x0000 /* From/To Port A */
#define SOCAL_PORT_B 0x0001 /* From/To Port A */
#define SOCAL_FC_HDR 0x0002 /* Contains FC Header */
#define SOCAL_NORSP 0x0004 /* Don't generate response nor interrupt */
#define SOCAL_NOINT 0x0008 /* Generate response but not interrupt */
#define SOCAL_XFERRDY 0x0010 /* Generate XFERRDY */
#define SOCAL_IGNOREPARAM 0x0020 /* Ignore PARAM field in the FC header */
#define SOCAL_COMPLETE 0x0040 /* Command completed */
#define SOCAL_UNSOLICITED 0x0080 /* For request this is the packet to establish unsolicited pools, */
/* for rsp this is unsolicited packet */
#define SOCAL_STATUS 0x0100 /* State change (on/off line) */
#define SOCAL_RSP_HDR 0x0200 /* Return frame header in any case */
typedef struct {
u32 token;
u16 flags;
u8 class;
u8 segcnt;
u32 bytecnt;
} socal_hdr;
typedef struct {
u32 base;
u32 count;
} socal_data;
#define SOCAL_CQTYPE_NOP 0x00
#define SOCAL_CQTYPE_OUTBOUND 0x01
#define SOCAL_CQTYPE_INBOUND 0x02
#define SOCAL_CQTYPE_SIMPLE 0x03
#define SOCAL_CQTYPE_IO_WRITE 0x04
#define SOCAL_CQTYPE_IO_READ 0x05
#define SOCAL_CQTYPE_UNSOLICITED 0x06
#define SOCAL_CQTYPE_BYPASS_DEV 0x06
#define SOCAL_CQTYPE_DIAG 0x07
#define SOCAL_CQTYPE_OFFLINE 0x08
#define SOCAL_CQTYPE_ADD_POOL 0x09
#define SOCAL_CQTYPE_DELETE_POOL 0x0a
#define SOCAL_CQTYPE_ADD_BUFFER 0x0b
#define SOCAL_CQTYPE_ADD_POOL_BUFFER 0x0c
#define SOCAL_CQTYPE_REQUEST_ABORT 0x0d
#define SOCAL_CQTYPE_REQUEST_LIP 0x0e
#define SOCAL_CQTYPE_REPORT_MAP 0x0f
#define SOCAL_CQTYPE_RESPONSE 0x10
#define SOCAL_CQTYPE_INLINE 0x20
#define SOCAL_CQFLAGS_CONT 0x01
#define SOCAL_CQFLAGS_FULL 0x02
#define SOCAL_CQFLAGS_BADHDR 0x04
#define SOCAL_CQFLAGS_BADPKT 0x08
typedef struct {
socal_hdr shdr;
socal_data data[3];
fc_hdr fchdr;
u8 count;
u8 type;
u8 flags;
u8 seqno;
} socal_req;
#define SOCAL_OK 0
#define SOCAL_P_RJT 2
#define SOCAL_F_RJT 3
#define SOCAL_P_BSY 4
#define SOCAL_F_BSY 5
#define SOCAL_ONLINE 0x10
#define SOCAL_OFFLINE 0x11
#define SOCAL_TIMEOUT 0x12
#define SOCAL_OVERRUN 0x13
#define SOCAL_ONLINE_LOOP 0x14
#define SOCAL_OLD_PORT 0x15
#define SOCAL_AL_PORT 0x16
#define SOCAL_UNKOWN_CQ_TYPE 0x20
#define SOCAL_BAD_SEG_CNT 0x21
#define SOCAL_MAX_XCHG_EXCEEDED 0x22
#define SOCAL_BAD_XID 0x23
#define SOCAL_XCHG_BUSY 0x24
#define SOCAL_BAD_POOL_ID 0x25
#define SOCAL_INSUFFICIENT_CQES 0x26
#define SOCAL_ALLOC_FAIL 0x27
#define SOCAL_BAD_SID 0x28
#define SOCAL_NO_SEG_INIT 0x29
#define SOCAL_BAD_DID 0x2a
#define SOCAL_ABORTED 0x30
#define SOCAL_ABORT_FAILED 0x31
typedef struct {
socal_hdr shdr;
u32 status;
socal_data data;
u8 xxx1[10];
u16 ncmds;
fc_hdr fchdr;
u8 count;
u8 type;
u8 flags;
u8 seqno;
} socal_rsp;
typedef struct {
socal_hdr shdr;
u8 xxx1[48];
u8 count;
u8 type;
u8 flags;
u8 seqno;
} socal_cmdonly;
#define SOCAL_DIAG_NOP 0x00
#define SOCAL_DIAG_INT_LOOP 0x01
#define SOCAL_DIAG_EXT_LOOP 0x02
#define SOCAL_DIAG_REM_LOOP 0x03
#define SOCAL_DIAG_XRAM_TEST 0x04
#define SOCAL_DIAG_SOC_TEST 0x05
#define SOCAL_DIAG_HCB_TEST 0x06
#define SOCAL_DIAG_SOCLB_TEST 0x07
#define SOCAL_DIAG_SRDSLB_TEST 0x08
#define SOCAL_DIAG_EXTOE_TEST 0x09
typedef struct {
socal_hdr shdr;
u32 cmd;
u8 xxx1[44];
u8 count;
u8 type;
u8 flags;
u8 seqno;
} socal_diag_req;
#define SOCAL_POOL_MASK_RCTL 0x800000
#define SOCAL_POOL_MASK_DID 0x700000
#define SOCAL_POOL_MASK_SID 0x070000
#define SOCAL_POOL_MASK_TYPE 0x008000
#define SOCAL_POOL_MASK_F_CTL 0x007000
#define SOCAL_POOL_MASK_SEQ_ID 0x000800
#define SOCAL_POOL_MASK_D_CTL 0x000400
#define SOCAL_POOL_MASK_SEQ_CNT 0x000300
#define SOCAL_POOL_MASK_OX_ID 0x0000f0
#define SOCAL_POOL_MASK_PARAM 0x00000f
typedef struct {
socal_hdr shdr;
u32 pool_id;
u32 header_mask;
u32 buf_size;
u32 entries;
u8 xxx1[8];
fc_hdr fchdr;
u8 count;
u8 type;
u8 flags;
u8 seqno;
} socal_pool_req;
/* }}} */
/* Now our software structures and constants we use to drive the beast {{{ */
#define SOCAL_CQ_REQ0_SIZE 4
#define SOCAL_CQ_REQ1_SIZE 256
#define SOCAL_CQ_RSP0_SIZE 8
#define SOCAL_CQ_RSP1_SIZE 4
#define SOCAL_CQ_RSP2_SIZE 4
#define SOCAL_SOLICITED_RSP_Q 0
#define SOCAL_SOLICITED_BAD_RSP_Q 1
#define SOCAL_UNSOLICITED_RSP_Q 2
struct socal;
typedef struct {
/* This must come first */
fc_channel fc;
struct socal *s;
u16 flags;
u16 mask;
} socal_port;
typedef struct {
socal_hw_cq __iomem *hw_cq; /* Related XRAM cq */
socal_req *pool;
u8 in;
u8 out;
u8 last;
u8 seqno;
} socal_cq;
struct socal {
spinlock_t lock;
socal_port port[2]; /* Every SOCAL has one or two FC ports */
socal_cq req[4]; /* Request CQs */
socal_cq rsp[4]; /* Response CQs */
int socal_no;
void __iomem *regs;
void __iomem *xram;
void __iomem *eeprom;
fc_wwn wwn;
u32 imask; /* Our copy of regs->imask */
u32 cfg; /* Our copy of regs->cfg */
char serv_params[80];
struct socal *next;
int curr_port; /* Which port will have priority to fcp_queue_empty */
socal_req * req_cpu;
u32 req_dvma;
};
/* }}} */
#endif /* !(__SOCAL_H) */

2
drivers/scsi/Makefile
View File

@ -115,7 +115,6 @@ obj-$(CONFIG_SCSI_QLOGICPTI) += qlogicpti.o
obj-$(CONFIG_BLK_DEV_IDESCSI) += ide-scsi.o obj-$(CONFIG_BLK_DEV_IDESCSI) += ide-scsi.o
obj-$(CONFIG_SCSI_MESH) += mesh.o obj-$(CONFIG_SCSI_MESH) += mesh.o
obj-$(CONFIG_SCSI_MAC53C94) += mac53c94.o obj-$(CONFIG_SCSI_MAC53C94) += mac53c94.o
obj-$(CONFIG_SCSI_PLUTO) += pluto.o
obj-$(CONFIG_SCSI_DECNCR) += NCR53C9x.o dec_esp.o obj-$(CONFIG_SCSI_DECNCR) += NCR53C9x.o dec_esp.o
obj-$(CONFIG_BLK_DEV_3W_XXXX_RAID) += 3w-xxxx.o obj-$(CONFIG_BLK_DEV_3W_XXXX_RAID) += 3w-xxxx.o
obj-$(CONFIG_SCSI_3W_9XXX) += 3w-9xxx.o obj-$(CONFIG_SCSI_3W_9XXX) += 3w-9xxx.o
@ -123,7 +122,6 @@ obj-$(CONFIG_SCSI_PPA) += ppa.o
obj-$(CONFIG_SCSI_IMM) += imm.o obj-$(CONFIG_SCSI_IMM) += imm.o
obj-$(CONFIG_JAZZ_ESP) += esp_scsi.o jazz_esp.o obj-$(CONFIG_JAZZ_ESP) += esp_scsi.o jazz_esp.o
obj-$(CONFIG_SUN3X_ESP) += NCR53C9x.o sun3x_esp.o obj-$(CONFIG_SUN3X_ESP) += NCR53C9x.o sun3x_esp.o
obj-$(CONFIG_SCSI_FCAL) += fcal.o
obj-$(CONFIG_SCSI_LASI700) += 53c700.o lasi700.o obj-$(CONFIG_SCSI_LASI700) += 53c700.o lasi700.o
obj-$(CONFIG_SCSI_SNI_53C710) += 53c700.o sni_53c710.o obj-$(CONFIG_SCSI_SNI_53C710) += 53c700.o sni_53c710.o
obj-$(CONFIG_SCSI_NSP32) += nsp32.o obj-$(CONFIG_SCSI_NSP32) += nsp32.o

16
drivers/scsi/aic7xxx/aic7770.c
View File

@ -60,8 +60,6 @@
#define ID_OLV_274xD 0x04907783 /* Olivetti OEM (Differential) */ #define ID_OLV_274xD 0x04907783 /* Olivetti OEM (Differential) */
static int aic7770_chip_init(struct ahc_softc *ahc); static int aic7770_chip_init(struct ahc_softc *ahc);
static int aic7770_suspend(struct ahc_softc *ahc);
static int aic7770_resume(struct ahc_softc *ahc);
static int aha2840_load_seeprom(struct ahc_softc *ahc); static int aha2840_load_seeprom(struct ahc_softc *ahc);
static ahc_device_setup_t ahc_aic7770_VL_setup; static ahc_device_setup_t ahc_aic7770_VL_setup;
static ahc_device_setup_t ahc_aic7770_EISA_setup; static ahc_device_setup_t ahc_aic7770_EISA_setup;
@ -155,8 +153,6 @@ aic7770_config(struct ahc_softc *ahc, struct aic7770_identity *entry, u_int io)
return (error); return (error);
ahc->bus_chip_init = aic7770_chip_init; ahc->bus_chip_init = aic7770_chip_init;
ahc->bus_suspend = aic7770_suspend;
ahc->bus_resume = aic7770_resume;
error = ahc_reset(ahc, /*reinit*/FALSE); error = ahc_reset(ahc, /*reinit*/FALSE);
if (error != 0) if (error != 0)
@ -272,18 +268,6 @@ aic7770_chip_init(struct ahc_softc *ahc)
return (ahc_chip_init(ahc)); return (ahc_chip_init(ahc));
} }
static int
aic7770_suspend(struct ahc_softc *ahc)
{
return (ahc_suspend(ahc));
}
static int
aic7770_resume(struct ahc_softc *ahc)
{
return (ahc_resume(ahc));
}
/* /*
* Read the 284x SEEPROM. * Read the 284x SEEPROM.
*/ */

11
drivers/scsi/aic7xxx/aic79xx.h
View File

@ -1003,8 +1003,15 @@ struct ahd_suspend_channel_state {
uint8_t seqctl; uint8_t seqctl;
}; };
struct ahd_suspend_pci_state {
uint32_t devconfig;
uint8_t command;
uint8_t csize_lattime;
};
struct ahd_suspend_state { struct ahd_suspend_state {
struct ahd_suspend_channel_state channel[2]; struct ahd_suspend_channel_state channel[2];
struct ahd_suspend_pci_state pci_state;
uint8_t optionmode; uint8_t optionmode;
uint8_t dscommand0; uint8_t dscommand0;
uint8_t dspcistatus; uint8_t dspcistatus;
@ -1333,6 +1340,8 @@ struct ahd_pci_identity *ahd_find_pci_device(ahd_dev_softc_t);
int ahd_pci_config(struct ahd_softc *, int ahd_pci_config(struct ahd_softc *,
struct ahd_pci_identity *); struct ahd_pci_identity *);
int ahd_pci_test_register_access(struct ahd_softc *); int ahd_pci_test_register_access(struct ahd_softc *);
void ahd_pci_suspend(struct ahd_softc *);
void ahd_pci_resume(struct ahd_softc *);
/************************** SCB and SCB queue management **********************/ /************************** SCB and SCB queue management **********************/
void ahd_qinfifo_requeue_tail(struct ahd_softc *ahd, void ahd_qinfifo_requeue_tail(struct ahd_softc *ahd,
@ -1343,6 +1352,8 @@ struct ahd_softc *ahd_alloc(void *platform_arg, char *name);
int ahd_softc_init(struct ahd_softc *); int ahd_softc_init(struct ahd_softc *);
void ahd_controller_info(struct ahd_softc *ahd, char *buf); void ahd_controller_info(struct ahd_softc *ahd, char *buf);
int ahd_init(struct ahd_softc *ahd); int ahd_init(struct ahd_softc *ahd);
int ahd_suspend(struct ahd_softc *ahd);
void ahd_resume(struct ahd_softc *ahd);
int ahd_default_config(struct ahd_softc *ahd); int ahd_default_config(struct ahd_softc *ahd);
int ahd_parse_vpddata(struct ahd_softc *ahd, int ahd_parse_vpddata(struct ahd_softc *ahd,
struct vpd_config *vpd); struct vpd_config *vpd);

7
drivers/scsi/aic7xxx/aic79xx_core.c
View File

@ -7175,7 +7175,6 @@ ahd_pause_and_flushwork(struct ahd_softc *ahd)
ahd->flags &= ~AHD_ALL_INTERRUPTS; ahd->flags &= ~AHD_ALL_INTERRUPTS;
} }
#if 0
int int
ahd_suspend(struct ahd_softc *ahd) ahd_suspend(struct ahd_softc *ahd)
{ {
@ -7189,19 +7188,15 @@ ahd_suspend(struct ahd_softc *ahd)
ahd_shutdown(ahd); ahd_shutdown(ahd);
return (0); return (0);
} }
#endif /* 0 */
#if 0 void
int
ahd_resume(struct ahd_softc *ahd) ahd_resume(struct ahd_softc *ahd)
{ {
ahd_reset(ahd, /*reinit*/TRUE); ahd_reset(ahd, /*reinit*/TRUE);
ahd_intr_enable(ahd, TRUE); ahd_intr_enable(ahd, TRUE);
ahd_restart(ahd); ahd_restart(ahd);
return (0);
} }
#endif /* 0 */
/************************** Busy Target Table *********************************/ /************************** Busy Target Table *********************************/
/* /*

4
drivers/scsi/aic7xxx/aic79xx_osm.c
View File

@ -315,8 +315,8 @@ uint32_t aic79xx_slowcrc;
*/ */
static char *aic79xx = NULL; static char *aic79xx = NULL;
MODULE_AUTHOR("Maintainer: Justin T. Gibbs <gibbs@scsiguy.com>"); MODULE_AUTHOR("Maintainer: Hannes Reinecke <hare@suse.de>");
MODULE_DESCRIPTION("Adaptec Aic790X U320 SCSI Host Bus Adapter driver"); MODULE_DESCRIPTION("Adaptec AIC790X U320 SCSI Host Bus Adapter driver");
MODULE_LICENSE("Dual BSD/GPL"); MODULE_LICENSE("Dual BSD/GPL");
MODULE_VERSION(AIC79XX_DRIVER_VERSION); MODULE_VERSION(AIC79XX_DRIVER_VERSION);
module_param(aic79xx, charp, 0444); module_param(aic79xx, charp, 0444);

50
drivers/scsi/aic7xxx/aic79xx_osm_pci.c
View File

@ -50,6 +50,8 @@ static int ahd_linux_pci_reserve_io_regions(struct ahd_softc *ahd,
static int ahd_linux_pci_reserve_mem_region(struct ahd_softc *ahd, static int ahd_linux_pci_reserve_mem_region(struct ahd_softc *ahd,
u_long *bus_addr, u_long *bus_addr,
uint8_t __iomem **maddr); uint8_t __iomem **maddr);
static int ahd_linux_pci_dev_suspend(struct pci_dev *pdev, pm_message_t mesg);
static int ahd_linux_pci_dev_resume(struct pci_dev *pdev);
static void ahd_linux_pci_dev_remove(struct pci_dev *pdev); static void ahd_linux_pci_dev_remove(struct pci_dev *pdev);
/* Define the macro locally since it's different for different class of chips. /* Define the macro locally since it's different for different class of chips.
@ -86,10 +88,58 @@ MODULE_DEVICE_TABLE(pci, ahd_linux_pci_id_table);
static struct pci_driver aic79xx_pci_driver = { static struct pci_driver aic79xx_pci_driver = {
.name = "aic79xx", .name = "aic79xx",
.probe = ahd_linux_pci_dev_probe, .probe = ahd_linux_pci_dev_probe,
#ifdef CONFIG_PM
.suspend = ahd_linux_pci_dev_suspend,
.resume = ahd_linux_pci_dev_resume,
#endif
.remove = ahd_linux_pci_dev_remove, .remove = ahd_linux_pci_dev_remove,
.id_table = ahd_linux_pci_id_table .id_table = ahd_linux_pci_id_table
}; };
static int
ahd_linux_pci_dev_suspend(struct pci_dev *pdev, pm_message_t mesg)
{
struct ahd_softc *ahd = pci_get_drvdata(pdev);
int rc;
if ((rc = ahd_suspend(ahd)))
return rc;
ahd_pci_suspend(ahd);
pci_save_state(pdev);
pci_disable_device(pdev);
if (mesg.event == PM_EVENT_SUSPEND)
pci_set_power_state(pdev, PCI_D3hot);
return rc;
}
static int
ahd_linux_pci_dev_resume(struct pci_dev *pdev)
{
struct ahd_softc *ahd = pci_get_drvdata(pdev);
int rc;
pci_set_power_state(pdev, PCI_D0);
pci_restore_state(pdev);
if ((rc = pci_enable_device(pdev))) {
dev_printk(KERN_ERR, &pdev->dev,
"failed to enable device after resume (%d)\n", rc);
return rc;
}
pci_set_master(pdev);
ahd_pci_resume(ahd);
ahd_resume(ahd);
return rc;
}
static void static void
ahd_linux_pci_dev_remove(struct pci_dev *pdev) ahd_linux_pci_dev_remove(struct pci_dev *pdev)
{ {

27
drivers/scsi/aic7xxx/aic79xx_pci.c
View File

@ -389,6 +389,33 @@ ahd_pci_config(struct ahd_softc *ahd, struct ahd_pci_identity *entry)
return error; return error;
} }
void
ahd_pci_suspend(struct ahd_softc *ahd)
{
/*
* Save chip register configuration data for chip resets
* that occur during runtime and resume events.
*/
ahd->suspend_state.pci_state.devconfig =
ahd_pci_read_config(ahd->dev_softc, DEVCONFIG, /*bytes*/4);
ahd->suspend_state.pci_state.command =
ahd_pci_read_config(ahd->dev_softc, PCIR_COMMAND, /*bytes*/1);
ahd->suspend_state.pci_state.csize_lattime =
ahd_pci_read_config(ahd->dev_softc, CSIZE_LATTIME, /*bytes*/1);
}
void
ahd_pci_resume(struct ahd_softc *ahd)
{
ahd_pci_write_config(ahd->dev_softc, DEVCONFIG,
ahd->suspend_state.pci_state.devconfig, /*bytes*/4);
ahd_pci_write_config(ahd->dev_softc, PCIR_COMMAND,
ahd->suspend_state.pci_state.command, /*bytes*/1);
ahd_pci_write_config(ahd->dev_softc, CSIZE_LATTIME,
ahd->suspend_state.pci_state.csize_lattime, /*bytes*/1);
}
/* /*
* Perform some simple tests that should catch situations where * Perform some simple tests that should catch situations where
* our registers are invalidly mapped. * our registers are invalidly mapped.

11
drivers/scsi/aic7xxx/aic7xxx.h
View File

@ -961,16 +961,6 @@ struct ahc_softc {
*/ */
ahc_bus_chip_init_t bus_chip_init; ahc_bus_chip_init_t bus_chip_init;
/*
* Bus specific suspend routine.
*/
ahc_bus_suspend_t bus_suspend;
/*
* Bus specific resume routine.
*/
ahc_bus_resume_t bus_resume;
/* /*
* Target mode related state kept on a per enabled lun basis. * Target mode related state kept on a per enabled lun basis.
* Targets that are not enabled will have null entries. * Targets that are not enabled will have null entries.
@ -1153,6 +1143,7 @@ struct ahc_pci_identity *ahc_find_pci_device(ahc_dev_softc_t);
int ahc_pci_config(struct ahc_softc *, int ahc_pci_config(struct ahc_softc *,
struct ahc_pci_identity *); struct ahc_pci_identity *);
int ahc_pci_test_register_access(struct ahc_softc *); int ahc_pci_test_register_access(struct ahc_softc *);
void ahc_pci_resume(struct ahc_softc *ahc);
/*************************** EISA/VL Front End ********************************/ /*************************** EISA/VL Front End ********************************/
struct aic7770_identity *aic7770_find_device(uint32_t); struct aic7770_identity *aic7770_find_device(uint32_t);

4
drivers/scsi/aic7xxx/aic7xxx_osm.c
View File

@ -335,8 +335,8 @@ static uint32_t aic7xxx_periodic_otag;
*/ */
static char *aic7xxx = NULL; static char *aic7xxx = NULL;
MODULE_AUTHOR("Maintainer: Justin T. Gibbs <gibbs@scsiguy.com>"); MODULE_AUTHOR("Maintainer: Hannes Reinecke <hare@suse.de>");
MODULE_DESCRIPTION("Adaptec Aic77XX/78XX SCSI Host Bus Adapter driver"); MODULE_DESCRIPTION("Adaptec AIC77XX/78XX SCSI Host Bus Adapter driver");
MODULE_LICENSE("Dual BSD/GPL"); MODULE_LICENSE("Dual BSD/GPL");
MODULE_VERSION(AIC7XXX_DRIVER_VERSION); MODULE_VERSION(AIC7XXX_DRIVER_VERSION);
module_param(aic7xxx, charp, 0444); module_param(aic7xxx, charp, 0444);

46
drivers/scsi/aic7xxx/aic7xxx_osm_pci.c
View File

@ -49,6 +49,8 @@ static int ahc_linux_pci_reserve_io_region(struct ahc_softc *ahc,
static int ahc_linux_pci_reserve_mem_region(struct ahc_softc *ahc, static int ahc_linux_pci_reserve_mem_region(struct ahc_softc *ahc,
u_long *bus_addr, u_long *bus_addr,
uint8_t __iomem **maddr); uint8_t __iomem **maddr);
static int ahc_linux_pci_dev_suspend(struct pci_dev *pdev, pm_message_t mesg);
static int ahc_linux_pci_dev_resume(struct pci_dev *pdev);
static void ahc_linux_pci_dev_remove(struct pci_dev *pdev); static void ahc_linux_pci_dev_remove(struct pci_dev *pdev);
/* Define the macro locally since it's different for different class of chips. /* Define the macro locally since it's different for different class of chips.
@ -133,10 +135,54 @@ MODULE_DEVICE_TABLE(pci, ahc_linux_pci_id_table);
static struct pci_driver aic7xxx_pci_driver = { static struct pci_driver aic7xxx_pci_driver = {
.name = "aic7xxx", .name = "aic7xxx",
.probe = ahc_linux_pci_dev_probe, .probe = ahc_linux_pci_dev_probe,
#ifdef CONFIG_PM
.suspend = ahc_linux_pci_dev_suspend,
.resume = ahc_linux_pci_dev_resume,
#endif
.remove = ahc_linux_pci_dev_remove, .remove = ahc_linux_pci_dev_remove,
.id_table = ahc_linux_pci_id_table .id_table = ahc_linux_pci_id_table
}; };
static int
ahc_linux_pci_dev_suspend(struct pci_dev *pdev, pm_message_t mesg)
{
struct ahc_softc *ahc = pci_get_drvdata(pdev);
int rc;
if ((rc = ahc_suspend(ahc)))
return rc;
pci_save_state(pdev);
pci_disable_device(pdev);
if (mesg.event == PM_EVENT_SUSPEND)
pci_set_power_state(pdev, PCI_D3hot);
return rc;
}
static int
ahc_linux_pci_dev_resume(struct pci_dev *pdev)
{
struct ahc_softc *ahc = pci_get_drvdata(pdev);
int rc;
pci_set_power_state(pdev, PCI_D0);
pci_restore_state(pdev);
if ((rc = pci_enable_device(pdev))) {
dev_printk(KERN_ERR, &pdev->dev,
"failed to enable device after resume (%d)\n", rc);
return rc;
}
pci_set_master(pdev);
ahc_pci_resume(ahc);
return (ahc_resume(ahc));
}
static void static void
ahc_linux_pci_dev_remove(struct pci_dev *pdev) ahc_linux_pci_dev_remove(struct pci_dev *pdev)
{ {

16
drivers/scsi/aic7xxx/aic7xxx_pci.c
View File

@ -633,8 +633,6 @@ static void write_brdctl(struct ahc_softc *ahc, uint8_t value);
static uint8_t read_brdctl(struct ahc_softc *ahc); static uint8_t read_brdctl(struct ahc_softc *ahc);
static void ahc_pci_intr(struct ahc_softc *ahc); static void ahc_pci_intr(struct ahc_softc *ahc);
static int ahc_pci_chip_init(struct ahc_softc *ahc); static int ahc_pci_chip_init(struct ahc_softc *ahc);
static int ahc_pci_suspend(struct ahc_softc *ahc);
static int ahc_pci_resume(struct ahc_softc *ahc);
static int static int
ahc_9005_subdevinfo_valid(uint16_t device, uint16_t vendor, ahc_9005_subdevinfo_valid(uint16_t device, uint16_t vendor,
@ -791,8 +789,6 @@ ahc_pci_config(struct ahc_softc *ahc, struct ahc_pci_identity *entry)
ahc->bus_intr = ahc_pci_intr; ahc->bus_intr = ahc_pci_intr;
ahc->bus_chip_init = ahc_pci_chip_init; ahc->bus_chip_init = ahc_pci_chip_init;
ahc->bus_suspend = ahc_pci_suspend;
ahc->bus_resume = ahc_pci_resume;
/* Remeber how the card was setup in case there is no SEEPROM */ /* Remeber how the card was setup in case there is no SEEPROM */
if ((ahc_inb(ahc, HCNTRL) & POWRDN) == 0) { if ((ahc_inb(ahc, HCNTRL) & POWRDN) == 0) {
@ -2024,18 +2020,9 @@ ahc_pci_chip_init(struct ahc_softc *ahc)
return (ahc_chip_init(ahc)); return (ahc_chip_init(ahc));
} }
static int void
ahc_pci_suspend(struct ahc_softc *ahc)
{
return (ahc_suspend(ahc));
}
static int
ahc_pci_resume(struct ahc_softc *ahc) ahc_pci_resume(struct ahc_softc *ahc)
{ {
pci_set_power_state(ahc->dev_softc, AHC_POWER_STATE_D0);
/* /*
* We assume that the OS has restored our register * We assume that the OS has restored our register
* mappings, etc. Just update the config space registers * mappings, etc. Just update the config space registers
@ -2063,7 +2050,6 @@ ahc_pci_resume(struct ahc_softc *ahc)
&sxfrctl1); &sxfrctl1);
ahc_release_seeprom(&sd); ahc_release_seeprom(&sd);
} }
return (ahc_resume(ahc));
} }
static int static int

3
drivers/scsi/aic7xxx/aicasm/aicasm_macro_scan.l
View File

@ -66,6 +66,7 @@ static char string_buf[MAX_STR_CONST];
static char *string_buf_ptr; static char *string_buf_ptr;
static int parren_count; static int parren_count;
static char buf[255]; static char buf[255];
int mmlineno;
%} %}
WORD [A-Za-z_][-A-Za-z_0-9]* WORD [A-Za-z_][-A-Za-z_0-9]*
@ -76,7 +77,7 @@ MCARG [^(), \t]+
%% %%
\n { \n {
++yylineno; ++mmlineno;
} }
\r ; \r ;
<ARGLIST>{SPACE} ; <ARGLIST>{SPACE} ;

2
drivers/scsi/aic7xxx_old.c
View File

@ -8417,7 +8417,7 @@ aic7xxx_alloc(struct scsi_host_template *sht, struct aic7xxx_host *temp)
p->host = host; p->host = host;
p->scb_data = kzalloc(sizeof(scb_data_type), GFP_ATOMIC); p->scb_data = kzalloc(sizeof(scb_data_type), GFP_ATOMIC);
if (!p->scb_data) if (p->scb_data)
{ {
scbq_init (&p->scb_data->free_scbs); scbq_init (&p->scb_data->free_scbs);
} }

317
drivers/scsi/fcal.c
View File

@ -1,317 +0,0 @@
/* fcal.c: Fibre Channel Arbitrated Loop SCSI host adapter driver.
*
* Copyright (C) 1998,1999 Jakub Jelinek (jj@ultra.linux.cz)
*
*/
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/blkdev.h>
#include <linux/proc_fs.h>
#include <linux/stat.h>
#include <linux/init.h>
#ifdef CONFIG_KMOD
#include <linux/kmod.h>
#endif
#include <asm/irq.h>
#include "scsi.h"
#include <scsi/scsi_host.h>
#include "../fc4/fcp_impl.h"
#include "fcal.h"
#include <linux/module.h>
/* #define FCAL_DEBUG */
#define fcal_printk printk ("FCAL %s: ", fc->name); printk
#ifdef FCAL_DEBUG
#define FCALD(x) fcal_printk x;
#define FCALND(x) printk ("FCAL: "); printk x;
#else
#define FCALD(x)
#define FCALND(x)
#endif
static unsigned char alpa2target[] = {
0x7e, 0x7d, 0x7c, 0xff, 0x7b, 0xff, 0xff, 0xff, 0x7a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x79,
0x78, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x77, 0x76, 0xff, 0xff, 0x75, 0xff, 0x74, 0x73, 0x72,
0xff, 0xff, 0xff, 0x71, 0xff, 0x70, 0x6f, 0x6e, 0xff, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x68, 0xff,
0xff, 0x67, 0x66, 0x65, 0x64, 0x63, 0x62, 0xff, 0xff, 0x61, 0x60, 0xff, 0x5f, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0x5e, 0xff, 0x5d, 0x5c, 0x5b, 0xff, 0x5a, 0x59, 0x58, 0x57, 0x56, 0x55, 0xff,
0xff, 0x54, 0x53, 0x52, 0x51, 0x50, 0x4f, 0xff, 0xff, 0x4e, 0x4d, 0xff, 0x4c, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0x4b, 0xff, 0x4a, 0x49, 0x48, 0xff, 0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0xff,
0xff, 0x41, 0x40, 0x3f, 0x3e, 0x3d, 0x3c, 0xff, 0xff, 0x3b, 0x3a, 0xff, 0x39, 0xff, 0xff, 0xff,
0x38, 0x37, 0x36, 0xff, 0x35, 0xff, 0xff, 0xff, 0x34, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x33,
0x32, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x31, 0x30, 0xff, 0xff, 0x2f, 0xff, 0x2e, 0x2d, 0x2c,
0xff, 0xff, 0xff, 0x2b, 0xff, 0x2a, 0x29, 0x28, 0xff, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0xff,
0xff, 0x21, 0x20, 0x1f, 0x1e, 0x1d, 0x1c, 0xff, 0xff, 0x1b, 0x1a, 0xff, 0x19, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0x18, 0xff, 0x17, 0x16, 0x15, 0xff, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0f, 0xff,
0xff, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0xff, 0xff, 0x08, 0x07, 0xff, 0x06, 0xff, 0xff, 0xff,
0x05, 0x04, 0x03, 0xff, 0x02, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00
};
static unsigned char target2alpa[] = {
0xef, 0xe8, 0xe4, 0xe2, 0xe1, 0xe0, 0xdc, 0xda, 0xd9, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xce,
0xcd, 0xcc, 0xcb, 0xca, 0xc9, 0xc7, 0xc6, 0xc5, 0xc3, 0xbc, 0xba, 0xb9, 0xb6, 0xb5, 0xb4, 0xb3,
0xb2, 0xb1, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9, 0xa7, 0xa6, 0xa5, 0xa3, 0x9f, 0x9e, 0x9d, 0x9b,
0x98, 0x97, 0x90, 0x8f, 0x88, 0x84, 0x82, 0x81, 0x80, 0x7c, 0x7a, 0x79, 0x76, 0x75, 0x74, 0x73,
0x72, 0x71, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x67, 0x66, 0x65, 0x63, 0x5c, 0x5a, 0x59, 0x56,
0x55, 0x54, 0x53, 0x52, 0x51, 0x4e, 0x4d, 0x4c, 0x4b, 0x4a, 0x49, 0x47, 0x46, 0x45, 0x43, 0x3c,
0x3a, 0x39, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x27, 0x26,
0x25, 0x23, 0x1f, 0x1e, 0x1d, 0x1b, 0x18, 0x17, 0x10, 0x0f, 0x08, 0x04, 0x02, 0x01, 0x00
};
static int fcal_encode_addr(Scsi_Cmnd *SCpnt, u16 *addr, fc_channel *fc, fcp_cmnd *fcmd);
int fcal_slave_configure(struct scsi_device *device)
{
int depth_to_use;
if (device->tagged_supported)
depth_to_use = /* 254 */ 8;
else
depth_to_use = 2;
scsi_adjust_queue_depth(device,
(device->tagged_supported ?
MSG_SIMPLE_TAG : 0),
depth_to_use);
return 0;
}
/* Detect all FC Arbitrated Loops attached to the machine.
fc4 module has done all the work for us... */
int __init fcal_detect(struct scsi_host_template *tpnt)
{
int nfcals = 0;
fc_channel *fc;
int fcalcount;
int i;
tpnt->proc_name = "fcal";
fcalcount = 0;
for_each_online_fc_channel(fc)
if (fc->posmap)
fcalcount++;
FCALND(("%d channels online\n", fcalcount))
if (!fcalcount) {
#if defined(MODULE) && defined(CONFIG_FC4_SOCAL_MODULE) && defined(CONFIG_KMOD)
request_module("socal");
for_each_online_fc_channel(fc)
if (fc->posmap)
fcalcount++;
if (!fcalcount)
#endif
return 0;
}
for_each_online_fc_channel(fc) {
struct Scsi_Host *host;
long *ages;
struct fcal *fcal;
if (!fc->posmap) continue;
/* Strange, this is already registered to some other SCSI host, then it cannot be fcal */
if (fc->scsi_name[0]) continue;
memcpy (fc->scsi_name, "FCAL", 4);
fc->can_queue = FCAL_CAN_QUEUE;
fc->rsp_size = 64;
fc->encode_addr = fcal_encode_addr;
ages = kmalloc (128 * sizeof(long), GFP_KERNEL);
if (!ages) continue;
host = scsi_register (tpnt, sizeof (struct fcal));
if (!host)
{
kfree(ages);
continue;
}
if (!try_module_get(fc->module)) {
kfree(ages);
scsi_unregister(host);
continue;
}
nfcals++;
fcal = (struct fcal *)host->hostdata;
fc->fcp_register(fc, TYPE_SCSI_FCP, 0);
for (i = 0; i < fc->posmap->len; i++) {
int status, target, alpa;
alpa = fc->posmap->list[i];
FCALD(("Sending PLOGI to %02x\n", alpa))
target = alpa2target[alpa];
status = fc_do_plogi(fc, alpa, fcal->node_wwn + target,
fcal->nport_wwn + target);
FCALD(("PLOGI returned with status %d\n", status))
if (status != FC_STATUS_OK)
continue;
FCALD(("Sending PRLI to %02x\n", alpa))
status = fc_do_prli(fc, alpa);
FCALD(("PRLI returned with status %d\n", status))
if (status == FC_STATUS_OK)
fcal->map[target] = 1;
}
host->max_id = 127;
host->irq = fc->irq;
#ifdef __sparc_v9__
host->unchecked_isa_dma = 1;
#endif
fc->channels = 1;
fc->targets = 127;
fc->ages = ages;
memset (ages, 0, 128 * sizeof(long));
fcal->fc = fc;
FCALD(("Found FCAL\n"))
}
if (nfcals)
#ifdef __sparc__
printk ("FCAL: Total of %d Sun Enterprise Network Array (A5000 or EX500) channels found\n", nfcals);
#else
printk ("FCAL: Total of %d Fibre Channel Arbitrated Loops found\n", nfcals);
#endif
return nfcals;
}
int fcal_release(struct Scsi_Host *host)
{
struct fcal *fcal = (struct fcal *)host->hostdata;
fc_channel *fc = fcal->fc;
module_put(fc->module);
fc->fcp_register(fc, TYPE_SCSI_FCP, 1);
FCALND((" releasing fcal.\n"));
kfree (fc->ages);
FCALND(("released fcal!\n"));
return 0;
}
#undef SPRINTF
#define SPRINTF(args...) { if (pos < (buffer + length)) pos += sprintf (pos, ## args); }
int fcal_proc_info (struct Scsi_Host *host, char *buffer, char **start, off_t offset, int length, int inout)
{
struct fcal *fcal;
fc_channel *fc;
char *pos = buffer;
int i, j;
if (inout) return length;
fcal = (struct fcal *)host->hostdata;
fc = fcal->fc;
#ifdef __sparc__
SPRINTF ("Sun Enterprise Network Array (A5000 or E?500) on %s PROM node %x\n", fc->name, fc->dev->prom_node);
#else
SPRINTF ("Fibre Channel Arbitrated Loop on %s\n", fc->name);
#endif
SPRINTF ("Initiator AL-PA: %02x\n", fc->sid);
SPRINTF ("\nAttached devices:\n");
for (i = 0; i < fc->posmap->len; i++) {
unsigned char alpa = fc->posmap->list[i];
unsigned char target;
u32 *u1, *u2;
target = alpa2target[alpa];
u1 = (u32 *)&fcal->nport_wwn[target];
u2 = (u32 *)&fcal->node_wwn[target];
if (!u1[0] && !u1[1]) {
SPRINTF (" [AL-PA: %02x] Not responded to PLOGI\n", alpa);
} else if (!fcal->map[target]) {
SPRINTF (" [AL-PA: %02x, Port WWN: %08x%08x, Node WWN: %08x%08x] Not responded to PRLI\n",
alpa, u1[0], u1[1], u2[0], u2[1]);
} else {
struct scsi_device *scd;
shost_for_each_device(scd, host)
if (scd->id == target) {
SPRINTF (" [AL-PA: %02x, Id: %02d, Port WWN: %08x%08x, Node WWN: %08x%08x] ",
alpa, target, u1[0], u1[1], u2[0], u2[1]);
SPRINTF ("%s ", scsi_device_type(scd->type));
for (j = 0; (j < 8) && (scd->vendor[j] >= 0x20); j++)
SPRINTF ("%c", scd->vendor[j]);
SPRINTF (" ");
for (j = 0; (j < 16) && (scd->model[j] >= 0x20); j++)
SPRINTF ("%c", scd->model[j]);
SPRINTF ("\n");
}
}
}
SPRINTF ("\n");
*start = buffer + offset;
if ((pos - buffer) < offset)
return 0;
else if (pos - buffer - offset < length)
return pos - buffer - offset;
else
return length;
}
/*
For FC-AL, we use a simple addressing: we have just one channel 0,
and all AL-PAs are mapped to targets 0..0x7e
*/
static int fcal_encode_addr(Scsi_Cmnd *SCpnt, u16 *addr, fc_channel *fc, fcp_cmnd *fcmd)
{
struct fcal *f;
/* We don't support LUNs yet - I'm not sure if LUN should be in SCSI fcp_cdb, or in second byte of addr[0] */
if (SCpnt->cmnd[1] & 0xe0) return -EINVAL;
/* FC-PLDA tells us... */
memset(addr, 0, 8);
f = (struct fcal *)SCpnt->device->host->hostdata;
if (!f->map[SCpnt->device->id])
return -EINVAL;
/* Now, determine DID: It will be Native Identifier, so we zero upper
2 bytes of the 3 byte DID, lowest byte will be AL-PA */
fcmd->did = target2alpa[SCpnt->device->id];
FCALD(("trying DID %06x\n", fcmd->did))
return 0;
}
static struct scsi_host_template driver_template = {
.name = "Fibre Channel Arbitrated Loop",
.detect = fcal_detect,
.release = fcal_release,
.proc_info = fcal_proc_info,
.queuecommand = fcp_scsi_queuecommand,
.slave_configure = fcal_slave_configure,
.can_queue = FCAL_CAN_QUEUE,
.this_id = -1,
.sg_tablesize = 1,
.cmd_per_lun = 1,
.use_clustering = ENABLE_CLUSTERING,
.eh_abort_handler = fcp_scsi_abort,
.eh_device_reset_handler = fcp_scsi_dev_reset,
.eh_host_reset_handler = fcp_scsi_host_reset,
};
#include "scsi_module.c"
MODULE_LICENSE("GPL");

27
drivers/scsi/fcal.h
View File

@ -1,27 +0,0 @@
/* fcal.h: Generic Fibre Channel Arbitrated Loop SCSI host adapter driver definitions.
*
* Copyright (C) 1998,1999 Jakub Jelinek (jj@ultra.linux.cz)
*/
#ifndef _FCAL_H
#define _FCAL_H
#include "../fc4/fcp_impl.h"
struct fcal {
/* fc must be first */
fc_channel *fc;
unsigned char map[128];
fc_wwn nport_wwn[128];
fc_wwn node_wwn[128];
};
/* Arbitrary constant. Cannot be too large, as fc4 layer has limitations
for a particular channel */
#define FCAL_CAN_QUEUE 512
int fcal_detect(struct scsi_host_template *);
int fcal_release(struct Scsi_Host *);
int fcal_slave_configure(struct scsi_device *);
#endif /* !(_FCAL_H) */

6
drivers/scsi/gdth.c
View File

@ -4734,7 +4734,7 @@ static struct scsi_host_template gdth_template = {
}; };
#ifdef CONFIG_ISA #ifdef CONFIG_ISA
static int gdth_isa_probe_one(ulong32 isa_bios) static int __init gdth_isa_probe_one(ulong32 isa_bios)
{ {
struct Scsi_Host *shp; struct Scsi_Host *shp;
gdth_ha_str *ha; gdth_ha_str *ha;
@ -4862,7 +4862,7 @@ static int gdth_isa_probe_one(ulong32 isa_bios)
#endif /* CONFIG_ISA */ #endif /* CONFIG_ISA */
#ifdef CONFIG_EISA #ifdef CONFIG_EISA
static int gdth_eisa_probe_one(ushort eisa_slot) static int __init gdth_eisa_probe_one(ushort eisa_slot)
{ {
struct Scsi_Host *shp; struct Scsi_Host *shp;
gdth_ha_str *ha; gdth_ha_str *ha;
@ -4991,7 +4991,7 @@ static int gdth_eisa_probe_one(ushort eisa_slot)
#endif /* CONFIG_EISA */ #endif /* CONFIG_EISA */
#ifdef CONFIG_PCI #ifdef CONFIG_PCI
static int gdth_pci_probe_one(gdth_pci_str *pcistr, int ctr) static int __init gdth_pci_probe_one(gdth_pci_str *pcistr, int ctr)
{ {
struct Scsi_Host *shp; struct Scsi_Host *shp;
gdth_ha_str *ha; gdth_ha_str *ha;

6
drivers/scsi/hosts.c
View File

@ -345,6 +345,12 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
shost->active_mode = sht->supported_mode; shost->active_mode = sht->supported_mode;
shost->use_sg_chaining = sht->use_sg_chaining; shost->use_sg_chaining = sht->use_sg_chaining;
if (sht->supported_mode == MODE_UNKNOWN)
/* means we didn't set it ... default to INITIATOR */
shost->active_mode = MODE_INITIATOR;
else
shost->active_mode = sht->supported_mode;
if (sht->max_host_blocked) if (sht->max_host_blocked)
shost->max_host_blocked = sht->max_host_blocked; shost->max_host_blocked = sht->max_host_blocked;
else else

5
drivers/scsi/hptiop.c
View File

@ -375,8 +375,9 @@ static void hptiop_host_request_callback(struct hptiop_hba *hba, u32 _tag)
scp->result = SAM_STAT_CHECK_CONDITION; scp->result = SAM_STAT_CHECK_CONDITION;
memset(&scp->sense_buffer, memset(&scp->sense_buffer,
0, sizeof(scp->sense_buffer)); 0, sizeof(scp->sense_buffer));
memcpy(&scp->sense_buffer, memcpy(&scp->sense_buffer, &req->sg_list,
&req->sg_list, le32_to_cpu(req->dataxfer_length)); min(sizeof(scp->sense_buffer),
le32_to_cpu(req->dataxfer_length)));
break; break;
default: default:

6
drivers/scsi/initio.c
View File

@ -665,7 +665,7 @@ static void initio_init(struct initio_host * host, u8 *bios_addr)
host->max_tags[i] = 0xFF; host->max_tags[i] = 0xFF;
} /* for */ } /* for */
printk("i91u: PCI Base=0x%04X, IRQ=%d, BIOS=0x%04X0, SCSI ID=%d\n", printk("i91u: PCI Base=0x%04X, IRQ=%d, BIOS=0x%04X0, SCSI ID=%d\n",
host->addr, host->irq, host->addr, host->pci_dev->irq,
host->bios_addr, host->scsi_id); host->bios_addr, host->scsi_id);
/* Reset SCSI Bus */ /* Reset SCSI Bus */
if (host->config & HCC_SCSI_RESET) { if (host->config & HCC_SCSI_RESET) {
@ -2891,6 +2891,8 @@ static int initio_probe_one(struct pci_dev *pdev,
goto out_release_region; goto out_release_region;
} }
host->pci_dev = pdev;
host->num_scbs = num_scb; host->num_scbs = num_scb;
host->scb = scb; host->scb = scb;
host->next_pending = scb; host->next_pending = scb;
@ -2905,6 +2907,7 @@ static int initio_probe_one(struct pci_dev *pdev,
host->scb_end = tmp; host->scb_end = tmp;
host->first_avail = scb; host->first_avail = scb;
host->last_avail = prev; host->last_avail = prev;
spin_lock_init(&host->avail_lock);
initio_init(host, phys_to_virt(bios_seg << 4)); initio_init(host, phys_to_virt(bios_seg << 4));
@ -2928,7 +2931,6 @@ static int initio_probe_one(struct pci_dev *pdev,
} }
pci_set_drvdata(pdev, shost); pci_set_drvdata(pdev, shost);
host->pci_dev = pdev;
error = scsi_add_host(shost, &pdev->dev); error = scsi_add_host(shost, &pdev->dev);
if (error) if (error)

2
drivers/scsi/lpfc/lpfc_debugfs.c
View File

@ -901,7 +901,7 @@ lpfc_debugfs_initialize(struct lpfc_vport *vport)
} }
} }
vport->disc_trc = kmzlloc( vport->disc_trc = kzalloc(
(sizeof(struct lpfc_debugfs_trc) * lpfc_debugfs_max_disc_trc), (sizeof(struct lpfc_debugfs_trc) * lpfc_debugfs_max_disc_trc),
GFP_KERNEL); GFP_KERNEL);

349
drivers/scsi/pluto.c
View File

@ -1,349 +0,0 @@
/* pluto.c: SparcSTORAGE Array SCSI host adapter driver.
*
* Copyright (C) 1997,1998,1999 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
*
*/
#include <linux/completion.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/blkdev.h>
#include <linux/proc_fs.h>
#include <linux/stat.h>
#include <linux/init.h>
#ifdef CONFIG_KMOD
#include <linux/kmod.h>
#endif
#include <asm/irq.h>
#include "scsi.h"
#include <scsi/scsi_host.h>
#include "../fc4/fcp_impl.h"
#include "pluto.h"
#include <linux/module.h>
#define RQ_SCSI_BUSY 0xffff
#define RQ_SCSI_DONE 0xfffe
/* #define PLUTO_DEBUG */
#define pluto_printk printk ("PLUTO %s: ", fc->name); printk
#ifdef PLUTO_DEBUG
#define PLD(x) pluto_printk x;
#define PLND(x) printk ("PLUTO: "); printk x;
#else
#define PLD(x)
#define PLND(x)
#endif
static struct ctrl_inquiry {
struct Scsi_Host host;
struct pluto pluto;
Scsi_Cmnd cmd;
char inquiry[256];
fc_channel *fc;
} *fcs __initdata;
static int fcscount __initdata = 0;
static atomic_t fcss __initdata = ATOMIC_INIT(0);
static DECLARE_COMPLETION(fc_detect_complete);
static int pluto_encode_addr(Scsi_Cmnd *SCpnt, u16 *addr, fc_channel *fc, fcp_cmnd *fcmd);
static void __init pluto_detect_done(Scsi_Cmnd *SCpnt)
{
/* Do nothing */
}
static void __init pluto_detect_scsi_done(Scsi_Cmnd *SCpnt)
{
PLND(("Detect done %08lx\n", (long)SCpnt))
if (atomic_dec_and_test (&fcss))
complete(&fc_detect_complete);
}
int pluto_slave_configure(struct scsi_device *device)
{
int depth_to_use;
if (device->tagged_supported)
depth_to_use = /* 254 */ 8;
else
depth_to_use = 2;
scsi_adjust_queue_depth(device,
(device->tagged_supported ?
MSG_SIMPLE_TAG : 0),
depth_to_use);
return 0;
}
/* Detect all SSAs attached to the machine.
To be fast, do it on all online FC channels at the same time. */
int __init pluto_detect(struct scsi_host_template *tpnt)
{
int i, retry, nplutos;
fc_channel *fc;
struct scsi_device dev;
tpnt->proc_name = "pluto";
fcscount = 0;
for_each_online_fc_channel(fc) {
if (!fc->posmap)
fcscount++;
}
PLND(("%d channels online\n", fcscount))
if (!fcscount) {
#if defined(MODULE) && defined(CONFIG_FC4_SOC_MODULE) && defined(CONFIG_KMOD)
request_module("soc");
for_each_online_fc_channel(fc) {
if (!fc->posmap)
fcscount++;
}
if (!fcscount)
#endif
return 0;
}
fcs = kcalloc(fcscount, sizeof (struct ctrl_inquiry), GFP_DMA);
if (!fcs) {
printk ("PLUTO: Not enough memory to probe\n");
return 0;
}
memset (&dev, 0, sizeof(dev));
atomic_set (&fcss, fcscount);
i = 0;
for_each_online_fc_channel(fc) {
Scsi_Cmnd *SCpnt;
struct Scsi_Host *host;
struct pluto *pluto;
if (i == fcscount) break;
if (fc->posmap) continue;
PLD(("trying to find SSA\n"))
/* If this is already registered to some other SCSI host, then it cannot be pluto */
if (fc->scsi_name[0]) continue;
memcpy (fc->scsi_name, "SSA", 4);
fcs[i].fc = fc;
fc->can_queue = PLUTO_CAN_QUEUE;
fc->rsp_size = 64;
fc->encode_addr = pluto_encode_addr;
fc->fcp_register(fc, TYPE_SCSI_FCP, 0);
SCpnt = &(fcs[i].cmd);
host = &(fcs[i].host);
pluto = (struct pluto *)host->hostdata;
pluto->fc = fc;
SCpnt->cmnd[0] = INQUIRY;
SCpnt->cmnd[4] = 255;
/* FC layer requires this, so that SCpnt->device->tagged_supported is initially 0 */
SCpnt->device = &dev;
dev.host = host;
SCpnt->cmd_len = COMMAND_SIZE(INQUIRY);
SCpnt->request->cmd_flags &= ~REQ_STARTED;
SCpnt->request_bufflen = 256;
SCpnt->request_buffer = fcs[i].inquiry;
PLD(("set up %d %08lx\n", i, (long)SCpnt))
i++;
}
for (retry = 0; retry < 5; retry++) {
for (i = 0; i < fcscount; i++) {
if (!fcs[i].fc) break;
if (!(fcs[i].cmd.request->cmd_flags & REQ_STARTED)) {
fcs[i].cmd.request->cmd_flags |= REQ_STARTED;
disable_irq(fcs[i].fc->irq);
PLND(("queuecommand %d %d\n", retry, i))
fcp_scsi_queuecommand (&(fcs[i].cmd),
pluto_detect_scsi_done);
enable_irq(fcs[i].fc->irq);
}
}
wait_for_completion_timeout(&fc_detect_complete, 10 * HZ);
PLND(("Woken up\n"))
if (!atomic_read(&fcss))
break; /* All fc channels have answered us */
}
PLND(("Finished search\n"))
for (i = 0, nplutos = 0; i < fcscount; i++) {
Scsi_Cmnd *SCpnt;
if (!(fc = fcs[i].fc)) break;
SCpnt = &(fcs[i].cmd);
/* Let FC mid-level free allocated resources */
pluto_detect_scsi_done(SCpnt);
if (!SCpnt->result) {
struct pluto_inquiry *inq;
struct pluto *pluto;
struct Scsi_Host *host;
inq = (struct pluto_inquiry *)fcs[i].inquiry;
if ((inq->dtype & 0x1f) == TYPE_PROCESSOR &&
!strncmp (inq->vendor_id, "SUN", 3) &&
!strncmp (inq->product_id, "SSA", 3)) {
char *p;
long *ages;
ages = kcalloc((inq->channels + 1) * inq->targets, sizeof(long), GFP_KERNEL);
if (!ages) continue;
host = scsi_register (tpnt, sizeof (struct pluto));
if(!host)
{
kfree(ages);
continue;
}
if (!try_module_get(fc->module)) {
kfree(ages);
scsi_unregister(host);
continue;
}
nplutos++;
pluto = (struct pluto *)host->hostdata;
host->max_id = inq->targets;
host->max_channel = inq->channels;
host->irq = fc->irq;
fc->channels = inq->channels + 1;
fc->targets = inq->targets;
fc->ages = ages;
pluto->fc = fc;
memcpy (pluto->rev_str, inq->revision, 4);
pluto->rev_str[4] = 0;
p = strchr (pluto->rev_str, ' ');
if (p) *p = 0;
memcpy (pluto->fw_rev_str, inq->fw_revision, 4);
pluto->fw_rev_str[4] = 0;
p = strchr (pluto->fw_rev_str, ' ');
if (p) *p = 0;
memcpy (pluto->serial_str, inq->serial, 12);
pluto->serial_str[12] = 0;
p = strchr (pluto->serial_str, ' ');
if (p) *p = 0;
PLD(("Found SSA rev %s fw rev %s serial %s %dx%d\n", pluto->rev_str, pluto->fw_rev_str, pluto->serial_str, host->max_channel, host->max_id))
} else
fc->fcp_register(fc, TYPE_SCSI_FCP, 1);
} else
fc->fcp_register(fc, TYPE_SCSI_FCP, 1);
}
kfree(fcs);
if (nplutos)
printk ("PLUTO: Total of %d SparcSTORAGE Arrays found\n", nplutos);
return nplutos;
}
int pluto_release(struct Scsi_Host *host)
{
struct pluto *pluto = (struct pluto *)host->hostdata;
fc_channel *fc = pluto->fc;
module_put(fc->module);
fc->fcp_register(fc, TYPE_SCSI_FCP, 1);
PLND((" releasing pluto.\n"));
kfree (fc->ages);
PLND(("released pluto!\n"));
return 0;
}
const char *pluto_info(struct Scsi_Host *host)
{
static char buf[128], *p;
struct pluto *pluto = (struct pluto *) host->hostdata;
sprintf(buf, "SUN SparcSTORAGE Array %s fw %s serial %s %dx%d on %s",
pluto->rev_str, pluto->fw_rev_str, pluto->serial_str,
host->max_channel, host->max_id, pluto->fc->name);
#ifdef __sparc__
p = strchr(buf, 0);
sprintf(p, " PROM node %x", pluto->fc->dev->prom_node);
#endif
return buf;
}
/* SSA uses this FC4S addressing:
switch (addr[0])
{
case 0: CONTROLLER - All of addr[1]..addr[3] has to be 0
case 1: SINGLE DISK - addr[1] channel, addr[2] id, addr[3] 0
case 2: DISK GROUP - ???
}
So that SCSI mid-layer can access to these, we reserve
channel 0 id 0 lun 0 for CONTROLLER
and channels 1 .. max_channel are normal single disks.
*/
static int pluto_encode_addr(Scsi_Cmnd *SCpnt, u16 *addr, fc_channel *fc, fcp_cmnd *fcmd)
{
PLND(("encode addr %d %d %d\n", SCpnt->device->channel, SCpnt->device->id, SCpnt->cmnd[1] & 0xe0))
/* We don't support LUNs - neither does SSA :) */
if (SCpnt->cmnd[1] & 0xe0)
return -EINVAL;
if (!SCpnt->device->channel) {
if (SCpnt->device->id)
return -EINVAL;
memset (addr, 0, 4 * sizeof(u16));
} else {
addr[0] = 1;
addr[1] = SCpnt->device->channel - 1;
addr[2] = SCpnt->device->id;
addr[3] = 0;
}
/* We're Point-to-Point, so target it to the default DID */
fcmd->did = fc->did;
PLND(("trying %04x%04x%04x%04x\n", addr[0], addr[1], addr[2], addr[3]))
return 0;
}
static struct scsi_host_template driver_template = {
.name = "Sparc Storage Array 100/200",
.detect = pluto_detect,
.release = pluto_release,
.info = pluto_info,
.queuecommand = fcp_scsi_queuecommand,
.slave_configure = pluto_slave_configure,
.can_queue = PLUTO_CAN_QUEUE,
.this_id = -1,
.sg_tablesize = 1,
.cmd_per_lun = 1,
.use_clustering = ENABLE_CLUSTERING,
.eh_abort_handler = fcp_scsi_abort,
.eh_device_reset_handler = fcp_scsi_dev_reset,
.eh_host_reset_handler = fcp_scsi_host_reset,
};
#include "scsi_module.c"
MODULE_LICENSE("GPL");

47
drivers/scsi/pluto.h
View File

@ -1,47 +0,0 @@
/* pluto.h: SparcSTORAGE Array SCSI host adapter driver definitions.
*
* Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
*/
#ifndef _PLUTO_H
#define _PLUTO_H
#include "../fc4/fcp_impl.h"
struct pluto {
/* This must be first */
fc_channel *fc;
char rev_str[5];
char fw_rev_str[5];
char serial_str[13];
};
struct pluto_inquiry {
u8 dtype;
u8 removable:1, qualifier:7;
u8 iso:2, ecma:3, ansi:3;
u8 aenc:1, trmiop:1, :2, rdf:4;
u8 len;
u8 xxx1;
u8 xxx2;
u8 reladdr:1, wbus32:1, wbus16:1, sync:1, linked:1, :1, cmdque:1, softreset:1;
u8 vendor_id[8];
u8 product_id[16];
u8 revision[4];
u8 fw_revision[4];
u8 serial[12];
u8 xxx3[2];
u8 channels;
u8 targets;
};
/* This is the max number of outstanding SCSI commands per pluto */
#define PLUTO_CAN_QUEUE 254
int pluto_detect(struct scsi_host_template *);
int pluto_release(struct Scsi_Host *);
const char * pluto_info(struct Scsi_Host *);
int pluto_slave_configure(struct scsi_device *);
#endif /* !(_PLUTO_H) */

4
drivers/scsi/qla1280.c
View File

@ -4310,7 +4310,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
printk(KERN_WARNING "scsi(%li): Unable to set a " printk(KERN_WARNING "scsi(%li): Unable to set a "
"suitable DMA mask - aborting\n", ha->host_no); "suitable DMA mask - aborting\n", ha->host_no);
error = -ENODEV; error = -ENODEV;
goto error_free_irq; goto error_put_host;
} }
} else } else
dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n", dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
@ -4320,7 +4320,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
printk(KERN_WARNING "scsi(%li): Unable to set a " printk(KERN_WARNING "scsi(%li): Unable to set a "
"suitable DMA mask - aborting\n", ha->host_no); "suitable DMA mask - aborting\n", ha->host_no);
error = -ENODEV; error = -ENODEV;
goto error_free_irq; goto error_put_host;
} }
#endif #endif

4
drivers/scsi/qla1280.h
View File

@ -91,8 +91,8 @@
#define INVALID_HANDLE (MAX_OUTSTANDING_COMMANDS + 2) #define INVALID_HANDLE (MAX_OUTSTANDING_COMMANDS + 2)
/* ISP request and response entry counts (37-65535) */ /* ISP request and response entry counts (37-65535) */
#define REQUEST_ENTRY_CNT 256 /* Number of request entries. */ #define REQUEST_ENTRY_CNT 255 /* Number of request entries. */
#define RESPONSE_ENTRY_CNT 16 /* Number of response entries. */ #define RESPONSE_ENTRY_CNT 63 /* Number of response entries. */
/* /*
* SCSI Request Block structure (sp) that is placed * SCSI Request Block structure (sp) that is placed

9
drivers/scsi/qla2xxx/qla_attr.c
View File

@ -114,7 +114,6 @@ qla2x00_sysfs_write_nvram(struct kobject *kobj,
{ {
struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj, struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
struct device, kobj))); struct device, kobj)));
unsigned long flags;
uint16_t cnt; uint16_t cnt;
if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size) if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size)
@ -144,11 +143,9 @@ qla2x00_sysfs_write_nvram(struct kobject *kobj,
} }
/* Write NVRAM. */ /* Write NVRAM. */
spin_lock_irqsave(&ha->hardware_lock, flags);
ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->nvram_base, count); ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->nvram_base, count);
ha->isp_ops->read_nvram(ha, (uint8_t *)ha->nvram, ha->nvram_base, ha->isp_ops->read_nvram(ha, (uint8_t *)ha->nvram, ha->nvram_base,
count); count);
spin_unlock_irqrestore(&ha->hardware_lock, flags);
set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
@ -397,16 +394,13 @@ qla2x00_sysfs_write_vpd(struct kobject *kobj,
{ {
struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj, struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
struct device, kobj))); struct device, kobj)));
unsigned long flags;
if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size) if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size)
return 0; return 0;
/* Write NVRAM. */ /* Write NVRAM. */
spin_lock_irqsave(&ha->hardware_lock, flags);
ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->vpd_base, count); ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->vpd_base, count);
ha->isp_ops->read_nvram(ha, (uint8_t *)ha->vpd, ha->vpd_base, count); ha->isp_ops->read_nvram(ha, (uint8_t *)ha->vpd, ha->vpd_base, count);
spin_unlock_irqrestore(&ha->hardware_lock, flags);
return count; return count;
} }
@ -544,6 +538,9 @@ qla2x00_serial_num_show(struct class_device *cdev, char *buf)
scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
uint32_t sn; uint32_t sn;
if (IS_FWI2_CAPABLE(ha))
return snprintf(buf, PAGE_SIZE, "\n");
sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1; sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1;
return snprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000, return snprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000,
sn % 100000); sn % 100000);

1
drivers/scsi/qla2xxx/qla_def.h
View File

@ -2271,6 +2271,7 @@ typedef struct scsi_qla_host {
spinlock_t hardware_lock ____cacheline_aligned; spinlock_t hardware_lock ____cacheline_aligned;
int bars;
device_reg_t __iomem *iobase; /* Base I/O address */ device_reg_t __iomem *iobase; /* Base I/O address */
unsigned long pio_address; unsigned long pio_address;
unsigned long pio_length; unsigned long pio_length;

7
drivers/scsi/qla2xxx/qla_devtbl.h
View File

@ -1,4 +1,4 @@
#define QLA_MODEL_NAMES 0x57 #define QLA_MODEL_NAMES 0x5C
/* /*
* Adapter model names and descriptions. * Adapter model names and descriptions.
@ -91,4 +91,9 @@ static char *qla2x00_model_name[QLA_MODEL_NAMES*2] = {
" ", " ", /* 0x154 */ " ", " ", /* 0x154 */
"QLE220", "PCI-Express to 4Gb FC, Single Channel", /* 0x155 */ "QLE220", "PCI-Express to 4Gb FC, Single Channel", /* 0x155 */
"QLE220", "PCI-Express to 4Gb FC, Single Channel", /* 0x156 */ "QLE220", "PCI-Express to 4Gb FC, Single Channel", /* 0x156 */
" ", " ", /* 0x157 */
" ", " ", /* 0x158 */
" ", " ", /* 0x159 */
" ", " ", /* 0x15a */
"QME2472", "Dell BS PCI-Express to 4Gb FC, Dual Channel", /* 0x15b */
}; };

2
drivers/scsi/qla2xxx/qla_iocb.c
View File

@ -525,7 +525,7 @@ qla2x00_req_pkt(scsi_qla_host_t *ha)
/* Check for pending interrupts. */ /* Check for pending interrupts. */
/* During init we issue marker directly */ /* During init we issue marker directly */
if (!ha->marker_needed) if (!ha->marker_needed && !ha->flags.init_done)
qla2x00_poll(ha); qla2x00_poll(ha);
spin_lock_irq(&ha->hardware_lock); spin_lock_irq(&ha->hardware_lock);

8
drivers/scsi/qla2xxx/qla_isr.c
View File

@ -1012,8 +1012,14 @@ qla2x00_status_entry(scsi_qla_host_t *ha, void *pkt)
case CS_DATA_UNDERRUN: case CS_DATA_UNDERRUN:
resid = resid_len; resid = resid_len;
/* Use F/W calculated residual length. */ /* Use F/W calculated residual length. */
if (IS_FWI2_CAPABLE(ha)) if (IS_FWI2_CAPABLE(ha)) {
if (scsi_status & SS_RESIDUAL_UNDER &&
resid != fw_resid_len) {
scsi_status &= ~SS_RESIDUAL_UNDER;
lscsi_status = 0;
}
resid = fw_resid_len; resid = fw_resid_len;
}
if (scsi_status & SS_RESIDUAL_UNDER) { if (scsi_status & SS_RESIDUAL_UNDER) {
scsi_set_resid(cp, resid); scsi_set_resid(cp, resid);

2
drivers/scsi/qla2xxx/qla_mbx.c
View File

@ -252,7 +252,7 @@ qla2x00_mailbox_command(scsi_qla_host_t *pvha, mbx_cmd_t *mcp)
/* Clean up */ /* Clean up */
ha->mcp = NULL; ha->mcp = NULL;
if (!abort_active) { if (abort_active || !io_lock_on) {
DEBUG11(printk("%s(%ld): checking for additional resp " DEBUG11(printk("%s(%ld): checking for additional resp "
"interrupt.\n", __func__, ha->host_no)); "interrupt.\n", __func__, ha->host_no));

50
drivers/scsi/qla2xxx/qla_os.c
View File

@ -1482,6 +1482,17 @@ qla2x00_iospace_config(scsi_qla_host_t *ha)
unsigned long pio, pio_len, pio_flags; unsigned long pio, pio_len, pio_flags;
unsigned long mmio, mmio_len, mmio_flags; unsigned long mmio, mmio_len, mmio_flags;
if (pci_request_selected_regions(ha->pdev, ha->bars,
QLA2XXX_DRIVER_NAME)) {
qla_printk(KERN_WARNING, ha,
"Failed to reserve PIO/MMIO regions (%s)\n",
pci_name(ha->pdev));
goto iospace_error_exit;
}
if (!(ha->bars & 1))
goto skip_pio;
/* We only need PIO for Flash operations on ISP2312 v2 chips. */ /* We only need PIO for Flash operations on ISP2312 v2 chips. */
pio = pci_resource_start(ha->pdev, 0); pio = pci_resource_start(ha->pdev, 0);
pio_len = pci_resource_len(ha->pdev, 0); pio_len = pci_resource_len(ha->pdev, 0);
@ -1499,7 +1510,10 @@ qla2x00_iospace_config(scsi_qla_host_t *ha)
pci_name(ha->pdev)); pci_name(ha->pdev));
pio = 0; pio = 0;
} }
ha->pio_address = pio;
ha->pio_length = pio_len;
skip_pio:
/* Use MMIO operations for all accesses. */ /* Use MMIO operations for all accesses. */
mmio = pci_resource_start(ha->pdev, 1); mmio = pci_resource_start(ha->pdev, 1);
mmio_len = pci_resource_len(ha->pdev, 1); mmio_len = pci_resource_len(ha->pdev, 1);
@ -1518,16 +1532,6 @@ qla2x00_iospace_config(scsi_qla_host_t *ha)
goto iospace_error_exit; goto iospace_error_exit;
} }
if (pci_request_regions(ha->pdev, QLA2XXX_DRIVER_NAME)) {
qla_printk(KERN_WARNING, ha,
"Failed to reserve PIO/MMIO regions (%s)\n",
pci_name(ha->pdev));
goto iospace_error_exit;
}
ha->pio_address = pio;
ha->pio_length = pio_len;
ha->iobase = ioremap(mmio, MIN_IOBASE_LEN); ha->iobase = ioremap(mmio, MIN_IOBASE_LEN);
if (!ha->iobase) { if (!ha->iobase) {
qla_printk(KERN_ERR, ha, qla_printk(KERN_ERR, ha,
@ -1579,21 +1583,26 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
char pci_info[30]; char pci_info[30];
char fw_str[30]; char fw_str[30];
struct scsi_host_template *sht; struct scsi_host_template *sht;
int bars;
if (pci_enable_device(pdev)) bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
sht = &qla2x00_driver_template;
if (pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2422 ||
pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2432 ||
pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5422 ||
pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5432 ||
pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2532) {
bars = pci_select_bars(pdev, IORESOURCE_MEM);
sht = &qla24xx_driver_template;
}
if (pci_enable_device_bars(pdev, bars))
goto probe_out; goto probe_out;
if (pci_find_aer_capability(pdev)) if (pci_find_aer_capability(pdev))
if (pci_enable_pcie_error_reporting(pdev)) if (pci_enable_pcie_error_reporting(pdev))
goto probe_out; goto probe_out;
sht = &qla2x00_driver_template;
if (pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2422 ||
pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2432 ||
pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5422 ||
pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5432 ||
pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2532)
sht = &qla24xx_driver_template;
host = scsi_host_alloc(sht, sizeof(scsi_qla_host_t)); host = scsi_host_alloc(sht, sizeof(scsi_qla_host_t));
if (host == NULL) { if (host == NULL) {
printk(KERN_WARNING printk(KERN_WARNING
@ -1610,6 +1619,7 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
ha->host_no = host->host_no; ha->host_no = host->host_no;
sprintf(ha->host_str, "%s_%ld", QLA2XXX_DRIVER_NAME, ha->host_no); sprintf(ha->host_str, "%s_%ld", QLA2XXX_DRIVER_NAME, ha->host_no);
ha->parent = NULL; ha->parent = NULL;
ha->bars = bars;
/* Set ISP-type information. */ /* Set ISP-type information. */
qla2x00_set_isp_flags(ha); qla2x00_set_isp_flags(ha);
@ -1880,7 +1890,7 @@ qla2x00_free_device(scsi_qla_host_t *ha)
/* release io space registers */ /* release io space registers */
if (ha->iobase) if (ha->iobase)
iounmap(ha->iobase); iounmap(ha->iobase);
pci_release_regions(ha->pdev); pci_release_selected_regions(ha->pdev, ha->bars);
} }
static inline void static inline void
@ -2890,7 +2900,7 @@ qla2xxx_pci_slot_reset(struct pci_dev *pdev)
pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT; pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT;
scsi_qla_host_t *ha = pci_get_drvdata(pdev); scsi_qla_host_t *ha = pci_get_drvdata(pdev);
if (pci_enable_device(pdev)) { if (pci_enable_device_bars(pdev, ha->bars)) {
qla_printk(KERN_WARNING, ha, qla_printk(KERN_WARNING, ha,
"Can't re-enable PCI device after reset.\n"); "Can't re-enable PCI device after reset.\n");

30
drivers/scsi/qla2xxx/qla_sup.c
View File

@ -7,6 +7,7 @@
#include "qla_def.h" #include "qla_def.h"
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/vmalloc.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
static uint16_t qla2x00_nvram_request(scsi_qla_host_t *, uint32_t); static uint16_t qla2x00_nvram_request(scsi_qla_host_t *, uint32_t);
@ -642,7 +643,7 @@ qla24xx_write_flash_data(scsi_qla_host_t *ha, uint32_t *dwptr, uint32_t faddr,
} }
/* Go with burst-write. */ /* Go with burst-write. */
if (optrom && (liter + OPTROM_BURST_DWORDS) < dwords) { if (optrom && (liter + OPTROM_BURST_DWORDS) <= dwords) {
/* Copy data to DMA'ble buffer. */ /* Copy data to DMA'ble buffer. */
for (miter = 0, s = optrom, d = dwptr; for (miter = 0, s = optrom, d = dwptr;
miter < OPTROM_BURST_DWORDS; miter++, s++, d++) miter < OPTROM_BURST_DWORDS; miter++, s++, d++)
@ -656,7 +657,7 @@ qla24xx_write_flash_data(scsi_qla_host_t *ha, uint32_t *dwptr, uint32_t faddr,
"Unable to burst-write optrom segment " "Unable to burst-write optrom segment "
"(%x/%x/%llx).\n", ret, "(%x/%x/%llx).\n", ret,
flash_data_to_access_addr(faddr), flash_data_to_access_addr(faddr),
optrom_dma); (unsigned long long)optrom_dma);
qla_printk(KERN_WARNING, ha, qla_printk(KERN_WARNING, ha,
"Reverting to slow-write.\n"); "Reverting to slow-write.\n");
@ -745,9 +746,11 @@ qla2x00_write_nvram_data(scsi_qla_host_t *ha, uint8_t *buf, uint32_t naddr,
int ret, stat; int ret, stat;
uint32_t i; uint32_t i;
uint16_t *wptr; uint16_t *wptr;
unsigned long flags;
ret = QLA_SUCCESS; ret = QLA_SUCCESS;
spin_lock_irqsave(&ha->hardware_lock, flags);
qla2x00_lock_nvram_access(ha); qla2x00_lock_nvram_access(ha);
/* Disable NVRAM write-protection. */ /* Disable NVRAM write-protection. */
@ -764,6 +767,7 @@ qla2x00_write_nvram_data(scsi_qla_host_t *ha, uint8_t *buf, uint32_t naddr,
qla2x00_set_nvram_protection(ha, stat); qla2x00_set_nvram_protection(ha, stat);
qla2x00_unlock_nvram_access(ha); qla2x00_unlock_nvram_access(ha);
spin_unlock_irqrestore(&ha->hardware_lock, flags);
return ret; return ret;
} }
@ -776,9 +780,11 @@ qla24xx_write_nvram_data(scsi_qla_host_t *ha, uint8_t *buf, uint32_t naddr,
uint32_t i; uint32_t i;
uint32_t *dwptr; uint32_t *dwptr;
struct device_reg_24xx __iomem *reg = &ha->iobase->isp24; struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
unsigned long flags;
ret = QLA_SUCCESS; ret = QLA_SUCCESS;
spin_lock_irqsave(&ha->hardware_lock, flags);
/* Enable flash write. */ /* Enable flash write. */
WRT_REG_DWORD(&reg->ctrl_status, WRT_REG_DWORD(&reg->ctrl_status,
RD_REG_DWORD(&reg->ctrl_status) | CSRX_FLASH_ENABLE); RD_REG_DWORD(&reg->ctrl_status) | CSRX_FLASH_ENABLE);
@ -812,6 +818,7 @@ qla24xx_write_nvram_data(scsi_qla_host_t *ha, uint8_t *buf, uint32_t naddr,
WRT_REG_DWORD(&reg->ctrl_status, WRT_REG_DWORD(&reg->ctrl_status,
RD_REG_DWORD(&reg->ctrl_status) & ~CSRX_FLASH_ENABLE); RD_REG_DWORD(&reg->ctrl_status) & ~CSRX_FLASH_ENABLE);
RD_REG_DWORD(&reg->ctrl_status); /* PCI Posting. */ RD_REG_DWORD(&reg->ctrl_status); /* PCI Posting. */
spin_unlock_irqrestore(&ha->hardware_lock, flags);
return ret; return ret;
} }
@ -836,8 +843,20 @@ int
qla25xx_write_nvram_data(scsi_qla_host_t *ha, uint8_t *buf, uint32_t naddr, qla25xx_write_nvram_data(scsi_qla_host_t *ha, uint8_t *buf, uint32_t naddr,
uint32_t bytes) uint32_t bytes)
{ {
return qla24xx_write_flash_data(ha, (uint32_t *)buf, #define RMW_BUFFER_SIZE (64 * 1024)
FA_VPD_NVRAM_ADDR | naddr, bytes >> 2); uint8_t *dbuf;
dbuf = vmalloc(RMW_BUFFER_SIZE);
if (!dbuf)
return QLA_MEMORY_ALLOC_FAILED;
ha->isp_ops->read_optrom(ha, dbuf, FA_VPD_NVRAM_ADDR << 2,
RMW_BUFFER_SIZE);
memcpy(dbuf + (naddr << 2), buf, bytes);
ha->isp_ops->write_optrom(ha, dbuf, FA_VPD_NVRAM_ADDR << 2,
RMW_BUFFER_SIZE);
vfree(dbuf);
return QLA_SUCCESS;
} }
static inline void static inline void
@ -1853,7 +1872,8 @@ qla25xx_read_optrom_data(struct scsi_qla_host *ha, uint8_t *buf,
qla_printk(KERN_WARNING, ha, qla_printk(KERN_WARNING, ha,
"Unable to burst-read optrom segment " "Unable to burst-read optrom segment "
"(%x/%x/%llx).\n", rval, "(%x/%x/%llx).\n", rval,
flash_data_to_access_addr(faddr), optrom_dma); flash_data_to_access_addr(faddr),
(unsigned long long)optrom_dma);
qla_printk(KERN_WARNING, ha, qla_printk(KERN_WARNING, ha,
"Reverting to slow-read.\n"); "Reverting to slow-read.\n");

2
drivers/scsi/qla2xxx/qla_version.h
View File

@ -7,7 +7,7 @@
/* /*
* Driver version * Driver version
*/ */
#define QLA2XXX_VERSION "8.02.00-k4" #define QLA2XXX_VERSION "8.02.00-k5"
#define QLA_DRIVER_MAJOR_VER 8 #define QLA_DRIVER_MAJOR_VER 8
#define QLA_DRIVER_MINOR_VER 2 #define QLA_DRIVER_MINOR_VER 2

1
drivers/scsi/scsi_error.c
View File

@ -24,7 +24,6 @@
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/scatterlist.h>
#include <scsi/scsi.h> #include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h> #include <scsi/scsi_cmnd.h>

10
drivers/scsi/scsi_sysfs.c
View File

@ -209,11 +209,13 @@ show_shost_mode(unsigned int mode, char *buf)
static ssize_t show_shost_supported_mode(struct class_device *class_dev, char *buf) static ssize_t show_shost_supported_mode(struct class_device *class_dev, char *buf)
{ {
struct Scsi_Host *shost = class_to_shost(class_dev); struct Scsi_Host *shost = class_to_shost(class_dev);
unsigned int supported_mode = shost->hostt->supported_mode;
if (shost->hostt->supported_mode == MODE_UNKNOWN) if (supported_mode == MODE_UNKNOWN)
return snprintf(buf, 20, "unknown\n"); /* by default this should be initiator */
else supported_mode = MODE_INITIATOR;
return show_shost_mode(shost->hostt->supported_mode, buf);
return show_shost_mode(supported_mode, buf);
} }
static CLASS_DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL); static CLASS_DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL);

1
drivers/scsi/sym53c8xx_2/sym53c8xx.h
View File

@ -127,7 +127,6 @@ struct sym_driver_setup {
u_char settle_delay; u_char settle_delay;
u_char use_nvram; u_char use_nvram;
u_long excludes[8]; u_long excludes[8];
char tag_ctrl[100];
}; };
#define SYM_SETUP_MAX_TAG sym_driver_setup.max_tag #define SYM_SETUP_MAX_TAG sym_driver_setup.max_tag

18
drivers/scsi/sym53c8xx_2/sym_fw.c
View File

@ -104,8 +104,9 @@ static struct sym_fwz_ofs sym_fw2z_ofs = {
* Patch routine for firmware #1. * Patch routine for firmware #1.
*/ */
static void static void
sym_fw1_patch(struct sym_hcb *np) sym_fw1_patch(struct Scsi_Host *shost)
{ {
struct sym_hcb *np = sym_get_hcb(shost);
struct sym_fw1a_scr *scripta0; struct sym_fw1a_scr *scripta0;
struct sym_fw1b_scr *scriptb0; struct sym_fw1b_scr *scriptb0;
@ -145,8 +146,11 @@ sym_fw1_patch(struct sym_hcb *np)
* Patch routine for firmware #2. * Patch routine for firmware #2.
*/ */
static void static void
sym_fw2_patch(struct sym_hcb *np) sym_fw2_patch(struct Scsi_Host *shost)
{ {
struct sym_data *sym_data = shost_priv(shost);
struct pci_dev *pdev = sym_data->pdev;
struct sym_hcb *np = sym_data->ncb;
struct sym_fw2a_scr *scripta0; struct sym_fw2a_scr *scripta0;
struct sym_fw2b_scr *scriptb0; struct sym_fw2b_scr *scriptb0;
@ -167,7 +171,7 @@ sym_fw2_patch(struct sym_hcb *np)
* Remove useless 64 bit DMA specific SCRIPTS, * Remove useless 64 bit DMA specific SCRIPTS,
* when this feature is not available. * when this feature is not available.
*/ */
if (!np->use_dac) { if (!use_dac(np)) {
scripta0->is_dmap_dirty[0] = cpu_to_scr(SCR_NO_OP); scripta0->is_dmap_dirty[0] = cpu_to_scr(SCR_NO_OP);
scripta0->is_dmap_dirty[1] = 0; scripta0->is_dmap_dirty[1] = 0;
scripta0->is_dmap_dirty[2] = cpu_to_scr(SCR_NO_OP); scripta0->is_dmap_dirty[2] = cpu_to_scr(SCR_NO_OP);
@ -205,14 +209,14 @@ sym_fw2_patch(struct sym_hcb *np)
* Remove a couple of work-arounds specific to C1010 if * Remove a couple of work-arounds specific to C1010 if
* they are not desirable. See `sym_fw2.h' for more details. * they are not desirable. See `sym_fw2.h' for more details.
*/ */
if (!(np->device_id == PCI_DEVICE_ID_LSI_53C1010_66 && if (!(pdev->device == PCI_DEVICE_ID_LSI_53C1010_66 &&
np->revision_id < 0x1 && pdev->revision < 0x1 &&
np->pciclk_khz < 60000)) { np->pciclk_khz < 60000)) {
scripta0->datao_phase[0] = cpu_to_scr(SCR_NO_OP); scripta0->datao_phase[0] = cpu_to_scr(SCR_NO_OP);
scripta0->datao_phase[1] = cpu_to_scr(0); scripta0->datao_phase[1] = cpu_to_scr(0);
} }
if (!(np->device_id == PCI_DEVICE_ID_LSI_53C1010_33 && if (!(pdev->device == PCI_DEVICE_ID_LSI_53C1010_33 /* &&
/* np->revision_id < 0xff */ 1)) { pdev->revision < 0xff */)) {
scripta0->sel_done[0] = cpu_to_scr(SCR_NO_OP); scripta0->sel_done[0] = cpu_to_scr(SCR_NO_OP);
scripta0->sel_done[1] = cpu_to_scr(0); scripta0->sel_done[1] = cpu_to_scr(0);
} }

2
drivers/scsi/sym53c8xx_2/sym_fw.h
View File

@ -143,7 +143,7 @@ struct sym_fw {
*z_ofs; /* Useful offsets in script Z */ *z_ofs; /* Useful offsets in script Z */
/* Setup and patch methods for this firmware */ /* Setup and patch methods for this firmware */
void (*setup)(struct sym_hcb *, struct sym_fw *); void (*setup)(struct sym_hcb *, struct sym_fw *);
void (*patch)(struct sym_hcb *); void (*patch)(struct Scsi_Host *);
}; };
/* /*

579
drivers/scsi/sym53c8xx_2/sym_glue.c
View File

@ -39,7 +39,6 @@
*/ */
#include <linux/ctype.h> #include <linux/ctype.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
@ -54,16 +53,12 @@
#define NAME53C "sym53c" #define NAME53C "sym53c"
#define NAME53C8XX "sym53c8xx" #define NAME53C8XX "sym53c8xx"
#define IRQ_FMT "%d"
#define IRQ_PRM(x) (x)
struct sym_driver_setup sym_driver_setup = SYM_LINUX_DRIVER_SETUP; struct sym_driver_setup sym_driver_setup = SYM_LINUX_DRIVER_SETUP;
unsigned int sym_debug_flags = 0; unsigned int sym_debug_flags = 0;
static char *excl_string; static char *excl_string;
static char *safe_string; static char *safe_string;
module_param_named(cmd_per_lun, sym_driver_setup.max_tag, ushort, 0); module_param_named(cmd_per_lun, sym_driver_setup.max_tag, ushort, 0);
module_param_string(tag_ctrl, sym_driver_setup.tag_ctrl, 100, 0);
module_param_named(burst, sym_driver_setup.burst_order, byte, 0); module_param_named(burst, sym_driver_setup.burst_order, byte, 0);
module_param_named(led, sym_driver_setup.scsi_led, byte, 0); module_param_named(led, sym_driver_setup.scsi_led, byte, 0);
module_param_named(diff, sym_driver_setup.scsi_diff, byte, 0); module_param_named(diff, sym_driver_setup.scsi_diff, byte, 0);
@ -78,7 +73,6 @@ module_param_named(excl, excl_string, charp, 0);
module_param_named(safe, safe_string, charp, 0); module_param_named(safe, safe_string, charp, 0);
MODULE_PARM_DESC(cmd_per_lun, "The maximum number of tags to use by default"); MODULE_PARM_DESC(cmd_per_lun, "The maximum number of tags to use by default");
MODULE_PARM_DESC(tag_ctrl, "More detailed control over tags per LUN");
MODULE_PARM_DESC(burst, "Maximum burst. 0 to disable, 255 to read from registers"); MODULE_PARM_DESC(burst, "Maximum burst. 0 to disable, 255 to read from registers");
MODULE_PARM_DESC(led, "Set to 1 to enable LED support"); MODULE_PARM_DESC(led, "Set to 1 to enable LED support");
MODULE_PARM_DESC(diff, "0 for no differential mode, 1 for BIOS, 2 for always, 3 for not GPIO3"); MODULE_PARM_DESC(diff, "0 for no differential mode, 1 for BIOS, 2 for always, 3 for not GPIO3");
@ -134,57 +128,27 @@ static struct scsi_transport_template *sym2_transport_template = NULL;
* Driver private area in the SCSI command structure. * Driver private area in the SCSI command structure.
*/ */
struct sym_ucmd { /* Override the SCSI pointer structure */ struct sym_ucmd { /* Override the SCSI pointer structure */
dma_addr_t data_mapping; struct completion *eh_done; /* SCSI error handling */
unsigned char data_mapped;
unsigned char to_do; /* For error handling */
void (*old_done)(struct scsi_cmnd *); /* For error handling */
struct completion *eh_done; /* For error handling */
}; };
#define SYM_UCMD_PTR(cmd) ((struct sym_ucmd *)(&(cmd)->SCp)) #define SYM_UCMD_PTR(cmd) ((struct sym_ucmd *)(&(cmd)->SCp))
#define SYM_SOFTC_PTR(cmd) sym_get_hcb(cmd->device->host) #define SYM_SOFTC_PTR(cmd) sym_get_hcb(cmd->device->host)
static void __unmap_scsi_data(struct pci_dev *pdev, struct scsi_cmnd *cmd)
{
if (SYM_UCMD_PTR(cmd)->data_mapped)
scsi_dma_unmap(cmd);
SYM_UCMD_PTR(cmd)->data_mapped = 0;
}
static int __map_scsi_sg_data(struct pci_dev *pdev, struct scsi_cmnd *cmd)
{
int use_sg;
use_sg = scsi_dma_map(cmd);
if (use_sg > 0) {
SYM_UCMD_PTR(cmd)->data_mapped = 2;
SYM_UCMD_PTR(cmd)->data_mapping = use_sg;
}
return use_sg;
}
#define unmap_scsi_data(np, cmd) \
__unmap_scsi_data(np->s.device, cmd)
#define map_scsi_sg_data(np, cmd) \
__map_scsi_sg_data(np->s.device, cmd)
/* /*
* Complete a pending CAM CCB. * Complete a pending CAM CCB.
*/ */
void sym_xpt_done(struct sym_hcb *np, struct scsi_cmnd *cmd) void sym_xpt_done(struct sym_hcb *np, struct scsi_cmnd *cmd)
{ {
unmap_scsi_data(np, cmd); struct sym_ucmd *ucmd = SYM_UCMD_PTR(cmd);
BUILD_BUG_ON(sizeof(struct scsi_pointer) < sizeof(struct sym_ucmd));
if (ucmd->eh_done)
complete(ucmd->eh_done);
scsi_dma_unmap(cmd);
cmd->scsi_done(cmd); cmd->scsi_done(cmd);
} }
static void sym_xpt_done2(struct sym_hcb *np, struct scsi_cmnd *cmd, int cam_status)
{
sym_set_cam_status(cmd, cam_status);
sym_xpt_done(np, cmd);
}
/* /*
* Tell the SCSI layer about a BUS RESET. * Tell the SCSI layer about a BUS RESET.
*/ */
@ -198,14 +162,6 @@ void sym_xpt_async_bus_reset(struct sym_hcb *np)
sym_name(np), sym_driver_setup.settle_delay); sym_name(np), sym_driver_setup.settle_delay);
} }
/*
* Tell the SCSI layer about a BUS DEVICE RESET message sent.
*/
void sym_xpt_async_sent_bdr(struct sym_hcb *np, int target)
{
printf_notice("%s: TARGET %d has been reset.\n", sym_name(np), target);
}
/* /*
* Choose the more appropriate CAM status if * Choose the more appropriate CAM status if
* the IO encountered an extended error. * the IO encountered an extended error.
@ -307,14 +263,14 @@ static int sym_scatter(struct sym_hcb *np, struct sym_ccb *cp, struct scsi_cmnd
cp->data_len = 0; cp->data_len = 0;
use_sg = map_scsi_sg_data(np, cmd); use_sg = scsi_dma_map(cmd);
if (use_sg > 0) { if (use_sg > 0) {
struct scatterlist *sg; struct scatterlist *sg;
struct sym_tcb *tp = &np->target[cp->target]; struct sym_tcb *tp = &np->target[cp->target];
struct sym_tblmove *data; struct sym_tblmove *data;
if (use_sg > SYM_CONF_MAX_SG) { if (use_sg > SYM_CONF_MAX_SG) {
unmap_scsi_data(np, cmd); scsi_dma_unmap(cmd);
return -1; return -1;
} }
@ -350,15 +306,6 @@ static int sym_queue_command(struct sym_hcb *np, struct scsi_cmnd *cmd)
struct sym_ccb *cp; struct sym_ccb *cp;
int order; int order;
/*
* Minimal checkings, so that we will not
* go outside our tables.
*/
if (sdev->id == np->myaddr) {
sym_xpt_done2(np, cmd, DID_NO_CONNECT);
return 0;
}
/* /*
* Retrieve the target descriptor. * Retrieve the target descriptor.
*/ */
@ -433,7 +380,7 @@ int sym_setup_data_and_start(struct sym_hcb *np, struct scsi_cmnd *cmd, struct s
*/ */
switch (dir) { switch (dir) {
case DMA_BIDIRECTIONAL: case DMA_BIDIRECTIONAL:
printk("%s: got DMA_BIDIRECTIONAL command", sym_name(np)); scmd_printk(KERN_INFO, cmd, "got DMA_BIDIRECTIONAL command");
sym_set_cam_status(cmd, DID_ERROR); sym_set_cam_status(cmd, DID_ERROR);
goto out_abort; goto out_abort;
case DMA_TO_DEVICE: case DMA_TO_DEVICE:
@ -542,14 +489,16 @@ static void sym_timer(struct sym_hcb *np)
/* /*
* PCI BUS error handler. * PCI BUS error handler.
*/ */
void sym_log_bus_error(struct sym_hcb *np) void sym_log_bus_error(struct Scsi_Host *shost)
{ {
u_short pci_sts; struct sym_data *sym_data = shost_priv(shost);
pci_read_config_word(np->s.device, PCI_STATUS, &pci_sts); struct pci_dev *pdev = sym_data->pdev;
unsigned short pci_sts;
pci_read_config_word(pdev, PCI_STATUS, &pci_sts);
if (pci_sts & 0xf900) { if (pci_sts & 0xf900) {
pci_write_config_word(np->s.device, PCI_STATUS, pci_sts); pci_write_config_word(pdev, PCI_STATUS, pci_sts);
printf("%s: PCI STATUS = 0x%04x\n", shost_printk(KERN_WARNING, shost,
sym_name(np), pci_sts & 0xf900); "PCI bus error: status = 0x%04x\n", pci_sts & 0xf900);
} }
} }
@ -593,18 +542,23 @@ static int sym53c8xx_queue_command(struct scsi_cmnd *cmd,
*/ */
static irqreturn_t sym53c8xx_intr(int irq, void *dev_id) static irqreturn_t sym53c8xx_intr(int irq, void *dev_id)
{ {
unsigned long flags; struct Scsi_Host *shost = dev_id;
struct sym_hcb *np = (struct sym_hcb *)dev_id; struct sym_data *sym_data = shost_priv(shost);
irqreturn_t result;
/* Avoid spinloop trying to handle interrupts on frozen device */
if (pci_channel_offline(sym_data->pdev))
return IRQ_NONE;
if (DEBUG_FLAGS & DEBUG_TINY) printf_debug ("["); if (DEBUG_FLAGS & DEBUG_TINY) printf_debug ("[");
spin_lock_irqsave(np->s.host->host_lock, flags); spin_lock(shost->host_lock);
sym_interrupt(np); result = sym_interrupt(shost);
spin_unlock_irqrestore(np->s.host->host_lock, flags); spin_unlock(shost->host_lock);
if (DEBUG_FLAGS & DEBUG_TINY) printf_debug ("]\n"); if (DEBUG_FLAGS & DEBUG_TINY) printf_debug ("]\n");
return IRQ_HANDLED; return result;
} }
/* /*
@ -629,60 +583,62 @@ static void sym53c8xx_timer(unsigned long npref)
#define SYM_EH_BUS_RESET 2 #define SYM_EH_BUS_RESET 2
#define SYM_EH_HOST_RESET 3 #define SYM_EH_HOST_RESET 3
/*
* What we will do regarding the involved SCSI command.
*/
#define SYM_EH_DO_IGNORE 0
#define SYM_EH_DO_WAIT 2
/*
* scsi_done() alias when error recovery is in progress.
*/
static void sym_eh_done(struct scsi_cmnd *cmd)
{
struct sym_ucmd *ucmd = SYM_UCMD_PTR(cmd);
BUILD_BUG_ON(sizeof(struct scsi_pointer) < sizeof(struct sym_ucmd));
cmd->scsi_done = ucmd->old_done;
if (ucmd->to_do == SYM_EH_DO_WAIT)
complete(ucmd->eh_done);
}
/* /*
* Generic method for our eh processing. * Generic method for our eh processing.
* The 'op' argument tells what we have to do. * The 'op' argument tells what we have to do.
*/ */
static int sym_eh_handler(int op, char *opname, struct scsi_cmnd *cmd) static int sym_eh_handler(int op, char *opname, struct scsi_cmnd *cmd)
{ {
struct sym_hcb *np = SYM_SOFTC_PTR(cmd);
struct sym_ucmd *ucmd = SYM_UCMD_PTR(cmd); struct sym_ucmd *ucmd = SYM_UCMD_PTR(cmd);
struct Scsi_Host *host = cmd->device->host; struct Scsi_Host *shost = cmd->device->host;
struct sym_data *sym_data = shost_priv(shost);
struct pci_dev *pdev = sym_data->pdev;
struct sym_hcb *np = sym_data->ncb;
SYM_QUEHEAD *qp; SYM_QUEHEAD *qp;
int to_do = SYM_EH_DO_IGNORE; int cmd_queued = 0;
int sts = -1; int sts = -1;
struct completion eh_done; struct completion eh_done;
dev_warn(&cmd->device->sdev_gendev, "%s operation started.\n", opname); scmd_printk(KERN_WARNING, cmd, "%s operation started\n", opname);
spin_lock_irq(host->host_lock); /* We may be in an error condition because the PCI bus
* went down. In this case, we need to wait until the
* PCI bus is reset, the card is reset, and only then
* proceed with the scsi error recovery. There's no
* point in hurrying; take a leisurely wait.
*/
#define WAIT_FOR_PCI_RECOVERY 35
if (pci_channel_offline(pdev)) {
struct completion *io_reset;
int finished_reset = 0;
init_completion(&eh_done);
spin_lock_irq(shost->host_lock);
/* Make sure we didn't race */
if (pci_channel_offline(pdev)) {
if (!sym_data->io_reset)
sym_data->io_reset = &eh_done;
io_reset = sym_data->io_reset;
} else {
finished_reset = 1;
}
spin_unlock_irq(shost->host_lock);
if (!finished_reset)
finished_reset = wait_for_completion_timeout(io_reset,
WAIT_FOR_PCI_RECOVERY*HZ);
if (!finished_reset)
return SCSI_FAILED;
}
spin_lock_irq(shost->host_lock);
/* This one is queued in some place -> to wait for completion */ /* This one is queued in some place -> to wait for completion */
FOR_EACH_QUEUED_ELEMENT(&np->busy_ccbq, qp) { FOR_EACH_QUEUED_ELEMENT(&np->busy_ccbq, qp) {
struct sym_ccb *cp = sym_que_entry(qp, struct sym_ccb, link_ccbq); struct sym_ccb *cp = sym_que_entry(qp, struct sym_ccb, link_ccbq);
if (cp->cmd == cmd) { if (cp->cmd == cmd) {
to_do = SYM_EH_DO_WAIT; cmd_queued = 1;
break; break;
} }
} }
if (to_do == SYM_EH_DO_WAIT) {
init_completion(&eh_done);
ucmd->old_done = cmd->scsi_done;
ucmd->eh_done = &eh_done;
wmb();
cmd->scsi_done = sym_eh_done;
}
/* Try to proceed the operation we have been asked for */ /* Try to proceed the operation we have been asked for */
sts = -1; sts = -1;
switch(op) { switch(op) {
@ -698,7 +654,7 @@ static int sym_eh_handler(int op, char *opname, struct scsi_cmnd *cmd)
break; break;
case SYM_EH_HOST_RESET: case SYM_EH_HOST_RESET:
sym_reset_scsi_bus(np, 0); sym_reset_scsi_bus(np, 0);
sym_start_up (np, 1); sym_start_up(shost, 1);
sts = 0; sts = 0;
break; break;
default: default:
@ -706,21 +662,21 @@ static int sym_eh_handler(int op, char *opname, struct scsi_cmnd *cmd)
} }
/* On error, restore everything and cross fingers :) */ /* On error, restore everything and cross fingers :) */
if (sts) { if (sts)
cmd->scsi_done = ucmd->old_done; cmd_queued = 0;
to_do = SYM_EH_DO_IGNORE;
}
ucmd->to_do = to_do; if (cmd_queued) {
spin_unlock_irq(host->host_lock); init_completion(&eh_done);
ucmd->eh_done = &eh_done;
if (to_do == SYM_EH_DO_WAIT) { spin_unlock_irq(shost->host_lock);
if (!wait_for_completion_timeout(&eh_done, 5*HZ)) { if (!wait_for_completion_timeout(&eh_done, 5*HZ)) {
ucmd->to_do = SYM_EH_DO_IGNORE; ucmd->eh_done = NULL;
wmb();
sts = -2; sts = -2;
} }
} else {
spin_unlock_irq(shost->host_lock);
} }
dev_warn(&cmd->device->sdev_gendev, "%s operation %s.\n", opname, dev_warn(&cmd->device->sdev_gendev, "%s operation %s.\n", opname,
sts==0 ? "complete" :sts==-2 ? "timed-out" : "failed"); sts==0 ? "complete" :sts==-2 ? "timed-out" : "failed");
return sts ? SCSI_FAILED : SCSI_SUCCESS; return sts ? SCSI_FAILED : SCSI_SUCCESS;
@ -775,59 +731,6 @@ static void sym_tune_dev_queuing(struct sym_tcb *tp, int lun, u_short reqtags)
} }
} }
/*
* Linux select queue depths function
*/
#define DEF_DEPTH (sym_driver_setup.max_tag)
#define ALL_TARGETS -2
#define NO_TARGET -1
#define ALL_LUNS -2
#define NO_LUN -1
static int device_queue_depth(struct sym_hcb *np, int target, int lun)
{
int c, h, t, u, v;
char *p = sym_driver_setup.tag_ctrl;
char *ep;
h = -1;
t = NO_TARGET;
u = NO_LUN;
while ((c = *p++) != 0) {
v = simple_strtoul(p, &ep, 0);
switch(c) {
case '/':
++h;
t = ALL_TARGETS;
u = ALL_LUNS;
break;
case 't':
if (t != target)
t = (target == v) ? v : NO_TARGET;
u = ALL_LUNS;
break;
case 'u':
if (u != lun)
u = (lun == v) ? v : NO_LUN;
break;
case 'q':
if (h == np->s.unit &&
(t == ALL_TARGETS || t == target) &&
(u == ALL_LUNS || u == lun))
return v;
break;
case '-':
t = ALL_TARGETS;
u = ALL_LUNS;
break;
default:
break;
}
p = ep;
}
return DEF_DEPTH;
}
static int sym53c8xx_slave_alloc(struct scsi_device *sdev) static int sym53c8xx_slave_alloc(struct scsi_device *sdev)
{ {
struct sym_hcb *np = sym_get_hcb(sdev->host); struct sym_hcb *np = sym_get_hcb(sdev->host);
@ -892,21 +795,16 @@ static int sym53c8xx_slave_configure(struct scsi_device *sdev)
* Use at least 2. * Use at least 2.
* Donnot use more than our maximum. * Donnot use more than our maximum.
*/ */
reqtags = device_queue_depth(np, sdev->id, sdev->lun); reqtags = sym_driver_setup.max_tag;
if (reqtags > tp->usrtags) if (reqtags > tp->usrtags)
reqtags = tp->usrtags; reqtags = tp->usrtags;
if (!sdev->tagged_supported) if (!sdev->tagged_supported)
reqtags = 0; reqtags = 0;
#if 1 /* Avoid to locally queue commands for no good reasons */
if (reqtags > SYM_CONF_MAX_TAG) if (reqtags > SYM_CONF_MAX_TAG)
reqtags = SYM_CONF_MAX_TAG; reqtags = SYM_CONF_MAX_TAG;
depth_to_use = (reqtags ? reqtags : 2); depth_to_use = reqtags ? reqtags : 2;
#else
depth_to_use = (reqtags ? SYM_CONF_MAX_TAG : 2);
#endif
scsi_adjust_queue_depth(sdev, scsi_adjust_queue_depth(sdev,
(sdev->tagged_supported ? sdev->tagged_supported ? MSG_SIMPLE_TAG : 0,
MSG_SIMPLE_TAG : 0),
depth_to_use); depth_to_use);
lp->s.scdev_depth = depth_to_use; lp->s.scdev_depth = depth_to_use;
sym_tune_dev_queuing(tp, sdev->lun, reqtags); sym_tune_dev_queuing(tp, sdev->lun, reqtags);
@ -1089,8 +987,9 @@ static int is_keyword(char *ptr, int len, char *verb)
* Parse a control command * Parse a control command
*/ */
static int sym_user_command(struct sym_hcb *np, char *buffer, int length) static int sym_user_command(struct Scsi_Host *shost, char *buffer, int length)
{ {
struct sym_hcb *np = sym_get_hcb(shost);
char *ptr = buffer; char *ptr = buffer;
int len = length; int len = length;
struct sym_usrcmd cmd, *uc = &cmd; struct sym_usrcmd cmd, *uc = &cmd;
@ -1217,9 +1116,9 @@ printk("sym_user_command: data=%ld\n", uc->data);
else { else {
unsigned long flags; unsigned long flags;
spin_lock_irqsave(np->s.host->host_lock, flags); spin_lock_irqsave(shost->host_lock, flags);
sym_exec_user_command (np, uc); sym_exec_user_command(np, uc);
spin_unlock_irqrestore(np->s.host->host_lock, flags); spin_unlock_irqrestore(shost->host_lock, flags);
} }
return length; return length;
} }
@ -1275,8 +1174,11 @@ static int copy_info(struct info_str *info, char *fmt, ...)
/* /*
* Copy formatted information into the input buffer. * Copy formatted information into the input buffer.
*/ */
static int sym_host_info(struct sym_hcb *np, char *ptr, off_t offset, int len) static int sym_host_info(struct Scsi_Host *shost, char *ptr, off_t offset, int len)
{ {
struct sym_data *sym_data = shost_priv(shost);
struct pci_dev *pdev = sym_data->pdev;
struct sym_hcb *np = sym_data->ncb;
struct info_str info; struct info_str info;
info.buffer = ptr; info.buffer = ptr;
@ -1285,10 +1187,10 @@ static int sym_host_info(struct sym_hcb *np, char *ptr, off_t offset, int len)
info.pos = 0; info.pos = 0;
copy_info(&info, "Chip " NAME53C "%s, device id 0x%x, " copy_info(&info, "Chip " NAME53C "%s, device id 0x%x, "
"revision id 0x%x\n", "revision id 0x%x\n", np->s.chip_name,
np->s.chip_name, np->device_id, np->revision_id); pdev->device, pdev->revision);
copy_info(&info, "At PCI address %s, IRQ " IRQ_FMT "\n", copy_info(&info, "At PCI address %s, IRQ %u\n",
pci_name(np->s.device), IRQ_PRM(np->s.irq)); pci_name(pdev), pdev->irq);
copy_info(&info, "Min. period factor %d, %s SCSI BUS%s\n", copy_info(&info, "Min. period factor %d, %s SCSI BUS%s\n",
(int) (np->minsync_dt ? np->minsync_dt : np->minsync), (int) (np->minsync_dt ? np->minsync_dt : np->minsync),
np->maxwide ? "Wide" : "Narrow", np->maxwide ? "Wide" : "Narrow",
@ -1307,15 +1209,14 @@ static int sym_host_info(struct sym_hcb *np, char *ptr, off_t offset, int len)
* - func = 0 means read (returns adapter infos) * - func = 0 means read (returns adapter infos)
* - func = 1 means write (not yet merget from sym53c8xx) * - func = 1 means write (not yet merget from sym53c8xx)
*/ */
static int sym53c8xx_proc_info(struct Scsi_Host *host, char *buffer, static int sym53c8xx_proc_info(struct Scsi_Host *shost, char *buffer,
char **start, off_t offset, int length, int func) char **start, off_t offset, int length, int func)
{ {
struct sym_hcb *np = sym_get_hcb(host);
int retv; int retv;
if (func) { if (func) {
#ifdef SYM_LINUX_USER_COMMAND_SUPPORT #ifdef SYM_LINUX_USER_COMMAND_SUPPORT
retv = sym_user_command(np, buffer, length); retv = sym_user_command(shost, buffer, length);
#else #else
retv = -EINVAL; retv = -EINVAL;
#endif #endif
@ -1323,7 +1224,7 @@ static int sym53c8xx_proc_info(struct Scsi_Host *host, char *buffer,
if (start) if (start)
*start = buffer; *start = buffer;
#ifdef SYM_LINUX_USER_INFO_SUPPORT #ifdef SYM_LINUX_USER_INFO_SUPPORT
retv = sym_host_info(np, buffer, offset, length); retv = sym_host_info(shost, buffer, offset, length);
#else #else
retv = -EINVAL; retv = -EINVAL;
#endif #endif
@ -1341,8 +1242,8 @@ static void sym_free_resources(struct sym_hcb *np, struct pci_dev *pdev)
/* /*
* Free O/S specific resources. * Free O/S specific resources.
*/ */
if (np->s.irq) if (pdev->irq)
free_irq(np->s.irq, np); free_irq(pdev->irq, np);
if (np->s.ioaddr) if (np->s.ioaddr)
pci_iounmap(pdev, np->s.ioaddr); pci_iounmap(pdev, np->s.ioaddr);
if (np->s.ramaddr) if (np->s.ramaddr)
@ -1355,31 +1256,6 @@ static void sym_free_resources(struct sym_hcb *np, struct pci_dev *pdev)
sym_mfree_dma(np, sizeof(*np), "HCB"); sym_mfree_dma(np, sizeof(*np), "HCB");
} }
/*
* Ask/tell the system about DMA addressing.
*/
static int sym_setup_bus_dma_mask(struct sym_hcb *np)
{
#if SYM_CONF_DMA_ADDRESSING_MODE > 0
#if SYM_CONF_DMA_ADDRESSING_MODE == 1
#define DMA_DAC_MASK DMA_40BIT_MASK
#elif SYM_CONF_DMA_ADDRESSING_MODE == 2
#define DMA_DAC_MASK DMA_64BIT_MASK
#endif
if ((np->features & FE_DAC) &&
!pci_set_dma_mask(np->s.device, DMA_DAC_MASK)) {
np->use_dac = 1;
return 0;
}
#endif
if (!pci_set_dma_mask(np->s.device, DMA_32BIT_MASK))
return 0;
printf_warning("%s: No suitable DMA available\n", sym_name(np));
return -1;
}
/* /*
* Host attach and initialisations. * Host attach and initialisations.
* *
@ -1392,32 +1268,28 @@ static int sym_setup_bus_dma_mask(struct sym_hcb *np)
static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt, static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
int unit, struct sym_device *dev) int unit, struct sym_device *dev)
{ {
struct host_data *host_data; struct sym_data *sym_data;
struct sym_hcb *np = NULL; struct sym_hcb *np = NULL;
struct Scsi_Host *instance = NULL; struct Scsi_Host *shost;
struct pci_dev *pdev = dev->pdev; struct pci_dev *pdev = dev->pdev;
unsigned long flags; unsigned long flags;
struct sym_fw *fw; struct sym_fw *fw;
printk(KERN_INFO printk(KERN_INFO "sym%d: <%s> rev 0x%x at pci %s irq %u\n",
"sym%d: <%s> rev 0x%x at pci %s irq " IRQ_FMT "\n", unit, dev->chip.name, pdev->revision, pci_name(pdev),
unit, dev->chip.name, dev->chip.revision_id, pdev->irq);
pci_name(pdev), IRQ_PRM(pdev->irq));
/* /*
* Get the firmware for this chip. * Get the firmware for this chip.
*/ */
fw = sym_find_firmware(&dev->chip); fw = sym_find_firmware(&dev->chip);
if (!fw) if (!fw)
goto attach_failed; return NULL;
/* shost = scsi_host_alloc(tpnt, sizeof(*sym_data));
* Allocate host_data structure if (!shost)
*/ return NULL;
instance = scsi_host_alloc(tpnt, sizeof(*host_data)); sym_data = shost_priv(shost);
if (!instance)
goto attach_failed;
host_data = (struct host_data *) instance->hostdata;
/* /*
* Allocate immediately the host control block, * Allocate immediately the host control block,
@ -1428,22 +1300,19 @@ static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
np = __sym_calloc_dma(&pdev->dev, sizeof(*np), "HCB"); np = __sym_calloc_dma(&pdev->dev, sizeof(*np), "HCB");
if (!np) if (!np)
goto attach_failed; goto attach_failed;
np->s.device = pdev;
np->bus_dmat = &pdev->dev; /* Result in 1 DMA pool per HBA */ np->bus_dmat = &pdev->dev; /* Result in 1 DMA pool per HBA */
host_data->ncb = np; sym_data->ncb = np;
np->s.host = instance; sym_data->pdev = pdev;
np->s.host = shost;
pci_set_drvdata(pdev, np); pci_set_drvdata(pdev, shost);
/* /*
* Copy some useful infos to the HCB. * Copy some useful infos to the HCB.
*/ */
np->hcb_ba = vtobus(np); np->hcb_ba = vtobus(np);
np->verbose = sym_driver_setup.verbose; np->verbose = sym_driver_setup.verbose;
np->s.device = pdev;
np->s.unit = unit; np->s.unit = unit;
np->device_id = dev->chip.device_id;
np->revision_id = dev->chip.revision_id;
np->features = dev->chip.features; np->features = dev->chip.features;
np->clock_divn = dev->chip.nr_divisor; np->clock_divn = dev->chip.nr_divisor;
np->maxoffs = dev->chip.offset_max; np->maxoffs = dev->chip.offset_max;
@ -1456,8 +1325,13 @@ static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
strlcpy(np->s.chip_name, dev->chip.name, sizeof(np->s.chip_name)); strlcpy(np->s.chip_name, dev->chip.name, sizeof(np->s.chip_name));
sprintf(np->s.inst_name, "sym%d", np->s.unit); sprintf(np->s.inst_name, "sym%d", np->s.unit);
if (sym_setup_bus_dma_mask(np)) if ((SYM_CONF_DMA_ADDRESSING_MODE > 0) && (np->features & FE_DAC) &&
!pci_set_dma_mask(pdev, DMA_DAC_MASK)) {
set_dac(np);
} else if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
printf_warning("%s: No suitable DMA available\n", sym_name(np));
goto attach_failed; goto attach_failed;
}
/* /*
* Try to map the controller chip to * Try to map the controller chip to
@ -1466,19 +1340,16 @@ static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
np->mmio_ba = (u32)dev->mmio_base; np->mmio_ba = (u32)dev->mmio_base;
np->s.ioaddr = dev->s.ioaddr; np->s.ioaddr = dev->s.ioaddr;
np->s.ramaddr = dev->s.ramaddr; np->s.ramaddr = dev->s.ramaddr;
np->s.io_ws = (np->features & FE_IO256) ? 256 : 128;
/* /*
* Map on-chip RAM if present and supported. * Map on-chip RAM if present and supported.
*/ */
if (!(np->features & FE_RAM)) if (!(np->features & FE_RAM))
dev->ram_base = 0; dev->ram_base = 0;
if (dev->ram_base) { if (dev->ram_base)
np->ram_ba = (u32)dev->ram_base; np->ram_ba = (u32)dev->ram_base;
np->ram_ws = (np->features & FE_RAM8K) ? 8192 : 4096;
}
if (sym_hcb_attach(instance, fw, dev->nvram)) if (sym_hcb_attach(shost, fw, dev->nvram))
goto attach_failed; goto attach_failed;
/* /*
@ -1486,25 +1357,25 @@ static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
* If we synchonize the C code with SCRIPTS on interrupt, * If we synchonize the C code with SCRIPTS on interrupt,
* we do not want to share the INTR line at all. * we do not want to share the INTR line at all.
*/ */
if (request_irq(pdev->irq, sym53c8xx_intr, IRQF_SHARED, NAME53C8XX, np)) { if (request_irq(pdev->irq, sym53c8xx_intr, IRQF_SHARED, NAME53C8XX,
printf_err("%s: request irq %d failure\n", shost)) {
printf_err("%s: request irq %u failure\n",
sym_name(np), pdev->irq); sym_name(np), pdev->irq);
goto attach_failed; goto attach_failed;
} }
np->s.irq = pdev->irq;
/* /*
* After SCSI devices have been opened, we cannot * After SCSI devices have been opened, we cannot
* reset the bus safely, so we do it here. * reset the bus safely, so we do it here.
*/ */
spin_lock_irqsave(instance->host_lock, flags); spin_lock_irqsave(shost->host_lock, flags);
if (sym_reset_scsi_bus(np, 0)) if (sym_reset_scsi_bus(np, 0))
goto reset_failed; goto reset_failed;
/* /*
* Start the SCRIPTS. * Start the SCRIPTS.
*/ */
sym_start_up (np, 1); sym_start_up(shost, 1);
/* /*
* Start the timer daemon * Start the timer daemon
@ -1519,33 +1390,37 @@ static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
* Fill Linux host instance structure * Fill Linux host instance structure
* and return success. * and return success.
*/ */
instance->max_channel = 0; shost->max_channel = 0;
instance->this_id = np->myaddr; shost->this_id = np->myaddr;
instance->max_id = np->maxwide ? 16 : 8; shost->max_id = np->maxwide ? 16 : 8;
instance->max_lun = SYM_CONF_MAX_LUN; shost->max_lun = SYM_CONF_MAX_LUN;
instance->unique_id = pci_resource_start(pdev, 0); shost->unique_id = pci_resource_start(pdev, 0);
instance->cmd_per_lun = SYM_CONF_MAX_TAG; shost->cmd_per_lun = SYM_CONF_MAX_TAG;
instance->can_queue = (SYM_CONF_MAX_START-2); shost->can_queue = (SYM_CONF_MAX_START-2);
instance->sg_tablesize = SYM_CONF_MAX_SG; shost->sg_tablesize = SYM_CONF_MAX_SG;
instance->max_cmd_len = 16; shost->max_cmd_len = 16;
BUG_ON(sym2_transport_template == NULL); BUG_ON(sym2_transport_template == NULL);
instance->transportt = sym2_transport_template; shost->transportt = sym2_transport_template;
spin_unlock_irqrestore(instance->host_lock, flags); /* 53c896 rev 1 errata: DMA may not cross 16MB boundary */
if (pdev->device == PCI_DEVICE_ID_NCR_53C896 && pdev->revision < 2)
shost->dma_boundary = 0xFFFFFF;
return instance; spin_unlock_irqrestore(shost->host_lock, flags);
return shost;
reset_failed: reset_failed:
printf_err("%s: FATAL ERROR: CHECK SCSI BUS - CABLES, " printf_err("%s: FATAL ERROR: CHECK SCSI BUS - CABLES, "
"TERMINATION, DEVICE POWER etc.!\n", sym_name(np)); "TERMINATION, DEVICE POWER etc.!\n", sym_name(np));
spin_unlock_irqrestore(instance->host_lock, flags); spin_unlock_irqrestore(shost->host_lock, flags);
attach_failed: attach_failed:
if (!instance) if (!shost)
return NULL; return NULL;
printf_info("%s: giving up ...\n", sym_name(np)); printf_info("%s: giving up ...\n", sym_name(np));
if (np) if (np)
sym_free_resources(np, pdev); sym_free_resources(np, pdev);
scsi_host_put(instance); scsi_host_put(shost);
return NULL; return NULL;
} }
@ -1558,7 +1433,6 @@ static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
static void __devinit sym_get_nvram(struct sym_device *devp, struct sym_nvram *nvp) static void __devinit sym_get_nvram(struct sym_device *devp, struct sym_nvram *nvp)
{ {
devp->nvram = nvp; devp->nvram = nvp;
devp->device_id = devp->chip.device_id;
nvp->type = 0; nvp->type = 0;
sym_read_nvram(devp, nvp); sym_read_nvram(devp, nvp);
@ -1573,7 +1447,6 @@ static int __devinit sym_check_supported(struct sym_device *device)
{ {
struct sym_chip *chip; struct sym_chip *chip;
struct pci_dev *pdev = device->pdev; struct pci_dev *pdev = device->pdev;
u_char revision;
unsigned long io_port = pci_resource_start(pdev, 0); unsigned long io_port = pci_resource_start(pdev, 0);
int i; int i;
@ -1593,14 +1466,12 @@ static int __devinit sym_check_supported(struct sym_device *device)
* to our device structure so we can make it match the actual device * to our device structure so we can make it match the actual device
* and options. * and options.
*/ */
pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision); chip = sym_lookup_chip_table(pdev->device, pdev->revision);
chip = sym_lookup_chip_table(pdev->device, revision);
if (!chip) { if (!chip) {
dev_info(&pdev->dev, "device not supported\n"); dev_info(&pdev->dev, "device not supported\n");
return -ENODEV; return -ENODEV;
} }
memcpy(&device->chip, chip, sizeof(device->chip)); memcpy(&device->chip, chip, sizeof(device->chip));
device->chip.revision_id = revision;
return 0; return 0;
} }
@ -1641,7 +1512,7 @@ static int __devinit sym_set_workarounds(struct sym_device *device)
* We must ensure the chip will use WRITE AND INVALIDATE. * We must ensure the chip will use WRITE AND INVALIDATE.
* The revision number limit is for now arbitrary. * The revision number limit is for now arbitrary.
*/ */
if (pdev->device == PCI_DEVICE_ID_NCR_53C896 && chip->revision_id < 0x4) { if (pdev->device == PCI_DEVICE_ID_NCR_53C896 && pdev->revision < 0x4) {
chip->features |= (FE_WRIE | FE_CLSE); chip->features |= (FE_WRIE | FE_CLSE);
} }
@ -1769,8 +1640,9 @@ static void sym_config_pqs(struct pci_dev *pdev, struct sym_device *sym_dev)
* Detach the host. * Detach the host.
* We have to free resources and halt the NCR chip. * We have to free resources and halt the NCR chip.
*/ */
static int sym_detach(struct sym_hcb *np, struct pci_dev *pdev) static int sym_detach(struct Scsi_Host *shost, struct pci_dev *pdev)
{ {
struct sym_hcb *np = sym_get_hcb(shost);
printk("%s: detaching ...\n", sym_name(np)); printk("%s: detaching ...\n", sym_name(np));
del_timer_sync(&np->s.timer); del_timer_sync(&np->s.timer);
@ -1823,7 +1695,7 @@ static int __devinit sym2_probe(struct pci_dev *pdev,
{ {
struct sym_device sym_dev; struct sym_device sym_dev;
struct sym_nvram nvram; struct sym_nvram nvram;
struct Scsi_Host *instance; struct Scsi_Host *shost;
memset(&sym_dev, 0, sizeof(sym_dev)); memset(&sym_dev, 0, sizeof(sym_dev));
memset(&nvram, 0, sizeof(nvram)); memset(&nvram, 0, sizeof(nvram));
@ -1850,13 +1722,13 @@ static int __devinit sym2_probe(struct pci_dev *pdev,
sym_get_nvram(&sym_dev, &nvram); sym_get_nvram(&sym_dev, &nvram);
instance = sym_attach(&sym2_template, attach_count, &sym_dev); shost = sym_attach(&sym2_template, attach_count, &sym_dev);
if (!instance) if (!shost)
goto free; goto free;
if (scsi_add_host(instance, &pdev->dev)) if (scsi_add_host(shost, &pdev->dev))
goto detach; goto detach;
scsi_scan_host(instance); scsi_scan_host(shost);
attach_count++; attach_count++;
@ -1874,20 +1746,143 @@ static int __devinit sym2_probe(struct pci_dev *pdev,
static void __devexit sym2_remove(struct pci_dev *pdev) static void __devexit sym2_remove(struct pci_dev *pdev)
{ {
struct sym_hcb *np = pci_get_drvdata(pdev); struct Scsi_Host *shost = pci_get_drvdata(pdev);
struct Scsi_Host *host = np->s.host;
scsi_remove_host(host);
scsi_host_put(host);
sym_detach(np, pdev);
scsi_remove_host(shost);
scsi_host_put(shost);
sym_detach(shost, pdev);
pci_release_regions(pdev); pci_release_regions(pdev);
pci_disable_device(pdev); pci_disable_device(pdev);
attach_count--; attach_count--;
} }
/**
* sym2_io_error_detected() - called when PCI error is detected
* @pdev: pointer to PCI device
* @state: current state of the PCI slot
*/
static pci_ers_result_t sym2_io_error_detected(struct pci_dev *pdev,
enum pci_channel_state state)
{
/* If slot is permanently frozen, turn everything off */
if (state == pci_channel_io_perm_failure) {
sym2_remove(pdev);
return PCI_ERS_RESULT_DISCONNECT;
}
disable_irq(pdev->irq);
pci_disable_device(pdev);
/* Request that MMIO be enabled, so register dump can be taken. */
return PCI_ERS_RESULT_CAN_RECOVER;
}
/**
* sym2_io_slot_dump - Enable MMIO and dump debug registers
* @pdev: pointer to PCI device
*/
static pci_ers_result_t sym2_io_slot_dump(struct pci_dev *pdev)
{
struct Scsi_Host *shost = pci_get_drvdata(pdev);
sym_dump_registers(shost);
/* Request a slot reset. */
return PCI_ERS_RESULT_NEED_RESET;
}
/**
* sym2_reset_workarounds - hardware-specific work-arounds
*
* This routine is similar to sym_set_workarounds(), except
* that, at this point, we already know that the device was
* succesfully intialized at least once before, and so most
* of the steps taken there are un-needed here.
*/
static void sym2_reset_workarounds(struct pci_dev *pdev)
{
u_short status_reg;
struct sym_chip *chip;
chip = sym_lookup_chip_table(pdev->device, pdev->revision);
/* Work around for errant bit in 895A, in a fashion
* similar to what is done in sym_set_workarounds().
*/
pci_read_config_word(pdev, PCI_STATUS, &status_reg);
if (!(chip->features & FE_66MHZ) && (status_reg & PCI_STATUS_66MHZ)) {
status_reg = PCI_STATUS_66MHZ;
pci_write_config_word(pdev, PCI_STATUS, status_reg);
pci_read_config_word(pdev, PCI_STATUS, &status_reg);
}
}
/**
* sym2_io_slot_reset() - called when the pci bus has been reset.
* @pdev: pointer to PCI device
*
* Restart the card from scratch.
*/
static pci_ers_result_t sym2_io_slot_reset(struct pci_dev *pdev)
{
struct Scsi_Host *shost = pci_get_drvdata(pdev);
struct sym_hcb *np = sym_get_hcb(shost);
printk(KERN_INFO "%s: recovering from a PCI slot reset\n",
sym_name(np));
if (pci_enable_device(pdev)) {
printk(KERN_ERR "%s: Unable to enable after PCI reset\n",
sym_name(np));
return PCI_ERS_RESULT_DISCONNECT;
}
pci_set_master(pdev);
enable_irq(pdev->irq);
/* If the chip can do Memory Write Invalidate, enable it */
if (np->features & FE_WRIE) {
if (pci_set_mwi(pdev))
return PCI_ERS_RESULT_DISCONNECT;
}
/* Perform work-arounds, analogous to sym_set_workarounds() */
sym2_reset_workarounds(pdev);
/* Perform host reset only on one instance of the card */
if (PCI_FUNC(pdev->devfn) == 0) {
if (sym_reset_scsi_bus(np, 0)) {
printk(KERN_ERR "%s: Unable to reset scsi host\n",
sym_name(np));
return PCI_ERS_RESULT_DISCONNECT;
}
sym_start_up(shost, 1);
}
return PCI_ERS_RESULT_RECOVERED;
}
/**
* sym2_io_resume() - resume normal ops after PCI reset
* @pdev: pointer to PCI device
*
* Called when the error recovery driver tells us that its
* OK to resume normal operation. Use completion to allow
* halted scsi ops to resume.
*/
static void sym2_io_resume(struct pci_dev *pdev)
{
struct Scsi_Host *shost = pci_get_drvdata(pdev);
struct sym_data *sym_data = shost_priv(shost);
spin_lock_irq(shost->host_lock);
if (sym_data->io_reset)
complete_all(sym_data->io_reset);
sym_data->io_reset = NULL;
spin_unlock_irq(shost->host_lock);
}
static void sym2_get_signalling(struct Scsi_Host *shost) static void sym2_get_signalling(struct Scsi_Host *shost)
{ {
struct sym_hcb *np = sym_get_hcb(shost); struct sym_hcb *np = sym_get_hcb(shost);
@ -2050,11 +2045,19 @@ static struct pci_device_id sym2_id_table[] __devinitdata = {
MODULE_DEVICE_TABLE(pci, sym2_id_table); MODULE_DEVICE_TABLE(pci, sym2_id_table);
static struct pci_error_handlers sym2_err_handler = {
.error_detected = sym2_io_error_detected,
.mmio_enabled = sym2_io_slot_dump,
.slot_reset = sym2_io_slot_reset,
.resume = sym2_io_resume,
};
static struct pci_driver sym2_driver = { static struct pci_driver sym2_driver = {
.name = NAME53C8XX, .name = NAME53C8XX,
.id_table = sym2_id_table, .id_table = sym2_id_table,
.probe = sym2_probe, .probe = sym2_probe,
.remove = __devexit_p(sym2_remove), .remove = __devexit_p(sym2_remove),
.err_handler = &sym2_err_handler,
}; };
static int __init sym2_init(void) static int __init sym2_init(void)

16
drivers/scsi/sym53c8xx_2/sym_glue.h
View File

@ -40,7 +40,9 @@
#ifndef SYM_GLUE_H #ifndef SYM_GLUE_H
#define SYM_GLUE_H #define SYM_GLUE_H
#include <linux/completion.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/ioport.h> #include <linux/ioport.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/string.h> #include <linux/string.h>
@ -177,14 +179,11 @@ struct sym_shcb {
int unit; int unit;
char inst_name[16]; char inst_name[16];
char chip_name[8]; char chip_name[8];
struct pci_dev *device;
struct Scsi_Host *host; struct Scsi_Host *host;
void __iomem * ioaddr; /* MMIO kernel io address */ void __iomem * ioaddr; /* MMIO kernel io address */
void __iomem * ramaddr; /* RAM kernel io address */ void __iomem * ramaddr; /* RAM kernel io address */
u_short io_ws; /* IO window size */
int irq; /* IRQ number */
struct timer_list timer; /* Timer handler link header */ struct timer_list timer; /* Timer handler link header */
u_long lasttime; u_long lasttime;
@ -212,20 +211,21 @@ struct sym_device {
} s; } s;
struct sym_chip chip; struct sym_chip chip;
struct sym_nvram *nvram; struct sym_nvram *nvram;
u_short device_id;
u_char host_id; u_char host_id;
}; };
/* /*
* Driver host data structure. * Driver host data structure.
*/ */
struct host_data { struct sym_data {
struct sym_hcb *ncb; struct sym_hcb *ncb;
struct completion *io_reset; /* PCI error handling */
struct pci_dev *pdev;
}; };
static inline struct sym_hcb * sym_get_hcb(struct Scsi_Host *host) static inline struct sym_hcb * sym_get_hcb(struct Scsi_Host *host)
{ {
return ((struct host_data *)host->hostdata)->ncb; return ((struct sym_data *)host->hostdata)->ncb;
} }
#include "sym_fw.h" #include "sym_fw.h"
@ -263,8 +263,8 @@ void sym_set_cam_result_error(struct sym_hcb *np, struct sym_ccb *cp, int resid)
void sym_xpt_done(struct sym_hcb *np, struct scsi_cmnd *ccb); void sym_xpt_done(struct sym_hcb *np, struct scsi_cmnd *ccb);
#define sym_print_addr(cmd, arg...) dev_info(&cmd->device->sdev_gendev , ## arg) #define sym_print_addr(cmd, arg...) dev_info(&cmd->device->sdev_gendev , ## arg)
void sym_xpt_async_bus_reset(struct sym_hcb *np); void sym_xpt_async_bus_reset(struct sym_hcb *np);
void sym_xpt_async_sent_bdr(struct sym_hcb *np, int target);
int sym_setup_data_and_start (struct sym_hcb *np, struct scsi_cmnd *csio, struct sym_ccb *cp); int sym_setup_data_and_start (struct sym_hcb *np, struct scsi_cmnd *csio, struct sym_ccb *cp);
void sym_log_bus_error(struct sym_hcb *np); void sym_log_bus_error(struct Scsi_Host *);
void sym_dump_registers(struct Scsi_Host *);
#endif /* SYM_GLUE_H */ #endif /* SYM_GLUE_H */

151
drivers/scsi/sym53c8xx_2/sym_hipd.c
View File

@ -52,7 +52,7 @@
* Needed function prototypes. * Needed function prototypes.
*/ */
static void sym_int_ma (struct sym_hcb *np); static void sym_int_ma (struct sym_hcb *np);
static void sym_int_sir (struct sym_hcb *np); static void sym_int_sir(struct sym_hcb *);
static struct sym_ccb *sym_alloc_ccb(struct sym_hcb *np); static struct sym_ccb *sym_alloc_ccb(struct sym_hcb *np);
static struct sym_ccb *sym_ccb_from_dsa(struct sym_hcb *np, u32 dsa); static struct sym_ccb *sym_ccb_from_dsa(struct sym_hcb *np, u32 dsa);
static void sym_alloc_lcb_tags (struct sym_hcb *np, u_char tn, u_char ln); static void sym_alloc_lcb_tags (struct sym_hcb *np, u_char tn, u_char ln);
@ -684,6 +684,8 @@ static void sym_set_bus_mode(struct sym_hcb *np, struct sym_nvram *nvram)
*/ */
static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, struct sym_nvram *nvram) static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, struct sym_nvram *nvram)
{ {
struct sym_data *sym_data = shost_priv(shost);
struct pci_dev *pdev = sym_data->pdev;
u_char burst_max; u_char burst_max;
u32 period; u32 period;
int i; int i;
@ -778,19 +780,12 @@ static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, stru
* 64 bit addressing (895A/896/1010) ? * 64 bit addressing (895A/896/1010) ?
*/ */
if (np->features & FE_DAC) { if (np->features & FE_DAC) {
#if SYM_CONF_DMA_ADDRESSING_MODE == 0 if (!use_dac(np))
np->rv_ccntl1 |= (DDAC); np->rv_ccntl1 |= (DDAC);
#elif SYM_CONF_DMA_ADDRESSING_MODE == 1 else if (SYM_CONF_DMA_ADDRESSING_MODE == 1)
if (!np->use_dac)
np->rv_ccntl1 |= (DDAC);
else
np->rv_ccntl1 |= (XTIMOD | EXTIBMV); np->rv_ccntl1 |= (XTIMOD | EXTIBMV);
#elif SYM_CONF_DMA_ADDRESSING_MODE == 2 else if (SYM_CONF_DMA_ADDRESSING_MODE == 2)
if (!np->use_dac)
np->rv_ccntl1 |= (DDAC);
else
np->rv_ccntl1 |= (0 | EXTIBMV); np->rv_ccntl1 |= (0 | EXTIBMV);
#endif
} }
/* /*
@ -804,8 +799,8 @@ static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, stru
* In dual channel mode, contention occurs if internal cycles * In dual channel mode, contention occurs if internal cycles
* are used. Disable internal cycles. * are used. Disable internal cycles.
*/ */
if (np->device_id == PCI_DEVICE_ID_LSI_53C1010_33 && if (pdev->device == PCI_DEVICE_ID_LSI_53C1010_33 &&
np->revision_id < 0x1) pdev->revision < 0x1)
np->rv_ccntl0 |= DILS; np->rv_ccntl0 |= DILS;
/* /*
@ -828,10 +823,10 @@ static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, stru
* this driver. The generic ncr driver that does not use * this driver. The generic ncr driver that does not use
* LOAD/STORE instructions does not need this work-around. * LOAD/STORE instructions does not need this work-around.
*/ */
if ((np->device_id == PCI_DEVICE_ID_NCR_53C810 && if ((pdev->device == PCI_DEVICE_ID_NCR_53C810 &&
np->revision_id >= 0x10 && np->revision_id <= 0x11) || pdev->revision >= 0x10 && pdev->revision <= 0x11) ||
(np->device_id == PCI_DEVICE_ID_NCR_53C860 && (pdev->device == PCI_DEVICE_ID_NCR_53C860 &&
np->revision_id <= 0x1)) pdev->revision <= 0x1))
np->features &= ~(FE_WRIE|FE_ERL|FE_ERMP); np->features &= ~(FE_WRIE|FE_ERL|FE_ERMP);
/* /*
@ -897,7 +892,7 @@ static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, stru
if ((SYM_SETUP_SCSI_LED || if ((SYM_SETUP_SCSI_LED ||
(nvram->type == SYM_SYMBIOS_NVRAM || (nvram->type == SYM_SYMBIOS_NVRAM ||
(nvram->type == SYM_TEKRAM_NVRAM && (nvram->type == SYM_TEKRAM_NVRAM &&
np->device_id == PCI_DEVICE_ID_NCR_53C895))) && pdev->device == PCI_DEVICE_ID_NCR_53C895))) &&
!(np->features & FE_LEDC) && !(np->sv_gpcntl & 0x01)) !(np->features & FE_LEDC) && !(np->sv_gpcntl & 0x01))
np->features |= FE_LED0; np->features |= FE_LED0;
@ -1135,8 +1130,9 @@ static int sym_snooptest(struct sym_hcb *np)
* First 24 register of the chip: * First 24 register of the chip:
* r0..rf * r0..rf
*/ */
static void sym_log_hard_error(struct sym_hcb *np, u_short sist, u_char dstat) static void sym_log_hard_error(struct Scsi_Host *shost, u_short sist, u_char dstat)
{ {
struct sym_hcb *np = sym_get_hcb(shost);
u32 dsp; u32 dsp;
int script_ofs; int script_ofs;
int script_size; int script_size;
@ -1180,16 +1176,27 @@ static void sym_log_hard_error(struct sym_hcb *np, u_short sist, u_char dstat)
scr_to_cpu((int) *(u32 *)(script_base + script_ofs))); scr_to_cpu((int) *(u32 *)(script_base + script_ofs)));
} }
printf ("%s: regdump:", sym_name(np)); printf("%s: regdump:", sym_name(np));
for (i=0; i<24;i++) for (i = 0; i < 24; i++)
printf (" %02x", (unsigned)INB_OFF(np, i)); printf(" %02x", (unsigned)INB_OFF(np, i));
printf (".\n"); printf(".\n");
/* /*
* PCI BUS error. * PCI BUS error.
*/ */
if (dstat & (MDPE|BF)) if (dstat & (MDPE|BF))
sym_log_bus_error(np); sym_log_bus_error(shost);
}
void sym_dump_registers(struct Scsi_Host *shost)
{
struct sym_hcb *np = sym_get_hcb(shost);
u_short sist;
u_char dstat;
sist = INW(np, nc_sist);
dstat = INB(np, nc_dstat);
sym_log_hard_error(shost, sist, dstat);
} }
static struct sym_chip sym_dev_table[] = { static struct sym_chip sym_dev_table[] = {
@ -1312,7 +1319,7 @@ int sym_lookup_dmap(struct sym_hcb *np, u32 h, int s)
{ {
int i; int i;
if (!np->use_dac) if (!use_dac(np))
goto weird; goto weird;
/* Look up existing mappings */ /* Look up existing mappings */
@ -1519,7 +1526,8 @@ void sym_put_start_queue(struct sym_hcb *np, struct sym_ccb *cp)
np->squeueput = qidx; np->squeueput = qidx;
if (DEBUG_FLAGS & DEBUG_QUEUE) if (DEBUG_FLAGS & DEBUG_QUEUE)
printf ("%s: queuepos=%d.\n", sym_name (np), np->squeueput); scmd_printk(KERN_DEBUG, cp->cmd, "queuepos=%d\n",
np->squeueput);
/* /*
* Script processor may be waiting for reselect. * Script processor may be waiting for reselect.
@ -1696,8 +1704,11 @@ static void sym_flush_busy_queue (struct sym_hcb *np, int cam_status)
* 1: SCSI BUS RESET delivered or received. * 1: SCSI BUS RESET delivered or received.
* 2: SCSI BUS MODE changed. * 2: SCSI BUS MODE changed.
*/ */
void sym_start_up (struct sym_hcb *np, int reason) void sym_start_up(struct Scsi_Host *shost, int reason)
{ {
struct sym_data *sym_data = shost_priv(shost);
struct pci_dev *pdev = sym_data->pdev;
struct sym_hcb *np = sym_data->ncb;
int i; int i;
u32 phys; u32 phys;
@ -1746,7 +1757,7 @@ void sym_start_up (struct sym_hcb *np, int reason)
* This also let point to first position the start * This also let point to first position the start
* and done queue pointers used from SCRIPTS. * and done queue pointers used from SCRIPTS.
*/ */
np->fw_patch(np); np->fw_patch(shost);
/* /*
* Wakeup all pending jobs. * Wakeup all pending jobs.
@ -1788,7 +1799,7 @@ void sym_start_up (struct sym_hcb *np, int reason)
/* /*
* For now, disable AIP generation on C1010-66. * For now, disable AIP generation on C1010-66.
*/ */
if (np->device_id == PCI_DEVICE_ID_LSI_53C1010_66) if (pdev->device == PCI_DEVICE_ID_LSI_53C1010_66)
OUTB(np, nc_aipcntl1, DISAIP); OUTB(np, nc_aipcntl1, DISAIP);
/* /*
@ -1798,8 +1809,8 @@ void sym_start_up (struct sym_hcb *np, int reason)
* that from SCRIPTS for each selection/reselection, but * that from SCRIPTS for each selection/reselection, but
* I just don't want. :) * I just don't want. :)
*/ */
if (np->device_id == PCI_DEVICE_ID_LSI_53C1010_33 && if (pdev->device == PCI_DEVICE_ID_LSI_53C1010_33 &&
np->revision_id < 1) pdev->revision < 1)
OUTB(np, nc_stest1, INB(np, nc_stest1) | 0x30); OUTB(np, nc_stest1, INB(np, nc_stest1) | 0x30);
/* /*
@ -1807,9 +1818,9 @@ void sym_start_up (struct sym_hcb *np, int reason)
* Disable overlapped arbitration for some dual function devices, * Disable overlapped arbitration for some dual function devices,
* regardless revision id (kind of post-chip-design feature. ;-)) * regardless revision id (kind of post-chip-design feature. ;-))
*/ */
if (np->device_id == PCI_DEVICE_ID_NCR_53C875) if (pdev->device == PCI_DEVICE_ID_NCR_53C875)
OUTB(np, nc_ctest0, (1<<5)); OUTB(np, nc_ctest0, (1<<5));
else if (np->device_id == PCI_DEVICE_ID_NCR_53C896) else if (pdev->device == PCI_DEVICE_ID_NCR_53C896)
np->rv_ccntl0 |= DPR; np->rv_ccntl0 |= DPR;
/* /*
@ -1827,7 +1838,7 @@ void sym_start_up (struct sym_hcb *np, int reason)
* Set up scratch C and DRS IO registers to map the 32 bit * Set up scratch C and DRS IO registers to map the 32 bit
* DMA address range our data structures are located in. * DMA address range our data structures are located in.
*/ */
if (np->use_dac) { if (use_dac(np)) {
np->dmap_bah[0] = 0; /* ??? */ np->dmap_bah[0] = 0; /* ??? */
OUTL(np, nc_scrx[0], np->dmap_bah[0]); OUTL(np, nc_scrx[0], np->dmap_bah[0]);
OUTL(np, nc_drs, np->dmap_bah[0]); OUTL(np, nc_drs, np->dmap_bah[0]);
@ -1900,7 +1911,7 @@ void sym_start_up (struct sym_hcb *np, int reason)
if (sym_verbose >= 2) if (sym_verbose >= 2)
printf("%s: Downloading SCSI SCRIPTS.\n", sym_name(np)); printf("%s: Downloading SCSI SCRIPTS.\n", sym_name(np));
memcpy_toio(np->s.ramaddr, np->scripta0, np->scripta_sz); memcpy_toio(np->s.ramaddr, np->scripta0, np->scripta_sz);
if (np->ram_ws == 8192) { if (np->features & FE_RAM8K) {
memcpy_toio(np->s.ramaddr + 4096, np->scriptb0, np->scriptb_sz); memcpy_toio(np->s.ramaddr + 4096, np->scriptb0, np->scriptb_sz);
phys = scr_to_cpu(np->scr_ram_seg); phys = scr_to_cpu(np->scr_ram_seg);
OUTL(np, nc_mmws, phys); OUTL(np, nc_mmws, phys);
@ -2214,8 +2225,9 @@ static void sym_int_udc (struct sym_hcb *np)
* mode to eight bit asynchronous, etc... * mode to eight bit asynchronous, etc...
* So, just reinitializing all except chip should be enough. * So, just reinitializing all except chip should be enough.
*/ */
static void sym_int_sbmc (struct sym_hcb *np) static void sym_int_sbmc(struct Scsi_Host *shost)
{ {
struct sym_hcb *np = sym_get_hcb(shost);
u_char scsi_mode = INB(np, nc_stest4) & SMODE; u_char scsi_mode = INB(np, nc_stest4) & SMODE;
/* /*
@ -2228,7 +2240,7 @@ static void sym_int_sbmc (struct sym_hcb *np)
* Should suspend command processing for a few seconds and * Should suspend command processing for a few seconds and
* reinitialize all except the chip. * reinitialize all except the chip.
*/ */
sym_start_up (np, 2); sym_start_up(shost, 2);
} }
/* /*
@ -2756,8 +2768,11 @@ static void sym_int_ma (struct sym_hcb *np)
* Use at your own decision and risk. * Use at your own decision and risk.
*/ */
void sym_interrupt (struct sym_hcb *np) irqreturn_t sym_interrupt(struct Scsi_Host *shost)
{ {
struct sym_data *sym_data = shost_priv(shost);
struct sym_hcb *np = sym_data->ncb;
struct pci_dev *pdev = sym_data->pdev;
u_char istat, istatc; u_char istat, istatc;
u_char dstat; u_char dstat;
u_short sist; u_short sist;
@ -2782,7 +2797,7 @@ void sym_interrupt (struct sym_hcb *np)
} }
if (!(istat & (SIP|DIP))) if (!(istat & (SIP|DIP)))
return; return (istat & INTF) ? IRQ_HANDLED : IRQ_NONE;
#if 0 /* We should never get this one */ #if 0 /* We should never get this one */
if (istat & CABRT) if (istat & CABRT)
@ -2809,6 +2824,13 @@ void sym_interrupt (struct sym_hcb *np)
dstat |= INB(np, nc_dstat); dstat |= INB(np, nc_dstat);
istatc = INB(np, nc_istat); istatc = INB(np, nc_istat);
istat |= istatc; istat |= istatc;
/* Prevent deadlock waiting on a condition that may
* never clear. */
if (unlikely(sist == 0xffff && dstat == 0xff)) {
if (pci_channel_offline(pdev))
return IRQ_NONE;
}
} while (istatc & (SIP|DIP)); } while (istatc & (SIP|DIP));
if (DEBUG_FLAGS & DEBUG_TINY) if (DEBUG_FLAGS & DEBUG_TINY)
@ -2842,10 +2864,10 @@ void sym_interrupt (struct sym_hcb *np)
!(dstat & (MDPE|BF|ABRT|IID))) { !(dstat & (MDPE|BF|ABRT|IID))) {
if (sist & PAR) sym_int_par (np, sist); if (sist & PAR) sym_int_par (np, sist);
else if (sist & MA) sym_int_ma (np); else if (sist & MA) sym_int_ma (np);
else if (dstat & SIR) sym_int_sir (np); else if (dstat & SIR) sym_int_sir(np);
else if (dstat & SSI) OUTONB_STD(); else if (dstat & SSI) OUTONB_STD();
else goto unknown_int; else goto unknown_int;
return; return IRQ_HANDLED;
} }
/* /*
@ -2861,8 +2883,8 @@ void sym_interrupt (struct sym_hcb *np)
*/ */
if (sist & RST) { if (sist & RST) {
printf("%s: SCSI BUS reset detected.\n", sym_name(np)); printf("%s: SCSI BUS reset detected.\n", sym_name(np));
sym_start_up (np, 1); sym_start_up(shost, 1);
return; return IRQ_HANDLED;
} }
OUTB(np, nc_ctest3, np->rv_ctest3 | CLF); /* clear dma fifo */ OUTB(np, nc_ctest3, np->rv_ctest3 | CLF); /* clear dma fifo */
@ -2870,11 +2892,11 @@ void sym_interrupt (struct sym_hcb *np)
if (!(sist & (GEN|HTH|SGE)) && if (!(sist & (GEN|HTH|SGE)) &&
!(dstat & (MDPE|BF|ABRT|IID))) { !(dstat & (MDPE|BF|ABRT|IID))) {
if (sist & SBMC) sym_int_sbmc (np); if (sist & SBMC) sym_int_sbmc(shost);
else if (sist & STO) sym_int_sto (np); else if (sist & STO) sym_int_sto (np);
else if (sist & UDC) sym_int_udc (np); else if (sist & UDC) sym_int_udc (np);
else goto unknown_int; else goto unknown_int;
return; return IRQ_HANDLED;
} }
/* /*
@ -2884,12 +2906,12 @@ void sym_interrupt (struct sym_hcb *np)
* Reset everything. * Reset everything.
*/ */
sym_log_hard_error(np, sist, dstat); sym_log_hard_error(shost, sist, dstat);
if ((sist & (GEN|HTH|SGE)) || if ((sist & (GEN|HTH|SGE)) ||
(dstat & (MDPE|BF|ABRT|IID))) { (dstat & (MDPE|BF|ABRT|IID))) {
sym_start_reset(np); sym_start_reset(np);
return; return IRQ_HANDLED;
} }
unknown_int: unknown_int:
@ -2900,6 +2922,7 @@ void sym_interrupt (struct sym_hcb *np)
printf( "%s: unknown interrupt(s) ignored, " printf( "%s: unknown interrupt(s) ignored, "
"ISTAT=0x%x DSTAT=0x%x SIST=0x%x\n", "ISTAT=0x%x DSTAT=0x%x SIST=0x%x\n",
sym_name(np), istat, dstat, sist); sym_name(np), istat, dstat, sist);
return IRQ_NONE;
} }
/* /*
@ -3520,7 +3543,8 @@ static void sym_sir_task_recovery(struct sym_hcb *np, int num)
* If we sent a BDR, make upper layer aware of that. * If we sent a BDR, make upper layer aware of that.
*/ */
if (np->abrt_msg[0] == M_RESET) if (np->abrt_msg[0] == M_RESET)
sym_xpt_async_sent_bdr(np, target); starget_printk(KERN_NOTICE, starget,
"has been reset\n");
break; break;
} }
@ -4304,7 +4328,7 @@ static void sym_nego_rejected(struct sym_hcb *np, struct sym_tcb *tp, struct sym
/* /*
* chip exception handler for programmed interrupts. * chip exception handler for programmed interrupts.
*/ */
static void sym_int_sir (struct sym_hcb *np) static void sym_int_sir(struct sym_hcb *np)
{ {
u_char num = INB(np, nc_dsps); u_char num = INB(np, nc_dsps);
u32 dsa = INL(np, nc_dsa); u32 dsa = INL(np, nc_dsa);
@ -4343,31 +4367,30 @@ static void sym_int_sir (struct sym_hcb *np)
return; return;
/* /*
* The device didn't go to MSG OUT phase after having * The device didn't go to MSG OUT phase after having
* been selected with ATN. We donnot want to handle * been selected with ATN. We do not want to handle that.
* that.
*/ */
case SIR_SEL_ATN_NO_MSG_OUT: case SIR_SEL_ATN_NO_MSG_OUT:
printf ("%s:%d: No MSG OUT phase after selection with ATN.\n", scmd_printk(KERN_WARNING, cp->cmd,
sym_name (np), target); "No MSG OUT phase after selection with ATN\n");
goto out_stuck; goto out_stuck;
/* /*
* The device didn't switch to MSG IN phase after * The device didn't switch to MSG IN phase after
* having reseleted the initiator. * having reselected the initiator.
*/ */
case SIR_RESEL_NO_MSG_IN: case SIR_RESEL_NO_MSG_IN:
printf ("%s:%d: No MSG IN phase after reselection.\n", scmd_printk(KERN_WARNING, cp->cmd,
sym_name (np), target); "No MSG IN phase after reselection\n");
goto out_stuck; goto out_stuck;
/* /*
* After reselection, the device sent a message that wasn't * After reselection, the device sent a message that wasn't
* an IDENTIFY. * an IDENTIFY.
*/ */
case SIR_RESEL_NO_IDENTIFY: case SIR_RESEL_NO_IDENTIFY:
printf ("%s:%d: No IDENTIFY after reselection.\n", scmd_printk(KERN_WARNING, cp->cmd,
sym_name (np), target); "No IDENTIFY after reselection\n");
goto out_stuck; goto out_stuck;
/* /*
* The device reselected a LUN we donnot know about. * The device reselected a LUN we do not know about.
*/ */
case SIR_RESEL_BAD_LUN: case SIR_RESEL_BAD_LUN:
np->msgout[0] = M_RESET; np->msgout[0] = M_RESET;
@ -4380,8 +4403,7 @@ static void sym_int_sir (struct sym_hcb *np)
np->msgout[0] = M_ABORT; np->msgout[0] = M_ABORT;
goto out; goto out;
/* /*
* The device reselected for a tagged nexus that we donnot * The device reselected for a tagged nexus that we do not have.
* have.
*/ */
case SIR_RESEL_BAD_I_T_L_Q: case SIR_RESEL_BAD_I_T_L_Q:
np->msgout[0] = M_ABORT_TAG; np->msgout[0] = M_ABORT_TAG;
@ -4393,8 +4415,8 @@ static void sym_int_sir (struct sym_hcb *np)
case SIR_RESEL_ABORTED: case SIR_RESEL_ABORTED:
np->lastmsg = np->msgout[0]; np->lastmsg = np->msgout[0];
np->msgout[0] = M_NOOP; np->msgout[0] = M_NOOP;
printf ("%s:%d: message %x sent on bad reselection.\n", scmd_printk(KERN_WARNING, cp->cmd,
sym_name (np), target, np->lastmsg); "message %x sent on bad reselection\n", np->lastmsg);
goto out; goto out;
/* /*
* The SCRIPTS let us know that a message has been * The SCRIPTS let us know that a message has been
@ -5580,14 +5602,11 @@ int sym_hcb_attach(struct Scsi_Host *shost, struct sym_fw *fw, struct sym_nvram
if (np->ram_ba) { if (np->ram_ba) {
np->scripta_ba = np->ram_ba; np->scripta_ba = np->ram_ba;
if (np->features & FE_RAM8K) { if (np->features & FE_RAM8K) {
np->ram_ws = 8192;
np->scriptb_ba = np->scripta_ba + 4096; np->scriptb_ba = np->scripta_ba + 4096;
#if 0 /* May get useful for 64 BIT PCI addressing */ #if 0 /* May get useful for 64 BIT PCI addressing */
np->scr_ram_seg = cpu_to_scr(np->scripta_ba >> 32); np->scr_ram_seg = cpu_to_scr(np->scripta_ba >> 32);
#endif #endif
} }
else
np->ram_ws = 4096;
} }
/* /*

22
drivers/scsi/sym53c8xx_2/sym_hipd.h
View File

@ -883,10 +883,7 @@ struct sym_hcb {
* Physical bus addresses of the chip. * Physical bus addresses of the chip.
*/ */
u32 mmio_ba; /* MMIO 32 bit BUS address */ u32 mmio_ba; /* MMIO 32 bit BUS address */
int mmio_ws; /* MMIO Window size */
u32 ram_ba; /* RAM 32 bit BUS address */ u32 ram_ba; /* RAM 32 bit BUS address */
int ram_ws; /* RAM window size */
/* /*
* SCRIPTS virtual and physical bus addresses. * SCRIPTS virtual and physical bus addresses.
@ -912,14 +909,12 @@ struct sym_hcb {
struct sym_fwb_ba fwb_bas; /* Useful SCRIPTB bus addresses */ struct sym_fwb_ba fwb_bas; /* Useful SCRIPTB bus addresses */
struct sym_fwz_ba fwz_bas; /* Useful SCRIPTZ bus addresses */ struct sym_fwz_ba fwz_bas; /* Useful SCRIPTZ bus addresses */
void (*fw_setup)(struct sym_hcb *np, struct sym_fw *fw); void (*fw_setup)(struct sym_hcb *np, struct sym_fw *fw);
void (*fw_patch)(struct sym_hcb *np); void (*fw_patch)(struct Scsi_Host *);
char *fw_name; char *fw_name;
/* /*
* General controller parameters and configuration. * General controller parameters and configuration.
*/ */
u_short device_id; /* PCI device id */
u_char revision_id; /* PCI device revision id */
u_int features; /* Chip features map */ u_int features; /* Chip features map */
u_char myaddr; /* SCSI id of the adapter */ u_char myaddr; /* SCSI id of the adapter */
u_char maxburst; /* log base 2 of dwords burst */ u_char maxburst; /* log base 2 of dwords burst */
@ -1031,6 +1026,14 @@ struct sym_hcb {
#endif #endif
}; };
#if SYM_CONF_DMA_ADDRESSING_MODE == 0
#define use_dac(np) 0
#define set_dac(np) do { } while (0)
#else
#define use_dac(np) (np)->use_dac
#define set_dac(np) (np)->use_dac = 1
#endif
#define HCB_BA(np, lbl) (np->hcb_ba + offsetof(struct sym_hcb, lbl)) #define HCB_BA(np, lbl) (np->hcb_ba + offsetof(struct sym_hcb, lbl))
@ -1052,8 +1055,8 @@ void sym_start_next_ccbs(struct sym_hcb *np, struct sym_lcb *lp, int maxn);
#else #else
void sym_put_start_queue(struct sym_hcb *np, struct sym_ccb *cp); void sym_put_start_queue(struct sym_hcb *np, struct sym_ccb *cp);
#endif #endif
void sym_start_up(struct sym_hcb *np, int reason); void sym_start_up(struct Scsi_Host *, int reason);
void sym_interrupt(struct sym_hcb *np); irqreturn_t sym_interrupt(struct Scsi_Host *);
int sym_clear_tasks(struct sym_hcb *np, int cam_status, int target, int lun, int task); int sym_clear_tasks(struct sym_hcb *np, int cam_status, int target, int lun, int task);
struct sym_ccb *sym_get_ccb(struct sym_hcb *np, struct scsi_cmnd *cmd, u_char tag_order); struct sym_ccb *sym_get_ccb(struct sym_hcb *np, struct scsi_cmnd *cmd, u_char tag_order);
void sym_free_ccb(struct sym_hcb *np, struct sym_ccb *cp); void sym_free_ccb(struct sym_hcb *np, struct sym_ccb *cp);
@ -1073,18 +1076,21 @@ int sym_hcb_attach(struct Scsi_Host *shost, struct sym_fw *fw, struct sym_nvram
*/ */
#if SYM_CONF_DMA_ADDRESSING_MODE == 0 #if SYM_CONF_DMA_ADDRESSING_MODE == 0
#define DMA_DAC_MASK DMA_32BIT_MASK
#define sym_build_sge(np, data, badd, len) \ #define sym_build_sge(np, data, badd, len) \
do { \ do { \
(data)->addr = cpu_to_scr(badd); \ (data)->addr = cpu_to_scr(badd); \
(data)->size = cpu_to_scr(len); \ (data)->size = cpu_to_scr(len); \
} while (0) } while (0)
#elif SYM_CONF_DMA_ADDRESSING_MODE == 1 #elif SYM_CONF_DMA_ADDRESSING_MODE == 1
#define DMA_DAC_MASK DMA_40BIT_MASK
#define sym_build_sge(np, data, badd, len) \ #define sym_build_sge(np, data, badd, len) \
do { \ do { \
(data)->addr = cpu_to_scr(badd); \ (data)->addr = cpu_to_scr(badd); \
(data)->size = cpu_to_scr((((badd) >> 8) & 0xff000000) + len); \ (data)->size = cpu_to_scr((((badd) >> 8) & 0xff000000) + len); \
} while (0) } while (0)
#elif SYM_CONF_DMA_ADDRESSING_MODE == 2 #elif SYM_CONF_DMA_ADDRESSING_MODE == 2
#define DMA_DAC_MASK DMA_64BIT_MASK
int sym_lookup_dmap(struct sym_hcb *np, u32 h, int s); int sym_lookup_dmap(struct sym_hcb *np, u32 h, int s);
static __inline void static __inline void
sym_build_sge(struct sym_hcb *np, struct sym_tblmove *data, u64 badd, int len) sym_build_sge(struct sym_hcb *np, struct sym_tblmove *data, u64 badd, int len)

2
drivers/scsi/sym53c8xx_2/sym_nvram.c
View File

@ -696,7 +696,7 @@ static int sym_read_Tekram_nvram (struct sym_device *np, Tekram_nvram *nvram)
u_short csum; u_short csum;
int x; int x;
switch (np->device_id) { switch (np->pdev->device) {
case PCI_DEVICE_ID_NCR_53C885: case PCI_DEVICE_ID_NCR_53C885:
case PCI_DEVICE_ID_NCR_53C895: case PCI_DEVICE_ID_NCR_53C895:
case PCI_DEVICE_ID_NCR_53C896: case PCI_DEVICE_ID_NCR_53C896:

2
include/scsi/scsi_eh.h
View File

@ -1,6 +1,8 @@
#ifndef _SCSI_SCSI_EH_H #ifndef _SCSI_SCSI_EH_H
#define _SCSI_SCSI_EH_H #define _SCSI_SCSI_EH_H
#include <linux/scatterlist.h>
#include <scsi/scsi_cmnd.h> #include <scsi/scsi_cmnd.h>
struct scsi_device; struct scsi_device;
struct Scsi_Host; struct Scsi_Host;