[deliverable/linux.git] / drivers / uwb / drp.c

/*
 * Ultra Wide Band
 * Dynamic Reservation Protocol handling
 *
 * Copyright (C) 2005-2006 Intel Corporation
 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
 * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
 *
 * 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, see <http://www.gnu.org/licenses/>.
 */
#include <linux/kthread.h>
#include <linux/freezer.h>
#include <linux/delay.h>
#include "uwb-internal.h"

/**
 * Construct and send the SET DRP IE
 *
 * @rc:         UWB Host controller
 * @returns:    >= 0 number of bytes still available in the beacon
 *              < 0 errno code on error.
 *
 * See WUSB[8.6.2.7]: The host must set all the DRP IEs that it wants the
 * device to include in its beacon at the same time. We thus have to
 * traverse all reservations and include the DRP IEs of all PENDING
 * and NEGOTIATED reservations in a SET DRP command for transmission.
 *
 * A DRP Availability IE is appended.
 *
 * rc->uwb_dev.mutex is held
 *
 * FIXME We currently ignore the returned value indicating the remaining space
 * in beacon. This could be used to deny reservation requests earlier if
 * determined that they would cause the beacon space to be exceeded.
 */
static
int uwb_rc_gen_send_drp_ie(struct uwb_rc *rc)
{
	int result;
	struct device *dev = &rc->uwb_dev.dev;
	struct uwb_rc_cmd_set_drp_ie *cmd;
	struct uwb_rc_evt_set_drp_ie reply;
	struct uwb_rsv *rsv;
	int num_bytes = 0;
	u8 *IEDataptr;

	result = -ENOMEM;
	/* First traverse all reservations to determine memory needed. */
	list_for_each_entry(rsv, &rc->reservations, rc_node) {
		if (rsv->drp_ie != NULL)
			num_bytes += rsv->drp_ie->hdr.length + 2;
	}
	num_bytes += sizeof(rc->drp_avail.ie);
	cmd = kzalloc(sizeof(*cmd) + num_bytes, GFP_KERNEL);
	if (cmd == NULL)
		goto error;
	cmd->rccb.bCommandType = UWB_RC_CET_GENERAL;
	cmd->rccb.wCommand = cpu_to_le16(UWB_RC_CMD_SET_DRP_IE);
	cmd->wIELength = num_bytes;
	IEDataptr = (u8 *)&cmd->IEData[0];

	/* Next traverse all reservations to place IEs in allocated memory. */
	list_for_each_entry(rsv, &rc->reservations, rc_node) {
		if (rsv->drp_ie != NULL) {
			memcpy(IEDataptr, rsv->drp_ie,
			       rsv->drp_ie->hdr.length + 2);
			IEDataptr += rsv->drp_ie->hdr.length + 2;
		}
	}
	memcpy(IEDataptr, &rc->drp_avail.ie, sizeof(rc->drp_avail.ie));

	reply.rceb.bEventType = UWB_RC_CET_GENERAL;
	reply.rceb.wEvent = UWB_RC_CMD_SET_DRP_IE;
	result = uwb_rc_cmd(rc, "SET-DRP-IE", &cmd->rccb,
			sizeof(*cmd) + num_bytes, &reply.rceb,
			sizeof(reply));
	if (result < 0)
		goto error_cmd;
	result = le16_to_cpu(reply.wRemainingSpace);
	if (reply.bResultCode != UWB_RC_RES_SUCCESS) {
		dev_err(&rc->uwb_dev.dev, "SET-DRP-IE: command execution "
				"failed: %s (%d). RemainingSpace in beacon "
				"= %d\n", uwb_rc_strerror(reply.bResultCode),
				reply.bResultCode, result);
		result = -EIO;
	} else {
		dev_dbg(dev, "SET-DRP-IE sent. RemainingSpace in beacon "
			     "= %d.\n", result);
		result = 0;
	}
error_cmd:
	kfree(cmd);
error:
	return result;

}
/**
 * Send all DRP IEs associated with this host
 *
 * @returns:    >= 0 number of bytes still available in the beacon
 *              < 0 errno code on error.
 *
 * As per the protocol we obtain the host controller device lock to access
 * bandwidth structures.
 */
