Linux 2.6.31-rc6
[linux-2.6] / drivers / char / pcmcia / ipwireless / hardware.c
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
30 static void ipw_send_setup_packet(struct ipw_hardware *hw);
31 static void handle_received_SETUP_packet(struct ipw_hardware *ipw,
32                                          unsigned int address,
33                                          const unsigned char *data, int len,
34                                          int is_last);
35 static void ipwireless_setup_timer(unsigned long data);
36 static 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
43 static 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
52 static void start_timing(void)
53 {
54         timing_stats.start_time = jiffies;
55 }
56
57 static 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
64 static 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
71 static 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
96 static void start_timing(void) { }
97 static void end_read_timing(unsigned length) { }
98 static 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 */
115 enum {
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
134 struct 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
142 struct 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
153 union 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
194 struct 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
203 struct 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
228 struct 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  */
293 struct 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
322 struct 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
329 struct ipw_control_packet {
330         struct ipw_tx_packet header;
331         struct ipw_control_packet_body body;
332 };
333
334 struct 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
342 static 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
362 static 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
373 static 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
388 static 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
403 static 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
458 static 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
520 static 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  */
554 static 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
608 static 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
618 static 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 incomming 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 incomming 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  */
702 static 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
764 static 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
810 static 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
841 static 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  */
853 static 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
913 static 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  */
928 static 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  */
954 static 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  */
1008 static 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  */
1047 static 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
1056 static 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
1093 static 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
1101 static 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
1214 irqreturn_t ipwireless_interrupt(int irq, void *dev_id)
1215 {
1216         struct ipw_hardware *hw = dev_id;
1217
1218         if (hw->hw_version == HW_VERSION_1)
1219                 return ipwireless_handle_v1_interrupt(irq, hw);
1220         else
1221                 return ipwireless_handle_v2_v3_interrupt(irq, hw);
1222 }
1223
1224 static 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
1236 static 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 */
1250 static 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
1269 static 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
1293 int 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
1313 static 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
1333 static 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
1344 static 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
1355 int 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
1361 int 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
1367 struct ipw_setup_get_version_query_packet {
1368         struct ipw_tx_packet header;
1369         struct tl_setup_get_version_qry body;
1370 };
1371
1372 struct ipw_setup_config_packet {
1373         struct ipw_tx_packet header;
1374         struct tl_setup_config_msg body;
1375 };
1376
1377 struct ipw_setup_config_done_packet {
1378         struct ipw_tx_packet header;
1379         struct tl_setup_config_done_msg body;
1380 };
1381
1382 struct ipw_setup_open_packet {
1383         struct ipw_tx_packet header;
1384         struct tl_setup_open_msg body;
1385 };
1386
1387 struct ipw_setup_info_packet {
1388         struct ipw_tx_packet header;
1389         struct tl_setup_info_msg body;
1390 };
1391
1392 struct 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 */
1398 static 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
1489 exit_nomem:
1490         printk(KERN_ERR IPWIRELESS_PCCARD_NAME
1491                         ": not enough memory to alloc control packet\n");
1492         hw->to_setup = -1;
1493 }
1494
1495 static 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
1510 static 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
1526 static 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
1590 static 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
1609 struct 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
1638 void 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
1661 void 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
1670 static 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  */
1712 void 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
1724 void 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_scheduled_work();
1733
1734         for (i = 0; i < NL_NUM_OF_ADDRESSES; i++)
1735                 if (hw->packet_assembler[i] != NULL)
1736                         kfree(hw->packet_assembler[i]);
1737
1738         for (i = 0; i < NL_NUM_OF_PRIORITIES; i++)
1739                 list_for_each_entry_safe(tp, tq, &hw->tx_queue[i], queue) {
1740                         list_del(&tp->queue);
1741                         kfree(tp);
1742                 }
1743
1744         list_for_each_entry_safe(rp, rq, &hw->rx_queue, queue) {
1745                 list_del(&rp->queue);
1746                 kfree(rp);
1747         }
1748
1749         list_for_each_entry_safe(rp, rq, &hw->rx_pool, queue) {
1750                 list_del(&rp->queue);
1751                 kfree(rp);
1752         }
1753         kfree(hw);
1754 }
1755
1756 /*
1757  * Associate the specified network with this hardware, so it will receive events
1758  * from it.
1759  */
1760 void ipwireless_associate_network(struct ipw_hardware *hw,
1761                                   struct ipw_network *network)
1762 {
1763         hw->network = network;
1764 }