tree 5ac765703ad79edeafc6eec39fe42850bd6b5dc6
parent aa5d2de7b080873f6d9ac3aede423c9713bf0caa
author Bartlomiej Zolnierkiewicz <bzolnier@gmail.com> 1223926772 +0200
committer Bartlomiej Zolnierkiewicz <bzolnier@gmail.com> 1223926772 +0200

ide: make ide_transfer_pc() static

* Move ->ticks field from struct ide_floppy_obj to ide_drive_t.

* Move idefloppy_transfer_pc() to ide-atapi.c and make
  ide_transfer_pc() use it.

* Always use ide_transfer_pc as a handler in ide_issue_pc().

* Remove no longer used idefloppy_start_pc_transfer(),
  ide*_transfer_pc() and 'handler' argument from ide_issue_pc().

* Make ide_transfer_pc() static.

While at it:

* idefloppy_transfer_pc() -> ide_delayed_transfer_pc()

* IDEFLOPPY_TICKS_DELAY -> IDEFLOPPY_PC_DELAY

* ->ticks -> ->pc_delay

There should be no functional changes caused by this patch.

Cc: Borislav Petkov <petkovbb@gmail.com>
Signed-off-by: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
