mntfunc.c

Go to the documentation of this file.

/* $Id: mntfunc.c,v 1.19.6.4 2005/01/31 12:22:20 armin Exp $
 *
 * Driver for Eicon DIVA Server ISDN cards.
 * Maint module
 *
 * Copyright 2000-2003 by Armin Schindler ([email protected])
 * Copyright 2000-2003 Cytronics & Melware ([email protected])
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 */


#include "platform.h"
#include "di_defs.h"
#include "divasync.h"
#include "debug_if.h"

extern char *DRIVERRELEASE_MNT;

#define DBG_MINIMUM  (DL_LOG + DL_FTL + DL_ERR)
#define DBG_DEFAULT  (DBG_MINIMUM + DL_XLOG + DL_REG)

extern void DIVA_DIDD_Read(void *, int);

static dword notify_handle;
static DESCRIPTOR DAdapter;
static DESCRIPTOR MAdapter;
static DESCRIPTOR MaintDescriptor =
{ IDI_DIMAINT, 0, 0, (IDI_CALL) diva_maint_prtComp };

extern int diva_os_copy_to_user(void *os_handle, void __user *dst,
                const void *src, int length);
extern int diva_os_copy_from_user(void *os_handle, void *dst,
                  const void __user *src, int length);

static void no_printf(unsigned char *x, ...)
{
    /* dummy debug function */
}

#include "debuglib.c"

/*
 *  DIDD callback function
 */
static void *didd_callback(void *context, DESCRIPTOR *adapter,
               int removal)
{
    if (adapter->type == IDI_DADAPTER) {
        DBG_ERR(("cb: Change in DAdapter ? Oops ?."));
    } else if (adapter->type == IDI_DIMAINT) {
        if (removal) {
            DbgDeregister();
            memset(&MAdapter, 0, sizeof(MAdapter));
            dprintf = no_printf;
        } else {
            memcpy(&MAdapter, adapter, sizeof(MAdapter));
            dprintf = (DIVA_DI_PRINTF) MAdapter.request;
            DbgRegister("MAINT", DRIVERRELEASE_MNT, DBG_DEFAULT);
        }
    } else if ((adapter->type > 0) && (adapter->type < 16)) {
        if (removal) {
            diva_mnt_remove_xdi_adapter(adapter);
        } else {
            diva_mnt_add_xdi_adapter(adapter);
        }
    }
    return (NULL);
}

/*
 * connect to didd
 */
static int __init connect_didd(void)
{
    int x = 0;
    int dadapter = 0;
    IDI_SYNC_REQ req;
    DESCRIPTOR DIDD_Table[MAX_DESCRIPTORS];

    DIVA_DIDD_Read(DIDD_Table, sizeof(DIDD_Table));

    for (x = 0; x < MAX_DESCRIPTORS; x++) {
        if (DIDD_Table[x].type == IDI_DADAPTER) {   /* DADAPTER found */
            dadapter = 1;
            memcpy(&DAdapter, &DIDD_Table[x], sizeof(DAdapter));
            req.didd_notify.e.Req = 0;
            req.didd_notify.e.Rc =
                IDI_SYNC_REQ_DIDD_REGISTER_ADAPTER_NOTIFY;
            req.didd_notify.info.callback = (void *)didd_callback;
            req.didd_notify.info.context = NULL;
            DAdapter.request((ENTITY *)&req);
            if (req.didd_notify.e.Rc != 0xff)
                return (0);
            notify_handle = req.didd_notify.info.handle;
            /* Register MAINT (me) */
            req.didd_add_adapter.e.Req = 0;
            req.didd_add_adapter.e.Rc =
                IDI_SYNC_REQ_DIDD_ADD_ADAPTER;
            req.didd_add_adapter.info.descriptor =
                (void *) &MaintDescriptor;
            DAdapter.request((ENTITY *)&req);
            if (req.didd_add_adapter.e.Rc != 0xff)
                return (0);
        } else if ((DIDD_Table[x].type > 0)
               && (DIDD_Table[x].type < 16)) {
            diva_mnt_add_xdi_adapter(&DIDD_Table[x]);
        }
    }
    return (dadapter);
}

/*
 * disconnect from didd
 */
static void __exit disconnect_didd(void)
{
    IDI_SYNC_REQ req;

    req.didd_notify.e.Req = 0;
    req.didd_notify.e.Rc = IDI_SYNC_REQ_DIDD_REMOVE_ADAPTER_NOTIFY;
    req.didd_notify.info.handle = notify_handle;
    DAdapter.request((ENTITY *)&req);

    req.didd_remove_adapter.e.Req = 0;
    req.didd_remove_adapter.e.Rc = IDI_SYNC_REQ_DIDD_REMOVE_ADAPTER;
    req.didd_remove_adapter.info.p_request =
        (IDI_CALL) MaintDescriptor.request;
    DAdapter.request((ENTITY *)&req);
}

/*
 * read/write maint
 */
