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"); 393