am930hw.c

wlan_monitor monitor utility for wlan device

			/*  first, get rid of the old one */
			old_state |= SURXD_ST_FWOWN;
			write8( hw, old_head + RXD_OFF_STATE, old_state);

			if ( SURXD_ST_IS_CONSUMED(state) )
			{
				/* it's a dummy, do nothing */
				DBPRT( DBFWINT, "We got a dummy!\n");
			}
			else if ( SURXD_ST_IS_RXERR(state) )
			{
				/* rx error, note it and move on... */

				DBPRT( DBFWINT, "RX int, desc err, state=0x%x\n", state);

				if ( SURXD_ST_IS_CRC_ERR(state) )
					hw->stats.rx_crcerr++;
				if ( SURXD_ST_IS_BUF_OFLOW(state) )
					hw->stats.rx_buf_oflow++;

				state |= SURXD_ST_CONSUMED;
				write8(hw, hw->rx_head+RXD_OFF_STATE, state);

				am930mac_rxframe_err(hw->mac);
				
			}
			else
			{
				/* hey! we've actually got something! */
				/*  copy the frame to host memory and pass it up */
				len = read16(hw, hw->rx_head + RXD_OFF_LEN);
				frm = am930mac_mk_rxfrmbuf( hw->mac, len);
				if ( frm == NULL )
				{
					printk(KERN_DEBUG"mac_mk_rxfrmbuf failed!\n");

					state |= SURXD_ST_CONSUMED;
					write8(hw, hw->rx_head+RXD_OFF_STATE, state);
				}
				else
				{
					data_off = read32(hw, hw->rx_head + RXD_OFF_START_FRAME);
					data_off &= 0x0000ffff;
					readcard(hw, data_off, frm->data, len);

					/* print new rx_desc */
					#ifdef DBMSG_ENABLED
						if ( (dbmask & FILEBIT) && (dbmask & DBRXDATA))
						{
							int i;
							printk(KERN_DEBUG"rxframe: ");
							for ( i = 0; i < len; i++)
							{
								printk("%02x ", frm->data[i]);
							}
							printk("\n");
						}
					#endif

					frm->len = len;
					frm->rssi = read8(hw, hw->rx_head + RXD_OFF_RSSI);

					/* start mod: tld */
					rssi_tld = (int) frm->rssi;
					/* end mod: tld */

					frm->ch = read8(hw, hw->rx_head + RXD_OFF_INDEX_OR_CH);
					frm->local_time = 
						read32(hw, hw->rx_head + RXD_OFF_LOCAL_TIME);
					frm->rate = read8(hw, hw->rx_head + RXD_OFF_RATE);

					state |= SURXD_ST_CONSUMED;
					write8(hw, hw->rx_head+RXD_OFF_STATE, state);

					am930mac_rxframe( hw->mac, frm );
				}
			}
		}

		/* read the state and next fields from the head */
		state = read8(hw, hw->rx_head + RXD_OFF_STATE);
		next = am930hw_read_rxnext(hw);

	}

	DBPRT( DBFWINT, "RXint done\n") 
}

/* start mod: tld */
/*----------------------------------------------------------------
 *      am930hw_rssi_tld
 *
 *      returns: rssi value as int
 ----------------------------------------------------------------*/
UINT32 am930hw_rssi_tld(int tld_v) {
  return( rssi_tld );
}
/* end mod: tld */


/*----------------------------------------------------------------
*	am930hw_read_rxnext
*
*	Repeated read of the rxnext field to make _sure_ we have real
*	data.  Very paranoid.
*
*	returns: nothing
----------------------------------------------------------------*/
static UINT32 am930hw_read_rxnext(am930hw_t *hw)
{
	UINT32 result = 0;
	UINT32 old = 0;

	result = read32( hw, hw->rx_head + RXD_OFF_NEXT);
	while ( result != old )
	{
		old = result;
		result = read32( hw, hw->rx_head + RXD_OFF_NEXT);
		if ( old != result )
		{
			DBPRT( DBFWINT, "two reads of rxnext didn't match!\n");
		}
	}
	return result;
}


