dahdi: Fix previous CentOS 6.5 commit.

The previous commit from earlier today to fix the backport of PDE_DATA was wrong in that it would not then process the other defines for older kernels if it detected it was running on a redhat release. Signed-off-by: Shaun Ruffell <sruffell@digium.com> (cherry picked from commit 71c003ba49)
dahdi: CentOS 6.5 backported PDE_DATA definition.
2013-12-03 09:36:40 -06:00 · 2013-12-03 09:36:40 -06:00 · 2013-08-16 15:28:24 -05:00 · 2013-07-30 15:04:00 +03:00 · 2013-06-26 14:32:15 -05:00 · 2013-06-23 22:12:33 +03:00
88 changed files with 13098 additions and 8284 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.6.1
--- a/555
+++ b/555
@@ -1,555 +0,0 @@
-2012-04-18 Shaun Ruffell <sruffell@digium.com>
-
-	* Released 2.6.1 
-
-2012-04-11 20:19 +0000 [r10657-10660]  Shaun Ruffell <sruffell@digium.com>
-
-	* drivers/dahdi/xpp/xpp_dahdi.c, drivers/dahdi/xpp/xpp_dahdi.h:
-	  xpp: Fix compilation when CONFIG_DAHDI_WATCHDOG is defined. Looks
-	  like a hold over from when dahdi_span_ops was first implemented
-	  in r8985 "dahdi: Move the callbacks in dahdi_span into its own
-	  structure" [1]. [1]
-	  http://svnview.digium.com/svn/dahdi?view=revision&revision=8985
-	  Signed-off-by: Shaun Ruffell <sruffell@digium.com> Acked-by:
-	  Tzafrir Cohen <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10658
-
-	* drivers/dahdi/dahdi-base.c: dahdi: Fix compilation when
-	  CONFIG_DAHDI_WATCHDOG is defined. From: Mike Sinkovsky
-	  <msink@trikom.ru> Internal-Issue-ID: DAHLIN-288 Signed-off-by:
-	  Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10655
-
-2012-04-11 09:16 +0000 [r10651-10654]  Tzafrir Cohen <tzafrir.cohen@xorcom.com>
-
-	* drivers/dahdi/xpp/firmwares/FPGA_1161.201.hex: FPGA_1161.201.hex
-	  rev 10545: fix reset of XR1000 Previous commit (r10651) included
-	  an incorrect version. Including full message from that commit for
-	  the description. rev. 10502 of the FPGA firmware for the new
-	  E-Main rev. 4 fixes a potential issue when used on Xorcom XR1000
-	  systems: an issue with the power supply may cause the unit to
-	  reset. Note that there is no issue with previous models, with a
-	  normal setup of an Astribank, or other XRx000 systems.
-	  Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10652
-
-	* drivers/dahdi/xpp/firmwares/FPGA_1161.201.hex: FPGA_1161.201.hex
-	  rev 10532: fix reset of XR1000 rev. 10502 of the FPGA firmware
-	  for the new E-Main rev. 4 fixes a potential issue when used on
-	  Xorcom XR1000 systems: an issue with the power supply may cause
-	  the unit to reset. Note that there is no issue with previous
-	  models, with a normal setup of an Astribank, or other XRx000
-	  systems. Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
-	  Origin: http://svnview.digium.com/svn/dahdi?view=rev&rev=10649
-
-2012-04-05 20:34 +0000 [r10644-10648]  Shaun Ruffell <sruffell@digium.com>
-
-	* drivers/dahdi/voicebus/Kbuild, drivers/dahdi/wct4xxp/Kbuild:
-	  wcte12xp, wctdm24xxp, wct4xxp: Print warning about potential GPL
-	  violation w/HOTPLUG_FIRMWARE=no. Print a warning message that it
-	  may be a GPL violation to redistribute these binaries if the
-	  firmware for the VPMOCT032/64/128/256 is compiled in.
-	  Signed-off-by: Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10646
-
-	* drivers/dahdi/wcb4xxp/base.c: wcb4xxp: Remove asm/system.h
-	  include. Not needed anymore and will break compilation on Kernel
-	  versions >= 3.4 since commit 0195c00244dc2e [1] [1]
-	  http://git.kernel.org/?p=linux/kernel/git/torvalds/linux.git;a=commit;h=0195c00244dc2e
-	  Signed-off-by: Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10641
-
-	* drivers/dahdi/dahdi_dummy.c: dahdi_dummy: Include timer.h instead
-	  of time.h It appears that some kernel configurations do not
-	  include timer.h in any of the include files that are included by
-	  dahdi_dummy. The timer_structs are defined in timer.h and not
-	  time.h, so this change is correct even though I never could find
-	  a configuation myself that actually failed to compile. This has
-	  negligible impact since dahdi_dummy is not compiled by default.
-	  Internal-Issue-ID: DAHLIN-185 Reported-by: Steve Murphy
-	  Signed-off-by: Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10640
-
-2012-04-03 22:02 +0000 [r10628-10637]  Shaun Ruffell <sruffell@digium.com>
-
-	* drivers/dahdi/dahdi-base.c: dahdi: Fix compilation when
-	  CONFIG_DAHDI_NET is defined. 'irq' field was removed from
-	  dahdi_span in r10276 "dahdi: Remove dahdi_span.irq and move
-	  dahdi_span.irqmisses into dahdi_device." [1] which was first
-	  released in dahdi-linux 2.6.0. [1]
-	  http://svnview.digium.com/svn/dahdi?view=revision&revision=10276
-	  Reported-by: Pavel Selivanov Internal-Issue-ID: DAHLIN-278
-	  Patches: hdlc.patch by Pavel Selivanov (license #5420)
-	  Signed-off-by: Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10634
-
-	* drivers/dahdi/dahdi-base.c: dahdi: Fix compilation when
-	  CONFIG_DAHDI_ECHOCAN_PROCESS_TX is defined. 'ec_state' was
-	  renamed to 'dahdi_echocan_state' in r6529 [1] but support for
-	  CONFIG_DAHDI_ECHOCAN_PROCESS_TX was first committed in r9442 [2].
-	  So it appears that I never compiled tested this exact commit when
-	  it went in for the 2.5.0 release. [1]
-	  http://svnview.digium.com/svn/dahdi?view=revision&revision=6529
-	  [2]
-	  http://svnview.digium.com/svn/dahdi?view=revision&revision=9442
-	  Reported-by: Pavel Selivanov Internal-Issue-ID: DAHLIN-279
-	  Patches: ec.patch uploaded by Pavel Selivanov (License #5420) [
-	  edited the patch slightly for minor formatting ] Signed-off-by:
-	  Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10633
-
-	* drivers/dahdi/dahdi_dynamic_loc.c: dahdi_dynamic_loc: Change and
-	  check the dyn->pvt pointer under lock. Fixes a crash on unload if
-	  the sync_tick callback was running at the same time the dynamic
-	  local span was destroyed. It was possible for
-	  dahdi_dynamic_local_transmit to dereference a pointer that may
-	  have already been freed. Signed-off-by: Shaun Ruffell
-	  <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10627
-
-	* drivers/dahdi/dahdi_dynamic_eth.c: dahdi_dynamic_eth: Make
-	  ztdeth_exit() symetrical with ztdeth_init() and fix race on
-	  unload. Minor change to follow generally recommended practice.
-	  Prevents new packets from being queued up for devices when they
-	  are about to be cleaned up. Also clean up any skbs that may still
-	  be on the queue after unloading. Also closes anoter potential
-	  kernel oops on module unload. It was possible to delete the
-	  private structure while the master span process was running. The
-	  result was an attempt to page memory from interrupt context. Make
-	  sure that the pvt function is set and cleared under the zlock.
-	  Also do not assume that the pvt pointer is valid in
-	  ztdeth_transmit. Signed-off-by: Shaun Ruffell
-	  <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10626
-
-	* drivers/dahdi/dahdi_dynamic.c: dahdi_dynamic: Close race on
-	  unload if red alarm timer was running when unloaded. I saw a
-	  kernel oops that was the result of the timer running after the
-	  dahdi_dynamic module was unloaded. Now we wait for the timer to
-	  complete, and then delete it again in case it reactivated itself.
-	  Signed-off-by: Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10625
-
-	* drivers/dahdi/dahdi_dynamic.c: dahdi_dynamic: Remove calls to
-	  __module_get(). The board drivers are the ones calling the
-	  unregister function, and therefore we do not need to worry about
-	  them unloading while calling the destroy callback. When
-	  destroying spans with the ioctl, replace __module_get() with
-	  try_module_get. This avoids hitting a BUG in module_get on kernel
-	  versions < 2.6.29. ALSO move the call to try_module_get out of
-	  the dahdi_dynamic_release function and into destroy. This way if
-	  the destroy callback isn't called because the dynamic driver is
-	  unloading the dynamic device can be left on the list to be
-	  cleaned up by the dahdi_dynamic_unregister_driver function().
-	  Signed-off-by: Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10624
-
-	* drivers/dahdi/dahdi-base.c, include/dahdi/kernel.h,
-	  drivers/dahdi/dahdi_dynamic.c: dahdi_dynamic: Do not call into
-	  dahdi_dynamic without holding reference. Instead of registering a
-	  function pointer, register a dahdi_dynamic_ops structure that
-	  contains the owner as well as the ioctl callback. This way
-	  dahdi.ko can bump up the reference count on dahdi_dynamic.ko
-	  before calling the ioctl callback. Also, use the registration
-	  mutex to guard against the module being unloaded between the time
-	  the structure pointer was checked, and the module reference is
-	  taken. Signed-off-by: Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10623
-
-2012-04-02 14:05 +0000 [r10620]  Shaun Ruffell <sruffell@digium.com>
-
-	* drivers/dahdi/voicebus/vpmoct.c, drivers/dahdi/firmware/Makefile,
-	  drivers/dahdi/voicebus/Kbuild: wctdm24xxp, wcte12xp: Allow
-	  VPMOCT032 firmware to be compiled into driver. Enables the driver
-	  to update firmware on systems that do not have the firmware
-	  loader configured / enabled (Linux config option
-	  CONFIG_FW_LOADER). Compiling the firmware into the driver
-	  increase the memory footprint by around ~440K. Internal-Issue-ID:
-	  DAHDI-963 Reported-and-Tested-by: Guenther Kelleter
-	  Signed-off-by: Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10618
-
-2012-03-29 15:28 +0000 [r10614]  Shaun Ruffell <sruffell@digium.com>
-
-	* drivers/dahdi/wctdm24xxp/base.c: wctdm24xxp: Remove forward
-	  declaration of inline for GCC 3.4.4 GCC 3.4.4 does not allow
-	  forward declaration of inline functions. Internal-Issue-ID:
-	  DAHLIN-286 Reported-by: Guenther Kelleter Patches:
-	  wctdm24xxp-inline.patch uploaded by Guenther Kelleter (License
-	  #6372) Signed-off-by: Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10613
-
-2012-03-28 Shaun Ruffell <sruffell@digium.com>
-
-	* Released 2.6.0-rc1 
-
-2012-03-22 18:36 +0000 [r10591-10594]  Shaun Ruffell <sruffell@digium.com>
-
-	* drivers/dahdi/wct4xxp/base.c: wct4xxp: Trivial formatting changes
-	  around request_irq. Quiet some checkpatch warnings introduced by
-	  the last patch. I kept this separate since it may have obscured
-	  the real change made in the previous commit if combined.
-	  Signed-off-by: Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10590
-
-	* drivers/dahdi/wct4xxp/base.c: wct4xxp: Disable all interrupts
-	  explicitly in interrupt handler. The driver makes the assumption
-	  that interrupts are disabled but this cannot be guaranteed. We'll
-	  explicity disable interrupts on the local processor while the
-	  interrupt handler is running. This eliminates the "IRQF_DISABLED
-	  is not guaranteed on shared IRQs" warning when loading the
-	  driver. Signed-off-by: Shaun Ruffell <sruffell@digium.com>
-	  Origin: http://svnview.digium.com/svn/dahdi?view=rev&rev=10589
-
-	* drivers/dahdi/dahdi_dynamic_eth.c: dahdi_dynamic_eth: Fix
-	  compilation on kernels < 2.6.22. Resolves the follwing build
-	  error: drivers/dahdi/dahdi_dynamic_eth.c: In function
-	  ‘ztdeth_exit’: drivers/dahdi/dahdi_dynamic_eth.c:448: error:
-	  implicit declaration of function ‘cancel_work_sync’ RHEL kernel
-	  versions 2.6.18-238 (5.6) and greater had cancel_work_sync()
-	  backported which is what I did my original smoke test on.
-	  Reported-by: Oron Peled <oron.peled@xorcom.com> Signed-off-by:
-	  Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10588
-
-	* drivers/dahdi/dahdi_dynamic_eth.c: dahdi_dynamic_eth: Prevent
-	  crash is packet arrives before span is fully configured. It was
-	  possible after a dynamic ethernet span was created for a packet
-	  to come in before the dahdi_span was fully initialized. The
-	  result would be a NULL pointer dereference. Now just discard any
-	  packets that might come in during this time window.
-	  Internal-Issue-ID: DAHLIN-280 Reported-by: Pavel Selivanov
-	  Signed-off-by: Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10587
-
-2012-03-21 20:35 +0000 [r10575-10576]  Tzafrir Cohen <tzafrir.cohen@xorcom.com>
-
-	* drivers/dahdi/xpp/card_fxs.c: xpp: FXS: added a
-	  'lower_ringing_noise' parameter * Adds a new parameter,
-	  'lower_ringing_noise', to module xpd_fxs. * Makes the
-	  "power-down" behaviour that was added in upstream svn r10478,
-	  switchable in runtime. * By default (false), makes the vbat_h
-	  behave like it did before the power-down change. - I.e: vbat_h is
-	  held throughout the ringing period (during both
-	  ring-up/ring-down) - So this patch revert part of r10478 * When
-	  switched to true, activate the "power-down" behaviour. - I.e:
-	  vbat_h follows the ring-up/ring-down. - This behaviour lowers the
-	  noise caused by group ringing of FXS channels in the same unit,
-	  but causes problems with CallerID. Signed-off-by: Oron Peled
-	  <oron.peled@xorcom.com> Acked-by: Tzafrir Cohen
-	  <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10574
-
-	* drivers/dahdi/xpp/card_fxs.c: xpp: FXS: atomic vbat_h power
-	  handling * In do_chan_power() make vbat_h changes atomic. * As a
-	  result we can ignore duplicate requests. This will allow cleaner
-	  logic in the next commit. * Added proper debug messages.
-	  Signed-off-by: Oron Peled <oron.peled@xorcom.com> Acked-by:
-	  Tzafrir Cohen <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10573
-
-2012-03-21 19:36 +0000 [r10564-10572]  Shaun Ruffell <sruffell@digium.com>
-
-	* drivers/dahdi/dahdi-sysfs.c: remove a duplicate dev_set_name()
-	  Remove duplicate definition from dahdi-sysfs.c Signed-off-by:
-	  Oron Peled <oron.peled@xorcom.com> Acked-by: Tzafrir Cohen
-	  <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10447
-
-	* include/dahdi/kernel.h, drivers/dahdi/dahdi_dynamic.c:
-	  dahdi_dynamic: Since dynamic devices are 'parentless' we must
-	  name them. This in conjunction with r10449 "A parent-less device
-	  should not crash dahdi", this allows dahdi_dynamic spans to work
-	  post the dahdi_devices changes in 2.6.0. The full address of the
-	  device is not used since kernels prior to 2.6.31 limit the length
-	  of a devicename to 20 characters. The full address of the device
-	  can be pulled out of the "hardware_id" and "type" fields of the
-	  span. This patch is just to get things working again.
-	  dahdi_dynamic devices *may* still have issues if the
-	  auto_assign_spans module parameter is 0. Internal-Issue-ID:
-	  DAHLIN-280 Reported-by: Pavel Selivanov Signed-off-by: Shaun
-	  Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10563
-
-	* drivers/dahdi/dahdi_dynamic_eth.c: dahdi_dynamic_eth: Move tx
-	  packet flushing to process context. The masterspan can be, and
-	  often is, called with interrupts disabled but dev_queue_xmit()
-	  needs to be called with interrupts enabled. This potentially
-	  fixes a deadlock. Signed-off-by: Shaun Ruffell
-	  <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10562
-
-	* include/dahdi/kernel.h: dahdi: Update dev_set_name / dev_name for
-	  RHEL 5.6+. This is needed because dev_name() is mapped to
-	  kobject_name() in a backport, but the kobject name isn't set
-	  until after device_add(). The result would be parentless devices
-	  would fail since dahdi would not think a name was set for these
-	  devices. For these systems, we'll set both the bus_id string and
-	  the underlying kobject_name. Signed-off-by: Shaun Ruffell
-	  <sruffell@digium.com> Acked-by: Tzafrir Cohen
-	  <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10561
-
-	* drivers/dahdi/dahdi-base.c, drivers/dahdi/dahdi-sysfs.c: A
-	  parent-less device should not crash dahdi * A parent-less device
-	  should not crash dahdi: - Access span->parent->dev instead of
-	  span->parent-dev.parent in soem cases. - Access span->parent->dev
-	  via new inline span_device() - Use span_device() in all
-	  dahdi_dev_{dbg,info}() * Allow low-level drivers to set their
-	  device name. - Drivers that don't use this feature get the
-	  default name based on the parent device name - Parent-less
-	  devices which don't set their name, fails to register with
-	  -EINVAL Signed-off-by: Oron Peled <oron.peled@xorcom.com>
-	  Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10449
-
-	* drivers/dahdi/voicebus/voicebus.h, drivers/dahdi/wcte12xp/base.c,
-	  drivers/dahdi/wctdm24xxp/base.c: wcte12xp, wctdm24xxp: Add
-	  compile-time option to disable ASPM for PCIe devices. Certain
-	  BIOSes appear to enable ASPM even though it is not fully
-	  supported by the platform. Also, since the PCIe links for TDM
-	  cards are always in use it does not make sense to allow them to
-	  transition to the disabled state. Just turn off power management
-	  on the PCIe links completely. For more information see
-	  http://lwn.net/Articles/449448/. Internal-Issue-ID: DAHLIN-283
-	  Signed-off-by: Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10557
-
-	* drivers/dahdi/wct4xxp/base.c: wct4xxp: Add compile-time option to
-	  disable ASPM for PCIe devices. Certain BIOSes appear to enable
-	  ASPM even though it is not fully supported by the platform. Also,
-	  since the PCIe links for TDM cards are always in use it does not
-	  make sense to allow them to transition to the disabled state.
-	  Just turn off power management on the PCIe links completely. For
-	  more information see http://lwn.net/Articles/449448/.
-	  Internal-Issue-ID: DAHLIN-283 Signed-off-by: Shaun Ruffell
-	  <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10558
-
-	* drivers/dahdi/wct4xxp/base.c: wct4xxp: __t4_frame_in and
-	  __t4_framer_out slowdowns. This is a partial revert of r10234
-	  "wct4xxp: __t4_framer_in and __t4_framer_out speedups." There
-	  were some platform + firmware version combinations that would
-	  fail to properly configure the framer with the aforementioned
-	  speedups. The originally reported sympton was that interrupts
-	  would fail to start and while troubleshooting I also saw cases
-	  where one of the spans would stay in alarm after starting. By
-	  adding in additional reads to the version register, the overall
-	  process of writing / reading from the framer control registers is
-	  slowed down which increases reliability. This change does *not*
-	  affect the main path of TDM data which is DMAed directly into
-	  buffers in host memory and are not read / written to / from
-	  framer registers directly. Reported-and-Tested-by: Vahan
-	  Yerkanian <vahan@arminco.com> Signed-off-by: Shaun Ruffell
-	  <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10559
-
-	* drivers/dahdi/dahdi-base.c, include/dahdi/kernel.h: dahdi: Add
-	  dahdi_pci_disable_link_state for kernel < 2.6.25. Will allow the
-	  ASPM (Active State Power Management) state to be disabled on PCIe
-	  devices before kernel version 2.6.25. Signed-off-by: Shaun
-	  Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10556
-
-2012-03-20 11:20 +0000 [r10553]  Tzafrir Cohen <tzafrir.cohen@xorcom.com>
-
-	* drivers/dahdi/xpp/firmwares/USB_RECOV.hex,
-	  drivers/dahdi/xpp/firmwares/USB_FW.hex,
-	  drivers/dahdi/xpp/firmwares/FPGA_1161.201.hex: xpp: firmwares:
-	  useless 0x1A at EOF Remove a mostly harmless 0x1A (^Z) at the end
-	  of the file. If you add a NL after it, it breaks the firmware
-	  loading. Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
-	  Origin: http://svnview.digium.com/svn/dahdi?view=rev&rev=10550
-
-2012-03-18 19:00 +0000 [r10537-10538]  Tzafrir Cohen <tzafrir.cohen@xorcom.com>
-
-	* drivers/dahdi/xpp/firmwares/Makefile,
-	  drivers/dahdi/xpp/firmwares/FPGA_1161.201.hex (added),
-	  drivers/dahdi/xpp/firmwares/USB_FW.201.hex (added): xpp:
-	  firmwares to support E-Main 4 USB firmware (USB_FW.201.hex 10402)
-	  and FPGA firmware (FPGA_1161.201.hex 10480) with support of the
-	  new E-Main 4 Astribank mainboard. (This was accidentally labeled
-	  as 'E-Main 3' in some previous commit messages) Also includes
-	  Makefile fixes from r10536. Signed-off-by: Tzafrir Cohen
-	  <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10535
-
-	* drivers/dahdi/xpp/firmwares/USB_FW.hex: xpp: USB_FW rev 10401:
-	  minor 6FXS/2FXO caps issue Fixes an issues with the 6FXS/2FXO
-	  module: if an extra FXS or FXO module is added to a system with
-	  such a module, an excessive number of port licenses was
-	  accidentally required (as if the 6FXS/2FXO module required
-	  8FXS/8FXO licenses). Internal-Issue-ID: #1371 Signed-off-by:
-	  Tzafrir Cohen <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10534
-
-2012-03-16 16:11 +0000 [r10524-10526]  Shaun Ruffell <sruffell@digium.com>
-
-	* drivers/dahdi/dahdi_dummy.c: dahdi_dummy: Fix compilation since
-	  dahdi-linux 2.6.0. Even though dahdi_dummy is no longer built by
-	  default, the adoption of dahdi_devices in 2.6 broke the ability
-	  to compile. This was not intended as there are some packagers who
-	  still patch the Kbuild file to enable dahdi_dummy.
-	  Internal-Issue-ID: DAHLIN-274 Signed-off-by: Shaun Ruffell
-	  <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10486
-
-	* drivers/dahdi/xpp/xproto.c: xpp: '%d' -> '%lu' when displaying
-	  module_refcount on kernel versions >= 3.3 Upstream commit
-	  bd77c047 "module: struct module_ref should contains long fields"
-	  changed the return of module_refcount from int to unsigned long.
-	  This change eliminates a warning from the string format
-	  specifier. Signed-off-by: Shaun Ruffell <sruffell@digium.com>
-	  Acked-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10485 Conflicts:
-	  drivers/dahdi/xpp/xproto.c
-
-	* drivers/dahdi/xpp/xpd.h: xpp: Use 'bool' type for boolean module
-	  parameters on kernel versions >= 2.6.31. Eliminates warnings that
-	  are a result of upstream commit 72db395ffa "module_param: check
-	  that bool parameters really are bool." Signed-off-by: Shaun
-	  Ruffell <sruffell@digium.com> Acked-by: Tzafrir Cohen
-	  <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10484 Conflicts:
-	  drivers/dahdi/xpp/xpd.h
-
-2012-03-15 17:36 +0000 [r10489-10490]  Tzafrir Cohen <tzafrir.cohen@xorcom.com>
-
-	* drivers/dahdi/xpp/card_fxs.c: xpp: FXS: better power-down to
-	  lower noise * Now every linefeed control command which is not
-	  RING'ing powers-down the SLIC. This reduce audible noise when
-	  several channels are ringing. * Simplify code by removing
-	  redundant calls to do_chan_power() before linefeed_control() *
-	  Manage vbat_h state so we skip do_chan_power() calls when there
-	  isn't a state change * Export vbat_h state to /proc/.../fxs_info
-	  Signed-off-by: Oron Peled <oron.peled@xorcom.com> Acked-by:
-	  Tzafrir Cohen <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10478
-
-	* drivers/dahdi/xpp/card_global.c, drivers/dahdi/xpp/card_global.h:
-	  xpp: reset Astribank SPI busses * A driver reload should reset
-	  Astribank hardware * This patch send an SPI reset after we get
-	  AB_DESCRIPTION reply from Astribank Signed-off-by: Oron Peled
-	  <oron.peled@xorcom.com> Acked-by: Tzafrir Cohen
-	  <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10474
-
-2012-03-15 15:03 +0000 [r10481]  Shaun Ruffell <sruffell@digium.com>
-
-	* drivers/dahdi/wctdm24xxp/base.c: wctdm24xxp: Shorten RINGOFF
-	  debounce interval from 512ms to 128ms. In commit r10168
-	  "wctdm24xxp: Use time interval for debouncing FXO ring detect"
-	  [1], I inadvertently changed the debounce interval of the RINGOFF
-	  event from 128ms to 512ms. The result was a potential failure to
-	  detect CID, depending on line conditions, since Asterisk would
-	  bump the rx gains on the channel in the middle of the CID spill
-	  as opposed to before the CID spill. This fixes a regression first
-	  introduced in DAHDI-Linux 2.6.0. [1]
-	  http://svnview.digium.com/svn/dahdi?view=revision&revision=10168
-	  Internal-Issue-ID: DAHDI-951 Reported-and-Tested-by: Jack Wilson
-	  <ljwilson@digitalav.com> Signed-off-by: Shaun Ruffell
-	  <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10473
-
-2012-02-07 22:19 +0000 [r10457]  Tzafrir Cohen <tzafrir.cohen@xorcom.com>
-
-	* drivers/dahdi/xpp/firmwares/USB_RECOV.hex (added),
-	  drivers/dahdi/xpp/firmwares/Makefile: USB_RECOV.hex: recovering
-	  from xpp hardware issues USB_RECOV.hex, rev. 9760. It may be used
-	  to recover from certain issues of the USB controller of the
-	  Astribank (when an Astribank is not detected as such) by Support
-	  staff. Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
-	  Origin: http://svnview.digium.com/svn/dahdi?view=rev&rev=10455
-
-2012-01-25 20:51 +0000 [r10445]  Tzafrir Cohen <tzafrir.cohen@xorcom.com>
-
-	* drivers/dahdi/xpp/firmwares/FPGA_FXS.hex,
-	  drivers/dahdi/xpp/firmwares/FPGA_1141.hex,
-	  drivers/dahdi/xpp/firmwares/FPGA_1151.hex: Astribank I firmwares
-	  rev. 7107 A slightly newer firmware (Xorcom rev. 7107) for older
-	  (non Astribank II) Astribank modules. Was accidentally left
-	  uncommited. Includes minor bug fixes. No change for any
-	  relatively recent (Astribank II) Astribank. Signed-off-by:
-	  Tzafrir Cohen <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10443
-
-2012-01-17 14:50 +0000 [r10442]  Tzafrir Cohen <tzafrir.cohen@xorcom.com>
-
-	* README, drivers/dahdi/Kbuild: Build OSLEC EC if in the tree Build
-	  the OSLEC echo canceller (drivers/staging/echo and
-	  dahdi_echocan_oslec) if the code of oslec is present in the tree.
-	  Also closing another issue regarding documentation of building
-	  OSLEC, as it is now even clearer than before. Patch has been used
-	  in the Debian package for quite some time. Signed-off-by: Tzafrir
-	  Cohen <tzafrir.cohen@xorcom.com> (closes issue DAHLIN-110)
-	  Reported by: biohumanoid (Pavel Selivanov) Patches:
-	  oslec_auto.diff uploaded by tzafrir (license 5035) (closes issue
-	  DAHLIN-261) Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10440
-
-2012-01-10 22:09 +0000 [r10415-10419]  Shaun Ruffell <sruffell@digium.com>
-
-	* drivers/dahdi/xpp/xbus-core.c: xpp: handle failures during
-	  dahdi_register_device() * If dahdi_register_device() failed, not
-	  all resources were freed. When dahdi_unregister_device() was
-	  called later (during driver removal) a panic was caused. * Add
-	  proper error handling for possible failures in
-	  xbus_register_dahdi_device(): - new xbus_free_ddev() safely free
-	  an xbus->ddev - This is called from all failures points. - It is
-	  also called from xbus_unregister_dahdi_device() Signed-off-by:
-	  Oron Peled <oron.peled@xorcom.com> Acked-By: Tzafrir Cohen
-	  <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10410
-
-	* drivers/dahdi/xpp/xpp_dahdi.c, drivers/dahdi/xpp/xbus-core.c:
-	  xpp: Don't deactivate XPDs on unregistration * A bug was
-	  introduced during migration to dahdi_device code:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10273 * Marking
-	  XPDs as non-functional (card_present=0, XPD_STATE_NOHW) was moved
-	  from xbus_request_removal() into xpd_dahdi_preunregister() * As a
-	  result, unregistering an Astribank, made it non-functional so
-	  trying to re-register it later caused errors (e.g: "Cannot open"
-	  error message from xpp_open()) * This fix move XPD deactivation
-	  into the proper location (during xbus_deactivate() Signed-off-by:
-	  Oron Peled <oron.peled@xorcom.com> Acked-By: Tzafrir Cohen
-	  <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10409
-
-	* drivers/dahdi/xpp/xpp_dahdi.c: xpp: bugfix: fix bad refcount Code
-	  path called in error condition contained an superflous put_xpd()
-	  call Signed-off-by: Oron Peled <oron.peled@xorcom.com> Acked-By:
-	  Tzafrir Cohen <tzafrir.cohen@xorcom.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10408
-
-	* drivers/dahdi/wct4xxp/vpm450m.c: wct4xxp: VPM module creates
-	  noise on alternate channels on E1 spans. The VPMOCT128 module was
-	  using the VPMOCT256 timeslots assigments which would mean that
-	  channels that should be marked alaw were being set in ulaw. This
-	  only affected E1 spans since by default all spans are configured
-	  for ulaw by default. This fixes a regression introduced in r10290
-	  [1] "wct4xxp: Add support for TE820 and VPMOCT256", first
-	  released in 2.6.0, that only affects E1 spans on a quad and
-	  dual-span card when used with the hardware echocanceler. [1]
-	  http://svnview.digium.com/svn/dahdi?view=revision&revision=10290
-	  Internal-Issue-ID: DAHDI-945, DAHLIN-275 Signed-off-by: Shaun
-	  Ruffell <sruffell@digium.com> Acked-by: Russ Meyerriecks
-	  <rmeyerriecks@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10414
-
-	* drivers/dahdi/wctdm24xxp/base.c: wctdm24xxp: FXS on-hook
-	  transmission timer incorrect. The DAHDI_ONHOOKTRANSFER ioctl was
-	  incorrectly setting the ohttimer to 0. The result was that an FXS
-	  port was leaving the on-hook transfer state before finishing the
-	  transmission. This was discovered while looking at why ./fxstest
-	  dtmfcid was not able to pass the DTMF callerid digits to an
-	  attached FXO port properly. Fixes a regression introduced in
-	  r10167 "wctdm24xxp: Use interval for checking FXS on hook
-	  transfer timer." [1], first released in 2.6.0. [1]
-	  http://svnview.digium.com/svn/dahdi?view=revision&revision=10167
-	  Signed-off-by: Shaun Ruffell <sruffell@digium.com> Origin:
-	  http://svnview.digium.com/svn/dahdi?view=rev&rev=10413
-
-2012-01-04 22:19 +0000 [r10406]  Shaun Ruffell <sruffell@digium.com>
-
-	* / (added): Creating branch for 2.6.
-
--- a/22
+++ b/22
@@ -64,17 +64,7 @@ ASCIIDOC_CMD:=$(ASCIIDOC) -n -a toc -a toclevels=4

 GENERATED_DOCS:=README.html

-ifneq ($(wildcard .version),)
-  DAHDIVERSION:=$(shell cat .version)
-else
-ifneq ($(wildcard .svn),)
-  DAHDIVERSION:=$(shell build_tools/make_version . dahdi/linux)
-else
-ifneq ($(wildcard .git),)
-  DAHDIVERSION:=$(shell build_tools/make_version . dahdi/linux)
-endif
-endif
-endif
+DAHDIVERSION:=$(shell build_tools/make_version . dahdi/linux)

 all: modules

@@ -92,7 +82,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 +118,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 +192,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/316
+++ b/316
@@ -163,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
@@ -230,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
@@ -418,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 

@@ -473,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
@@ -491,9 +646,14 @@ or dynamically through the udev system.

 * /dev/dahdi/ctl (196:0) - a general device file for various information and
  control operations on the DAHDI channels.
+* /dev/dahdi/chan/N/M - A device file for channel M in span N
+  - Both N and M are zero padded 3 digit numbers
+  - Both N and M start at 001
+  - M is chanpos - numbering relative to the current span.
 * /dev/dahdi/NNN (196:NNN) - for NNN in the range 1-249. A device file for
  DAHDI channel NNN. It can be used to read data from the channel
-  and write data to the channel.
+  and write data to the channel. It is not generated by default but may
+  be generated as a symlink using udev rules.
 * /dev/dahdi/transcode (196:250) - Used to connect to a DAHDI transcoding
  device.
 * /dev/dahdi/timer (196:253) - Allows setting timers. Used anywhere?
@@ -802,6 +962,12 @@ A free-form description of the span.
 ===== /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.

@@ -815,6 +981,60 @@ A very short type string.
 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
--- a/build_tools/make_version
+++ b/build_tools/make_version
@@ -1,7 +1,7 @@
 #!/bin/sh

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

        echo SVN-${RESULT##-}-r${SVN_REV}${MODIFIED}
    fi
+else
+	# Use the directory information in the absence of any other version
+	# information
+	pwd -P
 fi
--- a/drivers/dahdi/Kbuild
+++ b/drivers/dahdi/Kbuild
@@ -11,6 +11,14 @@ 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/
@@ -38,7 +46,7 @@ obj-m += $(DAHDI_MODULES_EXTRA)
 # well:
 ifneq (,$(wildcard $(src)/../staging/echo/echo.c))
 obj-m += dahdi_echocan_oslec.o
-obj-m += ../staging/echo/
+obj-m += ../staging/echo/echo.o
 endif

 CFLAGS_MODULE += -I$(DAHDI_INCLUDE) -I$(src)
@@ -77,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!chan!%03d!%03d", span->spanno, chan->chanpos);
+	dev_set_drvdata(dev, chan);
+	dev->release = chan_release;
+	res = device_register(dev);
+	if (res) {
+		chan_err(chan, "%s: device_register failed: %d\n",
+				__func__, res);
+		put_device(dev);
+		return res;
+	}
+	set_bit(DAHDI_FLAGBIT_DEVFILE, &chan->flags);
+	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,108 +1,35 @@
+/* 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
-
-/*
- * Very old hotplug support
- */
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 9)
-#define	OLD_HOTPLUG_SUPPORT	/* for older kernels */
-#define	OLD_HOTPLUG_SUPPORT_269
-#endif
-
-#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
-
-/*
- * 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, 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)
-#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)
-#else
-#define	DEVICE_ATTR_READER(name, dev, buf)	\
-		ssize_t name(struct device *dev, char *buf)
-#define	DEVICE_ATTR_WRITER(name, dev, buf, count)	\
-		ssize_t name(struct device *dev, const char *buf, size_t count)
-#define BUS_ATTR_READER(name, dev, buf) \
-		ssize_t name(struct device *dev, char *buf)
-#define BUS_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)	\
-		ssize_t name(struct device_driver *drv, char * buf)
+#include "dahdi-sysfs.h"


 static char *initdir = "/usr/share/dahdi";
@@ -118,23 +45,6 @@ static inline struct dahdi_span *dev_to_span(struct device *dev)
 	return dev_get_drvdata(dev);
 }

-#ifdef OLD_HOTPLUG_SUPPORT
-static int span_hotplug(struct device *dev, char **envp, int envnum,
-		char *buff, int bufsize)
-{
-	struct dahdi_span *span;
-
-	if (!dev)
-		return -ENODEV;
-	span = dev_to_span(dev);
-	envp[0] = buff;
-	if (snprintf(buff, bufsize, "SPAN_NAME=%s", span->name) >= bufsize)
-		return -ENOMEM;
-	envp[1] = NULL;
-	return 0;
-}
-#else
-
 #define	SPAN_VAR_BLOCK	\
 	do {		\
 		DAHDI_ADD_UEVENT_VAR("DAHDI_INIT_DIR=%s", initdir);	\
@@ -198,8 +108,6 @@ static int span_uevent(struct device *dev, struct kobj_uevent_env *kenv)

 #endif

-#endif	/* OLD_HOTPLUG_SUPPORT */
-
 #define span_attr(field, format_string)				\
 static BUS_ATTR_READER(field##_show, dev, buf)			\
 {								\
@@ -211,11 +119,18 @@ static BUS_ATTR_READER(field##_show, dev, buf)			\

 span_attr(name, "%s\n");
 span_attr(desc, "%s\n");
-span_attr(spantype, "%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;
@@ -245,6 +160,8 @@ 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);
 }

@@ -256,6 +173,38 @@ static BUS_ATTR_READER(channels_show, dev, buf)
 	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),
@@ -268,6 +217,8 @@ static struct device_attribute span_dev_attrs[] = {
 	__ATTR_RO(is_sync_master),
 	__ATTR_RO(basechan),
 	__ATTR_RO(channels),
+	__ATTR_RO(lineconfig),
+	__ATTR_RO(linecompat),
 	__ATTR_NULL,
 };

@@ -278,11 +229,7 @@ static struct driver_attribute dahdi_attrs[] = {
 static struct bus_type spans_bus_type = {
 	.name           = "dahdi_spans",
 	.match          = span_match,
-#ifdef OLD_HOTPLUG_SUPPORT
-	.hotplug	= span_hotplug,
-#else
 	.uevent         = span_uevent,
-#endif
 	.dev_attrs	= span_dev_attrs,
 	.drv_attrs	= dahdi_attrs,
 };
@@ -310,9 +257,7 @@ static struct device_driver dahdi_driver = {
 	.bus		= &spans_bus_type,
 	.probe		= span_probe,
 	.remove		= span_remove,
-#ifndef OLD_HOTPLUG_SUPPORT
 	.owner		= THIS_MODULE
-#endif
 };

 static void span_uevent_send(struct dahdi_span *span, enum kobject_action act)
@@ -322,26 +267,7 @@ static void span_uevent_send(struct dahdi_span *span, enum kobject_action act)
 	kobj = &span->span_device->kobj;
 	span_dbg(DEVICES, span, "SYFS dev_name=%s action=%d\n",
 		dev_name(span->span_device), act);
-
-#if defined(OLD_HOTPLUG_SUPPORT_269)
-	{
-		/* Copy from new kernels lib/kobject_uevent.c */
-		static const char *const str[] = {
-			[KOBJ_ADD]	"add",
-			[KOBJ_REMOVE]	"remove",
-			[KOBJ_CHANGE]	"change",
-			[KOBJ_MOUNT]	"mount",
-			[KOBJ_UMOUNT]	"umount",
-			[KOBJ_OFFLINE]	"offline",
-			[KOBJ_ONLINE]	"online"
-		};
-		kobject_hotplug(str[act], kobj);
-	}
-#elif defined(OLD_HOTPLUG_SUPPORT)
-	kobject_hotplug(kobj, act);
-#else
 	kobject_uevent(kobj, act);
-#endif
 }

 static void span_release(struct device *dev)
@@ -349,32 +275,6 @@ static void span_release(struct device *dev)
 	dahdi_dbg(DEVICES, "%s: %s\n", __func__, dev_name(dev));
 }

-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);
-	CLASS_DEV_CREATE(dahdi_class, MKDEV(DAHDI_MAJOR, dev->minor), NULL, udevname);
-	kfree(udevname);
-	return 0;
-}
-EXPORT_SYMBOL(dahdi_register_chardev);
-
-int dahdi_unregister_chardev(struct dahdi_chardev *dev)
-{
-	CLASS_DEV_DESTROY(dahdi_class, MKDEV(DAHDI_MAJOR, dev->minor));
-
-	return 0;
-}
-EXPORT_SYMBOL(dahdi_unregister_chardev);
-
 void span_sysfs_remove(struct dahdi_span *span)
 {
 	struct device *span_device;
@@ -386,15 +286,8 @@ void span_sysfs_remove(struct dahdi_span *span)
 	if (!span_device)
 		return;

-	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);
-	}
+	for (x = 0; x < span->channels; x++)
+		chan_sysfs_remove(span->chans[x]);
 	if (!dev_get_drvdata(span_device))
 		return;

