arch/arm/mach-msm/smd_debug.c

   1 /* arch/arm/mach-msm/smd_debug.c
   2  *
   3  * Copyright (C) 2007 Google, Inc.
   4  * Author: Brian Swetland <swetland@google.com>
   5  *
   6  * This software is licensed under the terms of the GNU General Public
   7  * License version 2, as published by the Free Software Foundation, and
   8  * may be copied, distributed, and modified under those terms.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  */
  16
  17 #include <linux/debugfs.h>
  18 #include <linux/list.h>
  19
  20 #include <mach/msm_iomap.h>
  21
  22 #include "smd_private.h"
  23
  24 #if defined(CONFIG_DEBUG_FS)
  25
  26 static char *chstate(unsigned n)
  27 {
  28         switch (n) {
  29         case SMD_SS_CLOSED:
  30                 return "CLOSED";
  31         case SMD_SS_OPENING:
  32                 return "OPENING";
  33         case SMD_SS_OPENED:
  34                 return "OPENED";
  35         case SMD_SS_FLUSHING:
  36                 return "FLUSHING";
  37         case SMD_SS_CLOSING:
  38                 return "CLOSING";
  39         case SMD_SS_RESET:
  40                 return "RESET";
  41         case SMD_SS_RESET_OPENING:
  42                 return "ROPENING";
  43         default:
  44                 return "UNKNOWN";
  45         }
  46 }
  47
  48
  49 static int dump_ch(char *buf, int max, struct smd_channel *ch)
  50 {
  51         volatile struct smd_half_channel *s = ch->send;
  52         volatile struct smd_half_channel *r = ch->recv;
  53
  54         return scnprintf(
  55                 buf, max,
  56                 "ch%02d:"
  57                 " %8s(%05d/%05d) %c%c%c%c%c%c%c <->"
  58                 " %8s(%05d/%05d) %c%c%c%c%c%c%c '%s'\n", ch->n,
  59                 chstate(s->state), s->tail, s->head,
  60                 s->fDSR ? 'D' : 'd',
  61                 s->fCTS ? 'C' : 'c',
  62                 s->fCD ? 'C' : 'c',
  63                 s->fRI ? 'I' : 'i',
  64                 s->fHEAD ? 'W' : 'w',
  65                 s->fTAIL ? 'R' : 'r',
  66                 s->fSTATE ? 'S' : 's',
  67                 chstate(r->state), r->tail, r->head,
  68                 r->fDSR ? 'D' : 'd',
  69                 r->fCTS ? 'R' : 'r',
  70                 r->fCD ? 'C' : 'c',
  71                 r->fRI ? 'I' : 'i',
  72                 r->fHEAD ? 'W' : 'w',
  73                 r->fTAIL ? 'R' : 'r',
  74                 r->fSTATE ? 'S' : 's',
  75                 ch->name
  76                 );
  77 }
  78
  79 static int debug_read_stat(char *buf, int max)
  80 {
  81         char *msg;
  82         int i = 0;
  83
  84         msg = smem_find(ID_DIAG_ERR_MSG, SZ_DIAG_ERR_MSG);
  85
  86         if (raw_smsm_get_state(SMSM_STATE_MODEM) & SMSM_RESET)
  87                 i += scnprintf(buf + i, max - i,
  88                                "smsm: ARM9 HAS CRASHED\n");
  89
  90         i += scnprintf(buf + i, max - i, "smsm: a9: %08x a11: %08x\n",
  91                        raw_smsm_get_state(SMSM_STATE_MODEM),
  92                        raw_smsm_get_state(SMSM_STATE_APPS));
  93 #ifdef CONFIG_ARCH_MSM_SCORPION
  94         i += scnprintf(buf + i, max - i, "smsm dem: apps: %08x modem: %08x "
  95                        "qdsp6: %08x power: %08x time: %08x\n",
  96                        raw_smsm_get_state(SMSM_STATE_APPS_DEM),
  97                        raw_smsm_get_state(SMSM_STATE_MODEM_DEM),
  98                        raw_smsm_get_state(SMSM_STATE_QDSP6_DEM),
  99                        raw_smsm_get_state(SMSM_STATE_POWER_MASTER_DEM),
 100                        raw_smsm_get_state(SMSM_STATE_TIME_MASTER_DEM));
 101 #endif
 102         if (msg) {
 103                 msg[SZ_DIAG_ERR_MSG - 1] = 0;
 104                 i += scnprintf(buf + i, max - i, "diag: '%s'\n", msg);
 105         }
 106         return i;
 107 }
 108
 109 static int debug_read_mem(char *buf, int max)
 110 {
 111         unsigned n;
 112         struct smem_shared *shared = (void *) MSM_SHARED_RAM_BASE;
 113         struct smem_heap_entry *toc = shared->heap_toc;
 114         int i = 0;
 115
 116         i += scnprintf(buf + i, max - i,
 117                        "heap: init=%d free=%d remain=%d\n",
 118                        shared->heap_info.initialized,
 119                        shared->heap_info.free_offset,
 120                        shared->heap_info.heap_remaining);
 121
 122         for (n = 0; n < SMEM_NUM_ITEMS; n++) {
 123                 if (toc[n].allocated == 0)
 124                         continue;
 125                 i += scnprintf(buf + i, max - i,
 126                                "%04d: offset %08x size %08x\n",
 127                                n, toc[n].offset, toc[n].size);
 128         }
 129         return i;
 130 }
 131
 132 static int debug_read_ch(char *buf, int max)
 133 {
 134         struct smd_channel *ch;
 135         unsigned long flags;
 136         int i = 0;
 137
 138         spin_lock_irqsave(&smd_lock, flags);
 139         list_for_each_entry(ch, &smd_ch_list_dsp, ch_list)
 140                 i += dump_ch(buf + i, max - i, ch);
 141         list_for_each_entry(ch, &smd_ch_list_modem, ch_list)
 142                 i += dump_ch(buf + i, max - i, ch);
 143         list_for_each_entry(ch, &smd_ch_closed_list, ch_list)
 144                 i += dump_ch(buf + i, max - i, ch);
 145         spin_unlock_irqrestore(&smd_lock, flags);
 146
 147         return i;
 148 }
 149
 150 static int debug_read_version(char *buf, int max)
 151 {
 152         struct smem_shared *shared = (void *) MSM_SHARED_RAM_BASE;
 153         unsigned version = shared->version[VERSION_MODEM];
 154         return sprintf(buf, "%d.%d\n", version >> 16, version & 0xffff);
 155 }
 156
 157 static int debug_read_build_id(char *buf, int max)
 158 {
 159         unsigned size;
 160         void *data;
 161
 162         data = smem_item(SMEM_HW_SW_BUILD_ID, &size);
 163         if (!data)
 164                 return 0;
 165
 166         if (size >= max)
 167                 size = max;
 168         memcpy(buf, data, size);
 169
 170         return size;
 171 }
 172
 173 static int debug_read_alloc_tbl(char *buf, int max)
 174 {
 175         struct smd_alloc_elm *shared;
 176         int n, i = 0;
 177
 178         shared = smem_find(ID_CH_ALLOC_TBL, sizeof(*shared) * 64);
 179
 180         for (n = 0; n < 64; n++) {
 181                 if (shared[n].ref_count == 0)
 182                         continue;
 183                 i += scnprintf(buf + i, max - i,
 184                                "%03d: %-20s cid=%02d type=%03d "
 185                                "kind=%02d ref_count=%d\n",
 186                                n, shared[n].name, shared[n].cid,
 187                                shared[n].ctype & 0xff,
 188                                (shared[n].ctype >> 8) & 0xf,
 189                                shared[n].ref_count);
 190         }
 191
 192         return i;
 193 }
 194
 195 #define DEBUG_BUFMAX 4096
 196 static char debug_buffer[DEBUG_BUFMAX];
 197
 198 static ssize_t debug_read(struct file *file, char __user *buf,
 199                           size_t count, loff_t *ppos)
 200 {
 201         int (*fill)(char *buf, int max) = file->private_data;
 202         int bsize = fill(debug_buffer, DEBUG_BUFMAX);
 203         return simple_read_from_buffer(buf, count, ppos, debug_buffer, bsize);
 204 }
 205
 206 static int debug_open(struct inode *inode, struct file *file)
 207 {
 208         file->private_data = inode->i_private;
 209         return 0;
 210 }
 211
 212 static const struct file_operations debug_ops = {
 213         .read = debug_read,
 214         .open = debug_open,
 215         .llseek = default_llseek,
 216 };
 217
 218 static void debug_create(const char *name, mode_t mode,
 219                          struct dentry *dent,
 220                          int (*fill)(char *buf, int max))
 221 {
 222         debugfs_create_file(name, mode, dent, fill, &debug_ops);
 223 }
 224
 225 static int smd_debugfs_init(void)
 226 {
 227         struct dentry *dent;
 228
 229         dent = debugfs_create_dir("smd", 0);
 230         if (IS_ERR(dent))
 231                 return 1;
 232
 233         debug_create("ch", 0444, dent, debug_read_ch);
 234         debug_create("stat", 0444, dent, debug_read_stat);
 235         debug_create("mem", 0444, dent, debug_read_mem);
 236         debug_create("version", 0444, dent, debug_read_version);
 237         debug_create("tbl", 0444, dent, debug_read_alloc_tbl);
 238         debug_create("build", 0444, dent, debug_read_build_id);
 239
 240         return 0;
 241 }
 242
 243 late_initcall(smd_debugfs_init);
 244 #endif
 245
 246
 247 #define MAX_NUM_SLEEP_CLIENTS           64
 248 #define MAX_SLEEP_NAME_LEN              8
 249
 250 #define NUM_GPIO_INT_REGISTERS          6
 251 #define GPIO_SMEM_NUM_GROUPS            2
 252 #define GPIO_SMEM_MAX_PC_INTERRUPTS     8
 253
 254 struct tramp_gpio_save {
 255         unsigned int enable;
 256         unsigned int detect;
 257         unsigned int polarity;
 258 };
 259
 260 struct tramp_gpio_smem {
 261         uint16_t num_fired[GPIO_SMEM_NUM_GROUPS];
 262         uint16_t fired[GPIO_SMEM_NUM_GROUPS][GPIO_SMEM_MAX_PC_INTERRUPTS];
 263         uint32_t enabled[NUM_GPIO_INT_REGISTERS];
 264         uint32_t detection[NUM_GPIO_INT_REGISTERS];
 265         uint32_t polarity[NUM_GPIO_INT_REGISTERS];
 266 };
 267
 268
 269 void smsm_print_sleep_info(void)
 270 {
 271         unsigned long flags;
 272         uint32_t *ptr;
 273         struct tramp_gpio_smem *gpio;
 274         struct smsm_interrupt_info *int_info;
 275
 276
 277         spin_lock_irqsave(&smem_lock, flags);
 278
 279         ptr = smem_alloc(SMEM_SMSM_SLEEP_DELAY, sizeof(*ptr));
 280         if (ptr)
 281                 pr_info("SMEM_SMSM_SLEEP_DELAY: %x\n", *ptr);
 282
 283         ptr = smem_alloc(SMEM_SMSM_LIMIT_SLEEP, sizeof(*ptr));
 284         if (ptr)
 285                 pr_info("SMEM_SMSM_LIMIT_SLEEP: %x\n", *ptr);
 286
 287         ptr = smem_alloc(SMEM_SLEEP_POWER_COLLAPSE_DISABLED, sizeof(*ptr));
 288         if (ptr)
 289                 pr_info("SMEM_SLEEP_POWER_COLLAPSE_DISABLED: %x\n", *ptr);
 290
 291 #ifndef CONFIG_ARCH_MSM_SCORPION
 292         int_info = smem_alloc(SMEM_SMSM_INT_INFO, sizeof(*int_info));
 293         if (int_info)
 294                 pr_info("SMEM_SMSM_INT_INFO %x %x %x\n",
 295                         int_info->interrupt_mask,
 296                         int_info->pending_interrupts,
 297                         int_info->wakeup_reason);
 298
 299         gpio = smem_alloc(SMEM_GPIO_INT, sizeof(*gpio));
 300         if (gpio) {
 301                 int i;
 302                 for (i = 0; i < NUM_GPIO_INT_REGISTERS; i++)
 303                         pr_info("SMEM_GPIO_INT: %d: e %x d %x p %x\n",
 304                                 i, gpio->enabled[i], gpio->detection[i],
 305                                 gpio->polarity[i]);
 306
 307                 for (i = 0; i < GPIO_SMEM_NUM_GROUPS; i++)
 308                         pr_info("SMEM_GPIO_INT: %d: f %d: %d %d...\n",
 309                                 i, gpio->num_fired[i], gpio->fired[i][0],
 310                                 gpio->fired[i][1]);
 311         }
 312 #else
 313 #endif
 314         spin_unlock_irqrestore(&smem_lock, flags);
 315 }
 316