2 * IPWireless 3G PCMCIA Network Driver
5 * by Stephen Blackheath <stephen@blacksapphire.com>,
6 * Ben Martel <benm@symmetric.co.nz>
8 * Copyrighted as follows:
9 * Copyright (C) 2004 by Symmetric Systems Ltd (NZ)
11 * Various driver changes and rewrites, port to new kernels
12 * Copyright (C) 2006-2007 Jiri Kosina
14 * Misc code cleanups and updates
15 * Copyright (C) 2007 David Sterba
18 #include <linux/interrupt.h>
20 #include <linux/irq.h>
21 #include <linux/kernel.h>
22 #include <linux/list.h>
23 #include <linux/slab.h>
26 #include "setup_protocol.h"
30 static void ipw_send_setup_packet(struct ipw_hardware
*hw
);
31 static void handle_received_SETUP_packet(struct ipw_hardware
*ipw
,
33 unsigned char *data
, int len
,
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
, unsigned char *data
, int len
);
39 /*#define TIMING_DIAGNOSTICS*/
41 #ifdef TIMING_DIAGNOSTICS
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
;
52 static void start_timing(void)
54 timing_stats
.start_time
= jiffies
;
57 static void end_read_timing(unsigned length
)
59 timing_stats
.read_time
+= (jiffies
- start_time
);
60 timing_stats
.read_bytes
+= length
+ 2;
64 static void end_write_timing(unsigned length
)
66 timing_stats
.write_time
+= (jiffies
- start_time
);
67 timing_stats
.write_bytes
+= length
+ 2;
71 static void report_timing(void)
73 unsigned long since
= jiffies
- timing_stats
.last_report_time
;
75 /* If it's been more than one second... */
77 int first
= (timing_stats
.last_report_time
== 0);
79 timing_stats
.last_report_time
= jiffies
;
81 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
82 ": %u us elapsed - read %lu bytes in %u us, "
83 "wrote %lu bytes in %u us\n",
84 jiffies_to_usecs(since
),
85 timing_stats
.read_bytes
,
86 jiffies_to_usecs(timing_stats
.read_time
),
87 timing_stats
.write_bytes
,
88 jiffies_to_usecs(timing_stats
.write_time
));
90 timing_stats
.read_time
= 0;
91 timing_stats
.write_time
= 0;
92 timing_stats
.read_bytes
= 0;
93 timing_stats
.write_bytes
= 0;
97 static void start_timing(void) { }
98 static void end_read_timing(unsigned length
) { }
99 static void end_write_timing(unsigned length
) { }
102 /* Imported IPW definitions */
104 #define LL_MTU_V1 318
105 #define LL_MTU_V2 250
106 #define LL_MTU_MAX (LL_MTU_V1 > LL_MTU_V2 ? LL_MTU_V1 : LL_MTU_V2)
113 #define ADDR_SETUP_PROT 0
117 /* Identifier for the Com Data protocol */
118 TL_PROTOCOLID_COM_DATA
= 0,
120 /* Identifier for the Com Control protocol */
121 TL_PROTOCOLID_COM_CTRL
= 1,
123 /* Identifier for the Setup protocol */
124 TL_PROTOCOLID_SETUP
= 2
127 /* Number of bytes in NL packet header (cannot do
128 * sizeof(nl_packet_header) since it's a bitfield) */
129 #define NL_FIRST_PACKET_HEADER_SIZE 3
131 /* Number of bytes in NL packet header (cannot do
132 * sizeof(nl_packet_header) since it's a bitfield) */
133 #define NL_FOLLOWING_PACKET_HEADER_SIZE 1
135 struct nl_first_packet_header
{
136 #if defined(__BIG_ENDIAN_BITFIELD)
137 unsigned char packet_rank
:2;
138 unsigned char address
:3;
139 unsigned char protocol
:3;
141 unsigned char protocol
:3;
142 unsigned char address
:3;
143 unsigned char packet_rank
:2;
145 unsigned char length_lsb
;
146 unsigned char length_msb
;
149 struct nl_packet_header
{
150 #if defined(__BIG_ENDIAN_BITFIELD)
151 unsigned char packet_rank
:2;
152 unsigned char address
:3;
153 unsigned char protocol
:3;
155 unsigned char protocol
:3;
156 unsigned char address
:3;
157 unsigned char packet_rank
:2;
161 /* Value of 'packet_rank' above */
162 #define NL_INTERMEDIATE_PACKET 0x0
163 #define NL_LAST_PACKET 0x1
164 #define NL_FIRST_PACKET 0x2
167 /* Network packet header of the first packet (a special case) */
168 struct nl_first_packet_header hdr_first
;
169 /* Network packet header of the following packets (if any) */
170 struct nl_packet_header hdr
;
171 /* Complete network packet (header + data) */
172 unsigned char rawpkt
[LL_MTU_MAX
];
173 } __attribute__ ((__packed__
));
175 #define HW_VERSION_UNKNOWN -1
176 #define HW_VERSION_1 1
177 #define HW_VERSION_2 2
180 #define IOIER 0x00 /* Interrupt Enable Register */
181 #define IOIR 0x02 /* Interrupt Source/ACK register */
182 #define IODCR 0x04 /* Data Control Register */
183 #define IODRR 0x06 /* Data Read Register */
184 #define IODWR 0x08 /* Data Write Register */
185 #define IOESR 0x0A /* Embedded Driver Status Register */
186 #define IORXR 0x0C /* Rx Fifo Register (Host to Embedded) */
187 #define IOTXR 0x0E /* Tx Fifo Register (Embedded to Host) */
189 /* I/O ports and bit definitions for version 1 of the hardware */
192 #define IER_RXENABLED 0x1
193 #define IER_TXENABLED 0x2
196 #define IR_RXINTR 0x1
197 #define IR_TXINTR 0x2
200 #define DCR_RXDONE 0x1
201 #define DCR_TXDONE 0x2
202 #define DCR_RXRESET 0x4
203 #define DCR_TXRESET 0x8
205 /* I/O ports and bit definitions for version 2 of the hardware */
208 unsigned short reg_config_option
; /* PCCOR: Configuration Option Register */
209 unsigned short reg_config_and_status
; /* PCCSR: Configuration and Status Register */
210 unsigned short reg_pin_replacement
; /* PCPRR: Pin Replacemant Register */
211 unsigned short reg_socket_and_copy
; /* PCSCR: Socket and Copy Register */
212 unsigned short reg_ext_status
; /* PCESR: Extendend Status Register */
213 unsigned short reg_io_base
; /* PCIOB: I/O Base Register */
217 unsigned short memreg_tx_old
; /* TX Register (R/W) */
219 unsigned short memreg_rx_done
; /* RXDone Register (R/W) */
221 unsigned short memreg_rx
; /* RX Register (R/W) */
223 unsigned short memreg_pc_interrupt_ack
; /* PC intr Ack Register (W) */
225 unsigned long memreg_card_present
;/* Mask for Host to check (R) for
226 * CARD_PRESENT_VALUE */
227 unsigned short memreg_tx_new
; /* TX2 (new) Register (R/W) */
230 #define IODMADPR 0x00 /* DMA Data Port Register (R/W) */
232 #define CARD_PRESENT_VALUE (0xBEEFCAFEUL)
234 #define MEMTX_TX 0x0001
235 #define MEMRX_RX 0x0001
236 #define MEMRX_RX_DONE 0x0001
237 #define MEMRX_PCINTACKK 0x0001
238 #define MEMRX_MEMSPURIOUSINT 0x0001
240 #define NL_NUM_OF_PRIORITIES 3
241 #define NL_NUM_OF_PROTOCOLS 3
242 #define NL_NUM_OF_ADDRESSES NO_OF_IPW_CHANNELS
244 struct ipw_hardware
{
245 unsigned int base_port
;
247 unsigned short ll_mtu
;
252 struct timer_list setup_timer
;
254 /* Flag if hw is ready to send next packet */
256 /* Count of pending packets to be sent */
258 struct list_head tx_queue
[NL_NUM_OF_PRIORITIES
];
261 struct list_head rx_queue
;
262 /* Pool of rx_packet structures that are not currently used. */
263 struct list_head rx_pool
;
265 /* True if reception of data is blocked while userspace processes it. */
267 /* True if there is RX data ready on the hardware. */
269 unsigned short last_memtx_serial
;
271 * Newer versions of the V2 card firmware send serial numbers in the
272 * MemTX register. 'serial_number_detected' is set true when we detect
273 * a non-zero serial number (indicating the new firmware). Thereafter,
274 * the driver can safely ignore the Timer Recovery re-sends to avoid
275 * out-of-sync problems.
277 int serial_number_detected
;
278 struct work_struct work_rx
;
280 /* True if we are to send the set-up data to the hardware. */
283 /* Card has been removed */
285 /* Saved irq value when we disable the interrupt. */
287 /* True if this driver is shutting down. */
289 /* Modem control lines */
290 unsigned int control_lines
[NL_NUM_OF_ADDRESSES
];
291 struct ipw_rx_packet
*packet_assembler
[NL_NUM_OF_ADDRESSES
];
293 struct tasklet_struct tasklet
;
295 /* The handle for the network layer, for the sending of events to it. */
296 struct ipw_network
*network
;
297 struct MEMINFREG __iomem
*memory_info_regs
;
298 struct MEMCCR __iomem
*memregs_CCR
;
299 void (*reboot_callback
) (void *data
);
300 void *reboot_callback_data
;
302 unsigned short __iomem
*memreg_tx
;
306 * Packet info structure for tx packets.
307 * Note: not all the fields defined here are required for all protocols
309 struct ipw_tx_packet
{
310 struct list_head queue
;
311 /* channel idx + 1 */
312 unsigned char dest_addr
;
313 /* SETUP, CTRL or DATA */
314 unsigned char protocol
;
315 /* Length of data block, which starts at the end of this structure */
316 unsigned short length
;
318 /* Offset of where we've sent up to so far */
319 unsigned long offset
;
320 /* Count of packet fragments, starting at 0 */
323 /* Called after packet is sent and before is freed */
324 void (*packet_callback
) (void *cb_data
, unsigned int packet_length
);
328 /* Signals from DTE */
329 #define COMCTRL_RTS 0
330 #define COMCTRL_DTR 1
332 /* Signals from DCE */
333 #define COMCTRL_CTS 2
334 #define COMCTRL_DCD 3
335 #define COMCTRL_DSR 4
338 struct ipw_control_packet_body
{
339 /* DTE signal or DCE signal */
340 unsigned char sig_no
;
341 /* 0: set signal, 1: clear signal */
343 } __attribute__ ((__packed__
));
345 struct ipw_control_packet
{
346 struct ipw_tx_packet header
;
347 struct ipw_control_packet_body body
;
350 struct ipw_rx_packet
{
351 struct list_head queue
;
352 unsigned int capacity
;
354 unsigned int protocol
;
355 unsigned int channel_idx
;
358 static char *data_type(const unsigned char *buf
, unsigned length
)
360 struct nl_packet_header
*hdr
= (struct nl_packet_header
*) buf
;
365 if (hdr
->packet_rank
& NL_FIRST_PACKET
) {
366 switch (hdr
->protocol
) {
367 case TL_PROTOCOLID_COM_DATA
: return "DATA ";
368 case TL_PROTOCOLID_COM_CTRL
: return "CTRL ";
369 case TL_PROTOCOLID_SETUP
: return "SETUP";
370 default: return "???? ";
376 #define DUMP_MAX_BYTES 64
378 static void dump_data_bytes(const char *type
, const unsigned char *data
,
383 sprintf(prefix
, IPWIRELESS_PCCARD_NAME
": %s %s ",
384 type
, data_type(data
, length
));
385 print_hex_dump_bytes(prefix
, 0, (void *)data
,
386 length
< DUMP_MAX_BYTES
? length
: DUMP_MAX_BYTES
);
389 static int do_send_fragment(struct ipw_hardware
*hw
, const unsigned char *data
,
400 if (length
> hw
->ll_mtu
)
403 if (ipwireless_debug
)
404 dump_data_bytes("send", data
, length
);
406 spin_lock_irqsave(&hw
->spinlock
, flags
);
410 if (hw
->hw_version
== HW_VERSION_1
) {
411 outw((unsigned short) length
, hw
->base_port
+ IODWR
);
413 for (i
= 0; i
< length
; i
+= 2) {
414 unsigned short d
= data
[i
];
418 d
|= data
[i
+ 1] << 8;
419 raw_data
= cpu_to_le16(d
);
420 outw(raw_data
, hw
->base_port
+ IODWR
);
423 outw(DCR_TXDONE
, hw
->base_port
+ IODCR
);
424 } else if (hw
->hw_version
== HW_VERSION_2
) {
425 outw((unsigned short) length
, hw
->base_port
+ IODMADPR
);
427 for (i
= 0; i
< length
; i
+= 2) {
428 unsigned short d
= data
[i
];
432 d
|= data
[i
+ 1] << 8;
433 raw_data
= cpu_to_le16(d
);
434 outw(raw_data
, hw
->base_port
+ IODMADPR
);
436 while ((i
& 3) != 2) {
437 outw((unsigned short) 0xDEAD, hw
->base_port
+ IODMADPR
);
440 writew(MEMRX_RX
, &hw
->memory_info_regs
->memreg_rx
);
443 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
445 end_write_timing(length
);
450 static int do_send_packet(struct ipw_hardware
*hw
, struct ipw_tx_packet
*packet
)
452 unsigned short fragment_data_len
;
453 unsigned short data_left
= packet
->length
- packet
->offset
;
454 unsigned short header_size
;
458 (packet
->fragment_count
== 0)
459 ? NL_FIRST_PACKET_HEADER_SIZE
460 : NL_FOLLOWING_PACKET_HEADER_SIZE
;
461 fragment_data_len
= hw
->ll_mtu
- header_size
;
462 if (data_left
< fragment_data_len
)
463 fragment_data_len
= data_left
;
465 pkt
.hdr_first
.protocol
= packet
->protocol
;
466 pkt
.hdr_first
.address
= packet
->dest_addr
;
467 pkt
.hdr_first
.packet_rank
= 0;
470 if (packet
->fragment_count
== 0) {
471 pkt
.hdr_first
.packet_rank
|= NL_FIRST_PACKET
;
472 pkt
.hdr_first
.length_lsb
= (unsigned char) packet
->length
;
473 pkt
.hdr_first
.length_msb
=
474 (unsigned char) (packet
->length
>> 8);
477 memcpy(pkt
.rawpkt
+ header_size
,
478 ((unsigned char *) packet
) + sizeof(struct ipw_tx_packet
) +
479 packet
->offset
, fragment_data_len
);
480 packet
->offset
+= fragment_data_len
;
481 packet
->fragment_count
++;
483 /* Last packet? (May also be first packet.) */
484 if (packet
->offset
== packet
->length
)
485 pkt
.hdr_first
.packet_rank
|= NL_LAST_PACKET
;
486 do_send_fragment(hw
, pkt
.rawpkt
, header_size
+ fragment_data_len
);
488 /* If this packet has unsent data, then re-queue it. */
489 if (packet
->offset
< packet
->length
) {
491 * Re-queue it at the head of the highest priority queue so
492 * it goes before all other packets
496 spin_lock_irqsave(&hw
->spinlock
, flags
);
497 list_add(&packet
->queue
, &hw
->tx_queue
[0]);
499 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
501 if (packet
->packet_callback
)
502 packet
->packet_callback(packet
->callback_data
,
510 static void ipw_setup_hardware(struct ipw_hardware
*hw
)
514 spin_lock_irqsave(&hw
->spinlock
, flags
);
515 if (hw
->hw_version
== HW_VERSION_1
) {
517 outw(DCR_RXRESET
, hw
->base_port
+ IODCR
);
518 /* SB: Reset TX FIFO */
519 outw(DCR_TXRESET
, hw
->base_port
+ IODCR
);
521 /* Enable TX and RX interrupts. */
522 outw(IER_TXENABLED
| IER_RXENABLED
, hw
->base_port
+ IOIER
);
525 * Set INTRACK bit (bit 0), which means we must explicitly
526 * acknowledge interrupts by clearing bit 2 of reg_config_and_status.
528 unsigned short csr
= readw(&hw
->memregs_CCR
->reg_config_and_status
);
531 writew(csr
, &hw
->memregs_CCR
->reg_config_and_status
);
533 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
537 * If 'packet' is NULL, then this function allocates a new packet, setting its
538 * length to 0 and ensuring it has the specified minimum amount of free space.
540 * If 'packet' is not NULL, then this function enlarges it if it doesn't
541 * have the specified minimum amount of free space.
544 static struct ipw_rx_packet
*pool_allocate(struct ipw_hardware
*hw
,
545 struct ipw_rx_packet
*packet
,
546 int minimum_free_space
)
552 spin_lock_irqsave(&hw
->spinlock
, flags
);
553 if (!list_empty(&hw
->rx_pool
)) {
554 packet
= list_first_entry(&hw
->rx_pool
,
555 struct ipw_rx_packet
, queue
);
556 list_del(&packet
->queue
);
558 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
560 static int min_capacity
= 256;
563 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
565 (minimum_free_space
> min_capacity
568 packet
= kmalloc(sizeof(struct ipw_rx_packet
)
569 + new_capacity
, GFP_ATOMIC
);
572 packet
->capacity
= new_capacity
;
577 if (packet
->length
+ minimum_free_space
> packet
->capacity
) {
578 struct ipw_rx_packet
*old_packet
= packet
;
580 packet
= kmalloc(sizeof(struct ipw_rx_packet
) +
581 old_packet
->length
+ minimum_free_space
,
587 memcpy(packet
, old_packet
,
588 sizeof(struct ipw_rx_packet
)
589 + old_packet
->length
);
590 packet
->capacity
= old_packet
->length
+ minimum_free_space
;
597 static void pool_free(struct ipw_hardware
*hw
, struct ipw_rx_packet
*packet
)
599 if (hw
->rx_pool_size
> 6)
603 list_add_tail(&packet
->queue
, &hw
->rx_pool
);
607 static void queue_received_packet(struct ipw_hardware
*hw
,
608 unsigned int protocol
, unsigned int address
,
609 unsigned char *data
, int length
, int is_last
)
611 unsigned int channel_idx
= address
- 1;
612 struct ipw_rx_packet
*packet
= NULL
;
615 /* Discard packet if channel index is out of range. */
616 if (channel_idx
>= NL_NUM_OF_ADDRESSES
) {
617 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
618 ": data packet has bad address %u\n", address
);
623 * ->packet_assembler is safe to touch unlocked, this is the only place
625 if (protocol
== TL_PROTOCOLID_COM_DATA
) {
626 struct ipw_rx_packet
**assem
=
627 &hw
->packet_assembler
[channel_idx
];
630 * Create a new packet, or assembler already contains one
631 * enlarge it by 'length' bytes.
633 (*assem
) = pool_allocate(hw
, *assem
, length
);
635 printk(KERN_ERR IPWIRELESS_PCCARD_NAME
636 ": no memory for incomming data packet, dropped!\n");
639 (*assem
)->protocol
= protocol
;
640 (*assem
)->channel_idx
= channel_idx
;
642 /* Append this packet data onto existing data. */
643 memcpy((unsigned char *)(*assem
) +
644 sizeof(struct ipw_rx_packet
)
645 + (*assem
)->length
, data
, length
);
646 (*assem
)->length
+= length
;
650 /* Count queued DATA bytes only */
651 spin_lock_irqsave(&hw
->spinlock
, flags
);
652 hw
->rx_bytes_queued
+= packet
->length
;
653 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
656 /* If it's a CTRL packet, don't assemble, just queue it. */
657 packet
= pool_allocate(hw
, NULL
, length
);
659 printk(KERN_ERR IPWIRELESS_PCCARD_NAME
660 ": no memory for incomming ctrl packet, dropped!\n");
663 packet
->protocol
= protocol
;
664 packet
->channel_idx
= channel_idx
;
665 memcpy((unsigned char *)packet
+ sizeof(struct ipw_rx_packet
),
667 packet
->length
= length
;
671 * If this is the last packet, then send the assembled packet on to the
675 spin_lock_irqsave(&hw
->spinlock
, flags
);
676 list_add_tail(&packet
->queue
, &hw
->rx_queue
);
677 /* Block reception of incoming packets if queue is full. */
679 (hw
->rx_bytes_queued
>= IPWIRELESS_RX_QUEUE_SIZE
);
681 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
682 schedule_work(&hw
->work_rx
);
689 static void ipw_receive_data_work(struct work_struct
*work_rx
)
691 struct ipw_hardware
*hw
=
692 container_of(work_rx
, struct ipw_hardware
, work_rx
);
695 spin_lock_irqsave(&hw
->spinlock
, flags
);
696 while (!list_empty(&hw
->rx_queue
)) {
697 struct ipw_rx_packet
*packet
=
698 list_first_entry(&hw
->rx_queue
,
699 struct ipw_rx_packet
, queue
);
701 if (hw
->shutting_down
)
703 list_del(&packet
->queue
);
706 * Note: ipwireless_network_packet_received must be called in a
707 * process context (i.e. via schedule_work) because the tty
708 * output code can sleep in the tty_flip_buffer_push call.
710 if (packet
->protocol
== TL_PROTOCOLID_COM_DATA
) {
711 if (hw
->network
!= NULL
) {
712 /* If the network hasn't been disconnected. */
713 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
715 * This must run unlocked due to tty processing
718 ipwireless_network_packet_received(
721 (unsigned char *)packet
722 + sizeof(struct ipw_rx_packet
),
724 spin_lock_irqsave(&hw
->spinlock
, flags
);
726 /* Count queued DATA bytes only */
727 hw
->rx_bytes_queued
-= packet
->length
;
730 * This is safe to be called locked, callchain does
733 handle_received_CTRL_packet(hw
, packet
->channel_idx
,
734 (unsigned char *)packet
735 + sizeof(struct ipw_rx_packet
),
738 pool_free(hw
, packet
);
740 * Unblock reception of incoming packets if queue is no longer
744 hw
->rx_bytes_queued
>= IPWIRELESS_RX_QUEUE_SIZE
;
745 if (hw
->shutting_down
)
748 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
751 static void handle_received_CTRL_packet(struct ipw_hardware
*hw
,
752 unsigned int channel_idx
,
753 unsigned char *data
, int len
)
755 struct ipw_control_packet_body
*body
=
756 (struct ipw_control_packet_body
*) data
;
757 unsigned int changed_mask
;
759 if (len
!= sizeof(struct ipw_control_packet_body
)) {
760 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
761 ": control packet was %d bytes - wrong size!\n",
766 switch (body
->sig_no
) {
768 changed_mask
= IPW_CONTROL_LINE_CTS
;
771 changed_mask
= IPW_CONTROL_LINE_DCD
;
774 changed_mask
= IPW_CONTROL_LINE_DSR
;
777 changed_mask
= IPW_CONTROL_LINE_RI
;
783 if (changed_mask
!= 0) {
785 hw
->control_lines
[channel_idx
] |= changed_mask
;
787 hw
->control_lines
[channel_idx
] &= ~changed_mask
;
789 ipwireless_network_notify_control_line_change(
792 hw
->control_lines
[channel_idx
],
797 static void handle_received_packet(struct ipw_hardware
*hw
,
798 union nl_packet
*packet
,
801 unsigned int protocol
= packet
->hdr
.protocol
;
802 unsigned int address
= packet
->hdr
.address
;
803 unsigned int header_length
;
805 unsigned int data_len
;
806 int is_last
= packet
->hdr
.packet_rank
& NL_LAST_PACKET
;
808 if (packet
->hdr
.packet_rank
& NL_FIRST_PACKET
)
809 header_length
= NL_FIRST_PACKET_HEADER_SIZE
;
811 header_length
= NL_FOLLOWING_PACKET_HEADER_SIZE
;
813 data
= packet
->rawpkt
+ header_length
;
814 data_len
= len
- header_length
;
816 case TL_PROTOCOLID_COM_DATA
:
817 case TL_PROTOCOLID_COM_CTRL
:
818 queue_received_packet(hw
, protocol
, address
, data
, data_len
,
821 case TL_PROTOCOLID_SETUP
:
822 handle_received_SETUP_packet(hw
, address
, data
, data_len
,
828 static void acknowledge_data_read(struct ipw_hardware
*hw
)
830 if (hw
->hw_version
== HW_VERSION_1
)
831 outw(DCR_RXDONE
, hw
->base_port
+ IODCR
);
833 writew(MEMRX_PCINTACKK
,
834 &hw
->memory_info_regs
->memreg_pc_interrupt_ack
);
838 * Retrieve a packet from the IPW hardware.
840 static void do_receive_packet(struct ipw_hardware
*hw
)
844 unsigned char pkt
[LL_MTU_MAX
];
848 if (hw
->hw_version
== HW_VERSION_1
) {
849 len
= inw(hw
->base_port
+ IODRR
);
850 if (len
> hw
->ll_mtu
) {
851 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
852 ": received a packet of %u bytes - "
853 "longer than the MTU!\n", len
);
854 outw(DCR_RXDONE
| DCR_RXRESET
, hw
->base_port
+ IODCR
);
858 for (i
= 0; i
< len
; i
+= 2) {
859 __le16 raw_data
= inw(hw
->base_port
+ IODRR
);
860 unsigned short data
= le16_to_cpu(raw_data
);
862 pkt
[i
] = (unsigned char) data
;
863 pkt
[i
+ 1] = (unsigned char) (data
>> 8);
866 len
= inw(hw
->base_port
+ IODMADPR
);
867 if (len
> hw
->ll_mtu
) {
868 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
869 ": received a packet of %u bytes - "
870 "longer than the MTU!\n", len
);
871 writew(MEMRX_PCINTACKK
,
872 &hw
->memory_info_regs
->memreg_pc_interrupt_ack
);
876 for (i
= 0; i
< len
; i
+= 2) {
877 __le16 raw_data
= inw(hw
->base_port
+ IODMADPR
);
878 unsigned short data
= le16_to_cpu(raw_data
);
880 pkt
[i
] = (unsigned char) data
;
881 pkt
[i
+ 1] = (unsigned char) (data
>> 8);
884 while ((i
& 3) != 2) {
885 inw(hw
->base_port
+ IODMADPR
);
890 acknowledge_data_read(hw
);
892 if (ipwireless_debug
)
893 dump_data_bytes("recv", pkt
, len
);
895 handle_received_packet(hw
, (union nl_packet
*) pkt
, len
);
897 end_read_timing(len
);
900 static int get_current_packet_priority(struct ipw_hardware
*hw
)
903 * If we're initializing, don't send anything of higher priority than
904 * PRIO_SETUP. The network layer therefore need not care about
905 * hardware initialization - any of its stuff will simply be queued
906 * until setup is complete.
908 return (hw
->to_setup
|| hw
->initializing
909 ? PRIO_SETUP
+ 1 : NL_NUM_OF_PRIORITIES
);
913 * return 1 if something has been received from hw
915 static int get_packets_from_hw(struct ipw_hardware
*hw
)
920 spin_lock_irqsave(&hw
->spinlock
, flags
);
921 while (hw
->rx_ready
&& !hw
->blocking_rx
) {
924 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
926 do_receive_packet(hw
);
928 spin_lock_irqsave(&hw
->spinlock
, flags
);
930 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
936 * Send pending packet up to given priority, prioritize SETUP data until
937 * hardware is fully setup.
939 * return 1 if more packets can be sent
941 static int send_pending_packet(struct ipw_hardware
*hw
, int priority_limit
)
943 int more_to_send
= 0;
946 spin_lock_irqsave(&hw
->spinlock
, flags
);
947 if (hw
->tx_queued
&& hw
->tx_ready
) {
949 struct ipw_tx_packet
*packet
= NULL
;
952 for (priority
= 0; priority
< priority_limit
; priority
++) {
953 if (!list_empty(&hw
->tx_queue
[priority
])) {
954 packet
= list_first_entry(
955 &hw
->tx_queue
[priority
],
956 struct ipw_tx_packet
,
960 list_del(&packet
->queue
);
967 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
971 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
974 do_send_packet(hw
, packet
);
976 /* Check if more to send */
977 spin_lock_irqsave(&hw
->spinlock
, flags
);
978 for (priority
= 0; priority
< priority_limit
; priority
++)
979 if (!list_empty(&hw
->tx_queue
[priority
])) {
987 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
993 * Send and receive all queued packets.
995 static void ipwireless_do_tasklet(unsigned long hw_
)
997 struct ipw_hardware
*hw
= (struct ipw_hardware
*) hw_
;
1000 spin_lock_irqsave(&hw
->spinlock
, flags
);
1001 if (hw
->shutting_down
) {
1002 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
1006 if (hw
->to_setup
== 1) {
1008 * Initial setup data sent to hardware
1011 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
1013 ipw_setup_hardware(hw
);
1014 ipw_send_setup_packet(hw
);
1016 send_pending_packet(hw
, PRIO_SETUP
+ 1);
1017 get_packets_from_hw(hw
);
1019 int priority_limit
= get_current_packet_priority(hw
);
1022 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
1025 again
= send_pending_packet(hw
, priority_limit
);
1026 again
|= get_packets_from_hw(hw
);
1032 * return true if the card is physically present.
1034 static int is_card_present(struct ipw_hardware
*hw
)
1036 if (hw
->hw_version
== HW_VERSION_1
)
1037 return inw(hw
->base_port
+ IOIR
) != 0xFFFF;
1039 return readl(&hw
->memory_info_regs
->memreg_card_present
) ==
1043 static irqreturn_t
ipwireless_handle_v1_interrupt(int irq
,
1044 struct ipw_hardware
*hw
)
1046 unsigned short irqn
;
1048 irqn
= inw(hw
->base_port
+ IOIR
);
1050 /* Check if card is present */
1053 else if (irqn
!= 0) {
1054 unsigned short ack
= 0;
1055 unsigned long flags
;
1057 /* Transmit complete. */
1058 if (irqn
& IR_TXINTR
) {
1060 spin_lock_irqsave(&hw
->spinlock
, flags
);
1062 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
1065 if (irqn
& IR_RXINTR
) {
1067 spin_lock_irqsave(&hw
->spinlock
, flags
);
1069 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
1072 outw(ack
, hw
->base_port
+ IOIR
);
1073 tasklet_schedule(&hw
->tasklet
);
1080 static void acknowledge_pcmcia_interrupt(struct ipw_hardware
*hw
)
1082 unsigned short csr
= readw(&hw
->memregs_CCR
->reg_config_and_status
);
1085 writew(csr
, &hw
->memregs_CCR
->reg_config_and_status
);
1088 static irqreturn_t
ipwireless_handle_v2_v3_interrupt(int irq
,
1089 struct ipw_hardware
*hw
)
1095 unsigned long flags
;
1099 unsigned short memtx
= readw(hw
->memreg_tx
);
1100 unsigned short memtx_serial
;
1101 unsigned short memrxdone
=
1102 readw(&hw
->memory_info_regs
->memreg_rx_done
);
1106 /* check whether the interrupt was generated by ipwireless card */
1107 if (!(memtx
& MEMTX_TX
) && !(memrxdone
& MEMRX_RX_DONE
)) {
1109 /* check if the card uses memreg_tx_old register */
1110 if (hw
->memreg_tx
== &hw
->memory_info_regs
->memreg_tx_new
) {
1111 memtx
= readw(&hw
->memory_info_regs
->memreg_tx_old
);
1112 if (memtx
& MEMTX_TX
) {
1113 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
1114 ": Using memreg_tx_old\n");
1116 &hw
->memory_info_regs
->memreg_tx_old
;
1125 * See if the card is physically present. Note that while it is
1126 * powering up, it appears not to be present.
1128 if (!is_card_present(hw
)) {
1129 acknowledge_pcmcia_interrupt(hw
);
1133 memtx_serial
= memtx
& (unsigned short) 0xff00;
1134 if (memtx
& MEMTX_TX
) {
1135 writew(memtx_serial
, hw
->memreg_tx
);
1137 if (hw
->serial_number_detected
) {
1138 if (memtx_serial
!= hw
->last_memtx_serial
) {
1139 hw
->last_memtx_serial
= memtx_serial
;
1140 spin_lock_irqsave(&hw
->spinlock
, flags
);
1142 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
1145 /* Ignore 'Timer Recovery' duplicates. */
1149 * If a non-zero serial number is seen, then enable
1150 * serial number checking.
1152 if (memtx_serial
!= 0) {
1153 hw
->serial_number_detected
= 1;
1154 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
1155 ": memreg_tx serial num detected\n");
1157 spin_lock_irqsave(&hw
->spinlock
, flags
);
1159 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
1164 if (memrxdone
& MEMRX_RX_DONE
) {
1165 writew(0, &hw
->memory_info_regs
->memreg_rx_done
);
1166 spin_lock_irqsave(&hw
->spinlock
, flags
);
1168 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
1172 writew(MEMRX_PCINTACKK
,
1173 &hw
->memory_info_regs
->memreg_pc_interrupt_ack
);
1175 acknowledge_pcmcia_interrupt(hw
);
1178 tasklet_schedule(&hw
->tasklet
);
1179 else if (!rx_repeat
) {
1180 if (hw
->memreg_tx
== &hw
->memory_info_regs
->memreg_tx_new
) {
1181 if (hw
->serial_number_detected
)
1182 printk(KERN_WARNING IPWIRELESS_PCCARD_NAME
1183 ": spurious interrupt - new_tx mode\n");
1185 printk(KERN_WARNING IPWIRELESS_PCCARD_NAME
1186 ": no valid memreg_tx value - "
1187 "switching to the old memreg_tx\n");
1189 &hw
->memory_info_regs
->memreg_tx_old
;
1193 printk(KERN_WARNING IPWIRELESS_PCCARD_NAME
1194 ": spurious interrupt - old_tx mode\n");
1197 } while (try_mem_tx_old
== 1);
1202 irqreturn_t
ipwireless_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
1204 struct ipw_hardware
*hw
= dev_id
;
1206 if (hw
->hw_version
== HW_VERSION_1
)
1207 return ipwireless_handle_v1_interrupt(irq
, hw
);
1209 return ipwireless_handle_v2_v3_interrupt(irq
, hw
);
1212 static void flush_packets_to_hw(struct ipw_hardware
*hw
)
1215 unsigned long flags
;
1217 spin_lock_irqsave(&hw
->spinlock
, flags
);
1218 priority_limit
= get_current_packet_priority(hw
);
1219 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
1221 while (send_pending_packet(hw
, priority_limit
));
1224 static void send_packet(struct ipw_hardware
*hw
, int priority
,
1225 struct ipw_tx_packet
*packet
)
1227 unsigned long flags
;
1229 spin_lock_irqsave(&hw
->spinlock
, flags
);
1230 list_add_tail(&packet
->queue
, &hw
->tx_queue
[priority
]);
1232 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
1234 flush_packets_to_hw(hw
);
1237 /* Create data packet, non-atomic allocation */
1238 static void *alloc_data_packet(int data_size
,
1239 unsigned char dest_addr
,
1240 unsigned char protocol
)
1242 struct ipw_tx_packet
*packet
= kzalloc(
1243 sizeof(struct ipw_tx_packet
) + data_size
,
1249 INIT_LIST_HEAD(&packet
->queue
);
1250 packet
->dest_addr
= dest_addr
;
1251 packet
->protocol
= protocol
;
1252 packet
->length
= data_size
;
1257 static void *alloc_ctrl_packet(int header_size
,
1258 unsigned char dest_addr
,
1259 unsigned char protocol
,
1260 unsigned char sig_no
)
1263 * sig_no is located right after ipw_tx_packet struct in every
1264 * CTRL or SETUP packets, we can use ipw_control_packet as a
1267 struct ipw_control_packet
*packet
= kzalloc(header_size
, GFP_ATOMIC
);
1272 INIT_LIST_HEAD(&packet
->header
.queue
);
1273 packet
->header
.dest_addr
= dest_addr
;
1274 packet
->header
.protocol
= protocol
;
1275 packet
->header
.length
= header_size
- sizeof(struct ipw_tx_packet
);
1276 packet
->body
.sig_no
= sig_no
;
1281 int ipwireless_send_packet(struct ipw_hardware
*hw
, unsigned int channel_idx
,
1282 unsigned char *data
, unsigned int length
,
1283 void (*callback
) (void *cb
, unsigned int length
),
1284 void *callback_data
)
1286 struct ipw_tx_packet
*packet
;
1288 packet
= alloc_data_packet(length
, (channel_idx
+ 1),
1289 TL_PROTOCOLID_COM_DATA
);
1292 packet
->packet_callback
= callback
;
1293 packet
->callback_data
= callback_data
;
1294 memcpy((unsigned char *) packet
+ sizeof(struct ipw_tx_packet
), data
,
1297 send_packet(hw
, PRIO_DATA
, packet
);
1301 static int set_control_line(struct ipw_hardware
*hw
, int prio
,
1302 unsigned int channel_idx
, int line
, int state
)
1304 struct ipw_control_packet
*packet
;
1305 int protocolid
= TL_PROTOCOLID_COM_CTRL
;
1307 if (prio
== PRIO_SETUP
)
1308 protocolid
= TL_PROTOCOLID_SETUP
;
1310 packet
= alloc_ctrl_packet(sizeof(struct ipw_control_packet
),
1311 (channel_idx
+ 1), protocolid
, line
);
1314 packet
->header
.length
= sizeof(struct ipw_control_packet_body
);
1315 packet
->body
.value
= (state
== 0 ? 0 : 1);
1316 send_packet(hw
, prio
, &packet
->header
);
1321 static int set_DTR(struct ipw_hardware
*hw
, int priority
,
1322 unsigned int channel_idx
, int state
)
1325 hw
->control_lines
[channel_idx
] |= IPW_CONTROL_LINE_DTR
;
1327 hw
->control_lines
[channel_idx
] &= ~IPW_CONTROL_LINE_DTR
;
1329 return set_control_line(hw
, priority
, channel_idx
, COMCTRL_DTR
, state
);
1332 static int set_RTS(struct ipw_hardware
*hw
, int priority
,
1333 unsigned int channel_idx
, int state
)
1336 hw
->control_lines
[channel_idx
] |= IPW_CONTROL_LINE_RTS
;
1338 hw
->control_lines
[channel_idx
] &= ~IPW_CONTROL_LINE_RTS
;
1340 return set_control_line(hw
, priority
, channel_idx
, COMCTRL_RTS
, state
);
1343 int ipwireless_set_DTR(struct ipw_hardware
*hw
, unsigned int channel_idx
,
1346 return set_DTR(hw
, PRIO_CTRL
, channel_idx
, state
);
1349 int ipwireless_set_RTS(struct ipw_hardware
*hw
, unsigned int channel_idx
,
1352 return set_RTS(hw
, PRIO_CTRL
, channel_idx
, state
);
1355 struct ipw_setup_get_version_query_packet
{
1356 struct ipw_tx_packet header
;
1357 struct tl_setup_get_version_qry body
;
1360 struct ipw_setup_config_packet
{
1361 struct ipw_tx_packet header
;
1362 struct tl_setup_config_msg body
;
1365 struct ipw_setup_config_done_packet
{
1366 struct ipw_tx_packet header
;
1367 struct tl_setup_config_done_msg body
;
1370 struct ipw_setup_open_packet
{
1371 struct ipw_tx_packet header
;
1372 struct tl_setup_open_msg body
;
1375 struct ipw_setup_info_packet
{
1376 struct ipw_tx_packet header
;
1377 struct tl_setup_info_msg body
;
1380 struct ipw_setup_reboot_msg_ack
{
1381 struct ipw_tx_packet header
;
1382 struct TlSetupRebootMsgAck body
;
1385 /* This handles the actual initialization of the card */
1386 static void __handle_setup_get_version_rsp(struct ipw_hardware
*hw
)
1388 struct ipw_setup_config_packet
*config_packet
;
1389 struct ipw_setup_config_done_packet
*config_done_packet
;
1390 struct ipw_setup_open_packet
*open_packet
;
1391 struct ipw_setup_info_packet
*info_packet
;
1393 unsigned int channel_idx
;
1395 /* generate config packet */
1396 for (port
= 1; port
<= NL_NUM_OF_ADDRESSES
; port
++) {
1397 config_packet
= alloc_ctrl_packet(
1398 sizeof(struct ipw_setup_config_packet
),
1400 TL_PROTOCOLID_SETUP
,
1401 TL_SETUP_SIGNO_CONFIG_MSG
);
1404 config_packet
->header
.length
= sizeof(struct tl_setup_config_msg
);
1405 config_packet
->body
.port_no
= port
;
1406 config_packet
->body
.prio_data
= PRIO_DATA
;
1407 config_packet
->body
.prio_ctrl
= PRIO_CTRL
;
1408 send_packet(hw
, PRIO_SETUP
, &config_packet
->header
);
1410 config_done_packet
= alloc_ctrl_packet(
1411 sizeof(struct ipw_setup_config_done_packet
),
1413 TL_PROTOCOLID_SETUP
,
1414 TL_SETUP_SIGNO_CONFIG_DONE_MSG
);
1415 if (!config_done_packet
)
1417 config_done_packet
->header
.length
= sizeof(struct tl_setup_config_done_msg
);
1418 send_packet(hw
, PRIO_SETUP
, &config_done_packet
->header
);
1420 /* generate open packet */
1421 for (port
= 1; port
<= NL_NUM_OF_ADDRESSES
; port
++) {
1422 open_packet
= alloc_ctrl_packet(
1423 sizeof(struct ipw_setup_open_packet
),
1425 TL_PROTOCOLID_SETUP
,
1426 TL_SETUP_SIGNO_OPEN_MSG
);
1429 open_packet
->header
.length
= sizeof(struct tl_setup_open_msg
);
1430 open_packet
->body
.port_no
= port
;
1431 send_packet(hw
, PRIO_SETUP
, &open_packet
->header
);
1433 for (channel_idx
= 0;
1434 channel_idx
< NL_NUM_OF_ADDRESSES
; channel_idx
++) {
1437 ret
= set_DTR(hw
, PRIO_SETUP
, channel_idx
,
1438 (hw
->control_lines
[channel_idx
] &
1439 IPW_CONTROL_LINE_DTR
) != 0);
1441 printk(KERN_ERR IPWIRELESS_PCCARD_NAME
1442 ": error setting DTR (%d)\n", ret
);
1446 set_RTS(hw
, PRIO_SETUP
, channel_idx
,
1447 (hw
->control_lines
[channel_idx
] &
1448 IPW_CONTROL_LINE_RTS
) != 0);
1450 printk(KERN_ERR IPWIRELESS_PCCARD_NAME
1451 ": error setting RTS (%d)\n", ret
);
1456 * For NDIS we assume that we are using sync PPP frames, for COM async.
1457 * This driver uses NDIS mode too. We don't bother with translation
1458 * from async -> sync PPP.
1460 info_packet
= alloc_ctrl_packet(sizeof(struct ipw_setup_info_packet
),
1462 TL_PROTOCOLID_SETUP
,
1463 TL_SETUP_SIGNO_INFO_MSG
);
1466 info_packet
->header
.length
= sizeof(struct tl_setup_info_msg
);
1467 info_packet
->body
.driver_type
= NDISWAN_DRIVER
;
1468 info_packet
->body
.major_version
= NDISWAN_DRIVER_MAJOR_VERSION
;
1469 info_packet
->body
.minor_version
= NDISWAN_DRIVER_MINOR_VERSION
;
1470 send_packet(hw
, PRIO_SETUP
, &info_packet
->header
);
1472 /* Initialization is now complete, so we clear the 'to_setup' flag */
1478 printk(KERN_ERR IPWIRELESS_PCCARD_NAME
1479 ": not enough memory to alloc control packet\n");
1483 static void handle_setup_get_version_rsp(struct ipw_hardware
*hw
,
1484 unsigned char vers_no
)
1486 del_timer(&hw
->setup_timer
);
1487 hw
->initializing
= 0;
1488 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
": card is ready.\n");
1490 if (vers_no
== TL_SETUP_VERSION
)
1491 __handle_setup_get_version_rsp(hw
);
1494 IPWIRELESS_PCCARD_NAME
1495 ": invalid hardware version no %u\n",
1496 (unsigned int) vers_no
);
1499 static void ipw_send_setup_packet(struct ipw_hardware
*hw
)
1501 struct ipw_setup_get_version_query_packet
*ver_packet
;
1503 ver_packet
= alloc_ctrl_packet(
1504 sizeof(struct ipw_setup_get_version_query_packet
),
1505 ADDR_SETUP_PROT
, TL_PROTOCOLID_SETUP
,
1506 TL_SETUP_SIGNO_GET_VERSION_QRY
);
1507 ver_packet
->header
.length
= sizeof(struct tl_setup_get_version_qry
);
1510 * Response is handled in handle_received_SETUP_packet
1512 send_packet(hw
, PRIO_SETUP
, &ver_packet
->header
);
1515 static void handle_received_SETUP_packet(struct ipw_hardware
*hw
,
1516 unsigned int address
,
1517 unsigned char *data
, int len
,
1520 union ipw_setup_rx_msg
*rx_msg
= (union ipw_setup_rx_msg
*) data
;
1522 if (address
!= ADDR_SETUP_PROT
) {
1523 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
1524 ": setup packet has bad address %d\n", address
);
1528 switch (rx_msg
->sig_no
) {
1529 case TL_SETUP_SIGNO_GET_VERSION_RSP
:
1531 handle_setup_get_version_rsp(hw
,
1532 rx_msg
->version_rsp_msg
.version
);
1535 case TL_SETUP_SIGNO_OPEN_MSG
:
1536 if (ipwireless_debug
) {
1537 unsigned int channel_idx
= rx_msg
->open_msg
.port_no
- 1;
1539 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
1540 ": OPEN_MSG [channel %u] reply received\n",
1545 case TL_SETUP_SIGNO_INFO_MSG_ACK
:
1546 if (ipwireless_debug
)
1547 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
1548 ": card successfully configured as NDISWAN\n");
1551 case TL_SETUP_SIGNO_REBOOT_MSG
:
1553 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
1554 ": Setup not completed - ignoring reboot msg\n");
1556 struct ipw_setup_reboot_msg_ack
*packet
;
1558 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
1559 ": Acknowledging REBOOT message\n");
1560 packet
= alloc_ctrl_packet(
1561 sizeof(struct ipw_setup_reboot_msg_ack
),
1562 ADDR_SETUP_PROT
, TL_PROTOCOLID_SETUP
,
1563 TL_SETUP_SIGNO_REBOOT_MSG_ACK
);
1564 packet
->header
.length
=
1565 sizeof(struct TlSetupRebootMsgAck
);
1566 send_packet(hw
, PRIO_SETUP
, &packet
->header
);
1567 if (hw
->reboot_callback
)
1568 hw
->reboot_callback(hw
->reboot_callback_data
);
1573 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
1574 ": unknown setup message %u received\n",
1575 (unsigned int) rx_msg
->sig_no
);
1579 static void do_close_hardware(struct ipw_hardware
*hw
)
1583 if (hw
->hw_version
== HW_VERSION_1
) {
1584 /* Disable TX and RX interrupts. */
1585 outw(0, hw
->base_port
+ IOIER
);
1587 /* Acknowledge any outstanding interrupt requests */
1588 irqn
= inw(hw
->base_port
+ IOIR
);
1589 if (irqn
& IR_TXINTR
)
1590 outw(IR_TXINTR
, hw
->base_port
+ IOIR
);
1591 if (irqn
& IR_RXINTR
)
1592 outw(IR_RXINTR
, hw
->base_port
+ IOIR
);
1594 synchronize_irq(hw
->irq
);
1598 struct ipw_hardware
*ipwireless_hardware_create(void)
1601 struct ipw_hardware
*hw
=
1602 kzalloc(sizeof(struct ipw_hardware
), GFP_KERNEL
);
1608 hw
->initializing
= 1;
1610 hw
->rx_bytes_queued
= 0;
1611 hw
->rx_pool_size
= 0;
1612 hw
->last_memtx_serial
= (unsigned short) 0xffff;
1613 for (i
= 0; i
< NL_NUM_OF_PRIORITIES
; i
++)
1614 INIT_LIST_HEAD(&hw
->tx_queue
[i
]);
1616 INIT_LIST_HEAD(&hw
->rx_queue
);
1617 INIT_LIST_HEAD(&hw
->rx_pool
);
1618 spin_lock_init(&hw
->spinlock
);
1619 tasklet_init(&hw
->tasklet
, ipwireless_do_tasklet
, (unsigned long) hw
);
1620 INIT_WORK(&hw
->work_rx
, ipw_receive_data_work
);
1621 setup_timer(&hw
->setup_timer
, ipwireless_setup_timer
,
1622 (unsigned long) hw
);
1627 void ipwireless_init_hardware_v1(struct ipw_hardware
*hw
,
1628 unsigned int base_port
,
1629 void __iomem
*attr_memory
,
1630 void __iomem
*common_memory
,
1632 void (*reboot_callback
) (void *data
),
1633 void *reboot_callback_data
)
1637 enable_irq(hw
->irq
);
1639 hw
->base_port
= base_port
;
1640 hw
->hw_version
= (is_v2_card
? HW_VERSION_2
: HW_VERSION_1
);
1641 hw
->ll_mtu
= (hw
->hw_version
== HW_VERSION_1
? LL_MTU_V1
: LL_MTU_V2
);
1642 hw
->memregs_CCR
= (struct MEMCCR __iomem
*)
1643 ((unsigned short __iomem
*) attr_memory
+ 0x200);
1644 hw
->memory_info_regs
= (struct MEMINFREG __iomem
*) common_memory
;
1645 hw
->memreg_tx
= &hw
->memory_info_regs
->memreg_tx_new
;
1646 hw
->reboot_callback
= reboot_callback
;
1647 hw
->reboot_callback_data
= reboot_callback_data
;
1650 void ipwireless_init_hardware_v2_v3(struct ipw_hardware
*hw
)
1652 hw
->initializing
= 1;
1654 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
1655 ": waiting for card to start up...\n");
1656 ipwireless_setup_timer((unsigned long) hw
);
1659 static void ipwireless_setup_timer(unsigned long data
)
1661 struct ipw_hardware
*hw
= (struct ipw_hardware
*) data
;
1665 if (hw
->init_loops
== TL_SETUP_MAX_VERSION_QRY
&&
1666 hw
->hw_version
== HW_VERSION_2
&&
1667 hw
->memreg_tx
== &hw
->memory_info_regs
->memreg_tx_new
) {
1668 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
1669 ": failed to startup using TX2, trying TX\n");
1671 hw
->memreg_tx
= &hw
->memory_info_regs
->memreg_tx_old
;
1674 /* Give up after a certain number of retries */
1675 if (hw
->init_loops
== TL_SETUP_MAX_VERSION_QRY
) {
1676 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
1677 ": card failed to start up!\n");
1678 hw
->initializing
= 0;
1680 /* Do not attempt to write to the board if it is not present. */
1681 if (is_card_present(hw
)) {
1682 unsigned long flags
;
1684 spin_lock_irqsave(&hw
->spinlock
, flags
);
1687 spin_unlock_irqrestore(&hw
->spinlock
, flags
);
1688 tasklet_schedule(&hw
->tasklet
);
1691 mod_timer(&hw
->setup_timer
,
1692 jiffies
+ msecs_to_jiffies(TL_SETUP_VERSION_QRY_TMO
));
1697 * Stop any interrupts from executing so that, once this function returns,
1698 * other layers of the driver can be sure they won't get any more callbacks.
1699 * Thus must be called on a proper process context.
1701 void ipwireless_stop_interrupts(struct ipw_hardware
*hw
)
1703 if (!hw
->shutting_down
) {
1704 /* Tell everyone we are going down. */
1705 hw
->shutting_down
= 1;
1706 del_timer(&hw
->setup_timer
);
1708 /* Prevent the hardware from sending any more interrupts */
1709 do_close_hardware(hw
);
1713 void ipwireless_hardware_free(struct ipw_hardware
*hw
)
1716 struct ipw_rx_packet
*rp
, *rq
;
1717 struct ipw_tx_packet
*tp
, *tq
;
1719 ipwireless_stop_interrupts(hw
);
1721 flush_scheduled_work();
1723 for (i
= 0; i
< NL_NUM_OF_ADDRESSES
; i
++)
1724 if (hw
->packet_assembler
[i
] != NULL
)
1725 kfree(hw
->packet_assembler
[i
]);
1727 for (i
= 0; i
< NL_NUM_OF_PRIORITIES
; i
++)
1728 list_for_each_entry_safe(tp
, tq
, &hw
->tx_queue
[i
], queue
) {
1729 list_del(&tp
->queue
);
1733 list_for_each_entry_safe(rp
, rq
, &hw
->rx_queue
, queue
) {
1734 list_del(&rp
->queue
);
1738 list_for_each_entry_safe(rp
, rq
, &hw
->rx_pool
, queue
) {
1739 list_del(&rp
->queue
);
1746 * Associate the specified network with this hardware, so it will receive events
1749 void ipwireless_associate_network(struct ipw_hardware
*hw
,
1750 struct ipw_network
*network
)
1752 hw
->network
= network
;