Copy stable/11@r303970 to releng/11.0 as part of the 11.0-RELEASE
cycle.

Prune svn:mergeinfo from the new branch, and rename it to RC1.

Update __FreeBSD_version.

Use the quarterly branch for the default FreeBSD.conf pkg(8) repo and
the dvd1.iso packages population.

Approved by: re (implicit)
Sponsored by: The FreeBSD Foundation

Copy head@r302406 to stable/11 as part of the 11.0-RELEASE cycle.
Prune svn:mergeinfo from the new branch, as nothing has been merged
here.

Additional commits post-branch will follow.

Approved by: re (implicit)
Sponsored by: The FreeBSD Foundation

Start each of the license/copyright comments with /*-, minor shuffle of lines

Update Perforce Ids.

Major update to the aic7xxx driver:

ahc_eisa.c:
ahc_pci.c:
Conform to new aic7xxx IRQ API.

Adapt to aic7xxx_freebsd -> aic7xxx_osm changes.

aic7770.c:
Disable card generated interrupt early in our probe for
"extra safety"

Commonize some seeprom code with the PCI side of the driver.

aic7xxx.c:
Correctly initialize a few scratch ram locations during
a sequencer restart. This avoids spurious sequencer ram
parity errors in some configurations.

Include the softc in ahc_update_residual calls. We need it
for some diagnostics in this code path.

Flag a data overrun on an auto-request sense failure as a
CAM_AUTOSENSE_FAIL rather than a CAM_DATA_RUN_ERR.

Force a renegotiation after noticing a parity error. This
covers targets that lose our negotiation settings but don't
bother to give us a unit attention condition. This can happen
if a target fails during a reselection of us during a cable
pull.

Convert some code to using constants.

Fix some typos.

Correct target mode message loop handling. ahc_clear_msg_state
was not clearing the "need to go to message out phase" bit once
our loop was over.

Simplify some abort handling code.

Include tag information in target mode immediate notify events.

When shutting down EISA controllers, don't EISA BIOS settings in
the high portions of scratch ram. This fixes warm boot issues on
some systems.

Save a bit of space by only allocating the SCBs that we can use.

Avoid some code paths in ahc_abort_scbs() if we are currently
acting as a target.

Correctly cleanup stranded SCBs in the card's SCB array. These
are SCBs who's mapping has already been torn down by code that
aborted the SCB by seeing it in another list first.

Add a comment about some potential bus reset issues for target
mode on Twin (EISA only) controllers.

aic7xxx.h:
Cleanup the hardware scb definitions a bit.

Allocate a ful 256 byte scb mapping index. This simplifies
the lookup code since the table covers all possible (and potentially
bogus) values.

Make AHC_DEBUG work again.

aic7xxx.reg:
Updates to hardware SCB definition.

New definitions for target mode fixes.

aic7xxx.seq:
In target mode, initialize SAVED_LUN just after we receive
the identify message. It may be required in the error recovery
path when a normal cdb packet (includes lun) is not sent up to
the host for processing.

Respond to irregular messages during a selection in target mode.

Defer looking for space for a cdb packet until we are about to
enter command phase. We want to be able to handle irregular messages
even if we would otherwise return QUEUE_FULL or BUSY.

Add support for sending Ignore Wide Residue messages as a target.

In the disable disconnect case in target mode, set our transfer
rate correctly once data are availble.

aic7xxx_93cx6.c:
aic7xxx_93cx6.h:
Add the ability to write and erase the seeprom.

aic7xxx_inline.h:
Correct Big Endian handling of large cdb sizes (> 12 bytes).

Adaptec to changes in the calc_residual API.

Correct a target mode bug where we always attempted to service
the input queue even if no progress could be made due to lack
of ATIOs.

aic7xxx_osm.c:
Adaptec to new IRQ mapping API. The new API allows the core
to only enable our IRQ mapping once it is safe (sufficient
initialization) to do so.

Slap bootverbose protection around some diagnostics.

Only attempt DT phases if we are wide.

aic7xxx_osm.h:
Enable big endian support.

Adjust for IRQ API change.

aic7xxx_pci.c:
Be more careful about relying on subvendor 9005 information.
We now only trust it for HBAs. This should allow the driver
to attach to some MBs where the subvendor/device information
does not follow the Adaptec spec.

Only enable interrupts on the card once we are fully setup.

Disable external SCB ram usage on the aic7895. I have not
been able to make it 100% reliable.

Adjust to seeprom routines being properly prefixed with "ahc".

Fix a few bugs in the external SCB ram probing routine. We
need to clear any parity errors we've triggered during the
probe to avoid future, fatal, interrupts.

If we detect an invalid cable combination, pretent there are
no cable at all. This will enable all of the terminators
which is probably the safest configuration we can "guess".

MFC after: 4 days

ahc_eisa.c:
ahc_pci.c:
Add detach support.

Make use of soft allocated on our behalf by newbus.

For PCI devices, disable the mapping type we aren't
using for extra protection from rogue code.

aic7xxx_93cx6.c:
aic7xxx_93cx6.h:
Sync perforce IDs.

aic7xxx_freebsd.c:
Capture the eventhandle returned by EVENTHANDER_REGISTER
so we can kill the handler off during detach.

Use AHC_* constants instead of hard coded numbers in a
few more places.

Test PPR option state when deciding to "really" negotiate
when the CAM_NEGOTIATE flag is passed in a CCB.

Make use of core "ahc_pause_and_flushwork" routine in our
timeout handler rather than re-inventing this code.

Cleanup all of our resources (really!) in ahc_platform_free().
We should be all set to become a module now.

Implement the core ahc_detach() routine shared by all of
the FreeBSD front-ends.

aic7xxx_freebsd.h:
Softc storage for our event handler.

Null implementation for the ahc_platform_flushwork() OSM
callback. FreeBSD doesn't need this as XPT callbacks are
safe from all contexts and are done directly in ahc_done().

aic7xxx_inline.h:
Implement new lazy interrupt scheme. To avoid an extra
PCI bus read, we first check our completion queues to
see if any work has completed. If work is available, we
assume that this is the source of the interrupt and skip
reading INTSTAT. Any remaining interrupt status will be
cleared by a second call to the interrupt handler should
the interrupt line still be asserted. This drops the
interrupt handler down to a single PCI bus read in the
common case of I/O completion. This is the same overhead
as in the not so distant past, but the extra sanity of
perforning a PCI read after clearing the command complete
interrupt and before running the completion queue to avoid
missing command complete interrupts added a cycle.

aic7xxx.c:
During initialization, be sure to initialize all scratch
ram locations before they are read to avoid parity errors.
In this case, we use a new function, ahc_unbusy_tcl() to
initialize the scratch ram busy target table.

Replace instances of ahc_index_busy_tcl() used to unbusy
a tcl without looking at the old value with ahc_unbusy_tcl().

Modify ahc_sent_msg so that it can find single byte messages.
ahc_sent_msg is now used to determine if a transfer negotiation
attempt resulted in a bus free.

Be more careful in filtering out only the SCSI interrupts
of interest in ahc_handle_scsiint.

Rearrange interrupt clearing code to ensure that at least
one PCI transaction occurrs after hitting CLRSINT1 and
writting to CLRINT. CLRSINT1 writes take a bit to
take effect, and the re-arrangement provides sufficient
delay to ensure the write to CLRINT is effective. The
old code might report a spurious interrupt on some "fast"
chipsets.

export ahc-update_target_msg_request for use by OSM code.

If a target does not respond to our ATN request, clear
it once we move to a non-message phase. This avoids
sending a MSG_NOOP in some later message out phase.

Use max lun and max target constants instead of
hard-coded values.

Use softc storage built into our device_t under FreeBSD.

Fix a bug in ahc_free() that caused us to delete
resources that were not allocated.

Clean up any tstate/lstate info in ahc_free().

Clear the powerdown state in ahc_reset() so that
registers can be accessed.

Add a preliminary function for pausing the chip and
processing any posted work.

Add a preliminary suspend and resume functions.

aic7xxx.h:
Limit the number of supported luns to 64. We don't
support information unit transfers, so this is the
maximum that makes sense for these chips.

Add a new flag AHC_ALL_INTERRUPTS that forces the
processing of all interrupt state in a single invokation
of ahc_intr(). When the flag is not set, we use the
lazy interrupt handling scheme.

Add data structures to store controller state while
we are suspended.

Use constants instead of hard coded values where appropriate.

Correct some harmless "unsigned/signed" conflicts.

aic7xxx.seq:
Only perform the SCSIBUSL fix on ULTRA2 or newer controllers.
Older controllers seem to be confused by this.

In target mode, ignore PHASEMIS during data phases.
This bit seems to be flakey on U160 controllers acting
in target mode.

aic7xxx_pci.c:
Add support for the 29160C CPCI adapter.

Add definitions for subvendor ID information
available for devices with the "9005" vendor id.
We currently use this information to determine
if a multi-function device doesn't have the second
channel hooked up on a board.

Add rudimentary power mode code so we can put the
controller into the D0 state. In the future this
will be an OSM callback so that in FreeBSD we don't
duplicate functionality provided by the PCI code.
The powerstate code was added after I'd completed
my regression tests on this code.

Only capture "left over BIOS state" if the POWRDN
setting is not set in HCNTRL.

In target mode, don't bother sending incremental
CRC data.

Sync Perforce IDs, add tranceiver state change support, and correct
numerous error recovery buglets.

Many thanks to Tor Egge for his assistance in diagnosing problems with
the error recovery code.

aic7xxx.c:
Report missed bus free events using their own sequencer interrupt
code to avoid confusion with other "bad phase" interrupts.

Remove a delay used in debugging. This delay could only be hit
in certain, very extreme, error recovery scenarios.

Handle transceiver state changes correctly. You can now
plug an SE device into a hot-plug LVD bus without hanging
the controller.

When stepping through a critical section, panic if we step
more than a reasonable number of times.

After a bus reset, disable bus reset interupts until we either
our first attempt to (re)select another device, or another device
attemps to select us. This removes the need to busy wait in
kernel for the scsi reset line to fall yet still ensures we
see any reset events that impact the state of either our initiator
or target roles. Before this change, we had the potential of
servicing a "storm" of reset interrupts if the reset line was
held for a significant amount of time.

Indicate the current sequencer address whenever we dump the
card's state.

aic7xxx.reg:
Transceiver state change register definitions.

Add the missed bussfree sequencer interrupt code.

Re-enable the scsi reset interrupt if it has been
disabled before every attempt to (re)select a device
and when we have been selected as a target.

When being (re)selected, check to see if the selection
dissappeared just after we enabled our bus free interrupt.
If the bus has gone free again, go back to the idle loop
and wait for another selection.

Note two locations where we should change our behavior
if ATN is still raised. If ATN is raised during the
presentation of a command complete or disconnect message,
we should ignore the message and expect the target to put
us in msgout phase. We don't currently do this as it
requires some code re-arrangement so that critical sections
can be properly placed around our handling of these two
events. Otherwise, we cannot guarantee that the check of
ATN is atomic relative to our acking of the message in
byte (the kernel could assert ATN).

Only set the IDENTIFY_SEEN flag after we have settled
on the SCB for this transaction. The kernel looks at
this flag before assuming that SCB_TAG is valid. This
avoids confusion during certain types of error recovery.

Add a critical section around findSCB. We cannot allow
the kernel to remove an entry from the disconnected
list while we are traversing it. Ditto for get_free_or_disc_scb.

aic7xxx_freebsd.c:
Only assume that SCB_TAG is accurate if IDENTIFY_SEEN is
set in SEQ_FLAGS.

Fix a typo that caused us to execute some code for the
non-SCB paging case when paging SCBs. This only occurred
during error recovery.

Add Perforce RCSIDs for easy revision correlation to my local tree.

ahc_pci.c:
Bring back the AHC_ALLOW_MEMIO option at least until the
memory mapped I/O problem on the SuperMicro 370DR3 is
better understood.

aic7xxx.c:
If we see a spurious SCSI interrupt, attempt to clear it and
continue by unpausing the sequencer.

Change the interface to ahc_send_async(). Some async messages
need to be broadcast to all the luns of a target or all the
targets of a bus. This is easier to achieve by passing explicit
channel, target, and lun parameters instead of attempting to
construct a device info struct to match.

Filter the sync parameters for the PPR message in exactly the
same way we do for an old fashioned SDTR message.

Correct some typos and correct a panic message.

Handle rejected PPR messages.

In ahc_handle_msg_reject(), let ahc_build_transfer_msg() build
any additional transfer messages instead of doing this inline.

aic7xxx.h:
Increase the size of both msgout_buf and msgin_buf to
better accomodate PPR messages.

aic7xxx_freebsd.c:
Update for change in ahc_send_async() parameters.

aic7xxx_freebsd.h
Update for change in ahc_send_async() parameters.

Honor AHC_ALLOW_MEMIO.

aic7xxx_pci.c:
Check the error register before going into full blown PCI
interrupt handling. This avoids a few costly PCI configuration
space reads when we run our PCI interrupt handler because another
device sharing our interrupt line is more active than we are.

Also unpause the sequencer after processing a PCI interrupt.

Move aicasm to its own subdirectory.

Separate our platform independent hooks from core driver functionality
shared between platforms (FreeBSD and Linux at this time).

Add sequencer workarounds for several chip->chipset interactions.

Correct external SCB corruption problem on aic7895 based cards (3940AUW).

Lots of cleanups resulting from the port to another OS.

o Convert to <inttypes.h> style fixed sized types to facilitate porting to
other systems.

o Normalize copyright text.

o Clean up probe code function interfaces by passing around a single
structure of common arguments instead of passing "too many" args
in each function call.

o Add support for the AAA-131 as a SCSI adapter.

o Add support for the AHA-4944 courtesy of "Matthew N. Dodd" <winter@jurai.net

o Correct manual termination support for PCI cards. The bit definitions
for manual termination control in the SEEPROM were incorrect.

o Add support for extracting NVRAM information from SCB 2 for BIOSen
that use this mechanism to pass this data to OS drivers.

o Properly set the STPWLEVEL bit in PCI config space based on the
setting in an SEEPROM.

o Go back to useing 32byte SCBs for all controllers. The current
firmware allows us to embed 12byte cdbs on all controllers in
a 32byte SCB, and larger cdbs are rarely used, so it is a
better use of this space to offer more SCBs (32).

o Add support for U160 transfers.

o Add an idle loop executed during data transfers that prefetches
S/G segments on controllers that have a secondary DMA engine
(aic789X).

o Improve the performance of reselections by avoiding an extra
one byte DMA in the case of an SCB lookup miss for the reselecting
target. We now keep a 16byte "untagged target" array on the card
for dealing with untagged reselections. If the controller has
external SCB ram and can support 64byte SCBs, then we use an
"untagged target/lun" array to maximize concurrency. Without
external SCB ram, the controller is limited to one untagged
transaction per target, auto-request sense operations excluded.

o Correct the setup of the STPWEN bit in SXFRCTL1. This control
line is tri-stated until set to one, so set it to one and then
set it to the desired value.

o Add tagged queuing support to our target role implementation.

o Handle the common cases of the ignore wide residue message
in firmware.

o Add preliminary support for 39bit addressing.

o Add support for assembling on big-endian machines. Big-endian
support is not complete in the driver.

o Correctly remove SCBs in the waiting for selection queue when
freezing a device queue.

o Now that we understand more about the autoflush bug on the
aic7890, only use the workaround on devices that need it.

o Add a workaround for the "aic7890 hangs the system when you
attempt to pause it" problem. We can now pause the aic7890
safely regardless of what instruction it is executing.

Update copyright license terms to match the reset of the aic7xxx dirver.

Change #ifdef KERNEL to #ifdef _KERNEL in the public headers. "KERNEL"
is an application space macro and the applications are supposed to be free
to use it as they please (but cannot). This is consistant with the other
BSD's who made this change quite some time ago. More commits to come.

$Id$ -> $FreeBSD$

Massive overhaul of the aic7xxx driver:
- Convert to CAM
- Use a new DMA based queuing and paging scheme
- Add preliminary target mode support
- Add support for the aic789X chips
- Take advantage of external SRAM on more controllers.
- Numerous bug fixes and performance improvements.