Merge git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux-2.6-for-linus
[linux-2.6] / drivers / uwb / wlp / sysfs.c
1 /*
2  * WiMedia Logical Link Control Protocol (WLP)
3  * sysfs functions
4  *
5  * Copyright (C) 2007 Intel Corporation
6  * Reinette Chatre <reinette.chatre@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
27 #include <linux/wlp.h>
28 #include "wlp-internal.h"
29
30 static
31 size_t wlp_wss_wssid_e_print(char *buf, size_t bufsize,
32                              struct wlp_wssid_e *wssid_e)
33 {
34         size_t used = 0;
35         used += scnprintf(buf, bufsize, " WSS: ");
36         used += wlp_wss_uuid_print(buf + used, bufsize - used,
37                                    &wssid_e->wssid);
38
39         if (wssid_e->info != NULL) {
40                 used += scnprintf(buf + used, bufsize - used, " ");
41                 used += uwb_mac_addr_print(buf + used, bufsize - used,
42                                            &wssid_e->info->bcast);
43                 used += scnprintf(buf + used, bufsize - used, " %u %u %s\n",
44                                   wssid_e->info->accept_enroll,
45                                   wssid_e->info->sec_status,
46                                   wssid_e->info->name);
47         }
48         return used;
49 }
50
51 /**
52  * Print out information learned from neighbor discovery
53  *
54  * Some fields being printed may not be included in the device discovery
55  * information (it is not mandatory). We are thus careful how the
56  * information is printed to ensure it is clear to the user what field is
57  * being referenced.
58  * The information being printed is for one time use - temporary storage is
59  * cleaned after it is printed.
60  *
61  * Ideally sysfs output should be on one line. The information printed here
62  * contain a few strings so it will be hard to parse if they are all
63  * printed on the same line - without agreeing on a standard field
64  * separator.
65  */
66 static
67 ssize_t wlp_wss_neighborhood_print_remove(struct wlp *wlp, char *buf,
68                                    size_t bufsize)
69 {
70         size_t used = 0;
71         struct wlp_neighbor_e *neighb;
72         struct wlp_wssid_e *wssid_e;
73
74         mutex_lock(&wlp->nbmutex);
75         used = scnprintf(buf, bufsize, "#Neighbor information\n"
76                          "#uuid dev_addr\n"
77                          "# Device Name:\n# Model Name:\n# Manufacturer:\n"
78                          "# Model Nr:\n# Serial:\n"
79                          "# Pri Dev type: CategoryID OUI OUISubdiv "
80                          "SubcategoryID\n"
81                          "# WSS: WSSID WSS_name accept_enroll sec_status "
82                          "bcast\n"
83                          "# WSS: WSSID WSS_name accept_enroll sec_status "
84                          "bcast\n\n");
85         list_for_each_entry(neighb, &wlp->neighbors, node) {
86                 if (bufsize - used <= 0)
87                         goto out;
88                 used += wlp_wss_uuid_print(buf + used, bufsize - used,
89                                            &neighb->uuid);
90                 buf[used++] = ' ';
91                 used += uwb_dev_addr_print(buf + used, bufsize - used,
92                                            &neighb->uwb_dev->dev_addr);
93                 if (neighb->info != NULL)
94                         used += scnprintf(buf + used, bufsize - used,
95                                           "\n Device Name: %s\n"
96                                           " Model Name: %s\n"
97                                           " Manufacturer:%s \n"
98                                           " Model Nr: %s\n"
99                                           " Serial: %s\n"
100                                           " Pri Dev type: "
101                                           "%u %02x:%02x:%02x %u %u\n",
102                                           neighb->info->name,
103                                           neighb->info->model_name,
104                                           neighb->info->manufacturer,
105                                           neighb->info->model_nr,
106                                           neighb->info->serial,
107                                           neighb->info->prim_dev_type.category,
108                                           neighb->info->prim_dev_type.OUI[0],
109                                           neighb->info->prim_dev_type.OUI[1],
110                                           neighb->info->prim_dev_type.OUI[2],
111                                           neighb->info->prim_dev_type.OUIsubdiv,
112                                           neighb->info->prim_dev_type.subID);
113                 list_for_each_entry(wssid_e, &neighb->wssid, node) {
114                         used += wlp_wss_wssid_e_print(buf + used,
115                                                       bufsize - used,
116                                                       wssid_e);
117                 }
118                 buf[used++] = '\n';
119                 wlp_remove_neighbor_tmp_info(neighb);
120         }
121
122
123 out:
124         mutex_unlock(&wlp->nbmutex);
125         return used;
126 }
127
128
129 /**
130  * Show properties of all WSS in neighborhood.
131  *
132  * Will trigger a complete discovery of WSS activated by this device and
133  * its neighbors.
134  */
135 ssize_t wlp_neighborhood_show(struct wlp *wlp, char *buf)
136 {
137         wlp_discover(wlp);
138         return wlp_wss_neighborhood_print_remove(wlp, buf, PAGE_SIZE);
139 }
140 EXPORT_SYMBOL_GPL(wlp_neighborhood_show);
141
142 static
143 ssize_t __wlp_wss_properties_show(struct wlp_wss *wss, char *buf,
144                                   size_t bufsize)
145 {
146         ssize_t result;
147
148         result = wlp_wss_uuid_print(buf, bufsize, &wss->wssid);
149         result += scnprintf(buf + result, bufsize - result, " ");
150         result += uwb_mac_addr_print(buf + result, bufsize - result,
151                                      &wss->bcast);
152         result += scnprintf(buf + result, bufsize - result,
153                             " 0x%02x %u ", wss->hash, wss->secure_status);
154         result += wlp_wss_key_print(buf + result, bufsize - result,
155                                     wss->master_key);
156         result += scnprintf(buf + result, bufsize - result, " 0x%02x ",
157                             wss->tag);
158         result += uwb_mac_addr_print(buf + result, bufsize - result,
159                                      &wss->virtual_addr);
160         result += scnprintf(buf + result, bufsize - result, " %s", wss->name);
161         result += scnprintf(buf + result, bufsize - result,
162                             "\n\n#WSSID\n#WSS broadcast address\n"
163                             "#WSS hash\n#WSS secure status\n"
164                             "#WSS master key\n#WSS local tag\n"
165                             "#WSS local virtual EUI-48\n#WSS name\n");
166         return result;
167 }
168
169 /**
170  * Show which WSS is activated.
171  */
172 ssize_t wlp_wss_activate_show(struct wlp_wss *wss, char *buf)
173 {
174         int result = 0;
175
176         if (mutex_lock_interruptible(&wss->mutex))
177                 goto out;
178         if (wss->state >= WLP_WSS_STATE_ACTIVE)
179                 result = __wlp_wss_properties_show(wss, buf, PAGE_SIZE);
180         else
181                 result = scnprintf(buf, PAGE_SIZE, "No local WSS active.\n");
182         result += scnprintf(buf + result, PAGE_SIZE - result,
183                         "\n\n"
184                         "# echo WSSID SECURE_STATUS ACCEPT_ENROLLMENT "
185                         "NAME #create new WSS\n"
186                         "# echo WSSID [DEV ADDR] #enroll in and activate "
187                         "existing WSS, can request registrar\n"
188                         "#\n"
189                         "# WSSID is a 16 byte hex array. Eg. 12 A3 3B ... \n"
190                         "# SECURE_STATUS 0 - unsecure, 1 - secure (default)\n"
191                         "# ACCEPT_ENROLLMENT 0 - no, 1 - yes (default)\n"
192                         "# NAME is the text string identifying the WSS\n"
193                         "# DEV ADDR is the device address of neighbor "
194                         "that should be registrar. Eg. 32:AB\n");
195
196         mutex_unlock(&wss->mutex);
197 out:
198         return result;
199
200 }
201 EXPORT_SYMBOL_GPL(wlp_wss_activate_show);
202
203 /**
204  * Create/activate a new WSS or enroll/activate in neighboring WSS
205  *
206  * The user can provide the WSSID of a WSS in which it wants to enroll.
207  * Only the WSSID is necessary if the WSS have been discovered before. If
208  * the WSS has not been discovered before, or the user wants to use a
209  * particular neighbor as its registrar, then the user can also provide a
210  * device address or the neighbor that will be used as registrar.
211  *
212  * A new WSS is created when the user provides a WSSID, secure status, and
213  * WSS name.
214  */
215 ssize_t wlp_wss_activate_store(struct wlp_wss *wss,
216                                const char *buf, size_t size)
217 {
218         ssize_t result = -EINVAL;
219         struct wlp_uuid wssid;
220         struct uwb_dev_addr dev;
221         struct uwb_dev_addr bcast = {.data = {0xff, 0xff} };
222         char name[65];
223         unsigned sec_status, accept;
224         memset(name, 0, sizeof(name));
225         result = sscanf(buf, "%02hhx %02hhx %02hhx %02hhx "
226                         "%02hhx %02hhx %02hhx %02hhx "
227                         "%02hhx %02hhx %02hhx %02hhx "
228                         "%02hhx %02hhx %02hhx %02hhx "
229                         "%02hhx:%02hhx",
230                         &wssid.data[0] , &wssid.data[1],
231                         &wssid.data[2] , &wssid.data[3],
232                         &wssid.data[4] , &wssid.data[5],
233                         &wssid.data[6] , &wssid.data[7],
234                         &wssid.data[8] , &wssid.data[9],
235                         &wssid.data[10], &wssid.data[11],
236                         &wssid.data[12], &wssid.data[13],
237                         &wssid.data[14], &wssid.data[15],
238                         &dev.data[1], &dev.data[0]);
239         if (result == 16 || result == 17) {
240                 result = sscanf(buf, "%02hhx %02hhx %02hhx %02hhx "
241                                 "%02hhx %02hhx %02hhx %02hhx "
242                                 "%02hhx %02hhx %02hhx %02hhx "
243                                 "%02hhx %02hhx %02hhx %02hhx "
244                                 "%u %u %64c",
245                                 &wssid.data[0] , &wssid.data[1],
246                                 &wssid.data[2] , &wssid.data[3],
247                                 &wssid.data[4] , &wssid.data[5],
248                                 &wssid.data[6] , &wssid.data[7],
249                                 &wssid.data[8] , &wssid.data[9],
250                                 &wssid.data[10], &wssid.data[11],
251                                 &wssid.data[12], &wssid.data[13],
252                                 &wssid.data[14], &wssid.data[15],
253                                 &sec_status, &accept, name);
254                 if (result == 16)
255                         result = wlp_wss_enroll_activate(wss, &wssid, &bcast);
256                 else if (result == 19) {
257                         sec_status = sec_status == 0 ? 0 : 1;
258                         accept = accept == 0 ? 0 : 1;
259                         /* We read name using %c, so the newline needs to be
260                          * removed */
261                         if (strlen(name) != sizeof(name) - 1)
262                                 name[strlen(name) - 1] = '\0';
263                         result = wlp_wss_create_activate(wss, &wssid, name,
264                                                          sec_status, accept);
265                 } else
266                         result = -EINVAL;
267         } else if (result == 18)
268                 result = wlp_wss_enroll_activate(wss, &wssid, &dev);
269         else
270                 result = -EINVAL;
271         return result < 0 ? result : size;
272 }
273 EXPORT_SYMBOL_GPL(wlp_wss_activate_store);
274
275 /**
276  * Show the UUID of this host
277  */
278 ssize_t wlp_uuid_show(struct wlp *wlp, char *buf)
279 {
280         ssize_t result = 0;
281
282         mutex_lock(&wlp->mutex);
283         result = wlp_wss_uuid_print(buf, PAGE_SIZE, &wlp->uuid);
284         buf[result++] = '\n';
285         mutex_unlock(&wlp->mutex);
286         return result;
287 }
288 EXPORT_SYMBOL_GPL(wlp_uuid_show);
289
290 /**
291  * Store a new UUID for this host
292  *
293  * According to the spec this should be encoded as an octet string in the
294  * order the octets are shown in string representation in RFC 4122 (WLP
295  * 0.99 [Table 6])
296  *
297  * We do not check value provided by user.
298  */
299 ssize_t wlp_uuid_store(struct wlp *wlp, const char *buf, size_t size)
300 {
301         ssize_t result;
302         struct wlp_uuid uuid;
303
304         mutex_lock(&wlp->mutex);
305         result = sscanf(buf, "%02hhx %02hhx %02hhx %02hhx "
306                         "%02hhx %02hhx %02hhx %02hhx "
307                         "%02hhx %02hhx %02hhx %02hhx "
308                         "%02hhx %02hhx %02hhx %02hhx ",
309                         &uuid.data[0] , &uuid.data[1],
310                         &uuid.data[2] , &uuid.data[3],
311                         &uuid.data[4] , &uuid.data[5],
312                         &uuid.data[6] , &uuid.data[7],
313                         &uuid.data[8] , &uuid.data[9],
314                         &uuid.data[10], &uuid.data[11],
315                         &uuid.data[12], &uuid.data[13],
316                         &uuid.data[14], &uuid.data[15]);
317         if (result != 16) {
318                 result = -EINVAL;
319                 goto error;
320         }
321         wlp->uuid = uuid;
322 error:
323         mutex_unlock(&wlp->mutex);
324         return result < 0 ? result : size;
325 }
326 EXPORT_SYMBOL_GPL(wlp_uuid_store);
327
328 /**
329  * Show contents of members of device information structure
330  */
331 #define wlp_dev_info_show(type)                                         \
332 ssize_t wlp_dev_##type##_show(struct wlp *wlp, char *buf)               \
333 {                                                                       \
334         ssize_t result = 0;                                             \
335         mutex_lock(&wlp->mutex);                                        \
336         if (wlp->dev_info == NULL) {                                    \
337                 result = __wlp_setup_device_info(wlp);                  \
338                 if (result < 0)                                         \
339                         goto out;                                       \
340         }                                                               \
341         result = scnprintf(buf, PAGE_SIZE, "%s\n", wlp->dev_info->type);\
342 out:                                                                    \
343         mutex_unlock(&wlp->mutex);                                      \
344         return result;                                                  \
345 }                                                                       \
346 EXPORT_SYMBOL_GPL(wlp_dev_##type##_show);
347
348 wlp_dev_info_show(name)
349 wlp_dev_info_show(model_name)
350 wlp_dev_info_show(model_nr)
351 wlp_dev_info_show(manufacturer)
352 wlp_dev_info_show(serial)
353
354 /**
355  * Store contents of members of device information structure
356  */
357 #define wlp_dev_info_store(type, len)                                   \
358 ssize_t wlp_dev_##type##_store(struct wlp *wlp, const char *buf, size_t size)\
359 {                                                                       \
360         ssize_t result;                                                 \
361         char format[10];                                                \
362         mutex_lock(&wlp->mutex);                                        \
363         if (wlp->dev_info == NULL) {                                    \
364                 result = __wlp_alloc_device_info(wlp);                  \
365                 if (result < 0)                                         \
366                         goto out;                                       \
367         }                                                               \
368         memset(wlp->dev_info->type, 0, sizeof(wlp->dev_info->type));    \
369         sprintf(format, "%%%uc", len);                                  \
370         result = sscanf(buf, format, wlp->dev_info->type);              \
371 out:                                                                    \
372         mutex_unlock(&wlp->mutex);                                      \
373         return result < 0 ? result : size;                              \
374 }                                                                       \
375 EXPORT_SYMBOL_GPL(wlp_dev_##type##_store);
376
377 wlp_dev_info_store(name, 32)
378 wlp_dev_info_store(manufacturer, 64)
379 wlp_dev_info_store(model_name, 32)
380 wlp_dev_info_store(model_nr, 32)
381 wlp_dev_info_store(serial, 32)
382
383 static
384 const char *__wlp_dev_category[] = {
385         [WLP_DEV_CAT_COMPUTER] = "Computer",
386         [WLP_DEV_CAT_INPUT] = "Input device",
387         [WLP_DEV_CAT_PRINT_SCAN_FAX_COPIER] = "Printer, scanner, FAX, or "
388                                               "Copier",
389         [WLP_DEV_CAT_CAMERA] = "Camera",
390         [WLP_DEV_CAT_STORAGE] = "Storage Network",
391         [WLP_DEV_CAT_INFRASTRUCTURE] = "Infrastructure",
392         [WLP_DEV_CAT_DISPLAY] = "Display",
393         [WLP_DEV_CAT_MULTIM] = "Multimedia device",
394         [WLP_DEV_CAT_GAMING] = "Gaming device",
395         [WLP_DEV_CAT_TELEPHONE] = "Telephone",
396         [WLP_DEV_CAT_OTHER] = "Other",
397 };
398
399 static
400 const char *wlp_dev_category_str(unsigned cat)
401 {
402         if ((cat >= WLP_DEV_CAT_COMPUTER && cat <= WLP_DEV_CAT_TELEPHONE)
403             || cat == WLP_DEV_CAT_OTHER)
404                 return __wlp_dev_category[cat];
405         return "unknown category";
406 }
407
408 ssize_t wlp_dev_prim_category_show(struct wlp *wlp, char *buf)
409 {
410         ssize_t result = 0;
411         mutex_lock(&wlp->mutex);
412         if (wlp->dev_info == NULL) {
413                 result = __wlp_setup_device_info(wlp);
414                 if (result < 0)
415                         goto out;
416         }
417         result = scnprintf(buf, PAGE_SIZE, "%s\n",
418                   wlp_dev_category_str(wlp->dev_info->prim_dev_type.category));
419 out:
420         mutex_unlock(&wlp->mutex);
421         return result;
422 }
423 EXPORT_SYMBOL_GPL(wlp_dev_prim_category_show);
424
425 ssize_t wlp_dev_prim_category_store(struct wlp *wlp, const char *buf,
426                                     size_t size)
427 {
428         ssize_t result;
429         u16 cat;
430         mutex_lock(&wlp->mutex);
431         if (wlp->dev_info == NULL) {
432                 result = __wlp_alloc_device_info(wlp);
433                 if (result < 0)
434                         goto out;
435         }
436         result = sscanf(buf, "%hu", &cat);
437         if ((cat >= WLP_DEV_CAT_COMPUTER && cat <= WLP_DEV_CAT_TELEPHONE)
438             || cat == WLP_DEV_CAT_OTHER)
439                 wlp->dev_info->prim_dev_type.category = cat;
440         else
441                 result = -EINVAL;
442 out:
443         mutex_unlock(&wlp->mutex);
444         return result < 0 ? result : size;
445 }
446 EXPORT_SYMBOL_GPL(wlp_dev_prim_category_store);
447
448 ssize_t wlp_dev_prim_OUI_show(struct wlp *wlp, char *buf)
449 {
450         ssize_t result = 0;
451         mutex_lock(&wlp->mutex);
452         if (wlp->dev_info == NULL) {
453                 result = __wlp_setup_device_info(wlp);
454                 if (result < 0)
455                         goto out;
456         }
457         result = scnprintf(buf, PAGE_SIZE, "%02x:%02x:%02x\n",
458                            wlp->dev_info->prim_dev_type.OUI[0],
459                            wlp->dev_info->prim_dev_type.OUI[1],
460                            wlp->dev_info->prim_dev_type.OUI[2]);
461 out:
462         mutex_unlock(&wlp->mutex);
463         return result;
464 }
465 EXPORT_SYMBOL_GPL(wlp_dev_prim_OUI_show);
466
467 ssize_t wlp_dev_prim_OUI_store(struct wlp *wlp, const char *buf, size_t size)
468 {
469         ssize_t result;
470         u8 OUI[3];
471         mutex_lock(&wlp->mutex);
472         if (wlp->dev_info == NULL) {
473                 result = __wlp_alloc_device_info(wlp);
474                 if (result < 0)
475                         goto out;
476         }
477         result = sscanf(buf, "%hhx:%hhx:%hhx",
478                         &OUI[0], &OUI[1], &OUI[2]);
479         if (result != 3) {
480                 result = -EINVAL;
481                 goto out;
482         } else
483                 memcpy(wlp->dev_info->prim_dev_type.OUI, OUI, sizeof(OUI));
484 out:
485         mutex_unlock(&wlp->mutex);
486         return result < 0 ? result : size;
487 }
488 EXPORT_SYMBOL_GPL(wlp_dev_prim_OUI_store);
489
490
491 ssize_t wlp_dev_prim_OUI_sub_show(struct wlp *wlp, char *buf)
492 {
493         ssize_t result = 0;
494         mutex_lock(&wlp->mutex);
495         if (wlp->dev_info == NULL) {
496                 result = __wlp_setup_device_info(wlp);
497                 if (result < 0)
498                         goto out;
499         }
500         result = scnprintf(buf, PAGE_SIZE, "%u\n",
501                            wlp->dev_info->prim_dev_type.OUIsubdiv);
502 out:
503         mutex_unlock(&wlp->mutex);
504         return result;
505 }
506 EXPORT_SYMBOL_GPL(wlp_dev_prim_OUI_sub_show);
507
508 ssize_t wlp_dev_prim_OUI_sub_store(struct wlp *wlp, const char *buf,
509                                    size_t size)
510 {
511         ssize_t result;
512         unsigned sub;
513         u8 max_sub = ~0;
514         mutex_lock(&wlp->mutex);
515         if (wlp->dev_info == NULL) {
516                 result = __wlp_alloc_device_info(wlp);
517                 if (result < 0)
518                         goto out;
519         }
520         result = sscanf(buf, "%u", &sub);
521         if (sub <= max_sub)
522                 wlp->dev_info->prim_dev_type.OUIsubdiv = sub;
523         else
524                 result = -EINVAL;
525 out:
526         mutex_unlock(&wlp->mutex);
527         return result < 0 ? result : size;
528 }
529 EXPORT_SYMBOL_GPL(wlp_dev_prim_OUI_sub_store);
530
531 ssize_t wlp_dev_prim_subcat_show(struct wlp *wlp, char *buf)
532 {
533         ssize_t result = 0;
534         mutex_lock(&wlp->mutex);
535         if (wlp->dev_info == NULL) {
536                 result = __wlp_setup_device_info(wlp);
537                 if (result < 0)
538                         goto out;
539         }
540         result = scnprintf(buf, PAGE_SIZE, "%u\n",
541                            wlp->dev_info->prim_dev_type.subID);
542 out:
543         mutex_unlock(&wlp->mutex);
544         return result;
545 }
546 EXPORT_SYMBOL_GPL(wlp_dev_prim_subcat_show);
547
548 ssize_t wlp_dev_prim_subcat_store(struct wlp *wlp, const char *buf,
549                                   size_t size)
550 {
551         ssize_t result;
552         unsigned sub;
553         __le16 max_sub = ~0;
554         mutex_lock(&wlp->mutex);
555         if (wlp->dev_info == NULL) {
556                 result = __wlp_alloc_device_info(wlp);
557                 if (result < 0)
558                         goto out;
559         }
560         result = sscanf(buf, "%u", &sub);
561         if (sub <= max_sub)
562                 wlp->dev_info->prim_dev_type.subID = sub;
563         else
564                 result = -EINVAL;
565 out:
566         mutex_unlock(&wlp->mutex);
567         return result < 0 ? result : size;
568 }
569 EXPORT_SYMBOL_GPL(wlp_dev_prim_subcat_store);
570
571 /**
572  * Subsystem implementation for interaction with individual WSS via sysfs
573  *
574  * Followed instructions for subsystem in Documentation/filesystems/sysfs.txt
575  */
576
577 #define kobj_to_wlp_wss(obj) container_of(obj, struct wlp_wss, kobj)
578 #define attr_to_wlp_wss_attr(_attr) \
579         container_of(_attr, struct wlp_wss_attribute, attr)
580
581 /**
582  * Sysfs subsystem: forward read calls
583  *
584  * Sysfs operation for forwarding read call to the show method of the
585  * attribute owner
586  */
587 static
588 ssize_t wlp_wss_attr_show(struct kobject *kobj, struct attribute *attr,
589                           char *buf)
590 {
591         struct wlp_wss_attribute *wss_attr = attr_to_wlp_wss_attr(attr);
592         struct wlp_wss *wss = kobj_to_wlp_wss(kobj);
593         ssize_t ret = -EIO;
594
595         if (wss_attr->show)
596                 ret = wss_attr->show(wss, buf);
597         return ret;
598 }
599 /**
600  * Sysfs subsystem: forward write calls
601  *
602  * Sysfs operation for forwarding write call to the store method of the
603  * attribute owner
604  */
605 static
606 ssize_t wlp_wss_attr_store(struct kobject *kobj, struct attribute *attr,
607                            const char *buf, size_t count)
608 {
609         struct wlp_wss_attribute *wss_attr = attr_to_wlp_wss_attr(attr);
610         struct wlp_wss *wss = kobj_to_wlp_wss(kobj);
611         ssize_t ret = -EIO;
612
613         if (wss_attr->store)
614                 ret = wss_attr->store(wss, buf, count);
615         return ret;
616 }
617
618 static
619 struct sysfs_ops wss_sysfs_ops = {
620         .show   = wlp_wss_attr_show,
621         .store  = wlp_wss_attr_store,
622 };
623
624 struct kobj_type wss_ktype = {
625         .release        = wlp_wss_release,
626         .sysfs_ops      = &wss_sysfs_ops,
627 };
628
629
630 /**
631  * Sysfs files for individual WSS
632  */
633
634 /**
635  * Print static properties of this WSS
636  *
637  * The name of a WSS may not be null teminated. It's max size is 64 bytes
638  * so we copy it to a larger array just to make sure we print sane data.
639  */
640 static ssize_t wlp_wss_properties_show(struct wlp_wss *wss, char *buf)
641 {
642         int result = 0;
643
644         if (mutex_lock_interruptible(&wss->mutex))
645                 goto out;
646         result = __wlp_wss_properties_show(wss, buf, PAGE_SIZE);
647         mutex_unlock(&wss->mutex);
648 out:
649         return result;
650 }
651 WSS_ATTR(properties, S_IRUGO, wlp_wss_properties_show, NULL);
652
653 /**
654  * Print all connected members of this WSS
655  * The EDA cache contains all members of WSS neighborhood.
656  */
657 static ssize_t wlp_wss_members_show(struct wlp_wss *wss, char *buf)
658 {
659         struct wlp *wlp = container_of(wss, struct wlp, wss);
660         return wlp_eda_show(wlp, buf);
661 }
662 WSS_ATTR(members, S_IRUGO, wlp_wss_members_show, NULL);
663
664 static
665 const char *__wlp_strstate[] = {
666         "none",
667         "partially enrolled",
668         "enrolled",
669         "active",
670         "connected",
671 };
672
673 static const char *wlp_wss_strstate(unsigned state)
674 {
675         if (state >= ARRAY_SIZE(__wlp_strstate))
676                 return "unknown state";
677         return __wlp_strstate[state];
678 }
679
680 /*
681  * Print current state of this WSS
682  */
683 static ssize_t wlp_wss_state_show(struct wlp_wss *wss, char *buf)
684 {
685         int result = 0;
686
687         if (mutex_lock_interruptible(&wss->mutex))
688                 goto out;
689         result = scnprintf(buf, PAGE_SIZE, "%s\n",
690                            wlp_wss_strstate(wss->state));
691         mutex_unlock(&wss->mutex);
692 out:
693         return result;
694 }
695 WSS_ATTR(state, S_IRUGO, wlp_wss_state_show, NULL);
696
697
698 static
699 struct attribute *wss_attrs[] = {
700         &wss_attr_properties.attr,
701         &wss_attr_members.attr,
702         &wss_attr_state.attr,
703         NULL,
704 };
705
706 struct attribute_group wss_attr_group = {
707         .name = NULL,   /* we want them in the same directory */
708         .attrs = wss_attrs,
709 };