1771 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * IPWireless 3G PCMCIA Network Driver4 *5 * Original code6 * by Stephen Blackheath <stephen@blacksapphire.com>,7 * Ben Martel <benm@symmetric.co.nz>8 *9 * Copyrighted as follows:10 * Copyright (C) 2004 by Symmetric Systems Ltd (NZ)11 *12 * Various driver changes and rewrites, port to new kernels13 * Copyright (C) 2006-2007 Jiri Kosina14 *15 * Misc code cleanups and updates16 * Copyright (C) 2007 David Sterba17 */18 19#include <linux/interrupt.h>20#include <linux/io.h>21#include <linux/irq.h>22#include <linux/kernel.h>23#include <linux/list.h>24#include <linux/slab.h>25 26#include "hardware.h"27#include "setup_protocol.h"28#include "network.h"29#include "main.h"30 31static void ipw_send_setup_packet(struct ipw_hardware *hw);32static void handle_received_SETUP_packet(struct ipw_hardware *ipw,33 unsigned int address,34 const unsigned char *data, int len,35 int is_last);36static void ipwireless_setup_timer(struct timer_list *t);37static void handle_received_CTRL_packet(struct ipw_hardware *hw,38 unsigned int channel_idx, const unsigned char *data, int len);39 40/*#define TIMING_DIAGNOSTICS*/41 42#ifdef TIMING_DIAGNOSTICS43 44static struct timing_stats {45 unsigned long last_report_time;46 unsigned long read_time;47 unsigned long write_time;48 unsigned long read_bytes;49 unsigned long write_bytes;50 unsigned long start_time;51};52 53static void start_timing(void)54{55 timing_stats.start_time = jiffies;56}57 58static void end_read_timing(unsigned length)59{60 timing_stats.read_time += (jiffies - start_time);61 timing_stats.read_bytes += length + 2;62 report_timing();63}64 65static void end_write_timing(unsigned length)66{67 timing_stats.write_time += (jiffies - start_time);68 timing_stats.write_bytes += length + 2;69 report_timing();70}71 72static void report_timing(void)73{74 unsigned long since = jiffies - timing_stats.last_report_time;75 76 /* If it's been more than one second... */77 if (since >= HZ) {78 int first = (timing_stats.last_report_time == 0);79 80 timing_stats.last_report_time = jiffies;81 if (!first)82 printk(KERN_INFO IPWIRELESS_PCCARD_NAME83 ": %u us elapsed - read %lu bytes in %u us, wrote %lu bytes in %u us\n",84 jiffies_to_usecs(since),85 timing_stats.read_bytes,86 jiffies_to_usecs(timing_stats.read_time),87 timing_stats.write_bytes,88 jiffies_to_usecs(timing_stats.write_time));89 90 timing_stats.read_time = 0;91 timing_stats.write_time = 0;92 timing_stats.read_bytes = 0;93 timing_stats.write_bytes = 0;94 }95}96#else97static void start_timing(void) { }98static void end_read_timing(unsigned length) { }99static void end_write_timing(unsigned length) { }100#endif101 102/* Imported IPW definitions */103 104#define LL_MTU_V1 318105#define LL_MTU_V2 250106#define LL_MTU_MAX (LL_MTU_V1 > LL_MTU_V2 ? LL_MTU_V1 : LL_MTU_V2)107 108#define PRIO_DATA 2109#define PRIO_CTRL 1110#define PRIO_SETUP 0111 112/* Addresses */113#define ADDR_SETUP_PROT 0114 115/* Protocol ids */116enum {117 /* Identifier for the Com Data protocol */118 TL_PROTOCOLID_COM_DATA = 0,119 120 /* Identifier for the Com Control protocol */121 TL_PROTOCOLID_COM_CTRL = 1,122 123 /* Identifier for the Setup protocol */124 TL_PROTOCOLID_SETUP = 2125};126 127/* Number of bytes in NL packet header (cannot do128 * sizeof(nl_packet_header) since it's a bitfield) */129#define NL_FIRST_PACKET_HEADER_SIZE 3130 131/* Number of bytes in NL packet header (cannot do132 * sizeof(nl_packet_header) since it's a bitfield) */133#define NL_FOLLOWING_PACKET_HEADER_SIZE 1134 135struct nl_first_packet_header {136 unsigned char protocol:3;137 unsigned char address:3;138 unsigned char packet_rank:2;139 unsigned char length_lsb;140 unsigned char length_msb;141};142 143struct nl_packet_header {144 unsigned char protocol:3;145 unsigned char address:3;146 unsigned char packet_rank:2;147};148 149/* Value of 'packet_rank' above */150#define NL_INTERMEDIATE_PACKET 0x0151#define NL_LAST_PACKET 0x1152#define NL_FIRST_PACKET 0x2153 154union nl_packet {155 /* Network packet header of the first packet (a special case) */156 struct nl_first_packet_header hdr_first;157 /* Network packet header of the following packets (if any) */158 struct nl_packet_header hdr;159 /* Complete network packet (header + data) */160 unsigned char rawpkt[LL_MTU_MAX];161} __attribute__ ((__packed__));162 163#define HW_VERSION_UNKNOWN -1164#define HW_VERSION_1 1165#define HW_VERSION_2 2166 167/* IPW I/O ports */168#define IOIER 0x00 /* Interrupt Enable Register */169#define IOIR 0x02 /* Interrupt Source/ACK register */170#define IODCR 0x04 /* Data Control Register */171#define IODRR 0x06 /* Data Read Register */172#define IODWR 0x08 /* Data Write Register */173#define IOESR 0x0A /* Embedded Driver Status Register */174#define IORXR 0x0C /* Rx Fifo Register (Host to Embedded) */175#define IOTXR 0x0E /* Tx Fifo Register (Embedded to Host) */176 177/* I/O ports and bit definitions for version 1 of the hardware */178 179/* IER bits*/180#define IER_RXENABLED 0x1181#define IER_TXENABLED 0x2182 183/* ISR bits */184#define IR_RXINTR 0x1185#define IR_TXINTR 0x2186 187/* DCR bits */188#define DCR_RXDONE 0x1189#define DCR_TXDONE 0x2190#define DCR_RXRESET 0x4191#define DCR_TXRESET 0x8192 193/* I/O ports and bit definitions for version 2 of the hardware */194 195struct MEMCCR {196 unsigned short reg_config_option; /* PCCOR: Configuration Option Register */197 unsigned short reg_config_and_status; /* PCCSR: Configuration and Status Register */198 unsigned short reg_pin_replacement; /* PCPRR: Pin Replacemant Register */199 unsigned short reg_socket_and_copy; /* PCSCR: Socket and Copy Register */200 unsigned short reg_ext_status; /* PCESR: Extendend Status Register */201 unsigned short reg_io_base; /* PCIOB: I/O Base Register */202};203 204struct MEMINFREG {205 unsigned short memreg_tx_old; /* TX Register (R/W) */206 unsigned short pad1;207 unsigned short memreg_rx_done; /* RXDone Register (R/W) */208 unsigned short pad2;209 unsigned short memreg_rx; /* RX Register (R/W) */210 unsigned short pad3;211 unsigned short memreg_pc_interrupt_ack; /* PC intr Ack Register (W) */212 unsigned short pad4;213 unsigned long memreg_card_present;/* Mask for Host to check (R) for214 * CARD_PRESENT_VALUE */215 unsigned short memreg_tx_new; /* TX2 (new) Register (R/W) */216};217 218#define CARD_PRESENT_VALUE (0xBEEFCAFEUL)219 220#define MEMTX_TX 0x0001221#define MEMRX_RX 0x0001222#define MEMRX_RX_DONE 0x0001223#define MEMRX_PCINTACKK 0x0001224 225#define NL_NUM_OF_PRIORITIES 3226#define NL_NUM_OF_PROTOCOLS 3227#define NL_NUM_OF_ADDRESSES NO_OF_IPW_CHANNELS228 229struct ipw_hardware {230 unsigned int base_port;231 short hw_version;232 unsigned short ll_mtu;233 spinlock_t lock;234 235 int initializing;236 int init_loops;237 struct timer_list setup_timer;238 239 /* Flag if hw is ready to send next packet */240 int tx_ready;241 /* Count of pending packets to be sent */242 int tx_queued;243 struct list_head tx_queue[NL_NUM_OF_PRIORITIES];244 245 int rx_bytes_queued;246 struct list_head rx_queue;247 /* Pool of rx_packet structures that are not currently used. */248 struct list_head rx_pool;249 int rx_pool_size;250 /* True if reception of data is blocked while userspace processes it. */251 int blocking_rx;252 /* True if there is RX data ready on the hardware. */253 int rx_ready;254 unsigned short last_memtx_serial;255 /*256 * Newer versions of the V2 card firmware send serial numbers in the257 * MemTX register. 'serial_number_detected' is set true when we detect258 * a non-zero serial number (indicating the new firmware). Thereafter,259 * the driver can safely ignore the Timer Recovery re-sends to avoid260 * out-of-sync problems.261 */262 int serial_number_detected;263 struct work_struct work_rx;264 265 /* True if we are to send the set-up data to the hardware. */266 int to_setup;267 268 /* Card has been removed */269 int removed;270 /* Saved irq value when we disable the interrupt. */271 int irq;272 /* True if this driver is shutting down. */273 int shutting_down;274 /* Modem control lines */275 unsigned int control_lines[NL_NUM_OF_ADDRESSES];276 struct ipw_rx_packet *packet_assembler[NL_NUM_OF_ADDRESSES];277 278 struct tasklet_struct tasklet;279 280 /* The handle for the network layer, for the sending of events to it. */281 struct ipw_network *network;282 struct MEMINFREG __iomem *memory_info_regs;283 struct MEMCCR __iomem *memregs_CCR;284 void (*reboot_callback) (void *data);285 void *reboot_callback_data;286 287 unsigned short __iomem *memreg_tx;288};289 290/*291 * Packet info structure for tx packets.292 * Note: not all the fields defined here are required for all protocols293 */294struct ipw_tx_packet {295 struct list_head queue;296 /* channel idx + 1 */297 unsigned char dest_addr;298 /* SETUP, CTRL or DATA */299 unsigned char protocol;300 /* Length of data block, which starts at the end of this structure */301 unsigned short length;302 /* Sending state */303 /* Offset of where we've sent up to so far */304 unsigned long offset;305 /* Count of packet fragments, starting at 0 */306 int fragment_count;307 308 /* Called after packet is sent and before is freed */309 void (*packet_callback) (void *cb_data, unsigned int packet_length);310 void *callback_data;311};312 313/* Signals from DTE */314#define COMCTRL_RTS 0315#define COMCTRL_DTR 1316 317/* Signals from DCE */318#define COMCTRL_CTS 2319#define COMCTRL_DCD 3320#define COMCTRL_DSR 4321#define COMCTRL_RI 5322 323struct ipw_control_packet_body {324 /* DTE signal or DCE signal */325 unsigned char sig_no;326 /* 0: set signal, 1: clear signal */327 unsigned char value;328} __attribute__ ((__packed__));329 330struct ipw_control_packet {331 struct ipw_tx_packet header;332 struct ipw_control_packet_body body;333};334 335struct ipw_rx_packet {336 struct list_head queue;337 unsigned int capacity;338 unsigned int length;339 unsigned int protocol;340 unsigned int channel_idx;341};342 343static char *data_type(const unsigned char *buf, unsigned length)344{345 struct nl_packet_header *hdr = (struct nl_packet_header *) buf;346 347 if (length == 0)348 return " ";349 350 if (hdr->packet_rank & NL_FIRST_PACKET) {351 switch (hdr->protocol) {352 case TL_PROTOCOLID_COM_DATA: return "DATA ";353 case TL_PROTOCOLID_COM_CTRL: return "CTRL ";354 case TL_PROTOCOLID_SETUP: return "SETUP";355 default: return "???? ";356 }357 } else358 return " ";359}360 361#define DUMP_MAX_BYTES 64362 363static void dump_data_bytes(const char *type, const unsigned char *data,364 unsigned length)365{366 char prefix[56];367 368 sprintf(prefix, IPWIRELESS_PCCARD_NAME ": %s %s ",369 type, data_type(data, length));370 print_hex_dump_bytes(prefix, 0, (void *)data,371 length < DUMP_MAX_BYTES ? length : DUMP_MAX_BYTES);372}373 374static void swap_packet_bitfield_to_le(unsigned char *data)375{376#ifdef __BIG_ENDIAN_BITFIELD377 unsigned char tmp = *data, ret = 0;378 379 /*380 * transform bits from aa.bbb.ccc to ccc.bbb.aa381 */382 ret |= (tmp & 0xc0) >> 6;383 ret |= (tmp & 0x38) >> 1;384 ret |= (tmp & 0x07) << 5;385 *data = ret & 0xff;386#endif387}388 389static void swap_packet_bitfield_from_le(unsigned char *data)390{391#ifdef __BIG_ENDIAN_BITFIELD392 unsigned char tmp = *data, ret = 0;393 394 /*395 * transform bits from ccc.bbb.aa to aa.bbb.ccc396 */397 ret |= (tmp & 0xe0) >> 5;398 ret |= (tmp & 0x1c) << 1;399 ret |= (tmp & 0x03) << 6;400 *data = ret & 0xff;401#endif402}403 404static void do_send_fragment(struct ipw_hardware *hw, unsigned char *data,405 unsigned length)406{407 unsigned i;408 unsigned long flags;409 410 start_timing();411 BUG_ON(length > hw->ll_mtu);412 413 if (ipwireless_debug)414 dump_data_bytes("send", data, length);415 416 spin_lock_irqsave(&hw->lock, flags);417 418 hw->tx_ready = 0;419 swap_packet_bitfield_to_le(data);420 421 if (hw->hw_version == HW_VERSION_1) {422 outw((unsigned short) length, hw->base_port + IODWR);423 424 for (i = 0; i < length; i += 2) {425 unsigned short d = data[i];426 __le16 raw_data;427 428 if (i + 1 < length)429 d |= data[i + 1] << 8;430 raw_data = cpu_to_le16(d);431 outw(raw_data, hw->base_port + IODWR);432 }433 434 outw(DCR_TXDONE, hw->base_port + IODCR);435 } else if (hw->hw_version == HW_VERSION_2) {436 outw((unsigned short) length, hw->base_port);437 438 for (i = 0; i < length; i += 2) {439 unsigned short d = data[i];440 __le16 raw_data;441 442 if (i + 1 < length)443 d |= data[i + 1] << 8;444 raw_data = cpu_to_le16(d);445 outw(raw_data, hw->base_port);446 }447 while ((i & 3) != 2) {448 outw((unsigned short) 0xDEAD, hw->base_port);449 i += 2;450 }451 writew(MEMRX_RX, &hw->memory_info_regs->memreg_rx);452 }453 454 spin_unlock_irqrestore(&hw->lock, flags);455 456 end_write_timing(length);457}458 459static void do_send_packet(struct ipw_hardware *hw, struct ipw_tx_packet *packet)460{461 unsigned short fragment_data_len;462 unsigned short data_left = packet->length - packet->offset;463 unsigned short header_size;464 union nl_packet pkt;465 466 header_size =467 (packet->fragment_count == 0)468 ? NL_FIRST_PACKET_HEADER_SIZE469 : NL_FOLLOWING_PACKET_HEADER_SIZE;470 fragment_data_len = hw->ll_mtu - header_size;471 if (data_left < fragment_data_len)472 fragment_data_len = data_left;473 474 /*475 * hdr_first is now in machine bitfield order, which will be swapped476 * to le just before it goes to hw477 */478 pkt.hdr_first.protocol = packet->protocol;479 pkt.hdr_first.address = packet->dest_addr;480 pkt.hdr_first.packet_rank = 0;481 482 /* First packet? */483 if (packet->fragment_count == 0) {484 pkt.hdr_first.packet_rank |= NL_FIRST_PACKET;485 pkt.hdr_first.length_lsb = (unsigned char) packet->length;486 pkt.hdr_first.length_msb =487 (unsigned char) (packet->length >> 8);488 }489 490 memcpy(pkt.rawpkt + header_size,491 ((unsigned char *) packet) + sizeof(struct ipw_tx_packet) +492 packet->offset, fragment_data_len);493 packet->offset += fragment_data_len;494 packet->fragment_count++;495 496 /* Last packet? (May also be first packet.) */497 if (packet->offset == packet->length)498 pkt.hdr_first.packet_rank |= NL_LAST_PACKET;499 do_send_fragment(hw, pkt.rawpkt, header_size + fragment_data_len);500 501 /* If this packet has unsent data, then re-queue it. */502 if (packet->offset < packet->length) {503 /*504 * Re-queue it at the head of the highest priority queue so505 * it goes before all other packets506 */507 unsigned long flags;508 509 spin_lock_irqsave(&hw->lock, flags);510 list_add(&packet->queue, &hw->tx_queue[0]);511 hw->tx_queued++;512 spin_unlock_irqrestore(&hw->lock, flags);513 } else {514 if (packet->packet_callback)515 packet->packet_callback(packet->callback_data,516 packet->length);517 kfree(packet);518 }519}520 521static void ipw_setup_hardware(struct ipw_hardware *hw)522{523 unsigned long flags;524 525 spin_lock_irqsave(&hw->lock, flags);526 if (hw->hw_version == HW_VERSION_1) {527 /* Reset RX FIFO */528 outw(DCR_RXRESET, hw->base_port + IODCR);529 /* SB: Reset TX FIFO */530 outw(DCR_TXRESET, hw->base_port + IODCR);531 532 /* Enable TX and RX interrupts. */533 outw(IER_TXENABLED | IER_RXENABLED, hw->base_port + IOIER);534 } else {535 /*536 * Set INTRACK bit (bit 0), which means we must explicitly537 * acknowledge interrupts by clearing bit 2 of reg_config_and_status.538 */539 unsigned short csr = readw(&hw->memregs_CCR->reg_config_and_status);540 541 csr |= 1;542 writew(csr, &hw->memregs_CCR->reg_config_and_status);543 }544 spin_unlock_irqrestore(&hw->lock, flags);545}546 547/*548 * If 'packet' is NULL, then this function allocates a new packet, setting its549 * length to 0 and ensuring it has the specified minimum amount of free space.550 *551 * If 'packet' is not NULL, then this function enlarges it if it doesn't552 * have the specified minimum amount of free space.553 *554 */555static struct ipw_rx_packet *pool_allocate(struct ipw_hardware *hw,556 struct ipw_rx_packet *packet,557 int minimum_free_space)558{559 560 if (!packet) {561 unsigned long flags;562 563 spin_lock_irqsave(&hw->lock, flags);564 if (!list_empty(&hw->rx_pool)) {565 packet = list_first_entry(&hw->rx_pool,566 struct ipw_rx_packet, queue);567 hw->rx_pool_size--;568 spin_unlock_irqrestore(&hw->lock, flags);569 list_del(&packet->queue);570 } else {571 const int min_capacity =572 ipwireless_ppp_mru(hw->network) + 2;573 int new_capacity;574 575 spin_unlock_irqrestore(&hw->lock, flags);576 new_capacity =577 (minimum_free_space > min_capacity578 ? minimum_free_space579 : min_capacity);580 packet = kmalloc(sizeof(struct ipw_rx_packet)581 + new_capacity, GFP_ATOMIC);582 if (!packet)583 return NULL;584 packet->capacity = new_capacity;585 }586 packet->length = 0;587 }588 589 if (packet->length + minimum_free_space > packet->capacity) {590 struct ipw_rx_packet *old_packet = packet;591 592 packet = kmalloc(sizeof(struct ipw_rx_packet) +593 old_packet->length + minimum_free_space,594 GFP_ATOMIC);595 if (!packet) {596 kfree(old_packet);597 return NULL;598 }599 memcpy(packet, old_packet,600 sizeof(struct ipw_rx_packet)601 + old_packet->length);602 packet->capacity = old_packet->length + minimum_free_space;603 kfree(old_packet);604 }605 606 return packet;607}608 609static void pool_free(struct ipw_hardware *hw, struct ipw_rx_packet *packet)610{611 if (hw->rx_pool_size > 6)612 kfree(packet);613 else {614 hw->rx_pool_size++;615 list_add(&packet->queue, &hw->rx_pool);616 }617}618 619static void queue_received_packet(struct ipw_hardware *hw,620 unsigned int protocol,621 unsigned int address,622 const unsigned char *data, int length,623 int is_last)624{625 unsigned int channel_idx = address - 1;626 struct ipw_rx_packet *packet = NULL;627 unsigned long flags;628 629 /* Discard packet if channel index is out of range. */630 if (channel_idx >= NL_NUM_OF_ADDRESSES) {631 printk(KERN_INFO IPWIRELESS_PCCARD_NAME632 ": data packet has bad address %u\n", address);633 return;634 }635 636 /*637 * ->packet_assembler is safe to touch unlocked, this is the only place638 */639 if (protocol == TL_PROTOCOLID_COM_DATA) {640 struct ipw_rx_packet **assem =641 &hw->packet_assembler[channel_idx];642 643 /*644 * Create a new packet, or assembler already contains one645 * enlarge it by 'length' bytes.646 */647 (*assem) = pool_allocate(hw, *assem, length);648 if (!(*assem)) {649 printk(KERN_ERR IPWIRELESS_PCCARD_NAME650 ": no memory for incoming data packet, dropped!\n");651 return;652 }653 (*assem)->protocol = protocol;654 (*assem)->channel_idx = channel_idx;655 656 /* Append this packet data onto existing data. */657 memcpy((unsigned char *)(*assem) +658 sizeof(struct ipw_rx_packet)659 + (*assem)->length, data, length);660 (*assem)->length += length;661 if (is_last) {662 packet = *assem;663 *assem = NULL;664 /* Count queued DATA bytes only */665 spin_lock_irqsave(&hw->lock, flags);666 hw->rx_bytes_queued += packet->length;667 spin_unlock_irqrestore(&hw->lock, flags);668 }669 } else {670 /* If it's a CTRL packet, don't assemble, just queue it. */671 packet = pool_allocate(hw, NULL, length);672 if (!packet) {673 printk(KERN_ERR IPWIRELESS_PCCARD_NAME674 ": no memory for incoming ctrl packet, dropped!\n");675 return;676 }677 packet->protocol = protocol;678 packet->channel_idx = channel_idx;679 memcpy((unsigned char *)packet + sizeof(struct ipw_rx_packet),680 data, length);681 packet->length = length;682 }683 684 /*685 * If this is the last packet, then send the assembled packet on to the686 * network layer.687 */688 if (packet) {689 spin_lock_irqsave(&hw->lock, flags);690 list_add_tail(&packet->queue, &hw->rx_queue);691 /* Block reception of incoming packets if queue is full. */692 hw->blocking_rx =693 (hw->rx_bytes_queued >= IPWIRELESS_RX_QUEUE_SIZE);694 695 spin_unlock_irqrestore(&hw->lock, flags);696 schedule_work(&hw->work_rx);697 }698}699 700/*701 * Workqueue callback702 */703static void ipw_receive_data_work(struct work_struct *work_rx)704{705 struct ipw_hardware *hw =706 container_of(work_rx, struct ipw_hardware, work_rx);707 unsigned long flags;708 709 spin_lock_irqsave(&hw->lock, flags);710 while (!list_empty(&hw->rx_queue)) {711 struct ipw_rx_packet *packet =712 list_first_entry(&hw->rx_queue,713 struct ipw_rx_packet, queue);714 715 if (hw->shutting_down)716 break;717 list_del(&packet->queue);718 719 /*720 * Note: ipwireless_network_packet_received must be called in a721 * process context (i.e. via schedule_work) because the tty722 * output code can sleep in the tty_flip_buffer_push call.723 */724 if (packet->protocol == TL_PROTOCOLID_COM_DATA) {725 if (hw->network != NULL) {726 /* If the network hasn't been disconnected. */727 spin_unlock_irqrestore(&hw->lock, flags);728 /*729 * This must run unlocked due to tty processing730 * and mutex locking731 */732 ipwireless_network_packet_received(733 hw->network,734 packet->channel_idx,735 (unsigned char *)packet736 + sizeof(struct ipw_rx_packet),737 packet->length);738 spin_lock_irqsave(&hw->lock, flags);739 }740 /* Count queued DATA bytes only */741 hw->rx_bytes_queued -= packet->length;742 } else {743 /*744 * This is safe to be called locked, callchain does745 * not block746 */747 handle_received_CTRL_packet(hw, packet->channel_idx,748 (unsigned char *)packet749 + sizeof(struct ipw_rx_packet),750 packet->length);751 }752 pool_free(hw, packet);753 /*754 * Unblock reception of incoming packets if queue is no longer755 * full.756 */757 hw->blocking_rx =758 hw->rx_bytes_queued >= IPWIRELESS_RX_QUEUE_SIZE;759 if (hw->shutting_down)760 break;761 }762 spin_unlock_irqrestore(&hw->lock, flags);763}764 765static void handle_received_CTRL_packet(struct ipw_hardware *hw,766 unsigned int channel_idx,767 const unsigned char *data, int len)768{769 const struct ipw_control_packet_body *body =770 (const struct ipw_control_packet_body *) data;771 unsigned int changed_mask;772 773 if (len != sizeof(struct ipw_control_packet_body)) {774 printk(KERN_INFO IPWIRELESS_PCCARD_NAME775 ": control packet was %d bytes - wrong size!\n",776 len);777 return;778 }779 780 switch (body->sig_no) {781 case COMCTRL_CTS:782 changed_mask = IPW_CONTROL_LINE_CTS;783 break;784 case COMCTRL_DCD:785 changed_mask = IPW_CONTROL_LINE_DCD;786 break;787 case COMCTRL_DSR:788 changed_mask = IPW_CONTROL_LINE_DSR;789 break;790 case COMCTRL_RI:791 changed_mask = IPW_CONTROL_LINE_RI;792 break;793 default:794 changed_mask = 0;795 }796 797 if (changed_mask != 0) {798 if (body->value)799 hw->control_lines[channel_idx] |= changed_mask;800 else801 hw->control_lines[channel_idx] &= ~changed_mask;802 if (hw->network)803 ipwireless_network_notify_control_line_change(804 hw->network,805 channel_idx,806 hw->control_lines[channel_idx],807 changed_mask);808 }809}810 811static void handle_received_packet(struct ipw_hardware *hw,812 const union nl_packet *packet,813 unsigned short len)814{815 unsigned int protocol = packet->hdr.protocol;816 unsigned int address = packet->hdr.address;817 unsigned int header_length;818 const unsigned char *data;819 unsigned int data_len;820 int is_last = packet->hdr.packet_rank & NL_LAST_PACKET;821 822 if (packet->hdr.packet_rank & NL_FIRST_PACKET)823 header_length = NL_FIRST_PACKET_HEADER_SIZE;824 else825 header_length = NL_FOLLOWING_PACKET_HEADER_SIZE;826 827 data = packet->rawpkt + header_length;828 data_len = len - header_length;829 switch (protocol) {830 case TL_PROTOCOLID_COM_DATA:831 case TL_PROTOCOLID_COM_CTRL:832 queue_received_packet(hw, protocol, address, data, data_len,833 is_last);834 break;835 case TL_PROTOCOLID_SETUP:836 handle_received_SETUP_packet(hw, address, data, data_len,837 is_last);838 break;839 }840}841 842static void acknowledge_data_read(struct ipw_hardware *hw)843{844 if (hw->hw_version == HW_VERSION_1)845 outw(DCR_RXDONE, hw->base_port + IODCR);846 else847 writew(MEMRX_PCINTACKK,848 &hw->memory_info_regs->memreg_pc_interrupt_ack);849}850 851/*852 * Retrieve a packet from the IPW hardware.853 */854static void do_receive_packet(struct ipw_hardware *hw)855{856 unsigned len;857 unsigned i;858 unsigned char pkt[LL_MTU_MAX];859 860 start_timing();861 862 if (hw->hw_version == HW_VERSION_1) {863 len = inw(hw->base_port + IODRR);864 if (len > hw->ll_mtu) {865 printk(KERN_INFO IPWIRELESS_PCCARD_NAME866 ": received a packet of %u bytes - longer than the MTU!\n", len);867 outw(DCR_RXDONE | DCR_RXRESET, hw->base_port + IODCR);868 return;869 }870 871 for (i = 0; i < len; i += 2) {872 __le16 raw_data = inw(hw->base_port + IODRR);873 unsigned short data = le16_to_cpu(raw_data);874 875 pkt[i] = (unsigned char) data;876 pkt[i + 1] = (unsigned char) (data >> 8);877 }878 } else {879 len = inw(hw->base_port);880 if (len > hw->ll_mtu) {881 printk(KERN_INFO IPWIRELESS_PCCARD_NAME882 ": received a packet of %u bytes - longer than the MTU!\n", len);883 writew(MEMRX_PCINTACKK,884 &hw->memory_info_regs->memreg_pc_interrupt_ack);885 return;886 }887 888 for (i = 0; i < len; i += 2) {889 __le16 raw_data = inw(hw->base_port);890 unsigned short data = le16_to_cpu(raw_data);891 892 pkt[i] = (unsigned char) data;893 pkt[i + 1] = (unsigned char) (data >> 8);894 }895 896 while ((i & 3) != 2) {897 inw(hw->base_port);898 i += 2;899 }900 }901 902 acknowledge_data_read(hw);903 904 swap_packet_bitfield_from_le(pkt);905 906 if (ipwireless_debug)907 dump_data_bytes("recv", pkt, len);908 909 handle_received_packet(hw, (union nl_packet *) pkt, len);910 911 end_read_timing(len);912}913 914static int get_current_packet_priority(struct ipw_hardware *hw)915{916 /*917 * If we're initializing, don't send anything of higher priority than918 * PRIO_SETUP. The network layer therefore need not care about919 * hardware initialization - any of its stuff will simply be queued920 * until setup is complete.921 */922 return (hw->to_setup || hw->initializing923 ? PRIO_SETUP + 1 : NL_NUM_OF_PRIORITIES);924}925 926/*927 * return 1 if something has been received from hw928 */929static int get_packets_from_hw(struct ipw_hardware *hw)930{931 int received = 0;932 unsigned long flags;933 934 spin_lock_irqsave(&hw->lock, flags);935 while (hw->rx_ready && !hw->blocking_rx) {936 received = 1;937 hw->rx_ready--;938 spin_unlock_irqrestore(&hw->lock, flags);939 940 do_receive_packet(hw);941 942 spin_lock_irqsave(&hw->lock, flags);943 }944 spin_unlock_irqrestore(&hw->lock, flags);945 946 return received;947}948 949/*950 * Send pending packet up to given priority, prioritize SETUP data until951 * hardware is fully setup.952 *953 * return 1 if more packets can be sent954 */955static int send_pending_packet(struct ipw_hardware *hw, int priority_limit)956{957 int more_to_send = 0;958 unsigned long flags;959 960 spin_lock_irqsave(&hw->lock, flags);961 if (hw->tx_queued && hw->tx_ready) {962 int priority;963 struct ipw_tx_packet *packet = NULL;964 965 /* Pick a packet */966 for (priority = 0; priority < priority_limit; priority++) {967 if (!list_empty(&hw->tx_queue[priority])) {968 packet = list_first_entry(969 &hw->tx_queue[priority],970 struct ipw_tx_packet,971 queue);972 973 hw->tx_queued--;974 list_del(&packet->queue);975 976 break;977 }978 }979 if (!packet) {980 hw->tx_queued = 0;981 spin_unlock_irqrestore(&hw->lock, flags);982 return 0;983 }984 985 spin_unlock_irqrestore(&hw->lock, flags);986 987 /* Send */988 do_send_packet(hw, packet);989 990 /* Check if more to send */991 spin_lock_irqsave(&hw->lock, flags);992 for (priority = 0; priority < priority_limit; priority++)993 if (!list_empty(&hw->tx_queue[priority])) {994 more_to_send = 1;995 break;996 }997 998 if (!more_to_send)999 hw->tx_queued = 0;1000 }1001 spin_unlock_irqrestore(&hw->lock, flags);1002 1003 return more_to_send;1004}1005 1006/*1007 * Send and receive all queued packets.1008 */1009static void ipwireless_do_tasklet(struct tasklet_struct *t)1010{1011 struct ipw_hardware *hw = from_tasklet(hw, t, tasklet);1012 unsigned long flags;1013 1014 spin_lock_irqsave(&hw->lock, flags);1015 if (hw->shutting_down) {1016 spin_unlock_irqrestore(&hw->lock, flags);1017 return;1018 }1019 1020 if (hw->to_setup == 1) {1021 /*1022 * Initial setup data sent to hardware1023 */1024 hw->to_setup = 2;1025 spin_unlock_irqrestore(&hw->lock, flags);1026 1027 ipw_setup_hardware(hw);1028 ipw_send_setup_packet(hw);1029 1030 send_pending_packet(hw, PRIO_SETUP + 1);1031 get_packets_from_hw(hw);1032 } else {1033 int priority_limit = get_current_packet_priority(hw);1034 int again;1035 1036 spin_unlock_irqrestore(&hw->lock, flags);1037 1038 do {1039 again = send_pending_packet(hw, priority_limit);1040 again |= get_packets_from_hw(hw);1041 } while (again);1042 }1043}1044 1045/*1046 * return true if the card is physically present.1047 */1048static int is_card_present(struct ipw_hardware *hw)1049{1050 if (hw->hw_version == HW_VERSION_1)1051 return inw(hw->base_port + IOIR) != 0xFFFF;1052 else1053 return readl(&hw->memory_info_regs->memreg_card_present) ==1054 CARD_PRESENT_VALUE;1055}1056 1057static irqreturn_t ipwireless_handle_v1_interrupt(int irq,1058 struct ipw_hardware *hw)1059{1060 unsigned short irqn;1061 1062 irqn = inw(hw->base_port + IOIR);1063 1064 /* Check if card is present */1065 if (irqn == 0xFFFF)1066 return IRQ_NONE;1067 else if (irqn != 0) {1068 unsigned short ack = 0;1069 unsigned long flags;1070 1071 /* Transmit complete. */1072 if (irqn & IR_TXINTR) {1073 ack |= IR_TXINTR;1074 spin_lock_irqsave(&hw->lock, flags);1075 hw->tx_ready = 1;1076 spin_unlock_irqrestore(&hw->lock, flags);1077 }1078 /* Received data */1079 if (irqn & IR_RXINTR) {1080 ack |= IR_RXINTR;1081 spin_lock_irqsave(&hw->lock, flags);1082 hw->rx_ready++;1083 spin_unlock_irqrestore(&hw->lock, flags);1084 }1085 if (ack != 0) {1086 outw(ack, hw->base_port + IOIR);1087 tasklet_schedule(&hw->tasklet);1088 }1089 return IRQ_HANDLED;1090 }1091 return IRQ_NONE;1092}1093 1094static void acknowledge_pcmcia_interrupt(struct ipw_hardware *hw)1095{1096 unsigned short csr = readw(&hw->memregs_CCR->reg_config_and_status);1097 1098 csr &= 0xfffd;1099 writew(csr, &hw->memregs_CCR->reg_config_and_status);1100}1101 1102static irqreturn_t ipwireless_handle_v2_v3_interrupt(int irq,1103 struct ipw_hardware *hw)1104{1105 int tx = 0;1106 int rx = 0;1107 int rx_repeat = 0;1108 int try_mem_tx_old;1109 unsigned long flags;1110 1111 do {1112 1113 unsigned short memtx = readw(hw->memreg_tx);1114 unsigned short memtx_serial;1115 unsigned short memrxdone =1116 readw(&hw->memory_info_regs->memreg_rx_done);1117 1118 try_mem_tx_old = 0;1119 1120 /* check whether the interrupt was generated by ipwireless card */1121 if (!(memtx & MEMTX_TX) && !(memrxdone & MEMRX_RX_DONE)) {1122 1123 /* check if the card uses memreg_tx_old register */1124 if (hw->memreg_tx == &hw->memory_info_regs->memreg_tx_new) {1125 memtx = readw(&hw->memory_info_regs->memreg_tx_old);1126 if (memtx & MEMTX_TX) {1127 printk(KERN_INFO IPWIRELESS_PCCARD_NAME1128 ": Using memreg_tx_old\n");1129 hw->memreg_tx =1130 &hw->memory_info_regs->memreg_tx_old;1131 } else {1132 return IRQ_NONE;1133 }1134 } else1135 return IRQ_NONE;1136 }1137 1138 /*1139 * See if the card is physically present. Note that while it is1140 * powering up, it appears not to be present.1141 */1142 if (!is_card_present(hw)) {1143 acknowledge_pcmcia_interrupt(hw);1144 return IRQ_HANDLED;1145 }1146 1147 memtx_serial = memtx & (unsigned short) 0xff00;1148 if (memtx & MEMTX_TX) {1149 writew(memtx_serial, hw->memreg_tx);1150 1151 if (hw->serial_number_detected) {1152 if (memtx_serial != hw->last_memtx_serial) {1153 hw->last_memtx_serial = memtx_serial;1154 spin_lock_irqsave(&hw->lock, flags);1155 hw->rx_ready++;1156 spin_unlock_irqrestore(&hw->lock, flags);1157 rx = 1;1158 } else1159 /* Ignore 'Timer Recovery' duplicates. */1160 rx_repeat = 1;1161 } else {1162 /*1163 * If a non-zero serial number is seen, then enable1164 * serial number checking.1165 */1166 if (memtx_serial != 0) {1167 hw->serial_number_detected = 1;1168 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME1169 ": memreg_tx serial num detected\n");1170 1171 spin_lock_irqsave(&hw->lock, flags);1172 hw->rx_ready++;1173 spin_unlock_irqrestore(&hw->lock, flags);1174 }1175 rx = 1;1176 }1177 }1178 if (memrxdone & MEMRX_RX_DONE) {1179 writew(0, &hw->memory_info_regs->memreg_rx_done);1180 spin_lock_irqsave(&hw->lock, flags);1181 hw->tx_ready = 1;1182 spin_unlock_irqrestore(&hw->lock, flags);1183 tx = 1;1184 }1185 if (tx)1186 writew(MEMRX_PCINTACKK,1187 &hw->memory_info_regs->memreg_pc_interrupt_ack);1188 1189 acknowledge_pcmcia_interrupt(hw);1190 1191 if (tx || rx)1192 tasklet_schedule(&hw->tasklet);1193 else if (!rx_repeat) {1194 if (hw->memreg_tx == &hw->memory_info_regs->memreg_tx_new) {1195 if (hw->serial_number_detected)1196 printk(KERN_WARNING IPWIRELESS_PCCARD_NAME1197 ": spurious interrupt - new_tx mode\n");1198 else {1199 printk(KERN_WARNING IPWIRELESS_PCCARD_NAME1200 ": no valid memreg_tx value - switching to the old memreg_tx\n");1201 hw->memreg_tx =1202 &hw->memory_info_regs->memreg_tx_old;1203 try_mem_tx_old = 1;1204 }1205 } else1206 printk(KERN_WARNING IPWIRELESS_PCCARD_NAME1207 ": spurious interrupt - old_tx mode\n");1208 }1209 1210 } while (try_mem_tx_old == 1);1211 1212 return IRQ_HANDLED;1213}1214 1215irqreturn_t ipwireless_interrupt(int irq, void *dev_id)1216{1217 struct ipw_dev *ipw = dev_id;1218 1219 if (ipw->hardware->hw_version == HW_VERSION_1)1220 return ipwireless_handle_v1_interrupt(irq, ipw->hardware);1221 else1222 return ipwireless_handle_v2_v3_interrupt(irq, ipw->hardware);1223}1224 1225static void flush_packets_to_hw(struct ipw_hardware *hw)1226{1227 int priority_limit;1228 unsigned long flags;1229 1230 spin_lock_irqsave(&hw->lock, flags);1231 priority_limit = get_current_packet_priority(hw);1232 spin_unlock_irqrestore(&hw->lock, flags);1233 1234 while (send_pending_packet(hw, priority_limit));1235}1236 1237static void send_packet(struct ipw_hardware *hw, int priority,1238 struct ipw_tx_packet *packet)1239{1240 unsigned long flags;1241 1242 spin_lock_irqsave(&hw->lock, flags);1243 list_add_tail(&packet->queue, &hw->tx_queue[priority]);1244 hw->tx_queued++;1245 spin_unlock_irqrestore(&hw->lock, flags);1246 1247 flush_packets_to_hw(hw);1248}1249 1250/* Create data packet, non-atomic allocation */1251static void *alloc_data_packet(int data_size,1252 unsigned char dest_addr,1253 unsigned char protocol)1254{1255 struct ipw_tx_packet *packet = kzalloc(1256 sizeof(struct ipw_tx_packet) + data_size,1257 GFP_ATOMIC);1258 1259 if (!packet)1260 return NULL;1261 1262 INIT_LIST_HEAD(&packet->queue);1263 packet->dest_addr = dest_addr;1264 packet->protocol = protocol;1265 packet->length = data_size;1266 1267 return packet;1268}1269 1270static void *alloc_ctrl_packet(int header_size,1271 unsigned char dest_addr,1272 unsigned char protocol,1273 unsigned char sig_no)1274{1275 /*1276 * sig_no is located right after ipw_tx_packet struct in every1277 * CTRL or SETUP packets, we can use ipw_control_packet as a1278 * common struct1279 */1280 struct ipw_control_packet *packet = kzalloc(header_size, GFP_ATOMIC);1281 1282 if (!packet)1283 return NULL;1284 1285 INIT_LIST_HEAD(&packet->header.queue);1286 packet->header.dest_addr = dest_addr;1287 packet->header.protocol = protocol;1288 packet->header.length = header_size - sizeof(struct ipw_tx_packet);1289 packet->body.sig_no = sig_no;1290 1291 return packet;1292}1293 1294int ipwireless_send_packet(struct ipw_hardware *hw, unsigned int channel_idx,1295 const u8 *data, unsigned int length,1296 void (*callback) (void *cb, unsigned int length),1297 void *callback_data)1298{1299 struct ipw_tx_packet *packet;1300 1301 packet = alloc_data_packet(length, (channel_idx + 1),1302 TL_PROTOCOLID_COM_DATA);1303 if (!packet)1304 return -ENOMEM;1305 packet->packet_callback = callback;1306 packet->callback_data = callback_data;1307 memcpy((unsigned char *) packet + sizeof(struct ipw_tx_packet), data,1308 length);1309 1310 send_packet(hw, PRIO_DATA, packet);1311 return 0;1312}1313 1314static int set_control_line(struct ipw_hardware *hw, int prio,1315 unsigned int channel_idx, int line, int state)1316{1317 struct ipw_control_packet *packet;1318 int protocolid = TL_PROTOCOLID_COM_CTRL;1319 1320 if (prio == PRIO_SETUP)1321 protocolid = TL_PROTOCOLID_SETUP;1322 1323 packet = alloc_ctrl_packet(sizeof(struct ipw_control_packet),1324 (channel_idx + 1), protocolid, line);1325 if (!packet)1326 return -ENOMEM;1327 packet->header.length = sizeof(struct ipw_control_packet_body);1328 packet->body.value = (state == 0 ? 0 : 1);1329 send_packet(hw, prio, &packet->header);1330 return 0;1331}1332 1333 1334static int set_DTR(struct ipw_hardware *hw, int priority,1335 unsigned int channel_idx, int state)1336{1337 if (state != 0)1338 hw->control_lines[channel_idx] |= IPW_CONTROL_LINE_DTR;1339 else1340 hw->control_lines[channel_idx] &= ~IPW_CONTROL_LINE_DTR;1341 1342 return set_control_line(hw, priority, channel_idx, COMCTRL_DTR, state);1343}1344 1345static int set_RTS(struct ipw_hardware *hw, int priority,1346 unsigned int channel_idx, int state)1347{1348 if (state != 0)1349 hw->control_lines[channel_idx] |= IPW_CONTROL_LINE_RTS;1350 else1351 hw->control_lines[channel_idx] &= ~IPW_CONTROL_LINE_RTS;1352 1353 return set_control_line(hw, priority, channel_idx, COMCTRL_RTS, state);1354}1355 1356int ipwireless_set_DTR(struct ipw_hardware *hw, unsigned int channel_idx,1357 int state)1358{1359 return set_DTR(hw, PRIO_CTRL, channel_idx, state);1360}1361 1362int ipwireless_set_RTS(struct ipw_hardware *hw, unsigned int channel_idx,1363 int state)1364{1365 return set_RTS(hw, PRIO_CTRL, channel_idx, state);1366}1367 1368struct ipw_setup_get_version_query_packet {1369 struct ipw_tx_packet header;1370 struct tl_setup_get_version_qry body;1371};1372 1373struct ipw_setup_config_packet {1374 struct ipw_tx_packet header;1375 struct tl_setup_config_msg body;1376};1377 1378struct ipw_setup_config_done_packet {1379 struct ipw_tx_packet header;1380 struct tl_setup_config_done_msg body;1381};1382 1383struct ipw_setup_open_packet {1384 struct ipw_tx_packet header;1385 struct tl_setup_open_msg body;1386};1387 1388struct ipw_setup_info_packet {1389 struct ipw_tx_packet header;1390 struct tl_setup_info_msg body;1391};1392 1393struct ipw_setup_reboot_msg_ack {1394 struct ipw_tx_packet header;1395 struct TlSetupRebootMsgAck body;1396};1397 1398/* This handles the actual initialization of the card */1399static void __handle_setup_get_version_rsp(struct ipw_hardware *hw)1400{1401 struct ipw_setup_config_packet *config_packet;1402 struct ipw_setup_config_done_packet *config_done_packet;1403 struct ipw_setup_open_packet *open_packet;1404 struct ipw_setup_info_packet *info_packet;1405 int port;1406 unsigned int channel_idx;1407 1408 /* generate config packet */1409 for (port = 1; port <= NL_NUM_OF_ADDRESSES; port++) {1410 config_packet = alloc_ctrl_packet(1411 sizeof(struct ipw_setup_config_packet),1412 ADDR_SETUP_PROT,1413 TL_PROTOCOLID_SETUP,1414 TL_SETUP_SIGNO_CONFIG_MSG);1415 if (!config_packet)1416 goto exit_nomem;1417 config_packet->header.length = sizeof(struct tl_setup_config_msg);1418 config_packet->body.port_no = port;1419 config_packet->body.prio_data = PRIO_DATA;1420 config_packet->body.prio_ctrl = PRIO_CTRL;1421 send_packet(hw, PRIO_SETUP, &config_packet->header);1422 }1423 config_done_packet = alloc_ctrl_packet(1424 sizeof(struct ipw_setup_config_done_packet),1425 ADDR_SETUP_PROT,1426 TL_PROTOCOLID_SETUP,1427 TL_SETUP_SIGNO_CONFIG_DONE_MSG);1428 if (!config_done_packet)1429 goto exit_nomem;1430 config_done_packet->header.length = sizeof(struct tl_setup_config_done_msg);1431 send_packet(hw, PRIO_SETUP, &config_done_packet->header);1432 1433 /* generate open packet */1434 for (port = 1; port <= NL_NUM_OF_ADDRESSES; port++) {1435 open_packet = alloc_ctrl_packet(1436 sizeof(struct ipw_setup_open_packet),1437 ADDR_SETUP_PROT,1438 TL_PROTOCOLID_SETUP,1439 TL_SETUP_SIGNO_OPEN_MSG);1440 if (!open_packet)1441 goto exit_nomem;1442 open_packet->header.length = sizeof(struct tl_setup_open_msg);1443 open_packet->body.port_no = port;1444 send_packet(hw, PRIO_SETUP, &open_packet->header);1445 }1446 for (channel_idx = 0;1447 channel_idx < NL_NUM_OF_ADDRESSES; channel_idx++) {1448 int ret;1449 1450 ret = set_DTR(hw, PRIO_SETUP, channel_idx,1451 (hw->control_lines[channel_idx] &1452 IPW_CONTROL_LINE_DTR) != 0);1453 if (ret) {1454 printk(KERN_ERR IPWIRELESS_PCCARD_NAME1455 ": error setting DTR (%d)\n", ret);1456 return;1457 }1458 1459 ret = set_RTS(hw, PRIO_SETUP, channel_idx,1460 (hw->control_lines [channel_idx] &1461 IPW_CONTROL_LINE_RTS) != 0);1462 if (ret) {1463 printk(KERN_ERR IPWIRELESS_PCCARD_NAME1464 ": error setting RTS (%d)\n", ret);1465 return;1466 }1467 }1468 /*1469 * For NDIS we assume that we are using sync PPP frames, for COM async.1470 * This driver uses NDIS mode too. We don't bother with translation1471 * from async -> sync PPP.1472 */1473 info_packet = alloc_ctrl_packet(sizeof(struct ipw_setup_info_packet),1474 ADDR_SETUP_PROT,1475 TL_PROTOCOLID_SETUP,1476 TL_SETUP_SIGNO_INFO_MSG);1477 if (!info_packet)1478 goto exit_nomem;1479 info_packet->header.length = sizeof(struct tl_setup_info_msg);1480 info_packet->body.driver_type = NDISWAN_DRIVER;1481 info_packet->body.major_version = NDISWAN_DRIVER_MAJOR_VERSION;1482 info_packet->body.minor_version = NDISWAN_DRIVER_MINOR_VERSION;1483 send_packet(hw, PRIO_SETUP, &info_packet->header);1484 1485 /* Initialization is now complete, so we clear the 'to_setup' flag */1486 hw->to_setup = 0;1487 1488 return;1489 1490exit_nomem:1491 printk(KERN_ERR IPWIRELESS_PCCARD_NAME1492 ": not enough memory to alloc control packet\n");1493 hw->to_setup = -1;1494}1495 1496static void handle_setup_get_version_rsp(struct ipw_hardware *hw,1497 unsigned char vers_no)1498{1499 del_timer(&hw->setup_timer);1500 hw->initializing = 0;1501 printk(KERN_INFO IPWIRELESS_PCCARD_NAME ": card is ready.\n");1502 1503 if (vers_no == TL_SETUP_VERSION)1504 __handle_setup_get_version_rsp(hw);1505 else1506 printk(KERN_ERR IPWIRELESS_PCCARD_NAME1507 ": invalid hardware version no %u\n",1508 (unsigned int) vers_no);1509}1510 1511static void ipw_send_setup_packet(struct ipw_hardware *hw)1512{1513 struct ipw_setup_get_version_query_packet *ver_packet;1514 1515 ver_packet = alloc_ctrl_packet(1516 sizeof(struct ipw_setup_get_version_query_packet),1517 ADDR_SETUP_PROT, TL_PROTOCOLID_SETUP,1518 TL_SETUP_SIGNO_GET_VERSION_QRY);1519 if (!ver_packet)1520 return;1521 ver_packet->header.length = sizeof(struct tl_setup_get_version_qry);1522 1523 /*1524 * Response is handled in handle_received_SETUP_packet1525 */1526 send_packet(hw, PRIO_SETUP, &ver_packet->header);1527}1528 1529static void handle_received_SETUP_packet(struct ipw_hardware *hw,1530 unsigned int address,1531 const unsigned char *data, int len,1532 int is_last)1533{1534 const union ipw_setup_rx_msg *rx_msg = (const union ipw_setup_rx_msg *) data;1535 1536 if (address != ADDR_SETUP_PROT) {1537 printk(KERN_INFO IPWIRELESS_PCCARD_NAME1538 ": setup packet has bad address %d\n", address);1539 return;1540 }1541 1542 switch (rx_msg->sig_no) {1543 case TL_SETUP_SIGNO_GET_VERSION_RSP:1544 if (hw->to_setup)1545 handle_setup_get_version_rsp(hw,1546 rx_msg->version_rsp_msg.version);1547 break;1548 1549 case TL_SETUP_SIGNO_OPEN_MSG:1550 if (ipwireless_debug) {1551 unsigned int channel_idx = rx_msg->open_msg.port_no - 1;1552 1553 printk(KERN_INFO IPWIRELESS_PCCARD_NAME1554 ": OPEN_MSG [channel %u] reply received\n",1555 channel_idx);1556 }1557 break;1558 1559 case TL_SETUP_SIGNO_INFO_MSG_ACK:1560 if (ipwireless_debug)1561 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME1562 ": card successfully configured as NDISWAN\n");1563 break;1564 1565 case TL_SETUP_SIGNO_REBOOT_MSG:1566 if (hw->to_setup)1567 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME1568 ": Setup not completed - ignoring reboot msg\n");1569 else {1570 struct ipw_setup_reboot_msg_ack *packet;1571 1572 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME1573 ": Acknowledging REBOOT message\n");1574 packet = alloc_ctrl_packet(1575 sizeof(struct ipw_setup_reboot_msg_ack),1576 ADDR_SETUP_PROT, TL_PROTOCOLID_SETUP,1577 TL_SETUP_SIGNO_REBOOT_MSG_ACK);1578 if (!packet) {1579 pr_err(IPWIRELESS_PCCARD_NAME1580 ": Not enough memory to send reboot packet");1581 break;1582 }1583 packet->header.length =1584 sizeof(struct TlSetupRebootMsgAck);1585 send_packet(hw, PRIO_SETUP, &packet->header);1586 if (hw->reboot_callback)1587 hw->reboot_callback(hw->reboot_callback_data);1588 }1589 break;1590 1591 default:1592 printk(KERN_INFO IPWIRELESS_PCCARD_NAME1593 ": unknown setup message %u received\n",1594 (unsigned int) rx_msg->sig_no);1595 }1596}1597 1598static void do_close_hardware(struct ipw_hardware *hw)1599{1600 unsigned int irqn;1601 1602 if (hw->hw_version == HW_VERSION_1) {1603 /* Disable TX and RX interrupts. */1604 outw(0, hw->base_port + IOIER);1605 1606 /* Acknowledge any outstanding interrupt requests */1607 irqn = inw(hw->base_port + IOIR);1608 if (irqn & IR_TXINTR)1609 outw(IR_TXINTR, hw->base_port + IOIR);1610 if (irqn & IR_RXINTR)1611 outw(IR_RXINTR, hw->base_port + IOIR);1612 1613 synchronize_irq(hw->irq);1614 }1615}1616 1617struct ipw_hardware *ipwireless_hardware_create(void)1618{1619 int i;1620 struct ipw_hardware *hw =1621 kzalloc(sizeof(struct ipw_hardware), GFP_KERNEL);1622 1623 if (!hw)1624 return NULL;1625 1626 hw->irq = -1;1627 hw->initializing = 1;1628 hw->tx_ready = 1;1629 hw->rx_bytes_queued = 0;1630 hw->rx_pool_size = 0;1631 hw->last_memtx_serial = (unsigned short) 0xffff;1632 for (i = 0; i < NL_NUM_OF_PRIORITIES; i++)1633 INIT_LIST_HEAD(&hw->tx_queue[i]);1634 1635 INIT_LIST_HEAD(&hw->rx_queue);1636 INIT_LIST_HEAD(&hw->rx_pool);1637 spin_lock_init(&hw->lock);1638 tasklet_setup(&hw->tasklet, ipwireless_do_tasklet);1639 INIT_WORK(&hw->work_rx, ipw_receive_data_work);1640 timer_setup(&hw->setup_timer, ipwireless_setup_timer, 0);1641 1642 return hw;1643}1644 1645void ipwireless_init_hardware_v1(struct ipw_hardware *hw,1646 unsigned int base_port,1647 void __iomem *attr_memory,1648 void __iomem *common_memory,1649 int is_v2_card,1650 void (*reboot_callback) (void *data),1651 void *reboot_callback_data)1652{1653 if (hw->removed) {1654 hw->removed = 0;1655 enable_irq(hw->irq);1656 }1657 hw->base_port = base_port;1658 hw->hw_version = (is_v2_card ? HW_VERSION_2 : HW_VERSION_1);1659 hw->ll_mtu = (hw->hw_version == HW_VERSION_1 ? LL_MTU_V1 : LL_MTU_V2);1660 hw->memregs_CCR = (struct MEMCCR __iomem *)1661 ((unsigned short __iomem *) attr_memory + 0x200);1662 hw->memory_info_regs = (struct MEMINFREG __iomem *) common_memory;1663 hw->memreg_tx = &hw->memory_info_regs->memreg_tx_new;1664 hw->reboot_callback = reboot_callback;1665 hw->reboot_callback_data = reboot_callback_data;1666}1667 1668void ipwireless_init_hardware_v2_v3(struct ipw_hardware *hw)1669{1670 hw->initializing = 1;1671 hw->init_loops = 0;1672 printk(KERN_INFO IPWIRELESS_PCCARD_NAME1673 ": waiting for card to start up...\n");1674 ipwireless_setup_timer(&hw->setup_timer);1675}1676 1677static void ipwireless_setup_timer(struct timer_list *t)1678{1679 struct ipw_hardware *hw = from_timer(hw, t, setup_timer);1680 1681 hw->init_loops++;1682 1683 if (hw->init_loops == TL_SETUP_MAX_VERSION_QRY &&1684 hw->hw_version == HW_VERSION_2 &&1685 hw->memreg_tx == &hw->memory_info_regs->memreg_tx_new) {1686 printk(KERN_INFO IPWIRELESS_PCCARD_NAME1687 ": failed to startup using TX2, trying TX\n");1688 1689 hw->memreg_tx = &hw->memory_info_regs->memreg_tx_old;1690 hw->init_loops = 0;1691 }1692 /* Give up after a certain number of retries */1693 if (hw->init_loops == TL_SETUP_MAX_VERSION_QRY) {1694 printk(KERN_INFO IPWIRELESS_PCCARD_NAME1695 ": card failed to start up!\n");1696 hw->initializing = 0;1697 } else {1698 /* Do not attempt to write to the board if it is not present. */1699 if (is_card_present(hw)) {1700 unsigned long flags;1701 1702 spin_lock_irqsave(&hw->lock, flags);1703 hw->to_setup = 1;1704 hw->tx_ready = 1;1705 spin_unlock_irqrestore(&hw->lock, flags);1706 tasklet_schedule(&hw->tasklet);1707 }1708 1709 mod_timer(&hw->setup_timer,1710 jiffies + msecs_to_jiffies(TL_SETUP_VERSION_QRY_TMO));1711 }1712}1713 1714/*1715 * Stop any interrupts from executing so that, once this function returns,1716 * other layers of the driver can be sure they won't get any more callbacks.1717 * Thus must be called on a proper process context.1718 */1719void ipwireless_stop_interrupts(struct ipw_hardware *hw)1720{1721 if (!hw->shutting_down) {1722 /* Tell everyone we are going down. */1723 hw->shutting_down = 1;1724 del_timer(&hw->setup_timer);1725 1726 /* Prevent the hardware from sending any more interrupts */1727 do_close_hardware(hw);1728 }1729}1730 1731void ipwireless_hardware_free(struct ipw_hardware *hw)1732{1733 int i;1734 struct ipw_rx_packet *rp, *rq;1735 struct ipw_tx_packet *tp, *tq;1736 1737 ipwireless_stop_interrupts(hw);1738 1739 flush_work(&hw->work_rx);1740 1741 for (i = 0; i < NL_NUM_OF_ADDRESSES; i++)1742 kfree(hw->packet_assembler[i]);1743 1744 for (i = 0; i < NL_NUM_OF_PRIORITIES; i++)1745 list_for_each_entry_safe(tp, tq, &hw->tx_queue[i], queue) {1746 list_del(&tp->queue);1747 kfree(tp);1748 }1749 1750 list_for_each_entry_safe(rp, rq, &hw->rx_queue, queue) {1751 list_del(&rp->queue);1752 kfree(rp);1753 }1754 1755 list_for_each_entry_safe(rp, rq, &hw->rx_pool, queue) {1756 list_del(&rp->queue);1757 kfree(rp);1758 }1759 kfree(hw);1760}1761 1762/*1763 * Associate the specified network with this hardware, so it will receive events1764 * from it.1765 */1766void ipwireless_associate_network(struct ipw_hardware *hw,1767 struct ipw_network *network)1768{1769 hw->network = network;1770}1771