Revert "wcaxx: Use startup/shutdown callbacks to protect access to channel registers."

This reverts commit 1cf7d9b08c.

It turns out this change was not necessary.

Signed-off-by: Shaun Ruffell <sruffell@digium.com>

.gitignore

@@ -0,0 +1,50 @@
+# Files that are generated as part of the build process which we do not want git
+# to track.
+
+*.[oa]
+*.mod
+*.mod.[oc]
+*.ko
+*.ko.unsigned
+*.cmd
+*.order
+*.tar.gz
+tags
+cscope.*
+*.symvers
+*.markers
+.*.o.d
+
+README.html
+modules.order
+Module.markers
+build_tools/checkpatch.pl
+drivers/dahdi/xpp/*.verified
+drivers/dahdi/.tmp_versions/
+drivers/dahdi/Module.symvers
+drivers/dahdi/makefw
+drivers/dahdi/radfw.h
+drivers/dahdi/tor2fw.h
+drivers/dahdi/xpp/init_fxo_modes
+drivers/dahdi/xpp/print_fxo_modes
+drivers/dahdi/xpp/xpp_version.h
+include/dahdi/version.h
+drivers/dahdi/vpmadt032_loader/vpmadt032_loader.h
+drivers/dahdi/vpmadt032_loader/vpmadt032_x86_32.o_shipped
+drivers/dahdi/vpmadt032_loader/vpmadt032_x86_64.o_shipped
+drivers/dahdi/firmware/dahdi-fw-hx8.bin
+drivers/dahdi/firmware/dahdi-fw-oct6114-064.bin
+drivers/dahdi/firmware/dahdi-fw-oct6114-128.bin
+drivers/dahdi/firmware/dahdi-fw-oct6114-256.bin
+drivers/dahdi/firmware/dahdi-fw-tc400m.bin
+drivers/dahdi/firmware/dahdi-fw-te820.bin
+drivers/dahdi/firmware/dahdi-fw-vpmoct032.bin
+drivers/dahdi/firmware/dahdi-fw-a4a.bin
+drivers/dahdi/firmware/dahdi-fw-a4b.bin
+drivers/dahdi/firmware/dahdi-fw-a8a.bin
+drivers/dahdi/firmware/dahdi-fw-a8b.bin
+drivers/dahdi/firmware/dahdi-fw-oct6114-032.bin
+drivers/dahdi/firmware/dahdi-fw-te133.bin
+drivers/dahdi/firmware/dahdi-fw-te134.bin
+drivers/dahdi/firmware/dahdi-fw-te435.bin
+drivers/dahdi/firmware/make_firmware_object

Makefile

@@ -47,8 +47,6 @@ ifeq (yes,$(HAS_KSRC))
   HOTPLUG_FIRMWARE:=$(shell if grep -q '^CONFIG_FW_LOADER=[ym]' $(KCONFIG); then echo "yes"; else echo "no"; fi)
 endif
 
-UDEV_DIR:=/etc/udev/rules.d
-
 MODULE_ALIASES:=wcfxs wctdm8xxp wct2xxp
 
 INST_HEADERS:=kernel.h user.h fasthdlc.h wctdm_user.h dahdi_config.h
@@ -64,17 +62,7 @@ ASCIIDOC_CMD:=$(ASCIIDOC) -n -a toc -a toclevels=4
 
 GENERATED_DOCS:=README.html
 
-ifneq ($(wildcard .version),)
-  DAHDIVERSION:=$(shell cat .version)
-else
-ifneq ($(wildcard .svn),)
-  DAHDIVERSION:=$(shell build_tools/make_version . dahdi/linux)
-else
-ifneq ($(wildcard .git),)
-  DAHDIVERSION:=$(shell build_tools/make_version . dahdi/linux)
-endif
-endif
-endif
+DAHDIVERSION:=$(shell build_tools/make_version . dahdi/linux)
 
 all: modules
 
@@ -97,7 +85,7 @@ prereq: include/dahdi/version.h firmware-loaders
 stackcheck: $(CHECKSTACK) modules
 	objdump -d drivers/dahdi/*.ko drivers/dahdi/*/*.ko | $(CHECKSTACK)
 
-install: all install-modules install-devices install-include install-firmware install-xpp-firm
+install: all install-modules install-include install-firmware install-xpp-firm
 	@echo "###################################################"
 	@echo "###"
 	@echo "### DAHDI installed successfully."
@@ -106,7 +94,7 @@ install: all install-modules install-devices install-include install-firmware in
 	@echo "###"
 	@echo "###################################################"
 
-uninstall: uninstall-modules uninstall-devices uninstall-include uninstall-firmware
+uninstall: uninstall-modules uninstall-include uninstall-firmware
 
 install-modconf:
 	build_tools/genmodconf $(BUILDVER) "$(ROOT_PREFIX)" "$(filter-out dahdi dahdi_dummy xpp dahdi_transcode dahdi_dynamic,$(BUILD_MODULES)) $(MODULE_ALIASES)"
@@ -140,14 +128,6 @@ uninstall-include:
 	done
 	-rmdir $(DESTDIR)/usr/include/dahdi
 
-install-devices:
-	install -d $(DESTDIR)$(UDEV_DIR)
-	build_tools/genudevrules > $(DESTDIR)$(UDEV_DIR)/dahdi.rules
-	install -m 644 drivers/dahdi/xpp/xpp.rules $(DESTDIR)$(UDEV_DIR)/
-
-uninstall-devices:
-	rm -f $(DESTDIR)$(UDEV_DIR)/dahdi.rules
-
 install-modules: modules
 ifndef DESTDIR
 	@if modinfo zaptel > /dev/null 2>&1; then \
@@ -189,12 +169,16 @@ update:
 		echo "Not under version control";  \
 	fi
 
+dist:
+	@./build_tools/make_dist "dahdi-linux" "$(DAHDIVERSION)"
+
 clean:
 ifneq (no,$(HAS_KSRC))
 	$(KMAKE) clean
 endif
 	@rm -f $(GENERATED_DOCS)
 	$(MAKE) -C drivers/dahdi/firmware clean
+	$(MAKE) -C $(KSRC) M='$(PWD)/drivers/dahdi/oct612x' clean
 
 distclean: dist-clean
 
@@ -217,6 +201,6 @@ README.html: README
 dahdi-api.html: drivers/dahdi/dahdi-base.c
 	build_tools/kernel-doc --kernel $(KSRC) $^ >$@
 
-.PHONY: distclean dist-clean clean all install devices modules stackcheck install-udev update install-modules install-include uninstall-modules firmware-download install-xpp-firm firmware-loaders
+.PHONY: distclean dist-clean clean all install devices modules stackcheck install-udev update install-modules install-include uninstall-modules firmware-download install-xpp-firm firmware-loaders dist
 
 FORCE:

README

@@ -445,57 +445,17 @@ reside directly under /sys/module/'module_name' .
 
 Useful module parameters:
 
-debug (most modules)::
-  Sets debug mode / debug level. With most modules 'debug' can be either
-  disabled (0, the default value) or enabled (any other value). 
-  +
-  +
-  wctdm and wcte1xp print several extra debugging messages if the value
-  of debug is more than 1.
-  +
-  +
-  Some modules have "debugging flags" bits - the value of debug is a
-  bitmask and several messages are printed if some bits are set:
-  - wctdm24xxp:
-    * 1: DEBUG_CARD
-    * 2: DEBUG_ECHOCAN
-  - wct4xxp:
-    * 1: DEBUG_MAIN
-    * 2: DEBUG_DTMF
-    * 4: DEBUG_REGS
-    * 8: DEBUG_TSI
-    * 16: DEBUG_ECHOCAN
-    * 32: DEBUG_RBS
-    * 64: DEBUG_FRAMER
-  - xpp: See also README.Astribank:
-    * 1: GENERAL - General debug comments.
-    * 2: PCM - PCM-related messages. Tend to flood logs.
-    * 4: LEDS - Anything related to the LEDs status control. The driver
-      produces a lot of messages when the option is enabled.
-    * 8: SYNC - Synchronization related messages.
-    * 16: SIGNAL - DAHDI signalling related messages.
-    * 32: PROC - Messages related to the procfs interface.
-    * 64: REGS - Reading and writing to chip registers. Tends to flood
-          logs.
-    * 128: DEVICES - Device instantiation, destruction and such.
-    * 256 - COMMANDS - Protocol commands. Tends to flood logs.
+=== debug
+(most modules)
 
-deftaps (dahdi)::
-  The default size for the echo canceller. The number is in "taps", that
-  is "samples", 1/8 ms. The default is 64 - for a tail size of 8 ms.
-  +
-  +
-  Asterisk's chan_dahdi tends to pass its own value anyway, with a
-  different default size. So normally setting this doesn't change
-  anything.
+Sets debug mode / debug level. With most modules 'debug' can be either
+disabled (0, the default value) or enabled (any other value). 
 
-max_pseudo_channels (dahdi)::
-  The maximum number of pseudo channels that dahdi will allow userspace to
-  create.  Pseudo channels are used when conferencing channels together.
-  The default is 512.
+wctdm and wcte1xp print several extra debugging messages if the value
+of debug is more than 1.
 
-auto_assign_spans (dahdi)::
-  See <<_span_assignments,Span Assignments>> below.
+Some modules have "debugging flags" bits - the value of debug is a
+bitmask and several messages are printed if some bits are set:
 
 To get a list of parameters supported by a module, use 
 
@@ -503,13 +463,187 @@ To get a list of parameters supported by a module, use
 
 Or, for a module you have just built:
 
-  modinfo ./module_name.ko
+  modinfo ./drivers/dahdi/module_name.ko
 
 For the xpp modules this will also include the description and default
 value of the module. You can find a list of useful xpp module parameters
 in README.Astribank .
 
 
+- wctdm24xxp:
+  * 1: DEBUG_CARD
+  * 2: DEBUG_ECHOCAN
+- wct4xxp:
+  * 1: DEBUG_MAIN
+  * 2: DEBUG_DTMF
+  * 4: DEBUG_REGS
+  * 8: DEBUG_TSI
+  * 16: DEBUG_ECHOCAN
+  * 32: DEBUG_RBS
+  * 64: DEBUG_FRAMER
+- xpp: See also README.Astribank:
+  * 1: GENERAL - General debug comments.
+  * 2: PCM - PCM-related messages. Tend to flood logs.
+  * 4: LEDS - Anything related to the LEDs status control. The driver
+    produces a lot of messages when the option is enabled.
+  * 8: SYNC - Synchronization related messages.
+  * 16: SIGNAL - DAHDI signalling related messages.
+  * 32: PROC - Messages related to the procfs interface.
+  * 64: REGS - Reading and writing to chip registers. Tends to flood
+        logs.
+  * 128: DEVICES - Device instantiation, destruction and such.
+  * 256 - COMMANDS - Protocol commands. Tends to flood logs.
+  +
+  +
+  The script xpp_debug in the source tree can help settting them at run
+  time.
+
+=== deftaps
+(dahdi)
+
+The default size for the echo canceller. The number is in "taps", that
+is "samples", 1/8 ms. The default is 64 - for a tail size of 8 ms.
+
+Asterisk's chan_dahdi tends to pass its own value anyway, with a
+different default size. So normally setting this doesn't change
+anything.
+
+=== max_pseudo_channels
+(dahdi)
+
+The maximum number of pseudo channels that dahdi will allow userspace to
+create.  Pseudo channels are used when conferencing channels together.
+The default is 512.
+
+=== auto_assign_spans
+(dahdi)
+
+See <<_span_assignments,Span Assignments>> below.
+
+XPP (Astribank) module parameters
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== debug
+(all modules) - see above.
+
+==== dahdi_autoreg
+(xpp)
+
+Register spans automatically (1) or not (0). Default: 0.
+Setting it simplifies operations with a single Astribank and no other
+DAHDI hardware. However if you have such systems, automatic
+registration can cause the order of spans to be unpredictable.
+The standard startup scripts use 'dahdi_registration on' instead of this.
+
+==== tools_rootdir
+(xpp)
+
+Defaults to /. Passed (as the variable DAHDI_TOOLS_ROOTDIR) to generated
+events (which can be used in udev hooks). Also serves as the base of
+the variable DAHDI_INIT_DIR (by default: $DAHDI_TOOLS_DIR/usr/share/dahdi).
+
+==== initdir
+(xpp)
+
+Deprecated. Setting both initdir and tools_rootdir will generate an error.
+
+A directory under tools_rootdir containing the initialization scripts.
+The default is /usr/share/dahdi .
+Setting this value could be useful if that location is inconvenient for you.
+
+==== rx_tasklet
+(xpp)
+
+Enable (1) or disable (0) doing most of the packets processing in
+separate tasklets. This should probably help on higher-end systems with
+multiple Astribanks.
+
+==== vmwi_ioctl
+(xpd_fxs)
+
+Does userspace support VMWI notification via ioctl? Default: 1 (yes).
+
+Disable this (0) to have the driver attempt to detect the voicemail
+message waiting indication status for this port from FSK messages
+userspace (Asterisk) sends. Set the ports to use AC neon-lamp style
+message waiting indication. The detection from the FSK messages takes
+extra CPU cycles but is required with e.g. Asterisk < 1.6.0 .
+
+Also note that in order for this parameter to take effect, it must be
+set before the span is registered. This practically means that it
+should be set through modprobe.d files.
+
+See also Voicemail Indication in README.Astribank.
+
+==== usb1
+(xpp_usb)
+
+Enable (1) or disable (0) support of USB1 devices. Disabled by default.
+
+USB1 devices are not well-tested. It seems that they don't work at all
+for Astribank BRI. Generally they should work with the current code, but
+we expect the voice quality issues. Hence we would like to make it
+very clear that you if you have a USB1 port (rather than a USB2 one, as
+recommended) you will have to take an action to enable the device.
+
+==== poll intervals
+(various)
+
+There are various values which the driver occasionally polls the
+device for. For instance, the parameter poll_battery_interval for
+xpd_fxo to poll the battery, in order to know if the telco line is
+actually connected.
+
+The value of those parameters is typically a number in milliseconds.
+0 is used to disable polling. Under normal operation there should be
+no reason to play with those parameters.
+
+==== dtmf_detection
+(xpd_fxs)
+
+Enable (1) or disable (0) support of hardware DTMF detection by the
+Astribank.
+
+==== caller_id_style
+(xpd_fxo)
+
+Various types of caller ID signalling styles require knowing the PCM
+even when the line is on-hook (which is usually a waste of CPU and
+bandwidth). This parameter allows fine-tuning the behaviour here:
+
+* 0 (default) - Don't pass extra PCM when on-hook.
+* 1 ETSI-FSK: Wait for polarity reversal to come before a ring and
+  then start passing PCM until the caller ID has been passed.
+* 2 ETSI-DTMF: Always pass PCM and generate a DTMF if polarity reversal is
+  detected before ring.
+* 3 Passthrough: Always pass PCM as-is.
+
+This parameter is read-only. It cannot be changed at run-time.
+
+==== battery_threshold
+(xpd_fxo)
+
+Minimum voltage that shows there is battery. Defaults to 3. Normally you
+should not need to change this, unless dealing with a funky PSTN
+provider.
+
+==== battery_debounce
+(xpd_fxo)
+
+Minimum interval (msec) for detection of battery off (as opposed to e.g.
+a temporary power denial to signal a hangup). Defaults to 1000. As with
+battery_threshold above, there's normally no need to tweak it.
+
+==== use_polrev_firmware
+(xpd_fxo)
+
+Enable (1, default) or disable (0) support for polarity reversal
+detection in the hardware. Only has effect with PIC_TYPE_2.hex rev. >=
+11039 and with the initialization changes (init_card_2_30) in rev.
+949aa49.
+
+This parameter is read-only. It cannot be changed at run-time.
+
+
 Internals
 ---------
 DAHDI Device Files
@@ -521,9 +655,14 @@ or dynamically through the udev system.
 
 * /dev/dahdi/ctl (196:0) - a general device file for various information and
   control operations on the DAHDI channels.
+* /dev/dahdi/chan/N/M - A device file for channel M in span N
+  - Both N and M are zero padded 3 digit numbers
+  - Both N and M start at 001
+  - M is chanpos - numbering relative to the current span.
 * /dev/dahdi/NNN (196:NNN) - for NNN in the range 1-249. A device file for
   DAHDI channel NNN. It can be used to read data from the channel
-  and write data to the channel.
+  and write data to the channel. It is not generated by default but may
+  be generated as a symlink using udev rules.
 * /dev/dahdi/transcode (196:250) - Used to connect to a DAHDI transcoding
   device.
 * /dev/dahdi/timer (196:253) - Allows setting timers. Used anywhere?
@@ -850,6 +989,66 @@ A very short type string.
 ===== /sys/bus/dahdi_spans/devices/span-N/syncsrc
 Current sync source.
 
+==== sys/bus/dahdi_spans/drivers/generic_lowlevel/master_span
+All spans in the bus are handled by a single driver. The driver has one
+non-standard attribute: master_span. printing it shows the current DAHDI
+master span writing a number to it forces setting this span as the master
+span.
+
+
+Channels Bus
+^^^^^^^^^^^^
+Each DAHDI channel is represented by a node under
+/sys/bus/dahdi_channels/devices with the name 'dahdi!channels!N!M'
+(where N is the number of the span and M is the number of the channel
+in the span - chanpos). Channels of each span also reside under the node
+of the span.
+
+Useful attributes in the channel node (All attributed listed below are
+read-only):
+
+===== /sys/bus/dahdi_spans/devices/span-N/dahdi!channels!N!M/alarms
+List of names of the current active alarms (space separated). Normally
+(no alarms) empty. Example:
+
+  RED YELLOW
+
+===== /sys/bus/dahdi_spans/devices/span-N/dahdi!channels!N!M/blocksize
+The block size set by userspace.
+
+===== /sys/bus/dahdi_spans/devices/span-N/dahdi!channels!N!M/channo
+The (global) channel number.
+
+===== /sys/bus/dahdi_spans/devices/span-N/dahdi!channels!N!M/chanpos
+The channel number within the span.
+
+===== /sys/bus/dahdi_spans/devices/span-N/dahdi!channels!N!M/dev
+Major and minor device numbers.
+
+===== /sys/bus/dahdi_spans/devices/span-N/dahdi!channels!N!M/ec_factory
+The name of the echo canceller to be used in the channel, if one is
+configured. Example:
+
+  MG2
+
+===== /sys/bus/dahdi_spans/devices/span-N/dahdi!channels!N!M/ec_state
+State of the echo canceller. ACTIVE: configured and inuse. INACTIVE
+otherwise.
+
+===== /sys/bus/dahdi_spans/devices/span-N/dahdi!channels!N!M/in_use
+1 if the channel is in use (was opepend by userspace), 0 otherwise.
+
+===== /sys/bus/dahdi_spans/devices/span-N/dahdi!channels!N!M/name
+A name string for the channel
+
+===== /sys/bus/dahdi_spans/devices/span-N/dahdi!channels!N!M/sig
+The signalling types set for the channel. A space-separated list of
+signalling types.
+
+===== /sys/bus/dahdi_spans/devices/span-N/dahdi!channels!N!M/sigcap
+The signalling types this channel may be configured to handle. A space-
+separated list of signalling types.
+
 
 User-space Interface
 ~~~~~~~~~~~~~~~~~~~~

build_tools/genudevrules

@@ -1,40 +0,0 @@
-#!/bin/sh
-
-ver=`udevinfo -V | cut -f3 -d" "`
-
-if [ -z "${ver}" ]; then
-   # Not found - try udevadm
-   ver=`udevadm info -V | cut -f3 -d" "`
-
-   if [ -z "${ver}" ]; then
-      # nobody has that old version, anyway.
-      ver=54
-   fi
-fi
-
-# udev versions prior to 055 use a single '=' for matching key values
-# udev versions 055 and later support '==' for that purpose, and versions
-# beyond 092 will probably make it mandatory
-#
-# very old versions of udev required naming rules and permissions rules to be
-# in separate files, but it's not clear at what version number that changed
-
-if [ ${ver} -gt 54 ]; then
-    match="=="
-else
-    match="="
-fi
-
-cat <<EOF
-# udev rules to generate the /dev/dahdi device files (if not yet provided 
-# by your distribution):
-KERNEL${match}"dahdictl", NAME="dahdi/ctl"
-KERNEL${match}"dahditranscode", NAME="dahdi/transcode"
-KERNEL${match}"dahditimer", NAME="dahdi/timer"
-KERNEL${match}"dahdichannel", NAME="dahdi/channel"
-KERNEL${match}"dahdipseudo", NAME="dahdi/pseudo"
-KERNEL${match}"dahdi[0-9]*", NAME="dahdi/%n"
-
-# DAHDI devices with ownership/permissions for running as non-root
-SUBSYSTEM${match}"dahdi",  OWNER="asterisk", GROUP="asterisk", MODE="0660"
-EOF

build_tools/live_dahdi

@@ -61,7 +61,7 @@ export ASTRIBANK_HEXLOAD
 
 # make sure Astribank initialization scripts are from our tree.
 xpp_ARGS="$xpp_ARGS initdir=$FIRMWARE_DIR"
-#dahdi_ARGS="$dahdi_ARGS initdir=$FIRMWARE_DIR"
+dahdi_ARGS="$dahdi_ARGS tools_rootdir=$DESTDIR"
 
 if [ "$DYNAMIC_LOC" = 'yes' ]; then
 	MODULES_LOAD="$MODULES_LOAD dahdi_dynamic dahdi_dynamic_loc"

build_tools/make_dist

@@ -0,0 +1,26 @@
+#! /bin/sh
+
+if [ "$#" -ne 2 ]; then
+	echo >&2 "Usage: $0 <package> <version>"
+	exit 1
+fi
+package="$1"
+version="$2"
+tarball_prefix="$package-$version"
+echo "I: Making dist tarball for $tarball_prefix"
+tarball_name="$tarball_prefix.tar.gz"
+
+tmp_work_dir=".tmp"
+tmp_version_dir="$tmp_work_dir/$tarball_prefix"
+
+if [ "$DESTDIR" != '' ]; then
+	destdir="$DESTDIR/"
+fi
+output="$destdir$tarball_name"
+
+mkdir -p "$tmp_version_dir"
+git archive --format tar HEAD | tar xf - -C "$tmp_version_dir"
+echo "$version" > "$tmp_version_dir/.version"
+tar czf "$output" -C "$tmp_work_dir" "$tarball_prefix"
+rm -rf "$tmp_work_dir"
+echo "I: tarball is ready: '$output'"

build_tools/make_version

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 if [ -f ${1}/.version ]; then
-	cat ${1}.version
+	cat ${1}/.version
 elif [ -f ${1}/.svnrevision ]; then
 	echo SVN-`cat ${1}/.svnbranch`-r`cat ${1}/.svnrevision`
 elif [ -d ${1}/.svn ]; then
@@ -59,7 +59,7 @@ elif [ -d ${1}/.git ]; then
     MODIFIED=""
     SVN_REV=`git log --pretty=full -1 | grep -F "git-svn-id:" | sed -e "s/.*\@\([^\s]*\)\s.*/\1/g"`
     if [ -z "$SVN_REV" ]; then
-        VERSION=`git describe --long --always --tags --dirty=M 2> /dev/null`
+        VERSION=`git describe --tags --dirty=M 2> /dev/null | sed -e "s/^v\([0-9]\)/\1/"`
         if [ $? -ne 0 ]; then
             if [ "`git ls-files -m | wc -l`" != "0" ]; then
                 MODIFIED="M"
@@ -115,4 +115,8 @@ elif [ -d ${1}/.git ]; then
 
         echo SVN-${RESULT##-}-r${SVN_REV}${MODIFIED}
     fi
+else
+	# Use the directory information in the absence of any other version
+	# information
+	pwd -P
 fi

drivers/dahdi/Kbuild

@@ -7,10 +7,35 @@ obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_DYNAMIC_ETHMF)	+= dahdi_dynamic_ethmf.o
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_TRANSCODE)		+= dahdi_transcode.o
 
 ifdef CONFIG_PCI
+obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_OCT612X)		+= oct612x/
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCT4XXP)		+= wct4xxp/
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCTC4XXP)		+= wctc4xxp/
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCTDM24XXP)	+= wctdm24xxp/
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCTE12XP)		+= wcte12xp/
+obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCTE13XP)		+= wcte13xp.o
+
+wcte13xp-objs := wcte13xp-base.o wcxb_spi.o wcxb.o wcxb_flash.o
+CFLAGS_wcte13xp-base.o += -I$(src)/oct612x -I$(src)/oct612x/include -I$(src)/oct612x/octdeviceapi -I$(src)/oct612x/octdeviceapi/oct6100api
+ifeq ($(HOTPLUG_FIRMWARE),yes)
+  CFLAGS_wcte13xp-base.o += -DHOTPLUG_FIRMWARE
+endif
+
+obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCTE43X)		+= wcte43x.o
+
+wcte43x-objs := wcte43x-base.o wcxb_spi.o wcxb.o wcxb_flash.o
+CFLAGS_wcte43x-base.o += -I$(src)/oct612x -I$(src)/oct612x/include -I$(src)/oct612x/octdeviceapi -I$(src)/oct612x/octdeviceapi/oct6100api
+ifeq ($(HOTPLUG_FIRMWARE),yes)
+  CFLAGS_wcte43x-base.o += -DHOTPLUG_FIRMWARE
+endif
+
+obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCAXX)		+= wcaxx.o
+
+wcaxx-objs := wcaxx-base.o wcxb_spi.o wcxb.o wcxb_flash.o
+CFLAGS_wcaxx-base.o += -I$(src)/oct612x/ -I$(src)/oct612x/include -I$(src)/oct612x/octdeviceapi -I$(src)/oct612x/octdeviceapi/oct6100api
+ifeq ($(HOTPLUG_FIRMWARE),yes)
+  CFLAGS_wcaxx-base.o += -DHOTPLUG_FIRMWARE
+endif
+
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCTDM)		+= wctdm.o
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_VOICEBUS)		+= voicebus/
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCB4XXP)		+= wcb4xxp/
@@ -38,7 +63,7 @@ obj-m += $(DAHDI_MODULES_EXTRA)
 # well:
 ifneq (,$(wildcard $(src)/../staging/echo/echo.c))
 obj-m += dahdi_echocan_oslec.o
-obj-m += ../staging/echo/
+obj-m += ../staging/echo/echo.o
 endif
 
 CFLAGS_MODULE += -I$(DAHDI_INCLUDE) -I$(src)

drivers/dahdi/dahdi-base.c

@@ -173,9 +173,20 @@ static sumtype *conf_sums_next;
 static sumtype *conf_sums;
 static sumtype *conf_sums_prev;
 
-static struct dahdi_span *master;
+static struct dahdi_span *master_span;
 struct file_operations *dahdi_transcode_fops = NULL;
 
+
+#ifdef CONFIG_DAHDI_CONFLINK
+static struct {
+	int	src;	/* source conf number */
+	int	dst;	/* dst conf number */
+} conf_links[DAHDI_MAX_CONF + 1];
+
+static int maxlinks;
+
+#endif
+
 #ifdef CONFIG_DAHDI_CORE_TIMER
 
 static struct core_timer {
@@ -283,6 +294,7 @@ static inline void dahdi_kernel_fpu_end(void)
 #endif
 
 struct dahdi_timer {
+	spinlock_t lock;
 	int ms;			/* Countdown */
 	int pos;		/* Position */
 	int ping;		/* Whether we've been ping'd */
@@ -599,7 +611,7 @@ void dahdi_unregister_echocan_factory(const struct dahdi_echocan_factory *ec)
 /* Is this span our syncronization master? */
 int dahdi_is_sync_master(const struct dahdi_span *span)
 {
-	return span == master;
+	return span == master_span;
 }
 
 static inline void rotate_sums(void)
@@ -720,6 +732,8 @@ enum spantypes dahdi_str2spantype(const char *name)
 		return SPANTYPE_DIGITAL_BRI_TE;
 	else if (strcasecmp("BRI_SOFT", name) == 0)
 		return SPANTYPE_DIGITAL_BRI_SOFT;
+	else if (strcasecmp("DYNAMIC", name) == 0)
+		return SPANTYPE_DIGITAL_DYNAMIC;
 	else
 		return SPANTYPE_INVALID;
 }
@@ -737,6 +751,7 @@ const char *dahdi_spantype2str(enum spantypes st)
 	case SPANTYPE_DIGITAL_BRI_NT:	return "BRI_NT";
 	case SPANTYPE_DIGITAL_BRI_TE:	return "BRI_TE";
 	case SPANTYPE_DIGITAL_BRI_SOFT:	return "BRI_SOFT";
+	case SPANTYPE_DIGITAL_DYNAMIC:	return "DYNAMIC";
 	default:
 	case SPANTYPE_INVALID:		return "INVALID";
 	};
@@ -775,6 +790,7 @@ ssize_t lineconfig_str(int lineconfig, char buf[], size_t size)
 	int crc4_bit = 0;
 	int len = 0;
 	int bit;
+	bool written = false;
 
 	for (bit = 4; bit <= 12; bit++) {
 		int mask = (1 << bit);
@@ -786,8 +802,10 @@ ssize_t lineconfig_str(int lineconfig, char buf[], size_t size)
 			case DAHDI_CONFIG_AMI:
 			case DAHDI_CONFIG_HDB3:
 				framing_bit = bit;
-				len += snprintf(buf + len, size, "%s/",
+				len += snprintf(buf + len, size, "%s%s",
+					(written) ? "/" : "",
 					dahdi_lineconfig_bit_name(bit));
+				written = true;
 			}
 		}
 		if (!coding_bit) {
@@ -796,14 +814,18 @@ ssize_t lineconfig_str(int lineconfig, char buf[], size_t size)
 			case DAHDI_CONFIG_D4:
 			case DAHDI_CONFIG_CCS:
 				coding_bit = bit;
-				len += snprintf(buf + len, size, "%s",
+				len += snprintf(buf + len, size, "%s%s",
+					(written) ? "/" : "",
 					dahdi_lineconfig_bit_name(bit));
+				written = true;
 			}
 		}
 		if (!crc4_bit && mask == DAHDI_CONFIG_CRC4) {
 				crc4_bit = bit;
-				len += snprintf(buf + len, size, "/%s",
+				len += snprintf(buf + len, size, "%s%s",
+					(written) ? "/" : "",
 					dahdi_lineconfig_bit_name(bit));
+				written = true;
 		}
 	}
 	return len;
@@ -811,7 +833,7 @@ ssize_t lineconfig_str(int lineconfig, char buf[], size_t size)
 EXPORT_SYMBOL(lineconfig_str);
 
 #ifdef CONFIG_PROC_FS
-static const char *sigstr(int sig)
+const char *sigstr(int sig)
 {
 	switch (sig) {
 	case DAHDI_SIG_FXSLS:
@@ -858,7 +880,7 @@ static const char *sigstr(int sig)
 	}
 }
 
-static int fill_alarm_string(char *buf, int count, int alarms)
+int fill_alarm_string(char *buf, int count, int alarms)
 {
 	int len;
 
@@ -888,7 +910,7 @@ static void seq_fill_alarm_string(struct seq_file *sfile, int alarms)
 		seq_printf(sfile, "%s", tmp);
 }
 
-static int dahdi_seq_show(struct seq_file *sfile, void *v)
+static int dahdi_seq_show(struct seq_file *sfile, void *data)
 {
 	long spanno = (long)sfile->private;
 	int x;
@@ -932,8 +954,8 @@ static int dahdi_seq_show(struct seq_file *sfile, void *v)
 		seq_printf(sfile, "\tFAS error count: %d\n", s->count.fas);
 	if (s->parent->irqmisses)
 		seq_printf(sfile, "\tIRQ misses: %d\n", s->parent->irqmisses);
-	if (s->timingslips)
-		seq_printf(sfile, "\tTiming slips: %d\n", s->timingslips);
+	if (s->count.timingslips)
+		seq_printf(sfile, "\tTiming slips: %d\n", s->count.timingslips);
 	seq_printf(sfile, "\n");
 
 	for (x = 0; x < s->channels; x++) {
@@ -980,7 +1002,7 @@ static int dahdi_seq_show(struct seq_file *sfile, void *v)
 
 static int dahdi_proc_open(struct inode *inode, struct file *file)
 {
-	return single_open(file, dahdi_seq_show, PDE(inode)->data);
+	return single_open(file, dahdi_seq_show, PDE_DATA(inode));
 }
 
 static const struct file_operations dahdi_proc_ops = {
@@ -1060,10 +1082,29 @@ static unsigned long _chan_in_conf(struct dahdi_chan *chan, unsigned long x)
 	     confmode == DAHDI_CONF_REALANDPSEUDO)) ? 1 : 0;
 }
 
+#ifdef CONFIG_DAHDI_CONFLINK
+static void recalc_maxlinks(void)
+{
+	int x;
+
+	for (x = DAHDI_MAX_CONF - 1; x > 0; x--) {
+		if (conf_links[x].src || conf_links[x].dst) {
+			maxlinks = x + 1;
+			return;
+		}
+	}
+
+	maxlinks = 0;
+}
+#endif
+
 static void dahdi_check_conf(int x)
 {
 	unsigned long res;
 	unsigned long flags;
+#ifdef CONFIG_DAHDI_CONFLINK
+	int i;
+#endif
 
 	/* return if no valid conf number */
 	if (x <= 0)
@@ -1086,6 +1127,17 @@ static void dahdi_check_conf(int x)
 
 	/* Highest conference may have changed */
 	recalc_maxconfs();
+
+#ifdef CONFIG_DAHDI_CONFLINK
+	/* And unlink it from any conflinks */
+	for (i = DAHDI_MAX_CONF - 1; i > 0; i--) {
+		if (conf_links[i].src == x)
+			conf_links[i].src = 0;
+		if (conf_links[i].dst == x)
+			conf_links[i].dst = 0;
+	}
+	recalc_maxlinks();
+#endif
 }
 
 /* enqueue an event on a channel */
@@ -1922,7 +1974,6 @@ static int dahdi_net_open(struct net_device *dev)
 		return -EINVAL;
 	}
 	ms->txbufpolicy = DAHDI_POLICY_IMMEDIATE;
-	ms->rxbufpolicy = DAHDI_POLICY_IMMEDIATE;
 
 	res = dahdi_reallocbufs(ms, DAHDI_DEFAULT_MTU_MRU, DAHDI_DEFAULT_NUM_BUFS);
 	if (res)
@@ -2957,50 +3008,42 @@ static int initialize_channel(struct dahdi_chan *chan)
 	return 0;
 }
 
-static int dahdi_timing_open(struct file *file)
+static const struct file_operations dahdi_timer_fops;
+
+static int dahdi_timer_open(struct file *file)
 {
-	struct dahdi_timer *t;
-	unsigned long flags;
-
-	if (!(t = kzalloc(sizeof(*t), GFP_KERNEL)))
+	struct dahdi_timer *t = kzalloc(sizeof(*t), GFP_KERNEL);
+	if (!t)
 		return -ENOMEM;
-
-	init_waitqueue_head(&t->sel);
 	INIT_LIST_HEAD(&t->list);
+	init_waitqueue_head(&t->sel);
 	file->private_data = t;
-
-	spin_lock_irqsave(&dahdi_timer_lock, flags);
-	list_add(&t->list, &dahdi_timers);
-	spin_unlock_irqrestore(&dahdi_timer_lock, flags);
+	spin_lock_init(&t->lock);
+	file->f_op = &dahdi_timer_fops;
 
 	return 0;
 }
 
-static int dahdi_timer_release(struct file *file)
+static int dahdi_timer_release(struct inode *inode, struct file *file)
 {
-	struct dahdi_timer *t, *cur, *next;
+	struct dahdi_timer *timer = file->private_data;
 	unsigned long flags;
 
-	if (!(t = file->private_data))
+	if (!timer)
 		return 0;
 
-	spin_lock_irqsave(&dahdi_timer_lock, flags);
-
-	list_for_each_entry_safe(cur, next, &dahdi_timers, list) {
-		if (t == cur) {
-			list_del(&cur->list);
-			break;
-		}
+	spin_lock_irqsave(&timer->lock, flags);
+	if (!list_empty(&timer->list)) {
+		spin_unlock(&timer->lock);
+		spin_lock(&dahdi_timer_lock);
+		spin_lock(&timer->lock);
+		list_del_init(&timer->list);
+		spin_unlock(&dahdi_timer_lock);
 	}
+	file->private_data = NULL;
+	spin_unlock_irqrestore(&timer->lock, flags);
 
-	spin_unlock_irqrestore(&dahdi_timer_lock, flags);
-
-	if (!cur) {
-		module_printk(KERN_NOTICE, "Timer: Not on list??\n");
-		return 0;
-	}
-
-	kfree(cur);
+	kfree(timer);
 
 	return 0;
 }
@@ -3238,7 +3281,7 @@ static int dahdi_open(struct inode *inode, struct file *file)
 	}
 	if (unit == DAHDI_TIMER) {
 		if (can_open_timer()) {
-			return dahdi_timing_open(file);
+			return dahdi_timer_open(file);
 		} else {
 			return -ENXIO;
 		}
@@ -3740,7 +3783,7 @@ static int dahdi_release(struct inode *inode, struct file *file)
 	if (unit == DAHDI_CTL)
 		return dahdi_ctl_release(file);
 	if (unit == DAHDI_TIMER) {
-		return dahdi_timer_release(file);
+		return dahdi_timer_release(inode, file);
 	}
 	if (unit == DAHDI_TRANSCODE) {
 		/* We should not be here because the dahdi_transcode.ko module
@@ -3800,6 +3843,31 @@ void dahdi_alarm_channel(struct dahdi_chan *chan, int alarms)
 	spin_unlock_irqrestore(&chan->lock, flags);
 }
 
+struct dahdi_span *get_master_span(void)
+{
+	return master_span;
+}
+
+void set_master_span(int spanno)
+{
+	struct dahdi_span *s;
+	unsigned long flags;
+	struct dahdi_span *old_master;
+
+	spin_lock_irqsave(&chan_lock, flags);
+	old_master = master_span;
+	list_for_each_entry(s, &span_list, spans_node) {
+		if (spanno == s->spanno) {
+			master_span = s;
+			break;
+		}
+	}
+	spin_unlock_irqrestore(&chan_lock, flags);
+	if ((debug & DEBUG_MAIN) && (old_master != master_span))
+		module_printk(KERN_NOTICE, "Master span is set to %d (%s)\n",
+			master_span->spanno, master_span->name);
+}
+
 static void __dahdi_find_master_span(void)
 {
 	struct dahdi_span *s;
@@ -3807,7 +3875,7 @@ static void __dahdi_find_master_span(void)
 	struct dahdi_span *old_master;
 
 	spin_lock_irqsave(&chan_lock, flags);
-	old_master = master;
+	old_master = master_span;
 	list_for_each_entry(s, &span_list, spans_node) {
 		if (s->alarms && old_master)
 			continue;
@@ -3817,15 +3885,15 @@ static void __dahdi_find_master_span(void)
 			continue;
 		if (!can_provide_timing(s))
 			continue;
-		if (master == s)
+		if (master_span == s)
 			continue;
 
-		master = s;
+		master_span = s;
 		break;
 	}
 	spin_unlock_irqrestore(&chan_lock, flags);
 
-	if ((debug & DEBUG_MAIN) && (old_master != master))
+	if ((debug & DEBUG_MAIN) && (old_master != master_span))
 		module_printk(KERN_NOTICE, "Master changed to %s\n", s->name);
 }
 
@@ -3866,7 +3934,7 @@ void dahdi_alarm_notify(struct dahdi_span *span)
 			dahdi_alarm_channel(span->chans[x], span->alarms);
 
 		/* If we're going into or out of alarm we should try to find a
-		 * new master that may be a better fit. */
+		 * new master_span that may be a better fit. */
 		dahdi_find_master_span();
 
 		/* Report more detailed alarms */
@@ -3890,48 +3958,74 @@ void dahdi_alarm_notify(struct dahdi_span *span)
 	}
 }
 
-static int dahdi_timer_ioctl(struct file *file, unsigned int cmd, unsigned long data, struct dahdi_timer *timer)
+static long
+dahdi_timer_unlocked_ioctl(struct file *file, unsigned int cmd,
+			   unsigned long data)
 {
 	int j;
 	unsigned long flags;
+	struct dahdi_timer *const timer = file->private_data;
+
 	switch(cmd) {
 	case DAHDI_TIMERCONFIG:
 		get_user(j, (int __user *)data);
 		if (j < 0)
 			j = 0;
-		spin_lock_irqsave(&dahdi_timer_lock, flags);
-		timer->ms = timer->pos = j;
-		spin_unlock_irqrestore(&dahdi_timer_lock, flags);
+		spin_lock_irqsave(&timer->lock, flags);
+		if (timer->ms != j) {
+			if (j && list_empty(&timer->list)) {
+				/* The timer is being activated so add to the
+				 * global timer list. */
+				spin_unlock(&timer->lock);
+				spin_lock(&dahdi_timer_lock);
+				spin_lock(&timer->lock);
+				timer->ms = timer->pos = j;
+				list_add(&timer->list, &dahdi_timers);
+				spin_unlock(&dahdi_timer_lock);
+			} else if (!j && !list_empty(&timer->list)) {
+				/* The timer is being disabled so we can remove
+				 * from the global timer list. */
+				spin_unlock(&timer->lock);
+				spin_lock(&dahdi_timer_lock);
+				spin_lock(&timer->lock);
+				list_del_init(&timer->list);
+				timer->ms = timer->pos = j;
+				spin_unlock(&dahdi_timer_lock);
+			} else {
+				timer->ms = timer->pos = j;
+			}
+		}
+		spin_unlock_irqrestore(&timer->lock, flags);
 		break;
 	case DAHDI_TIMERACK:
 		get_user(j, (int __user *)data);
-		spin_lock_irqsave(&dahdi_timer_lock, flags);
+		spin_lock_irqsave(&timer->lock, flags);
 		if ((j < 1) || (j > timer->tripped))
 			j = timer->tripped;
 		timer->tripped -= j;
-		spin_unlock_irqrestore(&dahdi_timer_lock, flags);
+		spin_unlock_irqrestore(&timer->lock, flags);
 		break;
 	case DAHDI_GETEVENT:  /* Get event on queue */
 		j = DAHDI_EVENT_NONE;
-		spin_lock_irqsave(&dahdi_timer_lock, flags);
+		spin_lock_irqsave(&timer->lock, flags);
 		  /* set up for no event */
 		if (timer->tripped)
 			j = DAHDI_EVENT_TIMER_EXPIRED;
 		if (timer->ping)
 			j = DAHDI_EVENT_TIMER_PING;
-		spin_unlock_irqrestore(&dahdi_timer_lock, flags);
+		spin_unlock_irqrestore(&timer->lock, flags);
 		put_user(j, (int __user *)data);
 		break;
 	case DAHDI_TIMERPING:
-		spin_lock_irqsave(&dahdi_timer_lock, flags);
+		spin_lock_irqsave(&timer->lock, flags);
 		timer->ping = 1;
 		wake_up_interruptible(&timer->sel);
-		spin_unlock_irqrestore(&dahdi_timer_lock, flags);
+		spin_unlock_irqrestore(&timer->lock, flags);
 		break;
 	case DAHDI_TIMERPONG:
-		spin_lock_irqsave(&dahdi_timer_lock, flags);
+		spin_lock_irqsave(&timer->lock, flags);
 		timer->ping = 0;
-		spin_unlock_irqrestore(&dahdi_timer_lock, flags);
+		spin_unlock_irqrestore(&timer->lock, flags);
 		break;
 	default:
 		return -ENOTTY;
@@ -3939,6 +4033,14 @@ static int dahdi_timer_ioctl(struct file *file, unsigned int cmd, unsigned long
 	return 0;
 }
 
+#ifndef HAVE_UNLOCKED_IOCTL
+static int dahdi_timer_ioctl(struct inode *inode, struct file *file,
+		unsigned int cmd, unsigned long data)
+{
+	return dahdi_timer_unlocked_ioctl(file, cmd, data);
+}
+#endif
+
 static int dahdi_ioctl_getgains(struct file *file, unsigned long data)
 {
 	int res = 0;
@@ -4480,6 +4582,90 @@ static int dahdi_ioctl_spanstat_v1(struct file *file, unsigned long data)
 	return ret;
 }
 
+#ifdef CONFIG_DAHDI_CONFLINK
+static int dahdi_ioctl_conflink(struct file *file, unsigned long data)
+{
+	struct dahdi_chan *chan;
+	struct dahdi_confinfo conf;
+	unsigned long flags;
+	int res = 0;
+	int i;
+
+	chan = chan_from_file(file);
+	if (!chan)
+		return -EINVAL;
+	if (!(chan->flags & DAHDI_FLAG_AUDIO))
+		return -EINVAL;
+	if (copy_from_user(&conf, (void __user *)data, sizeof(conf)))
+		return -EFAULT;
+	/* check sanity of arguments */
+	if ((conf.chan < 0) || (conf.chan > DAHDI_MAX_CONF))
+		return -EINVAL;
+	if ((conf.confno < 0) || (conf.confno > DAHDI_MAX_CONF))
+		return -EINVAL;
+	/* cant listen to self!! */
+	if (conf.chan && (conf.chan == conf.confno))
+		return -EINVAL;
+
+	spin_lock_irqsave(&chan_lock, flags);
+	spin_lock(&chan->lock);
+
+	/* if to clear all links */
+	if ((!conf.chan) && (!conf.confno)) {
+		/* clear all the links */
+		memset(conf_links, 0, sizeof(conf_links));
+		recalc_maxlinks();
+		spin_unlock(&chan->lock);
+		spin_unlock_irqrestore(&chan_lock, flags);
+		return 0;
+	}
+	/* look for already existant specified combination */
+	for (i = 1; i <= DAHDI_MAX_CONF; i++) {
+		/* if found, exit */
+		if ((conf_links[i].src == conf.chan) &&
+		    (conf_links[i].dst == conf.confno))
+			break;
+	}
+	if (i <= DAHDI_MAX_CONF) { /* if found */
+		if (!conf.confmode) { /* if to remove link */
+			conf_links[i].src = 0;
+			conf_links[i].dst = 0;
+		} else { /* if to add and already there, error */
+			res = -EEXIST;
+		}
+	} else { /* if not found */
+		if (conf.confmode) { /* if to add link */
+			/* look for empty location */
+			for (i = 1; i <= DAHDI_MAX_CONF; i++) {
+				/* if empty, exit loop */
+				if ((!conf_links[i].src) &&
+				    (!conf_links[i].dst))
+					break;
+			}
+			/* if empty spot found */
+			if (i <= DAHDI_MAX_CONF) {
+				conf_links[i].src = conf.chan;
+				conf_links[i].dst = conf.confno;
+			} else { /* if no empties -- error */
+				res = -ENOSPC;
+			 }
+		} else { /* if to remove, and not found -- error */
+			res = -ENOENT;
+		}
+	}
+	recalc_maxlinks();
+	spin_unlock(&chan->lock);
+	spin_unlock_irqrestore(&chan_lock, flags);
+	return res;
+}
+#else
+static int dahdi_ioctl_conflink(struct file *file, unsigned long data)
+{
+	return -ENOSYS;
+}
+#endif
+
+
 static int dahdi_common_ioctl(struct file *file, unsigned int cmd,
 			      unsigned long data)
 {
@@ -4508,6 +4694,10 @@ static int dahdi_common_ioctl(struct file *file, unsigned int cmd,
 	case DAHDI_CHANDIAG_V1: /* Intentional drop through. */
 	case DAHDI_CHANDIAG:
 		return dahdi_ioctl_chandiag(file, data);
+
+	case DAHDI_CONFLINK:
+		return dahdi_ioctl_conflink(file, data);
+
 	default:
 		return -ENOTTY;
 	}
@@ -4974,18 +5164,35 @@ static int dahdi_ioctl_startup(struct file *file, unsigned long data)
 		}
 
 		/* Now that this span is running, it might be selected as the
-		 * master span */
+		 * master_span */
 		__dahdi_find_master_span();
 	}
 	put_span(s);
 	return res;
 }
 
+static int dahdi_shutdown_span(struct dahdi_span *s)
+{
+	int res = 0;
+	int x;
+
+	/* Unconfigure channels */
+	for (x = 0; x < s->channels; x++)
+		s->chans[x]->sig = 0;
+
+	if (s->ops->shutdown)
+		res = s->ops->shutdown(s);
+
+	clear_bit(DAHDI_FLAGBIT_RUNNING, &s->flags);
+	return res;
+}
+
 static int dahdi_ioctl_shutdown(unsigned long data)
 {
+	int res;
 	/* I/O CTL's for control interface */
 	int j;
-	int x;
+
 	struct dahdi_span *s;
 
 	if (get_user(j, (int __user *)data))
@@ -4993,22 +5200,9 @@ static int dahdi_ioctl_shutdown(unsigned long data)
 	s = span_find_and_get(j);
 	if (!s)
 		return -ENXIO;
-
-	/* Unconfigure channels */
-	for (x = 0; x < s->channels; x++)
-		s->chans[x]->sig = 0;
-
-	if (s->ops->shutdown) {
-		int res = s->ops->shutdown(s);
-		if (res) {
-			put_span(s);
-			return res;
-		}
-	}
-
-	s->flags &= ~DAHDI_FLAG_RUNNING;
+	res = dahdi_shutdown_span(s);
 	put_span(s);
-	return 0;
+	return res;
 }
 
 /**
@@ -5210,7 +5404,8 @@ static int dahdi_ioctl_maint(unsigned long data)
 	spin_lock_irqsave(&s->lock, flags);
 	  /* save current maint state */
 	i = s->maintstat;
-
+	  /* set maint mode */
+	s->maintstat = maint.command;
 	switch (maint.command) {
 	case DAHDI_MAINT_NONE:
 	case DAHDI_MAINT_LOCALLOOP:
@@ -5223,6 +5418,8 @@ static int dahdi_ioctl_maint(unsigned long data)
 		spin_unlock_irqrestore(&s->lock, flags);
 		if (rv) {
 			put_span(s);
+			/* Restore the state on error */
+			s->maintstat = i;
 			return rv;
 		}
 		spin_lock_irqsave(&s->lock, flags);
@@ -5234,6 +5431,8 @@ static int dahdi_ioctl_maint(unsigned long data)
 		spin_unlock_irqrestore(&s->lock, flags);
 		if (rv) {
 			put_span(s);
+			/* Restore the state on error */
+			s->maintstat = i;
 			return rv;
 		}
 		spin_lock_irqsave(&s->lock, flags);
@@ -5257,6 +5456,8 @@ static int dahdi_ioctl_maint(unsigned long data)
 		spin_unlock_irqrestore(&s->lock, flags);
 		if (rv) {
 			put_span(s);
+			/* Restore the state on error */
+			s->maintstat = i;
 			return rv;
 		}
 		spin_lock_irqsave(&s->lock, flags);
@@ -5267,12 +5468,10 @@ static int dahdi_ioctl_maint(unsigned long data)
 			      "Unknown maintenance event: %d\n",
 			      maint.command);
 		put_span(s);
+		/* Restore the state on error */
+		s->maintstat = i;
 		return -ENOSYS;
 	}
-
-	/* set maint mode */
-	s->maintstat = maint.command;
-
 	dahdi_alarm_notify(s);  /* process alarm-related events */
 	spin_unlock_irqrestore(&s->lock, flags);
 	put_span(s);
@@ -5580,10 +5779,10 @@ static int dahdi_ioctl_confdiag(struct file *file, unsigned long data)
 	for (i = ((j) ? j : 1); i <= ((j) ? j : DAHDI_MAX_CONF); i++) {
 		struct dahdi_span *s;
 		struct pseudo_chan *pseudo;
+		int k;
 		c = 0;
 		spin_lock_irqsave(&chan_lock, flags);
 		list_for_each_entry(s, &span_list, spans_node) {
-			int k;
 			for (k = 0; k < s->channels; k++) {
 				chan = s->chans[k];
 				if (chan->confna != i)
@@ -5605,6 +5804,29 @@ static int dahdi_ioctl_confdiag(struct file *file, unsigned long data)
 			module_printk(KERN_NOTICE, "chan %d, mode %x\n",
 				      pseudo->chan.channo, pseudo->chan.confmode);
 		}
+
+#ifdef CONFIG_DAHDI_CONFLINK
+		{
+			int rv;
+			rv = 0;
+			for (k = 1; k <= DAHDI_MAX_CONF; k++) {
+				if (conf_links[k].dst == i) {
+					if (!c) {
+						c = 1;
+						module_printk(KERN_NOTICE,
+							      "Conf #%d:\n", i);
+					}
+					if (!rv) {
+						rv = 1;
+						module_printk(KERN_NOTICE,
+							      "Snooping on:\n");
+					}
+					module_printk(KERN_NOTICE, "conf %d\n",
+						      conf_links[k].src);
+				}
+			}
+		}
+#endif
 		spin_unlock_irqrestore(&chan_lock, flags);
 		if (c)
 			module_printk(KERN_NOTICE, "\n");
@@ -6704,16 +6926,11 @@ static long
 dahdi_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long data)
 {
 	int unit = UNIT(file);
-	struct dahdi_timer *timer;
 	int ret;
 
-#if defined(HAVE_UNLOCKED_IOCTL) && defined(CONFIG_BKL)
-	lock_kernel();
-#endif
-
 	if (unit == DAHDI_CTL) {
 		ret = dahdi_ctl_ioctl(file, cmd, data);
-		goto unlock_exit;
+		goto exit;
 	}
 
 	if (unit == DAHDI_TRANSCODE) {
@@ -6721,45 +6938,41 @@ dahdi_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long data)
 		 * this file object on open, so we shouldn't be here. */
 		WARN_ON(1);
 		ret = -EFAULT;
-		goto unlock_exit;
+		goto exit;
 	}
 
 	if (unit == DAHDI_TIMER) {
-		timer = file->private_data;
-		if (timer)
-			ret = dahdi_timer_ioctl(file, cmd, data, timer);
-		else
-			ret = -EINVAL;
-		goto unlock_exit;
+		/* The file operations for a timer device should have been
+		 * updated. */
+		WARN_ON(1);
+		ret = -EFAULT;
+		goto exit;
 	}
 	if (unit == DAHDI_CHANNEL) {
 		if (file->private_data)
 			ret = dahdi_chan_ioctl(file, cmd, data);
 		else
 			ret = dahdi_prechan_ioctl(file, cmd, data);
-		goto unlock_exit;
+		goto exit;
 	}
 	if (unit == DAHDI_PSEUDO) {
 		if (!file->private_data) {
 			module_printk(KERN_NOTICE, "No pseudo channel structure to read?\n");
 			ret = -EINVAL;
-			goto unlock_exit;
+			goto exit;
 		}
 		ret = dahdi_chanandpseudo_ioctl(file, cmd, data);
-		goto unlock_exit;
+		goto exit;
 	}
 
 	if (!file->private_data) {
 		ret = -ENXIO;
-		goto unlock_exit;
+		goto exit;
 	}
 
 	ret = dahdi_chan_ioctl(file, cmd, data);
 
-unlock_exit:
-#if defined(HAVE_UNLOCKED_IOCTL) && defined(CONFIG_BKL)
-	unlock_kernel();
-#endif
+exit:
 	return ret;
 }
 
@@ -6843,7 +7056,7 @@ static int _assign_spanno_and_basechan(struct dahdi_span *span)
 		}
 
 		next_channo = _get_next_channo(pos);
-		if ((basechan + span->channels) >= next_channo)
+		if ((basechan + span->channels) <= next_channo)
 			break;
 
 		/* We can't fit here, let's look at the next location. */
@@ -6975,6 +7188,13 @@ static void __dahdi_init_span(struct dahdi_span *span)
 	spin_lock_init(&span->lock);
 	clear_bit(DAHDI_FLAGBIT_REGISTERED, &span->flags);
 
+	/* DAHDI_ALARM_NOTOPEN can be set when a span is disabled, i.e. via
+	 * sysfs, so when the span is being initialized again before
+	 * reassignment we should make sure it's cleared. This eliminates the
+	 * need for board drivers to re-report their alarm states on span
+	 * reassignment. */
+	span->alarms &= ~DAHDI_ALARM_NOTOPEN;
+
 	if (!span->deflaw) {
 		module_printk(KERN_NOTICE, "Span %s didn't specify default "
 			      "law. Assuming mulaw, please fix driver!\n",
@@ -7016,7 +7236,7 @@ EXPORT_SYMBOL(dahdi_init_span);
  * @spanno:	The span number we would like assigned. If 0, the first
  *		available spanno/basechan will be used.
  * @basechan:	The base channel number we would like. Ignored if spanno is 0.
- * @prefmaster:	will the new span be preferred as a master?
+ * @prefmaster:	will the new span be preferred as a master_span?
  *
  * Assigns a span for usage with DAHDI. All the channel numbers in it will
  * have their numbering started at basechan.
@@ -7081,15 +7301,14 @@ static int _dahdi_assign_span(struct dahdi_span *span, unsigned int spanno,
 	{
 		char tempfile[17];
 		snprintf(tempfile, sizeof(tempfile), "%d", span->spanno);
-		span->proc_entry = create_proc_entry(tempfile, 0444,
-					root_proc_entry);
+		span->proc_entry = proc_create_data(tempfile, 0444,
+					root_proc_entry, &dahdi_proc_ops,
+					(void *)((unsigned long)span->spanno));
 		if (!span->proc_entry) {
 			res = -EFAULT;
 			span_err(span, "Error creating procfs entry\n");
 			goto cleanup;
 		}
-		span->proc_entry->data = (void *)(long)span->spanno;
-		span->proc_entry->proc_fops = &dahdi_proc_ops;
 	}
 #endif
 
@@ -7237,6 +7456,15 @@ static void disable_span(struct dahdi_span *span)
 	module_printk(KERN_INFO, "%s: span %d\n", __func__, span->spanno);
 }
 
+#ifdef CONFIG_PROC_FS
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 10, 0)
+static inline void proc_remove(struct proc_dir_entry *proc_entry)
+{
+	remove_proc_entry(proc_entry->name, root_proc_entry);
+}
+#endif
+#endif
+
 /**
  * _dahdi_unassign_span() - unassign a DAHDI span
  * @span:	the DAHDI span
@@ -7249,6 +7477,7 @@ static void disable_span(struct dahdi_span *span)
  */
 static int _dahdi_unassign_span(struct dahdi_span *span)
 {
+	int res;
 	int x;
 	struct dahdi_span *new_master, *s;
 	unsigned long flags;
@@ -7265,15 +7494,19 @@ static int _dahdi_unassign_span(struct dahdi_span *span)
 	span->spanno = 0;
 	clear_bit(DAHDI_FLAGBIT_REGISTERED, &span->flags);
 
-	/* Shutdown the span if it's running */
-	if ((span->flags & DAHDI_FLAG_RUNNING) && span->ops->shutdown)
-		span->ops->shutdown(span);
+	res = dahdi_shutdown_span(span);
+	if (res) {
+		dev_err(span_device(span),
+			"Failed to shutdown when unassigning.\n");
+	}
 
 	if (debug & DEBUG_MAIN)
 		module_printk(KERN_NOTICE, "Unassigning Span '%s' with %d channels\n", span->name, span->channels);
 #ifdef CONFIG_PROC_FS
-	if (span->proc_entry)
-		remove_proc_entry(span->proc_entry->name, root_proc_entry);
+	if (span->proc_entry) {
+		proc_remove(span->proc_entry);
+		span->proc_entry = NULL;
+	}
 #endif /* CONFIG_PROC_FS */
 
 	span_sysfs_remove(span);
@@ -7281,8 +7514,8 @@ static int _dahdi_unassign_span(struct dahdi_span *span)
 	for (x=0;x<span->channels;x++)
 		dahdi_chan_unreg(span->chans[x]);
 
-	new_master = master; /* FIXME: locking */
-	if (master == span)
+	new_master = master_span; /* FIXME: locking */
+	if (master_span == span)
 		new_master = NULL;
 
 	spin_lock_irqsave(&chan_lock, flags);
@@ -7293,13 +7526,13 @@ static int _dahdi_unassign_span(struct dahdi_span *span)
 		break;
 	}
 	spin_unlock_irqrestore(&chan_lock, flags);
-	if (master != new_master) {
+	if (master_span != new_master) {
 		if (debug & DEBUG_MAIN) {
 			module_printk(KERN_NOTICE, "%s: Span ('%s') is new master\n", __FUNCTION__,
 				      (new_master)? new_master->name: "no master");
 		}
 	}
-	master = new_master;
+	master_span = new_master;
 	return 0;
 }
 
@@ -8353,7 +8586,6 @@ void dahdi_rbsbits(struct dahdi_chan *chan, int cursig)
 			break;
 		}
 		/* Fall through */
-	    case DAHDI_SIG_EM:  /* E and M */
 	    case DAHDI_SIG_EM_E1:
 	    case DAHDI_SIG_FXOLS: /* FXO Loopstart */
 	    case DAHDI_SIG_FXOKS: /* FXO Kewlstart */
@@ -8362,7 +8594,13 @@ void dahdi_rbsbits(struct dahdi_chan *chan, int cursig)
 		else /* on hook */
 			__dahdi_hooksig_pvt(chan,DAHDI_RXSIG_ONHOOK);
 		break;
-
+	    case DAHDI_SIG_EM:  /* E and M */
+		/* Watch only the ABIT for changes. */
+		if ((cursig & DAHDI_ABIT) == (chan->rxsig & DAHDI_ABIT))
+			break;
+		__dahdi_hooksig_pvt(chan, (cursig & DAHDI_ABIT) ?
+				      DAHDI_RXSIG_OFFHOOK : DAHDI_RXSIG_ONHOOK);
+		break;
 	   case DAHDI_SIG_FXSKS:  /* FXS Kewlstart */
 	   case DAHDI_SIG_FXSGS:  /* FXS Groundstart */
 		/* Fall through */
@@ -9302,14 +9540,14 @@ static void process_timers(void)
 
 	spin_lock(&dahdi_timer_lock);
 	list_for_each_entry(cur, &dahdi_timers, list) {
-		if (cur->ms) {
-			cur->pos -= DAHDI_CHUNKSIZE;
-			if (cur->pos <= 0) {
-				cur->tripped++;
-				cur->pos = cur->ms;
-				wake_up_interruptible(&cur->sel);
-			}
+		spin_lock(&cur->lock);
+		cur->pos -= DAHDI_CHUNKSIZE;
+		if (cur->pos <= 0) {
+			cur->tripped++;
+			cur->pos = cur->ms;
+			wake_up_interruptible(&cur->sel);
 		}
+		spin_unlock(&cur->lock);
 	}
 	spin_unlock(&dahdi_timer_lock);
 }
@@ -9321,10 +9559,10 @@ static unsigned int dahdi_timer_poll(struct file *file, struct poll_table_struct
 	int ret = 0;
 	if (timer) {
 		poll_wait(file, &timer->sel, wait_table);
-		spin_lock_irqsave(&dahdi_timer_lock, flags);
+		spin_lock_irqsave(&timer->lock, flags);
 		if (timer->tripped || timer->ping)
 			ret |= POLLPRI;
-		spin_unlock_irqrestore(&dahdi_timer_lock, flags);
+		spin_unlock_irqrestore(&timer->lock, flags);
 	} else {
 		/*
 		 * This should never happen. Surprise device removal
@@ -9691,6 +9929,29 @@ static void _process_masterspan(void)
 		spin_unlock(&pseudo->chan.lock);
 	}
 
+#ifdef CONFIG_DAHDI_CONFLINK
+	if (maxlinks) {
+		int z;
+		int y;
+#ifdef CONFIG_DAHDI_MMX
+		dahdi_kernel_fpu_begin();
+#endif
+		/* process all the conf links */
+		for (x = 1; x <= maxlinks; x++) {
+			/* if we have a destination conf */
+			z = confalias[conf_links[x].dst];
+			if (z) {
+				y = confalias[conf_links[x].src];
+				if (y)
+					ACSS(conf_sums[z], conf_sums[y]);
+			}
+		}
+#ifdef CONFIG_DAHDI_MMX
+		dahdi_kernel_fpu_end();
+#endif
+	}
+#endif /* CONFIG_DAHDI_CONFLINK */
+
 	/* do all the pseudo/conferenced channel transmits (putbuf's) */
 	list_for_each_entry(pseudo, &pseudo_chans, node) {
 		pseudo_rx_audio(&pseudo->chan);
@@ -9996,6 +10257,20 @@ static const struct file_operations dahdi_fops = {
 	.poll    = dahdi_poll,
 };
 
+static const struct file_operations dahdi_timer_fops = {
+	.owner   = THIS_MODULE,
+	.release = dahdi_timer_release,
+#ifdef HAVE_UNLOCKED_IOCTL
+	.unlocked_ioctl  = dahdi_timer_unlocked_ioctl,
+#ifdef HAVE_COMPAT_IOCTL
+	.compat_ioctl = dahdi_timer_unlocked_ioctl,
+#endif
+#else
+	.ioctl   = dahdi_timer_ioctl,
+#endif
+	.poll    = dahdi_timer_poll,
+};
+
 /*
  * DAHDI stability should not depend on the calling process behaviour.
  * In case of suprise device removal, we should be able to return

drivers/dahdi/dahdi-sysfs-chan.c

@@ -26,6 +26,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/slab.h>
+#include <linux/ctype.h>
 #include <dahdi/kernel.h>
 #include "dahdi.h"
 #include "dahdi-sysfs.h"
@@ -38,22 +39,222 @@
 
 static struct class *dahdi_class;
 
+static dev_t dahdi_channels_devt;	/*!< Device number of first channel */
+static struct cdev dahdi_channels_cdev;	/*!< Channels chardev's */
+
+/*
+ * Flags to remember what initializations already
+ * succeeded.
+ */
+static struct {
+	u32 channel_driver:1;
+	u32 channels_bus:1;
+	u32 cdev:1;
+} should_cleanup;
+
+#define chan_attr(field, format_string)		\
+static BUS_ATTR_READER(field##_show, dev, buf)	\
+{						\
+	struct dahdi_chan *chan;		\
+						\
+	chan = dev_to_chan(dev);		\
+	return sprintf(buf, format_string, chan->field); \
+}
+
+chan_attr(name, "%s\n");
+chan_attr(channo, "%d\n");
+chan_attr(chanpos, "%d\n");
+chan_attr(blocksize, "%d\n");
+#ifdef OPTIMIZE_CHANMUTE
+chan_attr(chanmute, "%d\n");
+#endif
+
+static BUS_ATTR_READER(sigcap_show, dev, buf)
+{
+	struct dahdi_chan *chan;
+	int len = 0;
+	int i;
+	uint sigtypes[] = {
+		DAHDI_SIG_FXSLS,
+		DAHDI_SIG_FXSGS,
+		DAHDI_SIG_FXSKS,
+		DAHDI_SIG_FXOLS,
+		DAHDI_SIG_FXOGS,
+		DAHDI_SIG_FXOKS,
+		DAHDI_SIG_EM,
+		DAHDI_SIG_CLEAR,
+		DAHDI_SIG_HDLCRAW,
+		DAHDI_SIG_HDLCFCS,
+		DAHDI_SIG_HDLCNET,
+		DAHDI_SIG_SLAVE,
+		DAHDI_SIG_SF,
+		DAHDI_SIG_CAS,
+		DAHDI_SIG_EM_E1,
+		DAHDI_SIG_DACS_RBS,
+		DAHDI_SIG_HARDHDLC,
+		DAHDI_SIG_MTP2,
+	};
+	chan = dev_to_chan(dev);
+
+	for (i = 0; i < ARRAY_SIZE(sigtypes); i++) {
+		uint x = chan->sigcap & sigtypes[i];
+		if (x == sigtypes[i])
+			len += sprintf(buf + len, "%s ", sigstr(x));
+	}
+	while (len > 0 && isspace(buf[len - 1])) /* trim */
+		len--;
+	len += sprintf(buf + len, "\n");
+	return len;
+}
+
+static BUS_ATTR_READER(sig_show, dev, buf)
+{
+	struct dahdi_chan *chan;
+
+	chan = dev_to_chan(dev);
+	return sprintf(buf, "%s\n", sigstr(chan->sig));
+}
+
+static BUS_ATTR_READER(in_use_show, dev, buf)
+{
+	struct dahdi_chan *chan;
+
+	chan = dev_to_chan(dev);
+	return sprintf(buf, "%d\n", test_bit(DAHDI_FLAGBIT_OPEN, &chan->flags));
+}
+
+static BUS_ATTR_READER(alarms_show, dev, buf)
+{
+	struct dahdi_chan *chan;
+	int len;
+
+	chan = dev_to_chan(dev);
+	len = fill_alarm_string(buf, PAGE_SIZE, chan->chan_alarms);
+	buf[len++] = '\n';
+	return len;
+}
+
+static BUS_ATTR_READER(ec_factory_show, dev, buf)
+{
+	struct dahdi_chan *chan;
+	int len = 0;
+
+	chan = dev_to_chan(dev);
+	if (chan->ec_factory)
+		len += sprintf(buf, "%s", chan->ec_factory->get_name(chan));
+	buf[len++] = '\n';
+	return len;
+}
+
+static BUS_ATTR_READER(ec_state_show, dev, buf)
+{
+	struct dahdi_chan *chan;
+	int len = 0;
+
+	chan = dev_to_chan(dev);
+	if (chan->ec_factory)
+		len += sprintf(buf, "%sACTIVE", (chan->ec_state) ? "" : "IN");
+	buf[len++] = '\n';
+	return len;
+}
+
+static struct device_attribute chan_dev_attrs[] = {
+	__ATTR_RO(name),
+	__ATTR_RO(channo),
+	__ATTR_RO(chanpos),
+	__ATTR_RO(sig),
+	__ATTR_RO(sigcap),
+	__ATTR_RO(alarms),
+	__ATTR_RO(ec_factory),
+	__ATTR_RO(ec_state),
+	__ATTR_RO(blocksize),
+#ifdef OPTIMIZE_CHANMUTE
+	__ATTR_RO(chanmute),
+#endif
+	__ATTR_RO(in_use),
+	__ATTR_NULL,
+};
+
+static void chan_release(struct device *dev)
+{
+	struct dahdi_chan *chan;
+
+	BUG_ON(!dev);
+	chan = dev_to_chan(dev);
+	chan_dbg(DEVICES, chan, "SYSFS\n");
+}
+
+static int chan_match(struct device *dev, struct device_driver *driver)
+{
+	struct dahdi_chan *chan;
+
+	chan = dev_to_chan(dev);
+	chan_dbg(DEVICES, chan, "SYSFS\n");
+	return 1;
+}
+
+static struct bus_type chan_bus_type = {
+	.name		= "dahdi_channels",
+	.match		= chan_match,
+	.dev_attrs	= chan_dev_attrs,
+};
+
+static int chan_probe(struct device *dev)
+{
+	struct dahdi_chan *chan;
+
+	chan = dev_to_chan(dev);
+	chan_dbg(DEVICES, chan, "SYSFS\n");
+	return 0;
+}
+
+static int chan_remove(struct device *dev)
+{
+	struct dahdi_chan *chan;
+
+	chan = dev_to_chan(dev);
+	chan_dbg(DEVICES, chan, "SYSFS\n");
+	return 0;
+}
+
+static struct device_driver chan_driver = {
+	.name = "dahdi",
+	.bus = &chan_bus_type,
+#ifndef OLD_HOTPLUG_SUPPORT
+	.owner = THIS_MODULE,
+#endif
+	.probe = chan_probe,
+	.remove = chan_remove
+};
+
 int chan_sysfs_create(struct dahdi_chan *chan)
 {
-	char chan_name[32];
-	void *dummy;
-	int res = 0;
+	struct device *dev;
+	struct dahdi_span *span;
+	int res;
+	dev_t devt;
 
-	if (chan->channo >= 250)
-		return 0;
+	chan_dbg(DEVICES, chan, "Creating channel %d\n", chan->channo);
 	if (test_bit(DAHDI_FLAGBIT_DEVFILE, &chan->flags))
 		return 0;
-	snprintf(chan_name, sizeof(chan_name), "dahdi!%d", chan->channo);
-	dummy = (void *)MAKE_DAHDI_DEV(chan->channo, chan_name);
-	if (IS_ERR(dummy)) {
-		res = PTR_ERR(dummy);
-		chan_err(chan, "Failed creating sysfs device: %d\n",
-				res);
+	span = chan->span;
+	devt = MKDEV(MAJOR(dahdi_channels_devt), chan->channo);
+	dev = &chan->chan_device;
+	memset(dev, 0, sizeof(*dev));
+	dev->devt = devt;
+	dev->bus = &chan_bus_type;
+	dev->parent = span->span_device;
+	/*
+	 * FIXME: the name cannot be longer than KOBJ_NAME_LEN
+	 */
+	dev_set_name(dev, "dahdi!chan!%03d!%03d", span->spanno, chan->chanpos);
+	dev_set_drvdata(dev, chan);
+	dev->release = chan_release;
+	res = device_register(dev);
+	if (res) {
+		chan_err(chan, "%s: device_register failed: %d\n",
+				__func__, res);
+		put_device(dev);
 		return res;
 	}
 	set_bit(DAHDI_FLAGBIT_DEVFILE, &chan->flags);
@@ -62,9 +263,18 @@ int chan_sysfs_create(struct dahdi_chan *chan)
 
 void chan_sysfs_remove(struct dahdi_chan *chan)
 {
+	struct device *dev = &chan->chan_device;
+
+	chan_dbg(DEVICES, chan, "Destroying channel %d\n", chan->channo);
+	if (!dev_get_drvdata(dev))
+		return;
 	if (!test_bit(DAHDI_FLAGBIT_DEVFILE, &chan->flags))
 		return;
-	DEL_DAHDI_DEV(chan->channo);
+	dev = &chan->chan_device;
+	BUG_ON(dev_get_drvdata(dev) != chan);
+	device_unregister(dev);
+	/* FIXME: should have been done earlier in dahdi_chan_unreg */
+	chan->channo = -1;
 	clear_bit(DAHDI_FLAGBIT_DEVFILE, &chan->flags);
 }
 
@@ -77,7 +287,7 @@ int dahdi_register_chardev(struct dahdi_chardev *dev)
 	char *udevname;
 
 	udevname = kzalloc(strlen(dev->name) + sizeof(DAHDI_STRING) + 1,
-			   GFP_KERNEL);
+			GFP_KERNEL);
 	if (!udevname)
 		return -ENOMEM;
 
@@ -181,28 +391,86 @@ cleanup:
  */
 static void sysfs_channels_cleanup(void)
 {
+	if (should_cleanup.cdev) {
+		dahdi_dbg(DEVICES, "removing channels cdev\n");
+		cdev_del(&dahdi_channels_cdev);
+		should_cleanup.cdev = 0;
+	}
+	if (dahdi_channels_devt) {
+		dahdi_dbg(DEVICES, "unregistering chrdev_region\n");
+		unregister_chrdev_region(dahdi_channels_devt,
+			DAHDI_MAX_CHANNELS);
+	}
+
 	fixed_devfiles_remove();
 	if (dahdi_class) {
 		dahdi_dbg(DEVICES, "Destroying DAHDI class:\n");
 		class_destroy(dahdi_class);
 		dahdi_class = NULL;
 	}
+	if (should_cleanup.channel_driver) {
+		dahdi_dbg(DEVICES, "Removing channel driver\n");
+		driver_unregister(&chan_driver);
+		should_cleanup.channel_driver = 0;
+	}
+	if (should_cleanup.channels_bus) {
+		dahdi_dbg(DEVICES, "Removing channels bus\n");
+		bus_unregister(&chan_bus_type);
+		should_cleanup.channels_bus = 0;
+	}
 }
 
 int __init dahdi_sysfs_chan_init(const struct file_operations *fops)
 {
 	int res = 0;
 
+	dahdi_dbg(DEVICES, "Registering channels bus\n");
+	res = bus_register(&chan_bus_type);
+	if (res) {
+		dahdi_err("%s: bus_register(%s) failed. Error number %d\n",
+				__func__, chan_bus_type.name, res);
+		goto cleanup;
+	}
+	should_cleanup.channels_bus = 1;
+
+	dahdi_dbg(DEVICES, "Registering channel driver\n");
+	res = driver_register(&chan_driver);
+	if (res) {
+		dahdi_err("%s: driver_register(%s) failed. Error number %d",
+				__func__, chan_driver.name, res);
+		goto cleanup;
+	}
+	should_cleanup.channel_driver = 1;
+
 	dahdi_class = class_create(THIS_MODULE, "dahdi");
 	if (IS_ERR(dahdi_class)) {
 		res = PTR_ERR(dahdi_class);
 		dahdi_err("%s: class_create(dahi_chan) failed. Error: %d\n",
-			__func__, res);
+				__func__, res);
 		goto cleanup;
 	}
 	res = fixed_devfiles_create();
 	if (res)
 		goto cleanup;
+	dahdi_dbg(DEVICES, "allocating chrdev_region\n");
+	res = alloc_chrdev_region(&dahdi_channels_devt,
+			0,
+			DAHDI_MAX_CHANNELS,
+			"dahdi_channels");
+	if (res) {
+		dahdi_err("%s: Failed allocating chrdev for %d channels (%d)",
+			__func__, DAHDI_MAX_CHANNELS, res);
+		goto cleanup;
+	}
+	dahdi_dbg(DEVICES, "adding channels cdev\n");
+	cdev_init(&dahdi_channels_cdev, fops);
+	res = cdev_add(&dahdi_channels_cdev, dahdi_channels_devt,
+		DAHDI_MAX_CHANNELS);
+	if (res) {
+		dahdi_err("%s: cdev_add() failed (%d)", __func__, res);
+		goto cleanup;
+	}
+	should_cleanup.cdev = 1;
 	return 0;
 cleanup:
 	sysfs_channels_cleanup();

drivers/dahdi/dahdi-sysfs.c

@@ -32,8 +32,15 @@
 #include "dahdi-sysfs.h"
 
 
-static char *initdir = "/usr/share/dahdi";
-module_param(initdir, charp, 0644);
+static char *initdir;
+module_param(initdir, charp, 0444);
+MODULE_PARM_DESC(initdir,
+		"deprecated, should use <tools_rootdir>/usr/share/dahdi");
+
+static char *tools_rootdir;
+module_param(tools_rootdir, charp, 0444);
+MODULE_PARM_DESC(tools_rootdir,
+		"root directory of all tools paths (default /)");
 
 static int span_match(struct device *dev, struct device_driver *driver)
 {
@@ -47,7 +54,9 @@ static inline struct dahdi_span *dev_to_span(struct device *dev)
 
 #define	SPAN_VAR_BLOCK	\
 	do {		\
-		DAHDI_ADD_UEVENT_VAR("DAHDI_INIT_DIR=%s", initdir);	\
+		DAHDI_ADD_UEVENT_VAR("DAHDI_TOOLS_ROOTDIR=%s", tools_rootdir); \
+		DAHDI_ADD_UEVENT_VAR("DAHDI_INIT_DIR=%s/%s", tools_rootdir,    \
+				initdir);	\
 		DAHDI_ADD_UEVENT_VAR("SPAN_NUM=%d", span->spanno);	\
 		DAHDI_ADD_UEVENT_VAR("SPAN_NAME=%s", span->name);	\
 	} while (0)
@@ -222,16 +231,51 @@ static struct device_attribute span_dev_attrs[] = {
 	__ATTR_NULL,
 };
 
+static ssize_t master_span_show(struct device_driver *driver, char *buf)
+{
+	struct dahdi_span *s = get_master_span();
+
+	return snprintf(buf, PAGE_SIZE, "%d\n", (s) ? s->spanno : 0);
+}
+
+static ssize_t master_span_store(struct device_driver *driver, const char *buf,
+			  size_t count)
+{
+	int spanno;
+
+	if (sscanf(buf, "%d", &spanno) != 1) {
+		module_printk(KERN_ERR, "non-numeric input '%s'\n", buf);
+		return -EINVAL;
+	}
+	set_master_span(spanno);
+	return count;
+}
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 13, 0)
 static struct driver_attribute dahdi_attrs[] = {
+	__ATTR(master_span, S_IRUGO | S_IWUSR, master_span_show,
+			master_span_store),
 	__ATTR_NULL,
 };
+#else
+static DRIVER_ATTR_RW(master_span);
+static struct attribute *dahdi_attrs[] = {
+	&driver_attr_master_span.attr,
+	NULL,
+};
+ATTRIBUTE_GROUPS(dahdi);
+#endif
 
 static struct bus_type spans_bus_type = {
 	.name           = "dahdi_spans",
 	.match          = span_match,
 	.uevent         = span_uevent,
 	.dev_attrs	= span_dev_attrs,
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 13, 0)
 	.drv_attrs	= dahdi_attrs,
+#else
+	.drv_groups 	= dahdi_groups,
+#endif
 };
 
 static int span_probe(struct device *dev)
@@ -296,6 +340,7 @@ void span_sysfs_remove(struct dahdi_span *span)
 
 	get_device(span_device);
 	span_uevent_send(span, KOBJ_OFFLINE);
+	sysfs_remove_link(&span_device->kobj, "ddev");
 	device_unregister(span->span_device);
 	dev_set_drvdata(span_device, NULL);
 	span_device->parent = NULL;
@@ -336,6 +381,15 @@ int span_sysfs_create(struct dahdi_span *span)
 		span->span_device = NULL;
 		goto cleanup;
 	}
+	res = sysfs_create_link(&span_device->kobj, &span_device->parent->kobj,
+			"ddev");
+	if (res) {
+		span_err(span, "%s: sysfs_create_link failed: %d\n", __func__,
+				res);
+		kfree(span->span_device);
+		span->span_device = NULL;
+		goto cleanup;
+	}
 
 	for (x = 0; x < span->channels; x++) {
 		res = chan_sysfs_create(span->chans[x]);
@@ -362,6 +416,71 @@ static inline struct dahdi_device *to_ddev(struct device *dev)
 	return container_of(dev, struct dahdi_device, dev);
 }
 
+#define	DEVICE_VAR_BLOCK	\
+	do {		\
+		DAHDI_ADD_UEVENT_VAR("DAHDI_TOOLS_ROOTDIR=%s", tools_rootdir); \
+		DAHDI_ADD_UEVENT_VAR("DAHDI_INIT_DIR=%s/%s", tools_rootdir,    \
+				initdir);				\
+		DAHDI_ADD_UEVENT_VAR("DAHDI_DEVICE_HWID=%s",		\
+				ddev->hardware_id);			\
+		DAHDI_ADD_UEVENT_VAR("DAHDI_DEVICE_LOCATION=%s",	\
+				ddev->location);			\
+	} while (0)
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
+#define DAHDI_ADD_UEVENT_VAR(fmt, val...)			\
+	do {							\
+		int err = add_uevent_var(envp, num_envp, &i,	\
+				buffer, buffer_size, &len,	\
+				fmt, val);			\
+		if (err)					\
+			return err;				\
+	} while (0)
+
+static int device_uevent(struct device *dev, char **envp, int num_envp,
+		char *buffer, int buffer_size)
+{
+	struct dahdi_device	*ddev;
+	int			i = 0;
+	int			len = 0;
+
+	if (!dev)
+		return -ENODEV;
+
+	ddev = to_ddev(dev);
+	if (!ddev)
+		return -ENODEV;
+
+	dahdi_dbg(GENERAL, "SYFS dev_name=%s\n", dev_name(dev));
+	DEVICE_VAR_BLOCK;
+	envp[i] = NULL;
+	return 0;
+}
+
+#else
+#define DAHDI_ADD_UEVENT_VAR(fmt, val...)			\
+	do {							\
+		int err = add_uevent_var(kenv, fmt, val);	\
+		if (err)					\
+			return err;				\
+	} while (0)
+
+static int device_uevent(struct device *dev, struct kobj_uevent_env *kenv)
+{
+	struct dahdi_device *ddev;
+
+	if (!dev)
+		return -ENODEV;
+	ddev = to_ddev(dev);
+	if (!ddev)
+		return -ENODEV;
+	dahdi_dbg(GENERAL, "SYFS dev_name=%s\n", dev_name(dev));
+	DEVICE_VAR_BLOCK;
+	return 0;
+}
+
+#endif
+
 static ssize_t
 dahdi_device_manufacturer_show(struct device *dev,
 			       struct device_attribute *attr, char *buf)
@@ -402,6 +521,16 @@ dahdi_device_hardware_id_show(struct device *dev,
 		(ddev->hardware_id) ? ddev->hardware_id : "");
 }
 
+static ssize_t
+dahdi_device_location_show(struct device *dev,
+			     struct device_attribute *attr, char *buf)
+{
+	struct dahdi_device *ddev = to_ddev(dev);
+
+	return sprintf(buf, "%s\n",
+		(ddev->location) ? ddev->location : "");
+}
+
 static ssize_t
 dahdi_device_auto_assign(struct device *dev, struct device_attribute *attr,
 			 const char *buf, size_t count)
@@ -549,6 +678,7 @@ static struct device_attribute dahdi_device_attrs[] = {
 	__ATTR(type, S_IRUGO, dahdi_device_type_show, NULL),
 	__ATTR(span_count, S_IRUGO, dahdi_device_span_count_show, NULL),
 	__ATTR(hardware_id, S_IRUGO, dahdi_device_hardware_id_show, NULL),
+	__ATTR(location, S_IRUGO, dahdi_device_location_show, NULL),
 	__ATTR(auto_assign, S_IWUSR, NULL, dahdi_device_auto_assign),
 	__ATTR(assign_span, S_IWUSR, NULL, dahdi_device_assign_span),
 	__ATTR(unassign_span, S_IWUSR, NULL, dahdi_device_unassign_span),
@@ -559,6 +689,7 @@ static struct device_attribute dahdi_device_attrs[] = {
 
 static struct bus_type dahdi_device_bus = {
 	.name = "dahdi_devices",
+	.uevent         = device_uevent,
 	.dev_attrs = dahdi_device_attrs,
 };
 
@@ -639,6 +770,19 @@ int __init dahdi_sysfs_init(const struct file_operations *dahdi_fops)
 	int res = 0;
 
 	dahdi_dbg(DEVICES, "Registering DAHDI device bus\n");
+
+	/* Handle dahdi-tools paths (for udev environment) */
+	if (tools_rootdir && initdir) {
+		dahdi_err("Cannot use tools-rootdir and initdir parameters simultaneously\n");
+		return -EINVAL;
+	}
+	if (initdir)
+		pr_notice("dahdi: initdir is depracated -- prefer using \"tools_rootdir\" parameter\n");
+	else
+		initdir = "/usr/share/dahdi";
+	if (!tools_rootdir)
+		tools_rootdir = "";
+
 	res = bus_register(&dahdi_device_bus);
 	if (res)
 		return res;

drivers/dahdi/dahdi_dynamic.c

@@ -88,6 +88,8 @@ static int txerrors;
 static struct tasklet_struct dahdi_dynamic_tlet;
 
 static void dahdi_dynamic_tasklet(unsigned long data);
+#else
+static struct tasklet_struct dahdi_dynamic_flush_tlet;
 #endif
 
 static DEFINE_MUTEX(dspan_mutex);
@@ -208,12 +210,25 @@ static void __dahdi_dynamic_run(void)
 		dahdi_dynamic_sendmessage(d);
 	}
 
+#ifdef ENABLE_TASKLETS
+	/* If tasklets are not enabled, the above section will be called in
+	 * interrupt context and the flushing of each driver will be called in a
+	 * separate tasklet that only handles that. This is necessary since some
+	 * of the dynamic spans need to call functions that require interrupts
+	 * to be enabled but dahdi_transmit / ...sendmessage needs to be called
+	 * each time the masterspan is processed which happens with interrupts
+	 * disabled.
+	 *
+	 */
+	tasklet_hi_schedule(&dahdi_dynamic_flush_tlet);
+#else
 	list_for_each_entry_rcu(drv, &driver_list, list) {
 		/* Flush any traffic still pending in the driver */
 		if (drv->flush) {
 			drv->flush();
 		}
 	}
+#endif
 	rcu_read_unlock();
 }
 
@@ -615,6 +630,10 @@ static int _create_dynamic(struct dahdi_dynamic_span *dds)
 	d->span.deflaw = DAHDI_LAW_MULAW;
 	d->span.flags |= DAHDI_FLAG_RBS;
 	d->span.chans = d->chans;
+	d->span.spantype = SPANTYPE_DIGITAL_DYNAMIC; 
+	d->span.linecompat = DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF	| 
+		DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_CCS |
+		DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CRC4 | DAHDI_CONFIG_NOTOPEN;
 	d->span.ops = &dynamic_ops;
 	for (x = 0; x < d->span.channels; x++) {
 		sprintf(d->chans[x]->name, "DYN/%s/%s/%d",
@@ -708,6 +727,20 @@ static void dahdi_dynamic_tasklet(unsigned long data)
 	}
 	taskletpending = 0;
 }
+#else
+static void dahdi_dynamic_flush_tasklet(unsigned long data)
+{
+	struct dahdi_dynamic_driver *drv;
+
+	rcu_read_lock();
+	list_for_each_entry_rcu(drv, &driver_list, list) {
+		/* Flush any traffic still pending in the driver */
+		if (drv->flush) {
+			drv->flush();
+		}
+	}
+	rcu_read_unlock();
+}
 #endif
 
 static int dahdi_dynamic_ioctl(unsigned int cmd, unsigned long data)
@@ -840,6 +873,8 @@ static int dahdi_dynamic_init(void)
 	mod_timer(&alarmcheck, jiffies + 1 * HZ);
 #ifdef ENABLE_TASKLETS
 	tasklet_init(&dahdi_dynamic_tlet, dahdi_dynamic_tasklet, 0);
+#else
+	tasklet_init(&dahdi_dynamic_flush_tlet, dahdi_dynamic_flush_tasklet, 0);
 #endif
 	dahdi_set_dynamic_ops(&dahdi_dynamic_ops);
 
@@ -856,6 +891,9 @@ static void dahdi_dynamic_cleanup(void)
 		tasklet_disable(&dahdi_dynamic_tlet);
 		tasklet_kill(&dahdi_dynamic_tlet);
 	}
+#else
+	tasklet_disable(&dahdi_dynamic_flush_tlet);
+	tasklet_kill(&dahdi_dynamic_flush_tlet);
 #endif
 	del_timer_sync(&alarmcheck);
 	/* Must call again in case it was running before and rescheduled

drivers/dahdi/dahdi_dynamic_eth.c

@@ -185,44 +185,16 @@ static void ztdeth_transmit(struct dahdi_dynamic *dyn, u8 *msg, size_t msglen)
 		spin_unlock_irqrestore(&zlock, flags);
 }
 
-/**
- * dahdi_dynamic_flush_work_fn - Flush all pending transactions.
- *
- * This function is run in a work queue since we can't guarantee interrupts
- * will be enabled when we're called, and dev_queue_xmit() requires that
- * interrupts be enabled.
- *
- */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
-static void dahdi_dynamic_flush_work_fn(void *data)
-#else
-static void dahdi_dynamic_flush_work_fn(struct work_struct *work)
-#endif
-{
-	struct sk_buff *skb;
-	/* Handle all transmissions now */
-	while ((skb = skb_dequeue(&skbs))) {
-		dev_queue_xmit(skb);
-	}
-}
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
-static DECLARE_WORK(dahdi_dynamic_eth_flush_work,
-		    dahdi_dynamic_flush_work_fn, NULL);
-#else
-static DECLARE_WORK(dahdi_dynamic_eth_flush_work,
-		    dahdi_dynamic_flush_work_fn);
-#endif
-
 /**
  * ztdeth_flush - Flush all pending transactions.
  *
- * This function is called in interrupt context while processing the master
- * span.
+ * This function is always called in softirq context.
  */
 static int ztdeth_flush(void)
 {
-	schedule_work(&dahdi_dynamic_eth_flush_work);
+	struct sk_buff *skb;
+	while ((skb = skb_dequeue(&skbs)))
+		dev_queue_xmit(skb);
 	return 0;
 }
 
@@ -446,11 +418,6 @@ static int __init ztdeth_init(void)
 
 static void __exit ztdeth_exit(void)
 {
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
-	flush_scheduled_work();
-#else
-	cancel_work_sync(&dahdi_dynamic_eth_flush_work);
-#endif
 	dahdi_dynamic_unregister_driver(&ztd_eth);
 	unregister_netdevice_notifier(&ztdeth_nblock);
 	dev_remove_pack(&ztdeth_ptype);

drivers/dahdi/dahdi_dynamic_ethmf.c

@@ -36,6 +36,7 @@
 #include <linux/netdevice.h>
 #include <linux/notifier.h>
 #include <linux/crc32.h>
+#include <linux/seq_file.h>
 
 /**
  * Undefine USE_PROC_FS, if you do not want the /proc/dahdi/dynamic-ethmf
@@ -696,71 +697,69 @@ static void timer_callback(unsigned long param)
 #ifdef USE_PROC_FS
 static struct proc_dir_entry *proc_entry;
 static const char *ztdethmf_procname = "dahdi/dynamic-ethmf";
-static int ztdethmf_proc_read(char *page, char **start, off_t off, int count,
-		int *eof, void *data)
+
+static int ztdethmf_proc_show(struct seq_file *sfile, void *not_used)
 {
 	struct ztdeth *z = NULL;
-	int len = 0, i = 0;
+	int i = 0;
 	unsigned int group = 0, c = 0;
 
 	rcu_read_lock();
 
-	len += sprintf(page + len, "Errors: %d\n\n", atomic_read(&errcount));
+	seq_printf(sfile, "Errors: %d\n\n", atomic_read(&errcount));
 
 	for (group = 0; group < ETHMF_MAX_GROUPS; ++group) {
 		if (atomic_read(&(ethmf_groups[group].spans))) {
-			len += sprintf(page + len, "Group #%d (0x%x)\n", i++, ethmf_groups[group].hash_addr);
-			len += sprintf(page + len, "  Spans: %d\n",
-				atomic_read(&(ethmf_groups[group].spans)));
+			seq_printf(sfile, "Group #%d (0x%x)\n", i++,
+				   ethmf_groups[group].hash_addr);
+			seq_printf(sfile, "Spans: %d\n",
+				   atomic_read(&(ethmf_groups[group].spans)));
 
 			c = 1;
 			list_for_each_entry_rcu(z, &ethmf_list, list) {
 				if (z->addr_hash == ethmf_groups[group].hash_addr) {
 					if (c == 1) {
-						len += sprintf(page + len,
+						seq_printf(sfile,
 							"  Device: %s (MAC: %02x:%02x:%02x:%02x:%02x:%02x)\n",
 							z->ethdev,
 							z->addr[0], z->addr[1], z->addr[2],
 							z->addr[3], z->addr[4], z->addr[5]);
 					}
-					len += sprintf(page + len, "    Span %d: subaddr=%u ready=%d delay=%d real_channels=%d no_front_padding=%d\n",
+					seq_printf(sfile, "    Span %d: subaddr=%u ready=%d delay=%d real_channels=%d no_front_padding=%d\n",
 						c++, ntohs(z->subaddr),
 						atomic_read(&z->ready), atomic_read(&z->delay),
 						z->real_channels, atomic_read(&z->no_front_padding));
 				}
 			}
-			len += sprintf(page + len, "  Device UPs: %u\n",
+			seq_printf(sfile, "  Device UPs: %u\n",
 				atomic_read(&(ethmf_groups[group].devupcount)));
-			len += sprintf(page + len, "  Device DOWNs: %u\n",
+			seq_printf(sfile, "  Device DOWNs: %u\n",
 				atomic_read(&(ethmf_groups[group].devdowncount)));
-			len += sprintf(page + len, "  Rx Frames: %u\n",
+			seq_printf(sfile, "  Rx Frames: %u\n",
 				atomic_read(&(ethmf_groups[group].rxframecount)));
-			len += sprintf(page + len, "  Tx Frames: %u\n",
+			seq_printf(sfile, "  Tx Frames: %u\n",
 				atomic_read(&(ethmf_groups[group].txframecount)));
-			len += sprintf(page + len, "  Rx Bytes: %u\n",
+			seq_printf(sfile, "  Rx Bytes: %u\n",
 				atomic_read(&(ethmf_groups[group].rxbytecount)));
-			len += sprintf(page + len, "  Tx Bytes: %u\n",
+			seq_printf(sfile, "  Tx Bytes: %u\n",
 				atomic_read(&(ethmf_groups[group].txbytecount)));
-			if (len <= off) {
-				off -= len;
-				len = 0;
-			}
-			if (len > off+count)
-				break;
 		}
 	}
 	rcu_read_unlock();
-
-	if (len <= off) {
-		off -= len;
-		len = 0;
-	}
-	*start = page + off;
-	len -= off;
-	if (len > count)
-		len = count;
-	return len;
+	return 0;
 }
+
+static int ztdethmf_proc_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, ztdethmf_proc_show, NULL);
+}
+
+static const struct file_operations ztdethmf_proc_fops = {
+	.open           = ztdethmf_proc_open,
+	.read           = seq_read,
+	.llseek         = seq_lseek,
+	.release        = seq_release,
+};
 #endif
 
 static int __init ztdethmf_init(void)
@@ -778,8 +777,8 @@ static int __init ztdethmf_init(void)
 	skb_queue_head_init(&skbs);
 
 #ifdef USE_PROC_FS
-	proc_entry = create_proc_read_entry(ztdethmf_procname, 0444, NULL,
-		ztdethmf_proc_read, NULL);
+	proc_entry = proc_create_data(ztdethmf_procname, 0444, NULL,
+				      &ztdethmf_proc_fops, NULL);
 	if (!proc_entry) {
 		printk(KERN_ALERT "create_proc_read_entry failed.\n");
 	}

drivers/dahdi/firmware/Makefile

@@ -3,7 +3,7 @@
 # 
 # Makefile for firmware downloading/installation
 #
-# Copyright (C) 2007-2010, Digium, Inc.
+# Copyright (C) 2007-2013, Digium, Inc.
 #
 # Joshua Colp <jcolp@digium.com>
 #
@@ -22,6 +22,7 @@
 
 .PHONY: dist-clean clean all uninstall have_download install object-build hotplug-install hotplug-dirs hotplug-uninstall make_firmware_object firmware-loaders
 
+OCT6114_032_VERSION:=1.05.01
 OCT6114_064_VERSION:=1.05.01
 OCT6114_128_VERSION:=1.05.01
 OCT6114_256_VERSION:=1.05.01
@@ -30,10 +31,19 @@ VPMADT032_VERSION:=1.25.0
 HX8_VERSION:=2.06
 VPMOCT032_VERSION:=1.12.0
 WCT820_VERSION:=1.76
+TE133_VERSION:=6f0017
+TE134_VERSION:=6f0017
+TE435_VERSION:=e0017
+A8A_VERSION:=1d0017
+A8B_VERSION:=1d0017
+A4A_VERSION:=a0017
+A4B_VERSION:=b0017
 
 FIRMWARE_URL:=http://downloads.digium.com/pub/telephony/firmware/releases
 
-ALL_FIRMWARE=FIRMWARE-OCT6114-064 FIRMWARE-OCT6114-128 FIRMWARE-OCT6114-256 FIRMWARE-TC400M FIRMWARE-HX8 FIRMWARE-VPMOCT032 FIRMWARE-TE820
+ALL_FIRMWARE=FIRMWARE-OCT6114-032 FIRMWARE-OCT6114-064 FIRMWARE-OCT6114-128 FIRMWARE-OCT6114-256
+ALL_FIRMWARE+=FIRMWARE-TC400M FIRMWARE-HX8 FIRMWARE-VPMOCT032 FIRMWARE-TE820 FIRMWARE-TE133 FIRMWARE-TE134
+ALL_FIRMWARE+=FIRMWARE-A8A FIRMWARE-A8B FIRMWARE-A4A FIRMWARE-A4B FIRMWARE-TE435
 
 # Firmware files should use the naming convention: dahdi-fw-<base name>-<sub name>-<version> or dahdi-fw-<base name>-<version>
 # First example: dahdi-fw-oct6114-064-1.05.01
@@ -42,17 +52,26 @@ ALL_FIRMWARE=FIRMWARE-OCT6114-064 FIRMWARE-OCT6114-128 FIRMWARE-OCT6114-256 FIRM
 # This means this is version MR5.6 of the tc400m firmware
 
 # Build a list of firmware package filenames we need
-FIRMWARE:=$(ALL_FIRMWARE:FIRMWARE-OCT6114-064=dahdi-fw-oct6114-064-$(OCT6114_064_VERSION).tar.gz)
+FIRMWARE:=$(ALL_FIRMWARE:FIRMWARE-OCT6114-032=dahdi-fw-oct6114-032-$(OCT6114_032_VERSION).tar.gz)
+FIRMWARE:=$(FIRMWARE:FIRMWARE-OCT6114-064=dahdi-fw-oct6114-064-$(OCT6114_064_VERSION).tar.gz)
 FIRMWARE:=$(FIRMWARE:FIRMWARE-OCT6114-128=dahdi-fw-oct6114-128-$(OCT6114_128_VERSION).tar.gz)
 FIRMWARE:=$(FIRMWARE:FIRMWARE-OCT6114-256=dahdi-fw-oct6114-256-$(OCT6114_256_VERSION).tar.gz)
 FIRMWARE:=$(FIRMWARE:FIRMWARE-TC400M=dahdi-fw-tc400m-$(TC400M_VERSION).tar.gz)
 FIRMWARE:=$(FIRMWARE:FIRMWARE-HX8=dahdi-fw-hx8-$(HX8_VERSION).tar.gz)
 FIRMWARE:=$(FIRMWARE:FIRMWARE-VPMOCT032=dahdi-fw-vpmoct032-$(VPMOCT032_VERSION).tar.gz)
 FIRMWARE:=$(FIRMWARE:FIRMWARE-TE820=dahdi-fw-te820-$(WCT820_VERSION).tar.gz)
+FIRMWARE:=$(FIRMWARE:FIRMWARE-TE133=dahdi-fw-te133-$(TE133_VERSION).tar.gz)
+FIRMWARE:=$(FIRMWARE:FIRMWARE-TE134=dahdi-fw-te134-$(TE134_VERSION).tar.gz)
+FIRMWARE:=$(FIRMWARE:FIRMWARE-TE435=dahdi-fw-te435-$(TE435_VERSION).tar.gz)
+FIRMWARE:=$(FIRMWARE:FIRMWARE-A8A=dahdi-fw-a8b-$(A8B_VERSION).tar.gz)
+FIRMWARE:=$(FIRMWARE:FIRMWARE-A8B=dahdi-fw-a8a-$(A8A_VERSION).tar.gz)
+FIRMWARE:=$(FIRMWARE:FIRMWARE-A4A=dahdi-fw-a4b-$(A4B_VERSION).tar.gz)
+FIRMWARE:=$(FIRMWARE:FIRMWARE-A4B=dahdi-fw-a4a-$(A4A_VERSION).tar.gz)
 
 FWLOADERS:=dahdi-fwload-vpmadt032-$(VPMADT032_VERSION).tar.gz
 
 # Build a list of object files if hotplug will not be used
+OBJECT_FILES:=$(ALL_FIRMWARE:FIRMWARE-OCT6114-032=dahdi-fw-oct6114-032.o)
 OBJECT_FILES:=$(ALL_FIRMWARE:FIRMWARE-OCT6114-064=dahdi-fw-oct6114-064.o)
 OBJECT_FILES:=$(OBJECT_FILES:FIRMWARE-OCT6114-128=dahdi-fw-oct6114-128.o)
 OBJECT_FILES:=$(OBJECT_FILES:FIRMWARE-OCT6114-256=dahdi-fw-oct6114-256.o)
@@ -107,6 +126,17 @@ $(DESTDIR)/usr/lib/hotplug/firmware $(DESTDIR)/lib/firmware:
 
 # Install all downloaded firmware images for hotplug usage
 hotplug-install: $(DESTDIR)/usr/lib/hotplug/firmware $(DESTDIR)/lib/firmware $(FIRMWARE)
+ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-oct6114-032-$(OCT6114_032_VERSION) ] ) && ( [ -f $(DESTDIR)/lib/firmware/.dahdi-fw-oct6114-032-$(OCT6114_032_VERSION) ] ); then echo "no"; else echo "yes"; fi),yes)
+	@echo "Installing dahdi-fw-oct6114-032.bin to hotplug firmware directories"
+	@install -m 644 dahdi-fw-oct6114-032.bin $(DESTDIR)/usr/lib/hotplug/firmware
+	@rm -rf $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-oct6114-032-*
+	@touch $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-oct6114-032-$(OCT6114_032_VERSION)
+	@install -m 644 dahdi-fw-oct6114-032.bin $(DESTDIR)/lib/firmware
+	@rm -rf $(DESTDIR)/lib/firmware/.dahdi-fw-oct6114-032-*
+	@touch $(DESTDIR)/lib/firmware/.dahdi-fw-oct6114-032-$(OCT6114_032_VERSION)
+else
+	@echo "Firmware dahdi-fw-oct6114-032.bin is already installed with required version $(OCT6114_032_VERSION)"
+endif
 ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-oct6114-064-$(OCT6114_064_VERSION) ] ) && ( [ -f $(DESTDIR)/lib/firmware/.dahdi-fw-oct6114-064-$(OCT6114_064_VERSION) ] ); then echo "no"; else echo "yes"; fi),yes)
 	@echo "Installing dahdi-fw-oct6114-064.bin to hotplug firmware directories"
 	@install -m 644 dahdi-fw-oct6114-064.bin $(DESTDIR)/usr/lib/hotplug/firmware
@@ -185,6 +215,84 @@ else
 	@echo "Firmware dahdi-fw-te820.bin is already installed with required version $(WCT820_VERSION)"
 endif
 
+ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-te133-$(TE133_VERSION) ] ) && ( [ -f $(DESTDIR)/lib/firmware/.dahdi-fw-te133-$(TE133_VERSION) ] ); then echo "no"; else echo "yes"; fi),yes)
+	@echo "Installing dahdi-fw-te133.bin to hotplug firmware directories"
+	@install -m 644 dahdi-fw-te133.bin $(DESTDIR)/usr/lib/hotplug/firmware
+	@rm -rf $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-te133-*
+	@touch $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-te133-$(TE133_VERSION)
+	@install -m 644 dahdi-fw-te133.bin $(DESTDIR)/lib/firmware
+	@rm -rf $(DESTDIR)/lib/firmware/.dahdi-fw-te133-*
+	@touch $(DESTDIR)/lib/firmware/.dahdi-fw-te133-$(TE133_VERSION)
+else
+	@echo "Firmware dahdi-fw-te133.bin is already installed with required version $(TE133_VERSION)"
+endif
+ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-te134-$(TE134_VERSION) ] ) && ( [ -f $(DESTDIR)/lib/firmware/.dahdi-fw-te134-$(TE134_VERSION) ] ); then echo "no"; else echo "yes"; fi),yes)
+	@echo "Installing dahdi-fw-te134.bin to hotplug firmware directories"
+	@install -m 644 dahdi-fw-te134.bin $(DESTDIR)/usr/lib/hotplug/firmware
+	@rm -rf $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-te134-*
+	@touch $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-te134-$(TE134_VERSION)
+	@install -m 644 dahdi-fw-te134.bin $(DESTDIR)/lib/firmware
+	@rm -rf $(DESTDIR)/lib/firmware/.dahdi-fw-te134-*
+	@touch $(DESTDIR)/lib/firmware/.dahdi-fw-te134-$(TE134_VERSION)
+else
+	@echo "Firmware dahdi-fw-te134.bin is already installed with required version $(TE134_VERSION)"
+endif
+ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-te435-$(TE435_VERSION) ] ) && ( [ -f $(DESTDIR)/lib/firmware/.dahdi-fw-te435-$(TE435_VERSION) ] ); then echo "no"; else echo "yes"; fi),yes)
+	@echo "Installing dahdi-fw-te435.bin to hotplug firmware directories"
+	@install -m 644 dahdi-fw-te435.bin $(DESTDIR)/usr/lib/hotplug/firmware
+	@rm -rf $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-te435-*
+	@touch $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-te435-$(TE435_VERSION)
+	@install -m 644 dahdi-fw-te435.bin $(DESTDIR)/lib/firmware
+	@rm -rf $(DESTDIR)/lib/firmware/.dahdi-fw-te435-*
+	@touch $(DESTDIR)/lib/firmware/.dahdi-fw-te435-$(TE435_VERSION)
+else
+	@echo "Firmware dahdi-fw-te435.bin is already installed with required version $(TE435_VERSION)"
+endif
+ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-a8a-$(A8A_VERSION) ] ) && ( [ -f $(DESTDIR)/lib/firmware/.dahdi-fw-a8a-$(A8A_VERSION) ] ); then echo "no"; else echo "yes"; fi),yes)
+	@echo "Installing dahdi-fw-a8a.bin to hotplug firmware directories"
+	@install -m 644 dahdi-fw-a8a.bin $(DESTDIR)/usr/lib/hotplug/firmware
+	@rm -rf $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-a8a-*
+	@touch $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-a8a-$(A8A_VERSION)
+	@install -m 644 dahdi-fw-a8a.bin $(DESTDIR)/lib/firmware
+	@rm -rf $(DESTDIR)/lib/firmware/.dahdi-fw-a8a-*
+	@touch $(DESTDIR)/lib/firmware/.dahdi-fw-a8a-$(A8A_VERSION)
+else
+	@echo "Firmware dahdi-fw-a8a.bin is already installed with required version $(A8A_VERSION)"
+endif
+ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-a8b-$(A8B_VERSION) ] ) && ( [ -f $(DESTDIR)/lib/firmware/.dahdi-fw-a8b-$(A8B_VERSION) ] ); then echo "no"; else echo "yes"; fi),yes)
+	@echo "Installing dahdi-fw-a8b.bin to hotplug firmware directories"
+	@install -m 644 dahdi-fw-a8b.bin $(DESTDIR)/usr/lib/hotplug/firmware
+	@rm -rf $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-a8b-*
+	@touch $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-a8b-$(A8B_VERSION)
+	@install -m 644 dahdi-fw-a8b.bin $(DESTDIR)/lib/firmware
+	@rm -rf $(DESTDIR)/lib/firmware/.dahdi-fw-a8b-*
+	@touch $(DESTDIR)/lib/firmware/.dahdi-fw-a8b-$(A8B_VERSION)
+else
+	@echo "Firmware dahdi-fw-a8b.bin is already installed with required version $(A8B_VERSION)"
+endif
+ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-a4a-$(A4A_VERSION) ] ) && ( [ -f $(DESTDIR)/lib/firmware/.dahdi-fw-a4a-$(A4A_VERSION) ] ); then echo "no"; else echo "yes"; fi),yes)
+	@echo "Installing dahdi-fw-a4a.bin to hotplug firmware directories"
+	@install -m 644 dahdi-fw-a4a.bin $(DESTDIR)/usr/lib/hotplug/firmware
+	@rm -rf $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-a4a-*
+	@touch $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-a4a-$(A4A_VERSION)
+	@install -m 644 dahdi-fw-a4a.bin $(DESTDIR)/lib/firmware
+	@rm -rf $(DESTDIR)/lib/firmware/.dahdi-fw-a4a-*
+	@touch $(DESTDIR)/lib/firmware/.dahdi-fw-a4a-$(A4A_VERSION)
+else
+	@echo "Firmware dahdi-fw-a4a.bin is already installed with required version $(A4A_VERSION)"
+endif
+ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-a4b-$(A4B_VERSION) ] ) && ( [ -f $(DESTDIR)/lib/firmware/.dahdi-fw-a4b-$(A4B_VERSION) ] ); then echo "no"; else echo "yes"; fi),yes)
+	@echo "Installing dahdi-fw-a4b.bin to hotplug firmware directories"
+	@install -m 644 dahdi-fw-a4b.bin $(DESTDIR)/usr/lib/hotplug/firmware
+	@rm -rf $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-a4b-*
+	@touch $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-a4b-$(A4B_VERSION)
+	@install -m 645 dahdi-fw-a4b.bin $(DESTDIR)/lib/firmware
+	@rm -rf $(DESTDIR)/lib/firmware/.dahdi-fw-a4b-*
+	@touch $(DESTDIR)/lib/firmware/.dahdi-fw-a4b-$(A4B_VERSION)
+else
+	@echo "Firmware dahdi-fw-a4b.bin is already installed with required version $(A4B_VERSION)"
+endif
+
 # Uninstall any installed dahdi firmware images from hotplug firmware directories
 hotplug-uninstall:
 	if [ -d $(DESTDIR)/usr/lib/hotplug/firmware ]; then \
@@ -202,6 +310,11 @@ make_firmware_object: make_firmware_object.in ../dahdi-base.o
 	 sed -e s/BFDNAME/$${BFDNAME}/ -e s/BFDARCH/$${BFDARCH}/ $< > $@
 	@chmod +x $@
 
+# Build object file of an oct6114 032 firmware image for linking
+dahdi-fw-oct6114-032.o: dahdi-fw-oct6114-032-$(OCT6114_032_VERSION).tar.gz dahdi-fw-oct6114-032.bin make_firmware_object
+	@echo Making firmware object file for dahdi-fw-oct6114-032.bin
+	./make_firmware_object dahdi-fw-oct6114-032.bin $@
+
 # Build object file of an oct6114 064 firmware image for linking
 dahdi-fw-oct6114-064.o: dahdi-fw-oct6114-064-$(OCT6114_064_VERSION).tar.gz dahdi-fw-oct6114-064.bin make_firmware_object
 	@echo Making firmware object file for dahdi-fw-oct6114-064.bin

drivers/dahdi/oct612x/Kbuild

@@ -0,0 +1,32 @@
+#
+# Produces the oct612x library
+#
+octapi_files = octdeviceapi/oct6100api/oct6100_api/oct6100_adpcm_chan.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_channel.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_chip_open.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_chip_stats.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_conf_bridge.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_debug.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_events.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_interrupts.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_memory.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_miscellaneous.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_mixer.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_phasing_tsst.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_playout_buf.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_remote_debug.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_tlv.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_tone_detection.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_tsi_cnct.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_tsst.o \
+		apilib/bt/octapi_bt0.o \
+		apilib/largmath/octapi_largmath.o \
+		apilib/llman/octapi_llman.o \
+		oct612x-user.o
+
+# TODO: ccflags was added in 2.6.24 in commit f77bf01425b11947eeb3b5b54. This
+# should be changed to a conditional compilation based on the Kernel Version.
+# ccflags-y := -I$(src)/.. -Wno-undef -I$(src)/include -I$(src)/octdeviceapi -I$(src)/octdeviceapi/oct6100api
+EXTRA_CFLAGS = -I$(src)/.. -Wno-undef -I$(src)/include -I$(src)/octdeviceapi -I$(src)/octdeviceapi/oct6100api
+obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_OCT612X) := oct612x.o
+oct612x-objs := $(octapi_files)

drivers/dahdi/oct612x/Makefile

@@ -1,38 +1,30 @@
-CFLAGS=-V3.4 -ffunction-sections -I/lib/modules/$(shell uname -r)/build/include -Iinclude -Ioctdeviceapi -Ioctdeviceapi/oct6100api -DGFP_ATOMIC=0 -Dkmalloc=calloc -Dkfree=free
-LDFLAGS=-V3.4 -Wl,-Map -Wl,test.map -Wl,--gc-sections
+#
+# Produces the oct612x library
+#
+octapi_files = octdeviceapi/oct6100api/oct6100_api/oct6100_adpcm_chan.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_channel.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_chip_open.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_chip_stats.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_conf_bridge.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_debug.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_events.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_interrupts.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_memory.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_miscellaneous.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_mixer.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_phasing_tsst.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_playout_buf.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_remote_debug.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_tlv.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_tone_detection.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_tsi_cnct.o \
+		octdeviceapi/oct6100api/oct6100_api/oct6100_tsst.o \
+		apilib/bt/octapi_bt0.o \
+		apilib/largmath/octapi_largmath.o \
+		apilib/llman/octapi_llman.o
 
-APIDIR=octdeviceapi/oct6100api/oct6100_api
-
-OCTASIC_OBJS=$(APIDIR)/oct6100_adpcm_chan.o \
-	    $(APIDIR)/oct6100_channel.o \
-	    $(APIDIR)/oct6100_chip_open.o \
-	    $(APIDIR)/oct6100_chip_stats.o \
-	    $(APIDIR)/oct6100_conf_bridge.o \
-	    $(APIDIR)/oct6100_debug.o \
-	    $(APIDIR)/oct6100_events.o \
-	    $(APIDIR)/oct6100_interrupts.o \
-	    $(APIDIR)/oct6100_memory.o \
-	    $(APIDIR)/oct6100_miscellaneous.o \
-	    $(APIDIR)/oct6100_mixer.o \
-	    $(APIDIR)/oct6100_phasing_tsst.o \
-	    $(APIDIR)/oct6100_playout_buf.o \
-	    $(APIDIR)/oct6100_remote_debug.o \
-	    $(APIDIR)/oct6100_tlv.o \
-	    $(APIDIR)/oct6100_tone_detection.o \
-	    $(APIDIR)/oct6100_tsi_cnct.o \
-	    $(APIDIR)/oct6100_tsst.o \
-	    $(APIDIR)/oct6100_user.o \
-	    apilib/bt/octapi_bt0.o \
-	    apilib/largmath/octapi_largmath.o \
-	    apilib/llman/octapi_llman.o
-
-
-all: test
-
-test.o: test.c
-
-test: test.o $(OCTASIC_OBJS)
-
-clean:
-	rm -rf test test.o
-	rm -rf $(OCTASIC_OBJS)
+# TODO: ccflags was added in 2.6.24 in commit f77bf01425b11947eeb3b5b54. This
+# should be changed to a conditional compilation based on the Kernel Version.
+# ccflags-y := -I$(src)/.. -Wno-undef -I$(src)/include -I$(src)/octdeviceapi -I$(src)/octdeviceapi/oct6100api
+EXTRA_CFLAGS = -I$(src)/.. -Wno-undef -I$(src)/include -I$(src)/octdeviceapi -I$(src)/octdeviceapi/oct6100api
+lib-y := $(octapi_files)

drivers/dahdi/oct612x/oct612x-user.c

@@ -0,0 +1,200 @@
+/*
+ * Octasic OCT6100 Interface
+ *
+ * Copyright (C) 2013 Digium, Inc.
+ *
+ * All rights reserved.
+ *
+ */
+
+/*
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2 as published by the
+ * Free Software Foundation. See the LICENSE file included with
+ * this program for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+
+#include <dahdi/kernel.h>
+
+#include "oct612x.h"
+
+UINT32 Oct6100UserGetTime(tPOCT6100_GET_TIME f_pTime)
+{
+	/* Why couldn't they just take a timeval like everyone else? */
+	struct timeval tv;
+	unsigned long long total_usecs;
+	unsigned int mask = ~0;
+
+	do_gettimeofday(&tv);
+	total_usecs = (((unsigned long long)(tv.tv_sec)) * 1000000) +
+				  (((unsigned long long)(tv.tv_usec)));
+	f_pTime->aulWallTimeUs[0] = (total_usecs & mask);
+	f_pTime->aulWallTimeUs[1] = (total_usecs >> 32);
+	return cOCT6100_ERR_OK;
+}
+
+UINT32 Oct6100UserMemSet(PVOID f_pAddress, UINT32 f_ulPattern,
+			 UINT32 f_ulLength)
+{
+	memset(f_pAddress, f_ulPattern, f_ulLength);
+	return cOCT6100_ERR_OK;
+}
+
+UINT32 Oct6100UserMemCopy(PVOID f_pDestination, const void *f_pSource,
+			  UINT32 f_ulLength)
+{
+	memcpy(f_pDestination, f_pSource, f_ulLength);
+	return cOCT6100_ERR_OK;
+}
+
+UINT32 Oct6100UserCreateSerializeObject(
+			tPOCT6100_CREATE_SERIALIZE_OBJECT f_pCreate)
+{
+	return cOCT6100_ERR_OK;
+}
+
+UINT32 Oct6100UserDestroySerializeObject(
+			tPOCT6100_DESTROY_SERIALIZE_OBJECT f_pDestroy)
+{
+#ifdef OCTASIC_DEBUG
+	pr_debug("I should never be called! (destroy serialize object)\n");
+#endif
+	return cOCT6100_ERR_OK;
+}
+
+UINT32 Oct6100UserSeizeSerializeObject(
+		tPOCT6100_SEIZE_SERIALIZE_OBJECT f_pSeize)
+{
+	/* Not needed */
+	return cOCT6100_ERR_OK;
+}
+
+UINT32 Oct6100UserReleaseSerializeObject(
+		tPOCT6100_RELEASE_SERIALIZE_OBJECT f_pRelease)
+{
+	/* Not needed */
+	return cOCT6100_ERR_OK;
+}
+
+UINT32 Oct6100UserDriverWriteApi(tPOCT6100_WRITE_PARAMS f_pWriteParams)
+{
+	struct oct612x_context *context = f_pWriteParams->pProcessContext;
+#ifdef OCTASIC_DEBUG
+	if (!context || !context->ops || !context->ops->write) {
+		pr_debug("Invalid call to %s\n", __func__);
+		return cOCT6100_ERR_BASE;
+	}
+#endif
+	context->ops->write(context, f_pWriteParams->ulWriteAddress,
+			    f_pWriteParams->usWriteData);
+	return cOCT6100_ERR_OK;
+}
+
+UINT32 Oct6100UserDriverWriteSmearApi(tPOCT6100_WRITE_SMEAR_PARAMS f_pSmearParams)
+{
+	struct oct612x_context *context = f_pSmearParams->pProcessContext;
+#ifdef OCTASIC_DEBUG
+	if (!context || !context->ops || !context->ops->write_smear) {
+		pr_debug("Invalid call to %s\n", __func__);
+		return cOCT6100_ERR_BASE;
+	}
+#endif
+	context->ops->write_smear(context, f_pSmearParams->ulWriteAddress,
+				  f_pSmearParams->usWriteData,
+				  f_pSmearParams->ulWriteLength);
+	return cOCT6100_ERR_OK;
+}
+
+UINT32 Oct6100UserDriverWriteBurstApi(
+		tPOCT6100_WRITE_BURST_PARAMS f_pBurstParams)
+{
+	struct oct612x_context *context = f_pBurstParams->pProcessContext;
+#ifdef OCTASIC_DEBUG
+	if (!context || !context->ops || !context->ops->write_burst) {
+		pr_debug("Invalid call to %s\n", __func__);
+		return cOCT6100_ERR_BASE;
+	}
+#endif
+	context->ops->write_burst(context, f_pBurstParams->ulWriteAddress,
+				  f_pBurstParams->pusWriteData,
+				  f_pBurstParams->ulWriteLength);
+	return cOCT6100_ERR_OK;
+}
+
+UINT32 Oct6100UserDriverReadApi(tPOCT6100_READ_PARAMS f_pReadParams)
+{
+	struct oct612x_context *context = f_pReadParams->pProcessContext;
+#ifdef OCTASIC_DEBUG
+	if (!context || !context->ops || !context->ops->read) {
+		pr_debug("Invalid call to %s\n", __func__);
+		return cOCT6100_ERR_BASE;
+	}
+#endif
+	context->ops->read(context, f_pReadParams->ulReadAddress,
+			   f_pReadParams->pusReadData);
+	return cOCT6100_ERR_OK;
+}
+
+UINT32 Oct6100UserDriverReadBurstApi(tPOCT6100_READ_BURST_PARAMS f_pBurstParams)
+{
+	struct oct612x_context *context = f_pBurstParams->pProcessContext;
+#ifdef OCTASIC_DEBUG
+	if (!context || !context->ops || !context->ops->read_burst) {
+		pr_debug("Invalid call to %s\n", __func__);
+		return cOCT6100_ERR_BASE;
+	}
+#endif
+	context->ops->read_burst(context, f_pBurstParams->ulReadAddress,
+				 f_pBurstParams->pusReadData,
+				 f_pBurstParams->ulReadLength);
+	return cOCT6100_ERR_OK;
+}
+
+EXPORT_SYMBOL(Oct6100ChipOpen);
+EXPORT_SYMBOL(Oct6100ChipClose);
+EXPORT_SYMBOL(Oct6100ChipCloseDef);
+EXPORT_SYMBOL(Oct6100GetInstanceSize);
+EXPORT_SYMBOL(Oct6100GetInstanceSizeDef);
+EXPORT_SYMBOL(Oct6100ChipOpenDef);
+EXPORT_SYMBOL(Oct6100ChannelModify);
+EXPORT_SYMBOL(Oct6100ToneDetectionEnableDef);
+EXPORT_SYMBOL(Oct6100InterruptServiceRoutine);
+EXPORT_SYMBOL(Oct6100InterruptServiceRoutineDef);
+EXPORT_SYMBOL(Oct6100ApiGetCapacityPins);
+EXPORT_SYMBOL(Oct6100ToneDetectionEnable);
+EXPORT_SYMBOL(Oct6100EventGetToneDef);
+EXPORT_SYMBOL(Oct6100EventGetTone);
+EXPORT_SYMBOL(Oct6100ApiGetCapacityPinsDef);
+EXPORT_SYMBOL(Oct6100ChannelOpen);
+EXPORT_SYMBOL(Oct6100ChannelOpenDef);
+EXPORT_SYMBOL(Oct6100ChannelModifyDef);
+
+static int __init oct612x_module_init(void)
+{
+	/* This registration with dahdi.ko will fail since the span is not
+	 * defined, but it will make sure that this module is a dependency of
+	 * dahdi.ko, so that when it is being unloded, this module will be
+	 * unloaded as well. */
+	dahdi_register_device(NULL, NULL);
+	return 0;
+}
+module_init(oct612x_module_init);
+
+static void __exit oct612x_module_cleanup(void)
+{
+	/* Nothing to do */;
+}
+module_exit(oct612x_module_cleanup);
+
+MODULE_AUTHOR("Digium Incorporated <support@digium.com>");
+MODULE_DESCRIPTION("Octasic OCT6100 Hardware Echocan Library");
+MODULE_LICENSE("GPL v2");

drivers/dahdi/oct612x/oct612x.h

@@ -0,0 +1,49 @@
+/*
+ * Octasic OCT6100 Interface
+ *
+ * Copyright (C) 2013 Digium, Inc.
+ *
+ * All rights reserved.
+ *
+ */
+
+/*
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2 as published by the
+ * Free Software Foundation. See the LICENSE file included with
+ * this program for more details.
+ */
+#ifndef __OCT612X_H__
+#define __OCT612X_H__
+
+#include <oct6100api/oct6100_api.h>
+
+struct oct612x_context;
+
+/**
+ * struct oct612x_ops - Callbacks used by oct612x library to talk to part.
+ *
+ */
+struct oct612x_ops {
+	int (*write)(struct oct612x_context *context, u32 address, u16 value);
+	int (*read)(struct oct612x_context *context, u32 address, u16 *value);
+	int (*write_smear)(struct oct612x_context *context, u32 address,
+			   u16 value, size_t count);
+	int (*write_burst)(struct oct612x_context *context, u32 address,
+			   const u16 *value, size_t count);
+	int (*read_burst)(struct oct612x_context *context, u32 address,
+			  u16 *value, size_t count);
+};
+
+struct oct612x_context {
+	const struct oct612x_ops *ops;
+	struct device *dev;
+};
+
+#endif /* __OCT612X_H__ */

drivers/dahdi/wcb4xxp/base.c

@@ -1242,7 +1242,8 @@ static char *hfc_decode_st_state(struct b4xxp *b4, int port, unsigned char state
 			"?", "?", "?", "?", "?", "?", "?", "?" }
 	};
 
-	if (!(str = kmalloc(256, GFP_KERNEL))) {
+	str = kmalloc(256, GFP_ATOMIC);
+	if (!str) {
 		dev_warn(&b4->pdev->dev, "could not allocate mem for ST state decode string!\n");
 		return NULL;
 	}

drivers/dahdi/wct4xxp/Kbuild

@@ -2,7 +2,7 @@ obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCT4XXP) += wct4xxp.o
 
 FIRM_DIR	:= ../firmware
 
-EXTRA_CFLAGS += -I$(src)/.. $(shell $(src)/../oct612x/octasic-helper cflags $(src)/../oct612x) -Wno-undef
+EXTRA_CFLAGS += -I$(src)/.. -I$(src)/../oct612x/ $(shell $(src)/../oct612x/octasic-helper cflags $(src)/../oct612x) -Wno-undef
 
 # The OCT612X source files are from a vendor drop and we do not want to edit
 # them to make this warning go away. Therefore, turn off the
@@ -14,7 +14,7 @@ ifeq ($(HOTPLUG_FIRMWARE),yes)
   EXTRA_CFLAGS+=-DHOTPLUG_FIRMWARE
 endif
 
-wct4xxp-objs := base.o vpm450m.o $(shell $(src)/../oct612x/octasic-helper objects ../oct612x)
+wct4xxp-objs := base.o vpm450m.o
 
 ifneq ($(HOTPLUG_FIRMWARE),yes)
 wct4xxp-objs += $(FIRM_DIR)/dahdi-fw-oct6114-064.o $(FIRM_DIR)/dahdi-fw-oct6114-128.o $(FIRM_DIR)/dahdi-fw-oct6114-256.o

drivers/dahdi/wct4xxp/base.c

@@ -183,7 +183,7 @@ static inline int t4_queue_work(struct workqueue_struct *wq, struct work_struct
 		"CONFIG_NOEXTENDED_RESET."
 #endif
 
-static int debug=0;
+int debug = 0;
 static int timingcable = 0;
 static int t1e1override = -1;  /* deprecated */
 static char *default_linemode = "auto";
@@ -299,6 +299,7 @@ struct t4_span {
 	unsigned long alarmcheck_time;
 	int spanflags;
 	int syncpos;
+
 #ifdef SUPPORT_GEN1
 	int e1check;			/* E1 check */
 #endif
@@ -345,6 +346,7 @@ struct t4 {
 	int irq;			/* IRQ used by device */
 	int order;			/* Order */
 	const struct devtype *devtype;
+	unsigned int reset_required:1;	/* If reset needed in serial_setup */
 	unsigned int falc31:1;	/* are we falc v3.1 (atomic not necessary) */
 	unsigned int t1e1:8;	/* T1 / E1 select pins */
 	int ledreg;				/* LED Register */
@@ -390,7 +392,7 @@ static inline bool is_pcie(const struct t4 *wc)
 
 static inline bool has_e1_span(const struct t4 *wc)
 {
-	return (wc->t1e1) != 0;
+	return (wc->t1e1 > 0);
 }
 
 static inline bool is_octal(const struct t4 *wc)
@@ -505,7 +507,7 @@ static void t4_check_sigbits(struct t4 *wc, int span);
 #define FMR5_EIBR (1 << 6)	/* Internal Bit Robbing Access */
 #define DEC_T 0x60		/* Diable Error Counter */
 #define IERR_T 0x1B		/* Single Bit Defect Insertion Register */
-#define IBV	0	 /* Bipolar violation */
+#define IBV	(1 << 0) /* Bipolar violation */
 #define IPE	(1 << 1) /* PRBS defect */
 #define ICASE	(1 << 2) /* CAS defect */
 #define ICRCE	(1 << 3) /* CRC defect */
@@ -1121,6 +1123,7 @@ static int t4_echocan_create(struct dahdi_chan *chan,
 	int channel;
 	const struct dahdi_echocan_ops *ops;
 	const struct dahdi_echocan_features *features;
+	const bool alaw = (chan->span->deflaw == 2);
 
 	if (!vpmsupport || !wc->vpm)
 		return -ENODEV;
@@ -1141,19 +1144,19 @@ static int t4_echocan_create(struct dahdi_chan *chan,
 
 	channel = has_e1_span(wc) ? chan->chanpos : chan->chanpos + 4;
 
-	if (wc->vpm) {
-		if (is_octal(wc))
-			channel = channel << 3;
-		else
-			channel = channel << 2;
-		channel |= chan->span->offset;
-		if (debug & DEBUG_ECHOCAN)
-			dev_notice(&wc->dev->dev, "echocan: Card is %d, "
-				"Channel is %d, Span is %d, offset is %d "
-				"length %d\n", wc->num, chan->chanpos,
-				chan->span->offset, channel, ecp->tap_length);
-		vpm450m_setec(wc->vpm, channel, ecp->tap_length);
+	if (is_octal(wc))
+		channel = channel << 3;
+	else
+		channel = channel << 2;
+	channel |= chan->span->offset;
+	if (debug & DEBUG_ECHOCAN) {
+		dev_notice(&wc->dev->dev,
+			   "echocan: Card is %d, Channel is %d, Span is %d, offset is %d length %d\n",
+			   wc->num, chan->chanpos, chan->span->offset,
+			   channel, ecp->tap_length);
 	}
+	vpm450m_set_alaw_companding(wc->vpm, channel, alaw);
+	vpm450m_setec(wc->vpm, channel, ecp->tap_length);
 	return 0;
 }
 
@@ -1162,23 +1165,23 @@ static void echocan_free(struct dahdi_chan *chan, struct dahdi_echocan_state *ec
 	struct t4 *wc = chan->pvt;
 	int channel;
 
-	memset(ec, 0, sizeof(*ec));
+	if (!wc->vpm)
+		return;
 
+	memset(ec, 0, sizeof(*ec));
 	channel = has_e1_span(wc) ? chan->chanpos : chan->chanpos + 4;
 
-	if (wc->vpm) {
-		if (is_octal(wc))
-			channel = channel << 3;
-		else
-			channel = channel << 2;
-		channel |= chan->span->offset;
-		if (debug & DEBUG_ECHOCAN)
-			dev_notice(&wc->dev->dev, "echocan: Card is %d, "
-				"Channel is %d, Span is %d, offset is %d "
-				"length 0\n", wc->num, chan->chanpos,
-				chan->span->offset, channel);
-		vpm450m_setec(wc->vpm, channel, 0);
+	if (is_octal(wc))
+		channel = channel << 3;
+	else
+		channel = channel << 2;
+	channel |= chan->span->offset;
+	if (debug & DEBUG_ECHOCAN) {
+		dev_notice(&wc->dev->dev,
+			   "echocan: Card is %d, Channel is %d, Span is %d, offset is %d length 0\n",
+			   wc->num, chan->chanpos, chan->span->offset, channel);
 	}
+	vpm450m_setec(wc->vpm, channel, 0);
 }
 #endif
 
@@ -1711,8 +1714,11 @@ _t4_spanconfig(struct file *file, struct dahdi_span *span,
 
 	if (lc->sync < 0)
 		lc->sync = 0;
-	if (lc->sync > wc->numspans)
+	if (lc->sync > wc->numspans) {
+		dev_warn(&wc->dev->dev, "WARNING: Cannot set priority on span %d to %d. Please set to a number between 1 and %d\n",
+			 span->spanno, lc->sync, wc->numspans);
 		lc->sync = 0;
+	}
 	
 	/* remove this span number from the current sync sources, if there */
 	for(i = 0; i < wc->numspans; i++) {
@@ -1889,6 +1895,33 @@ static void setup_chunks(struct t4 *wc, int which)
 	}
 }
 
+static int __t4_hardware_init_1(struct t4 *wc, unsigned int cardflags,
+				bool first_time);
+static int __t4_hardware_init_2(struct t4 *wc, bool first_time);
+
+static int t4_hardware_stop(struct t4 *wc);
+
+static void t4_framer_reset(struct t4 *wc)
+{
+	const bool first_time = false;
+	bool have_vpm = wc->vpm != NULL;
+	if (have_vpm) {
+		release_vpm450m(wc->vpm);
+		wc->vpm = NULL;
+	}
+	t4_hardware_stop(wc);
+	__t4_set_sclk_src(wc, WC_SELF, 0, 0);
+	__t4_hardware_init_1(wc, wc->devtype->flags, first_time);
+	__t4_hardware_init_2(wc, first_time);
+	if (have_vpm) {
+		t4_vpm_init(wc);
+		wc->dmactrl |= (wc->vpm) ? T4_VPM_PRESENT : 0;
+		t4_pci_out(wc, WC_DMACTRL, wc->dmactrl);
+	}
+	setup_chunks(wc, 0);
+	wc->lastindex = 0;
+}
+
 /**
  * t4_serial_setup - Setup serial parameters and system interface.
  * @wc:		The card to configure.
@@ -1898,6 +1931,7 @@ static void t4_serial_setup(struct t4 *wc)
 {
 	unsigned long flags;
 	unsigned int unit;
+	bool reset_required = false;
 
 	if (debug) {
 		dev_info(&wc->dev->dev,
@@ -1905,6 +1939,14 @@ static void t4_serial_setup(struct t4 *wc)
 			 wc->numspans);
 	}
 
+	spin_lock_irqsave(&wc->reglock, flags);
+	reset_required = wc->reset_required > 0;
+	wc->reset_required = 0;
+	spin_unlock_irqrestore(&wc->reglock, flags);
+
+	if (reset_required)
+		t4_framer_reset(wc);
+
 	spin_lock_irqsave(&wc->reglock, flags);
 	/* GPC1: Multiplex mode enabled, FSC is output, active low, RCLK from
 	 * channel 0 */
@@ -2055,16 +2097,23 @@ static void t4_span_assigned(struct dahdi_span *span)
 	struct t4 *wc = tspan->owner;
 	struct dahdi_span *pos;
 	unsigned int unassigned_spans = 0;
+	unsigned long flags;
 
 	/* We use this to make sure all the spans are assigned before
 	 * running the serial setup. */
 	list_for_each_entry(pos, &wc->ddev->spans, device_node) {
-		if (!test_bit(DAHDI_FLAGBIT_REGISTERED, &span->flags))
+		if (!test_bit(DAHDI_FLAGBIT_REGISTERED, &pos->flags))
 			++unassigned_spans;
 	}
 
-	if (0 == unassigned_spans)
+	if (0 == unassigned_spans) {
 		t4_serial_setup(wc);
+
+		set_bit(T4_CHECK_TIMING, &wc->checkflag);
+		spin_lock_irqsave(&wc->reglock, flags);
+		__t4_set_sclk_src(wc, WC_SELF, 0, 0);
+		spin_unlock_irqrestore(&wc->reglock, flags);
+	}
 }
 
 static void free_wc(struct t4 *wc)
@@ -2225,6 +2274,8 @@ static int t4_set_linemode(struct dahdi_span *span, enum spantypes linemode)
 	int res = 0;
 	enum linemode mode;
 	const char *old_name;
+	static DEFINE_MUTEX(linemode_lock);
+	unsigned long flags;
 
 	dev_dbg(&wc->dev->dev, "Setting '%s' to '%s'\n", span->name,
 		dahdi_spantype2str(linemode));
@@ -2232,22 +2283,31 @@ static int t4_set_linemode(struct dahdi_span *span, enum spantypes linemode)
 	if (span->spantype == linemode)
 		return 0;
 
+	spin_lock_irqsave(&wc->reglock, flags);
+	wc->reset_required = 1;
+	spin_unlock_irqrestore(&wc->reglock, flags);
+
+	/* Do not allow the t1e1 member to be changed by multiple threads. */
+	mutex_lock(&linemode_lock);
 	old_name = dahdi_spantype2str(span->spantype);
 	switch (linemode) {
 	case SPANTYPE_DIGITAL_T1:
 		dev_info(&wc->dev->dev,
 			 "Changing from %s to T1 line mode.\n", old_name);
 		mode = T1;
+		wc->t1e1 &= ~(1 << span->offset);
 		break;
 	case SPANTYPE_DIGITAL_E1:
 		dev_info(&wc->dev->dev,
 			 "Changing from %s to E1 line mode.\n", old_name);
 		mode = E1;
+		wc->t1e1 |= (1 << span->offset);
 		break;
 	case SPANTYPE_DIGITAL_J1:
 		dev_info(&wc->dev->dev,
 			 "Changing from %s to J1 line mode.\n", old_name);
 		mode = J1;
+		wc->t1e1 &= ~(1 << span->offset);
 		break;
 	default:
 		dev_err(&wc->dev->dev,
@@ -2261,6 +2321,7 @@ static int t4_set_linemode(struct dahdi_span *span, enum spantypes linemode)
 		dahdi_init_span(span);
 	}
 
+	mutex_unlock(&linemode_lock);
 	return res;
 }
 
@@ -2822,6 +2883,10 @@ static void __t4_configure_e1(struct t4 *wc, int unit, int lineconfig)
 	__t4_framer_out(wc, unit, 0x17, 0x04 | imr3extra); /* IMR3: AIS */
 	__t4_framer_out(wc, unit, 0x18, 0x3f);  /* IMR4: We care about slips on transmit */
 
+	__t4_framer_out(wc, unit, 0x2f, 0x00);
+	__t4_framer_out(wc, unit, 0x30, 0x00);
+	__t4_framer_out(wc, unit, 0x31, 0x00);
+
 	dev_info(&wc->dev->dev, "TE%dXXP: Span %d configured for %s/%s%s\n",
 			wc->numspans, unit + 1, framing, line, crc4);
 }
@@ -3682,7 +3747,7 @@ static inline void t4_framer_interrupt(struct t4 *wc, int span)
 	}
 	if (!ts->span.alarms) {
 		if ((isr3 & 0x3) || (isr4 & 0xc0))
-			ts->span.timingslips++;
+			ts->span.count.timingslips++;
 
 		if (debug & DEBUG_MAIN) {
 			if (isr3 & 0x02)
@@ -3703,7 +3768,7 @@ static inline void t4_framer_interrupt(struct t4 *wc, int span)
 					wc->numspans, span + 1);
 		}
 	} else
-		ts->span.timingslips = 0;
+		ts->span.count.timingslips = 0;
 
 	spin_lock_irqsave(&wc->reglock, flags);
 	/* HDLC controller checks - receive side */
@@ -4298,7 +4363,7 @@ static void t4_vpm_init(struct t4 *wc)
 			laws[x] = 1;
 	}
 
-	vpm_capacity = get_vpm450m_capacity(wc);
+	vpm_capacity = get_vpm450m_capacity(&wc->dev->dev);
 	if (vpm_capacity != wc->numspans * 32) {
 		dev_info(&wc->dev->dev, "Disabling VPMOCT%03d. TE%dXXP"\
 				" requires a VPMOCT%03d", vpm_capacity,
@@ -4370,7 +4435,8 @@ static void t4_vpm_init(struct t4 *wc)
 		return;
 	}
 
-	if (!(wc->vpm = init_vpm450m(wc, laws, wc->numspans, firmware))) {
+	wc->vpm = init_vpm450m(&wc->dev->dev, laws, wc->numspans, firmware);
+	if (!wc->vpm) {
 		dev_notice(&wc->dev->dev, "VPM450: Failed to initialize\n");
 		if (firmware != &embedded_firmware)
 			release_firmware(firmware);
@@ -4857,17 +4923,18 @@ cleanup:
 	return res;
 }
 
-static int t4_hardware_init_1(struct t4 *wc, unsigned int cardflags)
+static int
+__t4_hardware_init_1(struct t4 *wc, unsigned int cardflags, bool first_time)
 {
 	unsigned int version;
 	int res;
 
 	version = t4_pci_in(wc, WC_VERSION);
-	if (is_octal(wc)) {
+	if (is_octal(wc) && first_time) {
 		dev_info(&wc->dev->dev, "Firmware Version: %01x.%02x\n",
 			(version & 0xf00) >> 8,
 			version & 0xff);
-	} else {
+	} else if (first_time) {
 		dev_info(&wc->dev->dev, "Firmware Version: %08x\n", version);
 	}
 	if (debug) {
@@ -4915,30 +4982,33 @@ static int t4_hardware_init_1(struct t4 *wc, unsigned int cardflags)
 	t4_pci_out(wc, WC_INTR, 0x00000000);
 
 	/* Read T1/E1 status */
-	if (!strcasecmp("auto", default_linemode)) {
-		if (-1 == t1e1override) {
-			wc->t1e1 = (((t4_pci_in(wc, WC_LEDS)) & 0x0f00) >> 8);
-			wc->t1e1 &= 0xf;
-			if (is_octal(wc)) {
-				wc->t1e1 |= ((t4_pci_in(wc, WC_LEDS2)) &
-							0x0f00) >> 4;
+	if (first_time) {
+		if (!strcasecmp("auto", default_linemode)) {
+			if (-1 == t1e1override) {
+				wc->t1e1 = (((t4_pci_in(wc, WC_LEDS)) &
+							0x0f00) >> 8);
+				wc->t1e1 &= 0xf;
+				if (is_octal(wc)) {
+					wc->t1e1 |= ((t4_pci_in(wc, WC_LEDS2)) &
+								0x0f00) >> 4;
+				}
+			} else {
+				dev_warn(&wc->dev->dev,
+					 "'t1e1override' is deprecated. Please use 'default_linemode'.\n");
+				wc->t1e1 = t1e1override & 0xf;
 			}
+		} else if (!strcasecmp("t1", default_linemode)) {
+			wc->t1e1 = 0;
+		} else if (!strcasecmp("e1", default_linemode)) {
+			wc->t1e1 = 0xff;
+		} else if (!strcasecmp("j1", default_linemode)) {
+			wc->t1e1 = 0;
+			j1mode = 1;
 		} else {
-			dev_warn(&wc->dev->dev, "'t1e1override' is deprecated. "
-				 "Please use 'default_linemode'.\n");
-			wc->t1e1 = t1e1override & 0xf;
+			dev_err(&wc->dev->dev, "'%s' is an unknown linemode.\n",
+				default_linemode);
+			wc->t1e1 = 0;
 		}
-	} else if (!strcasecmp("t1", default_linemode)) {
-		wc->t1e1 = 0;
-	} else if (!strcasecmp("e1", default_linemode)) {
-		wc->t1e1 = 0xff;
-	} else if (!strcasecmp("j1", default_linemode)) {
-		wc->t1e1 = 0;
-		j1mode = 1;
-	} else {
-		dev_err(&wc->dev->dev, "'%s' is an unknown linemode.\n",
-			default_linemode);
-		wc->t1e1 = 0;
 	}
 
 	wc->order = ((t4_pci_in(wc, WC_LEDS)) & 0xf0000000) >> 28;
@@ -4967,7 +5037,12 @@ static int t4_hardware_init_1(struct t4 *wc, unsigned int cardflags)
 	return 0;
 }
 
-static int t4_hardware_init_2(struct t4 *wc)
+static int t4_hardware_init_1(struct t4 *wc, unsigned int cardflags)
+{
+	return __t4_hardware_init_1(wc, cardflags, true);
+}
+
+static int __t4_hardware_init_2(struct t4 *wc, bool first_time)
 {
 	int x;
 	unsigned int regval;
@@ -4999,13 +5074,14 @@ static int t4_hardware_init_2(struct t4 *wc)
 
 	if (!is_octal(wc)) {
 		regval = t4_framer_in(wc, 0, 0x4a);
-		if (regval == 0x05) {
+		if (first_time && regval == 0x05) {
 			dev_info(&wc->dev->dev, "FALC Framer Version: 2.1 or "
 				 "earlier\n");
 		} else if (regval == 0x20) {
-			dev_info(&wc->dev->dev, "FALC Framer Version: 3.1\n");
+			if (first_time)
+				dev_info(&wc->dev->dev, "FALC Framer Version: 3.1\n");
 			wc->falc31 = 1;
-		} else {
+		} else if (first_time) {
 			dev_info(&wc->dev->dev, "FALC Framer Version: Unknown "
 				 "(VSTR = 0x%02x)\n", regval);
 		}
@@ -5025,14 +5101,24 @@ static int t4_hardware_init_2(struct t4 *wc)
 					t4_pci_in(wc, x));
 		}
 	}
+
+	wc->gpio = 0x00000000;
+	t4_pci_out(wc, WC_GPIO, wc->gpio);
+	t4_gpio_setdir(wc, (1 << 17), (1 << 17));
+	t4_gpio_setdir(wc, (0xff), (0xff));
+
 	return 0;
 }
 
+static int t4_hardware_init_2(struct t4 *wc)
+{
+	return __t4_hardware_init_2(wc, true);
+}
+
 static int __devinit t4_launch(struct t4 *wc)
 {
 	int x;
 	int res;
-	unsigned long flags;
 
 	if (test_bit(DAHDI_FLAGBIT_REGISTERED, &wc->tspans[0]->span.flags))
 		return 0;
@@ -5064,17 +5150,14 @@ static int __devinit t4_launch(struct t4 *wc)
 			      &wc->ddev->spans);
 	}
 
+	tasklet_init(&wc->t4_tlet, t4_isr_bh, (unsigned long)wc);
+
 	res = dahdi_register_device(wc->ddev, &wc->dev->dev);
 	if (res) {
 		dev_err(&wc->dev->dev, "Failed to register with DAHDI.\n");
 		return res;
 	}
 
-	set_bit(T4_CHECK_TIMING, &wc->checkflag);
-	spin_lock_irqsave(&wc->reglock, flags);
-	__t4_set_sclk_src(wc, WC_SELF, 0, 0);
-	spin_unlock_irqrestore(&wc->reglock, flags);
-	tasklet_init(&wc->t4_tlet, t4_isr_bh, (unsigned long)wc);
 	return 0;
 }
 
@@ -5288,10 +5371,6 @@ t4_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 		dev_info(&wc->dev->dev,
 			 "Found a Wildcard: %s\n", wc->devtype->desc);
 	}
-	wc->gpio = 0x00000000;
-	t4_pci_out(wc, WC_GPIO, wc->gpio);
-	t4_gpio_setdir(wc, (1 << 17), (1 << 17));
-	t4_gpio_setdir(wc, (0xff), (0xff));
 
 #ifdef VPM_SUPPORT
 	if (!wc->vpm) {

drivers/dahdi/wct4xxp/vpm450m.c

@@ -19,106 +19,74 @@
  * this program for more details.
  */
 
+#define pr_fmt(fmt)             KBUILD_MODNAME ": " fmt
+
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/string.h>
 #include <linux/time.h>
 #include <linux/version.h>
 
+#include <dahdi/kernel.h>
+#include <stdbool.h>
+
 #include "vpm450m.h"
-#include "oct6100api/oct6100_api.h"
+#include <oct612x.h>
 
-/* API for Octasic access */
-UINT32 Oct6100UserGetTime(tPOCT6100_GET_TIME f_pTime)
+static int wct4xxp_oct612x_write(struct oct612x_context *context,
+				 u32 address, u16 value)
 {
-	/* Why couldn't they just take a timeval like everyone else? */
-	struct timeval tv;
-	unsigned long long total_usecs;
-	unsigned int mask = ~0;
-	
-	do_gettimeofday(&tv);
-	total_usecs = (((unsigned long long)(tv.tv_sec)) * 1000000) + 
-				  (((unsigned long long)(tv.tv_usec)));
-	f_pTime->aulWallTimeUs[0] = (total_usecs & mask);
-	f_pTime->aulWallTimeUs[1] = (total_usecs >> 32);
-	return cOCT6100_ERR_OK;
+	struct t4 *wc = dev_get_drvdata(context->dev);
+	oct_set_reg(wc, address, value);
+	return 0;
 }
 
-UINT32 Oct6100UserMemSet(PVOID f_pAddress, UINT32 f_ulPattern, UINT32 f_ulLength)
+static int wct4xxp_oct612x_read(struct oct612x_context *context, u32 address,
+				u16 *value)
 {
-	memset(f_pAddress, f_ulPattern, f_ulLength);
-	return cOCT6100_ERR_OK;
+	struct t4 *wc = dev_get_drvdata(context->dev);
+	*value = (u16)oct_get_reg(wc, address);
+	return 0;
 }
 
-UINT32 Oct6100UserMemCopy(PVOID f_pDestination, const void *f_pSource, UINT32 f_ulLength)
+static int wct4xxp_oct612x_write_smear(struct oct612x_context *context,
+				       u32 address, u16 value, size_t count)
 {
-	memcpy(f_pDestination, f_pSource, f_ulLength);
-	return cOCT6100_ERR_OK;
+	struct t4 *wc = dev_get_drvdata(context->dev);
+	int i;
+	for (i = 0; i < count; ++i)
+		oct_set_reg(wc, address + (i << 1), value);
+	return 0;
 }
 
-UINT32 Oct6100UserCreateSerializeObject(tPOCT6100_CREATE_SERIALIZE_OBJECT f_pCreate)
+static int wct4xxp_oct612x_write_burst(struct oct612x_context *context,
+				       u32 address, const u16 *buffer,
+				       size_t count)
 {
-	return cOCT6100_ERR_OK;
+	struct t4 *wc = dev_get_drvdata(context->dev);
+	int i;
+	for (i = 0; i < count; ++i)
+		oct_set_reg(wc, address + (i << 1), buffer[i]);
+	return 0;
 }
 
-UINT32 Oct6100UserDestroySerializeObject(tPOCT6100_DESTROY_SERIALIZE_OBJECT f_pDestroy)
+static int wct4xxp_oct612x_read_burst(struct oct612x_context *context,
+				      u32 address, u16 *buffer, size_t count)
 {
-#ifdef OCTASIC_DEBUG
-	printk(KERN_DEBUG "I should never be called! (destroy serialize object)\n");
-#endif
-	return cOCT6100_ERR_OK;
+	struct t4 *wc = dev_get_drvdata(context->dev);
+	int i;
+	for (i = 0; i < count; ++i)
+		buffer[i] = oct_get_reg(wc, address + (i << 1));
+	return 0;
 }
 
-UINT32 Oct6100UserSeizeSerializeObject(tPOCT6100_SEIZE_SERIALIZE_OBJECT f_pSeize)
-{
-	/* Not needed */
-	return cOCT6100_ERR_OK;
-}
-
-UINT32 Oct6100UserReleaseSerializeObject(tPOCT6100_RELEASE_SERIALIZE_OBJECT f_pRelease)
-{
-	/* Not needed */
-	return cOCT6100_ERR_OK;
-}
-
-UINT32 Oct6100UserDriverWriteApi(tPOCT6100_WRITE_PARAMS f_pWriteParams)
-{
-	oct_set_reg(f_pWriteParams->pProcessContext, f_pWriteParams->ulWriteAddress, f_pWriteParams->usWriteData);
-	return cOCT6100_ERR_OK;
-}
-
-UINT32 Oct6100UserDriverWriteSmearApi(tPOCT6100_WRITE_SMEAR_PARAMS f_pSmearParams)
-{
-	unsigned int x;
-	for (x=0;x<f_pSmearParams->ulWriteLength;x++) {
-		oct_set_reg(f_pSmearParams->pProcessContext, f_pSmearParams->ulWriteAddress + (x << 1), f_pSmearParams->usWriteData);
-	}
-	return cOCT6100_ERR_OK;
-}
-
-UINT32 Oct6100UserDriverWriteBurstApi(tPOCT6100_WRITE_BURST_PARAMS f_pBurstParams)
-{
-	unsigned int x;
-	for (x=0;x<f_pBurstParams->ulWriteLength;x++) {
-		oct_set_reg(f_pBurstParams->pProcessContext, f_pBurstParams->ulWriteAddress + (x << 1), f_pBurstParams->pusWriteData[x]);
-	}
-	return cOCT6100_ERR_OK;
-}
-
-UINT32 Oct6100UserDriverReadApi(tPOCT6100_READ_PARAMS f_pReadParams)
-{
-	*(f_pReadParams->pusReadData) = oct_get_reg(f_pReadParams->pProcessContext, f_pReadParams->ulReadAddress);
-	return cOCT6100_ERR_OK;
-}
-
-UINT32 Oct6100UserDriverReadBurstApi(tPOCT6100_READ_BURST_PARAMS f_pBurstParams)
-{
-	unsigned int x;
-	for (x=0;x<f_pBurstParams->ulReadLength;x++) {
-		f_pBurstParams->pusReadData[x] = oct_get_reg(f_pBurstParams->pProcessContext, f_pBurstParams->ulReadAddress + (x << 1));
-	}
-	return cOCT6100_ERR_OK;
-}
+static const struct oct612x_ops wct4xxp_oct612x_ops = {
+	.write = wct4xxp_oct612x_write,
+	.read = wct4xxp_oct612x_read,
+	.write_smear = wct4xxp_oct612x_write_smear,
+	.write_burst = wct4xxp_oct612x_write_burst,
+	.read_burst = wct4xxp_oct612x_read_burst,
+};
 
 #define SOUT_G168_1100GB_ON 0x40000004
 #define SOUT_DTMF_1 0x40000011
@@ -168,6 +136,7 @@ UINT32 Oct6100UserDriverReadBurstApi(tPOCT6100_READ_BURST_PARAMS f_pBurstParams)
 
 struct vpm450m {
 	tPOCT6100_INSTANCE_API pApiInstance;
+	struct oct612x_context context;
 	UINT32 aulEchoChanHndl[256];
 	int chanflags[256];
 	int ecmode[256];
@@ -177,6 +146,7 @@ struct vpm450m {
 #define FLAG_DTMF	 (1 << 0)
 #define FLAG_MUTE	 (1 << 1)
 #define FLAG_ECHO	 (1 << 2)
+#define FLAG_ALAW	 (1 << 3)
 
 static unsigned int tones[] = {
 	SOUT_DTMF_1,
@@ -216,6 +186,52 @@ static unsigned int tones[] = {
 	ROUT_G168_1100GB_ON,
 };
 
+void vpm450m_set_alaw_companding(struct vpm450m *vpm450m, int channel,
+					bool alaw)
+{
+	tOCT6100_CHANNEL_MODIFY *modify;
+	UINT32 ulResult;
+	UINT32		law_to_use = (alaw) ? cOCT6100_PCM_A_LAW :
+					      cOCT6100_PCM_U_LAW;
+
+	if (channel >= ARRAY_SIZE(vpm450m->chanflags)) {
+		pr_err("Channel out of bounds in %s\n", __func__);
+		return;
+	}
+	/* If we're already in this companding mode, no need to do anything. */
+	if (alaw == ((vpm450m->chanflags[channel] & FLAG_ALAW) > 0))
+		return;
+
+	modify = kzalloc(sizeof(tOCT6100_CHANNEL_MODIFY), GFP_ATOMIC);
+	if (!modify) {
+		pr_notice("Unable to allocate memory for setec!\n");
+		return;
+	}
+
+	Oct6100ChannelModifyDef(modify);
+	modify->ulChannelHndl =		      vpm450m->aulEchoChanHndl[channel];
+	modify->fTdmConfigModified =		TRUE;
+	modify->TdmConfig.ulSinPcmLaw =		law_to_use;
+	modify->TdmConfig.ulRinPcmLaw =		law_to_use;
+	modify->TdmConfig.ulSoutPcmLaw =	law_to_use;
+	modify->TdmConfig.ulRoutPcmLaw =	law_to_use;
+	ulResult = Oct6100ChannelModify(vpm450m->pApiInstance, modify);
+	if (ulResult != GENERIC_OK) {
+		pr_notice("Failed to apply echo can changes on channel %d %d %08x!\n",
+			  vpm450m->aulEchoChanHndl[channel], channel, ulResult);
+	} else {
+		if (debug) {
+			pr_info("Changed companding on channel %d to %s.\n",
+				channel, (alaw) ? "alaw" : "ulaw");
+		}
+		if (alaw)
+			vpm450m->chanflags[channel] |= FLAG_ALAW;
+		else
+			vpm450m->chanflags[channel] &= ~(FLAG_ALAW);
+	}
+	kfree(modify);
+}
+
 static void vpm450m_setecmode(struct vpm450m *vpm450m, int channel, int mode)
 {
 	tOCT6100_CHANNEL_MODIFY *modify;
@@ -248,6 +264,11 @@ void vpm450m_setdtmf(struct vpm450m *vpm450m, int channel, int detect, int mute)
 	tOCT6100_CHANNEL_MODIFY *modify;
 	UINT32 ulResult;
 
+	if (channel >= ARRAY_SIZE(vpm450m->chanflags)) {
+		pr_err("Channel out of bounds in %s\n", __func__);
+		return;
+	}
+
 	modify = kmalloc(sizeof(tOCT6100_CHANNEL_MODIFY), GFP_KERNEL);
 	if (!modify) {
 		printk(KERN_NOTICE "wct4xxp: Unable to allocate memory for setdtmf!\n");
@@ -286,6 +307,11 @@ void vpm450m_setdtmf(struct vpm450m *vpm450m, int channel, int detect, int mute)
 
 void vpm450m_setec(struct vpm450m *vpm450m, int channel, int eclen)
 {
+	if (channel >= ARRAY_SIZE(vpm450m->chanflags)) {
+		pr_err("Channel out of bounds in %s\n", __func__);
+		return;
+	}
+
 	if (eclen) {
 		vpm450m->chanflags[channel] |= FLAG_ECHO;
 		vpm450m_setecmode(vpm450m, channel, cOCT6100_ECHO_OP_MODE_HT_RESET);
@@ -391,14 +417,18 @@ int vpm450m_getdtmf(struct vpm450m *vpm450m, int *channel, int *tone, int *start
 	return 0;
 }
 
-unsigned int get_vpm450m_capacity(void *wc)
+unsigned int get_vpm450m_capacity(struct device *device)
 {
+	struct oct612x_context context;
 	UINT32 ulResult;
 
 	tOCT6100_API_GET_CAPACITY_PINS CapacityPins;
 
+	context.dev = device;
+	context.ops = &wct4xxp_oct612x_ops;
+
 	Oct6100ApiGetCapacityPinsDef(&CapacityPins);
-	CapacityPins.pProcessContext = wc;
+	CapacityPins.pProcessContext = &context;
 	CapacityPins.ulMemoryType = cOCT6100_MEM_TYPE_DDR;
 	CapacityPins.fEnableMemClkOut = TRUE;
 	CapacityPins.ulMemClkFreq = cOCT6100_MCLK_FREQ_133_MHZ;
@@ -412,7 +442,8 @@ unsigned int get_vpm450m_capacity(void *wc)
 	return CapacityPins.ulCapacityValue;
 }
 
-struct vpm450m *init_vpm450m(void *wc, int *isalaw, int numspans, const struct firmware *firmware)
+struct vpm450m *init_vpm450m(struct device *device, int *isalaw,
+			     int numspans, const struct firmware *firmware)
 {
 	tOCT6100_CHIP_OPEN *ChipOpen;
 	tOCT6100_GET_INSTANCE_SIZE InstanceSize;
@@ -427,6 +458,8 @@ struct vpm450m *init_vpm450m(void *wc, int *isalaw, int numspans, const struct f
 		return NULL;
 
 	memset(vpm450m, 0, sizeof(struct vpm450m));
+	vpm450m->context.dev = device;
+	vpm450m->context.ops = &wct4xxp_oct612x_ops;
 
 	if (!(ChipOpen = kmalloc(sizeof(tOCT6100_CHIP_OPEN), GFP_KERNEL))) {
 		kfree(vpm450m);
@@ -455,7 +488,7 @@ struct vpm450m *init_vpm450m(void *wc, int *isalaw, int numspans, const struct f
 	ChipOpen->ulUpclkFreq = cOCT6100_UPCLK_FREQ_33_33_MHZ;
 	Oct6100GetInstanceSizeDef(&InstanceSize);
 
-	ChipOpen->pProcessContext = wc;
+	ChipOpen->pProcessContext = &vpm450m->context;
 
 	ChipOpen->pbyImageFile = firmware->data;
 	ChipOpen->ulImageSize = firmware->size;
@@ -524,10 +557,13 @@ struct vpm450m *init_vpm450m(void *wc, int *isalaw, int numspans, const struct f
 		 	*  therefore, the lower 2 bits tell us which span this 
 			*  timeslot/channel
 		 	*/
-			if (isalaw[x & mask])
+			if (isalaw[x & mask]) {
 				law = cOCT6100_PCM_A_LAW;
-			else
+				vpm450m->chanflags[x] |= FLAG_ALAW;
+			} else {
 				law = cOCT6100_PCM_U_LAW;
+				vpm450m->chanflags[x] &= ~(FLAG_ALAW);
+			}
 			Oct6100ChannelOpenDef(ChannelOpen);
 			ChannelOpen->pulChannelHndl = &vpm450m->aulEchoChanHndl[x];
 			ChannelOpen->ulUserChanId = x;

drivers/dahdi/wct4xxp/vpm450m.h

@@ -25,6 +25,7 @@
 
 #include <linux/firmware.h>
 
+struct t4;
 struct vpm450m;
 
 /* From driver */
@@ -32,12 +33,17 @@ unsigned int oct_get_reg(void *data, unsigned int reg);
 void oct_set_reg(void *data, unsigned int reg, unsigned int val);
 
 /* From vpm450m */
-struct vpm450m *init_vpm450m(void *wc, int *isalaw, int numspans, const struct firmware *firmware);
-unsigned int get_vpm450m_capacity(void *wc);
+struct vpm450m *init_vpm450m(struct device *device, int *isalaw,
+			     int numspans, const struct firmware *firmware);
+unsigned int get_vpm450m_capacity(struct device *device);
 void vpm450m_setec(struct vpm450m *instance, int channel, int eclen);
 void vpm450m_setdtmf(struct vpm450m *instance, int channel, int dtmfdetect, int dtmfmute);
 int vpm450m_checkirq(struct vpm450m *vpm450m);
 int vpm450m_getdtmf(struct vpm450m *vpm450m, int *channel, int *tone, int *start);
 void release_vpm450m(struct vpm450m *instance);
+void vpm450m_set_alaw_companding(struct vpm450m *vpm450m,
+				 int channel, bool alaw);
+
+extern int debug;
 
 #endif

drivers/dahdi/wctc4xxp/base.c

@@ -866,6 +866,7 @@ wctc4xxp_initialize_descriptor_ring(struct pci_dev *pdev,
 	memset(dr->desc, 0, (sizeof(*d) + dr->padding) * DRING_SIZE);
 	for (i = 0; i < DRING_SIZE; ++i) {
 		d = wctc4xxp_descriptor(dr, i);
+		memset(d, 0, sizeof(*d));
 		d->des1 = cpu_to_le32(des1);
 	}
 

drivers/dahdi/wctdm24xxp/base.c

@@ -1961,19 +1961,26 @@ wctdm_check_battery_lost(struct wctdm *wc, struct wctdm_module *const mod)
 	   battery present or unknown, debounce timer (going to battery lost)
 	*/
 	switch (fxo->battery_state) {
+	case BATTERY_DEBOUNCING_PRESENT_ALARM:
+		fxo->battery_state = BATTERY_DEBOUNCING_LOST_FROM_PRESENT_ALARM;
+		fxo->battdebounce_timer = wc->framecount + battdebounce;
+		break;
 	case BATTERY_DEBOUNCING_PRESENT:
-		/* we were going to BATTERY_PRESENT, but
-		 * battery was lost again. */
 		fxo->battery_state = BATTERY_LOST;
 		break;
+	case BATTERY_DEBOUNCING_PRESENT_FROM_LOST_ALARM:
+		fxo->battery_state = BATTERY_DEBOUNCING_LOST_ALARM;
+		fxo->battdebounce_timer = wc->framecount +
+						battalarm - battdebounce;
+		break;
 	case BATTERY_UNKNOWN:
 		mod_hooksig(wc, mod, DAHDI_RXSIG_ONHOOK);
-	case BATTERY_DEBOUNCING_PRESENT_ALARM: /* intentional drop through */
 	case BATTERY_PRESENT:
 		fxo->battery_state = BATTERY_DEBOUNCING_LOST;
 		fxo->battdebounce_timer = wc->framecount + battdebounce;
 		break;
-	case BATTERY_DEBOUNCING_LOST:
+	case BATTERY_DEBOUNCING_LOST_FROM_PRESENT_ALARM:
+	case BATTERY_DEBOUNCING_LOST: /* Intentional drop through */
 		if (time_after(wc->framecount, fxo->battdebounce_timer)) {
 			if (debug) {
 				dev_info(&wc->vb.pdev->dev,
@@ -2022,8 +2029,9 @@ wctdm_check_battery_present(struct wctdm *wc, struct wctdm_module *const mod)
 	struct fxo *const fxo = &mod->mod.fxo;
 
 	switch (fxo->battery_state) {
-	case BATTERY_DEBOUNCING_PRESENT:
-		if (time_after(jiffies, fxo->battdebounce_timer)) {
+	case BATTERY_DEBOUNCING_PRESENT_FROM_LOST_ALARM:
+	case BATTERY_DEBOUNCING_PRESENT: /* intentional drop through */
+		if (time_after(wc->framecount, fxo->battdebounce_timer)) {
 			if (debug) {
 				dev_info(&wc->vb.pdev->dev,
 					 "BATTERY on %d/%d (%s)!\n",
@@ -2048,12 +2056,12 @@ wctdm_check_battery_present(struct wctdm *wc, struct wctdm_module *const mod)
 			 * of its time period has already passed while
 			 * debouncing occurred */
 			fxo->battery_state = BATTERY_DEBOUNCING_PRESENT_ALARM;
-			fxo->battdebounce_timer = jiffies +
-				msecs_to_jiffies(battalarm - battdebounce);
+			fxo->battdebounce_timer = wc->framecount +
+						   battalarm - battdebounce;
 		}
 		break;
 	case BATTERY_DEBOUNCING_PRESENT_ALARM:
-		if (time_after(jiffies, fxo->battdebounce_timer)) {
+		if (time_after(wc->framecount, fxo->battdebounce_timer)) {
 			fxo->battery_state = BATTERY_PRESENT;
 			dahdi_alarm_channel(get_dahdi_chan(wc, mod),
 					    DAHDI_ALARM_NONE);
@@ -2061,18 +2069,23 @@ wctdm_check_battery_present(struct wctdm *wc, struct wctdm_module *const mod)
 		break;
 	case BATTERY_PRESENT:
 		break;
+	case BATTERY_DEBOUNCING_LOST_ALARM:
+		fxo->battery_state = BATTERY_DEBOUNCING_PRESENT_FROM_LOST_ALARM;
+		fxo->battdebounce_timer = wc->framecount + battdebounce;
+		break;
+	case BATTERY_DEBOUNCING_LOST_FROM_PRESENT_ALARM:
+		fxo->battery_state = BATTERY_DEBOUNCING_PRESENT_ALARM;
+		fxo->battdebounce_timer = wc->framecount +
+						battalarm - battdebounce;
+		break;
 	case BATTERY_DEBOUNCING_LOST:
-		/* we were going to BATTERY_LOST, but battery appeared again,
-		 * so clear the debounce timer */
 		fxo->battery_state = BATTERY_PRESENT;
 		break;
 	case BATTERY_UNKNOWN:
 		mod_hooksig(wc, mod, DAHDI_RXSIG_OFFHOOK);
 	case BATTERY_LOST: /* intentional drop through */
-	case BATTERY_DEBOUNCING_LOST_ALARM:
 		fxo->battery_state = BATTERY_DEBOUNCING_PRESENT;
-		fxo->battdebounce_timer = jiffies +
-						msecs_to_jiffies(battdebounce);
+		fxo->battdebounce_timer = wc->framecount + battdebounce;
 		break;
 	}
 }
@@ -4371,32 +4384,6 @@ wctdm_chanconfig(struct file *file, struct dahdi_chan *chan, int sigtype)
 	return wctdm_wait_for_ready(wc);
 }
 
-/*
- * wctdm24xxp_assigned - Called when span is assigned.
- * @span:	The span that is now assigned.
- *
- * This function is called by the core of DAHDI after the span number and
- * channel numbers have been assigned.
- *
- */
-static void wctdm24xxp_assigned(struct dahdi_span *span)
-{
-	struct dahdi_span *s;
-	struct dahdi_device *ddev = span->parent;
-	struct wctdm *wc = NULL;
-
-	list_for_each_entry(s, &ddev->spans, device_node) {
-		wc = (container_of(s, struct wctdm_span, span))->wc;
-		if (!test_bit(DAHDI_FLAGBIT_REGISTERED, &s->flags))
-			return;
-	}
-
-	if (wc) {
-		WARN_ON(0 == wc->not_ready);
-		--wc->not_ready;
-	}
-}
-
 static const struct dahdi_span_ops wctdm24xxp_analog_span_ops = {
 	.owner = THIS_MODULE,
 	.hooksig = wctdm_hooksig,
@@ -4406,7 +4393,6 @@ static const struct dahdi_span_ops wctdm24xxp_analog_span_ops = {
 	.watchdog = wctdm_watchdog,
 	.chanconfig = wctdm_chanconfig,
 	.dacs = wctdm_dacs,
-	.assigned = wctdm24xxp_assigned,
 #ifdef VPM_SUPPORT
 	.enable_hw_preechocan = wctdm_enable_hw_preechocan,
 	.disable_hw_preechocan = wctdm_disable_hw_preechocan,
@@ -4425,7 +4411,6 @@ static const struct dahdi_span_ops wctdm24xxp_digital_span_ops = {
 	.spanconfig = b400m_spanconfig,
 	.chanconfig = b400m_chanconfig,
 	.dacs = wctdm_dacs,
-	.assigned = wctdm24xxp_assigned,
 #ifdef VPM_SUPPORT
 	.enable_hw_preechocan = wctdm_enable_hw_preechocan,
 	.disable_hw_preechocan = wctdm_disable_hw_preechocan,
@@ -5938,6 +5923,9 @@ __wctdm_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 		return -1;
 	}
 
+	WARN_ON(wc->not_ready <= 0);
+	--wc->not_ready;
+
 	dev_info(&wc->vb.pdev->dev,
 		 "Found a %s: %s (%d BRI spans, %d analog %s)\n",
 		 (is_hx8(wc)) ? "Hybrid card" : "Wildcard TDM",

drivers/dahdi/wctdm24xxp/wctdm24xxp.h

@@ -106,9 +106,11 @@ struct calregs {
 enum battery_state {
 	BATTERY_UNKNOWN = 0,
 	BATTERY_DEBOUNCING_PRESENT,
+	BATTERY_DEBOUNCING_PRESENT_FROM_LOST_ALARM,
 	BATTERY_DEBOUNCING_PRESENT_ALARM,
 	BATTERY_PRESENT,
 	BATTERY_DEBOUNCING_LOST,
+	BATTERY_DEBOUNCING_LOST_FROM_PRESENT_ALARM,
 	BATTERY_DEBOUNCING_LOST_ALARM,
 	BATTERY_LOST,
 };

drivers/dahdi/wcte12xp/base.c

@@ -658,6 +658,17 @@ static int __t1_getresult(struct t1 *wc, struct command *cmd)
 
 	might_sleep();
 
+	if (test_bit(IOERROR, &wc->bit_flags)) {
+		spin_lock_irqsave(&wc->reglock, flags);
+		list_del_init(&cmd->node);
+		spin_unlock_irqrestore(&wc->reglock, flags);
+		if (printk_ratelimit()) {
+			dev_warn(&wc->vb.pdev->dev,
+				 "Timeout in %s\n", __func__);
+		}
+		return -EIO;
+	}
+
 	ret = wait_for_completion_interruptible_timeout(&cmd->complete, HZ*10);
 	if (unlikely(!ret)) {
 		spin_lock_irqsave(&wc->reglock, flags);
@@ -666,13 +677,13 @@ static int __t1_getresult(struct t1 *wc, struct command *cmd)
 			 * can go ahead and free it right away. */
 			list_del_init(&cmd->node);
 			spin_unlock_irqrestore(&wc->reglock, flags);
-			free_cmd(wc, cmd);
 			if (-ERESTARTSYS != ret) {
 				if (printk_ratelimit()) {
 					dev_warn(&wc->vb.pdev->dev,
 						 "Timeout in %s\n", __func__);
 				}
 				ret = -EIO;
+				set_bit(IOERROR, &wc->bit_flags);
 			}
 			return ret;
 		} else {
@@ -683,7 +694,6 @@ static int __t1_getresult(struct t1 *wc, struct command *cmd)
 			ret = wait_for_completion_timeout(&cmd->complete, HZ*2);
 			WARN_ON(!ret);
 			ret = cmd->data;
-			free_cmd(wc, cmd);
 			return ret;
 		}
 	}
@@ -841,6 +851,75 @@ static void free_wc(struct t1 *wc)
 	kfree(wc);
 }
 
+/**
+ * t1_reset_registers - Put register back to their default values 
+ *
+ * Since the card does not have an ability to reset just the framer
+ * specifically, we need to write all the default values to the framer.
+ *
+ */
+static void t1_reset_registers(struct t1 *wc)
+{
+	int i;
+	struct t1_reg {
+		u8 address;
+		u8 value;
+	} __attribute__((packed));
+	struct t1_reg *reg;
+	static struct t1_reg DEFAULT_REGS[] = {
+		{0x00, 0x7d}, {0x01, 0x7d}, {0x02, 0x00}, {0x03, 0x00},
+		{0x04, 0xfd}, {0x05, 0xff}, {0x06, 0xff}, {0x07, 0xff},
+		{0x08, 0x05}, {0x09, 0x00}, {0x0a, 0x00}, {0x0b, 0x00},
+		{0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
+		{0x10, 0x00}, {0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00},
+		{0x14, 0xff}, {0x15, 0xff}, {0x16, 0xff}, {0x17, 0xff},
+		{0x18, 0xff}, {0x19, 0xff}, {0x1a, 0x00}, {0x1b, 0x00},
+		{0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
+		{0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x04},
+		{0x24, 0x00}, {0x25, 0x05}, {0x26, 0x7b}, {0x27, 0x03},
+		{0x28, 0x40}, {0x29, 0x00}, {0x2a, 0x00}, {0x2b, 0x00},
+		{0x2c, 0x00}, {0x2d, 0x00}, {0x2e, 0x00}, {0x2f, 0x00},
+		{0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
+		{0x34, 0x00}, {0x35, 0x00}, {0x36, 0x00}, {0x37, 0x80},
+		{0x38, 0x00}, {0x39, 0x00}, {0x3a, 0x20}, {0x3b, 0x00},
+		{0x3c, 0x00}, {0x3d, 0x00}, {0x3e, 0x0a}, {0x3f, 0x00},
+		{0x40, 0x04}, {0x41, 0x00}, {0x42, 0x00}, {0x43, 0x00},
+		{0x44, 0x30}, {0x45, 0x00}, {0x46, 0xc0}, {0x47, 0xff},
+		{0x48, 0x00}, {0x49, 0x1c}, {0x4a, 0x05}, {0x4b, 0x03},
+		{0x4c, 0xa3}, {0x4d, 0x28}, {0x4e, 0x00}, {0x4f, 0xc0},
+		{0x50, 0x00}, {0x51, 0x00}, {0x52, 0x00}, {0x53, 0x00},
+		{0x54, 0x00}, {0x55, 0x00}, {0x56, 0x00}, {0x57, 0x00},
+		{0x58, 0x00}, {0x59, 0x00}, {0x5a, 0x00}, {0x5b, 0x00},
+		{0x5c, 0x00}, {0x5d, 0x00}, {0x5e, 0x00}, {0x5f, 0x00},
+		{0x60, 0x00}, {0x61, 0x20}, {0x62, 0x00}, {0x63, 0x00},
+		{0x64, 0x5a}, {0x65, 0x02}, {0x66, 0x00}, {0x67, 0x00},
+		{0x68, 0x10}, {0x69, 0x09}, {0x6a, 0x00}, {0x6b, 0x03},
+		{0x6c, 0x00}, {0x6d, 0xc0}, {0x6e, 0x40}, {0x6f, 0x00},
+		{0x70, 0x00}, {0x71, 0x00}, {0x72, 0x00}, {0x73, 0x00},
+		{0x74, 0x00}, {0x75, 0x00}, {0x76, 0x00}, {0x77, 0x00},
+		{0x78, 0x00}, {0x79, 0x00}, {0x7a, 0x00}, {0x7b, 0x00},
+		{0x7c, 0x00}, {0x7d, 0x00}, {0x7e, 0x00}, {0x7f, 0x00},
+		{0x80, 0x00}, {0x81, 0x22}, {0x82, 0x65}, {0x83, 0x35},
+		{0x84, 0x31}, {0x85, 0x60}, {0x86, 0x03}, {0x87, 0x00},
+		{0x88, 0x00}, {0x89, 0x00}, {0x8a, 0x00}, {0x8b, 0x00},
+		{0x8c, 0x00}, {0x8d, 0x00}, {0x8e, 0x00}, {0x8f, 0x00},
+		{0x90, 0x00}, {0x91, 0x00}, {0x92, 0x00}, {0x93, 0x18},
+		{0x94, 0xfb}, {0x95, 0x0b}, {0x96, 0x00}, {0x97, 0x0b},
+		{0x98, 0xdb}, {0x99, 0xdf}, {0x9a, 0x48}, {0x9b, 0x00},
+		{0x9c, 0x3f}, {0x9d, 0x3f}, {0x9e, 0x77}, {0x9f, 0x77},
+		{0xa0, 0x00}, {0xa1, 0xff}, {0xa2, 0xff}, {0xa3, 0xff},
+		{0xa4, 0x00}, {0xa5, 0x00}, {0xa6, 0x00}, {0xa7, 0x00},
+		{0xa8, 0x00}
+	};
+
+	for (i = 0; i < ARRAY_SIZE(DEFAULT_REGS); ++i) {
+		reg = &DEFAULT_REGS[i];
+		t1_setreg(wc, reg->address, reg->value);
+	}
+	/* Flush previous writes. */
+	t1_getreg(wc, 0x1d);
+}
+
 static void t4_serial_setup(struct t1 *wc)
 {
 	t1_setreg(wc, 0x85, 0xe0);	/* GPC1: Multiplex mode enabled, FSC is output, active low, RCLK from channel 0 */
@@ -2029,10 +2108,13 @@ static int t1xxp_set_linemode(struct dahdi_span *span, enum spantypes linemode)
 	/* Stop the processing of the channels since we're going to change
 	 * them. */
 	clear_bit(INITIALIZED, &wc->bit_flags);
+	synchronize_irq(wc->vb.pdev->irq);
 	smp_mb__after_clear_bit();
 	del_timer_sync(&wc->timer);
 	flush_workqueue(wc->wq);
 
+	t1_reset_registers(wc);
+
 	switch (linemode) {
 	case SPANTYPE_DIGITAL_T1:
 		dev_info(&wc->vb.pdev->dev,
@@ -2206,27 +2288,32 @@ static void t1_check_alarms(struct t1 *wc)
 		/* Detect loopup code if we're not sending one */
 		if ((!wc->span.mainttimer) && (d & 0x08)) {
 			/* Loop-up code detected */
-			if ((wc->span.maintstat != DAHDI_MAINT_REMOTELOOP)) {
+			if ((++wc->loopupcnt > 80) &&
+			    (wc->span.maintstat != DAHDI_MAINT_REMOTELOOP)) {
 				t1_notice(wc, "Loopup detected,"\
 					" enabling remote loop\n");
 				t1_setreg(wc, 0x36, 0x08);	/* LIM0: Disable any local loop */
 				t1_setreg(wc, 0x37, 0xf6);	/* LIM1: Enable remote loop */
 				wc->span.maintstat = DAHDI_MAINT_REMOTELOOP;
 			}
-		} else
+		} else {
 			wc->loopupcnt = 0;
+		}
+
 		/* Same for loopdown code */
 		if ((!wc->span.mainttimer) && (d & 0x10)) {
 			/* Loop-down code detected */
-			if ((wc->span.maintstat == DAHDI_MAINT_REMOTELOOP)) {
+			if ((++wc->loopdowncnt > 80) &&
+			    (wc->span.maintstat == DAHDI_MAINT_REMOTELOOP)) {
 				t1_notice(wc, "Loopdown detected,"\
 					" disabling remote loop\n");
 				t1_setreg(wc, 0x36, 0x08);	/* LIM0: Disable any local loop */
 				t1_setreg(wc, 0x37, 0xf0);	/* LIM1: Disable remote loop */
 				wc->span.maintstat = DAHDI_MAINT_NONE;
 			}
-		} else
+		} else {
 			wc->loopdowncnt = 0;
+		}
 	}
 
 	if (wc->span.lineconfig & DAHDI_CONFIG_NOTOPEN) {

drivers/dahdi/wcte12xp/wcte12xp.h

@@ -114,6 +114,7 @@ struct t1 {
 #define INITIALIZED 1
 #define SHUTDOWN    2
 #define READY	    3
+#define IOERROR	    4
 	unsigned long bit_flags;
 	unsigned long alarmtimer;
 	unsigned char ledstate;

drivers/dahdi/wcxb.c

@@ -0,0 +1,951 @@
+/*
+ * wcxb SPI library
+ *
+ * Copyright (C) 2013 Digium, Inc.
+ *
+ * All rights reserved.
+ *
+ */
+
+/*
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2 as published by the
+ * Free Software Foundation. See the LICENSE file included with
+ * this program for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/errno.h>
+#include <linux/pci.h>
+#include <linux/interrupt.h>
+#include <linux/firmware.h>
+#include <linux/crc32.h>
+#include <linux/delay.h>
+#include <linux/version.h>
+
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 26)
+#define HAVE_RATELIMIT
+#include <linux/ratelimit.h>
+#endif
+
+#include <dahdi/kernel.h>
+
+#include <stdbool.h>
+
+#include "wcxb.h"
+#include "wcxb_spi.h"
+#include "wcxb_flash.h"
+
+/* The definition for Surprise Down was added in Linux 3.6 in (a0dee2e PCI: misc
+ * pci_reg additions). It may be backported though so we won't check for the
+ * version. */
+#ifndef PCI_ERR_UNC_SURPDN
+#define PCI_ERR_UNC_SURPDN 0x20
+#endif
+
+/* FPGA Status definitions */
+#define OCT_CPU_RESET		(1 << 0)
+#define OCT_CPU_DRAM_CKE	(1 << 1)
+#define STATUS_LED_GREEN	(1 << 9)
+#define STATUS_LED_RED		(1 << 10)
+#define FALC_CPU_RESET		(1 << 11)
+
+/* Descriptor ring definitions */
+#define DRING_SIZE		(1 << 7) /* Must be in multiples of 2 */
+#define DRING_SIZE_MASK		(DRING_SIZE-1)
+#define DESC_EOR		(1 << 0)
+#define DESC_INT		(1 << 1)
+#define DESC_OWN		(1 << 31)
+#define DESC_DEFAULT_STATUS	0xdeadbeef
+#define DMA_CHAN_SIZE		128
+
+/* Echocan definitions */
+#define OCT_OFFSET		(xb->membase + 0x10000)
+#define OCT_CONTROL_REG		(OCT_OFFSET + 0)
+#define OCT_DATA_REG		(OCT_OFFSET + 0x4)
+#define OCT_ADDRESS_HIGH_REG	(OCT_OFFSET + 0x8)
+#define OCT_ADDRESS_LOW_REG	(OCT_OFFSET + 0xa)
+#define OCT_DIRECT_WRITE_MASK	0x3001
+#define OCT_INDIRECT_READ_MASK	0x0101
+#define OCT_INDIRECT_WRITE_MASK	0x3101
+
+
+/* DMA definitions */
+#define TDM_DRING_ADDR		0x2000
+#define TDM_CONTROL		(TDM_DRING_ADDR + 0x4)
+#define ENABLE_ECHOCAN_TDM	(1 << 0)
+#define TDM_RECOVER_CLOCK	(1 << 1)
+#define ENABLE_DMA		(1 << 2)
+#define	DMA_RUNNING		(1 << 3)
+#define DMA_LOOPBACK		(1 << 4)
+#define AUTHENTICATED		(1 << 5)
+#define TDM_VERSION		(TDM_DRING_ADDR + 0x24)
+
+/* Interrupt definitions */
+#define INTERRUPT_CONTROL	0x300
+#define ISR			(INTERRUPT_CONTROL + 0x0)
+#define IPR			(INTERRUPT_CONTROL + 0x4)
+#define IER			(INTERRUPT_CONTROL + 0x8)
+#define IAR			(INTERRUPT_CONTROL + 0xc)
+#define SIE			(INTERRUPT_CONTROL + 0x10)
+#define CIE			(INTERRUPT_CONTROL + 0x14)
+#define IVR			(INTERRUPT_CONTROL + 0x18)
+#define MER			(INTERRUPT_CONTROL + 0x1c)
+#define MER_ME			(1<<0)
+#define MER_HIE			(1<<1)
+#define DESC_UNDERRUN		(1<<0)
+#define DESC_COMPLETE		(1<<1)
+#define OCT_INT			(1<<2)
+#define FALC_INT		(1<<3)
+#define SPI_INT			(1<<4)
+
+#define FLASH_SPI_BASE 0x200
+
+struct wcxb_hw_desc {
+	volatile __be32 status;
+	__be32 tx_buf;
+	__be32 rx_buf;
+	volatile __be32 control;
+} __packed;
+
+struct wcxb_meta_desc {
+	void *tx_buf_virt;
+	void *rx_buf_virt;
+};
+
+static inline bool wcxb_is_pcie(const struct wcxb *xb)
+{
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 33)
+	return pci_is_pcie(xb->pdev);
+#else
+#ifndef WCXB_PCI_DEV_DOES_NOT_HAVE_IS_PCIE
+	return (xb->pdev->is_pcie > 0);
+#else
+	return (xb->flags.is_pcie > 0);
+#endif
+#endif
+}
+
+static const unsigned int CLK_SRC_MASK = ((1 << 13) | (1 << 12) | (1 << 1));
+
+enum wcxb_clock_sources wcxb_get_clksrc(struct wcxb *xb)
+{
+	static const u32 SELF = 0x0;
+	static const u32 RECOVER = (1 << 1);
+	static const u32 SLAVE  = (1 << 12) | (1 << 1);
+	unsigned long flags;
+	u32 reg;
+
+	spin_lock_irqsave(&xb->lock, flags);
+	reg = ioread32be(xb->membase + TDM_CONTROL) & CLK_SRC_MASK;
+	spin_unlock_irqrestore(&xb->lock, flags);
+
+	if (SELF == reg)
+		return WCXB_CLOCK_SELF;
+	else if (RECOVER == reg)
+		return WCXB_CLOCK_RECOVER;
+	else if (SLAVE == reg)
+		return WCXB_CLOCK_SLAVE;
+	else
+		WARN_ON(1);
+	return WCXB_CLOCK_SELF;
+}
+
+void wcxb_set_clksrc(struct wcxb *xb, enum wcxb_clock_sources clksrc)
+{
+	unsigned long flags;
+	u32 clkbits = 0;
+
+	switch (clksrc) {
+	case WCXB_CLOCK_RECOVER:
+		if (xb->flags.drive_timing_cable)
+			clkbits = (1<<13) | (1 << 1);
+		else
+			clkbits = (1 << 1);
+		break;
+	case WCXB_CLOCK_SELF:
+		if (xb->flags.drive_timing_cable)
+			clkbits = (1<<13);
+		else
+			clkbits = 0;
+		break;
+	case WCXB_CLOCK_SLAVE:
+		/* When we're slave, do not ever drive the timing cable. */
+		clkbits = (1<<12) | (1 << 1);
+		break;
+	};
+
+	/* set new clock select */
+	spin_lock_irqsave(&xb->lock, flags);
+	if (!wcxb_is_stopped(xb)) {
+		dev_err(&xb->pdev->dev, "ERROR: Cannot set clock source while DMA engine is running.\n");
+	} else {
+		u32 reg;
+		reg = ioread32be(xb->membase + TDM_CONTROL);
+		reg &= ~CLK_SRC_MASK;
+		reg |= (clkbits & CLK_SRC_MASK);
+		iowrite32be(reg, xb->membase + TDM_CONTROL);
+	}
+	spin_unlock_irqrestore(&xb->lock, flags);
+}
+
+void wcxb_enable_echocan(struct wcxb *xb)
+{
+	u32 reg;
+	unsigned long flags;
+	spin_lock_irqsave(&xb->lock, flags);
+	reg = ioread32be(xb->membase + TDM_CONTROL);
+	reg |= ENABLE_ECHOCAN_TDM;
+	iowrite32be(reg, xb->membase + TDM_CONTROL);
+	spin_unlock_irqrestore(&xb->lock, flags);
+}
+
+void wcxb_disable_echocan(struct wcxb *xb)
+{
+	u32 reg;
+	unsigned long flags;
+	spin_lock_irqsave(&xb->lock, flags);
+	reg = ioread32be(xb->membase + TDM_CONTROL);
+	reg &= ~ENABLE_ECHOCAN_TDM;
+	iowrite32be(reg, xb->membase + TDM_CONTROL);
+	spin_unlock_irqrestore(&xb->lock, flags);
+}
+
+void wcxb_reset_echocan(struct wcxb *xb)
+{
+	unsigned long flags;
+	int reg;
+	spin_lock_irqsave(&xb->lock, flags);
+	reg = ioread32be(xb->membase);
+	iowrite32be((reg & ~OCT_CPU_RESET), xb->membase);
+	spin_unlock_irqrestore(&xb->lock, flags);
+
+	msleep_interruptible(1);
+
+	spin_lock_irqsave(&xb->lock, flags);
+	reg = ioread32be(xb->membase);
+	iowrite32be((reg | OCT_CPU_RESET), xb->membase);
+	spin_unlock_irqrestore(&xb->lock, flags);
+
+	dev_dbg(&xb->pdev->dev, "Reset octasic\n");
+}
+
+bool wcxb_is_echocan_present(struct wcxb *xb)
+{
+	return 0x1 == ioread16be(OCT_CONTROL_REG);
+}
+
+void wcxb_enable_echocan_dram(struct wcxb *xb)
+{
+	unsigned long flags;
+	int reg;
+	spin_lock_irqsave(&xb->lock, flags);
+	reg = ioread32be(xb->membase);
+	iowrite32be((reg | OCT_CPU_DRAM_CKE), xb->membase);
+	spin_unlock_irqrestore(&xb->lock, flags);
+}
+
+u16 wcxb_get_echocan_reg(struct wcxb *xb, u32 address)
+{
+	uint16_t highaddress = ((address >> 20) & 0xfff);
+	uint16_t lowaddress = ((address >> 4) & 0xfffff);
+	unsigned long stop = jiffies + HZ/10;
+	unsigned long flags;
+	u16 ret;
+
+	spin_lock_irqsave(&xb->lock, flags);
+	iowrite16be(highaddress, OCT_ADDRESS_HIGH_REG);
+	iowrite16be(lowaddress, OCT_ADDRESS_LOW_REG);
+
+	iowrite16be(OCT_INDIRECT_READ_MASK | ((address & 0xe) << 8),
+				OCT_CONTROL_REG);
+	do {
+		ret = ioread16be(OCT_CONTROL_REG);
+	} while ((ret & (1<<8)) && time_before(jiffies, stop));
+
+	WARN_ON_ONCE(time_after_eq(jiffies, stop));
+
+	ret = ioread16be(OCT_DATA_REG);
+	spin_unlock_irqrestore(&xb->lock, flags);
+
+	return ret;
+}
+
+void wcxb_set_echocan_reg(struct wcxb *xb, u32 address, u16 val)
+{
+	unsigned long flags;
+	uint16_t ret;
+	uint16_t highaddress = ((address >> 20) & 0xfff);
+	uint16_t lowaddress = ((address >> 4) & 0xffff);
+	unsigned long stop = jiffies + HZ/10;
+
+	spin_lock_irqsave(&xb->lock, flags);
+	iowrite16be(highaddress, OCT_ADDRESS_HIGH_REG);
+	iowrite16be(lowaddress, OCT_ADDRESS_LOW_REG);
+
+	iowrite16be(val, OCT_DATA_REG);
+	iowrite16be(OCT_INDIRECT_WRITE_MASK | ((address & 0xe) << 8),
+			OCT_CONTROL_REG);
+
+	/* No write should take longer than 100ms */
+	do {
+		ret = ioread16be(OCT_CONTROL_REG);
+	} while ((ret & (1<<8)) && time_before(jiffies, stop));
+	spin_unlock_irqrestore(&xb->lock, flags);
+
+	WARN_ON_ONCE(time_after_eq(jiffies, stop));
+}
+
+#ifdef HAVE_RATELIMIT
+static DEFINE_RATELIMIT_STATE(_underrun_rl, DEFAULT_RATELIMIT_INTERVAL,
+			      DEFAULT_RATELIMIT_BURST);
+#endif
+
+/* wcxb_reset_dring needs to be called with xb->lock held. */
+static void _wcxb_reset_dring(struct wcxb *xb)
+{
+	int x;
+	struct wcxb_meta_desc *mdesc;
+	struct wcxb_hw_desc *hdesc = NULL;
+
+	xb->dma_head = xb->dma_tail = 0;
+
+	if (unlikely(xb->latency > DRING_SIZE)) {
+#ifdef HAVE_RATELIMIT
+		if (__ratelimit(&_underrun_rl)) {
+#else
+		if (printk_ratelimit()) {
+#endif
+			dev_info(&xb->pdev->dev,
+				 "Oops! Tried to increase latency past buffer size.\n");
+		}
+		xb->latency = DRING_SIZE;
+	}
+
+	for (x = 0; x < xb->latency; x++) {
+		dma_addr_t dma_tmp;
+
+		mdesc = &xb->meta_dring[x];
+		hdesc = &xb->hw_dring[x];
+
+		hdesc->status = cpu_to_be32(DESC_DEFAULT_STATUS);
+		if (!mdesc->tx_buf_virt) {
+			mdesc->tx_buf_virt =
+				dma_pool_alloc(xb->pool, GFP_ATOMIC, &dma_tmp);
+			hdesc->tx_buf = cpu_to_be32(dma_tmp);
+			mdesc->rx_buf_virt =
+				dma_pool_alloc(xb->pool, GFP_ATOMIC, &dma_tmp);
+			hdesc->rx_buf = cpu_to_be32(dma_tmp);
+		}
+		hdesc->control = cpu_to_be32(DESC_INT|DESC_OWN);
+		BUG_ON(!mdesc->tx_buf_virt || !mdesc->rx_buf_virt);
+	}
+
+	BUG_ON(!hdesc);
+	/* Set end of ring bit in last descriptor to force hw to loop around */
+	hdesc->control |= cpu_to_be32(DESC_EOR);
+	iowrite32be(xb->hw_dring_phys, xb->membase + TDM_DRING_ADDR);
+}
+
+static void wcxb_handle_dma(struct wcxb *xb)
+{
+	struct wcxb_meta_desc *mdesc;
+
+	while (!(xb->hw_dring[xb->dma_tail].control & cpu_to_be32(DESC_OWN))) {
+		u_char *frame;
+
+		mdesc = &xb->meta_dring[xb->dma_tail];
+		frame = mdesc->rx_buf_virt;
+
+		xb->ops->handle_receive(xb, frame);
+
+		xb->dma_tail =
+			(xb->dma_tail == xb->latency-1) ? 0 : xb->dma_tail + 1;
+
+		mdesc = &xb->meta_dring[xb->dma_head];
+		frame = mdesc->tx_buf_virt;
+
+		xb->ops->handle_transmit(xb, frame);
+
+		wmb();
+		xb->hw_dring[xb->dma_head].control |= cpu_to_be32(DESC_OWN);
+		xb->dma_head =
+			(xb->dma_head == xb->latency-1) ? 0 : xb->dma_head + 1;
+	}
+}
+
+static irqreturn_t _wcxb_isr(int irq, void *dev_id)
+{
+	struct wcxb *xb = dev_id;
+	unsigned int limit = 8;
+	u32 pending;
+
+	pending = ioread32be(xb->membase + ISR);
+	if (!pending)
+		return IRQ_NONE;
+
+	do {
+		iowrite32be(pending, xb->membase + IAR);
+
+		if (pending & DESC_UNDERRUN) {
+			u32 reg;
+
+			/* bump latency */
+			spin_lock(&xb->lock);
+
+			if (!xb->flags.latency_locked) {
+				xb->latency++;
+
+#ifdef HAVE_RATELIMIT
+				if (__ratelimit(&_underrun_rl)) {
+#else
+				if (printk_ratelimit()) {
+#endif
+					dev_info(&xb->pdev->dev,
+						 "Underrun detected by hardware. Latency bumped to: %dms\n",
+						 xb->latency);
+				}
+			}
+
+			/* re-setup dma ring */
+			_wcxb_reset_dring(xb);
+
+			/* set dma enable bit */
+			reg = ioread32be(xb->membase + TDM_CONTROL);
+			reg |= ENABLE_DMA;
+			iowrite32be(reg, xb->membase + TDM_CONTROL);
+
+			spin_unlock(&xb->lock);
+		}
+
+		if (pending & DESC_COMPLETE) {
+			xb->framecount++;
+			wcxb_handle_dma(xb);
+		}
+
+		if (NULL != xb->ops->handle_interrupt)
+			xb->ops->handle_interrupt(xb, pending);
+
+		pending = ioread32be(xb->membase + ISR);
+	} while (pending && --limit);
+	return IRQ_HANDLED;
+}
+
+DAHDI_IRQ_HANDLER(wcxb_isr)
+{
+	irqreturn_t ret;
+	unsigned long flags;
+	local_irq_save(flags);
+	ret = _wcxb_isr(irq, dev_id);
+	local_irq_restore(flags);
+	return ret;
+}
+
+static int wcxb_alloc_dring(struct wcxb *xb, const char *board_name)
+{
+	xb->meta_dring =
+		kzalloc(sizeof(struct wcxb_meta_desc) * DRING_SIZE,
+		GFP_KERNEL);
+	if (!xb->meta_dring)
+		return -ENOMEM;
+
+	xb->hw_dring = dma_alloc_coherent(&xb->pdev->dev,
+			sizeof(struct wcxb_hw_desc) * DRING_SIZE,
+			&xb->hw_dring_phys,
+			GFP_KERNEL);
+	if (!xb->hw_dring) {
+		kfree(xb->meta_dring);
+		return -ENOMEM;
+	}
+
+	xb->pool = dma_pool_create(board_name, &xb->pdev->dev,
+			 PAGE_SIZE, PAGE_SIZE, 0);
+	if (!xb->pool) {
+		kfree(xb->meta_dring);
+		dma_free_coherent(&xb->pdev->dev,
+			sizeof(struct wcxb_hw_desc) * DRING_SIZE,
+			xb->hw_dring,
+			xb->hw_dring_phys);
+		return -ENOMEM;
+	}
+	return 0;
+}
+
+/**
+ * wcxb_soft_reset - Set interface registers back to known good values.
+ *
+ * This represents the normal default state after a reset of the FPGA. This
+ * function is preferred over the hard reset function.
+ *
+ */
+static void wcxb_soft_reset(struct wcxb *xb)
+{
+	/* digium_gpo */
+	iowrite32be(0x0, xb->membase);
+
+	/* xps_intc */
+	iowrite32be(0x0, xb->membase + 0x300);
+	iowrite32be(0x0, xb->membase + 0x308);
+	iowrite32be(0x0, xb->membase + 0x310);
+	iowrite32be(0x0, xb->membase + 0x31C);
+
+	/* xps_spi_config_flash */
+	iowrite32be(0xA, xb->membase + 0x200);
+
+	/* tdm engine */
+	iowrite32be(0x0, xb->membase + 0x2000);
+	iowrite32be(0x0, xb->membase + 0x2004);
+}
+
+static void _wcxb_hard_reset(struct wcxb *xb)
+{
+	struct pci_dev *const pdev = xb->pdev;
+	u32 microblaze_version;
+	unsigned long stop_time = jiffies + msecs_to_jiffies(2000);
+
+	pci_save_state(pdev);
+	iowrite32be(0xe00, xb->membase + TDM_CONTROL);
+
+	/* This sleep is to give FPGA time to bring up the PCI/PCIe interface */
+	msleep(200);
+
+	pci_restore_state(pdev);
+
+	/* Wait for the Microblaze CPU to complete it's startup */
+	do {
+		msleep(20);
+		/* Can return either 0xffff or 0 before it's fully booted */
+		microblaze_version = ioread32be(xb->membase + 0x2018) ?: 0xffff;
+	} while (time_before(jiffies, stop_time)
+			&& 0xffff == microblaze_version);
+}
+
+/*
+ * Since the FPGA hard reset drops the PCIe link we need to disable
+ * error reporting on the upsteam link. Otherwise Surprise Down errors
+ * may be reported in reponse to the link going away.
+ *
+ * NOTE: We cannot use pci_disable_pcie_error_reporting() because it will not
+ * disable error reporting if the system firmware is attached to the advanced
+ * error reporting mechanism.
+ */
+static void _wcxb_pcie_hard_reset(struct wcxb *xb)
+{
+	struct pci_dev *const parent = xb->pdev->bus->self;
+	u32 aer_mask;
+	int pos;
+
+	if (!wcxb_is_pcie(xb))
+		return;
+
+	pos = pci_find_ext_capability(parent, PCI_EXT_CAP_ID_ERR);
+	if (pos) {
+		pci_read_config_dword(parent, pos + PCI_ERR_UNCOR_MASK,
+				      &aer_mask);
+		pci_write_config_dword(parent, pos + PCI_ERR_UNCOR_MASK,
+				       aer_mask | PCI_ERR_UNC_SURPDN);
+	}
+
+	_wcxb_hard_reset(xb);
+
+	if (pos) {
+		pci_write_config_dword(parent, pos + PCI_ERR_UNCOR_MASK,
+				       aer_mask);
+
+		/* Clear the error as well from the status register. */
+		pci_write_config_dword(parent, pos + PCI_ERR_UNCOR_STATUS,
+				       PCI_ERR_UNC_SURPDN);
+	}
+
+	return;
+}
+
+/**
+ * wcxb_hard_reset - Reset FPGA and reload firmware.
+ *
+ * This may be called in the context of device probe and therefore the PCI
+ * device may be locked.
+ *
+ */
+static void wcxb_hard_reset(struct wcxb *xb)
+{
+	if (wcxb_is_pcie(xb))
+		_wcxb_pcie_hard_reset(xb);
+	else
+		_wcxb_hard_reset(xb);
+}
+
+int wcxb_init(struct wcxb *xb, const char *board_name, u32 int_mode)
+{
+	int res = 0;
+	struct pci_dev *pdev = xb->pdev;
+	u32 tdm_control;
+
+	if (pci_enable_device(pdev))
+		return -EIO;
+
+	pci_set_master(pdev);
+
+#ifdef WCXB_PCI_DEV_DOES_NOT_HAVE_IS_PCIE
+	xb->flags.is_pcie = pci_find_capability(pdev, PCI_CAP_ID_EXP) ? 1 : 0;
+#endif
+
+	WARN_ON(!pdev);
+	if (!pdev)
+		return -EINVAL;
+
+	xb->latency = WCXB_DEFAULT_LATENCY;
+	spin_lock_init(&xb->lock);
+
+	xb->membase = pci_iomap(pdev, 0, 0);
+	if (pci_request_regions(pdev, board_name))
+		dev_info(&xb->pdev->dev, "Unable to request regions\n");
+
+	wcxb_soft_reset(xb);
+
+	res = wcxb_alloc_dring(xb, board_name);
+	if (res) {
+		dev_err(&xb->pdev->dev,
+			"Failed to allocate descriptor rings.\n");
+		goto fail_exit;
+	}
+
+	/* Enable writes to fpga status register */
+	iowrite32be(0, xb->membase + 0x04);
+
+	xb->flags.have_msi = (int_mode) ? 0 : (0 == pci_enable_msi(pdev));
+
+	if (request_irq(pdev->irq, wcxb_isr,
+			(xb->flags.have_msi) ? 0 : DAHDI_IRQ_SHARED,
+			board_name, xb)) {
+		dev_notice(&xb->pdev->dev, "Unable to request IRQ %d\n",
+			   pdev->irq);
+		res = -EIO;
+		goto fail_exit;
+	}
+
+	iowrite32be(0, xb->membase + TDM_CONTROL);
+	tdm_control = ioread32be(xb->membase + TDM_CONTROL);
+	if (!(tdm_control & 0x20)) {
+		dev_err(&xb->pdev->dev,
+			"This board is not authenticated and may not function properly.\n");
+		msleep(1000);
+	} else {
+		dev_dbg(&xb->pdev->dev, "Authenticated. %08x\n", tdm_control);
+	}
+
+	return res;
+fail_exit:
+	pci_release_regions(xb->pdev);
+	return res;
+}
+
+void wcxb_stop_dma(struct wcxb *xb)
+{
+	unsigned long flags;
+	u32 reg;
+
+	/* Quiesce DMA engine interrupts */
+	spin_lock_irqsave(&xb->lock, flags);
+	reg = ioread32be(xb->membase + TDM_CONTROL);
+	reg &= ~ENABLE_DMA;
+	iowrite32be(reg, xb->membase + TDM_CONTROL);
+	spin_unlock_irqrestore(&xb->lock, flags);
+}
+
+int wcxb_wait_for_stop(struct wcxb *xb, unsigned long timeout_ms)
+{
+	unsigned long stop;
+	stop = jiffies + msecs_to_jiffies(timeout_ms);
+	do {
+		if (time_after(jiffies, stop))
+			return -EIO;
+		else
+			cpu_relax();
+	} while (!wcxb_is_stopped(xb));
+
+	return 0;
+}
+
+void wcxb_disable_interrupts(struct wcxb *xb)
+{
+	iowrite32be(0, xb->membase + IER);
+}
+
+void wcxb_stop(struct wcxb *xb)
+{
+	unsigned long flags;
+	spin_lock_irqsave(&xb->lock, flags);
+	/* Stop everything */
+	iowrite32be(0, xb->membase + TDM_CONTROL);
+	iowrite32be(0, xb->membase + IER);
+	iowrite32be(0, xb->membase + MER);
+	iowrite32be(-1, xb->membase + IAR);
+	/* Flush quiesce commands before exit */
+	ioread32be(xb->membase);
+	spin_unlock_irqrestore(&xb->lock, flags);
+	synchronize_irq(xb->pdev->irq);
+}
+
+bool wcxb_is_stopped(struct wcxb *xb)
+{
+	return !(ioread32be(xb->membase + TDM_CONTROL) & DMA_RUNNING);
+}
+
+static void wcxb_free_dring(struct wcxb *xb)
+{
+	struct wcxb_meta_desc *mdesc;
+	struct wcxb_hw_desc *hdesc;
+	int i;
+
+	/* Free tx/rx buffs */
+	for (i = 0; i < DRING_SIZE; i++) {
+		mdesc = &xb->meta_dring[i];
+		hdesc = &xb->hw_dring[i];
+		if (mdesc->tx_buf_virt) {
+			dma_pool_free(xb->pool,
+					mdesc->tx_buf_virt,
+					be32_to_cpu(hdesc->tx_buf));
+			dma_pool_free(xb->pool,
+					mdesc->rx_buf_virt,
+					be32_to_cpu(hdesc->rx_buf));
+		}
+	}
+
+	dma_pool_destroy(xb->pool);
+	dma_free_coherent(&xb->pdev->dev,
+		sizeof(struct wcxb_hw_desc) * DRING_SIZE,
+		xb->hw_dring,
+		xb->hw_dring_phys);
+	kfree(xb->meta_dring);
+}
+
+void wcxb_release(struct wcxb *xb)
+{
+	wcxb_stop(xb);
+	synchronize_irq(xb->pdev->irq);
+	free_irq(xb->pdev->irq, xb);
+	if (xb->flags.have_msi)
+		pci_disable_msi(xb->pdev);
+	if (xb->membase)
+		pci_iounmap(xb->pdev, xb->membase);
+	wcxb_free_dring(xb);
+	pci_release_regions(xb->pdev);
+	pci_disable_device(xb->pdev);
+	return;
+}
+
+int wcxb_start(struct wcxb *xb)
+{
+	u32 reg;
+	unsigned long flags;
+
+	spin_lock_irqsave(&xb->lock, flags);
+	_wcxb_reset_dring(xb);
+	/* Enable hardware interrupts */
+	iowrite32be(-1, xb->membase + IAR);
+	iowrite32be(DESC_UNDERRUN|DESC_COMPLETE, xb->membase + IER);
+	/* iowrite32be(0x3f7, xb->membase + IER); */
+	iowrite32be(MER_ME|MER_HIE, xb->membase + MER);
+
+	/* Start the DMA engine processing. */
+	reg = ioread32be(xb->membase + TDM_CONTROL);
+	reg |= ENABLE_DMA;
+	iowrite32be(reg, xb->membase + TDM_CONTROL);
+
+	spin_unlock_irqrestore(&xb->lock, flags);
+
+	return 0;
+}
+
+struct wcxb_meta_block {
+	__le32 chksum;
+	__le32 version;
+	__le32 size;
+} __packed;
+
+struct wcxb_firm_header {
+	u8	header[6];
+	__le32	chksum;
+	u8	pad[18];
+	__le32	version;
+} __packed;
+
+static u32 wcxb_get_firmware_version(struct wcxb *xb)
+{
+	u32 version = 0;
+
+	/* Two version registers are read and catenated into one */
+	/* Firmware version goes in bits upper byte */
+	version = ((ioread32be(xb->membase + 0x400) & 0xffff)<<16);
+
+	/* Microblaze version goes in lower word */
+	version += ioread32be(xb->membase + 0x2018);
+
+	return version;
+}
+
+static int wcxb_update_firmware(struct wcxb *xb, const struct firmware *fw,
+				const char *filename)
+{
+	u32 tdm_control;
+	static const int APPLICATION_ADDRESS = 0x200000;
+	static const int META_BLOCK_OFFSET   = 0x170000;
+	static const int ERASE_BLOCK_SIZE    = 0x010000;
+	static const int END_OFFSET = APPLICATION_ADDRESS + META_BLOCK_OFFSET +
+			 ERASE_BLOCK_SIZE;
+	struct wcxb_spi_master *flash_spi_master;
+	struct wcxb_spi_device *flash_spi_device;
+	struct wcxb_meta_block meta;
+	int offset;
+	struct wcxb_firm_header *head = (struct wcxb_firm_header *)(fw->data);
+
+	if (fw->size > (META_BLOCK_OFFSET + sizeof(*head))) {
+		dev_err(&xb->pdev->dev,
+			"Firmware is too large to fit in available space.\n");
+
+		return -EINVAL;
+	}
+
+	meta.size = cpu_to_le32(fw->size);
+	meta.version = head->version;
+	meta.chksum = head->chksum;
+
+	flash_spi_master = wcxb_spi_master_create(&xb->pdev->dev,
+						  xb->membase + FLASH_SPI_BASE,
+						  false);
+
+	flash_spi_device = wcxb_spi_device_create(flash_spi_master, 0);
+
+	dev_info(&xb->pdev->dev,
+		"Uploading %s. This can take up to 30 seconds.\n", filename);
+
+
+	/* First erase all the blocks in the application area. */
+	offset = APPLICATION_ADDRESS;
+	while (offset < END_OFFSET) {
+		wcxb_flash_sector_erase(flash_spi_device, offset);
+		offset += ERASE_BLOCK_SIZE;
+	}
+
+	/* Then write the new firmware file. */
+	wcxb_flash_write(flash_spi_device, APPLICATION_ADDRESS,
+			 &fw->data[sizeof(struct wcxb_firm_header)],
+			 fw->size - sizeof(struct wcxb_firm_header));
+
+	/* Finally, update the meta block. */
+	wcxb_flash_write(flash_spi_device,
+			 APPLICATION_ADDRESS + META_BLOCK_OFFSET,
+			 &meta, sizeof(meta));
+
+	/* Reset fpga after loading firmware */
+	dev_info(&xb->pdev->dev, "Firmware load complete. Reseting device.\n");
+	tdm_control = ioread32be(xb->membase + TDM_CONTROL);
+
+	wcxb_hard_reset(xb);
+
+	iowrite32be(0, xb->membase + 0x04);
+	iowrite32be(tdm_control, xb->membase + TDM_CONTROL);
+
+	wcxb_spi_device_destroy(flash_spi_device);
+	wcxb_spi_master_destroy(flash_spi_master);
+	return 0;
+}
+
+int wcxb_check_firmware(struct wcxb *xb, const u32 expected_version,
+			const char *firmware_filename, bool force_firmware)
+{
+	const struct firmware *fw;
+	const struct wcxb_firm_header *header;
+	int res = 0;
+	u32 crc;
+	u32 version = 0;
+
+	version = wcxb_get_firmware_version(xb);
+
+	if (0xff000000 == (version & 0xff000000)) {
+		dev_info(&xb->pdev->dev,
+			 "Invalid firmware %x. Please check your hardware.\n",
+			 version);
+		return -EIO;
+	}
+
+	if ((expected_version == version) && !force_firmware) {
+		dev_info(&xb->pdev->dev, "Firmware version: %x\n", version);
+		return 0;
+	}
+
+	if (force_firmware) {
+		dev_info(&xb->pdev->dev,
+			"force_firmware module parameter is set. Forcing firmware load, regardless of version\n");
+	} else {
+		dev_info(&xb->pdev->dev,
+			"Firmware version %x is running, but we require version %x.\n",
+			version, expected_version);
+	}
+
+	res = request_firmware(&fw, firmware_filename, &xb->pdev->dev);
+	if (res) {
+		dev_info(&xb->pdev->dev,
+			"Firmware '%s' not available from userspace.\n",
+			firmware_filename);
+		goto cleanup;
+	}
+
+	header = (const struct wcxb_firm_header *)fw->data;
+
+	/* Check the crc */
+	crc = crc32(~0, &fw->data[10], fw->size - 10) ^ ~0;
+	if (memcmp("DIGIUM", header->header, sizeof(header->header)) ||
+		 (le32_to_cpu(header->chksum) != crc)) {
+		dev_info(&xb->pdev->dev,
+			"%s is invalid. Please reinstall.\n",
+			firmware_filename);
+		goto cleanup;
+	}
+
+	/* Check the file vs required firmware versions */
+	if (le32_to_cpu(header->version) != expected_version) {
+		dev_err(&xb->pdev->dev,
+			"Existing firmware file %s is version %x, but we require %x. Please install the correct firmware file.\n",
+			firmware_filename, le32_to_cpu(header->version),
+			expected_version);
+		res = -EIO;
+		goto cleanup;
+	}
+
+	dev_info(&xb->pdev->dev, "Found %s (version: %x) Preparing for flash\n",
+				firmware_filename, header->version);
+
+	res = wcxb_update_firmware(xb, fw, firmware_filename);
+
+	version = wcxb_get_firmware_version(xb);
+	dev_info(&xb->pdev->dev, "Reset into firmware version: %x\n", version);
+
+	if ((expected_version != version) && !force_firmware) {
+		/* On the off chance that the interface is in a state where it
+		 * cannot boot into the updated firmware image, power cycling
+		 * the card can recover. A simple "reset" of the computer is not
+		 * sufficient, power has to be removed completely. */
+		dev_err(&xb->pdev->dev,
+			"The wrong firmware is running after update. Please power cycle and try again.\n");
+		res = -EIO;
+		goto cleanup;
+	}
+
+	if (res) {
+		dev_info(&xb->pdev->dev,
+			 "Failed to load firmware %s\n", firmware_filename);
+	}
+
+cleanup:
+	release_firmware(fw);
+	return res;
+}

drivers/dahdi/wcxb.h

@@ -0,0 +1,184 @@
+/*
+ * wcxb SPI library
+ *
+ * Copyright (C) 2013 Digium, Inc.
+ *
+ * All rights reserved.
+ *
+ */
+
+/*
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2 as published by the
+ * Free Software Foundation. See the LICENSE file included with
+ * this program for more details.
+ */
+
+#ifndef __WCXB_H__
+#define __WCXB_H__
+
+#define WCXB_DEFAULT_LATENCY	3U
+#define WCXB_DEFAULT_MAXLATENCY 20U
+#define WCXB_DMA_CHAN_SIZE	128
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
+/* The is_pcie member was backported but I'm not sure in which version. */
+#  ifndef RHEL_RELEASE_VERSION
+#define WCXB_PCI_DEV_DOES_NOT_HAVE_IS_PCIE
+#  endif
+#else
+#endif
+
+struct wcxb;
+
+struct wcxb_operations {
+	void (*handle_receive)(struct wcxb *xb, void *frame);
+	void (*handle_transmit)(struct wcxb *xb, void *frame);
+	void (*handle_error)(struct wcxb *xb);
+	void (*handle_interrupt)(struct wcxb *xb, u32 pending);
+};
+
+struct wcxb_meta_desc;
+struct wcxb_hw_desc;
+
+struct wcxb {
+	struct pci_dev			*pdev;
+	spinlock_t			lock;
+	const struct wcxb_operations	*ops;
+	unsigned int			*debug;
+	unsigned int			max_latency;
+	unsigned int			latency;
+	struct {
+		u32	have_msi:1;
+		u32	latency_locked:1;
+		u32	drive_timing_cable:1;
+#ifdef WCXB_PCI_DEV_DOES_NOT_HAVE_IS_PCIE
+		u32	is_pcie:1;
+#endif
+	} flags;
+	void __iomem			*membase;
+	struct wcxb_meta_desc		*meta_dring;
+	struct wcxb_hw_desc		*hw_dring;
+	unsigned int			dma_head;
+	unsigned int			dma_tail;
+	dma_addr_t			hw_dring_phys;
+	struct dma_pool			*pool;
+	unsigned long			framecount;
+};
+
+extern int wcxb_init(struct wcxb *xb, const char *board_name, u32 int_mode);
+extern void wcxb_release(struct wcxb *xb);
+extern int wcxb_start(struct wcxb *xb);
+extern void wcxb_stop(struct wcxb *xb);
+extern int wcxb_wait_for_stop(struct wcxb *xb, unsigned long timeout_ms);
+extern bool wcxb_is_stopped(struct wcxb *xb);
+
+enum wcxb_clock_sources {
+	WCXB_CLOCK_SELF,	/* Use the internal oscillator for timing. */
+	WCXB_CLOCK_RECOVER,	/* Recover the clock from a framer. */
+#ifdef RPC_RCLK
+	WCXB_CLOCK_RECOVER_ALT,	/* Recover the clock from a framer. */
+#endif
+	WCXB_CLOCK_SLAVE	/* Recover clock from any timing header. */
+};
+
+extern enum wcxb_clock_sources wcxb_get_clksrc(struct wcxb *xb);
+extern void wcxb_set_clksrc(struct wcxb *xb, enum wcxb_clock_sources clksrc);
+
+static inline void wcxb_enable_timing_header_driver(struct wcxb *xb)
+{
+	xb->flags.drive_timing_cable = 1;
+}
+static inline bool wcxb_is_timing_header_driver_enabled(struct wcxb *xb)
+{
+	return 1 == xb->flags.drive_timing_cable;
+}
+
+static inline void wcxb_disable_timing_header_driver(struct wcxb *xb)
+{
+	xb->flags.drive_timing_cable = 0;
+}
+
+extern int wcxb_check_firmware(struct wcxb *xb, const u32 expected_version,
+			       const char *firmware_filename,
+			       bool force_firmware);
+extern void wcxb_stop_dma(struct wcxb *xb);
+extern void wcxb_disable_interrupts(struct wcxb *xb);
+
+static inline void wcxb_gpio_set(struct wcxb *xb, u32 bits)
+{
+	u32 reg;
+	unsigned long flags;
+	spin_lock_irqsave(&xb->lock, flags);
+	reg = ioread32be(xb->membase);
+	iowrite32be(reg | bits, xb->membase);
+	spin_unlock_irqrestore(&xb->lock, flags);
+}
+
+static inline void wcxb_gpio_clear(struct wcxb *xb, u32 bits)
+{
+	u32 reg;
+	unsigned long flags;
+	spin_lock_irqsave(&xb->lock, flags);
+	reg = ioread32be(xb->membase);
+	iowrite32be(reg & (~bits), xb->membase);
+	spin_unlock_irqrestore(&xb->lock, flags);
+}
+
+static inline void
+wcxb_set_maxlatency(struct wcxb *xb, unsigned int max_latency)
+{
+	unsigned long flags;
+	spin_lock_irqsave(&xb->lock, flags);
+	xb->max_latency = clamp(max_latency,
+				xb->latency,
+				WCXB_DEFAULT_MAXLATENCY);
+	spin_unlock_irqrestore(&xb->lock, flags);
+}
+
+static inline void
+wcxb_set_minlatency(struct wcxb *xb, unsigned int min_latency)
+{
+	unsigned long flags;
+	spin_lock_irqsave(&xb->lock, flags);
+	xb->latency = clamp(min_latency, WCXB_DEFAULT_LATENCY,
+			    WCXB_DEFAULT_MAXLATENCY);
+	spin_unlock_irqrestore(&xb->lock, flags);
+}
+
+static inline void
+wcxb_lock_latency(struct wcxb *xb)
+{
+	unsigned long flags;
+	spin_lock_irqsave(&xb->lock, flags);
+	xb->flags.latency_locked = 1;
+	spin_unlock_irqrestore(&xb->lock, flags);
+	return;
+}
+
+static inline void
+wcxb_unlock_latency(struct wcxb *xb)
+{
+	unsigned long flags;
+	spin_lock_irqsave(&xb->lock, flags);
+	xb->flags.latency_locked = 0;
+	spin_unlock_irqrestore(&xb->lock, flags);
+	return;
+}
+
+/* Interface for the echocan block */
+extern void wcxb_enable_echocan(struct wcxb *xb);
+extern void wcxb_disable_echocan(struct wcxb *xb);
+extern void wcxb_reset_echocan(struct wcxb *xb);
+extern void wcxb_enable_echocan_dram(struct wcxb *xb);
+extern bool wcxb_is_echocan_present(struct wcxb *xb);
+extern u16 wcxb_get_echocan_reg(struct wcxb *xb, u32 address);
+extern void wcxb_set_echocan_reg(struct wcxb *xb, u32 address, u16 val);
+
+#endif

drivers/dahdi/wcxb_flash.c

@@ -0,0 +1,170 @@
+/*
+ * wcxb SPI library
+ *
+ * Copyright (C) 2013 Digium, Inc.
+ *
+ * All rights reserved.
+ *
+ */
+
+/*
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2 as published by the
+ * Free Software Foundation. See the LICENSE file included with
+ * this program for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/device.h>
+#include <linux/sched.h>
+
+#include "wcxb_spi.h"
+#include "wcxb_flash.h"
+
+#define FLASH_PAGE_PROGRAM	0x02
+#define FLASH_READ		0x03
+#define FLASH_READ_STATUS	0x05
+#define FLASH_WRITE_ENABLE	0x06
+#define FLASH_SECTOR_ERASE	0xd8
+
+static int wcxb_flash_read_status_register(struct wcxb_spi_device *spi,
+					   u8 *status)
+{
+	u8 command[] = {
+		FLASH_READ_STATUS,
+	};
+	struct wcxb_spi_transfer t_cmd = {
+		.tx_buf = command,
+		.len = sizeof(command),
+	};
+	struct wcxb_spi_transfer t_serial = {
+		.rx_buf = status,
+		.len = 1,
+	};
+	struct wcxb_spi_message m;
+	wcxb_spi_message_init(&m);
+	wcxb_spi_message_add_tail(&t_cmd, &m);
+	wcxb_spi_message_add_tail(&t_serial, &m);
+	return wcxb_spi_sync(spi, &m);
+}
+
+int wcxb_flash_read(struct wcxb_spi_device *spi, unsigned int address,
+		    void *data, size_t len)
+{
+	u8 command[] = {
+		FLASH_READ,
+		(address & 0xff0000) >> 16,
+		(address & 0xff00) >> 8,
+		(address & 0xff)
+	};
+	struct wcxb_spi_transfer t_cmd = {
+		.tx_buf = command,
+		.len = sizeof(command),
+	};
+	struct wcxb_spi_transfer t_serial = {
+		.rx_buf = data,
+		.len = len,
+	};
+	struct wcxb_spi_message m;
+	wcxb_spi_message_init(&m);
+	wcxb_spi_message_add_tail(&t_cmd, &m);
+	wcxb_spi_message_add_tail(&t_serial, &m);
+	return wcxb_spi_sync(spi, &m);
+}
+
+static int wcxb_flash_wait_until_not_busy(struct wcxb_spi_device *spi)
+{
+	int res;
+	u8 status;
+	unsigned long stop = jiffies + 5*HZ;
+	do {
+		res = wcxb_flash_read_status_register(spi, &status);
+	} while (!res && (status & 0x1) && time_before(jiffies, stop));
+	if (!res)
+		return res;
+	if (time_after_eq(jiffies, stop))
+		return -EIO;
+	return 0;
+}
+
+static int wcxb_flash_write_enable(struct wcxb_spi_device *spi)
+{
+	u8 command = FLASH_WRITE_ENABLE;
+	return wcxb_spi_write(spi, &command, 1);
+}
+
+int wcxb_flash_sector_erase(struct wcxb_spi_device *spi,
+				   unsigned int address)
+{
+	int res;
+	u8 command[] = {FLASH_SECTOR_ERASE, (address >> 16)&0xff, 0x00, 0x00};
+	/* Sector must be on 64KB boundary. */
+	if (address & 0xffff)
+		return -EINVAL;
+	/* Start the erase. */
+	res = wcxb_flash_write_enable(spi);
+	if (res)
+		return res;
+	res = wcxb_spi_write(spi, &command, sizeof(command));
+	if (res)
+		return res;
+	return wcxb_flash_wait_until_not_busy(spi);
+}
+
+int wcxb_flash_write(struct wcxb_spi_device *spi, unsigned int address,
+		     const void *data, size_t len)
+{
+	int res;
+	const size_t FLASH_PAGE_SIZE = 256;
+	u8 command[] = {
+		FLASH_PAGE_PROGRAM,
+		(address & 0xff0000) >> 16,
+		(address & 0xff00) >> 8,
+		0x00,
+	};
+	struct wcxb_spi_transfer t_cmd = {
+		.tx_buf = command,
+		.len = sizeof(command),
+	};
+	struct wcxb_spi_transfer t_data = {
+		.tx_buf = data,
+		.len = len,
+	};
+	struct wcxb_spi_message m;
+
+	/* We need to write on page size boundaries */
+	WARN_ON(address & 0xff);
+
+	wcxb_spi_message_init(&m);
+	wcxb_spi_message_add_tail(&t_cmd, &m);
+	wcxb_spi_message_add_tail(&t_data, &m);
+
+	while (len) {
+		res = wcxb_flash_write_enable(spi);
+		if (res)
+			return res;
+		command[1] = (address >> 16) & 0xff;
+		command[2] = (address >> 8) & 0xff;
+		t_data.tx_buf = data;
+		t_data.len = min(len, FLASH_PAGE_SIZE);
+		res = wcxb_spi_sync(spi, &m);
+		WARN_ON(res);
+		if (res)
+			return res;
+		res = wcxb_flash_wait_until_not_busy(spi);
+		WARN_ON(res);
+		if (res)
+			return res;
+		len -= t_data.len;
+		address += t_data.len;
+		data += t_data.len;
+	}
+	return 0;
+}

drivers/dahdi/wcxb_flash.h

@@ -0,0 +1,34 @@
+/*
+ * wcxb SPI library
+ *
+ * Copyright (C) 2013 Digium, Inc.
+ *
+ * All rights reserved.
+ *
+ */
+
+/*
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2 as published by the
+ * Free Software Foundation. See the LICENSE file included with
+ * this program for more details.
+ */
+
+#ifndef __WCXB_FLASH_H__
+#define __WCXB_FLASH_H__
+
+extern int wcxb_flash_read(struct wcxb_spi_device *spi, unsigned int address,
+			   void *data, size_t len);
+
+extern int wcxb_flash_sector_erase(struct wcxb_spi_device *spi, unsigned int
+				   address);
+extern int wcxb_flash_write(struct wcxb_spi_device *spi, unsigned int address,
+			    const void *data, size_t len);
+
+#endif

drivers/dahdi/wcxb_spi.c

@@ -0,0 +1,386 @@
+/*
+ * wcxb SPI library
+ *
+ * Copyright (C) 2013 Digium, Inc.
+ *
+ * All rights reserved.
+ *
+ */
+
+/*
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2 as published by the
+ * Free Software Foundation. See the LICENSE file included with
+ * this program for more details.
+ */
+
+#define DEBUG
+
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/device.h>
+#include <linux/completion.h>
+#include <linux/sched.h>
+#include <linux/delay.h>
+
+#include <linux/io.h>
+
+#include <dahdi/kernel.h>
+
+#include "wcxb_spi.h"
+
+#define BBIT(n) (1UL << (31UL - (n)))
+
+#define SPISRR	0x40
+#define SPISRR_RESET		0x0000000a /* Resets Device */
+
+#define SPICR			0x60
+#define SPICR_LSB_FIRST		BBIT(22) /* LSB First. 0=MSB first transfer */
+#define SPICR_MASTER_INHIBIT	BBIT(23) /* Master Transaction Inhibit */
+#define SPICR_SLAVE_SELECT	BBIT(24) /* Manual Slave Select Assert Enable */
+#define SPICR_RX_FIFO_RESET	BBIT(25) /* Receive FIFO Reset */
+#define SPICR_TX_FIFO_RESET	BBIT(26) /* Transmit FIFO Reset */
+#define SPICR_CPHA		BBIT(27) /* Clock Phase */
+#define SPICR_CPOL		BBIT(28) /* Clock Polarity 0=Active High */
+#define SPICR_MASTER		BBIT(29) /* Master Enable */
+#define SPICR_SPE		BBIT(30) /* SPI System Enable */
+#define SPICR_LOOP		BBIT(31) /* Local Loopback Mode */
+
+#define SPICR_START_TRANSFER	(SPICR_CPHA | SPICR_CPOL | \
+				 SPICR_MASTER | SPICR_SPE)
+#define SPICR_READY_TRANSFER	(SPICR_MASTER_INHIBIT | SPICR_START_TRANSFER)
+
+#define SPISR			0x64     /* SPI Status Register */
+#define SPISR_SLAVE_MODE_SEL	BBIT(26) /* Slave Mode Select Flag */
+#define SPISR_MODF		BBIT(27) /* Mode-Fault Error Flag */
+#define SPISR_TX_FULL		BBIT(28) /* Transmit FIFO Full */
+#define SPISR_TX_EMPTY		BBIT(29) /* Transmit FIFO Empty */
+#define SPISR_RX_FULL		BBIT(30) /* Receive FIFO Full */
+#define SPISR_RX_EMPTY		BBIT(31) /* Receive FIFO Empty */
+
+#define SPIDTR			0x68     /* SPI Data Transmit Register */
+#define SPIDRR			0x6c     /* SPI Data Receive Register */
+
+#define SPISSR			0x70     /* SPI Slave Select Register */
+
+#undef SUCCESS
+#define SUCCESS			0
+
+struct wcxb_spi_master {
+	struct device *parent;
+	struct list_head message_queue;
+	spinlock_t lock;
+	void __iomem *base;
+	struct wcxb_spi_message *cur_msg;
+	struct wcxb_spi_transfer *cur_transfer;
+	u16 bytes_left;
+	u16 bytes_in_fifo;
+	const u8 *cur_tx_byte;
+	u8 *cur_rx_byte;
+	u16 auto_cs:1;
+};
+
+static inline void _wcxb_assert_chip_select(struct wcxb_spi_master *master,
+					   unsigned int cs)
+{
+	const int cs_mask = ~(1UL << cs);
+	iowrite32be(cs_mask, master->base + SPISSR);
+	ioread32be(master->base + SPISSR);
+}
+
+static inline void _wcxb_clear_chip_select(struct wcxb_spi_master *master)
+{
+	iowrite32be(~(0), master->base + SPISSR);
+	ioread32(master->base + SPISSR);
+}
+
+static inline void wcxb_spi_reset_controller(struct wcxb_spi_master *master)
+{
+	u32 spicr = SPICR_READY_TRANSFER;
+	spicr |= (master->auto_cs) ? 0 : SPICR_SLAVE_SELECT;
+	iowrite32be(SPISRR_RESET, master->base + SPISRR);
+	iowrite32be(spicr, master->base + SPICR);
+	iowrite32be(0xffffffff, master->base + SPISSR);
+}
+
+struct wcxb_spi_master *wcxb_spi_master_create(struct device *parent,
+					       void __iomem *membase,
+					       bool auto_cs)
+{
+	struct wcxb_spi_master *master = NULL;
+	master = kzalloc(sizeof(struct wcxb_spi_master), GFP_KERNEL);
+	if (!master)
+		goto error_exit;
+
+	spin_lock_init(&master->lock);
+	INIT_LIST_HEAD(&master->message_queue);
+	master->base = membase;
+	master->parent = parent;
+
+	master->auto_cs = (auto_cs) ? 1 : 0;
+	wcxb_spi_reset_controller(master);
+	return master;
+
+error_exit:
+	kfree(master);
+	return NULL;
+}
+
+void wcxb_spi_master_destroy(struct wcxb_spi_master *master)
+{
+	struct wcxb_spi_message *m;
+	if (!master)
+		return;
+	while (!list_empty(&master->message_queue)) {
+		m = list_first_entry(&master->message_queue,
+				     struct wcxb_spi_message, node);
+		list_del(&m->node);
+		if (m->complete)
+			m->complete(m->arg);
+	}
+	kfree(master);
+	return;
+}
+
+static inline bool is_txfifo_empty(const struct wcxb_spi_master *master)
+{
+	return ((ioread32(master->base + SPISR) &
+		 cpu_to_be32(SPISR_TX_EMPTY)) > 0);
+}
+
+static const u8 DUMMY_TX = 0xff;
+static u8 DUMMY_RX;
+
+static void _wcxb_spi_transfer_to_fifo(struct wcxb_spi_master *master)
+{
+	const unsigned int FIFO_SIZE = 16;
+	u32 spicr;
+	while (master->bytes_left && master->bytes_in_fifo < FIFO_SIZE) {
+		iowrite32be(*master->cur_tx_byte, master->base + SPIDTR);
+		master->bytes_in_fifo++;
+		master->bytes_left--;
+		if (&DUMMY_TX != master->cur_tx_byte)
+			master->cur_tx_byte++;
+	}
+
+	spicr = (master->auto_cs) ? SPICR_START_TRANSFER :
+				    SPICR_START_TRANSFER | SPICR_SLAVE_SELECT;
+	iowrite32be(spicr, master->base + SPICR);
+}
+
+static void _wcxb_spi_transfer_from_fifo(struct wcxb_spi_master *master)
+{
+	u32 spicr;
+	while (master->bytes_in_fifo) {
+		*master->cur_rx_byte = ioread32be(master->base + SPIDRR);
+		if (&DUMMY_RX != master->cur_rx_byte)
+			master->cur_rx_byte++;
+		--master->bytes_in_fifo;
+	}
+
+	spicr = SPICR_START_TRANSFER;
+	spicr |= (master->auto_cs) ? 0 : SPICR_SLAVE_SELECT;
+	iowrite32be(spicr | SPICR_MASTER_INHIBIT, master->base + SPICR);
+}
+
+static void _wcxb_spi_start_transfer(struct wcxb_spi_master *master,
+				     struct wcxb_spi_transfer *t)
+{
+#ifdef DEBUG
+	if (!t || !master || (!t->tx_buf && !t->rx_buf) ||
+			master->cur_transfer) {
+		WARN_ON(1);
+		return;
+	}
+#endif
+
+	master->cur_transfer = t;
+	master->bytes_left = t->len;
+	master->cur_tx_byte = (t->tx_buf) ?: &DUMMY_TX;
+	master->cur_rx_byte = (t->rx_buf) ?: &DUMMY_RX;
+
+	_wcxb_spi_transfer_to_fifo(master);
+}
+
+/**
+ * _wcxb_spi_start_message - Start a new message transferring.
+ *
+ * Must be called with master->lock held.
+ *
+ */
+static int _wcxb_spi_start_message(struct wcxb_spi_master *master,
+				   struct wcxb_spi_message *message)
+{
+	struct wcxb_spi_transfer *t;
+
+	if (master->cur_msg) {
+		/* There is already a message in progress. Queue for later. */
+		list_add_tail(&message->node, &master->message_queue);
+		return 0;
+	}
+
+	if (!message->spi) {
+		dev_dbg(master->parent,
+			"Queueing message without SPI device specified?\n");
+		return -EINVAL;
+	};
+
+	master->cur_msg = message;
+
+	_wcxb_assert_chip_select(master, message->spi->chip_select);
+	t = list_first_entry(&message->transfers,
+			     struct wcxb_spi_transfer, node);
+	_wcxb_spi_start_transfer(master, t);
+
+	return 0;
+}
+
+/**
+ * wcxb_spi_complete_message - Complete the current message.
+ *
+ * Called after all transfers in current message have been completed. This will
+ * complete the current message and start the next queued message if there are
+ * any.
+ *
+ * Must be called with the master->lock held.
+ *
+ */
+static void _wcxb_spi_complete_cur_msg(struct wcxb_spi_master *master)
+{
+	struct wcxb_spi_message *message;
+	if (!master->cur_msg)
+		return;
+	message = master->cur_msg;
+	message->status = SUCCESS;
+	_wcxb_clear_chip_select(master);
+	master->cur_msg = NULL;
+	if (!list_empty(&master->message_queue)) {
+		message = list_first_entry(&master->message_queue,
+					   struct wcxb_spi_message, node);
+		list_del(&message->node);
+		_wcxb_spi_start_message(master, message);
+	}
+	return;
+}
+
+static inline bool
+_wcxb_spi_is_last_transfer(const struct wcxb_spi_transfer *t,
+			   const struct wcxb_spi_message *message)
+{
+	return t->node.next == &message->transfers;
+}
+
+static inline struct wcxb_spi_transfer *
+_wcxb_spi_next_transfer(struct wcxb_spi_transfer *t)
+{
+	return list_entry(t->node.next, struct wcxb_spi_transfer, node);
+}
+
+/**
+ * wcxb_spi_handle_interrupt - Drives the transfers forward.
+ *
+ * Doesn't necessarily need to be called in the context of a real interrupt, but
+ * should be called with interrupts disabled on the local CPU.
+ *
+ */
+void wcxb_spi_handle_interrupt(struct wcxb_spi_master *master)
+{
+	struct wcxb_spi_message *msg;
+	struct wcxb_spi_transfer *t;
+	void (*complete)(void *arg) = NULL;
+	unsigned long flags;
+
+	/* Check if we're not in the middle of a transfer, or not finished with
+	 * a part of one. */
+	spin_lock_irqsave(&master->lock, flags);
+
+	t = master->cur_transfer;
+	msg = master->cur_msg;
+
+	if (!msg || !is_txfifo_empty(master))
+		goto done;
+
+#ifdef DEBUG
+	if (!t) {
+		dev_dbg(master->parent,
+			"No current transfer in %s\n", __func__);
+		goto done;
+	}
+#endif
+
+	/* First read any data out of the receive FIFO into the current
+	 * transfer. */
+	_wcxb_spi_transfer_from_fifo(master);
+	if (master->bytes_left) {
+		/* The current transfer isn't finished. */
+		_wcxb_spi_transfer_to_fifo(master);
+		goto done;
+	}
+
+	/* The current transfer is finished. Check for another transfer in this
+	 * message or complete it and look for another message to start. */
+	master->cur_transfer = NULL;
+
+	if (_wcxb_spi_is_last_transfer(t, msg)) {
+		complete = msg->complete;
+		_wcxb_spi_complete_cur_msg(master);
+	} else {
+		t = _wcxb_spi_next_transfer(t);
+		_wcxb_spi_start_transfer(master, t);
+	}
+done:
+	spin_unlock_irqrestore(&master->lock, flags);
+	/* Do not call the complete call back under the bus lock. */
+	if (complete)
+		complete(msg->arg);
+	return;
+}
+
+int wcxb_spi_async(struct wcxb_spi_device *spi,
+		   struct wcxb_spi_message *message)
+{
+	int res;
+	unsigned long flags;
+	WARN_ON(!spi || !message || !spi->master);
+
+	if (list_empty(&message->transfers)) {
+		/* No transfers in this message? */
+		if (message->complete)
+			message->complete(message->arg);
+		message->status = -EINVAL;
+		return 0;
+	}
+	message->status = -EINPROGRESS;
+	message->spi = spi;
+	spin_lock_irqsave(&spi->master->lock, flags);
+	res = _wcxb_spi_start_message(spi->master, message);
+	spin_unlock_irqrestore(&spi->master->lock, flags);
+	return res;
+}
+
+static void wcxb_spi_complete_message(void *arg)
+{
+	complete((struct completion *)arg);
+}
+
+int wcxb_spi_sync(struct wcxb_spi_device *spi, struct wcxb_spi_message *message)
+{
+	DECLARE_COMPLETION_ONSTACK(done);
+	WARN_ON(!spi || !spi->master);
+	message->complete = wcxb_spi_complete_message;
+	message->arg = &done;
+	wcxb_spi_async(spi, message);
+
+	/* TODO: There has got to be a better way to do this. */
+	while (!try_wait_for_completion(&done)) {
+		wcxb_spi_handle_interrupt(spi->master);
+		cpu_relax();
+	}
+	return message->status;
+}

drivers/dahdi/wcxb_spi.h

@@ -0,0 +1,116 @@
+/*
+ * wcxb SPI library
+ *
+ * Copyright (C) 2013 Digium, Inc.
+ *
+ * All rights reserved.
+ *
+ */
+
+/*
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2 as published by the
+ * Free Software Foundation. See the LICENSE file included with
+ * this program for more details.
+ */
+
+#ifndef __WCXB_SPI_H
+#define __WCXB_SPI_H
+
+#include <linux/spi/spi.h>
+#include <stdbool.h>
+
+struct wcxb_spi_transfer {
+	const void	*tx_buf;
+	void		*rx_buf;
+	u32		len:16;
+	u16		delay_usecs;
+	struct list_head node;
+};
+
+struct wcxb_spi_message {
+	struct list_head transfers;
+	struct list_head node;
+	struct wcxb_spi_device *spi;
+	void (*complete)(void *arg);
+	void *arg;
+	int status;
+};
+
+struct wcxb_spi_master;
+
+struct wcxb_spi_device {
+	struct wcxb_spi_master *master;
+	u16 chip_select;
+};
+
+extern struct wcxb_spi_master *wcxb_spi_master_create(struct device *parent,
+					void __iomem *base, bool auto_cs);
+extern void wcxb_spi_master_destroy(struct wcxb_spi_master *master);
+extern int wcxb_spi_sync(struct wcxb_spi_device *spi,
+			 struct wcxb_spi_message *message);
+extern int wcxb_spi_async(struct wcxb_spi_device *spi,
+			  struct wcxb_spi_message *message);
+extern void wcxb_spi_handle_interrupt(struct wcxb_spi_master *master);
+
+static inline struct wcxb_spi_device *
+wcxb_spi_device_create(struct wcxb_spi_master *master, u16 chip_select)
+{
+	struct wcxb_spi_device *spi = kzalloc(sizeof(*spi), GFP_KERNEL);
+	if (!spi)
+		return NULL;
+	spi->master = master;
+	spi->chip_select = chip_select;
+	return spi;
+}
+
+static inline void wcxb_spi_device_destroy(struct wcxb_spi_device *spi)
+{
+	kfree(spi);
+}
+
+static inline void wcxb_spi_message_init(struct wcxb_spi_message *m)
+{
+	memset(m, 0, sizeof(*m));
+	INIT_LIST_HEAD(&m->transfers);
+}
+
+static inline void wcxb_spi_message_add_tail(struct wcxb_spi_transfer *t,
+					     struct wcxb_spi_message *m)
+{
+	list_add_tail(&t->node, &m->transfers);
+}
+
+static inline int
+wcxb_spi_write(struct wcxb_spi_device *spi, const void *buffer, size_t len)
+{
+	struct wcxb_spi_transfer	t = {
+			.tx_buf		= buffer,
+			.len		= len,
+		};
+	struct wcxb_spi_message	m;
+	wcxb_spi_message_init(&m);
+	wcxb_spi_message_add_tail(&t, &m);
+	return wcxb_spi_sync(spi, &m);
+}
+
+static inline int
+wcxb_spi_read(struct wcxb_spi_device *spi, void *buffer, size_t len)
+{
+	struct wcxb_spi_transfer	t = {
+			.rx_buf		= buffer,
+			.len		= len,
+		};
+	struct wcxb_spi_message	m;
+	wcxb_spi_message_init(&m);
+	wcxb_spi_message_add_tail(&t, &m);
+	return wcxb_spi_sync(spi, &m);
+}
+
+#endif

drivers/dahdi/xpp/card_bri.c

@@ -26,6 +26,7 @@
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/delay.h>
+#include <linux/seq_file.h>
 #include "xpd.h"
 #include "xproto.h"
 #include "xpp_dahdi.h"
@@ -152,8 +153,7 @@ static int write_state_register(xpd_t *xpd, __u8 value);
 static bool bri_packet_is_valid(xpacket_t *pack);
 static void bri_packet_dump(const char *msg, xpacket_t *pack);
 #ifdef	CONFIG_PROC_FS
-static int proc_bri_info_read(char *page, char **start, off_t off, int count,
-			      int *eof, void *data);
+static const struct file_operations proc_bri_info_ops;
 #endif
 static int bri_spanconfig(struct file *file, struct dahdi_span *span,
 			  struct dahdi_lineconfig *lc);
@@ -673,9 +673,8 @@ static int bri_proc_create(xbus_t *xbus, xpd_t *xpd)
 	XPD_DBG(PROC, xpd, "\n");
 #ifdef	CONFIG_PROC_FS
 	XPD_DBG(PROC, xpd, "Creating '%s'\n", PROC_BRI_INFO_FNAME);
-	priv->bri_info =
-	    create_proc_read_entry(PROC_BRI_INFO_FNAME, 0444, xpd->proc_xpd_dir,
-				   proc_bri_info_read, xpd);
+	priv->bri_info = proc_create_data(PROC_BRI_INFO_FNAME, 0444,
+				 xpd->proc_xpd_dir, &proc_bri_info_ops, xpd);
 	if (!priv->bri_info) {
 		XPD_ERR(xpd, "Failed to create proc file '%s'\n",
 			PROC_BRI_INFO_FNAME);
@@ -1667,12 +1666,10 @@ static void bri_packet_dump(const char *msg, xpacket_t *pack)
 /*------------------------- REGISTER Handling --------------------------*/
 
 #ifdef	CONFIG_PROC_FS
-static int proc_bri_info_read(char *page, char **start, off_t off, int count,
-			      int *eof, void *data)
+static int proc_bri_info_show(struct seq_file *sfile, void *not_used)
 {
-	int len = 0;
 	unsigned long flags;
-	xpd_t *xpd = data;
+	xpd_t *xpd = sfile->private;
 	struct BRI_priv_data *priv;
 
 	DBG(PROC, "\n");
@@ -1681,69 +1678,65 @@ static int proc_bri_info_read(char *page, char **start, off_t off, int count,
 	spin_lock_irqsave(&xpd->lock, flags);
 	priv = xpd->priv;
 	BUG_ON(!priv);
-	len += sprintf(page + len, "%05d Layer 1: ", priv->poll_counter);
+	seq_printf(sfile, "%05d Layer 1: ", priv->poll_counter);
 	if (priv->reg30_good) {
-		len +=
-		    sprintf(page + len, "%-5s ",
-			    (priv->layer1_up) ? "UP" : "DOWN");
-		len +=
-		    sprintf(page + len,
-			    "%c%d %-15s -- fr_sync=%d t2_exp=%d info0=%d g2_g3=%d\n",
-			    IS_NT(xpd) ? 'G' : 'F',
-			    priv->state_register.bits.v_su_sta,
-			    xhfc_state_name(IS_NT(xpd),
-					    priv->state_register.bits.v_su_sta),
-			    priv->state_register.bits.v_su_fr_sync,
-			    priv->state_register.bits.v_su_t2_exp,
-			    priv->state_register.bits.v_su_info0,
-			    priv->state_register.bits.v_g2_g3);
-	} else
-		len += sprintf(page + len, "Unknown\n");
+		seq_printf(sfile, "%-5s ", (priv->layer1_up) ? "UP" : "DOWN");
+		seq_printf(sfile,
+			   "%c%d %-15s -- fr_sync=%d t2_exp=%d info0=%d g2_g3=%d\n",
+			   IS_NT(xpd) ? 'G' : 'F',
+			   priv->state_register.bits.v_su_sta,
+			   xhfc_state_name(IS_NT(xpd),
+				    priv->state_register.bits.v_su_sta),
+			   priv->state_register.bits.v_su_fr_sync,
+			   priv->state_register.bits.v_su_t2_exp,
+			   priv->state_register.bits.v_su_info0,
+			   priv->state_register.bits.v_g2_g3);
+	} else {
+		seq_printf(sfile, "Unknown\n");
+	}
 	if (IS_NT(xpd))
-		len += sprintf(page + len, "T1 Timer: %d\n", priv->t1);
+		seq_printf(sfile, "T1 Timer: %d\n", priv->t1);
 	else
-		len += sprintf(page + len, "T3 Timer: %d\n", priv->t3);
-	len += sprintf(page + len, "Tick Counter: %d\n", priv->tick_counter);
-	len +=
-	    sprintf(page + len, "Last Poll Reply: %d ticks ago\n",
+		seq_printf(sfile, "T3 Timer: %d\n", priv->t3);
+	seq_printf(sfile, "Tick Counter: %d\n", priv->tick_counter);
+	seq_printf(sfile, "Last Poll Reply: %d ticks ago\n",
 		    priv->reg30_ticks);
-	len += sprintf(page + len, "reg30_good=%d\n", priv->reg30_good);
-	len +=
-	    sprintf(page + len, "D-Channel: TX=[%5d]    RX=[%5d]    BAD=[%5d] ",
+	seq_printf(sfile, "reg30_good=%d\n", priv->reg30_good);
+	seq_printf(sfile, "D-Channel: TX=[%5d]    RX=[%5d]    BAD=[%5d] ",
 		    priv->dchan_tx_counter, priv->dchan_rx_counter,
 		    priv->dchan_rx_drops);
 	if (priv->dchan_alive) {
-		len +=
-		    sprintf(page + len, "(alive %d K-ticks)\n",
+		seq_printf(sfile, "(alive %d K-ticks)\n",
 			    priv->dchan_alive_ticks / 1000);
 	} else {
-		len += sprintf(page + len, "(dead)\n");
+		seq_printf(sfile, "(dead)\n");
 	}
-	len +=
-	    sprintf(page + len, "dchan_notx_ticks: %d\n",
+	seq_printf(sfile, "dchan_notx_ticks: %d\n",
 		    priv->dchan_notx_ticks);
-	len +=
-	    sprintf(page + len, "dchan_norx_ticks: %d\n",
+	seq_printf(sfile, "dchan_norx_ticks: %d\n",
 		    priv->dchan_norx_ticks);
-	len +=
-	    sprintf(page + len, "LED: %-10s = %d\n", "GREEN",
+	seq_printf(sfile, "LED: %-10s = %d\n", "GREEN",
 		    priv->ledstate[GREEN_LED]);
-	len +=
-	    sprintf(page + len, "LED: %-10s = %d\n", "RED",
+	seq_printf(sfile, "LED: %-10s = %d\n", "RED",
 		    priv->ledstate[RED_LED]);
-	len += sprintf(page + len, "\nDCHAN:\n");
-	len += sprintf(page + len, "\n");
+	seq_printf(sfile, "\nDCHAN:\n");
+	seq_printf(sfile, "\n");
 	spin_unlock_irqrestore(&xpd->lock, flags);
-	if (len <= off + count)
-		*eof = 1;
-	*start = page + off;
-	len -= off;
-	if (len > count)
-		len = count;
-	if (len < 0)
-		len = 0;
-	return len;
+	return 0;
 }
+
+static int proc_bri_info_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, proc_bri_info_show, PDE_DATA(inode));
+}
+
+static const struct file_operations proc_bri_info_ops = {
+	.owner		= THIS_MODULE,
+	.open		= proc_bri_info_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
 #endif
 
 static int bri_xpd_probe(struct device *dev)

drivers/dahdi/xpp/card_fxo.c

@@ -24,6 +24,8 @@
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/delay.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include "xpd.h"
 #include "xproto.h"
 #include "xpp_dahdi.h"
@@ -36,6 +38,10 @@ static const char rcsid[] = "$Id$";
 static DEF_PARM(int, debug, 0, 0644, "Print DBG statements");
 static DEF_PARM(uint, poll_battery_interval, 500, 0644,
 		"Poll battery interval in milliseconds (0 - disable)");
+static DEF_PARM_BOOL(use_polrev_firmware, 1, 0444,
+		"Use firmware reports of polarity reversal");
+static DEF_PARM_BOOL(squelch_polrev, 0, 0644,
+		"Never report polarity reversal");
 #ifdef	WITH_METERING
 static DEF_PARM(uint, poll_metering_interval, 500, 0644,
 		"Poll metering interval in milliseconds (0 - disable)");
@@ -43,7 +49,11 @@ static DEF_PARM(uint, poll_metering_interval, 500, 0644,
 static DEF_PARM(int, ring_debounce, 50, 0644,
 		"Number of ticks to debounce a false RING indication");
 static DEF_PARM(int, caller_id_style, 0, 0444,
-		"Caller-Id detection style: 0 - [BELL], 1 - [ETSI_FSK], 2 - [ETSI_DTMF]");
+		"Caller-Id detection style: "
+		"0 - [BELL], "
+		"1 - [ETSI_FSK], "
+		"2 - [ETSI_DTMF], "
+		"3 - [PASSTHROUGH]");
 static DEF_PARM(int, power_denial_safezone, 650, 0644,
 		"msec after offhook to ignore power-denial ( (0 - disable power-denial)");
 static DEF_PARM(int, power_denial_minlen, 80, 0644,
@@ -57,6 +67,8 @@ enum cid_style {
 	CID_STYLE_BELL = 0,	/* E.g: US (Bellcore) */
 	CID_STYLE_ETSI_FSK = 1,	/* E.g: UK (British Telecom) */
 	CID_STYLE_ETSI_DTMF = 2,	/* E.g: DK, Russia */
+	CID_STYLE_PASSTHROUGH = 3,	/* No change: Let asterisk  */
+					/* (>= 1.8) DSP handle this */
 };
 
 /* Signaling is opposite (fxs signalling for fxo card) */
@@ -95,14 +107,13 @@ enum fxo_leds {
 static bool fxo_packet_is_valid(xpacket_t *pack);
 static void fxo_packet_dump(const char *msg, xpacket_t *pack);
 #ifdef CONFIG_PROC_FS
-static int proc_fxo_info_read(char *page, char **start, off_t off, int count,
-			      int *eof, void *data);
+static const struct file_operations proc_fxo_info_ops;
 #ifdef	WITH_METERING
-static int proc_xpd_metering_read(char *page, char **start, off_t off,
-				  int count, int *eof, void *data);
+static const struct file_operations proc_xpd_metering_ops;
 #endif
 #endif
 static void dahdi_report_battery(xpd_t *xpd, lineno_t chan);
+static void report_polarity_reversal(xpd_t *xpd, xportno_t portno, char *msg);
 
 #define	PROC_REGISTER_FNAME	"slics"
 #define	PROC_FXO_INFO_FNAME	"fxo_info"
@@ -110,6 +121,10 @@ static void dahdi_report_battery(xpd_t *xpd, lineno_t chan);
 #define	PROC_METERING_FNAME	"metering_read"
 #endif
 
+#define	REG_INTERRUPT_SRC	0x04	/*  4 -  Interrupt Source  */
+#define	REG_INTERRUPT_SRC_POLI	BIT(0)	/*  Polarity Reversal Detect Interrupt*/
+#define	REG_INTERRUPT_SRC_RING	BIT(7)	/*  Ring Detect Interrupt */
+
 #define	REG_DAA_CONTROL1	0x05	/*  5 -  DAA Control 1  */
 #define	REG_DAA_CONTROL1_OH	BIT(0)	/* Off-Hook.            */
 #define	REG_DAA_CONTROL1_ONHM	BIT(3)	/* On-Hook Line Monitor */
@@ -148,6 +163,9 @@ struct FXO_priv_data {
 	ushort nobattery_debounce[CHANNELS_PERXPD];
 	enum polarity_state polarity[CHANNELS_PERXPD];
 	ushort polarity_debounce[CHANNELS_PERXPD];
+	int  polarity_last_interval[CHANNELS_PERXPD];
+#define	POLARITY_LAST_INTERVAL_NONE	(-1)
+#define	POLARITY_LAST_INTERVAL_MAX	40
 	enum power_state power[CHANNELS_PERXPD];
 	ushort power_denial_delay[CHANNELS_PERXPD];
 	ushort power_denial_length[CHANNELS_PERXPD];
@@ -345,6 +363,7 @@ static void mark_ring(xpd_t *xpd, lineno_t pos, bool on, bool update_dahdi)
 			MARK_BLINK(priv, pos, LED_GREEN, 0);
 		if (update_dahdi)
 			update_dahdi_ring(xpd, pos, on);
+		priv->polarity_last_interval[pos] = POLARITY_LAST_INTERVAL_NONE;
 	}
 }
 
@@ -382,8 +401,14 @@ static int do_sethook(xpd_t *xpd, int pos, bool to_offhook)
 	    DAA_DIRECT_REQUEST(xbus, xpd, pos, DAA_WRITE, REG_DAA_CONTROL1,
 			       value);
 	mark_offhook(xpd, pos, to_offhook);
-	if (caller_id_style != CID_STYLE_ETSI_DTMF)
+	switch (caller_id_style) {
+	case CID_STYLE_ETSI_DTMF:
+	case CID_STYLE_PASSTHROUGH:
+		break;
+	default:
 		oht_pcm(xpd, pos, 0);
+		break;
+	}
 #ifdef	WITH_METERING
 	priv->metering_count[pos] = 0;
 	priv->metering_tone_state = 0L;
@@ -415,7 +440,6 @@ static void fxo_proc_remove(xbus_t *xbus, xpd_t *xpd)
 #ifdef	WITH_METERING
 	if (priv->meteringfile) {
 		XPD_DBG(PROC, xpd, "Removing xpd metering tone file\n");
-		priv->meteringfile->data = NULL;
 		remove_proc_entry(PROC_METERING_FNAME, xpd->proc_xpd_dir);
 		priv->meteringfile = NULL;
 	}
@@ -436,9 +460,9 @@ static int fxo_proc_create(xbus_t *xbus, xpd_t *xpd)
 	priv = xpd->priv;
 #ifdef	CONFIG_PROC_FS
 	XPD_DBG(PROC, xpd, "Creating FXO_INFO file\n");
-	priv->fxo_info =
-	    create_proc_read_entry(PROC_FXO_INFO_FNAME, 0444, xpd->proc_xpd_dir,
-				   proc_fxo_info_read, xpd);
+	priv->fxo_info = proc_create_data(PROC_FXO_INFO_FNAME, 0444,
+					  xpd->proc_xpd_dir,
+					  &proc_fxo_info_ops, xpd);
 	if (!priv->fxo_info) {
 		XPD_ERR(xpd, "Failed to create proc file '%s'\n",
 			PROC_FXO_INFO_FNAME);
@@ -448,9 +472,9 @@ static int fxo_proc_create(xbus_t *xbus, xpd_t *xpd)
 	SET_PROC_DIRENTRY_OWNER(priv->fxo_info);
 #ifdef	WITH_METERING
 	XPD_DBG(PROC, xpd, "Creating Metering tone file\n");
-	priv->meteringfile =
-	    create_proc_read_entry(PROC_METERING_FNAME, 0444, xpd->proc_xpd_dir,
-				   proc_xpd_metering_read, xpd);
+	priv->meteringfile = proc_create_data(PROC_METERING_FNAME, 0444,
+					      xpd->proc_xpd_dir,
+					      &proc_xpd_metering_ops, xpd);
 	if (!priv->meteringfile) {
 		XPD_ERR(xpd, "Failed to create proc file '%s'\n",
 			PROC_METERING_FNAME);
@@ -513,8 +537,13 @@ static int FXO_card_init(xbus_t *xbus, xpd_t *xpd)
 		priv->battery[i] = BATTERY_UNKNOWN;
 		/* will be updated on next battery sample */
 		priv->power[i] = POWER_UNKNOWN;
-		if (caller_id_style == CID_STYLE_ETSI_DTMF)
+		switch (caller_id_style) {
+		case CID_STYLE_ETSI_DTMF:
+		case CID_STYLE_PASSTHROUGH:
 			oht_pcm(xpd, i, 1);
+			break;
+		}
+		priv->polarity_last_interval[i] = POLARITY_LAST_INTERVAL_NONE;
 	}
 	XPD_DBG(GENERAL, xpd, "done\n");
 	for_each_line(xpd, i) {
@@ -684,6 +713,19 @@ static void handle_fxo_ring(xpd_t *xpd)
 
 	priv = xpd->priv;
 	for_each_line(xpd, i) {
+		if (likely(use_polrev_firmware)) {
+			int *t = &priv->polarity_last_interval[i];
+			if (*t != POLARITY_LAST_INTERVAL_NONE) {
+				(*t)++;
+				if (*t > POLARITY_LAST_INTERVAL_MAX) {
+					LINE_DBG(SIGNAL, xpd, i,
+						"polrev(GOOD): %d msec\n", *t);
+					*t = POLARITY_LAST_INTERVAL_NONE;
+					report_polarity_reversal(xpd,
+								i, "firmware");
+				}
+			}
+		}
 		if (atomic_read(&priv->ring_debounce[i]) > 0) {
 			/* Maybe start ring */
 			if (atomic_dec_and_test(&priv->ring_debounce[i]))
@@ -799,9 +841,9 @@ static void check_etsi_dtmf(xpd_t *xpd)
 					priv->cidtimer[portno] = timer_count;
 					BIT_SET(priv->cidfound, portno);
 					LINE_DBG(SIGNAL, xpd, portno,
-						 "Found DTMF CLIP (%d)\n", i);
-					dahdi_qevent_lock(chan,
-							  DAHDI_EVENT_POLARITY);
+						"Found DTMF CLIP (%d)\n", i);
+					report_polarity_reversal(xpd, portno,
+							"fake");
 					break;
 				}
 			}
@@ -951,6 +993,28 @@ HANDLER_DEF(FXO, SIG_CHANGED)
 	return 0;
 }
 
+static void report_polarity_reversal(xpd_t *xpd, xportno_t portno, char *msg)
+{
+	/*
+	 * Inform dahdi/Asterisk:
+	 * 1. Maybe used for hangup detection during offhook
+	 * 2. In some countries used to report caller-id
+	 *    during onhook but before first ring.
+	 */
+	if (caller_id_style == CID_STYLE_ETSI_FSK)
+		/* will be cleared on ring/offhook */
+		oht_pcm(xpd, portno, 1);
+	if (SPAN_REGISTERED(xpd)) {
+		LINE_DBG(SIGNAL, xpd, portno,
+			"%s DAHDI_EVENT_POLARITY (%s)\n",
+			(squelch_polrev) ? "Squelch" : "Send",
+			msg);
+		if (!squelch_polrev)
+			dahdi_qevent_lock(XPD_CHAN(xpd, portno),
+				DAHDI_EVENT_POLARITY);
+	}
+}
+
 static void update_battery_voltage(xpd_t *xpd, __u8 data_low,
 	xportno_t portno)
 {
@@ -1048,22 +1112,8 @@ static void update_battery_voltage(xpd_t *xpd, __u8 data_low,
 				BUG();
 			LINE_DBG(SIGNAL, xpd, portno,
 				 "Polarity changed to %s\n", polname);
-			/*
-			 * Inform dahdi/Asterisk:
-			 * 1. Maybe used for hangup detection during offhook
-			 * 2. In some countries used to report caller-id
-			 *    during onhook but before first ring.
-			 */
-			if (caller_id_style == CID_STYLE_ETSI_FSK)
-				/* will be cleared on ring/offhook */
-				oht_pcm(xpd, portno, 1);
-			if (SPAN_REGISTERED(xpd)) {
-				LINE_DBG(SIGNAL, xpd, portno,
-					 "Send DAHDI_EVENT_POLARITY: %s\n",
-					 polname);
-				dahdi_qevent_lock(XPD_CHAN(xpd, portno),
-						  DAHDI_EVENT_POLARITY);
-			}
+			if (!use_polrev_firmware)
+				report_polarity_reversal(xpd, portno, polname);
 		}
 		priv->polarity[portno] = pol;
 	}
@@ -1146,6 +1196,50 @@ static void update_metering_state(xpd_t *xpd, __u8 data_low, lineno_t portno)
 }
 #endif
 
+static void got_chip_interrupt(xpd_t *xpd, __u8 data_low,
+	xportno_t portno)
+{
+	struct FXO_priv_data *priv;
+	int t;
+
+	if (!use_polrev_firmware)
+		return;
+	priv = xpd->priv;
+	LINE_DBG(SIGNAL, xpd, portno, "mask=0x%X\n", data_low);
+	if (!(data_low & REG_INTERRUPT_SRC_POLI))
+		return;
+	t = priv->polarity_last_interval[portno];
+	if (PHONEDEV(xpd).ringing[portno]) {
+		priv->polarity_last_interval[portno] =
+			POLARITY_LAST_INTERVAL_NONE;
+		LINE_DBG(SIGNAL, xpd, portno,
+			"polrev(false): %d msec (while ringing)\n", t);
+	} else if (data_low & REG_INTERRUPT_SRC_RING) {
+		priv->polarity_last_interval[portno] =
+			POLARITY_LAST_INTERVAL_NONE;
+		LINE_DBG(SIGNAL, xpd, portno,
+			"polrev(false): %d msec (with chip-interrupt ring)\n",
+			t);
+	} else if (t == POLARITY_LAST_INTERVAL_NONE) {
+		priv->polarity_last_interval[portno] = 0;
+		LINE_DBG(SIGNAL, xpd, portno,
+			"polrev(start)\n");
+	} else if (t < POLARITY_LAST_INTERVAL_MAX) {
+		/*
+		 * Start counting upward from -POLARITY_LAST_INTERVAL_MAX
+		 * Until we reach POLARITY_LAST_INTERVAL_NONE.
+		 * This way we filter bursts of false reports we get
+		 * during ringing.
+		 */
+		priv->polarity_last_interval[portno] =
+			POLARITY_LAST_INTERVAL_NONE -
+			POLARITY_LAST_INTERVAL_MAX;
+		LINE_DBG(SIGNAL, xpd, portno,
+			"polrev(false): %d msec (interval shorter than %d)\n",
+			t, POLARITY_LAST_INTERVAL_MAX);
+	}
+}
+
 static int FXO_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info)
 {
 	struct FXO_priv_data *priv;
@@ -1155,6 +1249,9 @@ static int FXO_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info)
 	BUG_ON(!priv);
 	portno = info->portnum;
 	switch (REG_FIELD(info, regnum)) {
+	case REG_INTERRUPT_SRC:
+		got_chip_interrupt(xpd, REG_FIELD(info, data_low), portno);
+		break;
 	case DAA_REG_VBAT:
 		update_battery_voltage(xpd, REG_FIELD(info, data_low), portno);
 		break;
@@ -1249,12 +1346,10 @@ static void fxo_packet_dump(const char *msg, xpacket_t *pack)
 /*------------------------- DAA Handling --------------------------*/
 
 #ifdef	CONFIG_PROC_FS
-static int proc_fxo_info_read(char *page, char **start, off_t off, int count,
-			      int *eof, void *data)
+static int proc_fxo_info_show(struct seq_file *sfile, void *not_used)
 {
-	int len = 0;
 	unsigned long flags;
-	xpd_t *xpd = data;
+	xpd_t *xpd = sfile->private;
 	struct FXO_priv_data *priv;
 	int i;
 
@@ -1263,42 +1358,43 @@ static int proc_fxo_info_read(char *page, char **start, off_t off, int count,
 	spin_lock_irqsave(&xpd->lock, flags);
 	priv = xpd->priv;
 	BUG_ON(!priv);
-	len += sprintf(page + len, "\t%-17s: ", "Channel");
+	seq_printf(sfile, "\t%-17s: ", "Channel");
 	for_each_line(xpd, i) {
 		if (!IS_SET(PHONEDEV(xpd).digital_outputs, i)
-		    && !IS_SET(PHONEDEV(xpd).digital_inputs, i))
-			len += sprintf(page + len, "%4d ", i % 10);
+		    && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) {
+			seq_printf(sfile, "%4d ", i % 10);
+		}
 	}
-	len += sprintf(page + len, "\nLeds:");
-	len += sprintf(page + len, "\n\t%-17s: ", "state");
+	seq_printf(sfile, "\nLeds:");
+	seq_printf(sfile, "\n\t%-17s: ", "state");
 	for_each_line(xpd, i) {
 		if (!IS_SET(PHONEDEV(xpd).digital_outputs, i)
-		    && !IS_SET(PHONEDEV(xpd).digital_inputs, i))
-			len +=
-			    sprintf(page + len, "  %d%d ",
-				    IS_SET(priv->ledstate[LED_GREEN], i),
-				    IS_SET(priv->ledstate[LED_RED], i));
+		    && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) {
+			seq_printf(sfile, "  %d%d ",
+				   IS_SET(priv->ledstate[LED_GREEN], i),
+				   IS_SET(priv->ledstate[LED_RED], i));
+		}
 	}
-	len += sprintf(page + len, "\n\t%-17s: ", "blinking");
+	seq_printf(sfile, "\n\t%-17s: ", "blinking");
 	for_each_line(xpd, i) {
 		if (!IS_SET(PHONEDEV(xpd).digital_outputs, i)
-		    && !IS_SET(PHONEDEV(xpd).digital_inputs, i))
-			len +=
-			    sprintf(page + len, "  %d%d ",
-				    IS_BLINKING(priv, i, LED_GREEN),
-				    IS_BLINKING(priv, i, LED_RED));
+		    && !IS_SET(PHONEDEV(xpd).digital_inputs, i)) {
+			seq_printf(sfile, "  %d%d ",
+				   IS_BLINKING(priv, i, LED_GREEN),
+				   IS_BLINKING(priv, i, LED_RED));
+		}
 	}
-	len += sprintf(page + len, "\nBattery-Data:");
-	len += sprintf(page + len, "\n\t%-17s: ", "voltage");
+	seq_printf(sfile, "\nBattery-Data:");
+	seq_printf(sfile, "\n\t%-17s: ", "voltage");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%4d ", priv->battery_voltage[i]);
+		seq_printf(sfile, "%4d ", priv->battery_voltage[i]);
 	}
-	len += sprintf(page + len, "\n\t%-17s: ", "current");
+	seq_printf(sfile, "\n\t%-17s: ", "current");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%4d ", priv->battery_current[i]);
+		seq_printf(sfile, "%4d ", priv->battery_current[i]);
 	}
-	len += sprintf(page + len, "\nBattery:");
-	len += sprintf(page + len, "\n\t%-17s: ", "on");
+	seq_printf(sfile, "\nBattery:");
+	seq_printf(sfile, "\n\t%-17s: ", "on");
 	for_each_line(xpd, i) {
 		char *bat;
 
@@ -1308,14 +1404,14 @@ static int proc_fxo_info_read(char *page, char **start, off_t off, int count,
 			bat = "-";
 		else
 			bat = ".";
-		len += sprintf(page + len, "%4s ", bat);
+		seq_printf(sfile, "%4s ", bat);
 	}
-	len += sprintf(page + len, "\n\t%-17s: ", "debounce");
+	seq_printf(sfile, "\n\t%-17s: ", "debounce");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%4d ", priv->nobattery_debounce[i]);
+		seq_printf(sfile, "%4d ", priv->nobattery_debounce[i]);
 	}
-	len += sprintf(page + len, "\nPolarity-Reverse:");
-	len += sprintf(page + len, "\n\t%-17s: ", "polarity");
+	seq_printf(sfile, "\nPolarity-Reverse:");
+	seq_printf(sfile, "\n\t%-17s: ", "polarity");
 	for_each_line(xpd, i) {
 		char *polname;
 
@@ -1325,14 +1421,14 @@ static int proc_fxo_info_read(char *page, char **start, off_t off, int count,
 			polname = "-";
 		else
 			polname = ".";
-		len += sprintf(page + len, "%4s ", polname);
+		seq_printf(sfile, "%4s ", polname);
 	}
-	len += sprintf(page + len, "\n\t%-17s: ", "debounce");
+	seq_printf(sfile, "\n\t%-17s: ", "debounce");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%4d ", priv->polarity_debounce[i]);
+		seq_printf(sfile, "%4d ", priv->polarity_debounce[i]);
 	}
-	len += sprintf(page + len, "\nPower-Denial:");
-	len += sprintf(page + len, "\n\t%-17s: ", "power");
+	seq_printf(sfile, "\nPower-Denial:");
+	seq_printf(sfile, "\n\t%-17s: ", "power");
 	for_each_line(xpd, i) {
 		char *curr;
 
@@ -1342,45 +1438,46 @@ static int proc_fxo_info_read(char *page, char **start, off_t off, int count,
 			curr = "-";
 		else
 			curr = ".";
-		len += sprintf(page + len, "%4s ", curr);
+		seq_printf(sfile, "%4s ", curr);
 	}
-	len += sprintf(page + len, "\n\t%-17s: ", "safezone");
+	seq_printf(sfile, "\n\t%-17s: ", "safezone");
 	for_each_line(xpd, i) {
-		len +=
-		    sprintf(page + len, "%4d ", priv->power_denial_safezone[i]);
+		seq_printf(sfile, "%4d ", priv->power_denial_safezone[i]);
 	}
-	len += sprintf(page + len, "\n\t%-17s: ", "delay");
+	seq_printf(sfile, "\n\t%-17s: ", "delay");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%4d ", priv->power_denial_delay[i]);
+		seq_printf(sfile, "%4d ", priv->power_denial_delay[i]);
 	}
 #ifdef	WITH_METERING
-	len += sprintf(page + len, "\nMetering:");
-	len += sprintf(page + len, "\n\t%-17s: ", "count");
+	seq_printf(sfile, "\nMetering:");
+	seq_printf(sfile, "\n\t%-17s: ", "count");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%4d ", priv->metering_count[i]);
+		seq_printf(sfile, "%4d ", priv->metering_count[i]);
 	}
 #endif
-	len += sprintf(page + len, "\n");
+	seq_printf(sfile, "\n");
 	spin_unlock_irqrestore(&xpd->lock, flags);
-	if (len <= off + count)
-		*eof = 1;
-	*start = page + off;
-	len -= off;
-	if (len > count)
-		len = count;
-	if (len < 0)
-		len = 0;
-	return len;
+	return 0;
 }
-#endif
+
+static int proc_fxo_info_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, proc_fxo_info_show, PDE_DATA(inode));
+}
+
+static const struct file_operations proc_fxo_info_ops = {
+	.owner		= THIS_MODULE,
+	.open		= proc_fxo_info_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
 
 #ifdef	WITH_METERING
-static int proc_xpd_metering_read(char *page, char **start, off_t off,
-				  int count, int *eof, void *data)
+static int proc_xpd_metering_show(struct seq_file *sfile, void *not_used)
 {
-	int len = 0;
 	unsigned long flags;
-	xpd_t *xpd = data;
+	xpd_t *xpd = sfile->private;
 	struct FXO_priv_data *priv;
 	int i;
 
@@ -1389,25 +1486,31 @@ static int proc_xpd_metering_read(char *page, char **start, off_t off,
 	priv = xpd->priv;
 	BUG_ON(!priv);
 	spin_lock_irqsave(&xpd->lock, flags);
-	len += sprintf(page + len, "# Chan\tMeter (since last read)\n");
+	seq_printf(sfile, "# Chan\tMeter (since last read)\n");
 	for_each_line(xpd, i) {
-		len +=
-		    sprintf(page + len, "%d\t%d\n", i, priv->metering_count[i]);
+		seq_printf(sfile, "%d\t%d\n", i, priv->metering_count[i]);
 	}
 	spin_unlock_irqrestore(&xpd->lock, flags);
-	if (len <= off + count)
-		*eof = 1;
-	*start = page + off;
-	len -= off;
-	if (len > count)
-		len = count;
-	if (len < 0)
-		len = 0;
 	/* Zero meters */
 	for_each_line(xpd, i)
 	    priv->metering_count[i] = 0;
-	return len;
+	return 0;
 }
+
+static int proc_xpd_metering_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, proc_xpd_metering_show, PDE_DATA(inode));
+}
+
+static const struct file_operations proc_xpd_metering_ops = {
+	.owner		= THIS_MODULE,
+	.open		= proc_xpd_metering_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
+
+#endif
 #endif
 
 static DEVICE_ATTR_READER(fxo_battery_show, dev, buf)

drivers/dahdi/xpp/card_fxs.c

@@ -24,6 +24,7 @@
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/delay.h>
+#include <linux/seq_file.h>
 #include "xpd.h"
 #include "xproto.h"
 #include "xpp_dahdi.h"
@@ -120,11 +121,9 @@ enum fxs_state {
 static bool fxs_packet_is_valid(xpacket_t *pack);
 static void fxs_packet_dump(const char *msg, xpacket_t *pack);
 #ifdef CONFIG_PROC_FS
-static int proc_fxs_info_read(char *page, char **start, off_t off, int count,
-			      int *eof, void *data);
+static const struct file_operations proc_fxs_info_ops;
 #ifdef	WITH_METERING
-static int proc_xpd_metering_write(struct file *file,
-	const char __user *buffer, unsigned long count, void *data);
+static const struct file_operations proc_xpd_metering_ops;
 #endif
 #endif
 static void start_stop_vm_led(xbus_t *xbus, xpd_t *xpd, lineno_t pos);
@@ -399,7 +398,6 @@ static void fxs_proc_remove(xbus_t *xbus, xpd_t *xpd)
 #ifdef	WITH_METERING
 	if (priv->meteringfile) {
 		XPD_DBG(PROC, xpd, "Removing xpd metering tone file\n");
-		priv->meteringfile->data = NULL;
 		remove_proc_entry(PROC_METERING_FNAME, xpd->proc_xpd_dir);
 		priv->meteringfile = NULL;
 	}
@@ -421,9 +419,9 @@ static int fxs_proc_create(xbus_t *xbus, xpd_t *xpd)
 
 #ifdef	CONFIG_PROC_FS
 	XPD_DBG(PROC, xpd, "Creating FXS_INFO file\n");
-	priv->fxs_info =
-	    create_proc_read_entry(PROC_FXS_INFO_FNAME, 0444, xpd->proc_xpd_dir,
-				   proc_fxs_info_read, xpd);
+	priv->fxs_info = proc_create_data(PROC_FXS_INFO_FNAME, 0444,
+					  xpd->proc_xpd_dir,
+					  &proc_fxs_info_ops, xpd);
 	if (!priv->fxs_info) {
 		XPD_ERR(xpd, "Failed to create proc file '%s'\n",
 			PROC_FXS_INFO_FNAME);
@@ -433,18 +431,15 @@ static int fxs_proc_create(xbus_t *xbus, xpd_t *xpd)
 	SET_PROC_DIRENTRY_OWNER(priv->fxs_info);
 #ifdef	WITH_METERING
 	XPD_DBG(PROC, xpd, "Creating Metering tone file\n");
-	priv->meteringfile =
-	    create_proc_entry(PROC_METERING_FNAME, 0200, xpd->proc_xpd_dir);
+	priv->meteringfile = proc_create_data(PROC_METERING_FNAME, 0200,
+					      xpd->proc_xpd_dir,
+					      &proc_xpd_metering_ops, xpd);
 	if (!priv->meteringfile) {
 		XPD_ERR(xpd, "Failed to create proc file '%s'\n",
 			PROC_METERING_FNAME);
 		fxs_proc_remove(xbus, xpd);
 		return -EINVAL;
 	}
-	SET_PROC_DIRENTRY_OWNER(priv->meteringfile);
-	priv->meteringfile->write_proc = proc_xpd_metering_write;
-	priv->meteringfile->read_proc = NULL;
-	priv->meteringfile->data = xpd;
 #endif
 #endif
 	return 0;
@@ -659,6 +654,95 @@ static void __do_mute_dtmf(xpd_t *xpd, int pos, bool muteit)
 	CALL_PHONE_METHOD(card_pcm_recompute, xpd, priv->search_fsk_pattern);
 }
 
+struct ring_reg_param {
+	int is_indirect;
+	int regno;
+	uint8_t h_val;
+	uint8_t l_val;
+};
+
+enum ring_types {
+	RING_TYPE_NEON = 0,
+	RING_TYPE_TRAPEZ,
+	RING_TYPE_NORMAL,
+};
+
+struct byte_pair {
+	uint8_t h_val;
+	uint8_t l_val;
+};
+
+struct ring_reg_params {
+	const int is_indirect;
+	const int regno;
+	struct byte_pair values[1 + RING_TYPE_NORMAL - RING_TYPE_NEON];
+};
+
+#define	REG_ENTRY(di, reg, vh1, vl1, vh2, vl2, vh3, vl3) \
+	{ (di), (reg), .values = { \
+		[RING_TYPE_NEON]	= { .h_val = (vh1), .l_val = (vl1) }, \
+		[RING_TYPE_TRAPEZ]	= { .h_val = (vh2), .l_val = (vl2) }, \
+		[RING_TYPE_NORMAL]	= { .h_val = (vh3), .l_val = (vl3) }, \
+		}, \
+	}
+
+static struct ring_reg_params ring_parameters[] = {
+	/*        INDIR REG     NEON            TRAPEZ          NORMAL */
+	REG_ENTRY(1,	0x16,	0xE8, 0x03,	0xC8, 0x00,	0x00, 0x00),
+	REG_ENTRY(1,	0x15,	0xEF, 0x7B,	0xAB, 0x5E,	0x77, 0x01),
+	REG_ENTRY(1,	0x14,	0x9F, 0x00,	0x8C, 0x01,	0xFD, 0x7E),
+
+	REG_ENTRY(0,	0x22,	0x00, 0x19,	0x00, 0x01,	0x00, 0x00),
+
+	REG_ENTRY(0,	0x30,	0x00, 0xE0,	0x00, 0x00,	0x00, 0x00),
+	REG_ENTRY(0,	0x31,	0x00, 0x01,	0x00, 0x00,	0x00, 0x00),
+	REG_ENTRY(0,	0x32,	0x00, 0xF0,	0x00, 0x00,	0x00, 0x00),
+	REG_ENTRY(0,	0x33,	0x00, 0x05,	0x00, 0x00,	0x00, 0x00),
+
+	REG_ENTRY(1,	0x1D,	0x00, 0x46,	0x00, 0x36,	0x00, 0x36),
+};
+
+static int send_ring_parameters(xbus_t *xbus, xpd_t *xpd, int pos,
+		enum ring_types rtype)
+{
+	const struct ring_reg_params *p;
+	const struct byte_pair *v;
+	int ret = 0;
+	int i;
+
+	if (rtype < RING_TYPE_NEON || rtype > RING_TYPE_NORMAL)
+		return -EINVAL;
+	for (i = 0; i < ARRAY_SIZE(ring_parameters); i++) {
+		p = &ring_parameters[i];
+		v = &(p->values[rtype]);
+		if (p->is_indirect) {
+			LINE_DBG(REGS, xpd, pos,
+					"[%d] 0x%02X: I 0x%02X 0x%02X\n",
+					i, p->regno, v->h_val, v->l_val);
+			ret = SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE,
+				p->regno, v->h_val, v->l_val);
+			if (ret < 0) {
+				LINE_ERR(xpd, pos,
+					"Failed: 0x%02X: I 0x%02X, 0x%02X\n",
+					p->regno, v->h_val, v->l_val);
+				break;
+			}
+		} else {
+			LINE_DBG(REGS, xpd, pos, "[%d] 0x%02X: D 0x%02X\n",
+				i, p->regno, v->l_val);
+			ret = SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE,
+				p->regno, v->l_val);
+			if (ret < 0) {
+				LINE_ERR(xpd, pos,
+					"Failed: 0x%02X: D 0x%02X\n",
+					p->regno, v->l_val);
+				break;
+			}
+		}
+	}
+	return ret;
+}
+
 static int set_vm_led_mode(xbus_t *xbus, xpd_t *xpd, int pos,
 			   unsigned int msg_waiting)
 {
@@ -672,81 +756,15 @@ static int set_vm_led_mode(xbus_t *xbus, xpd_t *xpd, int pos,
 		/* A write to register 0x40 will now turn on/off the VM led */
 		LINE_DBG(SIGNAL, xpd, pos, "NEON\n");
 		BIT_SET(priv->neon_blinking, pos);
-		ret +=
-		    SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x16,
-					  0xE8, 0x03);
-		ret +=
-		    SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x15,
-					  0xEF, 0x7B);
-		ret +=
-		    SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x14,
-					  0x9F, 0x00);
-		ret +=
-		    SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x22, 0x19);
-		ret +=
-		    SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x30, 0xE0);
-		ret +=
-		    SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x31, 0x01);
-		ret +=
-		    SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x32, 0xF0);
-		ret +=
-		    SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x33, 0x05);
-		ret +=
-		    SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x1D,
-					  0x00, 0x46);
+		ret = send_ring_parameters(xbus, xpd, pos, RING_TYPE_NEON);
 	} else if (ring_trapez) {
 		LINE_DBG(SIGNAL, xpd, pos, "RINGER: Trapez ring\n");
-		ret +=
-		    SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x16,
-					  0xC8, 0x00);
-		ret +=
-		    SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x15,
-					  0xAB, 0x5E);
-		ret +=
-		    SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x14,
-					  0x8C, 0x01);
-		ret +=
-		    SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x22, 0x01);
-		ret +=
-		    SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x4A, 0x34);
-		ret +=
-		    SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x30, 0x00);
-		ret +=
-		    SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x31, 0x00);
-		ret +=
-		    SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x32, 0x00);
-		ret +=
-		    SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x33, 0x00);
-		ret +=
-		    SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x1D,
-					  0x00, 0x36);
+		ret = send_ring_parameters(xbus, xpd, pos, RING_TYPE_TRAPEZ);
 	} else {
 		/* A write to register 0x40 will now turn on/off the ringer */
 		LINE_DBG(SIGNAL, xpd, pos, "RINGER\n");
 		BIT_CLR(priv->neon_blinking, pos);
-
-		ret += SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE,
-			0x16, 0x00, 0x00);
-		ret += SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE,
-			0x15, 0x77, 0x01);
-		ret += SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE,
-			0x14, 0xFD, 0x7E);
-
-		ret += SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE,
-			0x22, 0x00);
-		ret += SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE,
-			0x30, 0x00);
-		ret += SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE,
-			0x31, 0x00);
-		ret += SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE,
-			0x32, 0x00);
-		ret += SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE,
-			0x33, 0x00);
-		/* High Vbat~ -82V[Dc] */
-		ret += SLIC_DIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE,
-			0x4A, 0x34);
-		ret += SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE,
-			0x1D, 0x00, 0x36);
+		ret = send_ring_parameters(xbus, xpd, pos, RING_TYPE_NORMAL);
 	}
 	return (ret ? -EPROTO : 0);
 }
@@ -1691,12 +1709,10 @@ static void fxs_packet_dump(const char *msg, xpacket_t *pack)
 /*------------------------- SLIC Handling --------------------------*/
 
 #ifdef	CONFIG_PROC_FS
-static int proc_fxs_info_read(char *page, char **start, off_t off, int count,
-			      int *eof, void *data)
+static int proc_fxs_info_show(struct seq_file *sfile, void *not_used)
 {
-	int len = 0;
 	unsigned long flags;
-	xpd_t *xpd = data;
+	xpd_t *xpd = sfile->private;
 	struct FXS_priv_data *priv;
 	int i;
 	int led;
@@ -1706,11 +1722,11 @@ static int proc_fxs_info_read(char *page, char **start, off_t off, int count,
 	spin_lock_irqsave(&xpd->lock, flags);
 	priv = xpd->priv;
 	BUG_ON(!priv);
-	len += sprintf(page + len, "%-12s", "Channel:");
+	seq_printf(sfile, "%-12s", "Channel:");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%4d", i);
+		seq_printf(sfile, "%4d", i);
 	}
-	len += sprintf(page + len, "\n%-12s", "");
+	seq_printf(sfile, "\n%-12s", "");
 	for_each_line(xpd, i) {
 		char *chan_type;
 
@@ -1720,84 +1736,85 @@ static int proc_fxs_info_read(char *page, char **start, off_t off, int count,
 			chan_type = "in";
 		else
 			chan_type = "";
-		len += sprintf(page + len, "%4s", chan_type);
+		seq_printf(sfile, "%4s", chan_type);
 	}
-	len += sprintf(page + len, "\n%-12s", "idletxhook:");
+	seq_printf(sfile, "\n%-12s", "idletxhook:");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%4d", priv->idletxhookstate[i]);
+		seq_printf(sfile, "%4d", priv->idletxhookstate[i]);
 	}
-	len += sprintf(page + len, "\n%-12s", "lasttxhook:");
+	seq_printf(sfile, "\n%-12s", "lasttxhook:");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%4d", priv->lasttxhook[i]);
+		seq_printf(sfile, "%4d", priv->lasttxhook[i]);
 	}
-	len += sprintf(page + len, "\n%-12s", "ohttimer:");
+	seq_printf(sfile, "\n%-12s", "ohttimer:");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%4d", priv->ohttimer[i]);
+		seq_printf(sfile, "%4d", priv->ohttimer[i]);
 	}
-	len += sprintf(page + len, "\n%-12s", "neon_blink:");
+	seq_printf(sfile, "\n%-12s", "neon_blink:");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%4d",
+		seq_printf(sfile, "%4d",
 			    IS_SET(priv->neon_blinking, i));
 	}
-	len += sprintf(page + len, "\n%-12s", "search_fsk:");
+	seq_printf(sfile, "\n%-12s", "search_fsk:");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%4d",
+		seq_printf(sfile, "%4d",
 			    IS_SET(priv->search_fsk_pattern, i));
 	}
-	len += sprintf(page + len, "\n%-12s", "vbat_h:");
+	seq_printf(sfile, "\n%-12s", "vbat_h:");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%4d",
+		seq_printf(sfile, "%4d",
 			test_bit(i, (unsigned long *)&priv->vbat_h));
 	}
-	len += sprintf(page + len, "\n");
+	seq_printf(sfile, "\n");
 	for (led = 0; led < NUM_LEDS; led++) {
-		len += sprintf(page + len, "\nLED #%d\t%-12s: ",
+		seq_printf(sfile, "\nLED #%d\t%-12s: ",
 			led, "ledstate");
 		for_each_line(xpd, i) {
 			if (!IS_SET(PHONEDEV(xpd).digital_outputs, i)
 			    && !IS_SET(PHONEDEV(xpd).digital_inputs, i))
-				len +=
-				    sprintf(page + len, "%d ",
+				seq_printf(sfile, "%d ",
 					    IS_SET(priv->ledstate[led], i));
 		}
-		len += sprintf(page + len, "\nLED #%d\t%-12s: ",
+		seq_printf(sfile, "\nLED #%d\t%-12s: ",
 			led, "ledcontrol");
 		for_each_line(xpd, i) {
 			if (!IS_SET(PHONEDEV(xpd).digital_outputs, i)
 			    && !IS_SET(PHONEDEV(xpd).digital_inputs, i))
-				len +=
-				    sprintf(page + len, "%d ",
+				seq_printf(sfile, "%d ",
 					    IS_SET(priv->ledcontrol[led], i));
 		}
-		len += sprintf(page + len, "\nLED #%d\t%-12s: ",
+		seq_printf(sfile, "\nLED #%d\t%-12s: ",
 			led, "led_counter");
 		for_each_line(xpd, i) {
 			if (!IS_SET(PHONEDEV(xpd).digital_outputs, i)
 			    && !IS_SET(PHONEDEV(xpd).digital_inputs, i))
-				len +=
-				    sprintf(page + len, "%d ",
+				seq_printf(sfile, "%d ",
 					    LED_COUNTER(priv, i, led));
 		}
 	}
-	len += sprintf(page + len, "\n");
+	seq_printf(sfile, "\n");
 	spin_unlock_irqrestore(&xpd->lock, flags);
-	if (len <= off + count)
-		*eof = 1;
-	*start = page + off;
-	len -= off;
-	if (len > count)
-		len = count;
-	if (len < 0)
-		len = 0;
-	return len;
+	return 0;
 }
-#endif
+
+static int proc_fxs_info_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, proc_fxs_info_show, PDE_DATA(inode));
+}
+
+static const struct file_operations proc_fxs_info_ops = {
+	.owner		= THIS_MODULE,
+	.open		= proc_fxs_info_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
 
 #ifdef	WITH_METERING
-static int proc_xpd_metering_write(struct file *file, const char
-		__user *buffer, unsigned long count, void *data)
+static ssize_t proc_xpd_metering_write(struct file *file,
+		const char __user *buffer, size_t count, loff_t *offset)
 {
-	xpd_t *xpd = data;
+	xpd_t *xpd = file->private_data;
 	char buf[MAX_PROC_WRITE];
 	lineno_t chan;
 	int num;
@@ -1806,7 +1823,7 @@ static int proc_xpd_metering_write(struct file *file, const char
 	if (!xpd)
 		return -ENODEV;
 	if (count >= MAX_PROC_WRITE - 1) {
-		XPD_ERR(xpd, "Metering string too long (%lu)\n", count);
+		XPD_ERR(xpd, "Metering string too long (%zu)\n", count);
 		return -EINVAL;
 	}
 	if (copy_from_user(&buf, buffer, count))
@@ -1829,11 +1846,149 @@ static int proc_xpd_metering_write(struct file *file, const char
 	}
 	return count;
 }
+
+static int proc_xpd_metering_open(struct inode *inode, struct file *file)
+{
+	file->private_data = PDE_DATA(inode);
+}
+
+static const struct file_operations proc_xpd_metering_ops = {
+	.owner		= THIS_MODULE,
+	.open		= proc_xpd_metering_open,
+	.write		= proc_xpd_metering_write,
+	.release	= single_release,
+};
 #endif
+#endif
+
+static DEVICE_ATTR_READER(fxs_ring_registers_show, dev, buf)
+{
+	xpd_t *xpd;
+	struct FXS_priv_data *priv;
+	unsigned long flags;
+	const struct ring_reg_params *p;
+	const struct byte_pair *v;
+	enum ring_types rtype;
+	int len = 0;
+	int i;
+
+	BUG_ON(!dev);
+	xpd = dev_to_xpd(dev);
+	if (!xpd)
+		return -ENODEV;
+	priv = xpd->priv;
+	BUG_ON(!priv);
+	spin_lock_irqsave(&xpd->lock, flags);
+	len += sprintf(buf + len, "#   Reg#: D/I\tNEON     \tTRAPEZ   \tNORMAL   \n");
+	for (i = 0; i < ARRAY_SIZE(ring_parameters); i++) {
+		p = &ring_parameters[i];
+		len += sprintf(buf + len, "[%d] 0x%02X: %c",
+			i, p->regno, (p->is_indirect) ? 'I' : 'D');
+		for (rtype = RING_TYPE_NEON; rtype <= RING_TYPE_NORMAL; rtype++) {
+			v = &(p->values[rtype]);
+			if (p->is_indirect)
+				len += sprintf(buf + len, "\t0x%02X 0x%02X",
+					v->h_val, v->l_val);
+			else
+				len += sprintf(buf + len, "\t0x%02X ----",
+					v->l_val);
+		}
+		len += sprintf(buf + len, "\n");
+	}
+	spin_unlock_irqrestore(&xpd->lock, flags);
+	return len;
+}
+
+static DEVICE_ATTR_WRITER(fxs_ring_registers_store, dev, buf, count)
+{
+	xpd_t *xpd;
+	struct FXS_priv_data *priv;
+	unsigned long flags;
+	char rtype_name[MAX_PROC_WRITE];
+	enum ring_types rtype;
+	struct ring_reg_params *params;
+	struct byte_pair *v;
+	int regno;
+	int h_val;
+	int l_val;
+	int ret;
+	int i;
+
+	BUG_ON(!dev);
+	xpd = dev_to_xpd(dev);
+	if (!xpd)
+		return -ENODEV;
+	priv = xpd->priv;
+	BUG_ON(!priv);
+	ret = sscanf(buf, "%10s %X %X %X\n",
+		rtype_name, &regno, &h_val, &l_val);
+	if (ret < 3 || ret > 4) {
+		XPD_ERR(xpd, "Bad input: '%s'\n", buf);
+		XPD_ERR(xpd, "# Correct input\n");
+		XPD_ERR(xpd, "{NEON|TRAPEZ|NORMAL} <regno> <byte> [<byte>]\n");
+		goto invalid_input;
+	}
+	if (strcasecmp("NEON", rtype_name) == 0)
+		rtype = RING_TYPE_NEON;
+	else if (strcasecmp("TRAPEZ", rtype_name) == 0)
+		rtype = RING_TYPE_TRAPEZ;
+	else if (strcasecmp("NORMAL", rtype_name) == 0)
+		rtype = RING_TYPE_NORMAL;
+	else {
+		XPD_ERR(xpd, "Unknown ring type '%s' (NEON/TRAPEZ/NORMAL)\n",
+			rtype_name);
+		goto invalid_input;
+	}
+	params = NULL;
+	for (i = 0; i < ARRAY_SIZE(ring_parameters); i++) {
+		if (ring_parameters[i].regno == regno) {
+			params = &ring_parameters[i];
+			break;
+		}
+	}
+	if (!params) {
+		XPD_ERR(xpd, "Bad register 0x%X\n", regno);
+		goto invalid_input;
+	}
+	if (params->is_indirect) {
+		if (ret != 4) {
+			XPD_ERR(xpd,
+				"Missing low-byte (0x%X is indirect register)\n",
+				regno);
+			goto invalid_input;
+		}
+		XPD_INFO(xpd, "%s Indirect 0x%X <=== 0x%X 0x%X\n",
+			rtype_name, regno, h_val, l_val);
+	} else {
+		if (ret != 3) {
+			XPD_ERR(xpd,
+				"Should give exactly one value (0x%X is direct register)\n",
+				regno);
+			goto invalid_input;
+		}
+		l_val = h_val;
+		h_val = 0;
+		XPD_INFO(xpd, "%s Direct 0x%X <=== 0x%X\n",
+			rtype_name, regno, h_val);
+	}
+	spin_lock_irqsave(&xpd->lock, flags);
+	v = &(params->values[rtype]);
+	v->h_val = h_val;
+	v->l_val = l_val;
+	spin_unlock_irqrestore(&xpd->lock, flags);
+	return count;
+invalid_input:
+	return -EINVAL;
+}
+
+static DEVICE_ATTR(fxs_ring_registers, S_IRUGO | S_IWUSR,
+	fxs_ring_registers_show,
+	fxs_ring_registers_store);
 
 static int fxs_xpd_probe(struct device *dev)
 {
 	xpd_t *xpd;
+	int ret;
 
 	xpd = dev_to_xpd(dev);
 	/* Is it our device? */
@@ -1843,7 +1998,15 @@ static int fxs_xpd_probe(struct device *dev)
 		return -EINVAL;
 	}
 	XPD_DBG(DEVICES, xpd, "SYSFS\n");
+	ret = device_create_file(dev, &dev_attr_fxs_ring_registers);
+	if (ret) {
+		XPD_ERR(xpd, "%s: device_create_file(fxs_ring_registers) failed: %d\n",
+			__func__, ret);
+		goto fail_fxs_ring_registers;
+	}
 	return 0;
+fail_fxs_ring_registers:
+	return ret;
 }
 
 static int fxs_xpd_remove(struct device *dev)
@@ -1852,6 +2015,7 @@ static int fxs_xpd_remove(struct device *dev)
 
 	xpd = dev_to_xpd(dev);
 	XPD_DBG(DEVICES, xpd, "SYSFS\n");
+	device_remove_file(dev, &dev_attr_fxs_ring_registers);
 	return 0;
 }
 

drivers/dahdi/xpp/card_global.c

@@ -511,6 +511,11 @@ HANDLER_DEF(GLOBAL, AB_DESCRIPTION)
 		ret = -EPROTO;
 		goto proto_err;
 	}
+	if (units[0].addr.unit != 0 || units[0].addr.subunit != 0) {
+		XBUS_NOTICE(xbus, "No first module. Astribank unusable.\n");
+		ret = -EPROTO;
+		goto proto_err;
+	}
 	if (!xbus_setstate(xbus, XBUS_STATE_RECVD_DESC)) {
 		ret = -EPROTO;
 		goto proto_err;
@@ -568,6 +573,7 @@ HANDLER_DEF(GLOBAL, AB_DESCRIPTION)
 	}
 	goto out;
 proto_err:
+	xbus_setstate(xbus, XBUS_STATE_FAIL);
 	dump_packet("AB_DESCRIPTION", pack, DBG_ANY);
 out:
 	return ret;

drivers/dahdi/xpp/firmwares/Makefile

@@ -3,7 +3,7 @@
 
 USB_FW		= USB_FW.hex USB_FW.201.hex USB_RECOV.hex
 FPGA_FW		= FPGA_FXS.hex FPGA_1141.hex FPGA_1151.hex FPGA_1161.hex  \
-		  FPGA_1161.201.hex
+		  FPGA_1161.201.hex FPGA_1161.202.hex
 PIC_FW		= PIC_TYPE_1.hex PIC_TYPE_2.hex PIC_TYPE_3.hex PIC_TYPE_4.hex  
 OCT_FW		= $(wildcard OCT6104E-256D.ima)
 FIRMWARES	= $(USB_FW) $(FPGA_FW) $(PIC_FW) $(OCT_FW)
@@ -20,4 +20,7 @@ install:
 	mkdir -p $(TARGET)
 	install $(SCRIPTS) $(TARGET)/
 	install -m 644 ../XppConfig.pm $(FIRMWARES) $(TARGET)/
+	if [ ! -r $(TARGET)/USB_FW.202.hex ]; then \
+		ln -s USB_FW.201.hex $(TARGET)/USB_FW.202.hex;\
+	fi
 

drivers/dahdi/xpp/firmwares/PIC_TYPE_2.hex

@@ -1,7 +1,7 @@
 #        
-# $Id: PIC_TYPE_2.hex 9732 2011-08-24 19:13:55Z dima $
+# $Id: PIC_TYPE_2.hex 11078 2013-04-11 16:52:37Z dima $
 #
-:03000000A57A4896
+:03000000A5DA4836
 :03000100C41C41DB
 :030002000390392F
 :0300030067967984
@@ -42,319 +42,375 @@
 :03002600CFC9013E
 :030027001652026C
 :0300280064403001
-:03002900A3290107
+:03002900A38901A7
 :03002A00704C40D7
-:03002B00A41FFF10
-:03002C00C011659B
-:03002D001E1C0294
-:03002E00C03FFFD1
-:03002F0016115057
-:030030002016B9DE
-:03003100125D025B
-:0300320020A022E9
-:03003300643C0228
-:03003400A3AD0178
-:03003500365162DF
-:030036003652053A
-:030037002C8030EA
-:03003800D00901EB
-:03003900A33204EB
-:03003A0020503023
-:03003B0072490106
-:03003C00A3E2023A
-:03003D00A40030EC
-:03003E0002D901E3
-:03003F00A4180002
-:0300400002E214C5
-:03004100800E70BE
-:030042000223088E
-:030043002063082F
-:030044006433081A
-:03004500A4A30869
-:0300460032203F26
-:030047002C880002
-:03004800D00C00D9
-:03004900A4403997
-:03004A00CFE038CC
-:03004B00162C0769
-:03004C00C01D4094
-:03004D00604034DC
-:03004E00122C0869
-:03004F00206038F6
-:03005000643219FE
-:03005100A56E0792
-:0300520036202035
-:030053002C83609B
-:03005400D0036076
-:03005500A50360A0
-:03005600800360C4
-:03005700C07C105A
-:03005800166038F7
-:03005900743219E5
-:03005A00A5FE07F9
-:03005B00C01120B1
-:03005C001CCC2099
-:03005D00E07180CF
-:03005E0002CE705F
-:03005F00206743D4
-:0300600090AA70F3
-:03006100205C021E
-:03006200D2018048
-:03006300D40E07B1
-:0300640003D6437D
-:03006500C1CA739A
+:03002B00A47FFFB0
+:03002C00C40165A7
+:03002D00150C02AD
+:03002E00743FFF1D
+:03002F00A32150BA
+:03003000C026B92E
+:03003100A33D02EA
+:03003200C01022D9
+:03003300121C029A
+:03003400C03D01CB
+:030035001611623F
+:0300360020120590
+:0300370012503034
+:0300380020A901FB
+:030039006432042A
+:03003A00A40030EF
+:03003B0036590132
+:03003C0036520237
+:03003D002C8030E4
+:03003E00D00901E5
+:03003F00A3980083
+:0300400020521437
+:03004100724E708C
+:03004200A44308CC
+:03004300A46308AB
+:0300440002D308DC
+:03004500A4730899
+:0300460002E03F96
+:030047008008002E
+:03004800022C0087
+:03004900206039FB
+:03004A00643038E7
+:03004B00A50C07FA
+:03004C00322D4012
+:03004D002C8034D0
+:03004E00D00C08CB
+:03004F00A4A03832
+:03005000CFE219E3
+:03005100162E0761
+:03005200C01020BB
+:03005300604360A7
+:0300540012236014
+:03005500206360C5
+:03005600643360B0
+:03005700A5CC1025
+:0300580036203817
+:030059002C8219DD
+:03005A00D00E07BE
+:03005B00A561207C
+:03005C00800C20F5
+:03005D00C07180EF
+:03005E00166E70AB
+:03005F00743743B0
+:03006000A65A702D
+:03006100C01C02BE
+:030062001CC1803E
+:03006300E07E0735
+:0300640002C6438E
+:03006500200A73FB
 :03006600022C0366
-:03006700C0018055
-:03006800024E073E
-:0300690021D6435A
-:03006A00030A7313
-:03006B00901C04E2
-:03006C00202180D0
-:03006D00030E0778
-:03006E00901643A6
-:03006F00204A73B1
-:03007000030C017D
-:03007100901038B4
-:03007200210A72EE
-:03007300024C1824
-:03007400C0303861
-:0300750008421925
-:03007600603E0FDA
-:03007700A7A0221D
-:03007800209C00C9
-:03007900A7C038E5
+:0300670020618095
+:03006800643E07EC
+:03006900A6E643C5
+:03006A00322A73C4
+:03006B002C8C04D6
+:03006C00D0018040
+:03006D00A68E0755
+:03006E00C0164376
+:03006F00142A73DD
+:03007000743C01DC
+:03007100ACB038F8
+:03007200206A728F
+:0300730090AC1836
+:03007400205038E1
+:03007500D202199B
+:03007600D40E0F96
+:0300770003D02291
+:03007800C04C0079
+:030079000220382A
 :03007A00C00200C1
-:03007B00A7CE0706
-:03007C00187F02E8
-:03007D0014974392
-:03007E00643A835E
-:03007F00AABC0018
-:030080001A7031C2
-:03008100C50C1299
-:03008200039A904E
-:030083007992006F
-:03008400A83E078C
-:0300850020BF0396
-:03008600D007435D
-:03008700038A8C5D
-:03008800219C00B8
-:03008900E07031F3
-:03008A00348C189B
-:03008B00348A9024
-:03008C00348C00B1
-:03008D003480318B
-:03008E00030C164A
-:03008F00206A9054
-:0300900034803B7E
-:03009100348E0F9B
-:0300920034808235
-:03009300348703AC
-:03009400D05A9AA5
-:03009500031C0F3A
-:03009600C00FFF99
-:0300970003215BE7
-:030098000331022F
-:03009900C70A9BF8
-:03009A0003921BB3
-:03009B00C500306D
-:03009C00039E0FB1
-:03009D00C1C03BA4
-:03009E00030C024E
-:03009F00C0003965
-:0300A000031C003E
-:0300A100204039C3
-:0300A200032C80AC
+:03007B00024E072B
+:03007C0021DF027F
+:03007D0003074333
+:03007E00901A8352
+:03007F00202C0032
+:0300800003003149
+:03008100901C12BE
+:03008200204A9081
+:0300830003020075
+:03008400901E07C4
+:03008500210F0345
+:03008600E017433D
+:03008700643A8C4C
+:03008800ACBC000D
+:0300890021003122
+:03008A00024C180D
+:03008B00E80A90F0
+:03008C00743C00C1
+:03008D00AB803114
+:03008E00C50C1688
+:03008F00039A9041
+:0300900079903B29
+:03009100A90E0FA6
+:0300920020B08219
+:03009300D0070390
+:03009400038A9A42
+:03009500219C0F9C
+:03009600E07FFF09
+:0300970034815B56
+:03009800348102AE
+:03009900348A9B0B
+:03009A0034821B92
+:03009B000300302F
+:03009C00206E0FC4
+:03009D0034803B71
+:03009E00348C029D
+:03009F0034803971
+:0300A000348C009D
+:0300A100D0503903
+:0300A200031C80BC
 :0300A300C00D0885
-:0300A400033039ED
-:0300A500C70C0085
-:0300A6000390398B
-:0300A700C50C4045
-:0300A80003903989
-:0300A900C407D9B0
-:0300AA00039AA90D
-:0300AB0020CC0066
-:0300AC0074302687
-:0300AD00B1702708
-:0300AE00C0002B64
-:0300AF00024020EC
-:0300B000C05C032E
-:0300B10002202CFE
-:0300B200205C20AF
-:0300B300D20D80EB
-:0300B400D4002550
-:0300B50003DC2049
-:0300B60021D02432
-:0300B700030C0037
-:0300B80090102283
-:0300B900202205FD
-:0300BA0003003010
-:0300BB0090190198
-:0300BC00204204DB
-:0300BD000300300D
-:0300BE0090190195
-:0300BF00C012026A
+:0300A400032039FD
+:0300A500033C0019
+:0300A600C7003957
+:0300A700039C4077
+:0300A800C5003957
+:0300A9000397D9E1
+:0300AA00C04AA9A0
+:0300AB00030C0043
+:0300AC00C000266B
+:0300AD0003102716
+:0300AE0020402BC4
+:0300AF000320200B
+:0300B000C00C037E
+:0300B10003302CED
+:0300B200C70C2058
+:0300B300039D802A
+:0300B400C500255F
+:0300B500039C2089
+:0300B600C400245F
+:0300B700039C00A7
+:0300B800C400225F
+:0300B900FFF2054E
+:0300BA00165030AD
+:0300BB00D2090166
+:0300BC0003D20468
+:0300BD00C0403010
+:0300BE0002290113
+:0300BF00C002027A
 :0300C000150030F8
 :0300C100024901F0
-:0300C20021AC402E
-:0300C3009420394D
-:0300C400202C01EC
-:0300C50003A0375E
-:0300C600206C604B
-:0300C7007432C8C8
-:0300C800AD5AC767
-:0300C900C9FC006F
-:0300CA0016B03736
-:0300CB00C006D993
-:0300CC006B0AD0EC
-:0300CD00D206F95F
-:0300CE006D0B4D6A
+:0300C20021DC40FE
+:0300C300030039FE
+:0300C400901C018C
+:0300C500202037C1
+:0300C600030C60C8
+:0300C7009012C8CC
+:0300C800204AC704
+:0300C900030C0025
+:0300CA009010375C
+:0300CB002066D9D3
+:0300CC0090AAD027
+:0300CD002056F9C1
+:0300CE00D20B4D05
 :0300CF00D40ACB85
-:0300D00012B94022
-:0300D100C80C2038
-:0300D2001AB195CB
-:0300D30020B64311
-:0300D400038ADFBD
-:0300D500206C019B
-:0300D60002A1DFA5
-:0300D700C0409B8B
-:0300D800086703B3
-:0300D900703ADF9B
-:0300DA00ADE7D3BC
-:0300DB00C00B480F
-:0300DC00024CFFD4
-:0300DD00AE202230
-:0300DE00C04B2AEA
-:0300DF000AA21F53
-:0300E000C0290A2A
-:0300E100024C20AE
-:0300E200917125F4
-:0300E300C016D371
-:0300E40003EAEA42
-:0300E500206C206C
-:0300E600643095EE
-:0300E700AEB6436F
-:0300E80037EAF202
-:0300E9002C8AEF6F
-:0300EA00AE8C4099
-:0300EB00C6012526
-:0300EC00150C00F0
-:0300ED0074302448
-:0300EE00AFFB1A4B
-:0300EF0021E217F4
-:0300F0001AF024DF
-:0300F10014FB1AE3
-:0300F200743C401B
-:0300F300B17105E3
-:0300F400C0403DCC
-:0300F500124C00AA
-:0300F600917024E2
-:0300F700C0021D27
-:0300F80002403093
-:0300F900200901DA
-:0300FA0094221538
-:0300FB0020203092
-:0300FC00020901F5
-:0300FD00035204A7
-:0300FE00B17030AE
-:0300FF00CFF90135
-:0301000019E210F1
-:0301010016F024D1
-:03010200C037F70C
-:03010300081B0BCB
-:03010400743C0246
-:03010500B0EFFF59
-:03010600C01164C1
-:03010700024C02A5
-:030108002001577C
-:030109009421241A
-:03010A00202B1790
-:03010B000207D711
-:03010C00035B177B
-:03010D00B17C01C1
-:03010E00C00FFF20
-:03010F0018116460
-:03011000643C014B
-:030111006B015728
-:03011200B14124D4
-:03011300B17B17A6
-:03011400C01217FF
-:0301150012402471
-:03011600917B17C3
-:03011700369C0211
-:03011800C01D0106
-:030119001E616400
-:03011A0021BC8085
-:03011B000866F380
-:03011C0074312516
-:03011D00A57205C3
-:03011E000260304C
-:03011F00C02901F3
-:03012000FFF215D6
-:0301210016B030E5
-:03012200C02901F0
-:0301230023A20410
-:0301240074303004
-:0301250012B9010B
-:0301260020B7D32C
-:03012700038B48FF
-:03012800C44210BE
-:030129000390221E
-:03012A00C40C50B2
-:03012B0003903905
-:03012C00C0079970
-:03012D00023B2C66
-:03012E00AC2212EE
-:03012F00B2F030FB
-:03013000000214B6
-:030131000000319A
-:03013200000213B5
-:0301330000003297
-:03013400000C00BC
-:0301350000003394
-:03013600000C704A
-:030137000000398C
-:03013800000C5068
-:030139000000398A
-:03013A00000215AB
-:03013B0000003091
-:03013C00000C00B4
-:03013D000000318E
-:03013E00000202BA
-:03013F000000328B
-:03014000000C00B0
-:0301410000003388
-:03014200000C703E
-:0301430000003980
-:03014400000C505C
-:030145000000397E
-:03014600000C406A
-:030147000000397C
-:03014800000C00A8
-:030149000000397A
-:03014A00000C00A6
-:03014B00000C00A5
-:03014C00000AC2E4
-:03014D00000C00A3
-:03014E0000002589
-:03014F00000C1091
-:0301500000003D6F
-:030151000009178B
-:03015200000C049A
-:0301530000002584
-:03015400000C009C
-:0301550000003D6A
-:0301560000091786
-:03015700000C0297
-:030158000000257F
-:03015900000C088F
-:03015A0000003D65
-:03015B0000091781
-:03015C00000C0094
-:03015D0000002679
-:03015E00000C0191
-:03015F0000002974
-:03016000000C2070
-:0301610000002378
-:03016200000A0090
-:03016300000B632B
+:0300D00003D94011
+:0300D100C1CC207F
+:0300D20002219573
+:0300D300C0064321
+:0300D400024ADFFE
+:0300D50021DC012A
+:0300D6000301DF44
+:0300D70090109BEB
+:0300D800202703DB
+:0300D900030ADF38
+:0300DA009017D3A9
+:0300DB00204B486F
+:0300DC00030CFF13
+:0300DD009010225E
+:0300DE00210B2AC9
+:0300DF0002421FBB
+:0300E000C0390A1A
+:0300E100084C20A8
+:0300E20060312565
+:0300E300AE66D333
+:0300E400209AEA75
+:0300E500AE8C20BE
+:0300E600C00095C2
+:0300E700AE86439F
+:0300E800187AF291
+:0300E900149AEF77
+:0300EA00643C4033
+:0300EB00B17125CB
+:0300EC001A7C007B
+:0300ED00C5002427
+:0300EE00039B1A57
+:0300EF00799217EC
+:0300F000AEF0244B
+:0300F10020BB1A17
+:0300F200D00C40EF
+:0300F30003810581
+:0300F40021903D1B
+:0300F500E07C00AC
+:0300F6003480242F
+:0300F70034821D33
+:0300F80034803021
+:0300F90034890146
+:0300FA00030215E9
+:0300FB0020603052
+:0300FC0034890143
+:0300FD0034820446
+:0300FE003480301B
+:0300FF0034890140
+:03010000D05210CA
+:03010100031024C4
+:03010200C007F73C
+:03010300032B0BC0
+:03010400033C02B7
+:03010500C70FFF22
+:03010600039164FE
+:03010700C50C0222
+:0301080003915709
+:03010900C1C1244D
+:03010A00030B17CD
+:03010B00C007D753
+:03010C00031B17BB
+:03010D00204C0182
+:03010E00032FFFBD
+:03010F00C00164C8
+:03011000033C01AC
+:03011100C70157CC
+:0301120003912432
+:03011300C50B1702
+:030114000392173C
+:03011500C40024FF
+:03011600039B1731
+:0301170020CC02F7
+:03011800743D0132
+:03011900B8316496
+:03011A00C00C8096
+:03011B000246F3A6
+:03011C00C05125AA
+:03011D00022205B6
+:03011E002050303E
+:03011F00D2090101
+:03012000D40215F1
+:0301210003D030D8
+:0301220021D901DF
+:03012300030204D0
+:0301240090103008
+:030125002029018D
+:030126000307D3F9
+:03012700901B48E2
+:0301280020421062
+:03012900030022AE
+:03012A00901C50D6
+:03012B00C01039C8
+:03012C001507991B
+:03012D00024B2C56
+:03012E0021A212F9
+:03012F0094803089
+:0301300020221476
+:0301310003A031F7
+:0301320020621335
+:03013300743032F3
+:03013400B41C00F8
+:03013500C9F033DB
+:0301360016BC7084
+:03013700C00039CC
+:030138006B0C50FD
+:03013900D20039B8
+:03013A006D02153E
+:03013B00D40030BD
+:03013C0012BC00F2
+:03013D00C80031C6
+:03013E001AB202F0
+:03013F0020B032BB
+:03014000038C002D
+:0301410020603308
+:0301420002AC709C
+:03014300C0403980
+:03014400086C50F4
+:03014500703039DE
+:03014600B4AC4016
+:03014700C00039BC
+:03014800024C0066
+:03014900B4E039E6
+:03014A00C04C00A6
+:03014B000AAC00FB
+:03014C00C02AC204
+:03014D00024C0061
+:03014E0091702588
+:03014F00C01C10C1
+:0301500003E03D8C
+:030151002069170B
+:03015200643C0406
+:03015300B570255F
+:0301540037EC0085
+:030155002C803DBE
+:03015600B5491791
+:03015700C60C02D1
+:030158001500256A
+:03015900743C08EB
+:03015A00B6B03DFF
+:03015B0021E91780
+:03015C001AFC008A
+:03015D0014F02675
+:03015E00743C01ED
+:03015F00B830298C
+:03016000C04C2070
+:0301610012402326
+:03016200917A008F
+:03016300C00B636B
+:0301640002400056
+:0301650020000077
+:0301660094800082
+:0301670020200055
+:0301680002000092
+:0301690003500040
+:03016A00B83000AA
+:03016B00CFF000D2
+:03016C0019E00097
+:03016D0016F00089
+:03016E00C030009E
+:03016F0008100075
+:03017000743000E8
+:03017100B7A00034
+:03017200C01000BA
+:0301730002400047
+:0301740020000068
+:0301750094800073
+:0301760020200046
+:0301770002000083
+:0301780003500031
+:03017900B830009B
+:03017A00C00000C2
+:03017B0018100059
+:03017C00643000EC
+:03017D006B000014
+:03017E00B80000C6
+:03017F00B8300095
+:03018000C01000AC
+:0301810012400029
+:0301820091700079
+:03018300369000B3
+:03018400C01000A8
+:030185001E6000F9
+:0301860021B000A5
+:030187000860000D
+:03018800743000D0
+:03018900A5D000FE
+:03018A0002600010
+:03018B00C0200091
+:03018C00FFF00081
+:03018D0016B000A9
+:03018E00C020008E
+:03018F0023A000AA
+:03019000743000C8
+:0301910012B000A9
+:0301920020B0009A
+:03019300038000E6
+:03019400C4400064
+:03019500039000D4
+:03019600C40000A2
+:03019700039000D2
+:03019800C00000A4
+:0301990002300031
+:03019A00AC200096
+:03019B00B9B000F8
 :00000001FF

drivers/dahdi/xpp/firmwares/USB_FW.202.hex

@@ -0,0 +1 @@
+USB_FW.201.hex

drivers/dahdi/xpp/init_card_1_30

@@ -59,6 +59,7 @@ my %settings;
 $settings{debug} = 0;
 $settings{fxs_skip_calib} = 0;
 my $chipregs;
+my $ring_registers;
 
 sub logit {
 	print STDERR "$unit_id: @_\n";
@@ -104,6 +105,10 @@ if (-t STDERR) {
 		logit "OLD DRIVER: does not use /sys chipregs. Falling back to /proc"
 			if -f $chipregs;
 	}
+	$ring_registers = sprintf "/sys/bus/xpds/devices/%02d:%1d:0/fxs_ring_registers",
+		$ENV{XBUS_NUMBER}, $ENV{UNIT_NUMBER};
+	logit "OLD DRIVER: missing '$ring_registers' -- fallback to hard-coded defaults"
+		unless -f $ring_registers;
 }
 
 sub set_output() {
@@ -147,6 +152,16 @@ sub write_to_slic_file($) {
 	
 }
 
+sub write_to_ring_register($) {
+	my $write_str = shift;
+
+	open(SLICS,">$ring_registers") or
+		die("Failed writing to ring_registers file $ring_registers");
+	print SLICS $write_str;
+	close(SLICS) or die "Failed writing '$write_str' to '$ring_registers': $!";
+	main::mysleep(0.001);
+}
+
 sub read_reg($$$) {
 	my $read_slic = shift;
 	my $read_reg = shift;
@@ -298,7 +313,7 @@ sub init_early_direct_regs() {
 	return write_to_slic_file("#
 *	WD	08	00	# Audio Path Loopback Control
 *	WD	6C	01
-*	WD	4A	3F	# High Battery Voltage
+*	WD	4A	34	# High Battery Voltage
 *	WD	4B	$lbv	# Low Battery Voltage
 *	WD	49	$vcm	# Common Mode Voltage (VCM)
 *	WD	40	00	# Line Feed Control
@@ -442,6 +457,10 @@ sub check_slics() {
 	return @slics;
 }
 
+sub overwrite_ring_registers() {
+	write_to_ring_register("NEON 0x33 0x12");
+}
+
 package main;
 
 main::debug "Starting '$0'";
@@ -470,6 +489,7 @@ while(<DATA>) {
 	print "$_\n";
 }
 close REG;
+FXS::overwrite_ring_registers();
 
 main::debug "Ending '$0'";
 close STDERR;

drivers/dahdi/xpp/init_card_2_30

@@ -415,6 +415,9 @@ close STDERR;
 exit 0;
 
 __DATA__
+*	WD	12	02	# Full wave rectified ring detection
+*	WD	03	01	# Polarity reversal detect mask
+*	WD	04	00	# Clear interrupt status
 *	WD	21	08	# Disable PCM transfers
 *	WD	18	99
 *	WD	06	00

drivers/dahdi/xpp/xbus-core.c

@@ -24,7 +24,9 @@
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
+#include <linux/mutex.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #ifdef	PROTOCOL_DEBUG
 #include <linux/ctype.h>
 #endif
@@ -47,8 +49,7 @@ static const char rcsid[] = "$Id$";
 #ifdef	PROTOCOL_DEBUG
 #ifdef	CONFIG_PROC_FS
 #define	PROC_XBUS_COMMAND	"command"
-static int proc_xbus_command_write(struct file *file,
-		const char __user *buffer, unsigned long count, void *data);
+static const struct file_operations proc_xbus_command_ops;
 #endif
 #endif
 
@@ -59,12 +60,11 @@ static DEF_PARM(uint, command_queue_length, 1500, 0444,
 static DEF_PARM(uint, poll_timeout, 1000, 0644,
 		"Timeout (in jiffies) waiting for units to reply");
 static DEF_PARM_BOOL(rx_tasklet, 0, 0644, "Use receive tasklets");
-static DEF_PARM_BOOL(dahdi_autoreg, 0, 0644,
+static DEF_PARM_BOOL(dahdi_autoreg, 1, 0644,
 		     "Register devices automatically (1) or not (0)");
 
 #ifdef	CONFIG_PROC_FS
-static int xbus_read_proc(char *page, char **start, off_t off, int count,
-			  int *eof, void *data);
+static const struct file_operations xbus_read_proc_ops;
 #endif
 static void transport_init(xbus_t *xbus, struct xbus_ops *ops,
 			   ushort max_send_size,
@@ -938,6 +938,8 @@ static void xbus_free_ddev(xbus_t *xbus)
 	xbus->ddev = NULL;
 }
 
+static DEFINE_MUTEX(dahdi_registration_mutex);
+
 int xbus_register_dahdi_device(xbus_t *xbus)
 {
 	int i;
@@ -945,6 +947,11 @@ int xbus_register_dahdi_device(xbus_t *xbus)
 	int ret;
 
 	XBUS_DBG(DEVICES, xbus, "Entering %s\n", __func__);
+	ret = mutex_lock_interruptible(&dahdi_registration_mutex);
+	if (ret < 0) {
+		XBUS_ERR(xbus, "dahdi_registration_mutex already taken\n");
+		goto err;
+	}
 	if (xbus_is_registered(xbus)) {
 		XBUS_ERR(xbus, "Already registered to DAHDI\n");
 		WARN_ON(1);
@@ -1009,17 +1016,26 @@ int xbus_register_dahdi_device(xbus_t *xbus)
 			xpd_dahdi_postregister(xpd);
 		}
 	}
-	return 0;
+	ret = 0;
+out:
+	mutex_unlock(&dahdi_registration_mutex);
+	return ret;
 err:
 	xbus_free_ddev(xbus);
-	return ret;
+	goto out;
 }
 
 void xbus_unregister_dahdi_device(xbus_t *xbus)
 {
 	int i;
+	int ret;
 
 	XBUS_NOTICE(xbus, "%s\n", __func__);
+	ret = mutex_lock_interruptible(&dahdi_registration_mutex);
+	if (ret < 0) {
+		XBUS_ERR(xbus, "dahdi_registration_mutex already taken\n");
+		return;
+	}
 	for (i = 0; i < MAX_XPDS; i++) {
 		xpd_t *xpd = xpd_of(xbus, i);
 		xpd_dahdi_preunregister(xpd);
@@ -1034,6 +1050,7 @@ void xbus_unregister_dahdi_device(xbus_t *xbus)
 		xpd_t *xpd = xpd_of(xbus, i);
 		xpd_dahdi_postunregister(xpd);
 	}
+	mutex_unlock(&dahdi_registration_mutex);
 }
 
 /*
@@ -1532,29 +1549,26 @@ xbus_t *xbus_new(struct xbus_ops *ops, ushort max_send_size,
 		err = -EIO;
 		goto nobus;
 	}
-	xbus->proc_xbus_summary =
-	    create_proc_read_entry(PROC_XBUS_SUMMARY, 0444, xbus->proc_xbus_dir,
-				   xbus_read_proc,
-				   (void *)((unsigned long)(xbus->num)));
+	xbus->proc_xbus_summary = proc_create_data(PROC_XBUS_SUMMARY, 0444,
+					xbus->proc_xbus_dir,
+					&xbus_read_proc_ops,
+					(void *)((unsigned long)xbus->num));
 	if (!xbus->proc_xbus_summary) {
 		XBUS_ERR(xbus, "Failed to create proc file '%s'\n",
 			 PROC_XBUS_SUMMARY);
 		err = -EIO;
 		goto nobus;
 	}
-	SET_PROC_DIRENTRY_OWNER(xbus->proc_xbus_summary);
 #ifdef	PROTOCOL_DEBUG
-	xbus->proc_xbus_command =
-	    create_proc_entry(PROC_XBUS_COMMAND, 0200, xbus->proc_xbus_dir);
+	xbus->proc_xbus_command = proc_create_data(PROC_XBUS_COMMAND, 0200,
+					xbus->proc_xbus_dir,
+					&proc_xbus_command_ops, xbus);
 	if (!xbus->proc_xbus_command) {
 		XBUS_ERR(xbus, "Failed to create proc file '%s'\n",
 			 PROC_XBUS_COMMAND);
 		err = -EIO;
 		goto nobus;
 	}
-	xbus->proc_xbus_command->write_proc = proc_xbus_command_write;
-	xbus->proc_xbus_command->data = xbus;
-	SET_PROC_DIRENTRY_OWNER(xbus->proc_xbus_command);
 #endif
 #endif
 	xframe_queue_init(&xbus->command_queue, 10, command_queue_length,
@@ -1596,8 +1610,6 @@ static bool xpds_done(xbus_t *xbus)
 {
 	if (XBUS_IS(xbus, FAIL))
 		return 1;	/* Nothing to wait for */
-	if (!XBUS_IS(xbus, RECVD_DESC))
-		return 1;	/* We are not in the initialization phase */
 	if (xbus->worker.xpds_init_done)
 		return 1;	/* All good */
 	/* Keep waiting */
@@ -1626,14 +1638,9 @@ int waitfor_xpds(xbus_t *xbus, char *buf)
 		len = -ENODEV;
 		goto out;
 	}
-	if (worker->num_units == 0) {
-		XBUS_ERR(xbus, "No cards. Skipping.\n");
-		goto out;
-	}
 	XBUS_DBG(DEVICES, xbus,
-		 "Waiting for card init of %d XPD's max %d seconds (%p)\n",
-		 worker->num_units, INITIALIZATION_TIMEOUT / HZ,
-		 &worker->wait_for_xpd_initialization);
+		 "Waiting for card init of XPDs max %d seconds\n",
+		 INITIALIZATION_TIMEOUT / HZ);
 	ret =
 	    wait_event_interruptible_timeout(worker->
 					     wait_for_xpd_initialization,
@@ -1668,106 +1675,96 @@ out:
 
 #ifdef CONFIG_PROC_FS
 
-static int xbus_fill_proc_queue(char *p, struct xframe_queue *q)
+static void xbus_fill_proc_queue(struct seq_file *sfile, struct xframe_queue *q)
 {
-	int len;
-
-	len = sprintf(p,
+	seq_printf(sfile,
 		"%-15s: counts %3d, %3d, %3d worst %3d, overflows %3d "
 		"worst_lag %02ld.%ld ms\n",
 		q->name, q->steady_state_count, q->count, q->max_count,
 		q->worst_count, q->overflows, q->worst_lag_usec / 1000,
 		q->worst_lag_usec % 1000);
 	xframe_queue_clearstats(q);
-	return len;
 }
 
-static int xbus_read_proc(char *page, char **start, off_t off, int count,
-			  int *eof, void *data)
+static int xbus_proc_show(struct seq_file *sfile, void *data)
 {
 	xbus_t *xbus;
 	unsigned long flags;
 	int len = 0;
-	int i = (int)((unsigned long)data);
+	int i = (int)((unsigned long)sfile->private);
 
-	xbus = get_xbus(__func__, i);	/* until end of xbus_read_proc */
+	xbus = get_xbus(__func__, i);	/* until end of xbus_proc_show() */
 	if (!xbus)
-		goto out;
+		return -EINVAL;
 	spin_lock_irqsave(&xbus->lock, flags);
 
-	len +=
-	    sprintf(page + len, "%s: CONNECTOR=%s LABEL=[%s] STATUS=%s\n",
+	seq_printf(sfile, "%s: CONNECTOR=%s LABEL=[%s] STATUS=%s\n",
 		    xbus->busname, xbus->connector, xbus->label,
 		    (XBUS_FLAGS(xbus, CONNECTED)) ? "connected" : "missing");
-	len += xbus_fill_proc_queue(page + len, &xbus->send_pool);
-	len += xbus_fill_proc_queue(page + len, &xbus->receive_pool);
-	len += xbus_fill_proc_queue(page + len, &xbus->command_queue);
-	len += xbus_fill_proc_queue(page + len, &xbus->receive_queue);
-	len += xbus_fill_proc_queue(page + len, &xbus->pcm_tospan);
+	xbus_fill_proc_queue(sfile, &xbus->send_pool);
+	xbus_fill_proc_queue(sfile, &xbus->receive_pool);
+	xbus_fill_proc_queue(sfile, &xbus->command_queue);
+	xbus_fill_proc_queue(sfile, &xbus->receive_queue);
+	xbus_fill_proc_queue(sfile, &xbus->pcm_tospan);
 	if (rx_tasklet) {
-		len += sprintf(page + len, "\ncpu_rcv_intr:    ");
+		seq_printf(sfile, "\ncpu_rcv_intr:    ");
 		for_each_online_cpu(i)
-		    len += sprintf(page + len, "%5d ", xbus->cpu_rcv_intr[i]);
-		len += sprintf(page + len, "\ncpu_rcv_tasklet: ");
+		    seq_printf(sfile, "%5d ", xbus->cpu_rcv_intr[i]);
+		seq_printf(sfile, "\ncpu_rcv_tasklet: ");
 		for_each_online_cpu(i)
-		    len +=
-		    sprintf(page + len, "%5d ", xbus->cpu_rcv_tasklet[i]);
-		len += sprintf(page + len, "\n");
+		    seq_printf(sfile, "%5d ", xbus->cpu_rcv_tasklet[i]);
+		seq_printf(sfile, "\n");
 	}
-	len +=
-	    sprintf(page + len, "self_ticking: %d (last_tick at %ld)\n",
+	seq_printf(sfile, "self_ticking: %d (last_tick at %ld)\n",
 		    xbus->self_ticking, xbus->ticker.last_sample.tv.tv_sec);
-	len +=
-	    sprintf(page + len, "command_tick: %d\n",
+	seq_printf(sfile, "command_tick: %d\n",
 		    xbus->command_tick_counter);
-	len += sprintf(page + len, "usec_nosend: %d\n", xbus->usec_nosend);
-	len +=
-	    sprintf(page + len, "xbus: pcm_rx_counter = %d, frag = %d\n",
+	seq_printf(sfile, "usec_nosend: %d\n", xbus->usec_nosend);
+	seq_printf(sfile, "xbus: pcm_rx_counter = %d, frag = %d\n",
 		    atomic_read(&xbus->pcm_rx_counter), xbus->xbus_frag_count);
-	len +=
-	    sprintf(page + len, "max_rx_process = %2ld.%ld ms\n",
+	seq_printf(sfile, "max_rx_process = %2ld.%ld ms\n",
 		    xbus->max_rx_process / 1000, xbus->max_rx_process % 1000);
 	xbus->max_rx_process = 0;
-	len +=
-	    sprintf(page + len, "\nTRANSPORT: max_send_size=%d refcount=%d\n",
+	seq_printf(sfile, "\nTRANSPORT: max_send_size=%d refcount=%d\n",
 		    MAX_SEND_SIZE(xbus),
 		    atomic_read(&xbus->transport.transport_refcount)
 	    );
-	len += sprintf(page + len, "PCM Metrices:\n");
-	len +=
-	    sprintf(page + len, "\tPCM TX: min=%ld  max=%ld\n",
+	seq_printf(sfile, "PCM Metrices:\n");
+	seq_printf(sfile, "\tPCM TX: min=%ld  max=%ld\n",
 		    xbus->min_tx_sync, xbus->max_tx_sync);
-	len +=
-	    sprintf(page + len, "\tPCM RX: min=%ld  max=%ld\n",
+	seq_printf(sfile, "\tPCM RX: min=%ld  max=%ld\n",
 		    xbus->min_rx_sync, xbus->max_rx_sync);
-	len += sprintf(page + len, "COUNTERS:\n");
+	seq_printf(sfile, "COUNTERS:\n");
 	for (i = 0; i < XBUS_COUNTER_MAX; i++) {
-		len +=
-		    sprintf(page + len, "\t%-15s = %d\n", xbus_counters[i].name,
+		seq_printf(sfile, "\t%-15s = %d\n", xbus_counters[i].name,
 			    xbus->counters[i]);
 	}
-	len += sprintf(page + len, "<-- len=%d\n", len);
+	seq_printf(sfile, "<-- len=%d\n", len);
 	spin_unlock_irqrestore(&xbus->lock, flags);
-	put_xbus(__func__, xbus);	/* from xbus_read_proc() */
-out:
-	if (len <= off + count)
-		*eof = 1;
-	*start = page + off;
-	len -= off;
-	if (len > count)
-		len = count;
-	if (len < 0)
-		len = 0;
-	return len;
+	put_xbus(__func__, xbus);	/* from xbus_proc_show() */
+	return 0;
 
 }
 
+static int xbus_read_proc_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, xbus_proc_show, PDE_DATA(inode));
+}
+
+static const struct file_operations xbus_read_proc_ops = {
+	.owner		= THIS_MODULE,
+	.open		= xbus_read_proc_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
+
 #ifdef	PROTOCOL_DEBUG
-static int proc_xbus_command_write(struct file *file,
-		const char __user *buffer, unsigned long count, void *data)
+static ssize_t proc_xbus_command_write(struct file *file,
+		const char __user *buffer, size_t count, loff_t *offset)
 {
 	char *buf;
-	xbus_t *xbus = data;
+	xbus_t *xbus = file->private_data;
 	char *p;
 	__u8 *pack_start;
 	__u8 *q;
@@ -1777,7 +1774,7 @@ static int proc_xbus_command_write(struct file *file,
 	const size_t max_text = max_len * 3 + 10;
 
 	if (count > max_text) {
-		XBUS_ERR(xbus, "%s: line too long (%ld > %zd)\n", __func__,
+		XBUS_ERR(xbus, "%s: line too long (%zd > %zd)\n", __func__,
 			 count, max_len);
 		return -EFBIG;
 	}
@@ -1790,7 +1787,7 @@ static int proc_xbus_command_write(struct file *file,
 		goto out;
 	}
 	buf[count] = '\0';
-	XBUS_DBG(GENERAL, xbus, "count=%ld\n", count);
+	XBUS_DBG(GENERAL, xbus, "count=%zd\n", count);
 	/*
 	 * We replace the content of buf[] from
 	 * ascii representation to packet content
@@ -1846,20 +1843,29 @@ out:
 	kfree(buf);
 	return count;
 }
+
+static int proc_xbus_command_open(struct inode *inode, struct file *file)
+{
+	file->private_data = PDE_DATA(inode);
+	return 0;
+}
+
+static const struct file_operations proc_xbus_command_ops = {
+	.owner		= THIS_MODULE,
+	.open		= proc_xbus_command_open,
+	.write		= proc_xbus_command_write,
+};
 #endif
 
-static int read_proc_xbuses(char *page, char **start, off_t off, int count,
-			    int *eof, void *data)
+static int xpp_proc_read_show(struct seq_file *sfile, void *data)
 {
-	int len = 0;
 	int i;
 
 	for (i = 0; i < MAX_BUSES; i++) {
 		xbus_t *xbus = get_xbus(__func__, i);
 
 		if (xbus) {
-			len +=
-			    sprintf(page + len,
+			seq_printf(sfile,
 				    "%s: CONNECTOR=%s LABEL=[%s] STATUS=%s\n",
 				    xbus->busname, xbus->connector, xbus->label,
 				    (XBUS_FLAGS(xbus, CONNECTED)) ? "connected"
@@ -1868,19 +1874,24 @@ static int read_proc_xbuses(char *page, char **start, off_t off, int count,
 		}
 	}
 #if 0
-	len += sprintf(page + len, "<-- len=%d\n", len);
+	seq_printf(sfile, "<-- len=%d\n", len);
 #endif
-	if (len <= off + count)
-		*eof = 1;
-	*start = page + off;
-	len -= off;
-	if (len > count)
-		len = count;
-	if (len < 0)
-		len = 0;
-	return len;
-
+	return 0;
 }
+
+static int xpp_proc_read_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, xpp_proc_read_show, PDE_DATA(inode));
+}
+
+static const struct file_operations xpp_proc_read_ops = {
+	.owner		= THIS_MODULE,
+	.open		= xpp_proc_read_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
+
 #endif
 
 static void transport_init(xbus_t *xbus, struct xbus_ops *ops,
@@ -1971,15 +1982,13 @@ int __init xbus_core_init(void)
 	INFO("FEATURE: with PROTOCOL_DEBUG\n");
 #endif
 #ifdef CONFIG_PROC_FS
-	proc_xbuses =
-	    create_proc_read_entry(PROC_XBUSES, 0444, xpp_proc_toplevel,
-				   read_proc_xbuses, NULL);
+	proc_xbuses = proc_create_data(PROC_XBUSES, 0444, xpp_proc_toplevel,
+				       &xpp_proc_read_ops, NULL);
 	if (!proc_xbuses) {
 		ERR("Failed to create proc file %s\n", PROC_XBUSES);
 		ret = -EFAULT;
 		goto err;
 	}
-	SET_PROC_DIRENTRY_OWNER(proc_xbuses);
 #endif
 	if ((ret = xpp_driver_init()) < 0)
 		goto err;

drivers/dahdi/xpp/xbus-sysfs.c

@@ -23,6 +23,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/errno.h>
+#include <linux/mutex.h>
 #include <linux/proc_fs.h>
 #ifdef	PROTOCOL_DEBUG
 #include <linux/ctype.h>
@@ -582,6 +583,8 @@ static DEVICE_ATTR_READER(span_show, dev, buf)
 	return len;
 }
 
+static DEFINE_MUTEX(span_store_mutex);
+
 /*
  * For backward compatibility with old dahdi-tools
  * Remove after dahdi_registration is upgraded
@@ -601,8 +604,13 @@ static DEVICE_ATTR_WRITER(span_store, dev, buf, count)
 		return -EINVAL;
 	if (!XBUS_IS(xpd->xbus, READY))
 		return -ENODEV;
-	XPD_DBG(DEVICES, xpd, "%s -- deprecated (should use pinned-spans)\n",
+	XPD_DBG(DEVICES, xpd, "%s -- deprecated (should use assigned-spans)\n",
 		(dahdi_reg) ? "register" : "unregister");
+	ret = mutex_lock_interruptible(&span_store_mutex);
+	if (ret < 0) {
+		XBUS_ERR(xpd->xbus, "span_store_mutex already taken\n");
+		return ret;
+	}
 	if (xbus_is_registered(xpd->xbus)) {
 		if (dahdi_reg) {
 			XPD_DBG(DEVICES, xpd,
@@ -620,6 +628,7 @@ static DEVICE_ATTR_WRITER(span_store, dev, buf, count)
 			xbus_register_dahdi_device(xpd->xbus);
 		}
 	}
+	mutex_unlock(&span_store_mutex);
 	return count;
 }
 

drivers/dahdi/xpp/xdefs.h

@@ -145,10 +145,12 @@ typedef char *charp;
 #endif
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
-/* Also don't define this for later RHEL >= 5.2 . hex_asc is from the
- * same linux-2.6-net-infrastructure-updates-to-mac80211-iwl4965.patch
- * as is the bool typedef. */
-#if LINUX_VERSION_CODE != KERNEL_VERSION(2, 6, 18)  || !defined(hex_asc)
+/* Also don't define this for later RHEL >= 5.2. */
+#if defined(RHEL_RELEASE_CODE) && defined(RHEL_RELEASE_VERSION)
+#if RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5, 3)
+typedef int bool;
+#endif
+#else
 typedef int bool;
 #endif
 #endif

drivers/dahdi/xpp/xpp.rules

@@ -1,11 +0,0 @@
-# Load firmware into the Xorcom Astribank device:
-SUBSYSTEM=="usb", ACTION=="add", \
-ENV{PRODUCT}=="e4e4/11[3456][013]/*", ENV{DEVTYPE}!="usb_interface", \
-	RUN+="/usr/share/dahdi/xpp_fxloader udev $env{PRODUCT}"
-
-# Hotplug hook for Astribank up/down
-# If you need this functionality, copy the astribank_hook.sample
-# to $XPP_INIT_DIR/astribank_hook
-#
-# By default XPP_INIT_DIR="/usr/share/dahdi"
-KERNEL=="xbus*", RUN+="%E{XPP_INIT_DIR}/astribank_hook udev $kernel $sysfs{status} $sysfs{connector}"

drivers/dahdi/xpp/xpp_dahdi.c

@@ -34,6 +34,7 @@
 #include <linux/delay.h>	/* for udelay */
 #include <linux/interrupt.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <dahdi/kernel.h>
 #include "xbus-core.h"
 #include "xproto.h"
@@ -102,8 +103,7 @@ int total_registered_spans(void)
 }
 
 #ifdef	CONFIG_PROC_FS
-static int xpd_read_proc(char *page, char **start, off_t off, int count,
-			 int *eof, void *data);
+static const struct file_operations xpd_read_proc_ops;
 #endif
 
 /*------------------------- XPD Management -------------------------*/
@@ -169,9 +169,9 @@ static int xpd_proc_create(xbus_t *xbus, xpd_t *xpd)
 		XPD_ERR(xpd, "Failed to create proc directory\n");
 		goto err;
 	}
-	xpd->proc_xpd_summary =
-	    create_proc_read_entry(PROC_XPD_SUMMARY, 0444, xpd->proc_xpd_dir,
-				   xpd_read_proc, xpd);
+	xpd->proc_xpd_summary = proc_create_data(PROC_XPD_SUMMARY, 0444,
+						 xpd->proc_xpd_dir,
+						 &xpd_read_proc_ops, xpd);
 	if (!xpd->proc_xpd_summary) {
 		XPD_ERR(xpd, "Failed to create proc file '%s'\n",
 			PROC_XPD_SUMMARY);
@@ -254,89 +254,72 @@ EXPORT_SYMBOL(create_xpd);
 
 /**
  * Prints a general procfs entry for the bus, under xpp/BUSNAME/summary
- * @page TODO: figure out procfs
- * @start TODO: figure out procfs
- * @off TODO: figure out procfs
- * @count TODO: figure out procfs
- * @eof TODO: figure out procfs
- * @data an xbus_t pointer with the bus data.
  */
-static int xpd_read_proc(char *page, char **start, off_t off, int count,
-			 int *eof, void *data)
+static int xpd_read_proc_show(struct seq_file *sfile, void *data)
 {
 	int len = 0;
-	xpd_t *xpd = data;
+	xpd_t *xpd = sfile->private;
 	int i;
 
 	if (!xpd)
-		goto out;
+		return -EINVAL;
 
-	len +=
-	    sprintf(page + len,
+	seq_printf(sfile,
 		    "%s (%s, card %s, span %d)\n" "timing_priority: %d\n"
 		    "timer_count: %d span->mainttimer=%d\n", xpd->xpdname,
 		    xpd->type_name, (xpd->card_present) ? "present" : "missing",
 		    (SPAN_REGISTERED(xpd)) ? PHONEDEV(xpd).span.spanno : 0,
 		    PHONEDEV(xpd).timing_priority, xpd->timer_count,
 		    PHONEDEV(xpd).span.mainttimer);
-	len +=
-	    sprintf(page + len, "xpd_state: %s (%d)\n",
+	seq_printf(sfile, "xpd_state: %s (%d)\n",
 		    xpd_statename(xpd->xpd_state), xpd->xpd_state);
-	len +=
-	    sprintf(page + len, "open_counter=%d refcount=%d\n",
+	seq_printf(sfile, "open_counter=%d refcount=%d\n",
 		    atomic_read(&PHONEDEV(xpd).open_counter),
 		    refcount_xpd(xpd));
-	len +=
-	    sprintf(page + len, "Address: U=%d S=%d\n", xpd->addr.unit,
+	seq_printf(sfile, "Address: U=%d S=%d\n", xpd->addr.unit,
 		    xpd->addr.subunit);
-	len += sprintf(page + len, "Subunits: %d\n", xpd->subunits);
-	len += sprintf(page + len, "Type: %d.%d\n\n", xpd->type, xpd->subtype);
-	len += sprintf(page + len, "pcm_len=%d\n\n", PHONEDEV(xpd).pcm_len);
-	len +=
-	    sprintf(page + len, "wanted_pcm_mask=0x%04X\n\n",
+	seq_printf(sfile, "Subunits: %d\n", xpd->subunits);
+	seq_printf(sfile, "Type: %d.%d\n\n", xpd->type, xpd->subtype);
+	seq_printf(sfile, "pcm_len=%d\n\n", PHONEDEV(xpd).pcm_len);
+	seq_printf(sfile, "wanted_pcm_mask=0x%04X\n\n",
 		    PHONEDEV(xpd).wanted_pcm_mask);
-	len +=
-	    sprintf(page + len, "mute_dtmf=0x%04X\n\n",
+	seq_printf(sfile, "mute_dtmf=0x%04X\n\n",
 		    PHONEDEV(xpd).mute_dtmf);
-	len += sprintf(page + len, "STATES:");
-	len += sprintf(page + len, "\n\t%-17s: ", "output_relays");
+	seq_printf(sfile, "STATES:");
+	seq_printf(sfile, "\n\t%-17s: ", "output_relays");
 	for_each_line(xpd, i) {
-		len +=
-		    sprintf(page + len, "%d ",
+		seq_printf(sfile, "%d ",
 			    IS_SET(PHONEDEV(xpd).digital_outputs, i));
 	}
-	len += sprintf(page + len, "\n\t%-17s: ", "input_relays");
+	seq_printf(sfile, "\n\t%-17s: ", "input_relays");
 	for_each_line(xpd, i) {
-		len +=
-		    sprintf(page + len, "%d ",
+		seq_printf(sfile, "%d ",
 			    IS_SET(PHONEDEV(xpd).digital_inputs, i));
 	}
-	len += sprintf(page + len, "\n\t%-17s: ", "offhook");
+	seq_printf(sfile, "\n\t%-17s: ", "offhook");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%d ", IS_OFFHOOK(xpd, i));
+		seq_printf(sfile, "%d ", IS_OFFHOOK(xpd, i));
 	}
-	len += sprintf(page + len, "\n\t%-17s: ", "oht_pcm_pass");
+	seq_printf(sfile, "\n\t%-17s: ", "oht_pcm_pass");
 	for_each_line(xpd, i) {
-		len +=
-		    sprintf(page + len, "%d ",
+		seq_printf(sfile, "%d ",
 			    IS_SET(PHONEDEV(xpd).oht_pcm_pass, i));
 	}
-	len += sprintf(page + len, "\n\t%-17s: ", "msg_waiting");
+	seq_printf(sfile, "\n\t%-17s: ", "msg_waiting");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%d ", PHONEDEV(xpd).msg_waiting[i]);
+		seq_printf(sfile, "%d ", PHONEDEV(xpd).msg_waiting[i]);
 	}
-	len += sprintf(page + len, "\n\t%-17s: ", "ringing");
+	seq_printf(sfile, "\n\t%-17s: ", "ringing");
 	for_each_line(xpd, i) {
-		len += sprintf(page + len, "%d ", PHONEDEV(xpd).ringing[i]);
+		seq_printf(sfile, "%d ", PHONEDEV(xpd).ringing[i]);
 	}
-	len += sprintf(page + len, "\n\t%-17s: ", "no_pcm");
+	seq_printf(sfile, "\n\t%-17s: ", "no_pcm");
 	for_each_line(xpd, i) {
-		len +=
-		    sprintf(page + len, "%d ", IS_SET(PHONEDEV(xpd).no_pcm, i));
+		seq_printf(sfile, "%d ", IS_SET(PHONEDEV(xpd).no_pcm, i));
 	}
 #if 1
 	if (SPAN_REGISTERED(xpd)) {
-		len += sprintf(page + len,
+		seq_printf(sfile,
 			"\nPCM:\n            |"
 			"         [readchunk]       |"
 			"         [writechunk]      | W D");
@@ -358,16 +341,16 @@ static int xpd_read_proc(char *page, char **start, off_t off, int count,
 			wp = chan->writechunk;
 			memcpy(rchunk, rp, DAHDI_CHUNKSIZE);
 			memcpy(wchunk, wp, DAHDI_CHUNKSIZE);
-			len += sprintf(page + len, "\n  port %2d>  |  ", i);
+			seq_printf(sfile, "\n  port %2d>  |  ", i);
 			for (j = 0; j < DAHDI_CHUNKSIZE; j++)
-				len += sprintf(page + len, "%02X ", rchunk[j]);
-			len += sprintf(page + len, " |  ");
+				seq_printf(sfile, "%02X ", rchunk[j]);
+			seq_printf(sfile, " |  ");
 			for (j = 0; j < DAHDI_CHUNKSIZE; j++)
-				len += sprintf(page + len, "%02X ", wchunk[j]);
-			len += sprintf(page + len, " | %c",
+				seq_printf(sfile, "%02X ", wchunk[j]);
+			seq_printf(sfile, " | %c",
 				(IS_SET(PHONEDEV(xpd).wanted_pcm_mask, i))
 					?  '+' : ' ');
-			len += sprintf(page + len, " %c",
+			seq_printf(sfile, " %c",
 				(IS_SET(PHONEDEV(xpd).mute_dtmf, i))
 					? '-' : ' ');
 		}
@@ -375,36 +358,37 @@ static int xpd_read_proc(char *page, char **start, off_t off, int count,
 #endif
 #if 0
 	if (SPAN_REGISTERED(xpd)) {
-		len += sprintf(page + len, "\nSignalling:\n");
+		seq_printf(sfile, "\nSignalling:\n");
 		for_each_line(xpd, i) {
 			struct dahdi_chan *chan = XPD_CHAN(xpd, i);
-			len +=
-			    sprintf(page + len,
+			seq_printf(sfile,
 				    "\t%2d> sigcap=0x%04X sig=0x%04X\n", i,
 				    chan->sigcap, chan->sig);
 		}
 	}
 #endif
-	len += sprintf(page + len, "\nCOUNTERS:\n");
+	seq_printf(sfile, "\nCOUNTERS:\n");
 	for (i = 0; i < XPD_COUNTER_MAX; i++) {
-		len +=
-		    sprintf(page + len, "\t\t%-20s = %d\n",
+		seq_printf(sfile, "\t\t%-20s = %d\n",
 			    xpd_counters[i].name, xpd->counters[i]);
 	}
-	len += sprintf(page + len, "<-- len=%d\n", len);
-out:
-	if (len <= off + count)
-		*eof = 1;
-	*start = page + off;
-	len -= off;
-	if (len > count)
-		len = count;
-	if (len < 0)
-		len = 0;
-	return len;
-
+	seq_printf(sfile, "<-- len=%d\n", len);
+	return 0;
 }
 
+static int xpd_read_proc_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, xpd_read_proc_show, PDE_DATA(inode));
+}
+
+static const struct file_operations xpd_read_proc_ops = {
+	.owner		= THIS_MODULE,
+	.open		= xpd_read_proc_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
+
 #endif
 
 const char *xpd_statename(enum xpd_state st)

drivers/dahdi/xpp/xpp_usb.c

@@ -231,8 +231,7 @@ static int xusb_probe(struct usb_interface *interface,
 		      const struct usb_device_id *id);
 static void xusb_disconnect(struct usb_interface *interface);
 #ifdef	CONFIG_PROC_FS
-static int xusb_read_proc(char *page, char **start, off_t off, int count,
-			  int *eof, void *data);
+static const struct file_operations xusb_read_proc_ops;
 #endif
 
 /*------------------------------------------------------------------*/
@@ -743,9 +742,9 @@ static int xusb_probe(struct usb_interface *interface,
 #ifdef CONFIG_PROC_FS
 	DBG(PROC,
 	    "Creating proc entry " PROC_USBXPP_SUMMARY " in bus proc dir.\n");
-	procsummary =
-	    create_proc_read_entry(PROC_USBXPP_SUMMARY, 0444,
-				   xbus->proc_xbus_dir, xusb_read_proc, xusb);
+	procsummary = proc_create_data(PROC_USBXPP_SUMMARY, 0444,
+				   xbus->proc_xbus_dir, &xusb_read_proc_ops,
+				   xusb);
 	if (!procsummary) {
 		XBUS_ERR(xbus, "Failed to create proc file '%s'\n",
 			 PROC_USBXPP_SUMMARY);
@@ -753,7 +752,6 @@ static int xusb_probe(struct usb_interface *interface,
 		retval = -EIO;
 		goto probe_failed;
 	}
-	SET_PROC_DIRENTRY_OWNER(procsummary);
 #endif
 	bus_count++;
 	xusb->xbus_num = xbus->num;
@@ -1020,90 +1018,83 @@ static void __exit xpp_usb_shutdown(void)
 
 #ifdef CONFIG_PROC_FS
 
-static int xusb_read_proc(char *page, char **start, off_t off, int count,
-			  int *eof, void *data)
+static int xusb_read_proc_show(struct seq_file *sfile, void *data)
 {
-	int len = 0;
 	unsigned long flags;
 	int i;
 	//unsigned long stamp = jiffies;
-	xusb_t *xusb = data;
+	xusb_t *xusb = sfile->private;
 	uint usb_tx_delay[NUM_BUCKETS];
 	const int mark_limit = tx_sluggish / USEC_BUCKET;
 
 	if (!xusb)
-		goto out;
+		return 0;
+
 	// TODO: probably needs a per-xusb lock:
 	spin_lock_irqsave(&xusb_lock, flags);
-	len +=
-	    sprintf(page + len, "Device: %03d/%03d\n", xusb->udev->bus->busnum,
+	seq_printf(sfile, "Device: %03d/%03d\n", xusb->udev->bus->busnum,
 		    xusb->udev->devnum);
-	len +=
-	    sprintf(page + len, "USB: manufacturer=%s\n", xusb->manufacturer);
-	len += sprintf(page + len, "USB: product=%s\n", xusb->product);
-	len += sprintf(page + len, "USB: serial=%s\n", xusb->serial);
-	len +=
-	    sprintf(page + len, "Minor: %d\nModel Info: %s\n", xusb->minor,
+	seq_printf(sfile, "USB: manufacturer=%s\n", xusb->manufacturer);
+	seq_printf(sfile, "USB: product=%s\n", xusb->product);
+	seq_printf(sfile, "USB: serial=%s\n", xusb->serial);
+	seq_printf(sfile, "Minor: %d\nModel Info: %s\n", xusb->minor,
 		    xusb->model_info->desc);
-	len +=
-	    sprintf(page + len,
+	seq_printf(sfile,
 		    "Endpoints:\n" "\tIn:  0x%02X  - Size: %d)\n"
 		    "\tOut: 0x%02X  - Size: %d)\n",
 		    xusb->endpoints[XUSB_RECV].ep_addr,
 		    xusb->endpoints[XUSB_RECV].max_size,
 		    xusb->endpoints[XUSB_SEND].ep_addr,
 		    xusb->endpoints[XUSB_SEND].max_size);
-	len +=
-	    sprintf(page + len, "\npending_writes=%d\n",
+	seq_printf(sfile, "\npending_writes=%d\n",
 		    atomic_read(&xusb->pending_writes));
-	len +=
-	    sprintf(page + len, "pending_reads=%d\n",
+	seq_printf(sfile, "pending_reads=%d\n",
 		    atomic_read(&xusb->pending_reads));
-	len += sprintf(page + len, "max_tx_delay=%d\n", xusb->max_tx_delay);
+	seq_printf(sfile, "max_tx_delay=%d\n", xusb->max_tx_delay);
 	xusb->max_tx_delay = 0;
 #ifdef	DEBUG_PCM_TIMING
-	len +=
-	    sprintf(page + len,
+	seq_printf(sfile,
 		    "\nstamp_last_pcm_read=%lld accumulate_diff=%lld\n",
 		    stamp_last_pcm_read, accumulate_diff);
 #endif
 	memcpy(usb_tx_delay, xusb->usb_tx_delay, sizeof(usb_tx_delay));
-	len +=
-	    sprintf(page + len, "usb_tx_delay[%d,%d,%d]: ", USEC_BUCKET,
+	seq_printf(sfile, "usb_tx_delay[%d,%d,%d]: ", USEC_BUCKET,
 		    BUCKET_START, NUM_BUCKETS);
 	for (i = BUCKET_START; i < NUM_BUCKETS; i++) {
-		len += sprintf(page + len, "%6d ", usb_tx_delay[i]);
+		seq_printf(sfile, "%6d ", usb_tx_delay[i]);
 		if (i == mark_limit)
-			len += sprintf(page + len, "| ");
+			seq_printf(sfile, "| ");
 	}
-	len +=
-	    sprintf(page + len, "\nPCM_TX_DROPS: %5d (sluggish: %d)\n",
+	seq_printf(sfile, "\nPCM_TX_DROPS: %5d (sluggish: %d)\n",
 		    atomic_read(&xusb->pcm_tx_drops),
 		    atomic_read(&xusb->usb_sluggish_count)
 	    );
-	len += sprintf(page + len, "\nCOUNTERS:\n");
+	seq_printf(sfile, "\nCOUNTERS:\n");
 	for (i = 0; i < XUSB_COUNTER_MAX; i++) {
-		len +=
-		    sprintf(page + len, "\t%-15s = %d\n", xusb_counters[i].name,
+		seq_printf(sfile, "\t%-15s = %d\n", xusb_counters[i].name,
 			    xusb->counters[i]);
 	}
 #if 0
-	len += sprintf(page + len, "<-- len=%d\n", len);
+	seq_printf(sfile, "<-- len=%d\n", len);
 #endif
 	spin_unlock_irqrestore(&xusb_lock, flags);
-out:
-	if (len <= off + count)
-		*eof = 1;
-	*start = page + off;
-	len -= off;
-	if (len > count)
-		len = count;
-	if (len < 0)
-		len = 0;
-	return len;
-
+	return 0;
 }
 
+static int xusb_read_proc_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, xusb_read_proc_show, PDE_DATA(inode));
+}
+
+static const struct file_operations xusb_read_proc_ops = {
+	.owner		= THIS_MODULE,
+	.open		= xusb_read_proc_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
+
+
 #endif
 
 MODULE_DESCRIPTION("XPP USB Transport Driver");

include/dahdi/dahdi_config.h

@@ -40,11 +40,10 @@
 /* #define SHORT_FLASH_TIME */
 
 /*
- * Uncomment to disable calibration and/or DC/DC converter tests
+ * Uncomment to disable calibration tests
  * (not generally recommended)
  */
 /* #define NO_CALIBRATION */
-/* #define NO_DCDC */
 
 /*
  * Boost ring voltage (Higher ring voltage, takes more power)
@@ -190,4 +189,10 @@
  */
 /* #define CONFIG_DAHDI_MIRROR */
 
+/*
+ * Adds support for conference links. There are some non-Asterisk users of this
+ * functionality.
+ */
+/* #define CONFIG_DAHDI_CONFLINK */
+
 #endif

include/dahdi/kernel.h

@@ -40,6 +40,7 @@
 #include <linux/version.h>
 #include <linux/fs.h>
 #include <linux/device.h>
+#include <linux/cdev.h>
 #include <linux/module.h>
 #include <linux/ioctl.h>
 
@@ -100,6 +101,14 @@
 #  endif
 #endif
 
+/* __dev* were removed in 3.8. They still have effect in 2.6.18. */
+#ifndef __devinit
+#  define __devinit
+#  define __devinitdata
+#  define __devexit
+#  define __devexit_p(x) x
+#endif
+
 /*! Default chunk size for conferences and such -- static right now, might make
    variable sometime.  8 samples = 1 ms = most frequent service interval possible
    for a USB device */
@@ -605,6 +614,8 @@ struct dahdi_chan {
 #else
 	unsigned char *lin2x;
 #endif
+	struct device chan_device;	/*!< Kernel object for this chan */
+#define dev_to_chan(dev)    container_of(dev, struct dahdi_chan, chan_device)
 };
 
 #ifdef CONFIG_DAHDI_NET
@@ -738,15 +749,16 @@ static inline int dahdi_have_netdev(const struct dahdi_chan *chan) { return 0; }
 #endif
 
 struct dahdi_count {
-	__u32 fe;		/*!< Framing error counter */
-	__u32 cv;		/*!< Coding violations counter */
-	__u32 bpv;		/*!< Bipolar Violation counter */
-	__u32 crc4;		/*!< CRC4 error counter */
-	__u32 ebit;		/*!< current E-bit error count */
-	__u32 fas;		/*!< current FAS error count */
-	__u32 be;		/*!< current bit error count */
-	__u32 prbs;		/*!< current PRBS detected pattern */
-	__u32 errsec;		/*!< errored seconds */
+	u32 fe;			/*!< Framing error counter */
+	u32 cv;			/*!< Coding violations counter */
+	u32 bpv;		/*!< Bipolar Violation counter */
+	u32 crc4;		/*!< CRC4 error counter */
+	u32 ebit;		/*!< current E-bit error count */
+	u32 fas;		/*!< current FAS error count */
+	u32 be;			/*!< current bit error count */
+	u32 prbs;		/*!< current PRBS detected pattern */
+	u32 errsec;		/*!< errored seconds */
+	u32 timingslips;	/*!< Clock slips */
 };
 
 /* map flagbits to flag masks */
@@ -799,6 +811,7 @@ enum spantypes {
 	SPANTYPE_DIGITAL_BRI_NT,
 	SPANTYPE_DIGITAL_BRI_TE,
 	SPANTYPE_DIGITAL_BRI_SOFT,
+	SPANTYPE_DIGITAL_DYNAMIC,
 };
 const char *dahdi_spantype2str(enum spantypes st);
 enum spantypes dahdi_str2spantype(const char *name);
@@ -897,7 +910,7 @@ struct dahdi_span_ops {
 	/*! Opt: Provide the name of the echo canceller on a channel */
 	const char *(*echocan_name)(const struct dahdi_chan *chan);
 
-	/*! When using "pinned_spans", this function is called back when this
+	/*! When using "assigned spans", this function is called back when this
 	 * span has been assigned with the system. */
 	void (*assigned)(struct dahdi_span *span);
 
@@ -952,8 +965,6 @@ struct dahdi_span {
 	int maintstat;			/*!< Maintenance state */
 	int mainttimer;			/*!< Maintenance timer */
 
-	int timingslips;		/*!< Clock slips */
-
 	struct dahdi_chan **chans;	/*!< Member channel structures */
 
 	const struct dahdi_span_ops *ops;	/*!< span callbacks. */
@@ -993,6 +1004,8 @@ struct dahdi_transcoder_channel {
 };
 
 int dahdi_is_sync_master(const struct dahdi_span *span);
+struct dahdi_span *get_master_span(void);
+void set_master_span(int spanno);
 
 static inline int 
 dahdi_tc_is_built(struct dahdi_transcoder_channel *dtc) {
@@ -1227,6 +1240,12 @@ void dahdi_init_tone_state(struct dahdi_tone_state *ts, struct dahdi_tone *zt);
 /*! \brief Get a given MF tone struct, suitable for dahdi_tone_nextsample. */
 struct dahdi_tone *dahdi_mf_tone(const struct dahdi_chan *chan, char digit, int digitmode);
 
+/*! \brief Convert signalling bits to human readable string */
+const char *sigstr(int sig);
+
+/*! \brief Convert alarm bits to human readable string */
+int fill_alarm_string(char *buf, int count, int alarms);
+
 /* Echo cancel a receive and transmit chunk for a given channel.  This
    should be called by the low-level driver as close to the interface
    as possible.  ECHO CANCELLATION IS NO LONGER AUTOMATICALLY DONE
@@ -1385,9 +1404,64 @@ static inline short dahdi_txtone_nextsample(struct dahdi_chan *ss)
 /*! Maximum audio mask */
 #define DAHDI_FORMAT_AUDIO_MASK	((1 << 16) - 1)
 
+#ifdef RHEL_RELEASE_VERSION
+#    if RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(6, 5)
+#        ifdef CONFIG_PROC_FS
+#include <linux/proc_fs.h>
+static inline void *PDE_DATA(const struct inode *inode)
+{
+	return PDE(inode)->data;
+}
+#        endif
+#   endif
+#else
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 10, 0)
+#ifdef CONFIG_PROC_FS
+#include <linux/proc_fs.h>
+static inline void *PDE_DATA(const struct inode *inode)
+{
+	return PDE(inode)->data;
+}
+#endif
+#endif
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 31)
 #define KERN_CONT ""
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
+
+#  ifndef RHEL_RELEASE_VERSION
+/* I'm not sure which 5.x release this was backported into. */
+static inline int try_wait_for_completion(struct completion *x)
+{
+	unsigned long flags;
+	int ret = 1;
+
+	spin_lock_irqsave(&x->wait.lock, flags);
+	if (!x->done)
+		ret = 0;
+	else
+		x->done--;
+	spin_unlock_irqrestore(&x->wait.lock, flags);
+	return ret;
+}
+#endif
+
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
+#ifdef CONFIG_PROC_FS
+#include <linux/proc_fs.h>
+static inline struct proc_dir_entry *proc_create_data(const char *name,
+					mode_t mode,
+					struct proc_dir_entry *parent,
+					const struct file_operations *proc_fops,
+					void *data)
+{
+	struct proc_dir_entry *pde = create_proc_entry(name, mode, parent);
+	if (!pde)
+		return NULL;
+	pde->proc_fops = proc_fops;
+	pde->data = data;
+	return pde;
+}
+#endif /* CONFIG_PROC_FS */
 #ifndef clamp
 #define clamp(x, low, high) min(max(low, x), high)
 #endif
@@ -1410,8 +1484,11 @@ void dahdi_pci_disable_link_state(struct pci_dev *pdev, int state);
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
 
-#ifndef __packed                                                                                         
-#define __packed  __attribute__((packed))                                                                
+#define list_first_entry(ptr, type, member) \
+	list_entry((ptr)->next, type, member)
+
+#ifndef __packed
+#define __packed  __attribute__((packed))
 #endif 
 
 #include <linux/ctype.h>
@@ -1439,11 +1516,9 @@ static inline int strcasecmp(const char *s1, const char *s2)
 #endif /* 2.6.22 */
 #endif /* 2.6.25 */
 #endif /* 2.6.26 */
+#endif /* 2.6.27 */
 #endif /* 2.6.31 */
-
-#ifndef CONFIG_TRACING
-#define trace_printk printk
-#endif
+#endif /* 3.10.0 */
 
 #ifndef DEFINE_SPINLOCK
 #define DEFINE_SPINLOCK(x)      spinlock_t x = SPIN_LOCK_UNLOCKED
@@ -1534,6 +1609,17 @@ struct mutex {
 	printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
 #endif
 
+/* If KBUILD_MODNAME is not defined in a compilation unit, then the dev_dbg
+ * macro will not work properly. */
+#ifndef KBUILD_MODNAME
+  #undef dev_dbg
+  #ifdef DEBUG
+    #define dev_dbg dev_info
+  #else
+    #define dev_dbg(...) do { } while (0)
+  #endif
+#endif
+
 /* The dbg_* ones use a magical variable 'debug' and the user should be
  * aware of that.
 */

include/dahdi/user.h

@@ -636,6 +636,11 @@ struct dahdi_confinfo {
 #define DAHDI_SETCONF_V1		_IOW(DAHDI_CODE,  12, struct dahdi_confinfo)
 #define DAHDI_SETCONF			_IOWR(DAHDI_CODE, 13, struct dahdi_confinfo)
 
+/*
+ * Setup or Remove Conference Link
+ */
+#define DAHDI_CONFLINK			_IOW(DAHDI_CODE, 14, struct dahdi_confinfo)
+
 /*
  * Display Conference Diagnostic Information on Console
  */