* switched to use ->hostdata to get ppa_struct from Scsi_Host, end
of messing with ppa_hosts[]

	* fixed missing wakeups in ppa_pb_claim()/ppa_wakeup() - if the
former had been called just as current holder of port was giving it up,
we could set "I'm waiting" flag too late.  Cleaned up the timeout logics.

	* starting to kill ppa_detect - we move the "probe a single port"
logics into a separate function and shift scanning into ppa_driver_init().
Later that will give us a parport_driver ->attach().

	* killed include of scsi_module.h and switched from scsi_register()
to scsi_alloc_host().  We still keep the old detect logics at that point,
it will be gone later.

	* killed ppa_pb_claim() call in ppa_init()

	* switched ppa to passing around references to ppa_struct instead
of host numbers.

	* ppa.c fed through Lindent, functions unused elsewhere (by now -
	  all of them) made static.

	* switched to proper parport_driver.

	* switched to use ->hostdata to get imm_struct from Scsi_Host, end
of messing with imm_hosts[]

	* fixed missing wakeups in imm_pb_claim()/imm_wakeup() - if the
former had been called just as current holder of port was giving it up,
we could set "I'm waiting" flag too late.  Cleaned up the timeout logics.

	* starting to kill imm_detect - we move the "probe a single port"
logics into a separate function and shift scanning into imm_driver_init().
Later that will give us a parport_driver ->attach().

	* killed include of scsi_module.h and switched from scsi_register()
to scsi_alloc_host().  We still keep the old detect logics at that point,
it will be gone later.

	* killed imm_pb_claim() call in imm_init()

	* switched imm to passing around references to imm_struct instead
of host numbers.

	* imm.c fed through Lindent, functions unused elsewhere (by now -
	  all of them) made static.

paride has a ->private field for use by low-level drivers.  It's not
64bit-clean - it's int, but is used to store a pointer (bpck6).
Fix: replace with unsigned long, update typecasts in users.

pd_identify() converted to pd_special_command().

pd_init_units() merged into pd_detect(), pd_drive_count made local to
pd_detect().

Now disk->present is not needed - we can always check for disk->gd.
Field removed, pd_probe_drive() became void(struct pd_unit *), pd_detect()
cleaned up,

Moved allocation and setup (but not adding) of gendisk into
pd_probe_drive().

Switched everything except pd_identify() to use of special requests.
New helper: pd_special_command() - builds special request, feeds it
into queue and waits for completion.
Moved pi_connect()/pi_disconnect() to the beginning/end of pi_identify.

Reordered stuff
made pd_ready() inlined
renamed ps_timeout to pd_timeout
renamed ps_tq to fsm_tq
renamed ps_set_intr to fsm_schedule
removed unused pd_wait_open.

Moved calls of ->connect and ->disconnect into run_fsm().  The only
change is that now do_pd_start_io() is ran when we are connected.

Equivalent transformation:
	now that all phase functions are called claimed, we can
	simplify the logics around claiming - new variable (pd_claimed)
	keeps track of claim/unclaim we'd done.  We check it in the
	beginning of the loop and do claiming if it's not set.

Equivalent transformation:
	* phase = do_pd_io replaced with phase = NULL, corresponding
	  check + open-coded equivalent added in run_fsm loop.
	* do_pd_io() is gone.

Equivalent transformation:
	next_request() call expanded.

Equivalent transformation:
	call of pi_do_claimed() in run_fsm() expanded; recursive
	call of run_fsm() replaced with loop.

Equivalent transformation:
	pi_unclaim() moved from phase functions to run_fsm().

Equivalent transformation:
	* calls of pi_disconnect() in phase functions expanded.
	* since both do_pd_read_start() and do_pd_write_start()
	  are always called claimed (as the matter of fact,
	  all phase functions except do_pd_io() are), we can
	  replace call of pi_connect() with direct method call -
	  pi_claim() is no-op there.

Equivalent transformation:
	* new type - enum action.  phase functions return it now.
	  run_fsm() looks at the result of phase() and does the
	  corresponding action - next_request(), pi_do_claimed()
	  or ps_set_intr().

Equivalent transformation:
	* ps_continuation renamed - it's "phase" now.
	* run_fsm() does what ps_tq_int() used to do
	* calls of pi_do_claimed(..., func) replaced with
	  phase = func; pi_do_claimed(..., run_fsm);
	Now all phase functions are called from run_fsm() and we
	can start pulling the common code into it.

Equivalent transformation:
	do_pd_reqeust1() calls lambda-expanded, function killed.
	resulting call of ps_set_intr() in next_request() has been
	moved past dropping pd_lock.

Equivalent transformation:
	instead of having do_pd_request1() calling do_pd_io() via
	pi_do_claimed() and do_pd_io() calling do_pd_io_start() via
	ps_set_intr(), do it the other way round.

Equivalent transformation:
	Handling of bogus requests taken into do_pd_io_start() - we
	call next_request(0) as we would for any other error.  We
	need to call pi_unclaim() before that - on other paths that
	would happen as a side effect of pi_disconnect().
	Setting variables moved into do_pd_io_start() - they don't
	need pd_lock being held, so we can shift that outside.

Equivalent transformation:
	* new function: do_pd_io_start().  Checks pd_cmd and calls
	  do_pd_read_start() or do_pd_write_start().
	* do_pd_read() and do_pd_write() merged into do_pd_io(), which
	  schedules execution of do_pd_io_start().

pd_busy gone - we can check for pd_req != NULL instead.

Logics around "if not ready, schedule the same step again" taken
out of ps_tq_intr() and into the steps that need it.

Removed junk (see the analysis in the previous patch), removed
ps_set_intr() arguments.

Preparation to crapectomy - expanded include of pseudo.h, split
the part of pd_do_request() into pd_do_request1(), leaving in pd_do_request()
only the check that FSM is not running and call of pd_do_request1().
Added locking analysis - it's in drivers/block/paride/Transition-notes
and it will be used on the next step.  Even though the subsequent steps are
small, they rely on properties of the damn thing and proof of these properties
is hairy.  Amazing perversions people manage to produce when writing a trivial
FSM - the code is very convoluted for no good reason...

* new helper: pi_schedule_claimed() - pi_do_claimed() sans the call
  of continuation if we don't have to wait; returns 1 if we don't
  have to wait and 0 otherwise.