WebSVN - shark - Rev 966 - /shark/trunk/drivers/net/eth.c

/*
* Project: S.Ha.R.K.
*
* Coordinators:
* Giorgio Buttazzo <giorgio@sssup.it>
* Paolo Gai <pj@gandalf.sssup.it>
*
* Authors :
* Paolo Gai <pj@gandalf.sssup.it>
* Massimiliano Giorgi <massy@gandalf.sssup.it>
* Luca Abeni <luca@gandalf.sssup.it>
* (see the web pages for full authors list)
*
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
*
* http://www.sssup.it
* http://retis.sssup.it
* http://shark.sssup.it
*/

/**
------------
CVS : $Id: eth.c,v 1.12 2005-02-25 11:04:03 pj Exp $

File: $File$
Revision: $Revision: 1.12 $
Last update: $Date: 2005-02-25 11:04:03 $
------------
**/

/*
* Copyright (C) 2000 Luca Abeni
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/

/* Author: Luca Abeni */
/* Date: 2/12/1997 */

/* File: eth.C */
/* Revision: 2.0 */

/*
Ethernet layer: it is an inetrface between the low level driver (
3Com 3c59xx, ...) and the high level protocols (IP, ARP,...).
*/

/* only 4 debug... */
int netlev;

#include <kernel/kern.h>
#include <hartport/hartport/hartport.h>

#include <linux/pci.h>

#include "eth_priv.h"
#include "netbuff.h"

#include <linux/netdevice.h>
/*#include "lowlev.h"
//#include "3com.h" */

//#define DEBUG_ETH

#define ETH_PAGE 5

struct eth_service{
WORD type;
void (*rfun)(void *pkt);
} ETH_SERVICE;

int definedprotocols;
struct eth_service eth_table[ETH_MAX_PROTOCOLS];

#define ETH_RX_BUFFERS 4
#define ETH_TX_BUFFERS 4

#ifndef ETH0_ADDR
# define ETH0_ADDR 0
#endif
#ifndef ETH0_IRQ
# define ETH0_IRQ 0
#endif

#define NONE 0

/*extern void net_handler(void);
//extern PID net_extern_driver(void);*/

PID nettask_pid = NIL;
static PORT NetRxPort;

/* void (*vortex_send)(DWORD BaseAddress, DWORD *txbuff, int len); */

int ethIsInstalled = FALSE;

/* device descriptor */
struct eth_device eth_dev;
struct pci_des pci_devs[5];
/* This is the Linux one!!! */
static struct device device0 = {
"eth0", 0, 0, 0, 0, ETH0_ADDR, ETH0_IRQ, 0, 0, 0, NULL, NULL};
struct device *dev_base = &device0;

/* received frames buffers */
extern struct netbuff rxbuff; /* from skbuff.c */

/* buffers for the frames to send */
/* struct netbuff txbuff; */

/* Called if an unknown frames arrives */
void eth_nullfun(void *pkt)
{
kern_raise(ETH_NULLPROTOCOL_EXC,NIL);
}

void dev_tint(struct device *dev)
{
printk(KERN_WARNING "Warning! dev_tint called. (Why?)\n");
exit(201);
}

/*
-----------------------------------------------------------------------
The extern process calls this function when a frame arrives
-----------------------------------------------------------------------
*/

void netif_rx(struct sk_buff *skb)
{
// cprintf("DENTRO netif_rx, skbuf=%p\n",skb->data);
if (nettask_pid == NIL) {
printk(KERN_CRIT "Net receives packets, but the driver doesn't exist.\n");
exit(300);
}

port_send(NetRxPort,skb,NON_BLOCK);
// task_activate(nettask_pid);
}

