* Copyright (c) 2010 The NetBSD Foundation, Inc.

/* $NetBSD: enic.c,v 1.5 2023/01/22 21:36:12 andvar Exp $ */

/*-
* Copyright (c) 2010 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code was written by Alessandro Forin and Neil Pittman
* at Microsoft Research and contributed to The NetBSD Foundation
* by Microsoft Corporation.
*
* 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 THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
*/

/* --------------------------------------------------------------------------
*
* Module:
*
* enic.c
*
* Purpose:
*
* Driver for the Microsoft eNIC (eMIPS system) Ethernet
*
* Author:
* A. Forin (sandrof)
*
* References:
* Internal Microsoft specifications, file eNIC_Design.docx titled
* "eNIC: a simple Ethernet" Revision 4/30/99
*
* Giano simulation module, file Peripherals\enic.cpp
*
* Various other drivers I wrote for said hardware
* --------------------------------------------------------------------------
*/

#include <sys/param.h>
#include <sys/types.h>

#include <net/if_ether.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>

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

#include <machine/emipsreg.h>

#include "start.h"
#include "common.h"

#define the_enic ((struct _Enic *)ETHERNET_DEFAULT_ADDRESS)

/* forward declarations */
static int enicprobe (struct netif *, void *);
static int enicmatch (struct netif *, void *);
static void enicinit (struct iodesc *, void *);
static int enicget (struct iodesc *, void *, size_t, saseconds_t);
static int enicput (struct iodesc *, void *, size_t);
static void enicend (struct netif *);

#ifdef NET_DEBUG
static void dump_packet(void *, int);
#endif

/* BUGBUG do we have this? */
#define kvtophys(_v_) ((paddr_t)(_v_) & ~0x80000000)

#define rpostone(_r_,_p_,_s_) \
(_r_)->SizeAndFlags = ES_F_RECV | (_s_); \
(_r_)->BufferAddressHi32 = 0; \
(_r_)->BufferAddressLo32 = _p_;
#define tpostone(_r_,_p_,_s_) \
(_r_)->SizeAndFlags = ES_F_XMIT | (_s_); \
(_r_)->BufferAddressHi32 = 0; \
(_r_)->BufferAddressLo32 = _p_;

/* Send a packet
*/
static int
enic_putpkt(struct _Enic *regs, void *buf, int bytes)
{
paddr_t phys = kvtophys(buf);

tpostone(regs,phys,bytes);

/* poll till done? */
//printf("\tenic: sent %d at %x\n",bytes,phys);
return bytes;
}

/* Get a packet
*/
static int
enic_getpkt(struct _Enic *regs, void *buf, int bytes, int timeo)
{
paddr_t phys;
unsigned int isr, saf, hi, lo, fl;

phys = kvtophys(buf);
rpostone(regs,phys,bytes);

//printf("\tenic: recv %d at %x\n",bytes,phys);

/* poll till we get some */
timeo += getsecs();

for (;;) {

/* anything there? */
isr = regs->Control;

if (isr & EC_ERROR) {
printf("enic: internal error %x\n", isr);
regs->Control = EC_RESET;
break;
}

//printf("isr %x ",isr);

if ((isr & (EC_DONE|EC_OF_EMPTY)) == EC_DONE) {

/* beware, order matters */
saf = regs->SizeAndFlags;
hi = regs->BufferAddressHi32; /* BUGBUG 64bit */
lo = regs->BufferAddressLo32; /* this pops the fifo */
__USE(hi);

fl = saf & (ES_F_MASK &~ ES_F_DONE);

if (fl == ES_F_RECV)
{
/* and we are done? */
if (phys == lo)
return saf & ES_S_MASK;
} else if (fl == ES_F_XMIT)
{
;/* nothing */
} else if (fl != ES_F_CMD)
{
printf("enic: invalid saf=x%x (lo=%x, hi=%x)\n", saf, lo, hi);
}
}

if (getsecs() >= timeo) {
//printf("enic: timeout\n");
regs->Control = EC_RESET;
break;
}
}

return 0;
}

