Merge git://git.kernel.org/pub/scm/linux/kernel/git/shemminger/beceem into work-next (2ff81110) · Commits · e / devices / android_kernel_teracube_emerald

drivers/staging/bcm/Adapter.h

+32 −98

Original line number	Diff line number	Diff line
		@@ -7,53 +7,6 @@
		#define MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES 256
		#include "Debug.h"

		typedef struct _LIST_ENTRY{
		struct _LIST_ENTRY *next;
		struct _LIST_ENTRY *prev;
		} LIST_ENTRY, *PLIST_ENTRY;

		typedef struct _BCM_LIST_ENTRY {

		LIST_ENTRY Link;

		} BCM_LIST_ENTRY, *PBCM_LIST_ENTRY;

		typedef enum _RCB_STATUS
		{
		DRIVER_PROCESSED=1,
		APPLICATION_PROCESSED
		} RCB_STATUS, *PRCB_STATUS;

		#define fFILLED 1
		#define fEMPTY 0

		struct _BCM_CB
		{
		// The network packet that this RCB is receiving
		PVOID pv_packet;
		// Describes the length of the packet .
		UINT ui_packet_length;
		// Pointer to the first buffer in the packet (only one buffer for Rx)
		PUCHAR buffer;
		atomic_t status;
		UINT filled;
		} __attribute__((packed));
		typedef struct _BCM_CB BCM_CB,*PBCM_CB;

		typedef BCM_CB BCM_RCB, *PBCM_RCB;
		typedef BCM_CB BCM_TCB, *PBCM_TCB;

		/* This is to be stored in the "pvOsDepData" of ADAPTER */
		typedef struct LINUX_DEP_DATA
		{
		struct net_device virtualdev; / Our Interface (veth0) */
		struct net_device actualdev; / True Interface (eth0) */
		struct net_device_stats netstats; /* Net statistics */
		struct fasync_struct async_queue; / For asynchronus notification */

		} LINUX_DEP_DATA, *PLINUX_DEP_DATA;


		struct _LEADER
		{
		USHORT Vcid;
		@@ -429,7 +382,9 @@ Driver adapter data structure
		struct _MINI_ADAPTER
		{
		struct _MINI_ADAPTER *next;
		PVOID pvOsDepData;
		struct net_device *dev;
		u32 msg_enable;

		CHAR *caDsxReqResp;
		atomic_t ApplicationRunning;
		volatile INT CtrlQueueLen;
		@@ -437,18 +392,18 @@ struct _MINI_ADAPTER
		BOOLEAN AppCtrlQueueOverFlow;
		atomic_t CurrentApplicationCount;
		atomic_t RegisteredApplicationCount;
		BOOLEAN LinkUpStatus;
		BOOLEAN TimerActive;
		ULONG StatisticsPointer;
		u32 StatisticsPointer;
		struct sk_buff *RxControlHead;
		struct sk_buff *RxControlTail;
		// spinlock_t RxControlQueuelock;

		struct semaphore RxAppControlQueuelock;
		struct semaphore fw_download_sema;

		PPER_TARANG_DATA pTarangs;
		spinlock_t control_queue_lock;
		wait_queue_head_t process_read_wait_queue;
		ULONG bcm_jiffies; /* Store Jiffies value */

		// the pointer to the first packet we have queued in send
		// deserialized miniport support variables
		@@ -458,24 +413,15 @@ struct _MINI_ADAPTER
		// this to keep track of the Tx and Rx MailBox Registers.
		atomic_t CurrNumFreeTxDesc;
		// to keep track the no of byte recieved
		atomic_t RxRollOverCount;
		USHORT PrevNumRecvDescs;
		USHORT CurrNumRecvDescs;
		atomic_t GoodRxByteCount;
		atomic_t GoodRxPktCount;
		atomic_t BadRxByteCount;
		atomic_t RxPacketDroppedCount;
		atomic_t GoodTxByteCount;
		atomic_t TxTotalPacketCount;
		atomic_t TxDroppedPacketCount;
		ULONG LinkUpStatus;
		BOOLEAN TransferMode;
		UINT u32TotalDSD;
		PacketInfo PackInfo[NO_OF_QUEUES];
		S_CLASSIFIER_RULE astClassifierTable[MAX_CLASSIFIERS];
		BOOLEAN TransferMode;

		/************* qos ****************/
		UINT bETHCSEnabled;
		BOOLEAN bETHCSEnabled;

		ULONG BEBucketSize;
		ULONG rtPSBucketSize;
		@@ -483,7 +429,6 @@ struct _MINI_ADAPTER
		BOOLEAN AutoLinkUp;
		BOOLEAN AutoSyncup;

		struct net_device *dev;
		int major;
		int minor;
		wait_queue_head_t tx_packet_wait_queue;
		@@ -491,8 +436,6 @@ struct _MINI_ADAPTER
		atomic_t process_waiting;
		BOOLEAN fw_download_done;

		unsigned int ctrlpkt_present;
		BOOLEAN packets_given_to_all;
		char *txctlpacket[MAX_CNTRL_PKTS];
		atomic_t cntrlpktCnt ;
		atomic_t index_app_read_cntrlpkt;
		@@ -505,31 +448,27 @@ struct _MINI_ADAPTER
		ULONG ulFreeTargetBufferCnt;
		ULONG ulCurrentTargetBuffer;
		ULONG ulTotalTargetBuffersAvailable;
		unsigned int timeout;
		int irq;

		unsigned long chip_id;
		unsigned int bFlashBoot;
		unsigned int if_up;
		// spinlock_t sleeper_lock;
		atomic_t rdm_wrm_access;
		atomic_t tx_rx_access;

		wait_queue_head_t lowpower_mode_wait_queue;
		atomic_t bAbortedByHost;

		BOOLEAN bFlashBoot;
		BOOLEAN bBinDownloaded;
		BOOLEAN bCfgDownloaded;
		USHORT usBestEffortQueueIndex;
		BOOLEAN bSyncUpRequestSent;
		// struct semaphore data_packet_queue_lock;
		USHORT usBestEffortQueueIndex;

		wait_queue_head_t ioctl_fw_dnld_wait_queue;
		BOOLEAN waiting_to_fw_download_done;
		pid_t fw_download_process_pid;
		PSTARGETPARAMS pstargetparams;
		BOOLEAN device_removed;
		BOOLEAN DeviceAccess;
		INT DDRSetting;
		BOOLEAN bIsAutoCorrectEnabled;
		BOOLEAN bDDRInitDone;
		INT DDRSetting;
		ULONG ulPowerSaveMode;
		BOOLEAN bIsAutoCorrectEnabled;
		spinlock_t txtransmitlock;
		B_UINT8 txtransmit_running;
		/* Thread for control packet handling */
		@@ -567,13 +506,13 @@ struct _MINI_ADAPTER
		unsigned int usIdleModePattern;
		//BOOLEAN bTriedToWakeUpFromShutdown;
		BOOLEAN bLinkDownRequested;
		unsigned int check_for_hang;

		int downloadDDR;
		PHS_DEVICE_EXTENSION stBCMPhsContext;
		S_HDR_SUPRESSION_CONTEXTINFO stPhsTxContextInfo;
		uint8_t ucaPHSPktRestoreBuf[2048];
		uint8_t bPHSEnabled;
		int AutoFirmDld;
		BOOLEAN AutoFirmDld;
		BOOLEAN bMipsConfig;
		BOOLEAN bDPLLConfig;
		UINT32 aTxPktSizeHist[MIBS_MAX_HIST_ENTRIES];
		@@ -599,10 +538,9 @@ struct _MINI_ADAPTER


		struct semaphore NVMRdmWrmLock;
		BOOLEAN bNetworkInterfaceRegistered;
		BOOLEAN bNetdeviceNotifierRegistered;

		struct device *pstCreatedClassDevice;
		BOOLEAN bUsbClassDriverRegistered;

		// BOOLEAN InterfaceUpStatus;
		PFLASH2X_CS_INFO psFlash2xCSInfo;
		PFLASH_CS_INFO psFlashCSInfo ;
		@@ -630,17 +568,13 @@ struct _MINI_ADAPTER
		struct semaphore LowPowerModeSync;
		ULONG liDrainCalculated;
		UINT gpioBitMap;

		S_BCM_DEBUG_STATE stDebugState;

		};
		typedef struct _MINI_ADAPTER MINI_ADAPTER, *PMINI_ADAPTER;


		typedef struct _DEVICE_EXTENSION
		{
		PMINI_ADAPTER pAdapt;
		}DEVICE_EXTENSION,*PDEVICE_EXTENSION;

		#define GET_BCM_ADAPTER(net_dev) netdev_priv(net_dev)

		struct _ETH_HEADER_STRUC {
		UCHAR au8DestinationAddress[6];

drivers/staging/bcm/Arp.c

deleted100644 → 0

+0 −94

Original line number	Diff line number	Diff line

		/*
		* File Name: Arp.c
		* Abstract: This file contains the routines for handling ARP PACKETS
		*/
		#include "headers.h"
		#define ARP_PKT_SIZE 60

		/* =========================================================================
		* Function - reply_to_arp_request()
		*
		* Description - When this host tries to broadcast ARP request packet through
		* the virtual interface (veth0), reply directly to upper layer.
		* This function allocates a new skb for ARP reply packet,
		* fills in the fields of the packet and then sends it to
		* upper layer.
		*
		* Parameters - skb: Pointer to sk_buff structure of the ARP request pkt.
		*
		* Returns - None
		* =========================================================================*/

		VOID
		reply_to_arp_request(struct sk_buff *skb)
		{
		PMINI_ADAPTER Adapter;
		struct ArpHeader *pArpHdr = NULL;
		struct ethhdr *pethhdr = NULL;
		UCHAR uiIPHdr[4];
		/* Check for valid skb */
		if(skb == NULL)
		{
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Invalid skb: Cannot reply to ARP request\n");
		return;
		}


		Adapter = GET_BCM_ADAPTER(skb->dev);
		/* Print the ARP Request Packet */
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, ARP_RESP, DBG_LVL_ALL, "ARP Packet Dump :");
		BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_TX, ARP_RESP, DBG_LVL_ALL, (PUCHAR)(skb->data), skb->len);

		/*
		* Extract the Ethernet Header and Arp Payload including Header
		*/
		pethhdr = (struct ethhdr *)skb->data;
		pArpHdr = (struct ArpHeader *)(skb->data+ETH_HLEN);

		if(Adapter->bETHCSEnabled)
		{
		if(memcmp(pethhdr->h_source, Adapter->dev->dev_addr, ETH_ALEN))
		{
		bcm_kfree_skb(skb);
		return;
		}
		}

		// Set the Ethernet Header First.
		memcpy(pethhdr->h_dest, pethhdr->h_source, ETH_ALEN);
		if(!memcmp(pethhdr->h_source, Adapter->dev->dev_addr, ETH_ALEN))
		{
		pethhdr->h_source[5]++;
		}

		/* Set the reply to ARP Reply */
		pArpHdr->arp.ar_op = ntohs(ARPOP_REPLY);

		/* Set the HW Address properly */
		memcpy(pArpHdr->ar_sha, pethhdr->h_source, ETH_ALEN);
		memcpy(pArpHdr->ar_tha, pethhdr->h_dest, ETH_ALEN);

		// Swapping the IP Adddress
		memcpy(uiIPHdr,pArpHdr->ar_sip,4);
		memcpy(pArpHdr->ar_sip,pArpHdr->ar_tip,4);
		memcpy(pArpHdr->ar_tip,uiIPHdr,4);

		/* Print the ARP Reply Packet */

		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, ARP_RESP, DBG_LVL_ALL, "ARP REPLY PACKET: ");

		/* Send the Packet to upper layer */
		BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_TX, ARP_RESP, DBG_LVL_ALL, (PUCHAR)(skb->data), skb->len);

		skb->protocol = eth_type_trans(skb,skb->dev);
		skb->pkt_type = PACKET_HOST;

		// skb->mac.raw=skb->data+LEADER_SIZE;
		skb_set_mac_header (skb, LEADER_SIZE);
		netif_rx(skb);
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, ARP_RESP, DBG_LVL_ALL, "<=============\n");
		return;
		}

