prism2.c

avrlib.rar ,一个学习AVR处理器十分有用的函数库.

void prism2Off(void)
{
	// turn off communication
	prism2Command(PRISM2_CMD_DISABLE_MAC0,0);
	// wait for all events to complete
	delay_ms(100);
	// reset card
	prism2Command(PRISM2_CMD_INIT,0);
}

void prism2GetMacAddress(u08* macaddr)
{
	u16 buffer[5];

	// read MAC address register
	prism2ReadRID(PRISM2_RID_CNFOWNMACADDR, 0, buffer, 5);

	*macaddr++ = buffer[2];
	*macaddr++ = buffer[2]>>8;
	*macaddr++ = buffer[3];
	*macaddr++ = buffer[3]>>8;
	*macaddr++ = buffer[4];
	*macaddr++ = buffer[4]>>8;
}

void prism2SetSSID(u08* ssid)
{
	u16 buffer[12];

	// prepare buffer for SSID write
	buffer[0] = 0x0012;
	buffer[1] = PRISM2_RID_CNFDESIREDSSID;
	buffer[2] = strlen(ssid);
	// copy ssid string to buffer
	strcpy((unsigned char*)&buffer[3], ssid);
	// write SSID
	prism2WriteRID(PRISM2_RID_CNFDESIREDSSID, 0, buffer, buffer[0]);
}

void prism2SetWEPKey(u08* wepkey)
{
	u16 buffer[9];

	// prepare buffer for SSID write
	buffer[0] = 0x0008;
	buffer[1] = PRISM2_RID_CNFWEPDEFAULTKEY0;
	// copy ssid string to buffer
	strncpy((unsigned char*)&buffer[2], wepkey, 13);
	buffer[8] &= 0x00FF;
	// write SSID
	prism2WriteRID(PRISM2_RID_CNFWEPDEFAULTKEY0, 0, buffer, buffer[0]);

	// set WEP active
	buffer[0] = 0x0002;
	buffer[1] = PRISM2_RID_CNFWEPFLAGS;
	buffer[2] = 0x0001;
	prism2WriteRID(PRISM2_RID_CNFWEPFLAGS, 0, buffer, buffer[0]);
	// set WEP active
	buffer[0] = 0x0002;
	buffer[1] = 0xfc2a;
	buffer[2] = 0x0001;
	prism2WriteRID(0xfc2a, 0, buffer, buffer[0]);
	// set WEP active
	buffer[0] = 0x0002;
	buffer[1] = 0xfc23;
	buffer[2] = 0x0000;
	prism2WriteRID(0xfc23, 0, buffer, buffer[0]);

}

u08 prism2Command(u16 cmd, u16 param0)
{
	u16 result;

	// wait until card not busy
//	rprintf("PRISM_CMD: Wait until card ready\r\n");
	while(prism2Read16(PRISM2_REG_CMD) & PRISM2_CMD_BUSY);
	
//	rprintf("PRISM_CMD: Issue Command = 0x%x\r\n", cmd);
	prism2Write16(PRISM2_REG_PARAM0, param0);
	prism2Write16(PRISM2_REG_CMD, cmd);
	
	// wait until card not busy
//	rprintf("PRISM_CMD: Wait until card ready\r\n");
	while(prism2Read16(PRISM2_REG_CMD) & PRISM2_CMD_BUSY);
	
	// read event register - wait for command to complete
//	rprintf("PRISM_CMD: Wait for command to complete\r\n");
	while(!(prism2Read16(PRISM2_REG_EVSTAT) & PRISM2_EVENT_CMD));

	// read status register
	result = prism2Read16(PRISM2_REG_STATUS)>>8;
//	rprintf("PRISM_CMD: Result  = 0x%x\r\n", result>>8);
//	rprintf("PRISM_CMD: CmdCode = 0x%x\r\n", result);
	
	// acknowledge event
//	rprintf("PRISM_CMD: Ack command event\r\n");
	prism2Write16(PRISM2_REG_EVACK, PRISM2_EVENT_CMD);

	// return command result
	return result;
}

