/* $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);
}