dadapter.c

Go to the documentation of this file.

/*
 *
 Copyright (c) Eicon Networks, 2002.
 *
 This source file is supplied for the use with
 Eicon Networks range of DIVA Server Adapters.
 *
 Eicon File Revision :    2.1
 *
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 any later version.
 *
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY OF ANY KIND WHATSOEVER INCLUDING ANY
 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 See the GNU General Public License for more details.
 *
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */
#include "platform.h"
#include "pc.h"
#include "debuglib.h"
#include "di_defs.h"
#include "divasync.h"
#include "dadapter.h"
/* --------------------------------------------------------------------------
   Adapter array change notification framework
   -------------------------------------------------------------------------- */
typedef struct _didd_adapter_change_notification {
    didd_adapter_change_callback_t callback;
    void IDI_CALL_ENTITY_T *context;
} didd_adapter_change_notification_t,               \
    * IDI_CALL_ENTITY_T pdidd_adapter_change_notification_t;
#define DIVA_DIDD_MAX_NOTIFICATIONS 256
static didd_adapter_change_notification_t   \
NotificationTable[DIVA_DIDD_MAX_NOTIFICATIONS];
/* --------------------------------------------------------------------------
   Array to held adapter information
   -------------------------------------------------------------------------- */
static DESCRIPTOR  HandleTable[NEW_MAX_DESCRIPTORS];
static dword Adapters = 0; /* Number of adapters */
/* --------------------------------------------------------------------------
   Shadow IDI_DIMAINT
   and 'shadow' debug stuff
   -------------------------------------------------------------------------- */
static void no_printf(unsigned char *format, ...)
{
#ifdef EBUG
    va_list ap;
    va_start(ap, format);
    debug((format, ap));
    va_end(ap);
#endif
}

/* -------------------------------------------------------------------------
   Portable debug Library
   ------------------------------------------------------------------------- */
#include "debuglib.c"

static DESCRIPTOR  MAdapter =  {IDI_DIMAINT, /* Adapter Type */
                0x00,     /* Channels */
                0x0000,    /* Features */
                (IDI_CALL)no_printf};
/* --------------------------------------------------------------------------
   DAdapter. Only IDI clients with buffer, that is huge enough to
   get all descriptors will receive information about DAdapter
   { byte type, byte channels, word features, IDI_CALL request }
   -------------------------------------------------------------------------- */
static void IDI_CALL_LINK_T diva_dadapter_request(ENTITY IDI_CALL_ENTITY_T *);
static DESCRIPTOR  DAdapter =  {IDI_DADAPTER, /* Adapter Type */
                0x00,     /* Channels */
                0x0000,    /* Features */
                diva_dadapter_request };
/* --------------------------------------------------------------------------
   LOCALS
   -------------------------------------------------------------------------- */
static dword diva_register_adapter_callback(\
    didd_adapter_change_callback_t callback,
    void IDI_CALL_ENTITY_T *context);
static void diva_remove_adapter_callback(dword handle);
static void diva_notify_adapter_change(DESCRIPTOR *d, int removal);
static diva_os_spin_lock_t didd_spin;
/* --------------------------------------------------------------------------
   Should be called as first step, after driver init
   -------------------------------------------------------------------------- */
void diva_didd_load_time_init(void) {
    memset(&HandleTable[0], 0x00, sizeof(HandleTable));
    memset(&NotificationTable[0], 0x00, sizeof(NotificationTable));
    diva_os_initialize_spin_lock(&didd_spin, "didd");
}
/* --------------------------------------------------------------------------
   Should be called as last step, if driver does unload
   -------------------------------------------------------------------------- */
void diva_didd_load_time_finit(void) {
    diva_os_destroy_spin_lock(&didd_spin, "didd");
}
/* --------------------------------------------------------------------------
   Called in order to register new adapter in adapter array
   return adapter handle (> 0) on success
   return -1 adapter array overflow
   -------------------------------------------------------------------------- */
