ide-tape: remove pipeline-specific code from idetape_end_request()

As a side effect, remove unused idetape_kfree_stage() and
idetape_abort_pipeline()

[bart: resurrect taking tape->lock + clearing IDETAPE_FLAG_PIPELINE_ACTIVE]

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

1 files changed, 1 insertions, 79 deletions

diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index cbba475ebc5a..d907abaed909 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -686,37 +686,6 @@ static void __idetape_kfree_stage(idetape_stage_t *stage)
         kfree(stage);
 }
 
-static void idetape_kfree_stage(idetape_tape_t *tape, idetape_stage_t *stage)
-{
-        __idetape_kfree_stage(stage);
-}
-
-/*
- * This will free all the pipeline stages starting from new_last_stage->next
- * to the end of the list, and point tape->last_stage to new_last_stage.
- */
-static void idetape_abort_pipeline(ide_drive_t *drive,
-                                   idetape_stage_t *new_last_stage)
-{
-        idetape_tape_t *tape = drive->driver_data;
-        idetape_stage_t *stage = new_last_stage->next;
-        idetape_stage_t *nstage;
-
-        debug_log(DBG_PROCS, "%s: Enter %s\n", tape->name, __func__);
-
-        while (stage) {
-                nstage = stage->next;
-                idetape_kfree_stage(tape, stage);
-                --tape->nr_stages;
-                --tape->nr_pending_stages;
-                stage = nstage;
-        }
-        if (new_last_stage)
-                new_last_stage->next = NULL;
-        tape->last_stage = new_last_stage;
-        tape->next_stage = NULL;
-}
-
 /*
  * Finish servicing a request and insert a pending pipeline request into the
  * main device queue.
@@ -727,7 +696,6 @@ static int idetape_end_request(ide_drive_t *drive, int uptodate, int nr_sects)
         idetape_tape_t *tape = drive->driver_data;
         unsigned long flags;
         int error;
-        idetape_stage_t *active_stage;
 
         debug_log(DBG_PROCS, "Enter %s\n", __func__);
 
@@ -747,55 +715,9 @@ static int idetape_end_request(ide_drive_t *drive, int uptodate, int nr_sects)
 
         spin_lock_irqsave(&tape->lock, flags);
 
-        /* The request was a pipelined data transfer request */
-        if (tape->active_data_rq == rq) {
-                active_stage = tape->active_stage;
-                tape->active_stage = NULL;
-                tape->active_data_rq = NULL;
-                tape->nr_pending_stages--;
-                if (rq->cmd[0] & REQ_IDETAPE_WRITE) {
-                        if (error) {
-                                set_bit(IDETAPE_FLAG_PIPELINE_ERR,
-                                        &tape->flags);
-                                if (error == IDETAPE_ERROR_EOD)
-                                        idetape_abort_pipeline(drive,
-                                                                active_stage);
-                        }
-                } else if (rq->cmd[0] & REQ_IDETAPE_READ) {
-                        if (error == IDETAPE_ERROR_EOD) {
-                                set_bit(IDETAPE_FLAG_PIPELINE_ERR,
-                                        &tape->flags);
-                                idetape_abort_pipeline(drive, active_stage);
-                        }
-                }
-                if (tape->next_stage != NULL) {
-                        idetape_activate_next_stage(drive);
-
-                        /* Insert the next request into the request queue. */
-                        (void)ide_do_drive_cmd(drive, tape->active_data_rq,
-                                                ide_end);
-                } else if (!error) {
-                        /*
-                         * This is a part of the feedback loop which tries to
-                         * find the optimum number of stages. We are starting
-                         * from a minimum maximum number of stages, and if we
-                         * sense that the pipeline is empty, we try to increase
-                         * it, until we reach the user compile time memory
-                         * limit.
-                         */
-                        int i = (tape->max_pipeline - tape->min_pipeline) / 10;
-
-                        tape->max_stages += max(i, 1);
-                        tape->max_stages = max(tape->max_stages,
-                                                tape->min_pipeline);
-                        tape->max_stages = min(tape->max_stages,
-                                                tape->max_pipeline);
-                }
-        }
         ide_end_drive_cmd(drive, 0, 0);
 
-        if (tape->active_data_rq == NULL)
-                clear_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags);
+        clear_bit(IDETAPE_FLAG_PIPELINE_ACTIVE, &tape->flags);
         spin_unlock_irqrestore(&tape->lock, flags);
         return 0;
 }