Logo Search packages:      
Sourcecode: linux version File versions  Download package

divasproc.c

/* $Id: divasproc.c,v 1.19.4.3 2005/01/31 12:22:20 armin Exp $
 *
 * Low level driver for Eicon DIVA Server ISDN cards.
 * /proc functions
 *
 * Copyright 2000-2003 by Armin Schindler (mac@melware.de)
 * Copyright 2000-2003 Cytronics & Melware (info@melware.de)
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/poll.h>
#include <linux/proc_fs.h>
#include <linux/list.h>
#include <asm/uaccess.h>

#include "platform.h"
#include "debuglib.h"
#undef ID_MASK
#undef N_DATA
#include "pc.h"
#include "di_defs.h"
#include "divasync.h"
#include "di.h"
#include "io.h"
#include "xdi_msg.h"
#include "xdi_adapter.h"
#include "diva.h"
#include "diva_pci.h"


extern PISDN_ADAPTER IoAdapters[MAX_ADAPTER];
extern void divas_get_version(char *);
extern void diva_get_vserial_number(PISDN_ADAPTER IoAdapter, char *buf);

/*********************************************************
 ** Functions for /proc interface / File operations
 *********************************************************/

static char *divas_proc_name = "divas";
static char *adapter_dir_name = "adapter";
static char *info_proc_name = "info";
static char *grp_opt_proc_name = "group_optimization";
static char *d_l1_down_proc_name = "dynamic_l1_down";

/*
** "divas" entry
*/

extern struct proc_dir_entry *proc_net_eicon;
static struct proc_dir_entry *divas_proc_entry = NULL;

static ssize_t
divas_read(struct file *file, char __user *buf, size_t count, loff_t * off)
{
      int len = 0;
      int cadapter;
      char tmpbuf[80];
      char tmpser[16];

      if (*off)
            return 0;

      divas_get_version(tmpbuf);
      if (copy_to_user(buf + len, &tmpbuf, strlen(tmpbuf)))
            return -EFAULT;
      len += strlen(tmpbuf);

      for (cadapter = 0; cadapter < MAX_ADAPTER; cadapter++) {
            if (IoAdapters[cadapter]) {
                  diva_get_vserial_number(IoAdapters[cadapter],
                                    tmpser);
                  sprintf(tmpbuf,
                        "%2d: %-30s Serial:%-10s IRQ:%2d\n",
                        cadapter + 1,
                        IoAdapters[cadapter]->Properties.Name,
                        tmpser,
                        IoAdapters[cadapter]->irq_info.irq_nr);
                  if ((strlen(tmpbuf) + len) > count)
                        break;
                  if (copy_to_user
                      (buf + len, &tmpbuf,
                       strlen(tmpbuf))) return -EFAULT;
                  len += strlen(tmpbuf);
            }
      }

      *off += len;
      return (len);
}

static ssize_t
divas_write(struct file *file, const char __user *buf, size_t count, loff_t * off)
{
      return (-ENODEV);
}

static unsigned int divas_poll(struct file *file, poll_table * wait)
{
      return (POLLERR);
}

static int divas_open(struct inode *inode, struct file *file)
{
      return nonseekable_open(inode, file);
}

static int divas_close(struct inode *inode, struct file *file)
{
      return (0);
}

static const struct file_operations divas_fops = {
      .owner   = THIS_MODULE,
      .llseek  = no_llseek,
      .read    = divas_read,
      .write   = divas_write,
      .poll    = divas_poll,
      .open    = divas_open,
      .release = divas_close
};

int create_divas_proc(void)
{
      divas_proc_entry = create_proc_entry(divas_proc_name,
                                   S_IFREG | S_IRUGO,
                                   proc_net_eicon);
      if (!divas_proc_entry)
            return (0);

      divas_proc_entry->proc_fops = &divas_fops;
      divas_proc_entry->owner = THIS_MODULE;

      return (1);
}

void remove_divas_proc(void)
{
      if (divas_proc_entry) {
            remove_proc_entry(divas_proc_name, proc_net_eicon);
            divas_proc_entry = NULL;
      }
}

/*
** write group_optimization 
*/
static int
write_grp_opt(struct file *file, const char __user *buffer, unsigned long count,
            void *data)
{
      diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) data;
      PISDN_ADAPTER IoAdapter = IoAdapters[a->controller - 1];

      if ((count == 1) || (count == 2)) {
            char c;
            if (get_user(c, buffer))
                  return -EFAULT;
            switch (c) {
            case '0':
                  IoAdapter->capi_cfg.cfg_1 &=
                      ~DIVA_XDI_CAPI_CFG_1_GROUP_POPTIMIZATION_ON;
                  break;
            case '1':
                  IoAdapter->capi_cfg.cfg_1 |=
                      DIVA_XDI_CAPI_CFG_1_GROUP_POPTIMIZATION_ON;
                  break;
            default:
                  return (-EINVAL);
            }
            return (count);
      }
      return (-EINVAL);
}

