Merge branch 'linux-2.6.33.y' of git://git.kernel.org/pub/scm/linux/kernel/git/inaky/wimax

 *   i2400m_set_init_config()

 *   i2400m_cmd_get_state()

 * i2400m_dev_shutdown()        Called by i2400m_dev_stop()

 *   i2400m->bus_reset()

 *   i2400m_reset()

 *

 * i2400m_{cmd,get,set}_*()

 *   i2400m_msg_to_dev()

#define D_SUBMODULE control

#include "debug-levels.h"

int i2400m_passive_mode;	/* 0 (passive mode disabled) by default */

module_param_named(passive_mode, i2400m_passive_mode, int, 0644);

MODULE_PARM_DESC(passive_mode,

		 "If true, the driver will not do any device setup "

		 "and leave it up to user space, who must be properly "

		 "setup.");

/*

 * Return if a TLV is of a give type and size

	if (status == 0)

		return 0;

	if (status > ARRAY_SIZE(ms_to_errno)) {

	if (status >= ARRAY_SIZE(ms_to_errno)) {

		str = "unknown status code";

		result = -EBADR;

	} else {

		/* Huh? just in case, shut it down */

		dev_err(dev, "HW BUG? unknown state %u: shutting down\n",

			i2400m_state);

		i2400m->bus_reset(i2400m, I2400M_RT_WARM);

		i2400m_reset(i2400m, I2400M_RT_WARM);

		break;

	};

	d_fnend(3, dev, "(i2400m %p ss %p [%u]) = void\n",

	unsigned argc = 0;

	d_fnstart(3, dev, "(i2400m %p)\n", i2400m);

	if (i2400m_passive_mode)

		goto out_passive;

	/* Disable idle mode? (enabled by default) */

	if (i2400m_idle_mode_disabled) {

		if (i2400m_le_v1_3(i2400m)) {

	result = i2400m_set_init_config(i2400m, args, argc);

	if (result < 0)

		goto error;

out_passive:

	/*

	 * Update state: Here it just calls a get state; parsing the

	 * result (System State TLV and RF Status TLV [done in the rx

	case I2400M_RT_WARM:

	case I2400M_RT_COLD:

	case I2400M_RT_BUS:

		result = i2400m->bus_reset(i2400m, rt);

		result = i2400m_reset(i2400m, rt);

		if (result >= 0)

			result = 0;

	default:

 *     __i2400m_dev_start()

 *

 * i2400m_setup()

 *   i2400m->bus_setup()

 *   i2400m_bootrom_init()

 *   register_netdev()

 *   wimax_dev_add()

 *   i2400m_dev_start()

 *     __i2400m_dev_start()

 *       i2400m_dev_bootstrap()

 *       i2400m->bus_dev_start()

 *       i2400m_firmware_check()

 *       i2400m_check_mac_addr()

 *   wimax_dev_add()

 *

 * i2400m_release()

 *   wimax_dev_rm()

 *   i2400m_dev_stop()

 *     __i2400m_dev_stop()

 *       i2400m_dev_shutdown()

 *       i2400m->bus_dev_stop()

 *       i2400m_tx_release()

 *   i2400m->bus_release()

 *   wimax_dev_rm()

 *   unregister_netdev()

 */

#include "i2400m.h"

#include <linux/wimax/i2400m.h>

#include <linux/module.h>

#include <linux/moduleparam.h>

#include <linux/suspend.h>

#define D_SUBMODULE driver

#include "debug-levels.h"

		 "False by default (so the device is told to do power "

		 "saving).");

/**

 * i2400m_queue_work - schedule work on a i2400m's queue

 *

 * @i2400m: device descriptor

 *

 * @fn: function to run to execute work. It gets passed a 'struct

 *     work_struct' that is wrapped in a 'struct i2400m_work'. Once

 *     done, you have to (1) i2400m_put(i2400m_work->i2400m) and then

 *     (2) kfree(i2400m_work).

 *

 * @gfp_flags: GFP flags for memory allocation.

 *

 * @pl: pointer to a payload buffer that you want to pass to the _work

 *     function. Use this to pack (for example) a struct with extra

 *     arguments.

 *

 * @pl_size: size of the payload buffer.

 *

 * We do this quite often, so this just saves typing; allocate a

 * wrapper for a i2400m, get a ref to it, pack arguments and launch

 * the work.

 *

 * A usual workflow is:

 *

 * struct my_work_args {

 *         void *something;

 *         int whatever;

 * };

 * ...

 *

 * struct my_work_args my_args = {

 *         .something = FOO,

 *         .whaetever = BLAH

 * };

 * i2400m_queue_work(i2400m, 1, my_work_function, GFP_KERNEL,

 *                   &args, sizeof(args))

 *

 * And now the work function can unpack the arguments and call the

 * real function (or do the job itself):

 *

 * static

 * void my_work_fn((struct work_struct *ws)

 * {

 *         struct i2400m_work *iw =

 *	           container_of(ws, struct i2400m_work, ws);

 *	   struct my_work_args *my_args = (void *) iw->pl;

 *

 *	   my_work(iw->i2400m, my_args->something, my_args->whatevert);

 * }

 */

int i2400m_queue_work(struct i2400m *i2400m,

		      void (*fn)(struct work_struct *), gfp_t gfp_flags,

		      const void *pl, size_t pl_size)

static char i2400m_debug_params[128];

module_param_string(debug, i2400m_debug_params, sizeof(i2400m_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.");

static char i2400m_barkers_params[128];

module_param_string(barkers, i2400m_barkers_params,

		    sizeof(i2400m_barkers_params), 0644);

MODULE_PARM_DESC(barkers,

		 "String of comma-separated 32-bit values; each is "

		 "recognized as the value the device sends as a reboot "

		 "signal; values are appended to a list--setting one value "

		 "as zero cleans the existing list and starts a new one.");

static

struct i2400m_work *__i2400m_work_setup(

	struct i2400m *i2400m, void (*fn)(struct work_struct *),

	gfp_t gfp_flags, const void *pl, size_t pl_size)

{

	int result;

	struct i2400m_work *iw;

	BUG_ON(i2400m->work_queue == NULL);

	result = -ENOMEM;

	iw = kzalloc(sizeof(*iw) + pl_size, gfp_flags);

	if (iw == NULL)

		goto error_kzalloc;

		return NULL;

	iw->i2400m = i2400m_get(i2400m);

	iw->pl_size = pl_size;

	memcpy(iw->pl, pl, pl_size);

	INIT_WORK(&iw->ws, fn);

	result = queue_work(i2400m->work_queue, &iw->ws);

error_kzalloc:

	return result;

	return iw;

}

EXPORT_SYMBOL_GPL(i2400m_queue_work);

/*

 * it should not happen.

 */

int i2400m_schedule_work(struct i2400m *i2400m,

			 void (*fn)(struct work_struct *), gfp_t gfp_flags)

			 void (*fn)(struct work_struct *), gfp_t gfp_flags,

			 const void *pl, size_t pl_size)

{

	int result;

	struct i2400m_work *iw;

	result = -ENOMEM;

	iw = kzalloc(sizeof(*iw), gfp_flags);

	if (iw == NULL)

		goto error_kzalloc;

	iw->i2400m = i2400m_get(i2400m);

	INIT_WORK(&iw->ws, fn);

	iw = __i2400m_work_setup(i2400m, fn, gfp_flags, pl, pl_size);

	if (iw != NULL) {

		result = schedule_work(&iw->ws);

	if (result == 0)

		if (WARN_ON(result == 0))

			result = -ENXIO;

error_kzalloc:

	}

	return result;

}

	mutex_lock(&i2400m->init_mutex);

	i2400m->reset_ctx = &ctx;

	mutex_unlock(&i2400m->init_mutex);

	result = i2400m->bus_reset(i2400m, I2400M_RT_WARM);

	result = i2400m_reset(i2400m, I2400M_RT_WARM);

	if (result < 0)

		goto out;

	result = wait_for_completion_timeout(&ctx.completion, 4*HZ);

		dev_err(dev, "cannot create workqueue\n");

		goto error_create_workqueue;

	}

	if (i2400m->bus_dev_start) {

		result = i2400m->bus_dev_start(i2400m);

		if (result < 0)

			goto error_bus_dev_start;

	}

	i2400m->ready = 1;

	wmb();		/* see i2400m->ready's documentation  */

	/* process pending reports from the device */

	queue_work(i2400m->work_queue, &i2400m->rx_report_ws);

	result = i2400m_firmware_check(i2400m);	/* fw versions ok? */

	if (result < 0)

		goto error_fw_check;

	result = i2400m_check_mac_addr(i2400m);

	if (result < 0)

		goto error_check_mac_addr;

	i2400m->ready = 1;

	wimax_state_change(wimax_dev, WIMAX_ST_UNINITIALIZED);

	result = i2400m_dev_initialize(i2400m);

	if (result < 0)

		goto error_dev_initialize;

error_dev_initialize:

error_check_mac_addr:

	i2400m->ready = 0;

	wmb();		/* see i2400m->ready's documentation  */

	flush_workqueue(i2400m->work_queue);

error_fw_check:

	if (i2400m->bus_dev_stop)

		i2400m->bus_dev_stop(i2400m);

error_bus_dev_start:

	destroy_workqueue(i2400m->work_queue);

static

int i2400m_dev_start(struct i2400m *i2400m, enum i2400m_bri bm_flags)

{

	int result;

	int result = 0;

	mutex_lock(&i2400m->init_mutex);	/* Well, start the device */

	if (i2400m->updown == 0) {

		result = __i2400m_dev_start(i2400m, bm_flags);

	if (result >= 0)

		if (result >= 0) {

			i2400m->updown = 1;

			wmb();	/* see i2400m->updown's documentation */

		}

	}

	mutex_unlock(&i2400m->init_mutex);

	return result;

}

	d_fnstart(3, dev, "(i2400m %p)\n", i2400m);

	wimax_state_change(wimax_dev, __WIMAX_ST_QUIESCING);

	i2400m_msg_to_dev_cancel_wait(i2400m, -EL3RST);

	complete(&i2400m->msg_completion);

	i2400m_net_wake_stop(i2400m);

	i2400m_dev_shutdown(i2400m);

	i2400m->ready = 0;

	/*

	 * Make sure no report hooks are running *before* we stop the

	 * communication infrastructure with the device.

	 */

	i2400m->ready = 0;	/* nobody can queue work anymore */

	wmb();		/* see i2400m->ready's documentation  */

	flush_workqueue(i2400m->work_queue);

	if (i2400m->bus_dev_stop)

		i2400m->bus_dev_stop(i2400m);

	destroy_workqueue(i2400m->work_queue);

	i2400m_rx_release(i2400m);

	if (i2400m->updown) {

		__i2400m_dev_stop(i2400m);

		i2400m->updown = 0;

		wmb();	/* see i2400m->updown's documentation  */

	}

	mutex_unlock(&i2400m->init_mutex);

}

/*

 * Listen to PM events to cache the firmware before suspend/hibernation

 *

 * When the device comes out of suspend, it might go into reset and

 * firmware has to be uploaded again. At resume, most of the times, we

 * can't load firmware images from disk, so we need to cache it.

 *

 * i2400m_fw_cache() will allocate a kobject and attach the firmware

 * to it; that way we don't have to worry too much about the fw loader

 * hitting a race condition.

 *

 * Note: modus operandi stolen from the Orinoco driver; thx.

 */

static

int i2400m_pm_notifier(struct notifier_block *notifier,

		       unsigned long pm_event,

		       void *unused)

{

	struct i2400m *i2400m =

		container_of(notifier, struct i2400m, pm_notifier);

	struct device *dev = i2400m_dev(i2400m);

	d_fnstart(3, dev, "(i2400m %p pm_event %lx)\n", i2400m, pm_event);

	switch (pm_event) {

	case PM_HIBERNATION_PREPARE:

	case PM_SUSPEND_PREPARE:

		i2400m_fw_cache(i2400m);

		break;

	case PM_POST_RESTORE:

		/* Restore from hibernation failed. We need to clean

		 * up in exactly the same way, so fall through. */

	case PM_POST_HIBERNATION:

	case PM_POST_SUSPEND:

		i2400m_fw_uncache(i2400m);

		break;

	case PM_RESTORE_PREPARE:

	default:

		break;

	}

	d_fnend(3, dev, "(i2400m %p pm_event %lx) = void\n", i2400m, pm_event);

	return NOTIFY_DONE;

}

/*

 * pre-reset is called before a device is going on reset

 *

 * This has to be followed by a call to i2400m_post_reset(), otherwise

 * bad things might happen.

 */

int i2400m_pre_reset(struct i2400m *i2400m)

{

	int result;

	struct device *dev = i2400m_dev(i2400m);

	d_fnstart(3, dev, "(i2400m %p)\n", i2400m);

	d_printf(1, dev, "pre-reset shut down\n");

	result = 0;

	mutex_lock(&i2400m->init_mutex);

	if (i2400m->updown) {

		netif_tx_disable(i2400m->wimax_dev.net_dev);

		__i2400m_dev_stop(i2400m);

		result = 0;

		/* down't set updown to zero -- this way

		 * post_reset can restore properly */

	}

	mutex_unlock(&i2400m->init_mutex);

	if (i2400m->bus_release)

		i2400m->bus_release(i2400m);

	d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result);

	return result;

}