/*----------------------------------------------------------------
*	am930hw_onint_tx
*
*	ISR helper for f/w generated scan complete interrupts
*
*	returns: nothing
----------------------------------------------------------------*/
void am930hw_onint_tx( am930hw_t *hw )
{
	UINT32	last;
	UINT8	state;
	UINT32	txresult = 0;

	DBPRT( DBFWINT, "TX Complete interrupt!\n")

	last = read32(hw, hw->txcmplt + TXCMPLT_OFF_DATA);
	state = read8(hw, last + TXD_OFF_STATE);
	if ( state & SUTXD_ST_TXERR )
	{
		DBPRT( DBFWINT, "Frame TX err detected\n");
		if ( state & SUTXD_ST_REJECTED )
		{
			DBPRT( DBFWCMD, "TX frame rejected by f/w\n");
			hw->stats.tx_rejected++;
		}
		if ( state & SUTXD_ST_MSDU_TMOUT )
		{
			hw->stats.tx_tmout++;
		}
		if ( state & SUTXD_ST_ABRT )
		{
/*			hw->stats.tx_fifo_uflow++; */
		}
		if ( state & SUTXD_ST_ABRT_NOTX )
		{
/*			hw->stats.tx_retry++; */
		}
		if ( state & SUTXD_ST_MAX_RETRY )
		{
			hw->stats.tx_retry++;
		}
	}
	txresult = state & (SUTXD_ST_TXERR | SUTXD_ST_ABRT) ? 1 : 0;

	am930mac_ontxcomplete(hw->mac, txresult);

/*
#ifdef DBMSG_ENABLED
	if ( (dbmask & FILEBIT) && (dbmask & DBTXDATA))
	{
		am930tx_desc_t desc;
		readcard(hw, last, &desc, sizeof(desc));
		am930hw_dbprintTXdesc(&desc);
	}
#endif
*/

	DBPRT( DBFWINT, "TX int done\n")
}


/*----------------------------------------------------------------
*	am930hw_onint_scancomplete
*
*	ISR helper for f/w generated scan complete interrupts
*
*	returns: nothing
----------------------------------------------------------------*/
void am930hw_onint_scancomplete( am930hw_t *hw)
{
	DBPRT( DBFWINT, "Scan Complete interrupt! ch = %d\n", hw->scan_ch)
	hw->state &= ~AM930HW_SCANNING;

	if ( hw->scan_callback != NULL )
	{
		/* alert the callback function */
		(*hw->scan_callback)(hw->scan_callbackarg);

		/* check to see if the callback put us back in scan mode */
		if ( (hw->state & AM930HW_SCANNING) == 0 )
		{
			/* if not, clear the callback and arg fields */
			hw->scan_callback = NULL;
			hw->scan_callbackarg = NULL;
		}
	}
}