/*
** write dynamic_l1_down
*/
static int
write_d_l1_down(struct file *file, const char __user *buffer, unsigned long count,
            void *data)
{
      diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) data;
      PISDN_ADAPTER IoAdapter = IoAdapters[a->controller - 1];

      if ((count == 1) || (count == 2)) {
            char c;
            if (get_user(c, buffer))
                  return -EFAULT;
            switch (c) {
            case '0':
                  IoAdapter->capi_cfg.cfg_1 &=
                      ~DIVA_XDI_CAPI_CFG_1_DYNAMIC_L1_ON;
                  break;
            case '1':
                  IoAdapter->capi_cfg.cfg_1 |=
                      DIVA_XDI_CAPI_CFG_1_DYNAMIC_L1_ON;
                  break;
            default:
                  return (-EINVAL);
            }
            return (count);
      }
      return (-EINVAL);
}


/*
** read dynamic_l1_down 
*/
static int
read_d_l1_down(char *page, char **start, off_t off, int count, int *eof,
             void *data)
{
      int len = 0;
      diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) data;
      PISDN_ADAPTER IoAdapter = IoAdapters[a->controller - 1];

      len += sprintf(page + len, "%s\n",
                   (IoAdapter->capi_cfg.
                  cfg_1 & DIVA_XDI_CAPI_CFG_1_DYNAMIC_L1_ON) ? "1" :
                   "0");

      if (off + count >= len)
            *eof = 1;
      if (len < off)
            return 0;
      *start = page + off;
      return ((count < len - off) ? count : len - off);
}

/*
** read group_optimization
*/
static int
read_grp_opt(char *page, char **start, off_t off, int count, int *eof,
           void *data)
{
      int len = 0;
      diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) data;
      PISDN_ADAPTER IoAdapter = IoAdapters[a->controller - 1];

      len += sprintf(page + len, "%s\n",
                   (IoAdapter->capi_cfg.
                  cfg_1 & DIVA_XDI_CAPI_CFG_1_GROUP_POPTIMIZATION_ON)
                   ? "1" : "0");

      if (off + count >= len)
            *eof = 1;
      if (len < off)
            return 0;
      *start = page + off;
      return ((count < len - off) ? count : len - off);
}

/*
** info write
*/
static int
info_write(struct file *file, const char __user *buffer, unsigned long count,
         void *data)
{
      diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) data;
      PISDN_ADAPTER IoAdapter = IoAdapters[a->controller - 1];
      char c[4];

      if (count <= 4)
            return -EINVAL;

      if (copy_from_user(c, buffer, 4))
            return -EFAULT;

      /* this is for test purposes only */
      if (!memcmp(c, "trap", 4)) {
            (*(IoAdapter->os_trap_nfy_Fnc)) (IoAdapter, IoAdapter->ANum);
            return (count);
      }
      return (-EINVAL);
}

