Driver core: Constify struct sysfs_ops in struct kobj_type
[linux-2.6.git] / drivers / uwb / address.c
1 /*
2  * Ultra Wide Band
3  * Address management
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  * FIXME: docs
24  */
25
26 #include <linux/errno.h>
27 #include <linux/module.h>
28 #include <linux/device.h>
29 #include <linux/random.h>
30 #include <linux/etherdevice.h>
31
32 #include "uwb-internal.h"
33
34
35 /** Device Address Management command */
36 struct uwb_rc_cmd_dev_addr_mgmt {
37         struct uwb_rccb rccb;
38         u8 bmOperationType;
39         u8 baAddr[6];
40 } __attribute__((packed));
41
42
43 /**
44  * Low level command for setting/getting UWB radio's addresses
45  *
46  * @hwarc:      HWA Radio Control interface instance
47  * @bmOperationType:
48  *              Set/get, MAC/DEV (see WUSB1.0[8.6.2.2])
49  * @baAddr:     address buffer--assumed to have enough data to hold
50  *              the address type requested.
51  * @reply:      Pointer to reply buffer (can be stack allocated)
52  * @returns:    0 if ok, < 0 errno code on error.
53  *
54  * @cmd has to be allocated because USB cannot grok USB or vmalloc
55  * buffers depending on your combination of host architecture.
56  */
57 static
58 int uwb_rc_dev_addr_mgmt(struct uwb_rc *rc,
59                          u8 bmOperationType, const u8 *baAddr,
60                          struct uwb_rc_evt_dev_addr_mgmt *reply)
61 {
62         int result;
63         struct uwb_rc_cmd_dev_addr_mgmt *cmd;
64
65         result = -ENOMEM;
66         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
67         if (cmd == NULL)
68                 goto error_kzalloc;
69         cmd->rccb.bCommandType = UWB_RC_CET_GENERAL;
70         cmd->rccb.wCommand = cpu_to_le16(UWB_RC_CMD_DEV_ADDR_MGMT);
71         cmd->bmOperationType = bmOperationType;
72         if (baAddr) {
73                 size_t size = 0;
74                 switch (bmOperationType >> 1) {
75                 case 0: size = 2; break;
76                 case 1: size = 6; break;
77                 default: BUG();
78                 }
79                 memcpy(cmd->baAddr, baAddr, size);
80         }
81         reply->rceb.bEventType = UWB_RC_CET_GENERAL;
82         reply->rceb.wEvent = UWB_RC_CMD_DEV_ADDR_MGMT;
83         result = uwb_rc_cmd(rc, "DEV-ADDR-MGMT",
84                             &cmd->rccb, sizeof(*cmd),
85                             &reply->rceb, sizeof(*reply));
86         if (result < 0)
87                 goto error_cmd;
88         if (result < sizeof(*reply)) {
89                 dev_err(&rc->uwb_dev.dev,
90                         "DEV-ADDR-MGMT: not enough data replied: "
91                         "%d vs %zu bytes needed\n", result, sizeof(*reply));
92                 result = -ENOMSG;
93         } else if (reply->bResultCode != UWB_RC_RES_SUCCESS) {
94                 dev_err(&rc->uwb_dev.dev,
95                         "DEV-ADDR-MGMT: command execution failed: %s (%d)\n",
96                         uwb_rc_strerror(reply->bResultCode),
97                         reply->bResultCode);
98                 result = -EIO;
99         } else
100                 result = 0;
101 error_cmd:
102         kfree(cmd);
103 error_kzalloc:
104         return result;
105 }
106
107
108 /**
109  * Set the UWB RC MAC or device address.
110  *
111  * @rc:      UWB Radio Controller
112  * @_addr:   Pointer to address to write [assumed to be either a
113  *           'struct uwb_mac_addr *' or a 'struct uwb_dev_addr *'].
114  * @type:    Type of address to set (UWB_ADDR_DEV or UWB_ADDR_MAC).
115  * @returns: 0 if ok, < 0 errno code on error.
116  *
117  * Some anal retentivity here: even if both 'struct
118  * uwb_{dev,mac}_addr' have the actual byte array in the same offset
119  * and I could just pass _addr to hwarc_cmd_dev_addr_mgmt(), I prefer
120  * to use some syntatic sugar in case someday we decide to change the
121  * format of the structs. The compiler will optimize it out anyway.
122  */
123 static int uwb_rc_addr_set(struct uwb_rc *rc,
124                     const void *_addr, enum uwb_addr_type type)
125 {
126         int result;
127         u8 bmOperationType = 0x1;               /* Set address */
128         const struct uwb_dev_addr *dev_addr = _addr;
129         const struct uwb_mac_addr *mac_addr = _addr;
130         struct uwb_rc_evt_dev_addr_mgmt reply;
131         const u8 *baAddr;
132
133         result = -EINVAL;
134         switch (type) {
135         case UWB_ADDR_DEV:
136                 baAddr = dev_addr->data;
137                 break;
138         case UWB_ADDR_MAC:
139                 baAddr = mac_addr->data;
140                 bmOperationType |= 0x2;
141                 break;
142         default:
143                 return result;
144         }
145         return uwb_rc_dev_addr_mgmt(rc, bmOperationType, baAddr, &reply);
146 }
147
148
149 /**
150  * Get the UWB radio's MAC or device address.
151  *
152  * @rc:      UWB Radio Controller
153  * @_addr:   Where to write the address data [assumed to be either a
154  *           'struct uwb_mac_addr *' or a 'struct uwb_dev_addr *'].
155  * @type:    Type of address to get (UWB_ADDR_DEV or UWB_ADDR_MAC).
156  * @returns: 0 if ok (and *_addr set), < 0 errno code on error.
157  *
158  * See comment in uwb_rc_addr_set() about anal retentivity in the
159  * type handling of the address variables.
160  */
161 static int uwb_rc_addr_get(struct uwb_rc *rc,
162                     void *_addr, enum uwb_addr_type type)
163 {
164         int result;
165         u8 bmOperationType = 0x0;               /* Get address */
166         struct uwb_rc_evt_dev_addr_mgmt evt;
167         struct uwb_dev_addr *dev_addr = _addr;
168         struct uwb_mac_addr *mac_addr = _addr;
169         u8 *baAddr;
170
171         result = -EINVAL;
172         switch (type) {
173         case UWB_ADDR_DEV:
174                 baAddr = dev_addr->data;
175                 break;
176         case UWB_ADDR_MAC:
177                 bmOperationType |= 0x2;
178                 baAddr = mac_addr->data;
179                 break;
180         default:
181                 return result;
182         }
183         result = uwb_rc_dev_addr_mgmt(rc, bmOperationType, baAddr, &evt);
184         if (result == 0)
185                 switch (type) {
186                 case UWB_ADDR_DEV:
187                         memcpy(&dev_addr->data, evt.baAddr,
188                                sizeof(dev_addr->data));
189                         break;
190                 case UWB_ADDR_MAC:
191                         memcpy(&mac_addr->data, evt.baAddr,
192                                sizeof(mac_addr->data));
193                         break;
194                 default:                /* shut gcc up */
195                         BUG();
196                 }
197         return result;
198 }
199
200
201 /** Get @rc's MAC address to @addr */
202 int uwb_rc_mac_addr_get(struct uwb_rc *rc,
203                         struct uwb_mac_addr *addr) {
204         return uwb_rc_addr_get(rc, addr, UWB_ADDR_MAC);
205 }
206 EXPORT_SYMBOL_GPL(uwb_rc_mac_addr_get);
207
208
209 /** Get @rc's device address to @addr */
210 int uwb_rc_dev_addr_get(struct uwb_rc *rc,
211                         struct uwb_dev_addr *addr) {
212         return uwb_rc_addr_get(rc, addr, UWB_ADDR_DEV);
213 }
214 EXPORT_SYMBOL_GPL(uwb_rc_dev_addr_get);
215
216
217 /** Set @rc's address to @addr */
218 int uwb_rc_mac_addr_set(struct uwb_rc *rc,
219                         const struct uwb_mac_addr *addr)
220 {
221         int result = -EINVAL;
222         mutex_lock(&rc->uwb_dev.mutex);
223         result = uwb_rc_addr_set(rc, addr, UWB_ADDR_MAC);
224         mutex_unlock(&rc->uwb_dev.mutex);
225         return result;
226 }
227
228
229 /** Set @rc's address to @addr */
230 int uwb_rc_dev_addr_set(struct uwb_rc *rc,
231                         const struct uwb_dev_addr *addr)
232 {
233         int result = -EINVAL;
234         mutex_lock(&rc->uwb_dev.mutex);
235         result = uwb_rc_addr_set(rc, addr, UWB_ADDR_DEV);
236         rc->uwb_dev.dev_addr = *addr;
237         mutex_unlock(&rc->uwb_dev.mutex);
238         return result;
239 }
240
241 /* Returns !0 if given address is already assigned to device. */
242 int __uwb_mac_addr_assigned_check(struct device *dev, void *_addr)
243 {
244         struct uwb_dev *uwb_dev = to_uwb_dev(dev);
245         struct uwb_mac_addr *addr = _addr;
246
247         if (!uwb_mac_addr_cmp(addr, &uwb_dev->mac_addr))
248                 return !0;
249         return 0;
250 }
251
252 /* Returns !0 if given address is already assigned to device. */
253 int __uwb_dev_addr_assigned_check(struct device *dev, void *_addr)
254 {
255         struct uwb_dev *uwb_dev = to_uwb_dev(dev);
256         struct uwb_dev_addr *addr = _addr;
257         if (!uwb_dev_addr_cmp(addr, &uwb_dev->dev_addr))
258                 return !0;
259         return 0;
260 }
261
262 /**
263  * uwb_dev_addr_assign - assigned a generated DevAddr to a radio controller
264  * @rc:      the (local) radio controller device requiring a new DevAddr
265  *
266  * A new DevAddr is required when:
267  *    - first setting up a radio controller
268  *    - if the hardware reports a DevAddr conflict
269  *
270  * The DevAddr is randomly generated in the generated DevAddr range
271  * [0x100, 0xfeff]. The number of devices in a beacon group is limited
272  * by mMaxBPLength (96) so this address space will never be exhausted.
273  *
274  * [ECMA-368] 17.1.1, 17.16.
275  */
276 int uwb_rc_dev_addr_assign(struct uwb_rc *rc)
277 {
278         struct uwb_dev_addr new_addr;
279
280         do {
281                 get_random_bytes(new_addr.data, sizeof(new_addr.data));
282         } while (new_addr.data[0] == 0x00 || new_addr.data[0] == 0xff
283                  || __uwb_dev_addr_assigned(rc, &new_addr));
284
285         return uwb_rc_dev_addr_set(rc, &new_addr);
286 }
287
288 /**
289  * uwbd_evt_handle_rc_dev_addr_conflict - handle a DEV_ADDR_CONFLICT event
290  * @evt: the DEV_ADDR_CONFLICT notification from the radio controller
291  *
292  * A new (non-conflicting) DevAddr is assigned to the radio controller.
293  *
294  * [ECMA-368] 17.1.1.1.
295  */
296 int uwbd_evt_handle_rc_dev_addr_conflict(struct uwb_event *evt)
297 {
298         struct uwb_rc *rc = evt->rc;
299
300         return uwb_rc_dev_addr_assign(rc);
301 }
302
303 /*
304  * Print the 48-bit EUI MAC address of the radio controller when
305  * reading /sys/class/uwb_rc/XX/mac_address
306  */
307 static ssize_t uwb_rc_mac_addr_show(struct device *dev,
308                                     struct device_attribute *attr, char *buf)
309 {
310         struct uwb_dev *uwb_dev = to_uwb_dev(dev);
311         struct uwb_rc *rc = uwb_dev->rc;
312         struct uwb_mac_addr addr;
313         ssize_t result;
314
315         mutex_lock(&rc->uwb_dev.mutex);
316         result = uwb_rc_addr_get(rc, &addr, UWB_ADDR_MAC);
317         mutex_unlock(&rc->uwb_dev.mutex);
318         if (result >= 0) {
319                 result = uwb_mac_addr_print(buf, UWB_ADDR_STRSIZE, &addr);
320                 buf[result++] = '\n';
321         }
322         return result;
323 }
324
325 /*
326  * Parse a 48 bit address written to /sys/class/uwb_rc/XX/mac_address
327  * and if correct, set it.
328  */
329 static ssize_t uwb_rc_mac_addr_store(struct device *dev,
330                                      struct device_attribute *attr,
331                                      const char *buf, size_t size)
332 {
333         struct uwb_dev *uwb_dev = to_uwb_dev(dev);
334         struct uwb_rc *rc = uwb_dev->rc;
335         struct uwb_mac_addr addr;
336         ssize_t result;
337
338         result = sscanf(buf, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx\n",
339                         &addr.data[0], &addr.data[1], &addr.data[2],
340                         &addr.data[3], &addr.data[4], &addr.data[5]);
341         if (result != 6) {
342                 result = -EINVAL;
343                 goto out;
344         }
345         if (is_multicast_ether_addr(addr.data)) {
346                 dev_err(&rc->uwb_dev.dev, "refusing to set multicast "
347                         "MAC address %s\n", buf);
348                 result = -EINVAL;
349                 goto out;
350         }
351         result = uwb_rc_mac_addr_set(rc, &addr);
352         if (result == 0)
353                 rc->uwb_dev.mac_addr = addr;
354 out:
355         return result < 0 ? result : size;
356 }
357 DEVICE_ATTR(mac_address, S_IRUGO | S_IWUSR, uwb_rc_mac_addr_show, uwb_rc_mac_addr_store);
358
359 /** Print @addr to @buf, @return bytes written */
360 size_t __uwb_addr_print(char *buf, size_t buf_size, const unsigned char *addr,
361                         int type)
362 {
363         size_t result;
364         if (type)
365                 result = scnprintf(buf, buf_size,
366                                   "%02x:%02x:%02x:%02x:%02x:%02x",
367                                   addr[0], addr[1], addr[2],
368                                   addr[3], addr[4], addr[5]);
369         else
370                 result = scnprintf(buf, buf_size, "%02x:%02x",
371                                   addr[1], addr[0]);
372         return result;
373 }
374 EXPORT_SYMBOL_GPL(__uwb_addr_print);