2005-01-06 01:43:34 +00:00
|
|
|
/*-
|
2002-08-11 23:34:20 +00:00
|
|
|
* Debug routines for LSI '909 FC adapters.
|
|
|
|
* FreeBSD Version.
|
|
|
|
*
|
|
|
|
* Copyright (c) 2000, 2001 by Greg Ansley
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice immediately at the beginning of the file, without modification,
|
|
|
|
* this list of conditions, and the following disclaimer.
|
|
|
|
* 2. The name of the author may not be used to endorse or promote products
|
|
|
|
* derived from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
|
|
|
|
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
*
|
2006-02-25 07:45:54 +00:00
|
|
|
*/
|
|
|
|
/*-
|
|
|
|
* Copyright (c) 2002, 2006 by Matthew Jacob
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are
|
|
|
|
* met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
|
|
|
|
* substantially similar to the "NO WARRANTY" disclaimer below
|
|
|
|
* ("Disclaimer") and any redistribution must be conditioned upon including
|
|
|
|
* a substantially similar Disclaimer requirement for further binary
|
|
|
|
* redistribution.
|
|
|
|
* 3. Neither the names of the above listed copyright holders nor the names
|
|
|
|
* of any contributors may be used to endorse or promote products derived
|
|
|
|
* from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF THE COPYRIGHT
|
|
|
|
* OWNER OR CONTRIBUTOR IS ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* Support from Chris Ellsworth in order to make SAS adapters work
|
|
|
|
* is gratefully acknowledged.
|
2006-05-29 20:34:28 +00:00
|
|
|
*
|
|
|
|
* Support from LSI-Logic has also gone a great deal toward making this a
|
|
|
|
* workable subsystem and is gratefully acknowledged.
|
2002-08-11 23:34:20 +00:00
|
|
|
*/
|
|
|
|
|
2004-08-21 17:44:57 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
#include <dev/mpt/mpt.h>
|
|
|
|
|
|
|
|
#include <dev/mpt/mpilib/mpi_ioc.h>
|
|
|
|
#include <dev/mpt/mpilib/mpi_init.h>
|
|
|
|
#include <dev/mpt/mpilib/mpi_fc.h>
|
2006-03-25 07:08:27 +00:00
|
|
|
#include <dev/mpt/mpilib/mpi_targ.h>
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
|
|
|
|
#include <cam/scsi/scsi_all.h>
|
|
|
|
|
2002-09-24 21:33:43 +00:00
|
|
|
#include <machine/stdarg.h> /* for use by mpt_prt below */
|
2002-08-11 23:34:20 +00:00
|
|
|
|
|
|
|
struct Error_Map {
|
|
|
|
int Error_Code;
|
|
|
|
char *Error_String;
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct Error_Map IOC_Status[] = {
|
|
|
|
{ MPI_IOCSTATUS_SUCCESS, "Success" },
|
|
|
|
{ MPI_IOCSTATUS_INVALID_FUNCTION, "IOC: Invalid Function" },
|
|
|
|
{ MPI_IOCSTATUS_BUSY, "IOC: Busy" },
|
|
|
|
{ MPI_IOCSTATUS_INVALID_SGL, "IOC: Invalid SGL" },
|
|
|
|
{ MPI_IOCSTATUS_INTERNAL_ERROR, "IOC: Internal Error" },
|
|
|
|
{ MPI_IOCSTATUS_RESERVED, "IOC: Reserved" },
|
|
|
|
{ MPI_IOCSTATUS_INSUFFICIENT_RESOURCES, "IOC: Insufficient Resources" },
|
|
|
|
{ MPI_IOCSTATUS_INVALID_FIELD, "IOC: Invalid Field" },
|
|
|
|
{ MPI_IOCSTATUS_INVALID_STATE, "IOC: Invalid State" },
|
|
|
|
{ MPI_IOCSTATUS_CONFIG_INVALID_ACTION, "Invalid Action" },
|
|
|
|
{ MPI_IOCSTATUS_CONFIG_INVALID_TYPE, "Invalid Type" },
|
|
|
|
{ MPI_IOCSTATUS_CONFIG_INVALID_PAGE, "Invalid Page" },
|
|
|
|
{ MPI_IOCSTATUS_CONFIG_INVALID_DATA, "Invalid Data" },
|
|
|
|
{ MPI_IOCSTATUS_CONFIG_NO_DEFAULTS, "No Defaults" },
|
|
|
|
{ MPI_IOCSTATUS_CONFIG_CANT_COMMIT, "Can't Commit" },
|
|
|
|
{ MPI_IOCSTATUS_SCSI_RECOVERED_ERROR, "SCSI: Recoverd Error" },
|
|
|
|
{ MPI_IOCSTATUS_SCSI_INVALID_BUS, "SCSI: Invalid Bus" },
|
|
|
|
{ MPI_IOCSTATUS_SCSI_INVALID_TARGETID, "SCSI: Invalid Target ID" },
|
|
|
|
{ MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE, "SCSI: Device Not There" },
|
|
|
|
{ MPI_IOCSTATUS_SCSI_DATA_OVERRUN, "SCSI: Data Overrun" },
|
|
|
|
{ MPI_IOCSTATUS_SCSI_DATA_UNDERRUN, "SCSI: Data Underrun" },
|
|
|
|
{ MPI_IOCSTATUS_SCSI_IO_DATA_ERROR, "SCSI: Data Error" },
|
|
|
|
{ MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR, "SCSI: Protocol Error" },
|
|
|
|
{ MPI_IOCSTATUS_SCSI_TASK_TERMINATED, "SCSI: Task Terminated" },
|
|
|
|
{ MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH, "SCSI: Residual Mismatch" },
|
|
|
|
{ MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED, "SCSI: Task Management Failed" },
|
|
|
|
{ MPI_IOCSTATUS_SCSI_IOC_TERMINATED, "SCSI: IOC Bus Reset" },
|
|
|
|
{ MPI_IOCSTATUS_SCSI_EXT_TERMINATED, "SCSI: External Bus Reset" },
|
|
|
|
{ MPI_IOCSTATUS_TARGET_PRIORITY_IO, "SCSI Target: Priority I/O" },
|
|
|
|
{ MPI_IOCSTATUS_TARGET_INVALID_PORT, "SCSI Target: Invalid Port" },
|
|
|
|
{ MPI_IOCSTATUS_TARGET_INVALID_IOCINDEX, "SCSI Target: Invalid IOC Index" },
|
|
|
|
{ MPI_IOCSTATUS_TARGET_ABORTED, "SCSI Target: Aborted" },
|
|
|
|
{ MPI_IOCSTATUS_TARGET_NO_CONN_RETRYABLE, "SCSI Target: No Connection (Retryable)" },
|
|
|
|
{ MPI_IOCSTATUS_TARGET_NO_CONNECTION, "SCSI Target: No Connection" },
|
|
|
|
{ MPI_IOCSTATUS_TARGET_XFER_COUNT_MISMATCH,"SCSI Target: Transfer Count Mismatch" },
|
|
|
|
{ MPI_IOCSTATUS_TARGET_FC_ABORTED, "FC: Aborted" },
|
|
|
|
{ MPI_IOCSTATUS_TARGET_FC_RX_ID_INVALID, "FC: Recieve ID Invalid" },
|
|
|
|
{ MPI_IOCSTATUS_TARGET_FC_DID_INVALID, "FC: Recieve DID Invalid" },
|
|
|
|
{ MPI_IOCSTATUS_TARGET_FC_NODE_LOGGED_OUT,"FC: Node Logged Out" },
|
|
|
|
{ MPI_IOCSTATUS_LAN_DEVICE_NOT_FOUND, "LAN: Device Not Found" },
|
|
|
|
{ MPI_IOCSTATUS_LAN_DEVICE_FAILURE, "LAN: Device Not Failure" },
|
|
|
|
{ MPI_IOCSTATUS_LAN_TRANSMIT_ERROR, "LAN: Transmit Error" },
|
|
|
|
{ MPI_IOCSTATUS_LAN_TRANSMIT_ABORTED, "LAN: Transmit Aborted" },
|
|
|
|
{ MPI_IOCSTATUS_LAN_RECEIVE_ERROR, "LAN: Recieve Error" },
|
|
|
|
{ MPI_IOCSTATUS_LAN_RECEIVE_ABORTED, "LAN: Recieve Aborted" },
|
|
|
|
{ MPI_IOCSTATUS_LAN_PARTIAL_PACKET, "LAN: Partial Packet" },
|
|
|
|
{ MPI_IOCSTATUS_LAN_CANCELED, "LAN: Canceled" },
|
|
|
|
{ -1, 0},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct Error_Map IOC_Func[] = {
|
|
|
|
{ MPI_FUNCTION_SCSI_IO_REQUEST, "SCSI IO Request" },
|
|
|
|
{ MPI_FUNCTION_SCSI_TASK_MGMT, "SCSI Task Management" },
|
|
|
|
{ MPI_FUNCTION_IOC_INIT, "IOC Init" },
|
|
|
|
{ MPI_FUNCTION_IOC_FACTS, "IOC Facts" },
|
|
|
|
{ MPI_FUNCTION_CONFIG, "Config" },
|
|
|
|
{ MPI_FUNCTION_PORT_FACTS, "Port Facts" },
|
|
|
|
{ MPI_FUNCTION_PORT_ENABLE, "Port Enable" },
|
|
|
|
{ MPI_FUNCTION_EVENT_NOTIFICATION, "Event Notification" },
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
{ MPI_FUNCTION_EVENT_ACK, "Event Ack" },
|
2002-08-11 23:34:20 +00:00
|
|
|
{ MPI_FUNCTION_FW_DOWNLOAD, "FW Download" },
|
|
|
|
{ MPI_FUNCTION_TARGET_CMD_BUFFER_POST, "SCSI Target Command Buffer" },
|
|
|
|
{ MPI_FUNCTION_TARGET_ASSIST, "Target Assist" },
|
|
|
|
{ MPI_FUNCTION_TARGET_STATUS_SEND, "Target Status Send" },
|
|
|
|
{ MPI_FUNCTION_TARGET_MODE_ABORT, "Target Mode Abort" },
|
|
|
|
{ -1, 0},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct Error_Map IOC_Event[] = {
|
|
|
|
{ MPI_EVENT_NONE, "None" },
|
|
|
|
{ MPI_EVENT_LOG_DATA, "LogData" },
|
|
|
|
{ MPI_EVENT_STATE_CHANGE, "State Change" },
|
|
|
|
{ MPI_EVENT_UNIT_ATTENTION, "Unit Attention" },
|
|
|
|
{ MPI_EVENT_IOC_BUS_RESET, "IOC Bus Reset" },
|
|
|
|
{ MPI_EVENT_EXT_BUS_RESET, "External Bus Reset" },
|
|
|
|
{ MPI_EVENT_RESCAN, "Rescan" },
|
|
|
|
{ MPI_EVENT_LINK_STATUS_CHANGE, "Link Status Change" },
|
|
|
|
{ MPI_EVENT_LOOP_STATE_CHANGE, "Loop State Change" },
|
|
|
|
{ MPI_EVENT_LOGOUT, "Logout" },
|
|
|
|
{ MPI_EVENT_EVENT_CHANGE, "EventChange" },
|
|
|
|
{ -1, 0},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct Error_Map IOC_SCSIState[] = {
|
|
|
|
{ MPI_SCSI_STATE_AUTOSENSE_VALID, "AutoSense_Valid" },
|
|
|
|
{ MPI_SCSI_STATE_AUTOSENSE_FAILED, "AutoSense_Failed" },
|
|
|
|
{ MPI_SCSI_STATE_NO_SCSI_STATUS, "No_SCSI_Status" },
|
|
|
|
{ MPI_SCSI_STATE_TERMINATED, "State_Terminated" },
|
|
|
|
{ MPI_SCSI_STATE_RESPONSE_INFO_VALID, "Repsonse_Info_Valid" },
|
|
|
|
{ MPI_SCSI_STATE_QUEUE_TAG_REJECTED, "Queue Tag Rejected" },
|
|
|
|
{ -1, 0},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct Error_Map IOC_SCSIStatus[] = {
|
|
|
|
{ SCSI_STATUS_OK, "OK" },
|
|
|
|
{ SCSI_STATUS_CHECK_COND, "Check Condition" },
|
|
|
|
{ SCSI_STATUS_COND_MET, "Check Condition Met" },
|
|
|
|
{ SCSI_STATUS_BUSY, "Busy" },
|
|
|
|
{ SCSI_STATUS_INTERMED, "Intermidiate Condition" },
|
|
|
|
{ SCSI_STATUS_INTERMED_COND_MET, "Intermidiate Condition Met" },
|
|
|
|
{ SCSI_STATUS_RESERV_CONFLICT, "Reservation Conflict" },
|
|
|
|
{ SCSI_STATUS_CMD_TERMINATED, "Command Terminated" },
|
|
|
|
{ SCSI_STATUS_QUEUE_FULL, "Queue Full" },
|
|
|
|
{ -1, 0},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct Error_Map IOC_Diag[] = {
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
{ MPI_DIAG_DRWE, "DWE" },
|
|
|
|
{ MPI_DIAG_FLASH_BAD_SIG, "FLASH_Bad" },
|
|
|
|
{ MPI_DIAGNOSTIC_OFFSET, "Offset" },
|
|
|
|
{ MPI_DIAG_RESET_ADAPTER, "Reset" },
|
|
|
|
{ MPI_DIAG_DISABLE_ARM, "DisARM" },
|
|
|
|
{ MPI_DIAG_MEM_ENABLE, "DME" },
|
2002-08-11 23:34:20 +00:00
|
|
|
{ -1, 0 },
|
|
|
|
};
|
|
|
|
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
static const struct Error_Map IOC_SCSITMType[] = {
|
|
|
|
{ MPI_SCSITASKMGMT_TASKTYPE_ABORT_TASK, "Abort Task" },
|
|
|
|
{ MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET, "Abort Task Set" },
|
|
|
|
{ MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, "Target Reset" },
|
|
|
|
{ MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS, "Reset Bus" },
|
|
|
|
{ MPI_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET, "Logical Unit Reset" },
|
|
|
|
{ -1, 0 },
|
|
|
|
};
|
2002-08-11 23:34:20 +00:00
|
|
|
|
|
|
|
static char *
|
|
|
|
mpt_ioc_status(int code)
|
|
|
|
{
|
|
|
|
const struct Error_Map *status = IOC_Status;
|
|
|
|
static char buf[64];
|
|
|
|
while (status->Error_Code >= 0) {
|
|
|
|
if (status->Error_Code == (code & MPI_IOCSTATUS_MASK))
|
|
|
|
return status->Error_String;
|
|
|
|
status++;
|
|
|
|
}
|
|
|
|
snprintf(buf, sizeof buf, "Unknown (0x%08x)", code);
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
char *
|
|
|
|
mpt_ioc_diag(u_int32_t code)
|
|
|
|
{
|
|
|
|
const struct Error_Map *status = IOC_Diag;
|
|
|
|
static char buf[128];
|
|
|
|
char *ptr = buf;
|
|
|
|
char *end = &buf[128];
|
|
|
|
buf[0] = '\0';
|
|
|
|
ptr += snprintf(buf, sizeof buf, "(0x%08x)", code);
|
|
|
|
while (status->Error_Code >= 0) {
|
|
|
|
if ((status->Error_Code & code) != 0)
|
|
|
|
ptr += snprintf(ptr, (size_t)(end-ptr), "%s ",
|
|
|
|
status->Error_String);
|
|
|
|
status++;
|
|
|
|
}
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
mpt_ioc_function(int code)
|
|
|
|
{
|
|
|
|
const struct Error_Map *status = IOC_Func;
|
|
|
|
static char buf[64];
|
|
|
|
while (status->Error_Code >= 0) {
|
|
|
|
if (status->Error_Code == code)
|
|
|
|
return status->Error_String;
|
|
|
|
status++;
|
|
|
|
}
|
|
|
|
snprintf(buf, sizeof buf, "Unknown (0x%08x)", code);
|
|
|
|
return buf;
|
|
|
|
}
|
2006-04-01 07:12:18 +00:00
|
|
|
|
2002-08-11 23:34:20 +00:00
|
|
|
static char *
|
|
|
|
mpt_ioc_event(int code)
|
|
|
|
{
|
|
|
|
const struct Error_Map *status = IOC_Event;
|
|
|
|
static char buf[64];
|
|
|
|
while (status->Error_Code >= 0) {
|
|
|
|
if (status->Error_Code == code)
|
|
|
|
return status->Error_String;
|
|
|
|
status++;
|
|
|
|
}
|
|
|
|
snprintf(buf, sizeof buf, "Unknown (0x%08x)", code);
|
|
|
|
return buf;
|
|
|
|
}
|
2006-04-01 07:12:18 +00:00
|
|
|
|
2002-08-11 23:34:20 +00:00
|
|
|
static char *
|
|
|
|
mpt_scsi_state(int code)
|
|
|
|
{
|
|
|
|
const struct Error_Map *status = IOC_SCSIState;
|
|
|
|
static char buf[128];
|
|
|
|
char *ptr = buf;
|
|
|
|
char *end = &buf[128];
|
|
|
|
buf[0] = '\0';
|
|
|
|
ptr += snprintf(buf, sizeof buf, "(0x%08x)", code);
|
|
|
|
while (status->Error_Code >= 0) {
|
|
|
|
if ((status->Error_Code & code) != 0)
|
|
|
|
ptr += snprintf(ptr, (size_t)(end-ptr), "%s ",
|
|
|
|
status->Error_String);
|
|
|
|
status++;
|
|
|
|
}
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
static char *
|
|
|
|
mpt_scsi_status(int code)
|
|
|
|
{
|
|
|
|
const struct Error_Map *status = IOC_SCSIStatus;
|
|
|
|
static char buf[64];
|
|
|
|
while (status->Error_Code >= 0) {
|
|
|
|
if (status->Error_Code == code)
|
|
|
|
return status->Error_String;
|
|
|
|
status++;
|
|
|
|
}
|
|
|
|
snprintf(buf, sizeof buf, "Unknown (0x%08x)", code);
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
static char *
|
|
|
|
mpt_who(int who_init)
|
|
|
|
{
|
|
|
|
char *who;
|
|
|
|
|
|
|
|
switch (who_init) {
|
|
|
|
case MPT_DB_INIT_NOONE: who = "No One"; break;
|
|
|
|
case MPT_DB_INIT_BIOS: who = "BIOS"; break;
|
|
|
|
case MPT_DB_INIT_ROMBIOS: who = "ROM BIOS"; break;
|
|
|
|
case MPT_DB_INIT_PCIPEER: who = "PCI Peer"; break;
|
|
|
|
case MPT_DB_INIT_HOST: who = "Host Driver"; break;
|
|
|
|
case MPT_DB_INIT_MANUFACTURE: who = "Manufacturing"; break;
|
|
|
|
default: who = "Unknown"; break;
|
|
|
|
}
|
|
|
|
return who;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
mpt_state(u_int32_t mb)
|
|
|
|
{
|
|
|
|
char *text;
|
|
|
|
|
|
|
|
switch (MPT_STATE(mb)) {
|
|
|
|
case MPT_DB_STATE_RESET: text = "Reset"; break;
|
|
|
|
case MPT_DB_STATE_READY: text = "Ready"; break;
|
|
|
|
case MPT_DB_STATE_RUNNING:text = "Running"; break;
|
|
|
|
case MPT_DB_STATE_FAULT: text = "Fault"; break;
|
|
|
|
default: text = "Unknown"; break;
|
|
|
|
}
|
|
|
|
return text;
|
2004-07-13 16:06:19 +00:00
|
|
|
}
|
2002-08-11 23:34:20 +00:00
|
|
|
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
static char *
|
|
|
|
mpt_scsi_tm_type(int code)
|
|
|
|
{
|
|
|
|
const struct Error_Map *status = IOC_SCSITMType;
|
|
|
|
static char buf[64];
|
|
|
|
while (status->Error_Code >= 0) {
|
|
|
|
if (status->Error_Code == code)
|
|
|
|
return status->Error_String;
|
|
|
|
status++;
|
|
|
|
}
|
|
|
|
snprintf(buf, sizeof buf, "Unknown (0x%08x)", code);
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2002-08-11 23:34:20 +00:00
|
|
|
void
|
|
|
|
mpt_print_db(u_int32_t mb)
|
|
|
|
{
|
|
|
|
printf("mpt mailbox: (0x%x) State %s WhoInit %s\n",
|
|
|
|
mb, mpt_state(mb), mpt_who(MPT_WHO(mb)));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* Reply functions */
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
|
|
mpt_print_reply_hdr(MSG_DEFAULT_REPLY *msg)
|
|
|
|
{
|
|
|
|
printf("%s Reply @ %p\n", mpt_ioc_function(msg->Function), msg);
|
|
|
|
printf("\tIOC Status %s\n", mpt_ioc_status(msg->IOCStatus));
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tIOCLogInfo 0x%08x\n", msg->IOCLogInfo);
|
2002-08-11 23:34:20 +00:00
|
|
|
printf("\tMsgLength 0x%02x\n", msg->MsgLength);
|
|
|
|
printf("\tMsgFlags 0x%02x\n", msg->MsgFlags);
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tMsgContext 0x%08x\n", msg->MsgContext);
|
2002-08-11 23:34:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
mpt_print_init_reply(MSG_IOC_INIT_REPLY *msg)
|
|
|
|
{
|
|
|
|
mpt_print_reply_hdr((MSG_DEFAULT_REPLY *)msg);
|
|
|
|
printf("\tWhoInit %s\n", mpt_who(msg->WhoInit));
|
|
|
|
printf("\tMaxDevices 0x%02x\n", msg->MaxDevices);
|
|
|
|
printf("\tMaxBuses 0x%02x\n", msg->MaxBuses);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
mpt_print_ioc_facts(MSG_IOC_FACTS_REPLY *msg)
|
|
|
|
{
|
|
|
|
mpt_print_reply_hdr((MSG_DEFAULT_REPLY *)msg);
|
|
|
|
printf("\tIOCNumber %d\n", msg->IOCNumber);
|
|
|
|
printf("\tMaxChainDepth %d\n", msg->MaxChainDepth);
|
|
|
|
printf("\tWhoInit %s\n", mpt_who(msg->WhoInit));
|
|
|
|
printf("\tBlockSize %d\n", msg->BlockSize);
|
|
|
|
printf("\tFlags %d\n", msg->Flags);
|
|
|
|
printf("\tReplyQueueDepth %d\n", msg->ReplyQueueDepth);
|
|
|
|
printf("\tReqFrameSize 0x%04x\n", msg->RequestFrameSize);
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tFW Version 0x%08x\n", msg->FWVersion.Word);
|
2002-08-11 23:34:20 +00:00
|
|
|
printf("\tProduct ID 0x%04x\n", msg->ProductID);
|
|
|
|
printf("\tCredits 0x%04x\n", msg->GlobalCredits);
|
|
|
|
printf("\tPorts %d\n", msg->NumberOfPorts);
|
|
|
|
printf("\tEventState 0x%02x\n", msg->EventState);
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tHostMFA_HA 0x%08x\n", msg->CurrentHostMfaHighAddr);
|
|
|
|
printf("\tSenseBuf_HA 0x%08x\n",
|
2002-08-11 23:34:20 +00:00
|
|
|
msg->CurrentSenseBufferHighAddr);
|
|
|
|
printf("\tRepFrameSize 0x%04x\n", msg->CurReplyFrameSize);
|
|
|
|
printf("\tMaxDevices 0x%02x\n", msg->MaxDevices);
|
|
|
|
printf("\tMaxBuses 0x%02x\n", msg->MaxBuses);
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tFWImageSize 0x%04x\n", msg->FWImageSize);
|
2002-08-11 23:34:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
mpt_print_enable_reply(MSG_PORT_ENABLE_REPLY *msg)
|
|
|
|
{
|
|
|
|
mpt_print_reply_hdr((MSG_DEFAULT_REPLY *)msg);
|
|
|
|
printf("\tPort: %d\n", msg->PortNumber);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
mpt_print_scsi_io_reply(MSG_SCSI_IO_REPLY *msg)
|
|
|
|
{
|
|
|
|
mpt_print_reply_hdr((MSG_DEFAULT_REPLY *)msg);
|
|
|
|
printf("\tBus: %d\n", msg->Bus);
|
|
|
|
printf("\tTargetID %d\n", msg->TargetID);
|
|
|
|
printf("\tCDBLength %d\n", msg->CDBLength);
|
|
|
|
printf("\tSCSI Status: %s\n", mpt_scsi_status(msg->SCSIStatus));
|
|
|
|
printf("\tSCSI State: %s\n", mpt_scsi_state(msg->SCSIState));
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tTransferCnt 0x%04x\n", msg->TransferCount);
|
|
|
|
printf("\tSenseCnt 0x%04x\n", msg->SenseCount);
|
|
|
|
printf("\tResponseInfo 0x%08x\n", msg->ResponseInfo);
|
2002-08-11 23:34:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
mpt_print_event_notice(MSG_EVENT_NOTIFY_REPLY *msg)
|
|
|
|
{
|
|
|
|
mpt_print_reply_hdr((MSG_DEFAULT_REPLY *)msg);
|
|
|
|
printf("\tEvent: %s\n", mpt_ioc_event(msg->Event));
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tEventContext 0x%04x\n", msg->EventContext);
|
2002-08-11 23:34:20 +00:00
|
|
|
printf("\tAckRequired %d\n", msg->AckRequired);
|
|
|
|
printf("\tEventDataLength %d\n", msg->EventDataLength);
|
|
|
|
printf("\tContinuation %d\n", msg->MsgFlags & 0x80);
|
|
|
|
switch(msg->Event) {
|
|
|
|
case MPI_EVENT_LOG_DATA:
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tEvtLogData: 0x%04x\n", msg->Data[0]);
|
2002-08-11 23:34:20 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_EVENT_UNIT_ATTENTION:
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tTargetID: 0x%04x\n",
|
|
|
|
msg->Data[0] & 0xff);
|
|
|
|
printf("\tBus: 0x%04x\n",
|
|
|
|
(msg->Data[0] >> 8) & 0xff);
|
2002-08-11 23:34:20 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_EVENT_IOC_BUS_RESET:
|
|
|
|
case MPI_EVENT_EXT_BUS_RESET:
|
|
|
|
case MPI_EVENT_RESCAN:
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tPort: %d\n",
|
|
|
|
(msg->Data[0] >> 8) & 0xff);
|
2002-08-11 23:34:20 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_EVENT_LINK_STATUS_CHANGE:
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tLinkState: %d\n",
|
|
|
|
msg->Data[0] & 0xff);
|
|
|
|
printf("\tPort: %d\n",
|
|
|
|
(msg->Data[1] >> 8) & 0xff);
|
2002-08-11 23:34:20 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_EVENT_LOOP_STATE_CHANGE:
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tType: %d\n",
|
|
|
|
(msg->Data[0] >> 16) & 0xff);
|
|
|
|
printf("\tChar3: 0x%02x\n",
|
|
|
|
(msg->Data[0] >> 8) & 0xff);
|
|
|
|
printf("\tChar4: 0x%02x\n",
|
|
|
|
(msg->Data[0] ) & 0xff);
|
|
|
|
printf("\tPort: %d\n",
|
|
|
|
(msg->Data[1] >> 8) & 0xff);
|
2002-08-11 23:34:20 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MPI_EVENT_LOGOUT:
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tN_PortId: 0x%04x\n", msg->Data[0]);
|
|
|
|
printf("\tPort: %d\n",
|
|
|
|
(msg->Data[1] >> 8) & 0xff);
|
2002-08-11 23:34:20 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
mpt_print_reply(void *vmsg)
|
|
|
|
{
|
|
|
|
MSG_DEFAULT_REPLY *msg = vmsg;
|
|
|
|
|
|
|
|
switch (msg->Function) {
|
|
|
|
case MPI_FUNCTION_EVENT_NOTIFICATION:
|
|
|
|
mpt_print_event_notice((MSG_EVENT_NOTIFY_REPLY *)msg);
|
|
|
|
break;
|
|
|
|
case MPI_FUNCTION_PORT_ENABLE:
|
|
|
|
mpt_print_enable_reply((MSG_PORT_ENABLE_REPLY *)msg);
|
|
|
|
break;
|
|
|
|
case MPI_FUNCTION_IOC_FACTS:
|
|
|
|
mpt_print_ioc_facts((MSG_IOC_FACTS_REPLY *)msg);
|
|
|
|
break;
|
|
|
|
case MPI_FUNCTION_IOC_INIT:
|
|
|
|
mpt_print_init_reply((MSG_IOC_INIT_REPLY *)msg);
|
|
|
|
break;
|
|
|
|
case MPI_FUNCTION_SCSI_IO_REQUEST:
|
2006-05-26 05:54:21 +00:00
|
|
|
case MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
|
2002-08-11 23:34:20 +00:00
|
|
|
mpt_print_scsi_io_reply((MSG_SCSI_IO_REPLY *)msg);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
mpt_print_reply_hdr((MSG_DEFAULT_REPLY *)msg);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* Request functions */
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
|
|
mpt_print_request_hdr(MSG_REQUEST_HEADER *req)
|
|
|
|
{
|
|
|
|
printf("%s @ %p\n", mpt_ioc_function(req->Function), req);
|
|
|
|
printf("\tChain Offset 0x%02x\n", req->ChainOffset);
|
|
|
|
printf("\tMsgFlags 0x%02x\n", req->MsgFlags);
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tMsgContext 0x%08x\n", req->MsgContext);
|
2002-08-11 23:34:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
mpt_print_scsi_io_request(MSG_SCSI_IO_REQUEST *orig_msg)
|
|
|
|
{
|
|
|
|
MSG_SCSI_IO_REQUEST local, *msg = &local;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
bcopy(orig_msg, msg, sizeof (MSG_SCSI_IO_REQUEST));
|
|
|
|
mpt_print_request_hdr((MSG_REQUEST_HEADER *)msg);
|
|
|
|
printf("\tBus: %d\n", msg->Bus);
|
|
|
|
printf("\tTargetID %d\n", msg->TargetID);
|
|
|
|
printf("\tSenseBufferLength %d\n", msg->SenseBufferLength);
|
|
|
|
printf("\tLUN: 0x%0x\n", msg->LUN[1]);
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tControl 0x%08x ", msg->Control);
|
2002-08-11 23:34:20 +00:00
|
|
|
#define MPI_PRINT_FIELD(x) \
|
|
|
|
case MPI_SCSIIO_CONTROL_ ## x : \
|
|
|
|
printf(" " #x " "); \
|
|
|
|
break
|
|
|
|
|
|
|
|
switch (msg->Control & MPI_SCSIIO_CONTROL_DATADIRECTION_MASK) {
|
|
|
|
MPI_PRINT_FIELD(NODATATRANSFER);
|
|
|
|
MPI_PRINT_FIELD(WRITE);
|
|
|
|
MPI_PRINT_FIELD(READ);
|
|
|
|
default:
|
|
|
|
printf(" Invalid DIR! ");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
switch (msg->Control & MPI_SCSIIO_CONTROL_TASKATTRIBUTE_MASK) {
|
|
|
|
MPI_PRINT_FIELD(SIMPLEQ);
|
|
|
|
MPI_PRINT_FIELD(HEADOFQ);
|
|
|
|
MPI_PRINT_FIELD(ORDEREDQ);
|
|
|
|
MPI_PRINT_FIELD(ACAQ);
|
|
|
|
MPI_PRINT_FIELD(UNTAGGED);
|
|
|
|
MPI_PRINT_FIELD(NO_DISCONNECT);
|
|
|
|
default:
|
|
|
|
printf(" Unknown attribute! ");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("\n");
|
|
|
|
#undef MPI_PRINT_FIELD
|
|
|
|
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tDataLength\t0x%08x\n", msg->DataLength);
|
|
|
|
printf("\tSenseBufAddr\t0x%08x\n", msg->SenseBufferLowAddr);
|
2002-08-11 23:34:20 +00:00
|
|
|
printf("\tCDB[0:%d]\t", msg->CDBLength);
|
|
|
|
for (i = 0; i < msg->CDBLength; i++)
|
|
|
|
printf("%02x ", msg->CDB[i]);
|
|
|
|
printf("\n");
|
2006-02-11 01:35:29 +00:00
|
|
|
|
|
|
|
if ((msg->Control & MPI_SCSIIO_CONTROL_DATADIRECTION_MASK) !=
|
|
|
|
MPI_SCSIIO_CONTROL_NODATATRANSFER ) {
|
|
|
|
mpt_dump_sgl(&orig_msg->SGL,
|
|
|
|
((char *)&orig_msg->SGL)-(char *)orig_msg);
|
|
|
|
}
|
2002-08-11 23:34:20 +00:00
|
|
|
}
|
|
|
|
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
static void
|
|
|
|
mpt_print_scsi_tmf_request(MSG_SCSI_TASK_MGMT *msg)
|
|
|
|
{
|
|
|
|
mpt_print_request_hdr((MSG_REQUEST_HEADER *)msg);
|
|
|
|
printf("\tLun 0x%02x\n", msg->LUN[1]);
|
|
|
|
printf("\tTaskType %s\n", mpt_scsi_tm_type(msg->TaskType));
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("\tTaskMsgContext 0x%08x\n", msg->TaskMsgContext);
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
}
|
|
|
|
|
2006-03-25 07:08:27 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
mpt_print_scsi_target_assist_request(PTR_MSG_TARGET_ASSIST_REQUEST msg)
|
|
|
|
{
|
|
|
|
mpt_print_request_hdr((MSG_REQUEST_HEADER *)msg);
|
|
|
|
printf("\tStatusCode 0x%02x\n", msg->StatusCode);
|
|
|
|
printf("\tTargetAssist 0x%02x\n", msg->TargetAssistFlags);
|
|
|
|
printf("\tQueueTag 0x%04x\n", msg->QueueTag);
|
|
|
|
printf("\tReplyWord 0x%08x\n", msg->ReplyWord);
|
|
|
|
printf("\tLun 0x%02x\n", msg->LUN[1]);
|
|
|
|
printf("\tRelativeOff 0x%08x\n", msg->RelativeOffset);
|
|
|
|
printf("\tDataLength 0x%08x\n", msg->DataLength);
|
|
|
|
mpt_dump_sgl(msg->SGL, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
mpt_print_scsi_target_status_send_request(MSG_TARGET_STATUS_SEND_REQUEST *msg)
|
|
|
|
{
|
|
|
|
SGE_IO_UNION x;
|
|
|
|
mpt_print_request_hdr((MSG_REQUEST_HEADER *)msg);
|
|
|
|
printf("\tStatusCode 0x%02x\n", msg->StatusCode);
|
|
|
|
printf("\tStatusFlags 0x%02x\n", msg->StatusFlags);
|
|
|
|
printf("\tQueueTag 0x%04x\n", msg->QueueTag);
|
|
|
|
printf("\tReplyWord 0x%08x\n", msg->ReplyWord);
|
|
|
|
printf("\tLun 0x%02x\n", msg->LUN[1]);
|
|
|
|
x.u.Simple = msg->StatusDataSGE;
|
|
|
|
mpt_dump_sgl(&x, 0);
|
|
|
|
}
|
|
|
|
|
2002-08-11 23:34:20 +00:00
|
|
|
void
|
|
|
|
mpt_print_request(void *vreq)
|
|
|
|
{
|
|
|
|
MSG_REQUEST_HEADER *req = vreq;
|
|
|
|
|
|
|
|
switch (req->Function) {
|
|
|
|
case MPI_FUNCTION_SCSI_IO_REQUEST:
|
2006-05-26 05:54:21 +00:00
|
|
|
case MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH:
|
2002-08-11 23:34:20 +00:00
|
|
|
mpt_print_scsi_io_request((MSG_SCSI_IO_REQUEST *)req);
|
|
|
|
break;
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
case MPI_FUNCTION_SCSI_TASK_MGMT:
|
|
|
|
mpt_print_scsi_tmf_request((MSG_SCSI_TASK_MGMT *)req);
|
2006-03-25 07:08:27 +00:00
|
|
|
break;
|
|
|
|
case MPI_FUNCTION_TARGET_ASSIST:
|
|
|
|
mpt_print_scsi_target_assist_request(
|
|
|
|
(PTR_MSG_TARGET_ASSIST_REQUEST)req);
|
|
|
|
break;
|
|
|
|
case MPI_FUNCTION_TARGET_STATUS_SEND:
|
|
|
|
mpt_print_scsi_target_status_send_request(
|
|
|
|
(MSG_TARGET_STATUS_SEND_REQUEST *)req);
|
|
|
|
break;
|
2002-08-11 23:34:20 +00:00
|
|
|
default:
|
|
|
|
mpt_print_request_hdr(req);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
int
|
|
|
|
mpt_decode_value(mpt_decode_entry_t *table, u_int num_entries,
|
|
|
|
const char *name, u_int value, u_int *cur_column,
|
|
|
|
u_int wrap_point)
|
2002-08-11 23:34:20 +00:00
|
|
|
{
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
int printed;
|
|
|
|
u_int printed_mask;
|
|
|
|
u_int dummy_column;
|
2002-08-11 23:34:20 +00:00
|
|
|
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
if (cur_column == NULL) {
|
|
|
|
dummy_column = 0;
|
|
|
|
cur_column = &dummy_column;
|
2002-08-11 23:34:20 +00:00
|
|
|
}
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
|
|
|
|
if (*cur_column >= wrap_point) {
|
|
|
|
printf("\n");
|
|
|
|
*cur_column = 0;
|
|
|
|
}
|
|
|
|
printed = printf("%s[0x%x]", name, value);
|
|
|
|
if (table == NULL) {
|
|
|
|
printed += printf(" ");
|
|
|
|
*cur_column += printed;
|
|
|
|
return (printed);
|
|
|
|
}
|
|
|
|
printed_mask = 0;
|
|
|
|
while (printed_mask != 0xFF) {
|
|
|
|
int entry;
|
|
|
|
|
|
|
|
for (entry = 0; entry < num_entries; entry++) {
|
|
|
|
if (((value & table[entry].mask)
|
|
|
|
!= table[entry].value)
|
|
|
|
|| ((printed_mask & table[entry].mask)
|
|
|
|
== table[entry].mask))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
printed += printf("%s%s",
|
|
|
|
printed_mask == 0 ? ":(" : "|",
|
|
|
|
table[entry].name);
|
|
|
|
printed_mask |= table[entry].mask;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (entry >= num_entries)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (printed_mask != 0)
|
|
|
|
printed += printf(") ");
|
|
|
|
else
|
|
|
|
printed += printf(" ");
|
|
|
|
*cur_column += printed;
|
|
|
|
return (printed);
|
|
|
|
}
|
|
|
|
|
|
|
|
static mpt_decode_entry_t req_state_parse_table[] = {
|
|
|
|
{ "REQ_FREE", 0x00, 0xff },
|
|
|
|
{ "REQ_ALLOCATED", 0x01, 0x01 },
|
|
|
|
{ "REQ_QUEUED", 0x02, 0x02 },
|
|
|
|
{ "REQ_DONE", 0x04, 0x04 },
|
|
|
|
{ "REQ_TIMEDOUT", 0x08, 0x08 },
|
|
|
|
{ "REQ_NEED_WAKEUP", 0x10, 0x10 }
|
|
|
|
};
|
|
|
|
|
|
|
|
void
|
|
|
|
mpt_req_state(mpt_req_state_t state)
|
|
|
|
{
|
|
|
|
mpt_decode_value(req_state_parse_table,
|
|
|
|
NUM_ELEMENTS(req_state_parse_table),
|
|
|
|
"REQ_STATE", state, NULL, 80);
|
2004-07-13 16:06:19 +00:00
|
|
|
}
|
2002-08-11 23:34:20 +00:00
|
|
|
|
2006-02-11 01:35:29 +00:00
|
|
|
#define LAST_SGE ( \
|
|
|
|
MPI_SGE_FLAGS_END_OF_LIST | \
|
|
|
|
MPI_SGE_FLAGS_END_OF_BUFFER| \
|
|
|
|
MPI_SGE_FLAGS_LAST_ELEMENT)
|
|
|
|
void
|
|
|
|
mpt_dump_sgl(SGE_IO_UNION *su, int offset)
|
2002-08-11 23:34:20 +00:00
|
|
|
{
|
|
|
|
SGE_SIMPLE32 *se = (SGE_SIMPLE32 *) su;
|
2006-02-11 01:35:29 +00:00
|
|
|
const char allfox[4] = { 0xff, 0xff, 0xff, 0xff };
|
|
|
|
void *nxtaddr = se;
|
|
|
|
void *lim;
|
|
|
|
int flags;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Can't be any bigger than this.
|
|
|
|
*/
|
|
|
|
lim = &((char *)se)[MPT_REQUEST_AREA - offset];
|
2002-08-11 23:34:20 +00:00
|
|
|
|
|
|
|
do {
|
|
|
|
int iprt;
|
|
|
|
|
|
|
|
printf("\t");
|
2006-02-11 01:35:29 +00:00
|
|
|
if (memcmp(se, allfox, 4) == 0) {
|
|
|
|
uint32_t *nxt = (uint32_t *)se;
|
|
|
|
printf("PAD %p\n", se);
|
|
|
|
nxtaddr = nxt + 1;
|
|
|
|
se = nxtaddr;
|
|
|
|
flags = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
nxtaddr = se + 1;
|
2002-08-11 23:34:20 +00:00
|
|
|
flags = MPI_SGE_GET_FLAGS(se->FlagsLength);
|
|
|
|
switch (flags & MPI_SGE_FLAGS_ELEMENT_MASK) {
|
|
|
|
case MPI_SGE_FLAGS_SIMPLE_ELEMENT:
|
2006-02-11 01:35:29 +00:00
|
|
|
if (flags & MPI_SGE_FLAGS_64_BIT_ADDRESSING) {
|
|
|
|
SGE_SIMPLE64 *se64 = (SGE_SIMPLE64 *)se;
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("SE64 %p: Addr=0x%08x%08x FlagsLength"
|
|
|
|
"=0x%0x\n", se64, se64->Address.High,
|
2006-02-11 01:35:29 +00:00
|
|
|
se64->Address.Low, se64->FlagsLength);
|
|
|
|
nxtaddr = se64 + 1;
|
|
|
|
} else {
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("SE32 %p: Addr=0x%0x FlagsLength=0x%0x"
|
2006-02-11 01:35:29 +00:00
|
|
|
"\n", se, se->Address, se->FlagsLength);
|
|
|
|
}
|
2002-08-11 23:34:20 +00:00
|
|
|
printf(" ");
|
|
|
|
break;
|
|
|
|
case MPI_SGE_FLAGS_CHAIN_ELEMENT:
|
2006-02-11 01:35:29 +00:00
|
|
|
if (flags & MPI_SGE_FLAGS_64_BIT_ADDRESSING) {
|
|
|
|
SGE_CHAIN64 *ce64 = (SGE_CHAIN64 *) se;
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("CE64 %p: Addr=0x%08x%08x NxtChnO=0x%x "
|
|
|
|
"Flgs=0x%x Len=0x%0x\n", ce64,
|
2006-02-11 01:35:29 +00:00
|
|
|
ce64->Address.High, ce64->Address.Low,
|
|
|
|
ce64->NextChainOffset,
|
|
|
|
ce64->Flags, ce64->Length);
|
|
|
|
nxtaddr = ce64 + 1;
|
|
|
|
} else {
|
|
|
|
SGE_CHAIN32 *ce = (SGE_CHAIN32 *) se;
|
2006-02-26 22:50:14 +00:00
|
|
|
printf("CE32 %p: Addr=0x%0x NxtChnO=0x%x "
|
|
|
|
" Flgs=0x%x Len=0x%0x\n", ce, ce->Address,
|
2006-02-11 01:35:29 +00:00
|
|
|
ce->NextChainOffset, ce->Flags, ce->Length);
|
|
|
|
}
|
2002-08-11 23:34:20 +00:00
|
|
|
flags = 0;
|
|
|
|
break;
|
|
|
|
case MPI_SGE_FLAGS_TRANSACTION_ELEMENT:
|
|
|
|
printf("TE32 @ %p\n", se);
|
|
|
|
flags = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
iprt = 0;
|
|
|
|
#define MPT_PRINT_FLAG(x) \
|
|
|
|
if (flags & MPI_SGE_FLAGS_ ## x ) { \
|
|
|
|
if (iprt == 0) { \
|
|
|
|
printf("\t"); \
|
|
|
|
} \
|
|
|
|
printf(" "); \
|
|
|
|
printf( #x ); \
|
|
|
|
iprt++; \
|
|
|
|
}
|
|
|
|
MPT_PRINT_FLAG(LOCAL_ADDRESS);
|
|
|
|
MPT_PRINT_FLAG(HOST_TO_IOC);
|
|
|
|
MPT_PRINT_FLAG(64_BIT_ADDRESSING);
|
|
|
|
MPT_PRINT_FLAG(LAST_ELEMENT);
|
|
|
|
MPT_PRINT_FLAG(END_OF_BUFFER);
|
|
|
|
MPT_PRINT_FLAG(END_OF_LIST);
|
|
|
|
#undef MPT_PRINT_FLAG
|
|
|
|
if (iprt)
|
|
|
|
printf("\n");
|
2006-02-11 01:35:29 +00:00
|
|
|
se = nxtaddr;
|
|
|
|
if ((flags & LAST_SGE) == LAST_SGE) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while ((flags & MPI_SGE_FLAGS_END_OF_LIST) == 0 && nxtaddr < lim);
|
2002-08-11 23:34:20 +00:00
|
|
|
}
|
2002-09-24 21:33:43 +00:00
|
|
|
|
2006-07-12 07:48:50 +00:00
|
|
|
void
|
|
|
|
mpt_dump_data(struct mpt_softc *mpt, const char *msg, void *addr, int len)
|
|
|
|
{
|
|
|
|
int offset;
|
|
|
|
uint8_t *cp = addr;
|
|
|
|
mpt_prt(mpt, "%s:", msg);
|
|
|
|
for (offset = 0; offset < len; offset++) {
|
|
|
|
if ((offset & 0xf) == 0) {
|
|
|
|
mpt_prtc(mpt, "\n");
|
|
|
|
}
|
|
|
|
mpt_prtc(mpt, " %02x", cp[offset]);
|
|
|
|
}
|
|
|
|
mpt_prtc(mpt, "\n");
|
|
|
|
}
|
|
|
|
|
2006-05-26 05:54:21 +00:00
|
|
|
void
|
|
|
|
mpt_dump_request(struct mpt_softc *mpt, request_t *req)
|
|
|
|
{
|
|
|
|
uint32_t *pReq = req->req_vbuf;
|
2006-12-07 22:02:28 +00:00
|
|
|
int o;
|
2006-05-26 05:54:21 +00:00
|
|
|
#if __FreeBSD_version >= 500000
|
|
|
|
mpt_prt(mpt, "Send Request %d (%jx):",
|
|
|
|
req->index, (uintmax_t) req->req_pbuf);
|
|
|
|
#else
|
|
|
|
mpt_prt(mpt, "Send Request %d (%llx):",
|
|
|
|
req->index, (unsigned long long) req->req_pbuf);
|
|
|
|
#endif
|
2006-12-07 22:02:28 +00:00
|
|
|
for (o = 0; o < mpt->ioc_facts.RequestFrameSize; o++) {
|
|
|
|
if ((o & 0x7) == 0) {
|
2006-05-26 05:54:21 +00:00
|
|
|
mpt_prtc(mpt, "\n");
|
|
|
|
mpt_prt(mpt, " ");
|
|
|
|
}
|
2006-12-07 22:02:28 +00:00
|
|
|
mpt_prtc(mpt, " %08x", pReq[o]);
|
2006-05-26 05:54:21 +00:00
|
|
|
}
|
|
|
|
mpt_prtc(mpt, "\n");
|
|
|
|
}
|
|
|
|
|
2006-03-25 07:08:27 +00:00
|
|
|
#if __FreeBSD_version < 500000
|
|
|
|
void
|
|
|
|
mpt_lprt(struct mpt_softc *mpt, int level, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
if (level <= mpt->verbose) {
|
|
|
|
printf("%s: ", device_get_nameunit(mpt->dev));
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vprintf(fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
mpt_lprtc(struct mpt_softc *mpt, int level, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
if (level <= mpt->verbose) {
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vprintf(fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-09-24 21:33:43 +00:00
|
|
|
void
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
mpt_prt(struct mpt_softc *mpt, const char *fmt, ...)
|
2002-09-24 21:33:43 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
|
2002-09-24 21:33:43 +00:00
|
|
|
printf("%s: ", device_get_nameunit(mpt->dev));
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vprintf(fmt, ap);
|
|
|
|
va_end(ap);
|
Massive overhaul of MPT Fusion driver:
o Add timeout error recovery (from a thread context to avoid
the deferral of other critical interrupts).
o Properly recover commands across controller reset events.
o Update the driver to handle events and status codes that
have been added to the MPI spec since the driver was
originally written.
o Make the driver more modular to improve maintainability and
support dynamic "personality" registration (e.g. SCSI Initiator,
RAID, SAS, FC, etc).
o Shorten and simplify the common I/O path to improve driver
performance.
o Add RAID volume and RAID member state/settings reporting.
o Add periodic volume resynchronization status reporting.
o Add support for sysctl tunable resync rate, member write cache
enable, and volume transaction queue depth.
Sponsored by
----------------
Avid Technologies Inc:
SCSI error recovery, driver re-organization, update of MPI library
headers, portions of dynamic personality registration, and misc bug
fixes.
Wheel Open Technologies:
RAID event notification, RAID member pass-thru support, firmware
upload/download support, enhanced RAID resync speed, portions
of dynamic personality registration, and misc bug fixes.
Detailed Changes
================
mpt.c mpt_cam.c mpt_raid.c mpt_pci.c:
o Add support for personality modules. Each module exports
load, and unload module scope methods as well as probe, attach,
event, reset, shutdown, and detach per-device instance
methods
mpt.c mpt.h mpt_pci.c:
o The driver now associates a callback function (via an
index) with every transaction submitted to the controller.
This allows the main interrupt handler to absolve itself
of any knowledge of individual transaction/response types
by simply calling the callback function "registered" for
the transaction. We use a callback index instead of a
callback function pointer in each requests so we can
properly handle responses (e.g. event notifications)
that are not associated with a transaction. Personality
modules dynamically register their callbacks with the
driver core to receive the callback index to use for their
handlers.
o Move the interrupt handler into mpt.c. The ISR algorithm
is bus transport and OS independent and thus had no reason
to be in mpt_pci.c.
o Simplify configuration message reply handling by copying
reply frame data for the requester and storing completion
status in the original request structure.
o Add the mpt_complete_request_chain() helper method and use
it to implement reset handlers that must abort transactions.
o Keep track of all pending requests on the new
requests_pending_list in the softc.
o Add default handlers to mpt.c to handle generic event
notifications and controller reset activities. The event
handler code is largely the same as in the original driver.
The reset handler is new and terminates any pending transactions
with a status code indicating the controller needs to be
re-initialized.
o Add some endian support to the driver. A complete audit is
still required for this driver to have any hope of operating
in a big-endian environment.
o Use inttypes.h and __inline. Come closer to being style(9)
compliant.
o Remove extraneous use of typedefs.
o Convert request state from a strict enumeration to a series
of flags. This allows us to, for example, tag transactions
that have timed-out while retaining the state that the
transaction is still in-flight on the controller.
o Add mpt_wait_req() which allows a caller to poll or sleep
for the completion of a request. Use this to simplify
and factor code out from many initialization routines.
We also use this to sleep for task management request
completions in our CAM timeout handler.
mpt.c:
o Correct a bug in the event handler where request structures were
freed even if the request reply was marked as a continuation
reply. Continuation replies indicate that the controller still owns
the request and freeing these replies prematurely corrupted
controller state.
o Implement firmware upload and download. On controllers that do
not have dedicated NVRAM (as in the Sun v20/v40z), the firmware
image is downloaded to the controller by the system BIOS. This
image occupies precious controller RAM space until the host driver
fetches the image, reducing the number of concurrent I/Os the
controller can processes. The uploaded image is used to
re-program the controller during hard reset events since the
controller cannot fetch the firmware on its own. Implementing this
feature allows much higher queue depths when RAID volumes
are configured.
o Changed configuration page accessors to allow threads to sleep
rather than busy wait for completion.
o Removed hard coded data transfer sizes from configuration page
routines so that RAID configuration page processing is possible.
mpt_reg.h:
o Move controller register definitions into a separate file.
mpt.h:
o Re-arrange includes to allow inlined functions to be
defined in mpt.h.
o Add reply, event, and reset handler definitions.
o Add softc fields for handling timeout and controller
reset recovery.
mpt_cam.c:
o Move mpt_freebsd.c to mpt_cam.c. Move all core functionality,
such as event handling, into mpt.c leaving only CAM SCSI
support here.
o Revamp completion handler to provide correct CAM status for
all currently defined SCSI MPI message result codes.
o Register event and reset handlers with the MPT core. Modify
the event handler to notify CAM of bus reset events. The
controller reset handler will abort any transactions that
have timed out. All other pending CAM transactions are
correctly aborted by the core driver's reset handler.
o Allocate a single request up front to perform task management
operations. This guarantees that we can always perform a
TMF operation even when the controller is saturated with other
operations. The single request also serves as a perfect
mechanism of guaranteeing that only a single TMF is in flight
at a time - something that is required according to the MPT
Fusion documentation.
o Add a helper function for issuing task management requests
to the controller. This is used to abort individual requests
or perform a bus reset.
o Modify the CAM XPT_BUS_RESET ccb handler to wait for and
properly handle the status of the bus reset task management
frame used to reset the bus. The previous code assumed that
the reset request would always succeed.
o Add timeout recovery support. When a timeout occurs, the
timed-out request is added to a queue to be processed by
our recovery thread and the thread is woken up. The recovery
thread processes timed-out command serially, attempting first
to abort them and then falling back to a bus reset if an
abort fails.
o Add calls to mpt_reset() to reset the controller if any
handshake command, bus reset attempt or abort attempt
fails due to a timeout.
o Export a secondary "bus" to CAM that exposes all volume drive
members as pass-thru devices, allowing CAM to perform proper
speed negotiation to hidden devices.
o Add a CAM async event handler tracking the AC_FOUND_DEVICE event.
Use this to trigger calls to set the per-volume queue depth once
the volume is fully registered with CAM. This is required to avoid
hitting firmware limits on volume queue depth. Exceeding the
limit causes the firmware to hang.
mpt_cam.h:
o Add several helper functions for interfacing to CAM and
performing timeout recovery.
mpt_pci.c:
o Disable interrupts on the controller before registering and
enabling interrupt delivery to the OS. Otherwise we risk
receiving interrupts before the driver is ready to receive
them.
o Make use of compatibility macros that allow the driver to
be compiled under 4.x and 5.x.
mpt_raid.c:
o Add a per-controller instance RAID thread to perform settings
changes and query status (minimizes CPU busy wait loops).
o Use a shutdown handler to disable "Member Write Cache Enable"
(MWCE) setting for RAID arrays set to enable MWCE During Rebuild.
o Change reply handler function signature to allow handlers to defer
the deletion of reply frames. Use this to allow the event reply
handler to queue up events that need to be acked if no resources
are available to immediately ack an event. Queued events are
processed in mpt_free_request() where resources are freed. This
avoids a panic on resource shortage.
o Parse and print out RAID controller capabilities during driver probe.
o Define, allocate, and maintain RAID data structures for volumes,
hidden member physical disks and spare disks.
o Add dynamic sysctls for per-instance setting of the log level, array
resync rate, array member cache enable, and volume queue depth.
mpt_debug.c:
o Add mpt_lprt and mpt_lprtc for printing diagnostics conditioned on
a particular log level to aid in tracking down driver issues.
o Add mpt_decode_value() which parses the bits in an integer
value based on a parsing table (mask, value, name string, tuples).
mpilib/*:
o Update mpi library header files to latest distribution from LSI.
Submitted by: gibbs
Approved by: re
2005-07-10 15:05:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
mpt_prtc(struct mpt_softc *mpt, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vprintf(fmt, ap);
|
|
|
|
va_end(ap);
|
2002-09-24 21:33:43 +00:00
|
|
|
}
|