drivers/net/ethernet/sun/sunvnet.c

   1 /* sunvnet.c: Sun LDOM Virtual Network Driver.
   2  *
   3  * Copyright (C) 2007, 2008 David S. Miller <davem@davemloft.net>
   4  * Copyright (C) 2016 Oracle. All rights reserved.
   5  */
   6
   7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   8
   9 #include <linux/module.h>
  10 #include <linux/kernel.h>
  11 #include <linux/types.h>
  12 #include <linux/slab.h>
  13 #include <linux/delay.h>
  14 #include <linux/init.h>
  15 #include <linux/netdevice.h>
  16 #include <linux/ethtool.h>
  17 #include <linux/etherdevice.h>
  18 #include <linux/mutex.h>
  19 #include <linux/highmem.h>
  20 #include <linux/if_vlan.h>
  21
  22 #if IS_ENABLED(CONFIG_IPV6)
  23 #include <linux/icmpv6.h>
  24 #endif
  25
  26 #include <net/ip.h>
  27 #include <net/icmp.h>
  28 #include <net/route.h>
  29
  30 #include <asm/vio.h>
  31 #include <asm/ldc.h>
  32
  33 #include "sunvnet_common.h"
  34
  35 /* length of time before we decide the hardware is borked,
  36  * and dev->tx_timeout() should be called to fix the problem
  37  */
  38 #define VNET_TX_TIMEOUT                 (5 * HZ)
  39
  40 #define DRV_MODULE_NAME         "sunvnet"
  41 #define DRV_MODULE_VERSION      "1.0"
  42 #define DRV_MODULE_RELDATE      "June 25, 2007"
  43
  44 static char version[] =
  45         DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
  46 MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
  47 MODULE_DESCRIPTION("Sun LDOM virtual network driver");
  48 MODULE_LICENSE("GPL");
  49 MODULE_VERSION(DRV_MODULE_VERSION);
  50
  51 /* Ordered from largest major to lowest */
  52 static struct vio_version vnet_versions[] = {
  53         { .major = 1, .minor = 8 },
  54         { .major = 1, .minor = 7 },
  55         { .major = 1, .minor = 6 },
  56         { .major = 1, .minor = 0 },
  57 };
  58
  59 static void vnet_get_drvinfo(struct net_device *dev,
  60                              struct ethtool_drvinfo *info)
  61 {
  62         strlcpy(info->driver, DRV_MODULE_NAME, sizeof(info->driver));
  63         strlcpy(info->version, DRV_MODULE_VERSION, sizeof(info->version));
  64 }
  65
  66 static u32 vnet_get_msglevel(struct net_device *dev)
  67 {
  68         struct vnet *vp = netdev_priv(dev);
  69
  70         return vp->msg_enable;
  71 }
  72
  73 static void vnet_set_msglevel(struct net_device *dev, u32 value)
  74 {
  75         struct vnet *vp = netdev_priv(dev);
  76
  77         vp->msg_enable = value;
  78 }
  79
  80 static const struct ethtool_ops vnet_ethtool_ops = {
  81         .get_drvinfo            = vnet_get_drvinfo,
  82         .get_msglevel           = vnet_get_msglevel,
  83         .set_msglevel           = vnet_set_msglevel,
  84         .get_link               = ethtool_op_get_link,
  85 };
  86
  87 static LIST_HEAD(vnet_list);
  88 static DEFINE_MUTEX(vnet_list_mutex);
  89
  90 static struct vnet_port *__tx_port_find(struct vnet *vp, struct sk_buff *skb)
  91 {
  92         unsigned int hash = vnet_hashfn(skb->data);
  93         struct hlist_head *hp = &vp->port_hash[hash];
  94         struct vnet_port *port;
  95
  96         hlist_for_each_entry_rcu(port, hp, hash) {
  97                 if (!sunvnet_port_is_up_common(port))
  98                         continue;
  99                 if (ether_addr_equal(port->raddr, skb->data))
 100                         return port;
 101         }
 102         list_for_each_entry_rcu(port, &vp->port_list, list) {
 103                 if (!port->switch_port)
 104                         continue;
 105                 if (!sunvnet_port_is_up_common(port))
 106                         continue;
 107                 return port;
 108         }
 109         return NULL;
 110 }
 111
 112 /* func arg to vnet_start_xmit_common() to get the proper tx port */
 113 static struct vnet_port *vnet_tx_port_find(struct sk_buff *skb,
 114                                            struct net_device *dev)
 115 {
 116         struct vnet *vp = netdev_priv(dev);
 117
 118         return __tx_port_find(vp, skb);
 119 }
 120
 121 static u16 vnet_select_queue(struct net_device *dev, struct sk_buff *skb,
 122                              void *accel_priv, select_queue_fallback_t fallback)
 123 {
 124         struct vnet *vp = netdev_priv(dev);
 125         struct vnet_port *port = __tx_port_find(vp, skb);
 126
 127         if (!port)
 128                 return 0;
 129
 130         return port->q_index;
 131 }
 132
 133 /* Wrappers to common functions */
 134 static int vnet_start_xmit(struct sk_buff *skb, struct net_device *dev)
 135 {
 136         return sunvnet_start_xmit_common(skb, dev, vnet_tx_port_find);
 137 }
 138
 139 static void vnet_set_rx_mode(struct net_device *dev)
 140 {
 141         struct vnet *vp = netdev_priv(dev);
 142
 143         return sunvnet_set_rx_mode_common(dev, vp);
 144 }
 145
 146 #ifdef CONFIG_NET_POLL_CONTROLLER
 147 static void vnet_poll_controller(struct net_device *dev)
 148 {
 149         struct vnet *vp = netdev_priv(dev);
 150
 151         return sunvnet_poll_controller_common(dev, vp);
 152 }
 153 #endif
 154
 155 static const struct net_device_ops vnet_ops = {
 156         .ndo_open               = sunvnet_open_common,
 157         .ndo_stop               = sunvnet_close_common,
 158         .ndo_set_rx_mode        = vnet_set_rx_mode,
 159         .ndo_set_mac_address    = sunvnet_set_mac_addr_common,
 160         .ndo_validate_addr      = eth_validate_addr,
 161         .ndo_tx_timeout         = sunvnet_tx_timeout_common,
 162         .ndo_change_mtu         = sunvnet_change_mtu_common,
 163         .ndo_start_xmit         = vnet_start_xmit,
 164         .ndo_select_queue       = vnet_select_queue,
 165 #ifdef CONFIG_NET_POLL_CONTROLLER
 166         .ndo_poll_controller    = vnet_poll_controller,
 167 #endif
 168 };
 169
 170 static struct vnet *vnet_new(const u64 *local_mac,
 171                              struct vio_dev *vdev)
 172 {
 173         struct net_device *dev;
 174         struct vnet *vp;
 175         int err, i;
 176
 177         dev = alloc_etherdev_mqs(sizeof(*vp), VNET_MAX_TXQS, 1);
 178         if (!dev)
 179                 return ERR_PTR(-ENOMEM);
 180         dev->needed_headroom = VNET_PACKET_SKIP + 8;
 181         dev->needed_tailroom = 8;
 182
 183         for (i = 0; i < ETH_ALEN; i++)
 184                 dev->dev_addr[i] = (*local_mac >> (5 - i) * 8) & 0xff;
 185
 186         vp = netdev_priv(dev);
 187
 188         spin_lock_init(&vp->lock);
 189         vp->dev = dev;
 190
 191         INIT_LIST_HEAD(&vp->port_list);
 192         for (i = 0; i < VNET_PORT_HASH_SIZE; i++)
 193                 INIT_HLIST_HEAD(&vp->port_hash[i]);
 194         INIT_LIST_HEAD(&vp->list);
 195         vp->local_mac = *local_mac;
 196
 197         dev->netdev_ops = &vnet_ops;
 198         dev->ethtool_ops = &vnet_ethtool_ops;
 199         dev->watchdog_timeo = VNET_TX_TIMEOUT;
 200
 201         dev->hw_features = NETIF_F_TSO | NETIF_F_GSO | NETIF_F_GSO_SOFTWARE |
 202                            NETIF_F_HW_CSUM | NETIF_F_SG;
 203         dev->features = dev->hw_features;
 204
 205         SET_NETDEV_DEV(dev, &vdev->dev);
 206
 207         err = register_netdev(dev);
 208         if (err) {
 209                 pr_err("Cannot register net device, aborting\n");
 210                 goto err_out_free_dev;
 211         }
 212
 213         netdev_info(dev, "Sun LDOM vnet %pM\n", dev->dev_addr);
 214
 215         list_add(&vp->list, &vnet_list);
 216
 217         return vp;
 218
 219 err_out_free_dev:
 220         free_netdev(dev);
 221
 222         return ERR_PTR(err);
 223 }
 224
 225 static struct vnet *vnet_find_or_create(const u64 *local_mac,
 226                                         struct vio_dev *vdev)
 227 {
 228         struct vnet *iter, *vp;
 229
 230         mutex_lock(&vnet_list_mutex);
 231         vp = NULL;
 232         list_for_each_entry(iter, &vnet_list, list) {
 233                 if (iter->local_mac == *local_mac) {
 234                         vp = iter;
 235                         break;
 236                 }
 237         }
 238         if (!vp)
 239                 vp = vnet_new(local_mac, vdev);
 240         mutex_unlock(&vnet_list_mutex);
 241
 242         return vp;
 243 }
 244
 245 static void vnet_cleanup(void)
 246 {
 247         struct vnet *vp;
 248         struct net_device *dev;
 249
 250         mutex_lock(&vnet_list_mutex);
 251         while (!list_empty(&vnet_list)) {
 252                 vp = list_first_entry(&vnet_list, struct vnet, list);
 253                 list_del(&vp->list);
 254                 dev = vp->dev;
 255                 /* vio_unregister_driver() should have cleaned up port_list */
 256                 BUG_ON(!list_empty(&vp->port_list));
 257                 unregister_netdev(dev);
 258                 free_netdev(dev);
 259         }
 260         mutex_unlock(&vnet_list_mutex);
 261 }
 262
 263 static const char *local_mac_prop = "local-mac-address";
 264
 265 static struct vnet *vnet_find_parent(struct mdesc_handle *hp,
 266                                      u64 port_node,
 267                                      struct vio_dev *vdev)
 268 {
 269         const u64 *local_mac = NULL;
 270         u64 a;
 271
 272         mdesc_for_each_arc(a, hp, port_node, MDESC_ARC_TYPE_BACK) {
 273                 u64 target = mdesc_arc_target(hp, a);
 274                 const char *name;
 275
 276                 name = mdesc_get_property(hp, target, "name", NULL);
 277                 if (!name || strcmp(name, "network"))
 278                         continue;
 279
 280                 local_mac = mdesc_get_property(hp, target,
 281                                                local_mac_prop, NULL);
 282                 if (local_mac)
 283                         break;
 284         }
 285         if (!local_mac)
 286                 return ERR_PTR(-ENODEV);
 287
 288         return vnet_find_or_create(local_mac, vdev);
 289 }
 290
 291 static struct ldc_channel_config vnet_ldc_cfg = {
 292         .event          = sunvnet_event_common,
 293         .mtu            = 64,
 294         .mode           = LDC_MODE_UNRELIABLE,
 295 };
 296
 297 static struct vio_driver_ops vnet_vio_ops = {
 298         .send_attr              = sunvnet_send_attr_common,
 299         .handle_attr            = sunvnet_handle_attr_common,
 300         .handshake_complete     = sunvnet_handshake_complete_common,
 301 };
 302
 303 static void print_version(void)
 304 {
 305         printk_once(KERN_INFO "%s", version);
 306 }
 307
 308 const char *remote_macaddr_prop = "remote-mac-address";
 309
 310 static int vnet_port_probe(struct vio_dev *vdev, const struct vio_device_id *id)
 311 {
 312         struct mdesc_handle *hp;
 313         struct vnet_port *port;
 314         unsigned long flags;
 315         struct vnet *vp;
 316         const u64 *rmac;
 317         int len, i, err, switch_port;
 318
 319         print_version();
 320
 321         hp = mdesc_grab();
 322
 323         vp = vnet_find_parent(hp, vdev->mp, vdev);
 324         if (IS_ERR(vp)) {
 325                 pr_err("Cannot find port parent vnet\n");
 326                 err = PTR_ERR(vp);
 327                 goto err_out_put_mdesc;
 328         }
 329
 330         rmac = mdesc_get_property(hp, vdev->mp, remote_macaddr_prop, &len);
 331         err = -ENODEV;
 332         if (!rmac) {
 333                 pr_err("Port lacks %s property\n", remote_macaddr_prop);
 334                 goto err_out_put_mdesc;
 335         }
 336
 337         port = kzalloc(sizeof(*port), GFP_KERNEL);
 338         err = -ENOMEM;
 339         if (!port)
 340                 goto err_out_put_mdesc;
 341
 342         for (i = 0; i < ETH_ALEN; i++)
 343                 port->raddr[i] = (*rmac >> (5 - i) * 8) & 0xff;
 344
 345         port->vp = vp;
 346
 347         err = vio_driver_init(&port->vio, vdev, VDEV_NETWORK,
 348                               vnet_versions, ARRAY_SIZE(vnet_versions),
 349                               &vnet_vio_ops, vp->dev->name);
 350         if (err)
 351                 goto err_out_free_port;
 352
 353         err = vio_ldc_alloc(&port->vio, &vnet_ldc_cfg, port);
 354         if (err)
 355                 goto err_out_free_port;
 356
 357         netif_napi_add(port->vp->dev, &port->napi, sunvnet_poll_common,
 358                        NAPI_POLL_WEIGHT);
 359
 360         INIT_HLIST_NODE(&port->hash);
 361         INIT_LIST_HEAD(&port->list);
 362
 363         switch_port = 0;
 364         if (mdesc_get_property(hp, vdev->mp, "switch-port", NULL))
 365                 switch_port = 1;
 366         port->switch_port = switch_port;
 367         port->tso = true;
 368         port->tsolen = 0;
 369
 370         spin_lock_irqsave(&vp->lock, flags);
 371         if (switch_port)
 372                 list_add_rcu(&port->list, &vp->port_list);
 373         else
 374                 list_add_tail_rcu(&port->list, &vp->port_list);
 375         hlist_add_head_rcu(&port->hash,
 376                            &vp->port_hash[vnet_hashfn(port->raddr)]);
 377         sunvnet_port_add_txq_common(port);
 378         spin_unlock_irqrestore(&vp->lock, flags);
 379
 380         dev_set_drvdata(&vdev->dev, port);
 381
 382         pr_info("%s: PORT ( remote-mac %pM%s )\n",
 383                 vp->dev->name, port->raddr, switch_port ? " switch-port" : "");
 384
 385         setup_timer(&port->clean_timer, sunvnet_clean_timer_expire_common,
 386                     (unsigned long)port);
 387
 388         napi_enable(&port->napi);
 389         vio_port_up(&port->vio);
 390
 391         mdesc_release(hp);
 392
 393         return 0;
 394
 395 err_out_free_port:
 396         kfree(port);
 397
 398 err_out_put_mdesc:
 399         mdesc_release(hp);
 400         return err;
 401 }
 402
 403 static int vnet_port_remove(struct vio_dev *vdev)
 404 {
 405         struct vnet_port *port = dev_get_drvdata(&vdev->dev);
 406
 407         if (port) {
 408                 del_timer_sync(&port->vio.timer);
 409
 410                 napi_disable(&port->napi);
 411
 412                 list_del_rcu(&port->list);
 413                 hlist_del_rcu(&port->hash);
 414
 415                 synchronize_rcu();
 416                 del_timer_sync(&port->clean_timer);
 417                 sunvnet_port_rm_txq_common(port);
 418                 netif_napi_del(&port->napi);
 419                 sunvnet_port_free_tx_bufs_common(port);
 420                 vio_ldc_free(&port->vio);
 421
 422                 dev_set_drvdata(&vdev->dev, NULL);
 423
 424                 kfree(port);
 425         }
 426         return 0;
 427 }
 428
 429 static const struct vio_device_id vnet_port_match[] = {
 430         {
 431                 .type = "vnet-port",
 432         },
 433         {},
 434 };
 435 MODULE_DEVICE_TABLE(vio, vnet_port_match);
 436
 437 static struct vio_driver vnet_port_driver = {
 438         .id_table       = vnet_port_match,
 439         .probe          = vnet_port_probe,
 440         .remove         = vnet_port_remove,
 441         .name           = "vnet_port",
 442 };
 443
 444 static int __init vnet_init(void)
 445 {
 446         return vio_register_driver(&vnet_port_driver);
 447 }
 448
 449 static void __exit vnet_exit(void)
 450 {
 451         vio_unregister_driver(&vnet_port_driver);
 452         vnet_cleanup();
 453 }
 454
 455 module_init(vnet_init);
 456 module_exit(vnet_exit);