| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| David Sterba | 7188 | 98.72% | 10 | 41.67% |
| Kees Cook | 21 | 0.29% | 1 | 4.17% |
| Sudip Mukherjee | 14 | 0.19% | 1 | 4.17% |
| Allen Pais | 13 | 0.18% | 1 | 4.17% |
| Joe Perches | 12 | 0.16% | 1 | 4.17% |
| Dominik Brodowski | 11 | 0.15% | 1 | 4.17% |
| Tejun Heo | 7 | 0.10% | 2 | 8.33% |
| Yue haibing | 6 | 0.08% | 1 | 4.17% |
| Jorrit Schippers | 2 | 0.03% | 1 | 4.17% |
| Alan One Thousand Gnomes | 2 | 0.03% | 1 | 4.17% |
| Darren Jenkins | 2 | 0.03% | 1 | 4.17% |
| James Bottomley | 1 | 0.01% | 1 | 4.17% |
| Greg Kroah-Hartman | 1 | 0.01% | 1 | 4.17% |
| Jiri Slaby (SUSE) | 1 | 0.01% | 1 | 4.17% |
| Total | 7281 | 24 |
// 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 u8 *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; }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1