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

Last change on this file since 43 was 43, checked in by mazzoo, 11 years ago

Makefile: allow users to "export PCMCIA_SLOT=0" if their pcmcia-card sits
in the other slor (default is 1). this brings "make load/unload/reload"
back to life

File size: 16.2 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                                                memcpy(
527                                                        packet.data,
528                                                        fppacket,
529                                                        5);
530                                                from_dip(
531                                                        &packet.data[5],
532                                                        sc14421_base+memofs+6,
533                                                        48);
534
535                                                if (config->slottable[a].type ==
536                                                        DECT_SLOTTYPE_SCAN)
537                                                        /* we received data on a scan-slot , channel is incemented before , but we want hear the old channel */
538                                                {
539                                                        packet.channel--;
540                                                        printk("slot in scanmode\n");
541                                                }
542
543                                                if (dect_is_multiframe_number(packet.data))                     /* if there was a multiframe number , then this packet was in frame 8 (0) */
544                                                {
545                                                        /* printk("found multiframe number\n");                                          */
546                                                        config->framenumber = 1;
547                                                }
548
549                                                /* if (dev->open) */
550                                                {
551                                                        packet.timestamp = dev->irq_timestamp;
552                                                        ret = kfifo_put(dev->rx_fifo, (unsigned char*) &packet, sizeof(struct sniffed_packet));
553                                                        if (ret <= 0)
554                                                        {
555                                                                printk("com_on_air_cs: rx fifo full? kfifo_put() = %d\n", ret);
556                                                        }
557                                                }
558
559
560
561#if 0 
562                                                printk("F:");
563                                                for (i=0; i<16; i++)
564                                                        printk("%.2x ", SC14421_READ(i+memofs));
565
566                                                printk("  : %.2x : %x\n", irq, a);
567#endif
568                                                SC14421_WRITE(1+memofs, 0);     /* clear checksum flag */
569
570
571                                                if (dect_update_slottable(config->slottable, a, packet.data))
572                                                {
573                                                        config->updateppslots = 1;
574                                                        config->updatefpslots = 1;
575                                                        /* printk("new slot , must update slots\n"); */
576                                                }
577
578                                        }
579                                        else
580                                        {
581                                                if (dect_receive_error(config->slottable, a))
582                                                {
583                                                        config->updateppslots = 1;
584                                                        config->updatefpslots = 1;
585                                                        printk("died slot , must update slots\n");
586                                                }
587                                        }
588                                }
589                        }
590
591                        if ( (!(irq & 0x08)) && (config->updatefpslots) )
592                        {
593                                /* printk("patching fp slots\n"); */
594                                sniffer_sync_patchloop(dev, config->slottable, SNIFF_SLOTPATCH_FP);
595                                config->updatefpslots = 0;
596                        }
597
598                }
599
600                if (irq & 0x08)
601                {
602
603                        for (a=12; a<24; a++)
604                        {
605                                if (config->slottable[a].active)
606                                {
607
608                                        SC14421_switch_to_bank(sc14421_base, sync_banktable[a]);
609
610                                        if ( (a/2) % 2)
611                                                memofs = 0x80;
612                                        else
613                                                memofs = 0x00;
614
615                                        if ( (SC14421_READ(1+memofs) & 0xc0) == 0xc0)           /* Checksum ok */
616                                        {
617                                                struct sniffed_packet packet;
618
619                                                packet.rssi = SC14421_READ(memofs);
620                                                /* FIXME DECT6.0 channels */
621                                                packet.channel = config->slottable[a].channel;
622                                                packet.slot = a;
623                                                memcpy(packet.data, pppacket, 5);
624                                                from_dip(&packet.data[5], sc14421_base+memofs+6, 48);
625                                                if (config->slottable[a].type == DECT_SLOTTYPE_SCAN)
626                                                {
627                                                        packet.channel--;
628                                                        printk("slot in scanmode\n");
629                                                }
630
631                                                /* if (dev->open) */
632                                                {
633                                                        packet.timestamp = dev->irq_timestamp;
634                                                        ret = kfifo_put(dev->rx_fifo, (unsigned char*) &packet, sizeof(struct sniffed_packet));
635                                                        if (ret <= 0)
636                                                        {
637                                                                printk("com_on_air_cs: rx fifo full? kfifo_put() = %d\n", ret);
638                                                        }
639                                                }
640
641
642#if 0
643                                                printk("F:");
644                                                for (i=0; i<16; i++)
645                                                        printk("%.2x ", SC14421_READ(i+memofs));
646
647                                                printk("  : %.2x : %x\n", irq, a);
648#endif
649
650                                                SC14421_WRITE(1+memofs, 0);     /* clear checksum flag */
651
652
653                                                if (dect_update_slottable(config->slottable, a, packet.data))
654                                                {
655                                                        config->updateppslots = 1;
656                                                        config->updatefpslots = 1;
657                                                        /* printk("new slot , must update slots\n"); */
658                                                }
659
660                                        }
661                                        else
662                                        {
663                                                if (dect_receive_error(config->slottable, a))
664                                                {
665                                                        config->updateppslots = 1;
666                                                        config->updatefpslots = 1;
667                                                        /* printk("died slot , must update slots\n"); */
668                                                }
669                                        }
670
671                                }
672
673                        }
674
675                        if ( (!(irq & 0x01)) && (config->updateppslots) )
676                        {
677                                /* printk("patching pp slots\n"); */
678                                sniffer_sync_patchloop(dev, config->slottable, SNIFF_SLOTPATCH_PP);
679                                config->updateppslots = 0;
680                        }
681
682                        if (dect_update_scanchannels(config->slottable))
683                        {
684                                config->updateppslots = 1;
685                                config->updatefpslots = 1;
686                                /* printk("new slot , must update slots\n"); */
687                        }
688
689                        if (config->framenumber >= 7)
690                                config->framenumber = 0;
691                        else
692                                config->framenumber++;
693                }
694
695        }
696}
697
698
699void sniffer_sync_patchloop(struct coa_info *dev, struct dect_slot_info *slottable, int type)
700{
701        static int fixme_count = 23;
702
703        int slot, offset = 0;
704        volatile uint16_t *sc14421_base = dev->sc14421_base;
705        struct sniffer_cfg *config = dev->sniffer_config;
706        int memofs;
707
708
709        if (type == SNIFF_SLOTPATCH_PP)
710                offset = 12;
711
712        for (slot = offset; slot < (offset+12); slot++)
713        {
714                if (slottable[slot].update)
715                {
716                        slottable[slot].update = 0;
717
718                        if (slottable[slot].active && (slot%2))
719                        {
720                                if (fixme_count)
721                                {
722                                        fixme_count--;
723                                        printk("can't use slot %u with this firmware !\n", slot);
724                                }
725                                continue;
726                        }
727
728
729                        if (slottable[slot].active)
730                        {
731
732                                set_channel(dev, slottable[slot].channel);
733
734                                if (slot > 11)
735                                        sync_init5[0] &= 0xFE;
736                                else
737                                        sync_init5[0] |= 0x01;
738
739                                if ( (slot/2) % 2)
740                                        memofs = 0x80;
741                                else
742                                        memofs = 0x00;
743
744                                sync_init5[6] = config->framenumber%8;
745
746                                SC14421_switch_to_bank(sc14421_base, sync_banktable[slot]);
747
748                                to_dip(sc14421_base + 0x4A + memofs, radio_II_chan, ARRAY_SIZE(radio_II_chan));
749                                to_dip(sc14421_base + 0x58 + memofs, sync_init5, ARRAY_SIZE(sync_init5));
750                                to_dip(sc14421_base + 0x50 + memofs, sync_init4, ARRAY_SIZE(sync_init4));
751
752
753                                /* printk("patching slot %u at addr %u\n", slot, sync_patchtable[slot]); */
754                                SC14421_switch_to_bank(sc14421_base, SC14421_CODEBANK);
755                                SC14421_write_cmd(sc14421_base, sync_patchtable[slot], JMP, sync_label_28);
756
757                        }
758                        else
759                        {
760                                SC14421_switch_to_bank(sc14421_base, SC14421_CODEBANK);
761                                SC14421_write_cmd(sc14421_base, sync_patchtable[slot], WNT, 2);
762                                /* printk("patching addr %u for wait\n", sync_patchtable[slot]); */
763                        }
764                }
765                else if (slottable[slot].active && (slottable[slot].type == DECT_SLOTTYPE_CARRIER))
766                {
767                        SC14421_switch_to_bank(sc14421_base, sync_banktable[slot]);
768                        SC14421_WRITE(0x5e, config->framenumber%8);
769                }
770        }
771}
772
773
774void sniffer_clear_slottable(struct dect_slot_info *slottable)
775{
776        int i;
777        for (i=0; i<24; i++)
778        {
779                slottable[i].active = 0;
780                slottable[i].update = 1;
781        }
782}
783
784
Note: See TracBrowser for help on using the repository browser.