Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-16 00:52:01 +00:00
Code Issues Packages Projects Releases Wiki Activity
d674838509
linux/net/mac802154/driver-ops.h
Alexander Aring ac8037c35b mac802154: set filter at drv_start() 
The current filtering level is set on the first interface up on a wpan
phy. If we support scan functionality we need to change the filtering
level on the fly on an operational phy and switching back again.

This patch will move the receive mode parameter e.g. address filter and
promiscuous mode to the drv_start() functionality to allow changing the
receive mode on an operational phy not on first ifup only. In future this
should be handled on driver layer because each hardware has it's own way
to enter a specific filtering level. However this should offer to switch
to mode IEEE802154_FILTERING_NONE and back to
IEEE802154_FILTERING_4_FRAME_FIELDS.

Only IEEE802154_FILTERING_4_FRAME_FIELDS and IEEE802154_FILTERING_NONE
are somewhat supported by current hardware. All other filtering levels
can be supported in future but will end in IEEE802154_FILTERING_NONE as
the receive part can kind of "emulate" those receive paths by doing
additional filtering routines.

There are in total three filtering levels in the code:
- the per-interface default level (should not be changed)
- the required per-interface level (mac commands may play with it)
- the actual per-PHY (hw) level that is currently in use

Signed-off-by: Alexander Aring <aahringo@redhat.com>
[<miquel.raynal@bootlin.com: Add the third filtering variable]
Signed-off-by: Miquel Raynal <miquel.raynal@bootlin.com>
Link: https://lore.kernel.org/r/20221007085310.503366-4-miquel.raynal@bootlin.com
Signed-off-by: Stefan Schmidt <stefan@datenfreihafen.org>
2022-10-12 12:56:58 +02:00