static int diva_didd_add_descriptor(DESCRIPTOR *d) {
    diva_os_spin_lock_magic_t      irql;
    int i;
    if (d->type == IDI_DIMAINT) {
        if (d->request) {
            MAdapter.request = d->request;
            dprintf = (DIVA_DI_PRINTF)d->request;
            diva_notify_adapter_change(&MAdapter, 0); /* Inserted */
            DBG_TRC(("DIMAINT registered, dprintf=%08x", d->request))
                } else {
            DBG_TRC(("DIMAINT removed"))
                diva_notify_adapter_change(&MAdapter, 1); /* About to remove */
            MAdapter.request = (IDI_CALL)no_printf;
            dprintf = no_printf;
        }
        return (NEW_MAX_DESCRIPTORS);
    }
    for (i = 0; i < NEW_MAX_DESCRIPTORS; i++) {
        diva_os_enter_spin_lock(&didd_spin, &irql, "didd_add");
        if (HandleTable[i].type == 0) {
            memcpy(&HandleTable[i], d, sizeof(*d));
            Adapters++;
            diva_os_leave_spin_lock(&didd_spin, &irql, "didd_add");
            diva_notify_adapter_change(d, 0); /* we have new adapter */
            DBG_TRC(("Add adapter[%d], request=%08x", (i + 1), d->request))
                return (i + 1);
        }
        diva_os_leave_spin_lock(&didd_spin, &irql, "didd_add");
    }
    DBG_ERR(("Can't add adapter, out of resources"))
        return (-1);
}
/* --------------------------------------------------------------------------
   Called in order to remove one registered adapter from array
   return adapter handle (> 0) on success
   return 0 on success
   -------------------------------------------------------------------------- */
static int diva_didd_remove_descriptor(IDI_CALL request) {
    diva_os_spin_lock_magic_t      irql;
    int i;
    if (request == MAdapter.request) {
        DBG_TRC(("DIMAINT removed"))
            dprintf = no_printf;
        diva_notify_adapter_change(&MAdapter, 1); /* About to remove */
        MAdapter.request = (IDI_CALL)no_printf;
        return (0);
    }
    for (i = 0; (Adapters && (i < NEW_MAX_DESCRIPTORS)); i++) {
        if (HandleTable[i].request == request) {
            diva_notify_adapter_change(&HandleTable[i], 1); /* About to remove */
            diva_os_enter_spin_lock(&didd_spin, &irql, "didd_rm");
            memset(&HandleTable[i], 0x00, sizeof(HandleTable[0]));
            Adapters--;
            diva_os_leave_spin_lock(&didd_spin, &irql, "didd_rm");
            DBG_TRC(("Remove adapter[%d], request=%08x", (i + 1), request))
                return (0);
        }
    }
    DBG_ERR(("Invalid request=%08x, can't remove adapter", request))
        return (-1);
}
/* --------------------------------------------------------------------------
   Read adapter array
   return 1 if not enough space to save all available adapters
   -------------------------------------------------------------------------- */
static int diva_didd_read_adapter_array(DESCRIPTOR *buffer, int length) {
    diva_os_spin_lock_magic_t      irql;
    int src, dst;
    memset(buffer, 0x00, length);
    length /= sizeof(DESCRIPTOR);
    DBG_TRC(("DIDD_Read, space = %d, Adapters = %d", length, Adapters + 2))

        diva_os_enter_spin_lock(&didd_spin, &irql, "didd_read");
    for (src = 0, dst = 0;
         (Adapters && (src < NEW_MAX_DESCRIPTORS) && (dst < length));
         src++) {
        if (HandleTable[src].type) {
            memcpy(&buffer[dst], &HandleTable[src], sizeof(DESCRIPTOR));
            dst++;
        }
    }
    diva_os_leave_spin_lock(&didd_spin, &irql, "didd_read");
    if (dst < length) {
        memcpy(&buffer[dst], &MAdapter, sizeof(DESCRIPTOR));
        dst++;
    } else {
        DBG_ERR(("Can't write DIMAINT. Array too small"))
            }
    if (dst < length) {
        memcpy(&buffer[dst], &DAdapter, sizeof(DESCRIPTOR));
        dst++;
    } else {
        DBG_ERR(("Can't write DADAPTER. Array too small"))
            }
    DBG_TRC(("Read %d adapters", dst))
        return (dst == length);
}
/* --------------------------------------------------------------------------
   DAdapter request function.
   This function does process only synchronous requests, and is used
   for reception/registration of new interfaces
   -------------------------------------------------------------------------- */