TASK net_extern_driver(void)
{
static PORT NetPort;
struct sk_buff skb;
void *pkt;
int len;
BYTE count;
int i;

NetPort = port_connect("NetPort", sizeof(struct sk_buff), STREAM, READ);
while (1) {
/* debug... */
netlev = 1;

port_receive(NetPort,&skb,BLOCK);
pkt = skb.data;
len = skb.len;

((struct eth_header *)pkt)->type = ntohs(((struct eth_header *)pkt)->type);
count = 0;
/* Search for the frame protocol...*/
for (i = 0; i < definedprotocols; i++) {
/* debug... */
netlev = 10 + i;

if (eth_table[i].type == (((struct eth_header *)pkt)->type)) {
count++;
/*...and call the protocol CallBack!!! */
eth_table[i].rfun(pkt);
}
}

/* debug... */
netlev = 20;

// cprintf("ETH: releasing %p\n", pkt);

// NOTE changed by PJ because skb.data not always point to the
// buffer start!!!... it is skb.head that always points there!
netbuff_release(&rxbuff, skb.head);

/* debug... */
netlev = 30;
}
}

/*
--------------------
Interface functions
--------------------
*/
/* formatted print of an ethernet header */
void eth_printHeader(struct eth_header *p)
{
cprintf("Dest : %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x \n",p->dest.ad[0],
p->dest.ad[1],
p->dest.ad[2],
p->dest.ad[3],
p->dest.ad[4],
p->dest.ad[5]);
cprintf("Source : %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x \n",p->source.ad[0],
p->source.ad[1],
p->source.ad[2],
p->source.ad[3],
p->source.ad[4],
p->source.ad[5]);
cprintf("Type : %x\n",p->type);
}

void eth_showinfo(struct eth_device *d)
{
cprintf("IntLine : %d\n",d->IntLine);
cprintf("BaseAddress : %lx\n",d->BaseAddress);
cprintf("Address : %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n",
d->addr.ad[0],d->addr.ad[1],d->addr.ad[2],
d->addr.ad[3],d->addr.ad[4],d->addr.ad[5]);
}

/* formatted print of an ethernet frame*/
void eth_printPkt(char *pkt,int len)
{
int i,j,offset;

eth_printHeader((struct eth_header *)pkt);
offset = sizeof(struct eth_header);
len -= offset;
for (i = 0; i < len; i += 10) {
for (j = 0; j < 10; j++)
cprintf("%2.2x ", pkt[offset+i+j]);
for (j = 0; j < 10; j++)
cputc(pkt[offset+i+j]);
cprintf("\n");
}
cprintf("\n");
}

void eth_copy_and_sum(struct sk_buff *dest, unsigned char *src, int length, int base)
{
memcpy(dest->data, src, length);
}

#if 0
/*-------------------- User Interface -----------------------------*/
unsigned short htons(unsigned short host)
{
return ((host & 0xff00) >> 8) + ((host & 0x00ff) << 8);
}

unsigned short ntohs(unsigned short host)
{
return ((host & 0xff00) >> 8) + ((host & 0x00ff) << 8);
}
#endif

/*
Translate an ethernet address from a text string to an eth_addr
structure
*/
void eth_str2Addr(char *add, struct eth_addr *ds)
{
int ad[6];
int i,j;
char c;

i = 0;
for(j = 0; j < 6; j++) {
ad[j] = 0;
while((add[i] != ':') && (add[i] != 0)) {
c = add[i++];
if (c <= '9') c = c - '0';
else c = c - 'A' + 10;
ad[j] = ad[j] * 16 + c;
}
i++;
}
for (i=0; i<6; i++) ds->ad[i] = ad[i];
}

/* Set a higher level protocol's CallBack */
int eth_setProtocol(WORD type, void (*recv)(void *pkt))
{
int i;

if (definedprotocols == ETH_MAX_PROTOCOLS) return FALSE;
for(i = 0; i < definedprotocols; i++) {
if (eth_table[i].type == type) return FALSE;
}
eth_table[definedprotocols].type = type;
eth_table[definedprotocols++].rfun = recv;

return TRUE;
}

/* Fill an ethernet frame's header and return a pointer to the frame's body */
void *eth_setHeader(void *b,struct eth_addr dest, WORD type)
{
setEthAddr(((struct eth_header *)b)->dest,dest);
setEthAddr(((struct eth_header *)b)->source,eth_dev.addr);
/* the type field is in big-endian format */
((struct eth_header *) b)->type = htons(type);

return((BYTE *)b + sizeof(struct eth_header));
}

