aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/uwb/wlp/eda.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/uwb/wlp/eda.c')
-rw-r--r--drivers/uwb/wlp/eda.c415
1 files changed, 0 insertions, 415 deletions
diff --git a/drivers/uwb/wlp/eda.c b/drivers/uwb/wlp/eda.c
deleted file mode 100644
index 086fc0cf9401..000000000000
--- a/drivers/uwb/wlp/eda.c
+++ /dev/null
@@ -1,415 +0,0 @@
1/*
2 * WUSB Wire Adapter: WLP interface
3 * Ethernet to device address cache
4 *
5 * Copyright (C) 2005-2006 Intel Corporation
6 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License version
10 * 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 * 02110-1301, USA.
21 *
22 *
23 * We need to be able to map ethernet addresses to device addresses
24 * and back because there is not explicit relationship between the eth
25 * addresses used in the ETH frames and the device addresses (no, it
26 * would not have been simpler to force as ETH address the MBOA MAC
27 * address...no, not at all :).
28 *
29 * A device has one MBOA MAC address and one device address. It is possible
30 * for a device to have more than one virtual MAC address (although a
31 * virtual address can be the same as the MBOA MAC address). The device
32 * address is guaranteed to be unique among the devices in the extended
33 * beacon group (see ECMA 17.1.1). We thus use the device address as index
34 * to this cache. We do allow searching based on virtual address as this
35 * is how Ethernet frames will be addressed.
36 *
37 * We need to support virtual EUI-48. Although, right now the virtual
38 * EUI-48 will always be the same as the MAC SAP address. The EDA cache
39 * entry thus contains a MAC SAP address as well as the virtual address
40 * (used to map the network stack address to a neighbor). When we move
41 * to support more than one virtual MAC on a host then this organization
42 * will have to change. Perhaps a neighbor has a list of WSSs, each with a
43 * tag and virtual EUI-48.
44 *
45 * On data transmission
46 * it is used to determine if the neighbor is connected and what WSS it
47 * belongs to. With this we know what tag to add to the WLP frame. Storing
48 * the WSS in the EDA cache may be overkill because we only support one
49 * WSS. Hopefully we will support more than one WSS at some point.
50 * On data reception it is used to determine the WSS based on
51 * the tag and address of the transmitting neighbor.
52 */
53
54#include <linux/netdevice.h>
55#include <linux/etherdevice.h>
56#include <linux/slab.h>
57#include <linux/wlp.h>
58#include "wlp-internal.h"
59
60
61/* FIXME: cache is not purged, only on device close */
62
63/* FIXME: does not scale, change to dynamic array */
64
65/*
66 * Initialize the EDA cache
67 *
68 * @returns 0 if ok, < 0 errno code on error
69 *
70 * Call when the interface is being brought up
71 *
72 * NOTE: Keep it as a separate function as the implementation will
73 * change and be more complex.
74 */
75void wlp_eda_init(struct wlp_eda *eda)
76{
77 INIT_LIST_HEAD(&eda->cache);
78 spin_lock_init(&eda->lock);
79}
80
81/*
82 * Release the EDA cache
83 *
84 * @returns 0 if ok, < 0 errno code on error
85 *
86 * Called when the interface is brought down
87 */
88void wlp_eda_release(struct wlp_eda *eda)
89{
90 unsigned long flags;
91 struct wlp_eda_node *itr, *next;
92
93 spin_lock_irqsave(&eda->lock, flags);
94 list_for_each_entry_safe(itr, next, &eda->cache, list_node) {
95 list_del(&itr->list_node);
96 kfree(itr);
97 }
98 spin_unlock_irqrestore(&eda->lock, flags);
99}
100
101/*
102 * Add an address mapping
103 *
104 * @returns 0 if ok, < 0 errno code on error
105 *
106 * An address mapping is initially created when the neighbor device is seen
107 * for the first time (it is "onair"). At this time the neighbor is not
108 * connected or associated with a WSS so we only populate the Ethernet and
109 * Device address fields.
110 *
111 */
112int wlp_eda_create_node(struct wlp_eda *eda,
113 const unsigned char eth_addr[ETH_ALEN],
114 const struct uwb_dev_addr *dev_addr)
115{
116 int result = 0;
117 struct wlp_eda_node *itr;
118 unsigned long flags;
119
120 BUG_ON(dev_addr == NULL || eth_addr == NULL);
121 spin_lock_irqsave(&eda->lock, flags);
122 list_for_each_entry(itr, &eda->cache, list_node) {
123 if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
124 printk(KERN_ERR "EDA cache already contains entry "
125 "for neighbor %02x:%02x\n",
126 dev_addr->data[1], dev_addr->data[0]);
127 result = -EEXIST;
128 goto out_unlock;
129 }
130 }
131 itr = kzalloc(sizeof(*itr), GFP_ATOMIC);
132 if (itr != NULL) {
133 memcpy(itr->eth_addr, eth_addr, sizeof(itr->eth_addr));
134 itr->dev_addr = *dev_addr;
135 list_add(&itr->list_node, &eda->cache);
136 } else
137 result = -ENOMEM;
138out_unlock:
139 spin_unlock_irqrestore(&eda->lock, flags);
140 return result;
141}
142
143/*
144 * Remove entry from EDA cache
145 *
146 * This is done when the device goes off air.
147 */
148void wlp_eda_rm_node(struct wlp_eda *eda, const struct uwb_dev_addr *dev_addr)
149{
150 struct wlp_eda_node *itr, *next;
151 unsigned long flags;
152
153 spin_lock_irqsave(&eda->lock, flags);
154 list_for_each_entry_safe(itr, next, &eda->cache, list_node) {
155 if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
156 list_del(&itr->list_node);
157 kfree(itr);
158 break;
159 }
160 }
161 spin_unlock_irqrestore(&eda->lock, flags);
162}
163
164/*
165 * Update an address mapping
166 *
167 * @returns 0 if ok, < 0 errno code on error
168 */
169int wlp_eda_update_node(struct wlp_eda *eda,
170 const struct uwb_dev_addr *dev_addr,
171 struct wlp_wss *wss,
172 const unsigned char virt_addr[ETH_ALEN],
173 const u8 tag, const enum wlp_wss_connect state)
174{
175 int result = -ENOENT;
176 struct wlp_eda_node *itr;
177 unsigned long flags;
178
179 spin_lock_irqsave(&eda->lock, flags);
180 list_for_each_entry(itr, &eda->cache, list_node) {
181 if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
182 /* Found it, update it */
183 itr->wss = wss;
184 memcpy(itr->virt_addr, virt_addr,
185 sizeof(itr->virt_addr));
186 itr->tag = tag;
187 itr->state = state;
188 result = 0;
189 goto out_unlock;
190 }
191 }
192 /* Not found */
193out_unlock:
194 spin_unlock_irqrestore(&eda->lock, flags);
195 return result;
196}
197
198/*
199 * Update only state field of an address mapping
200 *
201 * @returns 0 if ok, < 0 errno code on error
202 */
203int wlp_eda_update_node_state(struct wlp_eda *eda,
204 const struct uwb_dev_addr *dev_addr,
205 const enum wlp_wss_connect state)
206{
207 int result = -ENOENT;
208 struct wlp_eda_node *itr;
209 unsigned long flags;
210
211 spin_lock_irqsave(&eda->lock, flags);
212 list_for_each_entry(itr, &eda->cache, list_node) {
213 if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
214 /* Found it, update it */
215 itr->state = state;
216 result = 0;
217 goto out_unlock;
218 }
219 }
220 /* Not found */
221out_unlock:
222 spin_unlock_irqrestore(&eda->lock, flags);
223 return result;
224}
225
226/*
227 * Return contents of EDA cache entry
228 *
229 * @dev_addr: index to EDA cache
230 * @eda_entry: pointer to where contents of EDA cache will be copied
231 */
232int wlp_copy_eda_node(struct wlp_eda *eda, struct uwb_dev_addr *dev_addr,
233 struct wlp_eda_node *eda_entry)
234{
235 int result = -ENOENT;
236 struct wlp_eda_node *itr;
237 unsigned long flags;
238
239 spin_lock_irqsave(&eda->lock, flags);
240 list_for_each_entry(itr, &eda->cache, list_node) {
241 if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
242 *eda_entry = *itr;
243 result = 0;
244 goto out_unlock;
245 }
246 }
247 /* Not found */
248out_unlock:
249 spin_unlock_irqrestore(&eda->lock, flags);
250 return result;
251}
252
253/*
254 * Execute function for every element in the cache
255 *
256 * @function: function to execute on element of cache (must be atomic)
257 * @priv: private data of function
258 * @returns: result of first function that failed, or last function
259 * executed if no function failed.
260 *
261 * Stop executing when function returns error for any element in cache.
262 *
263 * IMPORTANT: We are using a spinlock here: the function executed on each
264 * element has to be atomic.
265 */
266int wlp_eda_for_each(struct wlp_eda *eda, wlp_eda_for_each_f function,
267 void *priv)
268{
269 int result = 0;
270 struct wlp *wlp = container_of(eda, struct wlp, eda);
271 struct wlp_eda_node *entry;
272 unsigned long flags;
273
274 spin_lock_irqsave(&eda->lock, flags);
275 list_for_each_entry(entry, &eda->cache, list_node) {
276 result = (*function)(wlp, entry, priv);
277 if (result < 0)
278 break;
279 }
280 spin_unlock_irqrestore(&eda->lock, flags);
281 return result;
282}
283
284/*
285 * Execute function for single element in the cache (return dev addr)
286 *
287 * @virt_addr: index into EDA cache used to determine which element to
288 * execute the function on
289 * @dev_addr: device address of element in cache will be returned using
290 * @dev_addr
291 * @function: function to execute on element of cache (must be atomic)
292 * @priv: private data of function
293 * @returns: result of function
294 *
295 * IMPORTANT: We are using a spinlock here: the function executed on the
296 * element has to be atomic.
297 */
298int wlp_eda_for_virtual(struct wlp_eda *eda,
299 const unsigned char virt_addr[ETH_ALEN],
300 struct uwb_dev_addr *dev_addr,
301 wlp_eda_for_each_f function,
302 void *priv)
303{
304 int result = 0;
305 struct wlp *wlp = container_of(eda, struct wlp, eda);
306 struct wlp_eda_node *itr;
307 unsigned long flags;
308 int found = 0;
309
310 spin_lock_irqsave(&eda->lock, flags);
311 list_for_each_entry(itr, &eda->cache, list_node) {
312 if (!memcmp(itr->virt_addr, virt_addr,
313 sizeof(itr->virt_addr))) {
314 result = (*function)(wlp, itr, priv);
315 *dev_addr = itr->dev_addr;
316 found = 1;
317 break;
318 }
319 }
320 if (!found)
321 result = -ENODEV;
322 spin_unlock_irqrestore(&eda->lock, flags);
323 return result;
324}
325
326static const char *__wlp_wss_connect_state[] = { "WLP_WSS_UNCONNECTED",
327 "WLP_WSS_CONNECTED",
328 "WLP_WSS_CONNECT_FAILED",
329};
330
331static const char *wlp_wss_connect_state_str(unsigned id)
332{
333 if (id >= ARRAY_SIZE(__wlp_wss_connect_state))
334 return "unknown WSS connection state";
335 return __wlp_wss_connect_state[id];
336}
337
338/*
339 * View EDA cache from user space
340 *
341 * A debugging feature to give user visibility into the EDA cache. Also
342 * used to display members of WSS to user (called from wlp_wss_members_show())
343 */
344ssize_t wlp_eda_show(struct wlp *wlp, char *buf)
345{
346 ssize_t result = 0;
347 struct wlp_eda_node *entry;
348 unsigned long flags;
349 struct wlp_eda *eda = &wlp->eda;
350 spin_lock_irqsave(&eda->lock, flags);
351 result = scnprintf(buf, PAGE_SIZE, "#eth_addr dev_addr wss_ptr "
352 "tag state virt_addr\n");
353 list_for_each_entry(entry, &eda->cache, list_node) {
354 result += scnprintf(buf + result, PAGE_SIZE - result,
355 "%pM %02x:%02x %p 0x%02x %s %pM\n",
356 entry->eth_addr,
357 entry->dev_addr.data[1],
358 entry->dev_addr.data[0], entry->wss,
359 entry->tag,
360 wlp_wss_connect_state_str(entry->state),
361 entry->virt_addr);
362 if (result >= PAGE_SIZE)
363 break;
364 }
365 spin_unlock_irqrestore(&eda->lock, flags);
366 return result;
367}
368EXPORT_SYMBOL_GPL(wlp_eda_show);
369
370/*
371 * Add new EDA cache entry based on user input in sysfs
372 *
373 * Should only be used for debugging.
374 *
375 * The WSS is assumed to be the only WSS supported. This needs to be
376 * redesigned when we support more than one WSS.
377 */
378ssize_t wlp_eda_store(struct wlp *wlp, const char *buf, size_t size)
379{
380 ssize_t result;
381 struct wlp_eda *eda = &wlp->eda;
382 u8 eth_addr[6];
383 struct uwb_dev_addr dev_addr;
384 u8 tag;
385 unsigned state;
386
387 result = sscanf(buf, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx "
388 "%02hhx:%02hhx %02hhx %u\n",
389 &eth_addr[0], &eth_addr[1],
390 &eth_addr[2], &eth_addr[3],
391 &eth_addr[4], &eth_addr[5],
392 &dev_addr.data[1], &dev_addr.data[0], &tag, &state);
393 switch (result) {
394 case 6: /* no dev addr specified -- remove entry NOT IMPLEMENTED */
395 /*result = wlp_eda_rm(eda, eth_addr, &dev_addr);*/
396 result = -ENOSYS;
397 break;
398 case 10:
399 state = state >= 1 ? 1 : 0;
400 result = wlp_eda_create_node(eda, eth_addr, &dev_addr);
401 if (result < 0 && result != -EEXIST)
402 goto error;
403 /* Set virtual addr to be same as MAC */
404 result = wlp_eda_update_node(eda, &dev_addr, &wlp->wss,
405 eth_addr, tag, state);
406 if (result < 0)
407 goto error;
408 break;
409 default: /* bad format */
410 result = -EINVAL;
411 }
412error:
413 return result < 0 ? result : size;
414}
415EXPORT_SYMBOL_GPL(wlp_eda_store);
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-28 19:59:36 -0500