staging: bcm: remove driver

S:	Maintained:

F:	drivers/md/bcache/

BECEEM BCS200/BCS220-3/BCSM250 WIMAX SUPPORT

M: Kevin McKinney <klmckinney1@gmail.com>

M: Matthias Beyer <mail@beyermatthias.de>

L: devel@driverdev.osuosl.org

S: Maintained

F: drivers/staging/bcm*

BEFS FILE SYSTEM

S:	Orphan

F:	Documentation/filesystems/befs.txt

source "drivers/staging/emxx_udc/Kconfig"

source "drivers/staging/bcm/Kconfig"

source "drivers/staging/ft1000/Kconfig"

source "drivers/staging/speakup/Kconfig"

obj-$(CONFIG_IIO)		+= iio/

obj-$(CONFIG_FB_XGI)		+= xgifb/

obj-$(CONFIG_USB_EMXX)		+= emxx_udc/

obj-$(CONFIG_BCM_WIMAX)		+= bcm/

obj-$(CONFIG_FT1000)		+= ft1000/

obj-$(CONFIG_SPEAKUP)		+= speakup/

obj-$(CONFIG_TOUCHSCREEN_CLEARPAD_TM1217)	+= cptm1217/

/***********************************

*	Adapter.h

************************************/

#ifndef	__ADAPTER_H__

#define	__ADAPTER_H__

#define MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES 256

#include "Debug.h"

struct bcm_leader {

	USHORT	Vcid;

	USHORT	PLength;

	UCHAR	Status;

	UCHAR	Unused[3];

} __packed;

struct bcm_packettosend {

	struct bcm_leader Leader;

	UCHAR	ucPayload;

} __packed;

struct bcm_control_packet {

	PVOID	ControlBuff;

	UINT	ControlBuffLen;

	struct bcm_control_packet *next;

} __packed;

struct bcm_link_request {

	struct bcm_leader Leader;

	UCHAR	szData[4];

} __packed;

#define MAX_IP_RANGE_LENGTH 4

#define MAX_PORT_RANGE 4

#define MAX_PROTOCOL_LENGTH   32

#define IPV6_ADDRESS_SIZEINBYTES 0x10

union u_ip_address {

	struct {

		/* Source Ip Address Range */

		ULONG ulIpv4Addr[MAX_IP_RANGE_LENGTH];

		 /* Source Ip Mask Address Range */

		ULONG ulIpv4Mask[MAX_IP_RANGE_LENGTH];

	};

	struct {

		/* Source Ip Address Range */

		ULONG ulIpv6Addr[MAX_IP_RANGE_LENGTH * 4];

		/* Source Ip Mask Address Range */

		ULONG ulIpv6Mask[MAX_IP_RANGE_LENGTH * 4];

	};

	struct {

		UCHAR ucIpv4Address[MAX_IP_RANGE_LENGTH * IP_LENGTH_OF_ADDRESS];

		UCHAR ucIpv4Mask[MAX_IP_RANGE_LENGTH * IP_LENGTH_OF_ADDRESS];

	};

	struct {

		UCHAR ucIpv6Address[MAX_IP_RANGE_LENGTH * IPV6_ADDRESS_SIZEINBYTES];

		UCHAR ucIpv6Mask[MAX_IP_RANGE_LENGTH * IPV6_ADDRESS_SIZEINBYTES];

	};

};

struct bcm_hdr_suppression_contextinfo {

	/* Intermediate buffer to accumulate pkt Header for PHS */

	UCHAR ucaHdrSuppressionInBuf[MAX_PHS_LENGTHS];

	/* Intermediate buffer containing pkt Header after PHS */

	UCHAR ucaHdrSuppressionOutBuf[MAX_PHS_LENGTHS + PHSI_LEN];

};

struct bcm_classifier_rule {

	ULONG		ulSFID;

	UCHAR		ucReserved[2];

	B_UINT16	uiClassifierRuleIndex;

	bool		bUsed;

