lkml.org 
[lkml]   [2008]   [Jul]   [28]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 03/12] ipwireless: Rename spinlock variables to lock
    Date
    ipwireless: Rename spinlock variables to lock

    Signed-off-by: David Sterba <dsterba@suse.cz>
    Signed-off-by: Jiri Kosina <jkosina@suse.cz>
    ---

    drivers/char/pcmcia/ipwireless/hardware.c | 96 +++++++++++++++--------------
    drivers/char/pcmcia/ipwireless/network.c | 46 +++++++-------
    2 files changed, 71 insertions(+), 71 deletions(-)

    diff --git a/drivers/char/pcmcia/ipwireless/hardware.c b/drivers/char/pcmcia/ipwireless/hardware.c
    index ce57a7f..f948791 100644
    --- a/drivers/char/pcmcia/ipwireless/hardware.c
    +++ b/drivers/char/pcmcia/ipwireless/hardware.c
    @@ -242,7 +242,7 @@ struct ipw_hardware {
    unsigned int base_port;
    short hw_version;
    unsigned short ll_mtu;
    - spinlock_t spinlock;
    + spinlock_t lock;

    int initializing;
    int init_loops;
    @@ -400,7 +400,7 @@ static int do_send_fragment(struct ipw_hardware *hw, const unsigned char *data,
    if (ipwireless_debug)
    dump_data_bytes("send", data, length);

    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);

    hw->tx_ready = 0;

    @@ -437,7 +437,7 @@ static int do_send_fragment(struct ipw_hardware *hw, const unsigned char *data,
    writew(MEMRX_RX, &hw->memory_info_regs->memreg_rx);
    }

    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);

    end_write_timing(length);

    @@ -490,10 +490,10 @@ static int do_send_packet(struct ipw_hardware *hw, struct ipw_tx_packet *packet)
    */
    unsigned long flags;

    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    list_add(&packet->queue, &hw->tx_queue[0]);
    hw->tx_queued++;
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    } else {
    if (packet->packet_callback)
    packet->packet_callback(packet->callback_data,
    @@ -508,7 +508,7 @@ static void ipw_setup_hardware(struct ipw_hardware *hw)
    {
    unsigned long flags;

    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    if (hw->hw_version == HW_VERSION_1) {
    /* Reset RX FIFO */
    outw(DCR_RXRESET, hw->base_port + IODCR);
    @@ -527,7 +527,7 @@ static void ipw_setup_hardware(struct ipw_hardware *hw)
    csr |= 1;
    writew(csr, &hw->memregs_CCR->reg_config_and_status);
    }
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    }

    /*
    @@ -546,18 +546,18 @@ static struct ipw_rx_packet *pool_allocate(struct ipw_hardware *hw,
    if (!packet) {
    unsigned long flags;

    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    if (!list_empty(&hw->rx_pool)) {
    packet = list_first_entry(&hw->rx_pool,
    struct ipw_rx_packet, queue);
    list_del(&packet->queue);
    hw->rx_pool_size--;
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    } else {
    static int min_capacity = 256;
    int new_capacity;

    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    new_capacity =
    (minimum_free_space > min_capacity
    ? minimum_free_space
    @@ -645,9 +645,9 @@ static void queue_received_packet(struct ipw_hardware *hw,
    packet = *assem;
    *assem = NULL;
    /* Count queued DATA bytes only */
    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    hw->rx_bytes_queued += packet->length;
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    }
    } else {
    /* If it's a CTRL packet, don't assemble, just queue it. */
    @@ -669,13 +669,13 @@ static void queue_received_packet(struct ipw_hardware *hw,
    * network layer.
    */
    if (packet) {
    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    list_add_tail(&packet->queue, &hw->rx_queue);
    /* Block reception of incoming packets if queue is full. */
    hw->blocking_rx =
    (hw->rx_bytes_queued >= IPWIRELESS_RX_QUEUE_SIZE);

    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    schedule_work(&hw->work_rx);
    }
    }
    @@ -689,7 +689,7 @@ static void ipw_receive_data_work(struct work_struct *work_rx)
    container_of(work_rx, struct ipw_hardware, work_rx);
    unsigned long flags;

    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    while (!list_empty(&hw->rx_queue)) {
    struct ipw_rx_packet *packet =
    list_first_entry(&hw->rx_queue,
    @@ -707,7 +707,7 @@ static void ipw_receive_data_work(struct work_struct *work_rx)
    if (packet->protocol == TL_PROTOCOLID_COM_DATA) {
    if (hw->network != NULL) {
    /* If the network hasn't been disconnected. */
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    /*
    * This must run unlocked due to tty processing
    * and mutex locking
    @@ -718,7 +718,7 @@ static void ipw_receive_data_work(struct work_struct *work_rx)
    (unsigned char *)packet
    + sizeof(struct ipw_rx_packet),
    packet->length);
    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    }
    /* Count queued DATA bytes only */
    hw->rx_bytes_queued -= packet->length;
    @@ -742,7 +742,7 @@ static void ipw_receive_data_work(struct work_struct *work_rx)
    if (hw->shutting_down)
    break;
    }
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    }

    static void handle_received_CTRL_packet(struct ipw_hardware *hw,
    @@ -914,17 +914,17 @@ static int get_packets_from_hw(struct ipw_hardware *hw)
    int received = 0;
    unsigned long flags;

    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    while (hw->rx_ready && !hw->blocking_rx) {
    received = 1;
    hw->rx_ready--;
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);

    do_receive_packet(hw);

    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    }
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);

    return received;
    }
    @@ -940,7 +940,7 @@ static int send_pending_packet(struct ipw_hardware *hw, int priority_limit)
    int more_to_send = 0;
    unsigned long flags;

    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    if (hw->tx_queued && hw->tx_ready) {
    int priority;
    struct ipw_tx_packet *packet = NULL;
    @@ -961,17 +961,17 @@ static int send_pending_packet(struct ipw_hardware *hw, int priority_limit)
    }
    if (!packet) {
    hw->tx_queued = 0;
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    return 0;
    }

    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);

    /* Send */
    do_send_packet(hw, packet);

    /* Check if more to send */
    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    for (priority = 0; priority < priority_limit; priority++)
    if (!list_empty(&hw->tx_queue[priority])) {
    more_to_send = 1;
    @@ -981,7 +981,7 @@ static int send_pending_packet(struct ipw_hardware *hw, int priority_limit)
    if (!more_to_send)
    hw->tx_queued = 0;
    }
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);

    return more_to_send;
    }
    @@ -994,9 +994,9 @@ static void ipwireless_do_tasklet(unsigned long hw_)
    struct ipw_hardware *hw = (struct ipw_hardware *) hw_;
    unsigned long flags;

    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    if (hw->shutting_down) {
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    return;
    }

    @@ -1005,7 +1005,7 @@ static void ipwireless_do_tasklet(unsigned long hw_)
    * Initial setup data sent to hardware
    */
    hw->to_setup = 2;
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);

    ipw_setup_hardware(hw);
    ipw_send_setup_packet(hw);
    @@ -1016,7 +1016,7 @@ static void ipwireless_do_tasklet(unsigned long hw_)
    int priority_limit = get_current_packet_priority(hw);
    int again;

    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);

    do {
    again = send_pending_packet(hw, priority_limit);
    @@ -1054,16 +1054,16 @@ static irqreturn_t ipwireless_handle_v1_interrupt(int irq,
    /* Transmit complete. */
    if (irqn & IR_TXINTR) {
    ack |= IR_TXINTR;
    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    hw->tx_ready = 1;
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    }
    /* Received data */
    if (irqn & IR_RXINTR) {
    ack |= IR_RXINTR;
    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    hw->rx_ready++;
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    }
    if (ack != 0) {
    outw(ack, hw->base_port + IOIR);
    @@ -1134,9 +1134,9 @@ static irqreturn_t ipwireless_handle_v2_v3_interrupt(int irq,
    if (hw->serial_number_detected) {
    if (memtx_serial != hw->last_memtx_serial) {
    hw->last_memtx_serial = memtx_serial;
    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    hw->rx_ready++;
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    rx = 1;
    } else
    /* Ignore 'Timer Recovery' duplicates. */
    @@ -1151,18 +1151,18 @@ static irqreturn_t ipwireless_handle_v2_v3_interrupt(int irq,
    printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
    ": memreg_tx serial num detected\n");

    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    hw->rx_ready++;
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    }
    rx = 1;
    }
    }
    if (memrxdone & MEMRX_RX_DONE) {
    writew(0, &hw->memory_info_regs->memreg_rx_done);
    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    hw->tx_ready = 1;
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    tx = 1;
    }
    if (tx)
    @@ -1211,9 +1211,9 @@ static void flush_packets_to_hw(struct ipw_hardware *hw)
    int priority_limit;
    unsigned long flags;

    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    priority_limit = get_current_packet_priority(hw);
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);

    while (send_pending_packet(hw, priority_limit));
    }
    @@ -1223,10 +1223,10 @@ static void send_packet(struct ipw_hardware *hw, int priority,
    {
    unsigned long flags;

    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    list_add_tail(&packet->queue, &hw->tx_queue[priority]);
    hw->tx_queued++;
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);

    flush_packets_to_hw(hw);
    }
    @@ -1612,7 +1612,7 @@ struct ipw_hardware *ipwireless_hardware_create(void)

    INIT_LIST_HEAD(&hw->rx_queue);
    INIT_LIST_HEAD(&hw->rx_pool);
    - spin_lock_init(&hw->spinlock);
    + spin_lock_init(&hw->lock);
    tasklet_init(&hw->tasklet, ipwireless_do_tasklet, (unsigned long) hw);
    INIT_WORK(&hw->work_rx, ipw_receive_data_work);
    setup_timer(&hw->setup_timer, ipwireless_setup_timer,
    @@ -1678,10 +1678,10 @@ static void ipwireless_setup_timer(unsigned long data)
    if (is_card_present(hw)) {
    unsigned long flags;

    - spin_lock_irqsave(&hw->spinlock, flags);
    + spin_lock_irqsave(&hw->lock, flags);
    hw->to_setup = 1;
    hw->tx_ready = 1;
    - spin_unlock_irqrestore(&hw->spinlock, flags);
    + spin_unlock_irqrestore(&hw->lock, flags);
    tasklet_schedule(&hw->tasklet);
    }

    diff --git a/drivers/char/pcmcia/ipwireless/network.c b/drivers/char/pcmcia/ipwireless/network.c
    index cf12eb4..28d9fd7 100644
    --- a/drivers/char/pcmcia/ipwireless/network.c
    +++ b/drivers/char/pcmcia/ipwireless/network.c
    @@ -45,7 +45,7 @@ struct ipw_network {
    /* Number of packets queued up in hardware module. */
    int outgoing_packets_queued;
    /* Spinlock to avoid interrupts during shutdown */
    - spinlock_t spinlock;
    + spinlock_t lock;
    struct mutex close_lock;

    /* PPP ioctl data, not actually used anywere */
    @@ -67,20 +67,20 @@ static void notify_packet_sent(void *callback_data, unsigned int packet_length)
    struct ipw_network *network = callback_data;
    unsigned long flags;

    - spin_lock_irqsave(&network->spinlock, flags);
    + spin_lock_irqsave(&network->lock, flags);
    network->outgoing_packets_queued--;
    if (network->ppp_channel != NULL) {
    if (network->ppp_blocked) {
    network->ppp_blocked = 0;
    - spin_unlock_irqrestore(&network->spinlock, flags);
    + spin_unlock_irqrestore(&network->lock, flags);
    ppp_output_wakeup(network->ppp_channel);
    if (ipwireless_debug)
    printk(KERN_INFO IPWIRELESS_PCCARD_NAME
    ": ppp unblocked\n");
    } else
    - spin_unlock_irqrestore(&network->spinlock, flags);
    + spin_unlock_irqrestore(&network->lock, flags);
    } else
    - spin_unlock_irqrestore(&network->spinlock, flags);
    + spin_unlock_irqrestore(&network->lock, flags);
    }

    /*
    @@ -92,7 +92,7 @@ static int ipwireless_ppp_start_xmit(struct ppp_channel *ppp_channel,
    struct ipw_network *network = ppp_channel->private;
    unsigned long flags;

    - spin_lock_irqsave(&network->spinlock, flags);
    + spin_lock_irqsave(&network->lock, flags);
    if (network->outgoing_packets_queued < ipwireless_out_queue) {
    unsigned char *buf;
    static unsigned char header[] = {
    @@ -102,7 +102,7 @@ static int ipwireless_ppp_start_xmit(struct ppp_channel *ppp_channel,
    int ret;

    network->outgoing_packets_queued++;
    - spin_unlock_irqrestore(&network->spinlock, flags);
    + spin_unlock_irqrestore(&network->lock, flags);

    /*
    * If we have the requested amount of headroom in the skb we
    @@ -143,7 +143,7 @@ static int ipwireless_ppp_start_xmit(struct ppp_channel *ppp_channel,
    * needs to be unblocked once we are ready to send.
    */
    network->ppp_blocked = 1;
    - spin_unlock_irqrestore(&network->spinlock, flags);
    + spin_unlock_irqrestore(&network->lock, flags);
    return 0;
    }
    }
    @@ -248,11 +248,11 @@ static void do_go_online(struct work_struct *work_go_online)
    work_go_online);
    unsigned long flags;

    - spin_lock_irqsave(&network->spinlock, flags);
    + spin_lock_irqsave(&network->lock, flags);
    if (!network->ppp_channel) {
    struct ppp_channel *channel;

    - spin_unlock_irqrestore(&network->spinlock, flags);
    + spin_unlock_irqrestore(&network->lock, flags);
    channel = kzalloc(sizeof(struct ppp_channel), GFP_KERNEL);
    if (!channel) {
    printk(KERN_ERR IPWIRELESS_PCCARD_NAME
    @@ -272,10 +272,10 @@ static void do_go_online(struct work_struct *work_go_online)
    network->xaccm[3] = 0x60000000U;
    network->raccm = ~0U;
    ppp_register_channel(channel);
    - spin_lock_irqsave(&network->spinlock, flags);
    + spin_lock_irqsave(&network->lock, flags);
    network->ppp_channel = channel;
    }
    - spin_unlock_irqrestore(&network->spinlock, flags);
    + spin_unlock_irqrestore(&network->lock, flags);
    }

    static void do_go_offline(struct work_struct *work_go_offline)
    @@ -286,16 +286,16 @@ static void do_go_offline(struct work_struct *work_go_offline)
    unsigned long flags;

    mutex_lock(&network->close_lock);
    - spin_lock_irqsave(&network->spinlock, flags);
    + spin_lock_irqsave(&network->lock, flags);
    if (network->ppp_channel != NULL) {
    struct ppp_channel *channel = network->ppp_channel;

    network->ppp_channel = NULL;
    - spin_unlock_irqrestore(&network->spinlock, flags);
    + spin_unlock_irqrestore(&network->lock, flags);
    mutex_unlock(&network->close_lock);
    ppp_unregister_channel(channel);
    } else {
    - spin_unlock_irqrestore(&network->spinlock, flags);
    + spin_unlock_irqrestore(&network->lock, flags);
    mutex_unlock(&network->close_lock);
    }
    }
    @@ -380,18 +380,18 @@ void ipwireless_network_packet_received(struct ipw_network *network,
    * the PPP layer.
    */
    mutex_lock(&network->close_lock);
    - spin_lock_irqsave(&network->spinlock, flags);
    + spin_lock_irqsave(&network->lock, flags);
    if (network->ppp_channel != NULL) {
    struct sk_buff *skb;

    - spin_unlock_irqrestore(&network->spinlock,
    + spin_unlock_irqrestore(&network->lock,
    flags);

    /* Send the data to the ppp_generic module. */
    skb = ipw_packet_received_skb(data, length);
    ppp_input(network->ppp_channel, skb);
    } else
    - spin_unlock_irqrestore(&network->spinlock,
    + spin_unlock_irqrestore(&network->lock,
    flags);
    mutex_unlock(&network->close_lock);
    }
    @@ -409,7 +409,7 @@ struct ipw_network *ipwireless_network_create(struct ipw_hardware *hw)
    if (!network)
    return NULL;

    - spin_lock_init(&network->spinlock);
    + spin_lock_init(&network->lock);
    mutex_init(&network->close_lock);

    network->hardware = hw;
    @@ -477,10 +477,10 @@ int ipwireless_ppp_channel_index(struct ipw_network *network)
    int ret = -1;
    unsigned long flags;

    - spin_lock_irqsave(&network->spinlock, flags);
    + spin_lock_irqsave(&network->lock, flags);
    if (network->ppp_channel != NULL)
    ret = ppp_channel_index(network->ppp_channel);
    - spin_unlock_irqrestore(&network->spinlock, flags);
    + spin_unlock_irqrestore(&network->lock, flags);

    return ret;
    }
    @@ -490,10 +490,10 @@ int ipwireless_ppp_unit_number(struct ipw_network *network)
    int ret = -1;
    unsigned long flags;

    - spin_lock_irqsave(&network->spinlock, flags);
    + spin_lock_irqsave(&network->lock, flags);
    if (network->ppp_channel != NULL)
    ret = ppp_unit_number(network->ppp_channel);
    - spin_unlock_irqrestore(&network->spinlock, flags);
    + spin_unlock_irqrestore(&network->lock, flags);

    return ret;
    }


    \
     
     \ /
      Last update: 2008-07-28 16:55    [W:0.054 / U:1.504 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site