drivers/net/wireless/rockchip_wlan/esp8089/esp_driver/esp_debug.c

   1 /*
   2  * Copyright (c) 2011-2014 Espressif System.
   3  *
   4  * esp debug interface
   5  *  - debugfs
   6  *  - debug level control
   7  */
   8
   9 #include <linux/types.h>
  10 #include <linux/kernel.h>
  11
  12 #include <net/mac80211.h>
  13 #include "sip2_common.h"
  14
  15 #include "esp_debug.h"
  16
  17 #if defined(CONFIG_DEBUG_FS) && defined(DEBUG_FS)
  18
  19 static struct dentry *esp_debugfs_root = NULL;
  20
  21 static int esp_debugfs_open(struct inode *inode, struct file *filp)
  22 {
  23         filp->private_data = inode->i_private;
  24         return 0;
  25 }
  26
  27 static ssize_t esp_debugfs_read(struct file *filp, char __user *buffer,
  28                                 size_t count, loff_t *ppos)
  29 {
  30         if (*ppos >= 32)
  31                 return 0;
  32         if (*ppos + count > 32)
  33                 count = 32 - *ppos;
  34
  35         if (copy_to_user(buffer, filp->private_data + *ppos, count))
  36                 return -EFAULT;
  37
  38         *ppos += count;
  39
  40         return count;
  41 }
  42
  43 static ssize_t esp_debugfs_write(struct file *filp, const char __user *buffer,
  44                                  size_t count, loff_t *ppos)
  45 {
  46         if (*ppos >= 32)
  47                 return 0;
  48         if (*ppos + count > 32)
  49                 count = 32 - *ppos;
  50
  51         if (copy_from_user(filp->private_data + *ppos, buffer, count))
  52                 return -EFAULT;
  53
  54         *ppos += count;
  55
  56         return count;
  57 }
  58
  59 struct file_operations esp_debugfs_fops = {
  60         .owner = THIS_MODULE,
  61         .open = esp_debugfs_open,
  62         .read = esp_debugfs_read,
  63         .write = esp_debugfs_write,
  64 };
  65
  66
  67 struct dentry *esp_dump_var(const char *name, struct dentry *parent, void *value, esp_type type) {
  68         struct dentry *rc = NULL;
  69         umode_t mode = 0644;
  70
  71         if(!esp_debugfs_root)
  72                 return NULL;
  73
  74         if(!parent)
  75                 parent = esp_debugfs_root;
  76
  77         switch(type) {
  78         case ESP_U8:
  79                 rc = debugfs_create_u8(name, mode, parent, (u8*)value);
  80                 break;
  81         case ESP_U16:
  82                 rc = debugfs_create_u16(name, mode, parent, (u16*)value);
  83                 break;
  84         case ESP_U32:
  85                 rc = debugfs_create_u32(name, mode, parent, (u32*)value);
  86                 break;
  87         case ESP_U64:
  88                 rc = debugfs_create_u64(name, mode, parent, (u64*)value);
  89                 break;
  90         case ESP_BOOL:
  91                 rc = debugfs_create_bool(name, mode, parent, (u32*)value);
  92                 break;
  93         default: //32
  94                 rc = debugfs_create_u32(name, mode, parent, (u32*)value);
  95         }
  96
  97         if (!rc)
  98                 goto Fail;
  99         else
 100                 return rc;
 101 Fail:
 102         debugfs_remove_recursive(esp_debugfs_root);
 103         esp_debugfs_root = NULL;
 104         esp_dbg(ESP_DBG_ERROR, "%s failed, debugfs root removed; var name: %s\n", __FUNCTION__, name);
 105         return NULL;
 106 }
 107
 108 struct dentry *esp_dump_array(const char *name, struct dentry *parent, struct debugfs_blob_wrapper *blob) {
 109         struct dentry * rc = NULL;
 110         umode_t mode = 0644;
 111
 112         if(!esp_debugfs_root)
 113                 return NULL;
 114
 115         if(!parent)
 116                 parent = esp_debugfs_root;
 117
 118         rc = debugfs_create_blob(name, mode, parent, blob);
 119
 120         if (!rc)
 121                 goto Fail;
 122         else
 123                 return rc;
 124
 125 Fail:
 126         debugfs_remove_recursive(esp_debugfs_root);
 127         esp_debugfs_root = NULL;
 128         esp_dbg(ESP_DBG_ERROR, "%s failed, debugfs root removed; var name: %s\n", __FUNCTION__, name);
 129         return NULL;
 130 }
 131
 132 struct dentry *esp_dump(const char *name, struct dentry *parent, void *data, int size) {
 133         struct dentry *rc;
 134         umode_t mode = 0644;
 135
 136         if(!esp_debugfs_root)
 137                 return NULL;
 138
 139         if(!parent)
 140                 parent = esp_debugfs_root;
 141
 142         rc = debugfs_create_file(name, mode, parent, data, &esp_debugfs_fops);
 143
 144         if (!rc)
 145                 goto Fail;
 146         else
 147                 return rc;
 148
 149 Fail:
 150         debugfs_remove_recursive(esp_debugfs_root);
 151         esp_debugfs_root = NULL;
 152         esp_dbg(ESP_DBG_ERROR, "%s failed, debugfs root removed; var name: %s\n", __FUNCTION__, name);
 153         return NULL;
 154 }
 155
 156 struct dentry *esp_debugfs_add_sub_dir(const char *name) {
 157         struct dentry *sub_dir = NULL;
 158
 159         sub_dir = debugfs_create_dir(name, esp_debugfs_root);
 160
 161         if (!sub_dir)
 162                 goto Fail;
 163
 164         return sub_dir;
 165
 166 Fail:
 167         debugfs_remove_recursive(esp_debugfs_root);
 168         esp_debugfs_root = NULL;
 169         esp_dbg(ESP_DBG_ERROR, "%s failed, debugfs root removed; dir name: %s\n", __FUNCTION__, name);
 170         return NULL;
 171
 172 }
 173
 174 int esp_debugfs_init(void)
 175 {
 176         esp_dbg(ESP_DBG, "esp debugfs init\n");
 177         esp_debugfs_root = debugfs_create_dir("esp_debug", NULL);
 178
 179         if (!esp_debugfs_root || IS_ERR_OR_NULL(esp_debugfs_root)) {
 180                 return -ENOENT;
 181         }
 182
 183         return 0;
 184 }
 185
 186 void esp_debugfs_exit(void)
 187 {
 188         esp_dbg(ESP_DBG, "esp debugfs exit");
 189
 190         debugfs_remove_recursive(esp_debugfs_root);
 191
 192         return;
 193 }
 194
 195 #else
 196
 197 inline struct dentry *esp_dump_var(const char *name, struct dentry *parent, void *value, esp_type type) {
 198         return NULL;
 199 }
 200
 201 inline struct dentry *esp_dump_array(const char *name, struct dentry *parent, struct debugfs_blob_wrapper *blob) {
 202         return NULL;
 203 }
 204
 205 inline struct dentry *esp_dump(const char *name, struct dentry *parent, void *data, int size) {
 206         return NULL;
 207 }
 208
 209 struct dentry *esp_debugfs_add_sub_dir(const char *name) {
 210         return NULL;
 211 }
 212
 213 inline int esp_debugfs_init(void)
 214 {
 215         return -EPERM;
 216 }
 217
 218 inline void esp_debugfs_exit(void)
 219 {
 220
 221 }
 222
 223 #endif
 224
 225
 226 void show_buf(u8 *buf, u32 len)
 227 {
 228 //      print_hex_dump(KERN_DEBUG, "",  DUMP_PREFIX_OFFSET, 16, 1, buf, len, true);
 229 #if 1
 230         int i = 0, j;
 231
 232         printk(KERN_INFO "\n++++++++++++++++show rbuf+++++++++++++++\n");
 233         for (i = 0; i < (len / 16); i++) {
 234                 j = i * 16;
 235                 printk(KERN_INFO "0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x \n", buf[j], buf[j+1],buf[j+2],buf[j+3],buf[j+4],buf[j+5],buf[j+6],buf[j+7],buf[j+8],buf[j+9],buf[j+10],buf[j+11],buf[j+12],buf[j+13],buf[j+14],buf[j+15]);
 236         }
 237         printk(KERN_INFO "\n++++++++++++++++++++++++++++++++++++++++\n");
 238 #endif//0000
 239 }
 240
 241 #ifdef HOST_RC
 242 static u8 get_cnt(u32 cnt_store, int idx)
 243 {
 244         int shift = idx << 2;
 245
 246         return (u8)((cnt_store>>shift) & 0xf);
 247 }
 248
 249 void esp_show_rcstatus(struct sip_rc_status *rcstatus)
 250 {
 251         int i;
 252         char msg[82];
 253         char rcstr[16];
 254         u32 cnt_store = rcstatus->rc_cnt_store;
 255
 256         memset(msg, 0 ,sizeof(msg));
 257         memset(rcstr, 0 ,sizeof(rcstr));
 258
 259         printk(KERN_INFO "rcstatus map 0x%08x cntStore 0x%08x\n", rcstatus->rc_map, rcstatus->rc_cnt_store);
 260
 261         for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
 262                 if (rcstatus->rc_map & BIT(i)) {
 263                         sprintf(rcstr, "rcIdx %d, cnt %d ", i, get_cnt(cnt_store, i));
 264                         strcat(msg, rcstr);
 265                 }
 266         }
 267         printk(KERN_INFO "%s \n", msg);
 268 }
 269
 270 void esp_show_tx_rates(struct ieee80211_tx_rate* rates)
 271 {
 272         int i;
 273         char msg[128];
 274         char rcstr[32];
 275
 276         memset(msg, 0 ,sizeof(msg));
 277         memset(rcstr, 0 ,sizeof(rcstr));
 278
 279         for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
 280                 if (rates->idx != -1 ) {
 281                         sprintf(rcstr, "Idx %d, cnt %d, flag %02x ", rates->idx, rates->count, rates->flags);
 282                         strcat(msg, rcstr);
 283                 }
 284                 rates++;
 285         }
 286         strcat(msg, "\n");
 287         printk(KERN_INFO "%s \n", msg);
 288 }
 289 #endif /* HOST_RC */