git.oblomov.eu Git - linux-2.6/blob - drivers/isdn/hardware/eicon/os_bri.c

   1 /* $Id: os_bri.c,v 1.21 2004/03/21 17:26:01 armin Exp $ */
   2
   3 #include "platform.h"
   4 #include "debuglib.h"
   5 #include "cardtype.h"
   6 #include "pc.h"
   7 #include "pr_pc.h"
   8 #include "di_defs.h"
   9 #include "dsp_defs.h"
  10 #include "di.h"
  11 #include "io.h"
  12
  13 #include "xdi_msg.h"
  14 #include "xdi_adapter.h"
  15 #include "os_bri.h"
  16 #include "diva_pci.h"
  17 #include "mi_pc.h"
  18 #include "pc_maint.h"
  19 #include "dsrv_bri.h"
  20
  21 /*
  22 **  IMPORTS
  23 */
  24 extern void prepare_maestra_functions(PISDN_ADAPTER IoAdapter);
  25 extern void diva_xdi_display_adapter_features(int card);
  26 extern int diva_card_read_xlog(diva_os_xdi_adapter_t * a);
  27
  28 /*
  29 **  LOCALS
  30 */
  31 static int bri_bar_length[3] = {
  32         0x80,
  33         0x80,
  34         0x20
  35 };
  36 static int diva_bri_cleanup_adapter(diva_os_xdi_adapter_t * a);
  37 static dword diva_bri_get_serial_number(diva_os_xdi_adapter_t * a);
  38 static int diva_bri_cmd_card_proc(struct _diva_os_xdi_adapter *a,
  39                                   diva_xdi_um_cfg_cmd_t * cmd, int length);
  40 static int diva_bri_reregister_io(diva_os_xdi_adapter_t * a);
  41 static int diva_bri_reset_adapter(PISDN_ADAPTER IoAdapter);
  42 static int diva_bri_write_sdram_block(PISDN_ADAPTER IoAdapter,
  43                                       dword address,
  44                                       const byte * data, dword length);
  45 static int diva_bri_start_adapter(PISDN_ADAPTER IoAdapter,
  46                                   dword start_address, dword features);
  47 static int diva_bri_stop_adapter(diva_os_xdi_adapter_t * a);
  48
  49 static void diva_bri_set_addresses(diva_os_xdi_adapter_t * a)
  50 {
  51         a->resources.pci.mem_type_id[MEM_TYPE_RAM] = 0;
  52         a->resources.pci.mem_type_id[MEM_TYPE_CFG] = 1;
  53         a->resources.pci.mem_type_id[MEM_TYPE_ADDRESS] = 2;
  54         a->resources.pci.mem_type_id[MEM_TYPE_RESET] = 1;
  55         a->resources.pci.mem_type_id[MEM_TYPE_PORT] = 2;
  56         a->resources.pci.mem_type_id[MEM_TYPE_CTLREG] = 2;
  57
  58         a->xdi_adapter.ram = a->resources.pci.addr[0];
  59         a->xdi_adapter.cfg = a->resources.pci.addr[1];
  60         a->xdi_adapter.Address = a->resources.pci.addr[2];
  61
  62         a->xdi_adapter.reset = a->xdi_adapter.cfg;
  63         a->xdi_adapter.port = a->xdi_adapter.Address;
  64
  65         a->xdi_adapter.ctlReg = a->xdi_adapter.port + M_PCI_RESET;
  66
  67         a->xdi_adapter.reset += 0x4C;   /* PLX 9050 !! */
  68 }
  69
  70 /*
  71 **  BAR0 - MEM Addr  - 0x80  - NOT USED
  72 **  BAR1 - I/O Addr  - 0x80
  73 **  BAR2 - I/O Addr  - 0x20
  74 */
  75 int diva_bri_init_card(diva_os_xdi_adapter_t * a)
  76 {
  77         int bar;
  78         dword bar2 = 0, bar2_length = 0xffffffff;
  79         word cmd = 0, cmd_org;
  80         byte Bus, Slot;
  81         void *hdev;
  82         byte __iomem *p;
  83
  84         /*
  85            Set properties
  86          */
  87         a->xdi_adapter.Properties = CardProperties[a->CardOrdinal];
  88         DBG_LOG(("Load %s", a->xdi_adapter.Properties.Name))
  89
  90             /*
  91                Get resources
  92              */
  93             for (bar = 0; bar < 3; bar++) {
  94                 a->resources.pci.bar[bar] =
  95                     divasa_get_pci_bar(a->resources.pci.bus,
  96                                        a->resources.pci.func, bar,
  97                                        a->resources.pci.hdev);
  98                 if (!a->resources.pci.bar[bar]) {
  99                         DBG_ERR(("A: can't get BAR[%d]", bar))
 100                         return (-1);
 101                 }
 102         }
 103
 104         a->resources.pci.irq =
 105             (byte) divasa_get_pci_irq(a->resources.pci.bus,
 106                                       a->resources.pci.func,
 107                                       a->resources.pci.hdev);
 108         if (!a->resources.pci.irq) {
 109                 DBG_ERR(("A: invalid irq"));
 110                 return (-1);
 111         }
 112
 113         /*
 114            Get length of I/O bar 2 - it is different by older
 115            EEPROM version
 116          */
 117         Bus = a->resources.pci.bus;
 118         Slot = a->resources.pci.func;
 119         hdev = a->resources.pci.hdev;
 120
 121         /*
 122            Get plain original values of the BAR2 CDM registers
 123          */
 124         PCIread(Bus, Slot, 0x18, &bar2, sizeof(bar2), hdev);
 125         PCIread(Bus, Slot, 0x04, &cmd_org, sizeof(cmd_org), hdev);
 126         /*
 127            Disable device and get BAR2 length
 128          */
 129         PCIwrite(Bus, Slot, 0x04, &cmd, sizeof(cmd), hdev);
 130         PCIwrite(Bus, Slot, 0x18, &bar2_length, sizeof(bar2_length), hdev);
 131         PCIread(Bus, Slot, 0x18, &bar2_length, sizeof(bar2_length), hdev);
 132         /*
 133            Restore BAR2 and CMD registers
 134          */
 135         PCIwrite(Bus, Slot, 0x18, &bar2, sizeof(bar2), hdev);
 136         PCIwrite(Bus, Slot, 0x04, &cmd_org, sizeof(cmd_org), hdev);
 137
 138         /*
 139            Calculate BAR2 length
 140          */
 141         bar2_length = (~(bar2_length & ~7)) + 1;
 142         DBG_LOG(("BAR[2] length=%lx", bar2_length))
 143
 144             /*
 145                Map and register resources
 146              */
 147             if (!(a->resources.pci.addr[0] =
 148                  divasa_remap_pci_bar(a, 0, a->resources.pci.bar[0],
 149                                       bri_bar_length[0]))) {
 150                 DBG_ERR(("A: BRI, can't map BAR[0]"))
 151                 diva_bri_cleanup_adapter(a);
 152                 return (-1);
 153         }
 154
 155         sprintf(&a->port_name[0], "BRI %02x:%02x",
 156                 a->resources.pci.bus, a->resources.pci.func);
 157
 158         if (diva_os_register_io_port(a, 1, a->resources.pci.bar[1],
 159                                      bri_bar_length[1], &a->port_name[0], 1)) {
 160                 DBG_ERR(("A: BRI, can't register BAR[1]"))
 161                 diva_bri_cleanup_adapter(a);
 162                 return (-1);
 163         }
 164         a->resources.pci.addr[1] = (void *) (unsigned long) a->resources.pci.bar[1];
 165         a->resources.pci.length[1] = bri_bar_length[1];
 166
 167         if (diva_os_register_io_port(a, 1, a->resources.pci.bar[2],
 168                                      bar2_length, &a->port_name[0], 2)) {
 169                 DBG_ERR(("A: BRI, can't register BAR[2]"))
 170                 diva_bri_cleanup_adapter(a);
 171                 return (-1);
 172         }
 173         a->resources.pci.addr[2] = (void *) (unsigned long) a->resources.pci.bar[2];
 174         a->resources.pci.length[2] = bar2_length;
 175
 176         /*
 177            Set all memory areas
 178          */
 179         diva_bri_set_addresses(a);
 180
 181         /*
 182            Get Serial Number
 183          */
 184         a->xdi_adapter.serialNo = diva_bri_get_serial_number(a);
 185
 186         /*
 187            Register I/O ports with correct name now
 188          */
 189         if (diva_bri_reregister_io(a)) {
 190                 diva_bri_cleanup_adapter(a);
 191                 return (-1);
 192         }
 193
 194         /*
 195            Initialize OS dependent objects
 196          */
 197         if (diva_os_initialize_spin_lock
 198             (&a->xdi_adapter.isr_spin_lock, "isr")) {
 199                 diva_bri_cleanup_adapter(a);
 200                 return (-1);
 201         }
 202         if (diva_os_initialize_spin_lock
 203             (&a->xdi_adapter.data_spin_lock, "data")) {
 204                 diva_bri_cleanup_adapter(a);
 205                 return (-1);
 206         }
 207
 208         strcpy(a->xdi_adapter.req_soft_isr.dpc_thread_name, "kdivasbrid");
 209
 210         if (diva_os_initialize_soft_isr(&a->xdi_adapter.req_soft_isr,
 211                                         DIDpcRoutine, &a->xdi_adapter)) {
 212                 diva_bri_cleanup_adapter(a);
 213                 return (-1);
 214         }
 215         /*
 216            Do not initialize second DPC - only one thread will be created
 217          */
 218         a->xdi_adapter.isr_soft_isr.object = a->xdi_adapter.req_soft_isr.object;
 219
 220         /*
 221            Create entity table
 222          */
 223         a->xdi_adapter.Channels = CardProperties[a->CardOrdinal].Channels;
 224         a->xdi_adapter.e_max = CardProperties[a->CardOrdinal].E_info;
 225         a->xdi_adapter.e_tbl = diva_os_malloc(0, a->xdi_adapter.e_max * sizeof(E_INFO));
 226         if (!a->xdi_adapter.e_tbl) {
 227                 diva_bri_cleanup_adapter(a);
 228                 return (-1);
 229         }
 230         memset(a->xdi_adapter.e_tbl, 0x00, a->xdi_adapter.e_max * sizeof(E_INFO));
 231
 232         /*
 233            Set up interface
 234          */
 235         a->xdi_adapter.a.io = &a->xdi_adapter;
 236         a->xdi_adapter.DIRequest = request;
 237         a->interface.cleanup_adapter_proc = diva_bri_cleanup_adapter;
 238         a->interface.cmd_proc = diva_bri_cmd_card_proc;
 239
 240         p = DIVA_OS_MEM_ATTACH_RESET(&a->xdi_adapter);
 241         outpp(p, 0x41);
 242         DIVA_OS_MEM_DETACH_RESET(&a->xdi_adapter, p);
 243
 244         prepare_maestra_functions(&a->xdi_adapter);
 245
 246         a->dsp_mask = 0x00000003;
 247
 248         /*
 249            Set IRQ handler
 250          */
 251         a->xdi_adapter.irq_info.irq_nr = a->resources.pci.irq;
 252         sprintf(a->xdi_adapter.irq_info.irq_name, "DIVA BRI %ld",
 253                 (long) a->xdi_adapter.serialNo);
 254         if (diva_os_register_irq(a, a->xdi_adapter.irq_info.irq_nr,
 255                                  a->xdi_adapter.irq_info.irq_name)) {
 256                 diva_bri_cleanup_adapter(a);
 257                 return (-1);
 258         }
 259         a->xdi_adapter.irq_info.registered = 1;
 260
 261         diva_log_info("%s IRQ:%d SerNo:%d", a->xdi_adapter.Properties.Name,
 262                       a->resources.pci.irq, a->xdi_adapter.serialNo);
 263
 264         return (0);
 265 }
 266
 267
 268 static int diva_bri_cleanup_adapter(diva_os_xdi_adapter_t * a)
 269 {
 270         int i;
 271
 272         if (a->xdi_adapter.Initialized) {
 273                 diva_bri_stop_adapter(a);
 274         }
 275
 276         /*
 277            Remove ISR Handler
 278          */
 279         if (a->xdi_adapter.irq_info.registered) {
 280                 diva_os_remove_irq(a, a->xdi_adapter.irq_info.irq_nr);
 281         }
 282         a->xdi_adapter.irq_info.registered = 0;
 283
 284         if (a->resources.pci.addr[0] && a->resources.pci.bar[0]) {
 285                 divasa_unmap_pci_bar(a->resources.pci.addr[0]);
 286                 a->resources.pci.addr[0] = NULL;
 287                 a->resources.pci.bar[0] = 0;
 288         }
 289
 290         for (i = 1; i < 3; i++) {
 291                 if (a->resources.pci.addr[i] && a->resources.pci.bar[i]) {
 292                         diva_os_register_io_port(a, 0,
 293                                                  a->resources.pci.bar[i],
 294                                                  a->resources.pci.
 295                                                  length[i],
 296                                                  &a->port_name[0], i);
 297                         a->resources.pci.addr[i] = NULL;
 298                         a->resources.pci.bar[i] = 0;
 299                 }
 300         }
 301
 302         /*
 303            Free OS objects
 304          */
 305         diva_os_cancel_soft_isr(&a->xdi_adapter.req_soft_isr);
 306         diva_os_cancel_soft_isr(&a->xdi_adapter.isr_soft_isr);
 307
 308         diva_os_remove_soft_isr(&a->xdi_adapter.req_soft_isr);
 309         a->xdi_adapter.isr_soft_isr.object = NULL;
 310
 311         diva_os_destroy_spin_lock(&a->xdi_adapter.isr_spin_lock, "rm");
 312         diva_os_destroy_spin_lock(&a->xdi_adapter.data_spin_lock, "rm");
 313
 314         /*
 315            Free memory
 316          */
 317         if (a->xdi_adapter.e_tbl) {
 318                 diva_os_free(0, a->xdi_adapter.e_tbl);
 319                 a->xdi_adapter.e_tbl = NULL;
 320         }
 321
 322         return (0);
 323 }
 324
 325 void diva_os_prepare_maestra_functions(PISDN_ADAPTER IoAdapter)
 326 {
 327 }
 328
 329 /*
 330 **  Get serial number
 331 */
 332 static dword diva_bri_get_serial_number(diva_os_xdi_adapter_t * a)
 333 {
 334         dword serNo = 0;
 335         byte __iomem *confIO;
 336         word serHi, serLo;
 337         word __iomem *confMem;
 338
 339         confIO = DIVA_OS_MEM_ATTACH_CFG(&a->xdi_adapter);
 340         serHi = (word) (inppw(&confIO[0x22]) & 0x0FFF);
 341         serLo = (word) (inppw(&confIO[0x26]) & 0x0FFF);
 342         serNo = ((dword) serHi << 16) | (dword) serLo;
 343         DIVA_OS_MEM_DETACH_CFG(&a->xdi_adapter, confIO);
 344
 345         if ((serNo == 0) || (serNo == 0xFFFFFFFF)) {
 346                 DBG_FTL(("W: BRI use BAR[0] to get card serial number"))
 347
 348                 confMem = (word __iomem *)DIVA_OS_MEM_ATTACH_RAM(&a->xdi_adapter);
 349                 serHi = (word) (READ_WORD(&confMem[0x11]) & 0x0FFF);
 350                 serLo = (word) (READ_WORD(&confMem[0x13]) & 0x0FFF);
 351                 serNo = (((dword) serHi) << 16) | ((dword) serLo);
 352                 DIVA_OS_MEM_DETACH_RAM(&a->xdi_adapter, confMem);
 353         }
 354
 355         DBG_LOG(("Serial Number=%ld", serNo))
 356
 357         return (serNo);
 358 }
 359
 360 /*
 361 **  Unregister I/O and register it with new name,
 362 **  based on Serial Number
 363 */
 364 static int diva_bri_reregister_io(diva_os_xdi_adapter_t * a)
 365 {
 366         int i;
 367
 368         for (i = 1; i < 3; i++) {
 369                 diva_os_register_io_port(a, 0, a->resources.pci.bar[i],
 370                                          a->resources.pci.length[i],
 371                                          &a->port_name[0], i);
 372                 a->resources.pci.addr[i] = NULL;
 373         }
 374
 375         sprintf(a->port_name, "DIVA BRI %ld",
 376                 (long) a->xdi_adapter.serialNo);
 377
 378         for (i = 1; i < 3; i++) {
 379                 if (diva_os_register_io_port(a, 1, a->resources.pci.bar[i],
 380                                              a->resources.pci.length[i],
 381                                              &a->port_name[0], i)) {
 382                         DBG_ERR(("A: failed to reregister BAR[%d]", i))
 383                         return (-1);
 384                 }
 385                 a->resources.pci.addr[i] =
 386                     (void *) (unsigned long) a->resources.pci.bar[i];
 387         }
 388
 389         return (0);
 390 }
 391
 392 /*
 393 **  Process command from user mode
 394 */
 395 static int
 396 diva_bri_cmd_card_proc(struct _diva_os_xdi_adapter *a,
 397                        diva_xdi_um_cfg_cmd_t * cmd, int length)
 398 {
 399         int ret = -1;
 400
 401         if (cmd->adapter != a->controller) {
 402                 DBG_ERR(("A: pri_cmd, invalid controller=%d != %d",
 403                          cmd->adapter, a->controller))
 404                 return (-1);
 405         }
 406
 407         switch (cmd->command) {
 408         case DIVA_XDI_UM_CMD_GET_CARD_ORDINAL:
 409                 a->xdi_mbox.data_length = sizeof(dword);
 410                 a->xdi_mbox.data =
 411                     diva_os_malloc(0, a->xdi_mbox.data_length);
 412                 if (a->xdi_mbox.data) {
 413                         *(dword *) a->xdi_mbox.data =
 414                             (dword) a->CardOrdinal;
 415                         a->xdi_mbox.status = DIVA_XDI_MBOX_BUSY;
 416                         ret = 0;
 417                 }
 418                 break;
 419
 420         case DIVA_XDI_UM_CMD_GET_SERIAL_NR:
 421                 a->xdi_mbox.data_length = sizeof(dword);
 422                 a->xdi_mbox.data =
 423                     diva_os_malloc(0, a->xdi_mbox.data_length);
 424                 if (a->xdi_mbox.data) {
 425                         *(dword *) a->xdi_mbox.data =
 426                             (dword) a->xdi_adapter.serialNo;
 427                         a->xdi_mbox.status = DIVA_XDI_MBOX_BUSY;
 428                         ret = 0;
 429                 }
 430                 break;
 431
 432         case DIVA_XDI_UM_CMD_GET_PCI_HW_CONFIG:
 433                 a->xdi_mbox.data_length = sizeof(dword) * 9;
 434                 a->xdi_mbox.data =
 435                     diva_os_malloc(0, a->xdi_mbox.data_length);
 436                 if (a->xdi_mbox.data) {
 437                         int i;
 438                         dword *data = (dword *) a->xdi_mbox.data;
 439
 440                         for (i = 0; i < 8; i++) {
 441                                 *data++ = a->resources.pci.bar[i];
 442                         }
 443                         *data++ = (dword) a->resources.pci.irq;
 444                         a->xdi_mbox.status = DIVA_XDI_MBOX_BUSY;
 445                         ret = 0;
 446                 }
 447                 break;
 448
 449         case DIVA_XDI_UM_CMD_GET_CARD_STATE:
 450                 a->xdi_mbox.data_length = sizeof(dword);
 451                 a->xdi_mbox.data =
 452                     diva_os_malloc(0, a->xdi_mbox.data_length);
 453                 if (a->xdi_mbox.data) {
 454                         dword *data = (dword *) a->xdi_mbox.data;
 455                         if (!a->xdi_adapter.port) {
 456                                 *data = 3;
 457                         } else if (a->xdi_adapter.trapped) {
 458                                 *data = 2;
 459                         } else if (a->xdi_adapter.Initialized) {
 460                                 *data = 1;
 461                         } else {
 462                                 *data = 0;
 463                         }
 464                         a->xdi_mbox.status = DIVA_XDI_MBOX_BUSY;
 465                         ret = 0;
 466                 }
 467                 break;
 468
 469         case DIVA_XDI_UM_CMD_RESET_ADAPTER:
 470                 ret = diva_bri_reset_adapter(&a->xdi_adapter);
 471                 break;
 472
 473         case DIVA_XDI_UM_CMD_WRITE_SDRAM_BLOCK:
 474                 ret = diva_bri_write_sdram_block(&a->xdi_adapter,
 475                                                  cmd->command_data.
 476                                                  write_sdram.offset,
 477                                                  (byte *) & cmd[1],
 478                                                  cmd->command_data.
 479                                                  write_sdram.length);
 480                 break;
 481
 482         case DIVA_XDI_UM_CMD_START_ADAPTER:
 483                 ret = diva_bri_start_adapter(&a->xdi_adapter,
 484                                              cmd->command_data.start.
 485                                              offset,
 486                                              cmd->command_data.start.
 487                                              features);
 488                 break;
 489
 490         case DIVA_XDI_UM_CMD_SET_PROTOCOL_FEATURES:
 491                 a->xdi_adapter.features =
 492                     cmd->command_data.features.features;
 493                 a->xdi_adapter.a.protocol_capabilities =
 494                     a->xdi_adapter.features;
 495                 DBG_TRC(
 496                         ("Set raw protocol features (%08x)",
 497                          a->xdi_adapter.features)) ret = 0;
 498                 break;
 499
 500         case DIVA_XDI_UM_CMD_STOP_ADAPTER:
 501                 ret = diva_bri_stop_adapter(a);
 502                 break;
 503
 504         case DIVA_XDI_UM_CMD_READ_XLOG_ENTRY:
 505                 ret = diva_card_read_xlog(a);
 506                 break;
 507
 508         default:
 509                 DBG_ERR(
 510                         ("A: A(%d) invalid cmd=%d", a->controller,
 511                          cmd->command))}
 512
 513         return (ret);
 514 }
 515
 516 static int diva_bri_reset_adapter(PISDN_ADAPTER IoAdapter)
 517 {
 518         byte __iomem *addrHi, *addrLo, *ioaddr;
 519         dword i;
 520         byte __iomem *Port;
 521
 522         if (!IoAdapter->port) {
 523                 return (-1);
 524         }
 525         if (IoAdapter->Initialized) {
 526                 DBG_ERR(("A: A(%d) can't reset BRI adapter - please stop first",
 527                          IoAdapter->ANum)) return (-1);
 528         }
 529         (*(IoAdapter->rstFnc)) (IoAdapter);
 530         diva_os_wait(100);
 531         Port = DIVA_OS_MEM_ATTACH_PORT(IoAdapter);
 532         addrHi = Port +
 533             ((IoAdapter->Properties.Bus == BUS_PCI) ? M_PCI_ADDRH : ADDRH);
 534         addrLo = Port + ADDR;
 535         ioaddr = Port + DATA;
 536         /*
 537            recover
 538          */
 539         outpp(addrHi, (byte) 0);
 540         outppw(addrLo, (word) 0);
 541         outppw(ioaddr, (word) 0);
 542         /*
 543            clear shared memory
 544          */
 545         outpp(addrHi,
 546               (byte) (
 547                       (IoAdapter->MemoryBase + IoAdapter->MemorySize -
 548                        BRI_SHARED_RAM_SIZE) >> 16));
 549         outppw(addrLo, 0);
 550         for (i = 0; i < 0x8000; outppw(ioaddr, 0), ++i);
 551         diva_os_wait(100);
 552
 553         /*
 554            clear signature
 555          */
 556         outpp(addrHi,
 557               (byte) (
 558                       (IoAdapter->MemoryBase + IoAdapter->MemorySize -
 559                        BRI_SHARED_RAM_SIZE) >> 16));
 560         outppw(addrLo, 0x1e);
 561         outpp(ioaddr, 0);
 562         outpp(ioaddr, 0);
 563
 564         outpp(addrHi, (byte) 0);
 565         outppw(addrLo, (word) 0);
 566         outppw(ioaddr, (word) 0);
 567
 568         DIVA_OS_MEM_DETACH_PORT(IoAdapter, Port);
 569
 570         /*
 571            Forget all outstanding entities
 572          */
 573         IoAdapter->e_count = 0;
 574         if (IoAdapter->e_tbl) {
 575                 memset(IoAdapter->e_tbl, 0x00,
 576                        IoAdapter->e_max * sizeof(E_INFO));
 577         }
 578         IoAdapter->head = 0;
 579         IoAdapter->tail = 0;
 580         IoAdapter->assign = 0;
 581         IoAdapter->trapped = 0;
 582
 583         memset(&IoAdapter->a.IdTable[0], 0x00,
 584                sizeof(IoAdapter->a.IdTable));
 585         memset(&IoAdapter->a.IdTypeTable[0], 0x00,
 586                sizeof(IoAdapter->a.IdTypeTable));
 587         memset(&IoAdapter->a.FlowControlIdTable[0], 0x00,
 588                sizeof(IoAdapter->a.FlowControlIdTable));
 589         memset(&IoAdapter->a.FlowControlSkipTable[0], 0x00,
 590                sizeof(IoAdapter->a.FlowControlSkipTable));
 591         memset(&IoAdapter->a.misc_flags_table[0], 0x00,
 592                sizeof(IoAdapter->a.misc_flags_table));
 593         memset(&IoAdapter->a.rx_stream[0], 0x00,
 594                sizeof(IoAdapter->a.rx_stream));
 595         memset(&IoAdapter->a.tx_stream[0], 0x00,
 596                sizeof(IoAdapter->a.tx_stream));
 597         memset(&IoAdapter->a.tx_pos[0], 0x00, sizeof(IoAdapter->a.tx_pos));
 598         memset(&IoAdapter->a.rx_pos[0], 0x00, sizeof(IoAdapter->a.rx_pos));
 599
 600         return (0);
 601 }
 602
 603 static int
 604 diva_bri_write_sdram_block(PISDN_ADAPTER IoAdapter,
 605                            dword address, const byte * data, dword length)
 606 {
 607         byte __iomem *addrHi, *addrLo, *ioaddr;
 608         byte __iomem *Port;
 609
 610         if (!IoAdapter->port) {
 611                 return (-1);
 612         }
 613
 614         Port = DIVA_OS_MEM_ATTACH_PORT(IoAdapter);
 615         addrHi = Port +
 616             ((IoAdapter->Properties.Bus == BUS_PCI) ? M_PCI_ADDRH : ADDRH);
 617         addrLo = Port + ADDR;
 618         ioaddr = Port + DATA;
 619
 620         while (length--) {
 621                 outpp(addrHi, (word) (address >> 16));
 622                 outppw(addrLo, (word) (address & 0x0000ffff));
 623                 outpp(ioaddr, *data++);
 624                 address++;
 625         }
 626
 627         DIVA_OS_MEM_DETACH_PORT(IoAdapter, Port);
 628         return (0);
 629 }
 630
 631 static int
 632 diva_bri_start_adapter(PISDN_ADAPTER IoAdapter,
 633                        dword start_address, dword features)
 634 {
 635         byte __iomem *Port;
 636         dword i, test;
 637         byte __iomem *addrHi, *addrLo, *ioaddr;
 638         int started = 0;
 639         ADAPTER *a = &IoAdapter->a;
 640
 641         if (IoAdapter->Initialized) {
 642                 DBG_ERR(
 643                         ("A: A(%d) bri_start_adapter, adapter already running",
 644                          IoAdapter->ANum)) return (-1);
 645         }
 646         if (!IoAdapter->port) {
 647                 DBG_ERR(("A: A(%d) bri_start_adapter, adapter not mapped",
 648                          IoAdapter->ANum)) return (-1);
 649         }
 650
 651         sprintf(IoAdapter->Name, "A(%d)", (int) IoAdapter->ANum);
 652         DBG_LOG(("A(%d) start BRI", IoAdapter->ANum))
 653
 654         Port = DIVA_OS_MEM_ATTACH_PORT(IoAdapter);
 655         addrHi = Port +
 656             ((IoAdapter->Properties.Bus == BUS_PCI) ? M_PCI_ADDRH : ADDRH);
 657         addrLo = Port + ADDR;
 658         ioaddr = Port + DATA;
 659
 660         outpp(addrHi,
 661               (byte) (
 662                       (IoAdapter->MemoryBase + IoAdapter->MemorySize -
 663                        BRI_SHARED_RAM_SIZE) >> 16));
 664         outppw(addrLo, 0x1e);
 665         outppw(ioaddr, 0x00);
 666         DIVA_OS_MEM_DETACH_PORT(IoAdapter, Port);
 667
 668         /*
 669            start the protocol code
 670          */
 671         Port = DIVA_OS_MEM_ATTACH_CTLREG(IoAdapter);
 672         outpp(Port, 0x08);
 673         DIVA_OS_MEM_DETACH_CTLREG(IoAdapter, Port);
 674
 675         Port = DIVA_OS_MEM_ATTACH_PORT(IoAdapter);
 676         addrHi = Port +
 677             ((IoAdapter->Properties.Bus == BUS_PCI) ? M_PCI_ADDRH : ADDRH);
 678         addrLo = Port + ADDR;
 679         ioaddr = Port + DATA;
 680         /*
 681            wait for signature (max. 3 seconds)
 682          */
 683         for (i = 0; i < 300; ++i) {
 684                 diva_os_wait(10);
 685                 outpp(addrHi,
 686                       (byte) (
 687                               (IoAdapter->MemoryBase +
 688                                IoAdapter->MemorySize -
 689                                BRI_SHARED_RAM_SIZE) >> 16));
 690                 outppw(addrLo, 0x1e);
 691                 test = (dword) inppw(ioaddr);
 692                 if (test == 0x4447) {
 693                         DBG_LOG(
 694                                 ("Protocol startup time %d.%02d seconds",
 695                                  (i / 100), (i % 100)))
 696                         started = 1;
 697                         break;
 698                 }
 699         }
 700         DIVA_OS_MEM_DETACH_PORT(IoAdapter, Port);
 701
 702         if (!started) {
 703                 DBG_FTL(("A: A(%d) %s: Adapter selftest failed 0x%04X",
 704                          IoAdapter->ANum, IoAdapter->Properties.Name,
 705                          test))
 706                 (*(IoAdapter->trapFnc)) (IoAdapter);
 707                 return (-1);
 708         }
 709
 710         IoAdapter->Initialized = 1;
 711
 712         /*
 713            Check Interrupt
 714          */
 715         IoAdapter->IrqCount = 0;
 716         a->ReadyInt = 1;
 717
 718         if (IoAdapter->reset) {
 719                 Port = DIVA_OS_MEM_ATTACH_RESET(IoAdapter);
 720                 outpp(Port, 0x41);
 721                 DIVA_OS_MEM_DETACH_RESET(IoAdapter, Port);
 722         }
 723
 724         a->ram_out(a, &PR_RAM->ReadyInt, 1);
 725         for (i = 0; ((!IoAdapter->IrqCount) && (i < 100)); i++) {
 726                 diva_os_wait(10);
 727         }
 728         if (!IoAdapter->IrqCount) {
 729                 DBG_ERR(
 730                         ("A: A(%d) interrupt test failed",
 731                          IoAdapter->ANum))
 732                 IoAdapter->Initialized = 0;
 733                 IoAdapter->stop(IoAdapter);
 734                 return (-1);
 735         }
 736
 737         IoAdapter->Properties.Features = (word) features;
 738         diva_xdi_display_adapter_features(IoAdapter->ANum);
 739         DBG_LOG(("A(%d) BRI adapter successfull started", IoAdapter->ANum))
 740             /*
 741                Register with DIDD
 742              */
 743         diva_xdi_didd_register_adapter(IoAdapter->ANum);
 744
 745         return (0);
 746 }
 747
 748 static void diva_bri_clear_interrupts(diva_os_xdi_adapter_t * a)
 749 {
 750         PISDN_ADAPTER IoAdapter = &a->xdi_adapter;
 751
 752         /*
 753            clear any pending interrupt
 754          */
 755         IoAdapter->disIrq(IoAdapter);
 756
 757         IoAdapter->tst_irq(&IoAdapter->a);
 758         IoAdapter->clr_irq(&IoAdapter->a);
 759         IoAdapter->tst_irq(&IoAdapter->a);
 760
 761         /*
 762            kill pending dpcs
 763          */
 764         diva_os_cancel_soft_isr(&IoAdapter->req_soft_isr);
 765         diva_os_cancel_soft_isr(&IoAdapter->isr_soft_isr);
 766 }
 767
 768 /*
 769 **  Stop card
 770 */
 771 static int diva_bri_stop_adapter(diva_os_xdi_adapter_t * a)
 772 {
 773         PISDN_ADAPTER IoAdapter = &a->xdi_adapter;
 774         int i = 100;
 775
 776         if (!IoAdapter->port) {
 777                 return (-1);
 778         }
 779         if (!IoAdapter->Initialized) {
 780                 DBG_ERR(("A: A(%d) can't stop BRI adapter - not running",
 781                          IoAdapter->ANum))
 782                 return (-1);    /* nothing to stop */
 783         }
 784         IoAdapter->Initialized = 0;
 785
 786         /*
 787            Disconnect Adapter from DIDD
 788          */
 789         diva_xdi_didd_remove_adapter(IoAdapter->ANum);
 790
 791         /*
 792            Stop interrupts
 793          */
 794         a->clear_interrupts_proc = diva_bri_clear_interrupts;
 795         IoAdapter->a.ReadyInt = 1;
 796         IoAdapter->a.ram_inc(&IoAdapter->a, &PR_RAM->ReadyInt);
 797         do {
 798                 diva_os_sleep(10);
 799         } while (i-- && a->clear_interrupts_proc);
 800         if (a->clear_interrupts_proc) {
 801                 diva_bri_clear_interrupts(a);
 802                 a->clear_interrupts_proc = NULL;
 803                 DBG_ERR(("A: A(%d) no final interrupt from BRI adapter",
 804                          IoAdapter->ANum))
 805         }
 806         IoAdapter->a.ReadyInt = 0;
 807
 808         /*
 809            Stop and reset adapter
 810          */
 811         IoAdapter->stop(IoAdapter);
 812
 813         return (0);
 814 }