~gandelman-a/ubuntu/precise/dahdi-linux/merge879743

#! /usr/bin/perl -w

use strict;

# Make warnings fatal

local $SIG{__WARN__} = sub { die @_ };

#

# $Id: init_card_4_30 9709 2011-01-30 18:10:33Z tzafrir $

#

#

# Written by Oron Peled <oron@actcom.co.il>

# Copyright (C) 2007, Xorcom

#

# All rights reserved.

#

# This program is free software;	you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation;	either version 2 of the License, or

# (at your option) any later version.

#

# See the file LICENSE in the top level of this tarball.

#

# This script is run from the xpp kernel module upon detection

# of a new XPD.

#

# Expects the following environment variables to be set:

#	XBUS_NAME	- bus name

#	UNIT_NUMBER	- xpd unit number

#	UNIT_SUBUNITS	- number of subunits in this xpd

#	UNIT_TYPE	- xpd type number (from protocol reply):

#			1 - FXS

#			2 - FXO

#			3 - BRI

#			4 - PRI

#	XBUS_REVISION	- xbus revision number

#	XBUS_CONNECTOR	- xbus connector string

#	XBUS_LABEL	- xbus label string

#

# Output data format:

#	- An optional comment start with ';' or '#' until the end of line

#	- Optional Blank lines are ignored

#	- Fields are whitespace separated (spaces or tabs)

#

# The fields are (in command line order):

#	1. CHIP select in decimal (ignored, taken from 3 LSB's of subunit number)

#	2. Command word:

#		- RD	Read Direct register.

#		- WD	Write Direct register.

#	3. Register number in hexadecimal.

#	5. Data byte in hexadecimal. (for WD command only).

#

package main;

use File::Basename;

use Getopt::Std;

my $program = basename("$0");

my $init_dir = dirname("$0");

BEGIN { $init_dir = dirname($0); unshift(@INC, "$init_dir"); }

use XppConfig $init_dir;

my $unit_id;

my %opts;

getopts('o:', \%opts);

my %settings;

sub logit {

	print STDERR "$unit_id: @_\n";

}

sub debug {

	logit @_ if $settings{debug};

}

# Arrange for error logging

if (-t STDERR) {

	$unit_id = 'Interactive';

	debug "Interactive startup";

} else {

	$unit_id = "$ENV{XBUS_NAME}/UNIT-$ENV{UNIT_NUMBER}";

	open (STDERR, "| logger -t $program -p kern.info") || die;

	debug "Non Interactive startup";

	foreach my $k (qw(

			XBUS_NAME

			XBUS_NUMBER

			UNIT_NUMBER

			UNIT_TYPE

			UNIT_SUBUNITS

			UNIT_SUBUNITS_DIR

			XBUS_REVISION

			XBUS_CONNECTOR

			XBUS_LABEL)) {

		unless(defined $ENV{$k}) {

			logit "Missing ENV{$k}\n";

			die;

		}

	}

}

sub select_subunit($) {

	my $subunit = shift;

	die unless defined $subunit;

	my $output;

	if($opts{o}) {

		$output = $opts{o};

	} else {

		$output = sprintf "/sys/bus/xpds/devices/%02d:%1d:%1d/chipregs",

				$ENV{XBUS_NUMBER}, $ENV{UNIT_NUMBER}, $subunit;

		if(! -f $output) {

			my $xpd_name = sprintf("XPD-%1d%1d", $ENV{UNIT_NUMBER}, $subunit);

			$output = "/proc/xpp/$ENV{XBUS_NAME}/$xpd_name/chipregs";

			logit "OLD DRIVER: does not use /sys chipregs. Falling back to /proc"

				if -f $output;

		}

	}

	open(REG, ">$output") || die "Failed to open '$output': $!\n";

	my $oldfh = select REG;

	print "# Selecting subunit $subunit\n" if $opts{o};

	return $oldfh;

}

package PRI;

sub gen {

	my $fmt = shift;

	$| = 1;

	printf "$fmt\n", @_;

}

sub init_quad() {

	main::select_subunit(0);

	PRI::gen "0 WD D6 20"; 		# GPC6.COMP_DIS=1

					# (Compatibility Mode Disable)

	# Tuning of clocking unit to the 16.384 MHz reference frequence

	# by setting Global Clock Mode registers (GCM[1:8]), same for E1 and T1/J1

	PRI::gen "0 WD 92 00"; 		# GCM1

	PRI::gen "0 WD 93 18";		# GCM2

	PRI::gen "0 WD 94 FB";		# GCM3

	PRI::gen "0 WD 95 0B";		# GCM4

	PRI::gen "0 WD 96 01";		# GCM5

	PRI::gen "0 WD 97 0B";		# GCM6

	PRI::gen "0 WD 98 DB";		# GCM7

	PRI::gen "0 WD 99 DF";		# GCM8

}

