Importing files for 2.6.1 release.

git-svn-id: http://svn.asterisk.org/svn/dahdi/linux/tags/2.6.1@10664 a0bf4364-ded3-4de4-8d8a-66a801d63aff

.version

@@ -0,0 +1 @@
+2.6.1

ChangeLog

@@ -0,0 +1,555 @@
+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.
+

README

@@ -212,13 +212,10 @@ under driver/staging/echo . In fact, dahdi_echocan_oslec assumes that
 this is where the oslec code lies. If it is elsewhere you'll need to fix
 the #include line.
 
-Thus for the moment, the simplest way to build OSLEC with dahdi is:
-
-1. Copy the directory `drivers/staging/echo` from a recent kernel tree 
-   (at least 2.6.28-rc1) to the a subdirectory with the same name in the
-   dahdi-linux tree.
-
-2. Edit drivers/dahdi/Kbuild and uncomment the two lines related to OSLEC.
+Thus for the moment, the simplest way to build OSLEC with dahdi is to
+copy the directory `drivers/staging/echo` from a recent kernel tree (at
+least 2.6.28-rc1) to the a subdirectory with the same name in the
+dahdi-linux tree.
 
 After doing that, you'll see the following when building (running
 'make')

drivers/dahdi/Kbuild

@@ -6,6 +6,7 @@ obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_DYNAMIC_ETH)	+= dahdi_dynamic_eth.o
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_DYNAMIC_ETHMF)	+= dahdi_dynamic_ethmf.o
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_TRANSCODE)		+= dahdi_transcode.o
 
+ifdef CONFIG_PCI
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCT4XXP)		+= wct4xxp/
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCTC4XXP)		+= wctc4xxp/
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCTDM24XXP)	+= wctdm24xxp/
@@ -20,6 +21,7 @@ obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCTE11XP)		+= wcte11xp.o
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_WCFXO)		+= wcfxo.o
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_TOR2)		+= tor2.o
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_PCIRADIO)		+= pciradio.o
+endif
 
 obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_XPP)		+= xpp/
 
@@ -31,14 +33,13 @@ obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_ECHOCAN_MG2)	+= dahdi_echocan_mg2.o
 
 obj-m += $(DAHDI_MODULES_EXTRA)
 
-# Only enable this if you think you know what you're doing. This is not
-# supported yet:
-#obj-m += dahdi_echocan_oslec.o
-#
-# A quick and dirty way to build OSLEC, if you happened to place it
-# yourself in the dahdi source tree. This is experimental. See README
-# regarding OSLEC.
-#obj-m += ../staging/echo/
+# If you want to build OSLEC, include the code in the standard location:
+# drivers/staging/echo . The DAHDI OSLEC echo canceller will be built as
+# well:
+ifneq (,$(wildcard $(src)/../staging/echo/echo.c))
+obj-m += dahdi_echocan_oslec.o
+obj-m += ../staging/echo/
+endif
 
 CFLAGS_MODULE += -I$(DAHDI_INCLUDE) -I$(src)
 

drivers/dahdi/dahdi-base.c

@@ -122,7 +122,6 @@ EXPORT_SYMBOL(dahdi_qevent_nolock);
 EXPORT_SYMBOL(dahdi_qevent_lock);
 EXPORT_SYMBOL(dahdi_hooksig);
 EXPORT_SYMBOL(dahdi_alarm_notify);
-EXPORT_SYMBOL(dahdi_set_dynamic_ioctl);
 EXPORT_SYMBOL(dahdi_hdlc_abort);
 EXPORT_SYMBOL(dahdi_hdlc_finish);
 EXPORT_SYMBOL(dahdi_hdlc_getbuf);
@@ -358,6 +357,11 @@ static DEFINE_SPINLOCK(zone_lock);
 /* The first zone on the list is the default zone. */
 static LIST_HEAD(tone_zones);
 
+static inline struct device *span_device(struct dahdi_span *span)
+{
+	return &span->parent->dev;
+}
+
 /* Protects the span_list and pseudo_chans lists from concurrent access in
  * process context.  The spin_lock is needed to synchronize with the interrupt
  * handler. */
@@ -2150,6 +2154,8 @@ static unsigned long _chan_cleanup(struct dahdi_chan *pos, unsigned long data)
 	return 0;
 }
 
+static const struct file_operations nodev_fops;
+
 static void dahdi_chan_unreg(struct dahdi_chan *chan)
 {
 	unsigned long flags;
@@ -2164,6 +2170,11 @@ static void dahdi_chan_unreg(struct dahdi_chan *chan)
 			"%s: surprise removal: chan %d\n",
 			__func__, chan->channo);
 		chan->file->private_data = NULL;
+		chan->file->f_op = &nodev_fops;
+		/*
+		 * From now on, any file_operations for this device
+		 * would call the nodev_fops methods.
+		 */
 	}
 
 	spin_lock_irqsave(&chan->lock, flags);
@@ -2240,14 +2251,12 @@ static ssize_t dahdi_chan_read(struct file *file, char __user *usrbuf,
 	count &= 0xffff;
 
 	if (unlikely(!chan)) {
-		/* We would typically be here because of surprise hardware
-		 * removal or driver unbinding while a user space application
-		 * has a channel open.  Most telephony applications are run at
-		 * elevated priorities so this sleep can prevent the high
-		 * priority threads from consuming the CPU if they're not
-		 * expecting surprise device removal.
+		/*
+		 * This should never happen. Surprise device removal
+		 * should lead us to the nodev_* file_operations
 		 */
 		msleep(5);
+		module_printk(KERN_ERR, "%s: NODEV\n", __func__);
 		return -ENODEV;
 	}
 
@@ -2363,14 +2372,12 @@ static ssize_t dahdi_chan_write(struct file *file, const char __user *usrbuf,
 	count &= 0xffff;
 
 	if (unlikely(!chan)) {
-		/* We would typically be here because of surprise hardware
-		 * removal or driver unbinding while a user space application
-		 * has a channel open.  Most telephony applications are run at
-		 * elevated priorities so this sleep can prevent the high
-		 * priority threads from consuming the CPU if they're not
-		 * expecting surprise device removal.
+		/*
+		 * This should never happen. Surprise device removal
+		 * should lead us to the nodev_* file_operations
 		 */
 		msleep(5);
+		module_printk(KERN_ERR, "%s: NODEV\n", __func__);
 		return -ENODEV;
 	}
 
@@ -2456,12 +2463,11 @@ static ssize_t dahdi_chan_write(struct file *file, const char __user *usrbuf,
 		if ((chan->ec_state) &&
 		    (ECHO_MODE_ACTIVE == chan->ec_state->status.mode) &&
 		    (chan->ec_state->ops->echocan_process_tx)) {
-			struct ec_state *const ec_state = chan->ec_state;
+			struct dahdi_echocan_state *const ec = chan->ec_state;
 			for (x = 0; x < chan->writen[res]; ++x) {
 				short tx;
 				tx = DAHDI_XLAW(chan->writebuf[res][x], chan);
-				ec_state->ops->echocan_process_tx(ec_state,
-								  &tx, 1);
+				ec->ops->echocan_process_tx(ec, &tx, 1);
 				chan->writebuf[res][x] = DAHDI_LIN2X((int) tx,
 								     chan);
 			}
@@ -4414,12 +4420,14 @@ static int dahdi_common_ioctl(struct file *file, unsigned int cmd,
 	return 0;
 }
 
-static int (*dahdi_dynamic_ioctl)(unsigned int cmd, unsigned long data);
-
-void dahdi_set_dynamic_ioctl(int (*func)(unsigned int cmd, unsigned long data))
+static const struct dahdi_dynamic_ops *dahdi_dynamic_ops;
+void dahdi_set_dynamic_ops(const struct dahdi_dynamic_ops *ops)
 {
-	dahdi_dynamic_ioctl = func;
+	mutex_lock(&registration_mutex);
+	dahdi_dynamic_ops = ops;
+	mutex_unlock(&registration_mutex);
 }
+EXPORT_SYMBOL(dahdi_set_dynamic_ops);
 
 static int (*dahdi_hpec_ioctl)(unsigned int cmd, unsigned long data);
 
@@ -4640,7 +4648,6 @@ static int dahdi_ioctl_chanconfig(struct file *file, unsigned long data)
 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 23)
 				SET_MODULE_OWNER(chan->hdlcnetdev->netdev);
 #endif
-				chan->hdlcnetdev->netdev->irq = chan->span->irq;
 				chan->hdlcnetdev->netdev->tx_queue_len = 50;
 #ifdef HAVE_NET_DEVICE_OPS
 				chan->hdlcnetdev->netdev->netdev_ops = &dahdi_netdev_ops;
@@ -4877,7 +4884,7 @@ static int dahdi_ioctl_startup(struct file *file, unsigned long data)
 		__dahdi_find_master_span();
 	}
 	put_span(s);
-	return 0;
+	return res;
 }
 
 static int dahdi_ioctl_shutdown(unsigned long data)
@@ -5138,6 +5145,33 @@ static int dahdi_ioctl_maint(unsigned long data)
 	return 0;
 }
 
