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!

1 files changed, 366 insertions, 0 deletions

diff --git a/drivers/isdn/hardware/eicon/dadapter.c b/drivers/isdn/hardware/eicon/dadapter.c
new file mode 100644
index 000000000000..6e548a222ef1
--- /dev/null
+++ b/drivers/isdn/hardware/eicon/dadapter.c
@@ -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);
+}
+