drivers/isdn/hardware/eicon/io.c

   1
   2 /*
   3  *
   4  Copyright (c) Eicon Networks, 2002.
   5  *
   6  This source file is supplied for the use with
   7  Eicon Networks range of DIVA Server Adapters.
   8  *
   9  Eicon File Revision :    2.1
  10  *
  11  This program is free software; you can redistribute it and/or modify
  12  it under the terms of the GNU General Public License as published by
  13  the Free Software Foundation; either version 2, or (at your option)
  14  any later version.
  15  *
  16  This program is distributed in the hope that it will be useful,
  17  but WITHOUT ANY WARRANTY OF ANY KIND WHATSOEVER INCLUDING ANY
  18  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  19  See the GNU General Public License for more details.
  20  *
  21  You should have received a copy of the GNU General Public License
  22  along with this program; if not, write to the Free Software
  23  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  *
  25  */
  26 #include "platform.h"
  27 #include "di_defs.h"
  28 #include "pc.h"
  29 #include "pr_pc.h"
  30 #include "divasync.h"
  31 #define MIPS_SCOM
  32 #include "pkmaint.h" /* pc_main.h, packed in os-dependent fashion */
  33 #include "di.h"
  34 #include "mi_pc.h"
  35 #include "io.h"
  36 extern ADAPTER *adapter[MAX_ADAPTER];
  37 extern PISDN_ADAPTER IoAdapters[MAX_ADAPTER];
  38 void request(PISDN_ADAPTER, ENTITY *);
  39 static void pcm_req(PISDN_ADAPTER, ENTITY *);
  40 /* --------------------------------------------------------------------------
  41    local functions
  42    -------------------------------------------------------------------------- */
  43 #define ReqFunc(N)                                                      \
  44         static void Request##N(ENTITY *e)                               \
  45         { if (IoAdapters[N]) (*IoAdapters[N]->DIRequest)(IoAdapters[N], e); }
  46 ReqFunc(0)
  47 ReqFunc(1)
  48 ReqFunc(2)
  49 ReqFunc(3)
  50 ReqFunc(4)
  51 ReqFunc(5)
  52 ReqFunc(6)
  53 ReqFunc(7)
  54 ReqFunc(8)
  55 ReqFunc(9)
  56 ReqFunc(10)
  57 ReqFunc(11)
  58 ReqFunc(12)
  59 ReqFunc(13)
  60 ReqFunc(14)
  61 ReqFunc(15)
  62 IDI_CALL Requests[MAX_ADAPTER] =
  63 { &Request0, &Request1, &Request2, &Request3,
  64   &Request4, &Request5, &Request6, &Request7,
  65   &Request8, &Request9, &Request10, &Request11,
  66   &Request12, &Request13, &Request14, &Request15
  67 };
  68 /*****************************************************************************/
  69 /*
  70   This array should indicate all new services, that this version of XDI
  71   is able to provide to his clients
  72 */
  73 static byte extended_xdi_features[DIVA_XDI_EXTENDED_FEATURES_MAX_SZ + 1] = {
  74         (DIVA_XDI_EXTENDED_FEATURES_VALID       |
  75          DIVA_XDI_EXTENDED_FEATURE_SDRAM_BAR    |
  76          DIVA_XDI_EXTENDED_FEATURE_CAPI_PRMS    |
  77 #if defined(DIVA_IDI_RX_DMA)
  78          DIVA_XDI_EXTENDED_FEATURE_CMA          |
  79          DIVA_XDI_EXTENDED_FEATURE_RX_DMA       |
  80          DIVA_XDI_EXTENDED_FEATURE_MANAGEMENT_DMA |
  81 #endif
  82          DIVA_XDI_EXTENDED_FEATURE_NO_CANCEL_RC),
  83         0
  84 };
  85 /*****************************************************************************/
  86 void
  87 dump_xlog_buffer(PISDN_ADAPTER IoAdapter, Xdesc *xlogDesc)
  88 {
  89         dword   logLen;
  90         word *Xlog   = xlogDesc->buf;
  91         word  logCnt = xlogDesc->cnt;
  92         word  logOut = xlogDesc->out / sizeof(*Xlog);
  93         DBG_FTL(("%s: ************* XLOG recovery (%d) *************",
  94                  &IoAdapter->Name[0], (int)logCnt))
  95                 DBG_FTL(("Microcode: %s", &IoAdapter->ProtocolIdString[0]))
  96                 for (; logCnt > 0; --logCnt)
  97                 {
  98                         if (!GET_WORD(&Xlog[logOut]))
  99                         {
 100                                 if (--logCnt == 0)
 101                                         break;
 102                                 logOut = 0;
 103                         }
 104                         if (GET_WORD(&Xlog[logOut]) <= (logOut * sizeof(*Xlog)))
 105                         {
 106                                 if (logCnt > 2)
 107                                 {
 108                                         DBG_FTL(("Possibly corrupted XLOG: %d entries left",
 109                                                  (int)logCnt))
 110                                                 }
 111                                 break;
 112                         }
 113                         logLen = (dword)(GET_WORD(&Xlog[logOut]) - (logOut * sizeof(*Xlog)));
 114                         DBG_FTL_MXLOG(((char *)&Xlog[logOut + 1], (dword)(logLen - 2)))
 115                                 logOut = (GET_WORD(&Xlog[logOut]) + 1) / sizeof(*Xlog);
 116                 }
 117         DBG_FTL(("%s: ***************** end of XLOG *****************",
 118                  &IoAdapter->Name[0]))
 119                 }
 120 /*****************************************************************************/
 121 #if defined(XDI_USE_XLOG)
 122 static char *(ExceptionCauseTable[]) =
 123 {
 124         "Interrupt",
 125         "TLB mod /IBOUND",
 126         "TLB load /DBOUND",
 127         "TLB store",
 128         "Address error load",
 129         "Address error store",
 130         "Instruction load bus error",
 131         "Data load/store bus error",
 132         "Syscall",
 133         "Breakpoint",
 134         "Reverd instruction",
 135         "Coprocessor unusable",
 136         "Overflow",
 137         "TRAP",
 138         "VCEI",
 139         "Floating Point Exception",
 140         "CP2",
 141         "Reserved 17",
 142         "Reserved 18",
 143         "Reserved 19",
 144         "Reserved 20",
 145         "Reserved 21",
 146         "Reserved 22",
 147         "WATCH",
 148         "Reserved 24",
 149         "Reserved 25",
 150         "Reserved 26",
 151         "Reserved 27",
 152         "Reserved 28",
 153         "Reserved 29",
 154         "Reserved 30",
 155         "VCED"
 156 };
 157 #endif
 158 void
 159 dump_trap_frame(PISDN_ADAPTER IoAdapter, byte __iomem *exceptionFrame)
 160 {
 161         MP_XCPTC __iomem *xcept = (MP_XCPTC __iomem *)exceptionFrame;
 162         dword    __iomem *regs;
 163         regs  = &xcept->regs[0];
 164         DBG_FTL(("%s: ***************** CPU TRAPPED *****************",
 165                  &IoAdapter->Name[0]))
 166                 DBG_FTL(("Microcode: %s", &IoAdapter->ProtocolIdString[0]))
 167                 DBG_FTL(("Cause: %s",
 168                          ExceptionCauseTable[(READ_DWORD(&xcept->cr) & 0x0000007c) >> 2]))
 169                 DBG_FTL(("sr    0x%08x cr    0x%08x epc   0x%08x vaddr 0x%08x",
 170                          READ_DWORD(&xcept->sr), READ_DWORD(&xcept->cr),
 171                          READ_DWORD(&xcept->epc), READ_DWORD(&xcept->vaddr)))
 172                 DBG_FTL(("zero  0x%08x at    0x%08x v0    0x%08x v1    0x%08x",
 173                          READ_DWORD(&regs[0]), READ_DWORD(&regs[1]),
 174                          READ_DWORD(&regs[2]), READ_DWORD(&regs[3])))
 175                 DBG_FTL(("a0    0x%08x a1    0x%08x a2    0x%08x a3    0x%08x",
 176                          READ_DWORD(&regs[4]), READ_DWORD(&regs[5]),
 177                          READ_DWORD(&regs[6]), READ_DWORD(&regs[7])))
 178                 DBG_FTL(("t0    0x%08x t1    0x%08x t2    0x%08x t3    0x%08x",
 179                          READ_DWORD(&regs[8]), READ_DWORD(&regs[9]),
 180                          READ_DWORD(&regs[10]), READ_DWORD(&regs[11])))
 181                 DBG_FTL(("t4    0x%08x t5    0x%08x t6    0x%08x t7    0x%08x",
 182                          READ_DWORD(&regs[12]), READ_DWORD(&regs[13]),
 183                          READ_DWORD(&regs[14]), READ_DWORD(&regs[15])))
 184                 DBG_FTL(("s0    0x%08x s1    0x%08x s2    0x%08x s3    0x%08x",
 185                          READ_DWORD(&regs[16]), READ_DWORD(&regs[17]),
 186                          READ_DWORD(&regs[18]), READ_DWORD(&regs[19])))
 187                 DBG_FTL(("s4    0x%08x s5    0x%08x s6    0x%08x s7    0x%08x",
 188                          READ_DWORD(&regs[20]), READ_DWORD(&regs[21]),
 189                          READ_DWORD(&regs[22]), READ_DWORD(&regs[23])))
 190                 DBG_FTL(("t8    0x%08x t9    0x%08x k0    0x%08x k1    0x%08x",
 191                          READ_DWORD(&regs[24]), READ_DWORD(&regs[25]),
 192                          READ_DWORD(&regs[26]), READ_DWORD(&regs[27])))
 193                 DBG_FTL(("gp    0x%08x sp    0x%08x s8    0x%08x ra    0x%08x",
 194                          READ_DWORD(&regs[28]), READ_DWORD(&regs[29]),
 195                          READ_DWORD(&regs[30]), READ_DWORD(&regs[31])))
 196                 DBG_FTL(("md    0x%08x|%08x         resvd 0x%08x class 0x%08x",
 197                          READ_DWORD(&xcept->mdhi), READ_DWORD(&xcept->mdlo),
 198                          READ_DWORD(&xcept->reseverd), READ_DWORD(&xcept->xclass)))
 199                 }
 200 /* --------------------------------------------------------------------------
 201    Real XDI Request function
 202    -------------------------------------------------------------------------- */
 203 void request(PISDN_ADAPTER IoAdapter, ENTITY *e)
 204 {
 205         byte i;
 206         diva_os_spin_lock_magic_t irql;
 207 /*
 208  * if the Req field in the entity structure is 0,
 209  * we treat this request as a special function call
 210  */
 211         if (!e->Req)
 212         {
 213                 IDI_SYNC_REQ *syncReq = (IDI_SYNC_REQ *)e;
 214                 switch (e->Rc)
 215                 {
 216 #if defined(DIVA_IDI_RX_DMA)
 217                 case IDI_SYNC_REQ_DMA_DESCRIPTOR_OPERATION: {
 218                         diva_xdi_dma_descriptor_operation_t *pI = \
 219                                 &syncReq->xdi_dma_descriptor_operation.info;
 220                         if (!IoAdapter->dma_map) {
 221                                 pI->operation         = -1;
 222                                 pI->descriptor_number = -1;
 223                                 return;
 224                         }
 225                         diva_os_enter_spin_lock(&IoAdapter->data_spin_lock, &irql, "dma_op");
 226                         if (pI->operation == IDI_SYNC_REQ_DMA_DESCRIPTOR_ALLOC) {
 227                                 pI->descriptor_number = diva_alloc_dma_map_entry(\
 228                                         (struct _diva_dma_map_entry *)IoAdapter->dma_map);
 229                                 if (pI->descriptor_number >= 0) {
 230                                         dword dma_magic;
 231                                         void *local_addr;
 232                                         diva_get_dma_map_entry(\
 233                                                 (struct _diva_dma_map_entry *)IoAdapter->dma_map,
 234                                                 pI->descriptor_number,
 235                                                 &local_addr, &dma_magic);
 236                                         pI->descriptor_address  = local_addr;
 237                                         pI->descriptor_magic    = dma_magic;
 238                                         pI->operation           = 0;
 239                                 } else {
 240                                         pI->operation           = -1;
 241                                 }
 242                         } else if ((pI->operation == IDI_SYNC_REQ_DMA_DESCRIPTOR_FREE) &&
 243                                    (pI->descriptor_number >= 0)) {
 244                                 diva_free_dma_map_entry((struct _diva_dma_map_entry *)IoAdapter->dma_map,
 245                                                         pI->descriptor_number);
 246                                 pI->descriptor_number = -1;
 247                                 pI->operation         = 0;
 248                         } else {
 249                                 pI->descriptor_number = -1;
 250                                 pI->operation         = -1;
 251                         }
 252                         diva_os_leave_spin_lock(&IoAdapter->data_spin_lock, &irql, "dma_op");
 253                 } return;
 254 #endif
 255                 case IDI_SYNC_REQ_XDI_GET_LOGICAL_ADAPTER_NUMBER: {
 256                         diva_xdi_get_logical_adapter_number_s_t *pI = \
 257                                 &syncReq->xdi_logical_adapter_number.info;
 258                         pI->logical_adapter_number = IoAdapter->ANum;
 259                         pI->controller = IoAdapter->ControllerNumber;
 260                         pI->total_controllers = IoAdapter->Properties.Adapters;
 261                 } return;
 262                 case IDI_SYNC_REQ_XDI_GET_CAPI_PARAMS: {
 263                         diva_xdi_get_capi_parameters_t prms, *pI = &syncReq->xdi_capi_prms.info;
 264                         memset(&prms, 0x00, sizeof(prms));
 265                         prms.structure_length = min_t(size_t, sizeof(prms), pI->structure_length);
 266                         memset(pI, 0x00, pI->structure_length);
 267                         prms.flag_dynamic_l1_down    = (IoAdapter->capi_cfg.cfg_1 & \
 268                                                         DIVA_XDI_CAPI_CFG_1_DYNAMIC_L1_ON) ? 1 : 0;
 269                         prms.group_optimization_enabled = (IoAdapter->capi_cfg.cfg_1 & \
 270                                                            DIVA_XDI_CAPI_CFG_1_GROUP_POPTIMIZATION_ON) ? 1 : 0;
 271                         memcpy(pI, &prms, prms.structure_length);
 272                 } return;
 273                 case IDI_SYNC_REQ_XDI_GET_ADAPTER_SDRAM_BAR:
 274                         syncReq->xdi_sdram_bar.info.bar = IoAdapter->sdram_bar;
 275                         return;
 276                 case IDI_SYNC_REQ_XDI_GET_EXTENDED_FEATURES: {
 277                         dword i;
 278                         diva_xdi_get_extended_xdi_features_t *pI =\
 279                                 &syncReq->xdi_extended_features.info;
 280                         pI->buffer_length_in_bytes &= ~0x80000000;
 281                         if (pI->buffer_length_in_bytes && pI->features) {
 282                                 memset(pI->features, 0x00, pI->buffer_length_in_bytes);
 283                         }
 284                         for (i = 0; ((pI->features) && (i < pI->buffer_length_in_bytes) &&
 285                                      (i < DIVA_XDI_EXTENDED_FEATURES_MAX_SZ)); i++) {
 286                                 pI->features[i] = extended_xdi_features[i];
 287                         }
 288                         if ((pI->buffer_length_in_bytes < DIVA_XDI_EXTENDED_FEATURES_MAX_SZ) ||
 289                             (!pI->features)) {
 290                                 pI->buffer_length_in_bytes =\
 291                                         (0x80000000 | DIVA_XDI_EXTENDED_FEATURES_MAX_SZ);
 292                         }
 293                 } return;
 294                 case IDI_SYNC_REQ_XDI_GET_STREAM:
 295                         if (IoAdapter) {
 296                                 diva_xdi_provide_istream_info(&IoAdapter->a,
 297                                                               &syncReq->xdi_stream_info.info);
 298                         } else {
 299                                 syncReq->xdi_stream_info.info.provided_service = 0;
 300                         }
 301                         return;
 302                 case IDI_SYNC_REQ_GET_NAME:
 303                         if (IoAdapter)
 304                         {
 305                                 strcpy(&syncReq->GetName.name[0], IoAdapter->Name);
 306                                 DBG_TRC(("xdi: Adapter %d / Name '%s'",
 307                                          IoAdapter->ANum, IoAdapter->Name))
 308                                         return;
 309                         }
 310                         syncReq->GetName.name[0] = '\0';
 311                         break;
 312                 case IDI_SYNC_REQ_GET_SERIAL:
 313                         if (IoAdapter)
 314                         {
 315                                 syncReq->GetSerial.serial = IoAdapter->serialNo;
 316                                 DBG_TRC(("xdi: Adapter %d / SerialNo %ld",
 317                                          IoAdapter->ANum, IoAdapter->serialNo))
 318                                         return;
 319                         }
 320                         syncReq->GetSerial.serial = 0;
 321                         break;
 322                 case IDI_SYNC_REQ_GET_CARDTYPE:
 323                         if (IoAdapter)
 324                         {
 325                                 syncReq->GetCardType.cardtype = IoAdapter->cardType;
 326                                 DBG_TRC(("xdi: Adapter %d / CardType %ld",
 327                                          IoAdapter->ANum, IoAdapter->cardType))
 328                                         return;
 329                         }
 330                         syncReq->GetCardType.cardtype = 0;
 331                         break;
 332                 case IDI_SYNC_REQ_GET_XLOG:
 333                         if (IoAdapter)
 334                         {
 335                                 pcm_req(IoAdapter, e);
 336                                 return;
 337                         }
 338                         e->Ind = 0;
 339                         break;
 340                 case IDI_SYNC_REQ_GET_DBG_XLOG:
 341                         if (IoAdapter)
 342                         {
 343                                 pcm_req(IoAdapter, e);
 344                                 return;
 345                         }
 346                         e->Ind = 0;
 347                         break;
 348                 case IDI_SYNC_REQ_GET_FEATURES:
 349                         if (IoAdapter)
 350                         {
 351                                 syncReq->GetFeatures.features =
 352                                         (unsigned short)IoAdapter->features;
 353                                 return;
 354                         }
 355                         syncReq->GetFeatures.features = 0;
 356                         break;
 357                 case IDI_SYNC_REQ_PORTDRV_HOOK:
 358                         if (IoAdapter)
 359                         {
 360                                 DBG_TRC(("Xdi:IDI_SYNC_REQ_PORTDRV_HOOK - ignored"))
 361                                         return;
 362                         }
 363                         break;
 364                 }
 365                 if (IoAdapter)
 366                 {
 367                         return;
 368                 }
 369         }
 370         DBG_TRC(("xdi: Id 0x%x / Req 0x%x / Rc 0x%x", e->Id, e->Req, e->Rc))
 371                 if (!IoAdapter)
 372                 {
 373                         DBG_FTL(("xdi: uninitialized Adapter used - ignore request"))
 374                                 return;
 375                 }
 376         diva_os_enter_spin_lock(&IoAdapter->data_spin_lock, &irql, "data_req");
 377 /*
 378  * assign an entity
 379  */
 380         if (!(e->Id & 0x1f))
 381         {
 382                 if (IoAdapter->e_count >= IoAdapter->e_max)
 383                 {
 384                         DBG_FTL(("xdi: all Ids in use (max=%d) --> Req ignored",
 385                                  IoAdapter->e_max))
 386                                 diva_os_leave_spin_lock(&IoAdapter->data_spin_lock, &irql, "data_req");
 387                         return;
 388                 }
 389 /*
 390  * find a new free id
 391  */
 392                 for (i = 1; IoAdapter->e_tbl[i].e; ++i);
 393                 IoAdapter->e_tbl[i].e = e;
 394                 IoAdapter->e_count++;
 395                 e->No = (byte)i;
 396                 e->More = 0;
 397                 e->RCurrent = 0xff;
 398         }
 399         else
 400         {
 401                 i = e->No;
 402         }
 403 /*
 404  * if the entity is still busy, ignore the request call
 405  */
 406         if (e->More & XBUSY)
 407         {
 408                 DBG_FTL(("xdi: Id 0x%x busy --> Req 0x%x ignored", e->Id, e->Req))
 409                         if (!IoAdapter->trapped && IoAdapter->trapFnc)
 410                         {
 411                                 IoAdapter->trapFnc(IoAdapter);
 412                                 /*
 413                                   Firs trap, also notify user if supported
 414                                 */
 415                                 if (IoAdapter->trapped && IoAdapter->os_trap_nfy_Fnc) {
 416                                         (*(IoAdapter->os_trap_nfy_Fnc))(IoAdapter, IoAdapter->ANum);
 417                                 }
 418                         }
 419                 diva_os_leave_spin_lock(&IoAdapter->data_spin_lock, &irql, "data_req");
 420                 return;
 421         }
 422 /*
 423  * initialize transmit status variables
 424  */
 425         e->More |= XBUSY;
 426         e->More &= ~XMOREF;
 427         e->XCurrent = 0;
 428         e->XOffset = 0;
 429 /*
 430  * queue this entity in the adapter request queue
 431  */
 432         IoAdapter->e_tbl[i].next = 0;
 433         if (IoAdapter->head)
 434         {
 435                 IoAdapter->e_tbl[IoAdapter->tail].next = i;
 436                 IoAdapter->tail = i;
 437         }
 438         else
 439         {
 440                 IoAdapter->head = i;
 441                 IoAdapter->tail = i;
 442         }
 443 /*
 444  * queue the DPC to process the request
 445  */
 446         diva_os_schedule_soft_isr(&IoAdapter->req_soft_isr);
 447         diva_os_leave_spin_lock(&IoAdapter->data_spin_lock, &irql, "data_req");
 448 }
 449 /* ---------------------------------------------------------------------
 450    Main DPC routine
 451    --------------------------------------------------------------------- */
 452 void DIDpcRoutine(struct _diva_os_soft_isr *psoft_isr, void *Context) {
 453         PISDN_ADAPTER IoAdapter = (PISDN_ADAPTER)Context;
 454         ADAPTER *a = &IoAdapter->a;
 455         diva_os_atomic_t *pin_dpc = &IoAdapter->in_dpc;
 456         if (diva_os_atomic_increment(pin_dpc) == 1) {
 457                 do {
 458                         if (IoAdapter->tst_irq(a))
 459                         {
 460                                 if (!IoAdapter->Unavailable)
 461                                         IoAdapter->dpc(a);
 462                                 IoAdapter->clr_irq(a);
 463                         }
 464                         IoAdapter->out(a);
 465                 } while (diva_os_atomic_decrement(pin_dpc) > 0);
 466                 /* ----------------------------------------------------------------
 467                    Look for XLOG request (cards with indirect addressing)
 468                    ---------------------------------------------------------------- */
 469                 if (IoAdapter->pcm_pending) {
 470                         struct pc_maint *pcm;
 471                         diva_os_spin_lock_magic_t OldIrql;
 472                         diva_os_enter_spin_lock(&IoAdapter->data_spin_lock,
 473                                                 &OldIrql,
 474                                                 "data_dpc");
 475                         pcm = (struct pc_maint *)IoAdapter->pcm_data;
 476                         switch (IoAdapter->pcm_pending) {
 477                         case 1: /* ask card for XLOG */
 478                                 a->ram_out(a, &IoAdapter->pcm->rc, 0);
 479                                 a->ram_out(a, &IoAdapter->pcm->req, pcm->req);
 480                                 IoAdapter->pcm_pending = 2;
 481                                 break;
 482                         case 2: /* Try to get XLOG from the card */
 483                                 if ((int)(a->ram_in(a, &IoAdapter->pcm->rc))) {
 484                                         a->ram_in_buffer(a, IoAdapter->pcm, pcm, sizeof(*pcm));
 485                                         IoAdapter->pcm_pending = 3;
 486                                 }
 487                                 break;
 488                         case 3: /* let XDI recovery XLOG */
 489                                 break;
 490                         }
 491                         diva_os_leave_spin_lock(&IoAdapter->data_spin_lock,
 492                                                 &OldIrql,
 493                                                 "data_dpc");
 494                 }
 495                 /* ---------------------------------------------------------------- */
 496         }
 497 }
 498 /* --------------------------------------------------------------------------
 499    XLOG interface
 500    -------------------------------------------------------------------------- */
 501 static void
 502 pcm_req(PISDN_ADAPTER IoAdapter, ENTITY *e)
 503 {
 504         diva_os_spin_lock_magic_t OldIrql;
 505         int              i, rc;
 506         ADAPTER         *a = &IoAdapter->a;
 507         struct pc_maint *pcm = (struct pc_maint *)&e->Ind;
 508 /*
 509  * special handling of I/O based card interface
 510  * the memory access isn't an atomic operation !
 511  */
 512         if (IoAdapter->Properties.Card == CARD_MAE)
 513         {
 514                 diva_os_enter_spin_lock(&IoAdapter->data_spin_lock,
 515                                         &OldIrql,
 516                                         "data_pcm_1");
 517                 IoAdapter->pcm_data = (void *)pcm;
 518                 IoAdapter->pcm_pending = 1;
 519                 diva_os_schedule_soft_isr(&IoAdapter->req_soft_isr);
 520                 diva_os_leave_spin_lock(&IoAdapter->data_spin_lock,
 521                                         &OldIrql,
 522                                         "data_pcm_1");
 523                 for (rc = 0, i = (IoAdapter->trapped ? 3000 : 250); !rc && (i > 0); --i)
 524                 {
 525                         diva_os_sleep(1);
 526                         if (IoAdapter->pcm_pending == 3) {
 527                                 diva_os_enter_spin_lock(&IoAdapter->data_spin_lock,
 528                                                         &OldIrql,
 529                                                         "data_pcm_3");
 530                                 IoAdapter->pcm_pending = 0;
 531                                 IoAdapter->pcm_data    = NULL;
 532                                 diva_os_leave_spin_lock(&IoAdapter->data_spin_lock,
 533                                                         &OldIrql,
 534                                                         "data_pcm_3");
 535                                 return;
 536                         }
 537                         diva_os_enter_spin_lock(&IoAdapter->data_spin_lock,
 538                                                 &OldIrql,
 539                                                 "data_pcm_2");
 540                         diva_os_schedule_soft_isr(&IoAdapter->req_soft_isr);
 541                         diva_os_leave_spin_lock(&IoAdapter->data_spin_lock,
 542                                                 &OldIrql,
 543                                                 "data_pcm_2");
 544                 }
 545                 diva_os_enter_spin_lock(&IoAdapter->data_spin_lock,
 546                                         &OldIrql,
 547                                         "data_pcm_4");
 548                 IoAdapter->pcm_pending = 0;
 549                 IoAdapter->pcm_data    = NULL;
 550                 diva_os_leave_spin_lock(&IoAdapter->data_spin_lock,
 551                                         &OldIrql,
 552                                         "data_pcm_4");
 553                 goto Trapped;
 554         }
 555 /*
 556  * memory based shared ram is accessible from different
 557  * processors without disturbing concurrent processes.
 558  */
 559         a->ram_out(a, &IoAdapter->pcm->rc, 0);
 560         a->ram_out(a, &IoAdapter->pcm->req, pcm->req);
 561         for (i = (IoAdapter->trapped ? 3000 : 250); --i > 0;)
 562         {
 563                 diva_os_sleep(1);
 564                 rc = (int)(a->ram_in(a, &IoAdapter->pcm->rc));
 565                 if (rc)
 566                 {
 567                         a->ram_in_buffer(a, IoAdapter->pcm, pcm, sizeof(*pcm));
 568                         return;
 569                 }
 570         }
 571 Trapped:
 572         if (IoAdapter->trapFnc)
 573         {
 574                 int trapped = IoAdapter->trapped;
 575                 IoAdapter->trapFnc(IoAdapter);
 576                 /*
 577                   Firs trap, also notify user if supported
 578                 */
 579                 if (!trapped && IoAdapter->trapped && IoAdapter->os_trap_nfy_Fnc) {
 580                         (*(IoAdapter->os_trap_nfy_Fnc))(IoAdapter, IoAdapter->ANum);
 581                 }
 582         }
 583 }
 584 /*------------------------------------------------------------------*/
 585 /* ram access functions for memory mapped cards                     */
 586 /*------------------------------------------------------------------*/
 587 byte mem_in(ADAPTER *a, void *addr)
 588 {
 589         byte val;
 590         volatile byte __iomem *Base = DIVA_OS_MEM_ATTACH_RAM((PISDN_ADAPTER)a->io);
 591         val = READ_BYTE(Base + (unsigned long)addr);
 592         DIVA_OS_MEM_DETACH_RAM((PISDN_ADAPTER)a->io, Base);
 593         return (val);
 594 }
 595 word mem_inw(ADAPTER *a, void *addr)
 596 {
 597         word val;
 598         volatile byte __iomem *Base = DIVA_OS_MEM_ATTACH_RAM((PISDN_ADAPTER)a->io);
 599         val = READ_WORD((Base + (unsigned long)addr));
 600         DIVA_OS_MEM_DETACH_RAM((PISDN_ADAPTER)a->io, Base);
 601         return (val);
 602 }
 603 void mem_in_dw(ADAPTER *a, void *addr, dword *data, int dwords)
 604 {
 605         volatile byte __iomem *Base = DIVA_OS_MEM_ATTACH_RAM((PISDN_ADAPTER)a->io);
 606         while (dwords--) {
 607                 *data++ = READ_DWORD((Base + (unsigned long)addr));
 608                 addr += 4;
 609         }
 610         DIVA_OS_MEM_DETACH_RAM((PISDN_ADAPTER)a->io, Base);
 611 }
 612 void mem_in_buffer(ADAPTER *a, void *addr, void *buffer, word length)
 613 {
 614         volatile byte __iomem *Base = DIVA_OS_MEM_ATTACH_RAM((PISDN_ADAPTER)a->io);
 615         memcpy_fromio(buffer, (Base + (unsigned long)addr), length);
 616         DIVA_OS_MEM_DETACH_RAM((PISDN_ADAPTER)a->io, Base);
 617 }
 618 void mem_look_ahead(ADAPTER *a, PBUFFER *RBuffer, ENTITY *e)
 619 {
 620         PISDN_ADAPTER IoAdapter = (PISDN_ADAPTER)a->io;
 621         IoAdapter->RBuffer.length = mem_inw(a, &RBuffer->length);
 622         mem_in_buffer(a, RBuffer->P, IoAdapter->RBuffer.P,
 623                       IoAdapter->RBuffer.length);
 624         e->RBuffer = (DBUFFER *)&IoAdapter->RBuffer;
 625 }
 626 void mem_out(ADAPTER *a, void *addr, byte data)
 627 {
 628         volatile byte __iomem *Base = DIVA_OS_MEM_ATTACH_RAM((PISDN_ADAPTER)a->io);
 629         WRITE_BYTE(Base + (unsigned long)addr, data);
 630         DIVA_OS_MEM_DETACH_RAM((PISDN_ADAPTER)a->io, Base);
 631 }
 632 void mem_outw(ADAPTER *a, void *addr, word data)
 633 {
 634         volatile byte __iomem *Base = DIVA_OS_MEM_ATTACH_RAM((PISDN_ADAPTER)a->io);
 635         WRITE_WORD((Base + (unsigned long)addr), data);
 636         DIVA_OS_MEM_DETACH_RAM((PISDN_ADAPTER)a->io, Base);
 637 }
 638 void mem_out_dw(ADAPTER *a, void *addr, const dword *data, int dwords)
 639 {
 640         volatile byte __iomem *Base = DIVA_OS_MEM_ATTACH_RAM((PISDN_ADAPTER)a->io);
 641         while (dwords--) {
 642                 WRITE_DWORD((Base + (unsigned long)addr), *data);
 643                 addr += 4;
 644                 data++;
 645         }
 646         DIVA_OS_MEM_DETACH_RAM((PISDN_ADAPTER)a->io, Base);
 647 }
 648 void mem_out_buffer(ADAPTER *a, void *addr, void *buffer, word length)
 649 {
 650         volatile byte __iomem *Base = DIVA_OS_MEM_ATTACH_RAM((PISDN_ADAPTER)a->io);
 651         memcpy_toio((Base + (unsigned long)addr), buffer, length);
 652         DIVA_OS_MEM_DETACH_RAM((PISDN_ADAPTER)a->io, Base);
 653 }
 654 void mem_inc(ADAPTER *a, void *addr)
 655 {
 656         volatile byte __iomem *Base = DIVA_OS_MEM_ATTACH_RAM((PISDN_ADAPTER)a->io);
 657         byte  x = READ_BYTE(Base + (unsigned long)addr);
 658         WRITE_BYTE(Base + (unsigned long)addr, x + 1);
 659         DIVA_OS_MEM_DETACH_RAM((PISDN_ADAPTER)a->io, Base);
 660 }
 661 /*------------------------------------------------------------------*/
 662 /* ram access functions for io-mapped cards                         */
 663 /*------------------------------------------------------------------*/
 664 byte io_in(ADAPTER *a, void *adr)
 665 {
 666         byte val;
 667         byte __iomem *Port = DIVA_OS_MEM_ATTACH_PORT((PISDN_ADAPTER)a->io);
 668         outppw(Port + 4, (word)(unsigned long)adr);
 669         val = inpp(Port);
 670         DIVA_OS_MEM_DETACH_PORT((PISDN_ADAPTER)a->io, Port);
 671         return (val);
 672 }
 673 word io_inw(ADAPTER *a, void *adr)
 674 {
 675         word val;
 676         byte __iomem *Port = DIVA_OS_MEM_ATTACH_PORT((PISDN_ADAPTER)a->io);
 677         outppw(Port + 4, (word)(unsigned long)adr);
 678         val = inppw(Port);
 679         DIVA_OS_MEM_DETACH_PORT((PISDN_ADAPTER)a->io, Port);
 680         return (val);
 681 }
 682 void io_in_buffer(ADAPTER *a, void *adr, void *buffer, word len)
 683 {
 684         byte __iomem *Port = DIVA_OS_MEM_ATTACH_PORT((PISDN_ADAPTER)a->io);
 685         byte *P = (byte *)buffer;
 686         if ((long)adr & 1) {
 687                 outppw(Port + 4, (word)(unsigned long)adr);
 688                 *P = inpp(Port);
 689                 P++;
 690                 adr = ((byte *) adr) + 1;
 691                 len--;
 692                 if (!len) {
 693                         DIVA_OS_MEM_DETACH_PORT((PISDN_ADAPTER)a->io, Port);
 694                         return;
 695                 }
 696         }
 697         outppw(Port + 4, (word)(unsigned long)adr);
 698         inppw_buffer(Port, P, len + 1);
 699         DIVA_OS_MEM_DETACH_PORT((PISDN_ADAPTER)a->io, Port);
 700 }
 701 void io_look_ahead(ADAPTER *a, PBUFFER *RBuffer, ENTITY *e)
 702 {
 703         byte __iomem *Port = DIVA_OS_MEM_ATTACH_PORT((PISDN_ADAPTER)a->io);
 704         outppw(Port + 4, (word)(unsigned long)RBuffer);
 705         ((PISDN_ADAPTER)a->io)->RBuffer.length = inppw(Port);
 706         inppw_buffer(Port, ((PISDN_ADAPTER)a->io)->RBuffer.P, ((PISDN_ADAPTER)a->io)->RBuffer.length + 1);
 707         e->RBuffer = (DBUFFER *) &(((PISDN_ADAPTER)a->io)->RBuffer);
 708         DIVA_OS_MEM_DETACH_PORT((PISDN_ADAPTER)a->io, Port);
 709 }
 710 void io_out(ADAPTER *a, void *adr, byte data)
 711 {
 712         byte __iomem *Port = DIVA_OS_MEM_ATTACH_PORT((PISDN_ADAPTER)a->io);
 713         outppw(Port + 4, (word)(unsigned long)adr);
 714         outpp(Port, data);
 715         DIVA_OS_MEM_DETACH_PORT((PISDN_ADAPTER)a->io, Port);
 716 }
 717 void io_outw(ADAPTER *a, void *adr, word data)
 718 {
 719         byte __iomem *Port = DIVA_OS_MEM_ATTACH_PORT((PISDN_ADAPTER)a->io);
 720         outppw(Port + 4, (word)(unsigned long)adr);
 721         outppw(Port, data);
 722         DIVA_OS_MEM_DETACH_PORT((PISDN_ADAPTER)a->io, Port);
 723 }
 724 void io_out_buffer(ADAPTER *a, void *adr, void *buffer, word len)
 725 {
 726         byte __iomem *Port = DIVA_OS_MEM_ATTACH_PORT((PISDN_ADAPTER)a->io);
 727         byte *P = (byte *)buffer;
 728         if ((long)adr & 1) {
 729                 outppw(Port + 4, (word)(unsigned long)adr);
 730                 outpp(Port, *P);
 731                 P++;
 732                 adr = ((byte *) adr) + 1;
 733                 len--;
 734                 if (!len) {
 735                         DIVA_OS_MEM_DETACH_PORT((PISDN_ADAPTER)a->io, Port);
 736                         return;
 737                 }
 738         }
 739         outppw(Port + 4, (word)(unsigned long)adr);
 740         outppw_buffer(Port, P, len + 1);
 741         DIVA_OS_MEM_DETACH_PORT((PISDN_ADAPTER)a->io, Port);
 742 }
 743 void io_inc(ADAPTER *a, void *adr)
 744 {
 745         byte x;
 746         byte __iomem *Port = DIVA_OS_MEM_ATTACH_PORT((PISDN_ADAPTER)a->io);
 747         outppw(Port + 4, (word)(unsigned long)adr);
 748         x = inpp(Port);
 749         outppw(Port + 4, (word)(unsigned long)adr);
 750         outpp(Port, x + 1);
 751         DIVA_OS_MEM_DETACH_PORT((PISDN_ADAPTER)a->io, Port);
 752 }
 753 /*------------------------------------------------------------------*/
 754 /* OS specific functions related to queuing of entities             */
 755 /*------------------------------------------------------------------*/
 756 void free_entity(ADAPTER *a, byte e_no)
 757 {
 758         PISDN_ADAPTER IoAdapter;
 759         diva_os_spin_lock_magic_t irql;
 760         IoAdapter = (PISDN_ADAPTER) a->io;
 761         diva_os_enter_spin_lock(&IoAdapter->data_spin_lock, &irql, "data_free");
 762         IoAdapter->e_tbl[e_no].e = NULL;
 763         IoAdapter->e_count--;
 764         diva_os_leave_spin_lock(&IoAdapter->data_spin_lock, &irql, "data_free");
 765 }
 766 void assign_queue(ADAPTER *a, byte e_no, word ref)
 767 {
 768         PISDN_ADAPTER IoAdapter;
 769         diva_os_spin_lock_magic_t irql;
 770         IoAdapter = (PISDN_ADAPTER) a->io;
 771         diva_os_enter_spin_lock(&IoAdapter->data_spin_lock, &irql, "data_assign");
 772         IoAdapter->e_tbl[e_no].assign_ref = ref;
 773         IoAdapter->e_tbl[e_no].next = (byte)IoAdapter->assign;
 774         IoAdapter->assign = e_no;
 775         diva_os_leave_spin_lock(&IoAdapter->data_spin_lock, &irql, "data_assign");
 776 }
 777 byte get_assign(ADAPTER *a, word ref)
 778 {
 779         PISDN_ADAPTER IoAdapter;
 780         diva_os_spin_lock_magic_t irql;
 781         byte e_no;
 782         IoAdapter = (PISDN_ADAPTER) a->io;
 783         diva_os_enter_spin_lock(&IoAdapter->data_spin_lock,
 784                                 &irql,
 785                                 "data_assign_get");
 786         for (e_no = (byte)IoAdapter->assign;
 787             e_no && IoAdapter->e_tbl[e_no].assign_ref != ref;
 788             e_no = IoAdapter->e_tbl[e_no].next);
 789         diva_os_leave_spin_lock(&IoAdapter->data_spin_lock,
 790                                 &irql,
 791                                 "data_assign_get");
 792         return e_no;
 793 }
 794 void req_queue(ADAPTER *a, byte e_no)
 795 {
 796         PISDN_ADAPTER IoAdapter;
 797         diva_os_spin_lock_magic_t irql;
 798         IoAdapter = (PISDN_ADAPTER) a->io;
 799         diva_os_enter_spin_lock(&IoAdapter->data_spin_lock, &irql, "data_req_q");
 800         IoAdapter->e_tbl[e_no].next = 0;
 801         if (IoAdapter->head) {
 802                 IoAdapter->e_tbl[IoAdapter->tail].next = e_no;
 803                 IoAdapter->tail = e_no;
 804         }
 805         else {
 806                 IoAdapter->head = e_no;
 807                 IoAdapter->tail = e_no;
 808         }
 809         diva_os_leave_spin_lock(&IoAdapter->data_spin_lock, &irql, "data_req_q");
 810 }
 811 byte look_req(ADAPTER *a)
 812 {
 813         PISDN_ADAPTER IoAdapter;
 814         IoAdapter = (PISDN_ADAPTER) a->io;
 815         return ((byte)IoAdapter->head);
 816 }
 817 void next_req(ADAPTER *a)
 818 {
 819         PISDN_ADAPTER IoAdapter;
 820         diva_os_spin_lock_magic_t irql;
 821         IoAdapter = (PISDN_ADAPTER) a->io;
 822         diva_os_enter_spin_lock(&IoAdapter->data_spin_lock, &irql, "data_req_next");
 823         IoAdapter->head = IoAdapter->e_tbl[IoAdapter->head].next;
 824         if (!IoAdapter->head) IoAdapter->tail = 0;
 825         diva_os_leave_spin_lock(&IoAdapter->data_spin_lock, &irql, "data_req_next");
 826 }
 827 /*------------------------------------------------------------------*/
 828 /* memory map functions                                             */
 829 /*------------------------------------------------------------------*/
 830 ENTITY *entity_ptr(ADAPTER *a, byte e_no)
 831 {
 832         PISDN_ADAPTER IoAdapter;
 833         IoAdapter = (PISDN_ADAPTER)a->io;
 834         return (IoAdapter->e_tbl[e_no].e);
 835 }
 836 void *PTR_X(ADAPTER *a, ENTITY *e)
 837 {
 838         return ((void *) e->X);
 839 }
 840 void *PTR_R(ADAPTER *a, ENTITY *e)
 841 {
 842         return ((void *) e->R);
 843 }
 844 void *PTR_P(ADAPTER *a, ENTITY *e, void *P)
 845 {
 846         return P;
 847 }
 848 void CALLBACK(ADAPTER *a, ENTITY *e)
 849 {
 850         if (e && e->callback)
 851                 e->callback(e);
 852 }