net/wireless/rdev-ops.h

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 /*
0003  * Portions of this file
0004  * Copyright(c) 2016-2017 Intel Deutschland GmbH
0005  * Copyright (C) 2018, 2021-2022 Intel Corporation
0006  */
0007 #ifndef __CFG80211_RDEV_OPS
0008 #define __CFG80211_RDEV_OPS
0009
0010 #include <linux/rtnetlink.h>
0011 #include <net/cfg80211.h>
0012 #include "core.h"
0013 #include "trace.h"
0014
0015 static inline int rdev_suspend(struct cfg80211_registered_device *rdev,
0016                    struct cfg80211_wowlan *wowlan)
0017 {
0018     int ret;
0019     trace_rdev_suspend(&rdev->wiphy, wowlan);
0020     ret = rdev->ops->suspend(&rdev->wiphy, wowlan);
0021     trace_rdev_return_int(&rdev->wiphy, ret);
0022     return ret;
0023 }
0024
0025 static inline int rdev_resume(struct cfg80211_registered_device *rdev)
0026 {
0027     int ret;
0028     trace_rdev_resume(&rdev->wiphy);
0029     ret = rdev->ops->resume(&rdev->wiphy);
0030     trace_rdev_return_int(&rdev->wiphy, ret);
0031     return ret;
0032 }
0033
0034 static inline void rdev_set_wakeup(struct cfg80211_registered_device *rdev,
0035                    bool enabled)
0036 {
0037     trace_rdev_set_wakeup(&rdev->wiphy, enabled);
0038     rdev->ops->set_wakeup(&rdev->wiphy, enabled);
0039     trace_rdev_return_void(&rdev->wiphy);
0040 }
0041
0042 static inline struct wireless_dev
0043 *rdev_add_virtual_intf(struct cfg80211_registered_device *rdev, char *name,
0044                unsigned char name_assign_type,
0045                enum nl80211_iftype type,
0046                struct vif_params *params)
0047 {
0048     struct wireless_dev *ret;
0049     trace_rdev_add_virtual_intf(&rdev->wiphy, name, type);
0050     ret = rdev->ops->add_virtual_intf(&rdev->wiphy, name, name_assign_type,
0051                       type, params);
0052     trace_rdev_return_wdev(&rdev->wiphy, ret);
0053     return ret;
0054 }
0055
0056 static inline int
0057 rdev_del_virtual_intf(struct cfg80211_registered_device *rdev,
0058               struct wireless_dev *wdev)
0059 {
0060     int ret;
0061     trace_rdev_del_virtual_intf(&rdev->wiphy, wdev);
0062     ret = rdev->ops->del_virtual_intf(&rdev->wiphy, wdev);
0063     trace_rdev_return_int(&rdev->wiphy, ret);
0064     return ret;
0065 }
0066
0067 static inline int
0068 rdev_change_virtual_intf(struct cfg80211_registered_device *rdev,
0069              struct net_device *dev, enum nl80211_iftype type,
0070              struct vif_params *params)
0071 {
0072     int ret;
0073     trace_rdev_change_virtual_intf(&rdev->wiphy, dev, type);
0074     ret = rdev->ops->change_virtual_intf(&rdev->wiphy, dev, type, params);
0075     trace_rdev_return_int(&rdev->wiphy, ret);
0076     return ret;
0077 }
0078
0079 static inline int rdev_add_key(struct cfg80211_registered_device *rdev,
0080                    struct net_device *netdev, u8 key_index,
0081                    bool pairwise, const u8 *mac_addr,
0082                    struct key_params *params)
0083 {
0084     int ret;
0085     trace_rdev_add_key(&rdev->wiphy, netdev, key_index, pairwise,
0086                mac_addr, params->mode);
0087     ret = rdev->ops->add_key(&rdev->wiphy, netdev, key_index, pairwise,
0088                   mac_addr, params);
0089     trace_rdev_return_int(&rdev->wiphy, ret);
0090     return ret;
0091 }
0092
0093 static inline int
0094 rdev_get_key(struct cfg80211_registered_device *rdev, struct net_device *netdev,
0095          u8 key_index, bool pairwise, const u8 *mac_addr, void *cookie,
0096          void (*callback)(void *cookie, struct key_params*))
0097 {
0098     int ret;
0099     trace_rdev_get_key(&rdev->wiphy, netdev, key_index, pairwise, mac_addr);
0100     ret = rdev->ops->get_key(&rdev->wiphy, netdev, key_index, pairwise,
0101                   mac_addr, cookie, callback);
0102     trace_rdev_return_int(&rdev->wiphy, ret);
0103     return ret;
0104 }
0105
0106 static inline int rdev_del_key(struct cfg80211_registered_device *rdev,
0107                    struct net_device *netdev, u8 key_index,
0108                    bool pairwise, const u8 *mac_addr)
0109 {
0110     int ret;
0111     trace_rdev_del_key(&rdev->wiphy, netdev, key_index, pairwise, mac_addr);
0112     ret = rdev->ops->del_key(&rdev->wiphy, netdev, key_index, pairwise,
0113                   mac_addr);
0114     trace_rdev_return_int(&rdev->wiphy, ret);
0115     return ret;
0116 }
0117
0118 static inline int
0119 rdev_set_default_key(struct cfg80211_registered_device *rdev,
0120              struct net_device *netdev, u8 key_index, bool unicast,
0121              bool multicast)
0122 {
0123     int ret;
0124     trace_rdev_set_default_key(&rdev->wiphy, netdev, key_index,
0125                    unicast, multicast);
0126     ret = rdev->ops->set_default_key(&rdev->wiphy, netdev, key_index,
0127                       unicast, multicast);
0128     trace_rdev_return_int(&rdev->wiphy, ret);
0129     return ret;
0130 }
0131
0132 static inline int
0133 rdev_set_default_mgmt_key(struct cfg80211_registered_device *rdev,
0134               struct net_device *netdev, u8 key_index)
0135 {
0136     int ret;
0137     trace_rdev_set_default_mgmt_key(&rdev->wiphy, netdev, key_index);
0138     ret = rdev->ops->set_default_mgmt_key(&rdev->wiphy, netdev,
0139                            key_index);
0140     trace_rdev_return_int(&rdev->wiphy, ret);
0141     return ret;
0142 }
0143
0144 static inline int
0145 rdev_set_default_beacon_key(struct cfg80211_registered_device *rdev,
0146                 struct net_device *netdev, u8 key_index)
0147 {
0148     int ret;
0149
0150     trace_rdev_set_default_beacon_key(&rdev->wiphy, netdev, key_index);
0151     ret = rdev->ops->set_default_beacon_key(&rdev->wiphy, netdev,
0152                         key_index);
0153     trace_rdev_return_int(&rdev->wiphy, ret);
0154     return ret;
0155 }
0156
0157 static inline int rdev_start_ap(struct cfg80211_registered_device *rdev,
0158                 struct net_device *dev,
0159                 struct cfg80211_ap_settings *settings)
0160 {
0161     int ret;
0162     trace_rdev_start_ap(&rdev->wiphy, dev, settings);
0163     ret = rdev->ops->start_ap(&rdev->wiphy, dev, settings);
0164     trace_rdev_return_int(&rdev->wiphy, ret);
0165     return ret;
0166 }
0167
0168 static inline int rdev_change_beacon(struct cfg80211_registered_device *rdev,
0169                      struct net_device *dev,
0170                      struct cfg80211_beacon_data *info)
0171 {
0172     int ret;
0173     trace_rdev_change_beacon(&rdev->wiphy, dev, info);
0174     ret = rdev->ops->change_beacon(&rdev->wiphy, dev, info);
0175     trace_rdev_return_int(&rdev->wiphy, ret);
0176     return ret;
0177 }
0178
0179 static inline int rdev_stop_ap(struct cfg80211_registered_device *rdev,
0180                    struct net_device *dev, unsigned int link_id)
0181 {
0182     int ret;
0183     trace_rdev_stop_ap(&rdev->wiphy, dev, link_id);
0184     ret = rdev->ops->stop_ap(&rdev->wiphy, dev, link_id);
0185     trace_rdev_return_int(&rdev->wiphy, ret);
0186     return ret;
0187 }
0188
0189 static inline int rdev_add_station(struct cfg80211_registered_device *rdev,
0190                    struct net_device *dev, u8 *mac,
0191                    struct station_parameters *params)
0192 {
0193     int ret;
0194     trace_rdev_add_station(&rdev->wiphy, dev, mac, params);
0195     ret = rdev->ops->add_station(&rdev->wiphy, dev, mac, params);
0196     trace_rdev_return_int(&rdev->wiphy, ret);
0197     return ret;
0198 }
0199
0200 static inline int rdev_del_station(struct cfg80211_registered_device *rdev,
0201                    struct net_device *dev,
0202                    struct station_del_parameters *params)
0203 {
0204     int ret;
0205     trace_rdev_del_station(&rdev->wiphy, dev, params);
0206     ret = rdev->ops->del_station(&rdev->wiphy, dev, params);
0207     trace_rdev_return_int(&rdev->wiphy, ret);
0208     return ret;
0209 }
0210
0211 static inline int rdev_change_station(struct cfg80211_registered_device *rdev,
0212                       struct net_device *dev, u8 *mac,
0213                       struct station_parameters *params)
0214 {
0215     int ret;
0216     trace_rdev_change_station(&rdev->wiphy, dev, mac, params);
0217     ret = rdev->ops->change_station(&rdev->wiphy, dev, mac, params);
0218     trace_rdev_return_int(&rdev->wiphy, ret);
0219     return ret;
0220 }
0221
0222 static inline int rdev_get_station(struct cfg80211_registered_device *rdev,
0223                    struct net_device *dev, const u8 *mac,
0224                    struct station_info *sinfo)
0225 {
0226     int ret;
0227     trace_rdev_get_station(&rdev->wiphy, dev, mac);
0228     ret = rdev->ops->get_station(&rdev->wiphy, dev, mac, sinfo);
0229     trace_rdev_return_int_station_info(&rdev->wiphy, ret, sinfo);
0230     return ret;
0231 }
0232
0233 static inline int rdev_dump_station(struct cfg80211_registered_device *rdev,
0234                     struct net_device *dev, int idx, u8 *mac,
0235                     struct station_info *sinfo)
0236 {
0237     int ret;
0238     trace_rdev_dump_station(&rdev->wiphy, dev, idx, mac);
0239     ret = rdev->ops->dump_station(&rdev->wiphy, dev, idx, mac, sinfo);
0240     trace_rdev_return_int_station_info(&rdev->wiphy, ret, sinfo);
0241     return ret;
0242 }
0243
0244 static inline int rdev_add_mpath(struct cfg80211_registered_device *rdev,
0245                  struct net_device *dev, u8 *dst, u8 *next_hop)
0246 {
0247     int ret;
0248     trace_rdev_add_mpath(&rdev->wiphy, dev, dst, next_hop);
0249     ret = rdev->ops->add_mpath(&rdev->wiphy, dev, dst, next_hop);
0250     trace_rdev_return_int(&rdev->wiphy, ret);
0251     return ret;
0252 }
0253
0254 static inline int rdev_del_mpath(struct cfg80211_registered_device *rdev,
0255                  struct net_device *dev, u8 *dst)
0256 {
0257     int ret;
0258     trace_rdev_del_mpath(&rdev->wiphy, dev, dst);
0259     ret = rdev->ops->del_mpath(&rdev->wiphy, dev, dst);
0260     trace_rdev_return_int(&rdev->wiphy, ret);
0261     return ret;
0262 }
0263
0264 static inline int rdev_change_mpath(struct cfg80211_registered_device *rdev,
0265                     struct net_device *dev, u8 *dst,
0266                     u8 *next_hop)
0267 {
0268     int ret;
0269     trace_rdev_change_mpath(&rdev->wiphy, dev, dst, next_hop);
0270     ret = rdev->ops->change_mpath(&rdev->wiphy, dev, dst, next_hop);
0271     trace_rdev_return_int(&rdev->wiphy, ret);
0272     return ret;
0273 }
0274
0275 static inline int rdev_get_mpath(struct cfg80211_registered_device *rdev,
0276                  struct net_device *dev, u8 *dst, u8 *next_hop,
0277                  struct mpath_info *pinfo)
0278 {
0279     int ret;
0280     trace_rdev_get_mpath(&rdev->wiphy, dev, dst, next_hop);
0281     ret = rdev->ops->get_mpath(&rdev->wiphy, dev, dst, next_hop, pinfo);
0282     trace_rdev_return_int_mpath_info(&rdev->wiphy, ret, pinfo);
0283     return ret;
0284
0285 }
0286
0287 static inline int rdev_get_mpp(struct cfg80211_registered_device *rdev,
0288                    struct net_device *dev, u8 *dst, u8 *mpp,
0289                    struct mpath_info *pinfo)
0290 {
0291     int ret;
0292
0293     trace_rdev_get_mpp(&rdev->wiphy, dev, dst, mpp);
0294     ret = rdev->ops->get_mpp(&rdev->wiphy, dev, dst, mpp, pinfo);
0295     trace_rdev_return_int_mpath_info(&rdev->wiphy, ret, pinfo);
0296     return ret;
0297 }
0298
0299 static inline int rdev_dump_mpath(struct cfg80211_registered_device *rdev,
0300                   struct net_device *dev, int idx, u8 *dst,
0301                   u8 *next_hop, struct mpath_info *pinfo)
0302
0303 {
0304     int ret;
0305     trace_rdev_dump_mpath(&rdev->wiphy, dev, idx, dst, next_hop);
0306     ret = rdev->ops->dump_mpath(&rdev->wiphy, dev, idx, dst, next_hop,
0307                     pinfo);
0308     trace_rdev_return_int_mpath_info(&rdev->wiphy, ret, pinfo);
0309     return ret;
0310 }
0311
0312 static inline int rdev_dump_mpp(struct cfg80211_registered_device *rdev,
0313                 struct net_device *dev, int idx, u8 *dst,
0314                 u8 *mpp, struct mpath_info *pinfo)
0315
0316 {
0317     int ret;
0318
0319     trace_rdev_dump_mpp(&rdev->wiphy, dev, idx, dst, mpp);
0320     ret = rdev->ops->dump_mpp(&rdev->wiphy, dev, idx, dst, mpp, pinfo);
0321     trace_rdev_return_int_mpath_info(&rdev->wiphy, ret, pinfo);
0322     return ret;
0323 }
0324
0325 static inline int
0326 rdev_get_mesh_config(struct cfg80211_registered_device *rdev,
0327              struct net_device *dev, struct mesh_config *conf)
0328 {
0329     int ret;
0330     trace_rdev_get_mesh_config(&rdev->wiphy, dev);
0331     ret = rdev->ops->get_mesh_config(&rdev->wiphy, dev, conf);
0332     trace_rdev_return_int_mesh_config(&rdev->wiphy, ret, conf);
0333     return ret;
0334 }
0335
0336 static inline int
0337 rdev_update_mesh_config(struct cfg80211_registered_device *rdev,
0338             struct net_device *dev, u32 mask,
0339             const struct mesh_config *nconf)
0340 {
0341     int ret;
0342     trace_rdev_update_mesh_config(&rdev->wiphy, dev, mask, nconf);
0343     ret = rdev->ops->update_mesh_config(&rdev->wiphy, dev, mask, nconf);
0344     trace_rdev_return_int(&rdev->wiphy, ret);
0345     return ret;
0346 }
0347
0348 static inline int rdev_join_mesh(struct cfg80211_registered_device *rdev,
0349                  struct net_device *dev,
0350                  const struct mesh_config *conf,
0351                  const struct mesh_setup *setup)
0352 {
0353     int ret;
0354     trace_rdev_join_mesh(&rdev->wiphy, dev, conf, setup);
0355     ret = rdev->ops->join_mesh(&rdev->wiphy, dev, conf, setup);
0356     trace_rdev_return_int(&rdev->wiphy, ret);
0357     return ret;
0358 }
0359
0360
0361 static inline int rdev_leave_mesh(struct cfg80211_registered_device *rdev,
0362                   struct net_device *dev)
0363 {
0364     int ret;
0365     trace_rdev_leave_mesh(&rdev->wiphy, dev);
0366     ret = rdev->ops->leave_mesh(&rdev->wiphy, dev);
0367     trace_rdev_return_int(&rdev->wiphy, ret);
0368     return ret;
0369 }
0370
0371 static inline int rdev_join_ocb(struct cfg80211_registered_device *rdev,
0372                 struct net_device *dev,
0373                 struct ocb_setup *setup)
0374 {
0375     int ret;
0376     trace_rdev_join_ocb(&rdev->wiphy, dev, setup);
0377     ret = rdev->ops->join_ocb(&rdev->wiphy, dev, setup);
0378     trace_rdev_return_int(&rdev->wiphy, ret);
0379     return ret;
0380 }
0381
0382 static inline int rdev_leave_ocb(struct cfg80211_registered_device *rdev,
0383                  struct net_device *dev)
0384 {
0385     int ret;
0386     trace_rdev_leave_ocb(&rdev->wiphy, dev);
0387     ret = rdev->ops->leave_ocb(&rdev->wiphy, dev);
0388     trace_rdev_return_int(&rdev->wiphy, ret);
0389     return ret;
0390 }
0391
0392 static inline int rdev_change_bss(struct cfg80211_registered_device *rdev,
0393                   struct net_device *dev,
0394                   struct bss_parameters *params)
0395
0396 {
0397     int ret;
0398     trace_rdev_change_bss(&rdev->wiphy, dev, params);
0399     ret = rdev->ops->change_bss(&rdev->wiphy, dev, params);
0400     trace_rdev_return_int(&rdev->wiphy, ret);
0401     return ret;
0402 }
0403
0404 static inline int rdev_set_txq_params(struct cfg80211_registered_device *rdev,
0405                       struct net_device *dev,
0406                       struct ieee80211_txq_params *params)
0407
0408 {
0409     int ret;
0410     trace_rdev_set_txq_params(&rdev->wiphy, dev, params);
0411     ret = rdev->ops->set_txq_params(&rdev->wiphy, dev, params);
0412     trace_rdev_return_int(&rdev->wiphy, ret);
0413     return ret;
0414 }
0415
0416 static inline int
0417 rdev_libertas_set_mesh_channel(struct cfg80211_registered_device *rdev,
0418                    struct net_device *dev,
0419                    struct ieee80211_channel *chan)
0420 {
0421     int ret;
0422     trace_rdev_libertas_set_mesh_channel(&rdev->wiphy, dev, chan);
0423     ret = rdev->ops->libertas_set_mesh_channel(&rdev->wiphy, dev, chan);
0424     trace_rdev_return_int(&rdev->wiphy, ret);
0425     return ret;
0426 }
0427
0428 static inline int
0429 rdev_set_monitor_channel(struct cfg80211_registered_device *rdev,
0430              struct cfg80211_chan_def *chandef)
0431 {
0432     int ret;
0433     trace_rdev_set_monitor_channel(&rdev->wiphy, chandef);
0434     ret = rdev->ops->set_monitor_channel(&rdev->wiphy, chandef);
0435     trace_rdev_return_int(&rdev->wiphy, ret);
0436     return ret;
0437 }
0438
0439 static inline int rdev_scan(struct cfg80211_registered_device *rdev,
0440                 struct cfg80211_scan_request *request)
0441 {
0442     int ret;
0443     trace_rdev_scan(&rdev->wiphy, request);
0444     ret = rdev->ops->scan(&rdev->wiphy, request);
0445     trace_rdev_return_int(&rdev->wiphy, ret);
0446     return ret;
0447 }
0448
0449 static inline void rdev_abort_scan(struct cfg80211_registered_device *rdev,
0450                    struct wireless_dev *wdev)
0451 {
0452     trace_rdev_abort_scan(&rdev->wiphy, wdev);
0453     rdev->ops->abort_scan(&rdev->wiphy, wdev);
0454     trace_rdev_return_void(&rdev->wiphy);
0455 }
0456
0457 static inline int rdev_auth(struct cfg80211_registered_device *rdev,
0458                 struct net_device *dev,
0459                 struct cfg80211_auth_request *req)
0460 {
0461     int ret;
0462     trace_rdev_auth(&rdev->wiphy, dev, req);
0463     ret = rdev->ops->auth(&rdev->wiphy, dev, req);
0464     trace_rdev_return_int(&rdev->wiphy, ret);
0465     return ret;
0466 }
0467
0468 static inline int rdev_assoc(struct cfg80211_registered_device *rdev,
0469                  struct net_device *dev,
0470                  struct cfg80211_assoc_request *req)
0471 {
0472     int ret;
0473
0474     trace_rdev_assoc(&rdev->wiphy, dev, req);
0475     ret = rdev->ops->assoc(&rdev->wiphy, dev, req);
0476     trace_rdev_return_int(&rdev->wiphy, ret);
0477     return ret;
0478 }
0479
0480 static inline int rdev_deauth(struct cfg80211_registered_device *rdev,
0481                   struct net_device *dev,
0482                   struct cfg80211_deauth_request *req)
0483 {
0484     int ret;
0485     trace_rdev_deauth(&rdev->wiphy, dev, req);
0486     ret = rdev->ops->deauth(&rdev->wiphy, dev, req);
0487     trace_rdev_return_int(&rdev->wiphy, ret);
0488     return ret;
0489 }
0490
0491 static inline int rdev_disassoc(struct cfg80211_registered_device *rdev,
0492                 struct net_device *dev,
0493                 struct cfg80211_disassoc_request *req)
0494 {
0495     int ret;
0496     trace_rdev_disassoc(&rdev->wiphy, dev, req);
0497     ret = rdev->ops->disassoc(&rdev->wiphy, dev, req);
0498     trace_rdev_return_int(&rdev->wiphy, ret);
0499     return ret;
0500 }
0501
0502 static inline int rdev_connect(struct cfg80211_registered_device *rdev,
0503                    struct net_device *dev,
0504                    struct cfg80211_connect_params *sme)
0505 {
0506     int ret;
0507     trace_rdev_connect(&rdev->wiphy, dev, sme);
0508     ret = rdev->ops->connect(&rdev->wiphy, dev, sme);
0509     trace_rdev_return_int(&rdev->wiphy, ret);
0510     return ret;
0511 }
0512
0513 static inline int
0514 rdev_update_connect_params(struct cfg80211_registered_device *rdev,
0515                struct net_device *dev,
0516                struct cfg80211_connect_params *sme, u32 changed)
0517 {
0518     int ret;
0519     trace_rdev_update_connect_params(&rdev->wiphy, dev, sme, changed);
0520     ret = rdev->ops->update_connect_params(&rdev->wiphy, dev, sme, changed);
0521     trace_rdev_return_int(&rdev->wiphy, ret);
0522     return ret;
0523 }
0524
0525 static inline int rdev_disconnect(struct cfg80211_registered_device *rdev,
0526                   struct net_device *dev, u16 reason_code)
0527 {
0528     int ret;
0529     trace_rdev_disconnect(&rdev->wiphy, dev, reason_code);
0530     ret = rdev->ops->disconnect(&rdev->wiphy, dev, reason_code);
0531     trace_rdev_return_int(&rdev->wiphy, ret);
0532     return ret;
0533 }
0534
0535 static inline int rdev_join_ibss(struct cfg80211_registered_device *rdev,
0536                  struct net_device *dev,
0537                  struct cfg80211_ibss_params *params)
0538 {
0539     int ret;
0540     trace_rdev_join_ibss(&rdev->wiphy, dev, params);
0541     ret = rdev->ops->join_ibss(&rdev->wiphy, dev, params);
0542     trace_rdev_return_int(&rdev->wiphy, ret);
0543     return ret;
0544 }
0545
0546 static inline int rdev_leave_ibss(struct cfg80211_registered_device *rdev,
0547                   struct net_device *dev)
0548 {
0549     int ret;
0550     trace_rdev_leave_ibss(&rdev->wiphy, dev);
0551     ret = rdev->ops->leave_ibss(&rdev->wiphy, dev);
0552     trace_rdev_return_int(&rdev->wiphy, ret);
0553     return ret;
0554 }
0555
0556 static inline int
0557 rdev_set_wiphy_params(struct cfg80211_registered_device *rdev, u32 changed)
0558 {
0559     int ret;
0560
0561     if (!rdev->ops->set_wiphy_params)
0562         return -EOPNOTSUPP;
0563
0564     trace_rdev_set_wiphy_params(&rdev->wiphy, changed);
0565     ret = rdev->ops->set_wiphy_params(&rdev->wiphy, changed);
0566     trace_rdev_return_int(&rdev->wiphy, ret);
0567     return ret;
0568 }
0569
0570 static inline int rdev_set_tx_power(struct cfg80211_registered_device *rdev,
0571                     struct wireless_dev *wdev,
0572                     enum nl80211_tx_power_setting type, int mbm)
0573 {
0574     int ret;
0575     trace_rdev_set_tx_power(&rdev->wiphy, wdev, type, mbm);
0576     ret = rdev->ops->set_tx_power(&rdev->wiphy, wdev, type, mbm);
0577     trace_rdev_return_int(&rdev->wiphy, ret);
0578     return ret;
0579 }
0580
0581 static inline int rdev_get_tx_power(struct cfg80211_registered_device *rdev,
0582                     struct wireless_dev *wdev, int *dbm)
0583 {
0584     int ret;
0585     trace_rdev_get_tx_power(&rdev->wiphy, wdev);
0586     ret = rdev->ops->get_tx_power(&rdev->wiphy, wdev, dbm);
0587     trace_rdev_return_int_int(&rdev->wiphy, ret, *dbm);
0588     return ret;
0589 }
0590
0591 static inline int
0592 rdev_set_multicast_to_unicast(struct cfg80211_registered_device *rdev,
0593                   struct net_device *dev,
0594                   const bool enabled)
0595 {
0596     int ret;
0597     trace_rdev_set_multicast_to_unicast(&rdev->wiphy, dev, enabled);
0598     ret = rdev->ops->set_multicast_to_unicast(&rdev->wiphy, dev, enabled);
0599     trace_rdev_return_int(&rdev->wiphy, ret);
0600     return ret;
0601 }
0602
0603 static inline int
0604 rdev_get_txq_stats(struct cfg80211_registered_device *rdev,
0605            struct wireless_dev *wdev,
0606            struct cfg80211_txq_stats *txqstats)
0607 {
0608     int ret;
0609     trace_rdev_get_txq_stats(&rdev->wiphy, wdev);
0610     ret = rdev->ops->get_txq_stats(&rdev->wiphy, wdev, txqstats);
0611     trace_rdev_return_int(&rdev->wiphy, ret);
0612     return ret;
0613 }
0614
0615 static inline void rdev_rfkill_poll(struct cfg80211_registered_device *rdev)
0616 {
0617     trace_rdev_rfkill_poll(&rdev->wiphy);
0618     rdev->ops->rfkill_poll(&rdev->wiphy);
0619     trace_rdev_return_void(&rdev->wiphy);
0620 }
0621
0622
0623 #ifdef CONFIG_NL80211_TESTMODE
0624 static inline int rdev_testmode_cmd(struct cfg80211_registered_device *rdev,
0625                     struct wireless_dev *wdev,
0626                     void *data, int len)
0627 {
0628     int ret;
0629     trace_rdev_testmode_cmd(&rdev->wiphy, wdev);
0630     ret = rdev->ops->testmode_cmd(&rdev->wiphy, wdev, data, len);
0631     trace_rdev_return_int(&rdev->wiphy, ret);
0632     return ret;
0633 }
0634
0635 static inline int rdev_testmode_dump(struct cfg80211_registered_device *rdev,
0636                      struct sk_buff *skb,
0637                      struct netlink_callback *cb, void *data,
0638                      int len)
0639 {
0640     int ret;
0641     trace_rdev_testmode_dump(&rdev->wiphy);
0642     ret = rdev->ops->testmode_dump(&rdev->wiphy, skb, cb, data, len);
0643     trace_rdev_return_int(&rdev->wiphy, ret);
0644     return ret;
0645 }
0646 #endif
0647
0648 static inline int
0649 rdev_set_bitrate_mask(struct cfg80211_registered_device *rdev,
0650               struct net_device *dev, unsigned int link_id,
0651               const u8 *peer,
0652               const struct cfg80211_bitrate_mask *mask)
0653 {
0654     int ret;
0655     trace_rdev_set_bitrate_mask(&rdev->wiphy, dev, link_id, peer, mask);
0656     ret = rdev->ops->set_bitrate_mask(&rdev->wiphy, dev, link_id,
0657                       peer, mask);
0658     trace_rdev_return_int(&rdev->wiphy, ret);
0659     return ret;
0660 }
0661
0662 static inline int rdev_dump_survey(struct cfg80211_registered_device *rdev,
0663                    struct net_device *netdev, int idx,
0664                    struct survey_info *info)
0665 {
0666     int ret;
0667     trace_rdev_dump_survey(&rdev->wiphy, netdev, idx);
0668     ret = rdev->ops->dump_survey(&rdev->wiphy, netdev, idx, info);
0669     if (ret < 0)
0670         trace_rdev_return_int(&rdev->wiphy, ret);
0671     else
0672         trace_rdev_return_int_survey_info(&rdev->wiphy, ret, info);
0673     return ret;
0674 }
0675
0676 static inline int rdev_set_pmksa(struct cfg80211_registered_device *rdev,
0677                  struct net_device *netdev,
0678                  struct cfg80211_pmksa *pmksa)
0679 {
0680     int ret;
0681     trace_rdev_set_pmksa(&rdev->wiphy, netdev, pmksa);
0682     ret = rdev->ops->set_pmksa(&rdev->wiphy, netdev, pmksa);
0683     trace_rdev_return_int(&rdev->wiphy, ret);
0684     return ret;
0685 }
0686
0687 static inline int rdev_del_pmksa(struct cfg80211_registered_device *rdev,
0688                  struct net_device *netdev,
0689                  struct cfg80211_pmksa *pmksa)
0690 {
0691     int ret;
0692     trace_rdev_del_pmksa(&rdev->wiphy, netdev, pmksa);
0693     ret = rdev->ops->del_pmksa(&rdev->wiphy, netdev, pmksa);
0694     trace_rdev_return_int(&rdev->wiphy, ret);
0695     return ret;
0696 }
0697
0698 static inline int rdev_flush_pmksa(struct cfg80211_registered_device *rdev,
0699                    struct net_device *netdev)
0700 {
0701     int ret;
0702     trace_rdev_flush_pmksa(&rdev->wiphy, netdev);
0703     ret = rdev->ops->flush_pmksa(&rdev->wiphy, netdev);
0704     trace_rdev_return_int(&rdev->wiphy, ret);
0705     return ret;
0706 }
0707
0708 static inline int
0709 rdev_remain_on_channel(struct cfg80211_registered_device *rdev,
0710                struct wireless_dev *wdev,
0711                struct ieee80211_channel *chan,
0712                unsigned int duration, u64 *cookie)
0713 {
0714     int ret;
0715     trace_rdev_remain_on_channel(&rdev->wiphy, wdev, chan, duration);
0716     ret = rdev->ops->remain_on_channel(&rdev->wiphy, wdev, chan,
0717                        duration, cookie);
0718     trace_rdev_return_int_cookie(&rdev->wiphy, ret, *cookie);
0719     return ret;
0720 }
0721
0722 static inline int
0723 rdev_cancel_remain_on_channel(struct cfg80211_registered_device *rdev,
0724                   struct wireless_dev *wdev, u64 cookie)
0725 {
0726     int ret;
0727     trace_rdev_cancel_remain_on_channel(&rdev->wiphy, wdev, cookie);
0728     ret = rdev->ops->cancel_remain_on_channel(&rdev->wiphy, wdev, cookie);
0729     trace_rdev_return_int(&rdev->wiphy, ret);
0730     return ret;
0731 }
0732
0733 static inline int rdev_mgmt_tx(struct cfg80211_registered_device *rdev,
0734                    struct wireless_dev *wdev,
0735                    struct cfg80211_mgmt_tx_params *params,
0736                    u64 *cookie)
0737 {
0738     int ret;
0739     trace_rdev_mgmt_tx(&rdev->wiphy, wdev, params);
0740     ret = rdev->ops->mgmt_tx(&rdev->wiphy, wdev, params, cookie);
0741     trace_rdev_return_int_cookie(&rdev->wiphy, ret, *cookie);
0742     return ret;
0743 }
0744
0745 static inline int rdev_tx_control_port(struct cfg80211_registered_device *rdev,
0746                        struct net_device *dev,
0747                        const void *buf, size_t len,
0748                        const u8 *dest, __be16 proto,
0749                        const bool noencrypt, int link,
0750                        u64 *cookie)
0751 {
0752     int ret;
0753     trace_rdev_tx_control_port(&rdev->wiphy, dev, buf, len,
0754                    dest, proto, noencrypt, link);
0755     ret = rdev->ops->tx_control_port(&rdev->wiphy, dev, buf, len,
0756                      dest, proto, noencrypt, link, cookie);
0757     if (cookie)
0758         trace_rdev_return_int_cookie(&rdev->wiphy, ret, *cookie);
0759     else
0760         trace_rdev_return_int(&rdev->wiphy, ret);
0761     return ret;
0762 }
0763
0764 static inline int
0765 rdev_mgmt_tx_cancel_wait(struct cfg80211_registered_device *rdev,
0766              struct wireless_dev *wdev, u64 cookie)
0767 {
0768     int ret;
0769     trace_rdev_mgmt_tx_cancel_wait(&rdev->wiphy, wdev, cookie);
0770     ret = rdev->ops->mgmt_tx_cancel_wait(&rdev->wiphy, wdev, cookie);
0771     trace_rdev_return_int(&rdev->wiphy, ret);
0772     return ret;
0773 }
0774
0775 static inline int rdev_set_power_mgmt(struct cfg80211_registered_device *rdev,
0776                       struct net_device *dev, bool enabled,
0777                       int timeout)
0778 {
0779     int ret;
0780     trace_rdev_set_power_mgmt(&rdev->wiphy, dev, enabled, timeout);
0781     ret = rdev->ops->set_power_mgmt(&rdev->wiphy, dev, enabled, timeout);
0782     trace_rdev_return_int(&rdev->wiphy, ret);
0783     return ret;
0784 }
0785
0786 static inline int
0787 rdev_set_cqm_rssi_config(struct cfg80211_registered_device *rdev,
0788              struct net_device *dev, s32 rssi_thold, u32 rssi_hyst)
0789 {
0790     int ret;
0791     trace_rdev_set_cqm_rssi_config(&rdev->wiphy, dev, rssi_thold,
0792                        rssi_hyst);
0793     ret = rdev->ops->set_cqm_rssi_config(&rdev->wiphy, dev, rssi_thold,
0794                        rssi_hyst);
0795     trace_rdev_return_int(&rdev->wiphy, ret);
0796     return ret;
0797 }
0798
0799 static inline int
0800 rdev_set_cqm_rssi_range_config(struct cfg80211_registered_device *rdev,
0801                    struct net_device *dev, s32 low, s32 high)
0802 {
0803     int ret;
0804     trace_rdev_set_cqm_rssi_range_config(&rdev->wiphy, dev, low, high);
0805     ret = rdev->ops->set_cqm_rssi_range_config(&rdev->wiphy, dev,
0806                            low, high);
0807     trace_rdev_return_int(&rdev->wiphy, ret);
0808     return ret;
0809 }
0810
0811 static inline int
0812 rdev_set_cqm_txe_config(struct cfg80211_registered_device *rdev,
0813             struct net_device *dev, u32 rate, u32 pkts, u32 intvl)
0814 {
0815     int ret;
0816     trace_rdev_set_cqm_txe_config(&rdev->wiphy, dev, rate, pkts, intvl);
0817     ret = rdev->ops->set_cqm_txe_config(&rdev->wiphy, dev, rate, pkts,
0818                          intvl);
0819     trace_rdev_return_int(&rdev->wiphy, ret);
0820     return ret;
0821 }
0822
0823 static inline void
0824 rdev_update_mgmt_frame_registrations(struct cfg80211_registered_device *rdev,
0825                      struct wireless_dev *wdev,
0826                      struct mgmt_frame_regs *upd)
0827 {
0828     might_sleep();
0829
0830     trace_rdev_update_mgmt_frame_registrations(&rdev->wiphy, wdev, upd);
0831     if (rdev->ops->update_mgmt_frame_registrations)
0832         rdev->ops->update_mgmt_frame_registrations(&rdev->wiphy, wdev,
0833                                upd);
0834     trace_rdev_return_void(&rdev->wiphy);
0835 }
0836
0837 static inline int rdev_set_antenna(struct cfg80211_registered_device *rdev,
0838                    u32 tx_ant, u32 rx_ant)
0839 {
0840     int ret;
0841     trace_rdev_set_antenna(&rdev->wiphy, tx_ant, rx_ant);
0842     ret = rdev->ops->set_antenna(&rdev->wiphy, tx_ant, rx_ant);
0843     trace_rdev_return_int(&rdev->wiphy, ret);
0844     return ret;
0845 }
0846
0847 static inline int rdev_get_antenna(struct cfg80211_registered_device *rdev,
0848                    u32 *tx_ant, u32 *rx_ant)
0849 {
0850     int ret;
0851     trace_rdev_get_antenna(&rdev->wiphy);
0852     ret = rdev->ops->get_antenna(&rdev->wiphy, tx_ant, rx_ant);
0853     if (ret)
0854         trace_rdev_return_int(&rdev->wiphy, ret);
0855     else
0856         trace_rdev_return_int_tx_rx(&rdev->wiphy, ret, *tx_ant,
0857                         *rx_ant);
0858     return ret;
0859 }
0860
0861 static inline int
0862 rdev_sched_scan_start(struct cfg80211_registered_device *rdev,
0863               struct net_device *dev,
0864               struct cfg80211_sched_scan_request *request)
0865 {
0866     int ret;
0867     trace_rdev_sched_scan_start(&rdev->wiphy, dev, request->reqid);
0868     ret = rdev->ops->sched_scan_start(&rdev->wiphy, dev, request);
0869     trace_rdev_return_int(&rdev->wiphy, ret);
0870     return ret;
0871 }
0872
0873 static inline int rdev_sched_scan_stop(struct cfg80211_registered_device *rdev,
0874                        struct net_device *dev, u64 reqid)
0875 {
0876     int ret;
0877     trace_rdev_sched_scan_stop(&rdev->wiphy, dev, reqid);
0878     ret = rdev->ops->sched_scan_stop(&rdev->wiphy, dev, reqid);
0879     trace_rdev_return_int(&rdev->wiphy, ret);
0880     return ret;
0881 }
0882
0883 static inline int rdev_set_rekey_data(struct cfg80211_registered_device *rdev,
0884                       struct net_device *dev,
0885                       struct cfg80211_gtk_rekey_data *data)
0886 {
0887     int ret;
0888     trace_rdev_set_rekey_data(&rdev->wiphy, dev);
0889     ret = rdev->ops->set_rekey_data(&rdev->wiphy, dev, data);
0890     trace_rdev_return_int(&rdev->wiphy, ret);
0891     return ret;
0892 }
0893
0894 static inline int rdev_tdls_mgmt(struct cfg80211_registered_device *rdev,
0895                  struct net_device *dev, u8 *peer,
0896                  u8 action_code, u8 dialog_token,
0897                  u16 status_code, u32 peer_capability,
0898                  bool initiator, const u8 *buf, size_t len)
0899 {
0900     int ret;
0901     trace_rdev_tdls_mgmt(&rdev->wiphy, dev, peer, action_code,
0902                  dialog_token, status_code, peer_capability,
0903                  initiator, buf, len);
0904     ret = rdev->ops->tdls_mgmt(&rdev->wiphy, dev, peer, action_code,
0905                    dialog_token, status_code, peer_capability,
0906                    initiator, buf, len);
0907     trace_rdev_return_int(&rdev->wiphy, ret);
0908     return ret;
0909 }
0910
0911 static inline int rdev_tdls_oper(struct cfg80211_registered_device *rdev,
0912                  struct net_device *dev, u8 *peer,
0913                  enum nl80211_tdls_operation oper)
0914 {
0915     int ret;
0916     trace_rdev_tdls_oper(&rdev->wiphy, dev, peer, oper);
0917     ret = rdev->ops->tdls_oper(&rdev->wiphy, dev, peer, oper);
0918     trace_rdev_return_int(&rdev->wiphy, ret);
0919     return ret;
0920 }
0921
0922 static inline int rdev_probe_client(struct cfg80211_registered_device *rdev,
0923                     struct net_device *dev, const u8 *peer,
0924                     u64 *cookie)
0925 {
0926     int ret;
0927     trace_rdev_probe_client(&rdev->wiphy, dev, peer);
0928     ret = rdev->ops->probe_client(&rdev->wiphy, dev, peer, cookie);
0929     trace_rdev_return_int_cookie(&rdev->wiphy, ret, *cookie);
0930     return ret;
0931 }
0932
0933 static inline int rdev_set_noack_map(struct cfg80211_registered_device *rdev,
0934                      struct net_device *dev, u16 noack_map)
0935 {
0936     int ret;
0937     trace_rdev_set_noack_map(&rdev->wiphy, dev, noack_map);
0938     ret = rdev->ops->set_noack_map(&rdev->wiphy, dev, noack_map);
0939     trace_rdev_return_int(&rdev->wiphy, ret);
0940     return ret;
0941 }
0942
0943 static inline int
0944 rdev_get_channel(struct cfg80211_registered_device *rdev,
0945          struct wireless_dev *wdev,
0946          unsigned int link_id,
0947          struct cfg80211_chan_def *chandef)
0948 {
0949     int ret;
0950
0951     trace_rdev_get_channel(&rdev->wiphy, wdev, link_id);
0952     ret = rdev->ops->get_channel(&rdev->wiphy, wdev, link_id, chandef);
0953     trace_rdev_return_chandef(&rdev->wiphy, ret, chandef);
0954
0955     return ret;
0956 }
0957
0958 static inline int rdev_start_p2p_device(struct cfg80211_registered_device *rdev,
0959                     struct wireless_dev *wdev)
0960 {
0961     int ret;
0962
0963     trace_rdev_start_p2p_device(&rdev->wiphy, wdev);
0964     ret = rdev->ops->start_p2p_device(&rdev->wiphy, wdev);
0965     trace_rdev_return_int(&rdev->wiphy, ret);
0966     return ret;
0967 }
0968
0969 static inline void rdev_stop_p2p_device(struct cfg80211_registered_device *rdev,
0970                     struct wireless_dev *wdev)
0971 {
0972     trace_rdev_stop_p2p_device(&rdev->wiphy, wdev);
0973     rdev->ops->stop_p2p_device(&rdev->wiphy, wdev);
0974     trace_rdev_return_void(&rdev->wiphy);
0975 }
0976
0977 static inline int rdev_start_nan(struct cfg80211_registered_device *rdev,
0978                  struct wireless_dev *wdev,
0979                  struct cfg80211_nan_conf *conf)
0980 {
0981     int ret;
0982
0983     trace_rdev_start_nan(&rdev->wiphy, wdev, conf);
0984     ret = rdev->ops->start_nan(&rdev->wiphy, wdev, conf);
0985     trace_rdev_return_int(&rdev->wiphy, ret);
0986     return ret;
0987 }
0988
0989 static inline void rdev_stop_nan(struct cfg80211_registered_device *rdev,
0990                  struct wireless_dev *wdev)
0991 {
0992     trace_rdev_stop_nan(&rdev->wiphy, wdev);
0993     rdev->ops->stop_nan(&rdev->wiphy, wdev);
0994     trace_rdev_return_void(&rdev->wiphy);
0995 }
0996
0997 static inline int
0998 rdev_add_nan_func(struct cfg80211_registered_device *rdev,
0999           struct wireless_dev *wdev,
1000           struct cfg80211_nan_func *nan_func)
1001 {
1002     int ret;
1003
1004     trace_rdev_add_nan_func(&rdev->wiphy, wdev, nan_func);
1005     ret = rdev->ops->add_nan_func(&rdev->wiphy, wdev, nan_func);
1006     trace_rdev_return_int(&rdev->wiphy, ret);
1007     return ret;
1008 }
1009
1010 static inline void rdev_del_nan_func(struct cfg80211_registered_device *rdev,
1011                     struct wireless_dev *wdev, u64 cookie)
1012 {
1013     trace_rdev_del_nan_func(&rdev->wiphy, wdev, cookie);
1014     rdev->ops->del_nan_func(&rdev->wiphy, wdev, cookie);
1015     trace_rdev_return_void(&rdev->wiphy);
1016 }
1017
1018 static inline int
1019 rdev_nan_change_conf(struct cfg80211_registered_device *rdev,
1020              struct wireless_dev *wdev,
1021              struct cfg80211_nan_conf *conf, u32 changes)
1022 {
1023     int ret;
1024
1025     trace_rdev_nan_change_conf(&rdev->wiphy, wdev, conf, changes);
1026     if (rdev->ops->nan_change_conf)
1027         ret = rdev->ops->nan_change_conf(&rdev->wiphy, wdev, conf,
1028                          changes);
1029     else
1030         ret = -ENOTSUPP;
1031     trace_rdev_return_int(&rdev->wiphy, ret);
1032     return ret;
1033 }
1034
1035 static inline int rdev_set_mac_acl(struct cfg80211_registered_device *rdev,
1036                    struct net_device *dev,
1037                    struct cfg80211_acl_data *params)
1038 {
1039     int ret;
1040
1041     trace_rdev_set_mac_acl(&rdev->wiphy, dev, params);
1042     ret = rdev->ops->set_mac_acl(&rdev->wiphy, dev, params);
1043     trace_rdev_return_int(&rdev->wiphy, ret);
1044     return ret;
1045 }
1046
1047 static inline int rdev_update_ft_ies(struct cfg80211_registered_device *rdev,
1048                      struct net_device *dev,
1049                      struct cfg80211_update_ft_ies_params *ftie)
1050 {
1051     int ret;
1052
1053     trace_rdev_update_ft_ies(&rdev->wiphy, dev, ftie);
1054     ret = rdev->ops->update_ft_ies(&rdev->wiphy, dev, ftie);
1055     trace_rdev_return_int(&rdev->wiphy, ret);
1056     return ret;
1057 }
1058
1059 static inline int rdev_crit_proto_start(struct cfg80211_registered_device *rdev,
1060                     struct wireless_dev *wdev,
1061                     enum nl80211_crit_proto_id protocol,
1062                     u16 duration)
1063 {
1064     int ret;
1065
1066     trace_rdev_crit_proto_start(&rdev->wiphy, wdev, protocol, duration);
1067     ret = rdev->ops->crit_proto_start(&rdev->wiphy, wdev,
1068                       protocol, duration);
1069     trace_rdev_return_int(&rdev->wiphy, ret);
1070     return ret;
1071 }
1072
1073 static inline void rdev_crit_proto_stop(struct cfg80211_registered_device *rdev,
1074                        struct wireless_dev *wdev)
1075 {
1076     trace_rdev_crit_proto_stop(&rdev->wiphy, wdev);
1077     rdev->ops->crit_proto_stop(&rdev->wiphy, wdev);
1078     trace_rdev_return_void(&rdev->wiphy);
1079 }
1080
1081 static inline int rdev_channel_switch(struct cfg80211_registered_device *rdev,
1082                       struct net_device *dev,
1083                       struct cfg80211_csa_settings *params)
1084 {
1085     int ret;
1086
1087     trace_rdev_channel_switch(&rdev->wiphy, dev, params);
1088     ret = rdev->ops->channel_switch(&rdev->wiphy, dev, params);
1089     trace_rdev_return_int(&rdev->wiphy, ret);
1090     return ret;
1091 }
1092
1093 static inline int rdev_set_qos_map(struct cfg80211_registered_device *rdev,
1094                    struct net_device *dev,
1095                    struct cfg80211_qos_map *qos_map)
1096 {
1097     int ret = -EOPNOTSUPP;
1098
1099     if (rdev->ops->set_qos_map) {
1100         trace_rdev_set_qos_map(&rdev->wiphy, dev, qos_map);
1101         ret = rdev->ops->set_qos_map(&rdev->wiphy, dev, qos_map);
1102         trace_rdev_return_int(&rdev->wiphy, ret);
1103     }
1104
1105     return ret;
1106 }
1107
1108 static inline int
1109 rdev_set_ap_chanwidth(struct cfg80211_registered_device *rdev,
1110               struct net_device *dev,
1111               unsigned int link_id,
1112               struct cfg80211_chan_def *chandef)
1113 {
1114     int ret;
1115
1116     trace_rdev_set_ap_chanwidth(&rdev->wiphy, dev, link_id, chandef);
1117     ret = rdev->ops->set_ap_chanwidth(&rdev->wiphy, dev, link_id, chandef);
1118     trace_rdev_return_int(&rdev->wiphy, ret);
1119
1120     return ret;
1121 }
1122
1123 static inline int
1124 rdev_add_tx_ts(struct cfg80211_registered_device *rdev,
1125            struct net_device *dev, u8 tsid, const u8 *peer,
1126            u8 user_prio, u16 admitted_time)
1127 {
1128     int ret = -EOPNOTSUPP;
1129
1130     trace_rdev_add_tx_ts(&rdev->wiphy, dev, tsid, peer,
1131                  user_prio, admitted_time);
1132     if (rdev->ops->add_tx_ts)
1133         ret = rdev->ops->add_tx_ts(&rdev->wiphy, dev, tsid, peer,
1134                        user_prio, admitted_time);
1135     trace_rdev_return_int(&rdev->wiphy, ret);
1136
1137     return ret;
1138 }
1139
1140 static inline int
1141 rdev_del_tx_ts(struct cfg80211_registered_device *rdev,
1142            struct net_device *dev, u8 tsid, const u8 *peer)
1143 {
1144     int ret = -EOPNOTSUPP;
1145
1146     trace_rdev_del_tx_ts(&rdev->wiphy, dev, tsid, peer);
1147     if (rdev->ops->del_tx_ts)
1148         ret = rdev->ops->del_tx_ts(&rdev->wiphy, dev, tsid, peer);
1149     trace_rdev_return_int(&rdev->wiphy, ret);
1150
1151     return ret;
1152 }
1153
1154 static inline int
1155 rdev_tdls_channel_switch(struct cfg80211_registered_device *rdev,
1156              struct net_device *dev, const u8 *addr,
1157              u8 oper_class, struct cfg80211_chan_def *chandef)
1158 {
1159     int ret;
1160
1161     trace_rdev_tdls_channel_switch(&rdev->wiphy, dev, addr, oper_class,
1162                        chandef);
1163     ret = rdev->ops->tdls_channel_switch(&rdev->wiphy, dev, addr,
1164                          oper_class, chandef);
1165     trace_rdev_return_int(&rdev->wiphy, ret);
1166     return ret;
1167 }
1168
1169 static inline void
1170 rdev_tdls_cancel_channel_switch(struct cfg80211_registered_device *rdev,
1171                 struct net_device *dev, const u8 *addr)
1172 {
1173     trace_rdev_tdls_cancel_channel_switch(&rdev->wiphy, dev, addr);
1174     rdev->ops->tdls_cancel_channel_switch(&rdev->wiphy, dev, addr);
1175     trace_rdev_return_void(&rdev->wiphy);
1176 }
1177
1178 static inline int
1179 rdev_start_radar_detection(struct cfg80211_registered_device *rdev,
1180                struct net_device *dev,
1181                struct cfg80211_chan_def *chandef,
1182                u32 cac_time_ms)
1183 {
1184     int ret = -ENOTSUPP;
1185
1186     trace_rdev_start_radar_detection(&rdev->wiphy, dev, chandef,
1187                      cac_time_ms);
1188     if (rdev->ops->start_radar_detection)
1189         ret = rdev->ops->start_radar_detection(&rdev->wiphy, dev,
1190                                chandef, cac_time_ms);
1191     trace_rdev_return_int(&rdev->wiphy, ret);
1192     return ret;
1193 }
1194
1195 static inline void
1196 rdev_end_cac(struct cfg80211_registered_device *rdev,
1197          struct net_device *dev)
1198 {
1199     trace_rdev_end_cac(&rdev->wiphy, dev);
1200     if (rdev->ops->end_cac)
1201         rdev->ops->end_cac(&rdev->wiphy, dev);
1202     trace_rdev_return_void(&rdev->wiphy);
1203 }
1204
1205 static inline int
1206 rdev_set_mcast_rate(struct cfg80211_registered_device *rdev,
1207             struct net_device *dev,
1208             int mcast_rate[NUM_NL80211_BANDS])
1209 {
1210     int ret = -ENOTSUPP;
1211
1212     trace_rdev_set_mcast_rate(&rdev->wiphy, dev, mcast_rate);
1213     if (rdev->ops->set_mcast_rate)
1214         ret = rdev->ops->set_mcast_rate(&rdev->wiphy, dev, mcast_rate);
1215     trace_rdev_return_int(&rdev->wiphy, ret);
1216     return ret;
1217 }
1218
1219 static inline int
1220 rdev_set_coalesce(struct cfg80211_registered_device *rdev,
1221           struct cfg80211_coalesce *coalesce)
1222 {
1223     int ret = -ENOTSUPP;
1224
1225     trace_rdev_set_coalesce(&rdev->wiphy, coalesce);
1226     if (rdev->ops->set_coalesce)
1227         ret = rdev->ops->set_coalesce(&rdev->wiphy, coalesce);
1228     trace_rdev_return_int(&rdev->wiphy, ret);
1229     return ret;
1230 }
1231
1232 static inline int rdev_set_pmk(struct cfg80211_registered_device *rdev,
1233                    struct net_device *dev,
1234                    struct cfg80211_pmk_conf *pmk_conf)
1235 {
1236     int ret = -EOPNOTSUPP;
1237
1238     trace_rdev_set_pmk(&rdev->wiphy, dev, pmk_conf);
1239     if (rdev->ops->set_pmk)
1240         ret = rdev->ops->set_pmk(&rdev->wiphy, dev, pmk_conf);
1241     trace_rdev_return_int(&rdev->wiphy, ret);
1242     return ret;
1243 }
1244
1245 static inline int rdev_del_pmk(struct cfg80211_registered_device *rdev,
1246                    struct net_device *dev, const u8 *aa)
1247 {
1248     int ret = -EOPNOTSUPP;
1249
1250     trace_rdev_del_pmk(&rdev->wiphy, dev, aa);
1251     if (rdev->ops->del_pmk)
1252         ret = rdev->ops->del_pmk(&rdev->wiphy, dev, aa);
1253     trace_rdev_return_int(&rdev->wiphy, ret);
1254     return ret;
1255 }
1256
1257 static inline int
1258 rdev_external_auth(struct cfg80211_registered_device *rdev,
1259            struct net_device *dev,
1260            struct cfg80211_external_auth_params *params)
1261 {
1262     int ret = -EOPNOTSUPP;
1263
1264     trace_rdev_external_auth(&rdev->wiphy, dev, params);
1265     if (rdev->ops->external_auth)
1266         ret = rdev->ops->external_auth(&rdev->wiphy, dev, params);
1267     trace_rdev_return_int(&rdev->wiphy, ret);
1268     return ret;
1269 }
1270
1271 static inline int
1272 rdev_get_ftm_responder_stats(struct cfg80211_registered_device *rdev,
1273                  struct net_device *dev,
1274                  struct cfg80211_ftm_responder_stats *ftm_stats)
1275 {
1276     int ret = -EOPNOTSUPP;
1277
1278     trace_rdev_get_ftm_responder_stats(&rdev->wiphy, dev, ftm_stats);
1279     if (rdev->ops->get_ftm_responder_stats)
1280         ret = rdev->ops->get_ftm_responder_stats(&rdev->wiphy, dev,
1281                             ftm_stats);
1282     trace_rdev_return_int(&rdev->wiphy, ret);
1283     return ret;
1284 }
1285
1286 static inline int
1287 rdev_start_pmsr(struct cfg80211_registered_device *rdev,
1288         struct wireless_dev *wdev,
1289         struct cfg80211_pmsr_request *request)
1290 {
1291     int ret = -EOPNOTSUPP;
1292
1293     trace_rdev_start_pmsr(&rdev->wiphy, wdev, request->cookie);
1294     if (rdev->ops->start_pmsr)
1295         ret = rdev->ops->start_pmsr(&rdev->wiphy, wdev, request);
1296     trace_rdev_return_int(&rdev->wiphy, ret);
1297     return ret;
1298 }
1299
1300 static inline void
1301 rdev_abort_pmsr(struct cfg80211_registered_device *rdev,
1302         struct wireless_dev *wdev,
1303         struct cfg80211_pmsr_request *request)
1304 {
1305     trace_rdev_abort_pmsr(&rdev->wiphy, wdev, request->cookie);
1306     if (rdev->ops->abort_pmsr)
1307         rdev->ops->abort_pmsr(&rdev->wiphy, wdev, request);
1308     trace_rdev_return_void(&rdev->wiphy);
1309 }
1310
1311 static inline int rdev_update_owe_info(struct cfg80211_registered_device *rdev,
1312                        struct net_device *dev,
1313                        struct cfg80211_update_owe_info *oweinfo)
1314 {
1315     int ret = -EOPNOTSUPP;
1316
1317     trace_rdev_update_owe_info(&rdev->wiphy, dev, oweinfo);
1318     if (rdev->ops->update_owe_info)
1319         ret = rdev->ops->update_owe_info(&rdev->wiphy, dev, oweinfo);
1320     trace_rdev_return_int(&rdev->wiphy, ret);
1321     return ret;
1322 }
1323
1324 static inline int
1325 rdev_probe_mesh_link(struct cfg80211_registered_device *rdev,
1326              struct net_device *dev, const u8 *dest,
1327              const void *buf, size_t len)
1328 {
1329     int ret;
1330
1331     trace_rdev_probe_mesh_link(&rdev->wiphy, dev, dest, buf, len);
1332     ret = rdev->ops->probe_mesh_link(&rdev->wiphy, dev, buf, len);
1333     trace_rdev_return_int(&rdev->wiphy, ret);
1334     return ret;
1335 }
1336
1337 static inline int rdev_set_tid_config(struct cfg80211_registered_device *rdev,
1338                       struct net_device *dev,
1339                       struct cfg80211_tid_config *tid_conf)
1340 {
1341     int ret;
1342
1343     trace_rdev_set_tid_config(&rdev->wiphy, dev, tid_conf);
1344     ret = rdev->ops->set_tid_config(&rdev->wiphy, dev, tid_conf);
1345     trace_rdev_return_int(&rdev->wiphy, ret);
1346     return ret;
1347 }
1348
1349 static inline int rdev_reset_tid_config(struct cfg80211_registered_device *rdev,
1350                     struct net_device *dev, const u8 *peer,
1351                     u8 tids)
1352 {
1353     int ret;
1354
1355     trace_rdev_reset_tid_config(&rdev->wiphy, dev, peer, tids);
1356     ret = rdev->ops->reset_tid_config(&rdev->wiphy, dev, peer, tids);
1357     trace_rdev_return_int(&rdev->wiphy, ret);
1358     return ret;
1359 }
1360
1361 static inline int rdev_set_sar_specs(struct cfg80211_registered_device *rdev,
1362                      struct cfg80211_sar_specs *sar)
1363 {
1364     int ret;
1365
1366     trace_rdev_set_sar_specs(&rdev->wiphy, sar);
1367     ret = rdev->ops->set_sar_specs(&rdev->wiphy, sar);
1368     trace_rdev_return_int(&rdev->wiphy, ret);
1369
1370     return ret;
1371 }
1372
1373 static inline int rdev_color_change(struct cfg80211_registered_device *rdev,
1374                     struct net_device *dev,
1375                     struct cfg80211_color_change_settings *params)
1376 {
1377     int ret;
1378
1379     trace_rdev_color_change(&rdev->wiphy, dev, params);
1380     ret = rdev->ops->color_change(&rdev->wiphy, dev, params);
1381     trace_rdev_return_int(&rdev->wiphy, ret);
1382
1383     return ret;
1384 }
1385
1386 static inline int
1387 rdev_set_fils_aad(struct cfg80211_registered_device *rdev,
1388           struct net_device *dev, struct cfg80211_fils_aad *fils_aad)
1389 {
1390     int ret = -EOPNOTSUPP;
1391
1392     trace_rdev_set_fils_aad(&rdev->wiphy, dev, fils_aad);
1393     if (rdev->ops->set_fils_aad)
1394         ret = rdev->ops->set_fils_aad(&rdev->wiphy, dev, fils_aad);
1395     trace_rdev_return_int(&rdev->wiphy, ret);
1396
1397     return ret;
1398 }
1399
1400 static inline int
1401 rdev_set_radar_background(struct cfg80211_registered_device *rdev,
1402               struct cfg80211_chan_def *chandef)
1403 {
1404     struct wiphy *wiphy = &rdev->wiphy;
1405     int ret;
1406
1407     if (!rdev->ops->set_radar_background)
1408         return -EOPNOTSUPP;
1409
1410     trace_rdev_set_radar_background(wiphy, chandef);
1411     ret = rdev->ops->set_radar_background(wiphy, chandef);
1412     trace_rdev_return_int(wiphy, ret);
1413
1414     return ret;
1415 }
1416
1417 static inline int
1418 rdev_add_intf_link(struct cfg80211_registered_device *rdev,
1419            struct wireless_dev *wdev,
1420            unsigned int link_id)
1421 {
1422     int ret = 0;
1423
1424     trace_rdev_add_intf_link(&rdev->wiphy, wdev, link_id);
1425     if (rdev->ops->add_intf_link)
1426         ret = rdev->ops->add_intf_link(&rdev->wiphy, wdev, link_id);
1427     trace_rdev_return_int(&rdev->wiphy, ret);
1428
1429     return ret;
1430 }
1431
1432 static inline void
1433 rdev_del_intf_link(struct cfg80211_registered_device *rdev,
1434            struct wireless_dev *wdev,
1435            unsigned int link_id)
1436 {
1437     trace_rdev_del_intf_link(&rdev->wiphy, wdev, link_id);
1438     if (rdev->ops->add_intf_link)
1439         rdev->ops->add_intf_link(&rdev->wiphy, wdev, link_id);
1440     trace_rdev_return_void(&rdev->wiphy);
1441 }
1442
1443 static inline int
1444 rdev_add_link_station(struct cfg80211_registered_device *rdev,
1445               struct net_device *dev,
1446               struct link_station_parameters *params)
1447 {
1448     int ret;
1449
1450     if (!rdev->ops->add_link_station)
1451         return -EOPNOTSUPP;
1452
1453     trace_rdev_add_link_station(&rdev->wiphy, dev, params);
1454     ret = rdev->ops->add_link_station(&rdev->wiphy, dev, params);
1455     trace_rdev_return_int(&rdev->wiphy, ret);
1456     return ret;
1457 }
1458
1459 static inline int
1460 rdev_mod_link_station(struct cfg80211_registered_device *rdev,
1461               struct net_device *dev,
1462               struct link_station_parameters *params)
1463 {
1464     int ret;
1465
1466     if (!rdev->ops->mod_link_station)
1467         return -EOPNOTSUPP;
1468
1469     trace_rdev_mod_link_station(&rdev->wiphy, dev, params);
1470     ret = rdev->ops->mod_link_station(&rdev->wiphy, dev, params);
1471     trace_rdev_return_int(&rdev->wiphy, ret);
1472     return ret;
1473 }
1474
1475 static inline int
1476 rdev_del_link_station(struct cfg80211_registered_device *rdev,
1477               struct net_device *dev,
1478               struct link_station_del_parameters *params)
1479 {
1480     int ret;
1481
1482     if (!rdev->ops->del_link_station)
1483         return -EOPNOTSUPP;
1484
1485     trace_rdev_del_link_station(&rdev->wiphy, dev, params);
1486     ret = rdev->ops->del_link_station(&rdev->wiphy, dev, params);
1487     trace_rdev_return_int(&rdev->wiphy, ret);
1488     return ret;
1489 }
1490
1491 #endif /* __CFG80211_RDEV_OPS */