← Back to branch summary

~ubuntu-branches/ubuntu/quantal/zaptel/quantal

« back to all changes in this revision

Viewing changes to kernel/xpp/utils/zconf/Zaptel/Span.pm

  • Committer: Bazaar Package Importer
  • Author(s): Tzafrir Cohen
  • Date: 2008-08-28 22:58:23 UTC
  • mfrom: (11.1.11 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080828225823-r8bdunirm8hmc76m
Tags: 1:1.4.11~dfsg-2
http://bugs.debian.org/493397
* Patch xpp_fxs_power: Fixed an issue with hook detection of the Astribank
  FXS module.
* Don't fail init.d script if fxotune fails. This may happen if running it
  when Asterisk is already running.
* Bump standards version to 3.8.0.0 .
* Ignore false lintian warning ("m-a a-i" has "a a").
* Patch xpp_fxo_cid_always: do always pass PCM if that's what the user
  asked.
* Patch vzaphfc_proc_root_dir: fix vzaphfc on 2.6.26.
* Patch wcte12xp_flags: Proper time for irq save flags.
* Patch headers_2627: Fix location of semaphore.h for 2.6.27 .
* Patch xpp_fxs_dtmf_leak: Don't play DTMFs to the wrong channel.
* Patch wctdm_fix_alarm: Fix sending channel alarms.
* Patch device_class_2626: Fix building 2.6.26 (Closes: #493397).
* Using dh_lintian for lintian overrides, hence requiring debhelper 6.0.7.
* Lintian: we know we have direct changes. Too bad we're half-upstream :-(
* Fix doc-base section names. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
kernel/xpp/utils/zconf/Zaptel/Span.pm
 
1
package Zaptel::Span;
 
2
#
 
3
# Written by Oron Peled <oron@actcom.co.il>
 
4
# Copyright (C) 2007, Xorcom
 
5
# This program is free software; you can redistribute and/or
 
6
# modify it under the same terms as Perl itself.
 
7
#
 
8
# $Id: Span.pm 3957 2008-03-07 00:45:53Z tzafrir $
 
9
#
 
10
use strict;
 
11
use Zaptel::Utils;
 
12
use Zaptel::Chans;
 
13
use Zaptel::Xpp::Xpd;
 
14
 
 
15
my $proc_base = "/proc/zaptel";
 
16
 
 
17
sub chans($) {
 
18
        my $span = shift;
 
19
        return @{$span->{CHANS}};
 
20
}
 
21
 
 
22
sub by_number($) {
 
23
        my $span_number = shift;
 
24
        die "Missing span number" unless defined $span_number;
 
25
        my @spans = Zaptel::spans();
 
26
 
 
27
        my ($span) = grep { $_->num == $span_number } @spans;
 
28
        return $span;
 
29
}
 
30
 
 
31
my @bri_strings = (
 
32
                'BRI_(NT|TE)',
 
33
                '(?:quad|octo)BRI PCI ISDN Card.* \[(NT|TE)\]\ ',
 
34
                'octoBRI \[(NT|TE)\] ',
 
35
                'HFC-S PCI A ISDN.* \[(NT|TE)\] '
 
36
                );
 
37
 
 
38
my @pri_strings = (
 
39
                '(E1|T1|J1)_(NT|TE)',
 
40
                'Tormenta 2 .*Quad (E1|T1)',       # tor2.
 
41
                'Digium Wildcard .100P (T1|E1)/', # wct1xxp
 
42
                'ISA Tormenta Span 1',             # torisa
 
43
                'TE110P T1/E1',                    # wcte11xp
 
44
                'Wildcard TE120P',                 # wcte12xp
 
45
                'Wildcard TE121',                  # wcte12xp
 
46
                'Wildcard TE122',                  # wcte12xp
 
47
                'T[24]XXP \(PCI\) Card ',          # wct4xxp
 
48
                );
 
49
 
 
50
our $ZAPBRI_NET = 'bri_net';
 
51
our $ZAPBRI_CPE = 'bri_cpe';
 
52
 
 
53
our $ZAPPRI_NET = 'pri_net';
 
54
our $ZAPPRI_CPE = 'pri_cpe';
 
55
 
 
56
sub init_proto($$) {
 
57
        my $self = shift;
 
58
        my $proto = shift;
 
59
 
 
60
        $self->{PROTO} = $proto;
 
61
        if($proto eq 'E1') {
 
62
                $self->{DCHAN_IDX} = 15;
 
63
                $self->{BCHAN_LIST} = [ 0 .. 14, 16 .. 30 ];
 
64
        } elsif($proto eq 'T1') {
 
65
                $self->{DCHAN_IDX} = 23;
 
66
                $self->{BCHAN_LIST} = [ 0 .. 22 ];
 
67
        }
 
68
        $self->{TYPE} = "${proto}_$self->{TERMTYPE}";
 
69
}
 
70
 
 
71
sub new($$) {
 
72
        my $pack = shift or die "Wasn't called as a class method\n";
 
73
        my $num = shift or die "Missing a span number parameter\n";
 
74
        my $self = { NUM => $num };
 
75
        bless $self, $pack;
 
76
        $self->{TYPE} = "UNKNOWN";
 
77
        my @xpds = Zaptel::Xpp::Xpd::xpds_by_spanno;
 
78
        my $xpd = $xpds[$num];
 
79
        if(defined $xpd) {
 
80
                die "Spanno mismatch: $xpd->spanno, $num" unless $xpd->spanno == $num;
 
81
                $self->{XPD} = $xpd;
 
82
        }
 
83
        open(F, "$proc_base/$num") or die "Failed to open '$proc_base/$num\n";
 
84
        my $head = <F>;
 
85
        chomp $head;
 
86
        $self->{IS_DIGITAL} = 0;
 
87
        $self->{IS_BRI} = 0;
 
88
        $self->{IS_PRI} = 0;
 
89
        foreach my $cardtype (@bri_strings) {
 
90
                if($head =~ m/$cardtype/) {
 
91
                        $self->{IS_DIGITAL} = 1;
 
92
                        $self->{IS_BRI} = 1;
 
93
                        $self->{TERMTYPE} = $1;
 
94
                        $self->{TYPE} = "BRI_$1";
 
95
                        $self->{DCHAN_IDX} = 2;
 
96
                        $self->{BCHAN_LIST} = [ 0, 1 ];
 
97
                        last;
 
98
                }
 
99
        }
 
100
        foreach my $cardtype (@pri_strings) {
 
101
                if($head =~ m/$cardtype/) {
 
102
                        my @info;
 
103
 
 
104
                        push(@info, $1) if defined $1;
 
105
                        push(@info, $2) if defined $2;
 
106
                        my ($proto) = grep(/(E1|T1|J1)/, @info);
 
107
                        $proto = 'UNKNOWN' unless defined $proto;
 
108
                        my ($termtype) = grep(/(NT|TE)/, @info);
 
109
                        $termtype = 'TE' unless defined $termtype;
 
110
 
 
111
                        $self->{IS_DIGITAL} = 1;
 
112
                        $self->{IS_PRI} = 1;
 
113
                        $self->{TERMTYPE} = $termtype;
 
114
                        $self->init_proto($proto);
 
115
                        last;
 
116
                }
 
117
        }
 
118
        die "$0: Unkown TERMTYPE [NT/TE]\n"
 
119
                if $self->is_digital  and !defined $self->{TERMTYPE};
 
120
        ($self->{NAME}, $self->{DESCRIPTION}) = (split(/\s+/, $head, 4))[2, 3];
 
121
        $self->{IS_ZAPTEL_SYNC_MASTER} =
 
122
                ($self->{DESCRIPTION} =~ /\(MASTER\)/) ? 1 : 0;
 
123
        $self->{CHANS} = [];
 
124
        my @channels;
 
125
        my $index = 0;
 
126
        while(<F>) {
 
127
                chomp;
 
128
                s/^\s*//;
 
129
                s/\s*$//;
 
130
                next unless /\S/;
 
131
                next unless /^\s*\d+/; # must be a real channel string.
 
132
                my $c = Zaptel::Chans->new($self, $index, $_);
 
133
                push(@channels, $c);
 
134
                $index++;
 
135
        }
 
136
        close F;
 
137
        if($self->is_pri()) {
 
138
                # Check for PRI with unknown type strings
 
139
                if($index == 31) {
 
140
                        if($self->{PROTO} eq 'UNKNOWN') {
 
141
                                $self->init_proto('E1');
 
142
                        } elsif($self->{PROTO} ne 'E1')  {
 
143
                                die "$index channels in a $self->{PROTO} span";
 
144
                        }
 
145
                } elsif($index == 24) {
 
146
                        if($self->{PROTO} eq 'UNKNOWN') {
 
147
                                $self->init_proto('T1');        # FIXME: J1?
 
148
                        } elsif($self->{PROTO} ne 'T1') {
 
149
                                die "$index channels in a $self->{PROTO} span";
 
150
                        }
 
151
                }
 
152
        }
 
153
        @channels = sort { $a->num <=> $b->num } @channels;
 
154
        $self->{CHANS} = \@channels;
 
155
        $self->{YELLOW} = undef;
 
156
        $self->{CRC4} = undef;
 
157
        if($self->is_bri()) {
 
158
                $self->{CODING} = 'ami';
 
159
                $self->{DCHAN} = ($self->chans())[$self->{DCHAN_IDX}];
 
160
                $self->{BCHANS} = [ ($self->chans())[@{$self->{BCHAN_LIST}}] ];
 
161
                # Infer some info from channel name:
 
162
                my $first_chan = ($self->chans())[0] || die "$0: No channels in span #$num\n";
 
163
                my $chan_fqn = $first_chan->fqn();
 
164
                if($chan_fqn =~ m(ZTHFC.*/|ztqoz.*/|XPP_BRI_.*/)) {             # BRI
 
165
                        $self->{FRAMING} = 'ccs';
 
166
                        $self->{SWITCHTYPE} = 'euroisdn';
 
167
                        $self->{SIGNALLING} = ($self->{TERMTYPE} eq 'NT') ? $ZAPBRI_NET : $ZAPBRI_CPE ;
 
168
                } elsif($chan_fqn =~ m(ztgsm.*/)) {                             # Junghanns's GSM cards. 
 
169
                        $self->{FRAMING} = 'ccs';
 
170
                        $self->{SIGNALLING} = 'gsm';
 
171
                }
 
172
        }
 
173
        if($self->is_pri()) {
 
174
                $self->{DCHAN} = ($self->chans())[$self->{DCHAN_IDX}];
 
175
                $self->{BCHANS} = [ ($self->chans())[@{$self->{BCHAN_LIST}}] ];
 
176
                if($self->{PROTO} eq 'E1') {
 
177
                        $self->{CODING} = 'hdb3';
 
178
                        $self->{FRAMING} = 'ccs';
 
179
                        $self->{SWITCHTYPE} = 'euroisdn';
 
180
                        $self->{CRC4} = 'crc4';
 
181
                } elsif($self->{PROTO} eq 'T1') {
 
182
                        $self->{CODING} = 'b8zs';
 
183
                        $self->{FRAMING} = 'esf';
 
184
                        $self->{SWITCHTYPE} = 'national';
 
185
                } else {
 
186
                        die "'$self->{PROTO}' unsupported yet";
 
187
                }
 
188
                $self->{SIGNALLING} = ($self->{TERMTYPE} eq 'NT') ? $ZAPPRI_NET : $ZAPPRI_CPE ;
 
189
        }
 
190
        return $self;
 
191
}
 
192
 
 
193
sub bchans($) {
 
194
        my $self = shift || die;
 
195
 
 
196
        return @{$self->{BCHANS}};
 
197
}
 
198
 
 
199
1;