	USHORT		usVCID_Value;

	/* This field detemines the Classifier Priority */

	B_UINT8		u8ClassifierRulePriority;

	union u_ip_address	stSrcIpAddress;

	UCHAR		ucIPSourceAddressLength; /* Ip Source Address Length */

	union u_ip_address	stDestIpAddress;

	/* Ip Destination Address Length */

	UCHAR		ucIPDestinationAddressLength;

	UCHAR		ucIPTypeOfServiceLength; /* Type of service Length */

	UCHAR		ucTosLow; /* Tos Low */

	UCHAR		ucTosHigh; /* Tos High */

	UCHAR		ucTosMask; /* Tos Mask */

	UCHAR		ucProtocolLength; /* protocol Length */

	UCHAR		ucProtocol[MAX_PROTOCOL_LENGTH]; /* protocol Length */

	USHORT		usSrcPortRangeLo[MAX_PORT_RANGE];

	USHORT		usSrcPortRangeHi[MAX_PORT_RANGE];

	UCHAR		ucSrcPortRangeLength;

	USHORT		usDestPortRangeLo[MAX_PORT_RANGE];

	USHORT		usDestPortRangeHi[MAX_PORT_RANGE];

	UCHAR		ucDestPortRangeLength;

	bool		bProtocolValid;

	bool		bTOSValid;

	bool		bDestIpValid;

	bool		bSrcIpValid;

	/* For IPv6 Addressing */

	UCHAR		ucDirection;

	bool		bIpv6Protocol;

	UINT32		u32PHSRuleID;

	struct bcm_phs_rule sPhsRule;

	UCHAR		u8AssociatedPHSI;

	/* Classification fields for ETH CS */

	UCHAR		ucEthCSSrcMACLen;

	UCHAR		au8EThCSSrcMAC[MAC_ADDRESS_SIZE];

	UCHAR		au8EThCSSrcMACMask[MAC_ADDRESS_SIZE];

	UCHAR		ucEthCSDestMACLen;

	UCHAR		au8EThCSDestMAC[MAC_ADDRESS_SIZE];

	UCHAR		au8EThCSDestMACMask[MAC_ADDRESS_SIZE];

	UCHAR		ucEtherTypeLen;

	UCHAR		au8EthCSEtherType[NUM_ETHERTYPE_BYTES];

	UCHAR		usUserPriority[2];

	USHORT		usVLANID;

	USHORT		usValidityBitMap;

};

struct bcm_fragmented_packet_info {

	bool			bUsed;

	ULONG			ulSrcIpAddress;

	USHORT			usIpIdentification;

	struct bcm_classifier_rule *pstMatchedClassifierEntry;

	bool			bOutOfOrderFragment;

};

struct bcm_packet_info {

	/* classification extension Rule */

	ULONG		ulSFID;

	USHORT		usVCID_Value;

	UINT		uiThreshold;

	/* This field determines the priority of the SF Queues */

	B_UINT8		u8TrafficPriority;

	bool		bValid;

	bool		bActive;

	bool		bActivateRequestSent;

	B_UINT8		u8QueueType; /* BE or rtPS */

	/* maximum size of the bucket for the queue */

	UINT		uiMaxBucketSize;

	UINT		uiCurrentQueueDepthOnTarget;

	UINT		uiCurrentBytesOnHost;

	UINT		uiCurrentPacketsOnHost;

	UINT		uiDroppedCountBytes;

	UINT		uiDroppedCountPackets;

	UINT		uiSentBytes;

	UINT		uiSentPackets;

	UINT		uiCurrentDrainRate;

	UINT		uiThisPeriodSentBytes;

	LARGE_INTEGER	liDrainCalculated;

	UINT		uiCurrentTokenCount;

	LARGE_INTEGER	liLastUpdateTokenAt;

	UINT		uiMaxAllowedRate;

	UINT		NumOfPacketsSent;

	UCHAR		ucDirection;

	USHORT		usCID;