int uwb_rc_send_all_drp_ie(struct uwb_rc *rc)
{
	int result;

	mutex_lock(&rc->uwb_dev.mutex);
	result = uwb_rc_gen_send_drp_ie(rc);
	mutex_unlock(&rc->uwb_dev.mutex);
	return result;
}

void uwb_drp_handle_timeout(struct uwb_rsv *rsv)
{
	struct device *dev = &rsv->rc->uwb_dev.dev;

	dev_dbg(dev, "reservation timeout in state %s (%d)\n",
		uwb_rsv_state_str(rsv->state), rsv->state);

	switch (rsv->state) {
	case UWB_RSV_STATE_O_INITIATED:
		if (rsv->is_multicast) {
			uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
			return;
		}
		break;
	case UWB_RSV_STATE_O_ESTABLISHED:
		if (rsv->is_multicast)
			return;
		break;
	default:
		break;
	}
	uwb_rsv_remove(rsv);
}

/*
 * Based on the DRP IE, transition a target reservation to a new
 * state.
 */
static void uwb_drp_process_target(struct uwb_rc *rc, struct uwb_rsv *rsv,
				   struct uwb_ie_drp *drp_ie)
{
	struct device *dev = &rc->uwb_dev.dev;
	int status;
	enum uwb_drp_reason reason_code;

	status = uwb_ie_drp_status(drp_ie);
	reason_code = uwb_ie_drp_reason_code(drp_ie);

	if (status) {
		switch (reason_code) {
		case UWB_DRP_REASON_ACCEPTED:
			uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
			break;
		case UWB_DRP_REASON_MODIFIED:
			dev_err(dev, "FIXME: unhandled reason code (%d/%d)\n",
				reason_code, status);
			break;
		default:
			dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
				 reason_code, status);
		}
	} else {
		switch (reason_code) {
		case UWB_DRP_REASON_ACCEPTED:
			/* New reservations are handled in uwb_rsv_find(). */
			break;
		case UWB_DRP_REASON_DENIED:
			uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
			break;
		case UWB_DRP_REASON_CONFLICT:
		case UWB_DRP_REASON_MODIFIED:
			dev_err(dev, "FIXME: unhandled reason code (%d/%d)\n",
				reason_code, status);
			break;
		default:
			dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
				 reason_code, status);
		}
	}
}

/*
 * Based on the DRP IE, transition an owner reservation to a new
 * state.
 */
static void uwb_drp_process_owner(struct uwb_rc *rc, struct uwb_rsv *rsv,
				  struct uwb_ie_drp *drp_ie)
{
	struct device *dev = &rc->uwb_dev.dev;
	int status;
	enum uwb_drp_reason reason_code;

	status = uwb_ie_drp_status(drp_ie);
	reason_code = uwb_ie_drp_reason_code(drp_ie);

	if (status) {
		switch (reason_code) {
		case UWB_DRP_REASON_ACCEPTED:
			uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
			break;
		case UWB_DRP_REASON_MODIFIED:
			dev_err(dev, "FIXME: unhandled reason code (%d/%d)\n",
				reason_code, status);
			break;
		default:
			dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
				 reason_code, status);
		}
	} else {
		switch (reason_code) {
		case UWB_DRP_REASON_PENDING:
			uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_PENDING);
			break;
		case UWB_DRP_REASON_DENIED:
			uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
			break;
		case UWB_DRP_REASON_CONFLICT:
		case UWB_DRP_REASON_MODIFIED:
			dev_err(dev, "FIXME: unhandled reason code (%d/%d)\n",
				reason_code, status);
			break;
		default:
			dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
				 reason_code, status);
		}
	}
}

/*
 * Process a received DRP IE, it's either for a reservation owned by
 * the RC or targeted at it (or it's for a WUSB cluster reservation).
 */
static void uwb_drp_process(struct uwb_rc *rc, struct uwb_dev *src,
		     struct uwb_ie_drp *drp_ie)
{
	struct uwb_rsv *rsv;

