drivers/wlan/wlantap/wlantap-mac.cpp - garnet - Git at Google

 // Copyright 2018 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "wlantap-mac.h"

 #include <ddk/debug.h>
 #include <ddk/driver.h>
 #include <fuchsia/wlan/device/cpp/fidl.h>
 #include <wlan/common/channel.h>
 #include <wlan/wlanmac-ifc-proxy.h>

 #include <mutex>
 #include "utils.h"

 namespace wlan {

 namespace wlantap = ::fuchsia::wlan::tap;
 namespace wlan_device = ::fuchsia::wlan::device;

 namespace {

 struct WlantapMacImpl : WlantapMac {
     WlantapMacImpl(zx_device_t* phy_device, uint16_t id, wlan_device::MacRole role,
                    const wlantap::WlantapPhyConfig* phy_config, Listener* listener)
         : id_(id), role_(role), phy_config_(phy_config), listener_(listener) {}

     static void DdkUnbind(void* ctx) {
         auto& self = *static_cast<WlantapMacImpl*>(ctx);
         self.RemoveDevice();
     }

     static void DdkRelease(void* ctx) { delete static_cast<WlantapMacImpl*>(ctx); }

     // Wlanmac protocol impl

     static zx_status_t WlanmacQuery(void* ctx, uint32_t options, wlanmac_info_t* info) {
         auto& self = *static_cast<WlantapMacImpl*>(ctx);
         wlan_info_t* ifc_info = &info->ifc_info;

         ConvertPhyInfo(ifc_info, self.phy_config_->phy_info);
         ifc_info->mac_role = ConvertMacRole(self.role_);
         return ZX_OK;
     }

     static zx_status_t WlanmacStart(void* ctx, wlanmac_ifc_t* ifc, void* cookie) {
         auto& self = *static_cast<WlantapMacImpl*>(ctx);
         {
             std::lock_guard<std::mutex> guard(self.lock_);
             if (self.ifc_) { return ZX_ERR_ALREADY_BOUND; }
             self.ifc_ = WlanmacIfcClient{ifc, cookie};
         }
         self.listener_->WlantapMacStart(self.id_);
         return ZX_OK;
     }

     static void WlanmacStop(void* ctx) {
         auto& self = *static_cast<WlantapMacImpl*>(ctx);
         {
             std::lock_guard<std::mutex> guard(self.lock_);
             self.ifc_ = {};
         }
         self.listener_->WlantapMacStop(self.id_);
     }

     static zx_status_t WlanmacQueueTx(void* ctx, uint32_t options, wlan_tx_packet_t* pkt) {
         auto& self = *static_cast<WlantapMacImpl*>(ctx);
         self.listener_->WlantapMacQueueTx(self.id_, pkt);
         return ZX_OK;
     }

     static zx_status_t WlanmacSetChannel(void* ctx, uint32_t options, wlan_channel_t* chan) {
         auto& self = *static_cast<WlantapMacImpl*>(ctx);
         if (options != 0) { return ZX_ERR_INVALID_ARGS; }
         if (!wlan::common::IsValidChan(*chan)) { return ZX_ERR_INVALID_ARGS; }
         self.listener_->WlantapMacSetChannel(self.id_, chan);
         return ZX_OK;
     }

     static zx_status_t WlanmacConfigureBss(void* ctx, uint32_t options, wlan_bss_config_t* config) {
         auto& self = *static_cast<WlantapMacImpl*>(ctx);
         if (options != 0) { return ZX_ERR_INVALID_ARGS; }
         bool expected_remote = self.role_ == wlan_device::MacRole::CLIENT;
         if (config->remote != expected_remote) { return ZX_ERR_INVALID_ARGS; }
         self.listener_->WlantapMacConfigureBss(self.id_, config);
         return ZX_OK;
     }

     static zx_status_t WlanmacEnableBeaconing(void* ctx, uint32_t options,
                                               wlan_bcn_config_t* bcn_cfg) {
         if (options != 0) { return ZX_ERR_INVALID_ARGS; }
         if (bcn_cfg != nullptr) { return ZX_ERR_NOT_SUPPORTED; }
         return ZX_OK;
     }

     static zx_status_t WlanmacConfigureBeacon(void* ctx, uint32_t options, wlan_tx_packet_t* pkt) {
         if (options != 0) { return ZX_ERR_INVALID_ARGS; }
         if (pkt != nullptr) { return ZX_ERR_NOT_SUPPORTED; }
         return ZX_OK;
     }

     static zx_status_t WlanmacSetKey(void* ctx, uint32_t options, wlan_key_config_t* key_config) {
         auto& self = *static_cast<WlantapMacImpl*>(ctx);
         if (options != 0) { return ZX_ERR_INVALID_ARGS; }
         self.listener_->WlantapMacSetKey(self.id_, key_config);
         return ZX_OK;
     }

     static zx_status_t WlanmacConfigureAssoc(void* ctx, uint32_t options,
                                              wlan_assoc_ctx* assoc_ctx) {
         if (options != 0) { return ZX_ERR_INVALID_ARGS; }
         if (assoc_ctx != 0) { return ZX_ERR_INVALID_ARGS; }
         // TODO(NET-1270): Evalute the use and implement
         return ZX_OK;
     }

     static zx_status_t WlanmacClearAssoc(void* ctx, uint32_t options, const uint8_t* mac) {
         if (options != 0) { return ZX_ERR_INVALID_ARGS; }
         if (!mac) { return ZX_ERR_INVALID_ARGS; }
         // TODO(NET-1270): Evalute the use and implement
         return ZX_OK;
     }

     // WlantapMac impl

     virtual void Rx(const std::vector<uint8_t>& data, const wlantap::WlanRxInfo& rx_info) override {
         std::lock_guard<std::mutex> guard(lock_);
         if (ifc_) {
             wlan_rx_info_t converted_info = {.rx_flags = rx_info.rx_flags,
                                              .valid_fields = rx_info.valid_fields,
                                              .phy = rx_info.phy,
                                              .data_rate = rx_info.data_rate,
                                              .chan = {.primary = rx_info.chan.primary,
                                                       .cbw = static_cast<uint8_t>(rx_info.chan.cbw),
                                                       .secondary80 = rx_info.chan.secondary80},
                                              .mcs = rx_info.mcs,
                                              .rssi_dbm = rx_info.rssi_dbm,
                                              .rcpi_dbmh = rx_info.rcpi_dbmh,
                                              .snr_dbh = rx_info.snr_dbh};
             ifc_.Recv(0, &data[0], data.size(), &converted_info);
         }
     }

     virtual void Status(uint32_t status) override {
         std::lock_guard<std::mutex> guard(lock_);
         if (ifc_) { ifc_.Status(status); }
     }

     virtual void ReportTxStatus(const wlantap::WlanTxStatus& ts) override {
         std::lock_guard<std::mutex> guard(lock_);
         if (ifc_) {
             wlan_tx_status_t converted_tx_status = ConvertTxStatus(ts);
             ifc_.ReportTxStatus(&converted_tx_status);
         }
     }

     virtual void RemoveDevice() override {
         {
             std::lock_guard<std::mutex> guard(lock_);
             ifc_ = {};
         }
         device_remove(device_);
     }

     zx_device_t* device_ = nullptr;
     uint16_t id_;
     wlan_device::MacRole role_;
     std::mutex lock_;
     WlanmacIfcClient ifc_ __TA_GUARDED(lock_);
     const wlantap::WlantapPhyConfig* phy_config_;
     Listener* listener_;
 };

 }  // namespace

 zx_status_t CreateWlantapMac(zx_device_t* parent_phy, const wlan_device::MacRole role,
                              const wlantap::WlantapPhyConfig* phy_config, uint16_t id,
                              WlantapMac::Listener* listener, WlantapMac** ret) {
     char name[ZX_MAX_NAME_LEN + 1];
     snprintf(name, sizeof(name), "%s-mac%u", device_get_name(parent_phy), id);
     std::unique_ptr<WlantapMacImpl> wlanmac(
         new WlantapMacImpl(parent_phy, id, role, phy_config, listener));
     static zx_protocol_device_t device_ops = {.version = DEVICE_OPS_VERSION,
                                               .unbind = &WlantapMacImpl::DdkUnbind,
                                               .release = &WlantapMacImpl::DdkRelease};
     static wlanmac_protocol_ops_t proto_ops = {
         .query = &WlantapMacImpl::WlanmacQuery,
         .start = &WlantapMacImpl::WlanmacStart,
         .stop = &WlantapMacImpl::WlanmacStop,
         .queue_tx = &WlantapMacImpl::WlanmacQueueTx,
         .set_channel = &WlantapMacImpl::WlanmacSetChannel,
         .configure_bss = &WlantapMacImpl::WlanmacConfigureBss,
         .enable_beaconing = &WlantapMacImpl::WlanmacEnableBeaconing,
         .configure_beacon = &WlantapMacImpl::WlanmacConfigureBeacon,
         .set_key = &WlantapMacImpl::WlanmacSetKey,
         .configure_assoc = &WlantapMacImpl::WlanmacConfigureAssoc,
         .clear_assoc = &WlantapMacImpl::WlanmacClearAssoc,
     };
     device_add_args_t args = {.version = DEVICE_ADD_ARGS_VERSION,
                               .name = name,
                               .ctx = wlanmac.get(),
                               .ops = &device_ops,
                               .proto_id = ZX_PROTOCOL_WLANMAC,
                               .proto_ops = &proto_ops};
     zx_status_t status = device_add(parent_phy, &args, &wlanmac->device_);
     if (status != ZX_OK) {
         zxlogf(ERROR, "%s: could not add device: %d\n", __func__, status);
         return status;
     }
     // Transfer ownership to devmgr
     *ret = wlanmac.release();
     return ZX_OK;
 }

 }  // namespace wlan
	// Copyright 2018 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "wlantap-mac.h"

	#include <ddk/debug.h>
	#include <ddk/driver.h>
	#include <fuchsia/wlan/device/cpp/fidl.h>
	#include <wlan/common/channel.h>
	#include <wlan/wlanmac-ifc-proxy.h>

	#include <mutex>
	#include "utils.h"

	namespace wlan {

	namespace wlantap = ::fuchsia::wlan::tap;
	namespace wlan_device = ::fuchsia::wlan::device;

	namespace {

	struct WlantapMacImpl : WlantapMac {
	WlantapMacImpl(zx_device_t* phy_device, uint16_t id, wlan_device::MacRole role,
	const wlantap::WlantapPhyConfig* phy_config, Listener* listener)
	: id_(id), role_(role), phy_config_(phy_config), listener_(listener) {}

	static void DdkUnbind(void* ctx) {
	auto& self = static_cast<WlantapMacImpl>(ctx);
	self.RemoveDevice();
	}

	static void DdkRelease(void* ctx) { delete static_cast<WlantapMacImpl*>(ctx); }

	// Wlanmac protocol impl

	static zx_status_t WlanmacQuery(void* ctx, uint32_t options, wlanmac_info_t* info) {
	auto& self = static_cast<WlantapMacImpl>(ctx);
	wlan_info_t* ifc_info = &info->ifc_info;

	ConvertPhyInfo(ifc_info, self.phy_config_->phy_info);
	ifc_info->mac_role = ConvertMacRole(self.role_);
	return ZX_OK;
	}

	static zx_status_t WlanmacStart(void* ctx, wlanmac_ifc_t* ifc, void* cookie) {
	auto& self = static_cast<WlantapMacImpl>(ctx);
	{
	std::lock_guard<std::mutex> guard(self.lock_);
	if (self.ifc_) { return ZX_ERR_ALREADY_BOUND; }
	self.ifc_ = WlanmacIfcClient{ifc, cookie};
	}
	self.listener_->WlantapMacStart(self.id_);
	return ZX_OK;
	}

	static void WlanmacStop(void* ctx) {
	auto& self = static_cast<WlantapMacImpl>(ctx);
	{
	std::lock_guard<std::mutex> guard(self.lock_);
	self.ifc_ = {};
	}
	self.listener_->WlantapMacStop(self.id_);
	}

	static zx_status_t WlanmacQueueTx(void* ctx, uint32_t options, wlan_tx_packet_t* pkt) {
	auto& self = static_cast<WlantapMacImpl>(ctx);
	self.listener_->WlantapMacQueueTx(self.id_, pkt);
	return ZX_OK;
	}

	static zx_status_t WlanmacSetChannel(void* ctx, uint32_t options, wlan_channel_t* chan) {
	auto& self = static_cast<WlantapMacImpl>(ctx);
	if (options != 0) { return ZX_ERR_INVALID_ARGS; }
	if (!wlan::common::IsValidChan(*chan)) { return ZX_ERR_INVALID_ARGS; }
	self.listener_->WlantapMacSetChannel(self.id_, chan);
	return ZX_OK;
	}

	static zx_status_t WlanmacConfigureBss(void* ctx, uint32_t options, wlan_bss_config_t* config) {
	auto& self = static_cast<WlantapMacImpl>(ctx);
	if (options != 0) { return ZX_ERR_INVALID_ARGS; }
	bool expected_remote = self.role_ == wlan_device::MacRole::CLIENT;
	if (config->remote != expected_remote) { return ZX_ERR_INVALID_ARGS; }
	self.listener_->WlantapMacConfigureBss(self.id_, config);
	return ZX_OK;
	}

	static zx_status_t WlanmacEnableBeaconing(void* ctx, uint32_t options,
	wlan_bcn_config_t* bcn_cfg) {
	if (options != 0) { return ZX_ERR_INVALID_ARGS; }
	if (bcn_cfg != nullptr) { return ZX_ERR_NOT_SUPPORTED; }
	return ZX_OK;
	}

	static zx_status_t WlanmacConfigureBeacon(void* ctx, uint32_t options, wlan_tx_packet_t* pkt) {
	if (options != 0) { return ZX_ERR_INVALID_ARGS; }
	if (pkt != nullptr) { return ZX_ERR_NOT_SUPPORTED; }
	return ZX_OK;
	}

	static zx_status_t WlanmacSetKey(void* ctx, uint32_t options, wlan_key_config_t* key_config) {
	auto& self = static_cast<WlantapMacImpl>(ctx);
	if (options != 0) { return ZX_ERR_INVALID_ARGS; }
	self.listener_->WlantapMacSetKey(self.id_, key_config);
	return ZX_OK;
	}

	static zx_status_t WlanmacConfigureAssoc(void* ctx, uint32_t options,
	wlan_assoc_ctx* assoc_ctx) {
	if (options != 0) { return ZX_ERR_INVALID_ARGS; }
	if (assoc_ctx != 0) { return ZX_ERR_INVALID_ARGS; }
	// TODO(NET-1270): Evalute the use and implement
	return ZX_OK;
	}

	static zx_status_t WlanmacClearAssoc(void* ctx, uint32_t options, const uint8_t* mac) {
	if (options != 0) { return ZX_ERR_INVALID_ARGS; }
	if (!mac) { return ZX_ERR_INVALID_ARGS; }
	// TODO(NET-1270): Evalute the use and implement
	return ZX_OK;
	}

	// WlantapMac impl

	virtual void Rx(const std::vector<uint8_t>& data, const wlantap::WlanRxInfo& rx_info) override {
	std::lock_guard<std::mutex> guard(lock_);
	if (ifc_) {
	wlan_rx_info_t converted_info = {.rx_flags = rx_info.rx_flags,
	.valid_fields = rx_info.valid_fields,
	.phy = rx_info.phy,
	.data_rate = rx_info.data_rate,
	.chan = {.primary = rx_info.chan.primary,
	.cbw = static_cast<uint8_t>(rx_info.chan.cbw),
	.secondary80 = rx_info.chan.secondary80},
	.mcs = rx_info.mcs,
	.rssi_dbm = rx_info.rssi_dbm,
	.rcpi_dbmh = rx_info.rcpi_dbmh,
	.snr_dbh = rx_info.snr_dbh};
	ifc_.Recv(0, &data[0], data.size(), &converted_info);
	}
	}

	virtual void Status(uint32_t status) override {
	std::lock_guard<std::mutex> guard(lock_);
	if (ifc_) { ifc_.Status(status); }
	}

	virtual void ReportTxStatus(const wlantap::WlanTxStatus& ts) override {
	std::lock_guard<std::mutex> guard(lock_);
	if (ifc_) {
	wlan_tx_status_t converted_tx_status = ConvertTxStatus(ts);
	ifc_.ReportTxStatus(&converted_tx_status);
	}
	}

	virtual void RemoveDevice() override {
	{
	std::lock_guard<std::mutex> guard(lock_);
	ifc_ = {};
	}
	device_remove(device_);
	}

	zx_device_t* device_ = nullptr;
	uint16_t id_;
	wlan_device::MacRole role_;
	std::mutex lock_;
	WlanmacIfcClient ifc_ __TA_GUARDED(lock_);
	const wlantap::WlantapPhyConfig* phy_config_;
	Listener* listener_;
	};

	} // namespace

	zx_status_t CreateWlantapMac(zx_device_t* parent_phy, const wlan_device::MacRole role,
	const wlantap::WlantapPhyConfig* phy_config, uint16_t id,
	WlantapMac::Listener* listener, WlantapMac** ret) {
	char name[ZX_MAX_NAME_LEN + 1];
	snprintf(name, sizeof(name), "%s-mac%u", device_get_name(parent_phy), id);
	std::unique_ptr<WlantapMacImpl> wlanmac(
	new WlantapMacImpl(parent_phy, id, role, phy_config, listener));
	static zx_protocol_device_t device_ops = {.version = DEVICE_OPS_VERSION,
	.unbind = &WlantapMacImpl::DdkUnbind,
	.release = &WlantapMacImpl::DdkRelease};
	static wlanmac_protocol_ops_t proto_ops = {
	.query = &WlantapMacImpl::WlanmacQuery,
	.start = &WlantapMacImpl::WlanmacStart,
	.stop = &WlantapMacImpl::WlanmacStop,
	.queue_tx = &WlantapMacImpl::WlanmacQueueTx,
	.set_channel = &WlantapMacImpl::WlanmacSetChannel,
	.configure_bss = &WlantapMacImpl::WlanmacConfigureBss,
	.enable_beaconing = &WlantapMacImpl::WlanmacEnableBeaconing,
	.configure_beacon = &WlantapMacImpl::WlanmacConfigureBeacon,
	.set_key = &WlantapMacImpl::WlanmacSetKey,
	.configure_assoc = &WlantapMacImpl::WlanmacConfigureAssoc,
	.clear_assoc = &WlantapMacImpl::WlanmacClearAssoc,
	};
	device_add_args_t args = {.version = DEVICE_ADD_ARGS_VERSION,
	.name = name,
	.ctx = wlanmac.get(),
	.ops = &device_ops,
	.proto_id = ZX_PROTOCOL_WLANMAC,
	.proto_ops = &proto_ops};
	zx_status_t status = device_add(parent_phy, &args, &wlanmac->device_);
	if (status != ZX_OK) {
	zxlogf(ERROR, "%s: could not add device: %d\n", __func__, status);
	return status;
	}
	// Transfer ownership to devmgr
	*ret = wlanmac.release();
	return ZX_OK;
	}

	} // namespace wlan