UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

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>
This commit is contained in:
Greg Kroah-Hartman 2010-09-22 08:34:49 -07:00
parent 43589a832d
commit bf3146c865
14 changed files with 779 additions and 779 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/staging/ft1000/Kconfig
View File

@ -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

26
drivers/staging/ft1000/ft1000-pcmcia/boot.h
View File

@ -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

60
drivers/staging/ft1000/ft1000-pcmcia/ft1000.h
View File

@ -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;

14
drivers/staging/ft1000/ft1000-pcmcia/ft1000_cs.c
View File

@ -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)

18
drivers/staging/ft1000/ft1000-pcmcia/ft1000_dev.h
View File

@ -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

28
drivers/staging/ft1000/ft1000-pcmcia/ft1000_dnld.c
View File

@ -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);

82
drivers/staging/ft1000/ft1000-pcmcia/ft1000_hw.c
View File

@ -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",

4
drivers/staging/ft1000/ft1000-pcmcia/ft1000_proc.c
View File

@ -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

212
drivers/staging/ft1000/ft1000-usb/ft1000_chdev.c
View File

@ -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;
}

202
drivers/staging/ft1000/ft1000-usb/ft1000_download.c
View File

@ -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);

762
drivers/staging/ft1000/ft1000-usb/ft1000_hw.c
View File

File diff suppressed because it is too large Load Diff

30
drivers/staging/ft1000/ft1000-usb/ft1000_ioctl.h
View File

@ -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];

64
drivers/staging/ft1000/ft1000-usb/ft1000_usb.c
View File

@ -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
//

52
drivers/staging/ft1000/ft1000-usb/ft1000_usb.h
View File

@ -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);