Staging: ft1000: remove trailing whitespace

Lots of trailing whitespace was removed

Cc: Marek Belisko <marek.belisko@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

drivers/staging/ft1000/Kconfig

@@ -5,7 +5,7 @@ if FT1000
 
 config FT1000_USB
 	tristate "Driver for ft1000 usb devices."
-	depends on USB 
+	depends on USB
 	depends on NET
 	help
 	  Say Y if you want to have support for Qleadtek FLASH-OFDM USB Modem [LR7F04],
@@ -13,7 +13,7 @@ config FT1000_USB
 
 config FT1000_PCMCIA
 	tristate "Driver for ft1000 pcmcia device."
-	depends on PCMCIA 
+	depends on PCMCIA
 	depends on NET
 	help
 	  Say Y if you want to have support for Flarion card also called

drivers/staging/ft1000/ft1000-pcmcia/boot.h

@@ -3,21 +3,21 @@
 //
 // Copyright (C) 2002 Flarion Technologies, All rights reserved.
 //
-// This program is free software; you can redistribute it and/or modify it 
+// This program is free software; you can redistribute it and/or modify it
 // under the terms of the GNU General Public License as published by the Free
-// Software Foundation; either version 2 of the License, or (at your option) any 
-// later version. This program is distributed in the hope that it will be useful, 
-// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
-// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
-// more details. You should have received a copy of the GNU General Public 
-// License along with this program; if not, write to the 
-// Free Software Foundation, Inc., 59 Temple Place - 
-// Suite 330, Boston, MA 02111-1307, USA. 
+// Software Foundation; either version 2 of the License, or (at your option) any
+// later version. This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+// more details. You should have received a copy of the GNU General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place -
+// Suite 330, Boston, MA 02111-1307, USA.
 //---------------------------------------------------------------------------
 //
 // File:         boot.h
 //
-// Description:    boatloader 
+// Description:    boatloader
 //
 // History:
 // 1/11/05    Whc                Ported to Linux.
@@ -27,7 +27,7 @@
 #define _BOOTH_
 
 // Official bootloader
-unsigned char bootimage [] = { 
+unsigned char bootimage [] = {
 0x00,0x00,0x01,0x5E,0x00,0x00
 ,0x00,0x00,0x00,0x00,0x02,0xD7
 ,0x00,0x00,0x01,0x5E,0x46,0xB3
@@ -152,7 +152,7 @@ unsigned char bootimage [] = {
 ,0x01,0x00,0x00,0xAE,0x62,0xE4
 ,0xE5,0x61,0x04,0x48,0x04,0xE5
 ,0x63,0x05,0x48,0x04,0x20,0x20
-,0x00,0x00,0x00,0x00 
-}; 
+,0x00,0x00,0x00,0x00
+};
 
 #endif

drivers/staging/ft1000/ft1000-pcmcia/ft1000.h

@@ -3,16 +3,16 @@
 //
 // Copyright (C) 2002 Flarion Technologies, All rights reserved.
 //
-// This program is free software; you can redistribute it and/or modify it 
+// This program is free software; you can redistribute it and/or modify it
 // under the terms of the GNU General Public License as published by the Free
-// Software Foundation; either version 2 of the License, or (at your option) any 
-// later version. This program is distributed in the hope that it will be useful, 
-// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
-// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
-// more details. You should have received a copy of the GNU General Public 
-// License along with this program; if not, write to the 
-// Free Software Foundation, Inc., 59 Temple Place - 
-// Suite 330, Boston, MA 02111-1307, USA. 
+// Software Foundation; either version 2 of the License, or (at your option) any
+// later version. This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+// more details. You should have received a copy of the GNU General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place -
+// Suite 330, Boston, MA 02111-1307, USA.
 //---------------------------------------------------------------------------
 //
 // File:         ft1000.h
@@ -41,7 +41,7 @@
 #define CALVERSZ                2
 #define CALDATESZ               6
 
-// Pseudo Header structure 
+// Pseudo Header structure
 typedef struct _PSEUDO_HDR
 {
    unsigned short    length;        // length of msg body
@@ -58,7 +58,7 @@ typedef struct _PSEUDO_HDR
                                     //    Dsp Loader = 0xa0
                                     //    Dsp MIP = 0xb0
    unsigned char     portsrc;       // software source port id (refer to portdest)
-   unsigned short    sh_str_id;     // not used 
+   unsigned short    sh_str_id;     // not used
    unsigned char     control;       // not used
    unsigned char     rsvd1;
    unsigned char     seq_num;       // message sequence number
@@ -78,7 +78,7 @@ typedef struct _PSEUDO_HDR
 #define PCHAR                u8 *
 #define UINT                 u32
 
-#define ELECTRABUZZ_ID       0          // ASIC ID for Electrabuzz 
+#define ELECTRABUZZ_ID       0          // ASIC ID for Electrabuzz
 #define MAGNEMITE_ID         0x1a01     // ASIC ID for Magnemite
 
 // MEMORY MAP common to both ELECTRABUZZ and MAGNEMITE
@@ -89,7 +89,7 @@ typedef struct _PSEUDO_HDR
 #define	FT1000_REG_SUP_ISR		0x0026	// HISR - Host Interrupt Status Register
 #define	FT1000_REG_SUP_IMASK	0x0028	// HIMASK - Host Interrupt Mask
 #define	FT1000_REG_DOORBELL		0x002a	// DBELL - Door Bell Register
-#define FT1000_REG_ASIC_ID      0x002e  // ASICID - ASIC Identification Number 
+#define FT1000_REG_ASIC_ID      0x002e  // ASICID - ASIC Identification Number
                                         // (Electrabuzz=0 Magnemite=0x1A01)
 
 // MEMORY MAP FOR ELECTRABUZZ ASIC
@@ -113,10 +113,10 @@ typedef struct _PSEUDO_HDR
 #define FT1000_REG_MAG_DFRL     0x0008  // DFRL - Downlink FIFO Register low-word (16-bits)
 #define FT1000_REG_MAG_DFRH     0x000a  // DFRH - Downlink FIFO Register high-word (16-bits)
 #define FT1000_REG_MAG_DFSR     0x000c  // DFSR - Downlink FIFO Status Register
-#define FT1000_REG_MAG_DPDATA   0x0010  // DPDATA - Dual Port RAM Indirect Data Register (32-bits) 
+#define FT1000_REG_MAG_DPDATA   0x0010  // DPDATA - Dual Port RAM Indirect Data Register (32-bits)
 #define FT1000_REG_MAG_DPDATAL  0x0010  // DPDATAL - Dual Port RAM Indirect Data Register low-word (16-bits)
 #define FT1000_REG_MAG_DPDATAH  0x0012  // DPDATAH - Dual Port RAM Indirect Data Register high-word (16-bits)
-#define	FT1000_REG_MAG_WATERMARK 0x002c	// WMARK - Watermark Register 
+#define	FT1000_REG_MAG_WATERMARK 0x002c	// WMARK - Watermark Register
 
 // Reserved Dual Port RAM offsets for Electrabuzz
 #define FT1000_DPRAM_TX_BASE	0x0002	// Host to PC Card Messaging Area
@@ -136,7 +136,7 @@ typedef struct _PSEUDO_HDR
 #define FT1000_DPRAM_MAG_TX_BASE		 0x0000	 //  Host to PC Card Messaging Area
 #define FT1000_DPRAM_MAG_RX_BASE		 0x0200	 //  PC Card to Host Messaging Area
 #define FT1000_MAG_FIFO_LEN              0x1FF   // total length for DSP FIFO tracking
-#define FT1000_MAG_FIFO_LEN_INDX         0x1     // low-word index 
+#define FT1000_MAG_FIFO_LEN_INDX         0x1     // low-word index
 #define FT1000_MAG_HI_HO                 0x1FF   // heartbeat with HI/HO
 #define FT1000_MAG_HI_HO_INDX            0x0     // high-word index
 #define FT1000_MAG_DSP_LED               0x3FE   // dsp led status for PAD device
@@ -161,7 +161,7 @@ typedef struct _PSEUDO_HDR
 #define FT1000_MAG_DSP_TIMER3_INDX       0x0
 
 #define FT1000_MAG_TOTAL_LEN             0x200
-#define FT1000_MAG_TOTAL_LEN_INDX        0x1    
+#define FT1000_MAG_TOTAL_LEN_INDX        0x1
 
 #define FT1000_MAG_PH_LEN                0x200
 #define FT1000_MAG_PH_LEN_INDX           0x0
@@ -173,17 +173,17 @@ typedef struct _PSEUDO_HDR
 #define HOST_INTF_BE                     0x1     // Host interface big endian mode
 
 // PC Card to Host Doorbell assignments
-#define FT1000_DB_DPRAM_RX		0x0001	// this value indicates that DSP has 
-                                        //      data for host in DPRAM 
+#define FT1000_DB_DPRAM_RX		0x0001	// this value indicates that DSP has
+                                        //      data for host in DPRAM
 #define FT1000_ASIC_RESET_REQ   0x0004  // DSP requesting host to reset the ASIC
 #define FT1000_DSP_ASIC_RESET   0x0008  // DSP indicating host that it will reset the ASIC
 #define FT1000_DB_COND_RESET    0x0010  // DSP request for a card reset.
 
 // Host to PC Card Doorbell assignments
-#define FT1000_DB_DPRAM_TX		0x0100	// this value indicates that host has 
-                                        //      data for DSP in DPRAM. 
+#define FT1000_DB_DPRAM_TX		0x0100	// this value indicates that host has
+                                        //      data for DSP in DPRAM.
 #define FT1000_ASIC_RESET_DSP   0x0400  // Responds to FT1000_ASIC_RESET_REQ
-#define FT1000_DB_HB            0x1000  // Indicates that supervisor 
+#define FT1000_DB_HB            0x1000  // Indicates that supervisor
                                         //      has a heartbeat message for DSP.
 
 #define FT1000_DPRAM_BASE		0x0000	// Dual Port RAM starting offset
@@ -201,27 +201,27 @@ typedef struct _PSEUDO_HDR
 // Indicate the cause of an interrupt.
 //
 #define ISR_EMPTY				0x00	  // no bits set
-#define ISR_DOORBELL_ACK		0x01	  // Doorbell acknowledge from DSP	   
+#define ISR_DOORBELL_ACK		0x01	  // Doorbell acknowledge from DSP
 #define ISR_DOORBELL_PEND		0x02	  // Doorbell pending from DSP
 #define ISR_RCV					0x04	  // Packet available in Downlink FIFO
-#define ISR_WATERMARK			0x08	  // Watermark requirements satisfied 
+#define ISR_WATERMARK			0x08	  // Watermark requirements satisfied
 
 // Bit field definition for Host Interrupt Mask
 #define ISR_MASK_NONE			0x0000	  // no bits set
 #define ISR_MASK_DOORBELL_ACK	0x0001	  // Doorbell acknowledge mask
 #define ISR_MASK_DOORBELL_PEND	0x0002	  // Doorbell pending mask
 #define ISR_MASK_RCV			0x0004	  // Downlink Packet available mask
-#define ISR_MASK_WATERMARK		0x0008	  // Watermark interrupt mask 
+#define ISR_MASK_WATERMARK		0x0008	  // Watermark interrupt mask
 #define ISR_MASK_ALL			0xffff    // Mask all interrupts
 
 // Bit field definition for Host Control Register
 #define DSP_RESET_BIT           0x0001    // Bit field to control dsp reset state
                                           // (0 = out of reset 1 = reset)
 #define ASIC_RESET_BIT          0x0002    // Bit field to control ASIC reset state
-                                          // (0 = out of reset 1 = reset) 
+                                          // (0 = out of reset 1 = reset)
 
-// Default interrupt mask (Enable Doorbell pending and Packet available interrupts) 
-#define ISR_DEFAULT_MASK		0x7ff9		
+// Default interrupt mask (Enable Doorbell pending and Packet available interrupts)
+#define ISR_DEFAULT_MASK		0x7ff9
 
 // Application specific IDs
 #define DSPID                   0x20
@@ -241,7 +241,7 @@ typedef struct _PSEUDO_HDR
 
 #define MAX_DSP_SESS_REC        1024
 
-#define DSP_QID_OFFSET          4     
+#define DSP_QID_OFFSET          4
 #define PSEUDOSZ                16
 #define PSEUDOSZWRD             8
 
@@ -299,7 +299,7 @@ typedef struct _MEDIAMSG {
 	u16 state;
 	u32 ip_addr;
     u32 net_mask;
-	u32 gateway;  
+	u32 gateway;
 	u32 dns_1;
 	u32 dns_2;
 } __attribute__ ((packed)) MEDIAMSG, *PMEDIAMSG;

drivers/staging/ft1000/ft1000-pcmcia/ft1000_cs.c

@@ -13,7 +13,7 @@
    by Wai Chan (w.chan@flarion.com).
 
    Port for kernel 2.6 created by Patrik Ostrihon (patrik.ostrihon@pwc.sk)
-  
+
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the Free
    Software Foundation; either version 2 of the License, or (at your option) any
@@ -182,7 +182,7 @@ static int get_tuple_next(struct pcmcia_device *link, tuple_t * tuple,
 
 /*======================================================================
 
-    
+
 ======================================================================*/
 
 static int ft1000_attach(struct pcmcia_device *link)
@@ -247,7 +247,7 @@ static void ft1000_detach(struct pcmcia_device *link)
     ft1000_config() is scheduled to run after a CARD_INSERTION event
     is received, to configure the PCMCIA socket, and to make the
     device available to the system.
-    
+
 ======================================================================*/
 
 #define CS_CHECK(fn, ret) \
@@ -348,7 +348,7 @@ static int ft1000_config(struct pcmcia_device * link)
 	if (last_ret != CS_SUCCESS) {
 		cs_error(link, RequestIO, last_ret);
 		goto failed;
-	}  
+	}
 
 	/*
 	   Allocate an interrupt line.  Note that this does not assign a
@@ -415,7 +415,7 @@ failed:
     After a card is removed, ft1000_release() will unregister the
     device, and release the PCMCIA configuration.  If the device is
     still open, this will be postponed until it is closed.
-    
+
 ======================================================================*/
 
 static void ft1000_release(struct pcmcia_device * link)
@@ -434,7 +434,7 @@ static void ft1000_release(struct pcmcia_device * link)
 
 	/*
 	   In a normal driver, additional code may be needed to release
-	   other kernel data structures associated with this device. 
+	   other kernel data structures associated with this device.
 	 */
 
 	/* Don't bother checking to see if these succeed or not */
@@ -451,7 +451,7 @@ static void ft1000_release(struct pcmcia_device * link)
     private flag to block future accesses to this device.  All the
     functions that actually access the device should check this flag
     to make sure the card is still present.
-    
+
 ======================================================================*/
 
 static int ft1000_suspend(struct pcmcia_device *link)

drivers/staging/ft1000/ft1000-pcmcia/ft1000_dev.h

@@ -3,16 +3,16 @@
 //
 // Copyright (C) 2002 Flarion Technologies, All rights reserved.
 //
-// This program is free software; you can redistribute it and/or modify it 
+// This program is free software; you can redistribute it and/or modify it
 // under the terms of the GNU General Public License as published by the Free
-// Software Foundation; either version 2 of the License, or (at your option) any 
-// later version. This program is distributed in the hope that it will be useful, 
-// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
-// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
-// more details. You should have received a copy of the GNU General Public 
-// License along with this program; if not, write to the 
-// Free Software Foundation, Inc., 59 Temple Place - 
-// Suite 330, Boston, MA 02111-1307, USA. 
+// Software Foundation; either version 2 of the License, or (at your option) any
+// later version. This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+// more details. You should have received a copy of the GNU General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place -
+// Suite 330, Boston, MA 02111-1307, USA.
 //---------------------------------------------------------------------------
 //
 // File:         ft1000_dev.h

drivers/staging/ft1000/ft1000-pcmcia/ft1000_dnld.c

@@ -1,23 +1,23 @@
 /*---------------------------------------------------------------------------
    FT1000 driver for Flarion Flash OFDM NIC Device
-  
+
    Copyright (C) 2002 Flarion Technologies, All rights reserved.
-  
-   This program is free software; you can redistribute it and/or modify it 
+
+   This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the Free
-   Software Foundation; either version 2 of the License, or (at your option) any 
-   later version. This program is distributed in the hope that it will be useful, 
-   but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
-   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
-   more details. You should have received a copy of the GNU General Public 
-   License along with this program; if not, write to the 
-   Free Software Foundation, Inc., 59 Temple Place - 
-   Suite 330, Boston, MA 02111-1307, USA. 
+   Software Foundation; either version 2 of the License, or (at your option) any
+   later version. This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+   more details. You should have received a copy of the GNU General Public
+   License along with this program; if not, write to the
+   Free Software Foundation, Inc., 59 Temple Place -
+   Suite 330, Boston, MA 02111-1307, USA.
   --------------------------------------------------------------------------
 
-   Description:  This module will handshake with the DSP bootloader to 
+   Description:  This module will handshake with the DSP bootloader to
                  download the DSP runtime image.
-  
+
 ---------------------------------------------------------------------------*/
 
 #define __KERNEL_SYSCALLS__
@@ -890,7 +890,7 @@ int card_download(struct net_device *dev, void *pFileStart, UINT FileLength)
 					memcpy(pbuffer, (void *)pUcFile,
 						   (UINT) (usHdrLength +
 							   sizeof(PSEUDO_HDR)));
-					// link provisioning data 
+					// link provisioning data
 					pprov_record =
 						kmalloc(sizeof(PROV_RECORD),
 							GFP_ATOMIC);

drivers/staging/ft1000/ft1000-pcmcia/ft1000_hw.c

@@ -1,20 +1,20 @@
 /*---------------------------------------------------------------------------
    FT1000 driver for Flarion Flash OFDM NIC Device
-  
+
    Copyright (C) 2002 Flarion Technologies, All rights reserved.
    Copyright (C) 2006 Patrik Ostrihon, All rights reserved.
    Copyright (C) 2006 ProWeb Consulting, a.s, All rights reserved.
-  
-   This program is free software; you can redistribute it and/or modify it 
+
+   This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the Free
-   Software Foundation; either version 2 of the License, or (at your option) any 
-   later version. This program is distributed in the hope that it will be useful, 
-   but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
-   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
-   more details. You should have received a copy of the GNU General Public 
-   License along with this program; if not, write to the 
-   Free Software Foundation, Inc., 59 Temple Place - 
-   Suite 330, Boston, MA 02111-1307, USA. 
+   Software Foundation; either version 2 of the License, or (at your option) any
+   later version. This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+   more details. You should have received a copy of the GNU General Public
+   License along with this program; if not, write to the
+   Free Software Foundation, Inc., 59 Temple Place -
+   Suite 330, Boston, MA 02111-1307, USA.
 -----------------------------------------------------------------------------*/
 
 #include <linux/kernel.h>
@@ -86,7 +86,7 @@ MODULE_SUPPORTED_DEVICE("FT1000");
 //---------------------------------------------------------------------------
 //
 // Function:   ft1000_asic_read
-// Descripton: This function will retrieve the value of a specific ASIC 
+// Descripton: This function will retrieve the value of a specific ASIC
 //             register.
 // Input:
 //    dev - network device structure
@@ -120,7 +120,7 @@ inline void ft1000_asic_write(struct net_device *dev, u16 offset, u16 value)
 //---------------------------------------------------------------------------
 //
 // Function:   ft1000_read_fifo_len
-// Descripton: This function will read the ASIC Uplink FIFO status register 
+// Descripton: This function will read the ASIC Uplink FIFO status register
 //             which will return the number of bytes remaining in the Uplink FIFO.
 //             Sixteen bytes are subtracted to make sure that the ASIC does not
 //             reach its threshold.
@@ -409,7 +409,7 @@ static void ft1000_reset_asic(struct net_device *dev)
 //     dev    - device structure
 // Output:
 //     status - FALSE (card reset fail)
-//              TRUE  (card reset successful) 
+//              TRUE  (card reset successful)
 //
 //---------------------------------------------------------------------------
 static int ft1000_reset_card(struct net_device *dev)
@@ -449,7 +449,7 @@ static int ft1000_reset_card(struct net_device *dev)
 				 (DSP_RESET_BIT | ASIC_RESET_BIT));
 	}
 