/*----------------------------------------------------------------
*	am930hw_reset
*
*	This function performs a reset of the am930 processor, waits
*	for the firmware to "reboot" and then sends the firmware a 
*	test command.
*
*	returns: 0 on success, non-zero on failure
----------------------------------------------------------------*/
UINT32	am930hw_reset( am930hw_t *hw )
{
	UINT32 	result = 0;
	UINT32 	init_retry = 0;
	UINT8	reg;
	UINT32	count;
	UINT32	i;
	UINT8	selftest;
	am930hw_cmd_result_t	cmd_result;

	DBFENTER;

	do
	{
		/* Lets go through a reset cycle */
		/* Set the CORESET bit of GCR and wait 10 us */
		outb( BIT6, GCR(hw) );
		udelay(10);
		/* Set the SWRESET bit of GCR and wait 10 us */
		outb( BIT7, GCR(hw) );
		udelay(10);
		/* Clear the GCR and wait 10 us */
		outb( 0, GCR(hw) );
		udelay(10);
		/* Set the CORESET bit of GCR and wait 10 us */
		outb( BIT6, GCR(hw) );
		udelay(10);

		/* Clear the ctl memory  regions (f/w should do this, but doesn't) */
		for ( i = SU_OFF_LAST_TXDESC; i < SU_OFF_BUFFER; i++)
		{
			write8(hw, i, 0);
		}

		/* Clear the GCR and wait 10 us */
		outb( 0, GCR(hw) );
		udelay(10);
		/* Before doing the ALE test, do an initial read of BSS */
		reg = inb( BSS(hw) );
		count = 0;
		do 
		{
			udelay(50);
			
			/* Write zero to BSS and wait 10us */
			outb( 0, BSS(hw) );
			udelay(50);
			
			/* Read BSS and check the ALE Test Read bit */
			reg = inb( BSS(hw) );
		} while ( reg != 0x80 && ++count < 20 );
	
		/* Now wait for 2 seconds */
		/*
		current->timeout = jiffies + (2 * HZ);
		current->state = TASK_INTERRUPTIBLE;
		schedule();
		current->timeout = 0;
		*/
		schedule_timeout( 2*HZ );

		/* Now, check the selftest status */
		while ( (selftest = read8(hw, hw->cs + CS_OFF_SELF_TEST)) < 0xf0)
		{
		}

		if ( selftest != 0xFF )
		{
		   printk(KERN_DEBUG"Card self-test failed, code=0x%02x\n", selftest);
		   result = 1;
		}

		/* Issue the test interface command */
		cmd_result = am930hw_fw_cmd( hw, SUCMD_CMD_TEST_NOP, NULL, 0); 
	
		if ( cmd_result.fw_status != SUCMD_STAT_CMPLT ||
		 	 cmd_result.drvr_status != 0 )
		{
			DBPRT( DBINIT | DBFWCMD, 
				"Firmware Test Interface failed, status=0x%x\n",
				cmd_result.fw_status);
			result = 1;
		}
	
		init_retry++;
	
	} while ( init_retry < 10 &&
			  ( cmd_result.fw_status != SUCMD_STAT_CMPLT ||
			    cmd_result.drvr_status != 0 ) );

	/* if the reset failed, log it */
	if ( init_retry >= 10 &&
	 		( cmd_result.fw_status != SUCMD_STAT_CMPLT ||
		      cmd_result.drvr_status != 0 ) )
	{
		DBPRT( DBINIT | DBFWCMD, 
			"All retries of reset and Test Interface failed status=0x%x\n",
			cmd_result.fw_status);
		result = 1;
	}
	return result;
}
	
/*----------------------------------------------------------------
*	am930hw_rx_enable
*
*	Helper function to send the sutro ENABLE_RX command. 
*
*	returns: AM930HW_CMD_SUCCESS or
*			 AM930HW_CMD_INITTXFAILED
----------------------------------------------------------------*/
UINT32 am930hw_rx_enable(am930hw_t *hw)
{
	UINT32 					result = AM930HW_CMD_SUCCESS;
	sucmd_en_rcvr_t			cmd;
	am930hw_cmd_result_t	cmd_result;

	DBFENTER;

	cmd.data_desc = 0;

/* TODO: handle the setting up of the pspoll descriptor */

	cmd_result = am930hw_fw_cmd( hw, SUCMD_CMD_EN_RCVR, &cmd, -sizeof(cmd));
	
	if ( cmd_result.fw_status != SUCMD_STAT_CMPLT || 
		cmd_result.drvr_status != 0 )
	{
		printk(KERN_DEBUG "init_rx failed!\n");
		result = AM930HW_CMD_INITRXFAILED;
	}
	else
	{
		hw->rx_head = cmd.data_desc;
	}

	DBFEXIT;
	return result;
}