/*
** info read
*/
static int
info_read(char *page, char **start, off_t off, int count, int *eof,
        void *data)
{
      int i = 0;
      int len = 0;
      char *p;
      char tmpser[16];
      diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) data;
      PISDN_ADAPTER IoAdapter = IoAdapters[a->controller - 1];

      len +=
          sprintf(page + len, "Name        : %s\n",
                IoAdapter->Properties.Name);
      len += sprintf(page + len, "DSP state   : %08x\n", a->dsp_mask);
      len += sprintf(page + len, "Channels    : %02d\n",
                   IoAdapter->Properties.Channels);
      len += sprintf(page + len, "E. max/used : %03d/%03d\n",
                   IoAdapter->e_max, IoAdapter->e_count);
      diva_get_vserial_number(IoAdapter, tmpser);
      len += sprintf(page + len, "Serial      : %s\n", tmpser);
      len +=
          sprintf(page + len, "IRQ         : %d\n",
                IoAdapter->irq_info.irq_nr);
      len += sprintf(page + len, "CardIndex   : %d\n", a->CardIndex);
      len += sprintf(page + len, "CardOrdinal : %d\n", a->CardOrdinal);
      len += sprintf(page + len, "Controller  : %d\n", a->controller);
      len += sprintf(page + len, "Bus-Type    : %s\n",
                   (a->Bus ==
                  DIVAS_XDI_ADAPTER_BUS_ISA) ? "ISA" : "PCI");
      len += sprintf(page + len, "Port-Name   : %s\n", a->port_name);
      if (a->Bus == DIVAS_XDI_ADAPTER_BUS_PCI) {
            len +=
                sprintf(page + len, "PCI-bus     : %d\n",
                      a->resources.pci.bus);
            len +=
                sprintf(page + len, "PCI-func    : %d\n",
                      a->resources.pci.func);
            for (i = 0; i < 8; i++) {
                  if (a->resources.pci.bar[i]) {
                        len +=
                            sprintf(page + len,
                                  "Mem / I/O %d : 0x%x / mapped : 0x%lx",
                                  i, a->resources.pci.bar[i],
                                  (unsigned long) a->resources.
                                  pci.addr[i]);
                        if (a->resources.pci.length[i]) {
                              len +=
                                  sprintf(page + len,
                                        " / length : %d",
                                        a->resources.pci.
                                        length[i]);
                        }
                        len += sprintf(page + len, "\n");
                  }
            }
      }
      if ((!a->xdi_adapter.port) &&
          ((!a->xdi_adapter.ram) ||
          (!a->xdi_adapter.reset)
           || (!a->xdi_adapter.cfg))) {
            if (!IoAdapter->irq_info.irq_nr) {
                  p = "slave";
            } else {
                  p = "out of service";
            }
      } else if (a->xdi_adapter.trapped) {
            p = "trapped";
      } else if (a->xdi_adapter.Initialized) {
            p = "active";
      } else {
            p = "ready";
      }
      len += sprintf(page + len, "State       : %s\n", p);

      if (off + count >= len)
            *eof = 1;
      if (len < off)
            return 0;
      *start = page + off;
      return ((count < len - off) ? count : len - off);
}

/*
** adapter proc init/de-init
*/

/* --------------------------------------------------------------------------
    Create adapter directory and files in proc file system
   -------------------------------------------------------------------------- */
int create_adapter_proc(diva_os_xdi_adapter_t * a)
{
      struct proc_dir_entry *de, *pe;
      char tmp[16];

      sprintf(tmp, "%s%d", adapter_dir_name, a->controller);
      if (!(de = proc_mkdir(tmp, proc_net_eicon)))
            return (0);
      a->proc_adapter_dir = (void *) de;

      if (!(pe =
           create_proc_entry(info_proc_name, S_IFREG | S_IRUGO | S_IWUSR, de)))
            return (0);
      a->proc_info = (void *) pe;
      pe->write_proc = info_write;
      pe->read_proc = info_read;
      pe->data = a;

      if ((pe = create_proc_entry(grp_opt_proc_name,
                         S_IFREG | S_IRUGO | S_IWUSR, de))) {
            a->proc_grp_opt = (void *) pe;
            pe->write_proc = write_grp_opt;
            pe->read_proc = read_grp_opt;
            pe->data = a;
      }
      if ((pe = create_proc_entry(d_l1_down_proc_name,
                         S_IFREG | S_IRUGO | S_IWUSR, de))) {
            a->proc_d_l1_down = (void *) pe;
            pe->write_proc = write_d_l1_down;
            pe->read_proc = read_d_l1_down;
            pe->data = a;
      }

      DBG_TRC(("proc entry %s created", tmp));

      return (1);
}

/* --------------------------------------------------------------------------
    Remove adapter directory and files in proc file system
   -------------------------------------------------------------------------- */
void remove_adapter_proc(diva_os_xdi_adapter_t * a)
{
      char tmp[16];

      if (a->proc_adapter_dir) {
            if (a->proc_d_l1_down) {
                  remove_proc_entry(d_l1_down_proc_name,
                                (struct proc_dir_entry *) a->proc_adapter_dir);
            }
            if (a->proc_grp_opt) {
                  remove_proc_entry(grp_opt_proc_name,
                                (struct proc_dir_entry *) a->proc_adapter_dir);
            }
            if (a->proc_info) {
                  remove_proc_entry(info_proc_name,
                                (struct proc_dir_entry *) a->proc_adapter_dir);
            }
            sprintf(tmp, "%s%d", adapter_dir_name, a->controller);
            remove_proc_entry(tmp, proc_net_eicon);
            DBG_TRC(("proc entry %s%d removed", adapter_dir_name,
                   a->controller));
      }
}

Generated by  Doxygen 1.6.0   Back to index