Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
os_bri.c
Go to the documentation of this file.
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 successfully 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 }
Generated on Thu Jan 10 2013 13:41:39 for Linux Kernel by   doxygen 1.8.2