+static int dahdi_ioctl_dynamic(unsigned int cmd, unsigned long data)
+{
+	bool tried_load = false;
+	int res;
+
+retry_check:
+	mutex_lock(&registration_mutex);
+	if (!dahdi_dynamic_ops) {
+		mutex_unlock(&registration_mutex);
+		if (tried_load)
+			return -ENOSYS;
+
+		request_module("dahdi_dynamic");
+		tried_load = true;
+		goto retry_check;
+	}
+	if (!try_module_get(dahdi_dynamic_ops->owner)) {
+		mutex_unlock(&registration_mutex);
+		return -ENOSYS;
+	}
+	mutex_unlock(&registration_mutex);
+
+	res = dahdi_dynamic_ops->ioctl(cmd, data);
+	module_put(dahdi_dynamic_ops->owner);
+	return res;
+}
+
 static int
 dahdi_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long data)
 {
@@ -5172,14 +5206,7 @@ dahdi_ctl_ioctl(struct file *file, unsigned int cmd, unsigned long data)
 		return dahdi_ioctl_maint(data);
 	case DAHDI_DYNAMIC_CREATE:
 	case DAHDI_DYNAMIC_DESTROY:
-		if (dahdi_dynamic_ioctl) {
-			return dahdi_dynamic_ioctl(cmd, data);
-		} else {
-			request_module("dahdi_dynamic");
-			if (dahdi_dynamic_ioctl)
-				return dahdi_dynamic_ioctl(cmd, data);
-		}
-		return -ENOSYS;
+		return dahdi_ioctl_dynamic(cmd, data);
 	case DAHDI_EC_LICENSE_CHALLENGE:
 	case DAHDI_EC_LICENSE_RESPONSE:
 		if (dahdi_hpec_ioctl) {
@@ -5500,13 +5527,12 @@ static int dahdi_ioctl_iomux(struct file *file, unsigned long data)
 		wait_result = 0;
 		prepare_to_wait(&chan->waitq, &wait, TASK_INTERRUPTIBLE);
 		if (unlikely(!chan->file->private_data)) {
-			static int rate_limit;
-
-			if ((rate_limit++ % 1000) == 0)
-				module_printk(KERN_NOTICE,
-					"%s: (%d) nodev\n",
-					__func__, rate_limit);
+			/*
+			 * This should never happen. Surprise device removal
+			 * should lead us to the nodev_* file_operations
+			 */
 			msleep(5);
+			module_printk(KERN_ERR, "%s: NODEV\n", __func__);
 			ret = -ENODEV;
 			break;
 		}
@@ -6647,6 +6673,9 @@ static void
 set_spanno_and_basechan(struct dahdi_span *span, u32 spanno, u32 basechan)
 {
 	int i;
+	dahdi_dev_dbg(ASSIGN, span_device(span),
+		"set: spanno=%d, basechan=%d (span->channels=%d)\n",
+		spanno, basechan, span->channels);
 	span->spanno = spanno;
 	for (i = 0; i < span->channels; ++i)
 		span->chans[i]->channo = basechan + i;
@@ -6668,6 +6697,8 @@ static int _assign_spanno_and_basechan(struct dahdi_span *span)
 	unsigned int spanno = 1;
 	unsigned int basechan = 1;
 
+	dahdi_dev_dbg(ASSIGN, span_device(span),
+		"assign: channels=%d\n", span->channels);
 	list_for_each_entry(pos, &span_list, spans_node) {
 
 		if (pos->spanno <= spanno) {
@@ -6686,6 +6717,9 @@ static int _assign_spanno_and_basechan(struct dahdi_span *span)
 			basechan = pos->chans[0]->channo + pos->channels;
 	}
 
+	dahdi_dev_dbg(ASSIGN, span_device(span),
+		"good: spanno=%d, basechan=%d (span->channels=%d)\n",
+		spanno, basechan, span->channels);
 	set_spanno_and_basechan(span, spanno, basechan);
 	return 0;
 }
@@ -6733,14 +6767,20 @@ _check_spanno_and_basechan(struct dahdi_span *span, u32 spanno, u32 basechan)
 	struct dahdi_span *pos;
 	unsigned int next_channo;
 
+	dahdi_dev_dbg(ASSIGN, span_device(span),
+		"check: spanno=%d, basechan=%d (span->channels=%d)\n",
+		spanno, basechan, span->channels);
 	list_for_each_entry(pos, &span_list, spans_node) {
 
 		next_channo = _get_next_channo(pos);
+		dahdi_dev_dbg(ASSIGN, span_device(span),
+			"pos: spanno=%d channels=%d (next_channo=%d)\n",
+			pos->spanno, pos->channels, next_channo);
 
 		if (pos->spanno <= spanno) {
 			if (basechan < next_channo + pos->channels) {
 				/* Requested basechan breaks channel sorting */
-				dev_info(span->parent->dev.parent,
+				dev_notice(span_device(span),
 					"[%d] basechan (%d) is too low for wanted span %d\n",
 					local_spanno(span), basechan, spanno);
 				return -EINVAL;
@@ -6751,13 +6791,19 @@ _check_spanno_and_basechan(struct dahdi_span *span, u32 spanno, u32 basechan)
 		if (next_channo == -1)
 			break;
 
-		if ((basechan + span->channels) < next_channo)
+		if ((basechan + span->channels) <= next_channo)
 			break;
 
 		/* Cannot fit the span into the requested location. Abort. */
+		dev_notice(span_device(span),
+			"cannot fit span %d (basechan=%d) into requested location\n",
+			spanno, basechan);
 		return -EINVAL;
 	}
 
+	dahdi_dev_dbg(ASSIGN, span_device(span),
+		"good: spanno=%d, basechan=%d (span->channels=%d)\n",
+		spanno, basechan, span->channels);
 	set_spanno_and_basechan(span, spanno, basechan);
 	return 0;
 }
@@ -6851,10 +6897,10 @@ static int _dahdi_assign_span(struct dahdi_span *span, unsigned int spanno,
 	unsigned int x;
 
 	if (!span || !span->ops || !span->ops->owner)
-		return -EINVAL;
+		return -EFAULT;
 
 	if (test_bit(DAHDI_FLAGBIT_REGISTERED, &span->flags)) {
-		dev_info(span->parent->dev.parent,
+		dev_notice(span_device(span),
 			 "local span %d is already assigned span %d "
 			 "with base channel %d\n", local_spanno(span), span->spanno,
 			 span->chans[0]->channo);
@@ -6864,8 +6910,11 @@ static int _dahdi_assign_span(struct dahdi_span *span, unsigned int spanno,
 	if (span->ops->enable_hw_preechocan ||
 	    span->ops->disable_hw_preechocan) {
 		if ((NULL == span->ops->enable_hw_preechocan) ||
-		    (NULL == span->ops->disable_hw_preechocan))
-			return -EINVAL;
+		    (NULL == span->ops->disable_hw_preechocan)) {
+			dev_notice(span_device(span),
+				"span with inconsistent enable/disable hw_preechocan");
+			return -EFAULT;
+		}
 	}
 
 	if (!span->deflaw) {
@@ -7002,6 +7051,9 @@ static int _dahdi_register_device(struct dahdi_device *ddev,
 	list_for_each_entry(s, &ddev->spans, device_node)
 		ret = _dahdi_assign_span(s, 0, 0, 1);
 
+	if (ret)
+		dahdi_sysfs_unregister_device(ddev);
+
 	return ret;
 }
 
@@ -7063,7 +7115,7 @@ static int _dahdi_unassign_span(struct dahdi_span *span)
 	unsigned long flags;
 
 	if (!test_bit(DAHDI_FLAGBIT_REGISTERED, &span->flags)) {
-		dev_info(span->parent->dev.parent,
+		dev_info(span_device(span),
 			"local span %d is already unassigned\n",
 			local_spanno(span));
 		return -EINVAL;
@@ -9145,12 +9197,12 @@ static unsigned int dahdi_timer_poll(struct file *file, struct poll_table_struct
 			ret |= POLLPRI;
 		spin_unlock_irqrestore(&dahdi_timer_lock, flags);
 	} else {
-		static int rate_limit;
-
-		if ((rate_limit++ % 1000) == 0)
-			module_printk(KERN_NOTICE, "%s: (%d) nodev\n",
-				__func__, rate_limit);
+		/*
+		 * This should never happen. Surprise device removal
+		 * should lead us to the nodev_* file_operations
+		 */
 		msleep(5);
+		module_printk(KERN_ERR, "%s: NODEV\n", __func__);
 		return POLLERR | POLLHUP | POLLRDHUP | POLLNVAL | POLLPRI;
 	}
 	return ret;
@@ -9165,12 +9217,12 @@ dahdi_chan_poll(struct file *file, struct poll_table_struct *wait_table)
 	unsigned long flags;
 
 	if (unlikely(!c)) {
-		static int rate_limit;
-
-		if ((rate_limit++ % 1000) == 0)
-			module_printk(KERN_NOTICE, "%s: (%d) nodev\n",
-				__func__, rate_limit);
-		msleep(20);
+		/*
+		 * This should never happen. Surprise device removal
+		 * should lead us to the nodev_* file_operations
+		 */
+		msleep(5);
+		module_printk(KERN_ERR, "%s: NODEV\n", __func__);
 		return POLLERR | POLLHUP | POLLRDHUP | POLLNVAL | POLLPRI;
 	}
 
@@ -9807,6 +9859,97 @@ static const struct file_operations dahdi_fops = {
 	.poll    = dahdi_poll,
 };
 
+/*
+ * DAHDI stability should not depend on the calling process behaviour.
+ * In case of suprise device removal, we should be able to return
+ * sane results (-ENODEV) even after the underlying device was released.
+ *
+ * This should be OK even if the calling process (hint, hint Asterisk)
+ * ignores the system calls return value.
+ *
+ * We simply use dummy file_operations to implement this.
+ */
+
+/*
+ * Common behaviour called from all other nodev_*() file_operations
+ */
+static int nodev_common(const char msg[])
+{
+	if (printk_ratelimit()) {
+		module_printk(KERN_NOTICE,
+			"nodev: %s: process %d still calling\n",
+			msg, current->tgid);
+	}
+	msleep(5);
+	return -ENODEV;
+}
+
+static ssize_t nodev_chan_read(struct file *file, char __user *usrbuf,
+			       size_t count, loff_t *ppos)
+{
+	return nodev_common("read");
+}
+
+static ssize_t nodev_chan_write(struct file *file, const char __user *usrbuf,
+				size_t count, loff_t *ppos)
+{
+	return nodev_common("write");
+}
+
+static unsigned int
+nodev_chan_poll(struct file *file, struct poll_table_struct *wait_table)
+{
+	return nodev_common("poll");
+}
+
+static long
+nodev_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long data)
+{
+	switch (cmd) {
+	case DAHDI_GETEVENT:  /* Get event on queue */
+		/*
+		 * Hint the bugger that the channel is gone for good
+		 */
+		put_user(DAHDI_EVENT_REMOVED, (int __user *)data);
+		break;
+	}
+	return nodev_common("ioctl");
+}
+
+#ifndef HAVE_UNLOCKED_IOCTL
+static int nodev_ioctl(struct inode *inode, struct file *file,
+		unsigned int cmd, unsigned long data)
+{
+	return nodev_unlocked_ioctl(file, cmd, data);
+}
+#endif
+
+#ifdef HAVE_COMPAT_IOCTL
+static long nodev_ioctl_compat(struct file *file, unsigned int cmd,
+		unsigned long data)
+{
+	if (cmd == DAHDI_SFCONFIG)
+		return -ENOTTY; /* Not supported yet */
+
+	return nodev_unlocked_ioctl(file, cmd, data);
+}
+#endif
+
+static const struct file_operations nodev_fops = {
+	.owner   = THIS_MODULE,
+#ifdef HAVE_UNLOCKED_IOCTL
+	.unlocked_ioctl  = nodev_unlocked_ioctl,
+#ifdef HAVE_COMPAT_IOCTL
+	.compat_ioctl = nodev_ioctl_compat,
+#endif
+#else
+	.ioctl   = nodev_ioctl,
+#endif
+	.read    = nodev_chan_read,
+	.write   = nodev_chan_write,
+	.poll    = nodev_chan_poll,
+};
+
 static const struct file_operations dahdi_chan_fops = {
 	.owner   = THIS_MODULE,
 	.open    = dahdi_open,
@@ -9833,7 +9976,7 @@ static void watchdog_check(unsigned long ignored)
 	static int wdcheck=0;
 	struct dahdi_span *s;
 
-	spin_lock_irqsave(&span_list_lock, flags);
+	spin_lock_irqsave(&chan_lock, flags);
 	list_for_each_entry(s, &span_list, spans_node) {
 		if (s->flags & DAHDI_FLAG_RUNNING) {
 			if (s->watchcounter == DAHDI_WATCHDOG_INIT) {
@@ -9841,9 +9984,9 @@ static void watchdog_check(unsigned long ignored)
 				if ((s->watchstate == DAHDI_WATCHSTATE_OK) ||
 					(s->watchstate == DAHDI_WATCHSTATE_UNKNOWN)) {
 					s->watchstate = DAHDI_WATCHSTATE_RECOVERING;
-					if (s->watchdog) {
+					if (s->ops->watchdog) {
 						module_printk(KERN_NOTICE, "Kicking span %s\n", s->name);
-						s->watchdog(spans[x], DAHDI_WATCHDOG_NOINTS);
+						s->ops->watchdog(s, DAHDI_WATCHDOG_NOINTS);
 					} else {
 						module_printk(KERN_NOTICE, "Span %s is dead with no revival\n", s->name);
 						s->watchstate = DAHDI_WATCHSTATE_FAILED;
@@ -9858,7 +10001,7 @@ static void watchdog_check(unsigned long ignored)
 			s->watchcounter = DAHDI_WATCHDOG_INIT;
 		}
 	}
-	spin_unlock_irqrestore(&span_list_lock, flags);
+	spin_unlock_irqrestore(&chan_lock, flags);
 	if (!wdcheck) {
 		module_printk(KERN_NOTICE, "watchdog on duty!\n");
 		wdcheck=1;
@@ -9926,6 +10069,24 @@ failed_driver_init:
 	return res;
 }
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
+#ifdef CONFIG_PCI
+void dahdi_pci_disable_link_state(struct pci_dev *pdev, int state)
+{
+	u16 reg16;
+	int pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
+	state &= (PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1 |
+		  PCIE_LINK_STATE_CLKPM);
+	if (!pos)
+		return;
+	pci_read_config_word(pdev, pos + PCI_EXP_LNKCTL, &reg16);
+	reg16 &= ~(state);
+	pci_write_config_word(pdev, pos + PCI_EXP_LNKCTL, reg16);
+}
+EXPORT_SYMBOL(dahdi_pci_disable_link_state);
+#endif /* CONFIG_PCI */
+#endif /* 2.6.25 */
+
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
 static inline void flush_find_master_work(void)
 {

drivers/dahdi/dahdi-sysfs.c

@@ -152,12 +152,6 @@ static int span_hotplug(struct device *dev, char **envp, int envnum,
 			return err;				\
 	} while (0)
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
-#define dev_name(dev)		((dev)->bus_id)
-#define dev_set_name(dev, format, ...) \
-	snprintf((dev)->bus_id, BUS_ID_SIZE, format, ## __VA_ARGS__);
-#endif
-
 static int span_uevent(struct device *dev, char **envp, int num_envp,
 		char *buffer, int buffer_size)
 {
@@ -590,8 +584,10 @@ 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)
+	if (ret != 3) {
+		dev_notice(dev, "badly formatted input (should be <num>:<num>:<num>)\n");
 		return -EINVAL;
+	}
 
 	if (desired_spanno && !desired_basechanno) {
 		dev_notice(dev, "Must set span number AND base chan number\n");
@@ -794,10 +790,17 @@ int dahdi_sysfs_add_device(struct dahdi_device *ddev, struct device *parent)
 {
 	int ret;
 	struct device *const dev = &ddev->dev;
+	const char *dn;
 
 	dev->parent = parent;
 	dev->bus = &dahdi_device_bus;
-	dev_set_name(dev, "%s:%s", parent->bus->name, dev_name(parent));
+	dn = dev_name(dev);
+	if (!dn || !*dn) {
+		/* Invent default name based on parent */
+		if (!parent)
+			return -EINVAL;
+		dev_set_name(dev, "%s:%s", parent->bus->name, dev_name(parent));
+	}
 	ret = device_add(dev);
 	return ret;
 }

drivers/dahdi/dahdi_dummy.c

@@ -53,7 +53,7 @@
 #if defined(USE_HIGHRESTIMER)
 #include <linux/hrtimer.h>
 #else
-#include <linux/time.h>
+#include <linux/timer.h>
 #endif
 
 #include <dahdi/kernel.h>
@@ -75,6 +75,7 @@ static inline void hrtimer_set_expires(struct hrtimer *timer, ktime_t time)
 #endif
 
 struct dahdi_dummy {
+	struct dahdi_device *ddev;
 	struct dahdi_span span;
 	struct dahdi_chan _chan;
 	struct dahdi_chan *chan;
@@ -205,37 +206,44 @@ static const struct dahdi_span_ops dummy_ops = {
 
 static int dahdi_dummy_initialize(struct dahdi_dummy *ztd)
 {
+	int res = 0;
 	/* DAHDI stuff */
+	ztd->ddev = dahdi_create_device();
+	if (!ztd->ddev)
+		return -ENOMEM;
+	dev_set_name(&ztd->ddev->dev, "dahdi_dummy");
 	ztd->chan = &ztd->_chan;
 	sprintf(ztd->span.name, "DAHDI_DUMMY/1");
 	snprintf(ztd->span.desc, sizeof(ztd->span.desc) - 1, "%s (source: " CLOCK_SRC ") %d", ztd->span.name, 1);
 	sprintf(ztd->chan->name, "DAHDI_DUMMY/%d/%d", 1, 0);
-	strlcpy(ztd->span.devicetype, "DAHDI Dummy Timing",
-		sizeof(ztd->span.devicetype));
+	ztd->ddev->devicetype = "DAHDI Dummy Timing";
 	ztd->chan->chanpos = 1;
 	ztd->span.chans = &ztd->chan;
 	ztd->span.channels = 0;		/* no channels on our span */
 	ztd->span.deflaw = DAHDI_LAW_MULAW;
 	ztd->chan->pvt = ztd;
 	ztd->span.ops = &dummy_ops;
-	if (dahdi_register(&ztd->span, 0)) {
-		return -1;
-	}
-	return 0;
+	list_add_tail(&ztd->span.device_node, &ztd->ddev->spans);
+	res = dahdi_register_device(ztd->ddev, NULL);
+	return res;
 }
 
 int init_module(void)
 {
+	int res;
 	ztd = kzalloc(sizeof(*ztd), GFP_KERNEL);
 	if (ztd == NULL) {
 		printk(KERN_ERR "dahdi_dummy: Unable to allocate memory\n");
 		return -ENOMEM;
 	}
 
-	if (dahdi_dummy_initialize(ztd)) {
-		printk(KERN_ERR "dahdi_dummy: Unable to intialize DAHDI driver\n");
+	res = dahdi_dummy_initialize(ztd);
+	if (res) {
+		printk(KERN_ERR
+		       "dahdi_dummy: Unable to intialize DAHDI driver (%d)\n",
+		       res);
 		kfree(ztd);
-		return -ENODEV;
+		return res;
 	}
 
 #if defined(USE_HIGHRESTIMER)
@@ -273,7 +281,8 @@ void cleanup_module(void)
 	atomic_set(&shutdown, 1);
 	del_timer_sync(&timer);
 #endif
-	dahdi_unregister(&ztd->span);
+	dahdi_unregister_device(ztd->ddev);
+	dahdi_free_device(ztd->ddev);
 	kfree(ztd);
 	if (debug)
 		printk(KERN_DEBUG "dahdi_dummy: cleanup() finished\n");

drivers/dahdi/dahdi_dynamic.c

@@ -385,16 +385,6 @@ static void dahdi_dynamic_release(struct kref *kref)
 
 	WARN_ON(test_bit(DAHDI_FLAGBIT_REGISTERED, &d->span.flags));
 
-	if (d->pvt) {
-		if (d->driver && d->driver->destroy) {
-			__module_get(d->driver->owner);
-			d->driver->destroy(d);
-			module_put(d->driver->owner);
-		} else {
-			WARN_ON(1);
-		}
-	}
-
 	kfree(d->msgbuf);
 
 	for (x = 0; x < d->span.channels; x++)
@@ -470,6 +460,24 @@ static int _destroy_dynamic(struct dahdi_dynamic_span *dds)
 		return -EBUSY;
 	}
 
+	if (d->pvt) {
+		if (d->driver && d->driver->destroy) {
+			if (!try_module_get(d->driver->owner)) {
+				/* The driver for this device is in the
+				 * process of unloading. Leave this dynamic on
+				 * the list so it's cleaned up when the driver
+				 * unregisters. */
+				 dynamic_put(d);
+				 return -ENXIO;
+			}
+			d->driver->destroy(d);
+			module_put(d->driver->owner);
+		} else {
+			WARN_ON(1);
+		}
+		d->pvt = NULL;
+	}
+
 	dahdi_unregister_device(d->ddev);
 
 	spin_lock_irqsave(&dspan_lock, flags);
@@ -605,9 +613,10 @@ static int _create_dynamic(struct dahdi_dynamic_span *dds)
 	strlcpy(d->dname, dds->driver, sizeof(d->dname));
 	strlcpy(d->addr, dds->addr, sizeof(d->addr));
 	d->timing = dds->timing;
-	sprintf(d->span.name, "DYN/%s/%s", dds->driver, dds->addr);
-	sprintf(d->span.desc, "Dynamic '%s' span at '%s'",
-		dds->driver, dds->addr);
+	snprintf(d->span.name, sizeof(d->span.name), "DYN/%s/%s",
+		 dds->driver, dds->addr);
+	snprintf(d->span.desc, sizeof(d->span.desc),
+		 "Dynamic '%s' span at '%s'", dds->driver, dds->addr);
 	d->span.deflaw = DAHDI_LAW_MULAW;
 	d->span.flags |= DAHDI_FLAG_RBS;
 	d->span.chans = d->chans;
@@ -658,6 +667,9 @@ static int _create_dynamic(struct dahdi_dynamic_span *dds)
 		return res;
 	}
 
+	d->ddev->devicetype = d->span.name;
+	d->ddev->hardware_id = d->span.name;
+	dev_set_name(&d->ddev->dev, "dynamic:%s:%d", dds->driver, dtd->id++);
 	list_add_tail(&d->span.device_node, &d->ddev->spans);
 	/* Whee!  We're created.  Now register the span */
 	if (dahdi_register_device(d->ddev, d->dev)) {
@@ -763,19 +775,17 @@ void dahdi_dynamic_unregister_driver(struct dahdi_dynamic_driver *dri)
 	list_for_each_entry_safe(d, n, &dspan_list, list) {
 		if (d->driver == dri) {
 			if (d->pvt) {
-				if (d->driver && d->driver->destroy) {
-					__module_get(d->driver->owner);
+				if (d->driver && d->driver->destroy)
 					d->driver->destroy(d);
-					module_put(d->driver->owner);
-				} else {
+				else
 					WARN_ON(1);
-				}
 			}
 			dahdi_unregister_device(d->ddev);
 			spin_lock_irqsave(&dspan_lock, flags);
 			list_del_rcu(&d->list);
 			spin_unlock_irqrestore(&dspan_lock, flags);
 			synchronize_rcu();
+			d->driver = NULL;
 			dynamic_put(d);
 		}
 	}
@@ -819,10 +829,13 @@ static void check_for_red_alarm(unsigned long ignored)
 	mod_timer(&alarmcheck, jiffies + 1 * HZ);
 }
 
+static const struct dahdi_dynamic_ops dahdi_dynamic_ops = {
+	.owner = THIS_MODULE,
+	.ioctl = dahdi_dynamic_ioctl,
+};
+
 static int dahdi_dynamic_init(void)
 {
-	dahdi_set_dynamic_ioctl(dahdi_dynamic_ioctl);
-
 	/* Start process to check for RED ALARM */
 	init_timer(&alarmcheck);
 	alarmcheck.expires = 0;
@@ -833,19 +846,25 @@ static int dahdi_dynamic_init(void)
 #ifdef ENABLE_TASKLETS
 	tasklet_init(&dahdi_dynamic_tlet, dahdi_dynamic_tasklet, 0);
 #endif
+	dahdi_set_dynamic_ops(&dahdi_dynamic_ops);
+
 	printk(KERN_INFO "DAHDI Dynamic Span support LOADED\n");
 	return 0;
 }
 
 static void dahdi_dynamic_cleanup(void)
 {
+	dahdi_set_dynamic_ops(NULL);
+
 #ifdef ENABLE_TASKLETS
 	if (taskletpending) {
 		tasklet_disable(&dahdi_dynamic_tlet);
 		tasklet_kill(&dahdi_dynamic_tlet);
 	}
 #endif
-	dahdi_set_dynamic_ioctl(NULL);
+	del_timer_sync(&alarmcheck);
+	/* Must call again in case it was running before and rescheduled
+	 * itself. */
 	del_timer(&alarmcheck);
 	printk(KERN_INFO "DAHDI Dynamic Span support unloaded\n");
 }

drivers/dahdi/dahdi_dynamic_eth.c

@@ -71,6 +71,8 @@ static struct dahdi_span *ztdeth_getspan(unsigned char *addr, unsigned short sub
 	if (z)
 		span = z->span;
 	spin_unlock_irqrestore(&zlock, flags);
+	if (!span || !test_bit(DAHDI_FLAGBIT_REGISTERED, &span->flags))
+		return NULL;
 	return span;
 }
 
@@ -152,7 +154,7 @@ static void ztdeth_transmit(struct dahdi_dynamic *dyn, u8 *msg, size_t msglen)
 
 	spin_lock_irqsave(&zlock, flags);
 	z = dyn->pvt;
-	if (z->dev) {
+	if (z && z->dev) {
 		/* Copy fields to local variables to remove spinlock ASAP */
 		dev = z->dev;
 		memcpy(addr, z->addr, sizeof(z->addr));
@@ -191,15 +193,44 @@ static void ztdeth_transmit(struct dahdi_dynamic *dyn, u8 *msg, size_t msglen)
 		spin_unlock_irqrestore(&zlock, flags);
 }
 
-
-static int ztdeth_flush(void)
+/**
+ * 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.
+ */
+static int ztdeth_flush(void)
+{
+	schedule_work(&dahdi_dynamic_eth_flush_work);
 	return 0;
 }
 
@@ -284,11 +315,12 @@ static void ztdeth_destroy(struct dahdi_dynamic *dyn)
 		prev = cur;
 		cur = cur->next;
 	}
-	spin_unlock_irqrestore(&zlock, flags);
 	if (cur == z) {	/* Successfully removed */
+		dyn->pvt = NULL;
 		printk(KERN_INFO "TDMoE: Removed interface for %s\n", z->span->name);
 		kfree(z);
 	}
+	spin_unlock_irqrestore(&zlock, flags);
 }
 
 static int ztdeth_create(struct dahdi_dynamic *dyn, const char *addr)
@@ -411,20 +443,27 @@ static struct notifier_block ztdeth_nblock = {
 
 static int __init ztdeth_init(void)
 {
+	skb_queue_head_init(&skbs);
+
 	dev_add_pack(&ztdeth_ptype);
 	register_netdevice_notifier(&ztdeth_nblock);
 	dahdi_dynamic_register_driver(&ztd_eth);
 
-	skb_queue_head_init(&skbs);
-
 	return 0;
 }
 
 static void __exit ztdeth_exit(void)
 {
-	dev_remove_pack(&ztdeth_ptype);
-	unregister_netdevice_notifier(&ztdeth_nblock);
+#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);
+
+	skb_queue_purge(&skbs);
 }
 
 MODULE_DESCRIPTION("DAHDI Dynamic TDMoE Support");

drivers/dahdi/dahdi_dynamic_loc.c

@@ -78,10 +78,11 @@ static LIST_HEAD(dynamic_local_list);
 static void
 dahdi_dynamic_local_transmit(struct dahdi_dynamic *dyn, u8 *msg, size_t msglen)
 {
-	struct dahdi_dynamic_local *const d = dyn->pvt;
+	struct dahdi_dynamic_local *d;
 	unsigned long flags;
 
 	spin_lock_irqsave(&local_lock, flags);
+	d = dyn->pvt;
 	if (d && d->peer && d->peer->span) {
 		if (test_bit(DAHDI_FLAGBIT_REGISTERED, &d->peer->span->flags))
 			dahdi_dynamic_receive(d->peer->span, msg, msglen);
@@ -130,11 +131,12 @@ static int digit2int(char d)
 
 static void dahdi_dynamic_local_destroy(struct dahdi_dynamic *dyn)
 {
-	struct dahdi_dynamic_local *d = dyn->pvt;
+	struct dahdi_dynamic_local *d;
 	unsigned long flags;
 	struct dahdi_dynamic_local *cur;
 
 	spin_lock_irqsave(&local_lock, flags);
+	d = dyn->pvt;
 	list_for_each_entry(cur, &dynamic_local_list, node) {
 		if (cur->peer == d)
 			cur->peer = NULL;

drivers/dahdi/firmware/Makefile

@@ -58,6 +58,7 @@ OBJECT_FILES:=$(OBJECT_FILES:FIRMWARE-OCT6114-128=dahdi-fw-oct6114-128.o)
 OBJECT_FILES:=$(OBJECT_FILES:FIRMWARE-OCT6114-256=dahdi-fw-oct6114-256.o)
 OBJECT_FILES:=$(OBJECT_FILES:FIRMWARE-TC400M=dahdi-fw-tc400m.o)
 OBJECT_FILES:=$(OBJECT_FILES:FIRMWARE-HX8=dahdi-fw-hx8.o)
+OBJECT_FILES:=$(OBJECT_FILES:FIRMWARE-VPMOCT032=dahdi-fw-vpmoct032.o)
 
 # Force usage of wget, for now
 DOWNLOAD=wget
@@ -220,3 +221,8 @@ dahdi-fw-oct6114-256.o: dahdi-fw-oct6114-256-$(OCT6114_256_VERSION).tar.gz dahdi
 dahdi-fw-tc400m.o: dahdi-fw-tc400m-$(TC400M_VERSION).tar.gz dahdi-fw-tc400m.bin make_firmware_object
 	@echo Making firmware object file for dahdi-fw-tc400m.bin
 	./make_firmware_object dahdi-fw-tc400m.bin $@
+
+# Build object file of a VPMOCT032 firmware image for linking
+dahdi-fw-vpmoct032.o: dahdi-fw-vpmoct032-$(VPMOCT032_VERSION).tar.gz dahdi-fw-vpmoct032.bin make_firmware_object
+	@echo Making firmware object file for dahdi-fw-vpmoct032.bin
+	./make_firmware_object dahdi-fw-vpmoct032.bin $@

drivers/dahdi/voicebus/GpakCust.h

@@ -36,6 +36,7 @@
 #ifndef _GPAKCUST_H  /* prevent multiple inclusion */
 #define _GPAKCUST_H
 
+#include <linux/module.h>
 #include <linux/device.h>
 #include <linux/completion.h>
 #include <linux/workqueue.h>

drivers/dahdi/voicebus/Kbuild

@@ -2,4 +2,17 @@ obj-$(DAHDI_BUILD_ALL)$(CONFIG_DAHDI_VOICEBUS) += dahdi_voicebus.o
 
 dahdi_voicebus-objs := voicebus.o GpakCust.o GpakApi.o voicebus_net.o vpmoct.o
 
-EXTRA_CFLAGS := -I$(src)/.. -Wno-undef
+FIRM_DIR	:= ../firmware
+
+ifneq ($(HOTPLUG_FIRMWARE),yes)
+dahdi_voicebus-objs += $(FIRM_DIR)/dahdi-fw-vpmoct032.o
+$(warning WARNING: You are compiling firmware into voicebus.ko which is not available under the terms of the GPL. It may be a violation of the GPL to distribute the resulting image since it combines both GPL and non-GPL work. You should consult a lawyer of your own before distributing such an image.)
+else
+  EXTRA_CFLAGS+=-DHOTPLUG_FIRMWARE
+endif
+
+EXTRA_CFLAGS += -I$(src)/.. -Wno-undef
+
+$(obj)/$(FIRM_DIR)/dahdi-fw-vpmoct032.o: $(obj)/voicebus.o
+	$(MAKE) -C $(obj)/$(FIRM_DIR) dahdi-fw-vpmoct032.o
+

drivers/dahdi/voicebus/voicebus.h

@@ -57,6 +57,15 @@
  * (and not tasklet). */
 #define CONFIG_VOICEBUS_INTERRUPT
 
+/*
+ * Enable the following definition in order to disable Active-State Power
+ * Management on the PCIe bridge for PCIe cards. This has been known to work
+ * around issues where the BIOS enables it on the cards even though the
+ * platform does not support it.
+ *
+ */
+#undef CONFIG_VOICEBUS_DISABLE_ASPM
+
 /* Define this to use a FIFO for the software echocan reference.
  * (experimental) */
 #undef CONFIG_VOICEBUS_ECREFERENCE

drivers/dahdi/voicebus/vpmoct.c

@@ -443,6 +443,47 @@ static void vpmoct_set_defaults(struct vpmoct *vpm)
 	vpmoct_write_dword(vpm, 0x30, 0);
 }
 
+static const char *const FIRMWARE_NAME = "dahdi-fw-vpmoct032.bin";
+#if defined(HOTPLUG_FIRMWARE)
+static int
+vpmoct_request_firmware(const struct firmware **fw, struct device *dev)
+{
+	return request_firmware(fw, FIRMWARE_NAME, dev);
+}
+
+static void vpmoct_release_firmware(const struct firmware *fw)
+{
+	release_firmware(fw);
+}
+#else
+static int
+vpmoct_request_firmware(const struct firmware **fw_p, struct device *dev)
+{
+	struct firmware *fw;
+	extern void _binary_dahdi_fw_vpmoct032_bin_size;
+	extern u8 _binary_dahdi_fw_vpmoct032_bin_start[];
+
+	*fw_p = fw = kzalloc(sizeof(*fw), GFP_KERNEL);
+	if (!fw)
+		return -ENOMEM;
+
+	fw->data = _binary_dahdi_fw_vpmoct032_bin_start;
+	/* Yes... this is weird. objcopy gives us a symbol containing
+	   the size of the firmware, not a pointer a variable containing the
+	   size. The only way we can get the value of the symbol is to take
+	   its address, so we define it as a pointer and then cast that value
+	   to the proper type.  */
+	fw->size = (size_t) &_binary_dahdi_fw_vpmoct032_bin_size;
+
+	return 0;
+}
+
+static void vpmoct_release_firmware(const struct firmware *fw)
+{
+	kfree(fw);
+}
+#endif
+
 /**
  * vpmoct_load_flash - Check the current flash version and possibly load.
  * @vpm:  The VPMOCT032 module to check / load.
@@ -463,10 +504,9 @@ static void vpmoct_load_flash(struct work_struct *data)
 	const struct firmware *fw;
 	const struct vpmoct_header *header;
 	char serial[VPMOCT_SERIAL_SIZE+1];
-	const char *const FIRMWARE_NAME = "dahdi-fw-vpmoct032.bin";
 	int i;
 
-	res = request_firmware(&fw, FIRMWARE_NAME, vpm->dev);
+	res = vpmoct_request_firmware(&fw, vpm->dev);
 	if (res) {
 		dev_warn(vpm->dev,
 			 "vpmoct: Failed to load firmware from userspace! %d\n",
@@ -505,7 +545,7 @@ static void vpmoct_load_flash(struct work_struct *data)
 				 FIRMWARE_NAME);
 
 			/* Just use the old version of the fimware. */
-			release_firmware(fw);
+			vpmoct_release_firmware(fw);
 			vpmoct_set_defaults(vpm);
 			vpmoct_load_complete(work, true);
 			return;
@@ -514,7 +554,7 @@ static void vpmoct_load_flash(struct work_struct *data)
 		if (vpm->minor == header->minor &&
 		    vpm->major == header->major) {
 			/* Proper version is running */
-			release_firmware(fw);
+			vpmoct_release_firmware(fw);
 			vpmoct_set_defaults(vpm);
 			vpmoct_load_complete(work, true);
 			return;
@@ -548,14 +588,14 @@ static void vpmoct_load_flash(struct work_struct *data)
 	if (vpmoct_check_firmware_crc(vpm, fw->size-VPMOCT_FIRM_HEADER_LEN*2,
 					header->major, header->minor))
 		goto error;
-	release_firmware(fw);
+	vpmoct_release_firmware(fw);
 	vpmoct_set_defaults(vpm);
 	vpmoct_load_complete(work, true);
 	return;
 
 error:
 	dev_info(vpm->dev, "Unable to load firmware\n");
-	release_firmware(fw);
+	vpmoct_release_firmware(fw);
 	/* TODO: Should we disable module if the firmware doesn't load? */
 	vpmoct_load_complete(work, false);
 	return;

drivers/dahdi/wcb4xxp/base.c

@@ -35,7 +35,6 @@
 #include <linux/spinlock.h>
 #include <linux/device.h>	/* dev_err() */
 #include <linux/interrupt.h>
-#include <asm/system.h>		/* cli(), *_flags */
 #include <asm/uaccess.h>	/* copy_*_user */
 #include <linux/workqueue.h>	/* work_struct */
 #include <linux/timer.h>	/* timer_struct */

drivers/dahdi/wct4xxp/Kbuild

@@ -18,6 +18,7 @@ wct4xxp-objs := base.o vpm450m.o $(shell $(src)/../oct612x/octasic-helper object
 
 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
+$(warning WARNING: You are compiling firmware into wct4xxp.ko which is not available under the terms of the GPL. It may be a violation of the GPL to distribute the resulting image since it combines both GPL and non-GPL work. You should consult a lawyer of your own before distributing such an image.)
 endif
 
 $(obj)/$(FIRM_DIR)/dahdi-fw-oct6114-064.o: $(obj)/base.o

drivers/dahdi/wct4xxp/base.c

@@ -173,6 +173,15 @@ static inline int t4_queue_work(struct workqueue_struct *wq, struct work_struct
 /* #define CONFIG_FORCE_EXTENDED_RESET */
 /* #define CONFIG_NOEXTENDED_RESET */
 
+/*
+ * Uncomment the following definition in order to disable Active-State Power
+ * Management on the PCIe bridge for PCIe cards. This has been known to work
+ * around issues where the BIOS enables it on the cards even though the
+ * platform does not support it.
+ *
+ */
+/* #define CONFIG_WCT4XXP_DISABLE_ASPM */
+
 #if defined(CONFIG_FORCE_EXTENDED_RESET) && defined(CONFIG_NOEXTENDED_RESET)
 #error "You cannot define both CONFIG_FORCE_EXTENDED_RESET and " \
 		"CONFIG_NOEXTENDED_RESET."
@@ -373,11 +382,16 @@ struct t4 {
 	int needed_latency;
 	
 #ifdef VPM_SUPPORT
-	struct vpm450m *vpm450m;
+	struct vpm450m *vpm;
 #endif	
 	struct spi_state st;
 };
 
+static inline bool is_pcie(const struct t4 *wc)
+{
+	return (wc->devtype->flags & FLAG_EXPRESS) > 0;
+}
+
 static inline bool has_e1_span(const struct t4 *wc)
 {
 	return (wc->t1e1) != 0;
@@ -410,7 +424,7 @@ static inline unsigned int ports_on_framer(const struct t4 *wc)
 }
 
 #ifdef VPM_SUPPORT
-static void t4_vpm450_init(struct t4 *wc);
+static void t4_vpm_init(struct t4 *wc);
 
 static void echocan_free(struct dahdi_chan *chan, struct dahdi_echocan_state *ec);
 
@@ -670,11 +684,12 @@ static unsigned int __t4_framer_in(const struct t4 *wc, int unit,
 
 	val = ((unit & 0x3) << 8) | (addr & 0xff) | haddr;
 	writel(val, wc_laddr);
-	/* readl(wc_version); */
+	readl(wc_version);
 	writel(val | WC_LFRMR_CS | WC_LREAD, wc_laddr);
 	readl(wc_version);
 	ret = readb(wc_ldata);
 	writel(val, wc_laddr);
+	readl(wc_version);
 	return ret;
 }
 
@@ -700,11 +715,13 @@ static void __t4_framer_out(const struct t4 *wc, int unit, const u8 addr,
 
 	val = ((unit & 0x3) << 8) | (addr & 0xff) | haddr;
 	writel(val, wc_laddr);
+	readl(wc_version);
 	writel(value, wc_ldata);
 	readl(wc_version);
 	writel(val | WC_LFRMR_CS | WC_LWRITE, wc_laddr);
-	/* readl(wc_version); */
+	readl(wc_version);
 	writel(val, wc_laddr);
+	readl(wc_version);
 }
 
 static void t4_framer_out(struct t4 *wc, int unit,
@@ -819,12 +836,12 @@ static inline void t4_oct_out(struct t4 *wc, const unsigned int addr, const unsi
 	spin_unlock_irqrestore(&wc->reglock, flags);
 }
 
-static void t4_check_vpm450(struct t4 *wc)
+static void t4_check_vpm(struct t4 *wc)
 {
 	int channel, tone, start, span;
 
-	if (vpm450m_checkirq(wc->vpm450m)) {
-		while(vpm450m_getdtmf(wc->vpm450m, &channel, &tone, &start)) {
+	if (vpm450m_checkirq(wc->vpm)) {
+		while(vpm450m_getdtmf(wc->vpm, &channel, &tone, &start)) {
 			span = channel & 0x3;
 			channel >>= 2;
 			if (!has_e1_span(wc))
@@ -1080,7 +1097,7 @@ unsigned int oct_get_reg(void *data, unsigned int reg)
 
 static const char *__t4_echocan_name(struct t4 *wc)
 {
-	if (wc->vpm450m) {
+	if (wc->vpm) {
 		if (wc->numspans == 2)
 			return vpmoct064_name;
 		else if (wc->numspans == 4)
@@ -1108,7 +1125,7 @@ static int t4_echocan_create(struct dahdi_chan *chan,
 	const struct dahdi_echocan_ops *ops;
 	const struct dahdi_echocan_features *features;
 
-	if (!vpmsupport || !wc->vpm450m)
+	if (!vpmsupport || !wc->vpm)
 		return -ENODEV;
 
 	ops = &vpm_ec_ops;
@@ -1127,7 +1144,7 @@ static int t4_echocan_create(struct dahdi_chan *chan,
 
 	channel = has_e1_span(wc) ? chan->chanpos : chan->chanpos + 4;
 
-	if (wc->vpm450m) {
+	if (wc->vpm) {
 		if (is_octal(wc))
 			channel = channel << 3;
 		else
@@ -1138,7 +1155,7 @@ static int t4_echocan_create(struct dahdi_chan *chan,
 				"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->vpm450m, channel, ecp->tap_length);
+		vpm450m_setec(wc->vpm, channel, ecp->tap_length);
 	}
 	return 0;
 }
@@ -1152,7 +1169,7 @@ static void echocan_free(struct dahdi_chan *chan, struct dahdi_echocan_state *ec
 
 	channel = has_e1_span(wc) ? chan->chanpos : chan->chanpos + 4;
 
-	if (wc->vpm450m) {
+	if (wc->vpm) {
 		if (is_octal(wc))
 			channel = channel << 3;
 		else
@@ -1163,7 +1180,7 @@ static void echocan_free(struct dahdi_chan *chan, struct dahdi_echocan_state *ec
 				"Channel is %d, Span is %d, offset is %d "
 				"length 0\n", wc->num, chan->chanpos,
 				chan->span->offset, channel);
-		vpm450m_setec(wc->vpm450m, channel, 0);
+		vpm450m_setec(wc->vpm, channel, 0);
 	}
 }
 #endif
@@ -1209,7 +1226,7 @@ static int t4_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long dat
 	case DAHDI_TONEDETECT:
 		if (get_user(j, (__user int *) data))
 			return -EFAULT;
-		if (!wc->vpm450m)
+		if (!wc->vpm)
 			return -ENOSYS;
 		if (j && (vpmdtmfsupport == 0))
 			return -ENOSYS;
@@ -1226,7 +1243,7 @@ static int t4_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long dat
 		if (!has_e1_span(wc))
 			channel += (4 << 3);
 		channel |= chan->span->offset;
-		vpm450m_setdtmf(wc->vpm450m, channel, j & DAHDI_TONEDETECT_ON,
+		vpm450m_setdtmf(wc->vpm, channel, j & DAHDI_TONEDETECT_ON,
 				j & DAHDI_TONEDETECT_MUTE);
 		return 0;
 #endif
@@ -2786,6 +2803,39 @@ static void __t4_configure_e1(struct t4 *wc, int unit, int lineconfig)
 			wc->numspans, unit + 1, framing, line, crc4);
 }
 
+/**
+ * t4_check_for_interrupts - Return 0 if the card is generating interrupts.
+ * @wc:	The card to check.
+ *
+ * If the card is not generating interrupts, this function will also place all
+ * the spans on the card into red alarm.
+ *
+ */
+static int t4_check_for_interrupts(struct t4 *wc)
+{
+	unsigned int starting_intcount = wc->intcount;
+	unsigned long stop_time = jiffies + HZ*2;
+	unsigned long flags;
+	int x;
+
+	msleep(20);
+	spin_lock_irqsave(&wc->reglock, flags);
+	while (starting_intcount == wc->intcount) {
+		spin_unlock_irqrestore(&wc->reglock, flags);
+		if (time_after(jiffies, stop_time)) {
+			for (x = 0; x < wc->numspans; x++)
+				wc->tspans[x]->span.alarms = DAHDI_ALARM_RED;
+			dev_err(&wc->dev->dev, "Interrupts not detected.\n");
+			return -EIO;
+		}
+		msleep(100);
+		spin_lock_irqsave(&wc->reglock, flags);
+	}
+	spin_unlock_irqrestore(&wc->reglock, flags);
+
+	return 0;
+}
+
 static int t4_startup(struct file *file, struct dahdi_span *span)
 {
 #ifdef SUPPORT_GEN1
@@ -2847,7 +2897,7 @@ static int t4_startup(struct file *file, struct dahdi_span *span)
 		/* Start DMA, enabling DMA interrupts on read only */
 		wc->dmactrl |= (ts->spanflags & FLAG_2NDGEN) ? 0xc0000000 : 0xc0000003;
 #ifdef VPM_SUPPORT
-		wc->dmactrl |= (wc->vpm450m) ? T4_VPM_PRESENT : 0;
+		wc->dmactrl |= (wc->vpm) ? T4_VPM_PRESENT : 0;
 #endif
 		/* Seed interrupt register */
 		__t4_pci_out(wc, WC_INTR, 0x0c);
@@ -2908,6 +2958,11 @@ static int t4_startup(struct file *file, struct dahdi_span *span)
 					"Source\n", span->spanno);
 	}
 
+	if (!alreadyrunning) {
+		if (t4_check_for_interrupts(wc))
+			return -EIO;
+	}
+
 	if (debug)
 		dev_info(&wc->dev->dev, "Completed startup!\n");
 	clear_bit(T4_IGNORE_LATENCY, &wc->checkflag);
@@ -3729,7 +3784,7 @@ static inline void t4_framer_interrupt(struct t4 *wc, int span)
 }
 
 #ifdef SUPPORT_GEN1
-DAHDI_IRQ_HANDLER(t4_interrupt)
+static irqreturn_t _t4_interrupt(int irq, void *dev_id)
 {
 	struct t4 *wc = dev_id;
 	unsigned long flags;
@@ -3797,6 +3852,16 @@ DAHDI_IRQ_HANDLER(t4_interrupt)
 
 	return IRQ_RETVAL(1);
 }
+
+DAHDI_IRQ_HANDLER(t4_interrupt)
+{
+	irqreturn_t ret;
+	unsigned long flags;
+	local_irq_save(flags);
+	ret = _t4_interrupt(irq, dev_id);
+	local_irq_restore(flags);
+	return ret;
+}
 #endif
 
 static int t4_allocate_buffers(struct t4 *wc, int numbufs,
@@ -3903,18 +3968,18 @@ static void t4_isr_bh(unsigned long data)
 		}
 	}
 #ifdef VPM_SUPPORT
-	if (wc->vpm450m) {
+	if (wc->vpm) {
 		if (test_and_clear_bit(T4_CHECK_VPM, &wc->checkflag)) {
 			/* How stupid is it that the octasic can't generate an
 			 * interrupt when there's a tone, in spite of what
 			 * their documentation says? */
-			t4_check_vpm450(wc);
+			t4_check_vpm(wc);
 		}
 	}
 #endif
 }
 
-DAHDI_IRQ_HANDLER(t4_interrupt_gen2)
+static irqreturn_t _t4_interrupt_gen2(int irq, void *dev_id)
 {
 	struct t4 *wc = dev_id;
 	unsigned int status;
@@ -4082,7 +4147,7 @@ DAHDI_IRQ_HANDLER(t4_interrupt_gen2)
 	}
 
 #ifdef VPM_SUPPORT
-	if (wc->vpm450m && vpmdtmfsupport) {
+	if (wc->vpm && vpmdtmfsupport) {
 		/* How stupid is it that the octasic can't generate an
 		 * interrupt when there's a tone, in spite of what their
 		 * documentation says? */
@@ -4110,6 +4175,16 @@ out:
 	return IRQ_RETVAL(1);
 }
 
+DAHDI_IRQ_HANDLER(t4_interrupt_gen2)
+{
+	irqreturn_t ret;
+	unsigned long flags;
+	local_irq_save(flags);
+	ret = _t4_interrupt_gen2(irq, dev_id);
+	local_irq_restore(flags);
+	return ret;
+}
+
 #ifdef SUPPORT_GEN1
 static int t4_reset_dma(struct t4 *wc)
 {
@@ -4127,7 +4202,7 @@ static int t4_reset_dma(struct t4 *wc)
 	t4_pci_out(wc, WC_INTR, 0);
 #ifdef VPM_SUPPORT
 	wc->dmactrl = 0xc0000000 | (1 << 29) |
-		      ((wc->vpm450m) ? T4_VPM_PRESENT : 0);
+		      ((wc->vpm) ? T4_VPM_PRESENT : 0);
 #else	
 	wc->dmactrl = 0xc0000000 | (1 << 29);
 #endif
@@ -4139,7 +4214,7 @@ static int t4_reset_dma(struct t4 *wc)
 #endif
 
 #ifdef VPM_SUPPORT
-static void t4_vpm450_init(struct t4 *wc)
+static void t4_vpm_init(struct t4 *wc)
 {
 	int laws[8] = { 0, };
 	int x;
@@ -4185,7 +4260,15 @@ static void t4_vpm450_init(struct t4 *wc)
 			laws[x] = 1;
 	}
 
-	switch ((vpm_capacity = get_vpm450m_capacity(wc))) {
+	vpm_capacity = get_vpm450m_capacity(wc);
+	if (vpm_capacity != wc->numspans * 32) {
+		dev_info(&wc->dev->dev, "Disabling VPMOCT%03d. TE%dXXP"\
+				" requires a VPMOCT%03d", vpm_capacity,
+				wc->numspans, wc->numspans*32);
+		return;
+	}
+
+	switch (vpm_capacity) {
 	case 64:
 #if defined(HOTPLUG_FIRMWARE)
 		if ((request_firmware(&firmware, oct064_firmware, &wc->dev->dev) != 0) ||
@@ -4249,7 +4332,7 @@ static void t4_vpm450_init(struct t4 *wc)
 		return;
 	}
 
-	if (!(wc->vpm450m = init_vpm450m(wc, laws, wc->numspans, firmware))) {
+	if (!(wc->vpm = init_vpm450m(wc, laws, wc->numspans, firmware))) {
 		dev_notice(&wc->dev->dev, "VPM450: Failed to initialize\n");
 		if (firmware != &embedded_firmware)
 			release_firmware(firmware);
@@ -4842,19 +4925,21 @@ static int t4_hardware_init_1(struct t4 *wc, unsigned int cardflags)
 
 	/* TE820 Auth Check */
 	if (is_octal(wc)) {
+		unsigned long stop = jiffies + HZ;
 		uint32_t donebit;
 
-		donebit = t4_pci_in(wc, WC_LEDS2);
 		t4_pci_out(wc, WC_LEDS2, WC_SET_AUTH);
-
-		msleep(1000);
-
 		donebit = t4_pci_in(wc, WC_LEDS2);
-		if (!(donebit & WC_GET_AUTH)) {
-			/* Encryption check failed, stop operation */
-			dev_info(&wc->dev->dev, "Failed encryption check. "\
-						"Unloading driver.\n");
-			return -EIO;
+		while (!(donebit & WC_GET_AUTH)) {
+			if (time_after(jiffies, stop)) {
+				/* Encryption check failed, stop operation */
+				dev_info(&wc->dev->dev,
+					 "Failed encryption check. "
+					 "Unloading driver.\n");
+				return -EIO;
+			}
+			msleep(20);
+			donebit = t4_pci_in(wc, WC_LEDS2);
 		}
 	}
 
@@ -5024,6 +5109,13 @@ t4_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 	spin_lock_init(&wc->reglock);
 	wc->devtype = (const struct devtype *)(ent->driver_data);
 
+#ifdef CONFIG_WCT4XXP_DISABLE_ASPM
+	if (is_pcie(wc)) {
+		pci_disable_link_state(pdev->bus->self, PCIE_LINK_STATE_L0S |
+			PCIE_LINK_STATE_L1 | PCIE_LINK_STATE_CLKPM);
+	};
+#endif
+
 	if (is_octal(wc))
 		wc->numspans = 8;
 	else if (wc->devtype->flags & FLAG_2PORT)
@@ -5140,22 +5232,23 @@ t4_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 #ifdef SUPPORT_GEN1
 	if (request_irq(pdev->irq, (wc->devtype->flags & FLAG_2NDGEN) ?
 					t4_interrupt_gen2 : t4_interrupt,
-			DAHDI_IRQ_SHARED_DISABLED,
+			DAHDI_IRQ_SHARED,
 			(wc->numspans == 8) ? "wct8xxp" :
 					      (wc->numspans == 2) ? "wct2xxp" :
 								    "wct4xxp",
-			wc))
+			wc)) {
 #else
-		if (!(wc->tspans[0]->spanflags & FLAG_2NDGEN)) {
-			dev_notice(&wc->dev->dev, "This driver does not "
-					"support 1st gen modules\n");
-			free_wc(wc);
-			return -ENODEV;
-		}	
-	if (request_irq(pdev->irq, t4_interrupt_gen2, DAHDI_IRQ_SHARED_DISABLED, "t4xxp", wc)) 
+	if (!(wc->tspans[0]->spanflags & FLAG_2NDGEN)) {
+		dev_notice(&wc->dev->dev, "This driver does not "
+				"support 1st gen modules\n");
+		free_wc(wc);
+		return -ENODEV;
+	}
+
+	if (request_irq(pdev->irq, t4_interrupt_gen2,
+			DAHDI_IRQ_SHARED, "t4xxp", wc)) {
 #endif
-	{
-		dev_notice(&wc->dev->dev, "t4xxp: Unable to request IRQ %d\n",
+		dev_notice(&wc->dev->dev, "Unable to request IRQ %d\n",
 				pdev->irq);
 		free_wc(wc);
 		return -EIO;
@@ -5180,11 +5273,11 @@ t4_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 	t4_gpio_setdir(wc, (0xff), (0xff));
 
 #ifdef VPM_SUPPORT
-	if (!wc->vpm450m) {
-		t4_vpm450_init(wc);
-		wc->dmactrl |= (wc->vpm450m) ? T4_VPM_PRESENT : 0;
+	if (!wc->vpm) {
+		t4_vpm_init(wc);
+		wc->dmactrl |= (wc->vpm) ? T4_VPM_PRESENT : 0;
 		t4_pci_out(wc, WC_DMACTRL, wc->dmactrl);
-		if (wc->vpm450m)
+		if (wc->vpm)
 			set_span_devicetype(wc);
 	}
 #endif
@@ -5260,10 +5353,10 @@ static void _t4_remove_one(struct t4 *wc)
 	t4_hardware_stop(wc);
 	
 #ifdef VPM_SUPPORT
-	/* Release vpm450m */
-	if (wc->vpm450m)
-		release_vpm450m(wc->vpm450m);
-	wc->vpm450m = NULL;
+	/* Release vpm */
+	if (wc->vpm)
+		release_vpm450m(wc->vpm);
+	wc->vpm = NULL;
 #endif
 	/* Unregister spans */
 

drivers/dahdi/wct4xxp/vpm450m.c

@@ -422,6 +422,7 @@ struct vpm450m *init_vpm450m(void *wc, int *isalaw, int numspans, const struct f
 	tOCT6100_GET_INSTANCE_SIZE InstanceSize;
 	tOCT6100_CHANNEL_OPEN *ChannelOpen;
 	UINT32 ulResult;
+	const unsigned int mask = (8 == numspans) ? 0x7 : 0x3;
 	unsigned int sout_stream, rout_stream;
 	struct vpm450m *vpm450m;
 	int x,y,law;
@@ -527,7 +528,7 @@ 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 & 0x07])
+			if (isalaw[x & mask])
 				law = cOCT6100_PCM_A_LAW;
 			else
 				law = cOCT6100_PCM_U_LAW;

drivers/dahdi/wctc4xxp/base.c

@@ -474,6 +474,7 @@ wctc4xxp_skb_to_cmd(struct wcdte *wc, const struct sk_buff *skb)
 	return cmd;
 }
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 2, 0)
 static void
 wctc4xxp_net_set_multi(struct net_device *netdev)
 {
@@ -481,6 +482,15 @@ wctc4xxp_net_set_multi(struct net_device *netdev)
 	DTE_DEBUG(DTE_DEBUG_GENERAL, "%s promiscuity:%d\n",
 	   __func__, netdev->promiscuity);
 }
+#else
+static void
+wctc4xxp_set_rx_mode(struct net_device *netdev)
+{
+	struct wcdte *wc = wcdte_from_netdev(netdev);
+	DTE_DEBUG(DTE_DEBUG_GENERAL, "%s promiscuity:%d\n",
+	   __func__, netdev->promiscuity);
+}
+#endif
 
 static int
 wctc4xxp_net_up(struct net_device *netdev)
@@ -644,7 +654,11 @@ wctc4xxp_net_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
 
 #ifdef HAVE_NET_DEVICE_OPS
 static const struct net_device_ops wctc4xxp_netdev_ops = {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 2, 0)
 	.ndo_set_multicast_list = &wctc4xxp_net_set_multi,
+#else
+	.ndo_set_rx_mode = &wctc4xxp_set_rx_mode,
+#endif
 	.ndo_open = &wctc4xxp_net_up,
 	.ndo_stop = &wctc4xxp_net_down,
 	.ndo_start_xmit = &wctc4xxp_net_hard_start_xmit,

drivers/dahdi/wctdm24xxp/base.c

@@ -191,6 +191,11 @@ static const struct wctdm_desc wcaex410 = { "Wildcard AEX410", FLAG_EXPRESS, 4 }
 static const struct wctdm_desc wcha80000 = { "HA8-0000", 0, 8 };
 static const struct wctdm_desc wchb80000 = { "HB8-0000", FLAG_EXPRESS, 8 };
 
+static inline bool is_pcie(const struct wctdm *wc)
+{
+	return (wc->desc->flags & FLAG_EXPRESS) > 0;
+}
+
 /**
  * Returns true if the card is one of the Hybrid Digital Analog Cards.
  */
@@ -1068,9 +1073,22 @@ wctdm_isr_getreg(struct wctdm *wc, struct wctdm_module *const mod, u8 address)
 	list_add(&cmd->node, &mod->pending_cmds);
 }
 
+/* Must be called with wc.reglock held and local interrupts disabled */
 static inline void
-wctdm_setreg_intr(struct wctdm *wc, struct wctdm_module *mod,
-		  int addr, int val);
+wctdm_setreg_intr(struct wctdm *wc, struct wctdm_module *mod, int addr, int val)
+{
+	struct wctdm_cmd *cmd;
+
+	cmd = kmalloc(sizeof(*cmd), GFP_ATOMIC);
+	if (unlikely(!cmd))
+		return;
+
+	cmd->complete = NULL;
+	cmd->cmd = CMD_WR(addr, val);
+
+	list_add_tail(&cmd->node, &mod->pending_cmds);
+}
+
 
 static void cmd_checkisr(struct wctdm *wc, struct wctdm_module *const mod)
 {
@@ -1215,22 +1233,6 @@ static inline void wctdm_transmitprep(struct wctdm *wc, unsigned char *sframe)
 	spin_unlock(&wc->reglock);
 }
 
-/* Must be called with wc.reglock held and local interrupts disabled */
-static inline void
-wctdm_setreg_intr(struct wctdm *wc, struct wctdm_module *mod, int addr, int val)
-{
-	struct wctdm_cmd *cmd;
-
-	cmd = kmalloc(sizeof(*cmd), GFP_ATOMIC);
-	if (unlikely(!cmd))
-		return;
-
-	cmd->complete = NULL;
-	cmd->cmd = CMD_WR(addr, val);
-
-	list_add_tail(&cmd->node, &mod->pending_cmds);
-}
-
 int wctdm_setreg(struct wctdm *wc, struct wctdm_module *mod, int addr, int val)
 {
 	struct wctdm_cmd *cmd;
@@ -1904,7 +1906,7 @@ static void wctdm_fxo_ring_detect(struct wctdm *wc, struct wctdm_module *mod)
 		if (!is_fxo_ringing(fxo)) {
 			set_ring(fxo, DEBOUNCING_RINGOFF);
 			fxo->ringdebounce_timer =
-					wc->framecount + ringdebounce / 2;
+					wc->framecount + ringdebounce / 8;
 		}
 		break;
 	case DEBOUNCING_RINGOFF:
@@ -2256,20 +2258,16 @@ wctdm_fxs_hooksig(struct wctdm *wc, struct wctdm_module *const mod,
 	switch (txsig) {
 	case DAHDI_TXSIG_ONHOOK:
 		switch (get_dahdi_chan(wc, mod)->sig) {
-		case DAHDI_SIG_EM:
-		case DAHDI_SIG_FXOKS:
-		case DAHDI_SIG_FXOLS:
-			x = fxs->idletxhookstate;
-			break;
 		case DAHDI_SIG_FXOGS:
 			x = (POLARITY_XOR(fxs)) ?
 					SLIC_LF_RING_OPEN :
 					SLIC_LF_TIP_OPEN;
 			break;
+		case DAHDI_SIG_EM:
+		case DAHDI_SIG_FXOKS:
+		case DAHDI_SIG_FXOLS:
 		default:
-			WARN_ONCE(1, "%x is an invalid signaling state for "
-				  "an FXS module.\n",
-				  get_dahdi_chan(wc, mod)->sig);
+			x = fxs->idletxhookstate;
 			break;
 		}
 		break;
@@ -3731,14 +3729,15 @@ static int wctdm_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long
 
 		if (((fxs->lasttxhook & SLIC_LF_SETMASK) == SLIC_LF_ACTIVE_FWD) ||
 		    ((fxs->lasttxhook & SLIC_LF_SETMASK) == SLIC_LF_ACTIVE_REV)) {
+			int res;
 
-			x = set_lasttxhook_interruptible(wc, fxs,
+			res = set_lasttxhook_interruptible(wc, fxs,
 				(POLARITY_XOR(fxs) ?
 				SLIC_LF_OHTRAN_REV : SLIC_LF_OHTRAN_FWD),
 				&mod->sethook);
 
 			if (debug & DEBUG_CARD) {
-				if (x) {
+				if (res) {
 					dev_info(&wc->vb.pdev->dev,
 						 "Channel %d TIMEOUT: "
 						 "OnHookTransfer start\n",
@@ -4937,8 +4936,30 @@ static void wctdm_back_out_gracefully(struct wctdm *wc)
 {
 	int i;
 	unsigned long flags;
+	struct vpmadt032 *vpm;
 	LIST_HEAD(local_list);
 
+	spin_lock_irqsave(&wc->reglock, flags);
+	if (wc->not_ready) {
+		wc->not_ready--;
+		spin_unlock_irqrestore(&wc->reglock, flags);
+		while (wctdm_wait_for_ready(wc))
+			schedule();
+		spin_lock_irqsave(&wc->reglock, flags);
+	}
+	spin_unlock_irqrestore(&wc->reglock, flags);
+
+	if (wc->vpmadt032) {
+		flush_workqueue(wc->vpmadt032->wq);
+		clear_bit(VPM150M_ACTIVE, &wc->vpmadt032->control);
+		flush_workqueue(wc->vpmadt032->wq);
+		spin_lock_irqsave(&wc->reglock, flags);
+		vpm = wc->vpmadt032;
+		wc->vpmadt032 = NULL;
+		spin_unlock_irqrestore(&wc->reglock, flags);
+		vpmadt032_free(vpm);
+	}
+
 	voicebus_release(&wc->vb);
 #ifdef CONFIG_VOICEBUS_ECREFERENCE
 	for (i = 0; i < ARRAY_SIZE(wc->ec_reference); ++i) {
@@ -5660,6 +5681,13 @@ __wctdm_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 	wc->vb.pdev = pdev;
 	wc->vb.debug = &debug;
 
+#ifdef CONFIG_VOICEBUS_DISABLE_ASPM
+	if (is_pcie(wc)) {
+		pci_disable_link_state(pdev->bus->self, PCIE_LINK_STATE_L0S |
+			PCIE_LINK_STATE_L1 | PCIE_LINK_STATE_CLKPM);
+	};
+#endif
+
 	if (is_hx8(wc)) {
 		wc->vb.ops = &hx8_voicebus_operations;
 		ret = voicebus_boot_init(&wc->vb, wc->board_name);
@@ -5716,7 +5744,6 @@ __wctdm_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 	if (is_hx8(wc)) {
 		ret = hx8_check_firmware(wc);
 		if (ret) {
-			voicebus_release(&wc->vb);
 			wctdm_back_out_gracefully(wc);
 			return -EIO;
 		}
@@ -5992,6 +6019,8 @@ static void __devexit wctdm_remove_one(struct pci_dev *pdev)
 			schedule();
 	}
 
+	flush_scheduled_work();
+
 	/* shut down any BRI modules */
 	for (i = 0; i < wc->mods_per_board; i += 4) {
 		if (wc->mods[i].type == BRI)

drivers/dahdi/wcte12xp/base.c

@@ -99,6 +99,11 @@ static const struct t1_desc te120p = {"Wildcard TE120P"};
 static const struct t1_desc te122 = {"Wildcard TE122"};
 static const struct t1_desc te121 = {"Wildcard TE121"};
 
+static inline bool is_pcie(const struct t1 *t1)
+{
+	return (0 == strcmp(t1->variety, te121.name));
+}
+
 /* names of HWEC modules */
 static const char *vpmadt032_name = "VPMADT032";
 static const char *vpmoct_name = "VPMOCT032";
@@ -2749,6 +2754,13 @@ static int __devinit te12xp_init_one(struct pci_dev *pdev, const struct pci_devi
 	}
 #endif /* CONFIG_VOICEBUS_ECREFERENCE */
 
+#ifdef CONFIG_VOICEBUS_DISABLE_ASPM
+	if (is_pcie(wc)) {
+		pci_disable_link_state(pdev->bus->self, PCIE_LINK_STATE_L0S |
+			PCIE_LINK_STATE_L1 | PCIE_LINK_STATE_CLKPM);
+	};
+#endif
+
 	snprintf(wc->name, sizeof(wc->name)-1, "wcte12xp%d", index);
 	pci_set_drvdata(pdev, wc);
 	wc->vb.ops = &voicebus_operations;

drivers/dahdi/xpp/card_bri.c

@@ -35,6 +35,10 @@
 
 static const char rcsid[] = "$Id$";
 
+#ifndef	DAHDI_SIG_HARDHDLC
+#error Cannot build BRI without HARDHDLC supprt
+#endif
+
 static DEF_PARM(int, debug, 0, 0644, "Print DBG statements");	/* must be before dahdi_debug.h */
 static DEF_PARM(uint, poll_interval, 500, 0644, "Poll channel state interval in milliseconds (0 - disable)");
 static DEF_PARM_BOOL(nt_keepalive, 1, 0644, "Force BRI_NT to keep trying connection");
@@ -129,22 +133,7 @@ typedef union {
 #define	REG30_LOST	3	/* in polls */
 #define	DCHAN_LOST	15000	/* in ticks */
 
-#ifdef	CONFIG_DAHDI_BRI_DCHANS
-#define	BRI_DCHAN_SIGCAP	(			  \
-					DAHDI_SIG_EM	| \
-					DAHDI_SIG_CLEAR	| \
-					DAHDI_SIG_FXSLS	| \
-					DAHDI_SIG_FXSGS	| \
-					DAHDI_SIG_FXSKS	| \
-					DAHDI_SIG_FXOLS	| \
-					DAHDI_SIG_FXOGS	| \
-					DAHDI_SIG_FXOKS	| \
-					DAHDI_SIG_CAS	| \
-					DAHDI_SIG_SF	  \
-				)
-#else
 #define	BRI_DCHAN_SIGCAP	DAHDI_SIG_HARDHDLC
-#endif
 #define	BRI_BCHAN_SIGCAP	(DAHDI_SIG_CLEAR | DAHDI_SIG_DACS)
 
 #define	IS_NT(xpd)		(PHONEDEV(xpd).direction == TO_PHONE)
@@ -218,13 +207,7 @@ struct BRI_priv_data {
 	/*
 	 * D-Chan: buffers + extra state info.
 	 */
-#ifdef	CONFIG_DAHDI_BRI_DCHANS
-	int				dchan_r_idx;
-	byte				dchan_rbuf[DCHAN_BUFSIZE];
-#else
 	atomic_t			hdlc_pending;
-#endif
-	byte				dchan_tbuf[DCHAN_BUFSIZE];
 	bool				txframe_begin;
 
 	uint				tick_counter;
@@ -438,22 +421,6 @@ static void nt_activation(xpd_t *xpd, bool on)
 /*
  * D-Chan receive
  */
-static void bri_hdlc_abort(xpd_t *xpd, struct dahdi_chan *dchan, int event)
-{
-	struct BRI_priv_data	*priv;
-
-	priv = xpd->priv;
-	BUG_ON(!priv);
-#ifdef	CONFIG_DAHDI_BRI_DCHANS
-	if(debug & DBG_COMMANDS)
-		dump_hex_buf(xpd, "D-Chan(abort) RX: dchan_rbuf",
-			priv->dchan_rbuf, priv->dchan_r_idx);
-	priv->dchan_r_idx = 0;
-#else
-	dahdi_hdlc_abort(dchan, event);
-#endif
-}
-
 static int bri_check_stat(xpd_t *xpd, struct dahdi_chan *dchan, byte *buf, int len)
 {
 	struct BRI_priv_data	*priv;
@@ -461,21 +428,11 @@ static int bri_check_stat(xpd_t *xpd, struct dahdi_chan *dchan, byte *buf, int l
 
 	priv = xpd->priv;
 	BUG_ON(!priv);
-#ifdef	CONFIG_DAHDI_BRI_DCHANS
-	if(priv->dchan_r_idx < 4) {
-		XPD_NOTICE(xpd, "D-Chan RX short frame (dchan_r_idx=%d)\n",
-			priv->dchan_r_idx);
-		dump_hex_buf(xpd, "D-Chan RX:    current packet", buf, len);
-		bri_hdlc_abort(xpd, dchan, DAHDI_EVENT_ABORT);
-		return -EPROTO;
-	}
-#else
 	if(len <= 0) {
 		XPD_NOTICE(xpd, "D-Chan RX DROP: short frame (len=%d)\n", len);
-		bri_hdlc_abort(xpd, dchan, DAHDI_EVENT_ABORT);
+		dahdi_hdlc_abort(dchan, DAHDI_EVENT_ABORT);
 		return -EPROTO;
 	}
-#endif
 	status = buf[len-1];
 	if(status) {
 		int	event = DAHDI_EVENT_ABORT;
@@ -487,132 +444,12 @@ static int bri_check_stat(xpd_t *xpd, struct dahdi_chan *dchan, byte *buf, int l
 			event = DAHDI_EVENT_BADFCS;
 		}
 		dump_hex_buf(xpd, "D-Chan RX:    current packet", buf, len);
-		bri_hdlc_abort(xpd, dchan, event);
+		dahdi_hdlc_abort(dchan, event);
 		return -EPROTO;
 	}
 	return 0;
 }
 
-static int bri_hdlc_putbuf(xpd_t *xpd, struct dahdi_chan *dchan,
-		unsigned char *buf, int len)
-{
-#ifdef	CONFIG_DAHDI_BRI_DCHANS
-	struct BRI_priv_data	*priv;
-	byte			*dchan_buf;
-	byte			*dst;
-	int			idx;
-
-	priv = xpd->priv;
-	BUG_ON(!priv);
-	dchan_buf = dchan->readchunk;
-	idx = priv->dchan_r_idx;
-	if(idx + len >= DCHAN_BUFSIZE) {
-		XPD_ERR(xpd, "D-Chan RX overflow: %d\n", idx);
-		dump_hex_buf(xpd, "    current packet", buf, len);
-		dump_hex_buf(xpd, "    dchan_buf", dchan_buf, idx);
-		return -ENOSPC;
-	}
-	dst = dchan_buf + idx;
-	idx += len;
-	priv->dchan_r_idx = idx;
-	memcpy(dst, buf, len);
-#else
-	dahdi_hdlc_putbuf(dchan, buf, len);
-#endif
-	return 0;
-}
-
-static void bri_hdlc_finish(xpd_t *xpd, struct dahdi_chan *dchan)
-{
-	struct BRI_priv_data	*priv;
-
-	priv = xpd->priv;
-	BUG_ON(!priv);
-#ifdef	CONFIG_DAHDI_BRI_DCHANS
-	dchan->bytes2receive = priv->dchan_r_idx - 1;
-	dchan->eofrx = 1;
-#else
-	dahdi_hdlc_finish(dchan);
-#endif
-}
-
-#ifdef	CONFIG_DAHDI_BRI_DCHANS
-static int rx_dchan(xpd_t *xpd, reg_cmd_t *regcmd)
-{
-	struct BRI_priv_data	*priv;
-	byte			*src;
-	byte			*dst;
-	byte			*dchan_buf;
-	struct dahdi_chan		*dchan;
-	uint			len;
-	bool			eoframe;
-	int			idx;
-	int			ret = 0;
-
-	src = REG_XDATA(regcmd);
-	len = regcmd->bytes;
-	eoframe = regcmd->eoframe;
-	if(len <= 0)
-		return 0;
-	if(!SPAN_REGISTERED(xpd)) /* Nowhere to copy data */
-		return 0;
-	BUG_ON(!xpd);
-	priv = xpd->priv;
-	BUG_ON(!priv);
-	xbus = xpd->xbus;
-	dchan = XPD_CHAN(xpd, 2);
-	if(!IS_OFFHOOK(xpd, 2)) {	/* D-chan is used? */
-		static int rate_limit;
-
-		if((rate_limit++ % 1000) == 0)
-			XPD_DBG(SIGNAL, xpd, "D-Chan unused\n");
-		dchan->bytes2receive = 0;
-		dchan->bytes2transmit = 0;
-		goto out;
-	}
-	dchan_buf = dchan->readchunk;
-	idx = priv->dchan_r_idx;
-	if(idx + len >= DCHAN_BUFSIZE) {
-		XPD_ERR(xpd, "D-Chan RX overflow: %d\n", idx);
-		dump_hex_buf(xpd, "    current packet", src, len);
-		dump_hex_buf(xpd, "    dchan_buf", dchan_buf, idx);
-		ret = -ENOSPC;
-		if(eoframe)
-			goto drop;
-		goto out;
-	}
-	dst = dchan_buf + idx;
-	idx += len;
-	priv->dchan_r_idx = idx;
-	memcpy(dst, src, len);
-	if(!eoframe)
-		goto out;
-	if(idx < 4) {
-		XPD_NOTICE(xpd, "D-Chan RX short frame (idx=%d)\n", idx);
-		dump_hex_buf(xpd, "D-Chan RX:    current packet", src, len);
-		dump_hex_buf(xpd, "D-Chan RX:    chan_buf", dchan_buf, idx);
-		ret = -EPROTO;
-		goto drop;
-	}
-	if((ret = bri_check_stat(xpd, dchan, dchan_buf, idx)) < 0)
-		goto drop;
-	if(debug)
-		dump_dchan_packet(xpd, 0, dchan_buf, idx /* - 3 */);	/* Print checksum? */
-	/* 
-	 * Tell Dahdi that we received idx-1 bytes. They include the data and a 2-byte checksum.
-	 * The last byte (that we don't pass on) is 0 if the checksum is correct. If it were wrong,
-	 * we would drop the packet in the "if(dchan_buf[idx-1])" above.
-	 */
-	dchan->bytes2receive = idx - 1;
-	dchan->eofrx = 1;
-	priv->dchan_rx_counter++;
-	priv->dchan_norx_ticks = 0;
-drop:
-	priv->dchan_r_idx = 0;
-out:
-	return ret;
-}
-#else
 static int rx_dchan(xpd_t *xpd, reg_cmd_t *regcmd)
 {
 	struct BRI_priv_data	*priv;
@@ -638,16 +475,10 @@ static int rx_dchan(xpd_t *xpd, reg_cmd_t *regcmd)
 
 		if((rate_limit++ % 1000) == 0)
 			XPD_DBG(SIGNAL, xpd, "D-Chan unused\n");
-#ifdef	CONFIG_DAHDI_BRI_DCHANS
-		dchan->bytes2receive = 0;
-		dchan->bytes2transmit = 0;
-#endif
 		goto out;
 	}
 	XPD_DBG(GENERAL, xpd, "D-Chan RX: eoframe=%d len=%d\n", eoframe, len);
-	ret = bri_hdlc_putbuf(xpd, dchan, src, (eoframe) ? len - 1 : len);
-	if(ret < 0)
-		goto out;
+	dahdi_hdlc_putbuf(dchan, src, (eoframe) ? len - 1 : len);
 	if(!eoframe)
 		goto out;
 	if((ret = bri_check_stat(xpd, dchan, src, len)) < 0)
@@ -657,18 +488,16 @@ static int rx_dchan(xpd_t *xpd, reg_cmd_t *regcmd)
 	 * The last byte (that we don't pass on) is 0 if the checksum is correct. If it were wrong,
 	 * we would drop the packet in the "if(src[len-1])" above.
 	 */
-	bri_hdlc_finish(xpd, dchan);
+	dahdi_hdlc_finish(dchan);
 	priv->dchan_rx_counter++;
 	priv->dchan_norx_ticks = 0;
 out:
 	return ret;
 }
-#endif
 
 /*
  * D-Chan transmit
  */
-#ifndef	CONFIG_DAHDI_BRI_DCHANS
 /* DAHDI calls this when it has data it wants to send to the HDLC controller */
 static void bri_hdlc_hard_xmit(struct dahdi_chan *chan)
 {
@@ -683,86 +512,129 @@ static void bri_hdlc_hard_xmit(struct dahdi_chan *chan)
 		atomic_inc(&priv->hdlc_pending);
 	}
 }
-#endif
 
-static int bri_hdlc_getbuf(struct dahdi_chan *dchan, unsigned char *buf,
-		unsigned int *size)
+static int send_dchan_frame(xpd_t *xpd, xframe_t *xframe, bool is_eof)
 {
-	int			len = *size;
-	int			eoframe;
-
-#ifdef	CONFIG_DAHDI_BRI_DCHANS
-	len = dchan->bytes2transmit;	/* dchan's hdlc package len */
-	if(len > *size)
-		len = *size;		/* Silent truncation */
-	eoframe = dchan->eoftx;		/* dchan's end of frame */
-	dchan->bytes2transmit = 0;
-	dchan->eoftx = 0;
-	dchan->bytes2receive = 0;
-	dchan->eofrx = 0;
-#else
-	eoframe = dahdi_hdlc_getbuf(dchan, buf, &len);
-#endif
-	*size = len;
-	return eoframe;
-}
-
-static int tx_dchan(xpd_t *xpd)
-{
-	struct BRI_priv_data	*priv;
-	struct dahdi_chan	*dchan;
-	int			len;
-	int			eoframe;
-	int			ret;
+	struct BRI_priv_data *priv;
+	int ret;
 
+	XPD_DBG(COMMANDS, xpd, "eoframe=%d\n", is_eof);
 	priv = xpd->priv;
-	BUG_ON(!priv);
-#ifndef	CONFIG_DAHDI_BRI_DCHANS
-	if(atomic_read(&priv->hdlc_pending) == 0)
-		return 0;
-#endif
-	if(!SPAN_REGISTERED(xpd) || !(PHONEDEV(xpd).span.flags & DAHDI_FLAG_RUNNING))
-		return 0;
-	dchan = XPD_CHAN(xpd, 2);
-	len = ARRAY_SIZE(priv->dchan_tbuf);
-	if(len > MULTIBYTE_MAX_LEN)
-		len = MULTIBYTE_MAX_LEN;
-	eoframe = bri_hdlc_getbuf(dchan, priv->dchan_tbuf, &len);
-	if(len <= 0)
-		return 0; /* Nothing to transmit on D channel */
-	if(len > MULTIBYTE_MAX_LEN) {
-		XPD_ERR(xpd, "%s: len=%d. need to split. Unimplemented.\n", __FUNCTION__, len);
-		dump_hex_buf(xpd, "D-Chan TX:", priv->dchan_tbuf, len);
-		return -EINVAL;
-	}
-	if(!test_bit(HFC_L1_ACTIVATED, &priv->l1_flags) && !test_bit(HFC_L1_ACTIVATING, &priv->l1_flags)) {
+	if (!test_bit(HFC_L1_ACTIVATED, &priv->l1_flags)
+			&& !test_bit(HFC_L1_ACTIVATING, &priv->l1_flags)) {
 		XPD_DBG(SIGNAL, xpd, "Want to transmit: Kick D-Channel transmiter\n");
-		if(! IS_NT(xpd))
+		if (!IS_NT(xpd))
 			te_activation(xpd, 1);
 		else
 			nt_activation(xpd, 1);
 	}
-	if(debug)
-		dump_dchan_packet(xpd, 1, priv->dchan_tbuf, len);
-	if(eoframe)
-		priv->txframe_begin = 1;
-	else
-		priv->txframe_begin = 0;
-	XPD_DBG(COMMANDS, xpd, "eoframe=%d len=%d\n", eoframe, len);
-	ret = send_multibyte_request(xpd->xbus, xpd->addr.unit, xpd->addr.subunit,
-			eoframe, priv->dchan_tbuf, len);
-	if(ret < 0)
-		XPD_NOTICE(xpd, "%s: failed sending xframe\n", __FUNCTION__);
-	if(eoframe) {
-#ifndef	CONFIG_DAHDI_BRI_DCHANS
+	dump_xframe("send_dchan_frame", xpd->xbus, xframe, debug);
+	ret = send_cmd_frame(xpd->xbus, xframe);
+	if (ret < 0)
+		XPD_ERR(xpd, "%s: failed sending xframe\n", __func__);
+	if (is_eof) {
 		atomic_dec(&priv->hdlc_pending);
-#endif
 		priv->dchan_tx_counter++;
-	}
+		priv->txframe_begin = 1;
+	} else
+		priv->txframe_begin = 0;
 	priv->dchan_notx_ticks = 0;
 	return ret;
 }
 
+/*
+ * Fill a single multibyte REGISTER_REQUEST
+ */
+static void fill_multibyte(xpd_t *xpd, xpacket_t *pack, bool eoframe,
+		char *buf, int len)
+{
+	reg_cmd_t *reg_cmd;
+	char *p;
+
+	XPACKET_INIT(pack, GLOBAL, REGISTER_REQUEST, xpd->xbus_idx, 0, 0);
+	XPACKET_LEN(pack) = RPACKET_SIZE(GLOBAL, REGISTER_REQUEST);
+	reg_cmd = &RPACKET_FIELD(pack, GLOBAL, REGISTER_REQUEST, reg_cmd);
+	reg_cmd->bytes = len;
+	reg_cmd->is_multibyte = 1;
+	reg_cmd->portnum = xpd->addr.subunit;
+	reg_cmd->eoframe = eoframe;
+	p = REG_XDATA(reg_cmd);
+	memcpy(p, buf, len);
+	if (debug)
+		dump_dchan_packet(xpd, 1, p, len);
+}
+
+/*
+ * Transmit available D-Channel frames
+ *
+ * - FPGA firmware expect to get this as a sequence of REGISTER_REQUEST
+ *   multibyte commands.
+ * - The payload of each command is limited to MULTIBYTE_MAX_LEN bytes.
+ * - We batch several REGISTER_REQUEST packets into a single xframe.
+ * - The xframe is terminated when we get a bri "end of frame"
+ *   or when the xframe is full (should not happen).
+ */
+static int tx_dchan(xpd_t *xpd)
+{
+	struct BRI_priv_data *priv;
+	xframe_t *xframe;
+	xpacket_t *pack;
+	int packet_count;
+	int eoframe;
+	int ret;
+
+	priv = xpd->priv;
+	BUG_ON(!priv);
+	if (atomic_read(&priv->hdlc_pending) == 0)
+		return 0;
+	if (!SPAN_REGISTERED(xpd) ||
+			!(PHONEDEV(xpd).span.flags & DAHDI_FLAG_RUNNING))
+		return 0;
+	/* Allocate frame */
+	xframe = ALLOC_SEND_XFRAME(xpd->xbus);
+	if (!xframe) {
+		XPD_NOTICE(xpd, "%s: failed to allocate new xframe\n",
+			__func__);
+		return -ENOMEM;
+	}
+	for (packet_count = 0, eoframe = 0; !eoframe; packet_count++) {
+		int packet_len = RPACKET_SIZE(GLOBAL, REGISTER_REQUEST);
+		char buf[MULTIBYTE_MAX_LEN];
+		int len = MULTIBYTE_MAX_LEN;
+
+		/* Reserve packet */
+		pack = xframe_next_packet(xframe, packet_len);
+		if (!pack) {
+			BUG_ON(!packet_count);
+			/*
+			 * A split. Send what we currently have.
+			 */
+			XPD_NOTICE(xpd,
+				"%s: xframe is full (%d packets)\n",
+				__func__, packet_count);
+			break;
+		}
+		/* Get data from DAHDI */
+		eoframe = dahdi_hdlc_getbuf(XPD_CHAN(xpd, 2), buf, &len);
+		if (len <= 0) {
+			/*
+			 * Already checked priv->hdlc_pending,
+			 * should never get here.
+			 */
+			if (printk_ratelimit())
+				XPD_ERR(xpd,
+					"%s: hdlc_pending, but nothing to transmit?\n",
+					__func__);
+			FREE_SEND_XFRAME(xpd->xbus, xframe);
+			return -EINVAL;
+		}
+		BUG_ON(len > MULTIBYTE_MAX_LEN);
+		fill_multibyte(xpd, pack, eoframe != 0, buf, len);
+	}
+	return send_dchan_frame(xpd, xframe, eoframe != 0);
+	return ret;
+}
+
 /*---------------- BRI: Methods -------------------------------------------*/
 
 static void bri_proc_remove(xbus_t *xbus, xpd_t *xpd)
@@ -853,9 +725,7 @@ static const struct dahdi_span_ops BRI_span_ops = {
 	.chanconfig = bri_chanconfig,
 	.startup = bri_startup,
 	.shutdown = bri_shutdown,
-#ifndef	CONFIG_DAHDI_BRI_DCHANS
 	.hdlc_hard_xmit = bri_hdlc_hard_xmit,
-#endif
 	.open = xpp_open,
 	.close = xpp_close,
 	.hooksig = xpp_hooksig,	/* Only with RBS bits */
@@ -904,19 +774,7 @@ static int BRI_card_dahdi_preregistration(xpd_t *xpd, bool on)
 			cur_chan->sigcap = BRI_DCHAN_SIGCAP;
 			clear_bit(DAHDI_FLAGBIT_HDLC, &cur_chan->flags);
 			priv->txframe_begin = 1;
-#ifdef	CONFIG_DAHDI_BRI_DCHANS
-			priv->dchan_r_idx = 0;
-			set_bit(DAHDI_FLAGBIT_BRIDCHAN, &cur_chan->flags);
-			/* Setup big buffers for D-Channel rx/tx */
-			cur_chan->readchunk = priv->dchan_rbuf;
-			cur_chan->writechunk = priv->dchan_tbuf;
-
-			cur_chan->maxbytes2transmit = MULTIBYTE_MAX_LEN;
-			cur_chan->bytes2transmit = 0;
-			cur_chan->bytes2receive = 0;
-#else
 			atomic_set(&priv->hdlc_pending, 0);
-#endif
 		} else {
 			cur_chan->sigcap = BRI_BCHAN_SIGCAP;
 		}
@@ -1146,15 +1004,6 @@ static int BRI_card_open(xpd_t *xpd, lineno_t pos)
 static int BRI_card_close(xpd_t *xpd, lineno_t pos)
 {
 	/* Clear D-Channel pending data */
-#ifdef	CONFIG_DAHDI_BRI_DCHANS
-	struct dahdi_chan	*chan = XPD_CHAN(xpd, pos);
-
-	/* Clear D-Channel pending data */
-	chan->bytes2receive = 0;
-	chan->eofrx = 0;
-	chan->bytes2transmit = 0;
-	chan->eoftx = 0;
-#endif
 	if(pos == 2) {
 		LINE_DBG(SIGNAL, xpd, pos, "ONHOOK the whole span\n");
 		BIT_CLR(PHONEDEV(xpd).offhook_state, 0);
@@ -1202,6 +1051,8 @@ static int bri_spanconfig(struct file *file, struct dahdi_span *span,
 		framingstr, codingstr, crcstr,
 		lc->lineconfig,
 		lc->sync);
+	PHONEDEV(xpd).timing_priority = lc->sync;
+	elect_syncer("BRI-spanconfig");
 	/*
 	 * FIXME: validate
 	 */
@@ -1253,9 +1104,6 @@ static int bri_startup(struct file *file, struct dahdi_span *span)
 		 *
 		 * Don't Get Mad, Get Even:  Now we override dahdi :-)
 		 */
-#ifdef	CONFIG_DAHDI_BRI_DCHANS
-		set_bit(DAHDI_FLAGBIT_BRIDCHAN, &dchan->flags);
-#endif
 		clear_bit(DAHDI_FLAGBIT_HDLC, &dchan->flags);
 	}
 	return 0;
@@ -1429,6 +1277,18 @@ static void BRI_card_pcm_tospan(xpd_t *xpd, xpacket_t *pack)
 	}
 }
 
+static int BRI_timing_priority(xpd_t *xpd)
+{
+	struct BRI_priv_data	*priv;
+
+	priv = xpd->priv;
+	BUG_ON(!priv);
+	if (priv->layer1_up)
+		return PHONEDEV(xpd).timing_priority;
+	XPD_DBG(SYNC, xpd, "No timing priority (no layer1)\n");
+	return -ENOENT;
+}
+
 int BRI_echocancel_timeslot(xpd_t *xpd, int pos)
 {
 	return xpd->addr.subunit * 4 + pos;
@@ -1696,7 +1556,7 @@ static const struct phoneops	bri_phoneops = {
 	.card_pcm_recompute	= BRI_card_pcm_recompute,
 	.card_pcm_fromspan	= BRI_card_pcm_fromspan,
 	.card_pcm_tospan	= BRI_card_pcm_tospan,
-	.card_timing_priority	= generic_timing_priority,
+	.card_timing_priority	= BRI_timing_priority,
 	.echocancel_timeslot	= BRI_echocancel_timeslot,
 	.echocancel_setmask	= BRI_echocancel_setmask,
 	.card_ioctl	= BRI_card_ioctl,
@@ -1776,9 +1636,6 @@ static int proc_bri_info_read(char *page, char **start, off_t off, int count, in
 	} else {
 		len += sprintf(page + len, "(dead)\n");
 	}
-#ifndef	CONFIG_DAHDI_BRI_DCHANS
-	len += sprintf(page + len, "hdlc_pending=%d\n", atomic_read(&priv->hdlc_pending));
-#endif
 	len += sprintf(page + len, "dchan_notx_ticks: %d\n", priv->dchan_notx_ticks);
 	len += sprintf(page + len, "dchan_norx_ticks: %d\n", priv->dchan_norx_ticks);
 	len += sprintf(page + len, "LED: %-10s = %d\n", "GREEN", priv->ledstate[GREEN_LED]);
@@ -1798,22 +1655,6 @@ static int proc_bri_info_read(char *page, char **start, off_t off, int count, in
 }
 #endif
 
-static DRIVER_ATTR_READER(dchan_hardhdlc_show, drv,buf)
-{
-	int			len = 0;
-
-#if	defined(CONFIG_DAHDI_BRI_DCHANS)
-	len += sprintf(buf + len, "0\n");
-#elif	defined(DAHDI_SIG_HARDHDLC)
-	len += sprintf(buf + len, "1\n");
-#else
-#error Cannot build BRI without BRISTUFF or HARDHDLC supprt
-#endif
-	return len;
-}
-
-static	DRIVER_ATTR(dchan_hardhdlc,S_IRUGO,dchan_hardhdlc_show,NULL);
-
 static int bri_xpd_probe(struct device *dev)
 {
 	xpd_t	*xpd;
@@ -1856,18 +1697,7 @@ static int __init card_bri_startup(void)
 
 	if((ret = xpd_driver_register(&bri_driver.driver)) < 0)
 		return ret;
-	ret = driver_create_file(&bri_driver.driver, &driver_attr_dchan_hardhdlc);
-	if(ret < 0)
-		return ret;
 	INFO("revision %s\n", XPP_VERSION);
-#if	defined(CONFIG_DAHDI_BRI_DCHANS)
-	INFO("FEATURE: WITH BRISTUFF\n");
-#elif	defined(DAHDI_SIG_HARDHDLC)
-	INFO("FEATURE: WITH HARDHDLC\n");
-#else
-#error Cannot build BRI without BRISTUFF or HARDHDLC supprt
-#endif
-
 	xproto_register(&PROTO_TABLE(BRI));
 	return 0;
 }
@@ -1876,7 +1706,6 @@ static void __exit card_bri_cleanup(void)
 {
 	DBG(GENERAL, "\n");
 	xproto_unregister(&PROTO_TABLE(BRI));
-	driver_remove_file(&bri_driver.driver, &driver_attr_dchan_hardhdlc);
 	xpd_driver_unregister(&bri_driver.driver);
 }
 

drivers/dahdi/xpp/card_fxs.c

@@ -42,6 +42,8 @@ static DEF_PARM(uint, poll_digital_inputs, 1000, 0644, "Poll Digital Inputs");
 
 static DEF_PARM_BOOL(vmwi_ioctl, 1, 0644, "Asterisk support VMWI notification via ioctl");
 static DEF_PARM_BOOL(ring_trapez, 0, 0664, "Use trapezoid ring type");
+static DEF_PARM_BOOL(lower_ringing_noise, 0, 0664,
+		"Lower ringing noise (may loose CallerID)");
 
 /* Signaling is opposite (fxo signalling for fxs card) */
 #if 1
@@ -134,6 +136,8 @@ struct FXS_priv_data {
 	xpp_line_t		want_dtmf_events;	/* what dahdi want */
 	xpp_line_t		want_dtmf_mute;		/* what dahdi want */
 	xpp_line_t		prev_key_down;		/* DTMF down sets the bit */
+	xpp_line_t		neon_blinking;
+	xpp_line_t vbat_h;		/* High voltage */
 	struct timeval		prev_key_time[CHANNELS_PERXPD];
 	int			led_counter[NUM_LEDS][CHANNELS_PERXPD];
 	int			ohttimer[CHANNELS_PERXPD];
@@ -156,24 +160,48 @@ struct FXS_priv_data {
 #define	LED_BLINK_RING			(1000/8)	/* in ticks */
 
 /*---------------- FXS: Static functions ----------------------------------*/
-static int linefeed_control(xbus_t *xbus, xpd_t *xpd, lineno_t chan, enum fxs_state value)
-{
-	struct FXS_priv_data	*priv;
-
-	priv = xpd->priv;
-	LINE_DBG(SIGNAL, xpd, chan, "value=0x%02X\n", value);
-	priv->lasttxhook[chan] = value;
-	return SLIC_DIRECT_REQUEST(xbus, xpd, chan, SLIC_WRITE, 0x40, value);
-}
-
 static int do_chan_power(xbus_t *xbus, xpd_t *xpd, lineno_t chan, bool on)
 {
-	int		value = (on) ? REG_BATTERY_BATSL : 0x00;
+	struct FXS_priv_data *priv;
+	unsigned long *p;
+	int was;
 
 	BUG_ON(!xbus);
 	BUG_ON(!xpd);
+	priv = xpd->priv;
+	p = (unsigned long *)&priv->vbat_h;
+	if (on)
+		was = test_and_set_bit(chan, p) != 0;
+	else
+		was = test_and_clear_bit(chan, p) != 0;
+	if (was == on) {
+		LINE_DBG(SIGNAL, xpd, chan,
+			"%s (same, ignored)\n", (on) ? "up" : "down");
+		return 0;
+	}
 	LINE_DBG(SIGNAL, xpd, chan, "%s\n", (on) ? "up" : "down");
-	return SLIC_DIRECT_REQUEST(xbus, xpd, chan, SLIC_WRITE, REG_BATTERY, value);
+	return SLIC_DIRECT_REQUEST(xbus, xpd, chan, SLIC_WRITE, REG_BATTERY,
+			(on) ? REG_BATTERY_BATSL : 0x00);
+}
+
+static int linefeed_control(xbus_t *xbus, xpd_t *xpd, lineno_t chan, enum fxs_state value)
+{
+	struct FXS_priv_data *priv;
+	bool want_vbat_h;
+
+	priv = xpd->priv;
+	/*
+	 * Should we drop vbat_h only during actuall ring?
+	 *   - It would lower the noise caused to other channels by
+	 *     group ringing
+	 *   - But it may also stop CallerID from passing through the SLIC
+	 */
+	want_vbat_h = value == FXS_LINE_RING;
+	if (lower_ringing_noise || want_vbat_h)
+		do_chan_power(xbus, xpd, chan, want_vbat_h);
+	LINE_DBG(SIGNAL, xpd, chan, "value=0x%02X\n", value);
+	priv->lasttxhook[chan] = value;
+	return SLIC_DIRECT_REQUEST(xbus, xpd, chan, SLIC_WRITE, 0x40, value);
 }
 
 static void vmwi_search(xpd_t *xpd, lineno_t pos, bool on)
@@ -564,12 +592,16 @@ static int FXS_card_dahdi_postregistration(xpd_t *xpd, bool on)
  */
 static void __do_mute_dtmf(xpd_t *xpd, int pos, bool muteit)
 {
+	struct FXS_priv_data	*priv;
+
+	priv = xpd->priv;
 	LINE_DBG(SIGNAL, xpd, pos, "%s\n", (muteit) ? "MUTE" : "UNMUTE");
 	if(muteit)
 		BIT_SET(PHONEDEV(xpd).mute_dtmf, pos);
 	else
 		BIT_CLR(PHONEDEV(xpd).mute_dtmf, pos);
-	CALL_PHONE_METHOD(card_pcm_recompute, xpd, 0);	/* already spinlocked */
+	/* already spinlocked */
+	CALL_PHONE_METHOD(card_pcm_recompute, xpd, priv->search_fsk_pattern);
 }
 
 static int set_vm_led_mode(xbus_t *xbus, xpd_t *xpd, int pos,
@@ -584,6 +616,7 @@ static int set_vm_led_mode(xbus_t *xbus, xpd_t *xpd, int pos,
 	if (VMWI_NEON(priv, pos) && msg_waiting) {
 		/* A write to register 0x40 will now turn on/off the VM led */
 		LINE_DBG(SIGNAL, xpd, pos, "NEON\n");
+		BIT_SET(priv->neon_blinking, pos);
 		ret += SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x16, 0xE8, 0x03);
 		ret += SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x15, 0xEF, 0x7B);
 		ret += SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x14, 0x9F, 0x00);
@@ -618,6 +651,7 @@ static int set_vm_led_mode(xbus_t *xbus, xpd_t *xpd, int pos,
 	} else {
 		/* A write to register 0x40 will now turn on/off the ringer */
 		LINE_DBG(SIGNAL, xpd, pos, "RINGER\n");
+		BIT_CLR(priv->neon_blinking, pos);
 
 		ret += SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x16, 0x00, 0x00);
 		ret += SLIC_INDIRECT_REQUEST(xbus, xpd, pos, SLIC_WRITE, 0x15, 0x77, 0x01);
@@ -684,7 +718,7 @@ static int send_ring(xpd_t *xpd, lineno_t chan, bool on)
 	LINE_DBG(SIGNAL, xpd, chan, "%s\n", (on)?"on":"off");
 	priv = xpd->priv;
 	set_vm_led_mode(xbus, xpd, chan, 0);
-	do_chan_power(xbus, xpd, chan, on);		// Power up (for ring)
+	do_chan_power(xbus, xpd, chan, on);	/* Power up (for ring) */
 	ret = linefeed_control(xbus, xpd, chan, value);
 	if(on) {
 		MARK_BLINK(priv, chan, LED_GREEN, LED_BLINK_RING);
@@ -877,7 +911,8 @@ static int FXS_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a
 			if (IS_SET(PHONEDEV(xpd).digital_inputs | PHONEDEV(xpd).digital_outputs, pos))
 				return 0;	/* Nothing to do */
 			oht_pcm(xpd, pos, 1);	/* Get ready of VMWI FSK tones */
-			if(priv->lasttxhook[pos] == FXS_LINE_POL_ACTIVE) {
+			if (priv->lasttxhook[pos] == FXS_LINE_POL_ACTIVE ||
+					IS_SET(priv->neon_blinking, pos)) {
 				priv->ohttimer[pos] = val;
 				priv->idletxhookstate[pos] = FXS_LINE_POL_OHTRANS;
 				vmwi_search(xpd, pos, 1);
@@ -940,10 +975,25 @@ static int FXS_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a
 		case DAHDI_SETPOLARITY:
 			if (get_user(val, (int __user *)arg))
 				return -EFAULT;
-			/* Can't change polarity while ringing or when open */
+			/*
+			 * Asterisk may send us this if chan_dahdi config
+			 * has "hanguponpolarityswitch=yes" to notify
+			 * that the other side has hanged up.
+			 *
+			 * This has no effect on normal phone (but we may
+			 * be connected to another FXO equipment).
+			 * note that this chan_dahdi settings has different
+			 * meaning for FXO, where it signals polarity
+			 * reversal *detection* logic.
+			 *
+			 * It seems that sometimes we get this from
+			 * asterisk in wrong state (e.g: while ringing).
+			 * In these cases, silently ignore it.
+			 */
 			if (priv->lasttxhook[pos] == FXS_LINE_RING || priv->lasttxhook[pos] == FXS_LINE_OPEN) {
-				LINE_ERR(xpd, pos, "DAHDI_SETPOLARITY: %s Cannot change when lasttxhook=0x%X\n",
-						(val)?"ON":"OFF", priv->lasttxhook[pos]);
+				LINE_DBG(SIGNAL, xpd, pos,
+					"DAHDI_SETPOLARITY: %s Cannot change when lasttxhook=0x%X\n",
+					(val)?"ON":"OFF", priv->lasttxhook[pos]);
 				return -EINVAL;
 			}
 			LINE_DBG(SIGNAL, xpd, pos, "DAHDI_SETPOLARITY: %s\n", (val)?"ON":"OFF");
@@ -1045,7 +1095,8 @@ static void handle_linefeed(xpd_t *xpd)
 	priv = xpd->priv;
 	BUG_ON(!priv);
 	for_each_line(xpd, i) {
-		if (priv->lasttxhook[i] == FXS_LINE_RING) {
+		if (priv->lasttxhook[i] == FXS_LINE_RING &&
+				!IS_SET(priv->neon_blinking, i)) {
 			/* RINGing, prepare for OHT */
 			priv->ohttimer[i] = OHT_TIMER;
 			priv->idletxhookstate[i] = FXS_LINE_POL_OHTRANS;
@@ -1499,11 +1550,13 @@ static int proc_fxs_info_read(char *page, char **start, off_t off, int count, in
 	spin_lock_irqsave(&xpd->lock, flags);
 	priv = xpd->priv;
 	BUG_ON(!priv);
-	len += sprintf(page + len, "%-8s %-10s %-10s %-10s\n",
+	len += sprintf(page + len, "%-8s %-10s %-10s %-10s %-10s %-10s\n",
 			"Channel",
 			"idletxhookstate",
 			"lasttxhook",
-			"ohttimer"
+			"ohttimer",
+			"neon_blinking",
+			"search_fsk_pattern"
 			);
 	for_each_line(xpd, i) {
 		char	pref;
@@ -1514,14 +1567,21 @@ static int proc_fxs_info_read(char *page, char **start, off_t off, int count, in
 			pref = 'I';
 		else
 			pref = ' ';
-		len += sprintf(page + len, "%c%7d %10d %10d %10d\n",
+		len += sprintf(page + len, "%c%7d %10d %10d %10d %10d %10d\n",
 				pref,
 				i,
 				priv->idletxhookstate[i],
 				priv->lasttxhook[i],
-				priv->ohttimer[i]
+				priv->ohttimer[i],
+				IS_SET(priv->neon_blinking, i),
+				IS_SET(priv->search_fsk_pattern, i)
 			      );
 	}
+	len += sprintf(page + len, "\n%-12s", "vbat_h:");
+	for_each_line(xpd, i) {
+		len += sprintf(page + len, "%4d",
+			test_bit(i, (unsigned long *)&priv->vbat_h));
+	}
 	len += sprintf(page + len, "\n");
 	for(led = 0; led < NUM_LEDS; led++) {
 		len += sprintf(page + len, "LED #%d", led);

drivers/dahdi/xpp/card_global.c

@@ -40,6 +40,36 @@ extern	int debug;
 
 /*---------------- GLOBAL PROC handling -----------------------------------*/
 
+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;
+
+	/*
+	 * Zero length multibyte is legal and has special meaning for the
+	 * firmware:
+	 *   eoftx==1: Start sending us D-channel packets.
+	 *   eoftx==0: Stop sending us D-channel packets.
+	 */
+	XFRAME_NEW_CMD(xframe, pack, xbus, GLOBAL, REGISTER_REQUEST, unit);
+	reg_cmd = &RPACKET_FIELD(pack, GLOBAL, REGISTER_REQUEST, reg_cmd);
+	reg_cmd->bytes = 0;
+	reg_cmd->is_multibyte = 1;
+	reg_cmd->portnum = portno;
+	reg_cmd->eoframe = eoftx;
+	PORT_DBG(REGS, xbus, unit, portno, "Magic Packet (eoftx=%d)\n", eoftx);
+	if (debug & DBG_REGS)
+		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__);
+	return ret;
+}
+
 static int parse_hexbyte(const char *buf)
 {
 	char		*endp;
@@ -155,8 +185,8 @@ static int execute_chip_command(xpd_t *xpd, const int argc, char *argv[])
 					addr_mode, argc - argno);
 			goto out;
 		}
-		ret = send_multibyte_request(xpd->xbus, xpd->addr.unit, portno,
-			addr_mode == 'm', NULL, 0);
+		ret = send_magic_request(xpd->xbus, xpd->addr.unit, portno,
+			addr_mode == 'm');
 		goto out;
 	}
 	/* Normal (non-Magic) register commands */
@@ -370,44 +400,6 @@ int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno,
 	return ret;
 }
 
-int send_multibyte_request(xbus_t *xbus,
-	unsigned unit, xportno_t portno,
-	bool eoftx, byte *buf, unsigned len)
-{
-	xframe_t	*xframe;
-	xpacket_t	*pack;
-	reg_cmd_t	*reg_cmd;
-	int		ret;
-
-	/*
-	 * Zero length multibyte is legal and has special meaning for the
-	 * firmware:
-	 *   eoftx==1: Start sending us D-channel packets.
-	 *   eoftx==0: Stop sending us D-channel packets.
-	 */
-	if(len > MULTIBYTE_MAX_LEN) {
-		PORT_ERR(xbus, unit, portno, "%s: len=%d is too long. dropping.\n", __FUNCTION__, len);
-		return -EINVAL;
-	}
-	XFRAME_NEW_CMD(xframe, pack, xbus, GLOBAL, REGISTER_REQUEST, unit);
-	reg_cmd = &RPACKET_FIELD(pack, GLOBAL, REGISTER_REQUEST, reg_cmd);
-	reg_cmd->bytes = len;
-	reg_cmd->is_multibyte = 1;
-	reg_cmd->portnum = portno;
-	reg_cmd->eoframe = eoftx;
-	if(len > 0) {
-		memcpy(REG_XDATA(reg_cmd), (byte *)buf, len);
-	} else {
-		PORT_DBG(REGS, xbus, unit, portno, "Magic Packet (eoftx=%d)\n", eoftx);
-	}
-	if(debug & DBG_REGS)
-		dump_xframe(__FUNCTION__, xbus, xframe, debug);
-	ret = send_cmd_frame(xbus, xframe);
-	if(ret < 0)
-		PORT_ERR(xbus, unit, portno, "%s: failed sending xframe\n", __FUNCTION__);
-	return ret;
-}
-
 /*
  * The XPD parameter is totaly ignored by the driver and firmware as well.
  */
@@ -430,19 +422,37 @@ int send_multibyte_request(xbus_t *xbus,
 	return 0;
 }
 
-/* 0x23 */ HOSTCMD(GLOBAL, RESET_SYNC_COUNTERS)
+/*
+ * Wrapper for different types of xbus reset
+ */
+static int send_xbus_reset(xbus_t *xbus, uint8_t reset_mask)
 {
 	xframe_t	*xframe;
 	xpacket_t	*pack;
 
 	BUG_ON(!xbus);
-	//XBUS_DBG(SYNC, xbus, "\n");
-	XFRAME_NEW_CMD(xframe, pack, xbus, GLOBAL, RESET_SYNC_COUNTERS, 0);
-	RPACKET_FIELD(pack, GLOBAL, RESET_SYNC_COUNTERS, mask) = 0x10;
+	XFRAME_NEW_CMD(xframe, pack, xbus, GLOBAL, XBUS_RESET, 0);
+	RPACKET_FIELD(pack, GLOBAL, XBUS_RESET, mask) = reset_mask;
 	send_cmd_frame(xbus, xframe);
 	return 0;
 }
 
+/* 0x23 */ HOSTCMD(GLOBAL, RESET_SPI)
+{
+	XBUS_DBG(DEVICES, xbus, "Sending SPI reset\n");
+	/* toggle reset line */
+	send_xbus_reset(xbus, 0x04);
+	send_xbus_reset(xbus, 0x00);
+	return 0;
+}
+
+
+/* 0x23 */ HOSTCMD(GLOBAL, RESET_SYNC_COUNTERS)
+{
+	//XBUS_DBG(SYNC, xbus, "\n");
+	return send_xbus_reset(xbus, 0x10);
+}
+
 /*---------------- GLOBAL: Astribank Reply Handlers -----------------------*/
 
 HANDLER_DEF(GLOBAL, NULL_REPLY)
@@ -534,6 +544,7 @@ HANDLER_DEF(GLOBAL, AB_DESCRIPTION)	/* 0x08 */
 		list_add_tail(&card_desc->card_list, &worker->card_list);
 		spin_unlock_irqrestore(&worker->worker_lock, flags);
 	}
+	CALL_PROTO(GLOBAL, RESET_SPI, xbus, NULL);
 	if (!xbus_process_worker(xbus)) {
 		ret = -ENODEV;
 		goto out;
@@ -752,4 +763,3 @@ err:
 EXPORT_SYMBOL(sync_mode_name);
 EXPORT_SYMBOL(run_initialize_registers);
 EXPORT_SYMBOL(xpp_register_request);
-EXPORT_SYMBOL(send_multibyte_request);

drivers/dahdi/xpp/card_global.h

@@ -38,7 +38,7 @@ enum global_opcodes {
 	XPROTO_NAME(GLOBAL, SYNC_REPLY)		= 0x1A,
 /**/
 	XPROTO_NAME(GLOBAL, ERROR_CODE)		= 0x22,
-	XPROTO_NAME(GLOBAL, RESET_SYNC_COUNTERS)	= 0x23,
+	XPROTO_NAME(GLOBAL, XBUS_RESET)	= 0x23,
 	XPROTO_NAME(GLOBAL, NULL_REPLY)		= 0xFE,
 };
 
@@ -87,7 +87,7 @@ DEF_RPACKET_DATA(GLOBAL, SYNC_REPLY,
 DEF_RPACKET_DATA(GLOBAL, REGISTER_REPLY,
 	reg_cmd_t	regcmd;
 	);
-DEF_RPACKET_DATA(GLOBAL, RESET_SYNC_COUNTERS,
+DEF_RPACKET_DATA(GLOBAL, XBUS_RESET,
 	byte		mask;
 	);
 DEF_RPACKET_DATA(GLOBAL, ERROR_CODE,
@@ -98,6 +98,7 @@ DEF_RPACKET_DATA(GLOBAL, ERROR_CODE,
 
 /* 0x07 */ DECLARE_CMD(GLOBAL, AB_REQUEST);
 /* 0x19 */ DECLARE_CMD(GLOBAL, SYNC_SOURCE, enum sync_mode mode, int drift);
+/* 0x23 */ DECLARE_CMD(GLOBAL, RESET_SPI);
 /* 0x23 */ DECLARE_CMD(GLOBAL, RESET_SYNC_COUNTERS);
 
 int xpp_register_request(xbus_t *xbus, xpd_t *xpd, xportno_t portno,

drivers/dahdi/xpp/card_pri.c

@@ -1034,6 +1034,17 @@ static int pri_lineconfig(xpd_t *xpd, int lineconfig)
 	}
 #endif
 	if(force_cas) {
+		if(priv->pri_protocol == PRI_PROTO_E1) {
+			int	rs1 = 0x0B;
+
+			/*
+			 * Set correct X1-X3 bits in the E1 CAS MFAS
+			 * They are unused in E1 and should be 1
+			 */
+			XPD_DBG(GENERAL, xpd, "%s: rs1(0x%02X) = 0x%02X\n",
+				__FUNCTION__, REG_RS1_E, rs1);
+			write_subunit(xpd, REG_RS1_E, rs1);
+		}
 		xsp |= REG_XSP_E_CASEN;	/* Same as REG_FMR5_T_EIBR for T1 */
 	}
 	XPD_DBG(GENERAL, xpd, "%s: xsp(0x%02X) = 0x%02X\n", __FUNCTION__, REG_XSP_E, xsp);
@@ -1467,14 +1478,17 @@ static int PRI_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a
 		return -ENODEV;
 	chan = XPD_CHAN(xpd, pos);
 	switch (cmd) {
+		/*
+		 * Asterisk may send FXS type ioctl()'s to us:
+		 *   - Some are sent to everybody (DAHDI_TONEDETECT)
+		 *   - Some are sent because we may be in CAS mode
+		 *     (FXS signalling)
+		 * Ignore them.
+		 */
 		case DAHDI_TONEDETECT:
-			/*
-			 * Asterisk call all span types with this (FXS specific)
-			 * call. Silently ignore it.
-			 */
 			LINE_DBG(SIGNAL, xpd, pos, "PRI: TONEDETECT (%s)\n",
 				(chan->flags & DAHDI_FLAG_AUDIO) ?
-					"AUDIO" : "SILENCE");
+				"AUDIO" : "SILENCE");
 			return -ENOTTY;
 		case DAHDI_ONHOOKTRANSFER:
 			LINE_DBG(SIGNAL, xpd, pos, "PRI: ONHOOKTRANSFER\n");
@@ -1485,6 +1499,10 @@ static int PRI_card_ioctl(xpd_t *xpd, int pos, unsigned int cmd, unsigned long a
 		case DAHDI_VMWI_CONFIG:
 			LINE_DBG(SIGNAL, xpd, pos, "PRI: VMWI_CONFIG\n");
 			return -ENOTTY;
+		case DAHDI_SETPOLARITY:
+			LINE_DBG(SIGNAL, xpd, pos, "PRI: SETPOLARITY\n");
+			return -ENOTTY;
+		/* report on really bad ioctl()'s */
 		default:
 			report_bad_ioctl(THIS_MODULE->name, xpd, pos, cmd);
 			return -ENOTTY;
@@ -2243,7 +2261,43 @@ static DEVICE_ATTR_READER(pri_protocol_show, dev, buf)
 	return len;
 }
 
-static	DEVICE_ATTR(pri_protocol, S_IRUGO, pri_protocol_show, NULL);
+static DEVICE_ATTR_WRITER(pri_protocol_store, dev, buf, count)
+{
+	xpd_t			*xpd;
+	enum pri_protocol	new_protocol = PRI_PROTO_0;
+	int			i;
+	int			ret;
+
+	BUG_ON(!dev);
+	xpd = dev_to_xpd(dev);
+	XPD_DBG(GENERAL, xpd, "%s\n", buf);
+	if (!xpd)
+		return -ENODEV;
+	i = strcspn(buf, " \r\n");
+	if (i != 2) {
+		XPD_NOTICE(xpd,
+			"Protocol name '%s' has %d characters (should be 2). Ignored.\n",
+			buf, i);
+		return -EINVAL;
+	}
+	if (strnicmp(buf, "E1", 2) == 0)
+		new_protocol = PRI_PROTO_E1;
+	else if (strnicmp(buf, "T1", 2) == 0)
+		new_protocol = PRI_PROTO_T1;
+	else if (strnicmp(buf, "J1", 2) == 0)
+		new_protocol = PRI_PROTO_J1;
+	else {
+		XPD_NOTICE(xpd,
+			"Unknown PRI protocol '%s' (should be E1|T1|J1). Ignored.\n",
+			buf);
+		return -EINVAL;
+	}
+	ret = set_pri_proto(xpd, new_protocol);
+	return (ret < 0) ? ret : count;
+}
+
+static	DEVICE_ATTR(pri_protocol, S_IRUGO | S_IWUSR, pri_protocol_show,
+		pri_protocol_store);
 
 static DEVICE_ATTR_READER(pri_localloop_show, dev, buf)
 {

drivers/dahdi/xpp/firmwares/Makefile

@@ -1,10 +1,12 @@
 # Install firmwares and initialization scripts for the Astribank
 # drivers
 
-FPGA_FW		= FPGA_FXS.hex FPGA_1141.hex FPGA_1151.hex FPGA_1161.hex
+USB_FW		= USB_FW.hex USB_FW.201.hex USB_RECOV.hex
+FPGA_FW		= FPGA_FXS.hex FPGA_1141.hex FPGA_1151.hex FPGA_1161.hex  \
+		  FPGA_1161.201.hex
 PIC_FW		= PIC_TYPE_1.hex PIC_TYPE_2.hex PIC_TYPE_3.hex PIC_TYPE_4.hex  
 OCT_FW		= $(wildcard OCT6104E-256D.ima)
-FIRMWARES	= USB_FW.hex $(FPGA_FW) $(PIC_FW) $(OCT_FW)
+FIRMWARES	= $(USB_FW) $(FPGA_FW) $(PIC_FW) $(OCT_FW)
 PROTO_VER	= 30
 SCRIPTS_BASE	= $(patsubst %,init_card_%_$(PROTO_VER),1 2 3 4 5)
 SCRIPTS		= $(SCRIPTS_BASE:%=../%)

drivers/dahdi/xpp/firmwares/PIC_TYPE_1.hex

@@ -1,5 +1,5 @@
 #        
-# $Id: PIC_TYPE_1.hex 9732 2011-08-24 19:13:55Z dima $
+# $Id: PIC_TYPE_1.hex 9841 2011-09-08 17:00:23Z dima $
 #        
 :03000000A1EA4A28
 :03000100C41C41DB
@@ -31,8 +31,8 @@
 :03001B00D00D0005
 :03001C00A17A17AF
 :03001D0080080058
-:03001E00C0710BA3
-:03001F0016603830
+:03001E00C0010B13
+:03001F0019A038ED
 :03002000743C0627
 :03002100A26D804D
 :03002200C01024E7
@@ -42,451 +42,445 @@
 :03002600C03030B7
 :0300270018C901F4
 :030028006432043B
-:03002900A4C03040
+:03002900A4A03060
 :03002A0020C901E9
 :03002B007432022A
-:03002C00AFA03052
-:03002D0020990116
-:03002E00021C8031
-:03002F00C40FFFFC
-:03003000D8016490
-:03003100024C106E
-:03003200C00FFFFD
-:0300330002215057
-:03003400201D0884
-:030035000306B906
-:03003600901D100A
-:0300370020402244
-:03003800030201BF
-:03003900901030F4
-:03003A0020290179
-:03003B00030204B9
-:03003C00901030F1
-:03003D00C11901E5
-:03003E00190202A2
-:03003F00643030FA
-:03004000A45901BF
-:03004100C22800D2
-:030042001902148C
-:03004300743E7098
-:03004400A483088A
-:03004500209308FD
-:030046001253084A
-:03004700A4B30857
-:03004800209027DE
-:03004900FFF800BD
-:03004A00165C0041
-:03004B00AFA0392A
-:03004C00209038C9
-:03004D00145C0739
-:03004E00643D40CE
-:03004F00A8C03412
-:03005000209C08E9
-:0300510002103862
-:03005200C40219CC
-:03005300D80E07BD
-:0300540002402047
-:03005500C0036085
-:0300560002236022
-:0300570020136013
-:030058000303603F
-:03005900901C10E8
-:03005A002040380B
-:03005B0003021984
-:03005C00901E07EC
-:03005D002021203F
-:03005E00030C1080
-:03005F009011807D
-:03006000C11E704E
-:0300610019074339
-:03006200643A728B
-:03006300A68C0266
-:03006400C2218036
-:03006500190E076A
-:03006600743643AA
-:03006700A8CA75AF
-:03006800209C03D6
-:0300690002118001
-:03006A00C44E077A
-:03006B00D8064371
-:03006C00024A75D0
-:03006D00C00C04C0
-:03006E00022180EC
-:03006F00201E0749
-:0300700003064341
-:03007100901A756D
-:03007200204C011E
-:030073000300384F
-:03007400901A746B
-:03007500202C1824
-:030076000300384C
-:03007700901219CB
-:03007800210E0F47
-:03007900E0303D37
-:03007A00743C00D3
-:03007B00C040384A
-:03007C00190C025A
-:03007D007481800B
-:03007E00A8CE0702
-:03007F00C0474334
-:03008000FFFA85FF
-:03008100150C3F1C
-:03008200643031B6
-:03008300A87C1640
-:03008400209A922D
-:0300850013EC0376
-:03008600A8A180AE
-:03008700209E07B1
-:03008800FFF7433C
-:0300890017EA8EE5
-:03008A0021ECFF67
-:03008B00035031EE
-:03008C00C14C184C
-:03008D00D80A92FC
-:03008E00024C031E
-:03008F00C000317D
-:03009000022C122D
-:03009100201A92A0
-:0300920003003C2C
-:03009300901E0FAD
-:0300940020409D6C
-:030095000307035B
-:03009600901A9C21
-:03009700202C0F0B
-:03009800030FFF54
-:0300990090115C67
-:03009A0021011D24
-:03009B00E01A9DCB
-:03009C0002721CD1
-:03009D00C18030EF
-:03009E00D80E0F6A
-:03009F0002403CE0
-:0300A000C00C028F
-:0300A10002203901
-:0300A200201C001F
-:0300A3000300391E
-:0300A400901C802D
-:0300A500204024D4
-:0300A600030C0840
-:0300A700901104B1
-:0300A800202039DC
-:0300A900030C0045
-:0300AA009010397A
-:0300AB00210C0025
-:0300AC0003B02678
-:0300AD00C140252A
-:0300AE0002403ECF
-:0300AF00C0102B53
-:0300B000022C031C
-:0300B10020102CF0
-:0300B200030C40FC
-:0300B30090103971
-:0300B4002047D909
-:0300B500030AB487
-:0300B600901C009B
-:0300B700207208AC
-:0300B80003003012
-:0300B9009019019A
-:0300BA0021AC80F6
-:0300BB0014120814
-:0300BC0070703031
-:0300BD00AC09018A
-:0300BE00181C40CB
-:0300BF00AC303929
-:0300C00069BC0117
-:0300C100AFA037B6
-:0300C200F00C60DF
-:0300C3002282C8CE
-:0300C400643AC3D8
-:0300C500AFAC00DD
-:0300C6001BA03745
-:0300C700C106D996
-:0300C800FFFACC70
-:0300C90017B6F96E
-:0300CA0021ABCF98
-:0300CB00141AC73D
-:0300CC0064394252
-:0300CD00AD0C0275
-:0300CE00C10180ED
-:0300CF0013BE0756
-:0300D000C507431E
-:0300D100039AEDA2
-:0300D200799C0610
-:0300D300AD2195C7
-:0300D40020B7430F
-:0300D500D00AED61
-:0300D6000387D3CA
-:0300D700219AED7E
-:0300D800E07C06C3
-:0300D900348187E8
-:0300DA0034874325
-:0300DB00348ADE86
-:0300DC00348C035E
-:0300DD00030AEB28
-:0300DE00206C078C
-:0300DF00348187E2
-:0300E0003487431F
-:0300E100348AE47A
-:0300E200348C015A
-:0300E300D05AEB05
-:0300E400031C03F7
-:0300E500C00187D0
-:0300E600032743AA
-:0300E700033AEAEF
-:0300E800C70C0042
-:0300E900039AEB8C
-:0300EA00C5020745
-:0300EB0003902758
-:0300EC00C18AFACC
-:0300ED00030C06FB
-:0300EE00C00195B9
-:0300EF00031643B2
-:0300F00021BAFA38
-:0300F100032C01DC
-:0300F200C001C783
-:0300F30003309C3B
-:0300F400C7070338
-:0300F500039AFA71
-:0300F600C50CFF37
-:0300F70003902251
-:0300F800C400271A
-:0300F900039B6204
-:0300FA00369C0031
-:0300FB00C016F339
-:0300FC001E6CFF78
-:0300FD0021C021FE
-:0300FE00086C018A
-:0300FF0074302436
-:03010000A1E90A68
-:030101000266B3E0
-:03010200C02B8986
-:03010300FFFC01FD
-:0301040016B02F03
-:03010500C0221500
-:0301060023E6D31A
-:03010700743D80C4
-:0301080012B0240E
-:0301090020B2170A
-:03010A000380224D
-:03010B00C44C06DB
-:03010C00039195C7
-:03010D00C40743E1
-:03010E00039B51FF
-:03010F00C006D354
-:03011000023B515E
-:03011100ABECE074
-:03011200B12157C1
-:03011300000643A0
-:03011400000B518C
-:03011500000C00DB
-:030116000007B728
-:03011700000C05D4
-:030118000007D706
-:03011900000C10C7
-:03011A000007F7E4
-:03011B00000C02D3
-:03011C00000027B9
-:03011D00000C10C3
-:03011E00000D02CF
-:03011F00000FFFCF
-:0301200000014299
-:030121000006973E
-:03012200000D02CB
-:030123000006379C
-:03012400000D10BB
-:03012500000022B5
-:03012600000C804A
-:03012700000124B0
-:03012800000C02C6
-:0301290000018052
-:03012A00000E07BD
-:03012B0000074387
-:03012C00000B3F86
-:03012D00000C05BE
-:03012E0000014786
-:03012F0000064384
-:03013000000B3F82
-:03013100000C01BE
-:0301320000018148
-:030133000007437F
-:03013400000B3885
-:03013500000C10AB
-:03013600000021A5
-:03013700000B3F7B
-:03013800000C10A8
-:0301390000018141
-:03013A0000074378
-:03013B00000B3F77
-:03013C00000C2094
-:03013D000000219E
-:03013E00000B3F74
-:03013F00000201BA
+:03002C00AE803073
+:03002D00C4090102
+:03002E00D80C806B
+:03002F00024FFF7E
+:03003000C00164A8
+:03003100022C108E
+:03003200209FFF0D
+:0300330003015076
+:03003400901D0814
+:030035002046B9A9
+:03003600030D10A7
+:0300370090102204
+:0300380020220182
+:0300390003003091
+:03003A0090190119
+:03003B00C11204EB
+:03003C0019003078
+:03003D0064390122
+:03003E00A43202E7
+:03003F00C22030AC
+:030040001909019A
+:0300410074380010
+:03004200A46214A1
+:03004300209E708C
+:030044001253084C
+:03004500A4930879
+:03004600209308FC
+:03004700FFF308BC
+:0300480016502728
+:03004900AE88007E
+:03004A00209C00F7
+:03004B0014503915
+:03004C00643038E5
+:03004D00A8603F69
+:03004E00C40C07D8
+:03004F00D80D4089
+:0300500002403437
+:03005100C00C08D8
+:0300520002203851
+:03005300209219DF
+:03005400030E0791
+:03005500901020E8
+:03005600204360E4
+:0300570003036040
+:03005800901360A2
+:0300590020236001
+:03005A00030C1084
+:03005B00901038CA
+:03005C00C11219B5
+:03005D00190E0772
+:03005E00643120EA
+:03005F00A64C109C
+:03006000C221803A
+:03006100190E7005
+:03006200743743AD
+:03006300A86A7315
+:03006400C44C0287
+:03006500D801803F
+:03006600024E0740
+:03006700C006438D
+:03006800022A76F3
+:03006900209C03D5
+:03006A000301800F
+:03006B00901E07DD
+:03006C00204643E8
+:03006D00030A760D
+:03006E00901C04DF
+:03006F00202180CD
+:03007000030E0775
+:03007100901643A3
+:03007200210A76EA
+:03007300E03C016D
+:03007400743038AD
+:03007500C04A7509
+:03007600190C184A
+:030077007480385A
+:03007800A8621962
+:03007900C04E0F67
+:03007A00FFF03D57
+:03007B00150C0061
+:03007C00643038B5
+:03007D00A81C02BA
+:03007E002091804E
+:03007F0013EE0776
+:03008000A847434B
+:03008100209A863C
+:03008200FFFC3F41
+:0300830017E03152
+:0300840021EC1656
+:03008500035A9388
+:03008600C14C0367
+:03008700D801801D
+:03008800024E071E
+:03008900C007436A
+:03008A00022A8FB8
+:03008B00209CFFB7
+:03008C000300313D
+:03008D00901C18AC
+:03008E00204A9372
+:03008F00030C035C
+:030090009010319C
+:03009100202C120E
+:03009200030A93CB
+:0300930090103C8E
+:03009400210E0F2B
+:0300950002709D59
+:03009600C147035C
+:03009700024A9D7D
+:03009800209C0F9A
+:03009900030FFF53
+:03009A0090115C66
+:03009B0020411DE4
+:03009C00030A9EB6
+:03009D0090121CA2
+:03009E002070309F
+:03009F00030E0F3E
+:0300A00090103C81
+:0300A100C18C020D
+:0300A200D800394A
+:0300A300024C000C
+:0300A400C0003960
+:0300A500022C80AA
+:0300A60020902483
+:0300A700030C083F
+:0300A800901104B0
+:0300A900204039BB
+:0300AA00030C0044
+:0300AB0090103979
+:0300AC00202C0005
+:0300AD0003003A13
+:0300AE009010258A
+:0300AF0021003EEF
+:0300B00003B02B6F
+:0300B100707C035D
+:0300B200AB602C14
+:0300B300209C404E
+:0300B40013F0390D
+:0300B500ABE7D9DD
+:0300B600209AB5D8
+:0300B70015FC0035
+:0300B800643208A7
+:0300B900AE8030E6
+:0300BA0069B90120
+:0300BB00AE8C8088
+:0300BC0020920887
+:0300BD001BF03005
+:0300BE00C5090170
+:0300BF00039C405F
+:0300C000799039FB
+:0300C100AC06D9B1
+:0300C20020BAC69B
+:0300C300D006F96B
+:0300C400038BC9E2
+:0300C500219AC1BC
+:0300C600E079429C
+:0300C700348C0274
+:0300C80034818000
+:0300C900348E076B
+:0300CA0034874335
+:0300CB00030AE73E
+:0300CC0021AC065E
+:0300CD00348195E6
+:0300CE0034874331
+:0300CF00348AE789
+:0300D0003487D39F
+:0300D100D05AE71B
+:0300D200031C0606
+:0300D300C00187E2
+:0300D400032743BC
+:0300D500033AD813
+:0300D600C70C0351
+:0300D700039AE5A4
+:0300D800C50C074D
+:0300D90003918709
+:0300DA00C1874398
+:0300DB00030ADE37
+:0300DC00C00C0154
+:0300DD00031AE51E
+:0300DE0021BC033F
+:0300DF0003218773
+:0300E000C0074313
+:0300E100033AE4FB
+:0300E200C70C0048
+:0300E300039AE598
+:0300E400C502074B
+:0300E5000390275E
+:0300E600C40AF455
+:0300E700039C0671
+:0300E800369195B9
+:0300E900C01643FB
+:0300EA001FAAF456
+:0300EB0021CC0124
+:0300EC0009A1C7A0
+:0300ED0074309CD0
+:0300EE00A1E70384
+:0300EF0003AAF46D
+:0300F000C02CFF22
+:0300F100FFF022FB
+:0300F20016B0271E
+:0300F300C02B5CC3
+:0300F40023EC00FA
+:0300F5007436F36B
+:0300F60012BCFF3A
+:0300F70020B02115
+:0300F800038C0175
+:0300F900C44024DC
+:0300FA0003990A5D
+:0300FB00C406B385
+:0300FC00039B83E0
+:0300FD00C00C0133
+:0300FE0002302F9E
+:0300FF00ABF2154C
+:03010000B006D373
+:03010100000D806E
+:03010200000024D6
+:03010300000217E0
+:03010400000022D6
+:03010500000C06E5
+:0301060000019560
+:03010700000743AB
+:03010800000B4B9E
+:030109000006D31A
+:03010A00000B4B9C
+:03010B00000CE005
+:03010C0000015798
+:03010D00000643A6
+:03010E00000B4B98
+:03010F00000C00E1
+:030110000007B72E
+:03011100000C05DA
+:030112000007D70C
+:03011300000C10CD
+:030114000007F7EA
+:03011500000C02D9
+:03011600000027BF
+:03011700000C10C9
+:03011800000D02D5
+:03011900000FFFD5
+:03011A000001429F
+:03011B0000069744
+:03011C00000D02D1
+:03011D00000637A2
+:03011E00000D10C1
+:03011F00000022BB
+:03012000000C8050
+:03012100000124B6
+:03012200000C02CC
+:0301230000018058
+:03012400000E07C3
+:030125000007438D
+:03012600000B3992
+:03012700000C05C4
+:030128000001478C
+:030129000006438A
+:03012A00000B398E
+:03012B00000C01C4
+:03012C000001814E
+:03012D0000074385
+:03012E00000B3291
+:03012F00000C10B1
+:03013000000021AB
+:03013100000B3987
+:03013200000C10AE
+:0301330000018147
+:030134000007437E
+:03013500000B3983
+:03013600000C209A
+:03013700000021A4
+:03013800000B3980
+:03013900000201C0
+:03013A0000003092
+:03013B00000901B7
+:03013C00000204BA
+:03013D000000308F
+:03013E00000901B4
+:03013F00000202B9
 :030140000000308C
 :03014100000901B1
-:03014200000204B4
-:0301430000003089
-:03014400000901AE
-:03014500000202B3
-:0301460000003086
-:03014700000901AB
-:03014800000C8028
-:03014900000FFFA5
-:03014A000001644D
-:03014B00000207A8
-:03014C000001624D
-:03014D00000FFFA1
-:03014E000001505D
-:03014F00000D0898
-:0301500000012289
-:03015100000201A8
+:03014200000C802E
+:03014300000FFFAB
+:0301440000016453
+:03014500000207AE
+:0301460000016253
+:03014700000FFFA7
+:0301480000015063
+:03014900000D089E
+:03014A000001228F
+:03014B00000201AE
+:03014C0000003080
+:03014D00000901A5
+:03014E00000204A8
+:03014F000000307D
+:03015000000901A2
+:03015100000202A7
 :030152000000307A
 :030153000009019F
-:03015400000204A2
-:0301550000003077
-:030156000009019C
-:03015700000202A1
-:0301580000003074
-:0301590000090199
-:03015A00000C0096
-:03015B0000002F72
-:03015C000007D3C6
-:03015D00000B8410
-:03015E000002108C
-:03015F000000227B
-:0301600000020E8C
-:0301610000002774
-:03016200000C503E
-:0301630000003960
-:03016400000799F8
-:03016500000B6428
-:0301660000021282
-:0301670000003065
-:030168000002147E
-:0301690000003162
-:03016A000002137D
-:03016B000006B3D8
-:03016C00000D1073
-:03016D000000325D
-:03016E00000C0082
-:03016F000000335A
-:03017000000C7010
-:0301710000003952
-:03017200000C502E
-:0301730000003950
-:0301740000021571
-:0301750000003057
-:030176000002166E
-:0301770000003154
-:0301780000020280
-:0301790000003251
-:03017A00000C0076
-:03017B000006B3C8
-:03017C0000020777
-:03017D000000334C
-:03017E00000C7002
+:03015400000C009C
+:0301550000002F78
+:030156000007D3CC
+:03015700000B7E1C
+:0301580000021092
+:0301590000002281
+:03015A0000020E92
+:03015B000000277A
+:03015C00000C5044
+:03015D0000003966
+:03015E00000799FE
+:03015F00000B5E34
+:0301600000021288
+:030161000000306B
+:0301620000021484
+:0301630000003168
+:0301640000021383
+:030165000006B3DE
+:03016600000D1079
+:0301670000003263
+:03016800000C0088
+:0301690000003360
+:03016A00000C7016
+:03016B0000003958
+:03016C00000C5034
+:03016D0000003956
+:03016E0000021577
+:03016F000000305D
+:0301700000021674
+:030171000000315A
+:0301720000020286
+:0301730000003257
+:03017400000C007C
+:030175000006B3CE
+:030176000002077D
+:0301770000003352
+:03017800000C7008
+:030179000000394A
+:03017A00000C5026
+:03017B0000003948
+:03017C00000C4034
+:03017D0000003946
+:03017E00000C0072
 :03017F0000003944
-:03018000000C5020
-:0301810000003942
-:03018200000C402E
-:0301830000003940
-:03018400000C006C
-:030185000000393E
-:03018600000C006A
+:03018000000C0070
+:03018100000C006F
+:03018200000ABFB1
+:03018300000C026B
+:0301840000002F49
+:03018500000C0A61
+:0301860000002A4C
 :03018700000C0069
-:03018800000ABEAC
-:03018900000C0265
-:03018A0000002F43
-:03018B00000C0A5B
-:03018C0000002A46
-:03018D00000C0063
-:03018E000000244A
-:03018F000007D393
-:03019000000BACB5
-:0301910000020168
+:0301880000002450
+:030189000007D399
+:03018A00000BA6C1
+:03018B000002016E
+:03018C0000003040
+:03018D0000090165
+:03018E0000021557
+:03018F000000303D
+:0301900000090162
+:0301910000021653
 :030192000000303A
 :030193000009015F
-:0301940000021551
-:0301950000003037
-:030196000009015C
-:030197000002164D
+:03019400000C1F3D
+:03019500000D80DA
+:0301960000002244
+:0301970000020162
 :0301980000003034
 :0301990000090159
-:03019A00000C1F37
-:03019B00000D80D4
-:03019C000000223E
-:03019D000002015C
+:03019A000002025E
+:03019B0000003031
+:03019C0000090156
+:03019D0000020459
 :03019E000000302E
 :03019F0000090153
-:0301A00000020258
-:0301A1000000302B
-:0301A20000090150
-:0301A30000020453
-:0301A40000003028
-:0301A5000009014D
-:0301A6000002EA6A
-:0301A7000007103E
-:0301A800000BAA9F
-:0301A900000B9DAB
-:0301AA000007D378
-:0301AB00000BCA7C
-:0301AC00000C1D27
-:0301AD000006D376
-:0301AE00000D80C1
-:0301AF000000222B
-:0301B00000020149
+:0301A0000002EA70
+:0301A10000071044
+:0301A200000BA4AB
+:0301A300000B97B7
+:0301A4000007D37E
+:0301A500000BC488
+:0301A600000C1D2D
+:0301A7000006D37C
+:0301A800000D80C7
+:0301A90000002231
+:0301AA000002014F
+:0301AB0000003021
+:0301AC0000090146
+:0301AD000002024B
+:0301AE000000301E
+:0301AF0000090143
+:0301B00000021832
 :0301B1000000301B
 :0301B20000090140
-:0301B30000020245
-:0301B40000003018
-:0301B5000009013D
-:0301B6000002182C
-:0301B70000003015
-:0301B8000009013A
-:0301B90000021031
-:0301BA0000002E14
-:0301BB00000C1C19
-:0301BC000006D367
-:0301BD00000D80B2
-:0301BE000000221C
-:0301BF000002013A
+:0301B30000021037
+:0301B40000002E1A
+:0301B500000C1C1F
+:0301B6000006D36D
+:0301B700000D80B8
+:0301B80000002222
+:0301B90000020140
+:0301BA0000003012
+:0301BB0000090137
+:0301BC000002023C
+:0301BD000000300F
+:0301BE0000090134
+:0301BF0000021724
 :0301C0000000300C
 :0301C10000090131
-:0301C20000020236
-:0301C30000003009
-:0301C4000009012E
-:0301C5000002171E
-:0301C60000003006
-:0301C7000009012B
-:0301C8000007D35A
-:0301C900000B9197
-:0301CA00000C0026
-:0301CB0000002F02
-:0301CC000007D356
-:0301CD00000B84A0
-:0301CE00000B5EC5
-:0301CF00000C071A
-:0301D00000002FFD
-:0301D100000C041B
-:0301D20000002109
-:0301D300000C001D
-:0301D40000091E01
+:0301C2000007D360
+:0301C300000B8BA3
+:0301C400000C002C
+:0301C50000002F08
+:0301C6000007D35C
+:0301C700000B7EAC
+:0301C800000B58D1
+:0301C900000C0720
+:0301CA0000002F03
+:0301CB00000C0421
+:0301CC000000210F
+:0301CD00000C0023
+:0301CE0000091E07
+:0301CF00000C1011
+:0301D0000000210B
+:0301D100000C0817
+:0301D20000091E03
+:0301D300000C40DD
+:0301D40000002107
 :0301D500000C100B
-:0301D60000002105
-:0301D700000C0811
-:0301D80000091EFD
-:0301D900000C40D7
-:0301DA0000002101
-:0301DB00000C1005
-:0301DC0000091EF9
-:0301DD00000C0013
-:0301DE00000026F8
-:0301DF00000C0110
-:0301E000000029F3
-:0301E100000C000F
-:0301E20000002FEB
-:0301E300000C20ED
-:0301E400000023F5
-:0301E500000A000D
-:0301E600000ABE4E
-:0301E700000BE723
+:0301D60000091EFF
+:0301D700000C0019
+:0301D80000003AEA
+:0301D900000C0116
+:0301DA00000029F9
+:0301DB00000C0015
+:0301DC0000002FF1
+:0301DD00000C20F3
+:0301DE00000023FB
+:0301DF00000A0013
+:0301E000000ABF53
+:0301E100000BE12F
 :00000001FF

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

@@ -0,0 +1,578 @@
+#
+# $Id: USB_FW.201.hex 10402 2012-02-15 15:34:50Z dima $
+#
+:03004300021F0099
+:03005300021F0089
+:101F0000021E3100021E8E00021E7800021E4900D1
+:081F1000021C2000021BA900C5
+:101000001201000200000040AAAAAAAAAAAA01028C
+:1010100003010A0600020000004001000902370037
+:10102000020100C0000904000002FFFFFF040705E1
+:101030000202000200070586020002000904010006
+:1010400002FFFFFF050705040200020007058802F2
+:10105000000200001201000200000040E4E451110F
+:101060000000010203010A06000200000040010026
+:1010700009023700020100C0320904000002FFFF2C
+:10108000FF04070502024000000705860240000039
+:101090000904010002FFFFFF0507050402400000EC
+:1010A0000705880240000006040016001400120024
+:1010B0000A00260004030904160358006F0072009A
+:1010C00063006F006D0020004C00540044001403C6
+:1010D00041007300740072006900620061006E00DC
+:1010E0006B001203530065007200690061006C0020
+:1010F0004E006F000A0346005000470041002603DF
+:101100004D0061006E00610067006D0065006E00BB
+:101110007400500072006F0063006500730073007C
+:061120006F0072000000E8
+:050FF6000300000000F3
+:100F3C0041E0370041E0B60042E0B1000041E0384A
+:100F4C0000021BE0850218E07943E0B30000004D7D
+:0F0F5C00E03931303339354D202020202020005E
+:101D71008B538A548955E5581558AE57700215573B
+:101D81004E6014AB530555E555AA54700205541421
+:081D9100F9ED12077780DF2253
+:101BE6008B538A548955E55A155AAE5970021559C0
+:101BF6004E6026AB560558E558AA5770020557148D
+:101C0600F9120731FFAB530555E555AA5470020585
+:0A1C16005414F9EF12077780CD2275
+:101DC100D2B7E490E670F0F5B575B5E653B5E743E3
+:101DD100B28853B2FCC2B3D2B1C2B2C2B67F32FE34
+:061DE100121E07D2B6221B
+:101E6100538EF75389FB5389F74389015389FDE465
+:071E7100F58AF58CD2A922CD
+:1018B2008C448D45AA06A9077556018A5789587521
+:1018C2005900755A1C7B017AE0794C121BE690E0B4
+:1018D20064E0FCA3E0FDA3E0FEA3E064D1FFEE64BC
+:1018E2008DFEED644CFDEC6449FC90E064120853FB
+:1018F2007EE07F4C7D1C7C001213707EE07F4C7B6F
+:101902001C7A00AD45AC441214247D1C7C00AF450A
+:10191200AE441211F57D1C7C00AF45AE44021C564C
+:08183F008E448F458C468D4755
+:10184700C20712001290E15BEFF0BF5004D207808D
+:1018570057E490E15CF0A3F090E15CE0FEA3E0FFC9
+:10186700C39410EE648094805030E5472FF582E5ED
+:10187700463EF583E0FF90E15CE0FCA3E02545F5FB
+:1018870082E5443CF583E0B5071090E15DE004F0A4
+:1018970070C690E15CE004F080BE90E15CE070040B
+:0A18A700A3E064107002D207A2074C
+:0118B1002214
+:020E12008F410E
+:100E14001200128F42E4F546F547AD47AC46121472
+:100E2400DA74692547F582E434E0F583E543F00597
+:100E340047E54770020546C39408E54664809480FC
+:100E440040D8E541600490E069F090E069E0B4C006
+:100E540008754400754508800675441D754536754A
+:100E64004600754708C3E5479410E54664809480BE
+:100E740050231214D674692547F582E434E0F583CF
+:100E8400E543F00547E547700205460545E545702D
+:100E9400D4054480D07543FF75441D7545197546C6
+:100EA40000754710C3E547942CE546648094805050
+:100EB40033E542B4510E7B007A007943AD45AC442E
+:100EC400FF1214E274692547F582E434E0F583E502
+:100ED40043F00547E547700205460545E54570C4FE
+:100EE400054480C075441D75453EE4F543F546F55B
+:100EF40047C3E5479406E54664809480502FE54255
+:100F0400B4510A90E069E0B4C2031214D6744625C1
+:100F140047F582E434E0F583E543F00547E547709F
+:100F24000205460545E54570C8054480C490E0695E
+:070F3400E0B4C20374C0F039
+:010F3B002293
+:0A1988008E448F458B468A4789483C
+:101992007E00E5452DF54DEE3544F54C1200128FD3
+:1019A20049E5496451600BC3E5459410E544940050
+:1019B200503585444A85454BC3E54B954DE54A95DF
+:1019C2004C5024AB46AA47A948AD4BAC4AAF49128A
+:1019D2001740054BE54B7002054A74012548F5484E
+:0719E200E43547F54780D111
+:0119E90022DB
+:0617C7008B418A428943B8
+:1017CD00D2067556017557E0755869755900755AE9
+:1017DD00107B017AE07995121BE6E5432410F9E4BC
+:1017ED003542854156F5578958755900755A0C7B08
+:1017FD00017AE079A5121BE67EE07F957CE07D1AEB
+:10180D001218B27EE07F1AE543241CF9E43542FC40
+:10181D00AD0112183F5016AB41E5432410F9E435E4
+:10182D0042FA7D1C7F197E1D1219888002C206A204
+:01183D0006A4
+:01183E002287
+:101126007F03121D46EF2402FFE43EA90775410125
+:10113600F542894390E06AE0FFE50C2408F582E475
+:10114600350BF583EFF090E06BE0FFE50C2409F535
+:1011560082E4350BF583EFF090E06CE0FFE50C24BC
+:101166000AF582E4350BF583EFF090E06DE0FFE5DC
+:101176000C240BF582E4350BF583EFF090E06EE07E
+:10118600FFE50C240CF582E4350BF583EFF090E0D7
+:101196006FE0FFE50C240DF582E4350BF583EFF0E7
+:1011A6007F087E00E4FDEDC39408502874692FF58E
+:1011B60082E434E0F583E0FCAB41AA42A94375F032
+:1011C60002EDA4F58285F083EC1207890D0FBF00AE
+:1011D600010E80D2E5192404F582E43518F583E082
+:0E11E60030E0047F0180027F0090E037EFF0E0
+:0111F40022D8
+:101B250090E06CE02FFFE50C240AF582E4350BF517
+:101B350083EFF0E50C240BF582E4350BF583E0FE2D
+:101B4500E50C240AF582E4350BF583E0FDEDFF9005
+:101B5500E0B1EEF0A3EFF0D206121CBD90E680E0F6
+:041B650054F7F0221F
+:1016200090E600E054E74410F090E60174C0F090BA
+:10163000E6107420F000000090E611F00000009029
+:10164000E6047480F0000000740FF0000000E4F085
+:1016500000000090E6187410F0000000E490E61915
+:10166000F000000090E61A7408F0000000E490E634
+:101670001BF000000090E6497482F0000000F000CA
+:10168000000090E6247402F0000000E490E625F0EB
+:1016900000000090E6957480F0000000F00000006B
+:1016A00043AF017B017AE07914755700755806E461
+:0416B000FD021D71A9
+:061E0100D2837F0A7E007F
+:101E07007C007D181207ABEF1FAC0670011E4C70EB
+:021E1700F622B1
+:0A1A43008E418F428B438A4489458F
+:101A4D00E4F546F547C3E5479542E54695415036E1
+:101A5D00AB43AA44A94585478285468312074AFFB1
+:101A6D00E4FBFAC2B2EF1392B1EFC313FFD2B20B84
+:101A7D00BB00010AEB64084A70E9C2B20547E547AD
+:071A8D0070C3054680BFD3C2
+:011A9400222F
+:101E190090E60174C0F0C2B67FC27E01121E07D2DD
+:081E2900B67F327E00021E07A5
+:101EA400D287121E01C287121E03C2837F0A7E00DC
+:031EB400021E0704
+:021B6900AB07C8
+:101B6B00E4F9FAEBC413131354011392877F027E2B
+:101B7B0000121E07D2837F057E00121E07E925E0A7
+:101B8B00FFA2B3E4334FF97F057E00121E07EB254E
+:0D1B9B00E0FBC283121E030ABA08C8AF01A6
+:011BA800221A
+:061A95008B558A568957AB
+:101A9B00A2AFE433F55D121EA4E4F55CE55CC395DF
+:101AAB005B5027AB55AA56A957855C8275830012EC
+:101ABB00074AFF121B69AB58AA59A95A855C827554
+:101ACB008300EF120789055C80D2120036E55D2496
+:031ADB00FF92AFC8
+:011ADE0022E5
+:0B003600C287121E03121E01D2872297
+:101DE70075418F8F42755800755900755A4B755B51
+:0A1DF700027B007A007941021A9580
+:101C8C0078417C007D007BFF7A0F79F67E007F0522
+:101C9C0012070B30B415755800755900755A4175FB
+:101CAC005B057B007A007941121A95E5435401FFDC
+:011CBC002205
+:100B4E007541007542007543007545017546E075A7
+:100B5E0047007548017549E0754A08E4F551FFF5FF
+:100B6E00527B017AE07900F557755808FD121D7118
+:100B7E00AB45AA46A9477401120777E4F550E55034
+:100B8E00C454F0AB45AA46A94790000112078985C7
+:100B9E004858854959854A5A755B08121A95AB48CB
+:100BAE00AA49A94A90000212074AFE5403FFEE54C6
+:100BBE0070F55124E0602924F0604B24F0605D2430
+:100BCE00F0606F24406003020C5675410185184297
+:100BDE00851943EF24FE600624FE703B801C801FA7
+:100BEE00E5192401FDE43518A905754101F5428981
+:100BFE0043EF24FC60092402700A7552028052757C
+:100C0E005206804D8011E5192402FDE43518A90520
+:100C1E00754101F54289437552088035E519240363
+:100C2E00FDE43518A905754101F542894375520455
+:100C3E00801FE5192405FDE43518A905754101F558
+:100C4E00428943755298800975410075420075437B
+:100C5E0000E542454345416022AB41AA42A94312F9
+:100C6E000731FED395524006AD52AE0580008E443C
+:100C7E00120731C39544120777800CE55170047E3C
+:100C8E000180027E008E44744B2550F8A644055018
+:100C9E00E550C394055003020B8CAB45AA46A947F9
+:100CAE007488120777AB45E5472401F9E43546FA17
+:100CBE0075560075570075584B755900755A0512C3
+:100CCE001BE6854858854959854A5A755B08AB45D8
+:070CDE00AA46A947021A957E
+:1019EA008F4190E0B1E0FEA3E054F064607003EE32
+:1019FA00641160037F012290E037E070037F0F22B9
+:101A0A00E5417003308108E541B401062080037F77
+:101A1A00102290E0B6E0B541037F0122E4F511D22D
+:101A2A0006121CBDAF4190E0B6EFF024FF92B590CC
+:091A3A00E680E054F7F07F002281
+:04000E0090FC04F06E
+:1000120090E678E0541824F06008240870087F50B5
+:0800220080067F518002E4FF1B
+:01002A0022B3
+:0C14D600AD45AC447B007A007943AF4286
+:0C14E2008F488C498D4A8B4B8A4C894DF9
+:1014EE00E4F54EF54F755003FDF551F552A2AF33AD
+:1014FE00F553E54824AF600D047012754E00754F1C
+:10150E00017D018008754E00754F02E4FDE54860CF
+:10151E0051E54F454E604BE54990E0B3F0E54AA3E7
+:10152E00F074B32DF582E434E0AD82FCAB4FAF48DE
+:10153E001219227551008F527F0A7E00121ADFE5B2
+:10154E0052455160107CE07D687B01AF4812157BDF
+:10155E007551008F5290E068E0AB4BAA4CA94D122A
+:0C156E000777E55324FF92AFAE51AF5257
+:01157A00224E
+:0C1740008F4E8C4F8D508B518A52895374
+:10174C00E4F554F555755603FDF557F558A2AF332E
+:10175C00F559E54E24AF600D0470127554007555A3
+:10176C00027D018008755400755503E4FDE54E605B
+:10177C003FE55545546039E54F90E0B3F0E550A393
+:10178C00F0AB51AA52A95312073190E0B5F0C2B791
+:10179C0074B32DF582E434E0AD82FCAB55AF4E1240
+:1017AC0019227557008F587F0A7E00121ADFD2B7A4
+:0A17BC00E55924FF92AFAE57AF5875
+:0117C6002200
+:10005600E4F531F532F535F53CF53DF53EF53FE590
+:10006600AA5484600302063A90E694E0FE90E69570
+:10007600E0FBEEF53CEBF53DC39405E53C94004012
+:100086000790F404E0FD80027DFFED12085F00CECC
+:100096000102C30503080703580903D80B011E0E06
+:1000A60000E40F019411025E130541250401310499
+:1000B6005732046A3404B23504C93604E63703E518
+:1000C6004503F647000005BA75310075320790FC06
+:1000D600047481F0A37414F0E4A3F00205DD7F0F2D
+:1000E600121DE775310075320690FC047480F0E449
+:1000F600A3F0753505F511FE74002535F9EE34F4D7
+:10010600FA7B011217C7400690FC05740EF0E4FF57
+:10011600120E127F8F0202BD7F0E121DE77531008F
+:10012600753205748E12000E8F3F7B007A0079407F
+:10013600E4FDFC1214E2E53F64516019E53F6450AA
+:10014600601375310075320690FC047480F0A37458
+:100156000BF00205DD90E0B7E0FF120E12740025E9
+:1001660032F974FC3531FA7B01C0038B567557E0C2
+:10017600755869755900755A2CD003121BE6742CF4
+:100186002532F532E43531F5317F8E0202BD753107
+:100196000075320790FC047491F090E678E090FCCC
+:1001A60005F030B3047F0280027F0030B4047E0184
+:1001B60080027E00EE4F90FC06F074002532F97442
+:1001C600FC3531FA7B01755700755812E4FD121D96
+:1001D6007174002532F974FC3531FA7B01C0038B4A
+:1001E600567557E0755839755900755A06D0031279
+:1001F6001BE674062532F532E43531F531FE74001E
+:100206002532F974FC3EFA7B01C0038B567557E024
+:10021600755814755900755A06D003121BE67406F4
+:100226002532F532E43531F531FE74002532F974A4
+:10023600FC3EFA7B01C0038B567557E07558467530
+:100246005900755A06D003121BE674062532F5329C
+:10025600E43531F5310205DD7F13121DE7753100F6
+:1002660075321D749312000E8F3F75381D75390057
+:10027600753600753705D3E5399418E538941D5061
+:1002860034E53FB4510E7B007A007940AD39AC3885
+:10029600FF1214E274002537F58274FC3536F583B7
+:1002A600E540F00539E539700205380537E5377060
+:1002B600C5053680C17F93121DE70205DD75310045
+:1002C60075320690FC047480F0E4A3F090F405E027
+:1002D60090E038F0E0147071121E1930B31B755699
+:1002E600017557F4755806755900755A067B017ADB
+:1002F600E07914121BE60205DD90FC057401F0029C
+:1003060003D075310075320690FC047480F0E4A3C6
+:10031600F0753507AF35FEC3E53D9FF534E53C9EE8
+:10032600F53390E038E014702074002FF974F43E31
+:10033600FA7B01AF34AE33121A435004E40204C20E
+:1003460090FC05740CF00205DD90FC057403F002C8
+:1003560005DD75310075320690FC047480F0E4A367
+:10036600F090E038E014705CE4FFFE20B411C2B2F5
+:10037600D2B1D2B20FBF00010EEF640A4E70EC305C
+:10038600B43A90E6017403F07F647E00121E079073
+:10039600E0B7E0FF120E127EE07F697CE07DB812C6
+:1003A60018B27EE07FB8AD1CAC1B12183F50051288
+:1003B6000B4E801690FC05740EF0800E90FC0574B2
+:1003C6000DF0800690FC057403F0E490E038F0022E
+:1003D60005DDE4F531F5327F02121B250205DDE469
+:1003E600FF120E12121126E4FF1219EAE4FF800230
+:1003F6007F01121B25121E190205DD7531007532AB
+:100406000690FC047480F0E4A3F090F405E0F53E59
+:10041600E4F511E53E64016004E53E703290E0B11A
+:10042600E0FEA3E054F064607003EE6411600280A5
+:100436007290E037E070028058E5116401600AE5C9
+:1004460011700C121C8CEF6006853E110205DD80D2
+:100456005275310075320690FC0474B2F0A3E511B2
+:10046600F00205DD75310075320690FC047480F0EB
+:10047600E4A3F090F405E0F53EFF1219EAEF24F14B
+:10048600600F1460152410701AE4F531F532020578
+:10049600DD90FC05740FF00205DD90FC057410F08C
+:1004A6000205DD90FC057401F00205DD753100756D
+:1004B600320690FC0474B5F090E0B6E090FC05F0CE
+:1004C6000205DD75310075320690FC0474B6F0A2A3
+:1004D60080E43325E0FFA281E4334FA3F00205DD7B
+:1004E600853C31853D3290FC0474B7F0753505C303
+:1004F600E53D9535F534E53C9400F5337400253536
+:10050600F582E434F4F583E0648870030205DDAF18
+:10051600357E0074002FF9EE34F4FA7B01C003C077
+:100526000174002FF9EE34FC8B58F559895A85343D
+:100536005BD001D003121A950205DD7531007532C4
+:100546000590FC0474A5F01200128F3F7B007A0020
+:100556007940E4FDFC1214E290E036E0FF0532E556
+:1005660032AC3170020531142400F58274FC3CF57E
+:1005760083EFF090E0B7E0FF0532E532AC31700270
+:100586000531142400F58274FC3CF583EFF0053246
+:10059600E532AE3170020531142400F58274FC3E5A
+:1005A600F583E540F090E6017403F07F647E001267
+:1005B6001E07802375310075320690FC047480F0A6
+:1005C600C3E53D9405E53C94005006A37407F0800E
+:1005D6000690FC057406F090F404E0B48004A3E0F1
+:1005E600701290F404E06405600FE06407600AE0AE
+:1005F60064096005E490E038F0E5324531602CE5A9
+:1006060032FD90FC00F0E531FFA3F090F402E0909B
+:10061600FC02F090F403E090FC03F090E69CEFF00F
+:1006260000000090E69DEDF000000090E6957480D5
+:04063600F0000000D0
+:01063A00229D
+:02004100D322C8
+:0800030090E6BAE0F51DD322DE
+:101ECA0090E740E51DF0E490E68AF090E68B04F096
+:021EDA00D32211
+:08002B0090E6BAE0F51AD322B9
+:101EDC0090E740E51AF0E490E68AF090E68B04F087
+:021EEC00D322FF
+:101D990090E6B9E0242F600D04701990E604E0FF85
+:101DA900430780800890E604E0FF53077F000000A6
+:071DB900EFF08002D322C30A
+:011DC0002200
+:101E3100C0E0C083C082D2015391EF90E65D74018E
+:081E4100F0D082D083D0E03222
+:101E7800C0E0C083C0825391EF90E65D7404F0D057
+:061E880082D083D0E0329D
+:101E8E00C0E0C083C0825391EF90E65D7402F0D043
+:061E9E0082D083D0E03287
+:101C2000C0E0C083C08285120D85130E850E8285AB
+:101C30000D83A37402F085090F850A108510828533
+:101C40000F83A37407F05391EF90E65D7410F0D00A
+:061C500082D083D0E032D7
+:101E4900C0E0C083C082D2035391EF90E65D74086D
+:081E5900F0D082D083D0E0320A
+:101BA900C0E0C083C08290E680E030E72085090D5F
+:101BB900850A0E850E82850D83A37402F085120FA6
+:101BC900851310851082850F83A37407F05391EF55
+:0D1BD90090E65D7420F0D082D083D0E03221
+:101EB700000102020303040405050300000000C03B
+:031EC700C2000056
+:060F6B0001110001080065
+:03000B000212BC22
+:1012BC00C0E0C0F0C083C082C0D075D000C000C0F8
+:0D12CC0001C002C003C004C005C006C00779
+:1012D90078217C007D007BFF7A1E79C17E007F0525
+:1012E90012070B90E0B6E0F526C204752700E50861
+:1012F900600415088056750805E5117004C204805C
+:1013090043A280308101B3500B3081047F008030CB
+:101319007F01802C30B415755800755900755A2114
+:10132900755B057B007A007921121A95E523540132
+:10133900F527701090E0B6E060047F0080027F011D
+:0C1349008F26D204300405AF261219EAEA
+:10135500D007D006D005D004D003D002D001D000EC
+:0B136500D0D0D082D083D0F0D0E03296
+:100CE50078567CE17D017BFF7A1E79C67E007F0404
+:100CF50012070BC203C200D202C201121DC1121E8D
+:100D050061121620750B10750C00751410751512EF
+:100D1500750910750A1C75121075137085120F85EB
+:100D250013107516107517B412001290E154EFF0F8
+:100D35007B017AE17955E4FDFC1214E290E155E07E
+:100D4500FF90E036F0E490E0B7F0EF64C26059EF51
+:100D550064C06054E490E15AF090E15AE0FFC39416
+:100D650004504A74562FF582E434E1F583E0FF60C0
+:100D75003C120E127EE07F697CE07DB81218B27ECF
+:100D8500E07FB8AD1CAC1B12183F501490E15AE03F
+:100D95002456F582E434E1F583E090E0B7F0800D68
+:100DA50090E15AE004F080B1E4FF120E1212112610
+:100DB500D2E843D82090E668E04409F090E65CE08C
+:100DC500443DF012001290E154EFF07B017AE17995
+:100DD50055E4FDFC1214E290E155E064C26007E4BD
+:100DE50090E0B6F0C2B57F01121B25D2AFD28C536D
+:100DF5008EF8C203C2AF120056D2AF3001051209F8
+:0D0E050026C2013003EEC203121D1A80E761
+:0B00460090E50DE030E402C322D3225D
+:1009260090E6B9E070030209EB147003020A602432
+:10093600FE7003020ADB24FB70030209E514700350
+:100946000209DF1470030209D31470030209D924C3
+:10095600056003020B3A1200414003020B4690E683
+:10096600BBE024FE602714603E24FD60111460275E
+:1009760024067056E50B90E6B3F0E50C80421200B3
+:10098600465044E51490E6B3F0E5158033E50D9046
+:10099600E6B3F0E50E802985120F851310E50F905A
+:1009A600E6B3F0E510801990E6BAE0FF121D46AAFC
+:1009B60006A9077B01EA494B600DEE90E6B3F0EF1E
+:1009C60090E6B4F0020B46020B35020B35121EDC24
+:1009D600020B4612002B020B46120003020B4612B4
+:1009E6001ECA020B4690E6B8E0247F601514601913
+:1009F60024027063A200E43325E0FFA202E4334F31
+:100A06008041E490E740F0803F90E6BCE0547EFFF2
+:100A16007E00E0D394807C0040047D0180027D004E
+:100A2600EC4EFEED4F24B7F582741E3EF583E4933B
+:100A3600FF3395E0FEEF24A1FFEE34E68F82F583C7
+:100A4600E0540190E740F0E4A3F090E68AF090E6E7
+:100A56008B7402F0020B46020B3590E6B8E024FEDA
+:100A6600601624026003020B4690E6BAE0B4010564
+:100A7600C200020B46020B3590E6BAE0705590E6CE
+:100A8600BCE0547EFF7E00E0D394807C0040047D71
+:100A96000180027D00EC4EFEED4F24B7F582741EF8
+:100AA6003EF583E493FF3395E0FEEF24A1FFEE3499
+:100AB600E68F82F583E054FEF090E6BCE0548013A6
+:100AC6001313541FFFE0540F2F90E683F0E04420E9
+:100AD600F0806D805A90E6B8E024FE60192402701A
+:100AE6004E90E6BAE0B40104D200805490E6BAE033
+:100AF6006402604C803990E6BCE0547EFF7E00E0E4
+:100B0600D394807C0040047D0180027D00EC4EFE83
+:100B1600ED4F24B7F582741E3EF583E493FF3395BB
+:100B2600E0FEEF24A1FFEE34E68F82F583800D9080
+:100B3600E6A08008121D99500790E6A0E04401F057
+:070B460090E6A0E04480F0FE
+:010B4D002285
+:03003300020FFBBE
+:040FFB0053D8EF32A6
+:100F71006080E0D4292E43C9A2D87C013D3654A11A
+:100F8100ECF0061362A705F3C0C7738C98932BD9B5
+:100F9100BC4C82CA1E9B573CFDD4E01667426F18B9
+:100FA1008A17E512BE4EC4D6DA9EDE49A0FBF58E45
+:100FB100BB2FEE7AA968799115B2073F94C21089C7
+:100FC1000B225F21807F5D9A5A903227353ECCE714
+:100FD100BFF79703FF1930B348A5B5D1D75E922A61
+:100FE100AC56AAC64FB838D296A47DB676FC6BE251
+:040FF1009C7404F1F7
+:081370008C468D47AB07AA066D
+:10137800E4F548F549C3E5499547E5466480F8E54D
+:1013880048648098400302141FE54925E0FFE548BA
+:1013980033FE74D42FF58274E03EF583E0FF7E00BF
+:1013A800AC46AD471207BD8C4A8D4BE54925E0FF99
+:1013B800E54833FE74D52FF58274E03EF583E0FFEF
+:1013C8007E00AC46AD471207BD8C4C8D4DE54B6594
+:1013D8004D7004E54A654C6030EB254BF582EA35E3
+:1013E8004AF583E0F9EB254DF582EA354CF583E0C3
+:1013F800FFEB254BF582EA354AF583EFF0EB254DF7
+:10140800F582EA354CF583E9F00549E549600302C0
+:0B141800137D054802137D7E007F015C
+:0114230022A6
+:0C1424008E468F478C488D498A4A8B4BBE
+:10143000E54745466006E54945487004E4FEFF225D
+:10144000E4F54CF54DC3E54D954BE54A6480F8E570
+:101450004C648098507BE4F54EF54FE549254DF5F9
+:1014600082E548354CF583E4F0C3E54F954BE54AFA
+:101470006480F8E54E6480985049E54F254D24D4AA
+:10148000F582E434E0F583E0FFE547254FF582E59A
+:1014900046354EF583E0FEEF8EF0A4FFE549254D7D
+:1014A000F582E548354CF583E02FFFE549254DF5FC
+:1014B00082E548354CF583EFF0054FE54F70AA05FE
+:1014C0004E80A6054DE54D6003021445054C0214FF
+:0514D000457E007F01D4
+:0114D50022F4
+:101CEC00120731FF90000312074A12077790000386
+:101CFC00EF12078990000212074AFF9000011207A9
+:0E1D0C004A900002120789900001EF02078939
+:0811F5008E468F478C488D499E
+:1011FD00E4F54AF54BE549AE487802CEA2E713CEA9
+:10120D0013D8F8FFC3E54B9FEE6480F8E54A648080
+:10121D009840030212B7E54BAE4A7802C333CE3382
+:10122D00CED8F92547FFEE3546FAA9077B018B4C41
+:10123D00F54D894E74D5254BF582E434E0F583E008
+:10124D00541FFFE48F52F551F550F54F121CECABC6
+:10125D004CAA4DA94E120819C374209552F9F812D3
+:10126D000806C004C005C006C007A94E120819A97A
+:10127D0052A8011207F3D003D002D001D000EF4BDA
+:10128D00FFEE4AFEED49FDEC48FCAB4CAA4DA94ED4
+:10129D00120839AB4CAA4DA94E121CEC054BE54B6F
+:0E12AD006003021202054A0212027E007F0157
+:0112BB002210
+:101C5600D3ED9410EC64809480402AED1D70011C35
+:101C6600142FF582EE3CF583E0FB547F24D4F582F5
+:101C7600E434E0F583E0F9540F2FF582E43EF58372
+:051C8600E06BF080CBD3
+:011C8B002236
+:101D1A0090E682E030E004E020E60B90E682E030D4
+:101D2A00E119E030E71590E680E04401F07F147E87
+:0C1D3A0000121ADF90E680E054FEF02258
+:101CBD0030060990E680E0440AF0800790E680E067
+:101CCD004408F07FDC7E05121ADF90E65D74FFF0AC
+:0F1CDD0090E65FF05391EF90E680E054F7F0222D
+:101ADF008E5A8F5B90E600E054187012E55B24017C
+:101AEF00FFE4355AC313F55AEF13F55B801590E6F3
+:101AFF0000E05418FFBF100BE55B25E0F55BE55ADE
+:101B0F0033F55AE55B155BAE5A7002155A4E6005F8
+:061B1F00121EEE80EE2212
+:06157B008C548D55AE07F3
+:10158100EB70037F012290E678E020E6F990E6789F
+:101591007480F0EE25E0440190E679F090E678E081
+:1015A10030E0F990E678E020E26BE030E167BB01E2
+:1015B1000790E678E04420F090E679E0F5561BEBE1
+:1015C100603090E678E030E0F990E678E020E2459E
+:1015D100BB010790E678E04420F090E679E0FF0552
+:1015E10055E555AC547002055414F5828C83EFF027
+:1015F10080CC90E678E030E0F990E678E020E215E2
+:1016010090E678E04440F090E679E0855582855493
+:0E16110083F07F012290E678E04440F07F00F5
+:01161F0022A8
+:1019220090E678E020E6F990E6787480F0EF25E022
+:1019320090E679F090E678E030E0F990E678E02001
+:10194200E23AE030E136EBD3940040260DEDAE04EE
+:1019520070010C14F5828E83E090E679F01B90E61C
+:1019620078E030E0F990E678E020E210E020E1D67D
+:10197200800A90E678E04440F07F012290E678E029
+:051982004440F07F006D
+:01198700223D
+:021D4600A907EB
+:101D4800AE16AF178F828E83A3E064037017AD01C0
+:101D580019ED7001228F828E83E07C002FFDEC3E0E
+:081D6800FEAF0580DFE4FEFF81
+:011D70002250
+:101EEE007400F58690FDA57C05A3E582458370F907
+:011EFE0022C1
+:030000000216B431
+:0C16B400787FE4F6D8FD75815D0216FB1E
+:10063B00E709F608DFFA8046E709F208DFFA803EA1
+:10064B0088828C83E709F0A3DFFA8032E309F6088E
+:10065B00DFFA8078E309F208DFFA807088828C83F6
+:10066B00E309F0A3DFFA806489828A83E0A3F608AA
+:10067B00DFFA805889828A83E0A3F208DFFA804C84
+:10068B0080D280FA80C680D4806980F2803380105B
+:10069B0080A680EA809A80A880DA80E280CA8033C4
+:1006AB0089828A83ECFAE493A3C8C582C8CCC5833C
+:1006BB00CCF0A3C8C582C8CCC583CCDFE9DEE7800C
+:1006CB000D89828A83E493A3F608DFF9ECFAA9F08B
+:1006DB00EDFB2289828A83ECFAE0A3C8C582C8CCE1
+:1006EB00C583CCF0A3C8C582C8CCC583CCDFEADEFA
+:1006FB00E880DB89828A83E493A3F208DFF980CC5C
+:10070B0088F0EF60010E4E60C388F0ED2402B40454
+:10071B000050B9F582EB2402B4040050AF232345FB
+:06072B00822390068B738F
+:10073100BB010689828A83E0225002E722BBFE02C6
+:09074100E32289828A83E49322F9
+:10074A00BB010CE58229F582E5833AF583E0225064
+:10075A0006E92582F8E622BBFE06E92582F8E222AE
+:0D076A00E58229F582E5833AF583E49322C8
+:10077700BB010689828A83F0225002F722BBFE0161
+:02078700F3225B
+:10078900F8BB010DE58229F582E5833AF583E8F0A6
+:10079900225006E92582C8F622BBFE05E92582C852
+:0207A900F2223A
+:1007AB00EF8DF0A4A8F0CF8CF0A428CE8DF0A42E62
+:0207BB00FE221C
+:1007BD00C2D5EC30E709B2D5E4C39DFDE49CFCEE57
+:1007CD0030E715B2D5E4C39FFFE49EFE120885C342
+:1007DD00E49DFDE49CFC800312088530D507C3E43D
+:0607ED009FFFE49EFE22C6
+:1007F300E8600FECC313FCED13FDEE13FEEF13FFE4
+:03080300D8F12207
+:10080600E8600FEFC333FFEE33FEED33FDEC33FC50
+:03081600D8F122F4
+:10081900BB010789828A830208E65005E9F80208C4
+:10082900DABBFE05E9F80208F289828A830208FE2A
+:10083900BB010789828A830208535005E9F8020936
+:0A0849000EBBFE05E9F802091A22B1
+:0C085300ECF0A3EDF0A3EEF0A3EFF02218
+:10085F00D083D082F8E4937012740193700DA3A328
+:10086F0093F8740193F5828883E47374029368603C
+:06087F00EFA3A3A380DF3C
+:1016C000020CE5E493A3F8E493A34003F68001F24F
+:1016D00008DFF48029E493A3F85407240CC8C3332B
+:1016E000C4540F4420C8834004F456800146F6DFFA
+:1016F000E4800B0102040810204080900F3CE47E3F
+:10170000019360BCA3FF543F30E509541FFEE493EE
+:10171000A360010ECF54C025E060A840B8E493A3B5
+:10172000FAE493A3F8E493A3C8C582C8CAC583CAE0
+:10173000F0A3C8C582C8CAC583CADFE9DEE780BE98
+:010FF50000FB
+:10088500BC000BBE0029EF8DF084FFADF022E4CC57
+:10089500F875F008EF2FFFEE33FEEC33FCEE9DEC20
+:1008A500984005FCEE9DFE0FD5F0E9E4CEFD22ED66
+:1008B500F8F5F0EE8420D21CFEADF075F008EF2FB0
+:1008C500FFED33FD4007985006D5F0F222C398FDA1
+:0508D5000FD5F0EA223E
+:0C08DA00E6FC08E6FD08E6FE08E6FF224A
+:0C08E600E0FCA3E0FDA3E0FEA3E0FF2285
+:0C08F200E2FC08E2FD08E2FE08E2FF2242
+:1008FE00E493FC740193FD740293FE740393FF2240
+:0C090E00ECF608EDF608EEF608EFF62215
+:0C091A00ECF208EDF208EEF208EFF22219
+:00000001FF

drivers/dahdi/xpp/firmwares/USB_RECOV.hex

@@ -0,0 +1,421 @@
+#
+# $Id: USB_RECOV.hex 9760 2011-09-05 12:33:27Z dima $
+#
+:03004300021600A2
+:0300530002160092
+:10160000021580000215C6000215B00002159800F0
+:081610000213F20002137B003B
+:100A00001201000200000040AAAAAAAAAAAA010292
+:100A100003010A060002000000400100090237003D
+:100A2000020100C0000904000002FFFFFF040705E7
+:100A3000020200020007058602000200090401000C
+:100A400002FFFFFF050705040200020007058802F8
+:100A5000000200001201000200000040E4E4511115
+:100A60000000010203010A0600020000004001002C
+:100A700009023700020100C0320904000002FFFF32
+:100A8000FF0407050202400000070586024000003F
+:100A90000904010002FFFFFF0507050402400000F2
+:100AA000070588024000000604001600140012002A
+:100AB0000A00260004030904160358006F007200A0
+:100AC00063006F006D0020004C00540044001403CC
+:100AD00041007300740072006900620061006E00E2
+:100AE0006B001203530065007200690061006C0026
+:100AF0004E006F000A0346005000470041002603E5
+:100B00004D0061006E00610067006D0065006E00C1
+:100B10007400500072006F00630065007300730082
+:060B20006F0072000000EE
+:08164300584F52434F4D2000A7
+:100E650041E0B20042E0AD0000021BE0810218E063
+:100E75007543E0AF0000004CE036393734364D207D
+:060E8500202020202000C7
+:101517008B2A8A2B892CE52F152FAE2E7002152EBC
+:101527004E6014AB2A052CE52CAA2B7002052B1450
+:08153700F9ED12019280DF22A0
+:1013B8008B328A338934E5391539AE3870021538DD
+:1013C8004E6026AB350537E537AA36700205361468
+:1013D800F912014CFFAB320534E534AA337002052B
+:0A13E8003314F9EF12019280CD22B8
+:1011FD008C2A8D2BAA06A9077535018A3689377574
+:10120D00380075391C7B017AE079481213B890E0EB
+:10121D0060E0FCA3E0FDA3E0FEA3E064D1FFEE647B
+:10122D008DFEED644CFDEC6449FC90E06012026EA5
+:10123D007EE07F487D1C7C00120CFF7EE07F487BAA
+:10124D001C7A00AD2BAC2A120DB37D1C7C00AF2B8C
+:10125D00AE2A120C387D1C7C00AF2BAE2A0214284E
+:08099F008E2A8F2B8C2C8D2D6C
+:1009A700C204121567BF5004D204803BE4F52EF54C
+:1009B7002FE52D252FF582E52C352EF583E0FFE574
+:1009C7002B252FF582E52A352EF583E0B5070E0591
+:1009D7002FE52F7002052E6410452E70D4E52F6485
+:0909E70010452E7002D204A20496
+:0109F00022E4
+:020875008F32C0
+:100877001215678F33E4F537F538AD38AC37120FFB
+:100887001474652538F582E434E0F583E534F00522
+:1008970038E53870020537C39408E53764809480DB
+:1008A70040D8E532600490E065F090E065E0B4C0C0
+:1008B70008753500753608800675351D7536367529
+:1008C7003700753808C3E5389410E537648094809D
+:1008D7005023120F1074652538F582E434E0F58350
+:1008E700E534F00538E538700205370536E536702A
+:1008F700D4053580D07534FF75351D7536197537B4
+:1009070000753810C3E538942CE53764809480501F
+:1009170033E533B4510E7B007A007934AD36AC350C
+:10092700FF120F1C74652538F582E434E0F583E582
+:1009370034F00538E538700205370536E53670C4FA
+:10094700053580C075351D75363EE4F534F537F548
+:1009570038C3E5389406E53764809480502FE53333
+:10096700B4510A90E065E0B4C203120F1074422537
+:1009770038F582E434E0F583E534F00538E538707E
+:100987000205370536E53670C8053580C490E06541
+:07099700E0B4C20374C0F0DC
+:01099E002236
+:0A12D3008E2A8F2B8B2C8A2D892E7A
+:1012DD007E00E52B2DF533EE352AF5321215678F8D
+:1012ED002FE52F6451600BC3E52B9410E52A940074
+:1012FD005035852A30852B31C3E5319533E5309551
+:10130D00325024AB2CAA2DA92EAD31AC30AF2F12FB
+:10131D00117A0531E531700205307401252EF52E57
+:07132D00E4352DF52D80D100
+:011334002296
+:020B26008F320C
+:100B28007F031214ECEF2402FFE43EA9077533019A
+:100B3800F534893578367C007D007BFF7A16794359
+:100B48007E007F08120126E532600464017054E5D6
+:100B58000C2408F582E4350BF58374B4F0E50C2415
+:100B680009F582E4350BF5837404F0E50C240AF5E5
+:100B780082E4350BF5837413F0E50C240BF582E45D
+:100B8800350BF5837486F0E50C240CF582E4350BFF
+:100B9800F583E4F0E50C240DF582E4350BF583E4E8
+:100BA800F0806C90E066E0FFE50C2408F582E435FF
+:100BB8000BF583EFF090E067E0FFE50C2409F58280
+:100BC800E4350BF583EFF090E068E0FFE50C240ACC
+:100BD800F582E4350BF583EFF090E069E0FFE50C72
+:100BE800240BF582E4350BF583EFF090E06AE0FF23
+:100BF800E50C240CF582E4350BF583EFF090E06BFF
+:100C0800E0FFE50C240DF582E4350BF583EFF0E405
+:100C1800FF74362FF8E6FEAB33AA34A93575F00217
+:0F0C2800EFA4F58285F083EE1201A40FBF08E25E
+:010C3700229A
+:10145E00E4F532E50C240BF582E4350BF583E0FE62
+:10146E00E50C240AF582E4350BF583E0FDEDFF90E3
+:10147E00E0ADEEF0A3EFF0D20412000390E680E0B0
+:03148E0054F7F020
+:011491002238
+:10105A0090E600E054E74410F090E60174C0F09086
+:10106A00E6107420F000000090E611F000000090F5
+:10107A00E6047480F0000000740FF0000000E4F051
+:10108A0000000090E6187410F0000000E490E619E1
+:10109A00F000000090E61A7408F0000000E490E600
+:1010AA001BF000000090E6497482F0000000F00096
+:1010BA00000090E6247402F0000000E490E625F0B7
+:1010CA0000000090E6957480F0000000F000000037
+:1010DA0043AF017B017AE07914752E00752F06E47F
+:0410EA00FD021517D7
+:1015DC007C007D181201C6EF1FAC0670011E4C700A
+:0215EC00F622E5
+:1015670090E678E0541824F06008240870087F504B
+:0815770080067F518002E4FFB1
+:01157F002249
+:0C0F1000AD36AC357B007A007934AF338D
+:0C0F1C008F398C3A8D3B8B3C8A3D893E1E
+:100F2800E4F53FF540754103FDF542F543A2AF33C3
+:100F3800F544E53924AF600D047012753F00754023
+:100F4800017D018008753F00754002E4FDE53960C8
+:100F580051E540453F604BE53A90E0AFF0E53BA3F3
+:100F6800F074AF2DF582E434E0AD82FCAB40AF39CC
+:100F780012126D7542008F437F0A7E00121335E509
+:100F880043454260107CE07D647B01AF39120FB5A8
+:100F98007542008F4390E064E0AB3CAA3DA93E1245
+:0C0FA8000192E54424FF92AFAE42AF433B
+:010FB400221A
+:0C117A008F348C358D368B378A388939DC
+:10118600E4F53AF53B753C03FDF53DF53EA2AF337C
+:10119600F53FE53424AF600D047012753A00753BD7
+:1011A600027D018008753A00753B03E4FDE5346075
+:1011B6003BE53B453A6035E53590E0AFF0E536A3D3
+:1011C600F0AB37AA38A93912014C90E0B1F074AFF0
+:1011D6002DF582E434E0AD82FCAB3BAF3412126DE8
+:1011E600753D008F3E7F0A7E00121335E53F24FFD2
+:0611F60092AFAE3DAF3EDA
+:0111FC0022D0
+:10054300E4F52AF52BF52CF52DF52EF52FF530E5F1
+:10055300AA5484600302071190E694E0FE90E695A6
+:10056300E0FBEEF52DEBF52EC39405E52D9400404D
+:100573000790F404E0FD80027DFFED24F570030293
+:10058300062524E6700302064F24E0700302062CBE
+:1005930024FE7003020649243960030206B3752A58
+:1005A30000752B0590FC04748EF01215678F30E5EF
+:1005B3003064516019E53064506013752A00752B5F
+:1005C3000690FC047480F0A3740BF00206D6121597
+:1005D300678F307B007A007931E4FDFC120F1CAF8A
+:1005E300311208757400252BF974FC352AFA7B0146
+:1005F300C0038B357536E075376575380075392C52
+:10060300D0031213B87400252BF58274FC352AF538
+:1006130083E531F0742C252BF52BE4352AF52A02DA
+:1006230006D6E4F52AF52B801D1215678F307B0063
+:100633007A007931E4FDFC120F1CAF311208757F8B
+:10064300C0120B26800012145E0206D6752A0075AE
+:100653002B0590FC0474A5F01215678F307B007A8C
+:10066300007931E4FDFC120F1C052BE52BAE2A703B
+:1006730002052A142400F58274FC3EF583E508F094
+:10068300052BE52BAE2A7002052A142400F582748B
+:10069300FC3EF583E515F0052BE52BAE2A7002052C
+:1006A3002A142400F58274FC3EF583E531F080239F
+:1006B300752A00752B0690FC047480F0C3E52E9414
+:1006C30005E52D94005006A37407F0800690FC0501
+:1006D3007406F0E52B452A602CE52BFD90FC00F019
+:1006E300E52AFFA3F090F402E090FC02F090F403FB
+:1006F300E090FC03F090E69CEFF000000090E69D94
+:0E070300EDF000000090E6957480F00000001C
+:0107110022C5
+:02004100D322C8
+:0800460090E6BAE0F51DD3229B
+:1015EE0090E740E51DF0E490E68AF090E68B04F07B
+:0215FE00D322F6
+:08163B0090E6BAE0F51AD32293
+:1016180090E740E51AF0E490E68AF090E68B04F053
+:02162800D322CB
+:10153F0090E6B9E0242F600D04701990E604E0FFE7
+:10154F00430780800890E604E0FF53077F00000008
+:07155F00EFF08002D322C36C
+:011566002262
+:10158000C0E0C083C082D2015391EF90E65D740148
+:08159000F0D082D083D0E032DC
+:1015B000C0E0C083C0825391EF90E65D7404F0D028
+:0615C00082D083D0E0326E
+:1015C600C0E0C083C0825391EF90E65D7402F0D014
+:0615D60082D083D0E03258
+:1013F200C0E0C083C08285110D85120E850E8285E4
+:101402000D83A37402F085090F850A108510828569
+:101412000F83A37407F05391EF90E65D7410F0D040
+:0614220082D083D0E0320D
+:10159800C0E0C083C082D2035391EF90E65D740827
+:0815A800F0D082D083D0E032C4
+:10137B00C0E0C083C08290E680E030E72085090D95
+:10138B00850A0E850E82850D83A37402F085110FDD
+:10139B00851210851082850F83A37407F05391EF8C
+:0D13AB0090E65D7420F0D082D083D0E03257
+:0E09F10000010202030304040505C0C2000059
+:1007120078237C007D007BFF7A0979FB7E007F04D1
+:10072200120126C203C200D202C20112105A750B74
+:100732000A750C0075130A75141275090A750A1CDC
+:1007420075110A75127085110F85121075160A75CA
+:1007520017B41215678F217B007A007922E4FDFC21
+:10076200120F1C852208E4F515F52774232527F8B6
+:10077200E6FF605C1208757EE07F657CE07DB31267
+:1007820011FD7EE07FB3AD1CAC1B12099F50387483
+:10079200232527F8E6F515652260277B007A007984
+:1007A200157D01E4FFFE1212D37B007A007922E468
+:1007B200FDFCAF21120F1CE52265156013751501B2
+:1007C200800E7515FF80090527E527C39404409B19
+:1007D200E5157059FB7A0079227D01FCAF21120FD9
+:1007E2001CE522752900F5287B007A0079227D021A
+:1007F2007C00AF21120F1CE5224229E52964E47036
+:1008020004E52864E470267515C0FB7A0079157D2D
+:1008120001FFFE1212D37B007A007922E4FDFCAFC5
+:1008220021120F1CE52265156003751501AF151223
+:100832000B26D2E843D82090E668E04409F090E61F
+:100842005CE0443DF0E51564C06005E515B4C20303
+:1008520012145ED2AF538EF8C203C2AF120543D256
+:10086200AF30010512031BC2013003EEC2031214A2
+:03087200C080E75C
+:0B00360090E50DE030E402C322D3226D
+:10031B0090E6B9E070030203E01470030204552465
+:10032B00FE70030204D024FB70030203DA14700383
+:10033B000203D41470030203C81470030203CE2407
+:10034B0005600302052F120041400302053B90E6B6
+:10035B00BBE024FE602714603E24FD60111460276F
+:10036B0024067056E50B90E6B3F0E50C80421200C4
+:10037B00365044E51390E6B3F0E5148033E50D9069
+:10038B00E6B3F0E50E802985110F851210E50F906D
+:10039B00E6B3F0E510801990E6BAE0FF1214ECAA70
+:1003AB0006A9077B01EA494B600DEE90E6B3F0EF2F
+:1003BB0090E6B4F002053B02052A02052A12161834
+:1003CB0002053B12163B02053B12004602053B128F
+:1003DB0015EE02053B90E6B8E0247F60151460191A
+:1003EB0024027063A200E43325E0FFA202E4334F42
+:1003FB008041E490E740F0803F90E6BCE0547EFF04
+:10040B007E00E0D394807C0040047D0180027D005F
+:10041B00EC4EFEED4F24F1F58274093EF583E49327
+:10042B00FF3395E0FEEF24A1FFEE34E68F82F583D8
+:10043B00E0540190E740F0E4A3F090E68AF090E6F8
+:10044B008B7402F002053B02052A90E6B8E024FE0D
+:10045B0060162402600302053B90E6BAE0B4010586
+:10046B00C20002053B02052A90E6BAE0705590E601
+:10047B00BCE0547EFF7E00E0D394807C0040047D82
+:10048B000180027D00EC4EFEED4F24F1F5827409E4
+:10049B003EF583E493FF3395E0FEEF24A1FFEE34AA
+:1004AB00E68F82F583E054FEF090E6BCE0548013B7
+:1004BB001313541FFFE0540F2F90E683F0E04420FA
+:1004CB00F0806D805A90E6B8E024FE60192402702B
+:1004DB004E90E6BAE0B40104D200805490E6BAE044
+:1004EB006402604C803990E6BCE0547EFF7E00E0F5
+:1004FB00D394807C0040047D0180027D00EC4EFE95
+:10050B00ED4F24F1F58274093EF583E493FF3395A7
+:10051B00E0FEEF24A1FFEE34E68F82F583800D9091
+:10052B00E6A0800812153F500790E6A0E04401F0CA
+:07053B0090E6A0E04480F00F
+:010542002296
+:0300330002004E7A
+:04004E0053D8EF3262
+:100E8B006080E0CF292E43C9A2D87C013D3654A106
+:100E9B00ECF0061362A705F3C0C7738C98932BD99C
+:100EAB00BC4C82CA1E9B573CFDD4E01667426F18A0
+:100EBB008A17E512BE4EC4D6DA9EDE49A0FBF58E2C
+:100ECB00BB2FEE7AA968799115B2073F94C21089AE
+:100EDB000B225F21807F5D9A5A903227353ECCE7FB
+:100EEB00BFF79703FF1930B348A5B5D1D75E922A48
+:100EFB00AC56AAC64FB838D296A47DB676FC6BE238
+:040F0B009C7404F1DD
+:080CFF008C2C8D2DAB07AA0619
+:100D0700E4F52EF52FC3E52F952DE52C6480F8E546
+:100D17002E6480984003020DAEE52F25E0FFE52EF7
+:100D270033FE74CF2FF58274E03EF583E0FF7E003B
+:100D3700AC2CAD2D1201D88C308D31E52F25E0FF7D
+:100D4700E52E33FE74D02FF58274E03EF583E0FF85
+:100D57007E00AC2CAD2D1201D88C328D33E5316578
+:100D6700337004E53065326030EB2531F582EA35C2
+:100D770030F583E0F9EB2533F582EA3532F583E088
+:100D8700FFEB2531F582EA3530F583EFF0EB2533BC
+:100D9700F582EA3532F583E9F0052FE52F60030286
+:0B0DA7000D0C052E020D0C7E007F01DC
+:010DB200221E
+:0C0DB3008E2C8F2D8C2E8D2F8A308B31D2
+:100DBF00E52D452C6006E52F452E7004E4FEFF223D
+:100DCF00E4F532F533C3E5339531E5306480F8E56A
+:100DDF0032648098507BE4F534F535E52F2533F5F3
+:100DEF0082E52E3532F583E4F0C3E5359531E530F4
+:100DFF006480F8E5346480985049E535253324CF75
+:100E0F00F582E434E0F583E0FFE52D2535F582E545
+:100E1F002C3534F583E0FEEF8EF0A4FFE52F25335C
+:100E2F00F582E52E3532F583E02FFFE52F2533F5DB
+:100E3F0082E52E3532F583EFF00535E53570AA05DD
+:100E4F003480A60533E5336003020DD40532020D5D
+:050E5F00D47E007F01BC
+:010E6400226B
+:1014920012014CFF900003120165120192900003A9
+:1014A200EF1201A4900002120165FF9000011201E7
+:0E14B200659000021201A4900001EF0201A457
+:080C38008E2C8F2D8C2E8D2FC8
+:100C4000E4F530F531E52FAE2E7802CEA2E713CED3
+:100C500013D8F8FFC3E5319FEE6480F8E530648077
+:100C6000984003020CFAE531AE307802C333CE333C
+:100C7000CED8F9252DFFEE352CFAA9077B018B3252
+:100C8000F533893474D02531F582E434E0F583E01E
+:100C9000541FFFE48F38F537F536F535121492AB53
+:100CA00032AA33A934120234C374209538F9F812E9
+:100CB0000221C004C005C006C007A934120234A92D
+:100CC00038A80112020ED003D002D001D000EF4BA1
+:100CD000FFEE4AFEED49FDEC48FCAB32AA33A934E5
+:100CE000120254AB32AA33A9341214920531E53101
+:0E0CF0006003020C450530020C457E007F01BA
+:010CFE0022D3
+:10142800D3ED9410EC64809480402AED1D70011C6B
+:10143800142FF582EE3CF583E0FB547F24CFF58230
+:10144800E434E0F583E0F9540F2FF582E43EF583A8
+:05145800E06BF080CB09
+:01145D00226C
+:1014C00090E682E030E004E020E60B90E682E03037
+:1014D000E119E030E71590E680E04401F07F147EEA
+:0C14E0000012133590E680E054FEF0226C
+:1000030030040990E680E0440AF0800790E680E03F
+:100013004408F07FDC7E0512133590E65D74FFF033
+:0F00230090E65FF05391EF90E680E054F7F02203
+:101335008E458F4690E600E054187012E54624016C
+:10134500FFE43545C313F545EF13F546801590E6E3
+:1013550000E05418FFBF100BE54625E0F546E545CE
+:1013650033F545E5461546AE45700215454E600513
+:0613750012162A80EE2290
+:060FB5008C458D46AE07DD
+:100FBB00EB70037F012290E678E020E6F990E6786B
+:100FCB007480F0EE25E0440190E679F090E678E04D
+:100FDB0030E0F990E678E020E26BE030E167BB01AE
+:100FEB000790E678E04420F090E679E0F5471BEBBC
+:100FFB00603090E678E030E0F990E678E020E2456A
+:10100B00BB010790E678E04420F090E679E0FF051D
+:10101B0046E546AC457002054514F5828C83EFF02E
+:10102B0080CC90E678E030E0F990E678E020E215AD
+:10103B0090E678E04440F090E679E085468285457D
+:0E104B0083F07F012290E678E04440F07F00C1
+:011059002274
+:10126D0090E678E020E6F990E6787480F0EF25E0DE
+:10127D0090E679F090E678E030E0F990E678E020BD
+:10128D00E23AE030E136EBD3940040260DEDAE04AA
+:10129D0070010C14F5828E83E090E679F01B90E6D8
+:1012AD0078E030E0F990E678E020E210E020E1D639
+:1012BD00800A90E678E04440F07F012290E678E0E5
+:0512CD004440F07F0029
+:0112D20022F9
+:0214EC00A9074E
+:1014EE00AE16AF178F828E83A3E064037017AD0123
+:1014FE0019ED7001228F828E83E07C002FFDEC3E71
+:08150E00FEAF0580DFE4FEFFE3
+:0115160022B2
+:10162A007400F58690FDA57C05A3E582458370F9D3
+:01163A00228D
+:030000000210EEFD
+:0C10EE00787FE4F6D8FD758147021135CB
+:10005600E709F608DFFA8046E709F208DFFA803E8C
+:1000660088828C83E709F0A3DFFA8032E309F60879
+:10007600DFFA8078E309F208DFFA807088828C83E1
+:10008600E309F0A3DFFA806489828A83E0A3F60895
+:10009600DFFA805889828A83E0A3F208DFFA804C6F
+:1000A60080D280FA80C680D4806980F28033801046
+:1000B60080A680EA809A80A880DA80E280CA8033AF
+:1000C60089828A83ECFAE493A3C8C582C8CCC58327
+:1000D600CCF0A3C8C582C8CCC583CCDFE9DEE780F7
+:1000E6000D89828A83E493A3F608DFF9ECFAA9F076
+:1000F600EDFB2289828A83ECFAE0A3C8C582C8CCCC
+:10010600C583CCF0A3C8C582C8CCC583CCDFEADEE4
+:10011600E880DB89828A83E493A3F208DFF980CC46
+:1001260088F0EF60010E4E60C388F0ED2402B4043F
+:100136000050B9F582EB2402B4040050AF232345E6
+:0601460082239000A67365
+:10014C00BB010689828A83E0225002E722BBFE02B1
+:09015C00E32289828A83E49322E4
+:10016500BB010CE58229F582E5833AF583E022504F
+:1001750006E92582F8E622BBFE06E92582F8E22299
+:0D018500E58229F582E5833AF583E49322B3
+:10019200BB010689828A83F0225002F722BBFE014C
+:0201A200F32246
+:1001A400F8BB010DE58229F582E5833AF583E8F091
+:1001B400225006E92582C8F622BBFE05E92582C83D
+:0201C400F22225
+:1001C600EF8DF0A4A8F0CF8CF0A428CE8DF0A42E4D
+:0201D600FE2207
+:1001D800C2D5EC30E709B2D5E4C39DFDE49CFCEE42
+:1001E80030E715B2D5E4C39FFFE49EFE12027AC33E
+:1001F800E49DFDE49CFC800312027A30D507C3E439
+:060208009FFFE49EFE22B0
+:10020E00E8600FECC313FCED13FDEE13FEEF13FFCE
+:03021E00D8F122F2
+:10022100E8600FEFC333FFEE33FEED33FDEC33FC3B
+:03023100D8F122DF
+:10023400BB010789828A830202DB5005E9F80202C6
+:10024400CFBBFE05E9F80202E789828A830202F342
+:10025400BB010789828A8302026E5005E9F8020312
+:0A02640003BBFE05E9F802030F22B8
+:0C026E00ECF0A3EDF0A3EEF0A3EFF02203
+:1010FA00020712E493A3F8E493A34003F68001F2F3
+:10110A0008DFF48029E493A3F85407240CC8C333F6
+:10111A00C4540F4420C8834004F456800146F6DFC5
+:10112A00E4800B0102040810204080900E65E47EE2
+:10113A00019360BCA3FF543F30E509541FFEE493BA
+:10114A00A360010ECF54C025E060A840B8E493A381
+:10115A00FAE493A3F8E493A3C8C582C8CAC583CAAC
+:10116A00F0A3C8C582C8CAC583CADFE9DEE780BE64
+:010F0F0000E1
+:10027A00BC000BBE0029EF8DF084FFADF022E4CC68
+:10028A00F875F008EF2FFFEE33FEEC33FCEE9DEC31
+:10029A00984005FCEE9DFE0FD5F0E9E4CEFD22ED77
+:1002AA00F8F5F0EE8420D21CFEADF075F008EF2FC1
+:1002BA00FFED33FD4007985006D5F0F222C398FDB2
+:0502CA000FD5F0EA224F
+:0C02CF00E6FC08E6FD08E6FE08E6FF225B
+:0C02DB00E0FCA3E0FDA3E0FEA3E0FF2296
+:0C02E700E2FC08E2FD08E2FE08E2FF2253
+:1002F300E493FC740193FD740293FE740393FF2251
+:0C030300ECF608EDF608EEF608EFF62226
+:0C030F00ECF208EDF208EEF208EFF2222A
+:00000001FF

drivers/dahdi/xpp/xbus-core.c

@@ -58,9 +58,11 @@ static int proc_xbus_command_write(struct file *file, const char __user *buffer,
 
 /* Command line parameters */
 extern int debug;
-static DEF_PARM(uint, command_queue_length, 1000, 0444, "Maximal command queue length");
+static DEF_PARM(uint, command_queue_length, 1500, 0444, "Maximal command queue length");
 static DEF_PARM(uint, poll_timeout, 1000, 0644, "Timeout (in jiffies) waiting for units to reply");
 static DEF_PARM_BOOL(rx_tasklet, 0, 0644, "Use receive tasklets");
+static DEF_PARM_BOOL(dahdi_autoreg, 0, 0644,
+		"Register devices automatically (1) or not (0)");
 
 #ifdef	CONFIG_PROC_FS
 static int xbus_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data);
@@ -809,6 +811,29 @@ static int xbus_echocancel(xbus_t *xbus, int on)
 	return 0;
 }
 
+static void xbus_deactivate_xpds(xbus_t *xbus)
+{
+	unsigned long flags;
+	int unit;
+	int subunit;
+	xpd_t *xpd;
+
+	for (unit = 0; unit < MAX_UNIT; unit++) {
+		xpd = xpd_byaddr(xbus, unit, 0);
+		if (!xpd)
+			continue;
+		for (subunit = 0; subunit < MAX_SUBUNIT; subunit++) {
+			xpd = xpd_byaddr(xbus, unit, subunit);
+			if (!xpd)
+				continue;
+			spin_lock_irqsave(&xpd->lock, flags);
+			xpd->card_present = 0;
+			xpd_setstate(xpd, XPD_STATE_NOHW);
+			spin_unlock_irqrestore(&xpd->lock, flags);
+		}
+	}
+}
+
 static int xbus_initialize(xbus_t *xbus)
 {
 	int	unit;
@@ -870,13 +895,42 @@ err:
 	goto out;
 }
 
-static int xbus_register_dahdi_device(xbus_t *xbus)
+int	xbus_is_registered(xbus_t *xbus)
 {
-	int	i;
-	int	offset = 0;
+	return xbus->ddev && xbus->ddev->dev.parent;
+}
+
+static void xbus_free_ddev(xbus_t *xbus)
+{
+	if (!xbus->ddev)
+		return;
+	if (xbus->ddev->devicetype)
+		kfree(xbus->ddev->devicetype);
+	xbus->ddev->devicetype = NULL;
+	xbus->ddev->location = NULL;
+	xbus->ddev->hardware_id = NULL;
+	dahdi_free_device(xbus->ddev);
+	xbus->ddev = NULL;
+}
+
+int xbus_register_dahdi_device(xbus_t *xbus)
+{
+	int i;
+	int offset = 0;
+	int ret;
 
 	XBUS_DBG(DEVICES, xbus, "Entering %s\n", __func__);
+	if (xbus_is_registered(xbus)) {
+		XBUS_ERR(xbus, "Already registered to DAHDI\n");
+		WARN_ON(1);
+		ret = -EINVAL;
+		goto err;
+	}
 	xbus->ddev = dahdi_create_device();
+	if (!xbus->ddev) {
+		ret = -ENOMEM;
+		goto err;
+	}
 	/*
 	 * This actually describe the dahdi_spaninfo version 3
 	 * A bunch of unrelated data exported via a modified ioctl()
@@ -891,8 +945,10 @@ static int xbus_register_dahdi_device(xbus_t *xbus)
 	 * OK, let's add to the kernel more useless info.
 	 */
 	xbus->ddev->devicetype = kasprintf(GFP_KERNEL, "Astribank2");
-	if (!xbus->ddev->devicetype)
-		return -ENOMEM;
+	if (!xbus->ddev->devicetype) {
+		ret = -ENOMEM;
+		goto err;
+	}
 
 	/*
 	 * location is the only usefull new data item.
@@ -917,7 +973,8 @@ static int xbus_register_dahdi_device(xbus_t *xbus)
 	}
 	if (dahdi_register_device(xbus->ddev, &xbus->astribank)) {
 		XBUS_ERR(xbus, "Failed to dahdi_register_device()\n");
-		return -ENODEV;
+		ret = -ENODEV;
+		goto err;
 	}
 	for (i = 0; i < MAX_XPDS; i++) {
 		xpd_t *xpd = xpd_of(xbus, i);
@@ -927,9 +984,12 @@ static int xbus_register_dahdi_device(xbus_t *xbus)
 		}
 	}
 	return 0;
+err:
+	xbus_free_ddev(xbus);
+	return ret;
 }
 
-static void xbus_unregister_dahdi_device(xbus_t *xbus)
+void xbus_unregister_dahdi_device(xbus_t *xbus)
 {
 	int i;
 
@@ -941,12 +1001,7 @@ static void xbus_unregister_dahdi_device(xbus_t *xbus)
 	if (xbus->ddev) {
 		dahdi_unregister_device(xbus->ddev);
 		XBUS_NOTICE(xbus, "%s: finished dahdi_unregister_device()\n", __func__);
-		kfree(xbus->ddev->devicetype);
-		xbus->ddev->devicetype = NULL;
-		xbus->ddev->location = NULL;
-		xbus->ddev->hardware_id = NULL;
-		dahdi_free_device(xbus->ddev);
-		xbus->ddev = NULL;
+		xbus_free_ddev(xbus);
 	}
 	for(i = 0; i < MAX_XPDS; i++) {
 		xpd_t *xpd = xpd_of(xbus, i);
@@ -1017,7 +1072,8 @@ void xbus_populate(void *data)
 	 */
 	xbus_request_sync(xbus, SYNC_MODE_PLL);
 	elect_syncer("xbus_populate(end)");	/* FIXME: try to do it later */
-	xbus_register_dahdi_device(xbus);
+	if (dahdi_autoreg)
+		xbus_register_dahdi_device(xbus);
 out:
 	XBUS_DBG(DEVICES, xbus, "Leaving\n");
 	wake_up_interruptible_all(&worker->wait_for_xpd_initialization);
@@ -1290,6 +1346,7 @@ void xbus_deactivate(xbus_t *xbus)
 	xbus_request_sync(xbus, SYNC_MODE_NONE);	/* no more ticks */
 	elect_syncer("deactivate");
 	xbus_echocancel(xbus, 0);
+	xbus_deactivate_xpds(xbus);
 	XBUS_DBG(DEVICES, xbus, "[%s] Waiting for queues\n", xbus->label);
 	xbus_command_queue_clean(xbus);
 	xbus_command_queue_waitempty(xbus);
@@ -1400,7 +1457,6 @@ xbus_t *xbus_new(struct xbus_ops *ops, ushort max_send_size, struct device *tran
 	xbus = xbus_alloc();
 	if(!xbus) {
 		ERR("%s: Failed allocating new xbus\n", __FUNCTION__);
-		module_put(THIS_MODULE);
 		return NULL;
 	}
 	snprintf(xbus->busname, XBUS_NAMELEN, "XBUS-%02d", xbus->num);

drivers/dahdi/xpp/xbus-core.h

@@ -29,7 +29,7 @@
 #include "xframe_queue.h"
 #include "xbus-pcm.h"
 
-#define	MAX_BUSES	32
+#define	MAX_BUSES	128
 #define	XFRAME_DATASIZE	512
 #define	MAX_ENV_STR	40
 
@@ -343,6 +343,10 @@ 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	xpp_driver_init(void);
 void	xpp_driver_exit(void);
 int	xbus_sysfs_transport_create(xbus_t *xbus);

drivers/dahdi/xpp/xbus-sysfs.c

@@ -613,6 +613,48 @@ static DEVICE_ATTR_READER(span_show, dev, buf)
 	return len;
 }
 
+/*
+ * For backward compatibility with old dahdi-tools
+ * Remove after dahdi_registration is upgraded
+ */
+static DEVICE_ATTR_WRITER(span_store, dev, buf, count)
+{
+	xpd_t		*xpd;
+	int		dahdi_reg;
+	int		ret;
+
+	BUG_ON(!dev);
+	xpd = dev_to_xpd(dev);
+	if (!xpd)
+		return -ENODEV;
+	ret = sscanf(buf, "%d", &dahdi_reg);
+	if (ret != 1)
+		return -EINVAL;
+	if (!XBUS_IS(xpd->xbus, READY))
+		return -ENODEV;
+	XPD_DBG(DEVICES, xpd,
+		"%s -- deprecated (should use pinned-spans)\n",
+		(dahdi_reg) ? "register" : "unregister");
+	if (xbus_is_registered(xpd->xbus)) {
+		if (dahdi_reg) {
+			XPD_DBG(DEVICES, xpd,
+				"already registered %s. Ignored.\n",
+				xpd->xbus->busname);
+		} else {
+			xbus_unregister_dahdi_device(xpd->xbus);
+		}
+	} else {
+		if (!dahdi_reg) {
+			XPD_DBG(DEVICES, xpd,
+				"already unregistered %s. Ignored.\n",
+				xpd->xbus->busname);
+		} else {
+			xbus_register_dahdi_device(xpd->xbus);
+		}
+	}
+	return count;
+}
+
 static DEVICE_ATTR_READER(type_show, dev, buf)
 {
 	xpd_t		*xpd;
@@ -695,7 +737,7 @@ static int xpd_match(struct device *dev, struct device_driver *driver)
 static struct device_attribute xpd_dev_attrs[] = {
 	__ATTR(chipregs,	S_IRUGO | S_IWUSR, chipregs_show, chipregs_store),
 	__ATTR(blink,		S_IRUGO | S_IWUSR, blink_show, blink_store),
-        __ATTR_RO(span),
+	__ATTR(span,		S_IRUGO | S_IWUSR, span_show, span_store),
         __ATTR_RO(type),
         __ATTR_RO(offhook),
         __ATTR_RO(timing_priority),

drivers/dahdi/xpp/xpd.h

@@ -49,6 +49,7 @@ typedef	unsigned gfp_t;		/* Added in 2.6.14 */
 #endif
 #endif
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 31)
 /*
  * FIXME: Kludge for 2.6.19
  * bool is now defined as a proper boolean type (gcc _Bool)
@@ -58,6 +59,12 @@ typedef	unsigned gfp_t;		/* Added in 2.6.14 */
 	int name = init;	\
 	module_param(name, bool, perm);		\
 	MODULE_PARM_DESC(name, desc " [default " #init "]")
+#else
+#define	DEF_PARM_BOOL(name, init, perm, desc) \
+	bool name = init; \
+	module_param(name, bool, perm); \
+	MODULE_PARM_DESC(name, desc " [default " #init "]")
+#endif
 
 #define	DEF_PARM(type,name,init,perm,desc)	\
 	type name = init;	\

drivers/dahdi/xpp/xpp_dahdi.c

@@ -697,7 +697,6 @@ int xpp_open(struct dahdi_chan *chan)
 	pos = chan->chanpos - 1;
 	if(!xpd->card_present) {
 		LINE_NOTICE(xpd, pos, "Cannot open -- device not ready\n");
-		put_xpd(__FUNCTION__, xpd);
 		return -ENODEV;
 	}
 	spin_lock_irqsave(&xbus->lock, flags);
@@ -835,7 +834,7 @@ int xpp_maint(struct dahdi_span *span, int cmd)
  * If the watchdog detects no received data, it will call the
  * watchdog routine
  */
-static int xpp_watchdog(struct dahdi_span *span, int cause)
+int xpp_watchdog(struct dahdi_span *span, int cause)
 {
 	static	int rate_limit = 0;
 
@@ -843,6 +842,7 @@ static int xpp_watchdog(struct dahdi_span *span, int cause)
 		DBG(GENERAL, "\n");
 	return 0;
 }
+EXPORT_SYMBOL(xpp_watchdog);
 #endif
 
 /*
@@ -1083,14 +1083,9 @@ int xpd_dahdi_postregister(xpd_t *xpd)
  */
 void xpd_dahdi_preunregister(xpd_t *xpd)
 {
-	unsigned long	flags;
 	if (!xpd)
 		return;
 	XPD_DBG(DEVICES, xpd, "\n");
-	spin_lock_irqsave(&xpd->lock, flags);
-	xpd->card_present = 0;
-	xpd_setstate(xpd, XPD_STATE_NOHW);
-	spin_unlock_irqrestore(&xpd->lock, flags);
 	update_xpd_status(xpd, DAHDI_ALARM_NOTOPEN);
 	if(xpd->card_present)
 		CALL_PHONE_METHOD(card_dahdi_preregistration, xpd, 0);
@@ -1136,11 +1131,6 @@ static int __init xpp_dahdi_init(void)
 
 	INFO("revision %s MAX_XPDS=%d (%d*%d)\n", XPP_VERSION,
 			MAX_XPDS, MAX_UNIT, MAX_SUBUNIT);
-#ifdef CONFIG_DAHDI_BRI_DCHANS
-	INFO("FEATURE: with BRISTUFF support\n");
-#else
-	INFO("FEATURE: without BRISTUFF support\n");
-#endif
 #ifdef CONFIG_PROC_FS
 	xpp_proc_toplevel = proc_mkdir(PROC_DIR, NULL);
 	if(!xpp_proc_toplevel) {

drivers/dahdi/xpp/xpp_dahdi.h

@@ -47,6 +47,7 @@ int xpp_close(struct dahdi_chan *chan);
 int xpp_ioctl(struct dahdi_chan *chan, unsigned int cmd, unsigned long arg);
 int xpp_hooksig(struct dahdi_chan *chan, enum dahdi_txsig txsig);
 int xpp_maint(struct dahdi_span *span, int cmd);
+int xpp_watchdog(struct dahdi_span *span, int cause);
 void xpp_span_assigned(struct dahdi_span *span);
 void report_bad_ioctl(const char *msg, xpd_t *xpd, int pos, unsigned int cmd);
 int total_registered_spans(void);

drivers/dahdi/xpp/xproto.c

@@ -75,6 +75,12 @@ static const xproto_table_t *xproto_table(xpd_type_t cardtype)
 	return xprotocol_tables[cardtype];
 }
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 3, 0)
+#define MODULE_REFCOUNT_FORMAT "%s refcount was %d\n"
+#else
+#define MODULE_REFCOUNT_FORMAT "%s refcount was %lu\n"
+#endif
+
 const xproto_table_t *xproto_get(xpd_type_t cardtype)
 {
 	const xproto_table_t *xtable;
@@ -94,7 +100,8 @@ const xproto_table_t *xproto_get(xpd_type_t cardtype)
 	if(xtable) {
 		BUG_ON(!xtable->owner);
 #ifdef CONFIG_MODULE_UNLOAD
-		DBG(GENERAL, "%s refcount was %d\n", xtable->name, module_refcount(xtable->owner));
+		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);
@@ -108,7 +115,8 @@ void xproto_put(const xproto_table_t *xtable)
 {
 	BUG_ON(!xtable);
 #ifdef CONFIG_MODULE_UNLOAD
-	DBG(GENERAL, "%s refcount was %d\n", xtable->name, module_refcount(xtable->owner));
+	DBG(GENERAL, MODULE_REFCOUNT_FORMAT, xtable->name,
+	    module_refcount(xtable->owner));
 	BUG_ON(module_refcount(xtable->owner) <= 0);
 #endif
 	module_put(xtable->owner);

include/dahdi/kernel.h

@@ -43,6 +43,7 @@
 #endif
 #include <linux/fs.h>
 #include <linux/device.h>
+#include <linux/module.h>
 #include <linux/ioctl.h>
 
 #ifdef CONFIG_DAHDI_NET	
@@ -71,6 +72,12 @@
 #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)
+#ifdef CONFIG_PCI
+#include <linux/pci-aspm.h>
+#endif
+#endif
+
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)
 #define HAVE_NET_DEVICE_OPS
 #endif
@@ -92,16 +99,25 @@
 #endif
 #endif
 
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
 #  ifdef RHEL_RELEASE_VERSION
 #    if RHEL_RELEASE_CODE < RHEL_RELEASE_VERSION(5, 6)
 #define dev_name(dev)		((dev)->bus_id)
+#define dev_set_name(dev, format, ...) \
+	snprintf((dev)->bus_id, BUS_ID_SIZE, format, ## __VA_ARGS__)
+#    else
+#define dev_set_name(dev, format, ...) \
+	do { \
+		kobject_set_name(&(dev)->kobj, format, ## __VA_ARGS__); \
+		snprintf((dev)->bus_id, BUS_ID_SIZE, \
+			kobject_name(&(dev)->kobj));	\
+	} while (0)
 #    endif
 #  else
 #define dev_name(dev)		((dev)->bus_id)
-#  endif
 #define dev_set_name(dev, format, ...) \
-	snprintf((dev)->bus_id, BUS_ID_SIZE, format, ## __VA_ARGS__);
+	snprintf((dev)->bus_id, BUS_ID_SIZE, format, ## __VA_ARGS__)
+#  endif
 #endif
 
 /*! Default chunk size for conferences and such -- static right now, might make
@@ -1100,6 +1116,9 @@ struct dahdi_dynamic_driver {
 
 	struct list_head list;
 	struct module *owner;
+
+	/*! Numberic id of next device created by this driver. */
+	unsigned int id;
 };
 
 /*! \brief Receive a dynamic span message */
@@ -1261,8 +1280,13 @@ extern u_char __dahdi_lin2mu[16384];
 extern u_char __dahdi_lin2a[16384];
 #endif
 
+struct dahdi_dynamic_ops {
+	struct module *owner;
+	int (*ioctl)(unsigned int cmd, unsigned long data);
+};
+
 /*! \brief Used by dynamic DAHDI -- don't use directly */
-void dahdi_set_dynamic_ioctl(int (*func)(unsigned int cmd, unsigned long data));
+void dahdi_set_dynamic_ops(const struct dahdi_dynamic_ops *ops);
 
 /*! \brief Used by DAHDI HPEC module -- don't use directly */
 void dahdi_set_hpec_ioctl(int (*func)(unsigned int cmd, unsigned long data));
@@ -1381,6 +1405,16 @@ static inline short dahdi_txtone_nextsample(struct dahdi_chan *ss)
 #define fatal_signal_pending(p) \
 	(signal_pending((p)) && sigismember(&(p)->pending.signal, SIGKILL))
 
+#ifdef CONFIG_PCI
+#ifndef PCIE_LINK_STATE_L0S
+#define PCIE_LINK_STATE_L0S	1
+#define PCIE_LINK_STATE_L1	2
+#define PCIE_LINK_STATE_CLKPM	4
+#endif
+#define pci_disable_link_state dahdi_pci_disable_link_state
+void dahdi_pci_disable_link_state(struct pci_dev *pdev, int state);
+#endif /* CONFIG_PCI */
+
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
 
 #ifndef __packed                                                                                         
@@ -1408,60 +1442,6 @@ static inline int strcasecmp(const char *s1, const char *s2)
 	return c1 - c2;
 }
 #endif /* clamp_val */
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
-static inline void list_replace(struct list_head *old, struct list_head *new)
-{
-        new->next = old->next;
-        new->next->prev = new;
-        new->prev = old->prev;
-        new->prev->next = new;
-}
-
-#ifndef WARN_ON_ONCE
-#define WARN_ON_ONCE(__condition) do {         \
-	static int __once = 1;                 \
-	if (unlikely(__condition)) {           \
-		if (__once) {                  \
-			__once = 0;            \
-			WARN_ON(0);            \
-		}                              \
-	}                                      \
-} while (0)
-#endif
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 17)
-#ifndef POLLRDHUP
-#define POLLRDHUP 0
-#endif
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)
-#define kzalloc(a, b) kcalloc(1, a, b)
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 12)
-#define synchronize_rcu() synchronize_kernel()
-#define kasprintf dahdi_kasprintf
-char *dahdi_kasprintf(gfp_t gfp, const char *fmt, ...);
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
-#if !defined(HAVE_WAIT_FOR_COMPLETION_TIMEOUT)
-static inline unsigned long
-wait_for_completion_interruptible_timeout(struct completion *x,
-					  unsigned long timeout)
-{
-	/* There is a race condition here.  If x->done is reset to 0
-	 * before the call to wait_for_completion after this thread wakes.
-	 */
-	timeout = wait_event_interruptible_timeout(x->wait, x->done, timeout);
-	if (timeout)
-		wait_for_completion(x);
-
-	return timeout;
-}
-#endif
-typedef u32 __bitwise pm_message_t;
-#endif /* 2.6.11 */
-#endif /* 2.6.12 */
-#endif /* 2.6.14 */
-#endif /* 2.6.17 */
-#endif /* 2.6.18 */
 #endif /* 2.6.22 */
 #endif /* 2.6.25 */
 #endif /* 2.6.26 */
@@ -1567,6 +1547,7 @@ struct mutex {
  * be of the form DAHDI_DBG_*
  */
 #define	DAHDI_DBG_GENERAL	BIT(0)
+#define	DAHDI_DBG_ASSIGN	BIT(1)
 #define	DAHDI_DBG_DEVICES	BIT(7)	/* instantiation/destruction etc. */
 #define	dahdi_dbg(bits, fmt, ...)	\
 	((void)((debug & (DAHDI_DBG_ ## bits)) && DAHDI_PRINTK(DEBUG, \
@@ -1579,6 +1560,10 @@ struct mutex {
 			((void)((debug & (DAHDI_DBG_ ## bits)) && \
 				chan_printk(DEBUG, "-" #bits, chan, \
 					"%s: " fmt, __func__, ## __VA_ARGS__)))
+#define dahdi_dev_dbg(bits, dev, fmt, ...)         \
+			((void)((debug & (DAHDI_DBG_ ## bits)) && \
+			dev_printk(KERN_DEBUG, dev, \
+			"DBG-%s(%s): " fmt, #bits, __func__, ## __VA_ARGS__)))
 #endif /* DAHDI_PRINK_MACROS_USE_debug */
 
 #endif /* _DAHDI_KERNEL_H */