int maint_read_write(void __user *buf, int count)
{
    byte data[128];
    dword cmd, id, mask;
    int ret = 0;

    if (count < (3 * sizeof(dword)))
        return (-EFAULT);

    if (diva_os_copy_from_user(NULL, (void *) &data[0],
                   buf, 3 * sizeof(dword))) {
        return (-EFAULT);
    }

    cmd = *(dword *)&data[0];   /* command */
    id = *(dword *)&data[4];    /* driver id */
    mask = *(dword *)&data[8];  /* mask or size */

    switch (cmd) {
    case DITRACE_CMD_GET_DRIVER_INFO:
        if ((ret = diva_get_driver_info(id, data, sizeof(data))) > 0) {
            if ((count < ret) || diva_os_copy_to_user
                (NULL, buf, (void *) &data[0], ret))
                ret = -EFAULT;
        } else {
            ret = -EINVAL;
        }
        break;

    case DITRACE_READ_DRIVER_DBG_MASK:
        if ((ret = diva_get_driver_dbg_mask(id, (byte *) data)) > 0) {
            if ((count < ret) || diva_os_copy_to_user
                (NULL, buf, (void *) &data[0], ret))
                ret = -EFAULT;
        } else {
            ret = -ENODEV;
        }
        break;

    case DITRACE_WRITE_DRIVER_DBG_MASK:
        if ((ret = diva_set_driver_dbg_mask(id, mask)) <= 0) {
            ret = -ENODEV;
        }
        break;

        /*
          Filter commands will ignore the ID due to fact that filtering affects
          the B- channel and Audio Tap trace levels only. Also MAINT driver will
          select the right trace ID by itself
        */
    case DITRACE_WRITE_SELECTIVE_TRACE_FILTER:
        if (!mask) {
            ret = diva_set_trace_filter(1, "*");
        } else if (mask < sizeof(data)) {
            if (diva_os_copy_from_user(NULL, data, (char __user *)buf + 12, mask)) {
                ret = -EFAULT;
            } else {
                ret = diva_set_trace_filter((int)mask, data);
            }
        } else {
            ret = -EINVAL;
        }
        break;

    case DITRACE_READ_SELECTIVE_TRACE_FILTER:
        if ((ret = diva_get_trace_filter(sizeof(data), data)) > 0) {
            if (diva_os_copy_to_user(NULL, buf, data, ret))
                ret = -EFAULT;
        } else {
            ret = -ENODEV;
        }
        break;

    case DITRACE_READ_TRACE_ENTRY:{
        diva_os_spin_lock_magic_t old_irql;
        word size;
        diva_dbg_entry_head_t *pmsg;
        byte *pbuf;

        if (!(pbuf = diva_os_malloc(0, mask))) {
            return (-ENOMEM);
        }

        for (;;) {
            if (!(pmsg =
                  diva_maint_get_message(&size, &old_irql))) {
                break;
            }
            if (size > mask) {
                diva_maint_ack_message(0, &old_irql);
                ret = -EINVAL;
                break;
            }
            ret = size;
            memcpy(pbuf, pmsg, size);
            diva_maint_ack_message(1, &old_irql);
            if ((count < size) ||
                diva_os_copy_to_user(NULL, buf, (void *) pbuf, size))
                ret = -EFAULT;
            break;
        }
        diva_os_free(0, pbuf);
    }
        break;

    case DITRACE_READ_TRACE_ENTRYS:{
        diva_os_spin_lock_magic_t old_irql;
        word size;
        diva_dbg_entry_head_t *pmsg;
        byte *pbuf = NULL;
        int written = 0;

        if (mask < 4096) {
            ret = -EINVAL;
            break;
        }
        if (!(pbuf = diva_os_malloc(0, mask))) {
            return (-ENOMEM);
        }

        for (;;) {
            if (!(pmsg =
                  diva_maint_get_message(&size, &old_irql))) {
                break;
            }
            if ((size + 8) > mask) {
                diva_maint_ack_message(0, &old_irql);
                break;
            }
            /*
              Write entry length
            */
            pbuf[written++] = (byte) size;
            pbuf[written++] = (byte) (size >> 8);
            pbuf[written++] = 0;
            pbuf[written++] = 0;
            /*
              Write message
            */
            memcpy(&pbuf[written], pmsg, size);
            diva_maint_ack_message(1, &old_irql);
            written += size;
            mask -= (size + 4);
        }
        pbuf[written++] = 0;
        pbuf[written++] = 0;
        pbuf[written++] = 0;
        pbuf[written++] = 0;

        if ((count < written) || diva_os_copy_to_user(NULL, buf, (void *) pbuf, written)) {
            ret = -EFAULT;
        } else {
            ret = written;
        }
        diva_os_free(0, pbuf);
    }
        break;

    default:
        ret = -EINVAL;
    }
    return (ret);
}

/*
 *  init
 */
int __init mntfunc_init(int *buffer_length, void **buffer,
                    unsigned long diva_dbg_mem)
{
    if (*buffer_length < 64) {
        *buffer_length = 64;
    }
    if (*buffer_length > 512) {
        *buffer_length = 512;
    }
    *buffer_length *= 1024;

    if (diva_dbg_mem) {
        *buffer = (void *) diva_dbg_mem;
    } else {
        while ((*buffer_length >= (64 * 1024))
               &&
               (!(*buffer = diva_os_malloc(0, *buffer_length)))) {
            *buffer_length -= 1024;
        }

        if (!*buffer) {
            DBG_ERR(("init: Can not alloc trace buffer"));
            return (0);
        }
    }

    if (diva_maint_init(*buffer, *buffer_length, (diva_dbg_mem == 0))) {
        if (!diva_dbg_mem) {
            diva_os_free(0, *buffer);
        }
        DBG_ERR(("init: maint init failed"));
        return (0);
    }

    if (!connect_didd()) {
        DBG_ERR(("init: failed to connect to DIDD."));
        diva_maint_finit();
        if (!diva_dbg_mem) {
            diva_os_free(0, *buffer);
        }
        return (0);
    }
    return (1);
}

/*
 *  exit
 */
void __exit mntfunc_finit(void)
{
    void *buffer;
    int i = 100;

    DbgDeregister();

    while (diva_mnt_shutdown_xdi_adapters() && i--) {
        diva_os_sleep(10);
    }

    disconnect_didd();

    if ((buffer = diva_maint_finit())) {
        diva_os_free(0, buffer);
    }

    memset(&MAdapter, 0, sizeof(MAdapter));
    dprintf = no_printf;
}