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