u08 prism2ReadRID(u16 id, u16 offset, u16* data, u16 len)
{
	prism2Command(PRISM2_CMD_ACCESS_RD, id);
	return prism2ReadBAP0(id, offset, data, len);
}

u08 prism2WriteRID(u16 id, u16 offset, u16* data, u16 len)
{
	u08 result;
	result = prism2WriteBAP0(id, offset, data, len);
	prism2Command(PRISM2_CMD_ACCESS_WR, id);
	return result;
}

u08 prism2ReadBAP0(u16 id, u16 offset, u16* data, u16 len)
{
	// wait for BAP to be ready
	//rprintf("PRISM_BAP: Wait1\r\n");
	while( prism2Read16(PRISM2_REG_BAP0OFFSET) & PRISM2_BAPOFFSET_BUSY);
	// set ID
	prism2Write16(PRISM2_REG_BAP0SEL, id);
	// set offset
	prism2Write16(PRISM2_REG_BAP0OFFSET, offset);
	// wait for BAP to be ready
	//rprintf("PRISM_BAP: Wait2\r\n");
	while( prism2Read16(PRISM2_REG_BAP0OFFSET) & PRISM2_BAPOFFSET_BUSY);
	// check for error
	if(prism2Read16(PRISM2_REG_BAP0OFFSET) & PRISM2_BAPOFFSET_ERROR)
		return -1;
	// read data
	//rprintf("PRISM_BAP: Read\r\n");
	while(len--)
        *data++ = prism2Read16(PRISM2_REG_BAP0DATA);
	// return success
	return 0;
}

u08 prism2WriteBAP0(u16 id, u16 offset, u16* data, u16 len)
{
	// wait for BAP to be ready
	//rprintf("PRISM_BAP: Wait1\r\n");
	while( prism2Read16(PRISM2_REG_BAP0OFFSET) & PRISM2_BAPOFFSET_BUSY);
	// set ID
	prism2Write16(PRISM2_REG_BAP0SEL, id);
	// set offset
	prism2Write16(PRISM2_REG_BAP0OFFSET, offset);
	// wait for BAP to be ready
	//rprintf("PRISM_BAP: Wait2\r\n");
	while( prism2Read16(PRISM2_REG_BAP0OFFSET) & PRISM2_BAPOFFSET_BUSY);
	// check for error
	if(prism2Read16(PRISM2_REG_BAP0OFFSET) & PRISM2_BAPOFFSET_ERROR)
		return -1;
	// write data
	//rprintf("PRISM_BAP: Write\r\n");
	while(len--)
        prism2Write16(PRISM2_REG_BAP0DATA, *data++);
	// return success
	return 0;
}

void prism2Write(unsigned short address, unsigned char data)
{
	cli();
	// assert the address
	outb(PRISM2_HADDRESS_PORT, (address>>8) | (inb(PRISM2_HADDRESS_PORT)&~PRISM2_HADDRESS_MASK));
	outb(PRISM2_ADDRESS_PORT, address | (inb(PRISM2_ADDRESS_PORT)&~PRISM2_ADDRESS_MASK));
	// set data bus as output
	outb(PRISM2_DATA_DDR, 0xFF);
	// place data on bus
	outb(PRISM2_DATA_PORT, data);
	// assert write
	cbi(PRISM2_CONTROL_PORT, PRISM2_CONTROL_IOWR);
	// delay
	PRISM2_IO_ACCESS_DELAY;
	// negate write
	sbi(PRISM2_CONTROL_PORT, PRISM2_CONTROL_IOWR);
	// set data bus back to input with pullups enabled
	outb(PRISM2_DATA_DDR, 0x00);
	outb(PRISM2_DATA_PORT, 0xFF);
	sei();
}