EXPORT_SYMBOL_GPL(i2400m_pre_reset);

/*

 * Restore device state after a reset

 *

 * Do the work needed after a device reset to bring it up to the same

 * state as it was before the reset.

 *

 * NOTE: this requires i2400m->init_mutex taken

 */

int i2400m_post_reset(struct i2400m *i2400m)

{

	int result = 0;

	struct device *dev = i2400m_dev(i2400m);

	d_fnstart(3, dev, "(i2400m %p)\n", i2400m);

	d_printf(1, dev, "post-reset start\n");

	if (i2400m->bus_setup) {

		result = i2400m->bus_setup(i2400m);

		if (result < 0) {

			dev_err(dev, "bus-specific setup failed: %d\n",

				result);

			goto error_bus_setup;

		}

	}

	mutex_lock(&i2400m->init_mutex);

	if (i2400m->updown) {

		result = __i2400m_dev_start(

			i2400m, I2400M_BRI_SOFT | I2400M_BRI_MAC_REINIT);

		if (result < 0)

			goto error_dev_start;

	}

	mutex_unlock(&i2400m->init_mutex);

	d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result);

	return result;

error_dev_start:

	if (i2400m->bus_release)

		i2400m->bus_release(i2400m);

error_bus_setup:

	/* even if the device was up, it could not be recovered, so we

	 * mark it as down. */

	i2400m->updown = 0;

	wmb();		/* see i2400m->updown's documentation  */

	mutex_unlock(&i2400m->init_mutex);

	d_fnend(3, dev, "(i2400m %p) = %d\n", i2400m, result);

	return result;

}