/* getFirstDataByte : Return a pointer to the body of an ethernet frame */
void *eth_getFDB(void *p)
{
return ((void *)((BYTE *)p + sizeof(struct eth_header)));
}

/* eth_getAddress : return the local ethernet address */
void eth_getAddress(struct eth_addr *eth)
{
memcpy(eth->ad,&(device0.dev_addr),sizeof(struct eth_addr));
}

/* Send an ethernet frame */
int eth_sendPkt(void *p, int len)
{
int i;
int l;
struct sk_buff buff;

l = len + sizeof(struct eth_header);
if (l < 60) {
for (i = l; i <= 60; i++) *((BYTE *)p + i) = 0;
l = 60;
}
buff.len = l;
buff.data = p;
device0.hard_start_xmit(&buff, &device0);
/* lowlev_send(eth_dev.BaseAddress, p, l); */

return TRUE;
}

int eth_exc(int err)
{
int p;

if (err != ETH_BUFFERS_FULL) printk(KERN_ERR "Ethernet : ");
switch (err) {
case ETH_DRIVER_NOT_FOUND :
printk(KERN_ERR "NET PANIC --> Etherlink not found.\n");
return 0;
case ETH_RXERROR :
printk(KERN_ERR "Receive error.\n");
return 0;
case ETH_TXERROR :
printk(KERN_ERR "Transimit error: N. Max Retry.\n");
return 0;
case ETH_PROTOCOL_ERROR :
printk(KERN_ERR "Too much protocols.\n");
return 0;
case ETH_BUFFERS_FULL:
printk(KERN_ERR "Buffers full: frame lost!\n");
return 1;
case ETH_NULLPROTOCOL_EXC:
printk(KERN_ERR "Null protocol called!\n");
for (p = 0; p < ETH_MAX_PROTOCOLS; p++) {
printk(KERN_ERR "%d: %d\n", p, eth_table[p].type);
}
return 0;
default :
return 1;
}
}

void skb_init(void);
void linuxpci_init(void);
int rtl8139_probe(struct device *dev);
int tc59x_probe(struct device *dev);
int eepro100_probe(struct device *dev);
int el3_probe(struct device *dev);
int ne_probe(struct device *dev);