	struct bcm_mibs_parameters stMibsExtServiceFlowTable;

	UINT		uiCurrentRxRate;

	UINT		uiThisPeriodRxBytes;

	UINT		uiTotalRxBytes;

	UINT		uiTotalTxBytes;

	UINT		uiPendedLast;

	UCHAR		ucIpVersion;

	union {

		struct {

			struct sk_buff *FirstTxQueue;

			struct sk_buff *LastTxQueue;

		};

		struct {

			struct sk_buff *ControlHead;

			struct sk_buff *ControlTail;

		};

	};

	bool		bProtocolValid;

	bool		bTOSValid;

	bool		bDestIpValid;

	bool		bSrcIpValid;

	bool		bActiveSet;

	bool		bAdmittedSet;

	bool		bAuthorizedSet;

	bool		bClassifierPriority;

	UCHAR		ucServiceClassName[MAX_CLASS_NAME_LENGTH];

	bool		bHeaderSuppressionEnabled;

	spinlock_t	SFQueueLock;

	void		*pstSFIndication;

	struct timeval	stLastUpdateTokenAt;

	atomic_t	uiPerSFTxResourceCount;

	UINT		uiMaxLatency;

	UCHAR		bIPCSSupport;

	UCHAR		bEthCSSupport;

};

struct bcm_tarang_data {

	struct bcm_tarang_data	*next;

	struct bcm_mini_adapter	*Adapter;

	struct sk_buff		*RxAppControlHead;

	struct sk_buff		*RxAppControlTail;

	int			AppCtrlQueueLen;

	bool			MacTracingEnabled;

	bool			bApplicationToExit;

	struct bcm_mibs_dropped_cntrl_msg stDroppedAppCntrlMsgs;

	ULONG			RxCntrlMsgBitMask;

};

struct bcm_targetdsx_buffer {

	ULONG		ulTargetDsxBuffer;

	B_UINT16	tid;

	bool		valid;

};

typedef int (*FP_FLASH_WRITE)(struct bcm_mini_adapter *, UINT, PVOID);

typedef int (*FP_FLASH_WRITE_STATUS)(struct bcm_mini_adapter *, UINT, PVOID);

/*

 * Driver adapter data structure

 */

struct bcm_mini_adapter {

	struct bcm_mini_adapter	*next;

	struct net_device	*dev;

	u32			msg_enable;

	CHAR			*caDsxReqResp;

	atomic_t		ApplicationRunning;

	bool			AppCtrlQueueOverFlow;

	atomic_t		CurrentApplicationCount;

	atomic_t		RegisteredApplicationCount;

	bool			LinkUpStatus;

	bool			TimerActive;

	u32			StatisticsPointer;

	struct sk_buff		*RxControlHead;

	struct sk_buff		*RxControlTail;

	struct semaphore	RxAppControlQueuelock;

	struct semaphore	fw_download_sema;

	struct bcm_tarang_data	*pTarangs;

	spinlock_t		control_queue_lock;

	wait_queue_head_t	process_read_wait_queue;

	/* the pointer to the first packet we have queued in send

	 * deserialized miniport support variables

	 */

	atomic_t		TotalPacketCount;

	atomic_t		TxPktAvail;

	/* this to keep track of the Tx and Rx MailBox Registers. */

	atomic_t		CurrNumFreeTxDesc;

	/* to keep track the no of byte received */

	USHORT			PrevNumRecvDescs;

	USHORT			CurrNumRecvDescs;

	UINT			u32TotalDSD;

	struct bcm_packet_info	PackInfo[NO_OF_QUEUES];

	struct bcm_classifier_rule astClassifierTable[MAX_CLASSIFIERS];

	bool			TransferMode;

	/*************** qos ******************/

	bool			bETHCSEnabled;

	ULONG			BEBucketSize;

	ULONG			rtPSBucketSize;

	UCHAR			LinkStatus;

	bool			AutoLinkUp;

	bool			AutoSyncup;

	int			major;

	int			minor;

