net/mac802154/mib.c

   1 /*
   2  * Copyright 2007-2012 Siemens AG
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2
   6  * as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * Written by:
  14  * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
  15  * Sergey Lapin <slapin@ossfans.org>
  16  * Maxim Gorbachyov <maxim.gorbachev@siemens.com>
  17  * Alexander Smirnov <alex.bluesman.smirnov@gmail.com>
  18  */
  19
  20 #include <linux/if_arp.h>
  21
  22 #include <net/mac802154.h>
  23 #include <net/ieee802154_netdev.h>
  24 #include <net/cfg802154.h>
  25
  26 #include "ieee802154_i.h"
  27 #include "driver-ops.h"
  28
  29 struct hw_addr_filt_notify_work {
  30         struct work_struct work;
  31         struct net_device *dev;
  32         unsigned long changed;
  33 };
  34
  35 static struct ieee802154_local *mac802154_slave_get_priv(struct net_device *dev)
  36 {
  37         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
  38
  39         BUG_ON(dev->type != ARPHRD_IEEE802154);
  40
  41         return sdata->local;
  42 }
  43
  44 static void hw_addr_notify(struct work_struct *work)
  45 {
  46         struct hw_addr_filt_notify_work *nw = container_of(work,
  47                         struct hw_addr_filt_notify_work, work);
  48         struct ieee802154_local *local = mac802154_slave_get_priv(nw->dev);
  49         int res;
  50
  51         res = local->ops->set_hw_addr_filt(&local->hw, &local->hw.hw_filt,
  52                                            nw->changed);
  53         if (res)
  54                 pr_debug("failed changed mask %lx\n", nw->changed);
  55
  56         kfree(nw);
  57 }
  58
  59 static void set_hw_addr_filt(struct net_device *dev, unsigned long changed)
  60 {
  61         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
  62         struct hw_addr_filt_notify_work *work;
  63
  64         work = kzalloc(sizeof(*work), GFP_ATOMIC);
  65         if (!work)
  66                 return;
  67
  68         INIT_WORK(&work->work, hw_addr_notify);
  69         work->dev = dev;
  70         work->changed = changed;
  71         queue_work(sdata->local->workqueue, &work->work);
  72 }
  73
  74 void mac802154_dev_set_short_addr(struct net_device *dev, __le16 val)
  75 {
  76         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
  77
  78         BUG_ON(dev->type != ARPHRD_IEEE802154);
  79
  80         spin_lock_bh(&sdata->mib_lock);
  81         sdata->short_addr = val;
  82         spin_unlock_bh(&sdata->mib_lock);
  83
  84         if ((sdata->local->ops->set_hw_addr_filt) &&
  85             (sdata->local->hw.hw_filt.short_addr != sdata->short_addr)) {
  86                 sdata->local->hw.hw_filt.short_addr = sdata->short_addr;
  87                 set_hw_addr_filt(dev, IEEE802154_AFILT_SADDR_CHANGED);
  88         }
  89 }
  90
  91 __le16 mac802154_dev_get_short_addr(const struct net_device *dev)
  92 {
  93         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
  94         __le16 ret;
  95
  96         BUG_ON(dev->type != ARPHRD_IEEE802154);
  97
  98         spin_lock_bh(&sdata->mib_lock);
  99         ret = sdata->short_addr;
 100         spin_unlock_bh(&sdata->mib_lock);
 101
 102         return ret;
 103 }
 104
 105 void mac802154_dev_set_ieee_addr(struct net_device *dev)
 106 {
 107         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 108         struct ieee802154_local *local = sdata->local;
 109
 110         sdata->extended_addr = ieee802154_devaddr_from_raw(dev->dev_addr);
 111
 112         if (local->ops->set_hw_addr_filt &&
 113             local->hw.hw_filt.ieee_addr != sdata->extended_addr) {
 114                 local->hw.hw_filt.ieee_addr = sdata->extended_addr;
 115                 set_hw_addr_filt(dev, IEEE802154_AFILT_IEEEADDR_CHANGED);
 116         }
 117 }
 118
 119 __le16 mac802154_dev_get_pan_id(const struct net_device *dev)
 120 {
 121         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 122         __le16 ret;
 123
 124         BUG_ON(dev->type != ARPHRD_IEEE802154);
 125
 126         spin_lock_bh(&sdata->mib_lock);
 127         ret = sdata->pan_id;
 128         spin_unlock_bh(&sdata->mib_lock);
 129
 130         return ret;
 131 }
 132
 133 void mac802154_dev_set_pan_id(struct net_device *dev, __le16 val)
 134 {
 135         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 136
 137         BUG_ON(dev->type != ARPHRD_IEEE802154);
 138
 139         spin_lock_bh(&sdata->mib_lock);
 140         sdata->pan_id = val;
 141         spin_unlock_bh(&sdata->mib_lock);
 142
 143         if ((sdata->local->ops->set_hw_addr_filt) &&
 144             (sdata->local->hw.hw_filt.pan_id != sdata->pan_id)) {
 145                 sdata->local->hw.hw_filt.pan_id = sdata->pan_id;
 146                 set_hw_addr_filt(dev, IEEE802154_AFILT_PANID_CHANGED);
 147         }
 148 }
 149
 150 u8 mac802154_dev_get_dsn(const struct net_device *dev)
 151 {
 152         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 153
 154         BUG_ON(dev->type != ARPHRD_IEEE802154);
 155
 156         return sdata->dsn++;
 157 }
 158
 159 void mac802154_dev_set_page_channel(struct net_device *dev, u8 page, u8 chan)
 160 {
 161         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 162         struct ieee802154_local *local = sdata->local;
 163         int res;
 164
 165         BUG_ON(dev->type != ARPHRD_IEEE802154);
 166
 167         res = drv_set_channel(local, page, chan);
 168         if (res) {
 169                 pr_debug("set_channel failed\n");
 170         } else {
 171                 mutex_lock(&local->phy->pib_lock);
 172                 local->phy->current_channel = chan;
 173                 local->phy->current_page = page;
 174                 mutex_unlock(&local->phy->pib_lock);
 175         }
 176 }
 177
 178
 179 int mac802154_get_params(struct net_device *dev,
 180                          struct ieee802154_llsec_params *params)
 181 {
 182         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 183         int res;
 184
 185         BUG_ON(dev->type != ARPHRD_IEEE802154);
 186
 187         mutex_lock(&sdata->sec_mtx);
 188         res = mac802154_llsec_get_params(&sdata->sec, params);
 189         mutex_unlock(&sdata->sec_mtx);
 190
 191         return res;
 192 }
 193
 194 int mac802154_set_params(struct net_device *dev,
 195                          const struct ieee802154_llsec_params *params,
 196                          int changed)
 197 {
 198         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 199         int res;
 200
 201         BUG_ON(dev->type != ARPHRD_IEEE802154);
 202
 203         mutex_lock(&sdata->sec_mtx);
 204         res = mac802154_llsec_set_params(&sdata->sec, params, changed);
 205         mutex_unlock(&sdata->sec_mtx);
 206
 207         return res;
 208 }
 209
 210
 211 int mac802154_add_key(struct net_device *dev,
 212                       const struct ieee802154_llsec_key_id *id,
 213                       const struct ieee802154_llsec_key *key)
 214 {
 215         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 216         int res;
 217
 218         BUG_ON(dev->type != ARPHRD_IEEE802154);
 219
 220         mutex_lock(&sdata->sec_mtx);
 221         res = mac802154_llsec_key_add(&sdata->sec, id, key);
 222         mutex_unlock(&sdata->sec_mtx);
 223
 224         return res;
 225 }
 226
 227 int mac802154_del_key(struct net_device *dev,
 228                       const struct ieee802154_llsec_key_id *id)
 229 {
 230         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 231         int res;
 232
 233         BUG_ON(dev->type != ARPHRD_IEEE802154);
 234
 235         mutex_lock(&sdata->sec_mtx);
 236         res = mac802154_llsec_key_del(&sdata->sec, id);
 237         mutex_unlock(&sdata->sec_mtx);
 238
 239         return res;
 240 }
 241
 242
 243 int mac802154_add_dev(struct net_device *dev,
 244                       const struct ieee802154_llsec_device *llsec_dev)
 245 {
 246         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 247         int res;
 248
 249         BUG_ON(dev->type != ARPHRD_IEEE802154);
 250
 251         mutex_lock(&sdata->sec_mtx);
 252         res = mac802154_llsec_dev_add(&sdata->sec, llsec_dev);
 253         mutex_unlock(&sdata->sec_mtx);
 254
 255         return res;
 256 }
 257
 258 int mac802154_del_dev(struct net_device *dev, __le64 dev_addr)
 259 {
 260         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 261         int res;
 262
 263         BUG_ON(dev->type != ARPHRD_IEEE802154);
 264
 265         mutex_lock(&sdata->sec_mtx);
 266         res = mac802154_llsec_dev_del(&sdata->sec, dev_addr);
 267         mutex_unlock(&sdata->sec_mtx);
 268
 269         return res;
 270 }
 271
 272
 273 int mac802154_add_devkey(struct net_device *dev,
 274                          __le64 device_addr,
 275                          const struct ieee802154_llsec_device_key *key)
 276 {
 277         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 278         int res;
 279
 280         BUG_ON(dev->type != ARPHRD_IEEE802154);
 281
 282         mutex_lock(&sdata->sec_mtx);
 283         res = mac802154_llsec_devkey_add(&sdata->sec, device_addr, key);
 284         mutex_unlock(&sdata->sec_mtx);
 285
 286         return res;
 287 }
 288
 289 int mac802154_del_devkey(struct net_device *dev,
 290                          __le64 device_addr,
 291                          const struct ieee802154_llsec_device_key *key)
 292 {
 293         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 294         int res;
 295
 296         BUG_ON(dev->type != ARPHRD_IEEE802154);
 297
 298         mutex_lock(&sdata->sec_mtx);
 299         res = mac802154_llsec_devkey_del(&sdata->sec, device_addr, key);
 300         mutex_unlock(&sdata->sec_mtx);
 301
 302         return res;
 303 }
 304
 305
 306 int mac802154_add_seclevel(struct net_device *dev,
 307                            const struct ieee802154_llsec_seclevel *sl)
 308 {
 309         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 310         int res;
 311
 312         BUG_ON(dev->type != ARPHRD_IEEE802154);
 313
 314         mutex_lock(&sdata->sec_mtx);
 315         res = mac802154_llsec_seclevel_add(&sdata->sec, sl);
 316         mutex_unlock(&sdata->sec_mtx);
 317
 318         return res;
 319 }
 320
 321 int mac802154_del_seclevel(struct net_device *dev,
 322                            const struct ieee802154_llsec_seclevel *sl)
 323 {
 324         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 325         int res;
 326
 327         BUG_ON(dev->type != ARPHRD_IEEE802154);
 328
 329         mutex_lock(&sdata->sec_mtx);
 330         res = mac802154_llsec_seclevel_del(&sdata->sec, sl);
 331         mutex_unlock(&sdata->sec_mtx);
 332
 333         return res;
 334 }
 335
 336
 337 void mac802154_lock_table(struct net_device *dev)
 338 {
 339         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 340
 341         BUG_ON(dev->type != ARPHRD_IEEE802154);
 342
 343         mutex_lock(&sdata->sec_mtx);
 344 }
 345
 346 void mac802154_get_table(struct net_device *dev,
 347                          struct ieee802154_llsec_table **t)
 348 {
 349         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 350
 351         BUG_ON(dev->type != ARPHRD_IEEE802154);
 352
 353         *t = &sdata->sec.table;
 354 }
 355
 356 void mac802154_unlock_table(struct net_device *dev)
 357 {
 358         struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev);
 359
 360         BUG_ON(dev->type != ARPHRD_IEEE802154);
 361
 362         mutex_unlock(&sdata->sec_mtx);
 363 }