drivers/isdn/capi/kcapi_proc.c

   1 /*
   2  * Kernel CAPI 2.0 Module - /proc/capi handling
   3  *
   4  * Copyright 1999 by Carsten Paeth <calle@calle.de>
   5  * Copyright 2002 by Kai Germaschewski <kai@germaschewski.name>
   6  *
   7  * This software may be used and distributed according to the terms
   8  * of the GNU General Public License, incorporated herein by reference.
   9  *
  10  */
  11
  12
  13 #include "kcapi.h"
  14 #include <linux/proc_fs.h>
  15 #include <linux/seq_file.h>
  16 #include <linux/init.h>
  17
  18 static char *
  19 cardstate2str(unsigned short cardstate)
  20 {
  21         switch (cardstate) {
  22         case CARD_DETECTED:     return "detected";
  23         case CARD_LOADING:      return "loading";
  24         case CARD_RUNNING:      return "running";
  25         default:                return "???";
  26         }
  27 }
  28
  29 // /proc/capi
  30 // ===========================================================================
  31
  32 // /proc/capi/controller:
  33 //      cnr driver cardstate name driverinfo
  34 // /proc/capi/contrstats:
  35 //      cnr nrecvctlpkt nrecvdatapkt nsentctlpkt nsentdatapkt
  36 // ---------------------------------------------------------------------------
  37
  38 static void *controller_start(struct seq_file *seq, loff_t *pos)
  39 {
  40         if (*pos < CAPI_MAXCONTR)
  41                 return &capi_cards[*pos];
  42
  43         return NULL;
  44 }
  45
  46 static void *controller_next(struct seq_file *seq, void *v, loff_t *pos)
  47 {
  48         ++*pos;
  49         if (*pos < CAPI_MAXCONTR)
  50                 return &capi_cards[*pos];
  51
  52         return NULL;
  53 }
  54
  55 static void controller_stop(struct seq_file *seq, void *v)
  56 {
  57 }
  58
  59 static int controller_show(struct seq_file *seq, void *v)
  60 {
  61         struct capi_ctr *ctr = *(struct capi_ctr **) v;
  62
  63         if (!ctr)
  64                 return 0;
  65
  66         seq_printf(seq, "%d %-10s %-8s %-16s %s\n",
  67                    ctr->cnr, ctr->driver_name,
  68                    cardstate2str(ctr->cardstate),
  69                    ctr->name,
  70                    ctr->procinfo ?  ctr->procinfo(ctr) : "");
  71
  72         return 0;
  73 }
  74
  75 static int contrstats_show(struct seq_file *seq, void *v)
  76 {
  77         struct capi_ctr *ctr = *(struct capi_ctr **) v;
  78
  79         if (!ctr)
  80                 return 0;
  81
  82         seq_printf(seq, "%d %lu %lu %lu %lu\n",
  83                    ctr->cnr,
  84                    ctr->nrecvctlpkt,
  85                    ctr->nrecvdatapkt,
  86                    ctr->nsentctlpkt,
  87                    ctr->nsentdatapkt);
  88
  89         return 0;
  90 }
  91
  92 static struct seq_operations seq_controller_ops = {
  93         .start  = controller_start,
  94         .next   = controller_next,
  95         .stop   = controller_stop,
  96         .show   = controller_show,
  97 };
  98
  99 static struct seq_operations seq_contrstats_ops = {
 100         .start  = controller_start,
 101         .next   = controller_next,
 102         .stop   = controller_stop,
 103         .show   = contrstats_show,
 104 };
 105
 106 static int seq_controller_open(struct inode *inode, struct file *file)
 107 {
 108         return seq_open(file, &seq_controller_ops);
 109 }
 110
 111 static int seq_contrstats_open(struct inode *inode, struct file *file)
 112 {
 113         return seq_open(file, &seq_contrstats_ops);
 114 }
 115
 116 static const struct file_operations proc_controller_ops = {
 117         .open           = seq_controller_open,
 118         .read           = seq_read,
 119         .llseek         = seq_lseek,
 120         .release        = seq_release,
 121 };
 122
 123 static const struct file_operations proc_contrstats_ops = {
 124         .open           = seq_contrstats_open,
 125         .read           = seq_read,
 126         .llseek         = seq_lseek,
 127         .release        = seq_release,
 128 };
 129
 130 // /proc/capi/applications:
 131 //      applid l3cnt dblkcnt dblklen #ncci recvqueuelen
 132 // /proc/capi/applstats:
 133 //      applid nrecvctlpkt nrecvdatapkt nsentctlpkt nsentdatapkt
 134 // ---------------------------------------------------------------------------
 135
 136 static void *
 137 applications_start(struct seq_file *seq, loff_t *pos)
 138 {
 139         if (*pos < CAPI_MAXAPPL)
 140                 return &capi_applications[*pos];
 141
 142         return NULL;
 143 }
 144
 145 static void *
 146 applications_next(struct seq_file *seq, void *v, loff_t *pos)
 147 {
 148         ++*pos;
 149         if (*pos < CAPI_MAXAPPL)
 150                 return &capi_applications[*pos];
 151
 152         return NULL;
 153 }
 154
 155 static void
 156 applications_stop(struct seq_file *seq, void *v)
 157 {
 158 }
 159
 160 static int
 161 applications_show(struct seq_file *seq, void *v)
 162 {
 163         struct capi20_appl *ap = *(struct capi20_appl **) v;
 164
 165         if (!ap)
 166                 return 0;
 167
 168         seq_printf(seq, "%u %d %d %d\n",
 169                    ap->applid,
 170                    ap->rparam.level3cnt,
 171                    ap->rparam.datablkcnt,
 172                    ap->rparam.datablklen);
 173
 174         return 0;
 175 }
 176
 177 static int
 178 applstats_show(struct seq_file *seq, void *v)
 179 {
 180         struct capi20_appl *ap = *(struct capi20_appl **) v;
 181
 182         if (!ap)
 183                 return 0;
 184
 185         seq_printf(seq, "%u %lu %lu %lu %lu\n",
 186                    ap->applid,
 187                    ap->nrecvctlpkt,
 188                    ap->nrecvdatapkt,
 189                    ap->nsentctlpkt,
 190                    ap->nsentdatapkt);
 191
 192         return 0;
 193 }
 194
 195 static struct seq_operations seq_applications_ops = {
 196         .start  = applications_start,
 197         .next   = applications_next,
 198         .stop   = applications_stop,
 199         .show   = applications_show,
 200 };
 201
 202 static struct seq_operations seq_applstats_ops = {
 203         .start  = applications_start,
 204         .next   = applications_next,
 205         .stop   = applications_stop,
 206         .show   = applstats_show,
 207 };
 208
 209 static int
 210 seq_applications_open(struct inode *inode, struct file *file)
 211 {
 212         return seq_open(file, &seq_applications_ops);
 213 }
 214
 215 static int
 216 seq_applstats_open(struct inode *inode, struct file *file)
 217 {
 218         return seq_open(file, &seq_applstats_ops);
 219 }
 220
 221 static const struct file_operations proc_applications_ops = {
 222         .open           = seq_applications_open,
 223         .read           = seq_read,
 224         .llseek         = seq_lseek,
 225         .release        = seq_release,
 226 };
 227
 228 static const struct file_operations proc_applstats_ops = {
 229         .open           = seq_applstats_open,
 230         .read           = seq_read,
 231         .llseek         = seq_lseek,
 232         .release        = seq_release,
 233 };
 234
 235 static void
 236 create_seq_entry(char *name, mode_t mode, const struct file_operations *f)
 237 {
 238         struct proc_dir_entry *entry;
 239         entry = create_proc_entry(name, mode, NULL);
 240         if (entry)
 241                 entry->proc_fops = f;
 242 }
 243
 244 // ---------------------------------------------------------------------------
 245
 246 static void *capi_driver_start(struct seq_file *seq, loff_t *pos)
 247 {
 248         read_lock(&capi_drivers_list_lock);
 249         return seq_list_start(&capi_drivers, *pos);
 250 }
 251
 252 static void *capi_driver_next(struct seq_file *seq, void *v, loff_t *pos)
 253 {
 254         return seq_list_next(v, &capi_drivers, pos);
 255 }
 256
 257 static void capi_driver_stop(struct seq_file *seq, void *v)
 258 {
 259         read_unlock(&capi_drivers_list_lock);
 260 }
 261
 262 static int capi_driver_show(struct seq_file *seq, void *v)
 263 {
 264         struct capi_driver *drv = list_entry(v, struct capi_driver, list);
 265
 266         seq_printf(seq, "%-32s %s\n", drv->name, drv->revision);
 267         return 0;
 268 }
 269
 270 static struct seq_operations seq_capi_driver_ops = {
 271         .start  = capi_driver_start,
 272         .next   = capi_driver_next,
 273         .stop   = capi_driver_stop,
 274         .show   = capi_driver_show,
 275 };
 276
 277 static int
 278 seq_capi_driver_open(struct inode *inode, struct file *file)
 279 {
 280         int err;
 281         err = seq_open(file, &seq_capi_driver_ops);
 282         return err;
 283 }
 284
 285 static const struct file_operations proc_driver_ops = {
 286         .open           = seq_capi_driver_open,
 287         .read           = seq_read,
 288         .llseek         = seq_lseek,
 289         .release        = seq_release,
 290 };
 291
 292 // ---------------------------------------------------------------------------
 293
 294 void __init
 295 kcapi_proc_init(void)
 296 {
 297         proc_mkdir("capi",             NULL);
 298         proc_mkdir("capi/controllers", NULL);
 299         create_seq_entry("capi/controller",   0, &proc_controller_ops);
 300         create_seq_entry("capi/contrstats",   0, &proc_contrstats_ops);
 301         create_seq_entry("capi/applications", 0, &proc_applications_ops);
 302         create_seq_entry("capi/applstats",    0, &proc_applstats_ops);
 303         create_seq_entry("capi/driver",       0, &proc_driver_ops);
 304 }
 305
 306 void __exit
 307 kcapi_proc_exit(void)
 308 {
 309         remove_proc_entry("capi/driver",       NULL);
 310         remove_proc_entry("capi/controller",   NULL);
 311         remove_proc_entry("capi/contrstats",   NULL);
 312         remove_proc_entry("capi/applications", NULL);
 313         remove_proc_entry("capi/applstats",    NULL);
 314         remove_proc_entry("capi/controllers",  NULL);
 315         remove_proc_entry("capi",              NULL);
 316 }