NetBSD/sys/arch/hpcmips/stand/lcboot/if_cs.c

/* $NetBSD: if_cs.c,v 1.3 2005/12/11 12:17:34 christos Exp $ */

/*
 * Copyright (c) 2003 Naoto Shimazaki.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY NAOTO SHIMAZAKI AND CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE NAOTO OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_cs.c,v 1.3 2005/12/11 12:17:34 christos Exp $");

#include <sys/param.h>
#include <netinet/in.h>

#include <lib/libsa/stand.h>
#include <lib/libsa/netif.h>

#include <dev/ic/cs89x0reg.h>

#include "extern.h"

static int	cs_match(struct netif *, void *);
static int	cs_probe(struct netif *, void *);
static void	cs_init(struct iodesc *, void *);
static int	cs_get(struct iodesc *, void *, size_t, time_t);
static int	cs_put(struct iodesc *, void *, size_t);
static void	cs_end(struct netif *);

static struct netif_stats	cs_stats;

static struct netif_dif	cs_if = {
	.dif_unit	= 0,
	.dif_nsel	= 1,
	.dif_stats	= &cs_stats,
	.dif_private	= NULL,
	.dif_used	= 0,
};

struct netif_driver	cs_driver = {
	.netif_bname	= "cs",
	.netif_match	= cs_match,
	.netif_probe	= cs_probe,
	.netif_init	= cs_init,
	.netif_get	= cs_get,
	.netif_put	= cs_put,
	.netif_end	= cs_end,
	.netif_ifs	= &cs_if,
	.netif_nifs	= 1,
};

#define CS_IO_BASE	0x14010300U

#define CS_READ_1(off)		REGREAD_1(CS_IO_BASE, (off))
#define CS_READ_2(off)		REGREAD_2(CS_IO_BASE, (off))
#define CS_WRITE_1(off, val)	REGWRITE_1(CS_IO_BASE, (off), (val))
#define CS_WRITE_2(off, val)	REGWRITE_2(CS_IO_BASE, (off), (val))
#define CS_READ_PACKET_PAGE(off)					\
		(REGWRITE_2(CS_IO_BASE, PORT_PKTPG_PTR, (off)),		\
		 REGREAD_2(CS_IO_BASE, PORT_PKTPG_DATA))
#define CS_WRITE_PACKET_PAGE(off, val)					\
		(REGWRITE_2(CS_IO_BASE, PORT_PKTPG_PTR, (off)),		\
		 REGWRITE_2(CS_IO_BASE, PORT_PKTPG_DATA, (val)))

static inline void
delay(int n)
{
	int	i = 33 * n;

	while (--i > 0)
		;
}

time_t
getsecs(void)
{
	return REGREAD_4(VRETIMEL, 0) >> 15;
}

static int
cs_match(struct netif *nif, void *machdep_hint)
{
	return 1;
}

static int
cs_probe(struct netif *nif, void *machdep_hint)
{
	return 0;
}

static void
cs_get_eeprom(int offset, u_int16_t *result)
{
	int	timeo;

	for (timeo = MAXLOOP; timeo > 0; timeo--) {
		if (!(CS_READ_PACKET_PAGE(PKTPG_SELF_ST)
		      & SELF_ST_SI_BUSY))
			break;
	}
	if (timeo == 0)
		goto eeprom_error;

	CS_WRITE_PACKET_PAGE(PKTPG_EEPROM_CMD, offset | EEPROM_CMD_READ);

	for (timeo = MAXLOOP; timeo > 0; timeo--) {
		if (!(CS_READ_PACKET_PAGE(PKTPG_SELF_ST)
		      & SELF_ST_SI_BUSY))
			break;
	}
	if (timeo == 0)
		goto eeprom_error;

	*result = CS_READ_PACKET_PAGE(PKTPG_EEPROM_DATA);

	return;

eeprom_error:
	panic("cannot read mac addr");
}

static void
cs_init(struct iodesc *desc, void *machdep_hint)
{
	int		i;
	u_int16_t	*myea;

	/* Issue a software reset command to the chip */
	CS_WRITE_PACKET_PAGE(PKTPG_SELF_CTL, SELF_CTL_RESET);

	/* We cannot touch the chip until calibration is done */
	delay(10000);

	/*
	 * Transition -SBHE H->L L->H is needed between reset and
	 * the first access to the chip's register.
	 */
	CS_READ_1(PORT_PKTPG_PTR + 0);
	CS_READ_1(PORT_PKTPG_PTR + 1);
	CS_READ_1(PORT_PKTPG_PTR + 0);
	CS_READ_1(PORT_PKTPG_PTR + 1);

	/* wait for INIT_DONE */
	for (i = 10000; i > 0; i--) {
		u_int16_t	s;

		s = CS_READ_PACKET_PAGE(PKTPG_SELF_ST);
		if ((s & SELF_ST_INIT_DONE) && !(s & SELF_ST_SI_BUSY))
			break;
	}
	if (i == 0)
		panic("cannot reset netif");

	myea = (u_int16_t *) desc->myea;

	cs_get_eeprom(EEPROM_IND_ADDR_H, &myea[0]);
	cs_get_eeprom(EEPROM_IND_ADDR_M, &myea[1]);
	cs_get_eeprom(EEPROM_IND_ADDR_L, &myea[2]);

	for (i = 0; i < 3; i++)
		CS_WRITE_PACKET_PAGE(PKTPG_IND_ADDR + (i << 1), myea[i]);

	/*
	 * Accepting frames:
	 *	RX_CTL_RX_OK_A:	correct crc, and valid length
	 *	RX_CTL_IND_A:	dest addr maches individual address
	 *	RX_CTL_BCAST_A:	dest addr maches broadcast address
	 */
	CS_WRITE_PACKET_PAGE(PKTPG_RX_CTL,
			     RX_CTL_RX_OK_A | RX_CTL_IND_A | RX_CTL_BCAST_A);
	CS_WRITE_PACKET_PAGE(PKTPG_LINE_CTL, LINE_CTL_RX_ON | LINE_CTL_TX_ON);
}