/*----------------------------------------------------------------
*	am930hw_scan
*
*	Public method used to tell the MAC to scan. In this case it 
*   is the hardware element of the MAC that's being told what to
*   do.
*
*	The cntl argument has two purposes, it specifies
*	what kind of BSS to scan for (BSSType)and what kind of scan to
*	perform (active or passive).
*	The values of the bit fields are:
*	AM930HWSCAN_ACTIVE
*	AM930HWSCAN_PASSIVE
*	AM930HWSCAN_IBSS
*	AM930HWSCAN_ESS
*	note 1: that IBSS and ESS can be used together.
*	note 2: the units for the duration field are Kus.
*
*	returns: AM930HW_CMD_SUCCESS or
*			 AM930HW_CMD_INITTXFAILED
----------------------------------------------------------------*/
UINT32 am930hw_scan( am930hw_t *hw, UINT32 cntl, UINT48 bssid, 
					UINT32 ch, UINT32 duration,
					am930hw_scan_callback_t cb, void *callback_arg)
{
	UINT32 					result = AM930HW_SUCCESS;
	sucmd_scan_t			cmd;
	am930hw_cmd_result_t	cmd_result;
	su_mib_mac_mgmt_t		mib;
	DBFENTER;

	/* Get the mac_mgmt mib */
	if ( am930hw_mibget( hw, SUMIB_MGMT, 0, sizeof(mib), &mib) 
			!= AM930HW_CMD_SUCCESS )
	{
		DBPRT( DBFWCMD, "Initial mib read failed!\n");
		result = AM930HW_FAILURE;
	}
	else
	{
		/* set the scan mode and duration (if passive) */
		if ( cntl & AM930HWSCAN_PASSIVE )
		{
			mib.scan_mode = SUMIB_SCANMODE_PASSIVE;
			mib.passive_scan_duration = duration;
		}
		else /* ACTIVE */
		{
			mib.scan_mode = SUMIB_SCANMODE_ACTIVE;
		}
	
		if ( am930hw_mibset( hw, SUMIB_MGMT, 0, sizeof(mib), &mib) 
				!= AM930HW_CMD_SUCCESS )
		{
			DBPRT( DBFWCMD, "MIB write failed!\n");
			result = AM930HW_FAILURE;
		}
		else
		{
			/* set the callback */
			hw->scan_callback = cb;
			hw->scan_callbackarg = callback_arg;

			/* send the scan command */
			memset( &cmd, 0, sizeof(cmd));
			cmd.duration = duration;
			cmd.set_or_ch = ch;
	/*	
			cmd.pattern = 5;
			cmd.index = 1;
	*/	
			hw->state |= AM930HW_SCANNING;
			hw->scan_ch = ch;
			cmd_result = am930hw_fw_cmd( hw, SUCMD_CMD_SCAN, &cmd, sizeof(cmd));
			
			if ( cmd_result.fw_status != SUCMD_STAT_CMPLT || cmd_result.drvr_status != 0 )
			{
				hw->state &= ~AM930HW_SCANNING;
				hw->scan_ch = 0;
				printk( KERN_DEBUG "scan command failed! ch=%ld\n", ch);
				result = AM930HW_FAILURE;
			}
		}
	}
	DBFEXIT;
	return result;
}


/*----------------------------------------------------------------
*	am930hw_mibget
*
*	I/F function used by mac and mgr to retrieve elements of or an
*	entire mib section. Also used by the mibgetitem function.
*
*	returns: AM930HW_SUCCESS or
*			 AM930HW_FAILURE
----------------------------------------------------------------*/
UINT32 am930hw_mibget( am930hw_t *hw, UINT32 mibsec, UINT32 offset,
						UINT32 len, void *buf)
{
	UINT32					result = AM930HW_SUCCESS;
	sucmd_get_mib_var_t		cmd;
	am930hw_cmd_result_t	cmd_result;

	DBFENTER;

	memset( &cmd, 0, sizeof(cmd));
	cmd.type = mibsec;
	cmd.size = len;
	cmd.index = offset;

	cmd_result = am930hw_fw_cmd( hw, SUCMD_CMD_GET_MIB_VAR, &cmd, -sizeof(cmd));
	
	if ( cmd_result.fw_status != SUCMD_STAT_CMPLT || 
		 cmd_result.drvr_status != 0 )
	{
		DBPRT( DBFWCMD, "GetMIB failed! mibsec=0x%02lx, offset=%lu, len=%lu\n", 
				mibsec, offset, len);
		result = AM930HW_FAILURE;
	}
	else
	{
		/* TODO: keep an eye on the where the f/w copies the result to */
		memcpy( buf, cmd.data, len);
	}

	DBFEXIT;
	return result;
}


/*----------------------------------------------------------------
*	am930hw_mibgetitem
*
*	I/F function used by mac and mgr to retrieve the values of 
*	particular MIB elements.
*
*	returns: AM930HW_SUCCESS or
*			 AM930HW_FAILURE
----------------------------------------------------------------*/
UINT32 am930hw_mibgetitem( am930hw_t *hw, UINT32 itemid, void *buf, UINT32 len)
{
	UINT32	result = AM930HW_SUCCESS;

	DBFENTER;

	result = am930hw_mibget( hw, MI_SEC(itemid), MI_OFF(itemid), 
								MI_SZ(itemid), buf);

	DBFEXIT;