@@ -445,28 +338,9 @@ int span_sysfs_create(struct dahdi_span *span)
 	}

 	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;

@@ -475,58 +349,38 @@ 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;
-	unsigned int sysfs_driver_registered:1;
-	unsigned int sysfs_spans_bus_type:1;
-	unsigned int dahdi_device_bus_registered: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;

 static inline struct dahdi_device *to_ddev(struct device *dev)
 {
 	return container_of(dev, struct dahdi_device, dev);
 }

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 13)
-static ssize_t dahdi_device_manufacturer_show(struct device *dev, char *buf)
-#else
 static ssize_t
 dahdi_device_manufacturer_show(struct device *dev,
 			       struct device_attribute *attr, char *buf)
-#endif
 {
 	struct dahdi_device *ddev = to_ddev(dev);
 	return sprintf(buf, "%s\n", ddev->manufacturer);
 }

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 13)
-static ssize_t dahdi_device_type_show(struct device *dev, char *buf)
-#else
 static ssize_t
 dahdi_device_type_show(struct device *dev,
 		       struct device_attribute *attr, char *buf)
-#endif
 {
 	struct dahdi_device *ddev = to_ddev(dev);
 	return sprintf(buf, "%s\n", ddev->devicetype);
 }

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 13)
-static ssize_t dahdi_device_span_count_show(struct device *dev, char *buf)
-#else
 static ssize_t
 dahdi_device_span_count_show(struct device *dev,
 			     struct device_attribute *attr, char *buf)
-#endif
 {
 	struct dahdi_device *ddev = to_ddev(dev);
 	unsigned int count = 0;
@@ -538,13 +392,9 @@ dahdi_device_span_count_show(struct device *dev,
 	return sprintf(buf, "%d\n", count);
 }

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 13)
-static ssize_t dahdi_device_hardware_id_show(struct device *dev, char *buf)
-#else
 static ssize_t
 dahdi_device_hardware_id_show(struct device *dev,
 			     struct device_attribute *attr, char *buf)
-#endif
 {
 	struct dahdi_device *ddev = to_ddev(dev);

@@ -552,28 +402,18 @@ dahdi_device_hardware_id_show(struct device *dev,
 		(ddev->hardware_id) ? ddev->hardware_id : "");
 }

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 13)
-static ssize_t
-dahdi_device_auto_assign(struct device *dev, const char *buf, size_t count)
-#else
 static ssize_t
 dahdi_device_auto_assign(struct device *dev, struct device_attribute *attr,
 			 const char *buf, size_t count)
-#endif
 {
 	struct dahdi_device *ddev = to_ddev(dev);
 	dahdi_assign_device_spans(ddev);
 	return count;
 }

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 13)
-static ssize_t
-dahdi_device_assign_span(struct device *dev, const char *buf, size_t count)
-#else
 static ssize_t
 dahdi_device_assign_span(struct device *dev, struct device_attribute *attr,
 			 const char *buf, size_t count)
-#endif
 {
 	int ret;
 	struct dahdi_span *span;
@@ -585,7 +425,7 @@ dahdi_device_assign_span(struct device *dev, struct device_attribute *attr,
 	ret = sscanf(buf, "%u:%u:%u", &local_span_number, &desired_spanno,
 		     &desired_basechanno);
 	if (ret != 3) {
-		dev_notice(dev, "badly formatted input (should be <num>:<num>:<num>)\n");
+		dev_notice(dev, "bad input (should be <num>:<num>:<num>)\n");
 		return -EINVAL;
 	}

@@ -601,18 +441,14 @@ dahdi_device_assign_span(struct device *dev, struct device_attribute *attr,
 			return (ret) ? ret : count;
 		}
 	}
-	dev_notice(dev, "no match for local span number %d\n", local_span_number);
+	dev_notice(dev, "no match for local span number %d\n",
+		local_span_number);
 	return -EINVAL;
 }

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 13)
-static ssize_t
-dahdi_device_unassign_span(struct device *dev, const char *buf, size_t count)
-#else
 static ssize_t
 dahdi_device_unassign_span(struct device *dev, struct device_attribute *attr,
 			   const char *buf, size_t count)
-#endif
 {
 	int ret;
 	unsigned int local_span_number;
@@ -638,13 +474,9 @@ dahdi_device_unassign_span(struct device *dev, struct device_attribute *attr,
 	return (ret < 0) ? ret : count;
 }

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 13)
-static ssize_t dahdi_spantype_show(struct device *dev, char *buf)
-#else
 static ssize_t
 dahdi_spantype_show(struct device *dev,
 		    struct device_attribute *attr, char *buf)
-#endif
 {
 	struct dahdi_device *ddev = to_ddev(dev);
 	int count = 0;
@@ -653,7 +485,8 @@ dahdi_spantype_show(struct device *dev,

 	/* 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), span->spantype);
+		count = sprintf(buf, "%d:%s\n",
+			local_spanno(span), dahdi_spantype2str(span->spantype));
 		buf += count;
 		total += count;
 	}
@@ -661,24 +494,27 @@ dahdi_spantype_show(struct device *dev,
 	return total;
 }

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 13)
-static ssize_t
-dahdi_spantype_store(struct device *dev, const char *buf, size_t count)
-#else
 static ssize_t
 dahdi_spantype_store(struct device *dev, struct device_attribute *attr,
 		     const char *buf, size_t count)
-#endif
 {
 	struct dahdi_device *const ddev = to_ddev(dev);
 	int ret;
 	struct dahdi_span *span;
 	unsigned int local_span_number;
-	char desired_spantype[80];
+	char spantype_name[80];
+	enum spantypes spantype;

-	ret = sscanf(buf, "%u:%70s", &local_span_number, desired_spantype);
-	if (ret != 2)
+	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)
@@ -692,8 +528,9 @@ dahdi_spantype_store(struct device *dev, struct device_attribute *attr,
 	}

 	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);
+		module_printk(KERN_WARNING,
+				"%d is not a valid local span number "
+				"for this device.\n", local_span_number);
 		return -EINVAL;
 	}

@@ -703,7 +540,7 @@ dahdi_spantype_store(struct device *dev, struct device_attribute *attr,
 		return -EINVAL;
 	}

-	ret = span->ops->set_spantype(span, &desired_spantype[0]);
+	ret = span->ops->set_spantype(span, spantype);
 	return (ret < 0) ? ret : count;
 }

@@ -725,49 +562,30 @@ static struct bus_type dahdi_device_bus = {
 	.dev_attrs = dahdi_device_attrs,
 };

-void dahdi_sysfs_exit(void)
+static void dahdi_sysfs_cleanup(void)
 {
 	dahdi_dbg(DEVICES, "SYSFS\n");
-	if (dummy_dev.pseudo) {
-		dahdi_dbg(DEVICES, "Removing /dev/dahdi/pseudo:\n");
-		DEL_DAHDI_DEV(DAHDI_PSEUDO);
-		dummy_dev.pseudo = 0;
-	}
-	if (dummy_dev.channel) {
-		dahdi_dbg(DEVICES, "Removing /dev/dahdi/channel:\n");
-		DEL_DAHDI_DEV(DAHDI_CHANNEL);
-		dummy_dev.channel = 0;
-	}
-	if (dummy_dev.timer) {
-		dahdi_dbg(DEVICES, "Removing /dev/dahdi/timer:\n");
-		DEL_DAHDI_DEV(DAHDI_TIMER);
-		dummy_dev.timer = 0;
-	}
-	if (dummy_dev.ctl) {
-		dahdi_dbg(DEVICES, "Removing /dev/dahdi/ctl:\n");
-		DEL_DAHDI_DEV(DAHDI_CTL);
-		dummy_dev.ctl = 0;
-	}
-	if (dahdi_class) {
-		dahdi_dbg(DEVICES, "Destroying DAHDI class:\n");
-		class_destroy(dahdi_class);
-		dahdi_class = NULL;
-	}
-	if (dummy_dev.sysfs_driver_registered) {
+	if (should_cleanup.clean_dahdi_driver) {
 		dahdi_dbg(DEVICES, "Unregister driver\n");
 		driver_unregister(&dahdi_driver);
-		dummy_dev.sysfs_driver_registered = 0;
+		should_cleanup.clean_dahdi_driver = 0;
 	}
-	if (dummy_dev.sysfs_spans_bus_type) {
+	if (should_cleanup.clean_span_bus_type) {
 		dahdi_dbg(DEVICES, "Unregister span bus type\n");
 		bus_unregister(&spans_bus_type);
-		dummy_dev.sysfs_spans_bus_type = 0;
+		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;
 	}
-	unregister_chrdev(DAHDI_MAJOR, "dahdi");

-	if (dummy_dev.dahdi_device_bus_registered) {
+	if (should_cleanup.clean_device_bus) {
+		dahdi_dbg(DEVICES, "Unregister DAHDI device bus\n");
 		bus_unregister(&dahdi_device_bus);
-		dummy_dev.dahdi_device_bus_registered = 0;
+		should_cleanup.clean_device_bus = 0;
 	}
 }

@@ -819,79 +637,54 @@ void dahdi_sysfs_unregister_device(struct dahdi_device *ddev)
 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;

-	dummy_dev.dahdi_device_bus_registered = 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;
 	}
-	module_printk(KERN_INFO, "Telephony Interface Registered on major %d\n",
-			DAHDI_MAJOR);
-	module_printk(KERN_INFO, "Version: %s\n", dahdi_version);
+	should_cleanup.clean_chardev = 1;

-	dahdi_class = class_create(THIS_MODULE, "dahdi");
-	if (!dahdi_class) {
-		res = -EEXIST;
+	res = dahdi_sysfs_chan_init(dahdi_fops);
+	if (res)
 		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;
 	res = bus_register(&spans_bus_type);
-	if (res != 0) {
+	if (res) {
 		dahdi_err("%s: bus_register(%s) failed. Error number %d",
 			__func__, spans_bus_type.name, res);
 		goto cleanup;
 	}
-	dummy_dev.sysfs_spans_bus_type = 1;
+	should_cleanup.clean_span_bus_type = 1;
+
 	res = driver_register(&dahdi_driver);
-	if (res < 0) {
+	if (res) {
 		dahdi_err("%s: driver_register(%s) failed. Error number %d",
 			__func__, dahdi_driver.name, res);
 		goto cleanup;
 	}
-	dummy_dev.sysfs_driver_registered = 1;
+	should_cleanup.clean_dahdi_driver = 1;

+	module_printk(KERN_INFO, "Telephony Interface Registered on major %d\n",
+			DAHDI_MAJOR);
 	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.
 *
--- 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.
 *
--- 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();
 }

@@ -396,12 +411,7 @@ static void dahdi_dynamic_release(struct kref *kref)

 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)
@@ -713,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)
@@ -845,6 +869,8 @@ static int dahdi_dynamic_init(void)
 	mod_timer(&alarmcheck, jiffies + 1 * HZ);
 #ifdef ENABLE_TASKLETS
 	tasklet_init(&dahdi_dynamic_tlet, dahdi_dynamic_tasklet, 0);
+#else
+	tasklet_init(&dahdi_dynamic_flush_tlet, dahdi_dynamic_flush_tasklet, 0);
 #endif
 	dahdi_set_dynamic_ops(&dahdi_dynamic_ops);

@@ -861,6 +887,9 @@ static void dahdi_dynamic_cleanup(void)
 		tasklet_disable(&dahdi_dynamic_tlet);
 		tasklet_kill(&dahdi_dynamic_tlet);
 	}
+#else
+	tasklet_disable(&dahdi_dynamic_flush_tlet);
+	tasklet_kill(&dahdi_dynamic_flush_tlet);
 #endif
 	del_timer_sync(&alarmcheck);
 	/* Must call again in case it was running before and rescheduled
--- 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.
 *
@@ -76,11 +76,7 @@ static struct dahdi_span *ztdeth_getspan(unsigned char *addr, unsigned short sub
 	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;
@@ -89,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
@@ -193,44 +185,16 @@ static void ztdeth_transmit(struct dahdi_dynamic *dyn, u8 *msg, size_t msglen)
 		spin_unlock_irqrestore(&zlock, flags);
 }

-/**
- * dahdi_dynamic_flush_work_fn - Flush all pending transactions.
- *
- * This function is run in a work queue since we can't guarantee interrupts
- * will be enabled when we're called, and dev_queue_xmit() requires that
- * interrupts be enabled.
- *
- */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
-static void dahdi_dynamic_flush_work_fn(void *data)
-#else
-static void dahdi_dynamic_flush_work_fn(struct work_struct *work)
-#endif
-{
-	struct sk_buff *skb;
-	/* Handle all transmissions now */
-	while ((skb = skb_dequeue(&skbs))) {
-		dev_queue_xmit(skb);
-	}
-}
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
-static DECLARE_WORK(dahdi_dynamic_eth_flush_work,
-		    dahdi_dynamic_flush_work_fn, NULL);
-#else
-static DECLARE_WORK(dahdi_dynamic_eth_flush_work,
-		    dahdi_dynamic_flush_work_fn);
-#endif
-
 /**
 * ztdeth_flush - Flush all pending transactions.
 *
- * This function is called in interrupt context while processing the master
- * span.
+ * This function is always called in softirq context.
 */
 static int ztdeth_flush(void)
 {
-	schedule_work(&dahdi_dynamic_eth_flush_work);
+	struct sk_buff *skb;
+	while ((skb = skb_dequeue(&skbs)))
+		dev_queue_xmit(skb);
 	return 0;
 }

@@ -454,11 +418,6 @@ static int __init ztdeth_init(void)

 static void __exit ztdeth_exit(void)
 {
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
-	flush_scheduled_work();
-#else
-	cancel_work_sync(&dahdi_dynamic_eth_flush_work);
-#endif
 	dahdi_dynamic_unregister_driver(&ztd_eth);
 	unregister_netdevice_notifier(&ztdeth_nblock);
 	dev_remove_pack(&ztdeth_ptype);
--- 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_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,6 +22,7 @@

 .PHONY: dist-clean clean all uninstall have_download install object-build hotplug-install hotplug-dirs hotplug-uninstall make_firmware_object firmware-loaders

+OCT6114_032_VERSION:=1.05.01
 OCT6114_064_VERSION:=1.05.01
 OCT6114_128_VERSION:=1.05.01
 OCT6114_256_VERSION:=1.05.01
@@ -30,10 +31,12 @@ VPMADT032_VERSION:=1.25.0
 HX8_VERSION:=2.06
 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-OCT6114-256 FIRMWARE-TC400M FIRMWARE-HX8 FIRMWARE-VPMOCT032 FIRMWARE-TE820
+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
@@ -42,17 +45,21 @@ ALL_FIRMWARE=FIRMWARE-OCT6114-064 FIRMWARE-OCT6114-128 FIRMWARE-OCT6114-256 FIRM
 # This means this is version MR5.6 of the tc400m firmware

 # Build a list of firmware package filenames we need
-FIRMWARE:=$(ALL_FIRMWARE:FIRMWARE-OCT6114-064=dahdi-fw-oct6114-064-$(OCT6114_064_VERSION).tar.gz)
+FIRMWARE:=$(ALL_FIRMWARE:FIRMWARE-OCT6114-032=dahdi-fw-oct6114-032-$(OCT6114_032_VERSION).tar.gz)
+FIRMWARE:=$(FIRMWARE:FIRMWARE-OCT6114-064=dahdi-fw-oct6114-064-$(OCT6114_064_VERSION).tar.gz)
 FIRMWARE:=$(FIRMWARE:FIRMWARE-OCT6114-128=dahdi-fw-oct6114-128-$(OCT6114_128_VERSION).tar.gz)
 FIRMWARE:=$(FIRMWARE:FIRMWARE-OCT6114-256=dahdi-fw-oct6114-256-$(OCT6114_256_VERSION).tar.gz)
 FIRMWARE:=$(FIRMWARE:FIRMWARE-TC400M=dahdi-fw-tc400m-$(TC400M_VERSION).tar.gz)
 FIRMWARE:=$(FIRMWARE:FIRMWARE-HX8=dahdi-fw-hx8-$(HX8_VERSION).tar.gz)
 FIRMWARE:=$(FIRMWARE:FIRMWARE-VPMOCT032=dahdi-fw-vpmoct032-$(VPMOCT032_VERSION).tar.gz)
 FIRMWARE:=$(FIRMWARE:FIRMWARE-TE820=dahdi-fw-te820-$(WCT820_VERSION).tar.gz)
+FIRMWARE:=$(FIRMWARE:FIRMWARE-TE133=dahdi-fw-te133-$(TE133_VERSION).tar.gz)
+FIRMWARE:=$(FIRMWARE:FIRMWARE-TE134=dahdi-fw-te134-$(TE134_VERSION).tar.gz)

 FWLOADERS:=dahdi-fwload-vpmadt032-$(VPMADT032_VERSION).tar.gz

 # Build a list of object files if hotplug will not be used
+OBJECT_FILES:=$(ALL_FIRMWARE:FIRMWARE-OCT6114-032=dahdi-fw-oct6114-032.o)
 OBJECT_FILES:=$(ALL_FIRMWARE:FIRMWARE-OCT6114-064=dahdi-fw-oct6114-064.o)
 OBJECT_FILES:=$(OBJECT_FILES:FIRMWARE-OCT6114-128=dahdi-fw-oct6114-128.o)
 OBJECT_FILES:=$(OBJECT_FILES:FIRMWARE-OCT6114-256=dahdi-fw-oct6114-256.o)
@@ -107,6 +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
@@ -185,6 +203,29 @@ 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:
 	if [ -d $(DESTDIR)/usr/lib/hotplug/firmware ]; then \
@@ -202,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
--- 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/tor2.c
+++ b/drivers/dahdi/tor2.c
@@ -290,12 +290,12 @@ static void init_spans(struct tor2 *tor)
 			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;
--- 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/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.
 *
 */
@@ -90,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;
@@ -139,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);
@@ -1197,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)
@@ -1225,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!
@@ -1249,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;
 	}
@@ -1302,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)
 {
@@ -1315,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. */
@@ -1332,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()) {
@@ -1355,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;

@@ -1441,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;
 		}
@@ -1462,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 */
@@ -1484,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
 */
@@ -1494,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. */
@@ -1528,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",
@@ -1548,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.
@@ -1591,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);
 	}
 }

@@ -1849,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);
@@ -2340,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. */
@@ -2474,7 +2506,9 @@ static void init_spans(struct b4xxp *b4)
 		bspan = &b4->spans[i];
 		bspan->parent = b4;

-		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;
@@ -3118,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 */
--- a/drivers/dahdi/wct1xxp.c
+++ b/drivers/dahdi/wct1xxp.c
@@ -792,12 +792,12 @@ static int t1xxp_software_init(struct t1xxp *wc)
 		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);
--- a/drivers/dahdi/wct4xxp/Kbuild
+++ b/drivers/dahdi/wct4xxp/Kbuild
@@ -14,7 +14,7 @@ ifeq ($(HOTPLUG_FIRMWARE),yes)
  EXTRA_CFLAGS+=-DHOTPLUG_FIRMWARE
 endif

-wct4xxp-objs := base.o vpm450m.o $(shell $(src)/../oct612x/octasic-helper objects ../oct612x)
+wct4xxp-objs := base.o vpm450m.o ../oct612x/lib.a

 ifneq ($(HOTPLUG_FIRMWARE),yes)
 wct4xxp-objs += $(FIRM_DIR)/dahdi-fw-oct6114-064.o $(FIRM_DIR)/dahdi-fw-oct6114-128.o $(FIRM_DIR)/dahdi-fw-oct6114-256.o