drivers/staging/bcm/Bcmchar.c

+329 −638

File changed.

Preview size limit exceeded, changes collapsed.

drivers/staging/bcm/Bcmnet.c

+189 −215

Original line number	Diff line number	Diff line
		#include "headers.h"

		static INT bcm_notify_event(struct notifier_block *nb, ULONG event, PVOID dev)
		{
		struct net_device ndev = (struct net_device)dev;
		PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
		//PMINI_ADAPTER Adapter = (PMINI_ADAPTER)ndev->priv;
		if(strncmp(ndev->name,gblpnetdev->name,5)==0)
		{
		switch(event)
		struct net_device *gblpnetdev;

		static INT bcm_open(struct net_device *dev)
		{
		case NETDEV_CHANGEADDR:
		case NETDEV_GOING_DOWN:
		/ignore this /
		break;
		case NETDEV_DOWN:
		break;

		case NETDEV_UP:
		break;

		case NETDEV_REGISTER:
		/* Increment the Reference Count for "veth0" */
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Register RefCount: %x\n",
		netdev_refcnt_read(ndev));
		dev_hold(ndev);
		break;

		case NETDEV_UNREGISTER:
		/* Decrement the Reference Count for "veth0" */
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Unregister RefCnt: %x\n",
		netdev_refcnt_read(ndev));
		dev_put(ndev);
		break;
		};
		}
		return NOTIFY_DONE;
		PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);

		if (Adapter->fw_download_done == FALSE) {
		pr_notice(PFX "%s: link up failed (download in progress)\n",
		dev->name);
		return -EBUSY;
		}

		/* Notifier block to receive netdevice events */
		static struct notifier_block bcm_notifier_block =
		{
		.notifier_call = bcm_notify_event,
		};
		if (netif_msg_ifup(Adapter))
		pr_info(PFX "%s: enabling interface\n", dev->name);

		struct net_device *gblpnetdev;
		/***************************************************************************************/
		/* proto-type of lower function */
		#ifdef BCM_SHM_INTERFACE
		const char *bcmVirtDeviceName="bcmeth";
		#endif
		if (Adapter->LinkUpStatus) {
		if (netif_msg_link(Adapter))
		pr_info(PFX "%s: link up\n", dev->name);

		static INT bcm_open(struct net_device *dev)
		{
		PMINI_ADAPTER Adapter = NULL ; //(PMINI_ADAPTER)dev->priv;
		Adapter = GET_BCM_ADAPTER(dev);
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "======>");
		if(Adapter->fw_download_done==FALSE)
		return -EINVAL;
		Adapter->if_up=1;
		if(Adapter->LinkUpStatus == 1){
		if(netif_queue_stopped(Adapter->dev)){
		netif_carrier_on(Adapter->dev);
		netif_start_queue(Adapter->dev);
		}
		}

		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "<======");
		return 0;
		}

		static INT bcm_close(struct net_device *dev)
		{
		PMINI_ADAPTER Adapter = NULL ;//gpadapter ;
		Adapter = GET_BCM_ADAPTER(dev);
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "=====>");
		Adapter->if_up=0;
		if(!netif_queue_stopped(dev)) {
		PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);

		if (netif_msg_ifdown(Adapter))
		pr_info(PFX "%s: disabling interface\n", dev->name);

		netif_carrier_off(dev);
		netif_stop_queue(dev);
		}
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL,"<=====");

		return 0;
		}

		static struct net_device_stats bcm_get_stats(struct net_device dev)
		static u16 bcm_select_queue(struct net_device dev, struct sk_buff skb)
		{
		PLINUX_DEP_DATA pLinuxData=NULL;
		PMINI_ADAPTER Adapter = NULL ;// gpadapter ;
		Adapter = GET_BCM_ADAPTER(dev);
		pLinuxData = (PLINUX_DEP_DATA)(Adapter->pvOsDepData);

		//BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Dev = %p, pLinuxData = %p", dev, pLinuxData);
		pLinuxData->netstats.rx_packets=atomic_read(&Adapter->RxRollOverCount)641024+Adapter->PrevNumRecvDescs;
		pLinuxData->netstats.rx_bytes=atomic_read(&Adapter->GoodRxByteCount)+atomic_read(&Adapter->BadRxByteCount);
		pLinuxData->netstats.rx_dropped=atomic_read(&Adapter->RxPacketDroppedCount);
		pLinuxData->netstats.rx_errors=atomic_read(&Adapter->RxPacketDroppedCount);
		pLinuxData->netstats.rx_length_errors=0;
		pLinuxData->netstats.rx_frame_errors=0;
		pLinuxData->netstats.rx_crc_errors=0;
		pLinuxData->netstats.tx_bytes=atomic_read(&Adapter->GoodTxByteCount);
		pLinuxData->netstats.tx_packets=atomic_read(&Adapter->TxTotalPacketCount);
		pLinuxData->netstats.tx_dropped=atomic_read(&Adapter->TxDroppedPacketCount);

		return &(pLinuxData->netstats);
		return ClassifyPacket(netdev_priv(dev), skb);
		}

		/*******************************************************************
		* Function - bcm_transmit()
		*
		* Description - This is the main transmit function for our virtual
		* interface(eth0). It handles the ARP packets. It
		* clones this packet and then Queue it to a suitable
		* Queue. Then calls the transmit_packet().
		*
		* Parameter - skb - Pointer to the socket buffer structure
		* dev - Pointer to the virtual net device structure
		*
		*********************************************************************/

		static netdev_tx_t bcm_transmit(struct sk_buff skb, struct net_device dev)
		{
		PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
		u16 qindex = skb_get_queue_mapping(skb);


		if (Adapter->device_removed \|\| !Adapter->LinkUpStatus)
		goto drop;

		if (Adapter->TransferMode != IP_PACKET_ONLY_MODE)
		goto drop;

		if (INVALID_QUEUE_INDEX == qindex)
		goto drop;

		if (Adapter->PackInfo[qindex].uiCurrentPacketsOnHost >=
		SF_MAX_ALLOWED_PACKETS_TO_BACKUP)
		return NETDEV_TX_BUSY;

		/* Now Enqueue the packet */
		if (netif_msg_tx_queued(Adapter))
		pr_info(PFX "%s: enqueueing packet to queue %d\n",
		dev->name, qindex);

		spin_lock(&Adapter->PackInfo[qindex].SFQueueLock);
		Adapter->PackInfo[qindex].uiCurrentBytesOnHost += skb->len;
		Adapter->PackInfo[qindex].uiCurrentPacketsOnHost++;

		((B_UINT32 ) skb->cb + SKB_CB_LATENCY_OFFSET) = jiffies;
		ENQUEUEPACKET(Adapter->PackInfo[qindex].FirstTxQueue,
		Adapter->PackInfo[qindex].LastTxQueue, skb);
		atomic_inc(&Adapter->TotalPacketCount);
		spin_unlock(&Adapter->PackInfo[qindex].SFQueueLock);

		/* FIXME - this is racy and incorrect, replace with work queue */
		if (!atomic_read(&Adapter->TxPktAvail)) {
		atomic_set(&Adapter->TxPktAvail, 1);
		wake_up(&Adapter->tx_packet_wait_queue);
		}
		return NETDEV_TX_OK;

		drop:
		dev_kfree_skb(skb);
		return NETDEV_TX_OK;
		}



		/**
		@ingroup init_functions
		Register other driver entry points with the kernel
		*/
		#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)
		static struct net_device_ops bcmNetDevOps = {
		static const struct net_device_ops bcmNetDevOps = {
		.ndo_open = bcm_open,
		.ndo_stop = bcm_close,
		.ndo_get_stats = bcm_get_stats,
		.ndo_start_xmit = bcm_transmit,
		.ndo_change_mtu = eth_change_mtu,
		.ndo_set_mac_address = eth_mac_addr,
		.ndo_validate_addr = eth_validate_addr,
		.ndo_select_queue = bcm_select_queue,
		};
		#endif

		int register_networkdev(PMINI_ADAPTER Adapter)
		{
		int result=0;
		#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
		void *temp = NULL; / actually we're allocating the device in alloc_etherdev */
		#endif
		Adapter->dev = alloc_etherdev(sizeof(PMINI_ADAPTER));
		if(!Adapter->dev)
		{
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "ERR: No Dev");
		return -ENOMEM;
		}
		gblpnetdev = Adapter->dev;
		#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
		Adapter->dev->priv = Adapter;
		#else
		temp = netdev_priv(Adapter->dev);
		temp = (void )Adapter;
		#endif
		//BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "init adapterptr: %x %x\n", (UINT)Adapter, temp);

		#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)
		Adapter->dev->netdev_ops = &bcmNetDevOps;
		#else
		Adapter->dev->open = bcm_open;
		Adapter->dev->stop = bcm_close;
		Adapter->dev->get_stats = bcm_get_stats;
		Adapter->dev->hard_start_xmit = bcm_transmit;
		Adapter->dev->hard_header_len = ETH_HLEN + LEADER_SIZE;
		#endif

		#ifndef BCM_SHM_INTERFACE
		Adapter->dev->mtu = MTU_SIZE; /* 1400 Bytes */
		/* Read the MAC Address from EEPROM */
		ReadMacAddressFromNVM(Adapter);

		static struct device_type wimax_type = {
		.name = "wimax",
		};

		/* Register the notifier block for getting netdevice events */
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Registering netdevice notifier\n");
		result = register_netdevice_notifier(&bcm_notifier_block);
		if(result)
		{
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "BCM Notifier Block did not get registered");
		Adapter->bNetdeviceNotifierRegistered = FALSE;
		return result;
		static int bcm_get_settings(struct net_device dev, struct ethtool_cmd cmd)
		{
		cmd->supported = 0;
		cmd->advertising = 0;
		cmd->speed = SPEED_10000;
		cmd->duplex = DUPLEX_FULL;
		cmd->port = PORT_TP;
		cmd->phy_address = 0;
		cmd->transceiver = XCVR_INTERNAL;
		cmd->autoneg = AUTONEG_DISABLE;
		cmd->maxtxpkt = 0;
		cmd->maxrxpkt = 0;
		return 0;
		}
		else

		static void bcm_get_drvinfo(struct net_device dev, struct ethtool_drvinfo info)
		{
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "BCM Notifier got Registered");
		Adapter->bNetdeviceNotifierRegistered = TRUE;
		}
		PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
		PS_INTERFACE_ADAPTER psIntfAdapter = Adapter->pvInterfaceAdapter;
		struct usb_device *udev = interface_to_usbdev(psIntfAdapter->interface);

		#else
		strcpy(info->driver, DRV_NAME);
		strcpy(info->version, DRV_VERSION);
		snprintf(info->fw_version, sizeof(info->fw_version), "%u.%u",
		Adapter->uiFlashLayoutMajorVersion,
		Adapter->uiFlashLayoutMinorVersion);

		Adapter->dev->mtu = CPE_MTU_SIZE;
		usb_make_path(udev, info->bus_info, sizeof(info->bus_info));
		}

		#if 0
		//for CPE - harcode the virtual mac address
		Adapter->dev->dev_addr[0] = MII_WIMAX_MACADDRESS[0];
		Adapter->dev->dev_addr[1] = MII_WIMAX_MACADDRESS[1];
		Adapter->dev->dev_addr[2] = MII_WIMAX_MACADDRESS[2];
		Adapter->dev->dev_addr[3] = MII_WIMAX_MACADDRESS[3];
		Adapter->dev->dev_addr[4] = MII_WIMAX_MACADDRESS[4];
		Adapter->dev->dev_addr[5] = MII_WIMAX_MACADDRESS[5];
		#else
		ReadMacAddressFromNVM(Adapter);
		#endif
		strcpy(Adapter->dev->name, bcmVirtDeviceName); //Copy the device name
		static u32 bcm_get_link(struct net_device *dev)
		{
		PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);

		#endif
		return Adapter->LinkUpStatus;
		}

		result = register_netdev(Adapter->dev);
		if (!result)
		static u32 bcm_get_msglevel (struct net_device *dev)
		{
		Adapter->bNetworkInterfaceRegistered = TRUE ;
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Beceem Network device name is %s!", Adapter->dev->name);
		PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);

		return Adapter->msg_enable;
		}
		else

		static void bcm_set_msglevel (struct net_device *dev, u32 level)
		{
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Network device can not be registered!");
		Adapter->bNetworkInterfaceRegistered = FALSE ;
		return result;
		PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);

		Adapter->msg_enable = level;
		}

		#if 0
		Adapter->stDebugState.debug_level = DBG_LVL_CURR;
		Adapter->stDebugState.type =(UINT)0xffffffff;
		Adapter->stDebugState.subtype[DBG_TYPE_OTHERS] = 0xffffffff;
		Adapter->stDebugState.subtype[DBG_TYPE_RX] = 0xffffffff;
		Adapter->stDebugState.subtype[DBG_TYPE_TX] = 0xffffffff;
		Adapter->stDebugState.subtype[DBG_TYPE_INITEXIT] = 0xffffffff;
		static const struct ethtool_ops bcm_ethtool_ops = {
		.get_settings = bcm_get_settings,
		.get_drvinfo = bcm_get_drvinfo,
		.get_link = bcm_get_link,
		.get_msglevel = bcm_get_msglevel,
		.set_msglevel = bcm_set_msglevel,
		};

		printk("-------ps_adapter->stDebugState.type=%x\n",Adapter->stDebugState.type);
		printk("-------ps_adapter->stDebugState.subtype[DBG_TYPE_OTHERS]=%x\n",Adapter->stDebugState.subtype[DBG_TYPE_OTHERS]);
		printk("-------ps_adapter->stDebugState.subtype[DBG_TYPE_RX]=%x\n",Adapter->stDebugState.subtype[DBG_TYPE_RX]);
		printk("-------ps_adapter->stDebugState.subtype[DBG_TYPE_TX]=%x\n",Adapter->stDebugState.subtype[DBG_TYPE_TX]);
		#endif
		int register_networkdev(PMINI_ADAPTER Adapter)
		{
		struct net_device *net = Adapter->dev;
		PS_INTERFACE_ADAPTER IntfAdapter = Adapter->pvInterfaceAdapter;
		struct usb_interface *udev = IntfAdapter->interface;
		struct usb_device *xdev = IntfAdapter->udev;

		return 0;
		}
		int result;

		void bcm_unregister_networkdev(PMINI_ADAPTER Adapter)
		{
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Unregistering the Net Dev...\n");
		if(Adapter->dev && !IS_ERR(Adapter->dev) && Adapter->bNetworkInterfaceRegistered)
		unregister_netdev(Adapter->dev);
		/* Unregister the notifier block */
		if(Adapter->bNetdeviceNotifierRegistered == TRUE)
		{
		BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Unregistering netdevice notifier\n");
		unregister_netdevice_notifier(&bcm_notifier_block);
		}
		net->netdev_ops = &bcmNetDevOps;
		net->ethtool_ops = &bcm_ethtool_ops;
		net->mtu = MTU_SIZE; /* 1400 Bytes */
		net->tx_queue_len = TX_QLEN;
		net->flags \|= IFF_NOARP;

		netif_carrier_off(net);

		SET_NETDEV_DEVTYPE(net, &wimax_type);

		/* Read the MAC Address from EEPROM */
		result = ReadMacAddressFromNVM(Adapter);
		if (result != STATUS_SUCCESS) {
		dev_err(&udev->dev,
		PFX "Error in Reading the mac Address: %d", result);
		return -EIO;
		}

		static int bcm_init(void)
		{
		int result;
		result = InterfaceInitialize();
		result = register_netdev(net);
		if (result)
		{
		printk("Initialisation failed for usbbcm");
		}
		else
		{
		printk("Initialised usbbcm");
		}
		return result;
		}

		gblpnetdev = Adapter->dev;

		static void bcm_exit(void)
		{
		printk("%s %s Calling InterfaceExit\n",__FILE__, __FUNCTION__);
		InterfaceExit();
		printk("%s %s InterfaceExit returned\n",__FILE__, __FUNCTION__);
		if (netif_msg_probe(Adapter))
		dev_info(&udev->dev, PFX "%s: register usb-%s-%s %pM\n",
		net->name, xdev->bus->bus_name, xdev->devpath,
		net->dev_addr);

		return 0;
		}

		module_init(bcm_init);
		module_exit(bcm_exit);
		MODULE_LICENSE ("GPL");
		void unregister_networkdev(PMINI_ADAPTER Adapter)
		{
		struct net_device *net = Adapter->dev;
		PS_INTERFACE_ADAPTER IntfAdapter = Adapter->pvInterfaceAdapter;
		struct usb_interface *udev = IntfAdapter->interface;
		struct usb_device *xdev = IntfAdapter->udev;

		if (netif_msg_probe(Adapter))
		dev_info(&udev->dev, PFX "%s: unregister usb-%s%s\n",
		net->name, xdev->bus->bus_name, xdev->devpath);

		unregister_netdev(Adapter->dev);
		}

drivers/staging/bcm/CmHost.c

+26 −103

File changed.

Preview size limit exceeded, changes collapsed.