EXPORT_SYMBOL_GPL(i2400m_post_reset);

/*

 *       _stop()], don't do anything, let it fail and handle it.

 *

 * This function is ran always in a thread context

 *

 * This function gets passed, as payload to i2400m_work() a 'const

 * char *' ptr with a "reason" why the reset happened (for messages).

 */

static

void __i2400m_dev_reset_handle(struct work_struct *ws)

{

	int result;

	struct i2400m_work *iw = container_of(ws, struct i2400m_work, ws);

	const char *reason;

	struct i2400m *i2400m = iw->i2400m;

	struct device *dev = i2400m_dev(i2400m);

	enum wimax_st wimax_state;

	struct i2400m_reset_ctx *ctx = i2400m->reset_ctx;

	d_fnstart(3, dev, "(ws %p i2400m %p)\n", ws, i2400m);

	if (WARN_ON(iw->pl_size != sizeof(reason)))

		reason = "SW BUG: reason n/a";

	else

		memcpy(&reason, iw->pl, sizeof(reason));

	d_fnstart(3, dev, "(ws %p i2400m %p reason %s)\n", ws, i2400m, reason);

	result = 0;

	if (mutex_trylock(&i2400m->init_mutex) == 0) {

		/* We are still in i2400m_dev_start() [let it fail] or

		 * i2400m_dev_stop() [we are shutting down anyway, so

		 * ignore it] or we are resetting somewhere else. */

		dev_err(dev, "device rebooted\n");

		dev_err(dev, "device rebooted somewhere else?\n");

		i2400m_msg_to_dev_cancel_wait(i2400m, -EL3RST);

		complete(&i2400m->msg_completion);

		goto out;

	}

	wimax_state = wimax_state_get(&i2400m->wimax_dev);

	if (wimax_state < WIMAX_ST_UNINITIALIZED) {

		dev_info(dev, "device rebooted: it is down, ignoring\n");

		goto out_unlock;	/* ifconfig up/down wasn't called */

	if (i2400m->updown == 0)  {

		dev_info(dev, "%s: device is down, doing nothing\n", reason);

		goto out_unlock;

	}

	dev_err(dev, "device rebooted: reinitializing driver\n");

	dev_err(dev, "%s: reinitializing driver\n", reason);

	__i2400m_dev_stop(i2400m);

	i2400m->updown = 0;

	result = __i2400m_dev_start(i2400m,

				    I2400M_BRI_SOFT | I2400M_BRI_MAC_REINIT);

	if (result < 0) {

		dev_err(dev, "device reboot: cannot start the device: %d\n",

			result);

		result = i2400m->bus_reset(i2400m, I2400M_RT_BUS);

		if (result >= 0)

			result = -ENODEV;

	} else

		i2400m->updown = 1;

		i2400m->updown = 0;

		wmb();		/* see i2400m->updown's documentation  */

		dev_err(dev, "%s: cannot start the device: %d\n",

			reason, result);

		result = -EUCLEAN;

	}

out_unlock:

	if (i2400m->reset_ctx) {

		ctx->result = result;

		complete(&ctx->completion);

	}

	mutex_unlock(&i2400m->init_mutex);

	if (result == -EUCLEAN) {

		/* ops, need to clean up [w/ init_mutex not held] */

		result = i2400m_reset(i2400m, I2400M_RT_BUS);

		if (result >= 0)

			result = -ENODEV;

	}

out:

	i2400m_put(i2400m);

	kfree(iw);

	d_fnend(3, dev, "(ws %p i2400m %p) = void\n", ws, i2400m);

	d_fnend(3, dev, "(ws %p i2400m %p reason %s) = void\n",

		ws, i2400m, reason);

	return;

}

 * reinitializing the driver to handle the reset, calling into the

 * bus-specific functions ops as needed.

 */