--- 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
@@ -9,7 +9,7 @@
 *   Russ Meyerriecks <rmeyerriecks@digium.com>
 *
 * Copyright (C) 2001 Jim Dixon / Zapata Telephony.
- * Copyright (C) 2001-2011, Digium, Inc.
+ * Copyright (C) 2001-2012, Digium, Inc.
 *
 * All rights reserved.
 *
@@ -119,11 +119,7 @@ struct cpu_workqueue_struct {
 */
 struct workqueue_struct {
 	/* TODO: Find out exactly where the API changed */
-#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
 	struct cpu_workqueue_struct *cpu_wq;
-#else
-	struct cpu_workqueue_struct cpu_wq[NR_CPUS];
-#endif
 	const char *name;
 	struct list_head list; 	/* Empty if single thread */
 };
@@ -394,7 +390,7 @@ static inline bool is_pcie(const struct t4 *wc)

 static inline bool has_e1_span(const struct t4 *wc)
 {
-	return (wc->t1e1) != 0;
+	return (wc->t1e1 > 0);
 }

 static inline bool is_octal(const struct t4 *wc)
@@ -440,6 +436,7 @@ static const struct dahdi_echocan_ops vpm_ec_ops = {
 #endif

 static void __set_clear(struct t4 *wc, int span);
+static int _t4_startup(struct file *file, struct dahdi_span *span);
 static int t4_startup(struct file *file, struct dahdi_span *span);
 static int t4_shutdown(struct dahdi_span *span);
 static int t4_rbsbits(struct dahdi_chan *chan, int bits);
@@ -1124,6 +1121,7 @@ static int t4_echocan_create(struct dahdi_chan *chan,
 	int channel;
 	const struct dahdi_echocan_ops *ops;
 	const struct dahdi_echocan_features *features;
+	const bool alaw = (chan->span->deflaw == 2);

 	if (!vpmsupport || !wc->vpm)
 		return -ENODEV;
@@ -1144,19 +1142,19 @@ static int t4_echocan_create(struct dahdi_chan *chan,

 	channel = has_e1_span(wc) ? chan->chanpos : chan->chanpos + 4;

-	if (wc->vpm) {
-		if (is_octal(wc))
-			channel = channel << 3;
-		else
-			channel = channel << 2;
-		channel |= chan->span->offset;
-		if (debug & DEBUG_ECHOCAN)
-			dev_notice(&wc->dev->dev, "echocan: Card is %d, "
-				"Channel is %d, Span is %d, offset is %d "
-				"length %d\n", wc->num, chan->chanpos,
-				chan->span->offset, channel, ecp->tap_length);
-		vpm450m_setec(wc->vpm, channel, ecp->tap_length);
+	if (is_octal(wc))
+		channel = channel << 3;
+	else
+		channel = channel << 2;
+	channel |= chan->span->offset;
+	if (debug & DEBUG_ECHOCAN) {
+		dev_notice(&wc->dev->dev,
+			   "echocan: Card is %d, Channel is %d, Span is %d, offset is %d length %d\n",
+			   wc->num, chan->chanpos, chan->span->offset,
+			   channel, ecp->tap_length);
 	}
+	vpm450m_set_alaw_companding(wc->vpm, channel, alaw);
+	vpm450m_setec(wc->vpm, channel, ecp->tap_length);
 	return 0;
 }

@@ -1165,23 +1163,23 @@ static void echocan_free(struct dahdi_chan *chan, struct dahdi_echocan_state *ec
 	struct t4 *wc = chan->pvt;
 	int channel;

-	memset(ec, 0, sizeof(*ec));
+	if (!wc->vpm)
+		return;

+	memset(ec, 0, sizeof(*ec));
 	channel = has_e1_span(wc) ? chan->chanpos : chan->chanpos + 4;

-	if (wc->vpm) {
-		if (is_octal(wc))
-			channel = channel << 3;
-		else
-			channel = channel << 2;
-		channel |= chan->span->offset;
-		if (debug & DEBUG_ECHOCAN)
-			dev_notice(&wc->dev->dev, "echocan: Card is %d, "
-				"Channel is %d, Span is %d, offset is %d "
-				"length 0\n", wc->num, chan->chanpos,
-				chan->span->offset, channel);
-		vpm450m_setec(wc->vpm, channel, 0);
+	if (is_octal(wc))
+		channel = channel << 3;
+	else
+		channel = channel << 2;
+	channel |= chan->span->offset;
+	if (debug & DEBUG_ECHOCAN) {
+		dev_notice(&wc->dev->dev,
+			   "echocan: Card is %d, Channel is %d, Span is %d, offset is %d length 0\n",
+			   wc->num, chan->chanpos, chan->span->offset, channel);
 	}
+	vpm450m_setec(wc->vpm, channel, 0);
 }
 #endif

@@ -1239,9 +1237,11 @@ static int t4_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long dat
 		else
 			clear_bit(chan->chanpos - 1, &ts->dtmfmutemask);

-		channel = (chan->chanpos) << 3;
-		if (!has_e1_span(wc))
-			channel += (4 << 3);
+		channel = has_e1_span(wc) ? chan->chanpos : chan->chanpos + 4;
+		if (is_octal(wc))
+			channel = channel << 3;
+		else
+			channel = channel << 2;
 		channel |= chan->span->offset;
 		vpm450m_setdtmf(wc->vpm, channel, j & DAHDI_TONEDETECT_ON,
 				j & DAHDI_TONEDETECT_MUTE);
@@ -1697,7 +1697,7 @@ static void t4_chan_set_sigcap(struct dahdi_span *span, int x)
 }

 static int
-t4_spanconfig(struct file *file, struct dahdi_span *span,
+_t4_spanconfig(struct file *file, struct dahdi_span *span,
 	      struct dahdi_lineconfig *lc)
 {
 	int i;
@@ -1737,13 +1737,36 @@ t4_spanconfig(struct file *file, struct dahdi_span *span,

 	/* If we're already running, then go ahead and apply the changes */
 	if (span->flags & DAHDI_FLAG_RUNNING)
-		return t4_startup(file, span);
+		return _t4_startup(file, span);

 	if (debug)
 		dev_info(&wc->dev->dev, "Done with spanconfig!\n");
 	return 0;
 }

+static int
+t4_spanconfig(struct file *file, struct dahdi_span *span,
+	      struct dahdi_lineconfig *lc)
+{
+	int ret;
+	struct dahdi_device *const ddev = span->parent;
+	struct dahdi_span *s;
+
+	ret = _t4_spanconfig(file, span, lc);
+
+	/* Make sure all the spans have a basic configuration in case they are
+	 * not all specified in the configuration files. */
+	lc->sync = 0;
+	list_for_each_entry(s, &ddev->spans, device_node) {
+		WARN_ON(!s->channels);
+		if (!s->channels)
+			continue;
+		if (!s->chans[0]->sigcap)
+			_t4_spanconfig(file, s, lc);
+	}
+	return ret;
+}
+
 static int
 t4_chanconfig(struct file *file, struct dahdi_chan *chan, int sigtype)
 {
@@ -2037,7 +2060,7 @@ static void t4_span_assigned(struct dahdi_span *span)
 	/* We use this to make sure all the spans are assigned before
 	 * running the serial setup. */
 	list_for_each_entry(pos, &wc->ddev->spans, device_node) {
-		if (!test_bit(DAHDI_FLAGBIT_REGISTERED, &span->flags))
+		if (!test_bit(DAHDI_FLAGBIT_REGISTERED, &pos->flags))
 			++unassigned_spans;
 	}

@@ -2093,6 +2116,8 @@ static int t4_alloc_channels(struct t4 *wc, struct t4_span *ts,
 	for (i = 0; i < ARRAY_SIZE(ts->chans); ++i) {
 		kfree(ts->chans[i]);
 		kfree(ts->ec[i]);
+		ts->chans[i] = NULL;
+		ts->ec[i] = NULL;
 	}

 	ts->linemode = linemode;
@@ -2132,13 +2157,13 @@ static void t4_init_one_span(struct t4 *wc, struct t4_span *ts)

 	switch (ts->linemode) {
 	case T1:
-		ts->span.spantype = "T1";
+		ts->span.spantype = SPANTYPE_DIGITAL_T1;
 		break;
 	case E1:
-		ts->span.spantype = "E1";
+		ts->span.spantype = SPANTYPE_DIGITAL_E1;
 		break;
 	case J1:
-		ts->span.spantype = "J1";
+		ts->span.spantype = SPANTYPE_DIGITAL_J1;
 		break;
 	}

@@ -2187,40 +2212,53 @@ static void t4_init_one_span(struct t4 *wc, struct t4_span *ts)
 /**
 * t4_set_linemode - Allows user space to change the linemode before spans are assigned.
 * @span:	span on which to change the linemode.
- * @linemode:	Textual description of the new linemode.
+ * @linemode:	A value from enumerated spantypes
 *
 * This callback is used to override the E1/T1 mode jumper settings and set
 * the linemode on for each span. Called when the "spantype" attribute
 * is written in sysfs under the dahdi_device.
 *
 */
-static int t4_set_linemode(struct dahdi_span *span, const char *linemode)
+static int t4_set_linemode(struct dahdi_span *span, enum spantypes linemode)
 {
 	struct t4_span *ts = container_of(span, struct t4_span, span);
 	struct t4 *wc = ts->owner;
 	int res = 0;
 	enum linemode mode;
+	const char *old_name;
+	static DEFINE_MUTEX(linemode_lock);

-	dev_dbg(&wc->dev->dev, "Setting '%s' to '%s'\n", span->name, linemode);
+	dev_dbg(&wc->dev->dev, "Setting '%s' to '%s'\n", span->name,
+		dahdi_spantype2str(linemode));

-	if (!strcasecmp(span->spantype, linemode))
+	if (span->spantype == linemode)
 		return 0;

-	if (!strcasecmp(linemode, "t1")) {
+	/* Do not allow the t1e1 member to be changed by multiple threads. */
+	mutex_lock(&linemode_lock);
+	old_name = dahdi_spantype2str(span->spantype);
+	switch (linemode) {
+	case SPANTYPE_DIGITAL_T1:
 		dev_info(&wc->dev->dev,
-			 "Changing from %s to T1 line mode.\n", span->spantype);
+			 "Changing from %s to T1 line mode.\n", old_name);
 		mode = T1;
-	} else if (!strcasecmp(linemode, "e1")) {
+		wc->t1e1 &= ~(1 << span->offset);
+		break;
+	case SPANTYPE_DIGITAL_E1:
 		dev_info(&wc->dev->dev,
-			 "Changing from %s to E1 line mode.\n", span->spantype);
+			 "Changing from %s to E1 line mode.\n", old_name);
 		mode = E1;
-	} else if (!strcasecmp(linemode, "j1")) {
+		wc->t1e1 |= (1 << span->offset);
+		break;
+	case SPANTYPE_DIGITAL_J1:
 		dev_info(&wc->dev->dev,
-			 "Changing from %s to J1 line mode.\n", span->spantype);
+			 "Changing from %s to J1 line mode.\n", old_name);
 		mode = J1;
-	} else {
+		wc->t1e1 &= ~(1 << span->offset);
+		break;
+	default:
 		dev_err(&wc->dev->dev,
-			"'%s' is an unknown linemode.\n", linemode);
+			"Got invalid linemode %d from dahdi\n", linemode);
 		res = -EINVAL;
 	}

@@ -2230,6 +2268,7 @@ static int t4_set_linemode(struct dahdi_span *span, const char *linemode)
 		dahdi_init_span(span);
 	}

+	mutex_unlock(&linemode_lock);
 	return res;
 }

@@ -2297,13 +2336,13 @@ static void init_spans(struct t4 *wc)
 			 "T%dXXP (PCI) Card %d Span %d", wc->numspans, wc->num, x+1);
 		switch (ts->linemode) {
 		case T1:
-			ts->span.spantype = "T1";
+			ts->span.spantype = SPANTYPE_DIGITAL_T1;
 			break;
 		case E1:
-			ts->span.spantype = "E1";
+			ts->span.spantype = SPANTYPE_DIGITAL_E1;
 			break;
 		case J1:
-			ts->span.spantype = "J1";
+			ts->span.spantype = SPANTYPE_DIGITAL_J1;
 			break;
 		}

@@ -2417,7 +2456,6 @@ static void __t4_set_sclk_src(struct t4 *wc, int mode, int master, int slave)
 	__t4_pci_out(wc, WC_DMACTRL, wc->dmactrl);
 }

-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18))
 static ssize_t t4_timing_master_show(struct device *dev,
 				     struct device_attribute *attr,
 				     char *buf)
@@ -2448,13 +2486,6 @@ static void remove_sysfs_files(struct t4 *wc)
 			   &dev_attr_timing_master);
 }

-#else
-
-static inline void create_sysfs_files(struct t4 *wc) { return; }
-static inline void remove_sysfs_files(struct t4 *wc) { return; }
-
-#endif /* LINUX_KERNEL > 2.6.18 */
-
 static inline void __t4_update_timing(struct t4 *wc)
 {
 	int i;
@@ -2836,7 +2867,7 @@ static int t4_check_for_interrupts(struct t4 *wc)
 	return 0;
 }

-static int t4_startup(struct file *file, struct dahdi_span *span)
+static int _t4_startup(struct file *file, struct dahdi_span *span)
 {
 #ifdef SUPPORT_GEN1
 	int i;
@@ -2969,6 +3000,21 @@ static int t4_startup(struct file *file, struct dahdi_span *span)
 	return 0;
 }

+static int t4_startup(struct file *file, struct dahdi_span *span)
+{
+	int ret;
+	struct dahdi_device *const ddev = span->parent;
+	struct dahdi_span *s;
+
+	ret = _t4_startup(file, span);
+	list_for_each_entry(s, &ddev->spans, device_node) {
+		if (!test_bit(DAHDI_FLAGBIT_RUNNING, &s->flags)) {
+			_t4_startup(file, s);
+		}
+	}
+	return ret;
+}
+
 #ifdef SUPPORT_GEN1
 static inline void e1_check(struct t4 *wc, int span, int val)
 {
@@ -3644,7 +3690,7 @@ static inline void t4_framer_interrupt(struct t4 *wc, int span)
 	}
 	if (!ts->span.alarms) {
 		if ((isr3 & 0x3) || (isr4 & 0xc0))
-			ts->span.timingslips++;
+			ts->span.count.timingslips++;

 		if (debug & DEBUG_MAIN) {
 			if (isr3 & 0x02)
@@ -3665,7 +3711,7 @@ static inline void t4_framer_interrupt(struct t4 *wc, int span)
 					wc->numspans, span + 1);
 		}
 	} else
-		ts->span.timingslips = 0;
+		ts->span.count.timingslips = 0;

 	spin_lock_irqsave(&wc->reglock, flags);
 	/* HDLC controller checks - receive side */
@@ -4654,12 +4700,6 @@ static int t8_update_firmware(struct t4 *wc, const struct firmware *fw,
 	const u32 BASE_ADDRESS = 0x00080000;
 	const u8 *data, *end;
 	size_t size = 0;
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 10)
-	u32 *pci_state;
-	pci_state = kzalloc(64 * sizeof(u32), GFP_KERNEL);
-	if (!pci_state)
-		return -ENOMEM;
-#endif

 	/* Erase flash */
 	erase_half(wc);
@@ -4684,11 +4724,7 @@ static int t8_update_firmware(struct t4 *wc, const struct firmware *fw,

 	/* Reset te820 fpga after loading firmware */
 	dev_info(&wc->dev->dev, "Firmware load complete. Reseting device.\n");
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 10)
-	res = pci_save_state(wc->dev, pci_state);
-#else
 	res = pci_save_state(wc->dev);
