source: trunk/com-on-air_cs-linux/sc14421_sniffer.c @ 44

Last change on this file since 44 was 44, checked in by krater, 11 years ago

descrambling bug fixed

File size: 16.4 KB
Line 
1/*
2 * com_on_air_cs - basic driver for the Dosch and Amand "com on air" cards
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 *
8 * authors:
9 * (C) 2008  Andreas Schuler <krater at badterrorist dot com>
10 * (C) 2008  Matthias Wenzel <dect at mazzoo dot de>
11 *
12 */
13
14#include <linux/kernel.h>
15#include <linux/module.h>
16#include <linux/kfifo.h>
17
18#include "sc14421.h"
19#include "dip_opcodes.h"
20#include "com_on_air.h"
21#include "sc14421_sniffer.h"
22#include "sc14421_firmware.h"
23#include "dect.h"
24
25
26/* dip config register control */
27unsigned char scan_init1[] = {0x27,0x00,0xff,0x00,0x5f,0x04,0x00};
28unsigned char scan_init2[] = {0xc2,0x05,0x00,0x03,0x00,0x00};
29
30/* hf register type II card */
31unsigned char radio_II_chan[] = {0x54,0x80,0x09/* patch */,0xa0,0x00,0x00};
32/* hf register type III card */
33unsigned char scan_III_init3[] = {0x54,0x80,0x09/* patch */,0xa0,0x00,0x00};
34
35/* hf register */
36unsigned char scan_init4[] = {0x15,0xa0,0xff,0x00/* &0x3f */,0x5f,0x04,0x00};
37
38/* dip control */
39unsigned char scan_init5[] = {0x27,0x00,0xff,0x00,0x5f,0x05,0x00};
40
41/* dip control */
42unsigned char sync_init1[] = {0x27,0x00,0xff,0x00,0x5f,0x04,0x00};
43unsigned char sync_init2[] = {0xc2,0x05,0x00,0x03,0x00,0x00};
44
45/* hf register type III card */
46unsigned char sync_III_init3[] = {0x54,0x80,0x09/* patch */,0xa0,0x00,0x00};
47/* hf register */
48unsigned char sync_init4[] = {0x15,0xa0,0xff,0x00/* &0x3f */,0x5f,0x04,0x00};
49/* dip control */
50unsigned char sync_init5[] = {0x27,0x00,0xff,0x00,0x5f,0x05,0x00};
51
52
53unsigned char fppacket[53] = {0xAA,0xAA,0xAA,0xE9,0x8A};
54unsigned char pppacket[53] = {0x55,0x55,0x55,0x16,0x75};
55
56
57/* FIXME:auto-generate all this stuff */
58
59int sync_jumptable[] = {
60         JP0, 0,
61         JP2, 0,
62         JP4, 0,
63         JP6, 0,
64         JP8, 0,
65        JP10, 0,
66        JP12, 0,
67        JP14, 0,
68        JP16, 0,
69        JP18, 0,
70        JP20, 0,
71        JP22, 0
72};
73int sync_patchtable[] = {
74         PP0, 0,
75         PP2, 0,
76         PP4, 0,
77         PP6, 0,
78         PP8, 0,
79        PP10, 0,
80        PP12, 0,
81        PP14, 0,
82        PP16, 0,
83        PP18, 0,
84        PP20, 0,
85        PP22, 0
86};
87/* FIXME:end */
88
89int sync_banktable[] = {
90        SC14421_RAMBANK1,
91        SC14421_RAMBANK1,
92        SC14421_RAMBANK1,
93        SC14421_RAMBANK1,
94        SC14421_RAMBANK2,
95        SC14421_RAMBANK2,
96        SC14421_RAMBANK2,
97        SC14421_RAMBANK2,
98        SC14421_RAMBANK3,
99        SC14421_RAMBANK3,
100        SC14421_RAMBANK3,
101        SC14421_RAMBANK3,
102        SC14421_RAMBANK4,
103        SC14421_RAMBANK4,
104        SC14421_RAMBANK4,
105        SC14421_RAMBANK4,
106        SC14421_RAMBANK5,
107        SC14421_RAMBANK5,
108        SC14421_RAMBANK5,
109        SC14421_RAMBANK5,
110        SC14421_RAMBANK6,
111        SC14421_RAMBANK6,
112        SC14421_RAMBANK6,
113        SC14421_RAMBANK6
114};
115
116
117void sniffer_init(struct coa_info *dev)
118{
119        int ret;
120
121        SC14421_switch_to_bank(
122                dev->sc14421_base,
123                SC14421_DIPSTOPPED | SC14421_CODEBANK
124                );
125
126        ret = SC14421_check_RAM(dev->sc14421_base);
127        if (ret)
128                printk("Found %u memory r/w errors \n\n", ret);
129
130        switch(dev->sniffer_config->snifftype)
131        {
132                case SNIFF_SCANFP:
133                case SNIFF_SCANPP:
134                        sniffer_init_sniff_scan(dev);
135                        break;
136                case SNIFF_SYNC:
137                        sniffer_init_sniff_sync(dev);
138                        break;
139        }
140}
141
142void set_channel(struct coa_info *dev, int ch)
143{
144        int channel;
145        if (ch<10)
146                channel = 10 - ch;
147        else
148                channel = ch;
149
150        switch(dev->radio_type)
151        {
152        case COA_RADIO_TYPE_II:
153                radio_II_chan[0] =
154                        (radio_II_chan[0] & 0xC1) |
155                        (channel << 1);
156                break;
157        default:
158                printk("ERROR: this radio type is currently not "
159                        "supported. please update the driver\n");
160        }
161}
162
163void sniffer_init_sniff_scan(struct coa_info *dev)
164{
165        volatile uint16_t *sc14421_base = dev->sc14421_base;
166
167/*      printk("loading sniff_scan firmware\n"); */
168
169        SC14421_switch_to_bank(
170                sc14421_base,
171                SC14421_DIPSTOPPED | SC14421_CODEBANK
172                );
173        to_dip(
174                sc14421_base,
175                sc14421_II_sniff_scan_fw,
176                ARRAY_SIZE(sc14421_II_sniff_scan_fw));
177
178        SC14421_clear_interrupt(sc14421_base);
179
180        set_channel(dev, dev->sniffer_config->channel);
181
182        if (dev->sniffer_config->snifftype == SNIFF_SCANPP)
183        {
184                scan_init1[0] &= 0xFE;
185                scan_init5[0] &= 0xFE;
186        }
187        else
188        {
189                scan_init1[0] |= 0x01;
190                scan_init5[0] |= 0x01;
191        }
192
193        SC14421_switch_to_bank(
194                sc14421_base,
195                SC14421_DIPSTOPPED | SC14421_RAMBANK0
196                );
197        to_dip(
198                sc14421_base + 0x00,
199                scan_init1,
200                ARRAY_SIZE(scan_init1));
201        to_dip(
202                sc14421_base + 0x10,
203                scan_init2,
204                ARRAY_SIZE(scan_init2)
205                );
206        SC14421_switch_to_bank(
207                sc14421_base,
208                SC14421_DIPSTOPPED | SC14421_RAMBANK1
209                );
210        to_dip(
211                sc14421_base + 0x4A,
212                radio_II_chan,
213                ARRAY_SIZE(radio_II_chan)
214                );
215        to_dip(
216                sc14421_base + 0x58,
217                scan_init5,
218                ARRAY_SIZE(scan_init5)
219                );
220        to_dip(
221                sc14421_base + 0x50,
222                scan_init4,
223                ARRAY_SIZE(scan_init4));
224
225/*      printk("starting dip\n"); */
226        SC14421_switch_to_bank(sc14421_base, SC14421_RAMBANK0);
227
228}
229
230
231void sniffer_init_sniff_sync(struct coa_info *dev)
232{
233        volatile uint16_t *sc14421_base = dev->sc14421_base;
234
235        printk("loading sniff_sync firmware\n");
236
237        SC14421_switch_to_bank(
238                sc14421_base,
239                SC14421_DIPSTOPPED | SC14421_CODEBANK
240                );
241        to_dip(
242                sc14421_base,
243                sc14421_II_sniff_sync_fw,
244                ARRAY_SIZE(sc14421_II_sniff_sync_fw));
245
246        printk("clear interrupt\n");
247        SC14421_clear_interrupt(sc14421_base);
248
249        SC14421_switch_to_bank(
250                sc14421_base,
251                SC14421_DIPSTOPPED | SC14421_RAMBANK0
252                );
253        to_dip(
254                sc14421_base + 0x00,
255                sync_init1,
256                ARRAY_SIZE(sync_init1)
257                );
258        to_dip(
259                sc14421_base + 0x10,
260                sync_init2,
261                ARRAY_SIZE(sync_init2));
262
263        set_channel(dev, dev->sniffer_config->channel);
264
265        sync_init5[0] |= 0x01;
266
267
268        SC14421_switch_to_bank(
269                sc14421_base,
270                SC14421_DIPSTOPPED | SC14421_RAMBANK1
271                );
272        to_dip(
273                sc14421_base + 0x4A,
274                radio_II_chan,
275                ARRAY_SIZE(radio_II_chan)
276                );
277        to_dip(
278                sc14421_base + 0x58,
279                sync_init5,
280                ARRAY_SIZE(sync_init5)
281                );
282        to_dip(
283                sc14421_base + 0x50,
284                sync_init4,
285                ARRAY_SIZE(sync_init4)
286                );
287
288        dev->sniffer_config->status = 0;
289        sniffer_clear_slottable(dev->sniffer_config->slottable);
290
291
292        printk("starting dip\n");
293        SC14421_switch_to_bank(sc14421_base, SC14421_RAMBANK0);
294
295}
296
297uint8_t sniffer_irq_handler(struct coa_info *dev)
298{
299        uint8_t irq = 0;
300
301        if (dev->sc14421_base)
302        {
303                irq = SC14421_clear_interrupt(dev->sc14421_base);
304
305                switch(dev->sniffer_config->snifftype)
306                {
307                        case SNIFF_SCANFP:
308                        case SNIFF_SCANPP:
309                                sniffer_sniff_scan_irq(dev, irq);
310                                break;
311                        case SNIFF_SYNC:
312                                sniffer_sniff_sync_irq(dev, irq);
313                                break;
314                }
315        }
316        return irq;
317}
318
319void sniffer_sniff_scan_irq(struct coa_info *dev, int irq)
320{
321        volatile uint16_t *sc14421_base = dev->sc14421_base;
322        int ret;
323        uint8_t station[7];
324
325        if (dev->open)
326        {
327                SC14421_switch_to_bank(sc14421_base, SC14421_RAMBANK1);
328
329                if ( (SC14421_READ(1) & 0xc0) == 0xc0) /* Checksum ok */
330                {
331                        uint8_t rssi = SC14421_READ(0);
332                        from_dip(
333                                fppacket + 5,
334                                sc14421_base + 6,
335                                6);
336
337                        SC14421_WRITE(1, 0); /* Clear Checksum-Flag */
338
339                        if (dect_is_RFPI_Packet(fppacket))
340                        {
341
342                                station[0] = dev->sniffer_config->channel;
343                                station[1] = rssi;
344                                memcpy(&station[2], &fppacket[6], 5); /* RFPI */
345
346                                ret = kfifo_put(dev->rx_fifo, station, 7);
347                                if (ret <= 0)
348                                {
349                                        printk("com_on_air_cs: rx fifo full? "
350                                                "kfifo_put() = %d\n", ret);
351                                }
352                        }
353                }
354        }
355}
356
357void sniffer_sniff_sync_irq(struct coa_info *dev, int irq)
358{
359        volatile uint16_t *sc14421_base = dev->sc14421_base;
360        struct sniffer_cfg *config = dev->sniffer_config;
361        struct sniffed_packet packet;
362        int ret;
363        int slot;
364        int a;
365        int memofs;
366
367        SC14421_switch_to_bank(sc14421_base, SC14421_RAMBANK1);
368
369
370        if (!(config->status & SNIFF_STATUS_FOUNDSTATION))
371        {
372                if (irq & 0x01)
373                {
374#if 0
375                        printk("N:");
376                        for (r=0; r<16; r++)
377                                printk("%.2x ", SC14421_READ(r));
378
379                        printk("\n");
380#endif
381                        if ( (SC14421_READ(1) & 0xc0) == 0xc0) /* Checksum ok */
382                        {
383                                SC14421_WRITE(1, 0); /* clear checksum flag */
384
385                                from_dip(
386                                        fppacket + 5,
387                                        sc14421_base + 6,
388                                        6);
389
390                                if (dect_compare_RFPI(fppacket, config->RFPI))
391                                {
392                                        printk("found station for sync\n");
393                                        config->status |=
394                                                SNIFF_STATUS_FOUNDSTATION;
395
396                                        SC14421_switch_to_bank(
397                                                sc14421_base,
398                                                SC14421_CODEBANK
399                                                );
400                                        SC14421_write_cmd(
401                                                sc14421_base,
402                                                sync_label_D4,
403                                                BR,
404                                                sync_label_D1
405                                                );
406                                }
407                        }
408                }
409        }
410        else if (!(config->status & SNIFF_STATUS_INSYNC))
411        {
412                if (irq & 0x01)
413                {
414
415#if 0
416                        printk("S:");   
417                        for (i=0; i<16; i++)
418                                printk("%.2x ", SC14421_READ(i));
419                        printk("\n");
420#endif
421                        if ( (SC14421_READ(1) & 0xc0) == 0xc0) /* Checksum ok */
422                        {
423                                SC14421_WRITE(1, 0); /* clear checksum flag */
424                                from_dip(
425                                        fppacket + 5,
426                                        sc14421_base + 6,
427                                        48);
428
429                                slot = dect_get_slot(fppacket);
430                                if (slot != -1)
431                                {
432                                        /* printk("station in slot %u\n", slot); */
433                                        config->status |= SNIFF_STATUS_INSYNC;
434                                        slot %= 12;
435                                        if (slot%2)
436                                                printk("slot not possible "
437                                                        "with this firmware\n");
438
439                                        config->slottable[slot].active = 1;
440                                        config->slottable[slot].channel =
441                                                config->channel;
442                                        config->slottable[slot].type =
443                                                DECT_SLOTTYPE_CARRIER;
444                                        config->slottable[slot].errcnt = 0;
445
446                                        sniffer_sync_patchloop(
447                                                dev,
448                                                config->slottable,
449                                                SNIFF_SLOTPATCH_FP
450                                                );
451                                        sniffer_sync_patchloop(
452                                                dev,
453                                                config->slottable,
454                                                SNIFF_SLOTPATCH_PP
455                                                );
456
457                                        SC14421_switch_to_bank(
458                                                sc14421_base,
459                                                SC14421_CODEBANK
460                                                );
461                                        printk("set jump to %u\n",
462                                                sync_jumptable[slot]);
463                                        SC14421_write_cmd(
464                                                sc14421_base,
465                                                sync_label_D4,
466                                                BR,
467                                                sync_jumptable[slot]
468                                                );
469
470                                        printk("we are in sync :)\n");
471
472
473
474                                        packet.rssi = SC14421_READ(0x00);
475                                        packet.channel = config->channel;
476                                        packet.slot = slot;
477                                        memcpy(packet.data, fppacket, 53);
478
479                                        packet.timestamp =
480                                                dev->irq_timestamp;
481                                        ret = kfifo_put(
482                                                dev->rx_fifo,
483                                                (unsigned char*) &packet,
484                                                sizeof(struct sniffed_packet));
485                                        if (ret <= 0)
486                                                printk("com_on_air_cs: rx fifo "
487                                                        "full? kfifo_put() "
488                                                        "= %d\n", ret);
489                                }
490                        }
491                }
492        }
493        else
494        {
495                if ( (irq & 0x09) == 0x09)
496                        printk("interrupt too slow , lost packets!\n");
497
498                if (irq & 0x01)
499                {
500
501                        for (a=0; a<12; a++)
502                        {
503                                if (config->slottable[a].active)
504                                {
505                                        SC14421_switch_to_bank(
506                                                sc14421_base,
507                                                sync_banktable[a]);
508
509                                        if ( (a/2) % 2)
510                                                memofs = 0x80;
511                                        else
512                                                memofs = 0x00;
513
514                                        if ( (SC14421_READ(1+memofs) & 0xc0) ==
515                                                0xc0) /* Checksum ok */
516                                        {
517                                                struct sniffed_packet packet;
518/* fixing indention / coding style is useless beyond here
519 * need to talk to krater about where to cut in functions
520 * - mazzoo */
521                                                packet.rssi =
522                                                        SC14421_READ(memofs);
523                                                packet.channel =
524                                                        config->slottable[a].channel;
525                                                packet.slot = a;
526                                                packet.framenumber = config->framenumber;
527                                                memcpy(
528                                                        packet.data,
529                                                        fppacket,
530                                                        5);
531                                                from_dip(
532                                                        &packet.data[5],
533                                                        sc14421_base+memofs+6,
534                                                        48);
535
536                                                if (config->slottable[a].type ==
537                                                        DECT_SLOTTYPE_SCAN)
538                                                        /* we received data on a scan-slot , channel is incemented before , but we want hear the old channel */
539                                                {
540                                                        packet.channel--;
541                                                        printk("slot in scanmode\n");
542                                                }
543
544                                                if (dect_is_multiframe_number(packet.data))                     /* if there was a multiframe number , then this packet was in frame 8 (0) */
545                                                {
546                                                        /* printk("found multiframe number\n");                                          */
547                                                        config->framenumber = 1;
548                                                }
549
550                                                /* if (dev->open) */
551                                                {
552                                                        packet.timestamp = dev->irq_timestamp;
553                                                        ret = kfifo_put(dev->rx_fifo, (unsigned char*) &packet, sizeof(struct sniffed_packet));
554                                                        if (ret <= 0)
555                                                        {
556                                                                printk("com_on_air_cs: rx fifo full? kfifo_put() = %d\n", ret);
557                                                        }
558                                                }
559
560
561
562#if 0 
563                                                printk("F:");
564                                                for (i=0; i<16; i++)
565                                                        printk("%.2x ", SC14421_READ(i+memofs));
566
567                                                printk("  : %.2x : %x\n", irq, a);
568#endif
569                                                SC14421_WRITE(1+memofs, 0);     /* clear checksum flag */
570
571
572                                                if (dect_update_slottable(config->slottable, a, packet.data))
573                                                {
574                                                        config->updateppslots = 1;
575                                                        config->updatefpslots = 1;
576                                                        /* printk("new slot , must update slots\n"); */
577                                                }
578
579                                        }
580                                        else
581                                        {
582                                                if (dect_receive_error(config->slottable, a))
583                                                {
584                                                        config->updateppslots = 1;
585                                                        config->updatefpslots = 1;
586                                                        printk("died slot , must update slots\n");
587                                                }
588                                        }
589                                }
590                        }
591
592                        if ( (!(irq & 0x08)) && (config->updatefpslots) )
593                        {
594                                /* printk("patching fp slots\n"); */
595                                sniffer_sync_patchloop(dev, config->slottable, SNIFF_SLOTPATCH_FP);
596                                config->updatefpslots = 0;
597                        }
598
599                }
600
601                if (irq & 0x08)
602                {
603
604                        for (a=12; a<24; a++)
605                        {
606                                if (config->slottable[a].active)
607                                {
608
609                                        SC14421_switch_to_bank(sc14421_base, sync_banktable[a]);
610
611                                        if ( (a/2) % 2)
612                                                memofs = 0x80;
613                                        else
614                                                memofs = 0x00;
615
616                                        if ( (SC14421_READ(1+memofs) & 0xc0) == 0xc0)           /* Checksum ok */
617                                        {
618                                                struct sniffed_packet packet;
619
620                                                packet.rssi = SC14421_READ(memofs);
621                                                /* FIXME DECT6.0 channels */
622                                                packet.channel = config->slottable[a].channel;
623                                                packet.slot = a;
624                                                packet.framenumber = config->framenumber;
625                                                memcpy(packet.data, pppacket, 5);
626                                                from_dip(&packet.data[5], sc14421_base+memofs+6, 48);
627                                                if (config->slottable[a].type == DECT_SLOTTYPE_SCAN)
628                                                {
629                                                        packet.channel--;
630                                                        printk("slot in scanmode\n");
631                                                }
632
633                                                /* if (dev->open) */
634                                                {
635                                                        packet.timestamp = dev->irq_timestamp;
636                                                        ret = kfifo_put(dev->rx_fifo, (unsigned char*) &packet, sizeof(struct sniffed_packet));
637                                                        if (ret <= 0)
638                                                        {
639                                                                printk("com_on_air_cs: rx fifo full? kfifo_put() = %d\n", ret);
640                                                        }
641                                                }
642
643
644#if 0
645                                                printk("F:");
646                                                for (i=0; i<16; i++)
647                                                        printk("%.2x ", SC14421_READ(i+memofs));
648
649                                                printk("  : %.2x : %x\n", irq, a);
650#endif
651
652                                                SC14421_WRITE(1+memofs, 0);     /* clear checksum flag */
653
654
655                                                if (dect_update_slottable(config->slottable, a, packet.data))
656                                                {
657                                                        config->updateppslots = 1;
658                                                        config->updatefpslots = 1;
659                                                        /* printk("new slot , must update slots\n"); */
660                                                }
661
662                                        }
663                                        else
664                                        {
665                                                if (dect_receive_error(config->slottable, a))
666                                                {
667                                                        config->updateppslots = 1;
668                                                        config->updatefpslots = 1;
669                                                        /* printk("died slot , must update slots\n"); */
670                                                }
671                                        }
672
673                                }
674
675                        }
676
677                        if ( (!(irq & 0x01)) && (config->updateppslots) )
678                        {
679                                /* printk("patching pp slots\n"); */
680                                sniffer_sync_patchloop(dev, config->slottable, SNIFF_SLOTPATCH_PP);
681                                config->updateppslots = 0;
682                        }
683
684                        if (dect_update_scanchannels(config->slottable))
685                        {
686                                config->updateppslots = 1;
687                                config->updatefpslots = 1;
688                                /* printk("new slot , must update slots\n"); */
689                        }
690
691                        if (config->framenumber >= 7)
692                                config->framenumber = 0;
693                        else
694                                config->framenumber++;
695                }
696
697        }
698}
699
700
701void sniffer_sync_patchloop(struct coa_info *dev, struct dect_slot_info *slottable, int type)
702{
703        static int fixme_count = 23;
704
705        int slot, offset = 0;
706        volatile uint16_t *sc14421_base = dev->sc14421_base;
707        struct sniffer_cfg *config = dev->sniffer_config;
708        int memofs;
709
710
711        if (type == SNIFF_SLOTPATCH_PP)
712                offset = 12;
713
714        for (slot = offset; slot < (offset+12); slot++)
715        {
716                if (slottable[slot].update)
717                {
718                        slottable[slot].update = 0;
719
720                        if (slottable[slot].active && (slot%2))
721                        {
722                                if (fixme_count)
723                                {
724                                        fixme_count--;
725                                        printk("can't use slot %u with this firmware !\n", slot);
726                                }
727                                continue;
728                        }
729
730
731                        if (slottable[slot].active)
732                        {
733
734                                set_channel(dev, slottable[slot].channel);
735
736                                if (slot > 11)
737                                        sync_init5[0] &= 0xFE;
738                                else
739                                        sync_init5[0] |= 0x01;
740
741                                if ( (slot/2) % 2)
742                                        memofs = 0x80;
743                                else
744                                        memofs = 0x00;
745
746                                sync_init5[6] = config->framenumber%8;
747
748                                SC14421_switch_to_bank(sc14421_base, sync_banktable[slot]);
749
750                                to_dip(sc14421_base + 0x4A + memofs, radio_II_chan, ARRAY_SIZE(radio_II_chan));
751                                to_dip(sc14421_base + 0x58 + memofs, sync_init5, ARRAY_SIZE(sync_init5));
752                                to_dip(sc14421_base + 0x50 + memofs, sync_init4, ARRAY_SIZE(sync_init4));
753
754
755                                /* printk("patching slot %u at addr %u\n", slot, sync_patchtable[slot]); */
756                                SC14421_switch_to_bank(sc14421_base, SC14421_CODEBANK);
757                                SC14421_write_cmd(sc14421_base, sync_patchtable[slot], JMP, sync_label_28);
758
759                        }
760                        else
761                        {
762                                SC14421_switch_to_bank(sc14421_base, SC14421_CODEBANK);
763                                SC14421_write_cmd(sc14421_base, sync_patchtable[slot], WNT, 2);
764                                /* printk("patching addr %u for wait\n", sync_patchtable[slot]); */
765                        }
766                }
767                else if (slottable[slot].active && (slottable[slot].type == DECT_SLOTTYPE_CARRIER))
768                {
769                        if ( (slot/2) % 2)
770                                memofs = 0x80;
771                        else
772                                memofs = 0x00;
773
774                        SC14421_switch_to_bank(sc14421_base, sync_banktable[slot]);
775                        SC14421_WRITE(0x5e + memofs, config->framenumber%8);
776                }
777        }
778}
779
780
781void sniffer_clear_slottable(struct dect_slot_info *slottable)
782{
783        int i;
784        for (i=0; i<24; i++)
785        {
786                slottable[i].active = 0;
787                slottable[i].update = 1;
788        }
789}
790
791
Note: See TracBrowser for help on using the repository browser.