unsigned char prism2Read(unsigned short address)
{
	unsigned char data;
	cli();
	// assert the address
	outb(PRISM2_HADDRESS_PORT, (address>>8) | (inb(PRISM2_HADDRESS_PORT)&~PRISM2_HADDRESS_MASK));
	outb(PRISM2_ADDRESS_PORT, address | (inb(PRISM2_ADDRESS_PORT)&~PRISM2_ADDRESS_MASK));
	// set data bus to input with pullups enabled
	outb(PRISM2_DATA_DDR, 0x00);
	outb(PRISM2_DATA_PORT, 0xFF);
	// assert read
	cbi(PRISM2_CONTROL_PORT, PRISM2_CONTROL_IORD);
	// delay
	PRISM2_IO_ACCESS_DELAY;
	// read in the data
	data = inb( PRISM2_DATA_PIN );
	// negate read
	sbi(PRISM2_CONTROL_PORT, PRISM2_CONTROL_IORD);
	// return data
	sei();
	return data;
}

void prism2Write16(unsigned short address, unsigned short data)
{
	prism2Write(address, data);
	prism2Write(address+1, data>>8);
}

unsigned short prism2Read16(unsigned short address)
{
	return prism2Read(address) | (prism2Read(address+1)<<8);
}

void prism2WriteMem(unsigned short address, unsigned short data)
{
	cli();
	// assert the address
	outb(PRISM2_HADDRESS_PORT, (address>>8) | (inb(PRISM2_HADDRESS_PORT)&~PRISM2_HADDRESS_MASK));
	outb(PRISM2_ADDRESS_PORT, address | (inb(PRISM2_ADDRESS_PORT)&~PRISM2_ADDRESS_MASK));
	// set data bus as output
	outb(PRISM2_DATA_DDR, 0xFF);
	// place data on bus
	outb(PRISM2_DATA_PORT, data);
	// assert write
	cbi(PRISM2_CONTROL_PORT, PRISM2_CONTROL_MEMWR);
	// delay
	PRISM2_MEM_ACCESS_DELAY;
	// negate write
	sbi(PRISM2_CONTROL_PORT, PRISM2_CONTROL_MEMWR);
	// set data bus back to input with pullups enabled
	outb(PRISM2_DATA_DDR, 0x00);
	outb(PRISM2_DATA_PORT, 0xFF);
	sei();
}

unsigned short prism2ReadMem(unsigned short address)
{
	unsigned char data;
	cli();
	// assert the address
	outb(PRISM2_HADDRESS_PORT, (address>>8) | (inb(PRISM2_HADDRESS_PORT)&~PRISM2_HADDRESS_MASK));
	outb(PRISM2_ADDRESS_PORT, address | (inb(PRISM2_ADDRESS_PORT)&~PRISM2_ADDRESS_MASK));
	// set data bus to input with pullups enabled
	outb(PRISM2_DATA_DDR, 0x00);
	outb(PRISM2_DATA_PORT, 0xFF);
	// assert read
	cbi(PRISM2_CONTROL_PORT, PRISM2_CONTROL_MEMRD);
	// delay
	PRISM2_MEM_ACCESS_DELAY;
	// read in the data
	data = inb( PRISM2_DATA_PIN );
	// negate read
	sbi(PRISM2_CONTROL_PORT, PRISM2_CONTROL_MEMRD);
	sei();
	// return data
	return data;
}

void prism2CardRegDump(void)
{
	u16 i;
	u08 buffer[0x100];

	rprintfProgStrM("Card Config Registers\r\n");
	rprintfProgStrM("-------------------------------\r\n");
	// read card CIS (16 bytes)
	rprintf("CIS : \r\n");
	for(i=0; i<0x100; i++)
		buffer[i] = prism2ReadMem(i<<1);
	debugPrintHexTable(0x100, buffer);

	rprintfCRLF();

	rprintf("COR : "); rprintfu08(prism2ReadMem(0x3E0+PCMCIA_ATTR_COR)); rprintfCRLF();
	rprintf("CSR : "); rprintfu08(prism2ReadMem(0x3E0+PCMCIA_ATTR_CSR)); rprintfCRLF();
	rprintf("PRR : "); rprintfu08(prism2ReadMem(0x3E0+PCMCIA_ATTR_PRR)); rprintfCRLF();
	rprintf("SCR : "); rprintfu08(prism2ReadMem(0x3E0+PCMCIA_ATTR_SCR)); rprintfCRLF();
}

