net/ieee802154/nl-mac.c

   1 /*
   2  * Netlink inteface for IEEE 802.15.4 stack
   3  *
   4  * Copyright 2007, 2008 Siemens AG
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Written by:
  20  * Sergey Lapin <slapin@ossfans.org>
  21  * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
  22  * Maxim Osipov <maxim.osipov@siemens.com>
  23  */
  24
  25 #include <linux/kernel.h>
  26 #include <linux/if_arp.h>
  27 #include <linux/netdevice.h>
  28 #include <net/netlink.h>
  29 #include <net/genetlink.h>
  30 #include <net/sock.h>
  31 #include <linux/nl802154.h>
  32 #include <net/af_ieee802154.h>
  33 #include <net/nl802154.h>
  34 #include <net/ieee802154.h>
  35 #include <net/ieee802154_netdev.h>
  36
  37 #include "ieee802154.h"
  38
  39 static struct genl_multicast_group ieee802154_coord_mcgrp = {
  40         .name           = IEEE802154_MCAST_COORD_NAME,
  41 };
  42
  43 static struct genl_multicast_group ieee802154_beacon_mcgrp = {
  44         .name           = IEEE802154_MCAST_BEACON_NAME,
  45 };
  46
  47 int ieee802154_nl_assoc_indic(struct net_device *dev,
  48                 struct ieee802154_addr *addr, u8 cap)
  49 {
  50         struct sk_buff *msg;
  51
  52         pr_debug("%s\n", __func__);
  53
  54         if (addr->addr_type != IEEE802154_ADDR_LONG) {
  55                 pr_err("%s: received non-long source address!\n", __func__);
  56                 return -EINVAL;
  57         }
  58
  59         msg = ieee802154_nl_create(0, IEEE802154_ASSOCIATE_INDIC);
  60         if (!msg)
  61                 return -ENOBUFS;
  62
  63         NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
  64         NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
  65         NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
  66                         dev->dev_addr);
  67
  68         NLA_PUT(msg, IEEE802154_ATTR_SRC_HW_ADDR, IEEE802154_ADDR_LEN,
  69                         addr->hwaddr);
  70
  71         NLA_PUT_U8(msg, IEEE802154_ATTR_CAPABILITY, cap);
  72
  73         return ieee802154_nl_mcast(msg, ieee802154_coord_mcgrp.id);
  74
  75 nla_put_failure:
  76         nlmsg_free(msg);
  77         return -ENOBUFS;
  78 }
  79 EXPORT_SYMBOL(ieee802154_nl_assoc_indic);
  80
  81 int ieee802154_nl_assoc_confirm(struct net_device *dev, u16 short_addr,
  82                 u8 status)
  83 {
  84         struct sk_buff *msg;
  85
  86         pr_debug("%s\n", __func__);
  87
  88         msg = ieee802154_nl_create(0, IEEE802154_ASSOCIATE_CONF);
  89         if (!msg)
  90                 return -ENOBUFS;
  91
  92         NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
  93         NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
  94         NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
  95                         dev->dev_addr);
  96
  97         NLA_PUT_U16(msg, IEEE802154_ATTR_SHORT_ADDR, short_addr);
  98         NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status);
  99
 100         return ieee802154_nl_mcast(msg, ieee802154_coord_mcgrp.id);
 101
 102 nla_put_failure:
 103         nlmsg_free(msg);
 104         return -ENOBUFS;
 105 }
 106 EXPORT_SYMBOL(ieee802154_nl_assoc_confirm);
 107
 108 int ieee802154_nl_disassoc_indic(struct net_device *dev,
 109                 struct ieee802154_addr *addr, u8 reason)
 110 {
 111         struct sk_buff *msg;
 112
 113         pr_debug("%s\n", __func__);
 114
 115         msg = ieee802154_nl_create(0, IEEE802154_DISASSOCIATE_INDIC);
 116         if (!msg)
 117                 return -ENOBUFS;
 118
 119         NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
 120         NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
 121         NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
 122                         dev->dev_addr);
 123
 124         if (addr->addr_type == IEEE802154_ADDR_LONG)
 125                 NLA_PUT(msg, IEEE802154_ATTR_SRC_HW_ADDR, IEEE802154_ADDR_LEN,
 126                                 addr->hwaddr);
 127         else
 128                 NLA_PUT_U16(msg, IEEE802154_ATTR_SRC_SHORT_ADDR,
 129                                 addr->short_addr);
 130
 131         NLA_PUT_U8(msg, IEEE802154_ATTR_REASON, reason);
 132
 133         return ieee802154_nl_mcast(msg, ieee802154_coord_mcgrp.id);
 134
 135 nla_put_failure:
 136         nlmsg_free(msg);
 137         return -ENOBUFS;
 138 }
 139 EXPORT_SYMBOL(ieee802154_nl_disassoc_indic);
 140
 141 int ieee802154_nl_disassoc_confirm(struct net_device *dev, u8 status)
 142 {
 143         struct sk_buff *msg;
 144
 145         pr_debug("%s\n", __func__);
 146
 147         msg = ieee802154_nl_create(0, IEEE802154_DISASSOCIATE_CONF);
 148         if (!msg)
 149                 return -ENOBUFS;
 150
 151         NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
 152         NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
 153         NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
 154                         dev->dev_addr);
 155
 156         NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status);
 157
 158         return ieee802154_nl_mcast(msg, ieee802154_coord_mcgrp.id);
 159
 160 nla_put_failure:
 161         nlmsg_free(msg);
 162         return -ENOBUFS;
 163 }
 164 EXPORT_SYMBOL(ieee802154_nl_disassoc_confirm);
 165
 166 int ieee802154_nl_beacon_indic(struct net_device *dev,
 167                 u16 panid, u16 coord_addr)
 168 {
 169         struct sk_buff *msg;
 170
 171         pr_debug("%s\n", __func__);
 172
 173         msg = ieee802154_nl_create(0, IEEE802154_BEACON_NOTIFY_INDIC);
 174         if (!msg)
 175                 return -ENOBUFS;
 176
 177         NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
 178         NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
 179         NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
 180                         dev->dev_addr);
 181         NLA_PUT_U16(msg, IEEE802154_ATTR_COORD_SHORT_ADDR, coord_addr);
 182         NLA_PUT_U16(msg, IEEE802154_ATTR_COORD_PAN_ID, panid);
 183
 184         return ieee802154_nl_mcast(msg, ieee802154_coord_mcgrp.id);
 185
 186 nla_put_failure:
 187         nlmsg_free(msg);
 188         return -ENOBUFS;
 189 }
 190 EXPORT_SYMBOL(ieee802154_nl_beacon_indic);
 191
 192 int ieee802154_nl_scan_confirm(struct net_device *dev,
 193                 u8 status, u8 scan_type, u32 unscanned, u8 page,
 194                 u8 *edl/* , struct list_head *pan_desc_list */)
 195 {
 196         struct sk_buff *msg;
 197
 198         pr_debug("%s\n", __func__);
 199
 200         msg = ieee802154_nl_create(0, IEEE802154_SCAN_CONF);
 201         if (!msg)
 202                 return -ENOBUFS;
 203
 204         NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
 205         NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
 206         NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
 207                         dev->dev_addr);
 208
 209         NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status);
 210         NLA_PUT_U8(msg, IEEE802154_ATTR_SCAN_TYPE, scan_type);
 211         NLA_PUT_U32(msg, IEEE802154_ATTR_CHANNELS, unscanned);
 212         NLA_PUT_U8(msg, IEEE802154_ATTR_PAGE, page);
 213
 214         if (edl)
 215                 NLA_PUT(msg, IEEE802154_ATTR_ED_LIST, 27, edl);
 216
 217         return ieee802154_nl_mcast(msg, ieee802154_coord_mcgrp.id);
 218
 219 nla_put_failure:
 220         nlmsg_free(msg);
 221         return -ENOBUFS;
 222 }
 223 EXPORT_SYMBOL(ieee802154_nl_scan_confirm);
 224
 225 int ieee802154_nl_start_confirm(struct net_device *dev, u8 status)
 226 {
 227         struct sk_buff *msg;
 228
 229         pr_debug("%s\n", __func__);
 230
 231         msg = ieee802154_nl_create(0, IEEE802154_START_CONF);
 232         if (!msg)
 233                 return -ENOBUFS;
 234
 235         NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
 236         NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
 237         NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
 238                         dev->dev_addr);
 239
 240         NLA_PUT_U8(msg, IEEE802154_ATTR_STATUS, status);
 241
 242         return ieee802154_nl_mcast(msg, ieee802154_coord_mcgrp.id);
 243
 244 nla_put_failure:
 245         nlmsg_free(msg);
 246         return -ENOBUFS;
 247 }
 248 EXPORT_SYMBOL(ieee802154_nl_start_confirm);
 249
 250 static int ieee802154_nl_fill_iface(struct sk_buff *msg, u32 pid,
 251         u32 seq, int flags, struct net_device *dev)
 252 {
 253         void *hdr;
 254
 255         pr_debug("%s\n", __func__);
 256
 257         hdr = genlmsg_put(msg, 0, seq, &nl802154_family, flags,
 258                 IEEE802154_LIST_IFACE);
 259         if (!hdr)
 260                 goto out;
 261
 262         NLA_PUT_STRING(msg, IEEE802154_ATTR_DEV_NAME, dev->name);
 263         NLA_PUT_U32(msg, IEEE802154_ATTR_DEV_INDEX, dev->ifindex);
 264
 265         NLA_PUT(msg, IEEE802154_ATTR_HW_ADDR, IEEE802154_ADDR_LEN,
 266                 dev->dev_addr);
 267         NLA_PUT_U16(msg, IEEE802154_ATTR_SHORT_ADDR,
 268                 ieee802154_mlme_ops(dev)->get_short_addr(dev));
 269         NLA_PUT_U16(msg, IEEE802154_ATTR_PAN_ID,
 270                 ieee802154_mlme_ops(dev)->get_pan_id(dev));
 271         return genlmsg_end(msg, hdr);
 272
 273 nla_put_failure:
 274         genlmsg_cancel(msg, hdr);
 275 out:
 276         return -EMSGSIZE;
 277 }
 278
 279 /* Requests from userspace */
 280 static struct net_device *ieee802154_nl_get_dev(struct genl_info *info)
 281 {
 282         struct net_device *dev;
 283
 284         if (info->attrs[IEEE802154_ATTR_DEV_NAME]) {
 285                 char name[IFNAMSIZ + 1];
 286                 nla_strlcpy(name, info->attrs[IEEE802154_ATTR_DEV_NAME],
 287                                 sizeof(name));
 288                 dev = dev_get_by_name(&init_net, name);
 289         } else if (info->attrs[IEEE802154_ATTR_DEV_INDEX])
 290                 dev = dev_get_by_index(&init_net,
 291                         nla_get_u32(info->attrs[IEEE802154_ATTR_DEV_INDEX]));
 292         else
 293                 return NULL;
 294
 295         if (!dev)
 296                 return NULL;
 297
 298         if (dev->type != ARPHRD_IEEE802154) {
 299                 dev_put(dev);
 300                 return NULL;
 301         }
 302
 303         return dev;
 304 }
 305
 306 static int ieee802154_associate_req(struct sk_buff *skb,
 307                 struct genl_info *info)
 308 {
 309         struct net_device *dev;
 310         struct ieee802154_addr addr;
 311         u8 page;
 312         int ret = -EINVAL;
 313
 314         if (!info->attrs[IEEE802154_ATTR_CHANNEL] ||
 315             !info->attrs[IEEE802154_ATTR_COORD_PAN_ID] ||
 316             (!info->attrs[IEEE802154_ATTR_COORD_HW_ADDR] &&
 317                 !info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]) ||
 318             !info->attrs[IEEE802154_ATTR_CAPABILITY])
 319                 return -EINVAL;
 320
 321         dev = ieee802154_nl_get_dev(info);
 322         if (!dev)
 323                 return -ENODEV;
 324
 325         if (info->attrs[IEEE802154_ATTR_COORD_HW_ADDR]) {
 326                 addr.addr_type = IEEE802154_ADDR_LONG;
 327                 nla_memcpy(addr.hwaddr,
 328                                 info->attrs[IEEE802154_ATTR_COORD_HW_ADDR],
 329                                 IEEE802154_ADDR_LEN);
 330         } else {
 331                 addr.addr_type = IEEE802154_ADDR_SHORT;
 332                 addr.short_addr = nla_get_u16(
 333                                 info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]);
 334         }
 335         addr.pan_id = nla_get_u16(info->attrs[IEEE802154_ATTR_COORD_PAN_ID]);
 336
 337         if (info->attrs[IEEE802154_ATTR_PAGE])
 338                 page = nla_get_u8(info->attrs[IEEE802154_ATTR_PAGE]);
 339         else
 340                 page = 0;
 341
 342         ret = ieee802154_mlme_ops(dev)->assoc_req(dev, &addr,
 343                         nla_get_u8(info->attrs[IEEE802154_ATTR_CHANNEL]),
 344                         page,
 345                         nla_get_u8(info->attrs[IEEE802154_ATTR_CAPABILITY]));
 346
 347         dev_put(dev);
 348         return ret;
 349 }
 350
 351 static int ieee802154_associate_resp(struct sk_buff *skb,
 352                 struct genl_info *info)
 353 {
 354         struct net_device *dev;
 355         struct ieee802154_addr addr;
 356         int ret = -EINVAL;
 357
 358         if (!info->attrs[IEEE802154_ATTR_STATUS] ||
 359             !info->attrs[IEEE802154_ATTR_DEST_HW_ADDR] ||
 360             !info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR])
 361                 return -EINVAL;
 362
 363         dev = ieee802154_nl_get_dev(info);
 364         if (!dev)
 365                 return -ENODEV;
 366
 367         addr.addr_type = IEEE802154_ADDR_LONG;
 368         nla_memcpy(addr.hwaddr, info->attrs[IEEE802154_ATTR_DEST_HW_ADDR],
 369                         IEEE802154_ADDR_LEN);
 370         addr.pan_id = ieee802154_mlme_ops(dev)->get_pan_id(dev);
 371
 372
 373         ret = ieee802154_mlme_ops(dev)->assoc_resp(dev, &addr,
 374                 nla_get_u16(info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]),
 375                 nla_get_u8(info->attrs[IEEE802154_ATTR_STATUS]));
 376
 377         dev_put(dev);
 378         return ret;
 379 }
 380
 381 static int ieee802154_disassociate_req(struct sk_buff *skb,
 382                 struct genl_info *info)
 383 {
 384         struct net_device *dev;
 385         struct ieee802154_addr addr;
 386         int ret = -EINVAL;
 387
 388         if ((!info->attrs[IEEE802154_ATTR_DEST_HW_ADDR] &&
 389                 !info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]) ||
 390             !info->attrs[IEEE802154_ATTR_REASON])
 391                 return -EINVAL;
 392
 393         dev = ieee802154_nl_get_dev(info);
 394         if (!dev)
 395                 return -ENODEV;
 396
 397         if (info->attrs[IEEE802154_ATTR_DEST_HW_ADDR]) {
 398                 addr.addr_type = IEEE802154_ADDR_LONG;
 399                 nla_memcpy(addr.hwaddr,
 400                                 info->attrs[IEEE802154_ATTR_DEST_HW_ADDR],
 401                                 IEEE802154_ADDR_LEN);
 402         } else {
 403                 addr.addr_type = IEEE802154_ADDR_SHORT;
 404                 addr.short_addr = nla_get_u16(
 405                                 info->attrs[IEEE802154_ATTR_DEST_SHORT_ADDR]);
 406         }
 407         addr.pan_id = ieee802154_mlme_ops(dev)->get_pan_id(dev);
 408
 409         ret = ieee802154_mlme_ops(dev)->disassoc_req(dev, &addr,
 410                         nla_get_u8(info->attrs[IEEE802154_ATTR_REASON]));
 411
 412         dev_put(dev);
 413         return ret;
 414 }
 415
 416 /*
 417  * PANid, channel, beacon_order = 15, superframe_order = 15,
 418  * PAN_coordinator, battery_life_extension = 0,
 419  * coord_realignment = 0, security_enable = 0
 420 */
 421 static int ieee802154_start_req(struct sk_buff *skb, struct genl_info *info)
 422 {
 423         struct net_device *dev;
 424         struct ieee802154_addr addr;
 425
 426         u8 channel, bcn_ord, sf_ord;
 427         u8 page;
 428         int pan_coord, blx, coord_realign;
 429         int ret;
 430
 431         if (!info->attrs[IEEE802154_ATTR_COORD_PAN_ID] ||
 432             !info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR] ||
 433             !info->attrs[IEEE802154_ATTR_CHANNEL] ||
 434             !info->attrs[IEEE802154_ATTR_BCN_ORD] ||
 435             !info->attrs[IEEE802154_ATTR_SF_ORD] ||
 436             !info->attrs[IEEE802154_ATTR_PAN_COORD] ||
 437             !info->attrs[IEEE802154_ATTR_BAT_EXT] ||
 438             !info->attrs[IEEE802154_ATTR_COORD_REALIGN]
 439          )
 440                 return -EINVAL;
 441
 442         dev = ieee802154_nl_get_dev(info);
 443         if (!dev)
 444                 return -ENODEV;
 445
 446         addr.addr_type = IEEE802154_ADDR_SHORT;
 447         addr.short_addr = nla_get_u16(
 448                         info->attrs[IEEE802154_ATTR_COORD_SHORT_ADDR]);
 449         addr.pan_id = nla_get_u16(info->attrs[IEEE802154_ATTR_COORD_PAN_ID]);
 450
 451         channel = nla_get_u8(info->attrs[IEEE802154_ATTR_CHANNEL]);
 452         bcn_ord = nla_get_u8(info->attrs[IEEE802154_ATTR_BCN_ORD]);
 453         sf_ord = nla_get_u8(info->attrs[IEEE802154_ATTR_SF_ORD]);
 454         pan_coord = nla_get_u8(info->attrs[IEEE802154_ATTR_PAN_COORD]);
 455         blx = nla_get_u8(info->attrs[IEEE802154_ATTR_BAT_EXT]);
 456         coord_realign = nla_get_u8(info->attrs[IEEE802154_ATTR_COORD_REALIGN]);
 457
 458         if (info->attrs[IEEE802154_ATTR_PAGE])
 459                 page = nla_get_u8(info->attrs[IEEE802154_ATTR_PAGE]);
 460         else
 461                 page = 0;
 462
 463
 464         if (addr.short_addr == IEEE802154_ADDR_BROADCAST) {
 465                 ieee802154_nl_start_confirm(dev, IEEE802154_NO_SHORT_ADDRESS);
 466                 dev_put(dev);
 467                 return -EINVAL;
 468         }
 469
 470         ret = ieee802154_mlme_ops(dev)->start_req(dev, &addr, channel, page,
 471                 bcn_ord, sf_ord, pan_coord, blx, coord_realign);
 472
 473         dev_put(dev);
 474         return ret;
 475 }
 476
 477 static int ieee802154_scan_req(struct sk_buff *skb, struct genl_info *info)
 478 {
 479         struct net_device *dev;
 480         int ret;
 481         u8 type;
 482         u32 channels;
 483         u8 duration;
 484         u8 page;
 485
 486         if (!info->attrs[IEEE802154_ATTR_SCAN_TYPE] ||
 487             !info->attrs[IEEE802154_ATTR_CHANNELS] ||
 488             !info->attrs[IEEE802154_ATTR_DURATION])
 489                 return -EINVAL;
 490
 491         dev = ieee802154_nl_get_dev(info);
 492         if (!dev)
 493                 return -ENODEV;
 494
 495         type = nla_get_u8(info->attrs[IEEE802154_ATTR_SCAN_TYPE]);
 496         channels = nla_get_u32(info->attrs[IEEE802154_ATTR_CHANNELS]);
 497         duration = nla_get_u8(info->attrs[IEEE802154_ATTR_DURATION]);
 498
 499         if (info->attrs[IEEE802154_ATTR_PAGE])
 500                 page = nla_get_u8(info->attrs[IEEE802154_ATTR_PAGE]);
 501         else
 502                 page = 0;
 503
 504
 505         ret = ieee802154_mlme_ops(dev)->scan_req(dev, type, channels, page,
 506                         duration);
 507
 508         dev_put(dev);
 509         return ret;
 510 }
 511
 512 static int ieee802154_list_iface(struct sk_buff *skb,
 513         struct genl_info *info)
 514 {
 515         /* Request for interface name, index, type, IEEE address,
 516            PAN Id, short address */
 517         struct sk_buff *msg;
 518         struct net_device *dev = NULL;
 519         int rc = -ENOBUFS;
 520
 521         pr_debug("%s\n", __func__);
 522
 523         dev = ieee802154_nl_get_dev(info);
 524         if (!dev)
 525                 return -ENODEV;
 526
 527         msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 528         if (!msg)
 529                 goto out_dev;
 530
 531         rc = ieee802154_nl_fill_iface(msg, info->snd_pid, info->snd_seq,
 532                         0, dev);
 533         if (rc < 0)
 534                 goto out_free;
 535
 536         dev_put(dev);
 537
 538         return genlmsg_reply(msg, info);
 539 out_free:
 540         nlmsg_free(msg);
 541 out_dev:
 542         dev_put(dev);
 543         return rc;
 544
 545 }
 546
 547 static int ieee802154_dump_iface(struct sk_buff *skb,
 548         struct netlink_callback *cb)
 549 {
 550         struct net *net = sock_net(skb->sk);
 551         struct net_device *dev;
 552         int idx;
 553         int s_idx = cb->args[0];
 554
 555         pr_debug("%s\n", __func__);
 556
 557         idx = 0;
 558         for_each_netdev(net, dev) {
 559                 if (idx < s_idx || (dev->type != ARPHRD_IEEE802154))
 560                         goto cont;
 561
 562                 if (ieee802154_nl_fill_iface(skb, NETLINK_CB(cb->skb).pid,
 563                         cb->nlh->nlmsg_seq, NLM_F_MULTI, dev) < 0)
 564                         break;
 565 cont:
 566                 idx++;
 567         }
 568         cb->args[0] = idx;
 569
 570         return skb->len;
 571 }
 572
 573 static struct genl_ops ieee802154_coordinator_ops[] = {
 574         IEEE802154_OP(IEEE802154_ASSOCIATE_REQ, ieee802154_associate_req),
 575         IEEE802154_OP(IEEE802154_ASSOCIATE_RESP, ieee802154_associate_resp),
 576         IEEE802154_OP(IEEE802154_DISASSOCIATE_REQ, ieee802154_disassociate_req),
 577         IEEE802154_OP(IEEE802154_SCAN_REQ, ieee802154_scan_req),
 578         IEEE802154_OP(IEEE802154_START_REQ, ieee802154_start_req),
 579         IEEE802154_DUMP(IEEE802154_LIST_IFACE, ieee802154_list_iface,
 580                                                         ieee802154_dump_iface),
 581 };
 582
 583 /*
 584  * No need to unregister as family unregistration will do it.
 585  */
 586 int nl802154_mac_register(void)
 587 {
 588         int i;
 589         int rc;
 590
 591         rc = genl_register_mc_group(&nl802154_family,
 592                         &ieee802154_coord_mcgrp);
 593         if (rc)
 594                 return rc;
 595
 596         rc = genl_register_mc_group(&nl802154_family,
 597                         &ieee802154_beacon_mcgrp);
 598         if (rc)
 599                 return rc;
 600
 601         for (i = 0; i < ARRAY_SIZE(ieee802154_coordinator_ops); i++) {
 602                 rc = genl_register_ops(&nl802154_family,
 603                                 &ieee802154_coordinator_ops[i]);
 604                 if (rc)
 605                         return rc;
 606         }
 607
 608         return 0;
 609 }