aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/libertas/debugfs.c
diff options
context:
space:
mode:
authorHolger Schurig <hs4233@mail.mn-solutions.de>2007-11-15 18:05:47 -0500
committerDavid S. Miller <davem@davemloft.net>2008-01-28 18:04:46 -0500
commit1007832103d016d1563fab71d4cf2b057a0bcceb (patch)
tree3b5080b01bee6e1f98cc9489382c534e963ac748 /drivers/net/wireless/libertas/debugfs.c
parent9a62f73b1a3bbd35a6f84fcd6636e672b09981ec (diff)
libertas: move to uniform lbs_/LBS_ namespace
This patch unifies the namespace of variables, functions defines and structures. It does: - rename libertas_XXX to lbs_XXX - rename LIBERTAS_XXX to lbs_XXX - rename wlan_XXX to lbs_XXX - rename WLAN_XXX to LBS_XXX (but only those that were defined in libertas-local *.h files, e.g. not defines from net/ieee80211.h) While passing, I fixed some checkpatch.pl errors too. Signed-off-by: Holger Schurig <hs4233@mail.mn-solutions.de> Acked-by: Dan Williams <dcbw@redhat.com> Signed-off-by: John W. Linville <linville@tuxdriver.com>
Diffstat (limited to 'drivers/net/wireless/libertas/debugfs.c')
-rw-r--r--drivers/net/wireless/libertas/debugfs.c402
1 files changed, 201 insertions, 201 deletions
diff --git a/drivers/net/wireless/libertas/debugfs.c b/drivers/net/wireless/libertas/debugfs.c
index 95dd4edf64cf..1b382cfaf37a 100644
--- a/drivers/net/wireless/libertas/debugfs.c
+++ b/drivers/net/wireless/libertas/debugfs.c
@@ -11,14 +11,14 @@
11#include "host.h" 11#include "host.h"
12#include "debugfs.h" 12#include "debugfs.h"
13 13
14static struct dentry *libertas_dir = NULL; 14static struct dentry *lbs_dir;
15static char *szStates[] = { 15static char *szStates[] = {
16 "Connected", 16 "Connected",
17 "Disconnected" 17 "Disconnected"
18}; 18};
19 19
20#ifdef PROC_DEBUG 20#ifdef PROC_DEBUG
21static void libertas_debug_init(wlan_private * priv, struct net_device *dev); 21static void lbs_debug_init(lbs_private * priv, struct net_device *dev);
22#endif 22#endif
23 23
24static int open_file_generic(struct inode *inode, struct file *file) 24static int open_file_generic(struct inode *inode, struct file *file)
@@ -35,10 +35,10 @@ static ssize_t write_file_dummy(struct file *file, const char __user *buf,
35 35
36static const size_t len = PAGE_SIZE; 36static const size_t len = PAGE_SIZE;
37 37
38static ssize_t libertas_dev_info(struct file *file, char __user *userbuf, 38static ssize_t lbs_dev_info(struct file *file, char __user *userbuf,
39 size_t count, loff_t *ppos) 39 size_t count, loff_t *ppos)
40{ 40{
41 wlan_private *priv = file->private_data; 41 lbs_private *priv = file->private_data;
42 size_t pos = 0; 42 size_t pos = 0;
43 unsigned long addr = get_zeroed_page(GFP_KERNEL); 43 unsigned long addr = get_zeroed_page(GFP_KERNEL);
44 char *buf = (char *)addr; 44 char *buf = (char *)addr;
@@ -56,10 +56,10 @@ static ssize_t libertas_dev_info(struct file *file, char __user *userbuf,
56} 56}
57 57
58 58
59static ssize_t libertas_getscantable(struct file *file, char __user *userbuf, 59static ssize_t lbs_getscantable(struct file *file, char __user *userbuf,
60 size_t count, loff_t *ppos) 60 size_t count, loff_t *ppos)
61{ 61{
62 wlan_private *priv = file->private_data; 62 lbs_private *priv = file->private_data;
63 size_t pos = 0; 63 size_t pos = 0;
64 int numscansdone = 0, res; 64 int numscansdone = 0, res;
65 unsigned long addr = get_zeroed_page(GFP_KERNEL); 65 unsigned long addr = get_zeroed_page(GFP_KERNEL);
@@ -98,11 +98,11 @@ static ssize_t libertas_getscantable(struct file *file, char __user *userbuf,
98 return res; 98 return res;
99} 99}
100 100
101static ssize_t libertas_sleepparams_write(struct file *file, 101static ssize_t lbs_sleepparams_write(struct file *file,
102 const char __user *user_buf, size_t count, 102 const char __user *user_buf, size_t count,
103 loff_t *ppos) 103 loff_t *ppos)
104{ 104{
105 wlan_private *priv = file->private_data; 105 lbs_private *priv = file->private_data;
106 ssize_t buf_size, res; 106 ssize_t buf_size, res;
107 int p1, p2, p3, p4, p5, p6; 107 int p1, p2, p3, p4, p5, p6;
108 unsigned long addr = get_zeroed_page(GFP_KERNEL); 108 unsigned long addr = get_zeroed_page(GFP_KERNEL);
@@ -125,7 +125,7 @@ static ssize_t libertas_sleepparams_write(struct file *file,
125 priv->adapter->sp.sp_extsleepclk = p5; 125 priv->adapter->sp.sp_extsleepclk = p5;
126 priv->adapter->sp.sp_reserved = p6; 126 priv->adapter->sp.sp_reserved = p6;
127 127
128 res = libertas_prepare_and_send_command(priv, 128 res = lbs_prepare_and_send_command(priv,
129 CMD_802_11_SLEEP_PARAMS, 129 CMD_802_11_SLEEP_PARAMS,
130 CMD_ACT_SET, 130 CMD_ACT_SET,
131 CMD_OPTION_WAITFORRSP, 0, NULL); 131 CMD_OPTION_WAITFORRSP, 0, NULL);
@@ -140,17 +140,17 @@ out_unlock:
140 return res; 140 return res;
141} 141}
142 142
143static ssize_t libertas_sleepparams_read(struct file *file, char __user *userbuf, 143static ssize_t lbs_sleepparams_read(struct file *file, char __user *userbuf,
144 size_t count, loff_t *ppos) 144 size_t count, loff_t *ppos)
145{ 145{
146 wlan_private *priv = file->private_data; 146 lbs_private *priv = file->private_data;
147 wlan_adapter *adapter = priv->adapter; 147 lbs_adapter *adapter = priv->adapter;
148 ssize_t res; 148 ssize_t res;
149 size_t pos = 0; 149 size_t pos = 0;
150 unsigned long addr = get_zeroed_page(GFP_KERNEL); 150 unsigned long addr = get_zeroed_page(GFP_KERNEL);
151 char *buf = (char *)addr; 151 char *buf = (char *)addr;
152 152
153 res = libertas_prepare_and_send_command(priv, 153 res = lbs_prepare_and_send_command(priv,
154 CMD_802_11_SLEEP_PARAMS, 154 CMD_802_11_SLEEP_PARAMS,
155 CMD_ACT_GET, 155 CMD_ACT_GET,
156 CMD_OPTION_WAITFORRSP, 0, NULL); 156 CMD_OPTION_WAITFORRSP, 0, NULL);
@@ -171,10 +171,10 @@ out_unlock:
171 return res; 171 return res;
172} 172}
173 173
174static ssize_t libertas_extscan(struct file *file, const char __user *userbuf, 174static ssize_t lbs_extscan(struct file *file, const char __user *userbuf,
175 size_t count, loff_t *ppos) 175 size_t count, loff_t *ppos)
176{ 176{
177 wlan_private *priv = file->private_data; 177 lbs_private *priv = file->private_data;
178 ssize_t res, buf_size; 178 ssize_t res, buf_size;
179 union iwreq_data wrqu; 179 union iwreq_data wrqu;
180 unsigned long addr = get_zeroed_page(GFP_KERNEL); 180 unsigned long addr = get_zeroed_page(GFP_KERNEL);
@@ -186,7 +186,7 @@ static ssize_t libertas_extscan(struct file *file, const char __user *userbuf,
186 goto out_unlock; 186 goto out_unlock;
187 } 187 }
188 188
189 libertas_send_specific_ssid_scan(priv, buf, strlen(buf)-1, 0); 189 lbs_send_specific_ssid_scan(priv, buf, strlen(buf)-1, 0);
190 190
191 memset(&wrqu, 0, sizeof(union iwreq_data)); 191 memset(&wrqu, 0, sizeof(union iwreq_data));
192 wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL); 192 wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
@@ -196,8 +196,8 @@ out_unlock:
196 return count; 196 return count;
197} 197}
198 198
199static int libertas_parse_chan(char *buf, size_t count, 199static int lbs_parse_chan(char *buf, size_t count,
200 struct wlan_ioctl_user_scan_cfg *scan_cfg, int dur) 200 struct lbs_ioctl_user_scan_cfg *scan_cfg, int dur)
201{ 201{
202 char *start, *end, *hold, *str; 202 char *start, *end, *hold, *str;
203 int i = 0; 203 int i = 0;
@@ -233,8 +233,8 @@ static int libertas_parse_chan(char *buf, size_t count,
233 return i; 233 return i;
234} 234}
235 235
236static void libertas_parse_bssid(char *buf, size_t count, 236static void lbs_parse_bssid(char *buf, size_t count,
237 struct wlan_ioctl_user_scan_cfg *scan_cfg) 237 struct lbs_ioctl_user_scan_cfg *scan_cfg)
238{ 238{
239 char *hold; 239 char *hold;
240 unsigned int mac[ETH_ALEN]; 240 unsigned int mac[ETH_ALEN];
@@ -248,8 +248,8 @@ static void libertas_parse_bssid(char *buf, size_t count,
248 memcpy(scan_cfg->bssid, mac, ETH_ALEN); 248 memcpy(scan_cfg->bssid, mac, ETH_ALEN);
249} 249}
250 250
251static void libertas_parse_ssid(char *buf, size_t count, 251static void lbs_parse_ssid(char *buf, size_t count,
252 struct wlan_ioctl_user_scan_cfg *scan_cfg) 252 struct lbs_ioctl_user_scan_cfg *scan_cfg)
253{ 253{
254 char *hold, *end; 254 char *hold, *end;
255 ssize_t size; 255 ssize_t size;
@@ -268,7 +268,7 @@ static void libertas_parse_ssid(char *buf, size_t count,
268 return; 268 return;
269} 269}
270 270
271static int libertas_parse_clear(char *buf, size_t count, const char *tag) 271static int lbs_parse_clear(char *buf, size_t count, const char *tag)
272{ 272{
273 char *hold; 273 char *hold;
274 int val; 274 int val;
@@ -285,8 +285,8 @@ static int libertas_parse_clear(char *buf, size_t count, const char *tag)
285 return val; 285 return val;
286} 286}
287 287
288static int libertas_parse_dur(char *buf, size_t count, 288static int lbs_parse_dur(char *buf, size_t count,
289 struct wlan_ioctl_user_scan_cfg *scan_cfg) 289 struct lbs_ioctl_user_scan_cfg *scan_cfg)
290{ 290{
291 char *hold; 291 char *hold;
292 int val; 292 int val;
@@ -300,8 +300,8 @@ static int libertas_parse_dur(char *buf, size_t count,
300 return val; 300 return val;
301} 301}
302 302
303static void libertas_parse_probes(char *buf, size_t count, 303static void lbs_parse_probes(char *buf, size_t count,
304 struct wlan_ioctl_user_scan_cfg *scan_cfg) 304 struct lbs_ioctl_user_scan_cfg *scan_cfg)
305{ 305{
306 char *hold; 306 char *hold;
307 int val; 307 int val;
@@ -317,8 +317,8 @@ static void libertas_parse_probes(char *buf, size_t count,
317 return; 317 return;
318} 318}
319 319
320static void libertas_parse_type(char *buf, size_t count, 320static void lbs_parse_type(char *buf, size_t count,
321 struct wlan_ioctl_user_scan_cfg *scan_cfg) 321 struct lbs_ioctl_user_scan_cfg *scan_cfg)
322{ 322{
323 char *hold; 323 char *hold;
324 int val; 324 int val;
@@ -338,19 +338,19 @@ static void libertas_parse_type(char *buf, size_t count,
338 return; 338 return;
339} 339}
340 340
341static ssize_t libertas_setuserscan(struct file *file, 341static ssize_t lbs_setuserscan(struct file *file,
342 const char __user *userbuf, 342 const char __user *userbuf,
343 size_t count, loff_t *ppos) 343 size_t count, loff_t *ppos)
344{ 344{
345 wlan_private *priv = file->private_data; 345 lbs_private *priv = file->private_data;
346 ssize_t res, buf_size; 346 ssize_t res, buf_size;
347 struct wlan_ioctl_user_scan_cfg *scan_cfg; 347 struct lbs_ioctl_user_scan_cfg *scan_cfg;
348 union iwreq_data wrqu; 348 union iwreq_data wrqu;
349 int dur; 349 int dur;
350 unsigned long addr = get_zeroed_page(GFP_KERNEL); 350 unsigned long addr = get_zeroed_page(GFP_KERNEL);
351 char *buf = (char *)addr; 351 char *buf = (char *)addr;
352 352
353 scan_cfg = kzalloc(sizeof(struct wlan_ioctl_user_scan_cfg), GFP_KERNEL); 353 scan_cfg = kzalloc(sizeof(struct lbs_ioctl_user_scan_cfg), GFP_KERNEL);
354 if (!scan_cfg) 354 if (!scan_cfg)
355 return -ENOMEM; 355 return -ENOMEM;
356 356
@@ -360,18 +360,18 @@ static ssize_t libertas_setuserscan(struct file *file,
360 goto out_unlock; 360 goto out_unlock;
361 } 361 }
362 362
363 scan_cfg->bsstype = WLAN_SCAN_BSS_TYPE_ANY; 363 scan_cfg->bsstype = LBS_SCAN_BSS_TYPE_ANY;
364 364
365 dur = libertas_parse_dur(buf, count, scan_cfg); 365 dur = lbs_parse_dur(buf, count, scan_cfg);
366 libertas_parse_chan(buf, count, scan_cfg, dur); 366 lbs_parse_chan(buf, count, scan_cfg, dur);
367 libertas_parse_bssid(buf, count, scan_cfg); 367 lbs_parse_bssid(buf, count, scan_cfg);
368 scan_cfg->clear_bssid = libertas_parse_clear(buf, count, "clear_bssid="); 368 scan_cfg->clear_bssid = lbs_parse_clear(buf, count, "clear_bssid=");
369 libertas_parse_ssid(buf, count, scan_cfg); 369 lbs_parse_ssid(buf, count, scan_cfg);
370 scan_cfg->clear_ssid = libertas_parse_clear(buf, count, "clear_ssid="); 370 scan_cfg->clear_ssid = lbs_parse_clear(buf, count, "clear_ssid=");
371 libertas_parse_probes(buf, count, scan_cfg); 371 lbs_parse_probes(buf, count, scan_cfg);
372 libertas_parse_type(buf, count, scan_cfg); 372 lbs_parse_type(buf, count, scan_cfg);
373 373
374 wlan_scan_networks(priv, scan_cfg, 1); 374 lbs_scan_networks(priv, scan_cfg, 1);
375 wait_event_interruptible(priv->adapter->cmd_pending, 375 wait_event_interruptible(priv->adapter->cmd_pending,
376 !priv->adapter->nr_cmd_pending); 376 !priv->adapter->nr_cmd_pending);
377 377
@@ -384,21 +384,21 @@ out_unlock:
384 return count; 384 return count;
385} 385}
386 386
387static int libertas_event_initcmd(wlan_private *priv, void **response_buf, 387static int lbs_event_initcmd(lbs_private *priv, void **response_buf,
388 struct cmd_ctrl_node **cmdnode, 388 struct cmd_ctrl_node **cmdnode,
389 struct cmd_ds_command **cmd) 389 struct cmd_ds_command **cmd)
390{ 390{
391 u16 wait_option = CMD_OPTION_WAITFORRSP; 391 u16 wait_option = CMD_OPTION_WAITFORRSP;
392 392
393 if (!(*cmdnode = libertas_get_free_cmd_ctrl_node(priv))) { 393 if (!(*cmdnode = lbs_get_free_cmd_ctrl_node(priv))) {
394 lbs_deb_debugfs("failed libertas_get_free_cmd_ctrl_node\n"); 394 lbs_deb_debugfs("failed lbs_get_free_cmd_ctrl_node\n");
395 return -ENOMEM; 395 return -ENOMEM;
396 } 396 }
397 if (!(*response_buf = kmalloc(3000, GFP_KERNEL))) { 397 if (!(*response_buf = kmalloc(3000, GFP_KERNEL))) {
398 lbs_deb_debugfs("failed to allocate response buffer!\n"); 398 lbs_deb_debugfs("failed to allocate response buffer!\n");
399 return -ENOMEM; 399 return -ENOMEM;
400 } 400 }
401 libertas_set_cmd_ctrl_node(priv, *cmdnode, 0, wait_option, NULL); 401 lbs_set_cmd_ctrl_node(priv, *cmdnode, 0, wait_option, NULL);
402 init_waitqueue_head(&(*cmdnode)->cmdwait_q); 402 init_waitqueue_head(&(*cmdnode)->cmdwait_q);
403 (*cmdnode)->pdata_buf = *response_buf; 403 (*cmdnode)->pdata_buf = *response_buf;
404 (*cmdnode)->cmdflags |= CMD_F_HOSTCMD; 404 (*cmdnode)->cmdflags |= CMD_F_HOSTCMD;
@@ -410,11 +410,11 @@ static int libertas_event_initcmd(wlan_private *priv, void **response_buf,
410 return 0; 410 return 0;
411} 411}
412 412
413static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf, 413static ssize_t lbs_lowrssi_read(struct file *file, char __user *userbuf,
414 size_t count, loff_t *ppos) 414 size_t count, loff_t *ppos)
415{ 415{
416 wlan_private *priv = file->private_data; 416 lbs_private *priv = file->private_data;
417 wlan_adapter *adapter = priv->adapter; 417 lbs_adapter *adapter = priv->adapter;
418 struct cmd_ctrl_node *pcmdnode; 418 struct cmd_ctrl_node *pcmdnode;
419 struct cmd_ds_command *pcmdptr; 419 struct cmd_ds_command *pcmdptr;
420 struct cmd_ds_802_11_subscribe_event *event; 420 struct cmd_ds_802_11_subscribe_event *event;
@@ -424,7 +424,7 @@ static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf,
424 unsigned long addr = get_zeroed_page(GFP_KERNEL); 424 unsigned long addr = get_zeroed_page(GFP_KERNEL);
425 char *buf = (char *)addr; 425 char *buf = (char *)addr;
426 426
427 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr); 427 res = lbs_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
428 if (res < 0) { 428 if (res < 0) {
429 free_page(addr); 429 free_page(addr);
430 return res; 430 return res;
@@ -433,7 +433,7 @@ static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf,
433 event = &pcmdptr->params.subscribe_event; 433 event = &pcmdptr->params.subscribe_event;
434 event->action = cpu_to_le16(CMD_ACT_GET); 434 event->action = cpu_to_le16(CMD_ACT_GET);
435 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 435 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
436 libertas_queue_cmd(adapter, pcmdnode, 1); 436 lbs_queue_cmd(adapter, pcmdnode, 1);
437 wake_up_interruptible(&priv->waitq); 437 wake_up_interruptible(&priv->waitq);
438 438
439 /* Sleep until response is generated by FW */ 439 /* Sleep until response is generated by FW */
@@ -480,9 +480,9 @@ static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf,
480 return res; 480 return res;
481} 481}
482 482
483static u16 libertas_get_events_bitmap(wlan_private *priv) 483static u16 lbs_get_events_bitmap(lbs_private *priv)
484{ 484{
485 wlan_adapter *adapter = priv->adapter; 485 lbs_adapter *adapter = priv->adapter;
486 struct cmd_ctrl_node *pcmdnode; 486 struct cmd_ctrl_node *pcmdnode;
487 struct cmd_ds_command *pcmdptr; 487 struct cmd_ds_command *pcmdptr;
488 struct cmd_ds_802_11_subscribe_event *event; 488 struct cmd_ds_802_11_subscribe_event *event;
@@ -490,14 +490,14 @@ static u16 libertas_get_events_bitmap(wlan_private *priv)
490 int res; 490 int res;
491 u16 event_bitmap; 491 u16 event_bitmap;
492 492
493 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr); 493 res = lbs_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
494 if (res < 0) 494 if (res < 0)
495 return res; 495 return res;
496 496
497 event = &pcmdptr->params.subscribe_event; 497 event = &pcmdptr->params.subscribe_event;
498 event->action = cpu_to_le16(CMD_ACT_GET); 498 event->action = cpu_to_le16(CMD_ACT_GET);
499 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 499 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
500 libertas_queue_cmd(adapter, pcmdnode, 1); 500 lbs_queue_cmd(adapter, pcmdnode, 1);
501 wake_up_interruptible(&priv->waitq); 501 wake_up_interruptible(&priv->waitq);
502 502
503 /* Sleep until response is generated by FW */ 503 /* Sleep until response is generated by FW */
@@ -525,12 +525,12 @@ static u16 libertas_get_events_bitmap(wlan_private *priv)
525 return event_bitmap; 525 return event_bitmap;
526} 526}
527 527
528static ssize_t libertas_lowrssi_write(struct file *file, 528static ssize_t lbs_lowrssi_write(struct file *file,
529 const char __user *userbuf, 529 const char __user *userbuf,
530 size_t count, loff_t *ppos) 530 size_t count, loff_t *ppos)
531{ 531{
532 wlan_private *priv = file->private_data; 532 lbs_private *priv = file->private_data;
533 wlan_adapter *adapter = priv->adapter; 533 lbs_adapter *adapter = priv->adapter;
534 ssize_t res, buf_size; 534 ssize_t res, buf_size;
535 int value, freq, subscribed, cmd_len; 535 int value, freq, subscribed, cmd_len;
536 struct cmd_ctrl_node *pcmdnode; 536 struct cmd_ctrl_node *pcmdnode;
@@ -554,9 +554,9 @@ static ssize_t libertas_lowrssi_write(struct file *file,
554 goto out_unlock; 554 goto out_unlock;
555 } 555 }
556 556
557 event_bitmap = libertas_get_events_bitmap(priv); 557 event_bitmap = lbs_get_events_bitmap(priv);
558 558
559 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr); 559 res = lbs_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
560 if (res < 0) 560 if (res < 0)
561 goto out_unlock; 561 goto out_unlock;
562 562
@@ -576,7 +576,7 @@ static ssize_t libertas_lowrssi_write(struct file *file,
576 event_bitmap |= subscribed ? 0x0001 : 0x0; 576 event_bitmap |= subscribed ? 0x0001 : 0x0;
577 event->events = cpu_to_le16(event_bitmap); 577 event->events = cpu_to_le16(event_bitmap);
578 578
579 libertas_queue_cmd(adapter, pcmdnode, 1); 579 lbs_queue_cmd(adapter, pcmdnode, 1);
580 wake_up_interruptible(&priv->waitq); 580 wake_up_interruptible(&priv->waitq);
581 581
582 /* Sleep until response is generated by FW */ 582 /* Sleep until response is generated by FW */
@@ -606,11 +606,11 @@ out_unlock:
606 return res; 606 return res;
607} 607}
608 608
609static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf, 609static ssize_t lbs_lowsnr_read(struct file *file, char __user *userbuf,
610 size_t count, loff_t *ppos) 610 size_t count, loff_t *ppos)
611{ 611{
612 wlan_private *priv = file->private_data; 612 lbs_private *priv = file->private_data;
613 wlan_adapter *adapter = priv->adapter; 613 lbs_adapter *adapter = priv->adapter;
614 struct cmd_ctrl_node *pcmdnode; 614 struct cmd_ctrl_node *pcmdnode;
615 struct cmd_ds_command *pcmdptr; 615 struct cmd_ds_command *pcmdptr;
616 struct cmd_ds_802_11_subscribe_event *event; 616 struct cmd_ds_802_11_subscribe_event *event;
@@ -620,7 +620,7 @@ static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf,
620 unsigned long addr = get_zeroed_page(GFP_KERNEL); 620 unsigned long addr = get_zeroed_page(GFP_KERNEL);
621 char *buf = (char *)addr; 621 char *buf = (char *)addr;
622 622
623 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr); 623 res = lbs_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
624 if (res < 0) { 624 if (res < 0) {
625 free_page(addr); 625 free_page(addr);
626 return res; 626 return res;
@@ -629,7 +629,7 @@ static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf,
629 event = &pcmdptr->params.subscribe_event; 629 event = &pcmdptr->params.subscribe_event;
630 event->action = cpu_to_le16(CMD_ACT_GET); 630 event->action = cpu_to_le16(CMD_ACT_GET);
631 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 631 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
632 libertas_queue_cmd(adapter, pcmdnode, 1); 632 lbs_queue_cmd(adapter, pcmdnode, 1);
633 wake_up_interruptible(&priv->waitq); 633 wake_up_interruptible(&priv->waitq);
634 634
635 /* Sleep until response is generated by FW */ 635 /* Sleep until response is generated by FW */
@@ -678,12 +678,12 @@ static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf,
678 return res; 678 return res;
679} 679}
680 680
681static ssize_t libertas_lowsnr_write(struct file *file, 681static ssize_t lbs_lowsnr_write(struct file *file,
682 const char __user *userbuf, 682 const char __user *userbuf,
683 size_t count, loff_t *ppos) 683 size_t count, loff_t *ppos)
684{ 684{
685 wlan_private *priv = file->private_data; 685 lbs_private *priv = file->private_data;
686 wlan_adapter *adapter = priv->adapter; 686 lbs_adapter *adapter = priv->adapter;
687 ssize_t res, buf_size; 687 ssize_t res, buf_size;
688 int value, freq, subscribed, cmd_len; 688 int value, freq, subscribed, cmd_len;
689 struct cmd_ctrl_node *pcmdnode; 689 struct cmd_ctrl_node *pcmdnode;
@@ -707,9 +707,9 @@ static ssize_t libertas_lowsnr_write(struct file *file,
707 goto out_unlock; 707 goto out_unlock;
708 } 708 }
709 709
710 event_bitmap = libertas_get_events_bitmap(priv); 710 event_bitmap = lbs_get_events_bitmap(priv);
711 711
712 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr); 712 res = lbs_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
713 if (res < 0) 713 if (res < 0)
714 goto out_unlock; 714 goto out_unlock;
715 715
@@ -728,7 +728,7 @@ static ssize_t libertas_lowsnr_write(struct file *file,
728 event_bitmap |= subscribed ? 0x0002 : 0x0; 728 event_bitmap |= subscribed ? 0x0002 : 0x0;
729 event->events = cpu_to_le16(event_bitmap); 729 event->events = cpu_to_le16(event_bitmap);
730 730
731 libertas_queue_cmd(adapter, pcmdnode, 1); 731 lbs_queue_cmd(adapter, pcmdnode, 1);
732 wake_up_interruptible(&priv->waitq); 732 wake_up_interruptible(&priv->waitq);
733 733
734 /* Sleep until response is generated by FW */ 734 /* Sleep until response is generated by FW */
@@ -759,11 +759,11 @@ out_unlock:
759 return res; 759 return res;
760} 760}
761 761
762static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf, 762static ssize_t lbs_failcount_read(struct file *file, char __user *userbuf,
763 size_t count, loff_t *ppos) 763 size_t count, loff_t *ppos)
764{ 764{
765 wlan_private *priv = file->private_data; 765 lbs_private *priv = file->private_data;
766 wlan_adapter *adapter = priv->adapter; 766 lbs_adapter *adapter = priv->adapter;
767 struct cmd_ctrl_node *pcmdnode; 767 struct cmd_ctrl_node *pcmdnode;
768 struct cmd_ds_command *pcmdptr; 768 struct cmd_ds_command *pcmdptr;
769 struct cmd_ds_802_11_subscribe_event *event; 769 struct cmd_ds_802_11_subscribe_event *event;
@@ -773,7 +773,7 @@ static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf,
773 unsigned long addr = get_zeroed_page(GFP_KERNEL); 773 unsigned long addr = get_zeroed_page(GFP_KERNEL);
774 char *buf = (char *)addr; 774 char *buf = (char *)addr;
775 775
776 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr); 776 res = lbs_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
777 if (res < 0) { 777 if (res < 0) {
778 free_page(addr); 778 free_page(addr);
779 return res; 779 return res;
@@ -782,7 +782,7 @@ static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf,
782 event = &pcmdptr->params.subscribe_event; 782 event = &pcmdptr->params.subscribe_event;
783 event->action = cpu_to_le16(CMD_ACT_GET); 783 event->action = cpu_to_le16(CMD_ACT_GET);
784 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 784 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
785 libertas_queue_cmd(adapter, pcmdnode, 1); 785 lbs_queue_cmd(adapter, pcmdnode, 1);
786 wake_up_interruptible(&priv->waitq); 786 wake_up_interruptible(&priv->waitq);
787 787
788 /* Sleep until response is generated by FW */ 788 /* Sleep until response is generated by FW */
@@ -830,12 +830,12 @@ static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf,
830 return res; 830 return res;
831} 831}
832 832
833static ssize_t libertas_failcount_write(struct file *file, 833static ssize_t lbs_failcount_write(struct file *file,
834 const char __user *userbuf, 834 const char __user *userbuf,
835 size_t count, loff_t *ppos) 835 size_t count, loff_t *ppos)
836{ 836{
837 wlan_private *priv = file->private_data; 837 lbs_private *priv = file->private_data;
838 wlan_adapter *adapter = priv->adapter; 838 lbs_adapter *adapter = priv->adapter;
839 ssize_t res, buf_size; 839 ssize_t res, buf_size;
840 int value, freq, subscribed, cmd_len; 840 int value, freq, subscribed, cmd_len;
841 struct cmd_ctrl_node *pcmdnode; 841 struct cmd_ctrl_node *pcmdnode;
@@ -859,9 +859,9 @@ static ssize_t libertas_failcount_write(struct file *file,
859 goto out_unlock; 859 goto out_unlock;
860 } 860 }
861 861
862 event_bitmap = libertas_get_events_bitmap(priv); 862 event_bitmap = lbs_get_events_bitmap(priv);
863 863
864 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr); 864 res = lbs_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
865 if (res < 0) 865 if (res < 0)
866 goto out_unlock; 866 goto out_unlock;
867 867
@@ -880,7 +880,7 @@ static ssize_t libertas_failcount_write(struct file *file,
880 event_bitmap |= subscribed ? 0x0004 : 0x0; 880 event_bitmap |= subscribed ? 0x0004 : 0x0;
881 event->events = cpu_to_le16(event_bitmap); 881 event->events = cpu_to_le16(event_bitmap);
882 882
883 libertas_queue_cmd(adapter, pcmdnode, 1); 883 lbs_queue_cmd(adapter, pcmdnode, 1);
884 wake_up_interruptible(&priv->waitq); 884 wake_up_interruptible(&priv->waitq);
885 885
886 /* Sleep until response is generated by FW */ 886 /* Sleep until response is generated by FW */
@@ -910,11 +910,11 @@ out_unlock:
910 return res; 910 return res;
911} 911}
912 912
913static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf, 913static ssize_t lbs_bcnmiss_read(struct file *file, char __user *userbuf,
914 size_t count, loff_t *ppos) 914 size_t count, loff_t *ppos)
915{ 915{
916 wlan_private *priv = file->private_data; 916 lbs_private *priv = file->private_data;
917 wlan_adapter *adapter = priv->adapter; 917 lbs_adapter *adapter = priv->adapter;
918 struct cmd_ctrl_node *pcmdnode; 918 struct cmd_ctrl_node *pcmdnode;
919 struct cmd_ds_command *pcmdptr; 919 struct cmd_ds_command *pcmdptr;
920 struct cmd_ds_802_11_subscribe_event *event; 920 struct cmd_ds_802_11_subscribe_event *event;
@@ -924,7 +924,7 @@ static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf,
924 unsigned long addr = get_zeroed_page(GFP_KERNEL); 924 unsigned long addr = get_zeroed_page(GFP_KERNEL);
925 char *buf = (char *)addr; 925 char *buf = (char *)addr;
926 926
927 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr); 927 res = lbs_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
928 if (res < 0) { 928 if (res < 0) {
929 free_page(addr); 929 free_page(addr);
930 return res; 930 return res;
@@ -933,7 +933,7 @@ static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf,
933 event = &pcmdptr->params.subscribe_event; 933 event = &pcmdptr->params.subscribe_event;
934 event->action = cpu_to_le16(CMD_ACT_GET); 934 event->action = cpu_to_le16(CMD_ACT_GET);
935 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 935 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
936 libertas_queue_cmd(adapter, pcmdnode, 1); 936 lbs_queue_cmd(adapter, pcmdnode, 1);
937 wake_up_interruptible(&priv->waitq); 937 wake_up_interruptible(&priv->waitq);
938 938
939 /* Sleep until response is generated by FW */ 939 /* Sleep until response is generated by FW */
@@ -981,12 +981,12 @@ static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf,
981 return res; 981 return res;
982} 982}
983 983
984static ssize_t libertas_bcnmiss_write(struct file *file, 984static ssize_t lbs_bcnmiss_write(struct file *file,
985 const char __user *userbuf, 985 const char __user *userbuf,
986 size_t count, loff_t *ppos) 986 size_t count, loff_t *ppos)
987{ 987{
988 wlan_private *priv = file->private_data; 988 lbs_private *priv = file->private_data;
989 wlan_adapter *adapter = priv->adapter; 989 lbs_adapter *adapter = priv->adapter;
990 ssize_t res, buf_size; 990 ssize_t res, buf_size;
991 int value, freq, subscribed, cmd_len; 991 int value, freq, subscribed, cmd_len;
992 struct cmd_ctrl_node *pcmdnode; 992 struct cmd_ctrl_node *pcmdnode;
@@ -1010,9 +1010,9 @@ static ssize_t libertas_bcnmiss_write(struct file *file,
1010 goto out_unlock; 1010 goto out_unlock;
1011 } 1011 }
1012 1012
1013 event_bitmap = libertas_get_events_bitmap(priv); 1013 event_bitmap = lbs_get_events_bitmap(priv);
1014 1014
1015 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr); 1015 res = lbs_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1016 if (res < 0) 1016 if (res < 0)
1017 goto out_unlock; 1017 goto out_unlock;
1018 1018
@@ -1030,7 +1030,7 @@ static ssize_t libertas_bcnmiss_write(struct file *file,
1030 event_bitmap |= subscribed ? 0x0008 : 0x0; 1030 event_bitmap |= subscribed ? 0x0008 : 0x0;
1031 event->events = cpu_to_le16(event_bitmap); 1031 event->events = cpu_to_le16(event_bitmap);
1032 1032
1033 libertas_queue_cmd(adapter, pcmdnode, 1); 1033 lbs_queue_cmd(adapter, pcmdnode, 1);
1034 wake_up_interruptible(&priv->waitq); 1034 wake_up_interruptible(&priv->waitq);
1035 1035
1036 /* Sleep until response is generated by FW */ 1036 /* Sleep until response is generated by FW */
@@ -1060,11 +1060,11 @@ out_unlock:
1060 return res; 1060 return res;
1061} 1061}
1062 1062
1063static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf, 1063static ssize_t lbs_highrssi_read(struct file *file, char __user *userbuf,
1064 size_t count, loff_t *ppos) 1064 size_t count, loff_t *ppos)
1065{ 1065{
1066 wlan_private *priv = file->private_data; 1066 lbs_private *priv = file->private_data;
1067 wlan_adapter *adapter = priv->adapter; 1067 lbs_adapter *adapter = priv->adapter;
1068 struct cmd_ctrl_node *pcmdnode; 1068 struct cmd_ctrl_node *pcmdnode;
1069 struct cmd_ds_command *pcmdptr; 1069 struct cmd_ds_command *pcmdptr;
1070 struct cmd_ds_802_11_subscribe_event *event; 1070 struct cmd_ds_802_11_subscribe_event *event;
@@ -1074,7 +1074,7 @@ static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf,
1074 unsigned long addr = get_zeroed_page(GFP_KERNEL); 1074 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1075 char *buf = (char *)addr; 1075 char *buf = (char *)addr;
1076 1076
1077 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr); 1077 res = lbs_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1078 if (res < 0) { 1078 if (res < 0) {
1079 free_page(addr); 1079 free_page(addr);
1080 return res; 1080 return res;
@@ -1083,7 +1083,7 @@ static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf,
1083 event = &pcmdptr->params.subscribe_event; 1083 event = &pcmdptr->params.subscribe_event;
1084 event->action = cpu_to_le16(CMD_ACT_GET); 1084 event->action = cpu_to_le16(CMD_ACT_GET);
1085 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 1085 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
1086 libertas_queue_cmd(adapter, pcmdnode, 1); 1086 lbs_queue_cmd(adapter, pcmdnode, 1);
1087 wake_up_interruptible(&priv->waitq); 1087 wake_up_interruptible(&priv->waitq);
1088 1088
1089 /* Sleep until response is generated by FW */ 1089 /* Sleep until response is generated by FW */
@@ -1132,12 +1132,12 @@ static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf,
1132 return res; 1132 return res;
1133} 1133}
1134 1134
1135static ssize_t libertas_highrssi_write(struct file *file, 1135static ssize_t lbs_highrssi_write(struct file *file,
1136 const char __user *userbuf, 1136 const char __user *userbuf,
1137 size_t count, loff_t *ppos) 1137 size_t count, loff_t *ppos)
1138{ 1138{
1139 wlan_private *priv = file->private_data; 1139 lbs_private *priv = file->private_data;
1140 wlan_adapter *adapter = priv->adapter; 1140 lbs_adapter *adapter = priv->adapter;
1141 ssize_t res, buf_size; 1141 ssize_t res, buf_size;
1142 int value, freq, subscribed, cmd_len; 1142 int value, freq, subscribed, cmd_len;
1143 struct cmd_ctrl_node *pcmdnode; 1143 struct cmd_ctrl_node *pcmdnode;
@@ -1161,9 +1161,9 @@ static ssize_t libertas_highrssi_write(struct file *file,
1161 goto out_unlock; 1161 goto out_unlock;
1162 } 1162 }
1163 1163
1164 event_bitmap = libertas_get_events_bitmap(priv); 1164 event_bitmap = lbs_get_events_bitmap(priv);
1165 1165
1166 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr); 1166 res = lbs_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1167 if (res < 0) 1167 if (res < 0)
1168 goto out_unlock; 1168 goto out_unlock;
1169 1169
@@ -1182,7 +1182,7 @@ static ssize_t libertas_highrssi_write(struct file *file,
1182 event_bitmap |= subscribed ? 0x0010 : 0x0; 1182 event_bitmap |= subscribed ? 0x0010 : 0x0;
1183 event->events = cpu_to_le16(event_bitmap); 1183 event->events = cpu_to_le16(event_bitmap);
1184 1184
1185 libertas_queue_cmd(adapter, pcmdnode, 1); 1185 lbs_queue_cmd(adapter, pcmdnode, 1);
1186 wake_up_interruptible(&priv->waitq); 1186 wake_up_interruptible(&priv->waitq);
1187 1187
1188 /* Sleep until response is generated by FW */ 1188 /* Sleep until response is generated by FW */
@@ -1210,11 +1210,11 @@ out_unlock:
1210 return res; 1210 return res;
1211} 1211}
1212 1212
1213static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf, 1213static ssize_t lbs_highsnr_read(struct file *file, char __user *userbuf,
1214 size_t count, loff_t *ppos) 1214 size_t count, loff_t *ppos)
1215{ 1215{
1216 wlan_private *priv = file->private_data; 1216 lbs_private *priv = file->private_data;
1217 wlan_adapter *adapter = priv->adapter; 1217 lbs_adapter *adapter = priv->adapter;
1218 struct cmd_ctrl_node *pcmdnode; 1218 struct cmd_ctrl_node *pcmdnode;
1219 struct cmd_ds_command *pcmdptr; 1219 struct cmd_ds_command *pcmdptr;
1220 struct cmd_ds_802_11_subscribe_event *event; 1220 struct cmd_ds_802_11_subscribe_event *event;
@@ -1224,7 +1224,7 @@ static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf,
1224 unsigned long addr = get_zeroed_page(GFP_KERNEL); 1224 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1225 char *buf = (char *)addr; 1225 char *buf = (char *)addr;
1226 1226
1227 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr); 1227 res = lbs_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1228 if (res < 0) { 1228 if (res < 0) {
1229 free_page(addr); 1229 free_page(addr);
1230 return res; 1230 return res;
@@ -1233,7 +1233,7 @@ static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf,
1233 event = &pcmdptr->params.subscribe_event; 1233 event = &pcmdptr->params.subscribe_event;
1234 event->action = cpu_to_le16(CMD_ACT_GET); 1234 event->action = cpu_to_le16(CMD_ACT_GET);
1235 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN); 1235 pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);
1236 libertas_queue_cmd(adapter, pcmdnode, 1); 1236 lbs_queue_cmd(adapter, pcmdnode, 1);
1237 wake_up_interruptible(&priv->waitq); 1237 wake_up_interruptible(&priv->waitq);
1238 1238
1239 /* Sleep until response is generated by FW */ 1239 /* Sleep until response is generated by FW */
@@ -1282,12 +1282,12 @@ static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf,
1282 return res; 1282 return res;
1283} 1283}
1284 1284
1285static ssize_t libertas_highsnr_write(struct file *file, 1285static ssize_t lbs_highsnr_write(struct file *file,
1286 const char __user *userbuf, 1286 const char __user *userbuf,
1287 size_t count, loff_t *ppos) 1287 size_t count, loff_t *ppos)
1288{ 1288{
1289 wlan_private *priv = file->private_data; 1289 lbs_private *priv = file->private_data;
1290 wlan_adapter *adapter = priv->adapter; 1290 lbs_adapter *adapter = priv->adapter;
1291 ssize_t res, buf_size; 1291 ssize_t res, buf_size;
1292 int value, freq, subscribed, cmd_len; 1292 int value, freq, subscribed, cmd_len;
1293 struct cmd_ctrl_node *pcmdnode; 1293 struct cmd_ctrl_node *pcmdnode;
@@ -1311,9 +1311,9 @@ static ssize_t libertas_highsnr_write(struct file *file,
1311 goto out_unlock; 1311 goto out_unlock;
1312 } 1312 }
1313 1313
1314 event_bitmap = libertas_get_events_bitmap(priv); 1314 event_bitmap = lbs_get_events_bitmap(priv);
1315 1315
1316 res = libertas_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr); 1316 res = lbs_event_initcmd(priv, &response_buf, &pcmdnode, &pcmdptr);
1317 if (res < 0) 1317 if (res < 0)
1318 goto out_unlock; 1318 goto out_unlock;
1319 1319
@@ -1332,7 +1332,7 @@ static ssize_t libertas_highsnr_write(struct file *file,
1332 event_bitmap |= subscribed ? 0x0020 : 0x0; 1332 event_bitmap |= subscribed ? 0x0020 : 0x0;
1333 event->events = cpu_to_le16(event_bitmap); 1333 event->events = cpu_to_le16(event_bitmap);
1334 1334
1335 libertas_queue_cmd(adapter, pcmdnode, 1); 1335 lbs_queue_cmd(adapter, pcmdnode, 1);
1336 wake_up_interruptible(&priv->waitq); 1336 wake_up_interruptible(&priv->waitq);
1337 1337
1338 /* Sleep until response is generated by FW */ 1338 /* Sleep until response is generated by FW */
@@ -1362,12 +1362,12 @@ out_unlock:
1362 return res; 1362 return res;
1363} 1363}
1364 1364
1365static ssize_t libertas_rdmac_read(struct file *file, char __user *userbuf, 1365static ssize_t lbs_rdmac_read(struct file *file, char __user *userbuf,
1366 size_t count, loff_t *ppos) 1366 size_t count, loff_t *ppos)
1367{ 1367{
1368 wlan_private *priv = file->private_data; 1368 lbs_private *priv = file->private_data;
1369 wlan_adapter *adapter = priv->adapter; 1369 lbs_adapter *adapter = priv->adapter;
1370 struct wlan_offset_value offval; 1370 struct lbs_offset_value offval;
1371 ssize_t pos = 0; 1371 ssize_t pos = 0;
1372 int ret; 1372 int ret;
1373 unsigned long addr = get_zeroed_page(GFP_KERNEL); 1373 unsigned long addr = get_zeroed_page(GFP_KERNEL);
@@ -1376,7 +1376,7 @@ static ssize_t libertas_rdmac_read(struct file *file, char __user *userbuf,
1376 offval.offset = priv->mac_offset; 1376 offval.offset = priv->mac_offset;
1377 offval.value = 0; 1377 offval.value = 0;
1378 1378
1379 ret = libertas_prepare_and_send_command(priv, 1379 ret = lbs_prepare_and_send_command(priv,
1380 CMD_MAC_REG_ACCESS, 0, 1380 CMD_MAC_REG_ACCESS, 0,
1381 CMD_OPTION_WAITFORRSP, 0, &offval); 1381 CMD_OPTION_WAITFORRSP, 0, &offval);
1382 mdelay(10); 1382 mdelay(10);
@@ -1388,11 +1388,11 @@ static ssize_t libertas_rdmac_read(struct file *file, char __user *userbuf,
1388 return ret; 1388 return ret;
1389} 1389}
1390 1390
1391static ssize_t libertas_rdmac_write(struct file *file, 1391static ssize_t lbs_rdmac_write(struct file *file,
1392 const char __user *userbuf, 1392 const char __user *userbuf,
1393 size_t count, loff_t *ppos) 1393 size_t count, loff_t *ppos)
1394{ 1394{
1395 wlan_private *priv = file->private_data; 1395 lbs_private *priv = file->private_data;
1396 ssize_t res, buf_size; 1396 ssize_t res, buf_size;
1397 unsigned long addr = get_zeroed_page(GFP_KERNEL); 1397 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1398 char *buf = (char *)addr; 1398 char *buf = (char *)addr;
@@ -1409,15 +1409,15 @@ out_unlock:
1409 return res; 1409 return res;
1410} 1410}
1411 1411
1412static ssize_t libertas_wrmac_write(struct file *file, 1412static ssize_t lbs_wrmac_write(struct file *file,
1413 const char __user *userbuf, 1413 const char __user *userbuf,
1414 size_t count, loff_t *ppos) 1414 size_t count, loff_t *ppos)
1415{ 1415{
1416 1416
1417 wlan_private *priv = file->private_data; 1417 lbs_private *priv = file->private_data;
1418 ssize_t res, buf_size; 1418 ssize_t res, buf_size;
1419 u32 offset, value; 1419 u32 offset, value;
1420 struct wlan_offset_value offval; 1420 struct lbs_offset_value offval;
1421 unsigned long addr = get_zeroed_page(GFP_KERNEL); 1421 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1422 char *buf = (char *)addr; 1422 char *buf = (char *)addr;
1423 1423
@@ -1434,7 +1434,7 @@ static ssize_t libertas_wrmac_write(struct file *file,
1434 1434
1435 offval.offset = offset; 1435 offval.offset = offset;
1436 offval.value = value; 1436 offval.value = value;
1437 res = libertas_prepare_and_send_command(priv, 1437 res = lbs_prepare_and_send_command(priv,
1438 CMD_MAC_REG_ACCESS, 1, 1438 CMD_MAC_REG_ACCESS, 1,
1439 CMD_OPTION_WAITFORRSP, 0, &offval); 1439 CMD_OPTION_WAITFORRSP, 0, &offval);
1440 mdelay(10); 1440 mdelay(10);
@@ -1445,12 +1445,12 @@ out_unlock:
1445 return res; 1445 return res;
1446} 1446}
1447 1447
1448static ssize_t libertas_rdbbp_read(struct file *file, char __user *userbuf, 1448static ssize_t lbs_rdbbp_read(struct file *file, char __user *userbuf,
1449 size_t count, loff_t *ppos) 1449 size_t count, loff_t *ppos)
1450{ 1450{
1451 wlan_private *priv = file->private_data; 1451 lbs_private *priv = file->private_data;
1452 wlan_adapter *adapter = priv->adapter; 1452 lbs_adapter *adapter = priv->adapter;
1453 struct wlan_offset_value offval; 1453 struct lbs_offset_value offval;
1454 ssize_t pos = 0; 1454 ssize_t pos = 0;
1455 int ret; 1455 int ret;
1456 unsigned long addr = get_zeroed_page(GFP_KERNEL); 1456 unsigned long addr = get_zeroed_page(GFP_KERNEL);
@@ -1459,7 +1459,7 @@ static ssize_t libertas_rdbbp_read(struct file *file, char __user *userbuf,
1459 offval.offset = priv->bbp_offset; 1459 offval.offset = priv->bbp_offset;
1460 offval.value = 0; 1460 offval.value = 0;
1461 1461
1462 ret = libertas_prepare_and_send_command(priv, 1462 ret = lbs_prepare_and_send_command(priv,
1463 CMD_BBP_REG_ACCESS, 0, 1463 CMD_BBP_REG_ACCESS, 0,
1464 CMD_OPTION_WAITFORRSP, 0, &offval); 1464 CMD_OPTION_WAITFORRSP, 0, &offval);
1465 mdelay(10); 1465 mdelay(10);
@@ -1472,11 +1472,11 @@ static ssize_t libertas_rdbbp_read(struct file *file, char __user *userbuf,
1472 return ret; 1472 return ret;
1473} 1473}
1474 1474
1475static ssize_t libertas_rdbbp_write(struct file *file, 1475static ssize_t lbs_rdbbp_write(struct file *file,
1476 const char __user *userbuf, 1476 const char __user *userbuf,
1477 size_t count, loff_t *ppos) 1477 size_t count, loff_t *ppos)
1478{ 1478{
1479 wlan_private *priv = file->private_data; 1479 lbs_private *priv = file->private_data;
1480 ssize_t res, buf_size; 1480 ssize_t res, buf_size;
1481 unsigned long addr = get_zeroed_page(GFP_KERNEL); 1481 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1482 char *buf = (char *)addr; 1482 char *buf = (char *)addr;
@@ -1493,15 +1493,15 @@ out_unlock:
1493 return res; 1493 return res;
1494} 1494}
1495 1495
1496static ssize_t libertas_wrbbp_write(struct file *file, 1496static ssize_t lbs_wrbbp_write(struct file *file,
1497 const char __user *userbuf, 1497 const char __user *userbuf,
1498 size_t count, loff_t *ppos) 1498 size_t count, loff_t *ppos)
1499{ 1499{
1500 1500
1501 wlan_private *priv = file->private_data; 1501 lbs_private *priv = file->private_data;
1502 ssize_t res, buf_size; 1502 ssize_t res, buf_size;
1503 u32 offset, value; 1503 u32 offset, value;
1504 struct wlan_offset_value offval; 1504 struct lbs_offset_value offval;
1505 unsigned long addr = get_zeroed_page(GFP_KERNEL); 1505 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1506 char *buf = (char *)addr; 1506 char *buf = (char *)addr;
1507 1507
@@ -1518,7 +1518,7 @@ static ssize_t libertas_wrbbp_write(struct file *file,
1518 1518
1519 offval.offset = offset; 1519 offval.offset = offset;
1520 offval.value = value; 1520 offval.value = value;
1521 res = libertas_prepare_and_send_command(priv, 1521 res = lbs_prepare_and_send_command(priv,
1522 CMD_BBP_REG_ACCESS, 1, 1522 CMD_BBP_REG_ACCESS, 1,
1523 CMD_OPTION_WAITFORRSP, 0, &offval); 1523 CMD_OPTION_WAITFORRSP, 0, &offval);
1524 mdelay(10); 1524 mdelay(10);
@@ -1529,12 +1529,12 @@ out_unlock:
1529 return res; 1529 return res;
1530} 1530}
1531 1531
1532static ssize_t libertas_rdrf_read(struct file *file, char __user *userbuf, 1532static ssize_t lbs_rdrf_read(struct file *file, char __user *userbuf,
1533 size_t count, loff_t *ppos) 1533 size_t count, loff_t *ppos)
1534{ 1534{
1535 wlan_private *priv = file->private_data; 1535 lbs_private *priv = file->private_data;
1536 wlan_adapter *adapter = priv->adapter; 1536 lbs_adapter *adapter = priv->adapter;
1537 struct wlan_offset_value offval; 1537 struct lbs_offset_value offval;
1538 ssize_t pos = 0; 1538 ssize_t pos = 0;
1539 int ret; 1539 int ret;
1540 unsigned long addr = get_zeroed_page(GFP_KERNEL); 1540 unsigned long addr = get_zeroed_page(GFP_KERNEL);
@@ -1543,7 +1543,7 @@ static ssize_t libertas_rdrf_read(struct file *file, char __user *userbuf,
1543 offval.offset = priv->rf_offset; 1543 offval.offset = priv->rf_offset;
1544 offval.value = 0; 1544 offval.value = 0;
1545 1545
1546 ret = libertas_prepare_and_send_command(priv, 1546 ret = lbs_prepare_and_send_command(priv,
1547 CMD_RF_REG_ACCESS, 0, 1547 CMD_RF_REG_ACCESS, 0,
1548 CMD_OPTION_WAITFORRSP, 0, &offval); 1548 CMD_OPTION_WAITFORRSP, 0, &offval);
1549 mdelay(10); 1549 mdelay(10);
@@ -1556,11 +1556,11 @@ static ssize_t libertas_rdrf_read(struct file *file, char __user *userbuf,
1556 return ret; 1556 return ret;
1557} 1557}
1558 1558
1559static ssize_t libertas_rdrf_write(struct file *file, 1559static ssize_t lbs_rdrf_write(struct file *file,
1560 const char __user *userbuf, 1560 const char __user *userbuf,
1561 size_t count, loff_t *ppos) 1561 size_t count, loff_t *ppos)
1562{ 1562{
1563 wlan_private *priv = file->private_data; 1563 lbs_private *priv = file->private_data;
1564 ssize_t res, buf_size; 1564 ssize_t res, buf_size;
1565 unsigned long addr = get_zeroed_page(GFP_KERNEL); 1565 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1566 char *buf = (char *)addr; 1566 char *buf = (char *)addr;
@@ -1577,15 +1577,15 @@ out_unlock:
1577 return res; 1577 return res;
1578} 1578}
1579 1579
1580static ssize_t libertas_wrrf_write(struct file *file, 1580static ssize_t lbs_wrrf_write(struct file *file,
1581 const char __user *userbuf, 1581 const char __user *userbuf,
1582 size_t count, loff_t *ppos) 1582 size_t count, loff_t *ppos)
1583{ 1583{
1584 1584
1585 wlan_private *priv = file->private_data; 1585 lbs_private *priv = file->private_data;
1586 ssize_t res, buf_size; 1586 ssize_t res, buf_size;
1587 u32 offset, value; 1587 u32 offset, value;
1588 struct wlan_offset_value offval; 1588 struct lbs_offset_value offval;
1589 unsigned long addr = get_zeroed_page(GFP_KERNEL); 1589 unsigned long addr = get_zeroed_page(GFP_KERNEL);
1590 char *buf = (char *)addr; 1590 char *buf = (char *)addr;
1591 1591
@@ -1602,7 +1602,7 @@ static ssize_t libertas_wrrf_write(struct file *file,
1602 1602
1603 offval.offset = offset; 1603 offval.offset = offset;
1604 offval.value = value; 1604 offval.value = value;
1605 res = libertas_prepare_and_send_command(priv, 1605 res = lbs_prepare_and_send_command(priv,
1606 CMD_RF_REG_ACCESS, 1, 1606 CMD_RF_REG_ACCESS, 1,
1607 CMD_OPTION_WAITFORRSP, 0, &offval); 1607 CMD_OPTION_WAITFORRSP, 0, &offval);
1608 mdelay(10); 1608 mdelay(10);
@@ -1620,69 +1620,69 @@ out_unlock:
1620 .write = (fwrite), \ 1620 .write = (fwrite), \
1621} 1621}
1622 1622
1623struct libertas_debugfs_files { 1623struct lbs_debugfs_files {
1624 char *name; 1624 char *name;
1625 int perm; 1625 int perm;
1626 struct file_operations fops; 1626 struct file_operations fops;
1627}; 1627};
1628 1628
1629static struct libertas_debugfs_files debugfs_files[] = { 1629static struct lbs_debugfs_files debugfs_files[] = {
1630 { "info", 0444, FOPS(libertas_dev_info, write_file_dummy), }, 1630 { "info", 0444, FOPS(lbs_dev_info, write_file_dummy), },
1631 { "getscantable", 0444, FOPS(libertas_getscantable, 1631 { "getscantable", 0444, FOPS(lbs_getscantable,
1632 write_file_dummy), }, 1632 write_file_dummy), },
1633 { "sleepparams", 0644, FOPS(libertas_sleepparams_read, 1633 { "sleepparams", 0644, FOPS(lbs_sleepparams_read,
1634 libertas_sleepparams_write), }, 1634 lbs_sleepparams_write), },
1635 { "extscan", 0600, FOPS(NULL, libertas_extscan), }, 1635 { "extscan", 0600, FOPS(NULL, lbs_extscan), },
1636 { "setuserscan", 0600, FOPS(NULL, libertas_setuserscan), }, 1636 { "setuserscan", 0600, FOPS(NULL, lbs_setuserscan), },
1637}; 1637};
1638 1638
1639static struct libertas_debugfs_files debugfs_events_files[] = { 1639static struct lbs_debugfs_files debugfs_events_files[] = {
1640 {"low_rssi", 0644, FOPS(libertas_lowrssi_read, 1640 {"low_rssi", 0644, FOPS(lbs_lowrssi_read,
1641 libertas_lowrssi_write), }, 1641 lbs_lowrssi_write), },
1642 {"low_snr", 0644, FOPS(libertas_lowsnr_read, 1642 {"low_snr", 0644, FOPS(lbs_lowsnr_read,
1643 libertas_lowsnr_write), }, 1643 lbs_lowsnr_write), },
1644 {"failure_count", 0644, FOPS(libertas_failcount_read, 1644 {"failure_count", 0644, FOPS(lbs_failcount_read,
1645 libertas_failcount_write), }, 1645 lbs_failcount_write), },
1646 {"beacon_missed", 0644, FOPS(libertas_bcnmiss_read, 1646 {"beacon_missed", 0644, FOPS(lbs_bcnmiss_read,
1647 libertas_bcnmiss_write), }, 1647 lbs_bcnmiss_write), },
1648 {"high_rssi", 0644, FOPS(libertas_highrssi_read, 1648 {"high_rssi", 0644, FOPS(lbs_highrssi_read,
1649 libertas_highrssi_write), }, 1649 lbs_highrssi_write), },
1650 {"high_snr", 0644, FOPS(libertas_highsnr_read, 1650 {"high_snr", 0644, FOPS(lbs_highsnr_read,
1651 libertas_highsnr_write), }, 1651 lbs_highsnr_write), },
1652}; 1652};
1653 1653
1654static struct libertas_debugfs_files debugfs_regs_files[] = { 1654static struct lbs_debugfs_files debugfs_regs_files[] = {
1655 {"rdmac", 0644, FOPS(libertas_rdmac_read, libertas_rdmac_write), }, 1655 {"rdmac", 0644, FOPS(lbs_rdmac_read, lbs_rdmac_write), },
1656 {"wrmac", 0600, FOPS(NULL, libertas_wrmac_write), }, 1656 {"wrmac", 0600, FOPS(NULL, lbs_wrmac_write), },
1657 {"rdbbp", 0644, FOPS(libertas_rdbbp_read, libertas_rdbbp_write), }, 1657 {"rdbbp", 0644, FOPS(lbs_rdbbp_read, lbs_rdbbp_write), },
1658 {"wrbbp", 0600, FOPS(NULL, libertas_wrbbp_write), }, 1658 {"wrbbp", 0600, FOPS(NULL, lbs_wrbbp_write), },
1659 {"rdrf", 0644, FOPS(libertas_rdrf_read, libertas_rdrf_write), }, 1659 {"rdrf", 0644, FOPS(lbs_rdrf_read, lbs_rdrf_write), },
1660 {"wrrf", 0600, FOPS(NULL, libertas_wrrf_write), }, 1660 {"wrrf", 0600, FOPS(NULL, lbs_wrrf_write), },
1661}; 1661};
1662 1662
1663void libertas_debugfs_init(void) 1663void lbs_debugfs_init(void)
1664{ 1664{
1665 if (!libertas_dir) 1665 if (!lbs_dir)
1666 libertas_dir = debugfs_create_dir("libertas_wireless", NULL); 1666 lbs_dir = debugfs_create_dir("lbs_wireless", NULL);
1667 1667
1668 return; 1668 return;
1669} 1669}
1670 1670
1671void libertas_debugfs_remove(void) 1671void lbs_debugfs_remove(void)
1672{ 1672{
1673 if (libertas_dir) 1673 if (lbs_dir)
1674 debugfs_remove(libertas_dir); 1674 debugfs_remove(lbs_dir);
1675 return; 1675 return;
1676} 1676}
1677 1677
1678void libertas_debugfs_init_one(wlan_private *priv, struct net_device *dev) 1678void lbs_debugfs_init_one(lbs_private *priv, struct net_device *dev)
1679{ 1679{
1680 int i; 1680 int i;
1681 struct libertas_debugfs_files *files; 1681 struct lbs_debugfs_files *files;
1682 if (!libertas_dir) 1682 if (!lbs_dir)
1683 goto exit; 1683 goto exit;
1684 1684
1685 priv->debugfs_dir = debugfs_create_dir(dev->name, libertas_dir); 1685 priv->debugfs_dir = debugfs_create_dir(dev->name, lbs_dir);
1686 if (!priv->debugfs_dir) 1686 if (!priv->debugfs_dir)
1687 goto exit; 1687 goto exit;
1688 1688
@@ -1722,13 +1722,13 @@ void libertas_debugfs_init_one(wlan_private *priv, struct net_device *dev)
1722 } 1722 }
1723 1723
1724#ifdef PROC_DEBUG 1724#ifdef PROC_DEBUG
1725 libertas_debug_init(priv, dev); 1725 lbs_debug_init(priv, dev);
1726#endif 1726#endif
1727exit: 1727exit:
1728 return; 1728 return;
1729} 1729}
1730 1730
1731void libertas_debugfs_remove_one(wlan_private *priv) 1731void lbs_debugfs_remove_one(lbs_private *priv)
1732{ 1732{
1733 int i; 1733 int i;
1734 1734
@@ -1755,8 +1755,8 @@ void libertas_debugfs_remove_one(wlan_private *priv)
1755 1755
1756#ifdef PROC_DEBUG 1756#ifdef PROC_DEBUG
1757 1757
1758#define item_size(n) (FIELD_SIZEOF(wlan_adapter, n)) 1758#define item_size(n) (FIELD_SIZEOF(lbs_adapter, n))
1759#define item_addr(n) (offsetof(wlan_adapter, n)) 1759#define item_addr(n) (offsetof(lbs_adapter, n))
1760 1760
1761 1761
1762struct debug_data { 1762struct debug_data {
@@ -1765,7 +1765,7 @@ struct debug_data {
1765 size_t addr; 1765 size_t addr;
1766}; 1766};
1767 1767
1768/* To debug any member of wlan_adapter, simply add one line here. 1768/* To debug any member of lbs_adapter, simply add one line here.
1769 */ 1769 */
1770static struct debug_data items[] = { 1770static struct debug_data items[] = {
1771 {"intcounter", item_size(intcounter), item_addr(intcounter)}, 1771 {"intcounter", item_size(intcounter), item_addr(intcounter)},
@@ -1786,7 +1786,7 @@ static int num_of_items = ARRAY_SIZE(items);
1786 * @param data data to output 1786 * @param data data to output
1787 * @return number of output data 1787 * @return number of output data
1788 */ 1788 */
1789static ssize_t wlan_debugfs_read(struct file *file, char __user *userbuf, 1789static ssize_t lbs_debugfs_read(struct file *file, char __user *userbuf,
1790 size_t count, loff_t *ppos) 1790 size_t count, loff_t *ppos)
1791{ 1791{
1792 int val = 0; 1792 int val = 0;
@@ -1830,7 +1830,7 @@ static ssize_t wlan_debugfs_read(struct file *file, char __user *userbuf,
1830 * @param data data to write 1830 * @param data data to write
1831 * @return number of data 1831 * @return number of data
1832 */ 1832 */
1833static ssize_t wlan_debugfs_write(struct file *f, const char __user *buf, 1833static ssize_t lbs_debugfs_write(struct file *f, const char __user *buf,
1834 size_t cnt, loff_t *ppos) 1834 size_t cnt, loff_t *ppos)
1835{ 1835{
1836 int r, i; 1836 int r, i;
@@ -1882,21 +1882,21 @@ static ssize_t wlan_debugfs_write(struct file *f, const char __user *buf,
1882 return (ssize_t)cnt; 1882 return (ssize_t)cnt;
1883} 1883}
1884 1884
1885static struct file_operations libertas_debug_fops = { 1885static struct file_operations lbs_debug_fops = {
1886 .owner = THIS_MODULE, 1886 .owner = THIS_MODULE,
1887 .open = open_file_generic, 1887 .open = open_file_generic,
1888 .write = wlan_debugfs_write, 1888 .write = lbs_debugfs_write,
1889 .read = wlan_debugfs_read, 1889 .read = lbs_debugfs_read,
1890}; 1890};
1891 1891
1892/** 1892/**
1893 * @brief create debug proc file 1893 * @brief create debug proc file
1894 * 1894 *
1895 * @param priv pointer wlan_private 1895 * @param priv pointer lbs_private
1896 * @param dev pointer net_device 1896 * @param dev pointer net_device
1897 * @return N/A 1897 * @return N/A
1898 */ 1898 */
1899static void libertas_debug_init(wlan_private * priv, struct net_device *dev) 1899static void lbs_debug_init(lbs_private * priv, struct net_device *dev)
1900{ 1900{
1901 int i; 1901 int i;
1902 1902
@@ -1908,7 +1908,7 @@ static void libertas_debug_init(wlan_private * priv, struct net_device *dev)
1908 1908
1909 priv->debugfs_debug = debugfs_create_file("debug", 0644, 1909 priv->debugfs_debug = debugfs_create_file("debug", 0644,
1910 priv->debugfs_dir, &items[0], 1910 priv->debugfs_dir, &items[0],
1911 &libertas_debug_fops); 1911 &lbs_debug_fops);
1912} 1912}
1913#endif 1913#endif
1914 1914
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-03 22:31:29 -0500