mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-06 02:24:14 +08:00
a42a9f6a9b
In preparation for unconditionally passing the struct tasklet_struct pointer to all tasklet callbacks, switch to using the new tasklet_setup() and from_tasklet() to pass the tasklet pointer explicitly. Signed-off-by: Romain Perier <romain.perier@gmail.com> Signed-off-by: Allen Pais <allen.lkml@gmail.com> Link: https://lore.kernel.org/r/20200817085921.26033-2-allen.cryptic@gmail.com Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
1771 lines
46 KiB
C
1771 lines
46 KiB
C
// 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;
|
|
}
|