/*
*/
static int enic_getmac(struct _Enic *regs, uint8_t *mac)
{
uint8_t buffer[8];
paddr_t phys = kvtophys(&buffer[0]);
int i;

regs->Control = EC_RESET;
Delay(1);
regs->Control = regs->Control & (~EC_RXDIS);

buffer[0] = ENIC_CMD_GET_ADDRESS;

//printf("%x:%x:%x:%x:%x:%x\n",buffer[0],buffer[1],buffer[2],buffer[3],buffer[4],buffer[5]);

regs->SizeAndFlags = (sizeof buffer) | ES_F_CMD;
regs->BufferAddressHi32 = 0;
regs->BufferAddressLo32 = phys; /* go! */

for (i = 0; i < 100; i++) {
Delay(100);
if (0 == (regs->Control & EC_OF_EMPTY))
break;
}
if (i == 100)
return 0;

//printf("%x:%x:%x:%x:%x:%x\n",buffer[0],buffer[1],buffer[2],buffer[3],buffer[4],buffer[5]);

memcpy(mac,buffer,6);
return 1;
}

/* Exported interface
*/
int
enic_present(int unit)
{
if ((unit != 0) || (the_enic->Tag != PMTTAG_ETHERNET))
return 0;

return 1;
}

extern int try_bootp;

extern struct netif_stats enicstats[];
struct netif_dif enicifs[] = {
/* dif_unit dif_nsel dif_stats dif_private */
{ 0, 1, &enicstats[0], the_enic, },
};
#define NENICIFS (sizeof(enicifs) / sizeof(enicifs[0]))
struct netif_stats enicstats[NENICIFS];

struct netif_driver enic_netif_driver = {
"enic", /* netif_bname */
enicmatch, /* netif_match */
enicprobe, /* netif_probe */
enicinit, /* netif_init */
enicget, /* netif_get */
enicput, /* netif_put */
enicend, /* netif_end */
enicifs, /* netif_ifs */
NENICIFS /* netif_nifs */
};

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

/* NB: We refuse anything but unit==0
*/
static int
enicprobe(struct netif *nif, void *machdep_hint)
{
int unit = nif->nif_unit;
#ifdef NET_DEBUG
printf("enic%d: probe\n", unit);
#endif
return (enic_present(unit) ? 0 : 1);
}

static void
enicinit(struct iodesc *desc, void *machdep_hint)
{
#ifdef NET_DEBUG
struct netif *nif = (struct netif *)desc->io_netif;
int unit = nif->nif_driver->netif_ifs->dif_unit;
printf("enic%d: init %s\n", unit, machdep_hint);
#endif

/*
* Yes we want DHCP and this is our MAC
*/
try_bootp = 1;
enic_getmac(the_enic,desc->myea);
desc->xid = 0xfe63d095;
}

static int
enicput(struct iodesc *desc, void *pkt, size_t len)
{
#ifdef NET_DEBUG
if (debug)
dump_packet(pkt,len);
#endif

return enic_putpkt(the_enic,pkt,len);
}

int
enicget(struct iodesc *desc, void *pkt, size_t len, saseconds_t timeout)
{
#ifdef NET_DEBUG
printf("enicget: %lx %lx\n",len,timeout);
#endif
return enic_getpkt(the_enic,pkt,len,timeout);
}

static void
enicend(struct netif *nif)
{
/* BUGBUG stop it in reset? */
}

#ifdef NET_DEBUG
static void dump_packet(void *pkt, int len)
{
struct ether_header *eh = (struct ether_header *)pkt;
struct ip *ih = (struct ip *)(eh + 1);

printf("ether_dhost = %s\n", ether_sprintf(eh->ether_dhost));
printf("ether_shost = %s\n", ether_sprintf(eh->ether_shost));
printf("ether_type = 0x%x\n", ntohs(eh->ether_type));

if (ntohs(eh->ether_type) == 0x0800) {
printf("ip packet version %d\n", ih->ip_v);
printf("source ip: 0x%x\n", ih->ip_src.s_addr);
printf("dest ip: 0x%x\n", ih->ip_dst.s_addr);

}
}
#endif