OSCL-LXR linux-6.0.1/​drivers/​tty/​ipwireless/​hardware.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // SPDX-License-Identifier: GPL-2.0
 /*
  * IPWireless 3G PCMCIA Network Driver
  *
  * Original code
  *   by Stephen Blackheath <stephen@blacksapphire.com>,
  *      Ben Martel <benm@symmetric.co.nz>
  *
  * Copyrighted as follows:
  *   Copyright (C) 2004 by Symmetric Systems Ltd (NZ)
  *
  * Various driver changes and rewrites, port to new kernels
  *   Copyright (C) 2006-2007 Jiri Kosina
  *
  * Misc code cleanups and updates
  *   Copyright (C) 2007 David Sterba
  */
 
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/irq.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/slab.h>
 
 #include "hardware.h"
 #include "setup_protocol.h"
 #include "network.h"
 #include "main.h"
 
 static void ipw_send_setup_packet(struct ipw_hardware *hw);
 static void handle_received_SETUP_packet(struct ipw_hardware *ipw,
                      unsigned int address,
                      const unsigned char *data, int len,
                      int is_last);
 static void ipwireless_setup_timer(struct timer_list *t);
 static void handle_received_CTRL_packet(struct ipw_hardware *hw,
         unsigned int channel_idx, const unsigned char *data, int len);
 
 /*#define TIMING_DIAGNOSTICS*/
 
 #ifdef TIMING_DIAGNOSTICS
 
 static struct timing_stats {
     unsigned long last_report_time;
     unsigned long read_time;
     unsigned long write_time;
     unsigned long read_bytes;
     unsigned long write_bytes;
     unsigned long start_time;
 };
 
 static void start_timing(void)
 {
     timing_stats.start_time = jiffies;
 }
 
 static void end_read_timing(unsigned length)
 {
     timing_stats.read_time += (jiffies - start_time);
     timing_stats.read_bytes += length + 2;
     report_timing();
 }
 
 static void end_write_timing(unsigned length)
 {
     timing_stats.write_time += (jiffies - start_time);
     timing_stats.write_bytes += length + 2;
     report_timing();
 }
 
 static void report_timing(void)
 {
     unsigned long since = jiffies - timing_stats.last_report_time;
 
     /* If it's been more than one second... */
     if (since >= HZ) {
         int first = (timing_stats.last_report_time == 0);
 
         timing_stats.last_report_time = jiffies;
         if (!first)
             printk(KERN_INFO IPWIRELESS_PCCARD_NAME
                    ": %u us elapsed - read %lu bytes in %u us, wrote %lu bytes in %u us\n",
                    jiffies_to_usecs(since),
                    timing_stats.read_bytes,
                    jiffies_to_usecs(timing_stats.read_time),
                    timing_stats.write_bytes,
                    jiffies_to_usecs(timing_stats.write_time));
 
         timing_stats.read_time = 0;
         timing_stats.write_time = 0;
         timing_stats.read_bytes = 0;
         timing_stats.write_bytes = 0;
     }
 }
 #else
 static void start_timing(void) { }
 static void end_read_timing(unsigned length) { }
 static void end_write_timing(unsigned length) { }
 #endif
 
 /* Imported IPW definitions */
 
 #define LL_MTU_V1 318
 #define LL_MTU_V2 250
 #define LL_MTU_MAX (LL_MTU_V1 > LL_MTU_V2 ? LL_MTU_V1 : LL_MTU_V2)
 
 #define PRIO_DATA  2
 #define PRIO_CTRL  1
 #define PRIO_SETUP 0
 
 /* Addresses */
 #define ADDR_SETUP_PROT 0
 
 /* Protocol ids */
 enum {
     /* Identifier for the Com Data protocol */
     TL_PROTOCOLID_COM_DATA = 0,
 
     /* Identifier for the Com Control protocol */
     TL_PROTOCOLID_COM_CTRL = 1,
 
     /* Identifier for the Setup protocol */
     TL_PROTOCOLID_SETUP = 2
 };
 
 /* Number of bytes in NL packet header (cannot do
  * sizeof(nl_packet_header) since it's a bitfield) */
 #define NL_FIRST_PACKET_HEADER_SIZE        3
 
 /* Number of bytes in NL packet header (cannot do
  * sizeof(nl_packet_header) since it's a bitfield) */
 #define NL_FOLLOWING_PACKET_HEADER_SIZE    1
 
 struct nl_first_packet_header {
     unsigned char protocol:3;
     unsigned char address:3;
     unsigned char packet_rank:2;
     unsigned char length_lsb;
     unsigned char length_msb;
 };
 
 struct nl_packet_header {
     unsigned char protocol:3;
     unsigned char address:3;
     unsigned char packet_rank:2;
 };
 
 /* Value of 'packet_rank' above */
 #define NL_INTERMEDIATE_PACKET    0x0
 #define NL_LAST_PACKET            0x1
 #define NL_FIRST_PACKET           0x2
 
 union nl_packet {
     /* Network packet header of the first packet (a special case) */
     struct nl_first_packet_header hdr_first;
     /* Network packet header of the following packets (if any) */
     struct nl_packet_header hdr;
     /* Complete network packet (header + data) */
     unsigned char rawpkt[LL_MTU_MAX];
 } __attribute__ ((__packed__));
 
 #define HW_VERSION_UNKNOWN -1
 #define HW_VERSION_1 1
 #define HW_VERSION_2 2
 
 /* IPW I/O ports */
 #define IOIER 0x00      /* Interrupt Enable Register */
 #define IOIR  0x02      /* Interrupt Source/ACK register */
 #define IODCR 0x04      /* Data Control Register */
 #define IODRR 0x06      /* Data Read Register */
 #define IODWR 0x08      /* Data Write Register */
 #define IOESR 0x0A      /* Embedded Driver Status Register */
 #define IORXR 0x0C      /* Rx Fifo Register (Host to Embedded) */
 #define IOTXR 0x0E      /* Tx Fifo Register (Embedded to Host) */
 
 /* I/O ports and bit definitions for version 1 of the hardware */
 
 /* IER bits*/
 #define IER_RXENABLED   0x1
 #define IER_TXENABLED   0x2
 
 /* ISR bits */
 #define IR_RXINTR       0x1
 #define IR_TXINTR       0x2
 
 /* DCR bits */
 #define DCR_RXDONE      0x1
 #define DCR_TXDONE      0x2
 #define DCR_RXRESET     0x4
 #define DCR_TXRESET     0x8
 
 /* I/O ports and bit definitions for version 2 of the hardware */
 
 struct MEMCCR {
     unsigned short reg_config_option;   /* PCCOR: Configuration Option Register */
     unsigned short reg_config_and_status;   /* PCCSR: Configuration and Status Register */
     unsigned short reg_pin_replacement; /* PCPRR: Pin Replacemant Register */
     unsigned short reg_socket_and_copy; /* PCSCR: Socket and Copy Register */
     unsigned short reg_ext_status;      /* PCESR: Extendend Status Register */
     unsigned short reg_io_base;     /* PCIOB: I/O Base Register */
 };
 
 struct MEMINFREG {
     unsigned short memreg_tx_old;   /* TX Register (R/W) */
     unsigned short pad1;
     unsigned short memreg_rx_done;  /* RXDone Register (R/W) */
     unsigned short pad2;
     unsigned short memreg_rx;   /* RX Register (R/W) */
     unsigned short pad3;
     unsigned short memreg_pc_interrupt_ack; /* PC intr Ack Register (W) */
     unsigned short pad4;
     unsigned long memreg_card_present;/* Mask for Host to check (R) for
                        * CARD_PRESENT_VALUE */
     unsigned short memreg_tx_new;   /* TX2 (new) Register (R/W) */
 };
 
 #define CARD_PRESENT_VALUE (0xBEEFCAFEUL)
 
 #define MEMTX_TX                       0x0001
 #define MEMRX_RX                       0x0001
 #define MEMRX_RX_DONE                  0x0001
 #define MEMRX_PCINTACKK                0x0001
 
 #define NL_NUM_OF_PRIORITIES       3
 #define NL_NUM_OF_PROTOCOLS        3
 #define NL_NUM_OF_ADDRESSES        NO_OF_IPW_CHANNELS
 
 struct ipw_hardware {
     unsigned int base_port;
     short hw_version;
     unsigned short ll_mtu;
     spinlock_t lock;
 
     int initializing;
     int init_loops;
     struct timer_list setup_timer;
 
     /* Flag if hw is ready to send next packet */
     int tx_ready;
     /* Count of pending packets to be sent */
     int tx_queued;
     struct list_head tx_queue[NL_NUM_OF_PRIORITIES];
 
     int rx_bytes_queued;
     struct list_head rx_queue;
     /* Pool of rx_packet structures that are not currently used. */
     struct list_head rx_pool;
     int rx_pool_size;
     /* True if reception of data is blocked while userspace processes it. */
     int blocking_rx;
     /* True if there is RX data ready on the hardware. */
     int rx_ready;
     unsigned short last_memtx_serial;
     /*
      * Newer versions of the V2 card firmware send serial numbers in the
      * MemTX register. 'serial_number_detected' is set true when we detect
      * a non-zero serial number (indicating the new firmware).  Thereafter,
      * the driver can safely ignore the Timer Recovery re-sends to avoid
      * out-of-sync problems.
      */
     int serial_number_detected;
     struct work_struct work_rx;
 
     /* True if we are to send the set-up data to the hardware. */
     int to_setup;
 
     /* Card has been removed */
     int removed;
     /* Saved irq value when we disable the interrupt. */
     int irq;
     /* True if this driver is shutting down. */
     int shutting_down;
     /* Modem control lines */
     unsigned int control_lines[NL_NUM_OF_ADDRESSES];
     struct ipw_rx_packet *packet_assembler[NL_NUM_OF_ADDRESSES];
 
     struct tasklet_struct tasklet;
 
     /* The handle for the network layer, for the sending of events to it. */
     struct ipw_network *network;
     struct MEMINFREG __iomem *memory_info_regs;
     struct MEMCCR __iomem *memregs_CCR;
     void (*reboot_callback) (void *data);
     void *reboot_callback_data;
 
     unsigned short __iomem *memreg_tx;
 };
 
 /*
  * Packet info structure for tx packets.
  * Note: not all the fields defined here are required for all protocols
  */
 struct ipw_tx_packet {
     struct list_head queue;
     /* channel idx + 1 */
     unsigned char dest_addr;
     /* SETUP, CTRL or DATA */
     unsigned char protocol;
     /* Length of data block, which starts at the end of this structure */
     unsigned short length;
     /* Sending state */
     /* Offset of where we've sent up to so far */
     unsigned long offset;
     /* Count of packet fragments, starting at 0 */
     int fragment_count;
 
     /* Called after packet is sent and before is freed */
     void (*packet_callback) (void *cb_data, unsigned int packet_length);
     void *callback_data;
 };
 
 /* Signals from DTE */
 #define COMCTRL_RTS 0
 #define COMCTRL_DTR 1
 
 /* Signals from DCE */
 #define COMCTRL_CTS 2
 #define COMCTRL_DCD 3
 #define COMCTRL_DSR 4
 #define COMCTRL_RI  5
 
 struct ipw_control_packet_body {
     /* DTE signal or DCE signal */
     unsigned char sig_no;
     /* 0: set signal, 1: clear signal */
     unsigned char value;
 } __attribute__ ((__packed__));
 
 struct ipw_control_packet {
     struct ipw_tx_packet header;
     struct ipw_control_packet_body body;
 };
 
 struct ipw_rx_packet {
     struct list_head queue;
     unsigned int capacity;
     unsigned int length;
     unsigned int protocol;
     unsigned int channel_idx;
 };
 
 static char *data_type(const unsigned char *buf, unsigned length)
 {
     struct nl_packet_header *hdr = (struct nl_packet_header *) buf;
 
     if (length == 0)
         return "     ";
 
     if (hdr->packet_rank & NL_FIRST_PACKET) {
         switch (hdr->protocol) {
         case TL_PROTOCOLID_COM_DATA:    return "DATA ";
         case TL_PROTOCOLID_COM_CTRL:    return "CTRL ";
         case TL_PROTOCOLID_SETUP:   return "SETUP";
         default: return "???? ";
         }
     } else
         return "     ";
 }
 
 #define DUMP_MAX_BYTES 64
 
 static void dump_data_bytes(const char *type, const unsigned char *data,
                 unsigned length)
 {
     char prefix[56];
 
     sprintf(prefix, IPWIRELESS_PCCARD_NAME ": %s %s ",
             type, data_type(data, length));
     print_hex_dump_bytes(prefix, 0, (void *)data,
             length < DUMP_MAX_BYTES ? length : DUMP_MAX_BYTES);
 }
 
 static void swap_packet_bitfield_to_le(unsigned char *data)
 {
 #ifdef __BIG_ENDIAN_BITFIELD
     unsigned char tmp = *data, ret = 0;
 
     /*
      * transform bits from aa.bbb.ccc to ccc.bbb.aa
      */
     ret |= (tmp & 0xc0) >> 6;
     ret |= (tmp & 0x38) >> 1;
     ret |= (tmp & 0x07) << 5;
     *data = ret & 0xff;
 #endif
 }
 
 static void swap_packet_bitfield_from_le(unsigned char *data)
 {
 #ifdef __BIG_ENDIAN_BITFIELD
     unsigned char tmp = *data, ret = 0;
 
     /*
      * transform bits from ccc.bbb.aa to aa.bbb.ccc
      */
     ret |= (tmp & 0xe0) >> 5;
     ret |= (tmp & 0x1c) << 1;
     ret |= (tmp & 0x03) << 6;
     *data = ret & 0xff;
 #endif
 }
 
 static void do_send_fragment(struct ipw_hardware *hw, unsigned char *data,
                 unsigned length)
 {
     unsigned i;
     unsigned long flags;
 
     start_timing();
     BUG_ON(length > hw->ll_mtu);
 
     if (ipwireless_debug)
         dump_data_bytes("send", data, length);
 
     spin_lock_irqsave(&hw->lock, flags);
 
     hw->tx_ready = 0;
     swap_packet_bitfield_to_le(data);
 
     if (hw->hw_version == HW_VERSION_1) {
         outw((unsigned short) length, hw->base_port + IODWR);
 
         for (i = 0; i < length; i += 2) {
             unsigned short d = data[i];
             __le16 raw_data;
 
             if (i + 1 < length)
                 d |= data[i + 1] << 8;
             raw_data = cpu_to_le16(d);
             outw(raw_data, hw->base_port + IODWR);
         }
 
         outw(DCR_TXDONE, hw->base_port + IODCR);
     } else if (hw->hw_version == HW_VERSION_2) {
         outw((unsigned short) length, hw->base_port);
 
         for (i = 0; i < length; i += 2) {
             unsigned short d = data[i];
             __le16 raw_data;
 
             if (i + 1 < length)
                 d |= data[i + 1] << 8;
             raw_data = cpu_to_le16(d);
             outw(raw_data, hw->base_port);
         }
         while ((i & 3) != 2) {
             outw((unsigned short) 0xDEAD, hw->base_port);
             i += 2;
         }
         writew(MEMRX_RX, &hw->memory_info_regs->memreg_rx);
     }
 
     spin_unlock_irqrestore(&hw->lock, flags);
 
     end_write_timing(length);
 }
 
 static void do_send_packet(struct ipw_hardware *hw, struct ipw_tx_packet *packet)
 {
     unsigned short fragment_data_len;
     unsigned short data_left = packet->length - packet->offset;
     unsigned short header_size;
     union nl_packet pkt;
 
     header_size =
         (packet->fragment_count == 0)
         ? NL_FIRST_PACKET_HEADER_SIZE
         : NL_FOLLOWING_PACKET_HEADER_SIZE;
     fragment_data_len = hw->ll_mtu - header_size;
     if (data_left < fragment_data_len)
         fragment_data_len = data_left;
 
     /*
      * hdr_first is now in machine bitfield order, which will be swapped
      * to le just before it goes to hw
      */
     pkt.hdr_first.protocol = packet->protocol;
     pkt.hdr_first.address = packet->dest_addr;
     pkt.hdr_first.packet_rank = 0;
 
     /* First packet? */
     if (packet->fragment_count == 0) {
         pkt.hdr_first.packet_rank |= NL_FIRST_PACKET;
         pkt.hdr_first.length_lsb = (unsigned char) packet->length;
         pkt.hdr_first.length_msb =
             (unsigned char) (packet->length >> 8);
     }
 
     memcpy(pkt.rawpkt + header_size,
            ((unsigned char *) packet) + sizeof(struct ipw_tx_packet) +
            packet->offset, fragment_data_len);
     packet->offset += fragment_data_len;
     packet->fragment_count++;
 
     /* Last packet? (May also be first packet.) */
     if (packet->offset == packet->length)
         pkt.hdr_first.packet_rank |= NL_LAST_PACKET;
     do_send_fragment(hw, pkt.rawpkt, header_size + fragment_data_len);
 
     /* If this packet has unsent data, then re-queue it. */
     if (packet->offset < packet->length) {
         /*
          * Re-queue it at the head of the highest priority queue so
          * it goes before all other packets
          */
         unsigned long flags;
 
         spin_lock_irqsave(&hw->lock, flags);
         list_add(&packet->queue, &hw->tx_queue[0]);
         hw->tx_queued++;
         spin_unlock_irqrestore(&hw->lock, flags);
     } else {
         if (packet->packet_callback)
             packet->packet_callback(packet->callback_data,
                     packet->length);
         kfree(packet);
     }
 }
 
 static void ipw_setup_hardware(struct ipw_hardware *hw)
 {
     unsigned long flags;
 
     spin_lock_irqsave(&hw->lock, flags);
     if (hw->hw_version == HW_VERSION_1) {
         /* Reset RX FIFO */
         outw(DCR_RXRESET, hw->base_port + IODCR);
         /* SB: Reset TX FIFO */
         outw(DCR_TXRESET, hw->base_port + IODCR);
 
         /* Enable TX and RX interrupts. */
         outw(IER_TXENABLED | IER_RXENABLED, hw->base_port + IOIER);
     } else {
         /*
          * Set INTRACK bit (bit 0), which means we must explicitly
          * acknowledge interrupts by clearing bit 2 of reg_config_and_status.
          */
         unsigned short csr = readw(&hw->memregs_CCR->reg_config_and_status);
 
         csr |= 1;
         writew(csr, &hw->memregs_CCR->reg_config_and_status);
     }
     spin_unlock_irqrestore(&hw->lock, flags);
 }
 
 /*
  * If 'packet' is NULL, then this function allocates a new packet, setting its
  * length to 0 and ensuring it has the specified minimum amount of free space.
  *
  * If 'packet' is not NULL, then this function enlarges it if it doesn't
  * have the specified minimum amount of free space.
  *
  */
 static struct ipw_rx_packet *pool_allocate(struct ipw_hardware *hw,
                        struct ipw_rx_packet *packet,
                        int minimum_free_space)
 {
 
     if (!packet) {
         unsigned long 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);
             hw->rx_pool_size--;
             spin_unlock_irqrestore(&hw->lock, flags);
             list_del(&packet->queue);
         } else {
             const int min_capacity =
                 ipwireless_ppp_mru(hw->network) + 2;
             int new_capacity;
 
             spin_unlock_irqrestore(&hw->lock, flags);
             new_capacity =
                 (minimum_free_space > min_capacity
                  ? minimum_free_space
                  : min_capacity);
             packet = kmalloc(sizeof(struct ipw_rx_packet)
                     + new_capacity, GFP_ATOMIC);
             if (!packet)
                 return NULL;
             packet->capacity = new_capacity;
         }
         packet->length = 0;
     }
 
     if (packet->length + minimum_free_space > packet->capacity) {
         struct ipw_rx_packet *old_packet = packet;
 
         packet = kmalloc(sizeof(struct ipw_rx_packet) +
                 old_packet->length + minimum_free_space,
                 GFP_ATOMIC);
         if (!packet) {
             kfree(old_packet);
             return NULL;
         }
         memcpy(packet, old_packet,
                 sizeof(struct ipw_rx_packet)
                     + old_packet->length);
         packet->capacity = old_packet->length + minimum_free_space;
         kfree(old_packet);
     }
 
     return packet;
 }
 
 static void pool_free(struct ipw_hardware *hw, struct ipw_rx_packet *packet)
 {
     if (hw->rx_pool_size > 6)
         kfree(packet);
     else {
         hw->rx_pool_size++;
         list_add(&packet->queue, &hw->rx_pool);
     }
 }
 
 static void queue_received_packet(struct ipw_hardware *hw,
                   unsigned int protocol,
                   unsigned int address,
                   const unsigned char *data, int length,
                   int is_last)
 {
     unsigned int channel_idx = address - 1;
     struct ipw_rx_packet *packet = NULL;
     unsigned long flags;
 
     /* Discard packet if channel index is out of range. */
     if (channel_idx >= NL_NUM_OF_ADDRESSES) {
         printk(KERN_INFO IPWIRELESS_PCCARD_NAME
                ": data packet has bad address %u\n", address);
         return;
     }
 
     /*
      * ->packet_assembler is safe to touch unlocked, this is the only place
      */
     if (protocol == TL_PROTOCOLID_COM_DATA) {
         struct ipw_rx_packet **assem =
             &hw->packet_assembler[channel_idx];
 
         /*
          * Create a new packet, or assembler already contains one
          * enlarge it by 'length' bytes.
          */
         (*assem) = pool_allocate(hw, *assem, length);
         if (!(*assem)) {
             printk(KERN_ERR IPWIRELESS_PCCARD_NAME
                 ": no memory for incoming data packet, dropped!\n");
             return;
         }
         (*assem)->protocol = protocol;
         (*assem)->channel_idx = channel_idx;
 
         /* Append this packet data onto existing data. */
         memcpy((unsigned char *)(*assem) +
                    sizeof(struct ipw_rx_packet)
                 + (*assem)->length, data, length);
         (*assem)->length += length;
         if (is_last) {
             packet = *assem;
             *assem = NULL;
             /* Count queued DATA bytes only */
             spin_lock_irqsave(&hw->lock, flags);
             hw->rx_bytes_queued += packet->length;
             spin_unlock_irqrestore(&hw->lock, flags);
         }
     } else {
         /* If it's a CTRL packet, don't assemble, just queue it. */
         packet = pool_allocate(hw, NULL, length);
         if (!packet) {
             printk(KERN_ERR IPWIRELESS_PCCARD_NAME
                 ": no memory for incoming ctrl packet, dropped!\n");
             return;
         }
         packet->protocol = protocol;
         packet->channel_idx = channel_idx;
         memcpy((unsigned char *)packet + sizeof(struct ipw_rx_packet),
                 data, length);
         packet->length = length;
     }
 
     /*
      * If this is the last packet, then send the assembled packet on to the
      * network layer.
      */
     if (packet) {
         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->lock, flags);
         schedule_work(&hw->work_rx);
     }
 }
 
 /*
  * Workqueue callback
  */
 static void ipw_receive_data_work(struct work_struct *work_rx)
 {
     struct ipw_hardware *hw =
         container_of(work_rx, struct ipw_hardware, work_rx);
     unsigned long flags;
 
     spin_lock_irqsave(&hw->lock, flags);
     while (!list_empty(&hw->rx_queue)) {
         struct ipw_rx_packet *packet =
             list_first_entry(&hw->rx_queue,
                     struct ipw_rx_packet, queue);
 
         if (hw->shutting_down)
             break;
         list_del(&packet->queue);
 
         /*
          * Note: ipwireless_network_packet_received must be called in a
          * process context (i.e. via schedule_work) because the tty
          * output code can sleep in the tty_flip_buffer_push call.
          */
         if (packet->protocol == TL_PROTOCOLID_COM_DATA) {
             if (hw->network != NULL) {
                 /* If the network hasn't been disconnected. */
                 spin_unlock_irqrestore(&hw->lock, flags);
                 /*
                  * This must run unlocked due to tty processing
                  * and mutex locking
                  */
                 ipwireless_network_packet_received(
                         hw->network,
                         packet->channel_idx,
                         (unsigned char *)packet
                         + sizeof(struct ipw_rx_packet),
                         packet->length);
                 spin_lock_irqsave(&hw->lock, flags);
             }
             /* Count queued DATA bytes only */
             hw->rx_bytes_queued -= packet->length;
         } else {
             /*
              * This is safe to be called locked, callchain does
              * not block
              */
             handle_received_CTRL_packet(hw, packet->channel_idx,
                     (unsigned char *)packet
                     + sizeof(struct ipw_rx_packet),
                     packet->length);
         }
         pool_free(hw, packet);
         /*
          * Unblock reception of incoming packets if queue is no longer
          * full.
          */
         hw->blocking_rx =
             hw->rx_bytes_queued >= IPWIRELESS_RX_QUEUE_SIZE;
         if (hw->shutting_down)
             break;
     }
     spin_unlock_irqrestore(&hw->lock, flags);
 }
 
 static void handle_received_CTRL_packet(struct ipw_hardware *hw,
                     unsigned int channel_idx,
                     const unsigned char *data, int len)
 {
     const struct ipw_control_packet_body *body =
         (const struct ipw_control_packet_body *) data;
     unsigned int changed_mask;
 
     if (len != sizeof(struct ipw_control_packet_body)) {
         printk(KERN_INFO IPWIRELESS_PCCARD_NAME
                ": control packet was %d bytes - wrong size!\n",
                len);
         return;
     }
 
     switch (body->sig_no) {
     case COMCTRL_CTS:
         changed_mask = IPW_CONTROL_LINE_CTS;
         break;
     case COMCTRL_DCD:
         changed_mask = IPW_CONTROL_LINE_DCD;
         break;
     case COMCTRL_DSR:
         changed_mask = IPW_CONTROL_LINE_DSR;
         break;
     case COMCTRL_RI:
         changed_mask = IPW_CONTROL_LINE_RI;
         break;
     default:
         changed_mask = 0;
     }
 
     if (changed_mask != 0) {
         if (body->value)
             hw->control_lines[channel_idx] |= changed_mask;
         else
             hw->control_lines[channel_idx] &= ~changed_mask;
         if (hw->network)
             ipwireless_network_notify_control_line_change(
                     hw->network,
                     channel_idx,
                     hw->control_lines[channel_idx],
                     changed_mask);
     }
 }
 
 static void handle_received_packet(struct ipw_hardware *hw,
                    const union nl_packet *packet,
                    unsigned short len)
 {
     unsigned int protocol = packet->hdr.protocol;
     unsigned int address = packet->hdr.address;
     unsigned int header_length;
     const unsigned char *data;
     unsigned int data_len;
     int is_last = packet->hdr.packet_rank & NL_LAST_PACKET;
 
     if (packet->hdr.packet_rank & NL_FIRST_PACKET)
         header_length = NL_FIRST_PACKET_HEADER_SIZE;
     else
         header_length = NL_FOLLOWING_PACKET_HEADER_SIZE;
 
     data = packet->rawpkt + header_length;
     data_len = len - header_length;
     switch (protocol) {
     case TL_PROTOCOLID_COM_DATA:
     case TL_PROTOCOLID_COM_CTRL:
         queue_received_packet(hw, protocol, address, data, data_len,
                 is_last);
         break;
     case TL_PROTOCOLID_SETUP:
         handle_received_SETUP_packet(hw, address, data, data_len,
                 is_last);
         break;
     }
 }
 
 static void acknowledge_data_read(struct ipw_hardware *hw)
 {
     if (hw->hw_version == HW_VERSION_1)
         outw(DCR_RXDONE, hw->base_port + IODCR);
     else
         writew(MEMRX_PCINTACKK,
                 &hw->memory_info_regs->memreg_pc_interrupt_ack);
 }
 
 /*
  * Retrieve a packet from the IPW hardware.
  */
 static void do_receive_packet(struct ipw_hardware *hw)
 {
     unsigned len;
     unsigned i;
     unsigned char pkt[LL_MTU_MAX];
 
     start_timing();
 
     if (hw->hw_version == HW_VERSION_1) {
         len = inw(hw->base_port + IODRR);
         if (len > hw->ll_mtu) {
             printk(KERN_INFO IPWIRELESS_PCCARD_NAME
                    ": received a packet of %u bytes - longer than the MTU!\n", len);
             outw(DCR_RXDONE | DCR_RXRESET, hw->base_port + IODCR);
             return;
         }
 
         for (i = 0; i < len; i += 2) {
             __le16 raw_data = inw(hw->base_port + IODRR);
             unsigned short data = le16_to_cpu(raw_data);
 
             pkt[i] = (unsigned char) data;
             pkt[i + 1] = (unsigned char) (data >> 8);
         }
     } else {
         len = inw(hw->base_port);
         if (len > hw->ll_mtu) {
             printk(KERN_INFO IPWIRELESS_PCCARD_NAME
                    ": received a packet of %u bytes - longer than the MTU!\n", len);
             writew(MEMRX_PCINTACKK,
                 &hw->memory_info_regs->memreg_pc_interrupt_ack);
             return;
         }
 
         for (i = 0; i < len; i += 2) {
             __le16 raw_data = inw(hw->base_port);
             unsigned short data = le16_to_cpu(raw_data);
 
             pkt[i] = (unsigned char) data;
             pkt[i + 1] = (unsigned char) (data >> 8);
         }
 
         while ((i & 3) != 2) {
             inw(hw->base_port);
             i += 2;
         }
     }
 
     acknowledge_data_read(hw);
 
     swap_packet_bitfield_from_le(pkt);
 
     if (ipwireless_debug)
         dump_data_bytes("recv", pkt, len);
 
     handle_received_packet(hw, (union nl_packet *) pkt, len);
 
     end_read_timing(len);
 }
 
 static int get_current_packet_priority(struct ipw_hardware *hw)
 {
     /*
      * If we're initializing, don't send anything of higher priority than
      * PRIO_SETUP.  The network layer therefore need not care about
      * hardware initialization - any of its stuff will simply be queued
      * until setup is complete.
      */
     return (hw->to_setup || hw->initializing
             ? PRIO_SETUP + 1 : NL_NUM_OF_PRIORITIES);
 }
 
 /*
  * return 1 if something has been received from hw
  */
 static int get_packets_from_hw(struct ipw_hardware *hw)
 {
     int received = 0;
     unsigned long flags;
 
     spin_lock_irqsave(&hw->lock, flags);
     while (hw->rx_ready && !hw->blocking_rx) {
         received = 1;
         hw->rx_ready--;
         spin_unlock_irqrestore(&hw->lock, flags);
 
         do_receive_packet(hw);
 
         spin_lock_irqsave(&hw->lock, flags);
     }
     spin_unlock_irqrestore(&hw->lock, flags);
 
     return received;
 }
 
 /*
  * Send pending packet up to given priority, prioritize SETUP data until
  * hardware is fully setup.
  *
  * return 1 if more packets can be sent
  */
 static int send_pending_packet(struct ipw_hardware *hw, int priority_limit)
 {
     int more_to_send = 0;
     unsigned long flags;
 
     spin_lock_irqsave(&hw->lock, flags);
     if (hw->tx_queued && hw->tx_ready) {
         int priority;
         struct ipw_tx_packet *packet = NULL;
 
         /* Pick a packet */
         for (priority = 0; priority < priority_limit; priority++) {
             if (!list_empty(&hw->tx_queue[priority])) {
                 packet = list_first_entry(
                         &hw->tx_queue[priority],
                         struct ipw_tx_packet,
                         queue);
 
                 hw->tx_queued--;
                 list_del(&packet->queue);
 
                 break;
             }
         }
         if (!packet) {
             hw->tx_queued = 0;
             spin_unlock_irqrestore(&hw->lock, flags);
             return 0;
         }
 
         spin_unlock_irqrestore(&hw->lock, flags);
 
         /* Send */
         do_send_packet(hw, packet);
 
         /* Check if more to send */
         spin_lock_irqsave(&hw->lock, flags);
         for (priority = 0; priority < priority_limit; priority++)
             if (!list_empty(&hw->tx_queue[priority])) {
                 more_to_send = 1;
                 break;
             }
 
         if (!more_to_send)
             hw->tx_queued = 0;
     }
     spin_unlock_irqrestore(&hw->lock, flags);
 
     return more_to_send;
 }
 
 /*
  * Send and receive all queued packets.
  */
 static void ipwireless_do_tasklet(struct tasklet_struct *t)
 {
     struct ipw_hardware *hw = from_tasklet(hw, t, tasklet);
     unsigned long flags;
 
     spin_lock_irqsave(&hw->lock, flags);
     if (hw->shutting_down) {
         spin_unlock_irqrestore(&hw->lock, flags);
         return;
     }
 
     if (hw->to_setup == 1) {
         /*
          * Initial setup data sent to hardware
          */
         hw->to_setup = 2;
         spin_unlock_irqrestore(&hw->lock, flags);
 
         ipw_setup_hardware(hw);
         ipw_send_setup_packet(hw);
 
         send_pending_packet(hw, PRIO_SETUP + 1);
         get_packets_from_hw(hw);
     } else {
         int priority_limit = get_current_packet_priority(hw);
         int again;
 
         spin_unlock_irqrestore(&hw->lock, flags);
 
         do {
             again = send_pending_packet(hw, priority_limit);
             again |= get_packets_from_hw(hw);
         } while (again);
     }
 }
 
 /*
  * return true if the card is physically present.
  */
 static int is_card_present(struct ipw_hardware *hw)
 {
     if (hw->hw_version == HW_VERSION_1)
         return inw(hw->base_port + IOIR) != 0xFFFF;
     else
         return readl(&hw->memory_info_regs->memreg_card_present) ==
             CARD_PRESENT_VALUE;
 }
 
 static irqreturn_t ipwireless_handle_v1_interrupt(int irq,
                           struct ipw_hardware *hw)
 {
     unsigned short irqn;
 
     irqn = inw(hw->base_port + IOIR);
 
     /* Check if card is present */
     if (irqn == 0xFFFF)
         return IRQ_NONE;
     else if (irqn != 0) {
         unsigned short ack = 0;
         unsigned long flags;
 
         /* Transmit complete. */
         if (irqn & IR_TXINTR) {
             ack |= IR_TXINTR;
             spin_lock_irqsave(&hw->lock, flags);
             hw->tx_ready = 1;
             spin_unlock_irqrestore(&hw->lock, flags);
         }
         /* Received data */
         if (irqn & IR_RXINTR) {
             ack |= IR_RXINTR;
             spin_lock_irqsave(&hw->lock, flags);
             hw->rx_ready++;
             spin_unlock_irqrestore(&hw->lock, flags);
         }
         if (ack != 0) {
             outw(ack, hw->base_port + IOIR);
             tasklet_schedule(&hw->tasklet);
         }
         return IRQ_HANDLED;
     }
     return IRQ_NONE;
 }
 
 static void acknowledge_pcmcia_interrupt(struct ipw_hardware *hw)
 {
     unsigned short csr = readw(&hw->memregs_CCR->reg_config_and_status);
 
     csr &= 0xfffd;
     writew(csr, &hw->memregs_CCR->reg_config_and_status);
 }
 
 static irqreturn_t ipwireless_handle_v2_v3_interrupt(int irq,
                              struct ipw_hardware *hw)
 {
     int tx = 0;
     int rx = 0;
     int rx_repeat = 0;
     int try_mem_tx_old;
     unsigned long flags;
 
     do {
 
     unsigned short memtx = readw(hw->memreg_tx);
     unsigned short memtx_serial;
     unsigned short memrxdone =
         readw(&hw->memory_info_regs->memreg_rx_done);
 
     try_mem_tx_old = 0;
 
     /* check whether the interrupt was generated by ipwireless card */
     if (!(memtx & MEMTX_TX) && !(memrxdone & MEMRX_RX_DONE)) {
 
         /* check if the card uses memreg_tx_old register */
         if (hw->memreg_tx == &hw->memory_info_regs->memreg_tx_new) {
             memtx = readw(&hw->memory_info_regs->memreg_tx_old);
             if (memtx & MEMTX_TX) {
                 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
                     ": Using memreg_tx_old\n");
                 hw->memreg_tx =
                     &hw->memory_info_regs->memreg_tx_old;
             } else {
                 return IRQ_NONE;
             }
         } else
             return IRQ_NONE;
     }
 
     /*
      * See if the card is physically present. Note that while it is
      * powering up, it appears not to be present.
      */
     if (!is_card_present(hw)) {
         acknowledge_pcmcia_interrupt(hw);
         return IRQ_HANDLED;
     }
 
     memtx_serial = memtx & (unsigned short) 0xff00;
     if (memtx & MEMTX_TX) {
         writew(memtx_serial, hw->memreg_tx);
 
         if (hw->serial_number_detected) {
             if (memtx_serial != hw->last_memtx_serial) {
                 hw->last_memtx_serial = memtx_serial;
                 spin_lock_irqsave(&hw->lock, flags);
                 hw->rx_ready++;
                 spin_unlock_irqrestore(&hw->lock, flags);
                 rx = 1;
             } else
                 /* Ignore 'Timer Recovery' duplicates. */
                 rx_repeat = 1;
         } else {
             /*
              * If a non-zero serial number is seen, then enable
              * serial number checking.
              */
             if (memtx_serial != 0) {
                 hw->serial_number_detected = 1;
                 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
                     ": memreg_tx serial num detected\n");
 
                 spin_lock_irqsave(&hw->lock, flags);
                 hw->rx_ready++;
                 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->lock, flags);
         hw->tx_ready = 1;
         spin_unlock_irqrestore(&hw->lock, flags);
         tx = 1;
     }
     if (tx)
         writew(MEMRX_PCINTACKK,
                 &hw->memory_info_regs->memreg_pc_interrupt_ack);
 
     acknowledge_pcmcia_interrupt(hw);
 
     if (tx || rx)
         tasklet_schedule(&hw->tasklet);
     else if (!rx_repeat) {
         if (hw->memreg_tx == &hw->memory_info_regs->memreg_tx_new) {
             if (hw->serial_number_detected)
                 printk(KERN_WARNING IPWIRELESS_PCCARD_NAME
                     ": spurious interrupt - new_tx mode\n");
             else {
                 printk(KERN_WARNING IPWIRELESS_PCCARD_NAME
                     ": no valid memreg_tx value - switching to the old memreg_tx\n");
                 hw->memreg_tx =
                     &hw->memory_info_regs->memreg_tx_old;
                 try_mem_tx_old = 1;
             }
         } else
             printk(KERN_WARNING IPWIRELESS_PCCARD_NAME
                     ": spurious interrupt - old_tx mode\n");
     }
 
     } while (try_mem_tx_old == 1);
 
     return IRQ_HANDLED;
 }
 
 irqreturn_t ipwireless_interrupt(int irq, void *dev_id)
 {
     struct ipw_dev *ipw = dev_id;
 
     if (ipw->hardware->hw_version == HW_VERSION_1)
         return ipwireless_handle_v1_interrupt(irq, ipw->hardware);
     else
         return ipwireless_handle_v2_v3_interrupt(irq, ipw->hardware);
 }
 
 static void flush_packets_to_hw(struct ipw_hardware *hw)
 {
     int priority_limit;
     unsigned long flags;
 
     spin_lock_irqsave(&hw->lock, flags);
     priority_limit = get_current_packet_priority(hw);
     spin_unlock_irqrestore(&hw->lock, flags);
 
     while (send_pending_packet(hw, priority_limit));
 }
 
 static void send_packet(struct ipw_hardware *hw, int priority,
             struct ipw_tx_packet *packet)
 {
     unsigned long flags;
 
     spin_lock_irqsave(&hw->lock, flags);
     list_add_tail(&packet->queue, &hw->tx_queue[priority]);
     hw->tx_queued++;
     spin_unlock_irqrestore(&hw->lock, flags);
 
     flush_packets_to_hw(hw);
 }
 
 /* Create data packet, non-atomic allocation */
 static void *alloc_data_packet(int data_size,
                 unsigned char dest_addr,
                 unsigned char protocol)
 {
     struct ipw_tx_packet *packet = kzalloc(
             sizeof(struct ipw_tx_packet) + data_size,
             GFP_ATOMIC);
 
     if (!packet)
         return NULL;
 
     INIT_LIST_HEAD(&packet->queue);
     packet->dest_addr = dest_addr;
     packet->protocol = protocol;
     packet->length = data_size;
 
     return packet;
 }
 
 static void *alloc_ctrl_packet(int header_size,
                    unsigned char dest_addr,
                    unsigned char protocol,
                    unsigned char sig_no)
 {
     /*
      * sig_no is located right after ipw_tx_packet struct in every
      * CTRL or SETUP packets, we can use ipw_control_packet as a
      * common struct
      */
     struct ipw_control_packet *packet = kzalloc(header_size, GFP_ATOMIC);
 
     if (!packet)
         return NULL;
 
     INIT_LIST_HEAD(&packet->header.queue);
     packet->header.dest_addr = dest_addr;
     packet->header.protocol = protocol;
     packet->header.length = header_size - sizeof(struct ipw_tx_packet);
     packet->body.sig_no = sig_no;
 
     return packet;
 }
 
 int ipwireless_send_packet(struct ipw_hardware *hw, unsigned int channel_idx,
                 const unsigned char *data, unsigned int length,
                 void (*callback) (void *cb, unsigned int length),
                 void *callback_data)
 {
     struct ipw_tx_packet *packet;
 
     packet = alloc_data_packet(length, (channel_idx + 1),
             TL_PROTOCOLID_COM_DATA);
     if (!packet)
         return -ENOMEM;
     packet->packet_callback = callback;
     packet->callback_data = callback_data;
     memcpy((unsigned char *) packet + sizeof(struct ipw_tx_packet), data,
             length);
 
     send_packet(hw, PRIO_DATA, packet);
     return 0;
 }
 
 static int set_control_line(struct ipw_hardware *hw, int prio,
                unsigned int channel_idx, int line, int state)
 {
     struct ipw_control_packet *packet;
     int protocolid = TL_PROTOCOLID_COM_CTRL;
 
     if (prio == PRIO_SETUP)
         protocolid = TL_PROTOCOLID_SETUP;
 
     packet = alloc_ctrl_packet(sizeof(struct ipw_control_packet),
             (channel_idx + 1), protocolid, line);
     if (!packet)
         return -ENOMEM;
     packet->header.length = sizeof(struct ipw_control_packet_body);
     packet->body.value = (state == 0 ? 0 : 1);
     send_packet(hw, prio, &packet->header);
     return 0;
 }
 
 
 static int set_DTR(struct ipw_hardware *hw, int priority,
            unsigned int channel_idx, int state)
 {
     if (state != 0)
         hw->control_lines[channel_idx] |= IPW_CONTROL_LINE_DTR;
     else
         hw->control_lines[channel_idx] &= ~IPW_CONTROL_LINE_DTR;
 
     return set_control_line(hw, priority, channel_idx, COMCTRL_DTR, state);
 }
 
 static int set_RTS(struct ipw_hardware *hw, int priority,
            unsigned int channel_idx, int state)
 {
     if (state != 0)
         hw->control_lines[channel_idx] |= IPW_CONTROL_LINE_RTS;
     else
         hw->control_lines[channel_idx] &= ~IPW_CONTROL_LINE_RTS;
 
     return set_control_line(hw, priority, channel_idx, COMCTRL_RTS, state);
 }
 
 int ipwireless_set_DTR(struct ipw_hardware *hw, unsigned int channel_idx,
                int state)
 {
     return set_DTR(hw, PRIO_CTRL, channel_idx, state);
 }
 
 int ipwireless_set_RTS(struct ipw_hardware *hw, unsigned int channel_idx,
                int state)
 {
     return set_RTS(hw, PRIO_CTRL, channel_idx, state);
 }
 
 struct ipw_setup_get_version_query_packet {
     struct ipw_tx_packet header;
     struct tl_setup_get_version_qry body;
 };
 
 struct ipw_setup_config_packet {
     struct ipw_tx_packet header;
     struct tl_setup_config_msg body;
 };
 
 struct ipw_setup_config_done_packet {
     struct ipw_tx_packet header;
     struct tl_setup_config_done_msg body;
 };
 
 struct ipw_setup_open_packet {
     struct ipw_tx_packet header;
     struct tl_setup_open_msg body;
 };
 
 struct ipw_setup_info_packet {
     struct ipw_tx_packet header;
     struct tl_setup_info_msg body;
 };
 
 struct ipw_setup_reboot_msg_ack {
     struct ipw_tx_packet header;
     struct TlSetupRebootMsgAck body;
 };
 
 /* This handles the actual initialization of the card */
 static void __handle_setup_get_version_rsp(struct ipw_hardware *hw)
 {
     struct ipw_setup_config_packet *config_packet;
     struct ipw_setup_config_done_packet *config_done_packet;
     struct ipw_setup_open_packet *open_packet;
     struct ipw_setup_info_packet *info_packet;
     int port;
     unsigned int channel_idx;
 
     /* generate config packet */
     for (port = 1; port <= NL_NUM_OF_ADDRESSES; port++) {
         config_packet = alloc_ctrl_packet(
                 sizeof(struct ipw_setup_config_packet),
                 ADDR_SETUP_PROT,
                 TL_PROTOCOLID_SETUP,
                 TL_SETUP_SIGNO_CONFIG_MSG);
         if (!config_packet)
             goto exit_nomem;
         config_packet->header.length = sizeof(struct tl_setup_config_msg);
         config_packet->body.port_no = port;
         config_packet->body.prio_data = PRIO_DATA;
         config_packet->body.prio_ctrl = PRIO_CTRL;
         send_packet(hw, PRIO_SETUP, &config_packet->header);
     }
     config_done_packet = alloc_ctrl_packet(
             sizeof(struct ipw_setup_config_done_packet),
             ADDR_SETUP_PROT,
             TL_PROTOCOLID_SETUP,
             TL_SETUP_SIGNO_CONFIG_DONE_MSG);
     if (!config_done_packet)
         goto exit_nomem;
     config_done_packet->header.length = sizeof(struct tl_setup_config_done_msg);
     send_packet(hw, PRIO_SETUP, &config_done_packet->header);
 
     /* generate open packet */
     for (port = 1; port <= NL_NUM_OF_ADDRESSES; port++) {
         open_packet = alloc_ctrl_packet(
                 sizeof(struct ipw_setup_open_packet),
                 ADDR_SETUP_PROT,
                 TL_PROTOCOLID_SETUP,
                 TL_SETUP_SIGNO_OPEN_MSG);
         if (!open_packet)
             goto exit_nomem;
         open_packet->header.length = sizeof(struct tl_setup_open_msg);
         open_packet->body.port_no = port;
         send_packet(hw, PRIO_SETUP, &open_packet->header);
     }
     for (channel_idx = 0;
             channel_idx < NL_NUM_OF_ADDRESSES; channel_idx++) {
         int ret;
 
         ret = set_DTR(hw, PRIO_SETUP, channel_idx,
             (hw->control_lines[channel_idx] &
              IPW_CONTROL_LINE_DTR) != 0);
         if (ret) {
             printk(KERN_ERR IPWIRELESS_PCCARD_NAME
                     ": error setting DTR (%d)\n", ret);
             return;
         }
 
         ret = set_RTS(hw, PRIO_SETUP, channel_idx,
             (hw->control_lines [channel_idx] &
              IPW_CONTROL_LINE_RTS) != 0);
         if (ret) {
             printk(KERN_ERR IPWIRELESS_PCCARD_NAME
                     ": error setting RTS (%d)\n", ret);
             return;
         }
     }
     /*
      * For NDIS we assume that we are using sync PPP frames, for COM async.
      * This driver uses NDIS mode too. We don't bother with translation
      * from async -> sync PPP.
      */
     info_packet = alloc_ctrl_packet(sizeof(struct ipw_setup_info_packet),
             ADDR_SETUP_PROT,
             TL_PROTOCOLID_SETUP,
             TL_SETUP_SIGNO_INFO_MSG);
     if (!info_packet)
         goto exit_nomem;
     info_packet->header.length = sizeof(struct tl_setup_info_msg);
     info_packet->body.driver_type = NDISWAN_DRIVER;
     info_packet->body.major_version = NDISWAN_DRIVER_MAJOR_VERSION;
     info_packet->body.minor_version = NDISWAN_DRIVER_MINOR_VERSION;
     send_packet(hw, PRIO_SETUP, &info_packet->header);
 
     /* Initialization is now complete, so we clear the 'to_setup' flag */
     hw->to_setup = 0;
 
     return;
 
 exit_nomem:
     printk(KERN_ERR IPWIRELESS_PCCARD_NAME
             ": not enough memory to alloc control packet\n");
     hw->to_setup = -1;
 }
 
 static void handle_setup_get_version_rsp(struct ipw_hardware *hw,
         unsigned char vers_no)
 {
     del_timer(&hw->setup_timer);
     hw->initializing = 0;
     printk(KERN_INFO IPWIRELESS_PCCARD_NAME ": card is ready.\n");
 
     if (vers_no == TL_SETUP_VERSION)
         __handle_setup_get_version_rsp(hw);
     else
         printk(KERN_ERR IPWIRELESS_PCCARD_NAME
                 ": invalid hardware version no %u\n",
                 (unsigned int) vers_no);
 }
 
 static void ipw_send_setup_packet(struct ipw_hardware *hw)
 {
     struct ipw_setup_get_version_query_packet *ver_packet;
 
     ver_packet = alloc_ctrl_packet(
             sizeof(struct ipw_setup_get_version_query_packet),
             ADDR_SETUP_PROT, TL_PROTOCOLID_SETUP,
             TL_SETUP_SIGNO_GET_VERSION_QRY);
     if (!ver_packet)
         return;
     ver_packet->header.length = sizeof(struct tl_setup_get_version_qry);
 
     /*
      * Response is handled in handle_received_SETUP_packet
      */
     send_packet(hw, PRIO_SETUP, &ver_packet->header);
 }
 
 static void handle_received_SETUP_packet(struct ipw_hardware *hw,
                      unsigned int address,
                      const unsigned char *data, int len,
                      int is_last)
 {
     const union ipw_setup_rx_msg *rx_msg = (const union ipw_setup_rx_msg *) data;
 
     if (address != ADDR_SETUP_PROT) {
         printk(KERN_INFO IPWIRELESS_PCCARD_NAME
                ": setup packet has bad address %d\n", address);
         return;
     }
 
     switch (rx_msg->sig_no) {
     case TL_SETUP_SIGNO_GET_VERSION_RSP:
         if (hw->to_setup)
             handle_setup_get_version_rsp(hw,
                     rx_msg->version_rsp_msg.version);
         break;
 
     case TL_SETUP_SIGNO_OPEN_MSG:
         if (ipwireless_debug) {
             unsigned int channel_idx = rx_msg->open_msg.port_no - 1;
 
             printk(KERN_INFO IPWIRELESS_PCCARD_NAME
                    ": OPEN_MSG [channel %u] reply received\n",
                    channel_idx);
         }
         break;
 
     case TL_SETUP_SIGNO_INFO_MSG_ACK:
         if (ipwireless_debug)
             printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
                    ": card successfully configured as NDISWAN\n");
         break;
 
     case TL_SETUP_SIGNO_REBOOT_MSG:
         if (hw->to_setup)
             printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
                    ": Setup not completed - ignoring reboot msg\n");
         else {
             struct ipw_setup_reboot_msg_ack *packet;
 
             printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
                    ": Acknowledging REBOOT message\n");
             packet = alloc_ctrl_packet(
                     sizeof(struct ipw_setup_reboot_msg_ack),
                     ADDR_SETUP_PROT, TL_PROTOCOLID_SETUP,
                     TL_SETUP_SIGNO_REBOOT_MSG_ACK);
             if (!packet) {
                 pr_err(IPWIRELESS_PCCARD_NAME
                        ": Not enough memory to send reboot packet");
                 break;
             }
             packet->header.length =
                 sizeof(struct TlSetupRebootMsgAck);
             send_packet(hw, PRIO_SETUP, &packet->header);
             if (hw->reboot_callback)
                 hw->reboot_callback(hw->reboot_callback_data);
         }
         break;
 
     default:
         printk(KERN_INFO IPWIRELESS_PCCARD_NAME
                ": unknown setup message %u received\n",
                (unsigned int) rx_msg->sig_no);
     }
 }
 
 static void do_close_hardware(struct ipw_hardware *hw)
 {
     unsigned int irqn;
 
     if (hw->hw_version == HW_VERSION_1) {
         /* Disable TX and RX interrupts. */
         outw(0, hw->base_port + IOIER);
 
         /* Acknowledge any outstanding interrupt requests */
         irqn = inw(hw->base_port + IOIR);
         if (irqn & IR_TXINTR)
             outw(IR_TXINTR, hw->base_port + IOIR);
         if (irqn & IR_RXINTR)
             outw(IR_RXINTR, hw->base_port + IOIR);
 
         synchronize_irq(hw->irq);
     }
 }
 
 struct ipw_hardware *ipwireless_hardware_create(void)
 {
     int i;
     struct ipw_hardware *hw =
         kzalloc(sizeof(struct ipw_hardware), GFP_KERNEL);
 
     if (!hw)
         return NULL;
 
     hw->irq = -1;
     hw->initializing = 1;
     hw->tx_ready = 1;
     hw->rx_bytes_queued = 0;
     hw->rx_pool_size = 0;
     hw->last_memtx_serial = (unsigned short) 0xffff;
     for (i = 0; i < NL_NUM_OF_PRIORITIES; i++)
         INIT_LIST_HEAD(&hw->tx_queue[i]);
 
     INIT_LIST_HEAD(&hw->rx_queue);
     INIT_LIST_HEAD(&hw->rx_pool);
     spin_lock_init(&hw->lock);
     tasklet_setup(&hw->tasklet, ipwireless_do_tasklet);
     INIT_WORK(&hw->work_rx, ipw_receive_data_work);
     timer_setup(&hw->setup_timer, ipwireless_setup_timer, 0);
 
     return hw;
 }
 
 void ipwireless_init_hardware_v1(struct ipw_hardware *hw,
         unsigned int base_port,
         void __iomem *attr_memory,
         void __iomem *common_memory,
         int is_v2_card,
         void (*reboot_callback) (void *data),
         void *reboot_callback_data)
 {
     if (hw->removed) {
         hw->removed = 0;
         enable_irq(hw->irq);
     }
     hw->base_port = base_port;
     hw->hw_version = (is_v2_card ? HW_VERSION_2 : HW_VERSION_1);
     hw->ll_mtu = (hw->hw_version == HW_VERSION_1 ? LL_MTU_V1 : LL_MTU_V2);
     hw->memregs_CCR = (struct MEMCCR __iomem *)
             ((unsigned short __iomem *) attr_memory + 0x200);
     hw->memory_info_regs = (struct MEMINFREG __iomem *) common_memory;
     hw->memreg_tx = &hw->memory_info_regs->memreg_tx_new;
     hw->reboot_callback = reboot_callback;
     hw->reboot_callback_data = reboot_callback_data;
 }
 
 void ipwireless_init_hardware_v2_v3(struct ipw_hardware *hw)
 {
     hw->initializing = 1;
     hw->init_loops = 0;
     printk(KERN_INFO IPWIRELESS_PCCARD_NAME
            ": waiting for card to start up...\n");
     ipwireless_setup_timer(&hw->setup_timer);
 }
 
 static void ipwireless_setup_timer(struct timer_list *t)
 {
     struct ipw_hardware *hw = from_timer(hw, t, setup_timer);
 
     hw->init_loops++;
 
     if (hw->init_loops == TL_SETUP_MAX_VERSION_QRY &&
             hw->hw_version == HW_VERSION_2 &&
             hw->memreg_tx == &hw->memory_info_regs->memreg_tx_new) {
         printk(KERN_INFO IPWIRELESS_PCCARD_NAME
                 ": failed to startup using TX2, trying TX\n");
 
         hw->memreg_tx = &hw->memory_info_regs->memreg_tx_old;
         hw->init_loops = 0;
     }
     /* Give up after a certain number of retries */
     if (hw->init_loops == TL_SETUP_MAX_VERSION_QRY) {
         printk(KERN_INFO IPWIRELESS_PCCARD_NAME
                ": card failed to start up!\n");
         hw->initializing = 0;
     } else {
         /* Do not attempt to write to the board if it is not present. */
         if (is_card_present(hw)) {
             unsigned long flags;
 
             spin_lock_irqsave(&hw->lock, flags);
             hw->to_setup = 1;
             hw->tx_ready = 1;
             spin_unlock_irqrestore(&hw->lock, flags);
             tasklet_schedule(&hw->tasklet);
         }
 
         mod_timer(&hw->setup_timer,
             jiffies + msecs_to_jiffies(TL_SETUP_VERSION_QRY_TMO));
     }
 }
 
 /*
  * Stop any interrupts from executing so that, once this function returns,
  * other layers of the driver can be sure they won't get any more callbacks.
  * Thus must be called on a proper process context.
  */
 void ipwireless_stop_interrupts(struct ipw_hardware *hw)
 {
     if (!hw->shutting_down) {
         /* Tell everyone we are going down. */
         hw->shutting_down = 1;
         del_timer(&hw->setup_timer);
 
         /* Prevent the hardware from sending any more interrupts */
         do_close_hardware(hw);
     }
 }
 
 void ipwireless_hardware_free(struct ipw_hardware *hw)
 {
     int i;
     struct ipw_rx_packet *rp, *rq;
     struct ipw_tx_packet *tp, *tq;
 
     ipwireless_stop_interrupts(hw);
 
     flush_work(&hw->work_rx);
 
     for (i = 0; i < NL_NUM_OF_ADDRESSES; i++)
         kfree(hw->packet_assembler[i]);
 
     for (i = 0; i < NL_NUM_OF_PRIORITIES; i++)
         list_for_each_entry_safe(tp, tq, &hw->tx_queue[i], queue) {
             list_del(&tp->queue);
             kfree(tp);
         }
 
     list_for_each_entry_safe(rp, rq, &hw->rx_queue, queue) {
         list_del(&rp->queue);
         kfree(rp);
     }
 
     list_for_each_entry_safe(rp, rq, &hw->rx_pool, queue) {
         list_del(&rp->queue);
         kfree(rp);
     }
     kfree(hw);
 }
 
 /*
  * Associate the specified network with this hardware, so it will receive events
  * from it.
  */
 void ipwireless_associate_network(struct ipw_hardware *hw,
                   struct ipw_network *network)
 {
     hw->network = network;
 }

This page was automatically generated by the 2.1.0 LXR engine. The LXR team