wctc4xxp: Ensure the descriptors are zeroed out on start.

If system conditions prevent the card from loading the firmware without touching all the descriptors in the ring, it's possible for wctc4xxp_cleanup_descriptor_ring to attempt cleanup of a command that was never submitted resulting in the following BUG. wctc4xxp 0000:02:0a.0: Failed to load firmware. BUG: unable to handle kernel paging request at c109556c IP: [<f9faa83e>] wctc4xxp_cleanup_descriptor_ring+0x8c/0x148 [wctc4xxp] Reported-by: Xavier Carcelle <xcarcelle@avencall.com> Signed-off-by: Shaun Ruffell <sruffell@digium.com>
wcte13xp: New driver for digium's te13x product range
2013-05-31 12:10:49 -05:00 · 2013-05-28 16:53:38 -05:00 · 2013-05-24 00:30:33 +03:00 · 2013-05-24 00:30:33 +03:00 · 2013-05-24 00:30:33 +03:00 · 2013-05-23 14:50:31 +03:00
111 changed files with 43125 additions and 18104 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,41 @@
+# Files that are generated as part of the build process which we do not want git
+# to track.
+
+*.[oa]
+*.mod
+*.mod.[oc]
+*.ko
+*.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/make_firmware_object
--- a/.version
+++ b/.version
@@ -1 +0,0 @@
-2.5.0.1
--- a/4939
+++ b/4939
--- a/16
+++ b/16
@@ -67,13 +67,7 @@ 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

 all: modules
@@ -92,7 +86,7 @@ include/dahdi/version.h: FORCE
 	fi
 	@rm -f $@.tmp

-prereq: include/dahdi/version.h firmware-loaders
+prereq: include/dahdi/version.h firmware-loaders oct612x-lib

 stackcheck: $(CHECKSTACK) modules
 	objdump -d drivers/dahdi/*.ko drivers/dahdi/*/*.ko | $(CHECKSTACK)
@@ -128,6 +122,13 @@ uninstall-firmware:
 firmware-loaders:
 	$(MAKE) -C drivers/dahdi/firmware firmware-loaders

+oct612x-lib:
+ifeq (no,$(HAS_KSRC))
+	@echo "You do not appear to have the sources for the $(KVERS) kernel installed."
+	@exit 1
+endif
+	$(MAKE) -C $(KSRC) M='$(PWD)/drivers/dahdi/oct612x'
+
 install-include:
 	for hdr in $(INST_HEADERS); do \
 		install -D -m 644 include/dahdi/$$hdr $(DESTDIR)/usr/include/dahdi/$$hdr; \
@@ -195,6 +196,7 @@ ifneq (no,$(HAS_KSRC))
 endif
 	@rm -f $(GENERATED_DOCS)
 	$(MAKE) -C drivers/dahdi/firmware clean
+	$(MAKE) -C $(KSRC) M='$(PWD)/drivers/dahdi/oct612x' clean

 distclean: dist-clean

--- a/501
+++ b/501
@@ -17,6 +17,7 @@ Digital Cards
  * Digium TE405P/TE407P/TE410P/TE412P: PCI quad-port T1/E1/J1
  * Digium TE220: PCI-Express dual-port T1/E1/J1
  * Digium TE420: PCI-Express quad-port T1/E1/J1
+  * Digium TE820: PCI-Express eight-port T1/E1/J1
 - wcte12xp:
  * Digium TE120P: PCI single-port T1/E1/J1
  * Digium TE121: PCI-Express single-port T1/E1/J1
@@ -162,6 +163,24 @@ to the script:
  ./build_tools/make_static_devs -d tmp/newroot/dev/dahdi


+DKMS
+~~~~
+DKMS, Dynamic Kernel Module Support, is a framework for building Linux
+kernel modules. It is used, among others, by several distributions that
+package the DAHDI kernel modules.
+
+DKMS is designed to provide updates over drivers installed from original
+kernel modules tree. Thus it installed modules into /lib/modules/updates
+or /lib/modules/VERSION/updates . This is generally not an issue on
+normal operation. However if you try to install DAHDI from source on
+a system with DAHDI installed from DKMS this way (potentially of an
+older version), be sure to remove the DKMS-installed modules from the
+updates directory. If you're not sure, the following command will give
+you a clue of the versions installed:
+
+  find /lib/modules -name dahdi.ko
+
+
 Installing the B410P drivers with mISDN
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 DAHDI includes the wcb4xxp driver for the B410P, however, support for the
@@ -211,13 +230,10 @@ under driver/staging/echo . In fact, dahdi_echocan_oslec assumes that
 this is where the oslec code lies. If it is elsewhere you'll need to fix
 the #include line.

-Thus for the moment, the simplest way to build OSLEC with dahdi is:
-
-1. Copy the directory `drivers/staging/echo` from a recent kernel tree 
-   (at least 2.6.28-rc1) to the a subdirectory with the same name in the
-   dahdi-linux tree.
-
-2. Edit drivers/dahdi/Kbuild and uncomment the two lines related to OSLEC.
+Thus for the moment, the simplest way to build OSLEC with dahdi is to
+copy the directory `drivers/staging/echo` from a recent kernel tree (at
+least 2.6.28-rc1) to the a subdirectory with the same name in the
+dahdi-linux tree.

 After doing that, you'll see the following when building (running
 'make')
@@ -232,6 +248,15 @@ be reported on the
 https://lists.sourceforge.net/lists/listinfo/freetel-oslec[OSLEC mailing
 list].

+Alternatively you can also get the OSLEC code from the dahdi-linux-extra
+GIT repository:
+
+  git clone git://gitorious.org/dahdi-extra/dahdi-linux-extra.git
+  cd dahdi-linux-extra
+  git archive extra-2.6 drivers/staging | (cd ..; tar xf -)
+  cd ..; rm -rf dahdi-linux-extra
+
+
 Live Install
 ~~~~~~~~~~~~
 In many cases you already have DAHDI installed on your system but would
@@ -420,54 +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.
+
+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 

@@ -475,13 +463,178 @@ 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.
+
+==== initdir
+(xpp)
+
+This is the directory 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
@@ -493,9 +646,12 @@ 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/channels/N/M - A device file for channel M in span N
+  (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?
@@ -538,6 +694,7 @@ timing device it will hang forever in the first cycle. Otherwise it will just
 give you in each cycle the percent of how close it was. Also try running it
 with the option -v for a verbose output.

+
 Spans and Channels
 ~~~~~~~~~~~~~~~~~~
 DAHDI provides telephony *channels* to the userspace applications. 
@@ -557,6 +714,81 @@ There are up to 128 spans and 1024 channels. This is a hard-wired limit
 number fits in a 16 bits number). Channel and span numbers start at 1.


+Span Assignments
+~~~~~~~~~~~~~~~~
+A DAHDI device (e.g. a PCI card) is represented within the DAHDI drivers
+as a 'DAHDI device'. Normally (with auto_assign_spans=1 in the module
+dahdi, which is the default), when a device is discovered and loaded,
+it registers with the DAHDI core and its spans automatically become
+available. However if you have more than one device, you may be
+interested to set explicit spans and channels numbers for them. To use
+manual span assigment, set 'auto_assign_spans' to 0 . e.g. in a file
+under /etc/modprobe.d/ include the following line:
+
+  options dahdi auto_assign_spans=0
+
+You will then need to assign the spans manually at device startup. You
+will need to assign a span number and channel numbers for each
+available span on the system. On my test system I have one BRI PCI card
+and one Astribank BRI+FXS:
+
+  # grep . /sys/bus/dahdi_devices/devices/*/spantype
+  /sys/bus/dahdi_devices/devices/astribanks:xbus-00/spantype:1:BRI
+  /sys/bus/dahdi_devices/devices/astribanks:xbus-00/spantype:2:BRI
+  /sys/bus/dahdi_devices/devices/astribanks:xbus-00/spantype:3:BRI
+  /sys/bus/dahdi_devices/devices/astribanks:xbus-00/spantype:4:BRI
+  /sys/bus/dahdi_devices/devices/astribanks:xbus-00/spantype:5:BRI
+  /sys/bus/dahdi_devices/devices/astribanks:xbus-00/spantype:6:BRI
+  /sys/bus/dahdi_devices/devices/astribanks:xbus-00/spantype:7:BRI
+  /sys/bus/dahdi_devices/devices/astribanks:xbus-00/spantype:8:BRI
+  /sys/bus/dahdi_devices/devices/astribanks:xbus-00/spantype:9:FXS
+  /sys/bus/dahdi_devices/devices/pci:0000:00:09.0/spantype:1:TE
+  /sys/bus/dahdi_devices/devices/pci:0000:00:09.0/spantype:2:TE
+  /sys/bus/dahdi_devices/devices/pci:0000:00:09.0/spantype:3:NT
+  /sys/bus/dahdi_devices/devices/pci:0000:00:09.0/spantype:4:NT
+
+All spans here, except the FXS one, are BRI spans with 3 channels per span.
+
+In order to assign a span, we write three numbers separated by colns to
+the file 'assign_span' in the SysFS node
+
+  local_num:span_num:base_chan_num
+
+Thus:
+
+  echo 9:5:10 >/sys/bus/dahdi_devices/devices/astribanks:xbus-00/assign_span
+  echo 2:8:40 >/sys/bus/dahdi_devices/devices/pci:0000:00:09.0/assign_span
+  echo 1:1:1  >/sys/bus/dahdi_devices/devices/astribanks:xbus-00/assign_span
+  echo 4:6:20 >/sys/bus/dahdi_devices/devices/pci:0000:00:09.0/assign_span
+  echo 3:2:5  >/sys/bus/dahdi_devices/devices/astribanks:xbus-00/assign_span
+
+As you can see, the order of span numbers or local span number is
+insignificant. However the order of channel numbers must be the same as
+that of span numbers.
+
+Which indeed produced:
+
+  # head -n3 -q /proc/dahdi/*
+  Span 1: XBUS-00/XPD-00 "Xorcom XPD [usb:LAB-0003].1: BRI_NT"
+
+             1 XPP_BRI_NT/00/00/0
+  Span 2: XBUS-00/XPD-02 "Xorcom XPD [usb:LAB-0003].3: BRI_TE"
+
+             5 XPP_BRI_TE/00/02/0
+  Span 5: XBUS-00/XPD-10 "Xorcom XPD [usb:LAB-0003].9: FXS" (MASTER)
+
+            10 XPP_FXS/00/10/0
+  Span 6: B4/0/4 "B4XXP (PCI) Card 0 Span 4" RED
+
+            23 B4/0/4/1 YELLOW
+  Span 8: B4/0/2 "B4XXP (PCI) Card 0 Span 2" RED
+
+            40 B4/0/2/1 RED
+
+Likewise spans can be unassigned by writing to the 'unassign-span'
+"file".
+
+
 Dynamic Spans
 ~~~~~~~~~~~~~
 Dynamic spans are spans that are not represented by real hardware.
@@ -644,6 +876,163 @@ see an extra '(In use)':
           2 XPP_FXS/0/0/1 FXOLS (In use)


+SysFS Interface
+~~~~~~~~~~~~~~~
+DAHDI exposes several interfaces under the SysFS virtual file system.
+SysFS represents kernel objects in nodes - directories. There properties
+are often files. They may also contain other nodes or include symlinks
+to other nodes.
+
+Class DAHDI
+^^^^^^^^^^^
+under /sys/class/dadhi there exists a node for each DAHDI device file
+under /dev/dahdi. The name is 'dahdi!foo' for the file '/dev/dahdi/foo'
+(udev translates exclamation marks to slashes). Those nodes are not, for
+the most part, proper SysFS nodes, and don't include any interesting
+properties.
+
+
+Devices Bus
+^^^^^^^^^^^
+Each DAHDI device (a physical device, such as a PCI card) is represented
+by a node under /sys/bus/dahdi_devices/devices named with the name of
+its device.
+
+Its attributes include:
+
+===== /sys/bus/dahdi_devices/devices/DEVICE/assgin-span
+Write-only attribute: this device's spans should now be assigned
+("registered"). See section about <<_span_assignments>>.
+
+===== /sys/bus/dahdi_devices/devices/DEVICE/auto-assign
+Write-only attribute. Spans in the device auto-assign ("register" as in
+the original interface). See section about <<_span_assignments>>.
+
+===== /sys/bus/dahdi_devices/devices/DEVICE/hardware_id
+A unique hardware-level identifier (e.g. serial number), if available.
+
+===== /sys/bus/dahdi_devices/devices/DEVICE/manufacturer
+The name of the manufacturer. Freeform-string.
+
+===== /sys/bus/dahdi_devices/devices/DEVICE/spantype
+A line for each available span: <num>:<type>. This has to be provided
+here as in the case of manual assignment, userspace may need to know
+it before span nodes are created.
+
+===== /sys/bus/dahdi_devices/devices/DEVICE/spantype
+Device type.
+
+===== /sys/bus/dahdi_devices/devices/DEVICE/unassign-span
+Write-only attribute: the span whose device-local number is written
+should now be unassigned ("unregistered"). See section about
+<<_span_assignments>>.
+
+
+Spans Bus
+^^^^^^^^^
+Each DAHDI span is represented by a node under
+/sys/bus/dahdi_spans/devices with the name 'span-N' (where N is the
+number of the span). Spans of each device also reside under the node of
+the device.
+
+Useful attributes in the span node:
+
+===== /sys/bus/dahdi_spans/devices/span-N/alarms
+The alarms of the span. Currently this is a numeric representation.
+This may change in the future.
+
+===== /sys/bus/dahdi_spans/devices/span-N/basechan
+The channel number of the first channel. The channel numbers of the
+following channels are guaranteed to follow it.
+
+===== /sys/bus/dahdi_spans/devices/span-N/channels
+The number of the channels in the span.
+
+===== /sys/bus/dahdi_spans/devices/span-N/desc
+A free-form description of the span.
+
+===== /sys/bus/dahdi_spans/devices/span-N/is_digital
+1 if the span is digital, 0 if it isn't.
+
+===== /sys/bus/dahdi_spans/devices/span-N/is_sync_master
+1 if the span is the sync master, 0 if it isn't.
+
+===== /sys/bus/dahdi_spans/devices/span-N/lbo
+LBO setting for the channel.
+
+===== /sys/bus/dahdi_spans/devices/span-N/lineconfig
+The framing and coding of the span, for a digital span. Textual
+represenation:
+
+<B8ZS|AMI|HDB3>/<D4|ESF|CCS>[/CRC4]
+
+===== /sys/bus/dahdi_spans/devices/span-N/local_spanno
+The number of the span within the DAHDI device.
+
+===== /sys/bus/dahdi_spans/devices/span-N/name
+A concise name for this span.
+
+===== /sys/bus/dahdi_spans/devices/span-N/spantype
+A very short type string.
+
+===== /sys/bus/dahdi_spans/devices/span-N/syncsrc
+Current sync source.
+
+
+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
 ~~~~~~~~~~~~~~~~~~~~
 User-space programs can only work with DAHDI channels. The basic
@@ -721,7 +1110,7 @@ standard HDLC rate of 64k).
 Low-Level Drivers
 ~~~~~~~~~~~~~~~~~
 Low-level drivers create spans ('struct dahdi_span'). They register the
-spans with the DAHDI core using 'dahdi_register()'.
+spans with the DAHDI core using 'dahdi_device_register()'.

 'struct dahdi_span' has a number of informative members that are updated
 solely by the low-level driver:
--- a/build_tools/live_dahdi
+++ b/build_tools/live_dahdi
@@ -293,6 +293,10 @@ load)
 	# TODO: A local copy of Asterisk, configured with dahdi_gnconf. 
 	# doable, but trickier.
 	run_asterisk
+	if [ "$LIVE_DAHDI_FREEPBXDB" = 'yes' ]; then
+		GENCONF_PARAMETERS=$DESTDIR/etc/dahdi/genconf_parameters \
+			dahdi_genconf freepbxdb
+	fi
 	;;
 genconf)
 	genconf
--- a/build_tools/make_version
+++ b/build_tools/make_version
@@ -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
--- a/drivers/dahdi/Kbuild
+++ b/drivers/dahdi/Kbuild
@@ -6,10 +6,19 @@ obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_DYNAMIC_ETH)	+= dahdi_dynamic_eth.o
 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_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 oct612x/lib.a
+CFLAGS_wcte13xp-base.o += -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_WCTDM)		+= wctdm.o
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_VOICEBUS)		+= voicebus/
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCB4XXP)		+= wcb4xxp/
@@ -20,6 +29,7 @@ obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCTE11XP)		+= wcte11xp.o
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCFXO)		+= wcfxo.o
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_TOR2)		+= tor2.o
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_PCIRADIO)		+= pciradio.o
+endif

 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_XPP)		+= xpp/

@@ -31,14 +41,13 @@ obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_ECHOCAN_MG2)	+= dahdi_echocan_mg2.o

 obj-m += $(DAHDI_MODULES_EXTRA)

-# Only enable this if you think you know what you're doing. This is not
-# supported yet:
-#obj-m += dahdi_echocan_oslec.o
-#
-# A quick and dirty way to build OSLEC, if you happened to place it
-# yourself in the dahdi source tree. This is experimental. See README
-# regarding OSLEC.
-#obj-m += ../staging/echo/
+# If you want to build OSLEC, include the code in the standard location:
+# drivers/staging/echo . The DAHDI OSLEC echo canceller will be built as
+# well:
+ifneq (,$(wildcard $(src)/../staging/echo/echo.c))
+obj-m += dahdi_echocan_oslec.o
+obj-m += ../staging/echo/echo.o
+endif

 CFLAGS_MODULE += -I$(DAHDI_INCLUDE) -I$(src)

@@ -76,7 +85,7 @@ CFLAGS_dahdi_dynamic_ethmf.o := -DNEW_SKB_LINEARIZE
 endif
 endif

-dahdi-objs := dahdi-base.o dahdi-sysfs.o dahdi-version.o
+dahdi-objs := dahdi-base.o dahdi-sysfs.o dahdi-sysfs-chan.o dahdi-version.o

 ###############################################################################
 # Find appropriate ARCH value for VPMADT032 and HPEC binary modules
--- a/drivers/dahdi/Makefile
+++ b/drivers/dahdi/Makefile
@@ -1,6 +0,0 @@
-ifdef KBUILD_EXTMOD
-# We only get here on kernels 2.6.0-2.6.9 .
-# For newer kernels, Kbuild will be included directly by the kernel
-# build system.
-include $(src)/Kbuild
-endif
--- a/drivers/dahdi/dahdi-base.c
+++ b/drivers/dahdi/dahdi-base.c
--- a/drivers/dahdi/dahdi-sysfs-chan.c
+++ b/drivers/dahdi/dahdi-sysfs-chan.c
@@ -0,0 +1,483 @@
+/* dahdi-sysfs-chan.c
+ *
+ * Copyright (C) 2011-2012, Xorcom
+ * Copyright (C) 2011-2012, 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/version.h>
+
+#define DAHDI_PRINK_MACROS_USE_debug
+#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"
+
+/* shortcuts, for code readability */
+#define MAKE_DAHDI_DEV(num, name) \
+	CLASS_DEV_CREATE(dahdi_class, MKDEV(DAHDI_MAJOR, num), NULL, name)
+#define DEL_DAHDI_DEV(num) \
+	CLASS_DEV_DESTROY(dahdi_class, MKDEV(DAHDI_MAJOR, num))
+
+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)
+{
+	struct device *dev;
+	struct dahdi_span *span;
+	int res;
+	dev_t devt;
+
+	chan_dbg(DEVICES, chan, "Creating channel %d\n", chan->channo);
+	if (test_bit(DAHDI_FLAGBIT_DEVFILE, &chan->flags))
+		return 0;
+	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!channels!%d!%d", 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);
+	return 0;
+}
+
+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;
+	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);
+}
+
+/*
+ * Used by dahdi_transcode.c
+ */
+int dahdi_register_chardev(struct dahdi_chardev *dev)
+{
+	static const char *DAHDI_STRING = "dahdi!";
+	char *udevname;
+
+	udevname = kzalloc(strlen(dev->name) + sizeof(DAHDI_STRING) + 1,
+			GFP_KERNEL);
+	if (!udevname)
+		return -ENOMEM;
+
+	strcpy(udevname, DAHDI_STRING);
+	strcat(udevname, dev->name);
+	MAKE_DAHDI_DEV(dev->minor, udevname);
+	kfree(udevname);
+	return 0;
+}
+EXPORT_SYMBOL(dahdi_register_chardev);
+
+/*
+ * Used by dahdi_transcode.c
+ */
+int dahdi_unregister_chardev(struct dahdi_chardev *dev)
+{
+	DEL_DAHDI_DEV(dev->minor);
+	return 0;
+}
+EXPORT_SYMBOL(dahdi_unregister_chardev);
+
+/*--------- Sysfs Device handling ----*/
+
+/*
+ * Describe fixed device files and maintain their
+ * pointer so fixed_devfiles_remove() can always be called
+ * and work cleanly
+ */
+static struct {
+	int	minor;
+	char	*name;
+	void	*dev;	/* FIXME: wrong type because of old kernels */
+} fixed_minors[] = {
+	{ DAHDI_CTL,		"dahdi!ctl",	},
+	{ DAHDI_TIMER,		"dahdi!timer",	},
+	{ DAHDI_CHANNEL,	"dahdi!channel",},
+	{ DAHDI_PSEUDO,		"dahdi!pseudo",	},
+};
+
+/*
+ * Removes /dev/dahdi/{ctl,timer,channel,pseudo}
+ *
+ * It is safe to call it during initialization error handling,
+ * as it skips non existing objects.
+ */
+static void fixed_devfiles_remove(void)
+{
+	int i;
+
+	if (!dahdi_class)
+		return;
+	for (i = 0; i < ARRAY_SIZE(fixed_minors); i++) {
+		void *d = fixed_minors[i].dev;
+		if (d && !IS_ERR(d))
+			dahdi_dbg(DEVICES, "Removing fixed device file %s\n",
+				fixed_minors[i].name);
+			DEL_DAHDI_DEV(fixed_minors[i].minor);
+	}
+}
+
+/*
+ * Creates /dev/dahdi/{ctl,timer,channel,pseudo}
+ */
+static int fixed_devfiles_create(void)
+{
+	int i;
+	int res = 0;
+
+	if (!dahdi_class) {
+		dahdi_err("%s: dahdi_class is not initialized yet!\n",
+				__func__);
+		res = -ENODEV;
+		goto cleanup;
+	}
+	for (i = 0; i < ARRAY_SIZE(fixed_minors); i++) {
+		char *name = fixed_minors[i].name;
+		int minor = fixed_minors[i].minor;
+		void *dummy;
+
+		dahdi_dbg(DEVICES, "Making fixed device file %s\n", name);
+		dummy = (void *)MAKE_DAHDI_DEV(minor, name);
+		if (IS_ERR(dummy)) {
+			int res = PTR_ERR(dummy);
+
+			dahdi_err("%s: failed (%d: %s). Error: %d\n",
+					__func__, minor, name, res);
+			goto cleanup;
+		}
+		fixed_minors[i].dev = dummy;
+	}
+	return 0;
+cleanup:
+	fixed_devfiles_remove();
+	return res;
+}
+
+/*
+ * Called during driver unload and while handling any error during
+ * driver load.
+ * Always clean any (and only) objects that were initialized (invariant)
+ */
+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);
+		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();
+	return res;
+}
+
+void dahdi_sysfs_chan_exit(void)
+{
+	sysfs_channels_cleanup();
+}
--- a/drivers/dahdi/dahdi-sysfs.c
+++ b/drivers/dahdi/dahdi-sysfs.c
@@ -1,123 +1,346 @@
+/* dahdi-sysfs.c
+ *
+ * Copyright (C) 2011-2012, Xorcom
+ * Copyright (C) 2011-2012, 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/version.h>
 #define DAHDI_PRINK_MACROS_USE_debug
 #include <dahdi/kernel.h>
 #include <linux/device.h>
 #include <linux/slab.h>
+#include <linux/ctype.h>

 #include "dahdi.h"
-
-/* FIXME: Move to kernel.h */
-#define module_printk(level, fmt, args...) printk(level "%s: " fmt, THIS_MODULE->name, ## args)
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-#define CLASS_DEV_CREATE(class, devt, device, name) \
-	device_create(class, device, devt, NULL, "%s", name)
-#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
-#define CLASS_DEV_CREATE(class, devt, device, name) \
-	device_create(class, device, devt, name)
-#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
-#define CLASS_DEV_CREATE(class, devt, device, name) \
-        class_device_create(class, NULL, devt, device, name)
-#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
-#define CLASS_DEV_CREATE(class, devt, device, name) \
-        class_device_create(class, devt, device, name)
-#else
-#define CLASS_DEV_CREATE(class, devt, device, name) \
-        class_simple_device_add(class, devt, device, name)
-#endif
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
-#define CLASS_DEV_DESTROY(class, devt) \
-	device_destroy(class, devt)
-#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
-#define CLASS_DEV_DESTROY(class, devt) \
-	class_device_destroy(class, devt)
-#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,9)
-#define CLASS_DEV_DESTROY(class, devt) \
-	class_simple_device_remove(devt)
-#else
-#define CLASS_DEV_DESTROY(class, devt) \
-	class_simple_device_remove(class, devt)
-#endif
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
-static struct class *dahdi_class = NULL;
-#else
-static struct class_simple *dahdi_class = NULL;
-#define class_create class_simple_create
-#define class_destroy class_simple_destroy
-#endif
+#include "dahdi-sysfs.h"


-int dahdi_register_chardev(struct dahdi_chardev *dev)
+static char *initdir = "/usr/share/dahdi";
+module_param(initdir, charp, 0644);
+
+static int span_match(struct device *dev, struct device_driver *driver)
 {
-	static const char *DAHDI_STRING = "dahdi!";
-	char *udevname;
+	return 1;
+}

-	udevname = kzalloc(strlen(dev->name) + sizeof(DAHDI_STRING) + 1,
-			   GFP_KERNEL);
-	if (!udevname)
-		return -ENOMEM;
+static inline struct dahdi_span *dev_to_span(struct device *dev)
+{
+	return dev_get_drvdata(dev);
+}

-	strcpy(udevname, DAHDI_STRING);
-	strcat(udevname, dev->name);
-	CLASS_DEV_CREATE(dahdi_class, MKDEV(DAHDI_MAJOR, dev->minor), NULL, udevname);
-	kfree(udevname);
+#define	SPAN_VAR_BLOCK	\
+	do {		\
+		DAHDI_ADD_UEVENT_VAR("DAHDI_INIT_DIR=%s", initdir);	\
+		DAHDI_ADD_UEVENT_VAR("SPAN_NUM=%d", span->spanno);	\
+		DAHDI_ADD_UEVENT_VAR("SPAN_NAME=%s", span->name);	\
+	} 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 span_uevent(struct device *dev, char **envp, int num_envp,
+		char *buffer, int buffer_size)
+{
+	struct dahdi_span	*span;
+	int			i = 0;
+	int			len = 0;
+
+	if (!dev)
+		return -ENODEV;
+
+	span = dev_to_span(dev);
+	if (!span)
+		return -ENODEV;
+
+	dahdi_dbg(GENERAL, "SYFS dev_name=%s span=%s\n",
+			dev_name(dev), span->name);
+	SPAN_VAR_BLOCK;
+	envp[i] = NULL;
 	return 0;
 }
-EXPORT_SYMBOL(dahdi_register_chardev);

-int dahdi_unregister_chardev(struct dahdi_chardev *dev)
+#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 span_uevent(struct device *dev, struct kobj_uevent_env *kenv)
 {
-	CLASS_DEV_DESTROY(dahdi_class, MKDEV(DAHDI_MAJOR, dev->minor));
+	struct dahdi_span *span;

+	if (!dev)
+		return -ENODEV;
+	span = dev_to_span(dev);
+	if (!span)
+		return -ENODEV;
+	dahdi_dbg(GENERAL, "SYFS dev_name=%s span=%s\n",
+			dev_name(dev), span->name);
+	SPAN_VAR_BLOCK;
 	return 0;
 }
-EXPORT_SYMBOL(dahdi_unregister_chardev);
+
+#endif
+
+#define span_attr(field, format_string)				\
+static BUS_ATTR_READER(field##_show, dev, buf)			\
+{								\
+	struct dahdi_span *span;				\
+								\
+	span = dev_to_span(dev);				\
+	return sprintf(buf, format_string, span->field);	\
+}
+
+span_attr(name, "%s\n");
+span_attr(desc, "%s\n");
+span_attr(alarms, "0x%x\n");
+span_attr(lbo, "%d\n");
+span_attr(syncsrc, "%d\n");
+
+static BUS_ATTR_READER(spantype_show, dev, buf)
+{
+	struct dahdi_span *span;
+
+	span = dev_to_span(dev);
+	return sprintf(buf, "%s\n", dahdi_spantype2str(span->spantype));
+}
+
+static BUS_ATTR_READER(local_spanno_show, dev, buf)
+{
+	struct dahdi_span *span;
+
+	span = dev_to_span(dev);
+	return sprintf(buf, "%d\n", local_spanno(span));
+}
+
+static BUS_ATTR_READER(is_digital_show, dev, buf)
+{
+	struct dahdi_span *span;
+
+	span = dev_to_span(dev);
+	return sprintf(buf, "%d\n", dahdi_is_digital_span(span));
+}
+
+static BUS_ATTR_READER(is_sync_master_show, dev, buf)
+{
+	struct dahdi_span *span;
+
+	span = dev_to_span(dev);
+	return sprintf(buf, "%d\n", dahdi_is_sync_master(span));
+}
+
+static BUS_ATTR_READER(basechan_show, dev, buf)
+{
+	struct dahdi_span *span;
+
+	span = dev_to_span(dev);
+	if (!span->channels)
+		return -ENODEV;
+	return sprintf(buf, "%d\n", span->chans[0]->channo);
+}
+
+static BUS_ATTR_READER(channels_show, dev, buf)
+{
+	struct dahdi_span *span;
+
+	span = dev_to_span(dev);
+	return sprintf(buf, "%d\n", span->channels);
+}
+
+static BUS_ATTR_READER(lineconfig_show, dev, buf)
+{
+	struct dahdi_span *span;
+	int len = 0;
+
+	span = dev_to_span(dev);
+	len += lineconfig_str(span->lineconfig, buf, 20);
+	len += sprintf(buf + len, "\n");
+	return len;
+}
+
+static BUS_ATTR_READER(linecompat_show, dev, buf)
+{
+	struct dahdi_span *span;
+	int bit;
+	int len = 0;
+
+	span = dev_to_span(dev);
+	for (bit = 4; bit <= 12; bit++) {
+		if (span->linecompat & (1 << bit)) {
+			const char *name = dahdi_lineconfig_bit_name(bit);
+			if (name)
+				len += sprintf(buf + len, "%s ", name);
+		}
+	}
+	/* chomp */
+	while (len > 0 && isspace(buf[len - 1]))
+		buf[--len] = '\0';
+	len += sprintf(buf + len, "\n");
+	return len;
+}
+
+static struct device_attribute span_dev_attrs[] = {
+	__ATTR_RO(name),
+	__ATTR_RO(desc),
+	__ATTR_RO(spantype),
+	__ATTR_RO(local_spanno),
+	__ATTR_RO(alarms),
+	__ATTR_RO(lbo),
+	__ATTR_RO(syncsrc),
+	__ATTR_RO(is_digital),
+	__ATTR_RO(is_sync_master),
+	__ATTR_RO(basechan),
+	__ATTR_RO(channels),
+	__ATTR_RO(lineconfig),
+	__ATTR_RO(linecompat),
+	__ATTR_NULL,
+};
+
+static struct driver_attribute dahdi_attrs[] = {
+	__ATTR_NULL,
+};
+
+static struct bus_type spans_bus_type = {
+	.name           = "dahdi_spans",
+	.match          = span_match,
+	.uevent         = span_uevent,
+	.dev_attrs	= span_dev_attrs,
+	.drv_attrs	= dahdi_attrs,
+};
+
+static int span_probe(struct device *dev)
+{
+	struct dahdi_span *span;
+
+	span = dev_to_span(dev);
+	span_dbg(DEVICES, span, "\n");
+	return 0;
+}
+
+static int span_remove(struct device *dev)
+{
+	struct dahdi_span *span;
+
+	span = dev_to_span(dev);
+	span_dbg(DEVICES, span, "\n");
+	return 0;
+}
+
+static struct device_driver dahdi_driver = {
+	.name		= "generic_lowlevel",
+	.bus		= &spans_bus_type,
+	.probe		= span_probe,
+	.remove		= span_remove,
+	.owner		= THIS_MODULE
+};
+
+static void span_uevent_send(struct dahdi_span *span, enum kobject_action act)
+{
+	struct kobject	*kobj;
+
+	kobj = &span->span_device->kobj;
+	span_dbg(DEVICES, span, "SYFS dev_name=%s action=%d\n",
+		dev_name(span->span_device), act);
+	kobject_uevent(kobj, act);
+}
+
+static void span_release(struct device *dev)
+{
+	dahdi_dbg(DEVICES, "%s: %s\n", __func__, dev_name(dev));
+}

 void span_sysfs_remove(struct dahdi_span *span)
 {
+	struct device *span_device;
 	int x;
-	for (x = 0; x < span->channels; x++) {
-		struct dahdi_chan *chan = span->chans[x];
-		if (!test_bit(DAHDI_FLAGBIT_DEVFILE, &chan->flags))
-			continue;

-		CLASS_DEV_DESTROY(dahdi_class,
-				MKDEV(DAHDI_MAJOR, chan->channo));
-		clear_bit(DAHDI_FLAGBIT_DEVFILE, &chan->flags);
-	}
+	span_dbg(DEVICES, span, "\n");
+	span_device = span->span_device;
+
+	if (!span_device)
+		return;
+
+	for (x = 0; x < span->channels; x++)
+		chan_sysfs_remove(span->chans[x]);
+	if (!dev_get_drvdata(span_device))
+		return;
+
+	/* Grab an extra reference to the device since we'll still want it
+	 * after we've unregistered it */
+
+	get_device(span_device);
+	span_uevent_send(span, KOBJ_OFFLINE);
+	device_unregister(span->span_device);
+	dev_set_drvdata(span_device, NULL);
+	span_device->parent = NULL;
+	put_device(span_device);
+	memset(&span->span_device, 0, sizeof(span->span_device));
+	kfree(span->span_device);
+	span->span_device = NULL;
 }

 int span_sysfs_create(struct dahdi_span *span)
 {
+	struct device *span_device;
 	int res = 0;
 	int x;

+	if (span->span_device) {
+		WARN_ON(1);
+		return -EEXIST;
+	}
+
+	span->span_device = kzalloc(sizeof(*span->span_device), GFP_KERNEL);
+	if (!span->span_device)
+		return -ENOMEM;
+
+	span_device = span->span_device;
+	span_dbg(DEVICES, span, "\n");
+
+	span_device->bus = &spans_bus_type;
+	span_device->parent = &span->parent->dev;
+	dev_set_name(span_device, "span-%d", span->spanno);
+	dev_set_drvdata(span_device, span);
+	span_device->release = span_release;
+	res = device_register(span_device);
+	if (res) {
+		span_err(span, "%s: device_register failed: %d\n", __func__,
+				res);
+		kfree(span->span_device);
+		span->span_device = NULL;
+		goto cleanup;
+	}
+
 	for (x = 0; x < span->channels; x++) {
-		struct dahdi_chan *chan = span->chans[x];
-		char chan_name[32];
-		void *dummy;
-
-		if (chan->channo >= 250)
-			continue;
-		if (test_bit(DAHDI_FLAGBIT_DEVFILE, &chan->flags))
-			continue;
-
-		snprintf(chan_name, sizeof(chan_name), "dahdi!%d",
-				chan->channo);
-		dummy = (void *)CLASS_DEV_CREATE(dahdi_class,
-				MKDEV(DAHDI_MAJOR, chan->channo),
-				NULL, chan_name);
-		if (IS_ERR(dummy)) {
-			res = PTR_ERR(dummy);
-			chan_err(chan, "Failed creating sysfs device: %d\n",
-					res);
+		res = chan_sysfs_create(span->chans[x]);
+		if (res)
 			goto cleanup;
-		}
-
-		set_bit(DAHDI_FLAGBIT_DEVFILE, &chan->flags);
 	}
 	return 0;

@@ -126,105 +349,342 @@ cleanup:
 	return res;
 }

-#define MAKE_DAHDI_DEV(num, name) \
-	CLASS_DEV_CREATE(dahdi_class, MKDEV(DAHDI_MAJOR, num), NULL, name)
-#define DEL_DAHDI_DEV(num) \
-	CLASS_DEV_DESTROY(dahdi_class, MKDEV(DAHDI_MAJOR, num))
-
 /* Only used to flag that the device exists: */
 static struct {
-	unsigned int ctl:1;
-	unsigned int timer:1;
-	unsigned int channel:1;
-	unsigned int pseudo:1;
-} dummy_dev;
+	unsigned int clean_dahdi_driver:1;
+	unsigned int clean_span_bus_type:1;
+	unsigned int clean_device_bus:1;
+	unsigned int clean_chardev:1;
+} should_cleanup;

-void dahdi_sysfs_exit(void)
+static inline struct dahdi_device *to_ddev(struct device *dev)
 {
-	if (dummy_dev.pseudo) {
-		dahdi_dbg(DEVICES, "Removing /dev/dahdi/pseudo:\n");
-		DEL_DAHDI_DEV(DAHDI_PSEUDO);
-		dummy_dev.pseudo = 0;
+	return container_of(dev, struct dahdi_device, dev);
+}
+
+static ssize_t
+dahdi_device_manufacturer_show(struct device *dev,
+			       struct device_attribute *attr, char *buf)
+{
+	struct dahdi_device *ddev = to_ddev(dev);
+	return sprintf(buf, "%s\n", ddev->manufacturer);
+}
+
+static ssize_t
+dahdi_device_type_show(struct device *dev,
+		       struct device_attribute *attr, char *buf)
+{
+	struct dahdi_device *ddev = to_ddev(dev);
+	return sprintf(buf, "%s\n", ddev->devicetype);
+}
+
+static ssize_t
+dahdi_device_span_count_show(struct device *dev,
+			     struct device_attribute *attr, char *buf)
+{
+	struct dahdi_device *ddev = to_ddev(dev);
+	unsigned int count = 0;
+	struct list_head *pos;
+
+	list_for_each(pos, &ddev->spans)
+		++count;
+
+	return sprintf(buf, "%d\n", count);
+}
+
+static ssize_t
+dahdi_device_hardware_id_show(struct device *dev,
+			     struct device_attribute *attr, char *buf)
+{
+	struct dahdi_device *ddev = to_ddev(dev);
+
+	return sprintf(buf, "%s\n",
+		(ddev->hardware_id) ? ddev->hardware_id : "");
+}
+
+static ssize_t
+dahdi_device_auto_assign(struct device *dev, struct device_attribute *attr,
+			 const char *buf, size_t count)
+{
+	struct dahdi_device *ddev = to_ddev(dev);
+	dahdi_assign_device_spans(ddev);
+	return count;
+}
+
+static ssize_t
+dahdi_device_assign_span(struct device *dev, struct device_attribute *attr,
+			 const char *buf, size_t count)
+{
+	int ret;
+	struct dahdi_span *span;
+	unsigned int local_span_number;
+	unsigned int desired_spanno;
+	unsigned int desired_basechanno;
+	struct dahdi_device *const ddev = to_ddev(dev);
+
+	ret = sscanf(buf, "%u:%u:%u", &local_span_number, &desired_spanno,
+		     &desired_basechanno);
+	if (ret != 3) {
+		dev_notice(dev, "bad input (should be <num>:<num>:<num>)\n");
+		return -EINVAL;
 	}
-	if (dummy_dev.channel) {
-		dahdi_dbg(DEVICES, "Removing /dev/dahdi/channel:\n");
-		DEL_DAHDI_DEV(DAHDI_CHANNEL);
-		dummy_dev.channel = 0;
+
+	if (desired_spanno && !desired_basechanno) {
+		dev_notice(dev, "Must set span number AND base chan number\n");
+		return -EINVAL;
 	}
-	if (dummy_dev.timer) {
-		dahdi_dbg(DEVICES, "Removing /dev/dahdi/timer:\n");
-		DEL_DAHDI_DEV(DAHDI_TIMER);
-		dummy_dev.timer = 0;
+
+	list_for_each_entry(span, &ddev->spans, device_node) {
+		if (local_span_number == local_spanno(span)) {
+			ret = dahdi_assign_span(span, desired_spanno,
+						desired_basechanno, 1);
+			return (ret) ? ret : count;
+		}
 	}
-	if (dummy_dev.ctl) {
-		dahdi_dbg(DEVICES, "Removing /dev/dahdi/ctl:\n");
-		DEL_DAHDI_DEV(DAHDI_CTL);
-		dummy_dev.ctl = 0;
+	dev_notice(dev, "no match for local span number %d\n",
+		local_span_number);
+	return -EINVAL;
+}
+
+static ssize_t
+dahdi_device_unassign_span(struct device *dev, struct device_attribute *attr,
+			   const char *buf, size_t count)
+{
+	int ret;
+	unsigned int local_span_number;
+	struct dahdi_span *span;
+	struct dahdi_device *const ddev = to_ddev(dev);
+
+	ret = sscanf(buf, "%u", &local_span_number);
+	if (ret != 1)
+		return -EINVAL;
+
+	ret = -ENODEV;
+	list_for_each_entry(span, &ddev->spans, device_node) {
+		if (local_span_number == local_spanno(span))
+			ret = dahdi_unassign_span(span);
 	}
-	if (dahdi_class) {
-		dahdi_dbg(DEVICES, "Destroying DAHDI class:\n");
-		class_destroy(dahdi_class);
-		dahdi_class = NULL;
+	if (-ENODEV == ret) {
+		if (printk_ratelimit()) {
+			dev_info(dev, "'%d' is an invalid local span number.\n",
+				 local_span_number);
+		}
+		return -EINVAL;
 	}
-	unregister_chrdev(DAHDI_MAJOR, "dahdi");
+	return (ret < 0) ? ret : count;
+}
+
+static ssize_t
+dahdi_spantype_show(struct device *dev,
+		    struct device_attribute *attr, char *buf)
+{
+	struct dahdi_device *ddev = to_ddev(dev);
+	int count = 0;
+	ssize_t total = 0;
+	struct dahdi_span *span;
+
+	/* TODO: Make sure this doesn't overflow the page. */
+	list_for_each_entry(span, &ddev->spans, device_node) {
+		count = sprintf(buf, "%d:%s\n",
+			local_spanno(span), dahdi_spantype2str(span->spantype));
+		buf += count;
+		total += count;
+	}
+
+	return total;
+}
+
+static ssize_t
+dahdi_spantype_store(struct device *dev, struct device_attribute *attr,
+		     const char *buf, size_t count)
+{
+	struct dahdi_device *const ddev = to_ddev(dev);
+	int ret;
+	struct dahdi_span *span;
+	unsigned int local_span_number;
+	char spantype_name[80];
+	enum spantypes spantype;
+
+	ret = sscanf(buf, "%u:%70s", &local_span_number, spantype_name);
+	if (ret != 2) {
+		dev_err(&ddev->dev, "Wrong input format: '%s'\n", buf);
+		return -EINVAL;
+	}
+	spantype = dahdi_str2spantype(spantype_name);
+	if (spantype == SPANTYPE_INVALID) {
+		dev_err(&ddev->dev, "Invalid spantype: '%s'\n", buf);
+		return -EINVAL;
+	}
+
+	list_for_each_entry(span, &ddev->spans, device_node) {
+		if (local_spanno(span) == local_span_number)
+			break;
+	}
+
+	if (test_bit(DAHDI_FLAGBIT_REGISTERED, &span->flags)) {
+		module_printk(KERN_WARNING, "Span %s is already assigned.\n",
+			      span->name);
+		return -EINVAL;
+	}
+
+	if (local_spanno(span) != local_span_number) {
+		module_printk(KERN_WARNING,
+				"%d is not a valid local span number "
+				"for this device.\n", local_span_number);
+		return -EINVAL;
+	}
+
+	if (!span->ops->set_spantype) {
+		module_printk(KERN_WARNING, "Span %s does not support "
+			      "setting type.\n", span->name);
+		return -EINVAL;
+	}
+
+	ret = span->ops->set_spantype(span, spantype);
+	return (ret < 0) ? ret : count;
+}
+
+static struct device_attribute dahdi_device_attrs[] = {
+	__ATTR(manufacturer, S_IRUGO, dahdi_device_manufacturer_show, NULL),
+	__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(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),
+	__ATTR(spantype, S_IWUSR | S_IRUGO, dahdi_spantype_show,
+	       dahdi_spantype_store),
+	__ATTR_NULL,
+};
+
+static struct bus_type dahdi_device_bus = {
+	.name = "dahdi_devices",
+	.dev_attrs = dahdi_device_attrs,
+};
+
+static void dahdi_sysfs_cleanup(void)
+{
+	dahdi_dbg(DEVICES, "SYSFS\n");
+	if (should_cleanup.clean_dahdi_driver) {
+		dahdi_dbg(DEVICES, "Unregister driver\n");
+		driver_unregister(&dahdi_driver);
+		should_cleanup.clean_dahdi_driver = 0;
+	}
+	if (should_cleanup.clean_span_bus_type) {
+		dahdi_dbg(DEVICES, "Unregister span bus type\n");
+		bus_unregister(&spans_bus_type);
+		should_cleanup.clean_span_bus_type = 0;
+	}
+	dahdi_sysfs_chan_exit();
+	if (should_cleanup.clean_chardev) {
+		dahdi_dbg(DEVICES, "Unregister character device\n");
+		unregister_chrdev(DAHDI_MAJOR, "dahdi");
+		should_cleanup.clean_chardev = 0;
+	}
+
+	if (should_cleanup.clean_device_bus) {
+		dahdi_dbg(DEVICES, "Unregister DAHDI device bus\n");
+		bus_unregister(&dahdi_device_bus);
+		should_cleanup.clean_device_bus = 0;
+	}
+}
+
+static void dahdi_device_release(struct device *dev)
+{
+	struct dahdi_device *ddev = container_of(dev, struct dahdi_device, dev);
+	kfree(ddev);
+}
+
+/**
+ * dahdi_sysfs_add_device - Add the dahdi_device into the sysfs hierarchy.
+ * @ddev:	The device to add.
+ * @parent:	The physical device that is implementing this device.
+ *
+ * By adding the dahdi_device to the sysfs hierarchy user space can control
+ * how spans are numbered.
+ *
+ */
+int dahdi_sysfs_add_device(struct dahdi_device *ddev, struct device *parent)
+{
+	int ret;
+	struct device *const dev = &ddev->dev;
+	const char *dn;
+
+	dev->parent = parent;
+	dev->bus = &dahdi_device_bus;
+	dn = dev_name(dev);
+	if (!dn || !*dn) {
+		/* Invent default name based on parent */
+		if (!parent)
+			return -EINVAL;
+		dev_set_name(dev, "%s:%s", parent->bus->name, dev_name(parent));
+	}
+	ret = device_add(dev);
+	return ret;
+}
+
+void dahdi_sysfs_init_device(struct dahdi_device *ddev)
+{
+	device_initialize(&ddev->dev);
+	ddev->dev.release = dahdi_device_release;
+}
+
+void dahdi_sysfs_unregister_device(struct dahdi_device *ddev)
+{
+	device_del(&ddev->dev);
 }

 int __init dahdi_sysfs_init(const struct file_operations *dahdi_fops)
 {
 	int res = 0;
-	void *dev;

+	dahdi_dbg(DEVICES, "Registering DAHDI device bus\n");
+	res = bus_register(&dahdi_device_bus);
+	if (res)
+		return res;
+	should_cleanup.clean_device_bus = 1;
+
+	dahdi_dbg(DEVICES,
+		"Registering character device (major=%d)\n", DAHDI_MAJOR);
 	res = register_chrdev(DAHDI_MAJOR, "dahdi", dahdi_fops);
 	if (res) {
-		module_printk(KERN_ERR, "Unable to register DAHDI character device handler on %d\n", DAHDI_MAJOR);
+		module_printk(KERN_ERR,
+			"Unable to register DAHDI character device "
+			"handler on %d\n", DAHDI_MAJOR);
 		return res;
 	}
+	should_cleanup.clean_chardev = 1;
+
+	res = dahdi_sysfs_chan_init(dahdi_fops);
+	if (res)
+		goto cleanup;
+
+	res = bus_register(&spans_bus_type);
+	if (res) {
+		dahdi_err("%s: bus_register(%s) failed. Error number %d",
+			__func__, spans_bus_type.name, res);
+		goto cleanup;
+	}
+	should_cleanup.clean_span_bus_type = 1;
+
+	res = driver_register(&dahdi_driver);
+	if (res) {
+		dahdi_err("%s: driver_register(%s) failed. Error number %d",
+			__func__, dahdi_driver.name, res);
+		goto cleanup;
+	}
+	should_cleanup.clean_dahdi_driver = 1;
+
 	module_printk(KERN_INFO, "Telephony Interface Registered on major %d\n",
 			DAHDI_MAJOR);
-	module_printk(KERN_INFO, "Version: %s\n", dahdi_version);
-
-	dahdi_class = class_create(THIS_MODULE, "dahdi");
-	if (!dahdi_class) {
-		res = -EEXIST;
-		goto cleanup;
-	}
-
-	dahdi_dbg(DEVICES, "Creating /dev/dahdi/timer:\n");
-	dev = MAKE_DAHDI_DEV(DAHDI_TIMER, "dahdi!timer");
-	if (IS_ERR(dev)) {
-		res = PTR_ERR(dev);
-		goto cleanup;
-	}
-	dummy_dev.timer = 1;
-
-	dahdi_dbg(DEVICES, "Creating /dev/dahdi/channel:\n");
-	dev = MAKE_DAHDI_DEV(DAHDI_CHANNEL, "dahdi!channel");
-	if (IS_ERR(dev)) {
-		res = PTR_ERR(dev);
-		goto cleanup;
-	}
-	dummy_dev.channel = 1;
-
-	dahdi_dbg(DEVICES, "Creating /dev/dahdi/pseudo:\n");
-	dev = MAKE_DAHDI_DEV(DAHDI_PSEUDO, "dahdi!pseudo");
-	if (IS_ERR(dev)) {
-		res = PTR_ERR(dev);
-		goto cleanup;
-	}
-	dummy_dev.pseudo = 1;
-
-	dahdi_dbg(DEVICES, "Creating /dev/dahdi/ctl:\n");
-	dev = MAKE_DAHDI_DEV(DAHDI_CTL, "dahdi!ctl");
-	if (IS_ERR(dev)) {
-		res = PTR_ERR(dev);
-		goto cleanup;
-	}
-	dummy_dev.ctl = 1;
-
 	return 0;

 cleanup:
-	dahdi_sysfs_exit();
+	dahdi_sysfs_cleanup();
 	return res;
 }

+void dahdi_sysfs_exit(void)
+{
+	dahdi_sysfs_cleanup();
+}
--- a/drivers/dahdi/dahdi-sysfs.h
+++ b/drivers/dahdi/dahdi-sysfs.h
@@ -0,0 +1,55 @@
+#ifndef	DAHDI_SYSFS_H
+#define	DAHDI_SYSFS_H
+
+#define	DEVICE_ATTR_READER(name, dev, buf) \
+		ssize_t name(struct device *dev, \
+			struct device_attribute *attr, \
+			char *buf)
+#define	DEVICE_ATTR_WRITER(name, dev, buf, count) \
+		ssize_t name(struct device *dev, \
+			struct device_attribute *attr, \
+			const char *buf, size_t count)
+#define BUS_ATTR_READER(name, dev, buf) \
+	ssize_t name(struct device *dev, \
+		struct device_attribute *attr, \
+		char *buf)
+#define BUS_ATTR_WRITER(name, dev, buf, count) \
+		ssize_t name(struct device *dev, \
+			struct device_attribute *attr, \
+			const char *buf, size_t count)
+
+#define	DRIVER_ATTR_READER(name, drv, buf)	\
+		ssize_t name(struct device_driver *drv, char * buf)
+
+/* Device file creation macros */
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
+#define CLASS_DEV_CREATE(class, devt, device, name) \
+	device_create(class, device, devt, NULL, "%s", name)
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
+#define CLASS_DEV_CREATE(class, devt, device, name) \
+	device_create(class, device, devt, name)
+#else
+#define CLASS_DEV_CREATE(class, devt, device, name) \
+	class_device_create(class, NULL, devt, device, name)
+#endif
+
+/* Device file destruction macros */
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
+#define CLASS_DEV_DESTROY(class, devt) \
+	device_destroy(class, devt)
+#else
+#define CLASS_DEV_DESTROY(class, devt) \
+	class_device_destroy(class, devt)
+#endif
+
+/* Global */
+int __init dahdi_sysfs_chan_init(const struct file_operations *fops);
+void dahdi_sysfs_chan_exit(void);
+
+/* Channel Handling */
+int chan_sysfs_create(struct dahdi_chan *chan);
+void chan_sysfs_remove(struct dahdi_chan *chan);
+
+#endif	/* DAHDI_SYSFS_H */
--- a/drivers/dahdi/dahdi.h
+++ b/drivers/dahdi/dahdi.h
@@ -6,6 +6,7 @@
 *
 * Written by Tzafrir Cohen <tzafrir.cohen@xorcom.com>
 * Copyright (C) 2011, Xorcom
+ * Copyright (C) 2011, Digium, Inc
 *
 * All rights reserved.
 *
@@ -34,4 +35,28 @@ void span_sysfs_remove(struct dahdi_span *span);
 int __init dahdi_sysfs_init(const struct file_operations *dahdi_fops);
 void dahdi_sysfs_exit(void);

+void dahdi_sysfs_init_device(struct dahdi_device *ddev);
+int dahdi_sysfs_add_device(struct dahdi_device *ddev, struct device *parent);
+void dahdi_sysfs_unregister_device(struct dahdi_device *ddev);
+
+int dahdi_assign_span(struct dahdi_span *span, unsigned int spanno,
+			unsigned int basechan, int prefmaster);
+int dahdi_unassign_span(struct dahdi_span *span);
+int dahdi_assign_device_spans(struct dahdi_device *ddev);
+
+static inline int get_span(struct dahdi_span *span)
+{
+	return try_module_get(span->ops->owner);
+}
+
+static inline void put_span(struct dahdi_span *span)
+{
+	module_put(span->ops->owner);
+}
+
+static inline int local_spanno(struct dahdi_span *span)
+{
+	return span->offset + 1;
+}
+
 #endif /* _DAHDI_H */
--- a/drivers/dahdi/dahdi_dummy.c
+++ b/drivers/dahdi/dahdi_dummy.c
@@ -10,7 +10,7 @@
 * Converted to use HighResTimers on i386 by Jeffery Palmer <jeff@triggerinc.com>
 *
 * Copyright (C) 2002, Hermes Softlab
- * Copyright (C) 2004-2009, Digium, Inc.
+ * Copyright (C) 2004-2012, Digium, Inc.
 *
 * All rights reserved.
 *
@@ -53,7 +53,7 @@
 #if defined(USE_HIGHRESTIMER)
 #include <linux/hrtimer.h>
 #else
-#include <linux/time.h>
+#include <linux/timer.h>
 #endif

 #include <dahdi/kernel.h>
@@ -75,6 +75,7 @@ static inline void hrtimer_set_expires(struct hrtimer *timer, ktime_t time)
 #endif

 struct dahdi_dummy {
+	struct dahdi_device *ddev;
 	struct dahdi_span span;
 	struct dahdi_chan _chan;
 	struct dahdi_chan *chan;
@@ -205,37 +206,44 @@ static const struct dahdi_span_ops dummy_ops = {

 static int dahdi_dummy_initialize(struct dahdi_dummy *ztd)
 {
+	int res = 0;
 	/* DAHDI stuff */
+	ztd->ddev = dahdi_create_device();
+	if (!ztd->ddev)
+		return -ENOMEM;
+	dev_set_name(&ztd->ddev->dev, "dahdi_dummy");
 	ztd->chan = &ztd->_chan;
 	sprintf(ztd->span.name, "DAHDI_DUMMY/1");
 	snprintf(ztd->span.desc, sizeof(ztd->span.desc) - 1, "%s (source: " CLOCK_SRC ") %d", ztd->span.name, 1);
 	sprintf(ztd->chan->name, "DAHDI_DUMMY/%d/%d", 1, 0);
-	strlcpy(ztd->span.devicetype, "DAHDI Dummy Timing",
-		sizeof(ztd->span.devicetype));
+	ztd->ddev->devicetype = "DAHDI Dummy Timing";
 	ztd->chan->chanpos = 1;
 	ztd->span.chans = &ztd->chan;
 	ztd->span.channels = 0;		/* no channels on our span */
 	ztd->span.deflaw = DAHDI_LAW_MULAW;
 	ztd->chan->pvt = ztd;
 	ztd->span.ops = &dummy_ops;
-	if (dahdi_register(&ztd->span, 0)) {
-		return -1;
-	}
-	return 0;
+	list_add_tail(&ztd->span.device_node, &ztd->ddev->spans);
+	res = dahdi_register_device(ztd->ddev, NULL);
+	return res;
 }

 int init_module(void)
 {
+	int res;
 	ztd = kzalloc(sizeof(*ztd), GFP_KERNEL);
 	if (ztd == NULL) {
 		printk(KERN_ERR "dahdi_dummy: Unable to allocate memory\n");
 		return -ENOMEM;
 	}

-	if (dahdi_dummy_initialize(ztd)) {
-		printk(KERN_ERR "dahdi_dummy: Unable to intialize DAHDI driver\n");
+	res = dahdi_dummy_initialize(ztd);
+	if (res) {
+		printk(KERN_ERR
+		       "dahdi_dummy: Unable to intialize DAHDI driver (%d)\n",
+		       res);
 		kfree(ztd);
-		return -ENODEV;
+		return res;
 	}

 #if defined(USE_HIGHRESTIMER)
@@ -273,7 +281,8 @@ void cleanup_module(void)
 	atomic_set(&shutdown, 1);
 	del_timer_sync(&timer);
 #endif
-	dahdi_unregister(&ztd->span);
+	dahdi_unregister_device(ztd->ddev);
+	dahdi_free_device(ztd->ddev);
 	kfree(ztd);
 	if (debug)
 		printk(KERN_DEBUG "dahdi_dummy: cleanup() finished\n");
--- a/drivers/dahdi/dahdi_dynamic.c
+++ b/drivers/dahdi/dahdi_dynamic.c
@@ -3,7 +3,7 @@
 *
 * Written by Mark Spencer <markster@digium.com>
 *
- * Copyright (C) 2001-2010, Digium, Inc.
+ * Copyright (C) 2001-2012, Digium, Inc.
 *
 * All rights reserved.
 *
@@ -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();
 }

@@ -385,32 +400,18 @@ static void dahdi_dynamic_release(struct kref *kref)

 	WARN_ON(test_bit(DAHDI_FLAGBIT_REGISTERED, &d->span.flags));

-	if (d->pvt) {
-		if (d->driver && d->driver->destroy) {
-			__module_get(d->driver->owner);
-			d->driver->destroy(d);
-			module_put(d->driver->owner);
-		} else {
-			WARN_ON(1);
-		}
-	}
-
 	kfree(d->msgbuf);

 	for (x = 0; x < d->span.channels; x++)
 		kfree(d->chans[x]);

+	dahdi_free_device(d->ddev);
 	kfree(d);
 }

 static inline int dynamic_put(struct dahdi_dynamic *d)
 {
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 12)
-	kref_put(&d->kref, dahdi_dynamic_release);
-	return 1;
-#else
 	return kref_put(&d->kref, dahdi_dynamic_release);
-#endif
 }

 static inline void dynamic_get(struct dahdi_dynamic *d)
@@ -469,7 +470,25 @@ static int _destroy_dynamic(struct dahdi_dynamic_span *dds)
 		return -EBUSY;
 	}

-	dahdi_unregister(&d->span);
+	if (d->pvt) {
+		if (d->driver && d->driver->destroy) {
+			if (!try_module_get(d->driver->owner)) {
+				/* The driver for this device is in the
+				 * process of unloading. Leave this dynamic on
+				 * the list so it's cleaned up when the driver
+				 * unregisters. */
+				 dynamic_put(d);
+				 return -ENXIO;
+			}
+			d->driver->destroy(d);
+			module_put(d->driver->owner);
+		} else {
+			WARN_ON(1);
+		}
+		d->pvt = NULL;
+	}
+
+	dahdi_unregister_device(d->ddev);

 	spin_lock_irqsave(&dspan_lock, flags);
 	list_del_rcu(&d->list);
@@ -578,8 +597,8 @@ static int _create_dynamic(struct dahdi_dynamic_span *dds)
 	d = kzalloc(sizeof(*d), GFP_KERNEL);
 	if (!d)
 		return -ENOMEM;
-
 	kref_init(&d->kref);
+	d->ddev = dahdi_create_device();

 	for (x = 0; x < dds->numchans; x++) {
 		d->chans[x] = kzalloc(sizeof(*d->chans[x]), GFP_KERNEL);
@@ -604,9 +623,10 @@ static int _create_dynamic(struct dahdi_dynamic_span *dds)
 	strlcpy(d->dname, dds->driver, sizeof(d->dname));
 	strlcpy(d->addr, dds->addr, sizeof(d->addr));
 	d->timing = dds->timing;
-	sprintf(d->span.name, "DYN/%s/%s", dds->driver, dds->addr);
-	sprintf(d->span.desc, "Dynamic '%s' span at '%s'",
-		dds->driver, dds->addr);
+	snprintf(d->span.name, sizeof(d->span.name), "DYN/%s/%s",
+		 dds->driver, dds->addr);
+	snprintf(d->span.desc, sizeof(d->span.desc),
+		 "Dynamic '%s' span at '%s'", dds->driver, dds->addr);
 	d->span.deflaw = DAHDI_LAW_MULAW;
 	d->span.flags |= DAHDI_FLAG_RBS;
 	d->span.chans = d->chans;
@@ -657,8 +677,12 @@ static int _create_dynamic(struct dahdi_dynamic_span *dds)
 		return res;
 	}

+	d->ddev->devicetype = d->span.name;
+	d->ddev->hardware_id = d->span.name;
+	dev_set_name(&d->ddev->dev, "dynamic:%s:%d", dds->driver, dtd->id++);
+	list_add_tail(&d->span.device_node, &d->ddev->spans);
 	/* Whee!  We're created.  Now register the span */
-	if (dahdi_register(&d->span, 0)) {
+	if (dahdi_register_device(d->ddev, d->dev)) {
 		printk(KERN_NOTICE "Unable to register span '%s'\n",
 			d->span.name);
 		dynamic_put(d);
@@ -699,6 +723,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)
@@ -761,19 +799,17 @@ void dahdi_dynamic_unregister_driver(struct dahdi_dynamic_driver *dri)
 	list_for_each_entry_safe(d, n, &dspan_list, list) {
 		if (d->driver == dri) {
 			if (d->pvt) {
-				if (d->driver && d->driver->destroy) {
-					__module_get(d->driver->owner);
+				if (d->driver && d->driver->destroy)
 					d->driver->destroy(d);
-					module_put(d->driver->owner);
-				} else {
+				else
 					WARN_ON(1);
-				}
 			}
-			dahdi_unregister(&d->span);
+			dahdi_unregister_device(d->ddev);
 			spin_lock_irqsave(&dspan_lock, flags);
 			list_del_rcu(&d->list);
 			spin_unlock_irqrestore(&dspan_lock, flags);
 			synchronize_rcu();
+			d->driver = NULL;
 			dynamic_put(d);
 		}
 	}
@@ -817,10 +853,13 @@ static void check_for_red_alarm(unsigned long ignored)
 	mod_timer(&alarmcheck, jiffies + 1 * HZ);
 }

+static const struct dahdi_dynamic_ops dahdi_dynamic_ops = {
+	.owner = THIS_MODULE,
+	.ioctl = dahdi_dynamic_ioctl,
+};
+
 static int dahdi_dynamic_init(void)
 {
-	dahdi_set_dynamic_ioctl(dahdi_dynamic_ioctl);
-
 	/* Start process to check for RED ALARM */
 	init_timer(&alarmcheck);
 	alarmcheck.expires = 0;
@@ -830,20 +869,31 @@ 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);
+
 	printk(KERN_INFO "DAHDI Dynamic Span support LOADED\n");
 	return 0;
 }

 static void dahdi_dynamic_cleanup(void)
 {
+	dahdi_set_dynamic_ops(NULL);
+
 #ifdef ENABLE_TASKLETS
 	if (taskletpending) {
 		tasklet_disable(&dahdi_dynamic_tlet);
 		tasklet_kill(&dahdi_dynamic_tlet);
 	}
+#else
+	tasklet_disable(&dahdi_dynamic_flush_tlet);
+	tasklet_kill(&dahdi_dynamic_flush_tlet);
 #endif
-	dahdi_set_dynamic_ioctl(NULL);
+	del_timer_sync(&alarmcheck);
+	/* Must call again in case it was running before and rescheduled
+	 * itself. */
 	del_timer(&alarmcheck);
 	printk(KERN_INFO "DAHDI Dynamic Span support unloaded\n");
 }
--- a/drivers/dahdi/dahdi_dynamic_eth.c
+++ b/drivers/dahdi/dahdi_dynamic_eth.c
@@ -3,7 +3,7 @@
 *
 * Written by Mark Spencer <markster@digium.com>
 *
- * Copyright (C) 2001-2008, Digium, Inc.
+ * Copyright (C) 2001-2012, Digium, Inc.
 *
 * All rights reserved.
 *
@@ -71,14 +71,12 @@ static struct dahdi_span *ztdeth_getspan(unsigned char *addr, unsigned short sub
 	if (z)
 		span = z->span;
 	spin_unlock_irqrestore(&zlock, flags);
+	if (!span || !test_bit(DAHDI_FLAGBIT_REGISTERED, &span->flags))
+		return NULL;
 	return span;
 }

-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14)
 static int ztdeth_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
-#else
-static int ztdeth_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt)
-#endif
 {
 	struct dahdi_span *span;
 	struct ztdeth_header *zh;
@@ -87,11 +85,7 @@ static int ztdeth_rcv(struct sk_buff *skb, struct net_device *dev, struct packet
 #else
 	zh = (struct ztdeth_header *)skb->nh.raw;
 #endif
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,9)
 	span = ztdeth_getspan(eth_hdr(skb)->h_source, zh->subaddr);
-#else
-	span = ztdeth_getspan(skb->mac.ethernet->h_source, zh->subaddr);
-#endif	
 	if (span) {
 		skb_pull(skb, sizeof(struct ztdeth_header));
 #ifdef NEW_SKB_LINEARIZE
@@ -152,7 +146,7 @@ static void ztdeth_transmit(struct dahdi_dynamic *dyn, u8 *msg, size_t msglen)

 	spin_lock_irqsave(&zlock, flags);
 	z = dyn->pvt;
-	if (z->dev) {
+	if (z && z->dev) {
 		/* Copy fields to local variables to remove spinlock ASAP */
 		dev = z->dev;
 		memcpy(addr, z->addr, sizeof(z->addr));
@@ -191,15 +185,16 @@ static void ztdeth_transmit(struct dahdi_dynamic *dyn, u8 *msg, size_t msglen)
 		spin_unlock_irqrestore(&zlock, flags);
 }

-
+/**
+ * ztdeth_flush - Flush all pending transactions.
+ *
+ * This function is always called in softirq context.
+ */
 static int ztdeth_flush(void)
 {
 	struct sk_buff *skb;
-
-	/* Handle all transmissions now */
-	while ((skb = skb_dequeue(&skbs))) {
+	while ((skb = skb_dequeue(&skbs)))
 		dev_queue_xmit(skb);
-	}
 	return 0;
 }

@@ -284,11 +279,12 @@ static void ztdeth_destroy(struct dahdi_dynamic *dyn)
 		prev = cur;
 		cur = cur->next;
 	}
-	spin_unlock_irqrestore(&zlock, flags);
 	if (cur == z) {	/* Successfully removed */
+		dyn->pvt = NULL;
 		printk(KERN_INFO "TDMoE: Removed interface for %s\n", z->span->name);
 		kfree(z);
 	}
+	spin_unlock_irqrestore(&zlock, flags);
 }

 static int ztdeth_create(struct dahdi_dynamic *dyn, const char *addr)
@@ -411,20 +407,22 @@ static struct notifier_block ztdeth_nblock = {

 static int __init ztdeth_init(void)
 {
+	skb_queue_head_init(&skbs);
+
 	dev_add_pack(&ztdeth_ptype);
 	register_netdevice_notifier(&ztdeth_nblock);
 	dahdi_dynamic_register_driver(&ztd_eth);

-	skb_queue_head_init(&skbs);
-
 	return 0;
 }

 static void __exit ztdeth_exit(void)
 {
-	dev_remove_pack(&ztdeth_ptype);
-	unregister_netdevice_notifier(&ztdeth_nblock);
 	dahdi_dynamic_unregister_driver(&ztd_eth);
+	unregister_netdevice_notifier(&ztdeth_nblock);
+	dev_remove_pack(&ztdeth_ptype);
+
+	skb_queue_purge(&skbs);
 }

 MODULE_DESCRIPTION("DAHDI Dynamic TDMoE Support");
--- a/drivers/dahdi/dahdi_dynamic_ethmf.c
+++ b/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
@@ -224,13 +225,8 @@ static inline int ethmf_trx_spans_ready(unsigned int addr_hash, struct ztdeth *(
 /**
 * Ethernet receiving side processing function.
 */
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 14)
 static int ztdethmf_rcv(struct sk_buff *skb, struct net_device *dev,
 		struct packet_type *pt, struct net_device *orig_dev)
-#else
-static int ztdethmf_rcv(struct sk_buff *skb, struct net_device *dev,
-		struct packet_type *pt)
-#endif
 {
 	int num_spans = 0, span_index = 0;
 	unsigned char *data;
@@ -267,13 +263,8 @@ static int ztdethmf_rcv(struct sk_buff *skb, struct net_device *dev,

 		rcu_read_lock();
 		do {
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 9)
 			find_ethmf(eth_hdr(skb)->h_source,
 				htons(span_index), &z, &span);
-#else
-			find_ethmf(skb->mac.ethernet->h_source,
-				htons(span_index), &z, &span);
-#endif
 			if (unlikely(!z || !span)) {
 				/* The recv'd span does not belong to us */
 				/* ethmf_errors_inc(); */
@@ -396,10 +387,6 @@ static void ztdethmf_transmit(struct dahdi_dynamic *dyn, u8 *msg, size_t msglen)
 	struct net_device *dev;
 	unsigned char addr[ETH_ALEN];
 	int spans_ready = 0, index = 0;
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 10)
-	static DEFINE_SPINLOCK(lock);
-	unsigned long flags;
-#endif

 	if (atomic_read(&shutdown))
 		return;
@@ -411,24 +398,12 @@ static void ztdethmf_transmit(struct dahdi_dynamic *dyn, u8 *msg, size_t msglen)
 		return;
 	}

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 10)
-	if (!atomic_read(&z->ready)) {
-		spin_lock_irqsave(&lock, flags);
-		atomic_inc(&z->ready);
-		if (1 == atomic_read(&z->ready)) {
-			memcpy(z->msgbuf, msg, msglen);
-			z->msgbuf_len = msglen;
-		}
-		spin_unlock_irqrestore(&lock, flags);
-	}
-#else
 	if (!atomic_read(&z->ready)) {
 		if (atomic_inc_return(&z->ready) == 1) {
 			memcpy(z->msgbuf, msg, msglen);
 			z->msgbuf_len = msglen;
 		}
 	}
-#endif

 	spans_ready = ethmf_trx_spans_ready(z->addr_hash, &ready_spans);
 	if (spans_ready) {
@@ -722,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)
@@ -804,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");
 	}
--- a/drivers/dahdi/dahdi_dynamic_loc.c
+++ b/drivers/dahdi/dahdi_dynamic_loc.c
@@ -78,10 +78,11 @@ static LIST_HEAD(dynamic_local_list);
 static void
 dahdi_dynamic_local_transmit(struct dahdi_dynamic *dyn, u8 *msg, size_t msglen)
 {
-	struct dahdi_dynamic_local *const d = dyn->pvt;
+	struct dahdi_dynamic_local *d;
 	unsigned long flags;

 	spin_lock_irqsave(&local_lock, flags);
+	d = dyn->pvt;
 	if (d && d->peer && d->peer->span) {
 		if (test_bit(DAHDI_FLAGBIT_REGISTERED, &d->peer->span->flags))
 			dahdi_dynamic_receive(d->peer->span, msg, msglen);
@@ -130,11 +131,12 @@ static int digit2int(char d)

 static void dahdi_dynamic_local_destroy(struct dahdi_dynamic *dyn)
 {
-	struct dahdi_dynamic_local *d = dyn->pvt;
+	struct dahdi_dynamic_local *d;
 	unsigned long flags;
 	struct dahdi_dynamic_local *cur;

 	spin_lock_irqsave(&local_lock, flags);
+	d = dyn->pvt;
 	list_for_each_entry(cur, &dynamic_local_list, node) {
 		if (cur->peer == d)
 			cur->peer = NULL;
--- a/drivers/dahdi/dahdi_echocan_jpah.c
+++ b/drivers/dahdi/dahdi_echocan_jpah.c
@@ -7,7 +7,7 @@
 * This "echo can" will completely hose your audio.
 * Don't use it unless you're absolutely sure you know what you're doing.
 *
- * Copyright (C) 2007-2008, Digium, Inc.
+ * Copyright (C) 2007-2012, Digium, Inc.
 *
 * All rights reserved.
 *
@@ -38,9 +38,6 @@

 static int debug;

-#define module_printk(level, fmt, args...) printk(level "%s: " fmt, THIS_MODULE->name, ## args)
-#define debug_printk(level, fmt, args...) if (debug >= level) printk("%s (%s): " fmt, THIS_MODULE->name, __FUNCTION__, ## args)
-
 static int echo_can_create(struct dahdi_chan *chan, struct dahdi_echocanparams *ecp,
 			   struct dahdi_echocanparam *p, struct dahdi_echocan_state **ec);
 static void echo_can_free(struct dahdi_chan *chan, struct dahdi_echocan_state *ec);
--- a/drivers/dahdi/dahdi_echocan_kb1.c
+++ b/drivers/dahdi/dahdi_echocan_kb1.c
@@ -5,7 +5,7 @@
 *
 * Based upon mec2.h
 * 
- * Copyright (C) 2002, Digium, Inc.
+ * Copyright (C) 2002-2012, Digium, Inc.
 *
 * Additional background on the techniques used in this code can be found in:
 *
@@ -44,9 +44,6 @@
 static int debug;
 static int aggressive;

-#define module_printk(level, fmt, args...) printk(level "%s: " fmt, THIS_MODULE->name, ## args)
-#define debug_printk(level, fmt, args...) if (debug >= level) printk(KERN_DEBUG "%s (%s): " fmt, THIS_MODULE->name, __FUNCTION__, ## args)
-
 /* Uncomment to provide summary statistics for overall echo can performance every 4000 samples */ 
 /* #define MEC2_STATS 4000 */

--- a/drivers/dahdi/dahdi_echocan_mg2.c
+++ b/drivers/dahdi/dahdi_echocan_mg2.c
@@ -5,7 +5,7 @@
 *
 * Based upon kb1ec.h and mec2.h
 * 
- * Copyright (C) 2002, Digium, Inc.
+ * Copyright (C) 2002-2012, Digium, Inc.
 *
 * Additional background on the techniques used in this code can be found in:
 *
@@ -44,9 +44,6 @@
 static int debug;
 static int aggressive;

-#define module_printk(level, fmt, args...) printk(level "%s: " fmt, THIS_MODULE->name, ## args)
-#define debug_printk(level, fmt, args...) if (debug >= level) printk("%s (%s): " fmt, THIS_MODULE->name, __FUNCTION__, ## args)
-
 #define ABS(a) abs(a!=-32768?a:-32767)

 #define RESTORE_COEFFS {\
--- a/drivers/dahdi/dahdi_echocan_oslec.c
+++ b/drivers/dahdi/dahdi_echocan_oslec.c
@@ -36,8 +36,6 @@

 #include <dahdi/kernel.h>

-#define module_printk(level, fmt, args...) printk(level "%s: " fmt, THIS_MODULE->name, ## args)
-
 static int echo_can_create(struct dahdi_chan *chan, struct dahdi_echocanparams *ecp,
 			   struct dahdi_echocanparam *p, struct dahdi_echocan_state **ec);
 static void echo_can_free(struct dahdi_chan *chan, struct dahdi_echocan_state *ec);
--- a/drivers/dahdi/dahdi_echocan_sec.c
+++ b/drivers/dahdi/dahdi_echocan_sec.c
@@ -48,9 +48,6 @@

 static int debug;

-#define module_printk(level, fmt, args...) printk(level "%s: " fmt, THIS_MODULE->name, ## args)
-#define debug_printk(level, fmt, args...) if (debug >= level) printk(KERN_DEBUG "%s (%s): " fmt, THIS_MODULE->name, __FUNCTION__, ## args)
-
 #include "arith.h"

 #ifndef NULL
--- a/drivers/dahdi/dahdi_echocan_sec2.c
+++ b/drivers/dahdi/dahdi_echocan_sec2.c
@@ -47,9 +47,6 @@

 static int debug;

-#define module_printk(level, fmt, args...) printk(level "%s: " fmt, THIS_MODULE->name, ## args)
-#define debug_printk(level, fmt, args...) if (debug >= level) printk(KERN_DEBUG "%s (%s): " fmt, THIS_MODULE->name, __FUNCTION__, ## args)
-
 #include "fir.h"

 #ifndef NULL
--- a/drivers/dahdi/firmware/Makefile
+++ b/drivers/dahdi/firmware/Makefile
@@ -22,16 +22,21 @@

 .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
 TC400M_VERSION:=MR6.12
 VPMADT032_VERSION:=1.25.0
 HX8_VERSION:=2.06
-VPMOCT032_VERSION:=1.11.0
+VPMOCT032_VERSION:=1.12.0
+WCT820_VERSION:=1.76
+TE133_VERSION:=6f0017
+TE134_VERSION:=6f0017

 FIRMWARE_URL:=http://downloads.digium.com/pub/telephony/firmware/releases

-ALL_FIRMWARE=FIRMWARE-OCT6114-064 FIRMWARE-OCT6114-128 FIRMWARE-TC400M FIRMWARE-HX8 FIRMWARE-VPMOCT032
+ALL_FIRMWARE=FIRMWARE-OCT6114-032 FIRMWARE-OCT6114-064 FIRMWARE-OCT6114-128 FIRMWARE-OCT6114-256 FIRMWARE-TC400M FIRMWARE-HX8 FIRMWARE-VPMOCT032 FIRMWARE-TE820 FIRMWARE-TE133 FIRMWARE-TE134

 # 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
@@ -40,19 +45,27 @@ ALL_FIRMWARE=FIRMWARE-OCT6114-064 FIRMWARE-OCT6114-128 FIRMWARE-TC400M FIRMWARE-
 # 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)

 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)
 OBJECT_FILES:=$(OBJECT_FILES:FIRMWARE-TC400M=dahdi-fw-tc400m.o)
 OBJECT_FILES:=$(OBJECT_FILES:FIRMWARE-HX8=dahdi-fw-hx8.o)
+OBJECT_FILES:=$(OBJECT_FILES:FIRMWARE-VPMOCT032=dahdi-fw-vpmoct032.o)

 # Force usage of wget, for now
 DOWNLOAD=wget
@@ -101,6 +114,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
@@ -123,6 +147,17 @@ ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-oct6114-12
 else
 	@echo "Firmware dahdi-fw-oct6114-128.bin is already installed with required version $(OCT6114_128_VERSION)"
 endif
+ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-oct6114-256-$(OCT6114_256_VERSION) ] ) && ( [ -f $(DESTDIR)/lib/firmware/.dahdi-fw-oct6114-256-$(OCT6114_256_VERSION) ] ); then echo "no"; else echo "yes"; fi),yes)
+	@echo "Installing dahdi-fw-oct6114-256.bin to hotplug firmware directories"
+	@install -m 644 dahdi-fw-oct6114-256.bin $(DESTDIR)/usr/lib/hotplug/firmware
+	@rm -rf $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-oct6114-256-*
+	@touch $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-oct6114-256-$(OCT6114_256_VERSION)
+	@install -m 644 dahdi-fw-oct6114-256.bin $(DESTDIR)/lib/firmware
+	@rm -rf $(DESTDIR)/lib/firmware/.dahdi-fw-oct6114-256-*
+	@touch $(DESTDIR)/lib/firmware/.dahdi-fw-oct6114-256-$(OCT6114_256_VERSION)
+else
+	@echo "Firmware dahdi-fw-oct6114-256.bin is already installed with required version $(OCT6114_256_VERSION)"
+endif
 ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-tc400m-$(TC400M_VERSION) ] ) && ( [ -f $(DESTDIR)/lib/firmware/.dahdi-fw-tc400m-$(TC400M_VERSION) ] ); then echo "no"; else echo "yes"; fi),yes)
 	@echo "Installing dahdi-fw-tc400m.bin to hotplug firmware directories"
 	@install -m 644 dahdi-fw-tc400m.bin $(DESTDIR)/usr/lib/hotplug/firmware
@@ -156,6 +191,40 @@ ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-vpmoct032-
 else
 	@echo "Firmware dahdi-fw-vpmoct032.bin is already installed with required version $(VPMOCT032_VERSION)"
 endif
+ifeq ($(shell if ( [ -f $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-te820-$(WCT820_VERSION) ] ) && ( [ -f $(DESTDIR)/lib/firmware/.dahdi-fw-te820-$(WCT820_VERSION) ] ); then echo "no"; else echo "yes"; fi),yes)
+	@echo "Installing dahdi-fw-te820.bin to hotplug firmware directories"
+	@install -m 644 dahdi-fw-te820.bin $(DESTDIR)/usr/lib/hotplug/firmware
+	@rm -rf $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-te820-*
+	@touch $(DESTDIR)/usr/lib/hotplug/firmware/.dahdi-fw-te820-$(WCT820_VERSION)
+	@install -m 644 dahdi-fw-te820.bin $(DESTDIR)/lib/firmware
+	@rm -rf $(DESTDIR)/lib/firmware/.dahdi-fw-te820-*
+	@touch $(DESTDIR)/lib/firmware/.dahdi-fw-te820-$(WCT820_VERSION)
+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

 # Uninstall any installed dahdi firmware images from hotplug firmware directories
 hotplug-uninstall:
@@ -174,6 +243,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
@@ -184,7 +258,17 @@ dahdi-fw-oct6114-128.o: dahdi-fw-oct6114-128-$(OCT6114_128_VERSION).tar.gz dahdi
 	@echo Making firmware object file for dahdi-fw-oct6114-128.bin
 	./make_firmware_object dahdi-fw-oct6114-128.bin $@

+# Build object file of an oct6114 256 firmware image for linking
+dahdi-fw-oct6114-256.o: dahdi-fw-oct6114-256-$(OCT6114_256_VERSION).tar.gz dahdi-fw-oct6114-256.bin make_firmware_object
+	@echo Making firmware object file for dahdi-fw-oct6114-256.bin
+	./make_firmware_object dahdi-fw-oct6114-256.bin $@
+
 # Build object file of a TC400M firmware image for linking
 dahdi-fw-tc400m.o: dahdi-fw-tc400m-$(TC400M_VERSION).tar.gz dahdi-fw-tc400m.bin make_firmware_object
 	@echo Making firmware object file for dahdi-fw-tc400m.bin
 	./make_firmware_object dahdi-fw-tc400m.bin $@
+
+# Build object file of a VPMOCT032 firmware image for linking
+dahdi-fw-vpmoct032.o: dahdi-fw-vpmoct032-$(VPMOCT032_VERSION).tar.gz dahdi-fw-vpmoct032.bin make_firmware_object
+	@echo Making firmware object file for dahdi-fw-vpmoct032.bin
+	./make_firmware_object dahdi-fw-vpmoct032.bin $@
--- a/drivers/dahdi/hpec/dahdi_echocan_hpec.c
+++ b/drivers/dahdi/hpec/dahdi_echocan_hpec.c
@@ -1,7 +1,7 @@
 /*
 * DAHDI Telephony Interface to Digium High-Performance Echo Canceller
 *
- * Copyright (C) 2006-2008 Digium, Inc.
+ * Copyright (C) 2006-2012 Digium, Inc.
 *
 * All rights reserved.
 *
@@ -31,9 +31,6 @@

 static int debug;

-#define module_printk(level, fmt, args...) printk(level "%s: " fmt, THIS_MODULE->name, ## args)
-#define debug_printk(level, fmt, args...) if (debug >= level) printk(KERN_DEBUG "%s (%s): " fmt, THIS_MODULE->name, __FUNCTION__, ## args)
-
 #include "hpec_user.h"
 #include "hpec.h"

@@ -75,18 +72,9 @@ static int __attribute__((regparm(0), format(printf, 1, 2))) logger(const char *
 	int res;
 	va_list args;

-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,9)
 	va_start(args, format);
 	res = vprintk(format, args);
 	va_end(args);
-#else
-	char buf[256];
-
-	va_start(args, format);
-	res = vsnprintf(buf, sizeof(buf), format, args);
-	va_end(args);
-	printk(KERN_INFO "%s" buf);
-#endif

 	return res;
 }
--- a/drivers/dahdi/oct612x/Makefile
+++ b/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)
--- a/drivers/dahdi/oct612x/include/oct6100api/oct6100_defines.h
+++ b/drivers/dahdi/oct612x/include/oct6100api/oct6100_defines.h
@@ -397,7 +397,7 @@ $Octasic_Revision: 171 $

 /* Max defines.*/
 #ifndef	cOCT6100_MAX_ECHO_CHANNELS
-#define cOCT6100_MAX_ECHO_CHANNELS				128
+#define cOCT6100_MAX_ECHO_CHANNELS				256
 #endif
 #define cOCT6100_MAX_TSI_CNCTS					1530
 #define cOCT6100_MAX_CALLER_ID_PLAYOUT_BUFFERS	( 3328 + 6 )
--- a/drivers/dahdi/pciradio.c
+++ b/drivers/dahdi/pciradio.c
@@ -146,6 +146,7 @@ struct encdec

 struct pciradio {
 	struct pci_dev *dev;
+	struct dahdi_device *ddev;
 	struct dahdi_span span;
 	unsigned char ios;
 	int usecount;
@@ -1488,7 +1489,7 @@ static int pciradio_initialize(struct pciradio *rad)
 	rad->span.flags = DAHDI_FLAG_RBS;
 	rad->span.ops = &pciradio_span_ops;

-	if (dahdi_register(&rad->span, 0)) {
+	if (dahdi_register_device(rad->ddev, &rad->dev->dev)) {
 		printk(KERN_NOTICE "Unable to register span with DAHDI\n");
 		return -1;
 	}
@@ -1777,7 +1778,7 @@ static int __devinit pciradio_init_one(struct pci_dev *pdev, const struct pci_de
 					release_region(rad->ioaddr, 0xff);
 				pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)rad->writechunk, rad->writedma);
 				pci_set_drvdata(pdev, NULL);
-				dahdi_unregister(&rad->span);
+				dahdi_free_device(rad->ddev);
 				kfree(rad);
 				return -EIO;

@@ -1810,7 +1811,7 @@ static int __devinit pciradio_init_one(struct pci_dev *pdev, const struct pci_de

 static void pciradio_release(struct pciradio *rad)
 {
-	dahdi_unregister(&rad->span);
+	dahdi_unregister_device(rad->ddev);
 	if (rad->freeregion)
 		release_region(rad->ioaddr, 0xff);
 	kfree(rad);
--- a/drivers/dahdi/tor2.c
+++ b/drivers/dahdi/tor2.c
@@ -97,6 +97,7 @@ struct tor2 {
 	unsigned long xilinx8_region;	/* 8 bit Region allocated to Xilinx */
 	unsigned long xilinx8_len;	/* Length of 8 bit Xilinx region */
 	__iomem volatile unsigned char *mem8;	/* Virtual representation of 8 bit Xilinx memory area */
+	struct dahdi_device *ddev;
 	struct tor2_span tspans[SPANS_PER_CARD];	/* Span data */
 	struct dahdi_chan **chans[SPANS_PER_CARD]; /* Pointers to card channels */
 	struct tor2_chan tchans[32 * SPANS_PER_CARD];	/* Channel user data */
@@ -285,20 +286,16 @@ static void init_spans(struct tor2 *tor)
 		snprintf(s->desc, sizeof(s->desc) - 1,
 			 "Tormenta 2 (PCI) Quad %s Card %d Span %d",
 			 (tor->cardtype == TYPE_T1)  ?  "T1"  :  "E1", tor->num, x + 1);
-		s->manufacturer = "Digium";
-		strlcpy(s->devicetype, tor->type, sizeof(s->devicetype));
-		snprintf(s->location, sizeof(s->location) - 1,
-			 "PCI Bus %02d Slot %02d", tor->pci->bus->number, PCI_SLOT(tor->pci->devfn) + 1);
 		if (tor->cardtype == TYPE_T1) {
 			s->channels = 24;
 			s->deflaw = DAHDI_LAW_MULAW;
 			s->linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF;
-			s->spantype = "T1";
+			s->spantype = SPANTYPE_DIGITAL_T1;
 		} else {
 			s->channels = 31;
 			s->deflaw = DAHDI_LAW_ALAW;
 			s->linecompat = DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
-			s->spantype = "E1";
+			s->spantype = SPANTYPE_DIGITAL_E1;
 		}
 		s->chans = tor->chans[x];
 		s->flags = DAHDI_FLAG_RBS;
@@ -322,19 +319,31 @@ static void init_spans(struct tor2 *tor)

 static int __devinit tor2_launch(struct tor2 *tor)
 {
+	int res;
 	struct dahdi_span *s;
 	int i;

 	if (test_bit(DAHDI_FLAGBIT_REGISTERED, &tor->tspans[0].dahdi_span.flags))
 		return 0;

+	tor->ddev = dahdi_create_device();
+	tor->ddev->location = kasprintf(GFP_KERNEL, "PCI Bus %02d Slot %02d",
+				       tor->pci->bus->number,
+				       PCI_SLOT(tor->pci->devfn) + 1);
+
+	if (!tor->ddev->location)
+		return -ENOMEM;
+
 	printk(KERN_INFO "Tor2: Launching card: %d\n", tor->order);
 	for (i = 0; i < SPANS_PER_CARD; ++i) {
 		s = &tor->tspans[i].dahdi_span;
-		if (dahdi_register(s, 0)) {
-			printk(KERN_ERR "Unable to register span %s\n", s->name);
-			goto error_exit;
-		}
+		list_add_tail(&s->device_node, &tor->ddev->spans);
+	}
+
+	res = dahdi_register_device(tor->ddev, &tor->pci->dev);
+	if (res) {
+		dev_err(&tor->pci->dev, "Unable to register with DAHDI.\n");
+		return res;
 	}
 	writew(PLX_INTENA, &tor->plx[INTCSR]); /* enable PLX interrupt */

@@ -342,14 +351,6 @@ static int __devinit tor2_launch(struct tor2 *tor)
 	tasklet_init(&tor->tor2_tlet, tor2_tasklet, (unsigned long)tor);
 #endif
 	return 0;
-
-error_exit:
-	for (i = 0; i < SPANS_PER_CARD; ++i) {
-		s = &tor->tspans[i].dahdi_span;
-		if (test_bit(DAHDI_FLAGBIT_REGISTERED, &s->flags))
-			dahdi_unregister(s);
-	}
-	return -1;
 }

 static void free_tor(struct tor2 *tor)
@@ -365,6 +366,8 @@ static void free_tor(struct tor2 *tor)
 		if (tor->chans[x])
 			kfree(tor->chans[x]);
 	}
+	kfree(tor->ddev->location);
+	dahdi_free_device(tor->ddev);
 	kfree(tor);
 }

@@ -631,7 +634,6 @@ static struct pci_driver tor2_driver;
 static void __devexit tor2_remove(struct pci_dev *pdev)
 {
 	struct tor2 *tor;
-	int i;

 	tor = pci_get_drvdata(pdev);
 	if (!tor)
@@ -641,11 +643,7 @@ static void __devexit tor2_remove(struct pci_dev *pdev)
 	writeb(0, &tor->mem8[LEDREG]);
 	writew(0, &tor->plx[INTCSR]);
 	free_irq(tor->irq, tor);
-	for (i = 0; i < SPANS_PER_CARD; ++i) {
-		struct dahdi_span *s = &tor->tspans[i].dahdi_span;
-		if (test_bit(DAHDI_FLAGBIT_REGISTERED, &s->flags))
-			dahdi_unregister(s);
-	}
+	dahdi_unregister_device(tor->ddev);
 	release_mem_region(tor->plx_region, tor->plx_len);
 	release_mem_region(tor->xilinx32_region, tor->xilinx32_len);
 	release_mem_region(tor->xilinx8_region, tor->xilinx8_len);
--- a/drivers/dahdi/voicebus/GpakCust.c
+++ b/drivers/dahdi/voicebus/GpakCust.c
@@ -126,8 +126,8 @@ static int vpmadt032_getreg_full_return(struct vpmadt032 *vpm, int pagechange,
 	unsigned long ret;
 	BUG_ON(!cmd);

-	/* We'll wait for 200ms */
-	ret = wait_for_completion_timeout(&cmd->complete, HZ/5);
+	/* We'll wait for 2s */
+	ret = wait_for_completion_timeout(&cmd->complete, HZ*2);
 	if (unlikely(!ret)) {
 		spin_lock_irqsave(&vpm->list_lock, flags);
 		list_del(&cmd->node);
--- a/drivers/dahdi/voicebus/GpakCust.h
+++ b/drivers/dahdi/voicebus/GpakCust.h
@@ -36,6 +36,7 @@
 #ifndef _GPAKCUST_H  /* prevent multiple inclusion */
 #define _GPAKCUST_H

+#include <linux/module.h>
 #include <linux/device.h>
 #include <linux/completion.h>
 #include <linux/workqueue.h>
--- a/drivers/dahdi/voicebus/Kbuild
+++ b/drivers/dahdi/voicebus/Kbuild
@@ -2,4 +2,17 @@ obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_VOICEBUS) += dahdi_voicebus.o

 dahdi_voicebus-objs := voicebus.o GpakCust.o GpakApi.o voicebus_net.o vpmoct.o

-EXTRA_CFLAGS := -I$(src)/.. -Wno-undef
+FIRM_DIR	:= ../firmware
+
+ifneq ($(HOTPLUG_FIRMWARE),yes)
+dahdi_voicebus-objs += $(FIRM_DIR)/dahdi-fw-vpmoct032.o
+$(warning WARNING: You are compiling firmware into voicebus.ko which is not available under the terms of the GPL. It may be a violation of the GPL to distribute the resulting image since it combines both GPL and non-GPL work. You should consult a lawyer of your own before distributing such an image.)
+else
+  EXTRA_CFLAGS+=-DHOTPLUG_FIRMWARE
+endif
+
+EXTRA_CFLAGS += -I$(src)/.. -Wno-undef
+
+$(obj)/$(FIRM_DIR)/dahdi-fw-vpmoct032.o: $(obj)/voicebus.o
+	$(MAKE) -C $(obj)/$(FIRM_DIR) dahdi-fw-vpmoct032.o
+
--- a/drivers/dahdi/voicebus/Makefile
+++ b/drivers/dahdi/voicebus/Makefile
@@ -1,6 +0,0 @@
-ifdef KBUILD_EXTMOD
-# We only get here on kernels 2.6.0-2.6.9 .
-# For newer kernels, Kbuild will be included directly by the kernel
-# build system.
-include $(src)/Kbuild
-endif
--- a/drivers/dahdi/voicebus/voicebus.c
+++ b/drivers/dahdi/voicebus/voicebus.c
@@ -2030,7 +2030,7 @@ static int __init voicebus_module_init(void)
 	 * 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(NULL, 0);
+	dahdi_register_device(NULL, NULL);
 	spin_lock_init(&loader_list_lock);
 	return 0;
 }
--- a/drivers/dahdi/voicebus/voicebus.h
+++ b/drivers/dahdi/voicebus/voicebus.h
@@ -57,6 +57,15 @@
 * (and not tasklet). */
 #define CONFIG_VOICEBUS_INTERRUPT

+/*
+ * Enable the following definition in order to disable Active-State Power
+ * Management on the PCIe bridge for PCIe cards. This has been known to work
+ * around issues where the BIOS enables it on the cards even though the
+ * platform does not support it.
+ *
+ */
+#undef CONFIG_VOICEBUS_DISABLE_ASPM
+
 /* Define this to use a FIFO for the software echocan reference.
 * (experimental) */
 #undef CONFIG_VOICEBUS_ECREFERENCE
--- a/drivers/dahdi/voicebus/vpmoct.c
+++ b/drivers/dahdi/voicebus/vpmoct.c
@@ -72,7 +72,7 @@ static int _vpmoct_read(struct vpmoct *vpm, u8 address,
 		list_del(&cmd->node);
 		spin_unlock_irqrestore(&vpm->list_lock, flags);
 		kfree(cmd);
-		dev_err(vpm->dev, "vpmoct_read_byte cmd timed out :O(\n");
+		dev_err(vpm->dev, "vpmoct_read_byte cmd timed out\n");
 		return 0;
 	}

@@ -443,6 +443,47 @@ static void vpmoct_set_defaults(struct vpmoct *vpm)
 	vpmoct_write_dword(vpm, 0x30, 0);
 }

+static const char *const FIRMWARE_NAME = "dahdi-fw-vpmoct032.bin";
+#if defined(HOTPLUG_FIRMWARE)
+static int
+vpmoct_request_firmware(const struct firmware **fw, struct device *dev)
+{
+	return request_firmware(fw, FIRMWARE_NAME, dev);
+}
+
+static void vpmoct_release_firmware(const struct firmware *fw)
+{
+	release_firmware(fw);
+}
+#else
+static int
+vpmoct_request_firmware(const struct firmware **fw_p, struct device *dev)
+{
+	struct firmware *fw;
+	extern void _binary_dahdi_fw_vpmoct032_bin_size;
+	extern u8 _binary_dahdi_fw_vpmoct032_bin_start[];
+
+	*fw_p = fw = kzalloc(sizeof(*fw), GFP_KERNEL);
+	if (!fw)
+		return -ENOMEM;
+
+	fw->data = _binary_dahdi_fw_vpmoct032_bin_start;
+	/* Yes... this is weird. objcopy gives us a symbol containing
+	   the size of the firmware, not a pointer a variable containing the
+	   size. The only way we can get the value of the symbol is to take
+	   its address, so we define it as a pointer and then cast that value
+	   to the proper type.  */
+	fw->size = (size_t) &_binary_dahdi_fw_vpmoct032_bin_size;
+
+	return 0;
+}
+
+static void vpmoct_release_firmware(const struct firmware *fw)
+{
+	kfree(fw);
+}
+#endif
+
 /**
 * vpmoct_load_flash - Check the current flash version and possibly load.
 * @vpm:  The VPMOCT032 module to check / load.
@@ -463,10 +504,9 @@ static void vpmoct_load_flash(struct work_struct *data)
 	const struct firmware *fw;
 	const struct vpmoct_header *header;
 	char serial[VPMOCT_SERIAL_SIZE+1];
-	const char *const FIRMWARE_NAME = "dahdi-fw-vpmoct032.bin";
 	int i;

-	res = request_firmware(&fw, FIRMWARE_NAME, vpm->dev);
+	res = vpmoct_request_firmware(&fw, vpm->dev);
 	if (res) {
 		dev_warn(vpm->dev,
 			 "vpmoct: Failed to load firmware from userspace! %d\n",
@@ -505,7 +545,7 @@ static void vpmoct_load_flash(struct work_struct *data)
 				 FIRMWARE_NAME);

 			/* Just use the old version of the fimware. */
-			release_firmware(fw);
+			vpmoct_release_firmware(fw);
 			vpmoct_set_defaults(vpm);
 			vpmoct_load_complete(work, true);
 			return;
@@ -514,7 +554,7 @@ static void vpmoct_load_flash(struct work_struct *data)
 		if (vpm->minor == header->minor &&
 		    vpm->major == header->major) {
 			/* Proper version is running */
-			release_firmware(fw);
+			vpmoct_release_firmware(fw);
 			vpmoct_set_defaults(vpm);
 			vpmoct_load_complete(work, true);
 			return;
@@ -548,14 +588,14 @@ static void vpmoct_load_flash(struct work_struct *data)
 	if (vpmoct_check_firmware_crc(vpm, fw->size-VPMOCT_FIRM_HEADER_LEN*2,
 					header->major, header->minor))
 		goto error;
-	release_firmware(fw);
+	vpmoct_release_firmware(fw);
 	vpmoct_set_defaults(vpm);
 	vpmoct_load_complete(work, true);
 	return;

 error:
 	dev_info(vpm->dev, "Unable to load firmware\n");
-	release_firmware(fw);
+	vpmoct_release_firmware(fw);
 	/* TODO: Should we disable module if the firmware doesn't load? */
 	vpmoct_load_complete(work, false);
 	return;
--- a/drivers/dahdi/vpmadt032_loader/dahdi_vpmadt032_loader.c
+++ b/drivers/dahdi/vpmadt032_loader/dahdi_vpmadt032_loader.c
@@ -1,7 +1,7 @@
 /*
 * DAHDI Telephony Interface to VPMADT032 Firmware Loader
 *
- * Copyright (C) 2008-2011 Digium, Inc. All rights reserved.
+ * Copyright (C) 2008-2012 Digium, Inc. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
@@ -38,18 +38,9 @@ logger(const char *format, ...)
 	int res;
 	va_list args;

-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 9)
 	va_start(args, format);
 	res = vprintk(format, args);
 	va_end(args);
-#else
-	char buf[256];
-
-	va_start(args, format);
-	res = vsnprintf(buf, sizeof(buf), format, args);
-	va_end(args);
-	printk(KERN_INFO "%s" buf);
-#endif

 	return res;
 }
--- a/drivers/dahdi/wcb4xxp/Makefile
+++ b/drivers/dahdi/wcb4xxp/Makefile
@@ -1,7 +0,0 @@
-ifdef KBUILD_EXTMOD
-# We only get here on kernels 2.6.0-2.6.9 .
-# For newer kernels, Kbuild will be included directly by the kernel
-# build system.
-include $(src)/Kbuild
-else
-endif
--- a/drivers/dahdi/wcb4xxp/base.c
+++ b/drivers/dahdi/wcb4xxp/base.c
@@ -2,7 +2,7 @@
 * WCB410P  Quad-BRI PCI Driver
 * Written by Andrew Kohlsmith <akohlsmith@mixdown.ca>
 *
- * Copyright (C) 2009-2011 Digium, Inc.
+ * Copyright (C) 2009-2012 Digium, Inc.
 * All rights reserved.
 *
 */
@@ -35,7 +35,6 @@
 #include <linux/spinlock.h>
 #include <linux/device.h>	/* dev_err() */
 #include <linux/interrupt.h>
-#include <asm/system.h>		/* cli(), *_flags */
 #include <asm/uaccess.h>	/* copy_*_user */
 #include <linux/workqueue.h>	/* work_struct */
 #include <linux/timer.h>	/* timer_struct */
@@ -91,6 +90,7 @@ static int milliwatt = 0;
 static int pedanticpci = 0;
 static int teignorered = 0;
 static int alarmdebounce = 500;
+static int persistentlayer1 = 1;
 static int vpmsupport = 1;
 static int timer_1_ms = 2000;
 static int timer_3_ms = 30000;
@@ -140,7 +140,7 @@ static struct devtype hfc8s_BN = {"BeroNet BN8S0", .ports = 8, .card_type = BN8S
 static struct devtype hfc4s_SW = {"Swyx 4xS0 SX2 QuadBri", .ports = 4, .card_type = BSWYX_SX2 };
 static struct devtype hfc4s_EV = {"CCD HFC-4S Eval. Board", .ports = 4,
 					.card_type = QUADBRI_EVAL };
- 
+
 #define CARD_HAS_EC(card) ((card)->card_type == B410P)

 static void echocan_free(struct dahdi_chan *chan, struct dahdi_echocan_state *ec);
@@ -1198,7 +1198,6 @@ static int b4xxp_find_sync(struct b4xxp *b4)
 		return src;
 }

-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18))
 static ssize_t b4_timing_master_show(struct device *dev,
 				     struct device_attribute *attr,
 				     char *buf)
@@ -1226,13 +1225,6 @@ static void remove_sysfs_files(struct b4xxp *b4)
 			   &dev_attr_timing_master);
 }

-#else
-
-static inline void create_sysfs_files(struct b4xxp *b4) { return; }
-static inline void remove_sysfs_files(struct b4xxp *b4) { return; }
-
-#endif /* LINUX_KERNEL > 2.6.18 */
-
 /*
 * allocates memory and pretty-prints a given S/T state engine state to it.
 * calling routine is responsible for freeing the pointer returned!
@@ -1250,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;
 	}
@@ -1303,6 +1296,9 @@ static void hfc_force_st_state(struct b4xxp *b4, int port, int state, int resume
 	hfc_handle_state(&b4->spans[port]);
 }

+static void hfc_stop_st(struct b4xxp_span *s);
+static void hfc_start_st(struct b4xxp_span *s);
+
 /* figures out what to do when an S/T port's timer expires. */
 static void hfc_timer_expire(struct b4xxp_span *s, int t_no)
 {
@@ -1316,10 +1312,15 @@ static void hfc_timer_expire(struct b4xxp_span *s, int t_no)
 			 s->hfc_timer_on[t_no]);
 	}
 /*
- * there are three timers associated with every HFC S/T port.
- * T1 is used by the NT state machine, and is the maximum time the NT side should wait for G3 (active) state.
- * T2 is not actually used in the driver, it is handled by the HFC-4S internally.
- * T3 is used by the TE state machine; it is the maximum time the TE side should wait for the INFO4 (activated) signal.
+ * There are four timers associated with every HFC S/T port:
+ * T1 is used by the NT state machine, and is the maximum time the NT side
+ *	should wait for G3 (active) state.
+ * T2 is not actually used in the driver, it is handled by the HFC-4S
+ *	internally.
+ * T3 is used by the TE state machine; it is the maximum time the TE side should
+ *	wait for the INFO4 (activated) signal.
+ * T4 is a special timer used for debug purposes for monitoring of L1 state
+ *	during activation attempt.
 */

 /* First, disable the expired timer; hfc_force_st_state() may activate it again. */
@@ -1333,7 +1334,14 @@ static void hfc_timer_expire(struct b4xxp_span *s, int t_no)
 		hfc_force_st_state(b4, s->port, 1, 1);
 		break;
 	case HFC_T3:					/* switch to F3 (deactivated), resume auto mode */
-		hfc_force_st_state(b4, s->port, 3, 1);
+		hfc_stop_st(s);
+		if (persistentlayer1)
+			hfc_start_st(s);
+		break;
+	case HFC_T4:
+		hfc_handle_state(s);
+		s->hfc_timers[HFC_T4] = b4->ticks + 1000;
+		s->hfc_timer_on[HFC_T4] = 1;
 		break;
 	default:
 		if (printk_ratelimit()) {
@@ -1356,9 +1364,9 @@ static void hfc_update_st_timers(struct b4xxp *b4)
 	for (i=0; i < b4->numspans; i++) {
 		s = &b4->spans[i];

-		for (j=HFC_T1; j <= HFC_T3; j++) {
-
-/* we don't really do timer2, it is expired by the state change handler */
+		for (j = HFC_T1; j < ARRAY_SIZE(s->hfc_timers); j++) {
+			/* we don't really do timer2, it is expired by the
+			 * state change handler */
 			if (j == HFC_T2)
 				continue;

@@ -1442,6 +1450,7 @@ static void hfc_handle_state(struct b4xxp_span *s)
 			break;
 		case 0x7:			/* TE state F7: Activated */
 			s->hfc_timer_on[HFC_T3] = 0;
+			s->hfc_timer_on[HFC_T4] = 0;
 			s->newalarm = 0;
 			break;
 		}
@@ -1463,14 +1472,17 @@ static void hfc_handle_state(struct b4xxp_span *s)

 /* If we're in F3 and receiving INFO0, start T3 and jump to F4 */
 	if (!nt && (sta == 3) && (state & V_INFO0)) {
-		s->hfc_timers[HFC_T3] = b4->ticks + timer_3_ms;
-		s->hfc_timer_on[HFC_T3] = 1;
-		if (DBG_ST) {
-			dev_info(&b4->pdev->dev,
-				 "port %d: receiving INFO0 in state 3, "
-				 "setting T3 and jumping to F4\n", s->port + 1);
+		if (persistentlayer1) {
+			s->hfc_timers[HFC_T3] = b4->ticks + timer_3_ms;
+			s->hfc_timer_on[HFC_T3] = 1;
+			if (DBG_ST) {
+				dev_info(&b4->pdev->dev,
+					 "port %d: receiving INFO0 in state 3, "
+					 "setting T3 and jumping to F4\n",
+					 s->port + 1);
+			}
+			hfc_start_st(s);
 		}
-		hfc_force_st_state(b4, s->port, 4, 1);
 	}

 /* read in R_BERT_STA to determine where our current sync source is */
@@ -1485,6 +1497,24 @@ static void hfc_handle_state(struct b4xxp_span *s)
 	}
 }

+static void hfc_stop_all_timers(struct b4xxp_span *s)
+{
+	s->hfc_timer_on[HFC_T4] = 0;
+	s->hfc_timer_on[HFC_T3] = 0;
+	s->hfc_timer_on[HFC_T2] = 0;
+	s->hfc_timer_on[HFC_T1] = 0;
+}
+
+static void hfc_stop_st(struct b4xxp_span *s)
+{
+	struct b4xxp *b4 = s->parent;
+
+	hfc_stop_all_timers(s);
+
+	b4xxp_setreg_ra(b4, R_ST_SEL, s->port, A_ST_WR_STA,
+			V_ST_ACT_DEACTIVATE);
+}
+
 /*
 * resets an S/T interface to a given NT/TE mode
 */
@@ -1495,10 +1525,16 @@ static void hfc_reset_st(struct b4xxp_span *s)

 	b4 = s->parent;

+	hfc_stop_st(s);
+
 /* force state G0/F0 (reset), then force state 1/2 (deactivated/sensing) */
 	b4xxp_setreg_ra(b4, R_ST_SEL, s->port, A_ST_WR_STA, V_ST_LD_STA);
 	flush_pci();			/* make sure write hit hardware */

+	s->span.alarms = DAHDI_ALARM_RED;
+	s->newalarm = DAHDI_ALARM_RED;
+	dahdi_alarm_notify(&s->span);
+
 	udelay(10);

 /* set up the clock control register.  Must be done before we activate the interface. */
@@ -1529,9 +1565,13 @@ static void hfc_start_st(struct b4xxp_span *s)

 /* start T1 if in NT mode, T3 if in TE mode */
 	if (s->te_mode) {
-		s->hfc_timers[HFC_T3] = b4->ticks + 500;	/* 500ms wait first time, timer_t3_ms afterward. */
+		s->hfc_timers[HFC_T3] = b4->ticks + timer_3_ms;
 		s->hfc_timer_on[HFC_T3] = 1;
 		s->hfc_timer_on[HFC_T1] = 0;
+
+		s->hfc_timers[HFC_T4] = b4->ticks + 1000;
+		s->hfc_timer_on[HFC_T4] = 1;
+
 		if (DBG_ST) {
 			dev_info(&b4->pdev->dev,
 				 "setting port %d t3 timer to %lu\n",
@@ -1549,17 +1589,6 @@ static void hfc_start_st(struct b4xxp_span *s)
 	}
 }

-#if 0 /* TODO: This function is not called anywhere */
-static void hfc_stop_st(struct b4xxp_span *s)
-{
-	b4xxp_setreg_ra(s->parent, R_ST_SEL, s->port, A_ST_WR_STA, V_ST_ACT_DEACTIVATE);
-
-	s->hfc_timer_on[HFC_T1] = 0;
-	s->hfc_timer_on[HFC_T2] = 0;
-	s->hfc_timer_on[HFC_T3] = 0;
-}
-#endif
-
 /*
 * read in the HFC GPIO to determine each port's mode (TE or NT).
 * Then, reset and start the port.
@@ -1592,8 +1621,6 @@ static void hfc_init_all_st(struct b4xxp *b4)
 		dev_info(&b4->pdev->dev,
 			 "Port %d: %s mode\n", i + 1, (nt ? "NT" : "TE"));

-		hfc_reset_st(s);
-		hfc_start_st(s);
 	}
 }

@@ -1850,10 +1877,10 @@ static int hdlc_tx_frame(struct b4xxp_span *bspan)
 	char debugbuf[256];
 	unsigned long irq_flags;

-/* if we're ignoring TE red alarms and we are in alarm, restart the S/T state machine */
-	if (bspan->te_mode && teignorered && bspan->newalarm == DAHDI_ALARM_RED) {
-		hfc_force_st_state(b4, bspan->port, 3, 1);
-	}
+	/* if we're ignoring TE red alarms and we are in alarm, restart the
+	 * S/T state machine */
+	if (bspan->te_mode && bspan->newalarm != 0)
+		hfc_start_st(bspan);

 	fifo = bspan->fifos[2];
 	res = dahdi_hdlc_getbuf(bspan->sigchan, buf, &size);
@@ -2205,7 +2232,7 @@ static const char *b4xxp_echocan_name(const struct dahdi_chan *chan)
 {
 	struct b4xxp_span *bspan = container_of(chan->span, struct b4xxp_span,
 						span);
-	if (bspan->parent->card_type == B410P)
+	if (vpmsupport && (B410P == bspan->parent->card_type))
 		return "LASVEGAS2";
 	return NULL;
 }
@@ -2341,6 +2368,10 @@ static int b4xxp_spanconfig(struct file *file, struct dahdi_span *span,
 	if (lc->sync)
 		b4->spans[lc->sync - 1].sync = (span->offset + 1);

+	hfc_reset_st(bspan);
+	if (persistentlayer1)
+		hfc_start_st(bspan);
+
 	b4xxp_reset_span(bspan);

 /* call startup() manually here, because DAHDI won't call the startup function unless it receives an IOCTL to do so, and dahdi_cfg doesn't. */
@@ -2475,8 +2506,9 @@ static void init_spans(struct b4xxp *b4)
 		bspan = &b4->spans[i];
 		bspan->parent = b4;

-		bspan->span.irq = b4->pdev->irq;
-		bspan->span.spantype = (bspan->te_mode) ? "TE" : "NT";
+		bspan->span.spantype = (bspan->te_mode)
+			? SPANTYPE_DIGITAL_BRI_TE
+			: SPANTYPE_DIGITAL_BRI_NT;
 		bspan->span.offset = i;
 		bspan->span.channels = WCB4XXP_CHANNELS_PER_SPAN;
 		bspan->span.flags = 0;
@@ -2494,11 +2526,6 @@ static void init_spans(struct b4xxp *b4)

 		sprintf(bspan->span.name, "B4/%d/%d", b4->cardno, i+1);
 		sprintf(bspan->span.desc, "B4XXP (PCI) Card %d Span %d", b4->cardno, i+1);
-		bspan->span.manufacturer = "Digium";
-		strlcpy(bspan->span.devicetype, b4->variety,
-			sizeof(bspan->span.devicetype));
-		sprintf(bspan->span.location, "PCI Bus %02d Slot %02d",
-			b4->pdev->bus->number, PCI_SLOT(b4->pdev->devfn) + 1);

 		bspan->span.ops = &b4xxp_span_ops;
 /* HDLC stuff */
@@ -2930,14 +2957,27 @@ static int __devinit b4xx_probe(struct pci_dev *pdev, const struct pci_device_id
 	hfc_init_all_st(b4);

 /* initialize the DAHDI structures, and let DAHDI know it has some new hardware to play with */
+	b4->ddev = dahdi_create_device();
 	init_spans(b4);
+
 	for (x=0; x < b4->numspans; x++) {
-		if (dahdi_register(&b4->spans[x].span, 0)) {
-			dev_err(&b4->pdev->dev,
-				"Unable to register span %s\n",
-				b4->spans[x].span.name);
-			goto err_out_unreg_spans;
-		}
+		struct dahdi_span *const s = &b4->spans[x].span;
+		list_add_tail(&s->device_node, &b4->ddev->spans);
+	}
+
+	b4->ddev->manufacturer = "Digium";
+	b4->ddev->devicetype = b4->variety;
+	b4->ddev->location = kasprintf(GFP_KERNEL, "PCI Bus %02d Slot %02d",
+				       b4->pdev->bus->number,
+				       PCI_SLOT(b4->pdev->devfn) + 1);
+	if (!b4->ddev->location) {
+		ret = -ENOMEM;
+		goto err_out_del_from_card_array;
+	}
+
+	if (dahdi_register_device(b4->ddev, &b4->pdev->dev)) {
+		dev_err(&b4->pdev->dev, "Unable to register device.\n");
+		goto err_out_unreg_spans;
 	}


@@ -2973,10 +3013,7 @@ static int __devinit b4xx_probe(struct pci_dev *pdev, const struct pci_device_id

 /* 'x' will have the failing span #. (0-3).  We need to unregister everything before it. */
 err_out_unreg_spans:
-	while (x) {
-		dahdi_unregister(&b4->spans[x].span);
-		x--;
-	};
+	dahdi_unregister_device(b4->ddev);

 	b4xxp_init_stage1(b4);			/* full reset, re-init to "no-irq" state */
 	free_irq(pdev->irq, b4);
@@ -2997,6 +3034,8 @@ err_out_free_mem:
 	pci_set_drvdata(pdev, NULL);
 	pci_iounmap(pdev, b4->ioaddr);
 	pci_iounmap(pdev, b4->addr);
+	kfree(b4->ddev->location);
+	dahdi_free_device(b4->ddev);
 	kfree(b4);

 err_out_release_regions:
@@ -3011,14 +3050,11 @@ err_out_disable_pdev:
 static void __devexit b4xxp_remove(struct pci_dev *pdev)
 {
 	struct b4xxp *b4 = pci_get_drvdata(pdev);
-	int i;

 	if (b4) {
 		b4->shutdown = 1;

-		for (i=b4->numspans - 1; i >= 0; i--) {
-			dahdi_unregister(&b4->spans[i].span);
-		}
+		dahdi_unregister_device(b4->ddev);

 		b4xxp_init_stage1(b4);
 		remove_sysfs_files(b4);
@@ -3033,6 +3069,8 @@ static void __devexit b4xxp_remove(struct pci_dev *pdev)

 		tasklet_kill(&b4->b4xxp_tlet);

+		kfree(b4->ddev->location);
+		dahdi_free_device(b4->ddev);
 		kfree(b4);
 	}

@@ -3114,6 +3152,7 @@ module_param(vpmsupport, int, S_IRUGO);
 module_param(timer_1_ms, int, S_IRUGO | S_IWUSR);
 module_param(timer_3_ms, int, S_IRUGO | S_IWUSR);
 module_param(companding, charp, S_IRUGO);
+module_param(persistentlayer1, int, S_IRUGO | S_IWUSR);

 MODULE_PARM_DESC(debug, "bitmap: 1=general 2=dtmf 4=regops 8=fops 16=ec 32=st state 64=hdlc 128=alarm");
 MODULE_PARM_DESC(spanfilter, "debug filter for spans. bitmap: 1=port 1, 2=port 2, 4=port 3, 8=port 4");
--- a/drivers/dahdi/wcb4xxp/wcb4xxp.h
+++ b/drivers/dahdi/wcb4xxp/wcb4xxp.h
@@ -376,6 +376,7 @@
 #define HFC_T1					0
 #define HFC_T2					1
 #define HFC_T3					2
+#define HFC_T4					3

 #define MAX_SPANS_PER_CARD			8

@@ -396,8 +397,8 @@ struct b4xxp_span {
 	unsigned long alarmtimer;

 	int te_mode;				/* 1=TE, 0=NT */
-	unsigned long hfc_timers[WCB4XXP_CHANNELS_PER_SPAN];		/* T1, T2, T3 */
-	int hfc_timer_on[WCB4XXP_CHANNELS_PER_SPAN];			/* 1=timer active */
+	unsigned long hfc_timers[4];		/* T1, T2, T3, Fake T4 */
+	int hfc_timer_on[4];			/* 1=timer active */
 	int fifos[WCB4XXP_CHANNELS_PER_SPAN];				/* B1, B2, D <--> host fifo numbers */

 	/* HDLC controller fields */
@@ -474,6 +475,7 @@ struct b4xxp {
 	/* Flags for our bottom half */
 	unsigned int shutdown;			/* 1=bottom half doesn't process anything, just returns */
 	struct tasklet_struct b4xxp_tlet;
+	struct dahdi_device *ddev;
 };

 /* CPLD access bits */
--- a/drivers/dahdi/wcfxo.c
+++ b/drivers/dahdi/wcfxo.c
@@ -135,6 +135,7 @@ static int wecareregs[] =
 struct wcfxo {
 	struct pci_dev *dev;
 	char *variety;
+	struct dahdi_device *ddev;
 	struct dahdi_span span;
 	struct dahdi_chan _chan;
 	struct dahdi_chan *chan;
@@ -647,19 +648,24 @@ static const struct dahdi_span_ops wcfxo_span_ops = {

 static int wcfxo_initialize(struct wcfxo *wc)
 {
+	wc->ddev = dahdi_create_device();
+
 	/* DAHDI stuff */
 	sprintf(wc->span.name, "WCFXO/%d", wc->pos);
 	snprintf(wc->span.desc, sizeof(wc->span.desc) - 1, "%s Board %d", wc->variety, wc->pos + 1);
 	sprintf(wc->chan->name, "WCFXO/%d/%d", wc->pos, 0);
-	snprintf(wc->span.location, sizeof(wc->span.location) - 1,
-		 "PCI Bus %02d Slot %02d", wc->dev->bus->number, PCI_SLOT(wc->dev->devfn) + 1);
-	wc->span.manufacturer = "Digium";
-	strlcpy(wc->span.devicetype, wc->variety, sizeof(wc->span.devicetype));
+	wc->ddev->location = kasprintf(GFP_KERNEL, "PCI Bus %02d Slot %02d",
+				      wc->dev->bus->number,
+				      PCI_SLOT(wc->dev->devfn) + 1);
+	if (!wc->ddev->location)
+		return -ENOMEM;
+
+	wc->ddev->manufacturer = "Digium";
+	wc->ddev->devicetype = wc->variety;
 	wc->chan->sigcap = DAHDI_SIG_FXSKS | DAHDI_SIG_FXSLS | DAHDI_SIG_SF;
 	wc->chan->chanpos = 1;
 	wc->span.chans = &wc->chan;
 	wc->span.channels = 1;
-	wc->span.irq = wc->dev->irq;
 	wc->span.flags = DAHDI_FLAG_RBS;
 	wc->span.deflaw = DAHDI_LAW_MULAW;
 #ifdef ENABLE_TASKLETS
@@ -668,7 +674,8 @@ static int wcfxo_initialize(struct wcfxo *wc)

 	wc->chan->pvt = wc;
 	wc->span.ops = &wcfxo_span_ops;
-	if (dahdi_register(&wc->span, 0)) {
+	list_add_tail(&wc->span.device_node, &wc->ddev->spans);
+	if (dahdi_register_device(wc->ddev, &wc->dev->dev)) {
 		printk(KERN_NOTICE "Unable to register span with DAHDI\n");
 		return -1;
 	}
@@ -976,7 +983,7 @@ static int __devinit wcfxo_init_one(struct pci_dev *pdev, const struct pci_devic
 		printk(KERN_NOTICE "Failed to initailize DAA, giving up...\n");
 		wcfxo_stop_dma(wc);
 		wcfxo_disable_interrupts(wc);
-		dahdi_unregister(&wc->span);
+		dahdi_unregister_device(wc->ddev);
 		free_irq(pdev->irq, wc);

 		/* Reset PCI chip and registers */
@@ -984,6 +991,8 @@ static int __devinit wcfxo_init_one(struct pci_dev *pdev, const struct pci_devic

 		if (wc->freeregion)
 			release_region(wc->ioaddr, 0xff);
+		kfree(wc->ddev->location);
+		dahdi_free_device(wc->ddev);
 		kfree(wc);
 		return -EIO;
 	}
@@ -995,9 +1004,11 @@ static int __devinit wcfxo_init_one(struct pci_dev *pdev, const struct pci_devic

 static void wcfxo_release(struct wcfxo *wc)
 {
-	dahdi_unregister(&wc->span);
+	dahdi_unregister_device(wc->ddev);
 	if (wc->freeregion)
 		release_region(wc->ioaddr, 0xff);
+	kfree(wc->ddev->location);
+	dahdi_free_device(wc->ddev);
 	kfree(wc);
 	printk(KERN_INFO "Freed a Wildcard\n");
 }
--- a/drivers/dahdi/wct1xxp.c
+++ b/drivers/dahdi/wct1xxp.c
@@ -159,6 +159,7 @@ struct t1xxp {
 	unsigned char ec_chunk2[31][DAHDI_CHUNKSIZE];
 	unsigned char tempo[32];
 	struct dahdi_span span;						/* Span */
+	struct dahdi_device *ddev;
 	struct dahdi_chan *chans[31];					/* Channels */
 };

@@ -272,10 +273,11 @@ static void t1xxp_release(struct t1xxp *wc)
 {
 	unsigned int x;

-	dahdi_unregister(&wc->span);
+	dahdi_unregister_device(wc->ddev);
 	for (x = 0; x < (wc->ise1 ? 31 : 24); x++) {
 		kfree(wc->chans[x]);
 	}
+	dahdi_free_device(wc->ddev);
 	kfree(wc);
 	printk(KERN_INFO "Freed a Wildcard\n");
 }
@@ -770,26 +772,32 @@ static int t1xxp_software_init(struct t1xxp *wc)
 	}
 	if (x >= WC_MAX_CARDS)
 		return -1;
+
+	wc->ddev = dahdi_create_device();
+
 	wc->num = x;
 	sprintf(wc->span.name, "WCT1/%d", wc->num);
 	snprintf(wc->span.desc, sizeof(wc->span.desc) - 1, "%s Card %d", wc->variety, wc->num);
-	wc->span.manufacturer = "Digium";
-	strlcpy(wc->span.devicetype, wc->variety, sizeof(wc->span.devicetype));
-	snprintf(wc->span.location, sizeof(wc->span.location) - 1,
-		 "PCI Bus %02d Slot %02d", wc->dev->bus->number, PCI_SLOT(wc->dev->devfn) + 1);
-	wc->span.irq = wc->dev->irq;
+	wc->ddev->manufacturer = "Digium";
+	wc->ddev->devicetype = wc->variety;
+	wc->ddev->location = kasprintf(GFP_KERNEL, "PCI Bus %02d Slot %02d",
+				      wc->dev->bus->number,
+				      PCI_SLOT(wc->dev->devfn) + 1);
+	if (!wc->ddev->location)
+		return -ENOMEM;
+
 	wc->span.chans = wc->chans;
 	wc->span.flags = DAHDI_FLAG_RBS;
 	if (wc->ise1) {
 		wc->span.channels = 31;
 		wc->span.deflaw = DAHDI_LAW_ALAW;
 		wc->span.linecompat = DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
-		wc->span.spantype = "E1";
+		wc->span.spantype = SPANTYPE_DIGITAL_E1;
 	} else {
 		wc->span.channels = 24;
 		wc->span.deflaw = DAHDI_LAW_MULAW;
 		wc->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF;
-		wc->span.spantype = "T1";
+		wc->span.spantype = SPANTYPE_DIGITAL_T1;
 	}
 	for (x=0;x<wc->span.channels;x++) {
 		sprintf(wc->chans[x]->name, "WCT1/%d/%d", wc->num, x + 1);
@@ -801,7 +809,8 @@ static int t1xxp_software_init(struct t1xxp *wc)
 		wc->chans[x]->chanpos = x + 1;
 	}
 	wc->span.ops = &t1xxp_span_ops;
-	if (dahdi_register(&wc->span, 0)) {
+	list_add_tail(&wc->span.device_node, &wc->ddev->spans);
+	if (dahdi_register_device(wc->ddev, &wc->dev->dev)) {
 		printk(KERN_NOTICE "Unable to register span with DAHDI\n");
 		return -1;
 	}
@@ -908,10 +917,10 @@ static void t1xxp_receiveprep(struct t1xxp *wc, int ints)
 	if (((oldcan & 0xffff0000) >> 16) != CANARY) {
 		/* Check top part */
 		if (debug) printk(KERN_DEBUG "Expecting top %04x, got %04x\n", CANARY, (oldcan & 0xffff0000) >> 16);
-		wc->span.irqmisses++;
+		wc->ddev->irqmisses++;
 	} else if ((oldcan & 0xffff) != ((wc->canary - 1) & 0xffff)) {
 		if (debug) printk(KERN_DEBUG "Expecting bottom %d, got %d\n", wc->canary - 1, oldcan & 0xffff);
-		wc->span.irqmisses++;
+		wc->ddev->irqmisses++;
 	}
 	for (y=0;y<DAHDI_CHUNKSIZE;y++) {
 		for (x=0;x<wc->span.channels;x++) {
--- a/drivers/dahdi/wct4xxp/Kbuild
+++ b/drivers/dahdi/wct4xxp/Kbuild
@@ -14,10 +14,11 @@ 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 ../oct612x/lib.a

 ifneq ($(HOTPLUG_FIRMWARE),yes)
-wct4xxp-objs += $(FIRM_DIR)/dahdi-fw-oct6114-064.o $(FIRM_DIR)/dahdi-fw-oct6114-128.o
+wct4xxp-objs += $(FIRM_DIR)/dahdi-fw-oct6114-064.o $(FIRM_DIR)/dahdi-fw-oct6114-128.o $(FIRM_DIR)/dahdi-fw-oct6114-256.o
+$(warning WARNING: You are compiling firmware into wct4xxp.ko which is not available under the terms of the GPL. It may be a violation of the GPL to distribute the resulting image since it combines both GPL and non-GPL work. You should consult a lawyer of your own before distributing such an image.)
 endif

 $(obj)/$(FIRM_DIR)/dahdi-fw-oct6114-064.o: $(obj)/base.o
@@ -25,3 +26,6 @@ $(obj)/$(FIRM_DIR)/dahdi-fw-oct6114-064.o: $(obj)/base.o

 $(obj)/$(FIRM_DIR)/dahdi-fw-oct6114-128.o: $(obj)/base.o
 	$(MAKE) -C $(obj)/$(FIRM_DIR) dahdi-fw-oct6114-128.o
+
+$(obj)/$(FIRM_DIR)/dahdi-fw-oct6114-256.o: $(obj)/base.o
+	$(MAKE) -C $(obj)/$(FIRM_DIR) dahdi-fw-oct6114-256.o
--- a/drivers/dahdi/wct4xxp/Makefile
+++ b/drivers/dahdi/wct4xxp/Makefile
@@ -1,8 +0,0 @@
-ifdef KBUILD_EXTMOD
-# We only get here on kernels 2.6.0-2.6.9 .
-# For newer kernels, Kbuild will be included directly by the kernel
-# build system.
-include $(src)/Kbuild
-
-else
-endif
--- a/drivers/dahdi/wct4xxp/base.c
+++ b/drivers/dahdi/wct4xxp/base.c
--- a/drivers/dahdi/wct4xxp/vpm450m.c
+++ b/drivers/dahdi/wct4xxp/vpm450m.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2005-2006 Digium, Inc.
+ * Copyright (C) 2005-2012 Digium, Inc.
 *
 * Mark Spencer <markster@digium.com>
 *
@@ -19,19 +19,20 @@
 * 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"

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
-#include <linux/config.h>
-#endif
-
 /* API for Octasic access */
 UINT32 Oct6100UserGetTime(tPOCT6100_GET_TIME f_pTime)
 {
@@ -172,15 +173,16 @@ UINT32 Oct6100UserDriverReadBurstApi(tPOCT6100_READ_BURST_PARAMS f_pBurstParams)

 struct vpm450m {
 	tPOCT6100_INSTANCE_API pApiInstance;
-	UINT32 aulEchoChanHndl[128];
-	int chanflags[128];
-	int ecmode[128];
+	UINT32 aulEchoChanHndl[256];
+	int chanflags[256];
+	int ecmode[256];
 	int numchans;
 };

 #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,
@@ -220,6 +222,50 @@ 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 {
+		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;
@@ -252,6 +298,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");
@@ -290,6 +341,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);
@@ -422,6 +478,8 @@ struct vpm450m *init_vpm450m(void *wc, int *isalaw, int numspans, const struct f
 	tOCT6100_GET_INSTANCE_SIZE InstanceSize;
 	tOCT6100_CHANNEL_OPEN *ChannelOpen;
 	UINT32 ulResult;
+	const unsigned int mask = (8 == numspans) ? 0x7 : 0x3;
+	unsigned int sout_stream, rout_stream;
 	struct vpm450m *vpm450m;
 	int x,y,law;
 	
@@ -467,15 +525,22 @@ struct vpm450m *init_vpm450m(void *wc, int *isalaw, int numspans, const struct f
 	ChipOpen->ulMemoryType = cOCT6100_MEM_TYPE_DDR;
 	ChipOpen->ulMemoryChipSize = cOCT6100_MEMORY_CHIP_SIZE_32MB;
 	ChipOpen->ulNumMemoryChips = 1;
-	ChipOpen->ulMaxTdmStreams = 4;
 	ChipOpen->aulTdmStreamFreqs[0] = cOCT6100_TDM_STREAM_FREQ_8MHZ;
-	ChipOpen->ulTdmSampling = cOCT6100_TDM_SAMPLE_AT_FALLING_EDGE;
 	ChipOpen->ulMaxFlexibleConfParticipants = 0;
 	ChipOpen->ulMaxConfBridges = 0;
 	ChipOpen->ulMaxRemoteDebugSessions = 0;
 	ChipOpen->fEnableChannelRecording = FALSE;
 	ChipOpen->ulSoftToneEventsBufSize = 64;

+	if (vpm450m->numchans <= 128) {
+		ChipOpen->ulMaxTdmStreams = 4;
+		ChipOpen->ulTdmSampling = cOCT6100_TDM_SAMPLE_AT_FALLING_EDGE;
+	} else {
+		ChipOpen->ulMaxTdmStreams = 32;
+		ChipOpen->fEnableFastH100Mode = TRUE;
+		ChipOpen->ulTdmSampling = cOCT6100_TDM_SAMPLE_AT_RISING_EDGE;
+	}
+
 #if 0
 	ChipOpen->fEnableAcousticEcho = TRUE;
 #endif		
@@ -507,7 +572,11 @@ struct vpm450m *init_vpm450m(void *wc, int *isalaw, int numspans, const struct f
 		kfree(ChannelOpen);
 		return NULL;
 	}
-	for (x = 0; x < ARRAY_SIZE(vpm450m->aulEchoChanHndl); x++) {
+
+	sout_stream = (8 == numspans) ? 29 : 2;
+	rout_stream = (8 == numspans) ? 24 : 3;
+
+	for (x = 0; x < ((8 == numspans) ? 256 : 128); x++) {
 		/* execute this loop always on 4 span cards but
 		*  on 2 span cards only execute for the channels related to our spans */
 		if (( numspans > 2) || ((x & 0x03) <2)) {
@@ -515,10 +584,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 & 0x03]) 
+			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;
@@ -529,11 +601,13 @@ struct vpm450m *init_vpm450m(void *wc, int *isalaw, int numspans, const struct f
 			ChannelOpen->TdmConfig.ulSinStream = 1;
 			ChannelOpen->TdmConfig.ulSinTimeslot = x;
 			ChannelOpen->TdmConfig.ulSoutPcmLaw = law;
-			ChannelOpen->TdmConfig.ulSoutStream = 2;
+			ChannelOpen->TdmConfig.ulSoutStream = sout_stream;
 			ChannelOpen->TdmConfig.ulSoutTimeslot = x;
+#if 1
 			ChannelOpen->TdmConfig.ulRoutPcmLaw = law;
-			ChannelOpen->TdmConfig.ulRoutStream = 3;
+			ChannelOpen->TdmConfig.ulRoutStream = rout_stream;
 			ChannelOpen->TdmConfig.ulRoutTimeslot = x;
+#endif
 			ChannelOpen->VqeConfig.fEnableNlp = TRUE;
 			ChannelOpen->VqeConfig.fRinDcOffsetRemoval = TRUE;
 			ChannelOpen->VqeConfig.fSinDcOffsetRemoval = TRUE;
@@ -543,7 +617,7 @@ struct vpm450m *init_vpm450m(void *wc, int *isalaw, int numspans, const struct f
 			
 			ulResult = Oct6100ChannelOpen(vpm450m->pApiInstance, ChannelOpen);
 			if (ulResult != GENERIC_OK) {
-				printk(KERN_NOTICE "Failed to open channel %d!\n", x);
+				printk(KERN_NOTICE "Failed to open channel %d %x!\n", x, ulResult);
 				continue;
 			}
 			for (y = 0; y < ARRAY_SIZE(tones); y++) {
--- a/drivers/dahdi/wct4xxp/vpm450m.h
+++ b/drivers/dahdi/wct4xxp/vpm450m.h
@@ -39,5 +39,7 @@ void vpm450m_setdtmf(struct vpm450m *instance, int channel, int dtmfdetect, int
 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);

 #endif
--- a/drivers/dahdi/wct4xxp/wct4xxp.h
+++ b/drivers/dahdi/wct4xxp/wct4xxp.h
@@ -54,6 +54,12 @@
 #define FRMR_SIC3 0x40
 #define FRMR_CMR1 0x44
 #define FRMR_CMR2 0x45
+/* OctalFALC Only */
+#define FRMR_CMR4 0x41
+#define FRMR_CMR5 0x42
+#define FRMR_CMR6 0x43
+#define FRMR_GPC2 0x8a
+/* End Octal */
 #define FRMR_GCR 0x46
 #define FRMR_ISR0 0x68
 #define FRMR_ISR0_RME 0x80
@@ -76,6 +82,13 @@
 #define FRMR_CIS_GIS2 0x02
 #define FRMR_CIS_GIS3 0x04
 #define FRMR_CIS_GIS4 0x08
+
+/* CIS - Octal falc bits */
+#define FRMR_CIS_GIS5 0x10
+#define FRMR_CIS_GIS6 0x20
+#define FRMR_CIS_GIS7 0x40
+#define FRMR_CIS_GIS8 0x80
+
 #define FRMR_CMDR 0x02
 #define FRMR_CMDR_SRES 0x01
 #define FRMR_CMDR_XRES 0x10
@@ -113,6 +126,11 @@ struct t4_regs {
 	unsigned char regs[NUM_REGS];
 };

+struct t4_reg {
+	unsigned int reg;
+	unsigned int val;
+};
+
 #define T4_CHECK_VPM		0
 #define T4_LOADING_FW		1
 #define T4_STOP_DMA		2
@@ -120,5 +138,7 @@ struct t4_regs {
 #define T4_CHANGE_LATENCY	4
 #define T4_IGNORE_LATENCY	5

-#define WCT4_GET_REGS	_IOW (DAHDI_CODE, 60, struct t4_regs)
+#define WCT4_GET_REGS	_IOW(DAHDI_CODE, 60, struct t4_regs)
+#define WCT4_GET_REG	_IOW(DAHDI_CODE, 61, struct t4_reg)
+#define WCT4_SET_REG	_IOW(DAHDI_CODE, 62, struct t4_reg)

--- a/drivers/dahdi/wctc4xxp/Makefile
+++ b/drivers/dahdi/wctc4xxp/Makefile
@@ -1,7 +0,0 @@
-ifdef KBUILD_EXTMOD
-# We only get here on kernels 2.6.0-2.6.9 .
-# For newer kernels, Kbuild will be included directly by the kernel
-# build system.
-include $(src)/Kbuild
-else
-endif
--- a/drivers/dahdi/wctc4xxp/base.c
+++ b/drivers/dahdi/wctc4xxp/base.c
@@ -1,6 +1,6 @@
 /* Wildcard TC400B Driver
 *
- * Copyright (C) 2006-2010, Digium, Inc.
+ * Copyright (C) 2006-2012, Digium, Inc.
 *
 * All rights reserved.
 *
@@ -42,11 +42,7 @@

 #include "dahdi/kernel.h"

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
-#include <asm/io.h>
-#else
 #include <linux/io.h>
-#endif

 /* COMPILE TIME OPTIONS =================================================== */

@@ -73,27 +69,6 @@
 		dev_info(&(wc)->pdev->dev, _fmt, ## _args);		\
 	}								\

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
-#ifndef WARN_ON_ONCE
-#define WARN_ON_ONCE(__condition) do {         \
-	static int __once = 1;                 \
-	if (unlikely(__condition)) {           \
-		if (__once) {                  \
-			__once = 0;            \
-			WARN_ON(0);            \
-		}                              \
-	}                                      \
-} while (0)
-#endif
-#endif
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)
-/* also added in RHEL kernels with the OpenInfiniband backport: */
-#if LINUX_VERSION_CODE != KERNEL_VERSION(2, 6, 9) || !defined(DEFINE_SPINLOCK)
-typedef	unsigned gfp_t;		/* Added in 2.6.14 */
-#endif
-#endif
-

 /* define CONFIG_WCTC4XXP_POLLING to operate in a pure polling mode.  This is
 * was placed in as a debugging tool for a particluar system that wasn't
@@ -488,6 +463,7 @@ wctc4xxp_skb_to_cmd(struct wcdte *wc, const struct sk_buff *skb)
 	return cmd;
 }

+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 2, 0)
 static void
 wctc4xxp_net_set_multi(struct net_device *netdev)
 {
@@ -495,6 +471,15 @@ wctc4xxp_net_set_multi(struct net_device *netdev)
 	DTE_DEBUG(DTE_DEBUG_GENERAL, "%s promiscuity:%d\n",
 	   __func__, netdev->promiscuity);
 }
+#else
+static void
+wctc4xxp_set_rx_mode(struct net_device *netdev)
+{
+	struct wcdte *wc = wcdte_from_netdev(netdev);
+	DTE_DEBUG(DTE_DEBUG_GENERAL, "%s promiscuity:%d\n",
+	   __func__, netdev->promiscuity);
+}
+#endif

 static int
 wctc4xxp_net_up(struct net_device *netdev)
@@ -658,7 +643,11 @@ wctc4xxp_net_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)

 #ifdef HAVE_NET_DEVICE_OPS
 static const struct net_device_ops wctc4xxp_netdev_ops = {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 2, 0)
 	.ndo_set_multicast_list = &wctc4xxp_net_set_multi,
+#else
+	.ndo_set_rx_mode = &wctc4xxp_set_rx_mode,
+#endif
 	.ndo_open = &wctc4xxp_net_up,
 	.ndo_stop = &wctc4xxp_net_down,
 	.ndo_start_xmit = &wctc4xxp_net_hard_start_xmit,
@@ -877,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);
 	}

@@ -2158,12 +2148,13 @@ wctc4xxp_write(struct file *file, const char __user *frame,
 	}

 	if (DAHDI_FORMAT_G723_1 == dtc->srcfmt) {
-		if ((G723_5K_BYTES != count) && (G723_6K_BYTES != count)) {
+		if ((G723_5K_BYTES != count) && (G723_6K_BYTES != count) &&
+		    (G723_SID_BYTES != count)) {
 			DTE_DEBUG(DTE_DEBUG_GENERAL,
 			   "Trying to transcode packet into G723 format " \
 			   "that is %Zu bytes instead of the expected " \
-			   "%d/%d bytes.\n", count, G723_5K_BYTES,
-			   G723_6K_BYTES);
+			   "%d/%d/%d bytes.\n", count, G723_5K_BYTES,
+			   G723_6K_BYTES, G723_SID_BYTES);
 			return -EINVAL;
 		}
 		cpvt->timestamp += G723_SAMPLES;
--- a/drivers/dahdi/wctdm.c
+++ b/drivers/dahdi/wctdm.c
@@ -205,6 +205,7 @@ struct wctdm {
 	struct pci_dev *dev;
 	char *variety;
 	struct dahdi_span span;
+	struct dahdi_device *ddev;
 	unsigned char ios;
 	int usecount;
 	unsigned int intcount;
@@ -2362,13 +2363,26 @@ static int wctdm_initialize(struct wctdm *wc)
 {
 	int x;

+	wc->ddev = dahdi_create_device();
+	if (!wc->ddev)
+		return -ENOMEM;
+
 	/* DAHDI stuff */
 	sprintf(wc->span.name, "WCTDM/%d", wc->pos);
 	snprintf(wc->span.desc, sizeof(wc->span.desc) - 1, "%s Board %d", wc->variety, wc->pos + 1);
-	snprintf(wc->span.location, sizeof(wc->span.location) - 1,
-		 "PCI Bus %02d Slot %02d", wc->dev->bus->number, PCI_SLOT(wc->dev->devfn) + 1);
-	wc->span.manufacturer = "Digium";
-	strlcpy(wc->span.devicetype, wc->variety, sizeof(wc->span.devicetype));
+	wc->ddev->location = kasprintf(GFP_KERNEL,
+				      "PCI Bus %02d Slot %02d",
+				      wc->dev->bus->number,
+				      PCI_SLOT(wc->dev->devfn) + 1);
+	if (!wc->ddev->location) {
+		dahdi_free_device(wc->ddev);
+		wc->ddev = NULL;
+		return -ENOMEM;
+	}
+
+	wc->ddev->manufacturer = "Digium";
+	wc->ddev->devicetype = wc->variety;
+
 	if (alawoverride) {
 		printk(KERN_INFO "ALAW override parameter detected.  Device will be operating in ALAW\n");
 		wc->span.deflaw = DAHDI_LAW_ALAW;
@@ -2384,12 +2398,15 @@ static int wctdm_initialize(struct wctdm *wc)
 	}
 	wc->span.chans = wc->chans;
 	wc->span.channels = NUM_CARDS;
-	wc->span.irq = wc->dev->irq;
 	wc->span.flags = DAHDI_FLAG_RBS;
 	wc->span.ops = &wctdm_span_ops;

-	if (dahdi_register(&wc->span, 0)) {
+	list_add_tail(&wc->span.device_node, &wc->ddev->spans);
+	if (dahdi_register_device(wc->ddev, &wc->dev->dev)) {
 		printk(KERN_NOTICE "Unable to register span with DAHDI\n");
+		kfree(wc->ddev->location);
+		dahdi_free_device(wc->ddev);
+		wc->ddev = NULL;
 		return -1;
 	}
 	return 0;
@@ -2677,7 +2694,9 @@ static int __devinit wctdm_init_one(struct pci_dev *pdev, const struct pci_devic
 					release_region(wc->ioaddr, 0xff);
 				pci_free_consistent(pdev, DAHDI_MAX_CHUNKSIZE * 2 * 2 * 2 * 4, (void *)wc->writechunk, wc->writedma);
 				pci_set_drvdata(pdev, NULL);
-				dahdi_unregister(&wc->span);
+				dahdi_unregister_device(wc->ddev);
+				kfree(wc->ddev->location);
+				dahdi_free_device(wc->ddev);
 				kfree(wc);
 				return -EIO;

@@ -2708,10 +2727,14 @@ static int __devinit wctdm_init_one(struct pci_dev *pdev, const struct pci_devic

 static void wctdm_release(struct wctdm *wc)
 {
-	dahdi_unregister(&wc->span);
+	dahdi_unregister_device(wc->ddev);
 	if (wc->freeregion)
 		release_region(wc->ioaddr, 0xff);
+
+	kfree(wc->ddev->location);
+	dahdi_free_device(wc->ddev);
 	kfree(wc);
+
 	printk(KERN_INFO "Freed a Wildcard\n");
 }

--- a/drivers/dahdi/wctdm24xxp/Makefile
+++ b/drivers/dahdi/wctdm24xxp/Makefile
@@ -1,6 +0,0 @@
-ifdef KBUILD_EXTMOD
-# We only get here on kernels 2.6.0-2.6.9 .
-# For newer kernels, Kbuild will be included directly by the kernel
-# build system.
-include $(src)/Kbuild
-endif
--- a/drivers/dahdi/wctdm24xxp/base.c
+++ b/drivers/dahdi/wctdm24xxp/base.c
--- a/drivers/dahdi/wctdm24xxp/wctdm24xxp.h
+++ b/drivers/dahdi/wctdm24xxp/wctdm24xxp.h
@@ -45,7 +45,6 @@
 * \brief Default ringer debounce (in ms)
 */
 #define DEFAULT_RING_DEBOUNCE	1024
-
 #define POLARITY_DEBOUNCE	64		/* Polarity debounce (in ms) */

 #define OHT_TIMER		6000	/* How long after RING to retain OHT */
@@ -85,7 +84,6 @@

 #define NUM_CAL_REGS		12

-#define ISR_COMMANDS		2
 #define QRV_DEBOUNCETIME	20

 #define VPM150M_HPI_CONTROL	0x00
@@ -107,10 +105,32 @@ 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,
 };

+enum ring_detector_state {
+	RINGOFF = 0,
+	DEBOUNCING_RINGING_POSITIVE,
+	DEBOUNCING_RINGING_NEGATIVE,
+	RINGING,
+	DEBOUNCING_RINGOFF,
+};
+
+enum polarity_state {
+	UNKNOWN_POLARITY = 0,
+	POLARITY_DEBOUNCE_POSITIVE,
+	POLARITY_POSITIVE,
+	POLARITY_DEBOUNCE_NEGATIVE,
+	POLARITY_NEGATIVE,
+};
+
 struct wctdm_cmd {
 	struct list_head node;
 	struct completion *complete;
@@ -146,29 +166,26 @@ struct wctdm_chan {
 };

 struct fxo {
-	int wasringing;
-	int lastrdtx;
-	int lastrdtx_count;
-	int ringdebounce;
+	enum ring_detector_state ring_state:4;
+	enum battery_state battery_state:4;
+	enum polarity_state polarity_state:4;
+	u8 ring_polarity_change_count:4;
+	u8 hook_ring_shadow;
+	s8 line_voltage_status;
 	int offhook;
-	int battdebounce;
-	int battalarm;
-	enum battery_state battery;
-	int lastpol;
-	int polarity;
-	int polaritydebounce;
 	int neonmwi_state;
 	int neonmwi_last_voltage;
 	unsigned int neonmwi_debounce;
 	unsigned int neonmwi_offcounter;
+	unsigned long display_fxovoltage;
+	unsigned long ringdebounce_timer;
+	unsigned long battdebounce_timer;
+	unsigned long poldebounce_timer;
 };

 struct fxs {
-	int oldrxhook;
-	int debouncehook;
-	int lastrxhook;
-	int debounce;
-	int ohttimer;
+	u8 oht_active:1;
+	u8 off_hook:1;
 	int idletxhookstate;	/* IDLE changing hook state */
 /* lasttxhook reflects the last value written to the proslic's reg
 * 64 (LINEFEED_CONTROL) in bits 0-2.  Bit 4 indicates if the last
@@ -180,13 +197,18 @@ struct fxs {
 * voicebus ISR.
 */
 	int lasttxhook;
-	int oppending_ms;
+	u8 linefeed_control_shadow;
+	u8 hook_state_shadow;
 	int palarms;
 	struct dahdi_vmwi_info vmwisetting;
 	int vmwi_active_messages;
 	int vmwi_linereverse;
 	int reversepolarity;	/* polarity reversal */
 	struct calregs calregs;
+	unsigned long check_alarm;
+	unsigned long check_proslic;
+	unsigned long oppending_timeout;
+	unsigned long ohttimer;
 };

 struct qrv {
@@ -203,6 +225,7 @@ struct qrv {
 	int radmode;
 	signed short rxgain;
 	signed short txgain;
+	u8 isrshadow[3];
 };

 enum module_type {
@@ -215,7 +238,7 @@ enum module_type {
 };

 struct wctdm_module {
-	union {
+	union modtypes {
 		struct fxo fxo;
 		struct fxs fxs;
 		struct qrv qrv;
@@ -227,7 +250,6 @@ struct wctdm_module {
 	struct list_head active_cmds;
 	u8 offsets[3];
 	u8 subaddr;
-	u8 isrshadow[ISR_COMMANDS];
 	u8 card;

 	enum module_type type;
@@ -242,7 +264,7 @@ struct wctdm {
 	spinlock_t frame_list_lock;
 	struct list_head frame_list;

-	unsigned int intcount;
+	unsigned long framecount;
 	unsigned char txident;
 	unsigned char rxident;

@@ -277,6 +299,7 @@ struct wctdm {
 	int not_ready;		 /* 0 when the entire card is ready to go */
 	unsigned long checkflag; /* Internal state flags and task bits */
 	int companding;
+	struct dahdi_device *ddev;
 };

 static inline bool is_initialized(struct wctdm *wc)
--- a/drivers/dahdi/wctdm24xxp/xhfc.c
+++ b/drivers/dahdi/wctdm24xxp/xhfc.c
@@ -2150,7 +2150,9 @@ static int b400m_set_ntte(struct b400m_span *bspan, int te_mode, int term_on)
 	int all_modes = 0, all_terms = 0;
 	int i;

-	bspan->wspan->span.spantype = (te_mode > 0) ? "TE" : "NT";
+	bspan->wspan->span.spantype = (te_mode > 0)
+		? SPANTYPE_DIGITAL_BRI_TE
+		: SPANTYPE_DIGITAL_BRI_NT;

 	bspan->te_mode = te_mode;
 	bspan->term_on = term_on;
--- a/drivers/dahdi/wcte11xp.c
+++ b/drivers/dahdi/wcte11xp.c
@@ -174,6 +174,7 @@ struct t1 {
 	unsigned char ec_chunk1[32][DAHDI_CHUNKSIZE];
 	unsigned char ec_chunk2[32][DAHDI_CHUNKSIZE];
 	unsigned char tempo[33];
+	struct dahdi_device *ddev;
 	struct dahdi_span span;						/* Span */
 	struct dahdi_chan *chans[32];					/* Channels */
 };
@@ -340,10 +341,12 @@ static void t1xxp_release(struct t1 *wc)
 {
 	unsigned int x;

-	dahdi_unregister(&wc->span);
+	dahdi_unregister_device(wc->ddev);
 	for (x = 0; x < (wc->spantype == TYPE_E1 ? 31 : 24); x++) {
 		kfree(wc->chans[x]);
 	}
+	kfree(wc->ddev->location);
+	dahdi_free_device(wc->ddev);
 	kfree(wc);
 	printk(KERN_INFO "Freed a Wildcard\n");
 }
@@ -976,27 +979,33 @@ static int t1xxp_software_init(struct t1 *wc)
 	}
 	if (x >= WC_MAX_CARDS)
 		return -1;
+
+	wc->ddev = dahdi_create_device();
+
 	t4_serial_setup(wc);
 	wc->num = x;
 	sprintf(wc->span.name, "WCT1/%d", wc->num);
 	snprintf(wc->span.desc, sizeof(wc->span.desc) - 1, "%s Card %d", wc->variety, wc->num);
-	wc->span.manufacturer = "Digium";
-	strlcpy(wc->span.devicetype, wc->variety, sizeof(wc->span.devicetype));
-	snprintf(wc->span.location, sizeof(wc->span.location) - 1,
-		 "PCI Bus %02d Slot %02d", wc->dev->bus->number, PCI_SLOT(wc->dev->devfn) + 1);
-	wc->span.irq = wc->dev->irq;
+	wc->ddev->manufacturer = "Digium";
+	wc->ddev->devicetype = wc->variety;
+	wc->ddev->location = kasprintf(GFP_KERNEL, "PCI Bus %02d Slot %02d",
+				       wc->dev->bus->number,
+				       PCI_SLOT(wc->dev->devfn) + 1);
+	if (!wc->ddev->location)
+		return -ENOMEM;
+
 	if (wc->spantype == TYPE_E1) {
 		if (unchannelized)
 			wc->span.channels = 32;
 		else
 			wc->span.channels = 31;
 		wc->span.deflaw = DAHDI_LAW_ALAW;
-		wc->span.spantype = "E1";
+		wc->span.spantype = SPANTYPE_DIGITAL_E1;
 		wc->span.linecompat = DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
 	} else {
 		wc->span.channels = 24;
 		wc->span.deflaw = DAHDI_LAW_MULAW;
-		wc->span.spantype = "T1";
+		wc->span.spantype = SPANTYPE_DIGITAL_T1;
 		wc->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF;
 	}
 	wc->span.chans = wc->chans;
@@ -1011,7 +1020,8 @@ static int t1xxp_software_init(struct t1 *wc)
 		wc->chans[x]->chanpos = x + 1;
 	}
 	wc->span.ops = &t1xxp_span_ops;
-	if (dahdi_register(&wc->span, 0)) {
+	list_add_tail(&wc->span.device_node, &wc->ddev->spans);
+	if (dahdi_register_device(wc->ddev, &wc->dev->dev)) {
 		printk(KERN_NOTICE "Unable to register span with DAHDI\n");
 		return -1;
 	}
@@ -1118,10 +1128,10 @@ static void t1xxp_receiveprep(struct t1 *wc, int ints)
 	if (((oldcan & 0xffff0000) >> 16) != CANARY) {
 		/* Check top part */
 		if (debug) printk(KERN_DEBUG "Expecting top %04x, got %04x\n", CANARY, (oldcan & 0xffff0000) >> 16);
-		wc->span.irqmisses++;
+		wc->ddev->irqmisses++;
 	} else if ((oldcan & 0xffff) != ((wc->canary - 1) & 0xffff)) {
 		if (debug) printk(KERN_DEBUG "Expecting bottom %d, got %d\n", wc->canary - 1, oldcan & 0xffff);
-		wc->span.irqmisses++;
+		wc->ddev->irqmisses++;
 	}
 	for (y=0;y<DAHDI_CHUNKSIZE;y++) {
 		for (x=0;x<wc->span.channels;x++) {
--- a/drivers/dahdi/wcte12xp/Makefile
+++ b/drivers/dahdi/wcte12xp/Makefile
@@ -1,6 +0,0 @@
-ifdef KBUILD_EXTMOD
-# We only get here on kernels 2.6.0-2.6.9 .
-# For newer kernels, Kbuild will be included directly by the kernel
-# build system.
-include $(src)/Kbuild
-endif
--- a/drivers/dahdi/wcte12xp/base.c
+++ b/drivers/dahdi/wcte12xp/base.c
--- a/drivers/dahdi/wcte12xp/wcte12xp.h
+++ b/drivers/dahdi/wcte12xp/wcte12xp.h
@@ -74,8 +74,11 @@
 #define CMD_BYTE(slot, a, is_vpm) (slot*6)+(a*2)+is_vpm /* only even slots */
 //TODO: make a separate macro

-#define TYPE_T1	1
-#define TYPE_E1	2
+enum linemode {
+	T1 = 1,
+	E1,
+	J1,
+};

 struct command {
 	struct list_head node;
@@ -94,7 +97,6 @@ struct t1 {
 	unsigned char txident;
 	unsigned char rxident;
 	unsigned char statreg; /* bit 0 = vpmadt032 int */
-	int spantype;
 	struct {
 		unsigned int nmf:1;
 		unsigned int sendingyellow:1;
@@ -112,10 +114,12 @@ struct t1 {
 #define INITIALIZED 1
 #define SHUTDOWN    2
 #define READY	    3
+#define IOERROR	    4
 	unsigned long bit_flags;
 	unsigned long alarmtimer;
 	unsigned char ledstate;
 	unsigned char vpm_check_count;
+	struct dahdi_device *ddev;
 	struct dahdi_span span;						/* Span */
 	struct dahdi_chan *chans[32];					/* Channels */
 	struct dahdi_echocan_state *ec[32];				/* Echocan state for channels */
--- a/drivers/dahdi/wcte13xp-base.c
+++ b/drivers/dahdi/wcte13xp-base.c
--- a/drivers/dahdi/xpp/card_bri.c
+++ b/drivers/dahdi/xpp/card_bri.c
--- a/drivers/dahdi/xpp/card_bri.h
+++ b/drivers/dahdi/xpp/card_bri.h
@@ -25,7 +25,7 @@
 #include "xpd.h"

 enum bri_opcodes {
-	XPROTO_NAME(BRI, SET_LED)			= 0x33,
+	XPROTO_NAME(BRI, SET_LED) = 0x33,
 };

-#endif	/* CARD_BRI_H */
+#endif /* CARD_BRI_H */
--- a/drivers/dahdi/xpp/card_echo.c
+++ b/drivers/dahdi/xpp/card_echo.c
@@ -42,25 +42,20 @@ static DEF_PARM(int, debug, 0, 0644, "Print DBG statements");
 static bool echo_packet_is_valid(xpacket_t *pack);
 static void echo_packet_dump(const char *msg, xpacket_t *pack);

-DEF_RPACKET_DATA(ECHO, SET,
-	byte timeslots[ECHO_TIMESLOTS];
-	);
+DEF_RPACKET_DATA(ECHO, SET, __u8 timeslots[ECHO_TIMESLOTS];);

-DEF_RPACKET_DATA(ECHO, SET_REPLY,
-	byte status;
-	byte reserved;
-	);
+DEF_RPACKET_DATA(ECHO, SET_REPLY, __u8 status; __u8 reserved;);

 struct ECHO_priv_data {
 };

-static xproto_table_t	PROTO_TABLE(ECHO);
+static xproto_table_t PROTO_TABLE(ECHO);

 /*---------------- ECHO: Methods -------------------------------------------*/

 static xpd_t *ECHO_card_new(xbus_t *xbus, int unit, int subunit,
-		const xproto_table_t *proto_table, byte subtype,
-		int subunits, int subunit_ports, bool to_phone)
+			    const xproto_table_t *proto_table, __u8 subtype,
+			    int subunits, int subunit_ports, bool to_phone)
 {
 	xpd_t *xpd = NULL;
 	int channels = 0;
@@ -70,8 +65,9 @@ static xpd_t *ECHO_card_new(xbus_t *xbus, int unit, int subunit,
 		return NULL;
 	}
 	XBUS_DBG(GENERAL, xbus, "\n");
-	xpd = xpd_alloc(xbus, unit, subunit, subtype, subunits,
-		sizeof(struct ECHO_priv_data), proto_table, channels);
+	xpd =
+	    xpd_alloc(xbus, unit, subunit, subtype, subunits,
+		      sizeof(struct ECHO_priv_data), proto_table, channels);
 	if (!xpd)
 		return NULL;
 	xpd->type_name = "ECHO";
@@ -122,19 +118,17 @@ static int ECHO_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info)
 		static int rate_limit;

 		if ((rate_limit++ % 1003) < 5)
-			notify_bad_xpd(__func__, xbus, addr,
-					orig_xpd->xpdname);
+			notify_bad_xpd(__func__, xbus, addr, orig_xpd->xpdname);
 		return -EPROTO;
 	}
 	spin_lock_irqsave(&xpd->lock, flags);
 	/* Update /proc info only if reply related to last reg read request */
-	if (
-			REG_FIELD(&xpd->requested_reply, regnum) ==
-				REG_FIELD(info, regnum) &&
-			REG_FIELD(&xpd->requested_reply, do_subreg) ==
-				REG_FIELD(info, do_subreg) &&
-			REG_FIELD(&xpd->requested_reply, subreg) ==
-				REG_FIELD(info, subreg)) {
+	if (REG_FIELD(&xpd->requested_reply, regnum) ==
+			REG_FIELD(info, regnum)
+		&& REG_FIELD(&xpd->requested_reply, do_subreg) ==
+			REG_FIELD(info, do_subreg)
+		&& REG_FIELD(&xpd->requested_reply, subreg) ==
+			REG_FIELD(info, subreg)) {
 		xpd->last_reply = *info;
 	}
 	spin_unlock_irqrestore(&xpd->lock, flags);
@@ -146,7 +140,7 @@ static int ECHO_card_register_reply(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *info)
 static /* 0x39 */ HOSTCMD(ECHO, SET)
 {
 	struct xbus_echo_state *es;
-	byte *ts;
+	__u8 *ts;
 	xframe_t *xframe;
 	xpacket_t *pack;
 	int ret;
@@ -172,7 +166,7 @@ static int ECHO_ec_set(xpd_t *xpd, int pos, bool on)
 {
 	int ts_number;
 	int ts_mask;
-	byte *ts;
+	__u8 *ts;

 	ts = xpd->xbus->echo_state.timeslots;
 	/*
@@ -198,7 +192,7 @@ static int ECHO_ec_set(xpd_t *xpd, int pos, bool on)
 			ts[ts_number] &= ~ts_mask;
 	}
 	LINE_DBG(GENERAL, xpd, pos, "%s = %d -- ts_number=%d ts_mask=0x%X\n",
-		__func__, on, ts_number, ts_mask);
+		 __func__, on, ts_number, ts_mask);
 	return 0;
 }

@@ -207,7 +201,7 @@ static int ECHO_ec_get(xpd_t *xpd, int pos)
 	int ts_number;
 	int ts_mask;
 	int is_on;
-	byte *ts;
+	__u8 *ts;

 	ts = xpd->xbus->echo_state.timeslots;
 	ts_mask = (xpd->addr.unit == 0) ? 0x1 : 0x2;	/* Which bit? */
@@ -220,14 +214,14 @@ static int ECHO_ec_get(xpd_t *xpd, int pos)
 	}
 #if 0
 	LINE_DBG(GENERAL, xpd, pos, "ec_get=%d -- ts_number=%d ts_mask=0x%X\n",
-		is_on, ts_number, ts_mask);
+		 is_on, ts_number, ts_mask);
 #endif
 	return is_on;
 }

 static void ECHO_ec_dump(xbus_t *xbus)
 {
-	byte *ts;
+	__u8 *ts;
 	int i;

 	ts = xbus->echo_state.timeslots;
@@ -236,12 +230,11 @@ static void ECHO_ec_dump(xbus_t *xbus)
 			"EC-DUMP[%03d]: "
 			"0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X "
 			"0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",
-			i,
-			ts[i+0], ts[i+1], ts[i+2], ts[i+3], ts[i+4], ts[i+5],
-				ts[i+6], ts[i+7],
-			ts[i+8], ts[i+9], ts[i+10], ts[i+11], ts[i+12],
-				ts[i+13], ts[i+14], ts[i+15]
-			);
+			i, ts[i + 0], ts[i + 1], ts[i + 2], ts[i + 3],
+			ts[i + 4], ts[i + 5], ts[i + 6], ts[i + 7], ts[i + 8],
+			ts[i + 9], ts[i + 10], ts[i + 11], ts[i + 12],
+			ts[i + 13], ts[i + 14], ts[i + 15]
+		    );
 	}
 }

@@ -255,7 +248,7 @@ static int ECHO_ec_update(xbus_t *xbus)
 /*---------------- ECHO: Astribank Reply Handlers --------------------------*/
 HANDLER_DEF(ECHO, SET_REPLY)
 {
-	byte	status;
+	__u8 status;

 	BUG_ON(!xpd);
 	status = RPACKET_FIELD(pack, ECHO, SET_REPLY, status);
@@ -263,26 +256,26 @@ HANDLER_DEF(ECHO, SET_REPLY)
 	return 0;
 }

-static const struct xops	echo_xops = {
-	.card_new		= ECHO_card_new,
-	.card_init		= ECHO_card_init,
-	.card_remove		= ECHO_card_remove,
-	.card_tick		= ECHO_card_tick,
-	.card_register_reply	= ECHO_card_register_reply,
+static const struct xops echo_xops = {
+	.card_new = ECHO_card_new,
+	.card_init = ECHO_card_init,
+	.card_remove = ECHO_card_remove,
+	.card_tick = ECHO_card_tick,
+	.card_register_reply = ECHO_card_register_reply,
 };

-static const struct echoops	echoops = {
-	.ec_set		= ECHO_ec_set,
-	.ec_get		= ECHO_ec_get,
-	.ec_update	= ECHO_ec_update,
-	.ec_dump	= ECHO_ec_dump,
+static const struct echoops echoops = {
+	.ec_set = ECHO_ec_set,
+	.ec_get = ECHO_ec_get,
+	.ec_update = ECHO_ec_update,
+	.ec_dump = ECHO_ec_dump,
 };

 static xproto_table_t PROTO_TABLE(ECHO) = {
 	.owner = THIS_MODULE,
 	.entries = {
-		/*	Table	Card	Opcode		*/
-		XENTRY(ECHO,	ECHO,	SET_REPLY),
+		/*      Table   Card    Opcode          */
+		XENTRY(	ECHO,	ECHO,	SET_REPLY	),
 	},
 	.name = "ECHO",
 	.ports_per_subunit = 1,
@@ -295,7 +288,7 @@ static xproto_table_t PROTO_TABLE(ECHO) = {

 static bool echo_packet_is_valid(xpacket_t *pack)
 {
-	const xproto_entry_t	*xe = NULL;
+	const xproto_entry_t *xe = NULL;
 	// DBG(GENERAL, "\n");
 	xe = xproto_card_entry(&PROTO_TABLE(ECHO), XPACKET_OP(pack));
 	return xe != NULL;
@@ -309,14 +302,14 @@ static void echo_packet_dump(const char *msg, xpacket_t *pack)
 /*------------------------- sysfs stuff --------------------------------*/
 static int echo_xpd_probe(struct device *dev)
 {
-	xpd_t	*ec_xpd;
-	int	ret = 0;
+	xpd_t *ec_xpd;
+	int ret = 0;

 	ec_xpd = dev_to_xpd(dev);
 	/* Is it our device? */
 	if (ec_xpd->type != XPD_TYPE_ECHO) {
-		XPD_ERR(ec_xpd, "drop suggestion for %s (%d)\n",
-			dev_name(dev), ec_xpd->type);
+		XPD_ERR(ec_xpd, "drop suggestion for %s (%d)\n", dev_name(dev),
+			ec_xpd->type);
 		return -EINVAL;
 	}
 	XPD_DBG(DEVICES, ec_xpd, "SYSFS\n");
@@ -325,23 +318,20 @@ static int echo_xpd_probe(struct device *dev)

 static int echo_xpd_remove(struct device *dev)
 {
-	xpd_t	*ec_xpd;
+	xpd_t *ec_xpd;

 	ec_xpd = dev_to_xpd(dev);
 	XPD_DBG(DEVICES, ec_xpd, "SYSFS\n");
 	return 0;
 }

-static struct xpd_driver	echo_driver = {
-	.type		= XPD_TYPE_ECHO,
-	.driver		= {
-		.name = "echo",
-#ifndef OLD_HOTPLUG_SUPPORT
-		.owner = THIS_MODULE,
-#endif
-		.probe = echo_xpd_probe,
-		.remove = echo_xpd_remove
-	}
+static struct xpd_driver echo_driver = {
+	.type = XPD_TYPE_ECHO,
+	.driver = {
+		   .name = "echo",
+		   .owner = THIS_MODULE,
+		   .probe = echo_xpd_probe,
+		   .remove = echo_xpd_remove}
 };

 static int __init card_echo_startup(void)
--- a/drivers/dahdi/xpp/card_echo.h
+++ b/drivers/dahdi/xpp/card_echo.h
@@ -24,8 +24,8 @@
 #include "xpd.h"

 enum echo_opcodes {
-	XPROTO_NAME(ECHO, SET)		= 0x39,
-	XPROTO_NAME(ECHO, SET_REPLY)	= 0x3A,
+	XPROTO_NAME(ECHO, SET) = 0x39,
+	XPROTO_NAME(ECHO, SET_REPLY) = 0x3A,
 };

-#endif	/* CARD_ECHO_H */
+#endif /* CARD_ECHO_H */
--- a/drivers/dahdi/xpp/card_fxo.c
+++ b/drivers/dahdi/xpp/card_fxo.c
--- a/drivers/dahdi/xpp/card_fxo.h
+++ b/drivers/dahdi/xpp/card_fxo.h
@@ -25,18 +25,16 @@
 #include "xpd.h"

 enum fxo_opcodes {
-	XPROTO_NAME(FXO, SIG_CHANGED)		= 0x06,
-/**/
-	XPROTO_NAME(FXO, DAA_WRITE)		= 0x0F,	/* Write to DAA */
-	XPROTO_NAME(FXO, XPD_STATE)		= 0x0F,	/* Write to DAA */
-	XPROTO_NAME(FXO, CHAN_CID)		= 0x0F,	/* Write to DAA */
-	XPROTO_NAME(FXO, LED)			= 0x0F,	/* Write to DAA */
+	XPROTO_NAME(FXO, SIG_CHANGED) = 0x06,		/**/
+	XPROTO_NAME(FXO, DAA_WRITE) = 0x0F,		/* Write to DAA */
+	XPROTO_NAME(FXO, CHAN_CID) = 0x0F,		/* Write to DAA */
+	XPROTO_NAME(FXO, LED) = 0x0F,			/* Write to DAA */
 };


 DEF_RPACKET_DATA(FXO, SIG_CHANGED,
-	xpp_line_t	sig_status;	/* channels: lsb=1, msb=8 */
-	xpp_line_t	sig_toggles;	/* channels: lsb=1, msb=8 */
-	);
+		xpp_line_t sig_status;	/* channels: lsb=1, msb=8 */
+		xpp_line_t sig_toggles;	/* channels: lsb=1, msb=8 */
+		);

-#endif	/* CARD_FXO_H */
+#endif /* CARD_FXO_H */
--- a/drivers/dahdi/xpp/card_fxs.c
+++ b/drivers/dahdi/xpp/card_fxs.c
--- a/drivers/dahdi/xpp/card_fxs.h
+++ b/drivers/dahdi/xpp/card_fxs.h
@@ -25,18 +25,15 @@
 #include "xpd.h"

 enum fxs_opcodes {
-	XPROTO_NAME(FXS, SIG_CHANGED)		= 0x06,
-/**/
-	XPROTO_NAME(FXS, XPD_STATE)		= 0x0F,	/* Write to SLIC */
-	XPROTO_NAME(FXS, CHAN_POWER)		= 0x0F,	/* Write to SLIC */
-	XPROTO_NAME(FXS, CHAN_CID)		= 0x0F,	/* Write to SLIC */
-	XPROTO_NAME(FXS, LED)			= 0x0F,	/* Write to SLIC */
+	XPROTO_NAME(FXS, SIG_CHANGED) = 0x06,
+	 /**/ XPROTO_NAME(FXS, CHAN_POWER) = 0x0F,	/* Write to SLIC */
+	XPROTO_NAME(FXS, CHAN_CID) = 0x0F,	/* Write to SLIC */
+	XPROTO_NAME(FXS, LED) = 0x0F,	/* Write to SLIC */
 };

-
 DEF_RPACKET_DATA(FXS, SIG_CHANGED,
-	xpp_line_t	sig_status;	/* channels: lsb=1, msb=8 */
-	xpp_line_t	sig_toggles;	/* channels: lsb=1, msb=8 */
-	);
+		xpp_line_t sig_status;	/* channels: lsb=1, msb=8 */
+		xpp_line_t sig_toggles;	/* channels: lsb=1, msb=8 */
+		);

-#endif	/* CARD_FXS_H */
+#endif /* CARD_FXS_H */
--- a/drivers/dahdi/xpp/card_global.c
+++ b/drivers/dahdi/xpp/card_global.c
--- a/drivers/dahdi/xpp/card_global.h
+++ b/drivers/dahdi/xpp/card_global.h
@@ -26,88 +26,60 @@
 #include "xbus-pcm.h"

 enum global_opcodes {
-	XPROTO_NAME(GLOBAL, AB_REQUEST)		= 0x07,
-	XPROTO_NAME(GLOBAL, AB_DESCRIPTION)	= 0x08,
-	XPROTO_NAME(GLOBAL, REGISTER_REQUEST)	= 0x0F,
-	XPROTO_NAME(GLOBAL, REGISTER_REPLY)	= 0x10,
-/**/
-	XPROTO_NAME(GLOBAL, PCM_WRITE)		= 0x11,
-	XPROTO_NAME(GLOBAL, PCM_READ)		= 0x12,
-/**/
-	XPROTO_NAME(GLOBAL, SYNC_SOURCE)	= 0x19,
-	XPROTO_NAME(GLOBAL, SYNC_REPLY)		= 0x1A,
-/**/
-	XPROTO_NAME(GLOBAL, ERROR_CODE)		= 0x22,
-	XPROTO_NAME(GLOBAL, RESET_SYNC_COUNTERS)	= 0x23,
-	XPROTO_NAME(GLOBAL, NULL_REPLY)		= 0xFE,
+	XPROTO_NAME(GLOBAL, AB_REQUEST) = 0x07,
+	XPROTO_NAME(GLOBAL, AB_DESCRIPTION) = 0x08,
+	XPROTO_NAME(GLOBAL, REGISTER_REQUEST) = 0x0F,
+	XPROTO_NAME(GLOBAL, REGISTER_REPLY) = 0x10,
+	 /**/ XPROTO_NAME(GLOBAL, PCM_WRITE) = 0x11,
+	XPROTO_NAME(GLOBAL, PCM_READ) = 0x12,
+	 /**/ XPROTO_NAME(GLOBAL, SYNC_SOURCE) = 0x19,
+	XPROTO_NAME(GLOBAL, SYNC_REPLY) = 0x1A,
+	 /**/ XPROTO_NAME(GLOBAL, ERROR_CODE) = 0x22,
+	XPROTO_NAME(GLOBAL, XBUS_RESET) = 0x23,
+	XPROTO_NAME(GLOBAL, NULL_REPLY) = 0xFE,
 };

 struct unit_descriptor {
-	struct xpd_addr	addr;
-	byte		subtype:4;
-	byte		type:4;
-	byte		numchips;
-	byte		ports_per_chip;
-	byte		port_dir;	/* bitmask: 0 - PSTN, 1 - PHONE */
-	byte		reserved[2];
-	struct xpd_addr	ec_addr;
+	struct xpd_addr addr;
+	__u8 subtype:4;
+	__u8 type:4;
+	__u8 numchips;
+	__u8 ports_per_chip;
+	__u8 port_dir;		/* bitmask: 0 - PSTN, 1 - PHONE */
+	__u8 reserved[2];
+	struct xpd_addr ec_addr;
 };

 #define	NUM_UNITS	6

 DEF_RPACKET_DATA(GLOBAL, NULL_REPLY);
-DEF_RPACKET_DATA(GLOBAL, AB_REQUEST,
-	byte		rev;
-	byte		reserved;
-	);
-DEF_RPACKET_DATA(GLOBAL, AB_DESCRIPTION,
-	byte			rev;
-	byte			reserved[3];
-	struct unit_descriptor	unit_descriptor[NUM_UNITS];
-	);
-DEF_RPACKET_DATA(GLOBAL, REGISTER_REQUEST,
-	reg_cmd_t	reg_cmd;
-	);
-DEF_RPACKET_DATA(GLOBAL, PCM_WRITE,
-	xpp_line_t	lines;
-	byte		pcm[PCM_CHUNKSIZE];
-	);
-DEF_RPACKET_DATA(GLOBAL, PCM_READ,
-	xpp_line_t	lines;
-	byte		pcm[PCM_CHUNKSIZE];
-	);
-DEF_RPACKET_DATA(GLOBAL, SYNC_SOURCE,
-	byte		sync_mode;
-	byte		drift;
-	);
-DEF_RPACKET_DATA(GLOBAL, SYNC_REPLY,
-	byte		sync_mode;
-	byte		drift;
-	);
-DEF_RPACKET_DATA(GLOBAL, REGISTER_REPLY,
-	reg_cmd_t	regcmd;
-	);
-DEF_RPACKET_DATA(GLOBAL, RESET_SYNC_COUNTERS,
-	byte		mask;
-	);
-DEF_RPACKET_DATA(GLOBAL, ERROR_CODE,
-	byte		category_code;
-	byte		errorbits;
-	byte		bad_packet[0];
-	);
+DEF_RPACKET_DATA(GLOBAL, AB_REQUEST, __u8 rev; __u8 reserved;);
+DEF_RPACKET_DATA(GLOBAL, AB_DESCRIPTION, __u8 rev; __u8 reserved[3];
+		 struct unit_descriptor unit_descriptor[NUM_UNITS];);
+DEF_RPACKET_DATA(GLOBAL, REGISTER_REQUEST, reg_cmd_t reg_cmd;);
+DEF_RPACKET_DATA(GLOBAL, PCM_WRITE, xpp_line_t lines; __u8 pcm[PCM_CHUNKSIZE];);
+DEF_RPACKET_DATA(GLOBAL, PCM_READ, xpp_line_t lines; __u8 pcm[PCM_CHUNKSIZE];);
+DEF_RPACKET_DATA(GLOBAL, SYNC_SOURCE, __u8 sync_mode; __u8 drift;);
+DEF_RPACKET_DATA(GLOBAL, SYNC_REPLY, __u8 sync_mode; __u8 drift;);
+DEF_RPACKET_DATA(GLOBAL, REGISTER_REPLY, reg_cmd_t regcmd;);
+DEF_RPACKET_DATA(GLOBAL, XBUS_RESET, __u8 mask;);
+DEF_RPACKET_DATA(GLOBAL, ERROR_CODE, __u8 category_code; __u8 errorbits;
+		 __u8 bad_packet[0];);

 /* 0x07 */ DECLARE_CMD(GLOBAL, AB_REQUEST);
 /* 0x19 */ DECLARE_CMD(GLOBAL, SYNC_SOURCE, enum sync_mode mode, int drift);
+/* 0x23 */ DECLARE_CMD(GLOBAL, RESET_SPI);
 /* 0x23 */ DECLARE_CMD(GLOBAL, RESET_SYNC_COUNTERS);

 int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno,
-	bool writing, byte regnum, bool do_subreg, byte subreg,
-	byte data_low, bool do_datah, byte data_high, bool should_reply);
+			 bool writing, __u8 regnum, bool do_subreg, __u8 subreg,
+			 __u8 data_low, bool do_datah, __u8 data_high,
+			 bool should_reply);
 int send_multibyte_request(xbus_t *xbus, unsigned unit, xportno_t portno,
-	bool eoftx, byte *buf, unsigned len);
+			   bool eoftx, __u8 *buf, unsigned len);
 extern xproto_table_t PROTO_TABLE(GLOBAL);
 int run_initialize_registers(xpd_t *xpd);
 int parse_chip_command(xpd_t *xpd, char *cmdline);
 extern charp initdir;

-#endif	/* CARD_GLOBAL_H */
+#endif /* CARD_GLOBAL_H */
--- a/drivers/dahdi/xpp/card_pri.c
+++ b/drivers/dahdi/xpp/card_pri.c
--- a/drivers/dahdi/xpp/card_pri.h
+++ b/drivers/dahdi/xpp/card_pri.h
@@ -25,8 +25,7 @@
 #include "xpd.h"

 enum pri_opcodes {
-	XPROTO_NAME(PRI, SET_LED)			= 0x33,
+	XPROTO_NAME(PRI, SET_LED) = 0x33,
 };

-
-#endif	/* CARD_PRI_H */
+#endif /* CARD_PRI_H */
--- a/drivers/dahdi/xpp/dahdi_debug.c
+++ b/drivers/dahdi/xpp/dahdi_debug.c
@@ -20,11 +20,6 @@
 *
 */
 #include <linux/version.h>
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-#  warning "This module is tested only with 2.6 kernels"
-#endif
-
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/module.h>
@@ -35,57 +30,48 @@
 static const char rcsid[] = "$Id$";

 #define	P_(x)	[ x ] = { .value = x, .name = #x, }
-static	struct {
+static struct {
 	int value;
 	char *name;
 } poll_names[] = {
-	P_(POLLIN),
-	P_(POLLPRI),
-	P_(POLLOUT),
-	P_(POLLERR),
-	P_(POLLHUP),
-	P_(POLLNVAL),
-	P_(POLLRDNORM),
-	P_(POLLRDBAND),
-	P_(POLLWRNORM),
-	P_(POLLWRBAND),
-	P_(POLLMSG),
-	P_(POLLREMOVE)
+	P_(POLLIN), P_(POLLPRI), P_(POLLOUT), P_(POLLERR), P_(POLLHUP),
+	    P_(POLLNVAL), P_(POLLRDNORM), P_(POLLRDBAND), P_(POLLWRNORM),
+	    P_(POLLWRBAND), P_(POLLMSG), P_(POLLREMOVE)
 };
+
 #undef	P_

 void dump_poll(int debug, const char *msg, int poll)
 {
-	int	i;
+	int i;

-	for(i = 0; i < ARRAY_SIZE(poll_names); i++) {
-		if(poll & poll_names[i].value)
+	for (i = 0; i < ARRAY_SIZE(poll_names); i++) {
+		if (poll & poll_names[i].value)
 			DBG(GENERAL, "%s: %s\n", msg, poll_names[i].name);
 	}
 }
+EXPORT_SYMBOL(dump_poll);

 void alarm2str(int alarm, char *buf, int buflen)
 {
-	char	*p = buf;
-	int	left = buflen;
-	int	i;
-	int	n;
+	char *p = buf;
+	int left = buflen;
+	int i;
+	int n;

-	if(!alarm) {
+	if (!alarm) {
 		snprintf(buf, buflen, "NONE");
 		return;
 	}
 	memset(buf, 0, buflen);
-	for(i = 0; i < 8; i++) {
-		if(left && (alarm & BIT(i))) {
+	for (i = 0; i < 8; i++) {
+		if (left && (alarm & BIT(i))) {
 			n = snprintf(p, left, "%s,", alarmbit2str(i));
 			p += n;
 			left -= n;
 		}
 	}
-	if(p > buf)	/* kill last comma */
+	if (p > buf)		/* kill last comma */
 		*(p - 1) = '\0';
 }
-
-EXPORT_SYMBOL(dump_poll);
 EXPORT_SYMBOL(alarm2str);
--- a/drivers/dahdi/xpp/dahdi_debug.h
+++ b/drivers/dahdi/xpp/dahdi_debug.h
@@ -26,55 +26,76 @@

 /* Debugging Macros */

-#define	PRINTK(level, category, fmt, ...)	\
-	printk(KERN_ ## level "%s%s-%s: " fmt, #level, category, THIS_MODULE->name, ## __VA_ARGS__)
+#define	PRINTK(level, category, fmt, ...) \
+	printk(KERN_ ## level "%s%s-%s: " fmt, \
+	#level, category, THIS_MODULE->name, ## __VA_ARGS__)

-#define	XBUS_PRINTK(level, category, xbus, fmt, ...)	\
-	printk(KERN_ ## level "%s%s-%s: %s: " fmt, #level,	\
+#define	XBUS_PRINTK(level, category, xbus, fmt, ...) \
+	printk(KERN_ ## level "%s%s-%s: %s: " fmt, #level, \
 		category, THIS_MODULE->name, (xbus)->busname, ## __VA_ARGS__)

-#define	XPD_PRINTK(level, category, xpd, fmt, ...)	\
-	printk(KERN_ ## level "%s%s-%s: %s/%s: " fmt, #level,	\
-		category, THIS_MODULE->name, (xpd)->xbus->busname, (xpd)->xpdname, ## __VA_ARGS__)
+#define	XPD_PRINTK(level, category, xpd, fmt, ...) \
+	printk(KERN_ ## level "%s%s-%s: %s/%s: " fmt, #level, \
+		category, THIS_MODULE->name, \
+		(xpd)->xbus->busname, (xpd)->xpdname, ## __VA_ARGS__)

-#define	LINE_PRINTK(level, category, xpd, pos, fmt, ...)	\
-	printk(KERN_ ## level "%s%s-%s: %s/%s/%d: " fmt, #level,	\
-		category, THIS_MODULE->name, (xpd)->xbus->busname, (xpd)->xpdname, (pos), ## __VA_ARGS__)
+#define	LINE_PRINTK(level, category, xpd, pos, fmt, ...) \
+	printk(KERN_ ## level "%s%s-%s: %s/%s/%d: " fmt, #level, \
+		category, THIS_MODULE->name, \
+		(xpd)->xbus->busname, (xpd)->xpdname, (pos), ## __VA_ARGS__)

-#define	PORT_PRINTK(level, category, xbus, unit, port, fmt, ...)	\
-	printk(KERN_ ## level "%s%s-%s: %s UNIT=%d PORT=%d: " fmt, #level,	\
-		category, THIS_MODULE->name, (xbus)->busname, (unit), (port), ## __VA_ARGS__)
+#define	PORT_PRINTK(level, category, xbus, unit, port, fmt, ...) \
+	printk(KERN_ ## level "%s%s-%s: %s UNIT=%d PORT=%d: " fmt, #level, \
+		category, THIS_MODULE->name, \
+		(xbus)->busname, (unit), (port), ## __VA_ARGS__)

-#define	DBG(bits, fmt, ...)	\
-	((void)((debug & (DBG_ ## bits)) && PRINTK(DEBUG, "-" #bits, "%s: " fmt, __FUNCTION__, ## __VA_ARGS__)))
+#define	DBG(bits, fmt, ...) \
+	((void)((debug & (DBG_ ## bits)) && \
+		PRINTK(DEBUG, "-" #bits, "%s: " fmt, \
+		__func__, ## __VA_ARGS__)))
 #define	INFO(fmt, ...)		PRINTK(INFO, "", fmt, ## __VA_ARGS__)
 #define	NOTICE(fmt, ...)	PRINTK(NOTICE, "", fmt, ## __VA_ARGS__)
 #define	WARNING(fmt, ...)	PRINTK(WARNING, "", fmt, ## __VA_ARGS__)
 #define	ERR(fmt, ...)		PRINTK(ERR, "", fmt, ## __VA_ARGS__)

-#define	XBUS_DBG(bits, xbus, fmt, ...)	\
-			((void)((debug & (DBG_ ## bits)) && XBUS_PRINTK(DEBUG, "-" #bits, xbus, "%s: " fmt, __FUNCTION__, ## __VA_ARGS__)))
-#define	XBUS_INFO(xbus, fmt, ...)		XBUS_PRINTK(INFO, "", xbus, fmt, ## __VA_ARGS__)
-#define	XBUS_NOTICE(xbus, fmt, ...)		XBUS_PRINTK(NOTICE, "", xbus, fmt, ## __VA_ARGS__)
-#define	XBUS_ERR(xbus, fmt, ...)		XBUS_PRINTK(ERR, "", xbus, fmt, ## __VA_ARGS__)
+#define	XBUS_DBG(bits, xbus, fmt, ...) \
+	((void)((debug & (DBG_ ## bits)) && XBUS_PRINTK(DEBUG, "-" #bits, \
+	xbus, "%s: " fmt, __func__, ## __VA_ARGS__)))
+#define	XBUS_INFO(xbus, fmt, ...) \
+		XBUS_PRINTK(INFO, "", xbus, fmt, ## __VA_ARGS__)
+#define	XBUS_NOTICE(xbus, fmt, ...) \
+		XBUS_PRINTK(NOTICE, "", xbus, fmt, ## __VA_ARGS__)
+#define	XBUS_ERR(xbus, fmt, ...) \
+		XBUS_PRINTK(ERR, "", xbus, fmt, ## __VA_ARGS__)

-#define	XPD_DBG(bits, xpd, fmt, ...)	\
-		((void)((debug & (DBG_ ## bits)) && XPD_PRINTK(DEBUG, "-" #bits, xpd, "%s: " fmt, __FUNCTION__, ## __VA_ARGS__)))
-#define	XPD_INFO(xpd, fmt, ...)		XPD_PRINTK(INFO, "", xpd, fmt, ## __VA_ARGS__)
-#define	XPD_NOTICE(xpd, fmt, ...)	XPD_PRINTK(NOTICE, "", xpd, fmt, ## __VA_ARGS__)
-#define	XPD_WARNING(xpd, fmt, ...)	XPD_PRINTK(WARNING, "", xpd, fmt, ## __VA_ARGS__)
-#define	XPD_ERR(xpd, fmt, ...)		XPD_PRINTK(ERR, "", xpd, fmt, ## __VA_ARGS__)
+#define	XPD_DBG(bits, xpd, fmt, ...) \
+	((void)((debug & (DBG_ ## bits)) && XPD_PRINTK(DEBUG, "-" #bits, \
+	xpd, "%s: " fmt, __func__, ## __VA_ARGS__)))
+#define	XPD_INFO(xpd, fmt, ...) \
+		XPD_PRINTK(INFO, "", xpd, fmt, ## __VA_ARGS__)
+#define	XPD_NOTICE(xpd, fmt, ...) \
+		XPD_PRINTK(NOTICE, "", xpd, fmt, ## __VA_ARGS__)
+#define	XPD_WARNING(xpd, fmt, ...) \
+		XPD_PRINTK(WARNING, "", xpd, fmt, ## __VA_ARGS__)
+#define	XPD_ERR(xpd, fmt, ...) \
+		XPD_PRINTK(ERR, "", xpd, fmt, ## __VA_ARGS__)

-#define	LINE_DBG(bits, xpd, pos, fmt, ...)	\
-			((void)((debug & (DBG_ ## bits)) && LINE_PRINTK(DEBUG, "-" #bits, xpd, pos, "%s: " fmt, __FUNCTION__, ## __VA_ARGS__)))
-#define	LINE_NOTICE(xpd, pos, fmt, ...)		LINE_PRINTK(NOTICE, "", xpd, pos, fmt, ## __VA_ARGS__)
-#define	LINE_ERR(xpd, pos, fmt, ...)		LINE_PRINTK(ERR, "", xpd, pos, fmt, ## __VA_ARGS__)
+#define	LINE_DBG(bits, xpd, pos, fmt, ...) \
+	((void)((debug & (DBG_ ## bits)) && LINE_PRINTK(DEBUG, "-" #bits, \
+	xpd, pos, "%s: " fmt, __func__, ## __VA_ARGS__)))
+#define	LINE_NOTICE(xpd, pos, fmt, ...) \
+		LINE_PRINTK(NOTICE, "", xpd, pos, fmt, ## __VA_ARGS__)
+#define	LINE_ERR(xpd, pos, fmt, ...) \
+		LINE_PRINTK(ERR, "", xpd, pos, fmt, ## __VA_ARGS__)

-#define	PORT_DBG(bits, xbus, unit, port, fmt, ...)	\
-			((void)((debug & (DBG_ ## bits)) && PORT_PRINTK(DEBUG, "-" #bits,	\
-					xbus, unit, port, "%s: " fmt, __FUNCTION__, ## __VA_ARGS__)))
-#define	PORT_NOTICE(xbus, unit, port, fmt, ...)	PORT_PRINTK(NOTICE, "", xbus, unit, port, fmt, ## __VA_ARGS__)
-#define	PORT_ERR(xbus, unit, port, fmt, ...)		PORT_PRINTK(ERR, "", xbus, unit, port, fmt, ## __VA_ARGS__)
+#define	PORT_DBG(bits, xbus, unit, port, fmt, ...) \
+		((void)((debug & (DBG_ ## bits)) && \
+		PORT_PRINTK(DEBUG, "-" #bits, \
+		xbus, unit, port, "%s: " fmt, __func__, ## __VA_ARGS__)))
+#define	PORT_NOTICE(xbus, unit, port, fmt, ...) \
+		PORT_PRINTK(NOTICE, "", xbus, unit, port, fmt, ## __VA_ARGS__)
+#define	PORT_ERR(xbus, unit, port, fmt, ...) \
+		PORT_PRINTK(ERR, "", xbus, unit, port, fmt, ## __VA_ARGS__)

 /*
 * Bits for debug
@@ -94,63 +115,98 @@ void dump_poll(int debug, const char *msg, int poll);

 static inline char *rxsig2str(enum dahdi_rxsig sig)
 {
-	switch(sig) {
-		case DAHDI_RXSIG_ONHOOK:	return "ONHOOK";
-		case DAHDI_RXSIG_OFFHOOK:	return "OFFHOOK";
-		case DAHDI_RXSIG_START:	return "START";
-		case DAHDI_RXSIG_RING:	return "RING";
-		case DAHDI_RXSIG_INITIAL:	return "INITIAL";
+	switch (sig) {
+	case DAHDI_RXSIG_ONHOOK:
+		return "ONHOOK";
+	case DAHDI_RXSIG_OFFHOOK:
+		return "OFFHOOK";
+	case DAHDI_RXSIG_START:
+		return "START";
+	case DAHDI_RXSIG_RING:
+		return "RING";
+	case DAHDI_RXSIG_INITIAL:
+		return "INITIAL";
 	}
 	return "Unknown rxsig";
 }

 static inline char *txsig2str(enum dahdi_txsig sig)
 {
-	switch(sig) {
-		case DAHDI_TXSIG_ONHOOK:	return "TXSIG_ONHOOK";
-		case DAHDI_TXSIG_OFFHOOK:	return "TXSIG_OFFHOOK";
-		case DAHDI_TXSIG_START:	return "TXSIG_START";
-		case DAHDI_TXSIG_KEWL:	return "TXSIG_KEWL";				/* Drop battery if possible */
-		case DAHDI_TXSIG_TOTAL: break;
+	switch (sig) {
+	case DAHDI_TXSIG_ONHOOK:
+		return "TXSIG_ONHOOK";
+	case DAHDI_TXSIG_OFFHOOK:
+		return "TXSIG_OFFHOOK";
+	case DAHDI_TXSIG_START:
+		return "TXSIG_START";
+	case DAHDI_TXSIG_KEWL:
+		return "TXSIG_KEWL";	/* Drop battery if possible */
+	case DAHDI_TXSIG_TOTAL:
+		break;
 	}
 	return "Unknown txsig";
 }

 static inline char *event2str(int event)
 {
-	switch(event) {
-		case DAHDI_EVENT_NONE:		return "NONE";
-		case DAHDI_EVENT_ONHOOK:		return "ONHOOK";
-		case DAHDI_EVENT_RINGOFFHOOK:	return "RINGOFFHOOK";
-		case DAHDI_EVENT_WINKFLASH:	return "WINKFLASH";
-		case DAHDI_EVENT_ALARM:		return "ALARM";
-		case DAHDI_EVENT_NOALARM:		return "NOALARM";
-		case DAHDI_EVENT_ABORT:		return "ABORT";
-		case DAHDI_EVENT_OVERRUN:		return "OVERRUN";
-		case DAHDI_EVENT_BADFCS:		return "BADFCS";
-		case DAHDI_EVENT_DIALCOMPLETE:	return "DIALCOMPLETE";
-		case DAHDI_EVENT_RINGERON:		return "RINGERON";
-		case DAHDI_EVENT_RINGEROFF:	return "RINGEROFF";
-		case DAHDI_EVENT_HOOKCOMPLETE:	return "HOOKCOMPLETE";
-		case DAHDI_EVENT_BITSCHANGED:	return "BITSCHANGED";
-		case DAHDI_EVENT_PULSE_START:	return "PULSE_START";
-		case DAHDI_EVENT_TIMER_EXPIRED:	return "TIMER_EXPIRED";
-		case DAHDI_EVENT_TIMER_PING:	return "TIMER_PING";
-		case DAHDI_EVENT_POLARITY:		return "POLARITY";
+	switch (event) {
+	case DAHDI_EVENT_NONE:
+		return "NONE";
+	case DAHDI_EVENT_ONHOOK:
+		return "ONHOOK";
+	case DAHDI_EVENT_RINGOFFHOOK:
+		return "RINGOFFHOOK";
+	case DAHDI_EVENT_WINKFLASH:
+		return "WINKFLASH";
+	case DAHDI_EVENT_ALARM:
+		return "ALARM";
+	case DAHDI_EVENT_NOALARM:
+		return "NOALARM";
+	case DAHDI_EVENT_ABORT:
+		return "ABORT";
+	case DAHDI_EVENT_OVERRUN:
+		return "OVERRUN";
+	case DAHDI_EVENT_BADFCS:
+		return "BADFCS";
+	case DAHDI_EVENT_DIALCOMPLETE:
+		return "DIALCOMPLETE";
+	case DAHDI_EVENT_RINGERON:
+		return "RINGERON";
+	case DAHDI_EVENT_RINGEROFF:
+		return "RINGEROFF";
+	case DAHDI_EVENT_HOOKCOMPLETE:
+		return "HOOKCOMPLETE";
+	case DAHDI_EVENT_BITSCHANGED:
+		return "BITSCHANGED";
+	case DAHDI_EVENT_PULSE_START:
+		return "PULSE_START";
+	case DAHDI_EVENT_TIMER_EXPIRED:
+		return "TIMER_EXPIRED";
+	case DAHDI_EVENT_TIMER_PING:
+		return "TIMER_PING";
+	case DAHDI_EVENT_POLARITY:
+		return "POLARITY";
 	}
 	return "Unknown event";
 }

 static inline char *hookstate2str(int hookstate)
 {
-	switch(hookstate) {
-		case DAHDI_ONHOOK:		return "DAHDI_ONHOOK";
-		case DAHDI_START:		return "DAHDI_START";
-		case DAHDI_OFFHOOK:	return "DAHDI_OFFHOOK";
-		case DAHDI_WINK:		return "DAHDI_WINK";
-		case DAHDI_FLASH:		return "DAHDI_FLASH";
-		case DAHDI_RING:		return "DAHDI_RING";
-		case DAHDI_RINGOFF:	return "DAHDI_RINGOFF";
+	switch (hookstate) {
+	case DAHDI_ONHOOK:
+		return "DAHDI_ONHOOK";
+	case DAHDI_START:
+		return "DAHDI_START";
+	case DAHDI_OFFHOOK:
+		return "DAHDI_OFFHOOK";
+	case DAHDI_WINK:
+		return "DAHDI_WINK";
+	case DAHDI_FLASH:
+		return "DAHDI_FLASH";
+	case DAHDI_RING:
+		return "DAHDI_RING";
+	case DAHDI_RINGOFF:
+		return "DAHDI_RINGOFF";
 	}
 	return "Unknown hookstate";
 }
@@ -159,25 +215,42 @@ static inline char *hookstate2str(int hookstate)
 static inline char *sig2str(int sig)
 {
 	switch (sig) {
-		case DAHDI_SIG_FXSLS:	return "FXSLS";
-		case DAHDI_SIG_FXSKS:	return "FXSKS";
-		case DAHDI_SIG_FXSGS:	return "FXSGS";
-		case DAHDI_SIG_FXOLS:	return "FXOLS";
-		case DAHDI_SIG_FXOKS:	return "FXOKS";
-		case DAHDI_SIG_FXOGS:	return "FXOGS";
-		case DAHDI_SIG_EM:		return "E&M";
-		case DAHDI_SIG_EM_E1:	return "E&M-E1";
-		case DAHDI_SIG_CLEAR:	return "Clear";
-		case DAHDI_SIG_HDLCRAW:	return "HDLCRAW";
-		case DAHDI_SIG_HDLCFCS:	return "HDLCFCS";
-		case DAHDI_SIG_HDLCNET:	return "HDLCNET";
-		case DAHDI_SIG_SLAVE:	return "Slave";
-		case DAHDI_SIG_CAS:	return "CAS";
-		case DAHDI_SIG_DACS:	return "DACS";
-		case DAHDI_SIG_DACS_RBS:	return "DACS+RBS";
-		case DAHDI_SIG_SF:		return "SF (ToneOnly)";
-		case DAHDI_SIG_NONE:
-					break;
+	case DAHDI_SIG_FXSLS:
+		return "FXSLS";
+	case DAHDI_SIG_FXSKS:
+		return "FXSKS";
+	case DAHDI_SIG_FXSGS:
+		return "FXSGS";
+	case DAHDI_SIG_FXOLS:
+		return "FXOLS";
+	case DAHDI_SIG_FXOKS:
+		return "FXOKS";
+	case DAHDI_SIG_FXOGS:
+		return "FXOGS";
+	case DAHDI_SIG_EM:
+		return "E&M";
+	case DAHDI_SIG_EM_E1:
+		return "E&M-E1";
+	case DAHDI_SIG_CLEAR:
+		return "Clear";
+	case DAHDI_SIG_HDLCRAW:
+		return "HDLCRAW";
+	case DAHDI_SIG_HDLCFCS:
+		return "HDLCFCS";
+	case DAHDI_SIG_HDLCNET:
+		return "HDLCNET";
+	case DAHDI_SIG_SLAVE:
+		return "Slave";
+	case DAHDI_SIG_CAS:
+		return "CAS";
+	case DAHDI_SIG_DACS:
+		return "DACS";
+	case DAHDI_SIG_DACS_RBS:
+		return "DACS+RBS";
+	case DAHDI_SIG_SF:
+		return "SF (ToneOnly)";
+	case DAHDI_SIG_NONE:
+		break;
 	}
 	return "Unconfigured";
 }
@@ -185,18 +258,25 @@ static inline char *sig2str(int sig)
 static inline char *alarmbit2str(int alarmbit)
 {
 	/* from dahdi/kernel.h */
-	switch(1 << alarmbit) {
-		case DAHDI_ALARM_NONE:	return "NONE";
-		case DAHDI_ALARM_RECOVER:	return "RECOVER";
-		case DAHDI_ALARM_LOOPBACK:	return "LOOPBACK";
-		case DAHDI_ALARM_YELLOW:	return "YELLOW";
-		case DAHDI_ALARM_RED:	return "RED";
-		case DAHDI_ALARM_BLUE:	return "BLUE";
-		case DAHDI_ALARM_NOTOPEN:	return "NOTOPEN";
+	switch (1 << alarmbit) {
+	case DAHDI_ALARM_NONE:
+		return "NONE";
+	case DAHDI_ALARM_RECOVER:
+		return "RECOVER";
+	case DAHDI_ALARM_LOOPBACK:
+		return "LOOPBACK";
+	case DAHDI_ALARM_YELLOW:
+		return "YELLOW";
+	case DAHDI_ALARM_RED:
+		return "RED";
+	case DAHDI_ALARM_BLUE:
+		return "BLUE";
+	case DAHDI_ALARM_NOTOPEN:
+		return "NOTOPEN";
 	}
 	return "UNKNOWN";
 }

 void alarm2str(int alarm, char *buf, int buflen);

-#endif	/* DAHDI_DEBUG_H */
+#endif /* DAHDI_DEBUG_H */
--- a/drivers/dahdi/xpp/firmwares/FPGA_1141.hex
+++ b/drivers/dahdi/xpp/firmwares/FPGA_1141.hex
--- a/drivers/dahdi/xpp/firmwares/FPGA_1151.hex
+++ b/drivers/dahdi/xpp/firmwares/FPGA_1151.hex
--- a/drivers/dahdi/xpp/firmwares/FPGA_1161.201.hex
+++ b/drivers/dahdi/xpp/firmwares/FPGA_1161.201.hex
--- a/drivers/dahdi/xpp/firmwares/FPGA_FXS.hex
+++ b/drivers/dahdi/xpp/firmwares/FPGA_FXS.hex
--- a/drivers/dahdi/xpp/firmwares/Makefile
+++ b/drivers/dahdi/xpp/firmwares/Makefile
@@ -1,10 +1,12 @@
 # Install firmwares and initialization scripts for the Astribank
 # drivers

-FPGA_FW		= FPGA_FXS.hex FPGA_1141.hex FPGA_1151.hex FPGA_1161.hex
+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
 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.hex $(FPGA_FW) $(PIC_FW) $(OCT_FW)
+FIRMWARES	= $(USB_FW) $(FPGA_FW) $(PIC_FW) $(OCT_FW)
 PROTO_VER	= 30
 SCRIPTS_BASE	= $(patsubst %,init_card_%_$(PROTO_VER),1 2 3 4 5)
 SCRIPTS		= $(SCRIPTS_BASE:%=../%)
--- a/drivers/dahdi/xpp/firmwares/PIC_TYPE_1.hex
+++ b/drivers/dahdi/xpp/firmwares/PIC_TYPE_1.hex
@@ -1,5 +1,5 @@
 #        
-# $Id: PIC_TYPE_1.hex 9732 2011-08-24 19:13:55Z dima $
+# $Id: PIC_TYPE_1.hex 9841 2011-09-08 17:00:23Z dima $
 #        
 :03000000A1EA4A28
 :03000100C41C41DB
@@ -31,8 +31,8 @@
 :03001B00D00D0005
 :03001C00A17A17AF
 :03001D0080080058
-:03001E00C0710BA3
-:03001F0016603830
+:03001E00C0010B13
+:03001F0019A038ED
 :03002000743C0627
 :03002100A26D804D
 :03002200C01024E7
@@ -42,451 +42,445 @@
 :03002600C03030B7
 :0300270018C901F4
 :030028006432043B
-:03002900A4C03040
+:03002900A4A03060
 :03002A0020C901E9
 :03002B007432022A
-:03002C00AFA03052
-:03002D0020990116
-:03002E00021C8031
-:03002F00C40FFFFC
-:03003000D8016490
-:03003100024C106E
-:03003200C00FFFFD
-:0300330002215057
-:03003400201D0884
-:030035000306B906
-:03003600901D100A
-:0300370020402244
-:03003800030201BF
-:03003900901030F4
-:03003A0020290179
-:03003B00030204B9
-:03003C00901030F1
-:03003D00C11901E5
-:03003E00190202A2
-:03003F00643030FA
-:03004000A45901BF
-:03004100C22800D2
-:030042001902148C
-:03004300743E7098
-:03004400A483088A
-:03004500209308FD
-:030046001253084A
-:03004700A4B30857
-:03004800209027DE
-:03004900FFF800BD
-:03004A00165C0041
-:03004B00AFA0392A
-:03004C00209038C9
-:03004D00145C0739
-:03004E00643D40CE
-:03004F00A8C03412
-:03005000209C08E9
-:0300510002103862
-:03005200C40219CC
-:03005300D80E07BD
-:0300540002402047
-:03005500C0036085
-:0300560002236022
-:0300570020136013
-:030058000303603F
-:03005900901C10E8
-:03005A002040380B
-:03005B0003021984
-:03005C00901E07EC
-:03005D002021203F
-:03005E00030C1080
-:03005F009011807D
-:03006000C11E704E
-:0300610019074339
-:03006200643A728B
-:03006300A68C0266
-:03006400C2218036
-:03006500190E076A
-:03006600743643AA
-:03006700A8CA75AF
-:03006800209C03D6
-:0300690002118001
-:03006A00C44E077A
-:03006B00D8064371
-:03006C00024A75D0
-:03006D00C00C04C0
-:03006E00022180EC
-:03006F00201E0749
-:0300700003064341
-:03007100901A756D
-:03007200204C011E
-:030073000300384F
-:03007400901A746B
-:03007500202C1824
-:030076000300384C
-:03007700901219CB
-:03007800210E0F47
-:03007900E0303D37
-:03007A00743C00D3
-:03007B00C040384A
-:03007C00190C025A
-:03007D007481800B
-:03007E00A8CE0702
-:03007F00C0474334
-:03008000FFFA85FF
-:03008100150C3F1C
-:03008200643031B6
-:03008300A87C1640
-:03008400209A922D
-:0300850013EC0376
-:03008600A8A180AE
-:03008700209E07B1
-:03008800FFF7433C
-:0300890017EA8EE5
-:03008A0021ECFF67
-:03008B00035031EE
-:03008C00C14C184C
-:03008D00D80A92FC
-:03008E00024C031E
-:03008F00C000317D
-:03009000022C122D
-:03009100201A92A0
-:0300920003003C2C
-:03009300901E0FAD
-:0300940020409D6C
-:030095000307035B
-:03009600901A9C21
-:03009700202C0F0B
-:03009800030FFF54
-:0300990090115C67
-:03009A0021011D24
-:03009B00E01A9DCB
-:03009C0002721CD1
-:03009D00C18030EF
-:03009E00D80E0F6A
-:03009F0002403CE0
-:0300A000C00C028F
-:0300A10002203901
-:0300A200201C001F
-:0300A3000300391E
-:0300A400901C802D
-:0300A500204024D4
-:0300A600030C0840
-:0300A700901104B1
-:0300A800202039DC
-:0300A900030C0045
-:0300AA009010397A
-:0300AB00210C0025
-:0300AC0003B02678
-:0300AD00C140252A
-:0300AE0002403ECF
-:0300AF00C0102B53
-:0300B000022C031C
-:0300B10020102CF0
-:0300B200030C40FC
-:0300B30090103971
-:0300B4002047D909
-:0300B500030AB487
-:0300B600901C009B
-:0300B700207208AC
-:0300B80003003012
-:0300B9009019019A
-:0300BA0021AC80F6
-:0300BB0014120814
-:0300BC0070703031
-:0300BD00AC09018A
-:0300BE00181C40CB
-:0300BF00AC303929
-:0300C00069BC0117
-:0300C100AFA037B6
-:0300C200F00C60DF
-:0300C3002282C8CE
-:0300C400643AC3D8
-:0300C500AFAC00DD
-:0300C6001BA03745
-:0300C700C106D996
-:0300C800FFFACC70
-:0300C90017B6F96E
-:0300CA0021ABCF98
-:0300CB00141AC73D
-:0300CC0064394252
-:0300CD00AD0C0275
-:0300CE00C10180ED
-:0300CF0013BE0756
-:0300D000C507431E
-:0300D100039AEDA2
-:0300D200799C0610
-:0300D300AD2195C7
-:0300D40020B7430F
-:0300D500D00AED61
-:0300D6000387D3CA
-:0300D700219AED7E
-:0300D800E07C06C3
-:0300D900348187E8
-:0300DA0034874325
-:0300DB00348ADE86
-:0300DC00348C035E
-:0300DD00030AEB28
-:0300DE00206C078C
-:0300DF00348187E2
-:0300E0003487431F
-:0300E100348AE47A
-:0300E200348C015A
-:0300E300D05AEB05
-:0300E400031C03F7
-:0300E500C00187D0
-:0300E600032743AA
-:0300E700033AEAEF
-:0300E800C70C0042
-:0300E900039AEB8C
-:0300EA00C5020745
-:0300EB0003902758
-:0300EC00C18AFACC
-:0300ED00030C06FB
-:0300EE00C00195B9
-:0300EF00031643B2
-:0300F00021BAFA38
-:0300F100032C01DC
-:0300F200C001C783
-:0300F30003309C3B
-:0300F400C7070338
-:0300F500039AFA71
-:0300F600C50CFF37
-:0300F70003902251
-:0300F800C400271A
-:0300F900039B6204
-:0300FA00369C0031
-:0300FB00C016F339
-:0300FC001E6CFF78
-:0300FD0021C021FE
-:0300FE00086C018A
-:0300FF0074302436
-:03010000A1E90A68
-:030101000266B3E0
-:03010200C02B8986
-:03010300FFFC01FD
-:0301040016B02F03
-:03010500C0221500
-:0301060023E6D31A
-:03010700743D80C4
-:0301080012B0240E
-:0301090020B2170A
-:03010A000380224D
-:03010B00C44C06DB
-:03010C00039195C7
-:03010D00C40743E1
-:03010E00039B51FF
-:03010F00C006D354
-:03011000023B515E
-:03011100ABECE074
-:03011200B12157C1
-:03011300000643A0
-:03011400000B518C
-:03011500000C00DB
-:030116000007B728
-:03011700000C05D4
-:030118000007D706
-:03011900000C10C7
-:03011A000007F7E4
-:03011B00000C02D3
-:03011C00000027B9
-:03011D00000C10C3
-:03011E00000D02CF
-:03011F00000FFFCF
-:0301200000014299
-:030121000006973E
-:03012200000D02CB
-:030123000006379C
-:03012400000D10BB
-:03012500000022B5
-:03012600000C804A
-:03012700000124B0
-:03012800000C02C6
-:0301290000018052
-:03012A00000E07BD
-:03012B0000074387
-:03012C00000B3F86
-:03012D00000C05BE
-:03012E0000014786
-:03012F0000064384
-:03013000000B3F82
-:03013100000C01BE
-:0301320000018148
-:030133000007437F
-:03013400000B3885
-:03013500000C10AB
-:03013600000021A5
-:03013700000B3F7B
-:03013800000C10A8
-:0301390000018141
-:03013A0000074378
-:03013B00000B3F77
-:03013C00000C2094
-:03013D000000219E
-:03013E00000B3F74
-:03013F00000201BA
+:03002C00AE803073
+:03002D00C4090102
+:03002E00D80C806B
+:03002F00024FFF7E
+:03003000C00164A8
+:03003100022C108E
+:03003200209FFF0D
+:0300330003015076
+:03003400901D0814
+:030035002046B9A9
+:03003600030D10A7
+:0300370090102204
+:0300380020220182
+:0300390003003091
+:03003A0090190119
+:03003B00C11204EB
+:03003C0019003078
+:03003D0064390122
+:03003E00A43202E7
+:03003F00C22030AC
+:030040001909019A
+:0300410074380010
+:03004200A46214A1
+:03004300209E708C
+:030044001253084C
+:03004500A4930879
+:03004600209308FC
+:03004700FFF308BC
+:0300480016502728
+:03004900AE88007E
+:03004A00209C00F7
+:03004B0014503915
+:03004C00643038E5
+:03004D00A8603F69
+:03004E00C40C07D8
+:03004F00D80D4089
+:0300500002403437
+:03005100C00C08D8
+:0300520002203851
+:03005300209219DF
+:03005400030E0791
+:03005500901020E8
+:03005600204360E4
+:0300570003036040
+:03005800901360A2
+:0300590020236001
+:03005A00030C1084
+:03005B00901038CA
+:03005C00C11219B5
+:03005D00190E0772
+:03005E00643120EA
+:03005F00A64C109C
+:03006000C221803A
+:03006100190E7005
+:03006200743743AD
+:03006300A86A7315
+:03006400C44C0287
+:03006500D801803F
+:03006600024E0740
+:03006700C006438D
+:03006800022A76F3
+:03006900209C03D5
+:03006A000301800F
+:03006B00901E07DD
+:03006C00204643E8
+:03006D00030A760D
+:03006E00901C04DF
+:03006F00202180CD
+:03007000030E0775
+:03007100901643A3
+:03007200210A76EA
+:03007300E03C016D
+:03007400743038AD
+:03007500C04A7509
+:03007600190C184A
+:030077007480385A
+:03007800A8621962
+:03007900C04E0F67
+:03007A00FFF03D57
+:03007B00150C0061
+:03007C00643038B5
+:03007D00A81C02BA
+:03007E002091804E
+:03007F0013EE0776
+:03008000A847434B
+:03008100209A863C
+:03008200FFFC3F41
+:0300830017E03152
+:0300840021EC1656
+:03008500035A9388
+:03008600C14C0367
+:03008700D801801D
+:03008800024E071E
+:03008900C007436A
+:03008A00022A8FB8
+:03008B00209CFFB7
+:03008C000300313D
+:03008D00901C18AC
+:03008E00204A9372
+:03008F00030C035C
+:030090009010319C
+:03009100202C120E
+:03009200030A93CB
+:0300930090103C8E
+:03009400210E0F2B
+:0300950002709D59
+:03009600C147035C
+:03009700024A9D7D
+:03009800209C0F9A
+:03009900030FFF53
+:03009A0090115C66
+:03009B0020411DE4
+:03009C00030A9EB6
+:03009D0090121CA2
+:03009E002070309F
+:03009F00030E0F3E
+:0300A00090103C81
+:0300A100C18C020D
+:0300A200D800394A
+:0300A300024C000C
+:0300A400C0003960
+:0300A500022C80AA
+:0300A60020902483
+:0300A700030C083F
+:0300A800901104B0
+:0300A900204039BB
+:0300AA00030C0044
+:0300AB0090103979
+:0300AC00202C0005
+:0300AD0003003A13
+:0300AE009010258A
+:0300AF0021003EEF
+:0300B00003B02B6F
+:0300B100707C035D
+:0300B200AB602C14
+:0300B300209C404E
+:0300B40013F0390D
+:0300B500ABE7D9DD
+:0300B600209AB5D8
+:0300B70015FC0035
+:0300B800643208A7
+:0300B900AE8030E6
+:0300BA0069B90120
+:0300BB00AE8C8088
+:0300BC0020920887
+:0300BD001BF03005
+:0300BE00C5090170
+:0300BF00039C405F
+:0300C000799039FB
+:0300C100AC06D9B1
+:0300C20020BAC69B
+:0300C300D006F96B
+:0300C400038BC9E2
+:0300C500219AC1BC
+:0300C600E079429C
+:0300C700348C0274
+:0300C80034818000
+:0300C900348E076B
+:0300CA0034874335
+:0300CB00030AE73E
+:0300CC0021AC065E
+:0300CD00348195E6
+:0300CE0034874331
+:0300CF00348AE789
+:0300D0003487D39F
+:0300D100D05AE71B
+:0300D200031C0606
+:0300D300C00187E2
+:0300D400032743BC
+:0300D500033AD813
+:0300D600C70C0351
+:0300D700039AE5A4
+:0300D800C50C074D
+:0300D90003918709
+:0300DA00C1874398
+:0300DB00030ADE37
+:0300DC00C00C0154
+:0300DD00031AE51E
+:0300DE0021BC033F
+:0300DF0003218773
+:0300E000C0074313
+:0300E100033AE4FB
+:0300E200C70C0048
+:0300E300039AE598
+:0300E400C502074B
+:0300E5000390275E
+:0300E600C40AF455
+:0300E700039C0671
+:0300E800369195B9
+:0300E900C01643FB
+:0300EA001FAAF456
+:0300EB0021CC0124
+:0300EC0009A1C7A0
+:0300ED0074309CD0
+:0300EE00A1E70384
+:0300EF0003AAF46D
+:0300F000C02CFF22
+:0300F100FFF022FB
+:0300F20016B0271E
+:0300F300C02B5CC3
+:0300F40023EC00FA
+:0300F5007436F36B
+:0300F60012BCFF3A
+:0300F70020B02115
+:0300F800038C0175
+:0300F900C44024DC
+:0300FA0003990A5D
+:0300FB00C406B385
+:0300FC00039B83E0
+:0300FD00C00C0133
+:0300FE0002302F9E
+:0300FF00ABF2154C
+:03010000B006D373
+:03010100000D806E
+:03010200000024D6
+:03010300000217E0
+:03010400000022D6
+:03010500000C06E5
+:0301060000019560
+:03010700000743AB
+:03010800000B4B9E
+:030109000006D31A
+:03010A00000B4B9C
+:03010B00000CE005
+:03010C0000015798
+:03010D00000643A6
+:03010E00000B4B98
+:03010F00000C00E1
+:030110000007B72E
+:03011100000C05DA
+:030112000007D70C
+:03011300000C10CD
+:030114000007F7EA
+:03011500000C02D9
+:03011600000027BF
+:03011700000C10C9
+:03011800000D02D5
+:03011900000FFFD5
+:03011A000001429F
+:03011B0000069744
+:03011C00000D02D1
+:03011D00000637A2
+:03011E00000D10C1
+:03011F00000022BB
+:03012000000C8050
+:03012100000124B6
+:03012200000C02CC
+:0301230000018058
+:03012400000E07C3
+:030125000007438D
+:03012600000B3992
+:03012700000C05C4
+:030128000001478C
+:030129000006438A
+:03012A00000B398E
+:03012B00000C01C4
+:03012C000001814E
+:03012D0000074385
+:03012E00000B3291
+:03012F00000C10B1
+:03013000000021AB
+:03013100000B3987
+:03013200000C10AE
+:0301330000018147
+:030134000007437E
+:03013500000B3983
+:03013600000C209A
+:03013700000021A4
+:03013800000B3980
+:03013900000201C0
+:03013A0000003092
+:03013B00000901B7
+:03013C00000204BA
+:03013D000000308F
+:03013E00000901B4
+:03013F00000202B9
 :030140000000308C
 :03014100000901B1
-:03014200000204B4
-:0301430000003089
-:03014400000901AE
-:03014500000202B3
-:0301460000003086
-:03014700000901AB
-:03014800000C8028
-:03014900000FFFA5
-:03014A000001644D
-:03014B00000207A8
-:03014C000001624D
-:03014D00000FFFA1
-:03014E000001505D
-:03014F00000D0898
-:0301500000012289
-:03015100000201A8
+:03014200000C802E
+:03014300000FFFAB
+:0301440000016453
+:03014500000207AE
+:0301460000016253
+:03014700000FFFA7
+:0301480000015063
+:03014900000D089E
+:03014A000001228F
+:03014B00000201AE
+:03014C0000003080
+:03014D00000901A5
+:03014E00000204A8
+:03014F000000307D
+:03015000000901A2
+:03015100000202A7
 :030152000000307A
 :030153000009019F
-:03015400000204A2
-:0301550000003077
-:030156000009019C
-:03015700000202A1
-:0301580000003074
-:0301590000090199
-:03015A00000C0096
-:03015B0000002F72
-:03015C000007D3C6
-:03015D00000B8410
-:03015E000002108C
-:03015F000000227B
-:0301600000020E8C
-:0301610000002774
-:03016200000C503E
-:0301630000003960
-:03016400000799F8
-:03016500000B6428
-:0301660000021282
-:0301670000003065
-:030168000002147E
-:0301690000003162
-:03016A000002137D
-:03016B000006B3D8
-:03016C00000D1073
-:03016D000000325D
-:03016E00000C0082
-:03016F000000335A
-:03017000000C7010
-:0301710000003952
-:03017200000C502E
-:0301730000003950
-:0301740000021571
-:0301750000003057
-:030176000002166E
-:0301770000003154
-:0301780000020280
-:0301790000003251
-:03017A00000C0076
-:03017B000006B3C8
-:03017C0000020777
-:03017D000000334C
-:03017E00000C7002
+:03015400000C009C
+:0301550000002F78
+:030156000007D3CC
+:03015700000B7E1C
+:0301580000021092
+:0301590000002281
+:03015A0000020E92
+:03015B000000277A
+:03015C00000C5044
+:03015D0000003966
+:03015E00000799FE
+:03015F00000B5E34
+:0301600000021288
+:030161000000306B
+:0301620000021484
+:0301630000003168
+:0301640000021383
+:030165000006B3DE
+:03016600000D1079
+:0301670000003263
+:03016800000C0088
+:0301690000003360
+:03016A00000C7016
+:03016B0000003958
+:03016C00000C5034
+:03016D0000003956
+:03016E0000021577
+:03016F000000305D
+:0301700000021674
+:030171000000315A
+:0301720000020286
+:0301730000003257
+:03017400000C007C
+:030175000006B3CE
+:030176000002077D
+:0301770000003352
+:03017800000C7008
+:030179000000394A
+:03017A00000C5026
+:03017B0000003948
+:03017C00000C4034
+:03017D0000003946
+:03017E00000C0072
 :03017F0000003944
-:03018000000C5020
-:0301810000003942
-:03018200000C402E
-:0301830000003940
-:03018400000C006C
-:030185000000393E
-:03018600000C006A
+:03018000000C0070
+:03018100000C006F
+:03018200000ABFB1
+:03018300000C026B
+:0301840000002F49
+:03018500000C0A61
+:0301860000002A4C
 :03018700000C0069
-:03018800000ABEAC
-:03018900000C0265
-:03018A0000002F43
-:03018B00000C0A5B
-:03018C0000002A46
-:03018D00000C0063
-:03018E000000244A
-:03018F000007D393
-:03019000000BACB5
-:0301910000020168
+:0301880000002450
+:030189000007D399
+:03018A00000BA6C1
+:03018B000002016E
+:03018C0000003040
+:03018D0000090165
+:03018E0000021557
+:03018F000000303D
+:0301900000090162
+:0301910000021653
 :030192000000303A
 :030193000009015F
-:0301940000021551
-:0301950000003037
-:030196000009015C
-:030197000002164D
+:03019400000C1F3D
+:03019500000D80DA
+:0301960000002244
+:0301970000020162
 :0301980000003034
 :0301990000090159
-:03019A00000C1F37
-:03019B00000D80D4
-:03019C000000223E
-:03019D000002015C
+:03019A000002025E
+:03019B0000003031
+:03019C0000090156
+:03019D0000020459
 :03019E000000302E
 :03019F0000090153
-:0301A00000020258
-:0301A1000000302B
-:0301A20000090150
-:0301A30000020453
-:0301A40000003028
-:0301A5000009014D
-:0301A6000002EA6A
-:0301A7000007103E
-:0301A800000BAA9F
-:0301A900000B9DAB
-:0301AA000007D378
-:0301AB00000BCA7C
-:0301AC00000C1D27
-:0301AD000006D376
-:0301AE00000D80C1
-:0301AF000000222B
-:0301B00000020149
+:0301A0000002EA70
+:0301A10000071044
+:0301A200000BA4AB
+:0301A300000B97B7
+:0301A4000007D37E
+:0301A500000BC488
+:0301A600000C1D2D
+:0301A7000006D37C
+:0301A800000D80C7
+:0301A90000002231
+:0301AA000002014F
+:0301AB0000003021
+:0301AC0000090146
+:0301AD000002024B
+:0301AE000000301E
+:0301AF0000090143
+:0301B00000021832
 :0301B1000000301B
 :0301B20000090140
-:0301B30000020245
-:0301B40000003018
-:0301B5000009013D
-:0301B6000002182C
-:0301B70000003015
-:0301B8000009013A
-:0301B90000021031
-:0301BA0000002E14
-:0301BB00000C1C19
-:0301BC000006D367
-:0301BD00000D80B2
-:0301BE000000221C
-:0301BF000002013A
+:0301B30000021037
+:0301B40000002E1A
+:0301B500000C1C1F
+:0301B6000006D36D
+:0301B700000D80B8
+:0301B80000002222
+:0301B90000020140
+:0301BA0000003012
+:0301BB0000090137
+:0301BC000002023C
+:0301BD000000300F
+:0301BE0000090134
+:0301BF0000021724
 :0301C0000000300C
 :0301C10000090131
-:0301C20000020236
-:0301C30000003009
-:0301C4000009012E
-:0301C5000002171E
-:0301C60000003006
-:0301C7000009012B
-:0301C8000007D35A
-:0301C900000B9197
-:0301CA00000C0026
-:0301CB0000002F02
-:0301CC000007D356
-:0301CD00000B84A0
-:0301CE00000B5EC5
-:0301CF00000C071A
-:0301D00000002FFD
-:0301D100000C041B
-:0301D20000002109
-:0301D300000C001D
-:0301D40000091E01
+:0301C2000007D360
+:0301C300000B8BA3
+:0301C400000C002C
+:0301C50000002F08
+:0301C6000007D35C
+:0301C700000B7EAC
+:0301C800000B58D1
+:0301C900000C0720
+:0301CA0000002F03
+:0301CB00000C0421
+:0301CC000000210F
+:0301CD00000C0023
+:0301CE0000091E07
+:0301CF00000C1011
+:0301D0000000210B
+:0301D100000C0817
+:0301D20000091E03
+:0301D300000C40DD
+:0301D40000002107
 :0301D500000C100B
-:0301D60000002105
-:0301D700000C0811
-:0301D80000091EFD
-:0301D900000C40D7
-:0301DA0000002101
-:0301DB00000C1005
-:0301DC0000091EF9
-:0301DD00000C0013
-:0301DE00000026F8
-:0301DF00000C0110
-:0301E000000029F3
-:0301E100000C000F
-:0301E20000002FEB
-:0301E300000C20ED
-:0301E400000023F5
-:0301E500000A000D
-:0301E600000ABE4E
-:0301E700000BE723
+:0301D60000091EFF
+:0301D700000C0019
+:0301D80000003AEA
+:0301D900000C0116
+:0301DA00000029F9
+:0301DB00000C0015
+:0301DC0000002FF1
+:0301DD00000C20F3
+:0301DE00000023FB
+:0301DF00000A0013
+:0301E000000ABF53
+:0301E100000BE12F
 :00000001FF
--- a/drivers/dahdi/xpp/firmwares/PIC_TYPE_2.hex
+++ b/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
--- a/drivers/dahdi/xpp/firmwares/USB_FW.201.hex
+++ b/drivers/dahdi/xpp/firmwares/USB_FW.201.hex
@@ -0,0 +1,578 @@
+#
+# $Id: USB_FW.201.hex 10402 2012-02-15 15:34:50Z dima $
+#
+:03004300021F0099
+:03005300021F0089
+:101F0000021E3100021E8E00021E7800021E4900D1
+:081F1000021C2000021BA900C5
+:101000001201000200000040AAAAAAAAAAAA01028C
+:1010100003010A0600020000004001000902370037
+:10102000020100C0000904000002FFFFFF040705E1
+:101030000202000200070586020002000904010006
+:1010400002FFFFFF050705040200020007058802F2
+:10105000000200001201000200000040E4E451110F
+:101060000000010203010A06000200000040010026
+:1010700009023700020100C0320904000002FFFF2C
+:10108000FF04070502024000000705860240000039
+:101090000904010002FFFFFF0507050402400000EC
+:1010A0000705880240000006040016001400120024
+:1010B0000A00260004030904160358006F0072009A
+:1010C00063006F006D0020004C00540044001403C6
+:1010D00041007300740072006900620061006E00DC
+:1010E0006B001203530065007200690061006C0020
+:1010F0004E006F000A0346005000470041002603DF
+:101100004D0061006E00610067006D0065006E00BB
+:101110007400500072006F0063006500730073007C
+:061120006F0072000000E8
+:050FF6000300000000F3
+:100F3C0041E0370041E0B60042E0B1000041E0384A
+:100F4C0000021BE0850218E07943E0B30000004D7D
+:0F0F5C00E03931303339354D202020202020005E
+:101D71008B538A548955E5581558AE57700215573B
+:101D81004E6014AB530555E555AA54700205541421
+:081D9100F9ED12077780DF2253
+:101BE6008B538A548955E55A155AAE5970021559C0
+:101BF6004E6026AB560558E558AA5770020557148D
+:101C0600F9120731FFAB530555E555AA5470020585
+:0A1C16005414F9EF12077780CD2275
+:101DC100D2B7E490E670F0F5B575B5E653B5E743E3
+:101DD100B28853B2FCC2B3D2B1C2B2C2B67F32FE34
+:061DE100121E07D2B6221B
+:101E6100538EF75389FB5389F74389015389FDE465
+:071E7100F58AF58CD2A922CD
+:1018B2008C448D45AA06A9077556018A5789587521
+:1018C2005900755A1C7B017AE0794C121BE690E0B4
+:1018D20064E0FCA3E0FDA3E0FEA3E064D1FFEE64BC
+:1018E2008DFEED644CFDEC6449FC90E064120853FB
+:1018F2007EE07F4C7D1C7C001213707EE07F4C7B6F
+:101902001C7A00AD45AC441214247D1C7C00AF450A
+:10191200AE441211F57D1C7C00AF45AE44021C564C
+:08183F008E448F458C468D4755
+:10184700C20712001290E15BEFF0BF5004D207808D
+:1018570057E490E15CF0A3F090E15CE0FEA3E0FFC9
+:10186700C39410EE648094805030E5472FF582E5ED
+:10187700463EF583E0FF90E15CE0FCA3E02545F5FB
+:1018870082E5443CF583E0B5071090E15DE004F0A4
+:1018970070C690E15CE004F080BE90E15CE070040B
+:0A18A700A3E064107002D207A2074C
+:0118B1002214
+:020E12008F410E
+:100E14001200128F42E4F546F547AD47AC46121472
+:100E2400DA74692547F582E434E0F583E543F00597
+:100E340047E54770020546C39408E54664809480FC
+:100E440040D8E541600490E069F090E069E0B4C006
+:100E540008754400754508800675441D754536754A
+:100E64004600754708C3E5479410E54664809480BE
+:100E740050231214D674692547F582E434E0F583CF
+:100E8400E543F00547E547700205460545E545702D
+:100E9400D4054480D07543FF75441D7545197546C6
+:100EA40000754710C3E547942CE546648094805050
+:100EB40033E542B4510E7B007A007943AD45AC442E
+:100EC400FF1214E274692547F582E434E0F583E502
+:100ED40043F00547E547700205460545E54570C4FE
+:100EE400054480C075441D75453EE4F543F546F55B
+:100EF40047C3E5479406E54664809480502FE54255
+:100F0400B4510A90E069E0B4C2031214D6744625C1
+:100F140047F582E434E0F583E543F00547E547709F
+:100F24000205460545E54570C8054480C490E0695E
+:070F3400E0B4C20374C0F039
+:010F3B002293
+:0A1988008E448F458B468A4789483C
+:101992007E00E5452DF54DEE3544F54C1200128FD3
+:1019A20049E5496451600BC3E5459410E544940050
+:1019B200503585444A85454BC3E54B954DE54A95DF
+:1019C2004C5024AB46AA47A948AD4BAC4AAF49128A
+:1019D2001740054BE54B7002054A74012548F5484E
+:0719E200E43547F54780D111
+:0119E90022DB
+:0617C7008B418A428943B8
+:1017CD00D2067556017557E0755869755900755AE9
+:1017DD00107B017AE07995121BE6E5432410F9E4BC
+:1017ED003542854156F5578958755900755A0C7B08
+:1017FD00017AE079A5121BE67EE07F957CE07D1AEB
+:10180D001218B27EE07F1AE543241CF9E43542FC40
+:10181D00AD0112183F5016AB41E5432410F9E435E4
+:10182D0042FA7D1C7F197E1D1219888002C206A204
+:01183D0006A4
+:01183E002287
+:101126007F03121D46EF2402FFE43EA90775410125
+:10113600F542894390E06AE0FFE50C2408F582E475
+:10114600350BF583EFF090E06BE0FFE50C2409F535
+:1011560082E4350BF583EFF090E06CE0FFE50C24BC
+:101166000AF582E4350BF583EFF090E06DE0FFE5DC
+:101176000C240BF582E4350BF583EFF090E06EE07E
+:10118600FFE50C240CF582E4350BF583EFF090E0D7
+:101196006FE0FFE50C240DF582E4350BF583EFF0E7
+:1011A6007F087E00E4FDEDC39408502874692FF58E
+:1011B60082E434E0F583E0FCAB41AA42A94375F032
+:1011C60002EDA4F58285F083EC1207890D0FBF00AE
+:1011D600010E80D2E5192404F582E43518F583E082
+:0E11E60030E0047F0180027F0090E037EFF0E0
+:0111F40022D8
+:101B250090E06CE02FFFE50C240AF582E4350BF517
+:101B350083EFF0E50C240BF582E4350BF583E0FE2D
+:101B4500E50C240AF582E4350BF583E0FDEDFF9005
+:101B5500E0B1EEF0A3EFF0D206121CBD90E680E0F6
+:041B650054F7F0221F
+:1016200090E600E054E74410F090E60174C0F090BA
+:10163000E6107420F000000090E611F00000009029
+:10164000E6047480F0000000740FF0000000E4F085
+:1016500000000090E6187410F0000000E490E61915
+:10166000F000000090E61A7408F0000000E490E634
+:101670001BF000000090E6497482F0000000F000CA
+:10168000000090E6247402F0000000E490E625F0EB
+:1016900000000090E6957480F0000000F00000006B
+:1016A00043AF017B017AE07914755700755806E461
+:0416B000FD021D71A9
+:061E0100D2837F0A7E007F
+:101E07007C007D181207ABEF1FAC0670011E4C70EB
+:021E1700F622B1
+:0A1A43008E418F428B438A4489458F
+:101A4D00E4F546F547C3E5479542E54695415036E1
+:101A5D00AB43AA44A94585478285468312074AFFB1
+:101A6D00E4FBFAC2B2EF1392B1EFC313FFD2B20B84
+:101A7D00BB00010AEB64084A70E9C2B20547E547AD
+:071A8D0070C3054680BFD3C2
+:011A9400222F
+:101E190090E60174C0F0C2B67FC27E01121E07D2DD
+:081E2900B67F327E00021E07A5
+:101EA400D287121E01C287121E03C2837F0A7E00DC
+:031EB400021E0704
+:021B6900AB07C8
+:101B6B00E4F9FAEBC413131354011392877F027E2B
+:101B7B0000121E07D2837F057E00121E07E925E0A7
+:101B8B00FFA2B3E4334FF97F057E00121E07EB254E
+:0D1B9B00E0FBC283121E030ABA08C8AF01A6
+:011BA800221A
+:061A95008B558A568957AB
+:101A9B00A2AFE433F55D121EA4E4F55CE55CC395DF
+:101AAB005B5027AB55AA56A957855C8275830012EC
+:101ABB00074AFF121B69AB58AA59A95A855C827554
+:101ACB008300EF120789055C80D2120036E55D2496
+:031ADB00FF92AFC8
+:011ADE0022E5
+:0B003600C287121E03121E01D2872297
+:101DE70075418F8F42755800755900755A4B755B51
+:0A1DF700027B007A007941021A9580
+:101C8C0078417C007D007BFF7A0F79F67E007F0522
+:101C9C0012070B30B415755800755900755A4175FB
+:101CAC005B057B007A007941121A95E5435401FFDC
+:011CBC002205
+:100B4E007541007542007543007545017546E075A7
+:100B5E0047007548017549E0754A08E4F551FFF5FF
+:100B6E00527B017AE07900F557755808FD121D7118
+:100B7E00AB45AA46A9477401120777E4F550E55034
+:100B8E00C454F0AB45AA46A94790000112078985C7
+:100B9E004858854959854A5A755B08121A95AB48CB
+:100BAE00AA49A94A90000212074AFE5403FFEE54C6
+:100BBE0070F55124E0602924F0604B24F0605D2430
+:100BCE00F0606F24406003020C5675410185184297
+:100BDE00851943EF24FE600624FE703B801C801FA7
+:100BEE00E5192401FDE43518A905754101F5428981
+:100BFE0043EF24FC60092402700A7552028052757C
+:100C0E005206804D8011E5192402FDE43518A90520
+:100C1E00754101F54289437552088035E519240363
+:100C2E00FDE43518A905754101F542894375520455
+:100C3E00801FE5192405FDE43518A905754101F558
+:100C4E00428943755298800975410075420075437B
+:100C5E0000E542454345416022AB41AA42A94312F9
+:100C6E000731FED395524006AD52AE0580008E443C
+:100C7E00120731C39544120777800CE55170047E3C
+:100C8E000180027E008E44744B2550F8A644055018
+:100C9E00E550C394055003020B8CAB45AA46A947F9
+:100CAE007488120777AB45E5472401F9E43546FA17
+:100CBE0075560075570075584B755900755A0512C3
+:100CCE001BE6854858854959854A5A755B08AB45D8
+:070CDE00AA46A947021A957E
+:1019EA008F4190E0B1E0FEA3E054F064607003EE32
+:1019FA00641160037F012290E037E070037F0F22B9
+:101A0A00E5417003308108E541B401062080037F77
+:101A1A00102290E0B6E0B541037F0122E4F511D22D
+:101A2A0006121CBDAF4190E0B6EFF024FF92B590CC
+:091A3A00E680E054F7F07F002281
+:04000E0090FC04F06E
+:1000120090E678E0541824F06008240870087F50B5
+:0800220080067F518002E4FF1B
+:01002A0022B3
+:0C14D600AD45AC447B007A007943AF4286
+:0C14E2008F488C498D4A8B4B8A4C894DF9
+:1014EE00E4F54EF54F755003FDF551F552A2AF33AD
+:1014FE00F553E54824AF600D047012754E00754F1C
+:10150E00017D018008754E00754F02E4FDE54860CF
+:10151E0051E54F454E604BE54990E0B3F0E54AA3E7
+:10152E00F074B32DF582E434E0AD82FCAB4FAF48DE
+:10153E001219227551008F527F0A7E00121ADFE5B2
+:10154E0052455160107CE07D687B01AF4812157BDF
+:10155E007551008F5290E068E0AB4BAA4CA94D122A
+:0C156E000777E55324FF92AFAE51AF5257
+:01157A00224E
+:0C1740008F4E8C4F8D508B518A52895374
+:10174C00E4F554F555755603FDF557F558A2AF332E
+:10175C00F559E54E24AF600D0470127554007555A3
+:10176C00027D018008755400755503E4FDE54E605B
+:10177C003FE55545546039E54F90E0B3F0E550A393
+:10178C00F0AB51AA52A95312073190E0B5F0C2B791
+:10179C0074B32DF582E434E0AD82FCAB55AF4E1240
+:1017AC0019227557008F587F0A7E00121ADFD2B7A4
+:0A17BC00E55924FF92AFAE57AF5875
+:0117C6002200
+:10005600E4F531F532F535F53CF53DF53EF53FE590
+:10006600AA5484600302063A90E694E0FE90E69570
+:10007600E0FBEEF53CEBF53DC39405E53C94004012
+:100086000790F404E0FD80027DFFED12085F00CECC
+:100096000102C30503080703580903D80B011E0E06
+:1000A60000E40F019411025E130541250401310499
+:1000B6005732046A3404B23504C93604E63703E518
+:1000C6004503F647000005BA75310075320790FC06
+:1000D600047481F0A37414F0E4A3F00205DD7F0F2D
+:1000E600121DE775310075320690FC047480F0E449
+:1000F600A3F0753505F511FE74002535F9EE34F4D7
+:10010600FA7B011217C7400690FC05740EF0E4FF57
+:10011600120E127F8F0202BD7F0E121DE77531008F
+:10012600753205748E12000E8F3F7B007A0079407F
+:10013600E4FDFC1214E2E53F64516019E53F6450AA
+:10014600601375310075320690FC047480F0A37458
+:100156000BF00205DD90E0B7E0FF120E12740025E9
+:1001660032F974FC3531FA7B01C0038B567557E0C2
+:10017600755869755900755A2CD003121BE6742CF4
+:100186002532F532E43531F5317F8E0202BD753107
+:100196000075320790FC047491F090E678E090FCCC
+:1001A60005F030B3047F0280027F0030B4047E0184
+:1001B60080027E00EE4F90FC06F074002532F97442
+:1001C600FC3531FA7B01755700755812E4FD121D96
+:1001D6007174002532F974FC3531FA7B01C0038B4A
+:1001E600567557E0755839755900755A06D0031279
+:1001F6001BE674062532F532E43531F531FE74001E
+:100206002532F974FC3EFA7B01C0038B567557E024
+:10021600755814755900755A06D003121BE67406F4
+:100226002532F532E43531F531FE74002532F974A4
+:10023600FC3EFA7B01C0038B567557E07558467530
+:100246005900755A06D003121BE674062532F5329C
+:10025600E43531F5310205DD7F13121DE7753100F6
+:1002660075321D749312000E8F3F75381D75390057
+:10027600753600753705D3E5399418E538941D5061
+:1002860034E53FB4510E7B007A007940AD39AC3885
+:10029600FF1214E274002537F58274FC3536F583B7
+:1002A600E540F00539E539700205380537E5377060
+:1002B600C5053680C17F93121DE70205DD75310045
+:1002C60075320690FC047480F0E4A3F090F405E027
+:1002D60090E038F0E0147071121E1930B31B755699
+:1002E600017557F4755806755900755A067B017ADB
+:1002F600E07914121BE60205DD90FC057401F0029C
+:1003060003D075310075320690FC047480F0E4A3C6
+:10031600F0753507AF35FEC3E53D9FF534E53C9EE8
+:10032600F53390E038E014702074002FF974F43E31
+:10033600FA7B01AF34AE33121A435004E40204C20E
+:1003460090FC05740CF00205DD90FC057403F002C8
+:1003560005DD75310075320690FC047480F0E4A367
+:10036600F090E038E014705CE4FFFE20B411C2B2F5
+:10037600D2B1D2B20FBF00010EEF640A4E70EC305C
+:10038600B43A90E6017403F07F647E00121E079073
+:10039600E0B7E0FF120E127EE07F697CE07DB812C6
+:1003A60018B27EE07FB8AD1CAC1B12183F50051288
+:1003B6000B4E801690FC05740EF0800E90FC0574B2
+:1003C6000DF0800690FC057403F0E490E038F0022E
+:1003D60005DDE4F531F5327F02121B250205DDE469
+:1003E600FF120E12121126E4FF1219EAE4FF800230
+:1003F6007F01121B25121E190205DD7531007532AB
+:100406000690FC047480F0E4A3F090F405E0F53E59
+:10041600E4F511E53E64016004E53E703290E0B11A
+:10042600E0FEA3E054F064607003EE6411600280A5
+:100436007290E037E070028058E5116401600AE5C9
+:1004460011700C121C8CEF6006853E110205DD80D2
+:100456005275310075320690FC0474B2F0A3E511B2
+:10046600F00205DD75310075320690FC047480F0EB
+:10047600E4A3F090F405E0F53EFF1219EAEF24F14B
+:10048600600F1460152410701AE4F531F532020578
+:10049600DD90FC05740FF00205DD90FC057410F08C
+:1004A6000205DD90FC057401F00205DD753100756D
+:1004B600320690FC0474B5F090E0B6E090FC05F0CE
+:1004C6000205DD75310075320690FC0474B6F0A2A3
+:1004D60080E43325E0FFA281E4334FA3F00205DD7B
+:1004E600853C31853D3290FC0474B7F0753505C303
+:1004F600E53D9535F534E53C9400F5337400253536
+:10050600F582E434F4F583E0648870030205DDAF18
+:10051600357E0074002FF9EE34F4FA7B01C003C077
+:100526000174002FF9EE34FC8B58F559895A85343D
+:100536005BD001D003121A950205DD7531007532C4
+:100546000590FC0474A5F01200128F3F7B007A0020
+:100556007940E4FDFC1214E290E036E0FF0532E556
+:1005660032AC3170020531142400F58274FC3CF57E
+:1005760083EFF090E0B7E0FF0532E532AC31700270
+:100586000531142400F58274FC3CF583EFF0053246
+:10059600E532AE3170020531142400F58274FC3E5A
+:1005A600F583E540F090E6017403F07F647E001267
+:1005B6001E07802375310075320690FC047480F0A6
+:1005C600C3E53D9405E53C94005006A37407F0800E
+:1005D6000690FC057406F090F404E0B48004A3E0F1
+:1005E600701290F404E06405600FE06407600AE0AE
+:1005F60064096005E490E038F0E5324531602CE5A9
+:1006060032FD90FC00F0E531FFA3F090F402E0909B
+:10061600FC02F090F403E090FC03F090E69CEFF00F
+:1006260000000090E69DEDF000000090E6957480D5
+:04063600F0000000D0
+:01063A00229D
+:02004100D322C8
+:0800030090E6BAE0F51DD322DE
+:101ECA0090E740E51DF0E490E68AF090E68B04F096
+:021EDA00D32211
+:08002B0090E6BAE0F51AD322B9
+:101EDC0090E740E51AF0E490E68AF090E68B04F087
+:021EEC00D322FF
+:101D990090E6B9E0242F600D04701990E604E0FF85
+:101DA900430780800890E604E0FF53077F000000A6
+:071DB900EFF08002D322C30A
+:011DC0002200
+:101E3100C0E0C083C082D2015391EF90E65D74018E
+:081E4100F0D082D083D0E03222
+:101E7800C0E0C083C0825391EF90E65D7404F0D057
+:061E880082D083D0E0329D
+:101E8E00C0E0C083C0825391EF90E65D7402F0D043
+:061E9E0082D083D0E03287
+:101C2000C0E0C083C08285120D85130E850E8285AB
+:101C30000D83A37402F085090F850A108510828533
+:101C40000F83A37407F05391EF90E65D7410F0D00A
+:061C500082D083D0E032D7
+:101E4900C0E0C083C082D2035391EF90E65D74086D
+:081E5900F0D082D083D0E0320A
+:101BA900C0E0C083C08290E680E030E72085090D5F
+:101BB900850A0E850E82850D83A37402F085120FA6
+:101BC900851310851082850F83A37407F05391EF55
+:0D1BD90090E65D7420F0D082D083D0E03221
+:101EB700000102020303040405050300000000C03B
+:031EC700C2000056
+:060F6B0001110001080065
+:03000B000212BC22
+:1012BC00C0E0C0F0C083C082C0D075D000C000C0F8
+:0D12CC0001C002C003C004C005C006C00779
+:1012D90078217C007D007BFF7A1E79C17E007F0525
+:1012E90012070B90E0B6E0F526C204752700E50861
+:1012F900600415088056750805E5117004C204805C
+:1013090043A280308101B3500B3081047F008030CB
+:101319007F01802C30B415755800755900755A2114
+:10132900755B057B007A007921121A95E523540132
+:10133900F527701090E0B6E060047F0080027F011D
+:0C1349008F26D204300405AF261219EAEA
+:10135500D007D006D005D004D003D002D001D000EC
+:0B136500D0D0D082D083D0F0D0E03296
+:100CE50078567CE17D017BFF7A1E79C67E007F0404
+:100CF50012070BC203C200D202C201121DC1121E8D
+:100D050061121620750B10750C00751410751512EF
+:100D1500750910750A1C75121075137085120F85EB
+:100D250013107516107517B412001290E154EFF0F8
+:100D35007B017AE17955E4FDFC1214E290E155E07E
+:100D4500FF90E036F0E490E0B7F0EF64C26059EF51
+:100D550064C06054E490E15AF090E15AE0FFC39416
+:100D650004504A74562FF582E434E1F583E0FF60C0
+:100D75003C120E127EE07F697CE07DB81218B27ECF
+:100D8500E07FB8AD1CAC1B12183F501490E15AE03F
+:100D95002456F582E434E1F583E090E0B7F0800D68
+:100DA50090E15AE004F080B1E4FF120E1212112610
+:100DB500D2E843D82090E668E04409F090E65CE08C
+:100DC500443DF012001290E154EFF07B017AE17995
+:100DD50055E4FDFC1214E290E155E064C26007E4BD
+:100DE50090E0B6F0C2B57F01121B25D2AFD28C536D
+:100DF5008EF8C203C2AF120056D2AF3001051209F8
+:0D0E050026C2013003EEC203121D1A80E761
+:0B00460090E50DE030E402C322D3225D
+:1009260090E6B9E070030209EB147003020A602432
+:10093600FE7003020ADB24FB70030209E514700350
+:100946000209DF1470030209D31470030209D924C3
+:10095600056003020B3A1200414003020B4690E683
+:10096600BBE024FE602714603E24FD60111460275E
+:1009760024067056E50B90E6B3F0E50C80421200B3
+:10098600465044E51490E6B3F0E5158033E50D9046
+:10099600E6B3F0E50E802985120F851310E50F905A
+:1009A600E6B3F0E510801990E6BAE0FF121D46AAFC
+:1009B60006A9077B01EA494B600DEE90E6B3F0EF1E
+:1009C60090E6B4F0020B46020B35020B35121EDC24
+:1009D600020B4612002B020B46120003020B4612B4
+:1009E6001ECA020B4690E6B8E0247F601514601913
+:1009F60024027063A200E43325E0FFA202E4334F31
+:100A06008041E490E740F0803F90E6BCE0547EFFF2
+:100A16007E00E0D394807C0040047D0180027D004E
+:100A2600EC4EFEED4F24B7F582741E3EF583E4933B
+:100A3600FF3395E0FEEF24A1FFEE34E68F82F583C7
+:100A4600E0540190E740F0E4A3F090E68AF090E6E7
+:100A56008B7402F0020B46020B3590E6B8E024FEDA
+:100A6600601624026003020B4690E6BAE0B4010564
+:100A7600C200020B46020B3590E6BAE0705590E6CE
+:100A8600BCE0547EFF7E00E0D394807C0040047D71
+:100A96000180027D00EC4EFEED4F24B7F582741EF8
+:100AA6003EF583E493FF3395E0FEEF24A1FFEE3499
+:100AB600E68F82F583E054FEF090E6BCE0548013A6
+:100AC6001313541FFFE0540F2F90E683F0E04420E9
+:100AD600F0806D805A90E6B8E024FE60192402701A
+:100AE6004E90E6BAE0B40104D200805490E6BAE033
+:100AF6006402604C803990E6BCE0547EFF7E00E0E4
+:100B0600D394807C0040047D0180027D00EC4EFE83
+:100B1600ED4F24B7F582741E3EF583E493FF3395BB
+:100B2600E0FEEF24A1FFEE34E68F82F583800D9080
+:100B3600E6A08008121D99500790E6A0E04401F057
+:070B460090E6A0E04480F0FE
+:010B4D002285
+:03003300020FFBBE
+:040FFB0053D8EF32A6
+:100F71006080E0D4292E43C9A2D87C013D3654A11A
+:100F8100ECF0061362A705F3C0C7738C98932BD9B5
+:100F9100BC4C82CA1E9B573CFDD4E01667426F18B9
+:100FA1008A17E512BE4EC4D6DA9EDE49A0FBF58E45
+:100FB100BB2FEE7AA968799115B2073F94C21089C7
+:100FC1000B225F21807F5D9A5A903227353ECCE714
+:100FD100BFF79703FF1930B348A5B5D1D75E922A61
+:100FE100AC56AAC64FB838D296A47DB676FC6BE251
+:040FF1009C7404F1F7
+:081370008C468D47AB07AA066D
+:10137800E4F548F549C3E5499547E5466480F8E54D
+:1013880048648098400302141FE54925E0FFE548BA
+:1013980033FE74D42FF58274E03EF583E0FF7E00BF
+:1013A800AC46AD471207BD8C4A8D4BE54925E0FF99
+:1013B800E54833FE74D52FF58274E03EF583E0FFEF
+:1013C8007E00AC46AD471207BD8C4C8D4DE54B6594
+:1013D8004D7004E54A654C6030EB254BF582EA35E3
+:1013E8004AF583E0F9EB254DF582EA354CF583E0C3
+:1013F800FFEB254BF582EA354AF583EFF0EB254DF7
+:10140800F582EA354CF583E9F00549E549600302C0
+:0B141800137D054802137D7E007F015C
+:0114230022A6
+:0C1424008E468F478C488D498A4A8B4BBE
+:10143000E54745466006E54945487004E4FEFF225D
+:10144000E4F54CF54DC3E54D954BE54A6480F8E570
+:101450004C648098507BE4F54EF54FE549254DF5F9
+:1014600082E548354CF583E4F0C3E54F954BE54AFA
+:101470006480F8E54E6480985049E54F254D24D4AA
+:10148000F582E434E0F583E0FFE547254FF582E59A
+:1014900046354EF583E0FEEF8EF0A4FFE549254D7D
+:1014A000F582E548354CF583E02FFFE549254DF5FC
+:1014B00082E548354CF583EFF0054FE54F70AA05FE
+:1014C0004E80A6054DE54D6003021445054C0214FF
+:0514D000457E007F01D4
+:0114D50022F4
+:101CEC00120731FF90000312074A12077790000386
+:101CFC00EF12078990000212074AFF9000011207A9
+:0E1D0C004A900002120789900001EF02078939
+:0811F5008E468F478C488D499E
+:1011FD00E4F54AF54BE549AE487802CEA2E713CEA9
+:10120D0013D8F8FFC3E54B9FEE6480F8E54A648080
+:10121D009840030212B7E54BAE4A7802C333CE3382
+:10122D00CED8F92547FFEE3546FAA9077B018B4C41
+:10123D00F54D894E74D5254BF582E434E0F583E008
+:10124D00541FFFE48F52F551F550F54F121CECABC6
+:10125D004CAA4DA94E120819C374209552F9F812D3
+:10126D000806C004C005C006C007A94E120819A97A
+:10127D0052A8011207F3D003D002D001D000EF4BDA
+:10128D00FFEE4AFEED49FDEC48FCAB4CAA4DA94ED4
+:10129D00120839AB4CAA4DA94E121CEC054BE54B6F
+:0E12AD006003021202054A0212027E007F0157
+:0112BB002210
+:101C5600D3ED9410EC64809480402AED1D70011C35
+:101C6600142FF582EE3CF583E0FB547F24D4F582F5
+:101C7600E434E0F583E0F9540F2FF582E43EF58372
+:051C8600E06BF080CBD3
+:011C8B002236
+:101D1A0090E682E030E004E020E60B90E682E030D4
+:101D2A00E119E030E71590E680E04401F07F147E87
+:0C1D3A0000121ADF90E680E054FEF02258
+:101CBD0030060990E680E0440AF0800790E680E067
+:101CCD004408F07FDC7E05121ADF90E65D74FFF0AC
+:0F1CDD0090E65FF05391EF90E680E054F7F0222D
+:101ADF008E5A8F5B90E600E054187012E55B24017C
+:101AEF00FFE4355AC313F55AEF13F55B801590E6F3
+:101AFF0000E05418FFBF100BE55B25E0F55BE55ADE
+:101B0F0033F55AE55B155BAE5A7002155A4E6005F8
+:061B1F00121EEE80EE2212
+:06157B008C548D55AE07F3
+:10158100EB70037F012290E678E020E6F990E6789F
+:101591007480F0EE25E0440190E679F090E678E081
+:1015A10030E0F990E678E020E26BE030E167BB01E2
+:1015B1000790E678E04420F090E679E0F5561BEBE1
+:1015C100603090E678E030E0F990E678E020E2459E
+:1015D100BB010790E678E04420F090E679E0FF0552
+:1015E10055E555AC547002055414F5828C83EFF027
+:1015F10080CC90E678E030E0F990E678E020E215E2
+:1016010090E678E04440F090E679E0855582855493
+:0E16110083F07F012290E678E04440F07F00F5
+:01161F0022A8
+:1019220090E678E020E6F990E6787480F0EF25E022
+:1019320090E679F090E678E030E0F990E678E02001
+:10194200E23AE030E136EBD3940040260DEDAE04EE
+:1019520070010C14F5828E83E090E679F01B90E61C
+:1019620078E030E0F990E678E020E210E020E1D67D
+:10197200800A90E678E04440F07F012290E678E029
+:051982004440F07F006D
+:01198700223D
+:021D4600A907EB
+:101D4800AE16AF178F828E83A3E064037017AD01C0
+:101D580019ED7001228F828E83E07C002FFDEC3E0E
+:081D6800FEAF0580DFE4FEFF81
+:011D70002250
+:101EEE007400F58690FDA57C05A3E582458370F907
+:011EFE0022C1
+:030000000216B431
+:0C16B400787FE4F6D8FD75815D0216FB1E
+:10063B00E709F608DFFA8046E709F208DFFA803EA1
+:10064B0088828C83E709F0A3DFFA8032E309F6088E
+:10065B00DFFA8078E309F208DFFA807088828C83F6
+:10066B00E309F0A3DFFA806489828A83E0A3F608AA
+:10067B00DFFA805889828A83E0A3F208DFFA804C84
+:10068B0080D280FA80C680D4806980F2803380105B
+:10069B0080A680EA809A80A880DA80E280CA8033C4
+:1006AB0089828A83ECFAE493A3C8C582C8CCC5833C
+:1006BB00CCF0A3C8C582C8CCC583CCDFE9DEE7800C
+:1006CB000D89828A83E493A3F608DFF9ECFAA9F08B
+:1006DB00EDFB2289828A83ECFAE0A3C8C582C8CCE1
+:1006EB00C583CCF0A3C8C582C8CCC583CCDFEADEFA
+:1006FB00E880DB89828A83E493A3F208DFF980CC5C
+:10070B0088F0EF60010E4E60C388F0ED2402B40454
+:10071B000050B9F582EB2402B4040050AF232345FB
+:06072B00822390068B738F
+:10073100BB010689828A83E0225002E722BBFE02C6
+:09074100E32289828A83E49322F9
+:10074A00BB010CE58229F582E5833AF583E0225064
+:10075A0006E92582F8E622BBFE06E92582F8E222AE
+:0D076A00E58229F582E5833AF583E49322C8
+:10077700BB010689828A83F0225002F722BBFE0161
+:02078700F3225B
+:10078900F8BB010DE58229F582E5833AF583E8F0A6
+:10079900225006E92582C8F622BBFE05E92582C852
+:0207A900F2223A
+:1007AB00EF8DF0A4A8F0CF8CF0A428CE8DF0A42E62
+:0207BB00FE221C
+:1007BD00C2D5EC30E709B2D5E4C39DFDE49CFCEE57
+:1007CD0030E715B2D5E4C39FFFE49EFE120885C342
+:1007DD00E49DFDE49CFC800312088530D507C3E43D
+:0607ED009FFFE49EFE22C6
+:1007F300E8600FECC313FCED13FDEE13FEEF13FFE4
+:03080300D8F12207
+:10080600E8600FEFC333FFEE33FEED33FDEC33FC50
+:03081600D8F122F4
+:10081900BB010789828A830208E65005E9F80208C4
+:10082900DABBFE05E9F80208F289828A830208FE2A
+:10083900BB010789828A830208535005E9F8020936
+:0A0849000EBBFE05E9F802091A22B1
+:0C085300ECF0A3EDF0A3EEF0A3EFF02218
+:10085F00D083D082F8E4937012740193700DA3A328
+:10086F0093F8740193F5828883E47374029368603C
+:06087F00EFA3A3A380DF3C
+:1016C000020CE5E493A3F8E493A34003F68001F24F
+:1016D00008DFF48029E493A3F85407240CC8C3332B
+:1016E000C4540F4420C8834004F456800146F6DFFA
+:1016F000E4800B0102040810204080900F3CE47E3F
+:10170000019360BCA3FF543F30E509541FFEE493EE
+:10171000A360010ECF54C025E060A840B8E493A3B5
+:10172000FAE493A3F8E493A3C8C582C8CAC583CAE0
+:10173000F0A3C8C582C8CAC583CADFE9DEE780BE98
+:010FF50000FB
+:10088500BC000BBE0029EF8DF084FFADF022E4CC57
+:10089500F875F008EF2FFFEE33FEEC33FCEE9DEC20
+:1008A500984005FCEE9DFE0FD5F0E9E4CEFD22ED66
+:1008B500F8F5F0EE8420D21CFEADF075F008EF2FB0
+:1008C500FFED33FD4007985006D5F0F222C398FDA1
+:0508D5000FD5F0EA223E
+:0C08DA00E6FC08E6FD08E6FE08E6FF224A
+:0C08E600E0FCA3E0FDA3E0FEA3E0FF2285
+:0C08F200E2FC08E2FD08E2FE08E2FF2242
+:1008FE00E493FC740193FD740293FE740393FF2240
+:0C090E00ECF608EDF608EEF608EFF62215
+:0C091A00ECF208EDF208EEF208EFF22219
+:00000001FF
--- a/drivers/dahdi/xpp/firmwares/USB_FW.hex
+++ b/drivers/dahdi/xpp/firmwares/USB_FW.hex
--- a/drivers/dahdi/xpp/firmwares/USB_RECOV.hex
+++ b/drivers/dahdi/xpp/firmwares/USB_RECOV.hex
@@ -0,0 +1,421 @@
+#
+# $Id: USB_RECOV.hex 9760 2011-09-05 12:33:27Z dima $
+#
+:03004300021600A2
+:0300530002160092
+:10160000021580000215C6000215B00002159800F0
+:081610000213F20002137B003B
+:100A00001201000200000040AAAAAAAAAAAA010292
+:100A100003010A060002000000400100090237003D
+:100A2000020100C0000904000002FFFFFF040705E7
+:100A3000020200020007058602000200090401000C
+:100A400002FFFFFF050705040200020007058802F8
+:100A5000000200001201000200000040E4E4511115
+:100A60000000010203010A0600020000004001002C
+:100A700009023700020100C0320904000002FFFF32
+:100A8000FF0407050202400000070586024000003F
+:100A90000904010002FFFFFF0507050402400000F2
+:100AA000070588024000000604001600140012002A
+:100AB0000A00260004030904160358006F007200A0
+:100AC00063006F006D0020004C00540044001403CC
+:100AD00041007300740072006900620061006E00E2
+:100AE0006B001203530065007200690061006C0026
+:100AF0004E006F000A0346005000470041002603E5
+:100B00004D0061006E00610067006D0065006E00C1
+:100B10007400500072006F00630065007300730082
+:060B20006F0072000000EE
+:08164300584F52434F4D2000A7
+:100E650041E0B20042E0AD0000021BE0810218E063
+:100E75007543E0AF0000004CE036393734364D207D
+:060E8500202020202000C7
+:101517008B2A8A2B892CE52F152FAE2E7002152EBC
+:101527004E6014AB2A052CE52CAA2B7002052B1450
+:08153700F9ED12019280DF22A0
+:1013B8008B328A338934E5391539AE3870021538DD
+:1013C8004E6026AB350537E537AA36700205361468
+:1013D800F912014CFFAB320534E534AA337002052B
+:0A13E8003314F9EF12019280CD22B8
+:1011FD008C2A8D2BAA06A9077535018A3689377574
+:10120D00380075391C7B017AE079481213B890E0EB
+:10121D0060E0FCA3E0FDA3E0FEA3E064D1FFEE647B
+:10122D008DFEED644CFDEC6449FC90E06012026EA5
+:10123D007EE07F487D1C7C00120CFF7EE07F487BAA
+:10124D001C7A00AD2BAC2A120DB37D1C7C00AF2B8C
+:10125D00AE2A120C387D1C7C00AF2BAE2A0214284E
+:08099F008E2A8F2B8C2C8D2D6C
+:1009A700C204121567BF5004D204803BE4F52EF54C
+:1009B7002FE52D252FF582E52C352EF583E0FFE574
+:1009C7002B252FF582E52A352EF583E0B5070E0591
+:1009D7002FE52F7002052E6410452E70D4E52F6485
+:0909E70010452E7002D204A20496
+:0109F00022E4
+:020875008F32C0
+:100877001215678F33E4F537F538AD38AC37120FFB
+:100887001474652538F582E434E0F583E534F00522
+:1008970038E53870020537C39408E53764809480DB
+:1008A70040D8E532600490E065F090E065E0B4C0C0
+:1008B70008753500753608800675351D7536367529
+:1008C7003700753808C3E5389410E537648094809D
+:1008D7005023120F1074652538F582E434E0F58350
+:1008E700E534F00538E538700205370536E536702A
+:1008F700D4053580D07534FF75351D7536197537B4
+:1009070000753810C3E538942CE53764809480501F
+:1009170033E533B4510E7B007A007934AD36AC350C
+:10092700FF120F1C74652538F582E434E0F583E582
+:1009370034F00538E538700205370536E53670C4FA
+:10094700053580C075351D75363EE4F534F537F548
+:1009570038C3E5389406E53764809480502FE53333
+:10096700B4510A90E065E0B4C203120F1074422537
+:1009770038F582E434E0F583E534F00538E538707E
+:100987000205370536E53670C8053580C490E06541
+:07099700E0B4C20374C0F0DC
+:01099E002236
+:0A12D3008E2A8F2B8B2C8A2D892E7A
+:1012DD007E00E52B2DF533EE352AF5321215678F8D
+:1012ED002FE52F6451600BC3E52B9410E52A940074
+:1012FD005035852A30852B31C3E5319533E5309551
+:10130D00325024AB2CAA2DA92EAD31AC30AF2F12FB
+:10131D00117A0531E531700205307401252EF52E57
+:07132D00E4352DF52D80D100
+:011334002296
+:020B26008F320C
+:100B28007F031214ECEF2402FFE43EA9077533019A
+:100B3800F534893578367C007D007BFF7A16794359
+:100B48007E007F08120126E532600464017054E5D6
+:100B58000C2408F582E4350BF58374B4F0E50C2415
+:100B680009F582E4350BF5837404F0E50C240AF5E5
+:100B780082E4350BF5837413F0E50C240BF582E45D
+:100B8800350BF5837486F0E50C240CF582E4350BFF
+:100B9800F583E4F0E50C240DF582E4350BF583E4E8
+:100BA800F0806C90E066E0FFE50C2408F582E435FF
+:100BB8000BF583EFF090E067E0FFE50C2409F58280
+:100BC800E4350BF583EFF090E068E0FFE50C240ACC
+:100BD800F582E4350BF583EFF090E069E0FFE50C72
+:100BE800240BF582E4350BF583EFF090E06AE0FF23
+:100BF800E50C240CF582E4350BF583EFF090E06BFF
+:100C0800E0FFE50C240DF582E4350BF583EFF0E405
+:100C1800FF74362FF8E6FEAB33AA34A93575F00217
+:0F0C2800EFA4F58285F083EE1201A40FBF08E25E
+:010C3700229A
+:10145E00E4F532E50C240BF582E4350BF583E0FE62
+:10146E00E50C240AF582E4350BF583E0FDEDFF90E3
+:10147E00E0ADEEF0A3EFF0D20412000390E680E0B0
+:03148E0054F7F020
+:011491002238
+:10105A0090E600E054E74410F090E60174C0F09086
+:10106A00E6107420F000000090E611F000000090F5
+:10107A00E6047480F0000000740FF0000000E4F051
+:10108A0000000090E6187410F0000000E490E619E1
+:10109A00F000000090E61A7408F0000000E490E600
+:1010AA001BF000000090E6497482F0000000F00096
+:1010BA00000090E6247402F0000000E490E625F0B7
+:1010CA0000000090E6957480F0000000F000000037
+:1010DA0043AF017B017AE07914752E00752F06E47F
+:0410EA00FD021517D7
+:1015DC007C007D181201C6EF1FAC0670011E4C700A
+:0215EC00F622E5
+:1015670090E678E0541824F06008240870087F504B
+:0815770080067F518002E4FFB1
+:01157F002249
+:0C0F1000AD36AC357B007A007934AF338D
+:0C0F1C008F398C3A8D3B8B3C8A3D893E1E
+:100F2800E4F53FF540754103FDF542F543A2AF33C3
+:100F3800F544E53924AF600D047012753F00754023
+:100F4800017D018008753F00754002E4FDE53960C8
+:100F580051E540453F604BE53A90E0AFF0E53BA3F3
+:100F6800F074AF2DF582E434E0AD82FCAB40AF39CC
+:100F780012126D7542008F437F0A7E00121335E509
+:100F880043454260107CE07D647B01AF39120FB5A8
+:100F98007542008F4390E064E0AB3CAA3DA93E1245
+:0C0FA8000192E54424FF92AFAE42AF433B
+:010FB400221A
+:0C117A008F348C358D368B378A388939DC
+:10118600E4F53AF53B753C03FDF53DF53EA2AF337C
+:10119600F53FE53424AF600D047012753A00753BD7
+:1011A600027D018008753A00753B03E4FDE5346075
+:1011B6003BE53B453A6035E53590E0AFF0E536A3D3
+:1011C600F0AB37AA38A93912014C90E0B1F074AFF0
+:1011D6002DF582E434E0AD82FCAB3BAF3412126DE8
+:1011E600753D008F3E7F0A7E00121335E53F24FFD2
+:0611F60092AFAE3DAF3EDA
+:0111FC0022D0
+:10054300E4F52AF52BF52CF52DF52EF52FF530E5F1
+:10055300AA5484600302071190E694E0FE90E695A6
+:10056300E0FBEEF52DEBF52EC39405E52D9400404D
+:100573000790F404E0FD80027DFFED24F570030293
+:10058300062524E6700302064F24E0700302062CBE
+:1005930024FE7003020649243960030206B3752A58
+:1005A30000752B0590FC04748EF01215678F30E5EF
+:1005B3003064516019E53064506013752A00752B5F
+:1005C3000690FC047480F0A3740BF00206D6121597
+:1005D300678F307B007A007931E4FDFC120F1CAF8A
+:1005E300311208757400252BF974FC352AFA7B0146
+:1005F300C0038B357536E075376575380075392C52
+:10060300D0031213B87400252BF58274FC352AF538
+:1006130083E531F0742C252BF52BE4352AF52A02DA
+:1006230006D6E4F52AF52B801D1215678F307B0063
+:100633007A007931E4FDFC120F1CAF311208757F8B
+:10064300C0120B26800012145E0206D6752A0075AE
+:100653002B0590FC0474A5F01215678F307B007A8C
+:10066300007931E4FDFC120F1C052BE52BAE2A703B
+:1006730002052A142400F58274FC3EF583E508F094
+:10068300052BE52BAE2A7002052A142400F582748B
+:10069300FC3EF583E515F0052BE52BAE2A7002052C
+:1006A3002A142400F58274FC3EF583E531F080239F
+:1006B300752A00752B0690FC047480F0C3E52E9414
+:1006C30005E52D94005006A37407F0800690FC0501
+:1006D3007406F0E52B452A602CE52BFD90FC00F019
+:1006E300E52AFFA3F090F402E090FC02F090F403FB
+:1006F300E090FC03F090E69CEFF000000090E69D94
+:0E070300EDF000000090E6957480F00000001C
+:0107110022C5
+:02004100D322C8
+:0800460090E6BAE0F51DD3229B
+:1015EE0090E740E51DF0E490E68AF090E68B04F07B
+:0215FE00D322F6
+:08163B0090E6BAE0F51AD32293
+:1016180090E740E51AF0E490E68AF090E68B04F053
+:02162800D322CB
+:10153F0090E6B9E0242F600D04701990E604E0FFE7
+:10154F00430780800890E604E0FF53077F00000008
+:07155F00EFF08002D322C36C
+:011566002262
+:10158000C0E0C083C082D2015391EF90E65D740148
+:08159000F0D082D083D0E032DC
+:1015B000C0E0C083C0825391EF90E65D7404F0D028
+:0615C00082D083D0E0326E
+:1015C600C0E0C083C0825391EF90E65D7402F0D014
+:0615D60082D083D0E03258
+:1013F200C0E0C083C08285110D85120E850E8285E4
+:101402000D83A37402F085090F850A108510828569
+:101412000F83A37407F05391EF90E65D7410F0D040
+:0614220082D083D0E0320D
+:10159800C0E0C083C082D2035391EF90E65D740827
+:0815A800F0D082D083D0E032C4
+:10137B00C0E0C083C08290E680E030E72085090D95
+:10138B00850A0E850E82850D83A37402F085110FDD
+:10139B00851210851082850F83A37407F05391EF8C
+:0D13AB0090E65D7420F0D082D083D0E03257
+:0E09F10000010202030304040505C0C2000059
+:1007120078237C007D007BFF7A0979FB7E007F04D1
+:10072200120126C203C200D202C20112105A750B74
+:100732000A750C0075130A75141275090A750A1CDC
+:1007420075110A75127085110F85121075160A75CA
+:1007520017B41215678F217B007A007922E4FDFC21
+:10076200120F1C852208E4F515F52774232527F8B6
+:10077200E6FF605C1208757EE07F657CE07DB31267
+:1007820011FD7EE07FB3AD1CAC1B12099F50387483
+:10079200232527F8E6F515652260277B007A007984
+:1007A200157D01E4FFFE1212D37B007A007922E468
+:1007B200FDFCAF21120F1CE52265156013751501B2
+:1007C200800E7515FF80090527E527C39404409B19
+:1007D200E5157059FB7A0079227D01FCAF21120FD9
+:1007E2001CE522752900F5287B007A0079227D021A
+:1007F2007C00AF21120F1CE5224229E52964E47036
+:1008020004E52864E470267515C0FB7A0079157D2D
+:1008120001FFFE1212D37B007A007922E4FDFCAFC5
+:1008220021120F1CE52265156003751501AF151223
+:100832000B26D2E843D82090E668E04409F090E61F
+:100842005CE0443DF0E51564C06005E515B4C20303
+:1008520012145ED2AF538EF8C203C2AF120543D256
+:10086200AF30010512031BC2013003EEC2031214A2
+:03087200C080E75C
+:0B00360090E50DE030E402C322D3226D
+:10031B0090E6B9E070030203E01470030204552465
+:10032B00FE70030204D024FB70030203DA14700383
+:10033B000203D41470030203C81470030203CE2407
+:10034B0005600302052F120041400302053B90E6B6
+:10035B00BBE024FE602714603E24FD60111460276F
+:10036B0024067056E50B90E6B3F0E50C80421200C4
+:10037B00365044E51390E6B3F0E5148033E50D9069
+:10038B00E6B3F0E50E802985110F851210E50F906D
+:10039B00E6B3F0E510801990E6BAE0FF1214ECAA70
+:1003AB0006A9077B01EA494B600DEE90E6B3F0EF2F
+:1003BB0090E6B4F002053B02052A02052A12161834
+:1003CB0002053B12163B02053B12004602053B128F
+:1003DB0015EE02053B90E6B8E0247F60151460191A
+:1003EB0024027063A200E43325E0FFA202E4334F42
+:1003FB008041E490E740F0803F90E6BCE0547EFF04
+:10040B007E00E0D394807C0040047D0180027D005F
+:10041B00EC4EFEED4F24F1F58274093EF583E49327
+:10042B00FF3395E0FEEF24A1FFEE34E68F82F583D8
+:10043B00E0540190E740F0E4A3F090E68AF090E6F8
+:10044B008B7402F002053B02052A90E6B8E024FE0D
+:10045B0060162402600302053B90E6BAE0B4010586
+:10046B00C20002053B02052A90E6BAE0705590E601
+:10047B00BCE0547EFF7E00E0D394807C0040047D82
+:10048B000180027D00EC4EFEED4F24F1F5827409E4
+:10049B003EF583E493FF3395E0FEEF24A1FFEE34AA
+:1004AB00E68F82F583E054FEF090E6BCE0548013B7
+:1004BB001313541FFFE0540F2F90E683F0E04420FA
+:1004CB00F0806D805A90E6B8E024FE60192402702B
+:1004DB004E90E6BAE0B40104D200805490E6BAE044
+:1004EB006402604C803990E6BCE0547EFF7E00E0F5
+:1004FB00D394807C0040047D0180027D00EC4EFE95
+:10050B00ED4F24F1F58274093EF583E493FF3395A7
+:10051B00E0FEEF24A1FFEE34E68F82F583800D9091
+:10052B00E6A0800812153F500790E6A0E04401F0CA
+:07053B0090E6A0E04480F00F
+:010542002296
+:0300330002004E7A
+:04004E0053D8EF3262
+:100E8B006080E0CF292E43C9A2D87C013D3654A106
+:100E9B00ECF0061362A705F3C0C7738C98932BD99C
+:100EAB00BC4C82CA1E9B573CFDD4E01667426F18A0
+:100EBB008A17E512BE4EC4D6DA9EDE49A0FBF58E2C
+:100ECB00BB2FEE7AA968799115B2073F94C21089AE
+:100EDB000B225F21807F5D9A5A903227353ECCE7FB
+:100EEB00BFF79703FF1930B348A5B5D1D75E922A48
+:100EFB00AC56AAC64FB838D296A47DB676FC6BE238
+:040F0B009C7404F1DD
+:080CFF008C2C8D2DAB07AA0619
+:100D0700E4F52EF52FC3E52F952DE52C6480F8E546
+:100D17002E6480984003020DAEE52F25E0FFE52EF7
+:100D270033FE74CF2FF58274E03EF583E0FF7E003B
+:100D3700AC2CAD2D1201D88C308D31E52F25E0FF7D
+:100D4700E52E33FE74D02FF58274E03EF583E0FF85
+:100D57007E00AC2CAD2D1201D88C328D33E5316578
+:100D6700337004E53065326030EB2531F582EA35C2
+:100D770030F583E0F9EB2533F582EA3532F583E088
+:100D8700FFEB2531F582EA3530F583EFF0EB2533BC
+:100D9700F582EA3532F583E9F0052FE52F60030286
+:0B0DA7000D0C052E020D0C7E007F01DC
+:010DB200221E
+:0C0DB3008E2C8F2D8C2E8D2F8A308B31D2
+:100DBF00E52D452C6006E52F452E7004E4FEFF223D
+:100DCF00E4F532F533C3E5339531E5306480F8E56A
+:100DDF0032648098507BE4F534F535E52F2533F5F3
+:100DEF0082E52E3532F583E4F0C3E5359531E530F4
+:100DFF006480F8E5346480985049E535253324CF75
+:100E0F00F582E434E0F583E0FFE52D2535F582E545
+:100E1F002C3534F583E0FEEF8EF0A4FFE52F25335C
+:100E2F00F582E52E3532F583E02FFFE52F2533F5DB
+:100E3F0082E52E3532F583EFF00535E53570AA05DD
+:100E4F003480A60533E5336003020DD40532020D5D
+:050E5F00D47E007F01BC
+:010E6400226B
+:1014920012014CFF900003120165120192900003A9
+:1014A200EF1201A4900002120165FF9000011201E7
+:0E14B200659000021201A4900001EF0201A457
+:080C38008E2C8F2D8C2E8D2FC8
+:100C4000E4F530F531E52FAE2E7802CEA2E713CED3
+:100C500013D8F8FFC3E5319FEE6480F8E530648077
+:100C6000984003020CFAE531AE307802C333CE333C
+:100C7000CED8F9252DFFEE352CFAA9077B018B3252
+:100C8000F533893474D02531F582E434E0F583E01E
+:100C9000541FFFE48F38F537F536F535121492AB53
+:100CA00032AA33A934120234C374209538F9F812E9
+:100CB0000221C004C005C006C007A934120234A92D
+:100CC00038A80112020ED003D002D001D000EF4BA1
+:100CD000FFEE4AFEED49FDEC48FCAB32AA33A934E5
+:100CE000120254AB32AA33A9341214920531E53101
+:0E0CF0006003020C450530020C457E007F01BA
+:010CFE0022D3
+:10142800D3ED9410EC64809480402AED1D70011C6B
+:10143800142FF582EE3CF583E0FB547F24CFF58230
+:10144800E434E0F583E0F9540F2FF582E43EF583A8
+:05145800E06BF080CB09
+:01145D00226C
+:1014C00090E682E030E004E020E60B90E682E03037
+:1014D000E119E030E71590E680E04401F07F147EEA
+:0C14E0000012133590E680E054FEF0226C
+:1000030030040990E680E0440AF0800790E680E03F
+:100013004408F07FDC7E0512133590E65D74FFF033
+:0F00230090E65FF05391EF90E680E054F7F02203
+:101335008E458F4690E600E054187012E54624016C
+:10134500FFE43545C313F545EF13F546801590E6E3
+:1013550000E05418FFBF100BE54625E0F546E545CE
+:1013650033F545E5461546AE45700215454E600513
+:0613750012162A80EE2290
+:060FB5008C458D46AE07DD
+:100FBB00EB70037F012290E678E020E6F990E6786B
+:100FCB007480F0EE25E0440190E679F090E678E04D
+:100FDB0030E0F990E678E020E26BE030E167BB01AE
+:100FEB000790E678E04420F090E679E0F5471BEBBC
+:100FFB00603090E678E030E0F990E678E020E2456A
+:10100B00BB010790E678E04420F090E679E0FF051D
+:10101B0046E546AC457002054514F5828C83EFF02E
+:10102B0080CC90E678E030E0F990E678E020E215AD
+:10103B0090E678E04440F090E679E085468285457D
+:0E104B0083F07F012290E678E04440F07F00C1
+:011059002274
+:10126D0090E678E020E6F990E6787480F0EF25E0DE
+:10127D0090E679F090E678E030E0F990E678E020BD
+:10128D00E23AE030E136EBD3940040260DEDAE04AA
+:10129D0070010C14F5828E83E090E679F01B90E6D8
+:1012AD0078E030E0F990E678E020E210E020E1D639
+:1012BD00800A90E678E04440F07F012290E678E0E5
+:0512CD004440F07F0029
+:0112D20022F9
+:0214EC00A9074E
+:1014EE00AE16AF178F828E83A3E064037017AD0123
+:1014FE0019ED7001228F828E83E07C002FFDEC3E71
+:08150E00FEAF0580DFE4FEFFE3
+:0115160022B2
+:10162A007400F58690FDA57C05A3E582458370F9D3
+:01163A00228D
+:030000000210EEFD
+:0C10EE00787FE4F6D8FD758147021135CB
+:10005600E709F608DFFA8046E709F208DFFA803E8C
+:1000660088828C83E709F0A3DFFA8032E309F60879
+:10007600DFFA8078E309F208DFFA807088828C83E1
+:10008600E309F0A3DFFA806489828A83E0A3F60895
+:10009600DFFA805889828A83E0A3F208DFFA804C6F
+:1000A60080D280FA80C680D4806980F28033801046
+:1000B60080A680EA809A80A880DA80E280CA8033AF
+:1000C60089828A83ECFAE493A3C8C582C8CCC58327
+:1000D600CCF0A3C8C582C8CCC583CCDFE9DEE780F7
+:1000E6000D89828A83E493A3F608DFF9ECFAA9F076
+:1000F600EDFB2289828A83ECFAE0A3C8C582C8CCCC
+:10010600C583CCF0A3C8C582C8CCC583CCDFEADEE4
+:10011600E880DB89828A83E493A3F208DFF980CC46
+:1001260088F0EF60010E4E60C388F0ED2402B4043F
+:100136000050B9F582EB2402B4040050AF232345E6
+:0601460082239000A67365
+:10014C00BB010689828A83E0225002E722BBFE02B1
+:09015C00E32289828A83E49322E4
+:10016500BB010CE58229F582E5833AF583E022504F
+:1001750006E92582F8E622BBFE06E92582F8E22299
+:0D018500E58229F582E5833AF583E49322B3
+:10019200BB010689828A83F0225002F722BBFE014C
+:0201A200F32246
+:1001A400F8BB010DE58229F582E5833AF583E8F091
+:1001B400225006E92582C8F622BBFE05E92582C83D
+:0201C400F22225
+:1001C600EF8DF0A4A8F0CF8CF0A428CE8DF0A42E4D
+:0201D600FE2207
+:1001D800C2D5EC30E709B2D5E4C39DFDE49CFCEE42
+:1001E80030E715B2D5E4C39FFFE49EFE12027AC33E
+:1001F800E49DFDE49CFC800312027A30D507C3E439
+:060208009FFFE49EFE22B0
+:10020E00E8600FECC313FCED13FDEE13FEEF13FFCE
+:03021E00D8F122F2
+:10022100E8600FEFC333FFEE33FEED33FDEC33FC3B
+:03023100D8F122DF
+:10023400BB010789828A830202DB5005E9F80202C6
+:10024400CFBBFE05E9F80202E789828A830202F342
+:10025400BB010789828A8302026E5005E9F8020312
+:0A02640003BBFE05E9F802030F22B8
+:0C026E00ECF0A3EDF0A3EEF0A3EFF02203
+:1010FA00020712E493A3F8E493A34003F68001F2F3
+:10110A0008DFF48029E493A3F85407240CC8C333F6
+:10111A00C4540F4420C8834004F456800146F6DFC5
+:10112A00E4800B0102040810204080900E65E47EE2
+:10113A00019360BCA3FF543F30E509541FFEE493BA
+:10114A00A360010ECF54C025E060A840B8E493A381
+:10115A00FAE493A3F8E493A3C8C582C8CAC583CAAC
+:10116A00F0A3C8C582C8CAC583CADFE9DEE780BE64
+:010F0F0000E1
+:10027A00BC000BBE0029EF8DF084FFADF022E4CC68
+:10028A00F875F008EF2FFFEE33FEEC33FCEE9DEC31
+:10029A00984005FCEE9DFE0FD5F0E9E4CEFD22ED77
+:1002AA00F8F5F0EE8420D21CFEADF075F008EF2FC1
+:1002BA00FFED33FD4007985006D5F0F222C398FDB2
+:0502CA000FD5F0EA224F
+:0C02CF00E6FC08E6FD08E6FE08E6FF225B
+:0C02DB00E0FCA3E0FDA3E0FEA3E0FF2296
+:0C02E700E2FC08E2FD08E2FE08E2FF2253
+:1002F300E493FC740193FD740293FE740393FF2251
+:0C030300ECF608EDF608EEF608EFF62226
+:0C030F00ECF208EDF208EEF208EFF2222A
+:00000001FF
--- a/drivers/dahdi/xpp/init_card_1_30
+++ b/drivers/dahdi/xpp/init_card_1_30
@@ -51,6 +51,7 @@ BEGIN { $init_dir = dirname($0); unshift(@INC, "$init_dir"); }
 use XppConfig $init_dir;
 my $unit_id;
 my %opts;
+my $eeprom_release_201 = 0;

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

@@ -78,6 +79,7 @@ if (-t STDERR) {
 	foreach my $k (qw(
 			XBUS_NAME
 			XBUS_NUMBER
+			XBUS_MODEL_STRING
 			UNIT_NUMBER
 			UNIT_TYPE
 			UNIT_SUBUNITS
@@ -90,6 +92,10 @@ if (-t STDERR) {
 			die;
 		}
 	}
+	logit "XBUS_MODEL_STRING='$ENV{XBUS_MODEL_STRING}'";
+	if ($ENV{XBUS_MODEL_STRING} =~ m{.*/.*/201}) {
+		$eeprom_release_201 = 1;
+	}
 	$chipregs = sprintf "/sys/bus/xpds/devices/%02d:%1d:0/chipregs",
 		$ENV{XBUS_NUMBER}, $ENV{UNIT_NUMBER};
 	if(! -f $chipregs) {
@@ -286,11 +292,15 @@ sub init_indirect_registers() {
 }

 sub init_early_direct_regs() {
+	my $lbv = ($eeprom_release_201) ? "20" : "10";
+	my $vcm = ($eeprom_release_201) ? "02" : "03";
+
 	return write_to_slic_file("#
 *	WD	08	00	# Audio Path Loopback Control
 *	WD	6C	01
 *	WD	4A	3F	# High Battery Voltage
-*	WD	4B	10	# Low Battery Voltage
+*	WD	4B	$lbv	# Low Battery Voltage
+*	WD	49	$vcm	# Common Mode Voltage (VCM)
 *	WD	40	00	# Line Feed Control
 #")
 }
@@ -578,9 +588,6 @@ __DATA__
 # On-Hook Line Voltage (VOC)
 *	WD	48 20

-# Common Mode Voltage (VCM)
-*	WD	49 03
-
 *	WS	1E	23	00 80
 *	WS	1E	24	20 03
 *	WS	1E	25	8C 00
--- a/drivers/dahdi/xpp/init_card_2_30
+++ b/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
--- a/drivers/dahdi/xpp/mmapbus.c
+++ b/drivers/dahdi/xpp/mmapbus.c
@@ -7,7 +7,9 @@ static int mmap_match(struct device *dev, struct device_driver *driver)
 {
 	return !strncmp(dev_name(dev), driver->name, strlen(driver->name));
 }
-static int mmap_uevent(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size)
+
+static int mmap_uevent(struct device *dev, char **envp, int num_envp,
+		       char *buffer, int buffer_size)
 {
 	envp[0] = buffer;
 	envp[1] = NULL;
@@ -33,8 +35,6 @@ static struct device mmap_bus = {
 	.release = mmap_bus_release,
 };

-
-
 int register_mmap_device(struct mmap_device *dev)
 {
 	dev->dev.bus = &mmap_bus_type;
@@ -43,12 +43,12 @@ int register_mmap_device(struct mmap_device *dev)
 	strncpy(dev->dev.bus_id, dev->name, BUS_ID_SIZE);
 	return device_register(&dev->dev);
 }
+EXPORT_SYMBOL(register_mmap_device);

 void unregister_mmap_device(struct mmap_device *dev)
 {
 	device_unregister(&dev->dev);
 }
-EXPORT_SYMBOL(register_mmap_device);
 EXPORT_SYMBOL(unregister_mmap_device);

 int register_mmap_driver(struct mmap_driver *driver)
@@ -56,12 +56,12 @@ int register_mmap_driver(struct mmap_driver *driver)
 	driver->driver.bus = &mmap_bus_type;
 	return driver_register(&driver->driver);
 }
+EXPORT_SYMBOL(register_mmap_driver);

 void unregister_mmap_driver(struct mmap_driver *driver)
 {
 	driver_unregister(&driver->driver);
 }
-EXPORT_SYMBOL(register_mmap_driver);
 EXPORT_SYMBOL(unregister_mmap_driver);

 int register_mmap_bus(void)
@@ -78,13 +78,13 @@ bus_reg:
 bus_type_reg:
 	return ret;
 }
+EXPORT_SYMBOL(register_mmap_bus);

 void unregister_mmap_bus(void)
 {
 	device_unregister(&mmap_bus);
 	bus_unregister(&mmap_bus_type);
 }
-EXPORT_SYMBOL(register_mmap_bus);
 EXPORT_SYMBOL(unregister_mmap_bus);

 MODULE_AUTHOR("Alexander Landau <landau.alex@gmail.com>");
--- a/drivers/dahdi/xpp/mmapdrv.c
+++ b/drivers/dahdi/xpp/mmapdrv.c
@@ -19,11 +19,13 @@
 #include "xframe_queue.h"

 /* Check at compile time that sizeof(xframe_t) is a multiple of 4 */
-typedef char sizeof_xframe_t_should_be_divisible_by_4[((sizeof(xframe_t) % 4) == 0) * 2 - 1];
+typedef char
+    sizeof_xframe_t_should_be_divisible_by_4[((sizeof(xframe_t) % 4) ==
+					      0) * 2 - 1];

 #define ssync()			__builtin_bfin_ssync()

-//#define AB_IN_BUF	PF5
+//#define AB_IN_BUF     PF5
 /* firmware pins */
 #define DATA            PG8
 #define NCONFIG         PG9
@@ -33,13 +35,13 @@ typedef char sizeof_xframe_t_should_be_divisible_by_4[((sizeof(xframe_t) % 4) ==

 #ifdef	DEBUG_VIA_GPIO
 /*
- * For debugging we can use the following two pins. 
+ * For debugging we can use the following two pins.
 * These two pins are not used *after initialization*
 */
 #define	DEBUG_GPIO1	CONF_DONE
 #define	DEBUG_GPIO2	NSTATUS

-static int	rx_intr_counter;
+static int rx_intr_counter;
 #endif

 #define FPGA_RX_IRQ	IRQ_PF7
@@ -49,9 +51,15 @@ static int	rx_intr_counter;
 #define END_OF_FRAME	0x0001
 #define GET_LEN		0x0002
 #define START_RD_BURST	0x0008
-#define AS_BF_MODE	0x0010 //stand alone Astribank without USB (Asterisk BlackFin Mode)
-#define EC_BF_MODE	0x0020 //all data between Astribank and USB routed thru BF(EchoCanceler BlackFin Mode)
-#define NO_BF_MODE	0x0040 //Astribank worke with USB only (no BlackFin Mode) 
+/* stand alone Astribank without USB (Asterisk BlackFin Mode) */
+#define AS_BF_MODE	0x0010
+/*
+ * all data between Astribank and USB routed
+ * thru BF(EchoCanceler BlackFin Mode)
+ */
+#define EC_BF_MODE	0x0020
+/* Astribank worke with USB only (no BlackFin Mode) */
+#define NO_BF_MODE	0x0040
 #define SET_XA_DIR	0x0080
 #define GET_XPD_STS	0x0100
 #define GET_CHECKSUM	0x0200
@@ -80,9 +88,8 @@ static void print_buffer(const char *msg, const char *buf, int len)
 {
 	int i;
 	printk(KERN_ERR "%s", msg);
-	for (i = 0; i < len; i++) {
+	for (i = 0; i < len; i++)
 		printk("%02X ", (unsigned char)buf[i]);
-	}
 	printk("\n");
 }

@@ -96,7 +103,8 @@ static void update_counter(struct counter *c, struct timeval *tv1)
 		c->intr_min = diff;
 	if (c->intr_max < diff)
 		c->intr_max = diff;
-	c->intr_avg = (c->intr_avg*c->intr_count + diff) / (c->intr_count+1);
+	c->intr_avg =
+	    (c->intr_avg * c->intr_count + diff) / (c->intr_count + 1);
 	c->intr_count++;
 }

@@ -105,7 +113,7 @@ static irqreturn_t xpp_mmap_rx_irq(int irq, void *dev_id)
 	unsigned short rxcnt;
 	xbus_t *xbus;
 	xframe_t *xframe;
-	byte *buf;
+	__u8 *buf;
 	bool in_use = 0;
 	struct timeval tv1;

@@ -115,7 +123,7 @@ static irqreturn_t xpp_mmap_rx_irq(int irq, void *dev_id)

 	xbus = xbus_num(global_xbus->num);
 	BUG_ON(!xbus);
-	if(!XBUS_GET(xbus)) {
+	if (!XBUS_GET(xbus)) {
 		if (printk_ratelimit())
 			XBUS_ERR(xbus, "Dropping packet. Is shutting down.\n");
 		goto out;
@@ -129,7 +137,7 @@ static irqreturn_t xpp_mmap_rx_irq(int irq, void *dev_id)
 			NOTICE("Got %d bytes\n", rxcnt);
 		goto out;
 	}
-	if(rxcnt >= XFRAME_DATASIZE) {
+	if (rxcnt >= XFRAME_DATASIZE) {
 		if (printk_ratelimit())
 			ERR("Bad rxcnt=%d\n", rxcnt);
 		goto out;
@@ -153,18 +161,22 @@ static irqreturn_t xpp_mmap_rx_irq(int irq, void *dev_id)
 	outw(START_RD_BURST, FPGA_BASE_ADDR + 4);
 	insw((unsigned long)FPGA_BASE_ADDR, buf, rxcnt / 2);
 #if 0
-	for (count = 0; count < rxcnt; count+=2) {
+	for (count = 0; count < rxcnt; count += 2) {
 		unsigned short v = inw(FPGA_BASE_ADDR);
 		buf[count] = v & 0xFF;
-		buf[count+1] = v >> 8;
+		buf[count + 1] = v >> 8;
 	}
 #endif
-	if (rxcnt & 1) 
-		buf[rxcnt-1] = inw(FPGA_BASE_ADDR);
-	/* Sanity check: length of first packet in frame should be no more than the frame length */
-	if (((buf[0] | (buf[1]<<8)) & 0x3FF) > rxcnt) {
+	if (rxcnt & 1)
+		buf[rxcnt - 1] = inw(FPGA_BASE_ADDR);
+	/*
+	 * Sanity check: length of first packet in frame
+	 * should be no more than the frame length
+	 */
+	if (((buf[0] | (buf[1] << 8)) & 0x3FF) > rxcnt) {
 		if (printk_ratelimit()) {
-			ERR("Packet len=%d, frame len=%d\n", (buf[0] | (buf[1]<<8)) & 0x3FF, rxcnt);
+			ERR("Packet len=%d, frame len=%d\n",
+			    (buf[0] | (buf[1] << 8)) & 0x3FF, rxcnt);
 			print_buffer("16 bytes of packet: ", buf, 16);
 		}
 		goto free;
@@ -199,7 +211,7 @@ static void send_buffer(unsigned char *buf, unsigned long len)
 		print_buffer("Sent: ", buf, len);
 	outsw((unsigned long)FPGA_BASE_ADDR, buf, len / 2);
 	if (len & 1)
-		outw((unsigned short)buf[len-1], FPGA_BASE_ADDR);
+		outw((unsigned short)buf[len - 1], FPGA_BASE_ADDR);
 	outw(END_OF_FRAME, FPGA_BASE_ADDR + 4);
 }

@@ -258,7 +270,10 @@ static int xframe_send_common(xbus_t *xbus, xframe_t *xframe, bool pcm)
 		if (pcm && pcm_in_pool_count >= 1) {
 			static int rate_limit;
 			if ((rate_limit++ % 1000) == 0)
-				XBUS_ERR(xbus, "Dropped PCM xframe (pcm_in_pool_count=%d).\n", pcm_in_pool_count);
+				XBUS_ERR(xbus,
+					 "Dropped PCM xframe "
+					 "(pcm_in_pool_count=%d).\n",
+					 pcm_in_pool_count);
 			FREE_SEND_XFRAME(xbus, xframe);
 			pcm_dropped++;
 		} else {
@@ -266,7 +281,9 @@ static int xframe_send_common(xbus_t *xbus, xframe_t *xframe, bool pcm)
 				static int rate_limit;
 				spin_unlock_irqrestore(&tx_ready_lock, flags);
 				if ((rate_limit++ % 1000) == 0)
-					XBUS_ERR(xbus, "Dropped xframe. Cannot enqueue.\n");
+					XBUS_ERR(xbus,
+						 "Dropped xframe. "
+						 "Cannot enqueue.\n");
 				FREE_SEND_XFRAME(xbus, xframe);
 				return -E2BIG;
 			}
@@ -284,10 +301,12 @@ static xframe_t *alloc_xframe(xbus_t *xbus, gfp_t gfp_flags)
 	if (!xframe) {
 		static int rate_limit;
 		if ((rate_limit++ % 1000) < 5)
-			XBUS_ERR(xbus, "frame allocation failed (%d)\n", rate_limit);
+			XBUS_ERR(xbus, "frame allocation failed (%d)\n",
+				 rate_limit);
 		return NULL;
 	}
-	xframe_init(xbus, xframe, ((byte*)xframe) + sizeof(xframe_t), XFRAME_DATASIZE, xbus);
+	xframe_init(xbus, xframe, ((__u8 *)xframe) + sizeof(xframe_t),
+		    XFRAME_DATASIZE, xbus);
 	return xframe;
 }

@@ -316,28 +335,26 @@ static struct xbus_ops xmmap_ops = {

 static int fill_proc_queue(char *p, struct xframe_queue *q)
 {
-	int	len;
+	int len;

 	len = sprintf(p,
-			"%-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);
+		"%-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 fill_proc_counter(char *p, struct counter *c)
 {
-	return sprintf(p, "min=%ld\nmax=%ld\navg=%ld\ncount=%ld\n", c->intr_min, c->intr_max, c->intr_avg, c->intr_count);
+	return sprintf(p, "min=%ld\nmax=%ld\navg=%ld\ncount=%ld\n", c->intr_min,
+		       c->intr_max, c->intr_avg, c->intr_count);
 }

-static int xpp_mmap_proc_read(char *page, char **start, off_t off, int count, int *eof, void *data)
+static int xpp_mmap_proc_read(char *page, char **start, off_t off, int count,
+			      int *eof, void *data)
 {
 	int len = 0;
 	len += fill_proc_queue(page + len, &txpool);
@@ -347,7 +364,7 @@ static int xpp_mmap_proc_read(char *page, char **start, off_t off, int count, in
 	len += fill_proc_counter(page + len, &rx_counter);
 	len += sprintf(page + len, "\ntx_counter:\n");
 	len += fill_proc_counter(page + len, &tx_counter);
-	if (len <= off+count) {
+	if (len <= off + count) {
 		*eof = 1;
 		tx_counter.intr_min = rx_counter.intr_min = INT_MAX;
 		tx_counter.intr_max = rx_counter.intr_max = 0;
@@ -363,14 +380,15 @@ static int xpp_mmap_proc_read(char *page, char **start, off_t off, int count, in
 	return len;
 }

-static int xpp_mmap_proc_write(struct file *file, const char __user *buffer, unsigned long count, void *data)
+static int xpp_mmap_proc_write(struct file *file, const char __user *buffer,
+			       unsigned long count, void *data)
 {
 	int i = 0;
 	char *txchunk, *p, *endp;

-	if (count >= XFRAME_DATASIZE*3+10)
+	if (count >= XFRAME_DATASIZE * 3 + 10)
 		return -EINVAL;
-	p = txchunk = kmalloc(count+1, GFP_KERNEL);
+	p = txchunk = kmalloc(count + 1, GFP_KERNEL);
 	if (copy_from_user(txchunk, buffer, count)) {
 		count = -EFAULT;
 		goto out;
@@ -379,13 +397,15 @@ static int xpp_mmap_proc_write(struct file *file, const char __user *buffer, uns

 	while (*p) {
 		unsigned long value;
-		while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r') p++;
-		if (*p == '\0') break;
+		while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')
+			p++;
+		if (*p == '\0')
+			break;
 		value = simple_strtoul(p, &endp, 16);
 		if (endp == p || value > 0xFF) {
-		    INFO("%s: Bad input\n", __FUNCTION__);
-		    count = -EINVAL;
-		    goto out;
+			INFO("%s: Bad input\n", __func__);
+			count = -EINVAL;
+			goto out;
 		}
 		p = endp;
 		txchunk[i++] = (char)value;
@@ -399,8 +419,8 @@ out:
 static struct mmap_driver astribank_driver = {
 	.module = THIS_MODULE,
 	.driver = {
-		.name = "xpp_mmap",
-	},
+		   .name = "xpp_mmap",
+		   },
 };

 static struct mmap_device astribank_dev = {
@@ -408,42 +428,52 @@ static struct mmap_device astribank_dev = {
 	.driver = &astribank_driver,
 };

-static int __init xpp_mmap_load_fpga(u8 *data, size_t size)
+static int __init xpp_mmap_load_fpga(u8 * data, size_t size)
 {
 	size_t i;
-	bfin_write_PORTGIO_DIR(bfin_read_PORTGIO_DIR() | DATA | NCONFIG | DCLK); //set data, nconfig and dclk to port out
+	/* set data, nconfig and dclk to port out */
+	bfin_write_PORTGIO_DIR(bfin_read_PORTGIO_DIR() | DATA | NCONFIG | DCLK);
 	bfin_write_PORTG_FER(bfin_read_PORTG_FER() & ~(DATA | NCONFIG | DCLK));
-	bfin_write_PORTGIO_DIR(bfin_read_PORTGIO_DIR() & ~(CONF_DONE | NSTATUS));//set conf_done and nstatus to port in
-	bfin_write_PORTGIO_INEN(bfin_read_PORTGIO_INEN() & ~(DATA | NCONFIG | DCLK));
+	/* set conf_done and nstatus to port in */
+	bfin_write_PORTGIO_DIR(
+		bfin_read_PORTGIO_DIR() & ~(CONF_DONE | NSTATUS));
+	bfin_write_PORTGIO_INEN(
+		bfin_read_PORTGIO_INEN() & ~(DATA | NCONFIG | DCLK));
 	bfin_write_PORTGIO_INEN(bfin_read_PORTGIO_INEN() | CONF_DONE | NSTATUS);

-	bfin_write_PORTGIO_CLEAR(NCONFIG);       //reset fpga during configuration holds nCONFIG low
-	udelay(40);                            //Tcfg ~40us delay
-	bfin_write_PORTGIO_SET(NCONFIG);        //transition nCONFIG to high - reset end.
-	udelay(40);                            //Tcf2ck ~40us delay
+	/* reset fpga during configuration holds nCONFIG low */
+	bfin_write_PORTGIO_CLEAR(NCONFIG);
+	udelay(40);		/* Tcfg ~40us delay */
+	/* transition nCONFIG to high - reset end. */
+	bfin_write_PORTGIO_SET(NCONFIG);
+	udelay(40);		/* Tcf2ck ~40us delay */
 	if (!(bfin_read_PORTGIO() & NSTATUS))
-		return -EIO;                           //report reset faill - Tcf2st1 pass
+		return -EIO;	/* report reset faill - Tcf2st1 pass */

 #if 0
 	if (!(bfin_read_PORTGIO() & CONF_DONE))
 		return -EIO;
 #endif
 	bfin_write_PORTGIO_CLEAR(DCLK);
-	for (i=0; i<size; i++) { // loop EP2OUT buffer data to FPGA
+	for (i = 0; i < size; i++) {	/* loop EP2OUT buffer data to FPGA */
 		int j;
-		u8 byte = data[i];
-		for (j=0; j<8; j++)         //send the configuration data through the DATA0 pin one bit at a time.
+		u8 __u8 = data[i];
+		/*
+		 * Send the configuration data through the DATA0 pin
+		 * one bit at a time.
+		 */
+		for (j = 0; j < 8; j++)
 		{
-			if (byte & 1)
+			if (__u8 & 1)
 				bfin_write_PORTGIO_SET(DATA);
 			else
 				bfin_write_PORTGIO_CLEAR(DATA);
-			byte >>= 1;
+			__u8 >>= 1;
 			bfin_write_PORTGIO_SET(DCLK);
 			bfin_write_PORTGIO_CLEAR(DCLK);
 		}
 		if (!(bfin_read_PORTGIO() & NSTATUS))
-			return -EIO;                                   //check the nSTATUS
+			return -EIO;	/* check the nSTATUS */
 	}
 	bfin_write_PORTGIO_CLEAR(DATA);
 	udelay(1);
@@ -455,20 +485,29 @@ static int __init xpp_mmap_load_fpga(u8 *data, size_t size)
 	 * some pins that were used only during initialization
 	 * to be used for debugging from now on.
 	 */
-	bfin_write_PORTGIO_DIR(bfin_read_PORTGIO_DIR() | DEBUG_GPIO1 | DEBUG_GPIO2); //set to port out
-	bfin_write_PORTG_FER(bfin_read_PORTG_FER() & ~(DEBUG_GPIO1 | DEBUG_GPIO2));
-	bfin_write_PORTGIO_INEN(bfin_read_PORTGIO_INEN() & ~(DEBUG_GPIO1 | DEBUG_GPIO2));
+	/* set to port out */
+	bfin_write_PORTGIO_DIR(
+		bfin_read_PORTGIO_DIR() | DEBUG_GPIO1 | DEBUG_GPIO2);
+	bfin_write_PORTG_FER(bfin_read_PORTG_FER() &
+			     ~(DEBUG_GPIO1 | DEBUG_GPIO2));
+	bfin_write_PORTGIO_INEN(bfin_read_PORTGIO_INEN() &
+				~(DEBUG_GPIO1 | DEBUG_GPIO2));
 #endif
-	udelay(40); //tCD2UM - CONF_DONE high to user mode
+	udelay(40);		/* tCD2UM - CONF_DONE high to user mode */
 	return 0;
 }

 static void __exit xpp_mmap_unload_fpga(void)
 {
-        bfin_write_PORTGIO_CLEAR(NCONFIG);       //reset fpga during configuration holds nCONFIG low
-	udelay(40);                            //Tcfg ~40us delay	
-	bfin_write_PORTGIO_DIR(bfin_read_PORTGIO_DIR() & ~( DATA | NCONFIG | DCLK));	//disable output pin
-	bfin_write_PORTGIO_INEN(bfin_read_PORTGIO_INEN() & ~( CONF_DONE | NSTATUS));//disable input buffer
+	/* reset fpga during configuration holds nCONFIG low */
+	bfin_write_PORTGIO_CLEAR(NCONFIG);
+	udelay(40);		/* Tcfg ~40us delay */
+	/* disable output pin */
+	bfin_write_PORTGIO_DIR(
+		bfin_read_PORTGIO_DIR() & ~(DATA | NCONFIG | DCLK));
+	/* disable input buffer */
+	bfin_write_PORTGIO_INEN(
+		bfin_read_PORTGIO_INEN() & ~(CONF_DONE | NSTATUS));
 	INFO("FPGA Firmware unloaded\n");
 }

@@ -476,7 +515,8 @@ static int __init xpp_mmap_load_firmware(void)
 {
 	const struct firmware *fw;
 	int ret;
-	if ((ret = request_firmware(&fw, "astribank.bin", &astribank_dev.dev)) < 0)
+	if ((ret =
+	     request_firmware(&fw, "astribank.bin", &astribank_dev.dev)) < 0)
 		return ret;
 	xpp_mmap_load_fpga(fw->data, fw->size);
 	release_firmware(fw);
@@ -498,29 +538,33 @@ static int __init xpp_mmap_init(void)
 		ERR("xpp_mmap_load_firmware() failed, errno=%d\n", ret);
 		goto fail_fw;
 	}
-	
-	if ((ret = request_irq(FPGA_RX_IRQ, xpp_mmap_rx_irq, IRQF_TRIGGER_RISING, "xpp_mmap_rx", NULL)) < 0) {
+
+	if ((ret =
+	     request_irq(FPGA_RX_IRQ, xpp_mmap_rx_irq, IRQF_TRIGGER_RISING,
+			 "xpp_mmap_rx", NULL)) < 0) {
 		ERR("Unable to attach to RX interrupt %d\n", FPGA_RX_IRQ);
 		goto fail_irq_rx;
 	}
-	if ((ret = request_irq(FPGA_TX_IRQ, xpp_mmap_tx_irq, IRQF_TRIGGER_RISING, "xpp_mmap_tx", NULL)) < 0) {
+	if ((ret =
+	     request_irq(FPGA_TX_IRQ, xpp_mmap_tx_irq, IRQF_TRIGGER_RISING,
+			 "xpp_mmap_tx", NULL)) < 0) {
 		ERR("Unable to attach to TX interrupt %d\n", FPGA_TX_IRQ);
 		goto fail_irq_tx;
 	}
-	if (!request_region((resource_size_t)FPGA_BASE_ADDR, 8, "xpp_mmap")) {
+	if (!request_region((resource_size_t) FPGA_BASE_ADDR, 8, "xpp_mmap")) {
 		ERR("Unable to request memory region at %p\n", FPGA_BASE_ADDR);
 		goto fail_region;
 	}
-	outw(AS_BF_MODE, FPGA_BASE_ADDR + 4);	
+	outw(AS_BF_MODE, FPGA_BASE_ADDR + 4);

-	xframe_cache = kmem_cache_create("xframe_cache",
-			sizeof(xframe_t) + XFRAME_DATASIZE,
-			0, 0,
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
-			NULL, 
+	xframe_cache =
+	    kmem_cache_create("xframe_cache",
+			      sizeof(xframe_t) + XFRAME_DATASIZE, 0, 0,
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)
+			      NULL,
 #endif
-			NULL);
-	if(!xframe_cache) {
+			      NULL);
+	if (!xframe_cache) {
 		ret = -ENOMEM;
 		goto fail_cache;
 	}
@@ -532,9 +576,11 @@ static int __init xpp_mmap_init(void)
 	}
 	strncpy(global_xbus->connector, "mmap", XBUS_DESCLEN);
 	strncpy(global_xbus->label, "mmap:0", LABEL_SIZE);
-	
+
 	xframe_queue_init(&txpool, 10, 200, "mmap_txpool", global_xbus);
-	if (!(proc_entry = create_proc_entry("xpp_mmap", 0, global_xbus->proc_xbus_dir))) {
+	if (!
+	    (proc_entry =
+	     create_proc_entry("xpp_mmap", 0, global_xbus->proc_xbus_dir))) {
 		ERR("create_proc_entry() failed\n");
 		ret = -EINVAL;
 		goto fail_proc;
@@ -552,7 +598,7 @@ fail_proc:
 fail_xbus:
 	kmem_cache_destroy(xframe_cache);
 fail_cache:
-	release_region((resource_size_t)FPGA_BASE_ADDR, 8);
+	release_region((resource_size_t) FPGA_BASE_ADDR, 8);
 fail_region:
 	free_irq(FPGA_TX_IRQ, NULL);
 fail_irq_tx:
@@ -579,7 +625,7 @@ static void __exit xpp_mmap_exit(void)
 	xbus_disconnect(xbus);
 	kmem_cache_destroy(xframe_cache);

-	release_region((resource_size_t)FPGA_BASE_ADDR, 8);
+	release_region((resource_size_t) FPGA_BASE_ADDR, 8);
 	free_irq(FPGA_RX_IRQ, NULL);
 	free_irq(FPGA_TX_IRQ, NULL);

--- a/drivers/dahdi/xpp/parport_debug.c
+++ b/drivers/dahdi/xpp/parport_debug.c
@@ -20,31 +20,26 @@
 *
 */
 #include <linux/version.h>
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
-#  warning "This module is tested only with 2.6 kernels"
-#endif
-
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/parport.h>
 #include "parport_debug.h"

-static struct parport	*debug_sync_parport = NULL;
-static int		parport_toggles[8];	/* 8 bit flip-flop */
+static struct parport *debug_sync_parport;
+static int parport_toggles[8];	/* 8 bit flip-flop */

 void flip_parport_bit(unsigned char bitnum)
 {
-	static unsigned char	last_value;
+	static unsigned char last_value;
 	DEFINE_SPINLOCK(lock);
-	unsigned long	flags;
-	unsigned char	mask;
-	unsigned char	value;
+	unsigned long flags;
+	unsigned char mask;
+	unsigned char value;

-	if(!debug_sync_parport) {
-		if(printk_ratelimit()) {
+	if (!debug_sync_parport) {
+		if (printk_ratelimit()) {
 			printk(KERN_NOTICE "%s: no debug parallel port\n",
-				THIS_MODULE->name);
+			       THIS_MODULE->name);
 		}
 		return;
 	}
@@ -52,7 +47,7 @@ void flip_parport_bit(unsigned char bitnum)
 	mask = 1 << bitnum;
 	spin_lock_irqsave(&lock, flags);
 	value = last_value & ~mask;
-	if(parport_toggles[bitnum] % 2)	/* square wave */
+	if (parport_toggles[bitnum] % 2)	/* square wave */
 		value |= mask;
 	last_value = value;
 	parport_toggles[bitnum]++;
@@ -63,10 +58,11 @@ EXPORT_SYMBOL(flip_parport_bit);

 static void parport_attach(struct parport *port)
 {
-	printk(KERN_INFO "%s: Using %s for debugging\n", THIS_MODULE->name, port->name);
-	if(debug_sync_parport) {
+	printk(KERN_INFO "%s: Using %s for debugging\n", THIS_MODULE->name,
+	       port->name);
+	if (debug_sync_parport) {
 		printk(KERN_ERR "%s: Using %s, ignore new attachment %s\n",
-			THIS_MODULE->name, debug_sync_parport->name, port->name);
+		       THIS_MODULE->name, debug_sync_parport->name, port->name);
 		return;
 	}
 	parport_get_port(port);
@@ -76,16 +72,16 @@ static void parport_attach(struct parport *port)
 static void parport_detach(struct parport *port)
 {
 	printk(KERN_INFO "%s: Releasing %s\n", THIS_MODULE->name, port->name);
-	if(debug_sync_parport != port) {
+	if (debug_sync_parport != port) {
 		printk(KERN_ERR "%s: Using %s, ignore new detachment %s\n",
-			THIS_MODULE->name, debug_sync_parport->name, port->name);
+		       THIS_MODULE->name, debug_sync_parport->name, port->name);
 		return;
 	}
 	parport_put_port(debug_sync_parport);
 	debug_sync_parport = NULL;
 }

-static struct parport_driver	debug_parport_driver = {
+static struct parport_driver debug_parport_driver = {
 	.name = "parport_debug",
 	.attach = parport_attach,
 	.detach = parport_detach,
@@ -93,7 +89,7 @@ static struct parport_driver	debug_parport_driver = {

 int __init parallel_dbg_init(void)
 {
-	int	ret;
+	int ret;

 	ret = parport_register_driver(&debug_parport_driver);
 	return ret;
--- a/drivers/dahdi/xpp/parport_debug.h
+++ b/drivers/dahdi/xpp/parport_debug.h
@@ -28,4 +28,4 @@ void flip_parport_bit(unsigned char bitnum);
 #define flip_parport_bit(bitnum)
 #endif

-#endif	/* PARPORT_DEBUG_H */
+#endif /* PARPORT_DEBUG_H */
--- a/drivers/dahdi/xpp/print_fxo_modes.c
+++ b/drivers/dahdi/xpp/print_fxo_modes.c
@@ -3,30 +3,35 @@
 int main(int argc, char *argv[])
 {
 	size_t i;
-	
-	for (i=0; i<(sizeof(fxo_modes)/sizeof(struct fxo_mode)); i++) {
-		if (fxo_modes[i].name == NULL) break;
-		int reg16=0, reg26=0, reg30=0, reg31=0x20;
-		char ring_osc[BUFSIZ]="", ring_x[BUFSIZ] = "";
-		
+
+	for (i = 0; i < (sizeof(fxo_modes) / sizeof(struct fxo_mode)); i++) {
+		if (fxo_modes[i].name == NULL)
+			break;
+		int reg16 = 0, reg26 = 0, reg30 = 0, reg31 = 0x20;
+		char ring_osc[BUFSIZ] = "", ring_x[BUFSIZ] = "";
+
 		reg16 |= (fxo_modes[i].ohs << 6);
 		reg16 |= (fxo_modes[i].rz << 1);
 		reg16 |= (fxo_modes[i].rt);
-		
+
 		reg26 |= (fxo_modes[i].dcv << 6);
 		reg26 |= (fxo_modes[i].mini << 4);
 		reg26 |= (fxo_modes[i].ilim << 1);
-		
+
 		reg30 = (fxo_modes[i].acim);
-		
+
 		reg31 |= (fxo_modes[i].ohs2 << 3);

 		if (fxo_modes[i].ring_osc)
-			snprintf(ring_osc, BUFSIZ, "ring_osc=%04X", fxo_modes[i].ring_osc);
+			snprintf(ring_osc, BUFSIZ, "ring_osc=%04X",
+				 fxo_modes[i].ring_osc);
 		if (fxo_modes[i].ring_x)
-			snprintf(ring_x, BUFSIZ, "ring_x=%04X", fxo_modes[i].ring_x);
-		printf("%-15s\treg16=%02X\treg26=%02X\treg30=%02X\treg31=%02X\t%s\t%s\n",
-		       fxo_modes[i].name, reg16, reg26, reg30, reg31, ring_osc, ring_x);
+			snprintf(ring_x, BUFSIZ, "ring_x=%04X",
+				 fxo_modes[i].ring_x);
+		printf("%-15s\treg16=%02X\treg26=%02X\treg30=%02X\t"
+			"reg31=%02X\t%s\t%s\n",
+			fxo_modes[i].name, reg16, reg26, reg30, reg31,
+			ring_osc, ring_x);
 	}
 	return 0;
 }
--- a/drivers/dahdi/xpp/xbus-core.c
+++ b/drivers/dahdi/xpp/xbus-core.c
--- a/drivers/dahdi/xpp/xbus-core.h
+++ b/drivers/dahdi/xpp/xbus-core.h
@@ -29,8 +29,9 @@
 #include "xframe_queue.h"
 #include "xbus-pcm.h"

-#define	MAX_BUSES		32
-#define	XFRAME_DATASIZE		512
+#define	MAX_BUSES	128
+#define	XFRAME_DATASIZE	512
+#define	MAX_ENV_STR	40

 /* forward declarations */
 struct xbus_workqueue;
@@ -38,10 +39,10 @@ struct xbus_workqueue;
 #ifdef	__KERNEL__

 struct xbus_ops {
-	int (*xframe_send_pcm)(xbus_t *xbus, xframe_t *xframe);
-	int (*xframe_send_cmd)(xbus_t *xbus, xframe_t *xframe);
-	xframe_t *(*alloc_xframe)(xbus_t *xbus, gfp_t gfp_flags);
-	void (*free_xframe)(xbus_t *xbus, xframe_t *xframe);
+	int (*xframe_send_pcm) (xbus_t *xbus, xframe_t *xframe);
+	int (*xframe_send_cmd) (xbus_t *xbus, xframe_t *xframe);
+	xframe_t *(*alloc_xframe) (xbus_t *xbus, gfp_t gfp_flags);
+	void (*free_xframe) (xbus_t *xbus, xframe_t *xframe);
 };

 /*
@@ -66,19 +67,11 @@ enum {

 /* yucky, make an instance so we can size it... */
 static struct xbus_counters {
-	char	*name;
+	char *name;
 } xbus_counters[] = {
-	C_(UNITS),
-	C_(TX_XFRAME_PCM),
-	C_(RX_XFRAME_PCM),
-	C_(TX_PACK_PCM),
-	C_(RX_PACK_PCM),
-	C_(TX_BYTES),
-	C_(RX_BYTES),
-	C_(TX_PCM_FRAG),
-	C_(RX_CMD),
-	C_(TX_CMD),
-};
+C_(UNITS), C_(TX_XFRAME_PCM), C_(RX_XFRAME_PCM), C_(TX_PACK_PCM),
+	    C_(RX_PACK_PCM), C_(TX_BYTES), C_(RX_BYTES),
+	    C_(TX_PCM_FRAG), C_(RX_CMD), C_(TX_CMD),};

 #undef C_

@@ -98,16 +91,17 @@ enum xbus_state {
 const char *xbus_statename(enum xbus_state st);

 struct xbus_transport {
-	struct xbus_ops		*ops;
-	void			*priv;
-	struct device		*transport_device;
-	ushort			max_send_size;
-	enum xbus_state		xbus_state;
-	unsigned long		transport_flags;
-	spinlock_t		state_lock;
-	atomic_t		transport_refcount;
-	wait_queue_head_t	transport_unused;
-	spinlock_t		lock;
+	struct xbus_ops *ops;
+	void *priv;
+	struct device *transport_device;
+	ushort max_send_size;
+	enum xbus_state xbus_state;
+	unsigned long transport_flags;
+	spinlock_t state_lock;
+	atomic_t transport_refcount;
+	wait_queue_head_t transport_unused;
+	spinlock_t lock;
+	char model_string[MAX_ENV_STR];
 };

 #define	MAX_SEND_SIZE(xbus)	((xbus)->transport.max_send_size)
@@ -116,7 +110,8 @@ struct xbus_transport {
 #define	TRANSPORT_EXIST(xbus)	((xbus)->transport.ops != NULL)

 #define	XBUS_FLAG_CONNECTED	0
-#define	XBUS_FLAGS(xbus, flg)	test_bit(XBUS_FLAG_ ## flg, &((xbus)->transport.transport_flags))
+#define	XBUS_FLAGS(xbus, flg) \
+	test_bit(XBUS_FLAG_ ## flg, &((xbus)->transport.transport_flags))

 struct xbus_ops *transportops_get(xbus_t *xbus);
 void transportops_put(xbus_t *xbus);
@@ -125,35 +120,39 @@ void transportops_put(xbus_t *xbus);
 * Encapsulate all poll related data of a single xbus.
 */
 struct xbus_workqueue {
-	struct workqueue_struct	*wq;
-	struct work_struct	xpds_init_work;
-	bool			xpds_init_done;
-	struct list_head	card_list;
-	int			num_units;
-	int			num_units_initialized;
-	wait_queue_head_t	wait_for_xpd_initialization;
-	spinlock_t		worker_lock;
-	struct semaphore	running_initialization;
+	struct workqueue_struct *wq;
+	struct work_struct xpds_init_work;
+	bool xpds_init_done;
+	struct list_head card_list;
+	int num_units;
+	int num_units_initialized;
+	wait_queue_head_t wait_for_xpd_initialization;
+	spinlock_t worker_lock;
+	struct semaphore running_initialization;
 };

 /*
 * Allocate/Free an xframe from pools of empty xframes.
- * Calls to {get,put}_xframe are wrapped in
+ * Calls to {get, put}_xframe are wrapped in
 * the macros bellow, so we take/return it
 * to the correct pool.
 */
 xframe_t *get_xframe(struct xframe_queue *q);
 void put_xframe(struct xframe_queue *q, xframe_t *xframe);

-#define	ALLOC_SEND_XFRAME(xbus)	get_xframe(&(xbus)->send_pool)
-#define	ALLOC_RECV_XFRAME(xbus)	get_xframe(&(xbus)->receive_pool)
-#define	FREE_SEND_XFRAME(xbus, xframe)	put_xframe(&(xbus)->send_pool, (xframe))
-#define	FREE_RECV_XFRAME(xbus, xframe)	put_xframe(&(xbus)->receive_pool, (xframe))
+#define	ALLOC_SEND_XFRAME(xbus) \
+		get_xframe(&(xbus)->send_pool)
+#define	ALLOC_RECV_XFRAME(xbus) \
+		get_xframe(&(xbus)->receive_pool)
+#define	FREE_SEND_XFRAME(xbus, xframe) \
+		put_xframe(&(xbus)->send_pool, (xframe))
+#define	FREE_RECV_XFRAME(xbus, xframe) \
+		put_xframe(&(xbus)->receive_pool, (xframe))

-xbus_t	*xbus_num(uint num);
-xbus_t	*get_xbus(const char *msg, uint num);
-void	put_xbus(const char *msg, xbus_t *xbus);
-int	refcount_xbus(xbus_t *xbus);
+xbus_t *xbus_num(uint num);
+xbus_t *get_xbus(const char *msg, uint num);
+void put_xbus(const char *msg, xbus_t *xbus);
+int refcount_xbus(xbus_t *xbus);

 /*
 * Echo canceller related data
@@ -161,17 +160,17 @@ int	refcount_xbus(xbus_t *xbus);
 #define	ECHO_TIMESLOTS	128

 struct echoops {
-	int	(*ec_set)(xpd_t *xpd, int pos, bool on);
-	int	(*ec_get)(xpd_t *xpd, int pos);
-	int	(*ec_update)(xbus_t *xbus);
-	void	(*ec_dump)(xbus_t *xbus);
+	int (*ec_set) (xpd_t *xpd, int pos, bool on);
+	int (*ec_get) (xpd_t *xpd, int pos);
+	int (*ec_update) (xbus_t *xbus);
+	void (*ec_dump) (xbus_t *xbus);
 };

 struct xbus_echo_state {
-	const struct echoops	*echoops;
-	byte			timeslots[ECHO_TIMESLOTS];
-	int			xpd_idx;
-	struct device_attribute	*da[MAX_XPDS];
+	const struct echoops *echoops;
+	__u8 timeslots[ECHO_TIMESLOTS];
+	int xpd_idx;
+	struct device_attribute *da[MAX_XPDS];
 };
 #define	ECHOOPS(xbus)			((xbus)->echo_state.echoops)
 #define	EC_METHOD(name, xbus)		(ECHOOPS(xbus)->name)
@@ -181,125 +180,128 @@ struct xbus_echo_state {
 * An xbus is a transport layer for Xorcom Protocol commands
 */
 struct xbus {
-	char			busname[XBUS_NAMELEN];	/* set by xbus_new() */
+	char busname[XBUS_NAMELEN];	/* set by xbus_new() */

 	/* low-level bus drivers set these 2 fields */
-	char			connector[XBUS_DESCLEN];
-	char			label[LABEL_SIZE];
-	byte			revision;		/* Protocol revision */
-	struct xbus_transport	transport;
+	char connector[XBUS_DESCLEN];
+	char label[LABEL_SIZE];
+	__u8 revision;		/* Protocol revision */
+	struct xbus_transport transport;
+	struct dahdi_device *ddev;

-	int			num;
-	struct xpd		*xpds[MAX_XPDS];
-	struct xbus_echo_state	echo_state;
+	int num;
+	struct xpd *xpds[MAX_XPDS];
+	struct xbus_echo_state echo_state;

-	int			command_tick_counter;
-	int			usec_nosend;		/* Firmware flow control */
-	struct xframe_queue	command_queue;
-	wait_queue_head_t	command_queue_empty;
+	int command_tick_counter;
+	int usec_nosend;	/* Firmware flow control */
+	struct xframe_queue command_queue;
+	wait_queue_head_t command_queue_empty;

-	struct xframe_queue	send_pool;		/* empty xframes for send */
-	struct xframe_queue	receive_pool;		/* empty xframes for receive */
+	struct xframe_queue send_pool;	/* empty xframes for send */
+	struct xframe_queue receive_pool;	/* empty xframes for receive */

 	/* tasklet processing */
-	struct xframe_queue	receive_queue;
-	struct tasklet_struct	receive_tasklet;
-	int			cpu_rcv_intr[NR_CPUS];
-	int			cpu_rcv_tasklet[NR_CPUS];
+	struct xframe_queue receive_queue;
+	struct tasklet_struct receive_tasklet;
+	int cpu_rcv_intr[NR_CPUS];
+	int cpu_rcv_tasklet[NR_CPUS];

 	struct quirks {
 		unsigned int has_fxo:1;
 		unsigned int has_digital_span:1;
-	}			quirks;
-	bool			self_ticking;
-	enum sync_mode		sync_mode;
+	} quirks;
+	bool self_ticking;
+	enum sync_mode sync_mode;
 	/* Managed by low-level drivers: */
-	enum sync_mode		sync_mode_default;
-	struct timer_list	command_timer;
-	unsigned int		xbus_frag_count;
-	struct xframe_queue	pcm_tospan;
+	enum sync_mode sync_mode_default;
+	struct timer_list command_timer;
+	unsigned int xbus_frag_count;
+	struct xframe_queue pcm_tospan;

-	struct xpp_ticker	ticker;		/* for tick rate */
-	struct xpp_drift	drift;		/* for tick offset */
+	struct xpp_ticker ticker;	/* for tick rate */
+	struct xpp_drift drift;	/* for tick offset */

-	atomic_t		pcm_rx_counter;
-	unsigned int		global_counter;
+	atomic_t pcm_rx_counter;
+	unsigned int global_counter;

 	/* Device-Model */
-	struct device		astribank;
+	struct device astribank;
 #define	dev_to_xbus(dev)	container_of(dev, struct xbus, astribank)
-	struct kref		kref;
+	struct kref kref;
 #define kref_to_xbus(k) container_of(k, struct xbus, kref)

-	spinlock_t		lock;
+	spinlock_t lock;

 	/* PCM metrics */
-	struct timeval		last_tx_sync;
-	struct timeval		last_rx_sync;
-	unsigned long		max_tx_sync;
-	unsigned long		min_tx_sync;
-	unsigned long		max_rx_sync;
-	unsigned long		min_rx_sync;
-	unsigned long		max_rx_process;		/* packet processing time (usec) */
+	struct timeval last_tx_sync;
+	struct timeval last_rx_sync;
+	unsigned long max_tx_sync;
+	unsigned long min_tx_sync;
+	unsigned long max_rx_sync;
+	unsigned long min_rx_sync;
+	unsigned long max_rx_process;	/* packet processing time (usec) */
 #ifdef	SAMPLE_TICKS
 #define	SAMPLE_SIZE	1000
-	int			sample_ticks[SAMPLE_SIZE];
-	bool			sample_running;
-	int			sample_pos;
+	int sample_ticks[SAMPLE_SIZE];
+	bool sample_running;
+	int sample_pos;
 #endif

-	struct xbus_workqueue	worker;
+	struct xbus_workqueue worker;

 	/*
 	 * Sync adjustment
 	 */
-	int			sync_adjustment;
-	int			sync_adjustment_offset;
-	long			pll_updated_at;
+	int sync_adjustment;
+	int sync_adjustment_offset;
+	long pll_updated_at;

-	atomic_t		num_xpds;
+	atomic_t num_xpds;

 #ifdef CONFIG_PROC_FS
-	struct proc_dir_entry	*proc_xbus_dir;
-	struct proc_dir_entry	*proc_xbus_summary;
+	struct proc_dir_entry *proc_xbus_dir;
+	struct proc_dir_entry *proc_xbus_summary;
 #ifdef	PROTOCOL_DEBUG
-	struct proc_dir_entry	*proc_xbus_command;
+	struct proc_dir_entry *proc_xbus_command;
 #endif
 #endif

 	/* statistics */
-	int		counters[XBUS_COUNTER_MAX];
+	int counters[XBUS_COUNTER_MAX];
 };
 #endif

 #define	XFRAME_MAGIC	123456L

 struct xframe {
-	unsigned long		xframe_magic;
-	struct list_head	frame_list;
-	atomic_t		frame_len;
-	xbus_t			*xbus;
-	struct timeval		tv_created;
-	struct timeval		tv_queued;
-	struct timeval		tv_submitted;
-	struct timeval		tv_received;
+	unsigned long xframe_magic;
+	struct list_head frame_list;
+	atomic_t frame_len;
+	xbus_t *xbus;
+	struct timeval tv_created;
+	struct timeval tv_queued;
+	struct timeval tv_submitted;
+	struct timeval tv_received;
 	/* filled by transport layer */
-	size_t			frame_maxlen;
-	byte			*packets;	/* max XFRAME_DATASIZE */
-	byte			*first_free;
-	int			usec_towait;	/* prevent overflowing AB */
-	void			*priv;
+	size_t frame_maxlen;
+	__u8 *packets;		/* max XFRAME_DATASIZE */
+	__u8 *first_free;
+	int usec_towait;	/* prevent overflowing AB */
+	void *priv;
 };

-void xframe_init(xbus_t *xbus, xframe_t *xframe, void *buf, size_t maxsize, void *priv);
+void xframe_init(xbus_t *xbus, xframe_t *xframe, void *buf, size_t maxsize,
+		 void *priv);

 #define XFRAME_LEN(frame)	atomic_read(&(frame)->frame_len)

-int xbus_core_init(void);		/* Initializer */
-void xbus_core_shutdown(void);		/* Terminator */
+int xbus_core_init(void);	/* Initializer */
+void xbus_core_shutdown(void);	/* Terminator */

 /* Frame handling */
-void dump_xframe(const char msg[], const xbus_t *xbus, const xframe_t *xframe, int debug);
+void dump_xframe(const char msg[], const xbus_t *xbus, const xframe_t *xframe,
+		 int debug);
 int send_cmd_frame(xbus_t *xbus, xframe_t *xframe);

 /*
@@ -313,54 +315,45 @@ xpacket_t *xframe_next_packet(xframe_t *xframe, int len);
 /*
 * Map: unit+subunit <--> index in xbus->xpds[]
 */
-#define	XPD_IDX(unit,subunit)	((unit) * MAX_SUBUNIT + (subunit))
+#define	XPD_IDX(unit, subunit)	((unit) * MAX_SUBUNIT + (subunit))
 #define	XBUS_UNIT(idx)		((idx) / MAX_SUBUNIT)
 #define	XBUS_SUBUNIT(idx)	((idx) % MAX_SUBUNIT)

-xpd_t	*xpd_of(const xbus_t *xbus, int xpd_num);
-xpd_t	*xpd_byaddr(const xbus_t *xbus, uint unit, uint subunit);
-int	xbus_check_unique(xbus_t *xbus);
-bool	xbus_setstate(xbus_t *xbus, enum xbus_state newstate);
-bool	xbus_setflags(xbus_t *xbus, int flagbit, bool on);
-xbus_t	*xbus_new(struct xbus_ops *ops, ushort max_send_size, struct device *transport_device, void *priv);
-void	xbus_free(xbus_t *xbus);
-int	xbus_connect(xbus_t *xbus);
-int	xbus_activate(xbus_t *xbus);
-void	xbus_deactivate(xbus_t *xbus);
-void	xbus_disconnect(xbus_t *xbus);
-void	xbus_receive_xframe(xbus_t *xbus, xframe_t *xframe);
-int	xbus_process_worker(xbus_t *xbus);
-int	waitfor_xpds(xbus_t *xbus, char *buf);
+xpd_t *xpd_of(const xbus_t *xbus, int xpd_num);
+xpd_t *xpd_byaddr(const xbus_t *xbus, uint unit, uint subunit);
+int xbus_check_unique(xbus_t *xbus);
+bool xbus_setstate(xbus_t *xbus, enum xbus_state newstate);
+bool xbus_setflags(xbus_t *xbus, int flagbit, bool on);
+xbus_t *xbus_new(struct xbus_ops *ops, ushort max_send_size,
+		 struct device *transport_device, void *priv);
+void xbus_free(xbus_t *xbus);
+int xbus_connect(xbus_t *xbus);
+int xbus_activate(xbus_t *xbus);
+void xbus_deactivate(xbus_t *xbus);
+void xbus_disconnect(xbus_t *xbus);
+void xbus_receive_xframe(xbus_t *xbus, xframe_t *xframe);
+int xbus_process_worker(xbus_t *xbus);
+int waitfor_xpds(xbus_t *xbus, char *buf);

-int	xbus_xpd_bind(xbus_t *xbus, xpd_t *xpd, int unit, int subunit);
-int	xbus_xpd_unbind(xbus_t *xbus, xpd_t *xpd);
+int xbus_xpd_bind(xbus_t *xbus, xpd_t *xpd, int unit, int subunit);
+int xbus_xpd_unbind(xbus_t *xbus, xpd_t *xpd);

 /* sysfs */
-int	xpd_device_register(xbus_t *xbus, xpd_t *xpd);
-void	xpd_device_unregister(xpd_t *xpd);
-int	echocancel_xpd(xpd_t *xpd, int on);
+int xpd_device_register(xbus_t *xbus, xpd_t *xpd);
+void xpd_device_unregister(xpd_t *xpd);
+int echocancel_xpd(xpd_t *xpd, int on);

-int	xpp_driver_init(void);
-void	xpp_driver_exit(void);
-int	xbus_sysfs_transport_create(xbus_t *xbus);
-void	xbus_sysfs_transport_remove(xbus_t *xbus);
-int	xbus_sysfs_create(xbus_t *xbus);
-void	xbus_sysfs_remove(xbus_t *xbus);
+int xbus_is_registered(xbus_t *xbus);
+int xbus_register_dahdi_device(xbus_t *xbus);
+void xbus_unregister_dahdi_device(xbus_t *xbus);

-#ifdef	OLD_HOTPLUG_SUPPORT_269
-/* Copy from new kernels lib/kobject_uevent.c */
-enum kobject_action {
-	KOBJ_ADD,
-	KOBJ_REMOVE,
-	KOBJ_CHANGE,
-	KOBJ_MOUNT,
-	KOBJ_UMOUNT,
-	KOBJ_OFFLINE,
-	KOBJ_ONLINE,
-};
-#endif
+int xpp_driver_init(void);
+void xpp_driver_exit(void);
+int xbus_sysfs_transport_create(xbus_t *xbus);
+void xbus_sysfs_transport_remove(xbus_t *xbus);
+int xbus_sysfs_create(xbus_t *xbus);
+void xbus_sysfs_remove(xbus_t *xbus);

-void	astribank_uevent_send(xbus_t *xbus, enum kobject_action act);
-
-#endif	/* XBUS_CORE_H */
+void astribank_uevent_send(xbus_t *xbus, enum kobject_action act);

+#endif /* XBUS_CORE_H */
--- a/drivers/dahdi/xpp/xbus-pcm.c
+++ b/drivers/dahdi/xpp/xbus-pcm.c
--- a/drivers/dahdi/xpp/xbus-pcm.h
+++ b/drivers/dahdi/xpp/xbus-pcm.h
@@ -33,10 +33,10 @@
 #ifdef	__KERNEL__

 enum sync_mode {
-	SYNC_MODE_NONE	= 0x00,
-	SYNC_MODE_AB	= 0x01,		/* Astribank sync */
-	SYNC_MODE_PLL	= 0x03,		/* Adjust XPD's PLL according to HOST */
-	SYNC_MODE_QUERY	= 0x80,
+	SYNC_MODE_NONE = 0x00,
+	SYNC_MODE_AB = 0x01,	/* Astribank sync */
+	SYNC_MODE_PLL = 0x03,	/* Adjust XPD's PLL according to HOST */
+	SYNC_MODE_QUERY = 0x80,
 };

 /*
@@ -46,7 +46,7 @@ enum sync_mode {
 * time representations.
 */
 struct xpp_timestamp {
-	struct timeval	tv;
+	struct timeval tv;
 };

 /*
@@ -58,12 +58,12 @@ struct xpp_timestamp {
 *     from other dahdi devices).
 */
 struct xpp_ticker {		/* for rate calculation */
-	int			count;
-	int			cycle;
-	struct xpp_timestamp	first_sample;
-	struct xpp_timestamp	last_sample;
-	int			tick_period;	/* usec/tick */
-	spinlock_t		lock;
+	int count;
+	int cycle;
+	struct xpp_timestamp first_sample;
+	struct xpp_timestamp last_sample;
+	int tick_period;	/* usec/tick */
+	spinlock_t lock;
 };

 /*
@@ -71,66 +71,65 @@ struct xpp_ticker {		/* for rate calculation */
 * xbus ticker to a reference ticker.
 */
 struct xpp_drift {
-	int			delta_tick;		/* from ref_ticker */
-	int			lost_ticks;		/* occurances */
-	int			lost_tick_count;
-	int			sync_inaccuracy;
-	struct xpp_timestamp	last_lost_tick;
-	long			delta_sum;
-	int			offset_prev;
-	int			offset_range;
-	int			offset_min;
-	int			offset_max;
-	int			min_speed;
-	int			max_speed;
-	spinlock_t		lock;
+	int delta_tick;		/* from ref_ticker */
+	int lost_ticks;		/* occurances */
+	int lost_tick_count;
+	int sync_inaccuracy;
+	struct xpp_timestamp last_lost_tick;
+	long delta_sum;
+	int offset_prev;
+	int offset_range;
+	int offset_min;
+	int offset_max;
+	int min_speed;
+	int max_speed;
+	spinlock_t lock;
 };

 void xpp_drift_init(xbus_t *xbus);

-static inline long usec_diff(const struct timeval *tv1, const struct timeval *tv2)
+static inline long usec_diff(const struct timeval *tv1,
+			     const struct timeval *tv2)
 {
-	long			diff_sec;
-	long			diff_usec;
+	long diff_sec;
+	long diff_usec;

 	diff_sec = tv1->tv_sec - tv2->tv_sec;
 	diff_usec = tv1->tv_usec - tv2->tv_usec;
 	return diff_sec * 1000000 + diff_usec;
 }

-
-int		xbus_pcm_init(void *top);
-void		xbus_pcm_shutdown(void);
-int		send_pcm_frame(xbus_t *xbus, xframe_t *xframe);
-void		pcm_recompute(xpd_t *xpd, xpp_line_t tmp_pcm_mask);
-void		xframe_receive_pcm(xbus_t *xbus, xframe_t *xframe);
-void		update_wanted_pcm_mask(xpd_t *xpd, xpp_line_t new_mask, uint new_pcm_len);
-void		generic_card_pcm_recompute(xpd_t *xpd, xpp_line_t pcm_mask);
-void		generic_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack);
-void		generic_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack);
-int		generic_timing_priority(xpd_t *xpd);
-int		generic_echocancel_timeslot(xpd_t *xpd, int pos);
-int		generic_echocancel_setmask(xpd_t *xpd, xpp_line_t ec_mask);
-void		fill_beep(u_char *buf, int num, int duration);
-const char	*sync_mode_name(enum sync_mode mode);
-void		xbus_set_command_timer(xbus_t *xbus, bool on);
-void		xbus_request_sync(xbus_t *xbus, enum sync_mode mode);
-void		got_new_syncer(xbus_t *xbus, enum sync_mode mode, int drift);
-int		xbus_command_queue_tick(xbus_t *xbus);
-void		xbus_reset_counters(xbus_t *xbus);
-void		elect_syncer(const char *msg);
-int		exec_sync_command(const char *buf, size_t count);
-int		fill_sync_string(char *buf, size_t count);
+int xbus_pcm_init(void *top);
+void xbus_pcm_shutdown(void);
+int send_pcm_frame(xbus_t *xbus, xframe_t *xframe);
+void pcm_recompute(xpd_t *xpd, xpp_line_t tmp_pcm_mask);
+void xframe_receive_pcm(xbus_t *xbus, xframe_t *xframe);
+void update_wanted_pcm_mask(xpd_t *xpd, xpp_line_t new_mask, uint new_pcm_len);
+void generic_card_pcm_recompute(xpd_t *xpd, xpp_line_t pcm_mask);
+void generic_card_pcm_fromspan(xpd_t *xpd, xpacket_t *pack);
+void generic_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack);
+int generic_timing_priority(xpd_t *xpd);
+int generic_echocancel_timeslot(xpd_t *xpd, int pos);
+int generic_echocancel_setmask(xpd_t *xpd, xpp_line_t ec_mask);
+void fill_beep(u_char *buf, int num, int duration);
+const char *sync_mode_name(enum sync_mode mode);
+void xbus_set_command_timer(xbus_t *xbus, bool on);
+void xbus_request_sync(xbus_t *xbus, enum sync_mode mode);
+void got_new_syncer(xbus_t *xbus, enum sync_mode mode, int drift);
+int xbus_command_queue_tick(xbus_t *xbus);
+void xbus_reset_counters(xbus_t *xbus);
+void elect_syncer(const char *msg);
+int exec_sync_command(const char *buf, size_t count);
+int fill_sync_string(char *buf, size_t count);
 #ifdef	DAHDI_SYNC_TICK
-void		dahdi_sync_tick(struct dahdi_span *span, int is_master);
+void dahdi_sync_tick(struct dahdi_span *span, int is_master);
 #endif

 #ifdef	DEBUG_PCMTX
-extern int	pcmtx;
-extern int	pcmtx_chan;
+extern int pcmtx;
+extern int pcmtx_chan;
 #endif

-#endif	/* __KERNEL__ */
-
-#endif	/* XBUS_PCM_H */
+#endif /* __KERNEL__ */

+#endif /* XBUS_PCM_H */
--- a/drivers/dahdi/xpp/xbus-sysfs.c
+++ b/drivers/dahdi/xpp/xbus-sysfs.c
--- a/drivers/dahdi/xpp/xdefs.h
+++ b/drivers/dahdi/xpp/xdefs.h
@@ -34,18 +34,21 @@
 /* This is to enable user-space programs to include this. */

 #include <stdint.h>
-typedef uint8_t  __u8;
+typedef uint8_t __u8;
 typedef uint32_t __u32;

 #include <stdio.h>

-#define	DBG(fmt, ...)		printf("DBG: %s: " fmt, __FUNCTION__, ## __VA_ARGS__)
+#define	DBG(fmt, ...)		printf("DBG: %s: " fmt, __func__, ## __VA_ARGS__)
 #define	INFO(fmt, ...)		printf("INFO: " fmt, ## __VA_ARGS__)
 #define	NOTICE(fmt, ...)	printf("NOTICE: " fmt, ## __VA_ARGS__)
 #define	ERR(fmt, ...)		printf("ERR: " fmt, ## __VA_ARGS__)
 #define	__user

-struct list_head { struct list_head *next; struct list_head *prev; };
+struct list_head {
+	struct list_head *next;
+	struct list_head *prev;
+};

 #endif

@@ -53,15 +56,15 @@ struct list_head { struct list_head *next; struct list_head *prev; };

 #define	ALL_LINES		((lineno_t)-1)

-#ifndef	BIT	/* added in 2.6.24 */
+#ifndef	BIT			/* added in 2.6.24 */
 #define	BIT(i)		(1UL << (i))
 #endif
-#define	BIT_SET(x,i)	((x) |= BIT(i))
-#define	BIT_CLR(x,i)	((x) &= ~BIT(i))
-#define	IS_SET(x,i)	(((x) & BIT(i)) != 0)
+#define	BIT_SET(x, i)	((x) |= BIT(i))
+#define	BIT_CLR(x, i)	((x) &= ~BIT(i))
+#define	IS_SET(x, i)	(((x) & BIT(i)) != 0)
 #define	BITMASK(i)	(((u64)1 << (i)) - 1)

-#define	MAX_PROC_WRITE	100	/* Largest buffer we allow writing our /proc files */
+#define	MAX_PROC_WRITE	100	/* Longest write allowed to our /proc files */
 #define	CHANNELS_PERXPD	32	/* Depends on xpp_line_t and protocol fields */

 #define	MAX_SPANNAME	20	/* From dahdi/kernel.h */
@@ -77,7 +80,8 @@ struct list_head { struct list_head *next; struct list_head *prev; };
 #define	UNIT_BITS	3	/* Bit for Astribank unit number */
 #define	SUBUNIT_BITS	3	/* Bit for Astribank subunit number */

-#define	MAX_UNIT	(1 << UNIT_BITS)	/* 1 FXS + 3 FXS/FXO | 1 BRI + 3 FXS/FXO */
+/* 1 FXS + 3 FXS/FXO | 1 BRI + 3 FXS/FXO */
+#define	MAX_UNIT	(1 << UNIT_BITS)
 #define	MAX_SUBUNIT	(1 << SUBUNIT_BITS)	/* 8 port BRI */

 /*
@@ -95,74 +99,72 @@ struct list_head { struct list_head *next; struct list_head *prev; };

 #define	VALID_XPD_NUM(x)	((x) < MAX_XPDS && (x) >= 0)

-#define	CHAN_BITS		5       /* 0-31 for E1 */
+#define	CHAN_BITS		5	/* 0-31 for E1 */

-typedef char			*charp;
-typedef unsigned char		byte;
+typedef char *charp;
 #ifdef __KERNEL__

 /* Kernel versions... */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
 #define	KMEM_CACHE_T	kmem_cache_t
-#else 
+#else
 #define	KMEM_CACHE_T	struct kmem_cache
-#endif 
+#endif

 #define	KZALLOC(size, gfp)	my_kzalloc(size, gfp)
-#define	KZFREE(p)		do {					\
-					memset((p), 0, sizeof(*(p)));	\
-					kfree(p);			\
-				} while(0);
+#define	KZFREE(p) \
+		do {					\
+			memset((p), 0, sizeof(*(p)));	\
+			kfree(p);			\
+		} while (0);

-/*
- * Hotplug replaced with uevent in 2.6.16
- */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16)
-#define	OLD_HOTPLUG_SUPPORT	// for older kernels
-#endif
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10)
-#define	OLD_HOTPLUG_SUPPORT_269// for way older kernels
-#endif
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14)
-#define	DEVICE_ATTR_READER(name,dev,buf)	\
-		ssize_t name(struct device *dev, struct device_attribute *attr, char *buf)
-#define	DEVICE_ATTR_WRITER(name,dev,buf, count)	\
-		ssize_t name(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 14)
+#define	DEVICE_ATTR_READER(name, dev, buf) \
+		ssize_t name(struct device *dev, \
+		struct device_attribute *attr, char *buf)
+#define	DEVICE_ATTR_WRITER(name, dev, buf, count) \
+		ssize_t name(struct device *dev, \
+		struct device_attribute *attr, \
+		const char *buf, size_t count)
 #else
-#define	DEVICE_ATTR_READER(name,dev,buf)	\
+#define	DEVICE_ATTR_READER(name, dev, buf) \
 		ssize_t name(struct device *dev, char *buf)
-#define	DEVICE_ATTR_WRITER(name,dev,buf, count)	\
+#define	DEVICE_ATTR_WRITER(name, dev, buf, count) \
 		ssize_t name(struct device *dev, const char *buf, size_t count)
 #endif
-#define	DRIVER_ATTR_READER(name,drv,buf)	\
+#define	DRIVER_ATTR_READER(name, drv, buf) \
 		ssize_t name(struct device_driver *drv, char * buf)

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)
-#define	SET_PROC_DIRENTRY_OWNER(p)	do { (p)->owner = THIS_MODULE; } while(0);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 30)
+#define	SET_PROC_DIRENTRY_OWNER(p) \
+		do { \
+			(p)->owner = THIS_MODULE; \
+		} while (0);
 #else
-#define	SET_PROC_DIRENTRY_OWNER(p)	do { } while(0);
+#define	SET_PROC_DIRENTRY_OWNER(p) do { } while (0);
 #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)
-typedef int			bool;
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
+/* 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
 #else
-typedef int			bool;
+typedef int bool;
 #endif
-typedef struct xbus		xbus_t;
-typedef	struct xpd		xpd_t;
-typedef	struct xframe		xframe_t;
-typedef	struct xpacket		xpacket_t;
-typedef	__u32			xpp_line_t;	/* at most 31 lines for E1 */
-typedef	byte			lineno_t;
-typedef byte			xportno_t;
+typedef struct xbus xbus_t;
+typedef struct xpd xpd_t;
+typedef struct xframe xframe_t;
+typedef struct xpacket xpacket_t;
+typedef __u32 xpp_line_t;	/* at most 31 lines for E1 */
+typedef __u8 lineno_t;
+typedef __u8 xportno_t;

 #define	PORT_BROADCAST		255

-#endif	/* XDEFS_H */
+#endif /* XDEFS_H */
--- a/drivers/dahdi/xpp/xframe_queue.c
+++ b/drivers/dahdi/xpp/xframe_queue.c
@@ -7,7 +7,9 @@ extern int debug;
 static xframe_t *transport_alloc_xframe(xbus_t *xbus, gfp_t gfp_flags);
 static void transport_free_xframe(xbus_t *xbus, xframe_t *xframe);

-void xframe_queue_init(struct xframe_queue *q, unsigned int steady_state_count, unsigned int max_count, const char *name, void *priv)
+void xframe_queue_init(struct xframe_queue *q,
+	unsigned int steady_state_count, unsigned int max_count,
+	const char *name, void *priv)
 {
 	memset(q, 0, sizeof(*q));
 	spin_lock_init(&q->lock);
@@ -17,61 +19,60 @@ void xframe_queue_init(struct xframe_queue *q, unsigned int steady_state_count,
 	q->name = name;
 	q->priv = priv;
 }
+EXPORT_SYMBOL(xframe_queue_init);

 void xframe_queue_clearstats(struct xframe_queue *q)
 {
 	q->worst_count = 0;
-	//q->overflows = 0;	/* Never clear overflows */
+	//q->overflows = 0;     /* Never clear overflows */
 	q->worst_lag_usec = 0L;
 }
+EXPORT_SYMBOL(xframe_queue_clearstats);

 static void __xframe_dump_queue(struct xframe_queue *q)
 {
-	xframe_t	*xframe;
-	int		i = 0;
-	char		prefix[30];
-	struct timeval	now;
+	xframe_t *xframe;
+	int i = 0;
+	char prefix[30];
+	struct timeval now;

 	do_gettimeofday(&now);
 	printk(KERN_DEBUG "%s: dump queue '%s' (first packet in each frame)\n",
-		THIS_MODULE->name,
-		q->name);
+	       THIS_MODULE->name, q->name);
 	list_for_each_entry_reverse(xframe, &q->head, frame_list) {
-		xpacket_t	*pack = (xpacket_t *)&xframe->packets[0];
-		long		usec = usec_diff(&now, &xframe->tv_queued);
+		xpacket_t *pack = (xpacket_t *)&xframe->packets[0];
+		long usec = usec_diff(&now, &xframe->tv_queued);
 		snprintf(prefix, ARRAY_SIZE(prefix), "  %3d> %5ld.%03ld msec",
-			i++, usec / 1000, usec % 1000);
+			 i++, usec / 1000, usec % 1000);
 		dump_packet(prefix, pack, 1);
 	}
 }

 static bool __xframe_enqueue(struct xframe_queue *q, xframe_t *xframe)
 {
-	int			ret = 1;
-	static int		overflow_cnt = 0;
+	int ret = 1;
+	static int overflow_cnt;

-	if(unlikely(q->disabled)) {
+	if (unlikely(q->disabled)) {
 		ret = 0;
 		goto out;
 	}
-	if(q->count >= q->max_count) {
+	if (q->count >= q->max_count) {
 		q->overflows++;
 		if ((overflow_cnt++ % 1000) < 5) {
-			NOTICE("Overflow of %-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);
+			NOTICE("Overflow of %-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_dump_queue(q);
 		}
 		ret = 0;
 		goto out;
 	}
-	if(++q->count > q->worst_count)
+	if (++q->count > q->worst_count)
 		q->worst_count = q->count;
 	list_add_tail(&xframe->frame_list, &q->head);
 	do_gettimeofday(&xframe->tv_queued);
@@ -81,33 +82,36 @@ out:

 bool xframe_enqueue(struct xframe_queue *q, xframe_t *xframe)
 {
-	unsigned long	flags;
-	int		ret;
+	unsigned long flags;
+	int ret;

 	spin_lock_irqsave(&q->lock, flags);
 	ret = __xframe_enqueue(q, xframe);
 	spin_unlock_irqrestore(&q->lock, flags);
 	return ret;
 }
+EXPORT_SYMBOL(xframe_enqueue);

 static xframe_t *__xframe_dequeue(struct xframe_queue *q)
 {
-	xframe_t		*frm = NULL;
-	struct list_head	*h;
-	struct timeval		now;
-	unsigned long		usec_lag;
+	xframe_t *frm = NULL;
+	struct list_head *h;
+	struct timeval now;
+	unsigned long usec_lag;

-	if(list_empty(&q->head))
+	if (list_empty(&q->head))
 		goto out;
 	h = q->head.next;
 	list_del_init(h);
 	--q->count;
 	frm = list_entry(h, xframe_t, frame_list);
 	do_gettimeofday(&now);
-	usec_lag =	
-		(now.tv_sec - frm->tv_queued.tv_sec)*1000*1000 +
-		(now.tv_usec - frm->tv_queued.tv_usec);
-	if(q->worst_lag_usec < usec_lag)
+	usec_lag =
+	    (now.tv_sec - frm->tv_queued.tv_sec) * 1000 * 1000 + (now.tv_usec -
+								  frm->
+								  tv_queued.
+								  tv_usec);
+	if (q->worst_lag_usec < usec_lag)
 		q->worst_lag_usec = usec_lag;
 out:
 	return frm;
@@ -115,59 +119,68 @@ out:

 xframe_t *xframe_dequeue(struct xframe_queue *q)
 {
-	unsigned long	flags;
-	xframe_t	*frm;
+	unsigned long flags;
+	xframe_t *frm;

 	spin_lock_irqsave(&q->lock, flags);
 	frm = __xframe_dequeue(q);
 	spin_unlock_irqrestore(&q->lock, flags);
 	return frm;
 }
+EXPORT_SYMBOL(xframe_dequeue);
+
 void xframe_queue_disable(struct xframe_queue *q, bool disabled)
 {
 	q->disabled = disabled;
 }
+EXPORT_SYMBOL(xframe_queue_disable);

 void xframe_queue_clear(struct xframe_queue *q)
 {
-	xframe_t	*xframe;
-	xbus_t		*xbus = q->priv;
-	int		i = 0;
+	xframe_t *xframe;
+	xbus_t *xbus = q->priv;
+	int i = 0;

 	xframe_queue_disable(q, 1);
-	while((xframe = xframe_dequeue(q)) != NULL) {
+	while ((xframe = xframe_dequeue(q)) != NULL) {
 		transport_free_xframe(xbus, xframe);
 		i++;
 	}
-	XBUS_DBG(DEVICES, xbus, "%s: finished queue clear (%d items)\n", q->name, i);
+	XBUS_DBG(DEVICES, xbus, "%s: finished queue clear (%d items)\n",
+		 q->name, i);
 }
+EXPORT_SYMBOL(xframe_queue_clear);

 uint xframe_queue_count(struct xframe_queue *q)
 {
 	return q->count;
 }
+EXPORT_SYMBOL(xframe_queue_count);

 /*------------------------- Frame Alloc/Dealloc --------------------*/

 static xframe_t *transport_alloc_xframe(xbus_t *xbus, gfp_t gfp_flags)
 {
-	struct xbus_ops	*ops;
-	xframe_t	*xframe;
-	unsigned long	flags;
+	struct xbus_ops *ops;
+	xframe_t *xframe;
+	unsigned long flags;

 	BUG_ON(!xbus);
 	ops = transportops_get(xbus);
-	if(unlikely(!ops)) {
+	if (unlikely(!ops)) {
 		XBUS_ERR(xbus, "Missing transport\n");
 		return NULL;
 	}
 	spin_lock_irqsave(&xbus->transport.lock, flags);
-	//XBUS_INFO(xbus, "%s (transport_refcount=%d)\n", __FUNCTION__, atomic_read(&xbus->transport.transport_refcount));
+#if 0
+	XBUS_INFO(xbus, "%s (transport_refcount=%d)\n",
+		__func__, atomic_read(&xbus->transport.transport_refcount));
+#endif
 	xframe = ops->alloc_xframe(xbus, gfp_flags);
-	if(!xframe) {
+	if (!xframe) {
 		static int rate_limit;

-		if((rate_limit++ % 3001) == 0)
+		if ((rate_limit++ % 3001) == 0)
 			XBUS_ERR(xbus,
 				"Failed xframe allocation from transport (%d)\n",
 				rate_limit);
@@ -180,14 +193,17 @@ static xframe_t *transport_alloc_xframe(xbus_t *xbus, gfp_t gfp_flags)

 static void transport_free_xframe(xbus_t *xbus, xframe_t *xframe)
 {
-	struct xbus_ops	*ops;
-	unsigned long	flags;
+	struct xbus_ops *ops;
+	unsigned long flags;

 	BUG_ON(!xbus);
 	ops = xbus->transport.ops;
 	BUG_ON(!ops);
 	spin_lock_irqsave(&xbus->transport.lock, flags);
-	//XBUS_INFO(xbus, "%s (transport_refcount=%d)\n", __FUNCTION__, atomic_read(&xbus->transport.transport_refcount));
+#if 0
+	XBUS_INFO(xbus, "%s (transport_refcount=%d)\n",
+		__func__, atomic_read(&xbus->transport.transport_refcount));
+#endif
 	ops->free_xframe(xbus, xframe);
 	transportops_put(xbus);
 	spin_unlock_irqrestore(&xbus->transport.lock, flags);
@@ -195,45 +211,48 @@ static void transport_free_xframe(xbus_t *xbus, xframe_t *xframe)

 static bool xframe_queue_adjust(struct xframe_queue *q)
 {
-	xbus_t		*xbus;
-	xframe_t	*xframe;
-	int		delta;
-	unsigned long	flags;
-	int		ret = 0;
+	xbus_t *xbus;
+	xframe_t *xframe;
+	int delta;
+	unsigned long flags;
+	int ret = 0;

 	BUG_ON(!q);
 	xbus = q->priv;
 	BUG_ON(!xbus);
 	spin_lock_irqsave(&q->lock, flags);
 	delta = q->count - q->steady_state_count;
-	if(delta < -XFRAME_QUEUE_MARGIN) {
+	if (delta < -XFRAME_QUEUE_MARGIN) {
 		/* Increase pool by one frame */
 		//XBUS_INFO(xbus, "%s(%d): Allocate one\n", q->name, delta);
 		xframe = transport_alloc_xframe(xbus, GFP_ATOMIC);
-		if(!xframe) {
+		if (!xframe) {
 			static int rate_limit;

-			if((rate_limit++ % 3001) == 0)
-				XBUS_ERR(xbus, "%s: failed frame allocation\n", q->name);
+			if ((rate_limit++ % 3001) == 0)
+				XBUS_ERR(xbus, "%s: failed frame allocation\n",
+					 q->name);
 			goto out;
 		}
-		if(!__xframe_enqueue(q, xframe)) {
+		if (!__xframe_enqueue(q, xframe)) {
 			static int rate_limit;

-			if((rate_limit++ % 3001) == 0)
-				XBUS_ERR(xbus, "%s: failed enqueueing frame\n", q->name);
+			if ((rate_limit++ % 3001) == 0)
+				XBUS_ERR(xbus, "%s: failed enqueueing frame\n",
+					 q->name);
 			transport_free_xframe(xbus, xframe);
 			goto out;
 		}
-	} else if(delta > XFRAME_QUEUE_MARGIN) {
+	} else if (delta > XFRAME_QUEUE_MARGIN) {
 		/* Decrease pool by one frame */
 		//XBUS_INFO(xbus, "%s(%d): Free one\n", q->name, delta);
 		xframe = __xframe_dequeue(q);
-		if(!xframe) {
+		if (!xframe) {
 			static int rate_limit;

-			if((rate_limit++ % 3001) == 0)
-				XBUS_ERR(xbus, "%s: failed dequeueing frame\n", q->name);
+			if ((rate_limit++ % 3001) == 0)
+				XBUS_ERR(xbus, "%s: failed dequeueing frame\n",
+					 q->name);
 			goto out;
 		}
 		transport_free_xframe(xbus, xframe);
@@ -246,19 +265,20 @@ out:

 xframe_t *get_xframe(struct xframe_queue *q)
 {
-	xframe_t	*xframe;
-	xbus_t		*xbus;
+	xframe_t *xframe;
+	xbus_t *xbus;

 	BUG_ON(!q);
 	xbus = (xbus_t *)q->priv;
 	BUG_ON(!xbus);
 	xframe_queue_adjust(q);
 	xframe = xframe_dequeue(q);
-	if(!xframe) {
+	if (!xframe) {
 		static int rate_limit;

-		if((rate_limit++ % 3001) == 0)
-			XBUS_ERR(xbus, "%s STILL EMPTY (%d)\n", q->name, rate_limit);
+		if ((rate_limit++ % 3001) == 0)
+			XBUS_ERR(xbus, "%s STILL EMPTY (%d)\n", q->name,
+				 rate_limit);
 		return NULL;
 	}
 	BUG_ON(xframe->xframe_magic != XFRAME_MAGIC);
@@ -273,34 +293,25 @@ xframe_t *get_xframe(struct xframe_queue *q)
 	 *
 	 * memset(xframe->packets, 0, xframe->frame_maxlen);
 	 */
-	//XBUS_INFO(xbus, "%s\n", __FUNCTION__);
+	//XBUS_INFO(xbus, "%s\n", __func__);
 	return xframe;
 }
+EXPORT_SYMBOL(get_xframe);

 void put_xframe(struct xframe_queue *q, xframe_t *xframe)
 {
-	xbus_t		*xbus;
+	xbus_t *xbus;

 	BUG_ON(!q);
 	xbus = (xbus_t *)q->priv;
 	BUG_ON(!xbus);
-	//XBUS_INFO(xbus, "%s\n", __FUNCTION__);
+	//XBUS_INFO(xbus, "%s\n", __func__);
 	BUG_ON(!TRANSPORT_EXIST(xbus));
-	if(unlikely(!xframe_enqueue(q, xframe))) {
+	if (unlikely(!xframe_enqueue(q, xframe))) {
 		XBUS_ERR(xbus, "Failed returning xframe to %s\n", q->name);
 		transport_free_xframe(xbus, xframe);
 		return;
 	}
 	xframe_queue_adjust(q);
 }
-
-
-EXPORT_SYMBOL(xframe_queue_init);
-EXPORT_SYMBOL(xframe_queue_clearstats);
-EXPORT_SYMBOL(xframe_enqueue);
-EXPORT_SYMBOL(xframe_dequeue);
-EXPORT_SYMBOL(xframe_queue_disable);
-EXPORT_SYMBOL(xframe_queue_clear);
-EXPORT_SYMBOL(xframe_queue_count);
-EXPORT_SYMBOL(get_xframe);
 EXPORT_SYMBOL(put_xframe);
--- a/Show More
+++ b/Show More