wusb: add the Wireless USB core (protocol)

/*

 * WUSB Wire Adapter: Control/Data Streaming Interface (WUSB[8])

 * MMC (Microscheduled Management Command) handling

 *

 * Copyright (C) 2005-2006 Intel Corporation

 * 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.

 *

 *

 * WUIEs and MMC IEs...well, they are almost the same at the end. MMC

 * IEs are Wireless USB IEs that go into the MMC period...[what is

 * that? look in Design-overview.txt].

 *

 *

 * This is a simple subsystem to keep track of which IEs are being

 * sent by the host in the MMC period.

 *

 * For each WUIE we ask to send, we keep it in an array, so we can

 * request its removal later, or replace the content. They are tracked

 * by pointer, so be sure to use the same pointer if you want to

 * remove it or update the contents.

 *

 * FIXME:

 *  - add timers that autoremove intervalled IEs?

 */

#include <linux/usb/wusb.h>

#include "wusbhc.h"

/* Initialize the MMCIEs handling mechanism */

int wusbhc_mmcie_create(struct wusbhc *wusbhc)

{

	u8 mmcies = wusbhc->mmcies_max;

	wusbhc->mmcie = kzalloc(mmcies * sizeof(wusbhc->mmcie[0]), GFP_KERNEL);

	if (wusbhc->mmcie == NULL)

		return -ENOMEM;

	mutex_init(&wusbhc->mmcie_mutex);

	return 0;

}

/* Release resources used by the MMCIEs handling mechanism */

void wusbhc_mmcie_destroy(struct wusbhc *wusbhc)

{

	kfree(wusbhc->mmcie);

}

/*

 * Add or replace an MMC Wireless USB IE.

 *

 * @interval:    See WUSB1.0[8.5.3.1]

 * @repeat_cnt:  See WUSB1.0[8.5.3.1]

 * @handle:      See WUSB1.0[8.5.3.1]

 * @wuie:        Pointer to the header of the WUSB IE data to add.

 *               MUST BE allocated in a kmalloc buffer (no stack or

 *               vmalloc).

 *               THE CALLER ALWAYS OWNS THE POINTER (we don't free it

 *               on remove, we just forget about it).

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

 *

 * Goes over the *whole* @wusbhc->mmcie array looking for (a) the

 * first free spot and (b) if @wuie is already in the array (aka:

 * transmitted in the MMCs) the spot were it is.

 *

 * If present, we "overwrite it" (update).

 *

 *

 * NOTE: Need special ordering rules -- see below WUSB1.0 Table 7-38.

 *       The host uses the handle as the 'sort' index. We

 *       allocate the last one always for the WUIE_ID_HOST_INFO, and

 *       the rest, first come first serve in inverse order.

 *

 *       Host software must make sure that it adds the other IEs in

 *       the right order... the host hardware is responsible for

 *       placing the WCTA IEs in the right place with the other IEs

 *       set by host software.

 *

 * NOTE: we can access wusbhc->wa_descr without locking because it is

 *       read only.

 */

int wusbhc_mmcie_set(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,

		     struct wuie_hdr *wuie)

{

	int result = -ENOBUFS;

	struct device *dev = wusbhc->dev;

	unsigned handle, itr;

	/* Search a handle, taking into account the ordering */

	mutex_lock(&wusbhc->mmcie_mutex);

	switch (wuie->bIEIdentifier) {

	case WUIE_ID_HOST_INFO:

		/* Always last */

		handle = wusbhc->mmcies_max - 1;

		break;

	case WUIE_ID_ISOCH_DISCARD:

		dev_err(wusbhc->dev, "Special ordering case for WUIE ID 0x%x "

			"unimplemented\n", wuie->bIEIdentifier);

		result = -ENOSYS;

		goto error_unlock;

	default:

		/* search for it or find the last empty slot */

		handle = ~0;

		for (itr = 0; itr < wusbhc->mmcies_max - 1; itr++) {

			if (wusbhc->mmcie[itr] == wuie) {

				handle = itr;

				break;

			}

			if (wusbhc->mmcie[itr] == NULL)

				handle = itr;

		}

		if (handle == ~0) {

			if (printk_ratelimit())

				dev_err(dev, "MMC handle space exhausted\n");

			goto error_unlock;

		}

	}

	result = (wusbhc->mmcie_add)(wusbhc, interval, repeat_cnt, handle,

				     wuie);

	if (result >= 0)

		wusbhc->mmcie[handle] = wuie;

error_unlock:

	mutex_unlock(&wusbhc->mmcie_mutex);

	return result;

}

EXPORT_SYMBOL_GPL(wusbhc_mmcie_set);

/*

 * Remove an MMC IE previously added with wusbhc_mmcie_set()

 *

 * @wuie	Pointer used to add the WUIE

 */

void wusbhc_mmcie_rm(struct wusbhc *wusbhc, struct wuie_hdr *wuie)

{

	int result;

	struct device *dev = wusbhc->dev;

	unsigned handle, itr;

	mutex_lock(&wusbhc->mmcie_mutex);

	for (itr = 0; itr < wusbhc->mmcies_max; itr++)

		if (wusbhc->mmcie[itr] == wuie) {

			handle = itr;

			goto found;

		}

	mutex_unlock(&wusbhc->mmcie_mutex);

	return;

found:

	result = (wusbhc->mmcie_rm)(wusbhc, handle);

	if (result == 0)

		wusbhc->mmcie[itr] = NULL;

	else if (printk_ratelimit())

		dev_err(dev, "MMC: Failed to remove IE %p (0x%02x)\n",

			wuie, wuie->bIEIdentifier);

	mutex_unlock(&wusbhc->mmcie_mutex);

	return;

}

