Collect together the components of several drivers and export eisa from
the i386-only area (It's not, it's on some alphas too). The code hasn't
been updated to work on the Alpha yet, but that can come later.
Repository copies were done a while ago.
Moving these now keeps them in consistant place across the 4.x series
as the newbusification progresses.
Submitted by: mdodd
things like sound cards can get called "Parallel port". A note to the
unwary; the isa-pnp devices in the system are probed like PCI - each
device ID is passed to *all* isa probe routines to find the best match.
If the driver is not prepared to deal with this, it must abort in this
scenario or it will try and claim all PnP devices.
Update list of supported products.
Adjust probe message to include the ASC3030.
advansys.c:
Fix a long standing bug in the error recovery strategy. In order
to keep recovery simple, we freeze the SIMQ, stopping the XPT from
submitting new requests. Unfortunately, we also will freeze the
SIMQ if bus_dmamap_load blocks or we run out of controller resources.
On cards with limited resources it was possible to freeze the
SIM a second time and never unfreeze it. Now we more carefully
track our exception state so we never freeze the SIMQ more than
once.
Don't rely on pointers fitting in a 32bit field stored in the
per-transaction data structures on the card. Use an index to
an array of transaction mapping structures instead. This should
allow this driver to work on the Alpha.
Deal with the ASC3030 which is almost idistinguishable from the
ASC3050. Unfortunately the ASC3030 does not work at Ultra speeds,
so if we can't find an eeprom, we must assume that ultra is disabled.
The SIIG cards using the 3030 do not have eeproms. As a side effect,
we now honor the ultra disable bit in the eeprom if it is present.
Don't bother attempting to write corrected eeprom data back to the
eeprom. We can function just fine if the data is corrupted and
I'd rather not risk messing up the user's eeprom.
Modify the interrupt handler to catch latched external bus rests.
Dynamically determine the maximum number of S/G elements we can
map at a single time. The nature of the firmware interface for
these cards makes this value dependent on the number of "queues"
the card can support.
advlib.c:
advlib.h:
advmcode.c:
advmcode.h:
Synchronize with the latest firmware image released in the
Linux Advansys driver.
USB-EL1202A chipset. Between this and the other two drivers, we should
have support for pretty much every USB ethernet adapter on the market.
The only other USB chip that I know of is the SMC USB97C196, and right
now I don't know of any adapters that use it (including the ones made
by SMC :/ ).
Note that the CATC chip supports a nifty feature: read and write combining.
This allows multiple ethernet packets to be transfered in a single USB
bulk in/out transaction. However I'm again having trouble with large
bulk in transfers like I did with the ADMtek chip, which leads me to
believe that our USB stack needs some work before we can really make
use of this feature. When/if things improve, I intend to revisit the
aue and cue drivers. For now, I've lost enough sanity points.
Do not not not call m_freem() in the txeof routines. Let the netisr routine
do it. This also makes the tx netisr queuing much simpler (I can just use
another ifqueue instead of the mess I had before.)
Thanks to Bosko Milekic for making me actually think about what I was
doing for a minute.
Note1: the correct interrupt level is invoked correctly for each driver.
For this purpose, drivers request the bus before being able to
call BUS_SETUP_INTR and BUS_TEARDOWN_INTR call is forced by the ppbus
core when drivers release it. Thus, when BUS_SETUP_INTR is called
at ppbus driver level, ppbus checks that the caller owns the
bus and stores the interrupt handler cookie (in order to unregister
it later).
Printing is impossible while plip link is up is still TRUE.
vpo (ZIP driver) and lpt are make in such a way that
using the ZIP and printing concurrently is permitted is also TRUE.
Note2: specific chipset detection is not done by default. PPC_PROBE_CHIPSET
is now needed to force chipset detection. If set, the flags 0x40
still avoid detection at boot.
Port of the pcf(4) driver to the newbus system (was previously directly
connected to the rootbus and attached by a bogus pcf_isa_probe function).
- Add vendor/device ID for Corega USB-T ethernet adapter to necessary
places so that it will work with the kue driver.
- Add vendor/device ID for CATC Netmate devices for driver to be added
soon.
- Get really crazy about netisr stuff: avoid doing any mbuf allocations
or deallocations at splbio/splusb.
- Fix if_aue driver so that it works with LinkSys USB100TX: you need
to flip the GPIO bits just the right way to put the PHY in the right
mode.
layout. It seems that I cleaned it up a bit too much and confused a few
if () {
if () {
} else {
}
}
statements in the obvious manner.
This allows the driver to transmit packets again. *sigh*
packets into a single buffer, and set the DC_TX_COALESCE flag for the
Davicom DM9102 chip. I thought I had escaped this problem, but... This
chip appears to silently corrupt or discard transmitted frames when
using scatter/gather DMA (i.e. DMAing each packet fragment in place
with a separate descriptor). The only way to insure reliable transmission
is to coalesce transmitted packets into a single cluster buffer. (There
may also be an alignment constraint here, but mbuf cluster buffers are
naturally aligned on 2K boundaries, which seems to be good enough.)
The DM9102 driver for Linux written by Davicom also uses this workaround.
Unfortunately, the Davicom datasheet has no errata section describing
this or any other apparently known defect.
Problem noted by: allan_chou@davicom.com.tw
drive the transmitter, we have to check the interface's send queue in the
TX end of frame handler (i.e. the usb bulk out callback) and push out new
transmissions if the queue has packets in it and the transmitter is
ready. But the txeof handler is also called from a USB callback running
at splusb() too.
Grrr.
Use IFQ_MAXLEN instead. This seemed like a good idea at the time since
most 3c509s have all of 2k for their TX fifo. My intention was to revisit
ifq_maxlen and auto-scale it or something.
ttcp-t: 16777216 bytes in 21.53 real seconds = 761.07 KB/sec +++
ttcp-t: 2771 I/O calls, msec/call = 7.96, calls/sec = 128.72
ttcp-t: 0.0user 2.9sys 0:21real 13% 20i+280d 222maxrss 0+2pf 717+0csw
ttcp-r: 16777216 bytes in 14.11 real seconds = 1161.48 KB/sec +++
ttcp-r: 2050 I/O calls, msec/call = 7.05, calls/sec = 145.33
ttcp-r: 0.0user 1.4sys 0:14real 10% 87i+1198d 196maxrss 0+1pf 1949+186csw
I've got some tweaks that move the TX speed up to the RX speed but I've
got to groom them from the mess I've made of my source tree.
Yelled at by: wpaul
ddb is entered. Don't refer to `in_Debugger' to see if we
are in the debugger. (The variable used to be static in Debugger()
and wasn't updated if ddb is entered via traps and panic anyway.)
- Don't refer to `in_Debugger'.
- Add `db_active' to i386/i386/db_interface.d (as in
alpha/alpha/db_interface.c).
- Remove cnpollc() stub from ddb/db_input.c.
- Add the dbctl function to syscons, pcvt, and sio. (The function for
pcvt and sio is noop at the moment.)
Jointly developed by: bde and me
(The final version was tweaked by me and not reviewed by bde. Thus,
if there is any error in this commit, that is entirely of mine, not
his.)
Some changes were obtained from: NetBSD
Packets are received inside USB bulk transfer callbacks, which run at
splusb() (actually splbio()). The packet input queues are meant to be
manipulated at splimp(). However the locking apparently breaks down under
certain circumstances and the input queues can get trampled.
There's a similar problem with if_ppp, which is driven by hardware/tty
interrupts from the serial driver, but which must also manipulate the
packet input queues at splimp(). The fix there is to use a netisr, and
that's the fix I used here. (I can hear you groaning back there. Hush up.)
The usb_ethersubr module maintains a single queue of its own. When a
packet is received in the USB callback routine, it's placed on this
queue with usb_ether_input(). This routine also schedules a soft net
interrupt with schednetisr(). The ISR routine then runs later, at
splnet, outside of the USB callback/interrupt context, and passes the
packet to ether_input(), hopefully in a safe manner.
The reason this is implemented as a separate module is that there are
a limited number of NETISRs that we can use, and snarfing one up for
each driver that needs it is wasteful (there will be three once I get
the CATC driver done). It also reduces code duplication to a certain
small extent. Unfortunately, it also needs to be linked in with the
usb.ko module in order for the USB ethernet drivers to share it.
Also removed some uneeded includes from if_aue.c and if_kue.c
Fix suggested by: peter
Not rejected as a hairbrained idea by: n_hibma
Driver is not functional yet, but does compile. Tests with xe cards
indicates that it doesn't panic the machine when they are present, but
fail to probe. Interface help in the pcic/pccard layers are needed to
complete this driver.
o ifdef out pccardchip.h (almost all of it, there are dangling bits
o Add rid/res members to pccard_function
o remove pct/pch from pccard_softc
o map memory properly in scan_cis (almost, see XXX for more work)
o manage ccr.
o remove bogus comment I added about touching the ccr being a layering
violation for pccard. It is properly done at that level.
o More function prototyping
whilst we are playing or recording. since we should irq ~20 times/sec when
active, this should never trigger. in theory. if it never does trigger,
the check will be removed.
