Pileus Git - ~andy/linux/blob - drivers/net/wireless/libertas/debugfs.c

   1 #include <linux/dcache.h>
   2 #include <linux/debugfs.h>
   3 #include <linux/delay.h>
   4 #include <linux/mm.h>
   5 #include <linux/string.h>
   6 #include <linux/slab.h>
   7
   8 #include "decl.h"
   9 #include "cmd.h"
  10 #include "debugfs.h"
  11
  12 static struct dentry *lbs_dir;
  13 static char *szStates[] = {
  14         "Connected",
  15         "Disconnected"
  16 };
  17
  18 #ifdef PROC_DEBUG
  19 static void lbs_debug_init(struct lbs_private *priv);
  20 #endif
  21
  22 static int open_file_generic(struct inode *inode, struct file *file)
  23 {
  24         file->private_data = inode->i_private;
  25         return 0;
  26 }
  27
  28 static ssize_t write_file_dummy(struct file *file, const char __user *buf,
  29                                 size_t count, loff_t *ppos)
  30 {
  31         return -EINVAL;
  32 }
  33
  34 static const size_t len = PAGE_SIZE;
  35
  36 static ssize_t lbs_dev_info(struct file *file, char __user *userbuf,
  37                                   size_t count, loff_t *ppos)
  38 {
  39         struct lbs_private *priv = file->private_data;
  40         size_t pos = 0;
  41         unsigned long addr = get_zeroed_page(GFP_KERNEL);
  42         char *buf = (char *)addr;
  43         ssize_t res;
  44         if (!buf)
  45                 return -ENOMEM;
  46
  47         pos += snprintf(buf+pos, len-pos, "state = %s\n",
  48                                 szStates[priv->connect_status]);
  49         pos += snprintf(buf+pos, len-pos, "region_code = %02x\n",
  50                                 (u32) priv->regioncode);
  51
  52         res = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
  53
  54         free_page(addr);
  55         return res;
  56 }
  57
  58 static ssize_t lbs_sleepparams_write(struct file *file,
  59                                 const char __user *user_buf, size_t count,
  60                                 loff_t *ppos)
  61 {
  62         struct lbs_private *priv = file->private_data;
  63         ssize_t buf_size, ret;
  64         struct sleep_params sp;
  65         int p1, p2, p3, p4, p5, p6;
  66         unsigned long addr = get_zeroed_page(GFP_KERNEL);
  67         char *buf = (char *)addr;
  68         if (!buf)
  69                 return -ENOMEM;
  70
  71         buf_size = min(count, len - 1);
  72         if (copy_from_user(buf, user_buf, buf_size)) {
  73                 ret = -EFAULT;
  74                 goto out_unlock;
  75         }
  76         ret = sscanf(buf, "%d %d %d %d %d %d", &p1, &p2, &p3, &p4, &p5, &p6);
  77         if (ret != 6) {
  78                 ret = -EINVAL;
  79                 goto out_unlock;
  80         }
  81         sp.sp_error = p1;
  82         sp.sp_offset = p2;
  83         sp.sp_stabletime = p3;
  84         sp.sp_calcontrol = p4;
  85         sp.sp_extsleepclk = p5;
  86         sp.sp_reserved = p6;
  87
  88         ret = lbs_cmd_802_11_sleep_params(priv, CMD_ACT_SET, &sp);
  89         if (!ret)
  90                 ret = count;
  91         else if (ret > 0)
  92                 ret = -EINVAL;
  93
  94 out_unlock:
  95         free_page(addr);
  96         return ret;
  97 }
  98
  99 static ssize_t lbs_sleepparams_read(struct file *file, char __user *userbuf,
 100                                   size_t count, loff_t *ppos)
 101 {
 102         struct lbs_private *priv = file->private_data;
 103         ssize_t ret;
 104         size_t pos = 0;
 105         struct sleep_params sp;
 106         unsigned long addr = get_zeroed_page(GFP_KERNEL);
 107         char *buf = (char *)addr;
 108         if (!buf)
 109                 return -ENOMEM;
 110
 111         ret = lbs_cmd_802_11_sleep_params(priv, CMD_ACT_GET, &sp);
 112         if (ret)
 113                 goto out_unlock;
 114
 115         pos += snprintf(buf, len, "%d %d %d %d %d %d\n", sp.sp_error,
 116                         sp.sp_offset, sp.sp_stabletime,
 117                         sp.sp_calcontrol, sp.sp_extsleepclk,
 118                         sp.sp_reserved);
 119
 120         ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
 121
 122 out_unlock:
 123         free_page(addr);
 124         return ret;
 125 }
 126
 127 static ssize_t lbs_host_sleep_write(struct file *file,
 128                                 const char __user *user_buf, size_t count,
 129                                 loff_t *ppos)
 130 {
 131         struct lbs_private *priv = file->private_data;
 132         ssize_t buf_size, ret;
 133         int host_sleep;
 134         unsigned long addr = get_zeroed_page(GFP_KERNEL);
 135         char *buf = (char *)addr;
 136         if (!buf)
 137                 return -ENOMEM;
 138
 139         buf_size = min(count, len - 1);
 140         if (copy_from_user(buf, user_buf, buf_size)) {
 141                 ret = -EFAULT;
 142                 goto out_unlock;
 143         }
 144         ret = sscanf(buf, "%d", &host_sleep);
 145         if (ret != 1) {
 146                 ret = -EINVAL;
 147                 goto out_unlock;
 148         }
 149
 150         if (host_sleep == 0)
 151                 ret = lbs_set_host_sleep(priv, 0);
 152         else if (host_sleep == 1) {
 153                 if (priv->wol_criteria == EHS_REMOVE_WAKEUP) {
 154                         lbs_pr_info("wake parameters not configured");
 155                         ret = -EINVAL;
 156                         goto out_unlock;
 157                 }
 158                 ret = lbs_set_host_sleep(priv, 1);
 159         } else {
 160                 lbs_pr_err("invalid option\n");
 161                 ret = -EINVAL;
 162         }
 163
 164         if (!ret)
 165                 ret = count;
 166
 167 out_unlock:
 168         free_page(addr);
 169         return ret;
 170 }
 171
 172 static ssize_t lbs_host_sleep_read(struct file *file, char __user *userbuf,
 173                                   size_t count, loff_t *ppos)
 174 {
 175         struct lbs_private *priv = file->private_data;
 176         ssize_t ret;
 177         size_t pos = 0;
 178         unsigned long addr = get_zeroed_page(GFP_KERNEL);
 179         char *buf = (char *)addr;
 180         if (!buf)
 181                 return -ENOMEM;
 182
 183         pos += snprintf(buf, len, "%d\n", priv->is_host_sleep_activated);
 184
 185         ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
 186
 187         free_page(addr);
 188         return ret;
 189 }
 190
 191 /*
 192  * When calling CMD_802_11_SUBSCRIBE_EVENT with CMD_ACT_GET, me might
 193  * get a bunch of vendor-specific TLVs (a.k.a. IEs) back from the
 194  * firmware. Here's an example:
 195  *      04 01 02 00 00 00 05 01 02 00 00 00 06 01 02 00
 196  *      00 00 07 01 02 00 3c 00 00 00 00 00 00 00 03 03
 197  *      00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 198  *
 199  * The 04 01 is the TLV type (here TLV_TYPE_RSSI_LOW), 02 00 is the length,
 200  * 00 00 are the data bytes of this TLV. For this TLV, their meaning is
 201  * defined in mrvlietypes_thresholds
 202  *
 203  * This function searches in this TLV data chunk for a given TLV type
 204  * and returns a pointer to the first data byte of the TLV, or to NULL
 205  * if the TLV hasn't been found.
 206  */
 207 static void *lbs_tlv_find(uint16_t tlv_type, const uint8_t *tlv, uint16_t size)
 208 {
 209         struct mrvl_ie_header *tlv_h;
 210         uint16_t length;
 211         ssize_t pos = 0;
 212
 213         while (pos < size) {
 214                 tlv_h = (struct mrvl_ie_header *) tlv;
 215                 if (!tlv_h->len)
 216                         return NULL;
 217                 if (tlv_h->type == cpu_to_le16(tlv_type))
 218                         return tlv_h;
 219                 length = le16_to_cpu(tlv_h->len) + sizeof(*tlv_h);
 220                 pos += length;
 221                 tlv += length;
 222         }
 223         return NULL;
 224 }
 225
 226
 227 static ssize_t lbs_threshold_read(uint16_t tlv_type, uint16_t event_mask,
 228                                   struct file *file, char __user *userbuf,
 229                                   size_t count, loff_t *ppos)
 230 {
 231         struct cmd_ds_802_11_subscribe_event *subscribed;
 232         struct mrvl_ie_thresholds *got;
 233         struct lbs_private *priv = file->private_data;
 234         ssize_t ret = 0;
 235         size_t pos = 0;
 236         char *buf;
 237         u8 value;
 238         u8 freq;
 239         int events = 0;
 240
 241         buf = (char *)get_zeroed_page(GFP_KERNEL);
 242         if (!buf)
 243                 return -ENOMEM;
 244
 245         subscribed = kzalloc(sizeof(*subscribed), GFP_KERNEL);
 246         if (!subscribed) {
 247                 ret = -ENOMEM;
 248                 goto out_page;
 249         }
 250
 251         subscribed->hdr.size = cpu_to_le16(sizeof(*subscribed));
 252         subscribed->action = cpu_to_le16(CMD_ACT_GET);
 253
 254         ret = lbs_cmd_with_response(priv, CMD_802_11_SUBSCRIBE_EVENT, subscribed);
 255         if (ret)
 256                 goto out_cmd;
 257
 258         got = lbs_tlv_find(tlv_type, subscribed->tlv, sizeof(subscribed->tlv));
 259         if (got) {
 260                 value = got->value;
 261                 freq  = got->freq;
 262                 events = le16_to_cpu(subscribed->events);
 263
 264                 pos += snprintf(buf, len, "%d %d %d\n", value, freq,
 265                                 !!(events & event_mask));
 266         }
 267
 268         ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
 269
 270  out_cmd:
 271         kfree(subscribed);
 272
 273  out_page:
 274         free_page((unsigned long)buf);
 275         return ret;
 276 }
 277
 278
 279 static ssize_t lbs_threshold_write(uint16_t tlv_type, uint16_t event_mask,
 280                                    struct file *file,
 281                                    const char __user *userbuf, size_t count,
 282                                    loff_t *ppos)
 283 {
 284         struct cmd_ds_802_11_subscribe_event *events;
 285         struct mrvl_ie_thresholds *tlv;
 286         struct lbs_private *priv = file->private_data;
 287         ssize_t buf_size;
 288         int value, freq, new_mask;
 289         uint16_t curr_mask;
 290         char *buf;
 291         int ret;
 292
 293         buf = (char *)get_zeroed_page(GFP_KERNEL);
 294         if (!buf)
 295                 return -ENOMEM;
 296
 297         buf_size = min(count, len - 1);
 298         if (copy_from_user(buf, userbuf, buf_size)) {
 299                 ret = -EFAULT;
 300                 goto out_page;
 301         }
 302         ret = sscanf(buf, "%d %d %d", &value, &freq, &new_mask);
 303         if (ret != 3) {
 304                 ret = -EINVAL;
 305                 goto out_page;
 306         }
 307         events = kzalloc(sizeof(*events), GFP_KERNEL);
 308         if (!events) {
 309                 ret = -ENOMEM;
 310                 goto out_page;
 311         }
 312
 313         events->hdr.size = cpu_to_le16(sizeof(*events));
 314         events->action = cpu_to_le16(CMD_ACT_GET);
 315
 316         ret = lbs_cmd_with_response(priv, CMD_802_11_SUBSCRIBE_EVENT, events);
 317         if (ret)
 318                 goto out_events;
 319
 320         curr_mask = le16_to_cpu(events->events);
 321
 322         if (new_mask)
 323                 new_mask = curr_mask | event_mask;
 324         else
 325                 new_mask = curr_mask & ~event_mask;
 326
 327         /* Now everything is set and we can send stuff down to the firmware */
 328
 329         tlv = (void *)events->tlv;
 330
 331         events->action = cpu_to_le16(CMD_ACT_SET);
 332         events->events = cpu_to_le16(new_mask);
 333         tlv->header.type = cpu_to_le16(tlv_type);
 334         tlv->header.len = cpu_to_le16(sizeof(*tlv) - sizeof(tlv->header));
 335         tlv->value = value;
 336         if (tlv_type != TLV_TYPE_BCNMISS)
 337                 tlv->freq = freq;
 338
 339         /* The command header, the action, the event mask, and one TLV */
 340         events->hdr.size = cpu_to_le16(sizeof(events->hdr) + 4 + sizeof(*tlv));
 341
 342         ret = lbs_cmd_with_response(priv, CMD_802_11_SUBSCRIBE_EVENT, events);
 343
 344         if (!ret)
 345                 ret = count;
 346  out_events:
 347         kfree(events);
 348  out_page:
 349         free_page((unsigned long)buf);
 350         return ret;
 351 }
 352
 353
 354 static ssize_t lbs_lowrssi_read(struct file *file, char __user *userbuf,
 355                                 size_t count, loff_t *ppos)
 356 {
 357         return lbs_threshold_read(TLV_TYPE_RSSI_LOW, CMD_SUBSCRIBE_RSSI_LOW,
 358                                   file, userbuf, count, ppos);
 359 }
 360
 361
 362 static ssize_t lbs_lowrssi_write(struct file *file, const char __user *userbuf,
 363                                  size_t count, loff_t *ppos)
 364 {
 365         return lbs_threshold_write(TLV_TYPE_RSSI_LOW, CMD_SUBSCRIBE_RSSI_LOW,
 366                                    file, userbuf, count, ppos);
 367 }
 368
 369
 370 static ssize_t lbs_lowsnr_read(struct file *file, char __user *userbuf,
 371                                size_t count, loff_t *ppos)
 372 {
 373         return lbs_threshold_read(TLV_TYPE_SNR_LOW, CMD_SUBSCRIBE_SNR_LOW,
 374                                   file, userbuf, count, ppos);
 375 }
 376
 377
 378 static ssize_t lbs_lowsnr_write(struct file *file, const char __user *userbuf,
 379                                 size_t count, loff_t *ppos)
 380 {
 381         return lbs_threshold_write(TLV_TYPE_SNR_LOW, CMD_SUBSCRIBE_SNR_LOW,
 382                                    file, userbuf, count, ppos);
 383 }
 384
 385
 386 static ssize_t lbs_failcount_read(struct file *file, char __user *userbuf,
 387                                   size_t count, loff_t *ppos)
 388 {
 389         return lbs_threshold_read(TLV_TYPE_FAILCOUNT, CMD_SUBSCRIBE_FAILCOUNT,
 390                                   file, userbuf, count, ppos);
 391 }
 392
 393
 394 static ssize_t lbs_failcount_write(struct file *file, const char __user *userbuf,
 395                                    size_t count, loff_t *ppos)
 396 {
 397         return lbs_threshold_write(TLV_TYPE_FAILCOUNT, CMD_SUBSCRIBE_FAILCOUNT,
 398                                    file, userbuf, count, ppos);
 399 }
 400
 401
 402 static ssize_t lbs_highrssi_read(struct file *file, char __user *userbuf,
 403                                  size_t count, loff_t *ppos)
 404 {
 405         return lbs_threshold_read(TLV_TYPE_RSSI_HIGH, CMD_SUBSCRIBE_RSSI_HIGH,
 406                                   file, userbuf, count, ppos);
 407 }
 408
 409
 410 static ssize_t lbs_highrssi_write(struct file *file, const char __user *userbuf,
 411                                   size_t count, loff_t *ppos)
 412 {
 413         return lbs_threshold_write(TLV_TYPE_RSSI_HIGH, CMD_SUBSCRIBE_RSSI_HIGH,
 414                                    file, userbuf, count, ppos);
 415 }
 416
 417
 418 static ssize_t lbs_highsnr_read(struct file *file, char __user *userbuf,
 419                                 size_t count, loff_t *ppos)
 420 {
 421         return lbs_threshold_read(TLV_TYPE_SNR_HIGH, CMD_SUBSCRIBE_SNR_HIGH,
 422                                   file, userbuf, count, ppos);
 423 }
 424
 425
 426 static ssize_t lbs_highsnr_write(struct file *file, const char __user *userbuf,
 427                                  size_t count, loff_t *ppos)
 428 {
 429         return lbs_threshold_write(TLV_TYPE_SNR_HIGH, CMD_SUBSCRIBE_SNR_HIGH,
 430                                    file, userbuf, count, ppos);
 431 }
 432
 433 static ssize_t lbs_bcnmiss_read(struct file *file, char __user *userbuf,
 434                                 size_t count, loff_t *ppos)
 435 {
 436         return lbs_threshold_read(TLV_TYPE_BCNMISS, CMD_SUBSCRIBE_BCNMISS,
 437                                   file, userbuf, count, ppos);
 438 }
 439
 440
 441 static ssize_t lbs_bcnmiss_write(struct file *file, const char __user *userbuf,
 442                                  size_t count, loff_t *ppos)
 443 {
 444         return lbs_threshold_write(TLV_TYPE_BCNMISS, CMD_SUBSCRIBE_BCNMISS,
 445                                    file, userbuf, count, ppos);
 446 }
 447
 448
 449
 450 static ssize_t lbs_rdmac_read(struct file *file, char __user *userbuf,
 451                                   size_t count, loff_t *ppos)
 452 {
 453         struct lbs_private *priv = file->private_data;
 454         struct lbs_offset_value offval;
 455         ssize_t pos = 0;
 456         int ret;
 457         unsigned long addr = get_zeroed_page(GFP_KERNEL);
 458         char *buf = (char *)addr;
 459         if (!buf)
 460                 return -ENOMEM;
 461
 462         offval.offset = priv->mac_offset;
 463         offval.value = 0;
 464
 465         ret = lbs_prepare_and_send_command(priv,
 466                                 CMD_MAC_REG_ACCESS, 0,
 467                                 CMD_OPTION_WAITFORRSP, 0, &offval);
 468         mdelay(10);
 469         if (!ret) {
 470                 pos += snprintf(buf+pos, len-pos, "MAC[0x%x] = 0x%08x\n",
 471                                 priv->mac_offset, priv->offsetvalue.value);
 472
 473                 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
 474         }
 475         free_page(addr);
 476         return ret;
 477 }
 478
 479 static ssize_t lbs_rdmac_write(struct file *file,
 480                                     const char __user *userbuf,
 481                                     size_t count, loff_t *ppos)
 482 {
 483         struct lbs_private *priv = file->private_data;
 484         ssize_t res, buf_size;
 485         unsigned long addr = get_zeroed_page(GFP_KERNEL);
 486         char *buf = (char *)addr;
 487         if (!buf)
 488                 return -ENOMEM;
 489
 490         buf_size = min(count, len - 1);
 491         if (copy_from_user(buf, userbuf, buf_size)) {
 492                 res = -EFAULT;
 493                 goto out_unlock;
 494         }
 495         priv->mac_offset = simple_strtoul((char *)buf, NULL, 16);
 496         res = count;
 497 out_unlock:
 498         free_page(addr);
 499         return res;
 500 }
 501
 502 static ssize_t lbs_wrmac_write(struct file *file,
 503                                     const char __user *userbuf,
 504                                     size_t count, loff_t *ppos)
 505 {
 506
 507         struct lbs_private *priv = file->private_data;
 508         ssize_t res, buf_size;
 509         u32 offset, value;
 510         struct lbs_offset_value offval;
 511         unsigned long addr = get_zeroed_page(GFP_KERNEL);
 512         char *buf = (char *)addr;
 513         if (!buf)
 514                 return -ENOMEM;
 515
 516         buf_size = min(count, len - 1);
 517         if (copy_from_user(buf, userbuf, buf_size)) {
 518                 res = -EFAULT;
 519                 goto out_unlock;
 520         }
 521         res = sscanf(buf, "%x %x", &offset, &value);
 522         if (res != 2) {
 523                 res = -EFAULT;
 524                 goto out_unlock;
 525         }
 526
 527         offval.offset = offset;
 528         offval.value = value;
 529         res = lbs_prepare_and_send_command(priv,
 530                                 CMD_MAC_REG_ACCESS, 1,
 531                                 CMD_OPTION_WAITFORRSP, 0, &offval);
 532         mdelay(10);
 533
 534         if (!res)
 535                 res = count;
 536 out_unlock:
 537         free_page(addr);
 538         return res;
 539 }
 540
 541 static ssize_t lbs_rdbbp_read(struct file *file, char __user *userbuf,
 542                                   size_t count, loff_t *ppos)
 543 {
 544         struct lbs_private *priv = file->private_data;
 545         struct lbs_offset_value offval;
 546         ssize_t pos = 0;
 547         int ret;
 548         unsigned long addr = get_zeroed_page(GFP_KERNEL);
 549         char *buf = (char *)addr;
 550         if (!buf)
 551                 return -ENOMEM;
 552
 553         offval.offset = priv->bbp_offset;
 554         offval.value = 0;
 555
 556         ret = lbs_prepare_and_send_command(priv,
 557                                 CMD_BBP_REG_ACCESS, 0,
 558                                 CMD_OPTION_WAITFORRSP, 0, &offval);
 559         mdelay(10);
 560         if (!ret) {
 561                 pos += snprintf(buf+pos, len-pos, "BBP[0x%x] = 0x%08x\n",
 562                                 priv->bbp_offset, priv->offsetvalue.value);
 563
 564                 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
 565         }
 566         free_page(addr);
 567
 568         return ret;
 569 }
 570
 571 static ssize_t lbs_rdbbp_write(struct file *file,
 572                                     const char __user *userbuf,
 573                                     size_t count, loff_t *ppos)
 574 {
 575         struct lbs_private *priv = file->private_data;
 576         ssize_t res, buf_size;
 577         unsigned long addr = get_zeroed_page(GFP_KERNEL);
 578         char *buf = (char *)addr;
 579         if (!buf)
 580                 return -ENOMEM;
 581
 582         buf_size = min(count, len - 1);
 583         if (copy_from_user(buf, userbuf, buf_size)) {
 584                 res = -EFAULT;
 585                 goto out_unlock;
 586         }
 587         priv->bbp_offset = simple_strtoul((char *)buf, NULL, 16);
 588         res = count;
 589 out_unlock:
 590         free_page(addr);
 591         return res;
 592 }
 593
 594 static ssize_t lbs_wrbbp_write(struct file *file,
 595                                     const char __user *userbuf,
 596                                     size_t count, loff_t *ppos)
 597 {
 598
 599         struct lbs_private *priv = file->private_data;
 600         ssize_t res, buf_size;
 601         u32 offset, value;
 602         struct lbs_offset_value offval;
 603         unsigned long addr = get_zeroed_page(GFP_KERNEL);
 604         char *buf = (char *)addr;
 605         if (!buf)
 606                 return -ENOMEM;
 607
 608         buf_size = min(count, len - 1);
 609         if (copy_from_user(buf, userbuf, buf_size)) {
 610                 res = -EFAULT;
 611                 goto out_unlock;
 612         }
 613         res = sscanf(buf, "%x %x", &offset, &value);
 614         if (res != 2) {
 615                 res = -EFAULT;
 616                 goto out_unlock;
 617         }
 618
 619         offval.offset = offset;
 620         offval.value = value;
 621         res = lbs_prepare_and_send_command(priv,
 622                                 CMD_BBP_REG_ACCESS, 1,
 623                                 CMD_OPTION_WAITFORRSP, 0, &offval);
 624         mdelay(10);
 625
 626         if (!res)
 627                 res = count;
 628 out_unlock:
 629         free_page(addr);
 630         return res;
 631 }
 632
 633 static ssize_t lbs_rdrf_read(struct file *file, char __user *userbuf,
 634                                   size_t count, loff_t *ppos)
 635 {
 636         struct lbs_private *priv = file->private_data;
 637         struct lbs_offset_value offval;
 638         ssize_t pos = 0;
 639         int ret;
 640         unsigned long addr = get_zeroed_page(GFP_KERNEL);
 641         char *buf = (char *)addr;
 642         if (!buf)
 643                 return -ENOMEM;
 644
 645         offval.offset = priv->rf_offset;
 646         offval.value = 0;
 647
 648         ret = lbs_prepare_and_send_command(priv,
 649                                 CMD_RF_REG_ACCESS, 0,
 650                                 CMD_OPTION_WAITFORRSP, 0, &offval);
 651         mdelay(10);
 652         if (!ret) {
 653                 pos += snprintf(buf+pos, len-pos, "RF[0x%x] = 0x%08x\n",
 654                                 priv->rf_offset, priv->offsetvalue.value);
 655
 656                 ret = simple_read_from_buffer(userbuf, count, ppos, buf, pos);
 657         }
 658         free_page(addr);
 659
 660         return ret;
 661 }
 662
 663 static ssize_t lbs_rdrf_write(struct file *file,
 664                                     const char __user *userbuf,
 665                                     size_t count, loff_t *ppos)
 666 {
 667         struct lbs_private *priv = file->private_data;
 668         ssize_t res, buf_size;
 669         unsigned long addr = get_zeroed_page(GFP_KERNEL);
 670         char *buf = (char *)addr;
 671         if (!buf)
 672                 return -ENOMEM;
 673
 674         buf_size = min(count, len - 1);
 675         if (copy_from_user(buf, userbuf, buf_size)) {
 676                 res = -EFAULT;
 677                 goto out_unlock;
 678         }
 679         priv->rf_offset = simple_strtoul(buf, NULL, 16);
 680         res = count;
 681 out_unlock:
 682         free_page(addr);
 683         return res;
 684 }
 685
 686 static ssize_t lbs_wrrf_write(struct file *file,
 687                                     const char __user *userbuf,
 688                                     size_t count, loff_t *ppos)
 689 {
 690
 691         struct lbs_private *priv = file->private_data;
 692         ssize_t res, buf_size;
 693         u32 offset, value;
 694         struct lbs_offset_value offval;
 695         unsigned long addr = get_zeroed_page(GFP_KERNEL);
 696         char *buf = (char *)addr;
 697         if (!buf)
 698                 return -ENOMEM;
 699
 700         buf_size = min(count, len - 1);
 701         if (copy_from_user(buf, userbuf, buf_size)) {
 702                 res = -EFAULT;
 703                 goto out_unlock;
 704         }
 705         res = sscanf(buf, "%x %x", &offset, &value);
 706         if (res != 2) {
 707                 res = -EFAULT;
 708                 goto out_unlock;
 709         }
 710
 711         offval.offset = offset;
 712         offval.value = value;
 713         res = lbs_prepare_and_send_command(priv,
 714                                 CMD_RF_REG_ACCESS, 1,
 715                                 CMD_OPTION_WAITFORRSP, 0, &offval);
 716         mdelay(10);
 717
 718         if (!res)
 719                 res = count;
 720 out_unlock:
 721         free_page(addr);
 722         return res;
 723 }
 724
 725 #define FOPS(fread, fwrite) { \
 726         .owner = THIS_MODULE, \
 727         .open = open_file_generic, \
 728         .read = (fread), \
 729         .write = (fwrite), \
 730 }
 731
 732 struct lbs_debugfs_files {
 733         const char *name;
 734         int perm;
 735         struct file_operations fops;
 736 };
 737
 738 static const struct lbs_debugfs_files debugfs_files[] = {
 739         { "info", 0444, FOPS(lbs_dev_info, write_file_dummy), },
 740         { "sleepparams", 0644, FOPS(lbs_sleepparams_read,
 741                                 lbs_sleepparams_write), },
 742         { "hostsleep", 0644, FOPS(lbs_host_sleep_read,
 743                                 lbs_host_sleep_write), },
 744 };
 745
 746 static const struct lbs_debugfs_files debugfs_events_files[] = {
 747         {"low_rssi", 0644, FOPS(lbs_lowrssi_read,
 748                                 lbs_lowrssi_write), },
 749         {"low_snr", 0644, FOPS(lbs_lowsnr_read,
 750                                 lbs_lowsnr_write), },
 751         {"failure_count", 0644, FOPS(lbs_failcount_read,
 752                                 lbs_failcount_write), },
 753         {"beacon_missed", 0644, FOPS(lbs_bcnmiss_read,
 754                                 lbs_bcnmiss_write), },
 755         {"high_rssi", 0644, FOPS(lbs_highrssi_read,
 756                                 lbs_highrssi_write), },
 757         {"high_snr", 0644, FOPS(lbs_highsnr_read,
 758                                 lbs_highsnr_write), },
 759 };
 760
 761 static const struct lbs_debugfs_files debugfs_regs_files[] = {
 762         {"rdmac", 0644, FOPS(lbs_rdmac_read, lbs_rdmac_write), },
 763         {"wrmac", 0600, FOPS(NULL, lbs_wrmac_write), },
 764         {"rdbbp", 0644, FOPS(lbs_rdbbp_read, lbs_rdbbp_write), },
 765         {"wrbbp", 0600, FOPS(NULL, lbs_wrbbp_write), },
 766         {"rdrf", 0644, FOPS(lbs_rdrf_read, lbs_rdrf_write), },
 767         {"wrrf", 0600, FOPS(NULL, lbs_wrrf_write), },
 768 };
 769
 770 void lbs_debugfs_init(void)
 771 {
 772         if (!lbs_dir)
 773                 lbs_dir = debugfs_create_dir("lbs_wireless", NULL);
 774 }
 775
 776 void lbs_debugfs_remove(void)
 777 {
 778         if (lbs_dir)
 779                  debugfs_remove(lbs_dir);
 780 }
 781
 782 void lbs_debugfs_init_one(struct lbs_private *priv, struct net_device *dev)
 783 {
 784         int i;
 785         const struct lbs_debugfs_files *files;
 786         if (!lbs_dir)
 787                 goto exit;
 788
 789         priv->debugfs_dir = debugfs_create_dir(dev->name, lbs_dir);
 790         if (!priv->debugfs_dir)
 791                 goto exit;
 792
 793         for (i=0; i<ARRAY_SIZE(debugfs_files); i++) {
 794                 files = &debugfs_files[i];
 795                 priv->debugfs_files[i] = debugfs_create_file(files->name,
 796                                                              files->perm,
 797                                                              priv->debugfs_dir,
 798                                                              priv,
 799                                                              &files->fops);
 800         }
 801
 802         priv->events_dir = debugfs_create_dir("subscribed_events", priv->debugfs_dir);
 803         if (!priv->events_dir)
 804                 goto exit;
 805
 806         for (i=0; i<ARRAY_SIZE(debugfs_events_files); i++) {
 807                 files = &debugfs_events_files[i];
 808                 priv->debugfs_events_files[i] = debugfs_create_file(files->name,
 809                                                              files->perm,
 810                                                              priv->events_dir,
 811                                                              priv,
 812                                                              &files->fops);
 813         }
 814
 815         priv->regs_dir = debugfs_create_dir("registers", priv->debugfs_dir);
 816         if (!priv->regs_dir)
 817                 goto exit;
 818
 819         for (i=0; i<ARRAY_SIZE(debugfs_regs_files); i++) {
 820                 files = &debugfs_regs_files[i];
 821                 priv->debugfs_regs_files[i] = debugfs_create_file(files->name,
 822                                                              files->perm,
 823                                                              priv->regs_dir,
 824                                                              priv,
 825                                                              &files->fops);
 826         }
 827
 828 #ifdef PROC_DEBUG
 829         lbs_debug_init(priv);
 830 #endif
 831 exit:
 832         return;
 833 }
 834
 835 void lbs_debugfs_remove_one(struct lbs_private *priv)
 836 {
 837         int i;
 838
 839         for(i=0; i<ARRAY_SIZE(debugfs_regs_files); i++)
 840                 debugfs_remove(priv->debugfs_regs_files[i]);
 841
 842         debugfs_remove(priv->regs_dir);
 843
 844         for(i=0; i<ARRAY_SIZE(debugfs_events_files); i++)
 845                 debugfs_remove(priv->debugfs_events_files[i]);
 846
 847         debugfs_remove(priv->events_dir);
 848 #ifdef PROC_DEBUG
 849         debugfs_remove(priv->debugfs_debug);
 850 #endif
 851         for(i=0; i<ARRAY_SIZE(debugfs_files); i++)
 852                 debugfs_remove(priv->debugfs_files[i]);
 853         debugfs_remove(priv->debugfs_dir);
 854 }
 855
 856
 857
 858 /* debug entry */
 859
 860 #ifdef PROC_DEBUG
 861
 862 #define item_size(n)    (FIELD_SIZEOF(struct lbs_private, n))
 863 #define item_addr(n)    (offsetof(struct lbs_private, n))
 864
 865
 866 struct debug_data {
 867         char name[32];
 868         u32 size;
 869         size_t addr;
 870 };
 871
 872 /* To debug any member of struct lbs_private, simply add one line here.
 873  */
 874 static struct debug_data items[] = {
 875         {"psmode", item_size(psmode), item_addr(psmode)},
 876         {"psstate", item_size(psstate), item_addr(psstate)},
 877 };
 878
 879 static int num_of_items = ARRAY_SIZE(items);
 880
 881 /**
 882  *  @brief proc read function
 883  *
 884  *  @param page    pointer to buffer
 885  *  @param s       read data starting position
 886  *  @param off     offset
 887  *  @param cnt     counter
 888  *  @param eof     end of file flag
 889  *  @param data    data to output
 890  *  @return        number of output data
 891  */
 892 static ssize_t lbs_debugfs_read(struct file *file, char __user *userbuf,
 893                         size_t count, loff_t *ppos)
 894 {
 895         int val = 0;
 896         size_t pos = 0;
 897         ssize_t res;
 898         char *p;
 899         int i;
 900         struct debug_data *d;
 901         unsigned long addr = get_zeroed_page(GFP_KERNEL);
 902         char *buf = (char *)addr;
 903         if (!buf)
 904                 return -ENOMEM;
 905
 906         p = buf;
 907
 908         d = file->private_data;
 909
 910         for (i = 0; i < num_of_items; i++) {
 911                 if (d[i].size == 1)
 912                         val = *((u8 *) d[i].addr);
 913                 else if (d[i].size == 2)
 914                         val = *((u16 *) d[i].addr);
 915                 else if (d[i].size == 4)
 916                         val = *((u32 *) d[i].addr);
 917                 else if (d[i].size == 8)
 918                         val = *((u64 *) d[i].addr);
 919
 920                 pos += sprintf(p + pos, "%s=%d\n", d[i].name, val);
 921         }
 922
 923         res = simple_read_from_buffer(userbuf, count, ppos, p, pos);
 924
 925         free_page(addr);
 926         return res;
 927 }
 928
 929 /**
 930  *  @brief proc write function
 931  *
 932  *  @param f       file pointer
 933  *  @param buf     pointer to data buffer
 934  *  @param cnt     data number to write
 935  *  @param data    data to write
 936  *  @return        number of data
 937  */
 938 static ssize_t lbs_debugfs_write(struct file *f, const char __user *buf,
 939                             size_t cnt, loff_t *ppos)
 940 {
 941         int r, i;
 942         char *pdata;
 943         char *p;
 944         char *p0;
 945         char *p1;
 946         char *p2;
 947         struct debug_data *d = f->private_data;
 948
 949         pdata = kmalloc(cnt, GFP_KERNEL);
 950         if (pdata == NULL)
 951                 return 0;
 952
 953         if (copy_from_user(pdata, buf, cnt)) {
 954                 lbs_deb_debugfs("Copy from user failed\n");
 955                 kfree(pdata);
 956                 return 0;
 957         }
 958
 959         p0 = pdata;
 960         for (i = 0; i < num_of_items; i++) {
 961                 do {
 962                         p = strstr(p0, d[i].name);
 963                         if (p == NULL)
 964                                 break;
 965                         p1 = strchr(p, '\n');
 966                         if (p1 == NULL)
 967                                 break;
 968                         p0 = p1++;
 969                         p2 = strchr(p, '=');
 970                         if (!p2)
 971                                 break;
 972                         p2++;
 973                         r = simple_strtoul(p2, NULL, 0);
 974                         if (d[i].size == 1)
 975                                 *((u8 *) d[i].addr) = (u8) r;
 976                         else if (d[i].size == 2)
 977                                 *((u16 *) d[i].addr) = (u16) r;
 978                         else if (d[i].size == 4)
 979                                 *((u32 *) d[i].addr) = (u32) r;
 980                         else if (d[i].size == 8)
 981                                 *((u64 *) d[i].addr) = (u64) r;
 982                         break;
 983                 } while (1);
 984         }
 985         kfree(pdata);
 986
 987         return (ssize_t)cnt;
 988 }
 989
 990 static const struct file_operations lbs_debug_fops = {
 991         .owner = THIS_MODULE,
 992         .open = open_file_generic,
 993         .write = lbs_debugfs_write,
 994         .read = lbs_debugfs_read,
 995 };
 996
 997 /**
 998  *  @brief create debug proc file
 999  *
1000  *  @param priv    pointer struct lbs_private
1001  *  @param dev     pointer net_device
1002  *  @return        N/A
1003  */
1004 static void lbs_debug_init(struct lbs_private *priv)
1005 {
1006         int i;
1007
1008         if (!priv->debugfs_dir)
1009                 return;
1010
1011         for (i = 0; i < num_of_items; i++)
1012                 items[i].addr += (size_t) priv;
1013
1014         priv->debugfs_debug = debugfs_create_file("debug", 0644,
1015                                                   priv->debugfs_dir, &items[0],
1016                                                   &lbs_debug_fops);
1017 }
1018 #endif