int eth_init(int mode, TASK_MODEL *m)
{
SOFT_TASK_MODEL m_soft;
int i;
#if 0
ndev;
WORD Class;
struct pci_regs *r;
PID p;

#endif

BYTE cardtype;
int linux_found = 0;

if (!ethIsInstalled) {
/* Scan the devices connected to the PCI bus */
cardtype = NONE;

skb_init();
NetRxPort = port_create("NetPort",sizeof(struct sk_buff),50,STREAM,WRITE);
if (!m) {
soft_task_default_model(m_soft);
soft_task_def_wcet(m_soft, 1000);
soft_task_def_period(m_soft,20000);
soft_task_def_met(m_soft, 1000);
soft_task_def_aperiodic(m_soft);
soft_task_def_system(m_soft);
soft_task_def_nokill(m_soft);
m = (TASK_MODEL *)&m_soft;
}

nettask_pid = task_create("rxProc", net_extern_driver, m, NULL);
if (nettask_pid == NIL) {
printk(KERN_ERR "Can't create extern driver.\n");
return 0;
}
task_activate(nettask_pid);

if (1) { //!!!if (pci_init() == 1) {
linuxpci_init();
#ifdef DEBUG_ETH
printk(KERN_DEBUG "LF %d\n", linux_found);
#endif
linux_found += (rtl8139_probe(&device0) == 0);
#ifdef DEBUG_ETH
printk(KERN_DEBUG "LF %d\n", linux_found);
#endif
linux_found += (tc59x_probe(&device0) == 0);
#ifdef DEBUG_ETH
printk(KERN_DEBUG "LF %d\n", linux_found);
#endif
linux_found += (eepro100_probe(&device0) == 0);
#ifdef DEBUG_ETH
printk(KERN_DEBUG "LF %d\n", linux_found);
#endif

#if 0
ndev = pci_scan_bus(pci_devs);
#ifdef __ETH_DBG__
pci_show(pci_devs, ndev);
#endif
for (i = 0; i < ndev; i++) {
r = (struct pci_regs *) pci_devs[i].mem;
Class = r->ClassCode;
/* Is there a network card? */
if (Class == 0x0200) {
if (cardtype == NONE) {
cardtype = UNKNOWN;
}
/* is it a 3COM card? */
if (r->VendorId == 0x10b7) {
/* YES!!!!!! */
lowlev_info = vortex_info;
lowlev_readregs = vortex_readregs;
lowlev_open = vortex_open;
lowlev_close = vortex_close;
if (mode == TXTASK) {
lowlev_send = vortex_send_msg;
} else {
lowlev_send = vortex_send_mem;
}
printk(KERN_INFO "PCI Ethlink card found:\n");
lowlev_info(r);
cardtype = VORTEX;
}
}
}
}
if ((cardtype == NONE) || (cardtype == UNKNOWN)) {
exc_raise(ETH_DRIVER_NOT_FOUND);
}
/*PUT HERE THE PFUN INIT!!!*/
if (cardtype == VORTEX) {
}
/*
Use it if you want to see the value of the internal
registers of the card
*/
/*vortex_readregs(eth_dev.BaseAddress);*/

p = lowlev_open(eth_dev.BaseAddress, mode);

/* Set the Fast Handler and the external process */
handler_set(eth_dev.IntLine, net_handler, p);
#else
}
if (linux_found == 0) {
linux_found += (el3_probe(&device0) == 0);
#ifdef DEBUG_ETH
printk(KERN_DEBUG "LF %d\n", linux_found);
#endif
linux_found += (ne_probe(&device0) == 0);
#ifdef DEBUG_ETH
printk(KERN_DEBUG "LF %d\n", linux_found);
#endif
linux_found += (NS8390_init(&device0, 1) == 0);
#ifdef DEBUG_ETH
printk(KERN_DEBUG "LF %d\n", linux_found);
#endif
}

/*
if (mode & LOOPBACK) {
cprintf("Installing loopback device (forced)\n");
loopback_init(&device0);
}
*/
if (linux_found) {
device0.open(&device0);
printk(KERN_INFO "Network card found.\n");
} else {
printk(KERN_INFO "No network card found.\n");
/* cprintf("No network card found. Installing loopback device.\n");
loopback_init(&device0);
device0.open(&device0);*/
return 0;
}
#endif

//netbuff_init(&rxbuff, ETH_RX_BUFFERS, ETH_MAX_LEN);
//netbuff_init(&txbuff, ETH_TX_BUFFERS, ETH_MAX_LEN);

definedprotocols = 0;
for (i = 0; i < ETH_MAX_PROTOCOLS; i++) {
eth_table[i].type = 0;
eth_table[i].rfun = eth_nullfun;
}
ethIsInstalled = TRUE;
/* Don't crash the system at the exit, please :) */
sys_atrunlevel(eth_close,NULL,RUNLEVEL_BEFORE_EXIT);

} else {
printk(KERN_INFO "Ethernet already installed.\n");
return 0;
}
return 1;
}

void eth_close(void *a)
{
#ifdef DEBUG_ETH
printk(KERN_DEBUG "Network Closing.\n");
#endif
if (ethIsInstalled == TRUE) {
device0.stop(&device0);
/* This seems to break everithing... */
// lowlev_close(eth_dev.BaseAddress);
ethIsInstalled = FALSE;
}
#ifdef DEBUG_ETH
printk(KERN_DEBUG "Network Closed.\n");
#endif
}

Subversion Repositories shark

(root)/shark/trunk/drivers/net/eth.c @ 1437 - Rev 966