355 lines
7.8 KiB
C
Raw Blame History

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __MAC802154_DRIVER_OPS
#define __MAC802154_DRIVER_OPS
#include <linux/types.h>
#include <linux/rtnetlink.h>
#include <net/mac802154.h>
#include "ieee802154_i.h"
#include "trace.h"
static inline int
drv_xmit_async(struct ieee802154_local *local, struct sk_buff *skb)
{
return local->ops->xmit_async(&local->hw, skb);
}
static inline int
drv_xmit_sync(struct ieee802154_local *local, struct sk_buff *skb)
{
might_sleep();
return local->ops->xmit_sync(&local->hw, skb);
}
static inline int drv_set_pan_id(struct ieee802154_local *local, __le16 pan_id)
{
struct ieee802154_hw_addr_filt filt;
int ret;
might_sleep();
if (!local->ops->set_hw_addr_filt) {
WARN_ON(1);
return -EOPNOTSUPP;
}
filt.pan_id = pan_id;
trace_802154_drv_set_pan_id(local, pan_id);
ret = local->ops->set_hw_addr_filt(&local->hw, &filt,
IEEE802154_AFILT_PANID_CHANGED);
trace_802154_drv_return_int(local, ret);
return ret;
}
static inline int
drv_set_extended_addr(struct ieee802154_local *local, __le64 extended_addr)
{
struct ieee802154_hw_addr_filt filt;
int ret;
might_sleep();
if (!local->ops->set_hw_addr_filt) {
WARN_ON(1);
return -EOPNOTSUPP;
}
filt.ieee_addr = extended_addr;
trace_802154_drv_set_extended_addr(local, extended_addr);
ret = local->ops->set_hw_addr_filt(&local->hw, &filt,
IEEE802154_AFILT_IEEEADDR_CHANGED);
trace_802154_drv_return_int(local, ret);
return ret;
}
static inline int
drv_set_short_addr(struct ieee802154_local *local, __le16 short_addr)
{
struct ieee802154_hw_addr_filt filt;
int ret;
might_sleep();
if (!local->ops->set_hw_addr_filt) {
WARN_ON(1);
return -EOPNOTSUPP;
}
filt.short_addr = short_addr;
trace_802154_drv_set_short_addr(local, short_addr);
ret = local->ops->set_hw_addr_filt(&local->hw, &filt,
IEEE802154_AFILT_SADDR_CHANGED);
trace_802154_drv_return_int(local, ret);
return ret;
}
static inline int
drv_set_pan_coord(struct ieee802154_local *local, bool is_coord)
{
struct ieee802154_hw_addr_filt filt;
int ret;
might_sleep();
if (!local->ops->set_hw_addr_filt) {
WARN_ON(1);
return -EOPNOTSUPP;
}
filt.pan_coord = is_coord;
trace_802154_drv_set_pan_coord(local, is_coord);
ret = local->ops->set_hw_addr_filt(&local->hw, &filt,
IEEE802154_AFILT_PANC_CHANGED);
trace_802154_drv_return_int(local, ret);
return ret;
}
static inline int
drv_set_promiscuous_mode(struct ieee802154_local *local, bool on)
{
int ret;
might_sleep();
if (!local->ops->set_promiscuous_mode) {
WARN_ON(1);
return -EOPNOTSUPP;
}
trace_802154_drv_set_promiscuous_mode(local, on);
ret = local->ops->set_promiscuous_mode(&local->hw, on);
trace_802154_drv_return_int(local, ret);
return ret;
}
static inline int drv_start(struct ieee802154_local *local,
enum ieee802154_filtering_level level,
const struct ieee802154_hw_addr_filt *addr_filt)
{
int ret;
might_sleep();
/* setup receive mode parameters e.g. address mode */
if (local->hw.flags & IEEE802154_HW_AFILT) {
ret = drv_set_pan_id(local, addr_filt->pan_id);
if (ret < 0)
return ret;
ret = drv_set_short_addr(local, addr_filt->short_addr);
if (ret < 0)
return ret;
ret = drv_set_extended_addr(local, addr_filt->ieee_addr);
if (ret < 0)
return ret;
}
switch (level) {
case IEEE802154_FILTERING_NONE:
fallthrough;
case IEEE802154_FILTERING_1_FCS:
fallthrough;
case IEEE802154_FILTERING_2_PROMISCUOUS:
/* TODO: Requires a different receive mode setup e.g.
* at86rf233 hardware.
*/
fallthrough;
case IEEE802154_FILTERING_3_SCAN:
if (local->hw.flags & IEEE802154_HW_PROMISCUOUS) {
ret = drv_set_promiscuous_mode(local, true);
if (ret < 0)
return ret;
} else {
return -EOPNOTSUPP;
}
/* In practice other filtering levels can be requested, but as
* for now most hardware/drivers only support
* IEEE802154_FILTERING_NONE, we fallback to this actual
* filtering level in hardware and make our own additional
* filtering in mac802154 receive path.
*
* TODO: Move this logic to the device drivers as hardware may
* support more higher level filters. Hardware may also require
* a different order how register are set, which could currently
* be buggy, so all received parameters need to be moved to the
* start() callback and let the driver go into the mode before
* it will turn on receive handling.
*/
local->phy->filtering = IEEE802154_FILTERING_NONE;
break;
case IEEE802154_FILTERING_4_FRAME_FIELDS:
/* Do not error out if IEEE802154_HW_PROMISCUOUS because we
* expect the hardware to operate at the level
* IEEE802154_FILTERING_4_FRAME_FIELDS anyway.
*/
if (local->hw.flags & IEEE802154_HW_PROMISCUOUS) {
ret = drv_set_promiscuous_mode(local, false);
if (ret < 0)
return ret;
}
local->phy->filtering = IEEE802154_FILTERING_4_FRAME_FIELDS;
break;
default:
WARN_ON(1);
return -EINVAL;
}
trace_802154_drv_start(local);
local->started = true;
smp_mb();
ret = local->ops->start(&local->hw);
trace_802154_drv_return_int(local, ret);
return ret;
}
static inline void drv_stop(struct ieee802154_local *local)
{
might_sleep();
trace_802154_drv_stop(local);
local->ops->stop(&local->hw);
trace_802154_drv_return_void(local);
/* sync away all work on the tasklet before clearing started */
tasklet_disable(&local->tasklet);
tasklet_enable(&local->tasklet);
barrier();
local->started = false;
}
static inline int
drv_set_channel(struct ieee802154_local *local, u8 page, u8 channel)
{
int ret;
might_sleep();
trace_802154_drv_set_channel(local, page, channel);
ret = local->ops->set_channel(&local->hw, page, channel);
trace_802154_drv_return_int(local, ret);
return ret;
}
static inline int drv_set_tx_power(struct ieee802154_local *local, s32 mbm)
{
int ret;
might_sleep();
if (!local->ops->set_txpower) {
WARN_ON(1);
return -EOPNOTSUPP;
}
trace_802154_drv_set_tx_power(local, mbm);
ret = local->ops->set_txpower(&local->hw, mbm);
trace_802154_drv_return_int(local, ret);
return ret;
}
static inline int drv_set_cca_mode(struct ieee802154_local *local,
const struct wpan_phy_cca *cca)
{
int ret;
might_sleep();
if (!local->ops->set_cca_mode) {
WARN_ON(1);
return -EOPNOTSUPP;
}
trace_802154_drv_set_cca_mode(local, cca);
ret = local->ops->set_cca_mode(&local->hw, cca);
trace_802154_drv_return_int(local, ret);
return ret;
}
static inline int drv_set_lbt_mode(struct ieee802154_local *local, bool mode)
{
int ret;
might_sleep();
if (!local->ops->set_lbt) {
WARN_ON(1);
return -EOPNOTSUPP;
}
trace_802154_drv_set_lbt_mode(local, mode);
ret = local->ops->set_lbt(&local->hw, mode);
trace_802154_drv_return_int(local, ret);
return ret;
}
static inline int
drv_set_cca_ed_level(struct ieee802154_local *local, s32 mbm)
{
int ret;
might_sleep();
if (!local->ops->set_cca_ed_level) {
WARN_ON(1);
return -EOPNOTSUPP;
}
trace_802154_drv_set_cca_ed_level(local, mbm);
ret = local->ops->set_cca_ed_level(&local->hw, mbm);
trace_802154_drv_return_int(local, ret);
return ret;
}
static inline int
drv_set_csma_params(struct ieee802154_local *local, u8 min_be, u8 max_be,
u8 max_csma_backoffs)
{
int ret;
might_sleep();
if (!local->ops->set_csma_params) {
WARN_ON(1);
return -EOPNOTSUPP;
}
trace_802154_drv_set_csma_params(local, min_be, max_be,
max_csma_backoffs);
ret = local->ops->set_csma_params(&local->hw, min_be, max_be,
max_csma_backoffs);
trace_802154_drv_return_int(local, ret);
return ret;
}
static inline int
drv_set_max_frame_retries(struct ieee802154_local *local, s8 max_frame_retries)
{
int ret;
might_sleep();
if (!local->ops->set_frame_retries) {
WARN_ON(1);
return -EOPNOTSUPP;
}
trace_802154_drv_set_max_frame_retries(local, max_frame_retries);
ret = local->ops->set_frame_retries(&local->hw, max_frame_retries);
trace_802154_drv_return_int(local, ret);
return ret;
}
#endif /* __MAC802154_DRIVER_OPS */
Reference in New Issue View Git Blame Copy Permalink