net/dsa/dsa.c

   1 /*
   2  * net/dsa/dsa.c - Hardware switch handling
   3  * Copyright (c) 2008 Marvell Semiconductor
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  */
  10
  11 #include <linux/list.h>
  12 #include <linux/netdevice.h>
  13 #include <linux/platform_device.h>
  14 #include <net/dsa.h>
  15 #include "dsa_priv.h"
  16
  17 char dsa_driver_version[] = "0.1";
  18
  19
  20 /* switch driver registration ***********************************************/
  21 static DEFINE_MUTEX(dsa_switch_drivers_mutex);
  22 static LIST_HEAD(dsa_switch_drivers);
  23
  24 void register_switch_driver(struct dsa_switch_driver *drv)
  25 {
  26         mutex_lock(&dsa_switch_drivers_mutex);
  27         list_add_tail(&drv->list, &dsa_switch_drivers);
  28         mutex_unlock(&dsa_switch_drivers_mutex);
  29 }
  30
  31 void unregister_switch_driver(struct dsa_switch_driver *drv)
  32 {
  33         mutex_lock(&dsa_switch_drivers_mutex);
  34         list_del_init(&drv->list);
  35         mutex_unlock(&dsa_switch_drivers_mutex);
  36 }
  37
  38 static struct dsa_switch_driver *
  39 dsa_switch_probe(struct mii_bus *bus, int sw_addr, char **_name)
  40 {
  41         struct dsa_switch_driver *ret;
  42         struct list_head *list;
  43         char *name;
  44
  45         ret = NULL;
  46         name = NULL;
  47
  48         mutex_lock(&dsa_switch_drivers_mutex);
  49         list_for_each(list, &dsa_switch_drivers) {
  50                 struct dsa_switch_driver *drv;
  51
  52                 drv = list_entry(list, struct dsa_switch_driver, list);
  53
  54                 name = drv->probe(bus, sw_addr);
  55                 if (name != NULL) {
  56                         ret = drv;
  57                         break;
  58                 }
  59         }
  60         mutex_unlock(&dsa_switch_drivers_mutex);
  61
  62         *_name = name;
  63
  64         return ret;
  65 }
  66
  67
  68 /* basic switch operations **************************************************/
  69 static struct dsa_switch *
  70 dsa_switch_setup(struct device *parent, struct dsa_platform_data *pd,
  71                  struct mii_bus *bus, struct net_device *dev)
  72 {
  73         struct dsa_switch *ds;
  74         int ret;
  75         struct dsa_switch_driver *drv;
  76         char *name;
  77         int i;
  78
  79         /*
  80          * Probe for switch model.
  81          */
  82         drv = dsa_switch_probe(bus, pd->sw_addr, &name);
  83         if (drv == NULL) {
  84                 printk(KERN_ERR "%s: could not detect attached switch\n",
  85                        dev->name);
  86                 return ERR_PTR(-EINVAL);
  87         }
  88         printk(KERN_INFO "%s: detected a %s switch\n", dev->name, name);
  89
  90
  91         /*
  92          * Allocate and initialise switch state.
  93          */
  94         ds = kzalloc(sizeof(*ds) + drv->priv_size, GFP_KERNEL);
  95         if (ds == NULL)
  96                 return ERR_PTR(-ENOMEM);
  97
  98         ds->pd = pd;
  99         ds->master_netdev = dev;
 100         ds->master_mii_bus = bus;
 101
 102         ds->drv = drv;
 103         ds->tag_protocol = drv->tag_protocol;
 104
 105
 106         /*
 107          * Validate supplied switch configuration.
 108          */
 109         ds->cpu_port = -1;
 110         for (i = 0; i < DSA_MAX_PORTS; i++) {
 111                 char *name;
 112
 113                 name = pd->port_names[i];
 114                 if (name == NULL)
 115                         continue;
 116
 117                 if (!strcmp(name, "cpu")) {
 118                         if (ds->cpu_port != -1) {
 119                                 printk(KERN_ERR "multiple cpu ports?!\n");
 120                                 ret = -EINVAL;
 121                                 goto out;
 122                         }
 123                         ds->cpu_port = i;
 124                 } else {
 125                         ds->valid_port_mask |= 1 << i;
 126                 }
 127         }
 128
 129         if (ds->cpu_port == -1) {
 130                 printk(KERN_ERR "no cpu port?!\n");
 131                 ret = -EINVAL;
 132                 goto out;
 133         }
 134
 135
 136         /*
 137          * If we use a tagging format that doesn't have an ethertype
 138          * field, make sure that all packets from this point on get
 139          * sent to the tag format's receive function.  (Which will
 140          * discard received packets until we set ds->ports[] below.)
 141          */
 142         wmb();
 143         dev->dsa_ptr = (void *)ds;
 144
 145
 146         /*
 147          * Do basic register setup.
 148          */
 149         ret = drv->setup(ds);
 150         if (ret < 0)
 151                 goto out;
 152
 153         ret = drv->set_addr(ds, dev->dev_addr);
 154         if (ret < 0)
 155                 goto out;
 156
 157         ds->slave_mii_bus = mdiobus_alloc();
 158         if (ds->slave_mii_bus == NULL) {
 159                 ret = -ENOMEM;
 160                 goto out;
 161         }
 162         dsa_slave_mii_bus_init(ds);
 163
 164         ret = mdiobus_register(ds->slave_mii_bus);
 165         if (ret < 0)
 166                 goto out_free;
 167
 168
 169         /*
 170          * Create network devices for physical switch ports.
 171          */
 172         wmb();
 173         for (i = 0; i < DSA_MAX_PORTS; i++) {
 174                 struct net_device *slave_dev;
 175
 176                 if (!(ds->valid_port_mask & (1 << i)))
 177                         continue;
 178
 179                 slave_dev = dsa_slave_create(ds, parent, i, pd->port_names[i]);
 180                 if (slave_dev == NULL) {
 181                         printk(KERN_ERR "%s: can't create dsa slave "
 182                                "device for port %d(%s)\n",
 183                                dev->name, i, pd->port_names[i]);
 184                         continue;
 185                 }
 186
 187                 ds->ports[i] = slave_dev;
 188         }
 189
 190         return ds;
 191
 192 out_free:
 193         mdiobus_free(ds->slave_mii_bus);
 194 out:
 195         dev->dsa_ptr = NULL;
 196         kfree(ds);
 197         return ERR_PTR(ret);
 198 }
 199
 200 static void dsa_switch_destroy(struct dsa_switch *ds)
 201 {
 202 }
 203
 204
 205 /* hooks for ethertype-less tagging formats *********************************/
 206 /*
 207  * The original DSA tag format and some other tag formats have no
 208  * ethertype, which means that we need to add a little hack to the
 209  * networking receive path to make sure that received frames get
 210  * the right ->protocol assigned to them when one of those tag
 211  * formats is in use.
 212  */
 213 bool dsa_uses_dsa_tags(void *dsa_ptr)
 214 {
 215         struct dsa_switch *ds = dsa_ptr;
 216
 217         return !!(ds->tag_protocol == htons(ETH_P_DSA));
 218 }
 219
 220 bool dsa_uses_trailer_tags(void *dsa_ptr)
 221 {
 222         struct dsa_switch *ds = dsa_ptr;
 223
 224         return !!(ds->tag_protocol == htons(ETH_P_TRAILER));
 225 }
 226
 227
 228 /* link polling *************************************************************/
 229 static void dsa_link_poll_work(struct work_struct *ugly)
 230 {
 231         struct dsa_switch *ds;
 232
 233         ds = container_of(ugly, struct dsa_switch, link_poll_work);
 234
 235         ds->drv->poll_link(ds);
 236         mod_timer(&ds->link_poll_timer, round_jiffies(jiffies + HZ));
 237 }
 238
 239 static void dsa_link_poll_timer(unsigned long _ds)
 240 {
 241         struct dsa_switch *ds = (void *)_ds;
 242
 243         schedule_work(&ds->link_poll_work);
 244 }
 245
 246
 247 /* platform driver init and cleanup *****************************************/
 248 static int dev_is_class(struct device *dev, void *class)
 249 {
 250         if (dev->class != NULL && !strcmp(dev->class->name, class))
 251                 return 1;
 252
 253         return 0;
 254 }
 255
 256 static struct device *dev_find_class(struct device *parent, char *class)
 257 {
 258         if (dev_is_class(parent, class)) {
 259                 get_device(parent);
 260                 return parent;
 261         }
 262
 263         return device_find_child(parent, class, dev_is_class);
 264 }
 265
 266 static struct mii_bus *dev_to_mii_bus(struct device *dev)
 267 {
 268         struct device *d;
 269
 270         d = dev_find_class(dev, "mdio_bus");
 271         if (d != NULL) {
 272                 struct mii_bus *bus;
 273
 274                 bus = to_mii_bus(d);
 275                 put_device(d);
 276
 277                 return bus;
 278         }
 279
 280         return NULL;
 281 }
 282
 283 static struct net_device *dev_to_net_device(struct device *dev)
 284 {
 285         struct device *d;
 286
 287         d = dev_find_class(dev, "net");
 288         if (d != NULL) {
 289                 struct net_device *nd;
 290
 291                 nd = to_net_dev(d);
 292                 dev_hold(nd);
 293                 put_device(d);
 294
 295                 return nd;
 296         }
 297
 298         return NULL;
 299 }
 300
 301 static int dsa_probe(struct platform_device *pdev)
 302 {
 303         static int dsa_version_printed;
 304         struct dsa_platform_data *pd = pdev->dev.platform_data;
 305         struct net_device *dev;
 306         struct mii_bus *bus;
 307         struct dsa_switch *ds;
 308
 309         if (!dsa_version_printed++)
 310                 printk(KERN_NOTICE "Distributed Switch Architecture "
 311                         "driver version %s\n", dsa_driver_version);
 312
 313         if (pd == NULL || pd->mii_bus == NULL || pd->netdev == NULL)
 314                 return -EINVAL;
 315
 316         bus = dev_to_mii_bus(pd->mii_bus);
 317         if (bus == NULL)
 318                 return -EINVAL;
 319
 320         dev = dev_to_net_device(pd->netdev);
 321         if (dev == NULL)
 322                 return -EINVAL;
 323
 324         if (dev->dsa_ptr != NULL) {
 325                 dev_put(dev);
 326                 return -EEXIST;
 327         }
 328
 329         ds = dsa_switch_setup(&pdev->dev, pd, bus, dev);
 330         if (IS_ERR(ds)) {
 331                 dev_put(dev);
 332                 return PTR_ERR(ds);
 333         }
 334
 335         if (ds->drv->poll_link != NULL) {
 336                 INIT_WORK(&ds->link_poll_work, dsa_link_poll_work);
 337                 init_timer(&ds->link_poll_timer);
 338                 ds->link_poll_timer.data = (unsigned long)ds;
 339                 ds->link_poll_timer.function = dsa_link_poll_timer;
 340                 ds->link_poll_timer.expires = round_jiffies(jiffies + HZ);
 341                 add_timer(&ds->link_poll_timer);
 342         }
 343
 344         platform_set_drvdata(pdev, ds);
 345
 346         return 0;
 347 }
 348
 349 static int dsa_remove(struct platform_device *pdev)
 350 {
 351         struct dsa_switch *ds = platform_get_drvdata(pdev);
 352
 353         if (ds->drv->poll_link != NULL)
 354                 del_timer_sync(&ds->link_poll_timer);
 355
 356         flush_scheduled_work();
 357
 358         dsa_switch_destroy(ds);
 359
 360         return 0;
 361 }
 362
 363 static void dsa_shutdown(struct platform_device *pdev)
 364 {
 365 }
 366
 367 static struct platform_driver dsa_driver = {
 368         .probe          = dsa_probe,
 369         .remove         = dsa_remove,
 370         .shutdown       = dsa_shutdown,
 371         .driver = {
 372                 .name   = "dsa",
 373                 .owner  = THIS_MODULE,
 374         },
 375 };
 376
 377 static int __init dsa_init_module(void)
 378 {
 379         return platform_driver_register(&dsa_driver);
 380 }
 381 module_init(dsa_init_module);
 382
 383 static void __exit dsa_cleanup_module(void)
 384 {
 385         platform_driver_unregister(&dsa_driver);
 386 }
 387 module_exit(dsa_cleanup_module);
 388
 389 MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>")
 390 MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
 391 MODULE_LICENSE("GPL");
 392 MODULE_ALIAS("platform:dsa");