	rsv = uwb_rsv_find(rc, src, drp_ie);
	if (!rsv) {
		/*
		 * No reservation? It's either for a recently
		 * terminated reservation; or the DRP IE couldn't be
		 * processed (e.g., an invalid IE or out of memory).
		 */
		return;
	}

	/*
	 * Do nothing with DRP IEs for reservations that have been
	 * terminated.
	 */
	if (rsv->state == UWB_RSV_STATE_NONE) {
		uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
		return;
	}

	if (uwb_ie_drp_owner(drp_ie))
		uwb_drp_process_target(rc, rsv, drp_ie);
	else
		uwb_drp_process_owner(rc, rsv, drp_ie);
}


/*
 * Process all the DRP IEs (both DRP IEs and the DRP Availability IE)
 * from a device.
 */
static
void uwb_drp_process_all(struct uwb_rc *rc, struct uwb_rc_evt_drp *drp_evt,
			 size_t ielen, struct uwb_dev *src_dev)
{
	struct device *dev = &rc->uwb_dev.dev;
	struct uwb_ie_hdr *ie_hdr;
	void *ptr;

	ptr = drp_evt->ie_data;
	for (;;) {
		ie_hdr = uwb_ie_next(&ptr, &ielen);
		if (!ie_hdr)
			break;

		switch (ie_hdr->element_id) {
		case UWB_IE_DRP_AVAILABILITY:
			/* FIXME: does something need to be done with this? */
			break;
		case UWB_IE_DRP:
			uwb_drp_process(rc, src_dev, (struct uwb_ie_drp *)ie_hdr);
			break;
		default:
			dev_warn(dev, "unexpected IE in DRP notification\n");
			break;
		}
	}

	if (ielen > 0)
		dev_warn(dev, "%d octets remaining in DRP notification\n",
			 (int)ielen);
}


/*
 * Go through all the DRP IEs and find the ones that conflict with our
 * reservations.
 *
 * FIXME: must resolve the conflict according the the rules in
 * [ECMA-368].
 */
static
void uwb_drp_process_conflict_all(struct uwb_rc *rc, struct uwb_rc_evt_drp *drp_evt,
				  size_t ielen, struct uwb_dev *src_dev)
{
	struct device *dev = &rc->uwb_dev.dev;
	struct uwb_ie_hdr *ie_hdr;
	struct uwb_ie_drp *drp_ie;
	void *ptr;

	ptr = drp_evt->ie_data;
	for (;;) {
		ie_hdr = uwb_ie_next(&ptr, &ielen);
		if (!ie_hdr)
			break;

		drp_ie = container_of(ie_hdr, struct uwb_ie_drp, hdr);

		/* FIXME: check if this DRP IE conflicts. */
	}

	if (ielen > 0)
		dev_warn(dev, "%d octets remaining in DRP notification\n",
			 (int)ielen);
}


/*
 * Terminate all reservations owned by, or targeted at, 'uwb_dev'.
 */
static void uwb_drp_terminate_all(struct uwb_rc *rc, struct uwb_dev *uwb_dev)
{
	struct uwb_rsv *rsv;

	list_for_each_entry(rsv, &rc->reservations, rc_node) {
		if (rsv->owner == uwb_dev
		    || (rsv->target.type == UWB_RSV_TARGET_DEV && rsv->target.dev == uwb_dev))
			uwb_rsv_remove(rsv);
	}
}


