903356547b79c715a896253ecd0658e74f6b2c29
[linux-2.6.git] / drivers / isdn / hardware / eicon / os_pri.c
1 /* $Id: os_pri.c,v 1.32 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_pri.h"
16 #include "diva_pci.h"
17 #include "mi_pc.h"
18 #include "pc_maint.h"
19 #include "dsp_tst.h"
20 #include "diva_dma.h"
21 #include "dsrv_pri.h"
22
23 /* --------------------------------------------------------------------------
24    OS Dependent part of XDI driver for DIVA PRI Adapter
25
26    DSP detection/validation by Anthony Booth (Eicon Networks, www.eicon.com)
27 -------------------------------------------------------------------------- */
28
29 #define DIVA_PRI_NO_PCI_BIOS_WORKAROUND 1
30
31 extern int diva_card_read_xlog(diva_os_xdi_adapter_t * a);
32
33 /*
34 **  IMPORTS
35 */
36 extern void prepare_pri_functions(PISDN_ADAPTER IoAdapter);
37 extern void prepare_pri2_functions(PISDN_ADAPTER IoAdapter);
38 extern void diva_xdi_display_adapter_features(int card);
39
40 static int diva_pri_cleanup_adapter(diva_os_xdi_adapter_t * a);
41 static int diva_pri_cmd_card_proc(struct _diva_os_xdi_adapter *a,
42                                   diva_xdi_um_cfg_cmd_t * cmd, int length);
43 static int pri_get_serial_number(diva_os_xdi_adapter_t * a);
44 static int diva_pri_stop_adapter(diva_os_xdi_adapter_t * a);
45 static dword diva_pri_detect_dsps(diva_os_xdi_adapter_t * a);
46
47 /*
48 **  Check card revision
49 */
50 static int pri_is_rev_2_card(int card_ordinal)
51 {
52         switch (card_ordinal) {
53         case CARDTYPE_DIVASRV_P_30M_V2_PCI:
54         case CARDTYPE_DIVASRV_VOICE_P_30M_V2_PCI:
55                 return (1);
56         }
57         return (0);
58 }
59
60 static void diva_pri_set_addresses(diva_os_xdi_adapter_t * a)
61 {
62         a->resources.pci.mem_type_id[MEM_TYPE_ADDRESS] = 0;
63         a->resources.pci.mem_type_id[MEM_TYPE_CONTROL] = 2;
64         a->resources.pci.mem_type_id[MEM_TYPE_CONFIG] = 4;
65         a->resources.pci.mem_type_id[MEM_TYPE_RAM] = 0;
66         a->resources.pci.mem_type_id[MEM_TYPE_RESET] = 2;
67         a->resources.pci.mem_type_id[MEM_TYPE_CFG] = 4;
68         a->resources.pci.mem_type_id[MEM_TYPE_PROM] = 3;
69         
70         a->xdi_adapter.Address = a->resources.pci.addr[0];
71         a->xdi_adapter.Control = a->resources.pci.addr[2];
72         a->xdi_adapter.Config = a->resources.pci.addr[4];
73
74         a->xdi_adapter.ram = a->resources.pci.addr[0];
75         a->xdi_adapter.ram += MP_SHARED_RAM_OFFSET;
76
77         a->xdi_adapter.reset = a->resources.pci.addr[2];
78         a->xdi_adapter.reset += MP_RESET;
79
80         a->xdi_adapter.cfg = a->resources.pci.addr[4];
81         a->xdi_adapter.cfg += MP_IRQ_RESET;
82
83         a->xdi_adapter.sdram_bar = a->resources.pci.bar[0];
84
85         a->xdi_adapter.prom = a->resources.pci.addr[3];
86 }
87
88 /*
89 **  BAR0 - SDRAM, MP_MEMORY_SIZE, MP2_MEMORY_SIZE by Rev.2
90 **  BAR1 - DEVICES,                             0x1000
91 **  BAR2 - CONTROL (REG), 0x2000
92 **  BAR3 - FLASH (REG),         0x8000
93 **  BAR4 - CONFIG (CFG),        0x1000
94 */
95 int diva_pri_init_card(diva_os_xdi_adapter_t * a)
96 {
97         int bar = 0;
98         int pri_rev_2;
99         unsigned long bar_length[5] = {
100                 MP_MEMORY_SIZE,
101                 0x1000,
102                 0x2000,
103                 0x8000,
104                 0x1000
105         };
106
107         pri_rev_2 = pri_is_rev_2_card(a->CardOrdinal);
108
109         if (pri_rev_2) {
110                 bar_length[0] = MP2_MEMORY_SIZE;
111         }
112         /*
113            Set properties
114          */
115         a->xdi_adapter.Properties = CardProperties[a->CardOrdinal];
116         DBG_LOG(("Load %s", a->xdi_adapter.Properties.Name))
117
118         /*
119            First initialization step: get and check hardware resoures.
120            Do not map resources and do not acecess card at this step
121          */
122         for (bar = 0; bar < 5; bar++) {
123                 a->resources.pci.bar[bar] =
124                     divasa_get_pci_bar(a->resources.pci.bus,
125                                        a->resources.pci.func, bar,
126                                        a->resources.pci.hdev);
127                 if (!a->resources.pci.bar[bar]
128                     || (a->resources.pci.bar[bar] == 0xFFFFFFF0)) {
129                         DBG_ERR(("A: invalid bar[%d]=%08x", bar,
130                                  a->resources.pci.bar[bar]))
131                         return (-1);
132                 }
133         }
134         a->resources.pci.irq =
135             (byte) divasa_get_pci_irq(a->resources.pci.bus,
136                                       a->resources.pci.func,
137                                       a->resources.pci.hdev);
138         if (!a->resources.pci.irq) {
139                 DBG_ERR(("A: invalid irq"));
140                 return (-1);
141         }
142
143         /*
144            Map all BAR's
145          */
146         for (bar = 0; bar < 5; bar++) {
147                 a->resources.pci.addr[bar] =
148                     divasa_remap_pci_bar(a, bar, a->resources.pci.bar[bar],
149                                          bar_length[bar]);
150                 if (!a->resources.pci.addr[bar]) {
151                         DBG_ERR(("A: A(%d), can't map bar[%d]",
152                                  a->controller, bar))
153                         diva_pri_cleanup_adapter(a);
154                         return (-1);
155                 }
156         }
157
158         /*
159            Set all memory areas
160          */
161         diva_pri_set_addresses(a);
162
163         /*
164            Get Serial Number of this adapter
165          */
166         if (pri_get_serial_number(a)) {
167                 dword serNo;
168                 serNo = a->resources.pci.bar[1] & 0xffff0000;
169                 serNo |= ((dword) a->resources.pci.bus) << 8;
170                 serNo += (a->resources.pci.func + a->controller + 1);
171                 a->xdi_adapter.serialNo = serNo & ~0xFF000000;
172                 DBG_ERR(("A: A(%d) can't get Serial Number, generated serNo=%ld",
173                          a->controller, a->xdi_adapter.serialNo))
174         }
175
176
177         /*
178            Initialize os objects
179          */
180         if (diva_os_initialize_spin_lock(&a->xdi_adapter.isr_spin_lock, "isr")) {
181                 diva_pri_cleanup_adapter(a);
182                 return (-1);
183         }
184         if (diva_os_initialize_spin_lock
185             (&a->xdi_adapter.data_spin_lock, "data")) {
186                 diva_pri_cleanup_adapter(a);
187                 return (-1);
188         }
189
190         strcpy(a->xdi_adapter.req_soft_isr.dpc_thread_name, "kdivasprid");
191
192         if (diva_os_initialize_soft_isr(&a->xdi_adapter.req_soft_isr,
193                                         DIDpcRoutine, &a->xdi_adapter)) {
194                 diva_pri_cleanup_adapter(a);
195                 return (-1);
196         }
197
198         /*
199            Do not initialize second DPC - only one thread will be created
200          */
201         a->xdi_adapter.isr_soft_isr.object =
202             a->xdi_adapter.req_soft_isr.object;
203
204         /*
205            Next step of card initialization:
206            set up all interface pointers
207          */
208         a->xdi_adapter.Channels = CardProperties[a->CardOrdinal].Channels;
209         a->xdi_adapter.e_max = CardProperties[a->CardOrdinal].E_info;
210
211         a->xdi_adapter.e_tbl =
212             diva_os_malloc(0, a->xdi_adapter.e_max * sizeof(E_INFO));
213         if (!a->xdi_adapter.e_tbl) {
214                 diva_pri_cleanup_adapter(a);
215                 return (-1);
216         }
217         memset(a->xdi_adapter.e_tbl, 0x00, a->xdi_adapter.e_max * sizeof(E_INFO));
218
219         a->xdi_adapter.a.io = &a->xdi_adapter;
220         a->xdi_adapter.DIRequest = request;
221         a->interface.cleanup_adapter_proc = diva_pri_cleanup_adapter;
222         a->interface.cmd_proc = diva_pri_cmd_card_proc;
223
224         if (pri_rev_2) {
225                 prepare_pri2_functions(&a->xdi_adapter);
226         } else {
227                 prepare_pri_functions(&a->xdi_adapter);
228         }
229
230         a->dsp_mask = diva_pri_detect_dsps(a);
231
232         /*
233            Allocate DMA map
234          */
235         if (pri_rev_2) {
236                 diva_init_dma_map(a->resources.pci.hdev,
237                                   (struct _diva_dma_map_entry **) &a->xdi_adapter.dma_map, 32);
238         }
239
240         /*
241            Set IRQ handler
242          */
243         a->xdi_adapter.irq_info.irq_nr = a->resources.pci.irq;
244         sprintf(a->xdi_adapter.irq_info.irq_name,
245                 "DIVA PRI %ld", (long) a->xdi_adapter.serialNo);
246
247         if (diva_os_register_irq(a, a->xdi_adapter.irq_info.irq_nr,
248                                  a->xdi_adapter.irq_info.irq_name)) {
249                 diva_pri_cleanup_adapter(a);
250                 return (-1);
251         }
252         a->xdi_adapter.irq_info.registered = 1;
253
254         diva_log_info("%s IRQ:%d SerNo:%d", a->xdi_adapter.Properties.Name,
255                       a->resources.pci.irq, a->xdi_adapter.serialNo);
256
257         return (0);
258 }
259
260 static int diva_pri_cleanup_adapter(diva_os_xdi_adapter_t * a)
261 {
262         int bar = 0;
263
264         /*
265            Stop Adapter if adapter is running
266          */
267         if (a->xdi_adapter.Initialized) {
268                 diva_pri_stop_adapter(a);
269         }
270
271         /*
272            Remove ISR Handler
273          */
274         if (a->xdi_adapter.irq_info.registered) {
275                 diva_os_remove_irq(a, a->xdi_adapter.irq_info.irq_nr);
276         }
277         a->xdi_adapter.irq_info.registered = 0;
278
279         /*
280            Step 1: unmap all BAR's, if any was mapped
281          */
282         for (bar = 0; bar < 5; bar++) {
283                 if (a->resources.pci.bar[bar]
284                     && a->resources.pci.addr[bar]) {
285                         divasa_unmap_pci_bar(a->resources.pci.addr[bar]);
286                         a->resources.pci.bar[bar] = 0;
287                         a->resources.pci.addr[bar] = NULL;
288                 }
289         }
290
291         /*
292            Free OS objects
293          */
294         diva_os_cancel_soft_isr(&a->xdi_adapter.isr_soft_isr);
295         diva_os_cancel_soft_isr(&a->xdi_adapter.req_soft_isr);
296
297         diva_os_remove_soft_isr(&a->xdi_adapter.req_soft_isr);
298         a->xdi_adapter.isr_soft_isr.object = NULL;
299
300         diva_os_destroy_spin_lock(&a->xdi_adapter.isr_spin_lock, "rm");
301         diva_os_destroy_spin_lock(&a->xdi_adapter.data_spin_lock, "rm");
302
303         /*
304            Free memory accupied by XDI adapter
305          */
306         if (a->xdi_adapter.e_tbl) {
307                 diva_os_free(0, a->xdi_adapter.e_tbl);
308                 a->xdi_adapter.e_tbl = NULL;
309         }
310         a->xdi_adapter.Channels = 0;
311         a->xdi_adapter.e_max = 0;
312
313
314         /*
315            Free adapter DMA map
316          */
317         diva_free_dma_map(a->resources.pci.hdev,
318                           (struct _diva_dma_map_entry *) a->xdi_adapter.
319                           dma_map);
320         a->xdi_adapter.dma_map = NULL;
321
322
323         /*
324            Detach this adapter from debug driver
325          */
326
327         return (0);
328 }
329
330 /*
331 **  Activate On Board Boot Loader
332 */
333 static int diva_pri_reset_adapter(PISDN_ADAPTER IoAdapter)
334 {
335         dword i;
336         struct mp_load __iomem *boot;
337
338         if (!IoAdapter->Address || !IoAdapter->reset) {
339                 return (-1);
340         }
341         if (IoAdapter->Initialized) {
342                 DBG_ERR(("A: A(%d) can't reset PRI adapter - please stop first",
343                          IoAdapter->ANum))
344                 return (-1);
345         }
346
347         boot = (struct mp_load __iomem *) DIVA_OS_MEM_ATTACH_ADDRESS(IoAdapter);
348         WRITE_DWORD(&boot->err, 0);
349         DIVA_OS_MEM_DETACH_ADDRESS(IoAdapter, boot);
350
351         IoAdapter->rstFnc(IoAdapter);
352
353         diva_os_wait(10);
354
355         boot = (struct mp_load __iomem *) DIVA_OS_MEM_ATTACH_ADDRESS(IoAdapter);
356         i = READ_DWORD(&boot->live);
357
358         diva_os_wait(10);
359         if (i == READ_DWORD(&boot->live)) {
360                 DIVA_OS_MEM_DETACH_ADDRESS(IoAdapter, boot);
361                 DBG_ERR(("A: A(%d) CPU on PRI %ld is not alive!",
362                          IoAdapter->ANum, IoAdapter->serialNo))
363                 return (-1);
364         }
365         if (READ_DWORD(&boot->err)) {
366                 DBG_ERR(("A: A(%d) PRI %ld Board Selftest failed, error=%08lx",
367                          IoAdapter->ANum, IoAdapter->serialNo,
368                          READ_DWORD(&boot->err)))
369                 DIVA_OS_MEM_DETACH_ADDRESS(IoAdapter, boot);
370                 return (-1);
371         }
372         DIVA_OS_MEM_DETACH_ADDRESS(IoAdapter, boot);
373
374         /*
375            Forget all outstanding entities
376          */
377         IoAdapter->e_count = 0;
378         if (IoAdapter->e_tbl) {
379                 memset(IoAdapter->e_tbl, 0x00,
380                        IoAdapter->e_max * sizeof(E_INFO));
381         }
382         IoAdapter->head = 0;
383         IoAdapter->tail = 0;
384         IoAdapter->assign = 0;
385         IoAdapter->trapped = 0;
386
387         memset(&IoAdapter->a.IdTable[0], 0x00,
388                sizeof(IoAdapter->a.IdTable));
389         memset(&IoAdapter->a.IdTypeTable[0], 0x00,
390                sizeof(IoAdapter->a.IdTypeTable));
391         memset(&IoAdapter->a.FlowControlIdTable[0], 0x00,
392                sizeof(IoAdapter->a.FlowControlIdTable));
393         memset(&IoAdapter->a.FlowControlSkipTable[0], 0x00,
394                sizeof(IoAdapter->a.FlowControlSkipTable));
395         memset(&IoAdapter->a.misc_flags_table[0], 0x00,
396                sizeof(IoAdapter->a.misc_flags_table));
397         memset(&IoAdapter->a.rx_stream[0], 0x00,
398                sizeof(IoAdapter->a.rx_stream));
399         memset(&IoAdapter->a.tx_stream[0], 0x00,
400                sizeof(IoAdapter->a.tx_stream));
401         memset(&IoAdapter->a.tx_pos[0], 0x00, sizeof(IoAdapter->a.tx_pos));
402         memset(&IoAdapter->a.rx_pos[0], 0x00, sizeof(IoAdapter->a.rx_pos));
403
404         return (0);
405 }
406
407 static int
408 diva_pri_write_sdram_block(PISDN_ADAPTER IoAdapter,
409                            dword address,
410                            const byte * data, dword length, dword limit)
411 {
412         byte __iomem *p = DIVA_OS_MEM_ATTACH_ADDRESS(IoAdapter);
413         byte __iomem *mem = p;
414
415         if (((address + length) >= limit) || !mem) {
416                 DIVA_OS_MEM_DETACH_ADDRESS(IoAdapter, p);
417                 DBG_ERR(("A: A(%d) write PRI address=0x%08lx",
418                          IoAdapter->ANum, address + length))
419                 return (-1);
420         }
421         mem += address;
422
423         /* memcpy_toio(), maybe? */
424         while (length--) {
425                 WRITE_BYTE(mem++, *data++);
426         }
427
428         DIVA_OS_MEM_DETACH_ADDRESS(IoAdapter, p);
429         return (0);
430 }
431
432 static int
433 diva_pri_start_adapter(PISDN_ADAPTER IoAdapter,
434                        dword start_address, dword features)
435 {
436         dword i;
437         int started = 0;
438         byte __iomem *p;
439         struct mp_load __iomem *boot = (struct mp_load __iomem *) DIVA_OS_MEM_ATTACH_ADDRESS(IoAdapter);
440         ADAPTER *a = &IoAdapter->a;
441
442         if (IoAdapter->Initialized) {
443                 DIVA_OS_MEM_DETACH_ADDRESS(IoAdapter, boot);
444                 DBG_ERR(("A: A(%d) pri_start_adapter, adapter already running",
445                          IoAdapter->ANum))
446                 return (-1);
447         }
448         if (!boot) {
449                 DIVA_OS_MEM_DETACH_ADDRESS(IoAdapter, boot);
450                 DBG_ERR(("A: PRI %ld can't start, adapter not mapped",
451                          IoAdapter->serialNo))
452                 return (-1);
453         }
454
455         sprintf(IoAdapter->Name, "A(%d)", (int) IoAdapter->ANum);
456         DBG_LOG(("A(%d) start PRI at 0x%08lx", IoAdapter->ANum,
457                  start_address))
458
459         WRITE_DWORD(&boot->addr, start_address);
460         WRITE_DWORD(&boot->cmd, 3);
461
462         for (i = 0; i < 300; ++i) {
463                 diva_os_wait(10);
464                 if ((READ_DWORD(&boot->signature) >> 16) == 0x4447) {
465                         DBG_LOG(("A(%d) Protocol startup time %d.%02d seconds",
466                                  IoAdapter->ANum, (i / 100), (i % 100)))
467                         started = 1;
468                         break;
469                 }
470         }
471
472         if (!started) {
473                 byte __iomem *p = (byte __iomem *)boot;
474                 dword TrapId;
475                 dword debug;
476                 TrapId = READ_DWORD(&p[0x80]);
477                 debug = READ_DWORD(&p[0x1c]);
478                 DBG_ERR(("A(%d) Adapter start failed 0x%08lx, TrapId=%08lx, debug=%08lx",
479                          IoAdapter->ANum, READ_DWORD(&boot->signature),
480                          TrapId, debug))
481                 DIVA_OS_MEM_DETACH_ADDRESS(IoAdapter, boot);
482                 if (IoAdapter->trapFnc) {
483                         (*(IoAdapter->trapFnc)) (IoAdapter);
484                 }
485                 IoAdapter->stop(IoAdapter);
486                 return (-1);
487         }
488         DIVA_OS_MEM_DETACH_ADDRESS(IoAdapter, boot);
489
490         IoAdapter->Initialized = true;
491
492         /*
493            Check Interrupt
494          */
495         IoAdapter->IrqCount = 0;
496         p = DIVA_OS_MEM_ATTACH_CFG(IoAdapter);
497         WRITE_DWORD(p, (dword) ~ 0x03E00000);
498         DIVA_OS_MEM_DETACH_CFG(IoAdapter, p);
499         a->ReadyInt = 1;
500         a->ram_out(a, &PR_RAM->ReadyInt, 1);
501
502         for (i = 100; !IoAdapter->IrqCount && (i-- > 0); diva_os_wait(10));
503
504         if (!IoAdapter->IrqCount) {
505                 DBG_ERR(("A: A(%d) interrupt test failed",
506                          IoAdapter->ANum))
507                 IoAdapter->Initialized = false;
508                 IoAdapter->stop(IoAdapter);
509                 return (-1);
510         }
511
512         IoAdapter->Properties.Features = (word) features;
513
514         diva_xdi_display_adapter_features(IoAdapter->ANum);
515
516         DBG_LOG(("A(%d) PRI adapter successfull started", IoAdapter->ANum))
517         /*
518            Register with DIDD
519          */
520         diva_xdi_didd_register_adapter(IoAdapter->ANum);
521
522         return (0);
523 }
524
525 static void diva_pri_clear_interrupts(diva_os_xdi_adapter_t * a)
526 {
527         PISDN_ADAPTER IoAdapter = &a->xdi_adapter;
528
529         /*
530            clear any pending interrupt
531          */
532         IoAdapter->disIrq(IoAdapter);
533
534         IoAdapter->tst_irq(&IoAdapter->a);
535         IoAdapter->clr_irq(&IoAdapter->a);
536         IoAdapter->tst_irq(&IoAdapter->a);
537
538         /*
539            kill pending dpcs
540          */
541         diva_os_cancel_soft_isr(&IoAdapter->req_soft_isr);
542         diva_os_cancel_soft_isr(&IoAdapter->isr_soft_isr);
543 }
544
545 /*
546 **  Stop Adapter, but do not unmap/unregister - adapter
547 **  will be restarted later
548 */
549 static int diva_pri_stop_adapter(diva_os_xdi_adapter_t * a)
550 {
551         PISDN_ADAPTER IoAdapter = &a->xdi_adapter;
552         int i = 100;
553
554         if (!IoAdapter->ram) {
555                 return (-1);
556         }
557         if (!IoAdapter->Initialized) {
558                 DBG_ERR(("A: A(%d) can't stop PRI adapter - not running",
559                          IoAdapter->ANum))
560                 return (-1);    /* nothing to stop */
561         }
562         IoAdapter->Initialized = 0;
563
564         /*
565            Disconnect Adapter from DIDD
566          */
567         diva_xdi_didd_remove_adapter(IoAdapter->ANum);
568
569         /*
570            Stop interrupts
571          */
572         a->clear_interrupts_proc = diva_pri_clear_interrupts;
573         IoAdapter->a.ReadyInt = 1;
574         IoAdapter->a.ram_inc(&IoAdapter->a, &PR_RAM->ReadyInt);
575         do {
576                 diva_os_sleep(10);
577         } while (i-- && a->clear_interrupts_proc);
578
579         if (a->clear_interrupts_proc) {
580                 diva_pri_clear_interrupts(a);
581                 a->clear_interrupts_proc = NULL;
582                 DBG_ERR(("A: A(%d) no final interrupt from PRI adapter",
583                          IoAdapter->ANum))
584         }
585         IoAdapter->a.ReadyInt = 0;
586
587         /*
588            Stop and reset adapter
589          */
590         IoAdapter->stop(IoAdapter);
591
592         return (0);
593 }
594
595 /*
596 **  Process commands form configuration/download framework and from
597 **  user mode
598 **
599 **  return 0 on success
600 */
601 static int
602 diva_pri_cmd_card_proc(struct _diva_os_xdi_adapter *a,
603                        diva_xdi_um_cfg_cmd_t * cmd, int length)
604 {
605         int ret = -1;
606
607         if (cmd->adapter != a->controller) {
608                 DBG_ERR(("A: pri_cmd, invalid controller=%d != %d",
609                          cmd->adapter, a->controller))
610                 return (-1);
611         }
612
613         switch (cmd->command) {
614         case DIVA_XDI_UM_CMD_GET_CARD_ORDINAL:
615                 a->xdi_mbox.data_length = sizeof(dword);
616                 a->xdi_mbox.data =
617                     diva_os_malloc(0, a->xdi_mbox.data_length);
618                 if (a->xdi_mbox.data) {
619                         *(dword *) a->xdi_mbox.data =
620                             (dword) a->CardOrdinal;
621                         a->xdi_mbox.status = DIVA_XDI_MBOX_BUSY;
622                         ret = 0;
623                 }
624                 break;
625
626         case DIVA_XDI_UM_CMD_GET_SERIAL_NR:
627                 a->xdi_mbox.data_length = sizeof(dword);
628                 a->xdi_mbox.data =
629                     diva_os_malloc(0, a->xdi_mbox.data_length);
630                 if (a->xdi_mbox.data) {
631                         *(dword *) a->xdi_mbox.data =
632                             (dword) a->xdi_adapter.serialNo;
633                         a->xdi_mbox.status = DIVA_XDI_MBOX_BUSY;
634                         ret = 0;
635                 }
636                 break;
637
638         case DIVA_XDI_UM_CMD_GET_PCI_HW_CONFIG:
639                 a->xdi_mbox.data_length = sizeof(dword) * 9;
640                 a->xdi_mbox.data =
641                     diva_os_malloc(0, a->xdi_mbox.data_length);
642                 if (a->xdi_mbox.data) {
643                         int i;
644                         dword *data = (dword *) a->xdi_mbox.data;
645
646                         for (i = 0; i < 8; i++) {
647                                 *data++ = a->resources.pci.bar[i];
648                         }
649                         *data++ = (dword) a->resources.pci.irq;
650                         a->xdi_mbox.status = DIVA_XDI_MBOX_BUSY;
651                         ret = 0;
652                 }
653                 break;
654
655         case DIVA_XDI_UM_CMD_RESET_ADAPTER:
656                 ret = diva_pri_reset_adapter(&a->xdi_adapter);
657                 break;
658
659         case DIVA_XDI_UM_CMD_WRITE_SDRAM_BLOCK:
660                 ret = diva_pri_write_sdram_block(&a->xdi_adapter,
661                                                  cmd->command_data.
662                                                  write_sdram.offset,
663                                                  (byte *) & cmd[1],
664                                                  cmd->command_data.
665                                                  write_sdram.length,
666                                                  pri_is_rev_2_card(a->
667                                                                    CardOrdinal)
668                                                  ? MP2_MEMORY_SIZE :
669                                                  MP_MEMORY_SIZE);
670                 break;
671
672         case DIVA_XDI_UM_CMD_STOP_ADAPTER:
673                 ret = diva_pri_stop_adapter(a);
674                 break;
675
676         case DIVA_XDI_UM_CMD_START_ADAPTER:
677                 ret = diva_pri_start_adapter(&a->xdi_adapter,
678                                              cmd->command_data.start.
679                                              offset,
680                                              cmd->command_data.start.
681                                              features);
682                 break;
683
684         case DIVA_XDI_UM_CMD_SET_PROTOCOL_FEATURES:
685                 a->xdi_adapter.features =
686                     cmd->command_data.features.features;
687                 a->xdi_adapter.a.protocol_capabilities =
688                     a->xdi_adapter.features;
689                 DBG_TRC(("Set raw protocol features (%08x)",
690                          a->xdi_adapter.features))
691                 ret = 0;
692                 break;
693
694         case DIVA_XDI_UM_CMD_GET_CARD_STATE:
695                 a->xdi_mbox.data_length = sizeof(dword);
696                 a->xdi_mbox.data =
697                     diva_os_malloc(0, a->xdi_mbox.data_length);
698                 if (a->xdi_mbox.data) {
699                         dword *data = (dword *) a->xdi_mbox.data;
700                         if (!a->xdi_adapter.ram ||
701                                 !a->xdi_adapter.reset ||
702                             !a->xdi_adapter.cfg) {
703                                 *data = 3;
704                         } else if (a->xdi_adapter.trapped) {
705                                 *data = 2;
706                         } else if (a->xdi_adapter.Initialized) {
707                                 *data = 1;
708                         } else {
709                                 *data = 0;
710                         }
711                         a->xdi_mbox.status = DIVA_XDI_MBOX_BUSY;
712                         ret = 0;
713                 }
714                 break;
715
716         case DIVA_XDI_UM_CMD_READ_XLOG_ENTRY:
717                 ret = diva_card_read_xlog(a);
718                 break;
719
720         case DIVA_XDI_UM_CMD_READ_SDRAM:
721                 if (a->xdi_adapter.Address) {
722                         if (
723                             (a->xdi_mbox.data_length =
724                              cmd->command_data.read_sdram.length)) {
725                                 if (
726                                     (a->xdi_mbox.data_length +
727                                      cmd->command_data.read_sdram.offset) <
728                                     a->xdi_adapter.MemorySize) {
729                                         a->xdi_mbox.data =
730                                             diva_os_malloc(0,
731                                                            a->xdi_mbox.
732                                                            data_length);
733                                         if (a->xdi_mbox.data) {
734                                                 byte __iomem *p = DIVA_OS_MEM_ATTACH_ADDRESS(&a->xdi_adapter);
735                                                 byte __iomem *src = p;
736                                                 byte *dst = a->xdi_mbox.data;
737                                                 dword len = a->xdi_mbox.data_length;
738
739                                                 src += cmd->command_data.read_sdram.offset;
740
741                                                 while (len--) {
742                                                         *dst++ = READ_BYTE(src++);
743                                                 }
744                                                 a->xdi_mbox.status = DIVA_XDI_MBOX_BUSY;
745                                                 DIVA_OS_MEM_DETACH_ADDRESS(&a->xdi_adapter, p);
746                                                 ret = 0;
747                                         }
748                                 }
749                         }
750                 }
751                 break;
752
753         default:
754                 DBG_ERR(("A: A(%d) invalid cmd=%d", a->controller,
755                          cmd->command))
756         }
757
758         return (ret);
759 }
760
761 /*
762 **  Get Serial Number
763 */
764 static int pri_get_serial_number(diva_os_xdi_adapter_t * a)
765 {
766         byte data[64];
767         int i;
768         dword len = sizeof(data);
769         volatile byte __iomem *config;
770         volatile byte __iomem *flash;
771         byte c;
772
773 /*
774  *  First set some GT6401x config registers before accessing the BOOT-ROM
775  */
776         config = DIVA_OS_MEM_ATTACH_CONFIG(&a->xdi_adapter);
777         c = READ_BYTE(&config[0xc3c]);
778         if (!(c & 0x08)) {
779                 WRITE_BYTE(&config[0xc3c], c);  /* Base Address enable register */
780         }
781         WRITE_BYTE(&config[LOW_BOOTCS_DREG], 0x00);
782         WRITE_BYTE(&config[HI_BOOTCS_DREG], 0xFF);
783         DIVA_OS_MEM_DETACH_CONFIG(&a->xdi_adapter, config);
784 /*
785  *  Read only the last 64 bytes of manufacturing data
786  */
787         memset(data, '\0', len);
788         flash = DIVA_OS_MEM_ATTACH_PROM(&a->xdi_adapter);
789         for (i = 0; i < len; i++) {
790                 data[i] = READ_BYTE(&flash[0x8000 - len + i]);
791         }
792         DIVA_OS_MEM_DETACH_PROM(&a->xdi_adapter, flash);
793
794         config = DIVA_OS_MEM_ATTACH_CONFIG(&a->xdi_adapter);
795         WRITE_BYTE(&config[LOW_BOOTCS_DREG], 0xFC);     /* Disable FLASH EPROM access */
796         WRITE_BYTE(&config[HI_BOOTCS_DREG], 0xFF);
797         DIVA_OS_MEM_DETACH_CONFIG(&a->xdi_adapter, config);
798
799         if (memcmp(&data[48], "DIVAserverPR", 12)) {
800 #if !defined(DIVA_PRI_NO_PCI_BIOS_WORKAROUND)   /* { */
801                 word cmd = 0, cmd_org;
802                 void *addr;
803                 dword addr1, addr3, addr4;
804                 byte Bus, Slot;
805                 void *hdev;
806                 addr4 = a->resources.pci.bar[4];
807                 addr3 = a->resources.pci.bar[3];        /* flash  */
808                 addr1 = a->resources.pci.bar[1];        /* unused */
809
810                 DBG_ERR(("A: apply Compaq BIOS workaround"))
811                 DBG_LOG(("%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
812                              data[0], data[1], data[2], data[3],
813                              data[4], data[5], data[6], data[7]))
814
815                 Bus = a->resources.pci.bus;
816                 Slot = a->resources.pci.func;
817                 hdev = a->resources.pci.hdev;
818                 PCIread(Bus, Slot, 0x04, &cmd_org, sizeof(cmd_org), hdev);
819                 PCIwrite(Bus, Slot, 0x04, &cmd, sizeof(cmd), hdev);
820
821                 PCIwrite(Bus, Slot, 0x14, &addr4, sizeof(addr4), hdev);
822                 PCIwrite(Bus, Slot, 0x20, &addr1, sizeof(addr1), hdev);
823
824                 PCIwrite(Bus, Slot, 0x04, &cmd_org, sizeof(cmd_org), hdev);
825
826                 addr = a->resources.pci.addr[1];
827                 a->resources.pci.addr[1] = a->resources.pci.addr[4];
828                 a->resources.pci.addr[4] = addr;
829
830                 addr1 = a->resources.pci.bar[1];
831                 a->resources.pci.bar[1] = a->resources.pci.bar[4];
832                 a->resources.pci.bar[4] = addr1;
833
834                 /*
835                    Try to read Flash again
836                  */
837                 len = sizeof(data);
838
839                 config = DIVA_OS_MEM_ATTACH_CONFIG(&a->xdi_adapter);
840                 if (!(config[0xc3c] & 0x08)) {
841                         config[0xc3c] |= 0x08;  /* Base Address enable register */
842                 }
843                 config[LOW_BOOTCS_DREG] = 0x00;
844                 config[HI_BOOTCS_DREG] = 0xFF;
845                 DIVA_OS_MEM_DETACH_CONFIG(&a->xdi_adapter, config);
846
847                 memset(data, '\0', len);
848                 flash = DIVA_OS_MEM_ATTACH_PROM(&a->xdi_adapter);
849                 for (i = 0; i < len; i++) {
850                         data[i] = flash[0x8000 - len + i];
851                 }
852                 DIVA_OS_MEM_ATTACH_PROM(&a->xdi_adapter, flash);
853                 config = DIVA_OS_MEM_ATTACH_CONFIG(&a->xdi_adapter);
854                 config[LOW_BOOTCS_DREG] = 0xFC;
855                 config[HI_BOOTCS_DREG] = 0xFF;
856                 DIVA_OS_MEM_DETACH_CONFIG(&a->xdi_adapter, config);
857
858                 if (memcmp(&data[48], "DIVAserverPR", 12)) {
859                         DBG_ERR(("A: failed to read serial number"))
860                         DBG_LOG(("%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
861                                      data[0], data[1], data[2], data[3],
862                                      data[4], data[5], data[6], data[7]))
863                         return (-1);
864                 }
865 #else                           /* } { */
866                 DBG_ERR(("A: failed to read DIVA signature word"))
867                 DBG_LOG(("%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
868                              data[0], data[1], data[2], data[3],
869                              data[4], data[5], data[6], data[7]))
870                 DBG_LOG(("%02x:%02x:%02x:%02x", data[47], data[46],
871                              data[45], data[44]))
872 #endif                          /* } */
873         }
874
875         a->xdi_adapter.serialNo =
876             (data[47] << 24) | (data[46] << 16) | (data[45] << 8) |
877             data[44];
878         if (!a->xdi_adapter.serialNo
879             || (a->xdi_adapter.serialNo == 0xffffffff)) {
880                 a->xdi_adapter.serialNo = 0;
881                 DBG_ERR(("A: failed to read serial number"))
882                 return (-1);
883         }
884
885         DBG_LOG(("Serial No.          : %ld", a->xdi_adapter.serialNo))
886         DBG_TRC(("Board Revision      : %d.%02d", (int) data[41],
887                      (int) data[40]))
888         DBG_TRC(("PLD revision        : %d.%02d", (int) data[33],
889                      (int) data[32]))
890         DBG_TRC(("Boot loader version : %d.%02d", (int) data[37],
891                      (int) data[36]))
892
893         DBG_TRC(("Manufacturing Date  : %d/%02d/%02d  (yyyy/mm/dd)",
894                      (int) ((data[28] > 90) ? 1900 : 2000) +
895                      (int) data[28], (int) data[29], (int) data[30]))
896
897         return (0);
898 }
899
900 void diva_os_prepare_pri2_functions(PISDN_ADAPTER IoAdapter)
901 {
902 }
903
904 void diva_os_prepare_pri_functions(PISDN_ADAPTER IoAdapter)
905 {
906 }
907
908 /*
909 **  Checks presence of DSP on board
910 */
911 static int
912 dsp_check_presence(volatile byte __iomem * addr, volatile byte __iomem * data, int dsp)
913 {
914         word pattern;
915
916         WRITE_WORD(addr, 0x4000);
917         WRITE_WORD(data, DSP_SIGNATURE_PROBE_WORD);
918
919         WRITE_WORD(addr, 0x4000);
920         pattern = READ_WORD(data);
921
922         if (pattern != DSP_SIGNATURE_PROBE_WORD) {
923                 DBG_TRC(("W: DSP[%d] %04x(is) != %04x(should)",
924                          dsp, pattern, DSP_SIGNATURE_PROBE_WORD))
925                 return (-1);
926         }
927
928         WRITE_WORD(addr, 0x4000);
929         WRITE_WORD(data, ~DSP_SIGNATURE_PROBE_WORD);
930
931         WRITE_WORD(addr, 0x4000);
932         pattern = READ_WORD(data);
933
934         if (pattern != (word) ~ DSP_SIGNATURE_PROBE_WORD) {
935                 DBG_ERR(("A: DSP[%d] %04x(is) != %04x(should)",
936                          dsp, pattern, (word) ~ DSP_SIGNATURE_PROBE_WORD))
937                 return (-2);
938         }
939
940         DBG_TRC(("DSP[%d] present", dsp))
941
942         return (0);
943 }
944
945
946 /*
947 **  Check if DSP's are present and operating
948 **  Information about detected DSP's is returned as bit mask
949 **  Bit 0  - DSP1
950 **  ...
951 **  ...
952 **  ...
953 **  Bit 29 - DSP30
954 */
955 static dword diva_pri_detect_dsps(diva_os_xdi_adapter_t * a)
956 {
957         byte __iomem *base;
958         byte __iomem *p;
959         dword ret = 0;
960         dword row_offset[7] = {
961                 0x00000000,
962                 0x00000800,     /* 1 - ROW 1 */
963                 0x00000840,     /* 2 - ROW 2 */
964                 0x00001000,     /* 3 - ROW 3 */
965                 0x00001040,     /* 4 - ROW 4 */
966                 0x00000000      /* 5 - ROW 0 */
967         };
968
969         byte __iomem *dsp_addr_port;
970         byte __iomem *dsp_data_port;
971         byte row_state;
972         int dsp_row = 0, dsp_index, dsp_num;
973
974         if (!a->xdi_adapter.Control || !a->xdi_adapter.reset) {
975                 return (0);
976         }
977
978         p = DIVA_OS_MEM_ATTACH_RESET(&a->xdi_adapter);
979         WRITE_BYTE(p, _MP_RISC_RESET | _MP_DSP_RESET);
980         DIVA_OS_MEM_DETACH_RESET(&a->xdi_adapter, p);
981         diva_os_wait(5);
982
983         base = DIVA_OS_MEM_ATTACH_CONTROL(&a->xdi_adapter);
984
985         for (dsp_num = 0; dsp_num < 30; dsp_num++) {
986                 dsp_row = dsp_num / 7 + 1;
987                 dsp_index = dsp_num % 7;
988
989                 dsp_data_port = base;
990                 dsp_addr_port = base;
991
992                 dsp_data_port += row_offset[dsp_row];
993                 dsp_addr_port += row_offset[dsp_row];
994
995                 dsp_data_port += (dsp_index * 8);
996                 dsp_addr_port += (dsp_index * 8) + 0x80;
997
998                 if (!dsp_check_presence
999                     (dsp_addr_port, dsp_data_port, dsp_num + 1)) {
1000                         ret |= (1 << dsp_num);
1001                 }
1002         }
1003         DIVA_OS_MEM_DETACH_CONTROL(&a->xdi_adapter, base);
1004
1005         p = DIVA_OS_MEM_ATTACH_RESET(&a->xdi_adapter);
1006         WRITE_BYTE(p, _MP_RISC_RESET | _MP_LED1 | _MP_LED2);
1007         DIVA_OS_MEM_DETACH_RESET(&a->xdi_adapter, p);
1008         diva_os_wait(5);
1009
1010         /*
1011            Verify modules
1012          */
1013         for (dsp_row = 0; dsp_row < 4; dsp_row++) {
1014                 row_state = ((ret >> (dsp_row * 7)) & 0x7F);
1015                 if (row_state && (row_state != 0x7F)) {
1016                         for (dsp_index = 0; dsp_index < 7; dsp_index++) {
1017                                 if (!(row_state & (1 << dsp_index))) {
1018                                         DBG_ERR(("A: MODULE[%d]-DSP[%d] failed",
1019                                                  dsp_row + 1,
1020                                                  dsp_index + 1))
1021                                 }
1022                         }
1023                 }
1024         }
1025
1026         if (!(ret & 0x10000000)) {
1027                 DBG_ERR(("A: ON BOARD-DSP[1] failed"))
1028         }
1029         if (!(ret & 0x20000000)) {
1030                 DBG_ERR(("A: ON BOARD-DSP[2] failed"))
1031         }
1032
1033         /*
1034            Print module population now
1035          */
1036         DBG_LOG(("+-----------------------+"))
1037         DBG_LOG(("| DSP MODULE POPULATION |"))
1038         DBG_LOG(("+-----------------------+"))
1039         DBG_LOG(("|  1  |  2  |  3  |  4  |"))
1040         DBG_LOG(("+-----------------------+"))
1041         DBG_LOG(("|  %s  |  %s  |  %s  |  %s  |",
1042                  ((ret >> (0 * 7)) & 0x7F) ? "Y" : "N",
1043                  ((ret >> (1 * 7)) & 0x7F) ? "Y" : "N",
1044                  ((ret >> (2 * 7)) & 0x7F) ? "Y" : "N",
1045                  ((ret >> (3 * 7)) & 0x7F) ? "Y" : "N"))
1046         DBG_LOG(("+-----------------------+"))
1047
1048         DBG_LOG(("DSP's(present-absent):%08x-%08x", ret,
1049                  ~ret & 0x3fffffff))
1050
1051         return (ret);
1052 }