367 lines
14 KiB
C
367 lines
14 KiB
C
|
|
/*
|
|
*
|
|
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);
|
|
}
|
|
|