static void IDI_CALL_LINK_T diva_dadapter_request(  \
    ENTITY IDI_CALL_ENTITY_T *e) {
    IDI_SYNC_REQ *syncReq = (IDI_SYNC_REQ *)e;
    if (e->Req) { /* We do not process it, also return error */
        e->Rc = OUT_OF_RESOURCES;
        DBG_ERR(("Can't process async request, Req=%02x", e->Req))
            return;
    }
    /*
      So, we process sync request
    */
    switch (e->Rc) {
    case IDI_SYNC_REQ_DIDD_REGISTER_ADAPTER_NOTIFY: {
        diva_didd_adapter_notify_t *pinfo = &syncReq->didd_notify.info;
        pinfo->handle = diva_register_adapter_callback(     \
            (didd_adapter_change_callback_t)pinfo->callback,
            (void IDI_CALL_ENTITY_T *)pinfo->context);
        e->Rc = 0xff;
    } break;
    case IDI_SYNC_REQ_DIDD_REMOVE_ADAPTER_NOTIFY: {
        diva_didd_adapter_notify_t *pinfo = &syncReq->didd_notify.info;
        diva_remove_adapter_callback(pinfo->handle);
        e->Rc = 0xff;
    } break;
    case IDI_SYNC_REQ_DIDD_ADD_ADAPTER: {
        diva_didd_add_adapter_t *pinfo = &syncReq->didd_add_adapter.info;
        if (diva_didd_add_descriptor((DESCRIPTOR *)pinfo->descriptor) < 0) {
            e->Rc = OUT_OF_RESOURCES;
        } else {
            e->Rc = 0xff;
        }
    } break;
    case IDI_SYNC_REQ_DIDD_REMOVE_ADAPTER: {
        diva_didd_remove_adapter_t *pinfo = &syncReq->didd_remove_adapter.info;
        if (diva_didd_remove_descriptor((IDI_CALL)pinfo->p_request) < 0) {
            e->Rc = OUT_OF_RESOURCES;
        } else {
            e->Rc = 0xff;
        }
    } break;
    case IDI_SYNC_REQ_DIDD_READ_ADAPTER_ARRAY: {
        diva_didd_read_adapter_array_t *pinfo =\
            &syncReq->didd_read_adapter_array.info;
        if (diva_didd_read_adapter_array((DESCRIPTOR *)pinfo->buffer,
                          (int)pinfo->length)) {
            e->Rc = OUT_OF_RESOURCES;
        } else {
            e->Rc = 0xff;
        }
    } break;
    default:
        DBG_ERR(("Can't process sync request, Req=%02x", e->Rc))
            e->Rc = OUT_OF_RESOURCES;
    }
}
/* --------------------------------------------------------------------------
   IDI client does register his notification function
   -------------------------------------------------------------------------- */
static dword diva_register_adapter_callback(        \
    didd_adapter_change_callback_t callback,
    void IDI_CALL_ENTITY_T *context) {
    diva_os_spin_lock_magic_t irql;
    dword i;

    for (i = 0; i < DIVA_DIDD_MAX_NOTIFICATIONS; i++) {
        diva_os_enter_spin_lock(&didd_spin, &irql, "didd_nfy_add");
        if (!NotificationTable[i].callback) {
            NotificationTable[i].callback = callback;
            NotificationTable[i].context = context;
            diva_os_leave_spin_lock(&didd_spin, &irql, "didd_nfy_add");
            DBG_TRC(("Register adapter notification[%d]=%08x", i + 1, callback))
                return (i + 1);
        }
        diva_os_leave_spin_lock(&didd_spin, &irql, "didd_nfy_add");
    }
    DBG_ERR(("Can't register adapter notification, overflow"))
        return (0);
}
/* --------------------------------------------------------------------------
   IDI client does register his notification function
   -------------------------------------------------------------------------- */
