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