EXPORT_SYMBOL_GPL(wusbhc_mmcie_rm);

/*

 * wusbhc_start - start transmitting MMCs and accepting connections

 * @wusbhc: the HC to start

 * @chid: the CHID to use for this host

 *

 * Establishes a cluster reservation, enables device connections, and

 * starts MMCs with appropriate DNTS parameters.

 */

int wusbhc_start(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)

{

	int result;

	struct device *dev = wusbhc->dev;

	WARN_ON(wusbhc->wuie_host_info != NULL);

	result = wusbhc_rsv_establish(wusbhc);

	if (result < 0) {

		dev_err(dev, "cannot establish cluster reservation: %d\n",

			result);

		goto error_rsv_establish;

	}

	result = wusbhc_devconnect_start(wusbhc, chid);

	if (result < 0) {

		dev_err(dev, "error enabling device connections: %d\n", result);

		goto error_devconnect_start;

	}

	result = wusbhc_sec_start(wusbhc);

	if (result < 0) {

		dev_err(dev, "error starting security in the HC: %d\n", result);

		goto error_sec_start;

	}

	/* FIXME: the choice of the DNTS parameters is somewhat

	 * arbitrary */

	result = wusbhc->set_num_dnts(wusbhc, 0, 15);

	if (result < 0) {

		dev_err(dev, "Cannot set DNTS parameters: %d\n", result);

		goto error_set_num_dnts;

	}

	result = wusbhc->start(wusbhc);

	if (result < 0) {

		dev_err(dev, "error starting wusbch: %d\n", result);

		goto error_wusbhc_start;

	}

	wusbhc->active = 1;

	return 0;

error_wusbhc_start:

	wusbhc_sec_stop(wusbhc);

error_set_num_dnts:

error_sec_start:

	wusbhc_devconnect_stop(wusbhc);

error_devconnect_start:

	wusbhc_rsv_terminate(wusbhc);

error_rsv_establish:

	return result;

}

/*

 * Disconnect all from the WUSB Channel

 *

 * Send a Host Disconnect IE in the MMC, wait, don't send it any more

 */

static int __wusbhc_host_disconnect_ie(struct wusbhc *wusbhc)

{

	int result = -ENOMEM;

	struct wuie_host_disconnect *host_disconnect_ie;

	might_sleep();

	host_disconnect_ie = kmalloc(sizeof(*host_disconnect_ie), GFP_KERNEL);

	if (host_disconnect_ie == NULL)

		goto error_alloc;

	host_disconnect_ie->hdr.bLength       = sizeof(*host_disconnect_ie);

	host_disconnect_ie->hdr.bIEIdentifier = WUIE_ID_HOST_DISCONNECT;

	result = wusbhc_mmcie_set(wusbhc, 0, 0, &host_disconnect_ie->hdr);

	if (result < 0)

		goto error_mmcie_set;

	/* WUSB1.0[8.5.3.1 & 7.5.2] */

	msleep(100);

	wusbhc_mmcie_rm(wusbhc, &host_disconnect_ie->hdr);

error_mmcie_set:

	kfree(host_disconnect_ie);

error_alloc:

	return result;

}

/*

 * wusbhc_stop - stop transmitting MMCs

 * @wusbhc: the HC to stop

 *

 * Send a Host Disconnect IE, wait, remove all the MMCs (stop sending MMCs).

 *

 * If we can't allocate a Host Stop IE, screw it, we don't notify the

 * devices we are disconnecting...

 */

void wusbhc_stop(struct wusbhc *wusbhc)

{

	if (wusbhc->active) {

		wusbhc->active = 0;

		wusbhc->stop(wusbhc);

		wusbhc_sec_stop(wusbhc);

		__wusbhc_host_disconnect_ie(wusbhc);

		wusbhc_devconnect_stop(wusbhc);

		wusbhc_rsv_terminate(wusbhc);

	}

}

EXPORT_SYMBOL_GPL(wusbhc_stop);

/*

 * Change the CHID in a WUSB Channel

 *

 * If it is just a new CHID, send a Host Disconnect IE and then change

 * the CHID IE.

 */

static int __wusbhc_chid_change(struct wusbhc *wusbhc,

				const struct wusb_ckhdid *chid)

{

	int result = -ENOSYS;

	struct device *dev = wusbhc->dev;

	dev_err(dev, "%s() not implemented yet\n", __func__);

	return result;

	BUG_ON(wusbhc->wuie_host_info == NULL);

	__wusbhc_host_disconnect_ie(wusbhc);

	wusbhc->wuie_host_info->CHID = *chid;

	result = wusbhc_mmcie_set(wusbhc, 0, 0, &wusbhc->wuie_host_info->hdr);

	if (result < 0)

		dev_err(dev, "Can't update Host Info WUSB IE: %d\n", result);

	return result;

}

/*

 * Set/reset/update a new CHID

 *

 * Depending on the previous state of the MMCs, start, stop or change

 * the sent MMC. This effectively switches the host controller on and

 * off (radio wise).

 */

int wusbhc_chid_set(struct wusbhc *wusbhc, const struct wusb_ckhdid *chid)

{

	int result = 0;

	if (memcmp(chid, &wusb_ckhdid_zero, sizeof(chid)) == 0)

		chid = NULL;

	mutex_lock(&wusbhc->mutex);

	if (wusbhc->active) {

		if (chid)

			result = __wusbhc_chid_change(wusbhc, chid);

		else

			wusbhc_stop(wusbhc);

	} else {

		if (chid)

			wusbhc_start(wusbhc, chid);

	}

	mutex_unlock(&wusbhc->mutex);

	return result;

}

EXPORT_SYMBOL_GPL(wusbhc_chid_set);