drivers/tty/ipwireless/hardware.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
start_timing
end_read_timing
end_write_timing
report_timing
start_timing
end_read_timing
end_write_timing
data_type
dump_data_bytes
swap_packet_bitfield_to_le
swap_packet_bitfield_from_le
do_send_fragment
do_send_packet
ipw_setup_hardware
pool_allocate
pool_free
queue_received_packet
ipw_receive_data_work
handle_received_CTRL_packet
handle_received_packet
acknowledge_data_read
do_receive_packet
get_current_packet_priority
get_packets_from_hw
send_pending_packet
ipwireless_do_tasklet
is_card_present
ipwireless_handle_v1_interrupt
acknowledge_pcmcia_interrupt
ipwireless_handle_v2_v3_interrupt
ipwireless_interrupt
flush_packets_to_hw
send_packet
alloc_data_packet
alloc_ctrl_packet
ipwireless_send_packet
set_control_line
set_DTR
set_RTS
ipwireless_set_DTR
ipwireless_set_RTS
__handle_setup_get_version_rsp
handle_setup_get_version_rsp
ipw_send_setup_packet
handle_received_SETUP_packet
do_close_hardware
ipwireless_hardware_create
ipwireless_init_hardware_v1
ipwireless_init_hardware_v2_v3
ipwireless_setup_timer
ipwireless_stop_interrupts
ipwireless_hardware_free
ipwireless_associate_network
   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 
  31 static void ipw_send_setup_packet(struct ipw_hardware *hw);
  32 static void handle_received_SETUP_packet(struct ipw_hardware *ipw,
  33                                          unsigned int address,
  34                                          const unsigned char *data, int len,
  35                                          int is_last);
  36 static void ipwireless_setup_timer(struct timer_list *t);
  37 static 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 
  44 static 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 
  53 static void start_timing(void)
  54 {
  55         timing_stats.start_time = jiffies;
  56 }
  57 
  58 static 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 
  65 static 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 
  72 static 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
  97 static void start_timing(void) { }
  98 static void end_read_timing(unsigned length) { }
  99 static 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 */
 116 enum {
 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 
 135 struct 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 
 143 struct 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 
 154 union 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 
 195 struct 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 
 204 struct 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 
 229 struct 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  */
 294 struct 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 
 323 struct 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 
 330 struct ipw_control_packet {
 331         struct ipw_tx_packet header;
 332         struct ipw_control_packet_body body;
 333 };
 334 
 335 struct 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 
 343 static 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 
 363 static 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 
 374 static 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 
 389 static 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 
 404 static 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 
 459 static 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 
 521 static 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  */
 555 static 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 
 609 static 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 
 619 static 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  */
 703 static 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 
 765 static 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 
 811 static 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 
 842 static 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  */
 854 static 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 
 914 static 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  */
 929 static 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  */
 955 static 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  */
1009 static 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  */
1048 static 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 
1057 static 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 
1094 static 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 
1102 static 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 
1215 irqreturn_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 
1225 static 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 
1237 static 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 */
1251 static 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 
1270 static 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 
1294 int 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 
1314 static 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 
1334 static 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 
1345 static 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 
1356 int 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 
1362 int 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 
1368 struct ipw_setup_get_version_query_packet {
1369         struct ipw_tx_packet header;
1370         struct tl_setup_get_version_qry body;
1371 };
1372 
1373 struct ipw_setup_config_packet {
1374         struct ipw_tx_packet header;
1375         struct tl_setup_config_msg body;
1376 };
1377 
1378 struct ipw_setup_config_done_packet {
1379         struct ipw_tx_packet header;
1380         struct tl_setup_config_done_msg body;
1381 };
1382 
1383 struct ipw_setup_open_packet {
1384         struct ipw_tx_packet header;
1385         struct tl_setup_open_msg body;
1386 };
1387 
1388 struct ipw_setup_info_packet {
1389         struct ipw_tx_packet header;
1390         struct tl_setup_info_msg body;
1391 };
1392 
1393 struct 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 */
1399 static 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 
1490 exit_nomem:
1491         printk(KERN_ERR IPWIRELESS_PCCARD_NAME
1492                         ": not enough memory to alloc control packet\n");
1493         hw->to_setup = -1;
1494 }
1495 
1496 static 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 
1511 static 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 
1529 static 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 
1598 static 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 
1617 struct 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 
1645 void 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 
1668 void 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 
1677 static 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  */
1719 void 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 
1731 void 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  */
1766 void ipwireless_associate_network(struct ipw_hardware *hw,
1767                                   struct ipw_network *network)
1768 {
1769         hw->network = network;
1770 }
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/tty/ipwireless/hardware.c

DEFINITIONS
