// SPDX-License-Identifier: GPL-2.0-only/* * Linux WiMAX * Initialization, addition and removal of wimax devices * * Copyright (C) 2005-2006 Intel Corporation <linux-wimax@intel.com> * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com> * * This implements: * *   - basic life cycle of 'struct wimax_dev' [wimax_dev_*()]; on *     addition/registration initialize all subfields and allocate *     generic netlink resources for user space communication. On *     removal/unregistration, undo all that. * *   - device state machine [wimax_state_change()] and support to send *     reports to user space when the state changes *     [wimax_gnl_re_state_change*()]. * * See include/net/wimax.h for rationales and design. * * ROADMAP * * [__]wimax_state_change()     Called by drivers to update device's state *   wimax_gnl_re_state_change_alloc() *   wimax_gnl_re_state_change_send() * * wimax_dev_init()	        Init a device * wimax_dev_add()              Register *   wimax_rfkill_add() *   wimax_gnl_add()            Register all the generic netlink resources. *   wimax_id_table_add() * wimax_dev_rm()               Unregister *   wimax_id_table_rm() *   wimax_gnl_rm() *   wimax_rfkill_rm() */#include <linux/device.h>#include <linux/gfp.h>#include <net/genetlink.h>#include <linux/netdevice.h>#include <linux/wimax.h>#include <linux/module.h>#include "wimax-internal.h"  #define D_SUBMODULE stack#include "debug-levels.h" static char wimax_debug_params[128];module_param_string(debug, wimax_debug_params, sizeof(wimax_debug_params),		    0644);MODULE_PARM_DESC(debug,		 "String of space-separated NAME:VALUE pairs, where NAMEs "		 "are the different debug submodules and VALUE are the "		 "initial debug value to set."); /* * Authoritative source for the RE_STATE_CHANGE attribute policy * * We don't really use it here, but /me likes to keep the definition * close to where the data is generated. *//*static const struct nla_policy wimax_gnl_re_status_change[WIMAX_GNL_ATTR_MAX + 1] = {	[WIMAX_GNL_STCH_STATE_OLD] = { .type = NLA_U8 },	[WIMAX_GNL_STCH_STATE_NEW] = { .type = NLA_U8 },};*/  /* * Allocate a Report State Change message * * @header: save it, you need it for _send() * * Creates and fills a basic state change message; different code * paths can then add more attributes to the message as needed. * * Use wimax_gnl_re_state_change_send() to send the returned skb. * * Returns: skb with the genl message if ok, IS_ERR() ptr on error *     with an errno code. */staticstruct sk_buff *wimax_gnl_re_state_change_alloc(	struct wimax_dev *wimax_dev,	enum wimax_st new_state, enum wimax_st old_state,	void **header){	int result;	struct device *dev = wimax_dev_to_dev(wimax_dev);	void *data;	struct sk_buff *report_skb; 	d_fnstart(3, dev, "(wimax_dev %p new_state %u old_state %u)\n",		  wimax_dev, new_state, old_state);	result = -ENOMEM;	report_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);	if (report_skb == NULL) {		dev_err(dev, "RE_STCH: can't create message\n");		goto error_new;	}	/* FIXME: sending a group ID as the seq is wrong */	data = genlmsg_put(report_skb, 0, wimax_gnl_family.mcgrp_offset,			   &wimax_gnl_family, 0, WIMAX_GNL_RE_STATE_CHANGE);	if (data == NULL) {		dev_err(dev, "RE_STCH: can't put data into message\n");		goto error_put;	}	*header = data; 	result = nla_put_u8(report_skb, WIMAX_GNL_STCH_STATE_OLD, old_state);	if (result < 0) {		dev_err(dev, "RE_STCH: Error adding OLD attr: %d\n", result);		goto error_put;	}	result = nla_put_u8(report_skb, WIMAX_GNL_STCH_STATE_NEW, new_state);	if (result < 0) {		dev_err(dev, "RE_STCH: Error adding NEW attr: %d\n", result);		goto error_put;	}	result = nla_put_u32(report_skb, WIMAX_GNL_STCH_IFIDX,			     wimax_dev->net_dev->ifindex);	if (result < 0) {		dev_err(dev, "RE_STCH: Error adding IFINDEX attribute\n");		goto error_put;	}	d_fnend(3, dev, "(wimax_dev %p new_state %u old_state %u) = %p\n",		wimax_dev, new_state, old_state, report_skb);	return report_skb; error_put:	nlmsg_free(report_skb);error_new:	d_fnend(3, dev, "(wimax_dev %p new_state %u old_state %u) = %d\n",		wimax_dev, new_state, old_state, result);	return ERR_PTR(result);}  /* * Send a Report State Change message (as created with _alloc). * * @report_skb: as returned by wimax_gnl_re_state_change_alloc() * @header: as returned by wimax_gnl_re_state_change_alloc() * * Returns: 0 if ok, < 0 errno code on error. * * If the message is  NULL, pretend it didn't happen. */staticint wimax_gnl_re_state_change_send(	struct wimax_dev *wimax_dev, struct sk_buff *report_skb,	void *header){	int result = 0;	struct device *dev = wimax_dev_to_dev(wimax_dev);	d_fnstart(3, dev, "(wimax_dev %p report_skb %p)\n",		  wimax_dev, report_skb);	if (report_skb == NULL) {		result = -ENOMEM;		goto out;	}	genlmsg_end(report_skb, header);	genlmsg_multicast(&wimax_gnl_family, report_skb, 0, 0, GFP_KERNEL);out:	d_fnend(3, dev, "(wimax_dev %p report_skb %p) = %d\n",		wimax_dev, report_skb, result);	return result;}  staticvoid __check_new_state(enum wimax_st old_state, enum wimax_st new_state,		       unsigned int allowed_states_bm){	if (WARN_ON(((1 << new_state) & allowed_states_bm) == 0)) {		pr_err("SW BUG! Forbidden state change %u -> %u\n",		       old_state, new_state);	}}  /* * Set the current state of a WiMAX device [unlocking version of * wimax_state_change(). */void __wimax_state_change(struct wimax_dev *wimax_dev, enum wimax_st new_state){	struct device *dev = wimax_dev_to_dev(wimax_dev);	enum wimax_st old_state = wimax_dev->state;	struct sk_buff *stch_skb;	void *header; 	d_fnstart(3, dev, "(wimax_dev %p new_state %u [old %u])\n",		  wimax_dev, new_state, old_state); 	if (WARN_ON(new_state >= __WIMAX_ST_INVALID)) {		dev_err(dev, "SW BUG: requesting invalid state %u\n",			new_state);		goto out;	}	if (old_state == new_state)		goto out;	header = NULL;	/* gcc complains? can't grok why */	stch_skb = wimax_gnl_re_state_change_alloc(		wimax_dev, new_state, old_state, &header); 	/* Verify the state transition and do exit-from-state actions */	switch (old_state) {	case __WIMAX_ST_NULL:		__check_new_state(old_state, new_state,				  1 << WIMAX_ST_DOWN);		break;	case WIMAX_ST_DOWN:		__check_new_state(old_state, new_state,				  1 << __WIMAX_ST_QUIESCING				  | 1 << WIMAX_ST_UNINITIALIZED				  | 1 << WIMAX_ST_RADIO_OFF);		break;	case __WIMAX_ST_QUIESCING:		__check_new_state(old_state, new_state, 1 << WIMAX_ST_DOWN);		break;	case WIMAX_ST_UNINITIALIZED:		__check_new_state(old_state, new_state,				  1 << __WIMAX_ST_QUIESCING				  | 1 << WIMAX_ST_RADIO_OFF);		break;	case WIMAX_ST_RADIO_OFF:		__check_new_state(old_state, new_state,				  1 << __WIMAX_ST_QUIESCING				  | 1 << WIMAX_ST_READY);		break;	case WIMAX_ST_READY:		__check_new_state(old_state, new_state,				  1 << __WIMAX_ST_QUIESCING				  | 1 << WIMAX_ST_RADIO_OFF				  | 1 << WIMAX_ST_SCANNING				  | 1 << WIMAX_ST_CONNECTING				  | 1 << WIMAX_ST_CONNECTED);		break;	case WIMAX_ST_SCANNING:		__check_new_state(old_state, new_state,				  1 << __WIMAX_ST_QUIESCING				  | 1 << WIMAX_ST_RADIO_OFF				  | 1 << WIMAX_ST_READY				  | 1 << WIMAX_ST_CONNECTING				  | 1 << WIMAX_ST_CONNECTED);		break;	case WIMAX_ST_CONNECTING:		__check_new_state(old_state, new_state,				  1 << __WIMAX_ST_QUIESCING				  | 1 << WIMAX_ST_RADIO_OFF				  | 1 << WIMAX_ST_READY				  | 1 << WIMAX_ST_SCANNING				  | 1 << WIMAX_ST_CONNECTED);		break;	case WIMAX_ST_CONNECTED:		__check_new_state(old_state, new_state,				  1 << __WIMAX_ST_QUIESCING				  | 1 << WIMAX_ST_RADIO_OFF				  | 1 << WIMAX_ST_READY);		netif_tx_disable(wimax_dev->net_dev);		netif_carrier_off(wimax_dev->net_dev);		break;	case __WIMAX_ST_INVALID:	default:		dev_err(dev, "SW BUG: wimax_dev %p is in unknown state %u\n",			wimax_dev, wimax_dev->state);		WARN_ON(1);		goto out;	} 	/* Execute the actions of entry to the new state */	switch (new_state) {	case __WIMAX_ST_NULL:		dev_err(dev, "SW BUG: wimax_dev %p entering NULL state "			"from %u\n", wimax_dev, wimax_dev->state);		WARN_ON(1);		/* Nobody can enter this state */		break;	case WIMAX_ST_DOWN:		break;	case __WIMAX_ST_QUIESCING:		break;	case WIMAX_ST_UNINITIALIZED:		break;	case WIMAX_ST_RADIO_OFF:		break;	case WIMAX_ST_READY:		break;	case WIMAX_ST_SCANNING:		break;	case WIMAX_ST_CONNECTING:		break;	case WIMAX_ST_CONNECTED:		netif_carrier_on(wimax_dev->net_dev);		netif_wake_queue(wimax_dev->net_dev);		break;	case __WIMAX_ST_INVALID:	default:		BUG();	}	__wimax_state_set(wimax_dev, new_state);	if (!IS_ERR(stch_skb))		wimax_gnl_re_state_change_send(wimax_dev, stch_skb, header);out:	d_fnend(3, dev, "(wimax_dev %p new_state %u [old %u]) = void\n",		wimax_dev, new_state, old_state);}  /** * wimax_state_change - Set the current state of a WiMAX device * * @wimax_dev: WiMAX device descriptor (properly referenced) * @new_state: New state to switch to * * This implements the state changes for the wimax devices. It will * * - verify that the state transition is legal (for now it'll just *   print a warning if not) according to the table in *   linux/wimax.h's documentation for 'enum wimax_st'. * * - perform the actions needed for leaving the current state and *   whichever are needed for entering the new state. * * - issue a report to user space indicating the new state (and an *   optional payload with information about the new state). * * NOTE: @wimax_dev must be locked */void wimax_state_change(struct wimax_dev *wimax_dev, enum wimax_st new_state){	/*	 * A driver cannot take the wimax_dev out of the	 * __WIMAX_ST_NULL state unless by calling wimax_dev_add(). If	 * the wimax_dev's state is still NULL, we ignore any request	 * to change its state because it means it hasn't been yet	 * registered.	 *	 * There is no need to complain about it, as routines that	 * call this might be shared from different code paths that	 * are called before or after wimax_dev_add() has done its	 * job.	 */	mutex_lock(&wimax_dev->mutex);	if (wimax_dev->state > __WIMAX_ST_NULL)		__wimax_state_change(wimax_dev, new_state);	mutex_unlock(&wimax_dev->mutex);}EXPORT_SYMBOL_GPL(wimax_state_change);  /** * wimax_state_get() - Return the current state of a WiMAX device * * @wimax_dev: WiMAX device descriptor * * Returns: Current state of the device according to its driver. */enum wimax_st wimax_state_get(struct wimax_dev *wimax_dev){	enum wimax_st state;	mutex_lock(&wimax_dev->mutex);	state = wimax_dev->state;	mutex_unlock(&wimax_dev->mutex);	return state;}EXPORT_SYMBOL_GPL(wimax_state_get);  /** * wimax_dev_init - initialize a newly allocated instance * * @wimax_dev: WiMAX device descriptor to initialize. * * Initializes fields of a freshly allocated @wimax_dev instance. This * function assumes that after allocation, the memory occupied by * @wimax_dev was zeroed. */void wimax_dev_init(struct wimax_dev *wimax_dev){	INIT_LIST_HEAD(&wimax_dev->id_table_node);	__wimax_state_set(wimax_dev, __WIMAX_ST_NULL);	mutex_init(&wimax_dev->mutex);	mutex_init(&wimax_dev->mutex_reset);}EXPORT_SYMBOL_GPL(wimax_dev_init); static const struct nla_policy wimax_gnl_policy[WIMAX_GNL_ATTR_MAX + 1] = {	[WIMAX_GNL_RESET_IFIDX] = { .type = NLA_U32, },	[WIMAX_GNL_RFKILL_IFIDX] = { .type = NLA_U32, },	[WIMAX_GNL_RFKILL_STATE] = {		.type = NLA_U32		/* enum wimax_rf_state */	},	[WIMAX_GNL_STGET_IFIDX] = { .type = NLA_U32, },	[WIMAX_GNL_MSG_IFIDX] = { .type = NLA_U32, },	[WIMAX_GNL_MSG_DATA] = {		.type = NLA_UNSPEC,	/* libnl doesn't grok BINARY yet */	},}; static const struct genl_ops wimax_gnl_ops[] = {	{		.cmd = WIMAX_GNL_OP_MSG_FROM_USER,		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,		.flags = GENL_ADMIN_PERM,		.doit = wimax_gnl_doit_msg_from_user,	},	{		.cmd = WIMAX_GNL_OP_RESET,		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,		.flags = GENL_ADMIN_PERM,		.doit = wimax_gnl_doit_reset,	},	{		.cmd = WIMAX_GNL_OP_RFKILL,		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,		.flags = GENL_ADMIN_PERM,		.doit = wimax_gnl_doit_rfkill,	},	{		.cmd = WIMAX_GNL_OP_STATE_GET,		.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,		.flags = GENL_ADMIN_PERM,		.doit = wimax_gnl_doit_state_get,	},};  staticsize_t wimax_addr_scnprint(char *addr_str, size_t addr_str_size,			   unsigned char *addr, size_t addr_len){	unsigned int cnt, total; 	for (total = cnt = 0; cnt < addr_len; cnt++)		total += scnprintf(addr_str + total, addr_str_size - total,				   "%02x%c", addr[cnt],				   cnt == addr_len - 1 ? '\0' : ':');	return total;}  /** * wimax_dev_add - Register a new WiMAX device * * @wimax_dev: WiMAX device descriptor (as embedded in your @net_dev's *     priv data). You must have called wimax_dev_init() on it before. * * @net_dev: net device the @wimax_dev is associated with. The *     function expects SET_NETDEV_DEV() and register_netdev() were *     already called on it. * * Registers the new WiMAX device, sets up the user-kernel control * interface (generic netlink) and common WiMAX infrastructure. * * Note that the parts that will allow interaction with user space are * setup at the very end, when the rest is in place, as once that * happens, the driver might get user space control requests via * netlink or from debugfs that might translate into calls into * wimax_dev->op_*(). */int wimax_dev_add(struct wimax_dev *wimax_dev, struct net_device *net_dev){	int result;	struct device *dev = net_dev->dev.parent;	char addr_str[32]; 	d_fnstart(3, dev, "(wimax_dev %p net_dev %p)\n", wimax_dev, net_dev); 	/* Do the RFKILL setup before locking, as RFKILL will call	 * into our functions.	 */	wimax_dev->net_dev = net_dev;	result = wimax_rfkill_add(wimax_dev);	if (result < 0)		goto error_rfkill_add; 	/* Set up user-space interaction */	mutex_lock(&wimax_dev->mutex);	wimax_id_table_add(wimax_dev);	wimax_debugfs_add(wimax_dev); 	__wimax_state_set(wimax_dev, WIMAX_ST_DOWN);	mutex_unlock(&wimax_dev->mutex); 	wimax_addr_scnprint(addr_str, sizeof(addr_str),			    net_dev->dev_addr, net_dev->addr_len);	dev_err(dev, "WiMAX interface %s (%s) ready\n",		net_dev->name, addr_str);	d_fnend(3, dev, "(wimax_dev %p net_dev %p) = 0\n", wimax_dev, net_dev);	return 0; error_rfkill_add:	d_fnend(3, dev, "(wimax_dev %p net_dev %p) = %d\n",		wimax_dev, net_dev, result);	return result;}

Lines 1–500 of 609. Load more