qemu/roms/ipxe/src/drivers/net/skeleton.c

   1 /*
   2  * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  *
  19  * You can also choose to distribute this program under the terms of
  20  * the Unmodified Binary Distribution Licence (as given in the file
  21  * COPYING.UBDL), provided that you have satisfied its requirements.
  22  */
  23
  24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  25
  26 #include <stdint.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <errno.h>
  30 #include <byteswap.h>
  31 #include <ipxe/netdevice.h>
  32 #include <ipxe/ethernet.h>
  33 #include <ipxe/if_ether.h>
  34 #include <ipxe/iobuf.h>
  35 #include <ipxe/malloc.h>
  36 #include <ipxe/pci.h>
  37 #include <ipxe/mii.h>
  38 #include "skeleton.h"
  39
  40 /** @file
  41  *
  42  * Skeleton network driver
  43  *
  44  */
  45
  46 /******************************************************************************
  47  *
  48  * MII interface
  49  *
  50  ******************************************************************************
  51  */
  52
  53 /**
  54  * Read from MII register
  55  *
  56  * @v mii               MII interface
  57  * @v reg               Register address
  58  * @ret value           Data read, or negative error
  59  */
  60 static int skeleton_mii_read ( struct mii_interface *mii, unsigned int reg ) {
  61         struct skeleton_nic *skel =
  62                 container_of ( mii, struct skeleton_nic, mii );
  63
  64         DBGC ( skel, "SKELETON %p does not yet support MII read\n", skel );
  65         ( void ) reg;
  66         return -ENOTSUP;
  67 }
  68
  69 /**
  70  * Write to MII register
  71  *
  72  * @v mii               MII interface
  73  * @v reg               Register address
  74  * @v data              Data to write
  75  * @ret rc              Return status code
  76  */
  77 static int skeleton_mii_write ( struct mii_interface *mii, unsigned int reg,
  78                                 unsigned int data) {
  79         struct skeleton_nic *skel =
  80                 container_of ( mii, struct skeleton_nic, mii );
  81
  82         DBGC ( skel, "SKELETON %p does not yet support MII write\n", skel );
  83         ( void ) reg;
  84         ( void ) data;
  85         return -ENOTSUP;
  86 }
  87
  88 /** Skeleton MII operations */
  89 static struct mii_operations skeleton_mii_operations = {
  90         .read = skeleton_mii_read,
  91         .write = skeleton_mii_write,
  92 };
  93
  94 /******************************************************************************
  95  *
  96  * Device reset
  97  *
  98  ******************************************************************************
  99  */
 100
 101 /**
 102  * Reset hardware
 103  *
 104  * @v skel              Skeleton device
 105  * @ret rc              Return status code
 106  */
 107 static int skeleton_reset ( struct skeleton_nic *skel ) {
 108
 109         DBGC ( skel, "SKELETON %p does not yet support reset\n", skel );
 110         return -ENOTSUP;
 111 }
 112
 113 /******************************************************************************
 114  *
 115  * Link state
 116  *
 117  ******************************************************************************
 118  */
 119
 120 /**
 121  * Check link state
 122  *
 123  * @v netdev            Network device
 124  */
 125 static void skeleton_check_link ( struct net_device *netdev ) {
 126         struct skeleton_nic *skel = netdev->priv;
 127
 128         DBGC ( skel, "SKELETON %p does not yet support link state\n", skel );
 129         netdev_link_err ( netdev, -ENOTSUP );
 130 }
 131
 132 /******************************************************************************
 133  *
 134  * Network device interface
 135  *
 136  ******************************************************************************
 137  */
 138
 139 /**
 140  * Open network device
 141  *
 142  * @v netdev            Network device
 143  * @ret rc              Return status code
 144  */
 145 static int skeleton_open ( struct net_device *netdev ) {
 146         struct skeleton_nic *skel = netdev->priv;
 147
 148         DBGC ( skel, "SKELETON %p does not yet support open\n", skel );
 149         return -ENOTSUP;
 150 }
 151
 152 /**
 153  * Close network device
 154  *
 155  * @v netdev            Network device
 156  */
 157 static void skeleton_close ( struct net_device *netdev ) {
 158         struct skeleton_nic *skel = netdev->priv;
 159
 160         DBGC ( skel, "SKELETON %p does not yet support close\n", skel );
 161 }
 162
 163 /**
 164  * Transmit packet
 165  *
 166  * @v netdev            Network device
 167  * @v iobuf             I/O buffer
 168  * @ret rc              Return status code
 169  */
 170 static int skeleton_transmit ( struct net_device *netdev,
 171                                struct io_buffer *iobuf ) {
 172         struct skeleton_nic *skel = netdev->priv;
 173
 174         DBGC ( skel, "SKELETON %p does not yet support transmit\n", skel );
 175         ( void ) iobuf;
 176         return -ENOTSUP;
 177 }
 178
 179 /**
 180  * Poll for completed and received packets
 181  *
 182  * @v netdev            Network device
 183  */
 184 static void skeleton_poll ( struct net_device *netdev ) {
 185         struct skeleton_nic *skel = netdev->priv;
 186
 187         /* Not yet implemented */
 188         ( void ) skel;
 189 }
 190
 191 /**
 192  * Enable or disable interrupts
 193  *
 194  * @v netdev            Network device
 195  * @v enable            Interrupts should be enabled
 196  */
 197 static void skeleton_irq ( struct net_device *netdev, int enable ) {
 198         struct skeleton_nic *skel = netdev->priv;
 199
 200         DBGC ( skel, "SKELETON %p does not yet support interrupts\n", skel );
 201         ( void ) enable;
 202 }
 203
 204 /** Skeleton network device operations */
 205 static struct net_device_operations skeleton_operations = {
 206         .open           = skeleton_open,
 207         .close          = skeleton_close,
 208         .transmit       = skeleton_transmit,
 209         .poll           = skeleton_poll,
 210         .irq            = skeleton_irq,
 211 };
 212
 213 /******************************************************************************
 214  *
 215  * PCI interface
 216  *
 217  ******************************************************************************
 218  */
 219
 220 /**
 221  * Probe PCI device
 222  *
 223  * @v pci               PCI device
 224  * @ret rc              Return status code
 225  */
 226 static int skeleton_probe ( struct pci_device *pci ) {
 227         struct net_device *netdev;
 228         struct skeleton_nic *skel;
 229         int rc;
 230
 231         /* Allocate and initialise net device */
 232         netdev = alloc_etherdev ( sizeof ( *skel ) );
 233         if ( ! netdev ) {
 234                 rc = -ENOMEM;
 235                 goto err_alloc;
 236         }
 237         netdev_init ( netdev, &skeleton_operations );
 238         skel = netdev->priv;
 239         pci_set_drvdata ( pci, netdev );
 240         netdev->dev = &pci->dev;
 241         memset ( skel, 0, sizeof ( *skel ) );
 242
 243         /* Fix up PCI device */
 244         adjust_pci_device ( pci );
 245
 246         /* Map registers */
 247         skel->regs = ioremap ( pci->membase, SKELETON_BAR_SIZE );
 248         if ( ! skel->regs ) {
 249                 rc = -ENODEV;
 250                 goto err_ioremap;
 251         }
 252
 253         /* Reset the NIC */
 254         if ( ( rc = skeleton_reset ( skel ) ) != 0 )
 255                 goto err_reset;
 256
 257         /* Initialise and reset MII interface */
 258         mii_init ( &skel->mii, &skeleton_mii_operations );
 259         if ( ( rc = mii_reset ( &skel->mii ) ) != 0 ) {
 260                 DBGC ( skel, "SKELETON %p could not reset MII: %s\n",
 261                        skel, strerror ( rc ) );
 262                 goto err_mii_reset;
 263         }
 264
 265         /* Register network device */
 266         if ( ( rc = register_netdev ( netdev ) ) != 0 )
 267                 goto err_register_netdev;
 268
 269         /* Set initial link state */
 270         skeleton_check_link ( netdev );
 271
 272         return 0;
 273
 274         unregister_netdev ( netdev );
 275  err_register_netdev:
 276  err_mii_reset:
 277         skeleton_reset ( skel );
 278  err_reset:
 279         iounmap ( skel->regs );
 280  err_ioremap:
 281         netdev_nullify ( netdev );
 282         netdev_put ( netdev );
 283  err_alloc:
 284         return rc;
 285 }
 286
 287 /**
 288  * Remove PCI device
 289  *
 290  * @v pci               PCI device
 291  */
 292 static void skeleton_remove ( struct pci_device *pci ) {
 293         struct net_device *netdev = pci_get_drvdata ( pci );
 294         struct skeleton_nic *skel = netdev->priv;
 295
 296         /* Unregister network device */
 297         unregister_netdev ( netdev );
 298
 299         /* Reset card */
 300         skeleton_reset ( skel );
 301
 302         /* Free network device */
 303         iounmap ( skel->regs );
 304         netdev_nullify ( netdev );
 305         netdev_put ( netdev );
 306 }
 307
 308 /** Skeleton PCI device IDs */
 309 static struct pci_device_id skeleton_nics[] = {
 310         PCI_ROM ( 0x5ce1, 0x5ce1, "skel",       "Skeleton", 0 ),
 311 };
 312
 313 /** Skeleton PCI driver */
 314 struct pci_driver skeleton_driver __pci_driver = {
 315         .ids = skeleton_nics,
 316         .id_count = ( sizeof ( skeleton_nics ) / sizeof ( skeleton_nics[0] ) ),
 317         .probe = skeleton_probe,
 318         .remove = skeleton_remove,
 319 };