static void diva_remove_adapter_callback(dword handle) {
    diva_os_spin_lock_magic_t irql;
    if (handle && ((--handle) < DIVA_DIDD_MAX_NOTIFICATIONS)) {
        diva_os_enter_spin_lock(&didd_spin, &irql, "didd_nfy_rm");
        NotificationTable[handle].callback = NULL;
        NotificationTable[handle].context  = NULL;
        diva_os_leave_spin_lock(&didd_spin, &irql, "didd_nfy_rm");
        DBG_TRC(("Remove adapter notification[%d]", (int)(handle + 1)))
            return;
    }
    DBG_ERR(("Can't remove adapter notification, handle=%d", handle))
        }
/* --------------------------------------------------------------------------
   Notify all client about adapter array change
   Does suppose following behavior in the client side:
   Step 1: Redister Notification
   Step 2: Read Adapter Array
   -------------------------------------------------------------------------- */
static void diva_notify_adapter_change(DESCRIPTOR *d, int removal) {
    int i, do_notify;
    didd_adapter_change_notification_t nfy;
    diva_os_spin_lock_magic_t irql;
    for (i = 0; i < DIVA_DIDD_MAX_NOTIFICATIONS; i++) {
        do_notify = 0;
        diva_os_enter_spin_lock(&didd_spin, &irql, "didd_nfy");
        if (NotificationTable[i].callback) {
            memcpy(&nfy, &NotificationTable[i], sizeof(nfy));
            do_notify = 1;
        }
        diva_os_leave_spin_lock(&didd_spin, &irql, "didd_nfy");
        if (do_notify) {
            (*(nfy.callback))(nfy.context, d, removal);
        }
    }
}
/* --------------------------------------------------------------------------
   For all systems, that are linked by Kernel Mode Linker this is ONLY one
   function thet should be exported by this device driver
   IDI clients should look for IDI_DADAPTER, and use request function
   of this adapter (sync request) in order to receive appropriate services:
   - add new adapter
   - remove existing adapter
   - add adapter array notification
   - remove adapter array notification
   (read adapter is redundant in this case)
   INPUT:
   buffer - pointer to buffer that will receive adapter array
   length  - length (in bytes) of space in buffer
   OUTPUT:
   Adapter array will be written to memory described by 'buffer'
   If the last adapter seen in the returned adapter array is
   IDI_DADAPTER or if last adapter in array does have type '0', then
   it was enougth space in buffer to accommodate all available
   adapter descriptors
   *NOTE 1 (debug interface):
   The IDI adapter of type 'IDI_DIMAINT' does register as 'request'
   famous 'dprintf' function (of type DI_PRINTF, please look
   include/debuglib.c and include/debuglib.h) for details.
   So dprintf is not exported from module debug module directly,
   instead of this IDI_DIMAINT is registered.
   Module load order will receive in this case:
   1. DIDD (this file)
   2. DIMAINT does load and register 'IDI_DIMAINT', at this step
   DIDD should be able to get 'dprintf', save it, and
   register with DIDD by means of 'dprintf' function.
   3. any other driver is loaded and is able to access adapter array
   and debug interface
   This approach does allow to load/unload debug interface on demand,
   and save memory, it it is necessary.
   -------------------------------------------------------------------------- */
void IDI_CALL_LINK_T DIVA_DIDD_Read(void IDI_CALL_ENTITY_T *buffer,
                    int length) {
    diva_didd_read_adapter_array(buffer, length);
}