/**	 * set_param - Set driver configuration parameters	 * @priv: private driver interface data from init()	 * @param: driver specific configuration parameters	 *	 * Returns: 0 on success, -1 on failure	 *	 * Optional handler for notifying driver interface about configuration	 * parameters (driver_param).	 */	int (*set_param)(void *priv, const char *param);	/**	 * set_countermeasures - Enable/disable TKIP countermeasures	 * @priv: private driver interface data	 * @enabled: 1 = countermeasures enabled, 0 = disabled	 *	 * Returns: 0 on success, -1 on failure	 *	 * Configure TKIP countermeasures. When these are enabled, the driver	 * should drop all received and queued frames that are using TKIP.	 */	int (*set_countermeasures)(void *priv, int enabled);	/**	 * set_drop_unencrypted - Enable/disable unencrypted frame filtering	 * @priv: private driver interface data	 * @enabled: 1 = unencrypted Tx/Rx frames will be dropped, 0 = disabled	 *	 * Returns: 0 on success, -1 on failure	 *	 * Configure the driver to drop all non-EAPOL frames (both receive and	 * transmit paths). Unencrypted EAPOL frames (ethertype 0x888e) must	 * still be allowed for key negotiation.	 */	int (*set_drop_unencrypted)(void *priv, int enabled);	/**	 * scan - Request the driver to initiate scan	 * @priv: private driver interface data	 * @ssid: specific SSID to scan for (ProbeReq) or %NULL to scan for	 *	all SSIDs (either active scan with broadcast SSID or passive	 *	scan	 * @ssid_len: length of the SSID	 *	 * Returns: 0 on success, -1 on failure	 *	 * Once the scan results are ready, the driver should report scan	 * results event for wpa_supplicant which will eventually request the	 * results with wpa_driver_get_scan_results().	 */	int (*scan)(void *priv, const u8 *ssid, size_t ssid_len);	/**	 * get_scan_results - Fetch the latest scan results	 * @priv: private driver interface data	 * @results: pointer to buffer for scan results	 * @max_size: maximum number of entries (buffer size)	 *	 * Returns: Number of scan result entries used on success, -1 on	 * failure	 *	 * If scan results include more than max_size BSSes, max_size will be	 * returned and the remaining entries will not be included in the	 * buffer.	 */	int (*get_scan_results)(void *priv,				struct wpa_scan_result *results,				size_t max_size);	/**	 * deauthenticate - Request driver to deauthenticate	 * @priv: private driver interface data	 * @addr: peer address (BSSID of the AP)	 * @reason_code: 16-bit reason code to be sent in the deauthentication	 *	frame	 *	 * Returns: 0 on success, -1 on failure	 */	int (*deauthenticate)(void *priv, const u8 *addr, int reason_code);	/**	 * disassociate - Request driver to disassociate	 * @priv: private driver interface data	 * @addr: peer address (BSSID of the AP)	 * @reason_code: 16-bit reason code to be sent in the disassociation	 *	frame	 *	 * Returns: 0 on success, -1 on failure	 */	int (*disassociate)(void *priv, const u8 *addr, int reason_code);	/**	 * associate - Request driver to associate	 * @priv: private driver interface data	 * @params: association parameters	 *	 * Returns: 0 on success, -1 on failure	 */	int (*associate)(void *priv,			 struct wpa_driver_associate_params *params);	/**	 * set_auth_alg - Set IEEE 802.11 authentication algorithm	 * @priv: private driver interface data	 * @auth_alg: bit field of AUTH_ALG_*	 *	 * If the driver supports more than one authentication algorithm at the	 * same time, it should configure all supported algorithms. If not, one	 * algorithm needs to be selected arbitrarily. Open System	 * authentication should be ok for most cases and it is recommended to	 * be used if other options are not supported. Static WEP configuration	 * may also use Shared Key authentication and LEAP requires its own	 * algorithm number. For LEAP, user can make sure that only one	 * algorithm is used at a time by configuring LEAP as the only	 * supported EAP method. This information is also available in	 * associate() params, so set_auth_alg may not be needed in case of	 * most drivers.	 *	 * Returns: 0 on success, -1 on failure	 */	int (*set_auth_alg)(void *priv, int auth_alg);	/**	 * add_pmkid - Add PMKSA cache entry to the driver	 * @priv: private driver interface data	 * @bssid: BSSID for the PMKSA cache entry	 * @pmkid: PMKID for the PMKSA cache entry	 *	 * Returns: 0 on success, -1 on failure	 *	 * This function is called when a new PMK is received, as a result of	 * either normal authentication or RSN pre-authentication.	 *	 * If the driver generates RSN IE, i.e., it does not use wpa_ie in	 * associate(), add_pmkid() can be used to add new PMKSA cache entries	 * in the driver. If the driver uses wpa_ie from wpa_supplicant, this	 * driver_ops function does not need to be implemented. Likewise, if	 * the driver does not support WPA, this function is not needed.	 */	int (*add_pmkid)(void *priv, const u8 *bssid, const u8 *pmkid);	/**	 * remove_pmkid - Remove PMKSA cache entry to the driver	 * @priv: private driver interface data	 * @bssid: BSSID for the PMKSA cache entry	 * @pmkid: PMKID for the PMKSA cache entry	 *	 * Returns: 0 on success, -1 on failure	 *	 * This function is called when the supplicant drops a PMKSA cache	 * entry for any reason.	 *	 * If the driver generates RSN IE, i.e., it does not use wpa_ie in	 * associate(), remove_pmkid() can be used to synchronize PMKSA caches	 * between the driver and wpa_supplicant. If the driver uses wpa_ie	 * from wpa_supplicant, this driver_ops function does not need to be	 * implemented. Likewise, if the driver does not support WPA, this	 * function is not needed.	 */	int (*remove_pmkid)(void *priv, const u8 *bssid, const u8 *pmkid);	/**	 * flush_pmkid - Flush PMKSA cache	 * @priv: private driver interface data	 *	 * Returns: 0 on success, -1 on failure	 *	 * This function is called when the supplicant drops all PMKSA cache	 * entries for any reason.	 *	 * If the driver generates RSN IE, i.e., it does not use wpa_ie in	 * associate(), remove_pmkid() can be used to synchronize PMKSA caches	 * between the driver and wpa_supplicant. If the driver uses wpa_ie	 * from wpa_supplicant, this driver_ops function does not need to be	 * implemented. Likewise, if the driver does not support WPA, this	 * function is not needed.	 */	int (*flush_pmkid)(void *priv);	/**	 * flush_pmkid - Flush PMKSA cache	 * @priv: private driver interface data	 *	 * Returns: 0 on success, -1 on failure	 *	 * Get driver/firmware/hardware capabilities.	 */	int (*get_capa)(void *priv, struct wpa_driver_capa *capa);	/**	 * poll - Poll driver for association information	 * @priv: private driver interface data	 *	 * This is an option callback that can be used when the driver does not	 * provide event mechanism for association events. This is called when	 * receiving WPA EAPOL-Key messages that require association	 * information. The driver interface is supposed to generate associnfo	 * event before returning from this callback function. In addition, the	 * driver interface should generate an association event after having	 * sent out associnfo.	 */	void (*poll)(void *priv);	/**	 * get_ifname - Get interface name	 * @priv: private driver interface data	 *	 * Returns: Pointer to the interface name. This can differ from the	 * interface name used in init() call.	 *	 * This optional function can be used to allow the driver interface to	 * replace the interface name with something else, e.g., based on an	 * interface mapping from a more descriptive name.	 */	const char * (*get_ifname)(void *priv);	/**	 * get_mac_addr - Get own MAC address	 * @priv: private driver interface data	 *	 * Returns: Pointer to own MAC address or %NULL on failure	 *	 * This optional function can be used to get the own MAC address of the	 * device from the driver interface code. This is only needed if the	 * l2_packet implementation for the OS does not provide easy access to	 * a MAC address. */	const u8 * (*get_mac_addr)(void *priv);	/**	 * send_eapol - Optional function for sending EAPOL packets	 * @priv: private driver interface data	 * @dest: Destination MAC address	 * @proto: Ethertype	 * @data: EAPOL packet starting with IEEE 802.1X header	 * @data_len: Size of the EAPOL packet	 *	 * Returns: 0 on success, -1 on failure	 *	 * This optional function can be used to override l2_packet operations	 * with driver specific functionality. If this function pointer is set,	 * l2_packet module is not used at all and the driver interface code is	 * responsible for receiving and sending all EAPOL packets. The	 * received EAPOL packets are sent to core code by calling	 * wpa_supplicant_rx_eapol(). The driver interface is required to	 * implement get_mac_addr() handler if send_eapol() is used.	 */	int (*send_eapol)(void *priv, const u8 *dest, u16 proto,			  const u8 *data, size_t data_len);	/**	 * set_operstate - Sets device operating state to DORMANT or UP	 * @priv: private driver interface data	 * @state: 0 = dormant, 1 = up	 * Returns: 0 on success, -1 on failure	 *	 * This is an optional function that can be used on operating systems	 * that support a concept of controlling network device state from user	 * space applications. This function, if set, gets called with	 * state = 1 when authentication has been completed and with state = 0	 * when connection is lost.	 */	int (*set_operstate)(void *priv, int state);	/**	 * mlme_setprotection - MLME-SETPROTECTION.request primitive	 * @priv: Private driver interface data	 * @addr: Address of the station for which to set protection (may be	 * %NULL for group keys)	 * @protect_type: MLME_SETPROTECTION_PROTECT_TYPE_*	 * @key_type: MLME_SETPROTECTION_KEY_TYPE_*	 * Returns: 0 on success, -1 on failure	 *	 * This is an optional function that can be used to set the driver to	 * require protection for Tx and/or Rx frames. This uses the layer	 * interface defined in IEEE 802.11i-2004 clause 10.3.22.1	 * (MLME-SETPROTECTION.request). Many drivers do not use explicit	 * set protection operation; instead, they set protection implicitly	 * based on configured keys.	 */	int (*mlme_setprotection)(void *priv, const u8 *addr, int protect_type,				  int key_type);	/**	 * get_hw_feature_data - Get hardware support data (channels and rates)	 * @priv: Private driver interface data	 * @num_modes: Variable for returning the number of returned modes	 * flags: Variable for returning hardware feature flags	 * Returns: Pointer to allocated hardware data on success or %NULL on	 * failure. Caller is responsible for freeing this.	 *	 * This function is only needed for drivers that export MLME	 * (management frame processing) to wpa_supplicant.	 */	struct wpa_hw_modes * (*get_hw_feature_data)(void *priv,						     u16 *num_modes,						     u16 *flags);	/**	 * set_channel - Set channel	 * @priv: Private driver interface data	 * @phymode: WPA_MODE_IEEE80211B, ..	 * @chan: IEEE 802.11 channel number	 * @freq: Frequency of the channel in MHz	 * Returns: 0 on success, -1 on failure	 *	 * This function is only needed for drivers that export MLME	 * (management frame processing) to wpa_supplicant.	 */	int (*set_channel)(void *priv, wpa_hw_mode phymode, int chan,			   int freq);	/**	 * set_ssid - Set SSID	 * @priv: Private driver interface data	 * @ssid: SSID	 * @ssid_len: SSID length	 * Returns: 0 on success, -1 on failure	 *	 * This function is only needed for drivers that export MLME	 * (management frame processing) to wpa_supplicant.	 */	int (*set_ssid)(void *priv, const u8 *ssid, size_t ssid_len);	/**	 * set_bssid - Set BSSID	 * @priv: Private driver interface data	 * @bssid: BSSID	 * Returns: 0 on success, -1 on failure	 *	 * This function is only needed for drivers that export MLME	 * (management frame processing) to wpa_supplicant.	 */	int (*set_bssid)(void *priv, const u8 *bssid);	/**	 * send_mlme - Send management frame from MLME	 * @priv: Private driver interface data	 * @data: IEEE 802.11 management frame with IEEE 802.11 header	 * @data_len: Size of the management frame	 * Returns: 0 on success, -1 on failure	 *	 * This function is only needed for drivers that export MLME	 * (management frame processing) to wpa_supplicant.	 */	int (*send_mlme)(void *priv, const u8 *data, size_t data_len);	/**	 * mlme_add_sta - Add a STA entry into the driver/netstack	 * @priv: Private driver interface data	 * @addr: MAC address of the STA (e.g., BSSID of the AP)	 * @supp_rates: Supported rate set (from (Re)AssocResp); in IEEE 802.11	 * format (one octet per rate, 1 = 0.5 Mbps)	 * @supp_rates_len: Number of entries in supp_rates	 * Returns: 0 on success, -1 on failure	 *	 * This function is only needed for drivers that export MLME	 * (management frame processing) to wpa_supplicant. When the MLME code	 * completes association with an AP, this function is called to	 * configure the driver/netstack with a STA entry for data frame	 * processing (TX rate control, encryption/decryption).	 */	 int (*mlme_add_sta)(void *priv, const u8 *addr, const u8 *supp_rates,			     size_t supp_rates_len);	/**	 * mlme_remove_sta - Remove a STA entry from the driver/netstack	 * @priv: Private driver interface data	 * @addr: MAC address of the STA (e.g., BSSID of the AP)	 * Returns: 0 on success, -1 on failure	 *	 * This function is only needed for drivers that export MLME	 * (management frame processing) to wpa_supplicant.	 */	 int (*mlme_remove_sta)(void *priv, const u8 *addr);};#endif /* DRIVER_H */