/*
   * Linux WiMAX
   * RF-kill framework integration
   *
   *
   * Copyright (C) 2008 Intel Corporation <linux-wimax@intel.com>
   * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public License version
   * 2 as published by the Free Software Foundation.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   * 02110-1301, USA.
   *
   *
   * This integrates into the Linux Kernel rfkill susbystem so that the
   * drivers just have to do the bare minimal work, which is providing a
   * method to set the software RF-Kill switch and to report changes in
   * the software and hardware switch status.
   *
   * A non-polled generic rfkill device is embedded into the WiMAX
   * subsystem's representation of a device.
   *

   * FIXME: Need polled support? Let drivers provide a poll routine
   *	  and hand it to rfkill ops then?

   *
   * All device drivers have to do is after wimax_dev_init(), call
   * wimax_report_rfkill_hw() and wimax_report_rfkill_sw() to update
   * initial state and then every time it changes. See wimax.h:struct
   * wimax_dev for more information.
   *
   * ROADMAP
   *
   * wimax_gnl_doit_rfkill()      User space calling wimax_rfkill()
   *   wimax_rfkill()             Kernel calling wimax_rfkill()
   *     __wimax_rf_toggle_radio()
   *

   * wimax_rfkill_set_radio_block()  RF-Kill subsystem calling

   *   __wimax_rf_toggle_radio()
   *
   * __wimax_rf_toggle_radio()
   *   wimax_dev->op_rfkill_sw_toggle() Driver backend
   *   __wimax_state_change()
   *
   * wimax_report_rfkill_sw()     Driver reports state change
   *   __wimax_state_change()
   *
   * wimax_report_rfkill_hw()     Driver reports state change
   *   __wimax_state_change()
   *
   * wimax_rfkill_add()           Initialize/shutdown rfkill support
   * wimax_rfkill_rm()            [called by wimax_dev_add/rm()]
   */
  
  #include <net/wimax.h>
  #include <net/genetlink.h>
  #include <linux/wimax.h>
  #include <linux/security.h>
  #include <linux/rfkill.h>

  #include <linux/export.h>

  #include "wimax-internal.h"
  
  #define D_SUBMODULE op_rfkill
  #include "debug-levels.h"

  /**
   * wimax_report_rfkill_hw - Reports changes in the hardware RF switch
   *
   * @wimax_dev: WiMAX device descriptor
   *
   * @state: New state of the RF Kill switch. %WIMAX_RF_ON radio on,
   *     %WIMAX_RF_OFF radio off.
   *
   * When the device detects a change in the state of thehardware RF
   * switch, it must call this function to let the WiMAX kernel stack
   * know that the state has changed so it can be properly propagated.
   *
   * The WiMAX stack caches the state (the driver doesn't need to). As
   * well, as the change is propagated it will come back as a request to
   * change the software state to mirror the hardware state.
   *
   * If the device doesn't have a hardware kill switch, just report
   * it on initialization as always on (%WIMAX_RF_ON, radio on).
   */
  void wimax_report_rfkill_hw(struct wimax_dev *wimax_dev,
  			    enum wimax_rf_state state)
  {
  	int result;
  	struct device *dev = wimax_dev_to_dev(wimax_dev);
  	enum wimax_st wimax_state;

  
  	d_fnstart(3, dev, "(wimax_dev %p state %u)
  ", wimax_dev, state);
  	BUG_ON(state == WIMAX_RF_QUERY);
  	BUG_ON(state != WIMAX_RF_ON && state != WIMAX_RF_OFF);
  
  	mutex_lock(&wimax_dev->mutex);
  	result = wimax_dev_is_ready(wimax_dev);
  	if (result < 0)
  		goto error_not_ready;
  
  	if (state != wimax_dev->rf_hw) {
  		wimax_dev->rf_hw = state;

  		if (wimax_dev->rf_hw == WIMAX_RF_ON &&
  		    wimax_dev->rf_sw == WIMAX_RF_ON)

  			wimax_state = WIMAX_ST_READY;
  		else
  			wimax_state = WIMAX_ST_RADIO_OFF;

  		result = rfkill_set_hw_state(wimax_dev->rfkill,
  					     state == WIMAX_RF_OFF);

  		__wimax_state_change(wimax_dev, wimax_state);

  	}
  error_not_ready:
  	mutex_unlock(&wimax_dev->mutex);
  	d_fnend(3, dev, "(wimax_dev %p state %u) = void [%d]
  ",
  		wimax_dev, state, result);
  }
  EXPORT_SYMBOL_GPL(wimax_report_rfkill_hw);
  
  
  /**
   * wimax_report_rfkill_sw - Reports changes in the software RF switch
   *
   * @wimax_dev: WiMAX device descriptor
   *
   * @state: New state of the RF kill switch. %WIMAX_RF_ON radio on,
   *     %WIMAX_RF_OFF radio off.
   *
   * Reports changes in the software RF switch state to the the WiMAX
   * stack.
   *
   * The main use is during initialization, so the driver can query the
   * device for its current software radio kill switch state and feed it
   * to the system.
   *
   * On the side, the device does not change the software state by
   * itself. In practice, this can happen, as the device might decide to
   * switch (in software) the radio off for different reasons.
   */
  void wimax_report_rfkill_sw(struct wimax_dev *wimax_dev,
  			    enum wimax_rf_state state)
  {
  	int result;
  	struct device *dev = wimax_dev_to_dev(wimax_dev);
  	enum wimax_st wimax_state;
  
  	d_fnstart(3, dev, "(wimax_dev %p state %u)
  ", wimax_dev, state);
  	BUG_ON(state == WIMAX_RF_QUERY);
  	BUG_ON(state != WIMAX_RF_ON && state != WIMAX_RF_OFF);
  
  	mutex_lock(&wimax_dev->mutex);
  	result = wimax_dev_is_ready(wimax_dev);
  	if (result < 0)
  		goto error_not_ready;
  
  	if (state != wimax_dev->rf_sw) {
  		wimax_dev->rf_sw = state;

  		if (wimax_dev->rf_hw == WIMAX_RF_ON &&
  		    wimax_dev->rf_sw == WIMAX_RF_ON)

  			wimax_state = WIMAX_ST_READY;
  		else
  			wimax_state = WIMAX_ST_RADIO_OFF;
  		__wimax_state_change(wimax_dev, wimax_state);

  		rfkill_set_sw_state(wimax_dev->rfkill, state == WIMAX_RF_OFF);

  	}
  error_not_ready:
  	mutex_unlock(&wimax_dev->mutex);
  	d_fnend(3, dev, "(wimax_dev %p state %u) = void [%d]
  ",
  		wimax_dev, state, result);
  }
  EXPORT_SYMBOL_GPL(wimax_report_rfkill_sw);
  
  
  /*
   * Callback for the RF Kill toggle operation
   *
   * This function is called by:
   *
   * - The rfkill subsystem when the RF-Kill key is pressed in the
   *   hardware and the driver notifies through
   *   wimax_report_rfkill_hw(). The rfkill subsystem ends up calling back
   *   here so the software RF Kill switch state is changed to reflect
   *   the hardware switch state.
   *
   * - When the user sets the state through sysfs' rfkill/state file
   *
   * - When the user calls wimax_rfkill().
   *
   * This call blocks!
   *
   * WARNING! When we call rfkill_unregister(), this will be called with
   * state 0!
   *
   * WARNING: wimax_dev must be locked
   */
  static
  int __wimax_rf_toggle_radio(struct wimax_dev *wimax_dev,
  			    enum wimax_rf_state state)
  {
  	int result = 0;
  	struct device *dev = wimax_dev_to_dev(wimax_dev);
  	enum wimax_st wimax_state;
  
  	might_sleep();
  	d_fnstart(3, dev, "(wimax_dev %p state %u)
  ", wimax_dev, state);
  	if (wimax_dev->rf_sw == state)
  		goto out_no_change;
  	if (wimax_dev->op_rfkill_sw_toggle != NULL)
  		result = wimax_dev->op_rfkill_sw_toggle(wimax_dev, state);
  	else if (state == WIMAX_RF_OFF)	/* No op? can't turn off */
  		result = -ENXIO;
  	else				/* No op? can turn on */
  		result = 0;		/* should never happen tho */
  	if (result >= 0) {
  		result = 0;
  		wimax_dev->rf_sw = state;
  		wimax_state = state == WIMAX_RF_ON ?
  			WIMAX_ST_READY : WIMAX_ST_RADIO_OFF;
  		__wimax_state_change(wimax_dev, wimax_state);
  	}
  out_no_change:
  	d_fnend(3, dev, "(wimax_dev %p state %u) = %d
  ",
  		wimax_dev, state, result);
  	return result;
  }
  
  
  /*
   * Translate from rfkill state to wimax state
   *
   * NOTE: Special state handling rules here
   *
   *     Just pretend the call didn't happen if we are in a state where
   *     we know for sure it cannot be handled (WIMAX_ST_DOWN or
   *     __WIMAX_ST_QUIESCING). rfkill() needs it to register and
   *     unregister, as it will run this path.
   *
   * NOTE: This call will block until the operation is completed.
   */

  static int wimax_rfkill_set_radio_block(void *data, bool blocked)

  {
  	int result;
  	struct wimax_dev *wimax_dev = data;
  	struct device *dev = wimax_dev_to_dev(wimax_dev);
  	enum wimax_rf_state rf_state;

  	d_fnstart(3, dev, "(wimax_dev %p blocked %u)
  ", wimax_dev, blocked);
  	rf_state = WIMAX_RF_ON;
  	if (blocked)

  		rf_state = WIMAX_RF_OFF;

  	mutex_lock(&wimax_dev->mutex);
  	if (wimax_dev->state <= __WIMAX_ST_QUIESCING)

  		result = 0;

  	else
  		result = __wimax_rf_toggle_radio(wimax_dev, rf_state);
  	mutex_unlock(&wimax_dev->mutex);

  	d_fnend(3, dev, "(wimax_dev %p blocked %u) = %d
  ",
  		wimax_dev, blocked, result);

  	return result;
  }

  static const struct rfkill_ops wimax_rfkill_ops = {
  	.set_block = wimax_rfkill_set_radio_block,
  };

  
  /**
   * wimax_rfkill - Set the software RF switch state for a WiMAX device
   *
   * @wimax_dev: WiMAX device descriptor
   *
   * @state: New RF state.
   *
   * Returns:
   *
   * >= 0 toggle state if ok, < 0 errno code on error. The toggle state
   * is returned as a bitmap, bit 0 being the hardware RF state, bit 1
   * the software RF state.
   *
   * 0 means disabled (%WIMAX_RF_ON, radio on), 1 means enabled radio
   * off (%WIMAX_RF_OFF).
   *
   * Description:
   *
   * Called by the user when he wants to request the WiMAX radio to be
   * switched on (%WIMAX_RF_ON) or off (%WIMAX_RF_OFF). With
   * %WIMAX_RF_QUERY, just the current state is returned.
   *
   * NOTE:
   *
   * This call will block until the operation is complete.
   */
  int wimax_rfkill(struct wimax_dev *wimax_dev, enum wimax_rf_state state)
  {
  	int result;
  	struct device *dev = wimax_dev_to_dev(wimax_dev);
  
  	d_fnstart(3, dev, "(wimax_dev %p state %u)
  ", wimax_dev, state);
  	mutex_lock(&wimax_dev->mutex);
  	result = wimax_dev_is_ready(wimax_dev);

  	if (result < 0) {
  		/* While initializing, < 1.4.3 wimax-tools versions use
  		 * this call to check if the device is a valid WiMAX
  		 * device; so we allow it to proceed always,
  		 * considering the radios are all off. */
  		if (result == -ENOMEDIUM && state == WIMAX_RF_QUERY)
  			result = WIMAX_RF_OFF << 1 | WIMAX_RF_OFF;

  		goto error_not_ready;

  	}

  	switch (state) {
  	case WIMAX_RF_ON:
  	case WIMAX_RF_OFF:
  		result = __wimax_rf_toggle_radio(wimax_dev, state);
  		if (result < 0)
  			goto error;

  		rfkill_set_sw_state(wimax_dev->rfkill, state == WIMAX_RF_OFF);

  		break;
  	case WIMAX_RF_QUERY:
  		break;
  	default:
  		result = -EINVAL;
  		goto error;
  	}
  	result = wimax_dev->rf_sw << 1 | wimax_dev->rf_hw;
  error:
  error_not_ready:
  	mutex_unlock(&wimax_dev->mutex);
  	d_fnend(3, dev, "(wimax_dev %p state %u) = %d
  ",
  		wimax_dev, state, result);
  	return result;
  }
  EXPORT_SYMBOL(wimax_rfkill);
  
  
  /*
   * Register a new WiMAX device's RF Kill support
   *
   * WARNING: wimax_dev->mutex must be unlocked
   */
  int wimax_rfkill_add(struct wimax_dev *wimax_dev)
  {
  	int result;
  	struct rfkill *rfkill;

  	struct device *dev = wimax_dev_to_dev(wimax_dev);
  
  	d_fnstart(3, dev, "(wimax_dev %p)
  ", wimax_dev);
  	/* Initialize RF Kill */
  	result = -ENOMEM;

  	rfkill = rfkill_alloc(wimax_dev->name, dev, RFKILL_TYPE_WIMAX,
  			      &wimax_rfkill_ops, wimax_dev);

  	if (rfkill == NULL)
  		goto error_rfkill_allocate;

  
  	d_printf(1, dev, "rfkill %p
  ", rfkill);

  	wimax_dev->rfkill = rfkill;

  	rfkill_init_sw_state(rfkill, 1);

  	result = rfkill_register(wimax_dev->rfkill);
  	if (result < 0)
  		goto error_rfkill_register;
  
  	/* If there is no SW toggle op, SW RFKill is always on */
  	if (wimax_dev->op_rfkill_sw_toggle == NULL)
  		wimax_dev->rf_sw = WIMAX_RF_ON;
  
  	d_fnend(3, dev, "(wimax_dev %p) = 0
  ", wimax_dev);
  	return 0;

  error_rfkill_register:

  	rfkill_destroy(wimax_dev->rfkill);

  error_rfkill_allocate:
  	d_fnend(3, dev, "(wimax_dev %p) = %d
  ", wimax_dev, result);
  	return result;
  }
  
  
  /*
   * Deregister a WiMAX device's RF Kill support
   *
   * Ick, we can't call rfkill_free() after rfkill_unregister()...oh
   * well.
   *
   * WARNING: wimax_dev->mutex must be unlocked
   */
  void wimax_rfkill_rm(struct wimax_dev *wimax_dev)
  {
  	struct device *dev = wimax_dev_to_dev(wimax_dev);
  	d_fnstart(3, dev, "(wimax_dev %p)
  ", wimax_dev);

  	rfkill_unregister(wimax_dev->rfkill);
  	rfkill_destroy(wimax_dev->rfkill);

  	d_fnend(3, dev, "(wimax_dev %p)
  ", wimax_dev);
  }

  /*
   * Exporting to user space over generic netlink
   *
   * Parse the rfkill command from user space, return a combination
   * value that describe the states of the different toggles.
   *
   * Only one attribute: the new state requested (on, off or no change,
   * just query).
   */

  static const struct nla_policy wimax_gnl_rfkill_policy[WIMAX_GNL_ATTR_MAX + 1] = {

  	[WIMAX_GNL_RFKILL_IFIDX] = {
  		.type = NLA_U32,
  	},
  	[WIMAX_GNL_RFKILL_STATE] = {
  		.type = NLA_U32		/* enum wimax_rf_state */
  	},
  };
  
  
  static
  int wimax_gnl_doit_rfkill(struct sk_buff *skb, struct genl_info *info)
  {
  	int result, ifindex;
  	struct wimax_dev *wimax_dev;
  	struct device *dev;
  	enum wimax_rf_state new_state;
  
  	d_fnstart(3, NULL, "(skb %p info %p)
  ", skb, info);
  	result = -ENODEV;
  	if (info->attrs[WIMAX_GNL_RFKILL_IFIDX] == NULL) {
  		printk(KERN_ERR "WIMAX_GNL_OP_RFKILL: can't find IFIDX "
  			"attribute
  ");
  		goto error_no_wimax_dev;
  	}
  	ifindex = nla_get_u32(info->attrs[WIMAX_GNL_RFKILL_IFIDX]);
  	wimax_dev = wimax_dev_get_by_genl_info(info, ifindex);
  	if (wimax_dev == NULL)
  		goto error_no_wimax_dev;
  	dev = wimax_dev_to_dev(wimax_dev);
  	result = -EINVAL;
  	if (info->attrs[WIMAX_GNL_RFKILL_STATE] == NULL) {
  		dev_err(dev, "WIMAX_GNL_RFKILL: can't find RFKILL_STATE "
  			"attribute
  ");
  		goto error_no_pid;
  	}
  	new_state = nla_get_u32(info->attrs[WIMAX_GNL_RFKILL_STATE]);
  
  	/* Execute the operation and send the result back to user space */
  	result = wimax_rfkill(wimax_dev, new_state);
  error_no_pid:
  	dev_put(wimax_dev->net_dev);
  error_no_wimax_dev:
  	d_fnend(3, NULL, "(skb %p info %p) = %d
  ", skb, info, result);
  	return result;
  }
  
  
  struct genl_ops wimax_gnl_rfkill = {
  	.cmd = WIMAX_GNL_OP_RFKILL,
  	.flags = GENL_ADMIN_PERM,
  	.policy = wimax_gnl_rfkill_policy,
  	.doit = wimax_gnl_doit_rfkill,
  	.dumpit = NULL,
  };