int i2400m_dev_reset_handle(struct i2400m *i2400m)

int i2400m_dev_reset_handle(struct i2400m *i2400m, const char *reason)

{

	i2400m->boot_mode = 1;

	wmb();		/* Make sure i2400m_msg_to_dev() sees boot_mode */

	return i2400m_schedule_work(i2400m, __i2400m_dev_reset_handle,

				    GFP_ATOMIC);

				    GFP_ATOMIC, &reason, sizeof(reason));

}

EXPORT_SYMBOL_GPL(i2400m_dev_reset_handle);

/*

 * Alloc the command and ack buffers for boot mode

 *

 * Get the buffers needed to deal with boot mode messages.  These

 * buffers need to be allocated before the sdio recieve irq is setup.

 */

static

int i2400m_bm_buf_alloc(struct i2400m *i2400m)

{

	int result;

	result = -ENOMEM;

	i2400m->bm_cmd_buf = kzalloc(I2400M_BM_CMD_BUF_SIZE, GFP_KERNEL);

	if (i2400m->bm_cmd_buf == NULL)

		goto error_bm_cmd_kzalloc;

	i2400m->bm_ack_buf = kzalloc(I2400M_BM_ACK_BUF_SIZE, GFP_KERNEL);

	if (i2400m->bm_ack_buf == NULL)

		goto error_bm_ack_buf_kzalloc;

	return 0;

error_bm_ack_buf_kzalloc:

	kfree(i2400m->bm_cmd_buf);

error_bm_cmd_kzalloc:

	return result;

}