	wait_queue_head_t	tx_packet_wait_queue;

	wait_queue_head_t	process_rx_cntrlpkt;

	atomic_t		process_waiting;

	bool			fw_download_done;

	char			*txctlpacket[MAX_CNTRL_PKTS];

	atomic_t		cntrlpktCnt;

	atomic_t		index_app_read_cntrlpkt;

	atomic_t		index_wr_txcntrlpkt;

	atomic_t		index_rd_txcntrlpkt;

	UINT			index_datpkt;

	struct semaphore	rdmwrmsync;

	struct bcm_targetdsx_buffer	astTargetDsxBuffer[MAX_TARGET_DSX_BUFFERS];

	ULONG			ulFreeTargetBufferCnt;

	ULONG			ulCurrentTargetBuffer;

	ULONG			ulTotalTargetBuffersAvailable;

	unsigned long		chip_id;

	wait_queue_head_t	lowpower_mode_wait_queue;

	bool			bFlashBoot;

	bool			bBinDownloaded;

	bool			bCfgDownloaded;

	bool			bSyncUpRequestSent;

	USHORT			usBestEffortQueueIndex;

	wait_queue_head_t	ioctl_fw_dnld_wait_queue;

	bool			waiting_to_fw_download_done;

	pid_t			fw_download_process_pid;

	struct bcm_target_params *pstargetparams;

	bool			device_removed;

	bool			DeviceAccess;

	bool			bIsAutoCorrectEnabled;

	bool			bDDRInitDone;

	int			DDRSetting;

	ULONG			ulPowerSaveMode;

	spinlock_t		txtransmitlock;

	B_UINT8			txtransmit_running;

	/* Thread for control packet handling */

	struct task_struct	*control_packet_handler;

	/* thread for transmitting packets. */

	struct task_struct	*transmit_packet_thread;

	/* LED Related Structures */

	struct bcm_led_info	LEDInfo;

	/* Driver State for LED Blinking */

	enum bcm_led_events	DriverState;

	/* Interface Specific */

	PVOID			pvInterfaceAdapter;

	int (*bcm_file_download)(PVOID,

				struct file *,

				unsigned int);

	int (*bcm_file_readback_from_chip)(PVOID,

					struct file *,

					unsigned int);

	int (*interface_rdm)(PVOID,

			UINT,

			PVOID,

			int);

	int (*interface_wrm)(PVOID,

			UINT,

			PVOID,

			int);

	int (*interface_transmit)(PVOID, PVOID , UINT);

	bool			IdleMode;

	bool			bDregRequestSentInIdleMode;

	bool			bTriedToWakeUpFromlowPowerMode;

	bool			bShutStatus;

	bool			bWakeUpDevice;

	unsigned int		usIdleModePattern;

	/* BOOLEAN			bTriedToWakeUpFromShutdown; */

	bool			bLinkDownRequested;

	int			downloadDDR;

	struct bcm_phs_extension stBCMPhsContext;

	struct bcm_hdr_suppression_contextinfo stPhsTxContextInfo;

	uint8_t			ucaPHSPktRestoreBuf[2048];

	uint8_t			bPHSEnabled;

	bool			AutoFirmDld;

	bool			bMipsConfig;

	bool			bDPLLConfig;

	UINT32			aTxPktSizeHist[MIBS_MAX_HIST_ENTRIES];

	UINT32			aRxPktSizeHist[MIBS_MAX_HIST_ENTRIES];

	struct bcm_fragmented_packet_info

		astFragmentedPktClassifierTable[MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES];

	atomic_t		uiMBupdate;

	UINT32			PmuMode;

	enum bcm_nvm_type	eNVMType;

	UINT			uiSectorSize;

	UINT			uiSectorSizeInCFG;

	bool			bSectorSizeOverride;

	bool			bStatusWrite;

	UINT			uiNVMDSDSize;

	UINT			uiVendorExtnFlag;

