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