sub finish_quad() {

	PRI::gen "0 WD BB 2C"; 		# REGFP

	PRI::gen "0 WD BC FF"; 		# REGFD

	PRI::gen "0 WD BB AC"; 		# REGFP

	PRI::gen "0 WD BB 2B"; 		# REGFP

	PRI::gen "0 WD BC 00"; 		# REGFD

	PRI::gen "0 WD BB AB"; 		# REGFP

	PRI::gen "0 WD BB 2A"; 		# REGFP

	PRI::gen "0 WD BC FF"; 		# REGFD

	PRI::gen "0 WD BB AA"; 		# REGFP

	PRI::gen "0 WD BB 29"; 		# REGFP

	PRI::gen "0 WD BC FF"; 		# REGFD

	PRI::gen "0 WD BB A9"; 		# REGFP

	PRI::gen "0 WD BB 28"; 		# REGFP

	PRI::gen "0 WD BC 00"; 		# REGFD

	PRI::gen "0 WD BB A8"; 		# REGFP

	PRI::gen "0 WD BB 27"; 		# REGFP

	PRI::gen "0 WD BC FF"; 		# REGFD

	PRI::gen "0 WD BB A7"; 		# REGFP

	PRI::gen "0 WD BB 00"; 		# REGFP

#	PRI::gen "0 WD 80 00"; 	# PC1 (Port configuration 1): RPB_1.SYPR           , XPB_1.SYPX

}

sub read_defaults() {

	if(XppConfig::read_config(\%settings)) {

		main::logit "Defaults from $settings{xppconf}";

	} else {

		main::logit "No defaults file, use hard-coded defaults.";

	}

}

package PRI::Port;

sub new {

	my $pack = shift;

	my $port = { @_ };

	bless $port, $pack;

	return $port;

}

sub get_pri_protocol {

	my $port = shift;

	my $subunit = $port->{PORT_NUM};

	my $xpd_name = "XPD-$ENV{UNIT_NUMBER}$subunit";

	my $pri_protocol;

	my @keys = (

			"pri_protocol/connector:$ENV{XBUS_CONNECTOR}/$xpd_name",

			"pri_protocol/label:$ENV{XBUS_LABEL}/$xpd_name",

			"pri_protocol/$ENV{XBUS_NAME}/$xpd_name",

			"pri_protocol"

		);

	foreach my $k (@keys) {

		$k = lc($k);		# Lowercase

		$pri_protocol = $settings{$k};

		if(defined $pri_protocol) {

			$port->{pri_protocol} = $pri_protocol;

			return $pri_protocol;

		}

	}

	return undef;

}

sub write_pri_info {

	my $port = shift;

	my $subunit = $port->{PORT_NUM};

	my $pri_protocol = $port->get_pri_protocol;

	my $xpd_name = sprintf("XPD-%1d%1d", $ENV{UNIT_NUMBER}, $subunit);

	if(defined $pri_protocol) {

		main::logit "$xpd_name: pri_protocol $pri_protocol";

		my $file = sprintf "/sys/bus/xpds/devices/%02d:%1d:%1d/pri_protocol",

				$ENV{XBUS_NUMBER}, $ENV{UNIT_NUMBER}, $subunit;

		if(! -f $file) {

			$file = "/proc/xpp/$ENV{XBUS_NAME}/$xpd_name/pri_info";

			main::logit "OLD DRIVER: does not use /sys chipregs. Falling back to /proc"

				if -f $file;

		}

		open(INFO, ">$file") || die "Failed to open '$file': $!\n";

		print INFO "$pri_protocol\n" || die "Failed writing '$pri_protocol' to '$file': $!\n";

		close INFO || die "Failed during close of '$file': $!\n";

	} else {

		main::logit "$xpd_name: pri_protocol not given. Driver will use defaults.";

	}

}