-	// Copy DSP session record into info block if this is not a coldstart    
+	// Copy DSP session record into info block if this is not a coldstart
 	if (ft1000_card_present == 1) {
 		spin_lock_irqsave(&info->dpram_lock, flags);
 		if (info->AsicID == ELECTRABUZZ_ID) {
@@ -573,7 +573,7 @@ static int ft1000_reset_card(struct net_device *dev)
 //     dev    - device structure
 // Output:
 //     status - FALSE (device is not present)
-//              TRUE  (device is present) 
+//              TRUE  (device is present)
 //
 //---------------------------------------------------------------------------
 static int ft1000_chkcard(struct net_device *dev)
@@ -640,7 +640,7 @@ static void ft1000_hbchk(u_long data)
 			else {
 				tempword = ntohs(ft1000_read_dpram_mag_16(dev, FT1000_MAG_HI_HO, FT1000_MAG_HI_HO_INDX));
 			}
-		} 
+		}
 		if (tempword != ho) {
 			printk(KERN_INFO
 				   "ft1000: heartbeat failed - no ho detected\n");
@@ -689,7 +689,7 @@ static void ft1000_hbchk(u_long data)
 		// Let's check doorbell again if fail
 		if (tempword & FT1000_DB_HB) {
 			tempword = ft1000_read_reg(dev, FT1000_REG_DOORBELL);
-		} 
+		}
 		if (tempword & FT1000_DB_HB) {
 			printk(KERN_INFO
 				   "ft1000: heartbeat doorbell not clear by firmware\n");
@@ -733,7 +733,7 @@ static void ft1000_hbchk(u_long data)
 			add_timer(&poll_timer);
 			return;
 		}
-		// Set dedicated area to hi and ring appropriate doorbell according 
+		// Set dedicated area to hi and ring appropriate doorbell according
 		// to hi/ho heartbeat protocol
 		if (info->AsicID == ELECTRABUZZ_ID) {
 			ft1000_write_dpram(dev, FT1000_HI_HO, hi);
@@ -765,9 +765,9 @@ static void ft1000_hbchk(u_long data)
 			else {
 				tempword = ntohs(ft1000_read_dpram_mag_16(dev, FT1000_MAG_HI_HO, FT1000_MAG_HI_HO_INDX));
 			}
-			
+
 		}
