Home Explore Help
Sign In
OpenWrt
/
openwrt
mirror of https://github.com/openwrt/openwrt.git
2
0
Fork 0
Files Issues 0 Wiki
Browse Source

kernel: remove linux 3.3 patches and config

Signed-off-by: Felix Fietkau <[email protected]>

SVN-Revision: 44109
Felix Fietkau 11 years ago
parent
ed60bb8360
commit
186db26d05
100 changed files with 0 additions and 35485 deletions
Split View Show Diff Stats
  1. 0 3527
      target/linux/generic/config-3.3
  2. 0 250
      target/linux/generic/patches-3.3/001-ARM-7668-1-fix-memset-related-crashes-caused-by-rece.patch
  3. 0 78
      target/linux/generic/patches-3.3/002-ARM-7668-1-fix-memset-related-crashes-caused-by-rece.patch
  4. 0 249
      target/linux/generic/patches-3.3/003-MIPS-Refactor-clear_page-and-copy_page-functions.patch
  5. 0 96
      target/linux/generic/patches-3.3/006-arm_kernel_xz_support.patch
  6. 0 40
      target/linux/generic/patches-3.3/007-hso-Earlier-catch-of-error-condition.patch
  7. 0 48
      target/linux/generic/patches-3.3/008-hso-Fix-stack-corruption-on-some-architectures.patch
  8. 0 3206
      target/linux/generic/patches-3.3/020-ssb_update.patch
  9. 0 5794
      target/linux/generic/patches-3.3/025-bcma_backport.patch
  10. 0 757
      target/linux/generic/patches-3.3/040-Controlled-Delay-AQM.patch
  11. 0 185
      target/linux/generic/patches-3.3/041-codel-use-Newton-method-instead-of-sqrt-and-divides.patch
  12. 0 839
      target/linux/generic/patches-3.3/042-fq_codel-Fair-Queue-Codel-AQM.patch
  13. 0 33
      target/linux/generic/patches-3.3/043-net-codel-Add-missing-include-linux-prefetch.h.patch
  14. 0 51
      target/linux/generic/patches-3.3/044-net-codel-fix-build-errors.patch
  15. 0 86
      target/linux/generic/patches-3.3/045-codel-use-u16-field-instead-of-31bits-for-rec_inv_sq.patch
  16. 0 132
      target/linux/generic/patches-3.3/046-fq_codel-qdisc-backlog.patch
  17. 0 603
      target/linux/generic/patches-3.3/047-spi_message_queue.patch
  18. 0 39
      target/linux/generic/patches-3.3/048-spi-Dont-call-prepare-unprepare-transfer-if-not-popu.patch
  19. 0 52
      target/linux/generic/patches-3.3/049-codel-refine-one-condition-to-avoid-a-nul-rec_inv_sqrt.patch
  20. 0 783
      target/linux/generic/patches-3.3/050-rng_git_backport.patch
  21. 0 543
      target/linux/generic/patches-3.3/051-rng_git_backport-remove_irqf_sample_random.patch
  22. 0 36
      target/linux/generic/patches-3.3/060-hso_devices.patch
  23. 0 61
      target/linux/generic/patches-3.3/060-tcp-ecn-dont-delay-ACKS-after-CE.patch
  24. 0 36
      target/linux/generic/patches-3.3/061-fq_codel-dont-reinit-flow-state.patch
  25. 0 187
      target/linux/generic/patches-3.3/065-8139cp-fixes.patch
  26. 0 68
      target/linux/generic/patches-3.3/070-gpio-add-flags-to-export-GPIOs-when-requesting.patch
  27. 0 27
      target/linux/generic/patches-3.3/080-prot-release-cb.patch
  28. 0 271
      target/linux/generic/patches-3.3/081-USB-OHCI-Add-a-generic-platform-device-driver.patch
  29. 0 283
      target/linux/generic/patches-3.3/082-USB-EHCI-Add-a-generic-platform-device-driver.patch
  30. 0 11
      target/linux/generic/patches-3.3/083-USB-EHCI-platform-remove-update.patch
  31. 0 27
      target/linux/generic/patches-3.3/084-x86_fix_perf_uclibc_build.patch
  32. 0 27
      target/linux/generic/patches-3.3/090-CVE-2013-1763.patch
  33. 0 3232
      target/linux/generic/patches-3.3/100-overlayfs_v12.patch
  34. 0 41
      target/linux/generic/patches-3.3/102-ehci_hcd_ignore_oc.patch
  35. 0 10
      target/linux/generic/patches-3.3/110-fix_mtd_include.patch
  36. 0 188
      target/linux/generic/patches-3.3/130-pppoatm-queue-depth.patch
  37. 0 900
      target/linux/generic/patches-3.3/131-atm-fixes.patch
  38. 0 442
      target/linux/generic/patches-3.3/132-solos-dma.patch
  39. 0 39
      target/linux/generic/patches-3.3/140-ixp4xx_hss_module_h_include.patch
  40. 0 11
      target/linux/generic/patches-3.3/200-fix_localversion.patch
  41. 0 14
      target/linux/generic/patches-3.3/201-extra_optimization.patch
  42. 0 11
      target/linux/generic/patches-3.3/202-reduce_module_size.patch
  43. 0 3088
      target/linux/generic/patches-3.3/210-darwin_scripts_include.patch
  44. 0 17
      target/linux/generic/patches-3.3/211-stddef_include.patch
  45. 0 22
      target/linux/generic/patches-3.3/212-x86_reloc_portability.patch
  46. 0 91
      target/linux/generic/patches-3.3/220-module_exports.patch
  47. 0 54
      target/linux/generic/patches-3.3/230-openwrt_lzma_options.patch
  48. 0 18
      target/linux/generic/patches-3.3/250-netfilter_depends.patch
  49. 0 18
      target/linux/generic/patches-3.3/251-sound_kconfig.patch
  50. 0 10
      target/linux/generic/patches-3.3/252-mv_cesa_depends.patch
  51. 0 29
      target/linux/generic/patches-3.3/253-ssb_b43_default_on.patch
  52. 0 23
      target/linux/generic/patches-3.3/254-textsearch_kconfig_hacks.patch
  53. 0 19
      target/linux/generic/patches-3.3/255-lib80211_kconfig_hacks.patch
  54. 0 47
      target/linux/generic/patches-3.3/256-crypto_add_kconfig_prompts.patch
  55. 0 22
      target/linux/generic/patches-3.3/257-wireless_ext_kconfig_hack.patch
  56. 0 11
      target/linux/generic/patches-3.3/258-netfilter_netlink_kconfig_hack.patch
  57. 0 23
      target/linux/generic/patches-3.3/259-compressor_kconfig_hack.patch
  58. 0 219
      target/linux/generic/patches-3.3/260-move_bcm963xx_tag.patch
  59. 0 55
      target/linux/generic/patches-3.3/270-regmap_dynamic.patch
  60. 0 39
      target/linux/generic/patches-3.3/300-mips_expose_boot_raw.patch
  61. 0 28
      target/linux/generic/patches-3.3/301-mips_image_cmdline_hack.patch
  62. 0 18
      target/linux/generic/patches-3.3/302-mips_use_generic_thread_info_allocator.patch
  63. 0 11
      target/linux/generic/patches-3.3/303-mips_fix_kexec.patch
  64. 0 160
      target/linux/generic/patches-3.3/304-mips_disable_fpu.patch
  65. 0 371
      target/linux/generic/patches-3.3/305-mips_module_reloc.patch
  66. 0 83
      target/linux/generic/patches-3.3/306-mips_mem_functions_performance.patch
  67. 0 35
      target/linux/generic/patches-3.3/307-mips_oprofile_fix.patch
  68. 0 17
      target/linux/generic/patches-3.3/308-mips-show-correct-cpu-name-for-24KEc.patch
  69. 0 32
      target/linux/generic/patches-3.3/309-mips_fuse_workaround.patch
  70. 0 13
      target/linux/generic/patches-3.3/310-arm_module_unresolved_weak_sym.patch
  71. 0 31
      target/linux/generic/patches-3.3/320-ppc4xx_optimization.patch
  72. 0 10
      target/linux/generic/patches-3.3/321-powerpc_crtsavres_prereq.patch
  73. 0 10
      target/linux/generic/patches-3.3/322-ppc4xx-crypto-compile-fix.patch
  74. 0 616
      target/linux/generic/patches-3.3/330-mips-add-crash-and-kdump-support.patch
  75. 0 157
      target/linux/generic/patches-3.3/331-mips-kexec-enhanche-the-support.patch
  76. 0 52
      target/linux/generic/patches-3.3/332-mips-kexec-init-the-arguments-for-the-new-kernel-image.patch
  77. 0 88
      target/linux/generic/patches-3.3/333-mips-kexec-get-kernel-parameters-from-kexec-tools.patch
  78. 0 83
      target/linux/generic/patches-3.3/334-mips-fix-compiling-failure-of-relocate_kernel.patch
  79. 0 186
      target/linux/generic/patches-3.3/335-mips-kexec-cleanup-kexec-tools-parameter-handling.patch
  80. 0 20
      target/linux/generic/patches-3.3/340-module_alloc_size_check.patch
  81. 0 327
      target/linux/generic/patches-3.3/400-rootfs_split.patch
  82. 0 146
      target/linux/generic/patches-3.3/401-partial_eraseblock_write.patch
  83. 0 18
      target/linux/generic/patches-3.3/410-mtd_info_move_forward_decl.patch
  84. 0 30
      target/linux/generic/patches-3.3/420-redboot_space.patch
  85. 0 35
      target/linux/generic/patches-3.3/430-mtd_myloader_partition_parser.patch
  86. 0 116
      target/linux/generic/patches-3.3/440-block2mtd_init.patch
  87. 0 291
      target/linux/generic/patches-3.3/441-block2mtd_refresh.patch
  88. 0 10
      target/linux/generic/patches-3.3/442-block2mtd_probe.patch
  89. 0 10
      target/linux/generic/patches-3.3/443-block2mtd-avoid-recursive-call-of-mtd_writev.patch
  90. 0 37
      target/linux/generic/patches-3.3/450-mtd_plat_nand_chip_fixup.patch
  91. 0 12
      target/linux/generic/patches-3.3/451-mtd_fix_nand_correct_data_return_code.patch
  92. 0 11
      target/linux/generic/patches-3.3/460-cfi_cmdset_0002_no_erase_suspend.patch
  93. 0 39
      target/linux/generic/patches-3.3/470-mtd_m25p80_add_pm25lv_flash_support.patch
  94. 0 10
      target/linux/generic/patches-3.3/473-mtd_m25p80_add_w25q128.patch
  95. 0 18
      target/linux/generic/patches-3.3/475-mtd_cfi_cmdset_0002-add-buffer-write-cmd-timeout.patch
  96. 0 41
      target/linux/generic/patches-3.3/476-mtd-m25p80-allow-to-disable-small-sector-erase.patch
  97. 0 10
      target/linux/generic/patches-3.3/477-mtd-m25p80-add-support-for-the-EON-EN25Q64-chip.patch
  98. 0 18
      target/linux/generic/patches-3.3/478-mtd-partial_eraseblock_unlock.patch
  99. 0 25
      target/linux/generic/patches-3.3/520-squashfs_update_xz_comp_opts.patch
  100. 0 5142
      target/linux/generic/patches-3.3/530-jffs2_make_lzma_available.patch

+ 0 - 3527
target/linux/generic/config-3.3
View File 

@@ -1,3527 +0,0 @@
 
-CONFIG_32BIT=y
 
-# CONFIG_6PACK is not set
 
-# CONFIG_8139CP is not set
 
-# CONFIG_8139TOO is not set
 
-# CONFIG_9P_FS is not set
 
-# CONFIG_AB3100_CORE is not set
 
-# CONFIG_AB8500_CORE is not set
 
-# CONFIG_ABX500_CORE is not set
 
-# CONFIG_ACCESSIBILITY is not set
 
-# CONFIG_ACENIC is not set
 
-# CONFIG_ACERHDF is not set
 
-# CONFIG_ACORN_PARTITION is not set
 
-# CONFIG_ACPI_APEI is not set
 
-# CONFIG_ACPI_CUSTOM_METHOD is not set
 
-# CONFIG_ACPI_HED is not set
 
-# CONFIG_ACPI_POWER_METER is not set
 
-# CONFIG_ACPI_QUICKSTART is not set
 
-# CONFIG_AD525X_DPOT is not set
 
-# CONFIG_ADAPTEC_STARFIRE is not set
 
-# CONFIG_ADFS_FS is not set
 
-# CONFIG_ADIS16255 is not set
 
-# CONFIG_ADM6996_PHY is not set
 
-# CONFIG_ADM8211 is not set
 
-CONFIG_AEABI=y
 
-# CONFIG_AFFS_FS is not set
 
-# CONFIG_AFS_FS is not set
 
-# CONFIG_AF_RXRPC is not set
 
-# CONFIG_AGP is not set
 
-CONFIG_AIO=y
 
-# CONFIG_AIRO is not set
 
-# CONFIG_AIRO_CS is not set
 
-# CONFIG_ALCHEMY_GPIO_INDIRECT is not set
 
-# CONFIG_ALIM7101_WDT is not set
 
-# CONFIG_ALTERA_STAPL is not set
 
-# CONFIG_AMD8111_ETH is not set
 
-# CONFIG_AMIGA_PARTITION is not set
 
-# CONFIG_AMILO_RFKILL is not set
 
-# CONFIG_ANDROID is not set
 
-CONFIG_ANON_INODES=y
 
-# CONFIG_APDS9802ALS is not set
 
-# CONFIG_APM8018X is not set
 
-# CONFIG_APPLICOM is not set
 
-# CONFIG_AR7 is not set
 
-# CONFIG_AR8216_PHY is not set
 
-# CONFIG_ARCH_AT91 is not set
 
-# CONFIG_ARCH_BCMRING is not set
 
-# CONFIG_ARCH_CLPS711X is not set
 
-# CONFIG_ARCH_CNS3XXX is not set
 
-# CONFIG_ARCH_DAVINCI is not set
 
-# CONFIG_ARCH_DMA_ADDR_T_64BIT is not set
 
-# CONFIG_ARCH_DOVE is not set
 
-# CONFIG_ARCH_EBSA110 is not set
 
-# CONFIG_ARCH_EP93XX is not set
 
-# CONFIG_ARCH_EXYNOS is not set
 
-CONFIG_ARCH_FLATMEM_ENABLE=y
 
-# CONFIG_ARCH_FOOTBRIDGE is not set
 
-# CONFIG_ARCH_GEMINI is not set
 
-# CONFIG_ARCH_H720X is not set
 
-# CONFIG_ARCH_HAS_ILOG2_U32 is not set
 
-# CONFIG_ARCH_HAS_ILOG2_U64 is not set
 
-# CONFIG_ARCH_HIGHBANK is not set
 
-# CONFIG_ARCH_INTEGRATOR is not set
 
-# CONFIG_ARCH_IOP13XX is not set
 
-# CONFIG_ARCH_IOP32X is not set
 
-# CONFIG_ARCH_IOP33X is not set
 
-# CONFIG_ARCH_IXP2000 is not set
 
-# CONFIG_ARCH_IXP23XX is not set
 
-# CONFIG_ARCH_IXP4XX is not set
 
-# CONFIG_ARCH_KIRKWOOD is not set
 
-# CONFIG_ARCH_KS8695 is not set
 
-# CONFIG_ARCH_LPC32XX is not set
 
-# CONFIG_ARCH_MMP is not set
 
-# CONFIG_ARCH_MSM is not set
 
-# CONFIG_ARCH_MV78XX0 is not set
 
-# CONFIG_ARCH_MXC is not set
 
-# CONFIG_ARCH_MXS is not set
 
-# CONFIG_ARCH_NETX is not set
 
-# CONFIG_ARCH_NOMADIK is not set
 
-# CONFIG_ARCH_NUC93X is not set
 
-# CONFIG_ARCH_OMAP is not set
 
-# CONFIG_ARCH_ORION5X is not set
 
-# CONFIG_ARCH_PHYS_ADDR_T_64BIT is not set
 
-# CONFIG_ARCH_PICOXCELL is not set
 
-# CONFIG_ARCH_PNX4008 is not set
 
-# CONFIG_ARCH_PRIMA2 is not set
 
-# CONFIG_ARCH_PXA is not set
 
-# CONFIG_ARCH_REALVIEW is not set
 
-# CONFIG_ARCH_RPC is not set
 
-# CONFIG_ARCH_S3C2410 is not set
 
-# CONFIG_ARCH_S3C64XX is not set
 
-# CONFIG_ARCH_S5P64X0 is not set
 
-# CONFIG_ARCH_S5PC100 is not set
 
-# CONFIG_ARCH_S5PV210 is not set
 
-# CONFIG_ARCH_SA1100 is not set
 
-# CONFIG_ARCH_SHARK is not set
 
-# CONFIG_ARCH_SHMOBILE is not set
 
-# CONFIG_ARCH_SUPPORTS_MSI is not set
 
-# CONFIG_ARCH_TCC_926 is not set
 
-# CONFIG_ARCH_TEGRA is not set
 
-# CONFIG_ARCH_U300 is not set
 
-# CONFIG_ARCH_U8500 is not set
 
-# CONFIG_ARCH_VERSATILE is not set
 
-# CONFIG_ARCH_VEXPRESS is not set
 
-# CONFIG_ARCH_VT8500 is not set
 
-# CONFIG_ARCH_W90X900 is not set
 
-# CONFIG_ARCH_ZYNQ is not set
 
-# CONFIG_ARCNET is not set
 
-CONFIG_ARM_CPU_TOPOLOGY=y
 
-CONFIG_ARM_DMA_MEM_BUFFERABLE=y
 
-# CONFIG_ARM_ERRATA_326103 is not set
 
-# CONFIG_ARM_ERRATA_364296 is not set
 
-# CONFIG_ARM_ERRATA_411920 is not set
 
-# CONFIG_ARM_ERRATA_430973 is not set
 
-# CONFIG_ARM_ERRATA_458693 is not set
 
-# CONFIG_ARM_ERRATA_460075 is not set
 
-# CONFIG_ARM_ERRATA_720789 is not set
 
-# CONFIG_ARM_ERRATA_742230 is not set
 
-# CONFIG_ARM_ERRATA_742231 is not set
 
-# CONFIG_ARM_ERRATA_743622 is not set
 
-# CONFIG_ARM_ERRATA_751472 is not set
 
-# CONFIG_ARM_ERRATA_754322 is not set
 
-# CONFIG_ARM_ERRATA_754327 is not set
 
-# CONFIG_ARM_ERRATA_764369 is not set
 
-# CONFIG_ARM_PATCH_PHYS_VIRT is not set
 
-# CONFIG_ARM_UNWIND is not set
 
-CONFIG_ARPD=y
 
-# CONFIG_ARTHUR is not set
 
-# CONFIG_ASUS_OLED is not set
 
-# CONFIG_ASYNC_RAID6_TEST is not set
 
-# CONFIG_ASYNC_TX_DMA is not set
 
-# CONFIG_AT76C50X_USB is not set
 
-# CONFIG_ATA is not set
 
-CONFIG_ATAGS_PROC=y
 
-# CONFIG_ATALK is not set
 
-# CONFIG_ATARI_PARTITION is not set
 
-# CONFIG_ATA_ACPI is not set
 
-CONFIG_ATA_BMDMA=y
 
-# CONFIG_ATA_GENERIC is not set
 
-# CONFIG_ATA_NONSTANDARD is not set
 
-# CONFIG_ATA_OVER_ETH is not set
 
-# CONFIG_ATA_PIIX is not set
 
-CONFIG_ATA_SFF=y
 
-# CONFIG_ATA_VERBOSE_ERROR is not set
 
-# CONFIG_ATH5K is not set
 
-# CONFIG_ATH6K_LEGACY is not set
 
-# CONFIG_ATH79 is not set
 
-# CONFIG_ATH9K is not set
 
-# CONFIG_ATL1 is not set
 
-# CONFIG_ATL1C is not set
 
-# CONFIG_ATL1E is not set
 
-# CONFIG_ATL2 is not set
 
-# CONFIG_ATM is not set
 
-# CONFIG_ATMEL is not set
 
-# CONFIG_ATMEL_PWM is not set
 
-# CONFIG_ATM_AMBASSADOR is not set
 
-# CONFIG_ATM_BR2684 is not set
 
-CONFIG_ATM_BR2684_IPFILTER=y
 
-# CONFIG_ATM_CLIP is not set
 
-CONFIG_ATM_CLIP_NO_ICMP=y
 
-# CONFIG_ATM_DRIVERS is not set
 
-# CONFIG_ATM_DUMMY is not set
 
-# CONFIG_ATM_ENI is not set
 
-# CONFIG_ATM_FIRESTREAM is not set
 
-# CONFIG_ATM_FORE200E is not set
 
-# CONFIG_ATM_HE is not set
 
-# CONFIG_ATM_HORIZON is not set
 
-# CONFIG_ATM_IA is not set
 
-# CONFIG_ATM_IDT77252 is not set
 
-# CONFIG_ATM_LANAI is not set
 
-# CONFIG_ATM_LANE is not set
 
-# CONFIG_ATM_MPOA is not set
 
-# CONFIG_ATM_NICSTAR is not set
 
-# CONFIG_ATM_SOLOS is not set
 
-# CONFIG_ATM_TCP is not set
 
-# CONFIG_ATM_ZATM is not set
 
-# CONFIG_ATOMIC64_SELFTEST is not set
 
-# CONFIG_ATP is not set
 
-# CONFIG_AUDIT is not set
 
-# CONFIG_AUDIT_LOGINUID_IMMUTABLE is not set
 
-# CONFIG_AUTOFS4_FS is not set
 
-# CONFIG_AUTO_ZRELADDR is not set
 
-# CONFIG_AUXDISPLAY is not set
 
-# CONFIG_AVERAGE is not set
 
-# CONFIG_AX25 is not set
 
-# CONFIG_AX25_DAMA_SLAVE is not set
 
-# CONFIG_AX88796 is not set
 
-# CONFIG_B43 is not set
 
-# CONFIG_B43LEGACY is not set
 
-# CONFIG_B44 is not set
 
-# CONFIG_BACKLIGHT_LCD_SUPPORT is not set
 
-# CONFIG_BACKTRACE_SELF_TEST is not set
 
-CONFIG_BASE_FULL=y
 
-CONFIG_BASE_SMALL=0
 
-# CONFIG_BATMAN_ADV is not set
 
-# CONFIG_BATTERY_BQ27x00 is not set
 
-# CONFIG_BATTERY_DS2760 is not set
 
-# CONFIG_BATTERY_DS2780 is not set
 
-# CONFIG_BATTERY_DS2782 is not set
 
-# CONFIG_BATTERY_MAX17040 is not set
 
-# CONFIG_BATTERY_MAX17042 is not set
 
-# CONFIG_BATTERY_SBS is not set
 
-# CONFIG_BAYCOM_EPP is not set
 
-# CONFIG_BAYCOM_PAR is not set
 
-# CONFIG_BAYCOM_SER_FDX is not set
 
-# CONFIG_BAYCOM_SER_HDX is not set
 
-# CONFIG_BCM47XX is not set
 
-# CONFIG_BCM63XX is not set
 
-# CONFIG_BCM63XX_PHY is not set
 
-# CONFIG_BCMA is not set
 
-# CONFIG_BCMA_DRIVER_GPIO is not set
 
-CONFIG_BCMA_POSSIBLE=y
 
-# CONFIG_BCM_WIMAX is not set
 
-# CONFIG_BDI_SWITCH is not set
 
-# CONFIG_BE2ISCSI is not set
 
-# CONFIG_BE2NET is not set
 
-# CONFIG_BEFS_FS is not set
 
-# CONFIG_BFS_FS is not set
 
-# CONFIG_BINARY_PRINTF is not set
 
-# CONFIG_BINFMT_AOUT is not set
 
-CONFIG_BINFMT_ELF=y
 
-# CONFIG_BINFMT_MISC is not set
 
-CONFIG_BITREVERSE=y
 
-# CONFIG_BLK_CPQ_CISS_DA is not set
 
-# CONFIG_BLK_CPQ_DA is not set
 
-CONFIG_BLK_DEV=y
 
-# CONFIG_BLK_DEV_3W_XXXX_RAID is not set
 
-# CONFIG_BLK_DEV_4DRIVES is not set
 
-# CONFIG_BLK_DEV_AEC62XX is not set
 
-# CONFIG_BLK_DEV_ALI14XX is not set
 
-# CONFIG_BLK_DEV_ALI15X3 is not set
 
-# CONFIG_BLK_DEV_AMD74XX is not set
 
-# CONFIG_BLK_DEV_ATIIXP is not set
 
-# CONFIG_BLK_DEV_BSG is not set
 
-# CONFIG_BLK_DEV_BSGLIB is not set
 
-# CONFIG_BLK_DEV_CMD640 is not set
 
-# CONFIG_BLK_DEV_CMD64X is not set
 
-# CONFIG_BLK_DEV_COW_COMMON is not set
 
-# CONFIG_BLK_DEV_CRYPTOLOOP is not set
 
-# CONFIG_BLK_DEV_CS5520 is not set
 
-# CONFIG_BLK_DEV_CS5530 is not set
 
-# CONFIG_BLK_DEV_CS5535 is not set
 
-# CONFIG_BLK_DEV_CS5536 is not set
 
-# CONFIG_BLK_DEV_CY82C693 is not set
 
-# CONFIG_BLK_DEV_DAC960 is not set
 
-# CONFIG_BLK_DEV_DELKIN is not set
 
-# CONFIG_BLK_DEV_DRBD is not set
 
-# CONFIG_BLK_DEV_DTC2278 is not set
 
-# CONFIG_BLK_DEV_FD is not set
 
-# CONFIG_BLK_DEV_GENERIC is not set
 
-# CONFIG_BLK_DEV_HD is not set
 
-# CONFIG_BLK_DEV_HPT366 is not set
 
-# CONFIG_BLK_DEV_HT6560B is not set
 
-# CONFIG_BLK_DEV_IDEACPI is not set
 
-# CONFIG_BLK_DEV_IDECD is not set
 
-# CONFIG_BLK_DEV_IDECS is not set
 
-# CONFIG_BLK_DEV_IDEPCI is not set
 
-# CONFIG_BLK_DEV_IDEPNP is not set
 
-# CONFIG_BLK_DEV_IDETAPE is not set
 
-# CONFIG_BLK_DEV_IDE_AU1XXX is not set
 
-# CONFIG_BLK_DEV_IDE_SATA is not set
 
-CONFIG_BLK_DEV_INITRD=y
 
-# CONFIG_BLK_DEV_INTEGRITY is not set
 
-# CONFIG_BLK_DEV_IO_TRACE is not set
 
-# CONFIG_BLK_DEV_IT8172 is not set
 
-# CONFIG_BLK_DEV_IT8213 is not set
 
-# CONFIG_BLK_DEV_IT821X is not set
 
-# CONFIG_BLK_DEV_JMICRON is not set
 
-# CONFIG_BLK_DEV_LOOP is not set
 
-CONFIG_BLK_DEV_LOOP_MIN_COUNT=8
 
-# CONFIG_BLK_DEV_NBD is not set
 
-# CONFIG_BLK_DEV_NS87415 is not set
 
-# CONFIG_BLK_DEV_NVME is not set
 
-# CONFIG_BLK_DEV_OFFBOARD is not set
 
-# CONFIG_BLK_DEV_OPTI621 is not set
 
-# CONFIG_BLK_DEV_PCIESSD_MTIP32XX is not set
 
-# CONFIG_BLK_DEV_PDC202XX_NEW is not set
 
-# CONFIG_BLK_DEV_PDC202XX_OLD is not set
 
-# CONFIG_BLK_DEV_PIIX is not set
 
-# CONFIG_BLK_DEV_PLATFORM is not set
 
-# CONFIG_BLK_DEV_QD65XX is not set
 
-# CONFIG_BLK_DEV_RAM is not set
 
-# CONFIG_BLK_DEV_RBD is not set
 
-# CONFIG_BLK_DEV_RZ1000 is not set
 
-# CONFIG_BLK_DEV_SC1200 is not set
 
-# CONFIG_BLK_DEV_SD is not set
 
-# CONFIG_BLK_DEV_SIIMAGE is not set
 
-# CONFIG_BLK_DEV_SIS5513 is not set
 
-# CONFIG_BLK_DEV_SL82C105 is not set
 
-# CONFIG_BLK_DEV_SLC90E66 is not set
 
-# CONFIG_BLK_DEV_SR is not set
 
-# CONFIG_BLK_DEV_SVWKS is not set
 
-# CONFIG_BLK_DEV_SX8 is not set
 
-# CONFIG_BLK_DEV_TC86C001 is not set
 
-# CONFIG_BLK_DEV_THROTTLING is not set
 
-# CONFIG_BLK_DEV_TRIFLEX is not set
 
-# CONFIG_BLK_DEV_TRM290 is not set
 
-# CONFIG_BLK_DEV_UB is not set
 
-# CONFIG_BLK_DEV_UMC8672 is not set
 
-# CONFIG_BLK_DEV_UMEM is not set
 
-# CONFIG_BLK_DEV_VIA82CXXX is not set
 
-# CONFIG_BLK_DEV_XIP is not set
 
-CONFIG_BLOCK=y
 
-# CONFIG_BMP085 is not set
 
-# CONFIG_BNA is not set
 
-# CONFIG_BNX2 is not set
 
-# CONFIG_BNX2X is not set
 
-# CONFIG_BONDING is not set
 
-# CONFIG_BOOKE_WDT is not set
 
-# CONFIG_BOOT_PRINTK_DELAY is not set
 
-CONFIG_BOOT_RAW=y
 
-# CONFIG_BPQETHER is not set
 
-CONFIG_BQL=y
 
-CONFIG_BRANCH_PROFILE_NONE=y
 
-# CONFIG_BRCMFMAC is not set
 
-CONFIG_BRIDGE=y
 
-# CONFIG_BRIDGE_EBT_802_3 is not set
 
-# CONFIG_BRIDGE_EBT_AMONG is not set
 
-# CONFIG_BRIDGE_EBT_ARP is not set
 
-# CONFIG_BRIDGE_EBT_ARPREPLY is not set
 
-# CONFIG_BRIDGE_EBT_BROUTE is not set
 
-# CONFIG_BRIDGE_EBT_DNAT is not set
 
-# CONFIG_BRIDGE_EBT_IP is not set
 
-# CONFIG_BRIDGE_EBT_IP6 is not set
 
-# CONFIG_BRIDGE_EBT_LIMIT is not set
 
-# CONFIG_BRIDGE_EBT_LOG is not set
 
-# CONFIG_BRIDGE_EBT_MARK is not set
 
-# CONFIG_BRIDGE_EBT_MARK_T is not set
 
-# CONFIG_BRIDGE_EBT_NFLOG is not set
 
-# CONFIG_BRIDGE_EBT_PKTTYPE is not set
 
-# CONFIG_BRIDGE_EBT_REDIRECT is not set
 
-# CONFIG_BRIDGE_EBT_SNAT is not set
 
-# CONFIG_BRIDGE_EBT_STP is not set
 
-# CONFIG_BRIDGE_EBT_T_FILTER is not set
 
-# CONFIG_BRIDGE_EBT_T_NAT is not set
 
-# CONFIG_BRIDGE_EBT_ULOG is not set
 
-# CONFIG_BRIDGE_EBT_VLAN is not set
 
-# CONFIG_BRIDGE_IGMP_SNOOPING is not set
 
-# CONFIG_BRIDGE_NETFILTER is not set
 
-# CONFIG_BRIDGE_NF_EBTABLES is not set
 
-# CONFIG_BROADCOM_PHY is not set
 
-CONFIG_BROKEN_ON_SMP=y
 
-# CONFIG_BSD_DISKLABEL is not set
 
-# CONFIG_BSD_PROCESS_ACCT is not set
 
-# CONFIG_BSD_PROCESS_ACCT_V3 is not set
 
-# CONFIG_BT is not set
 
-# CONFIG_BTRFS_FS is not set
 
-# CONFIG_BT_ATH3K is not set
 
-# CONFIG_BT_BNEP is not set
 
-CONFIG_BT_BNEP_MC_FILTER=y
 
-CONFIG_BT_BNEP_PROTO_FILTER=y
 
-# CONFIG_BT_CMTP is not set
 
-# CONFIG_BT_HCIBCM203X is not set
 
-# CONFIG_BT_HCIBFUSB is not set
 
-# CONFIG_BT_HCIBLUECARD is not set
 
-# CONFIG_BT_HCIBPA10X is not set
 
-# CONFIG_BT_HCIBT3C is not set
 
-# CONFIG_BT_HCIBTSDIO is not set
 
-# CONFIG_BT_HCIBTUART is not set
 
-# CONFIG_BT_HCIBTUSB is not set
 
-# CONFIG_BT_HCIDTL1 is not set
 
-# CONFIG_BT_HCIUART is not set
 
-# CONFIG_BT_HCIUART_ATH3K is not set
 
-CONFIG_BT_HCIUART_BCSP=y
 
-CONFIG_BT_HCIUART_H4=y
 
-# CONFIG_BT_HCIUART_LL is not set
 
-# CONFIG_BT_HCIVHCI is not set
 
-# CONFIG_BT_HIDP is not set
 
-CONFIG_BT_L2CAP=y
 
-# CONFIG_BT_MRVL is not set
 
-# CONFIG_BT_RFCOMM is not set
 
-CONFIG_BT_RFCOMM_TTY=y
 
-CONFIG_BT_SCO=y
 
-CONFIG_BUG=y
 
-# CONFIG_C2PORT is not set
 
-# CONFIG_CAIF is not set
 
-# CONFIG_CAN is not set
 
-# CONFIG_CAPI_AVM is not set
 
-# CONFIG_CAPI_EICON is not set
 
-# CONFIG_CAPI_TRACE is not set
 
-CONFIG_CARDBUS=y
 
-# CONFIG_CARDMAN_4000 is not set
 
-# CONFIG_CARDMAN_4040 is not set
 
-# CONFIG_CARMA_FPGA is not set
 
-# CONFIG_CARMA_FPGA_PROGRAM is not set
 
-# CONFIG_CASSINI is not set
 
-CONFIG_CAVIUM_OCTEON_HELPER=y
 
-# CONFIG_CAVIUM_OCTEON_REFERENCE_BOARD is not set
 
-# CONFIG_CAVIUM_OCTEON_SIMULATOR is not set
 
-# CONFIG_CB710_CORE is not set
 
-# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 
-# CONFIG_CC_STACKPROTECTOR is not set
 
-# CONFIG_CDROM_PKTCDVD is not set
 
-# CONFIG_CEPH_FS is not set
 
-# CONFIG_CEPH_LIB is not set
 
-# CONFIG_CFG80211 is not set
 
-# CONFIG_CGROUPS is not set
 
-# CONFIG_CGROUP_DEBUG is not set
 
-# CONFIG_CHARGER_GPIO is not set
 
-# CONFIG_CHARGER_LP8727 is not set
 
-# CONFIG_CHARGER_MAX8903 is not set
 
-# CONFIG_CHECKPOINT_RESTORE is not set
 
-# CONFIG_CHELSIO_T1 is not set
 
-# CONFIG_CHELSIO_T3 is not set
 
-# CONFIG_CHELSIO_T4 is not set
 
-# CONFIG_CHELSIO_T4VF is not set
 
-# CONFIG_CHR_DEV_OSST is not set
 
-# CONFIG_CHR_DEV_SCH is not set
 
-# CONFIG_CHR_DEV_SG is not set
 
-# CONFIG_CHR_DEV_ST is not set
 
-# CONFIG_CICADA_PHY is not set
 
-# CONFIG_CIFS is not set
 
-# CONFIG_CIFS_ACL is not set
 
-# CONFIG_CIFS_DEBUG2 is not set
 
-# CONFIG_CIFS_FSCACHE is not set
 
-# CONFIG_CIFS_NFSD_EXPORT is not set
 
-CONFIG_CIFS_POSIX=y
 
-CONFIG_CIFS_STATS=y
 
-# CONFIG_CIFS_STATS2 is not set
 
-# CONFIG_CIFS_WEAK_PW_HASH is not set
 
-# CONFIG_CIFS_XATTR is not set
 
-# CONFIG_CLEANCACHE is not set
 
-CONFIG_CLS_U32_MARK=y
 
-# CONFIG_CLS_U32_PERF is not set
 
-CONFIG_CMDLINE=""
 
-# CONFIG_CMDLINE_BOOL is not set
 
-# CONFIG_CMDLINE_EXTEND is not set
 
-# CONFIG_CMDLINE_FORCE is not set
 
-# CONFIG_CMDLINE_FROM_BOOTLOADER is not set
 
-# CONFIG_CNIC is not set
 
-# CONFIG_CODA_FS is not set
 
-# CONFIG_CODE_PATCHING_SELFTEST is not set
 
-# CONFIG_COMEDI is not set
 
-# CONFIG_COMPACTION is not set
 
-# CONFIG_COMPAL_LAPTOP is not set
 
-# CONFIG_COMPAT_BRK is not set
 
-# CONFIG_CONFIGFS_FS is not set
 
-# CONFIG_CONNECTOR is not set
 
-CONFIG_CONSTRUCTORS=y
 
-# CONFIG_CONTEXT_SWITCH_TRACER is not set
 
-# CONFIG_COPS is not set
 
-# CONFIG_CORDIC is not set
 
-# CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS is not set
 
-# CONFIG_CPA_DEBUG is not set
 
-# CONFIG_CPU_DCACHE_DISABLE is not set
 
-# CONFIG_CPU_FREQ is not set
 
-# CONFIG_CPU_IDLE is not set
 
-# CONFIG_CRAMFS is not set
 
-CONFIG_CRASHLOG=y
 
-# CONFIG_CRASH_DUMP is not set
 
-# CONFIG_CRC16 is not set
 
-CONFIG_CRC32=y
 
-# CONFIG_CRC7 is not set
 
-# CONFIG_CRC8 is not set
 
-# CONFIG_CRC_CCITT is not set
 
-# CONFIG_CRC_ITU_T is not set
 
-# CONFIG_CRC_T10DIF is not set
 
-CONFIG_CROSS_COMPILE=""
 
-CONFIG_CRYPTO=y
 
-# CONFIG_CRYPTO_AEAD is not set
 
-# CONFIG_CRYPTO_AES is not set
 
-# CONFIG_CRYPTO_AES_586 is not set
 
-# CONFIG_CRYPTO_AES_NI_INTEL is not set
 
-# CONFIG_CRYPTO_ALGAPI is not set
 
-# CONFIG_CRYPTO_ALGAPI2 is not set
 
-# CONFIG_CRYPTO_ANSI_CPRNG is not set
 
-# CONFIG_CRYPTO_ANUBIS is not set
 
-# CONFIG_CRYPTO_ARC4 is not set
 
-# CONFIG_CRYPTO_AUTHENC is not set
 
-# CONFIG_CRYPTO_BLKCIPHER is not set
 
-# CONFIG_CRYPTO_BLOWFISH is not set
 
-# CONFIG_CRYPTO_CAMELLIA is not set
 
-# CONFIG_CRYPTO_CAST5 is not set
 
-# CONFIG_CRYPTO_CAST6 is not set
 
-# CONFIG_CRYPTO_CBC is not set
 
-# CONFIG_CRYPTO_CCM is not set
 
-# CONFIG_CRYPTO_CRC32C is not set
 
-# CONFIG_CRYPTO_CRC32C_INTEL is not set
 
-# CONFIG_CRYPTO_CRYPTD is not set
 
-# CONFIG_CRYPTO_CTR is not set
 
-# CONFIG_CRYPTO_CTS is not set
 
-# CONFIG_CRYPTO_DEFLATE is not set
 
-# CONFIG_CRYPTO_DES is not set
 
-# CONFIG_CRYPTO_DEV_FSL_CAAM is not set
 
-# CONFIG_CRYPTO_DEV_HIFN_795X is not set
 
-# CONFIG_CRYPTO_DEV_MV_CESA is not set
 
-# CONFIG_CRYPTO_DEV_TALITOS is not set
 
-# CONFIG_CRYPTO_ECB is not set
 
-# CONFIG_CRYPTO_FCRYPT is not set
 
-# CONFIG_CRYPTO_FIPS is not set
 
-# CONFIG_CRYPTO_GCM is not set
 
-# CONFIG_CRYPTO_GF128MUL is not set
 
-# CONFIG_CRYPTO_GHASH is not set
 
-# CONFIG_CRYPTO_GHASH_CLMUL_NI_INTEL is not set
 
-# CONFIG_CRYPTO_HASH is not set
 
-# CONFIG_CRYPTO_HMAC is not set
 
-# CONFIG_CRYPTO_HW is not set
 
-# CONFIG_CRYPTO_KHAZAD is not set
 
-# CONFIG_CRYPTO_LRW is not set
 
-# CONFIG_CRYPTO_LZO is not set
 
-# CONFIG_CRYPTO_MANAGER is not set
 
-# CONFIG_CRYPTO_MANAGER2 is not set
 
-CONFIG_CRYPTO_MANAGER_DISABLE_TESTS=y
 
-# CONFIG_CRYPTO_MD4 is not set
 
-# CONFIG_CRYPTO_MD5 is not set
 
-# CONFIG_CRYPTO_MICHAEL_MIC is not set
 
-# CONFIG_CRYPTO_NULL is not set
 
-# CONFIG_CRYPTO_PCBC is not set
 
-# CONFIG_CRYPTO_PCOMP is not set
 
-# CONFIG_CRYPTO_PCOMP2 is not set
 
-# CONFIG_CRYPTO_PCRYPT is not set
 
-# CONFIG_CRYPTO_RMD128 is not set
 
-# CONFIG_CRYPTO_RMD160 is not set
 
-# CONFIG_CRYPTO_RMD256 is not set
 
-# CONFIG_CRYPTO_RMD320 is not set
 
-# CONFIG_CRYPTO_RNG is not set
 
-# CONFIG_CRYPTO_SALSA20 is not set
 
-# CONFIG_CRYPTO_SALSA20_586 is not set
 
-# CONFIG_CRYPTO_SEED is not set
 
-# CONFIG_CRYPTO_SEQIV is not set
 
-# CONFIG_CRYPTO_SERPENT is not set
 
-# CONFIG_CRYPTO_SHA1 is not set
 
-# CONFIG_CRYPTO_SHA256 is not set
 
-# CONFIG_CRYPTO_SHA512 is not set
 
-# CONFIG_CRYPTO_TEA is not set
 
-# CONFIG_CRYPTO_TEST is not set
 
-# CONFIG_CRYPTO_TGR192 is not set
 
-# CONFIG_CRYPTO_TWOFISH is not set
 
-# CONFIG_CRYPTO_TWOFISH_586 is not set
 
-# CONFIG_CRYPTO_TWOFISH_COMMON is not set
 
-# CONFIG_CRYPTO_USER is not set
 
-# CONFIG_CRYPTO_USER_API_HASH is not set
 
-# CONFIG_CRYPTO_USER_API_SKCIPHER is not set
 
-# CONFIG_CRYPTO_VMAC is not set
 
-# CONFIG_CRYPTO_WP512 is not set
 
-# CONFIG_CRYPTO_XCBC is not set
 
-# CONFIG_CRYPTO_XTS is not set
 
-# CONFIG_CRYPTO_XZ is not set
 
-# CONFIG_CRYPTO_ZLIB is not set
 
-# CONFIG_CRYSTALHD is not set
 
-# CONFIG_CS5535_MFGPT is not set
 
-# CONFIG_CUSE is not set
 
-# CONFIG_CXT1E1 is not set
 
-# CONFIG_DAVICOM_PHY is not set
 
-# CONFIG_DCB is not set
 
-# CONFIG_DE600 is not set
 
-# CONFIG_DE620 is not set
 
-# CONFIG_DEBUG_ATOMIC_SLEEP is not set
 
-# CONFIG_DEBUG_BLOCK_EXT_DEVT is not set
 
-# CONFIG_DEBUG_BUGVERBOSE is not set
 
-# CONFIG_DEBUG_CREDENTIALS is not set
 
-# CONFIG_DEBUG_DEVRES is not set
 
-# CONFIG_DEBUG_DRIVER is not set
 
-# CONFIG_DEBUG_FORCE_WEAK_PER_CPU is not set
 
-CONFIG_DEBUG_FS=y
 
-# CONFIG_DEBUG_GPIO is not set
 
-# CONFIG_DEBUG_HIGHMEM is not set
 
-# CONFIG_DEBUG_ICEDCC is not set
 
-# CONFIG_DEBUG_INFO is not set
 
-CONFIG_DEBUG_INFO_REDUCED=y
 
-CONFIG_DEBUG_KERNEL=y
 
-# CONFIG_DEBUG_KMEMLEAK is not set
 
-# CONFIG_DEBUG_KOBJECT is not set
 
-# CONFIG_DEBUG_LIST is not set
 
-# CONFIG_DEBUG_LL is not set
 
-# CONFIG_DEBUG_LOCKDEP is not set
 
-# CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set
 
-# CONFIG_DEBUG_LOCK_ALLOC is not set
 
-# CONFIG_DEBUG_MEMORY_INIT is not set
 
-# CONFIG_DEBUG_MUTEXES is not set
 
-# CONFIG_DEBUG_NOTIFIERS is not set
 
-# CONFIG_DEBUG_NX_TEST is not set
 
-# CONFIG_DEBUG_OBJECTS is not set
 
-# CONFIG_DEBUG_PAGEALLOC is not set
 
-# CONFIG_DEBUG_PERF_USE_VMALLOC is not set
 
-# CONFIG_DEBUG_PER_CPU_MAPS is not set
 
-# CONFIG_DEBUG_PREEMPT is not set
 
-# CONFIG_DEBUG_RODATA is not set
 
-# CONFIG_DEBUG_RT_MUTEXES is not set
 
-# CONFIG_DEBUG_SECTION_MISMATCH is not set
 
-# CONFIG_DEBUG_SET_MODULE_RONX is not set
 
-# CONFIG_DEBUG_SG is not set
 
-# CONFIG_DEBUG_SHIRQ is not set
 
-# CONFIG_DEBUG_SLAB is not set
 
-# CONFIG_DEBUG_SPINLOCK is not set
 
-# CONFIG_DEBUG_STACKOVERFLOW is not set
 
-# CONFIG_DEBUG_STACK_USAGE is not set
 
-# CONFIG_DEBUG_STRICT_USER_COPY_CHECKS is not set
 
-# CONFIG_DEBUG_VM is not set
 
-# CONFIG_DEBUG_WRITECOUNT is not set
 
-# CONFIG_DECNET is not set
 
-CONFIG_DEFAULT_CUBIC=y
 
-CONFIG_DEFAULT_DEADLINE=y
 
-CONFIG_DEFAULT_HOSTNAME="(none)"
 
-CONFIG_DEFAULT_IOSCHED="deadline"
 
-CONFIG_DEFAULT_MESSAGE_LOGLEVEL=4
 
-CONFIG_DEFAULT_MMAP_MIN_ADDR=4096
 
-# CONFIG_DEFAULT_NOOP is not set
 
-# CONFIG_DEFAULT_RENO is not set
 
-CONFIG_DEFAULT_SECURITY=""
 
-CONFIG_DEFAULT_SECURITY_DAC=y
 
-CONFIG_DEFAULT_TCP_CONG="cubic"
 
-CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"
 
-# CONFIG_DEPRECATED_PARAM_STRUCT is not set
 
-# CONFIG_DETECT_HUNG_TASK is not set
 
-# CONFIG_DEVKMEM is not set
 
-CONFIG_DEVPORT=y
 
-# CONFIG_DEVPTS_MULTIPLE_INSTANCES is not set
 
-# CONFIG_DEVTMPFS is not set
 
-# CONFIG_DEVTMPFS_MOUNT is not set
 
-# CONFIG_DISCONTIGMEM_MANUAL is not set
 
-# CONFIG_DISPLAY_SUPPORT is not set
 
-# CONFIG_DL2K is not set
 
-# CONFIG_DLM is not set
 
-# CONFIG_DM9000 is not set
 
-# CONFIG_DMADEVICES is not set
 
-# CONFIG_DMADEVICES_DEBUG is not set
 
-# CONFIG_DMASCC is not set
 
-# CONFIG_DMATEST is not set
 
-# CONFIG_DMA_API_DEBUG is not set
 
-# CONFIG_DMA_ENGINE is not set
 
-# CONFIG_DMA_SHARED_BUFFER is not set
 
-# CONFIG_DM_DEBUG is not set
 
-# CONFIG_DM_DELAY is not set
 
-# CONFIG_DM_FLAKEY is not set
 
-# CONFIG_DM_LOG_USERSPACE is not set
 
-# CONFIG_DM_MULTIPATH is not set
 
-# CONFIG_DM_RAID is not set
 
-# CONFIG_DM_THIN_PROVISIONING is not set
 
-# CONFIG_DM_UEVENT is not set
 
-# CONFIG_DM_ZERO is not set
 
-# CONFIG_DNET is not set
 
-# CONFIG_DNOTIFY is not set
 
-CONFIG_DQL=y
 
-# CONFIG_DRAGONRISE_FF is not set
 
-# CONFIG_DRM is not set
 
-# CONFIG_DS1682 is not set
 
-# CONFIG_DTLK is not set
 
-# CONFIG_DUMMY is not set
 
-# CONFIG_DVB_CORE is not set
 
-# CONFIG_DW_WATCHDOG is not set
 
-# CONFIG_DX_SEP is not set
 
-# CONFIG_DYNAMIC_DEBUG is not set
 
-# CONFIG_E100 is not set
 
-# CONFIG_E1000 is not set
 
-# CONFIG_E1000E is not set
 
-# CONFIG_E2100 is not set
 
-# CONFIG_EASYCAP is not set
 
-# CONFIG_ECHO is not set
 
-# CONFIG_ECONET is not set
 
-# CONFIG_ECRYPT_FS is not set
 
-# CONFIG_EDAC is not set
 
-# CONFIG_EEPROM_93CX6 is not set
 
-# CONFIG_EEPROM_93XX46 is not set
 
-# CONFIG_EEPROM_AT24 is not set
 
-# CONFIG_EEPROM_AT25 is not set
 
-# CONFIG_EEPROM_DIGSY_MTC_CFG is not set
 
-# CONFIG_EEPROM_LEGACY is not set
 
-# CONFIG_EEPROM_MAX6875 is not set
 
-# CONFIG_EEXPRESS is not set
 
-# CONFIG_EEXPRESS_PRO is not set
 
-CONFIG_EFI_PARTITION=y
 
-# CONFIG_EFS_FS is not set
 
-# CONFIG_ELF_CORE is not set
 
-CONFIG_EMBEDDED=y
 
-# CONFIG_ENABLE_MUST_CHECK is not set
 
-CONFIG_ENABLE_WARN_DEPRECATED=y
 
-# CONFIG_ENC28J60 is not set
 
-# CONFIG_ENCLOSURE_SERVICES is not set
 
-# CONFIG_ENCRYPTED_KEYS is not set
 
-# CONFIG_ENIC is not set
 
-# CONFIG_EPIC100 is not set
 
-CONFIG_EPOLL=y
 
-# CONFIG_EQUALIZER is not set
 
-# CONFIG_ET131X is not set
 
-# CONFIG_ETH16I is not set
 
-CONFIG_ETHERNET=y
 
-# CONFIG_ETHOC is not set
 
-CONFIG_EVENTFD=y
 
-# CONFIG_EVENT_POWER_TRACING_DEPRECATED is not set
 
-# CONFIG_EWRK3 is not set
 
-CONFIG_EXPERIMENTAL=y
 
-CONFIG_EXPERT=y
 
-# CONFIG_EXPORTFS is not set
 
-# CONFIG_EXT2_FS is not set
 
-# CONFIG_EXT2_FS_XATTR is not set
 
-# CONFIG_EXT2_FS_XIP is not set
 
-# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 
-# CONFIG_EXT3_FS is not set
 
-# CONFIG_EXT3_FS_XATTR is not set
 
-# CONFIG_EXT4_DEBUG is not set
 
-# CONFIG_EXT4_FS is not set
 
-# CONFIG_EXT4_FS_POSIX_ACL is not set
 
-# CONFIG_EXT4_FS_SECURITY is not set
 
-CONFIG_EXT4_FS_XATTR=y
 
-CONFIG_EXT4_USE_FOR_EXT23=y
 
-CONFIG_EXTRA_FIRMWARE=""
 
-CONFIG_EXTRA_TARGETS=""
 
-# CONFIG_EZX_PCAP is not set
 
-# CONFIG_FAIR_GROUP_SCHED is not set
 
-# CONFIG_FANOTIFY is not set
 
-CONFIG_FAT_DEFAULT_CODEPAGE=437
 
-CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
 
-# CONFIG_FAT_FS is not set
 
-# CONFIG_FAULT_INJECTION is not set
 
-# CONFIG_FB is not set
 
-# CONFIG_FB_3DFX is not set
 
-# CONFIG_FB_ARC is not set
 
-# CONFIG_FB_ARK is not set
 
-# CONFIG_FB_ARMCLCD is not set
 
-# CONFIG_FB_ASILIANT is not set
 
-# CONFIG_FB_ATY is not set
 
-# CONFIG_FB_ATY128 is not set
 
-# CONFIG_FB_BACKLIGHT is not set
 
-# CONFIG_FB_BOOT_VESA_SUPPORT is not set
 
-# CONFIG_FB_BROADSHEET is not set
 
-# CONFIG_FB_CARMINE is not set
 
-# CONFIG_FB_CFB_COPYAREA is not set
 
-# CONFIG_FB_CFB_FILLRECT is not set
 
-# CONFIG_FB_CFB_IMAGEBLIT is not set
 
-# CONFIG_FB_CFB_REV_PIXELS_IN_BYTE is not set
 
-# CONFIG_FB_CIRRUS is not set
 
-# CONFIG_FB_CYBER2000 is not set
 
-# CONFIG_FB_DDC is not set
 
-# CONFIG_FB_FOREIGN_ENDIAN is not set
 
-# CONFIG_FB_GEODE is not set
 
-# CONFIG_FB_HGA is not set
 
-# CONFIG_FB_IBM_GXT4500 is not set
 
-# CONFIG_FB_IMSTT is not set
 
-# CONFIG_FB_KYRO is not set
 
-# CONFIG_FB_LE80578 is not set
 
-# CONFIG_FB_MACMODES is not set
 
-# CONFIG_FB_MATROX is not set
 
-# CONFIG_FB_MB862XX is not set
 
-# CONFIG_FB_METRONOME is not set
 
-# CONFIG_FB_MODE_HELPERS is not set
 
-# CONFIG_FB_N411 is not set
 
-# CONFIG_FB_NEOMAGIC is not set
 
-# CONFIG_FB_NVIDIA is not set
 
-# CONFIG_FB_OF is not set
 
-# CONFIG_FB_PM2 is not set
 
-# CONFIG_FB_PM3 is not set
 
-# CONFIG_FB_PS3 is not set
 
-# CONFIG_FB_PXA is not set
 
-# CONFIG_FB_RADEON is not set
 
-# CONFIG_FB_RIVA is not set
 
-# CONFIG_FB_S1D13XXX is not set
 
-# CONFIG_FB_S3 is not set
 
-# CONFIG_FB_SAVAGE is not set
 
-# CONFIG_FB_SIS is not set
 
-# CONFIG_FB_SM7XX is not set
 
-# CONFIG_FB_SMSCUFX is not set
 
-# CONFIG_FB_SVGALIB is not set
 
-# CONFIG_FB_SYS_COPYAREA is not set
 
-# CONFIG_FB_SYS_FILLRECT is not set
 
-# CONFIG_FB_SYS_FOPS is not set
 
-# CONFIG_FB_SYS_IMAGEBLIT is not set
 
-# CONFIG_FB_TILEBLITTING is not set
 
-# CONFIG_FB_TMIO is not set
 
-# CONFIG_FB_TRIDENT is not set
 
-# CONFIG_FB_UDL is not set
 
-# CONFIG_FB_VGA16 is not set
 
-# CONFIG_FB_VIA is not set
 
-# CONFIG_FB_VIRTUAL is not set
 
-# CONFIG_FB_VOODOO1 is not set
 
-# CONFIG_FB_VT8623 is not set
 
-# CONFIG_FB_XGI is not set
 
-# CONFIG_FCOE is not set
 
-# CONFIG_FCOE_FNIC is not set
 
-# CONFIG_FDDI is not set
 
-# CONFIG_FEALNX is not set
 
-# CONFIG_FHANDLE is not set
 
-CONFIG_FIB_RULES=y
 
-CONFIG_FILE_LOCKING=y
 
-# CONFIG_FIREWIRE is not set
 
-# CONFIG_FIREWIRE_NOSY is not set
 
-# CONFIG_FIRMWARE_EDID is not set
 
-# CONFIG_FIRMWARE_IN_KERNEL is not set
 
-# CONFIG_FIXED_PHY is not set
 
-CONFIG_FLATMEM=y
 
-CONFIG_FLATMEM_MANUAL=y
 
-CONFIG_FLAT_NODE_MEM_MAP=y
 
-# CONFIG_FORCEDETH is not set
 
-CONFIG_FORCE_MAX_ZONEORDER=11
 
-# CONFIG_FRAMEBUFFER_CONSOLE is not set
 
-# CONFIG_FRAME_POINTER is not set
 
-CONFIG_FRAME_WARN=1024
 
-# CONFIG_FREEZER is not set
 
-# CONFIG_FRONTSWAP is not set
 
-# CONFIG_FSCACHE is not set
 
-CONFIG_FSNOTIFY=y
 
-# CONFIG_FS_POSIX_ACL is not set
 
-# CONFIG_FT1000 is not set
 
-# CONFIG_FTGMAC100 is not set
 
-# CONFIG_FTL is not set
 
-# CONFIG_FTMAC100 is not set
 
-# CONFIG_FTRACE is not set
 
-# CONFIG_FTRACE_STARTUP_TEST is not set
 
-# CONFIG_FTR_FIXUP_SELFTEST is not set
 
-# CONFIG_FUJITSU_TABLET is not set
 
-# CONFIG_FUNCTION_TRACER is not set
 
-# CONFIG_FUSE_FS is not set
 
-# CONFIG_FUSION is not set
 
-# CONFIG_FUSION_FC is not set
 
-# CONFIG_FUSION_SAS is not set
 
-# CONFIG_FUSION_SPI is not set
 
-CONFIG_FUTEX=y
 
-CONFIG_FW_LOADER=y
 
-CONFIG_GACT_PROB=y
 
-# CONFIG_GAMEPORT is not set
 
-# CONFIG_GCOV is not set
 
-# CONFIG_GCOV_KERNEL is not set
 
-CONFIG_GENERIC_CALIBRATE_DELAY=y
 
-# CONFIG_GENERIC_CPU_DEVICES is not set
 
-CONFIG_GENERIC_HARDIRQS=y
 
-CONFIG_GENERIC_HWEIGHT=y
 
-CONFIG_GENERIC_IRQ_PROBE=y
 
-CONFIG_GENERIC_TIME=y
 
-# CONFIG_GFS2_FS is not set
 
-# CONFIG_GIGASET_CAPI is not set
 
-# CONFIG_GIGASET_DEBUG is not set
 
-# CONFIG_GPIOLIB is not set
 
-# CONFIG_GPIO_74X164 is not set
 
-# CONFIG_GPIO_ADP5588 is not set
 
-# CONFIG_GPIO_BT8XX is not set
 
-# CONFIG_GPIO_CS5535 is not set
 
-# CONFIG_GPIO_GENERIC_PLATFORM is not set
 
-# CONFIG_GPIO_IT8761E is not set
 
-# CONFIG_GPIO_LANGWELL is not set
 
-# CONFIG_GPIO_MAX7300 is not set
 
-# CONFIG_GPIO_MAX7301 is not set
 
-# CONFIG_GPIO_MAX732X is not set
 
-# CONFIG_GPIO_MC33880 is not set
 
-# CONFIG_GPIO_MCP23S08 is not set
 
-# CONFIG_GPIO_ML_IOH is not set
 
-# CONFIG_GPIO_PCA953X is not set
 
-# CONFIG_GPIO_PCF857X is not set
 
-# CONFIG_GPIO_PCH is not set
 
-# CONFIG_GPIO_PL061 is not set
 
-# CONFIG_GPIO_RDC321X is not set
 
-# CONFIG_GPIO_SCH is not set
 
-# CONFIG_GPIO_SX150X is not set
 
-# CONFIG_GPIO_SYSFS is not set
 
-# CONFIG_GPIO_VX855 is not set
 
-# CONFIG_GPIO_XILINX is not set
 
-# CONFIG_GREENASIA_FF is not set
 
-# CONFIG_HAMACHI is not set
 
-CONFIG_HAMRADIO=y
 
-# CONFIG_HAPPYMEAL is not set
 
-# CONFIG_HARDLOCKUP_DETECTOR is not set
 
-# CONFIG_HAVE_AOUT is not set
 
-CONFIG_HAVE_KPROBES=y
 
-CONFIG_HAVE_KRETPROBES=y
 
-# CONFIG_HCALL_STATS is not set
 
-# CONFIG_HDLC is not set
 
-# CONFIG_HDLC_CISCO is not set
 
-# CONFIG_HDLC_FR is not set
 
-# CONFIG_HDLC_PPP is not set
 
-# CONFIG_HDLC_RAW is not set
 
-# CONFIG_HDLC_RAW_ETH is not set
 
-# CONFIG_HEADERS_CHECK is not set
 
-# CONFIG_HERMES is not set
 
-# CONFIG_HFSPLUS_FS is not set
 
-# CONFIG_HFS_FS is not set
 
-# CONFIG_HIBERNATION is not set
 
-# CONFIG_HID is not set
 
-# CONFIG_HIDRAW is not set
 
-# CONFIG_HID_A4TECH is not set
 
-# CONFIG_HID_ACRUX is not set
 
-# CONFIG_HID_ACRUX_FF is not set
 
-# CONFIG_HID_APPLE is not set
 
-# CONFIG_HID_BELKIN is not set
 
-# CONFIG_HID_CHERRY is not set
 
-# CONFIG_HID_CHICONY is not set
 
-# CONFIG_HID_CYPRESS is not set
 
-# CONFIG_HID_DRAGONRISE is not set
 
-# CONFIG_HID_ELECOM is not set
 
-# CONFIG_HID_EMS_FF is not set
 
-# CONFIG_HID_EZKEY is not set
 
-# CONFIG_HID_GREENASIA is not set
 
-# CONFIG_HID_GYRATION is not set
 
-# CONFIG_HID_HOLTEK is not set
 
-# CONFIG_HID_KENSINGTON is not set
 
-# CONFIG_HID_KEYTOUCH is not set
 
-# CONFIG_HID_KYE is not set
 
-# CONFIG_HID_LCPOWER is not set
 
-# CONFIG_HID_LOGITECH is not set
 
-# CONFIG_HID_MAGICMOUSE is not set
 
-# CONFIG_HID_MICROSOFT is not set
 
-# CONFIG_HID_MONTEREY is not set
 
-# CONFIG_HID_MULTITOUCH is not set
 
-# CONFIG_HID_NTRIG is not set
 
-# CONFIG_HID_ORTEK is not set
 
-# CONFIG_HID_PANTHERLORD is not set
 
-# CONFIG_HID_PETALYNX is not set
 
-# CONFIG_HID_PICOLCD is not set
 
-# CONFIG_HID_PID is not set
 
-# CONFIG_HID_PRIMAX is not set
 
-# CONFIG_HID_PRODIKEYS is not set
 
-# CONFIG_HID_QUANTA is not set
 
-# CONFIG_HID_ROCCAT is not set
 
-# CONFIG_HID_ROCCAT_ARVO is not set
 
-# CONFIG_HID_ROCCAT_KONE is not set
 
-# CONFIG_HID_ROCCAT_KONEPLUS is not set
 
-# CONFIG_HID_ROCCAT_KOVAPLUS is not set
 
-# CONFIG_HID_ROCCAT_PYRA is not set
 
-# CONFIG_HID_SAMSUNG is not set
 
-# CONFIG_HID_SMARTJOYPLUS is not set
 
-# CONFIG_HID_SONY is not set
 
-# CONFIG_HID_SPEEDLINK is not set
 
-# CONFIG_HID_SUNPLUS is not set
 
-# CONFIG_HID_SUPPORT is not set
 
-# CONFIG_HID_THRUSTMASTER is not set
 
-# CONFIG_HID_TOPSEED is not set
 
-# CONFIG_HID_TWINHAN is not set
 
-# CONFIG_HID_UCLOGIC is not set
 
-# CONFIG_HID_WACOM is not set
 
-# CONFIG_HID_WALTOP is not set
 
-# CONFIG_HID_WIIMOTE is not set
 
-# CONFIG_HID_ZEROPLUS is not set
 
-# CONFIG_HID_ZYDACRON is not set
 
-# CONFIG_HIGHMEM is not set
 
-CONFIG_HIGH_RES_TIMERS=y
 
-# CONFIG_HIPPI is not set
 
-# CONFIG_HMC6352 is not set
 
-# CONFIG_HOSTAP is not set
 
-# CONFIG_HOSTAP_CS is not set
 
-# CONFIG_HOSTAP_PCI is not set
 
-# CONFIG_HOSTAP_PLX is not set
 
-CONFIG_HOTPLUG=y
 
-# CONFIG_HOTPLUG_CPU is not set
 
-# CONFIG_HOTPLUG_PCI is not set
 
-# CONFIG_HP100 is not set
 
-# CONFIG_HPFS_FS is not set
 
-# CONFIG_HPLAN is not set
 
-# CONFIG_HPLAN_PLUS is not set
 
-# CONFIG_HP_ILO is not set
 
-# CONFIG_HTC_EGPIO is not set
 
-# CONFIG_HTC_I2CPLD is not set
 
-# CONFIG_HTC_PASIC3 is not set
 
-# CONFIG_HUGETLB_PAGE is not set
 
-# CONFIG_HVC_DCC is not set
 
-# CONFIG_HVC_UDBG is not set
 
-# CONFIG_HWMON is not set
 
-# CONFIG_HWMON_DEBUG_CHIP is not set
 
-# CONFIG_HWMON_VID is not set
 
-# CONFIG_HWSPINLOCK_OMAP is not set
 
-CONFIG_HW_PERF_EVENTS=y
 
-# CONFIG_HW_RANDOM is not set
 
-# CONFIG_HW_RANDOM_AMD is not set
 
-# CONFIG_HW_RANDOM_GEODE is not set
 
-# CONFIG_HW_RANDOM_INTEL is not set
 
-# CONFIG_HW_RANDOM_PPC4XX is not set
 
-# CONFIG_HW_RANDOM_TIMERIOMEM is not set
 
-# CONFIG_HW_RANDOM_VIA is not set
 
-# CONFIG_HYPERV is not set
 
-# CONFIG_HYSDN is not set
 
-CONFIG_HZ=100
 
-CONFIG_HZ_100=y
 
-# CONFIG_HZ_1000 is not set
 
-# CONFIG_HZ_1024 is not set
 
-# CONFIG_HZ_128 is not set
 
-# CONFIG_HZ_250 is not set
 
-# CONFIG_HZ_256 is not set
 
-# CONFIG_HZ_300 is not set
 
-# CONFIG_HZ_48 is not set
 
-# CONFIG_I2C is not set
 
-# CONFIG_I2C_ALGOBIT is not set
 
-# CONFIG_I2C_ALGOPCA is not set
 
-# CONFIG_I2C_ALGOPCF is not set
 
-# CONFIG_I2C_ALI1535 is not set
 
-# CONFIG_I2C_ALI1563 is not set
 
-# CONFIG_I2C_ALI15X3 is not set
 
-# CONFIG_I2C_AMD756 is not set
 
-# CONFIG_I2C_AMD8111 is not set
 
-# CONFIG_I2C_CHARDEV is not set
 
-# CONFIG_I2C_COMPAT is not set
 
-# CONFIG_I2C_DEBUG_ALGO is not set
 
-# CONFIG_I2C_DEBUG_BUS is not set
 
-# CONFIG_I2C_DEBUG_CORE is not set
 
-# CONFIG_I2C_DESIGNWARE is not set
 
-# CONFIG_I2C_DESIGNWARE_PCI is not set
 
-# CONFIG_I2C_DESIGNWARE_PLATFORM is not set
 
-# CONFIG_I2C_DIOLAN_U2C is not set
 
-# CONFIG_I2C_EG20T is not set
 
-# CONFIG_I2C_ELEKTOR is not set
 
-# CONFIG_I2C_GPIO is not set
 
-# CONFIG_I2C_HELPER_AUTO is not set
 
-# CONFIG_I2C_I801 is not set
 
-# CONFIG_I2C_IBM_IIC is not set
 
-# CONFIG_I2C_INTEL_MID is not set
 
-# CONFIG_I2C_ISCH is not set
 
-# CONFIG_I2C_MPC is not set
 
-# CONFIG_I2C_MUX is not set
 
-# CONFIG_I2C_MV64XXX is not set
 
-# CONFIG_I2C_NFORCE2 is not set
 
-# CONFIG_I2C_OCORES is not set
 
-# CONFIG_I2C_PARPORT is not set
 
-# CONFIG_I2C_PARPORT_LIGHT is not set
 
-# CONFIG_I2C_PCA_ISA is not set
 
-# CONFIG_I2C_PCA_PLATFORM is not set
 
-# CONFIG_I2C_PIIX4 is not set
 
-# CONFIG_I2C_PXA_PCI is not set
 
-# CONFIG_I2C_SCMI is not set
 
-# CONFIG_I2C_SIMTEC is not set
 
-# CONFIG_I2C_SIS5595 is not set
 
-# CONFIG_I2C_SIS630 is not set
 
-# CONFIG_I2C_SIS96X is not set
 
-# CONFIG_I2C_SMBUS is not set
 
-# CONFIG_I2C_STUB is not set
 
-# CONFIG_I2C_TAOS_EVM is not set
 
-# CONFIG_I2C_TINY_USB is not set
 
-# CONFIG_I2C_VERSATILE is not set
 
-# CONFIG_I2C_VIA is not set
 
-# CONFIG_I2C_VIAPRO is not set
 
-# CONFIG_I2C_XILINX is not set
 
-# CONFIG_I2O is not set
 
-# CONFIG_I82092 is not set
 
-# CONFIG_I82365 is not set
 
-# CONFIG_IBM_ASM is not set
 
-# CONFIG_IBM_EMAC_DEBUG is not set
 
-# CONFIG_IBM_EMAC_EMAC4 is not set
 
-# CONFIG_IBM_EMAC_MAL_CLR_ICINTSTAT is not set
 
-# CONFIG_IBM_EMAC_MAL_COMMON_ERR is not set
 
-# CONFIG_IBM_EMAC_NO_FLOW_CTRL is not set
 
-# CONFIG_IBM_EMAC_RGMII is not set
 
-# CONFIG_IBM_EMAC_TAH is not set
 
-# CONFIG_IBM_EMAC_ZMII is not set
 
-# CONFIG_ICPLUS_PHY is not set
 
-# CONFIG_ICS932S401 is not set
 
-# CONFIG_IDE is not set
 
-# CONFIG_IDEAPAD_LAPTOP is not set
 
-# CONFIG_IDE_GD is not set
 
-# CONFIG_IDE_PHISON is not set
 
-# CONFIG_IDE_PROC_FS is not set
 
-# CONFIG_IDE_TASK_IOCTL is not set
 
-# CONFIG_IEEE802154 is not set
 
-# CONFIG_IFB is not set
 
-# CONFIG_IGB is not set
 
-# CONFIG_IGBVF is not set
 
-# CONFIG_IIO is not set
 
-# CONFIG_IKCONFIG is not set
 
-# CONFIG_IKCONFIG_PROC is not set
 
-# CONFIG_IMAGE_CMDLINE_HACK is not set
 
-CONFIG_INET=y
 
-# CONFIG_INET6_AH is not set
 
-# CONFIG_INET6_ESP is not set
 
-# CONFIG_INET6_IPCOMP is not set
 
-# CONFIG_INET6_TUNNEL is not set
 
-# CONFIG_INET6_XFRM_MODE_BEET is not set
 
-# CONFIG_INET6_XFRM_MODE_ROUTEOPTIMIZATION is not set
 
-# CONFIG_INET6_XFRM_MODE_TRANSPORT is not set
 
-# CONFIG_INET6_XFRM_MODE_TUNNEL is not set
 
-# CONFIG_INET6_XFRM_TUNNEL is not set
 
-# CONFIG_INET_AH is not set
 
-# CONFIG_INET_DIAG is not set
 
-# CONFIG_INET_ESP is not set
 
-# CONFIG_INET_IPCOMP is not set
 
-# CONFIG_INET_LRO is not set
 
-# CONFIG_INET_TCP_DIAG is not set
 
-# CONFIG_INET_TUNNEL is not set
 
-# CONFIG_INET_UDP_DIAG is not set
 
-# CONFIG_INET_XFRM_MODE_BEET is not set
 
-# CONFIG_INET_XFRM_MODE_TRANSPORT is not set
 
-# CONFIG_INET_XFRM_MODE_TUNNEL is not set
 
-# CONFIG_INET_XFRM_TUNNEL is not set
 
-# CONFIG_INFINIBAND is not set
 
-# CONFIG_INFTL is not set
 
-# CONFIG_INITRAMFS_COMPRESSION_BZIP2 is not set
 
-# CONFIG_INITRAMFS_COMPRESSION_GZIP is not set
 
-# CONFIG_INITRAMFS_COMPRESSION_LZMA is not set
 
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 
-CONFIG_INIT_ENV_ARG_LIMIT=32
 
-# CONFIG_INLINE_READ_LOCK is not set
 
-# CONFIG_INLINE_READ_LOCK_BH is not set
 
-# CONFIG_INLINE_READ_LOCK_IRQ is not set
 
-# CONFIG_INLINE_READ_LOCK_IRQSAVE is not set
 
-# CONFIG_INLINE_READ_TRYLOCK is not set
 
-CONFIG_INLINE_READ_UNLOCK=y
 
-# CONFIG_INLINE_READ_UNLOCK_BH is not set
 
-CONFIG_INLINE_READ_UNLOCK_IRQ=y
 
-# CONFIG_INLINE_READ_UNLOCK_IRQRESTORE is not set
 
-# CONFIG_INLINE_SPIN_LOCK is not set
 
-# CONFIG_INLINE_SPIN_LOCK_BH is not set
 
-# CONFIG_INLINE_SPIN_LOCK_IRQ is not set
 
-# CONFIG_INLINE_SPIN_LOCK_IRQSAVE is not set
 
-# CONFIG_INLINE_SPIN_TRYLOCK is not set
 
-# CONFIG_INLINE_SPIN_TRYLOCK_BH is not set
 
-CONFIG_INLINE_SPIN_UNLOCK=y
 
-# CONFIG_INLINE_SPIN_UNLOCK_BH is not set
 
-CONFIG_INLINE_SPIN_UNLOCK_IRQ=y
 
-# CONFIG_INLINE_SPIN_UNLOCK_IRQRESTORE is not set
 
-# CONFIG_INLINE_WRITE_LOCK is not set
 
-# CONFIG_INLINE_WRITE_LOCK_BH is not set
 
-# CONFIG_INLINE_WRITE_LOCK_IRQ is not set
 
-# CONFIG_INLINE_WRITE_LOCK_IRQSAVE is not set
 
-# CONFIG_INLINE_WRITE_TRYLOCK is not set
 
-CONFIG_INLINE_WRITE_UNLOCK=y
 
-# CONFIG_INLINE_WRITE_UNLOCK_BH is not set
 
-CONFIG_INLINE_WRITE_UNLOCK_IRQ=y
 
-# CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE is not set
 
-CONFIG_INOTIFY_USER=y
 
-# CONFIG_INPUT is not set
 
-# CONFIG_INPUT_AD714X is not set
 
-# CONFIG_INPUT_ADXL34X is not set
 
-# CONFIG_INPUT_APANEL is not set
 
-# CONFIG_INPUT_ATI_REMOTE is not set
 
-# CONFIG_INPUT_ATI_REMOTE2 is not set
 
-# CONFIG_INPUT_ATLAS_BTNS is not set
 
-# CONFIG_INPUT_BMA150 is not set
 
-# CONFIG_INPUT_CM109 is not set
 
-# CONFIG_INPUT_CMA3000 is not set
 
-# CONFIG_INPUT_EVBUG is not set
 
-# CONFIG_INPUT_EVDEV is not set
 
-# CONFIG_INPUT_FF_MEMLESS is not set
 
-# CONFIG_INPUT_GP2A is not set
 
-# CONFIG_INPUT_GPIO_ROTARY_ENCODER is not set
 
-# CONFIG_INPUT_GPIO_TILT_POLLED is not set
 
-# CONFIG_INPUT_JOYDEV is not set
 
-# CONFIG_INPUT_JOYSTICK is not set
 
-# CONFIG_INPUT_KEYBOARD is not set
 
-# CONFIG_INPUT_KEYSPAN_REMOTE is not set
 
-# CONFIG_INPUT_KXTJ9 is not set
 
-CONFIG_INPUT_MISC=y
 
-# CONFIG_INPUT_MMA8450 is not set
 
-# CONFIG_INPUT_MOUSE is not set
 
-# CONFIG_INPUT_MOUSEDEV is not set
 
-# CONFIG_INPUT_MPU3050 is not set
 
-# CONFIG_INPUT_PCF8574 is not set
 
-# CONFIG_INPUT_PCSPKR is not set
 
-# CONFIG_INPUT_POLLDEV is not set
 
-# CONFIG_INPUT_POWERMATE is not set
 
-# CONFIG_INPUT_SPARSEKMAP is not set
 
-# CONFIG_INPUT_TABLET is not set
 
-# CONFIG_INPUT_TOUCHSCREEN is not set
 
-# CONFIG_INPUT_UINPUT is not set
 
-# CONFIG_INPUT_WISTRON_BTNS is not set
 
-# CONFIG_INPUT_YEALINK is not set
 
-# CONFIG_INTEL_IDLE is not set
 
-# CONFIG_INTEL_MID_PTI is not set
 
-# CONFIG_INTEL_OAKTRAIL is not set
 
-# CONFIG_IOMMU_SUPPORT is not set
 
-# CONFIG_IOSCHED_CFQ is not set
 
-CONFIG_IOSCHED_DEADLINE=y
 
-CONFIG_IOSCHED_NOOP=y
 
-# CONFIG_IP1000 is not set
 
-# CONFIG_IP17XX_PHY is not set
 
-# CONFIG_IP6_NF_FILTER is not set
 
-# CONFIG_IP6_NF_IPTABLES is not set
 
-# CONFIG_IP6_NF_MANGLE is not set
 
-# CONFIG_IP6_NF_MATCH_AH is not set
 
-# CONFIG_IP6_NF_MATCH_EUI64 is not set
 
-# CONFIG_IP6_NF_MATCH_FRAG is not set
 
-# CONFIG_IP6_NF_MATCH_HL is not set
 
-# CONFIG_IP6_NF_MATCH_IPV6HEADER is not set
 
-# CONFIG_IP6_NF_MATCH_MH is not set
 
-# CONFIG_IP6_NF_MATCH_OPTS is not set
 
-# CONFIG_IP6_NF_MATCH_RPFILTER is not set
 
-# CONFIG_IP6_NF_MATCH_RT is not set
 
-# CONFIG_IP6_NF_QUEUE is not set
 
-# CONFIG_IP6_NF_RAW is not set
 
-# CONFIG_IP6_NF_TARGET_HL is not set
 
-# CONFIG_IP6_NF_TARGET_LOG is not set
 
-# CONFIG_IP6_NF_TARGET_REJECT is not set
 
-# CONFIG_IPC_NS is not set
 
-# CONFIG_IPMI_HANDLER is not set
 
-# CONFIG_IPV6 is not set
 
-# CONFIG_IPV6_MIP6 is not set
 
-# CONFIG_IPV6_MROUTE is not set
 
-# CONFIG_IPV6_MROUTE_MULTIPLE_TABLES is not set
 
-# CONFIG_IPV6_MULTIPLE_TABLES is not set
 
-CONFIG_IPV6_NDISC_NODETYPE=y
 
-# CONFIG_IPV6_OPTIMISTIC_DAD is not set
 
-# CONFIG_IPV6_PRIVACY is not set
 
-# CONFIG_IPV6_ROUTER_PREF is not set
 
-# CONFIG_IPV6_ROUTE_INFO is not set
 
-# CONFIG_IPV6_SIT is not set
 
-# CONFIG_IPV6_SIT_6RD is not set
 
-# CONFIG_IPV6_TUNNEL is not set
 
-# CONFIG_IPW2100 is not set
 
-# CONFIG_IPW2100_DEBUG is not set
 
-CONFIG_IPW2100_MONITOR=y
 
-# CONFIG_IPW2200 is not set
 
-# CONFIG_IPW2200_DEBUG is not set
 
-CONFIG_IPW2200_MONITOR=y
 
-# CONFIG_IPW2200_PROMISCUOUS is not set
 
-# CONFIG_IPW2200_QOS is not set
 
-# CONFIG_IPW2200_RADIOTAP is not set
 
-# CONFIG_IPWIRELESS is not set
 
-# CONFIG_IPX is not set
 
-CONFIG_IP_ADVANCED_ROUTER=y
 
-# CONFIG_IP_DCCP is not set
 
-# CONFIG_IP_FIB_TRIE_STATS is not set
 
-CONFIG_IP_MROUTE=y
 
-CONFIG_IP_MROUTE_MULTIPLE_TABLES=y
 
-CONFIG_IP_MULTICAST=y
 
-CONFIG_IP_MULTIPLE_TABLES=y
 
-# CONFIG_IP_NF_ARPFILTER is not set
 
-# CONFIG_IP_NF_ARPTABLES is not set
 
-# CONFIG_IP_NF_ARP_MANGLE is not set
 
-# CONFIG_IP_NF_FILTER is not set
 
-# CONFIG_IP_NF_IPTABLES is not set
 
-# CONFIG_IP_NF_MANGLE is not set
 
-# CONFIG_IP_NF_MATCH_AH is not set
 
-# CONFIG_IP_NF_MATCH_ECN is not set
 
-# CONFIG_IP_NF_MATCH_RPFILTER is not set
 
-# CONFIG_IP_NF_MATCH_TTL is not set
 
-# CONFIG_IP_NF_QUEUE is not set
 
-# CONFIG_IP_NF_RAW is not set
 
-# CONFIG_IP_NF_SECURITY is not set
 
-# CONFIG_IP_NF_TARGET_CLUSTERIP is not set
 
-# CONFIG_IP_NF_TARGET_ECN is not set
 
-# CONFIG_IP_NF_TARGET_LOG is not set
 
-# CONFIG_IP_NF_TARGET_MASQUERADE is not set
 
-# CONFIG_IP_NF_TARGET_NETMAP is not set
 
-# CONFIG_IP_NF_TARGET_REDIRECT is not set
 
-# CONFIG_IP_NF_TARGET_REJECT is not set
 
-# CONFIG_IP_NF_TARGET_TTL is not set
 
-# CONFIG_IP_NF_TARGET_ULOG is not set
 
-# CONFIG_IP_PIMSM_V1 is not set
 
-# CONFIG_IP_PIMSM_V2 is not set
 
-# CONFIG_IP_PNP is not set
 
-CONFIG_IP_ROUTE_MULTIPATH=y
 
-CONFIG_IP_ROUTE_VERBOSE=y
 
-# CONFIG_IP_SCTP is not set
 
-# CONFIG_IP_SET is not set
 
-# CONFIG_IP_VS is not set
 
-# CONFIG_IRDA is not set
 
-# CONFIG_IRQSOFF_TRACER is not set
 
-# CONFIG_IRQ_ALL_CPUS is not set
 
-# CONFIG_IR_IMON is not set
 
-# CONFIG_IR_JVC_DECODER is not set
 
-# CONFIG_IR_LIRC_CODEC is not set
 
-# CONFIG_IR_MCEUSB is not set
 
-# CONFIG_IR_NEC_DECODER is not set
 
-# CONFIG_IR_RC5_DECODER is not set
 
-# CONFIG_IR_RC5_SZ_DECODER is not set
 
-# CONFIG_IR_RC6_DECODER is not set
 
-# CONFIG_IR_SONY_DECODER is not set
 
-# CONFIG_IR_STREAMZAP is not set
 
-# CONFIG_ISCSI_BOOT_SYSFS is not set
 
-# CONFIG_ISCSI_TCP is not set
 
-CONFIG_ISDN=y
 
-# CONFIG_ISDN_AUDIO is not set
 
-# CONFIG_ISDN_CAPI is not set
 
-# CONFIG_ISDN_CAPI_CAPIDRV is not set
 
-# CONFIG_ISDN_DIVERSION is not set
 
-# CONFIG_ISDN_DRV_ACT2000 is not set
 
-# CONFIG_ISDN_DRV_AVMB1_VERBOSE_REASON is not set
 
-# CONFIG_ISDN_DRV_GIGASET is not set
 
-# CONFIG_ISDN_DRV_HISAX is not set
 
-# CONFIG_ISDN_DRV_ICN is not set
 
-# CONFIG_ISDN_DRV_LOOP is not set
 
-# CONFIG_ISDN_DRV_PCBIT is not set
 
-# CONFIG_ISDN_DRV_SC is not set
 
-# CONFIG_ISDN_I4L is not set
 
-# CONFIG_ISL29003 is not set
 
-# CONFIG_ISL29020 is not set
 
-# CONFIG_ISO9660_FS is not set
 
-# CONFIG_ISS4xx is not set
 
-# CONFIG_IWL3945 is not set
 
-# CONFIG_IWLAGN is not set
 
-# CONFIG_IWLWIFI is not set
 
-# CONFIG_IWMC3200TOP is not set
 
-# CONFIG_IXGB is not set
 
-# CONFIG_IXGBE is not set
 
-# CONFIG_IXGBEVF is not set
 
-# CONFIG_JBD is not set
 
-# CONFIG_JBD2_DEBUG is not set
 
-# CONFIG_JBD_DEBUG is not set
 
-# CONFIG_JFFS2_CMODE_FAVOURLZO is not set
 
-# CONFIG_JFFS2_CMODE_NONE is not set
 
-CONFIG_JFFS2_CMODE_PRIORITY=y
 
-# CONFIG_JFFS2_CMODE_SIZE is not set
 
-CONFIG_JFFS2_COMPRESSION_OPTIONS=y
 
-CONFIG_JFFS2_FS=y
 
-CONFIG_JFFS2_FS_DEBUG=0
 
-# CONFIG_JFFS2_FS_POSIX_ACL is not set
 
-# CONFIG_JFFS2_FS_SECURITY is not set
 
-# CONFIG_JFFS2_FS_WBUF_VERIFY is not set
 
-CONFIG_JFFS2_FS_WRITEBUFFER=y
 
-CONFIG_JFFS2_FS_XATTR=y
 
-CONFIG_JFFS2_LZMA=y
 
-# CONFIG_JFFS2_LZO is not set
 
-CONFIG_JFFS2_RTIME=y
 
-# CONFIG_JFFS2_RUBIN is not set
 
-CONFIG_JFFS2_SUMMARY=y
 
-# CONFIG_JFFS2_ZLIB is not set
 
-# CONFIG_JFS_DEBUG is not set
 
-# CONFIG_JFS_FS is not set
 
-# CONFIG_JFS_POSIX_ACL is not set
 
-# CONFIG_JFS_SECURITY is not set
 
-# CONFIG_JFS_STATISTICS is not set
 
-# CONFIG_JME is not set
 
-CONFIG_JOLIET=y
 
-# CONFIG_JUMP_LABEL is not set
 
-# CONFIG_KALLSYMS is not set
 
-# CONFIG_KALLSYMS_ALL is not set
 
-# CONFIG_KARMA_PARTITION is not set
 
-# CONFIG_KERNEL_BZIP2 is not set
 
-# CONFIG_KERNEL_GZIP is not set
 
-# CONFIG_KERNEL_LZMA is not set
 
-# CONFIG_KERNEL_LZO is not set
 
-CONFIG_KERNEL_XZ=y
 
-# CONFIG_KEXEC is not set
 
-# CONFIG_KEYBOARD_ADP5588 is not set
 
-# CONFIG_KEYBOARD_ADP5589 is not set
 
-# CONFIG_KEYBOARD_ATKBD is not set
 
-# CONFIG_KEYBOARD_GPIO_POLLED is not set
 
-# CONFIG_KEYBOARD_LKKBD is not set
 
-# CONFIG_KEYBOARD_LM8323 is not set
 
-# CONFIG_KEYBOARD_MATRIX is not set
 
-# CONFIG_KEYBOARD_MAX7359 is not set
 
-# CONFIG_KEYBOARD_MCS is not set
 
-# CONFIG_KEYBOARD_MPR121 is not set
 
-# CONFIG_KEYBOARD_NEWTON is not set
 
-# CONFIG_KEYBOARD_OPENCORES is not set
 
-# CONFIG_KEYBOARD_PXA27x is not set
 
-# CONFIG_KEYBOARD_QT1070 is not set
 
-# CONFIG_KEYBOARD_QT2160 is not set
 
-# CONFIG_KEYBOARD_SAMSUNG is not set
 
-# CONFIG_KEYBOARD_STOWAWAY is not set
 
-# CONFIG_KEYBOARD_SUNKBD is not set
 
-# CONFIG_KEYBOARD_TCA6416 is not set
 
-# CONFIG_KEYBOARD_TCA8418 is not set
 
-# CONFIG_KEYBOARD_XTKBD is not set
 
-# CONFIG_KEYS is not set
 
-# CONFIG_KEYS_DEBUG_PROC_KEYS is not set
 
-# CONFIG_KGDB is not set
 
-# CONFIG_KMEMCHECK is not set
 
-# CONFIG_KPROBES is not set
 
-# CONFIG_KS8842 is not set
 
-# CONFIG_KS8851 is not set
 
-# CONFIG_KS8851_MLL is not set
 
-# CONFIG_KSM is not set
 
-# CONFIG_KSZ884X_PCI is not set
 
-# CONFIG_KVM_GUEST is not set
 
-# CONFIG_L2TP is not set
 
-# CONFIG_L2TP_ETH is not set
 
-# CONFIG_L2TP_IP is not set
 
-# CONFIG_L2TP_V3 is not set
 
-# CONFIG_LANMEDIA is not set
 
-# CONFIG_LANTIQ is not set
 
-# CONFIG_LAPB is not set
 
-# CONFIG_LASAT is not set
 
-# CONFIG_LATENCYTOP is not set
 
-CONFIG_LBDAF=y
 
-# CONFIG_LDM_PARTITION is not set
 
-# CONFIG_LEDS_BD2802 is not set
 
-CONFIG_LEDS_CLASS=y
 
-# CONFIG_LEDS_DAC124S085 is not set
 
-# CONFIG_LEDS_GPIO is not set
 
-CONFIG_LEDS_GPIO_OF=y
 
-CONFIG_LEDS_GPIO_PLATFORM=y
 
-# CONFIG_LEDS_INTEL_SS4200 is not set
 
-# CONFIG_LEDS_LM3530 is not set
 
-# CONFIG_LEDS_LP3944 is not set
 
-# CONFIG_LEDS_LP5521 is not set
 
-# CONFIG_LEDS_LP5523 is not set
 
-# CONFIG_LEDS_LT3593 is not set
 
-# CONFIG_LEDS_NET5501 is not set
 
-# CONFIG_LEDS_OT200 is not set
 
-# CONFIG_LEDS_PCA9532 is not set
 
-# CONFIG_LEDS_PCA955X is not set
 
-# CONFIG_LEDS_RENESAS_TPU is not set
 
-# CONFIG_LEDS_TCA6507 is not set
 
-CONFIG_LEDS_TRIGGERS=y
 
-# CONFIG_LEDS_TRIGGER_BACKLIGHT is not set
 
-CONFIG_LEDS_TRIGGER_DEFAULT_ON=y
 
-# CONFIG_LEDS_TRIGGER_GPIO is not set
 
-# CONFIG_LEDS_TRIGGER_HEARTBEAT is not set
 
-# CONFIG_LEDS_TRIGGER_IDE_DISK is not set
 
-# CONFIG_LEDS_TRIGGER_MORSE is not set
 
-CONFIG_LEDS_TRIGGER_NETDEV=y
 
-CONFIG_LEDS_TRIGGER_TIMER=y
 
-# CONFIG_LEDS_TRIGGER_USBDEV is not set
 
-# CONFIG_LEGACY_PTYS is not set
 
-# CONFIG_LIB80211 is not set
 
-# CONFIG_LIB80211_CRYPT_CCMP is not set
 
-# CONFIG_LIB80211_CRYPT_TKIP is not set
 
-# CONFIG_LIB80211_CRYPT_WEP is not set
 
-# CONFIG_LIB80211_DEBUG is not set
 
-# CONFIG_LIBCRC32C is not set
 
-# CONFIG_LIBERTAS is not set
 
-# CONFIG_LIBERTAS_THINFIRM is not set
 
-# CONFIG_LIBERTAS_USB is not set
 
-# CONFIG_LIBFC is not set
 
-# CONFIG_LIBFCOE is not set
 
-# CONFIG_LIBIPW_DEBUG is not set
 
-# CONFIG_LINE6_USB is not set
 
-# CONFIG_LIRC_STAGING is not set
 
-# CONFIG_LKDTM is not set
 
-CONFIG_LLC=y
 
-# CONFIG_LLC2 is not set
 
-CONFIG_LOCALVERSION=""
 
-# CONFIG_LOCALVERSION_AUTO is not set
 
-# CONFIG_LOCKD is not set
 
-CONFIG_LOCKDEP_SUPPORT=y
 
-CONFIG_LOCKD_V4=y
 
-# CONFIG_LOCKUP_DETECTOR is not set
 
-# CONFIG_LOCK_STAT is not set
 
-# CONFIG_LOGFS is not set
 
-# CONFIG_LOGIRUMBLEPAD2_FF is not set
 
-# CONFIG_LOGITECH_FF is not set
 
-# CONFIG_LOGO is not set
 
-CONFIG_LOG_BUF_SHIFT=17
 
-# CONFIG_LOONGSON_MC146818 is not set
 
-# CONFIG_LP486E is not set
 
-# CONFIG_LPC_SCH is not set
 
-# CONFIG_LP_CONSOLE is not set
 
-# CONFIG_LSI_ET1011C_PHY is not set
 
-# CONFIG_LTPC is not set
 
-# CONFIG_LXT_PHY is not set
 
-CONFIG_LZMA_COMPRESS=y
 
-CONFIG_LZMA_DECOMPRESS=y
 
-# CONFIG_LZO_COMPRESS is not set
 
-# CONFIG_LZO_DECOMPRESS is not set
 
-# CONFIG_M25PXX_PREFER_SMALL_SECTOR_ERASE is not set
 
-# CONFIG_MAC80211 is not set
 
-# CONFIG_MACH_DECSTATION is not set
 
-# CONFIG_MACH_JAZZ is not set
 
-# CONFIG_MACH_JZ4740 is not set
 
-# CONFIG_MACH_LOONGSON is not set
 
-# CONFIG_MACH_NO_WESTBRIDGE is not set
 
-# CONFIG_MACH_TX39XX is not set
 
-# CONFIG_MACH_TX49XX is not set
 
-# CONFIG_MACH_VR41XX is not set
 
-# CONFIG_MACINTOSH_DRIVERS is not set
 
-# CONFIG_MACVLAN is not set
 
-# CONFIG_MACVTAP is not set
 
-# CONFIG_MAC_EMUMOUSEBTN is not set
 
-# CONFIG_MAC_PARTITION is not set
 
-# CONFIG_MAGIC_SYSRQ is not set
 
-# CONFIG_MARVELL_PHY is not set
 
-# CONFIG_MAX63XX_WATCHDOG is not set
 
-# CONFIG_MD is not set
 
-# CONFIG_MDIO_BITBANG is not set
 
-# CONFIG_MD_FAULTY is not set
 
-# CONFIG_MEDIA_ATTACH is not set
 
-# CONFIG_MEDIA_CONTROLLER is not set
 
-# CONFIG_MEDIA_SUPPORT is not set
 
-# CONFIG_MEDIA_TUNER_CUSTOMISE is not set
 
-# CONFIG_MEGARAID_LEGACY is not set
 
-# CONFIG_MEGARAID_NEWGEN is not set
 
-# CONFIG_MEGARAID_SAS is not set
 
-# CONFIG_MEMORY_FAILURE is not set
 
-# CONFIG_MEMSTICK is not set
 
-# CONFIG_MFD_88PM860X is not set
 
-# CONFIG_MFD_AAT2870_CORE is not set
 
-# CONFIG_MFD_ASIC3 is not set
 
-# CONFIG_MFD_CORE is not set
 
-# CONFIG_MFD_CS5535 is not set
 
-# CONFIG_MFD_DA9052_I2C is not set
 
-# CONFIG_MFD_DA9052_SPI is not set
 
-# CONFIG_MFD_JANZ_CMODIO is not set
 
-# CONFIG_MFD_MAX8925 is not set
 
-# CONFIG_MFD_MAX8997 is not set
 
-# CONFIG_MFD_MAX8998 is not set
 
-# CONFIG_MFD_MC13783 is not set
 
-# CONFIG_MFD_MC13XXX is not set
 
-# CONFIG_MFD_PCF50633 is not set
 
-# CONFIG_MFD_RDC321X is not set
 
-# CONFIG_MFD_S5M_CORE is not set
 
-# CONFIG_MFD_SM501 is not set
 
-# CONFIG_MFD_STMPE is not set
 
-CONFIG_MFD_SUPPORT=y
 
-# CONFIG_MFD_TC3589X is not set
 
-# CONFIG_MFD_TC6387XB is not set
 
-# CONFIG_MFD_TC6393XB is not set
 
-# CONFIG_MFD_TIMBERDALE is not set
 
-# CONFIG_MFD_TMIO is not set
 
-# CONFIG_MFD_TPS6586X is not set
 
-# CONFIG_MFD_TPS65910 is not set
 
-# CONFIG_MFD_TPS65912_I2C is not set
 
-# CONFIG_MFD_TPS65912_SPI is not set
 
-# CONFIG_MFD_VX855 is not set
 
-# CONFIG_MFD_WL1273_CORE is not set
 
-# CONFIG_MFD_WM831X is not set
 
-# CONFIG_MFD_WM831X_I2C is not set
 
-# CONFIG_MFD_WM831X_SPI is not set
 
-# CONFIG_MFD_WM8350_I2C is not set
 
-# CONFIG_MFD_WM8400 is not set
 
-# CONFIG_MFD_WM8994 is not set
 
-# CONFIG_MG_DISK is not set
 
-# CONFIG_MICREL_KS8995MA is not set
 
-# CONFIG_MICREL_PHY is not set
 
-# CONFIG_MIGRATION is not set
 
-CONFIG_MII=y
 
-# CONFIG_MIKROTIK_RB532 is not set
 
-# CONFIG_MINIX_FS is not set
 
-# CONFIG_MINIX_FS_NATIVE_ENDIAN is not set
 
-# CONFIG_MINIX_SUBPARTITION is not set
 
-# CONFIG_MIPS_ALCHEMY is not set
 
-# CONFIG_MIPS_COBALT is not set
 
-# CONFIG_MIPS_FPU_EMU is not set
 
-# CONFIG_MIPS_MALTA is not set
 
-# CONFIG_MIPS_SIM is not set
 
-CONFIG_MISC_DEVICES=y
 
-CONFIG_MISC_FILESYSTEMS=y
 
-# CONFIG_MISDN is not set
 
-# CONFIG_MISDN_AVMFRITZ is not set
 
-# CONFIG_MISDN_HFCPCI is not set
 
-# CONFIG_MISDN_HFCUSB is not set
 
-# CONFIG_MISDN_INFINEON is not set
 
-# CONFIG_MISDN_NETJET is not set
 
-# CONFIG_MISDN_SPEEDFAX is not set
 
-# CONFIG_MISDN_W6692 is not set
 
-# CONFIG_MKISS is not set
 
-# CONFIG_MLX4_CORE is not set
 
-# CONFIG_MLX4_EN is not set
 
-# CONFIG_MMC is not set
 
-# CONFIG_MMC_ARMMMCI is not set
 
-# CONFIG_MMC_AU1X is not set
 
-# CONFIG_MMC_BLOCK is not set
 
-CONFIG_MMC_BLOCK_BOUNCE=y
 
-CONFIG_MMC_BLOCK_MINORS=8
 
-# CONFIG_MMC_CB710 is not set
 
-# CONFIG_MMC_CLKGATE is not set
 
-# CONFIG_MMC_DEBUG is not set
 
-# CONFIG_MMC_DW is not set
 
-# CONFIG_MMC_MVSDIO is not set
 
-# CONFIG_MMC_S3C is not set
 
-# CONFIG_MMC_SDHCI is not set
 
-# CONFIG_MMC_SDHCI_OF_ESDHC is not set
 
-# CONFIG_MMC_SDHCI_OF_HLWD is not set
 
-# CONFIG_MMC_SDHCI_PXAV2 is not set
 
-# CONFIG_MMC_SDHCI_PXAV3 is not set
 
-# CONFIG_MMC_SDRICOH_CS is not set
 
-# CONFIG_MMC_SPI is not set
 
-# CONFIG_MMC_TEST is not set
 
-# CONFIG_MMC_UNSAFE_RESUME is not set
 
-# CONFIG_MMC_USHC is not set
 
-# CONFIG_MMC_VIA_SDMMC is not set
 
-# CONFIG_MMC_VUB300 is not set
 
-CONFIG_MMU=y
 
-CONFIG_MODULES=y
 
-# CONFIG_MODULE_FORCE_LOAD is not set
 
-# CONFIG_MODULE_FORCE_UNLOAD is not set
 
-# CONFIG_MODULE_SRCVERSION_ALL is not set
 
-CONFIG_MODULE_UNLOAD=y
 
-# CONFIG_MODVERSIONS is not set
 
-# CONFIG_MOUSE_APPLETOUCH is not set
 
-# CONFIG_MOUSE_GPIO is not set
 
-# CONFIG_MOUSE_INPORT is not set
 
-# CONFIG_MOUSE_LOGIBM is not set
 
-# CONFIG_MOUSE_PC110PAD is not set
 
-# CONFIG_MOUSE_PS2_SENTELIC is not set
 
-# CONFIG_MOUSE_SYNAPTICS_I2C is not set
 
-# CONFIG_MSDOS_FS is not set
 
-CONFIG_MSDOS_PARTITION=y
 
-# CONFIG_MSI_BITMAP_SELFTEST is not set
 
-# CONFIG_MSI_LAPTOP is not set
 
-CONFIG_MTD=y
 
-# CONFIG_MTD_ABSENT is not set
 
-# CONFIG_MTD_AFS_PARTS is not set
 
-# CONFIG_MTD_ALAUDA is not set
 
-# CONFIG_MTD_AR7_PARTS is not set
 
-# CONFIG_MTD_ARM_INTEGRATOR is not set
 
-CONFIG_MTD_BLKDEVS=y
 
-CONFIG_MTD_BLOCK=y
 
-# CONFIG_MTD_BLOCK2MTD is not set
 
-CONFIG_MTD_CFI=y
 
-# CONFIG_MTD_CFI_ADV_OPTIONS is not set
 
-CONFIG_MTD_CFI_AMDSTD=y
 
-# CONFIG_MTD_CFI_BE_BYTE_SWAP is not set
 
-CONFIG_MTD_CFI_I1=y
 
-CONFIG_MTD_CFI_I2=y
 
-# CONFIG_MTD_CFI_I4 is not set
 
-# CONFIG_MTD_CFI_I8 is not set
 
-CONFIG_MTD_CFI_INTELEXT=y
 
-# CONFIG_MTD_CFI_LE_BYTE_SWAP is not set
 
-CONFIG_MTD_CFI_NOSWAP=y
 
-# CONFIG_MTD_CFI_STAA is not set
 
-CONFIG_MTD_CFI_UTIL=y
 
-CONFIG_MTD_CHAR=y
 
-# CONFIG_MTD_CMDLINE_PARTS is not set
 
-CONFIG_MTD_COMPLEX_MAPPINGS=y
 
-# CONFIG_MTD_DATAFLASH is not set
 
-# CONFIG_MTD_DEBUG is not set
 
-# CONFIG_MTD_DOC2000 is not set
 
-# CONFIG_MTD_DOC2001 is not set
 
-# CONFIG_MTD_DOC2001PLUS is not set
 
-# CONFIG_MTD_DOCG3 is not set
 
-CONFIG_MTD_GEN_PROBE=y
 
-# CONFIG_MTD_GPIO_ADDR is not set
 
-# CONFIG_MTD_INTEL_VR_NOR is not set
 
-# CONFIG_MTD_JEDECPROBE is not set
 
-# CONFIG_MTD_LATCH_ADDR is not set
 
-# CONFIG_MTD_LPDDR is not set
 
-# CONFIG_MTD_M25P80 is not set
 
-CONFIG_MTD_MAP_BANK_WIDTH_1=y
 
-# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set
 
-CONFIG_MTD_MAP_BANK_WIDTH_2=y
 
-# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set
 
-CONFIG_MTD_MAP_BANK_WIDTH_4=y
 
-# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set
 
-# CONFIG_MTD_MTDRAM is not set
 
-# CONFIG_MTD_MYLOADER_PARTS is not set
 
-# CONFIG_MTD_NAND is not set
 
-# CONFIG_MTD_NAND_AMS_DELTA is not set
 
-# CONFIG_MTD_NAND_AR934X is not set
 
-# CONFIG_MTD_NAND_ATMEL is not set
 
-# CONFIG_MTD_NAND_AU1550 is not set
 
-# CONFIG_MTD_NAND_AUTCPU12 is not set
 
-# CONFIG_MTD_NAND_BCH is not set
 
-# CONFIG_MTD_NAND_BCM_UMI is not set
 
-# CONFIG_MTD_NAND_BF5XX is not set
 
-# CONFIG_MTD_NAND_CAFE is not set
 
-# CONFIG_MTD_NAND_CM_X270 is not set
 
-# CONFIG_MTD_NAND_CS553X is not set
 
-# CONFIG_MTD_NAND_DAVINCI is not set
 
-# CONFIG_MTD_NAND_DENALI is not set
 
-CONFIG_MTD_NAND_DENALI_SCRATCH_REG_ADDR=0xff108018
 
-# CONFIG_MTD_NAND_DISKONCHIP is not set
 
-# CONFIG_MTD_NAND_ECC is not set
 
-# CONFIG_MTD_NAND_ECC_BCH is not set
 
-# CONFIG_MTD_NAND_ECC_SMC is not set
 
-# CONFIG_MTD_NAND_FSL_ELBC is not set
 
-# CONFIG_MTD_NAND_FSL_UPM is not set
 
-# CONFIG_MTD_NAND_FSMC is not set
 
-# CONFIG_MTD_NAND_GPIO is not set
 
-# CONFIG_MTD_NAND_GPMI_NAND is not set
 
-# CONFIG_MTD_NAND_H1900 is not set
 
-CONFIG_MTD_NAND_IDS=y
 
-# CONFIG_MTD_NAND_JZ4740 is not set
 
-# CONFIG_MTD_NAND_MPC5121_NFC is not set
 
-# CONFIG_MTD_NAND_MUSEUM_IDS is not set
 
-# CONFIG_MTD_NAND_MXC is not set
 
-# CONFIG_MTD_NAND_NANDSIM is not set
 
-# CONFIG_MTD_NAND_NDFC is not set
 
-# CONFIG_MTD_NAND_NOMADIK is not set
 
-# CONFIG_MTD_NAND_NUC900 is not set
 
-# CONFIG_MTD_NAND_OMAP2 is not set
 
-# CONFIG_MTD_NAND_ORION is not set
 
-# CONFIG_MTD_NAND_PASEMI is not set
 
-# CONFIG_MTD_NAND_PLATFORM is not set
 
-# CONFIG_MTD_NAND_PPCHAMELEONEVB is not set
 
-# CONFIG_MTD_NAND_PXA3xx is not set
 
-# CONFIG_MTD_NAND_RB4XX is not set
 
-# CONFIG_MTD_NAND_RB750 is not set
 
-# CONFIG_MTD_NAND_RICOH is not set
 
-# CONFIG_MTD_NAND_RTC_FROM4 is not set
 
-# CONFIG_MTD_NAND_S3C2410 is not set
 
-# CONFIG_MTD_NAND_SHARPSL is not set
 
-# CONFIG_MTD_NAND_SH_FLCTL is not set
 
-# CONFIG_MTD_NAND_SOCRATES is not set
 
-# CONFIG_MTD_NAND_SPIA is not set
 
-# CONFIG_MTD_NAND_TMIO is not set
 
-# CONFIG_MTD_NAND_TXX9NDFMC is not set
 
-# CONFIG_MTD_NAND_VERIFY_WRITE is not set
 
-# CONFIG_MTD_ONENAND is not set
 
-# CONFIG_MTD_OOPS is not set
 
-# CONFIG_MTD_OTP is not set
 
-# CONFIG_MTD_PCI is not set
 
-# CONFIG_MTD_PCMCIA is not set
 
-# CONFIG_MTD_PHRAM is not set
 
-# CONFIG_MTD_PHYSMAP is not set
 
-# CONFIG_MTD_PHYSMAP_COMPAT is not set
 
-# CONFIG_MTD_PLATRAM is not set
 
-# CONFIG_MTD_PMC551 is not set
 
-# CONFIG_MTD_RAM is not set
 
-CONFIG_MTD_REDBOOT_DIRECTORY_BLOCK=-1
 
-# CONFIG_MTD_REDBOOT_PARTS is not set
 
-# CONFIG_MTD_REDBOOT_PARTS_READONLY is not set
 
-# CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED is not set
 
-# CONFIG_MTD_ROM is not set
 
-CONFIG_MTD_ROOTFS_ROOT_DEV=y
 
-CONFIG_MTD_ROOTFS_SPLIT=y
 
-# CONFIG_MTD_SLRAM is not set
 
-# CONFIG_MTD_SST25L is not set
 
-# CONFIG_MTD_SWAP is not set
 
-# CONFIG_MTD_TESTS is not set
 
-# CONFIG_MTD_UBI is not set
 
-# CONFIG_MUTEX_SPIN_ON_OWNER is not set
 
-# CONFIG_MV643XX_ETH is not set
 
-# CONFIG_MVSWITCH_PHY is not set
 
-# CONFIG_MWAVE is not set
 
-# CONFIG_MWL8K is not set
 
-# CONFIG_MYRI10GE is not set
 
-# CONFIG_NAMESPACES is not set
 
-# CONFIG_NATIONAL_PHY is not set
 
-# CONFIG_NATSEMI is not set
 
-# CONFIG_NCP_FS is not set
 
-# CONFIG_NE2000 is not set
 
-# CONFIG_NE2K_PCI is not set
 
-# CONFIG_NEC_MARKEINS is not set
 
-CONFIG_NET=y
 
-# CONFIG_NETCONSOLE is not set
 
-CONFIG_NETDEVICES=y
 
-CONFIG_NETDEV_1000=y
 
-# CONFIG_NETDEV_10000 is not set
 
-# CONFIG_NETFILTER is not set
 
-# CONFIG_NETFILTER_ADVANCED is not set
 
-# CONFIG_NETFILTER_DEBUG is not set
 
-# CONFIG_NETFILTER_NETLINK is not set
 
-# CONFIG_NETFILTER_NETLINK_ACCT is not set
 
-# CONFIG_NETFILTER_NETLINK_LOG is not set
 
-# CONFIG_NETFILTER_NETLINK_QUEUE is not set
 
-# CONFIG_NETFILTER_TPROXY is not set
 
-# CONFIG_NETFILTER_XTABLES is not set
 
-# CONFIG_NETFILTER_XT_CONNMARK is not set
 
-# CONFIG_NETFILTER_XT_MARK is not set
 
-# CONFIG_NETFILTER_XT_MATCH_ADDRTYPE is not set
 
-# CONFIG_NETFILTER_XT_MATCH_CLUSTER is not set
 
-# CONFIG_NETFILTER_XT_MATCH_COMMENT is not set
 
-# CONFIG_NETFILTER_XT_MATCH_CONNBYTES is not set
 
-# CONFIG_NETFILTER_XT_MATCH_CONNLIMIT is not set
 
-# CONFIG_NETFILTER_XT_MATCH_CONNMARK is not set
 
-# CONFIG_NETFILTER_XT_MATCH_CONNTRACK is not set
 
-# CONFIG_NETFILTER_XT_MATCH_CPU is not set
 
-# CONFIG_NETFILTER_XT_MATCH_DCCP is not set
 
-# CONFIG_NETFILTER_XT_MATCH_DEVGROUP is not set
 
-# CONFIG_NETFILTER_XT_MATCH_DSCP is not set
 
-# CONFIG_NETFILTER_XT_MATCH_ECN is not set
 
-# CONFIG_NETFILTER_XT_MATCH_ESP is not set
 
-# CONFIG_NETFILTER_XT_MATCH_HASHLIMIT is not set
 
-# CONFIG_NETFILTER_XT_MATCH_HELPER is not set
 
-# CONFIG_NETFILTER_XT_MATCH_HL is not set
 
-# CONFIG_NETFILTER_XT_MATCH_IPRANGE is not set
 
-# CONFIG_NETFILTER_XT_MATCH_LAYER7 is not set
 
-# CONFIG_NETFILTER_XT_MATCH_LAYER7_DEBUG is not set
 
-# CONFIG_NETFILTER_XT_MATCH_LENGTH is not set
 
-# CONFIG_NETFILTER_XT_MATCH_LIMIT is not set
 
-# CONFIG_NETFILTER_XT_MATCH_MAC is not set
 
-# CONFIG_NETFILTER_XT_MATCH_MARK is not set
 
-# CONFIG_NETFILTER_XT_MATCH_MULTIPORT is not set
 
-# CONFIG_NETFILTER_XT_MATCH_NFACCT is not set
 
-# CONFIG_NETFILTER_XT_MATCH_OSF is not set
 
-# CONFIG_NETFILTER_XT_MATCH_OWNER is not set
 
-# CONFIG_NETFILTER_XT_MATCH_PHYSDEV is not set
 
-# CONFIG_NETFILTER_XT_MATCH_PKTTYPE is not set
 
-# CONFIG_NETFILTER_XT_MATCH_POLICY is not set
 
-# CONFIG_NETFILTER_XT_MATCH_QUOTA is not set
 
-# CONFIG_NETFILTER_XT_MATCH_RATEEST is not set
 
-# CONFIG_NETFILTER_XT_MATCH_REALM is not set
 
-# CONFIG_NETFILTER_XT_MATCH_RECENT is not set
 
-# CONFIG_NETFILTER_XT_MATCH_SCTP is not set
 
-# CONFIG_NETFILTER_XT_MATCH_SOCKET is not set
 
-# CONFIG_NETFILTER_XT_MATCH_STATE is not set
 
-# CONFIG_NETFILTER_XT_MATCH_STATISTIC is not set
 
-# CONFIG_NETFILTER_XT_MATCH_STRING is not set
 
-# CONFIG_NETFILTER_XT_MATCH_TCPMSS is not set
 
-# CONFIG_NETFILTER_XT_MATCH_TIME is not set
 
-# CONFIG_NETFILTER_XT_MATCH_U32 is not set
 
-# CONFIG_NETFILTER_XT_TARGET_AUDIT is not set
 
-# CONFIG_NETFILTER_XT_TARGET_CHECKSUM is not set
 
-# CONFIG_NETFILTER_XT_TARGET_CLASSIFY is not set
 
-# CONFIG_NETFILTER_XT_TARGET_CONNMARK is not set
 
-# CONFIG_NETFILTER_XT_TARGET_CT is not set
 
-# CONFIG_NETFILTER_XT_TARGET_DSCP is not set
 
-# CONFIG_NETFILTER_XT_TARGET_HL is not set
 
-# CONFIG_NETFILTER_XT_TARGET_IDLETIMER is not set
 
-# CONFIG_NETFILTER_XT_TARGET_LED is not set
 
-# CONFIG_NETFILTER_XT_TARGET_MARK is not set
 
-# CONFIG_NETFILTER_XT_TARGET_NFLOG is not set
 
-# CONFIG_NETFILTER_XT_TARGET_NFQUEUE is not set
 
-# CONFIG_NETFILTER_XT_TARGET_NOTRACK is not set
 
-# CONFIG_NETFILTER_XT_TARGET_RATEEST is not set
 
-# CONFIG_NETFILTER_XT_TARGET_TCPMSS is not set
 
-# CONFIG_NETFILTER_XT_TARGET_TCPOPTSTRIP is not set
 
-# CONFIG_NETFILTER_XT_TARGET_TEE is not set
 
-# CONFIG_NETFILTER_XT_TARGET_TPROXY is not set
 
-# CONFIG_NETFILTER_XT_TARGET_TRACE is not set
 
-# CONFIG_NETPOLL is not set
 
-# CONFIG_NETROM is not set
 
-CONFIG_NETWORK_FILESYSTEMS=y
 
-# CONFIG_NETWORK_PHY_TIMESTAMPING is not set
 
-# CONFIG_NETWORK_SECMARK is not set
 
-# CONFIG_NETXEN_NIC is not set
 
-# CONFIG_NET_9P is not set
 
-# CONFIG_NET_ACT_CSUM is not set
 
-# CONFIG_NET_ACT_GACT is not set
 
-# CONFIG_NET_ACT_IPT is not set
 
-# CONFIG_NET_ACT_MIRRED is not set
 
-# CONFIG_NET_ACT_NAT is not set
 
-# CONFIG_NET_ACT_PEDIT is not set
 
-# CONFIG_NET_ACT_POLICE is not set
 
-# CONFIG_NET_ACT_SIMP is not set
 
-# CONFIG_NET_ACT_SKBEDIT is not set
 
-CONFIG_NET_CADENCE=y
 
-# CONFIG_NET_CALXEDA_XGMAC is not set
 
-CONFIG_NET_CLS=y
 
-# CONFIG_NET_CLS_ACT is not set
 
-# CONFIG_NET_CLS_BASIC is not set
 
-# CONFIG_NET_CLS_FLOW is not set
 
-# CONFIG_NET_CLS_FW is not set
 
-CONFIG_NET_CLS_IND=y
 
-# CONFIG_NET_CLS_ROUTE4 is not set
 
-# CONFIG_NET_CLS_RSVP is not set
 
-# CONFIG_NET_CLS_RSVP6 is not set
 
-# CONFIG_NET_CLS_TCINDEX is not set
 
-# CONFIG_NET_CLS_U32 is not set
 
-CONFIG_NET_CORE=y
 
-# CONFIG_NET_DROP_MONITOR is not set
 
-# CONFIG_NET_DSA is not set
 
-# CONFIG_NET_DSA_MV88E6123_61_65 is not set
 
-# CONFIG_NET_DSA_MV88E6131 is not set
 
-# CONFIG_NET_DSA_MV88E6XXX is not set
 
-# CONFIG_NET_DSA_MV88E6XXX_NEED_PPU is not set
 
-# CONFIG_NET_DSA_TAG_DSA is not set
 
-# CONFIG_NET_DSA_TAG_EDSA is not set
 
-# CONFIG_NET_EMATCH is not set
 
-# CONFIG_NET_EMATCH_CMP is not set
 
-# CONFIG_NET_EMATCH_META is not set
 
-# CONFIG_NET_EMATCH_NBYTE is not set
 
-CONFIG_NET_EMATCH_STACK=32
 
-# CONFIG_NET_EMATCH_TEXT is not set
 
-# CONFIG_NET_EMATCH_U32 is not set
 
-CONFIG_NET_ETHERNET=y
 
-# CONFIG_NET_FC is not set
 
-# CONFIG_NET_IPGRE is not set
 
-CONFIG_NET_IPGRE_BROADCAST=y
 
-# CONFIG_NET_IPGRE_DEMUX is not set
 
-# CONFIG_NET_IPIP is not set
 
-# CONFIG_NET_ISA is not set
 
-# CONFIG_NET_KEY is not set
 
-# CONFIG_NET_KEY_MIGRATE is not set
 
-# CONFIG_NET_PACKET_ENGINE is not set
 
-CONFIG_NET_PCI=y
 
-# CONFIG_NET_PCMCIA is not set
 
-# CONFIG_NET_PKTGEN is not set
 
-# CONFIG_NET_POCKET is not set
 
-# CONFIG_NET_POLL_CONTROLLER is not set
 
-# CONFIG_NET_SB1000 is not set
 
-CONFIG_NET_SCHED=y
 
-# CONFIG_NET_SCH_ATM is not set
 
-# CONFIG_NET_SCH_CBQ is not set
 
-# CONFIG_NET_SCH_CHOKE is not set
 
-# CONFIG_NET_SCH_CODEL is not set
 
-# CONFIG_NET_SCH_DRR is not set
 
-# CONFIG_NET_SCH_DSMARK is not set
 
-# CONFIG_NET_SCH_ESFQ is not set
 
-CONFIG_NET_SCH_ESFQ_NFCT=y
 
-CONFIG_NET_SCH_FIFO=y
 
-# CONFIG_NET_SCH_FQ_CODEL is not set
 
-# CONFIG_NET_SCH_GRED is not set
 
-# CONFIG_NET_SCH_HFSC is not set
 
-# CONFIG_NET_SCH_HTB is not set
 
-# CONFIG_NET_SCH_INGRESS is not set
 
-# CONFIG_NET_SCH_MQPRIO is not set
 
-# CONFIG_NET_SCH_MULTIQ is not set
 
-# CONFIG_NET_SCH_NETEM is not set
 
-# CONFIG_NET_SCH_PRIO is not set
 
-# CONFIG_NET_SCH_QFQ is not set
 
-# CONFIG_NET_SCH_RED is not set
 
-# CONFIG_NET_SCH_SFB is not set
 
-# CONFIG_NET_SCH_SFQ is not set
 
-# CONFIG_NET_SCH_TBF is not set
 
-# CONFIG_NET_SCH_TEQL is not set
 
-# CONFIG_NET_TEAM is not set
 
-# CONFIG_NET_TULIP is not set
 
-CONFIG_NET_VENDOR_3COM=y
 
-CONFIG_NET_VENDOR_8390=y
 
-CONFIG_NET_VENDOR_ADAPTEC=y
 
-CONFIG_NET_VENDOR_ALTEON=y
 
-CONFIG_NET_VENDOR_AMD=y
 
-CONFIG_NET_VENDOR_ATHEROS=y
 
-CONFIG_NET_VENDOR_BROADCOM=y
 
-CONFIG_NET_VENDOR_BROCADE=y
 
-CONFIG_NET_VENDOR_CHELSIO=y
 
-CONFIG_NET_VENDOR_CIRRUS=y
 
-CONFIG_NET_VENDOR_CISCO=y
 
-CONFIG_NET_VENDOR_DEC=y
 
-CONFIG_NET_VENDOR_DLINK=y
 
-CONFIG_NET_VENDOR_EMULEX=y
 
-CONFIG_NET_VENDOR_EXAR=y
 
-CONFIG_NET_VENDOR_FARADAY=y
 
-CONFIG_NET_VENDOR_FREESCALE=y
 
-CONFIG_NET_VENDOR_FUJITSU=y
 
-CONFIG_NET_VENDOR_HP=y
 
-CONFIG_NET_VENDOR_I825XX=y
 
-CONFIG_NET_VENDOR_IBM=y
 
-CONFIG_NET_VENDOR_INTEL=y
 
-CONFIG_NET_VENDOR_MARVELL=y
 
-CONFIG_NET_VENDOR_MELLANOX=y
 
-CONFIG_NET_VENDOR_MICREL=y
 
-CONFIG_NET_VENDOR_MICROCHIP=y
 
-CONFIG_NET_VENDOR_MYRI=y
 
-CONFIG_NET_VENDOR_NATSEMI=y
 
-CONFIG_NET_VENDOR_NVIDIA=y
 
-CONFIG_NET_VENDOR_OKI=y
 
-CONFIG_NET_VENDOR_QLOGIC=y
 
-CONFIG_NET_VENDOR_RDC=y
 
-CONFIG_NET_VENDOR_REALTEK=y
 
-CONFIG_NET_VENDOR_SEEQ=y
 
-CONFIG_NET_VENDOR_SILAN=y
 
-CONFIG_NET_VENDOR_SIS=y
 
-CONFIG_NET_VENDOR_SMSC=y
 
-CONFIG_NET_VENDOR_STMICRO=y
 
-CONFIG_NET_VENDOR_SUN=y
 
-CONFIG_NET_VENDOR_TEHUTI=y
 
-CONFIG_NET_VENDOR_TI=y
 
-CONFIG_NET_VENDOR_TOSHIBA=y
 
-CONFIG_NET_VENDOR_VIA=y
 
-CONFIG_NET_VENDOR_XILINX=y
 
-CONFIG_NET_VENDOR_XIRCOM=y
 
-CONFIG_NEW_LEDS=y
 
-# CONFIG_NFC is not set
 
-# CONFIG_NFC_DEVICES is not set
 
-# CONFIG_NFSD is not set
 
-# CONFIG_NFSD_DEPRECATED is not set
 
-# CONFIG_NFSD_V2_ACL is not set
 
-CONFIG_NFSD_V3=y
 
-# CONFIG_NFSD_V3_ACL is not set
 
-# CONFIG_NFSD_V4 is not set
 
-# CONFIG_NFS_ACL_SUPPORT is not set
 
-CONFIG_NFS_COMMON=y
 
-# CONFIG_NFS_FS is not set
 
-# CONFIG_NFS_FSCACHE is not set
 
-CONFIG_NFS_V3=y
 
-# CONFIG_NFS_V3_ACL is not set
 
-# CONFIG_NFS_V4 is not set
 
-# CONFIG_NFS_V4_1 is not set
 
-# CONFIG_NFTL is not set
 
-# CONFIG_NF_CONNTRACK is not set
 
-# CONFIG_NF_CONNTRACK_AMANDA is not set
 
-# CONFIG_NF_CONNTRACK_EVENTS is not set
 
-# CONFIG_NF_CONNTRACK_FTP is not set
 
-# CONFIG_NF_CONNTRACK_H323 is not set
 
-# CONFIG_NF_CONNTRACK_IPV4 is not set
 
-# CONFIG_NF_CONNTRACK_IPV6 is not set
 
-# CONFIG_NF_CONNTRACK_IRC is not set
 
-# CONFIG_NF_CONNTRACK_MARK is not set
 
-# CONFIG_NF_CONNTRACK_NETBIOS_NS is not set
 
-# CONFIG_NF_CONNTRACK_PPTP is not set
 
-CONFIG_NF_CONNTRACK_PROCFS=y
 
-# CONFIG_NF_CONNTRACK_PROC_COMPAT is not set
 
-# CONFIG_NF_CONNTRACK_RTSP is not set
 
-# CONFIG_NF_CONNTRACK_SANE is not set
 
-# CONFIG_NF_CONNTRACK_SIP is not set
 
-# CONFIG_NF_CONNTRACK_SNMP is not set
 
-# CONFIG_NF_CONNTRACK_TFTP is not set
 
-# CONFIG_NF_CONNTRACK_TIMESTAMP is not set
 
-# CONFIG_NF_CONNTRACK_ZONES is not set
 
-# CONFIG_NF_CT_NETLINK is not set
 
-# CONFIG_NF_CT_PROTO_DCCP is not set
 
-# CONFIG_NF_CT_PROTO_GRE is not set
 
-# CONFIG_NF_CT_PROTO_SCTP is not set
 
-# CONFIG_NF_CT_PROTO_UDPLITE is not set
 
-# CONFIG_NF_DEFRAG_IPV4 is not set
 
-# CONFIG_NF_NAT is not set
 
-# CONFIG_NF_NAT_AMANDA is not set
 
-# CONFIG_NF_NAT_FTP is not set
 
-# CONFIG_NF_NAT_H323 is not set
 
-# CONFIG_NF_NAT_IRC is not set
 
-# CONFIG_NF_NAT_NEEDED is not set
 
-# CONFIG_NF_NAT_PPTP is not set
 
-# CONFIG_NF_NAT_PROTO_GRE is not set
 
-# CONFIG_NF_NAT_RTSP is not set
 
-# CONFIG_NF_NAT_SIP is not set
 
-# CONFIG_NF_NAT_SNMP_BASIC is not set
 
-# CONFIG_NF_NAT_TFTP is not set
 
-# CONFIG_NI52 is not set
 
-# CONFIG_NI65 is not set
 
-# CONFIG_NILFS2_FS is not set
 
-# CONFIG_NIU is not set
 
-CONFIG_NLATTR=y
 
-# CONFIG_NLM_XLP_BOARD is not set
 
-# CONFIG_NLM_XLR_BOARD is not set
 
-# CONFIG_NLS is not set
 
-# CONFIG_NLS_ASCII is not set
 
-# CONFIG_NLS_CODEPAGE_1250 is not set
 
-# CONFIG_NLS_CODEPAGE_1251 is not set
 
-# CONFIG_NLS_CODEPAGE_437 is not set
 
-# CONFIG_NLS_CODEPAGE_737 is not set
 
-# CONFIG_NLS_CODEPAGE_775 is not set
 
-# CONFIG_NLS_CODEPAGE_850 is not set
 
-# CONFIG_NLS_CODEPAGE_852 is not set
 
-# CONFIG_NLS_CODEPAGE_855 is not set
 
-# CONFIG_NLS_CODEPAGE_857 is not set
 
-# CONFIG_NLS_CODEPAGE_860 is not set
 
-# CONFIG_NLS_CODEPAGE_861 is not set
 
-# CONFIG_NLS_CODEPAGE_862 is not set
 
-# CONFIG_NLS_CODEPAGE_863 is not set
 
-# CONFIG_NLS_CODEPAGE_864 is not set
 
-# CONFIG_NLS_CODEPAGE_865 is not set
 
-# CONFIG_NLS_CODEPAGE_866 is not set
 
-# CONFIG_NLS_CODEPAGE_869 is not set
 
-# CONFIG_NLS_CODEPAGE_874 is not set
 
-# CONFIG_NLS_CODEPAGE_932 is not set
 
-# CONFIG_NLS_CODEPAGE_936 is not set
 
-# CONFIG_NLS_CODEPAGE_949 is not set
 
-# CONFIG_NLS_CODEPAGE_950 is not set
 
-CONFIG_NLS_DEFAULT="iso8859-1"
 
-# CONFIG_NLS_ISO8859_1 is not set
 
-# CONFIG_NLS_ISO8859_13 is not set
 
-# CONFIG_NLS_ISO8859_14 is not set
 
-# CONFIG_NLS_ISO8859_15 is not set
 
-# CONFIG_NLS_ISO8859_2 is not set
 
-# CONFIG_NLS_ISO8859_3 is not set
 
-# CONFIG_NLS_ISO8859_4 is not set
 
-# CONFIG_NLS_ISO8859_5 is not set
 
-# CONFIG_NLS_ISO8859_6 is not set
 
-# CONFIG_NLS_ISO8859_7 is not set
 
-# CONFIG_NLS_ISO8859_8 is not set
 
-# CONFIG_NLS_ISO8859_9 is not set
 
-# CONFIG_NLS_KOI8_R is not set
 
-# CONFIG_NLS_KOI8_U is not set
 
-# CONFIG_NLS_UTF8 is not set
 
-# CONFIG_NOP_USB_XCEIV is not set
 
-# CONFIG_NORTEL_HERMES is not set
 
-# CONFIG_NOZOMI is not set
 
-# CONFIG_NO_BOOTMEM is not set
 
-# CONFIG_NO_HZ is not set
 
-# CONFIG_NO_IOPORT is not set
 
-# CONFIG_NS83820 is not set
 
-# CONFIG_NTFS_DEBUG is not set
 
-# CONFIG_NTFS_FS is not set
 
-# CONFIG_NTFS_RW is not set
 
-# CONFIG_NTP_PPS is not set
 
-# CONFIG_NVRAM is not set
 
-# CONFIG_NV_TCO is not set
 
-# CONFIG_NXP_STB220 is not set
 
-# CONFIG_NXP_STB225 is not set
 
-# CONFIG_N_GSM is not set
 
-# CONFIG_OABI_COMPAT is not set
 
-# CONFIG_OBS600 is not set
 
-# CONFIG_OCFS2_FS is not set
 
-# CONFIG_OCF_BENCH is not set
 
-# CONFIG_OCF_C7108 is not set
 
-# CONFIG_OCF_CRYPTOCTEON is not set
 
-# CONFIG_OCF_EP80579 is not set
 
-# CONFIG_OCF_HIFN is not set
 
-# CONFIG_OCF_HIFNHIPP is not set
 
-# CONFIG_OCF_IXP4XX is not set
 
-# CONFIG_OCF_KIRKWOOD is not set
 
-# CONFIG_OCF_OCF is not set
 
-# CONFIG_OCF_OCFNULL is not set
 
-# CONFIG_OCF_SAFE is not set
 
-# CONFIG_OCF_TALITOS is not set
 
-# CONFIG_OCF_UBSEC_SSB is not set
 
-# CONFIG_OC_ETM is not set
 
-# CONFIG_OF_SELFTEST is not set
 
-# CONFIG_OMFS_FS is not set
 
-# CONFIG_OPENVSWITCH is not set
 
-# CONFIG_ORION_WATCHDOG is not set
 
-# CONFIG_OSF_PARTITION is not set
 
-CONFIG_OVERLAYFS_FS=y
 
-# CONFIG_P54_COMMON is not set
 
-CONFIG_PACKET=y
 
-# CONFIG_PAGE_POISONING is not set
 
-# CONFIG_PAGE_SIZE_16KB is not set
 
-# CONFIG_PAGE_SIZE_32KB is not set
 
-CONFIG_PAGE_SIZE_4KB=y
 
-# CONFIG_PAGE_SIZE_64KB is not set
 
-# CONFIG_PAGE_SIZE_8KB is not set
 
-# CONFIG_PANEL is not set
 
-# CONFIG_PANTHERLORD_FF is not set
 
-# CONFIG_PARPORT is not set
 
-# CONFIG_PARPORT_1284 is not set
 
-# CONFIG_PARPORT_AX88796 is not set
 
-# CONFIG_PARPORT_PC is not set
 
-CONFIG_PARTITION_ADVANCED=y
 
-# CONFIG_PATA_ALI is not set
 
-# CONFIG_PATA_AMD is not set
 
-# CONFIG_PATA_ARASAN_CF is not set
 
-# CONFIG_PATA_ARTOP is not set
 
-# CONFIG_PATA_ATIIXP is not set
 
-# CONFIG_PATA_ATP867X is not set
 
-# CONFIG_PATA_CMD640_PCI is not set
 
-# CONFIG_PATA_CMD64X is not set
 
-# CONFIG_PATA_CS5520 is not set
 
-# CONFIG_PATA_CS5530 is not set
 
-# CONFIG_PATA_CS5535 is not set
 
-# CONFIG_PATA_CS5536 is not set
 
-# CONFIG_PATA_CYPRESS is not set
 
-# CONFIG_PATA_EFAR is not set
 
-# CONFIG_PATA_HPT366 is not set
 
-# CONFIG_PATA_HPT37X is not set
 
-# CONFIG_PATA_HPT3X2N is not set
 
-# CONFIG_PATA_HPT3X3 is not set
 
-# CONFIG_PATA_ISAPNP is not set
 
-# CONFIG_PATA_IT8213 is not set
 
-# CONFIG_PATA_IT821X is not set
 
-# CONFIG_PATA_JMICRON is not set
 
-# CONFIG_PATA_LEGACY is not set
 
-# CONFIG_PATA_MARVELL is not set
 
-# CONFIG_PATA_MPIIX is not set
 
-# CONFIG_PATA_NETCELL is not set
 
-# CONFIG_PATA_NINJA32 is not set
 
-# CONFIG_PATA_NS87410 is not set
 
-# CONFIG_PATA_NS87415 is not set
 
-# CONFIG_PATA_OLDPIIX is not set
 
-# CONFIG_PATA_OPTI is not set
 
-# CONFIG_PATA_OPTIDMA is not set
 
-# CONFIG_PATA_PCMCIA is not set
 
-# CONFIG_PATA_PDC2027X is not set
 
-# CONFIG_PATA_PDC_OLD is not set
 
-# CONFIG_PATA_PLATFORM is not set
 
-# CONFIG_PATA_QDI is not set
 
-# CONFIG_PATA_RADISYS is not set
 
-# CONFIG_PATA_RDC is not set
 
-# CONFIG_PATA_RZ1000 is not set
 
-# CONFIG_PATA_SC1200 is not set
 
-# CONFIG_PATA_SCH is not set
 
-# CONFIG_PATA_SERVERWORKS is not set
 
-# CONFIG_PATA_SIL680 is not set
 
-# CONFIG_PATA_SIS is not set
 
-# CONFIG_PATA_TOSHIBA is not set
 
-# CONFIG_PATA_TRIFLEX is not set
 
-# CONFIG_PATA_VIA is not set
 
-# CONFIG_PATA_WINBOND is not set
 
-# CONFIG_PATA_WINBOND_VLB is not set
 
-# CONFIG_PC300TOO is not set
 
-# CONFIG_PCCARD is not set
 
-# CONFIG_PCH_GBE is not set
 
-# CONFIG_PCH_PHUB is not set
 
-# CONFIG_PCI200SYN is not set
 
-# CONFIG_PCIEAER_INJECT is not set
 
-# CONFIG_PCIEASPM is not set
 
-# CONFIG_PCIE_ECRC is not set
 
-# CONFIG_PCIPCWATCHDOG is not set
 
-# CONFIG_PCI_ATMEL is not set
 
-# CONFIG_PCI_CNB20LE_QUIRK is not set
 
-# CONFIG_PCI_DEBUG is not set
 
-# CONFIG_PCI_DISABLE_COMMON_QUIRKS is not set
 
-# CONFIG_PCI_HERMES is not set
 
-# CONFIG_PCI_IOV is not set
 
-# CONFIG_PCI_MSI is not set
 
-# CONFIG_PCI_PASID is not set
 
-# CONFIG_PCI_PRI is not set
 
-CONFIG_PCI_QUIRKS=y
 
-# CONFIG_PCI_STUB is not set
 
-CONFIG_PCI_SYSCALL=y
 
-# CONFIG_PCMCIA is not set
 
-# CONFIG_PCMCIA_3C574 is not set
 
-# CONFIG_PCMCIA_3C589 is not set
 
-# CONFIG_PCMCIA_AHA152X is not set
 
-# CONFIG_PCMCIA_ATMEL is not set
 
-# CONFIG_PCMCIA_AXNET is not set
 
-# CONFIG_PCMCIA_DEBUG is not set
 
-# CONFIG_PCMCIA_FDOMAIN is not set
 
-# CONFIG_PCMCIA_FMVJ18X is not set
 
-# CONFIG_PCMCIA_HERMES is not set
 
-# CONFIG_PCMCIA_LOAD_CIS is not set
 
-# CONFIG_PCMCIA_NINJA_SCSI is not set
 
-# CONFIG_PCMCIA_NMCLAN is not set
 
-# CONFIG_PCMCIA_PCNET is not set
 
-# CONFIG_PCMCIA_QLOGIC is not set
 
-# CONFIG_PCMCIA_RAYCS is not set
 
-# CONFIG_PCMCIA_SMC91C92 is not set
 
-# CONFIG_PCMCIA_SPECTRUM is not set
 
-# CONFIG_PCMCIA_SYM53C500 is not set
 
-# CONFIG_PCMCIA_WL3501 is not set
 
-# CONFIG_PCMCIA_XIRC2PS is not set
 
-# CONFIG_PCMCIA_XIRCOM is not set
 
-# CONFIG_PCNET32 is not set
 
-# CONFIG_PCSPKR_PLATFORM is not set
 
-# CONFIG_PD6729 is not set
 
-# CONFIG_PDC_ADMA is not set
 
-# CONFIG_PERF_COUNTERS is not set
 
-# CONFIG_PERF_EVENTS is not set
 
-# CONFIG_PHANTOM is not set
 
-# CONFIG_PHONE is not set
 
-# CONFIG_PHONET is not set
 
-# CONFIG_PHYLIB is not set
 
-# CONFIG_PHYS_ADDR_T_64BIT is not set
 
-# CONFIG_PID_NS is not set
 
-# CONFIG_PINCTRL is not set
 
-# CONFIG_PLAT_SPEAR is not set
 
-# CONFIG_PLIP is not set
 
-# CONFIG_PLX_HERMES is not set
 
-# CONFIG_PM is not set
 
-# CONFIG_PMBUS is not set
 
-# CONFIG_PMC_MSP is not set
 
-# CONFIG_PMC_YOSEMITE is not set
 
-# CONFIG_PMIC_ADP5520 is not set
 
-# CONFIG_PMIC_DA903X is not set
 
-# CONFIG_PM_DEVFREQ is not set
 
-# CONFIG_PM_RUNTIME is not set
 
-# CONFIG_PNX8550_JBS is not set
 
-# CONFIG_PNX8550_STB810 is not set
 
-# CONFIG_POHMELFS is not set
 
-# CONFIG_POSIX_MQUEUE is not set
 
-# CONFIG_POWERTV is not set
 
-# CONFIG_POWER_SUPPLY is not set
 
-# CONFIG_POWER_SUPPLY_DEBUG is not set
 
-# CONFIG_PPC4xx_GPIO is not set
 
-# CONFIG_PPC_16K_PAGES is not set
 
-# CONFIG_PPC_256K_PAGES is not set
 
-CONFIG_PPC_4K_PAGES=y
 
-# CONFIG_PPC_64K_PAGES is not set
 
-# CONFIG_PPC_DISABLE_WERROR is not set
 
-# CONFIG_PPC_EMULATED_STATS is not set
 
-# CONFIG_PPC_EPAPR_HV_BYTECHAN is not set
 
-# CONFIG_PPP is not set
 
-# CONFIG_PPPOATM is not set
 
-# CONFIG_PPPOE is not set
 
-# CONFIG_PPPOL2TP is not set
 
-# CONFIG_PPP_ASYNC is not set
 
-# CONFIG_PPP_BSDCOMP is not set
 
-# CONFIG_PPP_DEFLATE is not set
 
-CONFIG_PPP_FILTER=y
 
-# CONFIG_PPP_MPPE is not set
 
-CONFIG_PPP_MULTILINK=y
 
-# CONFIG_PPP_SYNC_TTY is not set
 
-# CONFIG_PPS is not set
 
-# CONFIG_PPS_CLIENT_GPIO is not set
 
-# CONFIG_PPS_CLIENT_KTIMER is not set
 
-# CONFIG_PPS_CLIENT_LDISC is not set
 
-# CONFIG_PPS_CLIENT_PARPORT is not set
 
-# CONFIG_PPS_DEBUG is not set
 
-# CONFIG_PPTP is not set
 
-# CONFIG_PREEMPT is not set
 
-CONFIG_PREEMPT_NONE=y
 
-# CONFIG_PREEMPT_VOLUNTARY is not set
 
-CONFIG_PREVENT_FIRMWARE_BUILD=y
 
-CONFIG_PRINTK=y
 
-# CONFIG_PRINTK_TIME is not set
 
-CONFIG_PRINT_STACK_DEPTH=64
 
-# CONFIG_PRISM2_USB is not set
 
-# CONFIG_PRISM54 is not set
 
-# CONFIG_PROBE_INITRD_HEADER is not set
 
-CONFIG_PROC_FS=y
 
-# CONFIG_PROC_KCORE is not set
 
-# CONFIG_PROC_PAGE_MONITOR is not set
 
-CONFIG_PROC_SYSCTL=y
 
-# CONFIG_PROFILE_ALL_BRANCHES is not set
 
-# CONFIG_PROFILE_ANNOTATED_BRANCHES is not set
 
-# CONFIG_PROFILING is not set
 
-# CONFIG_PROVE_LOCKING is not set
 
-# CONFIG_PROVE_RCU is not set
 
-# CONFIG_PSB6970_PHY is not set
 
-# CONFIG_PSTORE is not set
 
-# CONFIG_PTP_1588_CLOCK_IXP46X is not set
 
-# CONFIG_QLA3XXX is not set
 
-# CONFIG_QLCNIC is not set
 
-# CONFIG_QLGE is not set
 
-# CONFIG_QNX4FS_FS is not set
 
-# CONFIG_QSEMI_PHY is not set
 
-# CONFIG_QUOTA is not set
 
-# CONFIG_QUOTACTL is not set
 
-# CONFIG_QUOTA_DEBUG is not set
 
-# CONFIG_R3964 is not set
 
-# CONFIG_R6040 is not set
 
-# CONFIG_R8169 is not set
 
-# CONFIG_R8187SE is not set
 
-# CONFIG_R8712U is not set
 
-# CONFIG_RADIO_ADAPTERS is not set
 
-# CONFIG_RADIO_AZTECH is not set
 
-# CONFIG_RADIO_CADET is not set
 
-# CONFIG_RADIO_GEMTEK is not set
 
-# CONFIG_RADIO_MAXIRADIO is not set
 
-# CONFIG_RADIO_RTRACK is not set
 
-# CONFIG_RADIO_RTRACK2 is not set
 
-# CONFIG_RADIO_SF16FMI is not set
 
-# CONFIG_RADIO_SF16FMR2 is not set
 
-# CONFIG_RADIO_TERRATEC is not set
 
-# CONFIG_RADIO_TRUST is not set
 
-# CONFIG_RADIO_TYPHOON is not set
 
-# CONFIG_RADIO_ZOLTRIX is not set
 
-# CONFIG_RAID_ATTRS is not set
 
-# CONFIG_RAMOOPS is not set
 
-# CONFIG_RAPIDIO is not set
 
-# CONFIG_RAR_REGISTER is not set
 
-# CONFIG_RAW_DRIVER is not set
 
-CONFIG_RCU_CPU_STALL_TIMEOUT=60
 
-CONFIG_RCU_FANOUT=32
 
-# CONFIG_RCU_FANOUT_EXACT is not set
 
-# CONFIG_RCU_FAST_NO_HZ is not set
 
-# CONFIG_RCU_TORTURE_TEST is not set
 
-# CONFIG_RCU_TRACE is not set
 
-# CONFIG_RC_CORE is not set
 
-# CONFIG_RC_MAP is not set
 
-# CONFIG_RDS is not set
 
-# CONFIG_RD_BZIP2 is not set
 
-# CONFIG_RD_GZIP is not set
 
-# CONFIG_RD_LZMA is not set
 
-# CONFIG_RD_LZO is not set
 
-# CONFIG_RD_XZ is not set
 
-# CONFIG_REALTEK_PHY is not set
 
-# CONFIG_REDWOOD is not set
 
-# CONFIG_REGMAP is not set
 
-# CONFIG_REGMAP_I2C is not set
 
-# CONFIG_REGMAP_SPI is not set
 
-# CONFIG_REGULATOR is not set
 
-# CONFIG_REGULATOR_BQ24022 is not set
 
-# CONFIG_REGULATOR_FIXED_VOLTAGE is not set
 
-# CONFIG_REGULATOR_GPIO is not set
 
-# CONFIG_REGULATOR_VIRTUAL_CONSUMER is not set
 
-# CONFIG_REISERFS_CHECK is not set
 
-# CONFIG_REISERFS_FS is not set
 
-# CONFIG_REISERFS_FS_POSIX_ACL is not set
 
-# CONFIG_REISERFS_FS_SECURITY is not set
 
-# CONFIG_REISERFS_FS_XATTR is not set
 
-# CONFIG_REISERFS_PROC_INFO is not set
 
-# CONFIG_RELAY is not set
 
-# CONFIG_RFD_FTL is not set
 
-# CONFIG_RFKILL is not set
 
-# CONFIG_RFKILL_INPUT is not set
 
-# CONFIG_RING_BUFFER_BENCHMARK is not set
 
-# CONFIG_ROMFS_FS is not set
 
-# CONFIG_ROSE is not set
 
-# CONFIG_RPCSEC_GSS_KRB5 is not set
 
-# CONFIG_RT2X00 is not set
 
-# CONFIG_RTC_CLASS is not set
 
-# CONFIG_RTC_DEBUG is not set
 
-# CONFIG_RTC_DRV_AU1XXX is not set
 
-# CONFIG_RTC_DRV_BQ32K is not set
 
-# CONFIG_RTC_DRV_BQ4802 is not set
 
-CONFIG_RTC_DRV_CMOS=y
 
-# CONFIG_RTC_DRV_DS1286 is not set
 
-# CONFIG_RTC_DRV_DS1305 is not set
 
-# CONFIG_RTC_DRV_DS1307 is not set
 
-# CONFIG_RTC_DRV_DS1374 is not set
 
-# CONFIG_RTC_DRV_DS1390 is not set
 
-# CONFIG_RTC_DRV_DS1511 is not set
 
-# CONFIG_RTC_DRV_DS1553 is not set
 
-# CONFIG_RTC_DRV_DS1672 is not set
 
-# CONFIG_RTC_DRV_DS1742 is not set
 
-# CONFIG_RTC_DRV_DS3232 is not set
 
-# CONFIG_RTC_DRV_DS3234 is not set
 
-# CONFIG_RTC_DRV_EM3027 is not set
 
-# CONFIG_RTC_DRV_EP93XX is not set
 
-# CONFIG_RTC_DRV_FM3130 is not set
 
-# CONFIG_RTC_DRV_GENERIC is not set
 
-# CONFIG_RTC_DRV_ISL12022 is not set
 
-# CONFIG_RTC_DRV_ISL1208 is not set
 
-# CONFIG_RTC_DRV_M41T80 is not set
 
-# CONFIG_RTC_DRV_M41T93 is not set
 
-# CONFIG_RTC_DRV_M41T94 is not set
 
-# CONFIG_RTC_DRV_M48T35 is not set
 
-# CONFIG_RTC_DRV_M48T59 is not set
 
-# CONFIG_RTC_DRV_M48T86 is not set
 
-# CONFIG_RTC_DRV_MAX6900 is not set
 
-# CONFIG_RTC_DRV_MAX6902 is not set
 
-# CONFIG_RTC_DRV_MPC5121 is not set
 
-# CONFIG_RTC_DRV_MSM6242 is not set
 
-# CONFIG_RTC_DRV_PCF2123 is not set
 
-# CONFIG_RTC_DRV_PCF8563 is not set
 
-# CONFIG_RTC_DRV_PCF8583 is not set
 
-# CONFIG_RTC_DRV_PL030 is not set
 
-# CONFIG_RTC_DRV_PL031 is not set
 
-# CONFIG_RTC_DRV_PS3 is not set
 
-# CONFIG_RTC_DRV_PT7C4338 is not set
 
-# CONFIG_RTC_DRV_R9701 is not set
 
-# CONFIG_RTC_DRV_RP5C01 is not set
 
-# CONFIG_RTC_DRV_RS5C348 is not set
 
-# CONFIG_RTC_DRV_RS5C372 is not set
 
-# CONFIG_RTC_DRV_RTC7301 is not set
 
-# CONFIG_RTC_DRV_RV3029C2 is not set
 
-# CONFIG_RTC_DRV_RX8025 is not set
 
-# CONFIG_RTC_DRV_RX8581 is not set
 
-# CONFIG_RTC_DRV_S35390A is not set
 
-# CONFIG_RTC_DRV_STK17TA8 is not set
 
-# CONFIG_RTC_DRV_TEST is not set
 
-# CONFIG_RTC_DRV_V3020 is not set
 
-# CONFIG_RTC_DRV_X1205 is not set
 
-CONFIG_RTC_HCTOSYS=y
 
-CONFIG_RTC_HCTOSYS_DEVICE="rtc0"
 
-CONFIG_RTC_INTF_DEV=y
 
-# CONFIG_RTC_INTF_DEV_UIE_EMUL is not set
 
-CONFIG_RTC_INTF_PROC=y
 
-CONFIG_RTC_INTF_SYSFS=y
 
-CONFIG_RTC_LIB=y
 
-# CONFIG_RTL8180 is not set
 
-# CONFIG_RTL8187 is not set
 
-# CONFIG_RTL8192E is not set
 
-# CONFIG_RTL8192U is not set
 
-# CONFIG_RTL8306_PHY is not set
 
-# CONFIG_RTL8366RB_PHY is not set
 
-# CONFIG_RTL8366S_PHY is not set
 
-# CONFIG_RTL8366_SMI is not set
 
-# CONFIG_RTL8366_SMI_DEBUG_FS is not set
 
-# CONFIG_RTL8367B_PHY is not set
 
-# CONFIG_RTL8367_PHY is not set
 
-# CONFIG_RTLLIB is not set
 
-# CONFIG_RTS5139 is not set
 
-# CONFIG_RTS_PSTOR is not set
 
-CONFIG_RT_MUTEXES=y
 
-# CONFIG_RT_MUTEX_TESTER is not set
 
-# CONFIG_RUNTIME_DEBUG is not set
 
-CONFIG_RWSEM_GENERIC_SPINLOCK=y
 
-# CONFIG_S2IO is not set
 
-# CONFIG_SAMPLES is not set
 
-# CONFIG_SAMSUNG_LAPTOP is not set
 
-# CONFIG_SATA_ACARD_AHCI is not set
 
-# CONFIG_SATA_AHCI is not set
 
-# CONFIG_SATA_AHCI_PLATFORM is not set
 
-# CONFIG_SATA_DWC is not set
 
-# CONFIG_SATA_FSL is not set
 
-# CONFIG_SATA_INIC162X is not set
 
-# CONFIG_SATA_MV is not set
 
-# CONFIG_SATA_NV is not set
 
-# CONFIG_SATA_PMP is not set
 
-# CONFIG_SATA_PROMISE is not set
 
-# CONFIG_SATA_QSTOR is not set
 
-# CONFIG_SATA_SIL is not set
 
-# CONFIG_SATA_SIL24 is not set
 
-# CONFIG_SATA_SIS is not set
 
-# CONFIG_SATA_SVW is not set
 
-# CONFIG_SATA_SX4 is not set
 
-# CONFIG_SATA_ULI is not set
 
-# CONFIG_SATA_VIA is not set
 
-# CONFIG_SATA_VITESSE is not set
 
-# CONFIG_SBC_FITPC2_WATCHDOG is not set
 
-# CONFIG_SBE_2T3E3 is not set
 
-# CONFIG_SC92031 is not set
 
-# CONFIG_SCC is not set
 
-# CONFIG_SCHEDSTATS is not set
 
-# CONFIG_SCHED_AUTOGROUP is not set
 
-# CONFIG_SCHED_DEBUG is not set
 
-# CONFIG_SCHED_MC is not set
 
-CONFIG_SCHED_OMIT_FRAME_POINTER=y
 
-# CONFIG_SCHED_SMT is not set
 
-# CONFIG_SCHED_TRACER is not set
 
-# CONFIG_SCSI is not set
 
-# CONFIG_SCSI_3W_9XXX is not set
 
-# CONFIG_SCSI_3W_SAS is not set
 
-# CONFIG_SCSI_7000FASST is not set
 
-# CONFIG_SCSI_AACRAID is not set
 
-# CONFIG_SCSI_ACARD is not set
 
-# CONFIG_SCSI_ADVANSYS is not set
 
-# CONFIG_SCSI_AHA152X is not set
 
-# CONFIG_SCSI_AHA1542 is not set
 
-# CONFIG_SCSI_AIC79XX is not set
 
-# CONFIG_SCSI_AIC7XXX is not set
 
-# CONFIG_SCSI_AIC7XXX_OLD is not set
 
-# CONFIG_SCSI_AIC94XX is not set
 
-# CONFIG_SCSI_ARCMSR is not set
 
-# CONFIG_SCSI_BFA_FC is not set
 
-# CONFIG_SCSI_BNX2X_FCOE is not set
 
-# CONFIG_SCSI_BNX2_ISCSI is not set
 
-# CONFIG_SCSI_BUSLOGIC is not set
 
-# CONFIG_SCSI_CONSTANTS is not set
 
-# CONFIG_SCSI_CXGB3_ISCSI is not set
 
-# CONFIG_SCSI_CXGB4_ISCSI is not set
 
-# CONFIG_SCSI_DC390T is not set
 
-# CONFIG_SCSI_DC395x is not set
 
-# CONFIG_SCSI_DEBUG is not set
 
-# CONFIG_SCSI_DH is not set
 
-CONFIG_SCSI_DMA=y
 
-# CONFIG_SCSI_DMX3191D is not set
 
-# CONFIG_SCSI_DPT_I2O is not set
 
-# CONFIG_SCSI_DTC3280 is not set
 
-# CONFIG_SCSI_EATA is not set
 
-# CONFIG_SCSI_FC_ATTRS is not set
 
-# CONFIG_SCSI_FUTURE_DOMAIN is not set
 
-# CONFIG_SCSI_GDTH is not set
 
-# CONFIG_SCSI_GENERIC_NCR5380 is not set
 
-# CONFIG_SCSI_GENERIC_NCR5380_MMIO is not set
 
-# CONFIG_SCSI_HPSA is not set
 
-# CONFIG_SCSI_HPTIOP is not set
 
-# CONFIG_SCSI_IN2000 is not set
 
-# CONFIG_SCSI_INIA100 is not set
 
-# CONFIG_SCSI_INITIO is not set
 
-# CONFIG_SCSI_IPR is not set
 
-# CONFIG_SCSI_IPS is not set
 
-# CONFIG_SCSI_ISCI is not set
 
-# CONFIG_SCSI_ISCSI_ATTRS is not set
 
-# CONFIG_SCSI_LOGGING is not set
 
-CONFIG_SCSI_LOWLEVEL=y
 
-# CONFIG_SCSI_LOWLEVEL_PCMCIA is not set
 
-# CONFIG_SCSI_LPFC is not set
 
-CONFIG_SCSI_MOD=y
 
-# CONFIG_SCSI_MPT2SAS is not set
 
-CONFIG_SCSI_MULTI_LUN=y
 
-# CONFIG_SCSI_MVSAS is not set
 
-# CONFIG_SCSI_MVSAS_DEBUG is not set
 
-# CONFIG_SCSI_MVUMI is not set
 
-# CONFIG_SCSI_NCR53C406A is not set
 
-# CONFIG_SCSI_NETLINK is not set
 
-# CONFIG_SCSI_NSP32 is not set
 
-# CONFIG_SCSI_OSD_INITIATOR is not set
 
-# CONFIG_SCSI_PAS16 is not set
 
-# CONFIG_SCSI_PM8001 is not set
 
-# CONFIG_SCSI_PMCRAID is not set
 
-CONFIG_SCSI_PROC_FS=y
 
-# CONFIG_SCSI_QLA_FC is not set
 
-# CONFIG_SCSI_QLA_ISCSI is not set
 
-# CONFIG_SCSI_QLOGIC_1280 is not set
 
-# CONFIG_SCSI_QLOGIC_FAS is not set
 
-# CONFIG_SCSI_SAS_ATTRS is not set
 
-# CONFIG_SCSI_SAS_LIBSAS is not set
 
-# CONFIG_SCSI_SCAN_ASYNC is not set
 
-# CONFIG_SCSI_SPI_ATTRS is not set
 
-# CONFIG_SCSI_SRP is not set
 
-# CONFIG_SCSI_SRP_ATTRS is not set
 
-# CONFIG_SCSI_STEX is not set
 
-# CONFIG_SCSI_SYM53C416 is not set
 
-# CONFIG_SCSI_SYM53C8XX_2 is not set
 
-# CONFIG_SCSI_T128 is not set
 
-# CONFIG_SCSI_TGT is not set
 
-# CONFIG_SCSI_U14_34F is not set
 
-# CONFIG_SCSI_ULTRASTOR is not set
 
-# CONFIG_SDIO_UART is not set
 
-# CONFIG_SECURITY is not set
 
-# CONFIG_SECURITYFS is not set
 
-# CONFIG_SECURITY_DMESG_RESTRICT is not set
 
-# CONFIG_SEEQ8005 is not set
 
-CONFIG_SELECT_MEMORY_MODEL=y
 
-# CONFIG_SENSORS_ABITUGURU is not set
 
-# CONFIG_SENSORS_ABITUGURU3 is not set
 
-# CONFIG_SENSORS_ACPI_POWER is not set
 
-# CONFIG_SENSORS_AD7314 is not set
 
-# CONFIG_SENSORS_AD7414 is not set
 
-# CONFIG_SENSORS_AD7418 is not set
 
-# CONFIG_SENSORS_ADCXX is not set
 
-# CONFIG_SENSORS_ADM1021 is not set
 
-# CONFIG_SENSORS_ADM1025 is not set
 
-# CONFIG_SENSORS_ADM1026 is not set
 
-# CONFIG_SENSORS_ADM1029 is not set
 
-# CONFIG_SENSORS_ADM1031 is not set
 
-# CONFIG_SENSORS_ADM9240 is not set
 
-# CONFIG_SENSORS_ADS1015 is not set
 
-# CONFIG_SENSORS_ADS7828 is not set
 
-# CONFIG_SENSORS_ADS7871 is not set
 
-# CONFIG_SENSORS_ADT7411 is not set
 
-# CONFIG_SENSORS_ADT7462 is not set
 
-# CONFIG_SENSORS_ADT7470 is not set
 
-# CONFIG_SENSORS_ADT7475 is not set
 
-# CONFIG_SENSORS_AMC6821 is not set
 
-# CONFIG_SENSORS_APDS990X is not set
 
-# CONFIG_SENSORS_APPLESMC is not set
 
-# CONFIG_SENSORS_ASB100 is not set
 
-# CONFIG_SENSORS_ASC7621 is not set
 
-# CONFIG_SENSORS_ATK0110 is not set
 
-# CONFIG_SENSORS_ATXP1 is not set
 
-# CONFIG_SENSORS_BH1770 is not set
 
-# CONFIG_SENSORS_BH1780 is not set
 
-# CONFIG_SENSORS_CORETEMP is not set
 
-# CONFIG_SENSORS_DME1737 is not set
 
-# CONFIG_SENSORS_DS1621 is not set
 
-# CONFIG_SENSORS_DS620 is not set
 
-# CONFIG_SENSORS_EMC1403 is not set
 
-# CONFIG_SENSORS_EMC2103 is not set
 
-# CONFIG_SENSORS_EMC6W201 is not set
 
-# CONFIG_SENSORS_F71805F is not set
 
-# CONFIG_SENSORS_F71882FG is not set
 
-# CONFIG_SENSORS_F75375S is not set
 
-# CONFIG_SENSORS_FAM15H_POWER is not set
 
-# CONFIG_SENSORS_FSCHMD is not set
 
-# CONFIG_SENSORS_G760A is not set
 
-# CONFIG_SENSORS_GL518SM is not set
 
-# CONFIG_SENSORS_GL520SM is not set
 
-# CONFIG_SENSORS_GPIO_FAN is not set
 
-# CONFIG_SENSORS_GSC is not set
 
-# CONFIG_SENSORS_HDAPS is not set
 
-# CONFIG_SENSORS_I5K_AMB is not set
 
-# CONFIG_SENSORS_IT87 is not set
 
-# CONFIG_SENSORS_JC42 is not set
 
-# CONFIG_SENSORS_K10TEMP is not set
 
-# CONFIG_SENSORS_K8TEMP is not set
 
-# CONFIG_SENSORS_LINEAGE is not set
 
-# CONFIG_SENSORS_LIS3LV02D is not set
 
-# CONFIG_SENSORS_LIS3_I2C is not set
 
-# CONFIG_SENSORS_LIS3_SPI is not set
 
-# CONFIG_SENSORS_LM63 is not set
 
-# CONFIG_SENSORS_LM70 is not set
 
-# CONFIG_SENSORS_LM73 is not set
 
-# CONFIG_SENSORS_LM75 is not set
 
-# CONFIG_SENSORS_LM77 is not set
 
-# CONFIG_SENSORS_LM78 is not set
 
-# CONFIG_SENSORS_LM80 is not set
 
-# CONFIG_SENSORS_LM83 is not set
 
-# CONFIG_SENSORS_LM85 is not set
 
-# CONFIG_SENSORS_LM87 is not set
 
-# CONFIG_SENSORS_LM90 is not set
 
-# CONFIG_SENSORS_LM92 is not set
 
-# CONFIG_SENSORS_LM93 is not set
 
-# CONFIG_SENSORS_LM95241 is not set
 
-# CONFIG_SENSORS_LM95245 is not set
 
-# CONFIG_SENSORS_LTC4151 is not set
 
-# CONFIG_SENSORS_LTC4215 is not set
 
-# CONFIG_SENSORS_LTC4245 is not set
 
-# CONFIG_SENSORS_LTC4261 is not set
 
-# CONFIG_SENSORS_MAX1111 is not set
 
-# CONFIG_SENSORS_MAX16065 is not set
 
-# CONFIG_SENSORS_MAX1619 is not set
 
-# CONFIG_SENSORS_MAX1668 is not set
 
-# CONFIG_SENSORS_MAX6639 is not set
 
-# CONFIG_SENSORS_MAX6642 is not set
 
-# CONFIG_SENSORS_MAX6650 is not set
 
-# CONFIG_SENSORS_NTC_THERMISTOR is not set
 
-# CONFIG_SENSORS_PC87360 is not set
 
-# CONFIG_SENSORS_PC87427 is not set
 
-# CONFIG_SENSORS_PCF8591 is not set
 
-# CONFIG_SENSORS_SCH5627 is not set
 
-# CONFIG_SENSORS_SCH5636 is not set
 
-# CONFIG_SENSORS_SCH56XX_COMMON is not set
 
-# CONFIG_SENSORS_SHT15 is not set
 
-# CONFIG_SENSORS_SHT21 is not set
 
-# CONFIG_SENSORS_SIS5595 is not set
 
-# CONFIG_SENSORS_SMM665 is not set
 
-# CONFIG_SENSORS_SMSC47B397 is not set
 
-# CONFIG_SENSORS_SMSC47M1 is not set
 
-# CONFIG_SENSORS_SMSC47M192 is not set
 
-# CONFIG_SENSORS_THMC50 is not set
 
-# CONFIG_SENSORS_TMP102 is not set
 
-# CONFIG_SENSORS_TMP401 is not set
 
-# CONFIG_SENSORS_TMP421 is not set
 
-# CONFIG_SENSORS_TSL2550 is not set
 
-# CONFIG_SENSORS_VIA686A is not set
 
-# CONFIG_SENSORS_VIA_CPUTEMP is not set
 
-# CONFIG_SENSORS_VT1211 is not set
 
-# CONFIG_SENSORS_VT8231 is not set
 
-# CONFIG_SENSORS_W83627EHF is not set
 
-# CONFIG_SENSORS_W83627HF is not set
 
-# CONFIG_SENSORS_W83781D is not set
 
-# CONFIG_SENSORS_W83791D is not set
 
-# CONFIG_SENSORS_W83792D is not set
 
-# CONFIG_SENSORS_W83793 is not set
 
-# CONFIG_SENSORS_W83795 is not set
 
-# CONFIG_SENSORS_W83L785TS is not set
 
-# CONFIG_SENSORS_W83L786NG is not set
 
-CONFIG_SERIAL_8250=y
 
-# CONFIG_SERIAL_8250_ACCENT is not set
 
-# CONFIG_SERIAL_8250_BOCA is not set
 
-CONFIG_SERIAL_8250_CONSOLE=y
 
-# CONFIG_SERIAL_8250_CS is not set
 
-# CONFIG_SERIAL_8250_DW is not set
 
-# CONFIG_SERIAL_8250_EXAR_ST16C554 is not set
 
-# CONFIG_SERIAL_8250_EXTENDED is not set
 
-# CONFIG_SERIAL_8250_FOURPORT is not set
 
-# CONFIG_SERIAL_8250_HUB6 is not set
 
-CONFIG_SERIAL_8250_NR_UARTS=2
 
-# CONFIG_SERIAL_8250_PCI is not set
 
-CONFIG_SERIAL_8250_RUNTIME_UARTS=2
 
-# CONFIG_SERIAL_ALTERA_JTAGUART is not set
 
-# CONFIG_SERIAL_ALTERA_UART is not set
 
-CONFIG_SERIAL_CORE=y
 
-CONFIG_SERIAL_CORE_CONSOLE=y
 
-# CONFIG_SERIAL_GRLIB_GAISLER_APBUART is not set
 
-# CONFIG_SERIAL_IFX6X60 is not set
 
-# CONFIG_SERIAL_JSM is not set
 
-# CONFIG_SERIAL_MAX3100 is not set
 
-# CONFIG_SERIAL_MAX3107 is not set
 
-# CONFIG_SERIAL_MFD_HSU is not set
 
-# CONFIG_SERIAL_NONSTANDARD is not set
 
-# CONFIG_SERIAL_OF_PLATFORM is not set
 
-# CONFIG_SERIAL_OF_PLATFORM_NWPSERIAL is not set
 
-# CONFIG_SERIAL_PCH_UART is not set
 
-# CONFIG_SERIAL_TIMBERDALE is not set
 
-# CONFIG_SERIAL_UARTLITE is not set
 
-# CONFIG_SERIAL_XILINX_PS_UART is not set
 
-# CONFIG_SERIO is not set
 
-# CONFIG_SERIO_ALTERA_PS2 is not set
 
-# CONFIG_SERIO_AMBAKMI is not set
 
-# CONFIG_SERIO_I8042 is not set
 
-# CONFIG_SERIO_LIBPS2 is not set
 
-# CONFIG_SERIO_PARKBD is not set
 
-# CONFIG_SERIO_PCIPS2 is not set
 
-# CONFIG_SERIO_PS2MULT is not set
 
-# CONFIG_SERIO_RAW is not set
 
-# CONFIG_SERIO_SERPORT is not set
 
-# CONFIG_SFC is not set
 
-# CONFIG_SFI is not set
 
-# CONFIG_SGI_IOC4 is not set
 
-# CONFIG_SGI_IP22 is not set
 
-# CONFIG_SGI_IP27 is not set
 
-# CONFIG_SGI_IP28 is not set
 
-# CONFIG_SGI_IP32 is not set
 
-# CONFIG_SGI_PARTITION is not set
 
-CONFIG_SHMEM=y
 
-# CONFIG_SIBYTE_BIGSUR is not set
 
-# CONFIG_SIBYTE_CARMEL is not set
 
-# CONFIG_SIBYTE_CRHINE is not set
 
-# CONFIG_SIBYTE_CRHONE is not set
 
-# CONFIG_SIBYTE_LITTLESUR is not set
 
-# CONFIG_SIBYTE_RHONE is not set
 
-# CONFIG_SIBYTE_SENTOSA is not set
 
-# CONFIG_SIBYTE_SWARM is not set
 
-# CONFIG_SIGMA is not set
 
-CONFIG_SIGNALFD=y
 
-# CONFIG_SIMPLE_GPIO is not set
 
-# CONFIG_SIS190 is not set
 
-# CONFIG_SIS900 is not set
 
-# CONFIG_SKGE is not set
 
-# CONFIG_SKY2 is not set
 
-# CONFIG_SKY2_DEBUG is not set
 
-CONFIG_SLAB=y
 
-CONFIG_SLABINFO=y
 
-# CONFIG_SLHC is not set
 
-# CONFIG_SLICOSS is not set
 
-# CONFIG_SLIP is not set
 
-# CONFIG_SLOB is not set
 
-# CONFIG_SLUB is not set
 
-# CONFIG_SLUB_DEBUG is not set
 
-# CONFIG_SLUB_STATS is not set
 
-# CONFIG_SMARTJOYPLUS_FF is not set
 
-# CONFIG_SMC911X is not set
 
-# CONFIG_SMC9194 is not set
 
-# CONFIG_SMC91X is not set
 
-# CONFIG_SMP is not set
 
-# CONFIG_SMSC911X is not set
 
-# CONFIG_SMSC9420 is not set
 
-# CONFIG_SMSC_PHY is not set
 
-# CONFIG_SM_FTL is not set
 
-# CONFIG_SND is not set
 
-# CONFIG_SND_AC97_POWER_SAVE is not set
 
-# CONFIG_SND_AD1816A is not set
 
-# CONFIG_SND_AD1848 is not set
 
-# CONFIG_SND_AD1889 is not set
 
-# CONFIG_SND_ADLIB is not set
 
-# CONFIG_SND_ALI5451 is not set
 
-# CONFIG_SND_ALOOP is not set
 
-# CONFIG_SND_ALS100 is not set
 
-# CONFIG_SND_ALS300 is not set
 
-# CONFIG_SND_ALS4000 is not set
 
-# CONFIG_SND_ARM is not set
 
-# CONFIG_SND_ASIHPI is not set
 
-# CONFIG_SND_ATIIXP is not set
 
-# CONFIG_SND_ATIIXP_MODEM is not set
 
-# CONFIG_SND_ATMEL_AC97C is not set
 
-# CONFIG_SND_ATMEL_SOC is not set
 
-# CONFIG_SND_AU8810 is not set
 
-# CONFIG_SND_AU8820 is not set
 
-# CONFIG_SND_AU8830 is not set
 
-# CONFIG_SND_AW2 is not set
 
-# CONFIG_SND_AZT2320 is not set
 
-# CONFIG_SND_AZT3328 is not set
 
-# CONFIG_SND_BT87X is not set
 
-# CONFIG_SND_CA0106 is not set
 
-# CONFIG_SND_CMI8330 is not set
 
-# CONFIG_SND_CMIPCI is not set
 
-# CONFIG_SND_CS4231 is not set
 
-# CONFIG_SND_CS4236 is not set
 
-# CONFIG_SND_CS4281 is not set
 
-# CONFIG_SND_CS46XX is not set
 
-# CONFIG_SND_CS5530 is not set
 
-# CONFIG_SND_CS5535AUDIO is not set
 
-# CONFIG_SND_CTXFI is not set
 
-# CONFIG_SND_DARLA20 is not set
 
-# CONFIG_SND_DARLA24 is not set
 
-# CONFIG_SND_DEBUG is not set
 
-CONFIG_SND_DRIVERS=y
 
-# CONFIG_SND_DUMMY is not set
 
-# CONFIG_SND_DYNAMIC_MINORS is not set
 
-# CONFIG_SND_ECHO3G is not set
 
-# CONFIG_SND_EMU10K1 is not set
 
-# CONFIG_SND_EMU10K1X is not set
 
-# CONFIG_SND_ENS1370 is not set
 
-# CONFIG_SND_ENS1371 is not set
 
-# CONFIG_SND_ES1688 is not set
 
-# CONFIG_SND_ES18XX is not set
 
-# CONFIG_SND_ES1938 is not set
 
-# CONFIG_SND_ES1968 is not set
 
-# CONFIG_SND_FIREWIRE is not set
 
-# CONFIG_SND_FM801 is not set
 
-# CONFIG_SND_GINA20 is not set
 
-# CONFIG_SND_GINA24 is not set
 
-# CONFIG_SND_GUSCLASSIC is not set
 
-# CONFIG_SND_GUSEXTREME is not set
 
-# CONFIG_SND_GUSMAX is not set
 
-# CONFIG_SND_HDA_INTEL is not set
 
-# CONFIG_SND_HDSP is not set
 
-# CONFIG_SND_HDSPM is not set
 
-# CONFIG_SND_HRTIMER is not set
 
-# CONFIG_SND_HWDEP is not set
 
-# CONFIG_SND_ICE1712 is not set
 
-# CONFIG_SND_ICE1724 is not set
 
-# CONFIG_SND_INDIGO is not set
 
-# CONFIG_SND_INDIGODJ is not set
 
-# CONFIG_SND_INDIGODJX is not set
 
-# CONFIG_SND_INDIGOIO is not set
 
-# CONFIG_SND_INDIGOIOX is not set
 
-# CONFIG_SND_INTEL8X0 is not set
 
-# CONFIG_SND_INTEL8X0M is not set
 
-# CONFIG_SND_INTERWAVE is not set
 
-# CONFIG_SND_INTERWAVE_STB is not set
 
-# CONFIG_SND_ISA is not set
 
-# CONFIG_SND_KIRKWOOD_SOC is not set
 
-# CONFIG_SND_KORG1212 is not set
 
-# CONFIG_SND_LAYLA20 is not set
 
-# CONFIG_SND_LAYLA24 is not set
 
-# CONFIG_SND_LOLA is not set
 
-# CONFIG_SND_LX6464ES is not set
 
-# CONFIG_SND_MAESTRO3 is not set
 
-# CONFIG_SND_MIA is not set
 
-# CONFIG_SND_MIPS is not set
 
-# CONFIG_SND_MIRO is not set
 
-# CONFIG_SND_MIXART is not set
 
-# CONFIG_SND_MIXER_OSS is not set
 
-# CONFIG_SND_MONA is not set
 
-# CONFIG_SND_MPC52xx_SOC_EFIKA is not set
 
-# CONFIG_SND_MPU401 is not set
 
-# CONFIG_SND_MTPAV is not set
 
-# CONFIG_SND_MTS64 is not set
 
-# CONFIG_SND_NM256 is not set
 
-# CONFIG_SND_OPL3SA2 is not set
 
-# CONFIG_SND_OPTI92X_AD1848 is not set
 
-# CONFIG_SND_OPTI92X_CS4231 is not set
 
-# CONFIG_SND_OPTI93X is not set
 
-CONFIG_SND_OSSEMUL=y
 
-# CONFIG_SND_OXYGEN is not set
 
-CONFIG_SND_PCI=y
 
-# CONFIG_SND_PCM is not set
 
-# CONFIG_SND_PCMCIA is not set
 
-# CONFIG_SND_PCM_OSS is not set
 
-CONFIG_SND_PCM_OSS_PLUGINS=y
 
-# CONFIG_SND_PCXHR is not set
 
-# CONFIG_SND_PDAUDIOCF is not set
 
-# CONFIG_SND_PORTMAN2X4 is not set
 
-# CONFIG_SND_PPC is not set
 
-# CONFIG_SND_RAWMIDI is not set
 
-# CONFIG_SND_RIPTIDE is not set
 
-# CONFIG_SND_RME32 is not set
 
-# CONFIG_SND_RME96 is not set
 
-# CONFIG_SND_RME9652 is not set
 
-# CONFIG_SND_RTCTIMER is not set
 
-# CONFIG_SND_SB16 is not set
 
-# CONFIG_SND_SB8 is not set
 
-# CONFIG_SND_SBAWE is not set
 
-# CONFIG_SND_SEQUENCER is not set
 
-# CONFIG_SND_SERIAL_U16550 is not set
 
-# CONFIG_SND_SIS7019 is not set
 
-# CONFIG_SND_SOC is not set
 
-# CONFIG_SND_SOC_AU1XAUDIO is not set
 
-# CONFIG_SND_SOC_AU1XPSC is not set
 
-# CONFIG_SND_SOC_CACHE_LZO is not set
 
-# CONFIG_SND_SOC_MPC5200_AC97 is not set
 
-# CONFIG_SND_SOC_MPC5200_I2S is not set
 
-# CONFIG_SND_SONICVIBES is not set
 
-# CONFIG_SND_SPI is not set
 
-# CONFIG_SND_SSCAPE is not set
 
-# CONFIG_SND_SUPPORT_OLD_API is not set
 
-# CONFIG_SND_TIMER is not set
 
-# CONFIG_SND_TRIDENT is not set
 
-CONFIG_SND_USB=y
 
-# CONFIG_SND_USB_6FIRE is not set
 
-# CONFIG_SND_USB_AUDIO is not set
 
-# CONFIG_SND_USB_CAIAQ is not set
 
-# CONFIG_SND_USB_UA101 is not set
 
-# CONFIG_SND_USB_US122L is not set
 
-# CONFIG_SND_USB_USX2Y is not set
 
-# CONFIG_SND_VERBOSE_PRINTK is not set
 
-CONFIG_SND_VERBOSE_PROCFS=y
 
-# CONFIG_SND_VIA82XX is not set
 
-# CONFIG_SND_VIA82XX_MODEM is not set
 
-# CONFIG_SND_VIRTUOSO is not set
 
-# CONFIG_SND_VX222 is not set
 
-# CONFIG_SND_VXPOCKET is not set
 
-# CONFIG_SND_WAVEFRONT is not set
 
-# CONFIG_SND_YMFPCI is not set
 
-# CONFIG_SNI_RM is not set
 
-# CONFIG_SOC_CAMERA is not set
 
-# CONFIG_SOFT_WATCHDOG is not set
 
-# CONFIG_SOLARIS_X86_PARTITION is not set
 
-# CONFIG_SOLO6X10 is not set
 
-# CONFIG_SONYPI is not set
 
-# CONFIG_SONY_LAPTOP is not set
 
-# CONFIG_SOUND is not set
 
-# CONFIG_SOUND_PRIME is not set
 
-# CONFIG_SP5100_TCO is not set
 
-# CONFIG_SPARSEMEM_MANUAL is not set
 
-# CONFIG_SPARSEMEM_STATIC is not set
 
-# CONFIG_SPARSEMEM_VMEMMAP_ENABLE is not set
 
-# CONFIG_SPARSE_IRQ is not set
 
-# CONFIG_SPARSE_RCU_POINTER is not set
 
-# CONFIG_SPEAKUP is not set
 
-# CONFIG_SPI is not set
 
-# CONFIG_SPINLOCK_TEST is not set
 
-# CONFIG_SPI_ALTERA is not set
 
-# CONFIG_SPI_AU1550 is not set
 
-# CONFIG_SPI_BITBANG is not set
 
-# CONFIG_SPI_BUTTERFLY is not set
 
-# CONFIG_SPI_DEBUG is not set
 
-# CONFIG_SPI_DESIGNWARE is not set
 
-# CONFIG_SPI_FSL_ESPI is not set
 
-# CONFIG_SPI_FSL_SPI is not set
 
-# CONFIG_SPI_GPIO is not set
 
-# CONFIG_SPI_GPIO_OLD is not set
 
-# CONFIG_SPI_LM70_LLP is not set
 
-# CONFIG_SPI_MASTER is not set
 
-# CONFIG_SPI_MPC52xx is not set
 
-# CONFIG_SPI_MPC52xx_PSC is not set
 
-# CONFIG_SPI_OC_TINY is not set
 
-# CONFIG_SPI_ORION is not set
 
-# CONFIG_SPI_PL022 is not set
 
-# CONFIG_SPI_PPC4xx is not set
 
-# CONFIG_SPI_PXA2XX is not set
 
-# CONFIG_SPI_PXA2XX_PCI is not set
 
-# CONFIG_SPI_RAMIPS is not set
 
-# CONFIG_SPI_SPIDEV is not set
 
-# CONFIG_SPI_TLE62X0 is not set
 
-# CONFIG_SPI_TOPCLIFF_PCH is not set
 
-# CONFIG_SPI_XILINX is not set
 
-# CONFIG_SPI_XWAY is not set
 
-CONFIG_SPLIT_PTLOCK_CPUS=4
 
-CONFIG_SQUASHFS=y
 
-# CONFIG_SQUASHFS_4K_DEVBLK_SIZE is not set
 
-# CONFIG_SQUASHFS_EMBEDDED is not set
 
-CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE=3
 
-# CONFIG_SQUASHFS_LZO is not set
 
-# CONFIG_SQUASHFS_XATTR is not set
 
-CONFIG_SQUASHFS_XZ=y
 
-# CONFIG_SQUASHFS_ZLIB is not set
 
-# CONFIG_SSB is not set
 
-# CONFIG_SSB_DEBUG is not set
 
-# CONFIG_SSB_DRIVER_GPIO is not set
 
-# CONFIG_SSB_PCMCIAHOST is not set
 
-CONFIG_SSB_POSSIBLE=y
 
-# CONFIG_SSB_SDIOHOST is not set
 
-# CONFIG_SSB_SILENT is not set
 
-# CONFIG_SSFDC is not set
 
-CONFIG_STACKTRACE_SUPPORT=y
 
-# CONFIG_STACK_TRACER is not set
 
-CONFIG_STAGING=y
 
-# CONFIG_STAGING_MEDIA is not set
 
-CONFIG_STANDALONE=y
 
-CONFIG_STDBINUTILS=y
 
-# CONFIG_STE10XP is not set
 
-# CONFIG_STMMAC_ETH is not set
 
-CONFIG_STP=y
 
-# CONFIG_STRICT_DEVMEM is not set
 
-CONFIG_STRIP_ASM_SYMS=y
 
-# CONFIG_STUB_POULSBO is not set
 
-# CONFIG_SUNDANCE is not set
 
-# CONFIG_SUNGEM is not set
 
-# CONFIG_SUNRPC is not set
 
-# CONFIG_SUNRPC_GSS is not set
 
-# CONFIG_SUN_PARTITION is not set
 
-# CONFIG_SUSPEND is not set
 
-CONFIG_SWAP=y
 
-# CONFIG_SWCONFIG is not set
 
-# CONFIG_SWCONFIG_LEDS is not set
 
-# CONFIG_SYNCLINK_CS is not set
 
-CONFIG_SYN_COOKIES=y
 
-CONFIG_SYSCTL=y
 
-# CONFIG_SYSCTL_SYSCALL is not set
 
-# CONFIG_SYSCTL_SYSCALL_CHECK is not set
 
-CONFIG_SYSFS=y
 
-# CONFIG_SYSFS_DEPRECATED is not set
 
-# CONFIG_SYSFS_DEPRECATED_V2 is not set
 
-# CONFIG_SYSV68_PARTITION is not set
 
-CONFIG_SYSVIPC=y
 
-CONFIG_SYSVIPC_SYSCTL=y
 
-# CONFIG_SYSV_FS is not set
 
-# CONFIG_SYS_HYPERVISOR is not set
 
-# CONFIG_TARGET_CORE is not set
 
-# CONFIG_TASKSTATS is not set
 
-# CONFIG_TC35815 is not set
 
-# CONFIG_TCG_TPM is not set
 
-# CONFIG_TCIC is not set
 
-CONFIG_TCP_CONG_ADVANCED=y
 
-# CONFIG_TCP_CONG_BIC is not set
 
-CONFIG_TCP_CONG_CUBIC=y
 
-# CONFIG_TCP_CONG_HSTCP is not set
 
-# CONFIG_TCP_CONG_HTCP is not set
 
-# CONFIG_TCP_CONG_HYBLA is not set
 
-# CONFIG_TCP_CONG_ILLINOIS is not set
 
-# CONFIG_TCP_CONG_LP is not set
 
-# CONFIG_TCP_CONG_SCALABLE is not set
 
-# CONFIG_TCP_CONG_VEGAS is not set
 
-# CONFIG_TCP_CONG_VENO is not set
 
-# CONFIG_TCP_CONG_WESTWOOD is not set
 
-# CONFIG_TCP_CONG_YEAH is not set
 
-# CONFIG_TCP_MD5SIG is not set
 
-# CONFIG_TEHUTI is not set
 
-# CONFIG_TEST_KSTRTOX is not set
 
-# CONFIG_TEST_LIST_SORT is not set
 
-# CONFIG_TEST_POWER is not set
 
-CONFIG_TEXTSEARCH=y
 
-# CONFIG_TEXTSEARCH_BM is not set
 
-# CONFIG_TEXTSEARCH_FSM is not set
 
-# CONFIG_TEXTSEARCH_KMP is not set
 
-# CONFIG_THERMAL is not set
 
-# CONFIG_THERMAL_HWMON is not set
 
-# CONFIG_THRUSTMASTER_FF is not set
 
-CONFIG_TICK_ONESHOT=y
 
-# CONFIG_TIFM_CORE is not set
 
-# CONFIG_TIGON3 is not set
 
-# CONFIG_TIMB_DMA is not set
 
-CONFIG_TIMERFD=y
 
-# CONFIG_TIMER_STATS is not set
 
-CONFIG_TINY_RCU=y
 
-# CONFIG_TIPC is not set
 
-# CONFIG_TI_DAC7512 is not set
 
-# CONFIG_TI_ST is not set
 
-# CONFIG_TLAN is not set
 
-# CONFIG_TMD_HERMES is not set
 
-CONFIG_TMPFS=y
 
-# CONFIG_TMPFS_POSIX_ACL is not set
 
-CONFIG_TMPFS_XATTR=y
 
-# CONFIG_TOUCHSCREEN_AD7877 is not set
 
-# CONFIG_TOUCHSCREEN_AD7879 is not set
 
-# CONFIG_TOUCHSCREEN_AD7879_I2C is not set
 
-# CONFIG_TOUCHSCREEN_AD7879_SPI is not set
 
-# CONFIG_TOUCHSCREEN_ADS7846 is not set
 
-# CONFIG_TOUCHSCREEN_CLEARPAD_TM1217 is not set
 
-# CONFIG_TOUCHSCREEN_CY8CTMG110 is not set
 
-# CONFIG_TOUCHSCREEN_EETI is not set
 
-# CONFIG_TOUCHSCREEN_ELO is not set
 
-# CONFIG_TOUCHSCREEN_FUJITSU is not set
 
-# CONFIG_TOUCHSCREEN_GUNZE is not set
 
-# CONFIG_TOUCHSCREEN_INEXIO is not set
 
-# CONFIG_TOUCHSCREEN_MCS5000 is not set
 
-# CONFIG_TOUCHSCREEN_MK712 is not set
 
-# CONFIG_TOUCHSCREEN_MTOUCH is not set
 
-# CONFIG_TOUCHSCREEN_PENMOUNT is not set
 
-# CONFIG_TOUCHSCREEN_S3C2410 is not set
 
-# CONFIG_TOUCHSCREEN_SYNAPTICS_I2C_RMI4 is not set
 
-# CONFIG_TOUCHSCREEN_TOUCHIT213 is not set
 
-# CONFIG_TOUCHSCREEN_TOUCHRIGHT is not set
 
-# CONFIG_TOUCHSCREEN_TOUCHWIN is not set
 
-# CONFIG_TOUCHSCREEN_TPS6507X is not set
 
-# CONFIG_TOUCHSCREEN_TSC2007 is not set
 
-# CONFIG_TOUCHSCREEN_USB_COMPOSITE is not set
 
-# CONFIG_TOUCHSCREEN_W90X900 is not set
 
-# CONFIG_TOUCHSCREEN_WACOM_W8001 is not set
 
-# CONFIG_TOUCHSCREEN_WM97XX is not set
 
-# CONFIG_TPS6105X is not set
 
-# CONFIG_TPS65010 is not set
 
-# CONFIG_TPS6507X is not set
 
-# CONFIG_TR is not set
 
-# CONFIG_TRACE_BRANCH_PROFILING is not set
 
-CONFIG_TRACE_IRQFLAGS_SUPPORT=y
 
-# CONFIG_TRACE_SINK is not set
 
-CONFIG_TRACING_SUPPORT=y
 
-CONFIG_TRAD_SIGNALS=y
 
-# CONFIG_TRANZPORT is not set
 
-# CONFIG_TREE_PREEMPT_RCU is not set
 
-# CONFIG_TREE_RCU is not set
 
-# CONFIG_TREE_RCU_TRACE is not set
 
-# CONFIG_TTY_PRINTK is not set
 
-# CONFIG_TUN is not set
 
-# CONFIG_TWL4030_CORE is not set
 
-# CONFIG_TYPHOON is not set
 
-# CONFIG_UACCESS_WITH_MEMCPY is not set
 
-# CONFIG_UCB1400_CORE is not set
 
-# CONFIG_UDF_FS is not set
 
-CONFIG_UDF_NLS=y
 
-CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
 
-# CONFIG_UFS_FS is not set
 
-# CONFIG_UIO is not set
 
-# CONFIG_ULTRA is not set
 
-# CONFIG_ULTRIX_PARTITION is not set
 
-CONFIG_UNIX=y
 
-CONFIG_UNIX98_PTYS=y
 
-# CONFIG_UNIXWARE_DISKLABEL is not set
 
-# CONFIG_UNIX_DIAG is not set
 
-# CONFIG_UNUSED_SYMBOLS is not set
 
-# CONFIG_USB is not set
 
-# CONFIG_USBIP_CORE is not set
 
-# CONFIG_USBPCWATCHDOG is not set
 
-# CONFIG_USB_ACM is not set
 
-# CONFIG_USB_ADUTUX is not set
 
-CONFIG_USB_ALI_M5632=y
 
-# CONFIG_USB_AMD5536UDC is not set
 
-CONFIG_USB_AN2720=y
 
-# CONFIG_USB_ANNOUNCE_NEW_DEVICES is not set
 
-# CONFIG_USB_APPLEDISPLAY is not set
 
-CONFIG_USB_ARCH_HAS_EHCI=y
 
-CONFIG_USB_ARCH_HAS_HCD=y
 
-CONFIG_USB_ARCH_HAS_OHCI=y
 
-CONFIG_USB_ARMLINUX=y
 
-# CONFIG_USB_ATM is not set
 
-CONFIG_USB_BELKIN=y
 
-# CONFIG_USB_C67X00_HCD is not set
 
-# CONFIG_USB_CATC is not set
 
-# CONFIG_USB_CDC_COMPOSITE is not set
 
-# CONFIG_USB_CXACRU is not set
 
-# CONFIG_USB_CYPRESS_CY7C63 is not set
 
-# CONFIG_USB_CYTHERM is not set
 
-# CONFIG_USB_DEBUG is not set
 
-CONFIG_USB_DEVICEFS=y
 
-# CONFIG_USB_DEVICE_CLASS is not set
 
-# CONFIG_USB_DSBR is not set
 
-# CONFIG_USB_DUMMY_HCD is not set
 
-# CONFIG_USB_DWC3 is not set
 
-# CONFIG_USB_DWC_OTG_LPM is not set
 
-# CONFIG_USB_DYNAMIC_MINORS is not set
 
-# CONFIG_USB_EG20T is not set
 
-# CONFIG_USB_EHCI_HCD_PLATFORM is not set
 
-# CONFIG_USB_EHCI_HCD_PPC_OF is not set
 
-# CONFIG_USB_EHCI_MV is not set
 
-CONFIG_USB_EHCI_ROOT_HUB_TT=y
 
-CONFIG_USB_EHCI_TT_NEWSCHED=y
 
-# CONFIG_USB_EMI26 is not set
 
-# CONFIG_USB_EMI62 is not set
 
-# CONFIG_USB_ENESTORAGE is not set
 
-# CONFIG_USB_EPSON2888 is not set
 
-# CONFIG_USB_ET61X251 is not set
 
-CONFIG_USB_EZUSB=y
 
-# CONFIG_USB_FILE_STORAGE is not set
 
-# CONFIG_USB_FSL_USB2 is not set
 
-# CONFIG_USB_FTDI_ELAN is not set
 
-# CONFIG_USB_FUNCTIONFS is not set
 
-# CONFIG_USB_FUSB300 is not set
 
-# CONFIG_USB_GADGET is not set
 
-# CONFIG_USB_GADGETFS is not set
 
-# CONFIG_USB_GADGET_DEBUG is not set
 
-# CONFIG_USB_GADGET_DEBUG_FILES is not set
 
-# CONFIG_USB_GADGET_DEBUG_FS is not set
 
-CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS=2
 
-CONFIG_USB_GADGET_VBUS_DRAW=2
 
-# CONFIG_USB_GL860 is not set
 
-# CONFIG_USB_GOKU is not set
 
-# CONFIG_USB_GPIO_VBUS is not set
 
-# CONFIG_USB_GSPCA is not set
 
-# CONFIG_USB_GSPCA_BENQ is not set
 
-# CONFIG_USB_GSPCA_CONEX is not set
 
-# CONFIG_USB_GSPCA_CPIA1 is not set
 
-# CONFIG_USB_GSPCA_ETOMS is not set
 
-# CONFIG_USB_GSPCA_FINEPIX is not set
 
-# CONFIG_USB_GSPCA_JEILINJ is not set
 
-# CONFIG_USB_GSPCA_JL2005BCD is not set
 
-# CONFIG_USB_GSPCA_KINECT is not set
 
-# CONFIG_USB_GSPCA_KONICA is not set
 
-# CONFIG_USB_GSPCA_MARS is not set
 
-# CONFIG_USB_GSPCA_MR97310A is not set
 
-# CONFIG_USB_GSPCA_NW80X is not set
 
-# CONFIG_USB_GSPCA_OV519 is not set
 
-# CONFIG_USB_GSPCA_OV534 is not set
 
-# CONFIG_USB_GSPCA_OV534_9 is not set
 
-# CONFIG_USB_GSPCA_PAC207 is not set
 
-# CONFIG_USB_GSPCA_PAC7302 is not set
 
-# CONFIG_USB_GSPCA_PAC7311 is not set
 
-# CONFIG_USB_GSPCA_SE401 is not set
 
-# CONFIG_USB_GSPCA_SN9C2028 is not set
 
-# CONFIG_USB_GSPCA_SN9C20X is not set
 
-# CONFIG_USB_GSPCA_SONIXB is not set
 
-# CONFIG_USB_GSPCA_SONIXJ is not set
 
-# CONFIG_USB_GSPCA_SPCA1528 is not set
 
-# CONFIG_USB_GSPCA_SPCA500 is not set
 
-# CONFIG_USB_GSPCA_SPCA501 is not set
 
-# CONFIG_USB_GSPCA_SPCA505 is not set
 
-# CONFIG_USB_GSPCA_SPCA506 is not set
 
-# CONFIG_USB_GSPCA_SPCA508 is not set
 
-# CONFIG_USB_GSPCA_SPCA561 is not set
 
-# CONFIG_USB_GSPCA_SQ905 is not set
 
-# CONFIG_USB_GSPCA_SQ905C is not set
 
-# CONFIG_USB_GSPCA_SQ930X is not set
 
-# CONFIG_USB_GSPCA_STK014 is not set
 
-# CONFIG_USB_GSPCA_STV0680 is not set
 
-# CONFIG_USB_GSPCA_SUNPLUS is not set
 
-# CONFIG_USB_GSPCA_T613 is not set
 
-# CONFIG_USB_GSPCA_TOPRO is not set
 
-# CONFIG_USB_GSPCA_TV8532 is not set
 
-# CONFIG_USB_GSPCA_VC032X is not set
 
-# CONFIG_USB_GSPCA_VICAM is not set
 
-# CONFIG_USB_GSPCA_XIRLINK_CIT is not set
 
-# CONFIG_USB_GSPCA_ZC3XX is not set
 
-# CONFIG_USB_G_ACM_MS is not set
 
-# CONFIG_USB_G_DBGP is not set
 
-# CONFIG_USB_G_HID is not set
 
-# CONFIG_USB_G_MULTI is not set
 
-# CONFIG_USB_G_NCM is not set
 
-# CONFIG_USB_G_NOKIA is not set
 
-# CONFIG_USB_G_PRINTER is not set
 
-# CONFIG_USB_G_SERIAL is not set
 
-# CONFIG_USB_G_WEBCAM is not set
 
-# CONFIG_USB_HID is not set
 
-# CONFIG_USB_HIDDEV is not set
 
-# CONFIG_USB_HSO is not set
 
-# CONFIG_USB_HWA_HCD is not set
 
-# CONFIG_USB_IBMCAM is not set
 
-# CONFIG_USB_IDMOUSE is not set
 
-# CONFIG_USB_IOWARRIOR is not set
 
-# CONFIG_USB_IPHETH is not set
 
-# CONFIG_USB_IP_COMMON is not set
 
-# CONFIG_USB_ISIGHTFW is not set
 
-# CONFIG_USB_ISP116X_HCD is not set
 
-# CONFIG_USB_ISP1362_HCD is not set
 
-# CONFIG_USB_ISP1760_HCD is not set
 
-# CONFIG_USB_KAWETH is not set
 
-# CONFIG_USB_KBD is not set
 
-# CONFIG_USB_KC2190 is not set
 
-# CONFIG_USB_KONICAWC is not set
 
-# CONFIG_USB_LCD is not set
 
-# CONFIG_USB_LD is not set
 
-# CONFIG_USB_LED is not set
 
-# CONFIG_USB_LEGOTOWER is not set
 
-# CONFIG_USB_LIBUSUAL is not set
 
-# CONFIG_USB_M5602 is not set
 
-# CONFIG_USB_M66592 is not set
 
-# CONFIG_USB_MASS_STORAGE is not set
 
-# CONFIG_USB_MDC800 is not set
 
-# CONFIG_USB_MICROTEK is not set
 
-# CONFIG_USB_MIDI_GADGET is not set
 
-# CONFIG_USB_MON is not set
 
-# CONFIG_USB_MOUSE is not set
 
-# CONFIG_USB_MUSB_HDRC is not set
 
-# CONFIG_USB_MV_UDC is not set
 
-# CONFIG_USB_NET2272 is not set
 
-# CONFIG_USB_NET2280 is not set
 
-# CONFIG_USB_NET_AX8817X is not set
 
-# CONFIG_USB_NET_CDCETHER is not set
 
-# CONFIG_USB_NET_CDC_EEM is not set
 
-# CONFIG_USB_NET_CDC_NCM is not set
 
-# CONFIG_USB_NET_CDC_SUBSET is not set
 
-# CONFIG_USB_NET_CX82310_ETH is not set
 
-# CONFIG_USB_NET_DM9601 is not set
 
-# CONFIG_USB_NET_GL620A is not set
 
-# CONFIG_USB_NET_INT51X1 is not set
 
-# CONFIG_USB_NET_KALMIA is not set
 
-# CONFIG_USB_NET_MCS7830 is not set
 
-# CONFIG_USB_NET_NET1080 is not set
 
-# CONFIG_USB_NET_PLUSB is not set
 
-# CONFIG_USB_NET_RNDIS_HOST is not set
 
-# CONFIG_USB_NET_RNDIS_WLAN is not set
 
-# CONFIG_USB_NET_SMSC75XX is not set
 
-# CONFIG_USB_NET_SMSC95XX is not set
 
-# CONFIG_USB_NET_ZAURUS is not set
 
-# CONFIG_USB_OHCI_HCD is not set
 
-# CONFIG_USB_OHCI_HCD_PCI is not set
 
-# CONFIG_USB_OHCI_HCD_PLATFORM is not set
 
-# CONFIG_USB_OHCI_HCD_PPC_OF is not set
 
-# CONFIG_USB_OHCI_HCD_PPC_OF_BE is not set
 
-# CONFIG_USB_OHCI_HCD_PPC_OF_LE is not set
 
-# CONFIG_USB_OHCI_HCD_PPC_SOC is not set
 
-# CONFIG_USB_OHCI_HCD_SSB is not set
 
-CONFIG_USB_OHCI_LITTLE_ENDIAN=y
 
-# CONFIG_USB_OTG is not set
 
-# CONFIG_USB_OTG_BLACKLIST_HUB is not set
 
-# CONFIG_USB_OTG_WHITELIST is not set
 
-# CONFIG_USB_OXU210HP_HCD is not set
 
-# CONFIG_USB_PEGASUS is not set
 
-# CONFIG_USB_PRINTER is not set
 
-# CONFIG_USB_PWC_INPUT_EVDEV is not set
 
-# CONFIG_USB_PXA27X is not set
 
-# CONFIG_USB_R8A66597 is not set
 
-# CONFIG_USB_R8A66597_HCD is not set
 
-# CONFIG_USB_RENESAS_USBHS is not set
 
-# CONFIG_USB_RIO500 is not set
 
-# CONFIG_USB_RTL8150 is not set
 
-# CONFIG_USB_S2255 is not set
 
-# CONFIG_USB_SE401 is not set
 
-# CONFIG_USB_SERIAL is not set
 
-# CONFIG_USB_SERIAL_AIRCABLE is not set
 
-# CONFIG_USB_SERIAL_ARK3116 is not set
 
-# CONFIG_USB_SERIAL_BELKIN is not set
 
-# CONFIG_USB_SERIAL_CH341 is not set
 
-# CONFIG_USB_SERIAL_CP210X is not set
 
-# CONFIG_USB_SERIAL_CYBERJACK is not set
 
-# CONFIG_USB_SERIAL_CYPRESS_M8 is not set
 
-# CONFIG_USB_SERIAL_DEBUG is not set
 
-# CONFIG_USB_SERIAL_DIGI_ACCELEPORT is not set
 
-# CONFIG_USB_SERIAL_EDGEPORT is not set
 
-# CONFIG_USB_SERIAL_EDGEPORT_TI is not set
 
-# CONFIG_USB_SERIAL_EMPEG is not set
 
-# CONFIG_USB_SERIAL_FTDI_SIO is not set
 
-# CONFIG_USB_SERIAL_FUNSOFT is not set
 
-# CONFIG_USB_SERIAL_GARMIN is not set
 
-CONFIG_USB_SERIAL_GENERIC=y
 
-# CONFIG_USB_SERIAL_HP4X is not set
 
-# CONFIG_USB_SERIAL_IPAQ is not set
 
-# CONFIG_USB_SERIAL_IPW is not set
 
-# CONFIG_USB_SERIAL_IR is not set
 
-# CONFIG_USB_SERIAL_IUU is not set
 
-# CONFIG_USB_SERIAL_KEYSPAN is not set
 
-CONFIG_USB_SERIAL_KEYSPAN_MPR=y
 
-# CONFIG_USB_SERIAL_KEYSPAN_PDA is not set
 
-CONFIG_USB_SERIAL_KEYSPAN_USA18X=y
 
-CONFIG_USB_SERIAL_KEYSPAN_USA19=y
 
-CONFIG_USB_SERIAL_KEYSPAN_USA19QI=y
 
-CONFIG_USB_SERIAL_KEYSPAN_USA19QW=y
 
-CONFIG_USB_SERIAL_KEYSPAN_USA19W=y
 
-CONFIG_USB_SERIAL_KEYSPAN_USA28=y
 
-CONFIG_USB_SERIAL_KEYSPAN_USA28X=y
 
-CONFIG_USB_SERIAL_KEYSPAN_USA28XA=y
 
-CONFIG_USB_SERIAL_KEYSPAN_USA28XB=y
 
-CONFIG_USB_SERIAL_KEYSPAN_USA49W=y
 
-CONFIG_USB_SERIAL_KEYSPAN_USA49WLC=y
 
-# CONFIG_USB_SERIAL_KLSI is not set
 
-# CONFIG_USB_SERIAL_KOBIL_SCT is not set
 
-# CONFIG_USB_SERIAL_MCT_U232 is not set
 
-# CONFIG_USB_SERIAL_MOS7715_PARPORT is not set
 
-# CONFIG_USB_SERIAL_MOS7720 is not set
 
-# CONFIG_USB_SERIAL_MOS7840 is not set
 
-# CONFIG_USB_SERIAL_MOTOROLA is not set
 
-# CONFIG_USB_SERIAL_NAVMAN is not set
 
-# CONFIG_USB_SERIAL_OMNINET is not set
 
-# CONFIG_USB_SERIAL_OPTICON is not set
 
-# CONFIG_USB_SERIAL_OPTION is not set
 
-# CONFIG_USB_SERIAL_OTI6858 is not set
 
-# CONFIG_USB_SERIAL_PL2303 is not set
 
-# CONFIG_USB_SERIAL_QCAUX is not set
 
-# CONFIG_USB_SERIAL_QUALCOMM is not set
 
-# CONFIG_USB_SERIAL_QUATECH2 is not set
 
-# CONFIG_USB_SERIAL_QUATECH_USB2 is not set
 
-# CONFIG_USB_SERIAL_SAFE is not set
 
-CONFIG_USB_SERIAL_SAFE_PADDED=y
 
-# CONFIG_USB_SERIAL_SIEMENS_MPI is not set
 
-# CONFIG_USB_SERIAL_SIERRAWIRELESS is not set
 
-# CONFIG_USB_SERIAL_SPCP8X5 is not set
 
-# CONFIG_USB_SERIAL_SSU100 is not set
 
-# CONFIG_USB_SERIAL_SYMBOL is not set
 
-# CONFIG_USB_SERIAL_TI is not set
 
-# CONFIG_USB_SERIAL_VISOR is not set
 
-# CONFIG_USB_SERIAL_VIVOPAY_SERIAL is not set
 
-# CONFIG_USB_SERIAL_WHITEHEAT is not set
 
-# CONFIG_USB_SERIAL_XIRCOM is not set
 
-# CONFIG_USB_SERIAL_ZIO is not set
 
-# CONFIG_USB_SEVSEG is not set
 
-# CONFIG_USB_SIERRA_NET is not set
 
-# CONFIG_USB_SISUSBVGA is not set
 
-# CONFIG_USB_SL811_HCD is not set
 
-# CONFIG_USB_SN9C102 is not set
 
-# CONFIG_USB_SPEEDTOUCH is not set
 
-# CONFIG_USB_STKWEBCAM is not set
 
-# CONFIG_USB_STORAGE is not set
 
-# CONFIG_USB_STORAGE_ALAUDA is not set
 
-# CONFIG_USB_STORAGE_CYPRESS_ATACB is not set
 
-# CONFIG_USB_STORAGE_DATAFAB is not set
 
-# CONFIG_USB_STORAGE_DEBUG is not set
 
-# CONFIG_USB_STORAGE_ENE_UB6250 is not set
 
-# CONFIG_USB_STORAGE_FREECOM is not set
 
-# CONFIG_USB_STORAGE_ISD200 is not set
 
-# CONFIG_USB_STORAGE_JUMPSHOT is not set
 
-# CONFIG_USB_STORAGE_KARMA is not set
 
-# CONFIG_USB_STORAGE_ONETOUCH is not set
 
-# CONFIG_USB_STORAGE_REALTEK is not set
 
-# CONFIG_USB_STORAGE_SDDR09 is not set
 
-# CONFIG_USB_STORAGE_SDDR55 is not set
 
-# CONFIG_USB_STORAGE_USBAT is not set
 
-# CONFIG_USB_STV06XX is not set
 
-# CONFIG_USB_SUPPORT is not set
 
-# CONFIG_USB_SUSPEND is not set
 
-# CONFIG_USB_SWITCH_FSA9480 is not set
 
-# CONFIG_USB_TEST is not set
 
-# CONFIG_USB_TMC is not set
 
-# CONFIG_USB_TRANCEVIBRATOR is not set
 
-# CONFIG_USB_UAS is not set
 
-# CONFIG_USB_UEAGLEATM is not set
 
-# CONFIG_USB_ULPI is not set
 
-# CONFIG_USB_USBNET is not set
 
-# CONFIG_USB_USS720 is not set
 
-# CONFIG_USB_VIDEO_CLASS is not set
 
-CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV=y
 
-# CONFIG_USB_VL600 is not set
 
-# CONFIG_USB_WDM is not set
 
-# CONFIG_USB_WHCI_HCD is not set
 
-# CONFIG_USB_WUSB is not set
 
-# CONFIG_USB_WUSB_CBAF is not set
 
-# CONFIG_USB_XHCI_HCD is not set
 
-# CONFIG_USB_XUSBATM is not set
 
-# CONFIG_USB_YUREX is not set
 
-# CONFIG_USB_ZD1201 is not set
 
-# CONFIG_USB_ZERO is not set
 
-# CONFIG_USB_ZR364XX is not set
 
-# CONFIG_USE_GENERIC_SMP_HELPERS is not set
 
-# CONFIG_USE_OF is not set
 
-# CONFIG_UTS_NS is not set
 
-# CONFIG_UWB is not set
 
-# CONFIG_V4L_MEM2MEM_DRIVERS is not set
 
-# CONFIG_VETH is not set
 
-# CONFIG_VFAT_FS is not set
 
-# CONFIG_VGASTATE is not set
 
-# CONFIG_VGA_ARB is not set
 
-# CONFIG_VGA_SWITCHEROO is not set
 
-# CONFIG_VIA_RHINE is not set
 
-# CONFIG_VIA_VELOCITY is not set
 
-# CONFIG_VIDEO_ADV7170 is not set
 
-# CONFIG_VIDEO_ADV7175 is not set
 
-# CONFIG_VIDEO_ADV7180 is not set
 
-# CONFIG_VIDEO_ADV7343 is not set
 
-# CONFIG_VIDEO_ADV_DEBUG is not set
 
-# CONFIG_VIDEO_AK881X is not set
 
-# CONFIG_VIDEO_BT819 is not set
 
-# CONFIG_VIDEO_BT848 is not set
 
-# CONFIG_VIDEO_BT856 is not set
 
-# CONFIG_VIDEO_BT866 is not set
 
-# CONFIG_VIDEO_BWQCAM is not set
 
-# CONFIG_VIDEO_CAFE_CCIC is not set
 
-# CONFIG_VIDEO_CAPTURE_DRIVERS is not set
 
-# CONFIG_VIDEO_CPIA is not set
 
-# CONFIG_VIDEO_CQCAM is not set
 
-# CONFIG_VIDEO_CS5345 is not set
 
-# CONFIG_VIDEO_CS53L32A is not set
 
-# CONFIG_VIDEO_CX231XX is not set
 
-# CONFIG_VIDEO_CX2341X is not set
 
-# CONFIG_VIDEO_CX25840 is not set
 
-# CONFIG_VIDEO_CX88 is not set
 
-# CONFIG_VIDEO_DEV is not set
 
-# CONFIG_VIDEO_DT3155 is not set
 
-# CONFIG_VIDEO_EM28XX is not set
 
-# CONFIG_VIDEO_FIXED_MINOR_RANGES is not set
 
-# CONFIG_VIDEO_GO7007 is not set
 
-# CONFIG_VIDEO_HDPVR is not set
 
-# CONFIG_VIDEO_HELPER_CHIPS_AUTO is not set
 
-# CONFIG_VIDEO_HEXIUM_GEMINI is not set
 
-# CONFIG_VIDEO_HEXIUM_ORION is not set
 
-# CONFIG_VIDEO_IR_I2C is not set
 
-# CONFIG_VIDEO_IVTV is not set
 
-# CONFIG_VIDEO_KS0127 is not set
 
-# CONFIG_VIDEO_M52790 is not set
 
-# CONFIG_VIDEO_MEDIA is not set
 
-# CONFIG_VIDEO_MSP3400 is not set
 
-# CONFIG_VIDEO_MT9V011 is not set
 
-# CONFIG_VIDEO_MXB is not set
 
-# CONFIG_VIDEO_NOON010PC30 is not set
 
-# CONFIG_VIDEO_OUTPUT_CONTROL is not set
 
-# CONFIG_VIDEO_OV7670 is not set
 
-# CONFIG_VIDEO_PMS is not set
 
-# CONFIG_VIDEO_PVRUSB2 is not set
 
-# CONFIG_VIDEO_SAA6588 is not set
 
-# CONFIG_VIDEO_SAA7110 is not set
 
-# CONFIG_VIDEO_SAA711X is not set
 
-# CONFIG_VIDEO_SAA7127 is not set
 
-# CONFIG_VIDEO_SAA7134 is not set
 
-# CONFIG_VIDEO_SAA717X is not set
 
-# CONFIG_VIDEO_SAA7185 is not set
 
-# CONFIG_VIDEO_SAA7191 is not set
 
-# CONFIG_VIDEO_SH_MOBILE_CEU is not set
 
-# CONFIG_VIDEO_SR030PC30 is not set
 
-# CONFIG_VIDEO_TCM825X is not set
 
-# CONFIG_VIDEO_TDA7432 is not set
 
-# CONFIG_VIDEO_TDA9840 is not set
 
-# CONFIG_VIDEO_TEA6415C is not set
 
-# CONFIG_VIDEO_TEA6420 is not set
 
-# CONFIG_VIDEO_THS7303 is not set
 
-# CONFIG_VIDEO_TIMBERDALE is not set
 
-# CONFIG_VIDEO_TLV320AIC23B is not set
 
-# CONFIG_VIDEO_TM6000 is not set
 
-# CONFIG_VIDEO_TVAUDIO is not set
 
-# CONFIG_VIDEO_TVP514X is not set
 
-# CONFIG_VIDEO_TVP5150 is not set
 
-# CONFIG_VIDEO_TVP7002 is not set
 
-# CONFIG_VIDEO_UPD64031A is not set
 
-# CONFIG_VIDEO_UPD64083 is not set
 
-# CONFIG_VIDEO_USBVISION is not set
 
-# CONFIG_VIDEO_V4L2 is not set
 
-# CONFIG_VIDEO_V4L2_COMMON is not set
 
-# CONFIG_VIDEO_VIVI is not set
 
-# CONFIG_VIDEO_VP27SMPX is not set
 
-# CONFIG_VIDEO_VPX3220 is not set
 
-# CONFIG_VIDEO_WM8739 is not set
 
-# CONFIG_VIDEO_WM8775 is not set
 
-# CONFIG_VIDEO_ZORAN is not set
 
-# CONFIG_VIRQ_DEBUG is not set
 
-# CONFIG_VIRTIO_BALLOON is not set
 
-# CONFIG_VIRTIO_MMIO is not set
 
-# CONFIG_VIRTIO_PCI is not set
 
-# CONFIG_VIRTUALIZATION is not set
 
-# CONFIG_VIRT_DRIVERS is not set
 
-CONFIG_VIRT_TO_BUS=y
 
-# CONFIG_VITESSE_PHY is not set
 
-CONFIG_VLAN_8021Q=y
 
-# CONFIG_VLAN_8021Q_GVRP is not set
 
-# CONFIG_VME_BUS is not set
 
-# CONFIG_VMSPLIT_1G is not set
 
-# CONFIG_VMSPLIT_2G is not set
 
-# CONFIG_VMSPLIT_2G_OPT is not set
 
-CONFIG_VMSPLIT_3G=y
 
-# CONFIG_VMSPLIT_3G_OPT is not set
 
-# CONFIG_VMWARE_PVSCSI is not set
 
-# CONFIG_VMXNET3 is not set
 
-# CONFIG_VM_EVENT_COUNTERS is not set
 
-# CONFIG_VORTEX is not set
 
-# CONFIG_VT is not set
 
-# CONFIG_VT6655 is not set
 
-# CONFIG_VT6656 is not set
 
-# CONFIG_VXFS_FS is not set
 
-# CONFIG_VXGE is not set
 
-# CONFIG_W1 is not set
 
-# CONFIG_W1_CON is not set
 
-# CONFIG_W1_MASTER_DS1WM is not set
 
-# CONFIG_W1_MASTER_DS2482 is not set
 
-# CONFIG_W1_MASTER_DS2490 is not set
 
-# CONFIG_W1_MASTER_GPIO is not set
 
-# CONFIG_W1_MASTER_MATROX is not set
 
-# CONFIG_W1_SLAVE_BQ27000 is not set
 
-# CONFIG_W1_SLAVE_DS2408 is not set
 
-# CONFIG_W1_SLAVE_DS2423 is not set
 
-# CONFIG_W1_SLAVE_DS2431 is not set
 
-# CONFIG_W1_SLAVE_DS2433 is not set
 
-# CONFIG_W1_SLAVE_DS2760 is not set
 
-# CONFIG_W1_SLAVE_DS2780 is not set
 
-# CONFIG_W1_SLAVE_SMEM is not set
 
-# CONFIG_W1_SLAVE_THERM is not set
 
-# CONFIG_W83627HF_WDT is not set
 
-# CONFIG_W83697HF_WDT is not set
 
-# CONFIG_W83877F_WDT is not set
 
-# CONFIG_W83977F_WDT is not set
 
-# CONFIG_WAN is not set
 
-# CONFIG_WANXL is not set
 
-# CONFIG_WAN_ROUTER is not set
 
-CONFIG_WATCHDOG=y
 
-# CONFIG_WATCHDOG_CORE is not set
 
-# CONFIG_WATCHDOG_NOWAYOUT is not set
 
-# CONFIG_WD80x3 is not set
 
-# CONFIG_WDTPCI is not set
 
-CONFIG_WEXT_CORE=y
 
-CONFIG_WEXT_PRIV=y
 
-CONFIG_WEXT_PROC=y
 
-CONFIG_WEXT_SPY=y
 
-# CONFIG_WIMAX is not set
 
-CONFIG_WIRELESS=y
 
-CONFIG_WIRELESS_EXT=y
 
-# CONFIG_WIRELESS_EXT_SYSFS is not set
 
-# CONFIG_WLAGS49_H2 is not set
 
-# CONFIG_WLAGS49_H25 is not set
 
-CONFIG_WLAN=y
 
-# CONFIG_WR_PPMC is not set
 
-# CONFIG_X25 is not set
 
-CONFIG_XFRM=y
 
-# CONFIG_XFRM_IPCOMP is not set
 
-# CONFIG_XFRM_MIGRATE is not set
 
-# CONFIG_XFRM_STATISTICS is not set
 
-# CONFIG_XFRM_SUB_POLICY is not set
 
-# CONFIG_XFRM_USER is not set
 
-# CONFIG_XFS_DEBUG is not set
 
-# CONFIG_XFS_FS is not set
 
-# CONFIG_XFS_POSIX_ACL is not set
 
-# CONFIG_XFS_QUOTA is not set
 
-# CONFIG_XFS_RT is not set
 
-# CONFIG_XILINX_EMACLITE is not set
 
-# CONFIG_XILINX_LL_TEMAC is not set
 
-# CONFIG_XIP_KERNEL is not set
 
-# CONFIG_XMON is not set
 
-# CONFIG_XVMALLOC is not set
 
-CONFIG_XZ_DEC=y
 
-# CONFIG_XZ_DEC_ARM is not set
 
-# CONFIG_XZ_DEC_ARMTHUMB is not set
 
-# CONFIG_XZ_DEC_BCJ is not set
 
-# CONFIG_XZ_DEC_IA64 is not set
 
-# CONFIG_XZ_DEC_POWERPC is not set
 
-# CONFIG_XZ_DEC_SPARC is not set
 
-# CONFIG_XZ_DEC_TEST is not set
 
-# CONFIG_XZ_DEC_X86 is not set
 
-# CONFIG_YAM is not set
 
-# CONFIG_YELLOWFIN is not set
 
-# CONFIG_YENTA is not set
 
-# CONFIG_YENTA_O2 is not set
 
-# CONFIG_YENTA_RICOH is not set
 
-# CONFIG_YENTA_TI is not set
 
-# CONFIG_YENTA_TOSHIBA is not set
 
-# CONFIG_ZD1211RW is not set
 
-# CONFIG_ZD1211RW_DEBUG is not set
 
-# CONFIG_ZEROPLUS_FF is not set
 
-# CONFIG_ZISOFS is not set
 
-# CONFIG_ZLIB_DEFLATE is not set
 
-# CONFIG_ZLIB_INFLATE is not set
 
-# CONFIG_ZNET is not set
 
-CONFIG_ZONE_DMA=y
 
-CONFIG_ZONE_DMA_FLAG=1
 
-# CONFIG_ZRAM is not set

+ 0 - 250
target/linux/generic/patches-3.3/001-ARM-7668-1-fix-memset-related-crashes-caused-by-rece.patch
View File 

@@ -1,250 +0,0 @@
 
-From 455bd4c430b0c0a361f38e8658a0d6cb469942b5 Mon Sep 17 00:00:00 2001
 
-From: Ivan Djelic <[email protected]>
 
-Date: Wed, 6 Mar 2013 20:09:27 +0100
 
-Subject: [PATCH] ARM: 7668/1: fix memset-related crashes caused by recent GCC
 
- (4.7.2) optimizations
 
-
 
-Recent GCC versions (e.g. GCC-4.7.2) perform optimizations based on
 
-assumptions about the implementation of memset and similar functions.
 
-The current ARM optimized memset code does not return the value of
 
-its first argument, as is usually expected from standard implementations.
 
-
 
-For instance in the following function:
 
-
 
-void debug_mutex_lock_common(struct mutex *lock, struct mutex_waiter *waiter)
 
-{
 
-	memset(waiter, MUTEX_DEBUG_INIT, sizeof(*waiter));
 
-	waiter->magic = waiter;
 
-	INIT_LIST_HEAD(&waiter->list);
 
-}
 
-
 
-compiled as:
 
-
 
-800554d0 <debug_mutex_lock_common>:
 
-800554d0:       e92d4008        push    {r3, lr}
 
-800554d4:       e1a00001        mov     r0, r1
 
-800554d8:       e3a02010        mov     r2, #16 ; 0x10
 
-800554dc:       e3a01011        mov     r1, #17 ; 0x11
 
-800554e0:       eb04426e        bl      80165ea0 <memset>
 
-800554e4:       e1a03000        mov     r3, r0
 
-800554e8:       e583000c        str     r0, [r3, #12]
 
-800554ec:       e5830000        str     r0, [r3]
 
-800554f0:       e5830004        str     r0, [r3, #4]
 
-800554f4:       e8bd8008        pop     {r3, pc}
 
-
 
-GCC assumes memset returns the value of pointer 'waiter' in register r0; causing
 
-register/memory corruptions.
 
-
 
-This patch fixes the return value of the assembly version of memset.
 
-It adds a 'mov' instruction and merges an additional load+store into
 
-existing load/store instructions.
 
-For ease of review, here is a breakdown of the patch into 4 simple steps:
 
-
 
-Step 1
 
-======
 
-Perform the following substitutions:
 
-ip -> r8, then
 
-r0 -> ip,
 
-and insert 'mov ip, r0' as the first statement of the function.
 
-At this point, we have a memset() implementation returning the proper result,
 
-but corrupting r8 on some paths (the ones that were using ip).
 
-
 
-Step 2
 
-======
 
-Make sure r8 is saved and restored when (! CALGN(1)+0) == 1:
 
-
 
-save r8:
 
--       str     lr, [sp, #-4]!
 
-+       stmfd   sp!, {r8, lr}
 
-
 
-and restore r8 on both exit paths:
 
--       ldmeqfd sp!, {pc}               @ Now <64 bytes to go.
 
-+       ldmeqfd sp!, {r8, pc}           @ Now <64 bytes to go.
 
-(...)
 
-        tst     r2, #16
 
-        stmneia ip!, {r1, r3, r8, lr}
 
--       ldr     lr, [sp], #4
 
-+       ldmfd   sp!, {r8, lr}
 
-
 
-Step 3
 
-======
 
-Make sure r8 is saved and restored when (! CALGN(1)+0) == 0:
 
-
 
-save r8:
 
--       stmfd   sp!, {r4-r7, lr}
 
-+       stmfd   sp!, {r4-r8, lr}
 
-
 
-and restore r8 on both exit paths:
 
-        bgt     3b
 
--       ldmeqfd sp!, {r4-r7, pc}
 
-+       ldmeqfd sp!, {r4-r8, pc}
 
-(...)
 
-        tst     r2, #16
 
-        stmneia ip!, {r4-r7}
 
--       ldmfd   sp!, {r4-r7, lr}
 
-+       ldmfd   sp!, {r4-r8, lr}
 
-
 
-Step 4
 
-======
 
-Rewrite register list "r4-r7, r8" as "r4-r8".
 
-
 
-Signed-off-by: Ivan Djelic <[email protected]>
 
-Reviewed-by: Nicolas Pitre <[email protected]>
 
-Signed-off-by: Dirk Behme <[email protected]>
 
-Signed-off-by: Russell King <[email protected]>
 
----
 
- arch/arm/lib/memset.S | 85 ++++++++++++++++++++++++++-------------------------
 
- 1 file changed, 44 insertions(+), 41 deletions(-)
 
-
 
---- a/arch/arm/lib/memset.S
 
-+++ b/arch/arm/lib/memset.S
 
-@@ -19,9 +19,9 @@
 
- 1:	subs	r2, r2, #4		@ 1 do we have enough
 
- 	blt	5f			@ 1 bytes to align with?
 
- 	cmp	r3, #2			@ 1
 
--	strltb	r1, [r0], #1		@ 1
 
--	strleb	r1, [r0], #1		@ 1
 
--	strb	r1, [r0], #1		@ 1
 
-+	strltb	r1, [ip], #1		@ 1
 
-+	strleb	r1, [ip], #1		@ 1
 
-+	strb	r1, [ip], #1		@ 1
 
- 	add	r2, r2, r3		@ 1 (r2 = r2 - (4 - r3))
 
- /*
 
-  * The pointer is now aligned and the length is adjusted.  Try doing the
 
-@@ -29,10 +29,14 @@
 
-  */
 
- 
- ENTRY(memset)
 
--	ands	r3, r0, #3		@ 1 unaligned?
 
-+/*
 
-+ * Preserve the contents of r0 for the return value.
 
-+ */
 
-+	mov	ip, r0
 
-+	ands	r3, ip, #3		@ 1 unaligned?
 
- 	bne	1b			@ 1
 
- /*
 
-- * we know that the pointer in r0 is aligned to a word boundary.
 
-+ * we know that the pointer in ip is aligned to a word boundary.
 
-  */
 
- 	orr	r1, r1, r1, lsl #8
 
- 	orr	r1, r1, r1, lsl #16
 
-@@ -43,29 +47,28 @@ ENTRY(memset)
 
- #if ! CALGN(1)+0
 
- 
- /*
 
-- * We need an extra register for this loop - save the return address and
 
-- * use the LR
 
-+ * We need 2 extra registers for this loop - use r8 and the LR
 
-  */
 
--	str	lr, [sp, #-4]!
 
--	mov	ip, r1
 
-+	stmfd	sp!, {r8, lr}
 
-+	mov	r8, r1
 
- 	mov	lr, r1
 
- 
- 2:	subs	r2, r2, #64
 
--	stmgeia	r0!, {r1, r3, ip, lr}	@ 64 bytes at a time.
 
--	stmgeia	r0!, {r1, r3, ip, lr}
 
--	stmgeia	r0!, {r1, r3, ip, lr}
 
--	stmgeia	r0!, {r1, r3, ip, lr}
 
-+	stmgeia	ip!, {r1, r3, r8, lr}	@ 64 bytes at a time.
 
-+	stmgeia	ip!, {r1, r3, r8, lr}
 
-+	stmgeia	ip!, {r1, r3, r8, lr}
 
-+	stmgeia	ip!, {r1, r3, r8, lr}
 
- 	bgt	2b
 
--	ldmeqfd	sp!, {pc}		@ Now <64 bytes to go.
 
-+	ldmeqfd	sp!, {r8, pc}		@ Now <64 bytes to go.
 
- /*
 
-  * No need to correct the count; we're only testing bits from now on
 
-  */
 
- 	tst	r2, #32
 
--	stmneia	r0!, {r1, r3, ip, lr}
 
--	stmneia	r0!, {r1, r3, ip, lr}
 
-+	stmneia	ip!, {r1, r3, r8, lr}
 
-+	stmneia	ip!, {r1, r3, r8, lr}
 
- 	tst	r2, #16
 
--	stmneia	r0!, {r1, r3, ip, lr}
 
--	ldr	lr, [sp], #4
 
-+	stmneia	ip!, {r1, r3, r8, lr}
 
-+	ldmfd	sp!, {r8, lr}
 
- 
- #else
 
- 
-@@ -74,54 +77,54 @@ ENTRY(memset)
 
-  * whole cache lines at once.
 
-  */
 
- 
--	stmfd	sp!, {r4-r7, lr}
 
-+	stmfd	sp!, {r4-r8, lr}
 
- 	mov	r4, r1
 
- 	mov	r5, r1
 
- 	mov	r6, r1
 
- 	mov	r7, r1
 
--	mov	ip, r1
 
-+	mov	r8, r1
 
- 	mov	lr, r1
 
- 
- 	cmp	r2, #96
 
--	tstgt	r0, #31
 
-+	tstgt	ip, #31
 
- 	ble	3f
 
- 
--	and	ip, r0, #31
 
--	rsb	ip, ip, #32
 
--	sub	r2, r2, ip
 
--	movs	ip, ip, lsl #(32 - 4)
 
--	stmcsia	r0!, {r4, r5, r6, r7}
 
--	stmmiia	r0!, {r4, r5}
 
--	tst	ip, #(1 << 30)
 
--	mov	ip, r1
 
--	strne	r1, [r0], #4
 
-+	and	r8, ip, #31
 
-+	rsb	r8, r8, #32
 
-+	sub	r2, r2, r8
 
-+	movs	r8, r8, lsl #(32 - 4)
 
-+	stmcsia	ip!, {r4, r5, r6, r7}
 
-+	stmmiia	ip!, {r4, r5}
 
-+	tst	r8, #(1 << 30)
 
-+	mov	r8, r1
 
-+	strne	r1, [ip], #4
 
- 
- 3:	subs	r2, r2, #64
 
--	stmgeia	r0!, {r1, r3-r7, ip, lr}
 
--	stmgeia	r0!, {r1, r3-r7, ip, lr}
 
-+	stmgeia	ip!, {r1, r3-r8, lr}
 
-+	stmgeia	ip!, {r1, r3-r8, lr}
 
- 	bgt	3b
 
--	ldmeqfd	sp!, {r4-r7, pc}
 
-+	ldmeqfd	sp!, {r4-r8, pc}
 
- 
- 	tst	r2, #32
 
--	stmneia	r0!, {r1, r3-r7, ip, lr}
 
-+	stmneia	ip!, {r1, r3-r8, lr}
 
- 	tst	r2, #16
 
--	stmneia	r0!, {r4-r7}
 
--	ldmfd	sp!, {r4-r7, lr}
 
-+	stmneia	ip!, {r4-r7}
 
-+	ldmfd	sp!, {r4-r8, lr}
 
- 
- #endif
 
- 
- 4:	tst	r2, #8
 
--	stmneia	r0!, {r1, r3}
 
-+	stmneia	ip!, {r1, r3}
 
- 	tst	r2, #4
 
--	strne	r1, [r0], #4
 
-+	strne	r1, [ip], #4
 
- /*
 
-  * When we get here, we've got less than 4 bytes to zero.  We
 
-  * may have an unaligned pointer as well.
 
-  */
 
- 5:	tst	r2, #2
 
--	strneb	r1, [r0], #1
 
--	strneb	r1, [r0], #1
 
-+	strneb	r1, [ip], #1
 
-+	strneb	r1, [ip], #1
 
- 	tst	r2, #1
 
--	strneb	r1, [r0], #1
 
-+	strneb	r1, [ip], #1
 
- 	mov	pc, lr
 
- ENDPROC(memset)

+ 0 - 78
target/linux/generic/patches-3.3/002-ARM-7668-1-fix-memset-related-crashes-caused-by-rece.patch
View File 

@@ -1,78 +0,0 @@
 
-From 418df63adac56841ef6b0f1fcf435bc64d4ed177 Mon Sep 17 00:00:00 2001
 
-From: Nicolas Pitre <[email protected]>
 
-Date: Tue, 12 Mar 2013 13:00:42 +0100
 
-Subject: [PATCH] ARM: 7670/1: fix the memset fix
 
-
 
-Commit 455bd4c430b0 ("ARM: 7668/1: fix memset-related crashes caused by
 
-recent GCC (4.7.2) optimizations") attempted to fix a compliance issue
 
-with the memset return value.  However the memset itself became broken
 
-by that patch for misaligned pointers.
 
-
 
-This fixes the above by branching over the entry code from the
 
-misaligned fixup code to avoid reloading the original pointer.
 
-
 
-Also, because the function entry alignment is wrong in the Thumb mode
 
-compilation, that fixup code is moved to the end.
 
-
 
-While at it, the entry instructions are slightly reworked to help dual
 
-issue pipelines.
 
-
 
-Signed-off-by: Nicolas Pitre <[email protected]>
 
-Tested-by: Alexander Holler <[email protected]>
 
-Signed-off-by: Russell King <[email protected]>
 
----
 
- arch/arm/lib/memset.S | 33 +++++++++++++--------------------
 
- 1 file changed, 13 insertions(+), 20 deletions(-)
 
-
 
---- a/arch/arm/lib/memset.S
 
-+++ b/arch/arm/lib/memset.S
 
-@@ -14,31 +14,15 @@
 
- 
- 	.text
 
- 	.align	5
 
--	.word	0
 
--
 
--1:	subs	r2, r2, #4		@ 1 do we have enough
 
--	blt	5f			@ 1 bytes to align with?
 
--	cmp	r3, #2			@ 1
 
--	strltb	r1, [ip], #1		@ 1
 
--	strleb	r1, [ip], #1		@ 1
 
--	strb	r1, [ip], #1		@ 1
 
--	add	r2, r2, r3		@ 1 (r2 = r2 - (4 - r3))
 
--/*
 
-- * The pointer is now aligned and the length is adjusted.  Try doing the
 
-- * memset again.
 
-- */
 
- 
- ENTRY(memset)
 
--/*
 
-- * Preserve the contents of r0 for the return value.
 
-- */
 
--	mov	ip, r0
 
--	ands	r3, ip, #3		@ 1 unaligned?
 
--	bne	1b			@ 1
 
-+	ands	r3, r0, #3		@ 1 unaligned?
 
-+	mov	ip, r0			@ preserve r0 as return value
 
-+	bne	6f			@ 1
 
- /*
 
-  * we know that the pointer in ip is aligned to a word boundary.
 
-  */
 
--	orr	r1, r1, r1, lsl #8
 
-+1:	orr	r1, r1, r1, lsl #8
 
- 	orr	r1, r1, r1, lsl #16
 
- 	mov	r3, r1
 
- 	cmp	r2, #16
 
-@@ -127,4 +111,13 @@ ENTRY(memset)
 
- 	tst	r2, #1
 
- 	strneb	r1, [ip], #1
 
- 	mov	pc, lr
 
-+
 
-+6:	subs	r2, r2, #4		@ 1 do we have enough
 
-+	blt	5b			@ 1 bytes to align with?
 
-+	cmp	r3, #2			@ 1
 
-+	strltb	r1, [ip], #1		@ 1
 
-+	strleb	r1, [ip], #1		@ 1
 
-+	strb	r1, [ip], #1		@ 1
 
-+	add	r2, r2, r3		@ 1 (r2 = r2 - (4 - r3))
 
-+	b	1b
 
- ENDPROC(memset)

+ 0 - 249
target/linux/generic/patches-3.3/003-MIPS-Refactor-clear_page-and-copy_page-functions.patch
View File 

@@ -1,249 +0,0 @@
 
-From c022630633624a75b3b58f43dd3c6cc896a56cff Mon Sep 17 00:00:00 2001
 
-From: "Steven J. Hill" <[email protected]>
 
-Date: Fri, 6 Jul 2012 21:56:01 +0200
 
-Subject: [PATCH] MIPS: Refactor 'clear_page' and 'copy_page' functions.
 
-
 
-Remove usage of the '__attribute__((alias("...")))' hack that aliased
 
-to integer arrays containing micro-assembled instructions. This hack
 
-breaks when building a microMIPS kernel. It also makes the code much
 
-easier to understand.
 
-
 
-[[email protected]: Added back export of the clear_page and copy_page
 
-symbols so certain modules will work again.  Also fixed build with
 
-CONFIG_SIBYTE_DMA_PAGEOPS enabled.]
 
-
 
-Signed-off-by: Steven J. Hill <[email protected]>
 
-Cc: [email protected]
 
-Patchwork: https://patchwork.linux-mips.org/patch/3866/
 
-Acked-by: David Daney <[email protected]>
 
-Signed-off-by: Ralf Baechle <[email protected]>
 
----
 
- arch/mips/kernel/mips_ksyms.c |    8 ++++-
 
- arch/mips/mm/Makefile         |    4 +--
 
- arch/mips/mm/page-funcs.S     |   50 ++++++++++++++++++++++++++++++
 
- arch/mips/mm/page.c           |   67 +++++++++++------------------------------
 
- 4 files changed, 77 insertions(+), 52 deletions(-)
 
- create mode 100644 arch/mips/mm/page-funcs.S
 
-
 
---- a/arch/mips/kernel/mips_ksyms.c
 
-+++ b/arch/mips/kernel/mips_ksyms.c
 
-@@ -5,7 +5,7 @@
 
-  * License.  See the file "COPYING" in the main directory of this archive
 
-  * for more details.
 
-  *
 
-- * Copyright (C) 1996, 97, 98, 99, 2000, 01, 03, 04, 05 by Ralf Baechle
 
-+ * Copyright (C) 1996, 97, 98, 99, 2000, 01, 03, 04, 05, 12 by Ralf Baechle
 
-  * Copyright (C) 1999, 2000, 01 Silicon Graphics, Inc.
 
-  */
 
- #include <linux/interrupt.h>
 
-@@ -35,6 +35,12 @@ EXPORT_SYMBOL(memmove);
 
- EXPORT_SYMBOL(kernel_thread);
 
- 
- /*
 
-+ * Functions that operate on entire pages.  Mostly used by memory management.
 
-+ */
 
-+EXPORT_SYMBOL(clear_page);
 
-+EXPORT_SYMBOL(copy_page);
 
-+
 
-+/*
 
-  * Userspace access stuff.
 
-  */
 
- EXPORT_SYMBOL(__copy_user);
 
---- a/arch/mips/mm/Makefile
 
-+++ b/arch/mips/mm/Makefile
 
-@@ -3,8 +3,8 @@
 
- #
 
- 
- obj-y				+= cache.o dma-default.o extable.o fault.o \
 
--				   gup.o init.o mmap.o page.o tlbex.o \
 
--				   tlbex-fault.o uasm.o
 
-+				   gup.o init.o mmap.o page.o page-funcs.o \
 
-+				   tlbex.o tlbex-fault.o uasm.o
 
- 
- obj-$(CONFIG_32BIT)		+= ioremap.o pgtable-32.o
 
- obj-$(CONFIG_64BIT)		+= pgtable-64.o
 
---- /dev/null
 
-+++ b/arch/mips/mm/page-funcs.S
 
-@@ -0,0 +1,50 @@
 
-+/*
 
-+ * This file is subject to the terms and conditions of the GNU General Public
 
-+ * License.  See the file "COPYING" in the main directory of this archive
 
-+ * for more details.
 
-+ *
 
-+ * Micro-assembler generated clear_page/copy_page functions.
 
-+ *
 
-+ * Copyright (C) 2012  MIPS Technologies, Inc.
 
-+ * Copyright (C) 2012  Ralf Baechle <[email protected]>
 
-+ */
 
-+#include <asm/asm.h>
 
-+#include <asm/regdef.h>
 
-+
 
-+#ifdef CONFIG_SIBYTE_DMA_PAGEOPS
 
-+#define cpu_clear_page_function_name	clear_page_cpu
 
-+#define cpu_copy_page_function_name	copy_page_cpu
 
-+#else
 
-+#define cpu_clear_page_function_name	clear_page
 
-+#define cpu_copy_page_function_name	copy_page
 
-+#endif
 
-+
 
-+/*
 
-+ * Maximum sizes:
 
-+ *
 
-+ * R4000 128 bytes S-cache:		0x058 bytes
 
-+ * R4600 v1.7:				0x05c bytes
 
-+ * R4600 v2.0:				0x060 bytes
 
-+ * With prefetching, 16 word strides	0x120 bytes
 
-+ */
 
-+EXPORT(__clear_page_start)
 
-+LEAF(cpu_clear_page_function_name)
 
-+1:	j	1b		/* Dummy, will be replaced. */
 
-+	.space 288
 
-+END(cpu_clear_page_function_name)
 
-+EXPORT(__clear_page_end)
 
-+
 
-+/*
 
-+ * Maximum sizes:
 
-+ *
 
-+ * R4000 128 bytes S-cache:		0x11c bytes
 
-+ * R4600 v1.7:				0x080 bytes
 
-+ * R4600 v2.0:				0x07c bytes
 
-+ * With prefetching, 16 word strides	0x540 bytes
 
-+ */
 
-+EXPORT(__copy_page_start)
 
-+LEAF(cpu_copy_page_function_name)
 
-+1:	j	1b		/* Dummy, will be replaced. */
 
-+	.space 1344
 
-+END(cpu_copy_page_function_name)
 
-+EXPORT(__copy_page_end)
 
---- a/arch/mips/mm/page.c
 
-+++ b/arch/mips/mm/page.c
 
-@@ -6,6 +6,7 @@
 
-  * Copyright (C) 2003, 04, 05 Ralf Baechle ([email protected])
 
-  * Copyright (C) 2007  Maciej W. Rozycki
 
-  * Copyright (C) 2008  Thiemo Seufer
 
-+ * Copyright (C) 2012  MIPS Technologies, Inc.
 
-  */
 
- #include <linux/init.h>
 
- #include <linux/kernel.h>
 
-@@ -72,45 +73,6 @@ static struct uasm_reloc __cpuinitdata r
 
- #define cpu_is_r4600_v1_x()	((read_c0_prid() & 0xfffffff0) == 0x00002010)
 
- #define cpu_is_r4600_v2_x()	((read_c0_prid() & 0xfffffff0) == 0x00002020)
 
- 
--/*
 
-- * Maximum sizes:
 
-- *
 
-- * R4000 128 bytes S-cache:		0x058 bytes
 
-- * R4600 v1.7:				0x05c bytes
 
-- * R4600 v2.0:				0x060 bytes
 
-- * With prefetching, 16 word strides	0x120 bytes
 
-- */
 
--
 
--static u32 clear_page_array[0x120 / 4];
 
--
 
--#ifdef CONFIG_SIBYTE_DMA_PAGEOPS
 
--void clear_page_cpu(void *page) __attribute__((alias("clear_page_array")));
 
--#else
 
--void clear_page(void *page) __attribute__((alias("clear_page_array")));
 
--#endif
 
--
 
--EXPORT_SYMBOL(clear_page);
 
--
 
--/*
 
-- * Maximum sizes:
 
-- *
 
-- * R4000 128 bytes S-cache:		0x11c bytes
 
-- * R4600 v1.7:				0x080 bytes
 
-- * R4600 v2.0:				0x07c bytes
 
-- * With prefetching, 16 word strides	0x540 bytes
 
-- */
 
--static u32 copy_page_array[0x540 / 4];
 
--
 
--#ifdef CONFIG_SIBYTE_DMA_PAGEOPS
 
--void
 
--copy_page_cpu(void *to, void *from) __attribute__((alias("copy_page_array")));
 
--#else
 
--void copy_page(void *to, void *from) __attribute__((alias("copy_page_array")));
 
--#endif
 
--
 
--EXPORT_SYMBOL(copy_page);
 
--
 
--
 
- static int pref_bias_clear_store __cpuinitdata;
 
- static int pref_bias_copy_load __cpuinitdata;
 
- static int pref_bias_copy_store __cpuinitdata;
 
-@@ -283,10 +245,15 @@ static inline void __cpuinit build_clear
 
- 		}
 
- }
 
- 
-+extern u32 __clear_page_start;
 
-+extern u32 __clear_page_end;
 
-+extern u32 __copy_page_start;
 
-+extern u32 __copy_page_end;
 
-+
 
- void __cpuinit build_clear_page(void)
 
- {
 
- 	int off;
 
--	u32 *buf = (u32 *)&clear_page_array;
 
-+	u32 *buf = &__clear_page_start;
 
- 	struct uasm_label *l = labels;
 
- 	struct uasm_reloc *r = relocs;
 
- 	int i;
 
-@@ -357,17 +324,17 @@ void __cpuinit build_clear_page(void)
 
- 	uasm_i_jr(&buf, RA);
 
- 	uasm_i_nop(&buf);
 
- 
--	BUG_ON(buf > clear_page_array + ARRAY_SIZE(clear_page_array));
 
-+	BUG_ON(buf > &__clear_page_end);
 
- 
- 	uasm_resolve_relocs(relocs, labels);
 
- 
- 	pr_debug("Synthesized clear page handler (%u instructions).\n",
 
--		 (u32)(buf - clear_page_array));
 
-+		 (u32)(buf - &__clear_page_start));
 
- 
- 	pr_debug("\t.set push\n");
 
- 	pr_debug("\t.set noreorder\n");
 
--	for (i = 0; i < (buf - clear_page_array); i++)
 
--		pr_debug("\t.word 0x%08x\n", clear_page_array[i]);
 
-+	for (i = 0; i < (buf - &__clear_page_start); i++)
 
-+		pr_debug("\t.word 0x%08x\n", (&__clear_page_start)[i]);
 
- 	pr_debug("\t.set pop\n");
 
- }
 
- 
-@@ -428,7 +395,7 @@ static inline void build_copy_store_pref
 
- void __cpuinit build_copy_page(void)
 
- {
 
- 	int off;
 
--	u32 *buf = (u32 *)&copy_page_array;
 
-+	u32 *buf = &__copy_page_start;
 
- 	struct uasm_label *l = labels;
 
- 	struct uasm_reloc *r = relocs;
 
- 	int i;
 
-@@ -596,21 +563,23 @@ void __cpuinit build_copy_page(void)
 
- 	uasm_i_jr(&buf, RA);
 
- 	uasm_i_nop(&buf);
 
- 
--	BUG_ON(buf > copy_page_array + ARRAY_SIZE(copy_page_array));
 
-+	BUG_ON(buf > &__copy_page_end);
 
- 
- 	uasm_resolve_relocs(relocs, labels);
 
- 
- 	pr_debug("Synthesized copy page handler (%u instructions).\n",
 
--		 (u32)(buf - copy_page_array));
 
-+		 (u32)(buf - &__copy_page_start));
 
- 
- 	pr_debug("\t.set push\n");
 
- 	pr_debug("\t.set noreorder\n");
 
--	for (i = 0; i < (buf - copy_page_array); i++)
 
--		pr_debug("\t.word 0x%08x\n", copy_page_array[i]);
 
-+	for (i = 0; i < (buf - &__copy_page_start); i++)
 
-+		pr_debug("\t.word 0x%08x\n", (&__copy_page_start)[i]);
 
- 	pr_debug("\t.set pop\n");
 
- }
 
- 
- #ifdef CONFIG_SIBYTE_DMA_PAGEOPS
 
-+extern void clear_page_cpu(void *page);
 
-+extern void copy_page_cpu(void *to, void *from);
 
- 
- /*
 
-  * Pad descriptors to cacheline, since each is exclusively owned by a

+ 0 - 96
target/linux/generic/patches-3.3/006-arm_kernel_xz_support.patch
View File 

@@ -1,96 +0,0 @@
 
-From 2d303b4683145f7dbc918bd14d04e1396581b2ce Mon Sep 17 00:00:00 2001
 
-From: Imre Kaloz <[email protected]>
 
-Date: Thu, 7 Jul 2011 12:05:21 +0200
 
-Subject: [PATCH] ARM: support XZ compressed kernels
 
-
 
-Wire up support for the XZ decompressor
 
-
 
-Signed-off-by: Imre Kaloz <[email protected]>
 
----
 
- arch/arm/Kconfig                        |    1 +
 
- arch/arm/boot/compressed/Makefile       |   11 +++++++++--
 
- arch/arm/boot/compressed/decompress.c   |    4 ++++
 
- arch/arm/boot/compressed/piggy.xzkern.S |    6 ++++++
 
- lib/xz/xz_dec_stream.c                  |    1 +
 
- 5 files changed, 21 insertions(+), 2 deletions(-)
 
- create mode 100644 arch/arm/boot/compressed/piggy.xzkern.S
 
-
 
---- a/arch/arm/Kconfig
 
-+++ b/arch/arm/Kconfig
 
-@@ -21,6 +21,7 @@ config ARM
 
- 	select HAVE_KERNEL_GZIP
 
- 	select HAVE_KERNEL_LZO
 
- 	select HAVE_KERNEL_LZMA
 
-+	select HAVE_KERNEL_XZ
 
- 	select HAVE_IRQ_WORK
 
- 	select HAVE_PERF_EVENTS
 
- 	select PERF_USE_VMALLOC
 
---- a/arch/arm/boot/compressed/Makefile
 
-+++ b/arch/arm/boot/compressed/Makefile
 
-@@ -92,6 +92,7 @@ SEDFLAGS	= s/TEXT_START/$(ZTEXTADDR)/;s/
 
- suffix_$(CONFIG_KERNEL_GZIP) = gzip
 
- suffix_$(CONFIG_KERNEL_LZO)  = lzo
 
- suffix_$(CONFIG_KERNEL_LZMA) = lzma
 
-+suffix_$(CONFIG_KERNEL_XZ)   = xzkern
 
- 
- # Borrowed libfdt files for the ATAG compatibility mode
 
- 
-@@ -115,7 +116,7 @@ targets       := vmlinux vmlinux.lds \
 
- 		 lib1funcs.o lib1funcs.S font.o font.c head.o misc.o $(OBJS)
 
- 
- # Make sure files are removed during clean
 
--extra-y       += piggy.gzip piggy.lzo piggy.lzma lib1funcs.S $(libfdt) $(libfdt_hdrs)
 
-+extra-y       += piggy.gzip piggy.lzo piggy.lzma piggy.xzkern lib1funcs.S ashldi3.S $(libfdt) $(libfdt_hdrs)
 
- 
- ifeq ($(CONFIG_FUNCTION_TRACER),y)
 
- ORIG_CFLAGS := $(KBUILD_CFLAGS)
 
-@@ -171,8 +172,14 @@ if [ $(words $(ZRELADDR)) -gt 1 -a "$(CO
 
- 	false; \
 
- fi
 
- 
-+# For __aeabi_llsl
 
-+ashldi3 = $(obj)/ashldi3.o
 
-+
 
-+$(obj)/ashldi3.S: $(srctree)/arch/$(SRCARCH)/lib/ashldi3.S FORCE
 
-+	$(call cmd,shipped)
 
-+
 
- $(obj)/vmlinux: $(obj)/vmlinux.lds $(obj)/$(HEAD) $(obj)/piggy.$(suffix_y).o \
 
--	 	$(addprefix $(obj)/, $(OBJS)) $(lib1funcs) FORCE
 
-+	 	$(addprefix $(obj)/, $(OBJS)) $(lib1funcs) $(ashldi3) FORCE
 
- 	@$(check_for_multiple_zreladdr)
 
- 	$(call if_changed,ld)
 
- 	@$(check_for_bad_syms)
 
---- a/arch/arm/boot/compressed/decompress.c
 
-+++ b/arch/arm/boot/compressed/decompress.c
 
-@@ -44,6 +44,12 @@ extern void error(char *);
 
- #include "../../../../lib/decompress_unlzma.c"
 
- #endif
 
- 
-+#ifdef CONFIG_KERNEL_XZ
 
-+#define memmove memmove
 
-+#define memcpy memcpy
 
-+#include "../../../../lib/decompress_unxz.c"
 
-+#endif
 
-+
 
- int do_decompress(u8 *input, int len, u8 *output, void (*error)(char *x))
 
- {
 
- 	return decompress(input, len, NULL, NULL, output, NULL, error);
 
---- /dev/null
 
-+++ b/arch/arm/boot/compressed/piggy.xzkern.S
 
-@@ -0,0 +1,6 @@
 
-+	.section .piggydata,#alloc
 
-+	.globl	input_data
 
-+input_data:
 
-+	.incbin	"arch/arm/boot/compressed/piggy.xzkern"
 
-+	.globl	input_data_end
 
-+input_data_end:
 
---- a/lib/xz/xz_dec_stream.c
 
-+++ b/lib/xz/xz_dec_stream.c
 
-@@ -9,6 +9,7 @@
 
- 
- #include "xz_private.h"
 
- #include "xz_stream.h"
 
-+#include <linux/kernel.h>
 
- 
- /* Hash used to validate the Index field */
 
- struct xz_dec_hash {

+ 0 - 40
target/linux/generic/patches-3.3/007-hso-Earlier-catch-of-error-condition.patch
View File 

@@ -1,40 +0,0 @@
 
-From 35e57e1b49a351aa804dab6010cd46ae6112a541 Mon Sep 17 00:00:00 2001
 
-From: Daniel Gimpelevich <[email protected]>
 
-Date: Wed, 21 Aug 2013 01:43:07 -0700
 
-Subject: [PATCH 1/2] hso: Earlier catch of error condition
 
-
 
-There is no need to get an interface specification if we know it's the
 
-wrong one.
 
-
 
-Signed-off-by: Daniel Gimpelevich <[email protected]>
 
-Acked-by: Greg Kroah-Hartman <[email protected]>
 
-Signed-off-by: David S. Miller <[email protected]>
 
----
 
- drivers/net/usb/hso.c |    9 +++++----
 
- 1 file changed, 5 insertions(+), 4 deletions(-)
 
-
 
---- a/drivers/net/usb/hso.c
 
-+++ b/drivers/net/usb/hso.c
 
-@@ -2927,6 +2927,11 @@ static int hso_probe(struct usb_interfac
 
- 	struct hso_shared_int *shared_int;
 
- 	struct hso_device *tmp_dev = NULL;
 
- 
-+	if (interface->cur_altsetting->desc.bInterfaceClass != 0xFF) {
 
-+		dev_err(&interface->dev, "Not our interface\n");
 
-+		return -ENODEV;
 
-+	}
 
-+
 
- 	if_num = interface->altsetting->desc.bInterfaceNumber;
 
- 
- 	/* Get the interface/port specification from either driver_info or from
 
-@@ -2936,10 +2941,6 @@ static int hso_probe(struct usb_interfac
 
- 	else
 
- 		port_spec = hso_get_config_data(interface);
 
- 
--	if (interface->cur_altsetting->desc.bInterfaceClass != 0xFF) {
 
--		dev_err(&interface->dev, "Not our interface\n");
 
--		return -ENODEV;
 
--	}
 
- 	/* Check if we need to switch to alt interfaces prior to port
 
- 	 * configuration */
 
- 	if (interface->num_altsetting > 1)

+ 0 - 48
target/linux/generic/patches-3.3/008-hso-Fix-stack-corruption-on-some-architectures.patch
View File 

@@ -1,48 +0,0 @@
 
-From e75dc677ff8d06ffa61bef6fee436227ae5440c6 Mon Sep 17 00:00:00 2001
 
-From: Daniel Gimpelevich <[email protected]>
 
-Date: Wed, 21 Aug 2013 01:43:19 -0700
 
-Subject: [PATCH 2/2] hso: Fix stack corruption on some architectures
 
-
 
-As Sergei Shtylyov explained in the #mipslinux IRC channel:
 
-[Mon 2013-08-19 12:28:21 PM PDT] <headless> guys, are you sure it's not "DMA off stack" case?
 
-[Mon 2013-08-19 12:28:35 PM PDT] <headless> it's a known stack corruptor on non-coherent arches
 
-[Mon 2013-08-19 12:31:48 PM PDT] <DonkeyHotei> headless: for usb/ehci?
 
-[Mon 2013-08-19 12:34:11 PM PDT] <DonkeyHotei> headless: explain
 
-[Mon 2013-08-19 12:35:38 PM PDT] <headless> usb_control_msg() (or other such func) should not use buffer on stack. DMA from/to stack is prohibited
 
-[Mon 2013-08-19 12:35:58 PM PDT] <headless> and EHCI uses DMA on control xfers (as well as all the others)
 
-
 
-Signed-off-by: Daniel Gimpelevich <[email protected]>
 
-Acked-by: Greg Kroah-Hartman <[email protected]>
 
-Signed-off-by: David S. Miller <[email protected]>
 
----
 
- drivers/net/usb/hso.c |    6 +++++-
 
- 1 file changed, 5 insertions(+), 1 deletion(-)
 
-
 
---- a/drivers/net/usb/hso.c
 
-+++ b/drivers/net/usb/hso.c
 
-@@ -2857,13 +2857,16 @@ exit:
 
- static int hso_get_config_data(struct usb_interface *interface)
 
- {
 
- 	struct usb_device *usbdev = interface_to_usbdev(interface);
 
--	u8 config_data[17];
 
-+	u8 *config_data = kmalloc(17, GFP_KERNEL);
 
- 	u32 if_num = interface->altsetting->desc.bInterfaceNumber;
 
- 	s32 result;
 
- 
-+	if (!config_data)
 
-+		return -ENOMEM;
 
- 	if (usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
 
- 			    0x86, 0xC0, 0, 0, config_data, 17,
 
- 			    USB_CTRL_SET_TIMEOUT) != 0x11) {
 
-+		kfree(config_data);
 
- 		return -EIO;
 
- 	}
 
- 
-@@ -2914,6 +2917,7 @@ static int hso_get_config_data(struct us
 
- 	if (config_data[16] & 0x1)
 
- 		result |= HSO_INFO_CRC_BUG;
 
- 
-+	kfree(config_data);
 
- 	return result;
 
- }
 
-

+ 0 - 3206
target/linux/generic/patches-3.3/020-ssb_update.patch
View File 

@@ -1,3206 +0,0 @@
 
---- a/arch/mips/bcm47xx/nvram.c
 
-+++ b/arch/mips/bcm47xx/nvram.c
 
-@@ -43,8 +43,8 @@ static void early_nvram_init(void)
 
- #ifdef CONFIG_BCM47XX_SSB
 
- 	case BCM47XX_BUS_TYPE_SSB:
 
- 		mcore_ssb = &bcm47xx_bus.ssb.mipscore;
 
--		base = mcore_ssb->flash_window;
 
--		lim = mcore_ssb->flash_window_size;
 
-+		base = mcore_ssb->pflash.window;
 
-+		lim = mcore_ssb->pflash.window_size;
 
- 		break;
 
- #endif
 
- #ifdef CONFIG_BCM47XX_BCMA
 
---- a/arch/mips/bcm47xx/wgt634u.c
 
-+++ b/arch/mips/bcm47xx/wgt634u.c
 
-@@ -156,10 +156,10 @@ static int __init wgt634u_init(void)
 
- 					    SSB_CHIPCO_IRQ_GPIO);
 
- 		}
 
- 
--		wgt634u_flash_data.width = mcore->flash_buswidth;
 
--		wgt634u_flash_resource.start = mcore->flash_window;
 
--		wgt634u_flash_resource.end = mcore->flash_window
 
--					   + mcore->flash_window_size
 
-+		wgt634u_flash_data.width = mcore->pflash.buswidth;
 
-+		wgt634u_flash_resource.start = mcore->pflash.window;
 
-+		wgt634u_flash_resource.end = mcore->pflash.window
 
-+					   + mcore->pflash.window_size
 
- 					   - 1;
 
- 		return platform_add_devices(wgt634u_devices,
 
- 					    ARRAY_SIZE(wgt634u_devices));
 
---- a/drivers/ssb/Kconfig
 
-+++ b/drivers/ssb/Kconfig
 
-@@ -136,10 +136,15 @@ config SSB_DRIVER_MIPS
 
- 
- 	  If unsure, say N
 
- 
-+config SSB_SFLASH
 
-+	bool "SSB serial flash support"
 
-+	depends on SSB_DRIVER_MIPS
 
-+	default y
 
-+
 
- # Assumption: We are on embedded, if we compile the MIPS core.
 
- config SSB_EMBEDDED
 
- 	bool
 
--	depends on SSB_DRIVER_MIPS
 
-+	depends on SSB_DRIVER_MIPS && SSB_PCICORE_HOSTMODE
 
- 	default y
 
- 
- config SSB_DRIVER_EXTIF
 
-@@ -160,4 +165,12 @@ config SSB_DRIVER_GIGE
 
- 
- 	  If unsure, say N
 
- 
-+config SSB_DRIVER_GPIO
 
-+	bool "SSB GPIO driver"
 
-+	depends on SSB && GPIOLIB
 
-+	help
 
-+	  Driver to provide access to the GPIO pins on the bus.
 
-+
 
-+	  If unsure, say N
 
-+
 
- endmenu
 
---- a/drivers/ssb/Makefile
 
-+++ b/drivers/ssb/Makefile
 
-@@ -11,10 +11,12 @@ ssb-$(CONFIG_SSB_SDIOHOST)		+= sdio.o
 
- # built-in drivers
 
- ssb-y					+= driver_chipcommon.o
 
- ssb-y					+= driver_chipcommon_pmu.o
 
-+ssb-$(CONFIG_SSB_SFLASH)		+= driver_chipcommon_sflash.o
 
- ssb-$(CONFIG_SSB_DRIVER_MIPS)		+= driver_mipscore.o
 
- ssb-$(CONFIG_SSB_DRIVER_EXTIF)		+= driver_extif.o
 
- ssb-$(CONFIG_SSB_DRIVER_PCICORE)	+= driver_pcicore.o
 
- ssb-$(CONFIG_SSB_DRIVER_GIGE)		+= driver_gige.o
 
-+ssb-$(CONFIG_SSB_DRIVER_GPIO)		+= driver_gpio.o
 
- 
- # b43 pci-ssb-bridge driver
 
- # Not strictly a part of SSB, but kept here for convenience
 
---- a/drivers/ssb/b43_pci_bridge.c
 
-+++ b/drivers/ssb/b43_pci_bridge.c
 
-@@ -29,11 +29,15 @@ static const struct pci_device_id b43_pc
 
- 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4319) },
 
- 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4320) },
 
- 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4321) },
 
-+	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4322) },
 
-+	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 43222) },
 
- 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4324) },
 
- 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4325) },
 
- 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4328) },
 
- 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4329) },
 
- 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x432b) },
 
-+	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x432c) },
 
-+	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4350) },
 
- 	{ 0, },
 
- };
 
- MODULE_DEVICE_TABLE(pci, b43_pci_bridge_tbl);
 
---- a/drivers/ssb/driver_chipcommon.c
 
-+++ b/drivers/ssb/driver_chipcommon.c
 
-@@ -4,6 +4,7 @@
 
-  *
 
-  * Copyright 2005, Broadcom Corporation
 
-  * Copyright 2006, 2007, Michael Buesch <[email protected]>
 
-+ * Copyright 2012, Hauke Mehrtens <[email protected]>
 
-  *
 
-  * Licensed under the GNU/GPL. See COPYING for details.
 
-  */
 
-@@ -12,6 +13,7 @@
 
- #include <linux/ssb/ssb_regs.h>
 
- #include <linux/export.h>
 
- #include <linux/pci.h>
 
-+#include <linux/bcm47xx_wdt.h>
 
- 
- #include "ssb_private.h"
 
- 
-@@ -280,13 +282,79 @@ static void calc_fast_powerup_delay(stru
 
- 	cc->fast_pwrup_delay = tmp;
 
- }
 
- 
-+static u32 ssb_chipco_alp_clock(struct ssb_chipcommon *cc)
 
-+{
 
-+	if (cc->capabilities & SSB_CHIPCO_CAP_PMU)
 
-+		return ssb_pmu_get_alp_clock(cc);
 
-+
 
-+	return 20000000;
 
-+}
 
-+
 
-+static u32 ssb_chipco_watchdog_get_max_timer(struct ssb_chipcommon *cc)
 
-+{
 
-+	u32 nb;
 
-+
 
-+	if (cc->capabilities & SSB_CHIPCO_CAP_PMU) {
 
-+		if (cc->dev->id.revision < 26)
 
-+			nb = 16;
 
-+		else
 
-+			nb = (cc->dev->id.revision >= 37) ? 32 : 24;
 
-+	} else {
 
-+		nb = 28;
 
-+	}
 
-+	if (nb == 32)
 
-+		return 0xffffffff;
 
-+	else
 
-+		return (1 << nb) - 1;
 
-+}
 
-+
 
-+u32 ssb_chipco_watchdog_timer_set_wdt(struct bcm47xx_wdt *wdt, u32 ticks)
 
-+{
 
-+	struct ssb_chipcommon *cc = bcm47xx_wdt_get_drvdata(wdt);
 
-+
 
-+	if (cc->dev->bus->bustype != SSB_BUSTYPE_SSB)
 
-+		return 0;
 
-+
 
-+	return ssb_chipco_watchdog_timer_set(cc, ticks);
 
-+}
 
-+
 
-+u32 ssb_chipco_watchdog_timer_set_ms(struct bcm47xx_wdt *wdt, u32 ms)
 
-+{
 
-+	struct ssb_chipcommon *cc = bcm47xx_wdt_get_drvdata(wdt);
 
-+	u32 ticks;
 
-+
 
-+	if (cc->dev->bus->bustype != SSB_BUSTYPE_SSB)
 
-+		return 0;
 
-+
 
-+	ticks = ssb_chipco_watchdog_timer_set(cc, cc->ticks_per_ms * ms);
 
-+	return ticks / cc->ticks_per_ms;
 
-+}
 
-+
 
-+static int ssb_chipco_watchdog_ticks_per_ms(struct ssb_chipcommon *cc)
 
-+{
 
-+	struct ssb_bus *bus = cc->dev->bus;
 
-+
 
-+	if (cc->capabilities & SSB_CHIPCO_CAP_PMU) {
 
-+			/* based on 32KHz ILP clock */
 
-+			return 32;
 
-+	} else {
 
-+		if (cc->dev->id.revision < 18)
 
-+			return ssb_clockspeed(bus) / 1000;
 
-+		else
 
-+			return ssb_chipco_alp_clock(cc) / 1000;
 
-+	}
 
-+}
 
-+
 
- void ssb_chipcommon_init(struct ssb_chipcommon *cc)
 
- {
 
- 	if (!cc->dev)
 
- 		return; /* We don't have a ChipCommon */
 
-+
 
-+	spin_lock_init(&cc->gpio_lock);
 
-+
 
- 	if (cc->dev->id.revision >= 11)
 
- 		cc->status = chipco_read32(cc, SSB_CHIPCO_CHIPSTAT);
 
--	ssb_dprintk(KERN_INFO PFX "chipcommon status is 0x%x\n", cc->status);
 
-+	ssb_dbg("chipcommon status is 0x%x\n", cc->status);
 
- 
- 	if (cc->dev->id.revision >= 20) {
 
- 		chipco_write32(cc, SSB_CHIPCO_GPIOPULLUP, 0);
 
-@@ -297,6 +365,11 @@ void ssb_chipcommon_init(struct ssb_chip
 
- 	chipco_powercontrol_init(cc);
 
- 	ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST);
 
- 	calc_fast_powerup_delay(cc);
 
-+
 
-+	if (cc->dev->bus->bustype == SSB_BUSTYPE_SSB) {
 
-+		cc->ticks_per_ms = ssb_chipco_watchdog_ticks_per_ms(cc);
 
-+		cc->max_timer_ms = ssb_chipco_watchdog_get_max_timer(cc) / cc->ticks_per_ms;
 
-+	}
 
- }
 
- 
- void ssb_chipco_suspend(struct ssb_chipcommon *cc)
 
-@@ -395,10 +468,27 @@ void ssb_chipco_timing_init(struct ssb_c
 
- }
 
- 
- /* Set chip watchdog reset timer to fire in 'ticks' backplane cycles */
 
--void ssb_chipco_watchdog_timer_set(struct ssb_chipcommon *cc, u32 ticks)
 
-+u32 ssb_chipco_watchdog_timer_set(struct ssb_chipcommon *cc, u32 ticks)
 
- {
 
--	/* instant NMI */
 
--	chipco_write32(cc, SSB_CHIPCO_WATCHDOG, ticks);
 
-+	u32 maxt;
 
-+	enum ssb_clkmode clkmode;
 
-+
 
-+	maxt = ssb_chipco_watchdog_get_max_timer(cc);
 
-+	if (cc->capabilities & SSB_CHIPCO_CAP_PMU) {
 
-+		if (ticks == 1)
 
-+			ticks = 2;
 
-+		else if (ticks > maxt)
 
-+			ticks = maxt;
 
-+		chipco_write32(cc, SSB_CHIPCO_PMU_WATCHDOG, ticks);
 
-+	} else {
 
-+		clkmode = ticks ? SSB_CLKMODE_FAST : SSB_CLKMODE_DYNAMIC;
 
-+		ssb_chipco_set_clockmode(cc, clkmode);
 
-+		if (ticks > maxt)
 
-+			ticks = maxt;
 
-+		/* instant NMI */
 
-+		chipco_write32(cc, SSB_CHIPCO_WATCHDOG, ticks);
 
-+	}
 
-+	return ticks;
 
- }
 
- 
- void ssb_chipco_irq_mask(struct ssb_chipcommon *cc, u32 mask, u32 value)
 
-@@ -418,28 +508,93 @@ u32 ssb_chipco_gpio_in(struct ssb_chipco
 
- 
- u32 ssb_chipco_gpio_out(struct ssb_chipcommon *cc, u32 mask, u32 value)
 
- {
 
--	return chipco_write32_masked(cc, SSB_CHIPCO_GPIOOUT, mask, value);
 
-+	unsigned long flags;
 
-+	u32 res = 0;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = chipco_write32_masked(cc, SSB_CHIPCO_GPIOOUT, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
- 
- u32 ssb_chipco_gpio_outen(struct ssb_chipcommon *cc, u32 mask, u32 value)
 
- {
 
--	return chipco_write32_masked(cc, SSB_CHIPCO_GPIOOUTEN, mask, value);
 
-+	unsigned long flags;
 
-+	u32 res = 0;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = chipco_write32_masked(cc, SSB_CHIPCO_GPIOOUTEN, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
- 
- u32 ssb_chipco_gpio_control(struct ssb_chipcommon *cc, u32 mask, u32 value)
 
- {
 
--	return chipco_write32_masked(cc, SSB_CHIPCO_GPIOCTL, mask, value);
 
-+	unsigned long flags;
 
-+	u32 res = 0;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = chipco_write32_masked(cc, SSB_CHIPCO_GPIOCTL, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
- EXPORT_SYMBOL(ssb_chipco_gpio_control);
 
- 
- u32 ssb_chipco_gpio_intmask(struct ssb_chipcommon *cc, u32 mask, u32 value)
 
- {
 
--	return chipco_write32_masked(cc, SSB_CHIPCO_GPIOIRQ, mask, value);
 
-+	unsigned long flags;
 
-+	u32 res = 0;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = chipco_write32_masked(cc, SSB_CHIPCO_GPIOIRQ, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
- 
- u32 ssb_chipco_gpio_polarity(struct ssb_chipcommon *cc, u32 mask, u32 value)
 
- {
 
--	return chipco_write32_masked(cc, SSB_CHIPCO_GPIOPOL, mask, value);
 
-+	unsigned long flags;
 
-+	u32 res = 0;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = chipco_write32_masked(cc, SSB_CHIPCO_GPIOPOL, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
-+}
 
-+
 
-+u32 ssb_chipco_gpio_pullup(struct ssb_chipcommon *cc, u32 mask, u32 value)
 
-+{
 
-+	unsigned long flags;
 
-+	u32 res = 0;
 
-+
 
-+	if (cc->dev->id.revision < 20)
 
-+		return 0xffffffff;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = chipco_write32_masked(cc, SSB_CHIPCO_GPIOPULLUP, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
-+}
 
-+
 
-+u32 ssb_chipco_gpio_pulldown(struct ssb_chipcommon *cc, u32 mask, u32 value)
 
-+{
 
-+	unsigned long flags;
 
-+	u32 res = 0;
 
-+
 
-+	if (cc->dev->id.revision < 20)
 
-+		return 0xffffffff;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = chipco_write32_masked(cc, SSB_CHIPCO_GPIOPULLDOWN, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
- 
- #ifdef CONFIG_SSB_SERIAL
 
-@@ -473,12 +628,7 @@ int ssb_chipco_serial_init(struct ssb_ch
 
- 				       chipco_read32(cc, SSB_CHIPCO_CORECTL)
 
- 				       | SSB_CHIPCO_CORECTL_UARTCLK0);
 
- 		} else if ((ccrev >= 11) && (ccrev != 15)) {
 
--			/* Fixed ALP clock */
 
--			baud_base = 20000000;
 
--			if (cc->capabilities & SSB_CHIPCO_CAP_PMU) {
 
--				/* FIXME: baud_base is different for devices with a PMU */
 
--				SSB_WARN_ON(1);
 
--			}
 
-+			baud_base = ssb_chipco_alp_clock(cc);
 
- 			div = 1;
 
- 			if (ccrev >= 21) {
 
- 				/* Turn off UART clock before switching clocksource. */
 
---- a/drivers/ssb/driver_chipcommon_pmu.c
 
-+++ b/drivers/ssb/driver_chipcommon_pmu.c
 
-@@ -13,6 +13,9 @@
 
- #include <linux/ssb/ssb_driver_chipcommon.h>
 
- #include <linux/delay.h>
 
- #include <linux/export.h>
 
-+#ifdef CONFIG_BCM47XX
 
-+#include <asm/mach-bcm47xx/nvram.h>
 
-+#endif
 
- 
- #include "ssb_private.h"
 
- 
-@@ -92,10 +95,6 @@ static void ssb_pmu0_pllinit_r0(struct s
 
- 	u32 pmuctl, tmp, pllctl;
 
- 	unsigned int i;
 
- 
--	if ((bus->chip_id == 0x5354) && !crystalfreq) {
 
--		/* The 5354 crystal freq is 25MHz */
 
--		crystalfreq = 25000;
 
--	}
 
- 	if (crystalfreq)
 
- 		e = pmu0_plltab_find_entry(crystalfreq);
 
- 	if (!e)
 
-@@ -111,8 +110,8 @@ static void ssb_pmu0_pllinit_r0(struct s
 
- 		return;
 
- 	}
 
- 
--	ssb_printk(KERN_INFO PFX "Programming PLL to %u.%03u MHz\n",
 
--		   (crystalfreq / 1000), (crystalfreq % 1000));
 
-+	ssb_info("Programming PLL to %u.%03u MHz\n",
 
-+		 crystalfreq / 1000, crystalfreq % 1000);
 
- 
- 	/* First turn the PLL off. */
 
- 	switch (bus->chip_id) {
 
-@@ -139,7 +138,7 @@ static void ssb_pmu0_pllinit_r0(struct s
 
- 	}
 
- 	tmp = chipco_read32(cc, SSB_CHIPCO_CLKCTLST);
 
- 	if (tmp & SSB_CHIPCO_CLKCTLST_HAVEHT)
 
--		ssb_printk(KERN_EMERG PFX "Failed to turn the PLL off!\n");
 
-+		ssb_emerg("Failed to turn the PLL off!\n");
 
- 
- 	/* Set PDIV in PLL control 0. */
 
- 	pllctl = ssb_chipco_pll_read(cc, SSB_PMU0_PLLCTL0);
 
-@@ -250,8 +249,8 @@ static void ssb_pmu1_pllinit_r0(struct s
 
- 		return;
 
- 	}
 
- 
--	ssb_printk(KERN_INFO PFX "Programming PLL to %u.%03u MHz\n",
 
--		   (crystalfreq / 1000), (crystalfreq % 1000));
 
-+	ssb_info("Programming PLL to %u.%03u MHz\n",
 
-+		 crystalfreq / 1000, crystalfreq % 1000);
 
- 
- 	/* First turn the PLL off. */
 
- 	switch (bus->chip_id) {
 
-@@ -276,7 +275,7 @@ static void ssb_pmu1_pllinit_r0(struct s
 
- 	}
 
- 	tmp = chipco_read32(cc, SSB_CHIPCO_CLKCTLST);
 
- 	if (tmp & SSB_CHIPCO_CLKCTLST_HAVEHT)
 
--		ssb_printk(KERN_EMERG PFX "Failed to turn the PLL off!\n");
 
-+		ssb_emerg("Failed to turn the PLL off!\n");
 
- 
- 	/* Set p1div and p2div. */
 
- 	pllctl = ssb_chipco_pll_read(cc, SSB_PMU1_PLLCTL0);
 
-@@ -321,7 +320,11 @@ static void ssb_pmu_pll_init(struct ssb_
 
- 	u32 crystalfreq = 0; /* in kHz. 0 = keep default freq. */
 
- 
- 	if (bus->bustype == SSB_BUSTYPE_SSB) {
 
--		/* TODO: The user may override the crystal frequency. */
 
-+#ifdef CONFIG_BCM47XX
 
-+		char buf[20];
 
-+		if (nvram_getenv("xtalfreq", buf, sizeof(buf)) >= 0)
 
-+			crystalfreq = simple_strtoul(buf, NULL, 0);
 
-+#endif
 
- 	}
 
- 
- 	switch (bus->chip_id) {
 
-@@ -330,7 +333,11 @@ static void ssb_pmu_pll_init(struct ssb_
 
- 		ssb_pmu1_pllinit_r0(cc, crystalfreq);
 
- 		break;
 
- 	case 0x4328:
 
-+		ssb_pmu0_pllinit_r0(cc, crystalfreq);
 
-+		break;
 
- 	case 0x5354:
 
-+		if (crystalfreq == 0)
 
-+			crystalfreq = 25000;
 
- 		ssb_pmu0_pllinit_r0(cc, crystalfreq);
 
- 		break;
 
- 	case 0x4322:
 
-@@ -339,10 +346,11 @@ static void ssb_pmu_pll_init(struct ssb_
 
- 			chipco_write32(cc, SSB_CHIPCO_PLLCTL_DATA, 0x380005C0);
 
- 		}
 
- 		break;
 
-+	case 43222:
 
-+		break;
 
- 	default:
 
--		ssb_printk(KERN_ERR PFX
 
--			   "ERROR: PLL init unknown for device %04X\n",
 
--			   bus->chip_id);
 
-+		ssb_err("ERROR: PLL init unknown for device %04X\n",
 
-+			bus->chip_id);
 
- 	}
 
- }
 
- 
-@@ -427,6 +435,7 @@ static void ssb_pmu_resources_init(struc
 
- 		 min_msk = 0xCBB;
 
- 		 break;
 
- 	case 0x4322:
 
-+	case 43222:
 
- 		/* We keep the default settings:
 
- 		 * min_msk = 0xCBB
 
- 		 * max_msk = 0x7FFFF
 
-@@ -462,9 +471,8 @@ static void ssb_pmu_resources_init(struc
 
- 		max_msk = 0xFFFFF;
 
- 		break;
 
- 	default:
 
--		ssb_printk(KERN_ERR PFX
 
--			   "ERROR: PMU resource config unknown for device %04X\n",
 
--			   bus->chip_id);
 
-+		ssb_err("ERROR: PMU resource config unknown for device %04X\n",
 
-+			bus->chip_id);
 
- 	}
 
- 
- 	if (updown_tab) {
 
-@@ -516,8 +524,8 @@ void ssb_pmu_init(struct ssb_chipcommon
 
- 	pmucap = chipco_read32(cc, SSB_CHIPCO_PMU_CAP);
 
- 	cc->pmu.rev = (pmucap & SSB_CHIPCO_PMU_CAP_REVISION);
 
- 
--	ssb_dprintk(KERN_DEBUG PFX "Found rev %u PMU (capabilities 0x%08X)\n",
 
--		    cc->pmu.rev, pmucap);
 
-+	ssb_dbg("Found rev %u PMU (capabilities 0x%08X)\n",
 
-+		cc->pmu.rev, pmucap);
 
- 
- 	if (cc->pmu.rev == 1)
 
- 		chipco_mask32(cc, SSB_CHIPCO_PMU_CTL,
 
-@@ -607,3 +615,102 @@ void ssb_pmu_set_ldo_paref(struct ssb_ch
 
- 
- EXPORT_SYMBOL(ssb_pmu_set_ldo_voltage);
 
- EXPORT_SYMBOL(ssb_pmu_set_ldo_paref);
 
-+
 
-+static u32 ssb_pmu_get_alp_clock_clk0(struct ssb_chipcommon *cc)
 
-+{
 
-+	u32 crystalfreq;
 
-+	const struct pmu0_plltab_entry *e = NULL;
 
-+
 
-+	crystalfreq = chipco_read32(cc, SSB_CHIPCO_PMU_CTL) &
 
-+		      SSB_CHIPCO_PMU_CTL_XTALFREQ >> SSB_CHIPCO_PMU_CTL_XTALFREQ_SHIFT;
 
-+	e = pmu0_plltab_find_entry(crystalfreq);
 
-+	BUG_ON(!e);
 
-+	return e->freq * 1000;
 
-+}
 
-+
 
-+u32 ssb_pmu_get_alp_clock(struct ssb_chipcommon *cc)
 
-+{
 
-+	struct ssb_bus *bus = cc->dev->bus;
 
-+
 
-+	switch (bus->chip_id) {
 
-+	case 0x5354:
 
-+		ssb_pmu_get_alp_clock_clk0(cc);
 
-+	default:
 
-+		ssb_err("ERROR: PMU alp clock unknown for device %04X\n",
 
-+			bus->chip_id);
 
-+		return 0;
 
-+	}
 
-+}
 
-+
 
-+u32 ssb_pmu_get_cpu_clock(struct ssb_chipcommon *cc)
 
-+{
 
-+	struct ssb_bus *bus = cc->dev->bus;
 
-+
 
-+	switch (bus->chip_id) {
 
-+	case 0x5354:
 
-+		/* 5354 chip uses a non programmable PLL of frequency 240MHz */
 
-+		return 240000000;
 
-+	default:
 
-+		ssb_err("ERROR: PMU cpu clock unknown for device %04X\n",
 
-+			bus->chip_id);
 
-+		return 0;
 
-+	}
 
-+}
 
-+
 
-+u32 ssb_pmu_get_controlclock(struct ssb_chipcommon *cc)
 
-+{
 
-+	struct ssb_bus *bus = cc->dev->bus;
 
-+
 
-+	switch (bus->chip_id) {
 
-+	case 0x5354:
 
-+		return 120000000;
 
-+	default:
 
-+		ssb_err("ERROR: PMU controlclock unknown for device %04X\n",
 
-+			bus->chip_id);
 
-+		return 0;
 
-+	}
 
-+}
 
-+
 
-+void ssb_pmu_spuravoid_pllupdate(struct ssb_chipcommon *cc, int spuravoid)
 
-+{
 
-+	u32 pmu_ctl = 0;
 
-+
 
-+	switch (cc->dev->bus->chip_id) {
 
-+	case 0x4322:
 
-+		ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL0, 0x11100070);
 
-+		ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL1, 0x1014140a);
 
-+		ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL5, 0x88888854);
 
-+		if (spuravoid == 1)
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL2, 0x05201828);
 
-+		else
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL2, 0x05001828);
 
-+		pmu_ctl = SSB_CHIPCO_PMU_CTL_PLL_UPD;
 
-+		break;
 
-+	case 43222:
 
-+		if (spuravoid == 1) {
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL0, 0x11500008);
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL1, 0x0C000C06);
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL2, 0x0F600a08);
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL3, 0x00000000);
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL4, 0x2001E920);
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL5, 0x88888815);
 
-+		} else {
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL0, 0x11100008);
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL1, 0x0c000c06);
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL2, 0x03000a08);
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL3, 0x00000000);
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL4, 0x200005c0);
 
-+			ssb_chipco_pll_write(cc, SSB_PMU1_PLLCTL5, 0x88888855);
 
-+		}
 
-+		pmu_ctl = SSB_CHIPCO_PMU_CTL_PLL_UPD;
 
-+		break;
 
-+	default:
 
-+		ssb_printk(KERN_ERR PFX
 
-+			   "Unknown spuravoidance settings for chip 0x%04X, not changing PLL\n",
 
-+			   cc->dev->bus->chip_id);
 
-+		return;
 
-+	}
 
-+
 
-+	chipco_set32(cc, SSB_CHIPCO_PMU_CTL, pmu_ctl);
 
-+}
 
-+EXPORT_SYMBOL_GPL(ssb_pmu_spuravoid_pllupdate);
 
---- /dev/null
 
-+++ b/drivers/ssb/driver_chipcommon_sflash.c
 
-@@ -0,0 +1,164 @@
 
-+/*
 
-+ * Sonics Silicon Backplane
 
-+ * ChipCommon serial flash interface
 
-+ *
 
-+ * Licensed under the GNU/GPL. See COPYING for details.
 
-+ */
 
-+
 
-+#include <linux/ssb/ssb.h>
 
-+
 
-+#include "ssb_private.h"
 
-+
 
-+static struct resource ssb_sflash_resource = {
 
-+	.name	= "ssb_sflash",
 
-+	.start	= SSB_FLASH2,
 
-+	.end	= 0,
 
-+	.flags  = IORESOURCE_MEM | IORESOURCE_READONLY,
 
-+};
 
-+
 
-+struct platform_device ssb_sflash_dev = {
 
-+	.name		= "ssb_sflash",
 
-+	.resource	= &ssb_sflash_resource,
 
-+	.num_resources	= 1,
 
-+};
 
-+
 
-+struct ssb_sflash_tbl_e {
 
-+	char *name;
 
-+	u32 id;
 
-+	u32 blocksize;
 
-+	u16 numblocks;
 
-+};
 
-+
 
-+static const struct ssb_sflash_tbl_e ssb_sflash_st_tbl[] = {
 
-+	{ "M25P20", 0x11, 0x10000, 4, },
 
-+	{ "M25P40", 0x12, 0x10000, 8, },
 
-+
 
-+	{ "M25P16", 0x14, 0x10000, 32, },
 
-+	{ "M25P32", 0x15, 0x10000, 64, },
 
-+	{ "M25P64", 0x16, 0x10000, 128, },
 
-+	{ "M25FL128", 0x17, 0x10000, 256, },
 
-+	{ 0 },
 
-+};
 
-+
 
-+static const struct ssb_sflash_tbl_e ssb_sflash_sst_tbl[] = {
 
-+	{ "SST25WF512", 1, 0x1000, 16, },
 
-+	{ "SST25VF512", 0x48, 0x1000, 16, },
 
-+	{ "SST25WF010", 2, 0x1000, 32, },
 
-+	{ "SST25VF010", 0x49, 0x1000, 32, },
 
-+	{ "SST25WF020", 3, 0x1000, 64, },
 
-+	{ "SST25VF020", 0x43, 0x1000, 64, },
 
-+	{ "SST25WF040", 4, 0x1000, 128, },
 
-+	{ "SST25VF040", 0x44, 0x1000, 128, },
 
-+	{ "SST25VF040B", 0x8d, 0x1000, 128, },
 
-+	{ "SST25WF080", 5, 0x1000, 256, },
 
-+	{ "SST25VF080B", 0x8e, 0x1000, 256, },
 
-+	{ "SST25VF016", 0x41, 0x1000, 512, },
 
-+	{ "SST25VF032", 0x4a, 0x1000, 1024, },
 
-+	{ "SST25VF064", 0x4b, 0x1000, 2048, },
 
-+	{ 0 },
 
-+};
 
-+
 
-+static const struct ssb_sflash_tbl_e ssb_sflash_at_tbl[] = {
 
-+	{ "AT45DB011", 0xc, 256, 512, },
 
-+	{ "AT45DB021", 0x14, 256, 1024, },
 
-+	{ "AT45DB041", 0x1c, 256, 2048, },
 
-+	{ "AT45DB081", 0x24, 256, 4096, },
 
-+	{ "AT45DB161", 0x2c, 512, 4096, },
 
-+	{ "AT45DB321", 0x34, 512, 8192, },
 
-+	{ "AT45DB642", 0x3c, 1024, 8192, },
 
-+	{ 0 },
 
-+};
 
-+
 
-+static void ssb_sflash_cmd(struct ssb_chipcommon *cc, u32 opcode)
 
-+{
 
-+	int i;
 
-+	chipco_write32(cc, SSB_CHIPCO_FLASHCTL,
 
-+		       SSB_CHIPCO_FLASHCTL_START | opcode);
 
-+	for (i = 0; i < 1000; i++) {
 
-+		if (!(chipco_read32(cc, SSB_CHIPCO_FLASHCTL) &
 
-+		      SSB_CHIPCO_FLASHCTL_BUSY))
 
-+			return;
 
-+		cpu_relax();
 
-+	}
 
-+	pr_err("SFLASH control command failed (timeout)!\n");
 
-+}
 
-+
 
-+/* Initialize serial flash access */
 
-+int ssb_sflash_init(struct ssb_chipcommon *cc)
 
-+{
 
-+	struct ssb_sflash *sflash = &cc->dev->bus->mipscore.sflash;
 
-+	const struct ssb_sflash_tbl_e *e;
 
-+	u32 id, id2;
 
-+
 
-+	switch (cc->capabilities & SSB_CHIPCO_CAP_FLASHT) {
 
-+	case SSB_CHIPCO_FLASHT_STSER:
 
-+		ssb_sflash_cmd(cc, SSB_CHIPCO_FLASHCTL_ST_DP);
 
-+
 
-+		chipco_write32(cc, SSB_CHIPCO_FLASHADDR, 0);
 
-+		ssb_sflash_cmd(cc, SSB_CHIPCO_FLASHCTL_ST_RES);
 
-+		id = chipco_read32(cc, SSB_CHIPCO_FLASHDATA);
 
-+
 
-+		chipco_write32(cc, SSB_CHIPCO_FLASHADDR, 1);
 
-+		ssb_sflash_cmd(cc, SSB_CHIPCO_FLASHCTL_ST_RES);
 
-+		id2 = chipco_read32(cc, SSB_CHIPCO_FLASHDATA);
 
-+
 
-+		switch (id) {
 
-+		case 0xbf:
 
-+			for (e = ssb_sflash_sst_tbl; e->name; e++) {
 
-+				if (e->id == id2)
 
-+					break;
 
-+			}
 
-+			break;
 
-+		case 0x13:
 
-+			return -ENOTSUPP;
 
-+		default:
 
-+			for (e = ssb_sflash_st_tbl; e->name; e++) {
 
-+				if (e->id == id)
 
-+					break;
 
-+			}
 
-+			break;
 
-+		}
 
-+		if (!e->name) {
 
-+			pr_err("Unsupported ST serial flash (id: 0x%X, id2: 0x%X)\n",
 
-+			       id, id2);
 
-+			return -ENOTSUPP;
 
-+		}
 
-+
 
-+		break;
 
-+	case SSB_CHIPCO_FLASHT_ATSER:
 
-+		ssb_sflash_cmd(cc, SSB_CHIPCO_FLASHCTL_AT_STATUS);
 
-+		id = chipco_read32(cc, SSB_CHIPCO_FLASHDATA) & 0x3c;
 
-+
 
-+		for (e = ssb_sflash_at_tbl; e->name; e++) {
 
-+			if (e->id == id)
 
-+				break;
 
-+		}
 
-+		if (!e->name) {
 
-+			pr_err("Unsupported Atmel serial flash (id: 0x%X)\n",
 
-+			       id);
 
-+			return -ENOTSUPP;
 
-+		}
 
-+
 
-+		break;
 
-+	default:
 
-+		pr_err("Unsupported flash type\n");
 
-+		return -ENOTSUPP;
 
-+	}
 
-+
 
-+	sflash->window = SSB_FLASH2;
 
-+	sflash->blocksize = e->blocksize;
 
-+	sflash->numblocks = e->numblocks;
 
-+	sflash->size = sflash->blocksize * sflash->numblocks;
 
-+	sflash->present = true;
 
-+
 
-+	pr_info("Found %s serial flash (size: %dKiB, blocksize: 0x%X, blocks: %d)\n",
 
-+		e->name, sflash->size / 1024, e->blocksize, e->numblocks);
 
-+
 
-+	/* Prepare platform device, but don't register it yet. It's too early,
 
-+	 * malloc (required by device_private_init) is not available yet. */
 
-+	ssb_sflash_dev.resource[0].end = ssb_sflash_dev.resource[0].start +
 
-+					 sflash->size;
 
-+	ssb_sflash_dev.dev.platform_data = sflash;
 
-+
 
-+	return 0;
 
-+}
 
---- a/drivers/ssb/driver_extif.c
 
-+++ b/drivers/ssb/driver_extif.c
 
-@@ -112,10 +112,37 @@ void ssb_extif_get_clockcontrol(struct s
 
- 	*m = extif_read32(extif, SSB_EXTIF_CLOCK_SB);
 
- }
 
- 
--void ssb_extif_watchdog_timer_set(struct ssb_extif *extif,
 
--				  u32 ticks)
 
-+u32 ssb_extif_watchdog_timer_set_wdt(struct bcm47xx_wdt *wdt, u32 ticks)
 
- {
 
-+	struct ssb_extif *extif = bcm47xx_wdt_get_drvdata(wdt);
 
-+
 
-+	return ssb_extif_watchdog_timer_set(extif, ticks);
 
-+}
 
-+
 
-+u32 ssb_extif_watchdog_timer_set_ms(struct bcm47xx_wdt *wdt, u32 ms)
 
-+{
 
-+	struct ssb_extif *extif = bcm47xx_wdt_get_drvdata(wdt);
 
-+	u32 ticks = (SSB_EXTIF_WATCHDOG_CLK / 1000) * ms;
 
-+
 
-+	ticks = ssb_extif_watchdog_timer_set(extif, ticks);
 
-+
 
-+	return (ticks * 1000) / SSB_EXTIF_WATCHDOG_CLK;
 
-+}
 
-+
 
-+u32 ssb_extif_watchdog_timer_set(struct ssb_extif *extif, u32 ticks)
 
-+{
 
-+	if (ticks > SSB_EXTIF_WATCHDOG_MAX_TIMER)
 
-+		ticks = SSB_EXTIF_WATCHDOG_MAX_TIMER;
 
- 	extif_write32(extif, SSB_EXTIF_WATCHDOG, ticks);
 
-+
 
-+	return ticks;
 
-+}
 
-+
 
-+void ssb_extif_init(struct ssb_extif *extif)
 
-+{
 
-+	if (!extif->dev)
 
-+		return; /* We don't have a Extif core */
 
-+	spin_lock_init(&extif->gpio_lock);
 
- }
 
- 
- u32 ssb_extif_gpio_in(struct ssb_extif *extif, u32 mask)
 
-@@ -125,22 +152,50 @@ u32 ssb_extif_gpio_in(struct ssb_extif *
 
- 
- u32 ssb_extif_gpio_out(struct ssb_extif *extif, u32 mask, u32 value)
 
- {
 
--	return extif_write32_masked(extif, SSB_EXTIF_GPIO_OUT(0),
 
-+	unsigned long flags;
 
-+	u32 res = 0;
 
-+
 
-+	spin_lock_irqsave(&extif->gpio_lock, flags);
 
-+	res = extif_write32_masked(extif, SSB_EXTIF_GPIO_OUT(0),
 
- 				   mask, value);
 
-+	spin_unlock_irqrestore(&extif->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
- 
- u32 ssb_extif_gpio_outen(struct ssb_extif *extif, u32 mask, u32 value)
 
- {
 
--	return extif_write32_masked(extif, SSB_EXTIF_GPIO_OUTEN(0),
 
-+	unsigned long flags;
 
-+	u32 res = 0;
 
-+
 
-+	spin_lock_irqsave(&extif->gpio_lock, flags);
 
-+	res = extif_write32_masked(extif, SSB_EXTIF_GPIO_OUTEN(0),
 
- 				   mask, value);
 
-+	spin_unlock_irqrestore(&extif->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
- 
- u32 ssb_extif_gpio_polarity(struct ssb_extif *extif, u32 mask, u32 value)
 
- {
 
--	return extif_write32_masked(extif, SSB_EXTIF_GPIO_INTPOL, mask, value);
 
-+	unsigned long flags;
 
-+	u32 res = 0;
 
-+
 
-+	spin_lock_irqsave(&extif->gpio_lock, flags);
 
-+	res = extif_write32_masked(extif, SSB_EXTIF_GPIO_INTPOL, mask, value);
 
-+	spin_unlock_irqrestore(&extif->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
- 
- u32 ssb_extif_gpio_intmask(struct ssb_extif *extif, u32 mask, u32 value)
 
- {
 
--	return extif_write32_masked(extif, SSB_EXTIF_GPIO_INTMASK, mask, value);
 
-+	unsigned long flags;
 
-+	u32 res = 0;
 
-+
 
-+	spin_lock_irqsave(&extif->gpio_lock, flags);
 
-+	res = extif_write32_masked(extif, SSB_EXTIF_GPIO_INTMASK, mask, value);
 
-+	spin_unlock_irqrestore(&extif->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
---- /dev/null
 
-+++ b/drivers/ssb/driver_gpio.c
 
-@@ -0,0 +1,210 @@
 
-+/*
 
-+ * Sonics Silicon Backplane
 
-+ * GPIO driver
 
-+ *
 
-+ * Copyright 2011, Broadcom Corporation
 
-+ * Copyright 2012, Hauke Mehrtens <[email protected]>
 
-+ *
 
-+ * Licensed under the GNU/GPL. See COPYING for details.
 
-+ */
 
-+
 
-+#include <linux/gpio.h>
 
-+#include <linux/export.h>
 
-+#include <linux/ssb/ssb.h>
 
-+
 
-+#include "ssb_private.h"
 
-+
 
-+static struct ssb_bus *ssb_gpio_get_bus(struct gpio_chip *chip)
 
-+{
 
-+	return container_of(chip, struct ssb_bus, gpio);
 
-+}
 
-+
 
-+static int ssb_gpio_chipco_get_value(struct gpio_chip *chip, unsigned gpio)
 
-+{
 
-+	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 
-+
 
-+	return !!ssb_chipco_gpio_in(&bus->chipco, 1 << gpio);
 
-+}
 
-+
 
-+static void ssb_gpio_chipco_set_value(struct gpio_chip *chip, unsigned gpio,
 
-+				      int value)
 
-+{
 
-+	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 
-+
 
-+	ssb_chipco_gpio_out(&bus->chipco, 1 << gpio, value ? 1 << gpio : 0);
 
-+}
 
-+
 
-+static int ssb_gpio_chipco_direction_input(struct gpio_chip *chip,
 
-+					   unsigned gpio)
 
-+{
 
-+	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 
-+
 
-+	ssb_chipco_gpio_outen(&bus->chipco, 1 << gpio, 0);
 
-+	return 0;
 
-+}
 
-+
 
-+static int ssb_gpio_chipco_direction_output(struct gpio_chip *chip,
 
-+					    unsigned gpio, int value)
 
-+{
 
-+	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 
-+
 
-+	ssb_chipco_gpio_outen(&bus->chipco, 1 << gpio, 1 << gpio);
 
-+	ssb_chipco_gpio_out(&bus->chipco, 1 << gpio, value ? 1 << gpio : 0);
 
-+	return 0;
 
-+}
 
-+
 
-+static int ssb_gpio_chipco_request(struct gpio_chip *chip, unsigned gpio)
 
-+{
 
-+	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 
-+
 
-+	ssb_chipco_gpio_control(&bus->chipco, 1 << gpio, 0);
 
-+	/* clear pulldown */
 
-+	ssb_chipco_gpio_pulldown(&bus->chipco, 1 << gpio, 0);
 
-+	/* Set pullup */
 
-+	ssb_chipco_gpio_pullup(&bus->chipco, 1 << gpio, 1 << gpio);
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static void ssb_gpio_chipco_free(struct gpio_chip *chip, unsigned gpio)
 
-+{
 
-+	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 
-+
 
-+	/* clear pullup */
 
-+	ssb_chipco_gpio_pullup(&bus->chipco, 1 << gpio, 0);
 
-+}
 
-+
 
-+static int ssb_gpio_chipco_to_irq(struct gpio_chip *chip, unsigned gpio)
 
-+{
 
-+	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 
-+
 
-+	if (bus->bustype == SSB_BUSTYPE_SSB)
 
-+		return ssb_mips_irq(bus->chipco.dev) + 2;
 
-+	else
 
-+		return -EINVAL;
 
-+}
 
-+
 
-+static int ssb_gpio_chipco_init(struct ssb_bus *bus)
 
-+{
 
-+	struct gpio_chip *chip = &bus->gpio;
 
-+
 
-+	chip->label		= "ssb_chipco_gpio";
 
-+	chip->owner		= THIS_MODULE;
 
-+	chip->request		= ssb_gpio_chipco_request;
 
-+	chip->free		= ssb_gpio_chipco_free;
 
-+	chip->get		= ssb_gpio_chipco_get_value;
 
-+	chip->set		= ssb_gpio_chipco_set_value;
 
-+	chip->direction_input	= ssb_gpio_chipco_direction_input;
 
-+	chip->direction_output	= ssb_gpio_chipco_direction_output;
 
-+	chip->to_irq		= ssb_gpio_chipco_to_irq;
 
-+	chip->ngpio		= 16;
 
-+	/* There is just one SoC in one device and its GPIO addresses should be
 
-+	 * deterministic to address them more easily. The other buses could get
 
-+	 * a random base number. */
 
-+	if (bus->bustype == SSB_BUSTYPE_SSB)
 
-+		chip->base		= 0;
 
-+	else
 
-+		chip->base		= -1;
 
-+
 
-+	return gpiochip_add(chip);
 
-+}
 
-+
 
-+#ifdef CONFIG_SSB_DRIVER_EXTIF
 
-+
 
-+static int ssb_gpio_extif_get_value(struct gpio_chip *chip, unsigned gpio)
 
-+{
 
-+	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 
-+
 
-+	return !!ssb_extif_gpio_in(&bus->extif, 1 << gpio);
 
-+}
 
-+
 
-+static void ssb_gpio_extif_set_value(struct gpio_chip *chip, unsigned gpio,
 
-+				     int value)
 
-+{
 
-+	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 
-+
 
-+	ssb_extif_gpio_out(&bus->extif, 1 << gpio, value ? 1 << gpio : 0);
 
-+}
 
-+
 
-+static int ssb_gpio_extif_direction_input(struct gpio_chip *chip,
 
-+					  unsigned gpio)
 
-+{
 
-+	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 
-+
 
-+	ssb_extif_gpio_outen(&bus->extif, 1 << gpio, 0);
 
-+	return 0;
 
-+}
 
-+
 
-+static int ssb_gpio_extif_direction_output(struct gpio_chip *chip,
 
-+					   unsigned gpio, int value)
 
-+{
 
-+	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 
-+
 
-+	ssb_extif_gpio_outen(&bus->extif, 1 << gpio, 1 << gpio);
 
-+	ssb_extif_gpio_out(&bus->extif, 1 << gpio, value ? 1 << gpio : 0);
 
-+	return 0;
 
-+}
 
-+
 
-+static int ssb_gpio_extif_to_irq(struct gpio_chip *chip, unsigned gpio)
 
-+{
 
-+	struct ssb_bus *bus = ssb_gpio_get_bus(chip);
 
-+
 
-+	if (bus->bustype == SSB_BUSTYPE_SSB)
 
-+		return ssb_mips_irq(bus->extif.dev) + 2;
 
-+	else
 
-+		return -EINVAL;
 
-+}
 
-+
 
-+static int ssb_gpio_extif_init(struct ssb_bus *bus)
 
-+{
 
-+	struct gpio_chip *chip = &bus->gpio;
 
-+
 
-+	chip->label		= "ssb_extif_gpio";
 
-+	chip->owner		= THIS_MODULE;
 
-+	chip->get		= ssb_gpio_extif_get_value;
 
-+	chip->set		= ssb_gpio_extif_set_value;
 
-+	chip->direction_input	= ssb_gpio_extif_direction_input;
 
-+	chip->direction_output	= ssb_gpio_extif_direction_output;
 
-+	chip->to_irq		= ssb_gpio_extif_to_irq;
 
-+	chip->ngpio		= 5;
 
-+	/* There is just one SoC in one device and its GPIO addresses should be
 
-+	 * deterministic to address them more easily. The other buses could get
 
-+	 * a random base number. */
 
-+	if (bus->bustype == SSB_BUSTYPE_SSB)
 
-+		chip->base		= 0;
 
-+	else
 
-+		chip->base		= -1;
 
-+
 
-+	return gpiochip_add(chip);
 
-+}
 
-+
 
-+#else
 
-+static int ssb_gpio_extif_init(struct ssb_bus *bus)
 
-+{
 
-+	return -ENOTSUPP;
 
-+}
 
-+#endif
 
-+
 
-+int ssb_gpio_init(struct ssb_bus *bus)
 
-+{
 
-+	if (ssb_chipco_available(&bus->chipco))
 
-+		return ssb_gpio_chipco_init(bus);
 
-+	else if (ssb_extif_available(&bus->extif))
 
-+		return ssb_gpio_extif_init(bus);
 
-+	else
 
-+		SSB_WARN_ON(1);
 
-+
 
-+	return -1;
 
-+}
 
-+
 
-+int ssb_gpio_unregister(struct ssb_bus *bus)
 
-+{
 
-+	if (ssb_chipco_available(&bus->chipco) ||
 
-+	    ssb_extif_available(&bus->extif)) {
 
-+		return gpiochip_remove(&bus->gpio);
 
-+	} else {
 
-+		SSB_WARN_ON(1);
 
-+	}
 
-+
 
-+	return -1;
 
-+}
 
---- a/drivers/ssb/driver_mipscore.c
 
-+++ b/drivers/ssb/driver_mipscore.c
 
-@@ -10,6 +10,7 @@
 
- 
- #include <linux/ssb/ssb.h>
 
- 
-+#include <linux/mtd/physmap.h>
 
- #include <linux/serial.h>
 
- #include <linux/serial_core.h>
 
- #include <linux/serial_reg.h>
 
-@@ -17,6 +18,25 @@
 
- 
- #include "ssb_private.h"
 
- 
-+static const char * const part_probes[] = { "bcm47xxpart", NULL };
 
-+
 
-+static struct physmap_flash_data ssb_pflash_data = {
 
-+	.part_probe_types	= part_probes,
 
-+};
 
-+
 
-+static struct resource ssb_pflash_resource = {
 
-+	.name	= "ssb_pflash",
 
-+	.flags  = IORESOURCE_MEM,
 
-+};
 
-+
 
-+struct platform_device ssb_pflash_dev = {
 
-+	.name		= "physmap-flash",
 
-+	.dev		= {
 
-+		.platform_data  = &ssb_pflash_data,
 
-+	},
 
-+	.resource	= &ssb_pflash_resource,
 
-+	.num_resources	= 1,
 
-+};
 
- 
- static inline u32 mips_read32(struct ssb_mipscore *mcore,
 
- 			      u16 offset)
 
-@@ -147,21 +167,22 @@ static void set_irq(struct ssb_device *d
 
- 		irqflag |= (ipsflag & ~ipsflag_irq_mask[irq]);
 
- 		ssb_write32(mdev, SSB_IPSFLAG, irqflag);
 
- 	}
 
--	ssb_dprintk(KERN_INFO PFX
 
--		    "set_irq: core 0x%04x, irq %d => %d\n",
 
--		    dev->id.coreid, oldirq+2, irq+2);
 
-+	ssb_dbg("set_irq: core 0x%04x, irq %d => %d\n",
 
-+		dev->id.coreid, oldirq+2, irq+2);
 
- }
 
- 
- static void print_irq(struct ssb_device *dev, unsigned int irq)
 
- {
 
--	int i;
 
- 	static const char *irq_name[] = {"2(S)", "3", "4", "5", "6", "D", "I"};
 
--	ssb_dprintk(KERN_INFO PFX
 
--		"core 0x%04x, irq :", dev->id.coreid);
 
--	for (i = 0; i <= 6; i++) {
 
--		ssb_dprintk(" %s%s", irq_name[i], i==irq?"*":" ");
 
--	}
 
--	ssb_dprintk("\n");
 
-+	ssb_dbg("core 0x%04x, irq : %s%s %s%s %s%s %s%s %s%s %s%s %s%s\n",
 
-+		dev->id.coreid,
 
-+		irq_name[0], irq == 0 ? "*" : " ",
 
-+		irq_name[1], irq == 1 ? "*" : " ",
 
-+		irq_name[2], irq == 2 ? "*" : " ",
 
-+		irq_name[3], irq == 3 ? "*" : " ",
 
-+		irq_name[4], irq == 4 ? "*" : " ",
 
-+		irq_name[5], irq == 5 ? "*" : " ",
 
-+		irq_name[6], irq == 6 ? "*" : " ");
 
- }
 
- 
- static void dump_irq(struct ssb_bus *bus)
 
-@@ -178,9 +199,9 @@ static void ssb_mips_serial_init(struct
 
- {
 
- 	struct ssb_bus *bus = mcore->dev->bus;
 
- 
--	if (bus->extif.dev)
 
-+	if (ssb_extif_available(&bus->extif))
 
- 		mcore->nr_serial_ports = ssb_extif_serial_init(&bus->extif, mcore->serial_ports);
 
--	else if (bus->chipco.dev)
 
-+	else if (ssb_chipco_available(&bus->chipco))
 
- 		mcore->nr_serial_ports = ssb_chipco_serial_init(&bus->chipco, mcore->serial_ports);
 
- 	else
 
- 		mcore->nr_serial_ports = 0;
 
-@@ -189,17 +210,42 @@ static void ssb_mips_serial_init(struct
 
- static void ssb_mips_flash_detect(struct ssb_mipscore *mcore)
 
- {
 
- 	struct ssb_bus *bus = mcore->dev->bus;
 
-+	struct ssb_pflash *pflash = &mcore->pflash;
 
- 
--	mcore->flash_buswidth = 2;
 
--	if (bus->chipco.dev) {
 
--		mcore->flash_window = 0x1c000000;
 
--		mcore->flash_window_size = 0x02000000;
 
-+	/* When there is no chipcommon on the bus there is 4MB flash */
 
-+	if (!ssb_chipco_available(&bus->chipco)) {
 
-+		pflash->present = true;
 
-+		pflash->buswidth = 2;
 
-+		pflash->window = SSB_FLASH1;
 
-+		pflash->window_size = SSB_FLASH1_SZ;
 
-+		goto ssb_pflash;
 
-+	}
 
-+
 
-+	/* There is ChipCommon, so use it to read info about flash */
 
-+	switch (bus->chipco.capabilities & SSB_CHIPCO_CAP_FLASHT) {
 
-+	case SSB_CHIPCO_FLASHT_STSER:
 
-+	case SSB_CHIPCO_FLASHT_ATSER:
 
-+		pr_debug("Found serial flash\n");
 
-+		ssb_sflash_init(&bus->chipco);
 
-+		break;
 
-+	case SSB_CHIPCO_FLASHT_PARA:
 
-+		pr_debug("Found parallel flash\n");
 
-+		pflash->present = true;
 
-+		pflash->window = SSB_FLASH2;
 
-+		pflash->window_size = SSB_FLASH2_SZ;
 
- 		if ((ssb_read32(bus->chipco.dev, SSB_CHIPCO_FLASH_CFG)
 
- 		               & SSB_CHIPCO_CFG_DS16) == 0)
 
--			mcore->flash_buswidth = 1;
 
--	} else {
 
--		mcore->flash_window = 0x1fc00000;
 
--		mcore->flash_window_size = 0x00400000;
 
-+			pflash->buswidth = 1;
 
-+		else
 
-+			pflash->buswidth = 2;
 
-+		break;
 
-+	}
 
-+
 
-+ssb_pflash:
 
-+	if (pflash->present) {
 
-+		ssb_pflash_data.width = pflash->buswidth;
 
-+		ssb_pflash_resource.start = pflash->window;
 
-+		ssb_pflash_resource.end = pflash->window + pflash->window_size;
 
- 	}
 
- }
 
- 
-@@ -208,9 +254,12 @@ u32 ssb_cpu_clock(struct ssb_mipscore *m
 
- 	struct ssb_bus *bus = mcore->dev->bus;
 
- 	u32 pll_type, n, m, rate = 0;
 
- 
--	if (bus->extif.dev) {
 
-+	if (bus->chipco.capabilities & SSB_CHIPCO_CAP_PMU)
 
-+		return ssb_pmu_get_cpu_clock(&bus->chipco);
 
-+
 
-+	if (ssb_extif_available(&bus->extif)) {
 
- 		ssb_extif_get_clockcontrol(&bus->extif, &pll_type, &n, &m);
 
--	} else if (bus->chipco.dev) {
 
-+	} else if (ssb_chipco_available(&bus->chipco)) {
 
- 		ssb_chipco_get_clockcpu(&bus->chipco, &pll_type, &n, &m);
 
- 	} else
 
- 		return 0;
 
-@@ -238,7 +287,7 @@ void ssb_mipscore_init(struct ssb_mipsco
 
- 	if (!mcore->dev)
 
- 		return; /* We don't have a MIPS core */
 
- 
--	ssb_dprintk(KERN_INFO PFX "Initializing MIPS core...\n");
 
-+	ssb_dbg("Initializing MIPS core...\n");
 
- 
- 	bus = mcore->dev->bus;
 
- 	hz = ssb_clockspeed(bus);
 
-@@ -246,9 +295,9 @@ void ssb_mipscore_init(struct ssb_mipsco
 
- 		hz = 100000000;
 
- 	ns = 1000000000 / hz;
 
- 
--	if (bus->extif.dev)
 
-+	if (ssb_extif_available(&bus->extif))
 
- 		ssb_extif_timing_init(&bus->extif, ns);
 
--	else if (bus->chipco.dev)
 
-+	else if (ssb_chipco_available(&bus->chipco))
 
- 		ssb_chipco_timing_init(&bus->chipco, ns);
 
- 
- 	/* Assign IRQs to all cores on the bus, start with irq line 2, because serial usually takes 1 */
 
-@@ -286,7 +335,7 @@ void ssb_mipscore_init(struct ssb_mipsco
 
- 			break;
 
- 		}
 
- 	}
 
--	ssb_dprintk(KERN_INFO PFX "after irq reconfiguration\n");
 
-+	ssb_dbg("after irq reconfiguration\n");
 
- 	dump_irq(bus);
 
- 
- 	ssb_mips_serial_init(mcore);
 
---- a/drivers/ssb/driver_pcicore.c
 
-+++ b/drivers/ssb/driver_pcicore.c
 
-@@ -263,8 +263,7 @@ int ssb_pcicore_plat_dev_init(struct pci
 
- 		return -ENODEV;
 
- 	}
 
- 
--	ssb_printk(KERN_INFO "PCI: Fixing up device %s\n",
 
--		   pci_name(d));
 
-+	ssb_info("PCI: Fixing up device %s\n", pci_name(d));
 
- 
- 	/* Fix up interrupt lines */
 
- 	d->irq = ssb_mips_irq(extpci_core->dev) + 2;
 
-@@ -285,12 +284,12 @@ static void ssb_pcicore_fixup_pcibridge(
 
- 	if (dev->bus->number != 0 || PCI_SLOT(dev->devfn) != 0)
 
- 		return;
 
- 
--	ssb_printk(KERN_INFO "PCI: Fixing up bridge %s\n", pci_name(dev));
 
-+	ssb_info("PCI: Fixing up bridge %s\n", pci_name(dev));
 
- 
- 	/* Enable PCI bridge bus mastering and memory space */
 
- 	pci_set_master(dev);
 
- 	if (pcibios_enable_device(dev, ~0) < 0) {
 
--		ssb_printk(KERN_ERR "PCI: SSB bridge enable failed\n");
 
-+		ssb_err("PCI: SSB bridge enable failed\n");
 
- 		return;
 
- 	}
 
- 
-@@ -299,8 +298,8 @@ static void ssb_pcicore_fixup_pcibridge(
 
- 
- 	/* Make sure our latency is high enough to handle the devices behind us */
 
- 	lat = 168;
 
--	ssb_printk(KERN_INFO "PCI: Fixing latency timer of device %s to %u\n",
 
--		   pci_name(dev), lat);
 
-+	ssb_info("PCI: Fixing latency timer of device %s to %u\n",
 
-+		 pci_name(dev), lat);
 
- 	pci_write_config_byte(dev, PCI_LATENCY_TIMER, lat);
 
- }
 
- DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID, PCI_ANY_ID, ssb_pcicore_fixup_pcibridge);
 
-@@ -323,7 +322,7 @@ static void __devinit ssb_pcicore_init_h
 
- 		return;
 
- 	extpci_core = pc;
 
- 
--	ssb_dprintk(KERN_INFO PFX "PCIcore in host mode found\n");
 
-+	ssb_dbg("PCIcore in host mode found\n");
 
- 	/* Reset devices on the external PCI bus */
 
- 	val = SSB_PCICORE_CTL_RST_OE;
 
- 	val |= SSB_PCICORE_CTL_CLK_OE;
 
-@@ -338,7 +337,7 @@ static void __devinit ssb_pcicore_init_h
 
- 	udelay(1); /* Assertion time demanded by the PCI standard */
 
- 
- 	if (pc->dev->bus->has_cardbus_slot) {
 
--		ssb_dprintk(KERN_INFO PFX "CardBus slot detected\n");
 
-+		ssb_dbg("CardBus slot detected\n");
 
- 		pc->cardbusmode = 1;
 
- 		/* GPIO 1 resets the bridge */
 
- 		ssb_gpio_out(pc->dev->bus, 1, 1);
 
---- a/drivers/ssb/embedded.c
 
-+++ b/drivers/ssb/embedded.c
 
-@@ -4,11 +4,13 @@
 
-  *
 
-  * Copyright 2005-2008, Broadcom Corporation
 
-  * Copyright 2006-2008, Michael Buesch <[email protected]>
 
-+ * Copyright 2012, Hauke Mehrtens <[email protected]>
 
-  *
 
-  * Licensed under the GNU/GPL. See COPYING for details.
 
-  */
 
- 
- #include <linux/export.h>
 
-+#include <linux/platform_device.h>
 
- #include <linux/ssb/ssb.h>
 
- #include <linux/ssb/ssb_embedded.h>
 
- #include <linux/ssb/ssb_driver_pci.h>
 
-@@ -32,6 +34,38 @@ int ssb_watchdog_timer_set(struct ssb_bu
 
- }
 
- EXPORT_SYMBOL(ssb_watchdog_timer_set);
 
- 
-+int ssb_watchdog_register(struct ssb_bus *bus)
 
-+{
 
-+	struct bcm47xx_wdt wdt = {};
 
-+	struct platform_device *pdev;
 
-+
 
-+	if (ssb_chipco_available(&bus->chipco)) {
 
-+		wdt.driver_data = &bus->chipco;
 
-+		wdt.timer_set = ssb_chipco_watchdog_timer_set_wdt;
 
-+		wdt.timer_set_ms = ssb_chipco_watchdog_timer_set_ms;
 
-+		wdt.max_timer_ms = bus->chipco.max_timer_ms;
 
-+	} else if (ssb_extif_available(&bus->extif)) {
 
-+		wdt.driver_data = &bus->extif;
 
-+		wdt.timer_set = ssb_extif_watchdog_timer_set_wdt;
 
-+		wdt.timer_set_ms = ssb_extif_watchdog_timer_set_ms;
 
-+		wdt.max_timer_ms = SSB_EXTIF_WATCHDOG_MAX_TIMER_MS;
 
-+	} else {
 
-+		return -ENODEV;
 
-+	}
 
-+
 
-+	pdev = platform_device_register_data(NULL, "bcm47xx-wdt",
 
-+					     bus->busnumber, &wdt,
 
-+					     sizeof(wdt));
 
-+	if (IS_ERR(pdev)) {
 
-+		ssb_dbg("can not register watchdog device, err: %li\n",
 
-+			PTR_ERR(pdev));
 
-+		return PTR_ERR(pdev);
 
-+	}
 
-+
 
-+	bus->watchdog = pdev;
 
-+	return 0;
 
-+}
 
-+
 
- u32 ssb_gpio_in(struct ssb_bus *bus, u32 mask)
 
- {
 
- 	unsigned long flags;
 
---- a/drivers/ssb/main.c
 
-+++ b/drivers/ssb/main.c
 
-@@ -13,6 +13,7 @@
 
- #include <linux/delay.h>
 
- #include <linux/io.h>
 
- #include <linux/module.h>
 
-+#include <linux/platform_device.h>
 
- #include <linux/ssb/ssb.h>
 
- #include <linux/ssb/ssb_regs.h>
 
- #include <linux/ssb/ssb_driver_gige.h>
 
-@@ -289,8 +290,8 @@ int ssb_devices_thaw(struct ssb_freeze_c
 
- 
- 		err = sdrv->probe(sdev, &sdev->id);
 
- 		if (err) {
 
--			ssb_printk(KERN_ERR PFX "Failed to thaw device %s\n",
 
--				   dev_name(sdev->dev));
 
-+			ssb_err("Failed to thaw device %s\n",
 
-+				dev_name(sdev->dev));
 
- 			result = err;
 
- 		}
 
- 		ssb_driver_put(sdrv);
 
-@@ -449,10 +450,23 @@ static void ssb_devices_unregister(struc
 
- 		if (sdev->dev)
 
- 			device_unregister(sdev->dev);
 
- 	}
 
-+
 
-+#ifdef CONFIG_SSB_EMBEDDED
 
-+	if (bus->bustype == SSB_BUSTYPE_SSB)
 
-+		platform_device_unregister(bus->watchdog);
 
-+#endif
 
- }
 
- 
- void ssb_bus_unregister(struct ssb_bus *bus)
 
- {
 
-+	int err;
 
-+
 
-+	err = ssb_gpio_unregister(bus);
 
-+	if (err == -EBUSY)
 
-+		ssb_dbg("Some GPIOs are still in use\n");
 
-+	else if (err)
 
-+		ssb_dbg("Can not unregister GPIO driver: %i\n", err);
 
-+
 
- 	ssb_buses_lock();
 
- 	ssb_devices_unregister(bus);
 
- 	list_del(&bus->list);
 
-@@ -498,8 +512,7 @@ static int ssb_devices_register(struct s
 
- 
- 		devwrap = kzalloc(sizeof(*devwrap), GFP_KERNEL);
 
- 		if (!devwrap) {
 
--			ssb_printk(KERN_ERR PFX
 
--				   "Could not allocate device\n");
 
-+			ssb_err("Could not allocate device\n");
 
- 			err = -ENOMEM;
 
- 			goto error;
 
- 		}
 
-@@ -538,9 +551,7 @@ static int ssb_devices_register(struct s
 
- 		sdev->dev = dev;
 
- 		err = device_register(dev);
 
- 		if (err) {
 
--			ssb_printk(KERN_ERR PFX
 
--				   "Could not register %s\n",
 
--				   dev_name(dev));
 
-+			ssb_err("Could not register %s\n", dev_name(dev));
 
- 			/* Set dev to NULL to not unregister
 
- 			 * dev on error unwinding. */
 
- 			sdev->dev = NULL;
 
-@@ -550,6 +561,22 @@ static int ssb_devices_register(struct s
 
- 		dev_idx++;
 
- 	}
 
- 
-+#ifdef CONFIG_SSB_DRIVER_MIPS
 
-+	if (bus->mipscore.pflash.present) {
 
-+		err = platform_device_register(&ssb_pflash_dev);
 
-+		if (err)
 
-+			pr_err("Error registering parallel flash\n");
 
-+	}
 
-+#endif
 
-+
 
-+#ifdef CONFIG_SSB_SFLASH
 
-+	if (bus->mipscore.sflash.present) {
 
-+		err = platform_device_register(&ssb_sflash_dev);
 
-+		if (err)
 
-+			pr_err("Error registering serial flash\n");
 
-+	}
 
-+#endif
 
-+
 
- 	return 0;
 
- error:
 
- 	/* Unwind the already registered devices. */
 
-@@ -577,6 +604,8 @@ static int __devinit ssb_attach_queued_b
 
- 		if (err)
 
- 			goto error;
 
- 		ssb_pcicore_init(&bus->pcicore);
 
-+		if (bus->bustype == SSB_BUSTYPE_SSB)
 
-+			ssb_watchdog_register(bus);
 
- 		ssb_bus_may_powerdown(bus);
 
- 
- 		err = ssb_devices_register(bus);
 
-@@ -812,7 +841,13 @@ static int __devinit ssb_bus_register(st
 
- 	if (err)
 
- 		goto err_pcmcia_exit;
 
- 	ssb_chipcommon_init(&bus->chipco);
 
-+	ssb_extif_init(&bus->extif);
 
- 	ssb_mipscore_init(&bus->mipscore);
 
-+	err = ssb_gpio_init(bus);
 
-+	if (err == -ENOTSUPP)
 
-+		ssb_dbg("GPIO driver not activated\n");
 
-+	else if (err)
 
-+		ssb_dbg("Error registering GPIO driver: %i\n", err);
 
- 	err = ssb_fetch_invariants(bus, get_invariants);
 
- 	if (err) {
 
- 		ssb_bus_may_powerdown(bus);
 
-@@ -863,11 +898,11 @@ int __devinit ssb_bus_pcibus_register(st
 
- 
- 	err = ssb_bus_register(bus, ssb_pci_get_invariants, 0);
 
- 	if (!err) {
 
--		ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on "
 
--			   "PCI device %s\n", dev_name(&host_pci->dev));
 
-+		ssb_info("Sonics Silicon Backplane found on PCI device %s\n",
 
-+			 dev_name(&host_pci->dev));
 
- 	} else {
 
--		ssb_printk(KERN_ERR PFX "Failed to register PCI version"
 
--			   " of SSB with error %d\n", err);
 
-+		ssb_err("Failed to register PCI version of SSB with error %d\n",
 
-+			err);
 
- 	}
 
- 
- 	return err;
 
-@@ -888,8 +923,8 @@ int __devinit ssb_bus_pcmciabus_register
 
- 
- 	err = ssb_bus_register(bus, ssb_pcmcia_get_invariants, baseaddr);
 
- 	if (!err) {
 
--		ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on "
 
--			   "PCMCIA device %s\n", pcmcia_dev->devname);
 
-+		ssb_info("Sonics Silicon Backplane found on PCMCIA device %s\n",
 
-+			 pcmcia_dev->devname);
 
- 	}
 
- 
- 	return err;
 
-@@ -911,8 +946,8 @@ int __devinit ssb_bus_sdiobus_register(s
 
- 
- 	err = ssb_bus_register(bus, ssb_sdio_get_invariants, ~0);
 
- 	if (!err) {
 
--		ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on "
 
--			   "SDIO device %s\n", sdio_func_id(func));
 
-+		ssb_info("Sonics Silicon Backplane found on SDIO device %s\n",
 
-+			 sdio_func_id(func));
 
- 	}
 
- 
- 	return err;
 
-@@ -931,8 +966,8 @@ int __devinit ssb_bus_ssbbus_register(st
 
- 
- 	err = ssb_bus_register(bus, get_invariants, baseaddr);
 
- 	if (!err) {
 
--		ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found at "
 
--			   "address 0x%08lX\n", baseaddr);
 
-+		ssb_info("Sonics Silicon Backplane found at address 0x%08lX\n",
 
-+			 baseaddr);
 
- 	}
 
- 
- 	return err;
 
-@@ -1094,6 +1129,9 @@ u32 ssb_clockspeed(struct ssb_bus *bus)
 
- 	u32 plltype;
 
- 	u32 clkctl_n, clkctl_m;
 
- 
-+	if (bus->chipco.capabilities & SSB_CHIPCO_CAP_PMU)
 
-+		return ssb_pmu_get_controlclock(&bus->chipco);
 
-+
 
- 	if (ssb_extif_available(&bus->extif))
 
- 		ssb_extif_get_clockcontrol(&bus->extif, &plltype,
 
- 					   &clkctl_n, &clkctl_m);
 
-@@ -1131,8 +1169,7 @@ static u32 ssb_tmslow_reject_bitmask(str
 
- 	case SSB_IDLOW_SSBREV_27:     /* same here */
 
- 		return SSB_TMSLOW_REJECT;	/* this is a guess */
 
- 	default:
 
--		printk(KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev);
 
--		WARN_ON(1);
 
-+		WARN(1, KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev);
 
- 	}
 
- 	return (SSB_TMSLOW_REJECT | SSB_TMSLOW_REJECT_23);
 
- }
 
-@@ -1324,7 +1361,7 @@ out:
 
- #endif
 
- 	return err;
 
- error:
 
--	ssb_printk(KERN_ERR PFX "Bus powerdown failed\n");
 
-+	ssb_err("Bus powerdown failed\n");
 
- 	goto out;
 
- }
 
- EXPORT_SYMBOL(ssb_bus_may_powerdown);
 
-@@ -1347,7 +1384,7 @@ int ssb_bus_powerup(struct ssb_bus *bus,
 
- 
- 	return 0;
 
- error:
 
--	ssb_printk(KERN_ERR PFX "Bus powerup failed\n");
 
-+	ssb_err("Bus powerup failed\n");
 
- 	return err;
 
- }
 
- EXPORT_SYMBOL(ssb_bus_powerup);
 
-@@ -1455,15 +1492,13 @@ static int __init ssb_modinit(void)
 
- 
- 	err = b43_pci_ssb_bridge_init();
 
- 	if (err) {
 
--		ssb_printk(KERN_ERR "Broadcom 43xx PCI-SSB-bridge "
 
--			   "initialization failed\n");
 
-+		ssb_err("Broadcom 43xx PCI-SSB-bridge initialization failed\n");
 
- 		/* don't fail SSB init because of this */
 
- 		err = 0;
 
- 	}
 
- 	err = ssb_gige_init();
 
- 	if (err) {
 
--		ssb_printk(KERN_ERR "SSB Broadcom Gigabit Ethernet "
 
--			   "driver initialization failed\n");
 
-+		ssb_err("SSB Broadcom Gigabit Ethernet driver initialization failed\n");
 
- 		/* don't fail SSB init because of this */
 
- 		err = 0;
 
- 	}
 
---- a/drivers/ssb/pci.c
 
-+++ b/drivers/ssb/pci.c
 
-@@ -56,7 +56,7 @@ int ssb_pci_switch_coreidx(struct ssb_bu
 
- 	}
 
- 	return 0;
 
- error:
 
--	ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx);
 
-+	ssb_err("Failed to switch to core %u\n", coreidx);
 
- 	return -ENODEV;
 
- }
 
- 
-@@ -67,10 +67,9 @@ int ssb_pci_switch_core(struct ssb_bus *
 
- 	unsigned long flags;
 
- 
- #if SSB_VERBOSE_PCICORESWITCH_DEBUG
 
--	ssb_printk(KERN_INFO PFX
 
--		   "Switching to %s core, index %d\n",
 
--		   ssb_core_name(dev->id.coreid),
 
--		   dev->core_index);
 
-+	ssb_info("Switching to %s core, index %d\n",
 
-+		 ssb_core_name(dev->id.coreid),
 
-+		 dev->core_index);
 
- #endif
 
- 
- 	spin_lock_irqsave(&bus->bar_lock, flags);
 
-@@ -178,6 +177,18 @@ err_pci:
 
- #define SPEX(_outvar, _offset, _mask, _shift) \
 
- 	SPEX16(_outvar, _offset, _mask, _shift)
 
- 
-+#define SPEX_ARRAY8(_field, _offset, _mask, _shift)	\
 
-+	do {	\
 
-+		SPEX(_field[0], _offset +  0, _mask, _shift);	\
 
-+		SPEX(_field[1], _offset +  2, _mask, _shift);	\
 
-+		SPEX(_field[2], _offset +  4, _mask, _shift);	\
 
-+		SPEX(_field[3], _offset +  6, _mask, _shift);	\
 
-+		SPEX(_field[4], _offset +  8, _mask, _shift);	\
 
-+		SPEX(_field[5], _offset + 10, _mask, _shift);	\
 
-+		SPEX(_field[6], _offset + 12, _mask, _shift);	\
 
-+		SPEX(_field[7], _offset + 14, _mask, _shift);	\
 
-+	} while (0)
 
-+
 
- 
- static inline u8 ssb_crc8(u8 crc, u8 data)
 
- {
 
-@@ -219,6 +230,15 @@ static inline u8 ssb_crc8(u8 crc, u8 dat
 
- 	return t[crc ^ data];
 
- }
 
- 
-+static void sprom_get_mac(char *mac, const u16 *in)
 
-+{
 
-+	int i;
 
-+	for (i = 0; i < 3; i++) {
 
-+		*mac++ = in[i] >> 8;
 
-+		*mac++ = in[i];
 
-+	}
 
-+}
 
-+
 
- static u8 ssb_sprom_crc(const u16 *sprom, u16 size)
 
- {
 
- 	int word;
 
-@@ -266,7 +286,7 @@ static int sprom_do_write(struct ssb_bus
 
- 	u32 spromctl;
 
- 	u16 size = bus->sprom_size;
 
- 
--	ssb_printk(KERN_NOTICE PFX "Writing SPROM. Do NOT turn off the power! Please stand by...\n");
 
-+	ssb_notice("Writing SPROM. Do NOT turn off the power! Please stand by...\n");
 
- 	err = pci_read_config_dword(pdev, SSB_SPROMCTL, &spromctl);
 
- 	if (err)
 
- 		goto err_ctlreg;
 
-@@ -274,17 +294,17 @@ static int sprom_do_write(struct ssb_bus
 
- 	err = pci_write_config_dword(pdev, SSB_SPROMCTL, spromctl);
 
- 	if (err)
 
- 		goto err_ctlreg;
 
--	ssb_printk(KERN_NOTICE PFX "[ 0%%");
 
-+	ssb_notice("[ 0%%");
 
- 	msleep(500);
 
- 	for (i = 0; i < size; i++) {
 
- 		if (i == size / 4)
 
--			ssb_printk("25%%");
 
-+			ssb_cont("25%%");
 
- 		else if (i == size / 2)
 
--			ssb_printk("50%%");
 
-+			ssb_cont("50%%");
 
- 		else if (i == (size * 3) / 4)
 
--			ssb_printk("75%%");
 
-+			ssb_cont("75%%");
 
- 		else if (i % 2)
 
--			ssb_printk(".");
 
-+			ssb_cont(".");
 
- 		writew(sprom[i], bus->mmio + bus->sprom_offset + (i * 2));
 
- 		mmiowb();
 
- 		msleep(20);
 
-@@ -297,12 +317,12 @@ static int sprom_do_write(struct ssb_bus
 
- 	if (err)
 
- 		goto err_ctlreg;
 
- 	msleep(500);
 
--	ssb_printk("100%% ]\n");
 
--	ssb_printk(KERN_NOTICE PFX "SPROM written.\n");
 
-+	ssb_cont("100%% ]\n");
 
-+	ssb_notice("SPROM written\n");
 
- 
- 	return 0;
 
- err_ctlreg:
 
--	ssb_printk(KERN_ERR PFX "Could not access SPROM control register.\n");
 
-+	ssb_err("Could not access SPROM control register.\n");
 
- 	return err;
 
- }
 
- 
-@@ -327,11 +347,23 @@ static s8 r123_extract_antgain(u8 sprom_
 
- 	return (s8)gain;
 
- }
 
- 
-+static void sprom_extract_r23(struct ssb_sprom *out, const u16 *in)
 
-+{
 
-+	SPEX(boardflags_hi, SSB_SPROM2_BFLHI, 0xFFFF, 0);
 
-+	SPEX(opo, SSB_SPROM2_OPO, SSB_SPROM2_OPO_VALUE, 0);
 
-+	SPEX(pa1lob0, SSB_SPROM2_PA1LOB0, 0xFFFF, 0);
 
-+	SPEX(pa1lob1, SSB_SPROM2_PA1LOB1, 0xFFFF, 0);
 
-+	SPEX(pa1lob2, SSB_SPROM2_PA1LOB2, 0xFFFF, 0);
 
-+	SPEX(pa1hib0, SSB_SPROM2_PA1HIB0, 0xFFFF, 0);
 
-+	SPEX(pa1hib1, SSB_SPROM2_PA1HIB1, 0xFFFF, 0);
 
-+	SPEX(pa1hib2, SSB_SPROM2_PA1HIB2, 0xFFFF, 0);
 
-+	SPEX(maxpwr_ah, SSB_SPROM2_MAXP_A, SSB_SPROM2_MAXP_A_HI, 0);
 
-+	SPEX(maxpwr_al, SSB_SPROM2_MAXP_A, SSB_SPROM2_MAXP_A_LO,
 
-+	     SSB_SPROM2_MAXP_A_LO_SHIFT);
 
-+}
 
-+
 
- static void sprom_extract_r123(struct ssb_sprom *out, const u16 *in)
 
- {
 
--	int i;
 
--	u16 v;
 
--	s8 gain;
 
- 	u16 loc[3];
 
- 
- 	if (out->revision == 3)			/* rev 3 moved MAC */
 
-@@ -341,19 +373,10 @@ static void sprom_extract_r123(struct ss
 
- 		loc[1] = SSB_SPROM1_ET0MAC;
 
- 		loc[2] = SSB_SPROM1_ET1MAC;
 
- 	}
 
--	for (i = 0; i < 3; i++) {
 
--		v = in[SPOFF(loc[0]) + i];
 
--		*(((__be16 *)out->il0mac) + i) = cpu_to_be16(v);
 
--	}
 
-+	sprom_get_mac(out->il0mac, &in[SPOFF(loc[0])]);
 
- 	if (out->revision < 3) { 	/* only rev 1-2 have et0, et1 */
 
--		for (i = 0; i < 3; i++) {
 
--			v = in[SPOFF(loc[1]) + i];
 
--			*(((__be16 *)out->et0mac) + i) = cpu_to_be16(v);
 
--		}
 
--		for (i = 0; i < 3; i++) {
 
--			v = in[SPOFF(loc[2]) + i];
 
--			*(((__be16 *)out->et1mac) + i) = cpu_to_be16(v);
 
--		}
 
-+		sprom_get_mac(out->et0mac, &in[SPOFF(loc[1])]);
 
-+		sprom_get_mac(out->et1mac, &in[SPOFF(loc[2])]);
 
- 	}
 
- 	SPEX(et0phyaddr, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET0A, 0);
 
- 	SPEX(et1phyaddr, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET1A,
 
-@@ -361,8 +384,10 @@ static void sprom_extract_r123(struct ss
 
- 	SPEX(et0mdcport, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET0M, 14);
 
- 	SPEX(et1mdcport, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET1M, 15);
 
- 	SPEX(board_rev, SSB_SPROM1_BINF, SSB_SPROM1_BINF_BREV, 0);
 
--	SPEX(country_code, SSB_SPROM1_BINF, SSB_SPROM1_BINF_CCODE,
 
--	     SSB_SPROM1_BINF_CCODE_SHIFT);
 
-+	SPEX(board_type, SSB_SPROM1_SPID, 0xFFFF, 0);
 
-+	if (out->revision == 1)
 
-+		SPEX(country_code, SSB_SPROM1_BINF, SSB_SPROM1_BINF_CCODE,
 
-+		     SSB_SPROM1_BINF_CCODE_SHIFT);
 
- 	SPEX(ant_available_a, SSB_SPROM1_BINF, SSB_SPROM1_BINF_ANTA,
 
- 	     SSB_SPROM1_BINF_ANTA_SHIFT);
 
- 	SPEX(ant_available_bg, SSB_SPROM1_BINF, SSB_SPROM1_BINF_ANTBG,
 
-@@ -386,24 +411,19 @@ static void sprom_extract_r123(struct ss
 
- 	     SSB_SPROM1_ITSSI_A_SHIFT);
 
- 	SPEX(itssi_bg, SSB_SPROM1_ITSSI, SSB_SPROM1_ITSSI_BG, 0);
 
- 	SPEX(boardflags_lo, SSB_SPROM1_BFLLO, 0xFFFF, 0);
 
--	if (out->revision >= 2)
 
--		SPEX(boardflags_hi, SSB_SPROM2_BFLHI, 0xFFFF, 0);
 
-+
 
-+	SPEX(alpha2[0], SSB_SPROM1_CCODE, 0xff00, 8);
 
-+	SPEX(alpha2[1], SSB_SPROM1_CCODE, 0x00ff, 0);
 
- 
- 	/* Extract the antenna gain values. */
 
--	gain = r123_extract_antgain(out->revision, in,
 
--				    SSB_SPROM1_AGAIN_BG,
 
--				    SSB_SPROM1_AGAIN_BG_SHIFT);
 
--	out->antenna_gain.ghz24.a0 = gain;
 
--	out->antenna_gain.ghz24.a1 = gain;
 
--	out->antenna_gain.ghz24.a2 = gain;
 
--	out->antenna_gain.ghz24.a3 = gain;
 
--	gain = r123_extract_antgain(out->revision, in,
 
--				    SSB_SPROM1_AGAIN_A,
 
--				    SSB_SPROM1_AGAIN_A_SHIFT);
 
--	out->antenna_gain.ghz5.a0 = gain;
 
--	out->antenna_gain.ghz5.a1 = gain;
 
--	out->antenna_gain.ghz5.a2 = gain;
 
--	out->antenna_gain.ghz5.a3 = gain;
 
-+	out->antenna_gain.a0 = r123_extract_antgain(out->revision, in,
 
-+						    SSB_SPROM1_AGAIN_BG,
 
-+						    SSB_SPROM1_AGAIN_BG_SHIFT);
 
-+	out->antenna_gain.a1 = r123_extract_antgain(out->revision, in,
 
-+						    SSB_SPROM1_AGAIN_A,
 
-+						    SSB_SPROM1_AGAIN_A_SHIFT);
 
-+	if (out->revision >= 2)
 
-+		sprom_extract_r23(out, in);
 
- }
 
- 
- /* Revs 4 5 and 8 have partially shared layout */
 
-@@ -448,30 +468,30 @@ static void sprom_extract_r458(struct ss
 
- 
- static void sprom_extract_r45(struct ssb_sprom *out, const u16 *in)
 
- {
 
--	int i;
 
--	u16 v;
 
- 	u16 il0mac_offset;
 
- 
- 	if (out->revision == 4)
 
- 		il0mac_offset = SSB_SPROM4_IL0MAC;
 
- 	else
 
- 		il0mac_offset = SSB_SPROM5_IL0MAC;
 
--	/* extract the MAC address */
 
--	for (i = 0; i < 3; i++) {
 
--		v = in[SPOFF(il0mac_offset) + i];
 
--		*(((__be16 *)out->il0mac) + i) = cpu_to_be16(v);
 
--	}
 
-+
 
-+	sprom_get_mac(out->il0mac, &in[SPOFF(il0mac_offset)]);
 
-+
 
- 	SPEX(et0phyaddr, SSB_SPROM4_ETHPHY, SSB_SPROM4_ETHPHY_ET0A, 0);
 
- 	SPEX(et1phyaddr, SSB_SPROM4_ETHPHY, SSB_SPROM4_ETHPHY_ET1A,
 
- 	     SSB_SPROM4_ETHPHY_ET1A_SHIFT);
 
-+	SPEX(board_rev, SSB_SPROM4_BOARDREV, 0xFFFF, 0);
 
-+	SPEX(board_type, SSB_SPROM1_SPID, 0xFFFF, 0);
 
- 	if (out->revision == 4) {
 
--		SPEX(country_code, SSB_SPROM4_CCODE, 0xFFFF, 0);
 
-+		SPEX(alpha2[0], SSB_SPROM4_CCODE, 0xff00, 8);
 
-+		SPEX(alpha2[1], SSB_SPROM4_CCODE, 0x00ff, 0);
 
- 		SPEX(boardflags_lo, SSB_SPROM4_BFLLO, 0xFFFF, 0);
 
- 		SPEX(boardflags_hi, SSB_SPROM4_BFLHI, 0xFFFF, 0);
 
- 		SPEX(boardflags2_lo, SSB_SPROM4_BFL2LO, 0xFFFF, 0);
 
- 		SPEX(boardflags2_hi, SSB_SPROM4_BFL2HI, 0xFFFF, 0);
 
- 	} else {
 
--		SPEX(country_code, SSB_SPROM5_CCODE, 0xFFFF, 0);
 
-+		SPEX(alpha2[0], SSB_SPROM5_CCODE, 0xff00, 8);
 
-+		SPEX(alpha2[1], SSB_SPROM5_CCODE, 0x00ff, 0);
 
- 		SPEX(boardflags_lo, SSB_SPROM5_BFLLO, 0xFFFF, 0);
 
- 		SPEX(boardflags_hi, SSB_SPROM5_BFLHI, 0xFFFF, 0);
 
- 		SPEX(boardflags2_lo, SSB_SPROM5_BFL2LO, 0xFFFF, 0);
 
-@@ -504,16 +524,14 @@ static void sprom_extract_r45(struct ssb
 
- 	}
 
- 
- 	/* Extract the antenna gain values. */
 
--	SPEX(antenna_gain.ghz24.a0, SSB_SPROM4_AGAIN01,
 
-+	SPEX(antenna_gain.a0, SSB_SPROM4_AGAIN01,
 
- 	     SSB_SPROM4_AGAIN0, SSB_SPROM4_AGAIN0_SHIFT);
 
--	SPEX(antenna_gain.ghz24.a1, SSB_SPROM4_AGAIN01,
 
-+	SPEX(antenna_gain.a1, SSB_SPROM4_AGAIN01,
 
- 	     SSB_SPROM4_AGAIN1, SSB_SPROM4_AGAIN1_SHIFT);
 
--	SPEX(antenna_gain.ghz24.a2, SSB_SPROM4_AGAIN23,
 
-+	SPEX(antenna_gain.a2, SSB_SPROM4_AGAIN23,
 
- 	     SSB_SPROM4_AGAIN2, SSB_SPROM4_AGAIN2_SHIFT);
 
--	SPEX(antenna_gain.ghz24.a3, SSB_SPROM4_AGAIN23,
 
-+	SPEX(antenna_gain.a3, SSB_SPROM4_AGAIN23,
 
- 	     SSB_SPROM4_AGAIN3, SSB_SPROM4_AGAIN3_SHIFT);
 
--	memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24,
 
--	       sizeof(out->antenna_gain.ghz5));
 
- 
- 	sprom_extract_r458(out, in);
 
- 
-@@ -523,14 +541,21 @@ static void sprom_extract_r45(struct ssb
 
- static void sprom_extract_r8(struct ssb_sprom *out, const u16 *in)
 
- {
 
- 	int i;
 
--	u16 v;
 
-+	u16 o;
 
-+	u16 pwr_info_offset[] = {
 
-+		SSB_SROM8_PWR_INFO_CORE0, SSB_SROM8_PWR_INFO_CORE1,
 
-+		SSB_SROM8_PWR_INFO_CORE2, SSB_SROM8_PWR_INFO_CORE3
 
-+	};
 
-+	BUILD_BUG_ON(ARRAY_SIZE(pwr_info_offset) !=
 
-+			ARRAY_SIZE(out->core_pwr_info));
 
- 
- 	/* extract the MAC address */
 
--	for (i = 0; i < 3; i++) {
 
--		v = in[SPOFF(SSB_SPROM8_IL0MAC) + i];
 
--		*(((__be16 *)out->il0mac) + i) = cpu_to_be16(v);
 
--	}
 
--	SPEX(country_code, SSB_SPROM8_CCODE, 0xFFFF, 0);
 
-+	sprom_get_mac(out->il0mac, &in[SPOFF(SSB_SPROM8_IL0MAC)]);
 
-+
 
-+	SPEX(board_rev, SSB_SPROM8_BOARDREV, 0xFFFF, 0);
 
-+	SPEX(board_type, SSB_SPROM1_SPID, 0xFFFF, 0);
 
-+	SPEX(alpha2[0], SSB_SPROM8_CCODE, 0xff00, 8);
 
-+	SPEX(alpha2[1], SSB_SPROM8_CCODE, 0x00ff, 0);
 
- 	SPEX(boardflags_lo, SSB_SPROM8_BFLLO, 0xFFFF, 0);
 
- 	SPEX(boardflags_hi, SSB_SPROM8_BFLHI, 0xFFFF, 0);
 
- 	SPEX(boardflags2_lo, SSB_SPROM8_BFL2LO, 0xFFFF, 0);
 
-@@ -596,16 +621,46 @@ static void sprom_extract_r8(struct ssb_
 
- 	SPEX32(ofdm5ghpo, SSB_SPROM8_OFDM5GHPO, 0xFFFFFFFF, 0);
 
- 
- 	/* Extract the antenna gain values. */
 
--	SPEX(antenna_gain.ghz24.a0, SSB_SPROM8_AGAIN01,
 
-+	SPEX(antenna_gain.a0, SSB_SPROM8_AGAIN01,
 
- 	     SSB_SPROM8_AGAIN0, SSB_SPROM8_AGAIN0_SHIFT);
 
--	SPEX(antenna_gain.ghz24.a1, SSB_SPROM8_AGAIN01,
 
-+	SPEX(antenna_gain.a1, SSB_SPROM8_AGAIN01,
 
- 	     SSB_SPROM8_AGAIN1, SSB_SPROM8_AGAIN1_SHIFT);
 
--	SPEX(antenna_gain.ghz24.a2, SSB_SPROM8_AGAIN23,
 
-+	SPEX(antenna_gain.a2, SSB_SPROM8_AGAIN23,
 
- 	     SSB_SPROM8_AGAIN2, SSB_SPROM8_AGAIN2_SHIFT);
 
--	SPEX(antenna_gain.ghz24.a3, SSB_SPROM8_AGAIN23,
 
-+	SPEX(antenna_gain.a3, SSB_SPROM8_AGAIN23,
 
- 	     SSB_SPROM8_AGAIN3, SSB_SPROM8_AGAIN3_SHIFT);
 
--	memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24,
 
--	       sizeof(out->antenna_gain.ghz5));
 
-+
 
-+	/* Extract cores power info info */
 
-+	for (i = 0; i < ARRAY_SIZE(pwr_info_offset); i++) {
 
-+		o = pwr_info_offset[i];
 
-+		SPEX(core_pwr_info[i].itssi_2g, o + SSB_SROM8_2G_MAXP_ITSSI,
 
-+			SSB_SPROM8_2G_ITSSI, SSB_SPROM8_2G_ITSSI_SHIFT);
 
-+		SPEX(core_pwr_info[i].maxpwr_2g, o + SSB_SROM8_2G_MAXP_ITSSI,
 
-+			SSB_SPROM8_2G_MAXP, 0);
 
-+
 
-+		SPEX(core_pwr_info[i].pa_2g[0], o + SSB_SROM8_2G_PA_0, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_2g[1], o + SSB_SROM8_2G_PA_1, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_2g[2], o + SSB_SROM8_2G_PA_2, ~0, 0);
 
-+
 
-+		SPEX(core_pwr_info[i].itssi_5g, o + SSB_SROM8_5G_MAXP_ITSSI,
 
-+			SSB_SPROM8_5G_ITSSI, SSB_SPROM8_5G_ITSSI_SHIFT);
 
-+		SPEX(core_pwr_info[i].maxpwr_5g, o + SSB_SROM8_5G_MAXP_ITSSI,
 
-+			SSB_SPROM8_5G_MAXP, 0);
 
-+		SPEX(core_pwr_info[i].maxpwr_5gh, o + SSB_SPROM8_5GHL_MAXP,
 
-+			SSB_SPROM8_5GH_MAXP, 0);
 
-+		SPEX(core_pwr_info[i].maxpwr_5gl, o + SSB_SPROM8_5GHL_MAXP,
 
-+			SSB_SPROM8_5GL_MAXP, SSB_SPROM8_5GL_MAXP_SHIFT);
 
-+
 
-+		SPEX(core_pwr_info[i].pa_5gl[0], o + SSB_SROM8_5GL_PA_0, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5gl[1], o + SSB_SROM8_5GL_PA_1, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5gl[2], o + SSB_SROM8_5GL_PA_2, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5g[0], o + SSB_SROM8_5G_PA_0, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5g[1], o + SSB_SROM8_5G_PA_1, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5g[2], o + SSB_SROM8_5G_PA_2, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5gh[0], o + SSB_SROM8_5GH_PA_0, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5gh[1], o + SSB_SROM8_5GH_PA_1, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5gh[2], o + SSB_SROM8_5GH_PA_2, ~0, 0);
 
-+	}
 
- 
- 	/* Extract FEM info */
 
- 	SPEX(fem.ghz2.tssipos, SSB_SPROM8_FEM2G,
 
-@@ -630,6 +685,63 @@ static void sprom_extract_r8(struct ssb_
 
- 	SPEX(fem.ghz5.antswlut, SSB_SPROM8_FEM5G,
 
- 		SSB_SROM8_FEM_ANTSWLUT, SSB_SROM8_FEM_ANTSWLUT_SHIFT);
 
- 
-+	SPEX(leddc_on_time, SSB_SPROM8_LEDDC, SSB_SPROM8_LEDDC_ON,
 
-+	     SSB_SPROM8_LEDDC_ON_SHIFT);
 
-+	SPEX(leddc_off_time, SSB_SPROM8_LEDDC, SSB_SPROM8_LEDDC_OFF,
 
-+	     SSB_SPROM8_LEDDC_OFF_SHIFT);
 
-+
 
-+	SPEX(txchain, SSB_SPROM8_TXRXC, SSB_SPROM8_TXRXC_TXCHAIN,
 
-+	     SSB_SPROM8_TXRXC_TXCHAIN_SHIFT);
 
-+	SPEX(rxchain, SSB_SPROM8_TXRXC, SSB_SPROM8_TXRXC_RXCHAIN,
 
-+	     SSB_SPROM8_TXRXC_RXCHAIN_SHIFT);
 
-+	SPEX(antswitch, SSB_SPROM8_TXRXC, SSB_SPROM8_TXRXC_SWITCH,
 
-+	     SSB_SPROM8_TXRXC_SWITCH_SHIFT);
 
-+
 
-+	SPEX(opo, SSB_SPROM8_OFDM2GPO, 0x00ff, 0);
 
-+
 
-+	SPEX_ARRAY8(mcs2gpo, SSB_SPROM8_2G_MCSPO, ~0, 0);
 
-+	SPEX_ARRAY8(mcs5gpo, SSB_SPROM8_5G_MCSPO, ~0, 0);
 
-+	SPEX_ARRAY8(mcs5glpo, SSB_SPROM8_5GL_MCSPO, ~0, 0);
 
-+	SPEX_ARRAY8(mcs5ghpo, SSB_SPROM8_5GH_MCSPO, ~0, 0);
 
-+
 
-+	SPEX(rawtempsense, SSB_SPROM8_RAWTS, SSB_SPROM8_RAWTS_RAWTEMP,
 
-+	     SSB_SPROM8_RAWTS_RAWTEMP_SHIFT);
 
-+	SPEX(measpower, SSB_SPROM8_RAWTS, SSB_SPROM8_RAWTS_MEASPOWER,
 
-+	     SSB_SPROM8_RAWTS_MEASPOWER_SHIFT);
 
-+	SPEX(tempsense_slope, SSB_SPROM8_OPT_CORRX,
 
-+	     SSB_SPROM8_OPT_CORRX_TEMP_SLOPE,
 
-+	     SSB_SPROM8_OPT_CORRX_TEMP_SLOPE_SHIFT);
 
-+	SPEX(tempcorrx, SSB_SPROM8_OPT_CORRX, SSB_SPROM8_OPT_CORRX_TEMPCORRX,
 
-+	     SSB_SPROM8_OPT_CORRX_TEMPCORRX_SHIFT);
 
-+	SPEX(tempsense_option, SSB_SPROM8_OPT_CORRX,
 
-+	     SSB_SPROM8_OPT_CORRX_TEMP_OPTION,
 
-+	     SSB_SPROM8_OPT_CORRX_TEMP_OPTION_SHIFT);
 
-+	SPEX(freqoffset_corr, SSB_SPROM8_HWIQ_IQSWP,
 
-+	     SSB_SPROM8_HWIQ_IQSWP_FREQ_CORR,
 
-+	     SSB_SPROM8_HWIQ_IQSWP_FREQ_CORR_SHIFT);
 
-+	SPEX(iqcal_swp_dis, SSB_SPROM8_HWIQ_IQSWP,
 
-+	     SSB_SPROM8_HWIQ_IQSWP_IQCAL_SWP,
 
-+	     SSB_SPROM8_HWIQ_IQSWP_IQCAL_SWP_SHIFT);
 
-+	SPEX(hw_iqcal_en, SSB_SPROM8_HWIQ_IQSWP, SSB_SPROM8_HWIQ_IQSWP_HW_IQCAL,
 
-+	     SSB_SPROM8_HWIQ_IQSWP_HW_IQCAL_SHIFT);
 
-+
 
-+	SPEX(bw40po, SSB_SPROM8_BW40PO, ~0, 0);
 
-+	SPEX(cddpo, SSB_SPROM8_CDDPO, ~0, 0);
 
-+	SPEX(stbcpo, SSB_SPROM8_STBCPO, ~0, 0);
 
-+	SPEX(bwduppo, SSB_SPROM8_BWDUPPO, ~0, 0);
 
-+
 
-+	SPEX(tempthresh, SSB_SPROM8_THERMAL, SSB_SPROM8_THERMAL_TRESH,
 
-+	     SSB_SPROM8_THERMAL_TRESH_SHIFT);
 
-+	SPEX(tempoffset, SSB_SPROM8_THERMAL, SSB_SPROM8_THERMAL_OFFSET,
 
-+	     SSB_SPROM8_THERMAL_OFFSET_SHIFT);
 
-+	SPEX(phycal_tempdelta, SSB_SPROM8_TEMPDELTA,
 
-+	     SSB_SPROM8_TEMPDELTA_PHYCAL,
 
-+	     SSB_SPROM8_TEMPDELTA_PHYCAL_SHIFT);
 
-+	SPEX(temps_period, SSB_SPROM8_TEMPDELTA, SSB_SPROM8_TEMPDELTA_PERIOD,
 
-+	     SSB_SPROM8_TEMPDELTA_PERIOD_SHIFT);
 
-+	SPEX(temps_hysteresis, SSB_SPROM8_TEMPDELTA,
 
-+	     SSB_SPROM8_TEMPDELTA_HYSTERESIS,
 
-+	     SSB_SPROM8_TEMPDELTA_HYSTERESIS_SHIFT);
 
- 	sprom_extract_r458(out, in);
 
- 
- 	/* TODO - get remaining rev 8 stuff needed */
 
-@@ -641,7 +753,7 @@ static int sprom_extract(struct ssb_bus
 
- 	memset(out, 0, sizeof(*out));
 
- 
- 	out->revision = in[size - 1] & 0x00FF;
 
--	ssb_dprintk(KERN_DEBUG PFX "SPROM revision %d detected.\n", out->revision);
 
-+	ssb_dbg("SPROM revision %d detected\n", out->revision);
 
- 	memset(out->et0mac, 0xFF, 6);		/* preset et0 and et1 mac */
 
- 	memset(out->et1mac, 0xFF, 6);
 
- 
-@@ -650,7 +762,7 @@ static int sprom_extract(struct ssb_bus
 
- 		 * number stored in the SPROM.
 
- 		 * Always extract r1. */
 
- 		out->revision = 1;
 
--		ssb_dprintk(KERN_DEBUG PFX "SPROM treated as revision %d\n", out->revision);
 
-+		ssb_dbg("SPROM treated as revision %d\n", out->revision);
 
- 	}
 
- 
- 	switch (out->revision) {
 
-@@ -667,9 +779,8 @@ static int sprom_extract(struct ssb_bus
 
- 		sprom_extract_r8(out, in);
 
- 		break;
 
- 	default:
 
--		ssb_printk(KERN_WARNING PFX "Unsupported SPROM"
 
--			   " revision %d detected. Will extract"
 
--			   " v1\n", out->revision);
 
-+		ssb_warn("Unsupported SPROM revision %d detected. Will extract v1\n",
 
-+			 out->revision);
 
- 		out->revision = 1;
 
- 		sprom_extract_r123(out, in);
 
- 	}
 
-@@ -689,7 +800,7 @@ static int ssb_pci_sprom_get(struct ssb_
 
- 	u16 *buf;
 
- 
- 	if (!ssb_is_sprom_available(bus)) {
 
--		ssb_printk(KERN_ERR PFX "No SPROM available!\n");
 
-+		ssb_err("No SPROM available!\n");
 
- 		return -ENODEV;
 
- 	}
 
- 	if (bus->chipco.dev) {	/* can be unavailable! */
 
-@@ -708,7 +819,7 @@ static int ssb_pci_sprom_get(struct ssb_
 
- 	} else {
 
- 		bus->sprom_offset = SSB_SPROM_BASE1;
 
- 	}
 
--	ssb_dprintk(KERN_INFO PFX "SPROM offset is 0x%x\n", bus->sprom_offset);
 
-+	ssb_dbg("SPROM offset is 0x%x\n", bus->sprom_offset);
 
- 
- 	buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL);
 
- 	if (!buf)
 
-@@ -733,18 +844,15 @@ static int ssb_pci_sprom_get(struct ssb_
 
- 			 * available for this device in some other storage */
 
- 			err = ssb_fill_sprom_with_fallback(bus, sprom);
 
- 			if (err) {
 
--				ssb_printk(KERN_WARNING PFX "WARNING: Using"
 
--					   " fallback SPROM failed (err %d)\n",
 
--					   err);
 
-+				ssb_warn("WARNING: Using fallback SPROM failed (err %d)\n",
 
-+					 err);
 
- 			} else {
 
--				ssb_dprintk(KERN_DEBUG PFX "Using SPROM"
 
--					    " revision %d provided by"
 
--					    " platform.\n", sprom->revision);
 
-+				ssb_dbg("Using SPROM revision %d provided by platform\n",
 
-+					sprom->revision);
 
- 				err = 0;
 
- 				goto out_free;
 
- 			}
 
--			ssb_printk(KERN_WARNING PFX "WARNING: Invalid"
 
--				   " SPROM CRC (corrupt SPROM)\n");
 
-+			ssb_warn("WARNING: Invalid SPROM CRC (corrupt SPROM)\n");
 
- 		}
 
- 	}
 
- 	err = sprom_extract(bus, sprom, buf, bus->sprom_size);
 
-@@ -759,7 +867,6 @@ static void ssb_pci_get_boardinfo(struct
 
- {
 
- 	bi->vendor = bus->host_pci->subsystem_vendor;
 
- 	bi->type = bus->host_pci->subsystem_device;
 
--	bi->rev = bus->host_pci->revision;
 
- }
 
- 
- int ssb_pci_get_invariants(struct ssb_bus *bus,
 
---- a/drivers/ssb/pcihost_wrapper.c
 
-+++ b/drivers/ssb/pcihost_wrapper.c
 
-@@ -38,7 +38,7 @@ static int ssb_pcihost_resume(struct pci
 
- 	struct ssb_bus *ssb = pci_get_drvdata(dev);
 
- 	int err;
 
- 
--	pci_set_power_state(dev, 0);
 
-+	pci_set_power_state(dev, PCI_D0);
 
- 	err = pci_enable_device(dev);
 
- 	if (err)
 
- 		return err;
 
---- a/drivers/ssb/pcmcia.c
 
-+++ b/drivers/ssb/pcmcia.c
 
-@@ -143,7 +143,7 @@ int ssb_pcmcia_switch_coreidx(struct ssb
 
- 
- 	return 0;
 
- error:
 
--	ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx);
 
-+	ssb_err("Failed to switch to core %u\n", coreidx);
 
- 	return err;
 
- }
 
- 
-@@ -153,10 +153,9 @@ int ssb_pcmcia_switch_core(struct ssb_bu
 
- 	int err;
 
- 
- #if SSB_VERBOSE_PCMCIACORESWITCH_DEBUG
 
--	ssb_printk(KERN_INFO PFX
 
--		   "Switching to %s core, index %d\n",
 
--		   ssb_core_name(dev->id.coreid),
 
--		   dev->core_index);
 
-+	ssb_info("Switching to %s core, index %d\n",
 
-+		 ssb_core_name(dev->id.coreid),
 
-+		 dev->core_index);
 
- #endif
 
- 
- 	err = ssb_pcmcia_switch_coreidx(bus, dev->core_index);
 
-@@ -192,7 +191,7 @@ int ssb_pcmcia_switch_segment(struct ssb
 
- 
- 	return 0;
 
- error:
 
--	ssb_printk(KERN_ERR PFX "Failed to switch pcmcia segment\n");
 
-+	ssb_err("Failed to switch pcmcia segment\n");
 
- 	return err;
 
- }
 
- 
-@@ -549,44 +548,39 @@ static int ssb_pcmcia_sprom_write_all(st
 
- 	bool failed = 0;
 
- 	size_t size = SSB_PCMCIA_SPROM_SIZE;
 
- 
--	ssb_printk(KERN_NOTICE PFX
 
--		   "Writing SPROM. Do NOT turn off the power! "
 
--		   "Please stand by...\n");
 
-+	ssb_notice("Writing SPROM. Do NOT turn off the power! Please stand by...\n");
 
- 	err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEEN);
 
- 	if (err) {
 
--		ssb_printk(KERN_NOTICE PFX
 
--			   "Could not enable SPROM write access.\n");
 
-+		ssb_notice("Could not enable SPROM write access\n");
 
- 		return -EBUSY;
 
- 	}
 
--	ssb_printk(KERN_NOTICE PFX "[ 0%%");
 
-+	ssb_notice("[ 0%%");
 
- 	msleep(500);
 
- 	for (i = 0; i < size; i++) {
 
- 		if (i == size / 4)
 
--			ssb_printk("25%%");
 
-+			ssb_cont("25%%");
 
- 		else if (i == size / 2)
 
--			ssb_printk("50%%");
 
-+			ssb_cont("50%%");
 
- 		else if (i == (size * 3) / 4)
 
--			ssb_printk("75%%");
 
-+			ssb_cont("75%%");
 
- 		else if (i % 2)
 
--			ssb_printk(".");
 
-+			ssb_cont(".");
 
- 		err = ssb_pcmcia_sprom_write(bus, i, sprom[i]);
 
- 		if (err) {
 
--			ssb_printk(KERN_NOTICE PFX
 
--				   "Failed to write to SPROM.\n");
 
-+			ssb_notice("Failed to write to SPROM\n");
 
- 			failed = 1;
 
- 			break;
 
- 		}
 
- 	}
 
- 	err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEDIS);
 
- 	if (err) {
 
--		ssb_printk(KERN_NOTICE PFX
 
--			   "Could not disable SPROM write access.\n");
 
-+		ssb_notice("Could not disable SPROM write access\n");
 
- 		failed = 1;
 
- 	}
 
- 	msleep(500);
 
- 	if (!failed) {
 
--		ssb_printk("100%% ]\n");
 
--		ssb_printk(KERN_NOTICE PFX "SPROM written.\n");
 
-+		ssb_cont("100%% ]\n");
 
-+		ssb_notice("SPROM written\n");
 
- 	}
 
- 
- 	return failed ? -EBUSY : 0;
 
-@@ -676,14 +670,10 @@ static int ssb_pcmcia_do_get_invariants(
 
- 	case SSB_PCMCIA_CIS_ANTGAIN:
 
- 		GOTO_ERROR_ON(tuple->TupleDataLen != 2,
 
- 			"antg tpl size");
 
--		sprom->antenna_gain.ghz24.a0 = tuple->TupleData[1];
 
--		sprom->antenna_gain.ghz24.a1 = tuple->TupleData[1];
 
--		sprom->antenna_gain.ghz24.a2 = tuple->TupleData[1];
 
--		sprom->antenna_gain.ghz24.a3 = tuple->TupleData[1];
 
--		sprom->antenna_gain.ghz5.a0 = tuple->TupleData[1];
 
--		sprom->antenna_gain.ghz5.a1 = tuple->TupleData[1];
 
--		sprom->antenna_gain.ghz5.a2 = tuple->TupleData[1];
 
--		sprom->antenna_gain.ghz5.a3 = tuple->TupleData[1];
 
-+		sprom->antenna_gain.a0 = tuple->TupleData[1];
 
-+		sprom->antenna_gain.a1 = tuple->TupleData[1];
 
-+		sprom->antenna_gain.a2 = tuple->TupleData[1];
 
-+		sprom->antenna_gain.a3 = tuple->TupleData[1];
 
- 		break;
 
- 	case SSB_PCMCIA_CIS_BFLAGS:
 
- 		GOTO_ERROR_ON((tuple->TupleDataLen != 3) &&
 
-@@ -704,7 +694,7 @@ static int ssb_pcmcia_do_get_invariants(
 
- 	return -ENOSPC; /* continue with next entry */
 
- 
- error:
 
--	ssb_printk(KERN_ERR PFX
 
-+	ssb_err(
 
- 		   "PCMCIA: Failed to fetch device invariants: %s\n",
 
- 		   error_description);
 
- 	return -ENODEV;
 
-@@ -726,7 +716,7 @@ int ssb_pcmcia_get_invariants(struct ssb
 
- 	res = pcmcia_loop_tuple(bus->host_pcmcia, CISTPL_FUNCE,
 
- 				ssb_pcmcia_get_mac, sprom);
 
- 	if (res != 0) {
 
--		ssb_printk(KERN_ERR PFX
 
-+		ssb_err(
 
- 			"PCMCIA: Failed to fetch MAC address\n");
 
- 		return -ENODEV;
 
- 	}
 
-@@ -737,7 +727,7 @@ int ssb_pcmcia_get_invariants(struct ssb
 
- 	if ((res == 0) || (res == -ENOSPC))
 
- 		return 0;
 
- 
--	ssb_printk(KERN_ERR PFX
 
-+	ssb_err(
 
- 			"PCMCIA: Failed to fetch device invariants\n");
 
- 	return -ENODEV;
 
- }
 
-@@ -847,6 +837,6 @@ int ssb_pcmcia_init(struct ssb_bus *bus)
 
- 
- 	return 0;
 
- error:
 
--	ssb_printk(KERN_ERR PFX "Failed to initialize PCMCIA host device\n");
 
-+	ssb_err("Failed to initialize PCMCIA host device\n");
 
- 	return err;
 
- }
 
---- a/drivers/ssb/scan.c
 
-+++ b/drivers/ssb/scan.c
 
-@@ -90,6 +90,8 @@ const char *ssb_core_name(u16 coreid)
 
- 		return "ARM 1176";
 
- 	case SSB_DEV_ARM_7TDMI:
 
- 		return "ARM 7TDMI";
 
-+	case SSB_DEV_ARM_CM3:
 
-+		return "ARM Cortex M3";
 
- 	}
 
- 	return "UNKNOWN";
 
- }
 
-@@ -123,8 +125,7 @@ static u16 pcidev_to_chipid(struct pci_d
 
- 		chipid_fallback = 0x4401;
 
- 		break;
 
- 	default:
 
--		ssb_printk(KERN_ERR PFX
 
--			   "PCI-ID not in fallback list\n");
 
-+		ssb_err("PCI-ID not in fallback list\n");
 
- 	}
 
- 
- 	return chipid_fallback;
 
-@@ -150,8 +151,7 @@ static u8 chipid_to_nrcores(u16 chipid)
 
- 	case 0x4704:
 
- 		return 9;
 
- 	default:
 
--		ssb_printk(KERN_ERR PFX
 
--			   "CHIPID not in nrcores fallback list\n");
 
-+		ssb_err("CHIPID not in nrcores fallback list\n");
 
- 	}
 
- 
- 	return 1;
 
-@@ -318,12 +318,13 @@ int ssb_bus_scan(struct ssb_bus *bus,
 
- 			bus->chip_package = 0;
 
- 		}
 
- 	}
 
-+	ssb_info("Found chip with id 0x%04X, rev 0x%02X and package 0x%02X\n",
 
-+		 bus->chip_id, bus->chip_rev, bus->chip_package);
 
- 	if (!bus->nr_devices)
 
- 		bus->nr_devices = chipid_to_nrcores(bus->chip_id);
 
- 	if (bus->nr_devices > ARRAY_SIZE(bus->devices)) {
 
--		ssb_printk(KERN_ERR PFX
 
--			   "More than %d ssb cores found (%d)\n",
 
--			   SSB_MAX_NR_CORES, bus->nr_devices);
 
-+		ssb_err("More than %d ssb cores found (%d)\n",
 
-+			SSB_MAX_NR_CORES, bus->nr_devices);
 
- 		goto err_unmap;
 
- 	}
 
- 	if (bus->bustype == SSB_BUSTYPE_SSB) {
 
-@@ -365,8 +366,7 @@ int ssb_bus_scan(struct ssb_bus *bus,
 
- 			nr_80211_cores++;
 
- 			if (nr_80211_cores > 1) {
 
- 				if (!we_support_multiple_80211_cores(bus)) {
 
--					ssb_dprintk(KERN_INFO PFX "Ignoring additional "
 
--						    "802.11 core\n");
 
-+					ssb_dbg("Ignoring additional 802.11 core\n");
 
- 					continue;
 
- 				}
 
- 			}
 
-@@ -374,8 +374,7 @@ int ssb_bus_scan(struct ssb_bus *bus,
 
- 		case SSB_DEV_EXTIF:
 
- #ifdef CONFIG_SSB_DRIVER_EXTIF
 
- 			if (bus->extif.dev) {
 
--				ssb_printk(KERN_WARNING PFX
 
--					   "WARNING: Multiple EXTIFs found\n");
 
-+				ssb_warn("WARNING: Multiple EXTIFs found\n");
 
- 				break;
 
- 			}
 
- 			bus->extif.dev = dev;
 
-@@ -383,8 +382,7 @@ int ssb_bus_scan(struct ssb_bus *bus,
 
- 			break;
 
- 		case SSB_DEV_CHIPCOMMON:
 
- 			if (bus->chipco.dev) {
 
--				ssb_printk(KERN_WARNING PFX
 
--					   "WARNING: Multiple ChipCommon found\n");
 
-+				ssb_warn("WARNING: Multiple ChipCommon found\n");
 
- 				break;
 
- 			}
 
- 			bus->chipco.dev = dev;
 
-@@ -393,8 +391,7 @@ int ssb_bus_scan(struct ssb_bus *bus,
 
- 		case SSB_DEV_MIPS_3302:
 
- #ifdef CONFIG_SSB_DRIVER_MIPS
 
- 			if (bus->mipscore.dev) {
 
--				ssb_printk(KERN_WARNING PFX
 
--					   "WARNING: Multiple MIPS cores found\n");
 
-+				ssb_warn("WARNING: Multiple MIPS cores found\n");
 
- 				break;
 
- 			}
 
- 			bus->mipscore.dev = dev;
 
-@@ -415,8 +412,7 @@ int ssb_bus_scan(struct ssb_bus *bus,
 
- 				}
 
- 			}
 
- 			if (bus->pcicore.dev) {
 
--				ssb_printk(KERN_WARNING PFX
 
--					   "WARNING: Multiple PCI(E) cores found\n");
 
-+				ssb_warn("WARNING: Multiple PCI(E) cores found\n");
 
- 				break;
 
- 			}
 
- 			bus->pcicore.dev = dev;
 
---- a/drivers/ssb/sdio.c
 
-+++ b/drivers/ssb/sdio.c
 
-@@ -551,14 +551,10 @@ int ssb_sdio_get_invariants(struct ssb_b
 
- 			case SSB_SDIO_CIS_ANTGAIN:
 
- 				GOTO_ERROR_ON(tuple->size != 2,
 
- 					      "antg tpl size");
 
--				sprom->antenna_gain.ghz24.a0 = tuple->data[1];
 
--				sprom->antenna_gain.ghz24.a1 = tuple->data[1];
 
--				sprom->antenna_gain.ghz24.a2 = tuple->data[1];
 
--				sprom->antenna_gain.ghz24.a3 = tuple->data[1];
 
--				sprom->antenna_gain.ghz5.a0 = tuple->data[1];
 
--				sprom->antenna_gain.ghz5.a1 = tuple->data[1];
 
--				sprom->antenna_gain.ghz5.a2 = tuple->data[1];
 
--				sprom->antenna_gain.ghz5.a3 = tuple->data[1];
 
-+				sprom->antenna_gain.a0 = tuple->data[1];
 
-+				sprom->antenna_gain.a1 = tuple->data[1];
 
-+				sprom->antenna_gain.a2 = tuple->data[1];
 
-+				sprom->antenna_gain.a3 = tuple->data[1];
 
- 				break;
 
- 			case SSB_SDIO_CIS_BFLAGS:
 
- 				GOTO_ERROR_ON((tuple->size != 3) &&
 
---- a/drivers/ssb/sprom.c
 
-+++ b/drivers/ssb/sprom.c
 
-@@ -54,7 +54,7 @@ static int hex2sprom(u16 *sprom, const c
 
- 	while (cnt < sprom_size_words) {
 
- 		memcpy(tmp, dump, 4);
 
- 		dump += 4;
 
--		err = strict_strtoul(tmp, 16, &parsed);
 
-+		err = kstrtoul(tmp, 16, &parsed);
 
- 		if (err)
 
- 			return err;
 
- 		sprom[cnt++] = swab16((u16)parsed);
 
-@@ -127,13 +127,13 @@ ssize_t ssb_attr_sprom_store(struct ssb_
 
- 		goto out_kfree;
 
- 	err = ssb_devices_freeze(bus, &freeze);
 
- 	if (err) {
 
--		ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n");
 
-+		ssb_err("SPROM write: Could not freeze all devices\n");
 
- 		goto out_unlock;
 
- 	}
 
- 	res = sprom_write(bus, sprom);
 
- 	err = ssb_devices_thaw(&freeze);
 
- 	if (err)
 
--		ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n");
 
-+		ssb_err("SPROM write: Could not thaw all devices\n");
 
- out_unlock:
 
- 	mutex_unlock(&bus->sprom_mutex);
 
- out_kfree:
 
---- a/drivers/ssb/ssb_private.h
 
-+++ b/drivers/ssb/ssb_private.h
 
-@@ -3,21 +3,33 @@
 
- 
- #include <linux/ssb/ssb.h>
 
- #include <linux/types.h>
 
-+#include <linux/bcm47xx_wdt.h>
 
- 
- 
- #define PFX	"ssb: "
 
- 
- #ifdef CONFIG_SSB_SILENT
 
--# define ssb_printk(fmt, x...)	do { /* nothing */ } while (0)
 
-+# define ssb_printk(fmt, ...)					\
 
-+	do { if (0) printk(fmt, ##__VA_ARGS__); } while (0)
 
- #else
 
--# define ssb_printk		printk
 
-+# define ssb_printk(fmt, ...)					\
 
-+	printk(fmt, ##__VA_ARGS__)
 
- #endif /* CONFIG_SSB_SILENT */
 
- 
-+#define ssb_emerg(fmt, ...)	ssb_printk(KERN_EMERG PFX fmt, ##__VA_ARGS__)
 
-+#define ssb_err(fmt, ...)	ssb_printk(KERN_ERR PFX fmt, ##__VA_ARGS__)
 
-+#define ssb_warn(fmt, ...)	ssb_printk(KERN_WARNING PFX fmt, ##__VA_ARGS__)
 
-+#define ssb_notice(fmt, ...)	ssb_printk(KERN_NOTICE PFX fmt, ##__VA_ARGS__)
 
-+#define ssb_info(fmt, ...)	ssb_printk(KERN_INFO PFX fmt, ##__VA_ARGS__)
 
-+#define ssb_cont(fmt, ...)	ssb_printk(KERN_CONT fmt, ##__VA_ARGS__)
 
-+
 
- /* dprintk: Debugging printk; vanishes for non-debug compilation */
 
- #ifdef CONFIG_SSB_DEBUG
 
--# define ssb_dprintk(fmt, x...)	ssb_printk(fmt , ##x)
 
-+# define ssb_dbg(fmt, ...)					\
 
-+	ssb_printk(KERN_DEBUG PFX fmt, ##__VA_ARGS__)
 
- #else
 
--# define ssb_dprintk(fmt, x...)	do { /* nothing */ } while (0)
 
-+# define ssb_dbg(fmt, ...)					\
 
-+	do { if (0) printk(KERN_DEBUG PFX fmt, ##__VA_ARGS__); } while (0)
 
- #endif
 
- 
- #ifdef CONFIG_SSB_DEBUG
 
-@@ -207,4 +219,79 @@ static inline void b43_pci_ssb_bridge_ex
 
- }
 
- #endif /* CONFIG_SSB_B43_PCI_BRIDGE */
 
- 
-+/* driver_chipcommon_pmu.c */
 
-+extern u32 ssb_pmu_get_cpu_clock(struct ssb_chipcommon *cc);
 
-+extern u32 ssb_pmu_get_controlclock(struct ssb_chipcommon *cc);
 
-+extern u32 ssb_pmu_get_alp_clock(struct ssb_chipcommon *cc);
 
-+
 
-+extern u32 ssb_chipco_watchdog_timer_set_wdt(struct bcm47xx_wdt *wdt,
 
-+					     u32 ticks);
 
-+extern u32 ssb_chipco_watchdog_timer_set_ms(struct bcm47xx_wdt *wdt, u32 ms);
 
-+
 
-+/* driver_chipcommon_sflash.c */
 
-+#ifdef CONFIG_SSB_SFLASH
 
-+int ssb_sflash_init(struct ssb_chipcommon *cc);
 
-+#else
 
-+static inline int ssb_sflash_init(struct ssb_chipcommon *cc)
 
-+{
 
-+	pr_err("Serial flash not supported\n");
 
-+	return 0;
 
-+}
 
-+#endif /* CONFIG_SSB_SFLASH */
 
-+
 
-+#ifdef CONFIG_SSB_DRIVER_MIPS
 
-+extern struct platform_device ssb_pflash_dev;
 
-+#endif
 
-+
 
-+#ifdef CONFIG_SSB_SFLASH
 
-+extern struct platform_device ssb_sflash_dev;
 
-+#endif
 
-+
 
-+#ifdef CONFIG_SSB_DRIVER_EXTIF
 
-+extern u32 ssb_extif_watchdog_timer_set_wdt(struct bcm47xx_wdt *wdt, u32 ticks);
 
-+extern u32 ssb_extif_watchdog_timer_set_ms(struct bcm47xx_wdt *wdt, u32 ms);
 
-+#else
 
-+static inline u32 ssb_extif_watchdog_timer_set_wdt(struct bcm47xx_wdt *wdt,
 
-+						   u32 ticks)
 
-+{
 
-+	return 0;
 
-+}
 
-+static inline u32 ssb_extif_watchdog_timer_set_ms(struct bcm47xx_wdt *wdt,
 
-+						  u32 ms)
 
-+{
 
-+	return 0;
 
-+}
 
-+#endif
 
-+
 
-+#ifdef CONFIG_SSB_EMBEDDED
 
-+extern int ssb_watchdog_register(struct ssb_bus *bus);
 
-+#else /* CONFIG_SSB_EMBEDDED */
 
-+static inline int ssb_watchdog_register(struct ssb_bus *bus)
 
-+{
 
-+	return 0;
 
-+}
 
-+#endif /* CONFIG_SSB_EMBEDDED */
 
-+
 
-+#ifdef CONFIG_SSB_DRIVER_EXTIF
 
-+extern void ssb_extif_init(struct ssb_extif *extif);
 
-+#else
 
-+static inline void ssb_extif_init(struct ssb_extif *extif)
 
-+{
 
-+}
 
-+#endif
 
-+
 
-+#ifdef CONFIG_SSB_DRIVER_GPIO
 
-+extern int ssb_gpio_init(struct ssb_bus *bus);
 
-+extern int ssb_gpio_unregister(struct ssb_bus *bus);
 
-+#else /* CONFIG_SSB_DRIVER_GPIO */
 
-+static inline int ssb_gpio_init(struct ssb_bus *bus)
 
-+{
 
-+	return -ENOTSUPP;
 
-+}
 
-+static inline int ssb_gpio_unregister(struct ssb_bus *bus)
 
-+{
 
-+	return 0;
 
-+}
 
-+#endif /* CONFIG_SSB_DRIVER_GPIO */
 
-+
 
- #endif /* LINUX_SSB_PRIVATE_H_ */
 
---- a/include/linux/ssb/ssb.h
 
-+++ b/include/linux/ssb/ssb.h
 
-@@ -6,8 +6,10 @@
 
- #include <linux/types.h>
 
- #include <linux/spinlock.h>
 
- #include <linux/pci.h>
 
-+#include <linux/gpio.h>
 
- #include <linux/mod_devicetable.h>
 
- #include <linux/dma-mapping.h>
 
-+#include <linux/platform_device.h>
 
- 
- #include <linux/ssb/ssb_regs.h>
 
- 
-@@ -16,19 +18,29 @@ struct pcmcia_device;
 
- struct ssb_bus;
 
- struct ssb_driver;
 
- 
-+struct ssb_sprom_core_pwr_info {
 
-+	u8 itssi_2g, itssi_5g;
 
-+	u8 maxpwr_2g, maxpwr_5gl, maxpwr_5g, maxpwr_5gh;
 
-+	u16 pa_2g[4], pa_5gl[4], pa_5g[4], pa_5gh[4];
 
-+};
 
-+
 
- struct ssb_sprom {
 
- 	u8 revision;
 
--	u8 il0mac[6];		/* MAC address for 802.11b/g */
 
--	u8 et0mac[6];		/* MAC address for Ethernet */
 
--	u8 et1mac[6];		/* MAC address for 802.11a */
 
-+	u8 il0mac[6] __aligned(sizeof(u16));	/* MAC address for 802.11b/g */
 
-+	u8 et0mac[6] __aligned(sizeof(u16));	/* MAC address for Ethernet */
 
-+	u8 et1mac[6] __aligned(sizeof(u16));	/* MAC address for 802.11a */
 
- 	u8 et0phyaddr;		/* MII address for enet0 */
 
- 	u8 et1phyaddr;		/* MII address for enet1 */
 
- 	u8 et0mdcport;		/* MDIO for enet0 */
 
- 	u8 et1mdcport;		/* MDIO for enet1 */
 
-+	u16 dev_id;		/* Device ID overriding e.g. PCI ID */
 
- 	u16 board_rev;		/* Board revision number from SPROM. */
 
-+	u16 board_num;		/* Board number from SPROM. */
 
-+	u16 board_type;		/* Board type from SPROM. */
 
- 	u8 country_code;	/* Country Code */
 
--	u16 leddc_on_time;	/* LED Powersave Duty Cycle On Count */
 
--	u16 leddc_off_time;	/* LED Powersave Duty Cycle Off Count */
 
-+	char alpha2[2];		/* Country Code as two chars like EU or US */
 
-+	u8 leddc_on_time;	/* LED Powersave Duty Cycle On Count */
 
-+	u8 leddc_off_time;	/* LED Powersave Duty Cycle Off Count */
 
- 	u8 ant_available_a;	/* 2GHz antenna available bits (up to 4) */
 
- 	u8 ant_available_bg;	/* 5GHz antenna available bits (up to 4) */
 
- 	u16 pa0b0;
 
-@@ -47,10 +59,10 @@ struct ssb_sprom {
 
- 	u8 gpio1;		/* GPIO pin 1 */
 
- 	u8 gpio2;		/* GPIO pin 2 */
 
- 	u8 gpio3;		/* GPIO pin 3 */
 
--	u16 maxpwr_bg;		/* 2.4GHz Amplifier Max Power (in dBm Q5.2) */
 
--	u16 maxpwr_al;		/* 5.2GHz Amplifier Max Power (in dBm Q5.2) */
 
--	u16 maxpwr_a;		/* 5.3GHz Amplifier Max Power (in dBm Q5.2) */
 
--	u16 maxpwr_ah;		/* 5.8GHz Amplifier Max Power (in dBm Q5.2) */
 
-+	u8 maxpwr_bg;		/* 2.4GHz Amplifier Max Power (in dBm Q5.2) */
 
-+	u8 maxpwr_al;		/* 5.2GHz Amplifier Max Power (in dBm Q5.2) */
 
-+	u8 maxpwr_a;		/* 5.3GHz Amplifier Max Power (in dBm Q5.2) */
 
-+	u8 maxpwr_ah;		/* 5.8GHz Amplifier Max Power (in dBm Q5.2) */
 
- 	u8 itssi_a;		/* Idle TSSI Target for A-PHY */
 
- 	u8 itssi_bg;		/* Idle TSSI Target for B/G-PHY */
 
- 	u8 tri2g;		/* 2.4GHz TX isolation */
 
-@@ -61,8 +73,8 @@ struct ssb_sprom {
 
- 	u8 txpid5gl[4];		/* 4.9 - 5.1GHz TX power index */
 
- 	u8 txpid5g[4];		/* 5.1 - 5.5GHz TX power index */
 
- 	u8 txpid5gh[4];		/* 5.5 - ...GHz TX power index */
 
--	u8 rxpo2g;		/* 2GHz RX power offset */
 
--	u8 rxpo5g;		/* 5GHz RX power offset */
 
-+	s8 rxpo2g;		/* 2GHz RX power offset */
 
-+	s8 rxpo5g;		/* 5GHz RX power offset */
 
- 	u8 rssisav2g;		/* 2GHz RSSI params */
 
- 	u8 rssismc2g;
 
- 	u8 rssismf2g;
 
-@@ -82,16 +94,13 @@ struct ssb_sprom {
 
- 	u16 boardflags2_hi;	/* Board flags (bits 48-63) */
 
- 	/* TODO store board flags in a single u64 */
 
- 
-+	struct ssb_sprom_core_pwr_info core_pwr_info[4];
 
-+
 
- 	/* Antenna gain values for up to 4 antennas
 
- 	 * on each band. Values in dBm/4 (Q5.2). Negative gain means the
 
- 	 * loss in the connectors is bigger than the gain. */
 
- 	struct {
 
--		struct {
 
--			s8 a0, a1, a2, a3;
 
--		} ghz24;	/* 2.4GHz band */
 
--		struct {
 
--			s8 a0, a1, a2, a3;
 
--		} ghz5;		/* 5GHz band */
 
-+		s8 a0, a1, a2, a3;
 
- 	} antenna_gain;
 
- 
- 	struct {
 
-@@ -103,14 +112,85 @@ struct ssb_sprom {
 
- 		} ghz5;
 
- 	} fem;
 
- 
--	/* TODO - add any parameters needed from rev 2, 3, 4, 5 or 8 SPROMs */
 
-+	u16 mcs2gpo[8];
 
-+	u16 mcs5gpo[8];
 
-+	u16 mcs5glpo[8];
 
-+	u16 mcs5ghpo[8];
 
-+	u8 opo;
 
-+
 
-+	u8 rxgainerr2ga[3];
 
-+	u8 rxgainerr5gla[3];
 
-+	u8 rxgainerr5gma[3];
 
-+	u8 rxgainerr5gha[3];
 
-+	u8 rxgainerr5gua[3];
 
-+
 
-+	u8 noiselvl2ga[3];
 
-+	u8 noiselvl5gla[3];
 
-+	u8 noiselvl5gma[3];
 
-+	u8 noiselvl5gha[3];
 
-+	u8 noiselvl5gua[3];
 
-+
 
-+	u8 regrev;
 
-+	u8 txchain;
 
-+	u8 rxchain;
 
-+	u8 antswitch;
 
-+	u16 cddpo;
 
-+	u16 stbcpo;
 
-+	u16 bw40po;
 
-+	u16 bwduppo;
 
-+
 
-+	u8 tempthresh;
 
-+	u8 tempoffset;
 
-+	u16 rawtempsense;
 
-+	u8 measpower;
 
-+	u8 tempsense_slope;
 
-+	u8 tempcorrx;
 
-+	u8 tempsense_option;
 
-+	u8 freqoffset_corr;
 
-+	u8 iqcal_swp_dis;
 
-+	u8 hw_iqcal_en;
 
-+	u8 elna2g;
 
-+	u8 elna5g;
 
-+	u8 phycal_tempdelta;
 
-+	u8 temps_period;
 
-+	u8 temps_hysteresis;
 
-+	u8 measpower1;
 
-+	u8 measpower2;
 
-+	u8 pcieingress_war;
 
-+
 
-+	/* power per rate from sromrev 9 */
 
-+	u16 cckbw202gpo;
 
-+	u16 cckbw20ul2gpo;
 
-+	u32 legofdmbw202gpo;
 
-+	u32 legofdmbw20ul2gpo;
 
-+	u32 legofdmbw205glpo;
 
-+	u32 legofdmbw20ul5glpo;
 
-+	u32 legofdmbw205gmpo;
 
-+	u32 legofdmbw20ul5gmpo;
 
-+	u32 legofdmbw205ghpo;
 
-+	u32 legofdmbw20ul5ghpo;
 
-+	u32 mcsbw202gpo;
 
-+	u32 mcsbw20ul2gpo;
 
-+	u32 mcsbw402gpo;
 
-+	u32 mcsbw205glpo;
 
-+	u32 mcsbw20ul5glpo;
 
-+	u32 mcsbw405glpo;
 
-+	u32 mcsbw205gmpo;
 
-+	u32 mcsbw20ul5gmpo;
 
-+	u32 mcsbw405gmpo;
 
-+	u32 mcsbw205ghpo;
 
-+	u32 mcsbw20ul5ghpo;
 
-+	u32 mcsbw405ghpo;
 
-+	u16 mcs32po;
 
-+	u16 legofdm40duppo;
 
-+	u8 sar2g;
 
-+	u8 sar5g;
 
- };
 
- 
- /* Information about the PCB the circuitry is soldered on. */
 
- struct ssb_boardinfo {
 
- 	u16 vendor;
 
- 	u16 type;
 
--	u8  rev;
 
- };
 
- 
- 
-@@ -166,6 +246,7 @@ struct ssb_bus_ops {
 
- #define SSB_DEV_MINI_MACPHY	0x823
 
- #define SSB_DEV_ARM_1176	0x824
 
- #define SSB_DEV_ARM_7TDMI	0x825
 
-+#define SSB_DEV_ARM_CM3		0x82A
 
- 
- /* Vendor-ID values */
 
- #define SSB_VENDOR_BROADCOM	0x4243
 
-@@ -260,13 +341,61 @@ enum ssb_bustype {
 
- #define SSB_BOARDVENDOR_DELL	0x1028	/* Dell */
 
- #define SSB_BOARDVENDOR_HP	0x0E11	/* HP */
 
- /* board_type */
 
-+#define SSB_BOARD_BCM94301CB	0x0406
 
-+#define SSB_BOARD_BCM94301MP	0x0407
 
-+#define SSB_BOARD_BU4309	0x040A
 
-+#define SSB_BOARD_BCM94309CB	0x040B
 
-+#define SSB_BOARD_BCM4309MP	0x040C
 
-+#define SSB_BOARD_BU4306	0x0416
 
- #define SSB_BOARD_BCM94306MP	0x0418
 
- #define SSB_BOARD_BCM4309G	0x0421
 
- #define SSB_BOARD_BCM4306CB	0x0417
 
--#define SSB_BOARD_BCM4309MP	0x040C
 
-+#define SSB_BOARD_BCM94306PC	0x0425	/* pcmcia 3.3v 4306 card */
 
-+#define SSB_BOARD_BCM94306CBSG	0x042B	/* with SiGe PA */
 
-+#define SSB_BOARD_PCSG94306	0x042D	/* with SiGe PA */
 
-+#define SSB_BOARD_BU4704SD	0x042E	/* with sdram */
 
-+#define SSB_BOARD_BCM94704AGR	0x042F	/* dual 11a/11g Router */
 
-+#define SSB_BOARD_BCM94308MP	0x0430	/* 11a-only minipci */
 
-+#define SSB_BOARD_BU4318	0x0447
 
-+#define SSB_BOARD_CB4318	0x0448
 
-+#define SSB_BOARD_MPG4318	0x0449
 
- #define SSB_BOARD_MP4318	0x044A
 
--#define SSB_BOARD_BU4306	0x0416
 
--#define SSB_BOARD_BU4309	0x040A
 
-+#define SSB_BOARD_SD4318	0x044B
 
-+#define SSB_BOARD_BCM94306P	0x044C	/* with SiGe */
 
-+#define SSB_BOARD_BCM94303MP	0x044E
 
-+#define SSB_BOARD_BCM94306MPM	0x0450
 
-+#define SSB_BOARD_BCM94306MPL	0x0453
 
-+#define SSB_BOARD_PC4303	0x0454	/* pcmcia */
 
-+#define SSB_BOARD_BCM94306MPLNA	0x0457
 
-+#define SSB_BOARD_BCM94306MPH	0x045B
 
-+#define SSB_BOARD_BCM94306PCIV	0x045C
 
-+#define SSB_BOARD_BCM94318MPGH	0x0463
 
-+#define SSB_BOARD_BU4311	0x0464
 
-+#define SSB_BOARD_BCM94311MC	0x0465
 
-+#define SSB_BOARD_BCM94311MCAG	0x0466
 
-+/* 4321 boards */
 
-+#define SSB_BOARD_BU4321	0x046B
 
-+#define SSB_BOARD_BU4321E	0x047C
 
-+#define SSB_BOARD_MP4321	0x046C
 
-+#define SSB_BOARD_CB2_4321	0x046D
 
-+#define SSB_BOARD_CB2_4321_AG	0x0066
 
-+#define SSB_BOARD_MC4321	0x046E
 
-+/* 4325 boards */
 
-+#define SSB_BOARD_BCM94325DEVBU	0x0490
 
-+#define SSB_BOARD_BCM94325BGABU	0x0491
 
-+#define SSB_BOARD_BCM94325SDGWB	0x0492
 
-+#define SSB_BOARD_BCM94325SDGMDL	0x04AA
 
-+#define SSB_BOARD_BCM94325SDGMDL2	0x04C6
 
-+#define SSB_BOARD_BCM94325SDGMDL3	0x04C9
 
-+#define SSB_BOARD_BCM94325SDABGWBA	0x04E1
 
-+/* 4322 boards */
 
-+#define SSB_BOARD_BCM94322MC	0x04A4
 
-+#define SSB_BOARD_BCM94322USB	0x04A8	/* dualband */
 
-+#define SSB_BOARD_BCM94322HM	0x04B0
 
-+#define SSB_BOARD_BCM94322USB2D	0x04Bf	/* single band discrete front end */
 
-+/* 4312 boards */
 
-+#define SSB_BOARD_BU4312	0x048A
 
-+#define SSB_BOARD_BCM4312MCGSG	0x04B5
 
- /* chip_package */
 
- #define SSB_CHIPPACK_BCM4712S	1	/* Small 200pin 4712 */
 
- #define SSB_CHIPPACK_BCM4712M	2	/* Medium 225pin 4712 */
 
-@@ -354,7 +483,11 @@ struct ssb_bus {
 
- #ifdef CONFIG_SSB_EMBEDDED
 
- 	/* Lock for GPIO register access. */
 
- 	spinlock_t gpio_lock;
 
-+	struct platform_device *watchdog;
 
- #endif /* EMBEDDED */
 
-+#ifdef CONFIG_SSB_DRIVER_GPIO
 
-+	struct gpio_chip gpio;
 
-+#endif /* DRIVER_GPIO */
 
- 
- 	/* Internal-only stuff follows. Do not touch. */
 
- 	struct list_head list;
 
---- a/include/linux/ssb/ssb_driver_chipcommon.h
 
-+++ b/include/linux/ssb/ssb_driver_chipcommon.h
 
-@@ -219,6 +219,7 @@
 
- #define SSB_CHIPCO_PMU_CTL			0x0600 /* PMU control */
 
- #define  SSB_CHIPCO_PMU_CTL_ILP_DIV		0xFFFF0000 /* ILP div mask */
 
- #define  SSB_CHIPCO_PMU_CTL_ILP_DIV_SHIFT	16
 
-+#define  SSB_CHIPCO_PMU_CTL_PLL_UPD		0x00000400
 
- #define  SSB_CHIPCO_PMU_CTL_NOILPONW		0x00000200 /* No ILP on wait */
 
- #define  SSB_CHIPCO_PMU_CTL_HTREQEN		0x00000100 /* HT req enable */
 
- #define  SSB_CHIPCO_PMU_CTL_ALPREQEN		0x00000080 /* ALP req enable */
 
-@@ -504,7 +505,9 @@
 
- #define SSB_CHIPCO_FLASHCTL_ST_SE	0x02D8		/* Sector Erase */
 
- #define SSB_CHIPCO_FLASHCTL_ST_BE	0x00C7		/* Bulk Erase */
 
- #define SSB_CHIPCO_FLASHCTL_ST_DP	0x00B9		/* Deep Power-down */
 
--#define SSB_CHIPCO_FLASHCTL_ST_RSIG	0x03AB		/* Read Electronic Signature */
 
-+#define SSB_CHIPCO_FLASHCTL_ST_RES	0x03AB		/* Read Electronic Signature */
 
-+#define SSB_CHIPCO_FLASHCTL_ST_CSA	0x1000		/* Keep chip select asserted */
 
-+#define SSB_CHIPCO_FLASHCTL_ST_SSE	0x0220		/* Sub-sector Erase */
 
- 
- /* Status register bits for ST flashes */
 
- #define SSB_CHIPCO_FLASHSTA_ST_WIP	0x01		/* Write In Progress */
 
-@@ -588,7 +591,10 @@ struct ssb_chipcommon {
 
- 	u32 status;
 
- 	/* Fast Powerup Delay constant */
 
- 	u16 fast_pwrup_delay;
 
-+	spinlock_t gpio_lock;
 
- 	struct ssb_chipcommon_pmu pmu;
 
-+	u32 ticks_per_ms;
 
-+	u32 max_timer_ms;
 
- };
 
- 
- static inline bool ssb_chipco_available(struct ssb_chipcommon *cc)
 
-@@ -628,8 +634,7 @@ enum ssb_clkmode {
 
- extern void ssb_chipco_set_clockmode(struct ssb_chipcommon *cc,
 
- 				     enum ssb_clkmode mode);
 
- 
--extern void ssb_chipco_watchdog_timer_set(struct ssb_chipcommon *cc,
 
--					  u32 ticks);
 
-+extern u32 ssb_chipco_watchdog_timer_set(struct ssb_chipcommon *cc, u32 ticks);
 
- 
- void ssb_chipco_irq_mask(struct ssb_chipcommon *cc, u32 mask, u32 value);
 
- 
-@@ -642,6 +647,8 @@ u32 ssb_chipco_gpio_outen(struct ssb_chi
 
- u32 ssb_chipco_gpio_control(struct ssb_chipcommon *cc, u32 mask, u32 value);
 
- u32 ssb_chipco_gpio_intmask(struct ssb_chipcommon *cc, u32 mask, u32 value);
 
- u32 ssb_chipco_gpio_polarity(struct ssb_chipcommon *cc, u32 mask, u32 value);
 
-+u32 ssb_chipco_gpio_pullup(struct ssb_chipcommon *cc, u32 mask, u32 value);
 
-+u32 ssb_chipco_gpio_pulldown(struct ssb_chipcommon *cc, u32 mask, u32 value);
 
- 
- #ifdef CONFIG_SSB_SERIAL
 
- extern int ssb_chipco_serial_init(struct ssb_chipcommon *cc,
 
-@@ -661,5 +668,6 @@ enum ssb_pmu_ldo_volt_id {
 
- void ssb_pmu_set_ldo_voltage(struct ssb_chipcommon *cc,
 
- 			     enum ssb_pmu_ldo_volt_id id, u32 voltage);
 
- void ssb_pmu_set_ldo_paref(struct ssb_chipcommon *cc, bool on);
 
-+void ssb_pmu_spuravoid_pllupdate(struct ssb_chipcommon *cc, int spuravoid);
 
- 
- #endif /* LINUX_SSB_CHIPCO_H_ */
 
---- a/include/linux/ssb/ssb_driver_extif.h
 
-+++ b/include/linux/ssb/ssb_driver_extif.h
 
-@@ -152,12 +152,16 @@
 
- /* watchdog */
 
- #define SSB_EXTIF_WATCHDOG_CLK		48000000	/* Hz */
 
- 
-+#define SSB_EXTIF_WATCHDOG_MAX_TIMER	((1 << 28) - 1)
 
-+#define SSB_EXTIF_WATCHDOG_MAX_TIMER_MS	(SSB_EXTIF_WATCHDOG_MAX_TIMER \
 
-+					 / (SSB_EXTIF_WATCHDOG_CLK / 1000))
 
- 
- 
- #ifdef CONFIG_SSB_DRIVER_EXTIF
 
- 
- struct ssb_extif {
 
- 	struct ssb_device *dev;
 
-+	spinlock_t gpio_lock;
 
- };
 
- 
- static inline bool ssb_extif_available(struct ssb_extif *extif)
 
-@@ -171,8 +175,7 @@ extern void ssb_extif_get_clockcontrol(s
 
- extern void ssb_extif_timing_init(struct ssb_extif *extif,
 
- 				  unsigned long ns);
 
- 
--extern void ssb_extif_watchdog_timer_set(struct ssb_extif *extif,
 
--					 u32 ticks);
 
-+extern u32 ssb_extif_watchdog_timer_set(struct ssb_extif *extif, u32 ticks);
 
- 
- /* Extif GPIO pin access */
 
- u32 ssb_extif_gpio_in(struct ssb_extif *extif, u32 mask);
 
-@@ -205,10 +208,52 @@ void ssb_extif_get_clockcontrol(struct s
 
- }
 
- 
- static inline
 
--void ssb_extif_watchdog_timer_set(struct ssb_extif *extif,
 
--				  u32 ticks)
 
-+void ssb_extif_timing_init(struct ssb_extif *extif, unsigned long ns)
 
- {
 
- }
 
- 
-+static inline
 
-+u32 ssb_extif_watchdog_timer_set(struct ssb_extif *extif, u32 ticks)
 
-+{
 
-+	return 0;
 
-+}
 
-+
 
-+static inline u32 ssb_extif_gpio_in(struct ssb_extif *extif, u32 mask)
 
-+{
 
-+	return 0;
 
-+}
 
-+
 
-+static inline u32 ssb_extif_gpio_out(struct ssb_extif *extif, u32 mask,
 
-+				     u32 value)
 
-+{
 
-+	return 0;
 
-+}
 
-+
 
-+static inline u32 ssb_extif_gpio_outen(struct ssb_extif *extif, u32 mask,
 
-+				       u32 value)
 
-+{
 
-+	return 0;
 
-+}
 
-+
 
-+static inline u32 ssb_extif_gpio_polarity(struct ssb_extif *extif, u32 mask,
 
-+					  u32 value)
 
-+{
 
-+	return 0;
 
-+}
 
-+
 
-+static inline u32 ssb_extif_gpio_intmask(struct ssb_extif *extif, u32 mask,
 
-+					 u32 value)
 
-+{
 
-+	return 0;
 
-+}
 
-+
 
-+#ifdef CONFIG_SSB_SERIAL
 
-+static inline int ssb_extif_serial_init(struct ssb_extif *extif,
 
-+					struct ssb_serial_port *ports)
 
-+{
 
-+	return 0;
 
-+}
 
-+#endif /* CONFIG_SSB_SERIAL */
 
-+
 
- #endif /* CONFIG_SSB_DRIVER_EXTIF */
 
- #endif /* LINUX_SSB_EXTIFCORE_H_ */
 
---- a/include/linux/ssb/ssb_driver_gige.h
 
-+++ b/include/linux/ssb/ssb_driver_gige.h
 
-@@ -2,6 +2,7 @@
 
- #define LINUX_SSB_DRIVER_GIGE_H_
 
- 
- #include <linux/ssb/ssb.h>
 
-+#include <linux/bug.h>
 
- #include <linux/pci.h>
 
- #include <linux/spinlock.h>
 
- 
-@@ -96,21 +97,16 @@ static inline bool ssb_gige_must_flush_p
 
- 	return 0;
 
- }
 
- 
--#ifdef CONFIG_BCM47XX
 
--#include <asm/mach-bcm47xx/nvram.h>
 
- /* Get the device MAC address */
 
--static inline void ssb_gige_get_macaddr(struct pci_dev *pdev, u8 *macaddr)
 
--{
 
--	char buf[20];
 
--	if (nvram_getenv("et0macaddr", buf, sizeof(buf)) < 0)
 
--		return;
 
--	nvram_parse_macaddr(buf, macaddr);
 
--}
 
--#else
 
--static inline void ssb_gige_get_macaddr(struct pci_dev *pdev, u8 *macaddr)
 
-+static inline int ssb_gige_get_macaddr(struct pci_dev *pdev, u8 *macaddr)
 
- {
 
-+	struct ssb_gige *dev = pdev_to_ssb_gige(pdev);
 
-+	if (!dev)
 
-+		return -ENODEV;
 
-+
 
-+	memcpy(macaddr, dev->dev->bus->sprom.et0mac, 6);
 
-+	return 0;
 
- }
 
--#endif
 
- 
- extern int ssb_gige_pcibios_plat_dev_init(struct ssb_device *sdev,
 
- 					  struct pci_dev *pdev);
 
-@@ -174,6 +170,10 @@ static inline bool ssb_gige_must_flush_p
 
- {
 
- 	return 0;
 
- }
 
-+static inline int ssb_gige_get_macaddr(struct pci_dev *pdev, u8 *macaddr)
 
-+{
 
-+	return -ENODEV;
 
-+}
 
- 
- #endif /* CONFIG_SSB_DRIVER_GIGE */
 
- #endif /* LINUX_SSB_DRIVER_GIGE_H_ */
 
---- a/include/linux/ssb/ssb_driver_mips.h
 
-+++ b/include/linux/ssb/ssb_driver_mips.h
 
-@@ -13,6 +13,24 @@ struct ssb_serial_port {
 
- 	unsigned int reg_shift;
 
- };
 
- 
-+struct ssb_pflash {
 
-+	bool present;
 
-+	u8 buswidth;
 
-+	u32 window;
 
-+	u32 window_size;
 
-+};
 
-+
 
-+#ifdef CONFIG_SSB_SFLASH
 
-+struct ssb_sflash {
 
-+	bool present;
 
-+	u32 window;
 
-+	u32 blocksize;
 
-+	u16 numblocks;
 
-+	u32 size;
 
-+
 
-+	void *priv;
 
-+};
 
-+#endif
 
- 
- struct ssb_mipscore {
 
- 	struct ssb_device *dev;
 
-@@ -20,9 +38,10 @@ struct ssb_mipscore {
 
- 	int nr_serial_ports;
 
- 	struct ssb_serial_port serial_ports[4];
 
- 
--	u8 flash_buswidth;
 
--	u32 flash_window;
 
--	u32 flash_window_size;
 
-+	struct ssb_pflash pflash;
 
-+#ifdef CONFIG_SSB_SFLASH
 
-+	struct ssb_sflash sflash;
 
-+#endif
 
- };
 
- 
- extern void ssb_mipscore_init(struct ssb_mipscore *mcore);
 
-@@ -41,6 +60,11 @@ void ssb_mipscore_init(struct ssb_mipsco
 
- {
 
- }
 
- 
-+static inline unsigned int ssb_mips_irq(struct ssb_device *dev)
 
-+{
 
-+	return 0;
 
-+}
 
-+
 
- #endif /* CONFIG_SSB_DRIVER_MIPS */
 
- 
- #endif /* LINUX_SSB_MIPSCORE_H_ */
 
---- a/include/linux/ssb/ssb_regs.h
 
-+++ b/include/linux/ssb/ssb_regs.h
 
-@@ -172,6 +172,7 @@
 
- #define SSB_SPROMSIZE_WORDS_R4		220
 
- #define SSB_SPROMSIZE_BYTES_R123	(SSB_SPROMSIZE_WORDS_R123 * sizeof(u16))
 
- #define SSB_SPROMSIZE_BYTES_R4		(SSB_SPROMSIZE_WORDS_R4 * sizeof(u16))
 
-+#define SSB_SPROMSIZE_WORDS_R10		230
 
- #define SSB_SPROM_BASE1			0x1000
 
- #define SSB_SPROM_BASE31		0x0800
 
- #define SSB_SPROM_REVISION		0x007E
 
-@@ -228,6 +229,7 @@
 
- #define  SSB_SPROM1_AGAIN_BG_SHIFT	0
 
- #define  SSB_SPROM1_AGAIN_A		0xFF00	/* A-PHY */
 
- #define  SSB_SPROM1_AGAIN_A_SHIFT	8
 
-+#define SSB_SPROM1_CCODE		0x0076
 
- 
- /* SPROM Revision 2 (inherits from rev 1) */
 
- #define SSB_SPROM2_BFLHI		0x0038	/* Boardflags (high 16 bits) */
 
-@@ -267,6 +269,7 @@
 
- #define  SSB_SPROM3_OFDMGPO		0x107A	/* G-PHY OFDM Power Offset (4 bytes, BigEndian) */
 
- 
- /* SPROM Revision 4 */
 
-+#define SSB_SPROM4_BOARDREV		0x0042	/* Board revision */
 
- #define SSB_SPROM4_BFLLO		0x0044	/* Boardflags (low 16 bits) */
 
- #define SSB_SPROM4_BFLHI		0x0046  /* Board Flags Hi */
 
- #define SSB_SPROM4_BFL2LO		0x0048	/* Board flags 2 (low 16 bits) */
 
-@@ -287,11 +290,11 @@
 
- #define  SSB_SPROM4_ETHPHY_ET1A_SHIFT	5
 
- #define  SSB_SPROM4_ETHPHY_ET0M		(1<<14)	/* MDIO for enet0 */
 
- #define  SSB_SPROM4_ETHPHY_ET1M		(1<<15)	/* MDIO for enet1 */
 
--#define SSB_SPROM4_ANTAVAIL		0x005D  /* Antenna available bitfields */
 
--#define  SSB_SPROM4_ANTAVAIL_A		0x00FF	/* A-PHY bitfield */
 
--#define  SSB_SPROM4_ANTAVAIL_A_SHIFT	0
 
--#define  SSB_SPROM4_ANTAVAIL_BG		0xFF00	/* B-PHY and G-PHY bitfield */
 
--#define  SSB_SPROM4_ANTAVAIL_BG_SHIFT	8
 
-+#define SSB_SPROM4_ANTAVAIL		0x005C  /* Antenna available bitfields */
 
-+#define  SSB_SPROM4_ANTAVAIL_BG		0x00FF	/* B-PHY and G-PHY bitfield */
 
-+#define  SSB_SPROM4_ANTAVAIL_BG_SHIFT	0
 
-+#define  SSB_SPROM4_ANTAVAIL_A		0xFF00	/* A-PHY bitfield */
 
-+#define  SSB_SPROM4_ANTAVAIL_A_SHIFT	8
 
- #define SSB_SPROM4_AGAIN01		0x005E	/* Antenna Gain (in dBm Q5.2) */
 
- #define  SSB_SPROM4_AGAIN0		0x00FF	/* Antenna 0 */
 
- #define  SSB_SPROM4_AGAIN0_SHIFT	0
 
-@@ -389,6 +392,11 @@
 
- #define  SSB_SPROM8_GPIOB_P2		0x00FF	/* Pin 2 */
 
- #define  SSB_SPROM8_GPIOB_P3		0xFF00	/* Pin 3 */
 
- #define  SSB_SPROM8_GPIOB_P3_SHIFT	8
 
-+#define SSB_SPROM8_LEDDC		0x009A
 
-+#define  SSB_SPROM8_LEDDC_ON		0xFF00	/* oncount */
 
-+#define  SSB_SPROM8_LEDDC_ON_SHIFT	8
 
-+#define  SSB_SPROM8_LEDDC_OFF		0x00FF	/* offcount */
 
-+#define  SSB_SPROM8_LEDDC_OFF_SHIFT	0
 
- #define SSB_SPROM8_ANTAVAIL		0x009C  /* Antenna available bitfields*/
 
- #define  SSB_SPROM8_ANTAVAIL_A		0xFF00	/* A-PHY bitfield */
 
- #define  SSB_SPROM8_ANTAVAIL_A_SHIFT	8
 
-@@ -404,6 +412,13 @@
 
- #define  SSB_SPROM8_AGAIN2_SHIFT	0
 
- #define  SSB_SPROM8_AGAIN3		0xFF00	/* Antenna 3 */
 
- #define  SSB_SPROM8_AGAIN3_SHIFT	8
 
-+#define SSB_SPROM8_TXRXC		0x00A2
 
-+#define  SSB_SPROM8_TXRXC_TXCHAIN	0x000f
 
-+#define  SSB_SPROM8_TXRXC_TXCHAIN_SHIFT	0
 
-+#define  SSB_SPROM8_TXRXC_RXCHAIN	0x00f0
 
-+#define  SSB_SPROM8_TXRXC_RXCHAIN_SHIFT	4
 
-+#define  SSB_SPROM8_TXRXC_SWITCH	0xff00
 
-+#define  SSB_SPROM8_TXRXC_SWITCH_SHIFT	8
 
- #define SSB_SPROM8_RSSIPARM2G		0x00A4	/* RSSI params for 2GHz */
 
- #define  SSB_SPROM8_RSSISMF2G		0x000F
 
- #define  SSB_SPROM8_RSSISMC2G		0x00F0
 
-@@ -430,6 +445,7 @@
 
- #define  SSB_SPROM8_TRI5GH_SHIFT	8
 
- #define SSB_SPROM8_RXPO			0x00AC  /* RX power offsets */
 
- #define  SSB_SPROM8_RXPO2G		0x00FF	/* 2GHz RX power offset */
 
-+#define  SSB_SPROM8_RXPO2G_SHIFT	0
 
- #define  SSB_SPROM8_RXPO5G		0xFF00	/* 5GHz RX power offset */
 
- #define  SSB_SPROM8_RXPO5G_SHIFT	8
 
- #define SSB_SPROM8_FEM2G		0x00AE
 
-@@ -445,10 +461,71 @@
 
- #define  SSB_SROM8_FEM_ANTSWLUT		0xF800
 
- #define  SSB_SROM8_FEM_ANTSWLUT_SHIFT	11
 
- #define SSB_SPROM8_THERMAL		0x00B2
 
--#define SSB_SPROM8_MPWR_RAWTS		0x00B4
 
--#define SSB_SPROM8_TS_SLP_OPT_CORRX	0x00B6
 
--#define SSB_SPROM8_FOC_HWIQ_IQSWP	0x00B8
 
--#define SSB_SPROM8_PHYCAL_TEMPDELTA	0x00BA
 
-+#define  SSB_SPROM8_THERMAL_OFFSET	0x00ff
 
-+#define  SSB_SPROM8_THERMAL_OFFSET_SHIFT	0
 
-+#define  SSB_SPROM8_THERMAL_TRESH	0xff00
 
-+#define  SSB_SPROM8_THERMAL_TRESH_SHIFT	8
 
-+/* Temp sense related entries */
 
-+#define SSB_SPROM8_RAWTS		0x00B4
 
-+#define  SSB_SPROM8_RAWTS_RAWTEMP	0x01ff
 
-+#define  SSB_SPROM8_RAWTS_RAWTEMP_SHIFT	0
 
-+#define  SSB_SPROM8_RAWTS_MEASPOWER	0xfe00
 
-+#define  SSB_SPROM8_RAWTS_MEASPOWER_SHIFT	9
 
-+#define SSB_SPROM8_OPT_CORRX		0x00B6
 
-+#define  SSB_SPROM8_OPT_CORRX_TEMP_SLOPE	0x00ff
 
-+#define  SSB_SPROM8_OPT_CORRX_TEMP_SLOPE_SHIFT	0
 
-+#define  SSB_SPROM8_OPT_CORRX_TEMPCORRX	0xfc00
 
-+#define  SSB_SPROM8_OPT_CORRX_TEMPCORRX_SHIFT	10
 
-+#define  SSB_SPROM8_OPT_CORRX_TEMP_OPTION	0x0300
 
-+#define  SSB_SPROM8_OPT_CORRX_TEMP_OPTION_SHIFT	8
 
-+/* FOC: freiquency offset correction, HWIQ: H/W IOCAL enable, IQSWP: IQ CAL swap disable */
 
-+#define SSB_SPROM8_HWIQ_IQSWP		0x00B8
 
-+#define  SSB_SPROM8_HWIQ_IQSWP_FREQ_CORR	0x000f
 
-+#define  SSB_SPROM8_HWIQ_IQSWP_FREQ_CORR_SHIFT	0
 
-+#define  SSB_SPROM8_HWIQ_IQSWP_IQCAL_SWP	0x0010
 
-+#define  SSB_SPROM8_HWIQ_IQSWP_IQCAL_SWP_SHIFT	4
 
-+#define  SSB_SPROM8_HWIQ_IQSWP_HW_IQCAL	0x0020
 
-+#define  SSB_SPROM8_HWIQ_IQSWP_HW_IQCAL_SHIFT	5
 
-+#define SSB_SPROM8_TEMPDELTA		0x00BC
 
-+#define  SSB_SPROM8_TEMPDELTA_PHYCAL	0x00ff
 
-+#define  SSB_SPROM8_TEMPDELTA_PHYCAL_SHIFT	0
 
-+#define  SSB_SPROM8_TEMPDELTA_PERIOD	0x0f00
 
-+#define  SSB_SPROM8_TEMPDELTA_PERIOD_SHIFT	8
 
-+#define  SSB_SPROM8_TEMPDELTA_HYSTERESIS	0xf000
 
-+#define  SSB_SPROM8_TEMPDELTA_HYSTERESIS_SHIFT	12
 
-+
 
-+/* There are 4 blocks with power info sharing the same layout */
 
-+#define SSB_SROM8_PWR_INFO_CORE0	0x00C0
 
-+#define SSB_SROM8_PWR_INFO_CORE1	0x00E0
 
-+#define SSB_SROM8_PWR_INFO_CORE2	0x0100
 
-+#define SSB_SROM8_PWR_INFO_CORE3	0x0120
 
-+
 
-+#define SSB_SROM8_2G_MAXP_ITSSI		0x00
 
-+#define  SSB_SPROM8_2G_MAXP		0x00FF
 
-+#define  SSB_SPROM8_2G_ITSSI		0xFF00
 
-+#define  SSB_SPROM8_2G_ITSSI_SHIFT	8
 
-+#define SSB_SROM8_2G_PA_0		0x02	/* 2GHz power amp settings */
 
-+#define SSB_SROM8_2G_PA_1		0x04
 
-+#define SSB_SROM8_2G_PA_2		0x06
 
-+#define SSB_SROM8_5G_MAXP_ITSSI		0x08	/* 5GHz ITSSI and 5.3GHz Max Power */
 
-+#define  SSB_SPROM8_5G_MAXP		0x00FF
 
-+#define  SSB_SPROM8_5G_ITSSI		0xFF00
 
-+#define  SSB_SPROM8_5G_ITSSI_SHIFT	8
 
-+#define SSB_SPROM8_5GHL_MAXP		0x0A	/* 5.2GHz and 5.8GHz Max Power */
 
-+#define  SSB_SPROM8_5GH_MAXP		0x00FF
 
-+#define  SSB_SPROM8_5GL_MAXP		0xFF00
 
-+#define  SSB_SPROM8_5GL_MAXP_SHIFT	8
 
-+#define SSB_SROM8_5G_PA_0		0x0C	/* 5.3GHz power amp settings */
 
-+#define SSB_SROM8_5G_PA_1		0x0E
 
-+#define SSB_SROM8_5G_PA_2		0x10
 
-+#define SSB_SROM8_5GL_PA_0		0x12	/* 5.2GHz power amp settings */
 
-+#define SSB_SROM8_5GL_PA_1		0x14
 
-+#define SSB_SROM8_5GL_PA_2		0x16
 
-+#define SSB_SROM8_5GH_PA_0		0x18	/* 5.8GHz power amp settings */
 
-+#define SSB_SROM8_5GH_PA_1		0x1A
 
-+#define SSB_SROM8_5GH_PA_2		0x1C
 
-+
 
-+/* TODO: Make it deprecated */
 
- #define SSB_SPROM8_MAXP_BG		0x00C0  /* Max Power 2GHz in path 1 */
 
- #define  SSB_SPROM8_MAXP_BG_MASK	0x00FF  /* Mask for Max Power 2GHz */
 
- #define  SSB_SPROM8_ITSSI_BG		0xFF00	/* Mask for path 1 itssi_bg */
 
-@@ -473,12 +550,23 @@
 
- #define SSB_SPROM8_PA1HIB0		0x00D8	/* 5.8GHz power amp settings */
 
- #define SSB_SPROM8_PA1HIB1		0x00DA
 
- #define SSB_SPROM8_PA1HIB2		0x00DC
 
-+
 
- #define SSB_SPROM8_CCK2GPO		0x0140	/* CCK power offset */
 
- #define SSB_SPROM8_OFDM2GPO		0x0142	/* 2.4GHz OFDM power offset */
 
- #define SSB_SPROM8_OFDM5GPO		0x0146	/* 5.3GHz OFDM power offset */
 
- #define SSB_SPROM8_OFDM5GLPO		0x014A	/* 5.2GHz OFDM power offset */
 
- #define SSB_SPROM8_OFDM5GHPO		0x014E	/* 5.8GHz OFDM power offset */
 
- 
-+#define SSB_SPROM8_2G_MCSPO		0x0152
 
-+#define SSB_SPROM8_5G_MCSPO		0x0162
 
-+#define SSB_SPROM8_5GL_MCSPO		0x0172
 
-+#define SSB_SPROM8_5GH_MCSPO		0x0182
 
-+
 
-+#define SSB_SPROM8_CDDPO		0x0192
 
-+#define SSB_SPROM8_STBCPO		0x0194
 
-+#define SSB_SPROM8_BW40PO		0x0196
 
-+#define SSB_SPROM8_BWDUPPO		0x0198
 
-+
 
- /* Values for boardflags_lo read from SPROM */
 
- #define SSB_BFL_BTCOEXIST		0x0001	/* implements Bluetooth coexistance */
 
- #define SSB_BFL_PACTRL			0x0002	/* GPIO 9 controlling the PA */
 
---- /dev/null
 
-+++ b/include/linux/bcm47xx_wdt.h
 
-@@ -0,0 +1,19 @@
 
-+#ifndef LINUX_BCM47XX_WDT_H_
 
-+#define LINUX_BCM47XX_WDT_H_
 
-+
 
-+#include <linux/types.h>
 
-+
 
-+
 
-+struct bcm47xx_wdt {
 
-+	u32 (*timer_set)(struct bcm47xx_wdt *, u32);
 
-+	u32 (*timer_set_ms)(struct bcm47xx_wdt *, u32);
 
-+	u32 max_timer_ms;
 
-+
 
-+	void *driver_data;
 
-+};
 
-+
 
-+static inline void *bcm47xx_wdt_get_drvdata(struct bcm47xx_wdt *wdt)
 
-+{
 
-+	return wdt->driver_data;
 
-+}
 
-+#endif /* LINUX_BCM47XX_WDT_H_ */
 
---- a/drivers/net/wireless/b43/phy_n.c
 
-+++ b/drivers/net/wireless/b43/phy_n.c
 
-@@ -4259,7 +4259,8 @@ static void b43_nphy_pmu_spur_avoid(stru
 
- #endif
 
- #ifdef CONFIG_B43_SSB
 
- 	case B43_BUS_SSB:
 
--		/* FIXME */
 
-+		ssb_pmu_spuravoid_pllupdate(&dev->dev->sdev->bus->chipco,
 
-+					    avoid);
 
- 		break;
 
- #endif
 
- 	}

+ 0 - 5794
target/linux/generic/patches-3.3/025-bcma_backport.patch
View File 

@@ -1,5794 +0,0 @@
 
---- a/arch/mips/bcm47xx/serial.c
 
-+++ b/arch/mips/bcm47xx/serial.c
 
-@@ -62,7 +62,7 @@ static int __init uart8250_init_bcma(voi
 
- 
- 		p->mapbase = (unsigned int) bcma_port->regs;
 
- 		p->membase = (void *) bcma_port->regs;
 
--		p->irq = bcma_port->irq + 2;
 
-+		p->irq = bcma_port->irq;
 
- 		p->uartclk = bcma_port->baud_base;
 
- 		p->regshift = bcma_port->reg_shift;
 
- 		p->iotype = UPIO_MEM;
 
---- a/drivers/bcma/Kconfig
 
-+++ b/drivers/bcma/Kconfig
 
-@@ -26,16 +26,23 @@ config BCMA_HOST_PCI_POSSIBLE
 
- config BCMA_HOST_PCI
 
- 	bool "Support for BCMA on PCI-host bus"
 
- 	depends on BCMA_HOST_PCI_POSSIBLE
 
-+	default y
 
- 
- config BCMA_DRIVER_PCI_HOSTMODE
 
- 	bool "Driver for PCI core working in hostmode"
 
--	depends on BCMA && MIPS
 
-+	depends on BCMA && MIPS && BCMA_HOST_PCI
 
- 	help
 
- 	  PCI core hostmode operation (external PCI bus).
 
- 
- config BCMA_HOST_SOC
 
--	bool
 
--	depends on BCMA_DRIVER_MIPS
 
-+	bool "Support for BCMA in a SoC"
 
-+	depends on BCMA
 
-+	help
 
-+	  Host interface for a Broadcom AIX bus directly mapped into
 
-+	  the memory. This only works with the Broadcom SoCs from the
 
-+	  BCM47XX line.
 
-+
 
-+	  If unsure, say N
 
- 
- config BCMA_DRIVER_MIPS
 
- 	bool "BCMA Broadcom MIPS core driver"
 
-@@ -46,6 +53,33 @@ config BCMA_DRIVER_MIPS
 
- 
- 	  If unsure, say N
 
- 
-+config BCMA_SFLASH
 
-+	bool
 
-+	depends on BCMA_DRIVER_MIPS
 
-+	default y
 
-+
 
-+config BCMA_NFLASH
 
-+	bool
 
-+	depends on BCMA_DRIVER_MIPS
 
-+	default y
 
-+
 
-+config BCMA_DRIVER_GMAC_CMN
 
-+	bool "BCMA Broadcom GBIT MAC COMMON core driver"
 
-+	depends on BCMA
 
-+	help
 
-+	  Driver for the Broadcom GBIT MAC COMMON core attached to Broadcom
 
-+	  specific Advanced Microcontroller Bus.
 
-+
 
-+	  If unsure, say N
 
-+
 
-+config BCMA_DRIVER_GPIO
 
-+	bool "BCMA GPIO driver"
 
-+	depends on BCMA && GPIOLIB
 
-+	help
 
-+	  Driver to provide access to the GPIO pins of the bcma bus.
 
-+
 
-+	  If unsure, say N
 
-+
 
- config BCMA_DEBUG
 
- 	bool "BCMA debugging"
 
- 	depends on BCMA
 
---- a/drivers/bcma/Makefile
 
-+++ b/drivers/bcma/Makefile
 
-@@ -1,8 +1,12 @@
 
- bcma-y					+= main.o scan.o core.o sprom.o
 
- bcma-y					+= driver_chipcommon.o driver_chipcommon_pmu.o
 
-+bcma-$(CONFIG_BCMA_SFLASH)		+= driver_chipcommon_sflash.o
 
-+bcma-$(CONFIG_BCMA_NFLASH)		+= driver_chipcommon_nflash.o
 
- bcma-y					+= driver_pci.o
 
- bcma-$(CONFIG_BCMA_DRIVER_PCI_HOSTMODE)	+= driver_pci_host.o
 
- bcma-$(CONFIG_BCMA_DRIVER_MIPS)		+= driver_mips.o
 
-+bcma-$(CONFIG_BCMA_DRIVER_GMAC_CMN)	+= driver_gmac_cmn.o
 
-+bcma-$(CONFIG_BCMA_DRIVER_GPIO)		+= driver_gpio.o
 
- bcma-$(CONFIG_BCMA_HOST_PCI)		+= host_pci.o
 
- bcma-$(CONFIG_BCMA_HOST_SOC)		+= host_soc.o
 
- obj-$(CONFIG_BCMA)			+= bcma.o
 
---- a/drivers/bcma/bcma_private.h
 
-+++ b/drivers/bcma/bcma_private.h
 
-@@ -10,10 +10,21 @@
 
- 
- #define BCMA_CORE_SIZE		0x1000
 
- 
-+#define bcma_err(bus, fmt, ...) \
 
-+	pr_err("bus%d: " fmt, (bus)->num, ##__VA_ARGS__)
 
-+#define bcma_warn(bus, fmt, ...) \
 
-+	pr_warn("bus%d: " fmt, (bus)->num, ##__VA_ARGS__)
 
-+#define bcma_info(bus, fmt, ...) \
 
-+	pr_info("bus%d: " fmt, (bus)->num, ##__VA_ARGS__)
 
-+#define bcma_debug(bus, fmt, ...) \
 
-+	pr_debug("bus%d: " fmt, (bus)->num, ##__VA_ARGS__)
 
-+
 
- struct bcma_bus;
 
- 
- /* main.c */
 
--int bcma_bus_register(struct bcma_bus *bus);
 
-+bool bcma_wait_value(struct bcma_device *core, u16 reg, u32 mask, u32 value,
 
-+		     int timeout);
 
-+int __devinit bcma_bus_register(struct bcma_bus *bus);
 
- void bcma_bus_unregister(struct bcma_bus *bus);
 
- int __init bcma_bus_early_register(struct bcma_bus *bus,
 
- 				   struct bcma_device *core_cc,
 
-@@ -22,6 +33,8 @@ int __init bcma_bus_early_register(struc
 
- int bcma_bus_suspend(struct bcma_bus *bus);
 
- int bcma_bus_resume(struct bcma_bus *bus);
 
- #endif
 
-+struct bcma_device *bcma_find_core_unit(struct bcma_bus *bus, u16 coreid,
 
-+					u8 unit);
 
- 
- /* scan.c */
 
- int bcma_bus_scan(struct bcma_bus *bus);
 
-@@ -36,11 +49,36 @@ int bcma_sprom_get(struct bcma_bus *bus)
 
- /* driver_chipcommon.c */
 
- #ifdef CONFIG_BCMA_DRIVER_MIPS
 
- void bcma_chipco_serial_init(struct bcma_drv_cc *cc);
 
-+extern struct platform_device bcma_pflash_dev;
 
- #endif /* CONFIG_BCMA_DRIVER_MIPS */
 
- 
- /* driver_chipcommon_pmu.c */
 
--u32 bcma_pmu_alp_clock(struct bcma_drv_cc *cc);
 
--u32 bcma_pmu_get_clockcpu(struct bcma_drv_cc *cc);
 
-+u32 bcma_pmu_get_alp_clock(struct bcma_drv_cc *cc);
 
-+u32 bcma_pmu_get_cpu_clock(struct bcma_drv_cc *cc);
 
-+
 
-+#ifdef CONFIG_BCMA_SFLASH
 
-+/* driver_chipcommon_sflash.c */
 
-+int bcma_sflash_init(struct bcma_drv_cc *cc);
 
-+extern struct platform_device bcma_sflash_dev;
 
-+#else
 
-+static inline int bcma_sflash_init(struct bcma_drv_cc *cc)
 
-+{
 
-+	bcma_err(cc->core->bus, "Serial flash not supported\n");
 
-+	return 0;
 
-+}
 
-+#endif /* CONFIG_BCMA_SFLASH */
 
-+
 
-+#ifdef CONFIG_BCMA_NFLASH
 
-+/* driver_chipcommon_nflash.c */
 
-+int bcma_nflash_init(struct bcma_drv_cc *cc);
 
-+extern struct platform_device bcma_nflash_dev;
 
-+#else
 
-+static inline int bcma_nflash_init(struct bcma_drv_cc *cc)
 
-+{
 
-+	bcma_err(cc->core->bus, "NAND flash not supported\n");
 
-+	return 0;
 
-+}
 
-+#endif /* CONFIG_BCMA_NFLASH */
 
- 
- #ifdef CONFIG_BCMA_HOST_PCI
 
- /* host_pci.c */
 
-@@ -48,8 +86,29 @@ extern int __init bcma_host_pci_init(voi
 
- extern void __exit bcma_host_pci_exit(void);
 
- #endif /* CONFIG_BCMA_HOST_PCI */
 
- 
-+/* driver_pci.c */
 
-+u32 bcma_pcie_read(struct bcma_drv_pci *pc, u32 address);
 
-+
 
-+extern int bcma_chipco_watchdog_register(struct bcma_drv_cc *cc);
 
-+
 
- #ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE
 
--void bcma_core_pci_hostmode_init(struct bcma_drv_pci *pc);
 
-+bool __devinit bcma_core_pci_is_in_hostmode(struct bcma_drv_pci *pc);
 
-+void __devinit bcma_core_pci_hostmode_init(struct bcma_drv_pci *pc);
 
- #endif /* CONFIG_BCMA_DRIVER_PCI_HOSTMODE */
 
- 
-+#ifdef CONFIG_BCMA_DRIVER_GPIO
 
-+/* driver_gpio.c */
 
-+int bcma_gpio_init(struct bcma_drv_cc *cc);
 
-+int bcma_gpio_unregister(struct bcma_drv_cc *cc);
 
-+#else
 
-+static inline int bcma_gpio_init(struct bcma_drv_cc *cc)
 
-+{
 
-+	return -ENOTSUPP;
 
-+}
 
-+static inline int bcma_gpio_unregister(struct bcma_drv_cc *cc)
 
-+{
 
-+	return 0;
 
-+}
 
-+#endif /* CONFIG_BCMA_DRIVER_GPIO */
 
-+
 
- #endif
 
---- a/drivers/bcma/core.c
 
-+++ b/drivers/bcma/core.c
 
-@@ -9,6 +9,25 @@
 
- #include <linux/export.h>
 
- #include <linux/bcma/bcma.h>
 
- 
-+static bool bcma_core_wait_value(struct bcma_device *core, u16 reg, u32 mask,
 
-+				 u32 value, int timeout)
 
-+{
 
-+	unsigned long deadline = jiffies + timeout;
 
-+	u32 val;
 
-+
 
-+	do {
 
-+		val = bcma_aread32(core, reg);
 
-+		if ((val & mask) == value)
 
-+			return true;
 
-+		cpu_relax();
 
-+		udelay(10);
 
-+	} while (!time_after_eq(jiffies, deadline));
 
-+
 
-+	bcma_warn(core->bus, "Timeout waiting for register 0x%04X!\n", reg);
 
-+
 
-+	return false;
 
-+}
 
-+
 
- bool bcma_core_is_enabled(struct bcma_device *core)
 
- {
 
- 	if ((bcma_aread32(core, BCMA_IOCTL) & (BCMA_IOCTL_CLK | BCMA_IOCTL_FGC))
 
-@@ -25,12 +44,15 @@ void bcma_core_disable(struct bcma_devic
 
- 	if (bcma_aread32(core, BCMA_RESET_CTL) & BCMA_RESET_CTL_RESET)
 
- 		return;
 
- 
--	bcma_awrite32(core, BCMA_IOCTL, flags);
 
--	bcma_aread32(core, BCMA_IOCTL);
 
--	udelay(10);
 
-+	bcma_core_wait_value(core, BCMA_RESET_ST, ~0, 0, 300);
 
- 
- 	bcma_awrite32(core, BCMA_RESET_CTL, BCMA_RESET_CTL_RESET);
 
-+	bcma_aread32(core, BCMA_RESET_CTL);
 
- 	udelay(1);
 
-+
 
-+	bcma_awrite32(core, BCMA_IOCTL, flags);
 
-+	bcma_aread32(core, BCMA_IOCTL);
 
-+	udelay(10);
 
- }
 
- EXPORT_SYMBOL_GPL(bcma_core_disable);
 
- 
-@@ -42,6 +64,7 @@ int bcma_core_enable(struct bcma_device
 
- 	bcma_aread32(core, BCMA_IOCTL);
 
- 
- 	bcma_awrite32(core, BCMA_RESET_CTL, 0);
 
-+	bcma_aread32(core, BCMA_RESET_CTL);
 
- 	udelay(1);
 
- 
- 	bcma_awrite32(core, BCMA_IOCTL, (BCMA_IOCTL_CLK | flags));
 
-@@ -64,7 +87,7 @@ void bcma_core_set_clockmode(struct bcma
 
- 	switch (clkmode) {
 
- 	case BCMA_CLKMODE_FAST:
 
- 		bcma_set32(core, BCMA_CLKCTLST, BCMA_CLKCTLST_FORCEHT);
 
--		udelay(64);
 
-+		usleep_range(64, 300);
 
- 		for (i = 0; i < 1500; i++) {
 
- 			if (bcma_read32(core, BCMA_CLKCTLST) &
 
- 			    BCMA_CLKCTLST_HAVEHT) {
 
-@@ -74,10 +97,10 @@ void bcma_core_set_clockmode(struct bcma
 
- 			udelay(10);
 
- 		}
 
- 		if (i)
 
--			pr_err("HT force timeout\n");
 
-+			bcma_err(core->bus, "HT force timeout\n");
 
- 		break;
 
- 	case BCMA_CLKMODE_DYNAMIC:
 
--		pr_warn("Dynamic clockmode not supported yet!\n");
 
-+		bcma_set32(core, BCMA_CLKCTLST, ~BCMA_CLKCTLST_FORCEHT);
 
- 		break;
 
- 	}
 
- }
 
-@@ -101,9 +124,15 @@ void bcma_core_pll_ctl(struct bcma_devic
 
- 			udelay(10);
 
- 		}
 
- 		if (i)
 
--			pr_err("PLL enable timeout\n");
 
-+			bcma_err(core->bus, "PLL enable timeout\n");
 
- 	} else {
 
--		pr_warn("Disabling PLL not supported yet!\n");
 
-+		/*
 
-+		 * Mask the PLL but don't wait for it to be disabled. PLL may be
 
-+		 * shared between cores and will be still up if there is another
 
-+		 * core using it.
 
-+		 */
 
-+		bcma_mask32(core, BCMA_CLKCTLST, ~req);
 
-+		bcma_read32(core, BCMA_CLKCTLST);
 
- 	}
 
- }
 
- EXPORT_SYMBOL_GPL(bcma_core_pll_ctl);
 
-@@ -119,8 +148,8 @@ u32 bcma_core_dma_translation(struct bcm
 
- 		else
 
- 			return BCMA_DMA_TRANSLATION_DMA32_CMT;
 
- 	default:
 
--		pr_err("DMA translation unknown for host %d\n",
 
--		       core->bus->hosttype);
 
-+		bcma_err(core->bus, "DMA translation unknown for host %d\n",
 
-+			 core->bus->hosttype);
 
- 	}
 
- 	return BCMA_DMA_TRANSLATION_NONE;
 
- }
 
---- a/drivers/bcma/driver_chipcommon.c
 
-+++ b/drivers/bcma/driver_chipcommon.c
 
-@@ -4,12 +4,15 @@
 
-  *
 
-  * Copyright 2005, Broadcom Corporation
 
-  * Copyright 2006, 2007, Michael Buesch <[email protected]>
 
-+ * Copyright 2012, Hauke Mehrtens <[email protected]>
 
-  *
 
-  * Licensed under the GNU/GPL. See COPYING for details.
 
-  */
 
- 
- #include "bcma_private.h"
 
-+#include <linux/bcm47xx_wdt.h>
 
- #include <linux/export.h>
 
-+#include <linux/platform_device.h>
 
- #include <linux/bcma/bcma.h>
 
- 
- static inline u32 bcma_cc_write32_masked(struct bcma_drv_cc *cc, u16 offset,
 
-@@ -22,29 +25,136 @@ static inline u32 bcma_cc_write32_masked
 
- 	return value;
 
- }
 
- 
--void bcma_core_chipcommon_init(struct bcma_drv_cc *cc)
 
-+u32 bcma_chipco_get_alp_clock(struct bcma_drv_cc *cc)
 
- {
 
--	u32 leddc_on = 10;
 
--	u32 leddc_off = 90;
 
-+	if (cc->capabilities & BCMA_CC_CAP_PMU)
 
-+		return bcma_pmu_get_alp_clock(cc);
 
- 
--	if (cc->setup_done)
 
-+	return 20000000;
 
-+}
 
-+EXPORT_SYMBOL_GPL(bcma_chipco_get_alp_clock);
 
-+
 
-+static u32 bcma_chipco_watchdog_get_max_timer(struct bcma_drv_cc *cc)
 
-+{
 
-+	struct bcma_bus *bus = cc->core->bus;
 
-+	u32 nb;
 
-+
 
-+	if (cc->capabilities & BCMA_CC_CAP_PMU) {
 
-+		if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4706)
 
-+			nb = 32;
 
-+		else if (cc->core->id.rev < 26)
 
-+			nb = 16;
 
-+		else
 
-+			nb = (cc->core->id.rev >= 37) ? 32 : 24;
 
-+	} else {
 
-+		nb = 28;
 
-+	}
 
-+	if (nb == 32)
 
-+		return 0xffffffff;
 
-+	else
 
-+		return (1 << nb) - 1;
 
-+}
 
-+
 
-+static u32 bcma_chipco_watchdog_timer_set_wdt(struct bcm47xx_wdt *wdt,
 
-+					      u32 ticks)
 
-+{
 
-+	struct bcma_drv_cc *cc = bcm47xx_wdt_get_drvdata(wdt);
 
-+
 
-+	return bcma_chipco_watchdog_timer_set(cc, ticks);
 
-+}
 
-+
 
-+static u32 bcma_chipco_watchdog_timer_set_ms_wdt(struct bcm47xx_wdt *wdt,
 
-+						 u32 ms)
 
-+{
 
-+	struct bcma_drv_cc *cc = bcm47xx_wdt_get_drvdata(wdt);
 
-+	u32 ticks;
 
-+
 
-+	ticks = bcma_chipco_watchdog_timer_set(cc, cc->ticks_per_ms * ms);
 
-+	return ticks / cc->ticks_per_ms;
 
-+}
 
-+
 
-+static int bcma_chipco_watchdog_ticks_per_ms(struct bcma_drv_cc *cc)
 
-+{
 
-+	struct bcma_bus *bus = cc->core->bus;
 
-+
 
-+	if (cc->capabilities & BCMA_CC_CAP_PMU) {
 
-+		if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4706)
 
-+			/* 4706 CC and PMU watchdogs are clocked at 1/4 of ALP clock */
 
-+			return bcma_chipco_get_alp_clock(cc) / 4000;
 
-+		else
 
-+			/* based on 32KHz ILP clock */
 
-+			return 32;
 
-+	} else {
 
-+		return bcma_chipco_get_alp_clock(cc) / 1000;
 
-+	}
 
-+}
 
-+
 
-+int bcma_chipco_watchdog_register(struct bcma_drv_cc *cc)
 
-+{
 
-+	struct bcm47xx_wdt wdt = {};
 
-+	struct platform_device *pdev;
 
-+
 
-+	wdt.driver_data = cc;
 
-+	wdt.timer_set = bcma_chipco_watchdog_timer_set_wdt;
 
-+	wdt.timer_set_ms = bcma_chipco_watchdog_timer_set_ms_wdt;
 
-+	wdt.max_timer_ms = bcma_chipco_watchdog_get_max_timer(cc) / cc->ticks_per_ms;
 
-+
 
-+	pdev = platform_device_register_data(NULL, "bcm47xx-wdt",
 
-+					     cc->core->bus->num, &wdt,
 
-+					     sizeof(wdt));
 
-+	if (IS_ERR(pdev))
 
-+		return PTR_ERR(pdev);
 
-+
 
-+	cc->watchdog = pdev;
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+void bcma_core_chipcommon_early_init(struct bcma_drv_cc *cc)
 
-+{
 
-+	if (cc->early_setup_done)
 
- 		return;
 
- 
-+	spin_lock_init(&cc->gpio_lock);
 
-+
 
- 	if (cc->core->id.rev >= 11)
 
- 		cc->status = bcma_cc_read32(cc, BCMA_CC_CHIPSTAT);
 
- 	cc->capabilities = bcma_cc_read32(cc, BCMA_CC_CAP);
 
- 	if (cc->core->id.rev >= 35)
 
- 		cc->capabilities_ext = bcma_cc_read32(cc, BCMA_CC_CAP_EXT);
 
- 
-+	if (cc->capabilities & BCMA_CC_CAP_PMU)
 
-+		bcma_pmu_early_init(cc);
 
-+
 
-+	cc->early_setup_done = true;
 
-+}
 
-+
 
-+void bcma_core_chipcommon_init(struct bcma_drv_cc *cc)
 
-+{
 
-+	u32 leddc_on = 10;
 
-+	u32 leddc_off = 90;
 
-+
 
-+	if (cc->setup_done)
 
-+		return;
 
-+
 
-+	bcma_core_chipcommon_early_init(cc);
 
-+
 
- 	if (cc->core->id.rev >= 20) {
 
--		bcma_cc_write32(cc, BCMA_CC_GPIOPULLUP, 0);
 
--		bcma_cc_write32(cc, BCMA_CC_GPIOPULLDOWN, 0);
 
-+		u32 pullup = 0, pulldown = 0;
 
-+
 
-+		if (cc->core->bus->chipinfo.id == BCMA_CHIP_ID_BCM43142) {
 
-+			pullup = 0x402e0;
 
-+			pulldown = 0x20500;
 
-+		}
 
-+
 
-+		bcma_cc_write32(cc, BCMA_CC_GPIOPULLUP, pullup);
 
-+		bcma_cc_write32(cc, BCMA_CC_GPIOPULLDOWN, pulldown);
 
- 	}
 
- 
- 	if (cc->capabilities & BCMA_CC_CAP_PMU)
 
- 		bcma_pmu_init(cc);
 
- 	if (cc->capabilities & BCMA_CC_CAP_PCTL)
 
--		pr_err("Power control not implemented!\n");
 
-+		bcma_err(cc->core->bus, "Power control not implemented!\n");
 
- 
- 	if (cc->core->id.rev >= 16) {
 
- 		if (cc->core->bus->sprom.leddc_on_time &&
 
-@@ -56,15 +166,33 @@ void bcma_core_chipcommon_init(struct bc
 
- 			((leddc_on << BCMA_CC_GPIOTIMER_ONTIME_SHIFT) |
 
- 			 (leddc_off << BCMA_CC_GPIOTIMER_OFFTIME_SHIFT)));
 
- 	}
 
-+	cc->ticks_per_ms = bcma_chipco_watchdog_ticks_per_ms(cc);
 
- 
- 	cc->setup_done = true;
 
- }
 
- 
- /* Set chip watchdog reset timer to fire in 'ticks' backplane cycles */
 
--void bcma_chipco_watchdog_timer_set(struct bcma_drv_cc *cc, u32 ticks)
 
-+u32 bcma_chipco_watchdog_timer_set(struct bcma_drv_cc *cc, u32 ticks)
 
- {
 
--	/* instant NMI */
 
--	bcma_cc_write32(cc, BCMA_CC_WATCHDOG, ticks);
 
-+	u32 maxt;
 
-+	enum bcma_clkmode clkmode;
 
-+
 
-+	maxt = bcma_chipco_watchdog_get_max_timer(cc);
 
-+	if (cc->capabilities & BCMA_CC_CAP_PMU) {
 
-+		if (ticks == 1)
 
-+			ticks = 2;
 
-+		else if (ticks > maxt)
 
-+			ticks = maxt;
 
-+		bcma_cc_write32(cc, BCMA_CC_PMU_WATCHDOG, ticks);
 
-+	} else {
 
-+		clkmode = ticks ? BCMA_CLKMODE_FAST : BCMA_CLKMODE_DYNAMIC;
 
-+		bcma_core_set_clockmode(cc->core, clkmode);
 
-+		if (ticks > maxt)
 
-+			ticks = maxt;
 
-+		/* instant NMI */
 
-+		bcma_cc_write32(cc, BCMA_CC_WATCHDOG, ticks);
 
-+	}
 
-+	return ticks;
 
- }
 
- 
- void bcma_chipco_irq_mask(struct bcma_drv_cc *cc, u32 mask, u32 value)
 
-@@ -84,28 +212,99 @@ u32 bcma_chipco_gpio_in(struct bcma_drv_
 
- 
- u32 bcma_chipco_gpio_out(struct bcma_drv_cc *cc, u32 mask, u32 value)
 
- {
 
--	return bcma_cc_write32_masked(cc, BCMA_CC_GPIOOUT, mask, value);
 
-+	unsigned long flags;
 
-+	u32 res;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = bcma_cc_write32_masked(cc, BCMA_CC_GPIOOUT, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
-+EXPORT_SYMBOL_GPL(bcma_chipco_gpio_out);
 
- 
- u32 bcma_chipco_gpio_outen(struct bcma_drv_cc *cc, u32 mask, u32 value)
 
- {
 
--	return bcma_cc_write32_masked(cc, BCMA_CC_GPIOOUTEN, mask, value);
 
-+	unsigned long flags;
 
-+	u32 res;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = bcma_cc_write32_masked(cc, BCMA_CC_GPIOOUTEN, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
-+EXPORT_SYMBOL_GPL(bcma_chipco_gpio_outen);
 
- 
-+/*
 
-+ * If the bit is set to 0, chipcommon controlls this GPIO,
 
-+ * if the bit is set to 1, it is used by some part of the chip and not our code.
 
-+ */
 
- u32 bcma_chipco_gpio_control(struct bcma_drv_cc *cc, u32 mask, u32 value)
 
- {
 
--	return bcma_cc_write32_masked(cc, BCMA_CC_GPIOCTL, mask, value);
 
-+	unsigned long flags;
 
-+	u32 res;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = bcma_cc_write32_masked(cc, BCMA_CC_GPIOCTL, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
- EXPORT_SYMBOL_GPL(bcma_chipco_gpio_control);
 
- 
- u32 bcma_chipco_gpio_intmask(struct bcma_drv_cc *cc, u32 mask, u32 value)
 
- {
 
--	return bcma_cc_write32_masked(cc, BCMA_CC_GPIOIRQ, mask, value);
 
-+	unsigned long flags;
 
-+	u32 res;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = bcma_cc_write32_masked(cc, BCMA_CC_GPIOIRQ, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
- 
- u32 bcma_chipco_gpio_polarity(struct bcma_drv_cc *cc, u32 mask, u32 value)
 
- {
 
--	return bcma_cc_write32_masked(cc, BCMA_CC_GPIOPOL, mask, value);
 
-+	unsigned long flags;
 
-+	u32 res;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = bcma_cc_write32_masked(cc, BCMA_CC_GPIOPOL, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
-+}
 
-+
 
-+u32 bcma_chipco_gpio_pullup(struct bcma_drv_cc *cc, u32 mask, u32 value)
 
-+{
 
-+	unsigned long flags;
 
-+	u32 res;
 
-+
 
-+	if (cc->core->id.rev < 20)
 
-+		return 0;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = bcma_cc_write32_masked(cc, BCMA_CC_GPIOPULLUP, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
-+}
 
-+
 
-+u32 bcma_chipco_gpio_pulldown(struct bcma_drv_cc *cc, u32 mask, u32 value)
 
-+{
 
-+	unsigned long flags;
 
-+	u32 res;
 
-+
 
-+	if (cc->core->id.rev < 20)
 
-+		return 0;
 
-+
 
-+	spin_lock_irqsave(&cc->gpio_lock, flags);
 
-+	res = bcma_cc_write32_masked(cc, BCMA_CC_GPIOPULLDOWN, mask, value);
 
-+	spin_unlock_irqrestore(&cc->gpio_lock, flags);
 
-+
 
-+	return res;
 
- }
 
- 
- #ifdef CONFIG_BCMA_DRIVER_MIPS
 
-@@ -118,8 +317,7 @@ void bcma_chipco_serial_init(struct bcma
 
- 	struct bcma_serial_port *ports = cc->serial_ports;
 
- 
- 	if (ccrev >= 11 && ccrev != 15) {
 
--		/* Fixed ALP clock */
 
--		baud_base = bcma_pmu_alp_clock(cc);
 
-+		baud_base = bcma_chipco_get_alp_clock(cc);
 
- 		if (ccrev >= 21) {
 
- 			/* Turn off UART clock before switching clocksource. */
 
- 			bcma_cc_write32(cc, BCMA_CC_CORECTL,
 
-@@ -137,12 +335,11 @@ void bcma_chipco_serial_init(struct bcma
 
- 				       | BCMA_CC_CORECTL_UARTCLKEN);
 
- 		}
 
- 	} else {
 
--		pr_err("serial not supported on this device ccrev: 0x%x\n",
 
--		       ccrev);
 
-+		bcma_err(cc->core->bus, "serial not supported on this device ccrev: 0x%x\n", ccrev);
 
- 		return;
 
- 	}
 
- 
--	irq = bcma_core_mips_irq(cc->core);
 
-+	irq = bcma_core_irq(cc->core);
 
- 
- 	/* Determine the registers of the UARTs */
 
- 	cc->nr_serial_ports = (cc->capabilities & BCMA_CC_CAP_NRUART);
 
---- /dev/null
 
-+++ b/drivers/bcma/driver_chipcommon_nflash.c
 
-@@ -0,0 +1,44 @@
 
-+/*
 
-+ * Broadcom specific AMBA
 
-+ * ChipCommon NAND flash interface
 
-+ *
 
-+ * Licensed under the GNU/GPL. See COPYING for details.
 
-+ */
 
-+
 
-+#include "bcma_private.h"
 
-+
 
-+#include <linux/platform_device.h>
 
-+#include <linux/bcma/bcma.h>
 
-+
 
-+struct platform_device bcma_nflash_dev = {
 
-+	.name		= "bcma_nflash",
 
-+	.num_resources	= 0,
 
-+};
 
-+
 
-+/* Initialize NAND flash access */
 
-+int bcma_nflash_init(struct bcma_drv_cc *cc)
 
-+{
 
-+	struct bcma_bus *bus = cc->core->bus;
 
-+
 
-+	if (bus->chipinfo.id != BCMA_CHIP_ID_BCM4706 &&
 
-+	    cc->core->id.rev != 38) {
 
-+		bcma_err(bus, "NAND flash on unsupported board!\n");
 
-+		return -ENOTSUPP;
 
-+	}
 
-+
 
-+	if (!(cc->capabilities & BCMA_CC_CAP_NFLASH)) {
 
-+		bcma_err(bus, "NAND flash not present according to ChipCommon\n");
 
-+		return -ENODEV;
 
-+	}
 
-+
 
-+	cc->nflash.present = true;
 
-+	if (cc->core->id.rev == 38 &&
 
-+	    (cc->status & BCMA_CC_CHIPST_5357_NAND_BOOT))
 
-+		cc->nflash.boot = true;
 
-+
 
-+	/* Prepare platform device, but don't register it yet. It's too early,
 
-+	 * malloc (required by device_private_init) is not available yet. */
 
-+	bcma_nflash_dev.dev.platform_data = &cc->nflash;
 
-+
 
-+	return 0;
 
-+}
 
---- a/drivers/bcma/driver_chipcommon_pmu.c
 
-+++ b/drivers/bcma/driver_chipcommon_pmu.c
 
-@@ -3,7 +3,8 @@
 
-  * ChipCommon Power Management Unit driver
 
-  *
 
-  * Copyright 2009, Michael Buesch <[email protected]>
 
-- * Copyright 2007, Broadcom Corporation
 
-+ * Copyright 2007, 2011, Broadcom Corporation
 
-+ * Copyright 2011, 2012, Hauke Mehrtens <[email protected]>
 
-  *
 
-  * Licensed under the GNU/GPL. See COPYING for details.
 
-  */
 
-@@ -12,12 +13,13 @@
 
- #include <linux/export.h>
 
- #include <linux/bcma/bcma.h>
 
- 
--static u32 bcma_chipco_pll_read(struct bcma_drv_cc *cc, u32 offset)
 
-+u32 bcma_chipco_pll_read(struct bcma_drv_cc *cc, u32 offset)
 
- {
 
- 	bcma_cc_write32(cc, BCMA_CC_PLLCTL_ADDR, offset);
 
- 	bcma_cc_read32(cc, BCMA_CC_PLLCTL_ADDR);
 
- 	return bcma_cc_read32(cc, BCMA_CC_PLLCTL_DATA);
 
- }
 
-+EXPORT_SYMBOL_GPL(bcma_chipco_pll_read);
 
- 
- void bcma_chipco_pll_write(struct bcma_drv_cc *cc, u32 offset, u32 value)
 
- {
 
-@@ -54,19 +56,106 @@ void bcma_chipco_regctl_maskset(struct b
 
- }
 
- EXPORT_SYMBOL_GPL(bcma_chipco_regctl_maskset);
 
- 
-+static u32 bcma_pmu_xtalfreq(struct bcma_drv_cc *cc)
 
-+{
 
-+	u32 ilp_ctl, alp_hz;
 
-+
 
-+	if (!(bcma_cc_read32(cc, BCMA_CC_PMU_STAT) &
 
-+	      BCMA_CC_PMU_STAT_EXT_LPO_AVAIL))
 
-+		return 0;
 
-+
 
-+	bcma_cc_write32(cc, BCMA_CC_PMU_XTAL_FREQ,
 
-+			BIT(BCMA_CC_PMU_XTAL_FREQ_MEASURE_SHIFT));
 
-+	usleep_range(1000, 2000);
 
-+
 
-+	ilp_ctl = bcma_cc_read32(cc, BCMA_CC_PMU_XTAL_FREQ);
 
-+	ilp_ctl &= BCMA_CC_PMU_XTAL_FREQ_ILPCTL_MASK;
 
-+
 
-+	bcma_cc_write32(cc, BCMA_CC_PMU_XTAL_FREQ, 0);
 
-+
 
-+	alp_hz = ilp_ctl * 32768 / 4;
 
-+	return (alp_hz + 50000) / 100000 * 100;
 
-+}
 
-+
 
-+static void bcma_pmu2_pll_init0(struct bcma_drv_cc *cc, u32 xtalfreq)
 
-+{
 
-+	struct bcma_bus *bus = cc->core->bus;
 
-+	u32 freq_tgt_target = 0, freq_tgt_current;
 
-+	u32 pll0, mask;
 
-+
 
-+	switch (bus->chipinfo.id) {
 
-+	case BCMA_CHIP_ID_BCM43142:
 
-+		/* pmu2_xtaltab0_adfll_485 */
 
-+		switch (xtalfreq) {
 
-+		case 12000:
 
-+			freq_tgt_target = 0x50D52;
 
-+			break;
 
-+		case 20000:
 
-+			freq_tgt_target = 0x307FE;
 
-+			break;
 
-+		case 26000:
 
-+			freq_tgt_target = 0x254EA;
 
-+			break;
 
-+		case 37400:
 
-+			freq_tgt_target = 0x19EF8;
 
-+			break;
 
-+		case 52000:
 
-+			freq_tgt_target = 0x12A75;
 
-+			break;
 
-+		}
 
-+		break;
 
-+	}
 
-+
 
-+	if (!freq_tgt_target) {
 
-+		bcma_err(bus, "Unknown TGT frequency for xtalfreq %d\n",
 
-+			 xtalfreq);
 
-+		return;
 
-+	}
 
-+
 
-+	pll0 = bcma_chipco_pll_read(cc, BCMA_CC_PMU15_PLL_PLLCTL0);
 
-+	freq_tgt_current = (pll0 & BCMA_CC_PMU15_PLL_PC0_FREQTGT_MASK) >>
 
-+		BCMA_CC_PMU15_PLL_PC0_FREQTGT_SHIFT;
 
-+
 
-+	if (freq_tgt_current == freq_tgt_target) {
 
-+		bcma_debug(bus, "Target TGT frequency already set\n");
 
-+		return;
 
-+	}
 
-+
 
-+	/* Turn off PLL */
 
-+	switch (bus->chipinfo.id) {
 
-+	case BCMA_CHIP_ID_BCM43142:
 
-+		mask = (u32)~(BCMA_RES_4314_HT_AVAIL |
 
-+			      BCMA_RES_4314_MACPHY_CLK_AVAIL);
 
-+
 
-+		bcma_cc_mask32(cc, BCMA_CC_PMU_MINRES_MSK, mask);
 
-+		bcma_cc_mask32(cc, BCMA_CC_PMU_MAXRES_MSK, mask);
 
-+		bcma_wait_value(cc->core, BCMA_CLKCTLST,
 
-+				BCMA_CLKCTLST_HAVEHT, 0, 20000);
 
-+		break;
 
-+	}
 
-+
 
-+	pll0 &= ~BCMA_CC_PMU15_PLL_PC0_FREQTGT_MASK;
 
-+	pll0 |= freq_tgt_target << BCMA_CC_PMU15_PLL_PC0_FREQTGT_SHIFT;
 
-+	bcma_chipco_pll_write(cc, BCMA_CC_PMU15_PLL_PLLCTL0, pll0);
 
-+
 
-+	/* Flush */
 
-+	if (cc->pmu.rev >= 2)
 
-+		bcma_cc_set32(cc, BCMA_CC_PMU_CTL, BCMA_CC_PMU_CTL_PLL_UPD);
 
-+
 
-+	/* TODO: Do we need to update OTP? */
 
-+}
 
-+
 
- static void bcma_pmu_pll_init(struct bcma_drv_cc *cc)
 
- {
 
- 	struct bcma_bus *bus = cc->core->bus;
 
-+	u32 xtalfreq = bcma_pmu_xtalfreq(cc);
 
- 
- 	switch (bus->chipinfo.id) {
 
--	case 0x4313:
 
--	case 0x4331:
 
--	case 43224:
 
--	case 43225:
 
-+	case BCMA_CHIP_ID_BCM43142:
 
-+		if (xtalfreq == 0)
 
-+			xtalfreq = 20000;
 
-+		bcma_pmu2_pll_init0(cc, xtalfreq);
 
- 		break;
 
--	default:
 
--		pr_err("PLL init unknown for device 0x%04X\n",
 
--			bus->chipinfo.id);
 
- 	}
 
- }
 
- 
-@@ -76,16 +165,32 @@ static void bcma_pmu_resources_init(stru
 
- 	u32 min_msk = 0, max_msk = 0;
 
- 
- 	switch (bus->chipinfo.id) {
 
--	case 0x4313:
 
-+	case BCMA_CHIP_ID_BCM4313:
 
- 		min_msk = 0x200D;
 
- 		max_msk = 0xFFFF;
 
- 		break;
 
--	case 43224:
 
--	case 43225:
 
-+	case BCMA_CHIP_ID_BCM43142:
 
-+		min_msk = BCMA_RES_4314_LPLDO_PU |
 
-+			  BCMA_RES_4314_PMU_SLEEP_DIS |
 
-+			  BCMA_RES_4314_PMU_BG_PU |
 
-+			  BCMA_RES_4314_CBUCK_LPOM_PU |
 
-+			  BCMA_RES_4314_CBUCK_PFM_PU |
 
-+			  BCMA_RES_4314_CLDO_PU |
 
-+			  BCMA_RES_4314_LPLDO2_LVM |
 
-+			  BCMA_RES_4314_WL_PMU_PU |
 
-+			  BCMA_RES_4314_LDO3P3_PU |
 
-+			  BCMA_RES_4314_OTP_PU |
 
-+			  BCMA_RES_4314_WL_PWRSW_PU |
 
-+			  BCMA_RES_4314_LQ_AVAIL |
 
-+			  BCMA_RES_4314_LOGIC_RET |
 
-+			  BCMA_RES_4314_MEM_SLEEP |
 
-+			  BCMA_RES_4314_MACPHY_RET |
 
-+			  BCMA_RES_4314_WL_CORE_READY;
 
-+		max_msk = 0x3FFFFFFF;
 
- 		break;
 
- 	default:
 
--		pr_err("PMU resource config unknown for device 0x%04X\n",
 
--			bus->chipinfo.id);
 
-+		bcma_debug(bus, "PMU resource config unknown or not needed for device 0x%04X\n",
 
-+			   bus->chipinfo.id);
 
- 	}
 
- 
- 	/* Set the resource masks. */
 
-@@ -93,22 +198,12 @@ static void bcma_pmu_resources_init(stru
 
- 		bcma_cc_write32(cc, BCMA_CC_PMU_MINRES_MSK, min_msk);
 
- 	if (max_msk)
 
- 		bcma_cc_write32(cc, BCMA_CC_PMU_MAXRES_MSK, max_msk);
 
--}
 
- 
--void bcma_pmu_swreg_init(struct bcma_drv_cc *cc)
 
--{
 
--	struct bcma_bus *bus = cc->core->bus;
 
--
 
--	switch (bus->chipinfo.id) {
 
--	case 0x4313:
 
--	case 0x4331:
 
--	case 43224:
 
--	case 43225:
 
--		break;
 
--	default:
 
--		pr_err("PMU switch/regulators init unknown for device "
 
--			"0x%04X\n", bus->chipinfo.id);
 
--	}
 
-+	/*
 
-+	 * Add some delay; allow resources to come up and settle.
 
-+	 * Delay is required for SoC (early init).
 
-+	 */
 
-+	mdelay(2);
 
- }
 
- 
- /* Disable to allow reading SPROM. Don't know the adventages of enabling it. */
 
-@@ -122,51 +217,69 @@ void bcma_chipco_bcm4331_ext_pa_lines_ct
 
- 		val |= BCMA_CHIPCTL_4331_EXTPA_EN;
 
- 		if (bus->chipinfo.pkg == 9 || bus->chipinfo.pkg == 11)
 
- 			val |= BCMA_CHIPCTL_4331_EXTPA_ON_GPIO2_5;
 
-+		else if (bus->chipinfo.rev > 0)
 
-+			val |= BCMA_CHIPCTL_4331_EXTPA_EN2;
 
- 	} else {
 
- 		val &= ~BCMA_CHIPCTL_4331_EXTPA_EN;
 
-+		val &= ~BCMA_CHIPCTL_4331_EXTPA_EN2;
 
- 		val &= ~BCMA_CHIPCTL_4331_EXTPA_ON_GPIO2_5;
 
- 	}
 
- 	bcma_cc_write32(cc, BCMA_CC_CHIPCTL, val);
 
- }
 
- 
--void bcma_pmu_workarounds(struct bcma_drv_cc *cc)
 
-+static void bcma_pmu_workarounds(struct bcma_drv_cc *cc)
 
- {
 
- 	struct bcma_bus *bus = cc->core->bus;
 
- 
- 	switch (bus->chipinfo.id) {
 
--	case 0x4313:
 
--		bcma_chipco_chipctl_maskset(cc, 0, ~0, 0x7);
 
-+	case BCMA_CHIP_ID_BCM4313:
 
-+		/* enable 12 mA drive strenth for 4313 and set chipControl
 
-+		   register bit 1 */
 
-+		bcma_chipco_chipctl_maskset(cc, 0,
 
-+					    ~BCMA_CCTRL_4313_12MA_LED_DRIVE,
 
-+					    BCMA_CCTRL_4313_12MA_LED_DRIVE);
 
- 		break;
 
--	case 0x4331:
 
--		/* BCM4331 workaround is SPROM-related, we put it in sprom.c */
 
-+	case BCMA_CHIP_ID_BCM4331:
 
-+	case BCMA_CHIP_ID_BCM43431:
 
-+		/* Ext PA lines must be enabled for tx on BCM4331 */
 
-+		bcma_chipco_bcm4331_ext_pa_lines_ctl(cc, true);
 
- 		break;
 
--	case 43224:
 
-+	case BCMA_CHIP_ID_BCM43224:
 
-+	case BCMA_CHIP_ID_BCM43421:
 
-+		/* enable 12 mA drive strenth for 43224 and set chipControl
 
-+		   register bit 15 */
 
- 		if (bus->chipinfo.rev == 0) {
 
--			pr_err("Workarounds for 43224 rev 0 not fully "
 
--				"implemented\n");
 
--			bcma_chipco_chipctl_maskset(cc, 0, ~0, 0x00F000F0);
 
-+			bcma_cc_maskset32(cc, BCMA_CC_CHIPCTL,
 
-+					  ~BCMA_CCTRL_43224_GPIO_TOGGLE,
 
-+					  BCMA_CCTRL_43224_GPIO_TOGGLE);
 
-+			bcma_chipco_chipctl_maskset(cc, 0,
 
-+						    ~BCMA_CCTRL_43224A0_12MA_LED_DRIVE,
 
-+						    BCMA_CCTRL_43224A0_12MA_LED_DRIVE);
 
- 		} else {
 
--			bcma_chipco_chipctl_maskset(cc, 0, ~0, 0xF0);
 
-+			bcma_chipco_chipctl_maskset(cc, 0,
 
-+						    ~BCMA_CCTRL_43224B0_12MA_LED_DRIVE,
 
-+						    BCMA_CCTRL_43224B0_12MA_LED_DRIVE);
 
- 		}
 
- 		break;
 
--	case 43225:
 
--		break;
 
- 	default:
 
--		pr_err("Workarounds unknown for device 0x%04X\n",
 
--			bus->chipinfo.id);
 
-+		bcma_debug(bus, "Workarounds unknown or not needed for device 0x%04X\n",
 
-+			   bus->chipinfo.id);
 
- 	}
 
- }
 
- 
--void bcma_pmu_init(struct bcma_drv_cc *cc)
 
-+void bcma_pmu_early_init(struct bcma_drv_cc *cc)
 
- {
 
- 	u32 pmucap;
 
- 
- 	pmucap = bcma_cc_read32(cc, BCMA_CC_PMU_CAP);
 
- 	cc->pmu.rev = (pmucap & BCMA_CC_PMU_CAP_REVISION);
 
- 
--	pr_debug("Found rev %u PMU (capabilities 0x%08X)\n", cc->pmu.rev,
 
--		 pmucap);
 
-+	bcma_debug(cc->core->bus, "Found rev %u PMU (capabilities 0x%08X)\n",
 
-+		   cc->pmu.rev, pmucap);
 
-+}
 
- 
-+void bcma_pmu_init(struct bcma_drv_cc *cc)
 
-+{
 
- 	if (cc->pmu.rev == 1)
 
- 		bcma_cc_mask32(cc, BCMA_CC_PMU_CTL,
 
- 			      ~BCMA_CC_PMU_CTL_NOILPONW);
 
-@@ -174,37 +287,48 @@ void bcma_pmu_init(struct bcma_drv_cc *c
 
- 		bcma_cc_set32(cc, BCMA_CC_PMU_CTL,
 
- 			     BCMA_CC_PMU_CTL_NOILPONW);
 
- 
--	if (cc->core->id.id == 0x4329 && cc->core->id.rev == 2)
 
--		pr_err("Fix for 4329b0 bad LPOM state not implemented!\n");
 
--
 
- 	bcma_pmu_pll_init(cc);
 
- 	bcma_pmu_resources_init(cc);
 
--	bcma_pmu_swreg_init(cc);
 
- 	bcma_pmu_workarounds(cc);
 
- }
 
- 
--u32 bcma_pmu_alp_clock(struct bcma_drv_cc *cc)
 
-+u32 bcma_pmu_get_alp_clock(struct bcma_drv_cc *cc)
 
- {
 
- 	struct bcma_bus *bus = cc->core->bus;
 
- 
- 	switch (bus->chipinfo.id) {
 
--	case 0x4716:
 
--	case 0x4748:
 
--	case 47162:
 
--	case 0x4313:
 
--	case 0x5357:
 
--	case 0x4749:
 
--	case 53572:
 
-+	case BCMA_CHIP_ID_BCM4313:
 
-+	case BCMA_CHIP_ID_BCM43224:
 
-+	case BCMA_CHIP_ID_BCM43225:
 
-+	case BCMA_CHIP_ID_BCM43227:
 
-+	case BCMA_CHIP_ID_BCM43228:
 
-+	case BCMA_CHIP_ID_BCM4331:
 
-+	case BCMA_CHIP_ID_BCM43421:
 
-+	case BCMA_CHIP_ID_BCM43428:
 
-+	case BCMA_CHIP_ID_BCM43431:
 
-+	case BCMA_CHIP_ID_BCM4716:
 
-+	case BCMA_CHIP_ID_BCM47162:
 
-+	case BCMA_CHIP_ID_BCM4748:
 
-+	case BCMA_CHIP_ID_BCM4749:
 
-+	case BCMA_CHIP_ID_BCM5357:
 
-+	case BCMA_CHIP_ID_BCM53572:
 
-+	case BCMA_CHIP_ID_BCM6362:
 
- 		/* always 20Mhz */
 
- 		return 20000 * 1000;
 
--	case 0x5356:
 
--	case 0x5300:
 
-+	case BCMA_CHIP_ID_BCM4706:
 
-+	case BCMA_CHIP_ID_BCM5356:
 
- 		/* always 25Mhz */
 
- 		return 25000 * 1000;
 
-+	case BCMA_CHIP_ID_BCM43460:
 
-+	case BCMA_CHIP_ID_BCM4352:
 
-+	case BCMA_CHIP_ID_BCM4360:
 
-+		if (cc->status & BCMA_CC_CHIPST_4360_XTAL_40MZ)
 
-+			return 40000 * 1000;
 
-+		else
 
-+			return 20000 * 1000;
 
- 	default:
 
--		pr_warn("No ALP clock specified for %04X device, "
 
--			"pmu rev. %d, using default %d Hz\n",
 
--			bus->chipinfo.id, cc->pmu.rev, BCMA_CC_PMU_ALP_CLOCK);
 
-+		bcma_warn(bus, "No ALP clock specified for %04X device, pmu rev. %d, using default %d Hz\n",
 
-+			  bus->chipinfo.id, cc->pmu.rev, BCMA_CC_PMU_ALP_CLOCK);
 
- 	}
 
- 	return BCMA_CC_PMU_ALP_CLOCK;
 
- }
 
-@@ -212,7 +336,7 @@ u32 bcma_pmu_alp_clock(struct bcma_drv_c
 
- /* Find the output of the "m" pll divider given pll controls that start with
 
-  * pllreg "pll0" i.e. 12 for main 6 for phy, 0 for misc.
 
-  */
 
--static u32 bcma_pmu_clock(struct bcma_drv_cc *cc, u32 pll0, u32 m)
 
-+static u32 bcma_pmu_pll_clock(struct bcma_drv_cc *cc, u32 pll0, u32 m)
 
- {
 
- 	u32 tmp, div, ndiv, p1, p2, fc;
 
- 	struct bcma_bus *bus = cc->core->bus;
 
-@@ -221,7 +345,8 @@ static u32 bcma_pmu_clock(struct bcma_dr
 
- 
- 	BUG_ON(!m || m > 4);
 
- 
--	if (bus->chipinfo.id == 0x5357 || bus->chipinfo.id == 0x4749) {
 
-+	if (bus->chipinfo.id == BCMA_CHIP_ID_BCM5357 ||
 
-+	    bus->chipinfo.id == BCMA_CHIP_ID_BCM4749) {
 
- 		/* Detect failure in clock setting */
 
- 		tmp = bcma_cc_read32(cc, BCMA_CC_CHIPSTAT);
 
- 		if (tmp & 0x40000)
 
-@@ -240,60 +365,96 @@ static u32 bcma_pmu_clock(struct bcma_dr
 
- 	ndiv = (tmp & BCMA_CC_PPL_NDIV_MASK) >> BCMA_CC_PPL_NDIV_SHIFT;
 
- 
- 	/* Do calculation in Mhz */
 
--	fc = bcma_pmu_alp_clock(cc) / 1000000;
 
-+	fc = bcma_pmu_get_alp_clock(cc) / 1000000;
 
- 	fc = (p1 * ndiv * fc) / p2;
 
- 
- 	/* Return clock in Hertz */
 
- 	return (fc / div) * 1000000;
 
- }
 
- 
-+static u32 bcma_pmu_pll_clock_bcm4706(struct bcma_drv_cc *cc, u32 pll0, u32 m)
 
-+{
 
-+	u32 tmp, ndiv, p1div, p2div;
 
-+	u32 clock;
 
-+
 
-+	BUG_ON(!m || m > 4);
 
-+
 
-+	/* Get N, P1 and P2 dividers to determine CPU clock */
 
-+	tmp = bcma_chipco_pll_read(cc, pll0 + BCMA_CC_PMU6_4706_PROCPLL_OFF);
 
-+	ndiv = (tmp & BCMA_CC_PMU6_4706_PROC_NDIV_INT_MASK)
 
-+		>> BCMA_CC_PMU6_4706_PROC_NDIV_INT_SHIFT;
 
-+	p1div = (tmp & BCMA_CC_PMU6_4706_PROC_P1DIV_MASK)
 
-+		>> BCMA_CC_PMU6_4706_PROC_P1DIV_SHIFT;
 
-+	p2div = (tmp & BCMA_CC_PMU6_4706_PROC_P2DIV_MASK)
 
-+		>> BCMA_CC_PMU6_4706_PROC_P2DIV_SHIFT;
 
-+
 
-+	tmp = bcma_cc_read32(cc, BCMA_CC_CHIPSTAT);
 
-+	if (tmp & BCMA_CC_CHIPST_4706_PKG_OPTION)
 
-+		/* Low cost bonding: Fixed reference clock 25MHz and m = 4 */
 
-+		clock = (25000000 / 4) * ndiv * p2div / p1div;
 
-+	else
 
-+		/* Fixed reference clock 25MHz and m = 2 */
 
-+		clock = (25000000 / 2) * ndiv * p2div / p1div;
 
-+
 
-+	if (m == BCMA_CC_PMU5_MAINPLL_SSB)
 
-+		clock = clock / 4;
 
-+
 
-+	return clock;
 
-+}
 
-+
 
- /* query bus clock frequency for PMU-enabled chipcommon */
 
--u32 bcma_pmu_get_clockcontrol(struct bcma_drv_cc *cc)
 
-+u32 bcma_pmu_get_bus_clock(struct bcma_drv_cc *cc)
 
- {
 
- 	struct bcma_bus *bus = cc->core->bus;
 
- 
- 	switch (bus->chipinfo.id) {
 
--	case 0x4716:
 
--	case 0x4748:
 
--	case 47162:
 
--		return bcma_pmu_clock(cc, BCMA_CC_PMU4716_MAINPLL_PLL0,
 
--				      BCMA_CC_PMU5_MAINPLL_SSB);
 
--	case 0x5356:
 
--		return bcma_pmu_clock(cc, BCMA_CC_PMU5356_MAINPLL_PLL0,
 
--				      BCMA_CC_PMU5_MAINPLL_SSB);
 
--	case 0x5357:
 
--	case 0x4749:
 
--		return bcma_pmu_clock(cc, BCMA_CC_PMU5357_MAINPLL_PLL0,
 
--				      BCMA_CC_PMU5_MAINPLL_SSB);
 
--	case 0x5300:
 
--		return bcma_pmu_clock(cc, BCMA_CC_PMU4706_MAINPLL_PLL0,
 
--				      BCMA_CC_PMU5_MAINPLL_SSB);
 
--	case 53572:
 
-+	case BCMA_CHIP_ID_BCM4716:
 
-+	case BCMA_CHIP_ID_BCM4748:
 
-+	case BCMA_CHIP_ID_BCM47162:
 
-+		return bcma_pmu_pll_clock(cc, BCMA_CC_PMU4716_MAINPLL_PLL0,
 
-+					  BCMA_CC_PMU5_MAINPLL_SSB);
 
-+	case BCMA_CHIP_ID_BCM5356:
 
-+		return bcma_pmu_pll_clock(cc, BCMA_CC_PMU5356_MAINPLL_PLL0,
 
-+					  BCMA_CC_PMU5_MAINPLL_SSB);
 
-+	case BCMA_CHIP_ID_BCM5357:
 
-+	case BCMA_CHIP_ID_BCM4749:
 
-+		return bcma_pmu_pll_clock(cc, BCMA_CC_PMU5357_MAINPLL_PLL0,
 
-+					  BCMA_CC_PMU5_MAINPLL_SSB);
 
-+	case BCMA_CHIP_ID_BCM4706:
 
-+		return bcma_pmu_pll_clock_bcm4706(cc,
 
-+						  BCMA_CC_PMU4706_MAINPLL_PLL0,
 
-+						  BCMA_CC_PMU5_MAINPLL_SSB);
 
-+	case BCMA_CHIP_ID_BCM53572:
 
- 		return 75000000;
 
- 	default:
 
--		pr_warn("No backplane clock specified for %04X device, "
 
--			"pmu rev. %d, using default %d Hz\n",
 
--			bus->chipinfo.id, cc->pmu.rev, BCMA_CC_PMU_HT_CLOCK);
 
-+		bcma_warn(bus, "No bus clock specified for %04X device, pmu rev. %d, using default %d Hz\n",
 
-+			  bus->chipinfo.id, cc->pmu.rev, BCMA_CC_PMU_HT_CLOCK);
 
- 	}
 
- 	return BCMA_CC_PMU_HT_CLOCK;
 
- }
 
-+EXPORT_SYMBOL_GPL(bcma_pmu_get_bus_clock);
 
- 
- /* query cpu clock frequency for PMU-enabled chipcommon */
 
--u32 bcma_pmu_get_clockcpu(struct bcma_drv_cc *cc)
 
-+u32 bcma_pmu_get_cpu_clock(struct bcma_drv_cc *cc)
 
- {
 
- 	struct bcma_bus *bus = cc->core->bus;
 
- 
--	if (bus->chipinfo.id == 53572)
 
-+	if (bus->chipinfo.id == BCMA_CHIP_ID_BCM53572)
 
- 		return 300000000;
 
- 
-+	/* New PMUs can have different clock for bus and CPU */
 
- 	if (cc->pmu.rev >= 5) {
 
- 		u32 pll;
 
- 		switch (bus->chipinfo.id) {
 
--		case 0x5356:
 
-+		case BCMA_CHIP_ID_BCM4706:
 
-+			return bcma_pmu_pll_clock_bcm4706(cc,
 
-+						BCMA_CC_PMU4706_MAINPLL_PLL0,
 
-+						BCMA_CC_PMU5_MAINPLL_CPU);
 
-+		case BCMA_CHIP_ID_BCM5356:
 
- 			pll = BCMA_CC_PMU5356_MAINPLL_PLL0;
 
- 			break;
 
--		case 0x5357:
 
--		case 0x4749:
 
-+		case BCMA_CHIP_ID_BCM5357:
 
-+		case BCMA_CHIP_ID_BCM4749:
 
- 			pll = BCMA_CC_PMU5357_MAINPLL_PLL0;
 
- 			break;
 
- 		default:
 
-@@ -301,10 +462,189 @@ u32 bcma_pmu_get_clockcpu(struct bcma_dr
 
- 			break;
 
- 		}
 
- 
--		/* TODO: if (bus->chipinfo.id == 0x5300)
 
--		  return si_4706_pmu_clock(sih, osh, cc, PMU4706_MAINPLL_PLL0, PMU5_MAINPLL_CPU); */
 
--		return bcma_pmu_clock(cc, pll, BCMA_CC_PMU5_MAINPLL_CPU);
 
-+		return bcma_pmu_pll_clock(cc, pll, BCMA_CC_PMU5_MAINPLL_CPU);
 
-+	}
 
-+
 
-+	/* On old PMUs CPU has the same clock as the bus */
 
-+	return bcma_pmu_get_bus_clock(cc);
 
-+}
 
-+
 
-+static void bcma_pmu_spuravoid_pll_write(struct bcma_drv_cc *cc, u32 offset,
 
-+					 u32 value)
 
-+{
 
-+	bcma_cc_write32(cc, BCMA_CC_PLLCTL_ADDR, offset);
 
-+	bcma_cc_write32(cc, BCMA_CC_PLLCTL_DATA, value);
 
-+}
 
-+
 
-+void bcma_pmu_spuravoid_pllupdate(struct bcma_drv_cc *cc, int spuravoid)
 
-+{
 
-+	u32 tmp = 0;
 
-+	u8 phypll_offset = 0;
 
-+	u8 bcm5357_bcm43236_p1div[] = {0x1, 0x5, 0x5};
 
-+	u8 bcm5357_bcm43236_ndiv[] = {0x30, 0xf6, 0xfc};
 
-+	struct bcma_bus *bus = cc->core->bus;
 
-+
 
-+	switch (bus->chipinfo.id) {
 
-+	case BCMA_CHIP_ID_BCM5357:
 
-+	case BCMA_CHIP_ID_BCM4749:
 
-+	case BCMA_CHIP_ID_BCM53572:
 
-+		/* 5357[ab]0, 43236[ab]0, and 6362b0 */
 
-+
 
-+		/* BCM5357 needs to touch PLL1_PLLCTL[02],
 
-+		   so offset PLL0_PLLCTL[02] by 6 */
 
-+		phypll_offset = (bus->chipinfo.id == BCMA_CHIP_ID_BCM5357 ||
 
-+		       bus->chipinfo.id == BCMA_CHIP_ID_BCM4749 ||
 
-+		       bus->chipinfo.id == BCMA_CHIP_ID_BCM53572) ? 6 : 0;
 
-+
 
-+		/* RMW only the P1 divider */
 
-+		bcma_cc_write32(cc, BCMA_CC_PLLCTL_ADDR,
 
-+				BCMA_CC_PMU_PLL_CTL0 + phypll_offset);
 
-+		tmp = bcma_cc_read32(cc, BCMA_CC_PLLCTL_DATA);
 
-+		tmp &= (~(BCMA_CC_PMU1_PLL0_PC0_P1DIV_MASK));
 
-+		tmp |= (bcm5357_bcm43236_p1div[spuravoid] << BCMA_CC_PMU1_PLL0_PC0_P1DIV_SHIFT);
 
-+		bcma_cc_write32(cc, BCMA_CC_PLLCTL_DATA, tmp);
 
-+
 
-+		/* RMW only the int feedback divider */
 
-+		bcma_cc_write32(cc, BCMA_CC_PLLCTL_ADDR,
 
-+				BCMA_CC_PMU_PLL_CTL2 + phypll_offset);
 
-+		tmp = bcma_cc_read32(cc, BCMA_CC_PLLCTL_DATA);
 
-+		tmp &= ~(BCMA_CC_PMU1_PLL0_PC2_NDIV_INT_MASK);
 
-+		tmp |= (bcm5357_bcm43236_ndiv[spuravoid]) << BCMA_CC_PMU1_PLL0_PC2_NDIV_INT_SHIFT;
 
-+		bcma_cc_write32(cc, BCMA_CC_PLLCTL_DATA, tmp);
 
-+
 
-+		tmp = BCMA_CC_PMU_CTL_PLL_UPD;
 
-+		break;
 
-+
 
-+	case BCMA_CHIP_ID_BCM4331:
 
-+	case BCMA_CHIP_ID_BCM43431:
 
-+		if (spuravoid == 2) {
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL0,
 
-+						     0x11500014);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL2,
 
-+						     0x0FC00a08);
 
-+		} else if (spuravoid == 1) {
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL0,
 
-+						     0x11500014);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL2,
 
-+						     0x0F600a08);
 
-+		} else {
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL0,
 
-+						     0x11100014);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL2,
 
-+						     0x03000a08);
 
-+		}
 
-+		tmp = BCMA_CC_PMU_CTL_PLL_UPD;
 
-+		break;
 
-+
 
-+	case BCMA_CHIP_ID_BCM43224:
 
-+	case BCMA_CHIP_ID_BCM43225:
 
-+	case BCMA_CHIP_ID_BCM43421:
 
-+		if (spuravoid == 1) {
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL0,
 
-+						     0x11500010);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL1,
 
-+						     0x000C0C06);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL2,
 
-+						     0x0F600a08);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL3,
 
-+						     0x00000000);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL4,
 
-+						     0x2001E920);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL5,
 
-+						     0x88888815);
 
-+		} else {
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL0,
 
-+						     0x11100010);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL1,
 
-+						     0x000c0c06);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL2,
 
-+						     0x03000a08);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL3,
 
-+						     0x00000000);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL4,
 
-+						     0x200005c0);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL5,
 
-+						     0x88888815);
 
-+		}
 
-+		tmp = BCMA_CC_PMU_CTL_PLL_UPD;
 
-+		break;
 
-+
 
-+	case BCMA_CHIP_ID_BCM4716:
 
-+	case BCMA_CHIP_ID_BCM4748:
 
-+	case BCMA_CHIP_ID_BCM47162:
 
-+		if (spuravoid == 1) {
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL0,
 
-+						     0x11500060);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL1,
 
-+						     0x080C0C06);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL2,
 
-+						     0x0F600000);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL3,
 
-+						     0x00000000);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL4,
 
-+						     0x2001E924);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL5,
 
-+						     0x88888815);
 
-+		} else {
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL0,
 
-+						     0x11100060);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL1,
 
-+						     0x080c0c06);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL2,
 
-+						     0x03000000);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL3,
 
-+						     0x00000000);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL4,
 
-+						     0x200005c0);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL5,
 
-+						     0x88888815);
 
-+		}
 
-+
 
-+		tmp = BCMA_CC_PMU_CTL_PLL_UPD | BCMA_CC_PMU_CTL_NOILPONW;
 
-+		break;
 
-+
 
-+	case BCMA_CHIP_ID_BCM43227:
 
-+	case BCMA_CHIP_ID_BCM43228:
 
-+	case BCMA_CHIP_ID_BCM43428:
 
-+		/* LCNXN */
 
-+		/* PLL Settings for spur avoidance on/off mode,
 
-+		   no on2 support for 43228A0 */
 
-+		if (spuravoid == 1) {
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL0,
 
-+						     0x01100014);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL1,
 
-+						     0x040C0C06);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL2,
 
-+						     0x03140A08);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL3,
 
-+						     0x00333333);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL4,
 
-+						     0x202C2820);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL5,
 
-+						     0x88888815);
 
-+		} else {
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL0,
 
-+						     0x11100014);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL1,
 
-+						     0x040c0c06);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL2,
 
-+						     0x03000a08);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL3,
 
-+						     0x00000000);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL4,
 
-+						     0x200005c0);
 
-+			bcma_pmu_spuravoid_pll_write(cc, BCMA_CC_PMU_PLL_CTL5,
 
-+						     0x88888815);
 
-+		}
 
-+		tmp = BCMA_CC_PMU_CTL_PLL_UPD;
 
-+		break;
 
-+	default:
 
-+		bcma_err(bus, "Unknown spuravoidance settings for chip 0x%04X, not changing PLL\n",
 
-+			 bus->chipinfo.id);
 
-+		break;
 
- 	}
 
- 
--	return bcma_pmu_get_clockcontrol(cc);
 
-+	tmp |= bcma_cc_read32(cc, BCMA_CC_PMU_CTL);
 
-+	bcma_cc_write32(cc, BCMA_CC_PMU_CTL, tmp);
 
- }
 
-+EXPORT_SYMBOL_GPL(bcma_pmu_spuravoid_pllupdate);
 
---- /dev/null
 
-+++ b/drivers/bcma/driver_chipcommon_sflash.c
 
-@@ -0,0 +1,165 @@
 
-+/*
 
-+ * Broadcom specific AMBA
 
-+ * ChipCommon serial flash interface
 
-+ *
 
-+ * Licensed under the GNU/GPL. See COPYING for details.
 
-+ */
 
-+
 
-+#include "bcma_private.h"
 
-+
 
-+#include <linux/platform_device.h>
 
-+#include <linux/bcma/bcma.h>
 
-+
 
-+static struct resource bcma_sflash_resource = {
 
-+	.name	= "bcma_sflash",
 
-+	.start	= BCMA_SOC_FLASH2,
 
-+	.end	= 0,
 
-+	.flags  = IORESOURCE_MEM | IORESOURCE_READONLY,
 
-+};
 
-+
 
-+struct platform_device bcma_sflash_dev = {
 
-+	.name		= "bcma_sflash",
 
-+	.resource	= &bcma_sflash_resource,
 
-+	.num_resources	= 1,
 
-+};
 
-+
 
-+struct bcma_sflash_tbl_e {
 
-+	char *name;
 
-+	u32 id;
 
-+	u32 blocksize;
 
-+	u16 numblocks;
 
-+};
 
-+
 
-+static const struct bcma_sflash_tbl_e bcma_sflash_st_tbl[] = {
 
-+	{ "M25P20", 0x11, 0x10000, 4, },
 
-+	{ "M25P40", 0x12, 0x10000, 8, },
 
-+
 
-+	{ "M25P16", 0x14, 0x10000, 32, },
 
-+	{ "M25P32", 0x15, 0x10000, 64, },
 
-+	{ "M25P64", 0x16, 0x10000, 128, },
 
-+	{ "M25FL128", 0x17, 0x10000, 256, },
 
-+	{ 0 },
 
-+};
 
-+
 
-+static const struct bcma_sflash_tbl_e bcma_sflash_sst_tbl[] = {
 
-+	{ "SST25WF512", 1, 0x1000, 16, },
 
-+	{ "SST25VF512", 0x48, 0x1000, 16, },
 
-+	{ "SST25WF010", 2, 0x1000, 32, },
 
-+	{ "SST25VF010", 0x49, 0x1000, 32, },
 
-+	{ "SST25WF020", 3, 0x1000, 64, },
 
-+	{ "SST25VF020", 0x43, 0x1000, 64, },
 
-+	{ "SST25WF040", 4, 0x1000, 128, },
 
-+	{ "SST25VF040", 0x44, 0x1000, 128, },
 
-+	{ "SST25VF040B", 0x8d, 0x1000, 128, },
 
-+	{ "SST25WF080", 5, 0x1000, 256, },
 
-+	{ "SST25VF080B", 0x8e, 0x1000, 256, },
 
-+	{ "SST25VF016", 0x41, 0x1000, 512, },
 
-+	{ "SST25VF032", 0x4a, 0x1000, 1024, },
 
-+	{ "SST25VF064", 0x4b, 0x1000, 2048, },
 
-+	{ 0 },
 
-+};
 
-+
 
-+static const struct bcma_sflash_tbl_e bcma_sflash_at_tbl[] = {
 
-+	{ "AT45DB011", 0xc, 256, 512, },
 
-+	{ "AT45DB021", 0x14, 256, 1024, },
 
-+	{ "AT45DB041", 0x1c, 256, 2048, },
 
-+	{ "AT45DB081", 0x24, 256, 4096, },
 
-+	{ "AT45DB161", 0x2c, 512, 4096, },
 
-+	{ "AT45DB321", 0x34, 512, 8192, },
 
-+	{ "AT45DB642", 0x3c, 1024, 8192, },
 
-+	{ 0 },
 
-+};
 
-+
 
-+static void bcma_sflash_cmd(struct bcma_drv_cc *cc, u32 opcode)
 
-+{
 
-+	int i;
 
-+	bcma_cc_write32(cc, BCMA_CC_FLASHCTL,
 
-+			BCMA_CC_FLASHCTL_START | opcode);
 
-+	for (i = 0; i < 1000; i++) {
 
-+		if (!(bcma_cc_read32(cc, BCMA_CC_FLASHCTL) &
 
-+		      BCMA_CC_FLASHCTL_BUSY))
 
-+			return;
 
-+		cpu_relax();
 
-+	}
 
-+	bcma_err(cc->core->bus, "SFLASH control command failed (timeout)!\n");
 
-+}
 
-+
 
-+/* Initialize serial flash access */
 
-+int bcma_sflash_init(struct bcma_drv_cc *cc)
 
-+{
 
-+	struct bcma_bus *bus = cc->core->bus;
 
-+	struct bcma_sflash *sflash = &cc->sflash;
 
-+	const struct bcma_sflash_tbl_e *e;
 
-+	u32 id, id2;
 
-+
 
-+	switch (cc->capabilities & BCMA_CC_CAP_FLASHT) {
 
-+	case BCMA_CC_FLASHT_STSER:
 
-+		bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_DP);
 
-+
 
-+		bcma_cc_write32(cc, BCMA_CC_FLASHADDR, 0);
 
-+		bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_RES);
 
-+		id = bcma_cc_read32(cc, BCMA_CC_FLASHDATA);
 
-+
 
-+		bcma_cc_write32(cc, BCMA_CC_FLASHADDR, 1);
 
-+		bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_RES);
 
-+		id2 = bcma_cc_read32(cc, BCMA_CC_FLASHDATA);
 
-+
 
-+		switch (id) {
 
-+		case 0xbf:
 
-+			for (e = bcma_sflash_sst_tbl; e->name; e++) {
 
-+				if (e->id == id2)
 
-+					break;
 
-+			}
 
-+			break;
 
-+		case 0x13:
 
-+			return -ENOTSUPP;
 
-+		default:
 
-+			for (e = bcma_sflash_st_tbl; e->name; e++) {
 
-+				if (e->id == id)
 
-+					break;
 
-+			}
 
-+			break;
 
-+		}
 
-+		if (!e->name) {
 
-+			bcma_err(bus, "Unsupported ST serial flash (id: 0x%X, id2: 0x%X)\n", id, id2);
 
-+			return -ENOTSUPP;
 
-+		}
 
-+
 
-+		break;
 
-+	case BCMA_CC_FLASHT_ATSER:
 
-+		bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_AT_STATUS);
 
-+		id = bcma_cc_read32(cc, BCMA_CC_FLASHDATA) & 0x3c;
 
-+
 
-+		for (e = bcma_sflash_at_tbl; e->name; e++) {
 
-+			if (e->id == id)
 
-+				break;
 
-+		}
 
-+		if (!e->name) {
 
-+			bcma_err(bus, "Unsupported Atmel serial flash (id: 0x%X)\n", id);
 
-+			return -ENOTSUPP;
 
-+		}
 
-+
 
-+		break;
 
-+	default:
 
-+		bcma_err(bus, "Unsupported flash type\n");
 
-+		return -ENOTSUPP;
 
-+	}
 
-+
 
-+	sflash->window = BCMA_SOC_FLASH2;
 
-+	sflash->blocksize = e->blocksize;
 
-+	sflash->numblocks = e->numblocks;
 
-+	sflash->size = sflash->blocksize * sflash->numblocks;
 
-+	sflash->present = true;
 
-+
 
-+	bcma_info(bus, "Found %s serial flash (size: %dKiB, blocksize: 0x%X, blocks: %d)\n",
 
-+		  e->name, sflash->size / 1024, sflash->blocksize,
 
-+		  sflash->numblocks);
 
-+
 
-+	/* Prepare platform device, but don't register it yet. It's too early,
 
-+	 * malloc (required by device_private_init) is not available yet. */
 
-+	bcma_sflash_dev.resource[0].end = bcma_sflash_dev.resource[0].start +
 
-+					  sflash->size;
 
-+	bcma_sflash_dev.dev.platform_data = sflash;
 
-+
 
-+	return 0;
 
-+}
 
---- /dev/null
 
-+++ b/drivers/bcma/driver_gmac_cmn.c
 
-@@ -0,0 +1,14 @@
 
-+/*
 
-+ * Broadcom specific AMBA
 
-+ * GBIT MAC COMMON Core
 
-+ *
 
-+ * Licensed under the GNU/GPL. See COPYING for details.
 
-+ */
 
-+
 
-+#include "bcma_private.h"
 
-+#include <linux/bcma/bcma.h>
 
-+
 
-+void __devinit bcma_core_gmac_cmn_init(struct bcma_drv_gmac_cmn *gc)
 
-+{
 
-+	mutex_init(&gc->phy_mutex);
 
-+}
 
---- /dev/null
 
-+++ b/drivers/bcma/driver_gpio.c
 
-@@ -0,0 +1,114 @@
 
-+/*
 
-+ * Broadcom specific AMBA
 
-+ * GPIO driver
 
-+ *
 
-+ * Copyright 2011, Broadcom Corporation
 
-+ * Copyright 2012, Hauke Mehrtens <[email protected]>
 
-+ *
 
-+ * Licensed under the GNU/GPL. See COPYING for details.
 
-+ */
 
-+
 
-+#include <linux/gpio.h>
 
-+#include <linux/export.h>
 
-+#include <linux/bcma/bcma.h>
 
-+
 
-+#include "bcma_private.h"
 
-+
 
-+static inline struct bcma_drv_cc *bcma_gpio_get_cc(struct gpio_chip *chip)
 
-+{
 
-+	return container_of(chip, struct bcma_drv_cc, gpio);
 
-+}
 
-+
 
-+static int bcma_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
 
-+{
 
-+	struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
 
-+
 
-+	return !!bcma_chipco_gpio_in(cc, 1 << gpio);
 
-+}
 
-+
 
-+static void bcma_gpio_set_value(struct gpio_chip *chip, unsigned gpio,
 
-+				int value)
 
-+{
 
-+	struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
 
-+
 
-+	bcma_chipco_gpio_out(cc, 1 << gpio, value ? 1 << gpio : 0);
 
-+}
 
-+
 
-+static int bcma_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
 
-+{
 
-+	struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
 
-+
 
-+	bcma_chipco_gpio_outen(cc, 1 << gpio, 0);
 
-+	return 0;
 
-+}
 
-+
 
-+static int bcma_gpio_direction_output(struct gpio_chip *chip, unsigned gpio,
 
-+				      int value)
 
-+{
 
-+	struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
 
-+
 
-+	bcma_chipco_gpio_outen(cc, 1 << gpio, 1 << gpio);
 
-+	bcma_chipco_gpio_out(cc, 1 << gpio, value ? 1 << gpio : 0);
 
-+	return 0;
 
-+}
 
-+
 
-+static int bcma_gpio_request(struct gpio_chip *chip, unsigned gpio)
 
-+{
 
-+	struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
 
-+
 
-+	bcma_chipco_gpio_control(cc, 1 << gpio, 0);
 
-+	/* clear pulldown */
 
-+	bcma_chipco_gpio_pulldown(cc, 1 << gpio, 0);
 
-+	/* Set pullup */
 
-+	bcma_chipco_gpio_pullup(cc, 1 << gpio, 1 << gpio);
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static void bcma_gpio_free(struct gpio_chip *chip, unsigned gpio)
 
-+{
 
-+	struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
 
-+
 
-+	/* clear pullup */
 
-+	bcma_chipco_gpio_pullup(cc, 1 << gpio, 0);
 
-+}
 
-+
 
-+static int bcma_gpio_to_irq(struct gpio_chip *chip, unsigned gpio)
 
-+{
 
-+	struct bcma_drv_cc *cc = bcma_gpio_get_cc(chip);
 
-+
 
-+	if (cc->core->bus->hosttype == BCMA_HOSTTYPE_SOC)
 
-+		return bcma_core_irq(cc->core);
 
-+	else
 
-+		return -EINVAL;
 
-+}
 
-+
 
-+int bcma_gpio_init(struct bcma_drv_cc *cc)
 
-+{
 
-+	struct gpio_chip *chip = &cc->gpio;
 
-+
 
-+	chip->label		= "bcma_gpio";
 
-+	chip->owner		= THIS_MODULE;
 
-+	chip->request		= bcma_gpio_request;
 
-+	chip->free		= bcma_gpio_free;
 
-+	chip->get		= bcma_gpio_get_value;
 
-+	chip->set		= bcma_gpio_set_value;
 
-+	chip->direction_input	= bcma_gpio_direction_input;
 
-+	chip->direction_output	= bcma_gpio_direction_output;
 
-+	chip->to_irq		= bcma_gpio_to_irq;
 
-+	chip->ngpio		= 16;
 
-+	/* There is just one SoC in one device and its GPIO addresses should be
 
-+	 * deterministic to address them more easily. The other buses could get
 
-+	 * a random base number. */
 
-+	if (cc->core->bus->hosttype == BCMA_HOSTTYPE_SOC)
 
-+		chip->base		= 0;
 
-+	else
 
-+		chip->base		= -1;
 
-+
 
-+	return gpiochip_add(chip);
 
-+}
 
-+
 
-+int bcma_gpio_unregister(struct bcma_drv_cc *cc)
 
-+{
 
-+	return gpiochip_remove(&cc->gpio);
 
-+}
 
---- a/drivers/bcma/driver_mips.c
 
-+++ b/drivers/bcma/driver_mips.c
 
-@@ -14,23 +14,45 @@
 
- 
- #include <linux/bcma/bcma.h>
 
- 
-+#include <linux/mtd/physmap.h>
 
-+#include <linux/platform_device.h>
 
- #include <linux/serial.h>
 
- #include <linux/serial_core.h>
 
- #include <linux/serial_reg.h>
 
- #include <linux/time.h>
 
- 
-+static const char * const part_probes[] = { "bcm47xxpart", NULL };
 
-+
 
-+static struct physmap_flash_data bcma_pflash_data = {
 
-+	.part_probe_types	= part_probes,
 
-+};
 
-+
 
-+static struct resource bcma_pflash_resource = {
 
-+	.name	= "bcma_pflash",
 
-+	.flags  = IORESOURCE_MEM,
 
-+};
 
-+
 
-+struct platform_device bcma_pflash_dev = {
 
-+	.name		= "physmap-flash",
 
-+	.dev		= {
 
-+		.platform_data  = &bcma_pflash_data,
 
-+	},
 
-+	.resource	= &bcma_pflash_resource,
 
-+	.num_resources	= 1,
 
-+};
 
-+
 
- /* The 47162a0 hangs when reading MIPS DMP registers registers */
 
- static inline bool bcma_core_mips_bcm47162a0_quirk(struct bcma_device *dev)
 
- {
 
--	return dev->bus->chipinfo.id == 47162 && dev->bus->chipinfo.rev == 0 &&
 
--	       dev->id.id == BCMA_CORE_MIPS_74K;
 
-+	return dev->bus->chipinfo.id == BCMA_CHIP_ID_BCM47162 &&
 
-+	       dev->bus->chipinfo.rev == 0 && dev->id.id == BCMA_CORE_MIPS_74K;
 
- }
 
- 
- /* The 5357b0 hangs when reading USB20H DMP registers */
 
- static inline bool bcma_core_mips_bcm5357b0_quirk(struct bcma_device *dev)
 
- {
 
--	return (dev->bus->chipinfo.id == 0x5357 ||
 
--		dev->bus->chipinfo.id == 0x4749) &&
 
-+	return (dev->bus->chipinfo.id == BCMA_CHIP_ID_BCM5357 ||
 
-+		dev->bus->chipinfo.id == BCMA_CHIP_ID_BCM4749) &&
 
- 	       dev->bus->chipinfo.pkg == 11 &&
 
- 	       dev->id.id == BCMA_CORE_USB20_HOST;
 
- }
 
-@@ -74,28 +96,41 @@ static u32 bcma_core_mips_irqflag(struct
 
- 		return dev->core_index;
 
- 	flag = bcma_aread32(dev, BCMA_MIPS_OOBSELOUTA30);
 
- 
--	return flag & 0x1F;
 
-+	if (flag)
 
-+		return flag & 0x1F;
 
-+	else
 
-+		return 0x3f;
 
- }
 
- 
- /* Get the MIPS IRQ assignment for a specified device.
 
-  * If unassigned, 0 is returned.
 
-+ * If disabled, 5 is returned.
 
-+ * If not supported, 6 is returned.
 
-  */
 
--unsigned int bcma_core_mips_irq(struct bcma_device *dev)
 
-+static unsigned int bcma_core_mips_irq(struct bcma_device *dev)
 
- {
 
- 	struct bcma_device *mdev = dev->bus->drv_mips.core;
 
- 	u32 irqflag;
 
- 	unsigned int irq;
 
- 
- 	irqflag = bcma_core_mips_irqflag(dev);
 
-+	if (irqflag == 0x3f)
 
-+		return 6;
 
- 
--	for (irq = 1; irq <= 4; irq++)
 
-+	for (irq = 0; irq <= 4; irq++)
 
- 		if (bcma_read32(mdev, BCMA_MIPS_MIPS74K_INTMASK(irq)) &
 
- 		    (1 << irqflag))
 
- 			return irq;
 
- 
--	return 0;
 
-+	return 5;
 
-+}
 
-+
 
-+unsigned int bcma_core_irq(struct bcma_device *dev)
 
-+{
 
-+	unsigned int mips_irq = bcma_core_mips_irq(dev);
 
-+	return mips_irq <= 4 ? mips_irq + 2 : 0;
 
- }
 
--EXPORT_SYMBOL(bcma_core_mips_irq);
 
-+EXPORT_SYMBOL(bcma_core_irq);
 
- 
- static void bcma_core_mips_set_irq(struct bcma_device *dev, unsigned int irq)
 
- {
 
-@@ -114,8 +149,8 @@ static void bcma_core_mips_set_irq(struc
 
- 		bcma_write32(mdev, BCMA_MIPS_MIPS74K_INTMASK(0),
 
- 			    bcma_read32(mdev, BCMA_MIPS_MIPS74K_INTMASK(0)) &
 
- 			    ~(1 << irqflag));
 
--	else
 
--		bcma_write32(mdev, BCMA_MIPS_MIPS74K_INTMASK(irq), 0);
 
-+	else if (oldirq != 5)
 
-+		bcma_write32(mdev, BCMA_MIPS_MIPS74K_INTMASK(oldirq), 0);
 
- 
- 	/* assign the new one */
 
- 	if (irq == 0) {
 
-@@ -123,17 +158,17 @@ static void bcma_core_mips_set_irq(struc
 
- 			    bcma_read32(mdev, BCMA_MIPS_MIPS74K_INTMASK(0)) |
 
- 			    (1 << irqflag));
 
- 	} else {
 
--		u32 oldirqflag = bcma_read32(mdev,
 
--					     BCMA_MIPS_MIPS74K_INTMASK(irq));
 
--		if (oldirqflag) {
 
-+		u32 irqinitmask = bcma_read32(mdev,
 
-+					      BCMA_MIPS_MIPS74K_INTMASK(irq));
 
-+		if (irqinitmask) {
 
- 			struct bcma_device *core;
 
- 
- 			/* backplane irq line is in use, find out who uses
 
- 			 * it and set user to irq 0
 
- 			 */
 
--			list_for_each_entry_reverse(core, &bus->cores, list) {
 
-+			list_for_each_entry(core, &bus->cores, list) {
 
- 				if ((1 << bcma_core_mips_irqflag(core)) ==
 
--				    oldirqflag) {
 
-+				    irqinitmask) {
 
- 					bcma_core_mips_set_irq(core, 0);
 
- 					break;
 
- 				}
 
-@@ -143,15 +178,31 @@ static void bcma_core_mips_set_irq(struc
 
- 			     1 << irqflag);
 
- 	}
 
- 
--	pr_info("set_irq: core 0x%04x, irq %d => %d\n",
 
--		dev->id.id, oldirq + 2, irq + 2);
 
-+	bcma_debug(bus, "set_irq: core 0x%04x, irq %d => %d\n",
 
-+		   dev->id.id, oldirq <= 4 ? oldirq + 2 : 0, irq + 2);
 
-+}
 
-+
 
-+static void bcma_core_mips_set_irq_name(struct bcma_bus *bus, unsigned int irq,
 
-+					u16 coreid, u8 unit)
 
-+{
 
-+	struct bcma_device *core;
 
-+
 
-+	core = bcma_find_core_unit(bus, coreid, unit);
 
-+	if (!core) {
 
-+		bcma_warn(bus,
 
-+			  "Can not find core (id: 0x%x, unit %i) for IRQ configuration.\n",
 
-+			  coreid, unit);
 
-+		return;
 
-+	}
 
-+
 
-+	bcma_core_mips_set_irq(core, irq);
 
- }
 
- 
- static void bcma_core_mips_print_irq(struct bcma_device *dev, unsigned int irq)
 
- {
 
- 	int i;
 
- 	static const char *irq_name[] = {"2(S)", "3", "4", "5", "6", "D", "I"};
 
--	printk(KERN_INFO KBUILD_MODNAME ": core 0x%04x, irq :", dev->id.id);
 
-+	printk(KERN_DEBUG KBUILD_MODNAME ": core 0x%04x, irq :", dev->id.id);
 
- 	for (i = 0; i <= 6; i++)
 
- 		printk(" %s%s", irq_name[i], i == irq ? "*" : " ");
 
- 	printk("\n");
 
-@@ -161,7 +212,7 @@ static void bcma_core_mips_dump_irq(stru
 
- {
 
- 	struct bcma_device *core;
 
- 
--	list_for_each_entry_reverse(core, &bus->cores, list) {
 
-+	list_for_each_entry(core, &bus->cores, list) {
 
- 		bcma_core_mips_print_irq(core, bcma_core_mips_irq(core));
 
- 	}
 
- }
 
-@@ -171,9 +222,9 @@ u32 bcma_cpu_clock(struct bcma_drv_mips
 
- 	struct bcma_bus *bus = mcore->core->bus;
 
- 
- 	if (bus->drv_cc.capabilities & BCMA_CC_CAP_PMU)
 
--		return bcma_pmu_get_clockcpu(&bus->drv_cc);
 
-+		return bcma_pmu_get_cpu_clock(&bus->drv_cc);
 
- 
--	pr_err("No PMU available, need this to get the cpu clock\n");
 
-+	bcma_err(bus, "No PMU available, need this to get the cpu clock\n");
 
- 	return 0;
 
- }
 
- EXPORT_SYMBOL(bcma_cpu_clock);
 
-@@ -181,25 +232,81 @@ EXPORT_SYMBOL(bcma_cpu_clock);
 
- static void bcma_core_mips_flash_detect(struct bcma_drv_mips *mcore)
 
- {
 
- 	struct bcma_bus *bus = mcore->core->bus;
 
-+	struct bcma_drv_cc *cc = &bus->drv_cc;
 
-+	struct bcma_pflash *pflash = &cc->pflash;
 
- 
--	switch (bus->drv_cc.capabilities & BCMA_CC_CAP_FLASHT) {
 
-+	switch (cc->capabilities & BCMA_CC_CAP_FLASHT) {
 
- 	case BCMA_CC_FLASHT_STSER:
 
- 	case BCMA_CC_FLASHT_ATSER:
 
--		pr_err("Serial flash not supported.\n");
 
-+		bcma_debug(bus, "Found serial flash\n");
 
-+		bcma_sflash_init(cc);
 
- 		break;
 
- 	case BCMA_CC_FLASHT_PARA:
 
--		pr_info("found parallel flash.\n");
 
--		bus->drv_cc.pflash.window = 0x1c000000;
 
--		bus->drv_cc.pflash.window_size = 0x02000000;
 
-+		bcma_debug(bus, "Found parallel flash\n");
 
-+		pflash->present = true;
 
-+		pflash->window = BCMA_SOC_FLASH2;
 
-+		pflash->window_size = BCMA_SOC_FLASH2_SZ;
 
- 
--		if ((bcma_read32(bus->drv_cc.core, BCMA_CC_FLASH_CFG) &
 
-+		if ((bcma_read32(cc->core, BCMA_CC_FLASH_CFG) &
 
- 		     BCMA_CC_FLASH_CFG_DS) == 0)
 
--			bus->drv_cc.pflash.buswidth = 1;
 
-+			pflash->buswidth = 1;
 
- 		else
 
--			bus->drv_cc.pflash.buswidth = 2;
 
-+			pflash->buswidth = 2;
 
-+
 
-+		bcma_pflash_data.width = pflash->buswidth;
 
-+		bcma_pflash_resource.start = pflash->window;
 
-+		bcma_pflash_resource.end = pflash->window + pflash->window_size;
 
-+
 
- 		break;
 
- 	default:
 
--		pr_err("flash not supported.\n");
 
-+		bcma_err(bus, "Flash type not supported\n");
 
-+	}
 
-+
 
-+	if (cc->core->id.rev == 38 ||
 
-+	    bus->chipinfo.id == BCMA_CHIP_ID_BCM4706) {
 
-+		if (cc->capabilities & BCMA_CC_CAP_NFLASH) {
 
-+			bcma_debug(bus, "Found NAND flash\n");
 
-+			bcma_nflash_init(cc);
 
-+		}
 
-+	}
 
-+}
 
-+
 
-+void bcma_core_mips_early_init(struct bcma_drv_mips *mcore)
 
-+{
 
-+	struct bcma_bus *bus = mcore->core->bus;
 
-+
 
-+	if (mcore->early_setup_done)
 
-+		return;
 
-+
 
-+	bcma_chipco_serial_init(&bus->drv_cc);
 
-+	bcma_core_mips_flash_detect(mcore);
 
-+
 
-+	mcore->early_setup_done = true;
 
-+}
 
-+
 
-+static void bcma_fix_i2s_irqflag(struct bcma_bus *bus)
 
-+{
 
-+	struct bcma_device *cpu, *pcie, *i2s;
 
-+
 
-+	/* Fixup the interrupts in 4716/4748 for i2s core (2010 Broadcom SDK)
 
-+	 * (IRQ flags > 7 are ignored when setting the interrupt masks)
 
-+	 */
 
-+	if (bus->chipinfo.id != BCMA_CHIP_ID_BCM4716 &&
 
-+	    bus->chipinfo.id != BCMA_CHIP_ID_BCM4748)
 
-+		return;
 
-+
 
-+	cpu = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
 
-+	pcie = bcma_find_core(bus, BCMA_CORE_PCIE);
 
-+	i2s = bcma_find_core(bus, BCMA_CORE_I2S);
 
-+	if (cpu && pcie && i2s &&
 
-+	    bcma_aread32(cpu, BCMA_MIPS_OOBSELINA74) == 0x08060504 &&
 
-+	    bcma_aread32(pcie, BCMA_MIPS_OOBSELINA74) == 0x08060504 &&
 
-+	    bcma_aread32(i2s, BCMA_MIPS_OOBSELOUTA30) == 0x88) {
 
-+		bcma_awrite32(cpu, BCMA_MIPS_OOBSELINA74, 0x07060504);
 
-+		bcma_awrite32(pcie, BCMA_MIPS_OOBSELINA74, 0x07060504);
 
-+		bcma_awrite32(i2s, BCMA_MIPS_OOBSELOUTA30, 0x87);
 
-+		bcma_debug(bus,
 
-+			   "Moved i2s interrupt to oob line 7 instead of 8\n");
 
- 	}
 
- }
 
- 
-@@ -209,48 +316,59 @@ void bcma_core_mips_init(struct bcma_drv
 
- 	struct bcma_device *core;
 
- 	bus = mcore->core->bus;
 
- 
--	pr_info("Initializing MIPS core...\n");
 
-+	if (mcore->setup_done)
 
-+		return;
 
- 
--	if (!mcore->setup_done)
 
--		mcore->assigned_irqs = 1;
 
-+	bcma_debug(bus, "Initializing MIPS core...\n");
 
- 
--	/* Assign IRQs to all cores on the bus */
 
--	list_for_each_entry_reverse(core, &bus->cores, list) {
 
--		int mips_irq;
 
--		if (core->irq)
 
--			continue;
 
--
 
--		mips_irq = bcma_core_mips_irq(core);
 
--		if (mips_irq > 4)
 
--			core->irq = 0;
 
--		else
 
--			core->irq = mips_irq + 2;
 
--		if (core->irq > 5)
 
--			continue;
 
--		switch (core->id.id) {
 
--		case BCMA_CORE_PCI:
 
--		case BCMA_CORE_PCIE:
 
--		case BCMA_CORE_ETHERNET:
 
--		case BCMA_CORE_ETHERNET_GBIT:
 
--		case BCMA_CORE_MAC_GBIT:
 
--		case BCMA_CORE_80211:
 
--		case BCMA_CORE_USB20_HOST:
 
--			/* These devices get their own IRQ line if available,
 
--			 * the rest goes on IRQ0
 
--			 */
 
--			if (mcore->assigned_irqs <= 4)
 
--				bcma_core_mips_set_irq(core,
 
--						       mcore->assigned_irqs++);
 
--			break;
 
-+	bcma_core_mips_early_init(mcore);
 
-+
 
-+	bcma_fix_i2s_irqflag(bus);
 
-+
 
-+	switch (bus->chipinfo.id) {
 
-+	case BCMA_CHIP_ID_BCM4716:
 
-+	case BCMA_CHIP_ID_BCM4748:
 
-+		bcma_core_mips_set_irq_name(bus, 1, BCMA_CORE_80211, 0);
 
-+		bcma_core_mips_set_irq_name(bus, 2, BCMA_CORE_MAC_GBIT, 0);
 
-+		bcma_core_mips_set_irq_name(bus, 3, BCMA_CORE_USB20_HOST, 0);
 
-+		bcma_core_mips_set_irq_name(bus, 4, BCMA_CORE_PCIE, 0);
 
-+		bcma_core_mips_set_irq_name(bus, 0, BCMA_CORE_CHIPCOMMON, 0);
 
-+		bcma_core_mips_set_irq_name(bus, 0, BCMA_CORE_I2S, 0);
 
-+		break;
 
-+	case BCMA_CHIP_ID_BCM5356:
 
-+	case BCMA_CHIP_ID_BCM47162:
 
-+	case BCMA_CHIP_ID_BCM53572:
 
-+		bcma_core_mips_set_irq_name(bus, 1, BCMA_CORE_80211, 0);
 
-+		bcma_core_mips_set_irq_name(bus, 2, BCMA_CORE_MAC_GBIT, 0);
 
-+		bcma_core_mips_set_irq_name(bus, 0, BCMA_CORE_CHIPCOMMON, 0);
 
-+		break;
 
-+	case BCMA_CHIP_ID_BCM5357:
 
-+	case BCMA_CHIP_ID_BCM4749:
 
-+		bcma_core_mips_set_irq_name(bus, 1, BCMA_CORE_80211, 0);
 
-+		bcma_core_mips_set_irq_name(bus, 2, BCMA_CORE_MAC_GBIT, 0);
 
-+		bcma_core_mips_set_irq_name(bus, 3, BCMA_CORE_USB20_HOST, 0);
 
-+		bcma_core_mips_set_irq_name(bus, 0, BCMA_CORE_CHIPCOMMON, 0);
 
-+		bcma_core_mips_set_irq_name(bus, 0, BCMA_CORE_I2S, 0);
 
-+		break;
 
-+	case BCMA_CHIP_ID_BCM4706:
 
-+		bcma_core_mips_set_irq_name(bus, 1, BCMA_CORE_PCIE, 0);
 
-+		bcma_core_mips_set_irq_name(bus, 2, BCMA_CORE_4706_MAC_GBIT,
 
-+					    0);
 
-+		bcma_core_mips_set_irq_name(bus, 3, BCMA_CORE_PCIE, 1);
 
-+		bcma_core_mips_set_irq_name(bus, 4, BCMA_CORE_USB20_HOST, 0);
 
-+		bcma_core_mips_set_irq_name(bus, 0, BCMA_CORE_4706_CHIPCOMMON,
 
-+					    0);
 
-+		break;
 
-+	default:
 
-+		list_for_each_entry(core, &bus->cores, list) {
 
-+			core->irq = bcma_core_irq(core);
 
- 		}
 
-+		bcma_err(bus,
 
-+			 "Unknown device (0x%x) found, can not configure IRQs\n",
 
-+			 bus->chipinfo.id);
 
- 	}
 
--	pr_info("IRQ reconfiguration done\n");
 
-+	bcma_debug(bus, "IRQ reconfiguration done\n");
 
- 	bcma_core_mips_dump_irq(bus);
 
- 
--	if (mcore->setup_done)
 
--		return;
 
--
 
--	bcma_chipco_serial_init(&bus->drv_cc);
 
--	bcma_core_mips_flash_detect(mcore);
 
- 	mcore->setup_done = true;
 
- }
 
---- a/drivers/bcma/driver_pci.c
 
-+++ b/drivers/bcma/driver_pci.c
 
-@@ -2,8 +2,9 @@
 
-  * Broadcom specific AMBA
 
-  * PCI Core
 
-  *
 
-- * Copyright 2005, Broadcom Corporation
 
-+ * Copyright 2005, 2011, Broadcom Corporation
 
-  * Copyright 2006, 2007, Michael Buesch <[email protected]>
 
-+ * Copyright 2011, 2012, Hauke Mehrtens <[email protected]>
 
-  *
 
-  * Licensed under the GNU/GPL. See COPYING for details.
 
-  */
 
-@@ -16,120 +17,131 @@
 
-  * R/W ops.
 
-  **************************************************/
 
- 
--static u32 bcma_pcie_read(struct bcma_drv_pci *pc, u32 address)
 
-+u32 bcma_pcie_read(struct bcma_drv_pci *pc, u32 address)
 
- {
 
--	pcicore_write32(pc, 0x130, address);
 
--	pcicore_read32(pc, 0x130);
 
--	return pcicore_read32(pc, 0x134);
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_ADDR, address);
 
-+	pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_ADDR);
 
-+	return pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_DATA);
 
- }
 
- 
--#if 0
 
- static void bcma_pcie_write(struct bcma_drv_pci *pc, u32 address, u32 data)
 
- {
 
--	pcicore_write32(pc, 0x130, address);
 
--	pcicore_read32(pc, 0x130);
 
--	pcicore_write32(pc, 0x134, data);
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_ADDR, address);
 
-+	pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_ADDR);
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_DATA, data);
 
- }
 
--#endif
 
- 
--static void bcma_pcie_mdio_set_phy(struct bcma_drv_pci *pc, u8 phy)
 
-+static void bcma_pcie_mdio_set_phy(struct bcma_drv_pci *pc, u16 phy)
 
- {
 
--	const u16 mdio_control = 0x128;
 
--	const u16 mdio_data = 0x12C;
 
- 	u32 v;
 
- 	int i;
 
- 
--	v = (1 << 30); /* Start of Transaction */
 
--	v |= (1 << 28); /* Write Transaction */
 
--	v |= (1 << 17); /* Turnaround */
 
--	v |= (0x1F << 18);
 
-+	v = BCMA_CORE_PCI_MDIODATA_START;
 
-+	v |= BCMA_CORE_PCI_MDIODATA_WRITE;
 
-+	v |= (BCMA_CORE_PCI_MDIODATA_DEV_ADDR <<
 
-+	      BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF);
 
-+	v |= (BCMA_CORE_PCI_MDIODATA_BLK_ADDR <<
 
-+	      BCMA_CORE_PCI_MDIODATA_REGADDR_SHF);
 
-+	v |= BCMA_CORE_PCI_MDIODATA_TA;
 
- 	v |= (phy << 4);
 
--	pcicore_write32(pc, mdio_data, v);
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_DATA, v);
 
- 
- 	udelay(10);
 
- 	for (i = 0; i < 200; i++) {
 
--		v = pcicore_read32(pc, mdio_control);
 
--		if (v & 0x100 /* Trans complete */)
 
-+		v = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_CONTROL);
 
-+		if (v & BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE)
 
- 			break;
 
--		msleep(1);
 
-+		usleep_range(1000, 2000);
 
- 	}
 
- }
 
- 
--static u16 bcma_pcie_mdio_read(struct bcma_drv_pci *pc, u8 device, u8 address)
 
-+static u16 bcma_pcie_mdio_read(struct bcma_drv_pci *pc, u16 device, u8 address)
 
- {
 
--	const u16 mdio_control = 0x128;
 
--	const u16 mdio_data = 0x12C;
 
- 	int max_retries = 10;
 
- 	u16 ret = 0;
 
- 	u32 v;
 
- 	int i;
 
- 
--	v = 0x80; /* Enable Preamble Sequence */
 
--	v |= 0x2; /* MDIO Clock Divisor */
 
--	pcicore_write32(pc, mdio_control, v);
 
-+	/* enable mdio access to SERDES */
 
-+	v = BCMA_CORE_PCI_MDIOCTL_PREAM_EN;
 
-+	v |= BCMA_CORE_PCI_MDIOCTL_DIVISOR_VAL;
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, v);
 
- 
- 	if (pc->core->id.rev >= 10) {
 
- 		max_retries = 200;
 
- 		bcma_pcie_mdio_set_phy(pc, device);
 
-+		v = (BCMA_CORE_PCI_MDIODATA_DEV_ADDR <<
 
-+		     BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF);
 
-+		v |= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF);
 
-+	} else {
 
-+		v = (device << BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF_OLD);
 
-+		v |= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF_OLD);
 
- 	}
 
- 
--	v = (1 << 30); /* Start of Transaction */
 
--	v |= (1 << 29); /* Read Transaction */
 
--	v |= (1 << 17); /* Turnaround */
 
--	if (pc->core->id.rev < 10)
 
--		v |= (u32)device << 22;
 
--	v |= (u32)address << 18;
 
--	pcicore_write32(pc, mdio_data, v);
 
-+	v = BCMA_CORE_PCI_MDIODATA_START;
 
-+	v |= BCMA_CORE_PCI_MDIODATA_READ;
 
-+	v |= BCMA_CORE_PCI_MDIODATA_TA;
 
-+
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_DATA, v);
 
- 	/* Wait for the device to complete the transaction */
 
- 	udelay(10);
 
- 	for (i = 0; i < max_retries; i++) {
 
--		v = pcicore_read32(pc, mdio_control);
 
--		if (v & 0x100 /* Trans complete */) {
 
-+		v = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_CONTROL);
 
-+		if (v & BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE) {
 
- 			udelay(10);
 
--			ret = pcicore_read32(pc, mdio_data);
 
-+			ret = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_DATA);
 
- 			break;
 
- 		}
 
--		msleep(1);
 
-+		usleep_range(1000, 2000);
 
- 	}
 
--	pcicore_write32(pc, mdio_control, 0);
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, 0);
 
- 	return ret;
 
- }
 
- 
--static void bcma_pcie_mdio_write(struct bcma_drv_pci *pc, u8 device,
 
-+static void bcma_pcie_mdio_write(struct bcma_drv_pci *pc, u16 device,
 
- 				u8 address, u16 data)
 
- {
 
--	const u16 mdio_control = 0x128;
 
--	const u16 mdio_data = 0x12C;
 
- 	int max_retries = 10;
 
- 	u32 v;
 
- 	int i;
 
- 
--	v = 0x80; /* Enable Preamble Sequence */
 
--	v |= 0x2; /* MDIO Clock Divisor */
 
--	pcicore_write32(pc, mdio_control, v);
 
-+	/* enable mdio access to SERDES */
 
-+	v = BCMA_CORE_PCI_MDIOCTL_PREAM_EN;
 
-+	v |= BCMA_CORE_PCI_MDIOCTL_DIVISOR_VAL;
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, v);
 
- 
- 	if (pc->core->id.rev >= 10) {
 
- 		max_retries = 200;
 
- 		bcma_pcie_mdio_set_phy(pc, device);
 
-+		v = (BCMA_CORE_PCI_MDIODATA_DEV_ADDR <<
 
-+		     BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF);
 
-+		v |= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF);
 
-+	} else {
 
-+		v = (device << BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF_OLD);
 
-+		v |= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF_OLD);
 
- 	}
 
- 
--	v = (1 << 30); /* Start of Transaction */
 
--	v |= (1 << 28); /* Write Transaction */
 
--	v |= (1 << 17); /* Turnaround */
 
--	if (pc->core->id.rev < 10)
 
--		v |= (u32)device << 22;
 
--	v |= (u32)address << 18;
 
-+	v = BCMA_CORE_PCI_MDIODATA_START;
 
-+	v |= BCMA_CORE_PCI_MDIODATA_WRITE;
 
-+	v |= BCMA_CORE_PCI_MDIODATA_TA;
 
- 	v |= data;
 
--	pcicore_write32(pc, mdio_data, v);
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_DATA, v);
 
- 	/* Wait for the device to complete the transaction */
 
- 	udelay(10);
 
- 	for (i = 0; i < max_retries; i++) {
 
--		v = pcicore_read32(pc, mdio_control);
 
--		if (v & 0x100 /* Trans complete */)
 
-+		v = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_CONTROL);
 
-+		if (v & BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE)
 
- 			break;
 
--		msleep(1);
 
-+		usleep_range(1000, 2000);
 
- 	}
 
--	pcicore_write32(pc, mdio_control, 0);
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, 0);
 
-+}
 
-+
 
-+static u16 bcma_pcie_mdio_writeread(struct bcma_drv_pci *pc, u16 device,
 
-+				    u8 address, u16 data)
 
-+{
 
-+	bcma_pcie_mdio_write(pc, device, address, data);
 
-+	return bcma_pcie_mdio_read(pc, device, address);
 
- }
 
- 
- /**************************************************
 
-@@ -138,88 +150,134 @@ static void bcma_pcie_mdio_write(struct
 
- 
- static u8 bcma_pcicore_polarity_workaround(struct bcma_drv_pci *pc)
 
- {
 
--	return (bcma_pcie_read(pc, 0x204) & 0x10) ? 0xC0 : 0x80;
 
-+	u32 tmp;
 
-+
 
-+	tmp = bcma_pcie_read(pc, BCMA_CORE_PCI_PLP_STATUSREG);
 
-+	if (tmp & BCMA_CORE_PCI_PLP_POLARITYINV_STAT)
 
-+		return BCMA_CORE_PCI_SERDES_RX_CTRL_FORCE |
 
-+		       BCMA_CORE_PCI_SERDES_RX_CTRL_POLARITY;
 
-+	else
 
-+		return BCMA_CORE_PCI_SERDES_RX_CTRL_FORCE;
 
- }
 
- 
- static void bcma_pcicore_serdes_workaround(struct bcma_drv_pci *pc)
 
- {
 
--	const u8 serdes_pll_device = 0x1D;
 
--	const u8 serdes_rx_device = 0x1F;
 
- 	u16 tmp;
 
- 
--	bcma_pcie_mdio_write(pc, serdes_rx_device, 1 /* Control */,
 
--			      bcma_pcicore_polarity_workaround(pc));
 
--	tmp = bcma_pcie_mdio_read(pc, serdes_pll_device, 1 /* Control */);
 
--	if (tmp & 0x4000)
 
--		bcma_pcie_mdio_write(pc, serdes_pll_device, 1, tmp & ~0x4000);
 
-+	bcma_pcie_mdio_write(pc, BCMA_CORE_PCI_MDIODATA_DEV_RX,
 
-+	                     BCMA_CORE_PCI_SERDES_RX_CTRL,
 
-+			     bcma_pcicore_polarity_workaround(pc));
 
-+	tmp = bcma_pcie_mdio_read(pc, BCMA_CORE_PCI_MDIODATA_DEV_PLL,
 
-+	                          BCMA_CORE_PCI_SERDES_PLL_CTRL);
 
-+	if (tmp & BCMA_CORE_PCI_PLL_CTRL_FREQDET_EN)
 
-+		bcma_pcie_mdio_write(pc, BCMA_CORE_PCI_MDIODATA_DEV_PLL,
 
-+		                     BCMA_CORE_PCI_SERDES_PLL_CTRL,
 
-+		                     tmp & ~BCMA_CORE_PCI_PLL_CTRL_FREQDET_EN);
 
-+}
 
-+
 
-+static void bcma_core_pci_fixcfg(struct bcma_drv_pci *pc)
 
-+{
 
-+	struct bcma_device *core = pc->core;
 
-+	u16 val16, core_index;
 
-+	uint regoff;
 
-+
 
-+	regoff = BCMA_CORE_PCI_SPROM(BCMA_CORE_PCI_SPROM_PI_OFFSET);
 
-+	core_index = (u16)core->core_index;
 
-+
 
-+	val16 = pcicore_read16(pc, regoff);
 
-+	if (((val16 & BCMA_CORE_PCI_SPROM_PI_MASK) >> BCMA_CORE_PCI_SPROM_PI_SHIFT)
 
-+	     != core_index) {
 
-+		val16 = (core_index << BCMA_CORE_PCI_SPROM_PI_SHIFT) |
 
-+			(val16 & ~BCMA_CORE_PCI_SPROM_PI_MASK);
 
-+		pcicore_write16(pc, regoff, val16);
 
-+	}
 
-+}
 
-+
 
-+/* Fix MISC config to allow coming out of L2/L3-Ready state w/o PRST */
 
-+/* Needs to happen when coming out of 'standby'/'hibernate' */
 
-+static void bcma_core_pci_config_fixup(struct bcma_drv_pci *pc)
 
-+{
 
-+	u16 val16;
 
-+	uint regoff;
 
-+
 
-+	regoff = BCMA_CORE_PCI_SPROM(BCMA_CORE_PCI_SPROM_MISC_CONFIG);
 
-+
 
-+	val16 = pcicore_read16(pc, regoff);
 
-+
 
-+	if (!(val16 & BCMA_CORE_PCI_SPROM_L23READY_EXIT_NOPERST)) {
 
-+		val16 |= BCMA_CORE_PCI_SPROM_L23READY_EXIT_NOPERST;
 
-+		pcicore_write16(pc, regoff, val16);
 
-+	}
 
- }
 
- 
- /**************************************************
 
-  * Init.
 
-  **************************************************/
 
- 
--static void bcma_core_pci_clientmode_init(struct bcma_drv_pci *pc)
 
-+static void __devinit bcma_core_pci_clientmode_init(struct bcma_drv_pci *pc)
 
- {
 
-+	bcma_core_pci_fixcfg(pc);
 
- 	bcma_pcicore_serdes_workaround(pc);
 
-+	bcma_core_pci_config_fixup(pc);
 
- }
 
- 
--static bool bcma_core_pci_is_in_hostmode(struct bcma_drv_pci *pc)
 
--{
 
--	struct bcma_bus *bus = pc->core->bus;
 
--	u16 chipid_top;
 
--
 
--	chipid_top = (bus->chipinfo.id & 0xFF00);
 
--	if (chipid_top != 0x4700 &&
 
--	    chipid_top != 0x5300)
 
--		return false;
 
--
 
--#ifdef CONFIG_SSB_DRIVER_PCICORE
 
--	if (bus->sprom.boardflags_lo & SSB_BFL_NOPCI)
 
--		return false;
 
--#endif /* CONFIG_SSB_DRIVER_PCICORE */
 
--
 
--#if 0
 
--	/* TODO: on BCMA we use address from EROM instead of magic formula */
 
--	u32 tmp;
 
--	return !mips_busprobe32(tmp, (bus->mmio +
 
--		(pc->core->core_index * BCMA_CORE_SIZE)));
 
--#endif
 
--
 
--	return true;
 
--}
 
--
 
--void bcma_core_pci_init(struct bcma_drv_pci *pc)
 
-+void __devinit bcma_core_pci_init(struct bcma_drv_pci *pc)
 
- {
 
- 	if (pc->setup_done)
 
- 		return;
 
- 
--	if (bcma_core_pci_is_in_hostmode(pc)) {
 
- #ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE
 
-+	pc->hostmode = bcma_core_pci_is_in_hostmode(pc);
 
-+	if (pc->hostmode)
 
- 		bcma_core_pci_hostmode_init(pc);
 
--#else
 
--		pr_err("Driver compiled without support for hostmode PCI\n");
 
- #endif /* CONFIG_BCMA_DRIVER_PCI_HOSTMODE */
 
--	} else {
 
-+
 
-+	if (!pc->hostmode)
 
- 		bcma_core_pci_clientmode_init(pc);
 
--	}
 
-+}
 
-+
 
-+void bcma_core_pci_power_save(struct bcma_bus *bus, bool up)
 
-+{
 
-+	struct bcma_drv_pci *pc;
 
-+	u16 data;
 
- 
--	pc->setup_done = true;
 
-+	if (bus->hosttype != BCMA_HOSTTYPE_PCI)
 
-+		return;
 
-+
 
-+	pc = &bus->drv_pci[0];
 
-+
 
-+	if (pc->core->id.rev >= 15 && pc->core->id.rev <= 20) {
 
-+		data = up ? 0x74 : 0x7C;
 
-+		bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1,
 
-+					 BCMA_CORE_PCI_MDIO_BLK1_MGMT1, 0x7F64);
 
-+		bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1,
 
-+					 BCMA_CORE_PCI_MDIO_BLK1_MGMT3, data);
 
-+	} else if (pc->core->id.rev >= 21 && pc->core->id.rev <= 22) {
 
-+		data = up ? 0x75 : 0x7D;
 
-+		bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1,
 
-+					 BCMA_CORE_PCI_MDIO_BLK1_MGMT1, 0x7E65);
 
-+		bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1,
 
-+					 BCMA_CORE_PCI_MDIO_BLK1_MGMT3, data);
 
-+	}
 
- }
 
-+EXPORT_SYMBOL_GPL(bcma_core_pci_power_save);
 
- 
- int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc, struct bcma_device *core,
 
- 			  bool enable)
 
- {
 
--	struct pci_dev *pdev = pc->core->bus->host_pci;
 
-+	struct pci_dev *pdev;
 
- 	u32 coremask, tmp;
 
- 	int err = 0;
 
- 
--	if (core->bus->hosttype != BCMA_HOSTTYPE_PCI) {
 
-+	if (!pc || core->bus->hosttype != BCMA_HOSTTYPE_PCI) {
 
- 		/* This bcma device is not on a PCI host-bus. So the IRQs are
 
- 		 * not routed through the PCI core.
 
- 		 * So we must not enable routing through the PCI core. */
 
- 		goto out;
 
- 	}
 
- 
-+	pdev = pc->core->bus->host_pci;
 
-+
 
- 	err = pci_read_config_dword(pdev, BCMA_PCI_IRQMASK, &tmp);
 
- 	if (err)
 
- 		goto out;
 
-@@ -236,3 +294,42 @@ out:
 
- 	return err;
 
- }
 
- EXPORT_SYMBOL_GPL(bcma_core_pci_irq_ctl);
 
-+
 
-+static void bcma_core_pci_extend_L1timer(struct bcma_drv_pci *pc, bool extend)
 
-+{
 
-+	u32 w;
 
-+
 
-+	w = bcma_pcie_read(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG);
 
-+	if (extend)
 
-+		w |= BCMA_CORE_PCI_ASPMTIMER_EXTEND;
 
-+	else
 
-+		w &= ~BCMA_CORE_PCI_ASPMTIMER_EXTEND;
 
-+	bcma_pcie_write(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG, w);
 
-+	bcma_pcie_read(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG);
 
-+}
 
-+
 
-+void bcma_core_pci_up(struct bcma_bus *bus)
 
-+{
 
-+	struct bcma_drv_pci *pc;
 
-+
 
-+	if (bus->hosttype != BCMA_HOSTTYPE_PCI)
 
-+		return;
 
-+
 
-+	pc = &bus->drv_pci[0];
 
-+
 
-+	bcma_core_pci_extend_L1timer(pc, true);
 
-+}
 
-+EXPORT_SYMBOL_GPL(bcma_core_pci_up);
 
-+
 
-+void bcma_core_pci_down(struct bcma_bus *bus)
 
-+{
 
-+	struct bcma_drv_pci *pc;
 
-+
 
-+	if (bus->hosttype != BCMA_HOSTTYPE_PCI)
 
-+		return;
 
-+
 
-+	pc = &bus->drv_pci[0];
 
-+
 
-+	bcma_core_pci_extend_L1timer(pc, false);
 
-+}
 
-+EXPORT_SYMBOL_GPL(bcma_core_pci_down);
 
---- a/drivers/bcma/driver_pci_host.c
 
-+++ b/drivers/bcma/driver_pci_host.c
 
-@@ -2,13 +2,622 @@
 
-  * Broadcom specific AMBA
 
-  * PCI Core in hostmode
 
-  *
 
-+ * Copyright 2005 - 2011, Broadcom Corporation
 
-+ * Copyright 2006, 2007, Michael Buesch <[email protected]>
 
-+ * Copyright 2011, 2012, Hauke Mehrtens <[email protected]>
 
-+ *
 
-  * Licensed under the GNU/GPL. See COPYING for details.
 
-  */
 
- 
- #include "bcma_private.h"
 
-+#include <linux/pci.h>
 
-+#include <linux/export.h>
 
- #include <linux/bcma/bcma.h>
 
-+#include <asm/paccess.h>
 
-+
 
-+/* Probe a 32bit value on the bus and catch bus exceptions.
 
-+ * Returns nonzero on a bus exception.
 
-+ * This is MIPS specific */
 
-+#define mips_busprobe32(val, addr)	get_dbe((val), ((u32 *)(addr)))
 
-+
 
-+/* Assume one-hot slot wiring */
 
-+#define BCMA_PCI_SLOT_MAX	16
 
-+#define	PCI_CONFIG_SPACE_SIZE	256
 
-+
 
-+bool __devinit bcma_core_pci_is_in_hostmode(struct bcma_drv_pci *pc)
 
-+{
 
-+	struct bcma_bus *bus = pc->core->bus;
 
-+	u16 chipid_top;
 
-+	u32 tmp;
 
-+
 
-+	chipid_top = (bus->chipinfo.id & 0xFF00);
 
-+	if (chipid_top != 0x4700 &&
 
-+	    chipid_top != 0x5300)
 
-+		return false;
 
-+
 
-+	bcma_core_enable(pc->core, 0);
 
-+
 
-+	return !mips_busprobe32(tmp, pc->core->io_addr);
 
-+}
 
-+
 
-+static u32 bcma_pcie_read_config(struct bcma_drv_pci *pc, u32 address)
 
-+{
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_CONFIG_ADDR, address);
 
-+	pcicore_read32(pc, BCMA_CORE_PCI_CONFIG_ADDR);
 
-+	return pcicore_read32(pc, BCMA_CORE_PCI_CONFIG_DATA);
 
-+}
 
-+
 
-+static void bcma_pcie_write_config(struct bcma_drv_pci *pc, u32 address,
 
-+				   u32 data)
 
-+{
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_CONFIG_ADDR, address);
 
-+	pcicore_read32(pc, BCMA_CORE_PCI_CONFIG_ADDR);
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_CONFIG_DATA, data);
 
-+}
 
-+
 
-+static u32 bcma_get_cfgspace_addr(struct bcma_drv_pci *pc, unsigned int dev,
 
-+			     unsigned int func, unsigned int off)
 
-+{
 
-+	u32 addr = 0;
 
-+
 
-+	/* Issue config commands only when the data link is up (atleast
 
-+	 * one external pcie device is present).
 
-+	 */
 
-+	if (dev >= 2 || !(bcma_pcie_read(pc, BCMA_CORE_PCI_DLLP_LSREG)
 
-+			  & BCMA_CORE_PCI_DLLP_LSREG_LINKUP))
 
-+		goto out;
 
-+
 
-+	/* Type 0 transaction */
 
-+	/* Slide the PCI window to the appropriate slot */
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI1, BCMA_CORE_PCI_SBTOPCI_CFG0);
 
-+	/* Calculate the address */
 
-+	addr = pc->host_controller->host_cfg_addr;
 
-+	addr |= (dev << BCMA_CORE_PCI_CFG_SLOT_SHIFT);
 
-+	addr |= (func << BCMA_CORE_PCI_CFG_FUN_SHIFT);
 
-+	addr |= (off & ~3);
 
-+
 
-+out:
 
-+	return addr;
 
-+}
 
-+
 
-+static int bcma_extpci_read_config(struct bcma_drv_pci *pc, unsigned int dev,
 
-+				  unsigned int func, unsigned int off,
 
-+				  void *buf, int len)
 
-+{
 
-+	int err = -EINVAL;
 
-+	u32 addr, val;
 
-+	void __iomem *mmio = 0;
 
-+
 
-+	WARN_ON(!pc->hostmode);
 
-+	if (unlikely(len != 1 && len != 2 && len != 4))
 
-+		goto out;
 
-+	if (dev == 0) {
 
-+		/* we support only two functions on device 0 */
 
-+		if (func > 1)
 
-+			goto out;
 
-+
 
-+		/* accesses to config registers with offsets >= 256
 
-+		 * requires indirect access.
 
-+		 */
 
-+		if (off >= PCI_CONFIG_SPACE_SIZE) {
 
-+			addr = (func << 12);
 
-+			addr |= (off & 0x0FFC);
 
-+			val = bcma_pcie_read_config(pc, addr);
 
-+		} else {
 
-+			addr = BCMA_CORE_PCI_PCICFG0;
 
-+			addr |= (func << 8);
 
-+			addr |= (off & 0xFC);
 
-+			val = pcicore_read32(pc, addr);
 
-+		}
 
-+	} else {
 
-+		addr = bcma_get_cfgspace_addr(pc, dev, func, off);
 
-+		if (unlikely(!addr))
 
-+			goto out;
 
-+		err = -ENOMEM;
 
-+		mmio = ioremap_nocache(addr, sizeof(val));
 
-+		if (!mmio)
 
-+			goto out;
 
-+
 
-+		if (mips_busprobe32(val, mmio)) {
 
-+			val = 0xFFFFFFFF;
 
-+			goto unmap;
 
-+		}
 
-+	}
 
-+	val >>= (8 * (off & 3));
 
-+
 
-+	switch (len) {
 
-+	case 1:
 
-+		*((u8 *)buf) = (u8)val;
 
-+		break;
 
-+	case 2:
 
-+		*((u16 *)buf) = (u16)val;
 
-+		break;
 
-+	case 4:
 
-+		*((u32 *)buf) = (u32)val;
 
-+		break;
 
-+	}
 
-+	err = 0;
 
-+unmap:
 
-+	if (mmio)
 
-+		iounmap(mmio);
 
-+out:
 
-+	return err;
 
-+}
 
- 
--void bcma_core_pci_hostmode_init(struct bcma_drv_pci *pc)
 
-+static int bcma_extpci_write_config(struct bcma_drv_pci *pc, unsigned int dev,
 
-+				   unsigned int func, unsigned int off,
 
-+				   const void *buf, int len)
 
- {
 
--	pr_err("No support for PCI core in hostmode yet\n");
 
-+	int err = -EINVAL;
 
-+	u32 addr, val;
 
-+	void __iomem *mmio = 0;
 
-+	u16 chipid = pc->core->bus->chipinfo.id;
 
-+
 
-+	WARN_ON(!pc->hostmode);
 
-+	if (unlikely(len != 1 && len != 2 && len != 4))
 
-+		goto out;
 
-+	if (dev == 0) {
 
-+		/* we support only two functions on device 0 */
 
-+		if (func > 1)
 
-+			goto out;
 
-+
 
-+		/* accesses to config registers with offsets >= 256
 
-+		 * requires indirect access.
 
-+		 */
 
-+		if (off >= PCI_CONFIG_SPACE_SIZE) {
 
-+			addr = (func << 12);
 
-+			addr |= (off & 0x0FFC);
 
-+			val = bcma_pcie_read_config(pc, addr);
 
-+		} else {
 
-+			addr = BCMA_CORE_PCI_PCICFG0;
 
-+			addr |= (func << 8);
 
-+			addr |= (off & 0xFC);
 
-+			val = pcicore_read32(pc, addr);
 
-+		}
 
-+	} else {
 
-+		addr = bcma_get_cfgspace_addr(pc, dev, func, off);
 
-+		if (unlikely(!addr))
 
-+			goto out;
 
-+		err = -ENOMEM;
 
-+		mmio = ioremap_nocache(addr, sizeof(val));
 
-+		if (!mmio)
 
-+			goto out;
 
-+
 
-+		if (mips_busprobe32(val, mmio)) {
 
-+			val = 0xFFFFFFFF;
 
-+			goto unmap;
 
-+		}
 
-+	}
 
-+
 
-+	switch (len) {
 
-+	case 1:
 
-+		val &= ~(0xFF << (8 * (off & 3)));
 
-+		val |= *((const u8 *)buf) << (8 * (off & 3));
 
-+		break;
 
-+	case 2:
 
-+		val &= ~(0xFFFF << (8 * (off & 3)));
 
-+		val |= *((const u16 *)buf) << (8 * (off & 3));
 
-+		break;
 
-+	case 4:
 
-+		val = *((const u32 *)buf);
 
-+		break;
 
-+	}
 
-+	if (dev == 0) {
 
-+		/* accesses to config registers with offsets >= 256
 
-+		 * requires indirect access.
 
-+		 */
 
-+		if (off >= PCI_CONFIG_SPACE_SIZE)
 
-+			bcma_pcie_write_config(pc, addr, val);
 
-+		else
 
-+			pcicore_write32(pc, addr, val);
 
-+	} else {
 
-+		writel(val, mmio);
 
-+
 
-+		if (chipid == BCMA_CHIP_ID_BCM4716 ||
 
-+		    chipid == BCMA_CHIP_ID_BCM4748)
 
-+			readl(mmio);
 
-+	}
 
-+
 
-+	err = 0;
 
-+unmap:
 
-+	if (mmio)
 
-+		iounmap(mmio);
 
-+out:
 
-+	return err;
 
-+}
 
-+
 
-+static int bcma_core_pci_hostmode_read_config(struct pci_bus *bus,
 
-+					      unsigned int devfn,
 
-+					      int reg, int size, u32 *val)
 
-+{
 
-+	unsigned long flags;
 
-+	int err;
 
-+	struct bcma_drv_pci *pc;
 
-+	struct bcma_drv_pci_host *pc_host;
 
-+
 
-+	pc_host = container_of(bus->ops, struct bcma_drv_pci_host, pci_ops);
 
-+	pc = pc_host->pdev;
 
-+
 
-+	spin_lock_irqsave(&pc_host->cfgspace_lock, flags);
 
-+	err = bcma_extpci_read_config(pc, PCI_SLOT(devfn),
 
-+				     PCI_FUNC(devfn), reg, val, size);
 
-+	spin_unlock_irqrestore(&pc_host->cfgspace_lock, flags);
 
-+
 
-+	return err ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
 
-+}
 
-+
 
-+static int bcma_core_pci_hostmode_write_config(struct pci_bus *bus,
 
-+					       unsigned int devfn,
 
-+					       int reg, int size, u32 val)
 
-+{
 
-+	unsigned long flags;
 
-+	int err;
 
-+	struct bcma_drv_pci *pc;
 
-+	struct bcma_drv_pci_host *pc_host;
 
-+
 
-+	pc_host = container_of(bus->ops, struct bcma_drv_pci_host, pci_ops);
 
-+	pc = pc_host->pdev;
 
-+
 
-+	spin_lock_irqsave(&pc_host->cfgspace_lock, flags);
 
-+	err = bcma_extpci_write_config(pc, PCI_SLOT(devfn),
 
-+				      PCI_FUNC(devfn), reg, &val, size);
 
-+	spin_unlock_irqrestore(&pc_host->cfgspace_lock, flags);
 
-+
 
-+	return err ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
 
-+}
 
-+
 
-+/* return cap_offset if requested capability exists in the PCI config space */
 
-+static u8 __devinit bcma_find_pci_capability(struct bcma_drv_pci *pc,
 
-+					     unsigned int dev,
 
-+					     unsigned int func, u8 req_cap_id,
 
-+					     unsigned char *buf, u32 *buflen)
 
-+{
 
-+	u8 cap_id;
 
-+	u8 cap_ptr = 0;
 
-+	u32 bufsize;
 
-+	u8 byte_val;
 
-+
 
-+	/* check for Header type 0 */
 
-+	bcma_extpci_read_config(pc, dev, func, PCI_HEADER_TYPE, &byte_val,
 
-+				sizeof(u8));
 
-+	if ((byte_val & 0x7F) != PCI_HEADER_TYPE_NORMAL)
 
-+		return cap_ptr;
 
-+
 
-+	/* check if the capability pointer field exists */
 
-+	bcma_extpci_read_config(pc, dev, func, PCI_STATUS, &byte_val,
 
-+				sizeof(u8));
 
-+	if (!(byte_val & PCI_STATUS_CAP_LIST))
 
-+		return cap_ptr;
 
-+
 
-+	/* check if the capability pointer is 0x00 */
 
-+	bcma_extpci_read_config(pc, dev, func, PCI_CAPABILITY_LIST, &cap_ptr,
 
-+				sizeof(u8));
 
-+	if (cap_ptr == 0x00)
 
-+		return cap_ptr;
 
-+
 
-+	/* loop thr'u the capability list and see if the requested capabilty
 
-+	 * exists */
 
-+	bcma_extpci_read_config(pc, dev, func, cap_ptr, &cap_id, sizeof(u8));
 
-+	while (cap_id != req_cap_id) {
 
-+		bcma_extpci_read_config(pc, dev, func, cap_ptr + 1, &cap_ptr,
 
-+					sizeof(u8));
 
-+		if (cap_ptr == 0x00)
 
-+			return cap_ptr;
 
-+		bcma_extpci_read_config(pc, dev, func, cap_ptr, &cap_id,
 
-+					sizeof(u8));
 
-+	}
 
-+
 
-+	/* found the caller requested capability */
 
-+	if ((buf != NULL) && (buflen != NULL)) {
 
-+		u8 cap_data;
 
-+
 
-+		bufsize = *buflen;
 
-+		if (!bufsize)
 
-+			return cap_ptr;
 
-+
 
-+		*buflen = 0;
 
-+
 
-+		/* copy the cpability data excluding cap ID and next ptr */
 
-+		cap_data = cap_ptr + 2;
 
-+		if ((bufsize + cap_data)  > PCI_CONFIG_SPACE_SIZE)
 
-+			bufsize = PCI_CONFIG_SPACE_SIZE - cap_data;
 
-+		*buflen = bufsize;
 
-+		while (bufsize--) {
 
-+			bcma_extpci_read_config(pc, dev, func, cap_data, buf,
 
-+						sizeof(u8));
 
-+			cap_data++;
 
-+			buf++;
 
-+		}
 
-+	}
 
-+
 
-+	return cap_ptr;
 
-+}
 
-+
 
-+/* If the root port is capable of returning Config Request
 
-+ * Retry Status (CRS) Completion Status to software then
 
-+ * enable the feature.
 
-+ */
 
-+static void __devinit bcma_core_pci_enable_crs(struct bcma_drv_pci *pc)
 
-+{
 
-+	struct bcma_bus *bus = pc->core->bus;
 
-+	u8 cap_ptr, root_ctrl, root_cap, dev;
 
-+	u16 val16;
 
-+	int i;
 
-+
 
-+	cap_ptr = bcma_find_pci_capability(pc, 0, 0, PCI_CAP_ID_EXP, NULL,
 
-+					   NULL);
 
-+	root_cap = cap_ptr + PCI_EXP_RTCAP;
 
-+	bcma_extpci_read_config(pc, 0, 0, root_cap, &val16, sizeof(u16));
 
-+	if (val16 & BCMA_CORE_PCI_RC_CRS_VISIBILITY) {
 
-+		/* Enable CRS software visibility */
 
-+		root_ctrl = cap_ptr + PCI_EXP_RTCTL;
 
-+		val16 = PCI_EXP_RTCTL_CRSSVE;
 
-+		bcma_extpci_read_config(pc, 0, 0, root_ctrl, &val16,
 
-+					sizeof(u16));
 
-+
 
-+		/* Initiate a configuration request to read the vendor id
 
-+		 * field of the device function's config space header after
 
-+		 * 100 ms wait time from the end of Reset. If the device is
 
-+		 * not done with its internal initialization, it must at
 
-+		 * least return a completion TLP, with a completion status
 
-+		 * of "Configuration Request Retry Status (CRS)". The root
 
-+		 * complex must complete the request to the host by returning
 
-+		 * a read-data value of 0001h for the Vendor ID field and
 
-+		 * all 1s for any additional bytes included in the request.
 
-+		 * Poll using the config reads for max wait time of 1 sec or
 
-+		 * until we receive the successful completion status. Repeat
 
-+		 * the procedure for all the devices.
 
-+		 */
 
-+		for (dev = 1; dev < BCMA_PCI_SLOT_MAX; dev++) {
 
-+			for (i = 0; i < 100000; i++) {
 
-+				bcma_extpci_read_config(pc, dev, 0,
 
-+							PCI_VENDOR_ID, &val16,
 
-+							sizeof(val16));
 
-+				if (val16 != 0x1)
 
-+					break;
 
-+				udelay(10);
 
-+			}
 
-+			if (val16 == 0x1)
 
-+				bcma_err(bus, "PCI: Broken device in slot %d\n",
 
-+					 dev);
 
-+		}
 
-+	}
 
-+}
 
-+
 
-+void __devinit bcma_core_pci_hostmode_init(struct bcma_drv_pci *pc)
 
-+{
 
-+	struct bcma_bus *bus = pc->core->bus;
 
-+	struct bcma_drv_pci_host *pc_host;
 
-+	u32 tmp;
 
-+	u32 pci_membase_1G;
 
-+	unsigned long io_map_base;
 
-+
 
-+	bcma_info(bus, "PCIEcore in host mode found\n");
 
-+
 
-+	if (bus->sprom.boardflags_lo & BCMA_CORE_PCI_BFL_NOPCI) {
 
-+		bcma_info(bus, "This PCIE core is disabled and not working\n");
 
-+		return;
 
-+	}
 
-+
 
-+	pc_host = kzalloc(sizeof(*pc_host), GFP_KERNEL);
 
-+	if (!pc_host)  {
 
-+		bcma_err(bus, "can not allocate memory");
 
-+		return;
 
-+	}
 
-+
 
-+	spin_lock_init(&pc_host->cfgspace_lock);
 
-+
 
-+	pc->host_controller = pc_host;
 
-+	pc_host->pci_controller.io_resource = &pc_host->io_resource;
 
-+	pc_host->pci_controller.mem_resource = &pc_host->mem_resource;
 
-+	pc_host->pci_controller.pci_ops = &pc_host->pci_ops;
 
-+	pc_host->pdev = pc;
 
-+
 
-+	pci_membase_1G = BCMA_SOC_PCI_DMA;
 
-+	pc_host->host_cfg_addr = BCMA_SOC_PCI_CFG;
 
-+
 
-+	pc_host->pci_ops.read = bcma_core_pci_hostmode_read_config;
 
-+	pc_host->pci_ops.write = bcma_core_pci_hostmode_write_config;
 
-+
 
-+	pc_host->mem_resource.name = "BCMA PCIcore external memory",
 
-+	pc_host->mem_resource.start = BCMA_SOC_PCI_DMA;
 
-+	pc_host->mem_resource.end = BCMA_SOC_PCI_DMA + BCMA_SOC_PCI_DMA_SZ - 1;
 
-+	pc_host->mem_resource.flags = IORESOURCE_MEM | IORESOURCE_PCI_FIXED;
 
-+
 
-+	pc_host->io_resource.name = "BCMA PCIcore external I/O",
 
-+	pc_host->io_resource.start = 0x100;
 
-+	pc_host->io_resource.end = 0x7FF;
 
-+	pc_host->io_resource.flags = IORESOURCE_IO | IORESOURCE_PCI_FIXED;
 
-+
 
-+	/* Reset RC */
 
-+	usleep_range(3000, 5000);
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_CTL, BCMA_CORE_PCI_CTL_RST_OE);
 
-+	msleep(50);
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_CTL, BCMA_CORE_PCI_CTL_RST |
 
-+			BCMA_CORE_PCI_CTL_RST_OE);
 
-+
 
-+	/* 64 MB I/O access window. On 4716, use
 
-+	 * sbtopcie0 to access the device registers. We
 
-+	 * can't use address match 2 (1 GB window) region
 
-+	 * as mips can't generate 64-bit address on the
 
-+	 * backplane.
 
-+	 */
 
-+	if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4716 ||
 
-+	    bus->chipinfo.id == BCMA_CHIP_ID_BCM4748) {
 
-+		pc_host->mem_resource.start = BCMA_SOC_PCI_MEM;
 
-+		pc_host->mem_resource.end = BCMA_SOC_PCI_MEM +
 
-+					    BCMA_SOC_PCI_MEM_SZ - 1;
 
-+		pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI0,
 
-+				BCMA_CORE_PCI_SBTOPCI_MEM | BCMA_SOC_PCI_MEM);
 
-+	} else if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4706) {
 
-+		tmp = BCMA_CORE_PCI_SBTOPCI_MEM;
 
-+		tmp |= BCMA_CORE_PCI_SBTOPCI_PREF;
 
-+		tmp |= BCMA_CORE_PCI_SBTOPCI_BURST;
 
-+		if (pc->core->core_unit == 0) {
 
-+			pc_host->mem_resource.start = BCMA_SOC_PCI_MEM;
 
-+			pc_host->mem_resource.end = BCMA_SOC_PCI_MEM +
 
-+						    BCMA_SOC_PCI_MEM_SZ - 1;
 
-+			pc_host->io_resource.start = 0x100;
 
-+			pc_host->io_resource.end = 0x47F;
 
-+			pci_membase_1G = BCMA_SOC_PCIE_DMA_H32;
 
-+			pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI0,
 
-+					tmp | BCMA_SOC_PCI_MEM);
 
-+		} else if (pc->core->core_unit == 1) {
 
-+			pc_host->mem_resource.start = BCMA_SOC_PCI1_MEM;
 
-+			pc_host->mem_resource.end = BCMA_SOC_PCI1_MEM +
 
-+						    BCMA_SOC_PCI_MEM_SZ - 1;
 
-+			pc_host->io_resource.start = 0x480;
 
-+			pc_host->io_resource.end = 0x7FF;
 
-+			pci_membase_1G = BCMA_SOC_PCIE1_DMA_H32;
 
-+			pc_host->host_cfg_addr = BCMA_SOC_PCI1_CFG;
 
-+			pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI0,
 
-+					tmp | BCMA_SOC_PCI1_MEM);
 
-+		}
 
-+	} else
 
-+		pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI0,
 
-+				BCMA_CORE_PCI_SBTOPCI_IO);
 
-+
 
-+	/* 64 MB configuration access window */
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI1, BCMA_CORE_PCI_SBTOPCI_CFG0);
 
-+
 
-+	/* 1 GB memory access window */
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI2,
 
-+			BCMA_CORE_PCI_SBTOPCI_MEM | pci_membase_1G);
 
-+
 
-+
 
-+	/* As per PCI Express Base Spec 1.1 we need to wait for
 
-+	 * at least 100 ms from the end of a reset (cold/warm/hot)
 
-+	 * before issuing configuration requests to PCI Express
 
-+	 * devices.
 
-+	 */
 
-+	msleep(100);
 
-+
 
-+	bcma_core_pci_enable_crs(pc);
 
-+
 
-+	if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4706 ||
 
-+	    bus->chipinfo.id == BCMA_CHIP_ID_BCM4716) {
 
-+		u16 val16;
 
-+		bcma_extpci_read_config(pc, 0, 0, BCMA_CORE_PCI_CFG_DEVCTRL,
 
-+					&val16, sizeof(val16));
 
-+		val16 |= (2 << 5);	/* Max payload size of 512 */
 
-+		val16 |= (2 << 12);	/* MRRS 512 */
 
-+		bcma_extpci_write_config(pc, 0, 0, BCMA_CORE_PCI_CFG_DEVCTRL,
 
-+					 &val16, sizeof(val16));
 
-+	}
 
-+
 
-+	/* Enable PCI bridge BAR0 memory & master access */
 
-+	tmp = PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY;
 
-+	bcma_extpci_write_config(pc, 0, 0, PCI_COMMAND, &tmp, sizeof(tmp));
 
-+
 
-+	/* Enable PCI interrupts */
 
-+	pcicore_write32(pc, BCMA_CORE_PCI_IMASK, BCMA_CORE_PCI_IMASK_INTA);
 
-+
 
-+	/* Ok, ready to run, register it to the system.
 
-+	 * The following needs change, if we want to port hostmode
 
-+	 * to non-MIPS platform. */
 
-+	io_map_base = (unsigned long)ioremap_nocache(pc_host->mem_resource.start,
 
-+						     resource_size(&pc_host->mem_resource));
 
-+	pc_host->pci_controller.io_map_base = io_map_base;
 
-+	set_io_port_base(pc_host->pci_controller.io_map_base);
 
-+	/* Give some time to the PCI controller to configure itself with the new
 
-+	 * values. Not waiting at this point causes crashes of the machine. */
 
-+	usleep_range(10000, 15000);
 
-+	register_pci_controller(&pc_host->pci_controller);
 
-+	return;
 
-+}
 
-+
 
-+/* Early PCI fixup for a device on the PCI-core bridge. */
 
-+static void bcma_core_pci_fixup_pcibridge(struct pci_dev *dev)
 
-+{
 
-+	if (dev->bus->ops->read != bcma_core_pci_hostmode_read_config) {
 
-+		/* This is not a device on the PCI-core bridge. */
 
-+		return;
 
-+	}
 
-+	if (PCI_SLOT(dev->devfn) != 0)
 
-+		return;
 
-+
 
-+	pr_info("PCI: Fixing up bridge %s\n", pci_name(dev));
 
-+
 
-+	/* Enable PCI bridge bus mastering and memory space */
 
-+	pci_set_master(dev);
 
-+	if (pcibios_enable_device(dev, ~0) < 0) {
 
-+		pr_err("PCI: BCMA bridge enable failed\n");
 
-+		return;
 
-+	}
 
-+
 
-+	/* Enable PCI bridge BAR1 prefetch and burst */
 
-+	pci_write_config_dword(dev, BCMA_PCI_BAR1_CONTROL, 3);
 
-+}
 
-+DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID, PCI_ANY_ID, bcma_core_pci_fixup_pcibridge);
 
-+
 
-+/* Early PCI fixup for all PCI-cores to set the correct memory address. */
 
-+static void bcma_core_pci_fixup_addresses(struct pci_dev *dev)
 
-+{
 
-+	struct resource *res;
 
-+	int pos, err;
 
-+
 
-+	if (dev->bus->ops->read != bcma_core_pci_hostmode_read_config) {
 
-+		/* This is not a device on the PCI-core bridge. */
 
-+		return;
 
-+	}
 
-+	if (PCI_SLOT(dev->devfn) == 0)
 
-+		return;
 
-+
 
-+	pr_info("PCI: Fixing up addresses %s\n", pci_name(dev));
 
-+
 
-+	for (pos = 0; pos < 6; pos++) {
 
-+		res = &dev->resource[pos];
 
-+		if (res->flags & (IORESOURCE_IO | IORESOURCE_MEM)) {
 
-+			err = pci_assign_resource(dev, pos);
 
-+			if (err)
 
-+				pr_err("PCI: Problem fixing up the addresses on %s\n",
 
-+				       pci_name(dev));
 
-+		}
 
-+	}
 
-+}
 
-+DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, bcma_core_pci_fixup_addresses);
 
-+
 
-+/* This function is called when doing a pci_enable_device().
 
-+ * We must first check if the device is a device on the PCI-core bridge. */
 
-+int bcma_core_pci_plat_dev_init(struct pci_dev *dev)
 
-+{
 
-+	struct bcma_drv_pci_host *pc_host;
 
-+	int readrq;
 
-+
 
-+	if (dev->bus->ops->read != bcma_core_pci_hostmode_read_config) {
 
-+		/* This is not a device on the PCI-core bridge. */
 
-+		return -ENODEV;
 
-+	}
 
-+	pc_host = container_of(dev->bus->ops, struct bcma_drv_pci_host,
 
-+			       pci_ops);
 
-+
 
-+	pr_info("PCI: Fixing up device %s\n", pci_name(dev));
 
-+
 
-+	/* Fix up interrupt lines */
 
-+	dev->irq = bcma_core_irq(pc_host->pdev->core);
 
-+	pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
 
-+
 
-+	readrq = pcie_get_readrq(dev);
 
-+	if (readrq > 128) {
 
-+		pr_info("change PCIe max read request size from %i to 128\n", readrq);
 
-+		pcie_set_readrq(dev, 128);
 
-+	}
 
-+	return 0;
 
-+}
 
-+EXPORT_SYMBOL(bcma_core_pci_plat_dev_init);
 
-+
 
-+/* PCI device IRQ mapping. */
 
-+int bcma_core_pci_pcibios_map_irq(const struct pci_dev *dev)
 
-+{
 
-+	struct bcma_drv_pci_host *pc_host;
 
-+
 
-+	if (dev->bus->ops->read != bcma_core_pci_hostmode_read_config) {
 
-+		/* This is not a device on the PCI-core bridge. */
 
-+		return -ENODEV;
 
-+	}
 
-+
 
-+	pc_host = container_of(dev->bus->ops, struct bcma_drv_pci_host,
 
-+			       pci_ops);
 
-+	return bcma_core_irq(pc_host->pdev->core);
 
- }
 
-+EXPORT_SYMBOL(bcma_core_pci_pcibios_map_irq);
 
---- a/drivers/bcma/host_pci.c
 
-+++ b/drivers/bcma/host_pci.c
 
-@@ -18,7 +18,7 @@ static void bcma_host_pci_switch_core(st
 
- 	pci_write_config_dword(core->bus->host_pci, BCMA_PCI_BAR0_WIN2,
 
- 			       core->wrap);
 
- 	core->bus->mapped_core = core;
 
--	pr_debug("Switched to core: 0x%X\n", core->id.id);
 
-+	bcma_debug(core->bus, "Switched to core: 0x%X\n", core->id.id);
 
- }
 
- 
- /* Provides access to the requested core. Returns base offset that has to be
 
-@@ -77,8 +77,8 @@ static void bcma_host_pci_write32(struct
 
- }
 
- 
- #ifdef CONFIG_BCMA_BLOCKIO
 
--void bcma_host_pci_block_read(struct bcma_device *core, void *buffer,
 
--			      size_t count, u16 offset, u8 reg_width)
 
-+static void bcma_host_pci_block_read(struct bcma_device *core, void *buffer,
 
-+				     size_t count, u16 offset, u8 reg_width)
 
- {
 
- 	void __iomem *addr = core->bus->mmio + offset;
 
- 	if (core->bus->mapped_core != core)
 
-@@ -100,8 +100,9 @@ void bcma_host_pci_block_read(struct bcm
 
- 	}
 
- }
 
- 
--void bcma_host_pci_block_write(struct bcma_device *core, const void *buffer,
 
--			       size_t count, u16 offset, u8 reg_width)
 
-+static void bcma_host_pci_block_write(struct bcma_device *core,
 
-+				      const void *buffer, size_t count,
 
-+				      u16 offset, u8 reg_width)
 
- {
 
- 	void __iomem *addr = core->bus->mmio + offset;
 
- 	if (core->bus->mapped_core != core)
 
-@@ -139,7 +140,7 @@ static void bcma_host_pci_awrite32(struc
 
- 	iowrite32(value, core->bus->mmio + (1 * BCMA_CORE_SIZE) + offset);
 
- }
 
- 
--const struct bcma_host_ops bcma_host_pci_ops = {
 
-+static const struct bcma_host_ops bcma_host_pci_ops = {
 
- 	.read8		= bcma_host_pci_read8,
 
- 	.read16		= bcma_host_pci_read16,
 
- 	.read32		= bcma_host_pci_read32,
 
-@@ -154,8 +155,8 @@ const struct bcma_host_ops bcma_host_pci
 
- 	.awrite32	= bcma_host_pci_awrite32,
 
- };
 
- 
--static int bcma_host_pci_probe(struct pci_dev *dev,
 
--			     const struct pci_device_id *id)
 
-+static int __devinit bcma_host_pci_probe(struct pci_dev *dev,
 
-+					 const struct pci_device_id *id)
 
- {
 
- 	struct bcma_bus *bus;
 
- 	int err = -ENOMEM;
 
-@@ -188,7 +189,7 @@ static int bcma_host_pci_probe(struct pc
 
- 
- 	/* SSB needed additional powering up, do we have any AMBA PCI cards? */
 
- 	if (!pci_is_pcie(dev))
 
--		pr_err("PCI card detected, report problems.\n");
 
-+		bcma_err(bus, "PCI card detected, report problems.\n");
 
- 
- 	/* Map MMIO */
 
- 	err = -ENOMEM;
 
-@@ -201,6 +202,9 @@ static int bcma_host_pci_probe(struct pc
 
- 	bus->hosttype = BCMA_HOSTTYPE_PCI;
 
- 	bus->ops = &bcma_host_pci_ops;
 
- 
-+	bus->boardinfo.vendor = bus->host_pci->subsystem_vendor;
 
-+	bus->boardinfo.type = bus->host_pci->subsystem_device;
 
-+
 
- 	/* Register */
 
- 	err = bcma_bus_register(bus);
 
- 	if (err)
 
-@@ -222,7 +226,7 @@ err_kfree_bus:
 
- 	return err;
 
- }
 
- 
--static void bcma_host_pci_remove(struct pci_dev *dev)
 
-+static void __devexit bcma_host_pci_remove(struct pci_dev *dev)
 
- {
 
- 	struct bcma_bus *bus = pci_get_drvdata(dev);
 
- 
-@@ -234,7 +238,7 @@ static void bcma_host_pci_remove(struct
 
- 	pci_set_drvdata(dev, NULL);
 
- }
 
- 
--#ifdef CONFIG_PM
 
-+#ifdef CONFIG_PM_SLEEP
 
- static int bcma_host_pci_suspend(struct device *dev)
 
- {
 
- 	struct pci_dev *pdev = to_pci_dev(dev);
 
-@@ -257,17 +261,21 @@ static SIMPLE_DEV_PM_OPS(bcma_pm_ops, bc
 
- 			 bcma_host_pci_resume);
 
- #define BCMA_PM_OPS	(&bcma_pm_ops)
 
- 
--#else /* CONFIG_PM */
 
-+#else /* CONFIG_PM_SLEEP */
 
- 
- #define BCMA_PM_OPS     NULL
 
- 
--#endif /* CONFIG_PM */
 
-+#endif /* CONFIG_PM_SLEEP */
 
- 
- static DEFINE_PCI_DEVICE_TABLE(bcma_pci_bridge_tbl) = {
 
- 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x0576) },
 
-+	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 43224) },
 
- 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4331) },
 
- 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4353) },
 
- 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4357) },
 
-+	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4358) },
 
-+	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4359) },
 
-+	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4365) },
 
- 	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4727) },
 
- 	{ 0, },
 
- };
 
-@@ -277,7 +285,7 @@ static struct pci_driver bcma_pci_bridge
 
- 	.name = "bcma-pci-bridge",
 
- 	.id_table = bcma_pci_bridge_tbl,
 
- 	.probe = bcma_host_pci_probe,
 
--	.remove = bcma_host_pci_remove,
 
-+	.remove = __devexit_p(bcma_host_pci_remove),
 
- 	.driver.pm = BCMA_PM_OPS,
 
- };
 
- 
---- a/drivers/bcma/host_soc.c
 
-+++ b/drivers/bcma/host_soc.c
 
-@@ -143,7 +143,7 @@ static void bcma_host_soc_awrite32(struc
 
- 	writel(value, core->io_wrap + offset);
 
- }
 
- 
--const struct bcma_host_ops bcma_host_soc_ops = {
 
-+static const struct bcma_host_ops bcma_host_soc_ops = {
 
- 	.read8		= bcma_host_soc_read8,
 
- 	.read16		= bcma_host_soc_read16,
 
- 	.read32		= bcma_host_soc_read32,
 
---- a/drivers/bcma/main.c
 
-+++ b/drivers/bcma/main.c
 
-@@ -7,12 +7,19 @@
 
- 
- #include "bcma_private.h"
 
- #include <linux/module.h>
 
-+#include <linux/platform_device.h>
 
- #include <linux/bcma/bcma.h>
 
- #include <linux/slab.h>
 
- 
- MODULE_DESCRIPTION("Broadcom's specific AMBA driver");
 
- MODULE_LICENSE("GPL");
 
- 
-+/* contains the number the next bus should get. */
 
-+static unsigned int bcma_bus_next_num = 0;
 
-+
 
-+/* bcma_buses_mutex locks the bcma_bus_next_num */
 
-+static DEFINE_MUTEX(bcma_buses_mutex);
 
-+
 
- static int bcma_bus_match(struct device *dev, struct device_driver *drv);
 
- static int bcma_device_probe(struct device *dev);
 
- static int bcma_device_remove(struct device *dev);
 
-@@ -55,7 +62,14 @@ static struct bus_type bcma_bus_type = {
 
- 	.dev_attrs	= bcma_device_attrs,
 
- };
 
- 
--static struct bcma_device *bcma_find_core(struct bcma_bus *bus, u16 coreid)
 
-+static u16 bcma_cc_core_id(struct bcma_bus *bus)
 
-+{
 
-+	if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4706)
 
-+		return BCMA_CORE_4706_CHIPCOMMON;
 
-+	return BCMA_CORE_CHIPCOMMON;
 
-+}
 
-+
 
-+struct bcma_device *bcma_find_core(struct bcma_bus *bus, u16 coreid)
 
- {
 
- 	struct bcma_device *core;
 
- 
-@@ -65,6 +79,38 @@ static struct bcma_device *bcma_find_cor
 
- 	}
 
- 	return NULL;
 
- }
 
-+EXPORT_SYMBOL_GPL(bcma_find_core);
 
-+
 
-+struct bcma_device *bcma_find_core_unit(struct bcma_bus *bus, u16 coreid,
 
-+					u8 unit)
 
-+{
 
-+	struct bcma_device *core;
 
-+
 
-+	list_for_each_entry(core, &bus->cores, list) {
 
-+		if (core->id.id == coreid && core->core_unit == unit)
 
-+			return core;
 
-+	}
 
-+	return NULL;
 
-+}
 
-+
 
-+bool bcma_wait_value(struct bcma_device *core, u16 reg, u32 mask, u32 value,
 
-+		     int timeout)
 
-+{
 
-+	unsigned long deadline = jiffies + timeout;
 
-+	u32 val;
 
-+
 
-+	do {
 
-+		val = bcma_read32(core, reg);
 
-+		if ((val & mask) == value)
 
-+			return true;
 
-+		cpu_relax();
 
-+		udelay(10);
 
-+	} while (!time_after_eq(jiffies, deadline));
 
-+
 
-+	bcma_warn(core->bus, "Timeout waiting for register 0x%04X!\n", reg);
 
-+
 
-+	return false;
 
-+}
 
- 
- static void bcma_release_core_dev(struct device *dev)
 
- {
 
-@@ -84,16 +130,23 @@ static int bcma_register_cores(struct bc
 
- 	list_for_each_entry(core, &bus->cores, list) {
 
- 		/* We support that cores ourself */
 
- 		switch (core->id.id) {
 
-+		case BCMA_CORE_4706_CHIPCOMMON:
 
- 		case BCMA_CORE_CHIPCOMMON:
 
- 		case BCMA_CORE_PCI:
 
- 		case BCMA_CORE_PCIE:
 
- 		case BCMA_CORE_MIPS_74K:
 
-+		case BCMA_CORE_4706_MAC_GBIT_COMMON:
 
- 			continue;
 
- 		}
 
- 
-+		/* Only first GMAC core on BCM4706 is connected and working */
 
-+		if (core->id.id == BCMA_CORE_4706_MAC_GBIT &&
 
-+		    core->core_unit > 0)
 
-+			continue;
 
-+
 
- 		core->dev.release = bcma_release_core_dev;
 
- 		core->dev.bus = &bcma_bus_type;
 
--		dev_set_name(&core->dev, "bcma%d:%d", 0/*bus->num*/, dev_id);
 
-+		dev_set_name(&core->dev, "bcma%d:%d", bus->num, dev_id);
 
- 
- 		switch (bus->hosttype) {
 
- 		case BCMA_HOSTTYPE_PCI:
 
-@@ -111,41 +164,98 @@ static int bcma_register_cores(struct bc
 
- 
- 		err = device_register(&core->dev);
 
- 		if (err) {
 
--			pr_err("Could not register dev for core 0x%03X\n",
 
--			       core->id.id);
 
-+			bcma_err(bus,
 
-+				 "Could not register dev for core 0x%03X\n",
 
-+				 core->id.id);
 
- 			continue;
 
- 		}
 
- 		core->dev_registered = true;
 
- 		dev_id++;
 
- 	}
 
- 
-+#ifdef CONFIG_BCMA_DRIVER_MIPS
 
-+	if (bus->drv_cc.pflash.present) {
 
-+		err = platform_device_register(&bcma_pflash_dev);
 
-+		if (err)
 
-+			bcma_err(bus, "Error registering parallel flash\n");
 
-+	}
 
-+#endif
 
-+
 
-+#ifdef CONFIG_BCMA_SFLASH
 
-+	if (bus->drv_cc.sflash.present) {
 
-+		err = platform_device_register(&bcma_sflash_dev);
 
-+		if (err)
 
-+			bcma_err(bus, "Error registering serial flash\n");
 
-+	}
 
-+#endif
 
-+
 
-+#ifdef CONFIG_BCMA_NFLASH
 
-+	if (bus->drv_cc.nflash.present) {
 
-+		err = platform_device_register(&bcma_nflash_dev);
 
-+		if (err)
 
-+			bcma_err(bus, "Error registering NAND flash\n");
 
-+	}
 
-+#endif
 
-+	err = bcma_gpio_init(&bus->drv_cc);
 
-+	if (err == -ENOTSUPP)
 
-+		bcma_debug(bus, "GPIO driver not activated\n");
 
-+	else if (err)
 
-+		bcma_err(bus, "Error registering GPIO driver: %i\n", err);
 
-+
 
-+	if (bus->hosttype == BCMA_HOSTTYPE_SOC) {
 
-+		err = bcma_chipco_watchdog_register(&bus->drv_cc);
 
-+		if (err)
 
-+			bcma_err(bus, "Error registering watchdog driver\n");
 
-+	}
 
-+
 
- 	return 0;
 
- }
 
- 
- static void bcma_unregister_cores(struct bcma_bus *bus)
 
- {
 
--	struct bcma_device *core;
 
-+	struct bcma_device *core, *tmp;
 
- 
--	list_for_each_entry(core, &bus->cores, list) {
 
-+	list_for_each_entry_safe(core, tmp, &bus->cores, list) {
 
-+		list_del(&core->list);
 
- 		if (core->dev_registered)
 
- 			device_unregister(&core->dev);
 
- 	}
 
-+	if (bus->hosttype == BCMA_HOSTTYPE_SOC)
 
-+		platform_device_unregister(bus->drv_cc.watchdog);
 
- }
 
- 
--int bcma_bus_register(struct bcma_bus *bus)
 
-+int __devinit bcma_bus_register(struct bcma_bus *bus)
 
- {
 
- 	int err;
 
- 	struct bcma_device *core;
 
- 
-+	mutex_lock(&bcma_buses_mutex);
 
-+	bus->num = bcma_bus_next_num++;
 
-+	mutex_unlock(&bcma_buses_mutex);
 
-+
 
- 	/* Scan for devices (cores) */
 
- 	err = bcma_bus_scan(bus);
 
- 	if (err) {
 
--		pr_err("Failed to scan: %d\n", err);
 
--		return -1;
 
-+		bcma_err(bus, "Failed to scan: %d\n", err);
 
-+		return err;
 
- 	}
 
- 
-+	/* Early init CC core */
 
-+	core = bcma_find_core(bus, bcma_cc_core_id(bus));
 
-+	if (core) {
 
-+		bus->drv_cc.core = core;
 
-+		bcma_core_chipcommon_early_init(&bus->drv_cc);
 
-+	}
 
-+
 
-+	/* Try to get SPROM */
 
-+	err = bcma_sprom_get(bus);
 
-+	if (err == -ENOENT) {
 
-+		bcma_err(bus, "No SPROM available\n");
 
-+	} else if (err)
 
-+		bcma_err(bus, "Failed to get SPROM: %d\n", err);
 
-+
 
- 	/* Init CC core */
 
--	core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
 
-+	core = bcma_find_core(bus, bcma_cc_core_id(bus));
 
- 	if (core) {
 
- 		bus->drv_cc.core = core;
 
- 		bcma_core_chipcommon_init(&bus->drv_cc);
 
-@@ -159,30 +269,54 @@ int bcma_bus_register(struct bcma_bus *b
 
- 	}
 
- 
- 	/* Init PCIE core */
 
--	core = bcma_find_core(bus, BCMA_CORE_PCIE);
 
-+	core = bcma_find_core_unit(bus, BCMA_CORE_PCIE, 0);
 
- 	if (core) {
 
--		bus->drv_pci.core = core;
 
--		bcma_core_pci_init(&bus->drv_pci);
 
-+		bus->drv_pci[0].core = core;
 
-+		bcma_core_pci_init(&bus->drv_pci[0]);
 
- 	}
 
- 
--	/* Try to get SPROM */
 
--	err = bcma_sprom_get(bus);
 
--	if (err == -ENOENT) {
 
--		pr_err("No SPROM available\n");
 
--	} else if (err)
 
--		pr_err("Failed to get SPROM: %d\n", err);
 
-+	/* Init PCIE core */
 
-+	core = bcma_find_core_unit(bus, BCMA_CORE_PCIE, 1);
 
-+	if (core) {
 
-+		bus->drv_pci[1].core = core;
 
-+		bcma_core_pci_init(&bus->drv_pci[1]);
 
-+	}
 
-+
 
-+	/* Init GBIT MAC COMMON core */
 
-+	core = bcma_find_core(bus, BCMA_CORE_4706_MAC_GBIT_COMMON);
 
-+	if (core) {
 
-+		bus->drv_gmac_cmn.core = core;
 
-+		bcma_core_gmac_cmn_init(&bus->drv_gmac_cmn);
 
-+	}
 
- 
- 	/* Register found cores */
 
- 	bcma_register_cores(bus);
 
- 
--	pr_info("Bus registered\n");
 
-+	bcma_info(bus, "Bus registered\n");
 
- 
- 	return 0;
 
- }
 
- 
- void bcma_bus_unregister(struct bcma_bus *bus)
 
- {
 
-+	struct bcma_device *cores[3];
 
-+	int err;
 
-+
 
-+	err = bcma_gpio_unregister(&bus->drv_cc);
 
-+	if (err == -EBUSY)
 
-+		bcma_err(bus, "Some GPIOs are still in use.\n");
 
-+	else if (err)
 
-+		bcma_err(bus, "Can not unregister GPIO driver: %i\n", err);
 
-+
 
-+	cores[0] = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
 
-+	cores[1] = bcma_find_core(bus, BCMA_CORE_PCIE);
 
-+	cores[2] = bcma_find_core(bus, BCMA_CORE_4706_MAC_GBIT_COMMON);
 
-+
 
- 	bcma_unregister_cores(bus);
 
-+
 
-+	kfree(cores[2]);
 
-+	kfree(cores[1]);
 
-+	kfree(cores[0]);
 
- }
 
- 
- int __init bcma_bus_early_register(struct bcma_bus *bus,
 
-@@ -196,14 +330,14 @@ int __init bcma_bus_early_register(struc
 
- 	bcma_init_bus(bus);
 
- 
- 	match.manuf = BCMA_MANUF_BCM;
 
--	match.id = BCMA_CORE_CHIPCOMMON;
 
-+	match.id = bcma_cc_core_id(bus);
 
- 	match.class = BCMA_CL_SIM;
 
- 	match.rev = BCMA_ANY_REV;
 
- 
- 	/* Scan for chip common core */
 
- 	err = bcma_bus_scan_early(bus, &match, core_cc);
 
- 	if (err) {
 
--		pr_err("Failed to scan for common core: %d\n", err);
 
-+		bcma_err(bus, "Failed to scan for common core: %d\n", err);
 
- 		return -1;
 
- 	}
 
- 
-@@ -215,25 +349,25 @@ int __init bcma_bus_early_register(struc
 
- 	/* Scan for mips core */
 
- 	err = bcma_bus_scan_early(bus, &match, core_mips);
 
- 	if (err) {
 
--		pr_err("Failed to scan for mips core: %d\n", err);
 
-+		bcma_err(bus, "Failed to scan for mips core: %d\n", err);
 
- 		return -1;
 
- 	}
 
- 
--	/* Init CC core */
 
--	core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
 
-+	/* Early init CC core */
 
-+	core = bcma_find_core(bus, bcma_cc_core_id(bus));
 
- 	if (core) {
 
- 		bus->drv_cc.core = core;
 
--		bcma_core_chipcommon_init(&bus->drv_cc);
 
-+		bcma_core_chipcommon_early_init(&bus->drv_cc);
 
- 	}
 
- 
--	/* Init MIPS core */
 
-+	/* Early init MIPS core */
 
- 	core = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
 
- 	if (core) {
 
- 		bus->drv_mips.core = core;
 
--		bcma_core_mips_init(&bus->drv_mips);
 
-+		bcma_core_mips_early_init(&bus->drv_mips);
 
- 	}
 
- 
--	pr_info("Early bus registered\n");
 
-+	bcma_info(bus, "Early bus registered\n");
 
- 
- 	return 0;
 
- }
 
-@@ -259,8 +393,7 @@ int bcma_bus_resume(struct bcma_bus *bus
 
- 	struct bcma_device *core;
 
- 
- 	/* Init CC core */
 
--	core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
 
--	if (core) {
 
-+	if (bus->drv_cc.core) {
 
- 		bus->drv_cc.setup_done = false;
 
- 		bcma_core_chipcommon_init(&bus->drv_cc);
 
- 	}
 
---- a/drivers/bcma/scan.c
 
-+++ b/drivers/bcma/scan.c
 
-@@ -19,15 +19,39 @@ struct bcma_device_id_name {
 
- 	u16 id;
 
- 	const char *name;
 
- };
 
--struct bcma_device_id_name bcma_device_names[] = {
 
-+
 
-+static const struct bcma_device_id_name bcma_arm_device_names[] = {
 
-+	{ BCMA_CORE_4706_MAC_GBIT_COMMON, "BCM4706 GBit MAC Common" },
 
-+	{ BCMA_CORE_ARM_1176, "ARM 1176" },
 
-+	{ BCMA_CORE_ARM_7TDMI, "ARM 7TDMI" },
 
-+	{ BCMA_CORE_ARM_CM3, "ARM CM3" },
 
-+};
 
-+
 
-+static const struct bcma_device_id_name bcma_bcm_device_names[] = {
 
- 	{ BCMA_CORE_OOB_ROUTER, "OOB Router" },
 
-+	{ BCMA_CORE_4706_CHIPCOMMON, "BCM4706 ChipCommon" },
 
-+	{ BCMA_CORE_4706_SOC_RAM, "BCM4706 SOC RAM" },
 
-+	{ BCMA_CORE_4706_MAC_GBIT, "BCM4706 GBit MAC" },
 
-+	{ BCMA_CORE_PCIEG2, "PCIe Gen 2" },
 
-+	{ BCMA_CORE_DMA, "DMA" },
 
-+	{ BCMA_CORE_SDIO3, "SDIO3" },
 
-+	{ BCMA_CORE_USB20, "USB 2.0" },
 
-+	{ BCMA_CORE_USB30, "USB 3.0" },
 
-+	{ BCMA_CORE_A9JTAG, "ARM Cortex A9 JTAG" },
 
-+	{ BCMA_CORE_DDR23, "Denali DDR2/DDR3 memory controller" },
 
-+	{ BCMA_CORE_ROM, "ROM" },
 
-+	{ BCMA_CORE_NAND, "NAND flash controller" },
 
-+	{ BCMA_CORE_QSPI, "SPI flash controller" },
 
-+	{ BCMA_CORE_CHIPCOMMON_B, "Chipcommon B" },
 
-+	{ BCMA_CORE_ARMCA9, "ARM Cortex A9 core (ihost)" },
 
-+	{ BCMA_CORE_AMEMC, "AMEMC (DDR)" },
 
-+	{ BCMA_CORE_ALTA, "ALTA (I2S)" },
 
- 	{ BCMA_CORE_INVALID, "Invalid" },
 
- 	{ BCMA_CORE_CHIPCOMMON, "ChipCommon" },
 
- 	{ BCMA_CORE_ILINE20, "ILine 20" },
 
- 	{ BCMA_CORE_SRAM, "SRAM" },
 
- 	{ BCMA_CORE_SDRAM, "SDRAM" },
 
- 	{ BCMA_CORE_PCI, "PCI" },
 
--	{ BCMA_CORE_MIPS, "MIPS" },
 
- 	{ BCMA_CORE_ETHERNET, "Fast Ethernet" },
 
- 	{ BCMA_CORE_V90, "V90" },
 
- 	{ BCMA_CORE_USB11_HOSTDEV, "USB 1.1 Hostdev" },
 
-@@ -44,7 +68,6 @@ struct bcma_device_id_name bcma_device_n
 
- 	{ BCMA_CORE_PHY_A, "PHY A" },
 
- 	{ BCMA_CORE_PHY_B, "PHY B" },
 
- 	{ BCMA_CORE_PHY_G, "PHY G" },
 
--	{ BCMA_CORE_MIPS_3302, "MIPS 3302" },
 
- 	{ BCMA_CORE_USB11_HOST, "USB 1.1 Host" },
 
- 	{ BCMA_CORE_USB11_DEV, "USB 1.1 Device" },
 
- 	{ BCMA_CORE_USB20_HOST, "USB 2.0 Host" },
 
-@@ -58,15 +81,11 @@ struct bcma_device_id_name bcma_device_n
 
- 	{ BCMA_CORE_PHY_N, "PHY N" },
 
- 	{ BCMA_CORE_SRAM_CTL, "SRAM Controller" },
 
- 	{ BCMA_CORE_MINI_MACPHY, "Mini MACPHY" },
 
--	{ BCMA_CORE_ARM_1176, "ARM 1176" },
 
--	{ BCMA_CORE_ARM_7TDMI, "ARM 7TDMI" },
 
- 	{ BCMA_CORE_PHY_LP, "PHY LP" },
 
- 	{ BCMA_CORE_PMU, "PMU" },
 
- 	{ BCMA_CORE_PHY_SSN, "PHY SSN" },
 
- 	{ BCMA_CORE_SDIO_DEV, "SDIO Device" },
 
--	{ BCMA_CORE_ARM_CM3, "ARM CM3" },
 
- 	{ BCMA_CORE_PHY_HT, "PHY HT" },
 
--	{ BCMA_CORE_MIPS_74K, "MIPS 74K" },
 
- 	{ BCMA_CORE_MAC_GBIT, "GBit MAC" },
 
- 	{ BCMA_CORE_DDR12_MEM_CTL, "DDR1/DDR2 Memory Controller" },
 
- 	{ BCMA_CORE_PCIE_RC, "PCIe Root Complex" },
 
-@@ -77,18 +96,45 @@ struct bcma_device_id_name bcma_device_n
 
- 	{ BCMA_CORE_I2S, "I2S" },
 
- 	{ BCMA_CORE_SDR_DDR1_MEM_CTL, "SDR/DDR1 Memory Controller" },
 
- 	{ BCMA_CORE_SHIM, "SHIM" },
 
-+	{ BCMA_CORE_PCIE2, "PCIe Gen2" },
 
-+	{ BCMA_CORE_ARM_CR4, "ARM CR4" },
 
- 	{ BCMA_CORE_DEFAULT, "Default" },
 
- };
 
--const char *bcma_device_name(struct bcma_device_id *id)
 
-+
 
-+static const struct bcma_device_id_name bcma_mips_device_names[] = {
 
-+	{ BCMA_CORE_MIPS, "MIPS" },
 
-+	{ BCMA_CORE_MIPS_3302, "MIPS 3302" },
 
-+	{ BCMA_CORE_MIPS_74K, "MIPS 74K" },
 
-+};
 
-+
 
-+static const char *bcma_device_name(const struct bcma_device_id *id)
 
- {
 
--	int i;
 
-+	const struct bcma_device_id_name *names;
 
-+	int size, i;
 
- 
--	if (id->manuf == BCMA_MANUF_BCM) {
 
--		for (i = 0; i < ARRAY_SIZE(bcma_device_names); i++) {
 
--			if (bcma_device_names[i].id == id->id)
 
--				return bcma_device_names[i].name;
 
--		}
 
-+	/* search manufacturer specific names */
 
-+	switch (id->manuf) {
 
-+	case BCMA_MANUF_ARM:
 
-+		names = bcma_arm_device_names;
 
-+		size = ARRAY_SIZE(bcma_arm_device_names);
 
-+		break;
 
-+	case BCMA_MANUF_BCM:
 
-+		names = bcma_bcm_device_names;
 
-+		size = ARRAY_SIZE(bcma_bcm_device_names);
 
-+		break;
 
-+	case BCMA_MANUF_MIPS:
 
-+		names = bcma_mips_device_names;
 
-+		size = ARRAY_SIZE(bcma_mips_device_names);
 
-+		break;
 
-+	default:
 
-+		return "UNKNOWN";
 
-+	}
 
-+
 
-+	for (i = 0; i < size; i++) {
 
-+		if (names[i].id == id->id)
 
-+			return names[i].name;
 
- 	}
 
-+
 
- 	return "UNKNOWN";
 
- }
 
- 
-@@ -105,19 +151,19 @@ static void bcma_scan_switch_core(struct
 
- 				       addr);
 
- }
 
- 
--static u32 bcma_erom_get_ent(struct bcma_bus *bus, u32 **eromptr)
 
-+static u32 bcma_erom_get_ent(struct bcma_bus *bus, u32 __iomem **eromptr)
 
- {
 
- 	u32 ent = readl(*eromptr);
 
- 	(*eromptr)++;
 
- 	return ent;
 
- }
 
- 
--static void bcma_erom_push_ent(u32 **eromptr)
 
-+static void bcma_erom_push_ent(u32 __iomem **eromptr)
 
- {
 
- 	(*eromptr)--;
 
- }
 
- 
--static s32 bcma_erom_get_ci(struct bcma_bus *bus, u32 **eromptr)
 
-+static s32 bcma_erom_get_ci(struct bcma_bus *bus, u32 __iomem **eromptr)
 
- {
 
- 	u32 ent = bcma_erom_get_ent(bus, eromptr);
 
- 	if (!(ent & SCAN_ER_VALID))
 
-@@ -127,14 +173,14 @@ static s32 bcma_erom_get_ci(struct bcma_
 
- 	return ent;
 
- }
 
- 
--static bool bcma_erom_is_end(struct bcma_bus *bus, u32 **eromptr)
 
-+static bool bcma_erom_is_end(struct bcma_bus *bus, u32 __iomem **eromptr)
 
- {
 
- 	u32 ent = bcma_erom_get_ent(bus, eromptr);
 
- 	bcma_erom_push_ent(eromptr);
 
- 	return (ent == (SCAN_ER_TAG_END | SCAN_ER_VALID));
 
- }
 
- 
--static bool bcma_erom_is_bridge(struct bcma_bus *bus, u32 **eromptr)
 
-+static bool bcma_erom_is_bridge(struct bcma_bus *bus, u32 __iomem **eromptr)
 
- {
 
- 	u32 ent = bcma_erom_get_ent(bus, eromptr);
 
- 	bcma_erom_push_ent(eromptr);
 
-@@ -143,7 +189,7 @@ static bool bcma_erom_is_bridge(struct b
 
- 		((ent & SCAN_ADDR_TYPE) == SCAN_ADDR_TYPE_BRIDGE));
 
- }
 
- 
--static void bcma_erom_skip_component(struct bcma_bus *bus, u32 **eromptr)
 
-+static void bcma_erom_skip_component(struct bcma_bus *bus, u32 __iomem **eromptr)
 
- {
 
- 	u32 ent;
 
- 	while (1) {
 
-@@ -157,7 +203,7 @@ static void bcma_erom_skip_component(str
 
- 	bcma_erom_push_ent(eromptr);
 
- }
 
- 
--static s32 bcma_erom_get_mst_port(struct bcma_bus *bus, u32 **eromptr)
 
-+static s32 bcma_erom_get_mst_port(struct bcma_bus *bus, u32 __iomem **eromptr)
 
- {
 
- 	u32 ent = bcma_erom_get_ent(bus, eromptr);
 
- 	if (!(ent & SCAN_ER_VALID))
 
-@@ -167,7 +213,7 @@ static s32 bcma_erom_get_mst_port(struct
 
- 	return ent;
 
- }
 
- 
--static s32 bcma_erom_get_addr_desc(struct bcma_bus *bus, u32 **eromptr,
 
-+static u32 bcma_erom_get_addr_desc(struct bcma_bus *bus, u32 __iomem **eromptr,
 
- 				  u32 type, u8 port)
 
- {
 
- 	u32 addrl, addrh, sizel, sizeh = 0;
 
-@@ -179,7 +225,7 @@ static s32 bcma_erom_get_addr_desc(struc
 
- 	    ((ent & SCAN_ADDR_TYPE) != type) ||
 
- 	    (((ent & SCAN_ADDR_PORT) >> SCAN_ADDR_PORT_SHIFT) != port)) {
 
- 		bcma_erom_push_ent(eromptr);
 
--		return -EINVAL;
 
-+		return (u32)-EINVAL;
 
- 	}
 
- 
- 	addrl = ent & SCAN_ADDR_ADDR;
 
-@@ -212,11 +258,24 @@ static struct bcma_device *bcma_find_cor
 
- 	return NULL;
 
- }
 
- 
-+static struct bcma_device *bcma_find_core_reverse(struct bcma_bus *bus, u16 coreid)
 
-+{
 
-+	struct bcma_device *core;
 
-+
 
-+	list_for_each_entry_reverse(core, &bus->cores, list) {
 
-+		if (core->id.id == coreid)
 
-+			return core;
 
-+	}
 
-+	return NULL;
 
-+}
 
-+
 
-+#define IS_ERR_VALUE_U32(x) ((x) >= (u32)-MAX_ERRNO)
 
-+
 
- static int bcma_get_next_core(struct bcma_bus *bus, u32 __iomem **eromptr,
 
- 			      struct bcma_device_id *match, int core_num,
 
- 			      struct bcma_device *core)
 
- {
 
--	s32 tmp;
 
-+	u32 tmp;
 
- 	u8 i, j;
 
- 	s32 cia, cib;
 
- 	u8 ports[2], wrappers[2];
 
-@@ -252,11 +311,15 @@ static int bcma_get_next_core(struct bcm
 
- 
- 	/* check if component is a core at all */
 
- 	if (wrappers[0] + wrappers[1] == 0) {
 
--		/* we could save addrl of the router
 
--		if (cid == BCMA_CORE_OOB_ROUTER)
 
--		 */
 
--		bcma_erom_skip_component(bus, eromptr);
 
--		return -ENXIO;
 
-+		/* Some specific cores don't need wrappers */
 
-+		switch (core->id.id) {
 
-+		case BCMA_CORE_4706_MAC_GBIT_COMMON:
 
-+		/* Not used yet: case BCMA_CORE_OOB_ROUTER: */
 
-+			break;
 
-+		default:
 
-+			bcma_erom_skip_component(bus, eromptr);
 
-+			return -ENXIO;
 
-+		}
 
- 	}
 
- 
- 	if (bcma_erom_is_bridge(bus, eromptr)) {
 
-@@ -286,19 +349,36 @@ static int bcma_get_next_core(struct bcm
 
- 			return -EILSEQ;
 
- 	}
 
- 
-+	/* First Slave Address Descriptor should be port 0:
 
-+	 * the main register space for the core
 
-+	 */
 
-+	tmp = bcma_erom_get_addr_desc(bus, eromptr, SCAN_ADDR_TYPE_SLAVE, 0);
 
-+	if (tmp == 0 || IS_ERR_VALUE_U32(tmp)) {
 
-+		/* Try again to see if it is a bridge */
 
-+		tmp = bcma_erom_get_addr_desc(bus, eromptr,
 
-+					      SCAN_ADDR_TYPE_BRIDGE, 0);
 
-+		if (tmp == 0 || IS_ERR_VALUE_U32(tmp)) {
 
-+			return -EILSEQ;
 
-+		} else {
 
-+			bcma_info(bus, "Bridge found\n");
 
-+			return -ENXIO;
 
-+		}
 
-+	}
 
-+	core->addr = tmp;
 
-+
 
- 	/* get & parse slave ports */
 
- 	for (i = 0; i < ports[1]; i++) {
 
- 		for (j = 0; ; j++) {
 
- 			tmp = bcma_erom_get_addr_desc(bus, eromptr,
 
- 				SCAN_ADDR_TYPE_SLAVE, i);
 
--			if (tmp < 0) {
 
-+			if (IS_ERR_VALUE_U32(tmp)) {
 
- 				/* no more entries for port _i_ */
 
- 				/* pr_debug("erom: slave port %d "
 
- 				 * "has %d descriptors\n", i, j); */
 
- 				break;
 
- 			} else {
 
- 				if (i == 0 && j == 0)
 
--					core->addr = tmp;
 
-+					core->addr1 = tmp;
 
- 			}
 
- 		}
 
- 	}
 
-@@ -308,7 +388,7 @@ static int bcma_get_next_core(struct bcm
 
- 		for (j = 0; ; j++) {
 
- 			tmp = bcma_erom_get_addr_desc(bus, eromptr,
 
- 				SCAN_ADDR_TYPE_MWRAP, i);
 
--			if (tmp < 0) {
 
-+			if (IS_ERR_VALUE_U32(tmp)) {
 
- 				/* no more entries for port _i_ */
 
- 				/* pr_debug("erom: master wrapper %d "
 
- 				 * "has %d descriptors\n", i, j); */
 
-@@ -326,7 +406,7 @@ static int bcma_get_next_core(struct bcm
 
- 		for (j = 0; ; j++) {
 
- 			tmp = bcma_erom_get_addr_desc(bus, eromptr,
 
- 				SCAN_ADDR_TYPE_SWRAP, i + hack);
 
--			if (tmp < 0) {
 
-+			if (IS_ERR_VALUE_U32(tmp)) {
 
- 				/* no more entries for port _i_ */
 
- 				/* pr_debug("erom: master wrapper %d "
 
- 				 * has %d descriptors\n", i, j); */
 
-@@ -353,6 +433,7 @@ static int bcma_get_next_core(struct bcm
 
- void bcma_init_bus(struct bcma_bus *bus)
 
- {
 
- 	s32 tmp;
 
-+	struct bcma_chipinfo *chipinfo = &(bus->chipinfo);
 
- 
- 	if (bus->init_done)
 
- 		return;
 
-@@ -363,9 +444,12 @@ void bcma_init_bus(struct bcma_bus *bus)
 
- 	bcma_scan_switch_core(bus, BCMA_ADDR_BASE);
 
- 
- 	tmp = bcma_scan_read32(bus, 0, BCMA_CC_ID);
 
--	bus->chipinfo.id = (tmp & BCMA_CC_ID_ID) >> BCMA_CC_ID_ID_SHIFT;
 
--	bus->chipinfo.rev = (tmp & BCMA_CC_ID_REV) >> BCMA_CC_ID_REV_SHIFT;
 
--	bus->chipinfo.pkg = (tmp & BCMA_CC_ID_PKG) >> BCMA_CC_ID_PKG_SHIFT;
 
-+	chipinfo->id = (tmp & BCMA_CC_ID_ID) >> BCMA_CC_ID_ID_SHIFT;
 
-+	chipinfo->rev = (tmp & BCMA_CC_ID_REV) >> BCMA_CC_ID_REV_SHIFT;
 
-+	chipinfo->pkg = (tmp & BCMA_CC_ID_PKG) >> BCMA_CC_ID_PKG_SHIFT;
 
-+	bcma_info(bus, "Found chip with id 0x%04X, rev 0x%02X and package 0x%02X\n",
 
-+		  chipinfo->id, chipinfo->rev, chipinfo->pkg);
 
-+
 
- 	bus->init_done = true;
 
- }
 
- 
-@@ -392,9 +476,12 @@ int bcma_bus_scan(struct bcma_bus *bus)
 
- 	bcma_scan_switch_core(bus, erombase);
 
- 
- 	while (eromptr < eromend) {
 
-+		struct bcma_device *other_core;
 
- 		struct bcma_device *core = kzalloc(sizeof(*core), GFP_KERNEL);
 
--		if (!core)
 
--			return -ENOMEM;
 
-+		if (!core) {
 
-+			err = -ENOMEM;
 
-+			goto out;
 
-+		}
 
- 		INIT_LIST_HEAD(&core->list);
 
- 		core->bus = bus;
 
- 
-@@ -409,25 +496,28 @@ int bcma_bus_scan(struct bcma_bus *bus)
 
- 			} else if (err == -ESPIPE) {
 
- 				break;
 
- 			}
 
--			return err;
 
-+			goto out;
 
- 		}
 
- 
- 		core->core_index = core_num++;
 
- 		bus->nr_cores++;
 
-+		other_core = bcma_find_core_reverse(bus, core->id.id);
 
-+		core->core_unit = (other_core == NULL) ? 0 : other_core->core_unit + 1;
 
- 
--		pr_info("Core %d found: %s "
 
--			"(manuf 0x%03X, id 0x%03X, rev 0x%02X, class 0x%X)\n",
 
--			core->core_index, bcma_device_name(&core->id),
 
--			core->id.manuf, core->id.id, core->id.rev,
 
--			core->id.class);
 
-+		bcma_info(bus, "Core %d found: %s (manuf 0x%03X, id 0x%03X, rev 0x%02X, class 0x%X)\n",
 
-+			  core->core_index, bcma_device_name(&core->id),
 
-+			  core->id.manuf, core->id.id, core->id.rev,
 
-+			  core->id.class);
 
- 
--		list_add(&core->list, &bus->cores);
 
-+		list_add_tail(&core->list, &bus->cores);
 
- 	}
 
- 
-+	err = 0;
 
-+out:
 
- 	if (bus->hosttype == BCMA_HOSTTYPE_SOC)
 
- 		iounmap(eromptr);
 
- 
--	return 0;
 
-+	return err;
 
- }
 
- 
- int __init bcma_bus_scan_early(struct bcma_bus *bus,
 
-@@ -467,21 +557,21 @@ int __init bcma_bus_scan_early(struct bc
 
- 		else if (err == -ESPIPE)
 
- 			break;
 
- 		else if (err < 0)
 
--			return err;
 
-+			goto out;
 
- 
- 		core->core_index = core_num++;
 
- 		bus->nr_cores++;
 
--		pr_info("Core %d found: %s "
 
--			"(manuf 0x%03X, id 0x%03X, rev 0x%02X, class 0x%X)\n",
 
--			core->core_index, bcma_device_name(&core->id),
 
--			core->id.manuf, core->id.id, core->id.rev,
 
--			core->id.class);
 
-+		bcma_info(bus, "Core %d found: %s (manuf 0x%03X, id 0x%03X, rev 0x%02X, class 0x%X)\n",
 
-+			  core->core_index, bcma_device_name(&core->id),
 
-+			  core->id.manuf, core->id.id, core->id.rev,
 
-+			  core->id.class);
 
- 
--		list_add(&core->list, &bus->cores);
 
-+		list_add_tail(&core->list, &bus->cores);
 
- 		err = 0;
 
- 		break;
 
- 	}
 
- 
-+out:
 
- 	if (bus->hosttype == BCMA_HOSTTYPE_SOC)
 
- 		iounmap(eromptr);
 
- 
---- a/drivers/bcma/scan.h
 
-+++ b/drivers/bcma/scan.h
 
-@@ -27,7 +27,7 @@
 
- #define SCAN_CIB_NMW		0x0007C000
 
- #define SCAN_CIB_NMW_SHIFT	14
 
- #define SCAN_CIB_NSW		0x00F80000
 
--#define SCAN_CIB_NSW_SHIFT	17
 
-+#define SCAN_CIB_NSW_SHIFT	19
 
- #define SCAN_CIB_REV		0xFF000000
 
- #define SCAN_CIB_REV_SHIFT	24
 
- 
---- a/drivers/bcma/sprom.c
 
-+++ b/drivers/bcma/sprom.c
 
-@@ -2,6 +2,8 @@
 
-  * Broadcom specific AMBA
 
-  * SPROM reading
 
-  *
 
-+ * Copyright 2011, 2012, Hauke Mehrtens <[email protected]>
 
-+ *
 
-  * Licensed under the GNU/GPL. See COPYING for details.
 
-  */
 
- 
-@@ -14,18 +16,68 @@
 
- #include <linux/dma-mapping.h>
 
- #include <linux/slab.h>
 
- 
--#define SPOFF(offset)	((offset) / sizeof(u16))
 
-+static int(*get_fallback_sprom)(struct bcma_bus *dev, struct ssb_sprom *out);
 
-+
 
-+/**
 
-+ * bcma_arch_register_fallback_sprom - Registers a method providing a
 
-+ * fallback SPROM if no SPROM is found.
 
-+ *
 
-+ * @sprom_callback: The callback function.
 
-+ *
 
-+ * With this function the architecture implementation may register a
 
-+ * callback handler which fills the SPROM data structure. The fallback is
 
-+ * used for PCI based BCMA devices, where no valid SPROM can be found
 
-+ * in the shadow registers and to provide the SPROM for SoCs where BCMA is
 
-+ * to controll the system bus.
 
-+ *
 
-+ * This function is useful for weird architectures that have a half-assed
 
-+ * BCMA device hardwired to their PCI bus.
 
-+ *
 
-+ * This function is available for architecture code, only. So it is not
 
-+ * exported.
 
-+ */
 
-+int bcma_arch_register_fallback_sprom(int (*sprom_callback)(struct bcma_bus *bus,
 
-+				     struct ssb_sprom *out))
 
-+{
 
-+	if (get_fallback_sprom)
 
-+		return -EEXIST;
 
-+	get_fallback_sprom = sprom_callback;
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static int bcma_fill_sprom_with_fallback(struct bcma_bus *bus,
 
-+					 struct ssb_sprom *out)
 
-+{
 
-+	int err;
 
-+
 
-+	if (!get_fallback_sprom) {
 
-+		err = -ENOENT;
 
-+		goto fail;
 
-+	}
 
-+
 
-+	err = get_fallback_sprom(bus, out);
 
-+	if (err)
 
-+		goto fail;
 
-+
 
-+	bcma_debug(bus, "Using SPROM revision %d provided by platform.\n",
 
-+		   bus->sprom.revision);
 
-+	return 0;
 
-+fail:
 
-+	bcma_warn(bus, "Using fallback SPROM failed (err %d)\n", err);
 
-+	return err;
 
-+}
 
- 
- /**************************************************
 
-  * R/W ops.
 
-  **************************************************/
 
- 
--static void bcma_sprom_read(struct bcma_bus *bus, u16 offset, u16 *sprom)
 
-+static void bcma_sprom_read(struct bcma_bus *bus, u16 offset, u16 *sprom,
 
-+			    size_t words)
 
- {
 
- 	int i;
 
--	for (i = 0; i < SSB_SPROMSIZE_WORDS_R4; i++)
 
--		sprom[i] = bcma_read16(bus->drv_cc.core,
 
--				       offset + (i * 2));
 
-+	for (i = 0; i < words; i++)
 
-+		sprom[i] = bcma_read16(bus->drv_cc.core, offset + (i * 2));
 
- }
 
- 
- /**************************************************
 
-@@ -72,29 +124,29 @@ static inline u8 bcma_crc8(u8 crc, u8 da
 
- 	return t[crc ^ data];
 
- }
 
- 
--static u8 bcma_sprom_crc(const u16 *sprom)
 
-+static u8 bcma_sprom_crc(const u16 *sprom, size_t words)
 
- {
 
- 	int word;
 
- 	u8 crc = 0xFF;
 
- 
--	for (word = 0; word < SSB_SPROMSIZE_WORDS_R4 - 1; word++) {
 
-+	for (word = 0; word < words - 1; word++) {
 
- 		crc = bcma_crc8(crc, sprom[word] & 0x00FF);
 
- 		crc = bcma_crc8(crc, (sprom[word] & 0xFF00) >> 8);
 
- 	}
 
--	crc = bcma_crc8(crc, sprom[SSB_SPROMSIZE_WORDS_R4 - 1] & 0x00FF);
 
-+	crc = bcma_crc8(crc, sprom[words - 1] & 0x00FF);
 
- 	crc ^= 0xFF;
 
- 
- 	return crc;
 
- }
 
- 
--static int bcma_sprom_check_crc(const u16 *sprom)
 
-+static int bcma_sprom_check_crc(const u16 *sprom, size_t words)
 
- {
 
- 	u8 crc;
 
- 	u8 expected_crc;
 
- 	u16 tmp;
 
- 
--	crc = bcma_sprom_crc(sprom);
 
--	tmp = sprom[SSB_SPROMSIZE_WORDS_R4 - 1] & SSB_SPROM_REVISION_CRC;
 
-+	crc = bcma_sprom_crc(sprom, words);
 
-+	tmp = sprom[words - 1] & SSB_SPROM_REVISION_CRC;
 
- 	expected_crc = tmp >> SSB_SPROM_REVISION_CRC_SHIFT;
 
- 	if (crc != expected_crc)
 
- 		return -EPROTO;
 
-@@ -102,21 +154,25 @@ static int bcma_sprom_check_crc(const u1
 
- 	return 0;
 
- }
 
- 
--static int bcma_sprom_valid(const u16 *sprom)
 
-+static int bcma_sprom_valid(struct bcma_bus *bus, const u16 *sprom,
 
-+			    size_t words)
 
- {
 
- 	u16 revision;
 
- 	int err;
 
- 
--	err = bcma_sprom_check_crc(sprom);
 
-+	err = bcma_sprom_check_crc(sprom, words);
 
- 	if (err)
 
- 		return err;
 
- 
--	revision = sprom[SSB_SPROMSIZE_WORDS_R4 - 1] & SSB_SPROM_REVISION_REV;
 
--	if (revision != 8 && revision != 9) {
 
-+	revision = sprom[words - 1] & SSB_SPROM_REVISION_REV;
 
-+	if (revision != 8 && revision != 9 && revision != 10) {
 
- 		pr_err("Unsupported SPROM revision: %d\n", revision);
 
- 		return -ENOENT;
 
- 	}
 
- 
-+	bus->sprom.revision = revision;
 
-+	bcma_debug(bus, "Found SPROM revision %d\n", revision);
 
-+
 
- 	return 0;
 
- }
 
- 
-@@ -124,124 +180,439 @@ static int bcma_sprom_valid(const u16 *s
 
-  * SPROM extraction.
 
-  **************************************************/
 
- 
-+#define SPOFF(offset)	((offset) / sizeof(u16))
 
-+
 
-+#define SPEX(_field, _offset, _mask, _shift)	\
 
-+	bus->sprom._field = ((sprom[SPOFF(_offset)] & (_mask)) >> (_shift))
 
-+
 
-+#define SPEX32(_field, _offset, _mask, _shift)	\
 
-+	bus->sprom._field = ((((u32)sprom[SPOFF((_offset)+2)] << 16 | \
 
-+				sprom[SPOFF(_offset)]) & (_mask)) >> (_shift))
 
-+
 
-+#define SPEX_ARRAY8(_field, _offset, _mask, _shift)	\
 
-+	do {	\
 
-+		SPEX(_field[0], _offset +  0, _mask, _shift);	\
 
-+		SPEX(_field[1], _offset +  2, _mask, _shift);	\
 
-+		SPEX(_field[2], _offset +  4, _mask, _shift);	\
 
-+		SPEX(_field[3], _offset +  6, _mask, _shift);	\
 
-+		SPEX(_field[4], _offset +  8, _mask, _shift);	\
 
-+		SPEX(_field[5], _offset + 10, _mask, _shift);	\
 
-+		SPEX(_field[6], _offset + 12, _mask, _shift);	\
 
-+		SPEX(_field[7], _offset + 14, _mask, _shift);	\
 
-+	} while (0)
 
-+
 
- static void bcma_sprom_extract_r8(struct bcma_bus *bus, const u16 *sprom)
 
- {
 
--	u16 v;
 
-+	u16 v, o;
 
- 	int i;
 
--
 
--	bus->sprom.revision = sprom[SSB_SPROMSIZE_WORDS_R4 - 1] &
 
--		SSB_SPROM_REVISION_REV;
 
-+	u16 pwr_info_offset[] = {
 
-+		SSB_SROM8_PWR_INFO_CORE0, SSB_SROM8_PWR_INFO_CORE1,
 
-+		SSB_SROM8_PWR_INFO_CORE2, SSB_SROM8_PWR_INFO_CORE3
 
-+	};
 
-+	BUILD_BUG_ON(ARRAY_SIZE(pwr_info_offset) !=
 
-+			ARRAY_SIZE(bus->sprom.core_pwr_info));
 
- 
- 	for (i = 0; i < 3; i++) {
 
- 		v = sprom[SPOFF(SSB_SPROM8_IL0MAC) + i];
 
- 		*(((__be16 *)bus->sprom.il0mac) + i) = cpu_to_be16(v);
 
- 	}
 
- 
--	bus->sprom.board_rev = sprom[SPOFF(SSB_SPROM8_BOARDREV)];
 
-+	SPEX(board_rev, SSB_SPROM8_BOARDREV, ~0, 0);
 
-+	SPEX(board_type, SSB_SPROM1_SPID, ~0, 0);
 
-+
 
-+	SPEX(txpid2g[0], SSB_SPROM4_TXPID2G01, SSB_SPROM4_TXPID2G0,
 
-+	     SSB_SPROM4_TXPID2G0_SHIFT);
 
-+	SPEX(txpid2g[1], SSB_SPROM4_TXPID2G01, SSB_SPROM4_TXPID2G1,
 
-+	     SSB_SPROM4_TXPID2G1_SHIFT);
 
-+	SPEX(txpid2g[2], SSB_SPROM4_TXPID2G23, SSB_SPROM4_TXPID2G2,
 
-+	     SSB_SPROM4_TXPID2G2_SHIFT);
 
-+	SPEX(txpid2g[3], SSB_SPROM4_TXPID2G23, SSB_SPROM4_TXPID2G3,
 
-+	     SSB_SPROM4_TXPID2G3_SHIFT);
 
-+
 
-+	SPEX(txpid5gl[0], SSB_SPROM4_TXPID5GL01, SSB_SPROM4_TXPID5GL0,
 
-+	     SSB_SPROM4_TXPID5GL0_SHIFT);
 
-+	SPEX(txpid5gl[1], SSB_SPROM4_TXPID5GL01, SSB_SPROM4_TXPID5GL1,
 
-+	     SSB_SPROM4_TXPID5GL1_SHIFT);
 
-+	SPEX(txpid5gl[2], SSB_SPROM4_TXPID5GL23, SSB_SPROM4_TXPID5GL2,
 
-+	     SSB_SPROM4_TXPID5GL2_SHIFT);
 
-+	SPEX(txpid5gl[3], SSB_SPROM4_TXPID5GL23, SSB_SPROM4_TXPID5GL3,
 
-+	     SSB_SPROM4_TXPID5GL3_SHIFT);
 
-+
 
-+	SPEX(txpid5g[0], SSB_SPROM4_TXPID5G01, SSB_SPROM4_TXPID5G0,
 
-+	     SSB_SPROM4_TXPID5G0_SHIFT);
 
-+	SPEX(txpid5g[1], SSB_SPROM4_TXPID5G01, SSB_SPROM4_TXPID5G1,
 
-+	     SSB_SPROM4_TXPID5G1_SHIFT);
 
-+	SPEX(txpid5g[2], SSB_SPROM4_TXPID5G23, SSB_SPROM4_TXPID5G2,
 
-+	     SSB_SPROM4_TXPID5G2_SHIFT);
 
-+	SPEX(txpid5g[3], SSB_SPROM4_TXPID5G23, SSB_SPROM4_TXPID5G3,
 
-+	     SSB_SPROM4_TXPID5G3_SHIFT);
 
-+
 
-+	SPEX(txpid5gh[0], SSB_SPROM4_TXPID5GH01, SSB_SPROM4_TXPID5GH0,
 
-+	     SSB_SPROM4_TXPID5GH0_SHIFT);
 
-+	SPEX(txpid5gh[1], SSB_SPROM4_TXPID5GH01, SSB_SPROM4_TXPID5GH1,
 
-+	     SSB_SPROM4_TXPID5GH1_SHIFT);
 
-+	SPEX(txpid5gh[2], SSB_SPROM4_TXPID5GH23, SSB_SPROM4_TXPID5GH2,
 
-+	     SSB_SPROM4_TXPID5GH2_SHIFT);
 
-+	SPEX(txpid5gh[3], SSB_SPROM4_TXPID5GH23, SSB_SPROM4_TXPID5GH3,
 
-+	     SSB_SPROM4_TXPID5GH3_SHIFT);
 
-+
 
-+	SPEX(boardflags_lo, SSB_SPROM8_BFLLO, ~0, 0);
 
-+	SPEX(boardflags_hi, SSB_SPROM8_BFLHI, ~0, 0);
 
-+	SPEX(boardflags2_lo, SSB_SPROM8_BFL2LO, ~0, 0);
 
-+	SPEX(boardflags2_hi, SSB_SPROM8_BFL2HI, ~0, 0);
 
-+
 
-+	SPEX(alpha2[0], SSB_SPROM8_CCODE, 0xff00, 8);
 
-+	SPEX(alpha2[1], SSB_SPROM8_CCODE, 0x00ff, 0);
 
-+
 
-+	/* Extract cores power info info */
 
-+	for (i = 0; i < ARRAY_SIZE(pwr_info_offset); i++) {
 
-+		o = pwr_info_offset[i];
 
-+		SPEX(core_pwr_info[i].itssi_2g, o + SSB_SROM8_2G_MAXP_ITSSI,
 
-+			SSB_SPROM8_2G_ITSSI, SSB_SPROM8_2G_ITSSI_SHIFT);
 
-+		SPEX(core_pwr_info[i].maxpwr_2g, o + SSB_SROM8_2G_MAXP_ITSSI,
 
-+			SSB_SPROM8_2G_MAXP, 0);
 
-+
 
-+		SPEX(core_pwr_info[i].pa_2g[0], o + SSB_SROM8_2G_PA_0, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_2g[1], o + SSB_SROM8_2G_PA_1, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_2g[2], o + SSB_SROM8_2G_PA_2, ~0, 0);
 
-+
 
-+		SPEX(core_pwr_info[i].itssi_5g, o + SSB_SROM8_5G_MAXP_ITSSI,
 
-+			SSB_SPROM8_5G_ITSSI, SSB_SPROM8_5G_ITSSI_SHIFT);
 
-+		SPEX(core_pwr_info[i].maxpwr_5g, o + SSB_SROM8_5G_MAXP_ITSSI,
 
-+			SSB_SPROM8_5G_MAXP, 0);
 
-+		SPEX(core_pwr_info[i].maxpwr_5gh, o + SSB_SPROM8_5GHL_MAXP,
 
-+			SSB_SPROM8_5GH_MAXP, 0);
 
-+		SPEX(core_pwr_info[i].maxpwr_5gl, o + SSB_SPROM8_5GHL_MAXP,
 
-+			SSB_SPROM8_5GL_MAXP, SSB_SPROM8_5GL_MAXP_SHIFT);
 
-+
 
-+		SPEX(core_pwr_info[i].pa_5gl[0], o + SSB_SROM8_5GL_PA_0, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5gl[1], o + SSB_SROM8_5GL_PA_1, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5gl[2], o + SSB_SROM8_5GL_PA_2, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5g[0], o + SSB_SROM8_5G_PA_0, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5g[1], o + SSB_SROM8_5G_PA_1, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5g[2], o + SSB_SROM8_5G_PA_2, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5gh[0], o + SSB_SROM8_5GH_PA_0, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5gh[1], o + SSB_SROM8_5GH_PA_1, ~0, 0);
 
-+		SPEX(core_pwr_info[i].pa_5gh[2], o + SSB_SROM8_5GH_PA_2, ~0, 0);
 
-+	}
 
-+
 
-+	SPEX(fem.ghz2.tssipos, SSB_SPROM8_FEM2G, SSB_SROM8_FEM_TSSIPOS,
 
-+	     SSB_SROM8_FEM_TSSIPOS_SHIFT);
 
-+	SPEX(fem.ghz2.extpa_gain, SSB_SPROM8_FEM2G, SSB_SROM8_FEM_EXTPA_GAIN,
 
-+	     SSB_SROM8_FEM_EXTPA_GAIN_SHIFT);
 
-+	SPEX(fem.ghz2.pdet_range, SSB_SPROM8_FEM2G, SSB_SROM8_FEM_PDET_RANGE,
 
-+	     SSB_SROM8_FEM_PDET_RANGE_SHIFT);
 
-+	SPEX(fem.ghz2.tr_iso, SSB_SPROM8_FEM2G, SSB_SROM8_FEM_TR_ISO,
 
-+	     SSB_SROM8_FEM_TR_ISO_SHIFT);
 
-+	SPEX(fem.ghz2.antswlut, SSB_SPROM8_FEM2G, SSB_SROM8_FEM_ANTSWLUT,
 
-+	     SSB_SROM8_FEM_ANTSWLUT_SHIFT);
 
-+
 
-+	SPEX(fem.ghz5.tssipos, SSB_SPROM8_FEM5G, SSB_SROM8_FEM_TSSIPOS,
 
-+	     SSB_SROM8_FEM_TSSIPOS_SHIFT);
 
-+	SPEX(fem.ghz5.extpa_gain, SSB_SPROM8_FEM5G, SSB_SROM8_FEM_EXTPA_GAIN,
 
-+	     SSB_SROM8_FEM_EXTPA_GAIN_SHIFT);
 
-+	SPEX(fem.ghz5.pdet_range, SSB_SPROM8_FEM5G, SSB_SROM8_FEM_PDET_RANGE,
 
-+	     SSB_SROM8_FEM_PDET_RANGE_SHIFT);
 
-+	SPEX(fem.ghz5.tr_iso, SSB_SPROM8_FEM5G, SSB_SROM8_FEM_TR_ISO,
 
-+	     SSB_SROM8_FEM_TR_ISO_SHIFT);
 
-+	SPEX(fem.ghz5.antswlut, SSB_SPROM8_FEM5G, SSB_SROM8_FEM_ANTSWLUT,
 
-+	     SSB_SROM8_FEM_ANTSWLUT_SHIFT);
 
-+
 
-+	SPEX(ant_available_a, SSB_SPROM8_ANTAVAIL, SSB_SPROM8_ANTAVAIL_A,
 
-+	     SSB_SPROM8_ANTAVAIL_A_SHIFT);
 
-+	SPEX(ant_available_bg, SSB_SPROM8_ANTAVAIL, SSB_SPROM8_ANTAVAIL_BG,
 
-+	     SSB_SPROM8_ANTAVAIL_BG_SHIFT);
 
-+	SPEX(maxpwr_bg, SSB_SPROM8_MAXP_BG, SSB_SPROM8_MAXP_BG_MASK, 0);
 
-+	SPEX(itssi_bg, SSB_SPROM8_MAXP_BG, SSB_SPROM8_ITSSI_BG,
 
-+	     SSB_SPROM8_ITSSI_BG_SHIFT);
 
-+	SPEX(maxpwr_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_MAXP_A_MASK, 0);
 
-+	SPEX(itssi_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_ITSSI_A,
 
-+	     SSB_SPROM8_ITSSI_A_SHIFT);
 
-+	SPEX(maxpwr_ah, SSB_SPROM8_MAXP_AHL, SSB_SPROM8_MAXP_AH_MASK, 0);
 
-+	SPEX(maxpwr_al, SSB_SPROM8_MAXP_AHL, SSB_SPROM8_MAXP_AL_MASK,
 
-+	     SSB_SPROM8_MAXP_AL_SHIFT);
 
-+	SPEX(gpio0, SSB_SPROM8_GPIOA, SSB_SPROM8_GPIOA_P0, 0);
 
-+	SPEX(gpio1, SSB_SPROM8_GPIOA, SSB_SPROM8_GPIOA_P1,
 
-+	     SSB_SPROM8_GPIOA_P1_SHIFT);
 
-+	SPEX(gpio2, SSB_SPROM8_GPIOB, SSB_SPROM8_GPIOB_P2, 0);
 
-+	SPEX(gpio3, SSB_SPROM8_GPIOB, SSB_SPROM8_GPIOB_P3,
 
-+	     SSB_SPROM8_GPIOB_P3_SHIFT);
 
-+	SPEX(tri2g, SSB_SPROM8_TRI25G, SSB_SPROM8_TRI2G, 0);
 
-+	SPEX(tri5g, SSB_SPROM8_TRI25G, SSB_SPROM8_TRI5G,
 
-+	     SSB_SPROM8_TRI5G_SHIFT);
 
-+	SPEX(tri5gl, SSB_SPROM8_TRI5GHL, SSB_SPROM8_TRI5GL, 0);
 
-+	SPEX(tri5gh, SSB_SPROM8_TRI5GHL, SSB_SPROM8_TRI5GH,
 
-+	     SSB_SPROM8_TRI5GH_SHIFT);
 
-+	SPEX(rxpo2g, SSB_SPROM8_RXPO, SSB_SPROM8_RXPO2G,
 
-+	     SSB_SPROM8_RXPO2G_SHIFT);
 
-+	SPEX(rxpo5g, SSB_SPROM8_RXPO, SSB_SPROM8_RXPO5G,
 
-+	     SSB_SPROM8_RXPO5G_SHIFT);
 
-+	SPEX(rssismf2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_RSSISMF2G, 0);
 
-+	SPEX(rssismc2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_RSSISMC2G,
 
-+	     SSB_SPROM8_RSSISMC2G_SHIFT);
 
-+	SPEX(rssisav2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_RSSISAV2G,
 
-+	     SSB_SPROM8_RSSISAV2G_SHIFT);
 
-+	SPEX(bxa2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_BXA2G,
 
-+	     SSB_SPROM8_BXA2G_SHIFT);
 
-+	SPEX(rssismf5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_RSSISMF5G, 0);
 
-+	SPEX(rssismc5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_RSSISMC5G,
 
-+	     SSB_SPROM8_RSSISMC5G_SHIFT);
 
-+	SPEX(rssisav5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_RSSISAV5G,
 
-+	     SSB_SPROM8_RSSISAV5G_SHIFT);
 
-+	SPEX(bxa5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_BXA5G,
 
-+	     SSB_SPROM8_BXA5G_SHIFT);
 
-+
 
-+	SPEX(pa0b0, SSB_SPROM8_PA0B0, ~0, 0);
 
-+	SPEX(pa0b1, SSB_SPROM8_PA0B1, ~0, 0);
 
-+	SPEX(pa0b2, SSB_SPROM8_PA0B2, ~0, 0);
 
-+	SPEX(pa1b0, SSB_SPROM8_PA1B0, ~0, 0);
 
-+	SPEX(pa1b1, SSB_SPROM8_PA1B1, ~0, 0);
 
-+	SPEX(pa1b2, SSB_SPROM8_PA1B2, ~0, 0);
 
-+	SPEX(pa1lob0, SSB_SPROM8_PA1LOB0, ~0, 0);
 
-+	SPEX(pa1lob1, SSB_SPROM8_PA1LOB1, ~0, 0);
 
-+	SPEX(pa1lob2, SSB_SPROM8_PA1LOB2, ~0, 0);
 
-+	SPEX(pa1hib0, SSB_SPROM8_PA1HIB0, ~0, 0);
 
-+	SPEX(pa1hib1, SSB_SPROM8_PA1HIB1, ~0, 0);
 
-+	SPEX(pa1hib2, SSB_SPROM8_PA1HIB2, ~0, 0);
 
-+	SPEX(cck2gpo, SSB_SPROM8_CCK2GPO, ~0, 0);
 
-+	SPEX32(ofdm2gpo, SSB_SPROM8_OFDM2GPO, ~0, 0);
 
-+	SPEX32(ofdm5glpo, SSB_SPROM8_OFDM5GLPO, ~0, 0);
 
-+	SPEX32(ofdm5gpo, SSB_SPROM8_OFDM5GPO, ~0, 0);
 
-+	SPEX32(ofdm5ghpo, SSB_SPROM8_OFDM5GHPO, ~0, 0);
 
-+
 
-+	/* Extract the antenna gain values. */
 
-+	SPEX(antenna_gain.a0, SSB_SPROM8_AGAIN01,
 
-+	     SSB_SPROM8_AGAIN0, SSB_SPROM8_AGAIN0_SHIFT);
 
-+	SPEX(antenna_gain.a1, SSB_SPROM8_AGAIN01,
 
-+	     SSB_SPROM8_AGAIN1, SSB_SPROM8_AGAIN1_SHIFT);
 
-+	SPEX(antenna_gain.a2, SSB_SPROM8_AGAIN23,
 
-+	     SSB_SPROM8_AGAIN2, SSB_SPROM8_AGAIN2_SHIFT);
 
-+	SPEX(antenna_gain.a3, SSB_SPROM8_AGAIN23,
 
-+	     SSB_SPROM8_AGAIN3, SSB_SPROM8_AGAIN3_SHIFT);
 
-+
 
-+	SPEX(leddc_on_time, SSB_SPROM8_LEDDC, SSB_SPROM8_LEDDC_ON,
 
-+	     SSB_SPROM8_LEDDC_ON_SHIFT);
 
-+	SPEX(leddc_off_time, SSB_SPROM8_LEDDC, SSB_SPROM8_LEDDC_OFF,
 
-+	     SSB_SPROM8_LEDDC_OFF_SHIFT);
 
-+
 
-+	SPEX(txchain, SSB_SPROM8_TXRXC, SSB_SPROM8_TXRXC_TXCHAIN,
 
-+	     SSB_SPROM8_TXRXC_TXCHAIN_SHIFT);
 
-+	SPEX(rxchain, SSB_SPROM8_TXRXC, SSB_SPROM8_TXRXC_RXCHAIN,
 
-+	     SSB_SPROM8_TXRXC_RXCHAIN_SHIFT);
 
-+	SPEX(antswitch, SSB_SPROM8_TXRXC, SSB_SPROM8_TXRXC_SWITCH,
 
-+	     SSB_SPROM8_TXRXC_SWITCH_SHIFT);
 
-+
 
-+	SPEX(opo, SSB_SPROM8_OFDM2GPO, 0x00ff, 0);
 
-+
 
-+	SPEX_ARRAY8(mcs2gpo, SSB_SPROM8_2G_MCSPO, ~0, 0);
 
-+	SPEX_ARRAY8(mcs5gpo, SSB_SPROM8_5G_MCSPO, ~0, 0);
 
-+	SPEX_ARRAY8(mcs5glpo, SSB_SPROM8_5GL_MCSPO, ~0, 0);
 
-+	SPEX_ARRAY8(mcs5ghpo, SSB_SPROM8_5GH_MCSPO, ~0, 0);
 
-+
 
-+	SPEX(rawtempsense, SSB_SPROM8_RAWTS, SSB_SPROM8_RAWTS_RAWTEMP,
 
-+	     SSB_SPROM8_RAWTS_RAWTEMP_SHIFT);
 
-+	SPEX(measpower, SSB_SPROM8_RAWTS, SSB_SPROM8_RAWTS_MEASPOWER,
 
-+	     SSB_SPROM8_RAWTS_MEASPOWER_SHIFT);
 
-+	SPEX(tempsense_slope, SSB_SPROM8_OPT_CORRX,
 
-+	     SSB_SPROM8_OPT_CORRX_TEMP_SLOPE,
 
-+	     SSB_SPROM8_OPT_CORRX_TEMP_SLOPE_SHIFT);
 
-+	SPEX(tempcorrx, SSB_SPROM8_OPT_CORRX, SSB_SPROM8_OPT_CORRX_TEMPCORRX,
 
-+	     SSB_SPROM8_OPT_CORRX_TEMPCORRX_SHIFT);
 
-+	SPEX(tempsense_option, SSB_SPROM8_OPT_CORRX,
 
-+	     SSB_SPROM8_OPT_CORRX_TEMP_OPTION,
 
-+	     SSB_SPROM8_OPT_CORRX_TEMP_OPTION_SHIFT);
 
-+	SPEX(freqoffset_corr, SSB_SPROM8_HWIQ_IQSWP,
 
-+	     SSB_SPROM8_HWIQ_IQSWP_FREQ_CORR,
 
-+	     SSB_SPROM8_HWIQ_IQSWP_FREQ_CORR_SHIFT);
 
-+	SPEX(iqcal_swp_dis, SSB_SPROM8_HWIQ_IQSWP,
 
-+	     SSB_SPROM8_HWIQ_IQSWP_IQCAL_SWP,
 
-+	     SSB_SPROM8_HWIQ_IQSWP_IQCAL_SWP_SHIFT);
 
-+	SPEX(hw_iqcal_en, SSB_SPROM8_HWIQ_IQSWP, SSB_SPROM8_HWIQ_IQSWP_HW_IQCAL,
 
-+	     SSB_SPROM8_HWIQ_IQSWP_HW_IQCAL_SHIFT);
 
-+
 
-+	SPEX(bw40po, SSB_SPROM8_BW40PO, ~0, 0);
 
-+	SPEX(cddpo, SSB_SPROM8_CDDPO, ~0, 0);
 
-+	SPEX(stbcpo, SSB_SPROM8_STBCPO, ~0, 0);
 
-+	SPEX(bwduppo, SSB_SPROM8_BWDUPPO, ~0, 0);
 
-+
 
-+	SPEX(tempthresh, SSB_SPROM8_THERMAL, SSB_SPROM8_THERMAL_TRESH,
 
-+	     SSB_SPROM8_THERMAL_TRESH_SHIFT);
 
-+	SPEX(tempoffset, SSB_SPROM8_THERMAL, SSB_SPROM8_THERMAL_OFFSET,
 
-+	     SSB_SPROM8_THERMAL_OFFSET_SHIFT);
 
-+	SPEX(phycal_tempdelta, SSB_SPROM8_TEMPDELTA,
 
-+	     SSB_SPROM8_TEMPDELTA_PHYCAL,
 
-+	     SSB_SPROM8_TEMPDELTA_PHYCAL_SHIFT);
 
-+	SPEX(temps_period, SSB_SPROM8_TEMPDELTA, SSB_SPROM8_TEMPDELTA_PERIOD,
 
-+	     SSB_SPROM8_TEMPDELTA_PERIOD_SHIFT);
 
-+	SPEX(temps_hysteresis, SSB_SPROM8_TEMPDELTA,
 
-+	     SSB_SPROM8_TEMPDELTA_HYSTERESIS,
 
-+	     SSB_SPROM8_TEMPDELTA_HYSTERESIS_SHIFT);
 
-+}
 
-+
 
-+/*
 
-+ * Indicates the presence of external SPROM.
 
-+ */
 
-+static bool bcma_sprom_ext_available(struct bcma_bus *bus)
 
-+{
 
-+	u32 chip_status;
 
-+	u32 srom_control;
 
-+	u32 present_mask;
 
-+
 
-+	if (bus->drv_cc.core->id.rev >= 31) {
 
-+		if (!(bus->drv_cc.capabilities & BCMA_CC_CAP_SPROM))
 
-+			return false;
 
-+
 
-+		srom_control = bcma_read32(bus->drv_cc.core,
 
-+					   BCMA_CC_SROM_CONTROL);
 
-+		return srom_control & BCMA_CC_SROM_CONTROL_PRESENT;
 
-+	}
 
-+
 
-+	/* older chipcommon revisions use chip status register */
 
-+	chip_status = bcma_read32(bus->drv_cc.core, BCMA_CC_CHIPSTAT);
 
-+	switch (bus->chipinfo.id) {
 
-+	case BCMA_CHIP_ID_BCM4313:
 
-+		present_mask = BCMA_CC_CHIPST_4313_SPROM_PRESENT;
 
-+		break;
 
-+
 
-+	case BCMA_CHIP_ID_BCM4331:
 
-+		present_mask = BCMA_CC_CHIPST_4331_SPROM_PRESENT;
 
-+		break;
 
- 
--	bus->sprom.txpid2g[0] = (sprom[SPOFF(SSB_SPROM4_TXPID2G01)] &
 
--	     SSB_SPROM4_TXPID2G0) >> SSB_SPROM4_TXPID2G0_SHIFT;
 
--	bus->sprom.txpid2g[1] = (sprom[SPOFF(SSB_SPROM4_TXPID2G01)] &
 
--	     SSB_SPROM4_TXPID2G1) >> SSB_SPROM4_TXPID2G1_SHIFT;
 
--	bus->sprom.txpid2g[2] = (sprom[SPOFF(SSB_SPROM4_TXPID2G23)] &
 
--	     SSB_SPROM4_TXPID2G2) >> SSB_SPROM4_TXPID2G2_SHIFT;
 
--	bus->sprom.txpid2g[3] = (sprom[SPOFF(SSB_SPROM4_TXPID2G23)] &
 
--	     SSB_SPROM4_TXPID2G3) >> SSB_SPROM4_TXPID2G3_SHIFT;
 
--
 
--	bus->sprom.txpid5gl[0] = (sprom[SPOFF(SSB_SPROM4_TXPID5GL01)] &
 
--	     SSB_SPROM4_TXPID5GL0) >> SSB_SPROM4_TXPID5GL0_SHIFT;
 
--	bus->sprom.txpid5gl[1] = (sprom[SPOFF(SSB_SPROM4_TXPID5GL01)] &
 
--	     SSB_SPROM4_TXPID5GL1) >> SSB_SPROM4_TXPID5GL1_SHIFT;
 
--	bus->sprom.txpid5gl[2] = (sprom[SPOFF(SSB_SPROM4_TXPID5GL23)] &
 
--	     SSB_SPROM4_TXPID5GL2) >> SSB_SPROM4_TXPID5GL2_SHIFT;
 
--	bus->sprom.txpid5gl[3] = (sprom[SPOFF(SSB_SPROM4_TXPID5GL23)] &
 
--	     SSB_SPROM4_TXPID5GL3) >> SSB_SPROM4_TXPID5GL3_SHIFT;
 
--
 
--	bus->sprom.txpid5g[0] = (sprom[SPOFF(SSB_SPROM4_TXPID5G01)] &
 
--	     SSB_SPROM4_TXPID5G0) >> SSB_SPROM4_TXPID5G0_SHIFT;
 
--	bus->sprom.txpid5g[1] = (sprom[SPOFF(SSB_SPROM4_TXPID5G01)] &
 
--	     SSB_SPROM4_TXPID5G1) >> SSB_SPROM4_TXPID5G1_SHIFT;
 
--	bus->sprom.txpid5g[2] = (sprom[SPOFF(SSB_SPROM4_TXPID5G23)] &
 
--	     SSB_SPROM4_TXPID5G2) >> SSB_SPROM4_TXPID5G2_SHIFT;
 
--	bus->sprom.txpid5g[3] = (sprom[SPOFF(SSB_SPROM4_TXPID5G23)] &
 
--	     SSB_SPROM4_TXPID5G3) >> SSB_SPROM4_TXPID5G3_SHIFT;
 
--
 
--	bus->sprom.txpid5gh[0] = (sprom[SPOFF(SSB_SPROM4_TXPID5GH01)] &
 
--	     SSB_SPROM4_TXPID5GH0) >> SSB_SPROM4_TXPID5GH0_SHIFT;
 
--	bus->sprom.txpid5gh[1] = (sprom[SPOFF(SSB_SPROM4_TXPID5GH01)] &
 
--	     SSB_SPROM4_TXPID5GH1) >> SSB_SPROM4_TXPID5GH1_SHIFT;
 
--	bus->sprom.txpid5gh[2] = (sprom[SPOFF(SSB_SPROM4_TXPID5GH23)] &
 
--	     SSB_SPROM4_TXPID5GH2) >> SSB_SPROM4_TXPID5GH2_SHIFT;
 
--	bus->sprom.txpid5gh[3] = (sprom[SPOFF(SSB_SPROM4_TXPID5GH23)] &
 
--	     SSB_SPROM4_TXPID5GH3) >> SSB_SPROM4_TXPID5GH3_SHIFT;
 
--
 
--	bus->sprom.boardflags_lo = sprom[SPOFF(SSB_SPROM8_BFLLO)];
 
--	bus->sprom.boardflags_hi = sprom[SPOFF(SSB_SPROM8_BFLHI)];
 
--	bus->sprom.boardflags2_lo = sprom[SPOFF(SSB_SPROM8_BFL2LO)];
 
--	bus->sprom.boardflags2_hi = sprom[SPOFF(SSB_SPROM8_BFL2HI)];
 
--
 
--	bus->sprom.country_code = sprom[SPOFF(SSB_SPROM8_CCODE)];
 
--
 
--	bus->sprom.fem.ghz2.tssipos = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
 
--		SSB_SROM8_FEM_TSSIPOS) >> SSB_SROM8_FEM_TSSIPOS_SHIFT;
 
--	bus->sprom.fem.ghz2.extpa_gain = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
 
--		SSB_SROM8_FEM_EXTPA_GAIN) >> SSB_SROM8_FEM_EXTPA_GAIN_SHIFT;
 
--	bus->sprom.fem.ghz2.pdet_range = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
 
--		SSB_SROM8_FEM_PDET_RANGE) >> SSB_SROM8_FEM_PDET_RANGE_SHIFT;
 
--	bus->sprom.fem.ghz2.tr_iso = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
 
--		SSB_SROM8_FEM_TR_ISO) >> SSB_SROM8_FEM_TR_ISO_SHIFT;
 
--	bus->sprom.fem.ghz2.antswlut = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
 
--		SSB_SROM8_FEM_ANTSWLUT) >> SSB_SROM8_FEM_ANTSWLUT_SHIFT;
 
--
 
--	bus->sprom.fem.ghz5.tssipos = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
 
--		SSB_SROM8_FEM_TSSIPOS) >> SSB_SROM8_FEM_TSSIPOS_SHIFT;
 
--	bus->sprom.fem.ghz5.extpa_gain = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
 
--		SSB_SROM8_FEM_EXTPA_GAIN) >> SSB_SROM8_FEM_EXTPA_GAIN_SHIFT;
 
--	bus->sprom.fem.ghz5.pdet_range = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
 
--		SSB_SROM8_FEM_PDET_RANGE) >> SSB_SROM8_FEM_PDET_RANGE_SHIFT;
 
--	bus->sprom.fem.ghz5.tr_iso = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
 
--		SSB_SROM8_FEM_TR_ISO) >> SSB_SROM8_FEM_TR_ISO_SHIFT;
 
--	bus->sprom.fem.ghz5.antswlut = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
 
--		SSB_SROM8_FEM_ANTSWLUT) >> SSB_SROM8_FEM_ANTSWLUT_SHIFT;
 
-+	default:
 
-+		return true;
 
-+	}
 
-+
 
-+	return chip_status & present_mask;
 
-+}
 
-+
 
-+/*
 
-+ * Indicates that on-chip OTP memory is present and enabled.
 
-+ */
 
-+static bool bcma_sprom_onchip_available(struct bcma_bus *bus)
 
-+{
 
-+	u32 chip_status;
 
-+	u32 otpsize = 0;
 
-+	bool present;
 
-+
 
-+	chip_status = bcma_read32(bus->drv_cc.core, BCMA_CC_CHIPSTAT);
 
-+	switch (bus->chipinfo.id) {
 
-+	case BCMA_CHIP_ID_BCM4313:
 
-+		present = chip_status & BCMA_CC_CHIPST_4313_OTP_PRESENT;
 
-+		break;
 
-+
 
-+	case BCMA_CHIP_ID_BCM4331:
 
-+		present = chip_status & BCMA_CC_CHIPST_4331_OTP_PRESENT;
 
-+		break;
 
-+	case BCMA_CHIP_ID_BCM43142:
 
-+	case BCMA_CHIP_ID_BCM43224:
 
-+	case BCMA_CHIP_ID_BCM43225:
 
-+		/* for these chips OTP is always available */
 
-+		present = true;
 
-+		break;
 
-+	case BCMA_CHIP_ID_BCM43227:
 
-+	case BCMA_CHIP_ID_BCM43228:
 
-+	case BCMA_CHIP_ID_BCM43428:
 
-+		present = chip_status & BCMA_CC_CHIPST_43228_OTP_PRESENT;
 
-+		break;
 
-+	default:
 
-+		present = false;
 
-+		break;
 
-+	}
 
-+
 
-+	if (present) {
 
-+		otpsize = bus->drv_cc.capabilities & BCMA_CC_CAP_OTPS;
 
-+		otpsize >>= BCMA_CC_CAP_OTPS_SHIFT;
 
-+	}
 
-+
 
-+	return otpsize != 0;
 
-+}
 
-+
 
-+/*
 
-+ * Verify OTP is filled and determine the byte
 
-+ * offset where SPROM data is located.
 
-+ *
 
-+ * On error, returns 0; byte offset otherwise.
 
-+ */
 
-+static int bcma_sprom_onchip_offset(struct bcma_bus *bus)
 
-+{
 
-+	struct bcma_device *cc = bus->drv_cc.core;
 
-+	u32 offset;
 
-+
 
-+	/* verify OTP status */
 
-+	if ((bcma_read32(cc, BCMA_CC_OTPS) & BCMA_CC_OTPS_GU_PROG_HW) == 0)
 
-+		return 0;
 
-+
 
-+	/* obtain bit offset from otplayout register */
 
-+	offset = (bcma_read32(cc, BCMA_CC_OTPL) & BCMA_CC_OTPL_GURGN_OFFSET);
 
-+	return BCMA_CC_SPROM + (offset >> 3);
 
- }
 
- 
- int bcma_sprom_get(struct bcma_bus *bus)
 
- {
 
--	u16 offset;
 
-+	u16 offset = BCMA_CC_SPROM;
 
- 	u16 *sprom;
 
--	int err = 0;
 
-+	size_t sprom_sizes[] = { SSB_SPROMSIZE_WORDS_R4,
 
-+				 SSB_SPROMSIZE_WORDS_R10, };
 
-+	int i, err = 0;
 
- 
- 	if (!bus->drv_cc.core)
 
- 		return -EOPNOTSUPP;
 
- 
--	if (!(bus->drv_cc.capabilities & BCMA_CC_CAP_SPROM))
 
--		return -ENOENT;
 
-+	if (!bcma_sprom_ext_available(bus)) {
 
-+		bool sprom_onchip;
 
- 
--	sprom = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16),
 
--			GFP_KERNEL);
 
--	if (!sprom)
 
--		return -ENOMEM;
 
-+		/*
 
-+		 * External SPROM takes precedence so check
 
-+		 * on-chip OTP only when no external SPROM
 
-+		 * is present.
 
-+		 */
 
-+		sprom_onchip = bcma_sprom_onchip_available(bus);
 
-+		if (sprom_onchip) {
 
-+			/* determine offset */
 
-+			offset = bcma_sprom_onchip_offset(bus);
 
-+		}
 
-+		if (!offset || !sprom_onchip) {
 
-+			/*
 
-+			 * Maybe there is no SPROM on the device?
 
-+			 * Now we ask the arch code if there is some sprom
 
-+			 * available for this device in some other storage.
 
-+			 */
 
-+			err = bcma_fill_sprom_with_fallback(bus, &bus->sprom);
 
-+			return err;
 
-+		}
 
-+	}
 
- 
--	if (bus->chipinfo.id == 0x4331)
 
-+	if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4331 ||
 
-+	    bus->chipinfo.id == BCMA_CHIP_ID_BCM43431)
 
- 		bcma_chipco_bcm4331_ext_pa_lines_ctl(&bus->drv_cc, false);
 
- 
--	/* Most cards have SPROM moved by additional offset 0x30 (48 dwords).
 
--	 * According to brcm80211 this applies to cards with PCIe rev >= 6
 
--	 * TODO: understand this condition and use it */
 
--	offset = (bus->chipinfo.id == 0x4331) ? BCMA_CC_SPROM :
 
--		BCMA_CC_SPROM_PCIE6;
 
--	bcma_sprom_read(bus, offset, sprom);
 
-+	bcma_debug(bus, "SPROM offset 0x%x\n", offset);
 
-+	for (i = 0; i < ARRAY_SIZE(sprom_sizes); i++) {
 
-+		size_t words = sprom_sizes[i];
 
-+
 
-+		sprom = kcalloc(words, sizeof(u16), GFP_KERNEL);
 
-+		if (!sprom)
 
-+			return -ENOMEM;
 
-+
 
-+		bcma_sprom_read(bus, offset, sprom, words);
 
-+		err = bcma_sprom_valid(bus, sprom, words);
 
-+		if (!err)
 
-+			break;
 
- 
--	if (bus->chipinfo.id == 0x4331)
 
--		bcma_chipco_bcm4331_ext_pa_lines_ctl(&bus->drv_cc, true);
 
-+		kfree(sprom);
 
-+	}
 
- 
--	err = bcma_sprom_valid(sprom);
 
--	if (err)
 
--		goto out;
 
-+	if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4331 ||
 
-+	    bus->chipinfo.id == BCMA_CHIP_ID_BCM43431)
 
-+		bcma_chipco_bcm4331_ext_pa_lines_ctl(&bus->drv_cc, true);
 
- 
--	bcma_sprom_extract_r8(bus, sprom);
 
-+	if (err) {
 
-+		bcma_warn(bus, "Invalid SPROM read from the PCIe card, trying to use fallback SPROM\n");
 
-+		err = bcma_fill_sprom_with_fallback(bus, &bus->sprom);
 
-+	} else {
 
-+		bcma_sprom_extract_r8(bus, sprom);
 
-+		kfree(sprom);
 
-+	}
 
- 
--out:
 
--	kfree(sprom);
 
- 	return err;
 
- }
 
---- a/include/linux/bcma/bcma.h
 
-+++ b/include/linux/bcma/bcma.h
 
-@@ -7,9 +7,10 @@
 
- #include <linux/bcma/bcma_driver_chipcommon.h>
 
- #include <linux/bcma/bcma_driver_pci.h>
 
- #include <linux/bcma/bcma_driver_mips.h>
 
-+#include <linux/bcma/bcma_driver_gmac_cmn.h>
 
- #include <linux/ssb/ssb.h> /* SPROM sharing */
 
- 
--#include "bcma_regs.h"
 
-+#include <linux/bcma/bcma_regs.h>
 
- 
- struct bcma_device;
 
- struct bcma_bus;
 
-@@ -26,6 +27,11 @@ struct bcma_chipinfo {
 
- 	u8 pkg;
 
- };
 
- 
-+struct bcma_boardinfo {
 
-+	u16 vendor;
 
-+	u16 type;
 
-+};
 
-+
 
- enum bcma_clkmode {
 
- 	BCMA_CLKMODE_FAST,
 
- 	BCMA_CLKMODE_DYNAMIC,
 
-@@ -65,6 +71,25 @@ struct bcma_host_ops {
 
- 
- /* Core-ID values. */
 
- #define BCMA_CORE_OOB_ROUTER		0x367	/* Out of band */
 
-+#define BCMA_CORE_4706_CHIPCOMMON	0x500
 
-+#define BCMA_CORE_PCIEG2		0x501
 
-+#define BCMA_CORE_DMA			0x502
 
-+#define BCMA_CORE_SDIO3			0x503
 
-+#define BCMA_CORE_USB20			0x504
 
-+#define BCMA_CORE_USB30			0x505
 
-+#define BCMA_CORE_A9JTAG		0x506
 
-+#define BCMA_CORE_DDR23			0x507
 
-+#define BCMA_CORE_ROM			0x508
 
-+#define BCMA_CORE_NAND			0x509
 
-+#define BCMA_CORE_QSPI			0x50A
 
-+#define BCMA_CORE_CHIPCOMMON_B		0x50B
 
-+#define BCMA_CORE_4706_SOC_RAM		0x50E
 
-+#define BCMA_CORE_ARMCA9		0x510
 
-+#define BCMA_CORE_4706_MAC_GBIT		0x52D
 
-+#define BCMA_CORE_AMEMC			0x52E	/* DDR1/2 memory controller core */
 
-+#define BCMA_CORE_ALTA			0x534	/* I2S core */
 
-+#define BCMA_CORE_4706_MAC_GBIT_COMMON	0x5DC
 
-+#define BCMA_CORE_DDR23_PHY		0x5DD
 
- #define BCMA_CORE_INVALID		0x700
 
- #define BCMA_CORE_CHIPCOMMON		0x800
 
- #define BCMA_CORE_ILINE20		0x801
 
-@@ -121,10 +146,112 @@ struct bcma_host_ops {
 
- #define BCMA_CORE_I2S			0x834
 
- #define BCMA_CORE_SDR_DDR1_MEM_CTL	0x835	/* SDR/DDR1 memory controller core */
 
- #define BCMA_CORE_SHIM			0x837	/* SHIM component in ubus/6362 */
 
-+#define BCMA_CORE_PHY_AC		0x83B
 
-+#define BCMA_CORE_PCIE2			0x83C	/* PCI Express Gen2 */
 
-+#define BCMA_CORE_USB30_DEV		0x83D
 
-+#define BCMA_CORE_ARM_CR4		0x83E
 
- #define BCMA_CORE_DEFAULT		0xFFF
 
- 
- #define BCMA_MAX_NR_CORES		16
 
- 
-+/* Chip IDs of PCIe devices */
 
-+#define BCMA_CHIP_ID_BCM4313	0x4313
 
-+#define BCMA_CHIP_ID_BCM43142	43142
 
-+#define BCMA_CHIP_ID_BCM43131  43131
 
-+#define BCMA_CHIP_ID_BCM43217  43217
 
-+#define BCMA_CHIP_ID_BCM43222  43222
 
-+#define BCMA_CHIP_ID_BCM43224	43224
 
-+#define  BCMA_PKG_ID_BCM43224_FAB_CSM	0x8
 
-+#define  BCMA_PKG_ID_BCM43224_FAB_SMIC	0xa
 
-+#define BCMA_CHIP_ID_BCM43225	43225
 
-+#define BCMA_CHIP_ID_BCM43227	43227
 
-+#define BCMA_CHIP_ID_BCM43228	43228
 
-+#define BCMA_CHIP_ID_BCM43421	43421
 
-+#define BCMA_CHIP_ID_BCM43428	43428
 
-+#define BCMA_CHIP_ID_BCM43431	43431
 
-+#define BCMA_CHIP_ID_BCM43460	43460
 
-+#define BCMA_CHIP_ID_BCM4331	0x4331
 
-+#define BCMA_CHIP_ID_BCM6362	0x6362
 
-+#define BCMA_CHIP_ID_BCM4360	0x4360
 
-+#define BCMA_CHIP_ID_BCM4352	0x4352
 
-+
 
-+/* Chip IDs of SoCs */
 
-+#define BCMA_CHIP_ID_BCM4706	0x5300
 
-+#define  BCMA_PKG_ID_BCM4706L	1
 
-+#define BCMA_CHIP_ID_BCM4716	0x4716
 
-+#define  BCMA_PKG_ID_BCM4716	8
 
-+#define  BCMA_PKG_ID_BCM4717	9
 
-+#define  BCMA_PKG_ID_BCM4718	10
 
-+#define BCMA_CHIP_ID_BCM47162	47162
 
-+#define BCMA_CHIP_ID_BCM4748	0x4748
 
-+#define BCMA_CHIP_ID_BCM4749	0x4749
 
-+#define BCMA_CHIP_ID_BCM5356	0x5356
 
-+#define BCMA_CHIP_ID_BCM5357	0x5357
 
-+#define  BCMA_PKG_ID_BCM5358	9
 
-+#define  BCMA_PKG_ID_BCM47186	10
 
-+#define  BCMA_PKG_ID_BCM5357	11
 
-+#define BCMA_CHIP_ID_BCM53572	53572
 
-+#define  BCMA_PKG_ID_BCM47188	9
 
-+#define BCMA_CHIP_ID_BCM4707	53010
 
-+#define  BCMA_PKG_ID_BCM4707	1
 
-+#define  BCMA_PKG_ID_BCM4708	2
 
-+#define  BCMA_PKG_ID_BCM4709	0
 
-+#define BCMA_CHIP_ID_BCM53018	53018
 
-+
 
-+/* Board types (on PCI usually equals to the subsystem dev id) */
 
-+/* BCM4313 */
 
-+#define BCMA_BOARD_TYPE_BCM94313BU	0X050F
 
-+#define BCMA_BOARD_TYPE_BCM94313HM	0X0510
 
-+#define BCMA_BOARD_TYPE_BCM94313EPA	0X0511
 
-+#define BCMA_BOARD_TYPE_BCM94313HMG	0X051C
 
-+/* BCM4716 */
 
-+#define BCMA_BOARD_TYPE_BCM94716NR2	0X04CD
 
-+/* BCM43224 */
 
-+#define BCMA_BOARD_TYPE_BCM943224X21	0X056E
 
-+#define BCMA_BOARD_TYPE_BCM943224X21_FCC	0X00D1
 
-+#define BCMA_BOARD_TYPE_BCM943224X21B	0X00E9
 
-+#define BCMA_BOARD_TYPE_BCM943224M93	0X008B
 
-+#define BCMA_BOARD_TYPE_BCM943224M93A	0X0090
 
-+#define BCMA_BOARD_TYPE_BCM943224X16	0X0093
 
-+#define BCMA_BOARD_TYPE_BCM94322X9	0X008D
 
-+#define BCMA_BOARD_TYPE_BCM94322M35E	0X008E
 
-+/* BCM43228 */
 
-+#define BCMA_BOARD_TYPE_BCM943228BU8	0X0540
 
-+#define BCMA_BOARD_TYPE_BCM943228BU9	0X0541
 
-+#define BCMA_BOARD_TYPE_BCM943228BU	0X0542
 
-+#define BCMA_BOARD_TYPE_BCM943227HM4L	0X0543
 
-+#define BCMA_BOARD_TYPE_BCM943227HMB	0X0544
 
-+#define BCMA_BOARD_TYPE_BCM943228HM4L	0X0545
 
-+#define BCMA_BOARD_TYPE_BCM943228SD	0X0573
 
-+/* BCM4331 */
 
-+#define BCMA_BOARD_TYPE_BCM94331X19	0X00D6
 
-+#define BCMA_BOARD_TYPE_BCM94331X28	0X00E4
 
-+#define BCMA_BOARD_TYPE_BCM94331X28B	0X010E
 
-+#define BCMA_BOARD_TYPE_BCM94331PCIEBT3AX	0X00E4
 
-+#define BCMA_BOARD_TYPE_BCM94331X12_2G	0X00EC
 
-+#define BCMA_BOARD_TYPE_BCM94331X12_5G	0X00ED
 
-+#define BCMA_BOARD_TYPE_BCM94331X29B	0X00EF
 
-+#define BCMA_BOARD_TYPE_BCM94331CSAX	0X00EF
 
-+#define BCMA_BOARD_TYPE_BCM94331X19C	0X00F5
 
-+#define BCMA_BOARD_TYPE_BCM94331X33	0X00F4
 
-+#define BCMA_BOARD_TYPE_BCM94331BU	0X0523
 
-+#define BCMA_BOARD_TYPE_BCM94331S9BU	0X0524
 
-+#define BCMA_BOARD_TYPE_BCM94331MC	0X0525
 
-+#define BCMA_BOARD_TYPE_BCM94331MCI	0X0526
 
-+#define BCMA_BOARD_TYPE_BCM94331PCIEBT4	0X0527
 
-+#define BCMA_BOARD_TYPE_BCM94331HM	0X0574
 
-+#define BCMA_BOARD_TYPE_BCM94331PCIEDUAL	0X059B
 
-+#define BCMA_BOARD_TYPE_BCM94331MCH5	0X05A9
 
-+#define BCMA_BOARD_TYPE_BCM94331CS	0X05C6
 
-+#define BCMA_BOARD_TYPE_BCM94331CD	0X05DA
 
-+/* BCM53572 */
 
-+#define BCMA_BOARD_TYPE_BCM953572BU	0X058D
 
-+#define BCMA_BOARD_TYPE_BCM953572NR2	0X058E
 
-+#define BCMA_BOARD_TYPE_BCM947188NR2	0X058F
 
-+#define BCMA_BOARD_TYPE_BCM953572SDRNR2	0X0590
 
-+/* BCM43142 */
 
-+#define BCMA_BOARD_TYPE_BCM943142HM	0X05E0
 
-+
 
- struct bcma_device {
 
- 	struct bcma_bus *bus;
 
- 	struct bcma_device_id id;
 
-@@ -136,8 +263,10 @@ struct bcma_device {
 
- 	bool dev_registered;
 
- 
- 	u8 core_index;
 
-+	u8 core_unit;
 
- 
- 	u32 addr;
 
-+	u32 addr1;
 
- 	u32 wrap;
 
- 
- 	void __iomem *io_addr;
 
-@@ -175,6 +304,12 @@ int __bcma_driver_register(struct bcma_d
 
- 
- extern void bcma_driver_unregister(struct bcma_driver *drv);
 
- 
-+/* Set a fallback SPROM.
 
-+ * See kdoc at the function definition for complete documentation. */
 
-+extern int bcma_arch_register_fallback_sprom(
 
-+		int (*sprom_callback)(struct bcma_bus *bus,
 
-+		struct ssb_sprom *out));
 
-+
 
- struct bcma_bus {
 
- 	/* The MMIO area. */
 
- 	void __iomem *mmio;
 
-@@ -191,14 +326,18 @@ struct bcma_bus {
 
- 
- 	struct bcma_chipinfo chipinfo;
 
- 
-+	struct bcma_boardinfo boardinfo;
 
-+
 
- 	struct bcma_device *mapped_core;
 
- 	struct list_head cores;
 
- 	u8 nr_cores;
 
- 	u8 init_done:1;
 
-+	u8 num;
 
- 
- 	struct bcma_drv_cc drv_cc;
 
--	struct bcma_drv_pci drv_pci;
 
-+	struct bcma_drv_pci drv_pci[2];
 
- 	struct bcma_drv_mips drv_mips;
 
-+	struct bcma_drv_gmac_cmn drv_gmac_cmn;
 
- 
- 	/* We decided to share SPROM struct with SSB as long as we do not need
 
- 	 * any hacks for BCMA. This simplifies drivers code. */
 
-@@ -282,6 +421,7 @@ static inline void bcma_maskset16(struct
 
- 	bcma_write16(cc, offset, (bcma_read16(cc, offset) & mask) | set);
 
- }
 
- 
-+extern struct bcma_device *bcma_find_core(struct bcma_bus *bus, u16 coreid);
 
- extern bool bcma_core_is_enabled(struct bcma_device *core);
 
- extern void bcma_core_disable(struct bcma_device *core, u32 flags);
 
- extern int bcma_core_enable(struct bcma_device *core, u32 flags);
 
-@@ -289,6 +429,7 @@ extern void bcma_core_set_clockmode(stru
 
- 				    enum bcma_clkmode clkmode);
 
- extern void bcma_core_pll_ctl(struct bcma_device *core, u32 req, u32 status,
 
- 			      bool on);
 
-+extern u32 bcma_chipco_pll_read(struct bcma_drv_cc *cc, u32 offset);
 
- #define BCMA_DMA_TRANSLATION_MASK	0xC0000000
 
- #define  BCMA_DMA_TRANSLATION_NONE	0x00000000
 
- #define  BCMA_DMA_TRANSLATION_DMA32_CMT	0x40000000 /* Client Mode Translation for 32-bit DMA */
 
---- a/include/linux/bcma/bcma_driver_chipcommon.h
 
-+++ b/include/linux/bcma/bcma_driver_chipcommon.h
 
-@@ -1,6 +1,9 @@
 
- #ifndef LINUX_BCMA_DRIVER_CC_H_
 
- #define LINUX_BCMA_DRIVER_CC_H_
 
- 
-+#include <linux/platform_device.h>
 
-+#include <linux/gpio.h>
 
-+
 
- /** ChipCommon core registers. **/
 
- #define BCMA_CC_ID			0x0000
 
- #define  BCMA_CC_ID_ID			0x0000FFFF
 
-@@ -24,7 +27,7 @@
 
- #define   BCMA_CC_FLASHT_NONE		0x00000000	/* No flash */
 
- #define   BCMA_CC_FLASHT_STSER		0x00000100	/* ST serial flash */
 
- #define   BCMA_CC_FLASHT_ATSER		0x00000200	/* Atmel serial flash */
 
--#define   BCMA_CC_FLASHT_NFLASH		0x00000200
 
-+#define   BCMA_CC_FLASHT_NAND		0x00000300	/* NAND flash */
 
- #define	  BCMA_CC_FLASHT_PARA		0x00000700	/* Parallel flash */
 
- #define  BCMA_CC_CAP_PLLT		0x00038000	/* PLL Type */
 
- #define   BCMA_PLLTYPE_NONE		0x00000000
 
-@@ -45,6 +48,7 @@
 
- #define  BCMA_CC_CAP_PMU		0x10000000	/* PMU available (rev >= 20) */
 
- #define  BCMA_CC_CAP_ECI		0x20000000	/* ECI available (rev >= 20) */
 
- #define  BCMA_CC_CAP_SPROM		0x40000000	/* SPROM present */
 
-+#define  BCMA_CC_CAP_NFLASH		0x80000000	/* NAND flash present (rev >= 35 or BCM4706?) */
 
- #define BCMA_CC_CORECTL			0x0008
 
- #define  BCMA_CC_CORECTL_UARTCLK0	0x00000001	/* Drive UART with internal clock */
 
- #define	 BCMA_CC_CORECTL_SE		0x00000002	/* sync clk out enable (corerev >= 3) */
 
-@@ -56,6 +60,9 @@
 
- #define	 BCMA_CC_OTPS_HW_PROTECT	0x00000001
 
- #define	 BCMA_CC_OTPS_SW_PROTECT	0x00000002
 
- #define	 BCMA_CC_OTPS_CID_PROTECT	0x00000004
 
-+#define  BCMA_CC_OTPS_GU_PROG_IND	0x00000F00	/* General Use programmed indication */
 
-+#define  BCMA_CC_OTPS_GU_PROG_IND_SHIFT	8
 
-+#define  BCMA_CC_OTPS_GU_PROG_HW	0x00000100	/* HW region programmed */
 
- #define BCMA_CC_OTPC			0x0014		/* OTP control */
 
- #define	 BCMA_CC_OTPC_RECWAIT		0xFF000000
 
- #define	 BCMA_CC_OTPC_PROGWAIT		0x00FFFF00
 
-@@ -72,6 +79,8 @@
 
- #define	 BCMA_CC_OTPP_READ		0x40000000
 
- #define	 BCMA_CC_OTPP_START		0x80000000
 
- #define	 BCMA_CC_OTPP_BUSY		0x80000000
 
-+#define BCMA_CC_OTPL			0x001C		/* OTP layout */
 
-+#define  BCMA_CC_OTPL_GURGN_OFFSET	0x00000FFF	/* offset of general use region */
 
- #define BCMA_CC_IRQSTAT			0x0020
 
- #define BCMA_CC_IRQMASK			0x0024
 
- #define	 BCMA_CC_IRQ_GPIO		0x00000001	/* gpio intr */
 
-@@ -79,6 +88,23 @@
 
- #define	 BCMA_CC_IRQ_WDRESET		0x80000000	/* watchdog reset occurred */
 
- #define BCMA_CC_CHIPCTL			0x0028		/* Rev >= 11 only */
 
- #define BCMA_CC_CHIPSTAT		0x002C		/* Rev >= 11 only */
 
-+#define  BCMA_CC_CHIPST_4313_SPROM_PRESENT	1
 
-+#define  BCMA_CC_CHIPST_4313_OTP_PRESENT	2
 
-+#define  BCMA_CC_CHIPST_4331_SPROM_PRESENT	2
 
-+#define  BCMA_CC_CHIPST_4331_OTP_PRESENT	4
 
-+#define  BCMA_CC_CHIPST_43228_ILP_DIV_EN	0x00000001
 
-+#define  BCMA_CC_CHIPST_43228_OTP_PRESENT	0x00000002
 
-+#define  BCMA_CC_CHIPST_43228_SERDES_REFCLK_PADSEL	0x00000004
 
-+#define  BCMA_CC_CHIPST_43228_SDIO_MODE		0x00000008
 
-+#define  BCMA_CC_CHIPST_43228_SDIO_OTP_PRESENT	0x00000010
 
-+#define  BCMA_CC_CHIPST_43228_SDIO_RESET	0x00000020
 
-+#define  BCMA_CC_CHIPST_4706_PKG_OPTION		BIT(0) /* 0: full-featured package 1: low-cost package */
 
-+#define  BCMA_CC_CHIPST_4706_SFLASH_PRESENT	BIT(1) /* 0: parallel, 1: serial flash is present */
 
-+#define  BCMA_CC_CHIPST_4706_SFLASH_TYPE	BIT(2) /* 0: 8b-p/ST-s flash, 1: 16b-p/Atmal-s flash */
 
-+#define  BCMA_CC_CHIPST_4706_MIPS_BENDIAN	BIT(3) /* 0: little, 1: big endian */
 
-+#define  BCMA_CC_CHIPST_4706_PCIE1_DISABLE	BIT(5) /* PCIE1 enable strap pin */
 
-+#define  BCMA_CC_CHIPST_5357_NAND_BOOT		BIT(4) /* NAND boot, valid for CC rev 38 and/or BCM5357 */
 
-+#define  BCMA_CC_CHIPST_4360_XTAL_40MZ		0x00000001
 
- #define BCMA_CC_JCMD			0x0030		/* Rev >= 10 only */
 
- #define  BCMA_CC_JCMD_START		0x80000000
 
- #define  BCMA_CC_JCMD_BUSY		0x80000000
 
-@@ -108,10 +134,58 @@
 
- #define  BCMA_CC_JCTL_EXT_EN		2		/* Enable external targets */
 
- #define  BCMA_CC_JCTL_EN		1		/* Enable Jtag master */
 
- #define BCMA_CC_FLASHCTL		0x0040
 
-+/* Start/busy bit in flashcontrol */
 
-+#define  BCMA_CC_FLASHCTL_OPCODE	0x000000ff
 
-+#define  BCMA_CC_FLASHCTL_ACTION	0x00000700
 
-+#define  BCMA_CC_FLASHCTL_CS_ACTIVE	0x00001000	/* Chip Select Active, rev >= 20 */
 
- #define  BCMA_CC_FLASHCTL_START		0x80000000
 
- #define  BCMA_CC_FLASHCTL_BUSY		BCMA_CC_FLASHCTL_START
 
-+/* Flashcontrol action + opcodes for ST flashes */
 
-+#define  BCMA_CC_FLASHCTL_ST_WREN	0x0006		/* Write Enable */
 
-+#define  BCMA_CC_FLASHCTL_ST_WRDIS	0x0004		/* Write Disable */
 
-+#define  BCMA_CC_FLASHCTL_ST_RDSR	0x0105		/* Read Status Register */
 
-+#define  BCMA_CC_FLASHCTL_ST_WRSR	0x0101		/* Write Status Register */
 
-+#define  BCMA_CC_FLASHCTL_ST_READ	0x0303		/* Read Data Bytes */
 
-+#define  BCMA_CC_FLASHCTL_ST_PP		0x0302		/* Page Program */
 
-+#define  BCMA_CC_FLASHCTL_ST_SE		0x02d8		/* Sector Erase */
 
-+#define  BCMA_CC_FLASHCTL_ST_BE		0x00c7		/* Bulk Erase */
 
-+#define  BCMA_CC_FLASHCTL_ST_DP		0x00b9		/* Deep Power-down */
 
-+#define  BCMA_CC_FLASHCTL_ST_RES	0x03ab		/* Read Electronic Signature */
 
-+#define  BCMA_CC_FLASHCTL_ST_CSA	0x1000		/* Keep chip select asserted */
 
-+#define  BCMA_CC_FLASHCTL_ST_SSE	0x0220		/* Sub-sector Erase */
 
-+/* Flashcontrol action + opcodes for Atmel flashes */
 
-+#define  BCMA_CC_FLASHCTL_AT_READ			0x07e8
 
-+#define  BCMA_CC_FLASHCTL_AT_PAGE_READ			0x07d2
 
-+#define  BCMA_CC_FLASHCTL_AT_STATUS			0x01d7
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF1_WRITE			0x0384
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF2_WRITE			0x0387
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF1_ERASE_PROGRAM		0x0283
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF2_ERASE_PROGRAM		0x0286
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF1_PROGRAM		0x0288
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF2_PROGRAM		0x0289
 
-+#define  BCMA_CC_FLASHCTL_AT_PAGE_ERASE			0x0281
 
-+#define  BCMA_CC_FLASHCTL_AT_BLOCK_ERASE		0x0250
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF1_WRITE_ERASE_PROGRAM	0x0382
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF2_WRITE_ERASE_PROGRAM	0x0385
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF1_LOAD			0x0253
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF2_LOAD			0x0255
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF1_COMPARE		0x0260
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF2_COMPARE		0x0261
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF1_REPROGRAM		0x0258
 
-+#define  BCMA_CC_FLASHCTL_AT_BUF2_REPROGRAM		0x0259
 
- #define BCMA_CC_FLASHADDR		0x0044
 
- #define BCMA_CC_FLASHDATA		0x0048
 
-+/* Status register bits for ST flashes */
 
-+#define  BCMA_CC_FLASHDATA_ST_WIP	0x01		/* Write In Progress */
 
-+#define  BCMA_CC_FLASHDATA_ST_WEL	0x02		/* Write Enable Latch */
 
-+#define  BCMA_CC_FLASHDATA_ST_BP_MASK	0x1c		/* Block Protect */
 
-+#define  BCMA_CC_FLASHDATA_ST_BP_SHIFT	2
 
-+#define  BCMA_CC_FLASHDATA_ST_SRWD	0x80		/* Status Register Write Disable */
 
-+/* Status register bits for Atmel flashes */
 
-+#define  BCMA_CC_FLASHDATA_AT_READY	0x80
 
-+#define  BCMA_CC_FLASHDATA_AT_MISMATCH	0x40
 
-+#define  BCMA_CC_FLASHDATA_AT_ID_MASK	0x38
 
-+#define  BCMA_CC_FLASHDATA_AT_ID_SHIFT	3
 
- #define BCMA_CC_BCAST_ADDR		0x0050
 
- #define BCMA_CC_BCAST_DATA		0x0054
 
- #define BCMA_CC_GPIOPULLUP		0x0058		/* Rev >= 20 only */
 
-@@ -181,6 +255,45 @@
 
- #define BCMA_CC_FLASH_CFG		0x0128
 
- #define  BCMA_CC_FLASH_CFG_DS		0x0010	/* Data size, 0=8bit, 1=16bit */
 
- #define BCMA_CC_FLASH_WAITCNT		0x012C
 
-+#define BCMA_CC_SROM_CONTROL		0x0190
 
-+#define  BCMA_CC_SROM_CONTROL_START	0x80000000
 
-+#define  BCMA_CC_SROM_CONTROL_BUSY	0x80000000
 
-+#define  BCMA_CC_SROM_CONTROL_OPCODE	0x60000000
 
-+#define  BCMA_CC_SROM_CONTROL_OP_READ	0x00000000
 
-+#define  BCMA_CC_SROM_CONTROL_OP_WRITE	0x20000000
 
-+#define  BCMA_CC_SROM_CONTROL_OP_WRDIS	0x40000000
 
-+#define  BCMA_CC_SROM_CONTROL_OP_WREN	0x60000000
 
-+#define  BCMA_CC_SROM_CONTROL_OTPSEL	0x00000010
 
-+#define  BCMA_CC_SROM_CONTROL_LOCK	0x00000008
 
-+#define  BCMA_CC_SROM_CONTROL_SIZE_MASK	0x00000006
 
-+#define  BCMA_CC_SROM_CONTROL_SIZE_1K	0x00000000
 
-+#define  BCMA_CC_SROM_CONTROL_SIZE_4K	0x00000002
 
-+#define  BCMA_CC_SROM_CONTROL_SIZE_16K	0x00000004
 
-+#define  BCMA_CC_SROM_CONTROL_SIZE_SHIFT	1
 
-+#define  BCMA_CC_SROM_CONTROL_PRESENT	0x00000001
 
-+/* Block 0x140 - 0x190 registers are chipset specific */
 
-+#define BCMA_CC_4706_FLASHSCFG		0x18C		/* Flash struct configuration */
 
-+#define  BCMA_CC_4706_FLASHSCFG_MASK	0x000000ff
 
-+#define  BCMA_CC_4706_FLASHSCFG_SF1	0x00000001	/* 2nd serial flash present */
 
-+#define  BCMA_CC_4706_FLASHSCFG_PF1	0x00000002	/* 2nd parallel flash present */
 
-+#define  BCMA_CC_4706_FLASHSCFG_SF1_TYPE	0x00000004	/* 2nd serial flash type : 0 : ST, 1 : Atmel */
 
-+#define  BCMA_CC_4706_FLASHSCFG_NF1	0x00000008	/* 2nd NAND flash present */
 
-+#define  BCMA_CC_4706_FLASHSCFG_1ST_MADDR_SEG_MASK	0x000000f0
 
-+#define  BCMA_CC_4706_FLASHSCFG_1ST_MADDR_SEG_4MB	0x00000010	/* 4MB */
 
-+#define  BCMA_CC_4706_FLASHSCFG_1ST_MADDR_SEG_8MB	0x00000020	/* 8MB */
 
-+#define  BCMA_CC_4706_FLASHSCFG_1ST_MADDR_SEG_16MB	0x00000030	/* 16MB */
 
-+#define  BCMA_CC_4706_FLASHSCFG_1ST_MADDR_SEG_32MB	0x00000040	/* 32MB */
 
-+#define  BCMA_CC_4706_FLASHSCFG_1ST_MADDR_SEG_64MB	0x00000050	/* 64MB */
 
-+#define  BCMA_CC_4706_FLASHSCFG_1ST_MADDR_SEG_128MB	0x00000060	/* 128MB */
 
-+#define  BCMA_CC_4706_FLASHSCFG_1ST_MADDR_SEG_256MB	0x00000070	/* 256MB */
 
-+/* NAND flash registers for BCM4706 (corerev = 31) */
 
-+#define BCMA_CC_NFLASH_CTL		0x01A0
 
-+#define  BCMA_CC_NFLASH_CTL_ERR		0x08000000
 
-+#define BCMA_CC_NFLASH_CONF		0x01A4
 
-+#define BCMA_CC_NFLASH_COL_ADDR		0x01A8
 
-+#define BCMA_CC_NFLASH_ROW_ADDR		0x01AC
 
-+#define BCMA_CC_NFLASH_DATA		0x01B0
 
-+#define BCMA_CC_NFLASH_WAITCNT0		0x01B4
 
- /* 0x1E0 is defined as shared BCMA_CLKCTLST */
 
- #define BCMA_CC_HW_WORKAROUND		0x01E4 /* Hardware workaround (rev >= 20) */
 
- #define BCMA_CC_UART0_DATA		0x0300
 
-@@ -203,6 +316,9 @@
 
- #define BCMA_CC_PMU_CTL			0x0600 /* PMU control */
 
- #define  BCMA_CC_PMU_CTL_ILP_DIV	0xFFFF0000 /* ILP div mask */
 
- #define  BCMA_CC_PMU_CTL_ILP_DIV_SHIFT	16
 
-+#define  BCMA_CC_PMU_CTL_RES		0x00006000 /* reset control mask */
 
-+#define  BCMA_CC_PMU_CTL_RES_SHIFT	13
 
-+#define  BCMA_CC_PMU_CTL_RES_RELOAD	0x2	/* reload POR values */
 
- #define  BCMA_CC_PMU_CTL_PLL_UPD	0x00000400
 
- #define  BCMA_CC_PMU_CTL_NOILPONW	0x00000200 /* No ILP on wait */
 
- #define  BCMA_CC_PMU_CTL_HTREQEN	0x00000100 /* HT req enable */
 
-@@ -214,6 +330,8 @@
 
- #define BCMA_CC_PMU_CAP			0x0604 /* PMU capabilities */
 
- #define  BCMA_CC_PMU_CAP_REVISION	0x000000FF /* Revision mask */
 
- #define BCMA_CC_PMU_STAT		0x0608 /* PMU status */
 
-+#define  BCMA_CC_PMU_STAT_EXT_LPO_AVAIL	0x00000100
 
-+#define  BCMA_CC_PMU_STAT_WDRESET	0x00000080
 
- #define  BCMA_CC_PMU_STAT_INTPEND	0x00000040 /* Interrupt pending */
 
- #define  BCMA_CC_PMU_STAT_SBCLKST	0x00000030 /* Backplane clock status? */
 
- #define  BCMA_CC_PMU_STAT_HAVEALP	0x00000008 /* ALP available */
 
-@@ -239,8 +357,66 @@
 
- #define BCMA_CC_REGCTL_DATA		0x065C
 
- #define BCMA_CC_PLLCTL_ADDR		0x0660
 
- #define BCMA_CC_PLLCTL_DATA		0x0664
 
-+#define BCMA_CC_PMU_STRAPOPT		0x0668 /* (corerev >= 28) */
 
-+#define BCMA_CC_PMU_XTAL_FREQ		0x066C /* (pmurev >= 10) */
 
-+#define  BCMA_CC_PMU_XTAL_FREQ_ILPCTL_MASK	0x00001FFF
 
-+#define  BCMA_CC_PMU_XTAL_FREQ_MEASURE_MASK	0x80000000
 
-+#define  BCMA_CC_PMU_XTAL_FREQ_MEASURE_SHIFT	31
 
- #define BCMA_CC_SPROM			0x0800 /* SPROM beginning */
 
--#define BCMA_CC_SPROM_PCIE6		0x0830 /* SPROM beginning on PCIe rev >= 6 */
 
-+/* NAND flash MLC controller registers (corerev >= 38) */
 
-+#define BCMA_CC_NAND_REVISION		0x0C00
 
-+#define BCMA_CC_NAND_CMD_START		0x0C04
 
-+#define BCMA_CC_NAND_CMD_ADDR_X		0x0C08
 
-+#define BCMA_CC_NAND_CMD_ADDR		0x0C0C
 
-+#define BCMA_CC_NAND_CMD_END_ADDR	0x0C10
 
-+#define BCMA_CC_NAND_CS_NAND_SELECT	0x0C14
 
-+#define BCMA_CC_NAND_CS_NAND_XOR	0x0C18
 
-+#define BCMA_CC_NAND_SPARE_RD0		0x0C20
 
-+#define BCMA_CC_NAND_SPARE_RD4		0x0C24
 
-+#define BCMA_CC_NAND_SPARE_RD8		0x0C28
 
-+#define BCMA_CC_NAND_SPARE_RD12		0x0C2C
 
-+#define BCMA_CC_NAND_SPARE_WR0		0x0C30
 
-+#define BCMA_CC_NAND_SPARE_WR4		0x0C34
 
-+#define BCMA_CC_NAND_SPARE_WR8		0x0C38
 
-+#define BCMA_CC_NAND_SPARE_WR12		0x0C3C
 
-+#define BCMA_CC_NAND_ACC_CONTROL	0x0C40
 
-+#define BCMA_CC_NAND_CONFIG		0x0C48
 
-+#define BCMA_CC_NAND_TIMING_1		0x0C50
 
-+#define BCMA_CC_NAND_TIMING_2		0x0C54
 
-+#define BCMA_CC_NAND_SEMAPHORE		0x0C58
 
-+#define BCMA_CC_NAND_DEVID		0x0C60
 
-+#define BCMA_CC_NAND_DEVID_X		0x0C64
 
-+#define BCMA_CC_NAND_BLOCK_LOCK_STATUS	0x0C68
 
-+#define BCMA_CC_NAND_INTFC_STATUS	0x0C6C
 
-+#define BCMA_CC_NAND_ECC_CORR_ADDR_X	0x0C70
 
-+#define BCMA_CC_NAND_ECC_CORR_ADDR	0x0C74
 
-+#define BCMA_CC_NAND_ECC_UNC_ADDR_X	0x0C78
 
-+#define BCMA_CC_NAND_ECC_UNC_ADDR	0x0C7C
 
-+#define BCMA_CC_NAND_READ_ERROR_COUNT	0x0C80
 
-+#define BCMA_CC_NAND_CORR_STAT_THRESHOLD	0x0C84
 
-+#define BCMA_CC_NAND_READ_ADDR_X	0x0C90
 
-+#define BCMA_CC_NAND_READ_ADDR		0x0C94
 
-+#define BCMA_CC_NAND_PAGE_PROGRAM_ADDR_X	0x0C98
 
-+#define BCMA_CC_NAND_PAGE_PROGRAM_ADDR	0x0C9C
 
-+#define BCMA_CC_NAND_COPY_BACK_ADDR_X	0x0CA0
 
-+#define BCMA_CC_NAND_COPY_BACK_ADDR	0x0CA4
 
-+#define BCMA_CC_NAND_BLOCK_ERASE_ADDR_X	0x0CA8
 
-+#define BCMA_CC_NAND_BLOCK_ERASE_ADDR	0x0CAC
 
-+#define BCMA_CC_NAND_INV_READ_ADDR_X	0x0CB0
 
-+#define BCMA_CC_NAND_INV_READ_ADDR	0x0CB4
 
-+#define BCMA_CC_NAND_BLK_WR_PROTECT	0x0CC0
 
-+#define BCMA_CC_NAND_ACC_CONTROL_CS1	0x0CD0
 
-+#define BCMA_CC_NAND_CONFIG_CS1		0x0CD4
 
-+#define BCMA_CC_NAND_TIMING_1_CS1	0x0CD8
 
-+#define BCMA_CC_NAND_TIMING_2_CS1	0x0CDC
 
-+#define BCMA_CC_NAND_SPARE_RD16		0x0D30
 
-+#define BCMA_CC_NAND_SPARE_RD20		0x0D34
 
-+#define BCMA_CC_NAND_SPARE_RD24		0x0D38
 
-+#define BCMA_CC_NAND_SPARE_RD28		0x0D3C
 
-+#define BCMA_CC_NAND_CACHE_ADDR		0x0D40
 
-+#define BCMA_CC_NAND_CACHE_DATA		0x0D44
 
-+#define BCMA_CC_NAND_CTRL_CONFIG	0x0D48
 
-+#define BCMA_CC_NAND_CTRL_STATUS	0x0D4C
 
- 
- /* Divider allocation in 4716/47162/5356 */
 
- #define BCMA_CC_PMU5_MAINPLL_CPU	1
 
-@@ -256,6 +432,32 @@
 
- 
- /* 4706 PMU */
 
- #define BCMA_CC_PMU4706_MAINPLL_PLL0	0
 
-+#define BCMA_CC_PMU6_4706_PROCPLL_OFF	4	/* The CPU PLL */
 
-+#define  BCMA_CC_PMU6_4706_PROC_P2DIV_MASK	0x000f0000
 
-+#define  BCMA_CC_PMU6_4706_PROC_P2DIV_SHIFT	16
 
-+#define  BCMA_CC_PMU6_4706_PROC_P1DIV_MASK	0x0000f000
 
-+#define  BCMA_CC_PMU6_4706_PROC_P1DIV_SHIFT	12
 
-+#define  BCMA_CC_PMU6_4706_PROC_NDIV_INT_MASK	0x00000ff8
 
-+#define  BCMA_CC_PMU6_4706_PROC_NDIV_INT_SHIFT	3
 
-+#define  BCMA_CC_PMU6_4706_PROC_NDIV_MODE_MASK	0x00000007
 
-+#define  BCMA_CC_PMU6_4706_PROC_NDIV_MODE_SHIFT	0
 
-+
 
-+/* PMU rev 15 */
 
-+#define BCMA_CC_PMU15_PLL_PLLCTL0	0
 
-+#define  BCMA_CC_PMU15_PLL_PC0_CLKSEL_MASK	0x00000003
 
-+#define  BCMA_CC_PMU15_PLL_PC0_CLKSEL_SHIFT	0
 
-+#define  BCMA_CC_PMU15_PLL_PC0_FREQTGT_MASK	0x003FFFFC
 
-+#define  BCMA_CC_PMU15_PLL_PC0_FREQTGT_SHIFT	2
 
-+#define  BCMA_CC_PMU15_PLL_PC0_PRESCALE_MASK	0x00C00000
 
-+#define  BCMA_CC_PMU15_PLL_PC0_PRESCALE_SHIFT	22
 
-+#define  BCMA_CC_PMU15_PLL_PC0_KPCTRL_MASK	0x07000000
 
-+#define  BCMA_CC_PMU15_PLL_PC0_KPCTRL_SHIFT	24
 
-+#define  BCMA_CC_PMU15_PLL_PC0_FCNTCTRL_MASK	0x38000000
 
-+#define  BCMA_CC_PMU15_PLL_PC0_FCNTCTRL_SHIFT	27
 
-+#define  BCMA_CC_PMU15_PLL_PC0_FDCMODE_MASK	0x40000000
 
-+#define  BCMA_CC_PMU15_PLL_PC0_FDCMODE_SHIFT	30
 
-+#define  BCMA_CC_PMU15_PLL_PC0_CTRLBIAS_MASK	0x80000000
 
-+#define  BCMA_CC_PMU15_PLL_PC0_CTRLBIAS_SHIFT	31
 
- 
- /* ALP clock on pre-PMU chips */
 
- #define BCMA_CC_PMU_ALP_CLOCK		20000000
 
-@@ -284,6 +486,19 @@
 
- #define BCMA_CC_PPL_PCHI_OFF		5
 
- #define BCMA_CC_PPL_PCHI_MASK		0x0000003f
 
- 
-+#define BCMA_CC_PMU_PLL_CTL0		0
 
-+#define BCMA_CC_PMU_PLL_CTL1		1
 
-+#define BCMA_CC_PMU_PLL_CTL2		2
 
-+#define BCMA_CC_PMU_PLL_CTL3		3
 
-+#define BCMA_CC_PMU_PLL_CTL4		4
 
-+#define BCMA_CC_PMU_PLL_CTL5		5
 
-+
 
-+#define BCMA_CC_PMU1_PLL0_PC0_P1DIV_MASK	0x00f00000
 
-+#define BCMA_CC_PMU1_PLL0_PC0_P1DIV_SHIFT	20
 
-+
 
-+#define BCMA_CC_PMU1_PLL0_PC2_NDIV_INT_MASK	0x1ff00000
 
-+#define BCMA_CC_PMU1_PLL0_PC2_NDIV_INT_SHIFT	20
 
-+
 
- /* BCM4331 ChipControl numbers. */
 
- #define BCMA_CHIPCTL_4331_BT_COEXIST		BIT(0)	/* 0 disable */
 
- #define BCMA_CHIPCTL_4331_SECI			BIT(1)	/* 0 SECI is disabled (JATG functional) */
 
-@@ -297,9 +512,56 @@
 
- #define BCMA_CHIPCTL_4331_OVR_PIPEAUXPWRDOWN	BIT(9)	/* override core control on pipe_AuxPowerDown */
 
- #define BCMA_CHIPCTL_4331_PCIE_AUXCLKEN		BIT(10)	/* pcie_auxclkenable */
 
- #define BCMA_CHIPCTL_4331_PCIE_PIPE_PLLDOWN	BIT(11)	/* pcie_pipe_pllpowerdown */
 
-+#define BCMA_CHIPCTL_4331_EXTPA_EN2		BIT(12)	/* 0 ext pa disable, 1 ext pa enabled */
 
- #define BCMA_CHIPCTL_4331_BT_SHD0_ON_GPIO4	BIT(16)	/* enable bt_shd0 at gpio4 */
 
- #define BCMA_CHIPCTL_4331_BT_SHD1_ON_GPIO5	BIT(17)	/* enable bt_shd1 at gpio5 */
 
- 
-+/* 43224 chip-specific ChipControl register bits */
 
-+#define BCMA_CCTRL_43224_GPIO_TOGGLE		0x8000		/* gpio[3:0] pins as btcoex or s/w gpio */
 
-+#define BCMA_CCTRL_43224A0_12MA_LED_DRIVE	0x00F000F0	/* 12 mA drive strength */
 
-+#define BCMA_CCTRL_43224B0_12MA_LED_DRIVE	0xF0		/* 12 mA drive strength for later 43224s */
 
-+
 
-+/* 4313 Chip specific ChipControl register bits */
 
-+#define BCMA_CCTRL_4313_12MA_LED_DRIVE		0x00000007	/* 12 mA drive strengh for later 4313 */
 
-+
 
-+/* BCM5357 ChipControl register bits */
 
-+#define BCMA_CHIPCTL_5357_EXTPA			BIT(14)
 
-+#define BCMA_CHIPCTL_5357_ANT_MUX_2O3		BIT(15)
 
-+#define BCMA_CHIPCTL_5357_NFLASH		BIT(16)
 
-+#define BCMA_CHIPCTL_5357_I2S_PINS_ENABLE	BIT(18)
 
-+#define BCMA_CHIPCTL_5357_I2CSPI_PINS_ENABLE	BIT(19)
 
-+
 
-+#define BCMA_RES_4314_LPLDO_PU			BIT(0)
 
-+#define BCMA_RES_4314_PMU_SLEEP_DIS		BIT(1)
 
-+#define BCMA_RES_4314_PMU_BG_PU			BIT(2)
 
-+#define BCMA_RES_4314_CBUCK_LPOM_PU		BIT(3)
 
-+#define BCMA_RES_4314_CBUCK_PFM_PU		BIT(4)
 
-+#define BCMA_RES_4314_CLDO_PU			BIT(5)
 
-+#define BCMA_RES_4314_LPLDO2_LVM		BIT(6)
 
-+#define BCMA_RES_4314_WL_PMU_PU			BIT(7)
 
-+#define BCMA_RES_4314_LNLDO_PU			BIT(8)
 
-+#define BCMA_RES_4314_LDO3P3_PU			BIT(9)
 
-+#define BCMA_RES_4314_OTP_PU			BIT(10)
 
-+#define BCMA_RES_4314_XTAL_PU			BIT(11)
 
-+#define BCMA_RES_4314_WL_PWRSW_PU		BIT(12)
 
-+#define BCMA_RES_4314_LQ_AVAIL			BIT(13)
 
-+#define BCMA_RES_4314_LOGIC_RET			BIT(14)
 
-+#define BCMA_RES_4314_MEM_SLEEP			BIT(15)
 
-+#define BCMA_RES_4314_MACPHY_RET		BIT(16)
 
-+#define BCMA_RES_4314_WL_CORE_READY		BIT(17)
 
-+#define BCMA_RES_4314_ILP_REQ			BIT(18)
 
-+#define BCMA_RES_4314_ALP_AVAIL			BIT(19)
 
-+#define BCMA_RES_4314_MISC_PWRSW_PU		BIT(20)
 
-+#define BCMA_RES_4314_SYNTH_PWRSW_PU		BIT(21)
 
-+#define BCMA_RES_4314_RX_PWRSW_PU		BIT(22)
 
-+#define BCMA_RES_4314_RADIO_PU			BIT(23)
 
-+#define BCMA_RES_4314_VCO_LDO_PU		BIT(24)
 
-+#define BCMA_RES_4314_AFE_LDO_PU		BIT(25)
 
-+#define BCMA_RES_4314_RX_LDO_PU			BIT(26)
 
-+#define BCMA_RES_4314_TX_LDO_PU			BIT(27)
 
-+#define BCMA_RES_4314_HT_AVAIL			BIT(28)
 
-+#define BCMA_RES_4314_MACPHY_CLK_AVAIL		BIT(29)
 
-+
 
- /* Data for the PMU, if available.
 
-  * Check availability with ((struct bcma_chipcommon)->capabilities & BCMA_CC_CAP_PMU)
 
-  */
 
-@@ -310,11 +572,36 @@ struct bcma_chipcommon_pmu {
 
- 
- #ifdef CONFIG_BCMA_DRIVER_MIPS
 
- struct bcma_pflash {
 
-+	bool present;
 
- 	u8 buswidth;
 
- 	u32 window;
 
- 	u32 window_size;
 
- };
 
- 
-+#ifdef CONFIG_BCMA_SFLASH
 
-+struct bcma_sflash {
 
-+	bool present;
 
-+	u32 window;
 
-+	u32 blocksize;
 
-+	u16 numblocks;
 
-+	u32 size;
 
-+
 
-+	struct mtd_info *mtd;
 
-+	void *priv;
 
-+};
 
-+#endif
 
-+
 
-+#ifdef CONFIG_BCMA_NFLASH
 
-+struct mtd_info;
 
-+
 
-+struct bcma_nflash {
 
-+	bool present;
 
-+	bool boot;		/* This is the flash the SoC boots from */
 
-+
 
-+	struct mtd_info *mtd;
 
-+};
 
-+#endif
 
-+
 
- struct bcma_serial_port {
 
- 	void *regs;
 
- 	unsigned long clockspeed;
 
-@@ -330,15 +617,30 @@ struct bcma_drv_cc {
 
- 	u32 capabilities;
 
- 	u32 capabilities_ext;
 
- 	u8 setup_done:1;
 
-+	u8 early_setup_done:1;
 
- 	/* Fast Powerup Delay constant */
 
- 	u16 fast_pwrup_delay;
 
- 	struct bcma_chipcommon_pmu pmu;
 
- #ifdef CONFIG_BCMA_DRIVER_MIPS
 
- 	struct bcma_pflash pflash;
 
-+#ifdef CONFIG_BCMA_SFLASH
 
-+	struct bcma_sflash sflash;
 
-+#endif
 
-+#ifdef CONFIG_BCMA_NFLASH
 
-+	struct bcma_nflash nflash;
 
-+#endif
 
- 
- 	int nr_serial_ports;
 
- 	struct bcma_serial_port serial_ports[4];
 
- #endif /* CONFIG_BCMA_DRIVER_MIPS */
 
-+	u32 ticks_per_ms;
 
-+	struct platform_device *watchdog;
 
-+
 
-+	/* Lock for GPIO register access. */
 
-+	spinlock_t gpio_lock;
 
-+#ifdef CONFIG_BCMA_DRIVER_GPIO
 
-+	struct gpio_chip gpio;
 
-+#endif
 
- };
 
- 
- /* Register access */
 
-@@ -355,14 +657,16 @@ struct bcma_drv_cc {
 
- 	bcma_cc_write32(cc, offset, (bcma_cc_read32(cc, offset) & (mask)) | (set))
 
- 
- extern void bcma_core_chipcommon_init(struct bcma_drv_cc *cc);
 
-+extern void bcma_core_chipcommon_early_init(struct bcma_drv_cc *cc);
 
- 
- extern void bcma_chipco_suspend(struct bcma_drv_cc *cc);
 
- extern void bcma_chipco_resume(struct bcma_drv_cc *cc);
 
- 
- void bcma_chipco_bcm4331_ext_pa_lines_ctl(struct bcma_drv_cc *cc, bool enable);
 
- 
--extern void bcma_chipco_watchdog_timer_set(struct bcma_drv_cc *cc,
 
--					  u32 ticks);
 
-+extern u32 bcma_chipco_watchdog_timer_set(struct bcma_drv_cc *cc, u32 ticks);
 
-+
 
-+extern u32 bcma_chipco_get_alp_clock(struct bcma_drv_cc *cc);
 
- 
- void bcma_chipco_irq_mask(struct bcma_drv_cc *cc, u32 mask, u32 value);
 
- 
-@@ -375,9 +679,12 @@ u32 bcma_chipco_gpio_outen(struct bcma_d
 
- u32 bcma_chipco_gpio_control(struct bcma_drv_cc *cc, u32 mask, u32 value);
 
- u32 bcma_chipco_gpio_intmask(struct bcma_drv_cc *cc, u32 mask, u32 value);
 
- u32 bcma_chipco_gpio_polarity(struct bcma_drv_cc *cc, u32 mask, u32 value);
 
-+u32 bcma_chipco_gpio_pullup(struct bcma_drv_cc *cc, u32 mask, u32 value);
 
-+u32 bcma_chipco_gpio_pulldown(struct bcma_drv_cc *cc, u32 mask, u32 value);
 
- 
- /* PMU support */
 
- extern void bcma_pmu_init(struct bcma_drv_cc *cc);
 
-+extern void bcma_pmu_early_init(struct bcma_drv_cc *cc);
 
- 
- extern void bcma_chipco_pll_write(struct bcma_drv_cc *cc, u32 offset,
 
- 				  u32 value);
 
-@@ -387,5 +694,8 @@ extern void bcma_chipco_chipctl_maskset(
 
- 					u32 offset, u32 mask, u32 set);
 
- extern void bcma_chipco_regctl_maskset(struct bcma_drv_cc *cc,
 
- 				       u32 offset, u32 mask, u32 set);
 
-+extern void bcma_pmu_spuravoid_pllupdate(struct bcma_drv_cc *cc, int spuravoid);
 
-+
 
-+extern u32 bcma_pmu_get_bus_clock(struct bcma_drv_cc *cc);
 
- 
- #endif /* LINUX_BCMA_DRIVER_CC_H_ */
 
---- /dev/null
 
-+++ b/include/linux/bcma/bcma_driver_gmac_cmn.h
 
-@@ -0,0 +1,100 @@
 
-+#ifndef LINUX_BCMA_DRIVER_GMAC_CMN_H_
 
-+#define LINUX_BCMA_DRIVER_GMAC_CMN_H_
 
-+
 
-+#include <linux/types.h>
 
-+
 
-+#define BCMA_GMAC_CMN_STAG0		0x000
 
-+#define BCMA_GMAC_CMN_STAG1		0x004
 
-+#define BCMA_GMAC_CMN_STAG2		0x008
 
-+#define BCMA_GMAC_CMN_STAG3		0x00C
 
-+#define BCMA_GMAC_CMN_PARSER_CTL	0x020
 
-+#define BCMA_GMAC_CMN_MIB_MAX_LEN	0x024
 
-+#define BCMA_GMAC_CMN_PHY_ACCESS	0x100
 
-+#define  BCMA_GMAC_CMN_PA_DATA_MASK	0x0000ffff
 
-+#define  BCMA_GMAC_CMN_PA_ADDR_MASK	0x001f0000
 
-+#define  BCMA_GMAC_CMN_PA_ADDR_SHIFT	16
 
-+#define  BCMA_GMAC_CMN_PA_REG_MASK	0x1f000000
 
-+#define  BCMA_GMAC_CMN_PA_REG_SHIFT	24
 
-+#define  BCMA_GMAC_CMN_PA_WRITE		0x20000000
 
-+#define  BCMA_GMAC_CMN_PA_START		0x40000000
 
-+#define BCMA_GMAC_CMN_PHY_CTL		0x104
 
-+#define  BCMA_GMAC_CMN_PC_EPA_MASK	0x0000001f
 
-+#define  BCMA_GMAC_CMN_PC_MCT_MASK	0x007f0000
 
-+#define  BCMA_GMAC_CMN_PC_MCT_SHIFT	16
 
-+#define  BCMA_GMAC_CMN_PC_MTE		0x00800000
 
-+#define BCMA_GMAC_CMN_GMAC0_RGMII_CTL	0x110
 
-+#define BCMA_GMAC_CMN_CFP_ACCESS	0x200
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_DATA0	0x210
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_DATA1	0x214
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_DATA2	0x218
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_DATA3	0x21C
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_DATA4	0x220
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_DATA5	0x224
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_DATA6	0x228
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_DATA7	0x22C
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_MASK0	0x230
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_MASK1	0x234
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_MASK2	0x238
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_MASK3	0x23C
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_MASK4	0x240
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_MASK5	0x244
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_MASK6	0x248
 
-+#define BCMA_GMAC_CMN_CFP_TCAM_MASK7	0x24C
 
-+#define BCMA_GMAC_CMN_CFP_ACTION_DATA	0x250
 
-+#define BCMA_GMAC_CMN_TCAM_BIST_CTL	0x2A0
 
-+#define BCMA_GMAC_CMN_TCAM_BIST_STATUS	0x2A4
 
-+#define BCMA_GMAC_CMN_TCAM_CMP_STATUS	0x2A8
 
-+#define BCMA_GMAC_CMN_TCAM_DISABLE	0x2AC
 
-+#define BCMA_GMAC_CMN_TCAM_TEST_CTL	0x2F0
 
-+#define BCMA_GMAC_CMN_UDF_0_A3_A0	0x300
 
-+#define BCMA_GMAC_CMN_UDF_0_A7_A4	0x304
 
-+#define BCMA_GMAC_CMN_UDF_0_A8		0x308
 
-+#define BCMA_GMAC_CMN_UDF_1_A3_A0	0x310
 
-+#define BCMA_GMAC_CMN_UDF_1_A7_A4	0x314
 
-+#define BCMA_GMAC_CMN_UDF_1_A8		0x318
 
-+#define BCMA_GMAC_CMN_UDF_2_A3_A0	0x320
 
-+#define BCMA_GMAC_CMN_UDF_2_A7_A4	0x324
 
-+#define BCMA_GMAC_CMN_UDF_2_A8		0x328
 
-+#define BCMA_GMAC_CMN_UDF_0_B3_B0	0x330
 
-+#define BCMA_GMAC_CMN_UDF_0_B7_B4	0x334
 
-+#define BCMA_GMAC_CMN_UDF_0_B8		0x338
 
-+#define BCMA_GMAC_CMN_UDF_1_B3_B0	0x340
 
-+#define BCMA_GMAC_CMN_UDF_1_B7_B4	0x344
 
-+#define BCMA_GMAC_CMN_UDF_1_B8		0x348
 
-+#define BCMA_GMAC_CMN_UDF_2_B3_B0	0x350
 
-+#define BCMA_GMAC_CMN_UDF_2_B7_B4	0x354
 
-+#define BCMA_GMAC_CMN_UDF_2_B8		0x358
 
-+#define BCMA_GMAC_CMN_UDF_0_C3_C0	0x360
 
-+#define BCMA_GMAC_CMN_UDF_0_C7_C4	0x364
 
-+#define BCMA_GMAC_CMN_UDF_0_C8		0x368
 
-+#define BCMA_GMAC_CMN_UDF_1_C3_C0	0x370
 
-+#define BCMA_GMAC_CMN_UDF_1_C7_C4	0x374
 
-+#define BCMA_GMAC_CMN_UDF_1_C8		0x378
 
-+#define BCMA_GMAC_CMN_UDF_2_C3_C0	0x380
 
-+#define BCMA_GMAC_CMN_UDF_2_C7_C4	0x384
 
-+#define BCMA_GMAC_CMN_UDF_2_C8		0x388
 
-+#define BCMA_GMAC_CMN_UDF_0_D3_D0	0x390
 
-+#define BCMA_GMAC_CMN_UDF_0_D7_D4	0x394
 
-+#define BCMA_GMAC_CMN_UDF_0_D11_D8	0x394
 
-+
 
-+struct bcma_drv_gmac_cmn {
 
-+	struct bcma_device *core;
 
-+
 
-+	/* Drivers accessing BCMA_GMAC_CMN_PHY_ACCESS and
 
-+	 * BCMA_GMAC_CMN_PHY_CTL need to take that mutex first. */
 
-+	struct mutex phy_mutex;
 
-+};
 
-+
 
-+/* Register access */
 
-+#define gmac_cmn_read16(gc, offset)		bcma_read16((gc)->core, offset)
 
-+#define gmac_cmn_read32(gc, offset)		bcma_read32((gc)->core, offset)
 
-+#define gmac_cmn_write16(gc, offset, val)	bcma_write16((gc)->core, offset, val)
 
-+#define gmac_cmn_write32(gc, offset, val)	bcma_write32((gc)->core, offset, val)
 
-+
 
-+#ifdef CONFIG_BCMA_DRIVER_GMAC_CMN
 
-+extern void __devinit bcma_core_gmac_cmn_init(struct bcma_drv_gmac_cmn *gc);
 
-+#else
 
-+static inline void bcma_core_gmac_cmn_init(struct bcma_drv_gmac_cmn *gc) { }
 
-+#endif
 
-+
 
-+#endif /* LINUX_BCMA_DRIVER_GMAC_CMN_H_ */
 
---- a/include/linux/bcma/bcma_driver_mips.h
 
-+++ b/include/linux/bcma/bcma_driver_mips.h
 
-@@ -28,6 +28,7 @@
 
- #define BCMA_MIPS_MIPS74K_GPIOEN	0x0048
 
- #define BCMA_MIPS_MIPS74K_CLKCTLST	0x01E0
 
- 
-+#define BCMA_MIPS_OOBSELINA74		0x004
 
- #define BCMA_MIPS_OOBSELOUTA30		0x100
 
- 
- struct bcma_device;
 
-@@ -35,17 +36,24 @@ struct bcma_device;
 
- struct bcma_drv_mips {
 
- 	struct bcma_device *core;
 
- 	u8 setup_done:1;
 
--	unsigned int assigned_irqs;
 
-+	u8 early_setup_done:1;
 
- };
 
- 
- #ifdef CONFIG_BCMA_DRIVER_MIPS
 
- extern void bcma_core_mips_init(struct bcma_drv_mips *mcore);
 
-+extern void bcma_core_mips_early_init(struct bcma_drv_mips *mcore);
 
-+
 
-+extern unsigned int bcma_core_irq(struct bcma_device *core);
 
- #else
 
- static inline void bcma_core_mips_init(struct bcma_drv_mips *mcore) { }
 
-+static inline void bcma_core_mips_early_init(struct bcma_drv_mips *mcore) { }
 
-+
 
-+static inline unsigned int bcma_core_irq(struct bcma_device *core)
 
-+{
 
-+	return 0;
 
-+}
 
- #endif
 
- 
- extern u32 bcma_cpu_clock(struct bcma_drv_mips *mcore);
 
- 
--extern unsigned int bcma_core_mips_irq(struct bcma_device *dev);
 
--
 
- #endif /* LINUX_BCMA_DRIVER_MIPS_H_ */
 
---- a/include/linux/bcma/bcma_driver_pci.h
 
-+++ b/include/linux/bcma/bcma_driver_pci.h
 
-@@ -53,11 +53,47 @@ struct pci_dev;
 
- #define  BCMA_CORE_PCI_SBTOPCI1_MASK		0xFC000000
 
- #define BCMA_CORE_PCI_SBTOPCI2			0x0108	/* Backplane to PCI translation 2 (sbtopci2) */
 
- #define  BCMA_CORE_PCI_SBTOPCI2_MASK		0xC0000000
 
-+#define BCMA_CORE_PCI_CONFIG_ADDR		0x0120	/* pcie config space access */
 
-+#define BCMA_CORE_PCI_CONFIG_DATA		0x0124	/* pcie config space access */
 
-+#define BCMA_CORE_PCI_MDIO_CONTROL		0x0128	/* controls the mdio access */
 
-+#define  BCMA_CORE_PCI_MDIOCTL_DIVISOR_MASK	0x7f	/* clock to be used on MDIO */
 
-+#define  BCMA_CORE_PCI_MDIOCTL_DIVISOR_VAL	0x2
 
-+#define  BCMA_CORE_PCI_MDIOCTL_PREAM_EN		0x80	/* Enable preamble sequnce */
 
-+#define  BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE	0x100	/* Tranaction complete */
 
-+#define BCMA_CORE_PCI_MDIO_DATA			0x012c	/* Data to the mdio access */
 
-+#define  BCMA_CORE_PCI_MDIODATA_MASK		0x0000ffff /* data 2 bytes */
 
-+#define  BCMA_CORE_PCI_MDIODATA_TA		0x00020000 /* Turnaround */
 
-+#define  BCMA_CORE_PCI_MDIODATA_REGADDR_SHF_OLD	18	/* Regaddr shift (rev < 10) */
 
-+#define  BCMA_CORE_PCI_MDIODATA_REGADDR_MASK_OLD	0x003c0000 /* Regaddr Mask (rev < 10) */
 
-+#define  BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF_OLD	22	/* Physmedia devaddr shift (rev < 10) */
 
-+#define  BCMA_CORE_PCI_MDIODATA_DEVADDR_MASK_OLD	0x0fc00000 /* Physmedia devaddr Mask (rev < 10) */
 
-+#define  BCMA_CORE_PCI_MDIODATA_REGADDR_SHF	18	/* Regaddr shift */
 
-+#define  BCMA_CORE_PCI_MDIODATA_REGADDR_MASK	0x007c0000 /* Regaddr Mask */
 
-+#define  BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF	23	/* Physmedia devaddr shift */
 
-+#define  BCMA_CORE_PCI_MDIODATA_DEVADDR_MASK	0x0f800000 /* Physmedia devaddr Mask */
 
-+#define  BCMA_CORE_PCI_MDIODATA_WRITE		0x10000000 /* write Transaction */
 
-+#define  BCMA_CORE_PCI_MDIODATA_READ		0x20000000 /* Read Transaction */
 
-+#define  BCMA_CORE_PCI_MDIODATA_START		0x40000000 /* start of Transaction */
 
-+#define  BCMA_CORE_PCI_MDIODATA_DEV_ADDR	0x0	/* dev address for serdes */
 
-+#define  BCMA_CORE_PCI_MDIODATA_BLK_ADDR	0x1F	/* blk address for serdes */
 
-+#define  BCMA_CORE_PCI_MDIODATA_DEV_PLL		0x1d	/* SERDES PLL Dev */
 
-+#define  BCMA_CORE_PCI_MDIODATA_DEV_TX		0x1e	/* SERDES TX Dev */
 
-+#define  BCMA_CORE_PCI_MDIODATA_DEV_RX		0x1f	/* SERDES RX Dev */
 
-+#define BCMA_CORE_PCI_PCIEIND_ADDR		0x0130	/* indirect access to the internal register */
 
-+#define BCMA_CORE_PCI_PCIEIND_DATA		0x0134	/* Data to/from the internal regsiter */
 
-+#define BCMA_CORE_PCI_CLKREQENCTRL		0x0138	/*  >= rev 6, Clkreq rdma control */
 
- #define BCMA_CORE_PCI_PCICFG0			0x0400	/* PCI config space 0 (rev >= 8) */
 
- #define BCMA_CORE_PCI_PCICFG1			0x0500	/* PCI config space 1 (rev >= 8) */
 
- #define BCMA_CORE_PCI_PCICFG2			0x0600	/* PCI config space 2 (rev >= 8) */
 
- #define BCMA_CORE_PCI_PCICFG3			0x0700	/* PCI config space 3 (rev >= 8) */
 
- #define BCMA_CORE_PCI_SPROM(wordoffset)		(0x0800 + ((wordoffset) * 2)) /* SPROM shadow area (72 bytes) */
 
-+#define  BCMA_CORE_PCI_SPROM_PI_OFFSET		0	/* first word */
 
-+#define   BCMA_CORE_PCI_SPROM_PI_MASK		0xf000	/* bit 15:12 */
 
-+#define   BCMA_CORE_PCI_SPROM_PI_SHIFT		12	/* bit 15:12 */
 
-+#define  BCMA_CORE_PCI_SPROM_MISC_CONFIG	5	/* word 5 */
 
-+#define   BCMA_CORE_PCI_SPROM_L23READY_EXIT_NOPERST	0x8000	/* bit 15 */
 
-+#define   BCMA_CORE_PCI_SPROM_CLKREQ_OFFSET_REV5	20	/* word 20 for srom rev <= 5 */
 
-+#define   BCMA_CORE_PCI_SPROM_CLKREQ_ENB	0x0800	/* bit 11 */
 
- 
- /* SBtoPCIx */
 
- #define BCMA_CORE_PCI_SBTOPCI_MEM		0x00000000
 
-@@ -72,20 +108,143 @@ struct pci_dev;
 
- #define  BCMA_CORE_PCI_SBTOPCI_RC_READL		0x00000010 /* Memory read line */
 
- #define  BCMA_CORE_PCI_SBTOPCI_RC_READM		0x00000020 /* Memory read multiple */
 
- 
-+/* PCIE protocol PHY diagnostic registers */
 
-+#define BCMA_CORE_PCI_PLP_MODEREG		0x200	/* Mode */
 
-+#define BCMA_CORE_PCI_PLP_STATUSREG		0x204	/* Status */
 
-+#define  BCMA_CORE_PCI_PLP_POLARITYINV_STAT	0x10	/* Status reg PCIE_PLP_STATUSREG */
 
-+#define BCMA_CORE_PCI_PLP_LTSSMCTRLREG		0x208	/* LTSSM control */
 
-+#define BCMA_CORE_PCI_PLP_LTLINKNUMREG		0x20c	/* Link Training Link number */
 
-+#define BCMA_CORE_PCI_PLP_LTLANENUMREG		0x210	/* Link Training Lane number */
 
-+#define BCMA_CORE_PCI_PLP_LTNFTSREG		0x214	/* Link Training N_FTS */
 
-+#define BCMA_CORE_PCI_PLP_ATTNREG		0x218	/* Attention */
 
-+#define BCMA_CORE_PCI_PLP_ATTNMASKREG		0x21C	/* Attention Mask */
 
-+#define BCMA_CORE_PCI_PLP_RXERRCTR		0x220	/* Rx Error */
 
-+#define BCMA_CORE_PCI_PLP_RXFRMERRCTR		0x224	/* Rx Framing Error */
 
-+#define BCMA_CORE_PCI_PLP_RXERRTHRESHREG	0x228	/* Rx Error threshold */
 
-+#define BCMA_CORE_PCI_PLP_TESTCTRLREG		0x22C	/* Test Control reg */
 
-+#define BCMA_CORE_PCI_PLP_SERDESCTRLOVRDREG	0x230	/* SERDES Control Override */
 
-+#define BCMA_CORE_PCI_PLP_TIMINGOVRDREG		0x234	/* Timing param override */
 
-+#define BCMA_CORE_PCI_PLP_RXTXSMDIAGREG		0x238	/* RXTX State Machine Diag */
 
-+#define BCMA_CORE_PCI_PLP_LTSSMDIAGREG		0x23C	/* LTSSM State Machine Diag */
 
-+
 
-+/* PCIE protocol DLLP diagnostic registers */
 
-+#define BCMA_CORE_PCI_DLLP_LCREG		0x100	/* Link Control */
 
-+#define BCMA_CORE_PCI_DLLP_LSREG		0x104	/* Link Status */
 
-+#define BCMA_CORE_PCI_DLLP_LAREG		0x108	/* Link Attention */
 
-+#define  BCMA_CORE_PCI_DLLP_LSREG_LINKUP	(1 << 16)
 
-+#define BCMA_CORE_PCI_DLLP_LAMASKREG		0x10C	/* Link Attention Mask */
 
-+#define BCMA_CORE_PCI_DLLP_NEXTTXSEQNUMREG	0x110	/* Next Tx Seq Num */
 
-+#define BCMA_CORE_PCI_DLLP_ACKEDTXSEQNUMREG	0x114	/* Acked Tx Seq Num */
 
-+#define BCMA_CORE_PCI_DLLP_PURGEDTXSEQNUMREG	0x118	/* Purged Tx Seq Num */
 
-+#define BCMA_CORE_PCI_DLLP_RXSEQNUMREG		0x11C	/* Rx Sequence Number */
 
-+#define BCMA_CORE_PCI_DLLP_LRREG		0x120	/* Link Replay */
 
-+#define BCMA_CORE_PCI_DLLP_LACKTOREG		0x124	/* Link Ack Timeout */
 
-+#define BCMA_CORE_PCI_DLLP_PMTHRESHREG		0x128	/* Power Management Threshold */
 
-+#define  BCMA_CORE_PCI_ASPMTIMER_EXTEND		0x01000000 /* > rev7: enable extend ASPM timer */
 
-+#define BCMA_CORE_PCI_DLLP_RTRYWPREG		0x12C	/* Retry buffer write ptr */
 
-+#define BCMA_CORE_PCI_DLLP_RTRYRPREG		0x130	/* Retry buffer Read ptr */
 
-+#define BCMA_CORE_PCI_DLLP_RTRYPPREG		0x134	/* Retry buffer Purged ptr */
 
-+#define BCMA_CORE_PCI_DLLP_RTRRWREG		0x138	/* Retry buffer Read/Write */
 
-+#define BCMA_CORE_PCI_DLLP_ECTHRESHREG		0x13C	/* Error Count Threshold */
 
-+#define BCMA_CORE_PCI_DLLP_TLPERRCTRREG		0x140	/* TLP Error Counter */
 
-+#define BCMA_CORE_PCI_DLLP_ERRCTRREG		0x144	/* Error Counter */
 
-+#define BCMA_CORE_PCI_DLLP_NAKRXCTRREG		0x148	/* NAK Received Counter */
 
-+#define BCMA_CORE_PCI_DLLP_TESTREG		0x14C	/* Test */
 
-+#define BCMA_CORE_PCI_DLLP_PKTBIST		0x150	/* Packet BIST */
 
-+#define BCMA_CORE_PCI_DLLP_PCIE11		0x154	/* DLLP PCIE 1.1 reg */
 
-+
 
-+/* SERDES RX registers */
 
-+#define BCMA_CORE_PCI_SERDES_RX_CTRL		1	/* Rx cntrl */
 
-+#define  BCMA_CORE_PCI_SERDES_RX_CTRL_FORCE	0x80	/* rxpolarity_force */
 
-+#define  BCMA_CORE_PCI_SERDES_RX_CTRL_POLARITY	0x40	/* rxpolarity_value */
 
-+#define BCMA_CORE_PCI_SERDES_RX_TIMER1		2	/* Rx Timer1 */
 
-+#define BCMA_CORE_PCI_SERDES_RX_CDR		6	/* CDR */
 
-+#define BCMA_CORE_PCI_SERDES_RX_CDRBW		7	/* CDR BW */
 
-+
 
-+/* SERDES PLL registers */
 
-+#define BCMA_CORE_PCI_SERDES_PLL_CTRL		1	/* PLL control reg */
 
-+#define BCMA_CORE_PCI_PLL_CTRL_FREQDET_EN	0x4000	/* bit 14 is FREQDET on */
 
-+
 
- /* PCIcore specific boardflags */
 
- #define BCMA_CORE_PCI_BFL_NOPCI			0x00000400 /* Board leaves PCI floating */
 
- 
-+/* PCIE Config space accessing MACROS */
 
-+#define BCMA_CORE_PCI_CFG_BUS_SHIFT		24	/* Bus shift */
 
-+#define BCMA_CORE_PCI_CFG_SLOT_SHIFT		19	/* Slot/Device shift */
 
-+#define BCMA_CORE_PCI_CFG_FUN_SHIFT		16	/* Function shift */
 
-+#define BCMA_CORE_PCI_CFG_OFF_SHIFT		0	/* Register shift */
 
-+
 
-+#define BCMA_CORE_PCI_CFG_BUS_MASK		0xff	/* Bus mask */
 
-+#define BCMA_CORE_PCI_CFG_SLOT_MASK		0x1f	/* Slot/Device mask */
 
-+#define BCMA_CORE_PCI_CFG_FUN_MASK		7	/* Function mask */
 
-+#define BCMA_CORE_PCI_CFG_OFF_MASK		0xfff	/* Register mask */
 
-+
 
-+#define BCMA_CORE_PCI_CFG_DEVCTRL		0xd8
 
-+
 
-+#define BCMA_CORE_PCI_
 
-+
 
-+/* MDIO devices (SERDES modules) */
 
-+#define BCMA_CORE_PCI_MDIO_IEEE0		0x000
 
-+#define BCMA_CORE_PCI_MDIO_IEEE1		0x001
 
-+#define BCMA_CORE_PCI_MDIO_BLK0			0x800
 
-+#define BCMA_CORE_PCI_MDIO_BLK1			0x801
 
-+#define  BCMA_CORE_PCI_MDIO_BLK1_MGMT0		0x16
 
-+#define  BCMA_CORE_PCI_MDIO_BLK1_MGMT1		0x17
 
-+#define  BCMA_CORE_PCI_MDIO_BLK1_MGMT2		0x18
 
-+#define  BCMA_CORE_PCI_MDIO_BLK1_MGMT3		0x19
 
-+#define  BCMA_CORE_PCI_MDIO_BLK1_MGMT4		0x1A
 
-+#define BCMA_CORE_PCI_MDIO_BLK2			0x802
 
-+#define BCMA_CORE_PCI_MDIO_BLK3			0x803
 
-+#define BCMA_CORE_PCI_MDIO_BLK4			0x804
 
-+#define BCMA_CORE_PCI_MDIO_TXPLL		0x808	/* TXPLL register block idx */
 
-+#define BCMA_CORE_PCI_MDIO_TXCTRL0		0x820
 
-+#define BCMA_CORE_PCI_MDIO_SERDESID		0x831
 
-+#define BCMA_CORE_PCI_MDIO_RXCTRL0		0x840
 
-+
 
-+/* PCIE Root Capability Register bits (Host mode only) */
 
-+#define BCMA_CORE_PCI_RC_CRS_VISIBILITY		0x0001
 
-+
 
-+struct bcma_drv_pci;
 
-+struct bcma_bus;
 
-+
 
-+#ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE
 
-+struct bcma_drv_pci_host {
 
-+	struct bcma_drv_pci *pdev;
 
-+
 
-+	u32 host_cfg_addr;
 
-+	spinlock_t cfgspace_lock;
 
-+
 
-+	struct pci_controller pci_controller;
 
-+	struct pci_ops pci_ops;
 
-+	struct resource mem_resource;
 
-+	struct resource io_resource;
 
-+};
 
-+#endif
 
-+
 
- struct bcma_drv_pci {
 
- 	struct bcma_device *core;
 
- 	u8 setup_done:1;
 
-+	u8 hostmode:1;
 
-+
 
-+#ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE
 
-+	struct bcma_drv_pci_host *host_controller;
 
-+#endif
 
- };
 
- 
- /* Register access */
 
-+#define pcicore_read16(pc, offset)		bcma_read16((pc)->core, offset)
 
- #define pcicore_read32(pc, offset)		bcma_read32((pc)->core, offset)
 
-+#define pcicore_write16(pc, offset, val)	bcma_write16((pc)->core, offset, val)
 
- #define pcicore_write32(pc, offset, val)	bcma_write32((pc)->core, offset, val)
 
- 
--extern void bcma_core_pci_init(struct bcma_drv_pci *pc);
 
-+extern void __devinit bcma_core_pci_init(struct bcma_drv_pci *pc);
 
- extern int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc,
 
- 				 struct bcma_device *core, bool enable);
 
-+extern void bcma_core_pci_up(struct bcma_bus *bus);
 
-+extern void bcma_core_pci_down(struct bcma_bus *bus);
 
-+extern void bcma_core_pci_power_save(struct bcma_bus *bus, bool up);
 
-+
 
-+extern int bcma_core_pci_pcibios_map_irq(const struct pci_dev *dev);
 
-+extern int bcma_core_pci_plat_dev_init(struct pci_dev *dev);
 
- 
- #endif /* LINUX_BCMA_DRIVER_PCI_H_ */
 
---- a/include/linux/bcma/bcma_regs.h
 
-+++ b/include/linux/bcma/bcma_regs.h
 
-@@ -11,11 +11,13 @@
 
- #define  BCMA_CLKCTLST_HAVEHTREQ	0x00000010 /* HT available request */
 
- #define  BCMA_CLKCTLST_HWCROFF		0x00000020 /* Force HW clock request off */
 
- #define  BCMA_CLKCTLST_EXTRESREQ	0x00000700 /* Mask of external resource requests */
 
-+#define  BCMA_CLKCTLST_EXTRESREQ_SHIFT	8
 
- #define  BCMA_CLKCTLST_HAVEALP		0x00010000 /* ALP available */
 
- #define  BCMA_CLKCTLST_HAVEHT		0x00020000 /* HT available */
 
- #define  BCMA_CLKCTLST_BP_ON_ALP	0x00040000 /* RO: running on ALP clock */
 
- #define  BCMA_CLKCTLST_BP_ON_HT		0x00080000 /* RO: running on HT clock */
 
- #define  BCMA_CLKCTLST_EXTRESST		0x07000000 /* Mask of external resource status */
 
-+#define  BCMA_CLKCTLST_EXTRESST_SHIFT	24
 
- /* Is there any BCM4328 on BCMA bus? */
 
- #define  BCMA_CLKCTLST_4328A0_HAVEHT	0x00010000 /* 4328a0 has reversed bits */
 
- #define  BCMA_CLKCTLST_4328A0_HAVEALP	0x00020000 /* 4328a0 has reversed bits */
 
-@@ -35,6 +37,7 @@
 
- #define  BCMA_IOST_BIST_DONE		0x8000
 
- #define BCMA_RESET_CTL			0x0800
 
- #define  BCMA_RESET_CTL_RESET		0x0001
 
-+#define BCMA_RESET_ST			0x0804
 
- 
- /* BCMA PCI config space registers. */
 
- #define BCMA_PCI_PMCSR			0x44
 
-@@ -56,4 +59,36 @@
 
- #define  BCMA_PCI_GPIO_XTAL		0x40	/* PCI config space GPIO 14 for Xtal powerup */
 
- #define  BCMA_PCI_GPIO_PLL		0x80	/* PCI config space GPIO 15 for PLL powerdown */
 
- 
-+/* SiliconBackplane Address Map.
 
-+ * All regions may not exist on all chips.
 
-+ */
 
-+#define BCMA_SOC_SDRAM_BASE		0x00000000U	/* Physical SDRAM */
 
-+#define BCMA_SOC_PCI_MEM		0x08000000U	/* Host Mode sb2pcitranslation0 (64 MB) */
 
-+#define BCMA_SOC_PCI_MEM_SZ		(64 * 1024 * 1024)
 
-+#define BCMA_SOC_PCI_CFG		0x0c000000U	/* Host Mode sb2pcitranslation1 (64 MB) */
 
-+#define BCMA_SOC_SDRAM_SWAPPED		0x10000000U	/* Byteswapped Physical SDRAM */
 
-+#define BCMA_SOC_SDRAM_R2		0x80000000U	/* Region 2 for sdram (512 MB) */
 
-+
 
-+
 
-+#define BCMA_SOC_PCI_DMA		0x40000000U	/* Client Mode sb2pcitranslation2 (1 GB) */
 
-+#define BCMA_SOC_PCI_DMA2		0x80000000U	/* Client Mode sb2pcitranslation2 (1 GB) */
 
-+#define BCMA_SOC_PCI_DMA_SZ		0x40000000U	/* Client Mode sb2pcitranslation2 size in bytes */
 
-+#define BCMA_SOC_PCIE_DMA_L32		0x00000000U	/* PCIE Client Mode sb2pcitranslation2
 
-+							 * (2 ZettaBytes), low 32 bits
 
-+							 */
 
-+#define BCMA_SOC_PCIE_DMA_H32		0x80000000U	/* PCIE Client Mode sb2pcitranslation2
 
-+							 * (2 ZettaBytes), high 32 bits
 
-+							 */
 
-+
 
-+#define BCMA_SOC_PCI1_MEM		0x40000000U	/* Host Mode sb2pcitranslation0 (64 MB) */
 
-+#define BCMA_SOC_PCI1_CFG		0x44000000U	/* Host Mode sb2pcitranslation1 (64 MB) */
 
-+#define BCMA_SOC_PCIE1_DMA_H32		0xc0000000U	/* PCIE Client Mode sb2pcitranslation2
 
-+							 * (2 ZettaBytes), high 32 bits
 
-+							 */
 
-+
 
-+#define BCMA_SOC_FLASH1			0x1fc00000	/* MIPS Flash Region 1 */
 
-+#define BCMA_SOC_FLASH1_SZ		0x00400000	/* MIPS Size of Flash Region 1 */
 
-+#define BCMA_SOC_FLASH2			0x1c000000	/* Flash Region 2 (region 1 shadowed here) */
 
-+#define BCMA_SOC_FLASH2_SZ		0x02000000	/* Size of Flash Region 2 */
 
-+
 
- #endif /* LINUX_BCMA_REGS_H_ */
 
---- a/drivers/net/wireless/b43/main.c
 
-+++ b/drivers/net/wireless/b43/main.c
 
-@@ -4618,7 +4618,7 @@ static int b43_wireless_core_init(struct
 
- 	switch (dev->dev->bus_type) {
 
- #ifdef CONFIG_B43_BCMA
 
- 	case B43_BUS_BCMA:
 
--		bcma_core_pci_irq_ctl(&dev->dev->bdev->bus->drv_pci,
 
-+		bcma_core_pci_irq_ctl(&dev->dev->bdev->bus->drv_pci[0],
 
- 				      dev->dev->bdev, true);
 
- 		break;
 
- #endif
 
---- a/drivers/net/wireless/brcm80211/brcmsmac/aiutils.c
 
-+++ b/drivers/net/wireless/brcm80211/brcmsmac/aiutils.c
 
-@@ -533,7 +533,7 @@ ai_buscore_setup(struct si_info *sii, st
 
- 
- 	/* fixup necessary chip/core configurations */
 
- 	if (!sii->pch) {
 
--		sii->pch = pcicore_init(&sii->pub, sii->icbus->drv_pci.core);
 
-+		sii->pch = pcicore_init(&sii->pub, sii->icbus->drv_pci[0].core);
 
- 		if (sii->pch == NULL)
 
- 			return false;
 
- 	}

+ 0 - 757
target/linux/generic/patches-3.3/040-Controlled-Delay-AQM.patch
View File 

@@ -1,757 +0,0 @@
 
-From a93fd80d261f1dc2788442dba8dd5701363d3d6e Mon Sep 17 00:00:00 2001
 
-From: Eric Dumazet <[email protected]>
 
-Date: Thu, 10 May 2012 07:51:25 +0000
 
-Subject: [PATCH] codel: Controlled Delay AQM
 
-
 
-commit 76e3cc126bb223013a6b9a0e2a51238d1ef2e409 upstream.
 
-
 
-An implementation of CoDel AQM, from Kathleen Nichols and Van Jacobson.
 
-
 
-http://queue.acm.org/detail.cfm?id=2209336
 
-
 
-This AQM main input is no longer queue size in bytes or packets, but the
 
-delay packets stay in (FIFO) queue.
 
-
 
-As we don't have infinite memory, we still can drop packets in enqueue()
 
-in case of massive load, but mean of CoDel is to drop packets in
 
-dequeue(), using a control law based on two simple parameters :
 
-
 
-target : target sojourn time (default 5ms)
 
-interval : width of moving time window (default 100ms)
 
-
 
-Based on initial work from Dave Taht.
 
-
 
-Refactored to help future codel inclusion as a plugin for other linux
 
-qdisc (FQ_CODEL, ...), like RED.
 
-
 
-include/net/codel.h contains codel algorithm as close as possible than
 
-Kathleen reference.
 
-
 
-net/sched/sch_codel.c contains the linux qdisc specific glue.
 
-
 
-Separate structures permit a memory efficient implementation of fq_codel
 
-(to be sent as a separate work) : Each flow has its own struct
 
-codel_vars.
 
-
 
-timestamps are taken at enqueue() time with 1024 ns precision, allowing
 
-a range of 2199 seconds in queue, and 100Gb links support. iproute2 uses
 
-usec as base unit.
 
-
 
-Selected packets are dropped, unless ECN is enabled and packets can get
 
-ECN mark instead.
 
-
 
-Tested from 2Mb to 10Gb speeds with no particular problems, on ixgbe and
 
-tg3 drivers (BQL enabled).
 
-
 
-Usage: tc qdisc ... codel [ limit PACKETS ] [ target TIME ]
 
-                          [ interval TIME ] [ ecn ]
 
-
 
-qdisc codel 10: parent 1:1 limit 2000p target 3.0ms interval 60.0ms ecn
 
- Sent 13347099587 bytes 8815805 pkt (dropped 0, overlimits 0 requeues 0)
 
- rate 202365Kbit 16708pps backlog 113550b 75p requeues 0
 
-  count 116 lastcount 98 ldelay 4.3ms dropping drop_next 816us
 
-  maxpacket 1514 ecn_mark 84399 drop_overlimit 0
 
-
 
-CoDel must be seen as a base module, and should be used keeping in mind
 
-there is still a FIFO queue. So a typical setup will probably need a
 
-hierarchy of several qdiscs and packet classifiers to be able to meet
 
-whatever constraints a user might have.
 
-
 
-One possible example would be to use fq_codel, which combines Fair
 
-Queueing and CoDel, in replacement of sfq / sfq_red.
 
-
 
-Signed-off-by: Eric Dumazet <[email protected]>
 
-Signed-off-by: Dave Taht <[email protected]>
 
-Cc: Kathleen Nichols <[email protected]>
 
-Cc: Van Jacobson <[email protected]>
 
-Cc: Tom Herbert <[email protected]>
 
-Cc: Matt Mathis <[email protected]>
 
-Cc: Yuchung Cheng <[email protected]>
 
-Cc: Stephen Hemminger <[email protected]>
 
-Signed-off-by: David S. Miller <[email protected]>
 
----
 
- include/linux/pkt_sched.h |   26 ++++
 
- include/net/codel.h       |  332 +++++++++++++++++++++++++++++++++++++++++++++
 
- net/sched/Kconfig         |   11 ++
 
- net/sched/Makefile        |    1 +
 
- net/sched/sch_codel.c     |  275 +++++++++++++++++++++++++++++++++++++
 
- 5 files changed, 645 insertions(+)
 
- create mode 100644 include/net/codel.h
 
- create mode 100644 net/sched/sch_codel.c
 
-
 
---- a/include/linux/pkt_sched.h
 
-+++ b/include/linux/pkt_sched.h
 
-@@ -633,4 +633,30 @@ struct tc_qfq_stats {
 
- 	__u32 lmax;
 
- };
 
- 
-+/* CODEL */
 
-+
 
-+enum {
 
-+	TCA_CODEL_UNSPEC,
 
-+	TCA_CODEL_TARGET,
 
-+	TCA_CODEL_LIMIT,
 
-+	TCA_CODEL_INTERVAL,
 
-+	TCA_CODEL_ECN,
 
-+	__TCA_CODEL_MAX
 
-+};
 
-+
 
-+#define TCA_CODEL_MAX	(__TCA_CODEL_MAX - 1)
 
-+
 
-+struct tc_codel_xstats {
 
-+	__u32	maxpacket; /* largest packet we've seen so far */
 
-+	__u32	count;	   /* how many drops we've done since the last time we
 
-+			    * entered dropping state
 
-+			    */
 
-+	__u32	lastcount; /* count at entry to dropping state */
 
-+	__u32	ldelay;    /* in-queue delay seen by most recently dequeued packet */
 
-+	__s32	drop_next; /* time to drop next packet */
 
-+	__u32	drop_overlimit; /* number of time max qdisc packet limit was hit */
 
-+	__u32	ecn_mark;  /* number of packets we ECN marked instead of dropped */
 
-+	__u32	dropping;  /* are we in dropping state ? */
 
-+};
 
-+
 
- #endif
 
---- /dev/null
 
-+++ b/include/net/codel.h
 
-@@ -0,0 +1,332 @@
 
-+#ifndef __NET_SCHED_CODEL_H
 
-+#define __NET_SCHED_CODEL_H
 
-+
 
-+/*
 
-+ * Codel - The Controlled-Delay Active Queue Management algorithm
 
-+ *
 
-+ *  Copyright (C) 2011-2012 Kathleen Nichols <[email protected]>
 
-+ *  Copyright (C) 2011-2012 Van Jacobson <[email protected]>
 
-+ *  Copyright (C) 2012 Michael D. Taht <[email protected]>
 
-+ *  Copyright (C) 2012 Eric Dumazet <[email protected]>
 
-+ *
 
-+ * Redistribution and use in source and binary forms, with or without
 
-+ * modification, are permitted provided that the following conditions
 
-+ * are met:
 
-+ * 1. Redistributions of source code must retain the above copyright
 
-+ *    notice, this list of conditions, and the following disclaimer,
 
-+ *    without modification.
 
-+ * 2. Redistributions in binary form must reproduce the above copyright
 
-+ *    notice, this list of conditions and the following disclaimer in the
 
-+ *    documentation and/or other materials provided with the distribution.
 
-+ * 3. The names of the authors may not be used to endorse or promote products
 
-+ *    derived from this software without specific prior written permission.
 
-+ *
 
-+ * Alternatively, provided that this notice is retained in full, this
 
-+ * software may be distributed under the terms of the GNU General
 
-+ * Public License ("GPL") version 2, in which case the provisions of the
 
-+ * GPL apply INSTEAD OF those given above.
 
-+ *
 
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
-+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
-+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
-+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
-+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
-+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
-+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
-+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
-+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
-+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
-+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 
-+ * DAMAGE.
 
-+ *
 
-+ */
 
-+
 
-+#include <linux/types.h>
 
-+#include <linux/ktime.h>
 
-+#include <linux/skbuff.h>
 
-+#include <net/pkt_sched.h>
 
-+#include <net/inet_ecn.h>
 
-+
 
-+/* Controlling Queue Delay (CoDel) algorithm
 
-+ * =========================================
 
-+ * Source : Kathleen Nichols and Van Jacobson
 
-+ * http://queue.acm.org/detail.cfm?id=2209336
 
-+ *
 
-+ * Implemented on linux by Dave Taht and Eric Dumazet
 
-+ */
 
-+
 
-+
 
-+/* CoDel uses a 1024 nsec clock, encoded in u32
 
-+ * This gives a range of 2199 seconds, because of signed compares
 
-+ */
 
-+typedef u32 codel_time_t;
 
-+typedef s32 codel_tdiff_t;
 
-+#define CODEL_SHIFT 10
 
-+#define MS2TIME(a) ((a * NSEC_PER_MSEC) >> CODEL_SHIFT)
 
-+
 
-+static inline codel_time_t codel_get_time(void)
 
-+{
 
-+	u64 ns = ktime_to_ns(ktime_get());
 
-+
 
-+	return ns >> CODEL_SHIFT;
 
-+}
 
-+
 
-+#define codel_time_after(a, b)		((s32)(a) - (s32)(b) > 0)
 
-+#define codel_time_after_eq(a, b)	((s32)(a) - (s32)(b) >= 0)
 
-+#define codel_time_before(a, b)		((s32)(a) - (s32)(b) < 0)
 
-+#define codel_time_before_eq(a, b)	((s32)(a) - (s32)(b) <= 0)
 
-+
 
-+/* Qdiscs using codel plugin must use codel_skb_cb in their own cb[] */
 
-+struct codel_skb_cb {
 
-+	codel_time_t enqueue_time;
 
-+};
 
-+
 
-+static struct codel_skb_cb *get_codel_cb(const struct sk_buff *skb)
 
-+{
 
-+	qdisc_cb_private_validate(skb, sizeof(struct codel_skb_cb));
 
-+	return (struct codel_skb_cb *)qdisc_skb_cb(skb)->data;
 
-+}
 
-+
 
-+static codel_time_t codel_get_enqueue_time(const struct sk_buff *skb)
 
-+{
 
-+	return get_codel_cb(skb)->enqueue_time;
 
-+}
 
-+
 
-+static void codel_set_enqueue_time(struct sk_buff *skb)
 
-+{
 
-+	get_codel_cb(skb)->enqueue_time = codel_get_time();
 
-+}
 
-+
 
-+static inline u32 codel_time_to_us(codel_time_t val)
 
-+{
 
-+	u64 valns = ((u64)val << CODEL_SHIFT);
 
-+
 
-+	do_div(valns, NSEC_PER_USEC);
 
-+	return (u32)valns;
 
-+}
 
-+
 
-+/**
 
-+ * struct codel_params - contains codel parameters
 
-+ * @target:	target queue size (in time units)
 
-+ * @interval:	width of moving time window
 
-+ * @ecn:	is Explicit Congestion Notification enabled
 
-+ */
 
-+struct codel_params {
 
-+	codel_time_t	target;
 
-+	codel_time_t	interval;
 
-+	bool		ecn;
 
-+};
 
-+
 
-+/**
 
-+ * struct codel_vars - contains codel variables
 
-+ * @count:		how many drops we've done since the last time we
 
-+ *			entered dropping state
 
-+ * @lastcount:		count at entry to dropping state
 
-+ * @dropping:		set to true if in dropping state
 
-+ * @first_above_time:	when we went (or will go) continuously above target
 
-+ *			for interval
 
-+ * @drop_next:		time to drop next packet, or when we dropped last
 
-+ * @ldelay:		sojourn time of last dequeued packet
 
-+ */
 
-+struct codel_vars {
 
-+	u32		count;
 
-+	u32		lastcount;
 
-+	bool		dropping;
 
-+	codel_time_t	first_above_time;
 
-+	codel_time_t	drop_next;
 
-+	codel_time_t	ldelay;
 
-+};
 
-+
 
-+/**
 
-+ * struct codel_stats - contains codel shared variables and stats
 
-+ * @maxpacket:	largest packet we've seen so far
 
-+ * @drop_count:	temp count of dropped packets in dequeue()
 
-+ * ecn_mark:	number of packets we ECN marked instead of dropping
 
-+ */
 
-+struct codel_stats {
 
-+	u32		maxpacket;
 
-+	u32		drop_count;
 
-+	u32		ecn_mark;
 
-+};
 
-+
 
-+static void codel_params_init(struct codel_params *params)
 
-+{
 
-+	params->interval = MS2TIME(100);
 
-+	params->target = MS2TIME(5);
 
-+	params->ecn = false;
 
-+}
 
-+
 
-+static void codel_vars_init(struct codel_vars *vars)
 
-+{
 
-+	vars->drop_next = 0;
 
-+	vars->first_above_time = 0;
 
-+	vars->dropping = false; /* exit dropping state */
 
-+	vars->count = 0;
 
-+	vars->lastcount = 0;
 
-+}
 
-+
 
-+static void codel_stats_init(struct codel_stats *stats)
 
-+{
 
-+	stats->maxpacket = 256;
 
-+}
 
-+
 
-+/* return interval/sqrt(x) with good precision
 
-+ * relies on int_sqrt(unsigned long x) kernel implementation
 
-+ */
 
-+static u32 codel_inv_sqrt(u32 _interval, u32 _x)
 
-+{
 
-+	u64 interval = _interval;
 
-+	unsigned long x = _x;
 
-+
 
-+	/* Scale operands for max precision */
 
-+
 
-+#if BITS_PER_LONG == 64
 
-+	x <<= 32; /* On 64bit arches, we can prescale x by 32bits */
 
-+	interval <<= 16;
 
-+#endif
 
-+
 
-+	while (x < (1UL << (BITS_PER_LONG - 2))) {
 
-+		x <<= 2;
 
-+		interval <<= 1;
 
-+	}
 
-+	do_div(interval, int_sqrt(x));
 
-+	return (u32)interval;
 
-+}
 
-+
 
-+static codel_time_t codel_control_law(codel_time_t t,
 
-+				      codel_time_t interval,
 
-+				      u32 count)
 
-+{
 
-+	return t + codel_inv_sqrt(interval, count);
 
-+}
 
-+
 
-+
 
-+static bool codel_should_drop(struct sk_buff *skb,
 
-+			      unsigned int *backlog,
 
-+			      struct codel_vars *vars,
 
-+			      struct codel_params *params,
 
-+			      struct codel_stats *stats,
 
-+			      codel_time_t now)
 
-+{
 
-+	bool ok_to_drop;
 
-+
 
-+	if (!skb) {
 
-+		vars->first_above_time = 0;
 
-+		return false;
 
-+	}
 
-+
 
-+	vars->ldelay = now - codel_get_enqueue_time(skb);
 
-+	*backlog -= qdisc_pkt_len(skb);
 
-+
 
-+	if (unlikely(qdisc_pkt_len(skb) > stats->maxpacket))
 
-+		stats->maxpacket = qdisc_pkt_len(skb);
 
-+
 
-+	if (codel_time_before(vars->ldelay, params->target) ||
 
-+	    *backlog <= stats->maxpacket) {
 
-+		/* went below - stay below for at least interval */
 
-+		vars->first_above_time = 0;
 
-+		return false;
 
-+	}
 
-+	ok_to_drop = false;
 
-+	if (vars->first_above_time == 0) {
 
-+		/* just went above from below. If we stay above
 
-+		 * for at least interval we'll say it's ok to drop
 
-+		 */
 
-+		vars->first_above_time = now + params->interval;
 
-+	} else if (codel_time_after(now, vars->first_above_time)) {
 
-+		ok_to_drop = true;
 
-+	}
 
-+	return ok_to_drop;
 
-+}
 
-+
 
-+typedef struct sk_buff * (*codel_skb_dequeue_t)(struct codel_vars *vars,
 
-+						struct Qdisc *sch);
 
-+
 
-+static struct sk_buff *codel_dequeue(struct Qdisc *sch,
 
-+				     struct codel_params *params,
 
-+				     struct codel_vars *vars,
 
-+				     struct codel_stats *stats,
 
-+				     codel_skb_dequeue_t dequeue_func,
 
-+				     u32 *backlog)
 
-+{
 
-+	struct sk_buff *skb = dequeue_func(vars, sch);
 
-+	codel_time_t now;
 
-+	bool drop;
 
-+
 
-+	if (!skb) {
 
-+		vars->dropping = false;
 
-+		return skb;
 
-+	}
 
-+	now = codel_get_time();
 
-+	drop = codel_should_drop(skb, backlog, vars, params, stats, now);
 
-+	if (vars->dropping) {
 
-+		if (!drop) {
 
-+			/* sojourn time below target - leave dropping state */
 
-+			vars->dropping = false;
 
-+		} else if (codel_time_after_eq(now, vars->drop_next)) {
 
-+			/* It's time for the next drop. Drop the current
 
-+			 * packet and dequeue the next. The dequeue might
 
-+			 * take us out of dropping state.
 
-+			 * If not, schedule the next drop.
 
-+			 * A large backlog might result in drop rates so high
 
-+			 * that the next drop should happen now,
 
-+			 * hence the while loop.
 
-+			 */
 
-+			while (vars->dropping &&
 
-+			       codel_time_after_eq(now, vars->drop_next)) {
 
-+				if (++vars->count == 0) /* avoid zero divides */
 
-+					vars->count = ~0U;
 
-+				if (params->ecn && INET_ECN_set_ce(skb)) {
 
-+					stats->ecn_mark++;
 
-+					vars->drop_next =
 
-+						codel_control_law(vars->drop_next,
 
-+								  params->interval,
 
-+								  vars->count);
 
-+					goto end;
 
-+				}
 
-+				qdisc_drop(skb, sch);
 
-+				stats->drop_count++;
 
-+				skb = dequeue_func(vars, sch);
 
-+				if (!codel_should_drop(skb, backlog,
 
-+						       vars, params, stats, now)) {
 
-+					/* leave dropping state */
 
-+					vars->dropping = false;
 
-+				} else {
 
-+					/* and schedule the next drop */
 
-+					vars->drop_next =
 
-+						codel_control_law(vars->drop_next,
 
-+								  params->interval,
 
-+								  vars->count);
 
-+				}
 
-+			}
 
-+		}
 
-+	} else if (drop) {
 
-+		if (params->ecn && INET_ECN_set_ce(skb)) {
 
-+			stats->ecn_mark++;
 
-+		} else {
 
-+			qdisc_drop(skb, sch);
 
-+			stats->drop_count++;
 
-+
 
-+			skb = dequeue_func(vars, sch);
 
-+			drop = codel_should_drop(skb, backlog, vars, params,
 
-+						 stats, now);
 
-+		}
 
-+		vars->dropping = true;
 
-+		/* if min went above target close to when we last went below it
 
-+		 * assume that the drop rate that controlled the queue on the
 
-+		 * last cycle is a good starting point to control it now.
 
-+		 */
 
-+		if (codel_time_before(now - vars->drop_next,
 
-+				      16 * params->interval)) {
 
-+			vars->count = (vars->count - vars->lastcount) | 1;
 
-+		} else {
 
-+			vars->count = 1;
 
-+		}
 
-+		vars->lastcount = vars->count;
 
-+		vars->drop_next = codel_control_law(now, params->interval,
 
-+						    vars->count);
 
-+	}
 
-+end:
 
-+	return skb;
 
-+}
 
-+#endif
 
---- a/net/sched/Kconfig
 
-+++ b/net/sched/Kconfig
 
-@@ -250,6 +250,17 @@ config NET_SCH_QFQ
 
- 
- 	  If unsure, say N.
 
- 
-+config NET_SCH_CODEL
 
-+	tristate "Controlled Delay AQM (CODEL)"
 
-+	help
 
-+	  Say Y here if you want to use the Controlled Delay (CODEL)
 
-+	  packet scheduling algorithm.
 
-+
 
-+	  To compile this driver as a module, choose M here: the module
 
-+	  will be called sch_codel.
 
-+
 
-+	  If unsure, say N.
 
-+
 
- config NET_SCH_INGRESS
 
- 	tristate "Ingress Qdisc"
 
- 	depends on NET_CLS_ACT
 
---- a/net/sched/Makefile
 
-+++ b/net/sched/Makefile
 
-@@ -36,6 +36,7 @@ obj-$(CONFIG_NET_SCH_DRR)	+= sch_drr.o
 
- obj-$(CONFIG_NET_SCH_MQPRIO)	+= sch_mqprio.o
 
- obj-$(CONFIG_NET_SCH_CHOKE)	+= sch_choke.o
 
- obj-$(CONFIG_NET_SCH_QFQ)	+= sch_qfq.o
 
-+obj-$(CONFIG_NET_SCH_CODEL)	+= sch_codel.o
 
- 
- obj-$(CONFIG_NET_CLS_U32)	+= cls_u32.o
 
- obj-$(CONFIG_NET_CLS_ROUTE4)	+= cls_route.o
 
---- /dev/null
 
-+++ b/net/sched/sch_codel.c
 
-@@ -0,0 +1,275 @@
 
-+/*
 
-+ * Codel - The Controlled-Delay Active Queue Management algorithm
 
-+ *
 
-+ *  Copyright (C) 2011-2012 Kathleen Nichols <[email protected]>
 
-+ *  Copyright (C) 2011-2012 Van Jacobson <[email protected]>
 
-+ *
 
-+ *  Implemented on linux by :
 
-+ *  Copyright (C) 2012 Michael D. Taht <[email protected]>
 
-+ *  Copyright (C) 2012 Eric Dumazet <[email protected]>
 
-+ *
 
-+ * Redistribution and use in source and binary forms, with or without
 
-+ * modification, are permitted provided that the following conditions
 
-+ * are met:
 
-+ * 1. Redistributions of source code must retain the above copyright
 
-+ *    notice, this list of conditions, and the following disclaimer,
 
-+ *    without modification.
 
-+ * 2. Redistributions in binary form must reproduce the above copyright
 
-+ *    notice, this list of conditions and the following disclaimer in the
 
-+ *    documentation and/or other materials provided with the distribution.
 
-+ * 3. The names of the authors may not be used to endorse or promote products
 
-+ *    derived from this software without specific prior written permission.
 
-+ *
 
-+ * Alternatively, provided that this notice is retained in full, this
 
-+ * software may be distributed under the terms of the GNU General
 
-+ * Public License ("GPL") version 2, in which case the provisions of the
 
-+ * GPL apply INSTEAD OF those given above.
 
-+ *
 
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
-+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
-+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
-+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
-+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
-+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
-+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
-+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
-+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
-+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
-+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 
-+ * DAMAGE.
 
-+ *
 
-+ */
 
-+
 
-+#include <linux/module.h>
 
-+#include <linux/slab.h>
 
-+#include <linux/types.h>
 
-+#include <linux/kernel.h>
 
-+#include <linux/errno.h>
 
-+#include <linux/skbuff.h>
 
-+#include <net/pkt_sched.h>
 
-+#include <net/codel.h>
 
-+
 
-+
 
-+#define DEFAULT_CODEL_LIMIT 1000
 
-+
 
-+struct codel_sched_data {
 
-+	struct codel_params	params;
 
-+	struct codel_vars	vars;
 
-+	struct codel_stats	stats;
 
-+	u32			drop_overlimit;
 
-+};
 
-+
 
-+/* This is the specific function called from codel_dequeue()
 
-+ * to dequeue a packet from queue. Note: backlog is handled in
 
-+ * codel, we dont need to reduce it here.
 
-+ */
 
-+static struct sk_buff *dequeue(struct codel_vars *vars, struct Qdisc *sch)
 
-+{
 
-+	struct sk_buff *skb = __skb_dequeue(&sch->q);
 
-+
 
-+	prefetch(&skb->end); /* we'll need skb_shinfo() */
 
-+	return skb;
 
-+}
 
-+
 
-+static struct sk_buff *codel_qdisc_dequeue(struct Qdisc *sch)
 
-+{
 
-+	struct codel_sched_data *q = qdisc_priv(sch);
 
-+	struct sk_buff *skb;
 
-+
 
-+	skb = codel_dequeue(sch, &q->params, &q->vars, &q->stats,
 
-+			    dequeue, &sch->qstats.backlog);
 
-+	/* We cant call qdisc_tree_decrease_qlen() if our qlen is 0,
 
-+	 * or HTB crashes. Defer it for next round.
 
-+	 */
 
-+	if (q->stats.drop_count && sch->q.qlen) {
 
-+		qdisc_tree_decrease_qlen(sch, q->stats.drop_count);
 
-+		q->stats.drop_count = 0;
 
-+	}
 
-+	if (skb)
 
-+		qdisc_bstats_update(sch, skb);
 
-+	return skb;
 
-+}
 
-+
 
-+static int codel_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 
-+{
 
-+	struct codel_sched_data *q;
 
-+
 
-+	if (likely(qdisc_qlen(sch) < sch->limit)) {
 
-+		codel_set_enqueue_time(skb);
 
-+		return qdisc_enqueue_tail(skb, sch);
 
-+	}
 
-+	q = qdisc_priv(sch);
 
-+	q->drop_overlimit++;
 
-+	return qdisc_drop(skb, sch);
 
-+}
 
-+
 
-+static const struct nla_policy codel_policy[TCA_CODEL_MAX + 1] = {
 
-+	[TCA_CODEL_TARGET]	= { .type = NLA_U32 },
 
-+	[TCA_CODEL_LIMIT]	= { .type = NLA_U32 },
 
-+	[TCA_CODEL_INTERVAL]	= { .type = NLA_U32 },
 
-+	[TCA_CODEL_ECN]		= { .type = NLA_U32 },
 
-+};
 
-+
 
-+static int codel_change(struct Qdisc *sch, struct nlattr *opt)
 
-+{
 
-+	struct codel_sched_data *q = qdisc_priv(sch);
 
-+	struct nlattr *tb[TCA_CODEL_MAX + 1];
 
-+	unsigned int qlen;
 
-+	int err;
 
-+
 
-+	if (!opt)
 
-+		return -EINVAL;
 
-+
 
-+	err = nla_parse_nested(tb, TCA_CODEL_MAX, opt, codel_policy);
 
-+	if (err < 0)
 
-+		return err;
 
-+
 
-+	sch_tree_lock(sch);
 
-+
 
-+	if (tb[TCA_CODEL_TARGET]) {
 
-+		u32 target = nla_get_u32(tb[TCA_CODEL_TARGET]);
 
-+
 
-+		q->params.target = ((u64)target * NSEC_PER_USEC) >> CODEL_SHIFT;
 
-+	}
 
-+
 
-+	if (tb[TCA_CODEL_INTERVAL]) {
 
-+		u32 interval = nla_get_u32(tb[TCA_CODEL_INTERVAL]);
 
-+
 
-+		q->params.interval = ((u64)interval * NSEC_PER_USEC) >> CODEL_SHIFT;
 
-+	}
 
-+
 
-+	if (tb[TCA_CODEL_LIMIT])
 
-+		sch->limit = nla_get_u32(tb[TCA_CODEL_LIMIT]);
 
-+
 
-+	if (tb[TCA_CODEL_ECN])
 
-+		q->params.ecn = !!nla_get_u32(tb[TCA_CODEL_ECN]);
 
-+
 
-+	qlen = sch->q.qlen;
 
-+	while (sch->q.qlen > sch->limit) {
 
-+		struct sk_buff *skb = __skb_dequeue(&sch->q);
 
-+
 
-+		sch->qstats.backlog -= qdisc_pkt_len(skb);
 
-+		qdisc_drop(skb, sch);
 
-+	}
 
-+	qdisc_tree_decrease_qlen(sch, qlen - sch->q.qlen);
 
-+
 
-+	sch_tree_unlock(sch);
 
-+	return 0;
 
-+}
 
-+
 
-+static int codel_init(struct Qdisc *sch, struct nlattr *opt)
 
-+{
 
-+	struct codel_sched_data *q = qdisc_priv(sch);
 
-+
 
-+	sch->limit = DEFAULT_CODEL_LIMIT;
 
-+
 
-+	codel_params_init(&q->params);
 
-+	codel_vars_init(&q->vars);
 
-+	codel_stats_init(&q->stats);
 
-+
 
-+	if (opt) {
 
-+		int err = codel_change(sch, opt);
 
-+
 
-+		if (err)
 
-+			return err;
 
-+	}
 
-+
 
-+	if (sch->limit >= 1)
 
-+		sch->flags |= TCQ_F_CAN_BYPASS;
 
-+	else
 
-+		sch->flags &= ~TCQ_F_CAN_BYPASS;
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static int codel_dump(struct Qdisc *sch, struct sk_buff *skb)
 
-+{
 
-+	struct codel_sched_data *q = qdisc_priv(sch);
 
-+	struct nlattr *opts;
 
-+
 
-+	opts = nla_nest_start(skb, TCA_OPTIONS);
 
-+	if (opts == NULL)
 
-+		goto nla_put_failure;
 
-+
 
-+	if (nla_put_u32(skb, TCA_CODEL_TARGET,
 
-+			codel_time_to_us(q->params.target)) ||
 
-+	    nla_put_u32(skb, TCA_CODEL_LIMIT,
 
-+			sch->limit) ||
 
-+	    nla_put_u32(skb, TCA_CODEL_INTERVAL,
 
-+			codel_time_to_us(q->params.interval)) ||
 
-+	    nla_put_u32(skb, TCA_CODEL_ECN,
 
-+			q->params.ecn))
 
-+		goto nla_put_failure;
 
-+
 
-+	return nla_nest_end(skb, opts);
 
-+
 
-+nla_put_failure:
 
-+	nla_nest_cancel(skb, opts);
 
-+	return -1;
 
-+}
 
-+
 
-+static int codel_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
 
-+{
 
-+	const struct codel_sched_data *q = qdisc_priv(sch);
 
-+	struct tc_codel_xstats st = {
 
-+		.maxpacket	= q->stats.maxpacket,
 
-+		.count		= q->vars.count,
 
-+		.lastcount	= q->vars.lastcount,
 
-+		.drop_overlimit = q->drop_overlimit,
 
-+		.ldelay		= codel_time_to_us(q->vars.ldelay),
 
-+		.dropping	= q->vars.dropping,
 
-+		.ecn_mark	= q->stats.ecn_mark,
 
-+	};
 
-+
 
-+	if (q->vars.dropping) {
 
-+		codel_tdiff_t delta = q->vars.drop_next - codel_get_time();
 
-+
 
-+		if (delta >= 0)
 
-+			st.drop_next = codel_time_to_us(delta);
 
-+		else
 
-+			st.drop_next = -codel_time_to_us(-delta);
 
-+	}
 
-+
 
-+	return gnet_stats_copy_app(d, &st, sizeof(st));
 
-+}
 
-+
 
-+static void codel_reset(struct Qdisc *sch)
 
-+{
 
-+	struct codel_sched_data *q = qdisc_priv(sch);
 
-+
 
-+	qdisc_reset_queue(sch);
 
-+	codel_vars_init(&q->vars);
 
-+}
 
-+
 
-+static struct Qdisc_ops codel_qdisc_ops __read_mostly = {
 
-+	.id		=	"codel",
 
-+	.priv_size	=	sizeof(struct codel_sched_data),
 
-+
 
-+	.enqueue	=	codel_qdisc_enqueue,
 
-+	.dequeue	=	codel_qdisc_dequeue,
 
-+	.peek		=	qdisc_peek_dequeued,
 
-+	.init		=	codel_init,
 
-+	.reset		=	codel_reset,
 
-+	.change 	=	codel_change,
 
-+	.dump		=	codel_dump,
 
-+	.dump_stats	=	codel_dump_stats,
 
-+	.owner		=	THIS_MODULE,
 
-+};
 
-+
 
-+static int __init codel_module_init(void)
 
-+{
 
-+	return register_qdisc(&codel_qdisc_ops);
 
-+}
 
-+
 
-+static void __exit codel_module_exit(void)
 
-+{
 
-+	unregister_qdisc(&codel_qdisc_ops);
 
-+}
 
-+
 
-+module_init(codel_module_init)
 
-+module_exit(codel_module_exit)
 
-+
 
-+MODULE_DESCRIPTION("Controlled Delay queue discipline");
 
-+MODULE_AUTHOR("Dave Taht");
 
-+MODULE_AUTHOR("Eric Dumazet");
 
-+MODULE_LICENSE("Dual BSD/GPL");

+ 0 - 185
target/linux/generic/patches-3.3/041-codel-use-Newton-method-instead-of-sqrt-and-divides.patch
View File 

@@ -1,185 +0,0 @@
 
-From 4a8056dfeef49b306ad6af24a5563d7d6867aae0 Mon Sep 17 00:00:00 2001
 
-From: Eric Dumazet <[email protected]>
 
-Date: Sat, 12 May 2012 03:32:13 +0000
 
-Subject: [PATCH] codel: use Newton method instead of sqrt() and divides
 
-
 
-commit 536edd67109df5e0cdb2c4ee759e9bade7976367 upstream.
 
-
 
-As Van pointed out, interval/sqrt(count) can be implemented using
 
-multiplies only.
 
-
 
-http://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Iterative_methods_for_reciprocal_square_roots
 
-
 
-This patch implements the Newton method and reciprocal divide.
 
-
 
-Total cost is 15 cycles instead of 120 on my Corei5 machine (64bit
 
-kernel).
 
-
 
-There is a small 'error' for count values < 5, but we don't really care.
 
-
 
-I reuse a hole in struct codel_vars :
 
- - pack the dropping boolean into one bit
 
- - use 31bit to store the reciprocal value of sqrt(count).
 
-
 
-Suggested-by: Van Jacobson <[email protected]>
 
-Signed-off-by: Eric Dumazet <[email protected]>
 
-Cc: Dave Taht <[email protected]>
 
-Cc: Kathleen Nichols <[email protected]>
 
-Cc: Tom Herbert <[email protected]>
 
-Cc: Matt Mathis <[email protected]>
 
-Cc: Yuchung Cheng <[email protected]>
 
-Cc: Nandita Dukkipati <[email protected]>
 
-Cc: Stephen Hemminger <[email protected]>
 
-Signed-off-by: David S. Miller <[email protected]>
 
----
 
- include/net/codel.h |   68 ++++++++++++++++++++++++++++-----------------------
 
- 1 file changed, 37 insertions(+), 31 deletions(-)
 
-
 
---- a/include/net/codel.h
 
-+++ b/include/net/codel.h
 
-@@ -46,6 +46,7 @@
 
- #include <linux/skbuff.h>
 
- #include <net/pkt_sched.h>
 
- #include <net/inet_ecn.h>
 
-+#include <linux/reciprocal_div.h>
 
- 
- /* Controlling Queue Delay (CoDel) algorithm
 
-  * =========================================
 
-@@ -123,6 +124,7 @@ struct codel_params {
 
-  *			entered dropping state
 
-  * @lastcount:		count at entry to dropping state
 
-  * @dropping:		set to true if in dropping state
 
-+ * @rec_inv_sqrt:	reciprocal value of sqrt(count) >> 1
 
-  * @first_above_time:	when we went (or will go) continuously above target
 
-  *			for interval
 
-  * @drop_next:		time to drop next packet, or when we dropped last
 
-@@ -131,7 +133,8 @@ struct codel_params {
 
- struct codel_vars {
 
- 	u32		count;
 
- 	u32		lastcount;
 
--	bool		dropping;
 
-+	bool		dropping:1;
 
-+	u32		rec_inv_sqrt:31;
 
- 	codel_time_t	first_above_time;
 
- 	codel_time_t	drop_next;
 
- 	codel_time_t	ldelay;
 
-@@ -158,11 +161,7 @@ static void codel_params_init(struct cod
 
- 
- static void codel_vars_init(struct codel_vars *vars)
 
- {
 
--	vars->drop_next = 0;
 
--	vars->first_above_time = 0;
 
--	vars->dropping = false; /* exit dropping state */
 
--	vars->count = 0;
 
--	vars->lastcount = 0;
 
-+	memset(vars, 0, sizeof(*vars));
 
- }
 
- 
- static void codel_stats_init(struct codel_stats *stats)
 
-@@ -170,38 +169,37 @@ static void codel_stats_init(struct code
 
- 	stats->maxpacket = 256;
 
- }
 
- 
--/* return interval/sqrt(x) with good precision
 
-- * relies on int_sqrt(unsigned long x) kernel implementation
 
-+/*
 
-+ * http://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Iterative_methods_for_reciprocal_square_roots
 
-+ * new_invsqrt = (invsqrt / 2) * (3 - count * invsqrt^2)
 
-+ *
 
-+ * Here, invsqrt is a fixed point number (< 1.0), 31bit mantissa)
 
-  */
 
--static u32 codel_inv_sqrt(u32 _interval, u32 _x)
 
-+static void codel_Newton_step(struct codel_vars *vars)
 
- {
 
--	u64 interval = _interval;
 
--	unsigned long x = _x;
 
--
 
--	/* Scale operands for max precision */
 
-+	u32 invsqrt = vars->rec_inv_sqrt;
 
-+	u32 invsqrt2 = ((u64)invsqrt * invsqrt) >> 31;
 
-+	u64 val = (3LL << 31) - ((u64)vars->count * invsqrt2);
 
- 
--#if BITS_PER_LONG == 64
 
--	x <<= 32; /* On 64bit arches, we can prescale x by 32bits */
 
--	interval <<= 16;
 
--#endif
 
-+	val = (val * invsqrt) >> 32;
 
- 
--	while (x < (1UL << (BITS_PER_LONG - 2))) {
 
--		x <<= 2;
 
--		interval <<= 1;
 
--	}
 
--	do_div(interval, int_sqrt(x));
 
--	return (u32)interval;
 
-+	vars->rec_inv_sqrt = val;
 
- }
 
- 
-+/*
 
-+ * CoDel control_law is t + interval/sqrt(count)
 
-+ * We maintain in rec_inv_sqrt the reciprocal value of sqrt(count) to avoid
 
-+ * both sqrt() and divide operation.
 
-+ */
 
- static codel_time_t codel_control_law(codel_time_t t,
 
- 				      codel_time_t interval,
 
--				      u32 count)
 
-+				      u32 rec_inv_sqrt)
 
- {
 
--	return t + codel_inv_sqrt(interval, count);
 
-+	return t + reciprocal_divide(interval, rec_inv_sqrt << 1);
 
- }
 
- 
- 
--static bool codel_should_drop(struct sk_buff *skb,
 
-+static bool codel_should_drop(const struct sk_buff *skb,
 
- 			      unsigned int *backlog,
 
- 			      struct codel_vars *vars,
 
- 			      struct codel_params *params,
 
-@@ -274,14 +272,16 @@ static struct sk_buff *codel_dequeue(str
 
- 			 */
 
- 			while (vars->dropping &&
 
- 			       codel_time_after_eq(now, vars->drop_next)) {
 
--				if (++vars->count == 0) /* avoid zero divides */
 
--					vars->count = ~0U;
 
-+				vars->count++; /* dont care of possible wrap
 
-+						* since there is no more divide
 
-+						*/
 
-+				codel_Newton_step(vars);
 
- 				if (params->ecn && INET_ECN_set_ce(skb)) {
 
- 					stats->ecn_mark++;
 
- 					vars->drop_next =
 
- 						codel_control_law(vars->drop_next,
 
- 								  params->interval,
 
--								  vars->count);
 
-+								  vars->rec_inv_sqrt);
 
- 					goto end;
 
- 				}
 
- 				qdisc_drop(skb, sch);
 
-@@ -296,7 +296,7 @@ static struct sk_buff *codel_dequeue(str
 
- 					vars->drop_next =
 
- 						codel_control_law(vars->drop_next,
 
- 								  params->interval,
 
--								  vars->count);
 
-+								  vars->rec_inv_sqrt);
 
- 				}
 
- 			}
 
- 		}
 
-@@ -319,12 +319,18 @@ static struct sk_buff *codel_dequeue(str
 
- 		if (codel_time_before(now - vars->drop_next,
 
- 				      16 * params->interval)) {
 
- 			vars->count = (vars->count - vars->lastcount) | 1;
 
-+			/* we dont care if rec_inv_sqrt approximation
 
-+			 * is not very precise :
 
-+			 * Next Newton steps will correct it quadratically.
 
-+			 */
 
-+			codel_Newton_step(vars);
 
- 		} else {
 
- 			vars->count = 1;
 
-+			vars->rec_inv_sqrt = 0x7fffffff;
 
- 		}
 
- 		vars->lastcount = vars->count;
 
- 		vars->drop_next = codel_control_law(now, params->interval,
 
--						    vars->count);
 
-+						    vars->rec_inv_sqrt);
 
- 	}
 
- end:
 
- 	return skb;

+ 0 - 839
target/linux/generic/patches-3.3/042-fq_codel-Fair-Queue-Codel-AQM.patch
View File 

@@ -1,839 +0,0 @@
 
-From f8cf19c19528a468cc0b9846c0328a94cccdc605 Mon Sep 17 00:00:00 2001
 
-From: Eric Dumazet <[email protected]>
 
-Date: Fri, 11 May 2012 09:30:50 +0000
 
-Subject: [PATCH] fq_codel: Fair Queue Codel AQM
 
-
 
-commit 4b549a2ef4bef9965d97cbd992ba67930cd3e0fe upstream.
 
-
 
-Fair Queue Codel packet scheduler
 
-
 
-Principles :
 
-
 
-- Packets are classified (internal classifier or external) on flows.
 
-- This is a Stochastic model (as we use a hash, several flows might
 
-                              be hashed on same slot)
 
-- Each flow has a CoDel managed queue.
 
-- Flows are linked onto two (Round Robin) lists,
 
-  so that new flows have priority on old ones.
 
-
 
-- For a given flow, packets are not reordered (CoDel uses a FIFO)
 
-- head drops only.
 
-- ECN capability is on by default.
 
-- Very low memory footprint (64 bytes per flow)
 
-
 
-tc qdisc ... fq_codel [ limit PACKETS ] [ flows number ]
 
-                      [ target TIME ] [ interval TIME ] [ noecn ]
 
-                      [ quantum BYTES ]
 
-
 
-defaults : 1024 flows, 10240 packets limit, quantum : device MTU
 
-           target : 5ms (CoDel default)
 
-           interval : 100ms (CoDel default)
 
-
 
-Impressive results on load :
 
-
 
-class htb 1:1 root leaf 10: prio 0 quantum 1514 rate 200000Kbit ceil 200000Kbit burst 1475b/8 mpu 0b overhead 0b cburst 1475b/8 mpu 0b overhead 0b level 0
 
- Sent 43304920109 bytes 33063109 pkt (dropped 0, overlimits 0 requeues 0)
 
- rate 201691Kbit 28595pps backlog 0b 312p requeues 0
 
- lended: 33063109 borrowed: 0 giants: 0
 
- tokens: -912 ctokens: -912
 
-
 
-class fq_codel 10:1735 parent 10:
 
- (dropped 1292, overlimits 0 requeues 0)
 
- backlog 15140b 10p requeues 0
 
-  deficit 1514 count 1 lastcount 1 ldelay 7.1ms
 
-class fq_codel 10:4524 parent 10:
 
- (dropped 1291, overlimits 0 requeues 0)
 
- backlog 16654b 11p requeues 0
 
-  deficit 1514 count 1 lastcount 1 ldelay 7.1ms
 
-class fq_codel 10:4e74 parent 10:
 
- (dropped 1290, overlimits 0 requeues 0)
 
- backlog 6056b 4p requeues 0
 
-  deficit 1514 count 1 lastcount 1 ldelay 6.4ms dropping drop_next 92.0ms
 
-class fq_codel 10:628a parent 10:
 
- (dropped 1289, overlimits 0 requeues 0)
 
- backlog 7570b 5p requeues 0
 
-  deficit 1514 count 1 lastcount 1 ldelay 5.4ms dropping drop_next 90.9ms
 
-class fq_codel 10:a4b3 parent 10:
 
- (dropped 302, overlimits 0 requeues 0)
 
- backlog 16654b 11p requeues 0
 
-  deficit 1514 count 1 lastcount 1 ldelay 7.1ms
 
-class fq_codel 10:c3c2 parent 10:
 
- (dropped 1284, overlimits 0 requeues 0)
 
- backlog 13626b 9p requeues 0
 
-  deficit 1514 count 1 lastcount 1 ldelay 5.9ms
 
-class fq_codel 10:d331 parent 10:
 
- (dropped 299, overlimits 0 requeues 0)
 
- backlog 15140b 10p requeues 0
 
-  deficit 1514 count 1 lastcount 1 ldelay 7.0ms
 
-class fq_codel 10:d526 parent 10:
 
- (dropped 12160, overlimits 0 requeues 0)
 
- backlog 35870b 211p requeues 0
 
-  deficit 1508 count 12160 lastcount 1 ldelay 15.3ms dropping drop_next 247us
 
-class fq_codel 10:e2c6 parent 10:
 
- (dropped 1288, overlimits 0 requeues 0)
 
- backlog 15140b 10p requeues 0
 
-  deficit 1514 count 1 lastcount 1 ldelay 7.1ms
 
-class fq_codel 10:eab5 parent 10:
 
- (dropped 1285, overlimits 0 requeues 0)
 
- backlog 16654b 11p requeues 0
 
-  deficit 1514 count 1 lastcount 1 ldelay 5.9ms
 
-class fq_codel 10:f220 parent 10:
 
- (dropped 1289, overlimits 0 requeues 0)
 
- backlog 15140b 10p requeues 0
 
-  deficit 1514 count 1 lastcount 1 ldelay 7.1ms
 
-
 
-qdisc htb 1: root refcnt 6 r2q 10 default 1 direct_packets_stat 0 ver 3.17
 
- Sent 43331086547 bytes 33092812 pkt (dropped 0, overlimits 66063544 requeues 71)
 
- rate 201697Kbit 28602pps backlog 0b 260p requeues 71
 
-qdisc fq_codel 10: parent 1:1 limit 10240p flows 65536 target 5.0ms interval 100.0ms ecn
 
- Sent 43331086547 bytes 33092812 pkt (dropped 949359, overlimits 0 requeues 0)
 
- rate 201697Kbit 28602pps backlog 189352b 260p requeues 0
 
-  maxpacket 1514 drop_overlimit 0 new_flow_count 5582 ecn_mark 125593
 
-  new_flows_len 0 old_flows_len 11
 
-
 
-PING 172.30.42.18 (172.30.42.18) 56(84) bytes of data.
 
-64 bytes from 172.30.42.18: icmp_req=1 ttl=64 time=0.227 ms
 
-64 bytes from 172.30.42.18: icmp_req=2 ttl=64 time=0.165 ms
 
-64 bytes from 172.30.42.18: icmp_req=3 ttl=64 time=0.166 ms
 
-64 bytes from 172.30.42.18: icmp_req=4 ttl=64 time=0.151 ms
 
-64 bytes from 172.30.42.18: icmp_req=5 ttl=64 time=0.164 ms
 
-64 bytes from 172.30.42.18: icmp_req=6 ttl=64 time=0.172 ms
 
-64 bytes from 172.30.42.18: icmp_req=7 ttl=64 time=0.175 ms
 
-64 bytes from 172.30.42.18: icmp_req=8 ttl=64 time=0.183 ms
 
-64 bytes from 172.30.42.18: icmp_req=9 ttl=64 time=0.158 ms
 
-64 bytes from 172.30.42.18: icmp_req=10 ttl=64 time=0.200 ms
 
-
 
-10 packets transmitted, 10 received, 0% packet loss, time 8999ms
 
-rtt min/avg/max/mdev = 0.151/0.176/0.227/0.022 ms
 
-
 
-Much better than SFQ because of priority given to new flows, and fast
 
-path dirtying less cache lines.
 
-
 
-Signed-off-by: Eric Dumazet <[email protected]>
 
-Signed-off-by: David S. Miller <[email protected]>
 
----
 
- include/linux/pkt_sched.h |   54 ++++
 
- net/sched/Kconfig         |   11 +
 
- net/sched/Makefile        |    1 +
 
- net/sched/sch_fq_codel.c  |  624 +++++++++++++++++++++++++++++++++++++++++++++
 
- 4 files changed, 690 insertions(+)
 
- create mode 100644 net/sched/sch_fq_codel.c
 
-
 
---- a/include/linux/pkt_sched.h
 
-+++ b/include/linux/pkt_sched.h
 
-@@ -659,4 +659,58 @@ struct tc_codel_xstats {
 
- 	__u32	dropping;  /* are we in dropping state ? */
 
- };
 
- 
-+/* FQ_CODEL */
 
-+
 
-+enum {
 
-+	TCA_FQ_CODEL_UNSPEC,
 
-+	TCA_FQ_CODEL_TARGET,
 
-+	TCA_FQ_CODEL_LIMIT,
 
-+	TCA_FQ_CODEL_INTERVAL,
 
-+	TCA_FQ_CODEL_ECN,
 
-+	TCA_FQ_CODEL_FLOWS,
 
-+	TCA_FQ_CODEL_QUANTUM,
 
-+	__TCA_FQ_CODEL_MAX
 
-+};
 
-+
 
-+#define TCA_FQ_CODEL_MAX	(__TCA_FQ_CODEL_MAX - 1)
 
-+
 
-+enum {
 
-+	TCA_FQ_CODEL_XSTATS_QDISC,
 
-+	TCA_FQ_CODEL_XSTATS_CLASS,
 
-+};
 
-+
 
-+struct tc_fq_codel_qd_stats {
 
-+	__u32	maxpacket;	/* largest packet we've seen so far */
 
-+	__u32	drop_overlimit; /* number of time max qdisc
 
-+				 * packet limit was hit
 
-+				 */
 
-+	__u32	ecn_mark;	/* number of packets we ECN marked
 
-+				 * instead of being dropped
 
-+				 */
 
-+	__u32	new_flow_count; /* number of time packets
 
-+				 * created a 'new flow'
 
-+				 */
 
-+	__u32	new_flows_len;	/* count of flows in new list */
 
-+	__u32	old_flows_len;	/* count of flows in old list */
 
-+};
 
-+
 
-+struct tc_fq_codel_cl_stats {
 
-+	__s32	deficit;
 
-+	__u32	ldelay;		/* in-queue delay seen by most recently
 
-+				 * dequeued packet
 
-+				 */
 
-+	__u32	count;
 
-+	__u32	lastcount;
 
-+	__u32	dropping;
 
-+	__s32	drop_next;
 
-+};
 
-+
 
-+struct tc_fq_codel_xstats {
 
-+	__u32	type;
 
-+	union {
 
-+		struct tc_fq_codel_qd_stats qdisc_stats;
 
-+		struct tc_fq_codel_cl_stats class_stats;
 
-+	};
 
-+};
 
-+
 
- #endif
 
---- a/net/sched/Kconfig
 
-+++ b/net/sched/Kconfig
 
-@@ -261,6 +261,17 @@ config NET_SCH_CODEL
 
- 
- 	  If unsure, say N.
 
- 
-+config NET_SCH_FQ_CODEL
 
-+	tristate "Fair Queue Controlled Delay AQM (FQ_CODEL)"
 
-+	help
 
-+	  Say Y here if you want to use the FQ Controlled Delay (FQ_CODEL)
 
-+	  packet scheduling algorithm.
 
-+
 
-+	  To compile this driver as a module, choose M here: the module
 
-+	  will be called sch_fq_codel.
 
-+
 
-+	  If unsure, say N.
 
-+
 
- config NET_SCH_INGRESS
 
- 	tristate "Ingress Qdisc"
 
- 	depends on NET_CLS_ACT
 
---- a/net/sched/Makefile
 
-+++ b/net/sched/Makefile
 
-@@ -37,6 +37,7 @@ obj-$(CONFIG_NET_SCH_MQPRIO)	+= sch_mqpr
 
- obj-$(CONFIG_NET_SCH_CHOKE)	+= sch_choke.o
 
- obj-$(CONFIG_NET_SCH_QFQ)	+= sch_qfq.o
 
- obj-$(CONFIG_NET_SCH_CODEL)	+= sch_codel.o
 
-+obj-$(CONFIG_NET_SCH_FQ_CODEL)	+= sch_fq_codel.o
 
- 
- obj-$(CONFIG_NET_CLS_U32)	+= cls_u32.o
 
- obj-$(CONFIG_NET_CLS_ROUTE4)	+= cls_route.o
 
---- /dev/null
 
-+++ b/net/sched/sch_fq_codel.c
 
-@@ -0,0 +1,624 @@
 
-+/*
 
-+ * Fair Queue CoDel discipline
 
-+ *
 
-+ *	This program is free software; you can redistribute it and/or
 
-+ *	modify it under the terms of the GNU General Public License
 
-+ *	as published by the Free Software Foundation; either version
 
-+ *	2 of the License, or (at your option) any later version.
 
-+ *
 
-+ *  Copyright (C) 2012 Eric Dumazet <[email protected]>
 
-+ */
 
-+
 
-+#include <linux/module.h>
 
-+#include <linux/types.h>
 
-+#include <linux/kernel.h>
 
-+#include <linux/jiffies.h>
 
-+#include <linux/string.h>
 
-+#include <linux/in.h>
 
-+#include <linux/errno.h>
 
-+#include <linux/init.h>
 
-+#include <linux/skbuff.h>
 
-+#include <linux/jhash.h>
 
-+#include <linux/slab.h>
 
-+#include <linux/vmalloc.h>
 
-+#include <net/netlink.h>
 
-+#include <net/pkt_sched.h>
 
-+#include <net/flow_keys.h>
 
-+#include <net/codel.h>
 
-+
 
-+/*	Fair Queue CoDel.
 
-+ *
 
-+ * Principles :
 
-+ * Packets are classified (internal classifier or external) on flows.
 
-+ * This is a Stochastic model (as we use a hash, several flows
 
-+ *			       might be hashed on same slot)
 
-+ * Each flow has a CoDel managed queue.
 
-+ * Flows are linked onto two (Round Robin) lists,
 
-+ * so that new flows have priority on old ones.
 
-+ *
 
-+ * For a given flow, packets are not reordered (CoDel uses a FIFO)
 
-+ * head drops only.
 
-+ * ECN capability is on by default.
 
-+ * Low memory footprint (64 bytes per flow)
 
-+ */
 
-+
 
-+struct fq_codel_flow {
 
-+	struct sk_buff	  *head;
 
-+	struct sk_buff	  *tail;
 
-+	struct list_head  flowchain;
 
-+	int		  deficit;
 
-+	u32		  dropped; /* number of drops (or ECN marks) on this flow */
 
-+	struct codel_vars cvars;
 
-+}; /* please try to keep this structure <= 64 bytes */
 
-+
 
-+struct fq_codel_sched_data {
 
-+	struct tcf_proto *filter_list;	/* optional external classifier */
 
-+	struct fq_codel_flow *flows;	/* Flows table [flows_cnt] */
 
-+	u32		*backlogs;	/* backlog table [flows_cnt] */
 
-+	u32		flows_cnt;	/* number of flows */
 
-+	u32		perturbation;	/* hash perturbation */
 
-+	u32		quantum;	/* psched_mtu(qdisc_dev(sch)); */
 
-+	struct codel_params cparams;
 
-+	struct codel_stats cstats;
 
-+	u32		drop_overlimit;
 
-+	u32		new_flow_count;
 
-+
 
-+	struct list_head new_flows;	/* list of new flows */
 
-+	struct list_head old_flows;	/* list of old flows */
 
-+};
 
-+
 
-+static unsigned int fq_codel_hash(const struct fq_codel_sched_data *q,
 
-+				  const struct sk_buff *skb)
 
-+{
 
-+	struct flow_keys keys;
 
-+	unsigned int hash;
 
-+
 
-+	skb_flow_dissect(skb, &keys);
 
-+	hash = jhash_3words((__force u32)keys.dst,
 
-+			    (__force u32)keys.src ^ keys.ip_proto,
 
-+			    (__force u32)keys.ports, q->perturbation);
 
-+	return ((u64)hash * q->flows_cnt) >> 32;
 
-+}
 
-+
 
-+static unsigned int fq_codel_classify(struct sk_buff *skb, struct Qdisc *sch,
 
-+				      int *qerr)
 
-+{
 
-+	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
-+	struct tcf_result res;
 
-+	int result;
 
-+
 
-+	if (TC_H_MAJ(skb->priority) == sch->handle &&
 
-+	    TC_H_MIN(skb->priority) > 0 &&
 
-+	    TC_H_MIN(skb->priority) <= q->flows_cnt)
 
-+		return TC_H_MIN(skb->priority);
 
-+
 
-+	if (!q->filter_list)
 
-+		return fq_codel_hash(q, skb) + 1;
 
-+
 
-+	*qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
 
-+	result = tc_classify(skb, q->filter_list, &res);
 
-+	if (result >= 0) {
 
-+#ifdef CONFIG_NET_CLS_ACT
 
-+		switch (result) {
 
-+		case TC_ACT_STOLEN:
 
-+		case TC_ACT_QUEUED:
 
-+			*qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
 
-+		case TC_ACT_SHOT:
 
-+			return 0;
 
-+		}
 
-+#endif
 
-+		if (TC_H_MIN(res.classid) <= q->flows_cnt)
 
-+			return TC_H_MIN(res.classid);
 
-+	}
 
-+	return 0;
 
-+}
 
-+
 
-+/* helper functions : might be changed when/if skb use a standard list_head */
 
-+
 
-+/* remove one skb from head of slot queue */
 
-+static inline struct sk_buff *dequeue_head(struct fq_codel_flow *flow)
 
-+{
 
-+	struct sk_buff *skb = flow->head;
 
-+
 
-+	flow->head = skb->next;
 
-+	skb->next = NULL;
 
-+	return skb;
 
-+}
 
-+
 
-+/* add skb to flow queue (tail add) */
 
-+static inline void flow_queue_add(struct fq_codel_flow *flow,
 
-+				  struct sk_buff *skb)
 
-+{
 
-+	if (flow->head == NULL)
 
-+		flow->head = skb;
 
-+	else
 
-+		flow->tail->next = skb;
 
-+	flow->tail = skb;
 
-+	skb->next = NULL;
 
-+}
 
-+
 
-+static unsigned int fq_codel_drop(struct Qdisc *sch)
 
-+{
 
-+	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
-+	struct sk_buff *skb;
 
-+	unsigned int maxbacklog = 0, idx = 0, i, len;
 
-+	struct fq_codel_flow *flow;
 
-+
 
-+	/* Queue is full! Find the fat flow and drop packet from it.
 
-+	 * This might sound expensive, but with 1024 flows, we scan
 
-+	 * 4KB of memory, and we dont need to handle a complex tree
 
-+	 * in fast path (packet queue/enqueue) with many cache misses.
 
-+	 */
 
-+	for (i = 0; i < q->flows_cnt; i++) {
 
-+		if (q->backlogs[i] > maxbacklog) {
 
-+			maxbacklog = q->backlogs[i];
 
-+			idx = i;
 
-+		}
 
-+	}
 
-+	flow = &q->flows[idx];
 
-+	skb = dequeue_head(flow);
 
-+	len = qdisc_pkt_len(skb);
 
-+	q->backlogs[idx] -= len;
 
-+	kfree_skb(skb);
 
-+	sch->q.qlen--;
 
-+	sch->qstats.drops++;
 
-+	sch->qstats.backlog -= len;
 
-+	flow->dropped++;
 
-+	return idx;
 
-+}
 
-+
 
-+static int fq_codel_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 
-+{
 
-+	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
-+	unsigned int idx;
 
-+	struct fq_codel_flow *flow;
 
-+	int uninitialized_var(ret);
 
-+
 
-+	idx = fq_codel_classify(skb, sch, &ret);
 
-+	if (idx == 0) {
 
-+		if (ret & __NET_XMIT_BYPASS)
 
-+			sch->qstats.drops++;
 
-+		kfree_skb(skb);
 
-+		return ret;
 
-+	}
 
-+	idx--;
 
-+
 
-+	codel_set_enqueue_time(skb);
 
-+	flow = &q->flows[idx];
 
-+	flow_queue_add(flow, skb);
 
-+	q->backlogs[idx] += qdisc_pkt_len(skb);
 
-+	sch->qstats.backlog += qdisc_pkt_len(skb);
 
-+
 
-+	if (list_empty(&flow->flowchain)) {
 
-+		list_add_tail(&flow->flowchain, &q->new_flows);
 
-+		codel_vars_init(&flow->cvars);
 
-+		q->new_flow_count++;
 
-+		flow->deficit = q->quantum;
 
-+		flow->dropped = 0;
 
-+	}
 
-+	if (++sch->q.qlen < sch->limit)
 
-+		return NET_XMIT_SUCCESS;
 
-+
 
-+	q->drop_overlimit++;
 
-+	/* Return Congestion Notification only if we dropped a packet
 
-+	 * from this flow.
 
-+	 */
 
-+	if (fq_codel_drop(sch) == idx)
 
-+		return NET_XMIT_CN;
 
-+
 
-+	/* As we dropped a packet, better let upper stack know this */
 
-+	qdisc_tree_decrease_qlen(sch, 1);
 
-+	return NET_XMIT_SUCCESS;
 
-+}
 
-+
 
-+/* This is the specific function called from codel_dequeue()
 
-+ * to dequeue a packet from queue. Note: backlog is handled in
 
-+ * codel, we dont need to reduce it here.
 
-+ */
 
-+static struct sk_buff *dequeue(struct codel_vars *vars, struct Qdisc *sch)
 
-+{
 
-+	struct fq_codel_flow *flow;
 
-+	struct sk_buff *skb = NULL;
 
-+
 
-+	flow = container_of(vars, struct fq_codel_flow, cvars);
 
-+	if (flow->head) {
 
-+		skb = dequeue_head(flow);
 
-+		sch->qstats.backlog -= qdisc_pkt_len(skb);
 
-+		sch->q.qlen--;
 
-+	}
 
-+	return skb;
 
-+}
 
-+
 
-+static struct sk_buff *fq_codel_dequeue(struct Qdisc *sch)
 
-+{
 
-+	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
-+	struct sk_buff *skb;
 
-+	struct fq_codel_flow *flow;
 
-+	struct list_head *head;
 
-+	u32 prev_drop_count, prev_ecn_mark;
 
-+
 
-+begin:
 
-+	head = &q->new_flows;
 
-+	if (list_empty(head)) {
 
-+		head = &q->old_flows;
 
-+		if (list_empty(head))
 
-+			return NULL;
 
-+	}
 
-+	flow = list_first_entry(head, struct fq_codel_flow, flowchain);
 
-+
 
-+	if (flow->deficit <= 0) {
 
-+		flow->deficit += q->quantum;
 
-+		list_move_tail(&flow->flowchain, &q->old_flows);
 
-+		goto begin;
 
-+	}
 
-+
 
-+	prev_drop_count = q->cstats.drop_count;
 
-+	prev_ecn_mark = q->cstats.ecn_mark;
 
-+
 
-+	skb = codel_dequeue(sch, &q->cparams, &flow->cvars, &q->cstats,
 
-+			    dequeue, &q->backlogs[flow - q->flows]);
 
-+
 
-+	flow->dropped += q->cstats.drop_count - prev_drop_count;
 
-+	flow->dropped += q->cstats.ecn_mark - prev_ecn_mark;
 
-+
 
-+	if (!skb) {
 
-+		/* force a pass through old_flows to prevent starvation */
 
-+		if ((head == &q->new_flows) && !list_empty(&q->old_flows))
 
-+			list_move_tail(&flow->flowchain, &q->old_flows);
 
-+		else
 
-+			list_del_init(&flow->flowchain);
 
-+		goto begin;
 
-+	}
 
-+	qdisc_bstats_update(sch, skb);
 
-+	flow->deficit -= qdisc_pkt_len(skb);
 
-+	/* We cant call qdisc_tree_decrease_qlen() if our qlen is 0,
 
-+	 * or HTB crashes. Defer it for next round.
 
-+	 */
 
-+	if (q->cstats.drop_count && sch->q.qlen) {
 
-+		qdisc_tree_decrease_qlen(sch, q->cstats.drop_count);
 
-+		q->cstats.drop_count = 0;
 
-+	}
 
-+	return skb;
 
-+}
 
-+
 
-+static void fq_codel_reset(struct Qdisc *sch)
 
-+{
 
-+	struct sk_buff *skb;
 
-+
 
-+	while ((skb = fq_codel_dequeue(sch)) != NULL)
 
-+		kfree_skb(skb);
 
-+}
 
-+
 
-+static const struct nla_policy fq_codel_policy[TCA_FQ_CODEL_MAX + 1] = {
 
-+	[TCA_FQ_CODEL_TARGET]	= { .type = NLA_U32 },
 
-+	[TCA_FQ_CODEL_LIMIT]	= { .type = NLA_U32 },
 
-+	[TCA_FQ_CODEL_INTERVAL]	= { .type = NLA_U32 },
 
-+	[TCA_FQ_CODEL_ECN]	= { .type = NLA_U32 },
 
-+	[TCA_FQ_CODEL_FLOWS]	= { .type = NLA_U32 },
 
-+	[TCA_FQ_CODEL_QUANTUM]	= { .type = NLA_U32 },
 
-+};
 
-+
 
-+static int fq_codel_change(struct Qdisc *sch, struct nlattr *opt)
 
-+{
 
-+	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
-+	struct nlattr *tb[TCA_FQ_CODEL_MAX + 1];
 
-+	int err;
 
-+
 
-+	if (!opt)
 
-+		return -EINVAL;
 
-+
 
-+	err = nla_parse_nested(tb, TCA_FQ_CODEL_MAX, opt, fq_codel_policy);
 
-+	if (err < 0)
 
-+		return err;
 
-+	if (tb[TCA_FQ_CODEL_FLOWS]) {
 
-+		if (q->flows)
 
-+			return -EINVAL;
 
-+		q->flows_cnt = nla_get_u32(tb[TCA_FQ_CODEL_FLOWS]);
 
-+		if (!q->flows_cnt ||
 
-+		    q->flows_cnt > 65536)
 
-+			return -EINVAL;
 
-+	}
 
-+	sch_tree_lock(sch);
 
-+
 
-+	if (tb[TCA_FQ_CODEL_TARGET]) {
 
-+		u64 target = nla_get_u32(tb[TCA_FQ_CODEL_TARGET]);
 
-+
 
-+		q->cparams.target = (target * NSEC_PER_USEC) >> CODEL_SHIFT;
 
-+	}
 
-+
 
-+	if (tb[TCA_FQ_CODEL_INTERVAL]) {
 
-+		u64 interval = nla_get_u32(tb[TCA_FQ_CODEL_INTERVAL]);
 
-+
 
-+		q->cparams.interval = (interval * NSEC_PER_USEC) >> CODEL_SHIFT;
 
-+	}
 
-+
 
-+	if (tb[TCA_FQ_CODEL_LIMIT])
 
-+		sch->limit = nla_get_u32(tb[TCA_FQ_CODEL_LIMIT]);
 
-+
 
-+	if (tb[TCA_FQ_CODEL_ECN])
 
-+		q->cparams.ecn = !!nla_get_u32(tb[TCA_FQ_CODEL_ECN]);
 
-+
 
-+	if (tb[TCA_FQ_CODEL_QUANTUM])
 
-+		q->quantum = max(256U, nla_get_u32(tb[TCA_FQ_CODEL_QUANTUM]));
 
-+
 
-+	while (sch->q.qlen > sch->limit) {
 
-+		struct sk_buff *skb = fq_codel_dequeue(sch);
 
-+
 
-+		kfree_skb(skb);
 
-+		q->cstats.drop_count++;
 
-+	}
 
-+	qdisc_tree_decrease_qlen(sch, q->cstats.drop_count);
 
-+	q->cstats.drop_count = 0;
 
-+
 
-+	sch_tree_unlock(sch);
 
-+	return 0;
 
-+}
 
-+
 
-+static void *fq_codel_zalloc(size_t sz)
 
-+{
 
-+	void *ptr = kzalloc(sz, GFP_KERNEL | __GFP_NOWARN);
 
-+
 
-+	if (!ptr)
 
-+		ptr = vzalloc(sz);
 
-+	return ptr;
 
-+}
 
-+
 
-+static void fq_codel_free(void *addr)
 
-+{
 
-+	if (addr) {
 
-+		if (is_vmalloc_addr(addr))
 
-+			vfree(addr);
 
-+		else
 
-+			kfree(addr);
 
-+	}
 
-+}
 
-+
 
-+static void fq_codel_destroy(struct Qdisc *sch)
 
-+{
 
-+	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
-+
 
-+	tcf_destroy_chain(&q->filter_list);
 
-+	fq_codel_free(q->backlogs);
 
-+	fq_codel_free(q->flows);
 
-+}
 
-+
 
-+static int fq_codel_init(struct Qdisc *sch, struct nlattr *opt)
 
-+{
 
-+	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
-+	int i;
 
-+
 
-+	sch->limit = 10*1024;
 
-+	q->flows_cnt = 1024;
 
-+	q->quantum = psched_mtu(qdisc_dev(sch));
 
-+	q->perturbation = net_random();
 
-+	INIT_LIST_HEAD(&q->new_flows);
 
-+	INIT_LIST_HEAD(&q->old_flows);
 
-+	codel_params_init(&q->cparams);
 
-+	codel_stats_init(&q->cstats);
 
-+	q->cparams.ecn = true;
 
-+
 
-+	if (opt) {
 
-+		int err = fq_codel_change(sch, opt);
 
-+		if (err)
 
-+			return err;
 
-+	}
 
-+
 
-+	if (!q->flows) {
 
-+		q->flows = fq_codel_zalloc(q->flows_cnt *
 
-+					   sizeof(struct fq_codel_flow));
 
-+		if (!q->flows)
 
-+			return -ENOMEM;
 
-+		q->backlogs = fq_codel_zalloc(q->flows_cnt * sizeof(u32));
 
-+		if (!q->backlogs) {
 
-+			fq_codel_free(q->flows);
 
-+			return -ENOMEM;
 
-+		}
 
-+		for (i = 0; i < q->flows_cnt; i++) {
 
-+			struct fq_codel_flow *flow = q->flows + i;
 
-+
 
-+			INIT_LIST_HEAD(&flow->flowchain);
 
-+		}
 
-+	}
 
-+	if (sch->limit >= 1)
 
-+		sch->flags |= TCQ_F_CAN_BYPASS;
 
-+	else
 
-+		sch->flags &= ~TCQ_F_CAN_BYPASS;
 
-+	return 0;
 
-+}
 
-+
 
-+static int fq_codel_dump(struct Qdisc *sch, struct sk_buff *skb)
 
-+{
 
-+	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
-+	struct nlattr *opts;
 
-+
 
-+	opts = nla_nest_start(skb, TCA_OPTIONS);
 
-+	if (opts == NULL)
 
-+		goto nla_put_failure;
 
-+
 
-+	if (nla_put_u32(skb, TCA_FQ_CODEL_TARGET,
 
-+			codel_time_to_us(q->cparams.target)) ||
 
-+	    nla_put_u32(skb, TCA_FQ_CODEL_LIMIT,
 
-+			sch->limit) ||
 
-+	    nla_put_u32(skb, TCA_FQ_CODEL_INTERVAL,
 
-+			codel_time_to_us(q->cparams.interval)) ||
 
-+	    nla_put_u32(skb, TCA_FQ_CODEL_ECN,
 
-+			q->cparams.ecn) ||
 
-+	    nla_put_u32(skb, TCA_FQ_CODEL_QUANTUM,
 
-+			q->quantum) ||
 
-+	    nla_put_u32(skb, TCA_FQ_CODEL_FLOWS,
 
-+			q->flows_cnt))
 
-+		goto nla_put_failure;
 
-+
 
-+	nla_nest_end(skb, opts);
 
-+	return skb->len;
 
-+
 
-+nla_put_failure:
 
-+	return -1;
 
-+}
 
-+
 
-+static int fq_codel_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
 
-+{
 
-+	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
-+	struct tc_fq_codel_xstats st = {
 
-+		.type				= TCA_FQ_CODEL_XSTATS_QDISC,
 
-+		.qdisc_stats.maxpacket		= q->cstats.maxpacket,
 
-+		.qdisc_stats.drop_overlimit	= q->drop_overlimit,
 
-+		.qdisc_stats.ecn_mark		= q->cstats.ecn_mark,
 
-+		.qdisc_stats.new_flow_count	= q->new_flow_count,
 
-+	};
 
-+	struct list_head *pos;
 
-+
 
-+	list_for_each(pos, &q->new_flows)
 
-+		st.qdisc_stats.new_flows_len++;
 
-+
 
-+	list_for_each(pos, &q->old_flows)
 
-+		st.qdisc_stats.old_flows_len++;
 
-+
 
-+	return gnet_stats_copy_app(d, &st, sizeof(st));
 
-+}
 
-+
 
-+static struct Qdisc *fq_codel_leaf(struct Qdisc *sch, unsigned long arg)
 
-+{
 
-+	return NULL;
 
-+}
 
-+
 
-+static unsigned long fq_codel_get(struct Qdisc *sch, u32 classid)
 
-+{
 
-+	return 0;
 
-+}
 
-+
 
-+static unsigned long fq_codel_bind(struct Qdisc *sch, unsigned long parent,
 
-+			      u32 classid)
 
-+{
 
-+	/* we cannot bypass queue discipline anymore */
 
-+	sch->flags &= ~TCQ_F_CAN_BYPASS;
 
-+	return 0;
 
-+}
 
-+
 
-+static void fq_codel_put(struct Qdisc *q, unsigned long cl)
 
-+{
 
-+}
 
-+
 
-+static struct tcf_proto **fq_codel_find_tcf(struct Qdisc *sch, unsigned long cl)
 
-+{
 
-+	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
-+
 
-+	if (cl)
 
-+		return NULL;
 
-+	return &q->filter_list;
 
-+}
 
-+
 
-+static int fq_codel_dump_class(struct Qdisc *sch, unsigned long cl,
 
-+			  struct sk_buff *skb, struct tcmsg *tcm)
 
-+{
 
-+	tcm->tcm_handle |= TC_H_MIN(cl);
 
-+	return 0;
 
-+}
 
-+
 
-+static int fq_codel_dump_class_stats(struct Qdisc *sch, unsigned long cl,
 
-+				     struct gnet_dump *d)
 
-+{
 
-+	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
-+	u32 idx = cl - 1;
 
-+	struct gnet_stats_queue qs = { 0 };
 
-+	struct tc_fq_codel_xstats xstats;
 
-+
 
-+	if (idx < q->flows_cnt) {
 
-+		const struct fq_codel_flow *flow = &q->flows[idx];
 
-+		const struct sk_buff *skb = flow->head;
 
-+
 
-+		memset(&xstats, 0, sizeof(xstats));
 
-+		xstats.type = TCA_FQ_CODEL_XSTATS_CLASS;
 
-+		xstats.class_stats.deficit = flow->deficit;
 
-+		xstats.class_stats.ldelay =
 
-+			codel_time_to_us(flow->cvars.ldelay);
 
-+		xstats.class_stats.count = flow->cvars.count;
 
-+		xstats.class_stats.lastcount = flow->cvars.lastcount;
 
-+		xstats.class_stats.dropping = flow->cvars.dropping;
 
-+		if (flow->cvars.dropping) {
 
-+			codel_tdiff_t delta = flow->cvars.drop_next -
 
-+					      codel_get_time();
 
-+
 
-+			xstats.class_stats.drop_next = (delta >= 0) ?
 
-+				codel_time_to_us(delta) :
 
-+				-codel_time_to_us(-delta);
 
-+		}
 
-+		while (skb) {
 
-+			qs.qlen++;
 
-+			skb = skb->next;
 
-+		}
 
-+		qs.backlog = q->backlogs[idx];
 
-+		qs.drops = flow->dropped;
 
-+	}
 
-+	if (gnet_stats_copy_queue(d, &qs) < 0)
 
-+		return -1;
 
-+	if (idx < q->flows_cnt)
 
-+		return gnet_stats_copy_app(d, &xstats, sizeof(xstats));
 
-+	return 0;
 
-+}
 
-+
 
-+static void fq_codel_walk(struct Qdisc *sch, struct qdisc_walker *arg)
 
-+{
 
-+	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
-+	unsigned int i;
 
-+
 
-+	if (arg->stop)
 
-+		return;
 
-+
 
-+	for (i = 0; i < q->flows_cnt; i++) {
 
-+		if (list_empty(&q->flows[i].flowchain) ||
 
-+		    arg->count < arg->skip) {
 
-+			arg->count++;
 
-+			continue;
 
-+		}
 
-+		if (arg->fn(sch, i + 1, arg) < 0) {
 
-+			arg->stop = 1;
 
-+			break;
 
-+		}
 
-+		arg->count++;
 
-+	}
 
-+}
 
-+
 
-+static const struct Qdisc_class_ops fq_codel_class_ops = {
 
-+	.leaf		=	fq_codel_leaf,
 
-+	.get		=	fq_codel_get,
 
-+	.put		=	fq_codel_put,
 
-+	.tcf_chain	=	fq_codel_find_tcf,
 
-+	.bind_tcf	=	fq_codel_bind,
 
-+	.unbind_tcf	=	fq_codel_put,
 
-+	.dump		=	fq_codel_dump_class,
 
-+	.dump_stats	=	fq_codel_dump_class_stats,
 
-+	.walk		=	fq_codel_walk,
 
-+};
 
-+
 
-+static struct Qdisc_ops fq_codel_qdisc_ops __read_mostly = {
 
-+	.cl_ops		=	&fq_codel_class_ops,
 
-+	.id		=	"fq_codel",
 
-+	.priv_size	=	sizeof(struct fq_codel_sched_data),
 
-+	.enqueue	=	fq_codel_enqueue,
 
-+	.dequeue	=	fq_codel_dequeue,
 
-+	.peek		=	qdisc_peek_dequeued,
 
-+	.drop		=	fq_codel_drop,
 
-+	.init		=	fq_codel_init,
 
-+	.reset		=	fq_codel_reset,
 
-+	.destroy	=	fq_codel_destroy,
 
-+	.change		=	fq_codel_change,
 
-+	.dump		=	fq_codel_dump,
 
-+	.dump_stats =	fq_codel_dump_stats,
 
-+	.owner		=	THIS_MODULE,
 
-+};
 
-+
 
-+static int __init fq_codel_module_init(void)
 
-+{
 
-+	return register_qdisc(&fq_codel_qdisc_ops);
 
-+}
 
-+
 
-+static void __exit fq_codel_module_exit(void)
 
-+{
 
-+	unregister_qdisc(&fq_codel_qdisc_ops);
 
-+}
 
-+
 
-+module_init(fq_codel_module_init)
 
-+module_exit(fq_codel_module_exit)
 
-+MODULE_AUTHOR("Eric Dumazet");
 
-+MODULE_LICENSE("GPL");

+ 0 - 33
target/linux/generic/patches-3.3/043-net-codel-Add-missing-include-linux-prefetch.h.patch
View File 

@@ -1,33 +0,0 @@
 
-From 18c12e496ead3306de00a82d0bc73d71b34d7c24 Mon Sep 17 00:00:00 2001
 
-From: Geert Uytterhoeven <[email protected]>
 
-Date: Mon, 14 May 2012 09:47:05 +0000
 
-Subject: [PATCH] net/codel: Add missing #include <linux/prefetch.h>
 
-MIME-Version: 1.0
 
-Content-Type: text/plain; charset=UTF-8
 
-Content-Transfer-Encoding: 8bit
 
-
 
-commit ce5b4b977127ee20c3f9c3fd3637cd3796f649f5 upstream.
 
-
 
-m68k allmodconfig:
 
-
 
-net/sched/sch_codel.c: In function ‘dequeue’:
 
-net/sched/sch_codel.c:70: error: implicit declaration of function ‘prefetch’
 
-make[1]: *** [net/sched/sch_codel.o] Error 1
 
-
 
-Signed-off-by: Geert Uytterhoeven <[email protected]>
 
-Acked-by: Eric Dumazet <[email protected]>
 
-Signed-off-by: David S. Miller <[email protected]>
 
----
 
- net/sched/sch_codel.c |    1 +
 
- 1 file changed, 1 insertion(+)
 
-
 
---- a/net/sched/sch_codel.c
 
-+++ b/net/sched/sch_codel.c
 
-@@ -46,6 +46,7 @@
 
- #include <linux/kernel.h>
 
- #include <linux/errno.h>
 
- #include <linux/skbuff.h>
 
-+#include <linux/prefetch.h>
 
- #include <net/pkt_sched.h>
 
- #include <net/codel.h>
 
-

+ 0 - 51
target/linux/generic/patches-3.3/044-net-codel-fix-build-errors.patch
View File 

@@ -1,51 +0,0 @@
 
-From b49ab5f6bb7e609190065cb9a605de809e50ab60 Mon Sep 17 00:00:00 2001
 
-From: Sasha Levin <[email protected]>
 
-Date: Mon, 14 May 2012 11:57:06 +0000
 
-Subject: [PATCH] net: codel: fix build errors
 
-
 
-commit 669d67bf777def468970f2dcba1537edf3b2d329 upstream.
 
-
 
-Fix the following build error:
 
-
 
-net/sched/sch_fq_codel.c: In function 'fq_codel_dump_stats':
 
-net/sched/sch_fq_codel.c:464:3: error: unknown field 'qdisc_stats' specified in initializer
 
-net/sched/sch_fq_codel.c:464:3: warning: missing braces around initializer
 
-net/sched/sch_fq_codel.c:464:3: warning: (near initialization for 'st.<anonymous>')
 
-net/sched/sch_fq_codel.c:465:3: error: unknown field 'qdisc_stats' specified in initializer
 
-net/sched/sch_fq_codel.c:465:3: warning: excess elements in struct initializer
 
-net/sched/sch_fq_codel.c:465:3: warning: (near initialization for 'st')
 
-net/sched/sch_fq_codel.c:466:3: error: unknown field 'qdisc_stats' specified in initializer
 
-net/sched/sch_fq_codel.c:466:3: warning: excess elements in struct initializer
 
-net/sched/sch_fq_codel.c:466:3: warning: (near initialization for 'st')
 
-net/sched/sch_fq_codel.c:467:3: error: unknown field 'qdisc_stats' specified in initializer
 
-net/sched/sch_fq_codel.c:467:3: warning: excess elements in struct initializer
 
-net/sched/sch_fq_codel.c:467:3: warning: (near initialization for 'st')
 
-make[1]: *** [net/sched/sch_fq_codel.o] Error 1
 
-
 
-Signed-off-by: Sasha Levin <[email protected]>
 
-Signed-off-by: David S. Miller <[email protected]>
 
----
 
- net/sched/sch_fq_codel.c |    9 +++++----
 
- 1 file changed, 5 insertions(+), 4 deletions(-)
 
-
 
---- a/net/sched/sch_fq_codel.c
 
-+++ b/net/sched/sch_fq_codel.c
 
-@@ -461,13 +461,14 @@ static int fq_codel_dump_stats(struct Qd
 
- 	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
- 	struct tc_fq_codel_xstats st = {
 
- 		.type				= TCA_FQ_CODEL_XSTATS_QDISC,
 
--		.qdisc_stats.maxpacket		= q->cstats.maxpacket,
 
--		.qdisc_stats.drop_overlimit	= q->drop_overlimit,
 
--		.qdisc_stats.ecn_mark		= q->cstats.ecn_mark,
 
--		.qdisc_stats.new_flow_count	= q->new_flow_count,
 
- 	};
 
- 	struct list_head *pos;
 
- 
-+	st.qdisc_stats.maxpacket = q->cstats.maxpacket;
 
-+	st.qdisc_stats.drop_overlimit = q->drop_overlimit;
 
-+	st.qdisc_stats.ecn_mark = q->cstats.ecn_mark;
 
-+	st.qdisc_stats.new_flow_count = q->new_flow_count;
 
-+
 
- 	list_for_each(pos, &q->new_flows)
 
- 		st.qdisc_stats.new_flows_len++;
 
-

+ 0 - 86
target/linux/generic/patches-3.3/045-codel-use-u16-field-instead-of-31bits-for-rec_inv_sq.patch
View File 

@@ -1,86 +0,0 @@
 
-From 03333931c17d9c62ba4063d4e4fec1578c0729a7 Mon Sep 17 00:00:00 2001
 
-From: Eric Dumazet <[email protected]>
 
-Date: Sat, 12 May 2012 21:23:23 +0000
 
-Subject: [PATCH] codel: use u16 field instead of 31bits for rec_inv_sqrt
 
-
 
-commit 6ff272c9ad65eda219cd975b9da2dbc31cc812ee upstream.
 
-
 
-David pointed out gcc might generate poor code with 31bit fields.
 
-
 
-Using u16 is more than enough and permits a better code output.
 
-
 
-Also make the code intent more readable using constants, fixed point arithmetic
 
-not being trivial for everybody.
 
-
 
-Suggested-by: David Miller <[email protected]>
 
-Signed-off-by: Eric Dumazet <[email protected]>
 
-Signed-off-by: David S. Miller <[email protected]>
 
----
 
- include/net/codel.h |   25 +++++++++++++++----------
 
- 1 file changed, 15 insertions(+), 10 deletions(-)
 
-
 
---- a/include/net/codel.h
 
-+++ b/include/net/codel.h
 
-@@ -133,13 +133,17 @@ struct codel_params {
 
- struct codel_vars {
 
- 	u32		count;
 
- 	u32		lastcount;
 
--	bool		dropping:1;
 
--	u32		rec_inv_sqrt:31;
 
-+	bool		dropping;
 
-+	u16		rec_inv_sqrt;
 
- 	codel_time_t	first_above_time;
 
- 	codel_time_t	drop_next;
 
- 	codel_time_t	ldelay;
 
- };
 
- 
-+#define REC_INV_SQRT_BITS (8 * sizeof(u16)) /* or sizeof_in_bits(rec_inv_sqrt) */
 
-+/* needed shift to get a Q0.32 number from rec_inv_sqrt */
 
-+#define REC_INV_SQRT_SHIFT (32 - REC_INV_SQRT_BITS)
 
-+
 
- /**
 
-  * struct codel_stats - contains codel shared variables and stats
 
-  * @maxpacket:	largest packet we've seen so far
 
-@@ -173,17 +177,18 @@ static void codel_stats_init(struct code
 
-  * http://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Iterative_methods_for_reciprocal_square_roots
 
-  * new_invsqrt = (invsqrt / 2) * (3 - count * invsqrt^2)
 
-  *
 
-- * Here, invsqrt is a fixed point number (< 1.0), 31bit mantissa)
 
-+ * Here, invsqrt is a fixed point number (< 1.0), 32bit mantissa, aka Q0.32
 
-  */
 
- static void codel_Newton_step(struct codel_vars *vars)
 
- {
 
--	u32 invsqrt = vars->rec_inv_sqrt;
 
--	u32 invsqrt2 = ((u64)invsqrt * invsqrt) >> 31;
 
--	u64 val = (3LL << 31) - ((u64)vars->count * invsqrt2);
 
-+	u32 invsqrt = ((u32)vars->rec_inv_sqrt) << REC_INV_SQRT_SHIFT;
 
-+	u32 invsqrt2 = ((u64)invsqrt * invsqrt) >> 32;
 
-+	u64 val = (3LL << 32) - ((u64)vars->count * invsqrt2);
 
- 
--	val = (val * invsqrt) >> 32;
 
-+	val >>= 2; /* avoid overflow in following multiply */
 
-+	val = (val * invsqrt) >> (32 - 2 + 1);
 
- 
--	vars->rec_inv_sqrt = val;
 
-+	vars->rec_inv_sqrt = val >> REC_INV_SQRT_SHIFT;
 
- }
 
- 
- /*
 
-@@ -195,7 +200,7 @@ static codel_time_t codel_control_law(co
 
- 				      codel_time_t interval,
 
- 				      u32 rec_inv_sqrt)
 
- {
 
--	return t + reciprocal_divide(interval, rec_inv_sqrt << 1);
 
-+	return t + reciprocal_divide(interval, rec_inv_sqrt << REC_INV_SQRT_SHIFT);
 
- }
 
- 
- 
-@@ -326,7 +331,7 @@ static struct sk_buff *codel_dequeue(str
 
- 			codel_Newton_step(vars);
 
- 		} else {
 
- 			vars->count = 1;
 
--			vars->rec_inv_sqrt = 0x7fffffff;
 
-+			vars->rec_inv_sqrt = ~0U >> REC_INV_SQRT_SHIFT;
 
- 		}
 
- 		vars->lastcount = vars->count;
 
- 		vars->drop_next = codel_control_law(now, params->interval,

+ 0 - 132
target/linux/generic/patches-3.3/046-fq_codel-qdisc-backlog.patch
View File 

@@ -1,132 +0,0 @@
 
-From 7bd90773f89001ea4960ed47676b550137f3facb Mon Sep 17 00:00:00 2001
 
-From: Eric Dumazet <[email protected]>
 
-Date: Wed, 16 May 2012 04:39:09 +0000
 
-Subject: [PATCH] fq_codel: should use qdisc backlog as threshold
 
-
 
-commit 865ec5523dadbedefbc5710a68969f686a28d928 upstream.
 
-
 
-codel_should_drop() logic allows a packet being not dropped if queue
 
-size is under max packet size.
 
-
 
-In fq_codel, we have two possible backlogs : The qdisc global one, and
 
-the flow local one.
 
-
 
-The meaningful one for codel_should_drop() should be the global backlog,
 
-not the per flow one, so that thin flows can have a non zero drop/mark
 
-probability.
 
-
 
-Signed-off-by: Eric Dumazet <[email protected]>
 
-Cc: Dave Taht <[email protected]>
 
-Cc: Kathleen Nichols <[email protected]>
 
-Cc: Van Jacobson <[email protected]>
 
-Signed-off-by: David S. Miller <[email protected]>
 
----
 
- include/net/codel.h      |   15 +++++++--------
 
- net/sched/sch_codel.c    |    4 ++--
 
- net/sched/sch_fq_codel.c |    5 +++--
 
- 3 files changed, 12 insertions(+), 12 deletions(-)
 
-
 
---- a/include/net/codel.h
 
-+++ b/include/net/codel.h
 
-@@ -205,7 +205,7 @@ static codel_time_t codel_control_law(co
 
- 
- 
- static bool codel_should_drop(const struct sk_buff *skb,
 
--			      unsigned int *backlog,
 
-+			      struct Qdisc *sch,
 
- 			      struct codel_vars *vars,
 
- 			      struct codel_params *params,
 
- 			      struct codel_stats *stats,
 
-@@ -219,13 +219,13 @@ static bool codel_should_drop(const stru
 
- 	}
 
- 
- 	vars->ldelay = now - codel_get_enqueue_time(skb);
 
--	*backlog -= qdisc_pkt_len(skb);
 
-+	sch->qstats.backlog -= qdisc_pkt_len(skb);
 
- 
- 	if (unlikely(qdisc_pkt_len(skb) > stats->maxpacket))
 
- 		stats->maxpacket = qdisc_pkt_len(skb);
 
- 
- 	if (codel_time_before(vars->ldelay, params->target) ||
 
--	    *backlog <= stats->maxpacket) {
 
-+	    sch->qstats.backlog <= stats->maxpacket) {
 
- 		/* went below - stay below for at least interval */
 
- 		vars->first_above_time = 0;
 
- 		return false;
 
-@@ -249,8 +249,7 @@ static struct sk_buff *codel_dequeue(str
 
- 				     struct codel_params *params,
 
- 				     struct codel_vars *vars,
 
- 				     struct codel_stats *stats,
 
--				     codel_skb_dequeue_t dequeue_func,
 
--				     u32 *backlog)
 
-+				     codel_skb_dequeue_t dequeue_func)
 
- {
 
- 	struct sk_buff *skb = dequeue_func(vars, sch);
 
- 	codel_time_t now;
 
-@@ -261,7 +260,7 @@ static struct sk_buff *codel_dequeue(str
 
- 		return skb;
 
- 	}
 
- 	now = codel_get_time();
 
--	drop = codel_should_drop(skb, backlog, vars, params, stats, now);
 
-+	drop = codel_should_drop(skb, sch, vars, params, stats, now);
 
- 	if (vars->dropping) {
 
- 		if (!drop) {
 
- 			/* sojourn time below target - leave dropping state */
 
-@@ -292,7 +291,7 @@ static struct sk_buff *codel_dequeue(str
 
- 				qdisc_drop(skb, sch);
 
- 				stats->drop_count++;
 
- 				skb = dequeue_func(vars, sch);
 
--				if (!codel_should_drop(skb, backlog,
 
-+				if (!codel_should_drop(skb, sch,
 
- 						       vars, params, stats, now)) {
 
- 					/* leave dropping state */
 
- 					vars->dropping = false;
 
-@@ -313,7 +312,7 @@ static struct sk_buff *codel_dequeue(str
 
- 			stats->drop_count++;
 
- 
- 			skb = dequeue_func(vars, sch);
 
--			drop = codel_should_drop(skb, backlog, vars, params,
 
-+			drop = codel_should_drop(skb, sch, vars, params,
 
- 						 stats, now);
 
- 		}
 
- 		vars->dropping = true;
 
---- a/net/sched/sch_codel.c
 
-+++ b/net/sched/sch_codel.c
 
-@@ -77,8 +77,8 @@ static struct sk_buff *codel_qdisc_deque
 
- 	struct codel_sched_data *q = qdisc_priv(sch);
 
- 	struct sk_buff *skb;
 
- 
--	skb = codel_dequeue(sch, &q->params, &q->vars, &q->stats,
 
--			    dequeue, &sch->qstats.backlog);
 
-+	skb = codel_dequeue(sch, &q->params, &q->vars, &q->stats, dequeue);
 
-+
 
- 	/* We cant call qdisc_tree_decrease_qlen() if our qlen is 0,
 
- 	 * or HTB crashes. Defer it for next round.
 
- 	 */
 
---- a/net/sched/sch_fq_codel.c
 
-+++ b/net/sched/sch_fq_codel.c
 
-@@ -217,13 +217,14 @@ static int fq_codel_enqueue(struct sk_bu
 
-  */
 
- static struct sk_buff *dequeue(struct codel_vars *vars, struct Qdisc *sch)
 
- {
 
-+	struct fq_codel_sched_data *q = qdisc_priv(sch);
 
- 	struct fq_codel_flow *flow;
 
- 	struct sk_buff *skb = NULL;
 
- 
- 	flow = container_of(vars, struct fq_codel_flow, cvars);
 
- 	if (flow->head) {
 
- 		skb = dequeue_head(flow);
 
--		sch->qstats.backlog -= qdisc_pkt_len(skb);
 
-+		q->backlogs[flow - q->flows] -= qdisc_pkt_len(skb);
 
- 		sch->q.qlen--;
 
- 	}
 
- 	return skb;
 
-@@ -256,7 +257,7 @@ begin:
 
- 	prev_ecn_mark = q->cstats.ecn_mark;
 
- 
- 	skb = codel_dequeue(sch, &q->cparams, &flow->cvars, &q->cstats,
 
--			    dequeue, &q->backlogs[flow - q->flows]);
 
-+			    dequeue);
 
- 
- 	flow->dropped += q->cstats.drop_count - prev_drop_count;
 
- 	flow->dropped += q->cstats.ecn_mark - prev_ecn_mark;

+ 0 - 603
target/linux/generic/patches-3.3/047-spi_message_queue.patch
View File 

@@ -1,603 +0,0 @@
 
-commit ffbbdd21329f3e15eeca6df2d4bc11c04d9d91c0
 
-Author: Linus Walleij <[email protected]>
 
-Date:   Wed Feb 22 10:05:38 2012 +0100
 
-
 
-    spi: create a message queueing infrastructure
 
-    
-    This rips the message queue in the PL022 driver out and pushes
 
-    it into (optional) common infrastructure. Drivers that want to
 
-    use the message pumping thread will need to define the new
 
-    per-messags transfer methods and leave the deprecated transfer()
 
-    method as NULL.
 
-    
-    Most of the design is described in the documentation changes that
 
-    are included in this patch.
 
-    
-    Since there is a queue that need to be stopped when the system
 
-    is suspending/resuming, two new calls are implemented for the
 
-    device drivers to call in their suspend()/resume() functions:
 
-    spi_master_suspend() and spi_master_resume().
 
-    
-    ChangeLog v1->v2:
 
-    - Remove Kconfig entry and do not make the queue support optional
 
-      at all, instead be more agressive and have it as part of the
 
-      compulsory infrastructure.
 
-    - If the .transfer() method is implemented, delete print a small
 
-      deprecation notice and do not start the transfer pump.
 
-    - Fix a bitrotted comment.
 
-    ChangeLog v2->v3:
 
-    - Fix up a problematic sequence courtesy of Chris Blair.
 
-    - Stop rather than destroy the queue on suspend() courtesy of
 
-      Chris Blair.
 
-    
-    Signed-off-by: Chris Blair <[email protected]>
 
-    Signed-off-by: Linus Walleij <[email protected]>
 
-    Tested-by: Mark Brown <[email protected]>
 
-    Reviewed-by: Mark Brown <[email protected]>
 
-    Signed-off-by: Grant Likely <[email protected]>
 
-
 
-[Florian: dropped the changes on drivers/spi/spi-pl022.c, removed
 
-the dev_info() about unqueued drivers still using the master function]
 
-
 
---- a/Documentation/spi/spi-summary
 
-+++ b/Documentation/spi/spi-summary
 
-@@ -1,7 +1,7 @@
 
- Overview of Linux kernel SPI support
 
- ====================================
 
- 
--21-May-2007
 
-+02-Feb-2012
 
- 
- What is SPI?
 
- ------------
 
-@@ -483,9 +483,9 @@ also initialize its own internal state.
 
- and those methods.)
 
- 
- After you initialize the spi_master, then use spi_register_master() to
 
--publish it to the rest of the system.  At that time, device nodes for
 
--the controller and any predeclared spi devices will be made available,
 
--and the driver model core will take care of binding them to drivers.
 
-+publish it to the rest of the system. At that time, device nodes for the
 
-+controller and any predeclared spi devices will be made available, and
 
-+the driver model core will take care of binding them to drivers.
 
- 
- If you need to remove your SPI controller driver, spi_unregister_master()
 
- will reverse the effect of spi_register_master().
 
-@@ -521,21 +521,53 @@ SPI MASTER METHODS
 
- 		** When you code setup(), ASSUME that the controller
 
- 		** is actively processing transfers for another device.
 
- 
--    master->transfer(struct spi_device *spi, struct spi_message *message)
 
--    	This must not sleep.  Its responsibility is arrange that the
 
--	transfer happens and its complete() callback is issued.  The two
 
--	will normally happen later, after other transfers complete, and
 
--	if the controller is idle it will need to be kickstarted.
 
--
 
-     master->cleanup(struct spi_device *spi)
 
- 	Your controller driver may use spi_device.controller_state to hold
 
- 	state it dynamically associates with that device.  If you do that,
 
- 	be sure to provide the cleanup() method to free that state.
 
- 
-+    master->prepare_transfer_hardware(struct spi_master *master)
 
-+	This will be called by the queue mechanism to signal to the driver
 
-+	that a message is coming in soon, so the subsystem requests the
 
-+	driver to prepare the transfer hardware by issuing this call.
 
-+	This may sleep.
 
-+
 
-+    master->unprepare_transfer_hardware(struct spi_master *master)
 
-+	This will be called by the queue mechanism to signal to the driver
 
-+	that there are no more messages pending in the queue and it may
 
-+	relax the hardware (e.g. by power management calls). This may sleep.
 
-+
 
-+    master->transfer_one_message(struct spi_master *master,
 
-+				 struct spi_message *mesg)
 
-+	The subsystem calls the driver to transfer a single message while
 
-+	queuing transfers that arrive in the meantime. When the driver is
 
-+	finished with this message, it must call
 
-+	spi_finalize_current_message() so the subsystem can issue the next
 
-+	transfer. This may sleep.
 
-+
 
-+    DEPRECATED METHODS
 
-+
 
-+    master->transfer(struct spi_device *spi, struct spi_message *message)
 
-+	This must not sleep. Its responsibility is arrange that the
 
-+	transfer happens and its complete() callback is issued. The two
 
-+	will normally happen later, after other transfers complete, and
 
-+	if the controller is idle it will need to be kickstarted. This
 
-+	method is not used on queued controllers and must be NULL if
 
-+	transfer_one_message() and (un)prepare_transfer_hardware() are
 
-+	implemented.
 
-+
 
- 
- SPI MESSAGE QUEUE
 
- 
--The bulk of the driver will be managing the I/O queue fed by transfer().
 
-+If you are happy with the standard queueing mechanism provided by the
 
-+SPI subsystem, just implement the queued methods specified above. Using
 
-+the message queue has the upside of centralizing a lot of code and
 
-+providing pure process-context execution of methods. The message queue
 
-+can also be elevated to realtime priority on high-priority SPI traffic.
 
-+
 
-+Unless the queueing mechanism in the SPI subsystem is selected, the bulk
 
-+of the driver will be managing the I/O queue fed by the now deprecated
 
-+function transfer().
 
- 
- That queue could be purely conceptual.  For example, a driver used only
 
- for low-frequency sensor access might be fine using synchronous PIO.
 
-@@ -561,4 +593,6 @@ Stephen Street
 
- Mark Underwood
 
- Andrew Victor
 
- Vitaly Wool
 
--
 
-+Grant Likely
 
-+Mark Brown
 
-+Linus Walleij
 
---- a/drivers/spi/spi.c
 
-+++ b/drivers/spi/spi.c
 
-@@ -30,6 +30,9 @@
 
- #include <linux/of_spi.h>
 
- #include <linux/pm_runtime.h>
 
- #include <linux/export.h>
 
-+#include <linux/sched.h>
 
-+#include <linux/delay.h>
 
-+#include <linux/kthread.h>
 
- 
- static void spidev_release(struct device *dev)
 
- {
 
-@@ -507,6 +510,293 @@ spi_register_board_info(struct spi_board
 
- 
- /*-------------------------------------------------------------------------*/
 
- 
-+/**
 
-+ * spi_pump_messages - kthread work function which processes spi message queue
 
-+ * @work: pointer to kthread work struct contained in the master struct
 
-+ *
 
-+ * This function checks if there is any spi message in the queue that
 
-+ * needs processing and if so call out to the driver to initialize hardware
 
-+ * and transfer each message.
 
-+ *
 
-+ */
 
-+static void spi_pump_messages(struct kthread_work *work)
 
-+{
 
-+	struct spi_master *master =
 
-+		container_of(work, struct spi_master, pump_messages);
 
-+	unsigned long flags;
 
-+	bool was_busy = false;
 
-+	int ret;
 
-+
 
-+	/* Lock queue and check for queue work */
 
-+	spin_lock_irqsave(&master->queue_lock, flags);
 
-+	if (list_empty(&master->queue) || !master->running) {
 
-+		if (master->busy) {
 
-+			ret = master->unprepare_transfer_hardware(master);
 
-+			if (ret) {
 
-+				dev_err(&master->dev,
 
-+					"failed to unprepare transfer hardware\n");
 
-+				return;
 
-+			}
 
-+		}
 
-+		master->busy = false;
 
-+		spin_unlock_irqrestore(&master->queue_lock, flags);
 
-+		return;
 
-+	}
 
-+
 
-+	/* Make sure we are not already running a message */
 
-+	if (master->cur_msg) {
 
-+		spin_unlock_irqrestore(&master->queue_lock, flags);
 
-+		return;
 
-+	}
 
-+	/* Extract head of queue */
 
-+	master->cur_msg =
 
-+	    list_entry(master->queue.next, struct spi_message, queue);
 
-+
 
-+	list_del_init(&master->cur_msg->queue);
 
-+	if (master->busy)
 
-+		was_busy = true;
 
-+	else
 
-+		master->busy = true;
 
-+	spin_unlock_irqrestore(&master->queue_lock, flags);
 
-+
 
-+	if (!was_busy) {
 
-+		ret = master->prepare_transfer_hardware(master);
 
-+		if (ret) {
 
-+			dev_err(&master->dev,
 
-+				"failed to prepare transfer hardware\n");
 
-+			return;
 
-+		}
 
-+	}
 
-+
 
-+	ret = master->transfer_one_message(master, master->cur_msg);
 
-+	if (ret) {
 
-+		dev_err(&master->dev,
 
-+			"failed to transfer one message from queue\n");
 
-+		return;
 
-+	}
 
-+}
 
-+
 
-+static int spi_init_queue(struct spi_master *master)
 
-+{
 
-+	struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
 
-+
 
-+	INIT_LIST_HEAD(&master->queue);
 
-+	spin_lock_init(&master->queue_lock);
 
-+
 
-+	master->running = false;
 
-+	master->busy = false;
 
-+
 
-+	init_kthread_worker(&master->kworker);
 
-+	master->kworker_task = kthread_run(kthread_worker_fn,
 
-+					   &master->kworker,
 
-+					   dev_name(&master->dev));
 
-+	if (IS_ERR(master->kworker_task)) {
 
-+		dev_err(&master->dev, "failed to create message pump task\n");
 
-+		return -ENOMEM;
 
-+	}
 
-+	init_kthread_work(&master->pump_messages, spi_pump_messages);
 
-+
 
-+	/*
 
-+	 * Master config will indicate if this controller should run the
 
-+	 * message pump with high (realtime) priority to reduce the transfer
 
-+	 * latency on the bus by minimising the delay between a transfer
 
-+	 * request and the scheduling of the message pump thread. Without this
 
-+	 * setting the message pump thread will remain at default priority.
 
-+	 */
 
-+	if (master->rt) {
 
-+		dev_info(&master->dev,
 
-+			"will run message pump with realtime priority\n");
 
-+		sched_setscheduler(master->kworker_task, SCHED_FIFO, &param);
 
-+	}
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+/**
 
-+ * spi_get_next_queued_message() - called by driver to check for queued
 
-+ * messages
 
-+ * @master: the master to check for queued messages
 
-+ *
 
-+ * If there are more messages in the queue, the next message is returned from
 
-+ * this call.
 
-+ */
 
-+struct spi_message *spi_get_next_queued_message(struct spi_master *master)
 
-+{
 
-+	struct spi_message *next;
 
-+	unsigned long flags;
 
-+
 
-+	/* get a pointer to the next message, if any */
 
-+	spin_lock_irqsave(&master->queue_lock, flags);
 
-+	if (list_empty(&master->queue))
 
-+		next = NULL;
 
-+	else
 
-+		next = list_entry(master->queue.next,
 
-+				  struct spi_message, queue);
 
-+	spin_unlock_irqrestore(&master->queue_lock, flags);
 
-+
 
-+	return next;
 
-+}
 
-+EXPORT_SYMBOL_GPL(spi_get_next_queued_message);
 
-+
 
-+/**
 
-+ * spi_finalize_current_message() - the current message is complete
 
-+ * @master: the master to return the message to
 
-+ *
 
-+ * Called by the driver to notify the core that the message in the front of the
 
-+ * queue is complete and can be removed from the queue.
 
-+ */
 
-+void spi_finalize_current_message(struct spi_master *master)
 
-+{
 
-+	struct spi_message *mesg;
 
-+	unsigned long flags;
 
-+
 
-+	spin_lock_irqsave(&master->queue_lock, flags);
 
-+	mesg = master->cur_msg;
 
-+	master->cur_msg = NULL;
 
-+
 
-+	queue_kthread_work(&master->kworker, &master->pump_messages);
 
-+	spin_unlock_irqrestore(&master->queue_lock, flags);
 
-+
 
-+	mesg->state = NULL;
 
-+	if (mesg->complete)
 
-+		mesg->complete(mesg->context);
 
-+}
 
-+EXPORT_SYMBOL_GPL(spi_finalize_current_message);
 
-+
 
-+static int spi_start_queue(struct spi_master *master)
 
-+{
 
-+	unsigned long flags;
 
-+
 
-+	spin_lock_irqsave(&master->queue_lock, flags);
 
-+
 
-+	if (master->running || master->busy) {
 
-+		spin_unlock_irqrestore(&master->queue_lock, flags);
 
-+		return -EBUSY;
 
-+	}
 
-+
 
-+	master->running = true;
 
-+	master->cur_msg = NULL;
 
-+	spin_unlock_irqrestore(&master->queue_lock, flags);
 
-+
 
-+	queue_kthread_work(&master->kworker, &master->pump_messages);
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static int spi_stop_queue(struct spi_master *master)
 
-+{
 
-+	unsigned long flags;
 
-+	unsigned limit = 500;
 
-+	int ret = 0;
 
-+
 
-+	spin_lock_irqsave(&master->queue_lock, flags);
 
-+
 
-+	/*
 
-+	 * This is a bit lame, but is optimized for the common execution path.
 
-+	 * A wait_queue on the master->busy could be used, but then the common
 
-+	 * execution path (pump_messages) would be required to call wake_up or
 
-+	 * friends on every SPI message. Do this instead.
 
-+	 */
 
-+	while ((!list_empty(&master->queue) || master->busy) && limit--) {
 
-+		spin_unlock_irqrestore(&master->queue_lock, flags);
 
-+		msleep(10);
 
-+		spin_lock_irqsave(&master->queue_lock, flags);
 
-+	}
 
-+
 
-+	if (!list_empty(&master->queue) || master->busy)
 
-+		ret = -EBUSY;
 
-+	else
 
-+		master->running = false;
 
-+
 
-+	spin_unlock_irqrestore(&master->queue_lock, flags);
 
-+
 
-+	if (ret) {
 
-+		dev_warn(&master->dev,
 
-+			 "could not stop message queue\n");
 
-+		return ret;
 
-+	}
 
-+	return ret;
 
-+}
 
-+
 
-+static int spi_destroy_queue(struct spi_master *master)
 
-+{
 
-+	int ret;
 
-+
 
-+	ret = spi_stop_queue(master);
 
-+
 
-+	/*
 
-+	 * flush_kthread_worker will block until all work is done.
 
-+	 * If the reason that stop_queue timed out is that the work will never
 
-+	 * finish, then it does no good to call flush/stop thread, so
 
-+	 * return anyway.
 
-+	 */
 
-+	if (ret) {
 
-+		dev_err(&master->dev, "problem destroying queue\n");
 
-+		return ret;
 
-+	}
 
-+
 
-+	flush_kthread_worker(&master->kworker);
 
-+	kthread_stop(master->kworker_task);
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+/**
 
-+ * spi_queued_transfer - transfer function for queued transfers
 
-+ * @spi: spi device which is requesting transfer
 
-+ * @msg: spi message which is to handled is queued to driver queue
 
-+ */
 
-+static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
 
-+{
 
-+	struct spi_master *master = spi->master;
 
-+	unsigned long flags;
 
-+
 
-+	spin_lock_irqsave(&master->queue_lock, flags);
 
-+
 
-+	if (!master->running) {
 
-+		spin_unlock_irqrestore(&master->queue_lock, flags);
 
-+		return -ESHUTDOWN;
 
-+	}
 
-+	msg->actual_length = 0;
 
-+	msg->status = -EINPROGRESS;
 
-+
 
-+	list_add_tail(&msg->queue, &master->queue);
 
-+	if (master->running && !master->busy)
 
-+		queue_kthread_work(&master->kworker, &master->pump_messages);
 
-+
 
-+	spin_unlock_irqrestore(&master->queue_lock, flags);
 
-+	return 0;
 
-+}
 
-+
 
-+static int spi_master_initialize_queue(struct spi_master *master)
 
-+{
 
-+	int ret;
 
-+
 
-+	master->queued = true;
 
-+	master->transfer = spi_queued_transfer;
 
-+
 
-+	/* Initialize and start queue */
 
-+	ret = spi_init_queue(master);
 
-+	if (ret) {
 
-+		dev_err(&master->dev, "problem initializing queue\n");
 
-+		goto err_init_queue;
 
-+	}
 
-+	ret = spi_start_queue(master);
 
-+	if (ret) {
 
-+		dev_err(&master->dev, "problem starting queue\n");
 
-+		goto err_start_queue;
 
-+	}
 
-+
 
-+	return 0;
 
-+
 
-+err_start_queue:
 
-+err_init_queue:
 
-+	spi_destroy_queue(master);
 
-+	return ret;
 
-+}
 
-+
 
-+/*-------------------------------------------------------------------------*/
 
-+
 
- static void spi_master_release(struct device *dev)
 
- {
 
- 	struct spi_master *master;
 
-@@ -522,6 +812,7 @@ static struct class spi_master_class = {
 
- };
 
- 
- 
-+
 
- /**
 
-  * spi_alloc_master - allocate SPI master controller
 
-  * @dev: the controller, possibly using the platform_bus
 
-@@ -621,6 +912,15 @@ int spi_register_master(struct spi_maste
 
- 	dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),
 
- 			dynamic ? " (dynamic)" : "");
 
- 
-+	/* If we're using a queued driver, start the queue */
 
-+	if (!master->transfer) {
 
-+		status = spi_master_initialize_queue(master);
 
-+		if (status) {
 
-+			device_unregister(&master->dev);
 
-+			goto done;
 
-+		}
 
-+	}
 
-+
 
- 	mutex_lock(&board_lock);
 
- 	list_add_tail(&master->list, &spi_master_list);
 
- 	list_for_each_entry(bi, &board_list, list)
 
-@@ -636,7 +936,6 @@ done:
 
- }
 
- EXPORT_SYMBOL_GPL(spi_register_master);
 
- 
--
 
- static int __unregister(struct device *dev, void *null)
 
- {
 
- 	spi_unregister_device(to_spi_device(dev));
 
-@@ -657,6 +956,11 @@ void spi_unregister_master(struct spi_ma
 
- {
 
- 	int dummy;
 
- 
-+	if (master->queued) {
 
-+		if (spi_destroy_queue(master))
 
-+			dev_err(&master->dev, "queue remove failed\n");
 
-+	}
 
-+
 
- 	mutex_lock(&board_lock);
 
- 	list_del(&master->list);
 
- 	mutex_unlock(&board_lock);
 
-@@ -666,6 +970,37 @@ void spi_unregister_master(struct spi_ma
 
- }
 
- EXPORT_SYMBOL_GPL(spi_unregister_master);
 
- 
-+int spi_master_suspend(struct spi_master *master)
 
-+{
 
-+	int ret;
 
-+
 
-+	/* Basically no-ops for non-queued masters */
 
-+	if (!master->queued)
 
-+		return 0;
 
-+
 
-+	ret = spi_stop_queue(master);
 
-+	if (ret)
 
-+		dev_err(&master->dev, "queue stop failed\n");
 
-+
 
-+	return ret;
 
-+}
 
-+EXPORT_SYMBOL_GPL(spi_master_suspend);
 
-+
 
-+int spi_master_resume(struct spi_master *master)
 
-+{
 
-+	int ret;
 
-+
 
-+	if (!master->queued)
 
-+		return 0;
 
-+
 
-+	ret = spi_start_queue(master);
 
-+	if (ret)
 
-+		dev_err(&master->dev, "queue restart failed\n");
 
-+
 
-+	return ret;
 
-+}
 
-+EXPORT_SYMBOL_GPL(spi_master_resume);
 
-+
 
- static int __spi_master_match(struct device *dev, void *data)
 
- {
 
- 	struct spi_master *m;
 
---- a/include/linux/spi/spi.h
 
-+++ b/include/linux/spi/spi.h
 
-@@ -22,6 +22,7 @@
 
- #include <linux/device.h>
 
- #include <linux/mod_devicetable.h>
 
- #include <linux/slab.h>
 
-+#include <linux/kthread.h>
 
- 
- /*
 
-  * INTERFACES between SPI master-side drivers and SPI infrastructure.
 
-@@ -235,6 +236,27 @@ static inline void spi_unregister_driver
 
-  *	the device whose settings are being modified.
 
-  * @transfer: adds a message to the controller's transfer queue.
 
-  * @cleanup: frees controller-specific state
 
-+ * @queued: whether this master is providing an internal message queue
 
-+ * @kworker: thread struct for message pump
 
-+ * @kworker_task: pointer to task for message pump kworker thread
 
-+ * @pump_messages: work struct for scheduling work to the message pump
 
-+ * @queue_lock: spinlock to syncronise access to message queue
 
-+ * @queue: message queue
 
-+ * @cur_msg: the currently in-flight message
 
-+ * @busy: message pump is busy
 
-+ * @running: message pump is running
 
-+ * @rt: whether this queue is set to run as a realtime task
 
-+ * @prepare_transfer_hardware: a message will soon arrive from the queue
 
-+ *	so the subsystem requests the driver to prepare the transfer hardware
 
-+ *	by issuing this call
 
-+ * @transfer_one_message: the subsystem calls the driver to transfer a single
 
-+ *	message while queuing transfers that arrive in the meantime. When the
 
-+ *	driver is finished with this message, it must call
 
-+ *	spi_finalize_current_message() so the subsystem can issue the next
 
-+ *	transfer
 
-+ * @prepare_transfer_hardware: there are currently no more messages on the
 
-+ *	queue so the subsystem notifies the driver that it may relax the
 
-+ *	hardware by issuing this call
 
-  *
 
-  * Each SPI master controller can communicate with one or more @spi_device
 
-  * children.  These make a small bus, sharing MOSI, MISO and SCK signals
 
-@@ -318,6 +340,28 @@ struct spi_master {
 
- 
- 	/* called on release() to free memory provided by spi_master */
 
- 	void			(*cleanup)(struct spi_device *spi);
 
-+
 
-+	/*
 
-+	 * These hooks are for drivers that want to use the generic
 
-+	 * master transfer queueing mechanism. If these are used, the
 
-+	 * transfer() function above must NOT be specified by the driver.
 
-+	 * Over time we expect SPI drivers to be phased over to this API.
 
-+	 */
 
-+	bool				queued;
 
-+	struct kthread_worker		kworker;
 
-+	struct task_struct		*kworker_task;
 
-+	struct kthread_work		pump_messages;
 
-+	spinlock_t			queue_lock;
 
-+	struct list_head		queue;
 
-+	struct spi_message		*cur_msg;
 
-+	bool				busy;
 
-+	bool				running;
 
-+	bool				rt;
 
-+
 
-+	int (*prepare_transfer_hardware)(struct spi_master *master);
 
-+	int (*transfer_one_message)(struct spi_master *master,
 
-+				    struct spi_message *mesg);
 
-+	int (*unprepare_transfer_hardware)(struct spi_master *master);
 
- };
 
- 
- static inline void *spi_master_get_devdata(struct spi_master *master)
 
-@@ -343,6 +387,13 @@ static inline void spi_master_put(struct
 
- 		put_device(&master->dev);
 
- }
 
- 
-+/* PM calls that need to be issued by the driver */
 
-+extern int spi_master_suspend(struct spi_master *master);
 
-+extern int spi_master_resume(struct spi_master *master);
 
-+
 
-+/* Calls the driver make to interact with the message queue */
 
-+extern struct spi_message *spi_get_next_queued_message(struct spi_master *master);
 
-+extern void spi_finalize_current_message(struct spi_master *master);
 
- 
- /* the spi driver core manages memory for the spi_master classdev */
 
- extern struct spi_master *

+ 0 - 39
target/linux/generic/patches-3.3/048-spi-Dont-call-prepare-unprepare-transfer-if-not-popu.patch
View File 

@@ -1,39 +0,0 @@
 
-From 7dfd2bd70228d1f8d468d58cb3d12ecd618479ed Mon Sep 17 00:00:00 2001
 
-From: Shubhrajyoti D <[email protected]>
 
-Date: Thu, 10 May 2012 19:20:41 +0530
 
-Subject: [PATCH] spi: Dont call prepare/unprepare transfer if not populated
 
-
 
-Currently the prepare/unprepare transfer are called unconditionally.
 
-The assumption is that every driver using the spi core queue infrastructure
 
-has to populate the prepare and unprepare functions. This encourages
 
-drivers to populate empty functions to prevent crashing.
 
-This patch prevents the call to prepare/unprepare if not populated.
 
-
 
-Signed-off-by: Shubhrajyoti D <[email protected]>
 
-Acked-by: Linus Walleij <[email protected]>
 
-[grant.likely: fix whitespace defect]
 
-Signed-off-by: Grant Likely <[email protected]>
 
----
 
- drivers/spi/spi.c |    4 ++--
 
- 1 files changed, 2 insertions(+), 2 deletions(-)
 
-
 
---- a/drivers/spi/spi.c
 
-+++ b/drivers/spi/spi.c
 
-@@ -530,7 +530,7 @@ static void spi_pump_messages(struct kth
 
- 	/* Lock queue and check for queue work */
 
- 	spin_lock_irqsave(&master->queue_lock, flags);
 
- 	if (list_empty(&master->queue) || !master->running) {
 
--		if (master->busy) {
 
-+		if (master->busy && master->unprepare_transfer_hardware) {
 
- 			ret = master->unprepare_transfer_hardware(master);
 
- 			if (ret) {
 
- 				dev_err(&master->dev,
 
-@@ -559,7 +559,7 @@ static void spi_pump_messages(struct kth
 
- 		master->busy = true;
 
- 	spin_unlock_irqrestore(&master->queue_lock, flags);
 
- 
--	if (!was_busy) {
 
-+	if (!was_busy && master->prepare_transfer_hardware) {
 
- 		ret = master->prepare_transfer_hardware(master);
 
- 		if (ret) {
 
- 			dev_err(&master->dev,

+ 0 - 52
target/linux/generic/patches-3.3/049-codel-refine-one-condition-to-avoid-a-nul-rec_inv_sqrt.patch
View File 

@@ -1,52 +0,0 @@
 
-From b8fc328668a74e1314a19266755a54abd875e5a6 Mon Sep 17 00:00:00 2001
 
-From: Eric Dumazet <[email protected]>
 
-Date: Sun, 29 Jul 2012 20:52:21 +0000
 
-Subject: [PATCH] codel: refine one condition to avoid a nul rec_inv_sqrt
 
-
 
-commit 2359a47671fc4fb0fe5e9945f76c2cb10792c0f8 upstream.
 
-
 
-One condition before codel_Newton_step() was not good if
 
-we never left the dropping state for a flow. As a result
 
-rec_inv_sqrt was 0, instead of the ~0 initial value.
 
-
 
-codel control law was then set to a very aggressive mode, dropping
 
-many packets before reaching 'target' and recovering from this problem.
 
-
 
-To keep codel_vars_init() as efficient as possible, refine
 
-the condition to make sure rec_inv_sqrt initial value is correct
 
-
 
-Many thanks to Anton Mich for discovering the issue and suggesting
 
-a fix.
 
-
 
-Reported-by: Anton Mich <[email protected]>
 
-Signed-off-by: Eric Dumazet <[email protected]>
 
-Signed-off-by: David S. Miller <[email protected]>
 
----
 
- include/net/codel.h |    8 ++++++--
 
- 1 file changed, 6 insertions(+), 2 deletions(-)
 
-
 
---- a/include/net/codel.h
 
-+++ b/include/net/codel.h
 
-@@ -305,6 +305,8 @@ static struct sk_buff *codel_dequeue(str
 
- 			}
 
- 		}
 
- 	} else if (drop) {
 
-+		u32 delta;
 
-+
 
- 		if (params->ecn && INET_ECN_set_ce(skb)) {
 
- 			stats->ecn_mark++;
 
- 		} else {
 
-@@ -320,9 +322,11 @@ static struct sk_buff *codel_dequeue(str
 
- 		 * assume that the drop rate that controlled the queue on the
 
- 		 * last cycle is a good starting point to control it now.
 
- 		 */
 
--		if (codel_time_before(now - vars->drop_next,
 
-+		delta = vars->count - vars->lastcount;
 
-+		if (delta > 1 &&
 
-+		    codel_time_before(now - vars->drop_next,
 
- 				      16 * params->interval)) {
 
--			vars->count = (vars->count - vars->lastcount) | 1;
 
-+			vars->count = delta;
 
- 			/* we dont care if rec_inv_sqrt approximation
 
- 			 * is not very precise :
 
- 			 * Next Newton steps will correct it quadratically.

+ 0 - 783
target/linux/generic/patches-3.3/050-rng_git_backport.patch
View File 

@@ -1,783 +0,0 @@
 
---- a/drivers/char/random.c
 
-+++ b/drivers/char/random.c
 
-@@ -125,21 +125,26 @@
 
-  * The current exported interfaces for gathering environmental noise
 
-  * from the devices are:
 
-  *
 
-+ *	void add_device_randomness(const void *buf, unsigned int size);
 
-  * 	void add_input_randomness(unsigned int type, unsigned int code,
 
-  *                                unsigned int value);
 
-- * 	void add_interrupt_randomness(int irq);
 
-+ *	void add_interrupt_randomness(int irq, int irq_flags);
 
-  * 	void add_disk_randomness(struct gendisk *disk);
 
-  *
 
-  * add_input_randomness() uses the input layer interrupt timing, as well as
 
-  * the event type information from the hardware.
 
-  *
 
-- * add_interrupt_randomness() uses the inter-interrupt timing as random
 
-- * inputs to the entropy pool.  Note that not all interrupts are good
 
-- * sources of randomness!  For example, the timer interrupts is not a
 
-- * good choice, because the periodicity of the interrupts is too
 
-- * regular, and hence predictable to an attacker.  Network Interface
 
-- * Controller interrupts are a better measure, since the timing of the
 
-- * NIC interrupts are more unpredictable.
 
-+ * add_interrupt_randomness() uses the interrupt timing as random
 
-+ * inputs to the entropy pool. Using the cycle counters and the irq source
 
-+ * as inputs, it feeds the randomness roughly once a second.
 
-+ *
 
-+ * add_device_randomness() is for adding data to the random pool that
 
-+ * is likely to differ between two devices (or possibly even per boot).
 
-+ * This would be things like MAC addresses or serial numbers, or the
 
-+ * read-out of the RTC. This does *not* add any actual entropy to the
 
-+ * pool, but it initializes the pool to different values for devices
 
-+ * that might otherwise be identical and have very little entropy
 
-+ * available to them (particularly common in the embedded world).
 
-  *
 
-  * add_disk_randomness() uses what amounts to the seek time of block
 
-  * layer request events, on a per-disk_devt basis, as input to the
 
-@@ -248,6 +253,7 @@
 
- #include <linux/percpu.h>
 
- #include <linux/cryptohash.h>
 
- #include <linux/fips.h>
 
-+#include <linux/ptrace.h>
 
- 
- #ifdef CONFIG_GENERIC_HARDIRQS
 
- # include <linux/irq.h>
 
-@@ -256,8 +262,12 @@
 
- #include <asm/processor.h>
 
- #include <asm/uaccess.h>
 
- #include <asm/irq.h>
 
-+#include <asm/irq_regs.h>
 
- #include <asm/io.h>
 
- 
-+#define CREATE_TRACE_POINTS
 
-+#include <trace/events/random.h>
 
-+
 
- /*
 
-  * Configuration information
 
-  */
 
-@@ -420,8 +430,10 @@ struct entropy_store {
 
- 	/* read-write data: */
 
- 	spinlock_t lock;
 
- 	unsigned add_ptr;
 
-+	unsigned input_rotate;
 
- 	int entropy_count;
 
--	int input_rotate;
 
-+	int entropy_total;
 
-+	unsigned int initialized:1;
 
- 	__u8 last_data[EXTRACT_SIZE];
 
- };
 
- 
-@@ -454,6 +466,10 @@ static struct entropy_store nonblocking_
 
- 	.pool = nonblocking_pool_data
 
- };
 
- 
-+static __u32 const twist_table[8] = {
 
-+	0x00000000, 0x3b6e20c8, 0x76dc4190, 0x4db26158,
 
-+	0xedb88320, 0xd6d6a3e8, 0x9b64c2b0, 0xa00ae278 };
 
-+
 
- /*
 
-  * This function adds bytes into the entropy "pool".  It does not
 
-  * update the entropy estimate.  The caller should call
 
-@@ -464,29 +480,24 @@ static struct entropy_store nonblocking_
 
-  * it's cheap to do so and helps slightly in the expected case where
 
-  * the entropy is concentrated in the low-order bits.
 
-  */
 
--static void mix_pool_bytes_extract(struct entropy_store *r, const void *in,
 
--				   int nbytes, __u8 out[64])
 
-+static void _mix_pool_bytes(struct entropy_store *r, const void *in,
 
-+			    int nbytes, __u8 out[64])
 
- {
 
--	static __u32 const twist_table[8] = {
 
--		0x00000000, 0x3b6e20c8, 0x76dc4190, 0x4db26158,
 
--		0xedb88320, 0xd6d6a3e8, 0x9b64c2b0, 0xa00ae278 };
 
- 	unsigned long i, j, tap1, tap2, tap3, tap4, tap5;
 
- 	int input_rotate;
 
- 	int wordmask = r->poolinfo->poolwords - 1;
 
- 	const char *bytes = in;
 
- 	__u32 w;
 
--	unsigned long flags;
 
- 
--	/* Taps are constant, so we can load them without holding r->lock.  */
 
- 	tap1 = r->poolinfo->tap1;
 
- 	tap2 = r->poolinfo->tap2;
 
- 	tap3 = r->poolinfo->tap3;
 
- 	tap4 = r->poolinfo->tap4;
 
- 	tap5 = r->poolinfo->tap5;
 
- 
--	spin_lock_irqsave(&r->lock, flags);
 
--	input_rotate = r->input_rotate;
 
--	i = r->add_ptr;
 
-+	smp_rmb();
 
-+	input_rotate = ACCESS_ONCE(r->input_rotate);
 
-+	i = ACCESS_ONCE(r->add_ptr);
 
- 
- 	/* mix one byte at a time to simplify size handling and churn faster */
 
- 	while (nbytes--) {
 
-@@ -513,19 +524,61 @@ static void mix_pool_bytes_extract(struc
 
- 		input_rotate += i ? 7 : 14;
 
- 	}
 
- 
--	r->input_rotate = input_rotate;
 
--	r->add_ptr = i;
 
-+	ACCESS_ONCE(r->input_rotate) = input_rotate;
 
-+	ACCESS_ONCE(r->add_ptr) = i;
 
-+	smp_wmb();
 
- 
- 	if (out)
 
- 		for (j = 0; j < 16; j++)
 
- 			((__u32 *)out)[j] = r->pool[(i - j) & wordmask];
 
-+}
 
-+
 
-+static void __mix_pool_bytes(struct entropy_store *r, const void *in,
 
-+			     int nbytes, __u8 out[64])
 
-+{
 
-+	trace_mix_pool_bytes_nolock(r->name, nbytes, _RET_IP_);
 
-+	_mix_pool_bytes(r, in, nbytes, out);
 
-+}
 
- 
-+static void mix_pool_bytes(struct entropy_store *r, const void *in,
 
-+			   int nbytes, __u8 out[64])
 
-+{
 
-+	unsigned long flags;
 
-+
 
-+	trace_mix_pool_bytes(r->name, nbytes, _RET_IP_);
 
-+	spin_lock_irqsave(&r->lock, flags);
 
-+	_mix_pool_bytes(r, in, nbytes, out);
 
- 	spin_unlock_irqrestore(&r->lock, flags);
 
- }
 
- 
--static void mix_pool_bytes(struct entropy_store *r, const void *in, int bytes)
 
-+struct fast_pool {
 
-+	__u32		pool[4];
 
-+	unsigned long	last;
 
-+	unsigned short	count;
 
-+	unsigned char	rotate;
 
-+	unsigned char	last_timer_intr;
 
-+};
 
-+
 
-+/*
 
-+ * This is a fast mixing routine used by the interrupt randomness
 
-+ * collector.  It's hardcoded for an 128 bit pool and assumes that any
 
-+ * locks that might be needed are taken by the caller.
 
-+ */
 
-+static void fast_mix(struct fast_pool *f, const void *in, int nbytes)
 
- {
 
--       mix_pool_bytes_extract(r, in, bytes, NULL);
 
-+	const char	*bytes = in;
 
-+	__u32		w;
 
-+	unsigned	i = f->count;
 
-+	unsigned	input_rotate = f->rotate;
 
-+
 
-+	while (nbytes--) {
 
-+		w = rol32(*bytes++, input_rotate & 31) ^ f->pool[i & 3] ^
 
-+			f->pool[(i + 1) & 3];
 
-+		f->pool[i & 3] = (w >> 3) ^ twist_table[w & 7];
 
-+		input_rotate += (i++ & 3) ? 7 : 14;
 
-+	}
 
-+	f->count = i;
 
-+	f->rotate = input_rotate;
 
- }
 
- 
- /*
 
-@@ -533,30 +586,38 @@ static void mix_pool_bytes(struct entrop
 
-  */
 
- static void credit_entropy_bits(struct entropy_store *r, int nbits)
 
- {
 
--	unsigned long flags;
 
--	int entropy_count;
 
-+	int entropy_count, orig;
 
- 
- 	if (!nbits)
 
- 		return;
 
- 
--	spin_lock_irqsave(&r->lock, flags);
 
--
 
- 	DEBUG_ENT("added %d entropy credits to %s\n", nbits, r->name);
 
--	entropy_count = r->entropy_count;
 
-+retry:
 
-+	entropy_count = orig = ACCESS_ONCE(r->entropy_count);
 
- 	entropy_count += nbits;
 
-+
 
- 	if (entropy_count < 0) {
 
- 		DEBUG_ENT("negative entropy/overflow\n");
 
- 		entropy_count = 0;
 
- 	} else if (entropy_count > r->poolinfo->POOLBITS)
 
- 		entropy_count = r->poolinfo->POOLBITS;
 
--	r->entropy_count = entropy_count;
 
-+	if (cmpxchg(&r->entropy_count, orig, entropy_count) != orig)
 
-+		goto retry;
 
-+
 
-+	if (!r->initialized && nbits > 0) {
 
-+		r->entropy_total += nbits;
 
-+		if (r->entropy_total > 128)
 
-+			r->initialized = 1;
 
-+	}
 
-+
 
-+	trace_credit_entropy_bits(r->name, nbits, entropy_count,
 
-+				  r->entropy_total, _RET_IP_);
 
- 
- 	/* should we wake readers? */
 
- 	if (r == &input_pool && entropy_count >= random_read_wakeup_thresh) {
 
- 		wake_up_interruptible(&random_read_wait);
 
- 		kill_fasync(&fasync, SIGIO, POLL_IN);
 
- 	}
 
--	spin_unlock_irqrestore(&r->lock, flags);
 
- }
 
- 
- /*********************************************************************
 
-@@ -609,6 +670,25 @@ static void set_timer_rand_state(unsigne
 
- }
 
- #endif
 
- 
-+/*
 
-+ * Add device- or boot-specific data to the input and nonblocking
 
-+ * pools to help initialize them to unique values.
 
-+ *
 
-+ * None of this adds any entropy, it is meant to avoid the
 
-+ * problem of the nonblocking pool having similar initial state
 
-+ * across largely identical devices.
 
-+ */
 
-+void add_device_randomness(const void *buf, unsigned int size)
 
-+{
 
-+	unsigned long time = get_cycles() ^ jiffies;
 
-+
 
-+	mix_pool_bytes(&input_pool, buf, size, NULL);
 
-+	mix_pool_bytes(&input_pool, &time, sizeof(time), NULL);
 
-+	mix_pool_bytes(&nonblocking_pool, buf, size, NULL);
 
-+	mix_pool_bytes(&nonblocking_pool, &time, sizeof(time), NULL);
 
-+}
 
-+EXPORT_SYMBOL(add_device_randomness);
 
-+
 
- static struct timer_rand_state input_timer_state;
 
- 
- /*
 
-@@ -637,13 +717,9 @@ static void add_timer_randomness(struct
 
- 		goto out;
 
- 
- 	sample.jiffies = jiffies;
 
--
 
--	/* Use arch random value, fall back to cycles */
 
--	if (!arch_get_random_int(&sample.cycles))
 
--		sample.cycles = get_cycles();
 
--
 
-+	sample.cycles = get_cycles();
 
- 	sample.num = num;
 
--	mix_pool_bytes(&input_pool, &sample, sizeof(sample));
 
-+	mix_pool_bytes(&input_pool, &sample, sizeof(sample), NULL);
 
- 
- 	/*
 
- 	 * Calculate number of bits of randomness we probably added.
 
-@@ -700,17 +776,48 @@ void add_input_randomness(unsigned int t
 
- }
 
- EXPORT_SYMBOL_GPL(add_input_randomness);
 
- 
--void add_interrupt_randomness(int irq)
 
-+static DEFINE_PER_CPU(struct fast_pool, irq_randomness);
 
-+
 
-+void add_interrupt_randomness(int irq, int irq_flags)
 
- {
 
--	struct timer_rand_state *state;
 
-+	struct entropy_store	*r;
 
-+	struct fast_pool	*fast_pool = &__get_cpu_var(irq_randomness);
 
-+	struct pt_regs		*regs = get_irq_regs();
 
-+	unsigned long		now = jiffies;
 
-+	__u32			input[4], cycles = get_cycles();
 
-+
 
-+	input[0] = cycles ^ jiffies;
 
-+	input[1] = irq;
 
-+	if (regs) {
 
-+		__u64 ip = instruction_pointer(regs);
 
-+		input[2] = ip;
 
-+		input[3] = ip >> 32;
 
-+	}
 
- 
--	state = get_timer_rand_state(irq);
 
-+	fast_mix(fast_pool, input, sizeof(input));
 
- 
--	if (state == NULL)
 
-+	if ((fast_pool->count & 1023) &&
 
-+	    !time_after(now, fast_pool->last + HZ))
 
- 		return;
 
- 
--	DEBUG_ENT("irq event %d\n", irq);
 
--	add_timer_randomness(state, 0x100 + irq);
 
-+	fast_pool->last = now;
 
-+
 
-+	r = nonblocking_pool.initialized ? &input_pool : &nonblocking_pool;
 
-+	__mix_pool_bytes(r, &fast_pool->pool, sizeof(fast_pool->pool), NULL);
 
-+	/*
 
-+	 * If we don't have a valid cycle counter, and we see
 
-+	 * back-to-back timer interrupts, then skip giving credit for
 
-+	 * any entropy.
 
-+	 */
 
-+	if (cycles == 0) {
 
-+		if (irq_flags & __IRQF_TIMER) {
 
-+			if (fast_pool->last_timer_intr)
 
-+				return;
 
-+			fast_pool->last_timer_intr = 1;
 
-+		} else
 
-+			fast_pool->last_timer_intr = 0;
 
-+	}
 
-+	credit_entropy_bits(r, 1);
 
- }
 
- 
- #ifdef CONFIG_BLOCK
 
-@@ -742,7 +849,11 @@ static ssize_t extract_entropy(struct en
 
-  */
 
- static void xfer_secondary_pool(struct entropy_store *r, size_t nbytes)
 
- {
 
--	__u32 tmp[OUTPUT_POOL_WORDS];
 
-+	union {
 
-+		__u32	tmp[OUTPUT_POOL_WORDS];
 
-+		long	hwrand[4];
 
-+	} u;
 
-+	int	i;
 
- 
- 	if (r->pull && r->entropy_count < nbytes * 8 &&
 
- 	    r->entropy_count < r->poolinfo->POOLBITS) {
 
-@@ -753,17 +864,22 @@ static void xfer_secondary_pool(struct e
 
- 		/* pull at least as many as BYTES as wakeup BITS */
 
- 		bytes = max_t(int, bytes, random_read_wakeup_thresh / 8);
 
- 		/* but never more than the buffer size */
 
--		bytes = min_t(int, bytes, sizeof(tmp));
 
-+		bytes = min_t(int, bytes, sizeof(u.tmp));
 
- 
- 		DEBUG_ENT("going to reseed %s with %d bits "
 
- 			  "(%d of %d requested)\n",
 
- 			  r->name, bytes * 8, nbytes * 8, r->entropy_count);
 
- 
--		bytes = extract_entropy(r->pull, tmp, bytes,
 
-+		bytes = extract_entropy(r->pull, u.tmp, bytes,
 
- 					random_read_wakeup_thresh / 8, rsvd);
 
--		mix_pool_bytes(r, tmp, bytes);
 
-+		mix_pool_bytes(r, u.tmp, bytes, NULL);
 
- 		credit_entropy_bits(r, bytes*8);
 
- 	}
 
-+	for (i = 0; i < 4; i++)
 
-+		if (arch_get_random_long(&u.hwrand[i]))
 
-+			break;
 
-+	if (i)
 
-+		mix_pool_bytes(r, &u.hwrand, i * sizeof(u.hwrand[0]), 0);
 
- }
 
- 
- /*
 
-@@ -822,9 +938,11 @@ static void extract_buf(struct entropy_s
 
- 	int i;
 
- 	__u32 hash[5], workspace[SHA_WORKSPACE_WORDS];
 
- 	__u8 extract[64];
 
-+	unsigned long flags;
 
- 
- 	/* Generate a hash across the pool, 16 words (512 bits) at a time */
 
- 	sha_init(hash);
 
-+	spin_lock_irqsave(&r->lock, flags);
 
- 	for (i = 0; i < r->poolinfo->poolwords; i += 16)
 
- 		sha_transform(hash, (__u8 *)(r->pool + i), workspace);
 
- 
-@@ -837,7 +955,8 @@ static void extract_buf(struct entropy_s
 
- 	 * brute-forcing the feedback as hard as brute-forcing the
 
- 	 * hash.
 
- 	 */
 
--	mix_pool_bytes_extract(r, hash, sizeof(hash), extract);
 
-+	__mix_pool_bytes(r, hash, sizeof(hash), extract);
 
-+	spin_unlock_irqrestore(&r->lock, flags);
 
- 
- 	/*
 
- 	 * To avoid duplicates, we atomically extract a portion of the
 
-@@ -860,12 +979,12 @@ static void extract_buf(struct entropy_s
 
- }
 
- 
- static ssize_t extract_entropy(struct entropy_store *r, void *buf,
 
--			       size_t nbytes, int min, int reserved)
 
-+				 size_t nbytes, int min, int reserved)
 
- {
 
- 	ssize_t ret = 0, i;
 
- 	__u8 tmp[EXTRACT_SIZE];
 
--	unsigned long flags;
 
- 
-+	trace_extract_entropy(r->name, nbytes, r->entropy_count, _RET_IP_);
 
- 	xfer_secondary_pool(r, nbytes);
 
- 	nbytes = account(r, nbytes, min, reserved);
 
- 
-@@ -873,6 +992,8 @@ static ssize_t extract_entropy(struct en
 
- 		extract_buf(r, tmp);
 
- 
- 		if (fips_enabled) {
 
-+			unsigned long flags;
 
-+
 
- 			spin_lock_irqsave(&r->lock, flags);
 
- 			if (!memcmp(tmp, r->last_data, EXTRACT_SIZE))
 
- 				panic("Hardware RNG duplicated output!\n");
 
-@@ -898,6 +1019,7 @@ static ssize_t extract_entropy_user(stru
 
- 	ssize_t ret = 0, i;
 
- 	__u8 tmp[EXTRACT_SIZE];
 
- 
-+	trace_extract_entropy_user(r->name, nbytes, r->entropy_count, _RET_IP_);
 
- 	xfer_secondary_pool(r, nbytes);
 
- 	nbytes = account(r, nbytes, 0, 0);
 
- 
-@@ -931,17 +1053,35 @@ static ssize_t extract_entropy_user(stru
 
- 
- /*
 
-  * This function is the exported kernel interface.  It returns some
 
-- * number of good random numbers, suitable for seeding TCP sequence
 
-- * numbers, etc.
 
-+ * number of good random numbers, suitable for key generation, seeding
 
-+ * TCP sequence numbers, etc.  It does not use the hw random number
 
-+ * generator, if available; use get_random_bytes_arch() for that.
 
-  */
 
- void get_random_bytes(void *buf, int nbytes)
 
- {
 
-+	extract_entropy(&nonblocking_pool, buf, nbytes, 0, 0);
 
-+}
 
-+EXPORT_SYMBOL(get_random_bytes);
 
-+
 
-+/*
 
-+ * This function will use the architecture-specific hardware random
 
-+ * number generator if it is available.  The arch-specific hw RNG will
 
-+ * almost certainly be faster than what we can do in software, but it
 
-+ * is impossible to verify that it is implemented securely (as
 
-+ * opposed, to, say, the AES encryption of a sequence number using a
 
-+ * key known by the NSA).  So it's useful if we need the speed, but
 
-+ * only if we're willing to trust the hardware manufacturer not to
 
-+ * have put in a back door.
 
-+ */
 
-+void get_random_bytes_arch(void *buf, int nbytes)
 
-+{
 
- 	char *p = buf;
 
- 
-+	trace_get_random_bytes(nbytes, _RET_IP_);
 
- 	while (nbytes) {
 
- 		unsigned long v;
 
- 		int chunk = min(nbytes, (int)sizeof(unsigned long));
 
--		
-+
 
- 		if (!arch_get_random_long(&v))
 
- 			break;
 
- 		
-@@ -950,9 +1090,11 @@ void get_random_bytes(void *buf, int nby
 
- 		nbytes -= chunk;
 
- 	}
 
- 
--	extract_entropy(&nonblocking_pool, p, nbytes, 0, 0);
 
-+	if (nbytes)
 
-+		extract_entropy(&nonblocking_pool, p, nbytes, 0, 0);
 
- }
 
--EXPORT_SYMBOL(get_random_bytes);
 
-+EXPORT_SYMBOL(get_random_bytes_arch);
 
-+
 
- 
- /*
 
-  * init_std_data - initialize pool with system data
 
-@@ -966,21 +1108,18 @@ EXPORT_SYMBOL(get_random_bytes);
 
- static void init_std_data(struct entropy_store *r)
 
- {
 
- 	int i;
 
--	ktime_t now;
 
--	unsigned long flags;
 
-+	ktime_t now = ktime_get_real();
 
-+	unsigned long rv;
 
- 
--	spin_lock_irqsave(&r->lock, flags);
 
- 	r->entropy_count = 0;
 
--	spin_unlock_irqrestore(&r->lock, flags);
 
--
 
--	now = ktime_get_real();
 
--	mix_pool_bytes(r, &now, sizeof(now));
 
--	for (i = r->poolinfo->POOLBYTES; i > 0; i -= sizeof flags) {
 
--		if (!arch_get_random_long(&flags))
 
-+	r->entropy_total = 0;
 
-+	mix_pool_bytes(r, &now, sizeof(now), NULL);
 
-+	for (i = r->poolinfo->POOLBYTES; i > 0; i -= sizeof(rv)) {
 
-+		if (!arch_get_random_long(&rv))
 
- 			break;
 
--		mix_pool_bytes(r, &flags, sizeof(flags));
 
-+		mix_pool_bytes(r, &rv, sizeof(rv), NULL);
 
- 	}
 
--	mix_pool_bytes(r, utsname(), sizeof(*(utsname())));
 
-+	mix_pool_bytes(r, utsname(), sizeof(*(utsname())), NULL);
 
- }
 
- 
- static int rand_initialize(void)
 
-@@ -1117,7 +1256,7 @@ write_pool(struct entropy_store *r, cons
 
- 		count -= bytes;
 
- 		p += bytes;
 
- 
--		mix_pool_bytes(r, buf, bytes);
 
-+		mix_pool_bytes(r, buf, bytes, NULL);
 
- 		cond_resched();
 
- 	}
 
- 
-@@ -1274,6 +1413,7 @@ static int proc_do_uuid(ctl_table *table
 
- }
 
- 
- static int sysctl_poolsize = INPUT_POOL_WORDS * 32;
 
-+extern ctl_table random_table[];
 
- ctl_table random_table[] = {
 
- 	{
 
- 		.procname	= "poolsize",
 
-@@ -1339,7 +1479,7 @@ late_initcall(random_int_secret_init);
 
-  * value is not cryptographically secure but for several uses the cost of
 
-  * depleting entropy is too high
 
-  */
 
--DEFINE_PER_CPU(__u32 [MD5_DIGEST_WORDS], get_random_int_hash);
 
-+static DEFINE_PER_CPU(__u32 [MD5_DIGEST_WORDS], get_random_int_hash);
 
- unsigned int get_random_int(void)
 
- {
 
- 	__u32 *hash;
 
---- a/drivers/mfd/ab3100-core.c
 
-+++ b/drivers/mfd/ab3100-core.c
 
-@@ -409,8 +409,6 @@ static irqreturn_t ab3100_irq_handler(in
 
- 	u32 fatevent;
 
- 	int err;
 
- 
--	add_interrupt_randomness(irq);
 
--
 
- 	err = ab3100_get_register_page_interruptible(ab3100, AB3100_EVENTA1,
 
- 				       event_regs, 3);
 
- 	if (err)
 
---- a/drivers/usb/core/hub.c
 
-+++ b/drivers/usb/core/hub.c
 
-@@ -24,6 +24,7 @@
 
- #include <linux/kthread.h>
 
- #include <linux/mutex.h>
 
- #include <linux/freezer.h>
 
-+#include <linux/random.h>
 
- 
- #include <asm/uaccess.h>
 
- #include <asm/byteorder.h>
 
-@@ -1896,6 +1897,14 @@ int usb_new_device(struct usb_device *ud
 
- 	/* Tell the world! */
 
- 	announce_device(udev);
 
- 
-+	if (udev->serial)
 
-+		add_device_randomness(udev->serial, strlen(udev->serial));
 
-+	if (udev->product)
 
-+		add_device_randomness(udev->product, strlen(udev->product));
 
-+	if (udev->manufacturer)
 
-+		add_device_randomness(udev->manufacturer,
 
-+				      strlen(udev->manufacturer));
 
-+
 
- 	device_enable_async_suspend(&udev->dev);
 
- 	/* Register the device.  The device driver is responsible
 
- 	 * for configuring the device and invoking the add-device
 
---- a/include/linux/random.h
 
-+++ b/include/linux/random.h
 
-@@ -50,11 +50,13 @@ struct rnd_state {
 
- 
- extern void rand_initialize_irq(int irq);
 
- 
-+extern void add_device_randomness(const void *, unsigned int);
 
- extern void add_input_randomness(unsigned int type, unsigned int code,
 
- 				 unsigned int value);
 
--extern void add_interrupt_randomness(int irq);
 
-+extern void add_interrupt_randomness(int irq, int irq_flags);
 
- 
- extern void get_random_bytes(void *buf, int nbytes);
 
-+extern void get_random_bytes_arch(void *buf, int nbytes);
 
- void generate_random_uuid(unsigned char uuid_out[16]);
 
- 
- #ifndef MODULE
 
---- /dev/null
 
-+++ b/include/trace/events/random.h
 
-@@ -0,0 +1,134 @@
 
-+#undef TRACE_SYSTEM
 
-+#define TRACE_SYSTEM random
 
-+
 
-+#if !defined(_TRACE_RANDOM_H) || defined(TRACE_HEADER_MULTI_READ)
 
-+#define _TRACE_RANDOM_H
 
-+
 
-+#include <linux/writeback.h>
 
-+#include <linux/tracepoint.h>
 
-+
 
-+DECLARE_EVENT_CLASS(random__mix_pool_bytes,
 
-+	TP_PROTO(const char *pool_name, int bytes, unsigned long IP),
 
-+
 
-+	TP_ARGS(pool_name, bytes, IP),
 
-+
 
-+	TP_STRUCT__entry(
 
-+		__field( const char *,	pool_name		)
 
-+		__field(	  int,	bytes			)
 
-+		__field(unsigned long,	IP			)
 
-+	),
 
-+
 
-+	TP_fast_assign(
 
-+		__entry->pool_name	= pool_name;
 
-+		__entry->bytes		= bytes;
 
-+		__entry->IP		= IP;
 
-+	),
 
-+
 
-+	TP_printk("%s pool: bytes %d caller %pF",
 
-+		  __entry->pool_name, __entry->bytes, (void *)__entry->IP)
 
-+);
 
-+
 
-+DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes,
 
-+	TP_PROTO(const char *pool_name, int bytes, unsigned long IP),
 
-+
 
-+	TP_ARGS(pool_name, bytes, IP)
 
-+);
 
-+
 
-+DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock,
 
-+	TP_PROTO(const char *pool_name, int bytes, unsigned long IP),
 
-+
 
-+	TP_ARGS(pool_name, bytes, IP)
 
-+);
 
-+
 
-+TRACE_EVENT(credit_entropy_bits,
 
-+	TP_PROTO(const char *pool_name, int bits, int entropy_count,
 
-+		 int entropy_total, unsigned long IP),
 
-+
 
-+	TP_ARGS(pool_name, bits, entropy_count, entropy_total, IP),
 
-+
 
-+	TP_STRUCT__entry(
 
-+		__field( const char *,	pool_name		)
 
-+		__field(	  int,	bits			)
 
-+		__field(	  int,	entropy_count		)
 
-+		__field(	  int,	entropy_total		)
 
-+		__field(unsigned long,	IP			)
 
-+	),
 
-+
 
-+	TP_fast_assign(
 
-+		__entry->pool_name	= pool_name;
 
-+		__entry->bits		= bits;
 
-+		__entry->entropy_count	= entropy_count;
 
-+		__entry->entropy_total	= entropy_total;
 
-+		__entry->IP		= IP;
 
-+	),
 
-+
 
-+	TP_printk("%s pool: bits %d entropy_count %d entropy_total %d "
 
-+		  "caller %pF", __entry->pool_name, __entry->bits,
 
-+		  __entry->entropy_count, __entry->entropy_total,
 
-+		  (void *)__entry->IP)
 
-+);
 
-+
 
-+TRACE_EVENT(get_random_bytes,
 
-+	TP_PROTO(int nbytes, unsigned long IP),
 
-+
 
-+	TP_ARGS(nbytes, IP),
 
-+
 
-+	TP_STRUCT__entry(
 
-+		__field(	  int,	nbytes			)
 
-+		__field(unsigned long,	IP			)
 
-+	),
 
-+
 
-+	TP_fast_assign(
 
-+		__entry->nbytes		= nbytes;
 
-+		__entry->IP		= IP;
 
-+	),
 
-+
 
-+	TP_printk("nbytes %d caller %pF", __entry->nbytes, (void *)__entry->IP)
 
-+);
 
-+
 
-+DECLARE_EVENT_CLASS(random__extract_entropy,
 
-+	TP_PROTO(const char *pool_name, int nbytes, int entropy_count,
 
-+		 unsigned long IP),
 
-+
 
-+	TP_ARGS(pool_name, nbytes, entropy_count, IP),
 
-+
 
-+	TP_STRUCT__entry(
 
-+		__field( const char *,	pool_name		)
 
-+		__field(	  int,	nbytes			)
 
-+		__field(	  int,	entropy_count		)
 
-+		__field(unsigned long,	IP			)
 
-+	),
 
-+
 
-+	TP_fast_assign(
 
-+		__entry->pool_name	= pool_name;
 
-+		__entry->nbytes		= nbytes;
 
-+		__entry->entropy_count	= entropy_count;
 
-+		__entry->IP		= IP;
 
-+	),
 
-+
 
-+	TP_printk("%s pool: nbytes %d entropy_count %d caller %pF",
 
-+		  __entry->pool_name, __entry->nbytes, __entry->entropy_count,
 
-+		  (void *)__entry->IP)
 
-+);
 
-+
 
-+
 
-+DEFINE_EVENT(random__extract_entropy, extract_entropy,
 
-+	TP_PROTO(const char *pool_name, int nbytes, int entropy_count,
 
-+		 unsigned long IP),
 
-+
 
-+	TP_ARGS(pool_name, nbytes, entropy_count, IP)
 
-+);
 
-+
 
-+DEFINE_EVENT(random__extract_entropy, extract_entropy_user,
 
-+	TP_PROTO(const char *pool_name, int nbytes, int entropy_count,
 
-+		 unsigned long IP),
 
-+
 
-+	TP_ARGS(pool_name, nbytes, entropy_count, IP)
 
-+);
 
-+
 
-+
 
-+
 
-+#endif /* _TRACE_RANDOM_H */
 
-+
 
-+/* This part must be outside protection */
 
-+#include <trace/define_trace.h>
 
---- a/kernel/irq/handle.c
 
-+++ b/kernel/irq/handle.c
 
-@@ -117,7 +117,7 @@ irqreturn_t
 
- handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
 
- {
 
- 	irqreturn_t retval = IRQ_NONE;
 
--	unsigned int random = 0, irq = desc->irq_data.irq;
 
-+	unsigned int flags = 0, irq = desc->irq_data.irq;
 
- 
- 	do {
 
- 		irqreturn_t res;
 
-@@ -145,7 +145,7 @@ handle_irq_event_percpu(struct irq_desc
 
- 
- 			/* Fall through to add to randomness */
 
- 		case IRQ_HANDLED:
 
--			random |= action->flags;
 
-+			flags |= action->flags;
 
- 			break;
 
- 
- 		default:
 
-@@ -156,8 +156,7 @@ handle_irq_event_percpu(struct irq_desc
 
- 		action = action->next;
 
- 	} while (action);
 
- 
--	if (random & IRQF_SAMPLE_RANDOM)
 
--		add_interrupt_randomness(irq);
 
-+	add_interrupt_randomness(irq, flags);
 
- 
- 	if (!noirqdebug)
 
- 		note_interrupt(irq, desc, retval);
 
---- a/net/core/dev.c
 
-+++ b/net/core/dev.c
 
-@@ -1176,6 +1176,7 @@ static int __dev_open(struct net_device
 
- 		net_dmaengine_get();
 
- 		dev_set_rx_mode(dev);
 
- 		dev_activate(dev);
 
-+		add_device_randomness(dev->dev_addr, dev->addr_len);
 
- 	}
 
- 
- 	return ret;
 
-@@ -4823,6 +4824,7 @@ int dev_set_mac_address(struct net_devic
 
- 	err = ops->ndo_set_mac_address(dev, sa);
 
- 	if (!err)
 
- 		call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
 
-+	add_device_randomness(dev->dev_addr, dev->addr_len);
 
- 	return err;
 
- }
 
- EXPORT_SYMBOL(dev_set_mac_address);
 
-@@ -5602,6 +5604,7 @@ int register_netdevice(struct net_device
 
- 	dev_init_scheduler(dev);
 
- 	dev_hold(dev);
 
- 	list_netdevice(dev);
 
-+	add_device_randomness(dev->dev_addr, dev->addr_len);
 
- 
- 	/* Notify protocols, that a new device appeared. */
 
- 	ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
 
---- a/net/core/rtnetlink.c
 
-+++ b/net/core/rtnetlink.c
 
-@@ -1371,6 +1371,7 @@ static int do_setlink(struct net_device
 
- 			goto errout;
 
- 		send_addr_notify = 1;
 
- 		modified = 1;
 
-+		add_device_randomness(dev->dev_addr, dev->addr_len);
 
- 	}
 
- 
- 	if (tb[IFLA_MTU]) {

+ 0 - 543
target/linux/generic/patches-3.3/051-rng_git_backport-remove_irqf_sample_random.patch
View File 

@@ -1,543 +0,0 @@
 
---- a/arch/arm/mach-omap1/board-palmz71.c
 
-+++ b/arch/arm/mach-omap1/board-palmz71.c
 
-@@ -291,8 +291,7 @@ palmz71_gpio_setup(int early)
 
- 		}
 
- 		gpio_direction_input(PALMZ71_USBDETECT_GPIO);
 
- 		if (request_irq(gpio_to_irq(PALMZ71_USBDETECT_GPIO),
 
--				palmz71_powercable, IRQF_SAMPLE_RANDOM,
 
--				"palmz71-cable", 0))
 
-+				palmz71_powercable, 0, "palmz71-cable", 0))
 
- 			printk(KERN_ERR
 
- 					"IRQ request for power cable failed!\n");
 
- 		palmz71_powercable(gpio_to_irq(PALMZ71_USBDETECT_GPIO), 0);
 
---- a/arch/arm/mach-pxa/lubbock.c
 
-+++ b/arch/arm/mach-pxa/lubbock.c
 
-@@ -455,7 +455,7 @@ static int lubbock_mci_init(struct devic
 
- 	init_timer(&mmc_timer);
 
- 	mmc_timer.data = (unsigned long) data;
 
- 	return request_irq(LUBBOCK_SD_IRQ, lubbock_detect_int,
 
--			IRQF_SAMPLE_RANDOM, "lubbock-sd-detect", data);
 
-+			   0, "lubbock-sd-detect", data);
 
- }
 
- 
- static int lubbock_mci_get_ro(struct device *dev)
 
---- a/arch/arm/mach-pxa/magician.c
 
-+++ b/arch/arm/mach-pxa/magician.c
 
-@@ -617,9 +617,8 @@ static struct platform_device bq24022 =
 
- static int magician_mci_init(struct device *dev,
 
- 				irq_handler_t detect_irq, void *data)
 
- {
 
--	return request_irq(IRQ_MAGICIAN_SD, detect_irq,
 
--				IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
 
--				"mmc card detect", data);
 
-+	return request_irq(IRQ_MAGICIAN_SD, detect_irq, IRQF_DISABLED,
 
-+			   "mmc card detect", data);
 
- }
 
- 
- static void magician_mci_exit(struct device *dev, void *data)
 
---- a/arch/arm/mach-pxa/trizeps4.c
 
-+++ b/arch/arm/mach-pxa/trizeps4.c
 
-@@ -332,8 +332,8 @@ static int trizeps4_mci_init(struct devi
 
- 	int err;
 
- 
- 	err = request_irq(TRIZEPS4_MMC_IRQ, mci_detect_int,
 
--		IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_SAMPLE_RANDOM,
 
--		"MMC card detect", data);
 
-+			  IRQF_DISABLED | IRQF_TRIGGER_RISING,
 
-+			  "MMC card detect", data);
 
- 	if (err) {
 
- 		printk(KERN_ERR "trizeps4_mci_init: MMC/SD: can't request"
 
- 						"MMC card detect IRQ\n");
 
---- a/arch/ia64/kernel/irq_ia64.c
 
-+++ b/arch/ia64/kernel/irq_ia64.c
 
-@@ -23,7 +23,6 @@
 
- #include <linux/ioport.h>
 
- #include <linux/kernel_stat.h>
 
- #include <linux/ptrace.h>
 
--#include <linux/random.h>	/* for rand_initialize_irq() */
 
- #include <linux/signal.h>
 
- #include <linux/smp.h>
 
- #include <linux/threads.h>
 
---- a/arch/sparc/kernel/ldc.c
 
-+++ b/arch/sparc/kernel/ldc.c
 
-@@ -1250,14 +1250,12 @@ int ldc_bind(struct ldc_channel *lp, con
 
- 	snprintf(lp->rx_irq_name, LDC_IRQ_NAME_MAX, "%s RX", name);
 
- 	snprintf(lp->tx_irq_name, LDC_IRQ_NAME_MAX, "%s TX", name);
 
- 
--	err = request_irq(lp->cfg.rx_irq, ldc_rx,
 
--			  IRQF_SAMPLE_RANDOM | IRQF_DISABLED,
 
-+	err = request_irq(lp->cfg.rx_irq, ldc_rx, IRQF_DISABLED,
 
- 			  lp->rx_irq_name, lp);
 
- 	if (err)
 
- 		return err;
 
- 
--	err = request_irq(lp->cfg.tx_irq, ldc_tx,
 
--			  IRQF_SAMPLE_RANDOM | IRQF_DISABLED,
 
-+	err = request_irq(lp->cfg.tx_irq, ldc_tx, IRQF_DISABLED,
 
- 			  lp->tx_irq_name, lp);
 
- 	if (err) {
 
- 		free_irq(lp->cfg.rx_irq, lp);
 
---- a/arch/um/drivers/line.c
 
-+++ b/arch/um/drivers/line.c
 
-@@ -371,7 +371,7 @@ static irqreturn_t line_write_interrupt(
 
- int line_setup_irq(int fd, int input, int output, struct line *line, void *data)
 
- {
 
- 	const struct line_driver *driver = line->driver;
 
--	int err = 0, flags = IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM;
 
-+	int err = 0, flags = IRQF_DISABLED | IRQF_SHARED;
 
- 
- 	if (input)
 
- 		err = um_request_irq(driver->read_irq, fd, IRQ_READ,
 
-@@ -807,7 +807,7 @@ void register_winch_irq(int fd, int tty_
 
- 				   .stack	= stack });
 
- 
- 	if (um_request_irq(WINCH_IRQ, fd, IRQ_READ, winch_interrupt,
 
--			   IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM,
 
-+			   IRQF_DISABLED | IRQF_SHARED,
 
- 			   "winch", winch) < 0) {
 
- 		printk(KERN_ERR "register_winch_irq - failed to register "
 
- 		       "IRQ\n");
 
---- a/arch/um/drivers/mconsole_kern.c
 
-+++ b/arch/um/drivers/mconsole_kern.c
 
-@@ -773,7 +773,7 @@ static int __init mconsole_init(void)
 
- 	register_reboot_notifier(&reboot_notifier);
 
- 
- 	err = um_request_irq(MCONSOLE_IRQ, sock, IRQ_READ, mconsole_interrupt,
 
--			     IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM,
 
-+			     IRQF_DISABLED | IRQF_SHARED,
 
- 			     "mconsole", (void *)sock);
 
- 	if (err) {
 
- 		printk(KERN_ERR "Failed to get IRQ for management console\n");
 
---- a/arch/um/drivers/port_kern.c
 
-+++ b/arch/um/drivers/port_kern.c
 
-@@ -100,7 +100,7 @@ static int port_accept(struct port_list
 
- 		  .port 	= port });
 
- 
- 	if (um_request_irq(TELNETD_IRQ, socket[0], IRQ_READ, pipe_interrupt,
 
--			  IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM,
 
-+			  IRQF_DISABLED | IRQF_SHARED,
 
- 			  "telnetd", conn)) {
 
- 		printk(KERN_ERR "port_accept : failed to get IRQ for "
 
- 		       "telnetd\n");
 
-@@ -184,7 +184,7 @@ void *port_data(int port_num)
 
- 	}
 
- 
- 	if (um_request_irq(ACCEPT_IRQ, fd, IRQ_READ, port_interrupt,
 
--			  IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM,
 
-+			  IRQF_DISABLED | IRQF_SHARED,
 
- 			  "port", port)) {
 
- 		printk(KERN_ERR "Failed to get IRQ for port %d\n", port_num);
 
- 		goto out_close;
 
---- a/arch/um/drivers/random.c
 
-+++ b/arch/um/drivers/random.c
 
-@@ -131,8 +131,7 @@ static int __init rng_init (void)
 
- 	random_fd = err;
 
- 
- 	err = um_request_irq(RANDOM_IRQ, random_fd, IRQ_READ, random_interrupt,
 
--			     IRQF_DISABLED | IRQF_SAMPLE_RANDOM, "random",
 
--			     NULL);
 
-+			     IRQF_DISABLED, "random", NULL);
 
- 	if (err)
 
- 		goto err_out_cleanup_hw;
 
- 
---- a/arch/um/drivers/xterm_kern.c
 
-+++ b/arch/um/drivers/xterm_kern.c
 
-@@ -50,8 +50,7 @@ int xterm_fd(int socket, int *pid_out)
 
- 	init_completion(&data->ready);
 
- 
- 	err = um_request_irq(XTERM_IRQ, socket, IRQ_READ, xterm_interrupt,
 
--			     IRQF_DISABLED | IRQF_SHARED | IRQF_SAMPLE_RANDOM,
 
--			     "xterm", data);
 
-+			     IRQF_DISABLED | IRQF_SHARED, "xterm", data);
 
- 	if (err) {
 
- 		printk(KERN_ERR "xterm_fd : failed to get IRQ for xterm, "
 
- 		       "err = %d\n",  err);
 
---- a/arch/um/kernel/sigio.c
 
-+++ b/arch/um/kernel/sigio.c
 
-@@ -25,8 +25,7 @@ int write_sigio_irq(int fd)
 
- 	int err;
 
- 
- 	err = um_request_irq(SIGIO_WRITE_IRQ, fd, IRQ_READ, sigio_interrupt,
 
--			     IRQF_DISABLED|IRQF_SAMPLE_RANDOM, "write sigio",
 
--			     NULL);
 
-+			     IRQF_DISABLED, "write sigio", NULL);
 
- 	if (err) {
 
- 		printk(KERN_ERR "write_sigio_irq : um_request_irq failed, "
 
- 		       "err = %d\n", err);
 
---- a/Documentation/feature-removal-schedule.txt
 
-+++ b/Documentation/feature-removal-schedule.txt
 
-@@ -71,20 +71,6 @@ Who:	Luis R. Rodriguez <lrodriguez@ather
 
- 
- ---------------------------
 
- 
--What:	IRQF_SAMPLE_RANDOM
 
--Check:	IRQF_SAMPLE_RANDOM
 
--When:	July 2009
 
--
 
--Why:	Many of IRQF_SAMPLE_RANDOM users are technically bogus as entropy
 
--	sources in the kernel's current entropy model. To resolve this, every
 
--	input point to the kernel's entropy pool needs to better document the
 
--	type of entropy source it actually is. This will be replaced with
 
--	additional add_*_randomness functions in drivers/char/random.c
 
--
 
--Who:	Robin Getz <[email protected]> & Matt Mackall <[email protected]>
 
--
 
-----------------------------
 
--
 
- What:	The ieee80211_regdom module parameter
 
- When:	March 2010 / desktop catchup
 
- 
---- a/drivers/block/xen-blkfront.c
 
-+++ b/drivers/block/xen-blkfront.c
 
-@@ -852,9 +852,8 @@ static int setup_blkring(struct xenbus_d
 
- 	if (err)
 
- 		goto fail;
 
- 
--	err = bind_evtchn_to_irqhandler(info->evtchn,
 
--					blkif_interrupt,
 
--					IRQF_SAMPLE_RANDOM, "blkif", info);
 
-+	err = bind_evtchn_to_irqhandler(info->evtchn, blkif_interrupt, 0,
 
-+					"blkif", info);
 
- 	if (err <= 0) {
 
- 		xenbus_dev_fatal(dev, err,
 
- 				 "bind_evtchn_to_irqhandler failed");
 
---- a/drivers/char/random.c
 
-+++ b/drivers/char/random.c
 
-@@ -633,43 +633,6 @@ struct timer_rand_state {
 
- 	unsigned dont_count_entropy:1;
 
- };
 
- 
--#ifndef CONFIG_GENERIC_HARDIRQS
 
--
 
--static struct timer_rand_state *irq_timer_state[NR_IRQS];
 
--
 
--static struct timer_rand_state *get_timer_rand_state(unsigned int irq)
 
--{
 
--	return irq_timer_state[irq];
 
--}
 
--
 
--static void set_timer_rand_state(unsigned int irq,
 
--				 struct timer_rand_state *state)
 
--{
 
--	irq_timer_state[irq] = state;
 
--}
 
--
 
--#else
 
--
 
--static struct timer_rand_state *get_timer_rand_state(unsigned int irq)
 
--{
 
--	struct irq_desc *desc;
 
--
 
--	desc = irq_to_desc(irq);
 
--
 
--	return desc->timer_rand_state;
 
--}
 
--
 
--static void set_timer_rand_state(unsigned int irq,
 
--				 struct timer_rand_state *state)
 
--{
 
--	struct irq_desc *desc;
 
--
 
--	desc = irq_to_desc(irq);
 
--
 
--	desc->timer_rand_state = state;
 
--}
 
--#endif
 
--
 
- /*
 
-  * Add device- or boot-specific data to the input and nonblocking
 
-  * pools to help initialize them to unique values.
 
-@@ -1131,24 +1094,6 @@ static int rand_initialize(void)
 
- }
 
- module_init(rand_initialize);
 
- 
--void rand_initialize_irq(int irq)
 
--{
 
--	struct timer_rand_state *state;
 
--
 
--	state = get_timer_rand_state(irq);
 
--
 
--	if (state)
 
--		return;
 
--
 
--	/*
 
--	 * If kzalloc returns null, we just won't use that entropy
 
--	 * source.
 
--	 */
 
--	state = kzalloc(sizeof(struct timer_rand_state), GFP_KERNEL);
 
--	if (state)
 
--		set_timer_rand_state(irq, state);
 
--}
 
--
 
- #ifdef CONFIG_BLOCK
 
- void rand_initialize_disk(struct gendisk *disk)
 
- {
 
---- a/drivers/crypto/n2_core.c
 
-+++ b/drivers/crypto/n2_core.c
 
-@@ -1607,8 +1607,7 @@ static int spu_map_ino(struct platform_d
 
- 
- 	sprintf(p->irq_name, "%s-%d", irq_name, index);
 
- 
--	return request_irq(p->irq, handler, IRQF_SAMPLE_RANDOM,
 
--			   p->irq_name, p);
 
-+	return request_irq(p->irq, handler, 0, p->irq_name, p);
 
- }
 
- 
- static struct kmem_cache *queue_cache[2];
 
---- a/drivers/hv/vmbus_drv.c
 
-+++ b/drivers/hv/vmbus_drv.c
 
-@@ -545,8 +545,7 @@ static int vmbus_bus_init(int irq)
 
- 	if (ret)
 
- 		goto err_cleanup;
 
- 
--	ret = request_irq(irq, vmbus_isr, IRQF_SAMPLE_RANDOM,
 
--			driver_name, hv_acpi_dev);
 
-+	ret = request_irq(irq, vmbus_isr, 0, driver_name, hv_acpi_dev);
 
- 
- 	if (ret != 0) {
 
- 		pr_err("Unable to request IRQ %d\n",
 
---- a/drivers/i2c/busses/i2c-pmcmsp.c
 
-+++ b/drivers/i2c/busses/i2c-pmcmsp.c
 
-@@ -306,8 +306,7 @@ static int __devinit pmcmsptwi_probe(str
 
- 	pmcmsptwi_data.irq = platform_get_irq(pldev, 0);
 
- 	if (pmcmsptwi_data.irq) {
 
- 		rc = request_irq(pmcmsptwi_data.irq, &pmcmsptwi_interrupt,
 
--			IRQF_SHARED | IRQF_SAMPLE_RANDOM,
 
--			pldev->name, &pmcmsptwi_data);
 
-+				 IRQF_SHARED, pldev->name, &pmcmsptwi_data);
 
- 		if (rc == 0) {
 
- 			/*
 
- 			 * Enable 'DONE' interrupt only.
 
---- a/drivers/input/serio/hp_sdc.c
 
-+++ b/drivers/input/serio/hp_sdc.c
 
-@@ -879,7 +879,7 @@ static int __init hp_sdc_init(void)
 
- #endif
 
- 
- 	errstr = "IRQ not available for";
 
--	if (request_irq(hp_sdc.irq, &hp_sdc_isr, IRQF_SHARED|IRQF_SAMPLE_RANDOM,
 
-+	if (request_irq(hp_sdc.irq, &hp_sdc_isr, IRQF_SHARED,
 
- 			"HP SDC", &hp_sdc))
 
- 		goto err1;
 
- 
---- a/drivers/mfd/ab3100-core.c
 
-+++ b/drivers/mfd/ab3100-core.c
 
-@@ -937,9 +937,6 @@ static int __devinit ab3100_probe(struct
 
- 
- 	err = request_threaded_irq(client->irq, NULL, ab3100_irq_handler,
 
- 				IRQF_ONESHOT, "ab3100-core", ab3100);
 
--	/* This real unpredictable IRQ is of course sampled for entropy */
 
--	rand_initialize_irq(client->irq);
 
--
 
- 	if (err)
 
- 		goto exit_no_irq;
 
- 
---- a/drivers/mfd/tps65010.c
 
-+++ b/drivers/mfd/tps65010.c
 
-@@ -563,8 +563,7 @@ static int tps65010_probe(struct i2c_cli
 
- 	 */
 
- 	if (client->irq > 0) {
 
- 		status = request_irq(client->irq, tps65010_irq,
 
--			IRQF_SAMPLE_RANDOM | IRQF_TRIGGER_FALLING,
 
--			DRIVER_NAME, tps);
 
-+			IRQF_TRIGGER_FALLING, DRIVER_NAME, tps);
 
- 		if (status < 0) {
 
- 			dev_dbg(&client->dev, "can't get IRQ %d, err %d\n",
 
- 					client->irq, status);
 
---- a/drivers/net/ethernet/broadcom/tg3.c
 
-+++ b/drivers/net/ethernet/broadcom/tg3.c
 
-@@ -9415,7 +9415,7 @@ static int tg3_test_interrupt(struct tg3
 
- 	}
 
- 
- 	err = request_irq(tnapi->irq_vec, tg3_test_isr,
 
--			  IRQF_SHARED | IRQF_SAMPLE_RANDOM, dev->name, tnapi);
 
-+			  IRQF_SHARED, dev->name, tnapi);
 
- 	if (err)
 
- 		return err;
 
- 
---- a/drivers/power/pda_power.c
 
-+++ b/drivers/power/pda_power.c
 
-@@ -24,11 +24,7 @@
 
- 
- static inline unsigned int get_irq_flags(struct resource *res)
 
- {
 
--	unsigned int flags = IRQF_SAMPLE_RANDOM | IRQF_SHARED;
 
--
 
--	flags |= res->flags & IRQF_TRIGGER_MASK;
 
--
 
--	return flags;
 
-+	return IRQF_SHARED | (res->flags & IRQF_TRIGGER_MASK);
 
- }
 
- 
- static struct device *dev;
 
---- a/drivers/tty/serial/uartlite.c
 
-+++ b/drivers/tty/serial/uartlite.c
 
-@@ -216,8 +216,7 @@ static int ulite_startup(struct uart_por
 
- {
 
- 	int ret;
 
- 
--	ret = request_irq(port->irq, ulite_isr,
 
--			  IRQF_SHARED | IRQF_SAMPLE_RANDOM, "uartlite", port);
 
-+	ret = request_irq(port->irq, ulite_isr, IRQF_SHARED, "uartlite", port);
 
- 	if (ret)
 
- 		return ret;
 
- 
---- a/drivers/usb/gadget/goku_udc.c
 
-+++ b/drivers/usb/gadget/goku_udc.c
 
-@@ -1839,7 +1839,7 @@ static int goku_probe(struct pci_dev *pd
 
- 	/* init to known state, then setup irqs */
 
- 	udc_reset(dev);
 
- 	udc_reinit (dev);
 
--	if (request_irq(pdev->irq, goku_irq, IRQF_SHARED/*|IRQF_SAMPLE_RANDOM*/,
 
-+	if (request_irq(pdev->irq, goku_irq, IRQF_SHARED,
 
- 			driver_name, dev) != 0) {
 
- 		DBG(dev, "request interrupt %d failed\n", pdev->irq);
 
- 		retval = -EBUSY;
 
---- a/drivers/usb/gadget/omap_udc.c
 
-+++ b/drivers/usb/gadget/omap_udc.c
 
-@@ -2943,7 +2943,7 @@ known:
 
- 
- 	/* USB general purpose IRQ:  ep0, state changes, dma, etc */
 
- 	status = request_irq(pdev->resource[1].start, omap_udc_irq,
 
--			IRQF_SAMPLE_RANDOM, driver_name, udc);
 
-+			     0, driver_name, udc);
 
- 	if (status != 0) {
 
- 		ERR("can't get irq %d, err %d\n",
 
- 			(int) pdev->resource[1].start, status);
 
-@@ -2952,7 +2952,7 @@ known:
 
- 
- 	/* USB "non-iso" IRQ (PIO for all but ep0) */
 
- 	status = request_irq(pdev->resource[2].start, omap_udc_pio_irq,
 
--			IRQF_SAMPLE_RANDOM, "omap_udc pio", udc);
 
-+			     0, "omap_udc pio", udc);
 
- 	if (status != 0) {
 
- 		ERR("can't get irq %d, err %d\n",
 
- 			(int) pdev->resource[2].start, status);
 
---- a/drivers/usb/gadget/pxa25x_udc.c
 
-+++ b/drivers/usb/gadget/pxa25x_udc.c
 
-@@ -2202,19 +2202,15 @@ static int __init pxa25x_udc_probe(struc
 
- 
- #ifdef CONFIG_ARCH_LUBBOCK
 
- 	if (machine_is_lubbock()) {
 
--		retval = request_irq(LUBBOCK_USB_DISC_IRQ,
 
--				lubbock_vbus_irq,
 
--				IRQF_SAMPLE_RANDOM,
 
--				driver_name, dev);
 
-+		retval = request_irq(LUBBOCK_USB_DISC_IRQ, lubbock_vbus_irq,
 
-+				     0, driver_name, dev);
 
- 		if (retval != 0) {
 
- 			pr_err("%s: can't get irq %i, err %d\n",
 
- 				driver_name, LUBBOCK_USB_DISC_IRQ, retval);
 
- 			goto err_irq_lub;
 
- 		}
 
--		retval = request_irq(LUBBOCK_USB_IRQ,
 
--				lubbock_vbus_irq,
 
--				IRQF_SAMPLE_RANDOM,
 
--				driver_name, dev);
 
-+		retval = request_irq(LUBBOCK_USB_IRQ, lubbock_vbus_irq,
 
-+				     0, driver_name, dev);
 
- 		if (retval != 0) {
 
- 			pr_err("%s: can't get irq %i, err %d\n",
 
- 				driver_name, LUBBOCK_USB_IRQ, retval);
 
---- a/drivers/usb/otg/gpio_vbus.c
 
-+++ b/drivers/usb/otg/gpio_vbus.c
 
-@@ -51,8 +51,7 @@ struct gpio_vbus_data {
 
-  * edges might be workable.
 
-  */
 
- #define VBUS_IRQ_FLAGS \
 
--	( IRQF_SAMPLE_RANDOM | IRQF_SHARED \
 
--	| IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING )
 
-+	( IRQF_SHARED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING )
 
- 
- 
- /* interface to regulator framework */
 
-@@ -253,7 +252,7 @@ static int __init gpio_vbus_probe(struct
 
- 	if (res) {
 
- 		irq = res->start;
 
- 		res->flags &= IRQF_TRIGGER_MASK;
 
--		res->flags |= IRQF_SAMPLE_RANDOM | IRQF_SHARED;
 
-+		res->flags |= IRQF_SHARED;
 
- 	} else
 
- 		irq = gpio_to_irq(gpio);
 
- 
---- a/drivers/usb/otg/isp1301_omap.c
 
-+++ b/drivers/usb/otg/isp1301_omap.c
 
-@@ -1567,7 +1567,6 @@ isp1301_probe(struct i2c_client *i2c, co
 
- 		isp->irq_type = IRQF_TRIGGER_FALLING;
 
- 	}
 
- 
--	isp->irq_type |= IRQF_SAMPLE_RANDOM;
 
- 	status = request_irq(i2c->irq, isp1301_irq,
 
- 			isp->irq_type, DRIVER_NAME, isp);
 
- 	if (status < 0) {
 
---- a/include/linux/interrupt.h
 
-+++ b/include/linux/interrupt.h
 
-@@ -44,7 +44,6 @@
 
-  *
 
-  * IRQF_DISABLED - keep irqs disabled when calling the action handler.
 
-  *                 DEPRECATED. This flag is a NOOP and scheduled to be removed
 
-- * IRQF_SAMPLE_RANDOM - irq is used to feed the random generator
 
-  * IRQF_SHARED - allow sharing the irq among several devices
 
-  * IRQF_PROBE_SHARED - set by callers when they expect sharing mismatches to occur
 
-  * IRQF_TIMER - Flag to mark this interrupt as timer interrupt
 
-@@ -63,7 +62,6 @@
 
-  *                resume time.
 
-  */
 
- #define IRQF_DISABLED		0x00000020
 
--#define IRQF_SAMPLE_RANDOM	0x00000040
 
- #define IRQF_SHARED		0x00000080
 
- #define IRQF_PROBE_SHARED	0x00000100
 
- #define __IRQF_TIMER		0x00000200
 
---- a/include/linux/irqdesc.h
 
-+++ b/include/linux/irqdesc.h
 
-@@ -39,7 +39,6 @@ struct module;
 
-  */
 
- struct irq_desc {
 
- 	struct irq_data		irq_data;
 
--	struct timer_rand_state *timer_rand_state;
 
- 	unsigned int __percpu	*kstat_irqs;
 
- 	irq_flow_handler_t	handle_irq;
 
- #ifdef CONFIG_IRQ_PREFLOW_FASTEOI
 
---- a/include/linux/random.h
 
-+++ b/include/linux/random.h
 
-@@ -48,8 +48,6 @@ struct rnd_state {
 
- 
- #ifdef __KERNEL__
 
- 
--extern void rand_initialize_irq(int irq);
 
--
 
- extern void add_device_randomness(const void *, unsigned int);
 
- extern void add_input_randomness(unsigned int type, unsigned int code,
 
- 				 unsigned int value);
 
---- a/kernel/irq/manage.c
 
-+++ b/kernel/irq/manage.c
 
-@@ -891,22 +891,6 @@ __setup_irq(unsigned int irq, struct irq
 
- 		return -ENOSYS;
 
- 	if (!try_module_get(desc->owner))
 
- 		return -ENODEV;
 
--	/*
 
--	 * Some drivers like serial.c use request_irq() heavily,
 
--	 * so we have to be careful not to interfere with a
 
--	 * running system.
 
--	 */
 
--	if (new->flags & IRQF_SAMPLE_RANDOM) {
 
--		/*
 
--		 * This function might sleep, we want to call it first,
 
--		 * outside of the atomic block.
 
--		 * Yes, this might clear the entropy pool if the wrong
 
--		 * driver is attempted to be loaded, without actually
 
--		 * installing a new handler, but is this really a problem,
 
--		 * only the sysadmin is able to do this.
 
--		 */
 
--		rand_initialize_irq(irq);
 
--	}
 
- 
- 	/*
 
- 	 * Check whether the interrupt nests into another interrupt
 
-@@ -1342,7 +1326,6 @@ EXPORT_SYMBOL(free_irq);
 
-  *	Flags:
 
-  *
 
-  *	IRQF_SHARED		Interrupt is shared
 
-- *	IRQF_SAMPLE_RANDOM	The interrupt can be used for entropy
 
-  *	IRQF_TRIGGER_*		Specify active edge(s) or level
 
-  *
 
-  */

+ 0 - 36
target/linux/generic/patches-3.3/060-hso_devices.patch
View File 

@@ -1,36 +0,0 @@
 
---- a/drivers/net/usb/hso.c
 
-+++ b/drivers/net/usb/hso.c
 
-@@ -476,8 +476,10 @@ static const struct usb_device_id hso_id
 
- 	{USB_DEVICE(0x0af0, 0x8400)},
 
- 	{USB_DEVICE(0x0af0, 0x8600)},
 
- 	{USB_DEVICE(0x0af0, 0x8800)},
 
--	{USB_DEVICE(0x0af0, 0x8900)},
 
--	{USB_DEVICE(0x0af0, 0x9000)},
 
-+	{USB_DEVICE(0x0af0, 0x8900)},  /* GTM 67xx */
 
-+	{USB_DEVICE(0x0af0, 0x9000)},  /* GTM 66xx */
 
-+	{USB_DEVICE(0x0af0, 0x9200)},  /* GTM 67xxWFS */
 
-+	{USB_DEVICE(0x0af0, 0x9300)},  /* GTM 66xxWFS */
 
- 	{USB_DEVICE(0x0af0, 0xd035)},
 
- 	{USB_DEVICE(0x0af0, 0xd055)},
 
- 	{USB_DEVICE(0x0af0, 0xd155)},
 
---- a/drivers/usb/storage/unusual_devs.h
 
-+++ b/drivers/usb/storage/unusual_devs.h
 
-@@ -1231,6 +1231,18 @@ UNUSUAL_DEV( 0x0af0, 0x8304, 0x0000, 0x0
 
- 		USB_SC_DEVICE, USB_PR_DEVICE, NULL,
 
- 		0 ),
 
- 
-+UNUSUAL_DEV( 0x0af0, 0x9200, 0x0000, 0x0000,
 
-+		"Option",
 
-+		"Globetrotter 67xxWFS SD-Card",
 
-+		USB_SC_DEVICE, USB_PR_DEVICE, NULL,
 
-+		0 ),
 
-+
 
-+UNUSUAL_DEV( 0x0af0, 0x9300, 0x0000, 0x0000,
 
-+		"Option",
 
-+		"Globetrotter 66xxWFS SD-Card",
 
-+		USB_SC_DEVICE, USB_PR_DEVICE, NULL,
 
-+		0 ),
 
-+
 
- UNUSUAL_DEV( 0x0af0, 0xc100, 0x0000, 0x0000,
 
- 		"Option",
 
- 		"GI 070x SD-Card",

+ 0 - 61
target/linux/generic/patches-3.3/060-tcp-ecn-dont-delay-ACKS-after-CE.patch
View File 

@@ -1,61 +0,0 @@
 
-From patchwork Mon Aug  6 21:04:43 2012
 
-Content-Type: text/plain; charset="utf-8"
 
-MIME-Version: 1.0
 
-Content-Transfer-Encoding: 7bit
 
-Subject: [net-next] tcp: ecn: dont delay ACKS after CE
 
-Date: Mon, 06 Aug 2012 11:04:43 -0000
 
-From: Eric Dumazet <[email protected]>
 
-X-Patchwork-Id: 175453
 
-Message-Id: <1344287083.26674.83.camel@edumazet-glaptop>
 
-To: David Miller <[email protected]>
 
-Cc: netdev <[email protected]>,
 
-	Neal Cardwell <[email protected]>
 
-
 
-From: Eric Dumazet <[email protected]>
 
-
 
-While playing with CoDel and ECN marking, I discovered a
 
-non optimal behavior of receiver of CE (Congestion Encountered)
 
-segments.
 
-
 
-In pathological cases, sender has reduced its cwnd to low values,
 
-and receiver delays its ACK (by 40 ms).
 
-
 
-While RFC 3168 6.1.3 (The TCP Receiver) doesn't explicitly recommend
 
-to send immediate ACKS, we believe its better to not delay ACKS, because
 
-a CE segment should give same signal than a dropped segment, and its
 
-quite important to reduce RTT to give ECE/CWR signals as fast as
 
-possible.
 
-
 
-Note we already call tcp_enter_quickack_mode() from TCP_ECN_check_ce()
 
-if we receive a retransmit, for the same reason.
 
-
 
-Signed-off-by: Eric Dumazet <[email protected]>
 
-Cc: Neal Cardwell <[email protected]>
 
-Acked-by: Neal Cardwell <[email protected]>
 
-
 
----
 
-net/ipv4/tcp_input.c |    6 +++++-
 
- 1 file changed, 5 insertions(+), 1 deletion(-)
 
-
 
-
 
-
 
---
 
-To unsubscribe from this list: send the line "unsubscribe netdev" in
 
-the body of a message to [email protected]
 
-More majordomo info at  http://vger.kernel.org/majordomo-info.html
 
-
 
---- a/net/ipv4/tcp_input.c
 
-+++ b/net/ipv4/tcp_input.c
 
-@@ -231,7 +231,11 @@ static inline void TCP_ECN_check_ce(stru
 
- 			tcp_enter_quickack_mode((struct sock *)tp);
 
- 		break;
 
- 	case INET_ECN_CE:
 
--		tp->ecn_flags |= TCP_ECN_DEMAND_CWR;
 
-+		if (!(tp->ecn_flags & TCP_ECN_DEMAND_CWR)) {
 
-+			/* Better not delay acks, sender can have a very low cwnd */
 
-+			tcp_enter_quickack_mode((struct sock *)tp);
 
-+			tp->ecn_flags |= TCP_ECN_DEMAND_CWR;
 
-+		}
 
- 		/* fallinto */
 
- 	default:
 
- 		tp->ecn_flags |= TCP_ECN_SEEN;

+ 0 - 36
target/linux/generic/patches-3.3/061-fq_codel-dont-reinit-flow-state.patch
View File 

@@ -1,36 +0,0 @@
 
-From b379135c40163ae79ba7a54e6928b53983e74ee8 Mon Sep 17 00:00:00 2001
 
-From: Eric Dumazet <[email protected]>
 
-Date: Sat, 1 Sep 2012 03:19:57 +0000
 
-Subject: [PATCH 307/558] fq_codel: dont reinit flow state
 
-
 
-When fq_codel builds a new flow, it should not reset codel state.
 
-
 
-Codel algo needs to get previous values (lastcount, drop_next) to get
 
-proper behavior.
 
-
 
-Signed-off-by: Dave Taht <[email protected]>
 
-Signed-off-by: Eric Dumazet <[email protected]>
 
-Acked-by: Dave Taht <[email protected]>
 
-Signed-off-by: David S. Miller <[email protected]>
 
----
 
- net/sched/sch_fq_codel.c |    2 +-
 
- 1 file changed, 1 insertion(+), 1 deletion(-)
 
-
 
---- a/net/sched/sch_fq_codel.c
 
-+++ b/net/sched/sch_fq_codel.c
 
-@@ -191,7 +191,6 @@ static int fq_codel_enqueue(struct sk_bu
 
- 
- 	if (list_empty(&flow->flowchain)) {
 
- 		list_add_tail(&flow->flowchain, &q->new_flows);
 
--		codel_vars_init(&flow->cvars);
 
- 		q->new_flow_count++;
 
- 		flow->deficit = q->quantum;
 
- 		flow->dropped = 0;
 
-@@ -418,6 +417,7 @@ static int fq_codel_init(struct Qdisc *s
 
- 			struct fq_codel_flow *flow = q->flows + i;
 
- 
- 			INIT_LIST_HEAD(&flow->flowchain);
 
-+			codel_vars_init(&flow->cvars);
 
- 		}
 
- 	}
 
- 	if (sch->limit >= 1)

+ 0 - 187
target/linux/generic/patches-3.3/065-8139cp-fixes.patch
View File 

@@ -1,187 +0,0 @@
 
-commit 01ffc0a7f1c1801a2354719dedbc32aff45b987d
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Sat Nov 24 12:11:21 2012 +0000
 
-
 
-    8139cp: re-enable interrupts after tx timeout
 
-    
-    Recovery doesn't work too well if we leave interrupts disabled...
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Acked-by: Francois Romieu <[email protected]>
 
-    Signed-off-by: David S. Miller <[email protected]>
 
-
 
-commit 871f0d4c153e1258d4becf306eca6761bf38b629
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Thu Nov 22 03:16:58 2012 +0000
 
-
 
-    8139cp: enable bql
 
-    
-    This adds support for byte queue limits on RTL8139C+
 
-    
-    Tested on real hardware.
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Acked-By: Dave Täht <[email protected]>
 
-    Signed-off-by: David S. Miller <[email protected]>
 
-
 
-commit a9dbe40fc10cea2efe6e1ff9e03c62dd7579c5ba
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Wed Nov 21 10:27:19 2012 +0000
 
-
 
-    8139cp: set ring address after enabling C+ mode
 
-    
-    This fixes (for me) a regression introduced by commit b01af457 ("8139cp:
 
-    set ring address before enabling receiver"). That commit configured the
 
-    descriptor ring addresses earlier in the initialisation sequence, in
 
-    order to avoid the possibility of triggering stray DMA before the
 
-    correct address had been set up.
 
-    
-    Unfortunately, it seems that the hardware will scribble garbage into the
 
-    TxRingAddr registers when we enable "plus mode" Tx in the CpCmd
 
-    register. Observed on a Traverse Geos router board.
 
-    
-    To deal with this, while not reintroducing the problem which led to the
 
-    original commit, we augment cp_start_hw() to write to the CpCmd register
 
-    *first*, then set the descriptor ring addresses, and then finally to
 
-    enable Rx and Tx in the original 8139 Cmd register. The datasheet
 
-    actually indicates that we should enable Tx/Rx in the Cmd register
 
-    *before* configuring the descriptor addresses, but that would appear to
 
-    re-introduce the problem that the offending commit b01af457 was trying
 
-    to solve. And this variant appears to work fine on real hardware.
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Cc: [email protected] [3.5+]
 
-    Signed-off-by: David S. Miller <[email protected]>
 
-
 
-commit 071e3ef4a94a021b16a2912f3885c86f4ff36b49
 
-Author: David S. Miller <[email protected]>
 
-Date:   Sun Nov 25 15:52:09 2012 -0500
 
-
 
-    Revert "8139cp: revert "set ring address before enabling receiver""
 
-    
-    This reverts commit b26623dab7eeb1e9f5898c7a49458789dd492f20.
 
-    
-    This reverts the revert, in net-next we'll try another scheme
 
-    to fix this bug using patches from David Woodhouse.
 
-    
-    Signed-off-by: David S. Miller <[email protected]>
 
-
 
---- a/drivers/net/ethernet/realtek/8139cp.c
 
-+++ b/drivers/net/ethernet/realtek/8139cp.c
 
-@@ -645,6 +645,7 @@ static void cp_tx (struct cp_private *cp
 
- {
 
- 	unsigned tx_head = cp->tx_head;
 
- 	unsigned tx_tail = cp->tx_tail;
 
-+	unsigned bytes_compl = 0, pkts_compl = 0;
 
- 
- 	while (tx_tail != tx_head) {
 
- 		struct cp_desc *txd = cp->tx_ring + tx_tail;
 
-@@ -663,6 +664,9 @@ static void cp_tx (struct cp_private *cp
 
- 				 le32_to_cpu(txd->opts1) & 0xffff,
 
- 				 PCI_DMA_TODEVICE);
 
- 
-+		bytes_compl += skb->len;
 
-+		pkts_compl++;
 
-+
 
- 		if (status & LastFrag) {
 
- 			if (status & (TxError | TxFIFOUnder)) {
 
- 				netif_dbg(cp, tx_err, cp->dev,
 
-@@ -694,6 +698,7 @@ static void cp_tx (struct cp_private *cp
 
- 
- 	cp->tx_tail = tx_tail;
 
- 
-+	netdev_completed_queue(cp->dev, pkts_compl, bytes_compl);
 
- 	if (TX_BUFFS_AVAIL(cp) > (MAX_SKB_FRAGS + 1))
 
- 		netif_wake_queue(cp->dev);
 
- }
 
-@@ -840,6 +845,8 @@ static netdev_tx_t cp_start_xmit (struct
 
- 		wmb();
 
- 	}
 
- 	cp->tx_head = entry;
 
-+
 
-+	netdev_sent_queue(dev, skb->len);
 
- 	netif_dbg(cp, tx_queued, cp->dev, "tx queued, slot %d, skblen %d\n",
 
- 		  entry, skb->len);
 
- 	if (TX_BUFFS_AVAIL(cp) <= (MAX_SKB_FRAGS + 1))
 
-@@ -934,6 +941,8 @@ static void cp_stop_hw (struct cp_privat
 
- 
- 	cp->rx_tail = 0;
 
- 	cp->tx_head = cp->tx_tail = 0;
 
-+
 
-+	netdev_reset_queue(cp->dev);
 
- }
 
- 
- static void cp_reset_hw (struct cp_private *cp)
 
-@@ -954,8 +963,38 @@ static void cp_reset_hw (struct cp_priva
 
- 
- static inline void cp_start_hw (struct cp_private *cp)
 
- {
 
-+	dma_addr_t ring_dma;
 
-+
 
- 	cpw16(CpCmd, cp->cpcmd);
 
-+
 
-+	/*
 
-+	 * These (at least TxRingAddr) need to be configured after the
 
-+	 * corresponding bits in CpCmd are enabled. Datasheet v1.6 §6.33
 
-+	 * (C+ Command Register) recommends that these and more be configured
 
-+	 * *after* the [RT]xEnable bits in CpCmd are set. And on some hardware
 
-+	 * it's been observed that the TxRingAddr is actually reset to garbage
 
-+	 * when C+ mode Tx is enabled in CpCmd.
 
-+	 */
 
-+	cpw32_f(HiTxRingAddr, 0);
 
-+	cpw32_f(HiTxRingAddr + 4, 0);
 
-+
 
-+	ring_dma = cp->ring_dma;
 
-+	cpw32_f(RxRingAddr, ring_dma & 0xffffffff);
 
-+	cpw32_f(RxRingAddr + 4, (ring_dma >> 16) >> 16);
 
-+
 
-+	ring_dma += sizeof(struct cp_desc) * CP_RX_RING_SIZE;
 
-+	cpw32_f(TxRingAddr, ring_dma & 0xffffffff);
 
-+	cpw32_f(TxRingAddr + 4, (ring_dma >> 16) >> 16);
 
-+
 
-+	/*
 
-+	 * Strictly speaking, the datasheet says this should be enabled
 
-+	 * *before* setting the descriptor addresses. But what, then, would
 
-+	 * prevent it from doing DMA to random unconfigured addresses?
 
-+	 * This variant appears to work fine.
 
-+	 */
 
- 	cpw8(Cmd, RxOn | TxOn);
 
-+
 
-+	netdev_reset_queue(cp->dev);
 
- }
 
- 
- static void cp_enable_irq(struct cp_private *cp)
 
-@@ -966,7 +1005,6 @@ static void cp_enable_irq(struct cp_priv
 
- static void cp_init_hw (struct cp_private *cp)
 
- {
 
- 	struct net_device *dev = cp->dev;
 
--	dma_addr_t ring_dma;
 
- 
- 	cp_reset_hw(cp);
 
- 
-@@ -989,17 +1027,6 @@ static void cp_init_hw (struct cp_privat
 
- 
- 	cpw8(Config5, cpr8(Config5) & PMEStatus);
 
- 
--	cpw32_f(HiTxRingAddr, 0);
 
--	cpw32_f(HiTxRingAddr + 4, 0);
 
--
 
--	ring_dma = cp->ring_dma;
 
--	cpw32_f(RxRingAddr, ring_dma & 0xffffffff);
 
--	cpw32_f(RxRingAddr + 4, (ring_dma >> 16) >> 16);
 
--
 
--	ring_dma += sizeof(struct cp_desc) * CP_RX_RING_SIZE;
 
--	cpw32_f(TxRingAddr, ring_dma & 0xffffffff);
 
--	cpw32_f(TxRingAddr + 4, (ring_dma >> 16) >> 16);
 
--
 
- 	cpw16(MultiIntr, 0);
 
- 
- 	cpw8_f(Cfg9346, Cfg9346_Lock);
 
-@@ -1188,6 +1215,7 @@ static void cp_tx_timeout(struct net_dev
 
- 	cp_clean_rings(cp);
 
- 	rc = cp_init_rings(cp);
 
- 	cp_start_hw(cp);
 
-+	cp_enable_irq(cp);
 
- 
- 	netif_wake_queue(dev);
 
-

+ 0 - 68
target/linux/generic/patches-3.3/070-gpio-add-flags-to-export-GPIOs-when-requesting.patch
View File 

@@ -1,68 +0,0 @@
 
-From fc3a1f04f5040255cbc086c419e4237f29f89f88 Mon Sep 17 00:00:00 2001
 
-From: Wolfram Sang <[email protected]>
 
-Date: Tue, 13 Dec 2011 18:34:01 +0100
 
-Subject: [PATCH] gpio: add flags to export GPIOs when requesting
 
-
 
-commit fc3a1f04f5040255cbc086c419e4237f29f89f88 upstream.
 
-
 
-Introduce new flags to automatically export GPIOs when using the convenience
 
-functions gpio_request_one() or gpio_request_array(). This eases support for
 
-custom boards where lots of GPIOs need to be exported for customer
 
-applications.
 
-
 
-Signed-off-by: Wolfram Sang <[email protected]>
 
-Signed-off-by: Grant Likely <[email protected]>
 
----
 
- Documentation/gpio.txt |    3 +++
 
- drivers/gpio/gpiolib.c |   12 +++++++++++-
 
- include/linux/gpio.h   |    5 +++++
 
- 3 files changed, 19 insertions(+), 1 deletion(-)
 
-
 
---- a/Documentation/gpio.txt
 
-+++ b/Documentation/gpio.txt
 
-@@ -303,6 +303,9 @@ where 'flags' is currently defined to sp
 
- 	* GPIOF_INIT_LOW	- as output, set initial level to LOW
 
- 	* GPIOF_INIT_HIGH	- as output, set initial level to HIGH
 
- 
-+	* GPIOF_EXPORT_DIR_FIXED	- export gpio to sysfs, keep direction
 
-+	* GPIOF_EXPORT_DIR_CHANGEABLE	- also export, allow changing direction
 
-+
 
- since GPIOF_INIT_* are only valid when configured as output, so group valid
 
- combinations as:
 
- 
---- a/drivers/gpio/gpiolib.c
 
-+++ b/drivers/gpio/gpiolib.c
 
-@@ -1289,8 +1289,18 @@ int gpio_request_one(unsigned gpio, unsi
 
- 				(flags & GPIOF_INIT_HIGH) ? 1 : 0);
 
- 
- 	if (err)
 
--		gpio_free(gpio);
 
-+		goto free_gpio;
 
- 
-+	if (flags & GPIOF_EXPORT) {
 
-+		err = gpio_export(gpio, flags & GPIOF_EXPORT_CHANGEABLE);
 
-+		if (err)
 
-+			goto free_gpio;
 
-+	}
 
-+
 
-+	return 0;
 
-+
 
-+ free_gpio:
 
-+	gpio_free(gpio);
 
- 	return err;
 
- }
 
- EXPORT_SYMBOL_GPL(gpio_request_one);
 
---- a/include/linux/gpio.h
 
-+++ b/include/linux/gpio.h
 
-@@ -14,6 +14,11 @@
 
- #define GPIOF_OUT_INIT_LOW	(GPIOF_DIR_OUT | GPIOF_INIT_LOW)
 
- #define GPIOF_OUT_INIT_HIGH	(GPIOF_DIR_OUT | GPIOF_INIT_HIGH)
 
- 
-+#define GPIOF_EXPORT		(1 << 2)
 
-+#define GPIOF_EXPORT_CHANGEABLE	(1 << 3)
 
-+#define GPIOF_EXPORT_DIR_FIXED	(GPIOF_EXPORT)
 
-+#define GPIOF_EXPORT_DIR_CHANGEABLE (GPIOF_EXPORT | GPIOF_EXPORT_CHANGEABLE)
 
-+
 
- /**
 
-  * struct gpio - a structure describing a GPIO with configuration
 
-  * @gpio:	the GPIO number

+ 0 - 27
target/linux/generic/patches-3.3/080-prot-release-cb.patch
View File 

@@ -1,27 +0,0 @@
 
-This was added in commit 46d3ceabd8d98ed0ad10f20c595ca784e34786c5 (tcp: 
-TCP Small Queues) but we need it for pppoatm too.
 
-
 
---- a/include/net/sock.h
 
-+++ b/include/net/sock.h
 
-@@ -810,6 +810,8 @@ struct proto {
 
- 	int			(*backlog_rcv) (struct sock *sk, 
- 						struct sk_buff *skb);
 
- 
-+	void		(*release_cb)(struct sock *sk);
 
-+
 
- 	/* Keeping track of sk's, looking them up, and port selection methods. */
 
- 	void			(*hash)(struct sock *sk);
 
- 	void			(*unhash)(struct sock *sk);
 
---- a/net/core/sock.c
 
-+++ b/net/core/sock.c
 
-@@ -2138,6 +2138,10 @@ void release_sock(struct sock *sk)
 
- 	spin_lock_bh(&sk->sk_lock.slock);
 
- 	if (sk->sk_backlog.tail)
 
- 		__release_sock(sk);
 
-+
 
-+	if (sk->sk_prot->release_cb)
 
-+		sk->sk_prot->release_cb(sk);
 
-+
 
- 	sk->sk_lock.owned = 0;
 
- 	if (waitqueue_active(&sk->sk_lock.wq))
 
- 		wake_up(&sk->sk_lock.wq);

+ 0 - 271
target/linux/generic/patches-3.3/081-USB-OHCI-Add-a-generic-platform-device-driver.patch
View File 

@@ -1,271 +0,0 @@
 
---- a/drivers/usb/host/Kconfig
 
-+++ b/drivers/usb/host/Kconfig
 
-@@ -393,6 +393,16 @@ config USB_CNS3XXX_OHCI
 
- 	  Enable support for the CNS3XXX SOC's on-chip OHCI controller.
 
- 	  It is needed for low-speed USB 1.0 device support.
 
- 
-+config USB_OHCI_HCD_PLATFORM
 
-+	bool "Generic OHCI driver for a platform device"
 
-+	depends on USB_OHCI_HCD && EXPERIMENTAL
 
-+	default n
 
-+	---help---
 
-+	  Adds an OHCI host driver for a generic platform device, which
 
-+	  provieds a memory space and an irq.
 
-+
 
-+	  If unsure, say N.
 
-+
 
- config USB_OHCI_BIG_ENDIAN_DESC
 
- 	bool
 
- 	depends on USB_OHCI_HCD
 
---- a/drivers/usb/host/ohci-hcd.c
 
-+++ b/drivers/usb/host/ohci-hcd.c
 
-@@ -1121,6 +1121,11 @@ MODULE_LICENSE ("GPL");
 
- #define PLATFORM_DRIVER		ohci_xls_driver
 
- #endif
 
- 
-+#ifdef CONFIG_USB_OHCI_HCD_PLATFORM
 
-+#include "ohci-platform.c"
 
-+#define PLATFORM_DRIVER		ohci_platform_driver
 
-+#endif
 
-+
 
- #if	!defined(PCI_DRIVER) &&		\
 
- 	!defined(PLATFORM_DRIVER) &&	\
 
- 	!defined(OMAP1_PLATFORM_DRIVER) &&	\
 
---- /dev/null
 
-+++ b/drivers/usb/host/ohci-platform.c
 
-@@ -0,0 +1,194 @@
 
-+/*
 
-+ * Generic platform ohci driver
 
-+ *
 
-+ * Copyright 2007 Michael Buesch <[email protected]>
 
-+ * Copyright 2011-2012 Hauke Mehrtens <[email protected]>
 
-+ *
 
-+ * Derived from the OCHI-SSB driver
 
-+ * Derived from the OHCI-PCI driver
 
-+ * Copyright 1999 Roman Weissgaerber
 
-+ * Copyright 2000-2002 David Brownell
 
-+ * Copyright 1999 Linus Torvalds
 
-+ * Copyright 1999 Gregory P. Smith
 
-+ *
 
-+ * Licensed under the GNU/GPL. See COPYING for details.
 
-+ */
 
-+#include <linux/platform_device.h>
 
-+#include <linux/usb/ohci_pdriver.h>
 
-+
 
-+static int ohci_platform_reset(struct usb_hcd *hcd)
 
-+{
 
-+	struct platform_device *pdev = to_platform_device(hcd->self.controller);
 
-+	struct usb_ohci_pdata *pdata = pdev->dev.platform_data;
 
-+	struct ohci_hcd *ohci = hcd_to_ohci(hcd);
 
-+	int err;
 
-+
 
-+	if (pdata->big_endian_desc)
 
-+		ohci->flags |= OHCI_QUIRK_BE_DESC;
 
-+	if (pdata->big_endian_mmio)
 
-+		ohci->flags |= OHCI_QUIRK_BE_MMIO;
 
-+	if (pdata->no_big_frame_no)
 
-+		ohci->flags |= OHCI_QUIRK_FRAME_NO;
 
-+
 
-+	ohci_hcd_init(ohci);
 
-+	err = ohci_init(ohci);
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+static int ohci_platform_start(struct usb_hcd *hcd)
 
-+{
 
-+	struct ohci_hcd *ohci = hcd_to_ohci(hcd);
 
-+	int err;
 
-+
 
-+	err = ohci_run(ohci);
 
-+	if (err < 0) {
 
-+		ohci_err(ohci, "can't start\n");
 
-+		ohci_stop(hcd);
 
-+	}
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+static const struct hc_driver ohci_platform_hc_driver = {
 
-+	.description		= hcd_name,
 
-+	.product_desc		= "Generic Platform OHCI Controller",
 
-+	.hcd_priv_size		= sizeof(struct ohci_hcd),
 
-+
 
-+	.irq			= ohci_irq,
 
-+	.flags			= HCD_MEMORY | HCD_USB11,
 
-+
 
-+	.reset			= ohci_platform_reset,
 
-+	.start			= ohci_platform_start,
 
-+	.stop			= ohci_stop,
 
-+	.shutdown		= ohci_shutdown,
 
-+
 
-+	.urb_enqueue		= ohci_urb_enqueue,
 
-+	.urb_dequeue		= ohci_urb_dequeue,
 
-+	.endpoint_disable	= ohci_endpoint_disable,
 
-+
 
-+	.get_frame_number	= ohci_get_frame,
 
-+
 
-+	.hub_status_data	= ohci_hub_status_data,
 
-+	.hub_control		= ohci_hub_control,
 
-+#ifdef	CONFIG_PM
 
-+	.bus_suspend		= ohci_bus_suspend,
 
-+	.bus_resume		= ohci_bus_resume,
 
-+#endif
 
-+
 
-+	.start_port_reset	= ohci_start_port_reset,
 
-+};
 
-+
 
-+static int __devinit ohci_platform_probe(struct platform_device *dev)
 
-+{
 
-+	struct usb_hcd *hcd;
 
-+	struct resource *res_mem;
 
-+	int irq;
 
-+	int err = -ENOMEM;
 
-+
 
-+	BUG_ON(!dev->dev.platform_data);
 
-+
 
-+	if (usb_disabled())
 
-+		return -ENODEV;
 
-+
 
-+	irq = platform_get_irq(dev, 0);
 
-+	if (irq < 0) {
 
-+		pr_err("no irq provieded");
 
-+		return irq;
 
-+	}
 
-+
 
-+	res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
 
-+	if (!res_mem) {
 
-+		pr_err("no memory recourse provieded");
 
-+		return -ENXIO;
 
-+	}
 
-+
 
-+	hcd = usb_create_hcd(&ohci_platform_hc_driver, &dev->dev,
 
-+			dev_name(&dev->dev));
 
-+	if (!hcd)
 
-+		return -ENOMEM;
 
-+
 
-+	hcd->rsrc_start = res_mem->start;
 
-+	hcd->rsrc_len = resource_size(res_mem);
 
-+
 
-+	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
 
-+		pr_err("controller already in use");
 
-+		err = -EBUSY;
 
-+		goto err_put_hcd;
 
-+	}
 
-+
 
-+	hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
 
-+	if (!hcd->regs)
 
-+		goto err_release_region;
 
-+	err = usb_add_hcd(hcd, irq, IRQF_SHARED);
 
-+	if (err)
 
-+		goto err_iounmap;
 
-+
 
-+	platform_set_drvdata(dev, hcd);
 
-+
 
-+	return err;
 
-+
 
-+err_iounmap:
 
-+	iounmap(hcd->regs);
 
-+err_release_region:
 
-+	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 
-+err_put_hcd:
 
-+	usb_put_hcd(hcd);
 
-+	return err;
 
-+}
 
-+
 
-+static int __devexit ohci_platform_remove(struct platform_device *dev)
 
-+{
 
-+	struct usb_hcd *hcd = platform_get_drvdata(dev);
 
-+
 
-+	usb_remove_hcd(hcd);
 
-+	iounmap(hcd->regs);
 
-+	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 
-+	usb_put_hcd(hcd);
 
-+	platform_set_drvdata(dev, NULL);
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+#ifdef CONFIG_PM
 
-+
 
-+static int ohci_platform_suspend(struct device *dev)
 
-+{
 
-+	return 0;
 
-+}
 
-+
 
-+static int ohci_platform_resume(struct device *dev)
 
-+{
 
-+	struct usb_hcd *hcd = dev_get_drvdata(dev);
 
-+
 
-+	ohci_finish_controller_resume(hcd);
 
-+	return 0;
 
-+}
 
-+
 
-+#else /* !CONFIG_PM */
 
-+#define ohci_platform_suspend	NULL
 
-+#define ohci_platform_resume	NULL
 
-+#endif /* CONFIG_PM */
 
-+
 
-+static const struct platform_device_id ohci_platform_table[] = {
 
-+	{ "ohci-platform", 0 },
 
-+	{ }
 
-+};
 
-+MODULE_DEVICE_TABLE(platform, ohci_platform_table);
 
-+
 
-+static const struct dev_pm_ops ohci_platform_pm_ops = {
 
-+	.suspend	= ohci_platform_suspend,
 
-+	.resume		= ohci_platform_resume,
 
-+};
 
-+
 
-+static struct platform_driver ohci_platform_driver = {
 
-+	.id_table	= ohci_platform_table,
 
-+	.probe		= ohci_platform_probe,
 
-+	.remove		= __devexit_p(ohci_platform_remove),
 
-+	.shutdown	= usb_hcd_platform_shutdown,
 
-+	.driver		= {
 
-+		.owner	= THIS_MODULE,
 
-+		.name	= "ohci-platform",
 
-+		.pm	= &ohci_platform_pm_ops,
 
-+	}
 
-+};
 
---- /dev/null
 
-+++ b/include/linux/usb/ohci_pdriver.h
 
-@@ -0,0 +1,38 @@
 
-+/*
 
-+ * Copyright (C) 2012 Hauke Mehrtens <[email protected]>
 
-+ *
 
-+ * This program is free software; you can redistribute it and/or modify it
 
-+ * under the terms of the GNU General Public License as published by the
 
-+ * Free Software Foundation; either version 2 of the License, or (at your
 
-+ * option) any later version.
 
-+ *
 
-+ * This program is distributed in the hope that it will be useful, but
 
-+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 
-+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 
-+ * for more details.
 
-+ *
 
-+ * You should have received a copy of the GNU General Public License
 
-+ * along with this program; if not, write to the Free Software Foundation,
 
-+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-+ */
 
-+
 
-+#ifndef __USB_CORE_OHCI_PDRIVER_H
 
-+#define __USB_CORE_OHCI_PDRIVER_H
 
-+
 
-+/**
 
-+ * struct usb_ohci_pdata - platform_data for generic ohci driver
 
-+ *
 
-+ * @big_endian_desc:	BE descriptors
 
-+ * @big_endian_mmio:	BE registers
 
-+ * @no_big_frame_no:	no big endian frame_no shift
 
-+ *
 
-+ * These are general configuration options for the OHCI controller. All of
 
-+ * these options are activating more or less workarounds for some hardware.
 
-+ */
 
-+struct usb_ohci_pdata {
 
-+	unsigned	big_endian_desc:1;
 
-+	unsigned	big_endian_mmio:1;
 
-+	unsigned	no_big_frame_no:1;
 
-+};
 
-+
 
-+#endif /* __USB_CORE_OHCI_PDRIVER_H */

+ 0 - 283
target/linux/generic/patches-3.3/082-USB-EHCI-Add-a-generic-platform-device-driver.patch
View File 

@@ -1,283 +0,0 @@
 
---- a/drivers/usb/host/Kconfig
 
-+++ b/drivers/usb/host/Kconfig
 
-@@ -403,6 +403,16 @@ config USB_OHCI_HCD_PLATFORM
 
- 
- 	  If unsure, say N.
 
- 
-+config USB_EHCI_HCD_PLATFORM
 
-+	bool "Generic EHCI driver for a platform device"
 
-+	depends on USB_EHCI_HCD && EXPERIMENTAL
 
-+	default n
 
-+	---help---
 
-+	  Adds an EHCI host driver for a generic platform device, which
 
-+	  provieds a memory space and an irq.
 
-+
 
-+	  If unsure, say N.
 
-+
 
- config USB_OHCI_BIG_ENDIAN_DESC
 
- 	bool
 
- 	depends on USB_OHCI_HCD
 
---- a/drivers/usb/host/ehci-hcd.c
 
-+++ b/drivers/usb/host/ehci-hcd.c
 
-@@ -1381,6 +1381,11 @@ MODULE_LICENSE ("GPL");
 
- #define        PLATFORM_DRIVER         ehci_mv_driver
 
- #endif
 
- 
-+#ifdef CONFIG_USB_EHCI_HCD_PLATFORM
 
-+#include "ehci-platform.c"
 
-+#define PLATFORM_DRIVER		ehci_platform_driver
 
-+#endif
 
-+
 
- #if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
 
-     !defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) && \
 
-     !defined(XILINX_OF_PLATFORM_DRIVER)
 
---- /dev/null
 
-+++ b/drivers/usb/host/ehci-platform.c
 
-@@ -0,0 +1,198 @@
 
-+/*
 
-+ * Generic platform ehci driver
 
-+ *
 
-+ * Copyright 2007 Steven Brown <[email protected]>
 
-+ * Copyright 2010-2012 Hauke Mehrtens <[email protected]>
 
-+ *
 
-+ * Derived from the ohci-ssb driver
 
-+ * Copyright 2007 Michael Buesch <[email protected]>
 
-+ *
 
-+ * Derived from the EHCI-PCI driver
 
-+ * Copyright (c) 2000-2004 by David Brownell
 
-+ *
 
-+ * Derived from the ohci-pci driver
 
-+ * Copyright 1999 Roman Weissgaerber
 
-+ * Copyright 2000-2002 David Brownell
 
-+ * Copyright 1999 Linus Torvalds
 
-+ * Copyright 1999 Gregory P. Smith
 
-+ *
 
-+ * Licensed under the GNU/GPL. See COPYING for details.
 
-+ */
 
-+#include <linux/platform_device.h>
 
-+#include <linux/usb/ehci_pdriver.h>
 
-+
 
-+static int ehci_platform_reset(struct usb_hcd *hcd)
 
-+{
 
-+	struct platform_device *pdev = to_platform_device(hcd->self.controller);
 
-+	struct usb_ehci_pdata *pdata = pdev->dev.platform_data;
 
-+	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 
-+	int retval;
 
-+
 
-+	hcd->has_tt = pdata->has_tt;
 
-+	ehci->has_synopsys_hc_bug = pdata->has_synopsys_hc_bug;
 
-+	ehci->big_endian_desc = pdata->big_endian_desc;
 
-+	ehci->big_endian_mmio = pdata->big_endian_mmio;
 
-+
 
-+	ehci->caps = hcd->regs + pdata->caps_offset;
 
-+	retval = ehci_setup(hcd);
 
-+	if (retval)
 
-+		return retval;
 
-+
 
-+	if (pdata->port_power_on)
 
-+		ehci_port_power(ehci, 1);
 
-+	if (pdata->port_power_off)
 
-+		ehci_port_power(ehci, 0);
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static const struct hc_driver ehci_platform_hc_driver = {
 
-+	.description		= hcd_name,
 
-+	.product_desc		= "Generic Platform EHCI Controller",
 
-+	.hcd_priv_size		= sizeof(struct ehci_hcd),
 
-+
 
-+	.irq			= ehci_irq,
 
-+	.flags			= HCD_MEMORY | HCD_USB2,
 
-+
 
-+	.reset			= ehci_platform_reset,
 
-+	.start			= ehci_run,
 
-+	.stop			= ehci_stop,
 
-+	.shutdown		= ehci_shutdown,
 
-+
 
-+	.urb_enqueue		= ehci_urb_enqueue,
 
-+	.urb_dequeue		= ehci_urb_dequeue,
 
-+	.endpoint_disable	= ehci_endpoint_disable,
 
-+	.endpoint_reset		= ehci_endpoint_reset,
 
-+
 
-+	.get_frame_number	= ehci_get_frame,
 
-+
 
-+	.hub_status_data	= ehci_hub_status_data,
 
-+	.hub_control		= ehci_hub_control,
 
-+#if defined(CONFIG_PM)
 
-+	.bus_suspend		= ehci_bus_suspend,
 
-+	.bus_resume		= ehci_bus_resume,
 
-+#endif
 
-+	.relinquish_port	= ehci_relinquish_port,
 
-+	.port_handed_over	= ehci_port_handed_over,
 
-+
 
-+	.update_device		= ehci_update_device,
 
-+
 
-+	.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
 
-+};
 
-+
 
-+static int __devinit ehci_platform_probe(struct platform_device *dev)
 
-+{
 
-+	struct usb_hcd *hcd;
 
-+	struct resource *res_mem;
 
-+	int irq;
 
-+	int err = -ENOMEM;
 
-+
 
-+	BUG_ON(!dev->dev.platform_data);
 
-+
 
-+	if (usb_disabled())
 
-+		return -ENODEV;
 
-+
 
-+	irq = platform_get_irq(dev, 0);
 
-+	if (irq < 0) {
 
-+		pr_err("no irq provieded");
 
-+		return irq;
 
-+	}
 
-+	res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
 
-+	if (!res_mem) {
 
-+		pr_err("no memory recourse provieded");
 
-+		return -ENXIO;
 
-+	}
 
-+
 
-+	hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev,
 
-+			     dev_name(&dev->dev));
 
-+	if (!hcd)
 
-+		return -ENOMEM;
 
-+
 
-+	hcd->rsrc_start = res_mem->start;
 
-+	hcd->rsrc_len = resource_size(res_mem);
 
-+
 
-+	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
 
-+		pr_err("controller already in use");
 
-+		err = -EBUSY;
 
-+		goto err_put_hcd;
 
-+	}
 
-+
 
-+	hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
 
-+	if (!hcd->regs)
 
-+		goto err_release_region;
 
-+	err = usb_add_hcd(hcd, irq, IRQF_SHARED);
 
-+	if (err)
 
-+		goto err_iounmap;
 
-+
 
-+	platform_set_drvdata(dev, hcd);
 
-+
 
-+	return err;
 
-+
 
-+err_iounmap:
 
-+	iounmap(hcd->regs);
 
-+err_release_region:
 
-+	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 
-+err_put_hcd:
 
-+	usb_put_hcd(hcd);
 
-+	return err;
 
-+}
 
-+
 
-+static int __devexit ehci_platform_remove(struct platform_device *dev)
 
-+{
 
-+	struct usb_hcd *hcd = platform_get_drvdata(dev);
 
-+
 
-+	usb_remove_hcd(hcd);
 
-+	iounmap(hcd->regs);
 
-+	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 
-+	usb_put_hcd(hcd);
 
-+	platform_set_drvdata(dev, NULL);
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+#ifdef CONFIG_PM
 
-+
 
-+static int ehci_platform_suspend(struct device *dev)
 
-+{
 
-+	struct usb_hcd *hcd = dev_get_drvdata(dev);
 
-+	bool wakeup = device_may_wakeup(dev);
 
-+
 
-+	ehci_prepare_ports_for_controller_suspend(hcd_to_ehci(hcd), wakeup);
 
-+	return 0;
 
-+}
 
-+
 
-+static int ehci_platform_resume(struct device *dev)
 
-+{
 
-+	struct usb_hcd *hcd = dev_get_drvdata(dev);
 
-+
 
-+	ehci_prepare_ports_for_controller_resume(hcd_to_ehci(hcd));
 
-+	return 0;
 
-+}
 
-+
 
-+#else /* !CONFIG_PM */
 
-+#define ehci_platform_suspend	NULL
 
-+#define ehci_platform_resume	NULL
 
-+#endif /* CONFIG_PM */
 
-+
 
-+static const struct platform_device_id ehci_platform_table[] = {
 
-+	{ "ehci-platform", 0 },
 
-+	{ }
 
-+};
 
-+MODULE_DEVICE_TABLE(platform, ehci_platform_table);
 
-+
 
-+static const struct dev_pm_ops ehci_platform_pm_ops = {
 
-+	.suspend	= ehci_platform_suspend,
 
-+	.resume		= ehci_platform_resume,
 
-+};
 
-+
 
-+static struct platform_driver ehci_platform_driver = {
 
-+	.id_table	= ehci_platform_table,
 
-+	.probe		= ehci_platform_probe,
 
-+	.remove		= __devexit_p(ehci_platform_remove),
 
-+	.shutdown	= usb_hcd_platform_shutdown,
 
-+	.driver		= {
 
-+		.owner	= THIS_MODULE,
 
-+		.name	= "ehci-platform",
 
-+		.pm	= &ehci_platform_pm_ops,
 
-+	}
 
-+};
 
---- /dev/null
 
-+++ b/include/linux/usb/ehci_pdriver.h
 
-@@ -0,0 +1,46 @@
 
-+/*
 
-+ * Copyright (C) 2012 Hauke Mehrtens <[email protected]>
 
-+ *
 
-+ * This program is free software; you can redistribute it and/or modify it
 
-+ * under the terms of the GNU General Public License as published by the
 
-+ * Free Software Foundation; either version 2 of the License, or (at your
 
-+ * option) any later version.
 
-+ *
 
-+ * This program is distributed in the hope that it will be useful, but
 
-+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 
-+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 
-+ * for more details.
 
-+ *
 
-+ * You should have received a copy of the GNU General Public License
 
-+ * along with this program; if not, write to the Free Software Foundation,
 
-+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-+ */
 
-+
 
-+#ifndef __USB_CORE_EHCI_PDRIVER_H
 
-+#define __USB_CORE_EHCI_PDRIVER_H
 
-+
 
-+/**
 
-+ * struct usb_ehci_pdata - platform_data for generic ehci driver
 
-+ *
 
-+ * @caps_offset:	offset of the EHCI Capability Registers to the start of
 
-+ *			the io memory region provided to the driver.
 
-+ * @has_tt:		set to 1 if TT is integrated in root hub.
 
-+ * @port_power_on:	set to 1 if the controller needs a power up after
 
-+ *			initialization.
 
-+ * @port_power_off:	set to 1 if the controller needs to be powered down
 
-+ *			after initialization.
 
-+ *
 
-+ * These are general configuration options for the EHCI controller. All of
 
-+ * these options are activating more or less workarounds for some hardware.
 
-+ */
 
-+struct usb_ehci_pdata {
 
-+	int		caps_offset;
 
-+	unsigned	has_tt:1;
 
-+	unsigned	has_synopsys_hc_bug:1;
 
-+	unsigned	big_endian_desc:1;
 
-+	unsigned	big_endian_mmio:1;
 
-+	unsigned	port_power_on:1;
 
-+	unsigned	port_power_off:1;
 
-+};
 
-+
 
-+#endif /* __USB_CORE_EHCI_PDRIVER_H */

+ 0 - 11
target/linux/generic/patches-3.3/083-USB-EHCI-platform-remove-update.patch
View File 

@@ -1,11 +0,0 @@
 
---- a/drivers/usb/host/ehci-platform.c
 
-+++ b/drivers/usb/host/ehci-platform.c
 
-@@ -75,8 +75,6 @@ static const struct hc_driver ehci_platf
 
- 	.relinquish_port	= ehci_relinquish_port,
 
- 	.port_handed_over	= ehci_port_handed_over,
 
- 
--	.update_device		= ehci_update_device,
 
--
 
- 	.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
 
- };
 
-

+ 0 - 27
target/linux/generic/patches-3.3/084-x86_fix_perf_uclibc_build.patch
View File 

@@ -1,27 +0,0 @@
 
-From 031d8ad2c3cee85c515e551fc8c0054bdedb7b8b Mon Sep 17 00:00:00 2001
 
-From: Florian Fainelli <[email protected]>
 
-Date: Thu, 13 Dec 2012 18:02:11 +0100
 
-Subject: [PATCH] x86: fix perf build with uclibc toolchains
 
-
 
-libio.h is not provided by uClibc, in order to be able to test the
 
-definition of __UCLIBC__ we need to include stdlib.h, which also
 
-includes stddef.h, providing the definition of 'NULL'
 
-
 
-Signed-off-by: Florian Fainelli <[email protected]>
 
----
 
- tools/perf/arch/x86/util/dwarf-regs.c |    3 +++
 
- 1 file changed, 3 insertions(+)
 
-
 
---- a/tools/perf/arch/x86/util/dwarf-regs.c
 
-+++ b/tools/perf/arch/x86/util/dwarf-regs.c
 
-@@ -20,7 +20,10 @@
 
-  *
 
-  */
 
- 
-+#include <stdlib.h>
 
-+#ifndef __UCLIBC__
 
- #include <libio.h>
 
-+#endif
 
- #include <dwarf-regs.h>
 
- 
- /*

+ 0 - 27
target/linux/generic/patches-3.3/090-CVE-2013-1763.patch
View File 

@@ -1,27 +0,0 @@
 
-From 6e601a53566d84e1ffd25e7b6fe0b6894ffd79c0 Mon Sep 17 00:00:00 2001
 
-From: Mathias Krause <[email protected]>
 
-Date: Sat, 23 Feb 2013 01:13:47 +0000
 
-Subject: sock_diag: Fix out-of-bounds access to sock_diag_handlers[]
 
-
 
-Userland can send a netlink message requesting SOCK_DIAG_BY_FAMILY
 
-with a family greater or equal then AF_MAX -- the array size of
 
-sock_diag_handlers[]. The current code does not test for this
 
-condition therefore is vulnerable to an out-of-bound access opening
 
-doors for a privilege escalation.
 
-
 
-Signed-off-by: Mathias Krause <[email protected]>
 
-Acked-by: Eric Dumazet <[email protected]>
 
-Signed-off-by: David S. Miller <[email protected]>
 
----
 
---- a/net/core/sock_diag.c
 
-+++ b/net/core/sock_diag.c
 
-@@ -126,6 +126,9 @@ static int __sock_diag_rcv_msg(struct sk
 
- 	if (nlmsg_len(nlh) < sizeof(*req))
 
- 		return -EINVAL;
 
- 
-+	if (req->sdiag_family >= AF_MAX)
 
-+		return -EINVAL;
 
-+
 
- 	hndl = sock_diag_lock_handler(req->sdiag_family);
 
- 	if (hndl == NULL)
 
- 		err = -ENOENT;

+ 0 - 3232
target/linux/generic/patches-3.3/100-overlayfs_v12.patch
View File 

@@ -1,3232 +0,0 @@
 
---- a/Documentation/filesystems/Locking
 
-+++ b/Documentation/filesystems/Locking
 
-@@ -62,6 +62,7 @@ ata *);
 
- 	int (*removexattr) (struct dentry *, const char *);
 
- 	void (*truncate_range)(struct inode *, loff_t, loff_t);
 
- 	int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, u64 len);
 
-+	struct file *(*open)(struct dentry *,struct file *,const struct cred *);
 
- 
- locking rules:
 
- 	all may block
 
-@@ -89,6 +90,7 @@ listxattr:	no
 
- removexattr:	yes
 
- truncate_range:	yes
 
- fiemap:		no
 
-+open:		no
 
- 	Additionally, ->rmdir(), ->unlink() and ->rename() have ->i_mutex on
 
- victim.
 
- 	cross-directory ->rename() has (per-superblock) ->s_vfs_rename_sem.
 
---- /dev/null
 
-+++ b/Documentation/filesystems/overlayfs.txt
 
-@@ -0,0 +1,199 @@
 
-+Written by: Neil Brown <[email protected]>
 
-+
 
-+Overlay Filesystem
 
-+==================
 
-+
 
-+This document describes a prototype for a new approach to providing
 
-+overlay-filesystem functionality in Linux (sometimes referred to as
 
-+union-filesystems).  An overlay-filesystem tries to present a
 
-+filesystem which is the result over overlaying one filesystem on top
 
-+of the other.
 
-+
 
-+The result will inevitably fail to look exactly like a normal
 
-+filesystem for various technical reasons.  The expectation is that
 
-+many use cases will be able to ignore these differences.
 
-+
 
-+This approach is 'hybrid' because the objects that appear in the
 
-+filesystem do not all appear to belong to that filesystem.  In many
 
-+cases an object accessed in the union will be indistinguishable
 
-+from accessing the corresponding object from the original filesystem.
 
-+This is most obvious from the 'st_dev' field returned by stat(2).
 
-+
 
-+While directories will report an st_dev from the overlay-filesystem,
 
-+all non-directory objects will report an st_dev from the lower or
 
-+upper filesystem that is providing the object.  Similarly st_ino will
 
-+only be unique when combined with st_dev, and both of these can change
 
-+over the lifetime of a non-directory object.  Many applications and
 
-+tools ignore these values and will not be affected.
 
-+
 
-+Upper and Lower
 
-+---------------
 
-+
 
-+An overlay filesystem combines two filesystems - an 'upper' filesystem
 
-+and a 'lower' filesystem.  When a name exists in both filesystems, the
 
-+object in the 'upper' filesystem is visible while the object in the
 
-+'lower' filesystem is either hidden or, in the case of directories,
 
-+merged with the 'upper' object.
 
-+
 
-+It would be more correct to refer to an upper and lower 'directory
 
-+tree' rather than 'filesystem' as it is quite possible for both
 
-+directory trees to be in the same filesystem and there is no
 
-+requirement that the root of a filesystem be given for either upper or
 
-+lower.
 
-+
 
-+The lower filesystem can be any filesystem supported by Linux and does
 
-+not need to be writable.  The lower filesystem can even be another
 
-+overlayfs.  The upper filesystem will normally be writable and if it
 
-+is it must support the creation of trusted.* extended attributes, and
 
-+must provide valid d_type in readdir responses, at least for symbolic
 
-+links - so NFS is not suitable.
 
-+
 
-+A read-only overlay of two read-only filesystems may use any
 
-+filesystem type.
 
-+
 
-+Directories
 
-+-----------
 
-+
 
-+Overlaying mainly involved directories.  If a given name appears in both
 
-+upper and lower filesystems and refers to a non-directory in either,
 
-+then the lower object is hidden - the name refers only to the upper
 
-+object.
 
-+
 
-+Where both upper and lower objects are directories, a merged directory
 
-+is formed.
 
-+
 
-+At mount time, the two directories given as mount options are combined
 
-+into a merged directory:
 
-+
 
-+  mount -t overlayfs overlayfs -olowerdir=/lower,upperdir=/upper /overlay
 
-+
 
-+Then whenever a lookup is requested in such a merged directory, the
 
-+lookup is performed in each actual directory and the combined result
 
-+is cached in the dentry belonging to the overlay filesystem.  If both
 
-+actual lookups find directories, both are stored and a merged
 
-+directory is created, otherwise only one is stored: the upper if it
 
-+exists, else the lower.
 
-+
 
-+Only the lists of names from directories are merged.  Other content
 
-+such as metadata and extended attributes are reported for the upper
 
-+directory only.  These attributes of the lower directory are hidden.
 
-+
 
-+whiteouts and opaque directories
 
-+--------------------------------
 
-+
 
-+In order to support rm and rmdir without changing the lower
 
-+filesystem, an overlay filesystem needs to record in the upper filesystem
 
-+that files have been removed.  This is done using whiteouts and opaque
 
-+directories (non-directories are always opaque).
 
-+
 
-+The overlay filesystem uses extended attributes with a
 
-+"trusted.overlay."  prefix to record these details.
 
-+
 
-+A whiteout is created as a symbolic link with target
 
-+"(overlay-whiteout)" and with xattr "trusted.overlay.whiteout" set to "y".
 
-+When a whiteout is found in the upper level of a merged directory, any
 
-+matching name in the lower level is ignored, and the whiteout itself
 
-+is also hidden.
 
-+
 
-+A directory is made opaque by setting the xattr "trusted.overlay.opaque"
 
-+to "y".  Where the upper filesystem contains an opaque directory, any
 
-+directory in the lower filesystem with the same name is ignored.
 
-+
 
-+readdir
 
-+-------
 
-+
 
-+When a 'readdir' request is made on a merged directory, the upper and
 
-+lower directories are each read and the name lists merged in the
 
-+obvious way (upper is read first, then lower - entries that already
 
-+exist are not re-added).  This merged name list is cached in the
 
-+'struct file' and so remains as long as the file is kept open.  If the
 
-+directory is opened and read by two processes at the same time, they
 
-+will each have separate caches.  A seekdir to the start of the
 
-+directory (offset 0) followed by a readdir will cause the cache to be
 
-+discarded and rebuilt.
 
-+
 
-+This means that changes to the merged directory do not appear while a
 
-+directory is being read.  This is unlikely to be noticed by many
 
-+programs.
 
-+
 
-+seek offsets are assigned sequentially when the directories are read.
 
-+Thus if
 
-+  - read part of a directory
 
-+  - remember an offset, and close the directory
 
-+  - re-open the directory some time later
 
-+  - seek to the remembered offset
 
-+
 
-+there may be little correlation between the old and new locations in
 
-+the list of filenames, particularly if anything has changed in the
 
-+directory.
 
-+
 
-+Readdir on directories that are not merged is simply handled by the
 
-+underlying directory (upper or lower).
 
-+
 
-+
 
-+Non-directories
 
-+---------------
 
-+
 
-+Objects that are not directories (files, symlinks, device-special
 
-+files etc.) are presented either from the upper or lower filesystem as
 
-+appropriate.  When a file in the lower filesystem is accessed in a way
 
-+the requires write-access, such as opening for write access, changing
 
-+some metadata etc., the file is first copied from the lower filesystem
 
-+to the upper filesystem (copy_up).  Note that creating a hard-link
 
-+also requires copy_up, though of course creation of a symlink does
 
-+not.
 
-+
 
-+The copy_up may turn out to be unnecessary, for example if the file is
 
-+opened for read-write but the data is not modified.
 
-+
 
-+The copy_up process first makes sure that the containing directory
 
-+exists in the upper filesystem - creating it and any parents as
 
-+necessary.  It then creates the object with the same metadata (owner,
 
-+mode, mtime, symlink-target etc.) and then if the object is a file, the
 
-+data is copied from the lower to the upper filesystem.  Finally any
 
-+extended attributes are copied up.
 
-+
 
-+Once the copy_up is complete, the overlay filesystem simply
 
-+provides direct access to the newly created file in the upper
 
-+filesystem - future operations on the file are barely noticed by the
 
-+overlay filesystem (though an operation on the name of the file such as
 
-+rename or unlink will of course be noticed and handled).
 
-+
 
-+
 
-+Non-standard behavior
 
-+---------------------
 
-+
 
-+The copy_up operation essentially creates a new, identical file and
 
-+moves it over to the old name.  The new file may be on a different
 
-+filesystem, so both st_dev and st_ino of the file may change.
 
-+
 
-+Any open files referring to this inode will access the old data and
 
-+metadata.  Similarly any file locks obtained before copy_up will not
 
-+apply to the copied up file.
 
-+
 
-+On a file is opened with O_RDONLY fchmod(2), fchown(2), futimesat(2)
 
-+and fsetxattr(2) will fail with EROFS.
 
-+
 
-+If a file with multiple hard links is copied up, then this will
 
-+"break" the link.  Changes will not be propagated to other names
 
-+referring to the same inode.
 
-+
 
-+Symlinks in /proc/PID/ and /proc/PID/fd which point to a non-directory
 
-+object in overlayfs will not contain vaid absolute paths, only
 
-+relative paths leading up to the filesystem's root.  This will be
 
-+fixed in the future.
 
-+
 
-+Some operations are not atomic, for example a crash during copy_up or
 
-+rename will leave the filesystem in an inconsitent state.  This will
 
-+be addressed in the future.
 
-+
 
-+Changes to underlying filesystems
 
-+---------------------------------
 
-+
 
-+Offline changes, when the overlay is not mounted, are allowed to either
 
-+the upper or the lower trees.
 
-+
 
-+Changes to the underlying filesystems while part of a mounted overlay
 
-+filesystem are not allowed.  If the underlying filesystem is changed,
 
-+the behavior of the overlay is undefined, though it will not result in
 
-+a crash or deadlock.
 
---- a/Documentation/filesystems/vfs.txt
 
-+++ b/Documentation/filesystems/vfs.txt
 
-@@ -364,6 +364,8 @@ struct inode_operations {
 
- 	ssize_t (*listxattr) (struct dentry *, char *, size_t);
 
- 	int (*removexattr) (struct dentry *, const char *);
 
- 	void (*truncate_range)(struct inode *, loff_t, loff_t);
 
-+	struct file *(*open) (struct dentry *, struct file *,
 
-+			      const struct cred *);
 
- };
 
- 
- Again, all methods are called without any locks being held, unless
 
-@@ -475,6 +477,12 @@ otherwise noted.
 
-   truncate_range: a method provided by the underlying filesystem to truncate a
 
-   	range of blocks , i.e. punch a hole somewhere in a file.
 
- 
-+  open: this is an alternative to f_op->open(), the difference is that this
 
-+	method may return any open file, not necessarily originating from the
 
-+	same filesystem as the one i_op->open() was called on.  It may be useful
 
-+	for stacking filesystems which want to allow native I/O directly on
 
-+	underlying files.
 
-+
 
- 
- The Address Space Object
 
- ========================
 
---- a/MAINTAINERS
 
-+++ b/MAINTAINERS
 
-@@ -4955,6 +4955,13 @@ F:	drivers/scsi/osd/
 
- F:	include/scsi/osd_*
 
- F:	fs/exofs/
 
- 
-+OVERLAYFS FILESYSTEM
 
-+M:	Miklos Szeredi <[email protected]>
 
-+L:	[email protected]
 
-+S:	Supported
 
-+F:	fs/overlayfs/*
 
-+F:	Documentation/filesystems/overlayfs.txt
 
-+
 
- P54 WIRELESS DRIVER
 
- M:	Christian Lamparter <[email protected]>
 
- L:	[email protected]
 
---- a/fs/Kconfig
 
-+++ b/fs/Kconfig
 
-@@ -63,6 +63,7 @@ source "fs/quota/Kconfig"
 
- 
- source "fs/autofs4/Kconfig"
 
- source "fs/fuse/Kconfig"
 
-+source "fs/overlayfs/Kconfig"
 
- 
- config CUSE
 
- 	tristate "Character device in Userspace support"
 
---- a/fs/Makefile
 
-+++ b/fs/Makefile
 
-@@ -105,6 +105,7 @@ obj-$(CONFIG_QNX4FS_FS)		+= qnx4/
 
- obj-$(CONFIG_AUTOFS4_FS)	+= autofs4/
 
- obj-$(CONFIG_ADFS_FS)		+= adfs/
 
- obj-$(CONFIG_FUSE_FS)		+= fuse/
 
-+obj-$(CONFIG_OVERLAYFS_FS)	+= overlayfs/
 
- obj-$(CONFIG_UDF_FS)		+= udf/
 
- obj-$(CONFIG_SUN_OPENPROMFS)	+= openpromfs/
 
- obj-$(CONFIG_OMFS_FS)		+= omfs/
 
---- a/fs/ecryptfs/main.c
 
-+++ b/fs/ecryptfs/main.c
 
-@@ -544,6 +544,13 @@ static struct dentry *ecryptfs_mount(str
 
- 	s->s_maxbytes = path.dentry->d_sb->s_maxbytes;
 
- 	s->s_blocksize = path.dentry->d_sb->s_blocksize;
 
- 	s->s_magic = ECRYPTFS_SUPER_MAGIC;
 
-+	s->s_stack_depth = path.dentry->d_sb->s_stack_depth + 1;
 
-+
 
-+	rc = -EINVAL;
 
-+	if (s->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
 
-+		printk(KERN_ERR "eCryptfs: maximum fs stacking depth exceeded\n");
 
-+		goto out_free;
 
-+	}
 
- 
- 	inode = ecryptfs_get_inode(path.dentry->d_inode, s);
 
- 	rc = PTR_ERR(inode);
 
---- a/fs/namespace.c
 
-+++ b/fs/namespace.c
 
-@@ -1325,6 +1325,24 @@ void drop_collected_mounts(struct vfsmou
 
- 	release_mounts(&umount_list);
 
- }
 
- 
-+struct vfsmount *clone_private_mount(struct path *path)
 
-+{
 
-+	struct mount *old_mnt = real_mount(path->mnt);
 
-+	struct mount *new_mnt;
 
-+
 
-+	if (IS_MNT_UNBINDABLE(old_mnt))
 
-+		return ERR_PTR(-EINVAL);
 
-+
 
-+	down_read(&namespace_sem);
 
-+	new_mnt = clone_mnt(old_mnt, path->dentry, CL_PRIVATE);
 
-+	up_read(&namespace_sem);
 
-+	if (!new_mnt)
 
-+		return ERR_PTR(-ENOMEM);
 
-+
 
-+	return &new_mnt->mnt;
 
-+}
 
-+EXPORT_SYMBOL_GPL(clone_private_mount);
 
-+
 
- int iterate_mounts(int (*f)(struct vfsmount *, void *), void *arg,
 
- 		   struct vfsmount *root)
 
- {
 
---- a/fs/open.c
 
-+++ b/fs/open.c
 
-@@ -644,24 +644,24 @@ static inline int __get_file_write_acces
 
- 	return error;
 
- }
 
- 
--static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,
 
--					struct file *f,
 
--					int (*open)(struct inode *, struct file *),
 
--					const struct cred *cred)
 
-+static struct file *__dentry_open(struct path *path, struct file *f,
 
-+				  int (*open)(struct inode *, struct file *),
 
-+				  const struct cred *cred)
 
- {
 
- 	static const struct file_operations empty_fops = {};
 
- 	struct inode *inode;
 
- 	int error;
 
- 
-+	path_get(path);
 
- 	f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK |
 
- 				FMODE_PREAD | FMODE_PWRITE;
 
- 
- 	if (unlikely(f->f_flags & O_PATH))
 
- 		f->f_mode = FMODE_PATH;
 
- 
--	inode = dentry->d_inode;
 
-+	inode = path->dentry->d_inode;
 
- 	if (f->f_mode & FMODE_WRITE) {
 
--		error = __get_file_write_access(inode, mnt);
 
-+		error = __get_file_write_access(inode, path->mnt);
 
- 		if (error)
 
- 			goto cleanup_file;
 
- 		if (!special_file(inode->i_mode))
 
-@@ -669,8 +669,7 @@ static struct file *__dentry_open(struct
 
- 	}
 
- 
- 	f->f_mapping = inode->i_mapping;
 
--	f->f_path.dentry = dentry;
 
--	f->f_path.mnt = mnt;
 
-+	f->f_path = *path;
 
- 	f->f_pos = 0;
 
- 	file_sb_list_add(f, inode->i_sb);
 
- 
-@@ -727,7 +726,7 @@ cleanup_all:
 
- 			 * here, so just reset the state.
 
- 			 */
 
- 			file_reset_write(f);
 
--			mnt_drop_write(mnt);
 
-+			mnt_drop_write(path->mnt);
 
- 		}
 
- 	}
 
- 	file_sb_list_del(f);
 
-@@ -735,8 +734,7 @@ cleanup_all:
 
- 	f->f_path.mnt = NULL;
 
- cleanup_file:
 
- 	put_filp(f);
 
--	dput(dentry);
 
--	mntput(mnt);
 
-+	path_put(path);
 
- 	return ERR_PTR(error);
 
- }
 
- 
-@@ -762,14 +760,14 @@ cleanup_file:
 
- struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
 
- 		int (*open)(struct inode *, struct file *))
 
- {
 
-+	struct path path = { .dentry = dentry, .mnt = nd->path.mnt };
 
- 	const struct cred *cred = current_cred();
 
- 
- 	if (IS_ERR(nd->intent.open.file))
 
- 		goto out;
 
- 	if (IS_ERR(dentry))
 
- 		goto out_err;
 
--	nd->intent.open.file = __dentry_open(dget(dentry), mntget(nd->path.mnt),
 
--					     nd->intent.open.file,
 
-+	nd->intent.open.file = __dentry_open(&path, nd->intent.open.file,
 
- 					     open, cred);
 
- out:
 
- 	return nd->intent.open.file;
 
-@@ -797,11 +795,9 @@ struct file *nameidata_to_filp(struct na
 
- 	nd->intent.open.file = NULL;
 
- 
- 	/* Has the filesystem initialised the file for us? */
 
--	if (filp->f_path.dentry == NULL) {
 
--		path_get(&nd->path);
 
--		filp = __dentry_open(nd->path.dentry, nd->path.mnt, filp,
 
--				     NULL, cred);
 
--	}
 
-+	if (filp->f_path.dentry == NULL)
 
-+		filp = vfs_open(&nd->path, filp, cred);
 
-+
 
- 	return filp;
 
- }
 
- 
-@@ -812,27 +808,48 @@ struct file *nameidata_to_filp(struct na
 
- struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags,
 
- 			 const struct cred *cred)
 
- {
 
--	int error;
 
- 	struct file *f;
 
-+	struct file *ret;
 
-+	struct path path = { .dentry = dentry, .mnt = mnt };
 
- 
- 	validate_creds(cred);
 
- 
- 	/* We must always pass in a valid mount pointer. */
 
- 	BUG_ON(!mnt);
 
- 
--	error = -ENFILE;
 
-+	ret = ERR_PTR(-ENFILE);
 
- 	f = get_empty_filp();
 
--	if (f == NULL) {
 
--		dput(dentry);
 
--		mntput(mnt);
 
--		return ERR_PTR(error);
 
-+	if (f != NULL) {
 
-+		f->f_flags = flags;
 
-+		ret = vfs_open(&path, f, cred);
 
- 	}
 
-+	path_put(&path);
 
- 
--	f->f_flags = flags;
 
--	return __dentry_open(dentry, mnt, f, NULL, cred);
 
-+	return ret;
 
- }
 
- EXPORT_SYMBOL(dentry_open);
 
- 
-+/**
 
-+ * vfs_open - open the file at the given path
 
-+ * @path: path to open
 
-+ * @filp: newly allocated file with f_flag initialized
 
-+ * @cred: credentials to use
 
-+ *
 
-+ * Open the file.  If successful, the returned file will have acquired
 
-+ * an additional reference for path.
 
-+ */
 
-+struct file *vfs_open(struct path *path, struct file *filp,
 
-+		      const struct cred *cred)
 
-+{
 
-+	struct inode *inode = path->dentry->d_inode;
 
-+
 
-+	if (inode->i_op->open)
 
-+		return inode->i_op->open(path->dentry, filp, cred);
 
-+	else
 
-+		return __dentry_open(path, filp, NULL, cred);
 
-+}
 
-+EXPORT_SYMBOL(vfs_open);
 
-+
 
- static void __put_unused_fd(struct files_struct *files, unsigned int fd)
 
- {
 
- 	struct fdtable *fdt = files_fdtable(files);
 
---- /dev/null
 
-+++ b/fs/overlayfs/Kconfig
 
-@@ -0,0 +1,4 @@
 
-+config OVERLAYFS_FS
 
-+	tristate "Overlay filesystem support"
 
-+	help
 
-+	  Add support for overlay filesystem.
 
---- /dev/null
 
-+++ b/fs/overlayfs/Makefile
 
-@@ -0,0 +1,7 @@
 
-+#
 
-+# Makefile for the overlay filesystem.
 
-+#
 
-+
 
-+obj-$(CONFIG_OVERLAYFS_FS) += overlayfs.o
 
-+
 
-+overlayfs-objs := super.o inode.o dir.o readdir.o copy_up.o
 
---- /dev/null
 
-+++ b/fs/overlayfs/copy_up.c
 
-@@ -0,0 +1,384 @@
 
-+/*
 
-+ *
 
-+ * Copyright (C) 2011 Novell Inc.
 
-+ *
 
-+ * This program is free software; you can redistribute it and/or modify it
 
-+ * under the terms of the GNU General Public License version 2 as published by
 
-+ * the Free Software Foundation.
 
-+ */
 
-+
 
-+#include <linux/fs.h>
 
-+#include <linux/slab.h>
 
-+#include <linux/file.h>
 
-+#include <linux/splice.h>
 
-+#include <linux/xattr.h>
 
-+#include <linux/security.h>
 
-+#include <linux/uaccess.h>
 
-+#include "overlayfs.h"
 
-+
 
-+#define OVL_COPY_UP_CHUNK_SIZE (1 << 20)
 
-+
 
-+static int ovl_copy_up_xattr(struct dentry *old, struct dentry *new)
 
-+{
 
-+	ssize_t list_size, size;
 
-+	char *buf, *name, *value;
 
-+	int error;
 
-+
 
-+	if (!old->d_inode->i_op->getxattr ||
 
-+	    !new->d_inode->i_op->getxattr)
 
-+		return 0;
 
-+
 
-+	list_size = vfs_listxattr(old, NULL, 0);
 
-+	if (list_size <= 0) {
 
-+		if (list_size == -EOPNOTSUPP)
 
-+			return 0;
 
-+		return list_size;
 
-+	}
 
-+
 
-+	buf = kzalloc(list_size, GFP_KERNEL);
 
-+	if (!buf)
 
-+		return -ENOMEM;
 
-+
 
-+	error = -ENOMEM;
 
-+	value = kmalloc(XATTR_SIZE_MAX, GFP_KERNEL);
 
-+	if (!value)
 
-+		goto out;
 
-+
 
-+	list_size = vfs_listxattr(old, buf, list_size);
 
-+	if (list_size <= 0) {
 
-+		error = list_size;
 
-+		goto out_free_value;
 
-+	}
 
-+
 
-+	for (name = buf; name < (buf + list_size); name += strlen(name) + 1) {
 
-+		size = vfs_getxattr(old, name, value, XATTR_SIZE_MAX);
 
-+		if (size <= 0) {
 
-+			error = size;
 
-+			goto out_free_value;
 
-+		}
 
-+		error = vfs_setxattr(new, name, value, size, 0);
 
-+		if (error)
 
-+			goto out_free_value;
 
-+	}
 
-+
 
-+out_free_value:
 
-+	kfree(value);
 
-+out:
 
-+	kfree(buf);
 
-+	return error;
 
-+}
 
-+
 
-+static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len)
 
-+{
 
-+	struct file *old_file;
 
-+	struct file *new_file;
 
-+	int error = 0;
 
-+
 
-+	if (len == 0)
 
-+		return 0;
 
-+
 
-+	old_file = ovl_path_open(old, O_RDONLY);
 
-+	if (IS_ERR(old_file))
 
-+		return PTR_ERR(old_file);
 
-+
 
-+	new_file = ovl_path_open(new, O_WRONLY);
 
-+	if (IS_ERR(new_file)) {
 
-+		error = PTR_ERR(new_file);
 
-+		goto out_fput;
 
-+	}
 
-+
 
-+	/* FIXME: copy up sparse files efficiently */
 
-+	while (len) {
 
-+		loff_t offset = new_file->f_pos;
 
-+		size_t this_len = OVL_COPY_UP_CHUNK_SIZE;
 
-+		long bytes;
 
-+
 
-+		if (len < this_len)
 
-+			this_len = len;
 
-+
 
-+		if (signal_pending_state(TASK_KILLABLE, current)) {
 
-+			error = -EINTR;
 
-+			break;
 
-+		}
 
-+
 
-+		bytes = do_splice_direct(old_file, &offset, new_file, this_len,
 
-+				 SPLICE_F_MOVE);
 
-+		if (bytes <= 0) {
 
-+			error = bytes;
 
-+			break;
 
-+		}
 
-+
 
-+		len -= bytes;
 
-+	}
 
-+
 
-+	fput(new_file);
 
-+out_fput:
 
-+	fput(old_file);
 
-+	return error;
 
-+}
 
-+
 
-+static char *ovl_read_symlink(struct dentry *realdentry)
 
-+{
 
-+	int res;
 
-+	char *buf;
 
-+	struct inode *inode = realdentry->d_inode;
 
-+	mm_segment_t old_fs;
 
-+
 
-+	res = -EINVAL;
 
-+	if (!inode->i_op->readlink)
 
-+		goto err;
 
-+
 
-+	res = -ENOMEM;
 
-+	buf = (char *) __get_free_page(GFP_KERNEL);
 
-+	if (!buf)
 
-+		goto err;
 
-+
 
-+	old_fs = get_fs();
 
-+	set_fs(get_ds());
 
-+	/* The cast to a user pointer is valid due to the set_fs() */
 
-+	res = inode->i_op->readlink(realdentry,
 
-+				    (char __user *)buf, PAGE_SIZE - 1);
 
-+	set_fs(old_fs);
 
-+	if (res < 0) {
 
-+		free_page((unsigned long) buf);
 
-+		goto err;
 
-+	}
 
-+	buf[res] = '\0';
 
-+
 
-+	return buf;
 
-+
 
-+err:
 
-+	return ERR_PTR(res);
 
-+}
 
-+
 
-+static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat)
 
-+{
 
-+	struct iattr attr = {
 
-+		.ia_valid =
 
-+		     ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET,
 
-+		.ia_atime = stat->atime,
 
-+		.ia_mtime = stat->mtime,
 
-+	};
 
-+
 
-+	return notify_change(upperdentry, &attr);
 
-+}
 
-+
 
-+static int ovl_set_mode(struct dentry *upperdentry, umode_t mode)
 
-+{
 
-+	struct iattr attr = {
 
-+		.ia_valid = ATTR_MODE,
 
-+		.ia_mode = mode,
 
-+	};
 
-+
 
-+	return notify_change(upperdentry, &attr);
 
-+}
 
-+
 
-+static int ovl_copy_up_locked(struct dentry *upperdir, struct dentry *dentry,
 
-+			      struct path *lowerpath, struct kstat *stat,
 
-+			      const char *link)
 
-+{
 
-+	int err;
 
-+	struct path newpath;
 
-+	umode_t mode = stat->mode;
 
-+
 
-+	/* Can't properly set mode on creation because of the umask */
 
-+	stat->mode &= S_IFMT;
 
-+
 
-+	ovl_path_upper(dentry, &newpath);
 
-+	WARN_ON(newpath.dentry);
 
-+	newpath.dentry = ovl_upper_create(upperdir, dentry, stat, link);
 
-+	if (IS_ERR(newpath.dentry))
 
-+		return PTR_ERR(newpath.dentry);
 
-+
 
-+	if (S_ISREG(stat->mode)) {
 
-+		err = ovl_copy_up_data(lowerpath, &newpath, stat->size);
 
-+		if (err)
 
-+			goto err_remove;
 
-+	}
 
-+
 
-+	err = ovl_copy_up_xattr(lowerpath->dentry, newpath.dentry);
 
-+	if (err)
 
-+		goto err_remove;
 
-+
 
-+	mutex_lock(&newpath.dentry->d_inode->i_mutex);
 
-+	if (!S_ISLNK(stat->mode))
 
-+		err = ovl_set_mode(newpath.dentry, mode);
 
-+	if (!err)
 
-+		err = ovl_set_timestamps(newpath.dentry, stat);
 
-+	mutex_unlock(&newpath.dentry->d_inode->i_mutex);
 
-+	if (err)
 
-+		goto err_remove;
 
-+
 
-+	ovl_dentry_update(dentry, newpath.dentry);
 
-+
 
-+	/*
 
-+	 * Easiest way to get rid of the lower dentry reference is to
 
-+	 * drop this dentry.  This is neither needed nor possible for
 
-+	 * directories.
 
-+	 */
 
-+	if (!S_ISDIR(stat->mode))
 
-+		d_drop(dentry);
 
-+
 
-+	return 0;
 
-+
 
-+err_remove:
 
-+	if (S_ISDIR(stat->mode))
 
-+		vfs_rmdir(upperdir->d_inode, newpath.dentry);
 
-+	else
 
-+		vfs_unlink(upperdir->d_inode, newpath.dentry);
 
-+
 
-+	dput(newpath.dentry);
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+/*
 
-+ * Copy up a single dentry
 
-+ *
 
-+ * Directory renames only allowed on "pure upper" (already created on
 
-+ * upper filesystem, never copied up).  Directories which are on lower or
 
-+ * are merged may not be renamed.  For these -EXDEV is returned and
 
-+ * userspace has to deal with it.  This means, when copying up a
 
-+ * directory we can rely on it and ancestors being stable.
 
-+ *
 
-+ * Non-directory renames start with copy up of source if necessary.  The
 
-+ * actual rename will only proceed once the copy up was successful.  Copy
 
-+ * up uses upper parent i_mutex for exclusion.  Since rename can change
 
-+ * d_parent it is possible that the copy up will lock the old parent.  At
 
-+ * that point the file will have already been copied up anyway.
 
-+ */
 
-+static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry,
 
-+			   struct path *lowerpath, struct kstat *stat)
 
-+{
 
-+	int err;
 
-+	struct kstat pstat;
 
-+	struct path parentpath;
 
-+	struct dentry *upperdir;
 
-+	const struct cred *old_cred;
 
-+	struct cred *override_cred;
 
-+	char *link = NULL;
 
-+
 
-+	ovl_path_upper(parent, &parentpath);
 
-+	upperdir = parentpath.dentry;
 
-+
 
-+	err = vfs_getattr(parentpath.mnt, parentpath.dentry, &pstat);
 
-+	if (err)
 
-+		return err;
 
-+
 
-+	if (S_ISLNK(stat->mode)) {
 
-+		link = ovl_read_symlink(lowerpath->dentry);
 
-+		if (IS_ERR(link))
 
-+			return PTR_ERR(link);
 
-+	}
 
-+
 
-+	err = -ENOMEM;
 
-+	override_cred = prepare_creds();
 
-+	if (!override_cred)
 
-+		goto out_free_link;
 
-+
 
-+	override_cred->fsuid = stat->uid;
 
-+	override_cred->fsgid = stat->gid;
 
-+	/*
 
-+	 * CAP_SYS_ADMIN for copying up extended attributes
 
-+	 * CAP_DAC_OVERRIDE for create
 
-+	 * CAP_FOWNER for chmod, timestamp update
 
-+	 * CAP_FSETID for chmod
 
-+	 * CAP_MKNOD for mknod
 
-+	 */
 
-+	cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
 
-+	cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE);
 
-+	cap_raise(override_cred->cap_effective, CAP_FOWNER);
 
-+	cap_raise(override_cred->cap_effective, CAP_FSETID);
 
-+	cap_raise(override_cred->cap_effective, CAP_MKNOD);
 
-+	old_cred = override_creds(override_cred);
 
-+
 
-+	mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT);
 
-+	if (ovl_path_type(dentry) != OVL_PATH_LOWER) {
 
-+		err = 0;
 
-+	} else {
 
-+		err = ovl_copy_up_locked(upperdir, dentry, lowerpath,
 
-+					 stat, link);
 
-+		if (!err) {
 
-+			/* Restore timestamps on parent (best effort) */
 
-+			ovl_set_timestamps(upperdir, &pstat);
 
-+		}
 
-+	}
 
-+
 
-+	mutex_unlock(&upperdir->d_inode->i_mutex);
 
-+
 
-+	revert_creds(old_cred);
 
-+	put_cred(override_cred);
 
-+
 
-+out_free_link:
 
-+	if (link)
 
-+		free_page((unsigned long) link);
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+int ovl_copy_up(struct dentry *dentry)
 
-+{
 
-+	int err;
 
-+
 
-+	err = 0;
 
-+	while (!err) {
 
-+		struct dentry *next;
 
-+		struct dentry *parent;
 
-+		struct path lowerpath;
 
-+		struct kstat stat;
 
-+		enum ovl_path_type type = ovl_path_type(dentry);
 
-+
 
-+		if (type != OVL_PATH_LOWER)
 
-+			break;
 
-+
 
-+		next = dget(dentry);
 
-+		/* find the topmost dentry not yet copied up */
 
-+		for (;;) {
 
-+			parent = dget_parent(next);
 
-+
 
-+			type = ovl_path_type(parent);
 
-+			if (type != OVL_PATH_LOWER)
 
-+				break;
 
-+
 
-+			dput(next);
 
-+			next = parent;
 
-+		}
 
-+
 
-+		ovl_path_lower(next, &lowerpath);
 
-+		err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat);
 
-+		if (!err)
 
-+			err = ovl_copy_up_one(parent, next, &lowerpath, &stat);
 
-+
 
-+		dput(parent);
 
-+		dput(next);
 
-+	}
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+/* Optimize by not copying up the file first and truncating later */
 
-+int ovl_copy_up_truncate(struct dentry *dentry, loff_t size)
 
-+{
 
-+	int err;
 
-+	struct kstat stat;
 
-+	struct path lowerpath;
 
-+	struct dentry *parent = dget_parent(dentry);
 
-+
 
-+	err = ovl_copy_up(parent);
 
-+	if (err)
 
-+		goto out_dput_parent;
 
-+
 
-+	ovl_path_lower(dentry, &lowerpath);
 
-+	err = vfs_getattr(lowerpath.mnt, lowerpath.dentry, &stat);
 
-+	if (err)
 
-+		goto out_dput_parent;
 
-+
 
-+	if (size < stat.size)
 
-+		stat.size = size;
 
-+
 
-+	err = ovl_copy_up_one(parent, dentry, &lowerpath, &stat);
 
-+
 
-+out_dput_parent:
 
-+	dput(parent);
 
-+	return err;
 
-+}
 
---- /dev/null
 
-+++ b/fs/overlayfs/dir.c
 
-@@ -0,0 +1,596 @@
 
-+/*
 
-+ *
 
-+ * Copyright (C) 2011 Novell Inc.
 
-+ *
 
-+ * This program is free software; you can redistribute it and/or modify it
 
-+ * under the terms of the GNU General Public License version 2 as published by
 
-+ * the Free Software Foundation.
 
-+ */
 
-+
 
-+#include <linux/fs.h>
 
-+#include <linux/namei.h>
 
-+#include <linux/xattr.h>
 
-+#include <linux/security.h>
 
-+#include "overlayfs.h"
 
-+
 
-+static const char *ovl_whiteout_symlink = "(overlay-whiteout)";
 
-+
 
-+static int ovl_whiteout(struct dentry *upperdir, struct dentry *dentry)
 
-+{
 
-+	int err;
 
-+	struct dentry *newdentry;
 
-+	const struct cred *old_cred;
 
-+	struct cred *override_cred;
 
-+
 
-+	/* FIXME: recheck lower dentry to see if whiteout is really needed */
 
-+
 
-+	err = -ENOMEM;
 
-+	override_cred = prepare_creds();
 
-+	if (!override_cred)
 
-+		goto out;
 
-+
 
-+	/*
 
-+	 * CAP_SYS_ADMIN for setxattr
 
-+	 * CAP_DAC_OVERRIDE for symlink creation
 
-+	 * CAP_FOWNER for unlink in sticky directory
 
-+	 */
 
-+	cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
 
-+	cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE);
 
-+	cap_raise(override_cred->cap_effective, CAP_FOWNER);
 
-+	override_cred->fsuid = 0;
 
-+	override_cred->fsgid = 0;
 
-+	old_cred = override_creds(override_cred);
 
-+
 
-+	newdentry = lookup_one_len(dentry->d_name.name, upperdir,
 
-+				   dentry->d_name.len);
 
-+	err = PTR_ERR(newdentry);
 
-+	if (IS_ERR(newdentry))
 
-+		goto out_put_cred;
 
-+
 
-+	/* Just been removed within the same locked region */
 
-+	WARN_ON(newdentry->d_inode);
 
-+
 
-+	err = vfs_symlink(upperdir->d_inode, newdentry, ovl_whiteout_symlink);
 
-+	if (err)
 
-+		goto out_dput;
 
-+
 
-+	ovl_dentry_version_inc(dentry->d_parent);
 
-+
 
-+	err = vfs_setxattr(newdentry, ovl_whiteout_xattr, "y", 1, 0);
 
-+	if (err)
 
-+		vfs_unlink(upperdir->d_inode, newdentry);
 
-+
 
-+out_dput:
 
-+	dput(newdentry);
 
-+out_put_cred:
 
-+	revert_creds(old_cred);
 
-+	put_cred(override_cred);
 
-+out:
 
-+	if (err) {
 
-+		/*
 
-+		 * There's no way to recover from failure to whiteout.
 
-+		 * What should we do?  Log a big fat error and... ?
 
-+		 */
 
-+		printk(KERN_ERR "overlayfs: ERROR - failed to whiteout '%s'\n",
 
-+		       dentry->d_name.name);
 
-+	}
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+static struct dentry *ovl_lookup_create(struct dentry *upperdir,
 
-+					struct dentry *template)
 
-+{
 
-+	int err;
 
-+	struct dentry *newdentry;
 
-+	struct qstr *name = &template->d_name;
 
-+
 
-+	newdentry = lookup_one_len(name->name, upperdir, name->len);
 
-+	if (IS_ERR(newdentry))
 
-+		return newdentry;
 
-+
 
-+	if (newdentry->d_inode) {
 
-+		const struct cred *old_cred;
 
-+		struct cred *override_cred;
 
-+
 
-+		/* No need to check whiteout if lower parent is non-existent */
 
-+		err = -EEXIST;
 
-+		if (!ovl_dentry_lower(template->d_parent))
 
-+			goto out_dput;
 
-+
 
-+		if (!S_ISLNK(newdentry->d_inode->i_mode))
 
-+			goto out_dput;
 
-+
 
-+		err = -ENOMEM;
 
-+		override_cred = prepare_creds();
 
-+		if (!override_cred)
 
-+			goto out_dput;
 
-+
 
-+		/*
 
-+		 * CAP_SYS_ADMIN for getxattr
 
-+		 * CAP_FOWNER for unlink in sticky directory
 
-+		 */
 
-+		cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
 
-+		cap_raise(override_cred->cap_effective, CAP_FOWNER);
 
-+		old_cred = override_creds(override_cred);
 
-+
 
-+		err = -EEXIST;
 
-+		if (ovl_is_whiteout(newdentry))
 
-+			err = vfs_unlink(upperdir->d_inode, newdentry);
 
-+
 
-+		revert_creds(old_cred);
 
-+		put_cred(override_cred);
 
-+		if (err)
 
-+			goto out_dput;
 
-+
 
-+		dput(newdentry);
 
-+		newdentry = lookup_one_len(name->name, upperdir, name->len);
 
-+		if (IS_ERR(newdentry)) {
 
-+			ovl_whiteout(upperdir, template);
 
-+			return newdentry;
 
-+		}
 
-+
 
-+		/*
 
-+		 * Whiteout just been successfully removed, parent
 
-+		 * i_mutex is still held, there's no way the lookup
 
-+		 * could return positive.
 
-+		 */
 
-+		WARN_ON(newdentry->d_inode);
 
-+	}
 
-+
 
-+	return newdentry;
 
-+
 
-+out_dput:
 
-+	dput(newdentry);
 
-+	return ERR_PTR(err);
 
-+}
 
-+
 
-+struct dentry *ovl_upper_create(struct dentry *upperdir, struct dentry *dentry,
 
-+				struct kstat *stat, const char *link)
 
-+{
 
-+	int err;
 
-+	struct dentry *newdentry;
 
-+	struct inode *dir = upperdir->d_inode;
 
-+
 
-+	newdentry = ovl_lookup_create(upperdir, dentry);
 
-+	if (IS_ERR(newdentry))
 
-+		goto out;
 
-+
 
-+	switch (stat->mode & S_IFMT) {
 
-+	case S_IFREG:
 
-+		err = vfs_create(dir, newdentry, stat->mode, NULL);
 
-+		break;
 
-+
 
-+	case S_IFDIR:
 
-+		err = vfs_mkdir(dir, newdentry, stat->mode);
 
-+		break;
 
-+
 
-+	case S_IFCHR:
 
-+	case S_IFBLK:
 
-+	case S_IFIFO:
 
-+	case S_IFSOCK:
 
-+		err = vfs_mknod(dir, newdentry, stat->mode, stat->rdev);
 
-+		break;
 
-+
 
-+	case S_IFLNK:
 
-+		err = vfs_symlink(dir, newdentry, link);
 
-+		break;
 
-+
 
-+	default:
 
-+		err = -EPERM;
 
-+	}
 
-+	if (err) {
 
-+		if (ovl_dentry_is_opaque(dentry))
 
-+			ovl_whiteout(upperdir, dentry);
 
-+		dput(newdentry);
 
-+		newdentry = ERR_PTR(err);
 
-+	} else if (WARN_ON(!newdentry->d_inode)) {
 
-+		/*
 
-+		 * Not quite sure if non-instantiated dentry is legal or not.
 
-+		 * VFS doesn't seem to care so check and warn here.
 
-+		 */
 
-+		dput(newdentry);
 
-+		newdentry = ERR_PTR(-ENOENT);
 
-+	}
 
-+
 
-+out:
 
-+	return newdentry;
 
-+
 
-+}
 
-+
 
-+static int ovl_set_opaque(struct dentry *upperdentry)
 
-+{
 
-+	int err;
 
-+	const struct cred *old_cred;
 
-+	struct cred *override_cred;
 
-+
 
-+	override_cred = prepare_creds();
 
-+	if (!override_cred)
 
-+		return -ENOMEM;
 
-+
 
-+	/* CAP_SYS_ADMIN for setxattr of "trusted" namespace */
 
-+	cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
 
-+	old_cred = override_creds(override_cred);
 
-+	err = vfs_setxattr(upperdentry, ovl_opaque_xattr, "y", 1, 0);
 
-+	revert_creds(old_cred);
 
-+	put_cred(override_cred);
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+static int ovl_remove_opaque(struct dentry *upperdentry)
 
-+{
 
-+	int err;
 
-+	const struct cred *old_cred;
 
-+	struct cred *override_cred;
 
-+
 
-+	override_cred = prepare_creds();
 
-+	if (!override_cred)
 
-+		return -ENOMEM;
 
-+
 
-+	/* CAP_SYS_ADMIN for removexattr of "trusted" namespace */
 
-+	cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
 
-+	old_cred = override_creds(override_cred);
 
-+	err = vfs_removexattr(upperdentry, ovl_opaque_xattr);
 
-+	revert_creds(old_cred);
 
-+	put_cred(override_cred);
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+static int ovl_dir_getattr(struct vfsmount *mnt, struct dentry *dentry,
 
-+			 struct kstat *stat)
 
-+{
 
-+	int err;
 
-+	enum ovl_path_type type;
 
-+	struct path realpath;
 
-+
 
-+	type = ovl_path_real(dentry, &realpath);
 
-+	err = vfs_getattr(realpath.mnt, realpath.dentry, stat);
 
-+	if (err)
 
-+		return err;
 
-+
 
-+	stat->dev = dentry->d_sb->s_dev;
 
-+	stat->ino = dentry->d_inode->i_ino;
 
-+
 
-+	/*
 
-+	 * It's probably not worth it to count subdirs to get the
 
-+	 * correct link count.  nlink=1 seems to pacify 'find' and
 
-+	 * other utilities.
 
-+	 */
 
-+	if (type == OVL_PATH_MERGE)
 
-+		stat->nlink = 1;
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev,
 
-+			     const char *link)
 
-+{
 
-+	int err;
 
-+	struct dentry *newdentry;
 
-+	struct dentry *upperdir;
 
-+	struct inode *inode;
 
-+	struct kstat stat = {
 
-+		.mode = mode,
 
-+		.rdev = rdev,
 
-+	};
 
-+
 
-+	err = -ENOMEM;
 
-+	inode = ovl_new_inode(dentry->d_sb, mode, dentry->d_fsdata);
 
-+	if (!inode)
 
-+		goto out;
 
-+
 
-+	err = ovl_copy_up(dentry->d_parent);
 
-+	if (err)
 
-+		goto out_iput;
 
-+
 
-+	upperdir = ovl_dentry_upper(dentry->d_parent);
 
-+	mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT);
 
-+
 
-+	newdentry = ovl_upper_create(upperdir, dentry, &stat, link);
 
-+	err = PTR_ERR(newdentry);
 
-+	if (IS_ERR(newdentry))
 
-+		goto out_unlock;
 
-+
 
-+	ovl_dentry_version_inc(dentry->d_parent);
 
-+	if (ovl_dentry_is_opaque(dentry) && S_ISDIR(mode)) {
 
-+		err = ovl_set_opaque(newdentry);
 
-+		if (err) {
 
-+			vfs_rmdir(upperdir->d_inode, newdentry);
 
-+			ovl_whiteout(upperdir, dentry);
 
-+			goto out_dput;
 
-+		}
 
-+	}
 
-+	ovl_dentry_update(dentry, newdentry);
 
-+	d_instantiate(dentry, inode);
 
-+	inode = NULL;
 
-+	newdentry = NULL;
 
-+	err = 0;
 
-+
 
-+out_dput:
 
-+	dput(newdentry);
 
-+out_unlock:
 
-+	mutex_unlock(&upperdir->d_inode->i_mutex);
 
-+out_iput:
 
-+	iput(inode);
 
-+out:
 
-+	return err;
 
-+}
 
-+
 
-+static int ovl_create(struct inode *dir, struct dentry *dentry, umode_t mode,
 
-+			struct nameidata *nd)
 
-+{
 
-+	return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL);
 
-+}
 
-+
 
-+static int ovl_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 
-+{
 
-+	return ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL);
 
-+}
 
-+
 
-+static int ovl_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
 
-+		     dev_t rdev)
 
-+{
 
-+	return ovl_create_object(dentry, mode, rdev, NULL);
 
-+}
 
-+
 
-+static int ovl_symlink(struct inode *dir, struct dentry *dentry,
 
-+			 const char *link)
 
-+{
 
-+	return ovl_create_object(dentry, S_IFLNK, 0, link);
 
-+}
 
-+
 
-+static int ovl_do_remove(struct dentry *dentry, bool is_dir)
 
-+{
 
-+	int err;
 
-+	enum ovl_path_type type;
 
-+	struct path realpath;
 
-+	struct dentry *upperdir;
 
-+
 
-+	err = ovl_copy_up(dentry->d_parent);
 
-+	if (err)
 
-+		return err;
 
-+
 
-+	upperdir = ovl_dentry_upper(dentry->d_parent);
 
-+	mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT);
 
-+	type = ovl_path_real(dentry, &realpath);
 
-+	if (type != OVL_PATH_LOWER) {
 
-+		err = -ESTALE;
 
-+		if (realpath.dentry->d_parent != upperdir)
 
-+			goto out_d_drop;
 
-+
 
-+		/* FIXME: create whiteout up front and rename to target */
 
-+
 
-+		if (is_dir)
 
-+			err = vfs_rmdir(upperdir->d_inode, realpath.dentry);
 
-+		else
 
-+			err = vfs_unlink(upperdir->d_inode, realpath.dentry);
 
-+		if (err)
 
-+			goto out_d_drop;
 
-+
 
-+		ovl_dentry_version_inc(dentry->d_parent);
 
-+	}
 
-+
 
-+	if (type != OVL_PATH_UPPER || ovl_dentry_is_opaque(dentry))
 
-+		err = ovl_whiteout(upperdir, dentry);
 
-+
 
-+	/*
 
-+	 * Keeping this dentry hashed would mean having to release
 
-+	 * upperpath/lowerpath, which could only be done if we are the
 
-+	 * sole user of this dentry.  Too tricky...  Just unhash for
 
-+	 * now.
 
-+	 */
 
-+out_d_drop:
 
-+	d_drop(dentry);
 
-+	mutex_unlock(&upperdir->d_inode->i_mutex);
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+static int ovl_unlink(struct inode *dir, struct dentry *dentry)
 
-+{
 
-+	return ovl_do_remove(dentry, false);
 
-+}
 
-+
 
-+
 
-+static int ovl_rmdir(struct inode *dir, struct dentry *dentry)
 
-+{
 
-+	int err;
 
-+	enum ovl_path_type type;
 
-+
 
-+	type = ovl_path_type(dentry);
 
-+	if (type != OVL_PATH_UPPER) {
 
-+		err = ovl_check_empty_and_clear(dentry, type);
 
-+		if (err)
 
-+			return err;
 
-+	}
 
-+
 
-+	return ovl_do_remove(dentry, true);
 
-+}
 
-+
 
-+static int ovl_link(struct dentry *old, struct inode *newdir,
 
-+		    struct dentry *new)
 
-+{
 
-+	int err;
 
-+	struct dentry *olddentry;
 
-+	struct dentry *newdentry;
 
-+	struct dentry *upperdir;
 
-+
 
-+	err = ovl_copy_up(old);
 
-+	if (err)
 
-+		goto out;
 
-+
 
-+	err = ovl_copy_up(new->d_parent);
 
-+	if (err)
 
-+		goto out;
 
-+
 
-+	upperdir = ovl_dentry_upper(new->d_parent);
 
-+	mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT);
 
-+	newdentry = ovl_lookup_create(upperdir, new);
 
-+	err = PTR_ERR(newdentry);
 
-+	if (IS_ERR(newdentry))
 
-+		goto out_unlock;
 
-+
 
-+	olddentry = ovl_dentry_upper(old);
 
-+	err = vfs_link(olddentry, upperdir->d_inode, newdentry);
 
-+	if (!err) {
 
-+		if (WARN_ON(!newdentry->d_inode)) {
 
-+			dput(newdentry);
 
-+			err = -ENOENT;
 
-+			goto out_unlock;
 
-+		}
 
-+
 
-+		ovl_dentry_version_inc(new->d_parent);
 
-+		ovl_dentry_update(new, newdentry);
 
-+
 
-+		ihold(old->d_inode);
 
-+		d_instantiate(new, old->d_inode);
 
-+	} else {
 
-+		if (ovl_dentry_is_opaque(new))
 
-+			ovl_whiteout(upperdir, new);
 
-+		dput(newdentry);
 
-+	}
 
-+out_unlock:
 
-+	mutex_unlock(&upperdir->d_inode->i_mutex);
 
-+out:
 
-+	return err;
 
-+
 
-+}
 
-+
 
-+static int ovl_rename(struct inode *olddir, struct dentry *old,
 
-+			struct inode *newdir, struct dentry *new)
 
-+{
 
-+	int err;
 
-+	enum ovl_path_type old_type;
 
-+	enum ovl_path_type new_type;
 
-+	struct dentry *old_upperdir;
 
-+	struct dentry *new_upperdir;
 
-+	struct dentry *olddentry;
 
-+	struct dentry *newdentry;
 
-+	struct dentry *trap;
 
-+	bool old_opaque;
 
-+	bool new_opaque;
 
-+	bool new_create = false;
 
-+	bool is_dir = S_ISDIR(old->d_inode->i_mode);
 
-+
 
-+	/* Don't copy up directory trees */
 
-+	old_type = ovl_path_type(old);
 
-+	if (old_type != OVL_PATH_UPPER && is_dir)
 
-+		return -EXDEV;
 
-+
 
-+	if (new->d_inode) {
 
-+		new_type = ovl_path_type(new);
 
-+
 
-+		if (new_type == OVL_PATH_LOWER && old_type == OVL_PATH_LOWER) {
 
-+			if (ovl_dentry_lower(old)->d_inode ==
 
-+			    ovl_dentry_lower(new)->d_inode)
 
-+				return 0;
 
-+		}
 
-+		if (new_type != OVL_PATH_LOWER && old_type != OVL_PATH_LOWER) {
 
-+			if (ovl_dentry_upper(old)->d_inode ==
 
-+			    ovl_dentry_upper(new)->d_inode)
 
-+				return 0;
 
-+		}
 
-+
 
-+		if (new_type != OVL_PATH_UPPER &&
 
-+		    S_ISDIR(new->d_inode->i_mode)) {
 
-+			err = ovl_check_empty_and_clear(new, new_type);
 
-+			if (err)
 
-+				return err;
 
-+		}
 
-+	} else {
 
-+		new_type = OVL_PATH_UPPER;
 
-+	}
 
-+
 
-+	err = ovl_copy_up(old);
 
-+	if (err)
 
-+		return err;
 
-+
 
-+	err = ovl_copy_up(new->d_parent);
 
-+	if (err)
 
-+		return err;
 
-+
 
-+	old_upperdir = ovl_dentry_upper(old->d_parent);
 
-+	new_upperdir = ovl_dentry_upper(new->d_parent);
 
-+
 
-+	trap = lock_rename(new_upperdir, old_upperdir);
 
-+
 
-+	olddentry = ovl_dentry_upper(old);
 
-+	newdentry = ovl_dentry_upper(new);
 
-+	if (newdentry) {
 
-+		dget(newdentry);
 
-+	} else {
 
-+		new_create = true;
 
-+		newdentry = ovl_lookup_create(new_upperdir, new);
 
-+		err = PTR_ERR(newdentry);
 
-+		if (IS_ERR(newdentry))
 
-+			goto out_unlock;
 
-+	}
 
-+
 
-+	err = -ESTALE;
 
-+	if (olddentry->d_parent != old_upperdir)
 
-+		goto out_dput;
 
-+	if (newdentry->d_parent != new_upperdir)
 
-+		goto out_dput;
 
-+	if (olddentry == trap)
 
-+		goto out_dput;
 
-+	if (newdentry == trap)
 
-+		goto out_dput;
 
-+
 
-+	old_opaque = ovl_dentry_is_opaque(old);
 
-+	new_opaque = ovl_dentry_is_opaque(new) || new_type != OVL_PATH_UPPER;
 
-+
 
-+	if (is_dir && !old_opaque && new_opaque) {
 
-+		err = ovl_set_opaque(olddentry);
 
-+		if (err)
 
-+			goto out_dput;
 
-+	}
 
-+
 
-+	err = vfs_rename(old_upperdir->d_inode, olddentry,
 
-+			 new_upperdir->d_inode, newdentry);
 
-+
 
-+	if (err) {
 
-+		if (new_create && ovl_dentry_is_opaque(new))
 
-+			ovl_whiteout(new_upperdir, new);
 
-+		if (is_dir && !old_opaque && new_opaque)
 
-+			ovl_remove_opaque(olddentry);
 
-+		goto out_dput;
 
-+	}
 
-+
 
-+	if (old_type != OVL_PATH_UPPER || old_opaque)
 
-+		err = ovl_whiteout(old_upperdir, old);
 
-+	if (is_dir && old_opaque && !new_opaque)
 
-+		ovl_remove_opaque(olddentry);
 
-+
 
-+	if (old_opaque != new_opaque)
 
-+		ovl_dentry_set_opaque(old, new_opaque);
 
-+
 
-+	ovl_dentry_version_inc(old->d_parent);
 
-+	ovl_dentry_version_inc(new->d_parent);
 
-+
 
-+out_dput:
 
-+	dput(newdentry);
 
-+out_unlock:
 
-+	unlock_rename(new_upperdir, old_upperdir);
 
-+	return err;
 
-+}
 
-+
 
-+const struct inode_operations ovl_dir_inode_operations = {
 
-+	.lookup		= ovl_lookup,
 
-+	.mkdir		= ovl_mkdir,
 
-+	.symlink	= ovl_symlink,
 
-+	.unlink		= ovl_unlink,
 
-+	.rmdir		= ovl_rmdir,
 
-+	.rename		= ovl_rename,
 
-+	.link		= ovl_link,
 
-+	.setattr	= ovl_setattr,
 
-+	.create		= ovl_create,
 
-+	.mknod		= ovl_mknod,
 
-+	.permission	= ovl_permission,
 
-+	.getattr	= ovl_dir_getattr,
 
-+	.setxattr	= ovl_setxattr,
 
-+	.getxattr	= ovl_getxattr,
 
-+	.listxattr	= ovl_listxattr,
 
-+	.removexattr	= ovl_removexattr,
 
-+};
 
---- /dev/null
 
-+++ b/fs/overlayfs/inode.c
 
-@@ -0,0 +1,384 @@
 
-+/*
 
-+ *
 
-+ * Copyright (C) 2011 Novell Inc.
 
-+ *
 
-+ * This program is free software; you can redistribute it and/or modify it
 
-+ * under the terms of the GNU General Public License version 2 as published by
 
-+ * the Free Software Foundation.
 
-+ */
 
-+
 
-+#include <linux/fs.h>
 
-+#include <linux/slab.h>
 
-+#include <linux/xattr.h>
 
-+#include "overlayfs.h"
 
-+
 
-+int ovl_setattr(struct dentry *dentry, struct iattr *attr)
 
-+{
 
-+	struct dentry *upperdentry;
 
-+	int err;
 
-+
 
-+	if ((attr->ia_valid & ATTR_SIZE) && !ovl_dentry_upper(dentry))
 
-+		err = ovl_copy_up_truncate(dentry, attr->ia_size);
 
-+	else
 
-+		err = ovl_copy_up(dentry);
 
-+	if (err)
 
-+		return err;
 
-+
 
-+	upperdentry = ovl_dentry_upper(dentry);
 
-+
 
-+	if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
 
-+		attr->ia_valid &= ~ATTR_MODE;
 
-+
 
-+	mutex_lock(&upperdentry->d_inode->i_mutex);
 
-+	err = notify_change(upperdentry, attr);
 
-+	mutex_unlock(&upperdentry->d_inode->i_mutex);
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+static int ovl_getattr(struct vfsmount *mnt, struct dentry *dentry,
 
-+			 struct kstat *stat)
 
-+{
 
-+	struct path realpath;
 
-+
 
-+	ovl_path_real(dentry, &realpath);
 
-+	return vfs_getattr(realpath.mnt, realpath.dentry, stat);
 
-+}
 
-+
 
-+int ovl_permission(struct inode *inode, int mask)
 
-+{
 
-+	struct ovl_entry *oe;
 
-+	struct dentry *alias = NULL;
 
-+	struct inode *realinode;
 
-+	struct dentry *realdentry;
 
-+	bool is_upper;
 
-+	int err;
 
-+
 
-+	if (S_ISDIR(inode->i_mode)) {
 
-+		oe = inode->i_private;
 
-+	} else if (mask & MAY_NOT_BLOCK) {
 
-+		return -ECHILD;
 
-+	} else {
 
-+		/*
 
-+		 * For non-directories find an alias and get the info
 
-+		 * from there.
 
-+		 */
 
-+		spin_lock(&inode->i_lock);
 
-+		if (WARN_ON(list_empty(&inode->i_dentry))) {
 
-+			spin_unlock(&inode->i_lock);
 
-+			return -ENOENT;
 
-+		}
 
-+		alias = list_entry(inode->i_dentry.next,
 
-+				   struct dentry, d_alias);
 
-+		dget(alias);
 
-+		spin_unlock(&inode->i_lock);
 
-+		oe = alias->d_fsdata;
 
-+	}
 
-+
 
-+	realdentry = ovl_entry_real(oe, &is_upper);
 
-+
 
-+	/* Careful in RCU walk mode */
 
-+	realinode = ACCESS_ONCE(realdentry->d_inode);
 
-+	if (!realinode) {
 
-+		WARN_ON(!(mask & MAY_NOT_BLOCK));
 
-+		err = -ENOENT;
 
-+		goto out_dput;
 
-+	}
 
-+
 
-+	if (mask & MAY_WRITE) {
 
-+		umode_t mode = realinode->i_mode;
 
-+
 
-+		/*
 
-+		 * Writes will always be redirected to upper layer, so
 
-+		 * ignore lower layer being read-only.
 
-+		 *
 
-+		 * If the overlay itself is read-only then proceed
 
-+		 * with the permission check, don't return EROFS.
 
-+		 * This will only happen if this is the lower layer of
 
-+		 * another overlayfs.
 
-+		 *
 
-+		 * If upper fs becomes read-only after the overlay was
 
-+		 * constructed return EROFS to prevent modification of
 
-+		 * upper layer.
 
-+		 */
 
-+		err = -EROFS;
 
-+		if (is_upper && !IS_RDONLY(inode) && IS_RDONLY(realinode) &&
 
-+		    (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
 
-+			goto out_dput;
 
-+
 
-+		/*
 
-+		 * Nobody gets write access to an immutable file.
 
-+		 */
 
-+		err = -EACCES;
 
-+		if (IS_IMMUTABLE(realinode))
 
-+			goto out_dput;
 
-+	}
 
-+
 
-+	if (realinode->i_op->permission)
 
-+		err = realinode->i_op->permission(realinode, mask);
 
-+	else
 
-+		err = generic_permission(realinode, mask);
 
-+out_dput:
 
-+	dput(alias);
 
-+	return err;
 
-+}
 
-+
 
-+
 
-+struct ovl_link_data {
 
-+	struct dentry *realdentry;
 
-+	void *cookie;
 
-+};
 
-+
 
-+static void *ovl_follow_link(struct dentry *dentry, struct nameidata *nd)
 
-+{
 
-+	void *ret;
 
-+	struct dentry *realdentry;
 
-+	struct inode *realinode;
 
-+
 
-+	realdentry = ovl_dentry_real(dentry);
 
-+	realinode = realdentry->d_inode;
 
-+
 
-+	if (WARN_ON(!realinode->i_op->follow_link))
 
-+		return ERR_PTR(-EPERM);
 
-+
 
-+	ret = realinode->i_op->follow_link(realdentry, nd);
 
-+	if (IS_ERR(ret))
 
-+		return ret;
 
-+
 
-+	if (realinode->i_op->put_link) {
 
-+		struct ovl_link_data *data;
 
-+
 
-+		data = kmalloc(sizeof(struct ovl_link_data), GFP_KERNEL);
 
-+		if (!data) {
 
-+			realinode->i_op->put_link(realdentry, nd, ret);
 
-+			return ERR_PTR(-ENOMEM);
 
-+		}
 
-+		data->realdentry = realdentry;
 
-+		data->cookie = ret;
 
-+
 
-+		return data;
 
-+	} else {
 
-+		return NULL;
 
-+	}
 
-+}
 
-+
 
-+static void ovl_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
 
-+{
 
-+	struct inode *realinode;
 
-+	struct ovl_link_data *data = c;
 
-+
 
-+	if (!data)
 
-+		return;
 
-+
 
-+	realinode = data->realdentry->d_inode;
 
-+	realinode->i_op->put_link(data->realdentry, nd, data->cookie);
 
-+	kfree(data);
 
-+}
 
-+
 
-+static int ovl_readlink(struct dentry *dentry, char __user *buf, int bufsiz)
 
-+{
 
-+	struct path realpath;
 
-+	struct inode *realinode;
 
-+
 
-+	ovl_path_real(dentry, &realpath);
 
-+	realinode = realpath.dentry->d_inode;
 
-+
 
-+	if (!realinode->i_op->readlink)
 
-+		return -EINVAL;
 
-+
 
-+	touch_atime(realpath.mnt, realpath.dentry);
 
-+
 
-+	return realinode->i_op->readlink(realpath.dentry, buf, bufsiz);
 
-+}
 
-+
 
-+
 
-+static bool ovl_is_private_xattr(const char *name)
 
-+{
 
-+	return strncmp(name, "trusted.overlay.", 14) == 0;
 
-+}
 
-+
 
-+int ovl_setxattr(struct dentry *dentry, const char *name,
 
-+		 const void *value, size_t size, int flags)
 
-+{
 
-+	int err;
 
-+	struct dentry *upperdentry;
 
-+
 
-+	if (ovl_is_private_xattr(name))
 
-+		return -EPERM;
 
-+
 
-+	err = ovl_copy_up(dentry);
 
-+	if (err)
 
-+		return err;
 
-+
 
-+	upperdentry = ovl_dentry_upper(dentry);
 
-+	return  vfs_setxattr(upperdentry, name, value, size, flags);
 
-+}
 
-+
 
-+ssize_t ovl_getxattr(struct dentry *dentry, const char *name,
 
-+		     void *value, size_t size)
 
-+{
 
-+	if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE &&
 
-+	    ovl_is_private_xattr(name))
 
-+		return -ENODATA;
 
-+
 
-+	return vfs_getxattr(ovl_dentry_real(dentry), name, value, size);
 
-+}
 
-+
 
-+ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size)
 
-+{
 
-+	ssize_t res;
 
-+	int off;
 
-+
 
-+	res = vfs_listxattr(ovl_dentry_real(dentry), list, size);
 
-+	if (res <= 0 || size == 0)
 
-+		return res;
 
-+
 
-+	if (ovl_path_type(dentry->d_parent) != OVL_PATH_MERGE)
 
-+		return res;
 
-+
 
-+	/* filter out private xattrs */
 
-+	for (off = 0; off < res;) {
 
-+		char *s = list + off;
 
-+		size_t slen = strlen(s) + 1;
 
-+
 
-+		BUG_ON(off + slen > res);
 
-+
 
-+		if (ovl_is_private_xattr(s)) {
 
-+			res -= slen;
 
-+			memmove(s, s + slen, res - off);
 
-+		} else {
 
-+			off += slen;
 
-+		}
 
-+	}
 
-+
 
-+	return res;
 
-+}
 
-+
 
-+int ovl_removexattr(struct dentry *dentry, const char *name)
 
-+{
 
-+	int err;
 
-+	struct path realpath;
 
-+	enum ovl_path_type type;
 
-+
 
-+	if (ovl_path_type(dentry->d_parent) == OVL_PATH_MERGE &&
 
-+	    ovl_is_private_xattr(name))
 
-+		return -ENODATA;
 
-+
 
-+	type = ovl_path_real(dentry, &realpath);
 
-+	if (type == OVL_PATH_LOWER) {
 
-+		err = vfs_getxattr(realpath.dentry, name, NULL, 0);
 
-+		if (err < 0)
 
-+			return err;
 
-+
 
-+		err = ovl_copy_up(dentry);
 
-+		if (err)
 
-+			return err;
 
-+
 
-+		ovl_path_upper(dentry, &realpath);
 
-+	}
 
-+
 
-+	return vfs_removexattr(realpath.dentry, name);
 
-+}
 
-+
 
-+static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type,
 
-+				  struct dentry *realdentry)
 
-+{
 
-+	if (type != OVL_PATH_LOWER)
 
-+		return false;
 
-+
 
-+	if (special_file(realdentry->d_inode->i_mode))
 
-+		return false;
 
-+
 
-+	if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC))
 
-+		return false;
 
-+
 
-+	return true;
 
-+}
 
-+
 
-+static struct file *ovl_open(struct dentry *dentry, struct file *file,
 
-+			     const struct cred *cred)
 
-+{
 
-+	int err;
 
-+	struct path realpath;
 
-+	enum ovl_path_type type;
 
-+
 
-+	type = ovl_path_real(dentry, &realpath);
 
-+	if (ovl_open_need_copy_up(file->f_flags, type, realpath.dentry)) {
 
-+		if (file->f_flags & O_TRUNC)
 
-+			err = ovl_copy_up_truncate(dentry, 0);
 
-+		else
 
-+			err = ovl_copy_up(dentry);
 
-+		if (err)
 
-+			return ERR_PTR(err);
 
-+
 
-+		ovl_path_upper(dentry, &realpath);
 
-+	}
 
-+
 
-+	return vfs_open(&realpath, file, cred);
 
-+}
 
-+
 
-+static const struct inode_operations ovl_file_inode_operations = {
 
-+	.setattr	= ovl_setattr,
 
-+	.permission	= ovl_permission,
 
-+	.getattr	= ovl_getattr,
 
-+	.setxattr	= ovl_setxattr,
 
-+	.getxattr	= ovl_getxattr,
 
-+	.listxattr	= ovl_listxattr,
 
-+	.removexattr	= ovl_removexattr,
 
-+	.open		= ovl_open,
 
-+};
 
-+
 
-+static const struct inode_operations ovl_symlink_inode_operations = {
 
-+	.setattr	= ovl_setattr,
 
-+	.follow_link	= ovl_follow_link,
 
-+	.put_link	= ovl_put_link,
 
-+	.readlink	= ovl_readlink,
 
-+	.getattr	= ovl_getattr,
 
-+	.setxattr	= ovl_setxattr,
 
-+	.getxattr	= ovl_getxattr,
 
-+	.listxattr	= ovl_listxattr,
 
-+	.removexattr	= ovl_removexattr,
 
-+};
 
-+
 
-+struct inode *ovl_new_inode(struct super_block *sb, umode_t mode,
 
-+			    struct ovl_entry *oe)
 
-+{
 
-+	struct inode *inode;
 
-+
 
-+	inode = new_inode(sb);
 
-+	if (!inode)
 
-+		return NULL;
 
-+
 
-+	mode &= S_IFMT;
 
-+
 
-+	inode->i_ino = get_next_ino();
 
-+	inode->i_mode = mode;
 
-+	inode->i_flags |= S_NOATIME | S_NOCMTIME;
 
-+
 
-+	switch (mode) {
 
-+	case S_IFDIR:
 
-+		inode->i_private = oe;
 
-+		inode->i_op = &ovl_dir_inode_operations;
 
-+		inode->i_fop = &ovl_dir_operations;
 
-+		break;
 
-+
 
-+	case S_IFLNK:
 
-+		inode->i_op = &ovl_symlink_inode_operations;
 
-+		break;
 
-+
 
-+	case S_IFREG:
 
-+	case S_IFSOCK:
 
-+	case S_IFBLK:
 
-+	case S_IFCHR:
 
-+	case S_IFIFO:
 
-+		inode->i_op = &ovl_file_inode_operations;
 
-+		break;
 
-+
 
-+	default:
 
-+		WARN(1, "illegal file type: %i\n", mode);
 
-+		inode = NULL;
 
-+	}
 
-+
 
-+	return inode;
 
-+
 
-+}
 
---- /dev/null
 
-+++ b/fs/overlayfs/overlayfs.h
 
-@@ -0,0 +1,64 @@
 
-+/*
 
-+ *
 
-+ * Copyright (C) 2011 Novell Inc.
 
-+ *
 
-+ * This program is free software; you can redistribute it and/or modify it
 
-+ * under the terms of the GNU General Public License version 2 as published by
 
-+ * the Free Software Foundation.
 
-+ */
 
-+
 
-+struct ovl_entry;
 
-+
 
-+enum ovl_path_type {
 
-+	OVL_PATH_UPPER,
 
-+	OVL_PATH_MERGE,
 
-+	OVL_PATH_LOWER,
 
-+};
 
-+
 
-+extern const char *ovl_opaque_xattr;
 
-+extern const char *ovl_whiteout_xattr;
 
-+extern const struct dentry_operations ovl_dentry_operations;
 
-+
 
-+enum ovl_path_type ovl_path_type(struct dentry *dentry);
 
-+u64 ovl_dentry_version_get(struct dentry *dentry);
 
-+void ovl_dentry_version_inc(struct dentry *dentry);
 
-+void ovl_path_upper(struct dentry *dentry, struct path *path);
 
-+void ovl_path_lower(struct dentry *dentry, struct path *path);
 
-+enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path);
 
-+struct dentry *ovl_dentry_upper(struct dentry *dentry);
 
-+struct dentry *ovl_dentry_lower(struct dentry *dentry);
 
-+struct dentry *ovl_dentry_real(struct dentry *dentry);
 
-+struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper);
 
-+bool ovl_dentry_is_opaque(struct dentry *dentry);
 
-+void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque);
 
-+bool ovl_is_whiteout(struct dentry *dentry);
 
-+void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry);
 
-+struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
 
-+			  struct nameidata *nd);
 
-+struct file *ovl_path_open(struct path *path, int flags);
 
-+
 
-+struct dentry *ovl_upper_create(struct dentry *upperdir, struct dentry *dentry,
 
-+				struct kstat *stat, const char *link);
 
-+
 
-+/* readdir.c */
 
-+extern const struct file_operations ovl_dir_operations;
 
-+int ovl_check_empty_and_clear(struct dentry *dentry, enum ovl_path_type type);
 
-+
 
-+/* inode.c */
 
-+int ovl_setattr(struct dentry *dentry, struct iattr *attr);
 
-+int ovl_permission(struct inode *inode, int mask);
 
-+int ovl_setxattr(struct dentry *dentry, const char *name,
 
-+		 const void *value, size_t size, int flags);
 
-+ssize_t ovl_getxattr(struct dentry *dentry, const char *name,
 
-+		     void *value, size_t size);
 
-+ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size);
 
-+int ovl_removexattr(struct dentry *dentry, const char *name);
 
-+
 
-+struct inode *ovl_new_inode(struct super_block *sb, umode_t mode,
 
-+			    struct ovl_entry *oe);
 
-+/* dir.c */
 
-+extern const struct inode_operations ovl_dir_inode_operations;
 
-+
 
-+/* copy_up.c */
 
-+int ovl_copy_up(struct dentry *dentry);
 
-+int ovl_copy_up_truncate(struct dentry *dentry, loff_t size);
 
---- /dev/null
 
-+++ b/fs/overlayfs/readdir.c
 
-@@ -0,0 +1,565 @@
 
-+/*
 
-+ *
 
-+ * Copyright (C) 2011 Novell Inc.
 
-+ *
 
-+ * This program is free software; you can redistribute it and/or modify it
 
-+ * under the terms of the GNU General Public License version 2 as published by
 
-+ * the Free Software Foundation.
 
-+ */
 
-+
 
-+#include <linux/fs.h>
 
-+#include <linux/slab.h>
 
-+#include <linux/namei.h>
 
-+#include <linux/file.h>
 
-+#include <linux/xattr.h>
 
-+#include <linux/rbtree.h>
 
-+#include <linux/security.h>
 
-+#include "overlayfs.h"
 
-+
 
-+struct ovl_cache_entry {
 
-+	const char *name;
 
-+	unsigned int len;
 
-+	unsigned int type;
 
-+	u64 ino;
 
-+	bool is_whiteout;
 
-+	struct list_head l_node;
 
-+	struct rb_node node;
 
-+};
 
-+
 
-+struct ovl_readdir_data {
 
-+	struct rb_root *root;
 
-+	struct list_head *list;
 
-+	struct list_head *middle;
 
-+	struct dentry *dir;
 
-+	int count;
 
-+	int err;
 
-+};
 
-+
 
-+struct ovl_dir_file {
 
-+	bool is_real;
 
-+	bool is_cached;
 
-+	struct list_head cursor;
 
-+	u64 cache_version;
 
-+	struct list_head cache;
 
-+	struct file *realfile;
 
-+};
 
-+
 
-+static struct ovl_cache_entry *ovl_cache_entry_from_node(struct rb_node *n)
 
-+{
 
-+	return container_of(n, struct ovl_cache_entry, node);
 
-+}
 
-+
 
-+static struct ovl_cache_entry *ovl_cache_entry_find(struct rb_root *root,
 
-+						    const char *name, int len)
 
-+{
 
-+	struct rb_node *node = root->rb_node;
 
-+	int cmp;
 
-+
 
-+	while (node) {
 
-+		struct ovl_cache_entry *p = ovl_cache_entry_from_node(node);
 
-+
 
-+		cmp = strncmp(name, p->name, len);
 
-+		if (cmp > 0)
 
-+			node = p->node.rb_right;
 
-+		else if (cmp < 0 || len < p->len)
 
-+			node = p->node.rb_left;
 
-+		else
 
-+			return p;
 
-+	}
 
-+
 
-+	return NULL;
 
-+}
 
-+
 
-+static struct ovl_cache_entry *ovl_cache_entry_new(const char *name, int len,
 
-+						   u64 ino, unsigned int d_type)
 
-+{
 
-+	struct ovl_cache_entry *p;
 
-+
 
-+	p = kmalloc(sizeof(*p) + len + 1, GFP_KERNEL);
 
-+	if (p) {
 
-+		char *name_copy = (char *) (p + 1);
 
-+		memcpy(name_copy, name, len);
 
-+		name_copy[len] = '\0';
 
-+		p->name = name_copy;
 
-+		p->len = len;
 
-+		p->type = d_type;
 
-+		p->ino = ino;
 
-+		p->is_whiteout = false;
 
-+	}
 
-+
 
-+	return p;
 
-+}
 
-+
 
-+static int ovl_cache_entry_add_rb(struct ovl_readdir_data *rdd,
 
-+				  const char *name, int len, u64 ino,
 
-+				  unsigned int d_type)
 
-+{
 
-+	struct rb_node **newp = &rdd->root->rb_node;
 
-+	struct rb_node *parent = NULL;
 
-+	struct ovl_cache_entry *p;
 
-+
 
-+	while (*newp) {
 
-+		int cmp;
 
-+		struct ovl_cache_entry *tmp;
 
-+
 
-+		parent = *newp;
 
-+		tmp = ovl_cache_entry_from_node(*newp);
 
-+		cmp = strncmp(name, tmp->name, len);
 
-+		if (cmp > 0)
 
-+			newp = &tmp->node.rb_right;
 
-+		else if (cmp < 0 || len < tmp->len)
 
-+			newp = &tmp->node.rb_left;
 
-+		else
 
-+			return 0;
 
-+	}
 
-+
 
-+	p = ovl_cache_entry_new(name, len, ino, d_type);
 
-+	if (p == NULL)
 
-+		return -ENOMEM;
 
-+
 
-+	list_add_tail(&p->l_node, rdd->list);
 
-+	rb_link_node(&p->node, parent, newp);
 
-+	rb_insert_color(&p->node, rdd->root);
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static int ovl_fill_lower(void *buf, const char *name, int namelen,
 
-+			    loff_t offset, u64 ino, unsigned int d_type)
 
-+{
 
-+	struct ovl_readdir_data *rdd = buf;
 
-+	struct ovl_cache_entry *p;
 
-+
 
-+	rdd->count++;
 
-+	p = ovl_cache_entry_find(rdd->root, name, namelen);
 
-+	if (p) {
 
-+		list_move_tail(&p->l_node, rdd->middle);
 
-+	} else {
 
-+		p = ovl_cache_entry_new(name, namelen, ino, d_type);
 
-+		if (p == NULL)
 
-+			rdd->err = -ENOMEM;
 
-+		else
 
-+			list_add_tail(&p->l_node, rdd->middle);
 
-+	}
 
-+
 
-+	return rdd->err;
 
-+}
 
-+
 
-+static void ovl_cache_free(struct list_head *list)
 
-+{
 
-+	struct ovl_cache_entry *p;
 
-+	struct ovl_cache_entry *n;
 
-+
 
-+	list_for_each_entry_safe(p, n, list, l_node)
 
-+		kfree(p);
 
-+
 
-+	INIT_LIST_HEAD(list);
 
-+}
 
-+
 
-+static int ovl_fill_upper(void *buf, const char *name, int namelen,
 
-+			  loff_t offset, u64 ino, unsigned int d_type)
 
-+{
 
-+	struct ovl_readdir_data *rdd = buf;
 
-+
 
-+	rdd->count++;
 
-+	return ovl_cache_entry_add_rb(rdd, name, namelen, ino, d_type);
 
-+}
 
-+
 
-+static inline int ovl_dir_read(struct path *realpath,
 
-+			       struct ovl_readdir_data *rdd, filldir_t filler)
 
-+{
 
-+	struct file *realfile;
 
-+	int err;
 
-+
 
-+	realfile = ovl_path_open(realpath, O_RDONLY | O_DIRECTORY);
 
-+	if (IS_ERR(realfile))
 
-+		return PTR_ERR(realfile);
 
-+
 
-+	do {
 
-+		rdd->count = 0;
 
-+		rdd->err = 0;
 
-+		err = vfs_readdir(realfile, filler, rdd);
 
-+		if (err >= 0)
 
-+			err = rdd->err;
 
-+	} while (!err && rdd->count);
 
-+	fput(realfile);
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static void ovl_dir_reset(struct file *file)
 
-+{
 
-+	struct ovl_dir_file *od = file->private_data;
 
-+	enum ovl_path_type type = ovl_path_type(file->f_path.dentry);
 
-+
 
-+	if (ovl_dentry_version_get(file->f_path.dentry) != od->cache_version) {
 
-+		list_del_init(&od->cursor);
 
-+		ovl_cache_free(&od->cache);
 
-+		od->is_cached = false;
 
-+	}
 
-+	WARN_ON(!od->is_real && type != OVL_PATH_MERGE);
 
-+	if (od->is_real && type == OVL_PATH_MERGE) {
 
-+		fput(od->realfile);
 
-+		od->realfile = NULL;
 
-+		od->is_real = false;
 
-+	}
 
-+}
 
-+
 
-+static int ovl_dir_mark_whiteouts(struct ovl_readdir_data *rdd)
 
-+{
 
-+	struct ovl_cache_entry *p;
 
-+	struct dentry *dentry;
 
-+	const struct cred *old_cred;
 
-+	struct cred *override_cred;
 
-+
 
-+	override_cred = prepare_creds();
 
-+	if (!override_cred) {
 
-+		ovl_cache_free(rdd->list);
 
-+		return -ENOMEM;
 
-+	}
 
-+
 
-+	/*
 
-+	 * CAP_SYS_ADMIN for getxattr
 
-+	 * CAP_DAC_OVERRIDE for lookup
 
-+	 */
 
-+	cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
 
-+	cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE);
 
-+	old_cred = override_creds(override_cred);
 
-+
 
-+	mutex_lock(&rdd->dir->d_inode->i_mutex);
 
-+	list_for_each_entry(p, rdd->list, l_node) {
 
-+		if (p->type != DT_LNK)
 
-+			continue;
 
-+
 
-+		dentry = lookup_one_len(p->name, rdd->dir, p->len);
 
-+		if (IS_ERR(dentry))
 
-+			continue;
 
-+
 
-+		p->is_whiteout = ovl_is_whiteout(dentry);
 
-+		dput(dentry);
 
-+	}
 
-+	mutex_unlock(&rdd->dir->d_inode->i_mutex);
 
-+
 
-+	revert_creds(old_cred);
 
-+	put_cred(override_cred);
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static inline int ovl_dir_read_merged(struct path *upperpath,
 
-+				      struct path *lowerpath,
 
-+				      struct ovl_readdir_data *rdd)
 
-+{
 
-+	int err;
 
-+	struct rb_root root = RB_ROOT;
 
-+	struct list_head middle;
 
-+
 
-+	rdd->root = &root;
 
-+	if (upperpath->dentry) {
 
-+		rdd->dir = upperpath->dentry;
 
-+		err = ovl_dir_read(upperpath, rdd, ovl_fill_upper);
 
-+		if (err)
 
-+			goto out;
 
-+
 
-+		err = ovl_dir_mark_whiteouts(rdd);
 
-+		if (err)
 
-+			goto out;
 
-+	}
 
-+	/*
 
-+	 * Insert lowerpath entries before upperpath ones, this allows
 
-+	 * offsets to be reasonably constant
 
-+	 */
 
-+	list_add(&middle, rdd->list);
 
-+	rdd->middle = &middle;
 
-+	err = ovl_dir_read(lowerpath, rdd, ovl_fill_lower);
 
-+	list_del(&middle);
 
-+out:
 
-+	rdd->root = NULL;
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+static void ovl_seek_cursor(struct ovl_dir_file *od, loff_t pos)
 
-+{
 
-+	struct list_head *l;
 
-+	loff_t off;
 
-+
 
-+	l = od->cache.next;
 
-+	for (off = 0; off < pos; off++) {
 
-+		if (l == &od->cache)
 
-+			break;
 
-+		l = l->next;
 
-+	}
 
-+	list_move_tail(&od->cursor, l);
 
-+}
 
-+
 
-+static int ovl_readdir(struct file *file, void *buf, filldir_t filler)
 
-+{
 
-+	struct ovl_dir_file *od = file->private_data;
 
-+	int res;
 
-+
 
-+	if (!file->f_pos)
 
-+		ovl_dir_reset(file);
 
-+
 
-+	if (od->is_real) {
 
-+		res = vfs_readdir(od->realfile, filler, buf);
 
-+		file->f_pos = od->realfile->f_pos;
 
-+
 
-+		return res;
 
-+	}
 
-+
 
-+	if (!od->is_cached) {
 
-+		struct path lowerpath;
 
-+		struct path upperpath;
 
-+		struct ovl_readdir_data rdd = { .list = &od->cache };
 
-+
 
-+		ovl_path_lower(file->f_path.dentry, &lowerpath);
 
-+		ovl_path_upper(file->f_path.dentry, &upperpath);
 
-+
 
-+		res = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd);
 
-+		if (res) {
 
-+			ovl_cache_free(rdd.list);
 
-+			return res;
 
-+		}
 
-+
 
-+		od->cache_version = ovl_dentry_version_get(file->f_path.dentry);
 
-+		od->is_cached = true;
 
-+
 
-+		ovl_seek_cursor(od, file->f_pos);
 
-+	}
 
-+
 
-+	while (od->cursor.next != &od->cache) {
 
-+		int over;
 
-+		loff_t off;
 
-+		struct ovl_cache_entry *p;
 
-+
 
-+		p = list_entry(od->cursor.next, struct ovl_cache_entry, l_node);
 
-+		off = file->f_pos;
 
-+		if (!p->is_whiteout) {
 
-+			over = filler(buf, p->name, p->len, off, p->ino,
 
-+				      p->type);
 
-+			if (over)
 
-+				break;
 
-+		}
 
-+		file->f_pos++;
 
-+		list_move(&od->cursor, &p->l_node);
 
-+	}
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static loff_t ovl_dir_llseek(struct file *file, loff_t offset, int origin)
 
-+{
 
-+	loff_t res;
 
-+	struct ovl_dir_file *od = file->private_data;
 
-+
 
-+	mutex_lock(&file->f_dentry->d_inode->i_mutex);
 
-+	if (!file->f_pos)
 
-+		ovl_dir_reset(file);
 
-+
 
-+	if (od->is_real) {
 
-+		res = vfs_llseek(od->realfile, offset, origin);
 
-+		file->f_pos = od->realfile->f_pos;
 
-+	} else {
 
-+		res = -EINVAL;
 
-+
 
-+		switch (origin) {
 
-+		case SEEK_CUR:
 
-+			offset += file->f_pos;
 
-+			break;
 
-+		case SEEK_SET:
 
-+			break;
 
-+		default:
 
-+			goto out_unlock;
 
-+		}
 
-+		if (offset < 0)
 
-+			goto out_unlock;
 
-+
 
-+		if (offset != file->f_pos) {
 
-+			file->f_pos = offset;
 
-+			if (od->is_cached)
 
-+				ovl_seek_cursor(od, offset);
 
-+		}
 
-+		res = offset;
 
-+	}
 
-+out_unlock:
 
-+	mutex_unlock(&file->f_dentry->d_inode->i_mutex);
 
-+
 
-+	return res;
 
-+}
 
-+
 
-+static int ovl_dir_fsync(struct file *file, loff_t start, loff_t end,
 
-+			 int datasync)
 
-+{
 
-+	struct ovl_dir_file *od = file->private_data;
 
-+
 
-+	/* May need to reopen directory if it got copied up */
 
-+	if (!od->realfile) {
 
-+		struct path upperpath;
 
-+
 
-+		ovl_path_upper(file->f_path.dentry, &upperpath);
 
-+		od->realfile = ovl_path_open(&upperpath, O_RDONLY);
 
-+		if (IS_ERR(od->realfile))
 
-+			return PTR_ERR(od->realfile);
 
-+	}
 
-+
 
-+	return vfs_fsync_range(od->realfile, start, end, datasync);
 
-+}
 
-+
 
-+static int ovl_dir_release(struct inode *inode, struct file *file)
 
-+{
 
-+	struct ovl_dir_file *od = file->private_data;
 
-+
 
-+	list_del(&od->cursor);
 
-+	ovl_cache_free(&od->cache);
 
-+	if (od->realfile)
 
-+		fput(od->realfile);
 
-+	kfree(od);
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static int ovl_dir_open(struct inode *inode, struct file *file)
 
-+{
 
-+	struct path realpath;
 
-+	struct file *realfile;
 
-+	struct ovl_dir_file *od;
 
-+	enum ovl_path_type type;
 
-+
 
-+	od = kzalloc(sizeof(struct ovl_dir_file), GFP_KERNEL);
 
-+	if (!od)
 
-+		return -ENOMEM;
 
-+
 
-+	type = ovl_path_real(file->f_path.dentry, &realpath);
 
-+	realfile = ovl_path_open(&realpath, file->f_flags);
 
-+	if (IS_ERR(realfile)) {
 
-+		kfree(od);
 
-+		return PTR_ERR(realfile);
 
-+	}
 
-+	INIT_LIST_HEAD(&od->cache);
 
-+	INIT_LIST_HEAD(&od->cursor);
 
-+	od->is_cached = false;
 
-+	od->realfile = realfile;
 
-+	od->is_real = (type != OVL_PATH_MERGE);
 
-+	file->private_data = od;
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+const struct file_operations ovl_dir_operations = {
 
-+	.read		= generic_read_dir,
 
-+	.open		= ovl_dir_open,
 
-+	.readdir	= ovl_readdir,
 
-+	.llseek		= ovl_dir_llseek,
 
-+	.fsync		= ovl_dir_fsync,
 
-+	.release	= ovl_dir_release,
 
-+};
 
-+
 
-+static int ovl_check_empty_dir(struct dentry *dentry, struct list_head *list)
 
-+{
 
-+	int err;
 
-+	struct path lowerpath;
 
-+	struct path upperpath;
 
-+	struct ovl_cache_entry *p;
 
-+	struct ovl_readdir_data rdd = { .list = list };
 
-+
 
-+	ovl_path_upper(dentry, &upperpath);
 
-+	ovl_path_lower(dentry, &lowerpath);
 
-+
 
-+	err = ovl_dir_read_merged(&upperpath, &lowerpath, &rdd);
 
-+	if (err)
 
-+		return err;
 
-+
 
-+	err = 0;
 
-+
 
-+	list_for_each_entry(p, list, l_node) {
 
-+		if (p->is_whiteout)
 
-+			continue;
 
-+
 
-+		if (p->name[0] == '.') {
 
-+			if (p->len == 1)
 
-+				continue;
 
-+			if (p->len == 2 && p->name[1] == '.')
 
-+				continue;
 
-+		}
 
-+		err = -ENOTEMPTY;
 
-+		break;
 
-+	}
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+static int ovl_remove_whiteouts(struct dentry *dir, struct list_head *list)
 
-+{
 
-+	struct path upperpath;
 
-+	struct dentry *upperdir;
 
-+	struct ovl_cache_entry *p;
 
-+	const struct cred *old_cred;
 
-+	struct cred *override_cred;
 
-+	int err;
 
-+
 
-+	ovl_path_upper(dir, &upperpath);
 
-+	upperdir = upperpath.dentry;
 
-+
 
-+	override_cred = prepare_creds();
 
-+	if (!override_cred)
 
-+		return -ENOMEM;
 
-+
 
-+	/*
 
-+	 * CAP_DAC_OVERRIDE for lookup and unlink
 
-+	 * CAP_SYS_ADMIN for setxattr of "trusted" namespace
 
-+	 * CAP_FOWNER for unlink in sticky directory
 
-+	 */
 
-+	cap_raise(override_cred->cap_effective, CAP_DAC_OVERRIDE);
 
-+	cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
 
-+	cap_raise(override_cred->cap_effective, CAP_FOWNER);
 
-+	old_cred = override_creds(override_cred);
 
-+
 
-+	err = vfs_setxattr(upperdir, ovl_opaque_xattr, "y", 1, 0);
 
-+	if (err)
 
-+		goto out_revert_creds;
 
-+
 
-+	mutex_lock_nested(&upperdir->d_inode->i_mutex, I_MUTEX_PARENT);
 
-+	list_for_each_entry(p, list, l_node) {
 
-+		struct dentry *dentry;
 
-+		int ret;
 
-+
 
-+		if (!p->is_whiteout)
 
-+			continue;
 
-+
 
-+		dentry = lookup_one_len(p->name, upperdir, p->len);
 
-+		if (IS_ERR(dentry)) {
 
-+			printk(KERN_WARNING
 
-+			    "overlayfs: failed to lookup whiteout %.*s: %li\n",
 
-+			    p->len, p->name, PTR_ERR(dentry));
 
-+			continue;
 
-+		}
 
-+		ret = vfs_unlink(upperdir->d_inode, dentry);
 
-+		dput(dentry);
 
-+		if (ret)
 
-+			printk(KERN_WARNING
 
-+			    "overlayfs: failed to unlink whiteout %.*s: %i\n",
 
-+			    p->len, p->name, ret);
 
-+	}
 
-+	mutex_unlock(&upperdir->d_inode->i_mutex);
 
-+
 
-+out_revert_creds:
 
-+	revert_creds(old_cred);
 
-+	put_cred(override_cred);
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+int ovl_check_empty_and_clear(struct dentry *dentry, enum ovl_path_type type)
 
-+{
 
-+	int err;
 
-+	LIST_HEAD(list);
 
-+
 
-+	err = ovl_check_empty_dir(dentry, &list);
 
-+	if (!err && type == OVL_PATH_MERGE)
 
-+		err = ovl_remove_whiteouts(dentry, &list);
 
-+
 
-+	ovl_cache_free(&list);
 
-+
 
-+	return err;
 
-+}
 
---- /dev/null
 
-+++ b/fs/overlayfs/super.c
 
-@@ -0,0 +1,664 @@
 
-+/*
 
-+ *
 
-+ * Copyright (C) 2011 Novell Inc.
 
-+ *
 
-+ * This program is free software; you can redistribute it and/or modify it
 
-+ * under the terms of the GNU General Public License version 2 as published by
 
-+ * the Free Software Foundation.
 
-+ */
 
-+
 
-+#include <linux/fs.h>
 
-+#include <linux/namei.h>
 
-+#include <linux/xattr.h>
 
-+#include <linux/security.h>
 
-+#include <linux/mount.h>
 
-+#include <linux/slab.h>
 
-+#include <linux/parser.h>
 
-+#include <linux/module.h>
 
-+#include <linux/seq_file.h>
 
-+#include "overlayfs.h"
 
-+
 
-+MODULE_AUTHOR("Miklos Szeredi <[email protected]>");
 
-+MODULE_DESCRIPTION("Overlay filesystem");
 
-+MODULE_LICENSE("GPL");
 
-+
 
-+struct ovl_config {
 
-+	char *lowerdir;
 
-+	char *upperdir;
 
-+};
 
-+
 
-+/* private information held for overlayfs's superblock */
 
-+struct ovl_fs {
 
-+	struct vfsmount *upper_mnt;
 
-+	struct vfsmount *lower_mnt;
 
-+	/* pathnames of lower and upper dirs, for show_options */
 
-+	struct ovl_config config;
 
-+};
 
-+
 
-+/* private information held for every overlayfs dentry */
 
-+struct ovl_entry {
 
-+	/*
 
-+	 * Keep "double reference" on upper dentries, so that
 
-+	 * d_delete() doesn't think it's OK to reset d_inode to NULL.
 
-+	 */
 
-+	struct dentry *__upperdentry;
 
-+	struct dentry *lowerdentry;
 
-+	union {
 
-+		struct {
 
-+			u64 version;
 
-+			bool opaque;
 
-+		};
 
-+		struct rcu_head rcu;
 
-+	};
 
-+};
 
-+
 
-+const char *ovl_whiteout_xattr = "trusted.overlay.whiteout";
 
-+const char *ovl_opaque_xattr = "trusted.overlay.opaque";
 
-+
 
-+
 
-+enum ovl_path_type ovl_path_type(struct dentry *dentry)
 
-+{
 
-+	struct ovl_entry *oe = dentry->d_fsdata;
 
-+
 
-+	if (oe->__upperdentry) {
 
-+		if (oe->lowerdentry && S_ISDIR(dentry->d_inode->i_mode))
 
-+			return OVL_PATH_MERGE;
 
-+		else
 
-+			return OVL_PATH_UPPER;
 
-+	} else {
 
-+		return OVL_PATH_LOWER;
 
-+	}
 
-+}
 
-+
 
-+static struct dentry *ovl_upperdentry_dereference(struct ovl_entry *oe)
 
-+{
 
-+	struct dentry *upperdentry = ACCESS_ONCE(oe->__upperdentry);
 
-+	smp_read_barrier_depends();
 
-+	return upperdentry;
 
-+}
 
-+
 
-+void ovl_path_upper(struct dentry *dentry, struct path *path)
 
-+{
 
-+	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 
-+	struct ovl_entry *oe = dentry->d_fsdata;
 
-+
 
-+	path->mnt = ofs->upper_mnt;
 
-+	path->dentry = ovl_upperdentry_dereference(oe);
 
-+}
 
-+
 
-+void ovl_path_lower(struct dentry *dentry, struct path *path)
 
-+{
 
-+	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 
-+	struct ovl_entry *oe = dentry->d_fsdata;
 
-+
 
-+	path->mnt = ofs->lower_mnt;
 
-+	path->dentry = oe->lowerdentry;
 
-+}
 
-+
 
-+enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path)
 
-+{
 
-+
 
-+	enum ovl_path_type type = ovl_path_type(dentry);
 
-+
 
-+	if (type == OVL_PATH_LOWER)
 
-+		ovl_path_lower(dentry, path);
 
-+	else
 
-+		ovl_path_upper(dentry, path);
 
-+
 
-+	return type;
 
-+}
 
-+
 
-+struct dentry *ovl_dentry_upper(struct dentry *dentry)
 
-+{
 
-+	struct ovl_entry *oe = dentry->d_fsdata;
 
-+
 
-+	return ovl_upperdentry_dereference(oe);
 
-+}
 
-+
 
-+struct dentry *ovl_dentry_lower(struct dentry *dentry)
 
-+{
 
-+	struct ovl_entry *oe = dentry->d_fsdata;
 
-+
 
-+	return oe->lowerdentry;
 
-+}
 
-+
 
-+struct dentry *ovl_dentry_real(struct dentry *dentry)
 
-+{
 
-+	struct ovl_entry *oe = dentry->d_fsdata;
 
-+	struct dentry *realdentry;
 
-+
 
-+	realdentry = ovl_upperdentry_dereference(oe);
 
-+	if (!realdentry)
 
-+		realdentry = oe->lowerdentry;
 
-+
 
-+	return realdentry;
 
-+}
 
-+
 
-+struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper)
 
-+{
 
-+	struct dentry *realdentry;
 
-+
 
-+	realdentry = ovl_upperdentry_dereference(oe);
 
-+	if (realdentry) {
 
-+		*is_upper = true;
 
-+	} else {
 
-+		realdentry = oe->lowerdentry;
 
-+		*is_upper = false;
 
-+	}
 
-+	return realdentry;
 
-+}
 
-+
 
-+bool ovl_dentry_is_opaque(struct dentry *dentry)
 
-+{
 
-+	struct ovl_entry *oe = dentry->d_fsdata;
 
-+	return oe->opaque;
 
-+}
 
-+
 
-+void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque)
 
-+{
 
-+	struct ovl_entry *oe = dentry->d_fsdata;
 
-+	oe->opaque = opaque;
 
-+}
 
-+
 
-+void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry)
 
-+{
 
-+	struct ovl_entry *oe = dentry->d_fsdata;
 
-+
 
-+	WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex));
 
-+	WARN_ON(oe->__upperdentry);
 
-+	BUG_ON(!upperdentry->d_inode);
 
-+	smp_wmb();
 
-+	oe->__upperdentry = dget(upperdentry);
 
-+}
 
-+
 
-+void ovl_dentry_version_inc(struct dentry *dentry)
 
-+{
 
-+	struct ovl_entry *oe = dentry->d_fsdata;
 
-+
 
-+	WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
 
-+	oe->version++;
 
-+}
 
-+
 
-+u64 ovl_dentry_version_get(struct dentry *dentry)
 
-+{
 
-+	struct ovl_entry *oe = dentry->d_fsdata;
 
-+
 
-+	WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
 
-+	return oe->version;
 
-+}
 
-+
 
-+bool ovl_is_whiteout(struct dentry *dentry)
 
-+{
 
-+	int res;
 
-+	char val;
 
-+
 
-+	if (!dentry)
 
-+		return false;
 
-+	if (!dentry->d_inode)
 
-+		return false;
 
-+	if (!S_ISLNK(dentry->d_inode->i_mode))
 
-+		return false;
 
-+
 
-+	res = vfs_getxattr(dentry, ovl_whiteout_xattr, &val, 1);
 
-+	if (res == 1 && val == 'y')
 
-+		return true;
 
-+
 
-+	return false;
 
-+}
 
-+
 
-+static bool ovl_is_opaquedir(struct dentry *dentry)
 
-+{
 
-+	int res;
 
-+	char val;
 
-+
 
-+	if (!S_ISDIR(dentry->d_inode->i_mode))
 
-+		return false;
 
-+
 
-+	res = vfs_getxattr(dentry, ovl_opaque_xattr, &val, 1);
 
-+	if (res == 1 && val == 'y')
 
-+		return true;
 
-+
 
-+	return false;
 
-+}
 
-+
 
-+static void ovl_entry_free(struct rcu_head *head)
 
-+{
 
-+	struct ovl_entry *oe = container_of(head, struct ovl_entry, rcu);
 
-+	kfree(oe);
 
-+}
 
-+
 
-+static void ovl_dentry_release(struct dentry *dentry)
 
-+{
 
-+	struct ovl_entry *oe = dentry->d_fsdata;
 
-+
 
-+	if (oe) {
 
-+		dput(oe->__upperdentry);
 
-+		dput(oe->__upperdentry);
 
-+		dput(oe->lowerdentry);
 
-+		call_rcu(&oe->rcu, ovl_entry_free);
 
-+	}
 
-+}
 
-+
 
-+const struct dentry_operations ovl_dentry_operations = {
 
-+	.d_release = ovl_dentry_release,
 
-+};
 
-+
 
-+static struct ovl_entry *ovl_alloc_entry(void)
 
-+{
 
-+	return kzalloc(sizeof(struct ovl_entry), GFP_KERNEL);
 
-+}
 
-+
 
-+static inline struct dentry *ovl_lookup_real(struct dentry *dir,
 
-+					     struct qstr *name)
 
-+{
 
-+	struct dentry *dentry;
 
-+
 
-+	mutex_lock(&dir->d_inode->i_mutex);
 
-+	dentry = lookup_one_len(name->name, dir, name->len);
 
-+	mutex_unlock(&dir->d_inode->i_mutex);
 
-+
 
-+	if (IS_ERR(dentry)) {
 
-+		if (PTR_ERR(dentry) == -ENOENT)
 
-+			dentry = NULL;
 
-+	} else if (!dentry->d_inode) {
 
-+		dput(dentry);
 
-+		dentry = NULL;
 
-+	}
 
-+	return dentry;
 
-+}
 
-+
 
-+static int ovl_do_lookup(struct dentry *dentry)
 
-+{
 
-+	struct ovl_entry *oe;
 
-+	struct dentry *upperdir;
 
-+	struct dentry *lowerdir;
 
-+	struct dentry *upperdentry = NULL;
 
-+	struct dentry *lowerdentry = NULL;
 
-+	struct inode *inode = NULL;
 
-+	int err;
 
-+
 
-+	err = -ENOMEM;
 
-+	oe = ovl_alloc_entry();
 
-+	if (!oe)
 
-+		goto out;
 
-+
 
-+	upperdir = ovl_dentry_upper(dentry->d_parent);
 
-+	lowerdir = ovl_dentry_lower(dentry->d_parent);
 
-+
 
-+	if (upperdir) {
 
-+		upperdentry = ovl_lookup_real(upperdir, &dentry->d_name);
 
-+		err = PTR_ERR(upperdentry);
 
-+		if (IS_ERR(upperdentry))
 
-+			goto out_put_dir;
 
-+
 
-+		if (lowerdir && upperdentry &&
 
-+		    (S_ISLNK(upperdentry->d_inode->i_mode) ||
 
-+		     S_ISDIR(upperdentry->d_inode->i_mode))) {
 
-+			const struct cred *old_cred;
 
-+			struct cred *override_cred;
 
-+
 
-+			err = -ENOMEM;
 
-+			override_cred = prepare_creds();
 
-+			if (!override_cred)
 
-+				goto out_dput_upper;
 
-+
 
-+			/* CAP_SYS_ADMIN needed for getxattr */
 
-+			cap_raise(override_cred->cap_effective, CAP_SYS_ADMIN);
 
-+			old_cred = override_creds(override_cred);
 
-+
 
-+			if (ovl_is_opaquedir(upperdentry)) {
 
-+				oe->opaque = true;
 
-+			} else if (ovl_is_whiteout(upperdentry)) {
 
-+				dput(upperdentry);
 
-+				upperdentry = NULL;
 
-+				oe->opaque = true;
 
-+			}
 
-+			revert_creds(old_cred);
 
-+			put_cred(override_cred);
 
-+		}
 
-+	}
 
-+	if (lowerdir && !oe->opaque) {
 
-+		lowerdentry = ovl_lookup_real(lowerdir, &dentry->d_name);
 
-+		err = PTR_ERR(lowerdentry);
 
-+		if (IS_ERR(lowerdentry))
 
-+			goto out_dput_upper;
 
-+	}
 
-+
 
-+	if (lowerdentry && upperdentry &&
 
-+	    (!S_ISDIR(upperdentry->d_inode->i_mode) ||
 
-+	     !S_ISDIR(lowerdentry->d_inode->i_mode))) {
 
-+		dput(lowerdentry);
 
-+		lowerdentry = NULL;
 
-+		oe->opaque = true;
 
-+	}
 
-+
 
-+	if (lowerdentry || upperdentry) {
 
-+		struct dentry *realdentry;
 
-+
 
-+		realdentry = upperdentry ? upperdentry : lowerdentry;
 
-+		err = -ENOMEM;
 
-+		inode = ovl_new_inode(dentry->d_sb, realdentry->d_inode->i_mode,
 
-+				      oe);
 
-+		if (!inode)
 
-+			goto out_dput;
 
-+	}
 
-+
 
-+	if (upperdentry)
 
-+		oe->__upperdentry = dget(upperdentry);
 
-+
 
-+	if (lowerdentry)
 
-+		oe->lowerdentry = lowerdentry;
 
-+
 
-+	dentry->d_fsdata = oe;
 
-+	dentry->d_op = &ovl_dentry_operations;
 
-+	d_add(dentry, inode);
 
-+
 
-+	return 0;
 
-+
 
-+out_dput:
 
-+	dput(lowerdentry);
 
-+out_dput_upper:
 
-+	dput(upperdentry);
 
-+out_put_dir:
 
-+	kfree(oe);
 
-+out:
 
-+	return err;
 
-+}
 
-+
 
-+struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
 
-+			  struct nameidata *nd)
 
-+{
 
-+	int err = ovl_do_lookup(dentry);
 
-+
 
-+	if (err)
 
-+		return ERR_PTR(err);
 
-+
 
-+	return NULL;
 
-+}
 
-+
 
-+struct file *ovl_path_open(struct path *path, int flags)
 
-+{
 
-+	path_get(path);
 
-+	return dentry_open(path->dentry, path->mnt, flags, current_cred());
 
-+}
 
-+
 
-+static void ovl_put_super(struct super_block *sb)
 
-+{
 
-+	struct ovl_fs *ufs = sb->s_fs_info;
 
-+
 
-+	if (!(sb->s_flags & MS_RDONLY))
 
-+		mnt_drop_write(ufs->upper_mnt);
 
-+
 
-+	mntput(ufs->upper_mnt);
 
-+	mntput(ufs->lower_mnt);
 
-+
 
-+	kfree(ufs->config.lowerdir);
 
-+	kfree(ufs->config.upperdir);
 
-+	kfree(ufs);
 
-+}
 
-+
 
-+static int ovl_remount_fs(struct super_block *sb, int *flagsp, char *data)
 
-+{
 
-+	int flags = *flagsp;
 
-+	struct ovl_fs *ufs = sb->s_fs_info;
 
-+
 
-+	/* When remounting rw or ro, we need to adjust the write access to the
 
-+	 * upper fs.
 
-+	 */
 
-+	if (((flags ^ sb->s_flags) & MS_RDONLY) == 0)
 
-+		/* No change to readonly status */
 
-+		return 0;
 
-+
 
-+	if (flags & MS_RDONLY) {
 
-+		mnt_drop_write(ufs->upper_mnt);
 
-+		return 0;
 
-+	} else
 
-+		return mnt_want_write(ufs->upper_mnt);
 
-+}
 
-+
 
-+/**
 
-+ * ovl_statfs
 
-+ * @sb: The overlayfs super block
 
-+ * @buf: The struct kstatfs to fill in with stats
 
-+ *
 
-+ * Get the filesystem statistics.  As writes always target the upper layer
 
-+ * filesystem pass the statfs to the same filesystem.
 
-+ */
 
-+static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf)
 
-+{
 
-+	struct dentry *root_dentry = dentry->d_sb->s_root;
 
-+	struct path path;
 
-+	ovl_path_upper(root_dentry, &path);
 
-+
 
-+	if (!path.dentry->d_sb->s_op->statfs)
 
-+		return -ENOSYS;
 
-+	return path.dentry->d_sb->s_op->statfs(path.dentry, buf);
 
-+}
 
-+
 
-+/**
 
-+ * ovl_show_options
 
-+ *
 
-+ * Prints the mount options for a given superblock.
 
-+ * Returns zero; does not fail.
 
-+ */
 
-+static int ovl_show_options(struct seq_file *m, struct dentry *dentry)
 
-+{
 
-+	struct super_block *sb = dentry->d_sb;
 
-+	struct ovl_fs *ufs = sb->s_fs_info;
 
-+
 
-+	seq_printf(m, ",lowerdir=%s", ufs->config.lowerdir);
 
-+	seq_printf(m, ",upperdir=%s", ufs->config.upperdir);
 
-+	return 0;
 
-+}
 
-+
 
-+static const struct super_operations ovl_super_operations = {
 
-+	.put_super	= ovl_put_super,
 
-+	.remount_fs	= ovl_remount_fs,
 
-+	.statfs		= ovl_statfs,
 
-+	.show_options	= ovl_show_options,
 
-+};
 
-+
 
-+enum {
 
-+	Opt_lowerdir,
 
-+	Opt_upperdir,
 
-+	Opt_err,
 
-+};
 
-+
 
-+static const match_table_t ovl_tokens = {
 
-+	{Opt_lowerdir,			"lowerdir=%s"},
 
-+	{Opt_upperdir,			"upperdir=%s"},
 
-+	{Opt_err,			NULL}
 
-+};
 
-+
 
-+static int ovl_parse_opt(char *opt, struct ovl_config *config)
 
-+{
 
-+	char *p;
 
-+
 
-+	config->upperdir = NULL;
 
-+	config->lowerdir = NULL;
 
-+
 
-+	while ((p = strsep(&opt, ",")) != NULL) {
 
-+		int token;
 
-+		substring_t args[MAX_OPT_ARGS];
 
-+
 
-+		if (!*p)
 
-+			continue;
 
-+
 
-+		token = match_token(p, ovl_tokens, args);
 
-+		switch (token) {
 
-+		case Opt_upperdir:
 
-+			kfree(config->upperdir);
 
-+			config->upperdir = match_strdup(&args[0]);
 
-+			if (!config->upperdir)
 
-+				return -ENOMEM;
 
-+			break;
 
-+
 
-+		case Opt_lowerdir:
 
-+			kfree(config->lowerdir);
 
-+			config->lowerdir = match_strdup(&args[0]);
 
-+			if (!config->lowerdir)
 
-+				return -ENOMEM;
 
-+			break;
 
-+
 
-+		default:
 
-+			return -EINVAL;
 
-+		}
 
-+	}
 
-+	return 0;
 
-+}
 
-+
 
-+static int ovl_fill_super(struct super_block *sb, void *data, int silent)
 
-+{
 
-+	struct path lowerpath;
 
-+	struct path upperpath;
 
-+	struct inode *root_inode;
 
-+	struct dentry *root_dentry;
 
-+	struct ovl_entry *oe;
 
-+	struct ovl_fs *ufs;
 
-+	int err;
 
-+
 
-+	err = -ENOMEM;
 
-+	ufs = kmalloc(sizeof(struct ovl_fs), GFP_KERNEL);
 
-+	if (!ufs)
 
-+		goto out;
 
-+
 
-+	err = ovl_parse_opt((char *) data, &ufs->config);
 
-+	if (err)
 
-+		goto out_free_ufs;
 
-+
 
-+	err = -EINVAL;
 
-+	if (!ufs->config.upperdir || !ufs->config.lowerdir) {
 
-+		printk(KERN_ERR "overlayfs: missing upperdir or lowerdir\n");
 
-+		goto out_free_config;
 
-+	}
 
-+
 
-+	oe = ovl_alloc_entry();
 
-+	if (oe == NULL)
 
-+		goto out_free_config;
 
-+
 
-+	root_inode = ovl_new_inode(sb, S_IFDIR, oe);
 
-+	if (!root_inode)
 
-+		goto out_free_oe;
 
-+
 
-+	err = kern_path(ufs->config.upperdir, LOOKUP_FOLLOW, &upperpath);
 
-+	if (err)
 
-+		goto out_put_root;
 
-+
 
-+	err = kern_path(ufs->config.lowerdir, LOOKUP_FOLLOW, &lowerpath);
 
-+	if (err)
 
-+		goto out_put_upperpath;
 
-+
 
-+	err = -ENOTDIR;
 
-+	if (!S_ISDIR(upperpath.dentry->d_inode->i_mode) ||
 
-+	    !S_ISDIR(lowerpath.dentry->d_inode->i_mode))
 
-+		goto out_put_lowerpath;
 
-+
 
-+	sb->s_stack_depth = max(upperpath.mnt->mnt_sb->s_stack_depth,
 
-+				lowerpath.mnt->mnt_sb->s_stack_depth) + 1;
 
-+
 
-+	err = -EINVAL;
 
-+	if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
 
-+		printk(KERN_ERR "overlayfs: maximum fs stacking depth exceeded\n");
 
-+		goto out_put_lowerpath;
 
-+	}
 
-+
 
-+
 
-+	ufs->upper_mnt = clone_private_mount(&upperpath);
 
-+	err = PTR_ERR(ufs->upper_mnt);
 
-+	if (IS_ERR(ufs->upper_mnt)) {
 
-+		printk(KERN_ERR "overlayfs: failed to clone upperpath\n");
 
-+		goto out_put_lowerpath;
 
-+	}
 
-+
 
-+	ufs->lower_mnt = clone_private_mount(&lowerpath);
 
-+	err = PTR_ERR(ufs->lower_mnt);
 
-+	if (IS_ERR(ufs->lower_mnt)) {
 
-+		printk(KERN_ERR "overlayfs: failed to clone lowerpath\n");
 
-+		goto out_put_upper_mnt;
 
-+	}
 
-+
 
-+	/*
 
-+	 * Make lower_mnt R/O.  That way fchmod/fchown on lower file
 
-+	 * will fail instead of modifying lower fs.
 
-+	 */
 
-+	ufs->lower_mnt->mnt_flags |= MNT_READONLY;
 
-+
 
-+	/* If the upper fs is r/o, we mark overlayfs r/o too */
 
-+	if (ufs->upper_mnt->mnt_sb->s_flags & MS_RDONLY)
 
-+		sb->s_flags |= MS_RDONLY;
 
-+
 
-+	if (!(sb->s_flags & MS_RDONLY)) {
 
-+		err = mnt_want_write(ufs->upper_mnt);
 
-+		if (err)
 
-+			goto out_put_lower_mnt;
 
-+	}
 
-+
 
-+	err = -ENOMEM;
 
-+	root_dentry = d_alloc_root(root_inode);
 
-+	if (!root_dentry)
 
-+		goto out_drop_write;
 
-+
 
-+	mntput(upperpath.mnt);
 
-+	mntput(lowerpath.mnt);
 
-+
 
-+	oe->__upperdentry = dget(upperpath.dentry);
 
-+	oe->lowerdentry = lowerpath.dentry;
 
-+
 
-+	root_dentry->d_fsdata = oe;
 
-+	root_dentry->d_op = &ovl_dentry_operations;
 
-+
 
-+	sb->s_op = &ovl_super_operations;
 
-+	sb->s_root = root_dentry;
 
-+	sb->s_fs_info = ufs;
 
-+
 
-+	return 0;
 
-+
 
-+out_drop_write:
 
-+	if (!(sb->s_flags & MS_RDONLY))
 
-+		mnt_drop_write(ufs->upper_mnt);
 
-+out_put_lower_mnt:
 
-+	mntput(ufs->lower_mnt);
 
-+out_put_upper_mnt:
 
-+	mntput(ufs->upper_mnt);
 
-+out_put_lowerpath:
 
-+	path_put(&lowerpath);
 
-+out_put_upperpath:
 
-+	path_put(&upperpath);
 
-+out_put_root:
 
-+	iput(root_inode);
 
-+out_free_oe:
 
-+	kfree(oe);
 
-+out_free_config:
 
-+	kfree(ufs->config.lowerdir);
 
-+	kfree(ufs->config.upperdir);
 
-+out_free_ufs:
 
-+	kfree(ufs);
 
-+out:
 
-+	return err;
 
-+}
 
-+
 
-+static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags,
 
-+				const char *dev_name, void *raw_data)
 
-+{
 
-+	return mount_nodev(fs_type, flags, raw_data, ovl_fill_super);
 
-+}
 
-+
 
-+static struct file_system_type ovl_fs_type = {
 
-+	.owner		= THIS_MODULE,
 
-+	.name		= "overlayfs",
 
-+	.mount		= ovl_mount,
 
-+	.kill_sb	= kill_anon_super,
 
-+};
 
-+
 
-+static int __init ovl_init(void)
 
-+{
 
-+	return register_filesystem(&ovl_fs_type);
 
-+}
 
-+
 
-+static void __exit ovl_exit(void)
 
-+{
 
-+	unregister_filesystem(&ovl_fs_type);
 
-+}
 
-+
 
-+module_init(ovl_init);
 
-+module_exit(ovl_exit);
 
---- a/fs/splice.c
 
-+++ b/fs/splice.c
 
-@@ -1302,6 +1302,7 @@ long do_splice_direct(struct file *in, l
 
- 
- 	return ret;
 
- }
 
-+EXPORT_SYMBOL(do_splice_direct);
 
- 
- static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe,
 
- 			       struct pipe_inode_info *opipe,
 
---- a/include/linux/fs.h
 
-+++ b/include/linux/fs.h
 
-@@ -484,6 +484,12 @@ struct iattr {
 
-  */
 
- #include <linux/quota.h>
 
- 
-+/*
 
-+ * Maximum number of layers of fs stack.  Needs to be limited to
 
-+ * prevent kernel stack overflow
 
-+ */
 
-+#define FILESYSTEM_MAX_STACK_DEPTH 2
 
-+
 
- /** 
-  * enum positive_aop_returns - aop return codes with specific semantics
 
-  *
 
-@@ -1501,6 +1507,11 @@ struct super_block {
 
- 
- 	/* Being remounted read-only */
 
- 	int s_readonly_remount;
 
-+
 
-+	/*
 
-+	 * Indicates how deep in a filesystem stack this SB is
 
-+	 */
 
-+	int s_stack_depth;
 
- };
 
- 
- /* superblock cache pruning functions */
 
-@@ -1658,6 +1669,8 @@ struct inode_operations {
 
- 	void (*truncate_range)(struct inode *, loff_t, loff_t);
 
- 	int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
 
- 		      u64 len);
 
-+	struct file *(*open) (struct dentry *, struct file *,
 
-+			      const struct cred *);
 
- } ____cacheline_aligned;
 
- 
- struct seq_file;
 
-@@ -2028,6 +2041,7 @@ extern long do_sys_open(int dfd, const c
 
- extern struct file *filp_open(const char *, int, umode_t);
 
- extern struct file *file_open_root(struct dentry *, struct vfsmount *,
 
- 				   const char *, int);
 
-+extern struct file *vfs_open(struct path *, struct file *, const struct cred *);
 
- extern struct file * dentry_open(struct dentry *, struct vfsmount *, int,
 
- 				 const struct cred *);
 
- extern int filp_close(struct file *, fl_owner_t id);
 
---- a/include/linux/mount.h
 
-+++ b/include/linux/mount.h
 
-@@ -66,6 +66,9 @@ extern void mnt_pin(struct vfsmount *mnt
 
- extern void mnt_unpin(struct vfsmount *mnt);
 
- extern int __mnt_is_readonly(struct vfsmount *mnt);
 
- 
-+struct path;
 
-+extern struct vfsmount *clone_private_mount(struct path *path);
 
-+
 
- struct file_system_type;
 
- extern struct vfsmount *vfs_kern_mount(struct file_system_type *type,
 
- 				      int flags, const char *name,

+ 0 - 41
target/linux/generic/patches-3.3/102-ehci_hcd_ignore_oc.patch
View File 

@@ -1,41 +0,0 @@
 
---- a/drivers/usb/host/ehci-hcd.c
 
-+++ b/drivers/usb/host/ehci-hcd.c
 
-@@ -795,7 +795,7 @@ static int ehci_run (struct usb_hcd *hcd
 
- 		"USB %x.%x started, EHCI %x.%02x%s\n",
 
- 		((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
 
- 		temp >> 8, temp & 0xff,
 
--		ignore_oc ? ", overcurrent ignored" : "");
 
-+		(ignore_oc || ehci->ignore_oc) ? ", overcurrent ignored" : "");
 
- 
- 	ehci_writel(ehci, INTR_MASK,
 
- 		    &ehci->regs->intr_enable); /* Turn On Interrupts */
 
---- a/drivers/usb/host/ehci-hub.c
 
-+++ b/drivers/usb/host/ehci-hub.c
 
-@@ -578,7 +578,7 @@ ehci_hub_status_data (struct usb_hcd *hc
 
- 	 * always set, seem to clear PORT_OCC and PORT_CSC when writing to
 
- 	 * PORT_POWER; that's surprising, but maybe within-spec.
 
- 	 */
 
--	if (!ignore_oc)
 
-+	if (!ignore_oc && !ehci->ignore_oc)
 
- 		mask = PORT_CSC | PORT_PEC | PORT_OCC;
 
- 	else
 
- 		mask = PORT_CSC | PORT_PEC;
 
-@@ -803,7 +803,7 @@ static int ehci_hub_control (
 
- 		if (temp & PORT_PEC)
 
- 			status |= USB_PORT_STAT_C_ENABLE << 16;
 
- 
--		if ((temp & PORT_OCC) && !ignore_oc){
 
-+		if ((temp & PORT_OCC) && (!ignore_oc && !ehci->ignore_oc)){
 
- 			status |= USB_PORT_STAT_C_OVERCURRENT << 16;
 
- 
- 			/*
 
---- a/drivers/usb/host/ehci.h
 
-+++ b/drivers/usb/host/ehci.h
 
-@@ -147,6 +147,7 @@ struct ehci_hcd {			/* one per controlle
 
- 	unsigned		use_dummy_qh:1;	/* AMD Frame List table quirk*/
 
- 	unsigned		has_synopsys_hc_bug:1; /* Synopsys HC */
 
- 	unsigned		frame_index_bug:1; /* MosChip (AKA NetMos) */
 
-+	unsigned		ignore_oc:1;
 
- 
- 	/* required for usb32 quirk */
 
- 	#define OHCI_CTRL_HCFS          (3 << 6)

+ 0 - 10
target/linux/generic/patches-3.3/110-fix_mtd_include.patch
View File 

@@ -1,10 +0,0 @@
 
---- a/include/linux/mtd/physmap.h
 
-+++ b/include/linux/mtd/physmap.h
 
-@@ -17,6 +17,7 @@
 
- 
- #include <linux/mtd/mtd.h>
 
- #include <linux/mtd/partitions.h>
 
-+#include <linux/platform_device.h>
 
- 
- struct map_info;
 
- struct platform_device;

+ 0 - 188
target/linux/generic/patches-3.3/130-pppoatm-queue-depth.patch
View File 

@@ -1,188 +0,0 @@
 
-From 9d02daf754238adac48fa075ee79e7edd3d79ed3 Mon Sep 17 00:00:00 2001
 
-From: David Woodhouse <[email protected]>
 
-Date: Sun, 8 Apr 2012 09:55:43 +0000
 
-Subject: [PATCH] pppoatm: Fix excessive queue bloat
 
-
 
-We discovered that PPPoATM has an excessively deep transmit queue. A
 
-queue the size of the default socket send buffer (wmem_default) is
 
-maintained between the PPP generic core and the ATM device.
 
-
 
-Fix it to queue a maximum of *two* packets. The one the ATM device is
 
-currently working on, and one more for the ATM driver to process
 
-immediately in its TX done interrupt handler. The PPP core is designed
 
-to feed packets to the channel with minimal latency, so that really
 
-ought to be enough to keep the ATM device busy.
 
-
 
-While we're at it, fix the fact that we were triggering the wakeup
 
-tasklet on *every* pppoatm_pop() call. The comment saying "this is
 
-inefficient, but doing it right is too hard" turns out to be overly
 
-pessimistic... I think :)
 
-
 
-On machines like the Traverse Geos, with a slow Geode CPU and two
 
-high-speed ADSL2+ interfaces, there were reports of extremely high CPU
 
-usage which could partly be attributed to the extra wakeups.
 
-
 
-(The wakeup handling could actually be made a whole lot easier if we
 
- stop checking sk->sk_sndbuf altogether. Given that we now only queue
 
- *two* packets ever, one wonders what the point is. As it is, you could
 
- already deadlock the thing by setting the sk_sndbuf to a value lower
 
- than the MTU of the device, and it'd just block for ever.)
 
-
 
-Signed-off-by: David Woodhouse <[email protected]>
 
-Signed-off-by: David S. Miller <[email protected]>
 
----
 
- net/atm/pppoatm.c |   95 +++++++++++++++++++++++++++++++++++++++++++++++-----
 
- 1 files changed, 85 insertions(+), 10 deletions(-)
 
-
 
---- a/net/atm/pppoatm.c
 
-+++ b/net/atm/pppoatm.c
 
-@@ -62,12 +62,25 @@ struct pppoatm_vcc {
 
- 	void (*old_pop)(struct atm_vcc *, struct sk_buff *);
 
- 					/* keep old push/pop for detaching */
 
- 	enum pppoatm_encaps encaps;
 
-+	atomic_t inflight;
 
-+	unsigned long blocked;
 
- 	int flags;			/* SC_COMP_PROT - compress protocol */
 
- 	struct ppp_channel chan;	/* interface to generic ppp layer */
 
- 	struct tasklet_struct wakeup_tasklet;
 
- };
 
- 
- /*
 
-+ * We want to allow two packets in the queue. The one that's currently in
 
-+ * flight, and *one* queued up ready for the ATM device to send immediately
 
-+ * from its TX done IRQ. We want to be able to use atomic_inc_not_zero(), so
 
-+ * inflight == -2 represents an empty queue, -1 one packet, and zero means
 
-+ * there are two packets in the queue.
 
-+ */
 
-+#define NONE_INFLIGHT -2
 
-+
 
-+#define BLOCKED 0
 
-+
 
-+/*
 
-  * Header used for LLC Encapsulated PPP (4 bytes) followed by the LCP protocol
 
-  * ID (0xC021) used in autodetection
 
-  */
 
-@@ -102,16 +115,30 @@ static void pppoatm_wakeup_sender(unsign
 
- static void pppoatm_pop(struct atm_vcc *atmvcc, struct sk_buff *skb)
 
- {
 
- 	struct pppoatm_vcc *pvcc = atmvcc_to_pvcc(atmvcc);
 
-+
 
- 	pvcc->old_pop(atmvcc, skb);
 
-+	atomic_dec(&pvcc->inflight);
 
-+
 
- 	/*
 
--	 * We don't really always want to do this since it's
 
--	 * really inefficient - it would be much better if we could
 
--	 * test if we had actually throttled the generic layer.
 
--	 * Unfortunately then there would be a nasty SMP race where
 
--	 * we could clear that flag just as we refuse another packet.
 
--	 * For now we do the safe thing.
 
-+	 * We always used to run the wakeup tasklet unconditionally here, for
 
-+	 * fear of race conditions where we clear the BLOCKED flag just as we
 
-+	 * refuse another packet in pppoatm_send(). This was quite inefficient.
 
-+	 *
 
-+	 * In fact it's OK. The PPP core will only ever call pppoatm_send()
 
-+	 * while holding the channel->downl lock. And ppp_output_wakeup() as
 
-+	 * called by the tasklet will *also* grab that lock. So even if another
 
-+	 * CPU is in pppoatm_send() right now, the tasklet isn't going to race
 
-+	 * with it. The wakeup *will* happen after the other CPU is safely out
 
-+	 * of pppoatm_send() again.
 
-+	 *
 
-+	 * So if the CPU in pppoatm_send() has already set the BLOCKED bit and
 
-+	 * it about to return, that's fine. We trigger a wakeup which will
 
-+	 * happen later. And if the CPU in pppoatm_send() *hasn't* set the
 
-+	 * BLOCKED bit yet, that's fine too because of the double check in
 
-+	 * pppoatm_may_send() which is commented there.
 
- 	 */
 
--	tasklet_schedule(&pvcc->wakeup_tasklet);
 
-+	if (test_and_clear_bit(BLOCKED, &pvcc->blocked))
 
-+		tasklet_schedule(&pvcc->wakeup_tasklet);
 
- }
 
- 
- /*
 
-@@ -184,6 +211,51 @@ error:
 
- 	ppp_input_error(&pvcc->chan, 0);
 
- }
 
- 
-+static inline int pppoatm_may_send(struct pppoatm_vcc *pvcc, int size)
 
-+{
 
-+	/*
 
-+	 * It's not clear that we need to bother with using atm_may_send()
 
-+	 * to check we don't exceed sk->sk_sndbuf. If userspace sets a
 
-+	 * value of sk_sndbuf which is lower than the MTU, we're going to
 
-+	 * block for ever. But the code always did that before we introduced
 
-+	 * the packet count limit, so...
 
-+	 */
 
-+	if (atm_may_send(pvcc->atmvcc, size) &&
 
-+	    atomic_inc_not_zero_hint(&pvcc->inflight, NONE_INFLIGHT))
 
-+		return 1;
 
-+
 
-+	/*
 
-+	 * We use test_and_set_bit() rather than set_bit() here because
 
-+	 * we need to ensure there's a memory barrier after it. The bit
 
-+	 * *must* be set before we do the atomic_inc() on pvcc->inflight.
 
-+	 * There's no smp_mb__after_set_bit(), so it's this or abuse
 
-+	 * smp_mb__after_clear_bit().
 
-+	 */
 
-+	test_and_set_bit(BLOCKED, &pvcc->blocked);
 
-+
 
-+	/*
 
-+	 * We may have raced with pppoatm_pop(). If it ran for the
 
-+	 * last packet in the queue, *just* before we set the BLOCKED
 
-+	 * bit, then it might never run again and the channel could
 
-+	 * remain permanently blocked. Cope with that race by checking
 
-+	 * *again*. If it did run in that window, we'll have space on
 
-+	 * the queue now and can return success. It's harmless to leave
 
-+	 * the BLOCKED flag set, since it's only used as a trigger to
 
-+	 * run the wakeup tasklet. Another wakeup will never hurt.
 
-+	 * If pppoatm_pop() is running but hasn't got as far as making
 
-+	 * space on the queue yet, then it hasn't checked the BLOCKED
 
-+	 * flag yet either, so we're safe in that case too. It'll issue
 
-+	 * an "immediate" wakeup... where "immediate" actually involves
 
-+	 * taking the PPP channel's ->downl lock, which is held by the
 
-+	 * code path that calls pppoatm_send(), and is thus going to
 
-+	 * wait for us to finish.
 
-+	 */
 
-+	if (atm_may_send(pvcc->atmvcc, size) &&
 
-+	    atomic_inc_not_zero(&pvcc->inflight))
 
-+		return 1;
 
-+
 
-+	return 0;
 
-+}
 
- /*
 
-  * Called by the ppp_generic.c to send a packet - returns true if packet
 
-  * was accepted.  If we return false, then it's our job to call
 
-@@ -207,7 +279,7 @@ static int pppoatm_send(struct ppp_chann
 
- 			struct sk_buff *n;
 
- 			n = skb_realloc_headroom(skb, LLC_LEN);
 
- 			if (n != NULL &&
 
--			    !atm_may_send(pvcc->atmvcc, n->truesize)) {
 
-+			    !pppoatm_may_send(pvcc, n->truesize)) {
 
- 				kfree_skb(n);
 
- 				goto nospace;
 
- 			}
 
-@@ -215,12 +287,12 @@ static int pppoatm_send(struct ppp_chann
 
- 			skb = n;
 
- 			if (skb == NULL)
 
- 				return DROP_PACKET;
 
--		} else if (!atm_may_send(pvcc->atmvcc, skb->truesize))
 
-+		} else if (!pppoatm_may_send(pvcc, skb->truesize))
 
- 			goto nospace;
 
- 		memcpy(skb_push(skb, LLC_LEN), pppllc, LLC_LEN);
 
- 		break;
 
- 	case e_vc:
 
--		if (!atm_may_send(pvcc->atmvcc, skb->truesize))
 
-+		if (!pppoatm_may_send(pvcc, skb->truesize))
 
- 			goto nospace;
 
- 		break;
 
- 	case e_autodetect:
 
-@@ -285,6 +357,9 @@ static int pppoatm_assign_vcc(struct atm
 
- 	if (pvcc == NULL)
 
- 		return -ENOMEM;
 
- 	pvcc->atmvcc = atmvcc;
 
-+
 
-+	/* Maximum is zero, so that we can use atomic_inc_not_zero() */
 
-+	atomic_set(&pvcc->inflight, NONE_INFLIGHT);
 
- 	pvcc->old_push = atmvcc->push;
 
- 	pvcc->old_pop = atmvcc->pop;
 
- 	pvcc->encaps = (enum pppoatm_encaps) be.encaps;

+ 0 - 900
target/linux/generic/patches-3.3/131-atm-fixes.patch
View File 

@@ -1,900 +0,0 @@
 
-commit d7d3d8f1ee4435e32bc6c93187798b7e2e3170a9
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Thu Nov 29 23:28:30 2012 +0000
 
-
 
-    solos-pci: remove list_vccs() debugging function
 
-    
-    No idea why we've gone so long dumping a list of VCCs with vci==0 on
 
-    every ->open() call...
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-
 
-commit c93967bfd3a3dffa759a3f28370167bf3cdbc3d0
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Thu Nov 29 23:27:20 2012 +0000
 
-
 
-    solos-pci: use GFP_KERNEL where possible, not GFP_ATOMIC
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-
 
-commit ad6999e17ae4f7b99f6d28f425ae970acb115347
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Thu Nov 29 23:15:30 2012 +0000
 
-
 
-    solos-pci: clean up pclose() function
 
-    
-     - Flush pending TX skbs from the queue rather than waiting for them all to
 
-       complete (suggested by Krzysztof Mazur <[email protected]>).
 
-     - Clear ATM_VF_ADDR only when the PKT_PCLOSE packet has been submitted.
 
-     - Don't clear ATM_VF_READY at all — vcc_destroy_socket() does that for us.
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-
 
-commit 2547e97f29d6d69d567947d5ef90b6b4fbcaf565
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Wed Nov 28 10:15:05 2012 +0000
 
-
 
-    pppoatm: optimise PPP channel wakeups after sock_owned_by_user()
 
-    
-    We don't need to schedule the wakeup tasklet on *every* unlock; only if we
 
-    actually blocked the channel in the first place.
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Acked-by: Krzysztof Mazur <[email protected]>
 
-
 
-commit 990b0884a2e9668c08e9daa4d70a54d65329cb6f
 
-Author: Krzysztof Mazur <[email protected]>
 
-Date:   Wed Nov 28 09:08:04 2012 +0100
 
-
 
-    br2684: allow assign only on a connected socket
 
-    
-    The br2684 does not check if used vcc is in connected state,
 
-    causing potential Oops in pppoatm_send() when vcc->send() is called
 
-    on not fully connected socket.
 
-    
-    Now br2684 can be assigned only on connected sockets; otherwise
 
-    -EINVAL error is returned.
 
-    
-    Signed-off-by: Krzysztof Mazur <[email protected]>
 
-    Signed-off-by: David Woodhouse <[email protected]>
 
-
 
-commit f49b6da01f0abebb17f6241473d53018d923f6b0
 
-Author: Nathan Williams <[email protected]>
 
-Date:   Tue Nov 27 17:34:09 2012 +1100
 
-
 
-    solos-pci: Fix leak of skb received for unknown vcc
 
-    
-    ... and ensure that the next skb is set up for RX in the DMA case.
 
-    
-    Signed-off-by: Nathan Williams <[email protected]>
 
-    Signed-off-by: David Woodhouse <[email protected]>
 
-
 
-commit a61d37ff4a555886c4ebe31d2c6d893afb6f4d3c
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Wed Nov 28 00:46:45 2012 +0000
 
-
 
-    br2684: fix module_put() race
 
-    
-    The br2684 code used module_put() during unassignment from vcc with
 
-    hope that we have BKL. This assumption is no longer true.
 
-    
-    Now owner field in atmvcc is used to move this module_put()
 
-    to vcc_destroy_socket().
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Acked-by: Krzysztof Mazur <[email protected]>
 
-
 
-commit c52f40629884ddc62c7af445fd5d620fdb466fb2
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Wed Nov 28 00:05:52 2012 +0000
 
-
 
-    pppoatm: fix missing wakeup in pppoatm_send()
 
-    
-    Now that we can return zero from pppoatm_send() for reasons *other* than
 
-    the queue being full, that means we can't depend on a subsequent call to
 
-    pppoatm_pop() waking the queue, and we might leave it stalled
 
-    indefinitely.
 
-    
-    Use the ->release_cb() callback to wake the queue after the sock is
 
-    unlocked.
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Acked-by: Krzysztof Mazur <[email protected]>
 
-
 
-commit 35826e7372fe39b7db7930eda0267c82d68d1a4c
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Tue Nov 27 23:28:36 2012 +0000
 
-
 
-    br2684: don't send frames on not-ready vcc
 
-    
-    Avoid submitting packets to a vcc which is being closed. Things go badly
 
-    wrong when the ->pop method gets later called after everything's been
 
-    torn down.
 
-    
-    Use the ATM socket lock for synchronisation with vcc_destroy_socket(),
 
-    which clears the ATM_VF_READY bit under the same lock. Otherwise, we
 
-    could end up submitting a packet to the device driver even after its
 
-    ->ops->close method has been called. And it could call the vcc's ->pop
 
-    method after the protocol has been shut down. Which leads to a panic.
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Acked-by: Krzysztof Mazur <[email protected]>
 
-
 
-commit 7f940dde65de4a707f3dd723bb6ce9de90ca1eab
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Wed Nov 28 00:03:11 2012 +0000
 
-
 
-    atm: add release_cb() callback to vcc
 
-    
-    The immediate use case for this is that it will allow us to ensure that a
 
-    pppoatm queue is woken after it has to drop a packet due to the sock being
 
-    locked.
 
-    
-    Note that 'release_cb' is called when the socket is *unlocked*. This is
 
-    not to be confused with vcc_release() — which probably ought to be called
 
-    vcc_close().
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Acked-by: Krzysztof Mazur <[email protected]>
 
-
 
-commit def1b2f9083f84d0a77730e537c76429914d17c1
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Tue Nov 27 23:49:24 2012 +0000
 
-
 
-    solos-pci: wait for pending TX to complete when releasing vcc
 
-    
-    We should no longer be calling the old pop routine for the vcc, after
 
-    vcc_release() has completed. Make sure we wait for any pending TX skbs
 
-    to complete, by waiting for our own PKT_PCLOSE control skb to be sent.
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-
 
-commit 397ff16dce53888ec693b3718640be2560204751
 
-Author: Krzysztof Mazur <[email protected]>
 
-Date:   Tue Nov 6 23:17:02 2012 +0100
 
-
 
-    pppoatm: do not inline pppoatm_may_send()
 
-    
-    The pppoatm_may_send() is quite heavy and it's called three times
 
-    in pppoatm_send() and inlining costs more than 200 bytes of code
 
-    (more than 10% of total pppoatm driver code size).
 
-    
-    add/remove: 1/0 grow/shrink: 0/1 up/down: 132/-367 (-235)
 
-    function                                     old     new   delta
 
-    pppoatm_may_send                               -     132    +132
 
-    pppoatm_send                                 900     533    -367
 
-    
-    Signed-off-by: Krzysztof Mazur <[email protected]>
 
-    Signed-off-by: David Woodhouse <[email protected]>
 
-
 
-commit 071d93931a75dc1f82f0baa9959613af81c5a032
 
-Author: Krzysztof Mazur <[email protected]>
 
-Date:   Sat Nov 10 23:33:19 2012 +0100
 
-
 
-    pppoatm: drop frames to not-ready vcc
 
-    
-    The vcc_destroy_socket() closes vcc before the protocol is detached
 
-    from vcc by calling vcc->push() with NULL skb. This leaves some time
 
-    window, where the protocol may call vcc->send() on closed vcc
 
-    and crash.
 
-    
-    Now pppoatm_send(), like vcc_sendmsg(), checks for vcc flags that
 
-    indicate that vcc is not ready. If the vcc is not ready we just
 
-    drop frame. Queueing frames is much more complicated because we
 
-    don't have callbacks that inform us about vcc flags changes.
 
-    
-    Signed-off-by: Krzysztof Mazur <[email protected]>
 
-    Signed-off-by: David Woodhouse <[email protected]>
 
-
 
-commit 3ac108006fd7f20cb8fc8ea2287f1497bcda00a1
 
-Author: Krzysztof Mazur <[email protected]>
 
-Date:   Tue Nov 6 23:17:00 2012 +0100
 
-
 
-    pppoatm: take ATM socket lock in pppoatm_send()
 
-    
-    The pppoatm_send() does not take any lock that will prevent concurrent
 
-    vcc_sendmsg(). This causes two problems:
 
-    
-    	- there is no locking between checking the send queue size
 
-    	  with atm_may_send() and incrementing sk_wmem_alloc,
 
-    	  and the real queue size can be a little higher than sk_sndbuf
 
-    
-    	- the vcc->sendmsg() can be called concurrently. I'm not sure
 
-    	  if it's allowed. Some drivers (eni, nicstar, ...) seem
 
-    	  to assume it will never happen.
 
-    
-    Now pppoatm_send() takes ATM socket lock, the same that is used
 
-    in vcc_sendmsg() and other ATM socket functions. The pppoatm_send()
 
-    is called with BH disabled, so bh_lock_sock() is used instead
 
-    of lock_sock().
 
-    
-    Signed-off-by: Krzysztof Mazur <[email protected]>
 
-    Cc: Chas Williams - CONTRACTOR <[email protected]>
 
-    Signed-off-by: David Woodhouse <[email protected]>
 
-
 
-commit e41faed9cde1acce657f75a0b19a1787e9850d3f
 
-Author: Krzysztof Mazur <[email protected]>
 
-Date:   Tue Nov 6 23:16:59 2012 +0100
 
-
 
-    pppoatm: fix module_put() race
 
-    
-    The pppoatm used module_put() during unassignment from vcc with
 
-    hope that we have BKL. This assumption is no longer true.
 
-    
-    Now owner field in atmvcc is used to move this module_put()
 
-    to vcc_destroy_socket().
 
-    
-    Signed-off-by: Krzysztof Mazur <[email protected]>
 
-    Signed-off-by: David Woodhouse <[email protected]>
 
-
 
-commit 3b1a914595f3f9beb9e38ff3ddc7bdafa092ba22
 
-Author: Krzysztof Mazur <[email protected]>
 
-Date:   Tue Nov 6 23:16:58 2012 +0100
 
-
 
-    pppoatm: allow assign only on a connected socket
 
-    
-    The pppoatm does not check if used vcc is in connected state,
 
-    causing an Oops in pppoatm_send() when vcc->send() is called
 
-    on not fully connected socket.
 
-    
-    Now pppoatm can be assigned only on connected sockets; otherwise
 
-    -EINVAL error is returned.
 
-    
-    Signed-off-by: Krzysztof Mazur <[email protected]>
 
-    Cc: Chas Williams - CONTRACTOR <[email protected]>
 
-    Signed-off-by: David Woodhouse <[email protected]>
 
-
 
-commit ec809bd817dfa1905283468e4c813684ed4efe78
 
-Author: Krzysztof Mazur <[email protected]>
 
-Date:   Tue Nov 6 23:16:57 2012 +0100
 
-
 
-    atm: add owner of push() callback to atmvcc
 
-    
-    The atm is using atmvcc->push(vcc, NULL) callback to notify protocol
 
-    that vcc will be closed and protocol must detach from it. This callback
 
-    is usually used by protocol to decrement module usage count by module_put(),
 
-    but it leaves small window then module is still used after module_put().
 
-    
-    Now the owner of push() callback is kept in atmvcc and
 
-    module_put(atmvcc->owner) is called after the protocol is detached from vcc.
 
-    
-    Signed-off-by: Krzysztof Mazur <[email protected]>
 
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Acked-by: Chas Williams <[email protected]>
 
-
 
-commit ae088d663beebb3cad0e7abaac67ee61a7c578d5
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Sun Nov 25 12:06:52 2012 +0000
 
-
 
-    atm: br2684: Fix excessive queue bloat
 
-    
-    There's really no excuse for an additional wmem_default of buffering
 
-    between the netdev queue and the ATM device. Two packets (one in-flight,
 
-    and one ready to send) ought to be fine. It's not as if it should take
 
-    long to get another from the netdev queue when we need it.
 
-    
-    If necessary we can make the queue space configurable later, but I don't
 
-    think it's likely to be necessary.
 
-    
-    cf. commit 9d02daf754238adac48fa075ee79e7edd3d79ed3 (pppoatm: Fix
 
-    excessive queue bloat) which did something very similar for PPPoATM.
 
-    
-    Note that there is a tremendously unlikely race condition which may
 
-    result in qspace temporarily going negative. If a CPU running the
 
-    br2684_pop() function goes off into the weeds for a long period of time
 
-    after incrementing qspace to 1, but before calling netdev_wake_queue()...
 
-    and another CPU ends up calling br2684_start_xmit() and *stopping* the
 
-    queue again before the first CPU comes back, the netdev queue could
 
-    end up being woken when qspace has already reached zero.
 
-    
-    An alternative approach to coping with this race would be to check in
 
-    br2684_start_xmit() for qspace==0 and return NETDEV_TX_BUSY, but just
 
-    using '> 0' and '< 1' for comparison instead of '== 0' and '!= 0' is
 
-    simpler. It just warranted a mention of *why* we do it that way...
 
-    
-    Move the call to atmvcc->send() to happen *after* the accounting and
 
-    potentially stopping the netdev queue, in br2684_xmit_vcc(). This matters
 
-    if the ->send() call suffers an immediate failure, because it'll call
 
-    br2684_pop() with the offending skb before returning. We want that to
 
-    happen *after* we've done the initial accounting for the packet in
 
-    question. Also make it return an appropriate success/failure indication
 
-    while we're at it.
 
-    
-    Tested by running 'ping -l 1000 bottomless.aaisp.net.uk' from within my
 
-    network, with only a single PPPoE-over-BR2684 link running. And after
 
-    setting txqueuelen on the nas0 interface to something low (5, in fact).
 
-    Before the patch, we'd see about 15 packets being queued and a resulting
 
-    latency of ~56ms being reached. After the patch, we see only about 8,
 
-    which is fairly much what we expect. And a max latency of ~36ms. On this
 
-    OpenWRT box, wmem_default is 163840.
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Reviewed-by: Krzysztof Mazur <[email protected]>
 
-    Signed-off-by: David S. Miller <[email protected]>
 
-
 
---- a/drivers/atm/solos-pci.c
 
-+++ b/drivers/atm/solos-pci.c
 
-@@ -92,6 +92,7 @@ struct pkt_hdr {
 
- };
 
- 
- struct solos_skb_cb {
 
-+	struct completion c;
 
- 	struct atm_vcc *vcc;
 
- 	uint32_t dma_addr;
 
- };
 
-@@ -164,7 +165,6 @@ static void fpga_queue(struct solos_card
 
- static uint32_t fpga_tx(struct solos_card *);
 
- static irqreturn_t solos_irq(int irq, void *dev_id);
 
- static struct atm_vcc* find_vcc(struct atm_dev *dev, short vpi, int vci);
 
--static int list_vccs(int vci);
 
- static int atm_init(struct solos_card *, struct device *);
 
- static void atm_remove(struct solos_card *);
 
- static int send_command(struct solos_card *card, int dev, const char *buf, size_t size);
 
-@@ -710,7 +710,8 @@ void solos_bh(unsigned long card_arg)
 
- 						dev_warn(&card->dev->dev, "Received packet for unknown VPI.VCI %d.%d on port %d\n",
 
- 							 le16_to_cpu(header->vpi), le16_to_cpu(header->vci),
 
- 							 port);
 
--					continue;
 
-+					dev_kfree_skb_any(skb);
 
-+					break;
 
- 				}
 
- 				atm_charge(vcc, skb->truesize);
 
- 				vcc->push(vcc, skb);
 
-@@ -790,44 +791,6 @@ static struct atm_vcc *find_vcc(struct a
 
- 	return vcc;
 
- }
 
- 
--static int list_vccs(int vci)
 
--{
 
--	struct hlist_head *head;
 
--	struct atm_vcc *vcc;
 
--	struct hlist_node *node;
 
--	struct sock *s;
 
--	int num_found = 0;
 
--	int i;
 
--
 
--	read_lock(&vcc_sklist_lock);
 
--	if (vci != 0){
 
--		head = &vcc_hash[vci & (VCC_HTABLE_SIZE -1)];
 
--		sk_for_each(s, node, head) {
 
--			num_found ++;
 
--			vcc = atm_sk(s);
 
--			printk(KERN_DEBUG "Device: %d Vpi: %d Vci: %d\n",
 
--			       vcc->dev->number,
 
--			       vcc->vpi,
 
--			       vcc->vci);
 
--		}
 
--	} else {
 
--		for(i = 0; i < VCC_HTABLE_SIZE; i++){
 
--			head = &vcc_hash[i];
 
--			sk_for_each(s, node, head) {
 
--				num_found ++;
 
--				vcc = atm_sk(s);
 
--				printk(KERN_DEBUG "Device: %d Vpi: %d Vci: %d\n",
 
--				       vcc->dev->number,
 
--				       vcc->vpi,
 
--				       vcc->vci);
 
--			}
 
--		}
 
--	}
 
--	read_unlock(&vcc_sklist_lock);
 
--	return num_found;
 
--}
 
--
 
--
 
- static int popen(struct atm_vcc *vcc)
 
- {
 
- 	struct solos_card *card = vcc->dev->dev_data;
 
-@@ -840,7 +803,7 @@ static int popen(struct atm_vcc *vcc)
 
- 		return -EINVAL;
 
- 	}
 
- 
--	skb = alloc_skb(sizeof(*header), GFP_ATOMIC);
 
-+	skb = alloc_skb(sizeof(*header), GFP_KERNEL);
 
- 	if (!skb) {
 
- 		if (net_ratelimit())
 
- 			dev_warn(&card->dev->dev, "Failed to allocate sk_buff in popen()\n");
 
-@@ -857,8 +820,6 @@ static int popen(struct atm_vcc *vcc)
 
- 
- 	set_bit(ATM_VF_ADDR, &vcc->flags);
 
- 	set_bit(ATM_VF_READY, &vcc->flags);
 
--	list_vccs(0);
 
--
 
- 
- 	return 0;
 
- }
 
-@@ -866,10 +827,21 @@ static int popen(struct atm_vcc *vcc)
 
- static void pclose(struct atm_vcc *vcc)
 
- {
 
- 	struct solos_card *card = vcc->dev->dev_data;
 
--	struct sk_buff *skb;
 
-+	unsigned char port = SOLOS_CHAN(vcc->dev);
 
-+	struct sk_buff *skb, *tmpskb;
 
- 	struct pkt_hdr *header;
 
- 
--	skb = alloc_skb(sizeof(*header), GFP_ATOMIC);
 
-+	/* Remove any yet-to-be-transmitted packets from the pending queue */
 
-+	spin_lock(&card->tx_queue_lock);
 
-+	skb_queue_walk_safe(&card->tx_queue[port], skb, tmpskb) {
 
-+		if (SKB_CB(skb)->vcc == vcc) {
 
-+			skb_unlink(skb, &card->tx_queue[port]);
 
-+			solos_pop(vcc, skb);
 
-+		}
 
-+	}
 
-+	spin_unlock(&card->tx_queue_lock);
 
-+
 
-+	skb = alloc_skb(sizeof(*header), GFP_KERNEL);
 
- 	if (!skb) {
 
- 		dev_warn(&card->dev->dev, "Failed to allocate sk_buff in pclose()\n");
 
- 		return;
 
-@@ -881,15 +853,21 @@ static void pclose(struct atm_vcc *vcc)
 
- 	header->vci = cpu_to_le16(vcc->vci);
 
- 	header->type = cpu_to_le16(PKT_PCLOSE);
 
- 
--	fpga_queue(card, SOLOS_CHAN(vcc->dev), skb, NULL);
 
-+	init_completion(&SKB_CB(skb)->c);
 
- 
--	clear_bit(ATM_VF_ADDR, &vcc->flags);
 
--	clear_bit(ATM_VF_READY, &vcc->flags);
 
-+	fpga_queue(card, port, skb, NULL);
 
-+
 
-+	if (!wait_for_completion_timeout(&SKB_CB(skb)->c, 5 * HZ))
 
-+		dev_warn(&card->dev->dev, "Timeout waiting for VCC close on port %d\n",
 
-+			 port);
 
- 
- 	/* Hold up vcc_destroy_socket() (our caller) until solos_bh() in the
 
- 	   tasklet has finished processing any incoming packets (and, more to
 
- 	   the point, using the vcc pointer). */
 
- 	tasklet_unlock_wait(&card->tlet);
 
-+
 
-+	clear_bit(ATM_VF_ADDR, &vcc->flags);
 
-+
 
- 	return;
 
- }
 
- 
-@@ -1010,9 +988,12 @@ static uint32_t fpga_tx(struct solos_car
 
- 			if (vcc) {
 
- 				atomic_inc(&vcc->stats->tx);
 
- 				solos_pop(vcc, oldskb);
 
--			} else
 
-+			} else {
 
-+				struct pkt_hdr *header = (void *)oldskb->data;
 
-+				if (le16_to_cpu(header->type) == PKT_PCLOSE)
 
-+					complete(&SKB_CB(oldskb)->c);
 
- 				dev_kfree_skb_irq(oldskb);
 
--
 
-+			}
 
- 		}
 
- 	}
 
- 	/* For non-DMA TX, write the 'TX start' bit for all four ports simultaneously */
 
-@@ -1246,7 +1227,7 @@ static int atm_init(struct solos_card *c
 
- 		card->atmdev[i]->phy_data = (void *)(unsigned long)i;
 
- 		atm_dev_signal_change(card->atmdev[i], ATM_PHY_SIG_FOUND);
 
- 
--		skb = alloc_skb(sizeof(*header), GFP_ATOMIC);
 
-+		skb = alloc_skb(sizeof(*header), GFP_KERNEL);
 
- 		if (!skb) {
 
- 			dev_warn(&card->dev->dev, "Failed to allocate sk_buff in atm_init()\n");
 
- 			continue;
 
-@@ -1343,6 +1324,8 @@ static struct pci_driver fpga_driver = {
 
- 
- static int __init solos_pci_init(void)
 
- {
 
-+	BUILD_BUG_ON(sizeof(struct solos_skb_cb) > sizeof(((struct sk_buff *)0)->cb));
 
-+
 
- 	printk(KERN_INFO "Solos PCI Driver Version %s\n", VERSION);
 
- 	return pci_register_driver(&fpga_driver);
 
- }
 
---- a/include/linux/atmdev.h
 
-+++ b/include/linux/atmdev.h
 
-@@ -307,6 +307,7 @@ struct atm_vcc {
 
- 	struct atm_dev	*dev;		/* device back pointer */
 
- 	struct atm_qos	qos;		/* QOS */
 
- 	struct atm_sap	sap;		/* SAP */
 
-+	void (*release_cb)(struct atm_vcc *vcc); /* release_sock callback */
 
- 	void (*push)(struct atm_vcc *vcc,struct sk_buff *skb);
 
- 	void (*pop)(struct atm_vcc *vcc,struct sk_buff *skb); /* optional */
 
- 	int (*push_oam)(struct atm_vcc *vcc,void *cell);
 
-@@ -314,6 +315,7 @@ struct atm_vcc {
 
- 	void		*dev_data;	/* per-device data */
 
- 	void		*proto_data;	/* per-protocol data */
 
- 	struct k_atm_aal_stats *stats;	/* pointer to AAL stats group */
 
-+	struct module *owner;		/* owner of ->push function */
 
- 	/* SVC part --- may move later ------------------------------------- */
 
- 	short		itf;		/* interface number */
 
- 	struct sockaddr_atmsvc local;
 
---- a/net/atm/br2684.c
 
-+++ b/net/atm/br2684.c
 
-@@ -68,12 +68,15 @@ struct br2684_vcc {
 
- 	/* keep old push, pop functions for chaining */
 
- 	void (*old_push)(struct atm_vcc *vcc, struct sk_buff *skb);
 
- 	void (*old_pop)(struct atm_vcc *vcc, struct sk_buff *skb);
 
-+	void (*old_release_cb)(struct atm_vcc *vcc);
 
-+	struct module *old_owner;
 
- 	enum br2684_encaps encaps;
 
- 	struct list_head brvccs;
 
- #ifdef CONFIG_ATM_BR2684_IPFILTER
 
- 	struct br2684_filter filter;
 
- #endif /* CONFIG_ATM_BR2684_IPFILTER */
 
- 	unsigned copies_needed, copies_failed;
 
-+	atomic_t qspace;
 
- };
 
- 
- struct br2684_dev {
 
-@@ -181,18 +184,15 @@ static struct notifier_block atm_dev_not
 
- static void br2684_pop(struct atm_vcc *vcc, struct sk_buff *skb)
 
- {
 
- 	struct br2684_vcc *brvcc = BR2684_VCC(vcc);
 
--	struct net_device *net_dev = skb->dev;
 
- 
--	pr_debug("(vcc %p ; net_dev %p )\n", vcc, net_dev);
 
-+	pr_debug("(vcc %p ; net_dev %p )\n", vcc, brvcc->device);
 
- 	brvcc->old_pop(vcc, skb);
 
- 
--	if (!net_dev)
 
--		return;
 
--
 
--	if (atm_may_send(vcc, 0))
 
--		netif_wake_queue(net_dev);
 
--
 
-+	/* If the queue space just went up from zero, wake */
 
-+	if (atomic_inc_return(&brvcc->qspace) == 1)
 
-+		netif_wake_queue(brvcc->device);
 
- }
 
-+
 
- /*
 
-  * Send a packet out a particular vcc.  Not to useful right now, but paves
 
-  * the way for multiple vcc's per itf.  Returns true if we can send,
 
-@@ -256,16 +256,30 @@ static int br2684_xmit_vcc(struct sk_buf
 
- 	ATM_SKB(skb)->atm_options = atmvcc->atm_options;
 
- 	dev->stats.tx_packets++;
 
- 	dev->stats.tx_bytes += skb->len;
 
--	atmvcc->send(atmvcc, skb);
 
- 
--	if (!atm_may_send(atmvcc, 0)) {
 
-+	if (atomic_dec_return(&brvcc->qspace) < 1) {
 
-+		/* No more please! */
 
- 		netif_stop_queue(brvcc->device);
 
--		/*check for race with br2684_pop*/
 
--		if (atm_may_send(atmvcc, 0))
 
--			netif_start_queue(brvcc->device);
 
-+		/* We might have raced with br2684_pop() */
 
-+		if (unlikely(atomic_read(&brvcc->qspace) > 0))
 
-+			netif_wake_queue(brvcc->device);
 
- 	}
 
- 
--	return 1;
 
-+	/* If this fails immediately, the skb will be freed and br2684_pop()
 
-+	   will wake the queue if appropriate. Just return an error so that
 
-+	   the stats are updated correctly */
 
-+	return !atmvcc->send(atmvcc, skb);
 
-+}
 
-+
 
-+static void br2684_release_cb(struct atm_vcc *atmvcc)
 
-+{
 
-+	struct br2684_vcc *brvcc = BR2684_VCC(atmvcc);
 
-+
 
-+	if (atomic_read(&brvcc->qspace) > 0)
 
-+		netif_wake_queue(brvcc->device);
 
-+
 
-+	if (brvcc->old_release_cb)
 
-+		brvcc->old_release_cb(atmvcc);
 
- }
 
- 
- static inline struct br2684_vcc *pick_outgoing_vcc(const struct sk_buff *skb,
 
-@@ -279,6 +293,8 @@ static netdev_tx_t br2684_start_xmit(str
 
- {
 
- 	struct br2684_dev *brdev = BRPRIV(dev);
 
- 	struct br2684_vcc *brvcc;
 
-+	struct atm_vcc *atmvcc;
 
-+	netdev_tx_t ret = NETDEV_TX_OK;
 
- 
- 	pr_debug("skb_dst(skb)=%p\n", skb_dst(skb));
 
- 	read_lock(&devs_lock);
 
-@@ -289,9 +305,26 @@ static netdev_tx_t br2684_start_xmit(str
 
- 		dev->stats.tx_carrier_errors++;
 
- 		/* netif_stop_queue(dev); */
 
- 		dev_kfree_skb(skb);
 
--		read_unlock(&devs_lock);
 
--		return NETDEV_TX_OK;
 
-+		goto out_devs;
 
- 	}
 
-+	atmvcc = brvcc->atmvcc;
 
-+
 
-+	bh_lock_sock(sk_atm(atmvcc));
 
-+
 
-+	if (test_bit(ATM_VF_RELEASED, &atmvcc->flags) ||
 
-+	    test_bit(ATM_VF_CLOSE, &atmvcc->flags) ||
 
-+	    !test_bit(ATM_VF_READY, &atmvcc->flags)) {
 
-+		dev->stats.tx_dropped++;
 
-+		dev_kfree_skb(skb);
 
-+		goto out;
 
-+	}
 
-+
 
-+	if (sock_owned_by_user(sk_atm(atmvcc))) {
 
-+		netif_stop_queue(brvcc->device);
 
-+		ret = NETDEV_TX_BUSY;
 
-+		goto out;
 
-+	}
 
-+
 
- 	if (!br2684_xmit_vcc(skb, dev, brvcc)) {
 
- 		/*
 
- 		 * We should probably use netif_*_queue() here, but that
 
-@@ -303,8 +336,11 @@ static netdev_tx_t br2684_start_xmit(str
 
- 		dev->stats.tx_errors++;
 
- 		dev->stats.tx_fifo_errors++;
 
- 	}
 
-+ out:
 
-+	bh_unlock_sock(sk_atm(atmvcc));
 
-+ out_devs:
 
- 	read_unlock(&devs_lock);
 
--	return NETDEV_TX_OK;
 
-+	return ret;
 
- }
 
- 
- /*
 
-@@ -377,9 +413,10 @@ static void br2684_close_vcc(struct br26
 
- 	list_del(&brvcc->brvccs);
 
- 	write_unlock_irq(&devs_lock);
 
- 	brvcc->atmvcc->user_back = NULL;	/* what about vcc->recvq ??? */
 
-+	brvcc->atmvcc->release_cb = brvcc->old_release_cb;
 
- 	brvcc->old_push(brvcc->atmvcc, NULL);	/* pass on the bad news */
 
-+	module_put(brvcc->old_owner);
 
- 	kfree(brvcc);
 
--	module_put(THIS_MODULE);
 
- }
 
- 
- /* when AAL5 PDU comes in: */
 
-@@ -504,6 +541,13 @@ static int br2684_regvcc(struct atm_vcc
 
- 	brvcc = kzalloc(sizeof(struct br2684_vcc), GFP_KERNEL);
 
- 	if (!brvcc)
 
- 		return -ENOMEM;
 
-+	/*
 
-+	 * Allow two packets in the ATM queue. One actually being sent, and one
 
-+	 * for the ATM 'TX done' handler to send. It shouldn't take long to get
 
-+	 * the next one from the netdev queue, when we need it. More than that
 
-+	 * would be bufferbloat.
 
-+	 */
 
-+	atomic_set(&brvcc->qspace, 2);
 
- 	write_lock_irq(&devs_lock);
 
- 	net_dev = br2684_find_dev(&be.ifspec);
 
- 	if (net_dev == NULL) {
 
-@@ -546,9 +590,13 @@ static int br2684_regvcc(struct atm_vcc
 
- 	brvcc->encaps = (enum br2684_encaps)be.encaps;
 
- 	brvcc->old_push = atmvcc->push;
 
- 	brvcc->old_pop = atmvcc->pop;
 
-+	brvcc->old_release_cb = atmvcc->release_cb;
 
-+	brvcc->old_owner = atmvcc->owner;
 
- 	barrier();
 
- 	atmvcc->push = br2684_push;
 
- 	atmvcc->pop = br2684_pop;
 
-+	atmvcc->release_cb = br2684_release_cb;
 
-+	atmvcc->owner = THIS_MODULE;
 
- 
- 	/* initialize netdev carrier state */
 
- 	if (atmvcc->dev->signal == ATM_PHY_SIG_LOST)
 
-@@ -687,10 +735,13 @@ static int br2684_ioctl(struct socket *s
 
- 			return -ENOIOCTLCMD;
 
- 		if (!capable(CAP_NET_ADMIN))
 
- 			return -EPERM;
 
--		if (cmd == ATM_SETBACKEND)
 
-+		if (cmd == ATM_SETBACKEND) {
 
-+			if (sock->state != SS_CONNECTED)
 
-+				return -EINVAL;
 
- 			return br2684_regvcc(atmvcc, argp);
 
--		else
 
-+		} else {
 
- 			return br2684_create(argp);
 
-+		}
 
- #ifdef CONFIG_ATM_BR2684_IPFILTER
 
- 	case BR2684_SETFILT:
 
- 		if (atmvcc->push != br2684_push)
 
---- a/net/atm/common.c
 
-+++ b/net/atm/common.c
 
-@@ -126,10 +126,19 @@ static void vcc_write_space(struct sock
 
- 	rcu_read_unlock();
 
- }
 
- 
-+static void vcc_release_cb(struct sock *sk)
 
-+{
 
-+	struct atm_vcc *vcc = atm_sk(sk);
 
-+
 
-+	if (vcc->release_cb)
 
-+		vcc->release_cb(vcc);
 
-+}
 
-+
 
- static struct proto vcc_proto = {
 
- 	.name	  = "VCC",
 
- 	.owner	  = THIS_MODULE,
 
- 	.obj_size = sizeof(struct atm_vcc),
 
-+	.release_cb = vcc_release_cb,
 
- };
 
- 
- int vcc_create(struct net *net, struct socket *sock, int protocol, int family)
 
-@@ -156,7 +165,9 @@ int vcc_create(struct net *net, struct s
 
- 	atomic_set(&sk->sk_rmem_alloc, 0);
 
- 	vcc->push = NULL;
 
- 	vcc->pop = NULL;
 
-+	vcc->owner = NULL;
 
- 	vcc->push_oam = NULL;
 
-+	vcc->release_cb = NULL;
 
- 	vcc->vpi = vcc->vci = 0; /* no VCI/VPI yet */
 
- 	vcc->atm_options = vcc->aal_options = 0;
 
- 	sk->sk_destruct = vcc_sock_destruct;
 
-@@ -175,6 +186,7 @@ static void vcc_destroy_socket(struct so
 
- 			vcc->dev->ops->close(vcc);
 
- 		if (vcc->push)
 
- 			vcc->push(vcc, NULL); /* atmarpd has no push */
 
-+		module_put(vcc->owner);
 
- 
- 		while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
 
- 			atm_return(vcc, skb->truesize);
 
---- a/net/atm/pppoatm.c
 
-+++ b/net/atm/pppoatm.c
 
-@@ -60,6 +60,8 @@ struct pppoatm_vcc {
 
- 	struct atm_vcc	*atmvcc;	/* VCC descriptor */
 
- 	void (*old_push)(struct atm_vcc *, struct sk_buff *);
 
- 	void (*old_pop)(struct atm_vcc *, struct sk_buff *);
 
-+	void (*old_release_cb)(struct atm_vcc *);
 
-+	struct module *old_owner;
 
- 					/* keep old push/pop for detaching */
 
- 	enum pppoatm_encaps encaps;
 
- 	atomic_t inflight;
 
-@@ -107,6 +109,24 @@ static void pppoatm_wakeup_sender(unsign
 
- 	ppp_output_wakeup((struct ppp_channel *) arg);
 
- }
 
- 
-+static void pppoatm_release_cb(struct atm_vcc *atmvcc)
 
-+{
 
-+	struct pppoatm_vcc *pvcc = atmvcc_to_pvcc(atmvcc);
 
-+
 
-+	/*
 
-+	 * As in pppoatm_pop(), it's safe to clear the BLOCKED bit here because
 
-+	 * the wakeup *can't* race with pppoatm_send(). They both hold the PPP
 
-+	 * channel's ->downl lock. And the potential race with *setting* it,
 
-+	 * which leads to the double-check dance in pppoatm_may_send(), doesn't
 
-+	 * exist here. In the sock_owned_by_user() case in pppoatm_send(), we
 
-+	 * set the BLOCKED bit while the socket is still locked. We know that
 
-+	 * ->release_cb() can't be called until that's done.
 
-+	 */
 
-+	if (test_and_clear_bit(BLOCKED, &pvcc->blocked))
 
-+		tasklet_schedule(&pvcc->wakeup_tasklet);
 
-+	if (pvcc->old_release_cb)
 
-+		pvcc->old_release_cb(atmvcc);
 
-+}
 
- /*
 
-  * This gets called every time the ATM card has finished sending our
 
-  * skb.  The ->old_pop will take care up normal atm flow control,
 
-@@ -151,12 +171,11 @@ static void pppoatm_unassign_vcc(struct
 
- 	pvcc = atmvcc_to_pvcc(atmvcc);
 
- 	atmvcc->push = pvcc->old_push;
 
- 	atmvcc->pop = pvcc->old_pop;
 
-+	atmvcc->release_cb = pvcc->old_release_cb;
 
- 	tasklet_kill(&pvcc->wakeup_tasklet);
 
- 	ppp_unregister_channel(&pvcc->chan);
 
- 	atmvcc->user_back = NULL;
 
- 	kfree(pvcc);
 
--	/* Gee, I hope we have the big kernel lock here... */
 
--	module_put(THIS_MODULE);
 
- }
 
- 
- /* Called when an AAL5 PDU comes in */
 
-@@ -165,9 +184,13 @@ static void pppoatm_push(struct atm_vcc
 
- 	struct pppoatm_vcc *pvcc = atmvcc_to_pvcc(atmvcc);
 
- 	pr_debug("\n");
 
- 	if (skb == NULL) {			/* VCC was closed */
 
-+		struct module *module;
 
-+
 
- 		pr_debug("removing ATMPPP VCC %p\n", pvcc);
 
-+		module = pvcc->old_owner;
 
- 		pppoatm_unassign_vcc(atmvcc);
 
- 		atmvcc->push(atmvcc, NULL);	/* Pass along bad news */
 
-+		module_put(module);
 
- 		return;
 
- 	}
 
- 	atm_return(atmvcc, skb->truesize);
 
-@@ -211,7 +234,7 @@ error:
 
- 	ppp_input_error(&pvcc->chan, 0);
 
- }
 
- 
--static inline int pppoatm_may_send(struct pppoatm_vcc *pvcc, int size)
 
-+static int pppoatm_may_send(struct pppoatm_vcc *pvcc, int size)
 
- {
 
- 	/*
 
- 	 * It's not clear that we need to bother with using atm_may_send()
 
-@@ -269,10 +292,33 @@ static inline int pppoatm_may_send(struc
 
- static int pppoatm_send(struct ppp_channel *chan, struct sk_buff *skb)
 
- {
 
- 	struct pppoatm_vcc *pvcc = chan_to_pvcc(chan);
 
-+	struct atm_vcc *vcc;
 
-+	int ret;
 
-+
 
- 	ATM_SKB(skb)->vcc = pvcc->atmvcc;
 
- 	pr_debug("(skb=0x%p, vcc=0x%p)\n", skb, pvcc->atmvcc);
 
- 	if (skb->data[0] == '\0' && (pvcc->flags & SC_COMP_PROT))
 
- 		(void) skb_pull(skb, 1);
 
-+
 
-+	vcc = ATM_SKB(skb)->vcc;
 
-+	bh_lock_sock(sk_atm(vcc));
 
-+	if (sock_owned_by_user(sk_atm(vcc))) {
 
-+		/*
 
-+		 * Needs to happen (and be flushed, hence test_and_) before we unlock
 
-+		 * the socket. It needs to be seen by the time our ->release_cb gets
 
-+		 * called.
 
-+		 */
 
-+		test_and_set_bit(BLOCKED, &pvcc->blocked);
 
-+		goto nospace;
 
-+	}
 
-+	if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
 
-+	    test_bit(ATM_VF_CLOSE, &vcc->flags) ||
 
-+	    !test_bit(ATM_VF_READY, &vcc->flags)) {
 
-+		bh_unlock_sock(sk_atm(vcc));
 
-+		kfree_skb(skb);
 
-+		return DROP_PACKET;
 
-+	}
 
-+
 
- 	switch (pvcc->encaps) {		/* LLC encapsulation needed */
 
- 	case e_llc:
 
- 		if (skb_headroom(skb) < LLC_LEN) {
 
-@@ -285,8 +331,10 @@ static int pppoatm_send(struct ppp_chann
 
- 			}
 
- 			kfree_skb(skb);
 
- 			skb = n;
 
--			if (skb == NULL)
 
-+			if (skb == NULL) {
 
-+				bh_unlock_sock(sk_atm(vcc));
 
- 				return DROP_PACKET;
 
-+			}
 
- 		} else if (!pppoatm_may_send(pvcc, skb->truesize))
 
- 			goto nospace;
 
- 		memcpy(skb_push(skb, LLC_LEN), pppllc, LLC_LEN);
 
-@@ -296,6 +344,7 @@ static int pppoatm_send(struct ppp_chann
 
- 			goto nospace;
 
- 		break;
 
- 	case e_autodetect:
 
-+		bh_unlock_sock(sk_atm(vcc));
 
- 		pr_debug("Trying to send without setting encaps!\n");
 
- 		kfree_skb(skb);
 
- 		return 1;
 
-@@ -305,9 +354,12 @@ static int pppoatm_send(struct ppp_chann
 
- 	ATM_SKB(skb)->atm_options = ATM_SKB(skb)->vcc->atm_options;
 
- 	pr_debug("atm_skb(%p)->vcc(%p)->dev(%p)\n",
 
- 		 skb, ATM_SKB(skb)->vcc, ATM_SKB(skb)->vcc->dev);
 
--	return ATM_SKB(skb)->vcc->send(ATM_SKB(skb)->vcc, skb)
 
-+	ret = ATM_SKB(skb)->vcc->send(ATM_SKB(skb)->vcc, skb)
 
- 	    ? DROP_PACKET : 1;
 
-+	bh_unlock_sock(sk_atm(vcc));
 
-+	return ret;
 
- nospace:
 
-+	bh_unlock_sock(sk_atm(vcc));
 
- 	/*
 
- 	 * We don't have space to send this SKB now, but we might have
 
- 	 * already applied SC_COMP_PROT compression, so may need to undo
 
-@@ -362,6 +414,8 @@ static int pppoatm_assign_vcc(struct atm
 
- 	atomic_set(&pvcc->inflight, NONE_INFLIGHT);
 
- 	pvcc->old_push = atmvcc->push;
 
- 	pvcc->old_pop = atmvcc->pop;
 
-+	pvcc->old_owner = atmvcc->owner;
 
-+	pvcc->old_release_cb = atmvcc->release_cb;
 
- 	pvcc->encaps = (enum pppoatm_encaps) be.encaps;
 
- 	pvcc->chan.private = pvcc;
 
- 	pvcc->chan.ops = &pppoatm_ops;
 
-@@ -377,7 +431,9 @@ static int pppoatm_assign_vcc(struct atm
 
- 	atmvcc->user_back = pvcc;
 
- 	atmvcc->push = pppoatm_push;
 
- 	atmvcc->pop = pppoatm_pop;
 
-+	atmvcc->release_cb = pppoatm_release_cb;
 
- 	__module_get(THIS_MODULE);
 
-+	atmvcc->owner = THIS_MODULE;
 
- 
- 	/* re-process everything received between connection setup and
 
- 	   backend setup */
 
-@@ -406,6 +462,8 @@ static int pppoatm_ioctl(struct socket *
 
- 			return -ENOIOCTLCMD;
 
- 		if (!capable(CAP_NET_ADMIN))
 
- 			return -EPERM;
 
-+		if (sock->state != SS_CONNECTED)
 
-+			return -EINVAL;
 
- 		return pppoatm_assign_vcc(atmvcc, argp);
 
- 		}
 
- 	case PPPIOCGCHAN:

+ 0 - 442
target/linux/generic/patches-3.3/132-solos-dma.patch
View File 

@@ -1,442 +0,0 @@
 
-commit b4bd8ad9bb311e8536f726f7a633620ccd358cde
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Thu May 24 04:58:27 2012 +0000
 
-
 
-    solos-pci: Fix DMA support
 
-    
-    DMA support has finally made its way to the top of the TODO list, having
 
-    realised that a Geode using MMIO can't keep up with two ADSL2+ lines
 
-    each running at 21Mb/s.
 
-    
-    This patch fixes a couple of bugs in the DMA support in the driver, so
 
-    once the corresponding FPGA update is complete and tested everything
 
-    should work properly.
 
-    
-    We weren't storing the currently-transmitting skb, so we were never
 
-    unmapping it and never freeing/popping it when the TX was done.
 
-    And the addition of pci_set_master() is fairly self-explanatory.
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Cc: [email protected]
 
-    Signed-off-by: David S. Miller <[email protected]>
 
-
 
-commit 152a2a8b5e1d4cbe91a7c66f1028db15164a3766
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Wed Dec 19 11:01:21 2012 +0000
 
-
 
-    solos-pci: ensure all TX packets are aligned to 4 bytes
 
-    
-    The FPGA can't handled unaligned DMA (yet). So copy into an aligned buffer,
 
-    if skb->data isn't suitably aligned.
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Signed-off-by: David S. Miller <[email protected]>
 
-
 
-commit 13af816469db3449c072afbae6c4c1bd9ccecccb
 
-Author: Nathan Williams <[email protected]>
 
-Date:   Wed Dec 19 11:01:20 2012 +0000
 
-
 
-    solos-pci: add firmware upgrade support for new models
 
-    
-    Signed-off-by: Nathan Williams <[email protected]>
 
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Signed-off-by: David S. Miller <[email protected]>
 
-
 
-commit 7fbdadb5e951e4f0c0fc991ff5f50295568786e6
 
-Author: Nathan Williams <[email protected]>
 
-Date:   Wed Dec 19 11:01:19 2012 +0000
 
-
 
-    solos-pci: remove superfluous debug output
 
-    
-    Signed-off-by: Nathan Williams <[email protected]>
 
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Signed-off-by: David S. Miller <[email protected]>
 
-
 
-commit f9baad02e7411d9f38d5ebe1a1cdcde4ceec100d
 
-Author: Nathan Williams <[email protected]>
 
-Date:   Wed Dec 19 11:01:18 2012 +0000
 
-
 
-    solos-pci: add GPIO support for newer versions on Geos board
 
-    
-    dwmw2: Tidy up a little, simpler matching on which GPIO is being accessed,
 
-           only register on newer boards, register under PCI device instead of
 
-           duplicating them under each ATM device.
 
-    
-    Signed-off-by: Nathan Williams <[email protected]>
 
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Signed-off-by: David S. Miller <[email protected]>
 
-
 
-commit cae49ede00ec3d0cda290b03fee55b72b49efc11
 
-Author: David Woodhouse <[email protected]>
 
-Date:   Tue Dec 11 14:57:14 2012 +0000
 
-
 
-    solos-pci: fix double-free of TX skb in DMA mode
 
-    
-    We weren't clearing card->tx_skb[port] when processing the TX done interrupt.
 
-    If there wasn't another skb ready to transmit immediately, this led to a
 
-    double-free because we'd free it *again* next time we did have a packet to
 
-    send.
 
-    
-    Signed-off-by: David Woodhouse <[email protected]>
 
-    Cc: [email protected]
 
-    Signed-off-by: David S. Miller <[email protected]>
 
-
 
-==
 
-There is a typo here so we do a double lock instead of an unlock.
 
-
 
-Signed-off-by: Dan Carpenter <[email protected]>
 
----
 
-Only needed in linux-next.  Introduced in f9baad02e7411d9 [14/17]
 
-solos-pci: add GPIO support for newer versions on Geos board
 
-
 
-
 
---- a/drivers/atm/solos-pci.c
 
-+++ b/drivers/atm/solos-pci.c
 
-@@ -42,7 +42,8 @@
 
- #include <linux/swab.h>
 
- #include <linux/slab.h>
 
- 
--#define VERSION "0.07"
 
-+#define VERSION "1.04"
 
-+#define DRIVER_VERSION 0x01
 
- #define PTAG "solos-pci"
 
- 
- #define CONFIG_RAM_SIZE	128
 
-@@ -56,16 +57,21 @@
 
- #define FLASH_BUSY	0x60
 
- #define FPGA_MODE	0x5C
 
- #define FLASH_MODE	0x58
 
-+#define GPIO_STATUS	0x54
 
-+#define DRIVER_VER	0x50
 
- #define TX_DMA_ADDR(port)	(0x40 + (4 * (port)))
 
- #define RX_DMA_ADDR(port)	(0x30 + (4 * (port)))
 
- 
- #define DATA_RAM_SIZE	32768
 
- #define BUF_SIZE	2048
 
- #define OLD_BUF_SIZE	4096 /* For FPGA versions <= 2*/
 
--#define FPGA_PAGE	528 /* FPGA flash page size*/
 
--#define SOLOS_PAGE	512 /* Solos flash page size*/
 
--#define FPGA_BLOCK	(FPGA_PAGE * 8) /* FPGA flash block size*/
 
--#define SOLOS_BLOCK	(SOLOS_PAGE * 8) /* Solos flash block size*/
 
-+/* Old boards use ATMEL AD45DB161D flash */
 
-+#define ATMEL_FPGA_PAGE	528 /* FPGA flash page size*/
 
-+#define ATMEL_SOLOS_PAGE	512 /* Solos flash page size*/
 
-+#define ATMEL_FPGA_BLOCK	(ATMEL_FPGA_PAGE * 8) /* FPGA block size*/
 
-+#define ATMEL_SOLOS_BLOCK	(ATMEL_SOLOS_PAGE * 8) /* Solos block size*/
 
-+/* Current boards use M25P/M25PE SPI flash */
 
-+#define SPI_FLASH_BLOCK	(256 * 64)
 
- 
- #define RX_BUF(card, nr) ((card->buffers) + (nr)*(card->buffer_size)*2)
 
- #define TX_BUF(card, nr) ((card->buffers) + (nr)*(card->buffer_size)*2 + (card->buffer_size))
 
-@@ -123,11 +129,14 @@ struct solos_card {
 
- 	struct sk_buff_head cli_queue[4];
 
- 	struct sk_buff *tx_skb[4];
 
- 	struct sk_buff *rx_skb[4];
 
-+	unsigned char *dma_bounce;
 
- 	wait_queue_head_t param_wq;
 
- 	wait_queue_head_t fw_wq;
 
- 	int using_dma;
 
-+	int dma_alignment;
 
- 	int fpga_version;
 
- 	int buffer_size;
 
-+	int atmel_flash;
 
- };
 
- 
- 
-@@ -452,7 +461,6 @@ static ssize_t console_show(struct devic
 
- 
- 	len = skb->len;
 
- 	memcpy(buf, skb->data, len);
 
--	dev_dbg(&card->dev->dev, "len: %d\n", len);
 
- 
- 	kfree_skb(skb);
 
- 	return len;
 
-@@ -499,6 +507,78 @@ static ssize_t console_store(struct devi
 
- 	return err?:count;
 
- }
 
- 
-+struct geos_gpio_attr {
 
-+	struct device_attribute attr;
 
-+	int offset;
 
-+};
 
-+
 
-+#define SOLOS_GPIO_ATTR(_name, _mode, _show, _store, _offset)	\
 
-+	struct geos_gpio_attr gpio_attr_##_name = {		\
 
-+		.attr = __ATTR(_name, _mode, _show, _store),	\
 
-+		.offset = _offset }
 
-+
 
-+static ssize_t geos_gpio_store(struct device *dev, struct device_attribute *attr,
 
-+			       const char *buf, size_t count)
 
-+{
 
-+	struct pci_dev *pdev = container_of(dev, struct pci_dev, dev);
 
-+	struct geos_gpio_attr *gattr = container_of(attr, struct geos_gpio_attr, attr);
 
-+	struct solos_card *card = pci_get_drvdata(pdev);
 
-+	uint32_t data32;
 
-+
 
-+	if (count != 1 && (count != 2 || buf[1] != '\n'))
 
-+		return -EINVAL;
 
-+
 
-+	spin_lock_irq(&card->param_queue_lock);
 
-+	data32 = ioread32(card->config_regs + GPIO_STATUS);
 
-+	if (buf[0] == '1') {
 
-+		data32 |= 1 << gattr->offset;
 
-+		iowrite32(data32, card->config_regs + GPIO_STATUS);
 
-+	} else if (buf[0] == '0') {
 
-+		data32 &= ~(1 << gattr->offset);
 
-+		iowrite32(data32, card->config_regs + GPIO_STATUS);
 
-+	} else {
 
-+		count = -EINVAL;
 
-+	}
 
-+	spin_unlock_irq(&card->param_queue_lock);
 
-+	return count;
 
-+}
 
-+
 
-+static ssize_t geos_gpio_show(struct device *dev, struct device_attribute *attr,
 
-+			      char *buf)
 
-+{
 
-+	struct pci_dev *pdev = container_of(dev, struct pci_dev, dev);
 
-+	struct geos_gpio_attr *gattr = container_of(attr, struct geos_gpio_attr, attr);
 
-+	struct solos_card *card = pci_get_drvdata(pdev);
 
-+	uint32_t data32;
 
-+
 
-+	data32 = ioread32(card->config_regs + GPIO_STATUS);
 
-+	data32 = (data32 >> gattr->offset) & 1;
 
-+
 
-+	return sprintf(buf, "%d\n", data32);
 
-+}
 
-+
 
-+static ssize_t hardware_show(struct device *dev, struct device_attribute *attr,
 
-+			     char *buf)
 
-+{
 
-+	struct pci_dev *pdev = container_of(dev, struct pci_dev, dev);
 
-+	struct geos_gpio_attr *gattr = container_of(attr, struct geos_gpio_attr, attr);
 
-+	struct solos_card *card = pci_get_drvdata(pdev);
 
-+	uint32_t data32;
 
-+
 
-+	data32 = ioread32(card->config_regs + GPIO_STATUS);
 
-+	switch (gattr->offset) {
 
-+	case 0:
 
-+		/* HardwareVersion */
 
-+		data32 = data32 & 0x1F;
 
-+		break;
 
-+	case 1:
 
-+		/* HardwareVariant */
 
-+		data32 = (data32 >> 5) & 0x0F;
 
-+		break;
 
-+	}
 
-+	return sprintf(buf, "%d\n", data32);
 
-+}
 
-+
 
- static DEVICE_ATTR(console, 0644, console_show, console_store);
 
- 
- 
-@@ -507,6 +587,14 @@ static DEVICE_ATTR(console, 0644, consol
 
- 
- #include "solos-attrlist.c"
 
- 
-+static SOLOS_GPIO_ATTR(GPIO1, 0644, geos_gpio_show, geos_gpio_store, 9);
 
-+static SOLOS_GPIO_ATTR(GPIO2, 0644, geos_gpio_show, geos_gpio_store, 10);
 
-+static SOLOS_GPIO_ATTR(GPIO3, 0644, geos_gpio_show, geos_gpio_store, 11);
 
-+static SOLOS_GPIO_ATTR(GPIO4, 0644, geos_gpio_show, geos_gpio_store, 12);
 
-+static SOLOS_GPIO_ATTR(GPIO5, 0644, geos_gpio_show, geos_gpio_store, 13);
 
-+static SOLOS_GPIO_ATTR(PushButton, 0444, geos_gpio_show, NULL, 14);
 
-+static SOLOS_GPIO_ATTR(HardwareVersion, 0444, hardware_show, NULL, 0);
 
-+static SOLOS_GPIO_ATTR(HardwareVariant, 0444, hardware_show, NULL, 1);
 
- #undef SOLOS_ATTR_RO
 
- #undef SOLOS_ATTR_RW
 
- 
-@@ -523,6 +611,23 @@ static struct attribute_group solos_attr
 
- 	.name = "parameters",
 
- };
 
- 
-+static struct attribute *gpio_attrs[] = {
 
-+	&gpio_attr_GPIO1.attr.attr,
 
-+	&gpio_attr_GPIO2.attr.attr,
 
-+	&gpio_attr_GPIO3.attr.attr,
 
-+	&gpio_attr_GPIO4.attr.attr,
 
-+	&gpio_attr_GPIO5.attr.attr,
 
-+	&gpio_attr_PushButton.attr.attr,
 
-+	&gpio_attr_HardwareVersion.attr.attr,
 
-+	&gpio_attr_HardwareVariant.attr.attr,
 
-+	NULL
 
-+};
 
-+
 
-+static struct attribute_group gpio_attr_group = {
 
-+	.attrs = gpio_attrs,
 
-+	.name = "gpio",
 
-+};
 
-+
 
- static int flash_upgrade(struct solos_card *card, int chip)
 
- {
 
- 	const struct firmware *fw;
 
-@@ -534,16 +639,25 @@ static int flash_upgrade(struct solos_ca
 
- 	switch (chip) {
 
- 	case 0:
 
- 		fw_name = "solos-FPGA.bin";
 
--		blocksize = FPGA_BLOCK;
 
-+		if (card->atmel_flash)
 
-+			blocksize = ATMEL_FPGA_BLOCK;
 
-+		else
 
-+			blocksize = SPI_FLASH_BLOCK;
 
- 		break;
 
- 	case 1:
 
- 		fw_name = "solos-Firmware.bin";
 
--		blocksize = SOLOS_BLOCK;
 
-+		if (card->atmel_flash)
 
-+			blocksize = ATMEL_SOLOS_BLOCK;
 
-+		else
 
-+			blocksize = SPI_FLASH_BLOCK;
 
- 		break;
 
- 	case 2:
 
- 		if (card->fpga_version > LEGACY_BUFFERS){
 
- 			fw_name = "solos-db-FPGA.bin";
 
--			blocksize = FPGA_BLOCK;
 
-+			if (card->atmel_flash)
 
-+				blocksize = ATMEL_FPGA_BLOCK;
 
-+			else
 
-+				blocksize = SPI_FLASH_BLOCK;
 
- 		} else {
 
- 			dev_info(&card->dev->dev, "FPGA version doesn't support"
 
- 					" daughter board upgrades\n");
 
-@@ -553,7 +667,10 @@ static int flash_upgrade(struct solos_ca
 
- 	case 3:
 
- 		if (card->fpga_version > LEGACY_BUFFERS){
 
- 			fw_name = "solos-Firmware.bin";
 
--			blocksize = SOLOS_BLOCK;
 
-+			if (card->atmel_flash)
 
-+				blocksize = ATMEL_SOLOS_BLOCK;
 
-+			else
 
-+				blocksize = SPI_FLASH_BLOCK;
 
- 		} else {
 
- 			dev_info(&card->dev->dev, "FPGA version doesn't support"
 
- 					" daughter board upgrades\n");
 
-@@ -569,6 +686,9 @@ static int flash_upgrade(struct solos_ca
 
- 
- 	dev_info(&card->dev->dev, "Flash upgrade starting\n");
 
- 
-+	/* New FPGAs require driver version before permitting flash upgrades */
 
-+	iowrite32(DRIVER_VERSION, card->config_regs + DRIVER_VER);
 
-+
 
- 	numblocks = fw->size / blocksize;
 
- 	dev_info(&card->dev->dev, "Firmware size: %zd\n", fw->size);
 
- 	dev_info(&card->dev->dev, "Number of blocks: %d\n", numblocks);
 
-@@ -598,9 +718,13 @@ static int flash_upgrade(struct solos_ca
 
- 		/* dev_info(&card->dev->dev, "Set FPGA Flash mode to Block Write\n"); */
 
- 		iowrite32(((chip * 2) + 1), card->config_regs + FLASH_MODE);
 
- 
--		/* Copy block to buffer, swapping each 16 bits */
 
-+		/* Copy block to buffer, swapping each 16 bits for Atmel flash */
 
- 		for(i = 0; i < blocksize; i += 4) {
 
--			uint32_t word = swahb32p((uint32_t *)(fw->data + offset + i));
 
-+			uint32_t word;
 
-+			if (card->atmel_flash)
 
-+				word = swahb32p((uint32_t *)(fw->data + offset + i));
 
-+			else
 
-+				word = *(uint32_t *)(fw->data + offset + i);
 
- 			if(card->fpga_version > LEGACY_BUFFERS)
 
- 				iowrite32(word, FLASH_BUF + i);
 
- 			else
 
-@@ -945,10 +1069,11 @@ static uint32_t fpga_tx(struct solos_car
 
- 	for (port = 0; tx_pending; tx_pending >>= 1, port++) {
 
- 		if (tx_pending & 1) {
 
- 			struct sk_buff *oldskb = card->tx_skb[port];
 
--			if (oldskb)
 
-+			if (oldskb) {
 
- 				pci_unmap_single(card->dev, SKB_CB(oldskb)->dma_addr,
 
- 						 oldskb->len, PCI_DMA_TODEVICE);
 
--
 
-+				card->tx_skb[port] = NULL;
 
-+			}
 
- 			spin_lock(&card->tx_queue_lock);
 
- 			skb = skb_dequeue(&card->tx_queue[port]);
 
- 			if (!skb)
 
-@@ -960,8 +1085,14 @@ static uint32_t fpga_tx(struct solos_car
 
- 				tx_started |= 1 << port;
 
- 				oldskb = skb; /* We're done with this skb already */
 
- 			} else if (skb && card->using_dma) {
 
--				SKB_CB(skb)->dma_addr = pci_map_single(card->dev, skb->data,
 
-+				unsigned char *data = skb->data;
 
-+				if ((unsigned long)data & card->dma_alignment) {
 
-+					data = card->dma_bounce + (BUF_SIZE * port);
 
-+					memcpy(data, skb->data, skb->len);
 
-+				}
 
-+				SKB_CB(skb)->dma_addr = pci_map_single(card->dev, data,
 
- 								       skb->len, PCI_DMA_TODEVICE);
 
-+				card->tx_skb[port] = skb;
 
- 				iowrite32(SKB_CB(skb)->dma_addr,
 
- 					  card->config_regs + TX_DMA_ADDR(port));
 
- 			}
 
-@@ -1133,17 +1264,33 @@ static int fpga_probe(struct pci_dev *de
 
- 		db_fpga_upgrade = db_firmware_upgrade = 0;
 
- 	}
 
- 
--	if (card->fpga_version >= DMA_SUPPORTED){
 
-+	/* Stopped using Atmel flash after 0.03-38 */
 
-+	if (fpga_ver < 39)
 
-+		card->atmel_flash = 1;
 
-+	else
 
-+		card->atmel_flash = 0;
 
-+
 
-+	data32 = ioread32(card->config_regs + PORTS);
 
-+	card->nr_ports = (data32 & 0x000000FF);
 
-+
 
-+	if (card->fpga_version >= DMA_SUPPORTED) {
 
-+		pci_set_master(dev);
 
- 		card->using_dma = 1;
 
-+		if (1) { /* All known FPGA versions so far */
 
-+			card->dma_alignment = 3;
 
-+			card->dma_bounce = kmalloc(card->nr_ports * BUF_SIZE, GFP_KERNEL);
 
-+			if (!card->dma_bounce) {
 
-+				dev_warn(&card->dev->dev, "Failed to allocate DMA bounce buffers\n");
 
-+				/* Fallback to MMIO doesn't work */
 
-+				goto out_unmap_both;
 
-+			}
 
-+		}
 
- 	} else {
 
- 		card->using_dma = 0;
 
- 		/* Set RX empty flag for all ports */
 
- 		iowrite32(0xF0, card->config_regs + FLAGS_ADDR);
 
- 	}
 
- 
--	data32 = ioread32(card->config_regs + PORTS);
 
--	card->nr_ports = (data32 & 0x000000FF);
 
--
 
- 	pci_set_drvdata(dev, card);
 
- 
- 	tasklet_init(&card->tlet, solos_bh, (unsigned long)card);
 
-@@ -1178,6 +1325,10 @@ static int fpga_probe(struct pci_dev *de
 
- 	if (err)
 
- 		goto out_free_irq;
 
- 
-+	if (card->fpga_version >= DMA_SUPPORTED &&
 
-+	    sysfs_create_group(&card->dev->dev.kobj, &gpio_attr_group))
 
-+		dev_err(&card->dev->dev, "Could not register parameter group for GPIOs\n");
 
-+
 
- 	return 0;
 
- 
-  out_free_irq:
 
-@@ -1186,6 +1337,7 @@ static int fpga_probe(struct pci_dev *de
 
- 	tasklet_kill(&card->tlet);
 
- 	
-  out_unmap_both:
 
-+	kfree(card->dma_bounce);
 
- 	pci_set_drvdata(dev, NULL);
 
- 	pci_iounmap(dev, card->buffers);
 
-  out_unmap_config:
 
-@@ -1288,11 +1440,16 @@ static void fpga_remove(struct pci_dev *
 
- 	iowrite32(1, card->config_regs + FPGA_MODE);
 
- 	(void)ioread32(card->config_regs + FPGA_MODE); 
- 
-+	if (card->fpga_version >= DMA_SUPPORTED)
 
-+		sysfs_remove_group(&card->dev->dev.kobj, &gpio_attr_group);
 
-+
 
- 	atm_remove(card);
 
- 
- 	free_irq(dev->irq, card);
 
- 	tasklet_kill(&card->tlet);
 
- 
-+	kfree(card->dma_bounce);
 
-+
 
- 	/* Release device from reset */
 
- 	iowrite32(0, card->config_regs + FPGA_MODE);
 
- 	(void)ioread32(card->config_regs + FPGA_MODE);

+ 0 - 39
target/linux/generic/patches-3.3/140-ixp4xx_hss_module_h_include.patch
View File 

@@ -1,39 +0,0 @@
 
-From 32e857cd1fbb006f56a99a2eab998173b1576533 Mon Sep 17 00:00:00 2001
 
-From: Florian Fainelli <[email protected]>
 
-Date: Mon, 10 Sep 2012 10:18:57 +0200
 
-Subject: [PATCH net] ixp4xx_hss: fix build failure after logging conversion
 
-
 
-Commit c75bb2c6f0cf455c23e60f14d780e841dd47f801 (ixp4xx_hss: Update to
 
-current logging forms) converted the ixp4xx_hss module to use the current
 
-logging macros, but forgot to include linux/module.h, leading to the
 
-following build failures:
 
-
 
-  CC [M]  drivers/net/wan/ixp4xx_hss.o
 
- drivers/net/wan/ixp4xx_hss.c:1412:20: error: expected ';', ',' or ')'
 
- before string constant
 
- drivers/net/wan/ixp4xx_hss.c:1413:25: error: expected ';', ',' or ')'
 
- before string constant
 
- drivers/net/wan/ixp4xx_hss.c:1414:21: error: expected ';', ',' or ')'
 
- before string constant
 
- drivers/net/wan/ixp4xx_hss.c:1415:19: error: expected ';', ',' or ')'
 
- before string constant
 
- make[8]: *** [drivers/net/wan/ixp4xx_hss.o] Error 1
 
-
 
-CC: [email protected]
 
-Signed-off-by: Florian Fainelli <[email protected]>
 
----
 
-[stable: 3.1+]
 
-
 
- drivers/net/wan/ixp4xx_hss.c |    1 +
 
- 1 file changed, 1 insertion(+)
 
-
 
---- a/drivers/net/wan/ixp4xx_hss.c
 
-+++ b/drivers/net/wan/ixp4xx_hss.c
 
-@@ -10,6 +10,7 @@
 
- 
- #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
- 
-+#include <linux/module.h>
 
- #include <linux/bitops.h>
 
- #include <linux/cdev.h>
 
- #include <linux/dma-mapping.h>

+ 0 - 11
target/linux/generic/patches-3.3/200-fix_localversion.patch
View File 

@@ -1,11 +0,0 @@
 
---- a/scripts/setlocalversion
 
-+++ b/scripts/setlocalversion
 
-@@ -168,7 +168,7 @@ else
 
- 	# annotated or signed tagged state (as git describe only
 
- 	# looks at signed or annotated tags - git tag -a/-s) and
 
- 	# LOCALVERSION= is not specified
 
--	if test "${LOCALVERSION+set}" != "set"; then
 
-+	if test "${CONFIG_LOCALVERSION+set}" != "set"; then
 
- 		scm=$(scm_version --short)
 
- 		res="$res${scm:++}"
 
- 	fi

+ 0 - 14
target/linux/generic/patches-3.3/201-extra_optimization.patch
View File 

@@ -1,14 +0,0 @@
 
---- a/Makefile
 
-+++ b/Makefile
 
-@@ -559,9 +559,9 @@ endif # $(dot-config)
 
- all: vmlinux
 
- 
- ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE
 
--KBUILD_CFLAGS	+= -Os
 
-+KBUILD_CFLAGS	+= -Os $(EXTRA_OPTIMIZATION)
 
- else
 
--KBUILD_CFLAGS	+= -O2
 
-+KBUILD_CFLAGS	+= -O2 -fno-reorder-blocks -fno-tree-ch $(EXTRA_OPTIMIZATION)
 
- endif
 
- 
- include $(srctree)/arch/$(SRCARCH)/Makefile

+ 0 - 11
target/linux/generic/patches-3.3/202-reduce_module_size.patch
View File 

@@ -1,11 +0,0 @@
 
---- a/Makefile
 
-+++ b/Makefile
 
-@@ -374,7 +374,7 @@ KBUILD_CFLAGS_KERNEL :=
 
- KBUILD_AFLAGS   := -D__ASSEMBLY__
 
- KBUILD_AFLAGS_MODULE  := -DMODULE
 
- KBUILD_CFLAGS_MODULE  := -DMODULE
 
--KBUILD_LDFLAGS_MODULE := -T $(srctree)/scripts/module-common.lds
 
-+KBUILD_LDFLAGS_MODULE = -T $(srctree)/scripts/module-common.lds $(if $(CONFIG_PROFILING),,-s)
 
- 
- # Read KERNELRELEASE from include/config/kernel.release (if it exists)
 
- KERNELRELEASE = $(shell cat include/config/kernel.release 2> /dev/null)

+ 0 - 3088
target/linux/generic/patches-3.3/210-darwin_scripts_include.patch
View File 

@@ -1,3088 +0,0 @@
 
---- a/scripts/kallsyms.c
 
-+++ b/scripts/kallsyms.c
 
-@@ -22,6 +22,35 @@
 
- #include <stdlib.h>
 
- #include <string.h>
 
- #include <ctype.h>
 
-+#ifdef __APPLE__
 
-+/* Darwin has no memmem implementation, this one is ripped of the uClibc-0.9.28 source */
 
-+void *memmem (const void *haystack, size_t haystack_len,
 
-+                          const void *needle,  size_t needle_len)
 
-+{
 
-+  const char *begin;
 
-+  const char *const last_possible
 
-+    = (const char *) haystack + haystack_len - needle_len;
 
-+
 
-+  if (needle_len == 0)
 
-+    /* The first occurrence of the empty string is deemed to occur at
 
-+       the beginning of the string.  */
 
-+    return (void *) haystack;
 
-+
 
-+  /* Sanity check, otherwise the loop might search through the whole
 
-+     memory.  */
 
-+  if (__builtin_expect (haystack_len < needle_len, 0))
 
-+    return NULL;
 
-+
 
-+  for (begin = (const char *) haystack; begin <= last_possible; ++begin)
 
-+    if (begin[0] == ((const char *) needle)[0] &&
 
-+        !memcmp ((const void *) &begin[1],
 
-+                 (const void *) ((const char *) needle + 1),
 
-+                 needle_len - 1))
 
-+      return (void *) begin;
 
-+
 
-+  return NULL;
 
-+}
 
-+#endif
 
- 
- #ifndef ARRAY_SIZE
 
- #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
 
---- a/scripts/kconfig/Makefile
 
-+++ b/scripts/kconfig/Makefile
 
-@@ -123,6 +123,9 @@ check-lxdialog  := $(srctree)/$(src)/lxd
 
- # we really need to do so. (Do not call gcc as part of make mrproper)
 
- HOST_EXTRACFLAGS += $(shell $(CONFIG_SHELL) $(check-lxdialog) -ccflags) \
 
-                     -DLOCALE
 
-+ifeq ($(shell uname -s),Darwin)
 
-+HOST_LOADLIBES  += -lncurses
 
-+endif
 
- 
- # ===========================================================================
 
- # Shared Makefile for the various kconfig executables:
 
---- a/scripts/mod/mk_elfconfig.c
 
-+++ b/scripts/mod/mk_elfconfig.c
 
-@@ -1,7 +1,11 @@
 
- #include <stdio.h>
 
- #include <stdlib.h>
 
- #include <string.h>
 
-+#ifndef __APPLE__
 
- #include <elf.h>
 
-+#else
 
-+#include "elf.h"
 
-+#endif
 
- 
- int
 
- main(int argc, char **argv)
 
---- a/scripts/mod/modpost.h
 
-+++ b/scripts/mod/modpost.h
 
-@@ -7,7 +7,11 @@
 
- #include <sys/mman.h>
 
- #include <fcntl.h>
 
- #include <unistd.h>
 
-+#if !(defined(__APPLE__) || defined(__CYGWIN__))
 
- #include <elf.h>
 
-+#else
 
-+#include "elf.h"
 
-+#endif
 
- 
- #include "elfconfig.h"
 
- 
---- /dev/null
 
-+++ b/scripts/mod/elf.h
 
-@@ -0,0 +1,3007 @@
 
-+/* This file defines standard ELF types, structures, and macros.
 
-+   Copyright (C) 1995-2012 Free Software Foundation, Inc.
 
-+   This file is part of the GNU C Library.
 
-+
 
-+   The GNU C Library is free software; you can redistribute it and/or
 
-+   modify it under the terms of the GNU Lesser General Public
 
-+   License as published by the Free Software Foundation; either
 
-+   version 2.1 of the License, or (at your option) any later version.
 
-+
 
-+   The GNU C Library is distributed in the hope that it will be useful,
 
-+   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
-+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
-+   Lesser General Public License for more details.
 
-+
 
-+   You should have received a copy of the GNU Lesser General Public
 
-+   License along with the GNU C Library; if not, see
 
-+   <http://www.gnu.org/licenses/>.  */
 
-+
 
-+#ifndef _ELF_H
 
-+#define	_ELF_H 1
 
-+
 
-+/* Standard ELF types.  */
 
-+
 
-+#include <stdint.h>
 
-+
 
-+/* Type for a 16-bit quantity.  */
 
-+typedef uint16_t Elf32_Half;
 
-+typedef uint16_t Elf64_Half;
 
-+
 
-+/* Types for signed and unsigned 32-bit quantities.  */
 
-+typedef uint32_t Elf32_Word;
 
-+typedef	int32_t  Elf32_Sword;
 
-+typedef uint32_t Elf64_Word;
 
-+typedef	int32_t  Elf64_Sword;
 
-+
 
-+/* Types for signed and unsigned 64-bit quantities.  */
 
-+typedef uint64_t Elf32_Xword;
 
-+typedef	int64_t  Elf32_Sxword;
 
-+typedef uint64_t Elf64_Xword;
 
-+typedef	int64_t  Elf64_Sxword;
 
-+
 
-+/* Type of addresses.  */
 
-+typedef uint32_t Elf32_Addr;
 
-+typedef uint64_t Elf64_Addr;
 
-+
 
-+/* Type of file offsets.  */
 
-+typedef uint32_t Elf32_Off;
 
-+typedef uint64_t Elf64_Off;
 
-+
 
-+/* Type for section indices, which are 16-bit quantities.  */
 
-+typedef uint16_t Elf32_Section;
 
-+typedef uint16_t Elf64_Section;
 
-+
 
-+/* Type for version symbol information.  */
 
-+typedef Elf32_Half Elf32_Versym;
 
-+typedef Elf64_Half Elf64_Versym;
 
-+
 
-+
 
-+/* The ELF file header.  This appears at the start of every ELF file.  */
 
-+
 
-+#define EI_NIDENT (16)
 
-+
 
-+typedef struct
 
-+{
 
-+  unsigned char	e_ident[EI_NIDENT];	/* Magic number and other info */
 
-+  Elf32_Half	e_type;			/* Object file type */
 
-+  Elf32_Half	e_machine;		/* Architecture */
 
-+  Elf32_Word	e_version;		/* Object file version */
 
-+  Elf32_Addr	e_entry;		/* Entry point virtual address */
 
-+  Elf32_Off	e_phoff;		/* Program header table file offset */
 
-+  Elf32_Off	e_shoff;		/* Section header table file offset */
 
-+  Elf32_Word	e_flags;		/* Processor-specific flags */
 
-+  Elf32_Half	e_ehsize;		/* ELF header size in bytes */
 
-+  Elf32_Half	e_phentsize;		/* Program header table entry size */
 
-+  Elf32_Half	e_phnum;		/* Program header table entry count */
 
-+  Elf32_Half	e_shentsize;		/* Section header table entry size */
 
-+  Elf32_Half	e_shnum;		/* Section header table entry count */
 
-+  Elf32_Half	e_shstrndx;		/* Section header string table index */
 
-+} Elf32_Ehdr;
 
-+
 
-+typedef struct
 
-+{
 
-+  unsigned char	e_ident[EI_NIDENT];	/* Magic number and other info */
 
-+  Elf64_Half	e_type;			/* Object file type */
 
-+  Elf64_Half	e_machine;		/* Architecture */
 
-+  Elf64_Word	e_version;		/* Object file version */
 
-+  Elf64_Addr	e_entry;		/* Entry point virtual address */
 
-+  Elf64_Off	e_phoff;		/* Program header table file offset */
 
-+  Elf64_Off	e_shoff;		/* Section header table file offset */
 
-+  Elf64_Word	e_flags;		/* Processor-specific flags */
 
-+  Elf64_Half	e_ehsize;		/* ELF header size in bytes */
 
-+  Elf64_Half	e_phentsize;		/* Program header table entry size */
 
-+  Elf64_Half	e_phnum;		/* Program header table entry count */
 
-+  Elf64_Half	e_shentsize;		/* Section header table entry size */
 
-+  Elf64_Half	e_shnum;		/* Section header table entry count */
 
-+  Elf64_Half	e_shstrndx;		/* Section header string table index */
 
-+} Elf64_Ehdr;
 
-+
 
-+/* Fields in the e_ident array.  The EI_* macros are indices into the
 
-+   array.  The macros under each EI_* macro are the values the byte
 
-+   may have.  */
 
-+
 
-+#define EI_MAG0		0		/* File identification byte 0 index */
 
-+#define ELFMAG0		0x7f		/* Magic number byte 0 */
 
-+
 
-+#define EI_MAG1		1		/* File identification byte 1 index */
 
-+#define ELFMAG1		'E'		/* Magic number byte 1 */
 
-+
 
-+#define EI_MAG2		2		/* File identification byte 2 index */
 
-+#define ELFMAG2		'L'		/* Magic number byte 2 */
 
-+
 
-+#define EI_MAG3		3		/* File identification byte 3 index */
 
-+#define ELFMAG3		'F'		/* Magic number byte 3 */
 
-+
 
-+/* Conglomeration of the identification bytes, for easy testing as a word.  */
 
-+#define	ELFMAG		"\177ELF"
 
-+#define	SELFMAG		4
 
-+
 
-+#define EI_CLASS	4		/* File class byte index */
 
-+#define ELFCLASSNONE	0		/* Invalid class */
 
-+#define ELFCLASS32	1		/* 32-bit objects */
 
-+#define ELFCLASS64	2		/* 64-bit objects */
 
-+#define ELFCLASSNUM	3
 
-+
 
-+#define EI_DATA		5		/* Data encoding byte index */
 
-+#define ELFDATANONE	0		/* Invalid data encoding */
 
-+#define ELFDATA2LSB	1		/* 2's complement, little endian */
 
-+#define ELFDATA2MSB	2		/* 2's complement, big endian */
 
-+#define ELFDATANUM	3
 
-+
 
-+#define EI_VERSION	6		/* File version byte index */
 
-+					/* Value must be EV_CURRENT */
 
-+
 
-+#define EI_OSABI	7		/* OS ABI identification */
 
-+#define ELFOSABI_NONE		0	/* UNIX System V ABI */
 
-+#define ELFOSABI_SYSV		0	/* Alias.  */
 
-+#define ELFOSABI_HPUX		1	/* HP-UX */
 
-+#define ELFOSABI_NETBSD		2	/* NetBSD.  */
 
-+#define ELFOSABI_GNU		3	/* Object uses GNU ELF extensions.  */
 
-+#define ELFOSABI_LINUX		ELFOSABI_GNU /* Compatibility alias.  */
 
-+#define ELFOSABI_SOLARIS	6	/* Sun Solaris.  */
 
-+#define ELFOSABI_AIX		7	/* IBM AIX.  */
 
-+#define ELFOSABI_IRIX		8	/* SGI Irix.  */
 
-+#define ELFOSABI_FREEBSD	9	/* FreeBSD.  */
 
-+#define ELFOSABI_TRU64		10	/* Compaq TRU64 UNIX.  */
 
-+#define ELFOSABI_MODESTO	11	/* Novell Modesto.  */
 
-+#define ELFOSABI_OPENBSD	12	/* OpenBSD.  */
 
-+#define ELFOSABI_ARM_AEABI	64	/* ARM EABI */
 
-+#define ELFOSABI_ARM		97	/* ARM */
 
-+#define ELFOSABI_STANDALONE	255	/* Standalone (embedded) application */
 
-+
 
-+#define EI_ABIVERSION	8		/* ABI version */
 
-+
 
-+#define EI_PAD		9		/* Byte index of padding bytes */
 
-+
 
-+/* Legal values for e_type (object file type).  */
 
-+
 
-+#define ET_NONE		0		/* No file type */
 
-+#define ET_REL		1		/* Relocatable file */
 
-+#define ET_EXEC		2		/* Executable file */
 
-+#define ET_DYN		3		/* Shared object file */
 
-+#define ET_CORE		4		/* Core file */
 
-+#define	ET_NUM		5		/* Number of defined types */
 
-+#define ET_LOOS		0xfe00		/* OS-specific range start */
 
-+#define ET_HIOS		0xfeff		/* OS-specific range end */
 
-+#define ET_LOPROC	0xff00		/* Processor-specific range start */
 
-+#define ET_HIPROC	0xffff		/* Processor-specific range end */
 
-+
 
-+/* Legal values for e_machine (architecture).  */
 
-+
 
-+#define EM_NONE		 0		/* No machine */
 
-+#define EM_M32		 1		/* AT&T WE 32100 */
 
-+#define EM_SPARC	 2		/* SUN SPARC */
 
-+#define EM_386		 3		/* Intel 80386 */
 
-+#define EM_68K		 4		/* Motorola m68k family */
 
-+#define EM_88K		 5		/* Motorola m88k family */
 
-+#define EM_860		 7		/* Intel 80860 */
 
-+#define EM_MIPS		 8		/* MIPS R3000 big-endian */
 
-+#define EM_S370		 9		/* IBM System/370 */
 
-+#define EM_MIPS_RS3_LE	10		/* MIPS R3000 little-endian */
 
-+
 
-+#define EM_PARISC	15		/* HPPA */
 
-+#define EM_VPP500	17		/* Fujitsu VPP500 */
 
-+#define EM_SPARC32PLUS	18		/* Sun's "v8plus" */
 
-+#define EM_960		19		/* Intel 80960 */
 
-+#define EM_PPC		20		/* PowerPC */
 
-+#define EM_PPC64	21		/* PowerPC 64-bit */
 
-+#define EM_S390		22		/* IBM S390 */
 
-+
 
-+#define EM_V800		36		/* NEC V800 series */
 
-+#define EM_FR20		37		/* Fujitsu FR20 */
 
-+#define EM_RH32		38		/* TRW RH-32 */
 
-+#define EM_RCE		39		/* Motorola RCE */
 
-+#define EM_ARM		40		/* ARM */
 
-+#define EM_FAKE_ALPHA	41		/* Digital Alpha */
 
-+#define EM_SH		42		/* Hitachi SH */
 
-+#define EM_SPARCV9	43		/* SPARC v9 64-bit */
 
-+#define EM_TRICORE	44		/* Siemens Tricore */
 
-+#define EM_ARC		45		/* Argonaut RISC Core */
 
-+#define EM_H8_300	46		/* Hitachi H8/300 */
 
-+#define EM_H8_300H	47		/* Hitachi H8/300H */
 
-+#define EM_H8S		48		/* Hitachi H8S */
 
-+#define EM_H8_500	49		/* Hitachi H8/500 */
 
-+#define EM_IA_64	50		/* Intel Merced */
 
-+#define EM_MIPS_X	51		/* Stanford MIPS-X */
 
-+#define EM_COLDFIRE	52		/* Motorola Coldfire */
 
-+#define EM_68HC12	53		/* Motorola M68HC12 */
 
-+#define EM_MMA		54		/* Fujitsu MMA Multimedia Accelerator*/
 
-+#define EM_PCP		55		/* Siemens PCP */
 
-+#define EM_NCPU		56		/* Sony nCPU embeeded RISC */
 
-+#define EM_NDR1		57		/* Denso NDR1 microprocessor */
 
-+#define EM_STARCORE	58		/* Motorola Start*Core processor */
 
-+#define EM_ME16		59		/* Toyota ME16 processor */
 
-+#define EM_ST100	60		/* STMicroelectronic ST100 processor */
 
-+#define EM_TINYJ	61		/* Advanced Logic Corp. Tinyj emb.fam*/
 
-+#define EM_X86_64	62		/* AMD x86-64 architecture */
 
-+#define EM_PDSP		63		/* Sony DSP Processor */
 
-+
 
-+#define EM_FX66		66		/* Siemens FX66 microcontroller */
 
-+#define EM_ST9PLUS	67		/* STMicroelectronics ST9+ 8/16 mc */
 
-+#define EM_ST7		68		/* STmicroelectronics ST7 8 bit mc */
 
-+#define EM_68HC16	69		/* Motorola MC68HC16 microcontroller */
 
-+#define EM_68HC11	70		/* Motorola MC68HC11 microcontroller */
 
-+#define EM_68HC08	71		/* Motorola MC68HC08 microcontroller */
 
-+#define EM_68HC05	72		/* Motorola MC68HC05 microcontroller */
 
-+#define EM_SVX		73		/* Silicon Graphics SVx */
 
-+#define EM_ST19		74		/* STMicroelectronics ST19 8 bit mc */
 
-+#define EM_VAX		75		/* Digital VAX */
 
-+#define EM_CRIS		76		/* Axis Communications 32-bit embedded processor */
 
-+#define EM_JAVELIN	77		/* Infineon Technologies 32-bit embedded processor */
 
-+#define EM_FIREPATH	78		/* Element 14 64-bit DSP Processor */
 
-+#define EM_ZSP		79		/* LSI Logic 16-bit DSP Processor */
 
-+#define EM_MMIX		80		/* Donald Knuth's educational 64-bit processor */
 
-+#define EM_HUANY	81		/* Harvard University machine-independent object files */
 
-+#define EM_PRISM	82		/* SiTera Prism */
 
-+#define EM_AVR		83		/* Atmel AVR 8-bit microcontroller */
 
-+#define EM_FR30		84		/* Fujitsu FR30 */
 
-+#define EM_D10V		85		/* Mitsubishi D10V */
 
-+#define EM_D30V		86		/* Mitsubishi D30V */
 
-+#define EM_V850		87		/* NEC v850 */
 
-+#define EM_M32R		88		/* Mitsubishi M32R */
 
-+#define EM_MN10300	89		/* Matsushita MN10300 */
 
-+#define EM_MN10200	90		/* Matsushita MN10200 */
 
-+#define EM_PJ		91		/* picoJava */
 
-+#define EM_OPENRISC	92		/* OpenRISC 32-bit embedded processor */
 
-+#define EM_ARC_A5	93		/* ARC Cores Tangent-A5 */
 
-+#define EM_XTENSA	94		/* Tensilica Xtensa Architecture */
 
-+#define EM_TILEPRO	188		/* Tilera TILEPro */
 
-+#define EM_TILEGX	191		/* Tilera TILE-Gx */
 
-+#define EM_NUM		192
 
-+
 
-+/* If it is necessary to assign new unofficial EM_* values, please
 
-+   pick large random numbers (0x8523, 0xa7f2, etc.) to minimize the
 
-+   chances of collision with official or non-GNU unofficial values.  */
 
-+
 
-+#define EM_ALPHA	0x9026
 
-+
 
-+/* Legal values for e_version (version).  */
 
-+
 
-+#define EV_NONE		0		/* Invalid ELF version */
 
-+#define EV_CURRENT	1		/* Current version */
 
-+#define EV_NUM		2
 
-+
 
-+/* Section header.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Word	sh_name;		/* Section name (string tbl index) */
 
-+  Elf32_Word	sh_type;		/* Section type */
 
-+  Elf32_Word	sh_flags;		/* Section flags */
 
-+  Elf32_Addr	sh_addr;		/* Section virtual addr at execution */
 
-+  Elf32_Off	sh_offset;		/* Section file offset */
 
-+  Elf32_Word	sh_size;		/* Section size in bytes */
 
-+  Elf32_Word	sh_link;		/* Link to another section */
 
-+  Elf32_Word	sh_info;		/* Additional section information */
 
-+  Elf32_Word	sh_addralign;		/* Section alignment */
 
-+  Elf32_Word	sh_entsize;		/* Entry size if section holds table */
 
-+} Elf32_Shdr;
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Word	sh_name;		/* Section name (string tbl index) */
 
-+  Elf64_Word	sh_type;		/* Section type */
 
-+  Elf64_Xword	sh_flags;		/* Section flags */
 
-+  Elf64_Addr	sh_addr;		/* Section virtual addr at execution */
 
-+  Elf64_Off	sh_offset;		/* Section file offset */
 
-+  Elf64_Xword	sh_size;		/* Section size in bytes */
 
-+  Elf64_Word	sh_link;		/* Link to another section */
 
-+  Elf64_Word	sh_info;		/* Additional section information */
 
-+  Elf64_Xword	sh_addralign;		/* Section alignment */
 
-+  Elf64_Xword	sh_entsize;		/* Entry size if section holds table */
 
-+} Elf64_Shdr;
 
-+
 
-+/* Special section indices.  */
 
-+
 
-+#define SHN_UNDEF	0		/* Undefined section */
 
-+#define SHN_LORESERVE	0xff00		/* Start of reserved indices */
 
-+#define SHN_LOPROC	0xff00		/* Start of processor-specific */
 
-+#define SHN_BEFORE	0xff00		/* Order section before all others
 
-+					   (Solaris).  */
 
-+#define SHN_AFTER	0xff01		/* Order section after all others
 
-+					   (Solaris).  */
 
-+#define SHN_HIPROC	0xff1f		/* End of processor-specific */
 
-+#define SHN_LOOS	0xff20		/* Start of OS-specific */
 
-+#define SHN_HIOS	0xff3f		/* End of OS-specific */
 
-+#define SHN_ABS		0xfff1		/* Associated symbol is absolute */
 
-+#define SHN_COMMON	0xfff2		/* Associated symbol is common */
 
-+#define SHN_XINDEX	0xffff		/* Index is in extra table.  */
 
-+#define SHN_HIRESERVE	0xffff		/* End of reserved indices */
 
-+
 
-+/* Legal values for sh_type (section type).  */
 
-+
 
-+#define SHT_NULL	  0		/* Section header table entry unused */
 
-+#define SHT_PROGBITS	  1		/* Program data */
 
-+#define SHT_SYMTAB	  2		/* Symbol table */
 
-+#define SHT_STRTAB	  3		/* String table */
 
-+#define SHT_RELA	  4		/* Relocation entries with addends */
 
-+#define SHT_HASH	  5		/* Symbol hash table */
 
-+#define SHT_DYNAMIC	  6		/* Dynamic linking information */
 
-+#define SHT_NOTE	  7		/* Notes */
 
-+#define SHT_NOBITS	  8		/* Program space with no data (bss) */
 
-+#define SHT_REL		  9		/* Relocation entries, no addends */
 
-+#define SHT_SHLIB	  10		/* Reserved */
 
-+#define SHT_DYNSYM	  11		/* Dynamic linker symbol table */
 
-+#define SHT_INIT_ARRAY	  14		/* Array of constructors */
 
-+#define SHT_FINI_ARRAY	  15		/* Array of destructors */
 
-+#define SHT_PREINIT_ARRAY 16		/* Array of pre-constructors */
 
-+#define SHT_GROUP	  17		/* Section group */
 
-+#define SHT_SYMTAB_SHNDX  18		/* Extended section indeces */
 
-+#define	SHT_NUM		  19		/* Number of defined types.  */
 
-+#define SHT_LOOS	  0x60000000	/* Start OS-specific.  */
 
-+#define SHT_GNU_ATTRIBUTES 0x6ffffff5	/* Object attributes.  */
 
-+#define SHT_GNU_HASH	  0x6ffffff6	/* GNU-style hash table.  */
 
-+#define SHT_GNU_LIBLIST	  0x6ffffff7	/* Prelink library list */
 
-+#define SHT_CHECKSUM	  0x6ffffff8	/* Checksum for DSO content.  */
 
-+#define SHT_LOSUNW	  0x6ffffffa	/* Sun-specific low bound.  */
 
-+#define SHT_SUNW_move	  0x6ffffffa
 
-+#define SHT_SUNW_COMDAT   0x6ffffffb
 
-+#define SHT_SUNW_syminfo  0x6ffffffc
 
-+#define SHT_GNU_verdef	  0x6ffffffd	/* Version definition section.  */
 
-+#define SHT_GNU_verneed	  0x6ffffffe	/* Version needs section.  */
 
-+#define SHT_GNU_versym	  0x6fffffff	/* Version symbol table.  */
 
-+#define SHT_HISUNW	  0x6fffffff	/* Sun-specific high bound.  */
 
-+#define SHT_HIOS	  0x6fffffff	/* End OS-specific type */
 
-+#define SHT_LOPROC	  0x70000000	/* Start of processor-specific */
 
-+#define SHT_HIPROC	  0x7fffffff	/* End of processor-specific */
 
-+#define SHT_LOUSER	  0x80000000	/* Start of application-specific */
 
-+#define SHT_HIUSER	  0x8fffffff	/* End of application-specific */
 
-+
 
-+/* Legal values for sh_flags (section flags).  */
 
-+
 
-+#define SHF_WRITE	     (1 << 0)	/* Writable */
 
-+#define SHF_ALLOC	     (1 << 1)	/* Occupies memory during execution */
 
-+#define SHF_EXECINSTR	     (1 << 2)	/* Executable */
 
-+#define SHF_MERGE	     (1 << 4)	/* Might be merged */
 
-+#define SHF_STRINGS	     (1 << 5)	/* Contains nul-terminated strings */
 
-+#define SHF_INFO_LINK	     (1 << 6)	/* `sh_info' contains SHT index */
 
-+#define SHF_LINK_ORDER	     (1 << 7)	/* Preserve order after combining */
 
-+#define SHF_OS_NONCONFORMING (1 << 8)	/* Non-standard OS specific handling
 
-+					   required */
 
-+#define SHF_GROUP	     (1 << 9)	/* Section is member of a group.  */
 
-+#define SHF_TLS		     (1 << 10)	/* Section hold thread-local data.  */
 
-+#define SHF_MASKOS	     0x0ff00000	/* OS-specific.  */
 
-+#define SHF_MASKPROC	     0xf0000000	/* Processor-specific */
 
-+#define SHF_ORDERED	     (1 << 30)	/* Special ordering requirement
 
-+					   (Solaris).  */
 
-+#define SHF_EXCLUDE	     (1 << 31)	/* Section is excluded unless
 
-+					   referenced or allocated (Solaris).*/
 
-+
 
-+/* Section group handling.  */
 
-+#define GRP_COMDAT	0x1		/* Mark group as COMDAT.  */
 
-+
 
-+/* Symbol table entry.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Word	st_name;		/* Symbol name (string tbl index) */
 
-+  Elf32_Addr	st_value;		/* Symbol value */
 
-+  Elf32_Word	st_size;		/* Symbol size */
 
-+  unsigned char	st_info;		/* Symbol type and binding */
 
-+  unsigned char	st_other;		/* Symbol visibility */
 
-+  Elf32_Section	st_shndx;		/* Section index */
 
-+} Elf32_Sym;
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Word	st_name;		/* Symbol name (string tbl index) */
 
-+  unsigned char	st_info;		/* Symbol type and binding */
 
-+  unsigned char st_other;		/* Symbol visibility */
 
-+  Elf64_Section	st_shndx;		/* Section index */
 
-+  Elf64_Addr	st_value;		/* Symbol value */
 
-+  Elf64_Xword	st_size;		/* Symbol size */
 
-+} Elf64_Sym;
 
-+
 
-+/* The syminfo section if available contains additional information about
 
-+   every dynamic symbol.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Half si_boundto;		/* Direct bindings, symbol bound to */
 
-+  Elf32_Half si_flags;			/* Per symbol flags */
 
-+} Elf32_Syminfo;
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Half si_boundto;		/* Direct bindings, symbol bound to */
 
-+  Elf64_Half si_flags;			/* Per symbol flags */
 
-+} Elf64_Syminfo;
 
-+
 
-+/* Possible values for si_boundto.  */
 
-+#define SYMINFO_BT_SELF		0xffff	/* Symbol bound to self */
 
-+#define SYMINFO_BT_PARENT	0xfffe	/* Symbol bound to parent */
 
-+#define SYMINFO_BT_LOWRESERVE	0xff00	/* Beginning of reserved entries */
 
-+
 
-+/* Possible bitmasks for si_flags.  */
 
-+#define SYMINFO_FLG_DIRECT	0x0001	/* Direct bound symbol */
 
-+#define SYMINFO_FLG_PASSTHRU	0x0002	/* Pass-thru symbol for translator */
 
-+#define SYMINFO_FLG_COPY	0x0004	/* Symbol is a copy-reloc */
 
-+#define SYMINFO_FLG_LAZYLOAD	0x0008	/* Symbol bound to object to be lazy
 
-+					   loaded */
 
-+/* Syminfo version values.  */
 
-+#define SYMINFO_NONE		0
 
-+#define SYMINFO_CURRENT		1
 
-+#define SYMINFO_NUM		2
 
-+
 
-+
 
-+/* How to extract and insert information held in the st_info field.  */
 
-+
 
-+#define ELF32_ST_BIND(val)		(((unsigned char) (val)) >> 4)
 
-+#define ELF32_ST_TYPE(val)		((val) & 0xf)
 
-+#define ELF32_ST_INFO(bind, type)	(((bind) << 4) + ((type) & 0xf))
 
-+
 
-+/* Both Elf32_Sym and Elf64_Sym use the same one-byte st_info field.  */
 
-+#define ELF64_ST_BIND(val)		ELF32_ST_BIND (val)
 
-+#define ELF64_ST_TYPE(val)		ELF32_ST_TYPE (val)
 
-+#define ELF64_ST_INFO(bind, type)	ELF32_ST_INFO ((bind), (type))
 
-+
 
-+/* Legal values for ST_BIND subfield of st_info (symbol binding).  */
 
-+
 
-+#define STB_LOCAL	0		/* Local symbol */
 
-+#define STB_GLOBAL	1		/* Global symbol */
 
-+#define STB_WEAK	2		/* Weak symbol */
 
-+#define	STB_NUM		3		/* Number of defined types.  */
 
-+#define STB_LOOS	10		/* Start of OS-specific */
 
-+#define STB_GNU_UNIQUE	10		/* Unique symbol.  */
 
-+#define STB_HIOS	12		/* End of OS-specific */
 
-+#define STB_LOPROC	13		/* Start of processor-specific */
 
-+#define STB_HIPROC	15		/* End of processor-specific */
 
-+
 
-+/* Legal values for ST_TYPE subfield of st_info (symbol type).  */
 
-+
 
-+#define STT_NOTYPE	0		/* Symbol type is unspecified */
 
-+#define STT_OBJECT	1		/* Symbol is a data object */
 
-+#define STT_FUNC	2		/* Symbol is a code object */
 
-+#define STT_SECTION	3		/* Symbol associated with a section */
 
-+#define STT_FILE	4		/* Symbol's name is file name */
 
-+#define STT_COMMON	5		/* Symbol is a common data object */
 
-+#define STT_TLS		6		/* Symbol is thread-local data object*/
 
-+#define	STT_NUM		7		/* Number of defined types.  */
 
-+#define STT_LOOS	10		/* Start of OS-specific */
 
-+#define STT_GNU_IFUNC	10		/* Symbol is indirect code object */
 
-+#define STT_HIOS	12		/* End of OS-specific */
 
-+#define STT_LOPROC	13		/* Start of processor-specific */
 
-+#define STT_HIPROC	15		/* End of processor-specific */
 
-+
 
-+
 
-+/* Symbol table indices are found in the hash buckets and chain table
 
-+   of a symbol hash table section.  This special index value indicates
 
-+   the end of a chain, meaning no further symbols are found in that bucket.  */
 
-+
 
-+#define STN_UNDEF	0		/* End of a chain.  */
 
-+
 
-+
 
-+/* How to extract and insert information held in the st_other field.  */
 
-+
 
-+#define ELF32_ST_VISIBILITY(o)	((o) & 0x03)
 
-+
 
-+/* For ELF64 the definitions are the same.  */
 
-+#define ELF64_ST_VISIBILITY(o)	ELF32_ST_VISIBILITY (o)
 
-+
 
-+/* Symbol visibility specification encoded in the st_other field.  */
 
-+#define STV_DEFAULT	0		/* Default symbol visibility rules */
 
-+#define STV_INTERNAL	1		/* Processor specific hidden class */
 
-+#define STV_HIDDEN	2		/* Sym unavailable in other modules */
 
-+#define STV_PROTECTED	3		/* Not preemptible, not exported */
 
-+
 
-+
 
-+/* Relocation table entry without addend (in section of type SHT_REL).  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Addr	r_offset;		/* Address */
 
-+  Elf32_Word	r_info;			/* Relocation type and symbol index */
 
-+} Elf32_Rel;
 
-+
 
-+/* I have seen two different definitions of the Elf64_Rel and
 
-+   Elf64_Rela structures, so we'll leave them out until Novell (or
 
-+   whoever) gets their act together.  */
 
-+/* The following, at least, is used on Sparc v9, MIPS, and Alpha.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Addr	r_offset;		/* Address */
 
-+  Elf64_Xword	r_info;			/* Relocation type and symbol index */
 
-+} Elf64_Rel;
 
-+
 
-+/* Relocation table entry with addend (in section of type SHT_RELA).  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Addr	r_offset;		/* Address */
 
-+  Elf32_Word	r_info;			/* Relocation type and symbol index */
 
-+  Elf32_Sword	r_addend;		/* Addend */
 
-+} Elf32_Rela;
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Addr	r_offset;		/* Address */
 
-+  Elf64_Xword	r_info;			/* Relocation type and symbol index */
 
-+  Elf64_Sxword	r_addend;		/* Addend */
 
-+} Elf64_Rela;
 
-+
 
-+/* How to extract and insert information held in the r_info field.  */
 
-+
 
-+#define ELF32_R_SYM(val)		((val) >> 8)
 
-+#define ELF32_R_TYPE(val)		((val) & 0xff)
 
-+#define ELF32_R_INFO(sym, type)		(((sym) << 8) + ((type) & 0xff))
 
-+
 
-+#define ELF64_R_SYM(i)			((i) >> 32)
 
-+#define ELF64_R_TYPE(i)			((i) & 0xffffffff)
 
-+#define ELF64_R_INFO(sym,type)		((((Elf64_Xword) (sym)) << 32) + (type))
 
-+
 
-+/* Program segment header.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Word	p_type;			/* Segment type */
 
-+  Elf32_Off	p_offset;		/* Segment file offset */
 
-+  Elf32_Addr	p_vaddr;		/* Segment virtual address */
 
-+  Elf32_Addr	p_paddr;		/* Segment physical address */
 
-+  Elf32_Word	p_filesz;		/* Segment size in file */
 
-+  Elf32_Word	p_memsz;		/* Segment size in memory */
 
-+  Elf32_Word	p_flags;		/* Segment flags */
 
-+  Elf32_Word	p_align;		/* Segment alignment */
 
-+} Elf32_Phdr;
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Word	p_type;			/* Segment type */
 
-+  Elf64_Word	p_flags;		/* Segment flags */
 
-+  Elf64_Off	p_offset;		/* Segment file offset */
 
-+  Elf64_Addr	p_vaddr;		/* Segment virtual address */
 
-+  Elf64_Addr	p_paddr;		/* Segment physical address */
 
-+  Elf64_Xword	p_filesz;		/* Segment size in file */
 
-+  Elf64_Xword	p_memsz;		/* Segment size in memory */
 
-+  Elf64_Xword	p_align;		/* Segment alignment */
 
-+} Elf64_Phdr;
 
-+
 
-+/* Special value for e_phnum.  This indicates that the real number of
 
-+   program headers is too large to fit into e_phnum.  Instead the real
 
-+   value is in the field sh_info of section 0.  */
 
-+
 
-+#define PN_XNUM		0xffff
 
-+
 
-+/* Legal values for p_type (segment type).  */
 
-+
 
-+#define	PT_NULL		0		/* Program header table entry unused */
 
-+#define PT_LOAD		1		/* Loadable program segment */
 
-+#define PT_DYNAMIC	2		/* Dynamic linking information */
 
-+#define PT_INTERP	3		/* Program interpreter */
 
-+#define PT_NOTE		4		/* Auxiliary information */
 
-+#define PT_SHLIB	5		/* Reserved */
 
-+#define PT_PHDR		6		/* Entry for header table itself */
 
-+#define PT_TLS		7		/* Thread-local storage segment */
 
-+#define	PT_NUM		8		/* Number of defined types */
 
-+#define PT_LOOS		0x60000000	/* Start of OS-specific */
 
-+#define PT_GNU_EH_FRAME	0x6474e550	/* GCC .eh_frame_hdr segment */
 
-+#define PT_GNU_STACK	0x6474e551	/* Indicates stack executability */
 
-+#define PT_GNU_RELRO	0x6474e552	/* Read-only after relocation */
 
-+#define PT_LOSUNW	0x6ffffffa
 
-+#define PT_SUNWBSS	0x6ffffffa	/* Sun Specific segment */
 
-+#define PT_SUNWSTACK	0x6ffffffb	/* Stack segment */
 
-+#define PT_HISUNW	0x6fffffff
 
-+#define PT_HIOS		0x6fffffff	/* End of OS-specific */
 
-+#define PT_LOPROC	0x70000000	/* Start of processor-specific */
 
-+#define PT_HIPROC	0x7fffffff	/* End of processor-specific */
 
-+
 
-+/* Legal values for p_flags (segment flags).  */
 
-+
 
-+#define PF_X		(1 << 0)	/* Segment is executable */
 
-+#define PF_W		(1 << 1)	/* Segment is writable */
 
-+#define PF_R		(1 << 2)	/* Segment is readable */
 
-+#define PF_MASKOS	0x0ff00000	/* OS-specific */
 
-+#define PF_MASKPROC	0xf0000000	/* Processor-specific */
 
-+
 
-+/* Legal values for note segment descriptor types for core files. */
 
-+
 
-+#define NT_PRSTATUS	1		/* Contains copy of prstatus struct */
 
-+#define NT_FPREGSET	2		/* Contains copy of fpregset struct */
 
-+#define NT_PRPSINFO	3		/* Contains copy of prpsinfo struct */
 
-+#define NT_PRXREG	4		/* Contains copy of prxregset struct */
 
-+#define NT_TASKSTRUCT	4		/* Contains copy of task structure */
 
-+#define NT_PLATFORM	5		/* String from sysinfo(SI_PLATFORM) */
 
-+#define NT_AUXV		6		/* Contains copy of auxv array */
 
-+#define NT_GWINDOWS	7		/* Contains copy of gwindows struct */
 
-+#define NT_ASRS		8		/* Contains copy of asrset struct */
 
-+#define NT_PSTATUS	10		/* Contains copy of pstatus struct */
 
-+#define NT_PSINFO	13		/* Contains copy of psinfo struct */
 
-+#define NT_PRCRED	14		/* Contains copy of prcred struct */
 
-+#define NT_UTSNAME	15		/* Contains copy of utsname struct */
 
-+#define NT_LWPSTATUS	16		/* Contains copy of lwpstatus struct */
 
-+#define NT_LWPSINFO	17		/* Contains copy of lwpinfo struct */
 
-+#define NT_PRFPXREG	20		/* Contains copy of fprxregset struct */
 
-+#define NT_PRXFPREG	0x46e62b7f	/* Contains copy of user_fxsr_struct */
 
-+#define NT_PPC_VMX	0x100		/* PowerPC Altivec/VMX registers */
 
-+#define NT_PPC_SPE	0x101		/* PowerPC SPE/EVR registers */
 
-+#define NT_PPC_VSX	0x102		/* PowerPC VSX registers */
 
-+#define NT_386_TLS	0x200		/* i386 TLS slots (struct user_desc) */
 
-+#define NT_386_IOPERM	0x201		/* x86 io permission bitmap (1=deny) */
 
-+#define NT_X86_XSTATE	0x202		/* x86 extended state using xsave */
 
-+
 
-+/* Legal values for the note segment descriptor types for object files.  */
 
-+
 
-+#define NT_VERSION	1		/* Contains a version string.  */
 
-+
 
-+
 
-+/* Dynamic section entry.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Sword	d_tag;			/* Dynamic entry type */
 
-+  union
 
-+    {
 
-+      Elf32_Word d_val;			/* Integer value */
 
-+      Elf32_Addr d_ptr;			/* Address value */
 
-+    } d_un;
 
-+} Elf32_Dyn;
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Sxword	d_tag;			/* Dynamic entry type */
 
-+  union
 
-+    {
 
-+      Elf64_Xword d_val;		/* Integer value */
 
-+      Elf64_Addr d_ptr;			/* Address value */
 
-+    } d_un;
 
-+} Elf64_Dyn;
 
-+
 
-+/* Legal values for d_tag (dynamic entry type).  */
 
-+
 
-+#define DT_NULL		0		/* Marks end of dynamic section */
 
-+#define DT_NEEDED	1		/* Name of needed library */
 
-+#define DT_PLTRELSZ	2		/* Size in bytes of PLT relocs */
 
-+#define DT_PLTGOT	3		/* Processor defined value */
 
-+#define DT_HASH		4		/* Address of symbol hash table */
 
-+#define DT_STRTAB	5		/* Address of string table */
 
-+#define DT_SYMTAB	6		/* Address of symbol table */
 
-+#define DT_RELA		7		/* Address of Rela relocs */
 
-+#define DT_RELASZ	8		/* Total size of Rela relocs */
 
-+#define DT_RELAENT	9		/* Size of one Rela reloc */
 
-+#define DT_STRSZ	10		/* Size of string table */
 
-+#define DT_SYMENT	11		/* Size of one symbol table entry */
 
-+#define DT_INIT		12		/* Address of init function */
 
-+#define DT_FINI		13		/* Address of termination function */
 
-+#define DT_SONAME	14		/* Name of shared object */
 
-+#define DT_RPATH	15		/* Library search path (deprecated) */
 
-+#define DT_SYMBOLIC	16		/* Start symbol search here */
 
-+#define DT_REL		17		/* Address of Rel relocs */
 
-+#define DT_RELSZ	18		/* Total size of Rel relocs */
 
-+#define DT_RELENT	19		/* Size of one Rel reloc */
 
-+#define DT_PLTREL	20		/* Type of reloc in PLT */
 
-+#define DT_DEBUG	21		/* For debugging; unspecified */
 
-+#define DT_TEXTREL	22		/* Reloc might modify .text */
 
-+#define DT_JMPREL	23		/* Address of PLT relocs */
 
-+#define	DT_BIND_NOW	24		/* Process relocations of object */
 
-+#define	DT_INIT_ARRAY	25		/* Array with addresses of init fct */
 
-+#define	DT_FINI_ARRAY	26		/* Array with addresses of fini fct */
 
-+#define	DT_INIT_ARRAYSZ	27		/* Size in bytes of DT_INIT_ARRAY */
 
-+#define	DT_FINI_ARRAYSZ	28		/* Size in bytes of DT_FINI_ARRAY */
 
-+#define DT_RUNPATH	29		/* Library search path */
 
-+#define DT_FLAGS	30		/* Flags for the object being loaded */
 
-+#define DT_ENCODING	32		/* Start of encoded range */
 
-+#define DT_PREINIT_ARRAY 32		/* Array with addresses of preinit fct*/
 
-+#define DT_PREINIT_ARRAYSZ 33		/* size in bytes of DT_PREINIT_ARRAY */
 
-+#define	DT_NUM		34		/* Number used */
 
-+#define DT_LOOS		0x6000000d	/* Start of OS-specific */
 
-+#define DT_HIOS		0x6ffff000	/* End of OS-specific */
 
-+#define DT_LOPROC	0x70000000	/* Start of processor-specific */
 
-+#define DT_HIPROC	0x7fffffff	/* End of processor-specific */
 
-+#define	DT_PROCNUM	DT_MIPS_NUM	/* Most used by any processor */
 
-+
 
-+/* DT_* entries which fall between DT_VALRNGHI & DT_VALRNGLO use the
 
-+   Dyn.d_un.d_val field of the Elf*_Dyn structure.  This follows Sun's
 
-+   approach.  */
 
-+#define DT_VALRNGLO	0x6ffffd00
 
-+#define DT_GNU_PRELINKED 0x6ffffdf5	/* Prelinking timestamp */
 
-+#define DT_GNU_CONFLICTSZ 0x6ffffdf6	/* Size of conflict section */
 
-+#define DT_GNU_LIBLISTSZ 0x6ffffdf7	/* Size of library list */
 
-+#define DT_CHECKSUM	0x6ffffdf8
 
-+#define DT_PLTPADSZ	0x6ffffdf9
 
-+#define DT_MOVEENT	0x6ffffdfa
 
-+#define DT_MOVESZ	0x6ffffdfb
 
-+#define DT_FEATURE_1	0x6ffffdfc	/* Feature selection (DTF_*).  */
 
-+#define DT_POSFLAG_1	0x6ffffdfd	/* Flags for DT_* entries, effecting
 
-+					   the following DT_* entry.  */
 
-+#define DT_SYMINSZ	0x6ffffdfe	/* Size of syminfo table (in bytes) */
 
-+#define DT_SYMINENT	0x6ffffdff	/* Entry size of syminfo */
 
-+#define DT_VALRNGHI	0x6ffffdff
 
-+#define DT_VALTAGIDX(tag)	(DT_VALRNGHI - (tag))	/* Reverse order! */
 
-+#define DT_VALNUM 12
 
-+
 
-+/* DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the
 
-+   Dyn.d_un.d_ptr field of the Elf*_Dyn structure.
 
-+
 
-+   If any adjustment is made to the ELF object after it has been
 
-+   built these entries will need to be adjusted.  */
 
-+#define DT_ADDRRNGLO	0x6ffffe00
 
-+#define DT_GNU_HASH	0x6ffffef5	/* GNU-style hash table.  */
 
-+#define DT_TLSDESC_PLT	0x6ffffef6
 
-+#define DT_TLSDESC_GOT	0x6ffffef7
 
-+#define DT_GNU_CONFLICT	0x6ffffef8	/* Start of conflict section */
 
-+#define DT_GNU_LIBLIST	0x6ffffef9	/* Library list */
 
-+#define DT_CONFIG	0x6ffffefa	/* Configuration information.  */
 
-+#define DT_DEPAUDIT	0x6ffffefb	/* Dependency auditing.  */
 
-+#define DT_AUDIT	0x6ffffefc	/* Object auditing.  */
 
-+#define	DT_PLTPAD	0x6ffffefd	/* PLT padding.  */
 
-+#define	DT_MOVETAB	0x6ffffefe	/* Move table.  */
 
-+#define DT_SYMINFO	0x6ffffeff	/* Syminfo table.  */
 
-+#define DT_ADDRRNGHI	0x6ffffeff
 
-+#define DT_ADDRTAGIDX(tag)	(DT_ADDRRNGHI - (tag))	/* Reverse order! */
 
-+#define DT_ADDRNUM 11
 
-+
 
-+/* The versioning entry types.  The next are defined as part of the
 
-+   GNU extension.  */
 
-+#define DT_VERSYM	0x6ffffff0
 
-+
 
-+#define DT_RELACOUNT	0x6ffffff9
 
-+#define DT_RELCOUNT	0x6ffffffa
 
-+
 
-+/* These were chosen by Sun.  */
 
-+#define DT_FLAGS_1	0x6ffffffb	/* State flags, see DF_1_* below.  */
 
-+#define	DT_VERDEF	0x6ffffffc	/* Address of version definition
 
-+					   table */
 
-+#define	DT_VERDEFNUM	0x6ffffffd	/* Number of version definitions */
 
-+#define	DT_VERNEED	0x6ffffffe	/* Address of table with needed
 
-+					   versions */
 
-+#define	DT_VERNEEDNUM	0x6fffffff	/* Number of needed versions */
 
-+#define DT_VERSIONTAGIDX(tag)	(DT_VERNEEDNUM - (tag))	/* Reverse order! */
 
-+#define DT_VERSIONTAGNUM 16
 
-+
 
-+/* Sun added these machine-independent extensions in the "processor-specific"
 
-+   range.  Be compatible.  */
 
-+#define DT_AUXILIARY    0x7ffffffd      /* Shared object to load before self */
 
-+#define DT_FILTER       0x7fffffff      /* Shared object to get values from */
 
-+#define DT_EXTRATAGIDX(tag)	((Elf32_Word)-((Elf32_Sword) (tag) <<1>>1)-1)
 
-+#define DT_EXTRANUM	3
 
-+
 
-+/* Values of `d_un.d_val' in the DT_FLAGS entry.  */
 
-+#define DF_ORIGIN	0x00000001	/* Object may use DF_ORIGIN */
 
-+#define DF_SYMBOLIC	0x00000002	/* Symbol resolutions starts here */
 
-+#define DF_TEXTREL	0x00000004	/* Object contains text relocations */
 
-+#define DF_BIND_NOW	0x00000008	/* No lazy binding for this object */
 
-+#define DF_STATIC_TLS	0x00000010	/* Module uses the static TLS model */
 
-+
 
-+/* State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1
 
-+   entry in the dynamic section.  */
 
-+#define DF_1_NOW	0x00000001	/* Set RTLD_NOW for this object.  */
 
-+#define DF_1_GLOBAL	0x00000002	/* Set RTLD_GLOBAL for this object.  */
 
-+#define DF_1_GROUP	0x00000004	/* Set RTLD_GROUP for this object.  */
 
-+#define DF_1_NODELETE	0x00000008	/* Set RTLD_NODELETE for this object.*/
 
-+#define DF_1_LOADFLTR	0x00000010	/* Trigger filtee loading at runtime.*/
 
-+#define DF_1_INITFIRST	0x00000020	/* Set RTLD_INITFIRST for this object*/
 
-+#define DF_1_NOOPEN	0x00000040	/* Set RTLD_NOOPEN for this object.  */
 
-+#define DF_1_ORIGIN	0x00000080	/* $ORIGIN must be handled.  */
 
-+#define DF_1_DIRECT	0x00000100	/* Direct binding enabled.  */
 
-+#define DF_1_TRANS	0x00000200
 
-+#define DF_1_INTERPOSE	0x00000400	/* Object is used to interpose.  */
 
-+#define DF_1_NODEFLIB	0x00000800	/* Ignore default lib search path.  */
 
-+#define DF_1_NODUMP	0x00001000	/* Object can't be dldump'ed.  */
 
-+#define DF_1_CONFALT	0x00002000	/* Configuration alternative created.*/
 
-+#define DF_1_ENDFILTEE	0x00004000	/* Filtee terminates filters search. */
 
-+#define	DF_1_DISPRELDNE	0x00008000	/* Disp reloc applied at build time. */
 
-+#define	DF_1_DISPRELPND	0x00010000	/* Disp reloc applied at run-time.  */
 
-+
 
-+/* Flags for the feature selection in DT_FEATURE_1.  */
 
-+#define DTF_1_PARINIT	0x00000001
 
-+#define DTF_1_CONFEXP	0x00000002
 
-+
 
-+/* Flags in the DT_POSFLAG_1 entry effecting only the next DT_* entry.  */
 
-+#define DF_P1_LAZYLOAD	0x00000001	/* Lazyload following object.  */
 
-+#define DF_P1_GROUPPERM	0x00000002	/* Symbols from next object are not
 
-+					   generally available.  */
 
-+
 
-+/* Version definition sections.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Half	vd_version;		/* Version revision */
 
-+  Elf32_Half	vd_flags;		/* Version information */
 
-+  Elf32_Half	vd_ndx;			/* Version Index */
 
-+  Elf32_Half	vd_cnt;			/* Number of associated aux entries */
 
-+  Elf32_Word	vd_hash;		/* Version name hash value */
 
-+  Elf32_Word	vd_aux;			/* Offset in bytes to verdaux array */
 
-+  Elf32_Word	vd_next;		/* Offset in bytes to next verdef
 
-+					   entry */
 
-+} Elf32_Verdef;
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Half	vd_version;		/* Version revision */
 
-+  Elf64_Half	vd_flags;		/* Version information */
 
-+  Elf64_Half	vd_ndx;			/* Version Index */
 
-+  Elf64_Half	vd_cnt;			/* Number of associated aux entries */
 
-+  Elf64_Word	vd_hash;		/* Version name hash value */
 
-+  Elf64_Word	vd_aux;			/* Offset in bytes to verdaux array */
 
-+  Elf64_Word	vd_next;		/* Offset in bytes to next verdef
 
-+					   entry */
 
-+} Elf64_Verdef;
 
-+
 
-+
 
-+/* Legal values for vd_version (version revision).  */
 
-+#define VER_DEF_NONE	0		/* No version */
 
-+#define VER_DEF_CURRENT	1		/* Current version */
 
-+#define VER_DEF_NUM	2		/* Given version number */
 
-+
 
-+/* Legal values for vd_flags (version information flags).  */
 
-+#define VER_FLG_BASE	0x1		/* Version definition of file itself */
 
-+#define VER_FLG_WEAK	0x2		/* Weak version identifier */
 
-+
 
-+/* Versym symbol index values.  */
 
-+#define	VER_NDX_LOCAL		0	/* Symbol is local.  */
 
-+#define	VER_NDX_GLOBAL		1	/* Symbol is global.  */
 
-+#define	VER_NDX_LORESERVE	0xff00	/* Beginning of reserved entries.  */
 
-+#define	VER_NDX_ELIMINATE	0xff01	/* Symbol is to be eliminated.  */
 
-+
 
-+/* Auxialiary version information.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Word	vda_name;		/* Version or dependency names */
 
-+  Elf32_Word	vda_next;		/* Offset in bytes to next verdaux
 
-+					   entry */
 
-+} Elf32_Verdaux;
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Word	vda_name;		/* Version or dependency names */
 
-+  Elf64_Word	vda_next;		/* Offset in bytes to next verdaux
 
-+					   entry */
 
-+} Elf64_Verdaux;
 
-+
 
-+
 
-+/* Version dependency section.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Half	vn_version;		/* Version of structure */
 
-+  Elf32_Half	vn_cnt;			/* Number of associated aux entries */
 
-+  Elf32_Word	vn_file;		/* Offset of filename for this
 
-+					   dependency */
 
-+  Elf32_Word	vn_aux;			/* Offset in bytes to vernaux array */
 
-+  Elf32_Word	vn_next;		/* Offset in bytes to next verneed
 
-+					   entry */
 
-+} Elf32_Verneed;
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Half	vn_version;		/* Version of structure */
 
-+  Elf64_Half	vn_cnt;			/* Number of associated aux entries */
 
-+  Elf64_Word	vn_file;		/* Offset of filename for this
 
-+					   dependency */
 
-+  Elf64_Word	vn_aux;			/* Offset in bytes to vernaux array */
 
-+  Elf64_Word	vn_next;		/* Offset in bytes to next verneed
 
-+					   entry */
 
-+} Elf64_Verneed;
 
-+
 
-+
 
-+/* Legal values for vn_version (version revision).  */
 
-+#define VER_NEED_NONE	 0		/* No version */
 
-+#define VER_NEED_CURRENT 1		/* Current version */
 
-+#define VER_NEED_NUM	 2		/* Given version number */
 
-+
 
-+/* Auxiliary needed version information.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Word	vna_hash;		/* Hash value of dependency name */
 
-+  Elf32_Half	vna_flags;		/* Dependency specific information */
 
-+  Elf32_Half	vna_other;		/* Unused */
 
-+  Elf32_Word	vna_name;		/* Dependency name string offset */
 
-+  Elf32_Word	vna_next;		/* Offset in bytes to next vernaux
 
-+					   entry */
 
-+} Elf32_Vernaux;
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Word	vna_hash;		/* Hash value of dependency name */
 
-+  Elf64_Half	vna_flags;		/* Dependency specific information */
 
-+  Elf64_Half	vna_other;		/* Unused */
 
-+  Elf64_Word	vna_name;		/* Dependency name string offset */
 
-+  Elf64_Word	vna_next;		/* Offset in bytes to next vernaux
 
-+					   entry */
 
-+} Elf64_Vernaux;
 
-+
 
-+
 
-+/* Legal values for vna_flags.  */
 
-+#define VER_FLG_WEAK	0x2		/* Weak version identifier */
 
-+
 
-+
 
-+/* Auxiliary vector.  */
 
-+
 
-+/* This vector is normally only used by the program interpreter.  The
 
-+   usual definition in an ABI supplement uses the name auxv_t.  The
 
-+   vector is not usually defined in a standard <elf.h> file, but it
 
-+   can't hurt.  We rename it to avoid conflicts.  The sizes of these
 
-+   types are an arrangement between the exec server and the program
 
-+   interpreter, so we don't fully specify them here.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  uint32_t a_type;		/* Entry type */
 
-+  union
 
-+    {
 
-+      uint32_t a_val;		/* Integer value */
 
-+      /* We use to have pointer elements added here.  We cannot do that,
 
-+	 though, since it does not work when using 32-bit definitions
 
-+	 on 64-bit platforms and vice versa.  */
 
-+    } a_un;
 
-+} Elf32_auxv_t;
 
-+
 
-+typedef struct
 
-+{
 
-+  uint64_t a_type;		/* Entry type */
 
-+  union
 
-+    {
 
-+      uint64_t a_val;		/* Integer value */
 
-+      /* We use to have pointer elements added here.  We cannot do that,
 
-+	 though, since it does not work when using 32-bit definitions
 
-+	 on 64-bit platforms and vice versa.  */
 
-+    } a_un;
 
-+} Elf64_auxv_t;
 
-+
 
-+/* Legal values for a_type (entry type).  */
 
-+
 
-+#define AT_NULL		0		/* End of vector */
 
-+#define AT_IGNORE	1		/* Entry should be ignored */
 
-+#define AT_EXECFD	2		/* File descriptor of program */
 
-+#define AT_PHDR		3		/* Program headers for program */
 
-+#define AT_PHENT	4		/* Size of program header entry */
 
-+#define AT_PHNUM	5		/* Number of program headers */
 
-+#define AT_PAGESZ	6		/* System page size */
 
-+#define AT_BASE		7		/* Base address of interpreter */
 
-+#define AT_FLAGS	8		/* Flags */
 
-+#define AT_ENTRY	9		/* Entry point of program */
 
-+#define AT_NOTELF	10		/* Program is not ELF */
 
-+#define AT_UID		11		/* Real uid */
 
-+#define AT_EUID		12		/* Effective uid */
 
-+#define AT_GID		13		/* Real gid */
 
-+#define AT_EGID		14		/* Effective gid */
 
-+#define AT_CLKTCK	17		/* Frequency of times() */
 
-+
 
-+/* Some more special a_type values describing the hardware.  */
 
-+#define AT_PLATFORM	15		/* String identifying platform.  */
 
-+#define AT_HWCAP	16		/* Machine dependent hints about
 
-+					   processor capabilities.  */
 
-+
 
-+/* This entry gives some information about the FPU initialization
 
-+   performed by the kernel.  */
 
-+#define AT_FPUCW	18		/* Used FPU control word.  */
 
-+
 
-+/* Cache block sizes.  */
 
-+#define AT_DCACHEBSIZE	19		/* Data cache block size.  */
 
-+#define AT_ICACHEBSIZE	20		/* Instruction cache block size.  */
 
-+#define AT_UCACHEBSIZE	21		/* Unified cache block size.  */
 
-+
 
-+/* A special ignored value for PPC, used by the kernel to control the
 
-+   interpretation of the AUXV. Must be > 16.  */
 
-+#define AT_IGNOREPPC	22		/* Entry should be ignored.  */
 
-+
 
-+#define	AT_SECURE	23		/* Boolean, was exec setuid-like?  */
 
-+
 
-+#define AT_BASE_PLATFORM 24		/* String identifying real platforms.*/
 
-+
 
-+#define AT_RANDOM	25		/* Address of 16 random bytes.  */
 
-+
 
-+#define AT_EXECFN	31		/* Filename of executable.  */
 
-+
 
-+/* Pointer to the global system page used for system calls and other
 
-+   nice things.  */
 
-+#define AT_SYSINFO	32
 
-+#define AT_SYSINFO_EHDR	33
 
-+
 
-+/* Shapes of the caches.  Bits 0-3 contains associativity; bits 4-7 contains
 
-+   log2 of line size; mask those to get cache size.  */
 
-+#define AT_L1I_CACHESHAPE	34
 
-+#define AT_L1D_CACHESHAPE	35
 
-+#define AT_L2_CACHESHAPE	36
 
-+#define AT_L3_CACHESHAPE	37
 
-+
 
-+/* Note section contents.  Each entry in the note section begins with
 
-+   a header of a fixed form.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Word n_namesz;			/* Length of the note's name.  */
 
-+  Elf32_Word n_descsz;			/* Length of the note's descriptor.  */
 
-+  Elf32_Word n_type;			/* Type of the note.  */
 
-+} Elf32_Nhdr;
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Word n_namesz;			/* Length of the note's name.  */
 
-+  Elf64_Word n_descsz;			/* Length of the note's descriptor.  */
 
-+  Elf64_Word n_type;			/* Type of the note.  */
 
-+} Elf64_Nhdr;
 
-+
 
-+/* Known names of notes.  */
 
-+
 
-+/* Solaris entries in the note section have this name.  */
 
-+#define ELF_NOTE_SOLARIS	"SUNW Solaris"
 
-+
 
-+/* Note entries for GNU systems have this name.  */
 
-+#define ELF_NOTE_GNU		"GNU"
 
-+
 
-+
 
-+/* Defined types of notes for Solaris.  */
 
-+
 
-+/* Value of descriptor (one word) is desired pagesize for the binary.  */
 
-+#define ELF_NOTE_PAGESIZE_HINT	1
 
-+
 
-+
 
-+/* Defined note types for GNU systems.  */
 
-+
 
-+/* ABI information.  The descriptor consists of words:
 
-+   word 0: OS descriptor
 
-+   word 1: major version of the ABI
 
-+   word 2: minor version of the ABI
 
-+   word 3: subminor version of the ABI
 
-+*/
 
-+#define NT_GNU_ABI_TAG	1
 
-+#define ELF_NOTE_ABI	NT_GNU_ABI_TAG /* Old name.  */
 
-+
 
-+/* Known OSes.  These values can appear in word 0 of an
 
-+   NT_GNU_ABI_TAG note section entry.  */
 
-+#define ELF_NOTE_OS_LINUX	0
 
-+#define ELF_NOTE_OS_GNU		1
 
-+#define ELF_NOTE_OS_SOLARIS2	2
 
-+#define ELF_NOTE_OS_FREEBSD	3
 
-+
 
-+/* Synthetic hwcap information.  The descriptor begins with two words:
 
-+   word 0: number of entries
 
-+   word 1: bitmask of enabled entries
 
-+   Then follow variable-length entries, one byte followed by a
 
-+   '\0'-terminated hwcap name string.  The byte gives the bit
 
-+   number to test if enabled, (1U << bit) & bitmask.  */
 
-+#define NT_GNU_HWCAP	2
 
-+
 
-+/* Build ID bits as generated by ld --build-id.
 
-+   The descriptor consists of any nonzero number of bytes.  */
 
-+#define NT_GNU_BUILD_ID	3
 
-+
 
-+/* Version note generated by GNU gold containing a version string.  */
 
-+#define NT_GNU_GOLD_VERSION	4
 
-+
 
-+
 
-+/* Move records.  */
 
-+typedef struct
 
-+{
 
-+  Elf32_Xword m_value;		/* Symbol value.  */
 
-+  Elf32_Word m_info;		/* Size and index.  */
 
-+  Elf32_Word m_poffset;		/* Symbol offset.  */
 
-+  Elf32_Half m_repeat;		/* Repeat count.  */
 
-+  Elf32_Half m_stride;		/* Stride info.  */
 
-+} Elf32_Move;
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Xword m_value;		/* Symbol value.  */
 
-+  Elf64_Xword m_info;		/* Size and index.  */
 
-+  Elf64_Xword m_poffset;	/* Symbol offset.  */
 
-+  Elf64_Half m_repeat;		/* Repeat count.  */
 
-+  Elf64_Half m_stride;		/* Stride info.  */
 
-+} Elf64_Move;
 
-+
 
-+/* Macro to construct move records.  */
 
-+#define ELF32_M_SYM(info)	((info) >> 8)
 
-+#define ELF32_M_SIZE(info)	((unsigned char) (info))
 
-+#define ELF32_M_INFO(sym, size)	(((sym) << 8) + (unsigned char) (size))
 
-+
 
-+#define ELF64_M_SYM(info)	ELF32_M_SYM (info)
 
-+#define ELF64_M_SIZE(info)	ELF32_M_SIZE (info)
 
-+#define ELF64_M_INFO(sym, size)	ELF32_M_INFO (sym, size)
 
-+
 
-+
 
-+/* Motorola 68k specific definitions.  */
 
-+
 
-+/* Values for Elf32_Ehdr.e_flags.  */
 
-+#define EF_CPU32	0x00810000
 
-+
 
-+/* m68k relocs.  */
 
-+
 
-+#define R_68K_NONE	0		/* No reloc */
 
-+#define R_68K_32	1		/* Direct 32 bit  */
 
-+#define R_68K_16	2		/* Direct 16 bit  */
 
-+#define R_68K_8		3		/* Direct 8 bit  */
 
-+#define R_68K_PC32	4		/* PC relative 32 bit */
 
-+#define R_68K_PC16	5		/* PC relative 16 bit */
 
-+#define R_68K_PC8	6		/* PC relative 8 bit */
 
-+#define R_68K_GOT32	7		/* 32 bit PC relative GOT entry */
 
-+#define R_68K_GOT16	8		/* 16 bit PC relative GOT entry */
 
-+#define R_68K_GOT8	9		/* 8 bit PC relative GOT entry */
 
-+#define R_68K_GOT32O	10		/* 32 bit GOT offset */
 
-+#define R_68K_GOT16O	11		/* 16 bit GOT offset */
 
-+#define R_68K_GOT8O	12		/* 8 bit GOT offset */
 
-+#define R_68K_PLT32	13		/* 32 bit PC relative PLT address */
 
-+#define R_68K_PLT16	14		/* 16 bit PC relative PLT address */
 
-+#define R_68K_PLT8	15		/* 8 bit PC relative PLT address */
 
-+#define R_68K_PLT32O	16		/* 32 bit PLT offset */
 
-+#define R_68K_PLT16O	17		/* 16 bit PLT offset */
 
-+#define R_68K_PLT8O	18		/* 8 bit PLT offset */
 
-+#define R_68K_COPY	19		/* Copy symbol at runtime */
 
-+#define R_68K_GLOB_DAT	20		/* Create GOT entry */
 
-+#define R_68K_JMP_SLOT	21		/* Create PLT entry */
 
-+#define R_68K_RELATIVE	22		/* Adjust by program base */
 
-+#define R_68K_TLS_GD32      25          /* 32 bit GOT offset for GD */
 
-+#define R_68K_TLS_GD16      26          /* 16 bit GOT offset for GD */
 
-+#define R_68K_TLS_GD8       27          /* 8 bit GOT offset for GD */
 
-+#define R_68K_TLS_LDM32     28          /* 32 bit GOT offset for LDM */
 
-+#define R_68K_TLS_LDM16     29          /* 16 bit GOT offset for LDM */
 
-+#define R_68K_TLS_LDM8      30          /* 8 bit GOT offset for LDM */
 
-+#define R_68K_TLS_LDO32     31          /* 32 bit module-relative offset */
 
-+#define R_68K_TLS_LDO16     32          /* 16 bit module-relative offset */
 
-+#define R_68K_TLS_LDO8      33          /* 8 bit module-relative offset */
 
-+#define R_68K_TLS_IE32      34          /* 32 bit GOT offset for IE */
 
-+#define R_68K_TLS_IE16      35          /* 16 bit GOT offset for IE */
 
-+#define R_68K_TLS_IE8       36          /* 8 bit GOT offset for IE */
 
-+#define R_68K_TLS_LE32      37          /* 32 bit offset relative to
 
-+					   static TLS block */
 
-+#define R_68K_TLS_LE16      38          /* 16 bit offset relative to
 
-+					   static TLS block */
 
-+#define R_68K_TLS_LE8       39          /* 8 bit offset relative to
 
-+					   static TLS block */
 
-+#define R_68K_TLS_DTPMOD32  40          /* 32 bit module number */
 
-+#define R_68K_TLS_DTPREL32  41          /* 32 bit module-relative offset */
 
-+#define R_68K_TLS_TPREL32   42          /* 32 bit TP-relative offset */
 
-+/* Keep this the last entry.  */
 
-+#define R_68K_NUM	43
 
-+
 
-+/* Intel 80386 specific definitions.  */
 
-+
 
-+/* i386 relocs.  */
 
-+
 
-+#define R_386_NONE	   0		/* No reloc */
 
-+#define R_386_32	   1		/* Direct 32 bit  */
 
-+#define R_386_PC32	   2		/* PC relative 32 bit */
 
-+#define R_386_GOT32	   3		/* 32 bit GOT entry */
 
-+#define R_386_PLT32	   4		/* 32 bit PLT address */
 
-+#define R_386_COPY	   5		/* Copy symbol at runtime */
 
-+#define R_386_GLOB_DAT	   6		/* Create GOT entry */
 
-+#define R_386_JMP_SLOT	   7		/* Create PLT entry */
 
-+#define R_386_RELATIVE	   8		/* Adjust by program base */
 
-+#define R_386_GOTOFF	   9		/* 32 bit offset to GOT */
 
-+#define R_386_GOTPC	   10		/* 32 bit PC relative offset to GOT */
 
-+#define R_386_32PLT	   11
 
-+#define R_386_TLS_TPOFF	   14		/* Offset in static TLS block */
 
-+#define R_386_TLS_IE	   15		/* Address of GOT entry for static TLS
 
-+					   block offset */
 
-+#define R_386_TLS_GOTIE	   16		/* GOT entry for static TLS block
 
-+					   offset */
 
-+#define R_386_TLS_LE	   17		/* Offset relative to static TLS
 
-+					   block */
 
-+#define R_386_TLS_GD	   18		/* Direct 32 bit for GNU version of
 
-+					   general dynamic thread local data */
 
-+#define R_386_TLS_LDM	   19		/* Direct 32 bit for GNU version of
 
-+					   local dynamic thread local data
 
-+					   in LE code */
 
-+#define R_386_16	   20
 
-+#define R_386_PC16	   21
 
-+#define R_386_8		   22
 
-+#define R_386_PC8	   23
 
-+#define R_386_TLS_GD_32	   24		/* Direct 32 bit for general dynamic
 
-+					   thread local data */
 
-+#define R_386_TLS_GD_PUSH  25		/* Tag for pushl in GD TLS code */
 
-+#define R_386_TLS_GD_CALL  26		/* Relocation for call to
 
-+					   __tls_get_addr() */
 
-+#define R_386_TLS_GD_POP   27		/* Tag for popl in GD TLS code */
 
-+#define R_386_TLS_LDM_32   28		/* Direct 32 bit for local dynamic
 
-+					   thread local data in LE code */
 
-+#define R_386_TLS_LDM_PUSH 29		/* Tag for pushl in LDM TLS code */
 
-+#define R_386_TLS_LDM_CALL 30		/* Relocation for call to
 
-+					   __tls_get_addr() in LDM code */
 
-+#define R_386_TLS_LDM_POP  31		/* Tag for popl in LDM TLS code */
 
-+#define R_386_TLS_LDO_32   32		/* Offset relative to TLS block */
 
-+#define R_386_TLS_IE_32	   33		/* GOT entry for negated static TLS
 
-+					   block offset */
 
-+#define R_386_TLS_LE_32	   34		/* Negated offset relative to static
 
-+					   TLS block */
 
-+#define R_386_TLS_DTPMOD32 35		/* ID of module containing symbol */
 
-+#define R_386_TLS_DTPOFF32 36		/* Offset in TLS block */
 
-+#define R_386_TLS_TPOFF32  37		/* Negated offset in static TLS block */
 
-+/* 38? */
 
-+#define R_386_TLS_GOTDESC  39		/* GOT offset for TLS descriptor.  */
 
-+#define R_386_TLS_DESC_CALL 40		/* Marker of call through TLS
 
-+					   descriptor for
 
-+					   relaxation.  */
 
-+#define R_386_TLS_DESC     41		/* TLS descriptor containing
 
-+					   pointer to code and to
 
-+					   argument, returning the TLS
 
-+					   offset for the symbol.  */
 
-+#define R_386_IRELATIVE	   42		/* Adjust indirectly by program base */
 
-+/* Keep this the last entry.  */
 
-+#define R_386_NUM	   43
 
-+
 
-+/* SUN SPARC specific definitions.  */
 
-+
 
-+/* Legal values for ST_TYPE subfield of st_info (symbol type).  */
 
-+
 
-+#define STT_SPARC_REGISTER	13	/* Global register reserved to app. */
 
-+
 
-+/* Values for Elf64_Ehdr.e_flags.  */
 
-+
 
-+#define EF_SPARCV9_MM		3
 
-+#define EF_SPARCV9_TSO		0
 
-+#define EF_SPARCV9_PSO		1
 
-+#define EF_SPARCV9_RMO		2
 
-+#define EF_SPARC_LEDATA		0x800000 /* little endian data */
 
-+#define EF_SPARC_EXT_MASK	0xFFFF00
 
-+#define EF_SPARC_32PLUS		0x000100 /* generic V8+ features */
 
-+#define EF_SPARC_SUN_US1	0x000200 /* Sun UltraSPARC1 extensions */
 
-+#define EF_SPARC_HAL_R1		0x000400 /* HAL R1 extensions */
 
-+#define EF_SPARC_SUN_US3	0x000800 /* Sun UltraSPARCIII extensions */
 
-+
 
-+/* SPARC relocs.  */
 
-+
 
-+#define R_SPARC_NONE		0	/* No reloc */
 
-+#define R_SPARC_8		1	/* Direct 8 bit */
 
-+#define R_SPARC_16		2	/* Direct 16 bit */
 
-+#define R_SPARC_32		3	/* Direct 32 bit */
 
-+#define R_SPARC_DISP8		4	/* PC relative 8 bit */
 
-+#define R_SPARC_DISP16		5	/* PC relative 16 bit */
 
-+#define R_SPARC_DISP32		6	/* PC relative 32 bit */
 
-+#define R_SPARC_WDISP30		7	/* PC relative 30 bit shifted */
 
-+#define R_SPARC_WDISP22		8	/* PC relative 22 bit shifted */
 
-+#define R_SPARC_HI22		9	/* High 22 bit */
 
-+#define R_SPARC_22		10	/* Direct 22 bit */
 
-+#define R_SPARC_13		11	/* Direct 13 bit */
 
-+#define R_SPARC_LO10		12	/* Truncated 10 bit */
 
-+#define R_SPARC_GOT10		13	/* Truncated 10 bit GOT entry */
 
-+#define R_SPARC_GOT13		14	/* 13 bit GOT entry */
 
-+#define R_SPARC_GOT22		15	/* 22 bit GOT entry shifted */
 
-+#define R_SPARC_PC10		16	/* PC relative 10 bit truncated */
 
-+#define R_SPARC_PC22		17	/* PC relative 22 bit shifted */
 
-+#define R_SPARC_WPLT30		18	/* 30 bit PC relative PLT address */
 
-+#define R_SPARC_COPY		19	/* Copy symbol at runtime */
 
-+#define R_SPARC_GLOB_DAT	20	/* Create GOT entry */
 
-+#define R_SPARC_JMP_SLOT	21	/* Create PLT entry */
 
-+#define R_SPARC_RELATIVE	22	/* Adjust by program base */
 
-+#define R_SPARC_UA32		23	/* Direct 32 bit unaligned */
 
-+
 
-+/* Additional Sparc64 relocs.  */
 
-+
 
-+#define R_SPARC_PLT32		24	/* Direct 32 bit ref to PLT entry */
 
-+#define R_SPARC_HIPLT22		25	/* High 22 bit PLT entry */
 
-+#define R_SPARC_LOPLT10		26	/* Truncated 10 bit PLT entry */
 
-+#define R_SPARC_PCPLT32		27	/* PC rel 32 bit ref to PLT entry */
 
-+#define R_SPARC_PCPLT22		28	/* PC rel high 22 bit PLT entry */
 
-+#define R_SPARC_PCPLT10		29	/* PC rel trunc 10 bit PLT entry */
 
-+#define R_SPARC_10		30	/* Direct 10 bit */
 
-+#define R_SPARC_11		31	/* Direct 11 bit */
 
-+#define R_SPARC_64		32	/* Direct 64 bit */
 
-+#define R_SPARC_OLO10		33	/* 10bit with secondary 13bit addend */
 
-+#define R_SPARC_HH22		34	/* Top 22 bits of direct 64 bit */
 
-+#define R_SPARC_HM10		35	/* High middle 10 bits of ... */
 
-+#define R_SPARC_LM22		36	/* Low middle 22 bits of ... */
 
-+#define R_SPARC_PC_HH22		37	/* Top 22 bits of pc rel 64 bit */
 
-+#define R_SPARC_PC_HM10		38	/* High middle 10 bit of ... */
 
-+#define R_SPARC_PC_LM22		39	/* Low miggle 22 bits of ... */
 
-+#define R_SPARC_WDISP16		40	/* PC relative 16 bit shifted */
 
-+#define R_SPARC_WDISP19		41	/* PC relative 19 bit shifted */
 
-+#define R_SPARC_GLOB_JMP	42	/* was part of v9 ABI but was removed */
 
-+#define R_SPARC_7		43	/* Direct 7 bit */
 
-+#define R_SPARC_5		44	/* Direct 5 bit */
 
-+#define R_SPARC_6		45	/* Direct 6 bit */
 
-+#define R_SPARC_DISP64		46	/* PC relative 64 bit */
 
-+#define R_SPARC_PLT64		47	/* Direct 64 bit ref to PLT entry */
 
-+#define R_SPARC_HIX22		48	/* High 22 bit complemented */
 
-+#define R_SPARC_LOX10		49	/* Truncated 11 bit complemented */
 
-+#define R_SPARC_H44		50	/* Direct high 12 of 44 bit */
 
-+#define R_SPARC_M44		51	/* Direct mid 22 of 44 bit */
 
-+#define R_SPARC_L44		52	/* Direct low 10 of 44 bit */
 
-+#define R_SPARC_REGISTER	53	/* Global register usage */
 
-+#define R_SPARC_UA64		54	/* Direct 64 bit unaligned */
 
-+#define R_SPARC_UA16		55	/* Direct 16 bit unaligned */
 
-+#define R_SPARC_TLS_GD_HI22	56
 
-+#define R_SPARC_TLS_GD_LO10	57
 
-+#define R_SPARC_TLS_GD_ADD	58
 
-+#define R_SPARC_TLS_GD_CALL	59
 
-+#define R_SPARC_TLS_LDM_HI22	60
 
-+#define R_SPARC_TLS_LDM_LO10	61
 
-+#define R_SPARC_TLS_LDM_ADD	62
 
-+#define R_SPARC_TLS_LDM_CALL	63
 
-+#define R_SPARC_TLS_LDO_HIX22	64
 
-+#define R_SPARC_TLS_LDO_LOX10	65
 
-+#define R_SPARC_TLS_LDO_ADD	66
 
-+#define R_SPARC_TLS_IE_HI22	67
 
-+#define R_SPARC_TLS_IE_LO10	68
 
-+#define R_SPARC_TLS_IE_LD	69
 
-+#define R_SPARC_TLS_IE_LDX	70
 
-+#define R_SPARC_TLS_IE_ADD	71
 
-+#define R_SPARC_TLS_LE_HIX22	72
 
-+#define R_SPARC_TLS_LE_LOX10	73
 
-+#define R_SPARC_TLS_DTPMOD32	74
 
-+#define R_SPARC_TLS_DTPMOD64	75
 
-+#define R_SPARC_TLS_DTPOFF32	76
 
-+#define R_SPARC_TLS_DTPOFF64	77
 
-+#define R_SPARC_TLS_TPOFF32	78
 
-+#define R_SPARC_TLS_TPOFF64	79
 
-+#define R_SPARC_GOTDATA_HIX22	80
 
-+#define R_SPARC_GOTDATA_LOX10	81
 
-+#define R_SPARC_GOTDATA_OP_HIX22	82
 
-+#define R_SPARC_GOTDATA_OP_LOX10	83
 
-+#define R_SPARC_GOTDATA_OP	84
 
-+#define R_SPARC_H34		85
 
-+#define R_SPARC_SIZE32		86
 
-+#define R_SPARC_SIZE64		87
 
-+#define R_SPARC_WDISP10		88
 
-+#define R_SPARC_JMP_IREL	248
 
-+#define R_SPARC_IRELATIVE	249
 
-+#define R_SPARC_GNU_VTINHERIT	250
 
-+#define R_SPARC_GNU_VTENTRY	251
 
-+#define R_SPARC_REV32		252
 
-+/* Keep this the last entry.  */
 
-+#define R_SPARC_NUM		253
 
-+
 
-+/* For Sparc64, legal values for d_tag of Elf64_Dyn.  */
 
-+
 
-+#define DT_SPARC_REGISTER 0x70000001
 
-+#define DT_SPARC_NUM	2
 
-+
 
-+/* MIPS R3000 specific definitions.  */
 
-+
 
-+/* Legal values for e_flags field of Elf32_Ehdr.  */
 
-+
 
-+#define EF_MIPS_NOREORDER   1		/* A .noreorder directive was used */
 
-+#define EF_MIPS_PIC	    2		/* Contains PIC code */
 
-+#define EF_MIPS_CPIC	    4		/* Uses PIC calling sequence */
 
-+#define EF_MIPS_XGOT	    8
 
-+#define EF_MIPS_64BIT_WHIRL 16
 
-+#define EF_MIPS_ABI2	    32
 
-+#define EF_MIPS_ABI_ON32    64
 
-+#define EF_MIPS_ARCH	    0xf0000000	/* MIPS architecture level */
 
-+
 
-+/* Legal values for MIPS architecture level.  */
 
-+
 
-+#define EF_MIPS_ARCH_1	    0x00000000	/* -mips1 code.  */
 
-+#define EF_MIPS_ARCH_2	    0x10000000	/* -mips2 code.  */
 
-+#define EF_MIPS_ARCH_3	    0x20000000	/* -mips3 code.  */
 
-+#define EF_MIPS_ARCH_4	    0x30000000	/* -mips4 code.  */
 
-+#define EF_MIPS_ARCH_5	    0x40000000	/* -mips5 code.  */
 
-+#define EF_MIPS_ARCH_32	    0x60000000	/* MIPS32 code.  */
 
-+#define EF_MIPS_ARCH_64	    0x70000000	/* MIPS64 code.  */
 
-+
 
-+/* The following are non-official names and should not be used.  */
 
-+
 
-+#define E_MIPS_ARCH_1	  0x00000000	/* -mips1 code.  */
 
-+#define E_MIPS_ARCH_2	  0x10000000	/* -mips2 code.  */
 
-+#define E_MIPS_ARCH_3	  0x20000000	/* -mips3 code.  */
 
-+#define E_MIPS_ARCH_4	  0x30000000	/* -mips4 code.  */
 
-+#define E_MIPS_ARCH_5	  0x40000000	/* -mips5 code.  */
 
-+#define E_MIPS_ARCH_32	  0x60000000	/* MIPS32 code.  */
 
-+#define E_MIPS_ARCH_64	  0x70000000	/* MIPS64 code.  */
 
-+
 
-+/* Special section indices.  */
 
-+
 
-+#define SHN_MIPS_ACOMMON    0xff00	/* Allocated common symbols */
 
-+#define SHN_MIPS_TEXT	    0xff01	/* Allocated test symbols.  */
 
-+#define SHN_MIPS_DATA	    0xff02	/* Allocated data symbols.  */
 
-+#define SHN_MIPS_SCOMMON    0xff03	/* Small common symbols */
 
-+#define SHN_MIPS_SUNDEFINED 0xff04	/* Small undefined symbols */
 
-+
 
-+/* Legal values for sh_type field of Elf32_Shdr.  */
 
-+
 
-+#define SHT_MIPS_LIBLIST       0x70000000 /* Shared objects used in link */
 
-+#define SHT_MIPS_MSYM	       0x70000001
 
-+#define SHT_MIPS_CONFLICT      0x70000002 /* Conflicting symbols */
 
-+#define SHT_MIPS_GPTAB	       0x70000003 /* Global data area sizes */
 
-+#define SHT_MIPS_UCODE	       0x70000004 /* Reserved for SGI/MIPS compilers */
 
-+#define SHT_MIPS_DEBUG	       0x70000005 /* MIPS ECOFF debugging information*/
 
-+#define SHT_MIPS_REGINFO       0x70000006 /* Register usage information */
 
-+#define SHT_MIPS_PACKAGE       0x70000007
 
-+#define SHT_MIPS_PACKSYM       0x70000008
 
-+#define SHT_MIPS_RELD	       0x70000009
 
-+#define SHT_MIPS_IFACE         0x7000000b
 
-+#define SHT_MIPS_CONTENT       0x7000000c
 
-+#define SHT_MIPS_OPTIONS       0x7000000d /* Miscellaneous options.  */
 
-+#define SHT_MIPS_SHDR	       0x70000010
 
-+#define SHT_MIPS_FDESC	       0x70000011
 
-+#define SHT_MIPS_EXTSYM	       0x70000012
 
-+#define SHT_MIPS_DENSE	       0x70000013
 
-+#define SHT_MIPS_PDESC	       0x70000014
 
-+#define SHT_MIPS_LOCSYM	       0x70000015
 
-+#define SHT_MIPS_AUXSYM	       0x70000016
 
-+#define SHT_MIPS_OPTSYM	       0x70000017
 
-+#define SHT_MIPS_LOCSTR	       0x70000018
 
-+#define SHT_MIPS_LINE	       0x70000019
 
-+#define SHT_MIPS_RFDESC	       0x7000001a
 
-+#define SHT_MIPS_DELTASYM      0x7000001b
 
-+#define SHT_MIPS_DELTAINST     0x7000001c
 
-+#define SHT_MIPS_DELTACLASS    0x7000001d
 
-+#define SHT_MIPS_DWARF         0x7000001e /* DWARF debugging information.  */
 
-+#define SHT_MIPS_DELTADECL     0x7000001f
 
-+#define SHT_MIPS_SYMBOL_LIB    0x70000020
 
-+#define SHT_MIPS_EVENTS	       0x70000021 /* Event section.  */
 
-+#define SHT_MIPS_TRANSLATE     0x70000022
 
-+#define SHT_MIPS_PIXIE	       0x70000023
 
-+#define SHT_MIPS_XLATE	       0x70000024
 
-+#define SHT_MIPS_XLATE_DEBUG   0x70000025
 
-+#define SHT_MIPS_WHIRL	       0x70000026
 
-+#define SHT_MIPS_EH_REGION     0x70000027
 
-+#define SHT_MIPS_XLATE_OLD     0x70000028
 
-+#define SHT_MIPS_PDR_EXCEPTION 0x70000029
 
-+
 
-+/* Legal values for sh_flags field of Elf32_Shdr.  */
 
-+
 
-+#define SHF_MIPS_GPREL	 0x10000000	/* Must be part of global data area */
 
-+#define SHF_MIPS_MERGE	 0x20000000
 
-+#define SHF_MIPS_ADDR	 0x40000000
 
-+#define SHF_MIPS_STRINGS 0x80000000
 
-+#define SHF_MIPS_NOSTRIP 0x08000000
 
-+#define SHF_MIPS_LOCAL	 0x04000000
 
-+#define SHF_MIPS_NAMES	 0x02000000
 
-+#define SHF_MIPS_NODUPE	 0x01000000
 
-+
 
-+
 
-+/* Symbol tables.  */
 
-+
 
-+/* MIPS specific values for `st_other'.  */
 
-+#define STO_MIPS_DEFAULT		0x0
 
-+#define STO_MIPS_INTERNAL		0x1
 
-+#define STO_MIPS_HIDDEN			0x2
 
-+#define STO_MIPS_PROTECTED		0x3
 
-+#define STO_MIPS_PLT			0x8
 
-+#define STO_MIPS_SC_ALIGN_UNUSED	0xff
 
-+
 
-+/* MIPS specific values for `st_info'.  */
 
-+#define STB_MIPS_SPLIT_COMMON		13
 
-+
 
-+/* Entries found in sections of type SHT_MIPS_GPTAB.  */
 
-+
 
-+typedef union
 
-+{
 
-+  struct
 
-+    {
 
-+      Elf32_Word gt_current_g_value;	/* -G value used for compilation */
 
-+      Elf32_Word gt_unused;		/* Not used */
 
-+    } gt_header;			/* First entry in section */
 
-+  struct
 
-+    {
 
-+      Elf32_Word gt_g_value;		/* If this value were used for -G */
 
-+      Elf32_Word gt_bytes;		/* This many bytes would be used */
 
-+    } gt_entry;				/* Subsequent entries in section */
 
-+} Elf32_gptab;
 
-+
 
-+/* Entry found in sections of type SHT_MIPS_REGINFO.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Word	ri_gprmask;		/* General registers used */
 
-+  Elf32_Word	ri_cprmask[4];		/* Coprocessor registers used */
 
-+  Elf32_Sword	ri_gp_value;		/* $gp register value */
 
-+} Elf32_RegInfo;
 
-+
 
-+/* Entries found in sections of type SHT_MIPS_OPTIONS.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  unsigned char kind;		/* Determines interpretation of the
 
-+				   variable part of descriptor.  */
 
-+  unsigned char size;		/* Size of descriptor, including header.  */
 
-+  Elf32_Section section;	/* Section header index of section affected,
 
-+				   0 for global options.  */
 
-+  Elf32_Word info;		/* Kind-specific information.  */
 
-+} Elf_Options;
 
-+
 
-+/* Values for `kind' field in Elf_Options.  */
 
-+
 
-+#define ODK_NULL	0	/* Undefined.  */
 
-+#define ODK_REGINFO	1	/* Register usage information.  */
 
-+#define ODK_EXCEPTIONS	2	/* Exception processing options.  */
 
-+#define ODK_PAD		3	/* Section padding options.  */
 
-+#define ODK_HWPATCH	4	/* Hardware workarounds performed */
 
-+#define ODK_FILL	5	/* record the fill value used by the linker. */
 
-+#define ODK_TAGS	6	/* reserve space for desktop tools to write. */
 
-+#define ODK_HWAND	7	/* HW workarounds.  'AND' bits when merging. */
 
-+#define ODK_HWOR	8	/* HW workarounds.  'OR' bits when merging.  */
 
-+
 
-+/* Values for `info' in Elf_Options for ODK_EXCEPTIONS entries.  */
 
-+
 
-+#define OEX_FPU_MIN	0x1f	/* FPE's which MUST be enabled.  */
 
-+#define OEX_FPU_MAX	0x1f00	/* FPE's which MAY be enabled.  */
 
-+#define OEX_PAGE0	0x10000	/* page zero must be mapped.  */
 
-+#define OEX_SMM		0x20000	/* Force sequential memory mode?  */
 
-+#define OEX_FPDBUG	0x40000	/* Force floating point debug mode?  */
 
-+#define OEX_PRECISEFP	OEX_FPDBUG
 
-+#define OEX_DISMISS	0x80000	/* Dismiss invalid address faults?  */
 
-+
 
-+#define OEX_FPU_INVAL	0x10
 
-+#define OEX_FPU_DIV0	0x08
 
-+#define OEX_FPU_OFLO	0x04
 
-+#define OEX_FPU_UFLO	0x02
 
-+#define OEX_FPU_INEX	0x01
 
-+
 
-+/* Masks for `info' in Elf_Options for an ODK_HWPATCH entry.  */
 
-+
 
-+#define OHW_R4KEOP	0x1	/* R4000 end-of-page patch.  */
 
-+#define OHW_R8KPFETCH	0x2	/* may need R8000 prefetch patch.  */
 
-+#define OHW_R5KEOP	0x4	/* R5000 end-of-page patch.  */
 
-+#define OHW_R5KCVTL	0x8	/* R5000 cvt.[ds].l bug.  clean=1.  */
 
-+
 
-+#define OPAD_PREFIX	0x1
 
-+#define OPAD_POSTFIX	0x2
 
-+#define OPAD_SYMBOL	0x4
 
-+
 
-+/* Entry found in `.options' section.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Word hwp_flags1;	/* Extra flags.  */
 
-+  Elf32_Word hwp_flags2;	/* Extra flags.  */
 
-+} Elf_Options_Hw;
 
-+
 
-+/* Masks for `info' in ElfOptions for ODK_HWAND and ODK_HWOR entries.  */
 
-+
 
-+#define OHWA0_R4KEOP_CHECKED	0x00000001
 
-+#define OHWA1_R4KEOP_CLEAN	0x00000002
 
-+
 
-+/* MIPS relocs.  */
 
-+
 
-+#define R_MIPS_NONE		0	/* No reloc */
 
-+#define R_MIPS_16		1	/* Direct 16 bit */
 
-+#define R_MIPS_32		2	/* Direct 32 bit */
 
-+#define R_MIPS_REL32		3	/* PC relative 32 bit */
 
-+#define R_MIPS_26		4	/* Direct 26 bit shifted */
 
-+#define R_MIPS_HI16		5	/* High 16 bit */
 
-+#define R_MIPS_LO16		6	/* Low 16 bit */
 
-+#define R_MIPS_GPREL16		7	/* GP relative 16 bit */
 
-+#define R_MIPS_LITERAL		8	/* 16 bit literal entry */
 
-+#define R_MIPS_GOT16		9	/* 16 bit GOT entry */
 
-+#define R_MIPS_PC16		10	/* PC relative 16 bit */
 
-+#define R_MIPS_CALL16		11	/* 16 bit GOT entry for function */
 
-+#define R_MIPS_GPREL32		12	/* GP relative 32 bit */
 
-+
 
-+#define R_MIPS_SHIFT5		16
 
-+#define R_MIPS_SHIFT6		17
 
-+#define R_MIPS_64		18
 
-+#define R_MIPS_GOT_DISP		19
 
-+#define R_MIPS_GOT_PAGE		20
 
-+#define R_MIPS_GOT_OFST		21
 
-+#define R_MIPS_GOT_HI16		22
 
-+#define R_MIPS_GOT_LO16		23
 
-+#define R_MIPS_SUB		24
 
-+#define R_MIPS_INSERT_A		25
 
-+#define R_MIPS_INSERT_B		26
 
-+#define R_MIPS_DELETE		27
 
-+#define R_MIPS_HIGHER		28
 
-+#define R_MIPS_HIGHEST		29
 
-+#define R_MIPS_CALL_HI16	30
 
-+#define R_MIPS_CALL_LO16	31
 
-+#define R_MIPS_SCN_DISP		32
 
-+#define R_MIPS_REL16		33
 
-+#define R_MIPS_ADD_IMMEDIATE	34
 
-+#define R_MIPS_PJUMP		35
 
-+#define R_MIPS_RELGOT		36
 
-+#define R_MIPS_JALR		37
 
-+#define R_MIPS_TLS_DTPMOD32	38	/* Module number 32 bit */
 
-+#define R_MIPS_TLS_DTPREL32	39	/* Module-relative offset 32 bit */
 
-+#define R_MIPS_TLS_DTPMOD64	40	/* Module number 64 bit */
 
-+#define R_MIPS_TLS_DTPREL64	41	/* Module-relative offset 64 bit */
 
-+#define R_MIPS_TLS_GD		42	/* 16 bit GOT offset for GD */
 
-+#define R_MIPS_TLS_LDM		43	/* 16 bit GOT offset for LDM */
 
-+#define R_MIPS_TLS_DTPREL_HI16	44	/* Module-relative offset, high 16 bits */
 
-+#define R_MIPS_TLS_DTPREL_LO16	45	/* Module-relative offset, low 16 bits */
 
-+#define R_MIPS_TLS_GOTTPREL	46	/* 16 bit GOT offset for IE */
 
-+#define R_MIPS_TLS_TPREL32	47	/* TP-relative offset, 32 bit */
 
-+#define R_MIPS_TLS_TPREL64	48	/* TP-relative offset, 64 bit */
 
-+#define R_MIPS_TLS_TPREL_HI16	49	/* TP-relative offset, high 16 bits */
 
-+#define R_MIPS_TLS_TPREL_LO16	50	/* TP-relative offset, low 16 bits */
 
-+#define R_MIPS_GLOB_DAT		51
 
-+#define R_MIPS_COPY		126
 
-+#define R_MIPS_JUMP_SLOT        127
 
-+/* Keep this the last entry.  */
 
-+#define R_MIPS_NUM		128
 
-+
 
-+/* Legal values for p_type field of Elf32_Phdr.  */
 
-+
 
-+#define PT_MIPS_REGINFO	0x70000000	/* Register usage information */
 
-+#define PT_MIPS_RTPROC  0x70000001	/* Runtime procedure table. */
 
-+#define PT_MIPS_OPTIONS 0x70000002
 
-+
 
-+/* Special program header types.  */
 
-+
 
-+#define PF_MIPS_LOCAL	0x10000000
 
-+
 
-+/* Legal values for d_tag field of Elf32_Dyn.  */
 
-+
 
-+#define DT_MIPS_RLD_VERSION  0x70000001	/* Runtime linker interface version */
 
-+#define DT_MIPS_TIME_STAMP   0x70000002	/* Timestamp */
 
-+#define DT_MIPS_ICHECKSUM    0x70000003	/* Checksum */
 
-+#define DT_MIPS_IVERSION     0x70000004	/* Version string (string tbl index) */
 
-+#define DT_MIPS_FLAGS	     0x70000005	/* Flags */
 
-+#define DT_MIPS_BASE_ADDRESS 0x70000006	/* Base address */
 
-+#define DT_MIPS_MSYM	     0x70000007
 
-+#define DT_MIPS_CONFLICT     0x70000008	/* Address of CONFLICT section */
 
-+#define DT_MIPS_LIBLIST	     0x70000009	/* Address of LIBLIST section */
 
-+#define DT_MIPS_LOCAL_GOTNO  0x7000000a	/* Number of local GOT entries */
 
-+#define DT_MIPS_CONFLICTNO   0x7000000b	/* Number of CONFLICT entries */
 
-+#define DT_MIPS_LIBLISTNO    0x70000010	/* Number of LIBLIST entries */
 
-+#define DT_MIPS_SYMTABNO     0x70000011	/* Number of DYNSYM entries */
 
-+#define DT_MIPS_UNREFEXTNO   0x70000012	/* First external DYNSYM */
 
-+#define DT_MIPS_GOTSYM	     0x70000013	/* First GOT entry in DYNSYM */
 
-+#define DT_MIPS_HIPAGENO     0x70000014	/* Number of GOT page table entries */
 
-+#define DT_MIPS_RLD_MAP	     0x70000016	/* Address of run time loader map.  */
 
-+#define DT_MIPS_DELTA_CLASS  0x70000017	/* Delta C++ class definition.  */
 
-+#define DT_MIPS_DELTA_CLASS_NO    0x70000018 /* Number of entries in
 
-+						DT_MIPS_DELTA_CLASS.  */
 
-+#define DT_MIPS_DELTA_INSTANCE    0x70000019 /* Delta C++ class instances.  */
 
-+#define DT_MIPS_DELTA_INSTANCE_NO 0x7000001a /* Number of entries in
 
-+						DT_MIPS_DELTA_INSTANCE.  */
 
-+#define DT_MIPS_DELTA_RELOC  0x7000001b /* Delta relocations.  */
 
-+#define DT_MIPS_DELTA_RELOC_NO 0x7000001c /* Number of entries in
 
-+					     DT_MIPS_DELTA_RELOC.  */
 
-+#define DT_MIPS_DELTA_SYM    0x7000001d /* Delta symbols that Delta
 
-+					   relocations refer to.  */
 
-+#define DT_MIPS_DELTA_SYM_NO 0x7000001e /* Number of entries in
 
-+					   DT_MIPS_DELTA_SYM.  */
 
-+#define DT_MIPS_DELTA_CLASSSYM 0x70000020 /* Delta symbols that hold the
 
-+					     class declaration.  */
 
-+#define DT_MIPS_DELTA_CLASSSYM_NO 0x70000021 /* Number of entries in
 
-+						DT_MIPS_DELTA_CLASSSYM.  */
 
-+#define DT_MIPS_CXX_FLAGS    0x70000022 /* Flags indicating for C++ flavor.  */
 
-+#define DT_MIPS_PIXIE_INIT   0x70000023
 
-+#define DT_MIPS_SYMBOL_LIB   0x70000024
 
-+#define DT_MIPS_LOCALPAGE_GOTIDX 0x70000025
 
-+#define DT_MIPS_LOCAL_GOTIDX 0x70000026
 
-+#define DT_MIPS_HIDDEN_GOTIDX 0x70000027
 
-+#define DT_MIPS_PROTECTED_GOTIDX 0x70000028
 
-+#define DT_MIPS_OPTIONS	     0x70000029 /* Address of .options.  */
 
-+#define DT_MIPS_INTERFACE    0x7000002a /* Address of .interface.  */
 
-+#define DT_MIPS_DYNSTR_ALIGN 0x7000002b
 
-+#define DT_MIPS_INTERFACE_SIZE 0x7000002c /* Size of the .interface section. */
 
-+#define DT_MIPS_RLD_TEXT_RESOLVE_ADDR 0x7000002d /* Address of rld_text_rsolve
 
-+						    function stored in GOT.  */
 
-+#define DT_MIPS_PERF_SUFFIX  0x7000002e /* Default suffix of dso to be added
 
-+					   by rld on dlopen() calls.  */
 
-+#define DT_MIPS_COMPACT_SIZE 0x7000002f /* (O32)Size of compact rel section. */
 
-+#define DT_MIPS_GP_VALUE     0x70000030 /* GP value for aux GOTs.  */
 
-+#define DT_MIPS_AUX_DYNAMIC  0x70000031 /* Address of aux .dynamic.  */
 
-+/* The address of .got.plt in an executable using the new non-PIC ABI.  */
 
-+#define DT_MIPS_PLTGOT	     0x70000032
 
-+/* The base of the PLT in an executable using the new non-PIC ABI if that
 
-+   PLT is writable.  For a non-writable PLT, this is omitted or has a zero
 
-+   value.  */
 
-+#define DT_MIPS_RWPLT        0x70000034
 
-+#define DT_MIPS_NUM	     0x35
 
-+
 
-+/* Legal values for DT_MIPS_FLAGS Elf32_Dyn entry.  */
 
-+
 
-+#define RHF_NONE		   0		/* No flags */
 
-+#define RHF_QUICKSTART		   (1 << 0)	/* Use quickstart */
 
-+#define RHF_NOTPOT		   (1 << 1)	/* Hash size not power of 2 */
 
-+#define RHF_NO_LIBRARY_REPLACEMENT (1 << 2)	/* Ignore LD_LIBRARY_PATH */
 
-+#define RHF_NO_MOVE		   (1 << 3)
 
-+#define RHF_SGI_ONLY		   (1 << 4)
 
-+#define RHF_GUARANTEE_INIT	   (1 << 5)
 
-+#define RHF_DELTA_C_PLUS_PLUS	   (1 << 6)
 
-+#define RHF_GUARANTEE_START_INIT   (1 << 7)
 
-+#define RHF_PIXIE		   (1 << 8)
 
-+#define RHF_DEFAULT_DELAY_LOAD	   (1 << 9)
 
-+#define RHF_REQUICKSTART	   (1 << 10)
 
-+#define RHF_REQUICKSTARTED	   (1 << 11)
 
-+#define RHF_CORD		   (1 << 12)
 
-+#define RHF_NO_UNRES_UNDEF	   (1 << 13)
 
-+#define RHF_RLD_ORDER_SAFE	   (1 << 14)
 
-+
 
-+/* Entries found in sections of type SHT_MIPS_LIBLIST.  */
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf32_Word l_name;		/* Name (string table index) */
 
-+  Elf32_Word l_time_stamp;	/* Timestamp */
 
-+  Elf32_Word l_checksum;	/* Checksum */
 
-+  Elf32_Word l_version;		/* Interface version */
 
-+  Elf32_Word l_flags;		/* Flags */
 
-+} Elf32_Lib;
 
-+
 
-+typedef struct
 
-+{
 
-+  Elf64_Word l_name;		/* Name (string table index) */
 
-+  Elf64_Word l_time_stamp;	/* Timestamp */
 
-+  Elf64_Word l_checksum;	/* Checksum */
 
-+  Elf64_Word l_version;		/* Interface version */
 
-+  Elf64_Word l_flags;		/* Flags */
 
-+} Elf64_Lib;
 
-+
 
-+
 
-+/* Legal values for l_flags.  */
 
-+
 
-+#define LL_NONE		  0
 
-+#define LL_EXACT_MATCH	  (1 << 0)	/* Require exact match */
 
-+#define LL_IGNORE_INT_VER (1 << 1)	/* Ignore interface version */
 
-+#define LL_REQUIRE_MINOR  (1 << 2)
 
-+#define LL_EXPORTS	  (1 << 3)
 
-+#define LL_DELAY_LOAD	  (1 << 4)
 
-+#define LL_DELTA	  (1 << 5)
 
-+
 
-+/* Entries found in sections of type SHT_MIPS_CONFLICT.  */
 
-+
 
-+typedef Elf32_Addr Elf32_Conflict;
 
-+
 
-+
 
-+/* HPPA specific definitions.  */
 
-+
 
-+/* Legal values for e_flags field of Elf32_Ehdr.  */
 
-+
 
-+#define EF_PARISC_TRAPNIL	0x00010000 /* Trap nil pointer dereference.  */
 
-+#define EF_PARISC_EXT		0x00020000 /* Program uses arch. extensions. */
 
-+#define EF_PARISC_LSB		0x00040000 /* Program expects little endian. */
 
-+#define EF_PARISC_WIDE		0x00080000 /* Program expects wide mode.  */
 
-+#define EF_PARISC_NO_KABP	0x00100000 /* No kernel assisted branch
 
-+					      prediction.  */
 
-+#define EF_PARISC_LAZYSWAP	0x00400000 /* Allow lazy swapping.  */
 
-+#define EF_PARISC_ARCH		0x0000ffff /* Architecture version.  */
 
-+
 
-+/* Defined values for `e_flags & EF_PARISC_ARCH' are:  */
 
-+
 
-+#define EFA_PARISC_1_0		    0x020b /* PA-RISC 1.0 big-endian.  */
 
-+#define EFA_PARISC_1_1		    0x0210 /* PA-RISC 1.1 big-endian.  */
 
-+#define EFA_PARISC_2_0		    0x0214 /* PA-RISC 2.0 big-endian.  */
 
-+
 
-+/* Additional section indeces.  */
 
-+
 
-+#define SHN_PARISC_ANSI_COMMON	0xff00	   /* Section for tenatively declared
 
-+					      symbols in ANSI C.  */
 
-+#define SHN_PARISC_HUGE_COMMON	0xff01	   /* Common blocks in huge model.  */
 
-+
 
-+/* Legal values for sh_type field of Elf32_Shdr.  */
 
-+
 
-+#define SHT_PARISC_EXT		0x70000000 /* Contains product specific ext. */
 
-+#define SHT_PARISC_UNWIND	0x70000001 /* Unwind information.  */
 
-+#define SHT_PARISC_DOC		0x70000002 /* Debug info for optimized code. */
 
-+
 
-+/* Legal values for sh_flags field of Elf32_Shdr.  */
 
-+
 
-+#define SHF_PARISC_SHORT	0x20000000 /* Section with short addressing. */
 
-+#define SHF_PARISC_HUGE		0x40000000 /* Section far from gp.  */
 
-+#define SHF_PARISC_SBP		0x80000000 /* Static branch prediction code. */
 
-+
 
-+/* Legal values for ST_TYPE subfield of st_info (symbol type).  */
 
-+
 
-+#define STT_PARISC_MILLICODE	13	/* Millicode function entry point.  */
 
-+
 
-+#define STT_HP_OPAQUE		(STT_LOOS + 0x1)
 
-+#define STT_HP_STUB		(STT_LOOS + 0x2)
 
-+
 
-+/* HPPA relocs.  */
 
-+
 
-+#define R_PARISC_NONE		0	/* No reloc.  */
 
-+#define R_PARISC_DIR32		1	/* Direct 32-bit reference.  */
 
-+#define R_PARISC_DIR21L		2	/* Left 21 bits of eff. address.  */
 
-+#define R_PARISC_DIR17R		3	/* Right 17 bits of eff. address.  */
 
-+#define R_PARISC_DIR17F		4	/* 17 bits of eff. address.  */
 
-+#define R_PARISC_DIR14R		6	/* Right 14 bits of eff. address.  */
 
-+#define R_PARISC_PCREL32	9	/* 32-bit rel. address.  */
 
-+#define R_PARISC_PCREL21L	10	/* Left 21 bits of rel. address.  */
 
-+#define R_PARISC_PCREL17R	11	/* Right 17 bits of rel. address.  */
 
-+#define R_PARISC_PCREL17F	12	/* 17 bits of rel. address.  */
 
-+#define R_PARISC_PCREL14R	14	/* Right 14 bits of rel. address.  */
 
-+#define R_PARISC_DPREL21L	18	/* Left 21 bits of rel. address.  */
 
-+#define R_PARISC_DPREL14R	22	/* Right 14 bits of rel. address.  */
 
-+#define R_PARISC_GPREL21L	26	/* GP-relative, left 21 bits.  */
 
-+#define R_PARISC_GPREL14R	30	/* GP-relative, right 14 bits.  */
 
-+#define R_PARISC_LTOFF21L	34	/* LT-relative, left 21 bits.  */
 
-+#define R_PARISC_LTOFF14R	38	/* LT-relative, right 14 bits.  */
 
-+#define R_PARISC_SECREL32	41	/* 32 bits section rel. address.  */
 
-+#define R_PARISC_SEGBASE	48	/* No relocation, set segment base.  */
 
-+#define R_PARISC_SEGREL32	49	/* 32 bits segment rel. address.  */
 
-+#define R_PARISC_PLTOFF21L	50	/* PLT rel. address, left 21 bits.  */
 
-+#define R_PARISC_PLTOFF14R	54	/* PLT rel. address, right 14 bits.  */
 
-+#define R_PARISC_LTOFF_FPTR32	57	/* 32 bits LT-rel. function pointer. */
 
-+#define R_PARISC_LTOFF_FPTR21L	58	/* LT-rel. fct ptr, left 21 bits. */
 
-+#define R_PARISC_LTOFF_FPTR14R	62	/* LT-rel. fct ptr, right 14 bits. */
 
-+#define R_PARISC_FPTR64		64	/* 64 bits function address.  */
 
-+#define R_PARISC_PLABEL32	65	/* 32 bits function address.  */
 
-+#define R_PARISC_PLABEL21L	66	/* Left 21 bits of fdesc address.  */
 
-+#define R_PARISC_PLABEL14R	70	/* Right 14 bits of fdesc address.  */
 
-+#define R_PARISC_PCREL64	72	/* 64 bits PC-rel. address.  */
 
-+#define R_PARISC_PCREL22F	74	/* 22 bits PC-rel. address.  */
 
-+#define R_PARISC_PCREL14WR	75	/* PC-rel. address, right 14 bits.  */
 
-+#define R_PARISC_PCREL14DR	76	/* PC rel. address, right 14 bits.  */
 
-+#define R_PARISC_PCREL16F	77	/* 16 bits PC-rel. address.  */
 
-+#define R_PARISC_PCREL16WF	78	/* 16 bits PC-rel. address.  */
 
-+#define R_PARISC_PCREL16DF	79	/* 16 bits PC-rel. address.  */
 
-+#define R_PARISC_DIR64		80	/* 64 bits of eff. address.  */
 
-+#define R_PARISC_DIR14WR	83	/* 14 bits of eff. address.  */
 
-+#define R_PARISC_DIR14DR	84	/* 14 bits of eff. address.  */
 
-+#define R_PARISC_DIR16F		85	/* 16 bits of eff. address.  */
 
-+#define R_PARISC_DIR16WF	86	/* 16 bits of eff. address.  */
 
-+#define R_PARISC_DIR16DF	87	/* 16 bits of eff. address.  */
 
-+#define R_PARISC_GPREL64	88	/* 64 bits of GP-rel. address.  */
 
-+#define R_PARISC_GPREL14WR	91	/* GP-rel. address, right 14 bits.  */
 
-+#define R_PARISC_GPREL14DR	92	/* GP-rel. address, right 14 bits.  */
 
-+#define R_PARISC_GPREL16F	93	/* 16 bits GP-rel. address.  */
 
-+#define R_PARISC_GPREL16WF	94	/* 16 bits GP-rel. address.  */
 
-+#define R_PARISC_GPREL16DF	95	/* 16 bits GP-rel. address.  */
 
-+#define R_PARISC_LTOFF64	96	/* 64 bits LT-rel. address.  */
 
-+#define R_PARISC_LTOFF14WR	99	/* LT-rel. address, right 14 bits.  */
 
-+#define R_PARISC_LTOFF14DR	100	/* LT-rel. address, right 14 bits.  */
 
-+#define R_PARISC_LTOFF16F	101	/* 16 bits LT-rel. address.  */
 
-+#define R_PARISC_LTOFF16WF	102	/* 16 bits LT-rel. address.  */
 
-+#define R_PARISC_LTOFF16DF	103	/* 16 bits LT-rel. address.  */
 
-+#define R_PARISC_SECREL64	104	/* 64 bits section rel. address.  */
 
-+#define R_PARISC_SEGREL64	112	/* 64 bits segment rel. address.  */
 
-+#define R_PARISC_PLTOFF14WR	115	/* PLT-rel. address, right 14 bits.  */
 
-+#define R_PARISC_PLTOFF14DR	116	/* PLT-rel. address, right 14 bits.  */
 
-+#define R_PARISC_PLTOFF16F	117	/* 16 bits LT-rel. address.  */
 
-+#define R_PARISC_PLTOFF16WF	118	/* 16 bits PLT-rel. address.  */
 
-+#define R_PARISC_PLTOFF16DF	119	/* 16 bits PLT-rel. address.  */
 
-+#define R_PARISC_LTOFF_FPTR64	120	/* 64 bits LT-rel. function ptr.  */
 
-+#define R_PARISC_LTOFF_FPTR14WR	123	/* LT-rel. fct. ptr., right 14 bits. */
 
-+#define R_PARISC_LTOFF_FPTR14DR	124	/* LT-rel. fct. ptr., right 14 bits. */
 
-+#define R_PARISC_LTOFF_FPTR16F	125	/* 16 bits LT-rel. function ptr.  */
 
-+#define R_PARISC_LTOFF_FPTR16WF	126	/* 16 bits LT-rel. function ptr.  */
 
-+#define R_PARISC_LTOFF_FPTR16DF	127	/* 16 bits LT-rel. function ptr.  */
 
-+#define R_PARISC_LORESERVE	128
 
-+#define R_PARISC_COPY		128	/* Copy relocation.  */
 
-+#define R_PARISC_IPLT		129	/* Dynamic reloc, imported PLT */
 
-+#define R_PARISC_EPLT		130	/* Dynamic reloc, exported PLT */
 
-+#define R_PARISC_TPREL32	153	/* 32 bits TP-rel. address.  */
 
-+#define R_PARISC_TPREL21L	154	/* TP-rel. address, left 21 bits.  */
 
-+#define R_PARISC_TPREL14R	158	/* TP-rel. address, right 14 bits.  */
 
-+#define R_PARISC_LTOFF_TP21L	162	/* LT-TP-rel. address, left 21 bits. */
 
-+#define R_PARISC_LTOFF_TP14R	166	/* LT-TP-rel. address, right 14 bits.*/
 
-+#define R_PARISC_LTOFF_TP14F	167	/* 14 bits LT-TP-rel. address.  */
 
-+#define R_PARISC_TPREL64	216	/* 64 bits TP-rel. address.  */
 
-+#define R_PARISC_TPREL14WR	219	/* TP-rel. address, right 14 bits.  */
 
-+#define R_PARISC_TPREL14DR	220	/* TP-rel. address, right 14 bits.  */
 
-+#define R_PARISC_TPREL16F	221	/* 16 bits TP-rel. address.  */
 
-+#define R_PARISC_TPREL16WF	222	/* 16 bits TP-rel. address.  */
 
-+#define R_PARISC_TPREL16DF	223	/* 16 bits TP-rel. address.  */
 
-+#define R_PARISC_LTOFF_TP64	224	/* 64 bits LT-TP-rel. address.  */
 
-+#define R_PARISC_LTOFF_TP14WR	227	/* LT-TP-rel. address, right 14 bits.*/
 
-+#define R_PARISC_LTOFF_TP14DR	228	/* LT-TP-rel. address, right 14 bits.*/
 
-+#define R_PARISC_LTOFF_TP16F	229	/* 16 bits LT-TP-rel. address.  */
 
-+#define R_PARISC_LTOFF_TP16WF	230	/* 16 bits LT-TP-rel. address.  */
 
-+#define R_PARISC_LTOFF_TP16DF	231	/* 16 bits LT-TP-rel. address.  */
 
-+#define R_PARISC_GNU_VTENTRY	232
 
-+#define R_PARISC_GNU_VTINHERIT	233
 
-+#define R_PARISC_TLS_GD21L	234	/* GD 21-bit left.  */
 
-+#define R_PARISC_TLS_GD14R	235	/* GD 14-bit right.  */
 
-+#define R_PARISC_TLS_GDCALL	236	/* GD call to __t_g_a.  */
 
-+#define R_PARISC_TLS_LDM21L	237	/* LD module 21-bit left.  */
 
-+#define R_PARISC_TLS_LDM14R	238	/* LD module 14-bit right.  */
 
-+#define R_PARISC_TLS_LDMCALL	239	/* LD module call to __t_g_a.  */
 
-+#define R_PARISC_TLS_LDO21L	240	/* LD offset 21-bit left.  */
 
-+#define R_PARISC_TLS_LDO14R	241	/* LD offset 14-bit right.  */
 
-+#define R_PARISC_TLS_DTPMOD32	242	/* DTP module 32-bit.  */
 
-+#define R_PARISC_TLS_DTPMOD64	243	/* DTP module 64-bit.  */
 
-+#define R_PARISC_TLS_DTPOFF32	244	/* DTP offset 32-bit.  */
 
-+#define R_PARISC_TLS_DTPOFF64	245	/* DTP offset 32-bit.  */
 
-+#define R_PARISC_TLS_LE21L	R_PARISC_TPREL21L
 
-+#define R_PARISC_TLS_LE14R	R_PARISC_TPREL14R
 
-+#define R_PARISC_TLS_IE21L	R_PARISC_LTOFF_TP21L
 
-+#define R_PARISC_TLS_IE14R	R_PARISC_LTOFF_TP14R
 
-+#define R_PARISC_TLS_TPREL32	R_PARISC_TPREL32
 
-+#define R_PARISC_TLS_TPREL64	R_PARISC_TPREL64
 
-+#define R_PARISC_HIRESERVE	255
 
-+
 
-+/* Legal values for p_type field of Elf32_Phdr/Elf64_Phdr.  */
 
-+
 
-+#define PT_HP_TLS		(PT_LOOS + 0x0)
 
-+#define PT_HP_CORE_NONE		(PT_LOOS + 0x1)
 
-+#define PT_HP_CORE_VERSION	(PT_LOOS + 0x2)
 
-+#define PT_HP_CORE_KERNEL	(PT_LOOS + 0x3)
 
-+#define PT_HP_CORE_COMM		(PT_LOOS + 0x4)
 
-+#define PT_HP_CORE_PROC		(PT_LOOS + 0x5)
 
-+#define PT_HP_CORE_LOADABLE	(PT_LOOS + 0x6)
 
-+#define PT_HP_CORE_STACK	(PT_LOOS + 0x7)
 
-+#define PT_HP_CORE_SHM		(PT_LOOS + 0x8)
 
-+#define PT_HP_CORE_MMF		(PT_LOOS + 0x9)
 
-+#define PT_HP_PARALLEL		(PT_LOOS + 0x10)
 
-+#define PT_HP_FASTBIND		(PT_LOOS + 0x11)
 
-+#define PT_HP_OPT_ANNOT		(PT_LOOS + 0x12)
 
-+#define PT_HP_HSL_ANNOT		(PT_LOOS + 0x13)
 
-+#define PT_HP_STACK		(PT_LOOS + 0x14)
 
-+
 
-+#define PT_PARISC_ARCHEXT	0x70000000
 
-+#define PT_PARISC_UNWIND	0x70000001
 
-+
 
-+/* Legal values for p_flags field of Elf32_Phdr/Elf64_Phdr.  */
 
-+
 
-+#define PF_PARISC_SBP		0x08000000
 
-+
 
-+#define PF_HP_PAGE_SIZE		0x00100000
 
-+#define PF_HP_FAR_SHARED	0x00200000
 
-+#define PF_HP_NEAR_SHARED	0x00400000
 
-+#define PF_HP_CODE		0x01000000
 
-+#define PF_HP_MODIFY		0x02000000
 
-+#define PF_HP_LAZYSWAP		0x04000000
 
-+#define PF_HP_SBP		0x08000000
 
-+
 
-+
 
-+/* Alpha specific definitions.  */
 
-+
 
-+/* Legal values for e_flags field of Elf64_Ehdr.  */
 
-+
 
-+#define EF_ALPHA_32BIT		1	/* All addresses must be < 2GB.  */
 
-+#define EF_ALPHA_CANRELAX	2	/* Relocations for relaxing exist.  */
 
-+
 
-+/* Legal values for sh_type field of Elf64_Shdr.  */
 
-+
 
-+/* These two are primerily concerned with ECOFF debugging info.  */
 
-+#define SHT_ALPHA_DEBUG		0x70000001
 
-+#define SHT_ALPHA_REGINFO	0x70000002
 
-+
 
-+/* Legal values for sh_flags field of Elf64_Shdr.  */
 
-+
 
-+#define SHF_ALPHA_GPREL		0x10000000
 
-+
 
-+/* Legal values for st_other field of Elf64_Sym.  */
 
-+#define STO_ALPHA_NOPV		0x80	/* No PV required.  */
 
-+#define STO_ALPHA_STD_GPLOAD	0x88	/* PV only used for initial ldgp.  */
 
-+
 
-+/* Alpha relocs.  */
 
-+
 
-+#define R_ALPHA_NONE		0	/* No reloc */
 
-+#define R_ALPHA_REFLONG		1	/* Direct 32 bit */
 
-+#define R_ALPHA_REFQUAD		2	/* Direct 64 bit */
 
-+#define R_ALPHA_GPREL32		3	/* GP relative 32 bit */
 
-+#define R_ALPHA_LITERAL		4	/* GP relative 16 bit w/optimization */
 
-+#define R_ALPHA_LITUSE		5	/* Optimization hint for LITERAL */
 
-+#define R_ALPHA_GPDISP		6	/* Add displacement to GP */
 
-+#define R_ALPHA_BRADDR		7	/* PC+4 relative 23 bit shifted */
 
-+#define R_ALPHA_HINT		8	/* PC+4 relative 16 bit shifted */
 
-+#define R_ALPHA_SREL16		9	/* PC relative 16 bit */
 
-+#define R_ALPHA_SREL32		10	/* PC relative 32 bit */
 
-+#define R_ALPHA_SREL64		11	/* PC relative 64 bit */
 
-+#define R_ALPHA_GPRELHIGH	17	/* GP relative 32 bit, high 16 bits */
 
-+#define R_ALPHA_GPRELLOW	18	/* GP relative 32 bit, low 16 bits */
 
-+#define R_ALPHA_GPREL16		19	/* GP relative 16 bit */
 
-+#define R_ALPHA_COPY		24	/* Copy symbol at runtime */
 
-+#define R_ALPHA_GLOB_DAT	25	/* Create GOT entry */
 
-+#define R_ALPHA_JMP_SLOT	26	/* Create PLT entry */
 
-+#define R_ALPHA_RELATIVE	27	/* Adjust by program base */
 
-+#define R_ALPHA_TLS_GD_HI	28
 
-+#define R_ALPHA_TLSGD		29
 
-+#define R_ALPHA_TLS_LDM		30
 
-+#define R_ALPHA_DTPMOD64	31
 
-+#define R_ALPHA_GOTDTPREL	32
 
-+#define R_ALPHA_DTPREL64	33
 
-+#define R_ALPHA_DTPRELHI	34
 
-+#define R_ALPHA_DTPRELLO	35
 
-+#define R_ALPHA_DTPREL16	36
 
-+#define R_ALPHA_GOTTPREL	37
 
-+#define R_ALPHA_TPREL64		38
 
-+#define R_ALPHA_TPRELHI		39
 
-+#define R_ALPHA_TPRELLO		40
 
-+#define R_ALPHA_TPREL16		41
 
-+/* Keep this the last entry.  */
 
-+#define R_ALPHA_NUM		46
 
-+
 
-+/* Magic values of the LITUSE relocation addend.  */
 
-+#define LITUSE_ALPHA_ADDR	0
 
-+#define LITUSE_ALPHA_BASE	1
 
-+#define LITUSE_ALPHA_BYTOFF	2
 
-+#define LITUSE_ALPHA_JSR	3
 
-+#define LITUSE_ALPHA_TLS_GD	4
 
-+#define LITUSE_ALPHA_TLS_LDM	5
 
-+
 
-+/* Legal values for d_tag of Elf64_Dyn.  */
 
-+#define DT_ALPHA_PLTRO		(DT_LOPROC + 0)
 
-+#define DT_ALPHA_NUM		1
 
-+
 
-+/* PowerPC specific declarations */
 
-+
 
-+/* Values for Elf32/64_Ehdr.e_flags.  */
 
-+#define EF_PPC_EMB		0x80000000	/* PowerPC embedded flag */
 
-+
 
-+/* Cygnus local bits below */
 
-+#define EF_PPC_RELOCATABLE	0x00010000	/* PowerPC -mrelocatable flag*/
 
-+#define EF_PPC_RELOCATABLE_LIB	0x00008000	/* PowerPC -mrelocatable-lib
 
-+						   flag */
 
-+
 
-+/* PowerPC relocations defined by the ABIs */
 
-+#define R_PPC_NONE		0
 
-+#define R_PPC_ADDR32		1	/* 32bit absolute address */
 
-+#define R_PPC_ADDR24		2	/* 26bit address, 2 bits ignored.  */
 
-+#define R_PPC_ADDR16		3	/* 16bit absolute address */
 
-+#define R_PPC_ADDR16_LO		4	/* lower 16bit of absolute address */
 
-+#define R_PPC_ADDR16_HI		5	/* high 16bit of absolute address */
 
-+#define R_PPC_ADDR16_HA		6	/* adjusted high 16bit */
 
-+#define R_PPC_ADDR14		7	/* 16bit address, 2 bits ignored */
 
-+#define R_PPC_ADDR14_BRTAKEN	8
 
-+#define R_PPC_ADDR14_BRNTAKEN	9
 
-+#define R_PPC_REL24		10	/* PC relative 26 bit */
 
-+#define R_PPC_REL14		11	/* PC relative 16 bit */
 
-+#define R_PPC_REL14_BRTAKEN	12
 
-+#define R_PPC_REL14_BRNTAKEN	13
 
-+#define R_PPC_GOT16		14
 
-+#define R_PPC_GOT16_LO		15
 
-+#define R_PPC_GOT16_HI		16
 
-+#define R_PPC_GOT16_HA		17
 
-+#define R_PPC_PLTREL24		18
 
-+#define R_PPC_COPY		19
 
-+#define R_PPC_GLOB_DAT		20
 
-+#define R_PPC_JMP_SLOT		21
 
-+#define R_PPC_RELATIVE		22
 
-+#define R_PPC_LOCAL24PC		23
 
-+#define R_PPC_UADDR32		24
 
-+#define R_PPC_UADDR16		25
 
-+#define R_PPC_REL32		26
 
-+#define R_PPC_PLT32		27
 
-+#define R_PPC_PLTREL32		28
 
-+#define R_PPC_PLT16_LO		29
 
-+#define R_PPC_PLT16_HI		30
 
-+#define R_PPC_PLT16_HA		31
 
-+#define R_PPC_SDAREL16		32
 
-+#define R_PPC_SECTOFF		33
 
-+#define R_PPC_SECTOFF_LO	34
 
-+#define R_PPC_SECTOFF_HI	35
 
-+#define R_PPC_SECTOFF_HA	36
 
-+
 
-+/* PowerPC relocations defined for the TLS access ABI.  */
 
-+#define R_PPC_TLS		67 /* none	(sym+add)@tls */
 
-+#define R_PPC_DTPMOD32		68 /* word32	(sym+add)@dtpmod */
 
-+#define R_PPC_TPREL16		69 /* half16*	(sym+add)@tprel */
 
-+#define R_PPC_TPREL16_LO	70 /* half16	(sym+add)@tprel@l */
 
-+#define R_PPC_TPREL16_HI	71 /* half16	(sym+add)@tprel@h */
 
-+#define R_PPC_TPREL16_HA	72 /* half16	(sym+add)@tprel@ha */
 
-+#define R_PPC_TPREL32		73 /* word32	(sym+add)@tprel */
 
-+#define R_PPC_DTPREL16		74 /* half16*	(sym+add)@dtprel */
 
-+#define R_PPC_DTPREL16_LO	75 /* half16	(sym+add)@dtprel@l */
 
-+#define R_PPC_DTPREL16_HI	76 /* half16	(sym+add)@dtprel@h */
 
-+#define R_PPC_DTPREL16_HA	77 /* half16	(sym+add)@dtprel@ha */
 
-+#define R_PPC_DTPREL32		78 /* word32	(sym+add)@dtprel */
 
-+#define R_PPC_GOT_TLSGD16	79 /* half16*	(sym+add)@got@tlsgd */
 
-+#define R_PPC_GOT_TLSGD16_LO	80 /* half16	(sym+add)@got@tlsgd@l */
 
-+#define R_PPC_GOT_TLSGD16_HI	81 /* half16	(sym+add)@got@tlsgd@h */
 
-+#define R_PPC_GOT_TLSGD16_HA	82 /* half16	(sym+add)@got@tlsgd@ha */
 
-+#define R_PPC_GOT_TLSLD16	83 /* half16*	(sym+add)@got@tlsld */
 
-+#define R_PPC_GOT_TLSLD16_LO	84 /* half16	(sym+add)@got@tlsld@l */
 
-+#define R_PPC_GOT_TLSLD16_HI	85 /* half16	(sym+add)@got@tlsld@h */
 
-+#define R_PPC_GOT_TLSLD16_HA	86 /* half16	(sym+add)@got@tlsld@ha */
 
-+#define R_PPC_GOT_TPREL16	87 /* half16*	(sym+add)@got@tprel */
 
-+#define R_PPC_GOT_TPREL16_LO	88 /* half16	(sym+add)@got@tprel@l */
 
-+#define R_PPC_GOT_TPREL16_HI	89 /* half16	(sym+add)@got@tprel@h */
 
-+#define R_PPC_GOT_TPREL16_HA	90 /* half16	(sym+add)@got@tprel@ha */
 
-+#define R_PPC_GOT_DTPREL16	91 /* half16*	(sym+add)@got@dtprel */
 
-+#define R_PPC_GOT_DTPREL16_LO	92 /* half16*	(sym+add)@got@dtprel@l */
 
-+#define R_PPC_GOT_DTPREL16_HI	93 /* half16*	(sym+add)@got@dtprel@h */
 
-+#define R_PPC_GOT_DTPREL16_HA	94 /* half16*	(sym+add)@got@dtprel@ha */
 
-+
 
-+/* The remaining relocs are from the Embedded ELF ABI, and are not
 
-+   in the SVR4 ELF ABI.  */
 
-+#define R_PPC_EMB_NADDR32	101
 
-+#define R_PPC_EMB_NADDR16	102
 
-+#define R_PPC_EMB_NADDR16_LO	103
 
-+#define R_PPC_EMB_NADDR16_HI	104
 
-+#define R_PPC_EMB_NADDR16_HA	105
 
-+#define R_PPC_EMB_SDAI16	106
 
-+#define R_PPC_EMB_SDA2I16	107
 
-+#define R_PPC_EMB_SDA2REL	108
 
-+#define R_PPC_EMB_SDA21		109	/* 16 bit offset in SDA */
 
-+#define R_PPC_EMB_MRKREF	110
 
-+#define R_PPC_EMB_RELSEC16	111
 
-+#define R_PPC_EMB_RELST_LO	112
 
-+#define R_PPC_EMB_RELST_HI	113
 
-+#define R_PPC_EMB_RELST_HA	114
 
-+#define R_PPC_EMB_BIT_FLD	115
 
-+#define R_PPC_EMB_RELSDA	116	/* 16 bit relative offset in SDA */
 
-+
 
-+/* Diab tool relocations.  */
 
-+#define R_PPC_DIAB_SDA21_LO	180	/* like EMB_SDA21, but lower 16 bit */
 
-+#define R_PPC_DIAB_SDA21_HI	181	/* like EMB_SDA21, but high 16 bit */
 
-+#define R_PPC_DIAB_SDA21_HA	182	/* like EMB_SDA21, adjusted high 16 */
 
-+#define R_PPC_DIAB_RELSDA_LO	183	/* like EMB_RELSDA, but lower 16 bit */
 
-+#define R_PPC_DIAB_RELSDA_HI	184	/* like EMB_RELSDA, but high 16 bit */
 
-+#define R_PPC_DIAB_RELSDA_HA	185	/* like EMB_RELSDA, adjusted high 16 */
 
-+
 
-+/* GNU extension to support local ifunc.  */
 
-+#define R_PPC_IRELATIVE		248
 
-+
 
-+/* GNU relocs used in PIC code sequences.  */
 
-+#define R_PPC_REL16		249	/* half16   (sym+add-.) */
 
-+#define R_PPC_REL16_LO		250	/* half16   (sym+add-.)@l */
 
-+#define R_PPC_REL16_HI		251	/* half16   (sym+add-.)@h */
 
-+#define R_PPC_REL16_HA		252	/* half16   (sym+add-.)@ha */
 
-+
 
-+/* This is a phony reloc to handle any old fashioned TOC16 references
 
-+   that may still be in object files.  */
 
-+#define R_PPC_TOC16		255
 
-+
 
-+/* PowerPC specific values for the Dyn d_tag field.  */
 
-+#define DT_PPC_GOT		(DT_LOPROC + 0)
 
-+#define DT_PPC_NUM		1
 
-+
 
-+/* PowerPC64 relocations defined by the ABIs */
 
-+#define R_PPC64_NONE		R_PPC_NONE
 
-+#define R_PPC64_ADDR32		R_PPC_ADDR32 /* 32bit absolute address */
 
-+#define R_PPC64_ADDR24		R_PPC_ADDR24 /* 26bit address, word aligned */
 
-+#define R_PPC64_ADDR16		R_PPC_ADDR16 /* 16bit absolute address */
 
-+#define R_PPC64_ADDR16_LO	R_PPC_ADDR16_LO	/* lower 16bits of address */
 
-+#define R_PPC64_ADDR16_HI	R_PPC_ADDR16_HI	/* high 16bits of address. */
 
-+#define R_PPC64_ADDR16_HA	R_PPC_ADDR16_HA /* adjusted high 16bits.  */
 
-+#define R_PPC64_ADDR14		R_PPC_ADDR14 /* 16bit address, word aligned */
 
-+#define R_PPC64_ADDR14_BRTAKEN	R_PPC_ADDR14_BRTAKEN
 
-+#define R_PPC64_ADDR14_BRNTAKEN	R_PPC_ADDR14_BRNTAKEN
 
-+#define R_PPC64_REL24		R_PPC_REL24 /* PC-rel. 26 bit, word aligned */
 
-+#define R_PPC64_REL14		R_PPC_REL14 /* PC relative 16 bit */
 
-+#define R_PPC64_REL14_BRTAKEN	R_PPC_REL14_BRTAKEN
 
-+#define R_PPC64_REL14_BRNTAKEN	R_PPC_REL14_BRNTAKEN
 
-+#define R_PPC64_GOT16		R_PPC_GOT16
 
-+#define R_PPC64_GOT16_LO	R_PPC_GOT16_LO
 
-+#define R_PPC64_GOT16_HI	R_PPC_GOT16_HI
 
-+#define R_PPC64_GOT16_HA	R_PPC_GOT16_HA
 
-+
 
-+#define R_PPC64_COPY		R_PPC_COPY
 
-+#define R_PPC64_GLOB_DAT	R_PPC_GLOB_DAT
 
-+#define R_PPC64_JMP_SLOT	R_PPC_JMP_SLOT
 
-+#define R_PPC64_RELATIVE	R_PPC_RELATIVE
 
-+
 
-+#define R_PPC64_UADDR32		R_PPC_UADDR32
 
-+#define R_PPC64_UADDR16		R_PPC_UADDR16
 
-+#define R_PPC64_REL32		R_PPC_REL32
 
-+#define R_PPC64_PLT32		R_PPC_PLT32
 
-+#define R_PPC64_PLTREL32	R_PPC_PLTREL32
 
-+#define R_PPC64_PLT16_LO	R_PPC_PLT16_LO
 
-+#define R_PPC64_PLT16_HI	R_PPC_PLT16_HI
 
-+#define R_PPC64_PLT16_HA	R_PPC_PLT16_HA
 
-+
 
-+#define R_PPC64_SECTOFF		R_PPC_SECTOFF
 
-+#define R_PPC64_SECTOFF_LO	R_PPC_SECTOFF_LO
 
-+#define R_PPC64_SECTOFF_HI	R_PPC_SECTOFF_HI
 
-+#define R_PPC64_SECTOFF_HA	R_PPC_SECTOFF_HA
 
-+#define R_PPC64_ADDR30		37 /* word30 (S + A - P) >> 2 */
 
-+#define R_PPC64_ADDR64		38 /* doubleword64 S + A */
 
-+#define R_PPC64_ADDR16_HIGHER	39 /* half16 #higher(S + A) */
 
-+#define R_PPC64_ADDR16_HIGHERA	40 /* half16 #highera(S + A) */
 
-+#define R_PPC64_ADDR16_HIGHEST	41 /* half16 #highest(S + A) */
 
-+#define R_PPC64_ADDR16_HIGHESTA	42 /* half16 #highesta(S + A) */
 
-+#define R_PPC64_UADDR64		43 /* doubleword64 S + A */
 
-+#define R_PPC64_REL64		44 /* doubleword64 S + A - P */
 
-+#define R_PPC64_PLT64		45 /* doubleword64 L + A */
 
-+#define R_PPC64_PLTREL64	46 /* doubleword64 L + A - P */
 
-+#define R_PPC64_TOC16		47 /* half16* S + A - .TOC */
 
-+#define R_PPC64_TOC16_LO	48 /* half16 #lo(S + A - .TOC.) */
 
-+#define R_PPC64_TOC16_HI	49 /* half16 #hi(S + A - .TOC.) */
 
-+#define R_PPC64_TOC16_HA	50 /* half16 #ha(S + A - .TOC.) */
 
-+#define R_PPC64_TOC		51 /* doubleword64 .TOC */
 
-+#define R_PPC64_PLTGOT16	52 /* half16* M + A */
 
-+#define R_PPC64_PLTGOT16_LO	53 /* half16 #lo(M + A) */
 
-+#define R_PPC64_PLTGOT16_HI	54 /* half16 #hi(M + A) */
 
-+#define R_PPC64_PLTGOT16_HA	55 /* half16 #ha(M + A) */
 
-+
 
-+#define R_PPC64_ADDR16_DS	56 /* half16ds* (S + A) >> 2 */
 
-+#define R_PPC64_ADDR16_LO_DS	57 /* half16ds  #lo(S + A) >> 2 */
 
-+#define R_PPC64_GOT16_DS	58 /* half16ds* (G + A) >> 2 */
 
-+#define R_PPC64_GOT16_LO_DS	59 /* half16ds  #lo(G + A) >> 2 */
 
-+#define R_PPC64_PLT16_LO_DS	60 /* half16ds  #lo(L + A) >> 2 */
 
-+#define R_PPC64_SECTOFF_DS	61 /* half16ds* (R + A) >> 2 */
 
-+#define R_PPC64_SECTOFF_LO_DS	62 /* half16ds  #lo(R + A) >> 2 */
 
-+#define R_PPC64_TOC16_DS	63 /* half16ds* (S + A - .TOC.) >> 2 */
 
-+#define R_PPC64_TOC16_LO_DS	64 /* half16ds  #lo(S + A - .TOC.) >> 2 */
 
-+#define R_PPC64_PLTGOT16_DS	65 /* half16ds* (M + A) >> 2 */
 
-+#define R_PPC64_PLTGOT16_LO_DS	66 /* half16ds  #lo(M + A) >> 2 */
 
-+
 
-+/* PowerPC64 relocations defined for the TLS access ABI.  */
 
-+#define R_PPC64_TLS		67 /* none	(sym+add)@tls */
 
-+#define R_PPC64_DTPMOD64	68 /* doubleword64 (sym+add)@dtpmod */
 
-+#define R_PPC64_TPREL16		69 /* half16*	(sym+add)@tprel */
 
-+#define R_PPC64_TPREL16_LO	70 /* half16	(sym+add)@tprel@l */
 
-+#define R_PPC64_TPREL16_HI	71 /* half16	(sym+add)@tprel@h */
 
-+#define R_PPC64_TPREL16_HA	72 /* half16	(sym+add)@tprel@ha */
 
-+#define R_PPC64_TPREL64		73 /* doubleword64 (sym+add)@tprel */
 
-+#define R_PPC64_DTPREL16	74 /* half16*	(sym+add)@dtprel */
 
-+#define R_PPC64_DTPREL16_LO	75 /* half16	(sym+add)@dtprel@l */
 
-+#define R_PPC64_DTPREL16_HI	76 /* half16	(sym+add)@dtprel@h */
 
-+#define R_PPC64_DTPREL16_HA	77 /* half16	(sym+add)@dtprel@ha */
 
-+#define R_PPC64_DTPREL64	78 /* doubleword64 (sym+add)@dtprel */
 
-+#define R_PPC64_GOT_TLSGD16	79 /* half16*	(sym+add)@got@tlsgd */
 
-+#define R_PPC64_GOT_TLSGD16_LO	80 /* half16	(sym+add)@got@tlsgd@l */
 
-+#define R_PPC64_GOT_TLSGD16_HI	81 /* half16	(sym+add)@got@tlsgd@h */
 
-+#define R_PPC64_GOT_TLSGD16_HA	82 /* half16	(sym+add)@got@tlsgd@ha */
 
-+#define R_PPC64_GOT_TLSLD16	83 /* half16*	(sym+add)@got@tlsld */
 
-+#define R_PPC64_GOT_TLSLD16_LO	84 /* half16	(sym+add)@got@tlsld@l */
 
-+#define R_PPC64_GOT_TLSLD16_HI	85 /* half16	(sym+add)@got@tlsld@h */
 
-+#define R_PPC64_GOT_TLSLD16_HA	86 /* half16	(sym+add)@got@tlsld@ha */
 
-+#define R_PPC64_GOT_TPREL16_DS	87 /* half16ds*	(sym+add)@got@tprel */
 
-+#define R_PPC64_GOT_TPREL16_LO_DS 88 /* half16ds (sym+add)@got@tprel@l */
 
-+#define R_PPC64_GOT_TPREL16_HI	89 /* half16	(sym+add)@got@tprel@h */
 
-+#define R_PPC64_GOT_TPREL16_HA	90 /* half16	(sym+add)@got@tprel@ha */
 
-+#define R_PPC64_GOT_DTPREL16_DS	91 /* half16ds*	(sym+add)@got@dtprel */
 
-+#define R_PPC64_GOT_DTPREL16_LO_DS 92 /* half16ds (sym+add)@got@dtprel@l */
 
-+#define R_PPC64_GOT_DTPREL16_HI	93 /* half16	(sym+add)@got@dtprel@h */
 
-+#define R_PPC64_GOT_DTPREL16_HA	94 /* half16	(sym+add)@got@dtprel@ha */
 
-+#define R_PPC64_TPREL16_DS	95 /* half16ds*	(sym+add)@tprel */
 
-+#define R_PPC64_TPREL16_LO_DS	96 /* half16ds	(sym+add)@tprel@l */
 
-+#define R_PPC64_TPREL16_HIGHER	97 /* half16	(sym+add)@tprel@higher */
 
-+#define R_PPC64_TPREL16_HIGHERA	98 /* half16	(sym+add)@tprel@highera */
 
-+#define R_PPC64_TPREL16_HIGHEST	99 /* half16	(sym+add)@tprel@highest */
 
-+#define R_PPC64_TPREL16_HIGHESTA 100 /* half16	(sym+add)@tprel@highesta */
 
-+#define R_PPC64_DTPREL16_DS	101 /* half16ds* (sym+add)@dtprel */
 
-+#define R_PPC64_DTPREL16_LO_DS	102 /* half16ds	(sym+add)@dtprel@l */
 
-+#define R_PPC64_DTPREL16_HIGHER	103 /* half16	(sym+add)@dtprel@higher */
 
-+#define R_PPC64_DTPREL16_HIGHERA 104 /* half16	(sym+add)@dtprel@highera */
 
-+#define R_PPC64_DTPREL16_HIGHEST 105 /* half16	(sym+add)@dtprel@highest */
 
-+#define R_PPC64_DTPREL16_HIGHESTA 106 /* half16	(sym+add)@dtprel@highesta */
 
-+
 
-+/* GNU extension to support local ifunc.  */
 
-+#define R_PPC64_JMP_IREL	247
 
-+#define R_PPC64_IRELATIVE	248
 
-+#define R_PPC64_REL16		249	/* half16   (sym+add-.) */
 
-+#define R_PPC64_REL16_LO	250	/* half16   (sym+add-.)@l */
 
-+#define R_PPC64_REL16_HI	251	/* half16   (sym+add-.)@h */
 
-+#define R_PPC64_REL16_HA	252	/* half16   (sym+add-.)@ha */
 
-+
 
-+/* PowerPC64 specific values for the Dyn d_tag field.  */
 
-+#define DT_PPC64_GLINK  (DT_LOPROC + 0)
 
-+#define DT_PPC64_OPD	(DT_LOPROC + 1)
 
-+#define DT_PPC64_OPDSZ	(DT_LOPROC + 2)
 
-+#define DT_PPC64_NUM    3
 
-+
 
-+
 
-+/* ARM specific declarations */
 
-+
 
-+/* Processor specific flags for the ELF header e_flags field.  */
 
-+#define EF_ARM_RELEXEC		0x01
 
-+#define EF_ARM_HASENTRY		0x02
 
-+#define EF_ARM_INTERWORK	0x04
 
-+#define EF_ARM_APCS_26		0x08
 
-+#define EF_ARM_APCS_FLOAT	0x10
 
-+#define EF_ARM_PIC		0x20
 
-+#define EF_ARM_ALIGN8		0x40 /* 8-bit structure alignment is in use */
 
-+#define EF_ARM_NEW_ABI		0x80
 
-+#define EF_ARM_OLD_ABI		0x100
 
-+#define EF_ARM_SOFT_FLOAT	0x200
 
-+#define EF_ARM_VFP_FLOAT	0x400
 
-+#define EF_ARM_MAVERICK_FLOAT	0x800
 
-+
 
-+
 
-+/* Other constants defined in the ARM ELF spec. version B-01.  */
 
-+/* NB. These conflict with values defined above.  */
 
-+#define EF_ARM_SYMSARESORTED	0x04
 
-+#define EF_ARM_DYNSYMSUSESEGIDX	0x08
 
-+#define EF_ARM_MAPSYMSFIRST	0x10
 
-+#define EF_ARM_EABIMASK		0XFF000000
 
-+
 
-+/* Constants defined in AAELF.  */
 
-+#define EF_ARM_BE8	    0x00800000
 
-+#define EF_ARM_LE8	    0x00400000
 
-+
 
-+#define EF_ARM_EABI_VERSION(flags)	((flags) & EF_ARM_EABIMASK)
 
-+#define EF_ARM_EABI_UNKNOWN	0x00000000
 
-+#define EF_ARM_EABI_VER1	0x01000000
 
-+#define EF_ARM_EABI_VER2	0x02000000
 
-+#define EF_ARM_EABI_VER3	0x03000000
 
-+#define EF_ARM_EABI_VER4	0x04000000
 
-+#define EF_ARM_EABI_VER5	0x05000000
 
-+
 
-+/* Additional symbol types for Thumb.  */
 
-+#define STT_ARM_TFUNC		STT_LOPROC /* A Thumb function.  */
 
-+#define STT_ARM_16BIT		STT_HIPROC /* A Thumb label.  */
 
-+
 
-+/* ARM-specific values for sh_flags */
 
-+#define SHF_ARM_ENTRYSECT	0x10000000 /* Section contains an entry point */
 
-+#define SHF_ARM_COMDEF		0x80000000 /* Section may be multiply defined
 
-+					      in the input to a link step.  */
 
-+
 
-+/* ARM-specific program header flags */
 
-+#define PF_ARM_SB		0x10000000 /* Segment contains the location
 
-+					      addressed by the static base. */
 
-+#define PF_ARM_PI		0x20000000 /* Position-independent segment.  */
 
-+#define PF_ARM_ABS		0x40000000 /* Absolute segment.  */
 
-+
 
-+/* Processor specific values for the Phdr p_type field.  */
 
-+#define PT_ARM_EXIDX		(PT_LOPROC + 1)	/* ARM unwind segment.  */
 
-+
 
-+/* Processor specific values for the Shdr sh_type field.  */
 
-+#define SHT_ARM_EXIDX		(SHT_LOPROC + 1) /* ARM unwind section.  */
 
-+#define SHT_ARM_PREEMPTMAP	(SHT_LOPROC + 2) /* Preemption details.  */
 
-+#define SHT_ARM_ATTRIBUTES	(SHT_LOPROC + 3) /* ARM attributes section.  */
 
-+
 
-+
 
-+/* ARM relocs.  */
 
-+
 
-+#define R_ARM_NONE		0	/* No reloc */
 
-+#define R_ARM_PC24		1	/* PC relative 26 bit branch */
 
-+#define R_ARM_ABS32		2	/* Direct 32 bit  */
 
-+#define R_ARM_REL32		3	/* PC relative 32 bit */
 
-+#define R_ARM_PC13		4
 
-+#define R_ARM_ABS16		5	/* Direct 16 bit */
 
-+#define R_ARM_ABS12		6	/* Direct 12 bit */
 
-+#define R_ARM_THM_ABS5		7
 
-+#define R_ARM_ABS8		8	/* Direct 8 bit */
 
-+#define R_ARM_SBREL32		9
 
-+#define R_ARM_THM_PC22		10
 
-+#define R_ARM_THM_PC8		11
 
-+#define R_ARM_AMP_VCALL9	12
 
-+#define R_ARM_SWI24		13	/* Obsolete static relocation.  */
 
-+#define R_ARM_TLS_DESC		13      /* Dynamic relocation.  */
 
-+#define R_ARM_THM_SWI8		14
 
-+#define R_ARM_XPC25		15
 
-+#define R_ARM_THM_XPC22		16
 
-+#define R_ARM_TLS_DTPMOD32	17	/* ID of module containing symbol */
 
-+#define R_ARM_TLS_DTPOFF32	18	/* Offset in TLS block */
 
-+#define R_ARM_TLS_TPOFF32	19	/* Offset in static TLS block */
 
-+#define R_ARM_COPY		20	/* Copy symbol at runtime */
 
-+#define R_ARM_GLOB_DAT		21	/* Create GOT entry */
 
-+#define R_ARM_JUMP_SLOT		22	/* Create PLT entry */
 
-+#define R_ARM_RELATIVE		23	/* Adjust by program base */
 
-+#define R_ARM_GOTOFF		24	/* 32 bit offset to GOT */
 
-+#define R_ARM_GOTPC		25	/* 32 bit PC relative offset to GOT */
 
-+#define R_ARM_GOT32		26	/* 32 bit GOT entry */
 
-+#define R_ARM_PLT32		27	/* 32 bit PLT address */
 
-+#define R_ARM_ALU_PCREL_7_0	32
 
-+#define R_ARM_ALU_PCREL_15_8	33
 
-+#define R_ARM_ALU_PCREL_23_15	34
 
-+#define R_ARM_LDR_SBREL_11_0	35
 
-+#define R_ARM_ALU_SBREL_19_12	36
 
-+#define R_ARM_ALU_SBREL_27_20	37
 
-+#define R_ARM_TLS_GOTDESC	90
 
-+#define R_ARM_TLS_CALL		91
 
-+#define R_ARM_TLS_DESCSEQ	92
 
-+#define R_ARM_THM_TLS_CALL	93
 
-+#define R_ARM_GNU_VTENTRY	100
 
-+#define R_ARM_GNU_VTINHERIT	101
 
-+#define R_ARM_THM_PC11		102	/* thumb unconditional branch */
 
-+#define R_ARM_THM_PC9		103	/* thumb conditional branch */
 
-+#define R_ARM_TLS_GD32		104	/* PC-rel 32 bit for global dynamic
 
-+					   thread local data */
 
-+#define R_ARM_TLS_LDM32		105	/* PC-rel 32 bit for local dynamic
 
-+					   thread local data */
 
-+#define R_ARM_TLS_LDO32		106	/* 32 bit offset relative to TLS
 
-+					   block */
 
-+#define R_ARM_TLS_IE32		107	/* PC-rel 32 bit for GOT entry of
 
-+					   static TLS block offset */
 
-+#define R_ARM_TLS_LE32		108	/* 32 bit offset relative to static
 
-+					   TLS block */
 
-+#define	R_ARM_THM_TLS_DESCSEQ	129
 
-+#define R_ARM_IRELATIVE		160
 
-+#define R_ARM_RXPC25		249
 
-+#define R_ARM_RSBREL32		250
 
-+#define R_ARM_THM_RPC22		251
 
-+#define R_ARM_RREL32		252
 
-+#define R_ARM_RABS22		253
 
-+#define R_ARM_RPC24		254
 
-+#define R_ARM_RBASE		255
 
-+/* Keep this the last entry.  */
 
-+#define R_ARM_NUM		256
 
-+
 
-+/* IA-64 specific declarations.  */
 
-+
 
-+/* Processor specific flags for the Ehdr e_flags field.  */
 
-+#define EF_IA_64_MASKOS		0x0000000f	/* os-specific flags */
 
-+#define EF_IA_64_ABI64		0x00000010	/* 64-bit ABI */
 
-+#define EF_IA_64_ARCH		0xff000000	/* arch. version mask */
 
-+
 
-+/* Processor specific values for the Phdr p_type field.  */
 
-+#define PT_IA_64_ARCHEXT	(PT_LOPROC + 0)	/* arch extension bits */
 
-+#define PT_IA_64_UNWIND		(PT_LOPROC + 1)	/* ia64 unwind bits */
 
-+#define PT_IA_64_HP_OPT_ANOT	(PT_LOOS + 0x12)
 
-+#define PT_IA_64_HP_HSL_ANOT	(PT_LOOS + 0x13)
 
-+#define PT_IA_64_HP_STACK	(PT_LOOS + 0x14)
 
-+
 
-+/* Processor specific flags for the Phdr p_flags field.  */
 
-+#define PF_IA_64_NORECOV	0x80000000	/* spec insns w/o recovery */
 
-+
 
-+/* Processor specific values for the Shdr sh_type field.  */
 
-+#define SHT_IA_64_EXT		(SHT_LOPROC + 0) /* extension bits */
 
-+#define SHT_IA_64_UNWIND	(SHT_LOPROC + 1) /* unwind bits */
 
-+
 
-+/* Processor specific flags for the Shdr sh_flags field.  */
 
-+#define SHF_IA_64_SHORT		0x10000000	/* section near gp */
 
-+#define SHF_IA_64_NORECOV	0x20000000	/* spec insns w/o recovery */
 
-+
 
-+/* Processor specific values for the Dyn d_tag field.  */
 
-+#define DT_IA_64_PLT_RESERVE	(DT_LOPROC + 0)
 
-+#define DT_IA_64_NUM		1
 
-+
 
-+/* IA-64 relocations.  */
 
-+#define R_IA64_NONE		0x00	/* none */
 
-+#define R_IA64_IMM14		0x21	/* symbol + addend, add imm14 */
 
-+#define R_IA64_IMM22		0x22	/* symbol + addend, add imm22 */
 
-+#define R_IA64_IMM64		0x23	/* symbol + addend, mov imm64 */
 
-+#define R_IA64_DIR32MSB		0x24	/* symbol + addend, data4 MSB */
 
-+#define R_IA64_DIR32LSB		0x25	/* symbol + addend, data4 LSB */
 
-+#define R_IA64_DIR64MSB		0x26	/* symbol + addend, data8 MSB */
 
-+#define R_IA64_DIR64LSB		0x27	/* symbol + addend, data8 LSB */
 
-+#define R_IA64_GPREL22		0x2a	/* @gprel(sym + add), add imm22 */
 
-+#define R_IA64_GPREL64I		0x2b	/* @gprel(sym + add), mov imm64 */
 
-+#define R_IA64_GPREL32MSB	0x2c	/* @gprel(sym + add), data4 MSB */
 
-+#define R_IA64_GPREL32LSB	0x2d	/* @gprel(sym + add), data4 LSB */
 
-+#define R_IA64_GPREL64MSB	0x2e	/* @gprel(sym + add), data8 MSB */
 
-+#define R_IA64_GPREL64LSB	0x2f	/* @gprel(sym + add), data8 LSB */
 
-+#define R_IA64_LTOFF22		0x32	/* @ltoff(sym + add), add imm22 */
 
-+#define R_IA64_LTOFF64I		0x33	/* @ltoff(sym + add), mov imm64 */
 
-+#define R_IA64_PLTOFF22		0x3a	/* @pltoff(sym + add), add imm22 */
 
-+#define R_IA64_PLTOFF64I	0x3b	/* @pltoff(sym + add), mov imm64 */
 
-+#define R_IA64_PLTOFF64MSB	0x3e	/* @pltoff(sym + add), data8 MSB */
 
-+#define R_IA64_PLTOFF64LSB	0x3f	/* @pltoff(sym + add), data8 LSB */
 
-+#define R_IA64_FPTR64I		0x43	/* @fptr(sym + add), mov imm64 */
 
-+#define R_IA64_FPTR32MSB	0x44	/* @fptr(sym + add), data4 MSB */
 
-+#define R_IA64_FPTR32LSB	0x45	/* @fptr(sym + add), data4 LSB */
 
-+#define R_IA64_FPTR64MSB	0x46	/* @fptr(sym + add), data8 MSB */
 
-+#define R_IA64_FPTR64LSB	0x47	/* @fptr(sym + add), data8 LSB */
 
-+#define R_IA64_PCREL60B		0x48	/* @pcrel(sym + add), brl */
 
-+#define R_IA64_PCREL21B		0x49	/* @pcrel(sym + add), ptb, call */
 
-+#define R_IA64_PCREL21M		0x4a	/* @pcrel(sym + add), chk.s */
 
-+#define R_IA64_PCREL21F		0x4b	/* @pcrel(sym + add), fchkf */
 
-+#define R_IA64_PCREL32MSB	0x4c	/* @pcrel(sym + add), data4 MSB */
 
-+#define R_IA64_PCREL32LSB	0x4d	/* @pcrel(sym + add), data4 LSB */
 
-+#define R_IA64_PCREL64MSB	0x4e	/* @pcrel(sym + add), data8 MSB */
 
-+#define R_IA64_PCREL64LSB	0x4f	/* @pcrel(sym + add), data8 LSB */
 
-+#define R_IA64_LTOFF_FPTR22	0x52	/* @ltoff(@fptr(s+a)), imm22 */
 
-+#define R_IA64_LTOFF_FPTR64I	0x53	/* @ltoff(@fptr(s+a)), imm64 */
 
-+#define R_IA64_LTOFF_FPTR32MSB	0x54	/* @ltoff(@fptr(s+a)), data4 MSB */
 
-+#define R_IA64_LTOFF_FPTR32LSB	0x55	/* @ltoff(@fptr(s+a)), data4 LSB */
 
-+#define R_IA64_LTOFF_FPTR64MSB	0x56	/* @ltoff(@fptr(s+a)), data8 MSB */
 
-+#define R_IA64_LTOFF_FPTR64LSB	0x57	/* @ltoff(@fptr(s+a)), data8 LSB */
 
-+#define R_IA64_SEGREL32MSB	0x5c	/* @segrel(sym + add), data4 MSB */
 
-+#define R_IA64_SEGREL32LSB	0x5d	/* @segrel(sym + add), data4 LSB */
 
-+#define R_IA64_SEGREL64MSB	0x5e	/* @segrel(sym + add), data8 MSB */
 
-+#define R_IA64_SEGREL64LSB	0x5f	/* @segrel(sym + add), data8 LSB */
 
-+#define R_IA64_SECREL32MSB	0x64	/* @secrel(sym + add), data4 MSB */
 
-+#define R_IA64_SECREL32LSB	0x65	/* @secrel(sym + add), data4 LSB */
 
-+#define R_IA64_SECREL64MSB	0x66	/* @secrel(sym + add), data8 MSB */
 
-+#define R_IA64_SECREL64LSB	0x67	/* @secrel(sym + add), data8 LSB */
 
-+#define R_IA64_REL32MSB		0x6c	/* data 4 + REL */
 
-+#define R_IA64_REL32LSB		0x6d	/* data 4 + REL */
 
-+#define R_IA64_REL64MSB		0x6e	/* data 8 + REL */
 
-+#define R_IA64_REL64LSB		0x6f	/* data 8 + REL */
 
-+#define R_IA64_LTV32MSB		0x74	/* symbol + addend, data4 MSB */
 
-+#define R_IA64_LTV32LSB		0x75	/* symbol + addend, data4 LSB */
 
-+#define R_IA64_LTV64MSB		0x76	/* symbol + addend, data8 MSB */
 
-+#define R_IA64_LTV64LSB		0x77	/* symbol + addend, data8 LSB */
 
-+#define R_IA64_PCREL21BI	0x79	/* @pcrel(sym + add), 21bit inst */
 
-+#define R_IA64_PCREL22		0x7a	/* @pcrel(sym + add), 22bit inst */
 
-+#define R_IA64_PCREL64I		0x7b	/* @pcrel(sym + add), 64bit inst */
 
-+#define R_IA64_IPLTMSB		0x80	/* dynamic reloc, imported PLT, MSB */
 
-+#define R_IA64_IPLTLSB		0x81	/* dynamic reloc, imported PLT, LSB */
 
-+#define R_IA64_COPY		0x84	/* copy relocation */
 
-+#define R_IA64_SUB		0x85	/* Addend and symbol difference */
 
-+#define R_IA64_LTOFF22X		0x86	/* LTOFF22, relaxable.  */
 
-+#define R_IA64_LDXMOV		0x87	/* Use of LTOFF22X.  */
 
-+#define R_IA64_TPREL14		0x91	/* @tprel(sym + add), imm14 */
 
-+#define R_IA64_TPREL22		0x92	/* @tprel(sym + add), imm22 */
 
-+#define R_IA64_TPREL64I		0x93	/* @tprel(sym + add), imm64 */
 
-+#define R_IA64_TPREL64MSB	0x96	/* @tprel(sym + add), data8 MSB */
 
-+#define R_IA64_TPREL64LSB	0x97	/* @tprel(sym + add), data8 LSB */
 
-+#define R_IA64_LTOFF_TPREL22	0x9a	/* @ltoff(@tprel(s+a)), imm2 */
 
-+#define R_IA64_DTPMOD64MSB	0xa6	/* @dtpmod(sym + add), data8 MSB */
 
-+#define R_IA64_DTPMOD64LSB	0xa7	/* @dtpmod(sym + add), data8 LSB */
 
-+#define R_IA64_LTOFF_DTPMOD22	0xaa	/* @ltoff(@dtpmod(sym + add)), imm22 */
 
-+#define R_IA64_DTPREL14		0xb1	/* @dtprel(sym + add), imm14 */
 
-+#define R_IA64_DTPREL22		0xb2	/* @dtprel(sym + add), imm22 */
 
-+#define R_IA64_DTPREL64I	0xb3	/* @dtprel(sym + add), imm64 */
 
-+#define R_IA64_DTPREL32MSB	0xb4	/* @dtprel(sym + add), data4 MSB */
 
-+#define R_IA64_DTPREL32LSB	0xb5	/* @dtprel(sym + add), data4 LSB */
 
-+#define R_IA64_DTPREL64MSB	0xb6	/* @dtprel(sym + add), data8 MSB */
 
-+#define R_IA64_DTPREL64LSB	0xb7	/* @dtprel(sym + add), data8 LSB */
 
-+#define R_IA64_LTOFF_DTPREL22	0xba	/* @ltoff(@dtprel(s+a)), imm22 */
 
-+
 
-+/* SH specific declarations */
 
-+
 
-+/* Processor specific flags for the ELF header e_flags field.  */
 
-+#define EF_SH_MACH_MASK		0x1f
 
-+#define EF_SH_UNKNOWN		0x0
 
-+#define EF_SH1			0x1
 
-+#define EF_SH2			0x2
 
-+#define EF_SH3			0x3
 
-+#define EF_SH_DSP		0x4
 
-+#define EF_SH3_DSP		0x5
 
-+#define EF_SH4AL_DSP		0x6
 
-+#define EF_SH3E			0x8
 
-+#define EF_SH4			0x9
 
-+#define EF_SH2E			0xb
 
-+#define EF_SH4A			0xc
 
-+#define EF_SH2A			0xd
 
-+#define EF_SH4_NOFPU		0x10
 
-+#define EF_SH4A_NOFPU		0x11
 
-+#define EF_SH4_NOMMU_NOFPU	0x12
 
-+#define EF_SH2A_NOFPU		0x13
 
-+#define EF_SH3_NOMMU		0x14
 
-+#define EF_SH2A_SH4_NOFPU	0x15
 
-+#define EF_SH2A_SH3_NOFPU	0x16
 
-+#define EF_SH2A_SH4		0x17
 
-+#define EF_SH2A_SH3E		0x18
 
-+
 
-+/* SH relocs.  */
 
-+#define	R_SH_NONE		0
 
-+#define	R_SH_DIR32		1
 
-+#define	R_SH_REL32		2
 
-+#define	R_SH_DIR8WPN		3
 
-+#define	R_SH_IND12W		4
 
-+#define	R_SH_DIR8WPL		5
 
-+#define	R_SH_DIR8WPZ		6
 
-+#define	R_SH_DIR8BP		7
 
-+#define	R_SH_DIR8W		8
 
-+#define	R_SH_DIR8L		9
 
-+#define	R_SH_SWITCH16		25
 
-+#define	R_SH_SWITCH32		26
 
-+#define	R_SH_USES		27
 
-+#define	R_SH_COUNT		28
 
-+#define	R_SH_ALIGN		29
 
-+#define	R_SH_CODE		30
 
-+#define	R_SH_DATA		31
 
-+#define	R_SH_LABEL		32
 
-+#define	R_SH_SWITCH8		33
 
-+#define	R_SH_GNU_VTINHERIT	34
 
-+#define	R_SH_GNU_VTENTRY	35
 
-+#define	R_SH_TLS_GD_32		144
 
-+#define	R_SH_TLS_LD_32		145
 
-+#define	R_SH_TLS_LDO_32		146
 
-+#define	R_SH_TLS_IE_32		147
 
-+#define	R_SH_TLS_LE_32		148
 
-+#define	R_SH_TLS_DTPMOD32	149
 
-+#define	R_SH_TLS_DTPOFF32	150
 
-+#define	R_SH_TLS_TPOFF32	151
 
-+#define	R_SH_GOT32		160
 
-+#define	R_SH_PLT32		161
 
-+#define	R_SH_COPY		162
 
-+#define	R_SH_GLOB_DAT		163
 
-+#define	R_SH_JMP_SLOT		164
 
-+#define	R_SH_RELATIVE		165
 
-+#define	R_SH_GOTOFF		166
 
-+#define	R_SH_GOTPC		167
 
-+/* Keep this the last entry.  */
 
-+#define	R_SH_NUM		256
 
-+
 
-+/* S/390 specific definitions.  */
 
-+
 
-+/* Valid values for the e_flags field.  */
 
-+
 
-+#define EF_S390_HIGH_GPRS    0x00000001  /* High GPRs kernel facility needed.  */
 
-+
 
-+/* Additional s390 relocs */
 
-+
 
-+#define R_390_NONE		0	/* No reloc.  */
 
-+#define R_390_8			1	/* Direct 8 bit.  */
 
-+#define R_390_12		2	/* Direct 12 bit.  */
 
-+#define R_390_16		3	/* Direct 16 bit.  */
 
-+#define R_390_32		4	/* Direct 32 bit.  */
 
-+#define R_390_PC32		5	/* PC relative 32 bit.	*/
 
-+#define R_390_GOT12		6	/* 12 bit GOT offset.  */
 
-+#define R_390_GOT32		7	/* 32 bit GOT offset.  */
 
-+#define R_390_PLT32		8	/* 32 bit PC relative PLT address.  */
 
-+#define R_390_COPY		9	/* Copy symbol at runtime.  */
 
-+#define R_390_GLOB_DAT		10	/* Create GOT entry.  */
 
-+#define R_390_JMP_SLOT		11	/* Create PLT entry.  */
 
-+#define R_390_RELATIVE		12	/* Adjust by program base.  */
 
-+#define R_390_GOTOFF32		13	/* 32 bit offset to GOT.	 */
 
-+#define R_390_GOTPC		14	/* 32 bit PC relative offset to GOT.  */
 
-+#define R_390_GOT16		15	/* 16 bit GOT offset.  */
 
-+#define R_390_PC16		16	/* PC relative 16 bit.	*/
 
-+#define R_390_PC16DBL		17	/* PC relative 16 bit shifted by 1.  */
 
-+#define R_390_PLT16DBL		18	/* 16 bit PC rel. PLT shifted by 1.  */
 
-+#define R_390_PC32DBL		19	/* PC relative 32 bit shifted by 1.  */
 
-+#define R_390_PLT32DBL		20	/* 32 bit PC rel. PLT shifted by 1.  */
 
-+#define R_390_GOTPCDBL		21	/* 32 bit PC rel. GOT shifted by 1.  */
 
-+#define R_390_64		22	/* Direct 64 bit.  */
 
-+#define R_390_PC64		23	/* PC relative 64 bit.	*/
 
-+#define R_390_GOT64		24	/* 64 bit GOT offset.  */
 
-+#define R_390_PLT64		25	/* 64 bit PC relative PLT address.  */
 
-+#define R_390_GOTENT		26	/* 32 bit PC rel. to GOT entry >> 1. */
 
-+#define R_390_GOTOFF16		27	/* 16 bit offset to GOT. */
 
-+#define R_390_GOTOFF64		28	/* 64 bit offset to GOT. */
 
-+#define R_390_GOTPLT12		29	/* 12 bit offset to jump slot.	*/
 
-+#define R_390_GOTPLT16		30	/* 16 bit offset to jump slot.	*/
 
-+#define R_390_GOTPLT32		31	/* 32 bit offset to jump slot.	*/
 
-+#define R_390_GOTPLT64		32	/* 64 bit offset to jump slot.	*/
 
-+#define R_390_GOTPLTENT		33	/* 32 bit rel. offset to jump slot.  */
 
-+#define R_390_PLTOFF16		34	/* 16 bit offset from GOT to PLT. */
 
-+#define R_390_PLTOFF32		35	/* 32 bit offset from GOT to PLT. */
 
-+#define R_390_PLTOFF64		36	/* 16 bit offset from GOT to PLT. */
 
-+#define R_390_TLS_LOAD		37	/* Tag for load insn in TLS code.  */
 
-+#define R_390_TLS_GDCALL	38	/* Tag for function call in general
 
-+					   dynamic TLS code. */
 
-+#define R_390_TLS_LDCALL	39	/* Tag for function call in local
 
-+					   dynamic TLS code. */
 
-+#define R_390_TLS_GD32		40	/* Direct 32 bit for general dynamic
 
-+					   thread local data.  */
 
-+#define R_390_TLS_GD64		41	/* Direct 64 bit for general dynamic
 
-+					  thread local data.  */
 
-+#define R_390_TLS_GOTIE12	42	/* 12 bit GOT offset for static TLS
 
-+					   block offset.  */
 
-+#define R_390_TLS_GOTIE32	43	/* 32 bit GOT offset for static TLS
 
-+					   block offset.  */
 
-+#define R_390_TLS_GOTIE64	44	/* 64 bit GOT offset for static TLS
 
-+					   block offset. */
 
-+#define R_390_TLS_LDM32		45	/* Direct 32 bit for local dynamic
 
-+					   thread local data in LE code.  */
 
-+#define R_390_TLS_LDM64		46	/* Direct 64 bit for local dynamic
 
-+					   thread local data in LE code.  */
 
-+#define R_390_TLS_IE32		47	/* 32 bit address of GOT entry for
 
-+					   negated static TLS block offset.  */
 
-+#define R_390_TLS_IE64		48	/* 64 bit address of GOT entry for
 
-+					   negated static TLS block offset.  */
 
-+#define R_390_TLS_IEENT		49	/* 32 bit rel. offset to GOT entry for
 
-+					   negated static TLS block offset.  */
 
-+#define R_390_TLS_LE32		50	/* 32 bit negated offset relative to
 
-+					   static TLS block.  */
 
-+#define R_390_TLS_LE64		51	/* 64 bit negated offset relative to
 
-+					   static TLS block.  */
 
-+#define R_390_TLS_LDO32		52	/* 32 bit offset relative to TLS
 
-+					   block.  */
 
-+#define R_390_TLS_LDO64		53	/* 64 bit offset relative to TLS
 
-+					   block.  */
 
-+#define R_390_TLS_DTPMOD	54	/* ID of module containing symbol.  */
 
-+#define R_390_TLS_DTPOFF	55	/* Offset in TLS block.	 */
 
-+#define R_390_TLS_TPOFF		56	/* Negated offset in static TLS
 
-+					   block.  */
 
-+#define R_390_20		57	/* Direct 20 bit.  */
 
-+#define R_390_GOT20		58	/* 20 bit GOT offset.  */
 
-+#define R_390_GOTPLT20		59	/* 20 bit offset to jump slot.  */
 
-+#define R_390_TLS_GOTIE20	60	/* 20 bit GOT offset for static TLS
 
-+					   block offset.  */
 
-+#define R_390_IRELATIVE         61      /* STT_GNU_IFUNC relocation.  */
 
-+/* Keep this the last entry.  */
 
-+#define R_390_NUM		62
 
-+
 
-+
 
-+/* CRIS relocations.  */
 
-+#define R_CRIS_NONE		0
 
-+#define R_CRIS_8		1
 
-+#define R_CRIS_16		2
 
-+#define R_CRIS_32		3
 
-+#define R_CRIS_8_PCREL		4
 
-+#define R_CRIS_16_PCREL		5
 
-+#define R_CRIS_32_PCREL		6
 
-+#define R_CRIS_GNU_VTINHERIT	7
 
-+#define R_CRIS_GNU_VTENTRY	8
 
-+#define R_CRIS_COPY		9
 
-+#define R_CRIS_GLOB_DAT		10
 
-+#define R_CRIS_JUMP_SLOT	11
 
-+#define R_CRIS_RELATIVE		12
 
-+#define R_CRIS_16_GOT		13
 
-+#define R_CRIS_32_GOT		14
 
-+#define R_CRIS_16_GOTPLT	15
 
-+#define R_CRIS_32_GOTPLT	16
 
-+#define R_CRIS_32_GOTREL	17
 
-+#define R_CRIS_32_PLT_GOTREL	18
 
-+#define R_CRIS_32_PLT_PCREL	19
 
-+
 
-+#define R_CRIS_NUM		20
 
-+
 
-+
 
-+/* AMD x86-64 relocations.  */
 
-+#define R_X86_64_NONE		0	/* No reloc */
 
-+#define R_X86_64_64		1	/* Direct 64 bit  */
 
-+#define R_X86_64_PC32		2	/* PC relative 32 bit signed */
 
-+#define R_X86_64_GOT32		3	/* 32 bit GOT entry */
 
-+#define R_X86_64_PLT32		4	/* 32 bit PLT address */
 
-+#define R_X86_64_COPY		5	/* Copy symbol at runtime */
 
-+#define R_X86_64_GLOB_DAT	6	/* Create GOT entry */
 
-+#define R_X86_64_JUMP_SLOT	7	/* Create PLT entry */
 
-+#define R_X86_64_RELATIVE	8	/* Adjust by program base */
 
-+#define R_X86_64_GOTPCREL	9	/* 32 bit signed PC relative
 
-+					   offset to GOT */
 
-+#define R_X86_64_32		10	/* Direct 32 bit zero extended */
 
-+#define R_X86_64_32S		11	/* Direct 32 bit sign extended */
 
-+#define R_X86_64_16		12	/* Direct 16 bit zero extended */
 
-+#define R_X86_64_PC16		13	/* 16 bit sign extended pc relative */
 
-+#define R_X86_64_8		14	/* Direct 8 bit sign extended  */
 
-+#define R_X86_64_PC8		15	/* 8 bit sign extended pc relative */
 
-+#define R_X86_64_DTPMOD64	16	/* ID of module containing symbol */
 
-+#define R_X86_64_DTPOFF64	17	/* Offset in module's TLS block */
 
-+#define R_X86_64_TPOFF64	18	/* Offset in initial TLS block */
 
-+#define R_X86_64_TLSGD		19	/* 32 bit signed PC relative offset
 
-+					   to two GOT entries for GD symbol */
 
-+#define R_X86_64_TLSLD		20	/* 32 bit signed PC relative offset
 
-+					   to two GOT entries for LD symbol */
 
-+#define R_X86_64_DTPOFF32	21	/* Offset in TLS block */
 
-+#define R_X86_64_GOTTPOFF	22	/* 32 bit signed PC relative offset
 
-+					   to GOT entry for IE symbol */
 
-+#define R_X86_64_TPOFF32	23	/* Offset in initial TLS block */
 
-+#define R_X86_64_PC64		24	/* PC relative 64 bit */
 
-+#define R_X86_64_GOTOFF64	25	/* 64 bit offset to GOT */
 
-+#define R_X86_64_GOTPC32	26	/* 32 bit signed pc relative
 
-+					   offset to GOT */
 
-+#define R_X86_64_GOT64		27	/* 64-bit GOT entry offset */
 
-+#define R_X86_64_GOTPCREL64	28	/* 64-bit PC relative offset
 
-+					   to GOT entry */
 
-+#define R_X86_64_GOTPC64	29	/* 64-bit PC relative offset to GOT */
 
-+#define R_X86_64_GOTPLT64	30 	/* like GOT64, says PLT entry needed */
 
-+#define R_X86_64_PLTOFF64	31	/* 64-bit GOT relative offset
 
-+					   to PLT entry */
 
-+#define R_X86_64_SIZE32		32	/* Size of symbol plus 32-bit addend */
 
-+#define R_X86_64_SIZE64		33	/* Size of symbol plus 64-bit addend */
 
-+#define R_X86_64_GOTPC32_TLSDESC 34	/* GOT offset for TLS descriptor.  */
 
-+#define R_X86_64_TLSDESC_CALL   35	/* Marker for call through TLS
 
-+					   descriptor.  */
 
-+#define R_X86_64_TLSDESC        36	/* TLS descriptor.  */
 
-+#define R_X86_64_IRELATIVE	37	/* Adjust indirectly by program base */
 
-+#define R_X86_64_RELATIVE64	38	/* 64-bit adjust by program base */
 
-+
 
-+#define R_X86_64_NUM		39
 
-+
 
-+
 
-+/* AM33 relocations.  */
 
-+#define R_MN10300_NONE		0	/* No reloc.  */
 
-+#define R_MN10300_32		1	/* Direct 32 bit.  */
 
-+#define R_MN10300_16		2	/* Direct 16 bit.  */
 
-+#define R_MN10300_8		3	/* Direct 8 bit.  */
 
-+#define R_MN10300_PCREL32	4	/* PC-relative 32-bit.  */
 
-+#define R_MN10300_PCREL16	5	/* PC-relative 16-bit signed.  */
 
-+#define R_MN10300_PCREL8	6	/* PC-relative 8-bit signed.  */
 
-+#define R_MN10300_GNU_VTINHERIT	7	/* Ancient C++ vtable garbage... */
 
-+#define R_MN10300_GNU_VTENTRY	8	/* ... collection annotation.  */
 
-+#define R_MN10300_24		9	/* Direct 24 bit.  */
 
-+#define R_MN10300_GOTPC32	10	/* 32-bit PCrel offset to GOT.  */
 
-+#define R_MN10300_GOTPC16	11	/* 16-bit PCrel offset to GOT.  */
 
-+#define R_MN10300_GOTOFF32	12	/* 32-bit offset from GOT.  */
 
-+#define R_MN10300_GOTOFF24	13	/* 24-bit offset from GOT.  */
 
-+#define R_MN10300_GOTOFF16	14	/* 16-bit offset from GOT.  */
 
-+#define R_MN10300_PLT32		15	/* 32-bit PCrel to PLT entry.  */
 
-+#define R_MN10300_PLT16		16	/* 16-bit PCrel to PLT entry.  */
 
-+#define R_MN10300_GOT32		17	/* 32-bit offset to GOT entry.  */
 
-+#define R_MN10300_GOT24		18	/* 24-bit offset to GOT entry.  */
 
-+#define R_MN10300_GOT16		19	/* 16-bit offset to GOT entry.  */
 
-+#define R_MN10300_COPY		20	/* Copy symbol at runtime.  */
 
-+#define R_MN10300_GLOB_DAT	21	/* Create GOT entry.  */
 
-+#define R_MN10300_JMP_SLOT	22	/* Create PLT entry.  */
 
-+#define R_MN10300_RELATIVE	23	/* Adjust by program base.  */
 
-+
 
-+#define R_MN10300_NUM		24
 
-+
 
-+
 
-+/* M32R relocs.  */
 
-+#define R_M32R_NONE		0	/* No reloc. */
 
-+#define R_M32R_16		1	/* Direct 16 bit. */
 
-+#define R_M32R_32		2	/* Direct 32 bit. */
 
-+#define R_M32R_24		3	/* Direct 24 bit. */
 
-+#define R_M32R_10_PCREL		4	/* PC relative 10 bit shifted. */
 
-+#define R_M32R_18_PCREL		5	/* PC relative 18 bit shifted. */
 
-+#define R_M32R_26_PCREL		6	/* PC relative 26 bit shifted. */
 
-+#define R_M32R_HI16_ULO		7	/* High 16 bit with unsigned low. */
 
-+#define R_M32R_HI16_SLO		8	/* High 16 bit with signed low. */
 
-+#define R_M32R_LO16		9	/* Low 16 bit. */
 
-+#define R_M32R_SDA16		10	/* 16 bit offset in SDA. */
 
-+#define R_M32R_GNU_VTINHERIT	11
 
-+#define R_M32R_GNU_VTENTRY	12
 
-+/* M32R relocs use SHT_RELA.  */
 
-+#define R_M32R_16_RELA		33	/* Direct 16 bit. */
 
-+#define R_M32R_32_RELA		34	/* Direct 32 bit. */
 
-+#define R_M32R_24_RELA		35	/* Direct 24 bit. */
 
-+#define R_M32R_10_PCREL_RELA	36	/* PC relative 10 bit shifted. */
 
-+#define R_M32R_18_PCREL_RELA	37	/* PC relative 18 bit shifted. */
 
-+#define R_M32R_26_PCREL_RELA	38	/* PC relative 26 bit shifted. */
 
-+#define R_M32R_HI16_ULO_RELA	39	/* High 16 bit with unsigned low */
 
-+#define R_M32R_HI16_SLO_RELA	40	/* High 16 bit with signed low */
 
-+#define R_M32R_LO16_RELA	41	/* Low 16 bit */
 
-+#define R_M32R_SDA16_RELA	42	/* 16 bit offset in SDA */
 
-+#define R_M32R_RELA_GNU_VTINHERIT	43
 
-+#define R_M32R_RELA_GNU_VTENTRY	44
 
-+#define R_M32R_REL32		45	/* PC relative 32 bit.  */
 
-+
 
-+#define R_M32R_GOT24		48	/* 24 bit GOT entry */
 
-+#define R_M32R_26_PLTREL	49	/* 26 bit PC relative to PLT shifted */
 
-+#define R_M32R_COPY		50	/* Copy symbol at runtime */
 
-+#define R_M32R_GLOB_DAT		51	/* Create GOT entry */
 
-+#define R_M32R_JMP_SLOT		52	/* Create PLT entry */
 
-+#define R_M32R_RELATIVE		53	/* Adjust by program base */
 
-+#define R_M32R_GOTOFF		54	/* 24 bit offset to GOT */
 
-+#define R_M32R_GOTPC24		55	/* 24 bit PC relative offset to GOT */
 
-+#define R_M32R_GOT16_HI_ULO	56	/* High 16 bit GOT entry with unsigned
 
-+					   low */
 
-+#define R_M32R_GOT16_HI_SLO	57	/* High 16 bit GOT entry with signed
 
-+					   low */
 
-+#define R_M32R_GOT16_LO		58	/* Low 16 bit GOT entry */
 
-+#define R_M32R_GOTPC_HI_ULO	59	/* High 16 bit PC relative offset to
 
-+					   GOT with unsigned low */
 
-+#define R_M32R_GOTPC_HI_SLO	60	/* High 16 bit PC relative offset to
 
-+					   GOT with signed low */
 
-+#define R_M32R_GOTPC_LO		61	/* Low 16 bit PC relative offset to
 
-+					   GOT */
 
-+#define R_M32R_GOTOFF_HI_ULO	62	/* High 16 bit offset to GOT
 
-+					   with unsigned low */
 
-+#define R_M32R_GOTOFF_HI_SLO	63	/* High 16 bit offset to GOT
 
-+					   with signed low */
 
-+#define R_M32R_GOTOFF_LO	64	/* Low 16 bit offset to GOT */
 
-+#define R_M32R_NUM		256	/* Keep this the last entry. */
 
-+
 
-+
 
-+/* TILEPro relocations.  */
 
-+#define R_TILEPRO_NONE		0	/* No reloc */
 
-+#define R_TILEPRO_32		1	/* Direct 32 bit */
 
-+#define R_TILEPRO_16		2	/* Direct 16 bit */
 
-+#define R_TILEPRO_8		3	/* Direct 8 bit */
 
-+#define R_TILEPRO_32_PCREL	4	/* PC relative 32 bit */
 
-+#define R_TILEPRO_16_PCREL	5	/* PC relative 16 bit */
 
-+#define R_TILEPRO_8_PCREL	6	/* PC relative 8 bit */
 
-+#define R_TILEPRO_LO16		7	/* Low 16 bit */
 
-+#define R_TILEPRO_HI16		8	/* High 16 bit */
 
-+#define R_TILEPRO_HA16		9	/* High 16 bit, adjusted */
 
-+#define R_TILEPRO_COPY		10	/* Copy relocation */
 
-+#define R_TILEPRO_GLOB_DAT	11	/* Create GOT entry */
 
-+#define R_TILEPRO_JMP_SLOT	12	/* Create PLT entry */
 
-+#define R_TILEPRO_RELATIVE	13	/* Adjust by program base */
 
-+#define R_TILEPRO_BROFF_X1	14	/* X1 pipe branch offset */
 
-+#define R_TILEPRO_JOFFLONG_X1	15	/* X1 pipe jump offset */
 
-+#define R_TILEPRO_JOFFLONG_X1_PLT 16	/* X1 pipe jump offset to PLT */
 
-+#define R_TILEPRO_IMM8_X0	17	/* X0 pipe 8-bit */
 
-+#define R_TILEPRO_IMM8_Y0	18	/* Y0 pipe 8-bit */
 
-+#define R_TILEPRO_IMM8_X1	19	/* X1 pipe 8-bit */
 
-+#define R_TILEPRO_IMM8_Y1	20	/* Y1 pipe 8-bit */
 
-+#define R_TILEPRO_MT_IMM15_X1	21	/* X1 pipe mtspr */
 
-+#define R_TILEPRO_MF_IMM15_X1	22	/* X1 pipe mfspr */
 
-+#define R_TILEPRO_IMM16_X0	23	/* X0 pipe 16-bit */
 
-+#define R_TILEPRO_IMM16_X1	24	/* X1 pipe 16-bit */
 
-+#define R_TILEPRO_IMM16_X0_LO	25	/* X0 pipe low 16-bit */
 
-+#define R_TILEPRO_IMM16_X1_LO	26	/* X1 pipe low 16-bit */
 
-+#define R_TILEPRO_IMM16_X0_HI	27	/* X0 pipe high 16-bit */
 
-+#define R_TILEPRO_IMM16_X1_HI	28	/* X1 pipe high 16-bit */
 
-+#define R_TILEPRO_IMM16_X0_HA	29	/* X0 pipe high 16-bit, adjusted */
 
-+#define R_TILEPRO_IMM16_X1_HA	30	/* X1 pipe high 16-bit, adjusted */
 
-+#define R_TILEPRO_IMM16_X0_PCREL 31	/* X0 pipe PC relative 16 bit */
 
-+#define R_TILEPRO_IMM16_X1_PCREL 32	/* X1 pipe PC relative 16 bit */
 
-+#define R_TILEPRO_IMM16_X0_LO_PCREL 33	/* X0 pipe PC relative low 16 bit */
 
-+#define R_TILEPRO_IMM16_X1_LO_PCREL 34	/* X1 pipe PC relative low 16 bit */
 
-+#define R_TILEPRO_IMM16_X0_HI_PCREL 35	/* X0 pipe PC relative high 16 bit */
 
-+#define R_TILEPRO_IMM16_X1_HI_PCREL 36	/* X1 pipe PC relative high 16 bit */
 
-+#define R_TILEPRO_IMM16_X0_HA_PCREL 37	/* X0 pipe PC relative ha() 16 bit */
 
-+#define R_TILEPRO_IMM16_X1_HA_PCREL 38	/* X1 pipe PC relative ha() 16 bit */
 
-+#define R_TILEPRO_IMM16_X0_GOT	39	/* X0 pipe 16-bit GOT offset */
 
-+#define R_TILEPRO_IMM16_X1_GOT	40	/* X1 pipe 16-bit GOT offset */
 
-+#define R_TILEPRO_IMM16_X0_GOT_LO 41	/* X0 pipe low 16-bit GOT offset */
 
-+#define R_TILEPRO_IMM16_X1_GOT_LO 42	/* X1 pipe low 16-bit GOT offset */
 
-+#define R_TILEPRO_IMM16_X0_GOT_HI 43	/* X0 pipe high 16-bit GOT offset */
 
-+#define R_TILEPRO_IMM16_X1_GOT_HI 44	/* X1 pipe high 16-bit GOT offset */
 
-+#define R_TILEPRO_IMM16_X0_GOT_HA 45	/* X0 pipe ha() 16-bit GOT offset */
 
-+#define R_TILEPRO_IMM16_X1_GOT_HA 46	/* X1 pipe ha() 16-bit GOT offset */
 
-+#define R_TILEPRO_MMSTART_X0	47	/* X0 pipe mm "start" */
 
-+#define R_TILEPRO_MMEND_X0	48	/* X0 pipe mm "end" */
 
-+#define R_TILEPRO_MMSTART_X1	49	/* X1 pipe mm "start" */
 
-+#define R_TILEPRO_MMEND_X1	50	/* X1 pipe mm "end" */
 
-+#define R_TILEPRO_SHAMT_X0	51	/* X0 pipe shift amount */
 
-+#define R_TILEPRO_SHAMT_X1	52	/* X1 pipe shift amount */
 
-+#define R_TILEPRO_SHAMT_Y0	53	/* Y0 pipe shift amount */
 
-+#define R_TILEPRO_SHAMT_Y1	54	/* Y1 pipe shift amount */
 
-+#define R_TILEPRO_DEST_IMM8_X1	55	/* X1 pipe destination 8-bit */
 
-+/* Relocs 56-59 are currently not defined.  */
 
-+#define R_TILEPRO_TLS_GD_CALL	60	/* "jal" for TLS GD */
 
-+#define R_TILEPRO_IMM8_X0_TLS_GD_ADD 61	/* X0 pipe "addi" for TLS GD */
 
-+#define R_TILEPRO_IMM8_X1_TLS_GD_ADD 62	/* X1 pipe "addi" for TLS GD */
 
-+#define R_TILEPRO_IMM8_Y0_TLS_GD_ADD 63	/* Y0 pipe "addi" for TLS GD */
 
-+#define R_TILEPRO_IMM8_Y1_TLS_GD_ADD 64	/* Y1 pipe "addi" for TLS GD */
 
-+#define R_TILEPRO_TLS_IE_LOAD	65	/* "lw_tls" for TLS IE */
 
-+#define R_TILEPRO_IMM16_X0_TLS_GD 66	/* X0 pipe 16-bit TLS GD offset */
 
-+#define R_TILEPRO_IMM16_X1_TLS_GD 67	/* X1 pipe 16-bit TLS GD offset */
 
-+#define R_TILEPRO_IMM16_X0_TLS_GD_LO 68	/* X0 pipe low 16-bit TLS GD offset */
 
-+#define R_TILEPRO_IMM16_X1_TLS_GD_LO 69	/* X1 pipe low 16-bit TLS GD offset */
 
-+#define R_TILEPRO_IMM16_X0_TLS_GD_HI 70	/* X0 pipe high 16-bit TLS GD offset */
 
-+#define R_TILEPRO_IMM16_X1_TLS_GD_HI 71	/* X1 pipe high 16-bit TLS GD offset */
 
-+#define R_TILEPRO_IMM16_X0_TLS_GD_HA 72	/* X0 pipe ha() 16-bit TLS GD offset */
 
-+#define R_TILEPRO_IMM16_X1_TLS_GD_HA 73	/* X1 pipe ha() 16-bit TLS GD offset */
 
-+#define R_TILEPRO_IMM16_X0_TLS_IE 74	/* X0 pipe 16-bit TLS IE offset */
 
-+#define R_TILEPRO_IMM16_X1_TLS_IE 75	/* X1 pipe 16-bit TLS IE offset */
 
-+#define R_TILEPRO_IMM16_X0_TLS_IE_LO 76	/* X0 pipe low 16-bit TLS IE offset */
 
-+#define R_TILEPRO_IMM16_X1_TLS_IE_LO 77	/* X1 pipe low 16-bit TLS IE offset */
 
-+#define R_TILEPRO_IMM16_X0_TLS_IE_HI 78	/* X0 pipe high 16-bit TLS IE offset */
 
-+#define R_TILEPRO_IMM16_X1_TLS_IE_HI 79	/* X1 pipe high 16-bit TLS IE offset */
 
-+#define R_TILEPRO_IMM16_X0_TLS_IE_HA 80	/* X0 pipe ha() 16-bit TLS IE offset */
 
-+#define R_TILEPRO_IMM16_X1_TLS_IE_HA 81	/* X1 pipe ha() 16-bit TLS IE offset */
 
-+#define R_TILEPRO_TLS_DTPMOD32	82	/* ID of module containing symbol */
 
-+#define R_TILEPRO_TLS_DTPOFF32	83	/* Offset in TLS block */
 
-+#define R_TILEPRO_TLS_TPOFF32	84	/* Offset in static TLS block */
 
-+#define R_TILEPRO_IMM16_X0_TLS_LE 85	/* X0 pipe 16-bit TLS LE offset */
 
-+#define R_TILEPRO_IMM16_X1_TLS_LE 86	/* X1 pipe 16-bit TLS LE offset */
 
-+#define R_TILEPRO_IMM16_X0_TLS_LE_LO 87	/* X0 pipe low 16-bit TLS LE offset */
 
-+#define R_TILEPRO_IMM16_X1_TLS_LE_LO 88	/* X1 pipe low 16-bit TLS LE offset */
 
-+#define R_TILEPRO_IMM16_X0_TLS_LE_HI 89	/* X0 pipe high 16-bit TLS LE offset */
 
-+#define R_TILEPRO_IMM16_X1_TLS_LE_HI 90	/* X1 pipe high 16-bit TLS LE offset */
 
-+#define R_TILEPRO_IMM16_X0_TLS_LE_HA 91	/* X0 pipe ha() 16-bit TLS LE offset */
 
-+#define R_TILEPRO_IMM16_X1_TLS_LE_HA 92	/* X1 pipe ha() 16-bit TLS LE offset */
 
-+
 
-+#define R_TILEPRO_GNU_VTINHERIT	128	/* GNU C++ vtable hierarchy */
 
-+#define R_TILEPRO_GNU_VTENTRY	129	/* GNU C++ vtable member usage */
 
-+
 
-+#define R_TILEPRO_NUM		130
 
-+
 
-+
 
-+/* TILE-Gx relocations.  */
 
-+#define R_TILEGX_NONE		0	/* No reloc */
 
-+#define R_TILEGX_64		1	/* Direct 64 bit */
 
-+#define R_TILEGX_32		2	/* Direct 32 bit */
 
-+#define R_TILEGX_16		3	/* Direct 16 bit */
 
-+#define R_TILEGX_8		4	/* Direct 8 bit */
 
-+#define R_TILEGX_64_PCREL	5	/* PC relative 64 bit */
 
-+#define R_TILEGX_32_PCREL	6	/* PC relative 32 bit */
 
-+#define R_TILEGX_16_PCREL	7	/* PC relative 16 bit */
 
-+#define R_TILEGX_8_PCREL	8	/* PC relative 8 bit */
 
-+#define R_TILEGX_HW0		9	/* hword 0 16-bit */
 
-+#define R_TILEGX_HW1		10	/* hword 1 16-bit */
 
-+#define R_TILEGX_HW2		11	/* hword 2 16-bit */
 
-+#define R_TILEGX_HW3		12	/* hword 3 16-bit */
 
-+#define R_TILEGX_HW0_LAST	13	/* last hword 0 16-bit */
 
-+#define R_TILEGX_HW1_LAST	14	/* last hword 1 16-bit */
 
-+#define R_TILEGX_HW2_LAST	15	/* last hword 2 16-bit */
 
-+#define R_TILEGX_COPY		16	/* Copy relocation */
 
-+#define R_TILEGX_GLOB_DAT	17	/* Create GOT entry */
 
-+#define R_TILEGX_JMP_SLOT	18	/* Create PLT entry */
 
-+#define R_TILEGX_RELATIVE	19	/* Adjust by program base */
 
-+#define R_TILEGX_BROFF_X1	20	/* X1 pipe branch offset */
 
-+#define R_TILEGX_JUMPOFF_X1	21	/* X1 pipe jump offset */
 
-+#define R_TILEGX_JUMPOFF_X1_PLT	22	/* X1 pipe jump offset to PLT */
 
-+#define R_TILEGX_IMM8_X0	23	/* X0 pipe 8-bit */
 
-+#define R_TILEGX_IMM8_Y0	24	/* Y0 pipe 8-bit */
 
-+#define R_TILEGX_IMM8_X1	25	/* X1 pipe 8-bit */
 
-+#define R_TILEGX_IMM8_Y1	26	/* Y1 pipe 8-bit */
 
-+#define R_TILEGX_DEST_IMM8_X1	27	/* X1 pipe destination 8-bit */
 
-+#define R_TILEGX_MT_IMM14_X1	28	/* X1 pipe mtspr */
 
-+#define R_TILEGX_MF_IMM14_X1	29	/* X1 pipe mfspr */
 
-+#define R_TILEGX_MMSTART_X0	30	/* X0 pipe mm "start" */
 
-+#define R_TILEGX_MMEND_X0	31	/* X0 pipe mm "end" */
 
-+#define R_TILEGX_SHAMT_X0	32	/* X0 pipe shift amount */
 
-+#define R_TILEGX_SHAMT_X1	33	/* X1 pipe shift amount */
 
-+#define R_TILEGX_SHAMT_Y0	34	/* Y0 pipe shift amount */
 
-+#define R_TILEGX_SHAMT_Y1	35	/* Y1 pipe shift amount */
 
-+#define R_TILEGX_IMM16_X0_HW0	36	/* X0 pipe hword 0 */
 
-+#define R_TILEGX_IMM16_X1_HW0	37	/* X1 pipe hword 0 */
 
-+#define R_TILEGX_IMM16_X0_HW1	38	/* X0 pipe hword 1 */
 
-+#define R_TILEGX_IMM16_X1_HW1	39	/* X1 pipe hword 1 */
 
-+#define R_TILEGX_IMM16_X0_HW2	40	/* X0 pipe hword 2 */
 
-+#define R_TILEGX_IMM16_X1_HW2	41	/* X1 pipe hword 2 */
 
-+#define R_TILEGX_IMM16_X0_HW3	42	/* X0 pipe hword 3 */
 
-+#define R_TILEGX_IMM16_X1_HW3	43	/* X1 pipe hword 3 */
 
-+#define R_TILEGX_IMM16_X0_HW0_LAST 44	/* X0 pipe last hword 0 */
 
-+#define R_TILEGX_IMM16_X1_HW0_LAST 45	/* X1 pipe last hword 0 */
 
-+#define R_TILEGX_IMM16_X0_HW1_LAST 46	/* X0 pipe last hword 1 */
 
-+#define R_TILEGX_IMM16_X1_HW1_LAST 47	/* X1 pipe last hword 1 */
 
-+#define R_TILEGX_IMM16_X0_HW2_LAST 48	/* X0 pipe last hword 2 */
 
-+#define R_TILEGX_IMM16_X1_HW2_LAST 49	/* X1 pipe last hword 2 */
 
-+#define R_TILEGX_IMM16_X0_HW0_PCREL 50	/* X0 pipe PC relative hword 0 */
 
-+#define R_TILEGX_IMM16_X1_HW0_PCREL 51	/* X1 pipe PC relative hword 0 */
 
-+#define R_TILEGX_IMM16_X0_HW1_PCREL 52	/* X0 pipe PC relative hword 1 */
 
-+#define R_TILEGX_IMM16_X1_HW1_PCREL 53	/* X1 pipe PC relative hword 1 */
 
-+#define R_TILEGX_IMM16_X0_HW2_PCREL 54	/* X0 pipe PC relative hword 2 */
 
-+#define R_TILEGX_IMM16_X1_HW2_PCREL 55	/* X1 pipe PC relative hword 2 */
 
-+#define R_TILEGX_IMM16_X0_HW3_PCREL 56	/* X0 pipe PC relative hword 3 */
 
-+#define R_TILEGX_IMM16_X1_HW3_PCREL 57	/* X1 pipe PC relative hword 3 */
 
-+#define R_TILEGX_IMM16_X0_HW0_LAST_PCREL 58 /* X0 pipe PC-rel last hword 0 */
 
-+#define R_TILEGX_IMM16_X1_HW0_LAST_PCREL 59 /* X1 pipe PC-rel last hword 0 */
 
-+#define R_TILEGX_IMM16_X0_HW1_LAST_PCREL 60 /* X0 pipe PC-rel last hword 1 */
 
-+#define R_TILEGX_IMM16_X1_HW1_LAST_PCREL 61 /* X1 pipe PC-rel last hword 1 */
 
-+#define R_TILEGX_IMM16_X0_HW2_LAST_PCREL 62 /* X0 pipe PC-rel last hword 2 */
 
-+#define R_TILEGX_IMM16_X1_HW2_LAST_PCREL 63 /* X1 pipe PC-rel last hword 2 */
 
-+#define R_TILEGX_IMM16_X0_HW0_GOT 64	/* X0 pipe hword 0 GOT offset */
 
-+#define R_TILEGX_IMM16_X1_HW0_GOT 65	/* X1 pipe hword 0 GOT offset */
 
-+/* Relocs 66-71 are currently not defined.  */
 
-+#define R_TILEGX_IMM16_X0_HW0_LAST_GOT 72 /* X0 pipe last hword 0 GOT offset */
 
-+#define R_TILEGX_IMM16_X1_HW0_LAST_GOT 73 /* X1 pipe last hword 0 GOT offset */
 
-+#define R_TILEGX_IMM16_X0_HW1_LAST_GOT 74 /* X0 pipe last hword 1 GOT offset */
 
-+#define R_TILEGX_IMM16_X1_HW1_LAST_GOT 75 /* X1 pipe last hword 1 GOT offset */
 
-+/* Relocs 76-77 are currently not defined.  */
 
-+#define R_TILEGX_IMM16_X0_HW0_TLS_GD 78	/* X0 pipe hword 0 TLS GD offset */
 
-+#define R_TILEGX_IMM16_X1_HW0_TLS_GD 79	/* X1 pipe hword 0 TLS GD offset */
 
-+#define R_TILEGX_IMM16_X0_HW0_TLS_LE 80	/* X0 pipe hword 0 TLS LE offset */
 
-+#define R_TILEGX_IMM16_X1_HW0_TLS_LE 81	/* X1 pipe hword 0 TLS LE offset */
 
-+#define R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE 82 /* X0 pipe last hword 0 LE off */
 
-+#define R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE 83 /* X1 pipe last hword 0 LE off */
 
-+#define R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE 84 /* X0 pipe last hword 1 LE off */
 
-+#define R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE 85 /* X1 pipe last hword 1 LE off */
 
-+#define R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD 86 /* X0 pipe last hword 0 GD off */
 
-+#define R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD 87 /* X1 pipe last hword 0 GD off */
 
-+#define R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD 88 /* X0 pipe last hword 1 GD off */
 
-+#define R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD 89 /* X1 pipe last hword 1 GD off */
 
-+/* Relocs 90-91 are currently not defined.  */
 
-+#define R_TILEGX_IMM16_X0_HW0_TLS_IE 92	/* X0 pipe hword 0 TLS IE offset */
 
-+#define R_TILEGX_IMM16_X1_HW0_TLS_IE 93	/* X1 pipe hword 0 TLS IE offset */
 
-+/* Relocs 94-99 are currently not defined.  */
 
-+#define R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE 100 /* X0 pipe last hword 0 IE off */
 
-+#define R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE 101 /* X1 pipe last hword 0 IE off */
 
-+#define R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE 102 /* X0 pipe last hword 1 IE off */
 
-+#define R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE 103 /* X1 pipe last hword 1 IE off */
 
-+/* Relocs 104-105 are currently not defined.  */
 
-+#define R_TILEGX_TLS_DTPMOD64	106	/* 64-bit ID of symbol's module */
 
-+#define R_TILEGX_TLS_DTPOFF64	107	/* 64-bit offset in TLS block */
 
-+#define R_TILEGX_TLS_TPOFF64	108	/* 64-bit offset in static TLS block */
 
-+#define R_TILEGX_TLS_DTPMOD32	109	/* 32-bit ID of symbol's module */
 
-+#define R_TILEGX_TLS_DTPOFF32	110	/* 32-bit offset in TLS block */
 
-+#define R_TILEGX_TLS_TPOFF32	111	/* 32-bit offset in static TLS block */
 
-+#define R_TILEGX_TLS_GD_CALL	112	/* "jal" for TLS GD */
 
-+#define R_TILEGX_IMM8_X0_TLS_GD_ADD 113	/* X0 pipe "addi" for TLS GD */
 
-+#define R_TILEGX_IMM8_X1_TLS_GD_ADD 114	/* X1 pipe "addi" for TLS GD */
 
-+#define R_TILEGX_IMM8_Y0_TLS_GD_ADD 115	/* Y0 pipe "addi" for TLS GD */
 
-+#define R_TILEGX_IMM8_Y1_TLS_GD_ADD 116	/* Y1 pipe "addi" for TLS GD */
 
-+#define R_TILEGX_TLS_IE_LOAD	117	/* "ld_tls" for TLS IE */
 
-+#define R_TILEGX_IMM8_X0_TLS_ADD 118	/* X0 pipe "addi" for TLS GD/IE */
 
-+#define R_TILEGX_IMM8_X1_TLS_ADD 119	/* X1 pipe "addi" for TLS GD/IE */
 
-+#define R_TILEGX_IMM8_Y0_TLS_ADD 120	/* Y0 pipe "addi" for TLS GD/IE */
 
-+#define R_TILEGX_IMM8_Y1_TLS_ADD 121	/* Y1 pipe "addi" for TLS GD/IE */
 
-+
 
-+#define R_TILEGX_GNU_VTINHERIT	128	/* GNU C++ vtable hierarchy */
 
-+#define R_TILEGX_GNU_VTENTRY	129	/* GNU C++ vtable member usage */
 
-+
 
-+#define R_TILEGX_NUM		130
 
-+
 
-+#endif	/* elf.h */

+ 0 - 17
target/linux/generic/patches-3.3/211-stddef_include.patch
View File 

@@ -1,17 +0,0 @@
 
---- a/include/linux/stddef.h
 
-+++ b/include/linux/stddef.h
 
-@@ -16,6 +16,7 @@ enum {
 
- 	false	= 0,
 
- 	true	= 1
 
- };
 
-+#endif /* __KERNEL__ */
 
- 
- #undef offsetof
 
- #ifdef __compiler_offsetof
 
-@@ -23,6 +24,5 @@ enum {
 
- #else
 
- #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
 
- #endif
 
--#endif /* __KERNEL__ */
 
- 
- #endif

+ 0 - 22
target/linux/generic/patches-3.3/212-x86_reloc_portability.patch
View File 

@@ -1,22 +0,0 @@
 
---- a/arch/x86/tools/relocs.c
 
-+++ b/arch/x86/tools/relocs.c
 
-@@ -10,7 +10,18 @@
 
- #define USE_BSD
 
- #include <endian.h>
 
- #include <regex.h>
 
--#include <tools/le_byteshift.h>
 
-+
 
-+static inline void __put_unaligned_le16(uint16_t val, uint8_t *p)
 
-+{
 
-+	*p++ = val;
 
-+	*p++ = val >> 8;
 
-+}
 
-+
 
-+static inline void put_unaligned_le32(uint32_t val, uint8_t *p)
 
-+{
 
-+	__put_unaligned_le16(val >> 16, p + 2);
 
-+	__put_unaligned_le16(val, p);
 
-+}
 
- 
- static void die(char *fmt, ...);
 
-

+ 0 - 91
target/linux/generic/patches-3.3/220-module_exports.patch
View File 

@@ -1,91 +0,0 @@
 
---- a/include/asm-generic/vmlinux.lds.h
 
-+++ b/include/asm-generic/vmlinux.lds.h
 
-@@ -52,6 +52,18 @@
 
- #define LOAD_OFFSET 0
 
- #endif
 
- 
-+#ifndef SYMTAB_KEEP_STR
 
-+#define SYMTAB_KEEP *(SORT(___ksymtab+*))
 
-+#define SYMTAB_KEEP_GPL *(SORT(___ksymtab_gpl+*))
 
-+#define SYMTAB_KEEP_STR *(__ksymtab_strings+*)
 
-+#endif
 
-+
 
-+#ifndef SYMTAB_DISCARD
 
-+#define SYMTAB_DISCARD
 
-+#define SYMTAB_DISCARD_GPL
 
-+#define SYMTAB_DISCARD_STR
 
-+#endif
 
-+
 
- #ifndef SYMBOL_PREFIX
 
- #define VMLINUX_SYMBOL(sym) sym
 
- #else
 
-@@ -275,14 +287,14 @@
 
- 	/* Kernel symbol table: Normal symbols */			\
 
- 	__ksymtab         : AT(ADDR(__ksymtab) - LOAD_OFFSET) {		\
 
- 		VMLINUX_SYMBOL(__start___ksymtab) = .;			\
 
--		*(SORT(___ksymtab+*))					\
 
-+		SYMTAB_KEEP						\
 
- 		VMLINUX_SYMBOL(__stop___ksymtab) = .;			\
 
- 	}								\
 
- 									\
 
- 	/* Kernel symbol table: GPL-only symbols */			\
 
- 	__ksymtab_gpl     : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) {	\
 
- 		VMLINUX_SYMBOL(__start___ksymtab_gpl) = .;		\
 
--		*(SORT(___ksymtab_gpl+*))				\
 
-+		SYMTAB_KEEP_GPL						\
 
- 		VMLINUX_SYMBOL(__stop___ksymtab_gpl) = .;		\
 
- 	}								\
 
- 									\
 
-@@ -344,7 +356,7 @@
 
- 									\
 
- 	/* Kernel symbol table: strings */				\
 
-         __ksymtab_strings : AT(ADDR(__ksymtab_strings) - LOAD_OFFSET) {	\
 
--		*(__ksymtab_strings)					\
 
-+		SYMTAB_KEEP_STR						\
 
- 	}								\
 
- 									\
 
- 	/* __*init sections */						\
 
-@@ -676,6 +688,9 @@
 
- 	EXIT_TEXT							\
 
- 	EXIT_DATA							\
 
- 	EXIT_CALL							\
 
-+	SYMTAB_DISCARD							\
 
-+	SYMTAB_DISCARD_GPL						\
 
-+	SYMTAB_DISCARD_STR						\
 
- 	*(.discard)							\
 
- 	*(.discard.*)							\
 
- 	}
 
---- a/include/linux/export.h
 
-+++ b/include/linux/export.h
 
-@@ -45,12 +45,19 @@ extern struct module __this_module;
 
- #define __CRC_SYMBOL(sym, sec)
 
- #endif
 
- 
-+#ifdef MODULE
 
-+#define __EXPORT_SUFFIX(sym)
 
-+#else
 
-+#define __EXPORT_SUFFIX(sym) "+" #sym
 
-+#endif
 
-+
 
- /* For every exported symbol, place a struct in the __ksymtab section */
 
- #define __EXPORT_SYMBOL(sym, sec)				\
 
- 	extern typeof(sym) sym;					\
 
- 	__CRC_SYMBOL(sym, sec)					\
 
- 	static const char __kstrtab_##sym[]			\
 
--	__attribute__((section("__ksymtab_strings"), aligned(1))) \
 
-+	__attribute__((section("__ksymtab_strings"		\
 
-+	  __EXPORT_SUFFIX(sym)), aligned(1)))			\
 
- 	= MODULE_SYMBOL_PREFIX #sym;				\
 
- 	static const struct kernel_symbol __ksymtab_##sym	\
 
- 	__used							\
 
---- a/scripts/Makefile.build
 
-+++ b/scripts/Makefile.build
 
-@@ -346,7 +346,7 @@ targets += $(extra-y) $(MAKECMDGOALS) $(
 
- # Linker scripts preprocessor (.lds.S -> .lds)
 
- # ---------------------------------------------------------------------------
 
- quiet_cmd_cpp_lds_S = LDS     $@
 
--      cmd_cpp_lds_S = $(CPP) $(cpp_flags) -P -C -U$(ARCH) \
 
-+      cmd_cpp_lds_S = $(CPP) $(EXTRA_LDSFLAGS) $(cpp_flags) -P -C -U$(ARCH) \
 
- 	                     -D__ASSEMBLY__ -DLINKER_SCRIPT -o $@ $<
 
- 
- $(obj)/%.lds: $(src)/%.lds.S FORCE

+ 0 - 54
target/linux/generic/patches-3.3/230-openwrt_lzma_options.patch
View File 

@@ -1,54 +0,0 @@
 
---- a/scripts/Makefile.lib
 
-+++ b/scripts/Makefile.lib
 
-@@ -296,7 +296,7 @@ cmd_bzip2 = (cat $(filter-out FORCE,$^)
 
- 
- quiet_cmd_lzma = LZMA    $@
 
- cmd_lzma = (cat $(filter-out FORCE,$^) | \
 
--	lzma -9 && $(call size_append, $(filter-out FORCE,$^))) > $@ || \
 
-+	lzma e -d20 -lc1 -lp2 -pb2 -eos -si -so && $(call size_append, $(filter-out FORCE,$^))) > $@ || \
 
- 	(rm -f $@ ; false)
 
- 
- quiet_cmd_lzo = LZO     $@
 
---- a/scripts/gen_initramfs_list.sh
 
-+++ b/scripts/gen_initramfs_list.sh
 
-@@ -226,7 +226,7 @@ cpio_list=
 
- output="/dev/stdout"
 
- output_file=""
 
- is_cpio_compressed=
 
--compr="gzip -n -9 -f"
 
-+compr="gzip -n -9 -f -"
 
- 
- arg="$1"
 
- case "$arg" in
 
-@@ -240,9 +240,9 @@ case "$arg" in
 
- 		output_file="$1"
 
- 		cpio_list="$(mktemp ${TMPDIR:-/tmp}/cpiolist.XXXXXX)"
 
- 		output=${cpio_list}
 
--		echo "$output_file" | grep -q "\.gz$" && compr="gzip -n -9 -f"
 
--		echo "$output_file" | grep -q "\.bz2$" && compr="bzip2 -9 -f"
 
--		echo "$output_file" | grep -q "\.lzma$" && compr="lzma -9 -f"
 
-+		echo "$output_file" | grep -q "\.gz$" && compr="gzip -n -9 -f -"
 
-+		echo "$output_file" | grep -q "\.bz2$" && compr="bzip2 -9 -f -"
 
-+		echo "$output_file" | grep -q "\.lzma$" && compr="lzma e -d20 -lc1 -lp2 -pb2 -eos -si -so"
 
- 		echo "$output_file" | grep -q "\.xz$" && \
 
- 				compr="xz --check=crc32 --lzma2=dict=1MiB"
 
- 		echo "$output_file" | grep -q "\.lzo$" && compr="lzop -9 -f"
 
-@@ -303,7 +303,7 @@ if [ ! -z ${output_file} ]; then
 
- 	if [ "${is_cpio_compressed}" = "compressed" ]; then
 
- 		cat ${cpio_tfile} > ${output_file}
 
- 	else
 
--		(cat ${cpio_tfile} | ${compr}  - > ${output_file}) \
 
-+		(cat ${cpio_tfile} | ${compr} > ${output_file}) \
 
- 		|| (rm -f ${output_file} ; false)
 
- 	fi
 
- 	[ -z ${cpio_file} ] && rm ${cpio_tfile}
 
---- a/lib/decompress.c
 
-+++ b/lib/decompress.c
 
-@@ -40,6 +40,7 @@ static const struct compress_format {
 
- 	{ {037, 0236}, "gzip", gunzip },
 
- 	{ {0x42, 0x5a}, "bzip2", bunzip2 },
 
- 	{ {0x5d, 0x00}, "lzma", unlzma },
 
-+	{ {0x6d, 0x00}, "lzma-openwrt", unlzma },
 
- 	{ {0xfd, 0x37}, "xz", unxz },
 
- 	{ {0x89, 0x4c}, "lzo", unlzo },
 
- 	{ {0, 0}, NULL, NULL }

+ 0 - 18
target/linux/generic/patches-3.3/250-netfilter_depends.patch
View File 

@@ -1,18 +0,0 @@
 
---- a/net/netfilter/Kconfig
 
-+++ b/net/netfilter/Kconfig
 
-@@ -181,7 +181,6 @@ config NF_CONNTRACK_FTP
 
- 
- config NF_CONNTRACK_H323
 
- 	tristate "H.323 protocol support"
 
--	depends on (IPV6 || IPV6=n)
 
- 	depends on NETFILTER_ADVANCED
 
- 	help
 
- 	  H.323 is a VoIP signalling protocol from ITU-T. As one of the most
 
-@@ -627,7 +626,6 @@ config NETFILTER_XT_TARGET_SECMARK
 
- 
- config NETFILTER_XT_TARGET_TCPMSS
 
- 	tristate '"TCPMSS" target support'
 
--	depends on (IPV6 || IPV6=n)
 
- 	default m if NETFILTER_ADVANCED=n
 
- 	---help---
 
- 	  This option adds a `TCPMSS' target, which allows you to alter the

+ 0 - 18
target/linux/generic/patches-3.3/251-sound_kconfig.patch
View File 

@@ -1,18 +0,0 @@
 
---- a/sound/core/Kconfig
 
-+++ b/sound/core/Kconfig
 
-@@ -7,13 +7,13 @@ config SND_PCM
 
- 	select SND_TIMER
 
- 
- config SND_HWDEP
 
--	tristate
 
-+	tristate "Sound hardware support"
 
- 
- config SND_RAWMIDI
 
- 	tristate
 
- 
- config SND_COMPRESS_OFFLOAD
 
--	tristate
 
-+	tristate "Compression offloading support"
 
- 
- # To be effective this also requires INPUT - users should say:
 
- #    select SND_JACK if INPUT=y || INPUT=SND

+ 0 - 10
target/linux/generic/patches-3.3/252-mv_cesa_depends.patch
View File 

@@ -1,10 +0,0 @@
 
---- a/drivers/crypto/Kconfig
 
-+++ b/drivers/crypto/Kconfig
 
-@@ -172,6 +172,7 @@ config CRYPTO_DEV_MV_CESA
 
- 	depends on PLAT_ORION
 
- 	select CRYPTO_ALGAPI
 
- 	select CRYPTO_AES
 
-+	select CRYPTO_HASH2
 
- 	select CRYPTO_BLKCIPHER2
 
- 	select CRYPTO_HASH
 
- 	help

+ 0 - 29
target/linux/generic/patches-3.3/253-ssb_b43_default_on.patch
View File 

@@ -1,29 +0,0 @@
 
---- a/drivers/ssb/Kconfig
 
-+++ b/drivers/ssb/Kconfig
 
-@@ -29,6 +29,7 @@ config SSB_SPROM
 
- config SSB_BLOCKIO
 
- 	bool
 
- 	depends on SSB
 
-+	default y
 
- 
- config SSB_PCIHOST_POSSIBLE
 
- 	bool
 
-@@ -49,7 +50,7 @@ config SSB_PCIHOST
 
- config SSB_B43_PCI_BRIDGE
 
- 	bool
 
- 	depends on SSB_PCIHOST
 
--	default n
 
-+	default y
 
- 
- config SSB_PCMCIAHOST_POSSIBLE
 
- 	bool
 
---- a/drivers/bcma/Kconfig
 
-+++ b/drivers/bcma/Kconfig
 
-@@ -17,6 +17,7 @@ config BCMA
 
- config BCMA_BLOCKIO
 
- 	bool
 
- 	depends on BCMA
 
-+	default y
 
- 
- config BCMA_HOST_PCI_POSSIBLE
 
- 	bool

+ 0 - 23
target/linux/generic/patches-3.3/254-textsearch_kconfig_hacks.patch
View File 

@@ -1,23 +0,0 @@
 
---- a/lib/Kconfig
 
-+++ b/lib/Kconfig
 
-@@ -207,16 +207,16 @@ config BCH_CONST_T
 
- # Textsearch support is select'ed if needed
 
- #
 
- config TEXTSEARCH
 
--	boolean
 
-+	boolean	"Textsearch support"
 
- 
- config TEXTSEARCH_KMP
 
--	tristate
 
-+	tristate "Textsearch KMP"
 
- 
- config TEXTSEARCH_BM
 
--	tristate
 
-+	tristate "Textsearch BM"
 
- 
- config TEXTSEARCH_FSM
 
--	tristate
 
-+	tristate "Textsearch FSM"
 
- 
- config BTREE
 
- 	boolean

+ 0 - 19
target/linux/generic/patches-3.3/255-lib80211_kconfig_hacks.patch
View File 

@@ -1,19 +0,0 @@
 
---- a/net/wireless/Kconfig
 
-+++ b/net/wireless/Kconfig
 
-@@ -143,13 +143,13 @@ config LIB80211
 
- 	  you want this built into your kernel.
 
- 
- config LIB80211_CRYPT_WEP
 
--	tristate
 
-+	tristate "LIB80211_CRYPT_WEP"
 
- 
- config LIB80211_CRYPT_CCMP
 
--	tristate
 
-+	tristate "LIB80211_CRYPT_CCMP"
 
- 
- config LIB80211_CRYPT_TKIP
 
--	tristate
 
-+	tristate "LIB80211_CRYPT_TKIP"
 
- 
- config LIB80211_DEBUG
 
- 	bool "lib80211 debugging messages"

+ 0 - 47
target/linux/generic/patches-3.3/256-crypto_add_kconfig_prompts.patch
View File 

@@ -1,47 +0,0 @@
 
---- a/crypto/Kconfig
 
-+++ b/crypto/Kconfig
 
-@@ -31,7 +31,7 @@ config CRYPTO_FIPS
 
- 	  this is.
 
- 
- config CRYPTO_ALGAPI
 
--	tristate
 
-+	tristate "ALGAPI"
 
- 	select CRYPTO_ALGAPI2
 
- 	help
 
- 	  This option provides the API for cryptographic algorithms.
 
-@@ -40,7 +40,7 @@ config CRYPTO_ALGAPI2
 
- 	tristate
 
- 
- config CRYPTO_AEAD
 
--	tristate
 
-+	tristate "AEAD"
 
- 	select CRYPTO_AEAD2
 
- 	select CRYPTO_ALGAPI
 
- 
-@@ -49,7 +49,7 @@ config CRYPTO_AEAD2
 
- 	select CRYPTO_ALGAPI2
 
- 
- config CRYPTO_BLKCIPHER
 
--	tristate
 
-+	tristate "BLKCIPHER"
 
- 	select CRYPTO_BLKCIPHER2
 
- 	select CRYPTO_ALGAPI
 
- 
-@@ -60,7 +60,7 @@ config CRYPTO_BLKCIPHER2
 
- 	select CRYPTO_WORKQUEUE
 
- 
- config CRYPTO_HASH
 
--	tristate
 
-+	tristate "HASH"
 
- 	select CRYPTO_HASH2
 
- 	select CRYPTO_ALGAPI
 
- 
-@@ -69,7 +69,7 @@ config CRYPTO_HASH2
 
- 	select CRYPTO_ALGAPI2
 
- 
- config CRYPTO_RNG
 
--	tristate
 
-+	tristate "RNG"
 
- 	select CRYPTO_RNG2
 
- 	select CRYPTO_ALGAPI
 
-

+ 0 - 22
target/linux/generic/patches-3.3/257-wireless_ext_kconfig_hack.patch
View File 

@@ -1,22 +0,0 @@
 
---- a/net/wireless/Kconfig
 
-+++ b/net/wireless/Kconfig
 
-@@ -1,5 +1,5 @@
 
- config WIRELESS_EXT
 
--	bool
 
-+	bool "Wireless extensions"
 
- 
- config WEXT_CORE
 
- 	def_bool y
 
-@@ -11,10 +11,10 @@ config WEXT_PROC
 
- 	depends on WEXT_CORE
 
- 
- config WEXT_SPY
 
--	bool
 
-+	bool "WEXT_SPY"
 
- 
- config WEXT_PRIV
 
--	bool
 
-+	bool "WEXT_PRIV"
 
- 
- config CFG80211
 
- 	tristate "cfg80211 - wireless configuration API"

+ 0 - 11
target/linux/generic/patches-3.3/258-netfilter_netlink_kconfig_hack.patch
View File 

@@ -1,11 +0,0 @@
 
---- a/net/netfilter/Kconfig
 
-+++ b/net/netfilter/Kconfig
 
-@@ -2,7 +2,7 @@ menu "Core Netfilter Configuration"
 
- 	depends on NET && INET && NETFILTER
 
- 
- config NETFILTER_NETLINK
 
--	tristate
 
-+	tristate "Netfilter NFNETLINK interface"
 
- 
- config NETFILTER_NETLINK_ACCT
 
- tristate "Netfilter NFACCT over NFNETLINK interface"

+ 0 - 23
target/linux/generic/patches-3.3/259-compressor_kconfig_hack.patch
View File 

@@ -1,23 +0,0 @@
 
---- a/lib/Kconfig
 
-+++ b/lib/Kconfig
 
-@@ -105,16 +105,16 @@ config AUDIT_GENERIC
 
- # compression support is select'ed if needed
 
- #
 
- config ZLIB_INFLATE
 
--	tristate
 
-+	tristate "ZLIB inflate support"
 
- 
- config ZLIB_DEFLATE
 
--	tristate
 
-+	tristate "ZLIB deflate support"
 
- 
- config LZO_COMPRESS
 
--	tristate
 
-+	tristate "LZO compress support"
 
- 
- config LZO_DECOMPRESS
 
--	tristate
 
-+	tristate "LZO decompress support"
 
- 
- source "lib/xz/Kconfig"
 
-

+ 0 - 219
target/linux/generic/patches-3.3/260-move_bcm963xx_tag.patch
View File 

@@ -1,219 +0,0 @@
 
---- a/arch/mips/include/asm/mach-bcm63xx/bcm963xx_tag.h
 
-+++ /dev/null
 
-@@ -1,96 +0,0 @@
 
--#ifndef __BCM963XX_TAG_H
 
--#define __BCM963XX_TAG_H
 
--
 
--#define TAGVER_LEN		4	/* Length of Tag Version */
 
--#define TAGLAYOUT_LEN		4	/* Length of FlashLayoutVer */
 
--#define SIG1_LEN		20	/* Company Signature 1 Length */
 
--#define SIG2_LEN		14	/* Company Signature 2 Length */
 
--#define BOARDID_LEN		16	/* Length of BoardId */
 
--#define ENDIANFLAG_LEN		2	/* Endian Flag Length */
 
--#define CHIPID_LEN		6	/* Chip Id Length */
 
--#define IMAGE_LEN		10	/* Length of Length Field */
 
--#define ADDRESS_LEN		12	/* Length of Address field */
 
--#define DUALFLAG_LEN		2	/* Dual Image flag Length */
 
--#define INACTIVEFLAG_LEN	2	/* Inactie Flag Length */
 
--#define RSASIG_LEN		20	/* Length of RSA Signature in tag */
 
--#define TAGINFO1_LEN		30	/* Length of vendor information field1 in tag */
 
--#define FLASHLAYOUTVER_LEN	4	/* Length of Flash Layout Version String tag */
 
--#define TAGINFO2_LEN		16	/* Length of vendor information field2 in tag */
 
--#define ALTTAGINFO_LEN		54	/* Alternate length for vendor information; Pirelli */
 
--
 
--#define NUM_PIRELLI		2
 
--#define IMAGETAG_CRC_START	0xFFFFFFFF
 
--
 
--#define PIRELLI_BOARDS { \
 
--	"AGPF-S0", \
 
--	"DWV-S0", \
 
--}
 
--
 
--/*
 
-- * The broadcom firmware assumes the rootfs starts the image,
 
-- * therefore uses the rootfs start (flash_image_address)
 
-- * to determine where to flash the image.  Since we have the kernel first
 
-- * we have to give it the kernel address, but the crc uses the length
 
-- * associated with this address (root_length), which is added to the kernel
 
-- * length (kernel_length) to determine the length of image to flash and thus
 
-- * needs to be rootfs + deadcode (jffs2 EOF marker)
 
--*/
 
--
 
--struct bcm_tag {
 
--	/* 0-3: Version of the image tag */
 
--	char tag_version[TAGVER_LEN];
 
--	/* 4-23: Company Line 1 */
 
--	char sig_1[SIG1_LEN];
 
--	/*  24-37: Company Line 2 */
 
--	char sig_2[SIG2_LEN];
 
--	/* 38-43: Chip this image is for */
 
--	char chip_id[CHIPID_LEN];
 
--	/* 44-59: Board name */
 
--	char board_id[BOARDID_LEN];
 
--	/* 60-61: Map endianness -- 1 BE 0 LE */
 
--	char big_endian[ENDIANFLAG_LEN];
 
--	/* 62-71: Total length of image */
 
--	char total_length[IMAGE_LEN];
 
--	/* 72-83: Address in memory of CFE */
 
--	char cfe__address[ADDRESS_LEN];
 
--	/* 84-93: Size of CFE */
 
--	char cfe_length[IMAGE_LEN];
 
--	/* 94-105: Address in memory of image start
 
--	 * (kernel for OpenWRT, rootfs for stock firmware)
 
--	 */
 
--	char flash_image_start[ADDRESS_LEN];
 
--	/* 106-115: Size of rootfs */
 
--	char root_length[IMAGE_LEN];
 
--	/* 116-127: Address in memory of kernel */
 
--	char kernel_address[ADDRESS_LEN];
 
--	/* 128-137: Size of kernel */
 
--	char kernel_length[IMAGE_LEN];
 
--	/* 138-139: Unused at the moment */
 
--	char dual_image[DUALFLAG_LEN];
 
--	/* 140-141: Unused at the moment */
 
--	char inactive_flag[INACTIVEFLAG_LEN];
 
--	/* 142-161: RSA Signature (not used; some vendors may use this) */
 
--	char rsa_signature[RSASIG_LEN];
 
--	/* 162-191: Compilation and related information (not used in OpenWrt) */
 
--	char information1[TAGINFO1_LEN];
 
--	/* 192-195: Version flash layout */
 
--	char flash_layout_ver[FLASHLAYOUTVER_LEN];
 
--	/* 196-199: kernel+rootfs CRC32 */
 
--	__u32 fskernel_crc;
 
--	/* 200-215: Unused except on Alice Gate where is is information */
 
--	char information2[TAGINFO2_LEN];
 
--	/* 216-219: CRC32 of image less imagetag (kernel for Alice Gate) */
 
--	__u32 image_crc;
 
--	/* 220-223: CRC32 of rootfs partition */
 
--	__u32 rootfs_crc;
 
--	/* 224-227: CRC32 of kernel partition */
 
--	__u32 kernel_crc;
 
--	/* 228-235: Unused at present */
 
--	char reserved1[8];
 
--	/* 236-239: CRC32 of header excluding last 20 bytes */
 
--	__u32 header_crc;
 
--	/* 240-255: Unused at present */
 
--	char reserved2[16];
 
--};
 
--
 
--#endif /* __BCM63XX_TAG_H */
 
---- a/drivers/mtd/bcm63xxpart.c
 
-+++ b/drivers/mtd/bcm63xxpart.c
 
-@@ -32,7 +32,7 @@
 
- #include <linux/mtd/mtd.h>
 
- #include <linux/mtd/partitions.h>
 
- 
--#include <asm/mach-bcm63xx/bcm963xx_tag.h>
 
-+#include <linux/bcm963xx_tag.h>
 
- #include <asm/mach-bcm63xx/board_bcm963xx.h>
 
- 
- #define BCM63XX_EXTENDED_SIZE	0xBFC00000	/* Extended flash address */
 
---- a/include/linux/Kbuild
 
-+++ b/include/linux/Kbuild
 
-@@ -77,6 +77,7 @@ header-y += blk_types.h
 
- header-y += blkpg.h
 
- header-y += blktrace_api.h
 
- header-y += bpqether.h
 
-+header-y += bcm963xx_tag.h
 
- header-y += bsg.h
 
- header-y += can.h
 
- header-y += capability.h
 
---- /dev/null
 
-+++ b/include/linux/bcm963xx_tag.h
 
-@@ -0,0 +1,96 @@
 
-+#ifndef __BCM963XX_TAG_H
 
-+#define __BCM963XX_TAG_H
 
-+
 
-+#define TAGVER_LEN		4	/* Length of Tag Version */
 
-+#define TAGLAYOUT_LEN		4	/* Length of FlashLayoutVer */
 
-+#define SIG1_LEN		20	/* Company Signature 1 Length */
 
-+#define SIG2_LEN		14	/* Company Signature 2 Length */
 
-+#define BOARDID_LEN		16	/* Length of BoardId */
 
-+#define ENDIANFLAG_LEN		2	/* Endian Flag Length */
 
-+#define CHIPID_LEN		6	/* Chip Id Length */
 
-+#define IMAGE_LEN		10	/* Length of Length Field */
 
-+#define ADDRESS_LEN		12	/* Length of Address field */
 
-+#define DUALFLAG_LEN		2	/* Dual Image flag Length */
 
-+#define INACTIVEFLAG_LEN	2	/* Inactie Flag Length */
 
-+#define RSASIG_LEN		20	/* Length of RSA Signature in tag */
 
-+#define TAGINFO1_LEN		30	/* Length of vendor information field1 in tag */
 
-+#define FLASHLAYOUTVER_LEN	4	/* Length of Flash Layout Version String tag */
 
-+#define TAGINFO2_LEN		16	/* Length of vendor information field2 in tag */
 
-+#define ALTTAGINFO_LEN		54	/* Alternate length for vendor information; Pirelli */
 
-+
 
-+#define NUM_PIRELLI		2
 
-+#define IMAGETAG_CRC_START	0xFFFFFFFF
 
-+
 
-+#define PIRELLI_BOARDS { \
 
-+	"AGPF-S0", \
 
-+	"DWV-S0", \
 
-+}
 
-+
 
-+/*
 
-+ * The broadcom firmware assumes the rootfs starts the image,
 
-+ * therefore uses the rootfs start (flash_image_address)
 
-+ * to determine where to flash the image.  Since we have the kernel first
 
-+ * we have to give it the kernel address, but the crc uses the length
 
-+ * associated with this address (root_length), which is added to the kernel
 
-+ * length (kernel_length) to determine the length of image to flash and thus
 
-+ * needs to be rootfs + deadcode (jffs2 EOF marker)
 
-+*/
 
-+
 
-+struct bcm_tag {
 
-+	/* 0-3: Version of the image tag */
 
-+	char tag_version[TAGVER_LEN];
 
-+	/* 4-23: Company Line 1 */
 
-+	char sig_1[SIG1_LEN];
 
-+	/*  24-37: Company Line 2 */
 
-+	char sig_2[SIG2_LEN];
 
-+	/* 38-43: Chip this image is for */
 
-+	char chip_id[CHIPID_LEN];
 
-+	/* 44-59: Board name */
 
-+	char board_id[BOARDID_LEN];
 
-+	/* 60-61: Map endianness -- 1 BE 0 LE */
 
-+	char big_endian[ENDIANFLAG_LEN];
 
-+	/* 62-71: Total length of image */
 
-+	char total_length[IMAGE_LEN];
 
-+	/* 72-83: Address in memory of CFE */
 
-+	char cfe__address[ADDRESS_LEN];
 
-+	/* 84-93: Size of CFE */
 
-+	char cfe_length[IMAGE_LEN];
 
-+	/* 94-105: Address in memory of image start
 
-+	 * (kernel for OpenWRT, rootfs for stock firmware)
 
-+	 */
 
-+	char flash_image_start[ADDRESS_LEN];
 
-+	/* 106-115: Size of rootfs */
 
-+	char root_length[IMAGE_LEN];
 
-+	/* 116-127: Address in memory of kernel */
 
-+	char kernel_address[ADDRESS_LEN];
 
-+	/* 128-137: Size of kernel */
 
-+	char kernel_length[IMAGE_LEN];
 
-+	/* 138-139: Unused at the moment */
 
-+	char dual_image[DUALFLAG_LEN];
 
-+	/* 140-141: Unused at the moment */
 
-+	char inactive_flag[INACTIVEFLAG_LEN];
 
-+	/* 142-161: RSA Signature (not used; some vendors may use this) */
 
-+	char rsa_signature[RSASIG_LEN];
 
-+	/* 162-191: Compilation and related information (not used in OpenWrt) */
 
-+	char information1[TAGINFO1_LEN];
 
-+	/* 192-195: Version flash layout */
 
-+	char flash_layout_ver[FLASHLAYOUTVER_LEN];
 
-+	/* 196-199: kernel+rootfs CRC32 */
 
-+	__u32 fskernel_crc;
 
-+	/* 200-215: Unused except on Alice Gate where is is information */
 
-+	char information2[TAGINFO2_LEN];
 
-+	/* 216-219: CRC32 of image less imagetag (kernel for Alice Gate) */
 
-+	__u32 image_crc;
 
-+	/* 220-223: CRC32 of rootfs partition */
 
-+	__u32 rootfs_crc;
 
-+	/* 224-227: CRC32 of kernel partition */
 
-+	__u32 kernel_crc;
 
-+	/* 228-235: Unused at present */
 
-+	char reserved1[8];
 
-+	/* 236-239: CRC32 of header excluding last 20 bytes */
 
-+	__u32 header_crc;
 
-+	/* 240-255: Unused at present */
 
-+	char reserved2[16];
 
-+};
 
-+
 
-+#endif /* __BCM63XX_TAG_H */

+ 0 - 55
target/linux/generic/patches-3.3/270-regmap_dynamic.patch
View File 

@@ -1,55 +0,0 @@
 
---- a/drivers/base/regmap/Kconfig
 
-+++ b/drivers/base/regmap/Kconfig
 
-@@ -3,16 +3,18 @@
 
- # subsystems should select the appropriate symbols.
 
- 
- config REGMAP
 
--	default y if (REGMAP_I2C || REGMAP_SPI)
 
- 	select LZO_COMPRESS
 
- 	select LZO_DECOMPRESS
 
--	bool
 
-+	tristate "Regmap"
 
- 
- config REGMAP_I2C
 
--	tristate
 
-+	select REGMAP
 
-+	tristate "Regmap I2C"
 
- 
- config REGMAP_SPI
 
--	tristate
 
-+	select REGMAP
 
-+	depends on SPI_MASTER
 
-+	tristate "Regmap SPI"
 
- 
- config REGMAP_IRQ
 
- 	bool
 
---- a/drivers/base/regmap/Makefile
 
-+++ b/drivers/base/regmap/Makefile
 
-@@ -1,6 +1,8 @@
 
--obj-$(CONFIG_REGMAP) += regmap.o regcache.o
 
--obj-$(CONFIG_REGMAP) += regcache-rbtree.o regcache-lzo.o
 
--obj-$(CONFIG_DEBUG_FS) += regmap-debugfs.o
 
-+regmap-core-objs = regmap.o regcache.o regcache-rbtree.o regcache-lzo.o
 
-+ifdef CONFIG_DEBUG_FS
 
-+regmap-core-objs += regmap-debugfs.o
 
-+endif
 
-+obj-$(CONFIG_REGMAP) += regmap-core.o
 
- obj-$(CONFIG_REGMAP_I2C) += regmap-i2c.o
 
- obj-$(CONFIG_REGMAP_SPI) += regmap-spi.o
 
- obj-$(CONFIG_REGMAP_IRQ) += regmap-irq.o
 
---- a/drivers/base/regmap/regmap.c
 
-+++ b/drivers/base/regmap/regmap.c
 
-@@ -13,6 +13,7 @@
 
- #include <linux/slab.h>
 
- #include <linux/module.h>
 
- #include <linux/mutex.h>
 
-+#include <linux/module.h>
 
- #include <linux/err.h>
 
- 
- #define CREATE_TRACE_POINTS
 
-@@ -679,3 +680,5 @@ static int __init regmap_initcall(void)
 
- 	return 0;
 
- }
 
- postcore_initcall(regmap_initcall);
 
-+
 
-+MODULE_LICENSE("GPL");

+ 0 - 39
target/linux/generic/patches-3.3/300-mips_expose_boot_raw.patch
View File 

@@ -1,39 +0,0 @@
 
-From: Mark Miller <[email protected]>
 
-
 
-This exposes the CONFIG_BOOT_RAW symbol in Kconfig. This is needed on
 
-certain Broadcom chipsets running CFE in order to load the kernel.
 
-
 
-Signed-off-by: Mark Miller <[email protected]>
 
-Acked-by: Rob Landley <[email protected]>
 
----
 
---- a/arch/mips/Kconfig
 
-+++ b/arch/mips/Kconfig
 
-@@ -877,9 +877,6 @@ config ARC
 
- config ARCH_MAY_HAVE_PC_FDC
 
- 	bool
 
- 
--config BOOT_RAW
 
--	bool
 
--
 
- config CEVT_BCM1480
 
- 	bool
 
- 
-@@ -2330,6 +2327,18 @@ config USE_OF
 
- 	help
 
- 	  Include support for flattened device tree machine descriptions.
 
- 
-+config BOOT_RAW
 
-+	bool "Enable the kernel to be executed from the load address"
 
-+	default n
 
-+	help
 
-+	 Allow the kernel to be executed from the load address for
 
-+	 bootloaders which cannot read the ELF format. This places
 
-+	 a jump to start_kernel at the load address.
 
-+
 
-+	 If unsure, say N.
 
-+
 
-+
 
-+
 
- endmenu
 
- 
- config LOCKDEP_SUPPORT

+ 0 - 28
target/linux/generic/patches-3.3/301-mips_image_cmdline_hack.patch
View File 

@@ -1,28 +0,0 @@
 
---- a/arch/mips/Kconfig
 
-+++ b/arch/mips/Kconfig
 
-@@ -976,6 +976,10 @@ config SYNC_R4K
 
- config MIPS_MACHINE
 
- 	def_bool n
 
- 
-+config IMAGE_CMDLINE_HACK
 
-+	bool "OpenWrt specific image command line hack"
 
-+	default n
 
-+
 
- config NO_IOPORT
 
- 	def_bool n
 
- 
---- a/arch/mips/kernel/head.S
 
-+++ b/arch/mips/kernel/head.S
 
-@@ -141,6 +141,12 @@ FEXPORT(__kernel_entry)
 
- 	j	kernel_entry
 
- #endif
 
- 
-+#ifdef CONFIG_IMAGE_CMDLINE_HACK
 
-+	.ascii	"CMDLINE:"
 
-+EXPORT(__image_cmdline)
 
-+	.fill	0x400
 
-+#endif /* CONFIG_IMAGE_CMDLINE_HACK */
 
-+
 
- 	__REF
 
- 
- NESTED(kernel_entry, 16, sp)			# kernel entry point

+ 0 - 18
target/linux/generic/patches-3.3/302-mips_use_generic_thread_info_allocator.patch
View File 

@@ -1,18 +0,0 @@
 
---- a/arch/mips/include/asm/thread_info.h
 
-+++ b/arch/mips/include/asm/thread_info.h
 
-@@ -85,6 +85,7 @@ register struct thread_info *__current_t
 
- 
- #define STACK_WARN	(THREAD_SIZE / 8)
 
- 
-+#if 0
 
- #define __HAVE_ARCH_THREAD_INFO_ALLOCATOR
 
- 
- #ifdef CONFIG_DEBUG_STACK_USAGE
 
-@@ -96,6 +97,7 @@ register struct thread_info *__current_t
 
- #endif
 
- 
- #define free_thread_info(info) kfree(info)
 
-+#endif
 
- 
- #endif /* !__ASSEMBLY__ */
 
-

+ 0 - 11
target/linux/generic/patches-3.3/303-mips_fix_kexec.patch
View File 

@@ -1,11 +0,0 @@
 
---- a/arch/mips/kernel/machine_kexec.c
 
-+++ b/arch/mips/kernel/machine_kexec.c
 
-@@ -52,7 +52,7 @@ machine_kexec(struct kimage *image)
 
- 	reboot_code_buffer =
 
- 	  (unsigned long)page_address(image->control_code_page);
 
- 
--	kexec_start_address = image->start;
 
-+	kexec_start_address = (unsigned long) phys_to_virt(image->start);
 
- 	kexec_indirection_page =
 
- 		(unsigned long) phys_to_virt(image->head & PAGE_MASK);
 
-

+ 0 - 160
target/linux/generic/patches-3.3/304-mips_disable_fpu.patch
View File 

@@ -1,160 +0,0 @@
 
-MIPS: allow disabling the kernel FPU emulator
 
-
 
-This patch allows turning off the in-kernel Algorithmics
 
-FPU emulator support, which allows one to save a couple of
 
-precious blocks on an embedded system.
 
-
 
-Signed-off-by: Florian Fainelli <[email protected]>
 
---
 
---- a/arch/mips/Kconfig
 
-+++ b/arch/mips/Kconfig
 
-@@ -961,6 +961,17 @@ config I8259
 
- config MIPS_BONITO64
 
- 	bool
 
- 
-+config MIPS_FPU_EMU
 
-+	bool "Enable FPU emulation"
 
-+	default y
 
-+	help
 
-+	   This option allows building a kernel with or without the Algorithmics
 
-+	   FPU emulator enabled. Turning off this option results in a kernel which
 
-+	   does not catch floating operations exceptions. Make sure that your toolchain
 
-+	   is configured to enable software floating point emulation in that case.
 
-+		
-+	   If unsure say Y here.
 
-+
 
- config MIPS_MSC
 
- 	bool
 
- 
---- a/arch/mips/math-emu/Makefile
 
-+++ b/arch/mips/math-emu/Makefile
 
-@@ -2,11 +2,13 @@
 
- # Makefile for the Linux/MIPS kernel FPU emulation.
 
- #
 
- 
--obj-y	:= cp1emu.o ieee754m.o ieee754d.o ieee754dp.o ieee754sp.o ieee754.o \
 
-+obj-y	:=	kernel_linkage.o dsemul.o cp1emu.o
 
-+
 
-+obj-$(CONFIG_MIPS_FPU_EMU)	+= ieee754m.o ieee754d.o ieee754dp.o ieee754sp.o ieee754.o \
 
- 	   ieee754xcpt.o dp_frexp.o dp_modf.o dp_div.o dp_mul.o dp_sub.o \
 
- 	   dp_add.o dp_fsp.o dp_cmp.o dp_logb.o dp_scalb.o dp_simple.o \
 
- 	   dp_tint.o dp_fint.o dp_tlong.o dp_flong.o sp_frexp.o sp_modf.o \
 
- 	   sp_div.o sp_mul.o sp_sub.o sp_add.o sp_fdp.o sp_cmp.o sp_logb.o \
 
- 	   sp_scalb.o sp_simple.o sp_tint.o sp_fint.o sp_tlong.o sp_flong.o \
 
--	   dp_sqrt.o sp_sqrt.o kernel_linkage.o dsemul.o
 
-+	   dp_sqrt.o sp_sqrt.o
 
- 
---- a/arch/mips/math-emu/cp1emu.c
 
-+++ b/arch/mips/math-emu/cp1emu.c
 
-@@ -58,7 +58,11 @@
 
- #define __mips 4
 
- 
- /* Function which emulates a floating point instruction. */
 
-+#ifdef CONFIG_DEBUG_FS
 
-+DEFINE_PER_CPU(struct mips_fpu_emulator_stats, fpuemustats);
 
-+#endif
 
- 
-+#ifdef CONFIG_MIPS_FPU_EMU
 
- static int fpu_emu(struct pt_regs *, struct mips_fpu_struct *,
 
- 	mips_instruction);
 
- 
-@@ -69,10 +73,6 @@ static int fpux_emu(struct pt_regs *,
 
- 
- /* Further private data for which no space exists in mips_fpu_struct */
 
- 
--#ifdef CONFIG_DEBUG_FS
 
--DEFINE_PER_CPU(struct mips_fpu_emulator_stats, fpuemustats);
 
--#endif
 
--
 
- /* Control registers */
 
- 
- #define FPCREG_RID	0	/* $0  = revision id */
 
-@@ -1360,7 +1360,6 @@ int fpu_emulator_cop1Handler(struct pt_r
 
- 
- 	return sig;
 
- }
 
--
 
- #ifdef CONFIG_DEBUG_FS
 
- 
- static int fpuemu_stat_get(void *data, u64 *val)
 
-@@ -1409,4 +1408,11 @@ static int __init debugfs_fpuemu(void)
 
- 	return 0;
 
- }
 
- __initcall(debugfs_fpuemu);
 
--#endif
 
-+#endif /* CONFIG_DEBUGFS */
 
-+#else
 
-+int fpu_emulator_cop1Handler(struct pt_regs *xcp, struct mips_fpu_struct *ctx,
 
-+        int has_fpu)
 
-+{
 
-+	return 0;
 
-+}
 
-+#endif /* CONFIG_MIPS_FPU_EMU */
 
---- a/arch/mips/math-emu/dsemul.c
 
-+++ b/arch/mips/math-emu/dsemul.c
 
-@@ -109,6 +109,7 @@ int mips_dsemul(struct pt_regs *regs, mi
 
- 	return SIGILL;		/* force out of emulation loop */
 
- }
 
- 
-+#ifdef CONFIG_MIPS_FPU_EMU
 
- int do_dsemulret(struct pt_regs *xcp)
 
- {
 
- 	struct emuframe __user *fr;
 
-@@ -165,3 +166,9 @@ int do_dsemulret(struct pt_regs *xcp)
 
- 
- 	return 1;
 
- }
 
-+#else
 
-+int do_dsemulret(struct pt_regs *xcp)
 
-+{
 
-+	return 0;
 
-+}
 
-+#endif /* CONFIG_MIPS_FPU_EMU */
 
---- a/arch/mips/math-emu/kernel_linkage.c
 
-+++ b/arch/mips/math-emu/kernel_linkage.c
 
-@@ -29,6 +29,7 @@
 
- 
- #define SIGNALLING_NAN 0x7ff800007ff80000LL
 
- 
-+#ifdef CONFIG_MIPS_FPU_EMU
 
- void fpu_emulator_init_fpu(void)
 
- {
 
- 	static int first = 1;
 
-@@ -112,4 +113,36 @@ int fpu_emulator_restore_context32(struc
 
- 
- 	return err;
 
- }
 
--#endif
 
-+#endif	/* CONFIG_64BIT */
 
-+#else
 
-+
 
-+void fpu_emulator_init_fpu(void)
 
-+{
 
-+	printk(KERN_INFO "FPU emulator disabled, make sure your toolchain"
 
-+		"was compiled with software floating point support (soft-float)\n");
 
-+	return;
 
-+}
 
-+
 
-+int fpu_emulator_save_context(struct sigcontext __user *sc)
 
-+{
 
-+	return 0;
 
-+}
 
-+
 
-+int fpu_emulator_restore_context(struct sigcontext __user *sc)
 
-+{
 
-+	return 0;
 
-+}
 
-+
 
-+int fpu_emulator_save_context32(struct sigcontext32 __user *sc)
 
-+{
 
-+	return 0;
 
-+}
 
-+
 
-+int fpu_emulator_restore_context32(struct sigcontext32 __user *sc)
 
-+{
 
-+	return 0;
 
-+}
 
-+
 
-+#ifdef CONFIG_64BIT
 
-+#endif	/* CONFIG_64BIT */
 
-+#endif /* CONFIG_MIPS_FPU_EMU */

+ 0 - 371
target/linux/generic/patches-3.3/305-mips_module_reloc.patch
View File 

@@ -1,371 +0,0 @@
 
---- a/arch/mips/Makefile
 
-+++ b/arch/mips/Makefile
 
-@@ -90,8 +90,8 @@ all-$(CONFIG_SYS_SUPPORTS_ZBOOT)+= vmlin
 
- cflags-y			+= -G 0 -mno-abicalls -fno-pic -pipe
 
- cflags-y			+= -msoft-float
 
- LDFLAGS_vmlinux			+= -G 0 -static -n -nostdlib
 
--KBUILD_AFLAGS_MODULE		+= -mlong-calls
 
--KBUILD_CFLAGS_MODULE		+= -mlong-calls
 
-+KBUILD_AFLAGS_MODULE		+= -mno-long-calls
 
-+KBUILD_CFLAGS_MODULE		+= -mno-long-calls
 
- 
- cflags-y += -ffreestanding
 
- 
---- a/arch/mips/include/asm/module.h
 
-+++ b/arch/mips/include/asm/module.h
 
-@@ -9,6 +9,11 @@ struct mod_arch_specific {
 
- 	struct list_head dbe_list;
 
- 	const struct exception_table_entry *dbe_start;
 
- 	const struct exception_table_entry *dbe_end;
 
-+
 
-+	void *phys_plt_tbl;
 
-+	void *virt_plt_tbl;
 
-+	unsigned int phys_plt_offset;
 
-+	unsigned int virt_plt_offset;
 
- };
 
- 
- typedef uint8_t Elf64_Byte;		/* Type for a 8-bit quantity.  */
 
---- a/arch/mips/kernel/module.c
 
-+++ b/arch/mips/kernel/module.c
 
-@@ -44,14 +44,219 @@ static struct mips_hi16 *mips_hi16_list;
 
- static LIST_HEAD(dbe_list);
 
- static DEFINE_SPINLOCK(dbe_lock);
 
- 
--#ifdef MODULE_START
 
-+/*
 
-+ * Get the potential max trampolines size required of the init and
 
-+ * non-init sections. Only used if we cannot find enough contiguous
 
-+ * physically mapped memory to put the module into.
 
-+ */
 
-+static unsigned int
 
-+get_plt_size(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs,
 
-+             const char *secstrings, unsigned int symindex, bool is_init)
 
-+{
 
-+	unsigned long ret = 0;
 
-+	unsigned int i, j;
 
-+	Elf_Sym *syms;
 
-+
 
-+	/* Everything marked ALLOC (this includes the exported symbols) */
 
-+	for (i = 1; i < hdr->e_shnum; ++i) {
 
-+		unsigned int info = sechdrs[i].sh_info;
 
-+
 
-+		if (sechdrs[i].sh_type != SHT_REL
 
-+		    && sechdrs[i].sh_type != SHT_RELA)
 
-+			continue;
 
-+
 
-+		/* Not a valid relocation section? */
 
-+		if (info >= hdr->e_shnum)
 
-+			continue;
 
-+
 
-+		/* Don't bother with non-allocated sections */
 
-+		if (!(sechdrs[info].sh_flags & SHF_ALLOC))
 
-+			continue;
 
-+
 
-+		/* If it's called *.init*, and we're not init, we're
 
-+                   not interested */
 
-+		if ((strstr(secstrings + sechdrs[i].sh_name, ".init") != 0)
 
-+		    != is_init)
 
-+			continue;
 
-+
 
-+		syms = (Elf_Sym *) sechdrs[symindex].sh_addr;
 
-+		if (sechdrs[i].sh_type == SHT_REL) {
 
-+			Elf_Mips_Rel *rel = (void *) sechdrs[i].sh_addr;
 
-+			unsigned int size = sechdrs[i].sh_size / sizeof(*rel);
 
-+
 
-+			for (j = 0; j < size; ++j) {
 
-+				Elf_Sym *sym;
 
-+
 
-+				if (ELF_MIPS_R_TYPE(rel[j]) != R_MIPS_26)
 
-+					continue;
 
-+
 
-+				sym = syms + ELF_MIPS_R_SYM(rel[j]);
 
-+				if (!is_init && sym->st_shndx != SHN_UNDEF)
 
-+					continue;
 
-+
 
-+				ret += 4 * sizeof(int);
 
-+			}
 
-+		} else {
 
-+			Elf_Mips_Rela *rela = (void *) sechdrs[i].sh_addr;
 
-+			unsigned int size = sechdrs[i].sh_size / sizeof(*rela);
 
-+
 
-+			for (j = 0; j < size; ++j) {
 
-+				Elf_Sym *sym;
 
-+
 
-+				if (ELF_MIPS_R_TYPE(rela[j]) != R_MIPS_26)
 
-+					continue;
 
-+
 
-+				sym = syms + ELF_MIPS_R_SYM(rela[j]);
 
-+				if (!is_init && sym->st_shndx != SHN_UNDEF)
 
-+					continue;
 
-+
 
-+				ret += 4 * sizeof(int);
 
-+			}
 
-+		}
 
-+	}
 
-+
 
-+	return ret;
 
-+}
 
-+
 
-+#ifndef MODULE_START
 
-+static void *alloc_phys(unsigned long size)
 
-+{
 
-+	unsigned order;
 
-+	struct page *page;
 
-+	struct page *p;
 
-+
 
-+	size = PAGE_ALIGN(size);
 
-+	order = get_order(size);
 
-+
 
-+	page = alloc_pages(GFP_KERNEL | __GFP_NORETRY | __GFP_NOWARN |
 
-+			__GFP_THISNODE, order);
 
-+	if (!page)
 
-+		return NULL;
 
-+
 
-+	split_page(page, order);
 
-+
 
-+	for (p = page + (size >> PAGE_SHIFT); p < page + (1 << order); ++p)
 
-+		__free_page(p);
 
-+
 
-+	return page_address(page);
 
-+}
 
-+#endif
 
-+
 
-+static void free_phys(void *ptr, unsigned long size)
 
-+{
 
-+	struct page *page;
 
-+	struct page *end;
 
-+
 
-+	page = virt_to_page(ptr);
 
-+	end = page + (PAGE_ALIGN(size) >> PAGE_SHIFT);
 
-+
 
-+	for (; page < end; ++page)
 
-+		__free_page(page);
 
-+}
 
-+
 
-+
 
- void *module_alloc(unsigned long size)
 
- {
 
-+#ifdef MODULE_START
 
- 	return __vmalloc_node_range(size, 1, MODULE_START, MODULE_END,
 
- 				GFP_KERNEL, PAGE_KERNEL, -1,
 
- 				__builtin_return_address(0));
 
-+#else
 
-+	void *ptr;
 
-+
 
-+	if (size == 0)
 
-+		return NULL;
 
-+
 
-+	ptr = alloc_phys(size);
 
-+
 
-+	/* If we failed to allocate physically contiguous memory,
 
-+	 * fall back to regular vmalloc. The module loader code will
 
-+	 * create jump tables to handle long jumps */
 
-+	if (!ptr)
 
-+		return vmalloc(size);
 
-+
 
-+	return ptr;
 
-+#endif
 
- }
 
-+
 
-+static inline bool is_phys_addr(void *ptr)
 
-+{
 
-+#ifdef CONFIG_64BIT
 
-+	return (KSEGX((unsigned long)ptr) == CKSEG0);
 
-+#else
 
-+	return (KSEGX(ptr) == KSEG0);
 
- #endif
 
-+}
 
-+
 
-+/* Free memory returned from module_alloc */
 
-+void module_free(struct module *mod, void *module_region)
 
-+{
 
-+	if (is_phys_addr(module_region)) {
 
-+		if (mod->module_init == module_region)
 
-+			free_phys(module_region, mod->init_size);
 
-+		else if (mod->module_core == module_region)
 
-+			free_phys(module_region, mod->core_size);
 
-+		else
 
-+			BUG();
 
-+	} else {
 
-+		vfree(module_region);
 
-+	}
 
-+}
 
-+
 
-+static void *__module_alloc(int size, bool phys)
 
-+{
 
-+	void *ptr;
 
-+
 
-+	if (phys)
 
-+		ptr = kmalloc(size, GFP_KERNEL);
 
-+	else
 
-+		ptr = vmalloc(size);
 
-+	return ptr;
 
-+}
 
-+
 
-+static void __module_free(void *ptr)
 
-+{
 
-+	if (is_phys_addr(ptr))
 
-+		kfree(ptr);
 
-+	else
 
-+		vfree(ptr);
 
-+}
 
-+
 
-+int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
 
-+			      char *secstrings, struct module *mod)
 
-+{
 
-+	unsigned int symindex = 0;
 
-+	unsigned int core_size, init_size;
 
-+	int i;
 
-+
 
-+	for (i = 1; i < hdr->e_shnum; i++)
 
-+		if (sechdrs[i].sh_type == SHT_SYMTAB)
 
-+			symindex = i;
 
-+
 
-+	core_size = get_plt_size(hdr, sechdrs, secstrings, symindex, false);
 
-+	init_size = get_plt_size(hdr, sechdrs, secstrings, symindex, true);
 
-+
 
-+	mod->arch.phys_plt_offset = 0;
 
-+	mod->arch.virt_plt_offset = 0;
 
-+	mod->arch.phys_plt_tbl = NULL;
 
-+	mod->arch.virt_plt_tbl = NULL;
 
-+
 
-+	if ((core_size + init_size) == 0)
 
-+		return 0;
 
-+
 
-+	mod->arch.phys_plt_tbl = __module_alloc(core_size + init_size, 1);
 
-+	if (!mod->arch.phys_plt_tbl)
 
-+		return -ENOMEM;
 
-+
 
-+	mod->arch.virt_plt_tbl = __module_alloc(core_size + init_size, 0);
 
-+	if (!mod->arch.virt_plt_tbl) {
 
-+		__module_free(mod->arch.phys_plt_tbl);
 
-+		mod->arch.phys_plt_tbl = NULL;
 
-+		return -ENOMEM;
 
-+	}
 
-+
 
-+	return 0;
 
-+}
 
- 
- static int apply_r_mips_none(struct module *me, u32 *location, Elf_Addr v)
 
- {
 
-@@ -72,28 +277,36 @@ static int apply_r_mips_32_rela(struct m
 
- 	return 0;
 
- }
 
- 
--static int apply_r_mips_26_rel(struct module *me, u32 *location, Elf_Addr v)
 
-+static Elf_Addr add_plt_entry_to(unsigned *plt_offset,
 
-+				 void *start, Elf_Addr v)
 
- {
 
--	if (v % 4) {
 
--		pr_err("module %s: dangerous R_MIPS_26 REL relocation\n",
 
--		       me->name);
 
--		return -ENOEXEC;
 
--	}
 
-+	unsigned *tramp = start + *plt_offset;
 
-+	*plt_offset += 4 * sizeof(int);
 
- 
--	if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
 
--		printk(KERN_ERR
 
--		       "module %s: relocation overflow\n",
 
--		       me->name);
 
--		return -ENOEXEC;
 
--	}
 
-+	/* adjust carry for addiu */
 
-+	if (v & 0x00008000)
 
-+		v += 0x10000;
 
- 
--	*location = (*location & ~0x03ffffff) |
 
--	            ((*location + (v >> 2)) & 0x03ffffff);
 
-+	tramp[0] = 0x3c190000 | (v >> 16);      /* lui t9, hi16 */
 
-+	tramp[1] = 0x27390000 | (v & 0xffff);   /* addiu t9, t9, lo16 */
 
-+	tramp[2] = 0x03200008;                  /* jr t9 */
 
-+	tramp[3] = 0x00000000;                  /* nop */
 
- 
--	return 0;
 
-+	return (Elf_Addr) tramp;
 
- }
 
- 
--static int apply_r_mips_26_rela(struct module *me, u32 *location, Elf_Addr v)
 
-+static Elf_Addr add_plt_entry(struct module *me, void *location, Elf_Addr v)
 
-+{
 
-+	if (is_phys_addr(location))
 
-+		return add_plt_entry_to(&me->arch.phys_plt_offset,
 
-+				me->arch.phys_plt_tbl, v);
 
-+	else
 
-+		return add_plt_entry_to(&me->arch.virt_plt_offset,
 
-+				me->arch.virt_plt_tbl, v);
 
-+
 
-+}
 
-+
 
-+static int set_r_mips_26(struct module *me, u32 *location, u32 ofs, Elf_Addr v)
 
- {
 
- 	if (v % 4) {
 
- 		pr_err("module %s: dangerous R_MIPS_26 RELArelocation\n",
 
-@@ -102,17 +315,31 @@ static int apply_r_mips_26_rela(struct m
 
- 	}
 
- 
- 	if ((v & 0xf0000000) != (((unsigned long)location + 4) & 0xf0000000)) {
 
--		printk(KERN_ERR
 
-+	    v = add_plt_entry(me, location, v + (ofs << 2));
 
-+		if (!v) {
 
-+			printk(KERN_ERR
 
- 		       "module %s: relocation overflow\n",
 
- 		       me->name);
 
--		return -ENOEXEC;
 
-+			return -ENOEXEC;
 
-+		}
 
-+		ofs = 0;
 
- 	}
 
- 
--	*location = (*location & ~0x03ffffff) | ((v >> 2) & 0x03ffffff);
 
-+	*location = (*location & ~0x03ffffff) | ((ofs + (v >> 2)) & 0x03ffffff);
 
- 
- 	return 0;
 
- }
 
- 
-+static int apply_r_mips_26_rel(struct module *me, u32 *location, Elf_Addr v)
 
-+{
 
-+	return set_r_mips_26(me, location, *location & 0x03ffffff, v);
 
-+}
 
-+
 
-+static int apply_r_mips_26_rela(struct module *me, u32 *location, Elf_Addr v)
 
-+{
 
-+	return set_r_mips_26(me, location, 0, v);
 
-+}
 
-+
 
- static int apply_r_mips_hi16_rel(struct module *me, u32 *location, Elf_Addr v)
 
- {
 
- 	struct mips_hi16 *n;
 
-@@ -380,11 +607,32 @@ int module_finalize(const Elf_Ehdr *hdr,
 
- 		list_add(&me->arch.dbe_list, &dbe_list);
 
- 		spin_unlock_irq(&dbe_lock);
 
- 	}
 
-+
 
-+	/* Get rid of the fixup trampoline if we're running the module
 
-+	 * from physically mapped address space */
 
-+	if (me->arch.phys_plt_offset == 0) {
 
-+		__module_free(me->arch.phys_plt_tbl);
 
-+		me->arch.phys_plt_tbl = NULL;
 
-+	}
 
-+	if (me->arch.virt_plt_offset == 0) {
 
-+		__module_free(me->arch.virt_plt_tbl);
 
-+		me->arch.virt_plt_tbl = NULL;
 
-+	}
 
-+
 
- 	return 0;
 
- }
 
- 
- void module_arch_cleanup(struct module *mod)
 
- {
 
-+	if (mod->arch.phys_plt_tbl) {
 
-+		__module_free(mod->arch.phys_plt_tbl);
 
-+		mod->arch.phys_plt_tbl = NULL;
 
-+	}
 
-+	if (mod->arch.virt_plt_tbl) {
 
-+		__module_free(mod->arch.virt_plt_tbl);
 
-+		mod->arch.virt_plt_tbl = NULL;
 
-+	}
 
-+
 
- 	spin_lock_irq(&dbe_lock);
 
- 	list_del(&mod->arch.dbe_list);
 
- 	spin_unlock_irq(&dbe_lock);

+ 0 - 83
target/linux/generic/patches-3.3/306-mips_mem_functions_performance.patch
View File 

@@ -1,83 +0,0 @@
 
---- a/arch/mips/include/asm/string.h
 
-+++ b/arch/mips/include/asm/string.h
 
-@@ -133,11 +133,44 @@ strncmp(__const__ char *__cs, __const__
 
- 
- #define __HAVE_ARCH_MEMSET
 
- extern void *memset(void *__s, int __c, size_t __count);
 
-+#define memset(__s, __c, len)					\
 
-+({								\
 
-+	size_t __len = (len);					\
 
-+	void *__ret;						\
 
-+	if (__builtin_constant_p(len) && __len >= 64)		\
 
-+		__ret = memset((__s), (__c), __len);		\
 
-+	else							\
 
-+		__ret = __builtin_memset((__s), (__c), __len);	\
 
-+	__ret;							\
 
-+})
 
- 
- #define __HAVE_ARCH_MEMCPY
 
- extern void *memcpy(void *__to, __const__ void *__from, size_t __n);
 
-+#define memcpy(dst, src, len)					\
 
-+({								\
 
-+	size_t __len = (len);					\
 
-+	void *__ret;						\
 
-+	if (__builtin_constant_p(len) && __len >= 64)		\
 
-+		__ret = memcpy((dst), (src), __len);		\
 
-+	else							\
 
-+		__ret = __builtin_memcpy((dst), (src), __len);	\
 
-+	__ret;							\
 
-+})
 
- 
- #define __HAVE_ARCH_MEMMOVE
 
- extern void *memmove(void *__dest, __const__ void *__src, size_t __n);
 
-+#define memmove(dst, src, len)					\
 
-+({								\
 
-+	size_t __len = (len);					\
 
-+	void *__ret;						\
 
-+	if (__builtin_constant_p(len) && __len >= 64)		\
 
-+		__ret = memmove((dst), (src), __len);		\
 
-+	else							\
 
-+		__ret = __builtin_memmove((dst), (src), __len);	\
 
-+	__ret;							\
 
-+})
 
-+
 
-+#define __HAVE_ARCH_MEMCMP
 
-+#define memcmp(src1, src2, len) __builtin_memcmp((src1), (src2), (len))
 
- 
- #endif /* _ASM_STRING_H */
 
---- a/arch/mips/lib/Makefile
 
-+++ b/arch/mips/lib/Makefile
 
-@@ -3,7 +3,7 @@
 
- #
 
- 
- lib-y	+= csum_partial.o delay.o memcpy.o memcpy-inatomic.o memset.o \
 
--	   strlen_user.o strncpy_user.o strnlen_user.o uncached.o
 
-+	   strlen_user.o strncpy_user.o strnlen_user.o uncached.o memcmp.o
 
- 
- obj-y			+= iomap.o
 
- obj-$(CONFIG_PCI)	+= iomap-pci.o
 
---- /dev/null
 
-+++ b/arch/mips/lib/memcmp.c
 
-@@ -0,0 +1,22 @@
 
-+/*
 
-+ *  copied from linux/lib/string.c
 
-+ *
 
-+ *  Copyright (C) 1991, 1992  Linus Torvalds
 
-+ */
 
-+
 
-+#include <linux/module.h>
 
-+#include <linux/string.h>
 
-+
 
-+#undef memcmp
 
-+int memcmp(const void *cs, const void *ct, size_t count)
 
-+{
 
-+	const unsigned char *su1, *su2;
 
-+	int res = 0;
 
-+
 
-+	for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
 
-+		if ((res = *su1 - *su2) != 0)
 
-+			break;
 
-+	return res;
 
-+}
 
-+EXPORT_SYMBOL(memcmp);
 
-+

+ 0 - 35
target/linux/generic/patches-3.3/307-mips_oprofile_fix.patch
View File 

@@ -1,35 +0,0 @@
 
---- a/arch/mips/oprofile/op_model_mipsxx.c
 
-+++ b/arch/mips/oprofile/op_model_mipsxx.c
 
-@@ -298,6 +298,11 @@ static void reset_counters(void *arg)
 
- 	}
 
- }
 
- 
-+static irqreturn_t mipsxx_perfcount_int(int irq, void *dev_id)
 
-+{
 
-+	return mipsxx_perfcount_handler();
 
-+}
 
-+
 
- static int __init mipsxx_init(void)
 
- {
 
- 	int counters;
 
-@@ -374,6 +379,10 @@ static int __init mipsxx_init(void)
 
- 	save_perf_irq = perf_irq;
 
- 	perf_irq = mipsxx_perfcount_handler;
 
- 
-+	if (cp0_perfcount_irq >= 0)
 
-+		return request_irq(cp0_perfcount_irq, mipsxx_perfcount_int,
 
-+			IRQF_SHARED, "Perfcounter", save_perf_irq);
 
-+
 
- 	return 0;
 
- }
 
- 
-@@ -381,6 +390,9 @@ static void mipsxx_exit(void)
 
- {
 
- 	int counters = op_model_mipsxx_ops.num_counters;
 
- 
-+	if (cp0_perfcount_irq >= 0)
 
-+		free_irq(cp0_perfcount_irq, save_perf_irq);
 
-+
 
- 	counters = counters_per_cpu_to_total(counters);
 
- 	on_each_cpu(reset_counters, (void *)(long)counters, 1);
 
-

+ 0 - 17
target/linux/generic/patches-3.3/308-mips-show-correct-cpu-name-for-24KEc.patch
View File 

@@ -1,17 +0,0 @@
 
---- a/arch/mips/kernel/cpu-probe.c
 
-+++ b/arch/mips/kernel/cpu-probe.c
 
-@@ -816,10 +816,13 @@ static inline void cpu_probe_mips(struct
 
- 		__cpu_name[cpu] = "MIPS 20Kc";
 
- 		break;
 
- 	case PRID_IMP_24K:
 
--	case PRID_IMP_24KE:
 
- 		c->cputype = CPU_24K;
 
- 		__cpu_name[cpu] = "MIPS 24Kc";
 
- 		break;
 
-+	case PRID_IMP_24KE:
 
-+		c->cputype = CPU_24K;
 
-+		__cpu_name[cpu] = "MIPS 24KEc";
 
-+		break;
 
- 	case PRID_IMP_25KF:
 
- 		c->cputype = CPU_25KF;
 
- 		__cpu_name[cpu] = "MIPS 25Kc";

+ 0 - 32
target/linux/generic/patches-3.3/309-mips_fuse_workaround.patch
View File 

@@ -1,32 +0,0 @@
 
---- a/arch/mips/mm/cache.c
 
-+++ b/arch/mips/mm/cache.c
 
-@@ -39,6 +39,7 @@ void (*__flush_kernel_vmap_range)(unsign
 
- void (*__invalidate_kernel_vmap_range)(unsigned long vaddr, int size);
 
- 
- EXPORT_SYMBOL_GPL(__flush_kernel_vmap_range);
 
-+EXPORT_SYMBOL(__flush_cache_all);
 
- 
- /* MIPS specific cache operations */
 
- void (*flush_cache_sigtramp)(unsigned long addr);
 
---- a/fs/fuse/dev.c
 
-+++ b/fs/fuse/dev.c
 
-@@ -19,6 +19,9 @@
 
- #include <linux/pipe_fs_i.h>
 
- #include <linux/swap.h>
 
- #include <linux/splice.h>
 
-+#ifdef CONFIG_MIPS
 
-+#include <asm/cacheflush.h>
 
-+#endif
 
- 
- MODULE_ALIAS_MISCDEV(FUSE_MINOR);
 
- MODULE_ALIAS("devname:fuse");
 
-@@ -655,6 +658,9 @@ static int fuse_copy_fill(struct fuse_co
 
- static int fuse_copy_do(struct fuse_copy_state *cs, void **val, unsigned *size)
 
- {
 
- 	unsigned ncpy = min(*size, cs->len);
 
-+#ifdef CONFIG_MIPS
 
-+	__flush_cache_all();
 
-+#endif
 
- 	if (val) {
 
- 		if (cs->write)
 
- 			memcpy(cs->buf, *val, ncpy);

+ 0 - 13
target/linux/generic/patches-3.3/310-arm_module_unresolved_weak_sym.patch
View File 

@@ -1,13 +0,0 @@
 
---- a/arch/arm/kernel/module.c
 
-+++ b/arch/arm/kernel/module.c
 
-@@ -81,6 +81,10 @@ apply_relocate(Elf32_Shdr *sechdrs, cons
 
- 			return -ENOEXEC;
 
- 		}
 
- 
-+		if ((IS_ERR_VALUE(sym->st_value) || !sym->st_value) &&
 
-+		    ELF_ST_BIND(sym->st_info) == STB_WEAK)
 
-+			continue;
 
-+
 
- 		loc = dstsec->sh_addr + rel->r_offset;
 
- 
- 		switch (ELF32_R_TYPE(rel->r_info)) {

+ 0 - 31
target/linux/generic/patches-3.3/320-ppc4xx_optimization.patch
View File 

@@ -1,31 +0,0 @@
 
-Upstream doesn't optimize the kernel and bootwrappers for ppc44x because
 
-they still want to support gcc 3.3 -- well, we don't.
 
-
 
---- a/arch/powerpc/Makefile
 
-+++ b/arch/powerpc/Makefile
 
-@@ -130,7 +130,8 @@ ifeq ($(CONFIG_FUNCTION_TRACER),y)
 
- KBUILD_CFLAGS		+= -mno-sched-epilog
 
- endif
 
- 
--cpu-as-$(CONFIG_4xx)		+= -Wa,-m405
 
-+cpu-as-$(CONFIG_40x)		+= -Wa,-m405
 
-+cpu-as-$(CONFIG_44x)		+= -Wa,-m440
 
- cpu-as-$(CONFIG_ALTIVEC)	+= -Wa,-maltivec
 
- cpu-as-$(CONFIG_E500)		+= -Wa,-me500
 
- cpu-as-$(CONFIG_E200)		+= -Wa,-me200
 
---- a/arch/powerpc/boot/Makefile
 
-+++ b/arch/powerpc/boot/Makefile
 
-@@ -38,10 +38,10 @@ BOOTCFLAGS	+= -I$(obj) -I$(srctree)/$(ob
 
- DTC_FLAGS	?= -p 1024
 
- 
- $(obj)/4xx.o: BOOTCFLAGS += -mcpu=405
 
--$(obj)/ebony.o: BOOTCFLAGS += -mcpu=405
 
-+$(obj)/ebony.o: BOOTCFLAGS += -mcpu=440
 
- $(obj)/cuboot-hotfoot.o: BOOTCFLAGS += -mcpu=405
 
--$(obj)/cuboot-taishan.o: BOOTCFLAGS += -mcpu=405
 
--$(obj)/cuboot-katmai.o: BOOTCFLAGS += -mcpu=405
 
-+$(obj)/cuboot-taishan.o: BOOTCFLAGS += -mcpu=440
 
-+$(obj)/cuboot-katmai.o: BOOTCFLAGS += -mcpu=440
 
- $(obj)/cuboot-acadia.o: BOOTCFLAGS += -mcpu=405
 
- $(obj)/treeboot-walnut.o: BOOTCFLAGS += -mcpu=405
 
- $(obj)/treeboot-iss4xx.o: BOOTCFLAGS += -mcpu=405

+ 0 - 10
target/linux/generic/patches-3.3/321-powerpc_crtsavres_prereq.patch
View File 

@@ -1,10 +0,0 @@
 
---- a/arch/powerpc/Makefile
 
-+++ b/arch/powerpc/Makefile
 
-@@ -94,7 +94,6 @@ else
 
- endif
 
- endif
 
- 
--KBUILD_LDFLAGS_MODULE += arch/powerpc/lib/crtsavres.o
 
- 
- ifeq ($(CONFIG_TUNE_CELL),y)
 
- 	KBUILD_CFLAGS += $(call cc-option,-mtune=cell)

+ 0 - 10
target/linux/generic/patches-3.3/322-ppc4xx-crypto-compile-fix.patch
View File 

@@ -1,10 +0,0 @@
 
---- a/drivers/crypto/amcc/crypto4xx_core.c
 
-+++ b/drivers/crypto/amcc/crypto4xx_core.c
 
-@@ -19,6 +19,7 @@
 
-  */
 
- 
- #include <linux/kernel.h>
 
-+#include <linux/module.h>
 
- #include <linux/interrupt.h>
 
- #include <linux/spinlock_types.h>
 
- #include <linux/random.h>

+ 0 - 616
target/linux/generic/patches-3.3/330-mips-add-crash-and-kdump-support.patch
View File 

@@ -1,616 +0,0 @@
 
-From eee16330c9de9adf7880cce9f1d32e13f89706bb Mon Sep 17 00:00:00 2001
 
-From: Wu Zhangjin <[email protected]>
 
-Date: Tue, 11 Jan 2011 13:16:47 +0000
 
-Subject: MIPS: Add crash and kdump support
 
-
 
-From: http://patchwork.linux-mips.org/patch/1025/
 
-
 
-Hello folks,
 
-
 
-Please find here MIPS crash and kdump patches.
 
-This is patch set of 3 patches:
 
-1. generic MIPS changes (kernel);
 
-2. MIPS Cavium Octeon board kexec/kdump code (kernel);
 
-3. Kexec user space MIPS changes.
 
-
 
-Patches were tested on the latest linux-mips@ git kernel and the latest
 
-kexec-tools git on Cavium Octeon 50xx board.
 
-
 
-I also made the same code working on RMI XLR/XLS boards for both
 
-mips32 and mips64 kernels.
 
-
 
-Best regards,
 
-Maxim Uvarov.
 
-
 
-------
 
-[ Zhangjin: Several trivial building failure has been fixed.
 
-
 
-Note: the 2nd patch can not be cleanly applied, but may be a good
 
-reference for the other board development:
 
-
 
-	+ MIPS Cavium Octeon board kexec,kdump support
 
-	http://patchwork.linux-mips.org/patch/1026/
 
-
 
-And the 3rd patch has already been merged into the mainline kexec-tools:
 
-
 
-	+ some kexec MIPS improvements
 
-	http://patchwork.linux-mips.org/patch/1027/
 
-
 
-kexec-tools is available here:
 
-
 
-	+ http://horms.net/projects/kexec/
 
-	git://git.kernel.org/pub/scm/utils/kernel/kexec/kexec-tools.git
 
-]
 
-Signed-off-by: Wu Zhangjin <[email protected]>
 
----
 
-(limited to 'arch/mips/kernel')
 
-
 
---- a/arch/mips/kernel/Makefile
 
-+++ b/arch/mips/kernel/Makefile
 
-@@ -97,7 +97,8 @@ obj-$(CONFIG_I8253)		+= i8253.o
 
- 
- obj-$(CONFIG_GPIO_TXX9)		+= gpio_txx9.o
 
- 
--obj-$(CONFIG_KEXEC)		+= machine_kexec.o relocate_kernel.o
 
-+obj-$(CONFIG_KEXEC)		+= machine_kexec.o relocate_kernel.o crash.o
 
-+obj-$(CONFIG_CRASH_DUMP)	+= crash_dump.o
 
- obj-$(CONFIG_EARLY_PRINTK)	+= early_printk.o
 
- obj-$(CONFIG_SPINLOCK_TEST)	+= spinlock_test.o
 
- obj-$(CONFIG_MIPS_MACHINE)	+= mips_machine.o
 
---- /dev/null
 
-+++ b/arch/mips/kernel/crash.c
 
-@@ -0,0 +1,75 @@
 
-+#include <linux/kernel.h>
 
-+#include <linux/smp.h>
 
-+#include <linux/reboot.h>
 
-+#include <linux/kexec.h>
 
-+#include <linux/bootmem.h>
 
-+#include <linux/crash_dump.h>
 
-+#include <linux/delay.h>
 
-+#include <linux/init.h>
 
-+#include <linux/irq.h>
 
-+#include <linux/types.h>
 
-+#include <linux/sched.h>
 
-+
 
-+#ifdef CONFIG_CRASH_DUMP
 
-+unsigned long long elfcorehdr_addr = ELFCORE_ADDR_MAX;
 
-+#endif
 
-+
 
-+/* This keeps a track of which one is crashing cpu. */
 
-+int crashing_cpu = -1;
 
-+static cpumask_t cpus_in_crash = CPU_MASK_NONE;
 
-+
 
-+#ifdef CONFIG_SMP
 
-+void crash_shutdown_secondary(void *ignore)
 
-+{
 
-+	struct pt_regs *regs;
 
-+	int cpu = smp_processor_id();
 
-+
 
-+	regs = task_pt_regs(current);
 
-+
 
-+	if (!cpu_online(cpu))
 
-+		return;
 
-+
 
-+	local_irq_disable();
 
-+	if (!cpu_isset(cpu, cpus_in_crash))
 
-+		crash_save_cpu(regs, cpu);
 
-+	cpu_set(cpu, cpus_in_crash);
 
-+
 
-+	while (!atomic_read(&kexec_ready_to_reboot))
 
-+		cpu_relax();
 
-+	relocated_kexec_smp_wait(NULL);
 
-+	/* NOTREACHED */
 
-+}
 
-+
 
-+static void crash_kexec_prepare_cpus(void)
 
-+{
 
-+	unsigned int msecs;
 
-+
 
-+	unsigned int ncpus = num_online_cpus() - 1;/* Excluding the panic cpu */
 
-+
 
-+	dump_send_ipi(crash_shutdown_secondary);
 
-+	smp_wmb();
 
-+
 
-+	/*
 
-+	 * The crash CPU sends an IPI and wait for other CPUs to
 
-+	 * respond. Delay of at least 10 seconds.
 
-+	 */
 
-+	printk(KERN_EMERG "Sending IPI to other cpus...\n");
 
-+	msecs = 10000;
 
-+	while ((cpus_weight(cpus_in_crash) < ncpus) && (--msecs > 0)) {
 
-+		cpu_relax();
 
-+		mdelay(1);
 
-+	}
 
-+}
 
-+
 
-+#else
 
-+static void crash_kexec_prepare_cpus(void) {}
 
-+#endif
 
-+
 
-+void default_machine_crash_shutdown(struct pt_regs *regs)
 
-+{
 
-+	local_irq_disable();
 
-+	crashing_cpu = smp_processor_id();
 
-+	crash_save_cpu(regs, crashing_cpu);
 
-+	crash_kexec_prepare_cpus();
 
-+	cpu_set(crashing_cpu, cpus_in_crash);
 
-+}
 
---- /dev/null
 
-+++ b/arch/mips/kernel/crash_dump.c
 
-@@ -0,0 +1,86 @@
 
-+#include <linux/highmem.h>
 
-+#include <linux/bootmem.h>
 
-+#include <linux/crash_dump.h>
 
-+#include <asm/uaccess.h>
 
-+
 
-+#ifdef CONFIG_PROC_VMCORE
 
-+static int __init parse_elfcorehdr(char *p)
 
-+{
 
-+	if (p)
 
-+		elfcorehdr_addr = memparse(p, &p);
 
-+	return 1;
 
-+}
 
-+__setup("elfcorehdr=", parse_elfcorehdr);
 
-+#endif
 
-+
 
-+static int __init parse_savemaxmem(char *p)
 
-+{
 
-+	if (p)
 
-+		saved_max_pfn = (memparse(p, &p) >> PAGE_SHIFT) - 1;
 
-+
 
-+	return 1;
 
-+}
 
-+__setup("savemaxmem=", parse_savemaxmem);
 
-+
 
-+
 
-+static void *kdump_buf_page;
 
-+
 
-+/**
 
-+ * copy_oldmem_page - copy one page from "oldmem"
 
-+ * @pfn: page frame number to be copied
 
-+ * @buf: target memory address for the copy; this can be in kernel address
 
-+ *	space or user address space (see @userbuf)
 
-+ * @csize: number of bytes to copy
 
-+ * @offset: offset in bytes into the page (based on pfn) to begin the copy
 
-+ * @userbuf: if set, @buf is in user address space, use copy_to_user(),
 
-+ *	otherwise @buf is in kernel address space, use memcpy().
 
-+ *
 
-+ * Copy a page from "oldmem". For this page, there is no pte mapped
 
-+ * in the current kernel.
 
-+ *
 
-+ * Calling copy_to_user() in atomic context is not desirable. Hence first
 
-+ * copying the data to a pre-allocated kernel page and then copying to user
 
-+ * space in non-atomic context.
 
-+ */
 
-+ssize_t copy_oldmem_page(unsigned long pfn, char *buf,
 
-+		size_t csize, unsigned long offset, int userbuf)
 
-+{
 
-+	void  *vaddr;
 
-+
 
-+	if (!csize)
 
-+		return 0;
 
-+
 
-+	vaddr = kmap_atomic_pfn(pfn, KM_PTE0);
 
-+
 
-+	if (!userbuf) {
 
-+		memcpy(buf, (vaddr + offset), csize);
 
-+		kunmap_atomic(vaddr, KM_PTE0);
 
-+	} else {
 
-+		if (!kdump_buf_page) {
 
-+			printk(KERN_WARNING "Kdump: Kdump buffer page not"
 
-+				" allocated\n");
 
-+			return -EFAULT;
 
-+		}
 
-+		copy_page(kdump_buf_page, vaddr);
 
-+		kunmap_atomic(vaddr, KM_PTE0);
 
-+		if (copy_to_user(buf, (kdump_buf_page + offset), csize))
 
-+			return -EFAULT;
 
-+	}
 
-+
 
-+	return csize;
 
-+}
 
-+
 
-+static int __init kdump_buf_page_init(void)
 
-+{
 
-+	int ret = 0;
 
-+
 
-+	kdump_buf_page = kmalloc(PAGE_SIZE, GFP_KERNEL);
 
-+	if (!kdump_buf_page) {
 
-+		printk(KERN_WARNING "Kdump: Failed to allocate kdump buffer"
 
-+			 " page\n");
 
-+		ret = -ENOMEM;
 
-+	}
 
-+
 
-+	return ret;
 
-+}
 
-+arch_initcall(kdump_buf_page_init);
 
---- a/arch/mips/kernel/machine_kexec.c
 
-+++ b/arch/mips/kernel/machine_kexec.c
 
-@@ -19,9 +19,19 @@ extern const size_t relocate_new_kernel_
 
- extern unsigned long kexec_start_address;
 
- extern unsigned long kexec_indirection_page;
 
- 
-+int (*_machine_kexec_prepare)(struct kimage *) = NULL;
 
-+void (*_machine_kexec_shutdown)(void) = NULL;
 
-+void (*_machine_crash_shutdown)(struct pt_regs *regs) = NULL;
 
-+#ifdef CONFIG_SMP
 
-+void (*relocated_kexec_smp_wait) (void *);
 
-+atomic_t kexec_ready_to_reboot = ATOMIC_INIT(0);
 
-+#endif
 
-+
 
- int
 
- machine_kexec_prepare(struct kimage *kimage)
 
- {
 
-+	if (_machine_kexec_prepare)
 
-+		return _machine_kexec_prepare(kimage);
 
- 	return 0;
 
- }
 
- 
-@@ -33,11 +43,17 @@ machine_kexec_cleanup(struct kimage *kim
 
- void
 
- machine_shutdown(void)
 
- {
 
-+	if (_machine_kexec_shutdown)
 
-+		_machine_kexec_shutdown();
 
- }
 
- 
- void
 
- machine_crash_shutdown(struct pt_regs *regs)
 
- {
 
-+	if (_machine_crash_shutdown)
 
-+		_machine_crash_shutdown(regs);
 
-+	else
 
-+		default_machine_crash_shutdown(regs);
 
- }
 
- 
- typedef void (*noretfun_t)(void) __attribute__((noreturn));
 
-@@ -52,7 +68,9 @@ machine_kexec(struct kimage *image)
 
- 	reboot_code_buffer =
 
- 	  (unsigned long)page_address(image->control_code_page);
 
- 
--	kexec_start_address = (unsigned long) phys_to_virt(image->start);
 
-+	kexec_start_address =
 
-+	  (unsigned long) phys_to_virt(image->start);
 
-+
 
- 	kexec_indirection_page =
 
- 		(unsigned long) phys_to_virt(image->head & PAGE_MASK);
 
- 
-@@ -63,7 +81,7 @@ machine_kexec(struct kimage *image)
 
- 	 * The generic kexec code builds a page list with physical
 
- 	 * addresses. they are directly accessible through KSEG0 (or
 
- 	 * CKSEG0 or XPHYS if on 64bit system), hence the
 
--	 * pys_to_virt() call.
 
-+	 * phys_to_virt() call.
 
- 	 */
 
- 	for (ptr = &image->head; (entry = *ptr) && !(entry &IND_DONE);
 
- 	     ptr = (entry & IND_INDIRECTION) ?
 
-@@ -81,5 +99,13 @@ machine_kexec(struct kimage *image)
 
- 	printk("Will call new kernel at %08lx\n", image->start);
 
- 	printk("Bye ...\n");
 
- 	__flush_cache_all();
 
-+#ifdef CONFIG_SMP
 
-+	/* All secondary cpus now may jump to kexec_wait cycle */
 
-+	relocated_kexec_smp_wait = reboot_code_buffer +
 
-+		(void *)(kexec_smp_wait - relocate_new_kernel);
 
-+	smp_wmb();
 
-+	atomic_set(&kexec_ready_to_reboot, 1);
 
-+#endif
 
- 	((noretfun_t) reboot_code_buffer)();
 
- }
 
-+
 
---- a/arch/mips/kernel/relocate_kernel.S
 
-+++ b/arch/mips/kernel/relocate_kernel.S
 
-@@ -15,6 +15,11 @@
 
- #include <asm/addrspace.h>
 
- 
- LEAF(relocate_new_kernel)
 
-+	PTR_L a0,	arg0
 
-+	PTR_L a1,	arg1
 
-+	PTR_L a2,	arg2
 
-+	PTR_L a3,	arg3
 
-+
 
- 	PTR_L		s0, kexec_indirection_page
 
- 	PTR_L		s1, kexec_start_address
 
- 
-@@ -26,7 +31,6 @@ process_entry:
 
- 	and		s3, s2, 0x1
 
- 	beq		s3, zero, 1f
 
- 	and		s4, s2, ~0x1	/* store destination addr in s4 */
 
--	move		a0, s4
 
- 	b		process_entry
 
- 
- 1:
 
-@@ -60,23 +64,100 @@ copy_word:
 
- 	b		process_entry
 
- 
- done:
 
-+#ifdef CONFIG_SMP
 
-+	/* kexec_flag reset is signal to other CPUs what kernel
 
-+ 	   was moved to it's location. Note - we need relocated address
 
-+ 	   of kexec_flag.  */
 
-+
 
-+ 	bal		1f
 
-+ 1: 	move		t1,ra;
 
-+ 	PTR_LA		t2,1b
 
-+ 	PTR_LA		t0,kexec_flag
 
-+ 	PTR_SUB		t0,t0,t2;
 
-+ 	PTR_ADD		t0,t1,t0;
 
-+ 	LONG_S		zero,(t0)
 
-+#endif
 
-+
 
-+	sync
 
- 	/* jump to kexec_start_address */
 
- 	j		s1
 
- 	END(relocate_new_kernel)
 
- 
--kexec_start_address:
 
--	EXPORT(kexec_start_address)
 
-+#ifdef CONFIG_SMP
 
-+/*
 
-+ * Other CPUs should wait until code is relocated and
 
-+ * then start at entry (?) point.
 
-+ */
 
-+LEAF(kexec_smp_wait)
 
-+	PTR_L		a0, s_arg0
 
-+	PTR_L		a1, s_arg1
 
-+	PTR_L		a2, s_arg2
 
-+	PTR_L		a3, s_arg3
 
-+	PTR_L		s1, kexec_start_address
 
-+
 
-+	/* Non-relocated address works for args and kexec_start_address ( old
 
-+	 * kernel is not overwritten). But we need relocated address of
 
-+	 * kexec_flag.
 
-+	 */
 
-+
 
-+	bal		1f
 
-+1:	move		t1,ra;
 
-+	PTR_LA		t2,1b
 
-+	PTR_LA		t0,kexec_flag
 
-+	PTR_SUB		t0,t0,t2;
 
-+	PTR_ADD		t0,t1,t0;
 
-+
 
-+1:	LONG_L		s0, (t0)
 
-+	bne		s0, zero,1b
 
-+
 
-+	sync
 
-+	j		s1
 
-+	END(kexec_smp_wait)
 
-+#endif
 
-+
 
-+#ifdef __mips64
 
-+       /* all PTR's must be aligned to 8 byte in 64-bit mode */
 
-+       .align  3
 
-+#endif
 
-+
 
-+/* All parameters to new kernel are passed in registers a0-a3.
 
-+ * kexec_args[0..3] are uses to prepare register values.
 
-+ */
 
-+
 
-+EXPORT(kexec_args)
 
-+arg0:	PTR		0x0
 
-+arg1:	PTR		0x0
 
-+arg2:	PTR		0x0
 
-+arg3:	PTR		0x0
 
-+	.size	kexec_args,PTRSIZE*4
 
-+
 
-+#ifdef CONFIG_SMP
 
-+/*
 
-+ * Secondary CPUs may have different kernel parameters in
 
-+ * their registers a0-a3. secondary_kexec_args[0..3] are used
 
-+ * to prepare register values.
 
-+ */
 
-+EXPORT(secondary_kexec_args)
 
-+s_arg0:	PTR		0x0
 
-+s_arg1:	PTR		0x0
 
-+s_arg2:	PTR		0x0
 
-+s_arg3:	PTR		0x0
 
-+	.size	secondary_kexec_args,PTRSIZE*4
 
-+kexec_flag:
 
-+	LONG		0x1
 
-+
 
-+#endif
 
-+
 
-+EXPORT(kexec_start_address)
 
- 	PTR		0x0
 
- 	.size		kexec_start_address, PTRSIZE
 
- 
--kexec_indirection_page:
 
--	EXPORT(kexec_indirection_page)
 
-+EXPORT(kexec_indirection_page)
 
- 	PTR		0
 
- 	.size		kexec_indirection_page, PTRSIZE
 
- 
- relocate_new_kernel_end:
 
- 
--relocate_new_kernel_size:
 
--	EXPORT(relocate_new_kernel_size)
 
-+EXPORT(relocate_new_kernel_size)
 
- 	PTR		relocate_new_kernel_end - relocate_new_kernel
 
- 	.size		relocate_new_kernel_size, PTRSIZE
 
---- a/arch/mips/kernel/setup.c
 
-+++ b/arch/mips/kernel/setup.c
 
-@@ -22,6 +22,7 @@
 
- #include <linux/console.h>
 
- #include <linux/pfn.h>
 
- #include <linux/debugfs.h>
 
-+#include <linux/kexec.h>
 
- 
- #include <asm/addrspace.h>
 
- #include <asm/bootinfo.h>
 
-@@ -523,12 +524,62 @@ static void __init arch_mem_init(char **
 
- 	}
 
- 
- 	bootmem_init();
 
-+#ifdef CONFIG_KEXEC
 
-+	if (crashk_res.start != crashk_res.end)
 
-+		reserve_bootmem(crashk_res.start,
 
-+			crashk_res.end - crashk_res.start + 1,
 
-+			BOOTMEM_DEFAULT);
 
-+#endif
 
- 	device_tree_init();
 
- 	sparse_init();
 
- 	plat_swiotlb_setup();
 
- 	paging_init();
 
- }
 
- 
-+#ifdef CONFIG_KEXEC
 
-+static inline unsigned long long get_total_mem(void)
 
-+{
 
-+	unsigned long long total;
 
-+	total = max_pfn - min_low_pfn;
 
-+	return total << PAGE_SHIFT;
 
-+}
 
-+
 
-+static void __init mips_parse_crashkernel(void)
 
-+{
 
-+	unsigned long long total_mem;
 
-+	unsigned long long crash_size, crash_base;
 
-+	int ret;
 
-+
 
-+	total_mem = get_total_mem();
 
-+	ret = parse_crashkernel(boot_command_line, total_mem,
 
-+			&crash_size, &crash_base);
 
-+	if (ret != 0 || crash_size <= 0)
 
-+		return;
 
-+
 
-+	crashk_res.start = crash_base;
 
-+	crashk_res.end   = crash_base + crash_size - 1;
 
-+}
 
-+static void __init request_crashkernel(struct resource *res)
 
-+{
 
-+	int ret;
 
-+
 
-+	ret = request_resource(res, &crashk_res);
 
-+	if (!ret)
 
-+		printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
 
-+			"for crashkernel\n",
 
-+			(unsigned long)((crashk_res.end -
 
-+				crashk_res.start + 1) >> 20),
 
-+			(unsigned long)(crashk_res.start  >> 20));
 
-+}
 
-+#else
 
-+static void __init mips_parse_crashkernel(void)
 
-+{
 
-+}
 
-+static void __init request_crashkernel(struct resource *res)
 
-+{
 
-+}
 
-+#endif
 
-+
 
- static void __init resource_init(void)
 
- {
 
- 	int i;
 
-@@ -544,6 +595,8 @@ static void __init resource_init(void)
 
- 	/*
 
- 	 * Request address space for all standard RAM.
 
- 	 */
 
-+	mips_parse_crashkernel();
 
-+
 
- 	for (i = 0; i < boot_mem_map.nr_map; i++) {
 
- 		struct resource *res;
 
- 		unsigned long start, end;
 
-@@ -580,6 +633,7 @@ static void __init resource_init(void)
 
- 		 */
 
- 		request_resource(res, &code_resource);
 
- 		request_resource(res, &data_resource);
 
-+		request_crashkernel(res);
 
- 	}
 
- }
 
- 
---- a/arch/mips/kernel/smp.c
 
-+++ b/arch/mips/kernel/smp.c
 
-@@ -433,3 +433,21 @@ void flush_tlb_one(unsigned long vaddr)
 
- 
- EXPORT_SYMBOL(flush_tlb_page);
 
- EXPORT_SYMBOL(flush_tlb_one);
 
-+
 
-+#if defined(CONFIG_KEXEC)
 
-+void (*dump_ipi_function_ptr)(void *) = NULL;
 
-+void dump_send_ipi(void (*dump_ipi_callback)(void *))
 
-+{
 
-+	int i;
 
-+	int cpu = smp_processor_id();
 
-+
 
-+	dump_ipi_function_ptr = dump_ipi_callback;
 
-+	smp_mb();
 
-+	for_each_online_cpu(i)
 
-+		if (i != cpu)
 
-+			core_send_ipi(i, SMP_DUMP);
 
-+
 
-+}
 
-+EXPORT_SYMBOL(dump_send_ipi);
 
-+#endif
 
-+
 
---- a/arch/mips/include/asm/kexec.h
 
-+++ b/arch/mips/include/asm/kexec.h
 
-@@ -9,22 +9,45 @@
 
- #ifndef _MIPS_KEXEC
 
- # define _MIPS_KEXEC
 
- 
-+#include <asm/stacktrace.h>
 
-+
 
-+extern unsigned long long elfcorehdr_addr;
 
-+
 
- /* Maximum physical address we can use pages from */
 
- #define KEXEC_SOURCE_MEMORY_LIMIT (0x20000000)
 
- /* Maximum address we can reach in physical address mode */
 
- #define KEXEC_DESTINATION_MEMORY_LIMIT (0x20000000)
 
-  /* Maximum address we can use for the control code buffer */
 
- #define KEXEC_CONTROL_MEMORY_LIMIT (0x20000000)
 
--
 
--#define KEXEC_CONTROL_PAGE_SIZE 4096
 
-+/* Reserve 3*4096 bytes for board-specific info */
 
-+#define KEXEC_CONTROL_PAGE_SIZE (4096 + 3*4096)
 
- 
- /* The native architecture */
 
- #define KEXEC_ARCH KEXEC_ARCH_MIPS
 
-+#define MAX_NOTE_BYTES 1024
 
- 
- static inline void crash_setup_regs(struct pt_regs *newregs,
 
--				    struct pt_regs *oldregs)
 
-+					struct pt_regs *oldregs)
 
- {
 
--	/* Dummy implementation for now */
 
-+	if (oldregs)
 
-+		memcpy(newregs, oldregs, sizeof(*newregs));
 
-+	else
 
-+		prepare_frametrace(newregs);
 
- }
 
- 
-+#ifdef CONFIG_KEXEC
 
-+struct kimage;
 
-+extern unsigned long kexec_args[4];
 
-+extern int (*_machine_kexec_prepare)(struct kimage *);
 
-+extern void (*_machine_kexec_shutdown)(void);
 
-+extern void (*_machine_crash_shutdown)(struct pt_regs *regs);
 
-+extern void default_machine_crash_shutdown(struct pt_regs *regs);
 
-+#ifdef CONFIG_SMP
 
-+extern const unsigned char kexec_smp_wait[];
 
-+extern unsigned long secondary_kexec_args[4];
 
-+extern void (*relocated_kexec_smp_wait) (void *);
 
-+extern atomic_t kexec_ready_to_reboot;
 
-+#endif
 
-+#endif
 
-+
 
- #endif /* !_MIPS_KEXEC */
 
---- a/arch/mips/include/asm/smp.h
 
-+++ b/arch/mips/include/asm/smp.h
 
-@@ -40,6 +40,8 @@ extern int __cpu_logical_map[NR_CPUS];
 
- #define SMP_CALL_FUNCTION	0x2
 
- /* Octeon - Tell another core to flush its icache */
 
- #define SMP_ICACHE_FLUSH	0x4
 
-+/* Used by kexec crashdump to save all cpu's state */
 
-+#define SMP_DUMP		0x8
 
- 
- extern volatile cpumask_t cpu_callin_map;
 
- 
-@@ -91,4 +93,9 @@ static inline void arch_send_call_functi
 
- 	mp_ops->send_ipi_mask(mask, SMP_CALL_FUNCTION);
 
- }
 
- 
-+extern void core_send_ipi(int cpu, unsigned int action);
 
-+#if defined(CONFIG_KEXEC)
 
-+extern void (*dump_ipi_function_ptr)(void *);
 
-+void dump_send_ipi(void (*dump_ipi_callback)(void *));
 
-+#endif
 
- #endif /* __ASM_SMP_H */

+ 0 - 157
target/linux/generic/patches-3.3/331-mips-kexec-enhanche-the-support.patch
View File 

@@ -1,157 +0,0 @@
 
-From 03cd81fbca6b91317ec1a7b3b3c09fb8d08f83a6 Mon Sep 17 00:00:00 2001
 
-From: Wu Zhangjin <[email protected]>
 
-Date: Tue, 11 Jan 2011 18:42:08 +0000
 
-Subject: MIPS: Kexec: Enhance the support
 
-
 
-Changes:
 
-  o Print more information in machine_kexec() for debugging
 
-    E.g. with this information, the kexec_start_address has been found
 
-    it was wrong with 64bit kernel / o32 kexec-tools. Which must be
 
-    fixed later.
 
-  o Link relocate_kernel.S to a section for future extension
 
-    This allows more functions can be added for the kexec relocation
 
-    part even written in C. to add code into that section, you just need
 
-    to mark your function or data with __kexec or
 
-    __attribute__((__section__(".__kexec.relocate")))
 
-
 
-TODO:
 
-
 
-1. Make 64bit kernel / o32|n32|64 kexec-tools works
 
-
 
-Fix the user-space kexec-tools, seems the tool only work for 32bit
 
-machine. So, we need to add 64bit support for it. The address of the
 
-entry point(kexec_start_address) is wrong and make the "kexec -e" fail.
 
-the real entry point must be read from the new kernel image by the
 
-user-space kexec-tools, otherwise, it will not work.  The above 64bit
 
-support tested is 64bit kernel with o32 user-space kexec-tools. The root
 
-cause may be the different definition of virt_to_phys() and
 
-phys_to_virt() in the kexec-tools and kernel space for 64bit system /
 
-o32 kernel.
 
-
 
-Ref: http://www.linux-mips.org/archives/linux-mips/2009-08/msg00149.html
 
-
 
-2. Pass the arguments from kexec-tools to the new kernel image
 
-
 
-Please refer to: "MIPS: Loongson: Kexec: Pass parameters to new kernel"
 
-
 
-Signed-off-by: Wu Zhangjin <[email protected]>
 
----
 
---- a/arch/mips/include/asm/kexec.h
 
-+++ b/arch/mips/include/asm/kexec.h
 
-@@ -36,6 +36,16 @@ static inline void crash_setup_regs(stru
 
- }
 
- 
- #ifdef CONFIG_KEXEC
 
-+
 
-+#define __kexec __attribute__((__section__(".__kexec.relocate")))
 
-+
 
-+/* The linker tells us where the relocate_new_kernel part is. */
 
-+extern const unsigned char __start___kexec_relocate;
 
-+extern const unsigned char __end___kexec_relocate;
 
-+
 
-+extern unsigned long kexec_start_address;
 
-+extern unsigned long kexec_indirection_page;
 
-+
 
- struct kimage;
 
- extern unsigned long kexec_args[4];
 
- extern int (*_machine_kexec_prepare)(struct kimage *);
 
---- a/arch/mips/kernel/machine_kexec.c
 
-+++ b/arch/mips/kernel/machine_kexec.c
 
-@@ -14,10 +14,6 @@
 
- #include <asm/page.h>
 
- 
- extern const unsigned char relocate_new_kernel[];
 
--extern const size_t relocate_new_kernel_size;
 
--
 
--extern unsigned long kexec_start_address;
 
--extern unsigned long kexec_indirection_page;
 
- 
- int (*_machine_kexec_prepare)(struct kimage *) = NULL;
 
- void (*_machine_kexec_shutdown)(void) = NULL;
 
-@@ -61,21 +57,34 @@ typedef void (*noretfun_t)(void) __attri
 
- void
 
- machine_kexec(struct kimage *image)
 
- {
 
-+	unsigned long kexec_relocate_size;
 
- 	unsigned long reboot_code_buffer;
 
- 	unsigned long entry;
 
- 	unsigned long *ptr;
 
- 
-+	kexec_relocate_size = (unsigned long)(&__end___kexec_relocate) -
 
-+		(unsigned long)(&__start___kexec_relocate);
 
-+	pr_info("kexec_relocate_size = %lu\n", kexec_relocate_size);
 
-+
 
- 	reboot_code_buffer =
 
- 	  (unsigned long)page_address(image->control_code_page);
 
-+	pr_info("reboot_code_buffer = %p\n", (void *)reboot_code_buffer);
 
- 
- 	kexec_start_address =
 
- 	  (unsigned long) phys_to_virt(image->start);
 
-+	pr_info("kexec_start_address(entry point of new kernel) = %p\n",
 
-+			(void *)kexec_start_address);
 
- 
- 	kexec_indirection_page =
 
- 		(unsigned long) phys_to_virt(image->head & PAGE_MASK);
 
-+	pr_info("kexec_indirection_page = %p\n",
 
-+			(void *)kexec_indirection_page);
 
- 
--	memcpy((void*)reboot_code_buffer, relocate_new_kernel,
 
--	       relocate_new_kernel_size);
 
-+	memcpy((void *)reboot_code_buffer, &__start___kexec_relocate,
 
-+	       kexec_relocate_size);
 
-+
 
-+	pr_info("Copy kexec_relocate section from %p to reboot_code_buffer: %p\n",
 
-+			&__start___kexec_relocate, (void *)reboot_code_buffer);
 
- 
- 	/*
 
- 	 * The generic kexec code builds a page list with physical
 
-@@ -96,8 +105,8 @@ machine_kexec(struct kimage *image)
 
- 	 */
 
- 	local_irq_disable();
 
- 
--	printk("Will call new kernel at %08lx\n", image->start);
 
--	printk("Bye ...\n");
 
-+	pr_info("Will call new kernel at %p\n", (void *)kexec_start_address);
 
-+	pr_info("Bye ...\n");
 
- 	__flush_cache_all();
 
- #ifdef CONFIG_SMP
 
- 	/* All secondary cpus now may jump to kexec_wait cycle */
 
-@@ -108,4 +117,3 @@ machine_kexec(struct kimage *image)
 
- #endif
 
- 	((noretfun_t) reboot_code_buffer)();
 
- }
 
--
 
---- a/arch/mips/kernel/relocate_kernel.S
 
-+++ b/arch/mips/kernel/relocate_kernel.S
 
-@@ -14,6 +14,8 @@
 
- #include <asm/stackframe.h>
 
- #include <asm/addrspace.h>
 
- 
-+	.section	.kexec.relocate, "ax"
 
-+
 
- LEAF(relocate_new_kernel)
 
- 	PTR_L a0,	arg0
 
- 	PTR_L a1,	arg1
 
-@@ -155,9 +157,3 @@ EXPORT(kexec_start_address)
 
- EXPORT(kexec_indirection_page)
 
- 	PTR		0
 
- 	.size		kexec_indirection_page, PTRSIZE
 
--
 
--relocate_new_kernel_end:
 
--
 
--EXPORT(relocate_new_kernel_size)
 
--	PTR		relocate_new_kernel_end - relocate_new_kernel
 
--	.size		relocate_new_kernel_size, PTRSIZE
 
---- a/arch/mips/kernel/vmlinux.lds.S
 
-+++ b/arch/mips/kernel/vmlinux.lds.S
 
-@@ -50,6 +50,10 @@ SECTIONS
 
- 		*(.text.*)
 
- 		*(.fixup)
 
- 		*(.gnu.warning)
 
-+		__start___kexec_relocate = .;
 
-+		KEEP(*(.kexec.relocate))
 
-+		KEEP(*(.__kexec.relocate))
 
-+		__end___kexec_relocate = .;
 
- 	} :text = 0
 
- 	_etext = .;	/* End of text section */
 
-

+ 0 - 52
target/linux/generic/patches-3.3/332-mips-kexec-init-the-arguments-for-the-new-kernel-image.patch
View File 

@@ -1,52 +0,0 @@
 
-From 49d07a29653b1f2c6ae273b3d8fe93d981f43004 Mon Sep 17 00:00:00 2001
 
-From: Wu Zhangjin <[email protected]>
 
-Date: Wed, 12 Jan 2011 20:59:32 +0000
 
-Subject: MIPS: Kexec: Init the arguments for the new kernel image
 
-
 
-Whenever the kexec-tools pass the command lines to the new kernel image,
 
-init the arguments as the ones for the 1st kernel image. This fixed the
 
-booting failure of Kexec on YeeLoong.
 
-
 
-Signed-off-by: Wu Zhangjin <[email protected]>
 
----
 
---- a/arch/mips/kernel/machine_kexec.c
 
-+++ b/arch/mips/kernel/machine_kexec.c
 
-@@ -10,6 +10,7 @@
 
- #include <linux/mm.h>
 
- #include <linux/delay.h>
 
- 
-+#include <asm/bootinfo.h>
 
- #include <asm/cacheflush.h>
 
- #include <asm/page.h>
 
- 
-@@ -23,9 +24,30 @@ void (*relocated_kexec_smp_wait) (void *
 
- atomic_t kexec_ready_to_reboot = ATOMIC_INIT(0);
 
- #endif
 
- 
-+static void machine_kexec_init_args(void)
 
-+{
 
-+	kexec_args[0] = fw_arg0;
 
-+	kexec_args[1] = fw_arg1;
 
-+	kexec_args[2] = fw_arg2;
 
-+	kexec_args[3] = fw_arg3;
 
-+
 
-+	pr_info("kexec_args[0] (argc): %lu\n", kexec_args[0]);
 
-+	pr_info("kexec_args[1] (argv): %p\n", (void *)kexec_args[1]);
 
-+	pr_info("kexec_args[2] (env ): %p\n", (void *)kexec_args[2]);
 
-+	pr_info("kexec_args[3] (desc): %p\n", (void *)kexec_args[3]);
 
-+}
 
-+
 
- int
 
- machine_kexec_prepare(struct kimage *kimage)
 
- {
 
-+	/*
 
-+	 * Whenever arguments passed from kexec-tools, Init the arguments as
 
-+	 * the original ones to avoid booting failure.
 
-+	 *
 
-+	 * This can be overrided by _machine_kexec_prepare().
 
-+	 */
 
-+	machine_kexec_init_args();
 
-+
 
- 	if (_machine_kexec_prepare)
 
- 		return _machine_kexec_prepare(kimage);
 
- 	return 0;

+ 0 - 88
target/linux/generic/patches-3.3/333-mips-kexec-get-kernel-parameters-from-kexec-tools.patch
View File 

@@ -1,88 +0,0 @@
 
-From 240c76841b26f1b09aaced33414ee1d08b6454cf Mon Sep 17 00:00:00 2001
 
-From: Wu Zhangjin <[email protected]>
 
-Date: Sat, 15 Jan 2011 12:46:03 +0000
 
-Subject: MIPS: Get kernel parameters from kexec-tools
 
-
 
-Before, we simply use the command lines from the original bootloader,
 
-but it is not convenient. Now, we accept the kernel parameters from the
 
---command-line or --append option of the kexec-tools.  But If not
 
---command-line or --apend option indicated, will fall back to use the
 
-ones from the original bootloader.
 
-
 
-Signed-off-by: Wu Zhangjin <[email protected]>
 
----
 
---- a/arch/mips/kernel/machine_kexec.c
 
-+++ b/arch/mips/kernel/machine_kexec.c
 
-@@ -13,6 +13,7 @@
 
- #include <asm/bootinfo.h>
 
- #include <asm/cacheflush.h>
 
- #include <asm/page.h>
 
-+#include <asm/uaccess.h>
 
- 
- extern const unsigned char relocate_new_kernel[];
 
- 
-@@ -37,6 +38,56 @@ static void machine_kexec_init_args(void
 
- 	pr_info("kexec_args[3] (desc): %p\n", (void *)kexec_args[3]);
 
- }
 
- 
-+#define ARGV_MAX_ARGS (COMMAND_LINE_SIZE / 15)
 
-+
 
-+int machine_kexec_pass_args(struct kimage *image)
 
-+{
 
-+	int i, argc = 0;
 
-+	char *bootloader = "kexec";
 
-+	int *kexec_argv = (int *)kexec_args[1];
 
-+
 
-+	for (i = 0; i < image->nr_segments; i++) {
 
-+		if (!strncmp(bootloader, (char *)image->segment[i].buf,
 
-+				strlen(bootloader))) {
 
-+			/*
 
-+			 * convert command line string to array
 
-+			 * of parameters (as bootloader does).
 
-+			 */
 
-+			/*
 
-+			 * Note: we do treat the 1st string "kexec" as an
 
-+			 * argument ;-) so, argc here is 1.
 
-+			 */
 
-+			char *str = (char *)image->segment[i].buf;
 
-+			char *ptr = strchr(str, ' ');
 
-+			char *kbuf = (char *)kexec_argv[0];
 
-+			/* Whenever --command-line or --append used, "kexec" is copied */
 
-+			argc = 1;
 
-+			/* Parse the offset */
 
-+			while (ptr && (ARGV_MAX_ARGS > argc)) {
 
-+				*ptr = '\0';
 
-+				if (ptr[1] != ' ' && ptr[1] != '\0') {
 
-+					int offt = (int)(ptr - str + 1);
 
-+					kexec_argv[argc] = (int)kbuf + offt;
 
-+					argc++;
 
-+				}
 
-+				ptr = strchr(ptr + 1, ' ');
 
-+			}
 
-+			if (argc > 1) {
 
-+				/* Copy to kernel space */
 
-+				copy_from_user(kbuf, (char *)image->segment[i].buf, image->segment[i].bufsz);
 
-+				fw_arg0 = kexec_args[0] = argc;
 
-+			}
 
-+			break;
 
-+		}
 
-+	}
 
-+
 
-+	pr_info("argc = %lu\n", kexec_args[0]);
 
-+	for (i = 0; i < kexec_args[0]; i++)
 
-+		pr_info("argv[%d] = %p, %s\n", i, (char *)kexec_argv[i], (char *)kexec_argv[i]);
 
-+
 
-+	return 0;
 
-+}
 
-+
 
- int
 
- machine_kexec_prepare(struct kimage *kimage)
 
- {
 
-@@ -47,6 +98,7 @@ machine_kexec_prepare(struct kimage *kim
 
- 	 * This can be overrided by _machine_kexec_prepare().
 
- 	 */
 
- 	machine_kexec_init_args();
 
-+	machine_kexec_pass_args(kimage);
 
- 
- 	if (_machine_kexec_prepare)
 
- 		return _machine_kexec_prepare(kimage);

+ 0 - 83
target/linux/generic/patches-3.3/334-mips-fix-compiling-failure-of-relocate_kernel.patch
View File 

@@ -1,83 +0,0 @@
 
-From 4aded085fa0057a9a1e1dcec631f950307360c1f Mon Sep 17 00:00:00 2001
 
-From: Wu Zhangjin <[email protected]>
 
-Date: Tue, 11 Jan 2011 13:46:19 +0000
 
-Subject: MIPS: Fix compiling failure of relocate_kernel.S
 
-
 
-The following errors is fixed with the help of <asm/asm_nosec.h>. for
 
-this file need to put different symbols in the same section, the
 
-original LEAF, NESTED and EXPORT (without explicit section indication)
 
-must be used, <asm/asm_nosec.h> does it.
 
-
 
-arch/mips/kernel/relocate_kernel.S: Assembler messages:
 
-arch/mips/kernel/relocate_kernel.S:162: Error: operation combines symbols in different segments
 
-
 
-Signed-off-by: Wu Zhangjin <[email protected]>
 
----
 
-(limited to 'arch/mips/kernel')
 
-
 
---- a/arch/mips/kernel/relocate_kernel.S
 
-+++ b/arch/mips/kernel/relocate_kernel.S
 
-@@ -7,6 +7,7 @@
 
-  */
 
- 
- #include <asm/asm.h>
 
-+#include <asm/asm_nosec.h>
 
- #include <asm/asmmacro.h>
 
- #include <asm/regdef.h>
 
- #include <asm/page.h>
 
---- /dev/null
 
-+++ b/arch/mips/include/asm/asm_nosec.h
 
-@@ -0,0 +1,53 @@
 
-+/*
 
-+ * This file is subject to the terms and conditions of the GNU General Public
 
-+ * License.  See the file "COPYING" in the main directory of this archive
 
-+ * for more details.
 
-+ *
 
-+ * Copyright (C) 1995, 1996, 1997, 1999, 2001 by Ralf Baechle
 
-+ * Copyright (C) 1999 by Silicon Graphics, Inc.
 
-+ * Copyright (C) 2001 MIPS Technologies, Inc.
 
-+ * Copyright (C) 2002  Maciej W. Rozycki
 
-+ * Copyright (C) 2010  Wu Zhangjin <[email protected]>
 
-+ *
 
-+ * Derive from <asm/asm.h>
 
-+ *
 
-+ * Override the macros without -ffunction-sections and -fdata-sections support.
 
-+ * If several functions or data must be put in the same section, please include
 
-+ * this header file after the <asm/asm.h> to override the generic definition.
 
-+ */
 
-+
 
-+#ifndef __ASM_ASM_NOSEC_H
 
-+#define __ASM_ASM_NOSEC_H
 
-+
 
-+#undef LEAF
 
-+#undef NESTED
 
-+#undef EXPORT
 
-+
 
-+/*
 
-+ * LEAF - declare leaf routine
 
-+ */
 
-+#define	LEAF(symbol)                                    \
 
-+		.globl	symbol;                         \
 
-+		.align	2;                              \
 
-+		.type	symbol, @function;              \
 
-+		.ent	symbol, 0;                      \
 
-+symbol:		.frame	sp, 0, ra
 
-+
 
-+/*
 
-+ * NESTED - declare nested routine entry point
 
-+ */
 
-+#define	NESTED(symbol, framesize, rpc)                  \
 
-+		.globl	symbol;                         \
 
-+		.align	2;                              \
 
-+		.type	symbol, @function;              \
 
-+		.ent	symbol, 0;                       \
 
-+symbol:		.frame	sp, framesize, rpc
 
-+
 
-+/*
 
-+ * EXPORT - export definition of symbol
 
-+ */
 
-+#define EXPORT(symbol)					\
 
-+		.globl	symbol;                         \
 
-+symbol:
 
-+
 
-+#endif /* __ASM_ASM_NOSEC_H */

+ 0 - 186
target/linux/generic/patches-3.3/335-mips-kexec-cleanup-kexec-tools-parameter-handling.patch
View File 

@@ -1,186 +0,0 @@
 
---- a/arch/mips/kernel/machine_kexec.c
 
-+++ b/arch/mips/kernel/machine_kexec.c
 
-@@ -25,67 +25,104 @@ void (*relocated_kexec_smp_wait) (void *
 
- atomic_t kexec_ready_to_reboot = ATOMIC_INIT(0);
 
- #endif
 
- 
--static void machine_kexec_init_args(void)
 
-+#define KEXEC_MIPS_ARGV_BUF_SIZE	COMMAND_LINE_SIZE
 
-+#define KEXEC_MIPS_ARGV_MAX_ARGS	(COMMAND_LINE_SIZE / 15)
 
-+
 
-+char kexec_argv_buf[KEXEC_MIPS_ARGV_BUF_SIZE] __kexec;
 
-+char *kexec_argv[KEXEC_MIPS_ARGV_MAX_ARGS] __kexec;
 
-+
 
-+static void
 
-+machine_kexec_print_args(void)
 
- {
 
--	kexec_args[0] = fw_arg0;
 
--	kexec_args[1] = fw_arg1;
 
--	kexec_args[2] = fw_arg2;
 
--	kexec_args[3] = fw_arg3;
 
-+	int i;
 
- 
- 	pr_info("kexec_args[0] (argc): %lu\n", kexec_args[0]);
 
- 	pr_info("kexec_args[1] (argv): %p\n", (void *)kexec_args[1]);
 
- 	pr_info("kexec_args[2] (env ): %p\n", (void *)kexec_args[2]);
 
- 	pr_info("kexec_args[3] (desc): %p\n", (void *)kexec_args[3]);
 
--}
 
- 
--#define ARGV_MAX_ARGS (COMMAND_LINE_SIZE / 15)
 
-+	for (i = 0; i < kexec_args[0]; i++)
 
-+		pr_info("kexec_argv[%d] = %p, %s\n", i,
 
-+			(char *)kexec_argv[i], (char *)kexec_argv[i]);
 
-+}
 
- 
--int machine_kexec_pass_args(struct kimage *image)
 
-+static void
 
-+machine_kexec_init_argv(struct kimage *image)
 
- {
 
--	int i, argc = 0;
 
--	char *bootloader = "kexec";
 
--	int *kexec_argv = (int *)kexec_args[1];
 
-+	void __user *buf = NULL;
 
-+	size_t bufsz;
 
-+	size_t size;
 
-+	int i;
 
- 
-+	bufsz = 0;
 
- 	for (i = 0; i < image->nr_segments; i++) {
 
--		if (!strncmp(bootloader, (char *)image->segment[i].buf,
 
--				strlen(bootloader))) {
 
--			/*
 
--			 * convert command line string to array
 
--			 * of parameters (as bootloader does).
 
--			 */
 
--			/*
 
--			 * Note: we do treat the 1st string "kexec" as an
 
--			 * argument ;-) so, argc here is 1.
 
--			 */
 
--			char *str = (char *)image->segment[i].buf;
 
--			char *ptr = strchr(str, ' ');
 
--			char *kbuf = (char *)kexec_argv[0];
 
--			/* Whenever --command-line or --append used, "kexec" is copied */
 
--			argc = 1;
 
--			/* Parse the offset */
 
--			while (ptr && (ARGV_MAX_ARGS > argc)) {
 
--				*ptr = '\0';
 
--				if (ptr[1] != ' ' && ptr[1] != '\0') {
 
--					int offt = (int)(ptr - str + 1);
 
--					kexec_argv[argc] = (int)kbuf + offt;
 
--					argc++;
 
--				}
 
--				ptr = strchr(ptr + 1, ' ');
 
--			}
 
--			if (argc > 1) {
 
--				/* Copy to kernel space */
 
--				copy_from_user(kbuf, (char *)image->segment[i].buf, image->segment[i].bufsz);
 
--				fw_arg0 = kexec_args[0] = argc;
 
--			}
 
--			break;
 
-+		struct kexec_segment *seg;
 
-+
 
-+		seg = &image->segment[i];
 
-+		if (seg->bufsz < 6)
 
-+			continue;
 
-+
 
-+		if (strncmp((char *) seg->buf, "kexec", 5))
 
-+			continue;
 
-+
 
-+		/* don't copy "kexec" */
 
-+		buf = seg->buf + 5;
 
-+		bufsz = seg->bufsz - 5;
 
-+		break;
 
-+	}
 
-+
 
-+	if (!buf)
 
-+		return;
 
-+
 
-+	size = KEXEC_MIPS_ARGV_BUF_SIZE - 1;
 
-+	size = min(size, bufsz);
 
-+	if (size < bufsz)
 
-+		pr_warn("kexec command line truncated to %zd bytes\n", size);
 
-+
 
-+	/* Copy to kernel space */
 
-+	copy_from_user(kexec_argv_buf, buf, size);
 
-+}
 
-+
 
-+static void
 
-+machine_kexec_parse_argv(struct kimage *image)
 
-+{
 
-+	char *reboot_code_buffer;
 
-+	int reloc_delta;
 
-+	char *ptr;
 
-+	int argc;
 
-+	int i;
 
-+
 
-+	ptr = kexec_argv_buf;
 
-+	argc = 0;
 
-+
 
-+	/*
 
-+	 * convert command line string to array of parameters
 
-+	 * (as bootloader does).
 
-+	 */
 
-+	while (ptr && *ptr && (KEXEC_MIPS_ARGV_MAX_ARGS > argc)) {
 
-+		if (*ptr == ' ') {
 
-+			*ptr++ = '\0';
 
-+			continue;
 
- 		}
 
-+
 
-+		kexec_argv[argc++] = ptr;
 
-+		ptr = strchr(ptr, ' ');
 
- 	}
 
- 
--	pr_info("argc = %lu\n", kexec_args[0]);
 
--	for (i = 0; i < kexec_args[0]; i++)
 
--		pr_info("argv[%d] = %p, %s\n", i, (char *)kexec_argv[i], (char *)kexec_argv[i]);
 
-+	if (!argc)
 
-+		return;
 
- 
--	return 0;
 
-+	kexec_args[0] = argc;
 
-+	kexec_args[1] = (unsigned long)kexec_argv;
 
-+	kexec_args[2] = 0;
 
-+	kexec_args[3] = 0;
 
-+
 
-+	reboot_code_buffer = page_address(image->control_code_page);
 
-+	reloc_delta = reboot_code_buffer - (char *) &__start___kexec_relocate;
 
-+
 
-+	kexec_args[1] += reloc_delta;
 
-+	for (i = 0; i < argc; i++)
 
-+		kexec_argv[i] += reloc_delta;
 
- }
 
- 
- int
 
-@@ -97,8 +134,14 @@ machine_kexec_prepare(struct kimage *kim
 
- 	 *
 
- 	 * This can be overrided by _machine_kexec_prepare().
 
- 	 */
 
--	machine_kexec_init_args();
 
--	machine_kexec_pass_args(kimage);
 
-+
 
-+	kexec_args[0] = fw_arg0;
 
-+	kexec_args[1] = fw_arg1;
 
-+	kexec_args[2] = fw_arg2;
 
-+	kexec_args[3] = fw_arg3;
 
-+
 
-+	machine_kexec_init_argv(kimage);
 
-+	machine_kexec_parse_argv(kimage);
 
- 
- 	if (_machine_kexec_prepare)
 
- 		return _machine_kexec_prepare(kimage);
 
-@@ -154,11 +197,13 @@ machine_kexec(struct kimage *image)
 
- 	pr_info("kexec_indirection_page = %p\n",
 
- 			(void *)kexec_indirection_page);
 
- 
-+	pr_info("Copy kexec_relocate section from %p to reboot_code_buffer: %p\n",
 
-+			&__start___kexec_relocate, (void *)reboot_code_buffer);
 
-+
 
- 	memcpy((void *)reboot_code_buffer, &__start___kexec_relocate,
 
- 	       kexec_relocate_size);
 
- 
--	pr_info("Copy kexec_relocate section from %p to reboot_code_buffer: %p\n",
 
--			&__start___kexec_relocate, (void *)reboot_code_buffer);
 
-+	machine_kexec_print_args();
 
- 
- 	/*
 
- 	 * The generic kexec code builds a page list with physical

+ 0 - 20
target/linux/generic/patches-3.3/340-module_alloc_size_check.patch
View File 

@@ -1,20 +0,0 @@
 
---- a/kernel/module.c
 
-+++ b/kernel/module.c
 
-@@ -2322,12 +2322,15 @@ static void dynamic_debug_remove(struct
 
- 
- void * __weak module_alloc(unsigned long size)
 
- {
 
--	return size == 0 ? NULL : vmalloc_exec(size);
 
-+	return vmalloc_exec(size);
 
- }
 
- 
- static void *module_alloc_update_bounds(unsigned long size)
 
- {
 
--	void *ret = module_alloc(size);
 
-+	void *ret = NULL;
 
-+
 
-+	if (size)
 
-+		ret = module_alloc(size);
 
- 
- 	if (ret) {
 
- 		mutex_lock(&module_mutex);

+ 0 - 327
target/linux/generic/patches-3.3/400-rootfs_split.patch
View File 

@@ -1,327 +0,0 @@
 
---- a/drivers/mtd/Kconfig
 
-+++ b/drivers/mtd/Kconfig
 
-@@ -23,6 +23,14 @@ config MTD_TESTS
 
- 	  WARNING: some of the tests will ERASE entire MTD device which they
 
- 	  test. Do not use these tests unless you really know what you do.
 
- 
-+config MTD_ROOTFS_ROOT_DEV
 
-+	bool "Automatically set 'rootfs' partition to be root filesystem"
 
-+	default y
 
-+
 
-+config MTD_ROOTFS_SPLIT
 
-+	bool "Automatically split 'rootfs' partition for squashfs"
 
-+	default y
 
-+
 
- config MTD_REDBOOT_PARTS
 
- 	tristate "RedBoot partition table parsing"
 
- 	---help---
 
---- a/drivers/mtd/mtdpart.c
 
-+++ b/drivers/mtd/mtdpart.c
 
-@@ -29,6 +29,8 @@
 
- #include <linux/kmod.h>
 
- #include <linux/mtd/mtd.h>
 
- #include <linux/mtd/partitions.h>
 
-+#include <linux/root_dev.h>
 
-+#include <linux/magic.h>
 
- #include <linux/err.h>
 
- 
- #include "mtdcore.h"
 
-@@ -50,7 +52,7 @@ struct mtd_part {
 
-  * the pointer to that structure with this macro.
 
-  */
 
- #define PART(x)  ((struct mtd_part *)(x))
 
--
 
-+#define IS_PART(mtd) (mtd->read == part_read)
 
- 
- /*
 
-  * MTD methods which simply translate the effective address and pass through
 
-@@ -643,6 +645,155 @@ int mtd_del_partition(struct mtd_info *m
 
- }
 
- EXPORT_SYMBOL_GPL(mtd_del_partition);
 
- 
-+#ifdef CONFIG_MTD_ROOTFS_SPLIT
 
-+#define ROOTFS_SPLIT_NAME "rootfs_data"
 
-+#define ROOTFS_REMOVED_NAME "<removed>"
 
-+
 
-+struct squashfs_super_block {
 
-+	__le32 s_magic;
 
-+	__le32 pad0[9];
 
-+	__le64 bytes_used;
 
-+};
 
-+
 
-+
 
-+static int split_squashfs(struct mtd_info *master, int offset, int *split_offset)
 
-+{
 
-+	struct squashfs_super_block sb;
 
-+	int len, ret;
 
-+
 
-+	ret = master->read(master, offset, sizeof(sb), &len, (void *) &sb);
 
-+	if (ret || (len != sizeof(sb))) {
 
-+		printk(KERN_ALERT "split_squashfs: error occured while reading "
 
-+			"from \"%s\"\n", master->name);
 
-+		return -EINVAL;
 
-+	}
 
-+
 
-+	if (SQUASHFS_MAGIC != le32_to_cpu(sb.s_magic) ) {
 
-+		printk(KERN_ALERT "split_squashfs: no squashfs found in \"%s\"\n",
 
-+			master->name);
 
-+		*split_offset = 0;
 
-+		return 0;
 
-+	}
 
-+
 
-+	if (le64_to_cpu((sb.bytes_used)) <= 0) {
 
-+		printk(KERN_ALERT "split_squashfs: squashfs is empty in \"%s\"\n",
 
-+			master->name);
 
-+		*split_offset = 0;
 
-+		return 0;
 
-+	}
 
-+
 
-+	len = (u32) le64_to_cpu(sb.bytes_used);
 
-+	len += (offset & 0x000fffff);
 
-+	len +=  (master->erasesize - 1);
 
-+	len &= ~(master->erasesize - 1);
 
-+	len -= (offset & 0x000fffff);
 
-+	*split_offset = offset + len;
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static int split_rootfs_data(struct mtd_info *master, struct mtd_info *rpart, const struct mtd_partition *part)
 
-+{
 
-+	struct mtd_partition *dpart;
 
-+	struct mtd_part *slave = NULL;
 
-+	struct mtd_part *spart;
 
-+	int ret, split_offset = 0;
 
-+
 
-+	spart = PART(rpart);
 
-+	ret = split_squashfs(master, spart->offset, &split_offset);
 
-+	if (ret)
 
-+		return ret;
 
-+
 
-+	if (split_offset <= 0)
 
-+		return 0;
 
-+
 
-+	dpart = kmalloc(sizeof(*part)+sizeof(ROOTFS_SPLIT_NAME)+1, GFP_KERNEL);
 
-+	if (dpart == NULL) {
 
-+		printk(KERN_INFO "split_squashfs: no memory for partition \"%s\"\n",
 
-+			ROOTFS_SPLIT_NAME);
 
-+		return -ENOMEM;
 
-+	}
 
-+
 
-+	memcpy(dpart, part, sizeof(*part));
 
-+	dpart->name = (unsigned char *)&dpart[1];
 
-+	strcpy(dpart->name, ROOTFS_SPLIT_NAME);
 
-+
 
-+	dpart->size = rpart->size - (split_offset - spart->offset);
 
-+	dpart->offset = split_offset;
 
-+
 
-+	if (dpart == NULL)
 
-+		return 1;
 
-+
 
-+	printk(KERN_INFO "mtd: partition \"%s\" created automatically, ofs=%llX, len=%llX \n",
 
-+		ROOTFS_SPLIT_NAME, dpart->offset, dpart->size);
 
-+
 
-+	slave = allocate_partition(master, dpart, 0, split_offset);
 
-+	if (IS_ERR(slave))
 
-+		return PTR_ERR(slave);
 
-+	mutex_lock(&mtd_partitions_mutex);
 
-+	list_add(&slave->list, &mtd_partitions);
 
-+	mutex_unlock(&mtd_partitions_mutex);
 
-+
 
-+	add_mtd_device(&slave->mtd);
 
-+
 
-+	rpart->split = &slave->mtd;
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static int refresh_rootfs_split(struct mtd_info *mtd)
 
-+{
 
-+	struct mtd_partition tpart;
 
-+	struct mtd_part *part;
 
-+	char *name;
 
-+	//int index = 0;
 
-+	int offset, size;
 
-+	int ret;
 
-+
 
-+	part = PART(mtd);
 
-+
 
-+	/* check for the new squashfs offset first */
 
-+	ret = split_squashfs(part->master, part->offset, &offset);
 
-+	if (ret)
 
-+		return ret;
 
-+
 
-+	if ((offset > 0) && !mtd->split) {
 
-+		printk(KERN_INFO "%s: creating new split partition for \"%s\"\n", __func__, mtd->name);
 
-+		/* if we don't have a rootfs split partition, create a new one */
 
-+		tpart.name = (char *) mtd->name;
 
-+		tpart.size = mtd->size;
 
-+		tpart.offset = part->offset;
 
-+
 
-+		return split_rootfs_data(part->master, &part->mtd, &tpart);
 
-+	} else if ((offset > 0) && mtd->split) {
 
-+		/* update the offsets of the existing partition */
 
-+		size = mtd->size + part->offset - offset;
 
-+
 
-+		part = PART(mtd->split);
 
-+		part->offset = offset;
 
-+		part->mtd.size = size;
 
-+		printk(KERN_INFO "%s: %s partition \"" ROOTFS_SPLIT_NAME "\", offset: 0x%06x (0x%06x)\n",
 
-+			__func__, (!strcmp(part->mtd.name, ROOTFS_SPLIT_NAME) ? "updating" : "creating"),
 
-+			(u32) part->offset, (u32) part->mtd.size);
 
-+		name = kmalloc(sizeof(ROOTFS_SPLIT_NAME) + 1, GFP_KERNEL);
 
-+		strcpy(name, ROOTFS_SPLIT_NAME);
 
-+		part->mtd.name = name;
 
-+	} else if ((offset <= 0) && mtd->split) {
 
-+		printk(KERN_INFO "%s: removing partition \"%s\"\n", __func__, mtd->split->name);
 
-+
 
-+		/* mark existing partition as removed */
 
-+		part = PART(mtd->split);
 
-+		name = kmalloc(sizeof(ROOTFS_SPLIT_NAME) + 1, GFP_KERNEL);
 
-+		strcpy(name, ROOTFS_REMOVED_NAME);
 
-+		part->mtd.name = name;
 
-+		part->offset = 0;
 
-+		part->mtd.size = 0;
 
-+	}
 
-+
 
-+	return 0;
 
-+}
 
-+#endif /* CONFIG_MTD_ROOTFS_SPLIT */
 
-+
 
- /*
 
-  * This function, given a master MTD object and a partition table, creates
 
-  * and registers slave MTD objects which are bound to the master according to
 
-@@ -659,6 +810,9 @@ int add_mtd_partitions(struct mtd_info *
 
- 	struct mtd_part *slave;
 
- 	uint64_t cur_offset = 0;
 
- 	int i;
 
-+#ifdef CONFIG_MTD_ROOTFS_SPLIT
 
-+	int ret;
 
-+#endif
 
- 
- 	printk(KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);
 
- 
-@@ -673,12 +827,53 @@ int add_mtd_partitions(struct mtd_info *
 
- 
- 		add_mtd_device(&slave->mtd);
 
- 
-+		if (!strcmp(parts[i].name, "rootfs")) {
 
-+#ifdef CONFIG_MTD_ROOTFS_ROOT_DEV
 
-+			if (ROOT_DEV == 0) {
 
-+				printk(KERN_NOTICE "mtd: partition \"rootfs\" "
 
-+					"set to be root filesystem\n");
 
-+				ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, slave->mtd.index);
 
-+			}
 
-+#endif
 
-+#ifdef CONFIG_MTD_ROOTFS_SPLIT
 
-+			ret = split_rootfs_data(master, &slave->mtd, &parts[i]);
 
-+			/* if (ret == 0)
 
-+			 * 	j++; */
 
-+#endif
 
-+		}
 
-+
 
- 		cur_offset = slave->offset + slave->mtd.size;
 
- 	}
 
- 
- 	return 0;
 
- }
 
- 
-+int mtd_device_refresh(struct mtd_info *mtd)
 
-+{
 
-+	int ret = 0;
 
-+
 
-+	if (IS_PART(mtd)) {
 
-+		struct mtd_part *part;
 
-+		struct mtd_info *master;
 
-+
 
-+		part = PART(mtd);
 
-+		master = part->master;
 
-+		if (master->refresh_device)
 
-+			ret = master->refresh_device(master);
 
-+	}
 
-+
 
-+	if (!ret && mtd->refresh_device)
 
-+		ret = mtd->refresh_device(mtd);
 
-+
 
-+#ifdef CONFIG_MTD_ROOTFS_SPLIT
 
-+	if (!ret && IS_PART(mtd) && !strcmp(mtd->name, "rootfs"))
 
-+		refresh_rootfs_split(mtd);
 
-+#endif
 
-+
 
-+	return 0;
 
-+}
 
-+EXPORT_SYMBOL_GPL(mtd_device_refresh);
 
-+
 
- static DEFINE_SPINLOCK(part_parser_lock);
 
- static LIST_HEAD(part_parsers);
 
- 
---- a/drivers/mtd/mtdchar.c
 
-+++ b/drivers/mtd/mtdchar.c
 
-@@ -1005,6 +1005,12 @@ static int mtdchar_ioctl(struct file *fi
 
- 		break;
 
- 	}
 
- 
-+	case MTDREFRESH:
 
-+	{
 
-+		ret = mtd_device_refresh(mtd);
 
-+		break;
 
-+	}
 
-+
 
- 	default:
 
- 		ret = -ENOTTY;
 
- 	}
 
---- a/include/linux/mtd/mtd.h
 
-+++ b/include/linux/mtd/mtd.h
 
-@@ -114,6 +114,7 @@ struct nand_ecclayout {
 
- 
- struct module;	/* only needed for owner field in mtd_info */
 
- 
-+struct mtd_info;
 
- struct mtd_info {
 
- 	u_char type;
 
- 	uint32_t flags;
 
-@@ -214,6 +215,9 @@ struct mtd_info {
 
- 	int (*block_markbad) (struct mtd_info *mtd, loff_t ofs);
 
- 	int (*suspend) (struct mtd_info *mtd);
 
- 	void (*resume) (struct mtd_info *mtd);
 
-+	int (*refresh_device)(struct mtd_info *mtd);
 
-+	struct mtd_info *split;
 
-+
 
- 	/*
 
- 	 * If the driver is something smart, like UBI, it may need to maintain
 
- 	 * its own reference counting. The below functions are only for driver.
 
-@@ -502,6 +506,7 @@ extern int mtd_device_parse_register(str
 
- 			      int defnr_parts);
 
- #define mtd_device_register(master, parts, nr_parts)	\
 
- 	mtd_device_parse_register(master, NULL, NULL, parts, nr_parts)
 
-+extern int mtd_device_refresh(struct mtd_info *master);
 
- extern int mtd_device_unregister(struct mtd_info *master);
 
- extern struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num);
 
- extern int __get_mtd_device(struct mtd_info *mtd);
 
---- a/include/linux/mtd/partitions.h
 
-+++ b/include/linux/mtd/partitions.h
 
-@@ -36,12 +36,14 @@
 
-  * erasesize aligned (e.g. use MTDPART_OFS_NEXTBLK).
 
-  */
 
- 
-+struct mtd_partition;
 
- struct mtd_partition {
 
- 	char *name;			/* identifier string */
 
- 	uint64_t size;			/* partition size */
 
- 	uint64_t offset;		/* offset within the master MTD space */
 
- 	uint32_t mask_flags;		/* master MTD flags to mask out for this partition */
 
- 	struct nand_ecclayout *ecclayout;	/* out of band layout for this partition (NAND only) */
 
-+	int (*refresh_partition)(struct mtd_info *);
 
- };
 
- 
- #define MTDPART_OFS_RETAIN	(-3)
 
---- a/include/mtd/mtd-abi.h
 
-+++ b/include/mtd/mtd-abi.h
 
-@@ -202,6 +202,7 @@ struct otp_info {
 
-  * without OOB, e.g., NOR flash.
 
-  */
 
- #define MEMWRITE		_IOWR('M', 24, struct mtd_write_req)
 
-+#define MTDREFRESH		_IO('M', 50)
 
- 
- /*
 
-  * Obsolete legacy interface. Keep it in order not to break userspace

+ 0 - 146
target/linux/generic/patches-3.3/401-partial_eraseblock_write.patch
View File 

@@ -1,146 +0,0 @@
 
---- a/drivers/mtd/mtdpart.c
 
-+++ b/drivers/mtd/mtdpart.c
 
-@@ -35,6 +35,8 @@
 
- 
- #include "mtdcore.h"
 
- 
-+#define MTD_ERASE_PARTIAL	0x8000 /* partition only covers parts of an erase block */
 
-+
 
- /* Our partition linked list */
 
- static LIST_HEAD(mtd_partitions);
 
- static DEFINE_MUTEX(mtd_partitions_mutex);
 
-@@ -252,13 +254,61 @@ static int part_erase(struct mtd_info *m
 
- 		return -EROFS;
 
- 	if (instr->addr >= mtd->size)
 
- 		return -EINVAL;
 
-+
 
-+	instr->partial_start = false;
 
-+	if (mtd->flags & MTD_ERASE_PARTIAL) {
 
-+		size_t readlen = 0;
 
-+		u64 mtd_ofs;
 
-+
 
-+		instr->erase_buf = kmalloc(part->master->erasesize, GFP_ATOMIC);
 
-+		if (!instr->erase_buf)
 
-+			return -ENOMEM;
 
-+
 
-+		mtd_ofs = part->offset + instr->addr;
 
-+		instr->erase_buf_ofs = do_div(mtd_ofs, part->master->erasesize);
 
-+
 
-+		if (instr->erase_buf_ofs > 0) {
 
-+			instr->addr -= instr->erase_buf_ofs;
 
-+			ret = mtd_read(part->master,
 
-+				instr->addr + part->offset,
 
-+				part->master->erasesize,
 
-+				&readlen, instr->erase_buf);
 
-+
 
-+			instr->len += instr->erase_buf_ofs;
 
-+			instr->partial_start = true;
 
-+		} else {
 
-+			mtd_ofs = part->offset + part->mtd.size;
 
-+			instr->erase_buf_ofs = part->master->erasesize -
 
-+				do_div(mtd_ofs, part->master->erasesize);
 
-+
 
-+			if (instr->erase_buf_ofs > 0) {
 
-+				instr->len += instr->erase_buf_ofs;
 
-+				ret = mtd_read(part->master,
 
-+					part->offset + instr->addr +
 
-+					instr->len - part->master->erasesize,
 
-+					part->master->erasesize, &readlen,
 
-+					instr->erase_buf);
 
-+			} else {
 
-+				ret = 0;
 
-+			}
 
-+		}
 
-+		if (ret < 0) {
 
-+			kfree(instr->erase_buf);
 
-+			return ret;
 
-+		}
 
-+
 
-+	}
 
-+
 
- 	instr->addr += part->offset;
 
- 	ret = mtd_erase(part->master, instr);
 
- 	if (ret) {
 
- 		if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
 
- 			instr->fail_addr -= part->offset;
 
- 		instr->addr -= part->offset;
 
-+		if (mtd->flags & MTD_ERASE_PARTIAL)
 
-+			kfree(instr->erase_buf);
 
- 	}
 
-+
 
- 	return ret;
 
- }
 
- 
-@@ -266,7 +316,25 @@ void mtd_erase_callback(struct erase_inf
 
- {
 
- 	if (instr->mtd->erase == part_erase) {
 
- 		struct mtd_part *part = PART(instr->mtd);
 
-+		size_t wrlen = 0;
 
- 
-+		if (instr->mtd->flags & MTD_ERASE_PARTIAL) {
 
-+			if (instr->partial_start) {
 
-+				part->master->write(part->master,
 
-+					instr->addr, instr->erase_buf_ofs,
 
-+					&wrlen, instr->erase_buf);
 
-+				instr->addr += instr->erase_buf_ofs;
 
-+			} else {
 
-+				instr->len -= instr->erase_buf_ofs;
 
-+				part->master->write(part->master,
 
-+					instr->addr + instr->len,
 
-+					instr->erase_buf_ofs, &wrlen,
 
-+					instr->erase_buf +
 
-+					part->master->erasesize -
 
-+					instr->erase_buf_ofs);
 
-+			}
 
-+			kfree(instr->erase_buf);
 
-+		}
 
- 		if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
 
- 			instr->fail_addr -= part->offset;
 
- 		instr->addr -= part->offset;
 
-@@ -537,18 +605,24 @@ static struct mtd_part *allocate_partiti
 
- 	if ((slave->mtd.flags & MTD_WRITEABLE) &&
 
- 	    mtd_mod_by_eb(slave->offset, &slave->mtd)) {
 
- 		/* Doesn't start on a boundary of major erase size */
 
--		/* FIXME: Let it be writable if it is on a boundary of
 
--		 * _minor_ erase size though */
 
--		slave->mtd.flags &= ~MTD_WRITEABLE;
 
--		printk(KERN_WARNING"mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
 
--			part->name);
 
-+		slave->mtd.flags |= MTD_ERASE_PARTIAL;
 
-+		if (((u32) slave->mtd.size) > master->erasesize)
 
-+			slave->mtd.flags &= ~MTD_WRITEABLE;
 
-+		else
 
-+			slave->mtd.erasesize = slave->mtd.size;
 
- 	}
 
- 	if ((slave->mtd.flags & MTD_WRITEABLE) &&
 
--	    mtd_mod_by_eb(slave->mtd.size, &slave->mtd)) {
 
--		slave->mtd.flags &= ~MTD_WRITEABLE;
 
--		printk(KERN_WARNING"mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
 
--			part->name);
 
-+	    mtd_mod_by_eb(slave->offset + slave->mtd.size, &slave->mtd)) {
 
-+		slave->mtd.flags |= MTD_ERASE_PARTIAL;
 
-+
 
-+		if ((u32) slave->mtd.size > master->erasesize)
 
-+			slave->mtd.flags &= ~MTD_WRITEABLE;
 
-+		else
 
-+			slave->mtd.erasesize = slave->mtd.size;
 
- 	}
 
-+	if ((slave->mtd.flags & (MTD_ERASE_PARTIAL|MTD_WRITEABLE)) == MTD_ERASE_PARTIAL)
 
-+		printk(KERN_WARNING"mtd: partition \"%s\" must either start or end on erase block boundary or be smaller than an erase block -- forcing read-only\n",
 
-+				part->name);
 
- 
- 	slave->mtd.ecclayout = master->ecclayout;
 
- 	if (master->block_isbad) {
 
---- a/include/linux/mtd/mtd.h
 
-+++ b/include/linux/mtd/mtd.h
 
-@@ -58,6 +58,10 @@ struct erase_info {
 
- 	u_long priv;
 
- 	u_char state;
 
- 	struct erase_info *next;
 
-+
 
-+	u8 *erase_buf;
 
-+	u32 erase_buf_ofs;
 
-+	bool partial_start;
 
- };
 
- 
- struct mtd_erase_region_info {

+ 0 - 18
target/linux/generic/patches-3.3/410-mtd_info_move_forward_decl.patch
View File 

@@ -1,18 +0,0 @@
 
---- a/include/linux/mtd/partitions.h
 
-+++ b/include/linux/mtd/partitions.h
 
-@@ -35,6 +35,7 @@
 
-  * Note: writeable partitions require their size and offset be
 
-  * erasesize aligned (e.g. use MTDPART_OFS_NEXTBLK).
 
-  */
 
-+struct mtd_info;
 
- 
- struct mtd_partition;
 
- struct mtd_partition {
 
-@@ -52,7 +53,6 @@ struct mtd_partition {
 
- #define MTDPART_SIZ_FULL	(0)
 
- 
- 
--struct mtd_info;
 
- struct device_node;
 
- 
- /**

+ 0 - 30
target/linux/generic/patches-3.3/420-redboot_space.patch
View File 

@@ -1,30 +0,0 @@
 
---- a/drivers/mtd/redboot.c
 
-+++ b/drivers/mtd/redboot.c
 
-@@ -267,14 +267,21 @@ static int parse_redboot_partitions(stru
 
- #endif
 
- 		names += strlen(names)+1;
 
- 
--#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
 
- 		if(fl->next && fl->img->flash_base + fl->img->size + master->erasesize <= fl->next->img->flash_base) {
 
--			i++;
 
--			parts[i].offset = parts[i-1].size + parts[i-1].offset;
 
--			parts[i].size = fl->next->img->flash_base - parts[i].offset;
 
--			parts[i].name = nullname;
 
--		}
 
-+			if (!strcmp(parts[i].name, "rootfs")) {
 
-+				parts[i].size = fl->next->img->flash_base;
 
-+				parts[i].size &= ~(master->erasesize - 1);
 
-+				parts[i].size -= parts[i].offset;
 
-+#ifdef CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED
 
-+				nrparts--;
 
-+			} else {
 
-+				i++;
 
-+				parts[i].offset = parts[i-1].size + parts[i-1].offset;
 
-+				parts[i].size = fl->next->img->flash_base - parts[i].offset;
 
-+				parts[i].name = nullname;
 
- #endif
 
-+			}
 
-+		}
 
- 		tmp_fl = fl;
 
- 		fl = fl->next;
 
- 		kfree(tmp_fl);

+ 0 - 35
target/linux/generic/patches-3.3/430-mtd_myloader_partition_parser.patch
View File 

@@ -1,35 +0,0 @@
 
---- a/drivers/mtd/Kconfig
 
-+++ b/drivers/mtd/Kconfig
 
-@@ -156,6 +156,22 @@ config MTD_BCM63XX_PARTS
 
- 	  This provides partions parsing for BCM63xx devices with CFE
 
- 	  bootloaders.
 
- 
-+config MTD_MYLOADER_PARTS
 
-+	tristate "MyLoader partition parsing"
 
-+	depends on ADM5120 || ATHEROS_AR231X || ATHEROS_AR71XX || ATH79
 
-+	---help---
 
-+	  MyLoader is a bootloader which allows the user to define partitions
 
-+	  in flash devices, by putting a table in the second erase block
 
-+	  on the device, similar to a partition table. This table gives the 
-+	  offsets and lengths of the user defined partitions.
 
-+
 
-+	  If you need code which can detect and parse these tables, and
 
-+	  register MTD 'partitions' corresponding to each image detected,
 
-+	  enable this option.
 
-+
 
-+	  You will still need the parsing functions to be called by the driver
 
-+	  for your particular device. It won't happen automatically.
 
-+
 
- comment "User Modules And Translation Layers"
 
- 
- config MTD_CHAR
 
---- a/drivers/mtd/Makefile
 
-+++ b/drivers/mtd/Makefile
 
-@@ -12,6 +12,7 @@ obj-$(CONFIG_MTD_CMDLINE_PARTS) += cmdli
 
- obj-$(CONFIG_MTD_AFS_PARTS)	+= afs.o
 
- obj-$(CONFIG_MTD_AR7_PARTS)	+= ar7part.o
 
- obj-$(CONFIG_MTD_BCM63XX_PARTS)	+= bcm63xxpart.o
 
-+obj-$(CONFIG_MTD_MYLOADER_PARTS) += myloader.o
 
- 
- # 'Users' - code which presents functionality to userspace.
 
- obj-$(CONFIG_MTD_CHAR)		+= mtdchar.o

+ 0 - 116
target/linux/generic/patches-3.3/440-block2mtd_init.patch
View File 

@@ -1,116 +0,0 @@
 
---- a/drivers/mtd/devices/block2mtd.c
 
-+++ b/drivers/mtd/devices/block2mtd.c
 
-@@ -14,6 +14,7 @@
 
- #include <linux/list.h>
 
- #include <linux/init.h>
 
- #include <linux/mtd/mtd.h>
 
-+#include <linux/mtd/partitions.h>
 
- #include <linux/mutex.h>
 
- #include <linux/mount.h>
 
- #include <linux/slab.h>
 
-@@ -231,11 +232,12 @@ static void block2mtd_free_device(struct
 
- 
- 
- /* FIXME: ensure that mtd->size % erase_size == 0 */
 
--static struct block2mtd_dev *add_device(char *devname, int erase_size)
 
-+static struct block2mtd_dev *add_device(char *devname, int erase_size, const char *mtdname)
 
- {
 
- 	const fmode_t mode = FMODE_READ | FMODE_WRITE | FMODE_EXCL;
 
- 	struct block_device *bdev;
 
- 	struct block2mtd_dev *dev;
 
-+	struct mtd_partition *part;
 
- 	char *name;
 
- 
- 	if (!devname)
 
-@@ -274,13 +276,16 @@ static struct block2mtd_dev *add_device(
 
- 
- 	/* Setup the MTD structure */
 
- 	/* make the name contain the block device in */
 
--	name = kasprintf(GFP_KERNEL, "block2mtd: %s", devname);
 
-+	if (!mtdname)
 
-+		mtdname = devname;
 
-+	name = kmalloc(strlen(mtdname) + 1, GFP_KERNEL);
 
- 	if (!name)
 
- 		goto devinit_err;
 
- 
-+	strcpy(name, mtdname);
 
- 	dev->mtd.name = name;
 
- 
--	dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK;
 
-+	dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK & ~(erase_size - 1);
 
- 	dev->mtd.erasesize = erase_size;
 
- 	dev->mtd.writesize = 1;
 
- 	dev->mtd.writebufsize = PAGE_SIZE;
 
-@@ -294,14 +299,17 @@ static struct block2mtd_dev *add_device(
 
- 	dev->mtd.priv = dev;
 
- 	dev->mtd.owner = THIS_MODULE;
 
- 
--	if (mtd_device_register(&dev->mtd, NULL, 0)) {
 
-+	part = kzalloc(sizeof(struct mtd_partition), GFP_KERNEL);
 
-+	part->name = name;
 
-+	part->offset = 0;
 
-+	part->size = dev->mtd.size;
 
-+	if (mtd_device_register(&dev->mtd, part, 1)) {
 
- 		/* Device didn't get added, so free the entry */
 
- 		goto devinit_err;
 
- 	}
 
- 	list_add(&dev->list, &blkmtd_device_list);
 
- 	INFO("mtd%d: [%s] erase_size = %dKiB [%d]", dev->mtd.index,
 
--			dev->mtd.name + strlen("block2mtd: "),
 
--			dev->mtd.erasesize >> 10, dev->mtd.erasesize);
 
-+			mtdname, dev->mtd.erasesize >> 10, dev->mtd.erasesize);
 
- 	return dev;
 
- 
- devinit_err:
 
-@@ -374,9 +382,9 @@ static char block2mtd_paramline[80 + 12]
 
- 
- static int block2mtd_setup2(const char *val)
 
- {
 
--	char buf[80 + 12]; /* 80 for device, 12 for erase size */
 
-+	char buf[80 + 12 + 80]; /* 80 for device, 12 for erase size, 80 for name */
 
- 	char *str = buf;
 
--	char *token[2];
 
-+	char *token[3];
 
- 	char *name;
 
- 	size_t erase_size = PAGE_SIZE;
 
- 	int i, ret;
 
-@@ -387,7 +395,7 @@ static int block2mtd_setup2(const char *
 
- 	strcpy(str, val);
 
- 	kill_final_newline(str);
 
- 
--	for (i = 0; i < 2; i++)
 
-+	for (i = 0; i < 3; i++)
 
- 		token[i] = strsep(&str, ",");
 
- 
- 	if (str)
 
-@@ -406,8 +414,10 @@ static int block2mtd_setup2(const char *
 
- 			parse_err("illegal erase size");
 
- 		}
 
- 	}
 
-+	if (token[2] && (strlen(token[2]) + 1 > 80))
 
-+		parse_err("mtd device name too long");
 
- 
--	add_device(name, erase_size);
 
-+	add_device(name, erase_size, token[2]);
 
- 
- 	return 0;
 
- }
 
-@@ -441,7 +451,7 @@ static int block2mtd_setup(const char *v
 
- 
- 
- module_param_call(block2mtd, block2mtd_setup, NULL, NULL, 0200);
 
--MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>]\"");
 
-+MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>[,<name>]]\"");
 
- 
- static int __init block2mtd_init(void)
 
- {
 
---- a/block/partition-generic.c
 
-+++ b/block/partition-generic.c
 
-@@ -546,6 +546,7 @@ int invalidate_partitions(struct gendisk
 
- 
- 	return 0;
 
- }
 
-+EXPORT_SYMBOL(rescan_partitions);
 
- 
- unsigned char *read_dev_sector(struct block_device *bdev, sector_t n, Sector *p)
 
- {

+ 0 - 291
target/linux/generic/patches-3.3/441-block2mtd_refresh.patch
View File 

@@ -1,291 +0,0 @@
 
---- a/drivers/mtd/devices/block2mtd.c
 
-+++ b/drivers/mtd/devices/block2mtd.c
 
-@@ -29,6 +29,8 @@ struct block2mtd_dev {
 
- 	struct block_device *blkdev;
 
- 	struct mtd_info mtd;
 
- 	struct mutex write_mutex;
 
-+	rwlock_t bdev_mutex;
 
-+	char devname[0];
 
- };
 
- 
- 
-@@ -81,6 +83,12 @@ static int block2mtd_erase(struct mtd_in
 
- 	size_t len = instr->len;
 
- 	int err;
 
- 
-+	read_lock(&dev->bdev_mutex);
 
-+	if (!dev->blkdev) {
 
-+		err = -EINVAL;
 
-+		goto done;
 
-+	}
 
-+
 
- 	instr->state = MTD_ERASING;
 
- 	mutex_lock(&dev->write_mutex);
 
- 	err = _block2mtd_erase(dev, from, len);
 
-@@ -92,6 +100,10 @@ static int block2mtd_erase(struct mtd_in
 
- 		instr->state = MTD_ERASE_DONE;
 
- 
- 	mtd_erase_callback(instr);
 
-+
 
-+done:
 
-+	read_unlock(&dev->bdev_mutex);
 
-+
 
- 	return err;
 
- }
 
- 
-@@ -103,10 +115,14 @@ static int block2mtd_read(struct mtd_inf
 
- 	struct page *page;
 
- 	int index = from >> PAGE_SHIFT;
 
- 	int offset = from & (PAGE_SIZE-1);
 
--	int cpylen;
 
-+	int cpylen, err = 0;
 
-+
 
-+	read_lock(&dev->bdev_mutex);
 
-+	if (!dev->blkdev || (from > mtd->size)) {
 
-+		err = -EINVAL;
 
-+		goto done;
 
-+	}
 
- 
--	if (from > mtd->size)
 
--		return -EINVAL;
 
- 	if (from + len > mtd->size)
 
- 		len = mtd->size - from;
 
- 
-@@ -121,10 +137,14 @@ static int block2mtd_read(struct mtd_inf
 
- 		len = len - cpylen;
 
- 
- 		page = page_read(dev->blkdev->bd_inode->i_mapping, index);
 
--		if (!page)
 
--			return -ENOMEM;
 
--		if (IS_ERR(page))
 
--			return PTR_ERR(page);
 
-+		if (!page) {
 
-+			err = -ENOMEM;
 
-+			goto done;
 
-+		}
 
-+		if (IS_ERR(page)) {
 
-+			err = PTR_ERR(page);
 
-+			goto done;
 
-+		}
 
- 
- 		memcpy(buf, page_address(page) + offset, cpylen);
 
- 		page_cache_release(page);
 
-@@ -135,7 +155,10 @@ static int block2mtd_read(struct mtd_inf
 
- 		offset = 0;
 
- 		index++;
 
- 	}
 
--	return 0;
 
-+
 
-+done:
 
-+	read_unlock(&dev->bdev_mutex);
 
-+	return err;
 
- }
 
- 
- 
-@@ -187,12 +210,22 @@ static int block2mtd_write(struct mtd_in
 
- 		size_t *retlen, const u_char *buf)
 
- {
 
- 	struct block2mtd_dev *dev = mtd->priv;
 
--	int err;
 
-+	int err = 0;
 
-+
 
-+	read_lock(&dev->bdev_mutex);
 
-+	if (!dev->blkdev) {
 
-+		err = -EINVAL;
 
-+		goto done;
 
-+	}
 
- 
- 	if (!len)
 
--		return 0;
 
--	if (to >= mtd->size)
 
--		return -ENOSPC;
 
-+		goto done;
 
-+
 
-+	if (to >= mtd->size) {
 
-+		err = -ENOSPC;
 
-+		goto done;
 
-+	}
 
-+
 
- 	if (to + len > mtd->size)
 
- 		len = mtd->size - to;
 
- 
-@@ -201,6 +234,9 @@ static int block2mtd_write(struct mtd_in
 
- 	mutex_unlock(&dev->write_mutex);
 
- 	if (err > 0)
 
- 		err = 0;
 
-+
 
-+done:
 
-+	read_unlock(&dev->bdev_mutex);
 
- 	return err;
 
- }
 
- 
-@@ -209,33 +245,110 @@ static int block2mtd_write(struct mtd_in
 
- static void block2mtd_sync(struct mtd_info *mtd)
 
- {
 
- 	struct block2mtd_dev *dev = mtd->priv;
 
-+	read_lock(&dev->bdev_mutex);
 
-+	if (dev->blkdev)
 
- 	sync_blockdev(dev->blkdev);
 
-+	read_unlock(&dev->bdev_mutex);
 
-+
 
- 	return;
 
- }
 
- 
- 
-+static int _open_bdev(struct block2mtd_dev *dev)
 
-+{
 
-+	const fmode_t mode = FMODE_READ | FMODE_WRITE | FMODE_EXCL;
 
-+	struct block_device *bdev;
 
-+
 
-+	/* Get a handle on the device */
 
-+	bdev = blkdev_get_by_path(dev->devname, mode, dev);
 
-+#ifndef MODULE
 
-+	if (IS_ERR(bdev)) {
 
-+		dev_t devt;
 
-+
 
-+		/* We might not have rootfs mounted at this point. Try
 
-+		   to resolve the device name by other means. */
 
-+
 
-+		devt = name_to_dev_t(dev->devname);
 
-+		if (devt)
 
-+			bdev = blkdev_get_by_dev(devt, mode, dev);
 
-+	}
 
-+#endif
 
-+
 
-+	if (IS_ERR(bdev)) {
 
-+		ERROR("error: cannot open device %s", dev->devname);
 
-+		return 1;
 
-+	}
 
-+	dev->blkdev = bdev;
 
-+
 
-+	if (MAJOR(bdev->bd_dev) == MTD_BLOCK_MAJOR) {
 
-+		ERROR("attempting to use an MTD device as a block device");
 
-+		return 1;
 
-+	}
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static void _close_bdev(struct block2mtd_dev *dev)
 
-+{
 
-+	struct block_device *bdev;
 
-+
 
-+	if (!dev->blkdev)
 
-+		return;
 
-+
 
-+	bdev = dev->blkdev;
 
-+	invalidate_mapping_pages(dev->blkdev->bd_inode->i_mapping, 0, -1);
 
-+	blkdev_put(dev->blkdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
 
-+	dev->blkdev = NULL;
 
-+}
 
-+
 
- static void block2mtd_free_device(struct block2mtd_dev *dev)
 
- {
 
- 	if (!dev)
 
- 		return;
 
- 
- 	kfree(dev->mtd.name);
 
--
 
--	if (dev->blkdev) {
 
--		invalidate_mapping_pages(dev->blkdev->bd_inode->i_mapping,
 
--					0, -1);
 
--		blkdev_put(dev->blkdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
 
--	}
 
--
 
-+	_close_bdev(dev);
 
- 	kfree(dev);
 
- }
 
- 
- 
--/* FIXME: ensure that mtd->size % erase_size == 0 */
 
--static struct block2mtd_dev *add_device(char *devname, int erase_size, const char *mtdname)
 
-+static int block2mtd_refresh(struct mtd_info *mtd)
 
- {
 
--	const fmode_t mode = FMODE_READ | FMODE_WRITE | FMODE_EXCL;
 
-+	struct block2mtd_dev *dev = mtd->priv;
 
- 	struct block_device *bdev;
 
-+	dev_t devt;
 
-+	int err = 0;
 
-+
 
-+	/* no other mtd function can run at this point */
 
-+	write_lock(&dev->bdev_mutex);
 
-+
 
-+	/* get the device number for the whole disk */
 
-+	devt = MKDEV(MAJOR(dev->blkdev->bd_dev), 0);
 
-+
 
-+	/* close the old block device */
 
-+	_close_bdev(dev);
 
-+
 
-+	/* open the whole disk, issue a partition rescan, then */
 
-+	bdev = blkdev_get_by_dev(devt, FMODE_WRITE | FMODE_READ, mtd);
 
-+	if (!bdev || !bdev->bd_disk)
 
-+		err = -EINVAL;
 
-+#ifndef CONFIG_MTD_BLOCK2MTD_MODULE
 
-+	else
 
-+		err = rescan_partitions(bdev->bd_disk, bdev);
 
-+#endif
 
-+	if (bdev)
 
-+		blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
 
-+
 
-+	/* try to open the partition block device again */
 
-+	_open_bdev(dev);
 
-+	write_unlock(&dev->bdev_mutex);
 
-+
 
-+	return err;
 
-+}
 
-+
 
-+/* FIXME: ensure that mtd->size % erase_size == 0 */
 
-+static struct block2mtd_dev *add_device(char *devname, int erase_size, char *mtdname)
 
-+{
 
- 	struct block2mtd_dev *dev;
 
- 	struct mtd_partition *part;
 
- 	char *name;
 
-@@ -243,36 +356,17 @@ static struct block2mtd_dev *add_device(
 
- 	if (!devname)
 
- 		return NULL;
 
- 
--	dev = kzalloc(sizeof(struct block2mtd_dev), GFP_KERNEL);
 
-+	dev = kzalloc(sizeof(struct block2mtd_dev) + strlen(devname) + 1, GFP_KERNEL);
 
- 	if (!dev)
 
- 		return NULL;
 
- 
--	/* Get a handle on the device */
 
--	bdev = blkdev_get_by_path(devname, mode, dev);
 
--#ifndef MODULE
 
--	if (IS_ERR(bdev)) {
 
--
 
--		/* We might not have rootfs mounted at this point. Try
 
--		   to resolve the device name by other means. */
 
-+	strcpy(dev->devname, devname);
 
- 
--		dev_t devt = name_to_dev_t(devname);
 
--		if (devt)
 
--			bdev = blkdev_get_by_dev(devt, mode, dev);
 
--	}
 
--#endif
 
--
 
--	if (IS_ERR(bdev)) {
 
--		ERROR("error: cannot open device %s", devname);
 
-+	if (_open_bdev(dev))
 
- 		goto devinit_err;
 
--	}
 
--	dev->blkdev = bdev;
 
--
 
--	if (MAJOR(bdev->bd_dev) == MTD_BLOCK_MAJOR) {
 
--		ERROR("attempting to use an MTD device as a block device");
 
--		goto devinit_err;
 
--	}
 
- 
- 	mutex_init(&dev->write_mutex);
 
-+	rwlock_init(&dev->bdev_mutex);
 
- 
- 	/* Setup the MTD structure */
 
- 	/* make the name contain the block device in */
 
-@@ -298,6 +392,7 @@ static struct block2mtd_dev *add_device(
 
- 	dev->mtd.read = block2mtd_read;
 
- 	dev->mtd.priv = dev;
 
- 	dev->mtd.owner = THIS_MODULE;
 
-+	dev->mtd.refresh_device = block2mtd_refresh;
 
- 
- 	part = kzalloc(sizeof(struct mtd_partition), GFP_KERNEL);
 
- 	part->name = name;

+ 0 - 10
target/linux/generic/patches-3.3/442-block2mtd_probe.patch
View File 

@@ -1,10 +0,0 @@
 
---- a/drivers/mtd/devices/block2mtd.c
 
-+++ b/drivers/mtd/devices/block2mtd.c
 
-@@ -268,6 +268,7 @@ static int _open_bdev(struct block2mtd_d
 
- 		/* We might not have rootfs mounted at this point. Try
 
- 		   to resolve the device name by other means. */
 
- 
-+		wait_for_device_probe();
 
- 		devt = name_to_dev_t(dev->devname);
 
- 		if (devt)
 
- 			bdev = blkdev_get_by_dev(devt, mode, dev);

+ 0 - 10
target/linux/generic/patches-3.3/443-block2mtd-avoid-recursive-call-of-mtd_writev.patch
View File 

@@ -1,10 +0,0 @@
 
---- a/drivers/mtd/devices/block2mtd.c
 
-+++ b/drivers/mtd/devices/block2mtd.c
 
-@@ -388,7 +388,6 @@ static struct block2mtd_dev *add_device(
 
- 	dev->mtd.flags = MTD_CAP_RAM;
 
- 	dev->mtd.erase = block2mtd_erase;
 
- 	dev->mtd.write = block2mtd_write;
 
--	dev->mtd.writev = mtd_writev;
 
- 	dev->mtd.sync = block2mtd_sync;
 
- 	dev->mtd.read = block2mtd_read;
 
- 	dev->mtd.priv = dev;

+ 0 - 37
target/linux/generic/patches-3.3/450-mtd_plat_nand_chip_fixup.patch
View File 

@@ -1,37 +0,0 @@
 
----
 
- drivers/mtd/nand/plat_nand.c |   13 ++++++++++++-
 
- include/linux/mtd/nand.h     |    1 +
 
- 2 files changed, 13 insertions(+), 1 deletion(-)
 
-
 
---- a/include/linux/mtd/nand.h
 
-+++ b/include/linux/mtd/nand.h
 
-@@ -622,6 +622,7 @@ struct platform_nand_chip {
 
- 	unsigned int options;
 
- 	unsigned int bbt_options;
 
- 	const char **part_probe_types;
 
-+	int (*chip_fixup)(struct mtd_info *mtd);
 
- };
 
- 
- /* Keep gcc happy */
 
---- a/drivers/mtd/nand/plat_nand.c
 
-+++ b/drivers/mtd/nand/plat_nand.c
 
-@@ -93,7 +93,18 @@ static int __devinit plat_nand_probe(str
 
- 	}
 
- 
- 	/* Scan to find existence of the device */
 
--	if (nand_scan(&data->mtd, pdata->chip.nr_chips)) {
 
-+	if (nand_scan_ident(&data->mtd, pdata->chip.nr_chips, NULL)) {
 
-+		err = -ENXIO;
 
-+		goto out;
 
-+	}
 
-+
 
-+	if (pdata->chip.chip_fixup) {
 
-+		err = pdata->chip.chip_fixup(&data->mtd);
 
-+		if (err)
 
-+			goto out;
 
-+	}
 
-+
 
-+	if (nand_scan_tail(&data->mtd)) {
 
- 		err = -ENXIO;
 
- 		goto out;
 
- 	}

+ 0 - 12
target/linux/generic/patches-3.3/451-mtd_fix_nand_correct_data_return_code.patch
View File 

@@ -1,12 +0,0 @@
 
---- a/drivers/mtd/nand/nand_ecc.c
 
-+++ b/drivers/mtd/nand/nand_ecc.c
 
-@@ -507,8 +507,7 @@ int __nand_correct_data(unsigned char *b
 
- 	if ((bitsperbyte[b0] + bitsperbyte[b1] + bitsperbyte[b2]) == 1)
 
- 		return 1;	/* error in ECC data; no action needed */
 
- 
--	printk(KERN_ERR "uncorrectable error : ");
 
--	return -1;
 
-+	return -EBADMSG;
 
- }
 
- EXPORT_SYMBOL(__nand_correct_data);
 
-

+ 0 - 11
target/linux/generic/patches-3.3/460-cfi_cmdset_0002_no_erase_suspend.patch
View File 

@@ -1,11 +0,0 @@
 
---- a/drivers/mtd/chips/cfi_cmdset_0002.c
 
-+++ b/drivers/mtd/chips/cfi_cmdset_0002.c
 
-@@ -682,7 +682,7 @@ static int get_chip(struct map_info *map
 
- 		return 0;
 
- 
- 	case FL_ERASING:
 
--		if (!cfip || !(cfip->EraseSuspend & (0x1|0x2)) ||
 
-+		if (1 /* no suspend */ || !cfip || !(cfip->EraseSuspend & (0x1|0x2)) ||
 
- 		    !(mode == FL_READY || mode == FL_POINT ||
 
- 		    (mode == FL_WRITING && (cfip->EraseSuspend & 0x2))))
 
- 			goto sleep;

+ 0 - 39
target/linux/generic/patches-3.3/470-mtd_m25p80_add_pm25lv_flash_support.patch
View File 

@@ -1,39 +0,0 @@
 
---- a/drivers/mtd/devices/m25p80.c
 
-+++ b/drivers/mtd/devices/m25p80.c
 
-@@ -45,6 +45,7 @@
 
- #define	OPCODE_BE_4K		0x20	/* Erase 4KiB block */
 
- #define	OPCODE_BE_32K		0x52	/* Erase 32KiB block */
 
- #define	OPCODE_CHIP_ERASE	0xc7	/* Erase whole flash chip */
 
-+#define	OPCODE_BE_4K_PMC	0xd7	/* Erase 4KiB block on PMC chips*/
 
- #define	OPCODE_SE		0xd8	/* Sector erase (usually 64KiB) */
 
- #define	OPCODE_RDID		0x9f	/* Read JEDEC ID */
 
- 
-@@ -625,6 +626,7 @@ struct flash_info {
 
- 	u16		flags;
 
- #define	SECT_4K		0x01		/* OPCODE_BE_4K works uniformly */
 
- #define	M25P_NO_ERASE	0x02		/* No erase command needed */
 
-+#define	SECT_4K_PMC	0x04		/* OPCODE_BE_4K_PMC works uniformly */
 
- };
 
- 
- #define INFO(_jedec_id, _ext_id, _sector_size, _n_sectors, _flags)	\
 
-@@ -686,6 +688,10 @@ static const struct spi_device_id m25p_i
 
- 	{ "mx25l25635e", INFO(0xc22019, 0, 64 * 1024, 512, 0) },
 
- 	{ "mx25l25655e", INFO(0xc22619, 0, 64 * 1024, 512, 0) },
 
- 
-+	/* PMC -- pm25x "blocks" are 32K, sectors are 4K */
 
-+	{ "pm25lv512", INFO(0, 0, 32 * 1024, 2, SECT_4K_PMC) },
 
-+	{ "pm25lv010", INFO(0, 0, 32 * 1024, 4, SECT_4K_PMC) },
 
-+
 
- 	/* Spansion -- single (large) sector size only, at least
 
- 	 * for the chips listed here (without boot sectors).
 
- 	 */
 
-@@ -921,6 +927,9 @@ static int __devinit m25p_probe(struct s
 
- 	if (info->flags & SECT_4K) {
 
- 		flash->erase_opcode = OPCODE_BE_4K;
 
- 		flash->mtd.erasesize = 4096;
 
-+	} else if (info->flags & SECT_4K_PMC) {
 
-+		flash->erase_opcode = OPCODE_BE_4K_PMC;
 
-+		flash->mtd.erasesize = 4096;
 
- 	} else {
 
- 		flash->erase_opcode = OPCODE_SE;
 
- 		flash->mtd.erasesize = info->sector_size;

+ 0 - 10
target/linux/generic/patches-3.3/473-mtd_m25p80_add_w25q128.patch
View File 

@@ -1,10 +0,0 @@
 
---- a/drivers/mtd/devices/m25p80.c
 
-+++ b/drivers/mtd/devices/m25p80.c
 
-@@ -765,6 +765,7 @@ static const struct spi_device_id m25p_i
 
- 	{ "w25q32", INFO(0xef4016, 0, 64 * 1024,  64, SECT_4K) },
 
- 	{ "w25x64", INFO(0xef3017, 0, 64 * 1024, 128, SECT_4K) },
 
- 	{ "w25q64", INFO(0xef4017, 0, 64 * 1024, 128, SECT_4K) },
 
-+	{ "w25q128", INFO(0xef4018, 0, 64 * 1024, 256, SECT_4K) },
 
- 
- 	/* Catalyst / On Semiconductor -- non-JEDEC */
 
- 	{ "cat25c11", CAT25_INFO(  16, 8, 16, 1) },

+ 0 - 18
target/linux/generic/patches-3.3/475-mtd_cfi_cmdset_0002-add-buffer-write-cmd-timeout.patch
View File 

@@ -1,18 +0,0 @@
 
-From: George Kashperko <[email protected]>
 
-
 
-Issue map read after Write Buffer Load command to ensure chip is ready
 
-to receive data.
 
-Signed-off-by: George Kashperko <[email protected]>
 
----
 
- drivers/mtd/chips/cfi_cmdset_0002.c |    1 +
 
- 1 file changed, 1 insertion(+)
 
---- a/drivers/mtd/chips/cfi_cmdset_0002.c
 
-+++ b/drivers/mtd/chips/cfi_cmdset_0002.c
 
-@@ -1409,6 +1409,7 @@ static int __xipram do_write_buffer(stru
 
- 
- 	/* Write Buffer Load */
 
- 	map_write(map, CMD(0x25), cmd_adr);
 
-+	(void) map_read(map, cmd_adr);
 
- 
- 	chip->state = FL_WRITING_TO_BUFFER;
 
-

+ 0 - 41
target/linux/generic/patches-3.3/476-mtd-m25p80-allow-to-disable-small-sector-erase.patch
View File 

@@ -1,41 +0,0 @@
 
---- a/drivers/mtd/devices/Kconfig
 
-+++ b/drivers/mtd/devices/Kconfig
 
-@@ -102,6 +102,14 @@ config M25PXX_USE_FAST_READ
 
- 	help
 
- 	  This option enables FAST_READ access supported by ST M25Pxx.
 
- 
-+config M25PXX_PREFER_SMALL_SECTOR_ERASE
 
-+	bool "Prefer small sector erase"
 
-+	depends on MTD_M25P80
 
-+	default y
 
-+	help
 
-+	  This option enables use of the small erase sectors if that is
 
-+	  supported by the flash chip.
 
-+
 
- config MTD_SST25L
 
- 	tristate "Support SST25L (non JEDEC) SPI Flash chips"
 
- 	depends on SPI_MASTER
 
---- a/drivers/mtd/devices/m25p80.c
 
-+++ b/drivers/mtd/devices/m25p80.c
 
-@@ -84,6 +84,12 @@
 
- 
- #define JEDEC_MFR(_jedec_id)	((_jedec_id) >> 16)
 
- 
-+#ifdef CONFIG_M25PXX_PREFER_SMALL_SECTOR_ERASE
 
-+#define PREFER_SMALL_SECTOR_ERASE 1
 
-+#else
 
-+#define PREFER_SMALL_SECTOR_ERASE 0
 
-+#endif
 
-+
 
- /****************************************************************************/
 
- 
- struct m25p {
 
-@@ -925,7 +931,7 @@ static int __devinit m25p_probe(struct s
 
- 		flash->mtd.write = m25p80_write;
 
- 
- 	/* prefer "small sector" erase if possible */
 
--	if (info->flags & SECT_4K) {
 
-+	if (PREFER_SMALL_SECTOR_ERASE && (info->flags & SECT_4K)) {
 
- 		flash->erase_opcode = OPCODE_BE_4K;
 
- 		flash->mtd.erasesize = 4096;
 
- 	} else if (info->flags & SECT_4K_PMC) {

+ 0 - 10
target/linux/generic/patches-3.3/477-mtd-m25p80-add-support-for-the-EON-EN25Q64-chip.patch
View File 

@@ -1,10 +0,0 @@
 
---- a/drivers/mtd/devices/m25p80.c
 
-+++ b/drivers/mtd/devices/m25p80.c
 
-@@ -677,6 +677,7 @@ static const struct spi_device_id m25p_i
 
- 	{ "en25p32", INFO(0x1c2016, 0, 64 * 1024,  64, 0) },
 
- 	{ "en25q32b", INFO(0x1c3016, 0, 64 * 1024,  64, 0) },
 
- 	{ "en25p64", INFO(0x1c2017, 0, 64 * 1024, 128, 0) },
 
-+	{ "en25q64", INFO(0x1c3017, 0, 64 * 1024, 128, SECT_4K) },
 
- 
- 	/* Intel/Numonyx -- xxxs33b */
 
- 	{ "160s33b",  INFO(0x898911, 0, 64 * 1024,  32, 0) },

+ 0 - 18
target/linux/generic/patches-3.3/478-mtd-partial_eraseblock_unlock.patch
View File 

@@ -1,18 +0,0 @@
 
---- a/drivers/mtd/mtdpart.c
 
-+++ b/drivers/mtd/mtdpart.c
 
-@@ -357,7 +357,14 @@ static int part_unlock(struct mtd_info *
 
- 	struct mtd_part *part = PART(mtd);
 
- 	if ((len + ofs) > mtd->size)
 
- 		return -EINVAL;
 
--	return mtd_unlock(part->master, ofs + part->offset, len);
 
-+
 
-+	ofs += part->offset;
 
-+	if (mtd->flags & MTD_ERASE_PARTIAL) {
 
-+		/* round up len to next erasesize and round down offset to prev block */
 
-+		len = (mtd_div_by_eb(len, part->master) + 1) * part->master->erasesize;
 
-+		ofs &= ~(part->master->erasesize - 1);
 
-+	}
 
-+	return mtd_unlock(part->master, ofs, len);
 
- }
 
- 
- static int part_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)

+ 0 - 25
target/linux/generic/patches-3.3/520-squashfs_update_xz_comp_opts.patch
View File 

@@ -1,25 +0,0 @@
 
-From f31b7c0efa255dd17a5f584022a319387f09b0d8 Mon Sep 17 00:00:00 2001
 
-From: Jonas Gorski <[email protected]>
 
-Date: Tue, 12 Apr 2011 19:55:41 +0200
 
-Subject: [PATCH] squashfs: update xz compressor options struct.
 
-
 
-Update the xz compressor options struct to match the squashfs userspace
 
-one.
 
----
 
- fs/squashfs/xz_wrapper.c |    4 +++-
 
- 1 files changed, 3 insertions(+), 1 deletions(-)
 
-
 
---- a/fs/squashfs/xz_wrapper.c
 
-+++ b/fs/squashfs/xz_wrapper.c
 
-@@ -39,8 +39,10 @@ struct squashfs_xz {
 
- };
 
- 
- struct comp_opts {
 
--	__le32 dictionary_size;
 
- 	__le32 flags;
 
-+	__le16 bit_opts;
 
-+	__le16 fb;
 
-+	__le32 dictionary_size;
 
- };
 
- 
- static void *squashfs_xz_init(struct squashfs_sb_info *msblk, void *buff,

+ 0 - 5142
target/linux/generic/patches-3.3/530-jffs2_make_lzma_available.patch
View File 

@@ -1,5142 +0,0 @@
 
---- a/fs/jffs2/Kconfig
 
-+++ b/fs/jffs2/Kconfig
 
-@@ -139,6 +139,15 @@ config JFFS2_LZO
 
- 	  This feature was added in July, 2007. Say 'N' if you need
 
- 	  compatibility with older bootloaders or kernels.
 
- 
-+config JFFS2_LZMA
 
-+	bool "JFFS2 LZMA compression support" if JFFS2_COMPRESSION_OPTIONS
 
-+	select LZMA_COMPRESS
 
-+	select LZMA_DECOMPRESS
 
-+	depends on JFFS2_FS
 
-+	default n
 
-+	help
 
-+	  JFFS2 wrapper to the LZMA C SDK
 
-+
 
- config JFFS2_RTIME
 
- 	bool "JFFS2 RTIME compression support" if JFFS2_COMPRESSION_OPTIONS
 
- 	depends on JFFS2_FS
 
---- a/fs/jffs2/Makefile
 
-+++ b/fs/jffs2/Makefile
 
-@@ -18,4 +18,7 @@ jffs2-$(CONFIG_JFFS2_RUBIN)	+= compr_rub
 
- jffs2-$(CONFIG_JFFS2_RTIME)	+= compr_rtime.o
 
- jffs2-$(CONFIG_JFFS2_ZLIB)	+= compr_zlib.o
 
- jffs2-$(CONFIG_JFFS2_LZO)	+= compr_lzo.o
 
-+jffs2-$(CONFIG_JFFS2_LZMA)      += compr_lzma.o
 
- jffs2-$(CONFIG_JFFS2_SUMMARY)   += summary.o
 
-+
 
-+CFLAGS_compr_lzma.o += -Iinclude/linux -Ilib/lzma
 
---- a/fs/jffs2/compr.c
 
-+++ b/fs/jffs2/compr.c
 
-@@ -374,6 +374,9 @@ int __init jffs2_compressors_init(void)
 
- #ifdef CONFIG_JFFS2_LZO
 
- 	jffs2_lzo_init();
 
- #endif
 
-+#ifdef CONFIG_JFFS2_LZMA
 
-+        jffs2_lzma_init();
 
-+#endif
 
- /* Setting default compression mode */
 
- #ifdef CONFIG_JFFS2_CMODE_NONE
 
- 	jffs2_compression_mode = JFFS2_COMPR_MODE_NONE;
 
-@@ -397,6 +400,9 @@ int __init jffs2_compressors_init(void)
 
- int jffs2_compressors_exit(void)
 
- {
 
- /* Unregistering compressors */
 
-+#ifdef CONFIG_JFFS2_LZMA
 
-+        jffs2_lzma_exit();
 
-+#endif
 
- #ifdef CONFIG_JFFS2_LZO
 
- 	jffs2_lzo_exit();
 
- #endif
 
---- a/fs/jffs2/compr.h
 
-+++ b/fs/jffs2/compr.h
 
-@@ -29,9 +29,9 @@
 
- #define JFFS2_DYNRUBIN_PRIORITY  20
 
- #define JFFS2_LZARI_PRIORITY     30
 
- #define JFFS2_RTIME_PRIORITY     50
 
--#define JFFS2_ZLIB_PRIORITY      60
 
--#define JFFS2_LZO_PRIORITY       80
 
--
 
-+#define JFFS2_LZMA_PRIORITY      70
 
-+#define JFFS2_ZLIB_PRIORITY      80
 
-+#define JFFS2_LZO_PRIORITY       90
 
- 
- #define JFFS2_RUBINMIPS_DISABLED /* RUBINs will be used only */
 
- #define JFFS2_DYNRUBIN_DISABLED  /*	   for decompression */
 
-@@ -101,5 +101,9 @@ void jffs2_zlib_exit(void);
 
- int jffs2_lzo_init(void);
 
- void jffs2_lzo_exit(void);
 
- #endif
 
-+#ifdef CONFIG_JFFS2_LZMA
 
-+int jffs2_lzma_init(void);
 
-+void jffs2_lzma_exit(void);
 
-+#endif
 
- 
- #endif /* __JFFS2_COMPR_H__ */
 
---- /dev/null
 
-+++ b/fs/jffs2/compr_lzma.c
 
-@@ -0,0 +1,128 @@
 
-+/*
 
-+ * JFFS2 -- Journalling Flash File System, Version 2.
 
-+ *
 
-+ * For licensing information, see the file 'LICENCE' in this directory.
 
-+ *
 
-+ * JFFS2 wrapper to the LZMA C SDK
 
-+ *
 
-+ */
 
-+
 
-+#include <linux/lzma.h>
 
-+#include "compr.h"
 
-+
 
-+#ifdef __KERNEL__
 
-+	static DEFINE_MUTEX(deflate_mutex);
 
-+#endif
 
-+
 
-+CLzmaEncHandle *p;
 
-+Byte propsEncoded[LZMA_PROPS_SIZE];
 
-+SizeT propsSize = sizeof(propsEncoded);
 
-+
 
-+STATIC void lzma_free_workspace(void)
 
-+{
 
-+	LzmaEnc_Destroy(p, &lzma_alloc, &lzma_alloc);
 
-+}
 
-+
 
-+STATIC int INIT lzma_alloc_workspace(CLzmaEncProps *props)
 
-+{
 
-+	if ((p = (CLzmaEncHandle *)LzmaEnc_Create(&lzma_alloc)) == NULL)
 
-+	{
 
-+		PRINT_ERROR("Failed to allocate lzma deflate workspace\n");
 
-+		return -ENOMEM;
 
-+	}
 
-+
 
-+	if (LzmaEnc_SetProps(p, props) != SZ_OK)
 
-+	{
 
-+		lzma_free_workspace();
 
-+		return -1;
 
-+	}
 
-+	
-+	if (LzmaEnc_WriteProperties(p, propsEncoded, &propsSize) != SZ_OK)
 
-+	{
 
-+		lzma_free_workspace();
 
-+		return -1;
 
-+	}
 
-+
 
-+        return 0;
 
-+}
 
-+
 
-+STATIC int jffs2_lzma_compress(unsigned char *data_in, unsigned char *cpage_out,
 
-+			      uint32_t *sourcelen, uint32_t *dstlen)
 
-+{
 
-+	SizeT compress_size = (SizeT)(*dstlen);
 
-+	int ret;
 
-+
 
-+	#ifdef __KERNEL__
 
-+		mutex_lock(&deflate_mutex);
 
-+	#endif
 
-+
 
-+	ret = LzmaEnc_MemEncode(p, cpage_out, &compress_size, data_in, *sourcelen,
 
-+		0, NULL, &lzma_alloc, &lzma_alloc);
 
-+
 
-+	#ifdef __KERNEL__
 
-+		mutex_unlock(&deflate_mutex);
 
-+	#endif
 
-+
 
-+	if (ret != SZ_OK)
 
-+		return -1;
 
-+
 
-+	*dstlen = (uint32_t)compress_size;
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+STATIC int jffs2_lzma_decompress(unsigned char *data_in, unsigned char *cpage_out,
 
-+				 uint32_t srclen, uint32_t destlen)
 
-+{
 
-+	int ret;
 
-+	SizeT dl = (SizeT)destlen;
 
-+	SizeT sl = (SizeT)srclen;
 
-+	ELzmaStatus status;
 
-+	
-+	ret = LzmaDecode(cpage_out, &dl, data_in, &sl, propsEncoded,
 
-+		propsSize, LZMA_FINISH_ANY, &status, &lzma_alloc);
 
-+
 
-+	if (ret != SZ_OK || status == LZMA_STATUS_NOT_FINISHED || dl != (SizeT)destlen)
 
-+		return -1;
 
-+
 
-+	return 0;
 
-+}
 
-+
 
-+static struct jffs2_compressor jffs2_lzma_comp = {
 
-+	.priority = JFFS2_LZMA_PRIORITY,
 
-+	.name = "lzma",
 
-+	.compr = JFFS2_COMPR_LZMA,
 
-+	.compress = &jffs2_lzma_compress,
 
-+	.decompress = &jffs2_lzma_decompress,
 
-+	.disabled = 0,
 
-+};
 
-+
 
-+int INIT jffs2_lzma_init(void)
 
-+{
 
-+        int ret;
 
-+	CLzmaEncProps props;
 
-+	LzmaEncProps_Init(&props);
 
-+
 
-+        props.dictSize = LZMA_BEST_DICT(0x2000);
 
-+        props.level = LZMA_BEST_LEVEL;
 
-+        props.lc = LZMA_BEST_LC;
 
-+        props.lp = LZMA_BEST_LP;
 
-+        props.pb = LZMA_BEST_PB;
 
-+        props.fb = LZMA_BEST_FB;
 
-+
 
-+	ret = lzma_alloc_workspace(&props);
 
-+        if (ret < 0)
 
-+                return ret;
 
-+
 
-+	ret = jffs2_register_compressor(&jffs2_lzma_comp);
 
-+	if (ret)
 
-+		lzma_free_workspace();
 
-+	
-+        return ret;
 
-+}
 
-+
 
-+void jffs2_lzma_exit(void)
 
-+{
 
-+	jffs2_unregister_compressor(&jffs2_lzma_comp);
 
-+	lzma_free_workspace();
 
-+}
 
---- a/fs/jffs2/super.c
 
-+++ b/fs/jffs2/super.c
 
-@@ -371,14 +371,41 @@ static int __init init_jffs2_fs(void)
 
- 	BUILD_BUG_ON(sizeof(struct jffs2_raw_inode) != 68);
 
- 	BUILD_BUG_ON(sizeof(struct jffs2_raw_summary) != 32);
 
- 
--	printk(KERN_INFO "JFFS2 version 2.2."
 
-+	printk(KERN_INFO "JFFS2 version 2.2"
 
- #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
 
- 	       " (NAND)"
 
- #endif
 
- #ifdef CONFIG_JFFS2_SUMMARY
 
--	       " (SUMMARY) "
 
-+	       " (SUMMARY)"
 
- #endif
 
--	       " © 2001-2006 Red Hat, Inc.\n");
 
-+#ifdef CONFIG_JFFS2_ZLIB
 
-+	       " (ZLIB)"
 
-+#endif
 
-+#ifdef CONFIG_JFFS2_LZO
 
-+	       " (LZO)"
 
-+#endif
 
-+#ifdef CONFIG_JFFS2_LZMA
 
-+	       " (LZMA)"
 
-+#endif
 
-+#ifdef CONFIG_JFFS2_RTIME
 
-+	       " (RTIME)"
 
-+#endif
 
-+#ifdef CONFIG_JFFS2_RUBIN
 
-+	       " (RUBIN)"
 
-+#endif
 
-+#ifdef  CONFIG_JFFS2_CMODE_NONE
 
-+	       " (CMODE_NONE)"
 
-+#endif
 
-+#ifdef CONFIG_JFFS2_CMODE_PRIORITY
 
-+	       " (CMODE_PRIORITY)"
 
-+#endif
 
-+#ifdef CONFIG_JFFS2_CMODE_SIZE
 
-+	       " (CMODE_SIZE)"
 
-+#endif
 
-+#ifdef CONFIG_JFFS2_CMODE_FAVOURLZO
 
-+	       " (CMODE_FAVOURLZO)"
 
-+#endif
 
-+	       " (c) 2001-2006 Red Hat, Inc.\n");
 
- 
- 	jffs2_inode_cachep = kmem_cache_create("jffs2_i",
 
- 					     sizeof(struct jffs2_inode_info),
 
---- a/include/linux/jffs2.h
 
-+++ b/include/linux/jffs2.h
 
-@@ -46,6 +46,7 @@
 
- #define JFFS2_COMPR_DYNRUBIN	0x05
 
- #define JFFS2_COMPR_ZLIB	0x06
 
- #define JFFS2_COMPR_LZO		0x07
 
-+#define JFFS2_COMPR_LZMA	0x08
 
- /* Compatibility flags. */
 
- #define JFFS2_COMPAT_MASK 0xc000      /* What do to if an unknown nodetype is found */
 
- #define JFFS2_NODE_ACCURATE 0x2000
 
---- /dev/null
 
-+++ b/include/linux/lzma.h
 
-@@ -0,0 +1,62 @@
 
-+#ifndef __LZMA_H__
 
-+#define __LZMA_H__
 
-+
 
-+#ifdef __KERNEL__
 
-+	#include <linux/kernel.h>
 
-+	#include <linux/sched.h>
 
-+	#include <linux/slab.h>
 
-+	#include <linux/vmalloc.h>
 
-+	#include <linux/init.h>
 
-+	#define LZMA_MALLOC vmalloc
 
-+	#define LZMA_FREE vfree
 
-+	#define PRINT_ERROR(msg) printk(KERN_WARNING #msg)
 
-+	#define INIT __init
 
-+	#define STATIC static
 
-+#else
 
-+	#include <stdint.h>
 
-+	#include <stdlib.h>
 
-+	#include <stdio.h>
 
-+	#include <unistd.h>
 
-+	#include <string.h>
 
-+	#include <asm/types.h>
 
-+	#include <errno.h>
 
-+	#include <linux/jffs2.h>
 
-+	#ifndef PAGE_SIZE
 
-+		extern int page_size;
 
-+		#define PAGE_SIZE page_size
 
-+	#endif
 
-+	#define LZMA_MALLOC malloc
 
-+	#define LZMA_FREE free
 
-+	#define PRINT_ERROR(msg) fprintf(stderr, msg)
 
-+	#define INIT
 
-+	#define STATIC
 
-+#endif
 
-+
 
-+#include "lzma/LzmaDec.h"
 
-+#include "lzma/LzmaEnc.h"
 
-+
 
-+#define LZMA_BEST_LEVEL (9)
 
-+#define LZMA_BEST_LC    (0)
 
-+#define LZMA_BEST_LP    (0)
 
-+#define LZMA_BEST_PB    (0)
 
-+#define LZMA_BEST_FB  (273)
 
-+
 
-+#define LZMA_BEST_DICT(n) (((int)((n) / 2)) * 2)
 
-+
 
-+static void *p_lzma_malloc(void *p, size_t size)
 
-+{
 
-+        if (size == 0)
 
-+                return NULL;
 
-+
 
-+        return LZMA_MALLOC(size);
 
-+}
 
-+
 
-+static void p_lzma_free(void *p, void *address)
 
-+{
 
-+        if (address != NULL)
 
-+                LZMA_FREE(address);
 
-+}
 
-+
 
-+static ISzAlloc lzma_alloc = {p_lzma_malloc, p_lzma_free};
 
-+
 
-+#endif
 
---- /dev/null
 
-+++ b/include/linux/lzma/LzFind.h
 
-@@ -0,0 +1,115 @@
 
-+/* LzFind.h -- Match finder for LZ algorithms
 
-+2009-04-22 : Igor Pavlov : Public domain */
 
-+
 
-+#ifndef __LZ_FIND_H
 
-+#define __LZ_FIND_H
 
-+
 
-+#include "Types.h"
 
-+
 
-+#ifdef __cplusplus
 
-+extern "C" {
 
-+#endif
 
-+
 
-+typedef UInt32 CLzRef;
 
-+
 
-+typedef struct _CMatchFinder
 
-+{
 
-+  Byte *buffer;
 
-+  UInt32 pos;
 
-+  UInt32 posLimit;
 
-+  UInt32 streamPos;
 
-+  UInt32 lenLimit;
 
-+
 
-+  UInt32 cyclicBufferPos;
 
-+  UInt32 cyclicBufferSize; /* it must be = (historySize + 1) */
 
-+
 
-+  UInt32 matchMaxLen;
 
-+  CLzRef *hash;
 
-+  CLzRef *son;
 
-+  UInt32 hashMask;
 
-+  UInt32 cutValue;
 
-+
 
-+  Byte *bufferBase;
 
-+  ISeqInStream *stream;
 
-+  int streamEndWasReached;
 
-+
 
-+  UInt32 blockSize;
 
-+  UInt32 keepSizeBefore;
 
-+  UInt32 keepSizeAfter;
 
-+
 
-+  UInt32 numHashBytes;
 
-+  int directInput;
 
-+  size_t directInputRem;
 
-+  int btMode;
 
-+  int bigHash;
 
-+  UInt32 historySize;
 
-+  UInt32 fixedHashSize;
 
-+  UInt32 hashSizeSum;
 
-+  UInt32 numSons;
 
-+  SRes result;
 
-+  UInt32 crc[256];
 
-+} CMatchFinder;
 
-+
 
-+#define Inline_MatchFinder_GetPointerToCurrentPos(p) ((p)->buffer)
 
-+#define Inline_MatchFinder_GetIndexByte(p, index) ((p)->buffer[(Int32)(index)])
 
-+
 
-+#define Inline_MatchFinder_GetNumAvailableBytes(p) ((p)->streamPos - (p)->pos)
 
-+
 
-+int MatchFinder_NeedMove(CMatchFinder *p);
 
-+Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p);
 
-+void MatchFinder_MoveBlock(CMatchFinder *p);
 
-+void MatchFinder_ReadIfRequired(CMatchFinder *p);
 
-+
 
-+void MatchFinder_Construct(CMatchFinder *p);
 
-+
 
-+/* Conditions:
 
-+     historySize <= 3 GB
 
-+     keepAddBufferBefore + matchMaxLen + keepAddBufferAfter < 511MB
 
-+*/
 
-+int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
 
-+    UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
 
-+    ISzAlloc *alloc);
 
-+void MatchFinder_Free(CMatchFinder *p, ISzAlloc *alloc);
 
-+void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, UInt32 numItems);
 
-+void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue);
 
-+
 
-+UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *buffer, CLzRef *son,
 
-+    UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 _cutValue,
 
-+    UInt32 *distances, UInt32 maxLen);
 
-+
 
-+/*
 
-+Conditions:
 
-+  Mf_GetNumAvailableBytes_Func must be called before each Mf_GetMatchLen_Func.
 
-+  Mf_GetPointerToCurrentPos_Func's result must be used only before any other function
 
-+*/
 
-+
 
-+typedef void (*Mf_Init_Func)(void *object);
 
-+typedef Byte (*Mf_GetIndexByte_Func)(void *object, Int32 index);
 
-+typedef UInt32 (*Mf_GetNumAvailableBytes_Func)(void *object);
 
-+typedef const Byte * (*Mf_GetPointerToCurrentPos_Func)(void *object);
 
-+typedef UInt32 (*Mf_GetMatches_Func)(void *object, UInt32 *distances);
 
-+typedef void (*Mf_Skip_Func)(void *object, UInt32);
 
-+
 
-+typedef struct _IMatchFinder
 
-+{
 
-+  Mf_Init_Func Init;
 
-+  Mf_GetIndexByte_Func GetIndexByte;
 
-+  Mf_GetNumAvailableBytes_Func GetNumAvailableBytes;
 
-+  Mf_GetPointerToCurrentPos_Func GetPointerToCurrentPos;
 
-+  Mf_GetMatches_Func GetMatches;
 
-+  Mf_Skip_Func Skip;
 
-+} IMatchFinder;
 
-+
 
-+void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder *vTable);
 
-+
 
-+void MatchFinder_Init(CMatchFinder *p);
 
-+UInt32 Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
 
-+UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
 
-+void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
 
-+void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
 
-+
 
-+#ifdef __cplusplus
 
-+}
 
-+#endif
 
-+
 
-+#endif
 
---- /dev/null
 
-+++ b/include/linux/lzma/LzHash.h
 
-@@ -0,0 +1,54 @@
 
-+/* LzHash.h -- HASH functions for LZ algorithms
 
-+2009-02-07 : Igor Pavlov : Public domain */
 
-+
 
-+#ifndef __LZ_HASH_H
 
-+#define __LZ_HASH_H
 
-+
 
-+#define kHash2Size (1 << 10)
 
-+#define kHash3Size (1 << 16)
 
-+#define kHash4Size (1 << 20)
 
-+
 
-+#define kFix3HashSize (kHash2Size)
 
-+#define kFix4HashSize (kHash2Size + kHash3Size)
 
-+#define kFix5HashSize (kHash2Size + kHash3Size + kHash4Size)
 
-+
 
-+#define HASH2_CALC hashValue = cur[0] | ((UInt32)cur[1] << 8);
 
-+
 
-+#define HASH3_CALC { \
 
-+  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
 
-+  hash2Value = temp & (kHash2Size - 1); \
 
-+  hashValue = (temp ^ ((UInt32)cur[2] << 8)) & p->hashMask; }
 
-+
 
-+#define HASH4_CALC { \
 
-+  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
 
-+  hash2Value = temp & (kHash2Size - 1); \
 
-+  hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); \
 
-+  hashValue = (temp ^ ((UInt32)cur[2] << 8) ^ (p->crc[cur[3]] << 5)) & p->hashMask; }
 
-+
 
-+#define HASH5_CALC { \
 
-+  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
 
-+  hash2Value = temp & (kHash2Size - 1); \
 
-+  hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); \
 
-+  hash4Value = (temp ^ ((UInt32)cur[2] << 8) ^ (p->crc[cur[3]] << 5)); \
 
-+  hashValue = (hash4Value ^ (p->crc[cur[4]] << 3)) & p->hashMask; \
 
-+  hash4Value &= (kHash4Size - 1); }
 
-+
 
-+/* #define HASH_ZIP_CALC hashValue = ((cur[0] | ((UInt32)cur[1] << 8)) ^ p->crc[cur[2]]) & 0xFFFF; */
 
-+#define HASH_ZIP_CALC hashValue = ((cur[2] | ((UInt32)cur[0] << 8)) ^ p->crc[cur[1]]) & 0xFFFF;
 
-+
 
-+
 
-+#define MT_HASH2_CALC \
 
-+  hash2Value = (p->crc[cur[0]] ^ cur[1]) & (kHash2Size - 1);
 
-+
 
-+#define MT_HASH3_CALC { \
 
-+  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
 
-+  hash2Value = temp & (kHash2Size - 1); \
 
-+  hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); }
 
-+
 
-+#define MT_HASH4_CALC { \
 
-+  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
 
-+  hash2Value = temp & (kHash2Size - 1); \
 
-+  hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); \
 
-+  hash4Value = (temp ^ ((UInt32)cur[2] << 8) ^ (p->crc[cur[3]] << 5)) & (kHash4Size - 1); }
 
-+
 
-+#endif
 
---- /dev/null
 
-+++ b/include/linux/lzma/LzmaDec.h
 
-@@ -0,0 +1,231 @@
 
-+/* LzmaDec.h -- LZMA Decoder
 
-+2009-02-07 : Igor Pavlov : Public domain */
 
-+
 
-+#ifndef __LZMA_DEC_H
 
-+#define __LZMA_DEC_H
 
-+
 
-+#include "Types.h"
 
-+
 
-+#ifdef __cplusplus
 
-+extern "C" {
 
-+#endif
 
-+
 
-+/* #define _LZMA_PROB32 */
 
-+/* _LZMA_PROB32 can increase the speed on some CPUs,
 
-+   but memory usage for CLzmaDec::probs will be doubled in that case */
 
-+
 
-+#ifdef _LZMA_PROB32
 
-+#define CLzmaProb UInt32
 
-+#else
 
-+#define CLzmaProb UInt16
 
-+#endif
 
-+
 
-+
 
-+/* ---------- LZMA Properties ---------- */
 
-+
 
-+#define LZMA_PROPS_SIZE 5
 
-+
 
-+typedef struct _CLzmaProps
 
-+{
 
-+  unsigned lc, lp, pb;
 
-+  UInt32 dicSize;
 
-+} CLzmaProps;
 
-+
 
-+/* LzmaProps_Decode - decodes properties
 
-+Returns:
 
-+  SZ_OK
 
-+  SZ_ERROR_UNSUPPORTED - Unsupported properties
 
-+*/
 
-+
 
-+SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size);
 
-+
 
-+
 
-+/* ---------- LZMA Decoder state ---------- */
 
-+
 
-+/* LZMA_REQUIRED_INPUT_MAX = number of required input bytes for worst case.
 
-+   Num bits = log2((2^11 / 31) ^ 22) + 26 < 134 + 26 = 160; */
 
-+
 
-+#define LZMA_REQUIRED_INPUT_MAX 20
 
-+
 
-+typedef struct
 
-+{
 
-+  CLzmaProps prop;
 
-+  CLzmaProb *probs;
 
-+  Byte *dic;
 
-+  const Byte *buf;
 
-+  UInt32 range, code;
 
-+  SizeT dicPos;
 
-+  SizeT dicBufSize;
 
-+  UInt32 processedPos;
 
-+  UInt32 checkDicSize;
 
-+  unsigned state;
 
-+  UInt32 reps[4];
 
-+  unsigned remainLen;
 
-+  int needFlush;
 
-+  int needInitState;
 
-+  UInt32 numProbs;
 
-+  unsigned tempBufSize;
 
-+  Byte tempBuf[LZMA_REQUIRED_INPUT_MAX];
 
-+} CLzmaDec;
 
-+
 
-+#define LzmaDec_Construct(p) { (p)->dic = 0; (p)->probs = 0; }
 
-+
 
-+void LzmaDec_Init(CLzmaDec *p);
 
-+
 
-+/* There are two types of LZMA streams:
 
-+     0) Stream with end mark. That end mark adds about 6 bytes to compressed size.
 
-+     1) Stream without end mark. You must know exact uncompressed size to decompress such stream. */
 
-+
 
-+typedef enum
 
-+{
 
-+  LZMA_FINISH_ANY,   /* finish at any point */
 
-+  LZMA_FINISH_END    /* block must be finished at the end */
 
-+} ELzmaFinishMode;
 
-+
 
-+/* ELzmaFinishMode has meaning only if the decoding reaches output limit !!!
 
-+
 
-+   You must use LZMA_FINISH_END, when you know that current output buffer
 
-+   covers last bytes of block. In other cases you must use LZMA_FINISH_ANY.
 
-+
 
-+   If LZMA decoder sees end marker before reaching output limit, it returns SZ_OK,
 
-+   and output value of destLen will be less than output buffer size limit.
 
-+   You can check status result also.
 
-+
 
-+   You can use multiple checks to test data integrity after full decompression:
 
-+     1) Check Result and "status" variable.
 
-+     2) Check that output(destLen) = uncompressedSize, if you know real uncompressedSize.
 
-+     3) Check that output(srcLen) = compressedSize, if you know real compressedSize.
 
-+        You must use correct finish mode in that case. */
 
-+
 
-+typedef enum
 
-+{
 
-+  LZMA_STATUS_NOT_SPECIFIED,               /* use main error code instead */
 
-+  LZMA_STATUS_FINISHED_WITH_MARK,          /* stream was finished with end mark. */
 
-+  LZMA_STATUS_NOT_FINISHED,                /* stream was not finished */
 
-+  LZMA_STATUS_NEEDS_MORE_INPUT,            /* you must provide more input bytes */
 
-+  LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK  /* there is probability that stream was finished without end mark */
 
-+} ELzmaStatus;
 
-+
 
-+/* ELzmaStatus is used only as output value for function call */
 
-+
 
-+
 
-+/* ---------- Interfaces ---------- */
 
-+
 
-+/* There are 3 levels of interfaces:
 
-+     1) Dictionary Interface
 
-+     2) Buffer Interface
 
-+     3) One Call Interface
 
-+   You can select any of these interfaces, but don't mix functions from different
 
-+   groups for same object. */
 
-+
 
-+
 
-+/* There are two variants to allocate state for Dictionary Interface:
 
-+     1) LzmaDec_Allocate / LzmaDec_Free
 
-+     2) LzmaDec_AllocateProbs / LzmaDec_FreeProbs
 
-+   You can use variant 2, if you set dictionary buffer manually.
 
-+   For Buffer Interface you must always use variant 1.
 
-+
 
-+LzmaDec_Allocate* can return:
 
-+  SZ_OK
 
-+  SZ_ERROR_MEM         - Memory allocation error
 
-+  SZ_ERROR_UNSUPPORTED - Unsupported properties
 
-+*/
 
-+   
-+SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc);
 
-+void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc);
 
-+
 
-+SRes LzmaDec_Allocate(CLzmaDec *state, const Byte *prop, unsigned propsSize, ISzAlloc *alloc);
 
-+void LzmaDec_Free(CLzmaDec *state, ISzAlloc *alloc);
 
-+
 
-+/* ---------- Dictionary Interface ---------- */
 
-+
 
-+/* You can use it, if you want to eliminate the overhead for data copying from
 
-+   dictionary to some other external buffer.
 
-+   You must work with CLzmaDec variables directly in this interface.
 
-+
 
-+   STEPS:
 
-+     LzmaDec_Constr()
 
-+     LzmaDec_Allocate()
 
-+     for (each new stream)
 
-+     {
 
-+       LzmaDec_Init()
 
-+       while (it needs more decompression)
 
-+       {
 
-+         LzmaDec_DecodeToDic()
 
-+         use data from CLzmaDec::dic and update CLzmaDec::dicPos
 
-+       }
 
-+     }
 
-+     LzmaDec_Free()
 
-+*/
 
-+
 
-+/* LzmaDec_DecodeToDic
 
-+   
-+   The decoding to internal dictionary buffer (CLzmaDec::dic).
 
-+   You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!!
 
-+
 
-+finishMode:
 
-+  It has meaning only if the decoding reaches output limit (dicLimit).
 
-+  LZMA_FINISH_ANY - Decode just dicLimit bytes.
 
-+  LZMA_FINISH_END - Stream must be finished after dicLimit.
 
-+
 
-+Returns:
 
-+  SZ_OK
 
-+    status:
 
-+      LZMA_STATUS_FINISHED_WITH_MARK
 
-+      LZMA_STATUS_NOT_FINISHED
 
-+      LZMA_STATUS_NEEDS_MORE_INPUT
 
-+      LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
 
-+  SZ_ERROR_DATA - Data error
 
-+*/
 
-+
 
-+SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit,
 
-+    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
 
-+
 
-+
 
-+/* ---------- Buffer Interface ---------- */
 
-+
 
-+/* It's zlib-like interface.
 
-+   See LzmaDec_DecodeToDic description for information about STEPS and return results,
 
-+   but you must use LzmaDec_DecodeToBuf instead of LzmaDec_DecodeToDic and you don't need
 
-+   to work with CLzmaDec variables manually.
 
-+
 
-+finishMode:
 
-+  It has meaning only if the decoding reaches output limit (*destLen).
 
-+  LZMA_FINISH_ANY - Decode just destLen bytes.
 
-+  LZMA_FINISH_END - Stream must be finished after (*destLen).
 
-+*/
 
-+
 
-+SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,
 
-+    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
 
-+
 
-+
 
-+/* ---------- One Call Interface ---------- */
 
-+
 
-+/* LzmaDecode
 
-+
 
-+finishMode:
 
-+  It has meaning only if the decoding reaches output limit (*destLen).
 
-+  LZMA_FINISH_ANY - Decode just destLen bytes.
 
-+  LZMA_FINISH_END - Stream must be finished after (*destLen).
 
-+
 
-+Returns:
 
-+  SZ_OK
 
-+    status:
 
-+      LZMA_STATUS_FINISHED_WITH_MARK
 
-+      LZMA_STATUS_NOT_FINISHED
 
-+      LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
 
-+  SZ_ERROR_DATA - Data error
 
-+  SZ_ERROR_MEM  - Memory allocation error
 
-+  SZ_ERROR_UNSUPPORTED - Unsupported properties
 
-+  SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
 
-+*/
 
-+
 
-+SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
 
-+    const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
 
-+    ELzmaStatus *status, ISzAlloc *alloc);
 
-+
 
-+#ifdef __cplusplus
 
-+}
 
-+#endif
 
-+
 
-+#endif
 
---- /dev/null
 
-+++ b/include/linux/lzma/LzmaEnc.h
 
-@@ -0,0 +1,80 @@
 
-+/*  LzmaEnc.h -- LZMA Encoder
 
-+2009-02-07 : Igor Pavlov : Public domain */
 
-+
 
-+#ifndef __LZMA_ENC_H
 
-+#define __LZMA_ENC_H
 
-+
 
-+#include "Types.h"
 
-+
 
-+#ifdef __cplusplus
 
-+extern "C" {
 
-+#endif
 
-+
 
-+#define LZMA_PROPS_SIZE 5
 
-+
 
-+typedef struct _CLzmaEncProps
 
-+{
 
-+  int level;       /*  0 <= level <= 9 */
 
-+  UInt32 dictSize; /* (1 << 12) <= dictSize <= (1 << 27) for 32-bit version
 
-+                      (1 << 12) <= dictSize <= (1 << 30) for 64-bit version
 
-+                       default = (1 << 24) */
 
-+  int lc;          /* 0 <= lc <= 8, default = 3 */
 
-+  int lp;          /* 0 <= lp <= 4, default = 0 */
 
-+  int pb;          /* 0 <= pb <= 4, default = 2 */
 
-+  int algo;        /* 0 - fast, 1 - normal, default = 1 */
 
-+  int fb;          /* 5 <= fb <= 273, default = 32 */
 
-+  int btMode;      /* 0 - hashChain Mode, 1 - binTree mode - normal, default = 1 */
 
-+  int numHashBytes; /* 2, 3 or 4, default = 4 */
 
-+  UInt32 mc;        /* 1 <= mc <= (1 << 30), default = 32 */
 
-+  unsigned writeEndMark;  /* 0 - do not write EOPM, 1 - write EOPM, default = 0 */
 
-+  int numThreads;  /* 1 or 2, default = 2 */
 
-+} CLzmaEncProps;
 
-+
 
-+void LzmaEncProps_Init(CLzmaEncProps *p);
 
-+void LzmaEncProps_Normalize(CLzmaEncProps *p);
 
-+UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2);
 
-+
 
-+
 
-+/* ---------- CLzmaEncHandle Interface ---------- */
 
-+
 
-+/* LzmaEnc_* functions can return the following exit codes:
 
-+Returns:
 
-+  SZ_OK           - OK
 
-+  SZ_ERROR_MEM    - Memory allocation error
 
-+  SZ_ERROR_PARAM  - Incorrect paramater in props
 
-+  SZ_ERROR_WRITE  - Write callback error.
 
-+  SZ_ERROR_PROGRESS - some break from progress callback
 
-+  SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version)
 
-+*/
 
-+
 
-+typedef void * CLzmaEncHandle;
 
-+
 
-+CLzmaEncHandle LzmaEnc_Create(ISzAlloc *alloc);
 
-+void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAlloc *alloc, ISzAlloc *allocBig);
 
-+SRes LzmaEnc_SetProps(CLzmaEncHandle p, const CLzmaEncProps *props);
 
-+SRes LzmaEnc_WriteProperties(CLzmaEncHandle p, Byte *properties, SizeT *size);
 
-+SRes LzmaEnc_Encode(CLzmaEncHandle p, ISeqOutStream *outStream, ISeqInStream *inStream,
 
-+    ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);
 
-+SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
 
-+    int writeEndMark, ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);
 
-+
 
-+/* ---------- One Call Interface ---------- */
 
-+
 
-+/* LzmaEncode
 
-+Return code:
 
-+  SZ_OK               - OK
 
-+  SZ_ERROR_MEM        - Memory allocation error
 
-+  SZ_ERROR_PARAM      - Incorrect paramater
 
-+  SZ_ERROR_OUTPUT_EOF - output buffer overflow
 
-+  SZ_ERROR_THREAD     - errors in multithreading functions (only for Mt version)
 
-+*/
 
-+
 
-+SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
 
-+    const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
 
-+    ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);
 
-+
 
-+#ifdef __cplusplus
 
-+}
 
-+#endif
 
-+
 
-+#endif
 
---- /dev/null
 
-+++ b/include/linux/lzma/Types.h
 
-@@ -0,0 +1,226 @@
 
-+/* Types.h -- Basic types
 
-+2009-11-23 : Igor Pavlov : Public domain */
 
-+
 
-+#ifndef __7Z_TYPES_H
 
-+#define __7Z_TYPES_H
 
-+
 
-+#include <stddef.h>
 
-+
 
-+#ifdef _WIN32
 
-+#include <windows.h>
 
-+#endif
 
-+
 
-+#ifndef EXTERN_C_BEGIN
 
-+#ifdef __cplusplus
 
-+#define EXTERN_C_BEGIN extern "C" {
 
-+#define EXTERN_C_END }
 
-+#else
 
-+#define EXTERN_C_BEGIN
 
-+#define EXTERN_C_END
 
-+#endif
 
-+#endif
 
-+
 
-+EXTERN_C_BEGIN
 
-+
 
-+#define SZ_OK 0
 
-+
 
-+#define SZ_ERROR_DATA 1
 
-+#define SZ_ERROR_MEM 2
 
-+#define SZ_ERROR_CRC 3
 
-+#define SZ_ERROR_UNSUPPORTED 4
 
-+#define SZ_ERROR_PARAM 5
 
-+#define SZ_ERROR_INPUT_EOF 6
 
-+#define SZ_ERROR_OUTPUT_EOF 7
 
-+#define SZ_ERROR_READ 8
 
-+#define SZ_ERROR_WRITE 9
 
-+#define SZ_ERROR_PROGRESS 10
 
-+#define SZ_ERROR_FAIL 11
 
-+#define SZ_ERROR_THREAD 12
 
-+
 
-+#define SZ_ERROR_ARCHIVE 16
 
-+#define SZ_ERROR_NO_ARCHIVE 17
 
-+
 
-+typedef int SRes;
 
-+
 
-+#ifdef _WIN32
 
-+typedef DWORD WRes;
 
-+#else
 
-+typedef int WRes;
 
-+#endif
 
-+
 
-+#ifndef RINOK
 
-+#define RINOK(x) { int __result__ = (x); if (__result__ != 0) return __result__; }
 
-+#endif
 
-+
 
-+typedef unsigned char Byte;
 
-+typedef short Int16;
 
-+typedef unsigned short UInt16;
 
-+
 
-+#ifdef _LZMA_UINT32_IS_ULONG
 
-+typedef long Int32;
 
-+typedef unsigned long UInt32;
 
-+#else
 
-+typedef int Int32;
 
-+typedef unsigned int UInt32;
 
-+#endif
 
-+
 
-+#ifdef _SZ_NO_INT_64
 
-+
 
-+/* define _SZ_NO_INT_64, if your compiler doesn't support 64-bit integers.
 
-+   NOTES: Some code will work incorrectly in that case! */
 
-+
 
-+typedef long Int64;
 
-+typedef unsigned long UInt64;
 
-+
 
-+#else
 
-+
 
-+#if defined(_MSC_VER) || defined(__BORLANDC__)
 
-+typedef __int64 Int64;
 
-+typedef unsigned __int64 UInt64;
 
-+#else
 
-+typedef long long int Int64;
 
-+typedef unsigned long long int UInt64;
 
-+#endif
 
-+
 
-+#endif
 
-+
 
-+#ifdef _LZMA_NO_SYSTEM_SIZE_T
 
-+typedef UInt32 SizeT;
 
-+#else
 
-+typedef size_t SizeT;
 
-+#endif
 
-+
 
-+typedef int Bool;
 
-+#define True 1
 
-+#define False 0
 
-+
 
-+
 
-+#ifdef _WIN32
 
-+#define MY_STD_CALL __stdcall
 
-+#else
 
-+#define MY_STD_CALL
 
-+#endif
 
-+
 
-+#ifdef _MSC_VER
 
-+
 
-+#if _MSC_VER >= 1300
 
-+#define MY_NO_INLINE __declspec(noinline)
 
-+#else
 
-+#define MY_NO_INLINE
 
-+#endif
 
-+
 
-+#define MY_CDECL __cdecl
 
-+#define MY_FAST_CALL __fastcall
 
-+
 
-+#else
 
-+
 
-+#define MY_CDECL
 
-+#define MY_FAST_CALL
 
-+
 
-+#endif
 
-+
 
-+
 
-+/* The following interfaces use first parameter as pointer to structure */
 
-+
 
-+typedef struct
 
-+{
 
-+  SRes (*Read)(void *p, void *buf, size_t *size);
 
-+    /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.
 
-+       (output(*size) < input(*size)) is allowed */
 
-+} ISeqInStream;
 
-+
 
-+/* it can return SZ_ERROR_INPUT_EOF */
 
-+SRes SeqInStream_Read(ISeqInStream *stream, void *buf, size_t size);
 
-+SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorType);
 
-+SRes SeqInStream_ReadByte(ISeqInStream *stream, Byte *buf);
 
-+
 
-+typedef struct
 
-+{
 
-+  size_t (*Write)(void *p, const void *buf, size_t size);
 
-+    /* Returns: result - the number of actually written bytes.
 
-+       (result < size) means error */
 
-+} ISeqOutStream;
 
-+
 
-+typedef enum
 
-+{
 
-+  SZ_SEEK_SET = 0,
 
-+  SZ_SEEK_CUR = 1,
 
-+  SZ_SEEK_END = 2
 
-+} ESzSeek;
 
-+
 
-+typedef struct
 
-+{
 
-+  SRes (*Read)(void *p, void *buf, size_t *size);  /* same as ISeqInStream::Read */
 
-+  SRes (*Seek)(void *p, Int64 *pos, ESzSeek origin);
 
-+} ISeekInStream;
 
-+
 
-+typedef struct
 
-+{
 
-+  SRes (*Look)(void *p, void **buf, size_t *size);
 
-+    /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.
 
-+       (output(*size) > input(*size)) is not allowed
 
-+       (output(*size) < input(*size)) is allowed */
 
-+  SRes (*Skip)(void *p, size_t offset);
 
-+    /* offset must be <= output(*size) of Look */
 
-+
 
-+  SRes (*Read)(void *p, void *buf, size_t *size);
 
-+    /* reads directly (without buffer). It's same as ISeqInStream::Read */
 
-+  SRes (*Seek)(void *p, Int64 *pos, ESzSeek origin);
 
-+} ILookInStream;
 
-+
 
-+SRes LookInStream_LookRead(ILookInStream *stream, void *buf, size_t *size);
 
-+SRes LookInStream_SeekTo(ILookInStream *stream, UInt64 offset);
 
-+
 
-+/* reads via ILookInStream::Read */
 
-+SRes LookInStream_Read2(ILookInStream *stream, void *buf, size_t size, SRes errorType);
 
-+SRes LookInStream_Read(ILookInStream *stream, void *buf, size_t size);
 
-+
 
-+#define LookToRead_BUF_SIZE (1 << 14)
 
-+
 
-+typedef struct
 
-+{
 
-+  ILookInStream s;
 
-+  ISeekInStream *realStream;
 
-+  size_t pos;
 
-+  size_t size;
 
-+  Byte buf[LookToRead_BUF_SIZE];
 
-+} CLookToRead;
 
-+
 
-+void LookToRead_CreateVTable(CLookToRead *p, int lookahead);
 
-+void LookToRead_Init(CLookToRead *p);
 
-+
 
-+typedef struct
 
-+{
 
-+  ISeqInStream s;
 
-+  ILookInStream *realStream;
 
-+} CSecToLook;
 
-+
 
-+void SecToLook_CreateVTable(CSecToLook *p);
 
-+
 
-+typedef struct
 
-+{
 
-+  ISeqInStream s;
 
-+  ILookInStream *realStream;
 
-+} CSecToRead;
 
-+
 
-+void SecToRead_CreateVTable(CSecToRead *p);
 
-+
 
-+typedef struct
 
-+{
 
-+  SRes (*Progress)(void *p, UInt64 inSize, UInt64 outSize);
 
-+    /* Returns: result. (result != SZ_OK) means break.
 
-+       Value (UInt64)(Int64)-1 for size means unknown value. */
 
-+} ICompressProgress;
 
-+
 
-+typedef struct
 
-+{
 
-+  void *(*Alloc)(void *p, size_t size);
 
-+  void (*Free)(void *p, void *address); /* address can be 0 */
 
-+} ISzAlloc;
 
-+
 
-+#define IAlloc_Alloc(p, size) (p)->Alloc((p), size)
 
-+#define IAlloc_Free(p, a) (p)->Free((p), a)
 
-+
 
-+EXTERN_C_END
 
-+
 
-+#endif
 
---- a/lib/Kconfig
 
-+++ b/lib/Kconfig
 
-@@ -118,6 +118,12 @@ config LZO_DECOMPRESS
 
- 
- source "lib/xz/Kconfig"
 
- 
-+config LZMA_COMPRESS
 
-+    tristate
 
-+
 
-+config LZMA_DECOMPRESS
 
-+    tristate
 
-+
 
- #
 
- # These all provide a common interface (hence the apparent duplication with
 
- # ZLIB_INFLATE; DECOMPRESS_GZIP is just a wrapper.)
 
---- a/lib/Makefile
 
-+++ b/lib/Makefile
 
-@@ -2,6 +2,16 @@
 
- # Makefile for some libs needed in the kernel.
 
- #
 
- 
-+ifdef CONFIG_JFFS2_ZLIB
 
-+	CONFIG_ZLIB_INFLATE:=y
 
-+	CONFIG_ZLIB_DEFLATE:=y
 
-+endif
 
-+
 
-+ifdef CONFIG_JFFS2_LZMA
 
-+	CONFIG_LZMA_DECOMPRESS:=y
 
-+	CONFIG_LZMA_COMPRESS:=y
 
-+endif
 
-+
 
- ifdef CONFIG_FUNCTION_TRACER
 
- ORIG_CFLAGS := $(KBUILD_CFLAGS)
 
- KBUILD_CFLAGS = $(subst -pg,,$(ORIG_CFLAGS))
 
-@@ -73,6 +83,8 @@ obj-$(CONFIG_LZO_COMPRESS) += lzo/
 
- obj-$(CONFIG_LZO_DECOMPRESS) += lzo/
 
- obj-$(CONFIG_XZ_DEC) += xz/
 
- obj-$(CONFIG_RAID6_PQ) += raid6/
 
-+obj-$(CONFIG_LZMA_COMPRESS) += lzma/
 
-+obj-$(CONFIG_LZMA_DECOMPRESS) += lzma/
 
- 
- lib-$(CONFIG_DECOMPRESS_GZIP) += decompress_inflate.o
 
- lib-$(CONFIG_DECOMPRESS_BZIP2) += decompress_bunzip2.o
 
---- /dev/null
 
-+++ b/lib/lzma/LzFind.c
 
-@@ -0,0 +1,761 @@
 
-+/* LzFind.c -- Match finder for LZ algorithms
 
-+2009-04-22 : Igor Pavlov : Public domain */
 
-+
 
-+#include <string.h>
 
-+
 
-+#include "LzFind.h"
 
-+#include "LzHash.h"
 
-+
 
-+#define kEmptyHashValue 0
 
-+#define kMaxValForNormalize ((UInt32)0xFFFFFFFF)
 
-+#define kNormalizeStepMin (1 << 10) /* it must be power of 2 */
 
-+#define kNormalizeMask (~(kNormalizeStepMin - 1))
 
-+#define kMaxHistorySize ((UInt32)3 << 30)
 
-+
 
-+#define kStartMaxLen 3
 
-+
 
-+static void LzInWindow_Free(CMatchFinder *p, ISzAlloc *alloc)
 
-+{
 
-+  if (!p->directInput)
 
-+  {
 
-+    alloc->Free(alloc, p->bufferBase);
 
-+    p->bufferBase = 0;
 
-+  }
 
-+}
 
-+
 
-+/* keepSizeBefore + keepSizeAfter + keepSizeReserv must be < 4G) */
 
-+
 
-+static int LzInWindow_Create(CMatchFinder *p, UInt32 keepSizeReserv, ISzAlloc *alloc)
 
-+{
 
-+  UInt32 blockSize = p->keepSizeBefore + p->keepSizeAfter + keepSizeReserv;
 
-+  if (p->directInput)
 
-+  {
 
-+    p->blockSize = blockSize;
 
-+    return 1;
 
-+  }
 
-+  if (p->bufferBase == 0 || p->blockSize != blockSize)
 
-+  {
 
-+    LzInWindow_Free(p, alloc);
 
-+    p->blockSize = blockSize;
 
-+    p->bufferBase = (Byte *)alloc->Alloc(alloc, (size_t)blockSize);
 
-+  }
 
-+  return (p->bufferBase != 0);
 
-+}
 
-+
 
-+Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p) { return p->buffer; }
 
-+Byte MatchFinder_GetIndexByte(CMatchFinder *p, Int32 index) { return p->buffer[index]; }
 
-+
 
-+UInt32 MatchFinder_GetNumAvailableBytes(CMatchFinder *p) { return p->streamPos - p->pos; }
 
-+
 
-+void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue)
 
-+{
 
-+  p->posLimit -= subValue;
 
-+  p->pos -= subValue;
 
-+  p->streamPos -= subValue;
 
-+}
 
-+
 
-+static void MatchFinder_ReadBlock(CMatchFinder *p)
 
-+{
 
-+  if (p->streamEndWasReached || p->result != SZ_OK)
 
-+    return;
 
-+  if (p->directInput)
 
-+  {
 
-+    UInt32 curSize = 0xFFFFFFFF - p->streamPos;
 
-+    if (curSize > p->directInputRem)
 
-+      curSize = (UInt32)p->directInputRem;
 
-+    p->directInputRem -= curSize;
 
-+    p->streamPos += curSize;
 
-+    if (p->directInputRem == 0)
 
-+      p->streamEndWasReached = 1;
 
-+    return;
 
-+  }
 
-+  for (;;)
 
-+  {
 
-+    Byte *dest = p->buffer + (p->streamPos - p->pos);
 
-+    size_t size = (p->bufferBase + p->blockSize - dest);
 
-+    if (size == 0)
 
-+      return;
 
-+    p->result = p->stream->Read(p->stream, dest, &size);
 
-+    if (p->result != SZ_OK)
 
-+      return;
 
-+    if (size == 0)
 
-+    {
 
-+      p->streamEndWasReached = 1;
 
-+      return;
 
-+    }
 
-+    p->streamPos += (UInt32)size;
 
-+    if (p->streamPos - p->pos > p->keepSizeAfter)
 
-+      return;
 
-+  }
 
-+}
 
-+
 
-+void MatchFinder_MoveBlock(CMatchFinder *p)
 
-+{
 
-+  memmove(p->bufferBase,
 
-+    p->buffer - p->keepSizeBefore,
 
-+    (size_t)(p->streamPos - p->pos + p->keepSizeBefore));
 
-+  p->buffer = p->bufferBase + p->keepSizeBefore;
 
-+}
 
-+
 
-+int MatchFinder_NeedMove(CMatchFinder *p)
 
-+{
 
-+  if (p->directInput)
 
-+    return 0;
 
-+  /* if (p->streamEndWasReached) return 0; */
 
-+  return ((size_t)(p->bufferBase + p->blockSize - p->buffer) <= p->keepSizeAfter);
 
-+}
 
-+
 
-+void MatchFinder_ReadIfRequired(CMatchFinder *p)
 
-+{
 
-+  if (p->streamEndWasReached)
 
-+    return;
 
-+  if (p->keepSizeAfter >= p->streamPos - p->pos)
 
-+    MatchFinder_ReadBlock(p);
 
-+}
 
-+
 
-+static void MatchFinder_CheckAndMoveAndRead(CMatchFinder *p)
 
-+{
 
-+  if (MatchFinder_NeedMove(p))
 
-+    MatchFinder_MoveBlock(p);
 
-+  MatchFinder_ReadBlock(p);
 
-+}
 
-+
 
-+static void MatchFinder_SetDefaultSettings(CMatchFinder *p)
 
-+{
 
-+  p->cutValue = 32;
 
-+  p->btMode = 1;
 
-+  p->numHashBytes = 4;
 
-+  p->bigHash = 0;
 
-+}
 
-+
 
-+#define kCrcPoly 0xEDB88320
 
-+
 
-+void MatchFinder_Construct(CMatchFinder *p)
 
-+{
 
-+  UInt32 i;
 
-+  p->bufferBase = 0;
 
-+  p->directInput = 0;
 
-+  p->hash = 0;
 
-+  MatchFinder_SetDefaultSettings(p);
 
-+
 
-+  for (i = 0; i < 256; i++)
 
-+  {
 
-+    UInt32 r = i;
 
-+    int j;
 
-+    for (j = 0; j < 8; j++)
 
-+      r = (r >> 1) ^ (kCrcPoly & ~((r & 1) - 1));
 
-+    p->crc[i] = r;
 
-+  }
 
-+}
 
-+
 
-+static void MatchFinder_FreeThisClassMemory(CMatchFinder *p, ISzAlloc *alloc)
 
-+{
 
-+  alloc->Free(alloc, p->hash);
 
-+  p->hash = 0;
 
-+}
 
-+
 
-+void MatchFinder_Free(CMatchFinder *p, ISzAlloc *alloc)
 
-+{
 
-+  MatchFinder_FreeThisClassMemory(p, alloc);
 
-+  LzInWindow_Free(p, alloc);
 
-+}
 
-+
 
-+static CLzRef* AllocRefs(UInt32 num, ISzAlloc *alloc)
 
-+{
 
-+  size_t sizeInBytes = (size_t)num * sizeof(CLzRef);
 
-+  if (sizeInBytes / sizeof(CLzRef) != num)
 
-+    return 0;
 
-+  return (CLzRef *)alloc->Alloc(alloc, sizeInBytes);
 
-+}
 
-+
 
-+int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
 
-+    UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
 
-+    ISzAlloc *alloc)
 
-+{
 
-+  UInt32 sizeReserv;
 
-+  if (historySize > kMaxHistorySize)
 
-+  {
 
-+    MatchFinder_Free(p, alloc);
 
-+    return 0;
 
-+  }
 
-+  sizeReserv = historySize >> 1;
 
-+  if (historySize > ((UInt32)2 << 30))
 
-+    sizeReserv = historySize >> 2;
 
-+  sizeReserv += (keepAddBufferBefore + matchMaxLen + keepAddBufferAfter) / 2 + (1 << 19);
 
-+
 
-+  p->keepSizeBefore = historySize + keepAddBufferBefore + 1;
 
-+  p->keepSizeAfter = matchMaxLen + keepAddBufferAfter;
 
-+  /* we need one additional byte, since we use MoveBlock after pos++ and before dictionary using */
 
-+  if (LzInWindow_Create(p, sizeReserv, alloc))
 
-+  {
 
-+    UInt32 newCyclicBufferSize = historySize + 1;
 
-+    UInt32 hs;
 
-+    p->matchMaxLen = matchMaxLen;
 
-+    {
 
-+      p->fixedHashSize = 0;
 
-+      if (p->numHashBytes == 2)
 
-+        hs = (1 << 16) - 1;
 
-+      else
 
-+      {
 
-+        hs = historySize - 1;
 
-+        hs |= (hs >> 1);
 
-+        hs |= (hs >> 2);
 
-+        hs |= (hs >> 4);
 
-+        hs |= (hs >> 8);
 
-+        hs >>= 1;
 
-+        hs |= 0xFFFF; /* don't change it! It's required for Deflate */
 
-+        if (hs > (1 << 24))
 
-+        {
 
-+          if (p->numHashBytes == 3)
 
-+            hs = (1 << 24) - 1;
 
-+          else
 
-+            hs >>= 1;
 
-+        }
 
-+      }
 
-+      p->hashMask = hs;
 
-+      hs++;
 
-+      if (p->numHashBytes > 2) p->fixedHashSize += kHash2Size;
 
-+      if (p->numHashBytes > 3) p->fixedHashSize += kHash3Size;
 
-+      if (p->numHashBytes > 4) p->fixedHashSize += kHash4Size;
 
-+      hs += p->fixedHashSize;
 
-+    }
 
-+
 
-+    {
 
-+      UInt32 prevSize = p->hashSizeSum + p->numSons;
 
-+      UInt32 newSize;
 
-+      p->historySize = historySize;
 
-+      p->hashSizeSum = hs;
 
-+      p->cyclicBufferSize = newCyclicBufferSize;
 
-+      p->numSons = (p->btMode ? newCyclicBufferSize * 2 : newCyclicBufferSize);
 
-+      newSize = p->hashSizeSum + p->numSons;
 
-+      if (p->hash != 0 && prevSize == newSize)
 
-+        return 1;
 
-+      MatchFinder_FreeThisClassMemory(p, alloc);
 
-+      p->hash = AllocRefs(newSize, alloc);
 
-+      if (p->hash != 0)
 
-+      {
 
-+        p->son = p->hash + p->hashSizeSum;
 
-+        return 1;
 
-+      }
 
-+    }
 
-+  }
 
-+  MatchFinder_Free(p, alloc);
 
-+  return 0;
 
-+}
 
-+
 
-+static void MatchFinder_SetLimits(CMatchFinder *p)
 
-+{
 
-+  UInt32 limit = kMaxValForNormalize - p->pos;
 
-+  UInt32 limit2 = p->cyclicBufferSize - p->cyclicBufferPos;
 
-+  if (limit2 < limit)
 
-+    limit = limit2;
 
-+  limit2 = p->streamPos - p->pos;
 
-+  if (limit2 <= p->keepSizeAfter)
 
-+  {
 
-+    if (limit2 > 0)
 
-+      limit2 = 1;
 
-+  }
 
-+  else
 
-+    limit2 -= p->keepSizeAfter;
 
-+  if (limit2 < limit)
 
-+    limit = limit2;
 
-+  {
 
-+    UInt32 lenLimit = p->streamPos - p->pos;
 
-+    if (lenLimit > p->matchMaxLen)
 
-+      lenLimit = p->matchMaxLen;
 
-+    p->lenLimit = lenLimit;
 
-+  }
 
-+  p->posLimit = p->pos + limit;
 
-+}
 
-+
 
-+void MatchFinder_Init(CMatchFinder *p)
 
-+{
 
-+  UInt32 i;
 
-+  for (i = 0; i < p->hashSizeSum; i++)
 
-+    p->hash[i] = kEmptyHashValue;
 
-+  p->cyclicBufferPos = 0;
 
-+  p->buffer = p->bufferBase;
 
-+  p->pos = p->streamPos = p->cyclicBufferSize;
 
-+  p->result = SZ_OK;
 
-+  p->streamEndWasReached = 0;
 
-+  MatchFinder_ReadBlock(p);
 
-+  MatchFinder_SetLimits(p);
 
-+}
 
-+
 
-+static UInt32 MatchFinder_GetSubValue(CMatchFinder *p)
 
-+{
 
-+  return (p->pos - p->historySize - 1) & kNormalizeMask;
 
-+}
 
-+
 
-+void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, UInt32 numItems)
 
-+{
 
-+  UInt32 i;
 
-+  for (i = 0; i < numItems; i++)
 
-+  {
 
-+    UInt32 value = items[i];
 
-+    if (value <= subValue)
 
-+      value = kEmptyHashValue;
 
-+    else
 
-+      value -= subValue;
 
-+    items[i] = value;
 
-+  }
 
-+}
 
-+
 
-+static void MatchFinder_Normalize(CMatchFinder *p)
 
-+{
 
-+  UInt32 subValue = MatchFinder_GetSubValue(p);
 
-+  MatchFinder_Normalize3(subValue, p->hash, p->hashSizeSum + p->numSons);
 
-+  MatchFinder_ReduceOffsets(p, subValue);
 
-+}
 
-+
 
-+static void MatchFinder_CheckLimits(CMatchFinder *p)
 
-+{
 
-+  if (p->pos == kMaxValForNormalize)
 
-+    MatchFinder_Normalize(p);
 
-+  if (!p->streamEndWasReached && p->keepSizeAfter == p->streamPos - p->pos)
 
-+    MatchFinder_CheckAndMoveAndRead(p);
 
-+  if (p->cyclicBufferPos == p->cyclicBufferSize)
 
-+    p->cyclicBufferPos = 0;
 
-+  MatchFinder_SetLimits(p);
 
-+}
 
-+
 
-+static UInt32 * Hc_GetMatchesSpec(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
 
-+    UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue,
 
-+    UInt32 *distances, UInt32 maxLen)
 
-+{
 
-+  son[_cyclicBufferPos] = curMatch;
 
-+  for (;;)
 
-+  {
 
-+    UInt32 delta = pos - curMatch;
 
-+    if (cutValue-- == 0 || delta >= _cyclicBufferSize)
 
-+      return distances;
 
-+    {
 
-+      const Byte *pb = cur - delta;
 
-+      curMatch = son[_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)];
 
-+      if (pb[maxLen] == cur[maxLen] && *pb == *cur)
 
-+      {
 
-+        UInt32 len = 0;
 
-+        while (++len != lenLimit)
 
-+          if (pb[len] != cur[len])
 
-+            break;
 
-+        if (maxLen < len)
 
-+        {
 
-+          *distances++ = maxLen = len;
 
-+          *distances++ = delta - 1;
 
-+          if (len == lenLimit)
 
-+            return distances;
 
-+        }
 
-+      }
 
-+    }
 
-+  }
 
-+}
 
-+
 
-+UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
 
-+    UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue,
 
-+    UInt32 *distances, UInt32 maxLen)
 
-+{
 
-+  CLzRef *ptr0 = son + (_cyclicBufferPos << 1) + 1;
 
-+  CLzRef *ptr1 = son + (_cyclicBufferPos << 1);
 
-+  UInt32 len0 = 0, len1 = 0;
 
-+  for (;;)
 
-+  {
 
-+    UInt32 delta = pos - curMatch;
 
-+    if (cutValue-- == 0 || delta >= _cyclicBufferSize)
 
-+    {
 
-+      *ptr0 = *ptr1 = kEmptyHashValue;
 
-+      return distances;
 
-+    }
 
-+    {
 
-+      CLzRef *pair = son + ((_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1);
 
-+      const Byte *pb = cur - delta;
 
-+      UInt32 len = (len0 < len1 ? len0 : len1);
 
-+      if (pb[len] == cur[len])
 
-+      {
 
-+        if (++len != lenLimit && pb[len] == cur[len])
 
-+          while (++len != lenLimit)
 
-+            if (pb[len] != cur[len])
 
-+              break;
 
-+        if (maxLen < len)
 
-+        {
 
-+          *distances++ = maxLen = len;
 
-+          *distances++ = delta - 1;
 
-+          if (len == lenLimit)
 
-+          {
 
-+            *ptr1 = pair[0];
 
-+            *ptr0 = pair[1];
 
-+            return distances;
 
-+          }
 
-+        }
 
-+      }
 
-+      if (pb[len] < cur[len])
 
-+      {
 
-+        *ptr1 = curMatch;
 
-+        ptr1 = pair + 1;
 
-+        curMatch = *ptr1;
 
-+        len1 = len;
 
-+      }
 
-+      else
 
-+      {
 
-+        *ptr0 = curMatch;
 
-+        ptr0 = pair;
 
-+        curMatch = *ptr0;
 
-+        len0 = len;
 
-+      }
 
-+    }
 
-+  }
 
-+}
 
-+
 
-+static void SkipMatchesSpec(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
 
-+    UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue)
 
-+{
 
-+  CLzRef *ptr0 = son + (_cyclicBufferPos << 1) + 1;
 
-+  CLzRef *ptr1 = son + (_cyclicBufferPos << 1);
 
-+  UInt32 len0 = 0, len1 = 0;
 
-+  for (;;)
 
-+  {
 
-+    UInt32 delta = pos - curMatch;
 
-+    if (cutValue-- == 0 || delta >= _cyclicBufferSize)
 
-+    {
 
-+      *ptr0 = *ptr1 = kEmptyHashValue;
 
-+      return;
 
-+    }
 
-+    {
 
-+      CLzRef *pair = son + ((_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1);
 
-+      const Byte *pb = cur - delta;
 
-+      UInt32 len = (len0 < len1 ? len0 : len1);
 
-+      if (pb[len] == cur[len])
 
-+      {
 
-+        while (++len != lenLimit)
 
-+          if (pb[len] != cur[len])
 
-+            break;
 
-+        {
 
-+          if (len == lenLimit)
 
-+          {
 
-+            *ptr1 = pair[0];
 
-+            *ptr0 = pair[1];
 
-+            return;
 
-+          }
 
-+        }
 
-+      }
 
-+      if (pb[len] < cur[len])
 
-+      {
 
-+        *ptr1 = curMatch;
 
-+        ptr1 = pair + 1;
 
-+        curMatch = *ptr1;
 
-+        len1 = len;
 
-+      }
 
-+      else
 
-+      {
 
-+        *ptr0 = curMatch;
 
-+        ptr0 = pair;
 
-+        curMatch = *ptr0;
 
-+        len0 = len;
 
-+      }
 
-+    }
 
-+  }
 
-+}
 
-+
 
-+#define MOVE_POS \
 
-+  ++p->cyclicBufferPos; \
 
-+  p->buffer++; \
 
-+  if (++p->pos == p->posLimit) MatchFinder_CheckLimits(p);
 
-+
 
-+#define MOVE_POS_RET MOVE_POS return offset;
 
-+
 
-+static void MatchFinder_MovePos(CMatchFinder *p) { MOVE_POS; }
 
-+
 
-+#define GET_MATCHES_HEADER2(minLen, ret_op) \
 
-+  UInt32 lenLimit; UInt32 hashValue; const Byte *cur; UInt32 curMatch; \
 
-+  lenLimit = p->lenLimit; { if (lenLimit < minLen) { MatchFinder_MovePos(p); ret_op; }} \
 
-+  cur = p->buffer;
 
-+
 
-+#define GET_MATCHES_HEADER(minLen) GET_MATCHES_HEADER2(minLen, return 0)
 
-+#define SKIP_HEADER(minLen)        GET_MATCHES_HEADER2(minLen, continue)
 
-+
 
-+#define MF_PARAMS(p) p->pos, p->buffer, p->son, p->cyclicBufferPos, p->cyclicBufferSize, p->cutValue
 
-+
 
-+#define GET_MATCHES_FOOTER(offset, maxLen) \
 
-+  offset = (UInt32)(GetMatchesSpec1(lenLimit, curMatch, MF_PARAMS(p), \
 
-+  distances + offset, maxLen) - distances); MOVE_POS_RET;
 
-+
 
-+#define SKIP_FOOTER \
 
-+  SkipMatchesSpec(lenLimit, curMatch, MF_PARAMS(p)); MOVE_POS;
 
-+
 
-+static UInt32 Bt2_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
 
-+{
 
-+  UInt32 offset;
 
-+  GET_MATCHES_HEADER(2)
 
-+  HASH2_CALC;
 
-+  curMatch = p->hash[hashValue];
 
-+  p->hash[hashValue] = p->pos;
 
-+  offset = 0;
 
-+  GET_MATCHES_FOOTER(offset, 1)
 
-+}
 
-+
 
-+UInt32 Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
 
-+{
 
-+  UInt32 offset;
 
-+  GET_MATCHES_HEADER(3)
 
-+  HASH_ZIP_CALC;
 
-+  curMatch = p->hash[hashValue];
 
-+  p->hash[hashValue] = p->pos;
 
-+  offset = 0;
 
-+  GET_MATCHES_FOOTER(offset, 2)
 
-+}
 
-+
 
-+static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
 
-+{
 
-+  UInt32 hash2Value, delta2, maxLen, offset;
 
-+  GET_MATCHES_HEADER(3)
 
-+
 
-+  HASH3_CALC;
 
-+
 
-+  delta2 = p->pos - p->hash[hash2Value];
 
-+  curMatch = p->hash[kFix3HashSize + hashValue];
 
-+  
-+  p->hash[hash2Value] =
 
-+  p->hash[kFix3HashSize + hashValue] = p->pos;
 
-+
 
-+
 
-+  maxLen = 2;
 
-+  offset = 0;
 
-+  if (delta2 < p->cyclicBufferSize && *(cur - delta2) == *cur)
 
-+  {
 
-+    for (; maxLen != lenLimit; maxLen++)
 
-+      if (cur[(ptrdiff_t)maxLen - delta2] != cur[maxLen])
 
-+        break;
 
-+    distances[0] = maxLen;
 
-+    distances[1] = delta2 - 1;
 
-+    offset = 2;
 
-+    if (maxLen == lenLimit)
 
-+    {
 
-+      SkipMatchesSpec(lenLimit, curMatch, MF_PARAMS(p));
 
-+      MOVE_POS_RET;
 
-+    }
 
-+  }
 
-+  GET_MATCHES_FOOTER(offset, maxLen)
 
-+}
 
-+
 
-+static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
 
-+{
 
-+  UInt32 hash2Value, hash3Value, delta2, delta3, maxLen, offset;
 
-+  GET_MATCHES_HEADER(4)
 
-+
 
-+  HASH4_CALC;
 
-+
 
-+  delta2 = p->pos - p->hash[                hash2Value];
 
-+  delta3 = p->pos - p->hash[kFix3HashSize + hash3Value];
 
-+  curMatch = p->hash[kFix4HashSize + hashValue];
 
-+  
-+  p->hash[                hash2Value] =
 
-+  p->hash[kFix3HashSize + hash3Value] =
 
-+  p->hash[kFix4HashSize + hashValue] = p->pos;
 
-+
 
-+  maxLen = 1;
 
-+  offset = 0;
 
-+  if (delta2 < p->cyclicBufferSize && *(cur - delta2) == *cur)
 
-+  {
 
-+    distances[0] = maxLen = 2;
 
-+    distances[1] = delta2 - 1;
 
-+    offset = 2;
 
-+  }
 
-+  if (delta2 != delta3 && delta3 < p->cyclicBufferSize && *(cur - delta3) == *cur)
 
-+  {
 
-+    maxLen = 3;
 
-+    distances[offset + 1] = delta3 - 1;
 
-+    offset += 2;
 
-+    delta2 = delta3;
 
-+  }
 
-+  if (offset != 0)
 
-+  {
 
-+    for (; maxLen != lenLimit; maxLen++)
 
-+      if (cur[(ptrdiff_t)maxLen - delta2] != cur[maxLen])
 
-+        break;
 
-+    distances[offset - 2] = maxLen;
 
-+    if (maxLen == lenLimit)
 
-+    {
 
-+      SkipMatchesSpec(lenLimit, curMatch, MF_PARAMS(p));
 
-+      MOVE_POS_RET;
 
-+    }
 
-+  }
 
-+  if (maxLen < 3)
 
-+    maxLen = 3;
 
-+  GET_MATCHES_FOOTER(offset, maxLen)
 
-+}
 
-+
 
-+static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
 
-+{
 
-+  UInt32 hash2Value, hash3Value, delta2, delta3, maxLen, offset;
 
-+  GET_MATCHES_HEADER(4)
 
-+
 
-+  HASH4_CALC;
 
-+
 
-+  delta2 = p->pos - p->hash[                hash2Value];
 
-+  delta3 = p->pos - p->hash[kFix3HashSize + hash3Value];
 
-+  curMatch = p->hash[kFix4HashSize + hashValue];
 
-+
 
-+  p->hash[                hash2Value] =
 
-+  p->hash[kFix3HashSize + hash3Value] =
 
-+  p->hash[kFix4HashSize + hashValue] = p->pos;
 
-+
 
-+  maxLen = 1;
 
-+  offset = 0;
 
-+  if (delta2 < p->cyclicBufferSize && *(cur - delta2) == *cur)
 
-+  {
 
-+    distances[0] = maxLen = 2;
 
-+    distances[1] = delta2 - 1;
 
-+    offset = 2;
 
-+  }
 
-+  if (delta2 != delta3 && delta3 < p->cyclicBufferSize && *(cur - delta3) == *cur)
 
-+  {
 
-+    maxLen = 3;
 
-+    distances[offset + 1] = delta3 - 1;
 
-+    offset += 2;
 
-+    delta2 = delta3;
 
-+  }
 
-+  if (offset != 0)
 
-+  {
 
-+    for (; maxLen != lenLimit; maxLen++)
 
-+      if (cur[(ptrdiff_t)maxLen - delta2] != cur[maxLen])
 
-+        break;
 
-+    distances[offset - 2] = maxLen;
 
-+    if (maxLen == lenLimit)
 
-+    {
 
-+      p->son[p->cyclicBufferPos] = curMatch;
 
-+      MOVE_POS_RET;
 
-+    }
 
-+  }
 
-+  if (maxLen < 3)
 
-+    maxLen = 3;
 
-+  offset = (UInt32)(Hc_GetMatchesSpec(lenLimit, curMatch, MF_PARAMS(p),
 
-+    distances + offset, maxLen) - (distances));
 
-+  MOVE_POS_RET
 
-+}
 
-+
 
-+UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
 
-+{
 
-+  UInt32 offset;
 
-+  GET_MATCHES_HEADER(3)
 
-+  HASH_ZIP_CALC;
 
-+  curMatch = p->hash[hashValue];
 
-+  p->hash[hashValue] = p->pos;
 
-+  offset = (UInt32)(Hc_GetMatchesSpec(lenLimit, curMatch, MF_PARAMS(p),
 
-+    distances, 2) - (distances));
 
-+  MOVE_POS_RET
 
-+}
 
-+
 
-+static void Bt2_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
 
-+{
 
-+  do
 
-+  {
 
-+    SKIP_HEADER(2)
 
-+    HASH2_CALC;
 
-+    curMatch = p->hash[hashValue];
 
-+    p->hash[hashValue] = p->pos;
 
-+    SKIP_FOOTER
 
-+  }
 
-+  while (--num != 0);
 
-+}
 
-+
 
-+void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
 
-+{
 
-+  do
 
-+  {
 
-+    SKIP_HEADER(3)
 
-+    HASH_ZIP_CALC;
 
-+    curMatch = p->hash[hashValue];
 
-+    p->hash[hashValue] = p->pos;
 
-+    SKIP_FOOTER
 
-+  }
 
-+  while (--num != 0);
 
-+}
 
-+
 
-+static void Bt3_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
 
-+{
 
-+  do
 
-+  {
 
-+    UInt32 hash2Value;
 
-+    SKIP_HEADER(3)
 
-+    HASH3_CALC;
 
-+    curMatch = p->hash[kFix3HashSize + hashValue];
 
-+    p->hash[hash2Value] =
 
-+    p->hash[kFix3HashSize + hashValue] = p->pos;
 
-+    SKIP_FOOTER
 
-+  }
 
-+  while (--num != 0);
 
-+}
 
-+
 
-+static void Bt4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
 
-+{
 
-+  do
 
-+  {
 
-+    UInt32 hash2Value, hash3Value;
 
-+    SKIP_HEADER(4)
 
-+    HASH4_CALC;
 
-+    curMatch = p->hash[kFix4HashSize + hashValue];
 
-+    p->hash[                hash2Value] =
 
-+    p->hash[kFix3HashSize + hash3Value] = p->pos;
 
-+    p->hash[kFix4HashSize + hashValue] = p->pos;
 
-+    SKIP_FOOTER
 
-+  }
 
-+  while (--num != 0);
 
-+}
 
-+
 
-+static void Hc4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
 
-+{
 
-+  do
 
-+  {
 
-+    UInt32 hash2Value, hash3Value;
 
-+    SKIP_HEADER(4)
 
-+    HASH4_CALC;
 
-+    curMatch = p->hash[kFix4HashSize + hashValue];
 
-+    p->hash[                hash2Value] =
 
-+    p->hash[kFix3HashSize + hash3Value] =
 
-+    p->hash[kFix4HashSize + hashValue] = p->pos;
 
-+    p->son[p->cyclicBufferPos] = curMatch;
 
-+    MOVE_POS
 
-+  }
 
-+  while (--num != 0);
 
-+}
 
-+
 
-+void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
 
-+{
 
-+  do
 
-+  {
 
-+    SKIP_HEADER(3)
 
-+    HASH_ZIP_CALC;
 
-+    curMatch = p->hash[hashValue];
 
-+    p->hash[hashValue] = p->pos;
 
-+    p->son[p->cyclicBufferPos] = curMatch;
 
-+    MOVE_POS
 
-+  }
 
-+  while (--num != 0);
 
-+}
 
-+
 
-+void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder *vTable)
 
-+{
 
-+  vTable->Init = (Mf_Init_Func)MatchFinder_Init;
 
-+  vTable->GetIndexByte = (Mf_GetIndexByte_Func)MatchFinder_GetIndexByte;
 
-+  vTable->GetNumAvailableBytes = (Mf_GetNumAvailableBytes_Func)MatchFinder_GetNumAvailableBytes;
 
-+  vTable->GetPointerToCurrentPos = (Mf_GetPointerToCurrentPos_Func)MatchFinder_GetPointerToCurrentPos;
 
-+  if (!p->btMode)
 
-+  {
 
-+    vTable->GetMatches = (Mf_GetMatches_Func)Hc4_MatchFinder_GetMatches;
 
-+    vTable->Skip = (Mf_Skip_Func)Hc4_MatchFinder_Skip;
 
-+  }
 
-+  else if (p->numHashBytes == 2)
 
-+  {
 
-+    vTable->GetMatches = (Mf_GetMatches_Func)Bt2_MatchFinder_GetMatches;
 
-+    vTable->Skip = (Mf_Skip_Func)Bt2_MatchFinder_Skip;
 
-+  }
 
-+  else if (p->numHashBytes == 3)
 
-+  {
 
-+    vTable->GetMatches = (Mf_GetMatches_Func)Bt3_MatchFinder_GetMatches;
 
-+    vTable->Skip = (Mf_Skip_Func)Bt3_MatchFinder_Skip;
 
-+  }
 
-+  else
 
-+  {
 
-+    vTable->GetMatches = (Mf_GetMatches_Func)Bt4_MatchFinder_GetMatches;
 
-+    vTable->Skip = (Mf_Skip_Func)Bt4_MatchFinder_Skip;
 
-+  }
 
-+}
 
---- /dev/null
 
-+++ b/lib/lzma/LzmaDec.c
 
-@@ -0,0 +1,999 @@
 
-+/* LzmaDec.c -- LZMA Decoder
 
-+2009-09-20 : Igor Pavlov : Public domain */
 
-+
 
-+#include "LzmaDec.h"
 
-+
 
-+#include <string.h>
 
-+
 
-+#define kNumTopBits 24
 
-+#define kTopValue ((UInt32)1 << kNumTopBits)
 
-+
 
-+#define kNumBitModelTotalBits 11
 
-+#define kBitModelTotal (1 << kNumBitModelTotalBits)
 
-+#define kNumMoveBits 5
 
-+
 
-+#define RC_INIT_SIZE 5
 
-+
 
-+#define NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); }
 
-+
 
-+#define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)
 
-+#define UPDATE_0(p) range = bound; *(p) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
 
-+#define UPDATE_1(p) range -= bound; code -= bound; *(p) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits));
 
-+#define GET_BIT2(p, i, A0, A1) IF_BIT_0(p) \
 
-+  { UPDATE_0(p); i = (i + i); A0; } else \
 
-+  { UPDATE_1(p); i = (i + i) + 1; A1; }
 
-+#define GET_BIT(p, i) GET_BIT2(p, i, ; , ;)
 
-+
 
-+#define TREE_GET_BIT(probs, i) { GET_BIT((probs + i), i); }
 
-+#define TREE_DECODE(probs, limit, i) \
 
-+  { i = 1; do { TREE_GET_BIT(probs, i); } while (i < limit); i -= limit; }
 
-+
 
-+/* #define _LZMA_SIZE_OPT */
 
-+
 
-+#ifdef _LZMA_SIZE_OPT
 
-+#define TREE_6_DECODE(probs, i) TREE_DECODE(probs, (1 << 6), i)
 
-+#else
 
-+#define TREE_6_DECODE(probs, i) \
 
-+  { i = 1; \
 
-+  TREE_GET_BIT(probs, i); \
 
-+  TREE_GET_BIT(probs, i); \
 
-+  TREE_GET_BIT(probs, i); \
 
-+  TREE_GET_BIT(probs, i); \
 
-+  TREE_GET_BIT(probs, i); \
 
-+  TREE_GET_BIT(probs, i); \
 
-+  i -= 0x40; }
 
-+#endif
 
-+
 
-+#define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_ERROR; range <<= 8; code = (code << 8) | (*buf++); }
 
-+
 
-+#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)
 
-+#define UPDATE_0_CHECK range = bound;
 
-+#define UPDATE_1_CHECK range -= bound; code -= bound;
 
-+#define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \
 
-+  { UPDATE_0_CHECK; i = (i + i); A0; } else \
 
-+  { UPDATE_1_CHECK; i = (i + i) + 1; A1; }
 
-+#define GET_BIT_CHECK(p, i) GET_BIT2_CHECK(p, i, ; , ;)
 
-+#define TREE_DECODE_CHECK(probs, limit, i) \
 
-+  { i = 1; do { GET_BIT_CHECK(probs + i, i) } while (i < limit); i -= limit; }
 
-+
 
-+
 
-+#define kNumPosBitsMax 4
 
-+#define kNumPosStatesMax (1 << kNumPosBitsMax)
 
-+
 
-+#define kLenNumLowBits 3
 
-+#define kLenNumLowSymbols (1 << kLenNumLowBits)
 
-+#define kLenNumMidBits 3
 
-+#define kLenNumMidSymbols (1 << kLenNumMidBits)
 
-+#define kLenNumHighBits 8
 
-+#define kLenNumHighSymbols (1 << kLenNumHighBits)
 
-+
 
-+#define LenChoice 0
 
-+#define LenChoice2 (LenChoice + 1)
 
-+#define LenLow (LenChoice2 + 1)
 
-+#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))
 
-+#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
 
-+#define kNumLenProbs (LenHigh + kLenNumHighSymbols)
 
-+
 
-+
 
-+#define kNumStates 12
 
-+#define kNumLitStates 7
 
-+
 
-+#define kStartPosModelIndex 4
 
-+#define kEndPosModelIndex 14
 
-+#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
 
-+
 
-+#define kNumPosSlotBits 6
 
-+#define kNumLenToPosStates 4
 
-+
 
-+#define kNumAlignBits 4
 
-+#define kAlignTableSize (1 << kNumAlignBits)
 
-+
 
-+#define kMatchMinLen 2
 
-+#define kMatchSpecLenStart (kMatchMinLen + kLenNumLowSymbols + kLenNumMidSymbols + kLenNumHighSymbols)
 
-+
 
-+#define IsMatch 0
 
-+#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))
 
-+#define IsRepG0 (IsRep + kNumStates)
 
-+#define IsRepG1 (IsRepG0 + kNumStates)
 
-+#define IsRepG2 (IsRepG1 + kNumStates)
 
-+#define IsRep0Long (IsRepG2 + kNumStates)
 
-+#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))
 
-+#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
 
-+#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)
 
-+#define LenCoder (Align + kAlignTableSize)
 
-+#define RepLenCoder (LenCoder + kNumLenProbs)
 
-+#define Literal (RepLenCoder + kNumLenProbs)
 
-+
 
-+#define LZMA_BASE_SIZE 1846
 
-+#define LZMA_LIT_SIZE 768
 
-+
 
-+#define LzmaProps_GetNumProbs(p) ((UInt32)LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((p)->lc + (p)->lp)))
 
-+
 
-+#if Literal != LZMA_BASE_SIZE
 
-+StopCompilingDueBUG
 
-+#endif
 
-+
 
-+#define LZMA_DIC_MIN (1 << 12)
 
-+
 
-+/* First LZMA-symbol is always decoded.
 
-+And it decodes new LZMA-symbols while (buf < bufLimit), but "buf" is without last normalization
 
-+Out:
 
-+  Result:
 
-+    SZ_OK - OK
 
-+    SZ_ERROR_DATA - Error
 
-+  p->remainLen:
 
-+    < kMatchSpecLenStart : normal remain
 
-+    = kMatchSpecLenStart : finished
 
-+    = kMatchSpecLenStart + 1 : Flush marker
 
-+    = kMatchSpecLenStart + 2 : State Init Marker
 
-+*/
 
-+
 
-+static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
 
-+{
 
-+  CLzmaProb *probs = p->probs;
 
-+
 
-+  unsigned state = p->state;
 
-+  UInt32 rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3];
 
-+  unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;
 
-+  unsigned lpMask = ((unsigned)1 << (p->prop.lp)) - 1;
 
-+  unsigned lc = p->prop.lc;
 
-+
 
-+  Byte *dic = p->dic;
 
-+  SizeT dicBufSize = p->dicBufSize;
 
-+  SizeT dicPos = p->dicPos;
 
-+  
-+  UInt32 processedPos = p->processedPos;
 
-+  UInt32 checkDicSize = p->checkDicSize;
 
-+  unsigned len = 0;
 
-+
 
-+  const Byte *buf = p->buf;
 
-+  UInt32 range = p->range;
 
-+  UInt32 code = p->code;
 
-+
 
-+  do
 
-+  {
 
-+    CLzmaProb *prob;
 
-+    UInt32 bound;
 
-+    unsigned ttt;
 
-+    unsigned posState = processedPos & pbMask;
 
-+
 
-+    prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
 
-+    IF_BIT_0(prob)
 
-+    {
 
-+      unsigned symbol;
 
-+      UPDATE_0(prob);
 
-+      prob = probs + Literal;
 
-+      if (checkDicSize != 0 || processedPos != 0)
 
-+        prob += (LZMA_LIT_SIZE * (((processedPos & lpMask) << lc) +
 
-+        (dic[(dicPos == 0 ? dicBufSize : dicPos) - 1] >> (8 - lc))));
 
-+
 
-+      if (state < kNumLitStates)
 
-+      {
 
-+        state -= (state < 4) ? state : 3;
 
-+        symbol = 1;
 
-+        do { GET_BIT(prob + symbol, symbol) } while (symbol < 0x100);
 
-+      }
 
-+      else
 
-+      {
 
-+        unsigned matchByte = p->dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
 
-+        unsigned offs = 0x100;
 
-+        state -= (state < 10) ? 3 : 6;
 
-+        symbol = 1;
 
-+        do
 
-+        {
 
-+          unsigned bit;
 
-+          CLzmaProb *probLit;
 
-+          matchByte <<= 1;
 
-+          bit = (matchByte & offs);
 
-+          probLit = prob + offs + bit + symbol;
 
-+          GET_BIT2(probLit, symbol, offs &= ~bit, offs &= bit)
 
-+        }
 
-+        while (symbol < 0x100);
 
-+      }
 
-+      dic[dicPos++] = (Byte)symbol;
 
-+      processedPos++;
 
-+      continue;
 
-+    }
 
-+    else
 
-+    {
 
-+      UPDATE_1(prob);
 
-+      prob = probs + IsRep + state;
 
-+      IF_BIT_0(prob)
 
-+      {
 
-+        UPDATE_0(prob);
 
-+        state += kNumStates;
 
-+        prob = probs + LenCoder;
 
-+      }
 
-+      else
 
-+      {
 
-+        UPDATE_1(prob);
 
-+        if (checkDicSize == 0 && processedPos == 0)
 
-+          return SZ_ERROR_DATA;
 
-+        prob = probs + IsRepG0 + state;
 
-+        IF_BIT_0(prob)
 
-+        {
 
-+          UPDATE_0(prob);
 
-+          prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState;
 
-+          IF_BIT_0(prob)
 
-+          {
 
-+            UPDATE_0(prob);
 
-+            dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
 
-+            dicPos++;
 
-+            processedPos++;
 
-+            state = state < kNumLitStates ? 9 : 11;
 
-+            continue;
 
-+          }
 
-+          UPDATE_1(prob);
 
-+        }
 
-+        else
 
-+        {
 
-+          UInt32 distance;
 
-+          UPDATE_1(prob);
 
-+          prob = probs + IsRepG1 + state;
 
-+          IF_BIT_0(prob)
 
-+          {
 
-+            UPDATE_0(prob);
 
-+            distance = rep1;
 
-+          }
 
-+          else
 
-+          {
 
-+            UPDATE_1(prob);
 
-+            prob = probs + IsRepG2 + state;
 
-+            IF_BIT_0(prob)
 
-+            {
 
-+              UPDATE_0(prob);
 
-+              distance = rep2;
 
-+            }
 
-+            else
 
-+            {
 
-+              UPDATE_1(prob);
 
-+              distance = rep3;
 
-+              rep3 = rep2;
 
-+            }
 
-+            rep2 = rep1;
 
-+          }
 
-+          rep1 = rep0;
 
-+          rep0 = distance;
 
-+        }
 
-+        state = state < kNumLitStates ? 8 : 11;
 
-+        prob = probs + RepLenCoder;
 
-+      }
 
-+      {
 
-+        unsigned limit, offset;
 
-+        CLzmaProb *probLen = prob + LenChoice;
 
-+        IF_BIT_0(probLen)
 
-+        {
 
-+          UPDATE_0(probLen);
 
-+          probLen = prob + LenLow + (posState << kLenNumLowBits);
 
-+          offset = 0;
 
-+          limit = (1 << kLenNumLowBits);
 
-+        }
 
-+        else
 
-+        {
 
-+          UPDATE_1(probLen);
 
-+          probLen = prob + LenChoice2;
 
-+          IF_BIT_0(probLen)
 
-+          {
 
-+            UPDATE_0(probLen);
 
-+            probLen = prob + LenMid + (posState << kLenNumMidBits);
 
-+            offset = kLenNumLowSymbols;
 
-+            limit = (1 << kLenNumMidBits);
 
-+          }
 
-+          else
 
-+          {
 
-+            UPDATE_1(probLen);
 
-+            probLen = prob + LenHigh;
 
-+            offset = kLenNumLowSymbols + kLenNumMidSymbols;
 
-+            limit = (1 << kLenNumHighBits);
 
-+          }
 
-+        }
 
-+        TREE_DECODE(probLen, limit, len);
 
-+        len += offset;
 
-+      }
 
-+
 
-+      if (state >= kNumStates)
 
-+      {
 
-+        UInt32 distance;
 
-+        prob = probs + PosSlot +
 
-+            ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
 
-+        TREE_6_DECODE(prob, distance);
 
-+        if (distance >= kStartPosModelIndex)
 
-+        {
 
-+          unsigned posSlot = (unsigned)distance;
 
-+          int numDirectBits = (int)(((distance >> 1) - 1));
 
-+          distance = (2 | (distance & 1));
 
-+          if (posSlot < kEndPosModelIndex)
 
-+          {
 
-+            distance <<= numDirectBits;
 
-+            prob = probs + SpecPos + distance - posSlot - 1;
 
-+            {
 
-+              UInt32 mask = 1;
 
-+              unsigned i = 1;
 
-+              do
 
-+              {
 
-+                GET_BIT2(prob + i, i, ; , distance |= mask);
 
-+                mask <<= 1;
 
-+              }
 
-+              while (--numDirectBits != 0);
 
-+            }
 
-+          }
 
-+          else
 
-+          {
 
-+            numDirectBits -= kNumAlignBits;
 
-+            do
 
-+            {
 
-+              NORMALIZE
 
-+              range >>= 1;
 
-+              
-+              {
 
-+                UInt32 t;
 
-+                code -= range;
 
-+                t = (0 - ((UInt32)code >> 31)); /* (UInt32)((Int32)code >> 31) */
 
-+                distance = (distance << 1) + (t + 1);
 
-+                code += range & t;
 
-+              }
 
-+              /*
 
-+              distance <<= 1;
 
-+              if (code >= range)
 
-+              {
 
-+                code -= range;
 
-+                distance |= 1;
 
-+              }
 
-+              */
 
-+            }
 
-+            while (--numDirectBits != 0);
 
-+            prob = probs + Align;
 
-+            distance <<= kNumAlignBits;
 
-+            {
 
-+              unsigned i = 1;
 
-+              GET_BIT2(prob + i, i, ; , distance |= 1);
 
-+              GET_BIT2(prob + i, i, ; , distance |= 2);
 
-+              GET_BIT2(prob + i, i, ; , distance |= 4);
 
-+              GET_BIT2(prob + i, i, ; , distance |= 8);
 
-+            }
 
-+            if (distance == (UInt32)0xFFFFFFFF)
 
-+            {
 
-+              len += kMatchSpecLenStart;
 
-+              state -= kNumStates;
 
-+              break;
 
-+            }
 
-+          }
 
-+        }
 
-+        rep3 = rep2;
 
-+        rep2 = rep1;
 
-+        rep1 = rep0;
 
-+        rep0 = distance + 1;
 
-+        if (checkDicSize == 0)
 
-+        {
 
-+          if (distance >= processedPos)
 
-+            return SZ_ERROR_DATA;
 
-+        }
 
-+        else if (distance >= checkDicSize)
 
-+          return SZ_ERROR_DATA;
 
-+        state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;
 
-+      }
 
-+
 
-+      len += kMatchMinLen;
 
-+
 
-+      if (limit == dicPos)
 
-+        return SZ_ERROR_DATA;
 
-+      {
 
-+        SizeT rem = limit - dicPos;
 
-+        unsigned curLen = ((rem < len) ? (unsigned)rem : len);
 
-+        SizeT pos = (dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0);
 
-+
 
-+        processedPos += curLen;
 
-+
 
-+        len -= curLen;
 
-+        if (pos + curLen <= dicBufSize)
 
-+        {
 
-+          Byte *dest = dic + dicPos;
 
-+          ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;
 
-+          const Byte *lim = dest + curLen;
 
-+          dicPos += curLen;
 
-+          do
 
-+            *(dest) = (Byte)*(dest + src);
 
-+          while (++dest != lim);
 
-+        }
 
-+        else
 
-+        {
 
-+          do
 
-+          {
 
-+            dic[dicPos++] = dic[pos];
 
-+            if (++pos == dicBufSize)
 
-+              pos = 0;
 
-+          }
 
-+          while (--curLen != 0);
 
-+        }
 
-+      }
 
-+    }
 
-+  }
 
-+  while (dicPos < limit && buf < bufLimit);
 
-+  NORMALIZE;
 
-+  p->buf = buf;
 
-+  p->range = range;
 
-+  p->code = code;
 
-+  p->remainLen = len;
 
-+  p->dicPos = dicPos;
 
-+  p->processedPos = processedPos;
 
-+  p->reps[0] = rep0;
 
-+  p->reps[1] = rep1;
 
-+  p->reps[2] = rep2;
 
-+  p->reps[3] = rep3;
 
-+  p->state = state;
 
-+
 
-+  return SZ_OK;
 
-+}
 
-+
 
-+static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
 
-+{
 
-+  if (p->remainLen != 0 && p->remainLen < kMatchSpecLenStart)
 
-+  {
 
-+    Byte *dic = p->dic;
 
-+    SizeT dicPos = p->dicPos;
 
-+    SizeT dicBufSize = p->dicBufSize;
 
-+    unsigned len = p->remainLen;
 
-+    UInt32 rep0 = p->reps[0];
 
-+    if (limit - dicPos < len)
 
-+      len = (unsigned)(limit - dicPos);
 
-+
 
-+    if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len)
 
-+      p->checkDicSize = p->prop.dicSize;
 
-+
 
-+    p->processedPos += len;
 
-+    p->remainLen -= len;
 
-+    while (len-- != 0)
 
-+    {
 
-+      dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
 
-+      dicPos++;
 
-+    }
 
-+    p->dicPos = dicPos;
 
-+  }
 
-+}
 
-+
 
-+static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
 
-+{
 
-+  do
 
-+  {
 
-+    SizeT limit2 = limit;
 
-+    if (p->checkDicSize == 0)
 
-+    {
 
-+      UInt32 rem = p->prop.dicSize - p->processedPos;
 
-+      if (limit - p->dicPos > rem)
 
-+        limit2 = p->dicPos + rem;
 
-+    }
 
-+    RINOK(LzmaDec_DecodeReal(p, limit2, bufLimit));
 
-+    if (p->processedPos >= p->prop.dicSize)
 
-+      p->checkDicSize = p->prop.dicSize;
 
-+    LzmaDec_WriteRem(p, limit);
 
-+  }
 
-+  while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart);
 
-+
 
-+  if (p->remainLen > kMatchSpecLenStart)
 
-+  {
 
-+    p->remainLen = kMatchSpecLenStart;
 
-+  }
 
-+  return 0;
 
-+}
 
-+
 
-+typedef enum
 
-+{
 
-+  DUMMY_ERROR, /* unexpected end of input stream */
 
-+  DUMMY_LIT,
 
-+  DUMMY_MATCH,
 
-+  DUMMY_REP
 
-+} ELzmaDummy;
 
-+
 
-+static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inSize)
 
-+{
 
-+  UInt32 range = p->range;
 
-+  UInt32 code = p->code;
 
-+  const Byte *bufLimit = buf + inSize;
 
-+  CLzmaProb *probs = p->probs;
 
-+  unsigned state = p->state;
 
-+  ELzmaDummy res;
 
-+
 
-+  {
 
-+    CLzmaProb *prob;
 
-+    UInt32 bound;
 
-+    unsigned ttt;
 
-+    unsigned posState = (p->processedPos) & ((1 << p->prop.pb) - 1);
 
-+
 
-+    prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
 
-+    IF_BIT_0_CHECK(prob)
 
-+    {
 
-+      UPDATE_0_CHECK
 
-+
 
-+      /* if (bufLimit - buf >= 7) return DUMMY_LIT; */
 
-+
 
-+      prob = probs + Literal;
 
-+      if (p->checkDicSize != 0 || p->processedPos != 0)
 
-+        prob += (LZMA_LIT_SIZE *
 
-+          ((((p->processedPos) & ((1 << (p->prop.lp)) - 1)) << p->prop.lc) +
 
-+          (p->dic[(p->dicPos == 0 ? p->dicBufSize : p->dicPos) - 1] >> (8 - p->prop.lc))));
 
-+
 
-+      if (state < kNumLitStates)
 
-+      {
 
-+        unsigned symbol = 1;
 
-+        do { GET_BIT_CHECK(prob + symbol, symbol) } while (symbol < 0x100);
 
-+      }
 
-+      else
 
-+      {
 
-+        unsigned matchByte = p->dic[p->dicPos - p->reps[0] +
 
-+            ((p->dicPos < p->reps[0]) ? p->dicBufSize : 0)];
 
-+        unsigned offs = 0x100;
 
-+        unsigned symbol = 1;
 
-+        do
 
-+        {
 
-+          unsigned bit;
 
-+          CLzmaProb *probLit;
 
-+          matchByte <<= 1;
 
-+          bit = (matchByte & offs);
 
-+          probLit = prob + offs + bit + symbol;
 
-+          GET_BIT2_CHECK(probLit, symbol, offs &= ~bit, offs &= bit)
 
-+        }
 
-+        while (symbol < 0x100);
 
-+      }
 
-+      res = DUMMY_LIT;
 
-+    }
 
-+    else
 
-+    {
 
-+      unsigned len;
 
-+      UPDATE_1_CHECK;
 
-+
 
-+      prob = probs + IsRep + state;
 
-+      IF_BIT_0_CHECK(prob)
 
-+      {
 
-+        UPDATE_0_CHECK;
 
-+        state = 0;
 
-+        prob = probs + LenCoder;
 
-+        res = DUMMY_MATCH;
 
-+      }
 
-+      else
 
-+      {
 
-+        UPDATE_1_CHECK;
 
-+        res = DUMMY_REP;
 
-+        prob = probs + IsRepG0 + state;
 
-+        IF_BIT_0_CHECK(prob)
 
-+        {
 
-+          UPDATE_0_CHECK;
 
-+          prob = probs + IsRep0Long + (state << kNumPosBitsMax) + posState;
 
-+          IF_BIT_0_CHECK(prob)
 
-+          {
 
-+            UPDATE_0_CHECK;
 
-+            NORMALIZE_CHECK;
 
-+            return DUMMY_REP;
 
-+          }
 
-+          else
 
-+          {
 
-+            UPDATE_1_CHECK;
 
-+          }
 
-+        }
 
-+        else
 
-+        {
 
-+          UPDATE_1_CHECK;
 
-+          prob = probs + IsRepG1 + state;
 
-+          IF_BIT_0_CHECK(prob)
 
-+          {
 
-+            UPDATE_0_CHECK;
 
-+          }
 
-+          else
 
-+          {
 
-+            UPDATE_1_CHECK;
 
-+            prob = probs + IsRepG2 + state;
 
-+            IF_BIT_0_CHECK(prob)
 
-+            {
 
-+              UPDATE_0_CHECK;
 
-+            }
 
-+            else
 
-+            {
 
-+              UPDATE_1_CHECK;
 
-+            }
 
-+          }
 
-+        }
 
-+        state = kNumStates;
 
-+        prob = probs + RepLenCoder;
 
-+      }
 
-+      {
 
-+        unsigned limit, offset;
 
-+        CLzmaProb *probLen = prob + LenChoice;
 
-+        IF_BIT_0_CHECK(probLen)
 
-+        {
 
-+          UPDATE_0_CHECK;
 
-+          probLen = prob + LenLow + (posState << kLenNumLowBits);
 
-+          offset = 0;
 
-+          limit = 1 << kLenNumLowBits;
 
-+        }
 
-+        else
 
-+        {
 
-+          UPDATE_1_CHECK;
 
-+          probLen = prob + LenChoice2;
 
-+          IF_BIT_0_CHECK(probLen)
 
-+          {
 
-+            UPDATE_0_CHECK;
 
-+            probLen = prob + LenMid + (posState << kLenNumMidBits);
 
-+            offset = kLenNumLowSymbols;
 
-+            limit = 1 << kLenNumMidBits;
 
-+          }
 
-+          else
 
-+          {
 
-+            UPDATE_1_CHECK;
 
-+            probLen = prob + LenHigh;
 
-+            offset = kLenNumLowSymbols + kLenNumMidSymbols;
 
-+            limit = 1 << kLenNumHighBits;
 
-+          }
 
-+        }
 
-+        TREE_DECODE_CHECK(probLen, limit, len);
 
-+        len += offset;
 
-+      }
 
-+
 
-+      if (state < 4)
 
-+      {
 
-+        unsigned posSlot;
 
-+        prob = probs + PosSlot +
 
-+            ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) <<
 
-+            kNumPosSlotBits);
 
-+        TREE_DECODE_CHECK(prob, 1 << kNumPosSlotBits, posSlot);
 
-+        if (posSlot >= kStartPosModelIndex)
 
-+        {
 
-+          int numDirectBits = ((posSlot >> 1) - 1);
 
-+
 
-+          /* if (bufLimit - buf >= 8) return DUMMY_MATCH; */
 
-+
 
-+          if (posSlot < kEndPosModelIndex)
 
-+          {
 
-+            prob = probs + SpecPos + ((2 | (posSlot & 1)) << numDirectBits) - posSlot - 1;
 
-+          }
 
-+          else
 
-+          {
 
-+            numDirectBits -= kNumAlignBits;
 
-+            do
 
-+            {
 
-+              NORMALIZE_CHECK
 
-+              range >>= 1;
 
-+              code -= range & (((code - range) >> 31) - 1);
 
-+              /* if (code >= range) code -= range; */
 
-+            }
 
-+            while (--numDirectBits != 0);
 
-+            prob = probs + Align;
 
-+            numDirectBits = kNumAlignBits;
 
-+          }
 
-+          {
 
-+            unsigned i = 1;
 
-+            do
 
-+            {
 
-+              GET_BIT_CHECK(prob + i, i);
 
-+            }
 
-+            while (--numDirectBits != 0);
 
-+          }
 
-+        }
 
-+      }
 
-+    }
 
-+  }
 
-+  NORMALIZE_CHECK;
 
-+  return res;
 
-+}
 
-+
 
-+
 
-+static void LzmaDec_InitRc(CLzmaDec *p, const Byte *data)
 
-+{
 
-+  p->code = ((UInt32)data[1] << 24) | ((UInt32)data[2] << 16) | ((UInt32)data[3] << 8) | ((UInt32)data[4]);
 
-+  p->range = 0xFFFFFFFF;
 
-+  p->needFlush = 0;
 
-+}
 
-+
 
-+void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState)
 
-+{
 
-+  p->needFlush = 1;
 
-+  p->remainLen = 0;
 
-+  p->tempBufSize = 0;
 
-+
 
-+  if (initDic)
 
-+  {
 
-+    p->processedPos = 0;
 
-+    p->checkDicSize = 0;
 
-+    p->needInitState = 1;
 
-+  }
 
-+  if (initState)
 
-+    p->needInitState = 1;
 
-+}
 
-+
 
-+void LzmaDec_Init(CLzmaDec *p)
 
-+{
 
-+  p->dicPos = 0;
 
-+  LzmaDec_InitDicAndState(p, True, True);
 
-+}
 
-+
 
-+static void LzmaDec_InitStateReal(CLzmaDec *p)
 
-+{
 
-+  UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (p->prop.lc + p->prop.lp));
 
-+  UInt32 i;
 
-+  CLzmaProb *probs = p->probs;
 
-+  for (i = 0; i < numProbs; i++)
 
-+    probs[i] = kBitModelTotal >> 1;
 
-+  p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1;
 
-+  p->state = 0;
 
-+  p->needInitState = 0;
 
-+}
 
-+
 
-+SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen,
 
-+    ELzmaFinishMode finishMode, ELzmaStatus *status)
 
-+{
 
-+  SizeT inSize = *srcLen;
 
-+  (*srcLen) = 0;
 
-+  LzmaDec_WriteRem(p, dicLimit);
 
-+  
-+  *status = LZMA_STATUS_NOT_SPECIFIED;
 
-+
 
-+  while (p->remainLen != kMatchSpecLenStart)
 
-+  {
 
-+      int checkEndMarkNow;
 
-+
 
-+      if (p->needFlush != 0)
 
-+      {
 
-+        for (; inSize > 0 && p->tempBufSize < RC_INIT_SIZE; (*srcLen)++, inSize--)
 
-+          p->tempBuf[p->tempBufSize++] = *src++;
 
-+        if (p->tempBufSize < RC_INIT_SIZE)
 
-+        {
 
-+          *status = LZMA_STATUS_NEEDS_MORE_INPUT;
 
-+          return SZ_OK;
 
-+        }
 
-+        if (p->tempBuf[0] != 0)
 
-+          return SZ_ERROR_DATA;
 
-+
 
-+        LzmaDec_InitRc(p, p->tempBuf);
 
-+        p->tempBufSize = 0;
 
-+      }
 
-+
 
-+      checkEndMarkNow = 0;
 
-+      if (p->dicPos >= dicLimit)
 
-+      {
 
-+        if (p->remainLen == 0 && p->code == 0)
 
-+        {
 
-+          *status = LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK;
 
-+          return SZ_OK;
 
-+        }
 
-+        if (finishMode == LZMA_FINISH_ANY)
 
-+        {
 
-+          *status = LZMA_STATUS_NOT_FINISHED;
 
-+          return SZ_OK;
 
-+        }
 
-+        if (p->remainLen != 0)
 
-+        {
 
-+          *status = LZMA_STATUS_NOT_FINISHED;
 
-+          return SZ_ERROR_DATA;
 
-+        }
 
-+        checkEndMarkNow = 1;
 
-+      }
 
-+
 
-+      if (p->needInitState)
 
-+        LzmaDec_InitStateReal(p);
 
-+  
-+      if (p->tempBufSize == 0)
 
-+      {
 
-+        SizeT processed;
 
-+        const Byte *bufLimit;
 
-+        if (inSize < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
 
-+        {
 
-+          int dummyRes = LzmaDec_TryDummy(p, src, inSize);
 
-+          if (dummyRes == DUMMY_ERROR)
 
-+          {
 
-+            memcpy(p->tempBuf, src, inSize);
 
-+            p->tempBufSize = (unsigned)inSize;
 
-+            (*srcLen) += inSize;
 
-+            *status = LZMA_STATUS_NEEDS_MORE_INPUT;
 
-+            return SZ_OK;
 
-+          }
 
-+          if (checkEndMarkNow && dummyRes != DUMMY_MATCH)
 
-+          {
 
-+            *status = LZMA_STATUS_NOT_FINISHED;
 
-+            return SZ_ERROR_DATA;
 
-+          }
 
-+          bufLimit = src;
 
-+        }
 
-+        else
 
-+          bufLimit = src + inSize - LZMA_REQUIRED_INPUT_MAX;
 
-+        p->buf = src;
 
-+        if (LzmaDec_DecodeReal2(p, dicLimit, bufLimit) != 0)
 
-+          return SZ_ERROR_DATA;
 
-+        processed = (SizeT)(p->buf - src);
 
-+        (*srcLen) += processed;
 
-+        src += processed;
 
-+        inSize -= processed;
 
-+      }
 
-+      else
 
-+      {
 
-+        unsigned rem = p->tempBufSize, lookAhead = 0;
 
-+        while (rem < LZMA_REQUIRED_INPUT_MAX && lookAhead < inSize)
 
-+          p->tempBuf[rem++] = src[lookAhead++];
 
-+        p->tempBufSize = rem;
 
-+        if (rem < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
 
-+        {
 
-+          int dummyRes = LzmaDec_TryDummy(p, p->tempBuf, rem);
 
-+          if (dummyRes == DUMMY_ERROR)
 
-+          {
 
-+            (*srcLen) += lookAhead;
 
-+            *status = LZMA_STATUS_NEEDS_MORE_INPUT;
 
-+            return SZ_OK;
 
-+          }
 
-+          if (checkEndMarkNow && dummyRes != DUMMY_MATCH)
 
-+          {
 
-+            *status = LZMA_STATUS_NOT_FINISHED;
 
-+            return SZ_ERROR_DATA;
 
-+          }
 
-+        }
 
-+        p->buf = p->tempBuf;
 
-+        if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0)
 
-+          return SZ_ERROR_DATA;
 
-+        lookAhead -= (rem - (unsigned)(p->buf - p->tempBuf));
 
-+        (*srcLen) += lookAhead;
 
-+        src += lookAhead;
 
-+        inSize -= lookAhead;
 
-+        p->tempBufSize = 0;
 
-+      }
 
-+  }
 
-+  if (p->code == 0)
 
-+    *status = LZMA_STATUS_FINISHED_WITH_MARK;
 
-+  return (p->code == 0) ? SZ_OK : SZ_ERROR_DATA;
 
-+}
 
-+
 
-+SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
 
-+{
 
-+  SizeT outSize = *destLen;
 
-+  SizeT inSize = *srcLen;
 
-+  *srcLen = *destLen = 0;
 
-+  for (;;)
 
-+  {
 
-+    SizeT inSizeCur = inSize, outSizeCur, dicPos;
 
-+    ELzmaFinishMode curFinishMode;
 
-+    SRes res;
 
-+    if (p->dicPos == p->dicBufSize)
 
-+      p->dicPos = 0;
 
-+    dicPos = p->dicPos;
 
-+    if (outSize > p->dicBufSize - dicPos)
 
-+    {
 
-+      outSizeCur = p->dicBufSize;
 
-+      curFinishMode = LZMA_FINISH_ANY;
 
-+    }
 
-+    else
 
-+    {
 
-+      outSizeCur = dicPos + outSize;
 
-+      curFinishMode = finishMode;
 
-+    }
 
-+
 
-+    res = LzmaDec_DecodeToDic(p, outSizeCur, src, &inSizeCur, curFinishMode, status);
 
-+    src += inSizeCur;
 
-+    inSize -= inSizeCur;
 
-+    *srcLen += inSizeCur;
 
-+    outSizeCur = p->dicPos - dicPos;
 
-+    memcpy(dest, p->dic + dicPos, outSizeCur);
 
-+    dest += outSizeCur;
 
-+    outSize -= outSizeCur;
 
-+    *destLen += outSizeCur;
 
-+    if (res != 0)
 
-+      return res;
 
-+    if (outSizeCur == 0 || outSize == 0)
 
-+      return SZ_OK;
 
-+  }
 
-+}
 
-+
 
-+void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc)
 
-+{
 
-+  alloc->Free(alloc, p->probs);
 
-+  p->probs = 0;
 
-+}
 
-+
 
-+static void LzmaDec_FreeDict(CLzmaDec *p, ISzAlloc *alloc)
 
-+{
 
-+  alloc->Free(alloc, p->dic);
 
-+  p->dic = 0;
 
-+}
 
-+
 
-+void LzmaDec_Free(CLzmaDec *p, ISzAlloc *alloc)
 
-+{
 
-+  LzmaDec_FreeProbs(p, alloc);
 
-+  LzmaDec_FreeDict(p, alloc);
 
-+}
 
-+
 
-+SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
 
-+{
 
-+  UInt32 dicSize;
 
-+  Byte d;
 
-+  
-+  if (size < LZMA_PROPS_SIZE)
 
-+    return SZ_ERROR_UNSUPPORTED;
 
-+  else
 
-+    dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24);
 
-+ 
-+  if (dicSize < LZMA_DIC_MIN)
 
-+    dicSize = LZMA_DIC_MIN;
 
-+  p->dicSize = dicSize;
 
-+
 
-+  d = data[0];
 
-+  if (d >= (9 * 5 * 5))
 
-+    return SZ_ERROR_UNSUPPORTED;
 
-+
 
-+  p->lc = d % 9;
 
-+  d /= 9;
 
-+  p->pb = d / 5;
 
-+  p->lp = d % 5;
 
-+
 
-+  return SZ_OK;
 
-+}
 
-+
 
-+static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAlloc *alloc)
 
-+{
 
-+  UInt32 numProbs = LzmaProps_GetNumProbs(propNew);
 
-+  if (p->probs == 0 || numProbs != p->numProbs)
 
-+  {
 
-+    LzmaDec_FreeProbs(p, alloc);
 
-+    p->probs = (CLzmaProb *)alloc->Alloc(alloc, numProbs * sizeof(CLzmaProb));
 
-+    p->numProbs = numProbs;
 
-+    if (p->probs == 0)
 
-+      return SZ_ERROR_MEM;
 
-+  }
 
-+  return SZ_OK;
 
-+}
 
-+
 
-+SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
 
-+{
 
-+  CLzmaProps propNew;
 
-+  RINOK(LzmaProps_Decode(&propNew, props, propsSize));
 
-+  RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
 
-+  p->prop = propNew;
 
-+  return SZ_OK;
 
-+}
 
-+
 
-+SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
 
-+{
 
-+  CLzmaProps propNew;
 
-+  SizeT dicBufSize;
 
-+  RINOK(LzmaProps_Decode(&propNew, props, propsSize));
 
-+  RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
 
-+  dicBufSize = propNew.dicSize;
 
-+  if (p->dic == 0 || dicBufSize != p->dicBufSize)
 
-+  {
 
-+    LzmaDec_FreeDict(p, alloc);
 
-+    p->dic = (Byte *)alloc->Alloc(alloc, dicBufSize);
 
-+    if (p->dic == 0)
 
-+    {
 
-+      LzmaDec_FreeProbs(p, alloc);
 
-+      return SZ_ERROR_MEM;
 
-+    }
 
-+  }
 
-+  p->dicBufSize = dicBufSize;
 
-+  p->prop = propNew;
 
-+  return SZ_OK;
 
-+}
 
-+
 
-+SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
 
-+    const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
 
-+    ELzmaStatus *status, ISzAlloc *alloc)
 
-+{
 
-+  CLzmaDec p;
 
-+  SRes res;
 
-+  SizeT inSize = *srcLen;
 
-+  SizeT outSize = *destLen;
 
-+  *srcLen = *destLen = 0;
 
-+  if (inSize < RC_INIT_SIZE)
 
-+    return SZ_ERROR_INPUT_EOF;
 
-+
 
-+  LzmaDec_Construct(&p);
 
-+  res = LzmaDec_AllocateProbs(&p, propData, propSize, alloc);
 
-+  if (res != 0)
 
-+    return res;
 
-+  p.dic = dest;
 
-+  p.dicBufSize = outSize;
 
-+
 
-+  LzmaDec_Init(&p);
 
-+  
-+  *srcLen = inSize;
 
-+  res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);
 
-+
 
-+  if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)
 
-+    res = SZ_ERROR_INPUT_EOF;
 
-+
 
-+  (*destLen) = p.dicPos;
 
-+  LzmaDec_FreeProbs(&p, alloc);
 
-+  return res;
 
-+}
 
---- /dev/null
 
-+++ b/lib/lzma/LzmaEnc.c
 
-@@ -0,0 +1,2271 @@
 
-+/* LzmaEnc.c -- LZMA Encoder
 
-+2009-11-24 : Igor Pavlov : Public domain */
 
-+
 
-+#include <string.h>
 
-+
 
-+/* #define SHOW_STAT */
 
-+/* #define SHOW_STAT2 */
 
-+
 
-+#if defined(SHOW_STAT) || defined(SHOW_STAT2)
 
-+#include <stdio.h>
 
-+#endif
 
-+
 
-+#include "LzmaEnc.h"
 
-+
 
-+/* disable MT */
 
-+#define _7ZIP_ST
 
-+
 
-+#include "LzFind.h"
 
-+#ifndef _7ZIP_ST
 
-+#include "LzFindMt.h"
 
-+#endif
 
-+
 
-+#ifdef SHOW_STAT
 
-+static int ttt = 0;
 
-+#endif
 
-+
 
-+#define kBlockSizeMax ((1 << LZMA_NUM_BLOCK_SIZE_BITS) - 1)
 
-+
 
-+#define kBlockSize (9 << 10)
 
-+#define kUnpackBlockSize (1 << 18)
 
-+#define kMatchArraySize (1 << 21)
 
-+#define kMatchRecordMaxSize ((LZMA_MATCH_LEN_MAX * 2 + 3) * LZMA_MATCH_LEN_MAX)
 
-+
 
-+#define kNumMaxDirectBits (31)
 
-+
 
-+#define kNumTopBits 24
 
-+#define kTopValue ((UInt32)1 << kNumTopBits)
 
-+
 
-+#define kNumBitModelTotalBits 11
 
-+#define kBitModelTotal (1 << kNumBitModelTotalBits)
 
-+#define kNumMoveBits 5
 
-+#define kProbInitValue (kBitModelTotal >> 1)
 
-+
 
-+#define kNumMoveReducingBits 4
 
-+#define kNumBitPriceShiftBits 4
 
-+#define kBitPrice (1 << kNumBitPriceShiftBits)
 
-+
 
-+void LzmaEncProps_Init(CLzmaEncProps *p)
 
-+{
 
-+  p->level = 5;
 
-+  p->dictSize = p->mc = 0;
 
-+  p->lc = p->lp = p->pb = p->algo = p->fb = p->btMode = p->numHashBytes = p->numThreads = -1;
 
-+  p->writeEndMark = 0;
 
-+}
 
-+
 
-+void LzmaEncProps_Normalize(CLzmaEncProps *p)
 
-+{
 
-+  int level = p->level;
 
-+  if (level < 0) level = 5;
 
-+  p->level = level;
 
-+  if (p->dictSize == 0) p->dictSize = (level <= 5 ? (1 << (level * 2 + 14)) : (level == 6 ? (1 << 25) : (1 << 26)));
 
-+  if (p->lc < 0) p->lc = 3;
 
-+  if (p->lp < 0) p->lp = 0;
 
-+  if (p->pb < 0) p->pb = 2;
 
-+  if (p->algo < 0) p->algo = (level < 5 ? 0 : 1);
 
-+  if (p->fb < 0) p->fb = (level < 7 ? 32 : 64);
 
-+  if (p->btMode < 0) p->btMode = (p->algo == 0 ? 0 : 1);
 
-+  if (p->numHashBytes < 0) p->numHashBytes = 4;
 
-+  if (p->mc == 0)  p->mc = (16 + (p->fb >> 1)) >> (p->btMode ? 0 : 1);
 
-+  if (p->numThreads < 0)
 
-+    p->numThreads =
 
-+      #ifndef _7ZIP_ST
 
-+      ((p->btMode && p->algo) ? 2 : 1);
 
-+      #else
 
-+      1;
 
-+      #endif
 
-+}
 
-+
 
-+UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2)
 
-+{
 
-+  CLzmaEncProps props = *props2;
 
-+  LzmaEncProps_Normalize(&props);
 
-+  return props.dictSize;
 
-+}
 
-+
 
-+/* #define LZMA_LOG_BSR */
 
-+/* Define it for Intel's CPU */
 
-+
 
-+
 
-+#ifdef LZMA_LOG_BSR
 
-+
 
-+#define kDicLogSizeMaxCompress 30
 
-+
 
-+#define BSR2_RET(pos, res) { unsigned long i; _BitScanReverse(&i, (pos)); res = (i + i) + ((pos >> (i - 1)) & 1); }
 
-+
 
-+UInt32 GetPosSlot1(UInt32 pos)
 
-+{
 
-+  UInt32 res;
 
-+  BSR2_RET(pos, res);
 
-+  return res;
 
-+}
 
-+#define GetPosSlot2(pos, res) { BSR2_RET(pos, res); }
 
-+#define GetPosSlot(pos, res) { if (pos < 2) res = pos; else BSR2_RET(pos, res); }
 
-+
 
-+#else
 
-+
 
-+#define kNumLogBits (9 + (int)sizeof(size_t) / 2)
 
-+#define kDicLogSizeMaxCompress ((kNumLogBits - 1) * 2 + 7)
 
-+
 
-+void LzmaEnc_FastPosInit(Byte *g_FastPos)
 
-+{
 
-+  int c = 2, slotFast;
 
-+  g_FastPos[0] = 0;
 
-+  g_FastPos[1] = 1;
 
-+  
-+  for (slotFast = 2; slotFast < kNumLogBits * 2; slotFast++)
 
-+  {
 
-+    UInt32 k = (1 << ((slotFast >> 1) - 1));
 
-+    UInt32 j;
 
-+    for (j = 0; j < k; j++, c++)
 
-+      g_FastPos[c] = (Byte)slotFast;
 
-+  }
 
-+}
 
-+
 
-+#define BSR2_RET(pos, res) { UInt32 i = 6 + ((kNumLogBits - 1) & \
 
-+  (0 - (((((UInt32)1 << (kNumLogBits + 6)) - 1) - pos) >> 31))); \
 
-+  res = p->g_FastPos[pos >> i] + (i * 2); }
 
-+/*
 
-+#define BSR2_RET(pos, res) { res = (pos < (1 << (kNumLogBits + 6))) ? \
 
-+  p->g_FastPos[pos >> 6] + 12 : \
 
-+  p->g_FastPos[pos >> (6 + kNumLogBits - 1)] + (6 + (kNumLogBits - 1)) * 2; }
 
-+*/
 
-+
 
-+#define GetPosSlot1(pos) p->g_FastPos[pos]
 
-+#define GetPosSlot2(pos, res) { BSR2_RET(pos, res); }
 
-+#define GetPosSlot(pos, res) { if (pos < kNumFullDistances) res = p->g_FastPos[pos]; else BSR2_RET(pos, res); }
 
-+
 
-+#endif
 
-+
 
-+
 
-+#define LZMA_NUM_REPS 4
 
-+
 
-+typedef unsigned CState;
 
-+
 
-+typedef struct
 
-+{
 
-+  UInt32 price;
 
-+
 
-+  CState state;
 
-+  int prev1IsChar;
 
-+  int prev2;
 
-+
 
-+  UInt32 posPrev2;
 
-+  UInt32 backPrev2;
 
-+
 
-+  UInt32 posPrev;
 
-+  UInt32 backPrev;
 
-+  UInt32 backs[LZMA_NUM_REPS];
 
-+} COptimal;
 
-+
 
-+#define kNumOpts (1 << 12)
 
-+
 
-+#define kNumLenToPosStates 4
 
-+#define kNumPosSlotBits 6
 
-+#define kDicLogSizeMin 0
 
-+#define kDicLogSizeMax 32
 
-+#define kDistTableSizeMax (kDicLogSizeMax * 2)
 
-+
 
-+
 
-+#define kNumAlignBits 4
 
-+#define kAlignTableSize (1 << kNumAlignBits)
 
-+#define kAlignMask (kAlignTableSize - 1)
 
-+
 
-+#define kStartPosModelIndex 4
 
-+#define kEndPosModelIndex 14
 
-+#define kNumPosModels (kEndPosModelIndex - kStartPosModelIndex)
 
-+
 
-+#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
 
-+
 
-+#ifdef _LZMA_PROB32
 
-+#define CLzmaProb UInt32
 
-+#else
 
-+#define CLzmaProb UInt16
 
-+#endif
 
-+
 
-+#define LZMA_PB_MAX 4
 
-+#define LZMA_LC_MAX 8
 
-+#define LZMA_LP_MAX 4
 
-+
 
-+#define LZMA_NUM_PB_STATES_MAX (1 << LZMA_PB_MAX)
 
-+
 
-+
 
-+#define kLenNumLowBits 3
 
-+#define kLenNumLowSymbols (1 << kLenNumLowBits)
 
-+#define kLenNumMidBits 3
 
-+#define kLenNumMidSymbols (1 << kLenNumMidBits)
 
-+#define kLenNumHighBits 8
 
-+#define kLenNumHighSymbols (1 << kLenNumHighBits)
 
-+
 
-+#define kLenNumSymbolsTotal (kLenNumLowSymbols + kLenNumMidSymbols + kLenNumHighSymbols)
 
-+
 
-+#define LZMA_MATCH_LEN_MIN 2
 
-+#define LZMA_MATCH_LEN_MAX (LZMA_MATCH_LEN_MIN + kLenNumSymbolsTotal - 1)
 
-+
 
-+#define kNumStates 12
 
-+
 
-+typedef struct
 
-+{
 
-+  CLzmaProb choice;
 
-+  CLzmaProb choice2;
 
-+  CLzmaProb low[LZMA_NUM_PB_STATES_MAX << kLenNumLowBits];
 
-+  CLzmaProb mid[LZMA_NUM_PB_STATES_MAX << kLenNumMidBits];
 
-+  CLzmaProb high[kLenNumHighSymbols];
 
-+} CLenEnc;
 
-+
 
-+typedef struct
 
-+{
 
-+  CLenEnc p;
 
-+  UInt32 prices[LZMA_NUM_PB_STATES_MAX][kLenNumSymbolsTotal];
 
-+  UInt32 tableSize;
 
-+  UInt32 counters[LZMA_NUM_PB_STATES_MAX];
 
-+} CLenPriceEnc;
 
-+
 
-+typedef struct
 
-+{
 
-+  UInt32 range;
 
-+  Byte cache;
 
-+  UInt64 low;
 
-+  UInt64 cacheSize;
 
-+  Byte *buf;
 
-+  Byte *bufLim;
 
-+  Byte *bufBase;
 
-+  ISeqOutStream *outStream;
 
-+  UInt64 processed;
 
-+  SRes res;
 
-+} CRangeEnc;
 
-+
 
-+typedef struct
 
-+{
 
-+  CLzmaProb *litProbs;
 
-+
 
-+  CLzmaProb isMatch[kNumStates][LZMA_NUM_PB_STATES_MAX];
 
-+  CLzmaProb isRep[kNumStates];
 
-+  CLzmaProb isRepG0[kNumStates];
 
-+  CLzmaProb isRepG1[kNumStates];
 
-+  CLzmaProb isRepG2[kNumStates];
 
-+  CLzmaProb isRep0Long[kNumStates][LZMA_NUM_PB_STATES_MAX];
 
-+
 
-+  CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];
 
-+  CLzmaProb posEncoders[kNumFullDistances - kEndPosModelIndex];
 
-+  CLzmaProb posAlignEncoder[1 << kNumAlignBits];
 
-+  
-+  CLenPriceEnc lenEnc;
 
-+  CLenPriceEnc repLenEnc;
 
-+
 
-+  UInt32 reps[LZMA_NUM_REPS];
 
-+  UInt32 state;
 
-+} CSaveState;
 
-+
 
-+typedef struct
 
-+{
 
-+  IMatchFinder matchFinder;
 
-+  void *matchFinderObj;
 
-+
 
-+  #ifndef _7ZIP_ST
 
-+  Bool mtMode;
 
-+  CMatchFinderMt matchFinderMt;
 
-+  #endif
 
-+
 
-+  CMatchFinder matchFinderBase;
 
-+
 
-+  #ifndef _7ZIP_ST
 
-+  Byte pad[128];
 
-+  #endif
 
-+  
-+  UInt32 optimumEndIndex;
 
-+  UInt32 optimumCurrentIndex;
 
-+
 
-+  UInt32 longestMatchLength;
 
-+  UInt32 numPairs;
 
-+  UInt32 numAvail;
 
-+  COptimal opt[kNumOpts];
 
-+  
-+  #ifndef LZMA_LOG_BSR
 
-+  Byte g_FastPos[1 << kNumLogBits];
 
-+  #endif
 
-+
 
-+  UInt32 ProbPrices[kBitModelTotal >> kNumMoveReducingBits];
 
-+  UInt32 matches[LZMA_MATCH_LEN_MAX * 2 + 2 + 1];
 
-+  UInt32 numFastBytes;
 
-+  UInt32 additionalOffset;
 
-+  UInt32 reps[LZMA_NUM_REPS];
 
-+  UInt32 state;
 
-+
 
-+  UInt32 posSlotPrices[kNumLenToPosStates][kDistTableSizeMax];
 
-+  UInt32 distancesPrices[kNumLenToPosStates][kNumFullDistances];
 
-+  UInt32 alignPrices[kAlignTableSize];
 
-+  UInt32 alignPriceCount;
 
-+
 
-+  UInt32 distTableSize;
 
-+
 
-+  unsigned lc, lp, pb;
 
-+  unsigned lpMask, pbMask;
 
-+
 
-+  CLzmaProb *litProbs;
 
-+
 
-+  CLzmaProb isMatch[kNumStates][LZMA_NUM_PB_STATES_MAX];
 
-+  CLzmaProb isRep[kNumStates];
 
-+  CLzmaProb isRepG0[kNumStates];
 
-+  CLzmaProb isRepG1[kNumStates];
 
-+  CLzmaProb isRepG2[kNumStates];
 
-+  CLzmaProb isRep0Long[kNumStates][LZMA_NUM_PB_STATES_MAX];
 
-+
 
-+  CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];
 
-+  CLzmaProb posEncoders[kNumFullDistances - kEndPosModelIndex];
 
-+  CLzmaProb posAlignEncoder[1 << kNumAlignBits];
 
-+  
-+  CLenPriceEnc lenEnc;
 
-+  CLenPriceEnc repLenEnc;
 
-+
 
-+  unsigned lclp;
 
-+
 
-+  Bool fastMode;
 
-+  
-+  CRangeEnc rc;
 
-+
 
-+  Bool writeEndMark;
 
-+  UInt64 nowPos64;
 
-+  UInt32 matchPriceCount;
 
-+  Bool finished;
 
-+  Bool multiThread;
 
-+
 
-+  SRes result;
 
-+  UInt32 dictSize;
 
-+  UInt32 matchFinderCycles;
 
-+
 
-+  int needInit;
 
-+
 
-+  CSaveState saveState;
 
-+} CLzmaEnc;
 
-+
 
-+void LzmaEnc_SaveState(CLzmaEncHandle pp)
 
-+{
 
-+  CLzmaEnc *p = (CLzmaEnc *)pp;
 
-+  CSaveState *dest = &p->saveState;
 
-+  int i;
 
-+  dest->lenEnc = p->lenEnc;
 
-+  dest->repLenEnc = p->repLenEnc;
 
-+  dest->state = p->state;
 
-+
 
-+  for (i = 0; i < kNumStates; i++)
 
-+  {
 
-+    memcpy(dest->isMatch[i], p->isMatch[i], sizeof(p->isMatch[i]));
 
-+    memcpy(dest->isRep0Long[i], p->isRep0Long[i], sizeof(p->isRep0Long[i]));
 
-+  }
 
-+  for (i = 0; i < kNumLenToPosStates; i++)
 
-+    memcpy(dest->posSlotEncoder[i], p->posSlotEncoder[i], sizeof(p->posSlotEncoder[i]));
 
-+  memcpy(dest->isRep, p->isRep, sizeof(p->isRep));
 
-+  memcpy(dest->isRepG0, p->isRepG0, sizeof(p->isRepG0));
 
-+  memcpy(dest->isRepG1, p->isRepG1, sizeof(p->isRepG1));
 
-+  memcpy(dest->isRepG2, p->isRepG2, sizeof(p->isRepG2));
 
-+  memcpy(dest->posEncoders, p->posEncoders, sizeof(p->posEncoders));
 
-+  memcpy(dest->posAlignEncoder, p->posAlignEncoder, sizeof(p->posAlignEncoder));
 
-+  memcpy(dest->reps, p->reps, sizeof(p->reps));
 
-+  memcpy(dest->litProbs, p->litProbs, (0x300 << p->lclp) * sizeof(CLzmaProb));
 
-+}
 
-+
 
-+void LzmaEnc_RestoreState(CLzmaEncHandle pp)
 
-+{
 
-+  CLzmaEnc *dest = (CLzmaEnc *)pp;
 
-+  const CSaveState *p = &dest->saveState;
 
-+  int i;
 
-+  dest->lenEnc = p->lenEnc;
 
-+  dest->repLenEnc = p->repLenEnc;
 
-+  dest->state = p->state;
 
-+
 
-+  for (i = 0; i < kNumStates; i++)
 
-+  {
 
-+    memcpy(dest->isMatch[i], p->isMatch[i], sizeof(p->isMatch[i]));
 
-+    memcpy(dest->isRep0Long[i], p->isRep0Long[i], sizeof(p->isRep0Long[i]));
 
-+  }
 
-+  for (i = 0; i < kNumLenToPosStates; i++)
 
-+    memcpy(dest->posSlotEncoder[i], p->posSlotEncoder[i], sizeof(p->posSlotEncoder[i]));
 
-+  memcpy(dest->isRep, p->isRep, sizeof(p->isRep));
 
-+  memcpy(dest->isRepG0, p->isRepG0, sizeof(p->isRepG0));
 
-+  memcpy(dest->isRepG1, p->isRepG1, sizeof(p->isRepG1));
 
-+  memcpy(dest->isRepG2, p->isRepG2, sizeof(p->isRepG2));
 
-+  memcpy(dest->posEncoders, p->posEncoders, sizeof(p->posEncoders));
 
-+  memcpy(dest->posAlignEncoder, p->posAlignEncoder, sizeof(p->posAlignEncoder));
 
-+  memcpy(dest->reps, p->reps, sizeof(p->reps));
 
-+  memcpy(dest->litProbs, p->litProbs, (0x300 << dest->lclp) * sizeof(CLzmaProb));
 
-+}
 
-+
 
-+SRes LzmaEnc_SetProps(CLzmaEncHandle pp, const CLzmaEncProps *props2)
 
-+{
 
-+  CLzmaEnc *p = (CLzmaEnc *)pp;
 
-+  CLzmaEncProps props = *props2;
 
-+  LzmaEncProps_Normalize(&props);
 
-+
 
-+  if (props.lc > LZMA_LC_MAX || props.lp > LZMA_LP_MAX || props.pb > LZMA_PB_MAX ||
 
-+      props.dictSize > (1 << kDicLogSizeMaxCompress) || props.dictSize > (1 << 30))
 
-+    return SZ_ERROR_PARAM;
 
-+  p->dictSize = props.dictSize;
 
-+  p->matchFinderCycles = props.mc;
 
-+  {
 
-+    unsigned fb = props.fb;
 
-+    if (fb < 5)
 
-+      fb = 5;
 
-+    if (fb > LZMA_MATCH_LEN_MAX)
 
-+      fb = LZMA_MATCH_LEN_MAX;
 
-+    p->numFastBytes = fb;
 
-+  }
 
-+  p->lc = props.lc;
 
-+  p->lp = props.lp;
 
-+  p->pb = props.pb;
 
-+  p->fastMode = (props.algo == 0);
 
-+  p->matchFinderBase.btMode = props.btMode;
 
-+  {
 
-+    UInt32 numHashBytes = 4;
 
-+    if (props.btMode)
 
-+    {
 
-+      if (props.numHashBytes < 2)
 
-+        numHashBytes = 2;
 
-+      else if (props.numHashBytes < 4)
 
-+        numHashBytes = props.numHashBytes;
 
-+    }
 
-+    p->matchFinderBase.numHashBytes = numHashBytes;
 
-+  }
 
-+
 
-+  p->matchFinderBase.cutValue = props.mc;
 
-+
 
-+  p->writeEndMark = props.writeEndMark;
 
-+
 
-+  #ifndef _7ZIP_ST
 
-+  /*
 
-+  if (newMultiThread != _multiThread)
 
-+  {
 
-+    ReleaseMatchFinder();
 
-+    _multiThread = newMultiThread;
 
-+  }
 
-+  */
 
-+  p->multiThread = (props.numThreads > 1);
 
-+  #endif
 
-+
 
-+  return SZ_OK;
 
-+}
 
-+
 
-+static const int kLiteralNextStates[kNumStates] = {0, 0, 0, 0, 1, 2, 3, 4,  5,  6,   4, 5};
 
-+static const int kMatchNextStates[kNumStates]   = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};
 
-+static const int kRepNextStates[kNumStates]     = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};
 
-+static const int kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};
 
-+
 
-+#define IsCharState(s) ((s) < 7)
 
-+
 
-+#define GetLenToPosState(len) (((len) < kNumLenToPosStates + 1) ? (len) - 2 : kNumLenToPosStates - 1)
 
-+
 
-+#define kInfinityPrice (1 << 30)
 
-+
 
-+static void RangeEnc_Construct(CRangeEnc *p)
 
-+{
 
-+  p->outStream = 0;
 
-+  p->bufBase = 0;
 
-+}
 
-+
 
-+#define RangeEnc_GetProcessed(p) ((p)->processed + ((p)->buf - (p)->bufBase) + (p)->cacheSize)
 
-+
 
-+#define RC_BUF_SIZE (1 << 16)
 
-+static int RangeEnc_Alloc(CRangeEnc *p, ISzAlloc *alloc)
 
-+{
 
-+  if (p->bufBase == 0)
 
-+  {
 
-+    p->bufBase = (Byte *)alloc->Alloc(alloc, RC_BUF_SIZE);
 
-+    if (p->bufBase == 0)
 
-+      return 0;
 
-+    p->bufLim = p->bufBase + RC_BUF_SIZE;
 
-+  }
 
-+  return 1;
 
-+}
 
-+
 
-+static void RangeEnc_Free(CRangeEnc *p, ISzAlloc *alloc)
 
-+{
 
-+  alloc->Free(alloc, p->bufBase);
 
-+  p->bufBase = 0;
 
-+}
 
-+
 
-+static void RangeEnc_Init(CRangeEnc *p)
 
-+{
 
-+  /* Stream.Init(); */
 
-+  p->low = 0;
 
-+  p->range = 0xFFFFFFFF;
 
-+  p->cacheSize = 1;
 
-+  p->cache = 0;
 
-+
 
-+  p->buf = p->bufBase;
 
-+
 
-+  p->processed = 0;
 
-+  p->res = SZ_OK;
 
-+}
 
-+
 
-+static void RangeEnc_FlushStream(CRangeEnc *p)
 
-+{
 
-+  size_t num;
 
-+  if (p->res != SZ_OK)
 
-+    return;
 
-+  num = p->buf - p->bufBase;
 
-+  if (num != p->outStream->Write(p->outStream, p->bufBase, num))
 
-+    p->res = SZ_ERROR_WRITE;
 
-+  p->processed += num;
 
-+  p->buf = p->bufBase;
 
-+}
 
-+
 
-+static void MY_FAST_CALL RangeEnc_ShiftLow(CRangeEnc *p)
 
-+{
 
-+  if ((UInt32)p->low < (UInt32)0xFF000000 || (int)(p->low >> 32) != 0)
 
-+  {
 
-+    Byte temp = p->cache;
 
-+    do
 
-+    {
 
-+      Byte *buf = p->buf;
 
-+      *buf++ = (Byte)(temp + (Byte)(p->low >> 32));
 
-+      p->buf = buf;
 
-+      if (buf == p->bufLim)
 
-+        RangeEnc_FlushStream(p);
 
-+      temp = 0xFF;
 
-+    }
 
-+    while (--p->cacheSize != 0);
 
-+    p->cache = (Byte)((UInt32)p->low >> 24);
 
-+  }
 
-+  p->cacheSize++;
 
-+  p->low = (UInt32)p->low << 8;
 
-+}
 
-+
 
-+static void RangeEnc_FlushData(CRangeEnc *p)
 
-+{
 
-+  int i;
 
-+  for (i = 0; i < 5; i++)
 
-+    RangeEnc_ShiftLow(p);
 
-+}
 
-+
 
-+static void RangeEnc_EncodeDirectBits(CRangeEnc *p, UInt32 value, int numBits)
 
-+{
 
-+  do
 
-+  {
 
-+    p->range >>= 1;
 
-+    p->low += p->range & (0 - ((value >> --numBits) & 1));
 
-+    if (p->range < kTopValue)
 
-+    {
 
-+      p->range <<= 8;
 
-+      RangeEnc_ShiftLow(p);
 
-+    }
 
-+  }
 
-+  while (numBits != 0);
 
-+}
 
-+
 
-+static void RangeEnc_EncodeBit(CRangeEnc *p, CLzmaProb *prob, UInt32 symbol)
 
-+{
 
-+  UInt32 ttt = *prob;
 
-+  UInt32 newBound = (p->range >> kNumBitModelTotalBits) * ttt;
 
-+  if (symbol == 0)
 
-+  {
 
-+    p->range = newBound;
 
-+    ttt += (kBitModelTotal - ttt) >> kNumMoveBits;
 
-+  }
 
-+  else
 
-+  {
 
-+    p->low += newBound;
 
-+    p->range -= newBound;
 
-+    ttt -= ttt >> kNumMoveBits;
 
-+  }
 
-+  *prob = (CLzmaProb)ttt;
 
-+  if (p->range < kTopValue)
 
-+  {
 
-+    p->range <<= 8;
 
-+    RangeEnc_ShiftLow(p);
 
-+  }
 
-+}
 
-+
 
-+static void LitEnc_Encode(CRangeEnc *p, CLzmaProb *probs, UInt32 symbol)
 
-+{
 
-+  symbol |= 0x100;
 
-+  do
 
-+  {
 
-+    RangeEnc_EncodeBit(p, probs + (symbol >> 8), (symbol >> 7) & 1);
 
-+    symbol <<= 1;
 
-+  }
 
-+  while (symbol < 0x10000);
 
-+}
 
-+
 
-+static void LitEnc_EncodeMatched(CRangeEnc *p, CLzmaProb *probs, UInt32 symbol, UInt32 matchByte)
 
-+{
 
-+  UInt32 offs = 0x100;
 
-+  symbol |= 0x100;
 
-+  do
 
-+  {
 
-+    matchByte <<= 1;
 
-+    RangeEnc_EncodeBit(p, probs + (offs + (matchByte & offs) + (symbol >> 8)), (symbol >> 7) & 1);
 
-+    symbol <<= 1;
 
-+    offs &= ~(matchByte ^ symbol);
 
-+  }
 
-+  while (symbol < 0x10000);
 
-+}
 
-+
 
-+void LzmaEnc_InitPriceTables(UInt32 *ProbPrices)
 
-+{
 
-+  UInt32 i;
 
-+  for (i = (1 << kNumMoveReducingBits) / 2; i < kBitModelTotal; i += (1 << kNumMoveReducingBits))
 
-+  {
 
-+    const int kCyclesBits = kNumBitPriceShiftBits;
 
-+    UInt32 w = i;
 
-+    UInt32 bitCount = 0;
 
-+    int j;
 
-+    for (j = 0; j < kCyclesBits; j++)
 
-+    {
 
-+      w = w * w;
 
-+      bitCount <<= 1;
 
-+      while (w >= ((UInt32)1 << 16))
 
-+      {
 
-+        w >>= 1;
 
-+        bitCount++;
 
-+      }
 
-+    }
 
-+    ProbPrices[i >> kNumMoveReducingBits] = ((kNumBitModelTotalBits << kCyclesBits) - 15 - bitCount);
 
-+  }
 
-+}
 
-+
 
-+
 
-+#define GET_PRICE(prob, symbol) \
 
-+  p->ProbPrices[((prob) ^ (((-(int)(symbol))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits];
 
-+
 
-+#define GET_PRICEa(prob, symbol) \
 
-+  ProbPrices[((prob) ^ ((-((int)(symbol))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits];
 
-+
 
-+#define GET_PRICE_0(prob) p->ProbPrices[(prob) >> kNumMoveReducingBits]
 
-+#define GET_PRICE_1(prob) p->ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]
 
-+
 
-+#define GET_PRICE_0a(prob) ProbPrices[(prob) >> kNumMoveReducingBits]
 
-+#define GET_PRICE_1a(prob) ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]
 
-+
 
-+static UInt32 LitEnc_GetPrice(const CLzmaProb *probs, UInt32 symbol, UInt32 *ProbPrices)
 
-+{
 
-+  UInt32 price = 0;
 
-+  symbol |= 0x100;
 
-+  do
 
-+  {
 
-+    price += GET_PRICEa(probs[symbol >> 8], (symbol >> 7) & 1);
 
-+    symbol <<= 1;
 
-+  }
 
-+  while (symbol < 0x10000);
 
-+  return price;
 
-+}
 
-+
 
-+static UInt32 LitEnc_GetPriceMatched(const CLzmaProb *probs, UInt32 symbol, UInt32 matchByte, UInt32 *ProbPrices)
 
-+{
 
-+  UInt32 price = 0;
 
-+  UInt32 offs = 0x100;
 
-+  symbol |= 0x100;
 
-+  do
 
-+  {
 
-+    matchByte <<= 1;
 
-+    price += GET_PRICEa(probs[offs + (matchByte & offs) + (symbol >> 8)], (symbol >> 7) & 1);
 
-+    symbol <<= 1;
 
-+    offs &= ~(matchByte ^ symbol);
 
-+  }
 
-+  while (symbol < 0x10000);
 
-+  return price;
 
-+}
 
-+
 
-+
 
-+static void RcTree_Encode(CRangeEnc *rc, CLzmaProb *probs, int numBitLevels, UInt32 symbol)
 
-+{
 
-+  UInt32 m = 1;
 
-+  int i;
 
-+  for (i = numBitLevels; i != 0;)
 
-+  {
 
-+    UInt32 bit;
 
-+    i--;
 
-+    bit = (symbol >> i) & 1;
 
-+    RangeEnc_EncodeBit(rc, probs + m, bit);
 
-+    m = (m << 1) | bit;
 
-+  }
 
-+}
 
-+
 
-+static void RcTree_ReverseEncode(CRangeEnc *rc, CLzmaProb *probs, int numBitLevels, UInt32 symbol)
 
-+{
 
-+  UInt32 m = 1;
 
-+  int i;
 
-+  for (i = 0; i < numBitLevels; i++)
 
-+  {
 
-+    UInt32 bit = symbol & 1;
 
-+    RangeEnc_EncodeBit(rc, probs + m, bit);
 
-+    m = (m << 1) | bit;
 
-+    symbol >>= 1;
 
-+  }
 
-+}
 
-+
 
-+static UInt32 RcTree_GetPrice(const CLzmaProb *probs, int numBitLevels, UInt32 symbol, UInt32 *ProbPrices)
 
-+{
 
-+  UInt32 price = 0;
 
-+  symbol |= (1 << numBitLevels);
 
-+  while (symbol != 1)
 
-+  {
 
-+    price += GET_PRICEa(probs[symbol >> 1], symbol & 1);
 
-+    symbol >>= 1;
 
-+  }
 
-+  return price;
 
-+}
 
-+
 
-+static UInt32 RcTree_ReverseGetPrice(const CLzmaProb *probs, int numBitLevels, UInt32 symbol, UInt32 *ProbPrices)
 
-+{
 
-+  UInt32 price = 0;
 
-+  UInt32 m = 1;
 
-+  int i;
 
-+  for (i = numBitLevels; i != 0; i--)
 
-+  {
 
-+    UInt32 bit = symbol & 1;
 
-+    symbol >>= 1;
 
-+    price += GET_PRICEa(probs[m], bit);
 
-+    m = (m << 1) | bit;
 
-+  }
 
-+  return price;
 
-+}
 
-+
 
-+
 
-+static void LenEnc_Init(CLenEnc *p)
 
-+{
 
-+  unsigned i;
 
-+  p->choice = p->choice2 = kProbInitValue;
 
-+  for (i = 0; i < (LZMA_NUM_PB_STATES_MAX << kLenNumLowBits); i++)
 
-+    p->low[i] = kProbInitValue;
 
-+  for (i = 0; i < (LZMA_NUM_PB_STATES_MAX << kLenNumMidBits); i++)
 
-+    p->mid[i] = kProbInitValue;
 
-+  for (i = 0; i < kLenNumHighSymbols; i++)
 
-+    p->high[i] = kProbInitValue;
 
-+}
 
-+
 
-+static void LenEnc_Encode(CLenEnc *p, CRangeEnc *rc, UInt32 symbol, UInt32 posState)
 
-+{
 
-+  if (symbol < kLenNumLowSymbols)
 
-+  {
 
-+    RangeEnc_EncodeBit(rc, &p->choice, 0);
 
-+    RcTree_Encode(rc, p->low + (posState << kLenNumLowBits), kLenNumLowBits, symbol);
 
-+  }
 
-+  else
 
-+  {
 
-+    RangeEnc_EncodeBit(rc, &p->choice, 1);
 
-+    if (symbol < kLenNumLowSymbols + kLenNumMidSymbols)
 
-+    {
 
-+      RangeEnc_EncodeBit(rc, &p->choice2, 0);
 
-+      RcTree_Encode(rc, p->mid + (posState << kLenNumMidBits), kLenNumMidBits, symbol - kLenNumLowSymbols);
 
-+    }
 
-+    else
 
-+    {
 
-+      RangeEnc_EncodeBit(rc, &p->choice2, 1);
 
-+      RcTree_Encode(rc, p->high, kLenNumHighBits, symbol - kLenNumLowSymbols - kLenNumMidSymbols);
 
-+    }
 
-+  }
 
-+}
 
-+
 
-+static void LenEnc_SetPrices(CLenEnc *p, UInt32 posState, UInt32 numSymbols, UInt32 *prices, UInt32 *ProbPrices)
 
-+{
 
-+  UInt32 a0 = GET_PRICE_0a(p->choice);
 
-+  UInt32 a1 = GET_PRICE_1a(p->choice);
 
-+  UInt32 b0 = a1 + GET_PRICE_0a(p->choice2);
 
-+  UInt32 b1 = a1 + GET_PRICE_1a(p->choice2);
 
-+  UInt32 i = 0;
 
-+  for (i = 0; i < kLenNumLowSymbols; i++)
 
-+  {
 
-+    if (i >= numSymbols)
 
-+      return;
 
-+    prices[i] = a0 + RcTree_GetPrice(p->low + (posState << kLenNumLowBits), kLenNumLowBits, i, ProbPrices);
 
-+  }
 
-+  for (; i < kLenNumLowSymbols + kLenNumMidSymbols; i++)
 
-+  {
 
-+    if (i >= numSymbols)
 
-+      return;
 
-+    prices[i] = b0 + RcTree_GetPrice(p->mid + (posState << kLenNumMidBits), kLenNumMidBits, i - kLenNumLowSymbols, ProbPrices);
 
-+  }
 
-+  for (; i < numSymbols; i++)
 
-+    prices[i] = b1 + RcTree_GetPrice(p->high, kLenNumHighBits, i - kLenNumLowSymbols - kLenNumMidSymbols, ProbPrices);
 
-+}
 
-+
 
-+static void MY_FAST_CALL LenPriceEnc_UpdateTable(CLenPriceEnc *p, UInt32 posState, UInt32 *ProbPrices)
 
-+{
 
-+  LenEnc_SetPrices(&p->p, posState, p->tableSize, p->prices[posState], ProbPrices);
 
-+  p->counters[posState] = p->tableSize;
 
-+}
 
-+
 
-+static void LenPriceEnc_UpdateTables(CLenPriceEnc *p, UInt32 numPosStates, UInt32 *ProbPrices)
 
-+{
 
-+  UInt32 posState;
 
-+  for (posState = 0; posState < numPosStates; posState++)
 
-+    LenPriceEnc_UpdateTable(p, posState, ProbPrices);
 
-+}
 
-+
 
-+static void LenEnc_Encode2(CLenPriceEnc *p, CRangeEnc *rc, UInt32 symbol, UInt32 posState, Bool updatePrice, UInt32 *ProbPrices)
 
-+{
 
-+  LenEnc_Encode(&p->p, rc, symbol, posState);
 
-+  if (updatePrice)
 
-+    if (--p->counters[posState] == 0)
 
-+      LenPriceEnc_UpdateTable(p, posState, ProbPrices);
 
-+}
 
-+
 
-+
 
-+
 
-+
 
-+static void MovePos(CLzmaEnc *p, UInt32 num)
 
-+{
 
-+  #ifdef SHOW_STAT
 
-+  ttt += num;
 
-+  printf("\n MovePos %d", num);
 
-+  #endif
 
-+  if (num != 0)
 
-+  {
 
-+    p->additionalOffset += num;
 
-+    p->matchFinder.Skip(p->matchFinderObj, num);
 
-+  }
 
-+}
 
-+
 
-+static UInt32 ReadMatchDistances(CLzmaEnc *p, UInt32 *numDistancePairsRes)
 
-+{
 
-+  UInt32 lenRes = 0, numPairs;
 
-+  p->numAvail = p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
 
-+  numPairs = p->matchFinder.GetMatches(p->matchFinderObj, p->matches);
 
-+  #ifdef SHOW_STAT
 
-+  printf("\n i = %d numPairs = %d    ", ttt, numPairs / 2);
 
-+  ttt++;
 
-+  {
 
-+    UInt32 i;
 
-+    for (i = 0; i < numPairs; i += 2)
 
-+      printf("%2d %6d   | ", p->matches[i], p->matches[i + 1]);
 
-+  }
 
-+  #endif
 
-+  if (numPairs > 0)
 
-+  {
 
-+    lenRes = p->matches[numPairs - 2];
 
-+    if (lenRes == p->numFastBytes)
 
-+    {
 
-+      const Byte *pby = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
 
-+      UInt32 distance = p->matches[numPairs - 1] + 1;
 
-+      UInt32 numAvail = p->numAvail;
 
-+      if (numAvail > LZMA_MATCH_LEN_MAX)
 
-+        numAvail = LZMA_MATCH_LEN_MAX;
 
-+      {
 
-+        const Byte *pby2 = pby - distance;
 
-+        for (; lenRes < numAvail && pby[lenRes] == pby2[lenRes]; lenRes++);
 
-+      }
 
-+    }
 
-+  }
 
-+  p->additionalOffset++;
 
-+  *numDistancePairsRes = numPairs;
 
-+  return lenRes;
 
-+}
 
-+
 
-+
 
-+#define MakeAsChar(p) (p)->backPrev = (UInt32)(-1); (p)->prev1IsChar = False;
 
-+#define MakeAsShortRep(p) (p)->backPrev = 0; (p)->prev1IsChar = False;
 
-+#define IsShortRep(p) ((p)->backPrev == 0)
 
-+
 
-+static UInt32 GetRepLen1Price(CLzmaEnc *p, UInt32 state, UInt32 posState)
 
-+{
 
-+  return
 
-+    GET_PRICE_0(p->isRepG0[state]) +
 
-+    GET_PRICE_0(p->isRep0Long[state][posState]);
 
-+}
 
-+
 
-+static UInt32 GetPureRepPrice(CLzmaEnc *p, UInt32 repIndex, UInt32 state, UInt32 posState)
 
-+{
 
-+  UInt32 price;
 
-+  if (repIndex == 0)
 
-+  {
 
-+    price = GET_PRICE_0(p->isRepG0[state]);
 
-+    price += GET_PRICE_1(p->isRep0Long[state][posState]);
 
-+  }
 
-+  else
 
-+  {
 
-+    price = GET_PRICE_1(p->isRepG0[state]);
 
-+    if (repIndex == 1)
 
-+      price += GET_PRICE_0(p->isRepG1[state]);
 
-+    else
 
-+    {
 
-+      price += GET_PRICE_1(p->isRepG1[state]);
 
-+      price += GET_PRICE(p->isRepG2[state], repIndex - 2);
 
-+    }
 
-+  }
 
-+  return price;
 
-+}
 
-+
 
-+static UInt32 GetRepPrice(CLzmaEnc *p, UInt32 repIndex, UInt32 len, UInt32 state, UInt32 posState)
 
-+{
 
-+  return p->repLenEnc.prices[posState][len - LZMA_MATCH_LEN_MIN] +
 
-+    GetPureRepPrice(p, repIndex, state, posState);
 
-+}
 
-+
 
-+static UInt32 Backward(CLzmaEnc *p, UInt32 *backRes, UInt32 cur)
 
-+{
 
-+  UInt32 posMem = p->opt[cur].posPrev;
 
-+  UInt32 backMem = p->opt[cur].backPrev;
 
-+  p->optimumEndIndex = cur;
 
-+  do
 
-+  {
 
-+    if (p->opt[cur].prev1IsChar)
 
-+    {
 
-+      MakeAsChar(&p->opt[posMem])
 
-+      p->opt[posMem].posPrev = posMem - 1;
 
-+      if (p->opt[cur].prev2)
 
-+      {
 
-+        p->opt[posMem - 1].prev1IsChar = False;
 
-+        p->opt[posMem - 1].posPrev = p->opt[cur].posPrev2;
 
-+        p->opt[posMem - 1].backPrev = p->opt[cur].backPrev2;
 
-+      }
 
-+    }
 
-+    {
 
-+      UInt32 posPrev = posMem;
 
-+      UInt32 backCur = backMem;
 
-+      
-+      backMem = p->opt[posPrev].backPrev;
 
-+      posMem = p->opt[posPrev].posPrev;
 
-+      
-+      p->opt[posPrev].backPrev = backCur;
 
-+      p->opt[posPrev].posPrev = cur;
 
-+      cur = posPrev;
 
-+    }
 
-+  }
 
-+  while (cur != 0);
 
-+  *backRes = p->opt[0].backPrev;
 
-+  p->optimumCurrentIndex  = p->opt[0].posPrev;
 
-+  return p->optimumCurrentIndex;
 
-+}
 
-+
 
-+#define LIT_PROBS(pos, prevByte) (p->litProbs + ((((pos) & p->lpMask) << p->lc) + ((prevByte) >> (8 - p->lc))) * 0x300)
 
-+
 
-+static UInt32 GetOptimum(CLzmaEnc *p, UInt32 position, UInt32 *backRes)
 
-+{
 
-+  UInt32 numAvail, mainLen, numPairs, repMaxIndex, i, posState, lenEnd, len, cur;
 
-+  UInt32 matchPrice, repMatchPrice, normalMatchPrice;
 
-+  UInt32 reps[LZMA_NUM_REPS], repLens[LZMA_NUM_REPS];
 
-+  UInt32 *matches;
 
-+  const Byte *data;
 
-+  Byte curByte, matchByte;
 
-+  if (p->optimumEndIndex != p->optimumCurrentIndex)
 
-+  {
 
-+    const COptimal *opt = &p->opt[p->optimumCurrentIndex];
 
-+    UInt32 lenRes = opt->posPrev - p->optimumCurrentIndex;
 
-+    *backRes = opt->backPrev;
 
-+    p->optimumCurrentIndex = opt->posPrev;
 
-+    return lenRes;
 
-+  }
 
-+  p->optimumCurrentIndex = p->optimumEndIndex = 0;
 
-+  
-+  if (p->additionalOffset == 0)
 
-+    mainLen = ReadMatchDistances(p, &numPairs);
 
-+  else
 
-+  {
 
-+    mainLen = p->longestMatchLength;
 
-+    numPairs = p->numPairs;
 
-+  }
 
-+
 
-+  numAvail = p->numAvail;
 
-+  if (numAvail < 2)
 
-+  {
 
-+    *backRes = (UInt32)(-1);
 
-+    return 1;
 
-+  }
 
-+  if (numAvail > LZMA_MATCH_LEN_MAX)
 
-+    numAvail = LZMA_MATCH_LEN_MAX;
 
-+
 
-+  data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
 
-+  repMaxIndex = 0;
 
-+  for (i = 0; i < LZMA_NUM_REPS; i++)
 
-+  {
 
-+    UInt32 lenTest;
 
-+    const Byte *data2;
 
-+    reps[i] = p->reps[i];
 
-+    data2 = data - (reps[i] + 1);
 
-+    if (data[0] != data2[0] || data[1] != data2[1])
 
-+    {
 
-+      repLens[i] = 0;
 
-+      continue;
 
-+    }
 
-+    for (lenTest = 2; lenTest < numAvail && data[lenTest] == data2[lenTest]; lenTest++);
 
-+    repLens[i] = lenTest;
 
-+    if (lenTest > repLens[repMaxIndex])
 
-+      repMaxIndex = i;
 
-+  }
 
-+  if (repLens[repMaxIndex] >= p->numFastBytes)
 
-+  {
 
-+    UInt32 lenRes;
 
-+    *backRes = repMaxIndex;
 
-+    lenRes = repLens[repMaxIndex];
 
-+    MovePos(p, lenRes - 1);
 
-+    return lenRes;
 
-+  }
 
-+
 
-+  matches = p->matches;
 
-+  if (mainLen >= p->numFastBytes)
 
-+  {
 
-+    *backRes = matches[numPairs - 1] + LZMA_NUM_REPS;
 
-+    MovePos(p, mainLen - 1);
 
-+    return mainLen;
 
-+  }
 
-+  curByte = *data;
 
-+  matchByte = *(data - (reps[0] + 1));
 
-+
 
-+  if (mainLen < 2 && curByte != matchByte && repLens[repMaxIndex] < 2)
 
-+  {
 
-+    *backRes = (UInt32)-1;
 
-+    return 1;
 
-+  }
 
-+
 
-+  p->opt[0].state = (CState)p->state;
 
-+
 
-+  posState = (position & p->pbMask);
 
-+
 
-+  {
 
-+    const CLzmaProb *probs = LIT_PROBS(position, *(data - 1));
 
-+    p->opt[1].price = GET_PRICE_0(p->isMatch[p->state][posState]) +
 
-+        (!IsCharState(p->state) ?
 
-+          LitEnc_GetPriceMatched(probs, curByte, matchByte, p->ProbPrices) :
 
-+          LitEnc_GetPrice(probs, curByte, p->ProbPrices));
 
-+  }
 
-+
 
-+  MakeAsChar(&p->opt[1]);
 
-+
 
-+  matchPrice = GET_PRICE_1(p->isMatch[p->state][posState]);
 
-+  repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[p->state]);
 
-+
 
-+  if (matchByte == curByte)
 
-+  {
 
-+    UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(p, p->state, posState);
 
-+    if (shortRepPrice < p->opt[1].price)
 
-+    {
 
-+      p->opt[1].price = shortRepPrice;
 
-+      MakeAsShortRep(&p->opt[1]);
 
-+    }
 
-+  }
 
-+  lenEnd = ((mainLen >= repLens[repMaxIndex]) ? mainLen : repLens[repMaxIndex]);
 
-+
 
-+  if (lenEnd < 2)
 
-+  {
 
-+    *backRes = p->opt[1].backPrev;
 
-+    return 1;
 
-+  }
 
-+
 
-+  p->opt[1].posPrev = 0;
 
-+  for (i = 0; i < LZMA_NUM_REPS; i++)
 
-+    p->opt[0].backs[i] = reps[i];
 
-+
 
-+  len = lenEnd;
 
-+  do
 
-+    p->opt[len--].price = kInfinityPrice;
 
-+  while (len >= 2);
 
-+
 
-+  for (i = 0; i < LZMA_NUM_REPS; i++)
 
-+  {
 
-+    UInt32 repLen = repLens[i];
 
-+    UInt32 price;
 
-+    if (repLen < 2)
 
-+      continue;
 
-+    price = repMatchPrice + GetPureRepPrice(p, i, p->state, posState);
 
-+    do
 
-+    {
 
-+      UInt32 curAndLenPrice = price + p->repLenEnc.prices[posState][repLen - 2];
 
-+      COptimal *opt = &p->opt[repLen];
 
-+      if (curAndLenPrice < opt->price)
 
-+      {
 
-+        opt->price = curAndLenPrice;
 
-+        opt->posPrev = 0;
 
-+        opt->backPrev = i;
 
-+        opt->prev1IsChar = False;
 
-+      }
 
-+    }
 
-+    while (--repLen >= 2);
 
-+  }
 
-+
 
-+  normalMatchPrice = matchPrice + GET_PRICE_0(p->isRep[p->state]);
 
-+
 
-+  len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2);
 
-+  if (len <= mainLen)
 
-+  {
 
-+    UInt32 offs = 0;
 
-+    while (len > matches[offs])
 
-+      offs += 2;
 
-+    for (; ; len++)
 
-+    {
 
-+      COptimal *opt;
 
-+      UInt32 distance = matches[offs + 1];
 
-+
 
-+      UInt32 curAndLenPrice = normalMatchPrice + p->lenEnc.prices[posState][len - LZMA_MATCH_LEN_MIN];
 
-+      UInt32 lenToPosState = GetLenToPosState(len);
 
-+      if (distance < kNumFullDistances)
 
-+        curAndLenPrice += p->distancesPrices[lenToPosState][distance];
 
-+      else
 
-+      {
 
-+        UInt32 slot;
 
-+        GetPosSlot2(distance, slot);
 
-+        curAndLenPrice += p->alignPrices[distance & kAlignMask] + p->posSlotPrices[lenToPosState][slot];
 
-+      }
 
-+      opt = &p->opt[len];
 
-+      if (curAndLenPrice < opt->price)
 
-+      {
 
-+        opt->price = curAndLenPrice;
 
-+        opt->posPrev = 0;
 
-+        opt->backPrev = distance + LZMA_NUM_REPS;
 
-+        opt->prev1IsChar = False;
 
-+      }
 
-+      if (len == matches[offs])
 
-+      {
 
-+        offs += 2;
 
-+        if (offs == numPairs)
 
-+          break;
 
-+      }
 
-+    }
 
-+  }
 
-+
 
-+  cur = 0;
 
-+
 
-+    #ifdef SHOW_STAT2
 
-+    if (position >= 0)
 
-+    {
 
-+      unsigned i;
 
-+      printf("\n pos = %4X", position);
 
-+      for (i = cur; i <= lenEnd; i++)
 
-+      printf("\nprice[%4X] = %d", position - cur + i, p->opt[i].price);
 
-+    }
 
-+    #endif
 
-+
 
-+  for (;;)
 
-+  {
 
-+    UInt32 numAvailFull, newLen, numPairs, posPrev, state, posState, startLen;
 
-+    UInt32 curPrice, curAnd1Price, matchPrice, repMatchPrice;
 
-+    Bool nextIsChar;
 
-+    Byte curByte, matchByte;
 
-+    const Byte *data;
 
-+    COptimal *curOpt;
 
-+    COptimal *nextOpt;
 
-+
 
-+    cur++;
 
-+    if (cur == lenEnd)
 
-+      return Backward(p, backRes, cur);
 
-+
 
-+    newLen = ReadMatchDistances(p, &numPairs);
 
-+    if (newLen >= p->numFastBytes)
 
-+    {
 
-+      p->numPairs = numPairs;
 
-+      p->longestMatchLength = newLen;
 
-+      return Backward(p, backRes, cur);
 
-+    }
 
-+    position++;
 
-+    curOpt = &p->opt[cur];
 
-+    posPrev = curOpt->posPrev;
 
-+    if (curOpt->prev1IsChar)
 
-+    {
 
-+      posPrev--;
 
-+      if (curOpt->prev2)
 
-+      {
 
-+        state = p->opt[curOpt->posPrev2].state;
 
-+        if (curOpt->backPrev2 < LZMA_NUM_REPS)
 
-+          state = kRepNextStates[state];
 
-+        else
 
-+          state = kMatchNextStates[state];
 
-+      }
 
-+      else
 
-+        state = p->opt[posPrev].state;
 
-+      state = kLiteralNextStates[state];
 
-+    }
 
-+    else
 
-+      state = p->opt[posPrev].state;
 
-+    if (posPrev == cur - 1)
 
-+    {
 
-+      if (IsShortRep(curOpt))
 
-+        state = kShortRepNextStates[state];
 
-+      else
 
-+        state = kLiteralNextStates[state];
 
-+    }
 
-+    else
 
-+    {
 
-+      UInt32 pos;
 
-+      const COptimal *prevOpt;
 
-+      if (curOpt->prev1IsChar && curOpt->prev2)
 
-+      {
 
-+        posPrev = curOpt->posPrev2;
 
-+        pos = curOpt->backPrev2;
 
-+        state = kRepNextStates[state];
 
-+      }
 
-+      else
 
-+      {
 
-+        pos = curOpt->backPrev;
 
-+        if (pos < LZMA_NUM_REPS)
 
-+          state = kRepNextStates[state];
 
-+        else
 
-+          state = kMatchNextStates[state];
 
-+      }
 
-+      prevOpt = &p->opt[posPrev];
 
-+      if (pos < LZMA_NUM_REPS)
 
-+      {
 
-+        UInt32 i;
 
-+        reps[0] = prevOpt->backs[pos];
 
-+        for (i = 1; i <= pos; i++)
 
-+          reps[i] = prevOpt->backs[i - 1];
 
-+        for (; i < LZMA_NUM_REPS; i++)
 
-+          reps[i] = prevOpt->backs[i];
 
-+      }
 
-+      else
 
-+      {
 
-+        UInt32 i;
 
-+        reps[0] = (pos - LZMA_NUM_REPS);
 
-+        for (i = 1; i < LZMA_NUM_REPS; i++)
 
-+          reps[i] = prevOpt->backs[i - 1];
 
-+      }
 
-+    }
 
-+    curOpt->state = (CState)state;
 
-+
 
-+    curOpt->backs[0] = reps[0];
 
-+    curOpt->backs[1] = reps[1];
 
-+    curOpt->backs[2] = reps[2];
 
-+    curOpt->backs[3] = reps[3];
 
-+
 
-+    curPrice = curOpt->price;
 
-+    nextIsChar = False;
 
-+    data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
 
-+    curByte = *data;
 
-+    matchByte = *(data - (reps[0] + 1));
 
-+
 
-+    posState = (position & p->pbMask);
 
-+
 
-+    curAnd1Price = curPrice + GET_PRICE_0(p->isMatch[state][posState]);
 
-+    {
 
-+      const CLzmaProb *probs = LIT_PROBS(position, *(data - 1));
 
-+      curAnd1Price +=
 
-+        (!IsCharState(state) ?
 
-+          LitEnc_GetPriceMatched(probs, curByte, matchByte, p->ProbPrices) :
 
-+          LitEnc_GetPrice(probs, curByte, p->ProbPrices));
 
-+    }
 
-+
 
-+    nextOpt = &p->opt[cur + 1];
 
-+
 
-+    if (curAnd1Price < nextOpt->price)
 
-+    {
 
-+      nextOpt->price = curAnd1Price;
 
-+      nextOpt->posPrev = cur;
 
-+      MakeAsChar(nextOpt);
 
-+      nextIsChar = True;
 
-+    }
 
-+
 
-+    matchPrice = curPrice + GET_PRICE_1(p->isMatch[state][posState]);
 
-+    repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[state]);
 
-+    
-+    if (matchByte == curByte && !(nextOpt->posPrev < cur && nextOpt->backPrev == 0))
 
-+    {
 
-+      UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(p, state, posState);
 
-+      if (shortRepPrice <= nextOpt->price)
 
-+      {
 
-+        nextOpt->price = shortRepPrice;
 
-+        nextOpt->posPrev = cur;
 
-+        MakeAsShortRep(nextOpt);
 
-+        nextIsChar = True;
 
-+      }
 
-+    }
 
-+    numAvailFull = p->numAvail;
 
-+    {
 
-+      UInt32 temp = kNumOpts - 1 - cur;
 
-+      if (temp < numAvailFull)
 
-+        numAvailFull = temp;
 
-+    }
 
-+
 
-+    if (numAvailFull < 2)
 
-+      continue;
 
-+    numAvail = (numAvailFull <= p->numFastBytes ? numAvailFull : p->numFastBytes);
 
-+
 
-+    if (!nextIsChar && matchByte != curByte) /* speed optimization */
 
-+    {
 
-+      /* try Literal + rep0 */
 
-+      UInt32 temp;
 
-+      UInt32 lenTest2;
 
-+      const Byte *data2 = data - (reps[0] + 1);
 
-+      UInt32 limit = p->numFastBytes + 1;
 
-+      if (limit > numAvailFull)
 
-+        limit = numAvailFull;
 
-+
 
-+      for (temp = 1; temp < limit && data[temp] == data2[temp]; temp++);
 
-+      lenTest2 = temp - 1;
 
-+      if (lenTest2 >= 2)
 
-+      {
 
-+        UInt32 state2 = kLiteralNextStates[state];
 
-+        UInt32 posStateNext = (position + 1) & p->pbMask;
 
-+        UInt32 nextRepMatchPrice = curAnd1Price +
 
-+            GET_PRICE_1(p->isMatch[state2][posStateNext]) +
 
-+            GET_PRICE_1(p->isRep[state2]);
 
-+        /* for (; lenTest2 >= 2; lenTest2--) */
 
-+        {
 
-+          UInt32 curAndLenPrice;
 
-+          COptimal *opt;
 
-+          UInt32 offset = cur + 1 + lenTest2;
 
-+          while (lenEnd < offset)
 
-+            p->opt[++lenEnd].price = kInfinityPrice;
 
-+          curAndLenPrice = nextRepMatchPrice + GetRepPrice(p, 0, lenTest2, state2, posStateNext);
 
-+          opt = &p->opt[offset];
 
-+          if (curAndLenPrice < opt->price)
 
-+          {
 
-+            opt->price = curAndLenPrice;
 
-+            opt->posPrev = cur + 1;
 
-+            opt->backPrev = 0;
 
-+            opt->prev1IsChar = True;
 
-+            opt->prev2 = False;
 
-+          }
 
-+        }
 
-+      }
 
-+    }
 
-+    
-+    startLen = 2; /* speed optimization */
 
-+    {
 
-+    UInt32 repIndex;
 
-+    for (repIndex = 0; repIndex < LZMA_NUM_REPS; repIndex++)
 
-+    {
 
-+      UInt32 lenTest;
 
-+      UInt32 lenTestTemp;
 
-+      UInt32 price;
 
-+      const Byte *data2 = data - (reps[repIndex] + 1);
 
-+      if (data[0] != data2[0] || data[1] != data2[1])
 
-+        continue;
 
-+      for (lenTest = 2; lenTest < numAvail && data[lenTest] == data2[lenTest]; lenTest++);
 
-+      while (lenEnd < cur + lenTest)
 
-+        p->opt[++lenEnd].price = kInfinityPrice;
 
-+      lenTestTemp = lenTest;
 
-+      price = repMatchPrice + GetPureRepPrice(p, repIndex, state, posState);
 
-+      do
 
-+      {
 
-+        UInt32 curAndLenPrice = price + p->repLenEnc.prices[posState][lenTest - 2];
 
-+        COptimal *opt = &p->opt[cur + lenTest];
 
-+        if (curAndLenPrice < opt->price)
 
-+        {
 
-+          opt->price = curAndLenPrice;
 
-+          opt->posPrev = cur;
 
-+          opt->backPrev = repIndex;
 
-+          opt->prev1IsChar = False;
 
-+        }
 
-+      }
 
-+      while (--lenTest >= 2);
 
-+      lenTest = lenTestTemp;
 
-+      
-+      if (repIndex == 0)
 
-+        startLen = lenTest + 1;
 
-+        
-+      /* if (_maxMode) */
 
-+        {
 
-+          UInt32 lenTest2 = lenTest + 1;
 
-+          UInt32 limit = lenTest2 + p->numFastBytes;
 
-+          UInt32 nextRepMatchPrice;
 
-+          if (limit > numAvailFull)
 
-+            limit = numAvailFull;
 
-+          for (; lenTest2 < limit && data[lenTest2] == data2[lenTest2]; lenTest2++);
 
-+          lenTest2 -= lenTest + 1;
 
-+          if (lenTest2 >= 2)
 
-+          {
 
-+            UInt32 state2 = kRepNextStates[state];
 
-+            UInt32 posStateNext = (position + lenTest) & p->pbMask;
 
-+            UInt32 curAndLenCharPrice =
 
-+                price + p->repLenEnc.prices[posState][lenTest - 2] +
 
-+                GET_PRICE_0(p->isMatch[state2][posStateNext]) +
 
-+                LitEnc_GetPriceMatched(LIT_PROBS(position + lenTest, data[lenTest - 1]),
 
-+                    data[lenTest], data2[lenTest], p->ProbPrices);
 
-+            state2 = kLiteralNextStates[state2];
 
-+            posStateNext = (position + lenTest + 1) & p->pbMask;
 
-+            nextRepMatchPrice = curAndLenCharPrice +
 
-+                GET_PRICE_1(p->isMatch[state2][posStateNext]) +
 
-+                GET_PRICE_1(p->isRep[state2]);
 
-+            
-+            /* for (; lenTest2 >= 2; lenTest2--) */
 
-+            {
 
-+              UInt32 curAndLenPrice;
 
-+              COptimal *opt;
 
-+              UInt32 offset = cur + lenTest + 1 + lenTest2;
 
-+              while (lenEnd < offset)
 
-+                p->opt[++lenEnd].price = kInfinityPrice;
 
-+              curAndLenPrice = nextRepMatchPrice + GetRepPrice(p, 0, lenTest2, state2, posStateNext);
 
-+              opt = &p->opt[offset];
 
-+              if (curAndLenPrice < opt->price)
 
-+              {
 
-+                opt->price = curAndLenPrice;
 
-+                opt->posPrev = cur + lenTest + 1;
 
-+                opt->backPrev = 0;
 
-+                opt->prev1IsChar = True;
 
-+                opt->prev2 = True;
 
-+                opt->posPrev2 = cur;
 
-+                opt->backPrev2 = repIndex;
 
-+              }
 
-+            }
 
-+          }
 
-+        }
 
-+    }
 
-+    }
 
-+    /* for (UInt32 lenTest = 2; lenTest <= newLen; lenTest++) */
 
-+    if (newLen > numAvail)
 
-+    {
 
-+      newLen = numAvail;
 
-+      for (numPairs = 0; newLen > matches[numPairs]; numPairs += 2);
 
-+      matches[numPairs] = newLen;
 
-+      numPairs += 2;
 
-+    }
 
-+    if (newLen >= startLen)
 
-+    {
 
-+      UInt32 normalMatchPrice = matchPrice + GET_PRICE_0(p->isRep[state]);
 
-+      UInt32 offs, curBack, posSlot;
 
-+      UInt32 lenTest;
 
-+      while (lenEnd < cur + newLen)
 
-+        p->opt[++lenEnd].price = kInfinityPrice;
 
-+
 
-+      offs = 0;
 
-+      while (startLen > matches[offs])
 
-+        offs += 2;
 
-+      curBack = matches[offs + 1];
 
-+      GetPosSlot2(curBack, posSlot);
 
-+      for (lenTest = /*2*/ startLen; ; lenTest++)
 
-+      {
 
-+        UInt32 curAndLenPrice = normalMatchPrice + p->lenEnc.prices[posState][lenTest - LZMA_MATCH_LEN_MIN];
 
-+        UInt32 lenToPosState = GetLenToPosState(lenTest);
 
-+        COptimal *opt;
 
-+        if (curBack < kNumFullDistances)
 
-+          curAndLenPrice += p->distancesPrices[lenToPosState][curBack];
 
-+        else
 
-+          curAndLenPrice += p->posSlotPrices[lenToPosState][posSlot] + p->alignPrices[curBack & kAlignMask];
 
-+        
-+        opt = &p->opt[cur + lenTest];
 
-+        if (curAndLenPrice < opt->price)
 
-+        {
 
-+          opt->price = curAndLenPrice;
 
-+          opt->posPrev = cur;
 
-+          opt->backPrev = curBack + LZMA_NUM_REPS;
 
-+          opt->prev1IsChar = False;
 
-+        }
 
-+
 
-+        if (/*_maxMode && */lenTest == matches[offs])
 
-+        {
 
-+          /* Try Match + Literal + Rep0 */
 
-+          const Byte *data2 = data - (curBack + 1);
 
-+          UInt32 lenTest2 = lenTest + 1;
 
-+          UInt32 limit = lenTest2 + p->numFastBytes;
 
-+          UInt32 nextRepMatchPrice;
 
-+          if (limit > numAvailFull)
 
-+            limit = numAvailFull;
 
-+          for (; lenTest2 < limit && data[lenTest2] == data2[lenTest2]; lenTest2++);
 
-+          lenTest2 -= lenTest + 1;
 
-+          if (lenTest2 >= 2)
 
-+          {
 
-+            UInt32 state2 = kMatchNextStates[state];
 
-+            UInt32 posStateNext = (position + lenTest) & p->pbMask;
 
-+            UInt32 curAndLenCharPrice = curAndLenPrice +
 
-+                GET_PRICE_0(p->isMatch[state2][posStateNext]) +
 
-+                LitEnc_GetPriceMatched(LIT_PROBS(position + lenTest, data[lenTest - 1]),
 
-+                    data[lenTest], data2[lenTest], p->ProbPrices);
 
-+            state2 = kLiteralNextStates[state2];
 
-+            posStateNext = (posStateNext + 1) & p->pbMask;
 
-+            nextRepMatchPrice = curAndLenCharPrice +
 
-+                GET_PRICE_1(p->isMatch[state2][posStateNext]) +
 
-+                GET_PRICE_1(p->isRep[state2]);
 
-+            
-+            /* for (; lenTest2 >= 2; lenTest2--) */
 
-+            {
 
-+              UInt32 offset = cur + lenTest + 1 + lenTest2;
 
-+              UInt32 curAndLenPrice;
 
-+              COptimal *opt;
 
-+              while (lenEnd < offset)
 
-+                p->opt[++lenEnd].price = kInfinityPrice;
 
-+              curAndLenPrice = nextRepMatchPrice + GetRepPrice(p, 0, lenTest2, state2, posStateNext);
 
-+              opt = &p->opt[offset];
 
-+              if (curAndLenPrice < opt->price)
 
-+              {
 
-+                opt->price = curAndLenPrice;
 
-+                opt->posPrev = cur + lenTest + 1;
 
-+                opt->backPrev = 0;
 
-+                opt->prev1IsChar = True;
 
-+                opt->prev2 = True;
 
-+                opt->posPrev2 = cur;
 
-+                opt->backPrev2 = curBack + LZMA_NUM_REPS;
 
-+              }
 
-+            }
 
-+          }
 
-+          offs += 2;
 
-+          if (offs == numPairs)
 
-+            break;
 
-+          curBack = matches[offs + 1];
 
-+          if (curBack >= kNumFullDistances)
 
-+            GetPosSlot2(curBack, posSlot);
 
-+        }
 
-+      }
 
-+    }
 
-+  }
 
-+}
 
-+
 
-+#define ChangePair(smallDist, bigDist) (((bigDist) >> 7) > (smallDist))
 
-+
 
-+static UInt32 GetOptimumFast(CLzmaEnc *p, UInt32 *backRes)
 
-+{
 
-+  UInt32 numAvail, mainLen, mainDist, numPairs, repIndex, repLen, i;
 
-+  const Byte *data;
 
-+  const UInt32 *matches;
 
-+
 
-+  if (p->additionalOffset == 0)
 
-+    mainLen = ReadMatchDistances(p, &numPairs);
 
-+  else
 
-+  {
 
-+    mainLen = p->longestMatchLength;
 
-+    numPairs = p->numPairs;
 
-+  }
 
-+
 
-+  numAvail = p->numAvail;
 
-+  *backRes = (UInt32)-1;
 
-+  if (numAvail < 2)
 
-+    return 1;
 
-+  if (numAvail > LZMA_MATCH_LEN_MAX)
 
-+    numAvail = LZMA_MATCH_LEN_MAX;
 
-+  data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
 
-+
 
-+  repLen = repIndex = 0;
 
-+  for (i = 0; i < LZMA_NUM_REPS; i++)
 
-+  {
 
-+    UInt32 len;
 
-+    const Byte *data2 = data - (p->reps[i] + 1);
 
-+    if (data[0] != data2[0] || data[1] != data2[1])
 
-+      continue;
 
-+    for (len = 2; len < numAvail && data[len] == data2[len]; len++);
 
-+    if (len >= p->numFastBytes)
 
-+    {
 
-+      *backRes = i;
 
-+      MovePos(p, len - 1);
 
-+      return len;
 
-+    }
 
-+    if (len > repLen)
 
-+    {
 
-+      repIndex = i;
 
-+      repLen = len;
 
-+    }
 
-+  }
 
-+
 
-+  matches = p->matches;
 
-+  if (mainLen >= p->numFastBytes)
 
-+  {
 
-+    *backRes = matches[numPairs - 1] + LZMA_NUM_REPS;
 
-+    MovePos(p, mainLen - 1);
 
-+    return mainLen;
 
-+  }
 
-+
 
-+  mainDist = 0; /* for GCC */
 
-+  if (mainLen >= 2)
 
-+  {
 
-+    mainDist = matches[numPairs - 1];
 
-+    while (numPairs > 2 && mainLen == matches[numPairs - 4] + 1)
 
-+    {
 
-+      if (!ChangePair(matches[numPairs - 3], mainDist))
 
-+        break;
 
-+      numPairs -= 2;
 
-+      mainLen = matches[numPairs - 2];
 
-+      mainDist = matches[numPairs - 1];
 
-+    }
 
-+    if (mainLen == 2 && mainDist >= 0x80)
 
-+      mainLen = 1;
 
-+  }
 
-+
 
-+  if (repLen >= 2 && (
 
-+        (repLen + 1 >= mainLen) ||
 
-+        (repLen + 2 >= mainLen && mainDist >= (1 << 9)) ||
 
-+        (repLen + 3 >= mainLen && mainDist >= (1 << 15))))
 
-+  {
 
-+    *backRes = repIndex;
 
-+    MovePos(p, repLen - 1);
 
-+    return repLen;
 
-+  }
 
-+  
-+  if (mainLen < 2 || numAvail <= 2)
 
-+    return 1;
 
-+
 
-+  p->longestMatchLength = ReadMatchDistances(p, &p->numPairs);
 
-+  if (p->longestMatchLength >= 2)
 
-+  {
 
-+    UInt32 newDistance = matches[p->numPairs - 1];
 
-+    if ((p->longestMatchLength >= mainLen && newDistance < mainDist) ||
 
-+        (p->longestMatchLength == mainLen + 1 && !ChangePair(mainDist, newDistance)) ||
 
-+        (p->longestMatchLength > mainLen + 1) ||
 
-+        (p->longestMatchLength + 1 >= mainLen && mainLen >= 3 && ChangePair(newDistance, mainDist)))
 
-+      return 1;
 
-+  }
 
-+  
-+  data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
 
-+  for (i = 0; i < LZMA_NUM_REPS; i++)
 
-+  {
 
-+    UInt32 len, limit;
 
-+    const Byte *data2 = data - (p->reps[i] + 1);
 
-+    if (data[0] != data2[0] || data[1] != data2[1])
 
-+      continue;
 
-+    limit = mainLen - 1;
 
-+    for (len = 2; len < limit && data[len] == data2[len]; len++);
 
-+    if (len >= limit)
 
-+      return 1;
 
-+  }
 
-+  *backRes = mainDist + LZMA_NUM_REPS;
 
-+  MovePos(p, mainLen - 2);
 
-+  return mainLen;
 
-+}
 
-+
 
-+static void WriteEndMarker(CLzmaEnc *p, UInt32 posState)
 
-+{
 
-+  UInt32 len;
 
-+  RangeEnc_EncodeBit(&p->rc, &p->isMatch[p->state][posState], 1);
 
-+  RangeEnc_EncodeBit(&p->rc, &p->isRep[p->state], 0);
 
-+  p->state = kMatchNextStates[p->state];
 
-+  len = LZMA_MATCH_LEN_MIN;
 
-+  LenEnc_Encode2(&p->lenEnc, &p->rc, len - LZMA_MATCH_LEN_MIN, posState, !p->fastMode, p->ProbPrices);
 
-+  RcTree_Encode(&p->rc, p->posSlotEncoder[GetLenToPosState(len)], kNumPosSlotBits, (1 << kNumPosSlotBits) - 1);
 
-+  RangeEnc_EncodeDirectBits(&p->rc, (((UInt32)1 << 30) - 1) >> kNumAlignBits, 30 - kNumAlignBits);
 
-+  RcTree_ReverseEncode(&p->rc, p->posAlignEncoder, kNumAlignBits, kAlignMask);
 
-+}
 
-+
 
-+static SRes CheckErrors(CLzmaEnc *p)
 
-+{
 
-+  if (p->result != SZ_OK)
 
-+    return p->result;
 
-+  if (p->rc.res != SZ_OK)
 
-+    p->result = SZ_ERROR_WRITE;
 
-+  if (p->matchFinderBase.result != SZ_OK)
 
-+    p->result = SZ_ERROR_READ;
 
-+  if (p->result != SZ_OK)
 
-+    p->finished = True;
 
-+  return p->result;
 
-+}
 
-+
 
-+static SRes Flush(CLzmaEnc *p, UInt32 nowPos)
 
-+{
 
-+  /* ReleaseMFStream(); */
 
-+  p->finished = True;
 
-+  if (p->writeEndMark)
 
-+    WriteEndMarker(p, nowPos & p->pbMask);
 
-+  RangeEnc_FlushData(&p->rc);
 
-+  RangeEnc_FlushStream(&p->rc);
 
-+  return CheckErrors(p);
 
-+}
 
-+
 
-+static void FillAlignPrices(CLzmaEnc *p)
 
-+{
 
-+  UInt32 i;
 
-+  for (i = 0; i < kAlignTableSize; i++)
 
-+    p->alignPrices[i] = RcTree_ReverseGetPrice(p->posAlignEncoder, kNumAlignBits, i, p->ProbPrices);
 
-+  p->alignPriceCount = 0;
 
-+}
 
-+
 
-+static void FillDistancesPrices(CLzmaEnc *p)
 
-+{
 
-+  UInt32 tempPrices[kNumFullDistances];
 
-+  UInt32 i, lenToPosState;
 
-+  for (i = kStartPosModelIndex; i < kNumFullDistances; i++)
 
-+  {
 
-+    UInt32 posSlot = GetPosSlot1(i);
 
-+    UInt32 footerBits = ((posSlot >> 1) - 1);
 
-+    UInt32 base = ((2 | (posSlot & 1)) << footerBits);
 
-+    tempPrices[i] = RcTree_ReverseGetPrice(p->posEncoders + base - posSlot - 1, footerBits, i - base, p->ProbPrices);
 
-+  }
 
-+
 
-+  for (lenToPosState = 0; lenToPosState < kNumLenToPosStates; lenToPosState++)
 
-+  {
 
-+    UInt32 posSlot;
 
-+    const CLzmaProb *encoder = p->posSlotEncoder[lenToPosState];
 
-+    UInt32 *posSlotPrices = p->posSlotPrices[lenToPosState];
 
-+    for (posSlot = 0; posSlot < p->distTableSize; posSlot++)
 
-+      posSlotPrices[posSlot] = RcTree_GetPrice(encoder, kNumPosSlotBits, posSlot, p->ProbPrices);
 
-+    for (posSlot = kEndPosModelIndex; posSlot < p->distTableSize; posSlot++)
 
-+      posSlotPrices[posSlot] += ((((posSlot >> 1) - 1) - kNumAlignBits) << kNumBitPriceShiftBits);
 
-+
 
-+    {
 
-+      UInt32 *distancesPrices = p->distancesPrices[lenToPosState];
 
-+      UInt32 i;
 
-+      for (i = 0; i < kStartPosModelIndex; i++)
 
-+        distancesPrices[i] = posSlotPrices[i];
 
-+      for (; i < kNumFullDistances; i++)
 
-+        distancesPrices[i] = posSlotPrices[GetPosSlot1(i)] + tempPrices[i];
 
-+    }
 
-+  }
 
-+  p->matchPriceCount = 0;
 
-+}
 
-+
 
-+void LzmaEnc_Construct(CLzmaEnc *p)
 
-+{
 
-+  RangeEnc_Construct(&p->rc);
 
-+  MatchFinder_Construct(&p->matchFinderBase);
 
-+  #ifndef _7ZIP_ST
 
-+  MatchFinderMt_Construct(&p->matchFinderMt);
 
-+  p->matchFinderMt.MatchFinder = &p->matchFinderBase;
 
-+  #endif
 
-+
 
-+  {
 
-+    CLzmaEncProps props;
 
-+    LzmaEncProps_Init(&props);
 
-+    LzmaEnc_SetProps(p, &props);
 
-+  }
 
-+
 
-+  #ifndef LZMA_LOG_BSR
 
-+  LzmaEnc_FastPosInit(p->g_FastPos);
 
-+  #endif
 
-+
 
-+  LzmaEnc_InitPriceTables(p->ProbPrices);
 
-+  p->litProbs = 0;
 
-+  p->saveState.litProbs = 0;
 
-+}
 
-+
 
-+CLzmaEncHandle LzmaEnc_Create(ISzAlloc *alloc)
 
-+{
 
-+  void *p;
 
-+  p = alloc->Alloc(alloc, sizeof(CLzmaEnc));
 
-+  if (p != 0)
 
-+    LzmaEnc_Construct((CLzmaEnc *)p);
 
-+  return p;
 
-+}
 
-+
 
-+void LzmaEnc_FreeLits(CLzmaEnc *p, ISzAlloc *alloc)
 
-+{
 
-+  alloc->Free(alloc, p->litProbs);
 
-+  alloc->Free(alloc, p->saveState.litProbs);
 
-+  p->litProbs = 0;
 
-+  p->saveState.litProbs = 0;
 
-+}
 
-+
 
-+void LzmaEnc_Destruct(CLzmaEnc *p, ISzAlloc *alloc, ISzAlloc *allocBig)
 
-+{
 
-+  #ifndef _7ZIP_ST
 
-+  MatchFinderMt_Destruct(&p->matchFinderMt, allocBig);
 
-+  #endif
 
-+  MatchFinder_Free(&p->matchFinderBase, allocBig);
 
-+  LzmaEnc_FreeLits(p, alloc);
 
-+  RangeEnc_Free(&p->rc, alloc);
 
-+}
 
-+
 
-+void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAlloc *alloc, ISzAlloc *allocBig)
 
-+{
 
-+  LzmaEnc_Destruct((CLzmaEnc *)p, alloc, allocBig);
 
-+  alloc->Free(alloc, p);
 
-+}
 
-+
 
-+static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, Bool useLimits, UInt32 maxPackSize, UInt32 maxUnpackSize)
 
-+{
 
-+  UInt32 nowPos32, startPos32;
 
-+  if (p->needInit)
 
-+  {
 
-+    p->matchFinder.Init(p->matchFinderObj);
 
-+    p->needInit = 0;
 
-+  }
 
-+
 
-+  if (p->finished)
 
-+    return p->result;
 
-+  RINOK(CheckErrors(p));
 
-+
 
-+  nowPos32 = (UInt32)p->nowPos64;
 
-+  startPos32 = nowPos32;
 
-+
 
-+  if (p->nowPos64 == 0)
 
-+  {
 
-+    UInt32 numPairs;
 
-+    Byte curByte;
 
-+    if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) == 0)
 
-+      return Flush(p, nowPos32);
 
-+    ReadMatchDistances(p, &numPairs);
 
-+    RangeEnc_EncodeBit(&p->rc, &p->isMatch[p->state][0], 0);
 
-+    p->state = kLiteralNextStates[p->state];
 
-+    curByte = p->matchFinder.GetIndexByte(p->matchFinderObj, 0 - p->additionalOffset);
 
-+    LitEnc_Encode(&p->rc, p->litProbs, curByte);
 
-+    p->additionalOffset--;
 
-+    nowPos32++;
 
-+  }
 
-+
 
-+  if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) != 0)
 
-+  for (;;)
 
-+  {
 
-+    UInt32 pos, len, posState;
 
-+
 
-+    if (p->fastMode)
 
-+      len = GetOptimumFast(p, &pos);
 
-+    else
 
-+      len = GetOptimum(p, nowPos32, &pos);
 
-+
 
-+    #ifdef SHOW_STAT2
 
-+    printf("\n pos = %4X,   len = %d   pos = %d", nowPos32, len, pos);
 
-+    #endif
 
-+
 
-+    posState = nowPos32 & p->pbMask;
 
-+    if (len == 1 && pos == (UInt32)-1)
 
-+    {
 
-+      Byte curByte;
 
-+      CLzmaProb *probs;
 
-+      const Byte *data;
 
-+
 
-+      RangeEnc_EncodeBit(&p->rc, &p->isMatch[p->state][posState], 0);
 
-+      data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - p->additionalOffset;
 
-+      curByte = *data;
 
-+      probs = LIT_PROBS(nowPos32, *(data - 1));
 
-+      if (IsCharState(p->state))
 
-+        LitEnc_Encode(&p->rc, probs, curByte);
 
-+      else
 
-+        LitEnc_EncodeMatched(&p->rc, probs, curByte, *(data - p->reps[0] - 1));
 
-+      p->state = kLiteralNextStates[p->state];
 
-+    }
 
-+    else
 
-+    {
 
-+      RangeEnc_EncodeBit(&p->rc, &p->isMatch[p->state][posState], 1);
 
-+      if (pos < LZMA_NUM_REPS)
 
-+      {
 
-+        RangeEnc_EncodeBit(&p->rc, &p->isRep[p->state], 1);
 
-+        if (pos == 0)
 
-+        {
 
-+          RangeEnc_EncodeBit(&p->rc, &p->isRepG0[p->state], 0);
 
-+          RangeEnc_EncodeBit(&p->rc, &p->isRep0Long[p->state][posState], ((len == 1) ? 0 : 1));
 
-+        }
 
-+        else
 
-+        {
 
-+          UInt32 distance = p->reps[pos];
 
-+          RangeEnc_EncodeBit(&p->rc, &p->isRepG0[p->state], 1);
 
-+          if (pos == 1)
 
-+            RangeEnc_EncodeBit(&p->rc, &p->isRepG1[p->state], 0);
 
-+          else
 
-+          {
 
-+            RangeEnc_EncodeBit(&p->rc, &p->isRepG1[p->state], 1);
 
-+            RangeEnc_EncodeBit(&p->rc, &p->isRepG2[p->state], pos - 2);
 
-+            if (pos == 3)
 
-+              p->reps[3] = p->reps[2];
 
-+            p->reps[2] = p->reps[1];
 
-+          }
 
-+          p->reps[1] = p->reps[0];
 
-+          p->reps[0] = distance;
 
-+        }
 
-+        if (len == 1)
 
-+          p->state = kShortRepNextStates[p->state];
 
-+        else
 
-+        {
 
-+          LenEnc_Encode2(&p->repLenEnc, &p->rc, len - LZMA_MATCH_LEN_MIN, posState, !p->fastMode, p->ProbPrices);
 
-+          p->state = kRepNextStates[p->state];
 
-+        }
 
-+      }
 
-+      else
 
-+      {
 
-+        UInt32 posSlot;
 
-+        RangeEnc_EncodeBit(&p->rc, &p->isRep[p->state], 0);
 
-+        p->state = kMatchNextStates[p->state];
 
-+        LenEnc_Encode2(&p->lenEnc, &p->rc, len - LZMA_MATCH_LEN_MIN, posState, !p->fastMode, p->ProbPrices);
 
-+        pos -= LZMA_NUM_REPS;
 
-+        GetPosSlot(pos, posSlot);
 
-+        RcTree_Encode(&p->rc, p->posSlotEncoder[GetLenToPosState(len)], kNumPosSlotBits, posSlot);
 
-+        
-+        if (posSlot >= kStartPosModelIndex)
 
-+        {
 
-+          UInt32 footerBits = ((posSlot >> 1) - 1);
 
-+          UInt32 base = ((2 | (posSlot & 1)) << footerBits);
 
-+          UInt32 posReduced = pos - base;
 
-+
 
-+          if (posSlot < kEndPosModelIndex)
 
-+            RcTree_ReverseEncode(&p->rc, p->posEncoders + base - posSlot - 1, footerBits, posReduced);
 
-+          else
 
-+          {
 
-+            RangeEnc_EncodeDirectBits(&p->rc, posReduced >> kNumAlignBits, footerBits - kNumAlignBits);
 
-+            RcTree_ReverseEncode(&p->rc, p->posAlignEncoder, kNumAlignBits, posReduced & kAlignMask);
 
-+            p->alignPriceCount++;
 
-+          }
 
-+        }
 
-+        p->reps[3] = p->reps[2];
 
-+        p->reps[2] = p->reps[1];
 
-+        p->reps[1] = p->reps[0];
 
-+        p->reps[0] = pos;
 
-+        p->matchPriceCount++;
 
-+      }
 
-+    }
 
-+    p->additionalOffset -= len;
 
-+    nowPos32 += len;
 
-+    if (p->additionalOffset == 0)
 
-+    {
 
-+      UInt32 processed;
 
-+      if (!p->fastMode)
 
-+      {
 
-+        if (p->matchPriceCount >= (1 << 7))
 
-+          FillDistancesPrices(p);
 
-+        if (p->alignPriceCount >= kAlignTableSize)
 
-+          FillAlignPrices(p);
 
-+      }
 
-+      if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) == 0)
 
-+        break;
 
-+      processed = nowPos32 - startPos32;
 
-+      if (useLimits)
 
-+      {
 
-+        if (processed + kNumOpts + 300 >= maxUnpackSize ||
 
-+            RangeEnc_GetProcessed(&p->rc) + kNumOpts * 2 >= maxPackSize)
 
-+          break;
 
-+      }
 
-+      else if (processed >= (1 << 15))
 
-+      {
 
-+        p->nowPos64 += nowPos32 - startPos32;
 
-+        return CheckErrors(p);
 
-+      }
 
-+    }
 
-+  }
 
-+  p->nowPos64 += nowPos32 - startPos32;
 
-+  return Flush(p, nowPos32);
 
-+}
 
-+
 
-+#define kBigHashDicLimit ((UInt32)1 << 24)
 
-+
 
-+static SRes LzmaEnc_Alloc(CLzmaEnc *p, UInt32 keepWindowSize, ISzAlloc *alloc, ISzAlloc *allocBig)
 
-+{
 
-+  UInt32 beforeSize = kNumOpts;
 
-+  Bool btMode;
 
-+  if (!RangeEnc_Alloc(&p->rc, alloc))
 
-+    return SZ_ERROR_MEM;
 
-+  btMode = (p->matchFinderBase.btMode != 0);
 
-+  #ifndef _7ZIP_ST
 
-+  p->mtMode = (p->multiThread && !p->fastMode && btMode);
 
-+  #endif
 
-+
 
-+  {
 
-+    unsigned lclp = p->lc + p->lp;
 
-+    if (p->litProbs == 0 || p->saveState.litProbs == 0 || p->lclp != lclp)
 
-+    {
 
-+      LzmaEnc_FreeLits(p, alloc);
 
-+      p->litProbs = (CLzmaProb *)alloc->Alloc(alloc, (0x300 << lclp) * sizeof(CLzmaProb));
 
-+      p->saveState.litProbs = (CLzmaProb *)alloc->Alloc(alloc, (0x300 << lclp) * sizeof(CLzmaProb));
 
-+      if (p->litProbs == 0 || p->saveState.litProbs == 0)
 
-+      {
 
-+        LzmaEnc_FreeLits(p, alloc);
 
-+        return SZ_ERROR_MEM;
 
-+      }
 
-+      p->lclp = lclp;
 
-+    }
 
-+  }
 
-+
 
-+  p->matchFinderBase.bigHash = (p->dictSize > kBigHashDicLimit);
 
-+
 
-+  if (beforeSize + p->dictSize < keepWindowSize)
 
-+    beforeSize = keepWindowSize - p->dictSize;
 
-+
 
-+  #ifndef _7ZIP_ST
 
-+  if (p->mtMode)
 
-+  {
 
-+    RINOK(MatchFinderMt_Create(&p->matchFinderMt, p->dictSize, beforeSize, p->numFastBytes, LZMA_MATCH_LEN_MAX, allocBig));
 
-+    p->matchFinderObj = &p->matchFinderMt;
 
-+    MatchFinderMt_CreateVTable(&p->matchFinderMt, &p->matchFinder);
 
-+  }
 
-+  else
 
-+  #endif
 
-+  {
 
-+    if (!MatchFinder_Create(&p->matchFinderBase, p->dictSize, beforeSize, p->numFastBytes, LZMA_MATCH_LEN_MAX, allocBig))
 
-+      return SZ_ERROR_MEM;
 
-+    p->matchFinderObj = &p->matchFinderBase;
 
-+    MatchFinder_CreateVTable(&p->matchFinderBase, &p->matchFinder);
 
-+  }
 
-+  return SZ_OK;
 
-+}
 
-+
 
-+void LzmaEnc_Init(CLzmaEnc *p)
 
-+{
 
-+  UInt32 i;
 
-+  p->state = 0;
 
-+  for (i = 0 ; i < LZMA_NUM_REPS; i++)
 
-+    p->reps[i] = 0;
 
-+
 
-+  RangeEnc_Init(&p->rc);
 
-+
 
-+
 
-+  for (i = 0; i < kNumStates; i++)
 
-+  {
 
-+    UInt32 j;
 
-+    for (j = 0; j < LZMA_NUM_PB_STATES_MAX; j++)
 
-+    {
 
-+      p->isMatch[i][j] = kProbInitValue;
 
-+      p->isRep0Long[i][j] = kProbInitValue;
 
-+    }
 
-+    p->isRep[i] = kProbInitValue;
 
-+    p->isRepG0[i] = kProbInitValue;
 
-+    p->isRepG1[i] = kProbInitValue;
 
-+    p->isRepG2[i] = kProbInitValue;
 
-+  }
 
-+
 
-+  {
 
-+    UInt32 num = 0x300 << (p->lp + p->lc);
 
-+    for (i = 0; i < num; i++)
 
-+      p->litProbs[i] = kProbInitValue;
 
-+  }
 
-+
 
-+  {
 
-+    for (i = 0; i < kNumLenToPosStates; i++)
 
-+    {
 
-+      CLzmaProb *probs = p->posSlotEncoder[i];
 
-+      UInt32 j;
 
-+      for (j = 0; j < (1 << kNumPosSlotBits); j++)
 
-+        probs[j] = kProbInitValue;
 
-+    }
 
-+  }
 
-+  {
 
-+    for (i = 0; i < kNumFullDistances - kEndPosModelIndex; i++)
 
-+      p->posEncoders[i] = kProbInitValue;
 
-+  }
 
-+
 
-+  LenEnc_Init(&p->lenEnc.p);
 
-+  LenEnc_Init(&p->repLenEnc.p);
 
-+
 
-+  for (i = 0; i < (1 << kNumAlignBits); i++)
 
-+    p->posAlignEncoder[i] = kProbInitValue;
 
-+
 
-+  p->optimumEndIndex = 0;
 
-+  p->optimumCurrentIndex = 0;
 
-+  p->additionalOffset = 0;
 
-+
 
-+  p->pbMask = (1 << p->pb) - 1;
 
-+  p->lpMask = (1 << p->lp) - 1;
 
-+}
 
-+
 
-+void LzmaEnc_InitPrices(CLzmaEnc *p)
 
-+{
 
-+  if (!p->fastMode)
 
-+  {
 
-+    FillDistancesPrices(p);
 
-+    FillAlignPrices(p);
 
-+  }
 
-+
 
-+  p->lenEnc.tableSize =
 
-+  p->repLenEnc.tableSize =
 
-+      p->numFastBytes + 1 - LZMA_MATCH_LEN_MIN;
 
-+  LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, p->ProbPrices);
 
-+  LenPriceEnc_UpdateTables(&p->repLenEnc, 1 << p->pb, p->ProbPrices);
 
-+}
 
-+
 
-+static SRes LzmaEnc_AllocAndInit(CLzmaEnc *p, UInt32 keepWindowSize, ISzAlloc *alloc, ISzAlloc *allocBig)
 
-+{
 
-+  UInt32 i;
 
-+  for (i = 0; i < (UInt32)kDicLogSizeMaxCompress; i++)
 
-+    if (p->dictSize <= ((UInt32)1 << i))
 
-+      break;
 
-+  p->distTableSize = i * 2;
 
-+
 
-+  p->finished = False;
 
-+  p->result = SZ_OK;
 
-+  RINOK(LzmaEnc_Alloc(p, keepWindowSize, alloc, allocBig));
 
-+  LzmaEnc_Init(p);
 
-+  LzmaEnc_InitPrices(p);
 
-+  p->nowPos64 = 0;
 
-+  return SZ_OK;
 
-+}
 
-+
 
-+static SRes LzmaEnc_Prepare(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream,
 
-+    ISzAlloc *alloc, ISzAlloc *allocBig)
 
-+{
 
-+  CLzmaEnc *p = (CLzmaEnc *)pp;
 
-+  p->matchFinderBase.stream = inStream;
 
-+  p->needInit = 1;
 
-+  p->rc.outStream = outStream;
 
-+  return LzmaEnc_AllocAndInit(p, 0, alloc, allocBig);
 
-+}
 
-+
 
-+SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle pp,
 
-+    ISeqInStream *inStream, UInt32 keepWindowSize,
 
-+    ISzAlloc *alloc, ISzAlloc *allocBig)
 
-+{
 
-+  CLzmaEnc *p = (CLzmaEnc *)pp;
 
-+  p->matchFinderBase.stream = inStream;
 
-+  p->needInit = 1;
 
-+  return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
 
-+}
 
-+
 
-+static void LzmaEnc_SetInputBuf(CLzmaEnc *p, const Byte *src, SizeT srcLen)
 
-+{
 
-+  p->matchFinderBase.directInput = 1;
 
-+  p->matchFinderBase.bufferBase = (Byte *)src;
 
-+  p->matchFinderBase.directInputRem = srcLen;
 
-+}
 
-+
 
-+SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,
 
-+    UInt32 keepWindowSize, ISzAlloc *alloc, ISzAlloc *allocBig)
 
-+{
 
-+  CLzmaEnc *p = (CLzmaEnc *)pp;
 
-+  LzmaEnc_SetInputBuf(p, src, srcLen);
 
-+  p->needInit = 1;
 
-+
 
-+  return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
 
-+}
 
-+
 
-+void LzmaEnc_Finish(CLzmaEncHandle pp)
 
-+{
 
-+  #ifndef _7ZIP_ST
 
-+  CLzmaEnc *p = (CLzmaEnc *)pp;
 
-+  if (p->mtMode)
 
-+    MatchFinderMt_ReleaseStream(&p->matchFinderMt);
 
-+  #else
 
-+  pp = pp;
 
-+  #endif
 
-+}
 
-+
 
-+typedef struct
 
-+{
 
-+  ISeqOutStream funcTable;
 
-+  Byte *data;
 
-+  SizeT rem;
 
-+  Bool overflow;
 
-+} CSeqOutStreamBuf;
 
-+
 
-+static size_t MyWrite(void *pp, const void *data, size_t size)
 
-+{
 
-+  CSeqOutStreamBuf *p = (CSeqOutStreamBuf *)pp;
 
-+  if (p->rem < size)
 
-+  {
 
-+    size = p->rem;
 
-+    p->overflow = True;
 
-+  }
 
-+  memcpy(p->data, data, size);
 
-+  p->rem -= size;
 
-+  p->data += size;
 
-+  return size;
 
-+}
 
-+
 
-+
 
-+UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle pp)
 
-+{
 
-+  const CLzmaEnc *p = (CLzmaEnc *)pp;
 
-+  return p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
 
-+}
 
-+
 
-+const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle pp)
 
-+{
 
-+  const CLzmaEnc *p = (CLzmaEnc *)pp;
 
-+  return p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - p->additionalOffset;
 
-+}
 
-+
 
-+SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, Bool reInit,
 
-+    Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize)
 
-+{
 
-+  CLzmaEnc *p = (CLzmaEnc *)pp;
 
-+  UInt64 nowPos64;
 
-+  SRes res;
 
-+  CSeqOutStreamBuf outStream;
 
-+
 
-+  outStream.funcTable.Write = MyWrite;
 
-+  outStream.data = dest;
 
-+  outStream.rem = *destLen;
 
-+  outStream.overflow = False;
 
-+
 
-+  p->writeEndMark = False;
 
-+  p->finished = False;
 
-+  p->result = SZ_OK;
 
-+
 
-+  if (reInit)
 
-+    LzmaEnc_Init(p);
 
-+  LzmaEnc_InitPrices(p);
 
-+  nowPos64 = p->nowPos64;
 
-+  RangeEnc_Init(&p->rc);
 
-+  p->rc.outStream = &outStream.funcTable;
 
-+
 
-+  res = LzmaEnc_CodeOneBlock(p, True, desiredPackSize, *unpackSize);
 
-+  
-+  *unpackSize = (UInt32)(p->nowPos64 - nowPos64);
 
-+  *destLen -= outStream.rem;
 
-+  if (outStream.overflow)
 
-+    return SZ_ERROR_OUTPUT_EOF;
 
-+
 
-+  return res;
 
-+}
 
-+
 
-+static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress)
 
-+{
 
-+  SRes res = SZ_OK;
 
-+
 
-+  #ifndef _7ZIP_ST
 
-+  Byte allocaDummy[0x300];
 
-+  int i = 0;
 
-+  for (i = 0; i < 16; i++)
 
-+    allocaDummy[i] = (Byte)i;
 
-+  #endif
 
-+
 
-+  for (;;)
 
-+  {
 
-+    res = LzmaEnc_CodeOneBlock(p, False, 0, 0);
 
-+    if (res != SZ_OK || p->finished != 0)
 
-+      break;
 
-+    if (progress != 0)
 
-+    {
 
-+      res = progress->Progress(progress, p->nowPos64, RangeEnc_GetProcessed(&p->rc));
 
-+      if (res != SZ_OK)
 
-+      {
 
-+        res = SZ_ERROR_PROGRESS;
 
-+        break;
 
-+      }
 
-+    }
 
-+  }
 
-+  LzmaEnc_Finish(p);
 
-+  return res;
 
-+}
 
-+
 
-+SRes LzmaEnc_Encode(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress,
 
-+    ISzAlloc *alloc, ISzAlloc *allocBig)
 
-+{
 
-+  RINOK(LzmaEnc_Prepare(pp, outStream, inStream, alloc, allocBig));
 
-+  return LzmaEnc_Encode2((CLzmaEnc *)pp, progress);
 
-+}
 
-+
 
-+SRes LzmaEnc_WriteProperties(CLzmaEncHandle pp, Byte *props, SizeT *size)
 
-+{
 
-+  CLzmaEnc *p = (CLzmaEnc *)pp;
 
-+  int i;
 
-+  UInt32 dictSize = p->dictSize;
 
-+  if (*size < LZMA_PROPS_SIZE)
 
-+    return SZ_ERROR_PARAM;
 
-+  *size = LZMA_PROPS_SIZE;
 
-+  props[0] = (Byte)((p->pb * 5 + p->lp) * 9 + p->lc);
 
-+
 
-+  for (i = 11; i <= 30; i++)
 
-+  {
 
-+    if (dictSize <= ((UInt32)2 << i))
 
-+    {
 
-+      dictSize = (2 << i);
 
-+      break;
 
-+    }
 
-+    if (dictSize <= ((UInt32)3 << i))
 
-+    {
 
-+      dictSize = (3 << i);
 
-+      break;
 
-+    }
 
-+  }
 
-+
 
-+  for (i = 0; i < 4; i++)
 
-+    props[1 + i] = (Byte)(dictSize >> (8 * i));
 
-+  return SZ_OK;
 
-+}
 
-+
 
-+SRes LzmaEnc_MemEncode(CLzmaEncHandle pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
 
-+    int writeEndMark, ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig)
 
-+{
 
-+  SRes res;
 
-+  CLzmaEnc *p = (CLzmaEnc *)pp;
 
-+
 
-+  CSeqOutStreamBuf outStream;
 
-+
 
-+  LzmaEnc_SetInputBuf(p, src, srcLen);
 
-+
 
-+  outStream.funcTable.Write = MyWrite;
 
-+  outStream.data = dest;
 
-+  outStream.rem = *destLen;
 
-+  outStream.overflow = False;
 
-+
 
-+  p->writeEndMark = writeEndMark;
 
-+
 
-+  p->rc.outStream = &outStream.funcTable;
 
-+  res = LzmaEnc_MemPrepare(pp, src, srcLen, 0, alloc, allocBig);
 
-+  if (res == SZ_OK)
 
-+    res = LzmaEnc_Encode2(p, progress);
 
-+
 
-+  *destLen -= outStream.rem;
 
-+  if (outStream.overflow)
 
-+    return SZ_ERROR_OUTPUT_EOF;
 
-+  return res;
 
-+}
 
-+
 
-+SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
 
-+    const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
 
-+    ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig)
 
-+{
 
-+  CLzmaEnc *p = (CLzmaEnc *)LzmaEnc_Create(alloc);
 
-+  SRes res;
 
-+  if (p == 0)
 
-+    return SZ_ERROR_MEM;
 
-+
 
-+  res = LzmaEnc_SetProps(p, props);
 
-+  if (res == SZ_OK)
 
-+  {
 
-+    res = LzmaEnc_WriteProperties(p, propsEncoded, propsSize);
 
-+    if (res == SZ_OK)
 
-+      res = LzmaEnc_MemEncode(p, dest, destLen, src, srcLen,
 
-+          writeEndMark, progress, alloc, allocBig);
 
-+  }
 
-+
 
-+  LzmaEnc_Destroy(p, alloc, allocBig);
 
-+  return res;
 
-+}
 
---- /dev/null
 
-+++ b/lib/lzma/Makefile
 
-@@ -0,0 +1,7 @@
 
-+lzma_compress-objs := LzFind.o LzmaEnc.o
 
-+lzma_decompress-objs := LzmaDec.o
 
-+
 
-+obj-$(CONFIG_LZMA_COMPRESS) += lzma_compress.o
 
-+obj-$(CONFIG_LZMA_DECOMPRESS) += lzma_decompress.o
 
-+
 
-+EXTRA_CFLAGS += -Iinclude/linux -Iinclude/linux/lzma -include types.h

Some files were not shown because too many files changed in this diff