	/* it will always represent chosen DSD at any point of time.

	 * Generally it is Active DSD but in case of NVM RD/WR it

	 * might be different.

	 */

	UINT			ulFlashCalStart;

	ULONG			ulFlashControlSectionStart;

	ULONG			ulFlashWriteSize;

	ULONG			ulFlashID;

	FP_FLASH_WRITE		fpFlashWrite;

	FP_FLASH_WRITE_STATUS	fpFlashWriteWithStatusCheck;

	struct semaphore	NVMRdmWrmLock;

	struct device		*pstCreatedClassDevice;

	/*	BOOLEAN				InterfaceUpStatus; */

	struct bcm_flash2x_cs_info *psFlash2xCSInfo;

	struct bcm_flash_cs_info *psFlashCSInfo;

	struct bcm_flash2x_vendor_info *psFlash2xVendorInfo;

	UINT			uiFlashBaseAdd; /* Flash start address */

	/* Active ISO offset chosen before f/w download */

	UINT			uiActiveISOOffset;

	enum bcm_flash2x_section_val eActiveISO; /* Active ISO section val */

	/* Active DSD val chosen before f/w download */

	enum bcm_flash2x_section_val eActiveDSD;

	/* For accessing Active DSD chosen before f/w download */

	UINT			uiActiveDSDOffsetAtFwDld;

	UINT			uiFlashLayoutMajorVersion;

	UINT			uiFlashLayoutMinorVersion;

	bool			bAllDSDWriteAllow;

	bool			bSigCorrupted;

	/* this should be set who so ever want to change the Headers.

	 * after Write it should be reset immediately.

	 */

	bool			bHeaderChangeAllowed;

	int			SelectedChip;

	bool			bEndPointHalted;

	/* while bFlashRawRead will be true, Driver

	 * ignore map lay out and consider flash as of without any map.

	 */

	bool			bFlashRawRead;

	bool			bPreparingForLowPowerMode;

	bool			bDoSuspend;

	UINT			syscfgBefFwDld;

	bool			StopAllXaction;

	/* Used to Support extended CAPI requirements from */

	UINT32			liTimeSinceLastNetEntry;

	struct semaphore	LowPowerModeSync;

	ULONG			liDrainCalculated;

	UINT			gpioBitMap;

	struct bcm_debug_state	stDebugState;

};

#define GET_BCM_ADAPTER(net_dev) netdev_priv(net_dev)

struct bcm_eth_header {

	UCHAR	au8DestinationAddress[6];

	UCHAR	au8SourceAddress[6];

	USHORT	u16Etype;

} __packed;

struct bcm_firmware_info {

	void	__user *pvMappedFirmwareAddress;

	ULONG	u32FirmwareLength;

	ULONG	u32StartingAddress;

} __packed;

/* holds the value of net_device structure.. */

extern struct net_device *gblpnetdev;

struct bcm_ddr_setting {

	UINT ulRegAddress;

	UINT ulRegValue;

};

int InitAdapter(struct bcm_mini_adapter *psAdapter);

/* =====================================================================

 * Beceem vendor request codes for EP0

 * =====================================================================

 */

#define BCM_REQUEST_READ	0x2

#define BCM_REQUEST_WRITE	0x1

#define EP2_MPS_REG		0x0F0110A0

#define EP2_MPS			0x40

#define EP2_CFG_REG	0x0F0110A8

#define EP2_CFG_INT	0x27

#define EP2_CFG_BULK	0x25

#define EP4_MPS_REG	0x0F0110F0

#define EP4_MPS		0x8C

#define EP4_CFG_REG	0x0F0110F8

#define ISO_MPS_REG	0x0F0110C8

#define ISO_MPS		0x00000000

#define EP1 0

#define EP2 1

#define EP3 2

#define EP4 3

#define EP5 4

#define EP6 5

enum bcm_einterface_setting {

	DEFAULT_SETTING_0  = 0,

	ALTERNATE_SETTING_1 = 1,

};

#endif	/* __ADAPTER_H__ */