/*

 * Free boot mode command and ack buffers.

 */

static

void i2400m_bm_buf_free(struct i2400m *i2400m)

{

	kfree(i2400m->bm_ack_buf);

	kfree(i2400m->bm_cmd_buf);

}

/**

 * i2400m_init - Initialize a 'struct i2400m' from all zeroes

 *

 * This is a bus-generic API call.

 */

void i2400m_init(struct i2400m *i2400m)

{

	wimax_dev_init(&i2400m->wimax_dev);

	i2400m->boot_mode = 1;

	i2400m->rx_reorder = 1;

	init_waitqueue_head(&i2400m->state_wq);

	spin_lock_init(&i2400m->tx_lock);

	i2400m->tx_pl_min = UINT_MAX;

	i2400m->tx_size_min = UINT_MAX;

	spin_lock_init(&i2400m->rx_lock);

	i2400m->rx_pl_min = UINT_MAX;

	i2400m->rx_size_min = UINT_MAX;

	INIT_LIST_HEAD(&i2400m->rx_reports);

	INIT_WORK(&i2400m->rx_report_ws, i2400m_report_hook_work);

	mutex_init(&i2400m->msg_mutex);

	init_completion(&i2400m->msg_completion);

	mutex_init(&i2400m->init_mutex);

	/* wake_tx_ws is initialized in i2400m_tx_setup() */

}

