target/linux/generic-2.6/files/drivers/net/phy/swconfig.c

   1 /*
   2  * swconfig.c: Switch configuration API
   3  *
   4  * Copyright (C) 2008 Felix Fietkau <nbd@openwrt.org>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include <linux/types.h>
  18 #include <linux/module.h>
  19 #include <linux/init.h>
  20 #include <linux/list.h>
  21 #include <linux/if.h>
  22 #include <linux/if_ether.h>
  23 #include <linux/capability.h>
  24 #include <linux/skbuff.h>
  25 #include <linux/switch.h>
  26
  27 //#define DEBUG 1
  28 #ifdef DEBUG
  29 #define DPRINTF(format, ...) printk("%s: " format, __func__, ##__VA_ARGS__)
  30 #else
  31 #define DPRINTF(...) do {} while(0)
  32 #endif
  33
  34 MODULE_AUTHOR("Felix Fietkau <nbd@openwrt.org>");
  35 MODULE_LICENSE("GPL");
  36
  37 static int swdev_id = 0;
  38 static struct list_head swdevs;
  39 static spinlock_t swdevs_lock = SPIN_LOCK_UNLOCKED;
  40 struct swconfig_callback;
  41
  42 struct swconfig_callback
  43 {
  44         struct sk_buff *msg;
  45         struct genlmsghdr *hdr;
  46         struct genl_info *info;
  47         int cmd;
  48
  49         /* callback for filling in the message data */
  50         int (*fill)(struct swconfig_callback *cb, void *arg);
  51
  52         /* callback for closing the message before sending it */
  53         int (*close)(struct swconfig_callback *cb, void *arg);
  54
  55         struct nlattr *nest[4];
  56         int args[4];
  57 };
  58
  59 /* defaults */
  60
  61 static int
  62 swconfig_get_vlan_ports(struct switch_dev *dev, struct switch_attr *attr, struct switch_val *val)
  63 {
  64         int ret;
  65         if (val->port_vlan >= dev->vlans)
  66                 return -EINVAL;
  67
  68         if (!dev->get_vlan_ports)
  69                 return -EOPNOTSUPP;
  70
  71         ret = dev->get_vlan_ports(dev, val);
  72         printk("SET PORTS %d\n", val->len);
  73         return ret;
  74 }
  75
  76 static int
  77 swconfig_set_vlan_ports(struct switch_dev *dev, struct switch_attr *attr, struct switch_val *val)
  78 {
  79         int i;
  80
  81         if (val->port_vlan >= dev->vlans)
  82                 return -EINVAL;
  83
  84         /* validate ports */
  85         if (val->len > dev->ports)
  86                 return -EINVAL;
  87
  88         for (i = 0; i < val->len; i++) {
  89                 if (val->value.ports[i].id >= dev->ports)
  90                         return -EINVAL;
  91         }
  92
  93         if (!dev->set_vlan_ports)
  94                 return -EOPNOTSUPP;
  95
  96         printk("SET PORTS %d\n", val->len);
  97         return dev->set_vlan_ports(dev, val);
  98 }
  99
 100 static int
 101 swconfig_apply_config(struct switch_dev *dev, struct switch_attr *attr, struct switch_val *val)
 102 {
 103         /* don't complain if not supported by the switch driver */
 104         if (!dev->apply_config)
 105                 return 0;
 106
 107         return dev->apply_config(dev);
 108 }
 109
 110
 111 enum global_defaults {
 112         GLOBAL_APPLY,
 113 };
 114
 115 enum vlan_defaults {
 116         VLAN_PORTS,
 117 };
 118
 119 enum port_defaults {
 120         PORT_LINK,
 121 };
 122
 123 static struct switch_attr default_global[] = {
 124         [GLOBAL_APPLY] = {
 125                 .type = SWITCH_TYPE_NOVAL,
 126                 .name = "apply",
 127                 .description = "Activate changes in the hardware",
 128                 .set = swconfig_apply_config,
 129         }
 130 };
 131
 132 static struct switch_attr default_port[] = {
 133         [PORT_LINK] = {
 134                 .type = SWITCH_TYPE_INT,
 135                 .name = "link",
 136                 .description = "Current link speed",
 137         }
 138 };
 139
 140 static struct switch_attr default_vlan[] = {
 141         [VLAN_PORTS] = {
 142                 .type = SWITCH_TYPE_PORTS,
 143                 .name = "ports",
 144                 .description = "VLAN port mapping",
 145                 .set = swconfig_set_vlan_ports,
 146                 .get = swconfig_get_vlan_ports,
 147         },
 148 };
 149
 150
 151 static void swconfig_defaults_init(struct switch_dev *dev)
 152 {
 153         dev->def_global = 0;
 154         dev->def_vlan = 0;
 155         dev->def_port = 0;
 156
 157         if (dev->get_vlan_ports || dev->set_vlan_ports)
 158                 set_bit(VLAN_PORTS, &dev->def_vlan);
 159
 160         /* always present, can be no-op */
 161         set_bit(GLOBAL_APPLY, &dev->def_global);
 162 }
 163
 164
 165 static struct genl_family switch_fam = {
 166         .id = GENL_ID_GENERATE,
 167         .name = "switch",
 168         .hdrsize = 0,
 169         .version = 1,
 170         .maxattr = SWITCH_ATTR_MAX,
 171 };
 172
 173 static const struct nla_policy switch_policy[SWITCH_ATTR_MAX+1] = {
 174         [SWITCH_ATTR_ID] = { .type = NLA_U32 },
 175         [SWITCH_ATTR_OP_ID] = { .type = NLA_U32 },
 176         [SWITCH_ATTR_OP_PORT] = { .type = NLA_U32 },
 177         [SWITCH_ATTR_OP_VLAN] = { .type = NLA_U32 },
 178         [SWITCH_ATTR_OP_VALUE_INT] = { .type = NLA_U32 },
 179         [SWITCH_ATTR_OP_VALUE_STR] = { .type = NLA_NUL_STRING },
 180         [SWITCH_ATTR_OP_VALUE_PORTS] = { .type = NLA_NESTED },
 181         [SWITCH_ATTR_TYPE] = { .type = NLA_U32 },
 182 };
 183
 184 static const struct nla_policy port_policy[SWITCH_PORT_ATTR_MAX+1] = {
 185         [SWITCH_PORT_ID] = { .type = NLA_U32 },
 186         [SWITCH_PORT_FLAG_TAGGED] = { .type = NLA_FLAG },
 187 };
 188
 189 static inline void
 190 swconfig_lock(void)
 191 {
 192         spin_lock(&swdevs_lock);
 193 }
 194
 195 static inline void
 196 swconfig_unlock(void)
 197 {
 198         spin_unlock(&swdevs_lock);
 199 }
 200
 201 static struct switch_dev *
 202 swconfig_get_dev(struct genl_info *info)
 203 {
 204         struct switch_dev *dev = NULL;
 205         struct switch_dev *p;
 206         int id;
 207
 208         if (!info->attrs[SWITCH_ATTR_ID])
 209                 goto done;
 210
 211         id = nla_get_u32(info->attrs[SWITCH_ATTR_ID]);
 212         swconfig_lock();
 213         list_for_each_entry(p, &swdevs, dev_list) {
 214                 if (id != p->id)
 215                         continue;
 216
 217                 dev = p;
 218                 break;
 219         }
 220         if (dev)
 221                 spin_lock(&dev->lock);
 222         else
 223                 DPRINTF("device %d not found\n", id);
 224         swconfig_unlock();
 225 done:
 226         return dev;
 227 }
 228
 229 static inline void
 230 swconfig_put_dev(struct switch_dev *dev)
 231 {
 232         spin_unlock(&dev->lock);
 233 }
 234
 235 static int
 236 swconfig_dump_attr(struct swconfig_callback *cb, void *arg)
 237 {
 238         struct switch_attr *op = arg;
 239         struct genl_info *info = cb->info;
 240         struct sk_buff *msg = cb->msg;
 241         int id = cb->args[0];
 242         void *hdr;
 243
 244         hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq, &switch_fam,
 245                         NLM_F_MULTI, SWITCH_CMD_NEW_ATTR);
 246         if (IS_ERR(hdr))
 247                 return -1;
 248
 249         NLA_PUT_U32(msg, SWITCH_ATTR_OP_ID, id);
 250         NLA_PUT_U32(msg, SWITCH_ATTR_OP_TYPE, op->type);
 251         NLA_PUT_STRING(msg, SWITCH_ATTR_OP_NAME, op->name);
 252         if (op->description)
 253                 NLA_PUT_STRING(msg, SWITCH_ATTR_OP_DESCRIPTION,
 254                         op->description);
 255
 256         return genlmsg_end(msg, hdr);
 257 nla_put_failure:
 258         genlmsg_cancel(msg, hdr);
 259         return -EMSGSIZE;
 260 }
 261
 262 /* spread multipart messages across multiple message buffers */
 263 static int
 264 swconfig_send_multipart(struct swconfig_callback *cb, void *arg)
 265 {
 266         struct genl_info *info = cb->info;
 267         int restart = 0;
 268         int err;
 269
 270         do {
 271                 if (!cb->msg) {
 272                         cb->msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 273                         if (cb->msg == NULL)
 274                                 goto error;
 275                 }
 276
 277                 if (!(cb->fill(cb, arg) < 0))
 278                         break;
 279
 280                 /* fill failed, check if this was already the second attempt */
 281                 if (restart)
 282                         goto error;
 283
 284                 /* try again in a new message, send the current one */
 285                 restart = 1;
 286                 if (cb->close) {
 287                         if (cb->close(cb, arg) < 0)
 288                                 goto error;
 289                 }
 290                 err = genlmsg_unicast(cb->msg, info->snd_pid);
 291                 cb->msg = NULL;
 292                 if (err < 0)
 293                         goto error;
 294
 295         } while (restart);
 296
 297         return 0;
 298
 299 error:
 300         if (cb->msg)
 301                 nlmsg_free(cb->msg);
 302         return -1;
 303 }
 304
 305 static int
 306 swconfig_list_attrs(struct sk_buff *skb, struct genl_info *info)
 307 {
 308         struct genlmsghdr *hdr = nlmsg_data(info->nlhdr);
 309         const struct switch_attrlist *alist;
 310         struct switch_dev *dev;
 311         struct swconfig_callback cb;
 312         int err = -EINVAL;
 313         int i;
 314
 315         /* defaults */
 316         struct switch_attr *def_list;
 317         unsigned long *def_active;
 318         int n_def;
 319
 320         dev = swconfig_get_dev(info);
 321         if (!dev)
 322                 return -EINVAL;
 323
 324         switch(hdr->cmd) {
 325         case SWITCH_CMD_LIST_GLOBAL:
 326                 alist = &dev->attr_global;
 327                 def_list = default_global;
 328                 def_active = &dev->def_global;
 329                 n_def = ARRAY_SIZE(default_global);
 330                 break;
 331         case SWITCH_CMD_LIST_VLAN:
 332                 alist = &dev->attr_vlan;
 333                 def_list = default_vlan;
 334                 def_active = &dev->def_vlan;
 335                 n_def = ARRAY_SIZE(default_vlan);
 336                 break;
 337         case SWITCH_CMD_LIST_PORT:
 338                 alist = &dev->attr_port;
 339                 def_list = default_port;
 340                 def_active = &dev->def_port;
 341                 n_def = ARRAY_SIZE(default_port);
 342                 break;
 343         default:
 344                 WARN_ON(1);
 345                 goto out;
 346         }
 347
 348         memset(&cb, 0, sizeof(cb));
 349         cb.info = info;
 350         cb.fill = swconfig_dump_attr;
 351         for (i = 0; i < alist->n_attr; i++) {
 352                 if (alist->attr[i].disabled)
 353                         continue;
 354                 cb.args[0] = i;
 355                 err = swconfig_send_multipart(&cb, &alist->attr[i]);
 356                 if (err < 0)
 357                         goto error;
 358         }
 359
 360         /* defaults */
 361         for (i = 0; i < n_def; i++) {
 362                 if (!test_bit(i, def_active))
 363                         continue;
 364                 cb.args[0] = SWITCH_ATTR_DEFAULTS_OFFSET + i;
 365                 err = swconfig_send_multipart(&cb, &def_list[i]);
 366                 if (err < 0)
 367                         goto error;
 368         }
 369         swconfig_put_dev(dev);
 370
 371         if (!cb.msg)
 372                 return 0;
 373
 374         return genlmsg_unicast(cb.msg, info->snd_pid);
 375
 376 error:
 377         if (cb.msg)
 378                 nlmsg_free(cb.msg);
 379 out:
 380         swconfig_put_dev(dev);
 381         return err;
 382 }
 383
 384 static struct switch_attr *
 385 swconfig_lookup_attr(struct switch_dev *dev, struct genl_info *info,
 386                 struct switch_val *val)
 387 {
 388         struct genlmsghdr *hdr = nlmsg_data(info->nlhdr);
 389         const struct switch_attrlist *alist;
 390         struct switch_attr *attr = NULL;
 391         int attr_id;
 392
 393         /* defaults */
 394         struct switch_attr *def_list;
 395         unsigned long *def_active;
 396         int n_def;
 397
 398         if (!info->attrs[SWITCH_ATTR_OP_ID])
 399                 goto done;
 400
 401         switch(hdr->cmd) {
 402         case SWITCH_CMD_SET_GLOBAL:
 403         case SWITCH_CMD_GET_GLOBAL:
 404                 alist = &dev->attr_global;
 405                 def_list = default_global;
 406                 def_active = &dev->def_global;
 407                 n_def = ARRAY_SIZE(default_global);
 408                 break;
 409         case SWITCH_CMD_SET_VLAN:
 410         case SWITCH_CMD_GET_VLAN:
 411                 alist = &dev->attr_vlan;
 412                 def_list = default_vlan;
 413                 def_active = &dev->def_vlan;
 414                 n_def = ARRAY_SIZE(default_vlan);
 415                 if (!info->attrs[SWITCH_ATTR_OP_VLAN])
 416                         goto done;
 417                 val->port_vlan = nla_get_u32(info->attrs[SWITCH_ATTR_OP_VLAN]);
 418                 break;
 419         case SWITCH_CMD_SET_PORT:
 420         case SWITCH_CMD_GET_PORT:
 421                 alist = &dev->attr_port;
 422                 def_list = default_port;
 423                 def_active = &dev->def_port;
 424                 n_def = ARRAY_SIZE(default_port);
 425                 if (!info->attrs[SWITCH_ATTR_OP_PORT])
 426                         goto done;
 427                 val->port_vlan = nla_get_u32(info->attrs[SWITCH_ATTR_OP_PORT]);
 428                 break;
 429         default:
 430                 WARN_ON(1);
 431                 goto done;
 432         }
 433
 434         if (!alist)
 435                 goto done;
 436
 437         attr_id = nla_get_u32(info->attrs[SWITCH_ATTR_OP_ID]);
 438         if (attr_id >= SWITCH_ATTR_DEFAULTS_OFFSET) {
 439                 attr_id -= SWITCH_ATTR_DEFAULTS_OFFSET;
 440                 if (attr_id >= n_def)
 441                         goto done;
 442                 if (!test_bit(attr_id, def_active))
 443                         goto done;
 444                 attr = &def_list[attr_id];
 445         } else {
 446                 if (attr_id >= alist->n_attr)
 447                         goto done;
 448                 attr = &alist->attr[attr_id];
 449         }
 450
 451         if (attr->disabled)
 452                 attr = NULL;
 453
 454 done:
 455         if (!attr)
 456                 DPRINTF("attribute lookup failed\n");
 457         val->attr = attr;
 458         return attr;
 459 }
 460
 461 static int
 462 swconfig_parse_ports(struct sk_buff *msg, struct nlattr *head,
 463                 struct switch_val *val, int max)
 464 {
 465         struct nlattr *nla;
 466         int rem;
 467
 468         val->len = 0;
 469         nla_for_each_nested(nla, head, rem) {
 470                 struct nlattr *tb[SWITCH_PORT_ATTR_MAX+1];
 471                 struct switch_port *port = &val->value.ports[val->len];
 472
 473                 if (val->len >= max)
 474                         return -EINVAL;
 475
 476                 if (nla_parse_nested(tb, SWITCH_PORT_ATTR_MAX, nla,
 477                                 port_policy))
 478                         return -EINVAL;
 479
 480                 if (!tb[SWITCH_PORT_ID])
 481                         return -EINVAL;
 482
 483                 port->id = nla_get_u32(tb[SWITCH_PORT_ID]);
 484                 if (tb[SWITCH_PORT_FLAG_TAGGED])
 485                         port->flags |= (1 << SWITCH_PORT_FLAG_TAGGED);
 486                 val->len++;
 487         }
 488
 489         return 0;
 490 }
 491
 492 static int
 493 swconfig_set_attr(struct sk_buff *skb, struct genl_info *info)
 494 {
 495         struct switch_attr *attr;
 496         struct switch_dev *dev;
 497         struct switch_val val;
 498         int err = -EINVAL;
 499
 500         dev = swconfig_get_dev(info);
 501         if (!dev)
 502                 return -EINVAL;
 503
 504         memset(&val, 0, sizeof(val));
 505         attr = swconfig_lookup_attr(dev, info, &val);
 506         if (!attr || !attr->set)
 507                 goto error;
 508
 509         val.attr = attr;
 510         switch(attr->type) {
 511         case SWITCH_TYPE_NOVAL:
 512                 break;
 513         case SWITCH_TYPE_INT:
 514                 if (!info->attrs[SWITCH_ATTR_OP_VALUE_INT])
 515                         goto error;
 516                 val.value.i =
 517                         nla_get_u32(info->attrs[SWITCH_ATTR_OP_VALUE_INT]);
 518                 break;
 519         case SWITCH_TYPE_STRING:
 520                 if (!info->attrs[SWITCH_ATTR_OP_VALUE_STR])
 521                         goto error;
 522                 val.value.s =
 523                         nla_data(info->attrs[SWITCH_ATTR_OP_VALUE_STR]);
 524                 break;
 525         case SWITCH_TYPE_PORTS:
 526                 val.value.ports = dev->portbuf;
 527                 memset(dev->portbuf, 0,
 528                         sizeof(struct switch_port) * dev->ports);
 529
 530                 /* TODO: implement multipart? */
 531                 if (info->attrs[SWITCH_ATTR_OP_VALUE_PORTS]) {
 532                         err = swconfig_parse_ports(skb,
 533                                 info->attrs[SWITCH_ATTR_OP_VALUE_PORTS], &val, dev->ports);
 534                         if (err < 0)
 535                                 goto error;
 536                 } else {
 537                         val.len = 0;
 538                         err = 0;
 539                 }
 540                 break;
 541         default:
 542                 goto error;
 543         }
 544
 545         err = attr->set(dev, attr, &val);
 546 error:
 547         swconfig_put_dev(dev);
 548         return err;
 549 }
 550
 551 static int
 552 swconfig_close_portlist(struct swconfig_callback *cb, void *arg)
 553 {
 554         if (cb->nest[0])
 555                 nla_nest_end(cb->msg, cb->nest[0]);
 556         return 0;
 557 }
 558
 559 static int
 560 swconfig_send_port(struct swconfig_callback *cb, void *arg)
 561 {
 562         const struct switch_port *port = arg;
 563         struct nlattr *p = NULL;
 564
 565         if (!cb->nest[0]) {
 566                 cb->nest[0] = nla_nest_start(cb->msg, cb->cmd);
 567                 if (!cb->nest[0])
 568                         return -1;
 569         }
 570
 571         p = nla_nest_start(cb->msg, SWITCH_ATTR_PORT);
 572         if (!p)
 573                 goto error;
 574
 575         NLA_PUT_U32(cb->msg, SWITCH_PORT_ID, port->id);
 576         if (port->flags & (1 << SWITCH_PORT_FLAG_TAGGED))
 577                 NLA_PUT_FLAG(cb->msg, SWITCH_PORT_FLAG_TAGGED);
 578
 579         nla_nest_end(cb->msg, p);
 580         return 0;
 581
 582 nla_put_failure:
 583                 nla_nest_cancel(cb->msg, p);
 584 error:
 585         nla_nest_cancel(cb->msg, cb->nest[0]);
 586         return -1;
 587 }
 588
 589 static int
 590 swconfig_send_ports(struct sk_buff **msg, struct genl_info *info, int attr,
 591                 const struct switch_val *val)
 592 {
 593         struct swconfig_callback cb;
 594         int err = 0;
 595         int i;
 596
 597         if (!val->value.ports)
 598                 return -EINVAL;
 599
 600         memset(&cb, 0, sizeof(cb));
 601         cb.cmd = attr;
 602         cb.msg = *msg;
 603         cb.info = info;
 604         cb.fill = swconfig_send_port;
 605         cb.close = swconfig_close_portlist;
 606
 607         cb.nest[0] = nla_nest_start(cb.msg, cb.cmd);
 608         for (i = 0; i < val->len; i++) {
 609                 err = swconfig_send_multipart(&cb, &val->value.ports[i]);
 610                 if (err)
 611                         goto done;
 612         }
 613         err = val->len;
 614         swconfig_close_portlist(&cb, NULL);
 615         *msg = cb.msg;
 616
 617 done:
 618         return err;
 619 }
 620
 621 static int
 622 swconfig_get_attr(struct sk_buff *skb, struct genl_info *info)
 623 {
 624         struct genlmsghdr *hdr = nlmsg_data(info->nlhdr);
 625         struct switch_attr *attr;
 626         struct switch_dev *dev;
 627         struct sk_buff *msg = NULL;
 628         struct switch_val val;
 629         int err = -EINVAL;
 630         int cmd = hdr->cmd;
 631
 632         dev = swconfig_get_dev(info);
 633         if (!dev)
 634                 return -EINVAL;
 635
 636         memset(&val, 0, sizeof(val));
 637         attr = swconfig_lookup_attr(dev, info, &val);
 638         if (!attr || !attr->get)
 639                 goto error_dev;
 640
 641         if (attr->type == SWITCH_TYPE_PORTS) {
 642                 val.value.ports = dev->portbuf;
 643                 memset(dev->portbuf, 0,
 644                         sizeof(struct switch_port) * dev->ports);
 645         }
 646
 647         err = attr->get(dev, attr, &val);
 648         if (err)
 649                 goto error;
 650
 651         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 652         if (!msg)
 653                 goto error;
 654
 655         hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq, &switch_fam,
 656                         0, cmd);
 657         if (IS_ERR(hdr))
 658                 goto nla_put_failure;
 659
 660         switch(attr->type) {
 661         case SWITCH_TYPE_INT:
 662                 NLA_PUT_U32(msg, SWITCH_ATTR_OP_VALUE_INT, val.value.i);
 663                 break;
 664         case SWITCH_TYPE_STRING:
 665                 NLA_PUT_STRING(msg, SWITCH_ATTR_OP_VALUE_STR, val.value.s);
 666                 break;
 667         case SWITCH_TYPE_PORTS:
 668                 err = swconfig_send_ports(&msg, info,
 669                                 SWITCH_ATTR_OP_VALUE_PORTS, &val);
 670                 if (err < 0)
 671                         goto nla_put_failure;
 672                 break;
 673         default:
 674                 DPRINTF("invalid type in attribute\n");
 675                 err = -EINVAL;
 676                 goto error;
 677         }
 678         err = genlmsg_end(msg, hdr);
 679         if (err < 0)
 680                 goto nla_put_failure;
 681
 682         swconfig_put_dev(dev);
 683         return genlmsg_unicast(msg, info->snd_pid);
 684
 685 nla_put_failure:
 686         if (msg)
 687                 nlmsg_free(msg);
 688 error_dev:
 689         swconfig_put_dev(dev);
 690 error:
 691         if (!err)
 692                 err = -ENOMEM;
 693         return err;
 694 }
 695
 696 static int
 697 swconfig_send_switch(struct sk_buff *msg, u32 pid, u32 seq, int flags,
 698                 const struct switch_dev *dev)
 699 {
 700         void *hdr;
 701
 702         hdr = genlmsg_put(msg, pid, seq, &switch_fam, flags,
 703                         SWITCH_CMD_NEW_ATTR);
 704         if (IS_ERR(hdr))
 705                 return -1;
 706
 707         NLA_PUT_U32(msg, SWITCH_ATTR_ID, dev->id);
 708         NLA_PUT_STRING(msg, SWITCH_ATTR_NAME, dev->name);
 709         NLA_PUT_STRING(msg, SWITCH_ATTR_DEV_NAME, dev->devname);
 710         NLA_PUT_U32(msg, SWITCH_ATTR_VLANS, dev->vlans);
 711         NLA_PUT_U32(msg, SWITCH_ATTR_PORTS, dev->ports);
 712
 713         return genlmsg_end(msg, hdr);
 714 nla_put_failure:
 715         genlmsg_cancel(msg, hdr);
 716         return -EMSGSIZE;
 717 }
 718
 719 static int swconfig_dump_switches(struct sk_buff *skb,
 720                 struct netlink_callback *cb)
 721 {
 722         struct switch_dev *dev;
 723         int start = cb->args[0];
 724         int idx = 0;
 725
 726         swconfig_lock();
 727         list_for_each_entry(dev, &swdevs, dev_list) {
 728                 if (++idx <= start)
 729                         continue;
 730                 if (swconfig_send_switch(skb, NETLINK_CB(cb->skb).pid,
 731                                 cb->nlh->nlmsg_seq, NLM_F_MULTI,
 732                                 dev) < 0)
 733                         break;
 734         }
 735         swconfig_unlock();
 736         cb->args[0] = idx;
 737
 738         return skb->len;
 739 }
 740
 741 static int
 742 swconfig_done(struct netlink_callback *cb)
 743 {
 744         return 0;
 745 }
 746
 747 static struct genl_ops swconfig_ops[] = {
 748         {
 749                 .cmd = SWITCH_CMD_LIST_GLOBAL,
 750                 .doit = swconfig_list_attrs,
 751                 .policy = switch_policy,
 752         },
 753         {
 754                 .cmd = SWITCH_CMD_LIST_VLAN,
 755                 .doit = swconfig_list_attrs,
 756                 .policy = switch_policy,
 757         },
 758         {
 759                 .cmd = SWITCH_CMD_LIST_PORT,
 760                 .doit = swconfig_list_attrs,
 761                 .policy = switch_policy,
 762         },
 763         {
 764                 .cmd = SWITCH_CMD_GET_GLOBAL,
 765                 .doit = swconfig_get_attr,
 766                 .policy = switch_policy,
 767         },
 768         {
 769                 .cmd = SWITCH_CMD_GET_VLAN,
 770                 .doit = swconfig_get_attr,
 771                 .policy = switch_policy,
 772         },
 773         {
 774                 .cmd = SWITCH_CMD_GET_PORT,
 775                 .doit = swconfig_get_attr,
 776                 .policy = switch_policy,
 777         },
 778         {
 779                 .cmd = SWITCH_CMD_SET_GLOBAL,
 780                 .doit = swconfig_set_attr,
 781                 .policy = switch_policy,
 782         },
 783         {
 784                 .cmd = SWITCH_CMD_SET_VLAN,
 785                 .doit = swconfig_set_attr,
 786                 .policy = switch_policy,
 787         },
 788         {
 789                 .cmd = SWITCH_CMD_SET_PORT,
 790                 .doit = swconfig_set_attr,
 791                 .policy = switch_policy,
 792         },
 793         {
 794                 .cmd = SWITCH_CMD_GET_SWITCH,
 795                 .dumpit = swconfig_dump_switches,
 796                 .policy = switch_policy,
 797                 .done = swconfig_done,
 798         }
 799 };
 800
 801 int
 802 register_switch(struct switch_dev *dev, struct net_device *netdev)
 803 {
 804         INIT_LIST_HEAD(&dev->dev_list);
 805         if (netdev) {
 806                 dev->netdev = netdev;
 807                 if (!dev->devname)
 808                         dev->devname = netdev->name;
 809         }
 810         BUG_ON(!dev->devname);
 811
 812         if (dev->ports > 0) {
 813                 dev->portbuf = kzalloc(sizeof(struct switch_port) * dev->ports,
 814                                 GFP_KERNEL);
 815                 if (!dev->portbuf)
 816                         return -ENOMEM;
 817         }
 818         dev->id = ++swdev_id;
 819         swconfig_defaults_init(dev);
 820         spin_lock_init(&dev->lock);
 821         swconfig_lock();
 822         list_add(&dev->dev_list, &swdevs);
 823         swconfig_unlock();
 824
 825         return 0;
 826 }
 827 EXPORT_SYMBOL_GPL(register_switch);
 828
 829 void
 830 unregister_switch(struct switch_dev *dev)
 831 {
 832         kfree(dev->portbuf);
 833         spin_lock(&dev->lock);
 834         swconfig_lock();
 835         list_del(&dev->dev_list);
 836         swconfig_unlock();
 837 }
 838 EXPORT_SYMBOL_GPL(unregister_switch);
 839
 840
 841 static int __init
 842 swconfig_init(void)
 843 {
 844         int i, err;
 845
 846         INIT_LIST_HEAD(&swdevs);
 847         err = genl_register_family(&switch_fam);
 848         if (err)
 849                 return err;
 850
 851         for (i = 0; i < ARRAY_SIZE(swconfig_ops); i++) {
 852                 err = genl_register_ops(&switch_fam, &swconfig_ops[i]);
 853                 if (err)
 854                         goto unregister;
 855         }
 856
 857         return 0;
 858
 859 unregister:
 860         genl_unregister_family(&switch_fam);
 861         return err;
 862 }
 863
 864 static void __exit
 865 swconfig_exit(void)
 866 {
 867         genl_unregister_family(&switch_fam);
 868 }
 869
 870 module_init(swconfig_init);
 871 module_exit(swconfig_exit);
 872