/**
 * uwbd_evt_handle_rc_drp - handle a DRP_IE event
 * @evt: the DRP_IE event from the radio controller
 *
 * This processes DRP notifications from the radio controller, either
 * initiating a new reservation or transitioning an existing
 * reservation into a different state.
 *
 * DRP notifications can occur for three different reasons:
 *
 * - UWB_DRP_NOTIF_DRP_IE_RECVD: one or more DRP IEs with the RC as
 *   the target or source have been recieved.
 *
 *   These DRP IEs could be new or for an existing reservation.
 *
 *   If the DRP IE for an existing reservation ceases to be to
 *   recieved for at least mMaxLostBeacons, the reservation should be
 *   considered to be terminated.  Note that the TERMINATE reason (see
 *   below) may not always be signalled (e.g., the remote device has
 *   two or more reservations established with the RC).
 *
 * - UWB_DRP_NOTIF_CONFLICT: DRP IEs from any device in the beacon
 *   group conflict with the RC's reservations.
 *
 * - UWB_DRP_NOTIF_TERMINATE: DRP IEs are no longer being received
 *   from a device (i.e., it's terminated all reservations).
 *
 * Only the software state of the reservations is changed; the setting
 * of the radio controller's DRP IEs is done after all the events in
 * an event buffer are processed.  This saves waiting multiple times
 * for the SET_DRP_IE command to complete.
 */