EXPORT_SYMBOL_GPL(i2400m_init);

int i2400m_reset(struct i2400m *i2400m, enum i2400m_reset_type rt)

{

	struct net_device *net_dev = i2400m->wimax_dev.net_dev;

	/*

	 * Make sure we stop TXs and down the carrier before

	 * resetting; this is needed to avoid things like

	 * i2400m_wake_tx() scheduling stuff in parallel.

	 */

	if (net_dev->reg_state == NETREG_REGISTERED) {

		netif_tx_disable(net_dev);

		netif_carrier_off(net_dev);

	}

	return i2400m->bus_reset(i2400m, rt);

}

EXPORT_SYMBOL_GPL(i2400m_reset);

/**

 * i2400m_setup - bus-generic setup function for the i2400m device

 *

 *

 * Returns: 0 if ok, < 0 errno code on error.

 *

 * Initializes the bus-generic parts of the i2400m driver; the

 * bus-specific parts have been initialized, function pointers filled

 * out by the bus-specific probe function.

 *

 * As well, this registers the WiMAX and net device nodes. Once this

 * function returns, the device is operative and has to be ready to

 * receive and send network traffic and WiMAX control operations.

 * Sets up basic device comunication infrastructure, boots the ROM to

 * read the MAC address, registers with the WiMAX and network stacks

 * and then brings up the device.

 */

int i2400m_setup(struct i2400m *i2400m, enum i2400m_bri bm_flags)

{

	snprintf(wimax_dev->name, sizeof(wimax_dev->name),

		 "i2400m-%s:%s", dev->bus->name, dev_name(dev));

	i2400m->bm_cmd_buf = kzalloc(I2400M_BM_CMD_BUF_SIZE, GFP_KERNEL);

	if (i2400m->bm_cmd_buf == NULL) {

		dev_err(dev, "cannot allocate USB command buffer\n");

		goto error_bm_cmd_kzalloc;

	result = i2400m_bm_buf_alloc(i2400m);

	if (result < 0) {

		dev_err(dev, "cannot allocate bootmode scratch buffers\n");

		goto error_bm_buf_alloc;

	}

	if (i2400m->bus_setup) {

		result = i2400m->bus_setup(i2400m);

		if (result < 0) {

			dev_err(dev, "bus-specific setup failed: %d\n",

				result);

			goto error_bus_setup;

		}

	i2400m->bm_ack_buf = kzalloc(I2400M_BM_ACK_BUF_SIZE, GFP_KERNEL);

	if (i2400m->bm_ack_buf == NULL) {

		dev_err(dev, "cannot allocate USB ack buffer\n");

		goto error_bm_ack_buf_kzalloc;

	}