More duplicated code gone.

Also, remove the unused skb argument from xmit_pull_req_b().

As usual, lots of duplicated code gone.

The FIFO based cards can share the data underrun handling.

More code which can be nicely shared...

Same as for the B-Channels. We need to make sure that this doesn't
race with a new frame arriving from the upper layer, which will be done
shortly by sharing the upper layer interface as well. Protection is
provided by card->lock, which is now always taken around the entire
interrupt - more coarse-grained than possible, but still better than
the global cli(), and correctness and simplicity first.

No reason to duplicate sched_event() all over the drivers...

Now repeat the steps of unifying the xmit path for B-Channels for
D-Channel handling. Parts of xmit_fill_fifo() can easily be shared.

Something else which can be nicely shared amongst various drivers...

Again, the hardware is similar enough to use a shared function,
only the method of resetting the transmitter needs to be specified.

If we lose a fragment of a frame, we need to restart from the beginning,
share that code.

More obviously duplicated code moved into just one place.

Again, lots of drivers duplicated code to start transmitting a
B-channel frame. Now we do this from one place, and the converted
drivers are obviously serialized w.r.t. calling ->BC_Send_Data()

A lot of drivers do the same thing when they're ready for transmitting
the next frame, so let's share that code.

Again, this code sequence is repeated in a lot of drivers, so 
separate it out.

There's no need for each hardware driver to implement its own
(short) xxx_schedule_event().

We used to call writewakeup() directly from handling the "frame sent"
IRQ which potentially would call back up into the common ISDN layer and
higher up still in hard-IRQ context. Instead, queue the event and use
the usual mechanism of passing it up.

Whoever did the tqueue -> workqueue changes didn't really care to look
at how it was used in the HiSax driver, making the driver compile but
oops with NULL pointer derefs.

Oh, and workqueues are really not the right solution here, tasklets are.
But that's for later.

Patches by Frank Davis.

This doesnt fix all the isdn code but it sorts out the tqueue stuff so we
are no worse than before

This is the next iteration of the workqueue abstraction.

The framework includes:

 - per-CPU queueing support.

on SMP there is a per-CPU worker thread (bound to its CPU) and per-CPU
work queues - this feature is completely transparent to workqueue-users.
keventd automatically uses this feature. XFS can now update to work-queues
and have the same per-CPU performance as it had with its per-CPU worker
threads.

 - delayed work submission

there's a new queue_delayed_work(wq, work, delay) function and a new
schedule_delayed_work(work, delay) function. The later one is used to
correctly fix former tq_timer users. I've reverted those changes in 2.5.40
that changed tq_timer uses to schedule_work() - eg. in the case of
random.c or the tty flip queue it was definitely the wrong thing to do.

delayed work means a timer embedded in struct work_struct.  I considered
using split struct work_struct and delayed_work_struct types, but lots
of code actively uses task-queues in both delayed and non-delayed mode,
so i went for the more generic approach that allows both methods of work
submission.  Delayed timers do not cause any other overhead in the
normal submission path otherwise.

 - multithreaded run_workqueue() implementation

the run_workqueue() function can now be called from multiple contexts, and
a worker thread will only use up a single entryy - this property is used
by the flushing code, and can potentially be used in the future to extend
the number of per-CPU worker threads.

 - more reliable flushing

there's now a 'pending work' counter, which is used to accurately detect
when the last work-function has finished execution. It's also used to
correctly flush against timed requests. I'm not convinced whether the old
keventd implementation got this detail right.

 - i switched the arguments of the queueing function(s) per Jeff's
   suggestion, it's more straightforward this way.


Driver fixes:

i have converted almost every affected driver to the new framework. This
cleaned up tons of code. I also fixed a number of drivers that were still
using BHs (these drivers did not compile in 2.5.40).

while this means lots of changes, it might ease the QA decision whether to
put this patch into 2.5.

The pach converts roughly 80% of all tqueue-using code to workqueues - and
all the places that are not converted to workqueues yet are places that do
not compile in vanilla 2.5.40 anyway, due to unrelated changes. I've
converted a fair number of drivers that do not compile in 2.5.40, and i
think i've managed to convert every driver that compiles under 2.5.40.

#define __NO_VERSION__ has been unnecessary for a long time, so here it
goes...

(Rusty Russell)

(by Joerg Petersohn/Karsten Keil)