lkml.org 
[lkml]   [2010]   [Oct]   [22]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 12/29] memstick: mspro: rework interface switch
    Date
    Now no old style state machine exist.
    Thus this patch removes now unused code.

    Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
    ---
    drivers/memstick/core/memstick.c | 15 --
    drivers/memstick/core/mspro_block.c | 328 +++++++++++++++++------------------
    drivers/memstick/core/mspro_block.h | 4 +-
    include/linux/memstick.h | 2 -
    4 files changed, 162 insertions(+), 187 deletions(-)

    diff --git a/drivers/memstick/core/memstick.c b/drivers/memstick/core/memstick.c
    index e1aa089..5eea1b2 100644
    --- a/drivers/memstick/core/memstick.c
    +++ b/drivers/memstick/core/memstick.c
    @@ -424,21 +424,6 @@ int memstick_set_rw_addr(struct memstick_dev *card)
    EXPORT_SYMBOL(memstick_set_rw_addr);


    -/**
    - * memstick_new_req - notify the host that some requests are pending
    - * @host - host to use
    - */
    -void memstick_new_req(struct memstick_host *host)
    -{
    - if (host->card) {
    - host->retries = cmd_retries;
    - INIT_COMPLETION(host->card->mrq_complete);
    - host->request(host);
    - }
    -}
    -EXPORT_SYMBOL(memstick_new_req);
    -
    -
    /*** state machine support code ***/

    /**
    diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c
    index e54d467..85018ce 100644
    --- a/drivers/memstick/core/mspro_block.c
    +++ b/drivers/memstick/core/mspro_block.c
    @@ -372,54 +372,6 @@ static sysfs_show_t mspro_block_attr_show(unsigned char tag)
    * finished (and request processor should come back some time later).
    */

    -static int h_mspro_block_req_init(struct memstick_dev *card,
    - struct memstick_request **mrq)
    -{
    - struct mspro_block_data *msb = memstick_get_drvdata(card);
    -
    - *mrq = &card->current_mrq;
    - card->next_request = msb->mrq_handler;
    - return 0;
    -}
    -
    -static int h_mspro_block_default(struct memstick_dev *card,
    - struct memstick_request **mrq)
    -{
    - return memstick_exit_state_machine(card, *mrq, (*mrq)->error);
    -}
    -
    -
    -static int h_mspro_block_get_ro(struct memstick_dev *card,
    - struct memstick_request **mrq)
    -{
    - struct mspro_block_data *msb = memstick_get_drvdata(card);
    -
    - if (!(*mrq)->error) {
    - if ((*mrq)->data[offsetof(struct ms_status_register, status0)]
    - & MEMSTICK_STATUS0_WP)
    - msb->read_only = 1;
    - else
    - msb->read_only = 0;
    - }
    -
    - return memstick_exit_state_machine(card, *mrq, (*mrq)->error);
    -}
    -
    -static int h_mspro_block_wait_for_ced(struct memstick_dev *card,
    - struct memstick_request **mrq)
    -{
    - dev_dbg(&card->dev, "wait for ced: value %x\n", (*mrq)->data[0]);
    -
    - if (!(*mrq)->error) {
    - if ((*mrq)->data[0] & (MEMSTICK_INT_CMDNAK | MEMSTICK_INT_ERR))
    - (*mrq)->error = -EFAULT;
    - else if (!((*mrq)->data[0] & MEMSTICK_INT_CED))
    - return 0;
    - }
    -
    - return memstick_exit_state_machine(card, *mrq, (*mrq)->error);
    -}
    -
    static int h_mspro_block_transfer_data(struct memstick_dev *card,
    struct memstick_request **mrq)
    {
    @@ -552,6 +504,109 @@ again:
    return 0;
    }

    +
    +static int h_mspro_block_reset(struct memstick_dev *card,
    + struct memstick_request **mrq)
    +{
    + struct mspro_block_data *msb = memstick_get_drvdata(card);
    + struct ms_status_register *status;
    + u8 intreg;
    +
    + memstick_allocate_request(card, mrq);
    + if ((*mrq)->error)
    + return memstick_exit_state_machine(card, *mrq, (*mrq)->error);
    +
    +again:
    + switch (card->state) {
    +
    + case 0: /* send request for INT reg */
    + if (memstick_read_int_reg(card, *mrq, 10000))
    + break;
    + card->state++;
    +
    + case 1: /* process the INT reg and loop if nessesary */
    + intreg = (*mrq)->data[0];
    +
    + if (intreg & MEMSTICK_INT_ERR) {
    + if ((intreg & MEMSTICK_INT_CMDNAK)) {
    + msb->read_only = true;
    + return memstick_exit_state_machine(card,
    + *mrq, 0);
    + }
    + return memstick_exit_state_machine(card, *mrq, -EIO);
    + }
    +
    + if (intreg & MEMSTICK_INT_CMDNAK)
    + return memstick_exit_state_machine(card, *mrq, -EIO);
    +
    +
    + if (!(intreg & MEMSTICK_INT_CED)) {
    + card->state--;
    + goto again;
    + }
    +
    + memstick_read_int_reg_cleanup(card);
    + card->state++;
    +
    + case 2: /* read the R/O status */
    +
    + if (!memstick_read_regs(card,
    + offsetof(struct mspro_register, status),
    + sizeof(struct ms_status_register),
    + *mrq))
    + return 0;
    + break;
    +
    + case 3: /* process the result & done */
    + status = (struct ms_status_register *)(*mrq)->data;
    + msb->read_only = status->status0 & MEMSTICK_STATUS0_WP;
    + return memstick_exit_state_machine(card, *mrq, 0);
    + }
    +
    + card->state++;
    + return 0;
    +
    +}
    +
    +static int h_mspro_block_switch_interface(struct memstick_dev *card,
    + struct memstick_request **mrq)
    +{
    + struct mspro_block_data *msb = memstick_get_drvdata(card);
    + int error;
    + memstick_allocate_request(card, mrq);
    + if ((*mrq)->error)
    + return memstick_exit_state_machine(card, *mrq, (*mrq)->error);
    +
    + switch (card->state) {
    +
    + case 0: /* send switch command to the device */
    + if (!memstick_write_regs(card,
    + offsetof(struct mspro_register, param),
    + 1,
    + &msb->system,
    + *mrq))
    + return 0;
    + break;
    +
    + case 1: /* switch the host intrface + send dummy read to verify that */
    + /* connection works */
    + error = card->host->set_param(card->host,
    + MEMSTICK_INTERFACE, msb->target_interface);
    + if (error)
    + return memstick_exit_state_machine(card, *mrq, -EFAULT);
    +
    + memstick_init_req(*mrq, MS_TPC_GET_INT, NULL, 1);
    + break;
    +
    + case 2: /* done */
    + return memstick_exit_state_machine(card, *mrq, 0);
    +
    + }
    +
    + card->state++;
    + return 0;
    +}
    +
    /*** Data transfer ***/

    /* Common helper that prepares state for IO (read, write, read attributes) */
    @@ -717,113 +772,77 @@ static void mspro_block_submit_req(struct request_queue *q)

    /*** Initialization ***/

    -static int mspro_block_wait_for_ced(struct memstick_dev *card)
    +/* Reset the card */
    +static int mspro_block_reset(struct memstick_dev *card, bool full)
    {
    struct mspro_block_data *msb = memstick_get_drvdata(card);
    + int error;

    - card->next_request = h_mspro_block_req_init;
    - msb->mrq_handler = h_mspro_block_wait_for_ced;
    - memstick_init_req(&card->current_mrq, MS_TPC_GET_INT, NULL, 1);
    - memstick_new_req(card->host);
    - wait_for_completion(&card->mrq_complete);
    - return card->current_mrq.error;
    -}
    + dbg(card, "resetting the card");

    -static int mspro_block_set_interface(struct memstick_dev *card,
    - unsigned char sys_reg)
    -{
    - struct memstick_host *host = card->host;
    - struct mspro_block_data *msb = memstick_get_drvdata(card);
    - struct mspro_param_register param = {
    - .system = sys_reg,
    - .data_count = 0,
    - .data_address = 0,
    - .tpc_param = 0
    - };
    + msb->system = MEMSTICK_SYS_SERIAL;

    - card->next_request = h_mspro_block_req_init;
    - msb->mrq_handler = h_mspro_block_default;
    - memstick_init_req(&card->current_mrq, MS_TPC_WRITE_REG, &param,
    - sizeof(param));
    - memstick_new_req(host);
    - wait_for_completion(&card->mrq_complete);
    - return card->current_mrq.error;
    + if (full) {
    + error = memstick_reset(card->host);
    + if (error) {
    + dbg(card, "host controller reset failure");
    + return error;
    + }
    + }
    +
    + msleep(150);
    +
    + error = memstick_run_state_machine(card, h_mspro_block_reset, true);
    + if (error) {
    + dbg(card, "card reset failure");
    + return error;
    + }
    +
    + return mspro_block_switch_interface(card);
    }

    +/*
    + * Attempts to switch to faster interface.
    + * If switch fails it clears the card capability of this mode
    + * and calls reset which might call this function again but that
    + * time it won't attempt failed mode
    + */
    static int mspro_block_switch_interface(struct memstick_dev *card)
    {
    struct memstick_host *host = card->host;
    struct mspro_block_data *msb = memstick_get_drvdata(card);
    - int rc = 0;
    + int error = 0;

    -try_again:
    - if (msb->caps & MEMSTICK_CAP_PAR4)
    - rc = mspro_block_set_interface(card, MEMSTICK_SYS_PAR4);
    - else
    + if (!(card->caps & host->caps & MEMSTICK_CAP_PAR4))
    return 0;

    - if (rc) {
    - printk(KERN_WARNING
    - "%s: could not switch to 4-bit mode, error %d\n",
    - dev_name(&card->dev), rc);
    - return 0;
    - }
    + dbg(card, "switching to parallel 4 bit inteface");

    msb->system = MEMSTICK_SYS_PAR4;
    - host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_PAR4);
    - printk(KERN_INFO "%s: switching to 4-bit parallel mode\n",
    - dev_name(&card->dev));
    -
    - if (msb->caps & MEMSTICK_CAP_PAR8) {
    - rc = mspro_block_set_interface(card, MEMSTICK_SYS_PAR8);
    -
    - if (!rc) {
    - msb->system = MEMSTICK_SYS_PAR8;
    - host->set_param(host, MEMSTICK_INTERFACE,
    - MEMSTICK_PAR8);
    - printk(KERN_INFO
    - "%s: switching to 8-bit parallel mode\n",
    - dev_name(&card->dev));
    - } else
    - printk(KERN_WARNING
    - "%s: could not switch to 8-bit mode, error %d\n",
    - dev_name(&card->dev), rc);
    + msb->target_interface = MEMSTICK_PAR4;
    + error = memstick_run_state_machine(card,
    + h_mspro_block_switch_interface, true);
    + if (error) {
    + dbg(card, "failure to switch to parallel 4 bit inteface");
    + card->caps &= ~MEMSTICK_CAP_PAR4;
    + return mspro_block_reset(card, true);
    }

    - card->next_request = h_mspro_block_req_init;
    - msb->mrq_handler = h_mspro_block_default;
    - memstick_init_req(&card->current_mrq, MS_TPC_GET_INT, NULL, 1);
    - memstick_new_req(card->host);
    - wait_for_completion(&card->mrq_complete);
    - rc = card->current_mrq.error;
    + if (!(card->caps & host->caps & MEMSTICK_CAP_PAR8))
    + return 0;

    - if (rc) {
    - printk(KERN_WARNING
    - "%s: interface error, trying to fall back to serial\n",
    - dev_name(&card->dev));
    - msb->system = MEMSTICK_SYS_SERIAL;
    - host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
    - msleep(10);
    - host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
    - host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);
    -
    - rc = memstick_set_rw_addr(card);
    - if (!rc)
    - rc = mspro_block_set_interface(card, msb->system);
    -
    - if (!rc) {
    - msleep(150);
    - rc = mspro_block_wait_for_ced(card);
    - if (rc)
    - return rc;
    -
    - if (msb->caps & MEMSTICK_CAP_PAR8) {
    - msb->caps &= ~MEMSTICK_CAP_PAR8;
    - goto try_again;
    - }
    - }
    + msb->system = MEMSTICK_SYS_PAR8;
    + msb->target_interface = MEMSTICK_PAR8;
    + dbg(card, "switching to parallel 8 bit inteface");
    + error = memstick_run_state_machine(card,
    + h_mspro_block_switch_interface, true);
    + if (error) {
    + dbg(card, "failure to switch to parallel 8 bit inteface");
    + card->caps &= ~MEMSTICK_CAP_PAR8;
    + return mspro_block_reset(card, true);
    }
    - return rc;
    +
    + return error;
    }

    /* Read data from attribute space */
    @@ -857,7 +876,7 @@ static int mspro_block_read_attributes(struct memstick_dev *card)

    int cnt, error, attr_count;

    - /* Allocate initial buffer */
    + /* Allocate cache buffer */
    buffer_size = msb->page_size;
    buffer_address = 0;
    buffer = kmalloc(buffer_size, GFP_KERNEL);
    @@ -981,52 +1000,27 @@ out_free_buffer:
    static int mspro_block_init_card(struct memstick_dev *card)
    {
    struct mspro_block_data *msb = memstick_get_drvdata(card);
    - struct memstick_host *host = card->host;
    int rc = 0;

    - msb->system = MEMSTICK_SYS_SERIAL;
    - card->reg_addr.r_offset = offsetof(struct mspro_register, status);
    - card->reg_addr.r_length = sizeof(struct ms_status_register);
    - card->reg_addr.w_offset = offsetof(struct mspro_register, param);
    - card->reg_addr.w_length = sizeof(struct mspro_param_register);
    -
    - if (memstick_set_rw_addr(card))
    - return -EIO;
    + card->caps = MEMSTICK_CAP_PAR4 | MEMSTICK_CAP_PAR8;

    - msb->caps = host->caps;
    -
    - msleep(150);
    - rc = mspro_block_wait_for_ced(card);
    + rc = mspro_block_reset(card, false);
    if (rc)
    return rc;

    - rc = mspro_block_switch_interface(card);
    - if (rc)
    - return rc;
    -
    - dev_dbg(&card->dev, "card activated\n");
    + dbg(card, "card activated");
    if (msb->system != MEMSTICK_SYS_SERIAL)
    - msb->caps |= MEMSTICK_CAP_AUTO_GET_INT;
    -
    - card->next_request = h_mspro_block_req_init;
    - msb->mrq_handler = h_mspro_block_get_ro;
    - memstick_init_req(&card->current_mrq, MS_TPC_READ_REG, NULL,
    - sizeof(struct ms_status_register));
    - memstick_new_req(card->host);
    - wait_for_completion(&card->mrq_complete);
    - if (card->current_mrq.error)
    - return card->current_mrq.error;
    + card->caps |= MEMSTICK_CAP_AUTO_GET_INT;

    - dev_dbg(&card->dev, "card r/w status %d\n", msb->read_only ? 0 : 1);
    + dbg(card, "card r/w status %d", msb->read_only ? 0 : 1);

    msb->page_size = 512;
    rc = mspro_block_read_attributes(card);
    if (rc)
    return rc;

    - dev_dbg(&card->dev, "attributes loaded\n");
    + dbg(card, "attributes loaded");
    return 0;
    -
    }

    static int mspro_block_init_disk(struct memstick_dev *card)
    diff --git a/drivers/memstick/core/mspro_block.h b/drivers/memstick/core/mspro_block.h
    index 82ae2fe..a7ba42d 100644
    --- a/drivers/memstick/core/mspro_block.h
    +++ b/drivers/memstick/core/mspro_block.h
    @@ -135,9 +135,6 @@ struct mspro_block_data {
    spinlock_t q_lock;
    struct scatterlist req_sg[MSPRO_BLOCK_MAX_SEGS];

    - int (*mrq_handler)(struct memstick_dev *card,
    - struct memstick_request **mrq);
    -
    unsigned char read_only:1;
    unsigned char eject:1;
    unsigned char active:1;
    @@ -157,6 +154,7 @@ struct mspro_block_data {
    unsigned int current_sg_offset;
    unsigned int data_transferred;
    unsigned char data_dir:1;
    + unsigned int target_interface;
    int io_error;
    };

    diff --git a/include/linux/memstick.h b/include/linux/memstick.h
    index 73586cb..4700543 100644
    --- a/include/linux/memstick.h
    +++ b/include/linux/memstick.h
    @@ -366,8 +366,6 @@ int memstick_exit_state_machine(struct memstick_dev *card,
    void memstick_allocate_request(struct memstick_dev *card,
    struct memstick_request **mrq);

    -void memstick_new_req(struct memstick_host *host);
    -
    void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
    const struct scatterlist *sg);
    void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
    --
    1.7.1


    \
     
     \ /
      Last update: 2010-10-23 01:57    [W:0.050 / U:29.788 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site