1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * IPWireless 3G PCMCIA Network Driver
   4 *
   5 * Original code
   6 *   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 kernels
  13 *   Copyright (C) 2006-2007 Jiri Kosina
  14 *
  15 * Misc code cleanups and updates
  16 *   Copyright (C) 2007 David Sterba
  17 */
  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_DIAGNOSTICS
  43
  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_NAME
  83			       ": %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#else
  97static void start_timing(void) { }
  98static void end_read_timing(unsigned length) { }
  99static void end_write_timing(unsigned length) { }
 100#endif
 101
 102/* Imported IPW definitions */
 103
 104#define LL_MTU_V1 318
 105#define LL_MTU_V2 250
 106#define LL_MTU_MAX (LL_MTU_V1 > LL_MTU_V2 ? LL_MTU_V1 : LL_MTU_V2)
 107
 108#define PRIO_DATA  2
 109#define PRIO_CTRL  1
 110#define PRIO_SETUP 0
 111
 112/* Addresses */
 113#define ADDR_SETUP_PROT 0
 114
 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 = 2
 125};
 126
 127/* Number of bytes in NL packet header (cannot do
 128 * sizeof(nl_packet_header) since it's a bitfield) */
 129#define NL_FIRST_PACKET_HEADER_SIZE        3
 130
 131/* Number of bytes in NL packet header (cannot do
 132 * sizeof(nl_packet_header) since it's a bitfield) */
 133#define NL_FOLLOWING_PACKET_HEADER_SIZE    1
 134
 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    0x0
 151#define NL_LAST_PACKET            0x1
 152#define NL_FIRST_PACKET           0x2
 153
 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 -1
 164#define HW_VERSION_1 1
 165#define HW_VERSION_2 2
 166
 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   0x1
 181#define IER_TXENABLED   0x2
 182
 183/* ISR bits */
 184#define IR_RXINTR       0x1
 185#define IR_TXINTR       0x2
 186
 187/* DCR bits */
 188#define DCR_RXDONE      0x1
 189#define DCR_TXDONE      0x2
 190#define DCR_RXRESET     0x4
 191#define DCR_TXRESET     0x8
 192
 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) for
 214					   * 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                       0x0001
 221#define MEMRX_RX                       0x0001
 222#define MEMRX_RX_DONE                  0x0001
 223#define MEMRX_PCINTACKK                0x0001
 224
 225#define NL_NUM_OF_PRIORITIES       3
 226#define NL_NUM_OF_PROTOCOLS        3
 227#define NL_NUM_OF_ADDRESSES        NO_OF_IPW_CHANNELS
 228
 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 the
 257	 * MemTX register. 'serial_number_detected' is set true when we detect
 258	 * a non-zero serial number (indicating the new firmware).  Thereafter,
 259	 * the driver can safely ignore the Timer Recovery re-sends to avoid
 260	 * 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 protocols
 293 */
 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	0
 315#define COMCTRL_DTR	1
 316
 317/* Signals from DCE */
 318#define COMCTRL_CTS	2
 319#define COMCTRL_DCD	3
 320#define COMCTRL_DSR	4
 321#define COMCTRL_RI	5
 322
 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	} else
 358		return "     ";
 359}
 360
 361#define DUMP_MAX_BYTES 64
 362
 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_BITFIELD
 377	unsigned char tmp = *data, ret = 0;
 378
 379	/*
 380	 * transform bits from aa.bbb.ccc to ccc.bbb.aa
 381	 */
 382	ret |= (tmp & 0xc0) >> 6;
 383	ret |= (tmp & 0x38) >> 1;
 384	ret |= (tmp & 0x07) << 5;
 385	*data = ret & 0xff;
 386#endif
 387}
 388
 389static void swap_packet_bitfield_from_le(unsigned char *data)
 390{
 391#ifdef __BIG_ENDIAN_BITFIELD
 392	unsigned char tmp = *data, ret = 0;
 393
 394	/*
 395	 * transform bits from ccc.bbb.aa to aa.bbb.ccc
 396	 */
 397	ret |= (tmp & 0xe0) >> 5;
 398	ret |= (tmp & 0x1c) << 1;
 399	ret |= (tmp & 0x03) << 6;
 400	*data = ret & 0xff;
 401#endif
 402}
 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_SIZE
 469	    : 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 swapped
 476	 * to le just before it goes to hw
 477	 */
 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 so
 505		 * it goes before all other packets
 506		 */
 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 explicitly
 537		 * 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 its
 549 * 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't
 552 * 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_capacity
 578				 ? minimum_free_space
 579				 : 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_NAME
 632		       ": 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 place
 638	 */
 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 one
 645		 * enlarge it by 'length' bytes.
 646		 */
 647		(*assem) = pool_allocate(hw, *assem, length);
 648		if (!(*assem)) {
 649			printk(KERN_ERR IPWIRELESS_PCCARD_NAME
 650				": 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_NAME
 674				": 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 the
 686	 * 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 callback
 702 */
 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 a
 721		 * process context (i.e. via schedule_work) because the tty
 722		 * 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 processing
 730				 * and mutex locking
 731				 */
 732				ipwireless_network_packet_received(
 733						hw->network,
 734						packet->channel_idx,
 735						(unsigned char *)packet
 736						+ 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 does
 745			 * not block
 746			 */
 747			handle_received_CTRL_packet(hw, packet->channel_idx,
 748					(unsigned char *)packet
 749					+ 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 longer
 755		 * 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_NAME
 775		       ": 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		else
 801			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	else
 825		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	else
 847		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_NAME
 866			       ": 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_NAME
 882			       ": 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 than
 918	 * PRIO_SETUP.  The network layer therefore need not care about
 919	 * hardware initialization - any of its stuff will simply be queued
 920	 * until setup is complete.
 921	 */
 922	return (hw->to_setup || hw->initializing
 923			? PRIO_SETUP + 1 : NL_NUM_OF_PRIORITIES);
 924}
 925
 926/*
 927 * return 1 if something has been received from hw
 928 */
 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 until
 951 * hardware is fully setup.
 952 *
 953 * return 1 if more packets can be sent
 954 */
 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(unsigned long hw_)
1010{
1011	struct ipw_hardware *hw = (struct ipw_hardware *) hw_;
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 hardware
1023		 */
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	else
1053		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_NAME
1128					": 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		} else
1135			return IRQ_NONE;
1136	}
1137
1138	/*
1139	 * See if the card is physically present. Note that while it is
1140	 * 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			} else
1159				/* Ignore 'Timer Recovery' duplicates. */
1160				rx_repeat = 1;
1161		} else {
1162			/*
1163			 * If a non-zero serial number is seen, then enable
1164			 * serial number checking.
1165			 */
1166			if (memtx_serial != 0) {
1167				hw->serial_number_detected = 1;
1168				printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
1169					": 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_NAME
1197					": spurious interrupt - new_tx mode\n");
1198			else {
1199				printk(KERN_WARNING IPWIRELESS_PCCARD_NAME
1200					": 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		} else
1206			printk(KERN_WARNING IPWIRELESS_PCCARD_NAME
1207					": 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	else
1222		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 every
1277	 * CTRL or SETUP packets, we can use ipw_control_packet as a
1278	 * common struct
1279	 */
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 unsigned char *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	else
1340		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	else
1351		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_NAME
1455					": 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_NAME
1464					": 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 translation
1471	 * 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_NAME
1492			": 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	else
1506		printk(KERN_ERR IPWIRELESS_PCCARD_NAME
1507				": 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_packet
1525	 */
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_NAME
1538		       ": 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_NAME
1554			       ": 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_NAME
1562			       ": 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_NAME
1568			       ": Setup not completed - ignoring reboot msg\n");
1569		else {
1570			struct ipw_setup_reboot_msg_ack *packet;
1571
1572			printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
1573			       ": 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_NAME
1580				       ": 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_NAME
1593		       ": 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_init(&hw->tasklet, ipwireless_do_tasklet, (unsigned long) hw);
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_NAME
1673	       ": 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_NAME
1687				": 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_NAME
1695		       ": 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 events
1764 * from it.
1765 */
1766void ipwireless_associate_network(struct ipw_hardware *hw,
1767				  struct ipw_network *network)
1768{
1769	hw->network = network;
1770}