Linux-2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
This commit is contained in:
Linus Torvalds
366
drivers/isdn/hardware/eicon/dadapter.c
Normal file
366
drivers/isdn/hardware/eicon/dadapter.c
Normal file
@@ -0,0 +1,366 @@
|
||||
|
||||
/*
|
||||
*
|
||||
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];
|
||||
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);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user