-							
+
 		if (tempword != hi) {
 			printk(KERN_INFO
 				   "ft1000: heartbeat failed - cannot write hi into DPRAM\n");
@@ -824,7 +824,7 @@ static void ft1000_hbchk(u_long data)
 //---------------------------------------------------------------------------
 //
 // Function:   ft1000_send_cmd
-// Descripton: 
+// Descripton:
 // Input:
 // Output:
 //
@@ -904,7 +904,7 @@ void ft1000_send_cmd (struct net_device *dev, u16 *ptempbuffer, int size, u16 qt
 //---------------------------------------------------------------------------
 //
 // Function:   ft1000_receive_cmd
-// Descripton: This function will read a message from the dpram area. 
+// Descripton: This function will read a message from the dpram area.
 // Input:
 //    dev - network device structure
 //    pbuffer - caller supply address to buffer
@@ -1105,7 +1105,7 @@ void ft1000_proc_drvmsg(struct net_device *dev)
 					netif_carrier_off(dev);
 					netif_stop_queue(dev);
 					info->ConTm = 0;
-				} 
+				}
 			}
             }
             else {
@@ -1196,7 +1196,7 @@ void ft1000_proc_drvmsg(struct net_device *dev)
 				ppseudo_hdr->qos_class = 0;
 				// Insert slow queue sequence number
 				ppseudo_hdr->seq_num = info->squeseqnum++;
-				// Insert application id 
+				// Insert application id
 				ppseudo_hdr->portsrc = 0;
 				// Calculate new checksum
 				ppseudo_hdr->checksum = *pmsg++;
@@ -1244,7 +1244,7 @@ void ft1000_proc_drvmsg(struct net_device *dev)
 				ppseudo_hdr->qos_class = 0;
 				// Insert slow queue sequence number
 				ppseudo_hdr->seq_num = info->squeseqnum++;
-				// Insert application id 
+				// Insert application id
 				ppseudo_hdr->portsrc = 0;
 				// Calculate new checksum
                 ppseudo_hdr->checksum = *pmsg++;
@@ -1286,8 +1286,8 @@ void ft1000_proc_drvmsg(struct net_device *dev)
 // Input:
 //     dev    - device structure
 // Output:
-//     status - FAILURE 
-//              SUCCESS 
+//     status - FAILURE
+//              SUCCESS
 //
 //---------------------------------------------------------------------------
 int ft1000_parse_dpram_msg(struct net_device *dev)
@@ -1392,7 +1392,7 @@ int ft1000_parse_dpram_msg(struct net_device *dev)
 	}
 
 	if (doorbell & FT1000_DB_COND_RESET) {
-		// Reset ASIC and DSP        
+		// Reset ASIC and DSP
 		if (info->AsicID == ELECTRABUZZ_ID) {
 			info->DSP_TIME[0] =
 				ft1000_read_dpram(dev, FT1000_DSP_TIMER0);
@@ -1583,14 +1583,14 @@ static void ft1000_flush_fifo(struct net_device *dev, u16 DrvErrNum)
 //---------------------------------------------------------------------------
 //
 // Function:   ft1000_copy_up_pkt
-// Descripton: This function will pull Flarion packets out of the Downlink   
+// Descripton: This function will pull Flarion packets out of the Downlink
 //             FIFO and convert it to an ethernet packet.  The ethernet packet will
 //             then be deliver to the TCP/IP stack.
 // Input:
 //     dev    - device structure
 // Output:
-//     status - FAILURE 
-//              SUCCESS 
+//     status - FAILURE
+//              SUCCESS
 //
 //---------------------------------------------------------------------------
 int ft1000_copy_up_pkt(struct net_device *dev)
@@ -1767,16 +1767,16 @@ int ft1000_copy_up_pkt(struct net_device *dev)
 //---------------------------------------------------------------------------
 //
 // Function:   ft1000_copy_down_pkt
-// Descripton: This function will take an ethernet packet and convert it to  
-//             a Flarion packet prior to sending it to the ASIC Downlink 
+// Descripton: This function will take an ethernet packet and convert it to
+//             a Flarion packet prior to sending it to the ASIC Downlink
 //             FIFO.
 // Input:
 //     dev    - device structure
 //     packet - address of ethernet packet
 //     len    - length of IP packet
 // Output:
-//     status - FAILURE 
-//              SUCCESS 
+//     status - FAILURE
+//              SUCCESS
 //
 //---------------------------------------------------------------------------
 int ft1000_copy_down_pkt(struct net_device *dev, u16 * packet, u16 len)
@@ -1792,7 +1792,7 @@ int ft1000_copy_down_pkt(struct net_device *dev, u16 * packet, u16 len)
 
 	DEBUG(1, "ft1000_hw: copy_down_pkt()\n");
 
-	// Check if there is room on the FIFO 
+	// Check if there is room on the FIFO
 	if (len > ft1000_read_fifo_len(dev)) {
 		udelay(10);
 		if (len > ft1000_read_fifo_len(dev)) {
@@ -1841,12 +1841,12 @@ int ft1000_copy_down_pkt(struct net_device *dev, u16 * packet, u16 len)
 
 	// Production Mode
 	if (info->AsicID == ELECTRABUZZ_ID) {
-		// copy first word to UFIFO_BEG reg 
+		// copy first word to UFIFO_BEG reg
 		ft1000_write_reg(dev, FT1000_REG_UFIFO_BEG, pseudo.buff[0]);
 		DEBUG(1, "ft1000_hw:ft1000_copy_down_pkt:data 0 BEG = 0x%04x\n",
 			  pseudo.buff[0]);
 
-		// copy subsequent words to UFIFO_MID reg 
+		// copy subsequent words to UFIFO_MID reg
 		ft1000_write_reg(dev, FT1000_REG_UFIFO_MID, pseudo.buff[1]);
 		DEBUG(1, "ft1000_hw:ft1000_copy_down_pkt:data 1 MID = 0x%04x\n",
 			  pseudo.buff[1]);
@@ -1879,7 +1879,7 @@ int ft1000_copy_down_pkt(struct net_device *dev, u16 * packet, u16 len)
 			packet++;
 		}
 
-		// Check for odd byte 
+		// Check for odd byte
 		if (len & 0x0001) {
 			ft1000_write_reg(dev, FT1000_REG_UFIFO_MID,
 					 htons(*packet));
@@ -1923,7 +1923,7 @@ int ft1000_copy_down_pkt(struct net_device *dev, u16 * packet, u16 len)
 			outl(*plong++, dev->base_addr + FT1000_REG_MAG_UFDR);
 		}
 
-		// Check for odd alignment 
+		// Check for odd alignment
 		if (len & 0x0003) {
 			DEBUG(1,
 				  "ft1000_hw:ft1000_copy_down_pkt:data = 0x%8x\n",

drivers/staging/ft1000/ft1000-pcmcia/ft1000_proc.c

@@ -1,9 +1,9 @@
 /*---------------------------------------------------------------------------
    FT1000 driver for Flarion Flash OFDM NIC Device
-  
+
    Copyright (C) 2006 Patrik Ostrihon, All rights reserved.
    Copyright (C) 2006 ProWeb Consulting, a.s, All rights reserved.
-  
+
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the Free
    Software Foundation; either version 2 of the License, or (at your option) any

drivers/staging/ft1000/ft1000-usb/ft1000_chdev.c

@@ -3,16 +3,16 @@
 //
 // Copyright (C) 2006 Flarion Technologies, All rights reserved.
 //
-// This program is free software; you can redistribute it and/or modify it 
+// This program is free software; you can redistribute it and/or modify it
 // under the terms of the GNU General Public License as published by the Free
-// Software Foundation; either version 2 of the License, or (at your option) any 
-// later version. This program is distributed in the hope that it will be useful, 
-// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
-// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
-// more details. You should have received a copy of the GNU General Public 
-// License along with this program; if not, write to the 
-// Free Software Foundation, Inc., 59 Temple Place - 
-// Suite 330, Boston, MA 02111-1307, USA. 
+// Software Foundation; either version 2 of the License, or (at your option) any
+// later version. This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+// more details. You should have received a copy of the GNU General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place -
+// Suite 330, Boston, MA 02111-1307, USA.
 //---------------------------------------------------------------------------
 //
 // File:         ft1000_chdev.c
@@ -49,10 +49,10 @@ extern inline u16 ft1000_asic_read (struct net_device *dev, u16 offset);
 extern inline void ft1000_asic_write (struct net_device *dev, u16 offset, u16 value);
 extern void CardSendCommand(struct ft1000_device *ft1000dev, unsigned short *ptempbuffer, int size);
 
-static int ft1000_ChOpen (struct inode *Inode, struct file *File); 
+static int ft1000_ChOpen (struct inode *Inode, struct file *File);
 static unsigned int ft1000_ChPoll(struct file *file, poll_table *wait);
 static int ft1000_ChIoctl(struct file *File, unsigned int Command,
-                           unsigned long Argument); 
+                           unsigned long Argument);
 static int ft1000_ChRelease (struct inode *Inode, struct file *File);
 
 static int ft1000_flarion_cnt = 0;
@@ -69,7 +69,7 @@ static struct ft1000_device *pdevobj[MAX_NUM_CARDS + 2];
 struct list_head freercvpool;
 
 // lock to arbitrate free buffer list for receive command data
-spinlock_t free_buff_lock;   
+spinlock_t free_buff_lock;
 
 int numofmsgbuf = 0;
 
@@ -82,8 +82,8 @@ int numofmsgbuf = 0;
 static struct file_operations ft1000fops =
 {
     unlocked_ioctl:    ft1000_ChIoctl,
-    poll:     ft1000_ChPoll,    
-    open:     ft1000_ChOpen,        
+    poll:     ft1000_ChPoll,
+    open:     ft1000_ChOpen,
     release:  ft1000_ChRelease
 };
 
@@ -93,7 +93,7 @@ static struct file_operations ft1000fops =
 //---------------------------------------------------------------------------
 // Function:    exec_mknod
 //
-// Parameters:  
+// Parameters:
 //
 // Returns:
 //
@@ -102,12 +102,12 @@ static struct file_operations ft1000fops =
 // Notes:
 //
 //---------------------------------------------------------------------------
-static int exec_mknod (void *pdata) 
+static int exec_mknod (void *pdata)
 {
     PFT1000_INFO info;
     char mjnum[4];
     char minornum[4];
-    char temp[32];    
+    char temp[32];
     int retcode;
 //    int i;					//aelias [-] reason : unused variable
     char *envp[] = { "HOME=/", "PATH=/usr/bin:/bin", NULL };
@@ -118,20 +118,20 @@ static int exec_mknod (void *pdata)
     sprintf(temp, "%s%s", "/dev/", info->DeviceName) ;
     sprintf(mjnum, "%d", info->DeviceMajor);
     sprintf(minornum, "%d", info->CardNumber);
-    
+
     //char *argv[]={"mknod","-m 666",temp,"c",mjnum,minornum,NULL};
 //    char *argv[]={"-m 666",temp,"c",mjnum,minornum,NULL};
 
     //for (i=0; i<7;i++)
     //    DEBUG("argv[%d]=%s\n", i, argv[i]);
 
-	
+
     retcode = call_usermodehelper ("/bin/mknod", argv, envp, 1);
     if (retcode) {
         DEBUG("ft1000_chdev:exec_mknod failed to make the node: retcode = %d\n", retcode);
     }
 
-    
+
 
     return retcode;
 
@@ -143,21 +143,21 @@ static int exec_mknod (void *pdata)
 // Description: This module removes the FT1000 device file
 //
 //---------------------------------------------------------------------------
-static int rm_mknod (void *pdata) 
+static int rm_mknod (void *pdata)
 {
-   
+
     PFT1000_INFO info;
     //char *argv[4]={"rm", "-f", "/dev/FT1000", NULL};
     int retcode;
-    char temp[32];    
+    char temp[32];
     char *argv[]={"rm", "-f", temp, NULL};
 
     info = (PFT1000_INFO)pdata;
     DEBUG("ft1000_chdev:rm_mknod is called for device %s\n", info->DeviceName);
     sprintf(temp, "%s%s", "/dev/", info->DeviceName) ;
-    
+
 //    char *argv[]={"rm", "-f", temp, NULL};
-    
+
     retcode = call_usermodehelper ("/bin/rm", argv, NULL, 1);
     if (retcode) {
         DEBUG("ft1000_chdev:rm_mknod failed to remove the node: retcode = %d\n", retcode);
@@ -172,7 +172,7 @@ static int rm_mknod (void *pdata)
 //---------------------------------------------------------------------------
 // Function:    ft1000_get_buffer
 //
-// Parameters:  
+// Parameters:
 //
 // Returns:
 //
@@ -185,7 +185,7 @@ PDPRAM_BLK ft1000_get_buffer (struct list_head *bufflist)
 {
     unsigned long flags;
     PDPRAM_BLK ptr;
-    
+
     spin_lock_irqsave(&free_buff_lock, flags);
     // Check if buffer is available
     if ( list_empty(bufflist) ) {
@@ -209,7 +209,7 @@ PDPRAM_BLK ft1000_get_buffer (struct list_head *bufflist)
 //---------------------------------------------------------------------------
 // Function:    ft1000_free_buffer
 //
-// Parameters:  
+// Parameters:
 //
 // Returns:
 //
@@ -221,7 +221,7 @@ PDPRAM_BLK ft1000_get_buffer (struct list_head *bufflist)
 void ft1000_free_buffer (PDPRAM_BLK pdpram_blk, struct list_head *plist)
 {
     unsigned long flags;
-    
+
     spin_lock_irqsave(&free_buff_lock, flags);
     // Put memory back to list
     list_add_tail(&pdpram_blk->list, plist);
@@ -255,15 +255,15 @@ int ft1000_CreateDevice(struct ft1000_device *dev)
     // Delete any existing FT1000 node
     pid = kernel_thread (rm_mknod,(void *)info, 0);
     msleep(1000);
-    
+
     DEBUG("ft1000_CreateDevice: number of instance = %d\n", ft1000_flarion_cnt);
     DEBUG("DeviceCreated = %x\n", info->DeviceCreated);
-    
+
     //save the device info to global array
     pdevobj[info->CardNumber] = dev;
 
     DEBUG("ft1000_CreateDevice: ******SAVED pdevobj[%d]=%x\n", info->CardNumber, (unsigned int)pdevobj[info->CardNumber]);	//aelias [+] reason:up
-    
+
     if (info->DeviceCreated)
     {
 	DEBUG("ft1000_CreateDevice: \"%s\" already registered\n", info->DeviceName);
@@ -274,7 +274,7 @@ int ft1000_CreateDevice(struct ft1000_device *dev)
     // register the device
     DEBUG("ft1000_CreateDevice: \"%s\" device registration\n", info->DeviceName);
     info->DeviceMajor = 0;
-	
+
     result = register_chrdev(info->DeviceMajor, info->DeviceName, &ft1000fops);
     if (result < 0)
     {
@@ -293,12 +293,12 @@ int ft1000_CreateDevice(struct ft1000_device *dev)
 
     // Create a thread to call user mode app to mknod
     pid = kernel_thread (exec_mknod, (void *)info, 0);
-    
-    // initialize application information 
+
+    // initialize application information
     info->appcnt = 0;
-    
+
 //    if (ft1000_flarion_cnt == 0) {
-//    	
+//
 //    	  DEBUG("Initialize free_buff_lock and freercvpool\n");
 //        spin_lock_init(&free_buff_lock);
 //
@@ -310,15 +310,15 @@ int ft1000_CreateDevice(struct ft1000_device *dev)
 //            // Get memory for DPRAM_DATA link list
 //            pdpram_blk = kmalloc ( sizeof(DPRAM_BLK), GFP_KERNEL );
 //            // Get a block of memory to store command data
-//            pdpram_blk->pbuffer = kmalloc ( MAX_CMD_SQSIZE, GFP_KERNEL );         
-//            // link provisioning data 
+//            pdpram_blk->pbuffer = kmalloc ( MAX_CMD_SQSIZE, GFP_KERNEL );
+//            // link provisioning data
 //            list_add_tail (&pdpram_blk->list, &freercvpool);
 //        }
 //        numofmsgbuf = NUM_OF_FREE_BUFFERS;
 //    }
-    
 
-    // initialize application information 
+
+    // initialize application information
     info->appcnt = 0;
     for (i=0; i<MAX_NUM_APP; i++) {
         info->app_info[i].nTxMsg = 0;
@@ -336,7 +336,7 @@ int ft1000_CreateDevice(struct ft1000_device *dev)
 
 
 
-//    ft1000Handle[info->CardNumber] = devfs_register(NULL, info->DeviceName, DEVFS_FL_AUTO_DEVNUM, 0, 0, 
+//    ft1000Handle[info->CardNumber] = devfs_register(NULL, info->DeviceName, DEVFS_FL_AUTO_DEVNUM, 0, 0,
 //                                  S_IFCHR | S_IRUGO | S_IWUGO, &ft1000fops, NULL);
 
 
@@ -364,16 +364,16 @@ void ft1000_DestroyDevice(struct net_device *dev)
 		int i;
     PDPRAM_BLK pdpram_blk;
     DPRAM_BLK *ptr;
-		
+
     DEBUG("ft1000_chdev:ft1000_DestroyDevice called\n");
 
-        
-    
+
+
     if (info->DeviceCreated)
 	{
-        ft1000_flarion_cnt--;		
+        ft1000_flarion_cnt--;
 		unregister_chrdev(info->DeviceMajor, info->DeviceName);
-		DEBUG("ft1000_DestroyDevice: unregistered device \"%s\", result = %d\n", 
+		DEBUG("ft1000_DestroyDevice: unregistered device \"%s\", result = %d\n",
 					   info->DeviceName, result);
 
        pid = kernel_thread (rm_mknod, (void *)info, 0);
@@ -381,10 +381,10 @@ void ft1000_DestroyDevice(struct net_device *dev)
         // Make sure we free any memory reserve for slow Queue
         for (i=0; i<MAX_NUM_APP; i++) {
             while (list_empty(&info->app_info[i].app_sqlist) == 0) {
-                pdpram_blk = list_entry(info->app_info[i].app_sqlist.next, DPRAM_BLK, list);                
+                pdpram_blk = list_entry(info->app_info[i].app_sqlist.next, DPRAM_BLK, list);
                 list_del(&pdpram_blk->list);
                 ft1000_free_buffer(pdpram_blk, &freercvpool);
-                
+
             }
             wake_up_interruptible(&info->app_info[i].wait_dpram_msg);
         }
@@ -395,39 +395,39 @@ void ft1000_DestroyDevice(struct net_device *dev)
                 ptr = list_entry(freercvpool.next, DPRAM_BLK, list);
                 list_del(&ptr->list);
                 kfree(ptr->pbuffer);
-                kfree(ptr);   
+                kfree(ptr);
             }
         }
 
 //        devfs_unregister(ft1000Handle[info->CardNumber]);
 
 		info->DeviceCreated = FALSE;
-		
+
 		pdevobj[info->CardNumber] = NULL;
 	}
-	
-	    
+
+
 }
 
 //---------------------------------------------------------------------------
 // Function:    ft1000_ChOpen
 //
-// Parameters:  
+// Parameters:
 //
-// Description: 
+// Description:
 //
 // Notes:
 //
 //---------------------------------------------------------------------------
-static int ft1000_ChOpen (struct inode *Inode, struct file *File) 
+static int ft1000_ChOpen (struct inode *Inode, struct file *File)
 {
     PFT1000_INFO info;
     int i,num;
-    
+
     DEBUG("ft1000_ChOpen called\n");
     num = (MINOR(Inode->i_rdev) & 0xf);
     DEBUG("ft1000_ChOpen: minor number=%d\n", num);
-    
+
     for (i=0; i<5; i++)
         DEBUG("pdevobj[%d]=%x\n", i, (unsigned int)pdevobj[i]); //aelias [+] reason: down
 
@@ -477,9 +477,9 @@ static int ft1000_ChOpen (struct inode *Inode, struct file *File)
 //---------------------------------------------------------------------------
 // Function:    ft1000_ChPoll
 //
-// Parameters:  
+// Parameters:
 //
-// Description: 
+// Description:
 //
 // Notes:
 //
@@ -490,7 +490,7 @@ static unsigned int ft1000_ChPoll(struct file *file, poll_table *wait)
     struct net_device *dev = file->private_data;
     PFT1000_INFO info;
     int i;
-    
+
     //DEBUG("ft1000_ChPoll called\n");
     if (ft1000_flarion_cnt == 0) {
         DEBUG("FT1000:ft1000_ChPoll called when ft1000_flarion_cnt is zero\n");
@@ -498,7 +498,7 @@ static unsigned int ft1000_ChPoll(struct file *file, poll_table *wait)
     }
 
 	info = (FT1000_INFO *) netdev_priv (dev);
-    
+
     // Search for matching file object
     for (i=0; i<MAX_NUM_APP; i++) {
         if ( info->app_info[i].fileobject == (u32)(&file->f_owner) ) {
@@ -511,13 +511,13 @@ static unsigned int ft1000_ChPoll(struct file *file, poll_table *wait)
     if (i == MAX_NUM_APP) {
         DEBUG("FT1000:ft1000_ChIoctl:Could not find application info block\n");
         return ( -EACCES );
-    }    
-    
+    }
+
     if (list_empty(&info->app_info[i].app_sqlist) == 0) {
         DEBUG("FT1000:ft1000_ChPoll:Message detected in slow queue\n");
         return(POLLIN | POLLRDNORM | POLLPRI);
     }
-    
+
     poll_wait (file, &info->app_info[i].wait_dpram_msg, wait);
     //DEBUG("FT1000:ft1000_ChPoll:Polling for data from DSP\n");
 
@@ -527,24 +527,24 @@ static unsigned int ft1000_ChPoll(struct file *file, poll_table *wait)
 //---------------------------------------------------------------------------
 // Function:    ft1000_ChIoctl
 //
-// Parameters:  
+// Parameters:
 //
-// Description: 
+// Description:
 //
 // Notes:
 //
 //---------------------------------------------------------------------------
 static int ft1000_ChIoctl (struct file *File, unsigned int Command,
-                           unsigned long Argument) 
+                           unsigned long Argument)
 {
     struct net_device *dev;
     PFT1000_INFO info;
     struct ft1000_device *ft1000dev;
     int result=0;
     int cmd;
-    int i;    
-    u16 tempword;    
-    unsigned long flags;    
+    int i;
+    u16 tempword;
+    unsigned long flags;
     struct timeval tv;
     IOCTL_GET_VER get_ver_data;
     IOCTL_GET_DSP_STAT get_stat_data;
@@ -556,8 +556,8 @@ static int ft1000_ChIoctl (struct file *File, unsigned int Command,
                           0x00,0x01,0x00,0x00};
 
     unsigned short ledStat=0;
-    unsigned short conStat=0;                                                     
-    
+    unsigned short conStat=0;
+
     //DEBUG("ft1000_ChIoctl called\n");
 
     if (ft1000_flarion_cnt == 0) {
@@ -572,7 +572,7 @@ static int ft1000_ChIoctl (struct file *File, unsigned int Command,
     ft1000dev = info->pFt1000Dev;
     cmd = _IOC_NR(Command);
     //DEBUG("FT1000:ft1000_ChIoctl:cmd = 0x%x\n", cmd);
-   
+
     // process the command
     switch (cmd) {
     case IOCTL_REGISTER_CMD:
@@ -593,7 +593,7 @@ static int ft1000_ChIoctl (struct file *File, unsigned int Command,
                 }
             }
             break;
-    
+
     case IOCTL_GET_VER_CMD:
         DEBUG("FT1000:ft1000_ChIoctl: IOCTL_FT1000_GET_VER called\n");
 
@@ -612,14 +612,14 @@ static int ft1000_ChIoctl (struct file *File, unsigned int Command,
         // Connect Message
         DEBUG("FT1000:ft1000_ChIoctl: IOCTL_FT1000_CONNECT\n");
         ConnectionMsg[79] = 0xfc;
-			   CardSendCommand(ft1000dev, (unsigned short *)ConnectionMsg, 0x4c);  								
-        
+			   CardSendCommand(ft1000dev, (unsigned short *)ConnectionMsg, 0x4c);
+
         break;
     case IOCTL_DISCONNECT:
         // Disconnect Message
         DEBUG("FT1000:ft1000_ChIoctl: IOCTL_FT1000_DISCONNECT\n");
         ConnectionMsg[79] = 0xfd;
-			   CardSendCommand(ft1000dev, (unsigned short *)ConnectionMsg, 0x4c);  								
+			   CardSendCommand(ft1000dev, (unsigned short *)ConnectionMsg, 0x4c);
         break;
     case IOCTL_GET_DSP_STAT_CMD:
         //DEBUG("FT1000:ft1000_ChIoctl: IOCTL_FT1000_GET_DSP_STAT called\n");
@@ -640,22 +640,22 @@ static int ft1000_ChIoctl (struct file *File, unsigned int Command,
             else {
                 get_stat_data.ConStat = 0x0f;
             }
-            
-            
+
+
         get_stat_data.nTxPkts = info->stats.tx_packets;
         get_stat_data.nRxPkts = info->stats.rx_packets;
         get_stat_data.nTxBytes = info->stats.tx_bytes;
         get_stat_data.nRxBytes = info->stats.rx_bytes;
         do_gettimeofday ( &tv );
         get_stat_data.ConTm = (u32)(tv.tv_sec - info->ConTm);
-        DEBUG("Connection Time = %d\n", (int)get_stat_data.ConTm); 
+        DEBUG("Connection Time = %d\n", (int)get_stat_data.ConTm);
         if (copy_to_user((PIOCTL_GET_DSP_STAT)Argument, &get_stat_data, sizeof(get_stat_data)) ) {
             DEBUG("FT1000:ft1000_ChIoctl: copy fault occurred\n");
             result = -EFAULT;
             break;
         }
         DEBUG("ft1000_chioctl: GET_DSP_STAT succeed\n");
-        break;    
+        break;
     case IOCTL_SET_DPRAM_CMD:
         {
             IOCTL_DPRAM_BLK dpram_data;
@@ -669,12 +669,12 @@ static int ft1000_ChIoctl (struct file *File, unsigned int Command,
             u16 status;
 
             //DEBUG("FT1000:ft1000_ChIoctl: IOCTL_FT1000_SET_DPRAM called\n");
-            
+
 
             if (ft1000_flarion_cnt == 0) {
                 return (-EBADF);
             }
-            
+
             if (info->DrvMsgPend) {
                 return (-ENOTTY);
             }
@@ -684,16 +684,16 @@ static int ft1000_ChIoctl (struct file *File, unsigned int Command,
             }
 
             info->fAppMsgPend = 1;
-           
+
             if (info->CardReady) {
-            
+
                //DEBUG("FT1000:ft1000_ChIoctl: try to SET_DPRAM \n");
 
                 // Get the length field to see how many bytes to copy
                 result = get_user(msgsz, (unsigned short *)Argument);
                 msgsz = ntohs (msgsz);
                 //DEBUG("FT1000:ft1000_ChIoctl: length of message = %d\n", msgsz);
-                
+
                 if (msgsz > MAX_CMD_SQSIZE) {
                     DEBUG("FT1000:ft1000_ChIoctl: bad message length = %d\n", msgsz);
                     result = -EINVAL;
@@ -731,8 +731,8 @@ static int ft1000_ChIoctl (struct file *File, unsigned int Command,
                     qtype = ntohs(dpram_data.pseudohdr.qos_class) & 0xff;
                     //DEBUG("FT1000_ft1000_ChIoctl: qtype = %d\n", qtype);
                     if (qtype) {
-                    } 
-                    else {                        
+                    }
+                    else {
                         // Put message into Slow Queue
                         // Only put a message into the DPRAM if msg doorbell is available
                         status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_DOORBELL);
@@ -760,9 +760,9 @@ static int ft1000_ChIoctl (struct file *File, unsigned int Command,
                                 }
                             }
                         }
-                        
+
                         //DEBUG("FT1000_ft1000_ChIoctl: finished reading register\n");
-                        
+
                         // Make sure we are within the limits of the slow queue memory limitation
                         if ( (msgsz < MAX_CMD_SQSIZE) && (msgsz > PSEUDOSZ) ) {
                             // Need to put sequence number plus new checksum for message
@@ -773,7 +773,7 @@ static int ft1000_ChIoctl (struct file *File, unsigned int Command,
                             if (total_len & 0x1) {
                                 total_len++;
                             }
-                            
+
                             // Insert slow queue sequence number
                             ppseudo_hdr->seq_num = info->squeseqnum++;
                             ppseudo_hdr->portsrc = info->app_info[app_index].app_id;
@@ -794,11 +794,11 @@ static int ft1000_ChIoctl (struct file *File, unsigned int Command,
                             }
 #endif
                             //dpram_command.extra = 0;
-                            
-                            //CardSendCommand(ft1000dev,(unsigned char*)&dpram_command,total_len+2); 
-                            CardSendCommand(ft1000dev,(unsigned short*)&dpram_data,total_len+2); 
 
-                            
+                            //CardSendCommand(ft1000dev,(unsigned char*)&dpram_command,total_len+2);
+                            CardSendCommand(ft1000dev,(unsigned short*)&dpram_data,total_len+2);
+
+
                             info->app_info[app_index].nTxMsg++;
                             break;
                         }
@@ -846,15 +846,15 @@ static int ft1000_ChIoctl (struct file *File, unsigned int Command,
             result = 0;
             pioctl_dpram = (PIOCTL_DPRAM_BLK)Argument;
             if (list_empty(&info->app_info[i].app_sqlist) == 0) {
-                //DEBUG("FT1000:ft1000_ChIoctl:Message detected in slow queue\n");                            
+                //DEBUG("FT1000:ft1000_ChIoctl:Message detected in slow queue\n");
                 spin_lock_irqsave(&free_buff_lock, flags);
-                pdpram_blk = list_entry(info->app_info[i].app_sqlist.next, DPRAM_BLK, list);                
+                pdpram_blk = list_entry(info->app_info[i].app_sqlist.next, DPRAM_BLK, list);
                 list_del(&pdpram_blk->list);
                 info->app_info[i].NumOfMsg--;
                 //DEBUG("FT1000:ft1000_ChIoctl:NumOfMsg for app %d = %d\n", i, info->app_info[i].NumOfMsg);
                 spin_unlock_irqrestore(&free_buff_lock, flags);
                 msglen = ntohs(*(u16 *)pdpram_blk->pbuffer) + PSEUDOSZ;
-                pioctl_dpram->total_len = htons(msglen); 
+                pioctl_dpram->total_len = htons(msglen);
                 //DEBUG("FT1000:ft1000_ChIoctl:msg length = %x\n", msglen);
                 if(copy_to_user (&pioctl_dpram->pseudohdr, pdpram_blk->pbuffer, msglen))
 				{
@@ -882,9 +882,9 @@ static int ft1000_ChIoctl (struct file *File, unsigned int Command,
 //---------------------------------------------------------------------------
 // Function:    ft1000_ChRelease
 //
-// Parameters:  
+// Parameters:
 //
-// Description: 
+// Description:
 //
 // Notes:
 //
@@ -895,7 +895,7 @@ static int ft1000_ChRelease (struct inode *Inode, struct file *File)
     struct net_device *dev;
     int i;
     PDPRAM_BLK pdpram_blk;
-    
+
     DEBUG("ft1000_ChRelease called\n");
 
     dev = File->private_data;
@@ -919,16 +919,16 @@ static int ft1000_ChRelease (struct inode *Inode, struct file *File)
 
     while (list_empty(&info->app_info[i].app_sqlist) == 0) {
         DEBUG("Remove and free memory queue up on slow queue\n");
-        pdpram_blk = list_entry(info->app_info[i].app_sqlist.next, DPRAM_BLK, list);                
+        pdpram_blk = list_entry(info->app_info[i].app_sqlist.next, DPRAM_BLK, list);
         list_del(&pdpram_blk->list);
         ft1000_free_buffer(pdpram_blk, &freercvpool);
     }
-    
-    // initialize application information 
+
+    // initialize application information
     info->appcnt--;
     DEBUG("ft1000_chdev:%s:appcnt = %d\n", __FUNCTION__, info->appcnt);
     info->app_info[i].fileobject = 0;
-    
+
     return 0;
 }
 

drivers/staging/ft1000/ft1000-usb/ft1000_download.c

@@ -47,7 +47,7 @@
 #define  REQUEST_DONE_CL         0x0004
 #define  REQUEST_VERSION_INFO    0x0005
 #define  REQUEST_CODE_BY_VERSION 0x0006
-#define  REQUEST_MAILBOX_DATA    0x0007       
+#define  REQUEST_MAILBOX_DATA    0x0007
 #define  REQUEST_FILE_CHECKSUM   0x0008
 
 #define  STATE_START_DWNLD       0x01
@@ -72,7 +72,7 @@
 #define  HANDSHAKE_MAG_DSP_DATA      0x02000000   /* Dsp writes this to request for data block */
 #define  HANDSHAKE_MAG_DSP_DONE      0x03000000   /* Dsp writes this to indicate download done */
 
-#define  HANDSHAKE_MAG_DRV_READY     0xFFFF0000   /* Driver writes this to indicate ready to download */ 
+#define  HANDSHAKE_MAG_DRV_READY     0xFFFF0000   /* Driver writes this to indicate ready to download */
 #define  HANDSHAKE_MAG_DRV_DATA      0x02FECDAB   /* Driver writes this to indicate data available to DSP */
 #define  HANDSHAKE_MAG_DRV_ENTRY     0x01FECDAB   /* Driver writes this to indicate entry point to DSP */
 
@@ -208,7 +208,7 @@ char *getfw (char *fn, int *pimgsz)
 // Function:    check_usb_db
 //
 // Parameters:  struct ft1000_device  - device structure
-//              
+//
 // Returns:     0 - success
 //
 // Description: This function checks if the doorbell register is cleared
@@ -225,32 +225,32 @@ ULONG check_usb_db (struct ft1000_device *ft1000dev)
    loopcnt = 0;
    while (loopcnt < 10)
    {
-       
+
       status = ft1000_read_register (ft1000dev, &temp, FT1000_REG_DOORBELL);
       DEBUG("check_usb_db: read FT1000_REG_DOORBELL value is %x\n", temp);
-      if (temp & 0x0080) 
+      if (temp & 0x0080)
       {
            DEBUG("FT1000:Got checkusb doorbell\n");
            status = ft1000_write_register (ft1000dev, 0x0080, FT1000_REG_DOORBELL);
 #if FIFO_DNLD
            status = ft1000_write_register (ft1000dev, 0x0100, FT1000_REG_DOORBELL);
-#endif 
+#endif
            status = ft1000_write_register (ft1000dev,  0x8000, FT1000_REG_DOORBELL);
            break;
       }
-      else 
+      else
       {
            loopcnt++;
            msleep (10);
       }
 
-   } //end of while 
+   } //end of while
+
 
-   
    loopcnt = 0;
    while (loopcnt < 20)
    {
-       
+
       status = ft1000_read_register (ft1000dev, &temp, FT1000_REG_DOORBELL);
       DEBUG("FT1000:check_usb_db:Doorbell = 0x%x\n", temp);
       if (temp & 0x8000)
@@ -286,7 +286,7 @@ ULONG check_usb_db (struct ft1000_device *ft1000dev)
 //
 // Parameters:  struct ft1000_device  - device structure
 //              USHORT expected_value - the handshake value expected
-//              
+//
 // Returns:     handshakevalue - success
 //              HANDSHAKE_TIMEOUT_VALUE - failure
 //
@@ -305,17 +305,17 @@ USHORT get_handshake(struct ft1000_device *ft1000dev, USHORT expected_value)
    loopcnt = 0;
    while (loopcnt < 100)
    {
-        
+
 #if FIFO_DNLD
            // Need to clear downloader doorbell if Hartley ASIC
            status = ft1000_write_register (ft1000dev,  FT1000_DB_DNLD_RX, FT1000_REG_DOORBELL);
            //DEBUG("FT1000:get_handshake:doorbell = 0x%x\n", temp);
-               if (pft1000info->fcodeldr) 
+               if (pft1000info->fcodeldr)
                {
                    DEBUG(" get_handshake: fcodeldr is %d\n", pft1000info->fcodeldr);
                    pft1000info->fcodeldr = 0;
                    status = check_usb_db(ft1000dev);
-                   if (status != STATUS_SUCCESS) 
+                   if (status != STATUS_SUCCESS)
                    {
                        DEBUG("get_handshake: check_usb_db failed\n");
                        status = STATUS_FAILURE;
@@ -332,29 +332,29 @@ USHORT get_handshake(struct ft1000_device *ft1000dev, USHORT expected_value)
            // Need to clear downloader doorbell if Hartley ASIC
            status = ft1000_read_register (ft1000dev, &temp, FT1000_REG_DOORBELL);
            //DEBUG("FT1000:get_handshake:doorbell = 0x%x\n", temp);
-           if (temp) 
+           if (temp)
            {
                if (temp & FT1000_DB_DNLD_RX)
                {
                    //DEBUG("get_handshake: write FT1000_DB_DNLD_RX to doorbell register\n");
                    status = ft1000_write_register(ft1000dev, FT1000_DB_DNLD_RX, FT1000_REG_DOORBELL);
                }
-          
-               if (pft1000info->fcodeldr) 
+
+               if (pft1000info->fcodeldr)
                {
                    DEBUG(" get_handshake: fcodeldr is %d\n", pft1000info->fcodeldr);
                    pft1000info->fcodeldr = 0;
                    status = check_usb_db(ft1000dev);
-                   if (status != STATUS_SUCCESS) 
+                   if (status != STATUS_SUCCESS)
                    {
                        DEBUG("get_handshake: check_usb_db failed\n");
                        status = STATUS_FAILURE;
                        break;
-                   }                           
+                   }
 
                    status = ft1000_read_register (ft1000dev, &temp, FT1000_REG_DOORBELL);
                    //DEBUG("FT1000:get_handshake:doorbell = 0x%x\n", temp);
-                   if (temp) 
+                   if (temp)
                    {
                        if (temp & FT1000_DB_DNLD_RX)
                            status = ft1000_write_register(ft1000dev,FT1000_DB_DNLD_RX, FT1000_REG_DOORBELL);
@@ -370,7 +370,7 @@ USHORT get_handshake(struct ft1000_device *ft1000dev, USHORT expected_value)
 #endif
 
 
-        if (status) 
+        if (status)
            return HANDSHAKE_TIMEOUT_VALUE;
 
         //DEBUG("get_handshake: handshake= %x\n", handshake);
@@ -387,7 +387,7 @@ USHORT get_handshake(struct ft1000_device *ft1000dev, USHORT expected_value)
         //DEBUG("HANDSHKE LOOP: %d\n", loopcnt);
 
    }
-   
+
    //DEBUG("get_handshake: return handshake time out\n");
    return HANDSHAKE_TIMEOUT_VALUE;
 }
@@ -397,7 +397,7 @@ USHORT get_handshake(struct ft1000_device *ft1000dev, USHORT expected_value)
 //
 // Parameters:  struct ft1000_device  - device structure
 //              USHORT handshake_value - handshake to be written
-//              
+//
 // Returns:     none
 //
 // Description: This function write the handshake value to the handshake location
@@ -426,13 +426,13 @@ void put_handshake(struct ft1000_device *ft1000dev,USHORT handshake_value)
 #if FIFO_DNLD
         for (i=0; i<1000; i++);
 #else
-        for (i=0; i<10; i++) 
-        {            
+        for (i=0; i<10; i++)
+        {
             status = ft1000_read_register (ft1000dev, &tempword, FT1000_REG_DOORBELL);
             if ((tempword & FT1000_DB_DNLD_TX) == 0)
                 break;
         }
-        if (i==10) 
+        if (i==10)
         {
             DEBUG("FT1000:put_handshake could not clear Tx doorbell\n");
             status = ft1000_read_register (ft1000dev, &tempword, FT1000_REG_DOORBELL);
@@ -457,7 +457,7 @@ USHORT get_handshake_usb(struct ft1000_device *ft1000dev, USHORT expected_value)
        if (pft1000info->usbboot == 2) {
            status = ft1000_read_dpram32 (ft1000dev, 0, (PUCHAR)&(pft1000info->tempbuf[0]), 64);
            for (temp=0; temp<16; temp++)
-               DEBUG("tempbuf %d = 0x%x\n", temp, pft1000info->tempbuf[temp]); 
+               DEBUG("tempbuf %d = 0x%x\n", temp, pft1000info->tempbuf[temp]);
            status = ft1000_read_dpram16 (ft1000dev, DWNLD_MAG1_HANDSHAKE_LOC, (PUCHAR)&handshake, 1);
            DEBUG("handshake from read_dpram16 = 0x%x\n", handshake);
            if (pft1000info->dspalive == pft1000info->tempbuf[6])
@@ -493,7 +493,7 @@ void put_handshake_usb(struct ft1000_device *ft1000dev,USHORT handshake_value)
 // Function:    get_request_type
 //
 // Parameters:  struct ft1000_device  - device structure
-//              
+//
 // Returns:     request type - success
 //
 // Description: This function returns the request type
@@ -569,7 +569,7 @@ USHORT get_request_type_usb(struct ft1000_device *ft1000dev)
 // Function:    get_request_value
 //
 // Parameters:  struct ft1000_device  - device structure
-//              
+//
 // Returns:     request value - success
 //
 // Description: This function returns the request value
@@ -597,9 +597,9 @@ long get_request_value(struct ft1000_device *ft1000dev)
            status = ft1000_read_dpram16(ft1000dev, DWNLD_MAG1_SIZE_LOC, (PUCHAR)&tempword, 1);
 	   value |= (tempword << 16);
 	   value = ntohl(value);
-       }                                 
+       }
+
 
-   
    //DEBUG("get_request_value: value is %x\n", value);
    return value;
 
@@ -628,7 +628,7 @@ long get_request_value_usb(struct ft1000_device *ft1000dev)
    if (pft1000info->usbboot == 1)
        pft1000info->usbboot = 2;
 #endif
-   
+
    //DEBUG("get_request_value_usb: value is %x\n", value);
    return value;
 
@@ -639,7 +639,7 @@ long get_request_value_usb(struct ft1000_device *ft1000dev)
 //
 // Parameters:  struct ft1000_device  - device structure
 //              long lvalue - value to be put into DPRAM location DWNLD_MAG1_SIZE_LOC
-//              
+//
 // Returns:     none
 //
 // Description: This function writes a value to DWNLD_MAG1_SIZE_LOC
@@ -656,7 +656,7 @@ void put_request_value(struct ft1000_device *ft1000dev, long lvalue)
        status = fix_ft1000_write_dpram32(ft1000dev, DWNLD_MAG1_SIZE_LOC, (PUCHAR)&tempx);
 
 
-   
+
    //DEBUG("put_request_value: value is %x\n", lvalue);
 
 }
@@ -667,7 +667,7 @@ void put_request_value(struct ft1000_device *ft1000dev, long lvalue)
 // Function:    hdr_checksum
 //
 // Parameters:  PPSEUDO_HDR pHdr - Pseudo header pointer
-//              
+//
 // Returns:     checksum - success
 //
 // Description: This function returns the checksum of the pseudo header
@@ -680,7 +680,7 @@ USHORT hdr_checksum(PPSEUDO_HDR pHdr)
    USHORT   *usPtr = (USHORT *)pHdr;
    USHORT   chksum;
 
-  
+
   chksum = ((((((usPtr[0] ^ usPtr[1]) ^ usPtr[2]) ^ usPtr[3]) ^
                     usPtr[4]) ^ usPtr[5]) ^ usPtr[6]);
 
@@ -696,7 +696,7 @@ USHORT hdr_checksum(PPSEUDO_HDR pHdr)
 //              UCHAR  **pUcFile - DSP image file pointer in UCHAR
 //              long   word_length - lenght of the buffer to be written
 //                                   to DPRAM
-//              
+//
 // Returns:     STATUS_SUCCESS - success
 //              STATUS_FAILURE - failure
 //
@@ -736,9 +736,9 @@ ULONG write_blk (struct ft1000_device *ft1000dev, USHORT **pUsFile, UCHAR **pUcF
    {
 	   loopcnt = 0;
 
-	      for (i=0; i<32; i++) 
+	      for (i=0; i<32; i++)
 	      {
-		       if (tempword != 0) 
+		       if (tempword != 0)
 		       {
     		           tempbuffer[i++] = *(*pUsFile);
 			   (*pUsFile)++;
@@ -748,42 +748,42 @@ ULONG write_blk (struct ft1000_device *ft1000dev, USHORT **pUsFile, UCHAR **pUcF
 			   loopcnt++;
 			   tempword--;
 		       }
-		       else 
+		       else
 		       {
 			   tempbuffer[i++] = 0;
 			   tempbuffer[i] = 0;
                        }
 	      }
-              
+
               //DEBUG("write_blk: loopcnt is %d\n", loopcnt);
               //DEBUG("write_blk: bootmode = %d\n", bootmode);
               //DEBUG("write_blk: dpram = %x\n", dpram);
-	      if (pft1000info->bootmode == 0) 
-	      {	         
-		 if (dpram >= 0x3F4) 
+	      if (pft1000info->bootmode == 0)
+	      {
+		 if (dpram >= 0x3F4)
                      Status = ft1000_write_dpram32 (ft1000dev, dpram, (PUCHAR)&tempbuffer[0], 8);
-	         else 
+	         else
                     Status = ft1000_write_dpram32 (ft1000dev, dpram, (PUCHAR)&tempbuffer[0], 64);
 	      }
-	      else 
+	      else
 	      {
-                 for (j=0; j<10; j++) 
+                 for (j=0; j<10; j++)
                  {
                    Status = ft1000_write_dpram32 (ft1000dev, dpram, (PUCHAR)&tempbuffer[0], 64);
-		   if (Status == STATUS_SUCCESS) 
+		   if (Status == STATUS_SUCCESS)
 		   {
 		       // Work around for ASIC bit stuffing problem.
-		       if ( (tempbuffer[31] & 0xfe00) == 0xfe00) 
+		       if ( (tempbuffer[31] & 0xfe00) == 0xfe00)
 		       {
       		           Status = ft1000_write_dpram32(ft1000dev, dpram+12, (PUCHAR)&tempbuffer[24], 64);
 		       }
     		       // Let's check the data written
 	    	       Status = ft1000_read_dpram32 (ft1000dev, dpram, (PUCHAR)&resultbuffer[0], 64);
-		       if ( (tempbuffer[31] & 0xfe00) == 0xfe00) 
+		       if ( (tempbuffer[31] & 0xfe00) == 0xfe00)
 		       {
-		           for (i=0; i<28; i++) 
+		           for (i=0; i<28; i++)
 		           {
-			       if (resultbuffer[i] != tempbuffer[i]) 
+			       if (resultbuffer[i] != tempbuffer[i])
 			       {
 			           //NdisMSleep (100);
                                    DEBUG("FT1000:download:DPRAM write failed 1 during bootloading\n");
@@ -793,7 +793,7 @@ ULONG write_blk (struct ft1000_device *ft1000dev, USHORT **pUsFile, UCHAR **pUcF
 				}
 			   }
    			   Status = ft1000_read_dpram32 (ft1000dev, dpram+12, (PUCHAR)&resultbuffer[0], 64);
-		           for (i=0; i<16; i++) 
+		           for (i=0; i<16; i++)
 		           {
     			       if (resultbuffer[i] != tempbuffer[i+24])
     			       {
@@ -805,11 +805,11 @@ ULONG write_blk (struct ft1000_device *ft1000dev, USHORT **pUsFile, UCHAR **pUcF
 				}
 			   }
 			}
-			else 
+			else
 			{
-			    for (i=0; i<32; i++) 
+			    for (i=0; i<32; i++)
 			    {
-    			        if (resultbuffer[i] != tempbuffer[i]) 
+    			        if (resultbuffer[i] != tempbuffer[i])
     			        {
                                     //NdisMSleep (100);
                                     DEBUG("FT1000:download:DPRAM write failed 3 during bootloading\n");
@@ -820,13 +820,13 @@ ULONG write_blk (struct ft1000_device *ft1000dev, USHORT **pUsFile, UCHAR **pUcF
 			    }
 			}
 
-			if (Status == STATUS_SUCCESS) 
+			if (Status == STATUS_SUCCESS)
 			    break;
-				  
+
 		    }
 		}
-		
-		if (Status != STATUS_SUCCESS) 
+
+		if (Status != STATUS_SUCCESS)
 		{
                     DEBUG("FT1000:download:Write failed tempbuffer[31] = 0x%x\n", tempbuffer[31]);
 		    break;
@@ -835,7 +835,7 @@ ULONG write_blk (struct ft1000_device *ft1000dev, USHORT **pUsFile, UCHAR **pUcF
 	     }
    	     dpram = dpram + loopcnt;
    }
-   
+
    return Status;
 }
 
@@ -852,7 +852,7 @@ static void usb_dnld_complete (struct urb *urb)
 //              UCHAR  **pUcFile - DSP image file pointer in UCHAR
 //              long   word_length - lenght of the buffer to be written
 //                                   to DPRAM
-//              
+//
 // Returns:     STATUS_SUCCESS - success
 //              STATUS_FAILURE - failure
 //
@@ -894,7 +894,7 @@ ULONG write_blk_fifo (struct ft1000_device *ft1000dev, USHORT **pUsFile, UCHAR *
                           byte_length,
                           &cnt,
                           10);
-   DEBUG("write_blk_fifo Status = 0x%8x Bytes Transfer = %d Data = 0x%x\n", Status, cnt, *pblk); 
+   DEBUG("write_blk_fifo Status = 0x%8x Bytes Transfer = %d Data = 0x%x\n", Status, cnt, *pblk);
 
    kfree(pblk);
 #else
@@ -907,7 +907,7 @@ ULONG write_blk_fifo (struct ft1000_device *ft1000dev, USHORT **pUsFile, UCHAR *
                       byte_length,
                       usb_dnld_complete,
                       (void*)ft1000dev);
- 
+
     usb_submit_urb(ft1000dev->tx_urb, GFP_ATOMIC);
 #endif
 
@@ -962,9 +962,9 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG  FileLe
    USHORT                  dpram = 0;
    PUCHAR                  pbuffer;
    PPROV_RECORD            pprov_record;
-   FT1000_INFO *pft1000info = netdev_priv(ft1000dev->net); 
-                                
-   DEBUG("Entered   scram_dnldr...\n");                      
+   FT1000_INFO *pft1000info = netdev_priv(ft1000dev->net);
+
+   DEBUG("Entered   scram_dnldr...\n");
 
    pft1000info->fcodeldr = 0;
    pft1000info->usbboot = 0;
@@ -988,7 +988,7 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG  FileLe
       pBootEnd = (UCHAR *)(pFileStart + pFileHdr5->loader_code_end);
 
       loader_code_address = pFileHdr5->loader_code_address;
-      loader_code_size = pFileHdr5->loader_code_size;      
+      loader_code_size = pFileHdr5->loader_code_size;
       bGoodVersion = FALSE;
 
    while ((Status == STATUS_SUCCESS) && (uiState != STATE_DONE_FILE))
@@ -1031,7 +1031,7 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG  FileLe
             {
             case  REQUEST_RUN_ADDRESS:
                DEBUG("FT1000:REQUEST_RUN_ADDRESS\n");
-               put_request_value(ft1000dev, loader_code_address);               
+               put_request_value(ft1000dev, loader_code_address);
                break;
             case  REQUEST_CODE_LENGTH:
                DEBUG("FT1000:REQUEST_CODE_LENGTH\n");
@@ -1100,7 +1100,7 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG  FileLe
       case STATE_CODE_DWNLD:
          //DEBUG("FT1000:STATE_CODE_DWNLD\n");
          pft1000info->bootmode = 0;
-         if (pft1000info->usbboot) 
+         if (pft1000info->usbboot)
             handshake = get_handshake_usb(ft1000dev, HANDSHAKE_REQUEST);
          else
             handshake = get_handshake(ft1000dev, HANDSHAKE_REQUEST);
@@ -1111,7 +1111,7 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG  FileLe
              */
             if (pft1000info->usbboot)
                 request = get_request_type_usb(ft1000dev);
-            else 
+            else
                 request = get_request_type(ft1000dev);
             switch (request)
             {
@@ -1168,7 +1168,7 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG  FileLe
                word_length = get_request_value_usb(ft1000dev);
                //DEBUG("FT1000:download:word_length = %d\n", (int)word_length);
                if (word_length > MAX_LENGTH/2)
-#else 
+#else
                word_length = get_request_value(ft1000dev);
                //DEBUG("FT1000:download:word_length = %d\n", (int)word_length);
                if (word_length > MAX_LENGTH)
@@ -1207,35 +1207,35 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG  FileLe
 #else
    	       write_blk (ft1000dev, &pUsFile, &pUcFile, word_length);
    	       //ft1000_write_dpram32 (ft1000dev, dpram, (PUCHAR)pUcFile, word_length);
-#endif			   
+#endif
                break;
 
             case  REQUEST_MAILBOX_DATA:
                DEBUG("FT1000:download: REQUEST_MAILBOX_DATA\n");
                // Convert length from byte count to word count. Make sure we round up.
-               word_length = (long)(pft1000info->DSPInfoBlklen + 1)/2; 
+               word_length = (long)(pft1000info->DSPInfoBlklen + 1)/2;
                put_request_value(ft1000dev, word_length);
                pMailBoxData = (PDRVMSG)&(pft1000info->DSPInfoBlk[0]);
                /*
                 * Position ASIC DPRAM auto-increment pointer.
-                */         
-               
+                */
+
 
                    pUsData = (USHORT *)&pMailBoxData->data[0];
-                   dpram = (USHORT)DWNLD_MAG1_PS_HDR_LOC; 
+                   dpram = (USHORT)DWNLD_MAG1_PS_HDR_LOC;
                    if (word_length & 0x1)
                        word_length++;
-                    
+
                    word_length = (word_length / 2);
-             
+
 
                for (; word_length > 0; word_length--) /* In words */
                {
-                   
+
                       templong = *pUsData++;
 					  templong |= (*pUsData++ << 16);
-                      Status = fix_ft1000_write_dpram32 (ft1000dev, dpram++, (PUCHAR)&templong);                     
-                   
+                      Status = fix_ft1000_write_dpram32 (ft1000dev, dpram++, (PUCHAR)&templong);
+
                }
                break;
 
@@ -1245,26 +1245,26 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG  FileLe
                put_request_value(ft1000dev, word_length);
                /*
                 * Position ASIC DPRAM auto-increment pointer.
-                */               
-               
+                */
+
                pUsFile = (USHORT *)(pFileStart + pFileHdr5->version_data_offset);
 
-               
-                   dpram = (USHORT)DWNLD_MAG1_PS_HDR_LOC;                 
+
+                   dpram = (USHORT)DWNLD_MAG1_PS_HDR_LOC;
                    if (word_length & 0x1)
                        word_length++;
-                       
+
                    word_length = (word_length / 2);
-               
+
 
                for (; word_length > 0; word_length--) /* In words */
                {
-                   
+
                       templong = ntohs(*pUsFile++);
 					  temp = ntohs(*pUsFile++);
 					  templong |= (temp << 16);
-                      Status = fix_ft1000_write_dpram32 (ft1000dev, dpram++, (PUCHAR)&templong);                    
-                   
+                      Status = fix_ft1000_write_dpram32 (ft1000dev, dpram++, (PUCHAR)&templong);
+
                }
                break;
 
@@ -1272,12 +1272,12 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG  FileLe
                DEBUG("FT1000:download:REQUEST_CODE_BY_VERSION\n");
                bGoodVersion = FALSE;
                requested_version = get_request_value(ft1000dev);
-               
-                   pDspImageInfoV6 = (PDSP_IMAGE_INFO_V6)(pFileStart + sizeof(DSP_FILE_HDR_5));              
-               
+
+                   pDspImageInfoV6 = (PDSP_IMAGE_INFO_V6)(pFileStart + sizeof(DSP_FILE_HDR_5));
+
                for (imageN = 0; imageN < pFileHdr5->nDspImages; imageN++)
                {
-                   
+
                        temp = (USHORT)(pDspImageInfoV6->version);
                        templong = temp;
                        temp = (USHORT)(pDspImageInfoV6->version >> 16);
@@ -1295,10 +1295,10 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG  FileLe
                            break;
                         }
                         pDspImageInfoV6++;
-                    
+
 
                } //end of for
-               
+
                if (!bGoodVersion)
                {
                   /*
@@ -1332,7 +1332,7 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG  FileLe
          DEBUG("FT1000:download:Code loader is done...\n");
          uiState = STATE_SECTION_PROV;
          break;
- 
+
       case  STATE_SECTION_PROV:
          DEBUG("FT1000:download:STATE_SECTION_PROV\n");
          pHdr = (PPSEUDO_HDR)pUcFile;
@@ -1350,7 +1350,7 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG  FileLe
             pbuffer = kmalloc ( (usHdrLength + sizeof(PSEUDO_HDR) ), GFP_ATOMIC );
             if (pbuffer) {
                 memcpy(pbuffer, (void *)pUcFile, (UINT)(usHdrLength + sizeof(PSEUDO_HDR)));
-                // link provisioning data 
+                // link provisioning data
                 pprov_record = kmalloc( sizeof(PROV_RECORD), GFP_ATOMIC );
                 if (pprov_record) {
                     pprov_record->pprov_data = pbuffer;
@@ -1400,14 +1400,14 @@ u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG  FileLe
           break;
       }
 
-      Status = Harley_Read_Register(&temp, FT1000_REG_ASIC_ID); 
+      Status = Harley_Read_Register(&temp, FT1000_REG_ASIC_ID);
       if ( (Status != NDIS_STATUS_SUCCESS) || (temp == 0xffff) ) {
           break;
       }
 ****/
 
    } /* End while */
-   
+
    DEBUG("Download exiting with status = 0x%8x\n", Status);
    ft1000_write_register(ft1000dev, FT1000_DB_DNLD_TX, FT1000_REG_DOORBELL);
 

drivers/staging/ft1000/ft1000-usb/ft1000_ioctl.h

@@ -3,21 +3,21 @@
 //
 // Copyright (C) 2002 Flarion Technologies, All rights reserved.
 //
-// This program is free software; you can redistribute it and/or modify it 
+// This program is free software; you can redistribute it and/or modify it
 // under the terms of the GNU General Public License as published by the Free
-// Software Foundation; either version 2 of the License, or (at your option) any 
-// later version. This program is distributed in the hope that it will be useful, 
-// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
-// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
-// more details. You should have received a copy of the GNU General Public 
-// License along with this program; if not, write to the 
-// Free Software Foundation, Inc., 59 Temple Place - 
-// Suite 330, Boston, MA 02111-1307, USA. 
+// Software Foundation; either version 2 of the License, or (at your option) any
+// later version. This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+// more details. You should have received a copy of the GNU General Public
+// License along with this program; if not, write to the
+// Free Software Foundation, Inc., 59 Temple Place -
+// Suite 330, Boston, MA 02111-1307, USA.
 //---------------------------------------------------------------------------
 //
 // File:         ft1000_ioctl.h
 //
-// Description:    Common structures and defines relating to IOCTL 
+// Description:    Common structures and defines relating to IOCTL
 //
 // History:
 // 11/5/02    Whc                Created.
@@ -37,18 +37,18 @@
 
 // Standard Flarion Pseudo header
 typedef struct _PSEUDO_HDR
-{               
+{
    unsigned short    length;           //length of msg body
    unsigned char     source;           //source address (0x10=Host 0x20=DSP)
    unsigned char     destination;      //destination address (refer to source address)
-   unsigned char     portdest;         //destination port id 
+   unsigned char     portdest;         //destination port id
                                        //    0x00=Driver
                                        //    0x10=Application Broadcast
                                        //    0x20=Network Stack
                                        //    0x80=Dsp OAM
                                        //    0x90=Dsp Airlink
                                        //    0xa0=Dsp Loader
-                                       //    0xb0=Dsp MIP                 
+                                       //    0xb0=Dsp MIP
    unsigned char     portsrc;          //source port id (refer to portdest)
    unsigned short    sh_str_id;        //stream id (Not applicable on Mobile)
    unsigned char     control;          //stream id (Not applicable on Mobile)
@@ -97,14 +97,14 @@ typedef struct _IOCTL_GET_DSP_STAT
     unsigned long nRxPkts;                // Number of packets received from dsp to host
     unsigned long nTxBytes;               // Number of bytes transmitted from host to dsp
     unsigned long nRxBytes;               // Number of bytes received from dsp to host
-    unsigned long ConTm;                  // Current session connection time in seconds 
+    unsigned long ConTm;                  // Current session connection time in seconds
     unsigned char CalVer[CALVERSZ];       // Proprietary Calibration Version
     unsigned char CalDate[CALDATESZ];     // Proprietary Calibration Date
 } __attribute__ ((packed)) IOCTL_GET_DSP_STAT, *PIOCTL_GET_DSP_STAT;
 
 //Data structure for Dual Ported RAM messaging between Host and Dsp
 typedef struct _IOCTL_DPRAM_BLK
-{  
+{
     unsigned short total_len;
     PSEUDO_HDR pseudohdr;
     unsigned char buffer[1780];

drivers/staging/ft1000/ft1000-usb/ft1000_usb.c

@@ -73,7 +73,7 @@ int ft1000_poll_thread(void *arg)
         msleep(10);
         if ( ! gPollingfailed )
         {
-            ret = ft1000_poll(arg); 
+            ret = ft1000_poll(arg);
             if ( ret != STATUS_SUCCESS )
             {
                 DEBUG("ft1000_poll_thread: polling failed\n");
@@ -82,7 +82,7 @@ int ft1000_poll_thread(void *arg)
         }
     }
     //DEBUG("returned from polling thread\n");
-    return STATUS_SUCCESS;    
+    return STATUS_SUCCESS;
 }
 
 
@@ -104,7 +104,7 @@ static int ft1000_probe(struct usb_interface *interface, const struct usb_device
     struct usb_host_interface *iface_desc;
     struct usb_endpoint_descriptor *endpoint;
     struct usb_device *dev;
-    unsigned numaltsetting;    
+    unsigned numaltsetting;
     int i;
 
     struct ft1000_device *ft1000dev;
@@ -117,7 +117,7 @@ static int ft1000_probe(struct usb_interface *interface, const struct usb_device
     }
 
     memset(ft1000dev, 0, sizeof(*ft1000dev));
-    
+
 	//get usb device
     dev = interface_to_usbdev(interface);
     DEBUG("ft1000_probe: usb device descriptor info:\n");
@@ -134,9 +134,9 @@ static int ft1000_probe(struct usb_interface *interface, const struct usb_device
 
     DEBUG("ft1000_probe is called\n");
     numaltsetting = interface->num_altsetting;
-    DEBUG("ft1000_probe: number of alt settings is :%d\n",numaltsetting);     
+    DEBUG("ft1000_probe: number of alt settings is :%d\n",numaltsetting);
     iface_desc = interface->cur_altsetting;
-    DEBUG("ft1000_probe: number of endpoints is %d\n", iface_desc->desc.bNumEndpoints); 
+    DEBUG("ft1000_probe: number of endpoints is %d\n", iface_desc->desc.bNumEndpoints);
     DEBUG("ft1000_probe: descriptor type is %d\n", iface_desc->desc.bDescriptorType);
     DEBUG("ft1000_probe: interface number is %d\n", iface_desc->desc.bInterfaceNumber);
     DEBUG("ft1000_probe: alternatesetting is %d\n", iface_desc->desc.bAlternateSetting);
@@ -151,7 +151,7 @@ static int ft1000_probe(struct usb_interface *interface, const struct usb_device
 		endpoint = (struct usb_endpoint_descriptor *)&iface_desc->endpoint[i].desc;
                 DEBUG("endpoint %d\n", i);
                 DEBUG("bEndpointAddress=%x, bmAttributes=%x\n", endpoint->bEndpointAddress, endpoint->bmAttributes);
-		if ( (endpoint->bEndpointAddress & USB_DIR_IN) && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK))			 
+		if ( (endpoint->bEndpointAddress & USB_DIR_IN) && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK))
 		{
 			ft1000dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
 			DEBUG("ft1000_probe: in: %d\n", endpoint->bEndpointAddress);
@@ -163,7 +163,7 @@ static int ft1000_probe(struct usb_interface *interface, const struct usb_device
 			DEBUG("ft1000_probe: out: %d\n", endpoint->bEndpointAddress);
 		}
     }
-    
+
     DEBUG("bulk_in=%d, bulk_out=%d\n", ft1000dev->bulk_in_endpointAddr, ft1000dev->bulk_out_endpointAddr);
 
     //read DSP image
@@ -177,27 +177,27 @@ static int ft1000_probe(struct usb_interface *interface, const struct usb_device
 
     //for ( i=0; i< MAX_NUM_CARDS+2; i++)
     //    pdevobj[i] = NULL;
-    
+
     //download dsp image
     DEBUG("ft1000_probe: start downloading dsp image...\n");
     init_ft1000_netdev(ft1000dev);
     pft1000info = (FT1000_INFO *) netdev_priv (ft1000dev->net);
 
-//    DEBUG("In probe: pft1000info=%x\n", pft1000info);				// aelias [-] reason: warning: format ???%x??? expects type ???unsigned int???, but argument 2 has type ???struct FT1000_INFO *??? 
+//    DEBUG("In probe: pft1000info=%x\n", pft1000info);				// aelias [-] reason: warning: format ???%x??? expects type ???unsigned int???, but argument 2 has type ???struct FT1000_INFO *???
     DEBUG("In probe: pft1000info=%x\n", (unsigned int)pft1000info);		// aelias [+] reason: up
-    
+
     dsp_reload(ft1000dev);
     gPollingfailed = FALSE;  //mbelian
     pft1000info->pPollThread = kthread_run(ft1000_poll_thread, ft1000dev, "ft1000_poll");
 	msleep(500); //mbelian
-    
-    
+
+
     if ( pft1000info->DSP_loading )
     {
         DEBUG("ERROR!!!! RETURN FROM ft1000_probe **********************\n");
         return 0;
     }
-   
+
     while (!pft1000info->CardReady)
     {
         if ( gPollingfailed )
@@ -211,16 +211,16 @@ static int ft1000_probe(struct usb_interface *interface, const struct usb_device
         msleep(100);
         DEBUG("ft1000_probe::Waiting for Card Ready\n");
     }
-    
-   
+
+
     //initialize network device
     DEBUG("ft1000_probe::Card Ready!!!! Registering network device\n");
 
     reg_ft1000_netdev(ft1000dev, interface);
-    
+
     pft1000info->NetDevRegDone = 1;
 
-		ft1000InitProc(ft1000dev->net);// +mbelian 
+		ft1000InitProc(ft1000dev->net);// +mbelian
 
        return 0;
 }
@@ -229,7 +229,7 @@ static int ft1000_probe(struct usb_interface *interface, const struct usb_device
 // Function:    ft1000_disconnect
 //
 // Parameters:  struct usb_interface *interface  - passed by USB core
-//              
+//
 // Returns:     0 - success
 //
 // Description: This function is invoked when the express card is plugged out
@@ -240,11 +240,11 @@ static int ft1000_probe(struct usb_interface *interface, const struct usb_device
 static void ft1000_disconnect(struct usb_interface *interface)
 {
     FT1000_INFO *pft1000info;
-    
+
     DEBUG("ft1000_disconnect is called\n");
-    
+
     pft1000info = (PFT1000_INFO)usb_get_intfdata(interface);
-//    DEBUG("In disconnect pft1000info=%x\n", pft1000info);	// aelias [-] reason: warning: format ???%x??? expects type ???unsigned int???, but argument 2 has type ???struct FT1000_INFO *??? 
+//    DEBUG("In disconnect pft1000info=%x\n", pft1000info);	// aelias [-] reason: warning: format ???%x??? expects type ???unsigned int???, but argument 2 has type ???struct FT1000_INFO *???
     DEBUG("In disconnect pft1000info=%x\n", (unsigned int) pft1000info);	// aelias [+] reason: up
 
 
@@ -256,9 +256,9 @@ static void ft1000_disconnect(struct usb_interface *interface)
         {
             kthread_stop(pft1000info->pPollThread );
         }
-        
+
         DEBUG("ft1000_disconnect: threads are terminated\n");
-    
+
         if (pft1000info->pFt1000Dev->net)
         {
             DEBUG("ft1000_disconnect: destroy char driver\n");
@@ -271,17 +271,17 @@ static void ft1000_disconnect(struct usb_interface *interface)
             free_netdev(pft1000info->pFt1000Dev->net);
 
         }
-        
+
         usb_free_urb(pft1000info->pFt1000Dev->rx_urb);
         usb_free_urb(pft1000info->pFt1000Dev->tx_urb);
-    
+
         DEBUG("ft1000_disconnect: urb freed\n");
 
 		kfree(pft1000info->pFt1000Dev); //+mbelian
     }
 
     //terminate other kernel threads
-    //in multiple instances case, first find the device 
+    //in multiple instances case, first find the device
     //in the link list
     /**if (pPollThread)
     {
@@ -304,7 +304,7 @@ static struct usb_driver ft1000_usb_driver = {
 // Function:    usb_ft1000_init
 //
 // Parameters:  none
-//              
+//
 // Returns:     0 - success
 //
 // Description: The entry point of the module, register the usb driver
@@ -315,7 +315,7 @@ static struct usb_driver ft1000_usb_driver = {
 static int __init usb_ft1000_init(void)
 {
     int ret = 0;
-    
+
     DEBUG("Initialize and register the driver\n");
 
     ret = usb_register(&ft1000_usb_driver);
@@ -328,9 +328,9 @@ static int __init usb_ft1000_init(void)
 //---------------------------------------------------------------------------
 // Function:    usb_ft1000_exit
 //
-// Parameters:  
-//              
-// Returns:     
+// Parameters:
+//
+// Returns:
 //
 // Description: Moudle unload function, deregister usb driver
 //

drivers/staging/ft1000/ft1000-usb/ft1000_usb.h

@@ -24,7 +24,7 @@
 #define MAX_CMD_SQSIZE          1780
 #define SLOWQ_TYPE              0
 #define PSEUDOSZ                16
-#define DSP_QID_OFFSET          4     
+#define DSP_QID_OFFSET          4
 
 
 // MEMORY MAP FOR ELECTRABUZZ ASIC
@@ -58,7 +58,7 @@ typedef struct _MEDIAMSG {
 	u16 state;
 	u32 ip_addr;
         u32 net_mask;
-	u32 gateway;  
+	u32 gateway;
 	u32 dns_1;
 	u32 dns_2;
 } __attribute__ ((packed)) MEDIAMSG, *PMEDIAMSG;
@@ -209,7 +209,7 @@ typedef struct _PROV_RECORD {
 
 // DSP doorbells
 
-#define FT1000_DB_DPRAM_RX		0x0001	// this value indicates that DSP has 
+#define FT1000_DB_DPRAM_RX		0x0001	// this value indicates that DSP has
 
                                         //      data for host in DPRAM SlowQ
 
@@ -227,15 +227,15 @@ typedef struct _PROV_RECORD {
 
 // Host doorbells
 
-#define FT1000_DB_DPRAM_TX		0x0100	// this value indicates that host has 
+#define FT1000_DB_DPRAM_TX		0x0100	// this value indicates that host has
 
-                                        //      data for DSP in DPRAM. 
+                                        //      data for DSP in DPRAM.
 
 #define FT1000_DB_DNLD_TX       0x0200  // Downloader handshake doorbell
 
 #define FT1000_ASIC_RESET_DSP   0x0400
 
-#define FT1000_DB_HB            0x1000  // this value indicates that supervisor 
+#define FT1000_DB_HB            0x1000  // this value indicates that supervisor
 
 
 
@@ -267,7 +267,7 @@ typedef struct _PROV_RECORD {
 
 #define DSP_TIMESTAMP           0x1FFC  // dsp timestamp
 
-#define DSP_TIMESTAMP_DIFF      0x1FFA  // difference of dsp timestamp in DPRAM and Pseudo header.  
+#define DSP_TIMESTAMP_DIFF      0x1FFA  // difference of dsp timestamp in DPRAM and Pseudo header.
 
 
 
@@ -295,7 +295,7 @@ typedef struct _PROV_RECORD {
 
 #define FT1000_MAG_FIFO_LEN              0x1FF   // total length for DSP FIFO tracking
 
-#define FT1000_MAG_FIFO_LEN_INDX         0x1     // low-word index 
+#define FT1000_MAG_FIFO_LEN_INDX         0x1     // low-word index
 
 #define FT1000_MAG_HI_HO                 0x1FF   // heartbeat with HI/HO
 
@@ -345,7 +345,7 @@ typedef struct _PROV_RECORD {
 
 #define FT1000_MAG_TOTAL_LEN             0x200
 
-#define FT1000_MAG_TOTAL_LEN_INDX        0x1    
+#define FT1000_MAG_TOTAL_LEN_INDX        0x1
 
 
 
@@ -377,13 +377,13 @@ typedef struct _PROV_RECORD {
 
 #define ISR_EMPTY			(UCHAR)0x00 	 // no bits set in ISR
 
-#define ISR_DOORBELL_ACK	(UCHAR)0x01		 //  the doorbell i sent has been recieved. 	   
+#define ISR_DOORBELL_ACK	(UCHAR)0x01		 //  the doorbell i sent has been recieved.
 
 #define ISR_DOORBELL_PEND	(UCHAR)0x02 	 //  doorbell for me
 
 #define ISR_RCV				(UCHAR)0x04 	 // packet received with no errors
 
-#define ISR_WATERMARK		(UCHAR)0x08 	 //  
+#define ISR_WATERMARK		(UCHAR)0x08 	 //
 
 
 
@@ -391,15 +391,15 @@ typedef struct _PROV_RECORD {
 
 // note these are different from the ISR BIT MAPS.
 
-#define ISR_MASK_NONE			0x0000 	  
+#define ISR_MASK_NONE			0x0000
 
-#define ISR_MASK_DOORBELL_ACK	0x0001	
+#define ISR_MASK_DOORBELL_ACK	0x0001
 
-#define ISR_MASK_DOORBELL_PEND	0x0002 	
+#define ISR_MASK_DOORBELL_PEND	0x0002
 
-#define ISR_MASK_RCV			0x0004 	
+#define ISR_MASK_RCV			0x0004
 
-#define ISR_MASK_WATERMARK		0x0008 	  // Normally we will only mask the watermark interrupt when we want to enable interrupts. 
+#define ISR_MASK_WATERMARK		0x0008 	  // Normally we will only mask the watermark interrupt when we want to enable interrupts.
 
 #define ISR_MASK_ALL			0xffff
 
@@ -411,7 +411,7 @@ typedef struct _PROV_RECORD {
 
 
 
-#define ISR_DEFAULT_MASK		0x7ff9		
+#define ISR_DEFAULT_MASK		0x7ff9
 
 
 
@@ -515,7 +515,7 @@ struct ft1000_device
 
 	u8 tx_buf[MAX_BUF_SIZE];
 	u8 rx_buf[MAX_BUF_SIZE];
-	
+
 	u8 bulk_in_endpointAddr;
 	u8 bulk_out_endpointAddr;
 
@@ -527,18 +527,18 @@ struct ft1000_device
 typedef struct _FT1000_INFO {
     struct ft1000_device *pFt1000Dev;
     struct net_device_stats stats;
-    
+
     struct task_struct *pPollThread;
-    
-    unsigned char fcodeldr; 
+
+    unsigned char fcodeldr;
     unsigned char bootmode;
 	unsigned char usbboot;
     unsigned short dspalive;
     u16 ASIC_ID;
-    BOOLEAN fProvComplete;   
-    BOOLEAN fCondResetPend;    
-    BOOLEAN fAppMsgPend;     
-    char *pfwimg;                 
+    BOOLEAN fProvComplete;
+    BOOLEAN fCondResetPend;
+    BOOLEAN fAppMsgPend;
+    char *pfwimg;
     int fwimgsz;
     u16 DrvErrNum;
     u8  *pTestImage;
@@ -585,7 +585,7 @@ typedef struct _FT1000_INFO {
     u16 ProgConStat;
     struct list_head prov_list;
     int appcnt;
-    APP_INFO_BLOCK app_info[MAX_NUM_APP]; //Added by Jim    
+    APP_INFO_BLOCK app_info[MAX_NUM_APP]; //Added by Jim
     u16 DSPInfoBlklen;
     u16 DrvMsgPend;
     int (*ft1000_reset)(struct net_device *dev);