1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include "a_config.h"
27#include "athdefs.h"
28#include "a_types.h"
29#include "AR6002/hw2.0/hw/mbox_host_reg.h"
30#include "a_osapi.h"
31#include "../htc_debug.h"
32#include "hif.h"
33#include "htc_packet.h"
34#include "ar6k.h"
35
36extern void AR6KFreeIOPacket(AR6K_DEVICE *pDev, HTC_PACKET *pPacket);
37extern HTC_PACKET *AR6KAllocIOPacket(AR6K_DEVICE *pDev);
38
39static A_STATUS DevServiceDebugInterrupt(AR6K_DEVICE *pDev);
40
41#define DELAY_PER_INTERVAL_MS 10
42
43
44A_STATUS DevRWCompletionHandler(void *context, A_STATUS status)
45{
46 HTC_PACKET *pPacket = (HTC_PACKET *)context;
47
48 AR_DEBUG_PRINTF(ATH_DEBUG_RECV,
49 ("+DevRWCompletionHandler (Pkt:0x%lX) , Status: %d \n",
50 (unsigned long)pPacket,
51 status));
52
53 COMPLETE_HTC_PACKET(pPacket,status);
54
55 AR_DEBUG_PRINTF(ATH_DEBUG_RECV,
56 ("-DevRWCompletionHandler\n"));
57
58 return A_OK;
59}
60
61
62A_STATUS DevPollMboxMsgRecv(AR6K_DEVICE *pDev,
63 A_UINT32 *pLookAhead,
64 int TimeoutMS)
65{
66 A_STATUS status = A_OK;
67 int timeout = TimeoutMS/DELAY_PER_INTERVAL_MS;
68
69 A_ASSERT(timeout > 0);
70
71 AR_DEBUG_PRINTF(ATH_DEBUG_RECV,("+DevPollMboxMsgRecv \n"));
72
73 while (TRUE) {
74
75 if (pDev->GetPendingEventsFunc != NULL) {
76
77 HIF_PENDING_EVENTS_INFO events;
78
79#ifdef THREAD_X
80 events.Polling =1;
81#endif
82
83
84
85 status = pDev->GetPendingEventsFunc(pDev->HIFDevice,
86 &events,
87 NULL);
88 if (A_FAILED(status))
89 {
90 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Failed to get pending events \n"));
91 break;
92 }
93
94 if (events.Events & HIF_RECV_MSG_AVAIL)
95 {
96
97 *pLookAhead = events.LookAhead;
98
99 break;
100 }
101 } else {
102
103
104
105 status = HIFReadWrite(pDev->HIFDevice,
106 HOST_INT_STATUS_ADDRESS,
107 (A_UINT8 *)&pDev->IrqProcRegisters,
108 AR6K_IRQ_PROC_REGS_SIZE,
109 HIF_RD_SYNC_BYTE_INC,
110 NULL);
111
112 if (A_FAILED(status)){
113 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Failed to read register table \n"));
114 break;
115 }
116
117
118 if (pDev->IrqProcRegisters.host_int_status & (1 << HTC_MAILBOX)) {
119 if (pDev->IrqProcRegisters.rx_lookahead_valid & (1 << HTC_MAILBOX))
120 {
121
122 *pLookAhead = pDev->IrqProcRegisters.rx_lookahead[HTC_MAILBOX];
123 break;
124 }
125 }
126
127 }
128
129 timeout--;
130
131 if (timeout <= 0) {
132 AR_DEBUG_PRINTF(ATH_DEBUG_ERR, (" Timeout waiting for recv message \n"));
133 status = A_ERROR;
134
135
136 if ( pDev->IrqProcRegisters.counter_int_status & AR6K_TARGET_DEBUG_INTR_MASK) {
137
138
139 DevServiceDebugInterrupt(pDev);
140 }
141
142 break;
143 }
144
145
146 A_MDELAY(DELAY_PER_INTERVAL_MS);
147 AR_DEBUG_PRINTF(ATH_DEBUG_RECV,(" Retry Mbox Poll : %d \n",timeout));
148 }
149
150 AR_DEBUG_PRINTF(ATH_DEBUG_RECV,("-DevPollMboxMsgRecv \n"));
151
152 return status;
153}
154
155static A_STATUS DevServiceCPUInterrupt(AR6K_DEVICE *pDev)
156{
157 A_STATUS status;
158 A_UINT8 cpu_int_status;
159 A_UINT8 regBuffer[4];
160
161 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ, ("CPU Interrupt\n"));
162 cpu_int_status = pDev->IrqProcRegisters.cpu_int_status &
163 pDev->IrqEnableRegisters.cpu_int_status_enable;
164 A_ASSERT(cpu_int_status);
165 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,
166 ("Valid interrupt source(s) in CPU_INT_STATUS: 0x%x\n",
167 cpu_int_status));
168
169
170 pDev->IrqProcRegisters.cpu_int_status &= ~cpu_int_status;
171
172
173
174
175
176
177 regBuffer[0] = cpu_int_status;
178
179 regBuffer[1] = 0;
180 regBuffer[2] = 0;
181 regBuffer[3] = 0;
182
183 status = HIFReadWrite(pDev->HIFDevice,
184 CPU_INT_STATUS_ADDRESS,
185 regBuffer,
186 4,
187 HIF_WR_SYNC_BYTE_FIX,
188 NULL);
189
190 A_ASSERT(status == A_OK);
191 return status;
192}
193
194
195static A_STATUS DevServiceErrorInterrupt(AR6K_DEVICE *pDev)
196{
197 A_STATUS status;
198 A_UINT8 error_int_status;
199 A_UINT8 regBuffer[4];
200
201 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ, ("Error Interrupt\n"));
202 error_int_status = pDev->IrqProcRegisters.error_int_status & 0x0F;
203 A_ASSERT(error_int_status);
204 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,
205 ("Valid interrupt source(s) in ERROR_INT_STATUS: 0x%x\n",
206 error_int_status));
207
208 if (ERROR_INT_STATUS_WAKEUP_GET(error_int_status)) {
209
210 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ, ("Error : Wakeup\n"));
211 }
212
213 if (ERROR_INT_STATUS_RX_UNDERFLOW_GET(error_int_status)) {
214
215 AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Error : Rx Underflow\n"));
216 }
217
218 if (ERROR_INT_STATUS_TX_OVERFLOW_GET(error_int_status)) {
219
220 AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Error : Tx Overflow\n"));
221 }
222
223
224 pDev->IrqProcRegisters.error_int_status &= ~error_int_status;
225
226
227
228
229
230
231 regBuffer[0] = error_int_status;
232
233 regBuffer[1] = 0;
234 regBuffer[2] = 0;
235 regBuffer[3] = 0;
236
237 status = HIFReadWrite(pDev->HIFDevice,
238 ERROR_INT_STATUS_ADDRESS,
239 regBuffer,
240 4,
241 HIF_WR_SYNC_BYTE_FIX,
242 NULL);
243
244 A_ASSERT(status == A_OK);
245 return status;
246}
247
248static A_STATUS DevServiceDebugInterrupt(AR6K_DEVICE *pDev)
249{
250 A_UINT32 dummy;
251 A_STATUS status;
252
253
254 AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Target debug interrupt\n"));
255
256 if (pDev->TargetFailureCallback != NULL) {
257 pDev->TargetFailureCallback(pDev->HTCContext);
258 }
259
260 if (pDev->GMboxEnabled) {
261 DevNotifyGMboxTargetFailure(pDev);
262 }
263
264
265
266
267 status = HIFReadWrite(pDev->HIFDevice,
268 COUNT_DEC_ADDRESS,
269 (A_UINT8 *)&dummy,
270 4,
271 HIF_RD_SYNC_BYTE_INC,
272 NULL);
273
274 A_ASSERT(status == A_OK);
275 return status;
276}
277
278static A_STATUS DevServiceCounterInterrupt(AR6K_DEVICE *pDev)
279{
280 A_UINT8 counter_int_status;
281
282 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ, ("Counter Interrupt\n"));
283
284 counter_int_status = pDev->IrqProcRegisters.counter_int_status &
285 pDev->IrqEnableRegisters.counter_int_status_enable;
286
287 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,
288 ("Valid interrupt source(s) in COUNTER_INT_STATUS: 0x%x\n",
289 counter_int_status));
290
291
292
293
294
295 if (counter_int_status & AR6K_TARGET_DEBUG_INTR_MASK) {
296 return DevServiceDebugInterrupt(pDev);
297 }
298
299 return A_OK;
300}
301
302
303static void DevGetEventAsyncHandler(void *Context, HTC_PACKET *pPacket)
304{
305 AR6K_DEVICE *pDev = (AR6K_DEVICE *)Context;
306 A_UINT32 lookAhead = 0;
307 A_BOOL otherInts = FALSE;
308
309 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("+DevGetEventAsyncHandler: (dev: 0x%lX)\n", (unsigned long)pDev));
310
311 do {
312
313 if (A_FAILED(pPacket->Status)) {
314 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
315 (" GetEvents I/O request failed, status:%d \n", pPacket->Status));
316
317 break;
318 }
319
320 if (pDev->GetPendingEventsFunc != NULL) {
321
322 HIF_PENDING_EVENTS_INFO *pEvents = (HIF_PENDING_EVENTS_INFO *)pPacket->pBuffer;
323 if (pEvents->Events & HIF_RECV_MSG_AVAIL) {
324 lookAhead = pEvents->LookAhead;
325 if (0 == lookAhead) {
326 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" DevGetEventAsyncHandler1, lookAhead is zero! \n"));
327 }
328 }
329 if (pEvents->Events & HIF_OTHER_EVENTS) {
330 otherInts = TRUE;
331 }
332 } else {
333
334 AR6K_IRQ_PROC_REGISTERS *pReg = (AR6K_IRQ_PROC_REGISTERS *)pPacket->pBuffer;
335 A_UINT8 host_int_status;
336
337 host_int_status = pReg->host_int_status & pDev->IrqEnableRegisters.int_status_enable;
338
339 if (host_int_status & (1 << HTC_MAILBOX)) {
340 host_int_status &= ~(1 << HTC_MAILBOX);
341 if (pReg->rx_lookahead_valid & (1 << HTC_MAILBOX)) {
342
343 lookAhead = pReg->rx_lookahead[HTC_MAILBOX];
344 if (0 == lookAhead) {
345 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" DevGetEventAsyncHandler2, lookAhead is zero! \n"));
346 }
347 }
348 }
349
350 if (host_int_status) {
351
352 otherInts = TRUE;
353 }
354 }
355
356 if (otherInts || (lookAhead == 0)) {
357
358
359
360 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,
361 (" Acking interrupt from DevGetEventAsyncHandler (otherints:%d, lookahead:0x%X)\n",
362 otherInts, lookAhead));
363 HIFAckInterrupt(pDev->HIFDevice);
364 } else {
365 int fetched = 0;
366 A_STATUS status;
367
368 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,
369 (" DevGetEventAsyncHandler : detected another message, lookahead :0x%X \n",
370 lookAhead));
371
372
373 status = pDev->MessagePendingCallback(pDev->HTCContext, &lookAhead, 1, NULL, &fetched);
374
375 if (A_SUCCESS(status) && !fetched) {
376
377 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("MessagePendingCallback did not pull any messages, force-ack \n"));
378 DevAsyncIrqProcessComplete(pDev);
379 }
380 }
381
382 } while (FALSE);
383
384
385 AR6KFreeIOPacket(pDev,pPacket);
386 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("-DevGetEventAsyncHandler \n"));
387}
388
389
390
391A_STATUS DevCheckPendingRecvMsgsAsync(void *context)
392{
393 AR6K_DEVICE *pDev = (AR6K_DEVICE *)context;
394 A_STATUS status = A_OK;
395 HTC_PACKET *pIOPacket;
396
397
398
399
400 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("+DevCheckPendingRecvMsgsAsync: (dev: 0x%lX)\n", (unsigned long)pDev));
401
402 do {
403
404 if (HIF_DEVICE_IRQ_SYNC_ONLY == pDev->HifIRQProcessingMode) {
405
406
407
408 break;
409 }
410
411
412
413
414
415 if (pDev->RecheckIRQStatusCnt == 0) {
416 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("Bypassing IRQ Status re-check, re-acking HIF interrupts\n"));
417
418 HIFAckInterrupt(pDev->HIFDevice);
419 break;
420 }
421
422
423
424
425 pIOPacket = AR6KAllocIOPacket(pDev);
426
427 if (NULL == pIOPacket) {
428
429
430 status = A_NO_MEMORY;
431 A_ASSERT(FALSE);
432 break;
433 }
434
435
436 pIOPacket->Completion = DevGetEventAsyncHandler;
437 pIOPacket->pContext = pDev;
438
439 if (pDev->GetPendingEventsFunc) {
440
441 status = pDev->GetPendingEventsFunc(pDev->HIFDevice,
442 (HIF_PENDING_EVENTS_INFO *)pIOPacket->pBuffer,
443 pIOPacket);
444
445 } else {
446
447 status = HIFReadWrite(pDev->HIFDevice,
448 HOST_INT_STATUS_ADDRESS,
449 pIOPacket->pBuffer,
450 AR6K_IRQ_PROC_REGS_SIZE,
451 HIF_RD_ASYNC_BYTE_INC,
452 pIOPacket);
453 }
454
455 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,(" Async IO issued to get interrupt status...\n"));
456 } while (FALSE);
457
458 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("-DevCheckPendingRecvMsgsAsync \n"));
459
460 return status;
461}
462
463void DevAsyncIrqProcessComplete(AR6K_DEVICE *pDev)
464{
465 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("DevAsyncIrqProcessComplete - forcing HIF IRQ ACK \n"));
466 HIFAckInterrupt(pDev->HIFDevice);
467}
468
469
470static A_STATUS ProcessPendingIRQs(AR6K_DEVICE *pDev, A_BOOL *pDone, A_BOOL *pASyncProcessing)
471{
472 A_STATUS status = A_OK;
473 A_UINT8 host_int_status = 0;
474 A_UINT32 lookAhead = 0;
475
476 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("+ProcessPendingIRQs: (dev: 0x%lX)\n", (unsigned long)pDev));
477
478
479
480
481
482
483 do {
484
485 if (pDev->IrqEnableRegisters.int_status_enable == 0) {
486
487
488
489 break;
490 }
491
492 if (pDev->GetPendingEventsFunc != NULL) {
493 HIF_PENDING_EVENTS_INFO events;
494
495#ifdef THREAD_X
496 events.Polling= 0;
497#endif
498
499
500 status = pDev->GetPendingEventsFunc(pDev->HIFDevice,
501 &events,
502 NULL);
503
504 if (A_FAILED(status)) {
505 break;
506 }
507
508 if (events.Events & HIF_RECV_MSG_AVAIL) {
509 lookAhead = events.LookAhead;
510 if (0 == lookAhead) {
511 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" ProcessPendingIRQs1 lookAhead is zero! \n"));
512 }
513 }
514
515 if (!(events.Events & HIF_OTHER_EVENTS) ||
516 !(pDev->IrqEnableRegisters.int_status_enable & OTHER_INTS_ENABLED)) {
517
518
519
520 break;
521 }
522
523
524 }
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539#ifdef CONFIG_MMC_SDHCI_S3C
540 pDev->IrqProcRegisters.host_int_status = 0;
541 pDev->IrqProcRegisters.rx_lookahead_valid = 0;
542 pDev->IrqProcRegisters.host_int_status2 = 0;
543 pDev->IrqProcRegisters.rx_lookahead[0] = 0;
544 pDev->IrqProcRegisters.rx_lookahead[1] = 0xaaa5555;
545#endif
546 status = HIFReadWrite(pDev->HIFDevice,
547 HOST_INT_STATUS_ADDRESS,
548 (A_UINT8 *)&pDev->IrqProcRegisters,
549 AR6K_IRQ_PROC_REGS_SIZE,
550 HIF_RD_SYNC_BYTE_INC,
551 NULL);
552
553 if (A_FAILED(status)) {
554 break;
555 }
556
557#ifdef ATH_DEBUG_MODULE
558 if (AR_DEBUG_LVL_CHECK(ATH_DEBUG_IRQ)) {
559 DevDumpRegisters(pDev,
560 &pDev->IrqProcRegisters,
561 &pDev->IrqEnableRegisters);
562 }
563#endif
564
565
566 host_int_status = pDev->IrqProcRegisters.host_int_status &
567 pDev->IrqEnableRegisters.int_status_enable;
568
569 if (NULL == pDev->GetPendingEventsFunc) {
570
571
572 if (host_int_status & (1 << HTC_MAILBOX)) {
573
574
575 host_int_status &= ~(1 << HTC_MAILBOX);
576 if (pDev->IrqProcRegisters.rx_lookahead_valid & (1 << HTC_MAILBOX)) {
577
578 lookAhead = pDev->IrqProcRegisters.rx_lookahead[HTC_MAILBOX];
579 if (0 == lookAhead) {
580 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" ProcessPendingIRQs2, lookAhead is zero! \n"));
581 }
582 }
583 }
584 } else {
585
586 host_int_status &= ~(1 << HTC_MAILBOX);
587 }
588
589 if (pDev->GMboxEnabled) {
590
591 status = DevCheckGMboxInterrupts(pDev);
592 }
593
594 } while (FALSE);
595
596
597 do {
598
599
600 if (A_FAILED(status)) {
601 break;
602 }
603
604 if ((0 == host_int_status) && (0 == lookAhead)) {
605
606 *pDone = TRUE;
607 break;
608 }
609
610 if (lookAhead != 0) {
611 int fetched = 0;
612
613 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("Pending mailbox message, LookAhead: 0x%X\n",lookAhead));
614
615
616
617
618
619 status = pDev->MessagePendingCallback(pDev->HTCContext, &lookAhead, 1, pASyncProcessing, &fetched);
620 if (A_FAILED(status)) {
621 break;
622 }
623
624 if (!fetched) {
625
626
627 *pASyncProcessing = FALSE;
628 pDev->RecheckIRQStatusCnt = 0;
629 }
630 }
631
632
633 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,
634 (" Valid interrupt source(s) for OTHER interrupts: 0x%x\n",
635 host_int_status));
636
637 if (HOST_INT_STATUS_CPU_GET(host_int_status)) {
638
639 status = DevServiceCPUInterrupt(pDev);
640 if (A_FAILED(status)){
641 break;
642 }
643 }
644
645 if (HOST_INT_STATUS_ERROR_GET(host_int_status)) {
646
647 status = DevServiceErrorInterrupt(pDev);
648 if (A_FAILED(status)){
649 break;
650 }
651 }
652
653 if (HOST_INT_STATUS_COUNTER_GET(host_int_status)) {
654
655 status = DevServiceCounterInterrupt(pDev);
656 if (A_FAILED(status)){
657 break;
658 }
659 }
660
661 } while (FALSE);
662
663
664
665
666
667
668
669
670
671 if (!(*pASyncProcessing) && (pDev->RecheckIRQStatusCnt == 0) && (pDev->GetPendingEventsFunc == NULL)) {
672 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("Bypassing IRQ Status re-check, forcing done \n"));
673 *pDone = TRUE;
674 }
675
676 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("-ProcessPendingIRQs: (done:%d, async:%d) status=%d \n",
677 *pDone, *pASyncProcessing, status));
678
679 return status;
680}
681
682
683
684A_STATUS DevDsrHandler(void *context)
685{
686 AR6K_DEVICE *pDev = (AR6K_DEVICE *)context;
687 A_STATUS status = A_OK;
688 A_BOOL done = FALSE;
689 A_BOOL asyncProc = FALSE;
690
691 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("+DevDsrHandler: (dev: 0x%lX)\n", (unsigned long)pDev));
692
693
694 pDev->CurrentDSRRecvCount = 0;
695
696 pDev->RecheckIRQStatusCnt = 0;
697
698 while (!done) {
699 status = ProcessPendingIRQs(pDev, &done, &asyncProc);
700 if (A_FAILED(status)) {
701 break;
702 }
703
704 if (HIF_DEVICE_IRQ_SYNC_ONLY == pDev->HifIRQProcessingMode) {
705
706 asyncProc = FALSE;
707
708
709
710
711
712 if (pDev->DSRCanYield && DEV_CHECK_RECV_YIELD(pDev)) {
713
714
715 break;
716 }
717 }
718
719 if (asyncProc) {
720
721
722
723 break;
724 }
725
726 }
727
728 if (A_SUCCESS(status) && !asyncProc) {
729
730
731
732 if (pDev->DSRCanYield) {
733
734
735 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,(" Yield in effect (cur RX count: %d) \n", pDev->CurrentDSRRecvCount));
736 } else {
737 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,(" Acking interrupt from DevDsrHandler \n"));
738 HIFAckInterrupt(pDev->HIFDevice);
739 }
740 }
741
742 AR_DEBUG_PRINTF(ATH_DEBUG_IRQ,("-DevDsrHandler \n"));
743 return status;
744}
745
746#ifdef ATH_DEBUG_MODULE
747void DumpAR6KDevState(AR6K_DEVICE *pDev)
748{
749 A_STATUS status;
750 AR6K_IRQ_ENABLE_REGISTERS regs;
751 AR6K_IRQ_PROC_REGISTERS procRegs;
752
753 LOCK_AR6K(pDev);
754
755 A_MEMCPY(®s,&pDev->IrqEnableRegisters,AR6K_IRQ_ENABLE_REGS_SIZE);
756 UNLOCK_AR6K(pDev);
757
758
759 status = HIFReadWrite(pDev->HIFDevice,
760 HOST_INT_STATUS_ADDRESS,
761 (A_UINT8 *)&procRegs,
762 AR6K_IRQ_PROC_REGS_SIZE,
763 HIF_RD_SYNC_BYTE_INC,
764 NULL);
765
766 if (A_FAILED(status)) {
767 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
768 ("DumpAR6KDevState : Failed to read register table (%d) \n",status));
769 return;
770 }
771
772 DevDumpRegisters(pDev,&procRegs,®s);
773
774 if (pDev->GMboxInfo.pStateDumpCallback != NULL) {
775 pDev->GMboxInfo.pStateDumpCallback(pDev->GMboxInfo.pProtocolContext);
776 }
777
778
779 HIFConfigureDevice(pDev->HIFDevice,HIF_DEVICE_DEBUG_BUS_STATE,NULL,0);
780
781}
782#endif
783
784
785