-#endif
 	if (res)
 		goto error_exit;
 	/* Set the fpga reset bits and clobber the remainder of the
@@ -4696,11 +4732,7 @@ static int t8_update_firmware(struct t4 *wc, const struct firmware *fw,
 	t4_pci_out(wc, WC_LEDS, 0xe0000000);
 	msleep(1000);

-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 10)
-	pci_restore_state(wc->dev, pci_state);
-#else
 	pci_restore_state(wc->dev);
-#endif

 	/* Signal the driver to restart initialization.
 	 * This will back out all initialization so far and
@@ -4708,9 +4740,6 @@ static int t8_update_firmware(struct t4 *wc, const struct firmware *fw,
 	return -EAGAIN;

 error_exit:
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 10)
-	kfree(pci_state);
-#endif
 	return res;
 }

@@ -5428,13 +5457,11 @@ static DEFINE_PCI_DEVICE_TABLE(t4_pci_tbl) =
 	{ 0, }
 };

-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 12)
 static void _t4_shutdown(struct pci_dev *pdev)
 {
 	struct t4 *wc = pci_get_drvdata(pdev);
 	t4_hardware_stop(wc);
 }
-#endif

 static int t4_suspend(struct pci_dev *pdev, pm_message_t state)
 {
@@ -5445,9 +5472,7 @@ static struct pci_driver t4_driver = {
 	.name = "wct4xxp",
 	.probe = t4_init_one_retry,
 	.remove = __devexit_p(t4_remove_one),
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 12)
 	.shutdown = _t4_shutdown,
-#endif
 	.suspend = t4_suspend,
 	.id_table = t4_pci_tbl,
 };
--- 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)
 {
@@ -181,6 +182,7 @@ struct vpm450m {
 #define FLAG_DTMF	 (1 << 0)
 #define FLAG_MUTE	 (1 << 1)
 #define FLAG_ECHO	 (1 << 2)
+#define FLAG_ALAW	 (1 << 3)

 static unsigned int tones[] = {
 	SOUT_DTMF_1,
@@ -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);
@@ -528,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 & mask])
+			if (isalaw[x & mask]) {
 				law = cOCT6100_PCM_A_LAW;
-			else
+				vpm450m->chanflags[x] |= FLAG_ALAW;
+			} else {
 				law = cOCT6100_PCM_U_LAW;
+				vpm450m->chanflags[x] &= ~(FLAG_ALAW);
+			}
 			Oct6100ChannelOpenDef(ChannelOpen);
 			ChannelOpen->pulChannelHndl = &vpm450m->aulEchoChanHndl[x];
 			ChannelOpen->ulUserChanId = x;
--- 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/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,13 +69,6 @@
 		dev_info(&(wc)->pdev->dev, _fmt, ## _args);		\
 	}								\

-#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
@@ -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);
 	}

--- 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
@@ -7,7 +7,7 @@
 * Support for Hx8 by Andrew Kohlsmith <akohlsmith@mixdown.ca> and Matthew
 * Fredrickson <creslin@digium.com>
 *
- * Copyright (C) 2005 - 2011 Digium, Inc.
+ * Copyright (C) 2005 - 2012 Digium, Inc.
 * All rights reserved.
 *
 * Sections for QRV cards written by Jim Dixon <jim@lambdatel.com>
@@ -1833,19 +1833,22 @@ static void wctdm_qrvdri_check_hook(struct wctdm *wc, int card)
 static inline bool is_fxo_ringing(const struct fxo *const fxo)
 {
 	return ((fxo->hook_ring_shadow & 0x60) &&
-		(fxo->battery_state == BATTERY_PRESENT));
+		((fxo->battery_state == BATTERY_PRESENT) ||
+		 (fxo->battery_state == BATTERY_DEBOUNCING_LOST)));
 }

 static inline bool is_fxo_ringing_positive(const struct fxo *const fxo)
 {
 	return (((fxo->hook_ring_shadow & 0x60) == 0x20) &&
-		(fxo->battery_state == BATTERY_PRESENT));
+		((fxo->battery_state == BATTERY_PRESENT) ||
+		 (fxo->battery_state == BATTERY_DEBOUNCING_LOST)));
 }

 static inline bool is_fxo_ringing_negative(const struct fxo *const fxo)
 {
 	return (((fxo->hook_ring_shadow & 0x60) == 0x40) &&
-		(fxo->battery_state == BATTERY_PRESENT));
+		((fxo->battery_state == BATTERY_PRESENT) ||
+		 (fxo->battery_state == BATTERY_DEBOUNCING_LOST)));
 }

 static inline void set_ring(struct fxo *fxo, enum ring_detector_state new)
@@ -1856,19 +1859,21 @@ static inline void set_ring(struct fxo *fxo, enum ring_detector_state new)
 static void wctdm_fxo_ring_detect(struct wctdm *wc, struct wctdm_module *mod)
 {
 	struct fxo *const fxo = &mod->mod.fxo;
+	static const unsigned int POLARITY_CHANGES_NEEDED = 2;

 	/* Look for ring status bits (Ring Detect Signal Negative and Ring
-	 * Detect Signal Positive) to transition back and forth some number of
-	 * times to indicate that a ring is occurring.  Provide some number of
-	 * samples to allow for the transitions to occur before giving up.
-	 * NOTE: neon mwi voltages will trigger one of these bits to go active
-	 * but not to have transitions between the two bits (i.e. no negative
-	 * to positive or positive to negative traversals) */
+	 * Detect Signal Positive) to transition back and forth
+	 * POLARITY_CHANGES_NEEDED times to indicate that a ring is occurring.
+	 * Provide some number of samples to allow for the transitions to occur
+	 * before giving up.  NOTE: neon mwi voltages will trigger one of these
+	 * bits to go active but not to have transitions between the two bits
+	 * (i.e. no negative to positive or positive to negative traversals) */

 	switch (fxo->ring_state) {
 	case DEBOUNCING_RINGING_POSITIVE:
 		if (is_fxo_ringing_negative(fxo)) {
-			if (++fxo->ring_polarity_change_count > 4) {
+			if (++fxo->ring_polarity_change_count >
+						POLARITY_CHANGES_NEEDED) {
 				mod_hooksig(wc, mod, DAHDI_RXSIG_RING);
 				set_ring(fxo, RINGING);
 				if (debug) {
@@ -1886,7 +1891,8 @@ static void wctdm_fxo_ring_detect(struct wctdm *wc, struct wctdm_module *mod)
 		break;
 	case DEBOUNCING_RINGING_NEGATIVE:
 		if (is_fxo_ringing_positive(fxo)) {
-			if (++fxo->ring_polarity_change_count > 4) {
+			if (++fxo->ring_polarity_change_count >
+						POLARITY_CHANGES_NEEDED) {
 				mod_hooksig(wc, mod, DAHDI_RXSIG_RING);
 				set_ring(fxo, RINGING);
 				if (debug) {
@@ -1955,19 +1961,26 @@ wctdm_check_battery_lost(struct wctdm *wc, struct wctdm_module *const mod)
 	   battery present or unknown, debounce timer (going to battery lost)
 	*/
 	switch (fxo->battery_state) {
+	case BATTERY_DEBOUNCING_PRESENT_ALARM:
+		fxo->battery_state = BATTERY_DEBOUNCING_LOST_FROM_PRESENT_ALARM;
+		fxo->battdebounce_timer = wc->framecount + battdebounce;
+		break;
 	case BATTERY_DEBOUNCING_PRESENT:
-		/* we were going to BATTERY_PRESENT, but
-		 * battery was lost again. */
 		fxo->battery_state = BATTERY_LOST;
 		break;
+	case BATTERY_DEBOUNCING_PRESENT_FROM_LOST_ALARM:
+		fxo->battery_state = BATTERY_DEBOUNCING_LOST_ALARM;
+		fxo->battdebounce_timer = wc->framecount +
+						battalarm - battdebounce;
+		break;
 	case BATTERY_UNKNOWN:
 		mod_hooksig(wc, mod, DAHDI_RXSIG_ONHOOK);
-	case BATTERY_DEBOUNCING_PRESENT_ALARM: /* intentional drop through */
 	case BATTERY_PRESENT:
 		fxo->battery_state = BATTERY_DEBOUNCING_LOST;
 		fxo->battdebounce_timer = wc->framecount + battdebounce;
 		break;
-	case BATTERY_DEBOUNCING_LOST:
+	case BATTERY_DEBOUNCING_LOST_FROM_PRESENT_ALARM:
+	case BATTERY_DEBOUNCING_LOST: /* Intentional drop through */
 		if (time_after(wc->framecount, fxo->battdebounce_timer)) {
 			if (debug) {
 				dev_info(&wc->vb.pdev->dev,
@@ -2016,8 +2029,9 @@ wctdm_check_battery_present(struct wctdm *wc, struct wctdm_module *const mod)
 	struct fxo *const fxo = &mod->mod.fxo;

 	switch (fxo->battery_state) {
-	case BATTERY_DEBOUNCING_PRESENT:
-		if (time_after(jiffies, fxo->battdebounce_timer)) {
+	case BATTERY_DEBOUNCING_PRESENT_FROM_LOST_ALARM:
+	case BATTERY_DEBOUNCING_PRESENT: /* intentional drop through */
+		if (time_after(wc->framecount, fxo->battdebounce_timer)) {
 			if (debug) {
 				dev_info(&wc->vb.pdev->dev,
 					 "BATTERY on %d/%d (%s)!\n",
@@ -2042,12 +2056,12 @@ wctdm_check_battery_present(struct wctdm *wc, struct wctdm_module *const mod)
 			 * of its time period has already passed while
 			 * debouncing occurred */
 			fxo->battery_state = BATTERY_DEBOUNCING_PRESENT_ALARM;
-			fxo->battdebounce_timer = jiffies +
-				msecs_to_jiffies(battalarm - battdebounce);
+			fxo->battdebounce_timer = wc->framecount +
+						   battalarm - battdebounce;
 		}
 		break;
 	case BATTERY_DEBOUNCING_PRESENT_ALARM:
-		if (time_after(jiffies, fxo->battdebounce_timer)) {
+		if (time_after(wc->framecount, fxo->battdebounce_timer)) {
 			fxo->battery_state = BATTERY_PRESENT;
 			dahdi_alarm_channel(get_dahdi_chan(wc, mod),
 					    DAHDI_ALARM_NONE);
@@ -2055,18 +2069,23 @@ wctdm_check_battery_present(struct wctdm *wc, struct wctdm_module *const mod)
 		break;
 	case BATTERY_PRESENT:
 		break;
+	case BATTERY_DEBOUNCING_LOST_ALARM:
+		fxo->battery_state = BATTERY_DEBOUNCING_PRESENT_FROM_LOST_ALARM;
+		fxo->battdebounce_timer = wc->framecount + battdebounce;
+		break;
+	case BATTERY_DEBOUNCING_LOST_FROM_PRESENT_ALARM:
+		fxo->battery_state = BATTERY_DEBOUNCING_PRESENT_ALARM;
+		fxo->battdebounce_timer = wc->framecount +
+						battalarm - battdebounce;
+		break;
 	case BATTERY_DEBOUNCING_LOST:
-		/* we were going to BATTERY_LOST, but battery appeared again,
-		 * so clear the debounce timer */
 		fxo->battery_state = BATTERY_PRESENT;
 		break;
 	case BATTERY_UNKNOWN:
 		mod_hooksig(wc, mod, DAHDI_RXSIG_OFFHOOK);
 	case BATTERY_LOST: /* intentional drop through */
-	case BATTERY_DEBOUNCING_LOST_ALARM:
 		fxo->battery_state = BATTERY_DEBOUNCING_PRESENT;
-		fxo->battdebounce_timer = jiffies +
-						msecs_to_jiffies(battdebounce);
+		fxo->battdebounce_timer = wc->framecount + battdebounce;
 		break;
 	}
 }
@@ -4520,10 +4539,11 @@ wctdm_init_span(struct wctdm *wc, int spanno, int chanoffset, int chancount,
 		s->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS | DAHDI_CONFIG_D4;
 		s->span.linecompat |= DAHDI_CONFIG_ESF | DAHDI_CONFIG_HDB3 | DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
 		s->span.linecompat |= DAHDI_CONFIG_NTTE | DAHDI_CONFIG_TERM;
-		s->span.spantype = "TE";
+		s->span.spantype = SPANTYPE_DIGITAL_BRI_TE;
 	} else {
 		s->span.ops = &wctdm24xxp_analog_span_ops;
 		s->span.flags = DAHDI_FLAG_RBS;
+		s->span.spantype = SPANTYPE_ANALOG_MIXED;
 		/* analog sigcap handled in fixup_analog_span() */
 	}

@@ -6060,13 +6080,11 @@ static DEFINE_PCI_DEVICE_TABLE(wctdm_pci_tbl) = {
 	{ 0 }
 };

-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 12)
 static void wctdm_shutdown(struct pci_dev *pdev)
 {
 	struct wctdm *wc = pci_get_drvdata(pdev);
 	voicebus_quiesce(&wc->vb);
 }
-#endif

 MODULE_DEVICE_TABLE(pci, wctdm_pci_tbl);

@@ -6079,9 +6097,7 @@ static struct pci_driver wctdm_driver = {
 	.name = "wctdm24xxp",
 	.probe = wctdm_init_one,
 	.remove = __devexit_p(wctdm_remove_one),
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 12)
 	.shutdown = wctdm_shutdown,
-#endif
 	.suspend = wctdm_suspend,
 	.id_table = wctdm_pci_tbl,
 };
--- a/drivers/dahdi/wctdm24xxp/wctdm24xxp.h
+++ b/drivers/dahdi/wctdm24xxp/wctdm24xxp.h
@@ -106,9 +106,11 @@ struct calregs {
 enum battery_state {
 	BATTERY_UNKNOWN = 0,
 	BATTERY_DEBOUNCING_PRESENT,
+	BATTERY_DEBOUNCING_PRESENT_FROM_LOST_ALARM,
 	BATTERY_DEBOUNCING_PRESENT_ALARM,
 	BATTERY_PRESENT,
 	BATTERY_DEBOUNCING_LOST,
+	BATTERY_DEBOUNCING_LOST_FROM_PRESENT_ALARM,
 	BATTERY_DEBOUNCING_LOST_ALARM,
 	BATTERY_LOST,
 };
--- 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
@@ -1000,12 +1000,12 @@ static int t1xxp_software_init(struct t1 *wc)
 		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;
--- 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
@@ -8,7 +8,7 @@
 *            Matthew Fredrickson <creslin@digium.com>
 *            William Meadows <wmeadows@digium.com>
 *
- * Copyright (C) 2007-2011, Digium, Inc.
+ * Copyright (C) 2007-2012, Digium, Inc.
 *
 * All rights reserved.
 *
@@ -27,6 +27,8 @@
 * this program for more details.
 */

+#define pr_fmt(fmt)             KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/module.h>
@@ -55,18 +57,14 @@
 #error VOICEBUS_SFRAME_SIZE != SFRAME_SIZE
 #endif

-#ifndef pr_fmt
-#define pr_fmt(fmt)             KBUILD_MODNAME ": " fmt
-#endif
-
 static int debug;
-static int j1mode = 0;
+static int j1mode = -1;
 static int alarmdebounce = 2500; /* LOF/LFA def to 2.5s AT&T TR54016*/
 static int losalarmdebounce = 2500; /* LOS def to 2.5s AT&T TR54016*/
 static int aisalarmdebounce = 2500; /* AIS(blue) def to 2.5s AT&T TR54016*/
 static int yelalarmdebounce = 500; /* RAI(yellow) def to 0.5s AT&T devguide */
 static int t1e1override = -1; /* deprecated */
-static char *default_linemode = "auto"; /* 'auto', 'e1', or 't1' */
+static char *default_linemode = "auto"; /* 'auto', 'e1', 't1', or 'j1' */
 static int latency = VOICEBUS_DEFAULT_LATENCY;
 static unsigned int max_latency = VOICEBUS_DEFAULT_MAXLATENCY;
 static int vpmsupport = 1;
@@ -645,21 +643,32 @@ static inline int t1_setreg(struct t1 *wc, int addr, int val)
 	return 0;
 }

-static int t1_getreg(struct t1 *wc, int addr)
+static void __t1_getreg(struct t1 *wc, int addr, struct command *cmd)
 {
-	struct command *cmd =  NULL;
-	unsigned long ret;
-	unsigned long flags;
-
-	might_sleep();
-
-	cmd = get_free_cmd(wc);
-	if (!cmd)
-		return -ENOMEM;
 	cmd->address = addr;
 	cmd->data = 0x00;
 	cmd->flags = __CMD_RD;
 	submit_cmd(wc, cmd);
+}
+
+static int __t1_getresult(struct t1 *wc, struct command *cmd)
+{
+	int ret;
+	unsigned long flags;
+
+	might_sleep();
+
+	if (test_bit(IOERROR, &wc->bit_flags)) {
+		spin_lock_irqsave(&wc->reglock, flags);
+		list_del_init(&cmd->node);
+		spin_unlock_irqrestore(&wc->reglock, flags);
+		if (printk_ratelimit()) {
+			dev_warn(&wc->vb.pdev->dev,
+				 "Timeout in %s\n", __func__);
+		}
+		return -EIO;
+	}
+
 	ret = wait_for_completion_interruptible_timeout(&cmd->complete, HZ*10);
 	if (unlikely(!ret)) {
 		spin_lock_irqsave(&wc->reglock, flags);
@@ -668,13 +677,13 @@ static int t1_getreg(struct t1 *wc, int addr)
 			 * can go ahead and free it right away. */
 			list_del_init(&cmd->node);
 			spin_unlock_irqrestore(&wc->reglock, flags);
-			free_cmd(wc, cmd);
 			if (-ERESTARTSYS != ret) {
 				if (printk_ratelimit()) {
 					dev_warn(&wc->vb.pdev->dev,
 						 "Timeout in %s\n", __func__);
 				}
 				ret = -EIO;
+				set_bit(IOERROR, &wc->bit_flags);
 			}
 			return ret;
 		} else {
@@ -685,15 +694,26 @@ static int t1_getreg(struct t1 *wc, int addr)
 			ret = wait_for_completion_timeout(&cmd->complete, HZ*2);
 			WARN_ON(!ret);
 			ret = cmd->data;
-			free_cmd(wc, cmd);
 			return ret;
 		}
 	}
 	ret = cmd->data;
-	free_cmd(wc, cmd);
 	return ret;
 }

+static int t1_getreg(struct t1 *wc, int addr)
+{
+	int res;
+	struct command *cmd =  NULL;
+	cmd = get_free_cmd(wc);
+	if (!cmd)
+		return -ENOMEM;
+	__t1_getreg(wc, addr, cmd);
+	res = __t1_getresult(wc, cmd);
+	free_cmd(wc, cmd);
+	return res;
+}
+
 static void t1_setleds(struct t1 *wc, int leds)
 {
 	struct command *cmd;
@@ -831,6 +851,75 @@ static void free_wc(struct t1 *wc)
 	kfree(wc);
 }

+/**
+ * t1_reset_registers - Put register back to their default values 
+ *
+ * Since the card does not have an ability to reset just the framer
+ * specifically, we need to write all the default values to the framer.
+ *
+ */
+static void t1_reset_registers(struct t1 *wc)
+{
+	int i;
+	struct t1_reg {
+		u8 address;
+		u8 value;
+	} __attribute__((packed));
+	struct t1_reg *reg;
+	static struct t1_reg DEFAULT_REGS[] = {
+		{0x00, 0x7d}, {0x01, 0x7d}, {0x02, 0x00}, {0x03, 0x00},
+		{0x04, 0xfd}, {0x05, 0xff}, {0x06, 0xff}, {0x07, 0xff},
+		{0x08, 0x05}, {0x09, 0x00}, {0x0a, 0x00}, {0x0b, 0x00},
+		{0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
+		{0x10, 0x00}, {0x11, 0x00}, {0x12, 0x00}, {0x13, 0x00},
+		{0x14, 0xff}, {0x15, 0xff}, {0x16, 0xff}, {0x17, 0xff},
+		{0x18, 0xff}, {0x19, 0xff}, {0x1a, 0x00}, {0x1b, 0x00},
+		{0x1c, 0x00}, {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
+		{0x20, 0x00}, {0x21, 0x00}, {0x22, 0x00}, {0x23, 0x04},
+		{0x24, 0x00}, {0x25, 0x05}, {0x26, 0x7b}, {0x27, 0x03},
+		{0x28, 0x40}, {0x29, 0x00}, {0x2a, 0x00}, {0x2b, 0x00},
+		{0x2c, 0x00}, {0x2d, 0x00}, {0x2e, 0x00}, {0x2f, 0x00},
+		{0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
+		{0x34, 0x00}, {0x35, 0x00}, {0x36, 0x00}, {0x37, 0x80},
+		{0x38, 0x00}, {0x39, 0x00}, {0x3a, 0x20}, {0x3b, 0x00},
+		{0x3c, 0x00}, {0x3d, 0x00}, {0x3e, 0x0a}, {0x3f, 0x00},
+		{0x40, 0x04}, {0x41, 0x00}, {0x42, 0x00}, {0x43, 0x00},
+		{0x44, 0x30}, {0x45, 0x00}, {0x46, 0xc0}, {0x47, 0xff},
+		{0x48, 0x00}, {0x49, 0x1c}, {0x4a, 0x05}, {0x4b, 0x03},
+		{0x4c, 0xa3}, {0x4d, 0x28}, {0x4e, 0x00}, {0x4f, 0xc0},
+		{0x50, 0x00}, {0x51, 0x00}, {0x52, 0x00}, {0x53, 0x00},
+		{0x54, 0x00}, {0x55, 0x00}, {0x56, 0x00}, {0x57, 0x00},
+		{0x58, 0x00}, {0x59, 0x00}, {0x5a, 0x00}, {0x5b, 0x00},
+		{0x5c, 0x00}, {0x5d, 0x00}, {0x5e, 0x00}, {0x5f, 0x00},
+		{0x60, 0x00}, {0x61, 0x20}, {0x62, 0x00}, {0x63, 0x00},
+		{0x64, 0x5a}, {0x65, 0x02}, {0x66, 0x00}, {0x67, 0x00},
+		{0x68, 0x10}, {0x69, 0x09}, {0x6a, 0x00}, {0x6b, 0x03},
+		{0x6c, 0x00}, {0x6d, 0xc0}, {0x6e, 0x40}, {0x6f, 0x00},
+		{0x70, 0x00}, {0x71, 0x00}, {0x72, 0x00}, {0x73, 0x00},
+		{0x74, 0x00}, {0x75, 0x00}, {0x76, 0x00}, {0x77, 0x00},
+		{0x78, 0x00}, {0x79, 0x00}, {0x7a, 0x00}, {0x7b, 0x00},
+		{0x7c, 0x00}, {0x7d, 0x00}, {0x7e, 0x00}, {0x7f, 0x00},
+		{0x80, 0x00}, {0x81, 0x22}, {0x82, 0x65}, {0x83, 0x35},
+		{0x84, 0x31}, {0x85, 0x60}, {0x86, 0x03}, {0x87, 0x00},
+		{0x88, 0x00}, {0x89, 0x00}, {0x8a, 0x00}, {0x8b, 0x00},
+		{0x8c, 0x00}, {0x8d, 0x00}, {0x8e, 0x00}, {0x8f, 0x00},
+		{0x90, 0x00}, {0x91, 0x00}, {0x92, 0x00}, {0x93, 0x18},
+		{0x94, 0xfb}, {0x95, 0x0b}, {0x96, 0x00}, {0x97, 0x0b},
+		{0x98, 0xdb}, {0x99, 0xdf}, {0x9a, 0x48}, {0x9b, 0x00},
+		{0x9c, 0x3f}, {0x9d, 0x3f}, {0x9e, 0x77}, {0x9f, 0x77},
+		{0xa0, 0x00}, {0xa1, 0xff}, {0xa2, 0xff}, {0xa3, 0xff},
+		{0xa4, 0x00}, {0xa5, 0x00}, {0xa6, 0x00}, {0xa7, 0x00},
+		{0xa8, 0x00}
+	};
+
+	for (i = 0; i < ARRAY_SIZE(DEFAULT_REGS); ++i) {
+		reg = &DEFAULT_REGS[i];
+		t1_setreg(wc, reg->address, reg->value);
+	}
+	/* Flush previous writes. */
+	t1_getreg(wc, 0x1d);
+}
+
 static void t4_serial_setup(struct t1 *wc)
 {
 	t1_setreg(wc, 0x85, 0xe0);	/* GPC1: Multiplex mode enabled, FSC is output, active low, RCLK from channel 0 */
@@ -883,7 +972,8 @@ static void t1_configure_t1(struct t1 *wc, int lineconfig, int txlevel)
 	fmr1 = 0x9e; /* FMR1: Mode 0, T1 mode, CRC on for ESF, 2.048 Mhz system data rate, no XAIS */
 	fmr2 = 0x20; /* FMR2: no payload loopback, don't auto yellow alarm */

-	if (j1mode)
+
+	if (SPANTYPE_DIGITAL_J1 == wc->span.spantype)
 		fmr4 = 0x1c;
 	else
 		fmr4 = 0x0c; /* FMR4: Lose sync on 2 out of 5 framing bits, auto resync */
@@ -923,7 +1013,7 @@ static void t1_configure_t1(struct t1 *wc, int lineconfig, int txlevel)
 	t1_setreg(wc, 0x38, 0x0a);	/* PCD: LOS after 176 consecutive "zeros" */
 	t1_setreg(wc, 0x39, 0x15);	/* PCR: 22 "ones" clear LOS */

-	if (j1mode)
+	if (SPANTYPE_DIGITAL_J1 == wc->span.spantype)
 		t1_setreg(wc, 0x24, 0x80); /* J1 overide */
 		
 	/* Generate pulse mask for T1 */
@@ -1184,15 +1274,47 @@ static int t1xxp_rbsbits(struct dahdi_chan *chan, int bits)
 	return 0;
 }

-static inline void t1_check_sigbits(struct t1 *wc)
+static void t1_check_sigbits(struct t1 *wc)
 {
+	struct command_container {
+		struct command *cmd;
+		struct list_head node;
+		unsigned int index;
+	};
+	struct command_container *cont;
+	LIST_HEAD(commands);
 	int a,i,rxs;

 	if (!(test_bit(DAHDI_FLAGBIT_RUNNING, &wc->span.flags)))
 		return;
+
 	if (dahdi_is_e1_span(&wc->span)) {
+		/* Send out all the commands first. */
 		for (i = 0; i < 15; i++) {
-			a = t1_getreg(wc, 0x71 + i);
+			if (!(wc->span.chans[i+16]->sig & DAHDI_SIG_CLEAR) ||
+			    !(wc->span.chans[i]->sig & DAHDI_SIG_CLEAR))  {
+				cont = kzalloc(sizeof(*cont), GFP_KERNEL);
+				if (!cont) {
+					WARN_ON_ONCE(1);
+					goto done;
+				}
+				cont->cmd = get_free_cmd(wc);
+				if (!cont->cmd) {
+					WARN_ON_ONCE(1);
+					goto done;
+				}
+				cont->index = i;
+				list_add_tail(&cont->node, &commands);
+				__t1_getreg(wc, 0x71 + i, cont->cmd);
+			}
+		}
+
+		/* Now check the results */
+		list_for_each_entry_reverse(cont, &commands, node) {
+			i = cont->index;
+			a = __t1_getresult(wc, cont->cmd);
+			free_cmd(wc, cont->cmd);
+			cont->cmd = NULL;
 			if (a > -1) {
 				/* Get high channel in low bits */
 				rxs = (a & 0xf);
@@ -1210,8 +1332,29 @@ static inline void t1_check_sigbits(struct t1 *wc)
 			}
 		}
 	} else if (wc->span.lineconfig & DAHDI_CONFIG_D4) {
-		for (i = 0; i < 24; i+=4) {
-			a = t1_getreg(wc, 0x70 + (i>>2));
+		/* First we'll send out the commands */
+		for (i = 0; i < 24; i += 4) {
+			cont = kzalloc(sizeof(*cont), GFP_KERNEL);
+			if (!cont) {
+				WARN_ON_ONCE(1);
+				goto done;
+			}
+			cont->cmd = get_free_cmd(wc);
+			if (!cont->cmd) {
+				WARN_ON_ONCE(1);
+				goto done;
+			}
+			cont->index = i;
+			list_add_tail(&cont->node, &commands);
+			__t1_getreg(wc, 0x70 + (i>>2), cont->cmd);
+		}
+
+		/* Now we'll check the results */
+		list_for_each_entry_reverse(cont, &commands, node) {
+			i = cont->index;
+			a = __t1_getresult(wc, cont->cmd);
+			free_cmd(wc, cont->cmd);
+			cont->cmd = NULL;
 			if (a > -1) {
 				/* Get high channel in low bits */
 				rxs = (a & 0x3) << 2;
@@ -1241,8 +1384,28 @@ static inline void t1_check_sigbits(struct t1 *wc)
 			}
 		}
 	} else {
-		for (i = 0; i < 24; i+=2) {
-			a = t1_getreg(wc, 0x70 + (i>>1));
+		/* First send out the commands. */
+		for (i = 0; i < 24; i += 2) {
+			cont = kzalloc(sizeof(*cont), GFP_KERNEL);
+			if (!cont) {
+				WARN_ON_ONCE(1);
+				goto done;
+			}
+			cont->cmd = get_free_cmd(wc);
+			if (!cont->cmd) {
+				WARN_ON_ONCE(1);
+				goto done;
+			}
+			cont->index = i;
+			list_add_tail(&cont->node, &commands);
+			__t1_getreg(wc, 0x70 + (i>>1), cont->cmd);
+		}
+
+		list_for_each_entry_reverse(cont, &commands, node) {
+			i = cont->index;
+			a = __t1_getresult(wc, cont->cmd);
+			free_cmd(wc, cont->cmd);
+			cont->cmd = NULL;
 			if (a > -1) {
 				/* Get high channel in low bits */
 				rxs = (a & 0xf);
@@ -1260,6 +1423,21 @@ static inline void t1_check_sigbits(struct t1 *wc)
 			}
 		}
 	}
+done:
+	while (!list_empty(&commands)) {
+		cont = container_of(commands.next,
+				    struct command_container, node);
+		if (unlikely(cont->cmd)) {
+			/* We do not care about the result, let's just wait for
+			 * the rest of the system to finish with it. */
+			__t1_getresult(wc, cont->cmd);
+			free_cmd(wc, cont->cmd);
+			cont->cmd = NULL;
+		}
+		list_del(&cont->node);
+		kfree(cont);
+	}
+	return;
 }

 struct maint_work_struct {
@@ -1846,18 +2024,32 @@ static int t1_software_init(struct t1 *wc, enum linemode type)
 	memset(chans, 0, sizeof(chans));
 	memset(ec, 0, sizeof(ec));

-	if (type == E1) {
+	switch (type) {
+	case E1:
 		wc->span.channels = 31;
-		wc->span.spantype = "E1";
+		wc->span.spantype = SPANTYPE_DIGITAL_E1;
 		wc->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_HDB3 |
 			DAHDI_CONFIG_CCS | DAHDI_CONFIG_CRC4;
 		wc->span.deflaw = DAHDI_LAW_ALAW;
-	} else {
+		break;
+	case T1:
 		wc->span.channels = 24;
-		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.deflaw = DAHDI_LAW_MULAW;
+		break;
+	case J1:
+		wc->span.channels = 24;
+		wc->span.spantype = SPANTYPE_DIGITAL_J1;
+		wc->span.linecompat = DAHDI_CONFIG_AMI | DAHDI_CONFIG_B8ZS |
+			DAHDI_CONFIG_D4 | DAHDI_CONFIG_ESF;
+		wc->span.deflaw = DAHDI_LAW_MULAW;
+		break;
+	default:
+		spin_unlock_irqrestore(&wc->reglock, flags);
+		res = -EINVAL;
+		goto error_exit;
 	}

 	spin_unlock_irqrestore(&wc->reglock, flags);
@@ -1866,7 +2058,7 @@ static int t1_software_init(struct t1 *wc, enum linemode type)
 		return -ENOMEM;

 	t1_info(wc, "Setting up global serial parameters for %s\n",
-		(dahdi_is_e1_span(&wc->span) ? "E1" : "T1"));
+		dahdi_spantype2str(wc->span.spantype));

 	t4_serial_setup(wc);
 	set_bit(DAHDI_FLAGBIT_RBS, &wc->span.flags);
@@ -1900,13 +2092,13 @@ error_exit:
 * DAHDI).
 *
 */
-static int t1xxp_set_linemode(struct dahdi_span *span, const char *linemode)
+static int t1xxp_set_linemode(struct dahdi_span *span, enum spantypes linemode)
 {
 	int res;
 	struct t1 *wc = container_of(span, struct t1, span);

 	/* We may already be set to the requested type. */
-	if (!strcasecmp(span->spantype, linemode))
+	if (span->spantype == linemode)
 		return 0;

 	res = t1_wait_for_ready(wc);
@@ -1916,21 +2108,35 @@ static int t1xxp_set_linemode(struct dahdi_span *span, const char *linemode)
 	/* Stop the processing of the channels since we're going to change
 	 * them. */
 	clear_bit(INITIALIZED, &wc->bit_flags);
+	synchronize_irq(wc->vb.pdev->irq);
 	smp_mb__after_clear_bit();
 	del_timer_sync(&wc->timer);
 	flush_workqueue(wc->wq);

-	if (!strcasecmp(linemode, "t1")) {
+	t1_reset_registers(wc);
+
+	switch (linemode) {
+	case SPANTYPE_DIGITAL_T1:
 		dev_info(&wc->vb.pdev->dev,
-			 "Changing from E1 to T1 line mode.\n");
+			 "Changing from %s to T1 line mode.\n",
+			 dahdi_spantype2str(wc->span.spantype));
 		res = t1_software_init(wc, T1);
-	} else if (!strcasecmp(linemode, "e1")) {
+		break;
+	case SPANTYPE_DIGITAL_E1:
 		dev_info(&wc->vb.pdev->dev,
-			 "Changing from T1 to E1 line mode.\n");
+			 "Changing from %s to E1 line mode.\n",
+			 dahdi_spantype2str(wc->span.spantype));
 		res = t1_software_init(wc, E1);
-	} else {
+		break;
+	case SPANTYPE_DIGITAL_J1:
+		dev_info(&wc->vb.pdev->dev,
+			 "Changing from %s to E1 line mode.\n",
+			 dahdi_spantype2str(wc->span.spantype));
+		res = t1_software_init(wc, J1);
+	default:
 		dev_err(&wc->vb.pdev->dev,
-			"'%s' is an unknown linemode.\n", linemode);
+			"Got invalid linemode '%s' from dahdi\n",
+			dahdi_spantype2str(linemode));
 		res = -EINVAL;
 	}

@@ -1967,14 +2173,15 @@ static int t1_hardware_post_init(struct t1 *wc, enum linemode *type)
 	int x;

 	/* T1 or E1 */
-	if (-1 != t1e1override) {
-		pr_info("t1e1override is deprecated. Please use 'default_linemode'.\n");
-		*type = (t1e1override) ? E1 : T1;
+	if ((-1 != t1e1override) || (-1 != j1mode)) {
+		*type = (t1e1override) ? E1 : (j1mode) ? J1 : T1;
 	} else {
 		if (!strcasecmp(default_linemode, "e1")) {
 			*type = E1;
 		} else if (!strcasecmp(default_linemode, "t1")) {
 			*type = T1;
+		} else if (!strcasecmp(default_linemode, "j1")) {
+			*type = J1;
 		} else {
 			u8 pins;
 			res = t1_getpins(wc, &pins);
@@ -1983,7 +2190,8 @@ static int t1_hardware_post_init(struct t1 *wc, enum linemode *type)
 			*type = (pins & 0x01) ? T1 : E1;
 		}
 	}
-	debug_printk(wc, 1, "linemode: %s\n", (*type == T1) ? "T1" : "E1");
+	debug_printk(wc, 1, "linemode: %s\n", (*type == T1) ? "T1" :
+					(J1 == *type) ? "J1" : "E1");
 	
 	/* what version of the FALC are we using? */
 	reg = t1_setreg(wc, 0x4a, 0xaa);
@@ -2014,19 +2222,41 @@ static int t1_hardware_post_init(struct t1 *wc, enum linemode *type)
 	return 0;
 }

-static inline void t1_check_alarms(struct t1 *wc)
+static void t1_check_alarms(struct t1 *wc)
 {
 	unsigned char c,d;
 	int alarms;
 	int x,j;
 	unsigned char fmr4; /* must read this always */
+	struct command *cmds[3];

 	if (!(test_bit(DAHDI_FLAGBIT_RUNNING, &wc->span.flags)))
 		return;

-	c = t1_getreg(wc, 0x4c);
-	fmr4 = t1_getreg(wc, 0x20); /* must read this even if we don't use it */
-	d = t1_getreg(wc, 0x4d);
+	for (x = 0; x < ARRAY_SIZE(cmds); ++x) {
+		cmds[x] = get_free_cmd(wc);
+		if (!cmds[x]) {
+			WARN_ON(1);
+			for (x = 0; x < ARRAY_SIZE(cmds); ++x)
+				free_cmd(wc, cmds[x]);
+			return;
+		}
+	}
+
+	/* Since this is voicebus, if we issue all the reads initially and then
+	 * check the results we can save ourselves some time. Otherwise, each
+	 * read will take a minimum of 3ms to go through the complete pipeline.
+	 */
+	__t1_getreg(wc, 0x4c, cmds[0]);
+	__t1_getreg(wc, 0x20, cmds[1]); /* must read this even if not used */
+	__t1_getreg(wc, 0x4d, cmds[2]);
+
+	d = __t1_getresult(wc, cmds[2]);
+	fmr4 = __t1_getresult(wc, cmds[1]);
+	c = __t1_getresult(wc, cmds[0]);
+
+	for (x=0; x < ARRAY_SIZE(cmds); ++x)
+		free_cmd(wc, cmds[x]);

 	/* Assume no alarms */
 	alarms = 0;
@@ -2058,27 +2288,32 @@ static inline void t1_check_alarms(struct t1 *wc)
 		/* Detect loopup code if we're not sending one */
 		if ((!wc->span.mainttimer) && (d & 0x08)) {
 			/* Loop-up code detected */
-			if ((wc->span.maintstat != DAHDI_MAINT_REMOTELOOP)) {
+			if ((++wc->loopupcnt > 80) &&
+			    (wc->span.maintstat != DAHDI_MAINT_REMOTELOOP)) {
 				t1_notice(wc, "Loopup detected,"\
 					" enabling remote loop\n");
 				t1_setreg(wc, 0x36, 0x08);	/* LIM0: Disable any local loop */
 				t1_setreg(wc, 0x37, 0xf6);	/* LIM1: Enable remote loop */
 				wc->span.maintstat = DAHDI_MAINT_REMOTELOOP;
 			}
-		} else
+		} else {
 			wc->loopupcnt = 0;
+		}
+
 		/* Same for loopdown code */
 		if ((!wc->span.mainttimer) && (d & 0x10)) {
 			/* Loop-down code detected */
-			if ((wc->span.maintstat == DAHDI_MAINT_REMOTELOOP)) {
+			if ((++wc->loopdowncnt > 80) &&
+			    (wc->span.maintstat == DAHDI_MAINT_REMOTELOOP)) {
 				t1_notice(wc, "Loopdown detected,"\
 					" disabling remote loop\n");
 				t1_setreg(wc, 0x36, 0x08);	/* LIM0: Disable any local loop */
 				t1_setreg(wc, 0x37, 0xf0);	/* LIM1: Disable remote loop */
 				wc->span.maintstat = DAHDI_MAINT_NONE;
 			}
-		} else
+		} else {
 			wc->loopdowncnt = 0;
+		}
 	}

 	if (wc->span.lineconfig & DAHDI_CONFIG_NOTOPEN) {
@@ -2442,11 +2677,11 @@ static void timer_work_func(struct work_struct *work)
 {
 	struct t1 *wc = container_of(work, struct t1, timer_work);
 #endif
+	if (test_bit(INITIALIZED, &wc->bit_flags))
+		mod_timer(&wc->timer, jiffies + HZ/30);
 	t1_do_counters(wc);
 	t1_check_alarms(wc);
 	t1_check_sigbits(wc);
-	if (test_bit(INITIALIZED, &wc->bit_flags))
-		mod_timer(&wc->timer, jiffies + HZ/10);
 }

 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
@@ -2702,13 +2937,7 @@ static int __devinit te12xp_init_one(struct pci_dev *pdev, const struct pci_devi
 	spin_lock_init(&wc->reglock);
 	INIT_LIST_HEAD(&wc->active_cmds);
 	INIT_LIST_HEAD(&wc->pending_cmds);
-#	if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
-	wc->timer.function = te12xp_timer;
-	wc->timer.data = (unsigned long)wc;
-	init_timer(&wc->timer);
-#	else
 	setup_timer(&wc->timer, te12xp_timer, (unsigned long)wc);
-#	endif

 #	if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
 	INIT_WORK(&wc->timer_work, timer_work_func, wc);
@@ -2888,13 +3117,11 @@ static DEFINE_PCI_DEVICE_TABLE(te12xp_pci_tbl) = {
 	{ 0 }
 };

-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 12)
 static void te12xp_shutdown(struct pci_dev *pdev)
 {
 	struct t1 *wc = pci_get_drvdata(pdev);
 	voicebus_quiesce(&wc->vb);
 }
-#endif

 static int te12xp_suspend(struct pci_dev *pdev, pm_message_t state)
 {
@@ -2907,9 +3134,7 @@ static struct pci_driver te12xp_driver = {
 	.name = "wcte12xp",
 	.probe = te12xp_init_one,
 	.remove = __devexit_p(te12xp_remove_one),
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 12)
 	.shutdown = te12xp_shutdown,
-#endif
 	.suspend = te12xp_suspend,
 	.id_table = te12xp_pci_tbl,
 };
@@ -2932,14 +3157,20 @@ static int __init te12xp_init(void)
 	if (!cmd_cache)
 		return -ENOMEM;

-	if (-1 != t1e1override) {
-		pr_info("'t1e1override' is deprecated. "
-			"Please use 'default_linemode' instead\n");
+	if ((-1 != t1e1override) || (-1 != j1mode)) {
+		pr_info("'t1e1override' and 'j1mode' are deprecated. "
+			"Please use 'default_linemode' instead.\n");
+		/* If someone is setting j1mode, then, t1e1override most likely
+		 * needs to be forced to t1 mode */
+		if (j1mode > 0)
+			t1e1override = 0;
 	} else if (strcasecmp(default_linemode, "auto") &&
 		   strcasecmp(default_linemode, "t1") &&
+		   strcasecmp(default_linemode, "j1") &&
 		   strcasecmp(default_linemode, "e1")) {
-		pr_err("'%s' is an unknown span type.", default_linemode);
+		pr_err("'%s' is an unknown span type.\n", default_linemode);
 		default_linemode = "auto";
+		kmem_cache_destroy(cmd_cache);
 		return -EINVAL;
 	}
 	res = dahdi_pci_module(&te12xp_driver);
--- a/drivers/dahdi/wcte12xp/wcte12xp.h
+++ b/drivers/dahdi/wcte12xp/wcte12xp.h
@@ -77,6 +77,7 @@
 enum linemode {
 	T1 = 1,
 	E1,
+	J1,
 };

 struct command {
@@ -113,6 +114,7 @@ struct t1 {
 #define INITIALIZED 1
 #define SHUTDOWN    2
 #define READY	    3
+#define IOERROR	    4
 	unsigned long bit_flags;
 	unsigned long alarmtimer;
 	unsigned char ledstate;
--- 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,17 +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, 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,17 +25,15 @@
 #include "xpd.h"

 enum fxs_opcodes {
-	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 */
+	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
@@ -22,6 +22,7 @@

 #include <linux/module.h>
 #include <linux/delay.h>
+#include <linux/kmod.h>
 #include "xdefs.h"
 #include "xpd.h"
 #include "xpp_dahdi.h"
@@ -32,21 +33,22 @@

 static const char rcsid[] = "$Id$";

-DEF_PARM(charp,initdir, "/usr/share/dahdi", 0644, "The directory of card initialization scripts");
+DEF_PARM(charp, initdir, "/usr/share/dahdi", 0644,
+	 "The directory of card initialization scripts");

 #define	CHIP_REGISTERS	"chipregs"

-extern	int debug;
+extern int debug;

 /*---------------- GLOBAL PROC handling -----------------------------------*/

-static int send_magic_request(xbus_t *xbus,
-	unsigned unit, xportno_t portno, bool eoftx)
+static int send_magic_request(xbus_t *xbus, unsigned unit, xportno_t portno,
+			      bool eoftx)
 {
-	xframe_t	*xframe;
-	xpacket_t	*pack;
-	reg_cmd_t	*reg_cmd;
-	int		ret;
+	xframe_t *xframe;
+	xpacket_t *pack;
+	reg_cmd_t *reg_cmd;
+	int ret;

 	/*
 	 * Zero length multibyte is legal and has special meaning for the
@@ -65,203 +67,210 @@ static int send_magic_request(xbus_t *xbus,
 		dump_xframe(__func__, xbus, xframe, debug);
 	ret = send_cmd_frame(xbus, xframe);
 	if (ret < 0)
-		PORT_ERR(xbus, unit, portno,
-			"%s: failed sending xframe\n", __func__);
+		PORT_ERR(xbus, unit, portno, "%s: failed sending xframe\n",
+			 __func__);
 	return ret;
 }

 static int parse_hexbyte(const char *buf)
 {
-	char		*endp;
-	unsigned	val;
+	char *endp;
+	unsigned val;

 	val = simple_strtoul(buf, &endp, 16);
-	if(*endp != '\0' || val > 0xFF)
+	if (*endp != '\0' || val > 0xFF)
 		return -EBADR;
-	return (byte)val;
+	return (__u8)val;
 }

 static int execute_chip_command(xpd_t *xpd, const int argc, char *argv[])
 {
-	int			argno;
-	char			num_args;
-	int			portno;
-	bool			writing;
-	int			op;		/* [W]rite, [R]ead */
-	int			addr_mode;	/* [D]irect, [I]ndirect, [Mm]ulti */
-	bool			do_subreg = 0;
-	int			regnum;
-	int			subreg;
-	int			data_low;
-	bool			do_datah;
-	int			data_high;
-	int			ret = -EBADR;
+	int argno;
+	char num_args;
+	int portno;
+	bool writing;
+	int op;			/* [W]rite, [R]ead */
+	int addr_mode;		/* [D]irect, [I]ndirect, [Mm]ulti */
+	bool do_subreg = 0;
+	int regnum;
+	int subreg;
+	int data_low;
+	bool do_datah;
+	int data_high;
+	int ret = -EBADR;

-	num_args = 2;	/* port + operation */
-	if(argc < num_args) {
+	num_args = 2;		/* port + operation */
+	if (argc < num_args) {
 		XPD_ERR(xpd, "Not enough arguments (%d)\n", argc);
 		XPD_ERR(xpd,
-				"Any Command is composed of at least %d words (got only %d)\n",
-				num_args, argc);
+			"Any Command is composed of at least %d words "
+			"(got only %d)\n",
+			num_args, argc);
 		goto out;
 	}
 	/* Process the arguments */
 	argno = 0;
-	if(strcmp(argv[argno], "*") == 0) {
+	if (strcmp(argv[argno], "*") == 0) {
 		portno = PORT_BROADCAST;
 		//XPD_DBG(REGS, xpd, "Port broadcast\n");
 	} else {
 		portno = parse_hexbyte(argv[argno]);
-		if(portno < 0 || portno >= 8) {
+		if (portno < 0 || portno >= 8) {
 			XPD_ERR(xpd, "Illegal port number '%s'\n", argv[argno]);
 			goto out;
 		}
 		//XPD_DBG(REGS, xpd, "Port is %d\n", portno);
 	}
 	argno++;
-	if(strlen(argv[argno]) != 2) {
+	if (strlen(argv[argno]) != 2) {
 		XPD_ERR(xpd, "Wrong operation codes '%s'\n", argv[argno]);
 		goto out;
 	}
 	op = argv[argno][0];
-	switch(op) {
-		case 'W':
-			writing = 1;
-			num_args++;	/* data low */
-			//XPD_DBG(REGS, xpd, "WRITING\n");
-			break;
-		case 'R':
-			writing = 0;
-			//XPD_DBG(REGS, xpd, "READING\n");
-			break;
-		default:
-			XPD_ERR(xpd, "Unknown operation type '%c'\n", op);
-			goto out;
+	switch (op) {
+	case 'W':
+		writing = 1;
+		num_args++;	/* data low */
+		//XPD_DBG(REGS, xpd, "WRITING\n");
+		break;
+	case 'R':
+		writing = 0;
+		//XPD_DBG(REGS, xpd, "READING\n");
+		break;
+	default:
+		XPD_ERR(xpd, "Unknown operation type '%c'\n", op);
+		goto out;
 	}
 	addr_mode = argv[argno][1];
-	switch(addr_mode) {
-		case 'I':
-			XPD_NOTICE(xpd, "'I' is deprecated in register commands. Use 'S' instead.\n");
-			/* fall through */
-		case 'S':
-			do_subreg = 1;
-			num_args += 2;	/* register + subreg */
-			//XPD_DBG(REGS, xpd, "SUBREG\n");
-			break;
-		case 'D':
-			do_subreg = 0;
-			num_args++;	/* register */
-			//XPD_DBG(REGS, xpd, "DIRECT\n");
-			break;
-		case 'M':
-		case 'm':
-			if(op != 'W') {
-				XPD_ERR(xpd,
-						"Can use Multibyte (%c) only with op 'W'\n", addr_mode);
-				goto out;
-			}
-			num_args--;	/* No data low */
-			//XPD_DBG(REGS, xpd, "Multibyte (%c)\n", addr_mode);
-			break;
-		default:
-			XPD_ERR(xpd, "Unknown addressing type '%c'\n", addr_mode);
+	switch (addr_mode) {
+	case 'I':
+		XPD_NOTICE(xpd,
+			"'I' is deprecated in register commands. "
+			"Use 'S' instead.\n");
+		/* fall through */
+	case 'S':
+		do_subreg = 1;
+		num_args += 2;	/* register + subreg */
+		//XPD_DBG(REGS, xpd, "SUBREG\n");
+		break;
+	case 'D':
+		do_subreg = 0;
+		num_args++;	/* register */
+		//XPD_DBG(REGS, xpd, "DIRECT\n");
+		break;
+	case 'M':
+	case 'm':
+		if (op != 'W') {
+			XPD_ERR(xpd,
+				"Can use Multibyte (%c) only with op 'W'\n",
+				addr_mode);
 			goto out;
+		}
+		num_args--;	/* No data low */
+		//XPD_DBG(REGS, xpd, "Multibyte (%c)\n", addr_mode);
+		break;
+	default:
+		XPD_ERR(xpd, "Unknown addressing type '%c'\n", addr_mode);
+		goto out;
 	}
-	if(argv[argno][2] != '\0') {
+	if (argv[argno][2] != '\0') {
 		XPD_ERR(xpd, "Bad operation field '%s'\n", argv[argno]);
 		goto out;
 	}
-	if(argc < num_args) {
+	if (argc < num_args) {
 		XPD_ERR(xpd,
-				"Command \"%s\" is composed of at least %d words (got only %d)\n",
-				argv[argno], num_args, argc);
+			"Command \"%s\" is composed of at least %d words "
+			"(got only %d)\n",
+			argv[argno], num_args, argc);
 		goto out;
 	}
 	argno++;
-	if(addr_mode == 'M' || addr_mode == 'm') {
-		if(argno < argc) {
+	if (addr_mode == 'M' || addr_mode == 'm') {
+		if (argno < argc) {
 			XPD_ERR(xpd,
-					"Magic-Multibyte(%c) with %d extra arguments\n",
-					addr_mode, argc - argno);
+				"Magic-Multibyte(%c) with %d extra arguments\n",
+				addr_mode, argc - argno);
 			goto out;
 		}
-		ret = send_magic_request(xpd->xbus, xpd->addr.unit, portno,
-			addr_mode == 'm');
+		ret =
+		    send_magic_request(xpd->xbus, xpd->addr.unit, portno,
+				       addr_mode == 'm');
 		goto out;
 	}
 	/* Normal (non-Magic) register commands */
 	do_datah = 0;
-	if(argno >= argc) {
+	if (argno >= argc) {
 		XPD_ERR(xpd, "Missing register number\n");
 		goto out;
 	}
 	regnum = parse_hexbyte(argv[argno]);
-	if(regnum < 0) {
+	if (regnum < 0) {
 		XPD_ERR(xpd, "Illegal register number '%s'\n", argv[argno]);
 		goto out;
 	}
 	//XPD_DBG(REGS, xpd, "Register is %X\n", regnum);
 	argno++;
-	if(do_subreg) {
-		if(argno >= argc) {
+	if (do_subreg) {
+		if (argno >= argc) {
 			XPD_ERR(xpd, "Missing subregister number\n");
 			goto out;
 		}
 		subreg = parse_hexbyte(argv[argno]);
-		if(subreg < 0) {
-			XPD_ERR(xpd, "Illegal subregister number '%s'\n", argv[argno]);
+		if (subreg < 0) {
+			XPD_ERR(xpd, "Illegal subregister number '%s'\n",
+				argv[argno]);
 			goto out;
 		}
 		//XPD_DBG(REGS, xpd, "Subreg is %X\n", subreg);
 		argno++;
 	} else
 		subreg = 0;
-	if(writing) {
-		if(argno >= argc) {
+	if (writing) {
+		if (argno >= argc) {
 			XPD_ERR(xpd, "Missing data low number\n");
 			goto out;
 		}
 		data_low = parse_hexbyte(argv[argno]);
-		if(data_low < 0) {
-			XPD_ERR(xpd, "Illegal data_low number '%s'\n", argv[argno]);
+		if (data_low < 0) {
+			XPD_ERR(xpd, "Illegal data_low number '%s'\n",
+				argv[argno]);
 			goto out;
 		}
 		//XPD_DBG(REGS, xpd, "Data Low is %X\n", data_low);
 		argno++;
 	} else
 		data_low = 0;
-	if(argno < argc) {
+	if (argno < argc) {
 		do_datah = 1;
-		if(!argv[argno]) {
+		if (!argv[argno]) {
 			XPD_ERR(xpd, "Missing data high number\n");
 			goto out;
 		}
 		data_high = parse_hexbyte(argv[argno]);
-		if(data_high < 0) {
-			XPD_ERR(xpd, "Illegal data_high number '%s'\n", argv[argno]);
+		if (data_high < 0) {
+			XPD_ERR(xpd, "Illegal data_high number '%s'\n",
+				argv[argno]);
 			goto out;
 		}
 		//XPD_DBG(REGS, xpd, "Data High is %X\n", data_high);
 		argno++;
 	} else
 		data_high = 0;
-	if(argno < argc) {
-		XPD_ERR(xpd,
-				"Command contains an extra %d argument\n",
-				argc - argno);
+	if (argno < argc) {
+		XPD_ERR(xpd, "Command contains an extra %d argument\n",
+			argc - argno);
 		goto out;
 	}
 #if 0
 	XPD_DBG(REGS, xpd,
-			"portno=%d writing=%d regnum=%d do_subreg=%d subreg=%d dataL=%d do_datah=%d dataH=%d\n",
-			portno,		/* portno	*/
-			writing,	/* writing	*/
-			regnum,
-			do_subreg,	/* use subreg	*/
-			subreg, 	/* subreg	*/
-			data_low,
-			do_datah,	/* use data_high*/
-			data_high);
+		"portno=%d writing=%d regnum=%d do_subreg=%d subreg=%d "
+		"dataL=%d do_datah=%d dataH=%d\n",
+		portno,			/* portno       */
+		writing,		/* writing      */
+		regnum, do_subreg,	/* use subreg   */
+		subreg,			/* subreg       */
+		data_low, do_datah,	/* use data_high */
+		data_high);
 #endif
 	ret = xpp_register_request(xpd->xbus, xpd, portno,
 		writing, regnum, do_subreg, subreg,
@@ -270,36 +279,38 @@ out:
 	return ret;
 }

+#define	MAX_ARGS	10
+
 int parse_chip_command(xpd_t *xpd, char *cmdline)
 {
-	xbus_t			*xbus;
-	int			ret = -EBADR;
-	byte			buf[MAX_PROC_WRITE];
-	char			*str;
-	char			*p;
-	static const int	MAX_ARGS = 10;
-	char			*argv[MAX_ARGS + 1];
-	int			argc;
-	int			i;
+	xbus_t *xbus;
+	int ret = -EBADR;
+	__u8 buf[MAX_PROC_WRITE];
+	char *str;
+	char *p;
+	char *argv[MAX_ARGS + 1];
+	int argc;
+	int i;

 	BUG_ON(!xpd);
 	xbus = xpd->xbus;
-	if(!XBUS_FLAGS(xbus, CONNECTED)) {
+	if (!XBUS_FLAGS(xbus, CONNECTED)) {
 		XBUS_DBG(GENERAL, xbus, "Dropped packet. Disconnected.\n");
 		return -EBUSY;
 	}
 	strlcpy(buf, cmdline, MAX_PROC_WRITE);	/* Save a copy */
-	if(buf[0] == '#' || buf[0] == ';')
+	if (buf[0] == '#' || buf[0] == ';')
 		XPD_DBG(REGS, xpd, "Note: '%s'\n", buf);
-	if((p = strchr(buf, '#')) != NULL)	/* Truncate comments */
+	if ((p = strchr(buf, '#')) != NULL)	/* Truncate comments */
 		*p = '\0';
-	if((p = strchr(buf, ';')) != NULL)	/* Truncate comments */
+	if ((p = strchr(buf, ';')) != NULL)	/* Truncate comments */
 		*p = '\0';
-	for(p = buf; *p && (*p == ' ' || *p == '\t'); p++) /* Trim leading whitespace */
+	/* Trim leading whitespace */
+	for (p = buf; *p && (*p == ' ' || *p == '\t'); p++)
 		;
 	str = p;
-	for(i = 0; (p = strsep(&str, " \t")) != NULL && i < MAX_ARGS; ) {
-		if(*p != '\0') {
+	for (i = 0; (p = strsep(&str, " \t")) != NULL && i < MAX_ARGS;) {
+		if (*p != '\0') {
 			argv[i] = p;
 			// XPD_DBG(REGS, xpd, "ARG %d = '%s'\n", i, p);
 			i++;
@@ -307,11 +318,12 @@ int parse_chip_command(xpd_t *xpd, char *cmdline)
 	}
 	argv[i] = NULL;
 	argc = i;
-	if(p) {
-		XPD_ERR(xpd, "Too many words (%d) to process. Last was '%s'\n", i, p);
+	if (p) {
+		XPD_ERR(xpd, "Too many words (%d) to process. Last was '%s'\n",
+			i, p);
 		goto out;
 	}
-	if(argc)
+	if (argc)
 		ret = execute_chip_command(xpd, argc, argv);
 	else
 		ret = 0;	/* empty command - no op */
@@ -328,11 +340,11 @@ static void global_packet_dump(const char *msg, xpacket_t *pack);

 /* 0x07 */ HOSTCMD(GLOBAL, AB_REQUEST)
 {
-	int		ret = -ENODEV;
-	xframe_t	*xframe;
-	xpacket_t	*pack;
+	int ret = -ENODEV;
+	xframe_t *xframe;
+	xpacket_t *pack;

-	if(!xbus) {
+	if (!xbus) {
 		DBG(DEVICES, "NO XBUS\n");
 		return -EINVAL;
 	}
@@ -342,33 +354,35 @@ static void global_packet_dump(const char *msg, xpacket_t *pack);
 	RPACKET_FIELD(pack, GLOBAL, AB_REQUEST, rev) = XPP_PROTOCOL_VERSION;
 	RPACKET_FIELD(pack, GLOBAL, AB_REQUEST, reserved) = 0;
 	XBUS_DBG(DEVICES, xbus, "Protocol Version %d\n", XPP_PROTOCOL_VERSION);
-	if(xbus_setstate(xbus, XBUS_STATE_SENT_REQUEST))
+	if (xbus_setstate(xbus, XBUS_STATE_SENT_REQUEST))
 		ret = send_cmd_frame(xbus, xframe);
 	return ret;
 }

 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		ret = 0;
-	xframe_t	*xframe;
-	xpacket_t	*pack;
-	reg_cmd_t	*reg_cmd;
+	int ret = 0;
+	xframe_t *xframe;
+	xpacket_t *pack;
+	reg_cmd_t *reg_cmd;

-	if(!xbus) {
+	if (!xbus) {
 		DBG(REGS, "NO XBUS\n");
 		return -EINVAL;
 	}
-	XFRAME_NEW_CMD(xframe, pack, xbus, GLOBAL, REGISTER_REQUEST, xpd->xbus_idx);
+	XFRAME_NEW_CMD(xframe, pack, xbus, GLOBAL, REGISTER_REQUEST,
+		       xpd->xbus_idx);
 	LINE_DBG(REGS, xpd, portno, "%c%c %02X %02X %02X %02X\n",
-			(writing)?'W':'R',
-			(do_subreg)?'S':'D',
-			regnum, subreg, data_low, data_high);
+		 (writing) ? 'W' : 'R', (do_subreg) ? 'S' : 'D', regnum, subreg,
+		 data_low, data_high);
 	reg_cmd = &RPACKET_FIELD(pack, GLOBAL, REGISTER_REQUEST, reg_cmd);
-	reg_cmd->bytes = sizeof(*reg_cmd) - 1;	// do not count the 'bytes' field
+	/* do not count the 'bytes' field */
+	reg_cmd->bytes = sizeof(*reg_cmd) - 1;
 	reg_cmd->is_multibyte = 0;
-	if(portno == PORT_BROADCAST) {
+	if (portno == PORT_BROADCAST) {
 		reg_cmd->portnum = 0;
 		REG_FIELD(reg_cmd, all_ports_broadcast) = 1;
 	} else {
@@ -384,14 +398,15 @@ int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno,
 	REG_FIELD(reg_cmd, do_datah) = do_datah;
 	REG_FIELD(reg_cmd, data_low) = data_low;
 	REG_FIELD(reg_cmd, data_high) = data_high;
-	if(should_reply)
+	if (should_reply)
 		xpd->requested_reply = *reg_cmd;
-	if(debug & DBG_REGS) {
-		dump_reg_cmd("REG_REQ", 1, xbus, xpd->addr.unit, reg_cmd->portnum, reg_cmd);
+	if (debug & DBG_REGS) {
+		dump_reg_cmd("REG_REQ", 1, xbus, xpd->addr.unit,
+			     reg_cmd->portnum, reg_cmd);
 		dump_packet("REG_REQ", pack, 1);
 	}
-	if(!xframe->usec_towait) {	/* default processing time of SPI */
-		if(subreg)
+	if (!xframe->usec_towait) {	/* default processing time of SPI */
+		if (subreg)
 			xframe->usec_towait = 2000;
 		else
 			xframe->usec_towait = 1000;
@@ -399,18 +414,19 @@ int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno,
 	ret = send_cmd_frame(xbus, xframe);
 	return ret;
 }
+EXPORT_SYMBOL(xpp_register_request);

 /*
 * The XPD parameter is totaly ignored by the driver and firmware as well.
 */
 /* 0x19 */ HOSTCMD(GLOBAL, SYNC_SOURCE, enum sync_mode mode, int drift)
 {
-	xframe_t	*xframe;
-	xpacket_t	*pack;
-	const char	*mode_name;
+	xframe_t *xframe;
+	xpacket_t *pack;
+	const char *mode_name;

 	BUG_ON(!xbus);
-	if((mode_name = sync_mode_name(mode)) == NULL) {
+	if ((mode_name = sync_mode_name(mode)) == NULL) {
 		XBUS_ERR(xbus, "SYNC_SOURCE: bad sync_mode=0x%X\n", mode);
 		return -EINVAL;
 	}
@@ -427,8 +443,8 @@ int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno,
 */
 static int send_xbus_reset(xbus_t *xbus, uint8_t reset_mask)
 {
-	xframe_t	*xframe;
-	xpacket_t	*pack;
+	xframe_t *xframe;
+	xpacket_t *pack;

 	BUG_ON(!xbus);
 	XFRAME_NEW_CMD(xframe, pack, xbus, GLOBAL, XBUS_RESET, 0);
@@ -461,14 +477,14 @@ HANDLER_DEF(GLOBAL, NULL_REPLY)
 	return 0;
 }

-HANDLER_DEF(GLOBAL, AB_DESCRIPTION)	/* 0x08 */
-{
-	struct xbus_workqueue	*worker;
-	byte			rev;
-	struct unit_descriptor	*units;
-	int			count_units;
-	int			i;
-	int			ret = 0;
+HANDLER_DEF(GLOBAL, AB_DESCRIPTION)
+{				/* 0x08 */
+	struct xbus_workqueue *worker;
+	__u8 rev;
+	struct unit_descriptor *units;
+	int count_units;
+	int i;
+	int ret = 0;

 	if (!xbus) {
 		NOTICE("%s: xbus is gone!!!\n", __func__);
@@ -476,31 +492,31 @@ HANDLER_DEF(GLOBAL, AB_DESCRIPTION)	/* 0x08 */
 	}
 	rev = RPACKET_FIELD(pack, GLOBAL, AB_DESCRIPTION, rev);
 	units = RPACKET_FIELD(pack, GLOBAL, AB_DESCRIPTION, unit_descriptor);
-	count_units = XPACKET_LEN(pack) - ((byte *)units - (byte *)pack);
+	count_units = XPACKET_LEN(pack) - ((__u8 *)units - (__u8 *)pack);
 	count_units /= sizeof(*units);
-	if(rev != XPP_PROTOCOL_VERSION) {
+	if (rev != XPP_PROTOCOL_VERSION) {
 		XBUS_NOTICE(xbus, "Bad protocol version %d (should be %d)\n",
-			rev, XPP_PROTOCOL_VERSION);
+			    rev, XPP_PROTOCOL_VERSION);
 		ret = -EPROTO;
 		goto proto_err;
 	}
-	if(count_units > NUM_UNITS) {
+	if (count_units > NUM_UNITS) {
 		XBUS_NOTICE(xbus, "Too many units %d (should be %d)\n",
-			count_units, NUM_UNITS);
+			    count_units, NUM_UNITS);
 		ret = -EPROTO;
 		goto proto_err;
 	}
-	if(count_units <= 0) {
-		XBUS_NOTICE(xbus, "Empty astribank? (%d units)\n",
-			count_units);
+	if (count_units <= 0) {
+		XBUS_NOTICE(xbus, "Empty astribank? (%d units)\n", count_units);
 		ret = -EPROTO;
 		goto proto_err;
 	}
-	if(!xbus_setstate(xbus, XBUS_STATE_RECVD_DESC)) {
+	if (!xbus_setstate(xbus, XBUS_STATE_RECVD_DESC)) {
 		ret = -EPROTO;
 		goto proto_err;
 	}
-	XBUS_INFO(xbus, "DESCRIPTOR: %d cards, protocol revision %d\n", count_units, rev);
+	XBUS_INFO(xbus, "DESCRIPTOR: %d cards, protocol revision %d\n",
+		  count_units, rev);
 	if (xbus_check_unique(xbus))
 		return -EBUSY;
 	xbus->revision = rev;
@@ -510,12 +526,14 @@ HANDLER_DEF(GLOBAL, AB_DESCRIPTION)	/* 0x08 */
 		ret = -ENODEV;
 		goto out;
 	}
-	for(i = 0; i < count_units; i++) {
-		struct unit_descriptor	*this_unit = &units[i];
-		struct card_desc_struct	*card_desc;
-		unsigned long		flags;
+	for (i = 0; i < count_units; i++) {
+		struct unit_descriptor *this_unit = &units[i];
+		struct card_desc_struct *card_desc;
+		unsigned long flags;

-		if((card_desc = KZALLOC(sizeof(struct card_desc_struct), GFP_ATOMIC)) == NULL) {
+		if ((card_desc =
+		     KZALLOC(sizeof(struct card_desc_struct),
+			     GFP_ATOMIC)) == NULL) {
 			XBUS_ERR(xbus, "Card description allocation failed.\n");
 			ret = -ENOMEM;
 			goto out;
@@ -528,16 +546,15 @@ HANDLER_DEF(GLOBAL, AB_DESCRIPTION)	/* 0x08 */
 		card_desc->numchips = this_unit->numchips;
 		card_desc->ports_per_chip = this_unit->ports_per_chip;
 		card_desc->port_dir = this_unit->port_dir;
-		card_desc->ports = card_desc->numchips * card_desc->ports_per_chip;
-		XBUS_INFO(xbus, "    CARD %d type=%d.%d ports=%d (%dx%d), port-dir=0x%02X\n",
-				card_desc->xpd_addr.unit,
-				card_desc->type,
-				card_desc->subtype,
-				card_desc->ports,
-				card_desc->numchips,
-				card_desc->ports_per_chip,
-				card_desc->port_dir
-				);
+		card_desc->ports =
+		    card_desc->numchips * card_desc->ports_per_chip;
+		XBUS_INFO(xbus,
+			"    CARD %d type=%d.%d ports=%d (%dx%d), "
+			"port-dir=0x%02X\n",
+			card_desc->xpd_addr.unit, card_desc->type,
+			card_desc->subtype, card_desc->ports,
+			card_desc->numchips, card_desc->ports_per_chip,
+			card_desc->port_dir);
 		spin_lock_irqsave(&worker->worker_lock, flags);
 		worker->num_units++;
 		XBUS_COUNTER(xbus, UNITS)++;
@@ -558,21 +575,23 @@ out:

 HANDLER_DEF(GLOBAL, REGISTER_REPLY)
 {
-	reg_cmd_t		*reg = &RPACKET_FIELD(pack, GLOBAL, REGISTER_REPLY, regcmd);
+	reg_cmd_t *reg = &RPACKET_FIELD(pack, GLOBAL, REGISTER_REPLY, regcmd);

-	if(!xpd) {
-		static int	rate_limit;
+	if (!xpd) {
+		static int rate_limit;

-		if((rate_limit++ % 1003) < 5)
-			notify_bad_xpd(__FUNCTION__, xbus, XPACKET_ADDR(pack), "");
+		if ((rate_limit++ % 1003) < 5)
+			notify_bad_xpd(__func__, xbus, XPACKET_ADDR(pack), "");
 		return -EPROTO;
 	}
-	if(debug & DBG_REGS) {
-		dump_reg_cmd("REG_REPLY", 0, xbus, xpd->addr.unit, reg->portnum, reg);
+	if (debug & DBG_REGS) {
+		dump_reg_cmd("REG_REPLY", 0, xbus, xpd->addr.unit, reg->portnum,
+			     reg);
 		dump_packet("REG_REPLY", pack, 1);
 	}
-	if (! XMETHOD(card_register_reply, xpd)) {
-		XPD_ERR(xpd, "REGISTER_REPLY: without card_register_reply() method\n");
+	if (!XMETHOD(card_register_reply, xpd)) {
+		XPD_ERR(xpd,
+			"REGISTER_REPLY: missing card_register_reply()\n");
 		return -EINVAL;
 	}
 	return CALL_XMETHOD(card_register_reply, xpd, reg);
@@ -580,12 +599,12 @@ HANDLER_DEF(GLOBAL, REGISTER_REPLY)

 HANDLER_DEF(GLOBAL, SYNC_REPLY)
 {
-	byte		mode = RPACKET_FIELD(pack, GLOBAL, SYNC_REPLY, sync_mode);
-	byte		drift = RPACKET_FIELD(pack, GLOBAL, SYNC_REPLY, drift);
-	const char	*mode_name;
+	__u8 mode = RPACKET_FIELD(pack, GLOBAL, SYNC_REPLY, sync_mode);
+	__u8 drift = RPACKET_FIELD(pack, GLOBAL, SYNC_REPLY, drift);
+	const char *mode_name;

 	BUG_ON(!xbus);
-	if((mode_name = sync_mode_name(mode)) == NULL) {
+	if ((mode_name = sync_mode_name(mode)) == NULL) {
 		XBUS_ERR(xbus, "SYNC_REPLY: bad sync_mode=0x%X\n", mode);
 		return -EINVAL;
 	}
@@ -599,24 +618,26 @@ HANDLER_DEF(GLOBAL, SYNC_REPLY)

 HANDLER_DEF(GLOBAL, ERROR_CODE)
 {
-	char			tmp_name[TMP_NAME_LEN];
-	static long		rate_limit;
-	byte			category_code;
-	byte			errorbits;
+	char tmp_name[TMP_NAME_LEN];
+	static long rate_limit;
+	__u8 category_code;
+	__u8 errorbits;

 	BUG_ON(!xbus);
-	if((rate_limit++ % 5003) > 200)
+	if ((rate_limit++ % 5003) > 200)
 		return 0;
 	category_code = RPACKET_FIELD(pack, GLOBAL, ERROR_CODE, category_code);
 	errorbits = RPACKET_FIELD(pack, GLOBAL, ERROR_CODE, errorbits);
-	if(!xpd) {
+	if (!xpd) {
 		snprintf(tmp_name, TMP_NAME_LEN, "%s(%1d%1d)", xbus->busname,
-			XPACKET_ADDR_UNIT(pack), XPACKET_ADDR_SUBUNIT(pack));
+			 XPACKET_ADDR_UNIT(pack), XPACKET_ADDR_SUBUNIT(pack));
 	} else {
-		snprintf(tmp_name, TMP_NAME_LEN, "%s/%s", xbus->busname, xpd->xpdname);
+		snprintf(tmp_name, TMP_NAME_LEN, "%s/%s", xbus->busname,
+			 xpd->xpdname);
 	}
-	NOTICE("%s: FIRMWARE %s: category=%d errorbits=0x%02X (rate_limit=%ld)\n",
-			tmp_name, cmd->name, category_code, errorbits, rate_limit);
+	NOTICE
+	    ("%s: FIRMWARE %s: category=%d errorbits=0x%02X (rate_limit=%ld)\n",
+	     tmp_name, cmd->name, category_code, errorbits, rate_limit);
 	dump_packet("FIRMWARE: ", pack, 1);
 	/*
 	 * FIXME: Should implement an error recovery plan
@@ -624,15 +645,14 @@ HANDLER_DEF(GLOBAL, ERROR_CODE)
 	return 0;
 }

-
 xproto_table_t PROTO_TABLE(GLOBAL) = {
 	.entries = {
 		/*	Prototable	Card	Opcode		*/
-		XENTRY(	GLOBAL,		GLOBAL, NULL_REPLY	),
-		XENTRY(	GLOBAL,		GLOBAL, AB_DESCRIPTION	),
+		XENTRY(	GLOBAL,		GLOBAL,	NULL_REPLY	),
+		XENTRY(	GLOBAL,		GLOBAL,	AB_DESCRIPTION	),
 		XENTRY(	GLOBAL,		GLOBAL,	SYNC_REPLY	),
-		XENTRY(	GLOBAL,		GLOBAL, ERROR_CODE	),
-		XENTRY(	GLOBAL,		GLOBAL, REGISTER_REPLY	),
+		XENTRY(	GLOBAL,		GLOBAL,	ERROR_CODE	),
+		XENTRY(	GLOBAL,		GLOBAL,	REGISTER_REPLY	),
 	},
 	.name = "GLOBAL",
 	.packet_is_valid = global_packet_is_valid,
@@ -641,7 +661,7 @@ xproto_table_t PROTO_TABLE(GLOBAL) = {

 static bool global_packet_is_valid(xpacket_t *pack)
 {
-	const xproto_entry_t	*xe;
+	const xproto_entry_t *xe;

 	//DBG(GENERAL, "\n");
 	xe = xproto_global_entry(XPACKET_OP(pack));
@@ -655,28 +675,37 @@ static void global_packet_dump(const char *msg, xpacket_t *pack)

 #define	MAX_PATH_STR	128

+#ifndef	UMH_WAIT_PROC
+/*
+ * - UMH_WAIT_PROC was introduced as enum in 2.6.23
+ *   with a value of 1
+ * - It was changed to a macro (and it's value was modified) in 3.3.0
+ */
+#define	UMH_WAIT_PROC	1
+#endif
+
 int run_initialize_registers(xpd_t *xpd)
 {
-	int	ret;
-	xbus_t	*xbus;
-	char	busstr[MAX_ENV_STR];
-	char	busnumstr[MAX_ENV_STR];
-	char	modelstr[MAX_ENV_STR];
-	char	unitstr[MAX_ENV_STR];
-	char	subunitsstr[MAX_ENV_STR];
-	char	typestr[MAX_ENV_STR];
-	char	directionstr[MAX_ENV_STR];
-	char	revstr[MAX_ENV_STR];
-	char	connectorstr[MAX_ENV_STR];
-	char	xbuslabel[MAX_ENV_STR];
-	char	init_card[MAX_PATH_STR];
-	byte	direction_mask;
-	int	i;
-	char	*argv[] = {
+	int ret;
+	xbus_t *xbus;
+	char busstr[MAX_ENV_STR];
+	char busnumstr[MAX_ENV_STR];
+	char modelstr[MAX_ENV_STR];
+	char unitstr[MAX_ENV_STR];
+	char subunitsstr[MAX_ENV_STR];
+	char typestr[MAX_ENV_STR];
+	char directionstr[MAX_ENV_STR];
+	char revstr[MAX_ENV_STR];
+	char connectorstr[MAX_ENV_STR];
+	char xbuslabel[MAX_ENV_STR];
+	char init_card[MAX_PATH_STR];
+	__u8 direction_mask;
+	int i;
+	char *argv[] = {
 		init_card,
 		NULL
 	};
-	char	*envp[] = {
+	char *envp[] = {
 		busstr,
 		busnumstr,
 		modelstr,
@@ -692,74 +721,82 @@ int run_initialize_registers(xpd_t *xpd)

 	BUG_ON(!xpd);
 	xbus = xpd->xbus;
-	if(!initdir || !initdir[0]) {
+	if (!initdir || !initdir[0]) {
 		XPD_NOTICE(xpd, "Missing initdir parameter\n");
 		ret = -EINVAL;
 		goto err;
 	}
-	if(!xpd_setstate(xpd, XPD_STATE_INIT_REGS)) {
+	if (!xpd_setstate(xpd, XPD_STATE_INIT_REGS)) {
 		ret = -EINVAL;
 		goto err;
 	}
 	direction_mask = 0;
-	for(i = 0; i < xpd->subunits; i++) {
-		xpd_t	*su = xpd_byaddr(xbus, xpd->addr.unit, i);
+	for (i = 0; i < xpd->subunits; i++) {
+		xpd_t *su = xpd_byaddr(xbus, xpd->addr.unit, i);

-		if(!su) {
-			XPD_ERR(xpd,
-				"Have %d subunits, but not subunit #%d\n",
+		if (!su) {
+			XPD_ERR(xpd, "Have %d subunits, but not subunit #%d\n",
 				xpd->subunits, i);
 			continue;
 		}
-		direction_mask |= (PHONEDEV(su).direction == TO_PHONE) ? BIT(i) : 0;
+		direction_mask |=
+		    (PHONEDEV(su).direction == TO_PHONE) ? BIT(i) : 0;
 	}
 	snprintf(busstr, MAX_ENV_STR, "XBUS_NAME=%s", xbus->busname);
 	snprintf(busnumstr, MAX_ENV_STR, "XBUS_NUMBER=%d", xbus->num);
-	snprintf(modelstr, MAX_ENV_STR, "XBUS_MODEL_STRING=%s", xbus->transport.model_string);
+	snprintf(modelstr, MAX_ENV_STR, "XBUS_MODEL_STRING=%s",
+		 xbus->transport.model_string);
 	snprintf(unitstr, MAX_ENV_STR, "UNIT_NUMBER=%d", xpd->addr.unit);
 	snprintf(typestr, MAX_ENV_STR, "UNIT_TYPE=%d", xpd->type);
 	snprintf(subunitsstr, MAX_ENV_STR, "UNIT_SUBUNITS=%d", xpd->subunits);
-	snprintf(directionstr, MAX_ENV_STR, "UNIT_SUBUNITS_DIR=%d", direction_mask);
+	snprintf(directionstr, MAX_ENV_STR, "UNIT_SUBUNITS_DIR=%d",
+		 direction_mask);
 	snprintf(revstr, MAX_ENV_STR, "XBUS_REVISION=%d", xbus->revision);
-	snprintf(connectorstr, MAX_ENV_STR, "XBUS_CONNECTOR=%s", xbus->connector);
+	snprintf(connectorstr, MAX_ENV_STR, "XBUS_CONNECTOR=%s",
+		 xbus->connector);
 	snprintf(xbuslabel, MAX_ENV_STR, "XBUS_LABEL=%s", xbus->label);
-	if(snprintf(init_card, MAX_PATH_STR, "%s/init_card_%d_%d",
-				initdir, xpd->type, xbus->revision) > MAX_PATH_STR) {
-		XPD_NOTICE(xpd, "Cannot initialize. pathname is longer than %d characters.\n", MAX_PATH_STR);
+	if (snprintf
+	    (init_card, MAX_PATH_STR, "%s/init_card_%d_%d", initdir, xpd->type,
+	     xbus->revision) > MAX_PATH_STR) {
+		XPD_NOTICE(xpd,
+			"Cannot initialize. pathname is longer "
+			"than %d characters.\n",
+			MAX_PATH_STR);
 		ret = -E2BIG;
 		goto err;
 	}
-	if(!XBUS_IS(xbus, RECVD_DESC)) {
-		XBUS_ERR(xbus, "Skipped register initialization. In state %s.\n",
-			xbus_statename(XBUS_STATE(xbus)));
+	if (!XBUS_IS(xbus, RECVD_DESC)) {
+		XBUS_ERR(xbus,
+			 "Skipped register initialization. In state %s.\n",
+			 xbus_statename(XBUS_STATE(xbus)));
 		ret = -ENODEV;
 		goto err;
 	}
 	XPD_DBG(DEVICES, xpd, "running '%s' for type=%d revision=%d\n",
-			init_card, xpd->type, xbus->revision);
-	ret = call_usermodehelper(init_card, argv, envp, 1);
+		init_card, xpd->type, xbus->revision);
+	ret = call_usermodehelper(init_card, argv, envp, UMH_WAIT_PROC);
 	/*
 	 * Carefully report results
 	 */
-	if(ret == 0)
+	if (ret == 0)
 		XPD_DBG(DEVICES, xpd, "'%s' finished OK\n", init_card);
-	else if(ret < 0) {
-		XPD_ERR(xpd, "Failed running '%s' (errno %d)\n", init_card, ret);
+	else if (ret < 0) {
+		XPD_ERR(xpd, "Failed running '%s' (errno %d)\n", init_card,
+			ret);
 	} else {
-		byte	exitval = ((unsigned)ret >> 8) & 0xFF;
-		byte	sigval = ret & 0xFF;
+		__u8 exitval = ((unsigned)ret >> 8) & 0xFF;
+		__u8 sigval = ret & 0xFF;

-		if(!exitval) {
-			XPD_ERR(xpd, "'%s' killed by signal %d\n", init_card, sigval);
+		if (!exitval) {
+			XPD_ERR(xpd, "'%s' killed by signal %d\n", init_card,
+				sigval);
 		} else {
-			XPD_ERR(xpd, "'%s' aborted with exitval %d\n", init_card, exitval);
+			XPD_ERR(xpd, "'%s' aborted with exitval %d\n",
+				init_card, exitval);
 		}
 		ret = -EINVAL;
 	}
 err:
 	return ret;
 }
-
-EXPORT_SYMBOL(sync_mode_name);
 EXPORT_SYMBOL(run_initialize_registers);
-EXPORT_SYMBOL(xpp_register_request);
--- a/drivers/dahdi/xpp/card_global.h
+++ b/drivers/dahdi/xpp/card_global.h
@@ -26,75 +26,45 @@
 #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, XBUS_RESET)	= 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, XBUS_RESET,
-	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);
@@ -102,13 +72,14 @@ DEF_RPACKET_DATA(GLOBAL, ERROR_CODE,
 /* 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/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/init_card_1_30
+++ b/drivers/dahdi/xpp/init_card_1_30
@@ -51,7 +51,7 @@ BEGIN { $init_dir = dirname($0); unshift(@INC, "$init_dir"); }
 use XppConfig $init_dir;
 my $unit_id;
 my %opts;
-my $vbat_48 = 0;
+my $eeprom_release_201 = 0;

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

@@ -94,7 +94,7 @@ if (-t STDERR) {
 	}
 	logit "XBUS_MODEL_STRING='$ENV{XBUS_MODEL_STRING}'";
 	if ($ENV{XBUS_MODEL_STRING} =~ m{.*/.*/201}) {
-		$vbat_48 = 1;
+		$eeprom_release_201 = 1;
 	}
 	$chipregs = sprintf "/sys/bus/xpds/devices/%02d:%1d:0/chipregs",
 		$ENV{XBUS_NUMBER}, $ENV{UNIT_NUMBER};
@@ -292,8 +292,8 @@ sub init_indirect_registers() {
 }

 sub init_early_direct_regs() {
-	my $lbv = ($vbat_48) ? "20" : "10";
-	my $vcm = ($vbat_48) ? "02" : "03";
+	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
--- 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
@@ -39,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);
 };

 /*
@@ -67,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_

@@ -99,17 +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;
-	char			model_string[MAX_ENV_STR];
+	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)
@@ -118,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);
@@ -127,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
@@ -163,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)
@@ -183,126 +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;
-	struct dahdi_device	*ddev;
+	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);

 /*
@@ -316,58 +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	xbus_is_registered(xbus_t *xbus);
-int	xbus_register_dahdi_device(xbus_t *xbus);
-void	xbus_unregister_dahdi_device(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);

-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 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);

-#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
-
-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/drivers/dahdi/xpp/xframe_queue.h
+++ b/drivers/dahdi/xpp/xframe_queue.h
@@ -8,23 +8,22 @@
 #define	XFRAME_QUEUE_MARGIN	10

 struct xframe_queue {
-	struct list_head	head;
-	bool			disabled;
-	unsigned int		count;
-	unsigned int		max_count;
-	unsigned int		steady_state_count;
-	spinlock_t		lock;
-	const char		*name;
-	void			*priv;
+	struct list_head head;
+	bool disabled;
+	unsigned int count;
+	unsigned int max_count;
+	unsigned int steady_state_count;
+	spinlock_t lock;
+	const char *name;
+	void *priv;
 	/* statistics */
-	unsigned int		worst_count;
-	unsigned int		overflows;
-	unsigned long		worst_lag_usec;	/* since xframe creation */
+	unsigned int worst_count;
+	unsigned int overflows;
+	unsigned long worst_lag_usec;	/* since xframe creation */
 };

-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);
 __must_check bool xframe_enqueue(struct xframe_queue *q, xframe_t *xframe);
 __must_check xframe_t *xframe_dequeue(struct xframe_queue *q);
 void xframe_queue_clearstats(struct xframe_queue *q);
@@ -32,4 +31,4 @@ void xframe_queue_disable(struct xframe_queue *q, bool disabled);
 void xframe_queue_clear(struct xframe_queue *q);
 uint xframe_queue_count(struct xframe_queue *q);

-#endif	/* XFRAME_QUEUE_ */
+#endif /* XFRAME_QUEUE_ */
--- a/drivers/dahdi/xpp/xpd.h
+++ b/drivers/dahdi/xpp/xpd.h
@@ -31,23 +31,17 @@
 #include <linux/device.h>
 #include <linux/version.h>
 #include <asm/atomic.h>
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
 #include <linux/semaphore.h>
 #else
 #include <asm/semaphore.h>
 #endif
 #include <linux/moduleparam.h>
-#endif	/* __KERNEL__ */
+#endif /* __KERNEL__ */

 #include <dahdi/kernel.h>

 #ifdef __KERNEL__
-#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

 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 31)
 /*
@@ -55,9 +49,9 @@ typedef	unsigned gfp_t;		/* Added in 2.6.14 */
 * bool is now defined as a proper boolean type (gcc _Bool)
 * but the command line parsing framework handles it as int.
 */
-#define	DEF_PARM_BOOL(name,init,perm,desc)	\
-	int name = init;	\
-	module_param(name, bool, perm);		\
+#define	DEF_PARM_BOOL(name, init, perm, desc) \
+	int name = init; \
+	module_param(name, bool, perm); \
 	MODULE_PARM_DESC(name, desc " [default " #init "]")
 #else
 #define	DEF_PARM_BOOL(name, init, perm, desc) \
@@ -66,43 +60,31 @@ typedef	unsigned gfp_t;		/* Added in 2.6.14 */
 	MODULE_PARM_DESC(name, desc " [default " #init "]")
 #endif

-#define	DEF_PARM(type,name,init,perm,desc)	\
-	type name = init;	\
-	module_param(name, type, perm);		\
+#define	DEF_PARM(type, name, init, perm, desc) \
+	type name = init; \
+	module_param(name, type, perm); \
 	MODULE_PARM_DESC(name, desc " [default " #init "]")

-#if	LINUX_VERSION_CODE	< KERNEL_VERSION(2,6,10)
-/*
- * Old 2.6 kernels had module_param_array() macro that receive the counter
- * by value.
- */
-#define	DEF_ARRAY(type,name,count,init,desc)	\
-	unsigned int name ## _num_values;	\
-	type name[count] = { [0 ... ((count)-1)] = (init) };			\
-	module_param_array(name, type, name ## _num_values, 0644);	\
+#define	DEF_ARRAY(type, name, count, init, desc) \
+	unsigned int name ## _num_values; \
+	type name[count] = {[0 ... ((count)-1)] = init}; \
+	module_param_array(name, type, &name ## _num_values, 0644); \
 	MODULE_PARM_DESC(name, desc " ( 1-" __MODULE_STRING(count) ")")
-#else
-#define	DEF_ARRAY(type,name,count,init,desc)	\
-	unsigned int name ## _num_values;	\
-	type name[count] = {[0 ... ((count)-1)] = init};			\
-	module_param_array(name, type, &name ## _num_values, 0644);	\
-	MODULE_PARM_DESC(name, desc " ( 1-" __MODULE_STRING(count) ")")
-#endif
-#endif	// __KERNEL__
+#endif // __KERNEL__

 #define	CARD_DESC_MAGIC	0xca9dde5c

-struct	card_desc_struct {
-	struct list_head	card_list;
-	u32			magic;
-	byte			type;		/* LSB: 1 - to_phone, 0 - to_line */
-	byte			subtype;
-	struct xpd_addr		xpd_addr;
-	byte			numchips;
-	byte			ports_per_chip;
-	byte			ports;
-	byte			port_dir;
-	struct xpd_addr		ec_addr;	/* echo canceler address */
+struct card_desc_struct {
+	struct list_head card_list;
+	u32 magic;
+	__u8 type;		/* LSB: 1 - to_phone, 0 - to_line */
+	__u8 subtype;
+	struct xpd_addr xpd_addr;
+	__u8 numchips;
+	__u8 ports_per_chip;
+	__u8 ports;
+	__u8 port_dir;
+	struct xpd_addr ec_addr;	/* echo canceler address */
 };

 typedef enum xpd_direction {
@@ -127,12 +109,9 @@ enum {

 /* yucky, make an instance so we can size it... */
 static struct xpd_counters {
-	char	*name;
+	char *name;
 } xpd_counters[] = {
-	C_(PCM_READ),
-	C_(PCM_WRITE),
-	C_(RECV_ERRORS),
-};
+C_(PCM_READ), C_(PCM_WRITE), C_(RECV_ERRORS),};

 #undef C_

@@ -145,43 +124,43 @@ enum xpd_state {
 	XPD_STATE_NOHW,
 };

-bool		xpd_setstate(xpd_t *xpd, enum xpd_state newstate);
-const char	*xpd_statename(enum xpd_state st);
+bool xpd_setstate(xpd_t *xpd, enum xpd_state newstate);
+const char *xpd_statename(enum xpd_state st);

 #define	PHONEDEV(xpd)		((xpd)->phonedev)
 #define	IS_PHONEDEV(xpd)	(PHONEDEV(xpd).phoneops)

 struct phonedev {
-	const struct phoneops	*phoneops;	/* Card level operations */
-	struct dahdi_span	span;
-	struct dahdi_chan	*chans[32];
-#define	XPD_CHAN(xpd,chan)	(PHONEDEV(xpd).chans[(chan)])
+	const struct phoneops *phoneops;	/* Card level operations */
+	struct dahdi_span span;
+	struct dahdi_chan *chans[32];
+#define	XPD_CHAN(xpd, chan)	(PHONEDEV(xpd).chans[(chan)])
 	struct dahdi_echocan_state *ec[32];

-	int		channels;
-	xpd_direction_t	direction;		/* TO_PHONE, TO_PSTN */
-	xpp_line_t	no_pcm;			/* Temporary: disable PCM (for USB-1) */
-	xpp_line_t	offhook_state;		/* Actual chip state: 0 - ONHOOK, 1 - OFHOOK */
-	xpp_line_t	oht_pcm_pass;		/* Transfer on-hook PCM */
+	int channels;
+	xpd_direction_t direction;	/* TO_PHONE, TO_PSTN */
+	xpp_line_t no_pcm;		/* Temporary: disable PCM (for USB-1) */
+	xpp_line_t offhook_state;	/* chip state: 0 - ONHOOK, 1 - OFHOOK */
+	xpp_line_t oht_pcm_pass;	/* Transfer on-hook PCM */
 	/* Voice Mail Waiting Indication: */
-	unsigned int	msg_waiting[CHANNELS_PERXPD];
-	xpp_line_t	digital_outputs;	/* 0 - no, 1 - yes */
-	xpp_line_t	digital_inputs;		/* 0 - no, 1 - yes */
-	xpp_line_t	digital_signalling;	/* BRI signalling channels */
-	uint		timing_priority;	/* from 'span' directives in chan_dahdi.conf */
+	unsigned int msg_waiting[CHANNELS_PERXPD];
+	xpp_line_t digital_outputs;	/* 0 - no, 1 - yes */
+	xpp_line_t digital_inputs;	/* 0 - no, 1 - yes */
+	xpp_line_t digital_signalling;	/* BRI signalling channels */
+	uint timing_priority;	/* from 'span' directives in chan_dahdi.conf */

 	/* Assure atomicity of changes to pcm_len and wanted_pcm_mask */
-	spinlock_t	lock_recompute_pcm;
+	spinlock_t lock_recompute_pcm;
 	/* maintained by card drivers */
-	uint		pcm_len;		/* allocation length of PCM packet (dynamic) */
-	xpp_line_t	wanted_pcm_mask;
-	xpp_line_t	silence_pcm;		/* inject silence during next tick */
-	xpp_line_t	mute_dtmf;
+	uint pcm_len;		/* allocation length of PCM packet (dynamic) */
+	xpp_line_t wanted_pcm_mask;
+	xpp_line_t silence_pcm;	/* inject silence during next tick */
+	xpp_line_t mute_dtmf;

-	bool		ringing[CHANNELS_PERXPD];
+	bool ringing[CHANNELS_PERXPD];

-	atomic_t	dahdi_registered;	/* Am I fully registered with dahdi */
-	atomic_t	open_counter;	/* Number of open channels */
+	atomic_t dahdi_registered;	/* Am I fully registered with dahdi */
+	atomic_t open_counter;	/* Number of open channels */

 	/* Echo cancelation */
 	u_char ec_chunk1[CHANNELS_PERXPD][DAHDI_CHUNKSIZE];
@@ -193,51 +172,52 @@ struct phonedev {
 */
 struct xpd {
 	char xpdname[XPD_NAMELEN];
-	struct phonedev	phonedev;
+	struct phonedev phonedev;

-	const struct xops	*xops;
-	xpd_type_t	type;
-	const char	*type_name;
-	byte		subtype;
-	int		subunits;		/* all siblings */
-	enum xpd_state	xpd_state;
-	struct device	xpd_dev;
+	const struct xops *xops;
+	xpd_type_t type;
+	const char *type_name;
+	__u8 subtype;
+	int subunits;		/* all siblings */
+	enum xpd_state xpd_state;
+	struct device xpd_dev;
 #define	dev_to_xpd(dev)	container_of(dev, struct xpd, xpd_dev)
-	struct kref		kref;
+	struct kref kref;
 #define kref_to_xpd(k) container_of(k, struct xpd, kref)

-	xbus_t *xbus;			/* The XBUS we are connected to */
-	struct device	*echocancel;
+	xbus_t *xbus;		/* The XBUS we are connected to */
+	struct device *echocancel;

-	spinlock_t	lock;
+	spinlock_t lock;

-	int		flags;
-	unsigned long	blink_mode;	/* bitmask of blinking ports */
+	int flags;
+	unsigned long blink_mode;	/* bitmask of blinking ports */
 #define	DEFAULT_LED_PERIOD	(1000/8)	/* in tick */

 #ifdef CONFIG_PROC_FS
-	struct proc_dir_entry	*proc_xpd_dir;
-	struct proc_dir_entry	*proc_xpd_summary;
+	struct proc_dir_entry *proc_xpd_dir;
+	struct proc_dir_entry *proc_xpd_summary;
 #endif

-	int		counters[XPD_COUNTER_MAX];
+	int counters[XPD_COUNTER_MAX];

-	const xproto_table_t	*xproto;	/* Card level protocol table */
-	void		*priv;			/* Card level private data */
-	bool		card_present;
-	reg_cmd_t	requested_reply;
-	reg_cmd_t	last_reply;
+	const xproto_table_t *xproto;	/* Card level protocol table */
+	void *priv;		/* Card level private data */
+	bool card_present;
+	reg_cmd_t requested_reply;
+	reg_cmd_t last_reply;

-	unsigned long	last_response;	/* in jiffies */
-	unsigned	xbus_idx;	/* index in xbus->xpds[] */
-	struct xpd_addr	addr;
+	unsigned long last_response;	/* in jiffies */
+	unsigned xbus_idx;	/* index in xbus->xpds[] */
+	struct xpd_addr addr;
 	struct list_head xpd_list;
-	unsigned int	timer_count;
+	unsigned int timer_count;
 };

-#define	for_each_line(xpd,i)	for((i) = 0; (i) < PHONEDEV(xpd).channels; (i)++)
+#define	for_each_line(xpd, i) \
+		for ((i) = 0; (i) < PHONEDEV(xpd).channels; (i)++)
 #define	IS_BRI(xpd)		((xpd)->type == XPD_TYPE_BRI)
-#define	TICK_TOLERANCE		500 /* usec */
+#define	TICK_TOLERANCE		500	/* usec */

 #ifdef	DEBUG_SYNC_PARPORT
 void xbus_flip_bit(xbus_t *xbus, unsigned int bitnum0, unsigned int bitnum1);
@@ -247,27 +227,28 @@ void xbus_flip_bit(xbus_t *xbus, unsigned int bitnum0, unsigned int bitnum1);

 static inline void *my_kzalloc(size_t size, gfp_t flags)
 {
-	void	*p;
+	void *p;

 	p = kmalloc(size, flags);
-	if(p)
+	if (p)
 		memset(p, 0, size);
 	return p;
 }

 struct xpd_driver {
-	xpd_type_t	type;
+	xpd_type_t type;

-	struct device_driver	driver;
-#define   driver_to_xpd_driver(driver) container_of(driver, struct xpd_driver, driver)
+	struct device_driver driver;
+#define	driver_to_xpd_driver(driver) \
+		container_of(driver, struct xpd_driver, driver)
 };

-int	xpd_driver_register(struct device_driver *driver);
-void	xpd_driver_unregister(struct device_driver *driver);
-xpd_t	*get_xpd(const char *msg, xpd_t *xpd);
-void	put_xpd(const char *msg, xpd_t *xpd);
-int	refcount_xpd(xpd_t *xpd);
+int xpd_driver_register(struct device_driver *driver);
+void xpd_driver_unregister(struct device_driver *driver);
+xpd_t *get_xpd(const char *msg, xpd_t *xpd);
+void put_xpd(const char *msg, xpd_t *xpd);
+int refcount_xpd(xpd_t *xpd);

 #endif

-#endif	/* XPD_H */
+#endif /* XPD_H */
--- a/drivers/dahdi/xpp/xpp_dahdi.c
+++ b/drivers/dahdi/xpp/xpp_dahdi.c
--- a/drivers/dahdi/xpp/xpp_dahdi.h
+++ b/drivers/dahdi/xpp/xpp_dahdi.h
@@ -30,17 +30,19 @@ int xpd_dahdi_preregister(xpd_t *xpd, unsigned offset);
 int xpd_dahdi_postregister(xpd_t *xpd);
 void xpd_dahdi_preunregister(xpd_t *xpd);
 void xpd_dahdi_postunregister(xpd_t *xpd);
-int create_xpd(xbus_t *xbus, const xproto_table_t *proto_table,
-		int unit, int subunit, byte type, byte subtype, int subunits, int subunit_ports, byte port_dir);
-xpd_t *xpd_alloc(xbus_t *xbus, int unit, int subunit, int subtype, int subunits, size_t privsize, const xproto_table_t *proto_table, int channels);
+int create_xpd(xbus_t *xbus, const xproto_table_t *proto_table, int unit,
+	       int subunit, __u8 type, __u8 subtype, int subunits,
+	       int subunit_ports, __u8 port_dir);
+xpd_t *xpd_alloc(xbus_t *xbus, int unit, int subunit, int subtype, int subunits,
+		 size_t privsize, const xproto_table_t *proto_table,
+		 int channels);
 void xpd_free(xpd_t *xpd);
 void xpd_remove(xpd_t *xpd);
 void update_xpd_status(xpd_t *xpd, int alarm_flag);
 const char *xpp_echocan_name(const struct dahdi_chan *chan);
-int xpp_echocan_create(struct dahdi_chan *chan,
-				struct dahdi_echocanparams *ecp,
-				struct dahdi_echocanparam *p,
-				struct dahdi_echocan_state **ec);
+int xpp_echocan_create(struct dahdi_chan *chan, struct dahdi_echocanparams *ecp,
+		       struct dahdi_echocanparam *p,
+		       struct dahdi_echocan_state **ec);
 void hookstate_changed(xpd_t *xpd, int pos, bool good);
 int xpp_open(struct dahdi_chan *chan);
 int xpp_close(struct dahdi_chan *chan);
@@ -53,15 +55,15 @@ void report_bad_ioctl(const char *msg, xpd_t *xpd, int pos, unsigned int cmd);
 int total_registered_spans(void);
 void oht_pcm(xpd_t *xpd, int pos, bool pass);
 void mark_offhook(xpd_t *xpd, int pos, bool to_offhook);
-#define	IS_OFFHOOK(xpd,pos)	IS_SET((xpd)->phonedev.offhook_state, (pos))
+#define	IS_OFFHOOK(xpd, pos)	IS_SET((xpd)->phonedev.offhook_state, (pos))
 void notify_rxsig(xpd_t *xpd, int pos, enum dahdi_rxsig rxsig);

 #ifdef CONFIG_PROC_FS
 #include <linux/proc_fs.h>

-extern struct proc_dir_entry	*xpp_proc_toplevel;
+extern struct proc_dir_entry *xpp_proc_toplevel;
 #endif

 #define	SPAN_REGISTERED(xpd)	atomic_read(&PHONEDEV(xpd).dahdi_registered)

-#endif	/* XPP_DAHDI_H */
+#endif /* XPP_DAHDI_H */
--- a/drivers/dahdi/xpp/xpp_usb.c
+++ b/drivers/dahdi/xpp/xpp_usb.c
--- a/drivers/dahdi/xpp/xproto.c
+++ b/drivers/dahdi/xpp/xproto.c
@@ -30,7 +30,7 @@

 static const char rcsid[] = "$Id$";

-extern	int debug;
+extern int debug;

 static const xproto_table_t *xprotocol_tables[XPD_TYPE_NOMODULE];

@@ -40,12 +40,15 @@ static const xproto_table_t *xprotocol_tables[XPD_TYPE_NOMODULE];

 bool valid_xpd_addr(const struct xpd_addr *addr)
 {
-	return ((addr->subunit & ~BITMASK(SUBUNIT_BITS)) == 0) && ((addr->unit & ~BITMASK(UNIT_BITS)) == 0);
+	return ((addr->subunit & ~BITMASK(SUBUNIT_BITS)) == 0)
+	    && ((addr->unit & ~BITMASK(UNIT_BITS)) == 0);
 }
+EXPORT_SYMBOL(valid_xpd_addr);

-/*---------------- General Protocol Management ----------------------------*/
+/*------ General Protocol Management ----------------------------*/

-const xproto_entry_t *xproto_card_entry(const xproto_table_t *table, byte opcode)
+const xproto_entry_t *xproto_card_entry(const xproto_table_t *table,
+					__u8 opcode)
 {
 	const xproto_entry_t *xe;

@@ -53,8 +56,9 @@ const xproto_entry_t *xproto_card_entry(const xproto_table_t *table, byte opcode
 	xe = &table->entries[opcode];
 	return (xe->handler != NULL) ? xe : NULL;
 }
+EXPORT_SYMBOL(xproto_card_entry);

-const xproto_entry_t *xproto_global_entry(byte opcode)
+const xproto_entry_t *xproto_global_entry(__u8 opcode)
 {
 	const xproto_entry_t *xe;

@@ -62,15 +66,16 @@ const xproto_entry_t *xproto_global_entry(byte opcode)
 	//DBG(GENERAL, "opcode=0x%X xe=%p\n", opcode, xe);
 	return xe;
 }
+EXPORT_SYMBOL(xproto_global_entry);

-xproto_handler_t xproto_global_handler(byte opcode)
+xproto_handler_t xproto_global_handler(__u8 opcode)
 {
 	return xproto_card_handler(&PROTO_TABLE(GLOBAL), opcode);
 }

 static const xproto_table_t *xproto_table(xpd_type_t cardtype)
 {
-	if(cardtype >= XPD_TYPE_NOMODULE)
+	if (cardtype >= XPD_TYPE_NOMODULE)
 		return NULL;
 	return xprotocol_tables[cardtype];
 }
@@ -85,26 +90,28 @@ const xproto_table_t *xproto_get(xpd_type_t cardtype)
 {
 	const xproto_table_t *xtable;

-	if(cardtype >= XPD_TYPE_NOMODULE)
+	if (cardtype >= XPD_TYPE_NOMODULE)
 		return NULL;
 	xtable = xprotocol_tables[cardtype];
-	if(!xtable) {	/* Try to load the relevant module */
+	if (!xtable) {		/* Try to load the relevant module */
 		int ret = request_module(XPD_TYPE_PREFIX "%d", cardtype);
-		if(ret != 0) {
-			NOTICE("%s: Failed to load module for type=%d. exit status=%d.\n",
-					__FUNCTION__, cardtype, ret);
+		if (ret != 0) {
+			NOTICE("%s: Failed to load module for type=%d. "
+				"exit status=%d.\n",
+				__func__, cardtype, ret);
 			/* Drop through: we may be lucky... */
 		}
 		xtable = xprotocol_tables[cardtype];
 	}
-	if(xtable) {
+	if (xtable) {
 		BUG_ON(!xtable->owner);
 #ifdef CONFIG_MODULE_UNLOAD
 		DBG(GENERAL, MODULE_REFCOUNT_FORMAT, xtable->name,
 		    module_refcount(xtable->owner));
 #endif
-		if(!try_module_get(xtable->owner)) {
-			ERR("%s: try_module_get for %s failed.\n", __FUNCTION__, xtable->name);
+		if (!try_module_get(xtable->owner)) {
+			ERR("%s: try_module_get for %s failed.\n", __func__,
+			    xtable->name);
 			return NULL;
 		}
 	}
@@ -122,7 +129,8 @@ void xproto_put(const xproto_table_t *xtable)
 	module_put(xtable->owner);
 }

-xproto_handler_t xproto_card_handler(const xproto_table_t *table, byte opcode)
+xproto_handler_t xproto_card_handler(const xproto_table_t *table,
+	__u8 opcode)
 {
 	const xproto_entry_t *xe;

@@ -131,78 +139,89 @@ xproto_handler_t xproto_card_handler(const xproto_table_t *table, byte opcode)
 	return xe->handler;
 }

-void notify_bad_xpd(const char *funcname, xbus_t *xbus, const struct xpd_addr addr, const char *msg)
+void notify_bad_xpd(const char *funcname, xbus_t *xbus,
+		    const struct xpd_addr addr, const char *msg)
 {
-	XBUS_NOTICE(xbus, "%s: non-existing address (%1d%1d): %s\n",
-			funcname, addr.unit, addr.subunit, msg);
+	XBUS_NOTICE(xbus, "%s: non-existing address (%1d%1d): %s\n", funcname,
+		    addr.unit, addr.subunit, msg);
 }
+EXPORT_SYMBOL(notify_bad_xpd);

 static int packet_process(xbus_t *xbus, xpacket_t *pack)
 {
-	byte			op;
-	const xproto_entry_t	*xe;
-	xproto_handler_t	handler;
-	xproto_table_t		*table;
-	xpd_t			*xpd;
-	int			ret = -EPROTO;
+	__u8 op;
+	const xproto_entry_t *xe;
+	xproto_handler_t handler;
+	xproto_table_t *table;
+	xpd_t *xpd;
+	int ret = -EPROTO;

 	BUG_ON(!pack);
-	if(!valid_xpd_addr(&XPACKET_ADDR(pack))) {
-		if(printk_ratelimit()) {
+	if (!valid_xpd_addr(&XPACKET_ADDR(pack))) {
+		if (printk_ratelimit()) {
 			XBUS_NOTICE(xbus, "%s: from %d%d: bad address.\n",
-					__FUNCTION__,
-					XPACKET_ADDR_UNIT(pack), XPACKET_ADDR_SUBUNIT(pack));
-			dump_packet("packet_process -- bad address", pack, debug);
+				    __func__, XPACKET_ADDR_UNIT(pack),
+				    XPACKET_ADDR_SUBUNIT(pack));
+			dump_packet("packet_process -- bad address", pack,
+				    debug);
 		}
 		goto out;
 	}
 	op = XPACKET_OP(pack);
-	xpd = xpd_byaddr(xbus, XPACKET_ADDR_UNIT(pack), XPACKET_ADDR_SUBUNIT(pack));
+	xpd =
+	    xpd_byaddr(xbus, XPACKET_ADDR_UNIT(pack),
+		       XPACKET_ADDR_SUBUNIT(pack));
 	/* XPD may be NULL (e.g: during bus polling */
 	xe = xproto_global_entry(op);
 	/*-------- Validations -----------*/
-	if(!xe) {
+	if (!xe) {
 		const xproto_table_t *xtable;
-		
-		if(!xpd) {
-			if(printk_ratelimit()) {
-				XBUS_NOTICE(xbus, "%s: from %d%d opcode=0x%02X: no such global command.\n",
-						__FUNCTION__,
-						XPACKET_ADDR_UNIT(pack), XPACKET_ADDR_SUBUNIT(pack), op);
-				dump_packet("packet_process -- no such global command", pack, 1);
+
+		if (!xpd) {
+			if (printk_ratelimit()) {
+				XBUS_NOTICE(xbus,
+					"%s: from %d%d opcode=0x%02X: "
+					"no such global command.\n",
+					__func__, XPACKET_ADDR_UNIT(pack),
+					XPACKET_ADDR_SUBUNIT(pack), op);
+				dump_packet
+				    ("packet_process -- no such global command",
+				     pack, 1);
 			}
 			goto out;
 		}
 		xtable = xproto_table(xpd->type);
-		if(!xtable) {
-			if(printk_ratelimit())
-				XPD_ERR(xpd, "%s: no protocol table (type=%d)\n",
-					__FUNCTION__,
-					xpd->type);
+		if (!xtable) {
+			if (printk_ratelimit())
+				XPD_ERR(xpd,
+					"%s: no protocol table (type=%d)\n",
+					__func__, xpd->type);
 			goto out;
 		}
 		xe = xproto_card_entry(xtable, op);
-		if(!xe) {
-			if(printk_ratelimit()) {
-				XPD_NOTICE(xpd, "%s: bad command (type=%d,opcode=0x%x)\n",
-					__FUNCTION__,
-					xpd->type, op);
-				dump_packet("packet_process -- bad command", pack, 1);
+		if (!xe) {
+			if (printk_ratelimit()) {
+				XPD_NOTICE(xpd,
+					"%s: bad command (type=%d,opcode=0x%x)\n",
+					__func__, xpd->type, op);
+				dump_packet("packet_process -- bad command",
+					pack, 1);
 			}
 			goto out;
 		}
 	}
 	table = xe->table;
 	BUG_ON(!table);
-	if(!table->packet_is_valid(pack)) {
-		if(printk_ratelimit()) {
+	if (!table->packet_is_valid(pack)) {
+		if (printk_ratelimit()) {
 			ERR("xpp: %s: wrong size %d for opcode=0x%02X\n",
-					__FUNCTION__, XPACKET_LEN(pack), op);
-			dump_packet("packet_process -- wrong size", pack, debug);
+			    __func__, XPACKET_LEN(pack), op);
+			dump_packet("packet_process -- wrong size", pack,
+				    debug);
 		}
 		goto out;
 	}
-	ret = 0;	/* All well */
+	ret = 0;		/* All well */
 	handler = xe->handler;
 	BUG_ON(!handler);
 	XBUS_COUNTER(xbus, RX_BYTES) += XPACKET_LEN(pack);
@@ -213,13 +232,13 @@ out:

 static int xframe_receive_cmd(xbus_t *xbus, xframe_t *xframe)
 {
-	byte		*xframe_end;
-	xpacket_t	*pack;
-	byte		*p;
-	int		len;
-	int		ret;
+	__u8 *xframe_end;
+	xpacket_t *pack;
+	__u8 *p;
+	int len;
+	int ret;

-	if(debug & DBG_COMMANDS)
+	if (debug & DBG_COMMANDS)
 		dump_xframe("RX-CMD", xbus, xframe, DBG_ANY);
 	p = xframe->packets;
 	xframe_end = p + XFRAME_LEN(xframe);
@@ -227,31 +246,34 @@ static int xframe_receive_cmd(xbus_t *xbus, xframe_t *xframe)
 		pack = (xpacket_t *)p;
 		len = XPACKET_LEN(pack);
 		/* Sanity checks */
-		if(unlikely(XPACKET_OP(pack) == XPROTO_NAME(GLOBAL,PCM_READ))) {
-			static int	rate_limit;
+		if (unlikely(XPACKET_OP(pack) == XPROTO_NAME(GLOBAL, PCM_READ))) {
+			static int rate_limit;

-			if((rate_limit++ % 1003) == 0) {
-				XBUS_DBG(GENERAL, xbus, "A PCM packet within a Non-PCM xframe\n");
-				dump_xframe("In Non-PCM xframe", xbus, xframe, debug);
+			if ((rate_limit++ % 1003) == 0) {
+				XBUS_DBG(GENERAL, xbus,
+					"A PCM packet within a Non-PCM xframe\n");
+				dump_xframe("In Non-PCM xframe",
+					xbus, xframe, debug);
 			}
 			ret = -EPROTO;
 			goto out;
 		}
 		p += len;
-		if(p > xframe_end || len < RPACKET_HEADERSIZE) {
-			static int	rate_limit;
+		if (p > xframe_end || len < RPACKET_HEADERSIZE) {
+			static int rate_limit;

-			if((rate_limit++ % 1003) == 0) {
-				XBUS_NOTICE(xbus, "Invalid packet length %d\n", len);
+			if ((rate_limit++ % 1003) == 0) {
+				XBUS_NOTICE(xbus, "Invalid packet length %d\n",
+					    len);
 				dump_xframe("BAD LENGTH", xbus, xframe, debug);
 			}
 			ret = -EPROTO;
 			goto out;
 		}
 		ret = packet_process(xbus, pack);
-		if(unlikely(ret < 0))
+		if (unlikely(ret < 0))
 			break;
-	} while(p < xframe_end);
+	} while (p < xframe_end);
 out:
 	FREE_RECV_XFRAME(xbus, xframe);
 	return ret;
@@ -259,22 +281,22 @@ out:

 int xframe_receive(xbus_t *xbus, xframe_t *xframe)
 {
-	int		ret = 0;
-	struct timeval	now;
-	struct timeval	tv_received;
-	int		usec;
+	int ret = 0;
+	struct timeval now;
+	struct timeval tv_received;
+	int usec;

-	if(XFRAME_LEN(xframe) < RPACKET_HEADERSIZE) {
-		static int	rate_limit;
+	if (XFRAME_LEN(xframe) < RPACKET_HEADERSIZE) {
+		static int rate_limit;

-		if((rate_limit++ % 1003) == 0) {
+		if ((rate_limit++ % 1003) == 0) {
 			XBUS_NOTICE(xbus, "short xframe\n");
 			dump_xframe("short xframe", xbus, xframe, debug);
 		}
 		FREE_RECV_XFRAME(xbus, xframe);
 		return -EPROTO;
 	}
-	if(!XBUS_FLAGS(xbus, CONNECTED)) {
+	if (!XBUS_FLAGS(xbus, CONNECTED)) {
 		XBUS_DBG(GENERAL, xbus, "Dropped xframe. Is shutting down.\n");
 		return -ENODEV;
 	}
@@ -282,8 +304,8 @@ int xframe_receive(xbus_t *xbus, xframe_t *xframe)
 	/*
 	 * We want to check that xframes do not mix PCM and other commands
 	 */
-	if(XPACKET_IS_PCM((xpacket_t *)xframe->packets)) {
-		if(!XBUS_IS(xbus, READY))
+	if (XPACKET_IS_PCM((xpacket_t *)xframe->packets)) {
+		if (!XBUS_IS(xbus, READY))
 			FREE_RECV_XFRAME(xbus, xframe);
 		else
 			xframe_receive_pcm(xbus, xframe);
@@ -293,47 +315,48 @@ int xframe_receive(xbus_t *xbus, xframe_t *xframe)
 	}
 	/* Calculate total processing time */
 	do_gettimeofday(&now);
-	usec = (now.tv_sec - tv_received.tv_sec) * 1000000 +
-		now.tv_usec - tv_received.tv_usec;
-	if(usec > xbus->max_rx_process)
+	usec =
+	    (now.tv_sec - tv_received.tv_sec) * 1000000 + now.tv_usec -
+	    tv_received.tv_usec;
+	if (usec > xbus->max_rx_process)
 		xbus->max_rx_process = usec;
 	return ret;
 }
+EXPORT_SYMBOL(xframe_receive);

 #define	VERBOSE_DEBUG		1
 #define	ERR_REPORT_LIMIT	20

 void dump_packet(const char *msg, const xpacket_t *packet, bool debug)
 {
-	byte	op = XPACKET_OP(packet);
-	byte	*addr = (byte *)&XPACKET_ADDR(packet);
+	__u8 op = XPACKET_OP(packet);
+	__u8 *addr = (__u8 *)&XPACKET_ADDR(packet);

-	if(!debug)
+	if (!debug)
 		return;
-	printk(KERN_DEBUG "%s: XPD=%1X-%1X%c (0x%X) OP=0x%02X LEN=%d",
-			msg,
-			XPACKET_ADDR_UNIT(packet),
-			XPACKET_ADDR_SUBUNIT(packet),
-			(XPACKET_ADDR_SYNC(packet))?'+':' ',
-			*addr,
-			op,
-			XPACKET_LEN(packet));
+	printk(KERN_DEBUG "%s: XPD=%1X-%1X%c (0x%X) OP=0x%02X LEN=%d", msg,
+	       XPACKET_ADDR_UNIT(packet), XPACKET_ADDR_SUBUNIT(packet),
+	       (XPACKET_ADDR_SYNC(packet)) ? '+' : ' ', *addr, op,
+	       XPACKET_LEN(packet));
 #if VERBOSE_DEBUG
 	{
 		int i;
-		byte	*p = (byte *)packet;
+		__u8 *p = (__u8 *)packet;

 		printk(" BYTES: ");
-		for(i = 0; i < XPACKET_LEN(packet); i++) {
-			static int limiter = 0;
+		for (i = 0; i < XPACKET_LEN(packet); i++) {
+			static int limiter;

-			if(i >= sizeof(xpacket_t)) {
-				if(limiter < ERR_REPORT_LIMIT) {
-					ERR("%s: length overflow i=%d > sizeof(xpacket_t)=%lu\n",
-						__FUNCTION__, i+1, (long)sizeof(xpacket_t));
-				} else if(limiter == ERR_REPORT_LIMIT) {
-					ERR("%s: error packet #%d... squelsh reports.\n",
-						__FUNCTION__, limiter);
+			if (i >= sizeof(xpacket_t)) {
+				if (limiter < ERR_REPORT_LIMIT) {
+					ERR("%s: length overflow "
+						"i=%d > sizeof(xpacket_t)=%lu\n",
+						__func__, i + 1,
+						(long)sizeof(xpacket_t));
+				} else if (limiter == ERR_REPORT_LIMIT) {
+					ERR("%s: error packet #%d... "
+						"squelsh reports.\n",
+						__func__, limiter);
 				}
 				limiter++;
 				break;
@@ -345,112 +368,121 @@ void dump_packet(const char *msg, const xpacket_t *packet, bool debug)
 #endif
 	printk("\n");
 }
+EXPORT_SYMBOL(dump_packet);

 void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus,
-		byte unit, xportno_t port, const reg_cmd_t *regcmd)
+	__u8 unit, xportno_t port, const reg_cmd_t *regcmd)
 {
-	char		action;
-	char		modifier;
-	char		port_buf[MAX_PROC_WRITE];
-	char		reg_buf[MAX_PROC_WRITE];
-	char		data_buf[MAX_PROC_WRITE];
+	char action;
+	char modifier;
+	char port_buf[MAX_PROC_WRITE];
+	char reg_buf[MAX_PROC_WRITE];
+	char data_buf[MAX_PROC_WRITE];

-	if(regcmd->bytes > sizeof(*regcmd) - 1) {	/* The size byte is not included */
-		PORT_NOTICE(xbus, unit, port, "%s: %s: Too long: regcmd->bytes = %d\n",
-			__FUNCTION__, msg, regcmd->bytes);
+	/* The size byte is not included */
+	if (regcmd->bytes > sizeof(*regcmd) - 1) {
+		PORT_NOTICE(xbus, unit, port,
+			    "%s: %s: Too long: regcmd->bytes = %d\n", __func__,
+			    msg, regcmd->bytes);
 		return;
 	}
-	if(regcmd->is_multibyte) {
-		char		buf[MAX_PROC_WRITE + 1];
-		int		i;
-		int		n = 0;
-		size_t		len = regcmd->bytes;
-		const byte	*p = REG_XDATA(regcmd);
+	if (regcmd->is_multibyte) {
+		char buf[MAX_PROC_WRITE + 1];
+		int i;
+		int n = 0;
+		size_t len = regcmd->bytes;
+		const __u8 *p = REG_XDATA(regcmd);

 		buf[0] = '\0';
-		for(i = 0; i < len && n < MAX_PROC_WRITE; i++)
-			n += snprintf(&buf[n], MAX_PROC_WRITE - n, "%02X ", p[i]);
+		for (i = 0; i < len && n < MAX_PROC_WRITE; i++)
+			n += snprintf(&buf[n], MAX_PROC_WRITE - n, "%02X ",
+				      p[i]);
 		PORT_DBG(REGS, xbus, unit, port,
-			"UNIT-%d PORT-%d: Multibyte(eoframe=%d) %s[0..%zd]: %s%s\n",
-			unit, port, regcmd->eoframe,
-			msg, len-1, buf, (n >= MAX_PROC_WRITE)?"...":"");
+			"UNIT-%d PORT-%d: Multibyte(eoframe=%d) "
+			"%s[0..%zd]: %s%s\n",
+			unit, port, regcmd->eoframe, msg, len - 1, buf,
+			(n >= MAX_PROC_WRITE) ? "..." : "");
 		return;
 	}
-	if(regcmd->bytes != sizeof(*regcmd) - 1) {	/* The size byte is not included */
-		PORT_NOTICE(xbus, unit, port, "%s: %s: Wrong size: regcmd->bytes = %d\n",
-			__FUNCTION__, msg, regcmd->bytes);
+	/* The size byte is not included */
+	if (regcmd->bytes != sizeof(*regcmd) - 1) {
+		PORT_NOTICE(xbus, unit, port,
+			    "%s: %s: Wrong size: regcmd->bytes = %d\n",
+			    __func__, msg, regcmd->bytes);
 		return;
 	}
-	snprintf(port_buf, MAX_PROC_WRITE, "%d%s",
-			regcmd->portnum,
-			(REG_FIELD(regcmd, all_ports_broadcast)) ? "*" : "");
+	snprintf(port_buf, MAX_PROC_WRITE, "%d%s", regcmd->portnum,
+		 (REG_FIELD(regcmd, all_ports_broadcast)) ? "*" : "");
 	action = (REG_FIELD(regcmd, read_request)) ? 'R' : 'W';
 	modifier = 'D';
-	if(REG_FIELD(regcmd, do_subreg)) {
-		snprintf(reg_buf, MAX_PROC_WRITE, "%02X %02X", 
-			REG_FIELD(regcmd, regnum),
-			REG_FIELD(regcmd, subreg));
+	if (REG_FIELD(regcmd, do_subreg)) {
+		snprintf(reg_buf, MAX_PROC_WRITE, "%02X %02X",
+			 REG_FIELD(regcmd, regnum), REG_FIELD(regcmd, subreg));
 		modifier = 'S';
 	} else {
-		snprintf(reg_buf, MAX_PROC_WRITE, "%02X", 
-			REG_FIELD(regcmd, regnum));
+		snprintf(reg_buf, MAX_PROC_WRITE, "%02X",
+			 REG_FIELD(regcmd, regnum));
 	}
-	if(REG_FIELD(regcmd, read_request)) {
+	if (REG_FIELD(regcmd, read_request)) {
 		data_buf[0] = '\0';
-	} else if(REG_FIELD(regcmd, do_datah)) {
-		snprintf(data_buf, MAX_PROC_WRITE, "%02X %02X", 
-			REG_FIELD(regcmd, data_low),
-			REG_FIELD(regcmd, data_high));
+	} else if (REG_FIELD(regcmd, do_datah)) {
+		snprintf(data_buf, MAX_PROC_WRITE, "%02X %02X",
+			 REG_FIELD(regcmd, data_low), REG_FIELD(regcmd,
+								data_high));
 		modifier = 'I';
 	} else {
-		snprintf(data_buf, MAX_PROC_WRITE, "%02X", 
-			REG_FIELD(regcmd, data_low));
+		snprintf(data_buf, MAX_PROC_WRITE, "%02X",
+			 REG_FIELD(regcmd, data_low));
 	}
-	PORT_DBG(REGS, xbus, unit, port, "%s: %s %c%c %s %s\n",
-			msg, port_buf, action, modifier,
-			reg_buf, data_buf);
+	PORT_DBG(REGS, xbus, unit, port, "%s: %s %c%c %s %s\n", msg, port_buf,
+		 action, modifier, reg_buf, data_buf);
 }
+EXPORT_SYMBOL(dump_reg_cmd);

 const char *xproto_name(xpd_type_t xpd_type)
 {
-	const xproto_table_t	*proto_table;
+	const xproto_table_t *proto_table;

 	BUG_ON(xpd_type >= XPD_TYPE_NOMODULE);
 	proto_table = xprotocol_tables[xpd_type];
-	if(!proto_table)
+	if (!proto_table)
 		return NULL;
 	return proto_table->name;
 }
+EXPORT_SYMBOL(xproto_name);

 #define	CHECK_XOP(xops, f)	\
-		if(!(xops)->f) { \
-			ERR("%s: missing xmethod %s [%s (%d)]\n", __FUNCTION__, #f, name, type);	\
+		if (!(xops)->f) { \
+			ERR("%s: missing xmethod %s [%s (%d)]\n", \
+				__func__, #f, name, type);	\
 			return -EINVAL;	\
 		}

 #define	CHECK_PHONEOP(phoneops, f)	\
-		if(!(phoneops)->f) { \
-			ERR("%s: missing phone method %s [%s (%d)]\n", __FUNCTION__, #f, name, type);	\
+		if (!(phoneops)->f) { \
+			ERR("%s: missing phone method %s [%s (%d)]\n", \
+				__func__, #f, name, type);	\
 			return -EINVAL;	\
 		}

 int xproto_register(const xproto_table_t *proto_table)
 {
-	int			type;
-	const char		*name;
-	const struct xops	*xops;
-	const struct phoneops	*phoneops;
-	
+	int type;
+	const char *name;
+	const struct xops *xops;
+	const struct phoneops *phoneops;
+
 	BUG_ON(!proto_table);
 	type = proto_table->type;
 	name = proto_table->name;
-	if(type >= XPD_TYPE_NOMODULE) {
-		NOTICE("%s: Bad xproto type %d\n", __FUNCTION__, type);
+	if (type >= XPD_TYPE_NOMODULE) {
+		NOTICE("%s: Bad xproto type %d\n", __func__, type);
 		return -EINVAL;
 	}
 	DBG(GENERAL, "%s (%d)\n", name, type);
-	if(xprotocol_tables[type])
-		NOTICE("%s: overriding registration of %s (%d)\n", __FUNCTION__, name, type);
+	if (xprotocol_tables[type])
+		NOTICE("%s: overriding registration of %s (%d)\n", __func__,
+		       name, type);
 	xops = proto_table->xops;
 	CHECK_XOP(xops, card_new);
 	CHECK_XOP(xops, card_init);
@@ -468,38 +500,30 @@ int xproto_register(const xproto_table_t *proto_table)
 		CHECK_PHONEOP(phoneops, card_dahdi_preregistration);
 		CHECK_PHONEOP(phoneops, card_dahdi_postregistration);
 		/* optional method -- call after testing: */
-		/*CHECK_PHONEOP(phoneops, card_ioctl);*/
+		/*CHECK_PHONEOP(phoneops, card_ioctl); */
 	}

 	xprotocol_tables[type] = proto_table;
 	return 0;
 }
+EXPORT_SYMBOL(xproto_register);

 void xproto_unregister(const xproto_table_t *proto_table)
 {
-	int		type;
-	const char	*name;
-	
+	int type;
+	const char *name;
+
 	BUG_ON(!proto_table);
 	type = proto_table->type;
 	name = proto_table->name;
 	DBG(GENERAL, "%s (%d)\n", name, type);
-	if(type >= XPD_TYPE_NOMODULE) {
-		NOTICE("%s: Bad xproto type %s (%d)\n", __FUNCTION__, name, type);
+	if (type >= XPD_TYPE_NOMODULE) {
+		NOTICE("%s: Bad xproto type %s (%d)\n", __func__, name, type);
 		return;
 	}
-	if(!xprotocol_tables[type])
-		NOTICE("%s: xproto type %s (%d) is already unregistered\n", __FUNCTION__, name, type);
+	if (!xprotocol_tables[type])
+		NOTICE("%s: xproto type %s (%d) is already unregistered\n",
+		       __func__, name, type);
 	xprotocol_tables[type] = NULL;
 }
-
-EXPORT_SYMBOL(dump_packet);
-EXPORT_SYMBOL(dump_reg_cmd);
-EXPORT_SYMBOL(xframe_receive);
-EXPORT_SYMBOL(notify_bad_xpd);
-EXPORT_SYMBOL(valid_xpd_addr);
-EXPORT_SYMBOL(xproto_global_entry);
-EXPORT_SYMBOL(xproto_card_entry);
-EXPORT_SYMBOL(xproto_name);
-EXPORT_SYMBOL(xproto_register);
 EXPORT_SYMBOL(xproto_unregister);
--- a/drivers/dahdi/xpp/xproto.h
+++ b/drivers/dahdi/xpp/xproto.h
@@ -35,25 +35,25 @@
 #define	XPP_PROTOCOL_VERSION	30

 struct xpd_addr {
-	uint8_t		subunit:SUBUNIT_BITS;
-	uint8_t		reserved:1;
-	uint8_t		unit:UNIT_BITS;
-	uint8_t		sync_master:1;
+	uint8_t subunit:SUBUNIT_BITS;
+	uint8_t reserved:1;
+	uint8_t unit:UNIT_BITS;
+	uint8_t sync_master:1;
 } PACKED;

 #define	MKADDR(p, u, s)	do {	\
 				(p)->unit = (u);	\
 				(p)->subunit = (s);	\
 				(p)->sync_master = 0;	\
-			} while(0)
+			} while (0)

 struct xpacket_header {
-	uint16_t	packet_len:10;
-	uint16_t	reserved:1;
-	uint16_t	is_pcm:1;
-	uint16_t	pcmslot:4;
-	uint8_t		opcode;
-	struct xpd_addr	addr;
+	uint16_t packet_len:10;
+	uint16_t reserved:1;
+	uint16_t is_pcm:1;
+	uint16_t pcmslot:4;
+	uint8_t opcode;
+	struct xpd_addr addr;
 } PACKED;

 #define	XPACKET_OP(p)		((p)->head.opcode)
@@ -71,8 +71,8 @@ struct xpacket_header {

 /*
 * The LSB of the type number signifies:
- * 	0 - TO_PSTN
- * 	1 - TO_PHONE
+ *	0 - TO_PSTN
+ *	1 - TO_PHONE
 */
 #define	XPD_TYPE_FXS		1	// TO_PHONE
 #define	XPD_TYPE_FXO		2	// TO_PSTN
@@ -81,60 +81,61 @@ struct xpacket_header {
 #define	XPD_TYPE_ECHO		5	// Octasic echo canceller
 #define	XPD_TYPE_NOMODULE	7

-typedef	byte	xpd_type_t;
+typedef __u8 xpd_type_t;

 #define	XPD_TYPE_PREFIX	"xpd-type-"

-#define	MODULE_ALIAS_XPD(type)	\
+#define	MODULE_ALIAS_XPD(type) \
 	MODULE_ALIAS(XPD_TYPE_PREFIX __stringify(type))

 #define	PCM_CHUNKSIZE	(CHANNELS_PERXPD * 8)	/* samples of 8 bytes */

 bool valid_xpd_addr(const struct xpd_addr *addr);

-#define	XPROTO_NAME(card,op)	card ## _ ## op
-#define	XPROTO_HANDLER(card,op)	XPROTO_NAME(card,op ## _handler)
-#define	XPROTO_CALLER(card,op)	XPROTO_NAME(card,op ## _send)
+#define	XPROTO_NAME(card, op)	card ## _ ## op
+#define	XPROTO_HANDLER(card, op)	XPROTO_NAME(card, op ## _handler)
+#define	XPROTO_CALLER(card, op)	XPROTO_NAME(card, op ## _send)

-#define	HANDLER_DEF(card,op)	\
-	static int XPROTO_HANDLER(card,op) (	\
+#define	HANDLER_DEF(card, op) \
+	static int XPROTO_HANDLER(card, op) (	\
 		xbus_t *xbus,			\
 		xpd_t *xpd,			\
 		const xproto_entry_t *cmd,	\
 		xpacket_t *pack)

-#define	CALL_PROTO(card,op, ...)	XPROTO_CALLER(card,op)( __VA_ARGS__ )
+#define	CALL_PROTO(card, op, ...)	XPROTO_CALLER(card, op)(__VA_ARGS__)

-#define	DECLARE_CMD(card,op, ...)	\
-	int CALL_PROTO(card, op, xbus_t *xbus, xpd_t *xpd, ## __VA_ARGS__ )
+#define	DECLARE_CMD(card, op, ...) \
+	int CALL_PROTO(card, op, xbus_t *xbus, xpd_t *xpd, ## __VA_ARGS__)

-#define	HOSTCMD(card, op, ...)					\
-		DECLARE_CMD(card, op, ## __VA_ARGS__ )
+#define	HOSTCMD(card, op, ...) \
+		DECLARE_CMD(card, op, ## __VA_ARGS__)

-#define	RPACKET_NAME(card,op)	XPROTO_NAME(RPACKET_ ## card, op)
-#define	RPACKET_TYPE(card,op)	struct RPACKET_NAME(card, op)
+#define	RPACKET_NAME(card, op)	XPROTO_NAME(RPACKET_ ## card, op)
+#define	RPACKET_TYPE(card, op)	struct RPACKET_NAME(card, op)

-#define	DEF_RPACKET_DATA(card,op, ...)		\
-	RPACKET_TYPE(card,op) {			\
+#define	DEF_RPACKET_DATA(card, op, ...) \
+	RPACKET_TYPE(card, op) {		\
 		struct xpacket_header	head;	\
 		__VA_ARGS__			\
 	} PACKED
 #define	RPACKET_HEADERSIZE		sizeof(struct xpacket_header)
-#define	RPACKET_FIELD(p,card,op,field)	(((RPACKET_TYPE(card,op) *)(p))->field)
-#define	RPACKET_SIZE(card,op)		sizeof(RPACKET_TYPE(card,op))
+#define	RPACKET_FIELD(p, card, op, field) \
+		(((RPACKET_TYPE(card, op) *)(p))->field)
+#define	RPACKET_SIZE(card, op)		sizeof(RPACKET_TYPE(card, op))

-#define	XENTRY(prototab,module,op)			\
-	[ XPROTO_NAME(module,op) ] = {			\
-		.handler = XPROTO_HANDLER(module,op),	\
-		.datalen = RPACKET_SIZE(module,op),	\
+#define	XENTRY(prototab, module, op) \
+	[ XPROTO_NAME(module, op) ] = {			\
+		.handler = XPROTO_HANDLER(module, op),	\
+		.datalen = RPACKET_SIZE(module, op),	\
 		.name = #op,				\
 		.table = &PROTO_TABLE(prototab)		\
 	}

-#define	XPACKET_INIT(p, card, op, to, pcm, pcmslot)		\
+#define	XPACKET_INIT(p, card, op, to, pcm, pcmslot) \
 		do {						\
-			XPACKET_OP(p) = XPROTO_NAME(card,op);	\
-			XPACKET_LEN(p) = RPACKET_SIZE(card,op);	\
+			XPACKET_OP(p) = XPROTO_NAME(card, op);	\
+			XPACKET_LEN(p) = RPACKET_SIZE(card, op);	\
 			XPACKET_IS_PCM(p) = (pcm);		\
 			XPACKET_PCMSLOT(p) = (pcmslot);		\
 			XPACKET_RESERVED(p) = 0;		\
@@ -142,138 +143,138 @@ bool valid_xpd_addr(const struct xpd_addr *addr);
 			XPACKET_ADDR_SUBUNIT(p) = XBUS_SUBUNIT(to);	\
 			XPACKET_ADDR_SYNC(p) = 0;		\
 			XPACKET_ADDR_RESERVED(p) = 0;		\
-		} while(0)
+		} while (0)

-#define	XFRAME_NEW_CMD(frm, p, xbus, card, op, to)		\
+#define	XFRAME_NEW_CMD(frm, p, xbus, card, op, to) \
 	do {							\
-		int		pack_len = RPACKET_SIZE(card,op);	\
+		int	pack_len = RPACKET_SIZE(card, op);	\
 								\
-		if(!XBUS_FLAGS(xbus, CONNECTED))		\
+		if (!XBUS_FLAGS(xbus, CONNECTED))		\
 			return -ENODEV;				\
 		(frm) = ALLOC_SEND_XFRAME(xbus);		\
-		if(!(frm))					\
+		if (!(frm))					\
 			return -ENOMEM;				\
 		(p) = xframe_next_packet(frm, pack_len);	\
-		if(!(p))					\
+		if (!(p))					\
 			return -ENOMEM;				\
 		XPACKET_INIT(p, card, op, to, 0, 0);		\
 		(frm)->usec_towait = 0;				\
-	} while(0)
+	} while (0)

 #endif

-/*--------------------------- register handling --------------------------------*/
+/*----------------- register handling --------------------------------*/

 #define	MULTIBYTE_MAX_LEN	5	/* FPGA firmware limitation */

 typedef struct reg_cmd {
-	byte		bytes:3;		/* Length (for Multibyte)	*/
-	byte		eoframe:1;		/* For BRI -- end of frame	*/
-	byte		portnum:3;		/* For port specific registers	*/
-	byte		is_multibyte:1;
+	__u8 bytes:3;		/* Length (for Multibyte)       */
+	__u8 eoframe:1;		/* For BRI -- end of frame      */
+	__u8 portnum:3;		/* For port specific registers  */
+	__u8 is_multibyte:1;
 	union {
 		struct {
-			byte		reserved:4;
-			byte		do_datah:1;
-			byte		do_subreg:1;
-			byte		read_request:1;
-			byte		all_ports_broadcast:1;
-			byte		regnum;
-			byte		subreg;
-			byte		data_low;
-			byte		data_high;
+			__u8 reserved:4;
+			__u8 do_datah:1;
+			__u8 do_subreg:1;
+			__u8 read_request:1;
+			__u8 all_ports_broadcast:1;
+			__u8 regnum;
+			__u8 subreg;
+			__u8 data_low;
+			__u8 data_high;
 		} PACKED r;
 		/* For Write-Multibyte commands in BRI */
 		struct {
-			byte	xdata[MULTIBYTE_MAX_LEN];
+			__u8 xdata[MULTIBYTE_MAX_LEN];
 		} PACKED d;
 	} PACKED alt;
 } PACKED reg_cmd_t;

 /* Shortcut access macros */
-#define	REG_FIELD(regptr,member)	((regptr)->alt.r.member)
+#define	REG_FIELD(regptr, member)	((regptr)->alt.r.member)
 #define	REG_XDATA(regptr)		((regptr)->alt.d.xdata)

 #ifdef __KERNEL__
-/*--------------------------- protocol tables ----------------------------------*/
+/*----------------- protocol tables ----------------------------------*/

-typedef struct xproto_entry	xproto_entry_t;
-typedef struct xproto_table	xproto_table_t;
+typedef struct xproto_entry xproto_entry_t;
+typedef struct xproto_table xproto_table_t;

-typedef int (*xproto_handler_t)(
-		xbus_t *xbus,
-		xpd_t *xpd,
-		const xproto_entry_t *cmd,
-		xpacket_t *pack);
+typedef int (*xproto_handler_t) (xbus_t *xbus, xpd_t *xpd,
+				 const xproto_entry_t *cmd, xpacket_t *pack);

 const xproto_table_t *xproto_get(xpd_type_t cardtype);
 void xproto_put(const xproto_table_t *xtable);
-const xproto_entry_t *xproto_card_entry(const xproto_table_t *table, byte opcode);
-xproto_handler_t xproto_card_handler(const xproto_table_t *table, byte opcode);
+const xproto_entry_t *xproto_card_entry(const xproto_table_t *table,
+					__u8 opcode);
+xproto_handler_t xproto_card_handler(const xproto_table_t *table,
+	__u8 opcode);

-const xproto_entry_t *xproto_global_entry(byte opcode);
-xproto_handler_t xproto_global_handler(byte opcode);
+const xproto_entry_t *xproto_global_entry(__u8 opcode);
+xproto_handler_t xproto_global_handler(__u8 opcode);

 /*
 * XMETHOD() resolve to method pointer (NULL for optional methods)
 * CALL_XMETHOD() calls the method, passing mandatory arguments
 */
 #define	XMETHOD(name, xpd)	((xpd)->xops->name)
-#define	CALL_XMETHOD(name, xpd, ...)                              \
-		(XMETHOD(name, (xpd))((xpd)->xbus, (xpd), ## __VA_ARGS__ ))
+#define	CALL_XMETHOD(name, xpd, ...) \
+		(XMETHOD(name, (xpd))((xpd)->xbus, (xpd), ## __VA_ARGS__))

 /*
 * PHONE_METHOD() resolve to method pointer (NULL for optional methods)
 * CALL_PHONE_METHOD() calls the method, passing mandatory arguments
 */
 #define	PHONE_METHOD(name, xpd)	(PHONEDEV(xpd).phoneops->name)
-#define	CALL_PHONE_METHOD(name, xpd, ...)                              \
-		(PHONE_METHOD(name, (xpd))((xpd), ## __VA_ARGS__ ))
+#define	CALL_PHONE_METHOD(name, xpd, ...) \
+		(PHONE_METHOD(name, (xpd))((xpd), ## __VA_ARGS__))

 struct phoneops {
-	void (*card_pcm_recompute)(xpd_t *xpd, xpp_line_t pcm_mask);
-	void (*card_pcm_fromspan)(xpd_t *xpd, xpacket_t *pack);
-	void (*card_pcm_tospan)(xpd_t *xpd, xpacket_t *pack);
-	int (*echocancel_timeslot)(xpd_t *xpd, int pos);
-	int (*echocancel_setmask)(xpd_t *xpd, xpp_line_t ec_mask);
-	int (*card_timing_priority)(xpd_t *xpd);
-	int (*card_dahdi_preregistration)(xpd_t *xpd, bool on);
-	int (*card_dahdi_postregistration)(xpd_t *xpd, bool on);
-	int (*card_hooksig)(xpd_t *xpd, int pos, enum dahdi_txsig txsig);
-	int (*card_ioctl)(xpd_t *xpd, int pos, unsigned int cmd, unsigned long arg);
-	int (*card_open)(xpd_t *xpd, lineno_t pos);
-	int (*card_close)(xpd_t *xpd, lineno_t pos);
-	int (*card_state)(xpd_t *xpd, bool on);
+	void (*card_pcm_recompute) (xpd_t *xpd, xpp_line_t pcm_mask);
+	void (*card_pcm_fromspan) (xpd_t *xpd, xpacket_t *pack);
+	void (*card_pcm_tospan) (xpd_t *xpd, xpacket_t *pack);
+	int (*echocancel_timeslot) (xpd_t *xpd, int pos);
+	int (*echocancel_setmask) (xpd_t *xpd, xpp_line_t ec_mask);
+	int (*card_timing_priority) (xpd_t *xpd);
+	int (*card_dahdi_preregistration) (xpd_t *xpd, bool on);
+	int (*card_dahdi_postregistration) (xpd_t *xpd, bool on);
+	int (*card_hooksig) (xpd_t *xpd, int pos, enum dahdi_txsig txsig);
+	int (*card_ioctl) (xpd_t *xpd, int pos, unsigned int cmd,
+			   unsigned long arg);
+	int (*card_open) (xpd_t *xpd, lineno_t pos);
+	int (*card_close) (xpd_t *xpd, lineno_t pos);
+	int (*card_state) (xpd_t *xpd, bool on);
 };

 struct xops {
-	 xpd_t *(*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);
-	int (*card_init)(xbus_t *xbus, xpd_t *xpd);
-	int (*card_remove)(xbus_t *xbus, xpd_t *xpd);
-	int (*card_tick)(xbus_t *xbus, xpd_t *xpd);
-	int (*card_register_reply)(xbus_t *xbus, xpd_t *xpd, reg_cmd_t *reg);
+	xpd_t *(*card_new) (xbus_t *xbus, int unit, int subunit,
+			    const xproto_table_t *proto_table, __u8 subtype,
+			    int subunits, int subunit_ports, bool to_phone);
+	int (*card_init) (xbus_t *xbus, xpd_t *xpd);
+	int (*card_remove) (xbus_t *xbus, xpd_t *xpd);
+	int (*card_tick) (xbus_t *xbus, xpd_t *xpd);
+	int (*card_register_reply) (xbus_t *xbus, xpd_t *xpd, reg_cmd_t *reg);
 };

 struct xproto_entry {
-	xproto_handler_t	handler;
-	int			datalen;
-	const char		*name;
-	xproto_table_t		*table;
+	xproto_handler_t handler;
+	int datalen;
+	const char *name;
+	xproto_table_t *table;
 };

 struct xproto_table {
-	struct module		*owner;
-	xproto_entry_t		entries[256];	/* Indexed by opcode */
-	const struct xops	*xops;		/* Card level operations */
-	const struct phoneops	*phoneops;	/* DAHDI operations */
-	const struct echoops	*echoops;	/* Echo Canceller operations */
-	xpd_type_t	type;
-	byte		ports_per_subunit;
-	const char	*name;
-	bool (*packet_is_valid)(xpacket_t *pack);
-	void (*packet_dump)(const char *msg, xpacket_t *pack);
+	struct module *owner;
+	xproto_entry_t entries[256];	/* Indexed by opcode */
+	const struct xops *xops;	/* Card level operations */
+	const struct phoneops *phoneops;	/* DAHDI operations */
+	const struct echoops *echoops;	/* Echo Canceller operations */
+	xpd_type_t type;
+	__u8 ports_per_subunit;
+	const char *name;
+	bool (*packet_is_valid) (xpacket_t *pack);
+	void (*packet_dump) (const char *msg, xpacket_t *pack);
 };

 #include "card_global.h"
@@ -282,11 +283,10 @@ struct xproto_table {
 #include "card_bri.h"
 #include "card_pri.h"

-
-#define	MEMBER(card,op)	RPACKET_TYPE(card,op)	RPACKET_NAME(card,op)
+#define	MEMBER(card, op)	RPACKET_TYPE(card, op)	RPACKET_NAME(card, op)

 struct xpacket {
-	struct xpacket_header	head;
+	struct xpacket_header head;
 	union {
 		MEMBER(GLOBAL, NULL_REPLY);
 		MEMBER(GLOBAL, PCM_WRITE);
@@ -297,20 +297,22 @@ struct xpacket {
 		MEMBER(FXS, SIG_CHANGED);
 		MEMBER(FXO, SIG_CHANGED);

-		byte	data[0];
+		__u8 data[0];
 	};
 	/* Last byte is chksum */
 } PACKED;

 void dump_packet(const char *msg, const xpacket_t *packet, bool debug);
-void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus, byte unit, xportno_t port, const reg_cmd_t *regcmd);
+void dump_reg_cmd(const char msg[], bool writing, xbus_t *xbus,
+	__u8 unit, xportno_t port, const reg_cmd_t *regcmd);
 int xframe_receive(xbus_t *xbus, xframe_t *xframe);
-void notify_bad_xpd(const char *funcname, xbus_t *xbus, const struct xpd_addr addr, const char *msg);
+void notify_bad_xpd(const char *funcname, xbus_t *xbus,
+		    const struct xpd_addr addr, const char *msg);
 int xproto_register(const xproto_table_t *proto_table);
 void xproto_unregister(const xproto_table_t *proto_table);
-const xproto_entry_t *xproto_global_entry(byte opcode);
+const xproto_entry_t *xproto_global_entry(__u8 opcode);
 const char *xproto_name(xpd_type_t xpd_type);

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

-#endif	/* XPROTO_H */
+#endif /* XPROTO_H */
--- a/include/dahdi/dahdi_config.h
+++ b/include/dahdi/dahdi_config.h
@@ -21,9 +21,6 @@

 #ifdef __KERNEL__
 #include <linux/version.h>
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
-#include <linux/config.h>
-#endif
 #endif

 /* DAHDI compile time options */
@@ -76,10 +73,8 @@
 /* You can still override them below */
 #if defined(CONFIG_HDLC) || defined(CONFIG_HDLC_MODULE)
 #define DAHDI_HDLC_TYPE_TRANS
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,3)
 #define HDLC_MAINTAINERS_ARE_MORE_STUPID_THAN_I_THOUGHT
 #endif
-#endif

 /*
 * Uncomment CONFIG_DAHDI_NET to enable SyncPPP, CiscoHDLC, and Frame Relay
@@ -195,4 +190,10 @@
 */
 /* #define CONFIG_DAHDI_MIRROR */

+/*
+ * Adds support for conference links. There are some non-Asterisk users of this
+ * functionality.
+ */
+/* #define CONFIG_DAHDI_CONFLINK */
+
 #endif
--- a/include/dahdi/kernel.h
+++ b/include/dahdi/kernel.h
@@ -6,7 +6,7 @@
 * written by Jim Dixon <jim@lambdatel.com>.
 *
 * Copyright (C) 2001 Jim Dixon / Zapata Telephony.
- * Copyright (C) 2001 - 2010 Digium, Inc.
+ * Copyright (C) 2001 - 2012 Digium, Inc.
 *
 * All rights reserved.
 *
@@ -38,11 +38,9 @@

 #include <dahdi/dahdi_config.h>
 #include <linux/version.h>
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
-#include <linux/config.h>
-#endif
 #include <linux/fs.h>
 #include <linux/device.h>
+#include <linux/cdev.h>
 #include <linux/module.h>
 #include <linux/ioctl.h>

@@ -60,11 +58,7 @@

 #include <linux/poll.h>

-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10)
 #define dahdi_pci_module pci_register_driver
-#else
-#define dahdi_pci_module pci_module_init
-#endif

 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
 #define DAHDI_IRQ_HANDLER(a) static irqreturn_t a(int irq, void *dev_id)
@@ -72,7 +66,7 @@
 #define DAHDI_IRQ_HANDLER(a) static irqreturn_t a(int irq, void *dev_id, struct pt_regs *regs)
 #endif

-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
 #ifdef CONFIG_PCI
 #include <linux/pci-aspm.h>
 #endif
@@ -82,22 +76,9 @@
 #define HAVE_NET_DEVICE_OPS
 #endif

-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
 #define DAHDI_IRQ_SHARED IRQF_SHARED
 #define DAHDI_IRQ_DISABLED IRQF_DISABLED
 #define DAHDI_IRQ_SHARED_DISABLED IRQF_SHARED | IRQF_DISABLED
-#else
-#define DAHDI_IRQ_SHARED SA_SHIRQ
-#define DAHDI_IRQ_DISABLED SA_INTERRUPT
-#define DAHDI_IRQ_SHARED_DISABLED SA_SHIRQ | SA_INTERRUPT
-#endif
-
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,16)
-#ifndef dev_notice
-#define dev_notice(dev, format, arg...)         \
-        dev_printk(KERN_NOTICE , dev , format , ## arg)
-#endif
-#endif

 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
 #  ifdef RHEL_RELEASE_VERSION
@@ -120,6 +101,14 @@
 #  endif
 #endif

+/* __dev* were removed in 3.8. They still have effect in 2.6.18. */
+#ifndef __devinit
+#  define __devinit
+#  define __devinitdata
+#  define __devexit
+#  define __devexit_p(x) x
+#endif
+
 /*! Default chunk size for conferences and such -- static right now, might make
   variable sometime.  8 samples = 1 ms = most frequent service interval possible
   for a USB device */
@@ -127,7 +116,7 @@
 #define DAHDI_MIN_CHUNKSIZE	 DAHDI_CHUNKSIZE
 #define DAHDI_DEFAULT_CHUNKSIZE	 DAHDI_CHUNKSIZE
 #define DAHDI_MAX_CHUNKSIZE 	 DAHDI_CHUNKSIZE
-#define DAHDI_CB_SIZE		 2
+#define DAHDI_CB_SIZE		 (1 << 3)

 /* DAHDI operates at 8Khz by default */
 #define DAHDI_MS_TO_SAMPLES(ms) ((ms) * 8)
@@ -511,10 +500,7 @@ struct dahdi_chan {
 	
 	int		numbufs;			/*!< How many buffers in channel */
 	int		txbufpolicy;			/*!< Buffer policy */
-	int		rxbufpolicy;			/*!< Buffer policy */
 	int		txdisable;				/*!< Disable transmitter */
-	int 	rxdisable;				/*!< Disable receiver */
-	
 	
 	/* Tone zone stuff */
 	struct dahdi_zone *curzone;		/*!< Zone for selecting tones */
@@ -559,7 +545,6 @@ struct dahdi_chan {

 	short	getlin[DAHDI_MAX_CHUNKSIZE];			/*!< Last transmitted samples */
 	unsigned char getraw[DAHDI_MAX_CHUNKSIZE];		/*!< Last received raw data */
-	short	getlin_lastchunk[DAHDI_MAX_CHUNKSIZE];	/*!< Last transmitted samples from last chunk */
 	short	putlin[DAHDI_MAX_CHUNKSIZE];			/*!< Last received samples */
 	unsigned char putraw[DAHDI_MAX_CHUNKSIZE];		/*!< Last received raw data */
 	short	conflast[DAHDI_MAX_CHUNKSIZE];			/*!< Last conference sample -- base part of channel */
@@ -629,6 +614,8 @@ struct dahdi_chan {
 #else
 	unsigned char *lin2x;
 #endif
+	struct device chan_device;	/*!< Kernel object for this chan */
+#define dev_to_chan(dev)    container_of(dev, struct dahdi_chan, chan_device)
 };

 #ifdef CONFIG_DAHDI_NET
@@ -762,15 +749,16 @@ static inline int dahdi_have_netdev(const struct dahdi_chan *chan) { return 0; }
 #endif

 struct dahdi_count {
-	__u32 fe;		/*!< Framing error counter */
-	__u32 cv;		/*!< Coding violations counter */
-	__u32 bpv;		/*!< Bipolar Violation counter */
-	__u32 crc4;		/*!< CRC4 error counter */
-	__u32 ebit;		/*!< current E-bit error count */
-	__u32 fas;		/*!< current FAS error count */
-	__u32 be;		/*!< current bit error count */
-	__u32 prbs;		/*!< current PRBS detected pattern */
-	__u32 errsec;		/*!< errored seconds */
+	u32 fe;			/*!< Framing error counter */
+	u32 cv;			/*!< Coding violations counter */
+	u32 bpv;		/*!< Bipolar Violation counter */
+	u32 crc4;		/*!< CRC4 error counter */
+	u32 ebit;		/*!< current E-bit error count */
+	u32 fas;		/*!< current FAS error count */
+	u32 be;			/*!< current bit error count */
+	u32 prbs;		/*!< current PRBS detected pattern */
+	u32 errsec;		/*!< errored seconds */
+	u32 timingslips;	/*!< Clock slips */
 };

 /* map flagbits to flag masks */
@@ -812,6 +800,23 @@ struct dahdi_count {
 #define DAHDI_FLAG_TXUNDERRUN	DAHDI_FLAG(TXUNDERRUN)
 #define DAHDI_FLAG_RXOVERRUN	DAHDI_FLAG(RXOVERRUN)

+enum spantypes {
+	SPANTYPE_INVALID	= 0,
+	SPANTYPE_ANALOG_FXS,
+	SPANTYPE_ANALOG_FXO,
+	SPANTYPE_ANALOG_MIXED,
+	SPANTYPE_DIGITAL_E1,
+	SPANTYPE_DIGITAL_T1,
+	SPANTYPE_DIGITAL_J1,
+	SPANTYPE_DIGITAL_BRI_NT,
+	SPANTYPE_DIGITAL_BRI_TE,
+	SPANTYPE_DIGITAL_BRI_SOFT,
+};
+const char *dahdi_spantype2str(enum spantypes st);
+enum spantypes dahdi_str2spantype(const char *name);
+const char *dahdi_lineconfig_bit_name(int lineconfig_bit);
+ssize_t lineconfig_str(int lineconfig, char buf[], size_t size);
+
 struct file;

 struct dahdi_span_ops {
@@ -910,7 +915,7 @@ struct dahdi_span_ops {

 	/*! Called when the spantype / linemode is changed before the span is
 	 * assigned a number. */
-	int (*set_spantype)(struct dahdi_span *span, const char *spantype);
+	int (*set_spantype)(struct dahdi_span *span, enum spantypes st);
 };

 /**
@@ -941,7 +946,7 @@ struct dahdi_span {
 	spinlock_t lock;
 	char name[40];			/*!< Span name */
 	char desc[80];			/*!< Span description */
-	const char *spantype;		/*!< span type in text form */
+	enum spantypes spantype;	/*!< span type */
 	int deflaw;			/*!< Default law (DAHDI_MULAW or DAHDI_ALAW) */
 	int alarms;			/*!< Pending alarms on span */
 	unsigned long flags;
@@ -959,8 +964,6 @@ struct dahdi_span {
 	int maintstat;			/*!< Maintenance state */
 	int mainttimer;			/*!< Maintenance timer */

-	int timingslips;		/*!< Clock slips */
-
 	struct dahdi_chan **chans;	/*!< Member channel structures */

 	const struct dahdi_span_ops *ops;	/*!< span callbacks. */
@@ -1234,6 +1237,12 @@ void dahdi_init_tone_state(struct dahdi_tone_state *ts, struct dahdi_tone *zt);
 /*! \brief Get a given MF tone struct, suitable for dahdi_tone_nextsample. */
 struct dahdi_tone *dahdi_mf_tone(const struct dahdi_chan *chan, char digit, int digitmode);

+/*! \brief Convert signalling bits to human readable string */
+const char *sigstr(int sig);
+
+/*! \brief Convert alarm bits to human readable string */
+int fill_alarm_string(char *buf, int count, int alarms);
+
 /* Echo cancel a receive and transmit chunk for a given channel.  This
   should be called by the low-level driver as close to the interface
   as possible.  ECHO CANCELLATION IS NO LONGER AUTOMATICALLY DONE
@@ -1392,9 +1401,45 @@ static inline short dahdi_txtone_nextsample(struct dahdi_chan *ss)
 /*! Maximum audio mask */
 #define DAHDI_FORMAT_AUDIO_MASK	((1 << 16) - 1)

+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 10, 0)
+#ifdef RHEL_RELEASE_VERSION
+#if RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(6, 5)
+#ifdef CONFIG_PROC_FS
+#include <linux/proc_fs.h>
+static inline void *PDE_DATA(const struct inode *inode)
+{
+	return PDE(inode)->data;
+}
+#endif
+#endif
+#else
+#ifdef CONFIG_PROC_FS
+#include <linux/proc_fs.h>
+static inline void *PDE_DATA(const struct inode *inode)
+{
+	return PDE(inode)->data;
+}
+#endif
+#endif
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 31)
 #define KERN_CONT ""
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
+#ifdef CONFIG_PROC_FS
+#include <linux/proc_fs.h>
+static inline struct proc_dir_entry *proc_create_data(const char *name,
+					mode_t mode,
+					struct proc_dir_entry *parent,
+					const struct file_operations *proc_fops,
+					void *data)
+{
+	struct proc_dir_entry *pde = create_proc_entry(name, mode, parent);
+	if (!pde)
+		return NULL;
+	pde->proc_fops = proc_fops;
+	pde->data = data;
+	return pde;
+}
+#endif /* CONFIG_PROC_FS */
 #ifndef clamp
 #define clamp(x, low, high) min(max(low, x), high)
 #endif
@@ -1442,14 +1487,12 @@ static inline int strcasecmp(const char *s1, const char *s2)
 	return c1 - c2;
 }
 #endif /* clamp_val */
+
 #endif /* 2.6.22 */
 #endif /* 2.6.25 */
 #endif /* 2.6.26 */
 #endif /* 2.6.31 */
-
-#ifndef CONFIG_TRACING
-#define trace_printk printk
-#endif
+#endif /* 3.10.0 */

 #ifndef DEFINE_SPINLOCK
 #define DEFINE_SPINLOCK(x)      spinlock_t x = SPIN_LOCK_UNLOCKED
@@ -1495,6 +1538,10 @@ struct mutex {
 #define	DAHDI_PSEUDO	255

 /* prink-wrapper macros */
+
+#define module_printk(level, fmt, args...) \
+		printk(level "%s: " fmt, THIS_MODULE->name, ## args)
+
 #define	DAHDI_PRINTK(level, category, fmt, ...)	\
 	printk(KERN_ ## level "%s%s-%s: " fmt, #level, category, \
 			THIS_MODULE->name, ## __VA_ARGS__)
@@ -1502,7 +1549,7 @@ struct mutex {
 	printk(KERN_ ## level "%s%s-%s: span-%d: " fmt, #level,	\
 		category, THIS_MODULE->name, (span)->spanno, ## __VA_ARGS__)
 #define	chan_printk(level, category, chan, fmt, ...)	\
-	printk(KERN_ ## level "%s%s-%s: %d: " fmt, #level,	\
+	printk(KERN_ ## level "%s%s-%s: chan-%d: " fmt, #level,	\
 		category, THIS_MODULE->name, (chan)->channo, ## __VA_ARGS__)
 #define	dahdi_err(fmt, ...)	DAHDI_PRINTK(ERR, "", fmt, ## __VA_ARGS__)
 #define	span_info(span, fmt, ...)	span_printk(INFO, "", span, fmt, \
--- a/include/dahdi/user.h
+++ b/include/dahdi/user.h
@@ -636,6 +636,11 @@ struct dahdi_confinfo {
 #define DAHDI_SETCONF_V1		_IOW(DAHDI_CODE,  12, struct dahdi_confinfo)
 #define DAHDI_SETCONF			_IOWR(DAHDI_CODE, 13, struct dahdi_confinfo)

+/*
+ * Setup or Remove Conference Link
+ */
+#define DAHDI_CONFLINK			_IOW(DAHDI_CODE, 14, struct dahdi_confinfo)
+
 /*
 * Display Conference Diagnostic Information on Console
 */