void prism2RegDump(void)
{
	rprintfProgStrM("Prism2 Registers\r\n");
	rprintfProgStrM("CMD     : "); rprintfu16(prism2Read16(PRISM2_REG_CMD));		rprintfCRLF();
	rprintfProgStrM("PARAM0  : "); rprintfu16(prism2Read16(PRISM2_REG_PARAM0));		rprintfCRLF();
	rprintfProgStrM("PARAM1  : "); rprintfu16(prism2Read16(PRISM2_REG_PARAM1));		rprintfCRLF();
	rprintfProgStrM("PARAM2  : "); rprintfu16(prism2Read16(PRISM2_REG_PARAM2));		rprintfCRLF();
	rprintfProgStrM("STATUS  : "); rprintfu16(prism2Read16(PRISM2_REG_STATUS));		rprintfCRLF();
	rprintfProgStrM("RESP0   : "); rprintfu16(prism2Read16(PRISM2_REG_RESP0));		rprintfCRLF();
	rprintfProgStrM("RESP1   : "); rprintfu16(prism2Read16(PRISM2_REG_RESP1));		rprintfCRLF();
	rprintfProgStrM("RESP2   : "); rprintfu16(prism2Read16(PRISM2_REG_RESP2));		rprintfCRLF();

	rprintfProgStrM("INFOFID : "); rprintfu16(prism2Read16(PRISM2_REG_INFOFID));	rprintfCRLF();
	rprintfProgStrM("RXFID   : "); rprintfu16(prism2Read16(PRISM2_REG_RXFID));		rprintfCRLF();
	rprintfProgStrM("ALLOCFID: "); rprintfu16(prism2Read16(PRISM2_REG_ALLOCFID));	rprintfCRLF();
	rprintfProgStrM("TXFID   : "); rprintfu16(prism2Read16(PRISM2_REG_TXFID));		rprintfCRLF();

	rprintfProgStrM("BAP0SEL : "); rprintfu16(prism2Read16(PRISM2_REG_BAP0SEL));	rprintfCRLF();
	rprintfProgStrM("BAP0OFFS: "); rprintfu16(prism2Read16(PRISM2_REG_BAP0OFFSET));	rprintfCRLF();
	rprintfProgStrM("BAP0DATA: "); rprintfu16(prism2Read16(PRISM2_REG_BAP0DATA));	rprintfCRLF();

	rprintfProgStrM("BAP1SEL : "); rprintfu16(prism2Read16(PRISM2_REG_BAP1SEL));	rprintfCRLF();
	rprintfProgStrM("BAP1OFFS: "); rprintfu16(prism2Read16(PRISM2_REG_BAP1OFFSET));	rprintfCRLF();
	rprintfProgStrM("BAP1DATA: "); rprintfu16(prism2Read16(PRISM2_REG_BAP1DATA));	rprintfCRLF();

	rprintfProgStrM("EVSTAT  : "); rprintfu16(prism2Read16(PRISM2_REG_EVSTAT));		rprintfCRLF();
	rprintfProgStrM("INTEN   : "); rprintfu16(prism2Read16(PRISM2_REG_INTEN));		rprintfCRLF();
	rprintfProgStrM("EVACK   : "); rprintfu16(prism2Read16(PRISM2_REG_EVACK));		rprintfCRLF();

	rprintfProgStrM("SWSUP0  : "); rprintfu16(prism2Read16(PRISM2_REG_SWSUP0));		rprintfCRLF();
	rprintfProgStrM("SWSUP0  : "); rprintfu16(prism2Read16(PRISM2_REG_SWSUP1));		rprintfCRLF();
	rprintfProgStrM("SWSUP0  : "); rprintfu16(prism2Read16(PRISM2_REG_SWSUP2));		rprintfCRLF();

	rprintfProgStrM("AUXPAGE : "); rprintfu16(prism2Read16(PRISM2_REG_AUXPAGE));	rprintfCRLF();
	rprintfProgStrM("AUXOFFS : "); rprintfu16(prism2Read16(PRISM2_REG_AUXOFFSET));	rprintfCRLF();
	rprintfProgStrM("AUXDATA : "); rprintfu16(prism2Read16(PRISM2_REG_AUXDATA));	rprintfCRLF();

	delay_ms(25);
}