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/netdevice.h> 21 #include <linux/module.h> 22 #include <linux/if_arp.h> 23 #include <linux/ieee802154.h> 24 25 #include <net/rtnetlink.h> 26 #include <linux/nl802154.h> 27 #include <net/af_ieee802154.h> 28 #include <net/mac802154.h> 29 #include <net/ieee802154_netdev.h> 30 #include <net/cfg802154.h> 31 32 #include "ieee802154_i.h" 33 #include "driver-ops.h" 34 35 static int mac802154_wpan_update_llsec(struct net_device *dev) 36 { 37 struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev); 38 struct ieee802154_mlme_ops *ops = ieee802154_mlme_ops(dev); 39 int rc = 0; 40 41 if (ops->llsec) { 42 struct ieee802154_llsec_params params; 43 int changed = 0; 44 45 params.pan_id = sdata->pan_id; 46 changed |= IEEE802154_LLSEC_PARAM_PAN_ID; 47 48 params.hwaddr = sdata->extended_addr; 49 changed |= IEEE802154_LLSEC_PARAM_HWADDR; 50 51 rc = ops->llsec->set_params(dev, ¶ms, changed); 52 } 53 54 return rc; 55 } 56 57 static int 58 mac802154_wpan_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 59 { 60 struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev); 61 struct sockaddr_ieee802154 *sa = 62 (struct sockaddr_ieee802154 *)&ifr->ifr_addr; 63 int err = -ENOIOCTLCMD; 64 65 spin_lock_bh(&sdata->mib_lock); 66 67 switch (cmd) { 68 case SIOCGIFADDR: 69 { 70 u16 pan_id, short_addr; 71 72 pan_id = le16_to_cpu(sdata->pan_id); 73 short_addr = le16_to_cpu(sdata->short_addr); 74 if (pan_id == IEEE802154_PANID_BROADCAST || 75 short_addr == IEEE802154_ADDR_BROADCAST) { 76 err = -EADDRNOTAVAIL; 77 break; 78 } 79 80 sa->family = AF_IEEE802154; 81 sa->addr.addr_type = IEEE802154_ADDR_SHORT; 82 sa->addr.pan_id = pan_id; 83 sa->addr.short_addr = short_addr; 84 85 err = 0; 86 break; 87 } 88 case SIOCSIFADDR: 89 dev_warn(&dev->dev, 90 "Using DEBUGing ioctl SIOCSIFADDR isn't recommended!\n"); 91 if (sa->family != AF_IEEE802154 || 92 sa->addr.addr_type != IEEE802154_ADDR_SHORT || 93 sa->addr.pan_id == IEEE802154_PANID_BROADCAST || 94 sa->addr.short_addr == IEEE802154_ADDR_BROADCAST || 95 sa->addr.short_addr == IEEE802154_ADDR_UNDEF) { 96 err = -EINVAL; 97 break; 98 } 99 100 sdata->pan_id = cpu_to_le16(sa->addr.pan_id); 101 sdata->short_addr = cpu_to_le16(sa->addr.short_addr); 102 103 err = mac802154_wpan_update_llsec(dev); 104 break; 105 } 106 107 spin_unlock_bh(&sdata->mib_lock); 108 return err; 109 } 110 111 static int mac802154_wpan_mac_addr(struct net_device *dev, void *p) 112 { 113 struct sockaddr *addr = p; 114 115 if (netif_running(dev)) 116 return -EBUSY; 117 118 /* FIXME: validate addr */ 119 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); 120 mac802154_dev_set_ieee_addr(dev); 121 return mac802154_wpan_update_llsec(dev); 122 } 123 124 int mac802154_set_mac_params(struct net_device *dev, 125 const struct ieee802154_mac_params *params) 126 { 127 struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev); 128 129 mutex_lock(&sdata->local->iflist_mtx); 130 sdata->mac_params = *params; 131 mutex_unlock(&sdata->local->iflist_mtx); 132 133 return 0; 134 } 135 136 void mac802154_get_mac_params(struct net_device *dev, 137 struct ieee802154_mac_params *params) 138 { 139 struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev); 140 141 mutex_lock(&sdata->local->iflist_mtx); 142 *params = sdata->mac_params; 143 mutex_unlock(&sdata->local->iflist_mtx); 144 } 145 146 static int mac802154_slave_open(struct net_device *dev) 147 { 148 struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev); 149 struct ieee802154_sub_if_data *subif; 150 struct ieee802154_local *local = sdata->local; 151 int res = 0; 152 153 ASSERT_RTNL(); 154 155 if (sdata->type == IEEE802154_DEV_WPAN) { 156 mutex_lock(&sdata->local->iflist_mtx); 157 list_for_each_entry(subif, &sdata->local->interfaces, list) { 158 if (subif != sdata && subif->type == sdata->type && 159 ieee802154_sdata_running(subif)) { 160 mutex_unlock(&sdata->local->iflist_mtx); 161 return -EBUSY; 162 } 163 } 164 mutex_unlock(&sdata->local->iflist_mtx); 165 } 166 167 set_bit(SDATA_STATE_RUNNING, &sdata->state); 168 169 if (local->open_count++ == 0) { 170 res = drv_start(local); 171 WARN_ON(res); 172 if (res) 173 goto err; 174 } 175 176 netif_start_queue(dev); 177 return 0; 178 err: 179 /* might already be clear but that doesn't matter */ 180 clear_bit(SDATA_STATE_RUNNING, &sdata->state); 181 sdata->local->open_count--; 182 183 return res; 184 } 185 186 static int mac802154_wpan_open(struct net_device *dev) 187 { 188 int rc; 189 struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev); 190 struct ieee802154_local *local = sdata->local; 191 struct wpan_phy *phy = sdata->local->phy; 192 193 rc = mac802154_slave_open(dev); 194 if (rc < 0) 195 return rc; 196 197 mutex_lock(&phy->pib_lock); 198 199 if (local->hw.flags & IEEE802154_HW_TXPOWER) { 200 rc = drv_set_tx_power(local, sdata->mac_params.transmit_power); 201 if (rc < 0) 202 goto out; 203 } 204 205 if (local->hw.flags & IEEE802154_HW_LBT) { 206 rc = drv_set_lbt_mode(local, sdata->mac_params.lbt); 207 if (rc < 0) 208 goto out; 209 } 210 211 if (local->hw.flags & IEEE802154_HW_CCA_MODE) { 212 rc = drv_set_cca_mode(local, sdata->mac_params.cca_mode); 213 if (rc < 0) 214 goto out; 215 } 216 217 if (local->hw.flags & IEEE802154_HW_CCA_ED_LEVEL) { 218 rc = drv_set_cca_ed_level(local, 219 sdata->mac_params.cca_ed_level); 220 if (rc < 0) 221 goto out; 222 } 223 224 if (local->hw.flags & IEEE802154_HW_CSMA_PARAMS) { 225 rc = drv_set_csma_params(local, sdata->mac_params.min_be, 226 sdata->mac_params.max_be, 227 sdata->mac_params.csma_retries); 228 if (rc < 0) 229 goto out; 230 } 231 232 if (local->hw.flags & IEEE802154_HW_FRAME_RETRIES) { 233 rc = drv_set_max_frame_retries(local, 234 sdata->mac_params.frame_retries); 235 if (rc < 0) 236 goto out; 237 } 238 239 mutex_unlock(&phy->pib_lock); 240 return 0; 241 242 out: 243 mutex_unlock(&phy->pib_lock); 244 return rc; 245 } 246 247 static int mac802154_slave_close(struct net_device *dev) 248 { 249 struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev); 250 struct ieee802154_local *local = sdata->local; 251 252 ASSERT_RTNL(); 253 254 netif_stop_queue(dev); 255 256 clear_bit(SDATA_STATE_RUNNING, &sdata->state); 257 258 if (!--local->open_count) 259 drv_stop(local); 260 261 return 0; 262 } 263 264 static int mac802154_set_header_security(struct ieee802154_sub_if_data *sdata, 265 struct ieee802154_hdr *hdr, 266 const struct ieee802154_mac_cb *cb) 267 { 268 struct ieee802154_llsec_params params; 269 u8 level; 270 271 mac802154_llsec_get_params(&sdata->sec, ¶ms); 272 273 if (!params.enabled && cb->secen_override && cb->secen) 274 return -EINVAL; 275 if (!params.enabled || 276 (cb->secen_override && !cb->secen) || 277 !params.out_level) 278 return 0; 279 if (cb->seclevel_override && !cb->seclevel) 280 return -EINVAL; 281 282 level = cb->seclevel_override ? cb->seclevel : params.out_level; 283 284 hdr->fc.security_enabled = 1; 285 hdr->sec.level = level; 286 hdr->sec.key_id_mode = params.out_key.mode; 287 if (params.out_key.mode == IEEE802154_SCF_KEY_SHORT_INDEX) 288 hdr->sec.short_src = params.out_key.short_source; 289 else if (params.out_key.mode == IEEE802154_SCF_KEY_HW_INDEX) 290 hdr->sec.extended_src = params.out_key.extended_source; 291 hdr->sec.key_id = params.out_key.id; 292 293 return 0; 294 } 295 296 static int mac802154_header_create(struct sk_buff *skb, 297 struct net_device *dev, 298 unsigned short type, 299 const void *daddr, 300 const void *saddr, 301 unsigned len) 302 { 303 struct ieee802154_hdr hdr; 304 struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev); 305 struct ieee802154_mac_cb *cb = mac_cb(skb); 306 int hlen; 307 308 if (!daddr) 309 return -EINVAL; 310 311 memset(&hdr.fc, 0, sizeof(hdr.fc)); 312 hdr.fc.type = cb->type; 313 hdr.fc.security_enabled = cb->secen; 314 hdr.fc.ack_request = cb->ackreq; 315 hdr.seq = ieee802154_mlme_ops(dev)->get_dsn(dev); 316 317 if (mac802154_set_header_security(sdata, &hdr, cb) < 0) 318 return -EINVAL; 319 320 if (!saddr) { 321 spin_lock_bh(&sdata->mib_lock); 322 323 if (sdata->short_addr == cpu_to_le16(IEEE802154_ADDR_BROADCAST) || 324 sdata->short_addr == cpu_to_le16(IEEE802154_ADDR_UNDEF) || 325 sdata->pan_id == cpu_to_le16(IEEE802154_PANID_BROADCAST)) { 326 hdr.source.mode = IEEE802154_ADDR_LONG; 327 hdr.source.extended_addr = sdata->extended_addr; 328 } else { 329 hdr.source.mode = IEEE802154_ADDR_SHORT; 330 hdr.source.short_addr = sdata->short_addr; 331 } 332 333 hdr.source.pan_id = sdata->pan_id; 334 335 spin_unlock_bh(&sdata->mib_lock); 336 } else { 337 hdr.source = *(const struct ieee802154_addr *)saddr; 338 } 339 340 hdr.dest = *(const struct ieee802154_addr *)daddr; 341 342 hlen = ieee802154_hdr_push(skb, &hdr); 343 if (hlen < 0) 344 return -EINVAL; 345 346 skb_reset_mac_header(skb); 347 skb->mac_len = hlen; 348 349 if (len > ieee802154_max_payload(&hdr)) 350 return -EMSGSIZE; 351 352 return hlen; 353 } 354 355 static int 356 mac802154_header_parse(const struct sk_buff *skb, unsigned char *haddr) 357 { 358 struct ieee802154_hdr hdr; 359 struct ieee802154_addr *addr = (struct ieee802154_addr *)haddr; 360 361 if (ieee802154_hdr_peek_addrs(skb, &hdr) < 0) { 362 pr_debug("malformed packet\n"); 363 return 0; 364 } 365 366 *addr = hdr.source; 367 return sizeof(*addr); 368 } 369 370 static struct header_ops mac802154_header_ops = { 371 .create = mac802154_header_create, 372 .parse = mac802154_header_parse, 373 }; 374 375 static const struct net_device_ops mac802154_wpan_ops = { 376 .ndo_open = mac802154_wpan_open, 377 .ndo_stop = mac802154_slave_close, 378 .ndo_start_xmit = ieee802154_subif_start_xmit, 379 .ndo_do_ioctl = mac802154_wpan_ioctl, 380 .ndo_set_mac_address = mac802154_wpan_mac_addr, 381 }; 382 383 static const struct net_device_ops mac802154_monitor_ops = { 384 .ndo_open = mac802154_slave_open, 385 .ndo_stop = mac802154_slave_close, 386 .ndo_start_xmit = ieee802154_monitor_start_xmit, 387 }; 388 389 static void mac802154_wpan_free(struct net_device *dev) 390 { 391 struct ieee802154_sub_if_data *sdata = IEEE802154_DEV_TO_SUB_IF(dev); 392 393 mac802154_llsec_destroy(&sdata->sec); 394 395 free_netdev(dev); 396 } 397 398 void mac802154_wpan_setup(struct net_device *dev) 399 { 400 struct ieee802154_sub_if_data *sdata; 401 402 dev->addr_len = IEEE802154_ADDR_LEN; 403 memset(dev->broadcast, 0xff, IEEE802154_ADDR_LEN); 404 405 dev->hard_header_len = MAC802154_FRAME_HARD_HEADER_LEN; 406 dev->header_ops = &mac802154_header_ops; 407 dev->needed_tailroom = 2 + 16; /* FCS + MIC */ 408 dev->mtu = IEEE802154_MTU; 409 dev->tx_queue_len = 300; 410 dev->type = ARPHRD_IEEE802154; 411 dev->flags = IFF_NOARP | IFF_BROADCAST; 412 dev->watchdog_timeo = 0; 413 414 dev->destructor = mac802154_wpan_free; 415 dev->netdev_ops = &mac802154_wpan_ops; 416 dev->ml_priv = &mac802154_mlme_wpan; 417 418 sdata = IEEE802154_DEV_TO_SUB_IF(dev); 419 sdata->type = IEEE802154_DEV_WPAN; 420 421 sdata->chan = MAC802154_CHAN_NONE; 422 sdata->page = 0; 423 424 spin_lock_init(&sdata->mib_lock); 425 mutex_init(&sdata->sec_mtx); 426 427 get_random_bytes(&sdata->bsn, 1); 428 get_random_bytes(&sdata->dsn, 1); 429 430 /* defaults per 802.15.4-2011 */ 431 sdata->mac_params.min_be = 3; 432 sdata->mac_params.max_be = 5; 433 sdata->mac_params.csma_retries = 4; 434 /* for compatibility, actual default is 3 */ 435 sdata->mac_params.frame_retries = -1; 436 437 sdata->pan_id = cpu_to_le16(IEEE802154_PANID_BROADCAST); 438 sdata->short_addr = cpu_to_le16(IEEE802154_ADDR_BROADCAST); 439 440 mac802154_llsec_init(&sdata->sec); 441 } 442 443 void mac802154_monitor_setup(struct net_device *dev) 444 { 445 struct ieee802154_sub_if_data *sdata; 446 447 dev->addr_len = 0; 448 dev->hard_header_len = 0; 449 dev->needed_tailroom = 2; /* room for FCS */ 450 dev->mtu = IEEE802154_MTU; 451 dev->tx_queue_len = 10; 452 dev->type = ARPHRD_IEEE802154_MONITOR; 453 dev->flags = IFF_NOARP | IFF_BROADCAST; 454 dev->watchdog_timeo = 0; 455 456 dev->destructor = free_netdev; 457 dev->netdev_ops = &mac802154_monitor_ops; 458 dev->ml_priv = &mac802154_mlme_reduced; 459 460 sdata = IEEE802154_DEV_TO_SUB_IF(dev); 461 sdata->type = IEEE802154_DEV_MONITOR; 462 463 sdata->chan = MAC802154_CHAN_NONE; /* not initialized */ 464 sdata->page = 0; 465 } 466