mirror of https://gitee.com/openkylin/linux.git
371 lines
8.7 KiB
C
371 lines
8.7 KiB
C
/*
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
* License. See the file "COPYING" in the main directory of this archive
|
|
* for more details.
|
|
*/
|
|
|
|
#define DEBUG
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/platform_device.h>
|
|
#include <asm/io.h>
|
|
#include <asm/mips-boards/simint.h>
|
|
|
|
#include "mipsnet.h" /* actual device IO mapping */
|
|
|
|
#define MIPSNET_VERSION "2005-06-20"
|
|
|
|
#define mipsnet_reg_address(dev, field) (dev->base_addr + field_offset(field))
|
|
|
|
struct mipsnet_priv {
|
|
struct net_device_stats stats;
|
|
};
|
|
|
|
static struct platform_device *mips_plat_dev;
|
|
|
|
static char mipsnet_string[] = "mipsnet";
|
|
|
|
/*
|
|
* Copy data from the MIPSNET rx data port
|
|
*/
|
|
static int ioiocpy_frommipsnet(struct net_device *dev, unsigned char *kdata,
|
|
int len)
|
|
{
|
|
uint32_t available_len = inl(mipsnet_reg_address(dev, rxDataCount));
|
|
if (available_len < len)
|
|
return -EFAULT;
|
|
|
|
for (; len > 0; len--, kdata++) {
|
|
*kdata = inb(mipsnet_reg_address(dev, rxDataBuffer));
|
|
}
|
|
|
|
return inl(mipsnet_reg_address(dev, rxDataCount));
|
|
}
|
|
|
|
static inline ssize_t mipsnet_put_todevice(struct net_device *dev,
|
|
struct sk_buff *skb)
|
|
{
|
|
int count_to_go = skb->len;
|
|
char *buf_ptr = skb->data;
|
|
struct mipsnet_priv *mp = netdev_priv(dev);
|
|
|
|
pr_debug("%s: %s(): telling MIPSNET txDataCount(%d)\n",
|
|
dev->name, __FUNCTION__, skb->len);
|
|
|
|
outl(skb->len, mipsnet_reg_address(dev, txDataCount));
|
|
|
|
pr_debug("%s: %s(): sending data to MIPSNET txDataBuffer(%d)\n",
|
|
dev->name, __FUNCTION__, skb->len);
|
|
|
|
for (; count_to_go; buf_ptr++, count_to_go--) {
|
|
outb(*buf_ptr, mipsnet_reg_address(dev, txDataBuffer));
|
|
}
|
|
|
|
mp->stats.tx_packets++;
|
|
mp->stats.tx_bytes += skb->len;
|
|
|
|
return skb->len;
|
|
}
|
|
|
|
static int mipsnet_xmit(struct sk_buff *skb, struct net_device *dev)
|
|
{
|
|
pr_debug("%s:%s(): transmitting %d bytes\n",
|
|
dev->name, __FUNCTION__, skb->len);
|
|
|
|
/* Only one packet at a time. Once TXDONE interrupt is serviced, the
|
|
* queue will be restarted.
|
|
*/
|
|
netif_stop_queue(dev);
|
|
mipsnet_put_todevice(dev, skb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline ssize_t mipsnet_get_fromdev(struct net_device *dev, size_t count)
|
|
{
|
|
struct sk_buff *skb;
|
|
size_t len = count;
|
|
struct mipsnet_priv *mp = netdev_priv(dev);
|
|
|
|
if (!(skb = alloc_skb(len + 2, GFP_KERNEL))) {
|
|
mp->stats.rx_dropped++;
|
|
return -ENOMEM;
|
|
}
|
|
|
|
skb_reserve(skb, 2);
|
|
if (ioiocpy_frommipsnet(dev, skb_put(skb, len), len))
|
|
return -EFAULT;
|
|
|
|
skb->dev = dev;
|
|
skb->protocol = eth_type_trans(skb, dev);
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
|
|
|
pr_debug("%s:%s(): pushing RXed data to kernel\n",
|
|
dev->name, __FUNCTION__);
|
|
netif_rx(skb);
|
|
|
|
mp->stats.rx_packets++;
|
|
mp->stats.rx_bytes += len;
|
|
|
|
return count;
|
|
}
|
|
|
|
static irqreturn_t mipsnet_interrupt(int irq, void *dev_id)
|
|
{
|
|
struct net_device *dev = dev_id;
|
|
|
|
irqreturn_t retval = IRQ_NONE;
|
|
uint64_t interruptFlags;
|
|
|
|
if (irq == dev->irq) {
|
|
pr_debug("%s:%s(): irq %d for device\n",
|
|
dev->name, __FUNCTION__, irq);
|
|
|
|
retval = IRQ_HANDLED;
|
|
|
|
interruptFlags =
|
|
inl(mipsnet_reg_address(dev, interruptControl));
|
|
pr_debug("%s:%s(): intCtl=0x%016llx\n", dev->name,
|
|
__FUNCTION__, interruptFlags);
|
|
|
|
if (interruptFlags & MIPSNET_INTCTL_TXDONE) {
|
|
pr_debug("%s:%s(): got TXDone\n",
|
|
dev->name, __FUNCTION__);
|
|
outl(MIPSNET_INTCTL_TXDONE,
|
|
mipsnet_reg_address(dev, interruptControl));
|
|
// only one packet at a time, we are done.
|
|
netif_wake_queue(dev);
|
|
} else if (interruptFlags & MIPSNET_INTCTL_RXDONE) {
|
|
pr_debug("%s:%s(): got RX data\n",
|
|
dev->name, __FUNCTION__);
|
|
mipsnet_get_fromdev(dev,
|
|
inl(mipsnet_reg_address(dev, rxDataCount)));
|
|
pr_debug("%s:%s(): clearing RX int\n",
|
|
dev->name, __FUNCTION__);
|
|
outl(MIPSNET_INTCTL_RXDONE,
|
|
mipsnet_reg_address(dev, interruptControl));
|
|
|
|
} else if (interruptFlags & MIPSNET_INTCTL_TESTBIT) {
|
|
pr_debug("%s:%s(): got test interrupt\n",
|
|
dev->name, __FUNCTION__);
|
|
// TESTBIT is cleared on read.
|
|
// And takes effect after a write with 0
|
|
outl(0, mipsnet_reg_address(dev, interruptControl));
|
|
} else {
|
|
pr_debug("%s:%s(): no valid fags 0x%016llx\n",
|
|
dev->name, __FUNCTION__, interruptFlags);
|
|
// Maybe shared IRQ, just ignore, no clearing.
|
|
retval = IRQ_NONE;
|
|
}
|
|
|
|
} else {
|
|
printk(KERN_INFO "%s: %s(): irq %d for unknown device\n",
|
|
dev->name, __FUNCTION__, irq);
|
|
retval = IRQ_NONE;
|
|
}
|
|
return retval;
|
|
} //mipsnet_interrupt()
|
|
|
|
static int mipsnet_open(struct net_device *dev)
|
|
{
|
|
int err;
|
|
pr_debug("%s: mipsnet_open\n", dev->name);
|
|
|
|
err = request_irq(dev->irq, &mipsnet_interrupt,
|
|
IRQF_SHARED, dev->name, (void *) dev);
|
|
|
|
if (err) {
|
|
pr_debug("%s: %s(): can't get irq %d\n",
|
|
dev->name, __FUNCTION__, dev->irq);
|
|
release_region(dev->base_addr, MIPSNET_IO_EXTENT);
|
|
return err;
|
|
}
|
|
|
|
pr_debug("%s: %s(): got IO region at 0x%04lx and irq %d for dev.\n",
|
|
dev->name, __FUNCTION__, dev->base_addr, dev->irq);
|
|
|
|
|
|
netif_start_queue(dev);
|
|
|
|
// test interrupt handler
|
|
outl(MIPSNET_INTCTL_TESTBIT,
|
|
mipsnet_reg_address(dev, interruptControl));
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mipsnet_close(struct net_device *dev)
|
|
{
|
|
pr_debug("%s: %s()\n", dev->name, __FUNCTION__);
|
|
netif_stop_queue(dev);
|
|
return 0;
|
|
}
|
|
|
|
static struct net_device_stats *mipsnet_get_stats(struct net_device *dev)
|
|
{
|
|
struct mipsnet_priv *mp = netdev_priv(dev);
|
|
|
|
return &mp->stats;
|
|
}
|
|
|
|
static void mipsnet_set_mclist(struct net_device *dev)
|
|
{
|
|
// we don't do anything
|
|
return;
|
|
}
|
|
|
|
static int __init mipsnet_probe(struct device *dev)
|
|
{
|
|
struct net_device *netdev;
|
|
int err;
|
|
|
|
netdev = alloc_etherdev(sizeof(struct mipsnet_priv));
|
|
if (!netdev) {
|
|
err = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
dev_set_drvdata(dev, netdev);
|
|
|
|
netdev->open = mipsnet_open;
|
|
netdev->stop = mipsnet_close;
|
|
netdev->hard_start_xmit = mipsnet_xmit;
|
|
netdev->get_stats = mipsnet_get_stats;
|
|
netdev->set_multicast_list = mipsnet_set_mclist;
|
|
|
|
/*
|
|
* TODO: probe for these or load them from PARAM
|
|
*/
|
|
netdev->base_addr = 0x4200;
|
|
netdev->irq = MIPSCPU_INT_BASE + MIPSCPU_INT_MB0 +
|
|
inl(mipsnet_reg_address(netdev, interruptInfo));
|
|
|
|
// Get the io region now, get irq on open()
|
|
if (!request_region(netdev->base_addr, MIPSNET_IO_EXTENT, "mipsnet")) {
|
|
pr_debug("%s: %s(): IO region {start: 0x%04lux, len: %d} "
|
|
"for dev is not availble.\n", netdev->name,
|
|
__FUNCTION__, netdev->base_addr, MIPSNET_IO_EXTENT);
|
|
err = -EBUSY;
|
|
goto out_free_netdev;
|
|
}
|
|
|
|
/*
|
|
* Lacking any better mechanism to allocate a MAC address we use a
|
|
* random one ...
|
|
*/
|
|
random_ether_addr(netdev->dev_addr);
|
|
|
|
err = register_netdev(netdev);
|
|
if (err) {
|
|
printk(KERN_ERR "MIPSNet: failed to register netdev.\n");
|
|
goto out_free_region;
|
|
}
|
|
|
|
return 0;
|
|
|
|
out_free_region:
|
|
release_region(netdev->base_addr, MIPSNET_IO_EXTENT);
|
|
|
|
out_free_netdev:
|
|
free_netdev(netdev);
|
|
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
static int __devexit mipsnet_device_remove(struct device *device)
|
|
{
|
|
struct net_device *dev = dev_get_drvdata(device);
|
|
|
|
unregister_netdev(dev);
|
|
release_region(dev->base_addr, MIPSNET_IO_EXTENT);
|
|
free_netdev(dev);
|
|
dev_set_drvdata(device, NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct device_driver mipsnet_driver = {
|
|
.name = mipsnet_string,
|
|
.bus = &platform_bus_type,
|
|
.probe = mipsnet_probe,
|
|
.remove = __devexit_p(mipsnet_device_remove),
|
|
};
|
|
|
|
static void mipsnet_platform_release(struct device *device)
|
|
{
|
|
struct platform_device *pldev;
|
|
|
|
/* free device */
|
|
pldev = to_platform_device(device);
|
|
kfree(pldev);
|
|
}
|
|
|
|
static int __init mipsnet_init_module(void)
|
|
{
|
|
struct platform_device *pldev;
|
|
int err;
|
|
|
|
printk(KERN_INFO "MIPSNet Ethernet driver. Version: %s. "
|
|
"(c)2005 MIPS Technologies, Inc.\n", MIPSNET_VERSION);
|
|
|
|
if (driver_register(&mipsnet_driver)) {
|
|
printk(KERN_ERR "Driver registration failed\n");
|
|
err = -ENODEV;
|
|
goto out;
|
|
}
|
|
|
|
if (!(pldev = kmalloc (sizeof (*pldev), GFP_KERNEL))) {
|
|
err = -ENOMEM;
|
|
goto out_unregister_driver;
|
|
}
|
|
|
|
memset (pldev, 0, sizeof (*pldev));
|
|
pldev->name = mipsnet_string;
|
|
pldev->id = 0;
|
|
pldev->dev.release = mipsnet_platform_release;
|
|
|
|
if (platform_device_register(pldev)) {
|
|
err = -ENODEV;
|
|
goto out_free_pldev;
|
|
}
|
|
|
|
if (!pldev->dev.driver) {
|
|
/*
|
|
* The driver was not bound to this device, there was
|
|
* no hardware at this address. Unregister it, as the
|
|
* release fuction will take care of freeing the
|
|
* allocated structure
|
|
*/
|
|
platform_device_unregister (pldev);
|
|
}
|
|
|
|
mips_plat_dev = pldev;
|
|
|
|
return 0;
|
|
|
|
out_free_pldev:
|
|
kfree(pldev);
|
|
|
|
out_unregister_driver:
|
|
driver_unregister(&mipsnet_driver);
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
static void __exit mipsnet_exit_module(void)
|
|
{
|
|
pr_debug("MIPSNet Ethernet driver exiting\n");
|
|
|
|
driver_unregister(&mipsnet_driver);
|
|
}
|
|
|
|
module_init(mipsnet_init_module);
|
|
module_exit(mipsnet_exit_module);
|