int uwbd_evt_handle_rc_drp(struct uwb_event *evt)
{
	struct device *dev = &evt->rc->uwb_dev.dev;
	struct uwb_rc *rc = evt->rc;
	struct uwb_rc_evt_drp *drp_evt;
	size_t ielength, bytes_left;
	struct uwb_dev_addr src_addr;
	struct uwb_dev *src_dev;
	int reason;

	/* Is there enough data to decode the event (and any IEs in
	   its payload)? */
	if (evt->notif.size < sizeof(*drp_evt)) {
		dev_err(dev, "DRP event: Not enough data to decode event "
			"[%zu bytes left, %zu needed]\n",
			evt->notif.size, sizeof(*drp_evt));
		return 0;
	}
	bytes_left = evt->notif.size - sizeof(*drp_evt);
	drp_evt = container_of(evt->notif.rceb, struct uwb_rc_evt_drp, rceb);
	ielength = le16_to_cpu(drp_evt->ie_length);
	if (bytes_left != ielength) {
		dev_err(dev, "DRP event: Not enough data in payload [%zu"
			"bytes left, %zu declared in the event]\n",
			bytes_left, ielength);
		return 0;
	}

	memcpy(src_addr.data, &drp_evt->src_addr, sizeof(src_addr));
	src_dev = uwb_dev_get_by_devaddr(rc, &src_addr);
	if (!src_dev) {
		/*
		 * A DRP notification from an unrecognized device.
		 *
		 * This is probably from a WUSB device that doesn't
		 * have an EUI-48 and therefore doesn't show up in the
		 * UWB device database.  It's safe to simply ignore
		 * these.
		 */
		return 0;
	}

	mutex_lock(&rc->rsvs_mutex);

	reason = uwb_rc_evt_drp_reason(drp_evt);

	switch (reason) {
	case UWB_DRP_NOTIF_DRP_IE_RCVD:
		uwb_drp_process_all(rc, drp_evt, ielength, src_dev);
		break;
	case UWB_DRP_NOTIF_CONFLICT:
		uwb_drp_process_conflict_all(rc, drp_evt, ielength, src_dev);
		break;
	case UWB_DRP_NOTIF_TERMINATE:
		uwb_drp_terminate_all(rc, src_dev);
		break;
	default:
		dev_warn(dev, "ignored DRP event with reason code: %d\n", reason);
		break;
	}

	mutex_unlock(&rc->rsvs_mutex);

	uwb_dev_put(src_dev);
	return 0;
}
Commit	Line	Data
8cc13a09 DV	1	/*
	2	* Ultra Wide Band
	3	* Dynamic Reservation Protocol handling
	4	*
	5	* Copyright (C) 2005-2006 Intel Corporation
	6	* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
	7	* Copyright (C) 2008 Cambridge Silicon Radio Ltd.
	8	*
	9	* This program is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU General Public License version
	11	* 2 as published by the Free Software Foundation.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	20	*/
	21	#include <linux/kthread.h>
	22	#include <linux/freezer.h>
	23	#include <linux/delay.h>
	24	#include "uwb-internal.h"
	25
	26	/**
	27	* Construct and send the SET DRP IE
	28	*
	29	* @rc: UWB Host controller
	30	* @returns: >= 0 number of bytes still available in the beacon
	31	* < 0 errno code on error.
	32	*
	33	* See WUSB[8.6.2.7]: The host must set all the DRP IEs that it wants the
	34	* device to include in its beacon at the same time. We thus have to
	35	* traverse all reservations and include the DRP IEs of all PENDING
	36	* and NEGOTIATED reservations in a SET DRP command for transmission.
	37	*
	38	* A DRP Availability IE is appended.
	39	*
	40	* rc->uwb_dev.mutex is held
	41	*
	42	* FIXME We currently ignore the returned value indicating the remaining space
	43	* in beacon. This could be used to deny reservation requests earlier if
	44	* determined that they would cause the beacon space to be exceeded.
	45	*/
	46	static
	47	int uwb_rc_gen_send_drp_ie(struct uwb_rc *rc)
	48	{
	49	int result;
	50	struct device *dev = &rc->uwb_dev.dev;
	51	struct uwb_rc_cmd_set_drp_ie *cmd;
	52	struct uwb_rc_evt_set_drp_ie reply;
	53	struct uwb_rsv *rsv;
	54	int num_bytes = 0;
	55	u8 *IEDataptr;
	56
	57	result = -ENOMEM;
	58	/* First traverse all reservations to determine memory needed. */
	59	list_for_each_entry(rsv, &rc->reservations, rc_node) {
	60	if (rsv->drp_ie != NULL)
	61	num_bytes += rsv->drp_ie->hdr.length + 2;
	62	}
	63	num_bytes += sizeof(rc->drp_avail.ie);
	64	cmd = kzalloc(sizeof(*cmd) + num_bytes, GFP_KERNEL);
65	if (cmd == NULL)
66	goto error;
67	cmd->rccb.bCommandType = UWB_RC_CET_GENERAL;
68	cmd->rccb.wCommand = cpu_to_le16(UWB_RC_CMD_SET_DRP_IE);
69	cmd->wIELength = num_bytes;
70	IEDataptr = (u8 *)&cmd->IEData[0];
71
72	/* Next traverse all reservations to place IEs in allocated memory. */
73	list_for_each_entry(rsv, &rc->reservations, rc_node) {
74	if (rsv->drp_ie != NULL) {
75	memcpy(IEDataptr, rsv->drp_ie,
76	rsv->drp_ie->hdr.length + 2);
77	IEDataptr += rsv->drp_ie->hdr.length + 2;
78	}
79	}
80	memcpy(IEDataptr, &rc->drp_avail.ie, sizeof(rc->drp_avail.ie));
81
82	reply.rceb.bEventType = UWB_RC_CET_GENERAL;
83	reply.rceb.wEvent = UWB_RC_CMD_SET_DRP_IE;
84	result = uwb_rc_cmd(rc, "SET-DRP-IE", &cmd->rccb,
85	sizeof(*cmd) + num_bytes, &reply.rceb,
86	sizeof(reply));
87	if (result < 0)
88	goto error_cmd;
89	result = le16_to_cpu(reply.wRemainingSpace);
90	if (reply.bResultCode != UWB_RC_RES_SUCCESS) {
91	dev_err(&rc->uwb_dev.dev, "SET-DRP-IE: command execution "
92	"failed: %s (%d). RemainingSpace in beacon "
93	"= %d\n", uwb_rc_strerror(reply.bResultCode),
94	reply.bResultCode, result);
95	result = -EIO;
96	} else {
97	dev_dbg(dev, "SET-DRP-IE sent. RemainingSpace in beacon "
98	"= %d.\n", result);
99	result = 0;
100	}
101	error_cmd:
102	kfree(cmd);
103	error:
104	return result;
105
106	}
107	/**
108	* Send all DRP IEs associated with this host
109	*
110	* @returns: >= 0 number of bytes still available in the beacon
111	* < 0 errno code on error.
112	*
113	* As per the protocol we obtain the host controller device lock to access
114	* bandwidth structures.
115	*/
116	int uwb_rc_send_all_drp_ie(struct uwb_rc *rc)
117	{
118	int result;
119
120	mutex_lock(&rc->uwb_dev.mutex);
121	result = uwb_rc_gen_send_drp_ie(rc);
122	mutex_unlock(&rc->uwb_dev.mutex);
123	return result;
124	}
125
126	void uwb_drp_handle_timeout(struct uwb_rsv *rsv)
127	{
128	struct device *dev = &rsv->rc->uwb_dev.dev;
129
130	dev_dbg(dev, "reservation timeout in state %s (%d)\n",
131	uwb_rsv_state_str(rsv->state), rsv->state);
132
133	switch (rsv->state) {
134	case UWB_RSV_STATE_O_INITIATED:
135	if (rsv->is_multicast) {
136	uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
137	return;
138	}
139	break;
140	case UWB_RSV_STATE_O_ESTABLISHED:
141	if (rsv->is_multicast)
142	return;
143	break;
144	default:
145	break;
146	}
147	uwb_rsv_remove(rsv);
148	}
149
150	/*
151	* Based on the DRP IE, transition a target reservation to a new
152	* state.
153	*/
154	static void uwb_drp_process_target(struct uwb_rc rc, struct uwb_rsv rsv,
155	struct uwb_ie_drp *drp_ie)
156	{
157	struct device *dev = &rc->uwb_dev.dev;
158	int status;
159	enum uwb_drp_reason reason_code;
160
161	status = uwb_ie_drp_status(drp_ie);
162	reason_code = uwb_ie_drp_reason_code(drp_ie);
163
164	if (status) {
165	switch (reason_code) {
166	case UWB_DRP_REASON_ACCEPTED:
167	uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
168	break;
169	case UWB_DRP_REASON_MODIFIED:
170	dev_err(dev, "FIXME: unhandled reason code (%d/%d)\n",
171	reason_code, status);
172	break;
173	default:
174	dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
175	reason_code, status);
176	}
177	} else {
178	switch (reason_code) {
179	case UWB_DRP_REASON_ACCEPTED:
180	/* New reservations are handled in uwb_rsv_find(). */
181	break;
182	case UWB_DRP_REASON_DENIED:
183	uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
184	break;
185	case UWB_DRP_REASON_CONFLICT:
186	case UWB_DRP_REASON_MODIFIED:
187	dev_err(dev, "FIXME: unhandled reason code (%d/%d)\n",
188	reason_code, status);
189	break;
190	default:
191	dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
192	reason_code, status);
193	}
194	}
195	}
196
197	/*
198	* Based on the DRP IE, transition an owner reservation to a new
199	* state.
200	*/
201	static void uwb_drp_process_owner(struct uwb_rc rc, struct uwb_rsv rsv,
202	struct uwb_ie_drp *drp_ie)
203	{
204	struct device *dev = &rc->uwb_dev.dev;
205	int status;
206	enum uwb_drp_reason reason_code;
207
208	status = uwb_ie_drp_status(drp_ie);
209	reason_code = uwb_ie_drp_reason_code(drp_ie);
210
211	if (status) {
212	switch (reason_code) {
213	case UWB_DRP_REASON_ACCEPTED:
214	uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
215	break;
216	case UWB_DRP_REASON_MODIFIED:
217	dev_err(dev, "FIXME: unhandled reason code (%d/%d)\n",
218	reason_code, status);
219	break;
220	default:
221	dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
222	reason_code, status);
223	}
224	} else {
225	switch (reason_code) {
226	case UWB_DRP_REASON_PENDING:
227	uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_PENDING);
228	break;
229	case UWB_DRP_REASON_DENIED:
230	uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
231	break;
232	case UWB_DRP_REASON_CONFLICT:
233	case UWB_DRP_REASON_MODIFIED:
234	dev_err(dev, "FIXME: unhandled reason code (%d/%d)\n",
235	reason_code, status);
236	break;
237	default:
238	dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
239	reason_code, status);
240	}
241	}
242	}
243
244	/*
245	* Process a received DRP IE, it's either for a reservation owned by
246	* the RC or targeted at it (or it's for a WUSB cluster reservation).
247	*/
248	static void uwb_drp_process(struct uwb_rc rc, struct uwb_dev src,
249	struct uwb_ie_drp *drp_ie)
250	{
251	struct uwb_rsv *rsv;
252
253	rsv = uwb_rsv_find(rc, src, drp_ie);
254	if (!rsv) {
255	/*
256	* No reservation? It's either for a recently
257	* terminated reservation; or the DRP IE couldn't be
258	* processed (e.g., an invalid IE or out of memory).
259	*/
260	return;
261	}
262
263	/*
264	* Do nothing with DRP IEs for reservations that have been
265	* terminated.
266	*/
267	if (rsv->state == UWB_RSV_STATE_NONE) {
268	uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
269	return;
270	}
271
272	if (uwb_ie_drp_owner(drp_ie))
273	uwb_drp_process_target(rc, rsv, drp_ie);
274	else
275	uwb_drp_process_owner(rc, rsv, drp_ie);
276	}
277
278
279	/*
280	* Process all the DRP IEs (both DRP IEs and the DRP Availability IE)
281	* from a device.
282	*/
283	static
284	void uwb_drp_process_all(struct uwb_rc rc, struct uwb_rc_evt_drp drp_evt,
285	size_t ielen, struct uwb_dev *src_dev)
286	{
287	struct device *dev = &rc->uwb_dev.dev;
288	struct uwb_ie_hdr *ie_hdr;
289	void *ptr;
290
291	ptr = drp_evt->ie_data;
292	for (;;) {
293	ie_hdr = uwb_ie_next(&ptr, &ielen);
294	if (!ie_hdr)
295	break;
296
297	switch (ie_hdr->element_id) {
298	case UWB_IE_DRP_AVAILABILITY:
299	/* FIXME: does something need to be done with this? */
300	break;
301	case UWB_IE_DRP:
302	uwb_drp_process(rc, src_dev, (struct uwb_ie_drp *)ie_hdr);
303	break;
304	default:
305	dev_warn(dev, "unexpected IE in DRP notification\n");
306	break;
307	}
308	}
309
310	if (ielen > 0)
311	dev_warn(dev, "%d octets remaining in DRP notification\n",
312	(int)ielen);
313	}
314
315
316	/*
317	* Go through all the DRP IEs and find the ones that conflict with our
318	* reservations.
319	*
320	* FIXME: must resolve the conflict according the the rules in
321	* [ECMA-368].
322	*/
323	static
324	void uwb_drp_process_conflict_all(struct uwb_rc rc, struct uwb_rc_evt_drp drp_evt,
325	size_t ielen, struct uwb_dev *src_dev)
326	{
327	struct device *dev = &rc->uwb_dev.dev;
328	struct uwb_ie_hdr *ie_hdr;
329	struct uwb_ie_drp *drp_ie;
330	void *ptr;
331
332	ptr = drp_evt->ie_data;
333	for (;;) {
334	ie_hdr = uwb_ie_next(&ptr, &ielen);
335	if (!ie_hdr)
336	break;
337
338	drp_ie = container_of(ie_hdr, struct uwb_ie_drp, hdr);
339
340	/* FIXME: check if this DRP IE conflicts. */
341	}
342
343	if (ielen > 0)
344	dev_warn(dev, "%d octets remaining in DRP notification\n",
345	(int)ielen);
346	}
347
348
349	/*
350	* Terminate all reservations owned by, or targeted at, 'uwb_dev'.
351	*/
352	static void uwb_drp_terminate_all(struct uwb_rc rc, struct uwb_dev uwb_dev)
353	{
354	struct uwb_rsv *rsv;
355
356	list_for_each_entry(rsv, &rc->reservations, rc_node) {
357	if (rsv->owner == uwb_dev
358	\|\| (rsv->target.type == UWB_RSV_TARGET_DEV && rsv->target.dev == uwb_dev))
359	uwb_rsv_remove(rsv);
360	}
361	}
362
363
364	/**
365	* uwbd_evt_handle_rc_drp - handle a DRP_IE event
366	* @evt: the DRP_IE event from the radio controller
367	*
368	* This processes DRP notifications from the radio controller, either
369	* initiating a new reservation or transitioning an existing
370	* reservation into a different state.
371	*
372	* DRP notifications can occur for three different reasons:
373	*
374	* - UWB_DRP_NOTIF_DRP_IE_RECVD: one or more DRP IEs with the RC as
375	* the target or source have been recieved.
376	*
377	* These DRP IEs could be new or for an existing reservation.
378	*
379	* If the DRP IE for an existing reservation ceases to be to
380	* recieved for at least mMaxLostBeacons, the reservation should be
381	* considered to be terminated. Note that the TERMINATE reason (see
382	* below) may not always be signalled (e.g., the remote device has
383	* two or more reservations established with the RC).
384	*
385	* - UWB_DRP_NOTIF_CONFLICT: DRP IEs from any device in the beacon
386	* group conflict with the RC's reservations.
387	*
388	* - UWB_DRP_NOTIF_TERMINATE: DRP IEs are no longer being received
389	* from a device (i.e., it's terminated all reservations).
390	*
391	* Only the software state of the reservations is changed; the setting
392	* of the radio controller's DRP IEs is done after all the events in
393	* an event buffer are processed. This saves waiting multiple times
394	* for the SET_DRP_IE command to complete.
395	*/
396	int uwbd_evt_handle_rc_drp(struct uwb_event *evt)
397	{
398	struct device *dev = &evt->rc->uwb_dev.dev;
399	struct uwb_rc *rc = evt->rc;
400	struct uwb_rc_evt_drp *drp_evt;
401	size_t ielength, bytes_left;
402	struct uwb_dev_addr src_addr;
403	struct uwb_dev *src_dev;
404	int reason;
405
406	/* Is there enough data to decode the event (and any IEs in
407	its payload)? */
408	if (evt->notif.size < sizeof(*drp_evt)) {
409	dev_err(dev, "DRP event: Not enough data to decode event "
410	"[%zu bytes left, %zu needed]\n",
411	evt->notif.size, sizeof(*drp_evt));
412	return 0;
413	}
414	bytes_left = evt->notif.size - sizeof(*drp_evt);
415	drp_evt = container_of(evt->notif.rceb, struct uwb_rc_evt_drp, rceb);
416	ielength = le16_to_cpu(drp_evt->ie_length);
417	if (bytes_left != ielength) {
418	dev_err(dev, "DRP event: Not enough data in payload [%zu"
419	"bytes left, %zu declared in the event]\n",
420	bytes_left, ielength);
421	return 0;
422	}
423
424	memcpy(src_addr.data, &drp_evt->src_addr, sizeof(src_addr));
425	src_dev = uwb_dev_get_by_devaddr(rc, &src_addr);
426	if (!src_dev) {
427	/*
428	* A DRP notification from an unrecognized device.
429	*
430	* This is probably from a WUSB device that doesn't
431	* have an EUI-48 and therefore doesn't show up in the
432	* UWB device database. It's safe to simply ignore
433	* these.
434	*/
435	return 0;
436	}
437
438	mutex_lock(&rc->rsvs_mutex);
439
440	reason = uwb_rc_evt_drp_reason(drp_evt);
441
442	switch (reason) {
443	case UWB_DRP_NOTIF_DRP_IE_RCVD:
444	uwb_drp_process_all(rc, drp_evt, ielength, src_dev);
445	break;
446	case UWB_DRP_NOTIF_CONFLICT:
447	uwb_drp_process_conflict_all(rc, drp_evt, ielength, src_dev);
448	break;
449	case UWB_DRP_NOTIF_TERMINATE:
450	uwb_drp_terminate_all(rc, src_dev);
451	break;
452	default:
453	dev_warn(dev, "ignored DRP event with reason code: %d\n", reason);
454	break;
455	}
456
457	mutex_unlock(&rc->rsvs_mutex);
458
459	uwb_dev_put(src_dev);
460	return 0;
461	}