sub port_setup($) {

	my $port = shift;

	my $portno = $port->{PORT_NUM};

	my $pri_protocol = $port->get_pri_protocol;

	PRI::gen "$portno WD 28 40"; 	# XPM2.XLT Tristate

	my $cmr5 = sprintf("%x", ($portno << 5));

	PRI::gen "$portno WD 42 $cmr5"; # CMR5.DRSS=portno

	PRI::gen "$portno WD 26 F6"; 	# XPM0: Pulse Shape Programming for R1=18Ohms 

	PRI::gen "$portno WD 27 02"; 	# XPM1: ...3V Pulse Level at the line (Vp-p=6v)

					# if (unchannelized)

	#PRI::gen "$portno WD 1F 22";	# LOOP (Channel Looback): 

					#      ECLB (Enable Channel Loop-Back) 

					#      CLA  (Channel Address)

	PRI::gen "$portno WD 2B EF";	# IDL (Idle): 

					#      If channel loopback is enabled than transmit this code on the outgoing

	PRI::gen "$portno WD 1F 00";	# LOOP (Channel Looback): 

	#if($portno eq 0){ 

	#	PRI::gen "0 WD 1F 00";	# LOOP (Channel Looback): 

	#				#      channels (XL1/XL2)

	#}else { 

	#	PRI::gen "0 WD 1F 20";	# LOOP (Channel Looback): 

	#}

	# only one of the following loopbacks can be activated in the same time 

	my $LIM1_RL  = 0 << 1; 	# RL  (Remote  Loopback)

	my $lim1 = 0xB0 | $LIM1_RL;

	PRI::gen "$portno WD 37 %02X", $lim1;

					# LIM1: ~RL (Remote Loop bit 0x02),

					#       ~DRS (Dual Rail Select, latch receive data while trasmit),

					#       RIL1, RIL0 (Receive Input Treshold 0.62 V),

					#       CLOS (Clear data in case of LOS)

	PRI::gen "$portno WD 3A 20";	# LIM2: SLT1, SLT0 = 01 

					#            (Receiver Slicer Threshold, the receive slicer 

					#             generates a mark (digital one) if the voltage at

					#             RL1/2 exceeds 50% of the peak amplitude,

					#             default, recommended in E1 mode).

	PRI::gen "$portno WD 38 0A"; 	# PCD: (Pulse Count Detection, LOS Detection after 176 consecutive 0s)

	PRI::gen "$portno WD 39 15"; 	# PCR: (Pulse Count Recovery, LOS Recovery after 22 ones in PCD interval)

	# Configure system interface

	PRI::gen "$portno WD 3E C2";	# SIC1: SSC1 (System clock    ) is 8.192 Mhz, 

					#       SSD1 (System Data rate) is 8.192 Mbit/s,

					#	~BIM (Byte interleaved mode),

					#	XBS  (Transmit Buffer Size) is 2 frames

	PRI::gen "$portno WD 40 04";	# SIC3: Edges for capture, Synchronous Pulse Receive @Rising Edge

	PRI::gen "$portno WD 41 04";	# CMR4: RCLK is 8.192 MHz

	PRI::gen "$portno WD 43 04";	# CMR5: TCLK is 8.192 MHz

	PRI::gen "$portno WD 44 34";	# CMR6: Receive reference clock generated by channel 1,

					#       RCLK is at 8.192 Mhz dejittered, Clock recovered from the line

					#       TCLK is at 8.192 MHz is de-jittered by DCO-R to drive a6.176 MHz 

					#       clock on RCLK.*/

	PRI::gen "$portno WD 22 00"; 	# XC0: (Transmit Counter Offset = 497/T=2)

	PRI::gen "$portno WD 23 04"; 	# XC1: X=4  => T=4-X=0 offset

	PRI::gen "$portno WD 24 00"; 	# RC0: (Receive  Counter Offset = 497/T=2)

	PRI::gen "$portno WD 25 05"; 	# RC1: Remaining part of RC0

	my $sic2 = sprintf("%x", 0x00 | ($portno << 1));

	PRI::gen "$portno WD 3F $sic2";	# SIC2: No FFS, no center receive elastic buffer, data active at phase ($sic >> 1)

	# enable the following interrupt sources

	PRI::gen "$portno WD 14 F7"; 	# IMR0 (Interrupt Mask Register2): Enable CASC_E1/RSC_T1

	PRI::gen "$portno WD 16 00"; 	# IMR2 (Interrupt Mask Register2): Enable ALL

	PRI::gen "$portno WD 17 3F"; 	# IMR3 ~ES, ~SEC (Enable ES and SEC interrupts)

	PRI::gen "$portno WD 18 00"; 	# IMR4: Enable ALL

	PRI::gen "$portno WD 46 80"; 	# GCR: (Global Configuration Register)

					#      VIS (Masked Interrupts Visible)

	PRI::gen "$portno WD 08 04";	# IPC: SYNC is 8 Khz

	PRI::gen "$portno WD 02 51"; 	# CMDR (Command Register): RRES, XRES, SRES (Receiver/Transmitter reset)

	PRI::gen "$portno WD 02 00"; 	# CMDR

	PRI::gen "$portno WD 45 00";	# CMR2: External sources for SYPR, SCLKR, SYPX, SCLKX for TX and RX.

	#  Configure ports

	PRI::gen "$portno WD 85 80";		# GPC1 (Global Port Configuration 1):

	#PRI::gen "$portno WD 85 00";		# GPC1 (Global Port Configuration 1):

								#      SMM (System Interface Multiplex Mode)

	PRI::gen "$portno WD 80 00";	# PC1: SYPR/SYPX provided to RPA/XPA inputs

	PRI::gen "$portno WD 84 31";	# PC5: XMFS active low, SCLKR is input, RCLK is output (unused)

	PRI::gen "$portno WD 3B 00";	# Clear LCR1 - Loop Code Register 1

	#  printk("TE110P: Successfully initialized serial bus for card\n");

	# Initialize PCM and SIG regs

	PRI::gen "$portno WD A0 00";	# TSEO (Time Slot Even/Odd Select) 

	PRI::gen "$portno WD A1 FF";	# TSBS (Time Slot Bit Select)- only selected bits are used for HDLC channel 1

					#      in selected time slots

	PRI::gen "$portno WD 03 89";	# Mode Register:

					#      MDS  (Mode Select) = 100 (No address comparison)

					#      HRAC (Receiver Active - HDLC channel 1) 

					#      RFT2 (HDLC Receive FIFO is 64 byte deep)

	my $ccr1 = 0x18;		# CCR1 (Common Configuration Register1)

					#      EITS (Enable Internal Time Slot 0 to 31 Signalling)

					#      ITF  (Interframe Time Fill)

	my $sysfs_pri_protocol;

	if (defined $pri_protocol) {

		$sysfs_pri_protocol = $pri_protocol;

	} else {

		my $file = sprintf "/sys/bus/xpds/devices/%02d:%1d:%1d/pri_protocol",

				$ENV{XBUS_NUMBER}, $ENV{UNIT_NUMBER}, $portno;

		# The 'open' will fail if the port does not exist.

		# (or rather: the XPD for it does not exist). While

		# we only read this file to get the default E1/T1 value,

		# if it does not exist, it also implies the commands sent would

		# get nowhere. So we might as well quit now.

		open(F, $file) || return;

		$sysfs_pri_protocol = <F>;

		close F;

		chomp $sysfs_pri_protocol;

	}

	if($sysfs_pri_protocol eq 'T1') {

		$ccr1 |= 0x80;		#      RSCC (Serial CAS Format Selection)

	}

	PRI::gen "$portno WD 09 %02X", $ccr1;

	PRI::gen "$portno WD 0A 04";	# CCR2 (Common Configuration Register2)

					#      RCRC (enable CRC - HDLC channel 1enable CRC - HDLC channel 1)

	PRI::gen "$portno WD 0C 00";	# RTR1 (Receive  Time Slot register 1)

	PRI::gen "$portno WD 0D 00";	# RTR2 (Receive  Time Slot register 2)

	PRI::gen "$portno WD 0E 00";	# RTR3 (Receive  Time Slot register 3), TS16 (Enable time slot 16) 

	PRI::gen "$portno WD 0F 00";	# RTR4 (Receive  Time Slot register 4)

	PRI::gen "$portno WD 10 00";	# TTR1 (Transmit Time Slot register 1)

	PRI::gen "$portno WD 11 00";	# TTR2 (Transmit Time Slot register 2)

	PRI::gen "$portno WD 12 00";	# TTR3 (Transmit Time Slot register 3), TS16 (Enable time slot 16) 

	PRI::gen "$portno WD 13 00";	# TTR4 (Transmit Time Slot register 4)

	# configure the best performance of the Bipolar Violation detection for all four channels

	PRI::gen "$portno WD BD 00";	# BFR (Bugfix Register): ~BVP (Bipolar Violations),

					#                         use Improved Bipolar Violation Detection instead

}

package main;

main::debug "Starting '$0'";

PRI::read_defaults;

sub main() {

	my @ports;

	my $subunit;

	main::debug "main(): Initializing chip ($ENV{UNIT_SUBUNITS} ports)";

	PRI::init_quad;

	# Must initialize all 4 ports, regardless how much there are

	for($subunit = 0; $subunit < 4; $subunit++) {

		#main::debug "main(): Initializing subunit $subunit";

		my $p = PRI::Port->new(

				'PORT_NUM'		=> $subunit,

				'EXIST'			=> ($subunit < $ENV{UNIT_SUBUNITS})

				);

		$p->port_setup;

		push(@ports, $p);

	}

	PRI::finish_quad;

	foreach my $p (@ports) {

		if($p->{EXIST}) {

			$p->write_pri_info;

		}

	}

}

main;

main::debug "Ending '$0'";

close REG;

close STDERR;

exit 0;