1 /*---------------------------------------------------------------------------
2 FT1000 driver for Flarion Flash OFDM NIC Device
4 Copyright (C) 2002 Flarion Technologies, All rights reserved.
5 Copyright (C) 2006 Patrik Ostrihon, All rights reserved.
6 Copyright (C) 2006 ProWeb Consulting, a.s, All rights reserved.
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2 of the License, or (at your option) any
11 later version. This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 more details. You should have received a copy of the GNU General Public
15 License along with this program; if not, write to the
16 Free Software Foundation, Inc., 59 Temple Place -
17 Suite 330, Boston, MA 02111-1307, USA.
18 -------------------------------------------------------------------------*/
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/sched.h>
25 #include <linux/ptrace.h>
26 #include <linux/slab.h>
27 #include <linux/string.h>
28 #include <linux/timer.h>
29 #include <linux/interrupt.h>
32 #include <linux/bitops.h>
34 #include <linux/netdevice.h>
35 #include <linux/etherdevice.h>
36 #include <linux/skbuff.h>
37 #include <linux/if_arp.h>
38 #include <linux/ioport.h>
39 #include <linux/wait.h>
40 #include <linux/vmalloc.h>
42 #include <linux/firmware.h>
43 #include <linux/ethtool.h>
45 #include <pcmcia/cistpl.h>
46 #include <pcmcia/cisreg.h>
47 #include <pcmcia/ds.h>
49 #include <linux/delay.h>
52 static const struct firmware
*fw_entry
;
54 static void ft1000_hbchk(u_long data
);
55 static struct timer_list poll_timer
= {
56 .function
= ft1000_hbchk
59 static u16 cmdbuffer
[1024];
60 static u8 tempbuffer
[1600];
61 static u8 ft1000_card_present
;
62 static u8 flarion_ft1000_cnt
;
64 static irqreturn_t
ft1000_interrupt(int irq
, void *dev_id
);
65 static void ft1000_enable_interrupts(struct net_device
*dev
);
66 static void ft1000_disable_interrupts(struct net_device
*dev
);
70 MODULE_DESCRIPTION("Support for Flarion Flash OFDM NIC Device. Support for PCMCIA when used with ft1000_cs.");
71 MODULE_LICENSE("GPL");
72 MODULE_SUPPORTED_DEVICE("FT1000");
74 #define MAX_RCV_LOOP 100
76 /*---------------------------------------------------------------------------
78 Function: ft1000_read_fifo_len
79 Description: This function will read the ASIC Uplink FIFO status register
80 which will return the number of bytes remaining in the Uplink FIFO.
81 Sixteen bytes are subtracted to make sure that the ASIC does not
84 dev - network device structure
86 value - number of bytes available in the ASIC Uplink FIFO.
88 -------------------------------------------------------------------------*/
89 static inline u16
ft1000_read_fifo_len(struct net_device
*dev
)
91 struct ft1000_info
*info
= netdev_priv(dev
);
93 if (info
->AsicID
== ELECTRABUZZ_ID
)
94 return (ft1000_read_reg(dev
, FT1000_REG_UFIFO_STAT
) - 16);
96 return (ft1000_read_reg(dev
, FT1000_REG_MAG_UFSR
) - 16);
99 /*---------------------------------------------------------------------------
101 Function: ft1000_read_dpram
102 Description: This function will read the specific area of dpram
103 (Electrabuzz ASIC only)
105 dev - device structure
106 offset - index of dpram
108 value - value of dpram
110 -------------------------------------------------------------------------*/
111 u16
ft1000_read_dpram(struct net_device
*dev
, int offset
)
113 struct ft1000_info
*info
= netdev_priv(dev
);
117 /* Provide mutual exclusive access while reading ASIC registers. */
118 spin_lock_irqsave(&info
->dpram_lock
, flags
);
119 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
, offset
);
120 data
= ft1000_read_reg(dev
, FT1000_REG_DPRAM_DATA
);
121 spin_unlock_irqrestore(&info
->dpram_lock
, flags
);
126 /*---------------------------------------------------------------------------
128 Function: ft1000_write_dpram
129 Description: This function will write to a specific area of dpram
130 (Electrabuzz ASIC only)
132 dev - device structure
133 offset - index of dpram
134 value - value to write
138 -------------------------------------------------------------------------*/
139 static inline void ft1000_write_dpram(struct net_device
*dev
,
140 int offset
, u16 value
)
142 struct ft1000_info
*info
= netdev_priv(dev
);
145 /* Provide mutual exclusive access while reading ASIC registers. */
146 spin_lock_irqsave(&info
->dpram_lock
, flags
);
147 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
, offset
);
148 ft1000_write_reg(dev
, FT1000_REG_DPRAM_DATA
, value
);
149 spin_unlock_irqrestore(&info
->dpram_lock
, flags
);
152 /*---------------------------------------------------------------------------
154 Function: ft1000_read_dpram_mag_16
155 Description: This function will read the specific area of dpram
156 (Magnemite ASIC only)
158 dev - device structure
159 offset - index of dpram
161 value - value of dpram
163 -------------------------------------------------------------------------*/
164 u16
ft1000_read_dpram_mag_16(struct net_device
*dev
, int offset
, int Index
)
166 struct ft1000_info
*info
= netdev_priv(dev
);
170 /* Provide mutual exclusive access while reading ASIC registers. */
171 spin_lock_irqsave(&info
->dpram_lock
, flags
);
172 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
, offset
);
173 /* check if we want to read upper or lower 32-bit word */
175 data
= ft1000_read_reg(dev
, FT1000_REG_MAG_DPDATAL
);
177 data
= ft1000_read_reg(dev
, FT1000_REG_MAG_DPDATAH
);
179 spin_unlock_irqrestore(&info
->dpram_lock
, flags
);
184 /*---------------------------------------------------------------------------
186 Function: ft1000_write_dpram_mag_16
187 Description: This function will write to a specific area of dpram
188 (Magnemite ASIC only)
190 dev - device structure
191 offset - index of dpram
192 value - value to write
196 -------------------------------------------------------------------------*/
197 static inline void ft1000_write_dpram_mag_16(struct net_device
*dev
,
198 int offset
, u16 value
, int Index
)
200 struct ft1000_info
*info
= netdev_priv(dev
);
203 /* Provide mutual exclusive access while reading ASIC registers. */
204 spin_lock_irqsave(&info
->dpram_lock
, flags
);
205 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
, offset
);
207 ft1000_write_reg(dev
, FT1000_REG_MAG_DPDATAL
, value
);
209 ft1000_write_reg(dev
, FT1000_REG_MAG_DPDATAH
, value
);
211 spin_unlock_irqrestore(&info
->dpram_lock
, flags
);
214 /*---------------------------------------------------------------------------
216 Function: ft1000_read_dpram_mag_32
217 Description: This function will read the specific area of dpram
218 (Magnemite ASIC only)
220 dev - device structure
221 offset - index of dpram
223 value - value of dpram
225 -------------------------------------------------------------------------*/
226 u32
ft1000_read_dpram_mag_32(struct net_device
*dev
, int offset
)
228 struct ft1000_info
*info
= netdev_priv(dev
);
232 /* Provide mutual exclusive access while reading ASIC registers. */
233 spin_lock_irqsave(&info
->dpram_lock
, flags
);
234 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
, offset
);
235 data
= inl(dev
->base_addr
+ FT1000_REG_MAG_DPDATAL
);
236 spin_unlock_irqrestore(&info
->dpram_lock
, flags
);
241 /*---------------------------------------------------------------------------
243 Function: ft1000_write_dpram_mag_32
244 Description: This function will write to a specific area of dpram
245 (Magnemite ASIC only)
247 dev - device structure
248 offset - index of dpram
249 value - value to write
253 -------------------------------------------------------------------------*/
254 void ft1000_write_dpram_mag_32(struct net_device
*dev
, int offset
, u32 value
)
256 struct ft1000_info
*info
= netdev_priv(dev
);
259 /* Provide mutual exclusive access while reading ASIC registers. */
260 spin_lock_irqsave(&info
->dpram_lock
, flags
);
261 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
, offset
);
262 outl(value
, dev
->base_addr
+ FT1000_REG_MAG_DPDATAL
);
263 spin_unlock_irqrestore(&info
->dpram_lock
, flags
);
266 /*---------------------------------------------------------------------------
268 Function: ft1000_enable_interrupts
269 Description: This function will enable interrupts base on the current
272 dev - device structure
276 -------------------------------------------------------------------------*/
277 static void ft1000_enable_interrupts(struct net_device
*dev
)
281 ft1000_write_reg(dev
, FT1000_REG_SUP_IMASK
, ISR_DEFAULT_MASK
);
282 tempword
= ft1000_read_reg(dev
, FT1000_REG_SUP_IMASK
);
283 pr_debug("current interrupt enable mask = 0x%x\n", tempword
);
286 /*---------------------------------------------------------------------------
288 Function: ft1000_disable_interrupts
289 Description: This function will disable all interrupts.
291 dev - device structure
295 -------------------------------------------------------------------------*/
296 static void ft1000_disable_interrupts(struct net_device
*dev
)
300 ft1000_write_reg(dev
, FT1000_REG_SUP_IMASK
, ISR_MASK_ALL
);
301 tempword
= ft1000_read_reg(dev
, FT1000_REG_SUP_IMASK
);
302 pr_debug("current interrupt enable mask = 0x%x\n", tempword
);
305 /*---------------------------------------------------------------------------
306 Function: ft1000_read_dsp_timer
307 Description: This function reads the DSP timer and stores its value in the
308 DSP_TIME field of the ft1000_info struct passed as argument
310 dev - device structure
311 info - ft1000_info structure
315 -------------------------------------------------------------------------*/
316 static void ft1000_read_dsp_timer(struct net_device
*dev
,
317 struct ft1000_info
*info
)
319 if (info
->AsicID
== ELECTRABUZZ_ID
) {
320 info
->DSP_TIME
[0] = ft1000_read_dpram(dev
, FT1000_DSP_TIMER0
);
321 info
->DSP_TIME
[1] = ft1000_read_dpram(dev
, FT1000_DSP_TIMER1
);
322 info
->DSP_TIME
[2] = ft1000_read_dpram(dev
, FT1000_DSP_TIMER2
);
323 info
->DSP_TIME
[3] = ft1000_read_dpram(dev
, FT1000_DSP_TIMER3
);
326 ft1000_read_dpram_mag_16(dev
, FT1000_MAG_DSP_TIMER0
,
327 FT1000_MAG_DSP_TIMER0_INDX
);
329 ft1000_read_dpram_mag_16(dev
, FT1000_MAG_DSP_TIMER1
,
330 FT1000_MAG_DSP_TIMER1_INDX
);
332 ft1000_read_dpram_mag_16(dev
, FT1000_MAG_DSP_TIMER2
,
333 FT1000_MAG_DSP_TIMER2_INDX
);
335 ft1000_read_dpram_mag_16(dev
, FT1000_MAG_DSP_TIMER3
,
336 FT1000_MAG_DSP_TIMER3_INDX
);
340 /*---------------------------------------------------------------------------
342 Function: ft1000_reset_asic
343 Description: This function will call the Card Service function to reset the
346 dev - device structure
350 -------------------------------------------------------------------------*/
351 static void ft1000_reset_asic(struct net_device
*dev
)
353 struct ft1000_info
*info
= netdev_priv(dev
);
354 struct ft1000_pcmcia
*pcmcia
= info
->priv
;
357 (*info
->ft1000_reset
) (pcmcia
->link
);
360 * Let's use the register provided by the Magnemite ASIC to reset the
363 if (info
->AsicID
== MAGNEMITE_ID
) {
364 ft1000_write_reg(dev
, FT1000_REG_RESET
,
365 DSP_RESET_BIT
| ASIC_RESET_BIT
);
368 if (info
->AsicID
== ELECTRABUZZ_ID
) {
369 /* set watermark to -1 in order to not generate an interrupt */
370 ft1000_write_reg(dev
, FT1000_REG_WATERMARK
, 0xffff);
372 /* set watermark to -1 in order to not generate an interrupt */
373 ft1000_write_reg(dev
, FT1000_REG_MAG_WATERMARK
, 0xffff);
375 /* clear interrupts */
376 tempword
= ft1000_read_reg(dev
, FT1000_REG_SUP_ISR
);
377 pr_debug("interrupt status register = 0x%x\n", tempword
);
378 ft1000_write_reg(dev
, FT1000_REG_SUP_ISR
, tempword
);
379 tempword
= ft1000_read_reg(dev
, FT1000_REG_SUP_ISR
);
380 pr_debug("interrupt status register = 0x%x\n", tempword
);
384 /*---------------------------------------------------------------------------
386 Function: ft1000_reset_card
387 Description: This function will reset the card
389 dev - device structure
391 status - false (card reset fail)
392 true (card reset successful)
394 -------------------------------------------------------------------------*/
395 static int ft1000_reset_card(struct net_device
*dev
)
397 struct ft1000_info
*info
= netdev_priv(dev
);
401 struct prov_record
*ptr
;
402 struct prov_record
*tmp
;
405 info
->ProgConStat
= 0;
406 info
->squeseqnum
= 0;
407 ft1000_disable_interrupts(dev
);
409 /* del_timer(&poll_timer); */
411 /* Make sure we free any memory reserve for provisioning */
412 list_for_each_entry_safe(ptr
, tmp
, &info
->prov_list
, list
) {
413 pr_debug("deleting provisioning record\n");
414 list_del(&ptr
->list
);
415 kfree(ptr
->pprov_data
);
419 if (info
->AsicID
== ELECTRABUZZ_ID
) {
420 pr_debug("resetting DSP\n");
421 ft1000_write_reg(dev
, FT1000_REG_RESET
, DSP_RESET_BIT
);
423 pr_debug("resetting ASIC and DSP\n");
424 ft1000_write_reg(dev
, FT1000_REG_RESET
,
425 DSP_RESET_BIT
| ASIC_RESET_BIT
);
428 /* Copy DSP session record into info block if this is not a coldstart */
429 if (ft1000_card_present
== 1) {
430 spin_lock_irqsave(&info
->dpram_lock
, flags
);
431 if (info
->AsicID
== ELECTRABUZZ_ID
) {
432 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
,
433 FT1000_DPRAM_RX_BASE
);
434 for (i
= 0; i
< MAX_DSP_SESS_REC
; i
++) {
435 info
->DSPSess
.Rec
[i
] =
437 FT1000_REG_DPRAM_DATA
);
440 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
,
441 FT1000_DPRAM_MAG_RX_BASE
);
442 for (i
= 0; i
< MAX_DSP_SESS_REC
/ 2; i
++) {
443 info
->DSPSess
.MagRec
[i
] =
445 + FT1000_REG_MAG_DPDATA
);
448 spin_unlock_irqrestore(&info
->dpram_lock
, flags
);
451 pr_debug("resetting ASIC\n");
454 ft1000_reset_asic(dev
);
456 pr_debug("downloading dsp image\n");
458 if (info
->AsicID
== MAGNEMITE_ID
) {
459 /* Put dsp in reset and take ASIC out of reset */
460 pr_debug("Put DSP in reset and take ASIC out of reset\n");
461 ft1000_write_reg(dev
, FT1000_REG_RESET
, DSP_RESET_BIT
);
463 /* Setting MAGNEMITE ASIC to big endian mode */
464 ft1000_write_reg(dev
, FT1000_REG_SUP_CTRL
, HOST_INTF_BE
);
465 /* Download bootloader */
468 /* Take DSP out of reset */
469 ft1000_write_reg(dev
, FT1000_REG_RESET
, 0);
470 /* FLARION_DSP_ACTIVE; */
472 pr_debug("Take DSP out of reset\n");
475 * Wait for 0xfefe indicating dsp ready before starting
478 for (i
= 0; i
< 50; i
++) {
479 tempword
= ft1000_read_dpram_mag_16(dev
,
480 FT1000_MAG_DPRAM_FEFE
,
481 FT1000_MAG_DPRAM_FEFE_INDX
);
482 if (tempword
== 0xfefe)
488 pr_debug("No FEFE detected from DSP\n");
493 /* Take DSP out of reset */
494 ft1000_write_reg(dev
, FT1000_REG_RESET
, ~DSP_RESET_BIT
);
498 if (card_download(dev
, fw_entry
->data
, fw_entry
->size
)) {
499 pr_debug("card download unsuccessful\n");
502 pr_debug("card download successful\n");
506 if (info
->AsicID
== ELECTRABUZZ_ID
) {
508 * Need to initialize the FIFO length counter to zero in order
509 * to sync up with the DSP
512 ft1000_write_dpram(dev
, FT1000_FIFO_LEN
, info
->fifo_cnt
);
513 /* Initialize DSP heartbeat area to ho */
514 ft1000_write_dpram(dev
, FT1000_HI_HO
, ho
);
515 tempword
= ft1000_read_dpram(dev
, FT1000_HI_HO
);
516 pr_debug("hi_ho value = 0x%x\n", tempword
);
518 /* Initialize DSP heartbeat area to ho */
519 ft1000_write_dpram_mag_16(dev
, FT1000_MAG_HI_HO
, ho_mag
,
520 FT1000_MAG_HI_HO_INDX
);
522 ft1000_read_dpram_mag_16(dev
, FT1000_MAG_HI_HO
,
523 FT1000_MAG_HI_HO_INDX
);
524 pr_debug("hi_ho value = 0x%x\n", tempword
);
528 ft1000_enable_interrupts(dev
);
530 /* Schedule heartbeat process to run every 2 seconds */
531 /* poll_timer.expires = jiffies + (2*HZ); */
532 /* poll_timer.data = (u_long)dev; */
533 /* add_timer(&poll_timer); */
539 /*---------------------------------------------------------------------------
541 Function: ft1000_chkcard
542 Description: This function will check if the device is presently available on
545 dev - device structure
547 status - false (device is not present)
548 true (device is present)
550 -------------------------------------------------------------------------*/
551 static int ft1000_chkcard(struct net_device
*dev
)
556 * Mask register is used to check for device presence since it is never
559 tempword
= ft1000_read_reg(dev
, FT1000_REG_SUP_IMASK
);
561 pr_debug("IMASK = 0 Card not detected\n");
565 * The system will return the value of 0xffff for the version register
566 * if the device is not present.
568 tempword
= ft1000_read_reg(dev
, FT1000_REG_ASIC_ID
);
569 if (tempword
== 0xffff) {
570 pr_debug("Version = 0xffff Card not detected\n");
577 /*---------------------------------------------------------------------------
579 Function: ft1000_hbchk
580 Description: This function will perform the heart beat check of the DSP as
583 dev - device structure
587 -------------------------------------------------------------------------*/
588 static void ft1000_hbchk(u_long data
)
590 struct net_device
*dev
= (struct net_device
*)data
;
592 struct ft1000_info
*info
;
595 info
= netdev_priv(dev
);
597 if (info
->CardReady
== 1) {
598 /* Perform dsp heartbeat check */
599 if (info
->AsicID
== ELECTRABUZZ_ID
) {
600 tempword
= ft1000_read_dpram(dev
, FT1000_HI_HO
);
603 ntohs(ft1000_read_dpram_mag_16
604 (dev
, FT1000_MAG_HI_HO
,
605 FT1000_MAG_HI_HO_INDX
));
607 pr_debug("hi_ho value = 0x%x\n", tempword
);
608 /* Let's perform another check if ho is not detected */
609 if (tempword
!= ho
) {
610 if (info
->AsicID
== ELECTRABUZZ_ID
)
611 tempword
= ft1000_read_dpram(dev
, FT1000_HI_HO
);
613 tempword
= ntohs(ft1000_read_dpram_mag_16(dev
,
615 FT1000_MAG_HI_HO_INDX
));
617 if (tempword
!= ho
) {
618 pr_info("heartbeat failed - no ho detected\n");
619 ft1000_read_dsp_timer(dev
, info
);
620 info
->DrvErrNum
= DSP_HB_INFO
;
621 if (ft1000_reset_card(dev
) == 0) {
622 pr_info("Hardware Failure Detected - PC Card disabled\n");
623 info
->ProgConStat
= 0xff;
626 /* Schedule this module to run every 2 seconds */
627 poll_timer
.expires
= jiffies
+ (2*HZ
);
628 poll_timer
.data
= (u_long
)dev
;
629 add_timer(&poll_timer
);
633 tempword
= ft1000_read_reg(dev
, FT1000_REG_DOORBELL
);
634 /* Let's check doorbell again if fail */
635 if (tempword
& FT1000_DB_HB
)
636 tempword
= ft1000_read_reg(dev
, FT1000_REG_DOORBELL
);
638 if (tempword
& FT1000_DB_HB
) {
639 pr_info("heartbeat doorbell not clear by firmware\n");
640 ft1000_read_dsp_timer(dev
, info
);
641 info
->DrvErrNum
= DSP_HB_INFO
;
642 if (ft1000_reset_card(dev
) == 0) {
643 pr_info("Hardware Failure Detected - PC Card disabled\n");
644 info
->ProgConStat
= 0xff;
647 /* Schedule this module to run every 2 seconds */
648 poll_timer
.expires
= jiffies
+ (2*HZ
);
649 poll_timer
.data
= (u_long
)dev
;
650 add_timer(&poll_timer
);
654 * Set dedicated area to hi and ring appropriate doorbell
655 * according to hi/ho heartbeat protocol
657 if (info
->AsicID
== ELECTRABUZZ_ID
) {
658 ft1000_write_dpram(dev
, FT1000_HI_HO
, hi
);
660 ft1000_write_dpram_mag_16(dev
, FT1000_MAG_HI_HO
, hi_mag
,
661 FT1000_MAG_HI_HO_INDX
);
664 if (info
->AsicID
== ELECTRABUZZ_ID
) {
665 tempword
= ft1000_read_dpram(dev
, FT1000_HI_HO
);
668 ntohs(ft1000_read_dpram_mag_16
669 (dev
, FT1000_MAG_HI_HO
,
670 FT1000_MAG_HI_HO_INDX
));
672 /* Let's write hi again if fail */
673 if (tempword
!= hi
) {
674 if (info
->AsicID
== ELECTRABUZZ_ID
)
675 ft1000_write_dpram(dev
, FT1000_HI_HO
, hi
);
677 ft1000_write_dpram_mag_16(dev
, FT1000_MAG_HI_HO
,
678 hi_mag
, FT1000_MAG_HI_HO_INDX
);
680 if (info
->AsicID
== ELECTRABUZZ_ID
)
681 tempword
= ft1000_read_dpram(dev
, FT1000_HI_HO
);
683 tempword
= ntohs(ft1000_read_dpram_mag_16(dev
,
685 FT1000_MAG_HI_HO_INDX
));
688 if (tempword
!= hi
) {
689 pr_info("heartbeat failed - cannot write hi into DPRAM\n");
690 ft1000_read_dsp_timer(dev
, info
);
691 info
->DrvErrNum
= DSP_HB_INFO
;
692 if (ft1000_reset_card(dev
) == 0) {
693 pr_info("Hardware Failure Detected - PC Card disabled\n");
694 info
->ProgConStat
= 0xff;
697 /* Schedule this module to run every 2 seconds */
698 poll_timer
.expires
= jiffies
+ (2*HZ
);
699 poll_timer
.data
= (u_long
)dev
;
700 add_timer(&poll_timer
);
703 ft1000_write_reg(dev
, FT1000_REG_DOORBELL
, FT1000_DB_HB
);
707 /* Schedule this module to run every 2 seconds */
708 poll_timer
.expires
= jiffies
+ (2 * HZ
);
709 poll_timer
.data
= (u_long
)dev
;
710 add_timer(&poll_timer
);
713 /*---------------------------------------------------------------------------
715 Function: ft1000_send_cmd
720 -------------------------------------------------------------------------*/
721 static void ft1000_send_cmd(struct net_device
*dev
, u16
*ptempbuffer
, int size
,
724 struct ft1000_info
*info
= netdev_priv(dev
);
729 size
+= sizeof(struct pseudo_hdr
);
730 /* check for odd byte and increment to 16-bit word align value */
733 pr_debug("total length = %d\n", size
);
734 pr_debug("length = %d\n", ntohs(*ptempbuffer
));
736 * put message into slow queue area
737 * All messages are in the form total_len + pseudo header + message body
739 spin_lock_irqsave(&info
->dpram_lock
, flags
);
741 /* Make sure SLOWQ doorbell is clear */
742 tempword
= ft1000_read_reg(dev
, FT1000_REG_DOORBELL
);
744 while (tempword
& FT1000_DB_DPRAM_TX
) {
748 spin_unlock_irqrestore(&info
->dpram_lock
, flags
);
751 tempword
= ft1000_read_reg(dev
, FT1000_REG_DOORBELL
);
754 if (info
->AsicID
== ELECTRABUZZ_ID
) {
755 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
,
756 FT1000_DPRAM_TX_BASE
);
757 /* Write total length to dpram */
758 ft1000_write_reg(dev
, FT1000_REG_DPRAM_DATA
, size
);
759 /* Write pseudo header and messgae body */
760 for (i
= 0; i
< (size
>> 1); i
++) {
761 pr_debug("data %d = 0x%x\n", i
, *ptempbuffer
);
762 tempword
= htons(*ptempbuffer
++);
763 ft1000_write_reg(dev
, FT1000_REG_DPRAM_DATA
, tempword
);
766 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
,
767 FT1000_DPRAM_MAG_TX_BASE
);
768 /* Write total length to dpram */
769 ft1000_write_reg(dev
, FT1000_REG_MAG_DPDATAH
, htons(size
));
770 /* Write pseudo header and messgae body */
771 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
,
772 FT1000_DPRAM_MAG_TX_BASE
+ 1);
773 for (i
= 0; i
< (size
>> 2); i
++) {
774 pr_debug("data = 0x%x\n", *ptempbuffer
);
776 dev
->base_addr
+ FT1000_REG_MAG_DPDATAL
);
777 pr_debug("data = 0x%x\n", *ptempbuffer
);
779 dev
->base_addr
+ FT1000_REG_MAG_DPDATAH
);
781 pr_debug("data = 0x%x\n", *ptempbuffer
);
782 outw(*ptempbuffer
++, dev
->base_addr
+ FT1000_REG_MAG_DPDATAL
);
783 pr_debug("data = 0x%x\n", *ptempbuffer
);
784 outw(*ptempbuffer
++, dev
->base_addr
+ FT1000_REG_MAG_DPDATAH
);
786 spin_unlock_irqrestore(&info
->dpram_lock
, flags
);
788 /* ring doorbell to notify DSP that we have a message ready */
789 ft1000_write_reg(dev
, FT1000_REG_DOORBELL
, FT1000_DB_DPRAM_TX
);
792 /*---------------------------------------------------------------------------
794 Function: ft1000_receive_cmd
795 Description: This function will read a message from the dpram area.
797 dev - network device structure
798 pbuffer - caller supply address to buffer
799 pnxtph - pointer to next pseudo header
801 Status = 0 (unsuccessful)
804 -------------------------------------------------------------------------*/
805 static bool ft1000_receive_cmd(struct net_device
*dev
, u16
*pbuffer
,
806 int maxsz
, u16
*pnxtph
)
808 struct ft1000_info
*info
= netdev_priv(dev
);
815 if (info
->AsicID
== ELECTRABUZZ_ID
) {
816 size
= ft1000_read_dpram(dev
, *pnxtph
)
817 + sizeof(struct pseudo_hdr
);
819 size
= ntohs(ft1000_read_dpram_mag_16(dev
, FT1000_MAG_PH_LEN
,
820 FT1000_MAG_PH_LEN_INDX
))
821 + sizeof(struct pseudo_hdr
);
824 pr_debug("Invalid command length = %d\n", size
);
827 ppseudohdr
= (u16
*)pbuffer
;
828 spin_lock_irqsave(&info
->dpram_lock
, flags
);
829 if (info
->AsicID
== ELECTRABUZZ_ID
) {
830 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
,
831 FT1000_DPRAM_RX_BASE
+ 2);
832 for (i
= 0; i
<= (size
>> 1); i
++) {
834 ft1000_read_reg(dev
, FT1000_REG_DPRAM_DATA
);
835 *pbuffer
++ = ntohs(tempword
);
838 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
,
839 FT1000_DPRAM_MAG_RX_BASE
);
840 *pbuffer
= inw(dev
->base_addr
+ FT1000_REG_MAG_DPDATAH
);
841 pr_debug("received data = 0x%x\n", *pbuffer
);
843 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
,
844 FT1000_DPRAM_MAG_RX_BASE
+ 1);
845 for (i
= 0; i
<= (size
>> 2); i
++) {
848 FT1000_REG_MAG_DPDATAL
);
852 FT1000_REG_MAG_DPDATAH
);
855 /* copy odd aligned word */
856 *pbuffer
= inw(dev
->base_addr
+ FT1000_REG_MAG_DPDATAL
);
857 pr_debug("received data = 0x%x\n", *pbuffer
);
859 *pbuffer
= inw(dev
->base_addr
+ FT1000_REG_MAG_DPDATAH
);
860 pr_debug("received data = 0x%x\n", *pbuffer
);
864 /* copy odd byte from fifo */
865 tempword
= ft1000_read_reg(dev
, FT1000_REG_DPRAM_DATA
);
866 *pbuffer
= ntohs(tempword
);
868 spin_unlock_irqrestore(&info
->dpram_lock
, flags
);
871 * Check if pseudo header checksum is good
872 * Calculate pseudo header checksum
874 tempword
= *ppseudohdr
++;
875 for (i
= 1; i
< 7; i
++)
876 tempword
^= *ppseudohdr
++;
877 if (tempword
!= *ppseudohdr
) {
878 pr_debug("Pseudo header checksum mismatch\n");
879 /* Drop this message */
885 /*---------------------------------------------------------------------------
887 Function: ft1000_proc_drvmsg
888 Description: This function will process the various driver messages.
890 dev - device structure
891 pnxtph - pointer to next pseudo header
895 -------------------------------------------------------------------------*/
896 static void ft1000_proc_drvmsg(struct net_device
*dev
)
898 struct ft1000_info
*info
= netdev_priv(dev
);
901 struct media_msg
*pmediamsg
;
902 struct dsp_init_msg
*pdspinitmsg
;
903 struct drv_msg
*pdrvmsg
;
906 struct prov_record
*ptr
;
907 struct pseudo_hdr
*ppseudo_hdr
;
915 if (info
->AsicID
== ELECTRABUZZ_ID
)
916 tempword
= FT1000_DPRAM_RX_BASE
+2;
918 tempword
= FT1000_DPRAM_MAG_RX_BASE
;
920 if (ft1000_receive_cmd(dev
, &cmdbuffer
[0], MAX_CMD_SQSIZE
, &tempword
)) {
923 * Get the message type which is total_len + PSEUDO header
924 * + msgtype + message body
926 pdrvmsg
= (struct drv_msg
*)&cmdbuffer
[0];
927 msgtype
= ntohs(pdrvmsg
->type
);
928 pr_debug("Command message type = 0x%x\n", msgtype
);
931 pr_debug("Got a provisioning request message from DSP\n");
933 while (list_empty(&info
->prov_list
) == 0) {
934 pr_debug("Sending a provisioning message\n");
935 /* Make sure SLOWQ doorbell is clear */
936 tempword
= ft1000_read_reg(dev
,
937 FT1000_REG_DOORBELL
);
939 while (tempword
& FT1000_DB_DPRAM_TX
) {
945 ptr
= list_entry(info
->prov_list
.next
,
946 struct prov_record
, list
);
947 len
= *(u16
*)ptr
->pprov_data
;
950 pmsg
= (u16
*)ptr
->pprov_data
;
951 ppseudo_hdr
= (struct pseudo_hdr
*)pmsg
;
952 /* Insert slow queue sequence number */
953 ppseudo_hdr
->seq_num
= info
->squeseqnum
++;
954 ppseudo_hdr
->portsrc
= 0;
955 /* Calculate new checksum */
956 ppseudo_hdr
->checksum
= *pmsg
++;
957 pr_debug("checksum = 0x%x\n",
958 ppseudo_hdr
->checksum
);
959 for (i
= 1; i
< 7; i
++) {
960 ppseudo_hdr
->checksum
^= *pmsg
++;
961 pr_debug("checksum = 0x%x\n",
962 ppseudo_hdr
->checksum
);
965 ft1000_send_cmd(dev
, (u16
*)ptr
->pprov_data
,
967 list_del(&ptr
->list
);
968 kfree(ptr
->pprov_data
);
972 * Indicate adapter is ready to take application
973 * messages after all provisioning messages are sent
978 pmediamsg
= (struct media_msg
*)&cmdbuffer
[0];
979 if (info
->ProgConStat
!= 0xFF) {
980 if (pmediamsg
->state
) {
981 pr_debug("Media is up\n");
982 if (info
->mediastate
== 0) {
983 netif_carrier_on(dev
);
984 netif_wake_queue(dev
);
985 info
->mediastate
= 1;
986 do_gettimeofday(&tv
);
987 info
->ConTm
= tv
.tv_sec
;
990 pr_debug("Media is down\n");
991 if (info
->mediastate
== 1) {
992 info
->mediastate
= 0;
993 netif_carrier_off(dev
);
994 netif_stop_queue(dev
);
999 pr_debug("Media is down\n");
1000 if (info
->mediastate
== 1) {
1001 info
->mediastate
= 0;
1002 netif_carrier_off(dev
);
1003 netif_stop_queue(dev
);
1009 pdspinitmsg
= (struct dsp_init_msg
*)&cmdbuffer
[0];
1010 memcpy(info
->DspVer
, pdspinitmsg
->DspVer
, DSPVERSZ
);
1011 pr_debug("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n",
1012 info
->DspVer
[0], info
->DspVer
[1],
1013 info
->DspVer
[2], info
->DspVer
[3]);
1014 memcpy(info
->HwSerNum
, pdspinitmsg
->HwSerNum
,
1016 memcpy(info
->Sku
, pdspinitmsg
->Sku
, SKUSZ
);
1017 memcpy(info
->eui64
, pdspinitmsg
->eui64
, EUISZ
);
1018 dev
->dev_addr
[0] = info
->eui64
[0];
1019 dev
->dev_addr
[1] = info
->eui64
[1];
1020 dev
->dev_addr
[2] = info
->eui64
[2];
1021 dev
->dev_addr
[3] = info
->eui64
[5];
1022 dev
->dev_addr
[4] = info
->eui64
[6];
1023 dev
->dev_addr
[5] = info
->eui64
[7];
1025 if (ntohs(pdspinitmsg
->length
) ==
1026 (sizeof(struct dsp_init_msg
) - 20)) {
1027 memcpy(info
->ProductMode
,
1028 pdspinitmsg
->ProductMode
, MODESZ
);
1029 memcpy(info
->RfCalVer
, pdspinitmsg
->RfCalVer
,
1031 memcpy(info
->RfCalDate
, pdspinitmsg
->RfCalDate
,
1033 pr_debug("RFCalVer = 0x%2x 0x%2x\n",
1034 info
->RfCalVer
[0], info
->RfCalVer
[1]);
1038 case DSP_STORE_INFO
:
1039 pr_debug("Got DSP_STORE_INFO\n");
1040 tempword
= ntohs(pdrvmsg
->length
);
1041 info
->DSPInfoBlklen
= tempword
;
1042 if (tempword
< (MAX_DSP_SESS_REC
- 4)) {
1043 pmsg
= (u16
*)&pdrvmsg
->data
[0];
1044 for (i
= 0; i
< ((tempword
+ 1) / 2); i
++) {
1045 pr_debug("dsp info data = 0x%x\n",
1047 info
->DSPInfoBlk
[i
+ 10] = *pmsg
++;
1052 pr_debug("Got DSP_GET_INFO\n");
1054 * copy dsp info block to dsp
1055 * allow any outstanding ioctl to finish
1058 tempword
= ft1000_read_reg(dev
, FT1000_REG_DOORBELL
);
1059 if (tempword
& FT1000_DB_DPRAM_TX
) {
1061 tempword
= ft1000_read_reg(dev
,
1062 FT1000_REG_DOORBELL
);
1063 if (tempword
& FT1000_DB_DPRAM_TX
)
1067 if ((tempword
& FT1000_DB_DPRAM_TX
) == 0) {
1069 * Put message into Slow Queue
1070 * Form Pseudo header
1072 pmsg
= (u16
*)info
->DSPInfoBlk
;
1073 ppseudo_hdr
= (struct pseudo_hdr
*)pmsg
;
1074 ppseudo_hdr
->length
=
1075 htons(info
->DSPInfoBlklen
+ 4);
1076 ppseudo_hdr
->source
= 0x10;
1077 ppseudo_hdr
->destination
= 0x20;
1078 ppseudo_hdr
->portdest
= 0;
1079 ppseudo_hdr
->portsrc
= 0;
1080 ppseudo_hdr
->sh_str_id
= 0;
1081 ppseudo_hdr
->control
= 0;
1082 ppseudo_hdr
->rsvd1
= 0;
1083 ppseudo_hdr
->rsvd2
= 0;
1084 ppseudo_hdr
->qos_class
= 0;
1085 /* Insert slow queue sequence number */
1086 ppseudo_hdr
->seq_num
= info
->squeseqnum
++;
1087 /* Insert application id */
1088 ppseudo_hdr
->portsrc
= 0;
1089 /* Calculate new checksum */
1090 ppseudo_hdr
->checksum
= *pmsg
++;
1091 for (i
= 1; i
< 7; i
++)
1092 ppseudo_hdr
->checksum
^= *pmsg
++;
1094 info
->DSPInfoBlk
[8] = 0x7200;
1095 info
->DSPInfoBlk
[9] =
1096 htons(info
->DSPInfoBlklen
);
1097 ft1000_send_cmd(dev
, info
->DSPInfoBlk
,
1098 (u16
)(info
->DSPInfoBlklen
+4),
1103 case GET_DRV_ERR_RPT_MSG
:
1104 pr_debug("Got GET_DRV_ERR_RPT_MSG\n");
1106 * copy driver error message to dsp
1107 * allow any outstanding ioctl to finish
1110 tempword
= ft1000_read_reg(dev
, FT1000_REG_DOORBELL
);
1111 if (tempword
& FT1000_DB_DPRAM_TX
) {
1113 tempword
= ft1000_read_reg(dev
,
1114 FT1000_REG_DOORBELL
);
1115 if (tempword
& FT1000_DB_DPRAM_TX
)
1119 if ((tempword
& FT1000_DB_DPRAM_TX
) == 0) {
1121 * Put message into Slow Queue
1122 * Form Pseudo header
1124 pmsg
= (u16
*)&tempbuffer
[0];
1125 ppseudo_hdr
= (struct pseudo_hdr
*)pmsg
;
1126 ppseudo_hdr
->length
= htons(0x0012);
1127 ppseudo_hdr
->source
= 0x10;
1128 ppseudo_hdr
->destination
= 0x20;
1129 ppseudo_hdr
->portdest
= 0;
1130 ppseudo_hdr
->portsrc
= 0;
1131 ppseudo_hdr
->sh_str_id
= 0;
1132 ppseudo_hdr
->control
= 0;
1133 ppseudo_hdr
->rsvd1
= 0;
1134 ppseudo_hdr
->rsvd2
= 0;
1135 ppseudo_hdr
->qos_class
= 0;
1136 /* Insert slow queue sequence number */
1137 ppseudo_hdr
->seq_num
= info
->squeseqnum
++;
1138 /* Insert application id */
1139 ppseudo_hdr
->portsrc
= 0;
1140 /* Calculate new checksum */
1141 ppseudo_hdr
->checksum
= *pmsg
++;
1142 for (i
= 1; i
< 7; i
++)
1143 ppseudo_hdr
->checksum
^= *pmsg
++;
1145 pmsg
= (u16
*)&tempbuffer
[16];
1146 *pmsg
++ = htons(RSP_DRV_ERR_RPT_MSG
);
1147 *pmsg
++ = htons(0x000e);
1148 *pmsg
++ = htons(info
->DSP_TIME
[0]);
1149 *pmsg
++ = htons(info
->DSP_TIME
[1]);
1150 *pmsg
++ = htons(info
->DSP_TIME
[2]);
1151 *pmsg
++ = htons(info
->DSP_TIME
[3]);
1152 convert
.byte
[0] = info
->DspVer
[0];
1153 convert
.byte
[1] = info
->DspVer
[1];
1154 *pmsg
++ = convert
.wrd
;
1155 convert
.byte
[0] = info
->DspVer
[2];
1156 convert
.byte
[1] = info
->DspVer
[3];
1157 *pmsg
++ = convert
.wrd
;
1158 *pmsg
++ = htons(info
->DrvErrNum
);
1160 ft1000_send_cmd(dev
, (u16
*)&tempbuffer
[0],
1162 info
->DrvErrNum
= 0;
1172 /*---------------------------------------------------------------------------
1174 Function: ft1000_parse_dpram_msg
1175 Description: This function will parse the message received from the DSP
1176 via the DPRAM interface.
1178 dev - device structure
1183 -------------------------------------------------------------------------*/
1184 static int ft1000_parse_dpram_msg(struct net_device
*dev
)
1186 struct ft1000_info
*info
= netdev_priv(dev
);
1192 unsigned long flags
;
1194 doorbell
= ft1000_read_reg(dev
, FT1000_REG_DOORBELL
);
1195 pr_debug("Doorbell = 0x%x\n", doorbell
);
1197 if (doorbell
& FT1000_ASIC_RESET_REQ
) {
1198 /* Copy DSP session record from info block */
1199 spin_lock_irqsave(&info
->dpram_lock
, flags
);
1200 if (info
->AsicID
== ELECTRABUZZ_ID
) {
1201 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
,
1202 FT1000_DPRAM_RX_BASE
);
1203 for (i
= 0; i
< MAX_DSP_SESS_REC
; i
++) {
1204 ft1000_write_reg(dev
, FT1000_REG_DPRAM_DATA
,
1205 info
->DSPSess
.Rec
[i
]);
1208 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
,
1209 FT1000_DPRAM_MAG_RX_BASE
);
1210 for (i
= 0; i
< MAX_DSP_SESS_REC
/ 2; i
++) {
1211 outl(info
->DSPSess
.MagRec
[i
],
1212 dev
->base_addr
+ FT1000_REG_MAG_DPDATA
);
1215 spin_unlock_irqrestore(&info
->dpram_lock
, flags
);
1217 /* clear ASIC RESET request */
1218 ft1000_write_reg(dev
, FT1000_REG_DOORBELL
,
1219 FT1000_ASIC_RESET_REQ
);
1220 pr_debug("Got an ASIC RESET Request\n");
1221 ft1000_write_reg(dev
, FT1000_REG_DOORBELL
,
1222 FT1000_ASIC_RESET_DSP
);
1224 if (info
->AsicID
== MAGNEMITE_ID
) {
1225 /* Setting MAGNEMITE ASIC to big endian mode */
1226 ft1000_write_reg(dev
, FT1000_REG_SUP_CTRL
,
1231 if (doorbell
& FT1000_DSP_ASIC_RESET
) {
1232 pr_debug("Got a dsp ASIC reset message\n");
1233 ft1000_write_reg(dev
, FT1000_REG_DOORBELL
,
1234 FT1000_DSP_ASIC_RESET
);
1239 if (doorbell
& FT1000_DB_DPRAM_RX
) {
1240 pr_debug("Got a slow queue message\n");
1241 nxtph
= FT1000_DPRAM_RX_BASE
+ 2;
1242 if (info
->AsicID
== ELECTRABUZZ_ID
) {
1244 ft1000_read_dpram(dev
, FT1000_DPRAM_RX_BASE
);
1247 ntohs(ft1000_read_dpram_mag_16
1248 (dev
, FT1000_MAG_TOTAL_LEN
,
1249 FT1000_MAG_TOTAL_LEN_INDX
));
1251 pr_debug("total length = %d\n", total_len
);
1252 if ((total_len
< MAX_CMD_SQSIZE
)
1253 && (total_len
> sizeof(struct pseudo_hdr
))) {
1256 * ft1000_read_reg will return a value that needs to be
1257 * byteswap in order to get DSP_QID_OFFSET.
1259 if (info
->AsicID
== ELECTRABUZZ_ID
) {
1260 portid
= (ft1000_read_dpram(dev
, DSP_QID_OFFSET
1261 + FT1000_DPRAM_RX_BASE
+ 2)
1265 ft1000_read_dpram_mag_16
1266 (dev
, FT1000_MAG_PORT_ID
,
1267 FT1000_MAG_PORT_ID_INDX
) & 0xff;
1269 pr_debug("DSP_QID = 0x%x\n", portid
);
1271 if (portid
== DRIVERID
) {
1273 * We are assumming one driver message from the
1276 ft1000_proc_drvmsg(dev
);
1279 ft1000_write_reg(dev
, FT1000_REG_DOORBELL
, FT1000_DB_DPRAM_RX
);
1282 if (doorbell
& FT1000_DB_COND_RESET
) {
1283 /* Reset ASIC and DSP */
1284 ft1000_read_dsp_timer(dev
, info
);
1285 info
->DrvErrNum
= DSP_CONDRESET_INFO
;
1286 pr_debug("DSP conditional reset requested\n");
1287 ft1000_reset_card(dev
);
1288 ft1000_write_reg(dev
, FT1000_REG_DOORBELL
,
1289 FT1000_DB_COND_RESET
);
1291 /* let's clear any unexpected doorbells from DSP */
1293 doorbell
& ~(FT1000_DB_DPRAM_RX
| FT1000_ASIC_RESET_REQ
|
1294 FT1000_DB_COND_RESET
| 0xff00);
1296 pr_debug("Clearing unexpected doorbell = 0x%x\n", doorbell
);
1297 ft1000_write_reg(dev
, FT1000_REG_DOORBELL
, doorbell
);
1304 /*---------------------------------------------------------------------------
1306 Function: ft1000_flush_fifo
1307 Description: This function will flush one packet from the downlink
1310 dev - device structure
1311 drv_err - driver error causing the flush fifo
1315 -------------------------------------------------------------------------*/
1316 static void ft1000_flush_fifo(struct net_device
*dev
, u16 DrvErrNum
)
1318 struct ft1000_info
*info
= netdev_priv(dev
);
1319 struct ft1000_pcmcia
*pcmcia
= info
->priv
;
1324 if (pcmcia
->PktIntfErr
> MAX_PH_ERR
) {
1325 ft1000_read_dsp_timer(dev
, info
);
1326 info
->DrvErrNum
= DrvErrNum
;
1327 ft1000_reset_card(dev
);
1330 /* Flush corrupted pkt from FIFO */
1333 if (info
->AsicID
== ELECTRABUZZ_ID
) {
1335 ft1000_read_reg(dev
, FT1000_REG_DFIFO
);
1337 ft1000_read_reg(dev
, FT1000_REG_DFIFO_STAT
);
1340 inl(dev
->base_addr
+ FT1000_REG_MAG_DFR
);
1342 inw(dev
->base_addr
+ FT1000_REG_MAG_DFSR
);
1346 * This should never happen unless the ASIC is broken.
1347 * We must reset to recover.
1349 if ((i
> 2048) || (tempword
== 0)) {
1350 ft1000_read_dsp_timer(dev
, info
);
1351 if (tempword
== 0) {
1353 * Let's check if ASIC reads are still ok by
1354 * reading the Mask register which is never zero
1355 * at this point of the code.
1358 inw(dev
->base_addr
+
1359 FT1000_REG_SUP_IMASK
);
1360 if (tempword
== 0) {
1362 * This indicates that we can not
1363 * communicate with the ASIC
1365 info
->DrvErrNum
= FIFO_FLUSH_BADCNT
;
1368 * Let's assume that we really flush
1371 pcmcia
->PktIntfErr
++;
1375 info
->DrvErrNum
= FIFO_FLUSH_MAXLIMIT
;
1379 tempword
= inw(dev
->base_addr
+ FT1000_REG_SUP_STAT
);
1380 } while ((tempword
& 0x03) != 0x03);
1381 if (info
->AsicID
== ELECTRABUZZ_ID
) {
1383 pr_debug("Flushing FIFO complete = %x\n", tempword
);
1384 /* Flush last word in FIFO. */
1385 tempword
= ft1000_read_reg(dev
, FT1000_REG_DFIFO
);
1386 /* Update FIFO counter for DSP */
1388 pr_debug("Flush Data byte count to dsp = %d\n", i
);
1389 info
->fifo_cnt
+= i
;
1390 ft1000_write_dpram(dev
, FT1000_FIFO_LEN
,
1393 pr_debug("Flushing FIFO complete = %x\n", tempword
);
1394 /* Flush last word in FIFO */
1395 templong
= inl(dev
->base_addr
+ FT1000_REG_MAG_DFR
);
1396 tempword
= inw(dev
->base_addr
+ FT1000_REG_SUP_STAT
);
1397 pr_debug("FT1000_REG_SUP_STAT = 0x%x\n", tempword
);
1398 tempword
= inw(dev
->base_addr
+ FT1000_REG_MAG_DFSR
);
1399 pr_debug("FT1000_REG_MAG_DFSR = 0x%x\n", tempword
);
1402 pcmcia
->PktIntfErr
++;
1405 /*---------------------------------------------------------------------------
1407 Function: ft1000_copy_up_pkt
1408 Description: This function will pull Flarion packets out of the Downlink
1409 FIFO and convert it to an ethernet packet. The ethernet packet will
1410 then be deliver to the TCP/IP stack.
1412 dev - device structure
1417 -------------------------------------------------------------------------*/
1418 static int ft1000_copy_up_pkt(struct net_device
*dev
)
1421 struct ft1000_info
*info
= netdev_priv(dev
);
1423 struct sk_buff
*skb
;
1432 if (info
->AsicID
== ELECTRABUZZ_ID
) {
1433 tempword
= ft1000_read_reg(dev
, FT1000_REG_DFIFO
);
1436 tempword
= ft1000_read_reg(dev
, FT1000_REG_MAG_DFRL
);
1437 len
= ntohs(tempword
);
1440 pr_debug("Number of Bytes in FIFO = %d\n", len
);
1442 if (len
> ENET_MAX_SIZE
) {
1443 pr_debug("size of ethernet packet invalid\n");
1444 if (info
->AsicID
== MAGNEMITE_ID
) {
1445 /* Read High word to complete 32 bit access */
1446 tempword
= ft1000_read_reg(dev
, FT1000_REG_MAG_DFRH
);
1448 ft1000_flush_fifo(dev
, DSP_PKTLEN_INFO
);
1449 info
->stats
.rx_errors
++;
1453 skb
= dev_alloc_skb(len
+ 12 + 2);
1456 /* Read High word to complete 32 bit access */
1457 if (info
->AsicID
== MAGNEMITE_ID
)
1458 tempword
= ft1000_read_reg(dev
, FT1000_REG_MAG_DFRH
);
1460 ft1000_flush_fifo(dev
, 0);
1461 info
->stats
.rx_errors
++;
1464 pbuffer
= (u8
*)skb_put(skb
, len
+ 12);
1467 if (info
->AsicID
== ELECTRABUZZ_ID
) {
1468 for (i
= 1; i
< 7; i
++) {
1469 tempword
= ft1000_read_reg(dev
, FT1000_REG_DFIFO
);
1472 /* read checksum value */
1473 tempword
= ft1000_read_reg(dev
, FT1000_REG_DFIFO
);
1475 tempword
= ft1000_read_reg(dev
, FT1000_REG_MAG_DFRH
);
1476 pr_debug("Pseudo = 0x%x\n", tempword
);
1479 tempword
= ft1000_read_reg(dev
, FT1000_REG_MAG_DFRL
);
1480 pr_debug("Pseudo = 0x%x\n", tempword
);
1483 tempword
= ft1000_read_reg(dev
, FT1000_REG_MAG_DFRH
);
1484 pr_debug("Pseudo = 0x%x\n", tempword
);
1487 tempword
= ft1000_read_reg(dev
, FT1000_REG_MAG_DFRL
);
1488 pr_debug("Pseudo = 0x%x\n", tempword
);
1491 tempword
= ft1000_read_reg(dev
, FT1000_REG_MAG_DFRH
);
1492 pr_debug("Pseudo = 0x%x\n", tempword
);
1495 tempword
= ft1000_read_reg(dev
, FT1000_REG_MAG_DFRL
);
1496 pr_debug("Pseudo = 0x%x\n", tempword
);
1499 /* read checksum value */
1500 tempword
= ft1000_read_reg(dev
, FT1000_REG_MAG_DFRH
);
1501 pr_debug("Pseudo = 0x%x\n", tempword
);
1504 if (chksum
!= tempword
) {
1505 pr_debug("Packet checksum mismatch 0x%x 0x%x\n",
1507 ft1000_flush_fifo(dev
, DSP_PKTPHCKSUM_INFO
);
1508 info
->stats
.rx_errors
++;
1512 /* subtract the number of bytes read already */
1515 /* fake MAC address */
1516 *pbuffer
++ = dev
->dev_addr
[0];
1517 *pbuffer
++ = dev
->dev_addr
[1];
1518 *pbuffer
++ = dev
->dev_addr
[2];
1519 *pbuffer
++ = dev
->dev_addr
[3];
1520 *pbuffer
++ = dev
->dev_addr
[4];
1521 *pbuffer
++ = dev
->dev_addr
[5];
1529 if (info
->AsicID
== ELECTRABUZZ_ID
) {
1530 for (i
= 0; i
< len
/ 2; i
++) {
1531 tempword
= ft1000_read_reg(dev
, FT1000_REG_DFIFO
);
1532 *pbuffer
++ = (u8
) (tempword
>> 8);
1533 *pbuffer
++ = (u8
)tempword
;
1534 if (ft1000_chkcard(dev
) == false) {
1540 /* Need to read one more word if odd byte */
1542 tempword
= ft1000_read_reg(dev
, FT1000_REG_DFIFO
);
1543 *pbuffer
++ = (u8
) (tempword
>> 8);
1546 ptemplong
= (u32
*)pbuffer
;
1547 for (i
= 0; i
< len
/ 4; i
++) {
1548 templong
= inl(dev
->base_addr
+ FT1000_REG_MAG_DFR
);
1549 pr_debug("Data = 0x%8x\n", templong
);
1550 *ptemplong
++ = templong
;
1553 /* Need to read one more word if odd align. */
1555 templong
= inl(dev
->base_addr
+ FT1000_REG_MAG_DFR
);
1556 pr_debug("Data = 0x%8x\n", templong
);
1557 *ptemplong
++ = templong
;
1562 pr_debug("Data passed to Protocol layer:\n");
1563 for (i
= 0; i
< len
+ 12; i
++)
1564 pr_debug("Protocol Data: 0x%x\n", *ptemp
++);
1567 skb
->protocol
= eth_type_trans(skb
, dev
);
1568 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1571 info
->stats
.rx_packets
++;
1572 /* Add on 12 bytes for MAC address which was removed */
1573 info
->stats
.rx_bytes
+= (len
+ 12);
1575 if (info
->AsicID
== ELECTRABUZZ_ID
) {
1576 /* track how many bytes have been read from FIFO - round up to
1578 tempword
= len
+ 16;
1579 if (tempword
& 0x01)
1581 info
->fifo_cnt
+= tempword
;
1582 ft1000_write_reg(dev
, FT1000_REG_DPRAM_ADDR
, FT1000_FIFO_LEN
);
1583 ft1000_write_reg(dev
, FT1000_REG_DPRAM_DATA
, info
->fifo_cnt
);
1589 /*---------------------------------------------------------------------------
1591 Function: ft1000_copy_down_pkt
1592 Description: This function will take an ethernet packet and convert it to
1593 a Flarion packet prior to sending it to the ASIC Downlink
1596 dev - device structure
1597 packet - address of ethernet packet
1598 len - length of IP packet
1603 -------------------------------------------------------------------------*/
1604 static int ft1000_copy_down_pkt(struct net_device
*dev
, u16
*packet
, u16 len
)
1606 struct ft1000_info
*info
= netdev_priv(dev
);
1607 struct ft1000_pcmcia
*pcmcia
= info
->priv
;
1609 struct pseudo_hdr blk
;
1610 u16 buff
[sizeof(struct pseudo_hdr
) >> 1];
1611 u8 buffc
[sizeof(struct pseudo_hdr
)];
1616 /* Check if there is room on the FIFO */
1617 if (len
> ft1000_read_fifo_len(dev
)) {
1619 if (len
> ft1000_read_fifo_len(dev
))
1621 if (len
> ft1000_read_fifo_len(dev
))
1623 if (len
> ft1000_read_fifo_len(dev
))
1625 if (len
> ft1000_read_fifo_len(dev
))
1627 if (len
> ft1000_read_fifo_len(dev
))
1629 if (len
> ft1000_read_fifo_len(dev
)) {
1630 pr_debug("Transmit FIFO is full - pkt drop\n");
1631 info
->stats
.tx_errors
++;
1635 /* Create pseudo header and send pseudo/ip to hardware */
1636 if (info
->AsicID
== ELECTRABUZZ_ID
)
1637 pseudo
.blk
.length
= len
;
1639 pseudo
.blk
.length
= ntohs(len
);
1641 pseudo
.blk
.source
= DSPID
; /* Need to swap to get in correct
1643 pseudo
.blk
.destination
= HOSTID
;
1644 pseudo
.blk
.portdest
= NETWORKID
; /* Need to swap to get in
1646 pseudo
.blk
.portsrc
= DSPAIRID
;
1647 pseudo
.blk
.sh_str_id
= 0;
1648 pseudo
.blk
.control
= 0;
1649 pseudo
.blk
.rsvd1
= 0;
1650 pseudo
.blk
.seq_num
= 0;
1651 pseudo
.blk
.rsvd2
= pcmcia
->packetseqnum
++;
1652 pseudo
.blk
.qos_class
= 0;
1653 /* Calculate pseudo header checksum */
1654 pseudo
.blk
.checksum
= pseudo
.buff
[0];
1655 for (i
= 1; i
< 7; i
++)
1656 pseudo
.blk
.checksum
^= pseudo
.buff
[i
];
1658 /* Production Mode */
1659 if (info
->AsicID
== ELECTRABUZZ_ID
) {
1660 /* copy first word to UFIFO_BEG reg */
1661 ft1000_write_reg(dev
, FT1000_REG_UFIFO_BEG
, pseudo
.buff
[0]);
1662 pr_debug("data 0 BEG = 0x%04x\n", pseudo
.buff
[0]);
1664 /* copy subsequent words to UFIFO_MID reg */
1665 ft1000_write_reg(dev
, FT1000_REG_UFIFO_MID
, pseudo
.buff
[1]);
1666 pr_debug("data 1 MID = 0x%04x\n", pseudo
.buff
[1]);
1667 ft1000_write_reg(dev
, FT1000_REG_UFIFO_MID
, pseudo
.buff
[2]);
1668 pr_debug("data 2 MID = 0x%04x\n", pseudo
.buff
[2]);
1669 ft1000_write_reg(dev
, FT1000_REG_UFIFO_MID
, pseudo
.buff
[3]);
1670 pr_debug("data 3 MID = 0x%04x\n", pseudo
.buff
[3]);
1671 ft1000_write_reg(dev
, FT1000_REG_UFIFO_MID
, pseudo
.buff
[4]);
1672 pr_debug("data 4 MID = 0x%04x\n", pseudo
.buff
[4]);
1673 ft1000_write_reg(dev
, FT1000_REG_UFIFO_MID
, pseudo
.buff
[5]);
1674 pr_debug("data 5 MID = 0x%04x\n", pseudo
.buff
[5]);
1675 ft1000_write_reg(dev
, FT1000_REG_UFIFO_MID
, pseudo
.buff
[6]);
1676 pr_debug("data 6 MID = 0x%04x\n", pseudo
.buff
[6]);
1677 ft1000_write_reg(dev
, FT1000_REG_UFIFO_MID
, pseudo
.buff
[7]);
1678 pr_debug("data 7 MID = 0x%04x\n", pseudo
.buff
[7]);
1680 /* Write PPP type + IP Packet into Downlink FIFO */
1681 for (i
= 0; i
< (len
>> 1) - 1; i
++) {
1682 ft1000_write_reg(dev
, FT1000_REG_UFIFO_MID
,
1684 pr_debug("data %d MID = 0x%04x\n",
1685 i
+ 8, htons(*packet
));
1689 /* Check for odd byte */
1691 ft1000_write_reg(dev
, FT1000_REG_UFIFO_MID
,
1693 pr_debug("data MID = 0x%04x\n", htons(*packet
));
1695 ft1000_write_reg(dev
, FT1000_REG_UFIFO_END
,
1697 pr_debug("data %d MID = 0x%04x\n",
1698 i
+ 8, htons(*packet
));
1700 ft1000_write_reg(dev
, FT1000_REG_UFIFO_END
,
1702 pr_debug("data %d MID = 0x%04x\n",
1703 i
+ 8, htons(*packet
));
1706 outl(*(u32
*)&pseudo
.buff
[0],
1707 dev
->base_addr
+ FT1000_REG_MAG_UFDR
);
1708 pr_debug("Pseudo = 0x%8x\n", *(u32
*)&pseudo
.buff
[0]);
1709 outl(*(u32
*)&pseudo
.buff
[2],
1710 dev
->base_addr
+ FT1000_REG_MAG_UFDR
);
1711 pr_debug("Pseudo = 0x%8x\n", *(u32
*)&pseudo
.buff
[2]);
1712 outl(*(u32
*)&pseudo
.buff
[4],
1713 dev
->base_addr
+ FT1000_REG_MAG_UFDR
);
1714 pr_debug("Pseudo = 0x%8x\n", *(u32
*)&pseudo
.buff
[4]);
1715 outl(*(u32
*)&pseudo
.buff
[6],
1716 dev
->base_addr
+ FT1000_REG_MAG_UFDR
);
1717 pr_debug("Pseudo = 0x%8x\n", *(u32
*)&pseudo
.buff
[6]);
1719 plong
= (u32
*)packet
;
1720 /* Write PPP type + IP Packet into Downlink FIFO */
1721 for (i
= 0; i
< (len
>> 2); i
++)
1722 outl(*plong
++, dev
->base_addr
+ FT1000_REG_MAG_UFDR
);
1724 /* Check for odd alignment */
1726 pr_debug("data = 0x%8x\n", *plong
);
1727 outl(*plong
++, dev
->base_addr
+ FT1000_REG_MAG_UFDR
);
1729 outl(1, dev
->base_addr
+ FT1000_REG_MAG_UFER
);
1732 info
->stats
.tx_packets
++;
1733 /* Add 14 bytes for MAC address plus ethernet type */
1734 info
->stats
.tx_bytes
+= (len
+ 14);
1738 static struct net_device_stats
*ft1000_stats(struct net_device
*dev
)
1740 struct ft1000_info
*info
= netdev_priv(dev
);
1742 return &info
->stats
;
1745 static int ft1000_open(struct net_device
*dev
)
1747 ft1000_reset_card(dev
);
1749 /* schedule ft1000_hbchk to perform periodic heartbeat checks on DSP
1751 init_timer(&poll_timer
);
1752 poll_timer
.expires
= jiffies
+ (2 * HZ
);
1753 poll_timer
.data
= (u_long
)dev
;
1754 add_timer(&poll_timer
);
1759 static int ft1000_close(struct net_device
*dev
)
1761 struct ft1000_info
*info
= netdev_priv(dev
);
1763 info
->CardReady
= 0;
1764 del_timer(&poll_timer
);
1766 if (ft1000_card_present
== 1) {
1767 pr_debug("Media is down\n");
1768 netif_stop_queue(dev
);
1770 ft1000_disable_interrupts(dev
);
1771 ft1000_write_reg(dev
, FT1000_REG_RESET
, DSP_RESET_BIT
);
1774 ft1000_reset_asic(dev
);
1779 static int ft1000_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1781 struct ft1000_info
*info
= netdev_priv(dev
);
1785 pr_debug("skb == NULL!!!\n");
1789 pr_debug("length of packet = %d\n", skb
->len
);
1791 pdata
= (u8
*)skb
->data
;
1793 if (info
->mediastate
== 0) {
1794 /* Drop packet is mediastate is down */
1795 pr_debug("mediastate is down\n");
1799 if ((skb
->len
< ENET_HEADER_SIZE
) || (skb
->len
> ENET_MAX_SIZE
)) {
1800 /* Drop packet which has invalid size */
1801 pr_debug("invalid ethernet length\n");
1804 ft1000_copy_down_pkt(dev
, (u16
*) (pdata
+ ENET_HEADER_SIZE
- 2),
1805 skb
->len
- ENET_HEADER_SIZE
+ 2);
1812 static irqreturn_t
ft1000_interrupt(int irq
, void *dev_id
)
1814 struct net_device
*dev
= dev_id
;
1815 struct ft1000_info
*info
= netdev_priv(dev
);
1820 if (info
->CardReady
== 0) {
1821 ft1000_disable_interrupts(dev
);
1825 if (ft1000_chkcard(dev
) == false) {
1826 ft1000_disable_interrupts(dev
);
1830 ft1000_disable_interrupts(dev
);
1832 /* Read interrupt type */
1833 inttype
= ft1000_read_reg(dev
, FT1000_REG_SUP_ISR
);
1835 /* Make sure we process all interrupt before leaving the ISR due to the
1836 * edge trigger interrupt type */
1838 if (inttype
& ISR_DOORBELL_PEND
)
1839 ft1000_parse_dpram_msg(dev
);
1841 if (inttype
& ISR_RCV
) {
1842 pr_debug("Data in FIFO\n");
1846 /* Check if we have packets in the Downlink
1848 if (info
->AsicID
== ELECTRABUZZ_ID
) {
1849 tempword
= ft1000_read_reg(dev
,
1850 FT1000_REG_DFIFO_STAT
);
1852 tempword
= ft1000_read_reg(dev
,
1853 FT1000_REG_MAG_DFSR
);
1855 if (!(tempword
& 0x1f))
1857 ft1000_copy_up_pkt(dev
);
1859 } while (cnt
< MAX_RCV_LOOP
);
1862 /* clear interrupts */
1863 tempword
= ft1000_read_reg(dev
, FT1000_REG_SUP_ISR
);
1864 pr_debug("interrupt status register = 0x%x\n", tempword
);
1865 ft1000_write_reg(dev
, FT1000_REG_SUP_ISR
, tempword
);
1867 /* Read interrupt type */
1868 inttype
= ft1000_read_reg(dev
, FT1000_REG_SUP_ISR
);
1869 pr_debug("interrupt status register after clear = 0x%x\n",
1872 ft1000_enable_interrupts(dev
);
1876 void stop_ft1000_card(struct net_device
*dev
)
1878 struct ft1000_info
*info
= netdev_priv(dev
);
1879 struct prov_record
*ptr
;
1880 struct prov_record
*tmp
;
1883 info
->CardReady
= 0;
1884 ft1000_card_present
= 0;
1885 netif_stop_queue(dev
);
1886 ft1000_disable_interrupts(dev
);
1888 /* Make sure we free any memory reserve for provisioning */
1889 list_for_each_entry_safe(ptr
, tmp
, &info
->prov_list
, list
) {
1890 list_del(&ptr
->list
);
1891 kfree(ptr
->pprov_data
);
1897 if (info
->registered
) {
1898 unregister_netdev(dev
);
1899 info
->registered
= 0;
1902 free_irq(dev
->irq
, dev
);
1903 release_region(dev
->base_addr
, 256);
1904 release_firmware(fw_entry
);
1905 flarion_ft1000_cnt
--;
1909 static void ft1000_get_drvinfo(struct net_device
*dev
,
1910 struct ethtool_drvinfo
*info
)
1912 struct ft1000_info
*ft_info
;
1914 ft_info
= netdev_priv(dev
);
1916 strlcpy(info
->driver
, "ft1000", sizeof(info
->driver
));
1917 snprintf(info
->bus_info
, sizeof(info
->bus_info
), "PCMCIA 0x%lx",
1919 snprintf(info
->fw_version
, sizeof(info
->fw_version
), "%d.%d.%d.%d",
1920 ft_info
->DspVer
[0], ft_info
->DspVer
[1], ft_info
->DspVer
[2],
1921 ft_info
->DspVer
[3]);
1924 static u32
ft1000_get_link(struct net_device
*dev
)
1926 struct ft1000_info
*info
;
1928 info
= netdev_priv(dev
);
1929 return info
->mediastate
;
1932 static const struct ethtool_ops ops
= {
1933 .get_drvinfo
= ft1000_get_drvinfo
,
1934 .get_link
= ft1000_get_link
1937 struct net_device
*init_ft1000_card(struct pcmcia_device
*link
,
1940 struct ft1000_info
*info
;
1941 struct ft1000_pcmcia
*pcmcia
;
1942 struct net_device
*dev
;
1944 static const struct net_device_ops ft1000ops
= {
1945 .ndo_open
= &ft1000_open
,
1946 .ndo_stop
= &ft1000_close
,
1947 .ndo_start_xmit
= &ft1000_start_xmit
,
1948 .ndo_get_stats
= &ft1000_stats
,
1951 pr_debug("irq = %d, port = 0x%04llx\n",
1952 link
->irq
, (unsigned long long)link
->resource
[0]->start
);
1954 flarion_ft1000_cnt
++;
1956 if (flarion_ft1000_cnt
> 1) {
1957 flarion_ft1000_cnt
--;
1959 dev_info(&link
->dev
,
1960 "This driver can not support more than one instance\n");
1964 dev
= alloc_etherdev(sizeof(struct ft1000_info
));
1966 dev_err(&link
->dev
, "Failed to allocate etherdev\n");
1970 SET_NETDEV_DEV(dev
, &link
->dev
);
1971 info
= netdev_priv(dev
);
1973 memset(info
, 0, sizeof(struct ft1000_info
));
1975 pr_debug("address of dev = 0x%p\n", dev
);
1976 pr_debug("address of dev info = 0x%p\n", info
);
1977 pr_debug("device name = %s\n", dev
->name
);
1979 memset(&info
->stats
, 0, sizeof(struct net_device_stats
));
1981 info
->priv
= kzalloc(sizeof(struct ft1000_pcmcia
), GFP_KERNEL
);
1982 pcmcia
= info
->priv
;
1983 pcmcia
->link
= link
;
1985 spin_lock_init(&info
->dpram_lock
);
1986 info
->DrvErrNum
= 0;
1987 info
->registered
= 1;
1988 info
->ft1000_reset
= ft1000_reset
;
1989 info
->mediastate
= 0;
1991 info
->CardReady
= 0;
1992 info
->DSP_TIME
[0] = 0;
1993 info
->DSP_TIME
[1] = 0;
1994 info
->DSP_TIME
[2] = 0;
1995 info
->DSP_TIME
[3] = 0;
1996 flarion_ft1000_cnt
= 0;
1998 INIT_LIST_HEAD(&info
->prov_list
);
2000 info
->squeseqnum
= 0;
2002 /* dev->hard_start_xmit = &ft1000_start_xmit; */
2003 /* dev->get_stats = &ft1000_stats; */
2004 /* dev->open = &ft1000_open; */
2005 /* dev->stop = &ft1000_close; */
2007 dev
->netdev_ops
= &ft1000ops
;
2009 pr_debug("device name = %s\n", dev
->name
);
2011 dev
->irq
= link
->irq
;
2012 dev
->base_addr
= link
->resource
[0]->start
;
2013 if (pcmcia_get_mac_from_cis(link
, dev
)) {
2014 netdev_err(dev
, "Could not read mac address\n");
2018 if (request_irq(dev
->irq
, ft1000_interrupt
, IRQF_SHARED
, dev
->name
,
2020 netdev_err(dev
, "Could not request_irq\n");
2024 if (request_region(dev
->base_addr
, 256, dev
->name
) == NULL
) {
2025 netdev_err(dev
, "Could not request_region\n");
2029 if (register_netdev(dev
)) {
2030 pr_debug("Could not register netdev\n");
2034 info
->AsicID
= ft1000_read_reg(dev
, FT1000_REG_ASIC_ID
);
2035 if (info
->AsicID
== ELECTRABUZZ_ID
) {
2036 pr_debug("ELECTRABUZZ ASIC\n");
2037 if (request_firmware(&fw_entry
, "ft1000.img",
2039 pr_info("Could not open ft1000.img\n");
2043 pr_debug("MAGNEMITE ASIC\n");
2044 if (request_firmware(&fw_entry
, "ft2000.img",
2046 pr_info("Could not open ft2000.img\n");
2051 ft1000_enable_interrupts(dev
);
2053 ft1000_card_present
= 1;
2054 dev
->ethtool_ops
= &ops
;
2055 pr_info("%s: addr 0x%04lx irq %d, MAC addr %pM\n",
2056 dev
->name
, dev
->base_addr
, dev
->irq
, dev
->dev_addr
);
2060 unregister_netdev(dev
);
2062 release_region(dev
->base_addr
, 256);
2064 free_irq(dev
->irq
, dev
);