static int
cs_get(struct iodesc *desc, void *pkt, size_t len, time_t timeout)
{
	time_t		t;
	int		rlen;
	int		i;
	u_int16_t	*p;

	t = getsecs();
	rlen = 0;
	while (getsecs() - t < timeout && rlen == 0) {
		if (!(CS_READ_PACKET_PAGE(PKTPG_RX_EVENT) & RX_EVENT_RX_OK))
			continue;

		/* drop status */
		CS_READ_2(PORT_RXTX_DATA);

		/* get frame length */
		rlen = CS_READ_2(PORT_RXTX_DATA);

		if (rlen > len) {
			CS_WRITE_PACKET_PAGE(PKTPG_RX_CFG, RX_CFG_SKIP);
			rlen = 0;
			continue;
		}

		p = pkt;
		for (i = rlen >> 1; i > 0; i--)
			*p++ = CS_READ_2(PORT_RXTX_DATA);
		if (rlen & 1)
			*((u_int8_t *) p + 1) = CS_READ_1(PORT_RXTX_DATA);

		/* exit while loop */
	}

	return rlen;
}

static int
cs_put(struct iodesc *desc, void *pkt, size_t len)
{
	int		timeo;
	int		i;
	u_int16_t	*p;

	CS_WRITE_2(PORT_TX_CMD, TX_CMD_START_ALL);
	CS_WRITE_2(PORT_TX_LENGTH, len);

	for (timeo = 1000000; timeo > 0; timeo--) {
		if (CS_READ_PACKET_PAGE(PKTPG_BUS_ST) & BUS_ST_RDY4TXNOW)
			break;
	}
	if (timeo == 0)
		panic("cs: cannot send frame");

	p = pkt;
	i = (len + 1) >> 1;
	while (i > 0) {
		CS_WRITE_2(PORT_RXTX_DATA, *p++);
		i--;
	}

	return len;
}

static void
cs_end(struct netif *nif)
{
	CS_WRITE_PACKET_PAGE(PKTPG_LINE_CTL, 0);
}