1/* 2 * 3 Copyright (c) Eicon Networks, 2002. 4 * 5 This source file is supplied for the use with 6 Eicon Networks range of DIVA Server Adapters. 7 * 8 Eicon File Revision : 2.1 9 * 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 2, or (at your option) 13 any later version. 14 * 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY OF ANY KIND WHATSOEVER INCLUDING ANY 17 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 18 See the GNU General Public License for more details. 19 * 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 23 * 24 */ 25#include "platform.h" 26#include "pc.h" 27#include "debuglib.h" 28#include "di_defs.h" 29#include "divasync.h" 30#include "dadapter.h" 31/* -------------------------------------------------------------------------- 32 Adapter array change notification framework 33 -------------------------------------------------------------------------- */ 34typedef struct _didd_adapter_change_notification { 35 didd_adapter_change_callback_t callback; 36 void IDI_CALL_ENTITY_T *context; 37} didd_adapter_change_notification_t, \ 38 * IDI_CALL_ENTITY_T pdidd_adapter_change_notification_t; 39#define DIVA_DIDD_MAX_NOTIFICATIONS 256 40static didd_adapter_change_notification_t \ 41NotificationTable[DIVA_DIDD_MAX_NOTIFICATIONS]; 42/* -------------------------------------------------------------------------- 43 Array to held adapter information 44 -------------------------------------------------------------------------- */ 45static DESCRIPTOR HandleTable[NEW_MAX_DESCRIPTORS]; 46static dword Adapters = 0; /* Number of adapters */ 47/* -------------------------------------------------------------------------- 48 Shadow IDI_DIMAINT 49 and 'shadow' debug stuff 50 -------------------------------------------------------------------------- */ 51static void no_printf(unsigned char *format, ...) 52{ 53#ifdef EBUG 54 va_list ap; 55 va_start(ap, format); 56 debug((format, ap)); 57 va_end(ap); 58#endif 59} 60 61/* ------------------------------------------------------------------------- 62 Portable debug Library 63 ------------------------------------------------------------------------- */ 64#include "debuglib.c" 65 66static DESCRIPTOR MAdapter = {IDI_DIMAINT, /* Adapter Type */ 67 0x00, /* Channels */ 68 0x0000, /* Features */ 69 (IDI_CALL)no_printf}; 70/* -------------------------------------------------------------------------- 71 DAdapter. Only IDI clients with buffer, that is huge enough to 72 get all descriptors will receive information about DAdapter 73 { byte type, byte channels, word features, IDI_CALL request } 74 -------------------------------------------------------------------------- */ 75static void IDI_CALL_LINK_T diva_dadapter_request(ENTITY IDI_CALL_ENTITY_T *); 76static DESCRIPTOR DAdapter = {IDI_DADAPTER, /* Adapter Type */ 77 0x00, /* Channels */ 78 0x0000, /* Features */ 79 diva_dadapter_request }; 80/* -------------------------------------------------------------------------- 81 LOCALS 82 -------------------------------------------------------------------------- */ 83static dword diva_register_adapter_callback(\ 84 didd_adapter_change_callback_t callback, 85 void IDI_CALL_ENTITY_T *context); 86static void diva_remove_adapter_callback(dword handle); 87static void diva_notify_adapter_change(DESCRIPTOR *d, int removal); 88static diva_os_spin_lock_t didd_spin; 89/* -------------------------------------------------------------------------- 90 Should be called as first step, after driver init 91 -------------------------------------------------------------------------- */ 92void diva_didd_load_time_init(void) { 93 memset(&HandleTable[0], 0x00, sizeof(HandleTable)); 94 memset(&NotificationTable[0], 0x00, sizeof(NotificationTable)); 95 diva_os_initialize_spin_lock(&didd_spin, "didd"); 96} 97/* -------------------------------------------------------------------------- 98 Should be called as last step, if driver does unload 99 -------------------------------------------------------------------------- */ 100void diva_didd_load_time_finit(void) { 101 diva_os_destroy_spin_lock(&didd_spin, "didd"); 102} 103/* -------------------------------------------------------------------------- 104 Called in order to register new adapter in adapter array 105 return adapter handle (> 0) on success 106 return -1 adapter array overflow 107 -------------------------------------------------------------------------- */ 108static int diva_didd_add_descriptor(DESCRIPTOR *d) { 109 diva_os_spin_lock_magic_t irql; 110 int i; 111 if (d->type == IDI_DIMAINT) { 112 if (d->request) { 113 MAdapter.request = d->request; 114 dprintf = (DIVA_DI_PRINTF)d->request; 115 diva_notify_adapter_change(&MAdapter, 0); /* Inserted */ 116 DBG_TRC(("DIMAINT registered, dprintf=%08x", d->request)) 117 } else { 118 DBG_TRC(("DIMAINT removed")) 119 diva_notify_adapter_change(&MAdapter, 1); /* About to remove */ 120 MAdapter.request = (IDI_CALL)no_printf; 121 dprintf = no_printf; 122 } 123 return (NEW_MAX_DESCRIPTORS); 124 } 125 for (i = 0; i < NEW_MAX_DESCRIPTORS; i++) { 126 diva_os_enter_spin_lock(&didd_spin, &irql, "didd_add"); 127 if (HandleTable[i].type == 0) { 128 memcpy(&HandleTable[i], d, sizeof(*d)); 129 Adapters++; 130 diva_os_leave_spin_lock(&didd_spin, &irql, "didd_add"); 131 diva_notify_adapter_change(d, 0); /* we have new adapter */ 132 DBG_TRC(("Add adapter[%d], request=%08x", (i + 1), d->request)) 133 return (i + 1); 134 } 135 diva_os_leave_spin_lock(&didd_spin, &irql, "didd_add"); 136 } 137 DBG_ERR(("Can't add adapter, out of resources")) 138 return (-1); 139} 140/* -------------------------------------------------------------------------- 141 Called in order to remove one registered adapter from array 142 return adapter handle (> 0) on success 143 return 0 on success 144 -------------------------------------------------------------------------- */ 145static int diva_didd_remove_descriptor(IDI_CALL request) { 146 diva_os_spin_lock_magic_t irql; 147 int i; 148 if (request == MAdapter.request) { 149 DBG_TRC(("DIMAINT removed")) 150 dprintf = no_printf; 151 diva_notify_adapter_change(&MAdapter, 1); /* About to remove */ 152 MAdapter.request = (IDI_CALL)no_printf; 153 return (0); 154 } 155 for (i = 0; (Adapters && (i < NEW_MAX_DESCRIPTORS)); i++) { 156 if (HandleTable[i].request == request) { 157 diva_notify_adapter_change(&HandleTable[i], 1); /* About to remove */ 158 diva_os_enter_spin_lock(&didd_spin, &irql, "didd_rm"); 159 memset(&HandleTable[i], 0x00, sizeof(HandleTable[0])); 160 Adapters--; 161 diva_os_leave_spin_lock(&didd_spin, &irql, "didd_rm"); 162 DBG_TRC(("Remove adapter[%d], request=%08x", (i + 1), request)) 163 return (0); 164 } 165 } 166 DBG_ERR(("Invalid request=%08x, can't remove adapter", request)) 167 return (-1); 168} 169/* -------------------------------------------------------------------------- 170 Read adapter array 171 return 1 if not enough space to save all available adapters 172 -------------------------------------------------------------------------- */ 173static int diva_didd_read_adapter_array(DESCRIPTOR *buffer, int length) { 174 diva_os_spin_lock_magic_t irql; 175 int src, dst; 176 memset(buffer, 0x00, length); 177 length /= sizeof(DESCRIPTOR); 178 DBG_TRC(("DIDD_Read, space = %d, Adapters = %d", length, Adapters + 2)) 179 180 diva_os_enter_spin_lock(&didd_spin, &irql, "didd_read"); 181 for (src = 0, dst = 0; 182 (Adapters && (src < NEW_MAX_DESCRIPTORS) && (dst < length)); 183 src++) { 184 if (HandleTable[src].type) { 185 memcpy(&buffer[dst], &HandleTable[src], sizeof(DESCRIPTOR)); 186 dst++; 187 } 188 } 189 diva_os_leave_spin_lock(&didd_spin, &irql, "didd_read"); 190 if (dst < length) { 191 memcpy(&buffer[dst], &MAdapter, sizeof(DESCRIPTOR)); 192 dst++; 193 } else { 194 DBG_ERR(("Can't write DIMAINT. Array too small")) 195 } 196 if (dst < length) { 197 memcpy(&buffer[dst], &DAdapter, sizeof(DESCRIPTOR)); 198 dst++; 199 } else { 200 DBG_ERR(("Can't write DADAPTER. Array too small")) 201 } 202 DBG_TRC(("Read %d adapters", dst)) 203 return (dst == length); 204} 205/* -------------------------------------------------------------------------- 206 DAdapter request function. 207 This function does process only synchronous requests, and is used 208 for reception/registration of new interfaces 209 -------------------------------------------------------------------------- */ 210static void IDI_CALL_LINK_T diva_dadapter_request( \ 211 ENTITY IDI_CALL_ENTITY_T *e) { 212 IDI_SYNC_REQ *syncReq = (IDI_SYNC_REQ *)e; 213 if (e->Req) { /* We do not process it, also return error */ 214 e->Rc = OUT_OF_RESOURCES; 215 DBG_ERR(("Can't process async request, Req=%02x", e->Req)) 216 return; 217 } 218 /* 219 So, we process sync request 220 */ 221 switch (e->Rc) { 222 case IDI_SYNC_REQ_DIDD_REGISTER_ADAPTER_NOTIFY: { 223 diva_didd_adapter_notify_t *pinfo = &syncReq->didd_notify.info; 224 pinfo->handle = diva_register_adapter_callback( \ 225 (didd_adapter_change_callback_t)pinfo->callback, 226 (void IDI_CALL_ENTITY_T *)pinfo->context); 227 e->Rc = 0xff; 228 } break; 229 case IDI_SYNC_REQ_DIDD_REMOVE_ADAPTER_NOTIFY: { 230 diva_didd_adapter_notify_t *pinfo = &syncReq->didd_notify.info; 231 diva_remove_adapter_callback(pinfo->handle); 232 e->Rc = 0xff; 233 } break; 234 case IDI_SYNC_REQ_DIDD_ADD_ADAPTER: { 235 diva_didd_add_adapter_t *pinfo = &syncReq->didd_add_adapter.info; 236 if (diva_didd_add_descriptor((DESCRIPTOR *)pinfo->descriptor) < 0) { 237 e->Rc = OUT_OF_RESOURCES; 238 } else { 239 e->Rc = 0xff; 240 } 241 } break; 242 case IDI_SYNC_REQ_DIDD_REMOVE_ADAPTER: { 243 diva_didd_remove_adapter_t *pinfo = &syncReq->didd_remove_adapter.info; 244 if (diva_didd_remove_descriptor((IDI_CALL)pinfo->p_request) < 0) { 245 e->Rc = OUT_OF_RESOURCES; 246 } else { 247 e->Rc = 0xff; 248 } 249 } break; 250 case IDI_SYNC_REQ_DIDD_READ_ADAPTER_ARRAY: { 251 diva_didd_read_adapter_array_t *pinfo =\ 252 &syncReq->didd_read_adapter_array.info; 253 if (diva_didd_read_adapter_array((DESCRIPTOR *)pinfo->buffer, 254 (int)pinfo->length)) { 255 e->Rc = OUT_OF_RESOURCES; 256 } else { 257 e->Rc = 0xff; 258 } 259 } break; 260 default: 261 DBG_ERR(("Can't process sync request, Req=%02x", e->Rc)) 262 e->Rc = OUT_OF_RESOURCES; 263 } 264} 265/* -------------------------------------------------------------------------- 266 IDI client does register his notification function 267 -------------------------------------------------------------------------- */ 268static dword diva_register_adapter_callback( \ 269 didd_adapter_change_callback_t callback, 270 void IDI_CALL_ENTITY_T *context) { 271 diva_os_spin_lock_magic_t irql; 272 dword i; 273 274 for (i = 0; i < DIVA_DIDD_MAX_NOTIFICATIONS; i++) { 275 diva_os_enter_spin_lock(&didd_spin, &irql, "didd_nfy_add"); 276 if (!NotificationTable[i].callback) { 277 NotificationTable[i].callback = callback; 278 NotificationTable[i].context = context; 279 diva_os_leave_spin_lock(&didd_spin, &irql, "didd_nfy_add"); 280 DBG_TRC(("Register adapter notification[%d]=%08x", i + 1, callback)) 281 return (i + 1); 282 } 283 diva_os_leave_spin_lock(&didd_spin, &irql, "didd_nfy_add"); 284 } 285 DBG_ERR(("Can't register adapter notification, overflow")) 286 return (0); 287} 288/* -------------------------------------------------------------------------- 289 IDI client does register his notification function 290 -------------------------------------------------------------------------- */ 291static void diva_remove_adapter_callback(dword handle) { 292 diva_os_spin_lock_magic_t irql; 293 if (handle && ((--handle) < DIVA_DIDD_MAX_NOTIFICATIONS)) { 294 diva_os_enter_spin_lock(&didd_spin, &irql, "didd_nfy_rm"); 295 NotificationTable[handle].callback = NULL; 296 NotificationTable[handle].context = NULL; 297 diva_os_leave_spin_lock(&didd_spin, &irql, "didd_nfy_rm"); 298 DBG_TRC(("Remove adapter notification[%d]", (int)(handle + 1))) 299 return; 300 } 301 DBG_ERR(("Can't remove adapter notification, handle=%d", handle)) 302 } 303/* -------------------------------------------------------------------------- 304 Notify all client about adapter array change 305 Does suppose following behavior in the client side: 306 Step 1: Redister Notification 307 Step 2: Read Adapter Array 308 -------------------------------------------------------------------------- */ 309static void diva_notify_adapter_change(DESCRIPTOR *d, int removal) { 310 int i, do_notify; 311 didd_adapter_change_notification_t nfy; 312 diva_os_spin_lock_magic_t irql; 313 for (i = 0; i < DIVA_DIDD_MAX_NOTIFICATIONS; i++) { 314 do_notify = 0; 315 diva_os_enter_spin_lock(&didd_spin, &irql, "didd_nfy"); 316 if (NotificationTable[i].callback) { 317 memcpy(&nfy, &NotificationTable[i], sizeof(nfy)); 318 do_notify = 1; 319 } 320 diva_os_leave_spin_lock(&didd_spin, &irql, "didd_nfy"); 321 if (do_notify) { 322 (*(nfy.callback))(nfy.context, d, removal); 323 } 324 } 325} 326/* -------------------------------------------------------------------------- 327 For all systems, that are linked by Kernel Mode Linker this is ONLY one 328 function thet should be exported by this device driver 329 IDI clients should look for IDI_DADAPTER, and use request function 330 of this adapter (sync request) in order to receive appropriate services: 331 - add new adapter 332 - remove existing adapter 333 - add adapter array notification 334 - remove adapter array notification 335 (read adapter is redundant in this case) 336 INPUT: 337 buffer - pointer to buffer that will receive adapter array 338 length - length (in bytes) of space in buffer 339 OUTPUT: 340 Adapter array will be written to memory described by 'buffer' 341 If the last adapter seen in the returned adapter array is 342 IDI_DADAPTER or if last adapter in array does have type '0', then 343 it was enougth space in buffer to accommodate all available 344 adapter descriptors 345 *NOTE 1 (debug interface): 346 The IDI adapter of type 'IDI_DIMAINT' does register as 'request' 347 famous 'dprintf' function (of type DI_PRINTF, please look 348 include/debuglib.c and include/debuglib.h) for details. 349 So dprintf is not exported from module debug module directly, 350 instead of this IDI_DIMAINT is registered. 351 Module load order will receive in this case: 352 1. DIDD (this file) 353 2. DIMAINT does load and register 'IDI_DIMAINT', at this step 354 DIDD should be able to get 'dprintf', save it, and 355 register with DIDD by means of 'dprintf' function. 356 3. any other driver is loaded and is able to access adapter array 357 and debug interface 358 This approach does allow to load/unload debug interface on demand, 359 and save memory, it it is necessary. 360 -------------------------------------------------------------------------- */ 361void IDI_CALL_LINK_T DIVA_DIDD_Read(void IDI_CALL_ENTITY_T *buffer, 362 int length) { 363 diva_didd_read_adapter_array(buffer, length); 364} 365