brcm2708: add linux 4.9 support
authorÁlvaro Fernández Rojas <noltari@gmail.com>
Tue, 7 Feb 2017 20:07:54 +0000 (21:07 +0100)
committerÁlvaro Fernández Rojas <noltari@gmail.com>
Tue, 7 Feb 2017 22:00:16 +0000 (23:00 +0100)
Patches from Raspberry Pi repo:
https://github.com/raspberrypi/linux/commits/rpi-4.9.y

Signed-off-by: Álvaro Fernández Rojas <noltari@gmail.com>
148 files changed:
target/linux/brcm2708/bcm2708/config-4.9 [new file with mode: 0644]
target/linux/brcm2708/bcm2709/config-4.9 [new file with mode: 0644]
target/linux/brcm2708/bcm2710/config-4.9 [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0001-smsx95xx-fix-crimes-against-truesize.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0002-smsc95xx-Experimental-Enable-turbo_mode-and-packetsi.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0003-Allow-mac-address-to-be-set-in-smsc95xx.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0004-Protect-__release_resource-against-resources-without.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0005-mm-Remove-the-PFN-busy-warning.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0006-irq-bcm2836-Prevent-spurious-interrupts-and-trap-the.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0007-irqchip-bcm2835-Add-FIQ-support.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0008-irqchip-irq-bcm2835-Add-2836-FIQ-support.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0009-spidev-Add-spidev-compatible-string-to-silence-warni.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0010-serial-8250-Don-t-crash-when-nr_uarts-is-0.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0011-pinctrl-bcm2835-Set-base-to-0-give-expected-gpio-num.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0012-pinctrl-bcm2835-Fix-interrupt-handling-for-GPIOs-28-.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0013-pinctrl-bcm2835-Only-request-the-interrupts-listed-i.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0014-pinctrl-bcm2835-Return-pins-to-inputs-when-freed.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0015-spi-bcm2835-Support-pin-groups-other-than-7-11.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0016-spi-bcm2835-Disable-forced-software-CS.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0017-spi-bcm2835-Remove-unused-code.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0018-ARM-bcm2835-Set-Serial-number-and-Revision.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0019-dmaengine-bcm2835-Load-driver-early-and-support-lega.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0020-firmware-Updated-mailbox-header.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0021-clk-bcm2835-Mark-GPIO-clocks-enabled-at-boot-as-crit.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0022-rtc-Add-SPI-alias-for-pcf2123-driver.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0023-watchdog-bcm2835-Support-setting-reboot-partition.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0024-reboot-Use-power-off-rather-than-busy-spinning-when-.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0025-bcm-Make-RASPBERRYPI_POWER-depend-on-PM.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0026-Register-the-clocks-early-during-the-boot-process.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0027-bcm2835-rng-Avoid-initialising-if-already-enabled.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0028-kbuild-Ignore-dtco-targets-when-filtering-symbols.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0029-BCM2835_DT-Fix-I2S-register-map.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0030-Main-bcm2708-bcm2709-linux-port.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0031-Add-dwc_otg-driver.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0032-bcm2708-framebuffer-driver.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0033-dmaengine-Add-support-for-BCM2708.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0034-MMC-added-alternative-MMC-driver.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0035-Adding-bcm2835-sdhost-driver-and-an-overlay-to-enabl.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0036-mmc-Add-MMC_QUIRK_ERASE_BROKEN-for-some-cards.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0037-cma-Add-vc_cma-driver-to-enable-use-of-CMA.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0038-bcm2708-alsa-sound-driver.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0039-vc_mem-Add-vc_mem-driver-for-querying-firmware-memor.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0040-vcsm-VideoCore-shared-memory-service-for-BCM2835.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0041-Add-dev-gpiomem-device-for-rootless-user-GPIO-access.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0042-Add-SMI-driver.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0043-MISC-bcm2835-smi-use-clock-manager-and-fix-reload-is.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0044-Add-SMI-NAND-driver.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0045-lirc-added-support-for-RaspberryPi-GPIO.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0046-Add-cpufreq-driver.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0047-Added-hwmon-thermal-driver-for-reporting-core-temper.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0048-Add-Chris-Boot-s-i2c-driver.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0049-char-broadcom-Add-vcio-module.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0050-firmware-bcm2835-Support-ARCH_BCM270x.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0051-bcm2835-add-v4l2-camera-device.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0052-scripts-Add-mkknlimg-and-knlinfo-scripts-from-tools-.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0053-scripts-dtc-Update-to-upstream-version-1.4.1.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0054-BCM2708-Add-core-Device-Tree-support.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0055-BCM270x_DT-Add-pwr_led-and-the-required-input-trigge.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0056-fbdev-add-FBIOCOPYAREA-ioctl.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0057-Speed-up-console-framebuffer-imageblit-function.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0058-enabling-the-realtime-clock-1-wire-chip-DS1307-and-1.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0059-Added-Device-IDs-for-August-DVB-T-205.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0060-config-Enable-CONFIG_MEMCG-but-leave-it-disabled-due.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0061-hid-Reduce-default-mouse-polling-interval-to-60Hz.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0062-rpi-ft5406-Add-touchscreen-driver-for-pi-LCD-display.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0063-Improve-__copy_to_user-and-__copy_from_user-performa.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0064-gpio-poweroff-Allow-it-to-work-on-Raspberry-Pi.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0065-mfd-Add-Raspberry-Pi-Sense-HAT-core-driver.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0066-ASoC-Add-support-for-HifiBerry-DAC.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0067-ASoC-Add-support-for-Rpi-DAC.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0068-ASoC-wm8804-Implement-MCLK-configuration-options-add.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0069-ASoC-BCM-Add-support-for-HiFiBerry-Digi.-Driver-is-b.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0070-Add-IQaudIO-Sound-Card-support-for-Raspberry-Pi.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0071-iqaudio-dac-Compile-fix-untested.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0072-Added-support-for-HiFiBerry-DAC.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0073-Added-driver-for-HiFiBerry-Amp-amplifier-add-on-boar.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0074-Revert-Added-driver-for-HiFiBerry-Amp-amplifier-add-.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0075-Update-ds1307-driver-for-device-tree-support.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0076-Add-driver-for-rpi-proto.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0077-RaspiDAC3-support.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0078-Add-Support-for-JustBoom-Audio-boards.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0079-ARM-adau1977-adc-Add-basic-machine-driver-for-adau19.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0080-New-AudioInjector.net-Pi-soundcard-with-low-jitter-a.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0081-Add-IQAudIO-Digi-WM8804-board-support.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0082-New-driver-for-RRA-DigiDAC1-soundcard-using-WM8741-W.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0083-Add-support-for-Dion-Audio-LOCO-DAC-AMP-HAT.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0084-Allo-Piano-DAC-boards-Initial-2-channel-stereo-suppo.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0085-Support-for-Blokas-Labs-pisound-board.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0086-rpi_display-add-backlight-driver-and-overlay.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0087-bcm2835-virtgpio-Virtual-GPIO-driver.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0088-amba_pl011-Don-t-use-DT-aliases-for-numbering.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0089-net-Add-non-mainline-source-for-rtl8192cu-wlan.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0090-net-Fix-rtl8192cu-build-errors-on-other-platforms.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0091-OF-DT-Overlay-configfs-interface.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0092-brcm-adds-support-for-BCM43341-wifi.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0093-hci_h5-Don-t-send-conf_req-when-ACTIVE.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0094-config-Add-default-configs.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0095-Add-arm64-configuration-and-device-tree-differences.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0096-vchiq_arm-Tweak-the-logging-output.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0097-vchiq_arm-Access-the-dequeue_pending-flag-locked.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0098-vchiq_arm-Service-callbacks-must-not-fail.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0099-vchiq_arm-Add-completion-records-under-the-mutex.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0100-vchiq_arm-Avoid-use-of-mutex-in-add_completion.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0101-staging-vchi-Convert-to-current-get_user_pages-argum.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0102-staging-vchi-Update-for-rename-of-page_cache_release.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0103-drivers-vchi-Remove-dependency-on-CONFIG_BROKEN.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0104-raspberrypi-firmware-Export-the-general-transaction-.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0105-raspberrypi-firmware-Define-the-MBOX-channel-in-the-.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0106-drm-vc4-Add-a-mode-for-using-the-closed-firmware-for.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0107-i2c-bcm2835-Fix-hang-for-writing-messages-larger-tha.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0108-i2c-bcm2835-Protect-against-unexpected-TXW-RXR-inter.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0109-i2c-bcm2835-Use-dev_dbg-logging-on-transfer-errors.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0110-i2c-bcm2835-Can-t-support-I2C_M_IGNORE_NAK.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0111-i2c-bcm2835-Add-support-for-Repeated-Start-Condition.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0112-i2c-bcm2835-Support-i2c-dev-ioctl-I2C_TIMEOUT.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0113-i2c-bcm2835-Add-support-for-dynamic-clock.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0114-i2c-bcm2835-Add-debug-support.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0115-arm64-Add-CONFIG_ARCH_BCM2835.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0116-Add-support-for-Silicon-Labs-Si7013-20-21-humidity-t.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0117-Document-the-si7020-option.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0118-pisound-improvements.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0119-Revert-Revert-Added-driver-for-HiFiBerry-Amp-amplifi.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0120-hifiberry-amp-Adjust-for-ALSA-object-refactoring.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0121-bcm2835-i2s-Changes-for-allowing-asymmetric-sample-f.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0122-Add-driver_name-property.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0123-Add-driver_name-paramater.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0124-BCM270X_DT-Add-pi3-disable-wifi-overlay.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0125-ARM64-Make-it-work-again-on-4.9-1790.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0126-ARM64-Enable-Kernel-Address-Space-Randomization-1792.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0127-ARM64-Fix-build-break-for-RTL8187-RTL8192CU-wifi.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0128-ARM64-Enable-RTL8187-RTL8192CU-wifi-in-build-config.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0129-BCM270X_DT-Add-spi0-cs-overlay.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0130-spi-bcm2835-Disable-forced-software-CS.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0131-config-Add-CONFIG_TCP_CONG_BBR.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0132-Revert-bcm2835-i2s-Changes-for-allowing-asymmetric-s.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0133-BCM270X_DT-Enable-UART0-on-CM3.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0134-config-Add-CONFIG_MD_M25P80-and-CONFIG_MD_SPI_NOR.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0135-ARM64-DWC_OTG-Port-dwc_otg-driver-to-ARM64.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0136-ARM64-Round-Robin-dispatch-IRQs-between-CPUs.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0137-ARM64-Enable-DWC_OTG-Driver-In-ARM64-Build-Config-bc.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0138-ARM64-Use-dwc_otg-driver-by-default-for-USB.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0139-BCM270X_DT-Add-reference-to-audio_pins-to-CM-dtb.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0140-config-Add-additional-network-scheduling-modules.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0141-ASoC-A-simple-card-overlay-for-ADAU7002.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0142-config-Add-SND_SOC_ADAU7002-codec-module.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0143-Add-overlay-for-mcp3008-adc-1818.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/0144-usb-dwc2-Avoid-suspending-if-we-re-in-gadget-mode-18.patch [new file with mode: 0644]
target/linux/brcm2708/patches-4.9/1000-mfd-rpisense-disable.patch [new file with mode: 0644]

diff --git a/target/linux/brcm2708/bcm2708/config-4.9 b/target/linux/brcm2708/bcm2708/config-4.9
new file mode 100644 (file)
index 0000000..5a9b825
--- /dev/null
@@ -0,0 +1,365 @@
+# CONFIG_AIO is not set
+CONFIG_ALIGNMENT_TRAP=y
+# CONFIG_AMBA_PL08X is not set
+CONFIG_ARCH_BCM=y
+CONFIG_ARCH_BCM2835=y
+CONFIG_ARCH_CLOCKSOURCE_DATA=y
+CONFIG_ARCH_HAS_ELF_RANDOMIZE=y
+CONFIG_ARCH_HAS_GCOV_PROFILE_ALL=y
+CONFIG_ARCH_HAS_SG_CHAIN=y
+CONFIG_ARCH_HAVE_CUSTOM_GPIO_H=y
+CONFIG_ARCH_HIBERNATION_POSSIBLE=y
+CONFIG_ARCH_MIGHT_HAVE_PC_PARPORT=y
+CONFIG_ARCH_MULTIPLATFORM=y
+# CONFIG_ARCH_MULTI_CPU_AUTO is not set
+CONFIG_ARCH_MULTI_V6=y
+CONFIG_ARCH_MULTI_V6_V7=y
+CONFIG_ARCH_NR_GPIO=0
+# CONFIG_ARCH_SELECT_MEMORY_MODEL is not set
+# CONFIG_ARCH_SPARSEMEM_DEFAULT is not set
+CONFIG_ARCH_SUPPORTS_ATOMIC_RMW=y
+CONFIG_ARCH_SUPPORTS_UPROBES=y
+CONFIG_ARCH_SUSPEND_POSSIBLE=y
+CONFIG_ARCH_USE_BUILTIN_BSWAP=y
+CONFIG_ARCH_USE_CMPXCHG_LOCKREF=y
+CONFIG_ARCH_WANT_GENERAL_HUGETLB=y
+CONFIG_ARCH_WANT_IPC_PARSE_VERSION=y
+CONFIG_ARM=y
+CONFIG_ARM_AMBA=y
+CONFIG_ARM_CPU_SUSPEND=y
+CONFIG_ARM_ERRATA_411920=y
+CONFIG_ARM_HAS_SG_CHAIN=y
+CONFIG_ARM_L1_CACHE_SHIFT=5
+CONFIG_ARM_PATCH_PHYS_VIRT=y
+# CONFIG_ARM_SCPI_PROTOCOL is not set
+# CONFIG_ARM_SP805_WATCHDOG is not set
+CONFIG_ARM_THUMB=y
+CONFIG_ARM_TIMER_SP804=y
+CONFIG_ARM_UNWIND=y
+CONFIG_AUTO_ZRELADDR=y
+# CONFIG_BACKLIGHT_CLASS_DEVICE is not set
+CONFIG_BACKLIGHT_LCD_SUPPORT=y
+CONFIG_BCM2708_VCHIQ=y
+CONFIG_BCM2708_VCMEM=y
+# CONFIG_BCM2835_DEVGPIOMEM is not set
+CONFIG_BCM2835_FAST_MEMCPY=y
+CONFIG_BCM2835_MBOX=y
+# CONFIG_BCM2835_SMI is not set
+CONFIG_BCM2835_TIMER=y
+CONFIG_BCM2835_WDT=y
+CONFIG_BCM_VCIO=y
+CONFIG_BCM_VC_CMA=y
+CONFIG_BCM_VC_SM=y
+# CONFIG_BINFMT_FLAT is not set
+# CONFIG_BLK_DEV_INITRD is not set
+CONFIG_BLK_DEV_LOOP=y
+CONFIG_BLK_DEV_RAM=y
+CONFIG_BLK_DEV_RAM_COUNT=16
+CONFIG_BLK_DEV_RAM_SIZE=4096
+CONFIG_BLK_DEV_SD=y
+CONFIG_BRCM_CHAR_DRIVERS=y
+CONFIG_BUILD_BIN2C=y
+# CONFIG_CACHE_L2X0 is not set
+CONFIG_CLKDEV_LOOKUP=y
+CONFIG_CLKSRC_MMIO=y
+CONFIG_CLKSRC_OF=y
+CONFIG_CLKSRC_PROBE=y
+CONFIG_CLONE_BACKWARDS=y
+CONFIG_CMA=y
+CONFIG_CMA_ALIGNMENT=8
+CONFIG_CMA_AREAS=7
+# CONFIG_CMA_DEBUG is not set
+# CONFIG_CMA_DEBUGFS is not set
+CONFIG_CMA_SIZE_MBYTES=16
+# CONFIG_CMA_SIZE_SEL_MAX is not set
+CONFIG_CMA_SIZE_SEL_MBYTES=y
+# CONFIG_CMA_SIZE_SEL_MIN is not set
+# CONFIG_CMA_SIZE_SEL_PERCENTAGE is not set
+CONFIG_COMMON_CLK=y
+CONFIG_CONFIGFS_FS=y
+CONFIG_CONSOLE_TRANSLATIONS=y
+CONFIG_CPU_32v6=y
+CONFIG_CPU_32v6K=y
+CONFIG_CPU_ABRT_EV6=y
+# CONFIG_CPU_BPREDICT_DISABLE is not set
+CONFIG_CPU_CACHE_V6=y
+CONFIG_CPU_CACHE_VIPT=y
+CONFIG_CPU_COPY_V6=y
+CONFIG_CPU_CP15=y
+CONFIG_CPU_CP15_MMU=y
+CONFIG_CPU_HAS_ASID=y
+# CONFIG_CPU_ICACHE_DISABLE is not set
+CONFIG_CPU_IDLE=y
+CONFIG_CPU_IDLE_GOV_LADDER=y
+CONFIG_CPU_IDLE_GOV_MENU=y
+CONFIG_CPU_PABRT_V6=y
+CONFIG_CPU_PM=y
+CONFIG_CPU_TLB_V6=y
+CONFIG_CPU_V6K=y
+CONFIG_CRC16=y
+CONFIG_CRYPTO_CRC32C=y
+CONFIG_CRYPTO_HASH=y
+CONFIG_CRYPTO_HASH2=y
+CONFIG_CRYPTO_RNG2=y
+CONFIG_CRYPTO_WORKQUEUE=y
+CONFIG_DCACHE_WORD_ACCESS=y
+CONFIG_DEBUG_BUGVERBOSE=y
+CONFIG_DEBUG_INFO=y
+CONFIG_DEBUG_LL_INCLUDE="mach/debug-macro.S"
+# CONFIG_DEBUG_UART_8250 is not set
+# CONFIG_DEBUG_USER is not set
+CONFIG_DEFAULT_CFQ=y
+# CONFIG_DEFAULT_DEADLINE is not set
+CONFIG_DEFAULT_IOSCHED="cfq"
+CONFIG_DMADEVICES=y
+CONFIG_DMA_BCM2708=y
+CONFIG_DMA_BCM2835=y
+CONFIG_DMA_CMA=y
+CONFIG_DMA_ENGINE=y
+CONFIG_DMA_OF=y
+CONFIG_DMA_VIRTUAL_CHANNELS=y
+CONFIG_DNOTIFY=y
+CONFIG_DTC=y
+CONFIG_DUMMY_CONSOLE=y
+CONFIG_EDAC_ATOMIC_SCRUB=y
+CONFIG_EDAC_SUPPORT=y
+CONFIG_ENABLE_MUST_CHECK=y
+CONFIG_EXT4_FS=y
+CONFIG_EXT4_FS_POSIX_ACL=y
+CONFIG_EXT4_FS_SECURITY=y
+CONFIG_FB=y
+CONFIG_FB_BCM2708=y
+CONFIG_FB_CFB_COPYAREA=y
+CONFIG_FB_CFB_FILLRECT=y
+CONFIG_FB_CFB_IMAGEBLIT=y
+CONFIG_FB_CMDLINE=y
+# CONFIG_FB_RPISENSE is not set
+CONFIG_FIQ=y
+CONFIG_FIRMWARE_IN_KERNEL=y
+CONFIG_FIX_EARLYCON_MEM=y
+# CONFIG_FONTS is not set
+CONFIG_FONT_8x16=y
+CONFIG_FONT_8x8=y
+CONFIG_FONT_SUPPORT=y
+# CONFIG_FPE_FASTFPE is not set
+# CONFIG_FPE_NWFPE is not set
+CONFIG_FRAMEBUFFER_CONSOLE=y
+# CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY is not set
+# CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
+CONFIG_FREEZER=y
+CONFIG_FS_MBCACHE=y
+CONFIG_FS_POSIX_ACL=y
+CONFIG_GENERIC_ALLOCATOR=y
+CONFIG_GENERIC_BUG=y
+CONFIG_GENERIC_CLOCKEVENTS=y
+CONFIG_GENERIC_EARLY_IOREMAP=y
+CONFIG_GENERIC_IDLE_POLL_SETUP=y
+CONFIG_GENERIC_IO=y
+CONFIG_GENERIC_IRQ_SHOW=y
+CONFIG_GENERIC_IRQ_SHOW_LEVEL=y
+CONFIG_GENERIC_PCI_IOMAP=y
+CONFIG_GENERIC_PINCONF=y
+CONFIG_GENERIC_SCHED_CLOCK=y
+CONFIG_GENERIC_SMP_IDLE_THREAD=y
+CONFIG_GENERIC_STRNCPY_FROM_USER=y
+CONFIG_GENERIC_STRNLEN_USER=y
+CONFIG_GPIOLIB=y
+# CONFIG_GPIO_BCM_VIRT is not set
+CONFIG_GPIO_SYSFS=y
+CONFIG_HANDLE_DOMAIN_IRQ=y
+CONFIG_HARDIRQS_SW_RESEND=y
+CONFIG_HAS_DMA=y
+CONFIG_HAS_IOMEM=y
+CONFIG_HAS_IOPORT_MAP=y
+# CONFIG_HAVE_64BIT_ALIGNED_ACCESS is not set
+# CONFIG_HAVE_ARCH_BITREVERSE is not set
+CONFIG_HAVE_ARCH_JUMP_LABEL=y
+CONFIG_HAVE_ARCH_KGDB=y
+CONFIG_HAVE_ARCH_PFN_VALID=y
+CONFIG_HAVE_ARCH_TRACEHOOK=y
+# CONFIG_HAVE_BOOTMEM_INFO_NODE is not set
+CONFIG_HAVE_CBPF_JIT=y
+CONFIG_HAVE_CC_STACKPROTECTOR=y
+CONFIG_HAVE_CLK=y
+CONFIG_HAVE_CLK_PREPARE=y
+CONFIG_HAVE_CONTEXT_TRACKING=y
+CONFIG_HAVE_C_RECORDMCOUNT=y
+CONFIG_HAVE_DEBUG_KMEMLEAK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+CONFIG_HAVE_DMA_CONTIGUOUS=y
+CONFIG_HAVE_DYNAMIC_FTRACE=y
+CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS=y
+CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y
+CONFIG_HAVE_FUNCTION_TRACER=y
+CONFIG_HAVE_GENERIC_DMA_COHERENT=y
+CONFIG_HAVE_IRQ_TIME_ACCOUNTING=y
+CONFIG_HAVE_MEMBLOCK=y
+CONFIG_HAVE_MOD_ARCH_SPECIFIC=y
+CONFIG_HAVE_NET_DSA=y
+CONFIG_HAVE_OPROFILE=y
+CONFIG_HAVE_OPTPROBES=y
+CONFIG_HAVE_PERF_EVENTS=y
+CONFIG_HAVE_PERF_REGS=y
+CONFIG_HAVE_PERF_USER_STACK_DUMP=y
+CONFIG_HAVE_PROC_CPU=y
+CONFIG_HAVE_REGS_AND_STACK_ACCESS_API=y
+CONFIG_HAVE_SYSCALL_TRACEPOINTS=y
+CONFIG_HAVE_UID16=y
+CONFIG_HAVE_VIRT_CPU_ACCOUNTING_GEN=y
+CONFIG_HW_CONSOLE=y
+CONFIG_HZ_FIXED=0
+CONFIG_IKCONFIG=y
+CONFIG_IKCONFIG_PROC=y
+CONFIG_INPUT=y
+CONFIG_INPUT_MOUSEDEV=y
+# CONFIG_INPUT_MOUSEDEV_PSAUX is not set
+CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
+CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
+CONFIG_IOMMU_HELPER=y
+CONFIG_IOSCHED_CFQ=y
+CONFIG_IRQCHIP=y
+CONFIG_IRQ_DOMAIN=y
+CONFIG_IRQ_FORCED_THREADING=y
+CONFIG_IRQ_WORK=y
+CONFIG_JBD2=y
+CONFIG_KERNEL_GZIP=y
+# CONFIG_KERNEL_XZ is not set
+# CONFIG_LCD_CLASS_DEVICE is not set
+CONFIG_LEDS_GPIO=y
+CONFIG_LEDS_TRIGGER_INPUT=y
+CONFIG_LIBFDT=y
+CONFIG_LOGO=y
+CONFIG_LOGO_LINUX_CLUT224=y
+# CONFIG_LOGO_LINUX_MONO is not set
+# CONFIG_LOGO_LINUX_VGA16 is not set
+CONFIG_MAC_PARTITION=y
+CONFIG_MAGIC_SYSRQ=y
+CONFIG_MAILBOX=y
+# CONFIG_MAILBOX_TEST is not set
+CONFIG_MAX_RAW_DEVS=256
+CONFIG_MEMORY_ISOLATION=y
+CONFIG_MIGHT_HAVE_CACHE_L2X0=y
+CONFIG_MIGHT_HAVE_PCI=y
+CONFIG_MIGRATION=y
+CONFIG_MMC=y
+CONFIG_MMC_BCM2835=y
+CONFIG_MMC_BCM2835_DMA=y
+CONFIG_MMC_BCM2835_PIO_DMA_BARRIER=2
+CONFIG_MMC_BCM2835_SDHOST=y
+CONFIG_MMC_BLOCK=y
+CONFIG_MMC_BLOCK_MINORS=32
+CONFIG_MMC_SDHCI=y
+CONFIG_MMC_SDHCI_PLTFM=y
+CONFIG_MODULES_USE_ELF_REL=y
+# CONFIG_MTD is not set
+CONFIG_MULTI_IRQ_HANDLER=y
+CONFIG_NEED_DMA_MAP_STATE=y
+CONFIG_NEED_PER_CPU_KM=y
+CONFIG_NLS=y
+CONFIG_NLS_ASCII=y
+CONFIG_NLS_DEFAULT="utf8"
+CONFIG_NO_BOOTMEM=y
+CONFIG_NO_HZ=y
+CONFIG_NO_HZ_COMMON=y
+CONFIG_NO_HZ_IDLE=y
+CONFIG_OABI_COMPAT=y
+CONFIG_OF=y
+CONFIG_OF_ADDRESS=y
+CONFIG_OF_CONFIGFS=y
+CONFIG_OF_DYNAMIC=y
+CONFIG_OF_EARLY_FLATTREE=y
+CONFIG_OF_FLATTREE=y
+CONFIG_OF_GPIO=y
+CONFIG_OF_IRQ=y
+CONFIG_OF_NET=y
+CONFIG_OF_OVERLAY=y
+CONFIG_OF_RESERVED_MEM=y
+CONFIG_OF_RESOLVE=y
+CONFIG_OLD_SIGACTION=y
+CONFIG_OLD_SIGSUSPEND3=y
+CONFIG_PAGE_OFFSET=0xC0000000
+# CONFIG_PCI_DOMAINS_GENERIC is not set
+# CONFIG_PCI_SYSCALL is not set
+CONFIG_PERF_USE_VMALLOC=y
+CONFIG_PGTABLE_LEVELS=2
+CONFIG_PINCTRL=y
+CONFIG_PINCTRL_BCM2835=y
+# CONFIG_PL330_DMA is not set
+CONFIG_PM=y
+CONFIG_PM_CLK=y
+# CONFIG_PM_DEBUG is not set
+CONFIG_PM_GENERIC_DOMAINS=y
+CONFIG_PM_GENERIC_DOMAINS_OF=y
+CONFIG_PM_GENERIC_DOMAINS_SLEEP=y
+CONFIG_PM_SLEEP=y
+CONFIG_POWER_SUPPLY=y
+CONFIG_PRINTK_TIME=y
+CONFIG_PROC_PAGE_MONITOR=y
+CONFIG_PWM=y
+CONFIG_PWM_BCM2835=y
+CONFIG_PWM_SYSFS=y
+CONFIG_RASPBERRYPI_FIRMWARE=y
+CONFIG_RASPBERRYPI_POWER=y
+CONFIG_RATIONAL=y
+CONFIG_RAW_DRIVER=y
+# CONFIG_RCU_STALL_COMMON is not set
+CONFIG_RWSEM_XCHGADD_ALGORITHM=y
+CONFIG_SCHED_HRTICK=y
+# CONFIG_SCHED_INFO is not set
+CONFIG_SCSI=y
+# CONFIG_SCSI_LOWLEVEL is not set
+# CONFIG_SCSI_PROC_FS is not set
+CONFIG_SERIAL_8250_BCM2835AUX=y
+# CONFIG_SERIAL_8250_DMA is not set
+CONFIG_SERIAL_8250_EXTENDED=y
+CONFIG_SERIAL_8250_FSL=y
+CONFIG_SERIAL_8250_NR_UARTS=1
+CONFIG_SERIAL_8250_RUNTIME_UARTS=0
+CONFIG_SERIAL_8250_SHARE_IRQ=y
+# CONFIG_SERIAL_AMBA_PL010 is not set
+CONFIG_SERIAL_AMBA_PL011=y
+CONFIG_SERIAL_AMBA_PL011_CONSOLE=y
+CONFIG_SERIAL_OF_PLATFORM=y
+CONFIG_SPARSE_IRQ=y
+# CONFIG_SQUASHFS is not set
+CONFIG_SRCU=y
+# CONFIG_STRIP_ASM_SYMS is not set
+CONFIG_SUSPEND=y
+CONFIG_SUSPEND_FREEZER=y
+CONFIG_SWIOTLB=y
+CONFIG_SYS_SUPPORTS_APM_EMULATION=y
+# CONFIG_TEXTSEARCH is not set
+CONFIG_THERMAL=y
+CONFIG_THERMAL_BCM2835=y
+CONFIG_THERMAL_DEFAULT_GOV_STEP_WISE=y
+CONFIG_THERMAL_GOV_STEP_WISE=y
+CONFIG_THERMAL_OF=y
+CONFIG_TICK_CPU_ACCOUNTING=y
+CONFIG_TMPFS_POSIX_ACL=y
+CONFIG_UEVENT_HELPER_PATH=""
+# CONFIG_UID16 is not set
+CONFIG_UNCOMPRESS_INCLUDE="debug/uncompress.h"
+CONFIG_USB=y
+CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
+CONFIG_USB_COMMON=y
+CONFIG_USB_DWCOTG=y
+# CONFIG_USB_EHCI_HCD is not set
+CONFIG_USB_NET_DRIVERS=y
+CONFIG_USB_NET_SMSC95XX=y
+CONFIG_USB_STORAGE=y
+CONFIG_USB_SUPPORT=y
+CONFIG_USB_UAS=y
+CONFIG_USB_USBNET=y
+CONFIG_USE_OF=y
+CONFIG_VECTORS_BASE=0xffff0000
+CONFIG_VFP=y
+CONFIG_VT=y
+CONFIG_VT_CONSOLE=y
+CONFIG_VT_CONSOLE_SLEEP=y
+CONFIG_VT_HW_CONSOLE_BINDING=y
+CONFIG_WATCHDOG_CORE=y
+CONFIG_XZ_DEC_ARM=y
+CONFIG_XZ_DEC_BCJ=y
+CONFIG_ZBOOT_ROM_BSS=0x0
+CONFIG_ZBOOT_ROM_TEXT=0x0
diff --git a/target/linux/brcm2708/bcm2709/config-4.9 b/target/linux/brcm2708/bcm2709/config-4.9
new file mode 100644 (file)
index 0000000..6c6fefc
--- /dev/null
@@ -0,0 +1,407 @@
+# CONFIG_AIO is not set
+CONFIG_ALIGNMENT_TRAP=y
+# CONFIG_AMBA_PL08X is not set
+CONFIG_ARCH_BCM=y
+CONFIG_ARCH_BCM2835=y
+CONFIG_ARCH_CLOCKSOURCE_DATA=y
+CONFIG_ARCH_HAS_ELF_RANDOMIZE=y
+CONFIG_ARCH_HAS_GCOV_PROFILE_ALL=y
+CONFIG_ARCH_HAS_SG_CHAIN=y
+CONFIG_ARCH_HAS_TICK_BROADCAST=y
+CONFIG_ARCH_HAVE_CUSTOM_GPIO_H=y
+CONFIG_ARCH_HIBERNATION_POSSIBLE=y
+CONFIG_ARCH_MIGHT_HAVE_PC_PARPORT=y
+CONFIG_ARCH_MMAP_RND_BITS_MAX=15
+CONFIG_ARCH_MULTIPLATFORM=y
+# CONFIG_ARCH_MULTI_CPU_AUTO is not set
+CONFIG_ARCH_MULTI_V6_V7=y
+CONFIG_ARCH_MULTI_V7=y
+CONFIG_ARCH_NR_GPIO=0
+# CONFIG_ARCH_SELECT_MEMORY_MODEL is not set
+# CONFIG_ARCH_SPARSEMEM_DEFAULT is not set
+CONFIG_ARCH_SUPPORTS_ATOMIC_RMW=y
+CONFIG_ARCH_SUPPORTS_UPROBES=y
+CONFIG_ARCH_SUSPEND_POSSIBLE=y
+CONFIG_ARCH_USE_BUILTIN_BSWAP=y
+CONFIG_ARCH_USE_CMPXCHG_LOCKREF=y
+CONFIG_ARCH_WANT_GENERAL_HUGETLB=y
+CONFIG_ARCH_WANT_IPC_PARSE_VERSION=y
+CONFIG_ARM=y
+CONFIG_ARM_AMBA=y
+CONFIG_ARM_ARCH_TIMER=y
+CONFIG_ARM_ARCH_TIMER_EVTSTREAM=y
+CONFIG_ARM_CPU_SUSPEND=y
+CONFIG_ARM_HAS_SG_CHAIN=y
+CONFIG_ARM_L1_CACHE_SHIFT=6
+CONFIG_ARM_L1_CACHE_SHIFT_6=y
+# CONFIG_ARM_LPAE is not set
+CONFIG_ARM_PATCH_IDIV=y
+CONFIG_ARM_PATCH_PHYS_VIRT=y
+# CONFIG_ARM_SCPI_PROTOCOL is not set
+# CONFIG_ARM_SP805_WATCHDOG is not set
+CONFIG_ARM_THUMB=y
+# CONFIG_ARM_THUMBEE is not set
+CONFIG_ARM_TIMER_SP804=y
+CONFIG_ARM_UNWIND=y
+CONFIG_ARM_VIRT_EXT=y
+CONFIG_AUTO_ZRELADDR=y
+# CONFIG_BACKLIGHT_CLASS_DEVICE is not set
+CONFIG_BACKLIGHT_LCD_SUPPORT=y
+CONFIG_BCM2708_VCHIQ=y
+CONFIG_BCM2708_VCMEM=y
+# CONFIG_BCM2835_DEVGPIOMEM is not set
+CONFIG_BCM2835_MBOX=y
+# CONFIG_BCM2835_SMI is not set
+CONFIG_BCM2835_TIMER=y
+CONFIG_BCM2835_WDT=y
+CONFIG_BCM_VCIO=y
+CONFIG_BCM_VC_CMA=y
+CONFIG_BCM_VC_SM=y
+# CONFIG_BINFMT_FLAT is not set
+# CONFIG_BLK_DEV_INITRD is not set
+CONFIG_BLK_DEV_LOOP=y
+CONFIG_BLK_DEV_RAM=y
+CONFIG_BLK_DEV_RAM_COUNT=16
+CONFIG_BLK_DEV_RAM_SIZE=4096
+CONFIG_BLK_DEV_SD=y
+CONFIG_BRCM_CHAR_DRIVERS=y
+CONFIG_BUILD_BIN2C=y
+# CONFIG_CACHE_L2X0 is not set
+CONFIG_CLKDEV_LOOKUP=y
+CONFIG_CLKSRC_MMIO=y
+CONFIG_CLKSRC_OF=y
+CONFIG_CLKSRC_PROBE=y
+CONFIG_CLONE_BACKWARDS=y
+CONFIG_CMA=y
+CONFIG_CMA_ALIGNMENT=8
+CONFIG_CMA_AREAS=7
+# CONFIG_CMA_DEBUG is not set
+# CONFIG_CMA_DEBUGFS is not set
+CONFIG_CMA_SIZE_MBYTES=16
+# CONFIG_CMA_SIZE_SEL_MAX is not set
+CONFIG_CMA_SIZE_SEL_MBYTES=y
+# CONFIG_CMA_SIZE_SEL_MIN is not set
+# CONFIG_CMA_SIZE_SEL_PERCENTAGE is not set
+CONFIG_COMMON_CLK=y
+CONFIG_CONFIGFS_FS=y
+CONFIG_CONSOLE_TRANSLATIONS=y
+CONFIG_CPU_32v6K=y
+CONFIG_CPU_32v7=y
+CONFIG_CPU_ABRT_EV7=y
+# CONFIG_CPU_BPREDICT_DISABLE is not set
+CONFIG_CPU_CACHE_V7=y
+CONFIG_CPU_CACHE_VIPT=y
+CONFIG_CPU_COPY_V6=y
+CONFIG_CPU_CP15=y
+CONFIG_CPU_CP15_MMU=y
+CONFIG_CPU_HAS_ASID=y
+# CONFIG_CPU_HOTPLUG_STATE_CONTROL is not set
+# CONFIG_CPU_ICACHE_DISABLE is not set
+CONFIG_CPU_IDLE=y
+CONFIG_CPU_IDLE_GOV_LADDER=y
+CONFIG_CPU_IDLE_GOV_MENU=y
+CONFIG_CPU_PABRT_V7=y
+CONFIG_CPU_PM=y
+CONFIG_CPU_RMAP=y
+CONFIG_CPU_TLB_V7=y
+CONFIG_CPU_V7=y
+CONFIG_CRC16=y
+CONFIG_CRYPTO_AEAD=y
+CONFIG_CRYPTO_AEAD2=y
+CONFIG_CRYPTO_CRC32C=y
+CONFIG_CRYPTO_HASH=y
+CONFIG_CRYPTO_HASH2=y
+CONFIG_CRYPTO_MANAGER=y
+CONFIG_CRYPTO_MANAGER2=y
+CONFIG_CRYPTO_NULL2=y
+CONFIG_CRYPTO_RNG2=y
+CONFIG_CRYPTO_WORKQUEUE=y
+CONFIG_DCACHE_WORD_ACCESS=y
+CONFIG_DEBUG_BUGVERBOSE=y
+CONFIG_DEBUG_INFO=y
+CONFIG_DEBUG_LL_INCLUDE="mach/debug-macro.S"
+# CONFIG_DEBUG_UART_8250 is not set
+# CONFIG_DEBUG_USER is not set
+CONFIG_DEFAULT_CFQ=y
+# CONFIG_DEFAULT_DEADLINE is not set
+CONFIG_DEFAULT_IOSCHED="cfq"
+CONFIG_DMADEVICES=y
+CONFIG_DMA_BCM2708=y
+CONFIG_DMA_BCM2835=y
+CONFIG_DMA_CMA=y
+CONFIG_DMA_ENGINE=y
+CONFIG_DMA_OF=y
+CONFIG_DMA_VIRTUAL_CHANNELS=y
+CONFIG_DNOTIFY=y
+CONFIG_DTC=y
+CONFIG_DUMMY_CONSOLE=y
+CONFIG_EDAC_ATOMIC_SCRUB=y
+CONFIG_EDAC_SUPPORT=y
+CONFIG_ENABLE_MUST_CHECK=y
+CONFIG_EXT4_FS=y
+CONFIG_EXT4_FS_POSIX_ACL=y
+CONFIG_EXT4_FS_SECURITY=y
+CONFIG_FB=y
+CONFIG_FB_BCM2708=y
+CONFIG_FB_CFB_COPYAREA=y
+CONFIG_FB_CFB_FILLRECT=y
+CONFIG_FB_CFB_IMAGEBLIT=y
+CONFIG_FB_CMDLINE=y
+# CONFIG_FB_RPISENSE is not set
+CONFIG_FIQ=y
+CONFIG_FIRMWARE_IN_KERNEL=y
+CONFIG_FIX_EARLYCON_MEM=y
+# CONFIG_FONTS is not set
+CONFIG_FONT_8x16=y
+CONFIG_FONT_8x8=y
+CONFIG_FONT_SUPPORT=y
+# CONFIG_FPE_FASTFPE is not set
+# CONFIG_FPE_NWFPE is not set
+CONFIG_FRAMEBUFFER_CONSOLE=y
+# CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY is not set
+# CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
+CONFIG_FREEZER=y
+CONFIG_FS_MBCACHE=y
+CONFIG_FS_POSIX_ACL=y
+CONFIG_GENERIC_ALLOCATOR=y
+CONFIG_GENERIC_BUG=y
+CONFIG_GENERIC_CLOCKEVENTS=y
+CONFIG_GENERIC_CLOCKEVENTS_BROADCAST=y
+CONFIG_GENERIC_EARLY_IOREMAP=y
+CONFIG_GENERIC_IDLE_POLL_SETUP=y
+CONFIG_GENERIC_IO=y
+CONFIG_GENERIC_IRQ_SHOW=y
+CONFIG_GENERIC_IRQ_SHOW_LEVEL=y
+CONFIG_GENERIC_PCI_IOMAP=y
+CONFIG_GENERIC_PINCONF=y
+CONFIG_GENERIC_SCHED_CLOCK=y
+CONFIG_GENERIC_SMP_IDLE_THREAD=y
+CONFIG_GENERIC_STRNCPY_FROM_USER=y
+CONFIG_GENERIC_STRNLEN_USER=y
+CONFIG_GPIOLIB=y
+# CONFIG_GPIO_BCM_VIRT is not set
+CONFIG_GPIO_SYSFS=y
+CONFIG_HANDLE_DOMAIN_IRQ=y
+CONFIG_HARDIRQS_SW_RESEND=y
+CONFIG_HAS_DMA=y
+CONFIG_HAS_IOMEM=y
+CONFIG_HAS_IOPORT_MAP=y
+# CONFIG_HAVE_64BIT_ALIGNED_ACCESS is not set
+CONFIG_HAVE_ARCH_BITREVERSE=y
+CONFIG_HAVE_ARCH_JUMP_LABEL=y
+CONFIG_HAVE_ARCH_KGDB=y
+CONFIG_HAVE_ARCH_PFN_VALID=y
+CONFIG_HAVE_ARCH_TRACEHOOK=y
+CONFIG_HAVE_ARM_ARCH_TIMER=y
+CONFIG_HAVE_ARM_SMCCC=y
+# CONFIG_HAVE_BOOTMEM_INFO_NODE is not set
+CONFIG_HAVE_CBPF_JIT=y
+CONFIG_HAVE_CC_STACKPROTECTOR=y
+CONFIG_HAVE_CLK=y
+CONFIG_HAVE_CLK_PREPARE=y
+CONFIG_HAVE_CONTEXT_TRACKING=y
+CONFIG_HAVE_C_RECORDMCOUNT=y
+CONFIG_HAVE_DEBUG_KMEMLEAK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+CONFIG_HAVE_DMA_CONTIGUOUS=y
+CONFIG_HAVE_DYNAMIC_FTRACE=y
+CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS=y
+CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y
+CONFIG_HAVE_FUNCTION_TRACER=y
+CONFIG_HAVE_GENERIC_DMA_COHERENT=y
+CONFIG_HAVE_IRQ_TIME_ACCOUNTING=y
+CONFIG_HAVE_MEMBLOCK=y
+CONFIG_HAVE_MOD_ARCH_SPECIFIC=y
+CONFIG_HAVE_NET_DSA=y
+CONFIG_HAVE_OPROFILE=y
+CONFIG_HAVE_OPTPROBES=y
+CONFIG_HAVE_PERF_EVENTS=y
+CONFIG_HAVE_PERF_REGS=y
+CONFIG_HAVE_PERF_USER_STACK_DUMP=y
+CONFIG_HAVE_PROC_CPU=y
+CONFIG_HAVE_REGS_AND_STACK_ACCESS_API=y
+CONFIG_HAVE_SMP=y
+CONFIG_HAVE_SYSCALL_TRACEPOINTS=y
+CONFIG_HAVE_UID16=y
+CONFIG_HAVE_VIRT_CPU_ACCOUNTING_GEN=y
+CONFIG_HOTPLUG_CPU=y
+CONFIG_HW_CONSOLE=y
+CONFIG_HZ_FIXED=0
+CONFIG_IKCONFIG=y
+CONFIG_IKCONFIG_PROC=y
+CONFIG_INPUT=y
+CONFIG_INPUT_MOUSEDEV=y
+# CONFIG_INPUT_MOUSEDEV_PSAUX is not set
+CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
+CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
+CONFIG_IOMMU_HELPER=y
+CONFIG_IOSCHED_CFQ=y
+CONFIG_IRQCHIP=y
+CONFIG_IRQ_DOMAIN=y
+CONFIG_IRQ_FORCED_THREADING=y
+CONFIG_IRQ_WORK=y
+CONFIG_JBD2=y
+CONFIG_KERNEL_GZIP=y
+# CONFIG_KERNEL_XZ is not set
+# CONFIG_LCD_CLASS_DEVICE is not set
+CONFIG_LEDS_GPIO=y
+CONFIG_LEDS_TRIGGER_INPUT=y
+CONFIG_LIBFDT=y
+CONFIG_LOCK_SPIN_ON_OWNER=y
+CONFIG_LOGO=y
+CONFIG_LOGO_LINUX_CLUT224=y
+# CONFIG_LOGO_LINUX_MONO is not set
+# CONFIG_LOGO_LINUX_VGA16 is not set
+CONFIG_LZO_COMPRESS=y
+CONFIG_LZO_DECOMPRESS=y
+CONFIG_MAC_PARTITION=y
+CONFIG_MAGIC_SYSRQ=y
+CONFIG_MAILBOX=y
+# CONFIG_MAILBOX_TEST is not set
+CONFIG_MAX_RAW_DEVS=256
+CONFIG_MEMORY_ISOLATION=y
+CONFIG_MFD_SYSCON=y
+CONFIG_MIGHT_HAVE_CACHE_L2X0=y
+CONFIG_MIGHT_HAVE_PCI=y
+CONFIG_MIGRATION=y
+CONFIG_MMC=y
+CONFIG_MMC_BCM2835=y
+CONFIG_MMC_BCM2835_DMA=y
+CONFIG_MMC_BCM2835_PIO_DMA_BARRIER=2
+CONFIG_MMC_BCM2835_SDHOST=y
+CONFIG_MMC_BLOCK=y
+CONFIG_MMC_BLOCK_MINORS=32
+CONFIG_MMC_SDHCI=y
+CONFIG_MMC_SDHCI_PLTFM=y
+CONFIG_MODULES_USE_ELF_REL=y
+# CONFIG_MTD is not set
+CONFIG_MULTI_IRQ_HANDLER=y
+CONFIG_MUTEX_SPIN_ON_OWNER=y
+CONFIG_NEED_DMA_MAP_STATE=y
+CONFIG_NEON=y
+CONFIG_NET_FLOW_LIMIT=y
+CONFIG_NLS=y
+CONFIG_NLS_ASCII=y
+CONFIG_NLS_DEFAULT="utf8"
+CONFIG_NO_BOOTMEM=y
+CONFIG_NO_HZ=y
+CONFIG_NO_HZ_COMMON=y
+CONFIG_NO_HZ_IDLE=y
+CONFIG_NR_CPUS=4
+CONFIG_OABI_COMPAT=y
+CONFIG_OF=y
+CONFIG_OF_ADDRESS=y
+CONFIG_OF_CONFIGFS=y
+CONFIG_OF_DYNAMIC=y
+CONFIG_OF_EARLY_FLATTREE=y
+CONFIG_OF_FLATTREE=y
+CONFIG_OF_GPIO=y
+CONFIG_OF_IRQ=y
+CONFIG_OF_NET=y
+CONFIG_OF_OVERLAY=y
+CONFIG_OF_RESERVED_MEM=y
+CONFIG_OF_RESOLVE=y
+CONFIG_OLD_SIGACTION=y
+CONFIG_OLD_SIGSUSPEND3=y
+CONFIG_PADATA=y
+CONFIG_PAGE_OFFSET=0x80000000
+# CONFIG_PCI_DOMAINS_GENERIC is not set
+# CONFIG_PCI_SYSCALL is not set
+CONFIG_PERF_USE_VMALLOC=y
+CONFIG_PGTABLE_LEVELS=2
+CONFIG_PINCTRL=y
+CONFIG_PINCTRL_BCM2835=y
+# CONFIG_PL330_DMA is not set
+CONFIG_PM=y
+CONFIG_PM_CLK=y
+# CONFIG_PM_DEBUG is not set
+CONFIG_PM_GENERIC_DOMAINS=y
+CONFIG_PM_GENERIC_DOMAINS_OF=y
+CONFIG_PM_GENERIC_DOMAINS_SLEEP=y
+CONFIG_PM_SLEEP=y
+CONFIG_PM_SLEEP_SMP=y
+CONFIG_POWER_SUPPLY=y
+CONFIG_PRINTK_TIME=y
+CONFIG_PROC_PAGE_MONITOR=y
+CONFIG_PWM=y
+CONFIG_PWM_BCM2835=y
+CONFIG_PWM_SYSFS=y
+CONFIG_RASPBERRYPI_FIRMWARE=y
+CONFIG_RASPBERRYPI_POWER=y
+CONFIG_RATIONAL=y
+CONFIG_RAW_DRIVER=y
+CONFIG_RCU_STALL_COMMON=y
+CONFIG_REGMAP=y
+CONFIG_REGMAP_MMIO=y
+CONFIG_RFS_ACCEL=y
+CONFIG_RPS=y
+CONFIG_RWSEM_SPIN_ON_OWNER=y
+CONFIG_RWSEM_XCHGADD_ALGORITHM=y
+CONFIG_SCHED_HRTICK=y
+# CONFIG_SCHED_INFO is not set
+CONFIG_SCSI=y
+# CONFIG_SCSI_LOWLEVEL is not set
+# CONFIG_SCSI_PROC_FS is not set
+CONFIG_SERIAL_8250_BCM2835AUX=y
+# CONFIG_SERIAL_8250_DMA is not set
+CONFIG_SERIAL_8250_EXTENDED=y
+CONFIG_SERIAL_8250_FSL=y
+CONFIG_SERIAL_8250_NR_UARTS=1
+CONFIG_SERIAL_8250_RUNTIME_UARTS=0
+CONFIG_SERIAL_8250_SHARE_IRQ=y
+# CONFIG_SERIAL_AMBA_PL010 is not set
+CONFIG_SERIAL_AMBA_PL011=y
+CONFIG_SERIAL_AMBA_PL011_CONSOLE=y
+CONFIG_SERIAL_OF_PLATFORM=y
+CONFIG_SMP=y
+CONFIG_SMP_ON_UP=y
+CONFIG_SPARSE_IRQ=y
+# CONFIG_SQUASHFS is not set
+CONFIG_SRCU=y
+# CONFIG_STRIP_ASM_SYMS is not set
+CONFIG_SUSPEND=y
+CONFIG_SUSPEND_FREEZER=y
+CONFIG_SWIOTLB=y
+CONFIG_SWP_EMULATE=y
+CONFIG_SYS_SUPPORTS_APM_EMULATION=y
+# CONFIG_TEXTSEARCH is not set
+CONFIG_THERMAL=y
+CONFIG_THERMAL_BCM2835=y
+CONFIG_THERMAL_DEFAULT_GOV_STEP_WISE=y
+CONFIG_THERMAL_GOV_STEP_WISE=y
+CONFIG_THERMAL_OF=y
+# CONFIG_THUMB2_KERNEL is not set
+CONFIG_TICK_CPU_ACCOUNTING=y
+CONFIG_TMPFS_POSIX_ACL=y
+CONFIG_TREE_RCU=y
+CONFIG_UEVENT_HELPER_PATH=""
+# CONFIG_UID16 is not set
+CONFIG_UNCOMPRESS_INCLUDE="debug/uncompress.h"
+CONFIG_USB=y
+CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
+CONFIG_USB_COMMON=y
+CONFIG_USB_DWCOTG=y
+# CONFIG_USB_EHCI_HCD is not set
+CONFIG_USB_NET_DRIVERS=y
+CONFIG_USB_NET_SMSC95XX=y
+CONFIG_USB_STORAGE=y
+CONFIG_USB_SUPPORT=y
+CONFIG_USB_UAS=y
+CONFIG_USB_USBNET=y
+CONFIG_USE_OF=y
+CONFIG_VECTORS_BASE=0xffff0000
+CONFIG_VFP=y
+CONFIG_VFPv3=y
+CONFIG_VMSPLIT_2G=y
+# CONFIG_VMSPLIT_3G is not set
+CONFIG_VT=y
+CONFIG_VT_CONSOLE=y
+CONFIG_VT_CONSOLE_SLEEP=y
+CONFIG_VT_HW_CONSOLE_BINDING=y
+CONFIG_WATCHDOG_CORE=y
+CONFIG_XPS=y
+CONFIG_XZ_DEC_ARM=y
+CONFIG_XZ_DEC_BCJ=y
+CONFIG_ZBOOT_ROM_BSS=0x0
+CONFIG_ZBOOT_ROM_TEXT=0x0
diff --git a/target/linux/brcm2708/bcm2710/config-4.9 b/target/linux/brcm2708/bcm2710/config-4.9
new file mode 100644 (file)
index 0000000..9828c04
--- /dev/null
@@ -0,0 +1,407 @@
+# CONFIG_AIO is not set
+CONFIG_ALIGNMENT_TRAP=y
+# CONFIG_AMBA_PL08X is not set
+CONFIG_ARCH_BCM=y
+CONFIG_ARCH_BCM2835=y
+CONFIG_ARCH_CLOCKSOURCE_DATA=y
+CONFIG_ARCH_HAS_ELF_RANDOMIZE=y
+CONFIG_ARCH_HAS_GCOV_PROFILE_ALL=y
+CONFIG_ARCH_HAS_SG_CHAIN=y
+CONFIG_ARCH_HAS_TICK_BROADCAST=y
+CONFIG_ARCH_HAVE_CUSTOM_GPIO_H=y
+CONFIG_ARCH_HIBERNATION_POSSIBLE=y
+CONFIG_ARCH_MIGHT_HAVE_PC_PARPORT=y
+CONFIG_ARCH_MMAP_RND_BITS_MAX=15
+CONFIG_ARCH_MULTIPLATFORM=y
+# CONFIG_ARCH_MULTI_CPU_AUTO is not set
+CONFIG_ARCH_MULTI_V6_V7=y
+CONFIG_ARCH_MULTI_V7=y
+CONFIG_ARCH_NR_GPIO=0
+# CONFIG_ARCH_SELECT_MEMORY_MODEL is not set
+# CONFIG_ARCH_SPARSEMEM_DEFAULT is not set
+CONFIG_ARCH_SUPPORTS_ATOMIC_RMW=y
+CONFIG_ARCH_SUPPORTS_UPROBES=y
+CONFIG_ARCH_SUSPEND_POSSIBLE=y
+CONFIG_ARCH_USE_BUILTIN_BSWAP=y
+CONFIG_ARCH_USE_CMPXCHG_LOCKREF=y
+CONFIG_ARCH_WANT_GENERAL_HUGETLB=y
+CONFIG_ARCH_WANT_IPC_PARSE_VERSION=y
+CONFIG_ARM=y
+CONFIG_ARM_AMBA=y
+CONFIG_ARM_ARCH_TIMER=y
+CONFIG_ARM_ARCH_TIMER_EVTSTREAM=y
+CONFIG_ARM_CPU_SUSPEND=y
+CONFIG_ARM_HAS_SG_CHAIN=y
+CONFIG_ARM_L1_CACHE_SHIFT=6
+CONFIG_ARM_L1_CACHE_SHIFT_6=y
+# CONFIG_ARM_LPAE is not set
+CONFIG_ARM_PATCH_IDIV=y
+CONFIG_ARM_PATCH_PHYS_VIRT=y
+# CONFIG_ARM_SCPI_PROTOCOL is not set
+# CONFIG_ARM_SP805_WATCHDOG is not set
+CONFIG_ARM_THUMB=y
+# CONFIG_ARM_THUMBEE is not set
+CONFIG_ARM_TIMER_SP804=y
+CONFIG_ARM_UNWIND=y
+CONFIG_ARM_VIRT_EXT=y
+CONFIG_AUTO_ZRELADDR=y
+# CONFIG_BACKLIGHT_CLASS_DEVICE is not set
+CONFIG_BACKLIGHT_LCD_SUPPORT=y
+CONFIG_BCM2708_VCHIQ=y
+CONFIG_BCM2708_VCMEM=y
+# CONFIG_BCM2835_DEVGPIOMEM is not set
+CONFIG_BCM2835_MBOX=y
+# CONFIG_BCM2835_SMI is not set
+CONFIG_BCM2835_TIMER=y
+CONFIG_BCM2835_WDT=y
+CONFIG_BCM_VCIO=y
+CONFIG_BCM_VC_CMA=y
+CONFIG_BCM_VC_SM=y
+# CONFIG_BINFMT_FLAT is not set
+# CONFIG_BLK_DEV_INITRD is not set
+CONFIG_BLK_DEV_LOOP=y
+CONFIG_BLK_DEV_RAM=y
+CONFIG_BLK_DEV_RAM_COUNT=16
+CONFIG_BLK_DEV_RAM_SIZE=4096
+CONFIG_BLK_DEV_SD=y
+CONFIG_BRCM_CHAR_DRIVERS=y
+CONFIG_BUILD_BIN2C=y
+# CONFIG_CACHE_L2X0 is not set
+CONFIG_CLKDEV_LOOKUP=y
+CONFIG_CLKSRC_MMIO=y
+CONFIG_CLKSRC_OF=y
+CONFIG_CLKSRC_PROBE=y
+CONFIG_CLONE_BACKWARDS=y
+CONFIG_CMA=y
+CONFIG_CMA_ALIGNMENT=8
+CONFIG_CMA_AREAS=7
+# CONFIG_CMA_DEBUG is not set
+# CONFIG_CMA_DEBUGFS is not set
+CONFIG_CMA_SIZE_MBYTES=16
+# CONFIG_CMA_SIZE_SEL_MAX is not set
+CONFIG_CMA_SIZE_SEL_MBYTES=y
+# CONFIG_CMA_SIZE_SEL_MIN is not set
+# CONFIG_CMA_SIZE_SEL_PERCENTAGE is not set
+CONFIG_COMMON_CLK=y
+CONFIG_CONFIGFS_FS=y
+CONFIG_CONSOLE_TRANSLATIONS=y
+CONFIG_CPU_32v6K=y
+CONFIG_CPU_32v7=y
+CONFIG_CPU_ABRT_EV7=y
+# CONFIG_CPU_BPREDICT_DISABLE is not set
+CONFIG_CPU_CACHE_V7=y
+CONFIG_CPU_CACHE_VIPT=y
+CONFIG_CPU_COPY_V6=y
+CONFIG_CPU_CP15=y
+CONFIG_CPU_CP15_MMU=y
+CONFIG_CPU_HAS_ASID=y
+# CONFIG_CPU_HOTPLUG_STATE_CONTROL is not set
+# CONFIG_CPU_ICACHE_DISABLE is not set
+CONFIG_CPU_IDLE=y
+CONFIG_CPU_IDLE_GOV_LADDER=y
+CONFIG_CPU_IDLE_GOV_MENU=y
+CONFIG_CPU_PABRT_V7=y
+CONFIG_CPU_PM=y
+CONFIG_CPU_RMAP=y
+CONFIG_CPU_TLB_V7=y
+CONFIG_CPU_V7=y
+CONFIG_CRC16=y
+CONFIG_CRYPTO_AEAD=y
+CONFIG_CRYPTO_AEAD2=y
+CONFIG_CRYPTO_CRC32C=y
+CONFIG_CRYPTO_HASH=y
+CONFIG_CRYPTO_HASH2=y
+CONFIG_CRYPTO_MANAGER=y
+CONFIG_CRYPTO_MANAGER2=y
+CONFIG_CRYPTO_NULL2=y
+CONFIG_CRYPTO_RNG2=y
+CONFIG_CRYPTO_WORKQUEUE=y
+CONFIG_DCACHE_WORD_ACCESS=y
+CONFIG_DEBUG_BUGVERBOSE=y
+CONFIG_DEBUG_INFO=y
+CONFIG_DEBUG_LL_INCLUDE="mach/debug-macro.S"
+# CONFIG_DEBUG_UART_8250 is not set
+# CONFIG_DEBUG_USER is not set
+CONFIG_DEFAULT_CFQ=y
+# CONFIG_DEFAULT_DEADLINE is not set
+CONFIG_DEFAULT_IOSCHED="cfq"
+CONFIG_DMADEVICES=y
+CONFIG_DMA_BCM2708=y
+CONFIG_DMA_BCM2835=y
+CONFIG_DMA_CMA=y
+CONFIG_DMA_ENGINE=y
+CONFIG_DMA_OF=y
+CONFIG_DMA_VIRTUAL_CHANNELS=y
+CONFIG_DNOTIFY=y
+CONFIG_DTC=y
+CONFIG_DUMMY_CONSOLE=y
+CONFIG_EDAC_ATOMIC_SCRUB=y
+CONFIG_EDAC_SUPPORT=y
+CONFIG_ENABLE_MUST_CHECK=y
+CONFIG_EXT4_FS=y
+CONFIG_EXT4_FS_POSIX_ACL=y
+CONFIG_EXT4_FS_SECURITY=y
+CONFIG_FB=y
+CONFIG_FB_BCM2708=y
+CONFIG_FB_CFB_COPYAREA=y
+CONFIG_FB_CFB_FILLRECT=y
+CONFIG_FB_CFB_IMAGEBLIT=y
+CONFIG_FB_CMDLINE=y
+# CONFIG_FB_RPISENSE is not set
+CONFIG_FIQ=y
+CONFIG_FIRMWARE_IN_KERNEL=y
+CONFIG_FIX_EARLYCON_MEM=y
+# CONFIG_FONTS is not set
+CONFIG_FONT_8x16=y
+CONFIG_FONT_8x8=y
+CONFIG_FONT_SUPPORT=y
+# CONFIG_FPE_FASTFPE is not set
+# CONFIG_FPE_NWFPE is not set
+CONFIG_FRAMEBUFFER_CONSOLE=y
+# CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY is not set
+# CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
+CONFIG_FREEZER=y
+CONFIG_FS_MBCACHE=y
+CONFIG_FS_POSIX_ACL=y
+CONFIG_GENERIC_ALLOCATOR=y
+CONFIG_GENERIC_BUG=y
+CONFIG_GENERIC_CLOCKEVENTS=y
+CONFIG_GENERIC_CLOCKEVENTS_BROADCAST=y
+CONFIG_GENERIC_EARLY_IOREMAP=y
+CONFIG_GENERIC_IDLE_POLL_SETUP=y
+CONFIG_GENERIC_IO=y
+CONFIG_GENERIC_IRQ_SHOW=y
+CONFIG_GENERIC_IRQ_SHOW_LEVEL=y
+CONFIG_GENERIC_PCI_IOMAP=y
+CONFIG_GENERIC_PINCONF=y
+CONFIG_GENERIC_SCHED_CLOCK=y
+CONFIG_GENERIC_SMP_IDLE_THREAD=y
+CONFIG_GENERIC_STRNCPY_FROM_USER=y
+CONFIG_GENERIC_STRNLEN_USER=y
+CONFIG_GPIOLIB=y
+CONFIG_GPIO_BCM_VIRT=y
+CONFIG_GPIO_SYSFS=y
+CONFIG_HANDLE_DOMAIN_IRQ=y
+CONFIG_HARDIRQS_SW_RESEND=y
+CONFIG_HAS_DMA=y
+CONFIG_HAS_IOMEM=y
+CONFIG_HAS_IOPORT_MAP=y
+# CONFIG_HAVE_64BIT_ALIGNED_ACCESS is not set
+CONFIG_HAVE_ARCH_BITREVERSE=y
+CONFIG_HAVE_ARCH_JUMP_LABEL=y
+CONFIG_HAVE_ARCH_KGDB=y
+CONFIG_HAVE_ARCH_PFN_VALID=y
+CONFIG_HAVE_ARCH_TRACEHOOK=y
+CONFIG_HAVE_ARM_ARCH_TIMER=y
+CONFIG_HAVE_ARM_SMCCC=y
+# CONFIG_HAVE_BOOTMEM_INFO_NODE is not set
+CONFIG_HAVE_CBPF_JIT=y
+CONFIG_HAVE_CC_STACKPROTECTOR=y
+CONFIG_HAVE_CLK=y
+CONFIG_HAVE_CLK_PREPARE=y
+CONFIG_HAVE_CONTEXT_TRACKING=y
+CONFIG_HAVE_C_RECORDMCOUNT=y
+CONFIG_HAVE_DEBUG_KMEMLEAK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+CONFIG_HAVE_DMA_CONTIGUOUS=y
+CONFIG_HAVE_DYNAMIC_FTRACE=y
+CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS=y
+CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y
+CONFIG_HAVE_FUNCTION_TRACER=y
+CONFIG_HAVE_GENERIC_DMA_COHERENT=y
+CONFIG_HAVE_IRQ_TIME_ACCOUNTING=y
+CONFIG_HAVE_MEMBLOCK=y
+CONFIG_HAVE_MOD_ARCH_SPECIFIC=y
+CONFIG_HAVE_NET_DSA=y
+CONFIG_HAVE_OPROFILE=y
+CONFIG_HAVE_OPTPROBES=y
+CONFIG_HAVE_PERF_EVENTS=y
+CONFIG_HAVE_PERF_REGS=y
+CONFIG_HAVE_PERF_USER_STACK_DUMP=y
+CONFIG_HAVE_PROC_CPU=y
+CONFIG_HAVE_REGS_AND_STACK_ACCESS_API=y
+CONFIG_HAVE_SMP=y
+CONFIG_HAVE_SYSCALL_TRACEPOINTS=y
+CONFIG_HAVE_UID16=y
+CONFIG_HAVE_VIRT_CPU_ACCOUNTING_GEN=y
+CONFIG_HOTPLUG_CPU=y
+CONFIG_HW_CONSOLE=y
+CONFIG_HZ_FIXED=0
+CONFIG_IKCONFIG=y
+CONFIG_IKCONFIG_PROC=y
+CONFIG_INPUT=y
+CONFIG_INPUT_MOUSEDEV=y
+# CONFIG_INPUT_MOUSEDEV_PSAUX is not set
+CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
+CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
+CONFIG_IOMMU_HELPER=y
+CONFIG_IOSCHED_CFQ=y
+CONFIG_IRQCHIP=y
+CONFIG_IRQ_DOMAIN=y
+CONFIG_IRQ_FORCED_THREADING=y
+CONFIG_IRQ_WORK=y
+CONFIG_JBD2=y
+CONFIG_KERNEL_GZIP=y
+# CONFIG_KERNEL_XZ is not set
+# CONFIG_LCD_CLASS_DEVICE is not set
+CONFIG_LEDS_GPIO=y
+CONFIG_LEDS_TRIGGER_INPUT=y
+CONFIG_LIBFDT=y
+CONFIG_LOCK_SPIN_ON_OWNER=y
+CONFIG_LOGO=y
+CONFIG_LOGO_LINUX_CLUT224=y
+# CONFIG_LOGO_LINUX_MONO is not set
+# CONFIG_LOGO_LINUX_VGA16 is not set
+CONFIG_LZO_COMPRESS=y
+CONFIG_LZO_DECOMPRESS=y
+CONFIG_MAC_PARTITION=y
+CONFIG_MAGIC_SYSRQ=y
+CONFIG_MAILBOX=y
+# CONFIG_MAILBOX_TEST is not set
+CONFIG_MAX_RAW_DEVS=256
+CONFIG_MEMORY_ISOLATION=y
+CONFIG_MFD_SYSCON=y
+CONFIG_MIGHT_HAVE_CACHE_L2X0=y
+CONFIG_MIGHT_HAVE_PCI=y
+CONFIG_MIGRATION=y
+CONFIG_MMC=y
+CONFIG_MMC_BCM2835=y
+CONFIG_MMC_BCM2835_DMA=y
+CONFIG_MMC_BCM2835_PIO_DMA_BARRIER=2
+CONFIG_MMC_BCM2835_SDHOST=y
+CONFIG_MMC_BLOCK=y
+CONFIG_MMC_BLOCK_MINORS=32
+CONFIG_MMC_SDHCI=y
+CONFIG_MMC_SDHCI_PLTFM=y
+CONFIG_MODULES_USE_ELF_REL=y
+# CONFIG_MTD is not set
+CONFIG_MULTI_IRQ_HANDLER=y
+CONFIG_MUTEX_SPIN_ON_OWNER=y
+CONFIG_NEED_DMA_MAP_STATE=y
+CONFIG_NEON=y
+CONFIG_NET_FLOW_LIMIT=y
+CONFIG_NLS=y
+CONFIG_NLS_ASCII=y
+CONFIG_NLS_DEFAULT="utf8"
+CONFIG_NO_BOOTMEM=y
+CONFIG_NO_HZ=y
+CONFIG_NO_HZ_COMMON=y
+CONFIG_NO_HZ_IDLE=y
+CONFIG_NR_CPUS=4
+CONFIG_OABI_COMPAT=y
+CONFIG_OF=y
+CONFIG_OF_ADDRESS=y
+CONFIG_OF_CONFIGFS=y
+CONFIG_OF_DYNAMIC=y
+CONFIG_OF_EARLY_FLATTREE=y
+CONFIG_OF_FLATTREE=y
+CONFIG_OF_GPIO=y
+CONFIG_OF_IRQ=y
+CONFIG_OF_NET=y
+CONFIG_OF_OVERLAY=y
+CONFIG_OF_RESERVED_MEM=y
+CONFIG_OF_RESOLVE=y
+CONFIG_OLD_SIGACTION=y
+CONFIG_OLD_SIGSUSPEND3=y
+CONFIG_PADATA=y
+CONFIG_PAGE_OFFSET=0x80000000
+# CONFIG_PCI_DOMAINS_GENERIC is not set
+# CONFIG_PCI_SYSCALL is not set
+CONFIG_PERF_USE_VMALLOC=y
+CONFIG_PGTABLE_LEVELS=2
+CONFIG_PINCTRL=y
+CONFIG_PINCTRL_BCM2835=y
+# CONFIG_PL330_DMA is not set
+CONFIG_PM=y
+CONFIG_PM_CLK=y
+# CONFIG_PM_DEBUG is not set
+CONFIG_PM_GENERIC_DOMAINS=y
+CONFIG_PM_GENERIC_DOMAINS_OF=y
+CONFIG_PM_GENERIC_DOMAINS_SLEEP=y
+CONFIG_PM_SLEEP=y
+CONFIG_PM_SLEEP_SMP=y
+CONFIG_POWER_SUPPLY=y
+CONFIG_PRINTK_TIME=y
+CONFIG_PROC_PAGE_MONITOR=y
+CONFIG_PWM=y
+CONFIG_PWM_BCM2835=y
+CONFIG_PWM_SYSFS=y
+CONFIG_RASPBERRYPI_FIRMWARE=y
+CONFIG_RASPBERRYPI_POWER=y
+CONFIG_RATIONAL=y
+CONFIG_RAW_DRIVER=y
+CONFIG_RCU_STALL_COMMON=y
+CONFIG_REGMAP=y
+CONFIG_REGMAP_MMIO=y
+CONFIG_RFS_ACCEL=y
+CONFIG_RPS=y
+CONFIG_RWSEM_SPIN_ON_OWNER=y
+CONFIG_RWSEM_XCHGADD_ALGORITHM=y
+CONFIG_SCHED_HRTICK=y
+# CONFIG_SCHED_INFO is not set
+CONFIG_SCSI=y
+# CONFIG_SCSI_LOWLEVEL is not set
+# CONFIG_SCSI_PROC_FS is not set
+CONFIG_SERIAL_8250_BCM2835AUX=y
+# CONFIG_SERIAL_8250_DMA is not set
+CONFIG_SERIAL_8250_EXTENDED=y
+CONFIG_SERIAL_8250_FSL=y
+CONFIG_SERIAL_8250_NR_UARTS=1
+CONFIG_SERIAL_8250_RUNTIME_UARTS=0
+CONFIG_SERIAL_8250_SHARE_IRQ=y
+# CONFIG_SERIAL_AMBA_PL010 is not set
+CONFIG_SERIAL_AMBA_PL011=y
+CONFIG_SERIAL_AMBA_PL011_CONSOLE=y
+CONFIG_SERIAL_OF_PLATFORM=y
+CONFIG_SMP=y
+CONFIG_SMP_ON_UP=y
+CONFIG_SPARSE_IRQ=y
+# CONFIG_SQUASHFS is not set
+CONFIG_SRCU=y
+# CONFIG_STRIP_ASM_SYMS is not set
+CONFIG_SUSPEND=y
+CONFIG_SUSPEND_FREEZER=y
+CONFIG_SWIOTLB=y
+CONFIG_SWP_EMULATE=y
+CONFIG_SYS_SUPPORTS_APM_EMULATION=y
+# CONFIG_TEXTSEARCH is not set
+CONFIG_THERMAL=y
+CONFIG_THERMAL_BCM2835=y
+CONFIG_THERMAL_DEFAULT_GOV_STEP_WISE=y
+CONFIG_THERMAL_GOV_STEP_WISE=y
+CONFIG_THERMAL_OF=y
+# CONFIG_THUMB2_KERNEL is not set
+CONFIG_TICK_CPU_ACCOUNTING=y
+CONFIG_TMPFS_POSIX_ACL=y
+CONFIG_TREE_RCU=y
+CONFIG_UEVENT_HELPER_PATH=""
+# CONFIG_UID16 is not set
+CONFIG_UNCOMPRESS_INCLUDE="debug/uncompress.h"
+CONFIG_USB=y
+CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
+CONFIG_USB_COMMON=y
+CONFIG_USB_DWCOTG=y
+# CONFIG_USB_EHCI_HCD is not set
+CONFIG_USB_NET_DRIVERS=y
+CONFIG_USB_NET_SMSC95XX=y
+CONFIG_USB_STORAGE=y
+CONFIG_USB_SUPPORT=y
+CONFIG_USB_UAS=y
+CONFIG_USB_USBNET=y
+CONFIG_USE_OF=y
+CONFIG_VECTORS_BASE=0xffff0000
+CONFIG_VFP=y
+CONFIG_VFPv3=y
+CONFIG_VMSPLIT_2G=y
+# CONFIG_VMSPLIT_3G is not set
+CONFIG_VT=y
+CONFIG_VT_CONSOLE=y
+CONFIG_VT_CONSOLE_SLEEP=y
+CONFIG_VT_HW_CONSOLE_BINDING=y
+CONFIG_WATCHDOG_CORE=y
+CONFIG_XPS=y
+CONFIG_XZ_DEC_ARM=y
+CONFIG_XZ_DEC_BCJ=y
+CONFIG_ZBOOT_ROM_BSS=0x0
+CONFIG_ZBOOT_ROM_TEXT=0x0
diff --git a/target/linux/brcm2708/patches-4.9/0001-smsx95xx-fix-crimes-against-truesize.patch b/target/linux/brcm2708/patches-4.9/0001-smsx95xx-fix-crimes-against-truesize.patch
new file mode 100644 (file)
index 0000000..b8b424b
--- /dev/null
@@ -0,0 +1,47 @@
+From 3df8aa3aa981f3c463d793b69fa23c5aab53fec2 Mon Sep 17 00:00:00 2001
+From: Steve Glendinning <steve.glendinning@smsc.com>
+Date: Thu, 19 Feb 2015 18:47:12 +0000
+Subject: [PATCH] smsx95xx: fix crimes against truesize
+
+smsc95xx is adjusting truesize when it shouldn't, and following a recent patch from Eric this is now triggering warnings.
+
+This patch stops smsc95xx from changing truesize.
+
+Signed-off-by: Steve Glendinning <steve.glendinning@smsc.com>
+---
+ drivers/net/usb/smsc95xx.c | 10 ++++++++--
+ 1 file changed, 8 insertions(+), 2 deletions(-)
+
+--- a/drivers/net/usb/smsc95xx.c
++++ b/drivers/net/usb/smsc95xx.c
+@@ -82,6 +82,10 @@ static bool turbo_mode = true;
+ module_param(turbo_mode, bool, 0644);
+ MODULE_PARM_DESC(turbo_mode, "Enable multiple frames per Rx transaction");
++static bool truesize_mode = false;
++module_param(truesize_mode, bool, 0644);
++MODULE_PARM_DESC(truesize_mode, "Report larger truesize value");
++
+ static int __must_check __smsc95xx_read_reg(struct usbnet *dev, u32 index,
+                                           u32 *data, int in_pm)
+ {
+@@ -1951,7 +1955,8 @@ static int smsc95xx_rx_fixup(struct usbn
+                               if (dev->net->features & NETIF_F_RXCSUM)
+                                       smsc95xx_rx_csum_offload(skb);
+                               skb_trim(skb, skb->len - 4); /* remove fcs */
+-                              skb->truesize = size + sizeof(struct sk_buff);
++                              if (truesize_mode)
++                                      skb->truesize = size + sizeof(struct sk_buff);
+                               return 1;
+                       }
+@@ -1969,7 +1974,8 @@ static int smsc95xx_rx_fixup(struct usbn
+                       if (dev->net->features & NETIF_F_RXCSUM)
+                               smsc95xx_rx_csum_offload(ax_skb);
+                       skb_trim(ax_skb, ax_skb->len - 4); /* remove fcs */
+-                      ax_skb->truesize = size + sizeof(struct sk_buff);
++                      if (truesize_mode)
++                              ax_skb->truesize = size + sizeof(struct sk_buff);
+                       usbnet_skb_return(dev, ax_skb);
+               }
diff --git a/target/linux/brcm2708/patches-4.9/0002-smsc95xx-Experimental-Enable-turbo_mode-and-packetsi.patch b/target/linux/brcm2708/patches-4.9/0002-smsc95xx-Experimental-Enable-turbo_mode-and-packetsi.patch
new file mode 100644 (file)
index 0000000..9d47276
--- /dev/null
@@ -0,0 +1,43 @@
+From aefca8fa1aefb12cc7ac1862b4c6e94c1ec9e74c Mon Sep 17 00:00:00 2001
+From: Sam Nazarko <email@samnazarko.co.uk>
+Date: Fri, 1 Apr 2016 17:27:21 +0100
+Subject: [PATCH] smsc95xx: Experimental: Enable turbo_mode and packetsize=2560
+ by default
+
+See: http://forum.kodi.tv/showthread.php?tid=285288
+---
+ drivers/net/usb/smsc95xx.c | 14 +++++++++-----
+ 1 file changed, 9 insertions(+), 5 deletions(-)
+
+--- a/drivers/net/usb/smsc95xx.c
++++ b/drivers/net/usb/smsc95xx.c
+@@ -86,6 +86,10 @@ static bool truesize_mode = false;
+ module_param(truesize_mode, bool, 0644);
+ MODULE_PARM_DESC(truesize_mode, "Report larger truesize value");
++static int packetsize = 2560;
++module_param(packetsize, int, 0644);
++MODULE_PARM_DESC(packetsize, "Override the RX URB packet size");
++
+ static int __must_check __smsc95xx_read_reg(struct usbnet *dev, u32 index,
+                                           u32 *data, int in_pm)
+ {
+@@ -1106,13 +1110,13 @@ static int smsc95xx_reset(struct usbnet
+       if (!turbo_mode) {
+               burst_cap = 0;
+-              dev->rx_urb_size = MAX_SINGLE_PACKET_SIZE;
++              dev->rx_urb_size = packetsize ? packetsize : MAX_SINGLE_PACKET_SIZE;
+       } else if (dev->udev->speed == USB_SPEED_HIGH) {
+-              burst_cap = DEFAULT_HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
+-              dev->rx_urb_size = DEFAULT_HS_BURST_CAP_SIZE;
++              dev->rx_urb_size = packetsize ? packetsize : DEFAULT_HS_BURST_CAP_SIZE;
++              burst_cap = dev->rx_urb_size / HS_USB_PKT_SIZE;
+       } else {
+-              burst_cap = DEFAULT_FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
+-              dev->rx_urb_size = DEFAULT_FS_BURST_CAP_SIZE;
++              dev->rx_urb_size = packetsize ? packetsize : DEFAULT_FS_BURST_CAP_SIZE;
++              burst_cap = dev->rx_urb_size / FS_USB_PKT_SIZE;
+       }
+       netif_dbg(dev, ifup, dev->net, "rx_urb_size=%ld\n",
diff --git a/target/linux/brcm2708/patches-4.9/0003-Allow-mac-address-to-be-set-in-smsc95xx.patch b/target/linux/brcm2708/patches-4.9/0003-Allow-mac-address-to-be-set-in-smsc95xx.patch
new file mode 100644 (file)
index 0000000..dbcf303
--- /dev/null
@@ -0,0 +1,96 @@
+From a4774fe88b0a06562a7b6c5d3181f13e7444a3f0 Mon Sep 17 00:00:00 2001
+From: popcornmix <popcornmix@gmail.com>
+Date: Tue, 26 Mar 2013 17:26:38 +0000
+Subject: [PATCH] Allow mac address to be set in smsc95xx
+
+Signed-off-by: popcornmix <popcornmix@gmail.com>
+---
+ drivers/net/usb/smsc95xx.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 56 insertions(+)
+
+--- a/drivers/net/usb/smsc95xx.c
++++ b/drivers/net/usb/smsc95xx.c
+@@ -60,6 +60,7 @@
+ #define SUSPEND_SUSPEND3              (0x08)
+ #define SUSPEND_ALLMODES              (SUSPEND_SUSPEND0 | SUSPEND_SUSPEND1 | \
+                                        SUSPEND_SUSPEND2 | SUSPEND_SUSPEND3)
++#define MAC_ADDR_LEN                    (6)
+ #define CARRIER_CHECK_DELAY (2 * HZ)
+@@ -90,6 +91,10 @@ static int packetsize = 2560;
+ module_param(packetsize, int, 0644);
+ MODULE_PARM_DESC(packetsize, "Override the RX URB packet size");
++static char *macaddr = ":";
++module_param(macaddr, charp, 0);
++MODULE_PARM_DESC(macaddr, "MAC address");
++
+ static int __must_check __smsc95xx_read_reg(struct usbnet *dev, u32 index,
+                                           u32 *data, int in_pm)
+ {
+@@ -918,6 +923,53 @@ static int smsc95xx_ioctl(struct net_dev
+       return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
+ }
++/* Check the macaddr module parameter for a MAC address */
++static int smsc95xx_is_macaddr_param(struct usbnet *dev, u8 *dev_mac)
++{
++       int i, j, got_num, num;
++       u8 mtbl[MAC_ADDR_LEN];
++
++       if (macaddr[0] == ':')
++               return 0;
++
++       i = 0;
++       j = 0;
++       num = 0;
++       got_num = 0;
++       while (j < MAC_ADDR_LEN) {
++               if (macaddr[i] && macaddr[i] != ':') {
++                       got_num++;
++                       if ('0' <= macaddr[i] && macaddr[i] <= '9')
++                               num = num * 16 + macaddr[i] - '0';
++                       else if ('A' <= macaddr[i] && macaddr[i] <= 'F')
++                               num = num * 16 + 10 + macaddr[i] - 'A';
++                       else if ('a' <= macaddr[i] && macaddr[i] <= 'f')
++                               num = num * 16 + 10 + macaddr[i] - 'a';
++                       else
++                               break;
++                       i++;
++               } else if (got_num == 2) {
++                       mtbl[j++] = (u8) num;
++                       num = 0;
++                       got_num = 0;
++                       i++;
++               } else {
++                       break;
++               }
++       }
++
++       if (j == MAC_ADDR_LEN) {
++               netif_dbg(dev, ifup, dev->net, "Overriding MAC address with: "
++               "%02x:%02x:%02x:%02x:%02x:%02x\n", mtbl[0], mtbl[1], mtbl[2],
++                                               mtbl[3], mtbl[4], mtbl[5]);
++               for (i = 0; i < MAC_ADDR_LEN; i++)
++                       dev_mac[i] = mtbl[i];
++               return 1;
++       } else {
++               return 0;
++       }
++}
++
+ static void smsc95xx_init_mac_address(struct usbnet *dev)
+ {
+       const u8 *mac_addr;
+@@ -939,6 +991,10 @@ static void smsc95xx_init_mac_address(st
+               }
+       }
++      /* Check module parameters */
++      if (smsc95xx_is_macaddr_param(dev, dev->net->dev_addr))
++              return;
++
+       /* no useful static MAC address found. generate a random one */
+       eth_hw_addr_random(dev->net);
+       netif_dbg(dev, ifup, dev->net, "MAC address set to eth_random_addr\n");
diff --git a/target/linux/brcm2708/patches-4.9/0004-Protect-__release_resource-against-resources-without.patch b/target/linux/brcm2708/patches-4.9/0004-Protect-__release_resource-against-resources-without.patch
new file mode 100644 (file)
index 0000000..f46579b
--- /dev/null
@@ -0,0 +1,27 @@
+From 0b4480a51b80954e34605c9bf42947d97e37d1c3 Mon Sep 17 00:00:00 2001
+From: Phil Elwell <phil@raspberrypi.org>
+Date: Fri, 13 Mar 2015 12:43:36 +0000
+Subject: [PATCH] Protect __release_resource against resources without parents
+
+Without this patch, removing a device tree overlay can crash here.
+
+Signed-off-by: Phil Elwell <phil@raspberrypi.org>
+---
+ kernel/resource.c | 6 ++++++
+ 1 file changed, 6 insertions(+)
+
+--- a/kernel/resource.c
++++ b/kernel/resource.c
+@@ -246,6 +246,12 @@ static int __release_resource(struct res
+ {
+       struct resource *tmp, **p, *chd;
++      if (!old->parent) {
++              WARN(old->sibling, "sibling but no parent");
++              if (old->sibling)
++                      return -EINVAL;
++              return 0;
++      }
+       p = &old->parent->child;
+       for (;;) {
+               tmp = *p;
diff --git a/target/linux/brcm2708/patches-4.9/0005-mm-Remove-the-PFN-busy-warning.patch b/target/linux/brcm2708/patches-4.9/0005-mm-Remove-the-PFN-busy-warning.patch
new file mode 100644 (file)
index 0000000..376d6a8
--- /dev/null
@@ -0,0 +1,25 @@
+From 029f649c29d81583b412cb6ff5792a3cf9102a95 Mon Sep 17 00:00:00 2001
+From: Eric Anholt <eric@anholt.net>
+Date: Thu, 18 Dec 2014 16:07:15 -0800
+Subject: [PATCH] mm: Remove the PFN busy warning
+
+See commit dae803e165a11bc88ca8dbc07a11077caf97bbcb -- the warning is
+expected sometimes when using CMA.  However, that commit still spams
+my kernel log with these warnings.
+
+Signed-off-by: Eric Anholt <eric@anholt.net>
+---
+ mm/page_alloc.c | 2 --
+ 1 file changed, 2 deletions(-)
+
+--- a/mm/page_alloc.c
++++ b/mm/page_alloc.c
+@@ -7323,8 +7323,6 @@ int alloc_contig_range(unsigned long sta
+       /* Make sure the range is really isolated. */
+       if (test_pages_isolated(outer_start, end, false)) {
+-              pr_info("%s: [%lx, %lx) PFNs busy\n",
+-                      __func__, outer_start, end);
+               ret = -EBUSY;
+               goto done;
+       }
diff --git a/target/linux/brcm2708/patches-4.9/0006-irq-bcm2836-Prevent-spurious-interrupts-and-trap-the.patch b/target/linux/brcm2708/patches-4.9/0006-irq-bcm2836-Prevent-spurious-interrupts-and-trap-the.patch
new file mode 100644 (file)
index 0000000..3ebcb0a
--- /dev/null
@@ -0,0 +1,26 @@
+From 3fad09910dafeb93a351aefa90ca4fd490f68c84 Mon Sep 17 00:00:00 2001
+From: Phil Elwell <phil@raspberrypi.org>
+Date: Fri, 4 Dec 2015 17:41:50 +0000
+Subject: [PATCH] irq-bcm2836: Prevent spurious interrupts, and trap them early
+
+The old arch-specific IRQ macros included a dsb to ensure the
+write to clear the mailbox interrupt completed before returning
+from the interrupt. The BCM2836 irqchip driver needs the same
+precaution to avoid spurious interrupts.
+
+Spurious interrupts are still possible for other reasons,
+though, so trap them early.
+---
+ drivers/irqchip/irq-bcm2836.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+--- a/drivers/irqchip/irq-bcm2836.c
++++ b/drivers/irqchip/irq-bcm2836.c
+@@ -175,6 +175,7 @@ __exception_irq_entry bcm2836_arm_irqchi
+               u32 ipi = ffs(mbox_val) - 1;
+               writel(1 << ipi, mailbox0);
++              dsb(sy);
+               handle_IPI(ipi, regs);
+ #endif
+       } else if (stat) {
diff --git a/target/linux/brcm2708/patches-4.9/0007-irqchip-bcm2835-Add-FIQ-support.patch b/target/linux/brcm2708/patches-4.9/0007-irqchip-bcm2835-Add-FIQ-support.patch
new file mode 100644 (file)
index 0000000..a25275f
--- /dev/null
@@ -0,0 +1,127 @@
+From 0c9c73fafac86e96a1d1fb59b13aac0ce6d70692 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= <noralf@tronnes.org>
+Date: Fri, 12 Jun 2015 19:01:05 +0200
+Subject: [PATCH] irqchip: bcm2835: Add FIQ support
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Add a duplicate irq range with an offset on the hwirq's so the
+driver can detect that enable_fiq() is used.
+Tested with downstream dwc_otg USB controller driver.
+
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+Reviewed-by: Eric Anholt <eric@anholt.net>
+Acked-by: Stephen Warren <swarren@wwwdotorg.org>
+---
+ arch/arm/mach-bcm/Kconfig     |  1 +
+ drivers/irqchip/irq-bcm2835.c | 51 ++++++++++++++++++++++++++++++++++++++-----
+ 2 files changed, 47 insertions(+), 5 deletions(-)
+
+--- a/arch/arm/mach-bcm/Kconfig
++++ b/arch/arm/mach-bcm/Kconfig
+@@ -152,6 +152,7 @@ config ARCH_BCM2835
+       select HAVE_ARM_ARCH_TIMER if ARCH_MULTI_V7
+       select CLKSRC_OF
+       select BCM2835_TIMER
++      select FIQ
+       select PINCTRL
+       select PINCTRL_BCM2835
+       help
+--- a/drivers/irqchip/irq-bcm2835.c
++++ b/drivers/irqchip/irq-bcm2835.c
+@@ -54,7 +54,7 @@
+ #include <asm/exception.h>
+ /* Put the bank and irq (32 bits) into the hwirq */
+-#define MAKE_HWIRQ(b, n)      ((b << 5) | (n))
++#define MAKE_HWIRQ(b, n)      (((b) << 5) | (n))
+ #define HWIRQ_BANK(i)         (i >> 5)
+ #define HWIRQ_BIT(i)          BIT(i & 0x1f)
+@@ -70,9 +70,13 @@
+                                       | SHORTCUT1_MASK | SHORTCUT2_MASK)
+ #define REG_FIQ_CONTROL               0x0c
++#define REG_FIQ_ENABLE                0x80
++#define REG_FIQ_DISABLE               0
+ #define NR_BANKS              3
+ #define IRQS_PER_BANK         32
++#define NUMBER_IRQS           MAKE_HWIRQ(NR_BANKS, 0)
++#define FIQ_START             (NR_IRQS_BANK0 + MAKE_HWIRQ(NR_BANKS - 1, 0))
+ static const int reg_pending[] __initconst = { 0x00, 0x04, 0x08 };
+ static const int reg_enable[] __initconst = { 0x18, 0x10, 0x14 };
+@@ -97,14 +101,38 @@ static void __exception_irq_entry bcm283
+       struct pt_regs *regs);
+ static void bcm2836_chained_handle_irq(struct irq_desc *desc);
++static inline unsigned int hwirq_to_fiq(unsigned long hwirq)
++{
++      hwirq -= NUMBER_IRQS;
++      /*
++       * The hwirq numbering used in this driver is:
++       *   BASE (0-7) GPU1 (32-63) GPU2 (64-95).
++       * This differ from the one used in the FIQ register:
++       *   GPU1 (0-31) GPU2 (32-63) BASE (64-71)
++       */
++      if (hwirq >= 32)
++              return hwirq - 32;
++
++      return hwirq + 64;
++}
++
+ static void armctrl_mask_irq(struct irq_data *d)
+ {
+-      writel_relaxed(HWIRQ_BIT(d->hwirq), intc.disable[HWIRQ_BANK(d->hwirq)]);
++      if (d->hwirq >= NUMBER_IRQS)
++              writel_relaxed(REG_FIQ_DISABLE, intc.base + REG_FIQ_CONTROL);
++      else
++              writel_relaxed(HWIRQ_BIT(d->hwirq),
++                             intc.disable[HWIRQ_BANK(d->hwirq)]);
+ }
+ static void armctrl_unmask_irq(struct irq_data *d)
+ {
+-      writel_relaxed(HWIRQ_BIT(d->hwirq), intc.enable[HWIRQ_BANK(d->hwirq)]);
++      if (d->hwirq >= NUMBER_IRQS)
++              writel_relaxed(REG_FIQ_ENABLE | hwirq_to_fiq(d->hwirq),
++                             intc.base + REG_FIQ_CONTROL);
++      else
++              writel_relaxed(HWIRQ_BIT(d->hwirq),
++                             intc.enable[HWIRQ_BANK(d->hwirq)]);
+ }
+ static struct irq_chip armctrl_chip = {
+@@ -150,8 +178,9 @@ static int __init armctrl_of_init(struct
+               panic("%s: unable to map IC registers\n",
+                       node->full_name);
+-      intc.domain = irq_domain_add_linear(node, MAKE_HWIRQ(NR_BANKS, 0),
+-                      &armctrl_ops, NULL);
++      intc.base = base;
++      intc.domain = irq_domain_add_linear(node, NUMBER_IRQS * 2,
++                                          &armctrl_ops, NULL);
+       if (!intc.domain)
+               panic("%s: unable to create IRQ domain\n", node->full_name);
+@@ -181,6 +210,18 @@ static int __init armctrl_of_init(struct
+               set_handle_irq(bcm2835_handle_irq);
+       }
++      /* Make a duplicate irq range which is used to enable FIQ */
++      for (b = 0; b < NR_BANKS; b++) {
++              for (i = 0; i < bank_irqs[b]; i++) {
++                      irq = irq_create_mapping(intc.domain,
++                                      MAKE_HWIRQ(b, i) + NUMBER_IRQS);
++                      BUG_ON(irq <= 0);
++                      irq_set_chip(irq, &armctrl_chip);
++                      set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
++              }
++      }
++      init_FIQ(FIQ_START);
++
+       return 0;
+ }
diff --git a/target/linux/brcm2708/patches-4.9/0008-irqchip-irq-bcm2835-Add-2836-FIQ-support.patch b/target/linux/brcm2708/patches-4.9/0008-irqchip-irq-bcm2835-Add-2836-FIQ-support.patch
new file mode 100644 (file)
index 0000000..710e73a
--- /dev/null
@@ -0,0 +1,99 @@
+From 3b662c4466e336bab7ebb438b65bd5487d30305d Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= <noralf@tronnes.org>
+Date: Fri, 23 Oct 2015 16:26:55 +0200
+Subject: [PATCH] irqchip: irq-bcm2835: Add 2836 FIQ support
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+---
+ drivers/irqchip/irq-bcm2835.c | 43 +++++++++++++++++++++++++++++++++++++++++--
+ 1 file changed, 41 insertions(+), 2 deletions(-)
+
+--- a/drivers/irqchip/irq-bcm2835.c
++++ b/drivers/irqchip/irq-bcm2835.c
+@@ -50,8 +50,11 @@
+ #include <linux/of_irq.h>
+ #include <linux/irqchip.h>
+ #include <linux/irqdomain.h>
++#include <linux/mfd/syscon.h>
++#include <linux/regmap.h>
+ #include <asm/exception.h>
++#include <asm/mach/irq.h>
+ /* Put the bank and irq (32 bits) into the hwirq */
+ #define MAKE_HWIRQ(b, n)      (((b) << 5) | (n))
+@@ -69,6 +72,9 @@
+ #define BANK0_VALID_MASK      (BANK0_HWIRQ_MASK | BANK1_HWIRQ | BANK2_HWIRQ \
+                                       | SHORTCUT1_MASK | SHORTCUT2_MASK)
++#undef ARM_LOCAL_GPU_INT_ROUTING
++#define ARM_LOCAL_GPU_INT_ROUTING 0x0c
++
+ #define REG_FIQ_CONTROL               0x0c
+ #define REG_FIQ_ENABLE                0x80
+ #define REG_FIQ_DISABLE               0
+@@ -94,6 +100,7 @@ struct armctrl_ic {
+       void __iomem *enable[NR_BANKS];
+       void __iomem *disable[NR_BANKS];
+       struct irq_domain *domain;
++      struct regmap *local_regmap;
+ };
+ static struct armctrl_ic intc __read_mostly;
+@@ -127,12 +134,35 @@ static void armctrl_mask_irq(struct irq_
+ static void armctrl_unmask_irq(struct irq_data *d)
+ {
+-      if (d->hwirq >= NUMBER_IRQS)
++      if (d->hwirq >= NUMBER_IRQS) {
++              if (num_online_cpus() > 1) {
++                      unsigned int data;
++                      int ret;
++
++                      if (!intc.local_regmap) {
++                              pr_err("FIQ is disabled due to missing regmap\n");
++                              return;
++                      }
++
++                      ret = regmap_read(intc.local_regmap,
++                                        ARM_LOCAL_GPU_INT_ROUTING, &data);
++                      if (ret) {
++                              pr_err("Failed to read int routing %d\n", ret);
++                              return;
++                      }
++
++                      data &= ~0xc;
++                      data |= (1 << 2);
++                      regmap_write(intc.local_regmap,
++                                   ARM_LOCAL_GPU_INT_ROUTING, data);
++              }
++
+               writel_relaxed(REG_FIQ_ENABLE | hwirq_to_fiq(d->hwirq),
+                              intc.base + REG_FIQ_CONTROL);
+-      else
++      } else {
+               writel_relaxed(HWIRQ_BIT(d->hwirq),
+                              intc.enable[HWIRQ_BANK(d->hwirq)]);
++      }
+ }
+ static struct irq_chip armctrl_chip = {
+@@ -210,6 +240,15 @@ static int __init armctrl_of_init(struct
+               set_handle_irq(bcm2835_handle_irq);
+       }
++      if (is_2836) {
++              intc.local_regmap =
++                      syscon_regmap_lookup_by_compatible("brcm,bcm2836-arm-local");
++              if (IS_ERR(intc.local_regmap)) {
++                      pr_err("Failed to get local register map. FIQ is disabled for cpus > 1\n");
++                      intc.local_regmap = NULL;
++              }
++      }
++
+       /* Make a duplicate irq range which is used to enable FIQ */
+       for (b = 0; b < NR_BANKS; b++) {
+               for (i = 0; i < bank_irqs[b]; i++) {
diff --git a/target/linux/brcm2708/patches-4.9/0009-spidev-Add-spidev-compatible-string-to-silence-warni.patch b/target/linux/brcm2708/patches-4.9/0009-spidev-Add-spidev-compatible-string-to-silence-warni.patch
new file mode 100644 (file)
index 0000000..0c5f0ee
--- /dev/null
@@ -0,0 +1,20 @@
+From 21a313f8517a1be2b0962710ffe9ad94e7334ba1 Mon Sep 17 00:00:00 2001
+From: Phil Elwell <phil@raspberrypi.org>
+Date: Tue, 14 Jul 2015 10:26:09 +0100
+Subject: [PATCH] spidev: Add "spidev" compatible string to silence warning
+
+See: https://github.com/raspberrypi/linux/issues/1054
+---
+ drivers/spi/spidev.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+--- a/drivers/spi/spidev.c
++++ b/drivers/spi/spidev.c
+@@ -697,6 +697,7 @@ static const struct of_device_id spidev_
+       { .compatible = "rohm,dh2228fv" },
+       { .compatible = "lineartechnology,ltc2488" },
+       { .compatible = "siliconlabs,si3210" },
++      { .compatible = "spidev" },
+       {},
+ };
+ MODULE_DEVICE_TABLE(of, spidev_dt_ids);
diff --git a/target/linux/brcm2708/patches-4.9/0010-serial-8250-Don-t-crash-when-nr_uarts-is-0.patch b/target/linux/brcm2708/patches-4.9/0010-serial-8250-Don-t-crash-when-nr_uarts-is-0.patch
new file mode 100644 (file)
index 0000000..be8e903
--- /dev/null
@@ -0,0 +1,20 @@
+From 0059a02a50c6d01a399024cad56ec5254c645fd0 Mon Sep 17 00:00:00 2001
+From: Phil Elwell <phil@raspberrypi.org>
+Date: Tue, 30 Jun 2015 14:12:42 +0100
+Subject: [PATCH] serial: 8250: Don't crash when nr_uarts is 0
+
+---
+ drivers/tty/serial/8250/8250_core.c | 2 ++
+ 1 file changed, 2 insertions(+)
+
+--- a/drivers/tty/serial/8250/8250_core.c
++++ b/drivers/tty/serial/8250/8250_core.c
+@@ -509,6 +509,8 @@ static void __init serial8250_isa_init_p
+       if (nr_uarts > UART_NR)
+               nr_uarts = UART_NR;
++      if (!nr_uarts)
++              return;
+       for (i = 0; i < nr_uarts; i++) {
+               struct uart_8250_port *up = &serial8250_ports[i];
diff --git a/target/linux/brcm2708/patches-4.9/0011-pinctrl-bcm2835-Set-base-to-0-give-expected-gpio-num.patch b/target/linux/brcm2708/patches-4.9/0011-pinctrl-bcm2835-Set-base-to-0-give-expected-gpio-num.patch
new file mode 100644 (file)
index 0000000..978d675
--- /dev/null
@@ -0,0 +1,21 @@
+From c9d0e1314de3cde0674ef5a2c8688b1dc10b2091 Mon Sep 17 00:00:00 2001
+From: notro <notro@tronnes.org>
+Date: Thu, 10 Jul 2014 13:59:47 +0200
+Subject: [PATCH] pinctrl-bcm2835: Set base to 0 give expected gpio numbering
+
+Signed-off-by: Noralf Tronnes <notro@tronnes.org>
+---
+ drivers/pinctrl/bcm/pinctrl-bcm2835.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+--- a/drivers/pinctrl/bcm/pinctrl-bcm2835.c
++++ b/drivers/pinctrl/bcm/pinctrl-bcm2835.c
+@@ -386,7 +386,7 @@ static struct gpio_chip bcm2835_gpio_chi
+       .get = bcm2835_gpio_get,
+       .set = bcm2835_gpio_set,
+       .to_irq = bcm2835_gpio_to_irq,
+-      .base = -1,
++      .base = 0,
+       .ngpio = BCM2835_NUM_GPIOS,
+       .can_sleep = false,
+ };
diff --git a/target/linux/brcm2708/patches-4.9/0012-pinctrl-bcm2835-Fix-interrupt-handling-for-GPIOs-28-.patch b/target/linux/brcm2708/patches-4.9/0012-pinctrl-bcm2835-Fix-interrupt-handling-for-GPIOs-28-.patch
new file mode 100644 (file)
index 0000000..67cc420
--- /dev/null
@@ -0,0 +1,146 @@
+From c7ab4eb8e79ceaa923a7c9f4e14dc085a1934a29 Mon Sep 17 00:00:00 2001
+From: Phil Elwell <phil@raspberrypi.org>
+Date: Tue, 24 Feb 2015 13:40:50 +0000
+Subject: [PATCH] pinctrl-bcm2835: Fix interrupt handling for GPIOs 28-31 and
+ 46-53
+
+Contrary to the documentation, the BCM2835 GPIO controller actually has
+four interrupt lines - one each for the three IRQ groups and one common. Rather
+confusingly, the GPIO interrupt groups don't correspond directly with the GPIO
+control banks. Instead, GPIOs 0-27 generate IRQ GPIO0, 28-45 GPIO1 and
+46-53 GPIO2.
+
+Awkwardly, the GPIOS for IRQ GPIO1 straddle two 32-entry GPIO banks, so it is
+cleaner to split out a function to process the interrupts for a single GPIO
+bank.
+
+This bug has only just been observed because GPIOs above 27 can only be
+accessed on an old Raspberry Pi with the optional P5 header fitted, where
+the pins are often used for I2S instead.
+---
+ drivers/pinctrl/bcm/pinctrl-bcm2835.c | 51 ++++++++++++++++++++++++++---------
+ 1 file changed, 39 insertions(+), 12 deletions(-)
+
+--- a/drivers/pinctrl/bcm/pinctrl-bcm2835.c
++++ b/drivers/pinctrl/bcm/pinctrl-bcm2835.c
+@@ -47,6 +47,7 @@
+ #define MODULE_NAME "pinctrl-bcm2835"
+ #define BCM2835_NUM_GPIOS 54
+ #define BCM2835_NUM_BANKS 2
++#define BCM2835_NUM_IRQS  3
+ #define BCM2835_PIN_BITMAP_SZ \
+       DIV_ROUND_UP(BCM2835_NUM_GPIOS, sizeof(unsigned long) * 8)
+@@ -88,13 +89,13 @@ enum bcm2835_pinconf_pull {
+ struct bcm2835_gpio_irqdata {
+       struct bcm2835_pinctrl *pc;
+-      int bank;
++      int irqgroup;
+ };
+ struct bcm2835_pinctrl {
+       struct device *dev;
+       void __iomem *base;
+-      int irq[BCM2835_NUM_BANKS];
++      int irq[BCM2835_NUM_IRQS];
+       /* note: locking assumes each bank will have its own unsigned long */
+       unsigned long enabled_irq_map[BCM2835_NUM_BANKS];
+@@ -105,7 +106,7 @@ struct bcm2835_pinctrl {
+       struct gpio_chip gpio_chip;
+       struct pinctrl_gpio_range gpio_range;
+-      struct bcm2835_gpio_irqdata irq_data[BCM2835_NUM_BANKS];
++      struct bcm2835_gpio_irqdata irq_data[BCM2835_NUM_IRQS];
+       spinlock_t irq_lock[BCM2835_NUM_BANKS];
+ };
+@@ -391,17 +392,16 @@ static struct gpio_chip bcm2835_gpio_chi
+       .can_sleep = false,
+ };
+-static irqreturn_t bcm2835_gpio_irq_handler(int irq, void *dev_id)
++static int bcm2835_gpio_irq_handle_bank(struct bcm2835_pinctrl *pc,
++                                      unsigned int bank, u32 mask)
+ {
+-      struct bcm2835_gpio_irqdata *irqdata = dev_id;
+-      struct bcm2835_pinctrl *pc = irqdata->pc;
+-      int bank = irqdata->bank;
+       unsigned long events;
+       unsigned offset;
+       unsigned gpio;
+       unsigned int type;
+       events = bcm2835_gpio_rd(pc, GPEDS0 + bank * 4);
++      events &= mask;
+       events &= pc->enabled_irq_map[bank];
+       for_each_set_bit(offset, &events, 32) {
+               gpio = (32 * bank) + offset;
+@@ -409,7 +409,30 @@ static irqreturn_t bcm2835_gpio_irq_hand
+               generic_handle_irq(irq_linear_revmap(pc->irq_domain, gpio));
+       }
+-      return events ? IRQ_HANDLED : IRQ_NONE;
++
++      return (events != 0);
++}
++
++static irqreturn_t bcm2835_gpio_irq_handler(int irq, void *dev_id)
++{
++      struct bcm2835_gpio_irqdata *irqdata = dev_id;
++      struct bcm2835_pinctrl *pc = irqdata->pc;
++      int handled = 0;
++
++      switch (irqdata->irqgroup) {
++      case 0: /* IRQ0 covers GPIOs 0-27 */
++              handled = bcm2835_gpio_irq_handle_bank(pc, 0, 0x0fffffff);
++              break;
++      case 1: /* IRQ1 covers GPIOs 28-45 */
++              handled = bcm2835_gpio_irq_handle_bank(pc, 0, 0xf0000000) |
++                        bcm2835_gpio_irq_handle_bank(pc, 1, 0x00003fff);
++              break;
++      case 2: /* IRQ2 covers GPIOs 46-53 */
++              handled = bcm2835_gpio_irq_handle_bank(pc, 1, 0x003fc000);
++              break;
++      }
++
++      return handled ? IRQ_HANDLED : IRQ_NONE;
+ }
+ static inline void __bcm2835_gpio_irq_config(struct bcm2835_pinctrl *pc,
+@@ -998,8 +1021,6 @@ static int bcm2835_pinctrl_probe(struct
+       for (i = 0; i < BCM2835_NUM_BANKS; i++) {
+               unsigned long events;
+               unsigned offset;
+-              int len;
+-              char *name;
+               /* clear event detection flags */
+               bcm2835_gpio_wr(pc, GPREN0 + i * 4, 0);
+@@ -1014,10 +1035,15 @@ static int bcm2835_pinctrl_probe(struct
+               for_each_set_bit(offset, &events, 32)
+                       bcm2835_gpio_wr(pc, GPEDS0 + i * 4, BIT(offset));
++              spin_lock_init(&pc->irq_lock[i]);
++      }
++
++      for (i = 0; i < BCM2835_NUM_IRQS; i++) {
++              int len;
++              char *name;
+               pc->irq[i] = irq_of_parse_and_map(np, i);
+               pc->irq_data[i].pc = pc;
+-              pc->irq_data[i].bank = i;
+-              spin_lock_init(&pc->irq_lock[i]);
++              pc->irq_data[i].irqgroup = i;
+               len = strlen(dev_name(pc->dev)) + 16;
+               name = devm_kzalloc(pc->dev, len, GFP_KERNEL);
+@@ -1074,6 +1100,7 @@ static struct platform_driver bcm2835_pi
+       .remove = bcm2835_pinctrl_remove,
+       .driver = {
+               .name = MODULE_NAME,
++              .owner = THIS_MODULE,
+               .of_match_table = bcm2835_pinctrl_match,
+       },
+ };
diff --git a/target/linux/brcm2708/patches-4.9/0013-pinctrl-bcm2835-Only-request-the-interrupts-listed-i.patch b/target/linux/brcm2708/patches-4.9/0013-pinctrl-bcm2835-Only-request-the-interrupts-listed-i.patch
new file mode 100644 (file)
index 0000000..e16f89a
--- /dev/null
@@ -0,0 +1,27 @@
+From a5a46d240c25576b901f0afa76575c1ab4a1469a Mon Sep 17 00:00:00 2001
+From: Phil Elwell <phil@raspberrypi.org>
+Date: Thu, 26 Feb 2015 09:58:22 +0000
+Subject: [PATCH] pinctrl-bcm2835: Only request the interrupts listed in the
+ DTB
+
+Although the GPIO controller can generate three interrupts (four counting
+the common one), the device tree files currently only specify two. In the
+absence of the third, simply don't register that interrupt (as opposed to
+registering 0), which has the effect of making it impossible to generate
+interrupts for GPIOs 46-53 which, since they share pins with the SD card
+interface, is unlikely to be a problem.
+---
+ drivers/pinctrl/bcm/pinctrl-bcm2835.c | 2 ++
+ 1 file changed, 2 insertions(+)
+
+--- a/drivers/pinctrl/bcm/pinctrl-bcm2835.c
++++ b/drivers/pinctrl/bcm/pinctrl-bcm2835.c
+@@ -1042,6 +1042,8 @@ static int bcm2835_pinctrl_probe(struct
+               int len;
+               char *name;
+               pc->irq[i] = irq_of_parse_and_map(np, i);
++              if (pc->irq[i] == 0)
++                      break;
+               pc->irq_data[i].pc = pc;
+               pc->irq_data[i].irqgroup = i;
diff --git a/target/linux/brcm2708/patches-4.9/0014-pinctrl-bcm2835-Return-pins-to-inputs-when-freed.patch b/target/linux/brcm2708/patches-4.9/0014-pinctrl-bcm2835-Return-pins-to-inputs-when-freed.patch
new file mode 100644 (file)
index 0000000..bac0573
--- /dev/null
@@ -0,0 +1,41 @@
+From 403ea1795165839348e5953b80ec4da31b639f8e Mon Sep 17 00:00:00 2001
+From: Phil Elwell <phil@raspberrypi.org>
+Date: Fri, 6 May 2016 12:32:47 +0100
+Subject: [PATCH] pinctrl-bcm2835: Return pins to inputs when freed
+
+When dynamically unloading overlays, it is important that freed pins are
+restored to being inputs to prevent functions from being enabled in
+multiple places at once.
+
+Signed-off-by: Phil Elwell <phil@raspberrypi.org>
+---
+ drivers/pinctrl/bcm/pinctrl-bcm2835.c | 11 +++++++++++
+ 1 file changed, 11 insertions(+)
+
+--- a/drivers/pinctrl/bcm/pinctrl-bcm2835.c
++++ b/drivers/pinctrl/bcm/pinctrl-bcm2835.c
+@@ -844,6 +844,16 @@ static const struct pinctrl_ops bcm2835_
+       .dt_free_map = bcm2835_pctl_dt_free_map,
+ };
++static int bcm2835_pmx_free(struct pinctrl_dev *pctldev,
++              unsigned offset)
++{
++      struct bcm2835_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev);
++
++      /* disable by setting to GPIO_IN */
++      bcm2835_pinctrl_fsel_set(pc, offset, BCM2835_FSEL_GPIO_IN);
++      return 0;
++}
++
+ static int bcm2835_pmx_get_functions_count(struct pinctrl_dev *pctldev)
+ {
+       return BCM2835_FSEL_COUNT;
+@@ -903,6 +913,7 @@ static int bcm2835_pmx_gpio_set_directio
+ }
+ static const struct pinmux_ops bcm2835_pmx_ops = {
++      .free = bcm2835_pmx_free,
+       .get_functions_count = bcm2835_pmx_get_functions_count,
+       .get_function_name = bcm2835_pmx_get_function_name,
+       .get_function_groups = bcm2835_pmx_get_function_groups,
diff --git a/target/linux/brcm2708/patches-4.9/0015-spi-bcm2835-Support-pin-groups-other-than-7-11.patch b/target/linux/brcm2708/patches-4.9/0015-spi-bcm2835-Support-pin-groups-other-than-7-11.patch
new file mode 100644 (file)
index 0000000..9b8e869
--- /dev/null
@@ -0,0 +1,80 @@
+From d4a8fe93bffd4cab698a2630ee7125da93d55d8a Mon Sep 17 00:00:00 2001
+From: Phil Elwell <phil@raspberrypi.org>
+Date: Wed, 24 Jun 2015 14:10:44 +0100
+Subject: [PATCH] spi-bcm2835: Support pin groups other than 7-11
+
+The spi-bcm2835 driver automatically uses GPIO chip-selects due to
+some unreliability of the native ones. In doing so it chooses the
+same pins as the native chip-selects would use, but the existing
+code always uses pins 7 and 8, wherever the SPI function is mapped.
+
+Search the pinctrl group assigned to the driver for pins that
+correspond to native chip-selects, and use those for GPIO chip-
+selects.
+
+Signed-off-by: Phil Elwell <phil@raspberrypi.org>
+---
+ drivers/spi/spi-bcm2835.c | 45 +++++++++++++++++++++++++++++++++++++--------
+ 1 file changed, 37 insertions(+), 8 deletions(-)
+
+--- a/drivers/spi/spi-bcm2835.c
++++ b/drivers/spi/spi-bcm2835.c
+@@ -688,6 +688,8 @@ static int bcm2835_spi_setup(struct spi_
+ {
+       int err;
+       struct gpio_chip *chip;
++      struct device_node *pins;
++      u32 pingroup_index;
+       /*
+        * sanity checking the native-chipselects
+        */
+@@ -704,15 +706,42 @@ static int bcm2835_spi_setup(struct spi_
+                       "setup: only two native chip-selects are supported\n");
+               return -EINVAL;
+       }
+-      /* now translate native cs to GPIO */
+-      /* get the gpio chip for the base */
+-      chip = gpiochip_find("pinctrl-bcm2835", chip_match_name);
+-      if (!chip)
+-              return 0;
++      /* now translate native cs to GPIO */
++      /* first look for chip select pins in the devices pin groups */
++      for (pingroup_index = 0;
++           (pins = of_parse_phandle(spi->master->dev.of_node,
++                                   "pinctrl-0",
++                                    pingroup_index)) != 0;
++           pingroup_index++) {
++              u32 pin;
++              u32 pin_index;
++              for (pin_index = 0;
++                   of_property_read_u32_index(pins,
++                                              "brcm,pins",
++                                              pin_index,
++                                              &pin) == 0;
++                   pin_index++) {
++                      if (((spi->chip_select == 0) &&
++                           ((pin == 8) || (pin == 36) || (pin == 46))) ||
++                          ((spi->chip_select == 1) &&
++                           ((pin == 7) || (pin == 35)))) {
++                              spi->cs_gpio = pin;
++                              break;
++                      }
++              }
++              of_node_put(pins);
++      }
++      /* if that fails, assume GPIOs 7-11 are used */
++      if (!gpio_is_valid(spi->cs_gpio) ) {
++              /* get the gpio chip for the base */
++              chip = gpiochip_find("pinctrl-bcm2835", chip_match_name);
++              if (!chip)
++                      return 0;
+-      /* and calculate the real CS */
+-      spi->cs_gpio = chip->base + 8 - spi->chip_select;
++              /* and calculate the real CS */
++              spi->cs_gpio = chip->base + 8 - spi->chip_select;
++      }
+       /* and set up the "mode" and level */
+       dev_info(&spi->dev, "setting up native-CS%i as GPIO %i\n",
diff --git a/target/linux/brcm2708/patches-4.9/0016-spi-bcm2835-Disable-forced-software-CS.patch b/target/linux/brcm2708/patches-4.9/0016-spi-bcm2835-Disable-forced-software-CS.patch
new file mode 100644 (file)
index 0000000..3ec3537
--- /dev/null
@@ -0,0 +1,34 @@
+From fa79e1013557f418119bd9dd2c0cf4c51eb4c093 Mon Sep 17 00:00:00 2001
+From: Phil Elwell <phil@raspberrypi.org>
+Date: Fri, 1 Jul 2016 22:09:24 +0100
+Subject: [PATCH] spi-bcm2835: Disable forced software CS
+
+Select software CS in bcm2708_common.dtsi, and disable the automatic
+conversion in the driver to allow hardware CS to be re-enabled with an
+overlay.
+
+See: https://github.com/raspberrypi/linux/issues/1547
+
+Signed-off-by: Phil Elwell <phil@raspberrypi.org>
+---
+ drivers/spi/spi-bcm2835.c | 2 ++
+ 1 file changed, 2 insertions(+)
+
+--- a/drivers/spi/spi-bcm2835.c
++++ b/drivers/spi/spi-bcm2835.c
+@@ -707,6 +707,7 @@ static int bcm2835_spi_setup(struct spi_
+               return -EINVAL;
+       }
++#if 0
+       /* now translate native cs to GPIO */
+       /* first look for chip select pins in the devices pin groups */
+       for (pingroup_index = 0;
+@@ -756,6 +757,7 @@ static int bcm2835_spi_setup(struct spi_
+                       spi->chip_select, spi->cs_gpio, err);
+               return err;
+       }
++#endif
+       return 0;
+ }
diff --git a/target/linux/brcm2708/patches-4.9/0017-spi-bcm2835-Remove-unused-code.patch b/target/linux/brcm2708/patches-4.9/0017-spi-bcm2835-Remove-unused-code.patch
new file mode 100644 (file)
index 0000000..4143498
--- /dev/null
@@ -0,0 +1,88 @@
+From 85bb42acd1c5a045d372d187c26b77c6bf1b617a Mon Sep 17 00:00:00 2001
+From: Phil Elwell <phil@raspberrypi.org>
+Date: Tue, 8 Nov 2016 21:35:38 +0000
+Subject: [PATCH] spi-bcm2835: Remove unused code
+
+---
+ drivers/spi/spi-bcm2835.c | 61 -----------------------------------------------
+ 1 file changed, 61 deletions(-)
+
+--- a/drivers/spi/spi-bcm2835.c
++++ b/drivers/spi/spi-bcm2835.c
+@@ -679,17 +679,8 @@ static void bcm2835_spi_set_cs(struct sp
+       bcm2835_wr(bs, BCM2835_SPI_CS, cs);
+ }
+-static int chip_match_name(struct gpio_chip *chip, void *data)
+-{
+-      return !strcmp(chip->label, data);
+-}
+-
+ static int bcm2835_spi_setup(struct spi_device *spi)
+ {
+-      int err;
+-      struct gpio_chip *chip;
+-      struct device_node *pins;
+-      u32 pingroup_index;
+       /*
+        * sanity checking the native-chipselects
+        */
+@@ -707,58 +698,6 @@ static int bcm2835_spi_setup(struct spi_
+               return -EINVAL;
+       }
+-#if 0
+-      /* now translate native cs to GPIO */
+-      /* first look for chip select pins in the devices pin groups */
+-      for (pingroup_index = 0;
+-           (pins = of_parse_phandle(spi->master->dev.of_node,
+-                                   "pinctrl-0",
+-                                    pingroup_index)) != 0;
+-           pingroup_index++) {
+-              u32 pin;
+-              u32 pin_index;
+-              for (pin_index = 0;
+-                   of_property_read_u32_index(pins,
+-                                              "brcm,pins",
+-                                              pin_index,
+-                                              &pin) == 0;
+-                   pin_index++) {
+-                      if (((spi->chip_select == 0) &&
+-                           ((pin == 8) || (pin == 36) || (pin == 46))) ||
+-                          ((spi->chip_select == 1) &&
+-                           ((pin == 7) || (pin == 35)))) {
+-                              spi->cs_gpio = pin;
+-                              break;
+-                      }
+-              }
+-              of_node_put(pins);
+-      }
+-      /* if that fails, assume GPIOs 7-11 are used */
+-      if (!gpio_is_valid(spi->cs_gpio) ) {
+-              /* get the gpio chip for the base */
+-              chip = gpiochip_find("pinctrl-bcm2835", chip_match_name);
+-              if (!chip)
+-                      return 0;
+-
+-              /* and calculate the real CS */
+-              spi->cs_gpio = chip->base + 8 - spi->chip_select;
+-      }
+-
+-      /* and set up the "mode" and level */
+-      dev_info(&spi->dev, "setting up native-CS%i as GPIO %i\n",
+-               spi->chip_select, spi->cs_gpio);
+-
+-      /* set up GPIO as output and pull to the correct level */
+-      err = gpio_direction_output(spi->cs_gpio,
+-                                  (spi->mode & SPI_CS_HIGH) ? 0 : 1);
+-      if (err) {
+-              dev_err(&spi->dev,
+-                      "could not set CS%i gpio %i as output: %i",
+-                      spi->chip_select, spi->cs_gpio, err);
+-              return err;
+-      }
+-#endif
+-
+       return 0;
+ }
diff --git a/target/linux/brcm2708/patches-4.9/0018-ARM-bcm2835-Set-Serial-number-and-Revision.patch b/target/linux/brcm2708/patches-4.9/0018-ARM-bcm2835-Set-Serial-number-and-Revision.patch
new file mode 100644 (file)
index 0000000..1311ccb
--- /dev/null
@@ -0,0 +1,53 @@
+From c33ee72bce07fc83e4797ebea1bce97c0b301ba2 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= <noralf@tronnes.org>
+Date: Wed, 3 Jun 2015 12:26:13 +0200
+Subject: [PATCH] ARM: bcm2835: Set Serial number and Revision
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+The VideoCore bootloader passes in Serial number and
+Revision number through Device Tree. Make these available to
+userspace through /proc/cpuinfo.
+
+Mainline status:
+
+There is a commit in linux-next that standardize passing the serial
+number through Device Tree (string: /serial-number):
+ARM: 8355/1: arch: Show the serial number from devicetree in cpuinfo
+
+There was an attempt to do the same with the revision number, but it
+didn't get in:
+[PATCH v2 1/2] arm: devtree: Set system_rev from DT revision
+
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+---
+ arch/arm/mach-bcm/board_bcm2835.c | 10 ++++++++++
+ 1 file changed, 10 insertions(+)
+
+--- a/arch/arm/mach-bcm/board_bcm2835.c
++++ b/arch/arm/mach-bcm/board_bcm2835.c
+@@ -16,13 +16,23 @@
+ #include <linux/irqchip.h>
+ #include <linux/of_address.h>
+ #include <linux/clk/bcm2835.h>
++#include <asm/system_info.h>
+ #include <asm/mach/arch.h>
+ #include <asm/mach/map.h>
+ static void __init bcm2835_init(void)
+ {
++      struct device_node *np = of_find_node_by_path("/system");
++      u32 val;
++      u64 val64;
++
+       bcm2835_init_clocks();
++
++      if (!of_property_read_u32(np, "linux,revision", &val))
++              system_rev = val;
++      if (!of_property_read_u64(np, "linux,serial", &val64))
++              system_serial_low = val64;
+ }
+ static const char * const bcm2835_compat[] = {
diff --git a/target/linux/brcm2708/patches-4.9/0019-dmaengine-bcm2835-Load-driver-early-and-support-lega.patch b/target/linux/brcm2708/patches-4.9/0019-dmaengine-bcm2835-Load-driver-early-and-support-lega.patch
new file mode 100644 (file)
index 0000000..e3bde68
--- /dev/null
@@ -0,0 +1,100 @@
+From b4e0c1c3facd38ef5e615248c42dba90d2622257 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= <noralf@tronnes.org>
+Date: Sat, 3 Oct 2015 22:22:55 +0200
+Subject: [PATCH] dmaengine: bcm2835: Load driver early and support legacy API
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Load driver early since at least bcm2708_fb doesn't support deferred
+probing and even if it did, we don't want the video driver deferred.
+Support the legacy DMA API which is needed by bcm2708_fb.
+Don't mask out channel 2.
+
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+---
+ drivers/dma/Kconfig       |  2 +-
+ drivers/dma/bcm2835-dma.c | 26 +++++++++++++++++++++++++-
+ 2 files changed, 26 insertions(+), 2 deletions(-)
+
+--- a/drivers/dma/Kconfig
++++ b/drivers/dma/Kconfig
+@@ -108,7 +108,7 @@ config COH901318
+ config DMA_BCM2835
+       tristate "BCM2835 DMA engine support"
+-      depends on ARCH_BCM2835
++      depends on ARCH_BCM2835 || ARCH_BCM2708 || ARCH_BCM2709
+       select DMA_ENGINE
+       select DMA_VIRTUAL_CHANNELS
+--- a/drivers/dma/bcm2835-dma.c
++++ b/drivers/dma/bcm2835-dma.c
+@@ -37,6 +37,7 @@
+ #include <linux/interrupt.h>
+ #include <linux/list.h>
+ #include <linux/module.h>
++#include <linux/platform_data/dma-bcm2708.h>
+ #include <linux/platform_device.h>
+ #include <linux/slab.h>
+ #include <linux/io.h>
+@@ -48,6 +49,7 @@
+ #define BCM2835_DMA_MAX_DMA_CHAN_SUPPORTED 14
+ #define BCM2835_DMA_CHAN_NAME_SIZE 8
++#define BCM2835_DMA_BULK_MASK  BIT(0)
+ struct bcm2835_dmadev {
+       struct dma_device ddev;
+@@ -922,6 +924,9 @@ static int bcm2835_dma_probe(struct plat
+       base = devm_ioremap_resource(&pdev->dev, res);
+       if (IS_ERR(base))
+               return PTR_ERR(base);
++      rc = bcm_dmaman_probe(pdev, base, BCM2835_DMA_BULK_MASK);
++      if (rc)
++              dev_err(&pdev->dev, "Failed to initialize the legacy API\n");
+       od->base = base;
+@@ -959,6 +964,9 @@ static int bcm2835_dma_probe(struct plat
+               goto err_no_dma;
+       }
++      /* Channel 0 is used by the legacy API */
++      chans_available &= ~BCM2835_DMA_BULK_MASK;
++
+       /* get irqs for each channel that we support */
+       for (i = 0; i <= BCM2835_DMA_MAX_DMA_CHAN_SUPPORTED; i++) {
+               /* skip masked out channels */
+@@ -1033,6 +1041,7 @@ static int bcm2835_dma_remove(struct pla
+ {
+       struct bcm2835_dmadev *od = platform_get_drvdata(pdev);
++      bcm_dmaman_remove(pdev);
+       dma_async_device_unregister(&od->ddev);
+       bcm2835_dma_free(od);
+@@ -1048,7 +1057,22 @@ static struct platform_driver bcm2835_dm
+       },
+ };
+-module_platform_driver(bcm2835_dma_driver);
++static int bcm2835_dma_init(void)
++{
++      return platform_driver_register(&bcm2835_dma_driver);
++}
++
++static void bcm2835_dma_exit(void)
++{
++      platform_driver_unregister(&bcm2835_dma_driver);
++}
++
++/*
++ * Load after serial driver (arch_initcall) so we see the messages if it fails,
++ * but before drivers (module_init) that need a DMA channel.
++ */
++subsys_initcall(bcm2835_dma_init);
++module_exit(bcm2835_dma_exit);
+ MODULE_ALIAS("platform:bcm2835-dma");
+ MODULE_DESCRIPTION("BCM2835 DMA engine driver");
diff --git a/target/linux/brcm2708/patches-4.9/0020-firmware-Updated-mailbox-header.patch b/target/linux/brcm2708/patches-4.9/0020-firmware-Updated-mailbox-header.patch
new file mode 100644 (file)
index 0000000..deb271c
--- /dev/null
@@ -0,0 +1,63 @@
+From 05f9e93200ec5d5e27c8a93f69588180cddda924 Mon Sep 17 00:00:00 2001
+From: popcornmix <popcornmix@gmail.com>
+Date: Mon, 25 Jan 2016 17:25:12 +0000
+Subject: [PATCH] firmware: Updated mailbox header
+
+---
+ include/soc/bcm2835/raspberrypi-firmware.h | 11 +++++++++++
+ 1 file changed, 11 insertions(+)
+
+--- a/include/soc/bcm2835/raspberrypi-firmware.h
++++ b/include/soc/bcm2835/raspberrypi-firmware.h
+@@ -63,6 +63,7 @@ enum rpi_firmware_property_tag {
+       RPI_FIRMWARE_GET_MIN_VOLTAGE =                        0x00030008,
+       RPI_FIRMWARE_GET_TURBO =                              0x00030009,
+       RPI_FIRMWARE_GET_MAX_TEMPERATURE =                    0x0003000a,
++      RPI_FIRMWARE_GET_STC =                                0x0003000b,
+       RPI_FIRMWARE_ALLOCATE_MEMORY =                        0x0003000c,
+       RPI_FIRMWARE_LOCK_MEMORY =                            0x0003000d,
+       RPI_FIRMWARE_UNLOCK_MEMORY =                          0x0003000e,
+@@ -72,12 +73,15 @@ enum rpi_firmware_property_tag {
+       RPI_FIRMWARE_SET_ENABLE_QPU =                         0x00030012,
+       RPI_FIRMWARE_GET_DISPMANX_RESOURCE_MEM_HANDLE =       0x00030014,
+       RPI_FIRMWARE_GET_EDID_BLOCK =                         0x00030020,
++      RPI_FIRMWARE_GET_CUSTOMER_OTP =                       0x00030021,
+       RPI_FIRMWARE_GET_DOMAIN_STATE =                       0x00030030,
+       RPI_FIRMWARE_SET_CLOCK_STATE =                        0x00038001,
+       RPI_FIRMWARE_SET_CLOCK_RATE =                         0x00038002,
+       RPI_FIRMWARE_SET_VOLTAGE =                            0x00038003,
+       RPI_FIRMWARE_SET_TURBO =                              0x00038009,
++      RPI_FIRMWARE_SET_CUSTOMER_OTP =                       0x00038021,
+       RPI_FIRMWARE_SET_DOMAIN_STATE =                       0x00038030,
++      RPI_FIRMWARE_SET_SDHOST_CLOCK =                       0x00038042,
+       /* Dispmanx TAGS */
+       RPI_FIRMWARE_FRAMEBUFFER_ALLOCATE =                   0x00040001,
+@@ -91,6 +95,8 @@ enum rpi_firmware_property_tag {
+       RPI_FIRMWARE_FRAMEBUFFER_GET_VIRTUAL_OFFSET =         0x00040009,
+       RPI_FIRMWARE_FRAMEBUFFER_GET_OVERSCAN =               0x0004000a,
+       RPI_FIRMWARE_FRAMEBUFFER_GET_PALETTE =                0x0004000b,
++      RPI_FIRMWARE_FRAMEBUFFER_GET_TOUCHBUF =               0x0004000f,
++      RPI_FIRMWARE_FRAMEBUFFER_GET_GPIOVIRTBUF =            0x00040010,
+       RPI_FIRMWARE_FRAMEBUFFER_RELEASE =                    0x00048001,
+       RPI_FIRMWARE_FRAMEBUFFER_TEST_PHYSICAL_WIDTH_HEIGHT = 0x00044003,
+       RPI_FIRMWARE_FRAMEBUFFER_TEST_VIRTUAL_WIDTH_HEIGHT =  0x00044004,
+@@ -100,6 +106,7 @@ enum rpi_firmware_property_tag {
+       RPI_FIRMWARE_FRAMEBUFFER_TEST_VIRTUAL_OFFSET =        0x00044009,
+       RPI_FIRMWARE_FRAMEBUFFER_TEST_OVERSCAN =              0x0004400a,
+       RPI_FIRMWARE_FRAMEBUFFER_TEST_PALETTE =               0x0004400b,
++      RPI_FIRMWARE_FRAMEBUFFER_TEST_VSYNC =                 0x0004400e,
+       RPI_FIRMWARE_FRAMEBUFFER_SET_PHYSICAL_WIDTH_HEIGHT =  0x00048003,
+       RPI_FIRMWARE_FRAMEBUFFER_SET_VIRTUAL_WIDTH_HEIGHT =   0x00048004,
+       RPI_FIRMWARE_FRAMEBUFFER_SET_DEPTH =                  0x00048005,
+@@ -108,6 +115,10 @@ enum rpi_firmware_property_tag {
+       RPI_FIRMWARE_FRAMEBUFFER_SET_VIRTUAL_OFFSET =         0x00048009,
+       RPI_FIRMWARE_FRAMEBUFFER_SET_OVERSCAN =               0x0004800a,
+       RPI_FIRMWARE_FRAMEBUFFER_SET_PALETTE =                0x0004800b,
++      RPI_FIRMWARE_FRAMEBUFFER_SET_VSYNC =                  0x0004800e,
++      RPI_FIRMWARE_FRAMEBUFFER_SET_BACKLIGHT =              0x0004800f,
++
++      RPI_FIRMWARE_VCHIQ_INIT =                             0x00048010,
+       RPI_FIRMWARE_GET_COMMAND_LINE =                       0x00050001,
+       RPI_FIRMWARE_GET_DMA_CHANNELS =                       0x00060001,
diff --git a/target/linux/brcm2708/patches-4.9/0021-clk-bcm2835-Mark-GPIO-clocks-enabled-at-boot-as-crit.patch b/target/linux/brcm2708/patches-4.9/0021-clk-bcm2835-Mark-GPIO-clocks-enabled-at-boot-as-crit.patch
new file mode 100644 (file)
index 0000000..94862f5
--- /dev/null
@@ -0,0 +1,37 @@
+From c9cb54929b3466ed0da304563e22739477055d3b Mon Sep 17 00:00:00 2001
+From: Eric Anholt <eric@anholt.net>
+Date: Mon, 9 May 2016 17:28:18 -0700
+Subject: [PATCH] clk: bcm2835: Mark GPIO clocks enabled at boot as critical.
+
+These divide off of PLLD_PER and are used for the ethernet and wifi
+PHYs source PLLs.  Neither of them is currently represented by a phy
+device that would grab the clock for us.
+
+This keeps other drivers from killing the networking PHYs when they
+disable their own clocks and trigger PLLD_PER's refcount going to 0.
+
+v2: Skip marking as critical if they aren't on at boot.
+
+Signed-off-by: Eric Anholt <eric@anholt.net>
+---
+ drivers/clk/bcm/clk-bcm2835.c | 9 +++++++++
+ 1 file changed, 9 insertions(+)
+
+--- a/drivers/clk/bcm/clk-bcm2835.c
++++ b/drivers/clk/bcm/clk-bcm2835.c
+@@ -1262,6 +1262,15 @@ static struct clk_hw *bcm2835_register_c
+       init.name = data->name;
+       init.flags = data->flags | CLK_IGNORE_UNUSED;
++      /*
++       * Some GPIO clocks for ethernet/wifi PLLs are marked as
++       * critical (since some platforms use them), but if the
++       * firmware didn't have them turned on then they clearly
++       * aren't actually critical.
++       */
++      if ((cprman_read(cprman, data->ctl_reg) & CM_ENABLE) == 0)
++              init.flags &= ~CLK_IS_CRITICAL;
++
+       if (data->is_vpu_clock) {
+               init.ops = &bcm2835_vpu_clock_clk_ops;
+       } else {
diff --git a/target/linux/brcm2708/patches-4.9/0022-rtc-Add-SPI-alias-for-pcf2123-driver.patch b/target/linux/brcm2708/patches-4.9/0022-rtc-Add-SPI-alias-for-pcf2123-driver.patch
new file mode 100644 (file)
index 0000000..8c197fc
--- /dev/null
@@ -0,0 +1,20 @@
+From 6c8399fb8dcc815aa9d6b4488a519785912ea983 Mon Sep 17 00:00:00 2001
+From: Phil Elwell <phil@raspberrypi.org>
+Date: Wed, 15 Jun 2016 16:48:41 +0100
+Subject: [PATCH] rtc: Add SPI alias for pcf2123 driver
+
+Without this alias, Device Tree won't cause the driver
+to be loaded.
+
+See: https://github.com/raspberrypi/linux/pull/1510
+---
+ drivers/rtc/rtc-pcf2123.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+--- a/drivers/rtc/rtc-pcf2123.c
++++ b/drivers/rtc/rtc-pcf2123.c
+@@ -472,3 +472,4 @@ module_spi_driver(pcf2123_driver);
+ MODULE_AUTHOR("Chris Verges <chrisv@cyberswitching.com>");
+ MODULE_DESCRIPTION("NXP PCF2123 RTC driver");
+ MODULE_LICENSE("GPL");
++MODULE_ALIAS("spi:rtc-pcf2123");
diff --git a/target/linux/brcm2708/patches-4.9/0023-watchdog-bcm2835-Support-setting-reboot-partition.patch b/target/linux/brcm2708/patches-4.9/0023-watchdog-bcm2835-Support-setting-reboot-partition.patch
new file mode 100644 (file)
index 0000000..160c576
--- /dev/null
@@ -0,0 +1,124 @@
+From 259f169ef05f12bc7fed007befc11ed6c66dd9c8 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= <noralf@tronnes.org>
+Date: Fri, 7 Oct 2016 16:50:59 +0200
+Subject: [PATCH] watchdog: bcm2835: Support setting reboot partition
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+The Raspberry Pi firmware looks at the RSTS register to know which
+partition to boot from. The reboot syscall command
+LINUX_REBOOT_CMD_RESTART2 supports passing in a string argument.
+
+Add support for passing in a partition number 0..63 to boot from.
+Partition 63 is a special partiton indicating halt.
+If the partition doesn't exist, the firmware falls back to partition 0.
+
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+---
+ drivers/watchdog/bcm2835_wdt.c | 61 +++++++++++++++++++++++++-----------------
+ 1 file changed, 36 insertions(+), 25 deletions(-)
+
+--- a/drivers/watchdog/bcm2835_wdt.c
++++ b/drivers/watchdog/bcm2835_wdt.c
+@@ -35,13 +35,7 @@
+ #define PM_RSTC_WRCFG_SET             0x00000030
+ #define PM_RSTC_WRCFG_FULL_RESET      0x00000020
+ #define PM_RSTC_RESET                 0x00000102
+-
+-/*
+- * The Raspberry Pi firmware uses the RSTS register to know which partiton
+- * to boot from. The partiton value is spread into bits 0, 2, 4, 6, 8, 10.
+- * Partiton 63 is a special partition used by the firmware to indicate halt.
+- */
+-#define PM_RSTS_RASPBERRYPI_HALT      0x555
++#define PM_RSTS_PARTITION_CLR         0xfffffaaa
+ #define SECS_TO_WDOG_TICKS(x) ((x) << 16)
+ #define WDOG_TICKS_TO_SECS(x) ((x) >> 16)
+@@ -111,15 +105,28 @@ static struct watchdog_device bcm2835_wd
+       .timeout =      WDOG_TICKS_TO_SECS(PM_WDOG_TIME_SET),
+ };
+-static int
+-bcm2835_restart(struct notifier_block *this, unsigned long mode, void *cmd)
++/*
++ * The Raspberry Pi firmware uses the RSTS register to know which partiton
++ * to boot from. The partiton value is spread into bits 0, 2, 4, 6, 8, 10.
++ * Partiton 63 is a special partition used by the firmware to indicate halt.
++ */
++
++static void bcm2835_restart(struct bcm2835_wdt *wdt, u8 partition)
+ {
+-      struct bcm2835_wdt *wdt = container_of(this, struct bcm2835_wdt,
+-                                             restart_handler);
+-      u32 val;
++      u32 val, rsts;
++
++      rsts = (partition & BIT(0)) | ((partition & BIT(1)) << 1) |
++             ((partition & BIT(2)) << 2) | ((partition & BIT(3)) << 3) |
++             ((partition & BIT(4)) << 4) | ((partition & BIT(5)) << 5);
++
++      val = readl_relaxed(wdt->base + PM_RSTS);
++      val &= PM_RSTS_PARTITION_CLR;
++      val |= PM_PASSWORD | rsts;
++      writel_relaxed(val, wdt->base + PM_RSTS);
+       /* use a timeout of 10 ticks (~150us) */
+       writel_relaxed(10 | PM_PASSWORD, wdt->base + PM_WDOG);
++
+       val = readl_relaxed(wdt->base + PM_RSTC);
+       val &= PM_RSTC_WRCFG_CLR;
+       val |= PM_PASSWORD | PM_RSTC_WRCFG_FULL_RESET;
+@@ -127,6 +134,20 @@ bcm2835_restart(struct notifier_block *t
+       /* No sleeping, possibly atomic. */
+       mdelay(1);
++}
++
++static int bcm2835_restart_notifier_call(struct notifier_block *this,
++                                       unsigned long mode, void *cmd)
++{
++      struct bcm2835_wdt *wdt = container_of(this, struct bcm2835_wdt,
++                                             restart_handler);
++      unsigned long long val;
++      u8 partition = 0;
++
++      if (cmd && !kstrtoull(cmd, 0, &val) && val <= 63)
++              partition = val;
++
++      bcm2835_restart(wdt, partition);
+       return 0;
+ }
+@@ -142,19 +163,9 @@ static void bcm2835_power_off(void)
+               of_find_compatible_node(NULL, NULL, "brcm,bcm2835-pm-wdt");
+       struct platform_device *pdev = of_find_device_by_node(np);
+       struct bcm2835_wdt *wdt = platform_get_drvdata(pdev);
+-      u32 val;
+-
+-      /*
+-       * We set the watchdog hard reset bit here to distinguish this reset
+-       * from the normal (full) reset. bootcode.bin will not reboot after a
+-       * hard reset.
+-       */
+-      val = readl_relaxed(wdt->base + PM_RSTS);
+-      val |= PM_PASSWORD | PM_RSTS_RASPBERRYPI_HALT;
+-      writel_relaxed(val, wdt->base + PM_RSTS);
+-      /* Continue with normal reset mechanism */
+-      bcm2835_restart(&wdt->restart_handler, REBOOT_HARD, NULL);
++      /* Partition 63 tells the firmware that this is a halt */
++      bcm2835_restart(wdt, 63);
+ }
+ static int bcm2835_wdt_probe(struct platform_device *pdev)
+@@ -188,7 +199,7 @@ static int bcm2835_wdt_probe(struct plat
+               return err;
+       }
+-      wdt->restart_handler.notifier_call = bcm2835_restart;
++      wdt->restart_handler.notifier_call = bcm2835_restart_notifier_call;
+       wdt->restart_handler.priority = 128;
+       register_restart_handler(&wdt->restart_handler);
+       if (pm_power_off == NULL)
diff --git a/target/linux/brcm2708/patches-4.9/0024-reboot-Use-power-off-rather-than-busy-spinning-when-.patch b/target/linux/brcm2708/patches-4.9/0024-reboot-Use-power-off-rather-than-busy-spinning-when-.patch
new file mode 100644 (file)
index 0000000..dee1fed
--- /dev/null
@@ -0,0 +1,23 @@
+From 79d93260c98e0164ca89c9f7c767528d7a3aaeae Mon Sep 17 00:00:00 2001
+From: popcornmix <popcornmix@gmail.com>
+Date: Tue, 5 Apr 2016 19:40:12 +0100
+Subject: [PATCH] reboot: Use power off rather than busy spinning when halt is
+ requested
+
+---
+ arch/arm/kernel/reboot.c | 4 +---
+ 1 file changed, 1 insertion(+), 3 deletions(-)
+
+--- a/arch/arm/kernel/reboot.c
++++ b/arch/arm/kernel/reboot.c
+@@ -102,9 +102,7 @@ void machine_shutdown(void)
+  */
+ void machine_halt(void)
+ {
+-      local_irq_disable();
+-      smp_send_stop();
+-      while (1);
++      machine_power_off();
+ }
+ /*
diff --git a/target/linux/brcm2708/patches-4.9/0025-bcm-Make-RASPBERRYPI_POWER-depend-on-PM.patch b/target/linux/brcm2708/patches-4.9/0025-bcm-Make-RASPBERRYPI_POWER-depend-on-PM.patch
new file mode 100644 (file)
index 0000000..120f25d
--- /dev/null
@@ -0,0 +1,19 @@
+From 9799ea4ba8ae1e6c586a3dd728ad75f68830e93f Mon Sep 17 00:00:00 2001
+From: popcornmix <popcornmix@gmail.com>
+Date: Wed, 9 Nov 2016 13:02:52 +0000
+Subject: [PATCH] bcm: Make RASPBERRYPI_POWER depend on PM
+
+---
+ drivers/soc/bcm/Kconfig | 1 +
+ 1 file changed, 1 insertion(+)
+
+--- a/drivers/soc/bcm/Kconfig
++++ b/drivers/soc/bcm/Kconfig
+@@ -4,6 +4,7 @@ config RASPBERRYPI_POWER
+       bool "Raspberry Pi power domain driver"
+       depends on ARCH_BCM2835 || (COMPILE_TEST && OF)
+       depends on RASPBERRYPI_FIRMWARE=y
++      depends on PM
+       select PM_GENERIC_DOMAINS if PM
+       help
+         This enables support for the RPi power domains which can be enabled
diff --git a/target/linux/brcm2708/patches-4.9/0026-Register-the-clocks-early-during-the-boot-process.patch b/target/linux/brcm2708/patches-4.9/0026-Register-the-clocks-early-during-the-boot-process.patch
new file mode 100644 (file)
index 0000000..d4f4fec
--- /dev/null
@@ -0,0 +1,45 @@
+From 261269cc41f6b77f7264f0e44f9b9da5cc36de00 Mon Sep 17 00:00:00 2001
+From: Martin Sperl <kernel@martin.sperl.org>
+Date: Fri, 2 Sep 2016 16:45:27 +0100
+Subject: [PATCH] Register the clocks early during the boot process, so that
+ special/critical clocks can get enabled early on in the boot process avoiding
+ the risk of disabling a clock, pll_divider or pll when a claiming driver
+ fails to install propperly - maybe it needs to defer.
+
+Signed-off-by: Martin Sperl <kernel@martin.sperl.org>
+---
+ drivers/clk/bcm/clk-bcm2835.c | 15 +++++++++++++--
+ 1 file changed, 13 insertions(+), 2 deletions(-)
+
+--- a/drivers/clk/bcm/clk-bcm2835.c
++++ b/drivers/clk/bcm/clk-bcm2835.c
+@@ -1903,8 +1903,15 @@ static int bcm2835_clk_probe(struct plat
+       if (ret)
+               return ret;
+-      return of_clk_add_hw_provider(dev->of_node, of_clk_hw_onecell_get,
++      ret = of_clk_add_hw_provider(dev->of_node, of_clk_hw_onecell_get,
+                                     &cprman->onecell);
++      if (ret)
++              return ret;
++
++      /* note that we have registered all the clocks */
++      dev_dbg(dev, "registered %d clocks\n", asize);
++
++      return 0;
+ }
+ static const struct of_device_id bcm2835_clk_of_match[] = {
+@@ -1921,7 +1928,11 @@ static struct platform_driver bcm2835_cl
+       .probe          = bcm2835_clk_probe,
+ };
+-builtin_platform_driver(bcm2835_clk_driver);
++static int __init __bcm2835_clk_driver_init(void)
++{
++      return platform_driver_register(&bcm2835_clk_driver);
++}
++core_initcall(__bcm2835_clk_driver_init);
+ MODULE_AUTHOR("Eric Anholt <eric@anholt.net>");
+ MODULE_DESCRIPTION("BCM2835 clock driver");
diff --git a/target/linux/brcm2708/patches-4.9/0027-bcm2835-rng-Avoid-initialising-if-already-enabled.patch b/target/linux/brcm2708/patches-4.9/0027-bcm2835-rng-Avoid-initialising-if-already-enabled.patch
new file mode 100644 (file)
index 0000000..1fb2184
--- /dev/null
@@ -0,0 +1,26 @@
+From a195976d635c3672cae684d6338655aa25f6d98c Mon Sep 17 00:00:00 2001
+From: popcornmix <popcornmix@gmail.com>
+Date: Tue, 6 Dec 2016 17:05:39 +0000
+Subject: [PATCH] bcm2835-rng: Avoid initialising if already enabled
+
+Avoids the 0x40000 cycles of warmup again if firmware has already used it
+---
+ drivers/char/hw_random/bcm2835-rng.c | 7 ++++---
+ 1 file changed, 4 insertions(+), 3 deletions(-)
+
+--- a/drivers/char/hw_random/bcm2835-rng.c
++++ b/drivers/char/hw_random/bcm2835-rng.c
+@@ -102,9 +102,10 @@ static int bcm2835_rng_probe(struct plat
+               rng_setup(rng_base);
+       /* set warm-up count & enable */
+-      __raw_writel(RNG_WARMUP_COUNT, rng_base + RNG_STATUS);
+-      __raw_writel(RNG_RBGEN, rng_base + RNG_CTRL);
+-
++      if (!(__raw_readl(rng_base + RNG_CTRL) & RNG_RBGEN)) {
++              __raw_writel(RNG_WARMUP_COUNT, rng_base + RNG_STATUS);
++              __raw_writel(RNG_RBGEN, rng_base + RNG_CTRL);
++      }
+       /* register driver */
+       err = hwrng_register(&bcm2835_rng_ops);
+       if (err) {
diff --git a/target/linux/brcm2708/patches-4.9/0028-kbuild-Ignore-dtco-targets-when-filtering-symbols.patch b/target/linux/brcm2708/patches-4.9/0028-kbuild-Ignore-dtco-targets-when-filtering-symbols.patch
new file mode 100644 (file)
index 0000000..16d32cc
--- /dev/null
@@ -0,0 +1,20 @@
+From 6c52812a34fa4ab0d40b57fef10d23fe2fb0768b Mon Sep 17 00:00:00 2001
+From: Phil Elwell <phil@raspberrypi.org>
+Date: Wed, 24 Aug 2016 16:28:44 +0100
+Subject: [PATCH] kbuild: Ignore dtco targets when filtering symbols
+
+---
+ scripts/Kbuild.include | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+--- a/scripts/Kbuild.include
++++ b/scripts/Kbuild.include
+@@ -284,7 +284,7 @@ ksym_dep_filter =
+           $(CPP) $(call flags_nodeps,c_flags) -D__KSYM_DEPS__ $< ;;        \
+         as_*_S|cpp_s_S)                                                    \
+           $(CPP) $(call flags_nodeps,a_flags) -D__KSYM_DEPS__ $< ;;        \
+-        boot*|build*|*cpp_lds_S|dtc|host*|vdso*) : ;;                      \
++        boot*|build*|*cpp_lds_S|dtc*|host*|vdso*) : ;;                     \
+         *) echo "Don't know how to preprocess $(1)" >&2; false ;;          \
+       esac | tr ";" "\n" | sed -rn 's/^.*=== __KSYM_(.*) ===.*$$/KSYM_\1/p'
diff --git a/target/linux/brcm2708/patches-4.9/0029-BCM2835_DT-Fix-I2S-register-map.patch b/target/linux/brcm2708/patches-4.9/0029-BCM2835_DT-Fix-I2S-register-map.patch
new file mode 100644 (file)
index 0000000..4eecc14
--- /dev/null
@@ -0,0 +1,36 @@
+From 8ee6fd93aa3328d325524b8503714e3b4839d1b9 Mon Sep 17 00:00:00 2001
+From: Robert Tiemann <rtie@gmx.de>
+Date: Mon, 20 Jul 2015 11:01:25 +0200
+Subject: [PATCH] BCM2835_DT: Fix I2S register map
+
+---
+ Documentation/devicetree/bindings/dma/brcm,bcm2835-dma.txt   | 4 ++--
+ Documentation/devicetree/bindings/sound/brcm,bcm2835-i2s.txt | 4 ++--
+ 2 files changed, 4 insertions(+), 4 deletions(-)
+
+--- a/Documentation/devicetree/bindings/dma/brcm,bcm2835-dma.txt
++++ b/Documentation/devicetree/bindings/dma/brcm,bcm2835-dma.txt
+@@ -74,8 +74,8 @@ Example:
+ bcm2835_i2s: i2s@7e203000 {
+       compatible = "brcm,bcm2835-i2s";
+-      reg = < 0x7e203000 0x20>,
+-            < 0x7e101098 0x02>;
++      reg = < 0x7e203000 0x24>,
++            < 0x7e101098 0x08>;
+       dmas = <&dma 2>,
+              <&dma 3>;
+--- a/Documentation/devicetree/bindings/sound/brcm,bcm2835-i2s.txt
++++ b/Documentation/devicetree/bindings/sound/brcm,bcm2835-i2s.txt
+@@ -16,8 +16,8 @@ Example:
+ bcm2835_i2s: i2s@7e203000 {
+       compatible = "brcm,bcm2835-i2s";
+-      reg = <0x7e203000 0x20>,
+-            <0x7e101098 0x02>;
++      reg = <0x7e203000 0x24>,
++            <0x7e101098 0x08>;
+       dmas = <&dma 2>,
+              <&dma 3>;
diff --git a/target/linux/brcm2708/patches-4.9/0030-Main-bcm2708-bcm2709-linux-port.patch b/target/linux/brcm2708/patches-4.9/0030-Main-bcm2708-bcm2709-linux-port.patch
new file mode 100644 (file)
index 0000000..81d48b7
--- /dev/null
@@ -0,0 +1,199 @@
+From 28a1aeb6b49ffdf5cb5ba9e326df962c270c1f34 Mon Sep 17 00:00:00 2001
+From: popcornmix <popcornmix@gmail.com>
+Date: Sun, 12 May 2013 12:24:19 +0100
+Subject: [PATCH] Main bcm2708/bcm2709 linux port
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Signed-off-by: popcornmix <popcornmix@gmail.com>
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+
+bcm2709: Drop platform smp and timer init code
+
+irq-bcm2836 handles this through these functions:
+bcm2835_init_local_timer_frequency()
+bcm2836_arm_irqchip_smp_init()
+
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+
+bcm270x: Use watchdog for reboot/poweroff
+
+The watchdog driver already has support for reboot/poweroff.
+Make use of this and remove the code from the platform files.
+
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+---
+ arch/arm/mach-bcm/Kconfig         |  1 +
+ arch/arm/mach-bcm/board_bcm2835.c | 17 +++++++++++++++++
+ arch/arm/mm/proc-v6.S             | 15 ++++++++++++---
+ drivers/irqchip/irq-bcm2835.c     |  7 ++++++-
+ drivers/mailbox/bcm2835-mailbox.c | 18 ++++++++++++++++--
+ 5 files changed, 52 insertions(+), 6 deletions(-)
+
+--- a/arch/arm/mach-bcm/Kconfig
++++ b/arch/arm/mach-bcm/Kconfig
+@@ -155,6 +155,7 @@ config ARCH_BCM2835
+       select FIQ
+       select PINCTRL
+       select PINCTRL_BCM2835
++      select MFD_SYSCON if ARCH_MULTI_V7
+       help
+         This enables support for the Broadcom BCM2835 and BCM2836 SoCs.
+         This SoC is used in the Raspberry Pi and Roku 2 devices.
+--- a/arch/arm/mach-bcm/board_bcm2835.c
++++ b/arch/arm/mach-bcm/board_bcm2835.c
+@@ -16,17 +16,21 @@
+ #include <linux/irqchip.h>
+ #include <linux/of_address.h>
+ #include <linux/clk/bcm2835.h>
++#include <linux/broadcom/vc_cma.h>
+ #include <asm/system_info.h>
+ #include <asm/mach/arch.h>
+ #include <asm/mach/map.h>
++#include <linux/dma-mapping.h>
++
+ static void __init bcm2835_init(void)
+ {
+       struct device_node *np = of_find_node_by_path("/system");
+       u32 val;
+       u64 val64;
++      vc_cma_early_init();
+       bcm2835_init_clocks();
+       if (!of_property_read_u32(np, "linux,revision", &val))
+@@ -35,6 +39,17 @@ static void __init bcm2835_init(void)
+               system_serial_low = val64;
+ }
++static void __init bcm2835_init_early(void)
++{
++      /* dwc_otg needs this for bounce buffers on non-aligned transfers */
++      init_dma_coherent_pool_size(SZ_1M);
++}
++
++static void __init bcm2835_board_reserve(void)
++{
++      vc_cma_reserve();
++}
++
+ static const char * const bcm2835_compat[] = {
+ #ifdef CONFIG_ARCH_MULTI_V6
+       "brcm,bcm2835",
+@@ -47,5 +62,7 @@ static const char * const bcm2835_compat
+ DT_MACHINE_START(BCM2835, "BCM2835")
+       .init_machine = bcm2835_init,
++      .reserve = bcm2835_board_reserve,
++      .init_early = bcm2835_init_early,
+       .dt_compat = bcm2835_compat
+ MACHINE_END
+--- a/arch/arm/mm/proc-v6.S
++++ b/arch/arm/mm/proc-v6.S
+@@ -73,10 +73,19 @@ ENDPROC(cpu_v6_reset)
+  *
+  *    IRQs are already disabled.
+  */
++
++/* See jira SW-5991 for details of this workaround */
+ ENTRY(cpu_v6_do_idle)
+-      mov     r1, #0
+-      mcr     p15, 0, r1, c7, c10, 4          @ DWB - WFI may enter a low-power mode
+-      mcr     p15, 0, r1, c7, c0, 4           @ wait for interrupt
++      .align 5
++      mov     r1, #2
++1:    subs    r1, #1
++      nop
++      mcreq   p15, 0, r1, c7, c10, 4          @ DWB - WFI may enter a low-power mode
++      mcreq   p15, 0, r1, c7, c0, 4           @ wait for interrupt
++      nop
++      nop
++      nop
++      bne 1b
+       ret     lr
+ ENTRY(cpu_v6_dcache_clean_area)
+--- a/drivers/irqchip/irq-bcm2835.c
++++ b/drivers/irqchip/irq-bcm2835.c
+@@ -54,7 +54,9 @@
+ #include <linux/regmap.h>
+ #include <asm/exception.h>
++#ifndef CONFIG_ARM64
+ #include <asm/mach/irq.h>
++#endif
+ /* Put the bank and irq (32 bits) into the hwirq */
+ #define MAKE_HWIRQ(b, n)      (((b) << 5) | (n))
+@@ -82,6 +84,7 @@
+ #define NR_BANKS              3
+ #define IRQS_PER_BANK         32
+ #define NUMBER_IRQS           MAKE_HWIRQ(NR_BANKS, 0)
++#undef FIQ_START
+ #define FIQ_START             (NR_IRQS_BANK0 + MAKE_HWIRQ(NR_BANKS - 1, 0))
+ static const int reg_pending[] __initconst = { 0x00, 0x04, 0x08 };
+@@ -256,10 +259,12 @@ static int __init armctrl_of_init(struct
+                                       MAKE_HWIRQ(b, i) + NUMBER_IRQS);
+                       BUG_ON(irq <= 0);
+                       irq_set_chip(irq, &armctrl_chip);
+-                      set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
++                      irq_set_probe(irq);
+               }
+       }
++#ifndef CONFIG_ARM64
+       init_FIQ(FIQ_START);
++#endif
+       return 0;
+ }
+--- a/drivers/mailbox/bcm2835-mailbox.c
++++ b/drivers/mailbox/bcm2835-mailbox.c
+@@ -51,12 +51,15 @@
+ #define MAIL1_WRT     (ARM_0_MAIL1 + 0x00)
+ #define MAIL1_STA     (ARM_0_MAIL1 + 0x18)
++/* On ARCH_BCM270x these come through <linux/interrupt.h> (arm_control.h ) */
++#ifndef ARM_MS_FULL
+ /* Status register: FIFO state. */
+ #define ARM_MS_FULL           BIT(31)
+ #define ARM_MS_EMPTY          BIT(30)
+ /* Configuration register: Enable interrupts. */
+ #define ARM_MC_IHAVEDATAIRQEN BIT(0)
++#endif
+ struct bcm2835_mbox {
+       void __iomem *regs;
+@@ -151,7 +154,7 @@ static int bcm2835_mbox_probe(struct pla
+               return -ENOMEM;
+       spin_lock_init(&mbox->lock);
+-      ret = devm_request_irq(dev, irq_of_parse_and_map(dev->of_node, 0),
++      ret = devm_request_irq(dev, platform_get_irq(pdev, 0),
+                              bcm2835_mbox_irq, 0, dev_name(dev), mbox);
+       if (ret) {
+               dev_err(dev, "Failed to register a mailbox IRQ handler: %d\n",
+@@ -209,7 +212,18 @@ static struct platform_driver bcm2835_mb
+       .probe          = bcm2835_mbox_probe,
+       .remove         = bcm2835_mbox_remove,
+ };
+-module_platform_driver(bcm2835_mbox_driver);
++
++static int __init bcm2835_mbox_init(void)
++{
++      return platform_driver_register(&bcm2835_mbox_driver);
++}
++arch_initcall(bcm2835_mbox_init);
++
++static void __init bcm2835_mbox_exit(void)
++{
++      platform_driver_unregister(&bcm2835_mbox_driver);
++}
++module_exit(bcm2835_mbox_exit);
+ MODULE_AUTHOR("Lubomir Rintel <lkundrak@v3.sk>");
+ MODULE_DESCRIPTION("BCM2835 mailbox IPC driver");
diff --git a/target/linux/brcm2708/patches-4.9/0031-Add-dwc_otg-driver.patch b/target/linux/brcm2708/patches-4.9/0031-Add-dwc_otg-driver.patch
new file mode 100644 (file)
index 0000000..971581a
--- /dev/null
@@ -0,0 +1,60858 @@
+From 4c7d2ae77def863967cbc6e73597d92fe0fb24e7 Mon Sep 17 00:00:00 2001
+From: popcornmix <popcornmix@gmail.com>
+Date: Wed, 1 May 2013 19:46:17 +0100
+Subject: [PATCH] Add dwc_otg driver
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Signed-off-by: popcornmix <popcornmix@gmail.com>
+
+usb: dwc: fix lockdep false positive
+
+Signed-off-by: Kari Suvanto <karis79@gmail.com>
+
+usb: dwc: fix inconsistent lock state
+
+Signed-off-by: Kari Suvanto <karis79@gmail.com>
+
+Add FIQ patch to dwc_otg driver. Enable with dwc_otg.fiq_fix_enable=1. Should give about 10% more ARM performance.
+Thanks to Gordon and Costas
+
+Avoid dynamic memory allocation for channel lock in USB driver. Thanks ddv2005.
+
+Add NAK holdoff scheme. Enabled by default, disable with dwc_otg.nak_holdoff_enable=0. Thanks gsh
+
+Make sure we wait for the reset to finish
+
+dwc_otg: fix bug in dwc_otg_hcd.c resulting in silent kernel
+        memory corruption, escalating to OOPS under high USB load.
+
+dwc_otg: Fix unsafe access of QTD during URB enqueue
+
+In dwc_otg_hcd_urb_enqueue during qtd creation, it was possible that the
+transaction could complete almost immediately after the qtd was assigned
+to a host channel during URB enqueue, which meant the qtd pointer was no
+longer valid having been completed and removed. Usually, this resulted in
+an OOPS during URB submission. By predetermining whether transactions
+need to be queued or not, this unsafe pointer access is avoided.
+
+This bug was only evident on the Pi model A where a device was attached
+that had no periodic endpoints (e.g. USB pendrive or some wlan devices).
+
+dwc_otg: Fix incorrect URB allocation error handling
+
+If the memory allocation for a dwc_otg_urb failed, the kernel would OOPS
+because for some reason a member of the *unallocated* struct was set to
+zero. Error handling changed to fail correctly.
+
+dwc_otg: fix potential use-after-free case in interrupt handler
+
+If a transaction had previously aborted, certain interrupts are
+enabled to track error counts and reset where necessary. On IN
+endpoints the host generates an ACK interrupt near-simultaneously
+with completion of transfer. In the case where this transfer had
+previously had an error, this results in a use-after-free on
+the QTD memory space with a 1-byte length being overwritten to
+0x00.
+
+dwc_otg: add handling of SPLIT transaction data toggle errors
+
+Previously a data toggle error on packets from a USB1.1 device behind
+a TT would result in the Pi locking up as the driver never handled
+the associated interrupt. Patch adds basic retry mechanism and
+interrupt acknowledgement to cater for either a chance toggle error or
+for devices that have a broken initial toggle state (FT8U232/FT232BM).
+
+dwc_otg: implement tasklet for returning URBs to usbcore hcd layer
+
+The dwc_otg driver interrupt handler for transfer completion will spend
+a very long time with interrupts disabled when a URB is completed -
+this is because usb_hcd_giveback_urb is called from within the handler
+which for a USB device driver with complicated processing (e.g. webcam)
+will take an exorbitant amount of time to complete. This results in
+missed completion interrupts for other USB packets which lead to them
+being dropped due to microframe overruns.
+
+This patch splits returning the URB to the usb hcd layer into a
+high-priority tasklet. This will have most benefit for isochronous IN
+transfers but will also have incidental benefit where multiple periodic
+devices are active at once.
+
+dwc_otg: fix NAK holdoff and allow on split transactions only
+
+This corrects a bug where if a single active non-periodic endpoint
+had at least one transaction in its qh, on frnum == MAX_FRNUM the qh
+would get skipped and never get queued again. This would result in
+a silent device until error detection (automatic or otherwise) would
+either reset the device or flush and requeue the URBs.
+
+Additionally the NAK holdoff was enabled for all transactions - this
+would potentially stall a HS endpoint for 1ms if a previous error state
+enabled this interrupt and the next response was a NAK. Fix so that
+only split transactions get held off.
+
+dwc_otg: Call usb_hcd_unlink_urb_from_ep with lock held in completion handler
+
+usb_hcd_unlink_urb_from_ep must be called with the HCD lock held.  Calling it
+asynchronously in the tasklet was not safe (regression in
+c4564d4a1a0a9b10d4419e48239f5d99e88d2667).
+
+This change unlinks it from the endpoint prior to queueing it for handling in
+the tasklet, and also adds a check to ensure the urb is OK to be unlinked
+before doing so.
+
+NULL pointer dereference kernel oopses had been observed in usb_hcd_giveback_urb
+when a USB device was unplugged/replugged during data transfer.  This effect
+was reproduced using automated USB port power control, hundreds of replug
+events were performed during active transfers to confirm that the problem was
+eliminated.
+
+USB fix using a FIQ to implement split transactions
+
+This commit adds a FIQ implementaion that schedules
+the split transactions using a FIQ so we don't get
+held off by the interrupt latency of Linux
+
+dwc_otg: fix device attributes and avoid kernel warnings on boot
+
+dcw_otg: avoid logging function that can cause panics
+
+See: https://github.com/raspberrypi/firmware/issues/21
+Thanks to cleverca22 for fix
+
+dwc_otg: mask correct interrupts after transaction error recovery
+
+The dwc_otg driver will unmask certain interrupts on a transaction
+that previously halted in the error state in order to reset the
+QTD error count. The various fine-grained interrupt handlers do not
+consider that other interrupts besides themselves were unmasked.
+
+By disabling the two other interrupts only ever enabled in DMA mode
+for this purpose, we can avoid unnecessary function calls in the
+IRQ handler. This will also prevent an unneccesary FIQ interrupt
+from being generated if the FIQ is enabled.
+
+dwc_otg: fiq: prevent FIQ thrash and incorrect state passing to IRQ
+
+In the case of a transaction to a device that had previously aborted
+due to an error, several interrupts are enabled to reset the error
+count when a device responds. This has the side-effect of making the
+FIQ thrash because the hardware will generate multiple instances of
+a NAK on an IN bulk/interrupt endpoint and multiple instances of ACK
+on an OUT bulk/interrupt endpoint. Make the FIQ mask and clear the
+associated interrupts.
+
+Additionally, on non-split transactions make sure that only unmasked
+interrupts are cleared. This caused a hard-to-trigger but serious
+race condition when you had the combination of an endpoint awaiting
+error recovery and a transaction completed on an endpoint - due to
+the sequencing and timing of interrupts generated by the dwc_otg core,
+it was possible to confuse the IRQ handler.
+
+Fix function tracing
+
+dwc_otg: whitespace cleanup in dwc_otg_urb_enqueue
+
+dwc_otg: prevent OOPSes during device disconnects
+
+The dwc_otg_urb_enqueue function is thread-unsafe. In particular the
+access of urb->hcpriv, usb_hcd_link_urb_to_ep, dwc_otg_urb->qtd and
+friends does not occur within a critical section and so if a device
+was unplugged during activity there was a high chance that the
+usbcore hub_thread would try to disable the endpoint with partially-
+formed entries in the URB queue. This would result in BUG() or null
+pointer dereferences.
+
+Fix so that access of urb->hcpriv, enqueuing to the hardware and
+adding to usbcore endpoint URB lists is contained within a single
+critical section.
+
+dwc_otg: prevent BUG() in TT allocation if hub address is > 16
+
+A fixed-size array is used to track TT allocation. This was
+previously set to 16 which caused a crash because
+dwc_otg_hcd_allocate_port would read past the end of the array.
+
+This was hit if a hub was plugged in which enumerated as addr > 16,
+due to previous device resets or unplugs.
+
+Also add #ifdef FIQ_DEBUG around hcd->hub_port_alloc[], which grows
+to a large size if 128 hub addresses are supported. This field is
+for debug only for tracking which frame an allocate happened in.
+
+dwc_otg: make channel halts with unknown state less damaging
+
+If the IRQ received a channel halt interrupt through the FIQ
+with no other bits set, the IRQ would not release the host
+channel and never complete the URB.
+
+Add catchall handling to treat as a transaction error and retry.
+
+dwc_otg: fiq_split: use TTs with more granularity
+
+This fixes certain issues with split transaction scheduling.
+
+- Isochronous multi-packet OUT transactions now hog the TT until
+  they are completed - this prevents hubs aborting transactions
+  if they get a periodic start-split out-of-order
+- Don't perform TT allocation on non-periodic endpoints - this
+  allows simultaneous use of the TT's bulk/control and periodic
+  transaction buffers
+
+This commit will mainly affect USB audio playback.
+
+dwc_otg: fix potential sleep while atomic during urb enqueue
+
+Fixes a regression introduced with eb1b482a. Kmalloc called from
+dwc_otg_hcd_qtd_add / dwc_otg_hcd_qtd_create did not always have
+the GPF_ATOMIC flag set. Force this flag when inside the larger
+critical section.
+
+dwc_otg: make fiq_split_enable imply fiq_fix_enable
+
+Failing to set up the FIQ correctly would result in
+"IRQ 32: nobody cared" errors in dmesg.
+
+dwc_otg: prevent crashes on host port disconnects
+
+Fix several issues resulting in crashes or inconsistent state
+if a Model A root port was disconnected.
+
+- Clean up queue heads properly in kill_urbs_in_qh_list by
+  removing the empty QHs from the schedule lists
+- Set the halt status properly to prevent IRQ handlers from
+  using freed memory
+- Add fiq_split related cleanup for saved registers
+- Make microframe scheduling reclaim host channels if
+  active during a disconnect
+- Abort URBs with -ESHUTDOWN status response, informing
+  device drivers so they respond in a more correct fashion
+  and don't try to resubmit URBs
+- Prevent IRQ handlers from attempting to handle channel
+  interrupts if the associated URB was dequeued (and the
+  driver state was cleared)
+
+dwc_otg: prevent leaking URBs during enqueue
+
+A dwc_otg_urb would get leaked if the HCD enqueue function
+failed for any reason. Free the URB at the appropriate points.
+
+dwc_otg: Enable NAK holdoff for control split transactions
+
+Certain low-speed devices take a very long time to complete a
+data or status stage of a control transaction, producing NAK
+responses until they complete internal processing - the USB2.0
+spec limit is up to 500mS. This causes the same type of interrupt
+storm as seen with USB-serial dongles prior to c8edb238.
+
+In certain circumstances, usually while booting, this interrupt
+storm could cause SD card timeouts.
+
+dwc_otg: Fix for occasional lockup on boot when doing a USB reset
+
+dwc_otg: Don't issue traffic to LS devices in FS mode
+
+Issuing low-speed packets when the root port is in full-speed mode
+causes the root port to stop responding. Explicitly fail when
+enqueuing URBs to a LS endpoint on a FS bus.
+
+Fix ARM architecture issue with local_irq_restore()
+
+If local_fiq_enable() is called before a local_irq_restore(flags) where
+the flags variable has the F bit set, the FIQ will be erroneously disabled.
+
+Fixup arch_local_irq_restore to avoid trampling the F bit in CPSR.
+
+Also fix some of the hacks previously implemented for previous dwc_otg
+incarnations.
+
+dwc_otg: fiq_fsm: Base commit for driver rewrite
+
+This commit removes the previous FIQ fixes entirely and adds fiq_fsm.
+
+This rewrite features much more complete support for split transactions
+and takes into account several OTG hardware bugs. High-speed
+isochronous transactions are also capable of being performed by fiq_fsm.
+
+All driver options have been removed and replaced with:
+  - dwc_otg.fiq_enable (bool)
+  - dwc_otg.fiq_fsm_enable (bool)
+  - dwc_otg.fiq_fsm_mask (bitmask)
+  - dwc_otg.nak_holdoff (unsigned int)
+
+Defaults are specified such that fiq_fsm behaves similarly to the
+previously implemented FIQ fixes.
+
+fiq_fsm: Push error recovery into the FIQ when fiq_fsm is used
+
+If the transfer associated with a QTD failed due to a bus error, the HCD
+would retry the transfer up to 3 times (implementing the USB2.0
+three-strikes retry in software).
+
+Due to the masking mechanism used by fiq_fsm, it is only possible to pass
+a single interrupt through to the HCD per-transfer.
+
+In this instance host channels would fall off the radar because the error
+reset would function, but the subsequent channel halt would be lost.
+
+Push the error count reset into the FIQ handler.
+
+fiq_fsm: Implement timeout mechanism
+
+For full-speed endpoints with a large packet size, interrupt latency
+runs the risk of the FIQ starting a transaction too late in a full-speed
+frame. If the device is still transmitting data when EOF2 for the
+downstream frame occurs, the hub will disable the port. This change is
+not reflected in the hub status endpoint and the device becomes
+unresponsive.
+
+Prevent high-bandwidth transactions from being started too late in a
+frame. The mechanism is not guaranteed: a combination of bit stuffing
+and hub latency may still result in a device overrunning.
+
+fiq_fsm: fix bounce buffer utilisation for Isochronous OUT
+
+Multi-packet isochronous OUT transactions were subject to a few bounday
+bugs. Fix them.
+
+Audio playback is now much more robust: however, an issue stands with
+devices that have adaptive sinks - ALSA plays samples too fast.
+
+dwc_otg: Return full-speed frame numbers in HS mode
+
+The frame counter increments on every *microframe* in high-speed mode.
+Most device drivers expect this number to be in full-speed frames - this
+caused considerable confusion to e.g. snd_usb_audio which uses the
+frame counter to estimate the number of samples played.
+
+fiq_fsm: save PID on completion of interrupt OUT transfers
+
+Also add edge case handling for interrupt transports.
+
+Note that for periodic split IN, data toggles are unimplemented in the
+OTG host hardware - it unconditionally accepts any PID.
+
+fiq_fsm: add missing case for fiq_fsm_tt_in_use()
+
+Certain combinations of bitrate and endpoint activity could
+result in a periodic transaction erroneously getting started
+while the previous Isochronous OUT was still active.
+
+fiq_fsm: clear hcintmsk for aborted transactions
+
+Prevents the FIQ from erroneously handling interrupts
+on a timed out channel.
+
+fiq_fsm: enable by default
+
+fiq_fsm: fix dequeues for non-periodic split transactions
+
+If a dequeue happened between the SSPLIT and CSPLIT phases of the
+transaction, the HCD would never receive an interrupt.
+
+fiq_fsm: Disable by default
+
+fiq_fsm: Handle HC babble errors
+
+The HCTSIZ transfer size field raises a babble interrupt if
+the counter wraps. Handle the resulting interrupt in this case.
+
+dwc_otg: fix interrupt registration for fiq_enable=0
+
+Additionally make the module parameter conditional for wherever
+hcd->fiq_state is touched.
+
+fiq_fsm: Enable by default
+
+dwc_otg: Fix various issues with root port and transaction errors
+
+Process the host port interrupts correctly (and don't trample them).
+Root port hotplug now functional again.
+
+Fix a few thinkos with the transaction error passthrough for fiq_fsm.
+
+fiq_fsm: Implement hack for Split Interrupt transactions
+
+Hubs aren't too picky about which endpoint we send Control type split
+transactions to. By treating Interrupt transfers as Control, it is
+possible to use the non-periodic queue in the OTG core as well as the
+non-periodic FIFOs in the hub itself. This massively reduces the
+microframe exclusivity/contention that periodic split transactions
+otherwise have to enforce.
+
+It goes without saying that this is a fairly egregious USB specification
+violation, but it works.
+
+Original idea by Hans Petter Selasky @ FreeBSD.org.
+
+dwc_otg: FIQ support on SMP. Set up FIQ stack and handler on Core 0 only.
+
+dwc_otg: introduce fiq_fsm_spin(un|)lock()
+
+SMP safety for the FIQ relies on register read-modify write cycles being
+completed in the correct order. Several places in the DWC code modify
+registers also touched by the FIQ. Protect these by a bare-bones lock
+mechanism.
+
+This also makes it possible to run the FIQ and IRQ handlers on different
+cores.
+
+fiq_fsm: fix build on bcm2708 and bcm2709 platforms
+
+dwc_otg: put some barriers back where they should be for UP
+
+bcm2709/dwc_otg: Setup FIQ on core 1 if >1 core active
+
+dwc_otg: fixup read-modify-write in critical paths
+
+Be more careful about read-modify-write on registers that the FIQ
+also touches.
+
+Guard fiq_fsm_spin_lock with fiq_enable check
+
+fiq_fsm: Falling out of the state machine isn't fatal
+
+This edge case can be hit if the port is disabled while the FIQ is
+in the middle of a transaction. Make the effects less severe.
+
+Also get rid of the useless return value.
+
+squash: dwc_otg: Allow to build without SMP
+
+usb: core: make overcurrent messages more prominent
+
+Hub overcurrent messages are more serious than "debug". Increase loglevel.
+
+usb: dwc_otg: Don't use dma_to_virt()
+
+Commit 6ce0d20 changes dma_to_virt() which breaks this driver.
+Open code the old dma_to_virt() implementation to work around this.
+
+Limit the use of __bus_to_virt() to cases where transfer_buffer_length
+is set and transfer_buffer is not set. This is done to increase the
+chance that this driver will also work on ARCH_BCM2835.
+
+transfer_buffer should not be NULL if the length is set, but the
+comment in the code indicates that there are situations where this
+might happen. drivers/usb/isp1760/isp1760-hcd.c also has a similar
+comment pointing to a possible: 'usb storage / SCSI bug'.
+
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+
+dwc_otg: Fix crash when fiq_enable=0
+
+dwc_otg: fiq_fsm: Make high-speed isochronous strided transfers work properly
+
+Certain low-bandwidth high-speed USB devices (specialist audio devices,
+compressed-frame webcams) have packet intervals > 1 microframe.
+
+Stride these transfers in the FIQ by using the start-of-frame interrupt
+to restart the channel at the right time.
+
+dwc_otg: Force host mode to fix incorrect compute module boards
+
+dwc_otg: Add ARCH_BCM2835 support
+
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+
+dwc_otg: Simplify FIQ irq number code
+
+Dropping ATAGS means we can simplify the FIQ irq number code.
+Also add error checking on the returned irq number.
+
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+
+dwc_otg: Remove duplicate gadget probe/unregister function
+
+dwc_otg: Properly set the HFIR
+
+Douglas Anderson reported:
+
+According to the most up to date version of the dwc2 databook, the FRINT
+field of the HFIR register should be programmed to:
+* 125 us * (PHY clock freq for HS) - 1
+* 1000 us * (PHY clock freq for FS/LS) - 1
+
+This is opposed to older versions of the doc that claimed it should be:
+* 125 us * (PHY clock freq for HS)
+* 1000 us * (PHY clock freq for FS/LS)
+
+and reported lower timing jitter on a USB analyser
+
+dcw_otg: trim xfer length when buffer larger than allocated size is received
+
+dwc_otg: Don't free qh align buffers in atomic context
+
+dwc_otg: Enable the hack for Split Interrupt transactions by default
+
+dwc_otg.fiq_fsm_mask=0xF has long been a suggestion for users with audio stutters or other USB bandwidth issues.
+So far we are aware of many success stories but no failure caused by this setting.
+Make it a default to learn more.
+
+See: https://www.raspberrypi.org/forums/viewtopic.php?f=28&t=70437
+
+Signed-off-by: popcornmix <popcornmix@gmail.com>
+
+dwc_otg: Use kzalloc when suitable
+
+dwc_otg: Pass struct device to dma_alloc*()
+
+This makes it possible to get the bus address from Device Tree.
+
+Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
+---
+ arch/arm/include/asm/irqflags.h                    |   16 +-
+ arch/arm/kernel/fiqasm.S                           |    4 +
+ drivers/usb/Makefile                               |    1 +
+ drivers/usb/core/generic.c                         |    1 +
+ drivers/usb/core/hub.c                             |    2 +-
+ drivers/usb/core/message.c                         |   79 +
+ drivers/usb/core/otg_whitelist.h                   |  114 +-
+ drivers/usb/gadget/file_storage.c                  | 3676 ++++++++++
+ drivers/usb/host/Kconfig                           |   13 +
+ drivers/usb/host/Makefile                          |    2 +
+ drivers/usb/host/dwc_common_port/Makefile          |   58 +
+ drivers/usb/host/dwc_common_port/Makefile.fbsd     |   17 +
+ drivers/usb/host/dwc_common_port/Makefile.linux    |   49 +
+ drivers/usb/host/dwc_common_port/changes.txt       |  174 +
+ drivers/usb/host/dwc_common_port/doc/doxygen.cfg   |  270 +
+ drivers/usb/host/dwc_common_port/dwc_cc.c          |  532 ++
+ drivers/usb/host/dwc_common_port/dwc_cc.h          |  224 +
+ drivers/usb/host/dwc_common_port/dwc_common_fbsd.c | 1308 ++++
+ .../usb/host/dwc_common_port/dwc_common_linux.c    | 1418 ++++
+ drivers/usb/host/dwc_common_port/dwc_common_nbsd.c | 1275 ++++
+ drivers/usb/host/dwc_common_port/dwc_crypto.c      |  308 +
+ drivers/usb/host/dwc_common_port/dwc_crypto.h      |  111 +
+ drivers/usb/host/dwc_common_port/dwc_dh.c          |  291 +
+ drivers/usb/host/dwc_common_port/dwc_dh.h          |  106 +
+ drivers/usb/host/dwc_common_port/dwc_list.h        |  594 ++
+ drivers/usb/host/dwc_common_port/dwc_mem.c         |  245 +
+ drivers/usb/host/dwc_common_port/dwc_modpow.c      |  636 ++
+ drivers/usb/host/dwc_common_port/dwc_modpow.h      |   34 +
+ drivers/usb/host/dwc_common_port/dwc_notifier.c    |  319 +
+ drivers/usb/host/dwc_common_port/dwc_notifier.h    |  122 +
+ drivers/usb/host/dwc_common_port/dwc_os.h          | 1276 ++++
+ drivers/usb/host/dwc_common_port/usb.h             |  946 +++
+ drivers/usb/host/dwc_otg/Makefile                  |   82 +
+ drivers/usb/host/dwc_otg/doc/doxygen.cfg           |  224 +
+ drivers/usb/host/dwc_otg/dummy_audio.c             | 1574 +++++
+ drivers/usb/host/dwc_otg/dwc_cfi_common.h          |  142 +
+ drivers/usb/host/dwc_otg/dwc_otg_adp.c             |  854 +++
+ drivers/usb/host/dwc_otg/dwc_otg_adp.h             |   80 +
+ drivers/usb/host/dwc_otg/dwc_otg_attr.c            | 1210 ++++
+ drivers/usb/host/dwc_otg/dwc_otg_attr.h            |   89 +
+ drivers/usb/host/dwc_otg/dwc_otg_cfi.c             | 1876 +++++
+ drivers/usb/host/dwc_otg/dwc_otg_cfi.h             |  320 +
+ drivers/usb/host/dwc_otg/dwc_otg_cil.c             | 7141 ++++++++++++++++++++
+ drivers/usb/host/dwc_otg/dwc_otg_cil.h             | 1464 ++++
+ drivers/usb/host/dwc_otg/dwc_otg_cil_intr.c        | 1594 +++++
+ drivers/usb/host/dwc_otg/dwc_otg_core_if.h         |  705 ++
+ drivers/usb/host/dwc_otg/dwc_otg_dbg.h             |  117 +
+ drivers/usb/host/dwc_otg/dwc_otg_driver.c          | 1757 +++++
+ drivers/usb/host/dwc_otg/dwc_otg_driver.h          |   86 +
+ drivers/usb/host/dwc_otg/dwc_otg_fiq_fsm.c         | 1355 ++++
+ drivers/usb/host/dwc_otg/dwc_otg_fiq_fsm.h         |  370 +
+ drivers/usb/host/dwc_otg/dwc_otg_fiq_stub.S        |   80 +
+ drivers/usb/host/dwc_otg/dwc_otg_hcd.c             | 4260 ++++++++++++
+ drivers/usb/host/dwc_otg/dwc_otg_hcd.h             |  868 +++
+ drivers/usb/host/dwc_otg/dwc_otg_hcd_ddma.c        | 1139 ++++
+ drivers/usb/host/dwc_otg/dwc_otg_hcd_if.h          |  417 ++
+ drivers/usb/host/dwc_otg/dwc_otg_hcd_intr.c        | 2727 ++++++++
+ drivers/usb/host/dwc_otg/dwc_otg_hcd_linux.c       | 1005 +++
+ drivers/usb/host/dwc_otg/dwc_otg_hcd_queue.c       |  963 +++
+ drivers/usb/host/dwc_otg/dwc_otg_os_dep.h          |  188 +
+ drivers/usb/host/dwc_otg/dwc_otg_pcd.c             | 2725 ++++++++
+ drivers/usb/host/dwc_otg/dwc_otg_pcd.h             |  273 +
+ drivers/usb/host/dwc_otg/dwc_otg_pcd_if.h          |  361 +
+ drivers/usb/host/dwc_otg/dwc_otg_pcd_intr.c        | 5148 ++++++++++++++
+ drivers/usb/host/dwc_otg/dwc_otg_pcd_linux.c       | 1280 ++++
+ drivers/usb/host/dwc_otg/dwc_otg_regs.h            | 2550 +++++++
+ drivers/usb/host/dwc_otg/test/Makefile             |   16 +
+ drivers/usb/host/dwc_otg/test/dwc_otg_test.pm      |  337 +
+ drivers/usb/host/dwc_otg/test/test_mod_param.pl    |  133 +
+ drivers/usb/host/dwc_otg/test/test_sysfs.pl        |  193 +
+ 70 files changed, 59908 insertions(+), 16 deletions(-)
+ create mode 100644 drivers/usb/gadget/file_storage.c
+ create mode 100644 drivers/usb/host/dwc_common_port/Makefile
+ create mode 100644 drivers/usb/host/dwc_common_port/Makefile.fbsd
+ create mode 100644 drivers/usb/host/dwc_common_port/Makefile.linux
+ create mode 100644 drivers/usb/host/dwc_common_port/changes.txt
+ create mode 100644 drivers/usb/host/dwc_common_port/doc/doxygen.cfg
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_cc.c
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_cc.h
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_common_fbsd.c
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_common_linux.c
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_common_nbsd.c
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_crypto.c
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_crypto.h
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_dh.c
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_dh.h
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_list.h
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_mem.c
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_modpow.c
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_modpow.h
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_notifier.c
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_notifier.h
+ create mode 100644 drivers/usb/host/dwc_common_port/dwc_os.h
+ create mode 100644 drivers/usb/host/dwc_common_port/usb.h
+ create mode 100644 drivers/usb/host/dwc_otg/Makefile
+ create mode 100644 drivers/usb/host/dwc_otg/doc/doxygen.cfg
+ create mode 100644 drivers/usb/host/dwc_otg/dummy_audio.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_cfi_common.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_adp.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_adp.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_attr.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_attr.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_cfi.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_cfi.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_cil.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_cil.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_cil_intr.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_core_if.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_dbg.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_driver.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_driver.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_fiq_fsm.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_fiq_fsm.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_fiq_stub.S
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_hcd.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_hcd.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_hcd_ddma.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_hcd_if.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_hcd_intr.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_hcd_linux.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_hcd_queue.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_os_dep.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_pcd.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_pcd.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_pcd_if.h
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_pcd_intr.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_pcd_linux.c
+ create mode 100644 drivers/usb/host/dwc_otg/dwc_otg_regs.h
+ create mode 100644 drivers/usb/host/dwc_otg/test/Makefile
+ create mode 100644 drivers/usb/host/dwc_otg/test/dwc_otg_test.pm
+ create mode 100644 drivers/usb/host/dwc_otg/test/test_mod_param.pl
+ create mode 100644 drivers/usb/host/dwc_otg/test/test_sysfs.pl
+
+--- a/arch/arm/include/asm/irqflags.h
++++ b/arch/arm/include/asm/irqflags.h
+@@ -162,13 +162,23 @@ static inline unsigned long arch_local_s
+ }
+ /*
+- * restore saved IRQ & FIQ state
++ * restore saved IRQ state
+  */
+ #define arch_local_irq_restore arch_local_irq_restore
+ static inline void arch_local_irq_restore(unsigned long flags)
+ {
+-      asm volatile(
+-              "       msr     " IRQMASK_REG_NAME_W ", %0      @ local_irq_restore"
++      unsigned long temp = 0;
++      flags &= ~(1 << 6);
++      asm volatile (
++              " mrs %0, cpsr"
++              : "=r" (temp)
++              :
++              : "memory", "cc");
++              /* Preserve FIQ bit */
++              temp &= (1 << 6);
++              flags = flags | temp;
++      asm volatile (
++              "    msr    cpsr_c, %0    @ local_irq_restore"
+               :
+               : "r" (flags)
+               : "memory", "cc");
+--- a/arch/arm/kernel/fiqasm.S
++++ b/arch/arm/kernel/fiqasm.S
+@@ -47,3 +47,7 @@ ENTRY(__get_fiq_regs)
+       mov     r0, r0          @ avoid hazard prior to ARMv4
+       ret     lr
+ ENDPROC(__get_fiq_regs)
++
++ENTRY(__FIQ_Branch)
++      mov pc, r8
++ENDPROC(__FIQ_Branch)
+--- a/drivers/usb/Makefile
++++ b/drivers/usb/Makefile
+@@ -7,6 +7,7 @@
+ obj-$(CONFIG_USB)             += core/
+ obj-$(CONFIG_USB_SUPPORT)     += phy/
++obj-$(CONFIG_USB_DWCOTG)      += host/
+ obj-$(CONFIG_USB_DWC3)                += dwc3/
+ obj-$(CONFIG_USB_DWC2)                += dwc2/
+ obj-$(CONFIG_USB_ISP1760)     += isp1760/
+--- a/drivers/usb/core/generic.c
++++ b/drivers/usb/core/generic.c
+@@ -152,6 +152,7 @@ int usb_choose_configuration(struct usb_
+               dev_warn(&udev->dev,
+                       "no configuration chosen from %d choice%s\n",
+                       num_configs, plural(num_configs));
++              dev_warn(&udev->dev, "No support over %dmA\n", udev->bus_mA);
+       }
+       return i;
+ }
+--- a/drivers/usb/core/hub.c
++++ b/drivers/usb/core/hub.c
+@@ -5009,7 +5009,7 @@ static void port_event(struct usb_hub *h
+       if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
+               u16 status = 0, unused;
+-              dev_dbg(&port_dev->dev, "over-current change\n");
++              dev_notice(&port_dev->dev, "over-current change\n");
+               usb_clear_port_feature(hdev, port1,
+                               USB_PORT_FEAT_C_OVER_CURRENT);
+               msleep(100);    /* Cool down */
+--- a/drivers/usb/core/message.c
++++ b/drivers/usb/core/message.c
+@@ -1908,6 +1908,85 @@ free_interfaces:
+       if (cp->string == NULL &&
+                       !(dev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
+               cp->string = usb_cache_string(dev, cp->desc.iConfiguration);
++/* Uncomment this define to enable the HS Electrical Test support */
++#define DWC_HS_ELECT_TST 1
++#ifdef DWC_HS_ELECT_TST
++              /* Here we implement the HS Electrical Test support. The
++               * tester uses a vendor ID of 0x1A0A to indicate we should
++               * run a special test sequence. The product ID tells us
++               * which sequence to run. We invoke the test sequence by
++               * sending a non-standard SetFeature command to our root
++               * hub port. Our dwc_otg_hcd_hub_control() routine will
++               * recognize the command and perform the desired test
++               * sequence.
++               */
++              if (dev->descriptor.idVendor == 0x1A0A) {
++                      /* HSOTG Electrical Test */
++                      dev_warn(&dev->dev, "VID from HSOTG Electrical Test Fixture\n");
++
++                      if (dev->bus && dev->bus->root_hub) {
++                              struct usb_device *hdev = dev->bus->root_hub;
++                              dev_warn(&dev->dev, "Got PID 0x%x\n", dev->descriptor.idProduct);
++
++                              switch (dev->descriptor.idProduct) {
++                              case 0x0101:    /* TEST_SE0_NAK */
++                                      dev_warn(&dev->dev, "TEST_SE0_NAK\n");
++                                      usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
++                                                      USB_REQ_SET_FEATURE, USB_RT_PORT,
++                                                      USB_PORT_FEAT_TEST, 0x300, NULL, 0, HZ);
++                                      break;
++
++                              case 0x0102:    /* TEST_J */
++                                      dev_warn(&dev->dev, "TEST_J\n");
++                                      usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
++                                                      USB_REQ_SET_FEATURE, USB_RT_PORT,
++                                                      USB_PORT_FEAT_TEST, 0x100, NULL, 0, HZ);
++                                      break;
++
++                              case 0x0103:    /* TEST_K */
++                                      dev_warn(&dev->dev, "TEST_K\n");
++                                      usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
++                                                      USB_REQ_SET_FEATURE, USB_RT_PORT,
++                                                      USB_PORT_FEAT_TEST, 0x200, NULL, 0, HZ);
++                                      break;
++
++                              case 0x0104:    /* TEST_PACKET */
++                                      dev_warn(&dev->dev, "TEST_PACKET\n");
++                                      usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
++                                                      USB_REQ_SET_FEATURE, USB_RT_PORT,
++                                                      USB_PORT_FEAT_TEST, 0x400, NULL, 0, HZ);
++                                      break;
++
++                              case 0x0105:    /* TEST_FORCE_ENABLE */
++                                      dev_warn(&dev->dev, "TEST_FORCE_ENABLE\n");
++                                      usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
++                                                      USB_REQ_SET_FEATURE, USB_RT_PORT,
++                                                      USB_PORT_FEAT_TEST, 0x500, NULL, 0, HZ);
++                                      break;
++
++                              case 0x0106:    /* HS_HOST_PORT_SUSPEND_RESUME */
++                                      dev_warn(&dev->dev, "HS_HOST_PORT_SUSPEND_RESUME\n");
++                                      usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
++                                                      USB_REQ_SET_FEATURE, USB_RT_PORT,
++                                                      USB_PORT_FEAT_TEST, 0x600, NULL, 0, 40 * HZ);
++                                      break;
++
++                              case 0x0107:    /* SINGLE_STEP_GET_DEVICE_DESCRIPTOR setup */
++                                      dev_warn(&dev->dev, "SINGLE_STEP_GET_DEVICE_DESCRIPTOR setup\n");
++                                      usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
++                                                      USB_REQ_SET_FEATURE, USB_RT_PORT,
++                                                      USB_PORT_FEAT_TEST, 0x700, NULL, 0, 40 * HZ);
++                                      break;
++
++                              case 0x0108:    /* SINGLE_STEP_GET_DEVICE_DESCRIPTOR execute */
++                                      dev_warn(&dev->dev, "SINGLE_STEP_GET_DEVICE_DESCRIPTOR execute\n");
++                                      usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
++                                                      USB_REQ_SET_FEATURE, USB_RT_PORT,
++                                                      USB_PORT_FEAT_TEST, 0x800, NULL, 0, 40 * HZ);
++                              }
++                      }
++              }
++#endif /* DWC_HS_ELECT_TST */
+       /* Now that the interfaces are installed, re-enable LPM. */
+       usb_unlocked_enable_lpm(dev);
+--- a/drivers/usb/core/otg_whitelist.h
++++ b/drivers/usb/core/otg_whitelist.h
+@@ -19,33 +19,82 @@
+ static struct usb_device_id whitelist_table[] = {
+ /* hubs are optional in OTG, but very handy ... */
++#define CERT_WITHOUT_HUBS
++#if defined(CERT_WITHOUT_HUBS)
++{ USB_DEVICE( 0x0000, 0x0000 ), }, /* Root HUB Only*/
++#else
+ { USB_DEVICE_INFO(USB_CLASS_HUB, 0, 0), },
+ { USB_DEVICE_INFO(USB_CLASS_HUB, 0, 1), },
++{ USB_DEVICE_INFO(USB_CLASS_HUB, 0, 2), },
++#endif
+ #ifdef        CONFIG_USB_PRINTER              /* ignoring nonstatic linkage! */
+ /* FIXME actually, printers are NOT supposed to use device classes;
+  * they're supposed to use interface classes...
+  */
+-{ USB_DEVICE_INFO(7, 1, 1) },
+-{ USB_DEVICE_INFO(7, 1, 2) },
+-{ USB_DEVICE_INFO(7, 1, 3) },
++//{ USB_DEVICE_INFO(7, 1, 1) },
++//{ USB_DEVICE_INFO(7, 1, 2) },
++//{ USB_DEVICE_INFO(7, 1, 3) },
+ #endif
+ #ifdef        CONFIG_USB_NET_CDCETHER
+ /* Linux-USB CDC Ethernet gadget */
+-{ USB_DEVICE(0x0525, 0xa4a1), },
++//{ USB_DEVICE(0x0525, 0xa4a1), },
+ /* Linux-USB CDC Ethernet + RNDIS gadget */
+-{ USB_DEVICE(0x0525, 0xa4a2), },
++//{ USB_DEVICE(0x0525, 0xa4a2), },
+ #endif
+ #if   IS_ENABLED(CONFIG_USB_TEST)
+ /* gadget zero, for testing */
+-{ USB_DEVICE(0x0525, 0xa4a0), },
++//{ USB_DEVICE(0x0525, 0xa4a0), },
+ #endif
++/* OPT Tester */
++{ USB_DEVICE( 0x1a0a, 0x0101 ), }, /* TEST_SE0_NAK */
++{ USB_DEVICE( 0x1a0a, 0x0102 ), }, /* Test_J */
++{ USB_DEVICE( 0x1a0a, 0x0103 ), }, /* Test_K */
++{ USB_DEVICE( 0x1a0a, 0x0104 ), }, /* Test_PACKET */
++{ USB_DEVICE( 0x1a0a, 0x0105 ), }, /* Test_FORCE_ENABLE */
++{ USB_DEVICE( 0x1a0a, 0x0106 ), }, /* HS_PORT_SUSPEND_RESUME  */
++{ USB_DEVICE( 0x1a0a, 0x0107 ), }, /* SINGLE_STEP_GET_DESCRIPTOR setup */
++{ USB_DEVICE( 0x1a0a, 0x0108 ), }, /* SINGLE_STEP_GET_DESCRIPTOR execute */
++
++/* Sony cameras */
++{ USB_DEVICE_VER(0x054c,0x0010,0x0410, 0x0500), },
++
++/* Memory Devices */
++//{ USB_DEVICE( 0x0781, 0x5150 ), }, /* SanDisk */
++//{ USB_DEVICE( 0x05DC, 0x0080 ), }, /* Lexar */
++//{ USB_DEVICE( 0x4146, 0x9281 ), }, /* IOMEGA */
++//{ USB_DEVICE( 0x067b, 0x2507 ), }, /* Hammer 20GB External HD  */
++{ USB_DEVICE( 0x0EA0, 0x2168 ), }, /* Ours Technology Inc. (BUFFALO ClipDrive)*/
++//{ USB_DEVICE( 0x0457, 0x0150 ), }, /* Silicon Integrated Systems Corp. */
++
++/* HP Printers */
++//{ USB_DEVICE( 0x03F0, 0x1102 ), }, /* HP Photosmart 245 */
++//{ USB_DEVICE( 0x03F0, 0x1302 ), }, /* HP Photosmart 370 Series */
++
++/* Speakers */
++//{ USB_DEVICE( 0x0499, 0x3002 ), }, /* YAMAHA YST-MS35D USB Speakers */
++//{ USB_DEVICE( 0x0672, 0x1041 ), }, /* Labtec USB Headset */
++
+ { }   /* Terminating entry */
+ };
++static inline void report_errors(struct usb_device *dev)
++{
++      /* OTG MESSAGE: report errors here, customize to match your product */
++      dev_info(&dev->dev, "device Vendor:%04x Product:%04x is not supported\n",
++               le16_to_cpu(dev->descriptor.idVendor),
++               le16_to_cpu(dev->descriptor.idProduct));
++        if (USB_CLASS_HUB == dev->descriptor.bDeviceClass){
++                dev_printk(KERN_CRIT, &dev->dev, "Unsupported Hub Topology\n");
++        } else {
++                dev_printk(KERN_CRIT, &dev->dev, "Attached Device is not Supported\n");
++        }
++}
++
++
+ static int is_targeted(struct usb_device *dev)
+ {
+       struct usb_device_id    *id = whitelist_table;
+@@ -95,16 +144,57 @@ static int is_targeted(struct usb_device
+                       continue;
+               return 1;
+-      }
++              /* NOTE: can't use usb_match_id() since interface caches
++               * aren't set up yet. this is cut/paste from that code.
++               */
++              for (id = whitelist_table; id->match_flags; id++) {
++#ifdef DEBUG
++                      dev_dbg(&dev->dev,
++                              "ID: V:%04x P:%04x DC:%04x SC:%04x PR:%04x \n",
++                              id->idVendor,
++                              id->idProduct,
++                              id->bDeviceClass,
++                              id->bDeviceSubClass,
++                              id->bDeviceProtocol);
++#endif
+-      /* add other match criteria here ... */
++                      if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
++                          id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
++                              continue;
++
++                      if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
++                          id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
++                              continue;
++
++                      /* No need to test id->bcdDevice_lo != 0, since 0 is never
++                         greater than any unsigned number. */
++                      if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
++                          (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
++                              continue;
++
++                      if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
++                          (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
++                              continue;
++
++                      if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
++                          (id->bDeviceClass != dev->descriptor.bDeviceClass))
++                              continue;
++
++                      if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
++                          (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
++                              continue;
++
++                      if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
++                          (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
++                              continue;
++                      return 1;
++              }
++      }
+-      /* OTG MESSAGE: report errors here, customize to match your product */
+-      dev_err(&dev->dev, "device v%04x p%04x is not supported\n",
+-              le16_to_cpu(dev->descriptor.idVendor),
+-              le16_to_cpu(dev->descriptor.idProduct));
++      /* add other match criteria here ... */
++      report_errors(dev);
+       return 0;
+ }
+--- /dev/null
++++ b/drivers/usb/gadget/file_storage.c
+@@ -0,0 +1,3676 @@
++/*
++ * file_storage.c -- File-backed USB Storage Gadget, for USB development
++ *
++ * Copyright (C) 2003-2008 Alan Stern
++ * All rights reserved.
++ *
++ * 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 above-listed copyright holders may not be used
++ *    to endorse or promote products derived from this software without
++ *    specific prior written permission.
++ *
++ * ALTERNATIVELY, this software may be distributed under the terms of the
++ * GNU General Public License ("GPL") as published by the Free Software
++ * Foundation, either version 2 of that License or (at your option) any
++ * later version.
++ *
++ * 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.
++ */
++
++
++/*
++ * The File-backed Storage Gadget acts as a USB Mass Storage device,
++ * appearing to the host as a disk drive or as a CD-ROM drive.  In addition
++ * to providing an example of a genuinely useful gadget driver for a USB
++ * device, it also illustrates a technique of double-buffering for increased
++ * throughput.  Last but not least, it gives an easy way to probe the
++ * behavior of the Mass Storage drivers in a USB host.
++ *
++ * Backing storage is provided by a regular file or a block device, specified
++ * by the "file" module parameter.  Access can be limited to read-only by
++ * setting the optional "ro" module parameter.  (For CD-ROM emulation,
++ * access is always read-only.)  The gadget will indicate that it has
++ * removable media if the optional "removable" module parameter is set.
++ *
++ * The gadget supports the Control-Bulk (CB), Control-Bulk-Interrupt (CBI),
++ * and Bulk-Only (also known as Bulk-Bulk-Bulk or BBB) transports, selected
++ * by the optional "transport" module parameter.  It also supports the
++ * following protocols: RBC (0x01), ATAPI or SFF-8020i (0x02), QIC-157 (0c03),
++ * UFI (0x04), SFF-8070i (0x05), and transparent SCSI (0x06), selected by
++ * the optional "protocol" module parameter.  In addition, the default
++ * Vendor ID, Product ID, release number and serial number can be overridden.
++ *
++ * There is support for multiple logical units (LUNs), each of which has
++ * its own backing file.  The number of LUNs can be set using the optional
++ * "luns" module parameter (anywhere from 1 to 8), and the corresponding
++ * files are specified using comma-separated lists for "file" and "ro".
++ * The default number of LUNs is taken from the number of "file" elements;
++ * it is 1 if "file" is not given.  If "removable" is not set then a backing
++ * file must be specified for each LUN.  If it is set, then an unspecified
++ * or empty backing filename means the LUN's medium is not loaded.  Ideally
++ * each LUN would be settable independently as a disk drive or a CD-ROM
++ * drive, but currently all LUNs have to be the same type.  The CD-ROM
++ * emulation includes a single data track and no audio tracks; hence there
++ * need be only one backing file per LUN.
++ *
++ * Requirements are modest; only a bulk-in and a bulk-out endpoint are
++ * needed (an interrupt-out endpoint is also needed for CBI).  The memory
++ * requirement amounts to two 16K buffers, size configurable by a parameter.
++ * Support is included for both full-speed and high-speed operation.
++ *
++ * Note that the driver is slightly non-portable in that it assumes a
++ * single memory/DMA buffer will be useable for bulk-in, bulk-out, and
++ * interrupt-in endpoints.  With most device controllers this isn't an
++ * issue, but there may be some with hardware restrictions that prevent
++ * a buffer from being used by more than one endpoint.
++ *
++ * Module options:
++ *
++ *    file=filename[,filename...]
++ *                            Required if "removable" is not set, names of
++ *                                    the files or block devices used for
++ *                                    backing storage
++ *    serial=HHHH...          Required serial number (string of hex chars)
++ *    ro=b[,b...]             Default false, booleans for read-only access
++ *    removable               Default false, boolean for removable media
++ *    luns=N                  Default N = number of filenames, number of
++ *                                    LUNs to support
++ *    nofua=b[,b...]          Default false, booleans for ignore FUA flag
++ *                                    in SCSI WRITE(10,12) commands
++ *    stall                   Default determined according to the type of
++ *                                    USB device controller (usually true),
++ *                                    boolean to permit the driver to halt
++ *                                    bulk endpoints
++ *    cdrom                   Default false, boolean for whether to emulate
++ *                                    a CD-ROM drive
++ *    transport=XXX           Default BBB, transport name (CB, CBI, or BBB)
++ *    protocol=YYY            Default SCSI, protocol name (RBC, 8020 or
++ *                                    ATAPI, QIC, UFI, 8070, or SCSI;
++ *                                    also 1 - 6)
++ *    vendor=0xVVVV           Default 0x0525 (NetChip), USB Vendor ID
++ *    product=0xPPPP          Default 0xa4a5 (FSG), USB Product ID
++ *    release=0xRRRR          Override the USB release number (bcdDevice)
++ *    buflen=N                Default N=16384, buffer size used (will be
++ *                                    rounded down to a multiple of
++ *                                    PAGE_CACHE_SIZE)
++ *
++ * If CONFIG_USB_FILE_STORAGE_TEST is not set, only the "file", "serial", "ro",
++ * "removable", "luns", "nofua", "stall", and "cdrom" options are available;
++ * default values are used for everything else.
++ *
++ * The pathnames of the backing files and the ro settings are available in
++ * the attribute files "file", "nofua", and "ro" in the lun<n> subdirectory of
++ * the gadget's sysfs directory.  If the "removable" option is set, writing to
++ * these files will simulate ejecting/loading the medium (writing an empty
++ * line means eject) and adjusting a write-enable tab.  Changes to the ro
++ * setting are not allowed when the medium is loaded or if CD-ROM emulation
++ * is being used.
++ *
++ * This gadget driver is heavily based on "Gadget Zero" by David Brownell.
++ * The driver's SCSI command interface was based on the "Information
++ * technology - Small Computer System Interface - 2" document from
++ * X3T9.2 Project 375D, Revision 10L, 7-SEP-93, available at
++ * <http://www.t10.org/ftp/t10/drafts/s2/s2-r10l.pdf>.  The single exception
++ * is opcode 0x23 (READ FORMAT CAPACITIES), which was based on the
++ * "Universal Serial Bus Mass Storage Class UFI Command Specification"
++ * document, Revision 1.0, December 14, 1998, available at
++ * <http://www.usb.org/developers/devclass_docs/usbmass-ufi10.pdf>.
++ */
++
++
++/*
++ *                            Driver Design
++ *
++ * The FSG driver is fairly straightforward.  There is a main kernel
++ * thread that handles most of the work.  Interrupt routines field
++ * callbacks from the controller driver: bulk- and interrupt-request
++ * completion notifications, endpoint-0 events, and disconnect events.
++ * Completion events are passed to the main thread by wakeup calls.  Many
++ * ep0 requests are handled at interrupt time, but SetInterface,
++ * SetConfiguration, and device reset requests are forwarded to the
++ * thread in the form of "exceptions" using SIGUSR1 signals (since they
++ * should interrupt any ongoing file I/O operations).
++ *
++ * The thread's main routine implements the standard command/data/status
++ * parts of a SCSI interaction.  It and its subroutines are full of tests
++ * for pending signals/exceptions -- all this polling is necessary since
++ * the kernel has no setjmp/longjmp equivalents.  (Maybe this is an
++ * indication that the driver really wants to be running in userspace.)
++ * An important point is that so long as the thread is alive it keeps an
++ * open reference to the backing file.  This will prevent unmounting
++ * the backing file's underlying filesystem and could cause problems
++ * during system shutdown, for example.  To prevent such problems, the
++ * thread catches INT, TERM, and KILL signals and converts them into
++ * an EXIT exception.
++ *
++ * In normal operation the main thread is started during the gadget's
++ * fsg_bind() callback and stopped during fsg_unbind().  But it can also
++ * exit when it receives a signal, and there's no point leaving the
++ * gadget running when the thread is dead.  So just before the thread
++ * exits, it deregisters the gadget driver.  This makes things a little
++ * tricky: The driver is deregistered at two places, and the exiting
++ * thread can indirectly call fsg_unbind() which in turn can tell the
++ * thread to exit.  The first problem is resolved through the use of the
++ * REGISTERED atomic bitflag; the driver will only be deregistered once.
++ * The second problem is resolved by having fsg_unbind() check
++ * fsg->state; it won't try to stop the thread if the state is already
++ * FSG_STATE_TERMINATED.
++ *
++ * To provide maximum throughput, the driver uses a circular pipeline of
++ * buffer heads (struct fsg_buffhd).  In principle the pipeline can be
++ * arbitrarily long; in practice the benefits don't justify having more
++ * than 2 stages (i.e., double buffering).  But it helps to think of the
++ * pipeline as being a long one.  Each buffer head contains a bulk-in and
++ * a bulk-out request pointer (since the buffer can be used for both
++ * output and input -- directions always are given from the host's
++ * point of view) as well as a pointer to the buffer and various state
++ * variables.
++ *
++ * Use of the pipeline follows a simple protocol.  There is a variable
++ * (fsg->next_buffhd_to_fill) that points to the next buffer head to use.
++ * At any time that buffer head may still be in use from an earlier
++ * request, so each buffer head has a state variable indicating whether
++ * it is EMPTY, FULL, or BUSY.  Typical use involves waiting for the
++ * buffer head to be EMPTY, filling the buffer either by file I/O or by
++ * USB I/O (during which the buffer head is BUSY), and marking the buffer
++ * head FULL when the I/O is complete.  Then the buffer will be emptied
++ * (again possibly by USB I/O, during which it is marked BUSY) and
++ * finally marked EMPTY again (possibly by a completion routine).
++ *
++ * A module parameter tells the driver to avoid stalling the bulk
++ * endpoints wherever the transport specification allows.  This is
++ * necessary for some UDCs like the SuperH, which cannot reliably clear a
++ * halt on a bulk endpoint.  However, under certain circumstances the
++ * Bulk-only specification requires a stall.  In such cases the driver
++ * will halt the endpoint and set a flag indicating that it should clear
++ * the halt in software during the next device reset.  Hopefully this
++ * will permit everything to work correctly.  Furthermore, although the
++ * specification allows the bulk-out endpoint to halt when the host sends
++ * too much data, implementing this would cause an unavoidable race.
++ * The driver will always use the "no-stall" approach for OUT transfers.
++ *
++ * One subtle point concerns sending status-stage responses for ep0
++ * requests.  Some of these requests, such as device reset, can involve
++ * interrupting an ongoing file I/O operation, which might take an
++ * arbitrarily long time.  During that delay the host might give up on
++ * the original ep0 request and issue a new one.  When that happens the
++ * driver should not notify the host about completion of the original
++ * request, as the host will no longer be waiting for it.  So the driver
++ * assigns to each ep0 request a unique tag, and it keeps track of the
++ * tag value of the request associated with a long-running exception
++ * (device-reset, interface-change, or configuration-change).  When the
++ * exception handler is finished, the status-stage response is submitted
++ * only if the current ep0 request tag is equal to the exception request
++ * tag.  Thus only the most recently received ep0 request will get a
++ * status-stage response.
++ *
++ * Warning: This driver source file is too long.  It ought to be split up
++ * into a header file plus about 3 separate .c files, to handle the details
++ * of the Gadget, USB Mass Storage, and SCSI protocols.
++ */
++
++
++/* #define VERBOSE_DEBUG */
++/* #define DUMP_MSGS */
++
++
++#include <linux/blkdev.h>
++#include <linux/completion.h>
++#include <linux/dcache.h>
++#include <linux/delay.h>
++#include <linux/device.h>
++#include <linux/fcntl.h>
++#include <linux/file.h>
++#include <linux/fs.h>
++#include <linux/kref.h>
++#include <linux/kthread.h>
++#include <linux/limits.h>
++#include <linux/module.h>
++#include <linux/rwsem.h>
++#include <linux/slab.h>
++#include <linux/spinlock.h>
++#include <linux/string.h>
++#include <linux/freezer.h>
++#include <linux/utsname.h>
++
++#include <linux/usb/ch9.h>
++#include <linux/usb/gadget.h>
++
++#include "gadget_chips.h"
++
++
++
++/*
++ * Kbuild is not very cooperative with respect to linking separately
++ * compiled library objects into one module.  So for now we won't use
++ * separate compilation ... ensuring init/exit sections work to shrink
++ * the runtime footprint, and giving us at least some parts of what
++ * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
++ */
++#include "usbstring.c"
++#include "config.c"
++#include "epautoconf.c"
++
++/*-------------------------------------------------------------------------*/
++
++#define DRIVER_DESC           "File-backed Storage Gadget"
++#define DRIVER_NAME           "g_file_storage"
++#define DRIVER_VERSION                "1 September 2010"
++
++static       char fsg_string_manufacturer[64];
++static const char fsg_string_product[] = DRIVER_DESC;
++static const char fsg_string_config[] = "Self-powered";
++static const char fsg_string_interface[] = "Mass Storage";
++
++
++#include "storage_common.c"
++
++
++MODULE_DESCRIPTION(DRIVER_DESC);
++MODULE_AUTHOR("Alan Stern");
++MODULE_LICENSE("Dual BSD/GPL");
++
++/*
++ * This driver assumes self-powered hardware and has no way for users to
++ * trigger remote wakeup.  It uses autoconfiguration to select endpoints
++ * and endpoint addresses.
++ */
++
++
++/*-------------------------------------------------------------------------*/
++
++
++/* Encapsulate the module parameter settings */
++
++static struct {
++      char            *file[FSG_MAX_LUNS];
++      char            *serial;
++      bool            ro[FSG_MAX_LUNS];
++      bool            nofua[FSG_MAX_LUNS];
++      unsigned int    num_filenames;
++      unsigned int    num_ros;
++      unsigned int    num_nofuas;
++      unsigned int    nluns;
++
++      bool            removable;
++      bool            can_stall;
++      bool            cdrom;
++
++      char            *transport_parm;
++      char            *protocol_parm;
++      unsigned short  vendor;
++      unsigned short  product;
++      unsigned short  release;
++      unsigned int    buflen;
++
++      int             transport_type;
++      char            *transport_name;
++      int             protocol_type;
++      char            *protocol_name;
++
++} mod_data = {                                        // Default values
++      .transport_parm         = "BBB",
++      .protocol_parm          = "SCSI",
++      .removable              = 0,
++      .can_stall              = 1,
++      .cdrom                  = 0,
++      .vendor                 = FSG_VENDOR_ID,
++      .product                = FSG_PRODUCT_ID,
++      .release                = 0xffff,       // Use controller chip type
++      .buflen                 = 16384,
++      };
++
++
++module_param_array_named(file, mod_data.file, charp, &mod_data.num_filenames,
++              S_IRUGO);
++MODULE_PARM_DESC(file, "names of backing files or devices");
++
++module_param_named(serial, mod_data.serial, charp, S_IRUGO);
++MODULE_PARM_DESC(serial, "USB serial number");
++
++module_param_array_named(ro, mod_data.ro, bool, &mod_data.num_ros, S_IRUGO);
++MODULE_PARM_DESC(ro, "true to force read-only");
++
++module_param_array_named(nofua, mod_data.nofua, bool, &mod_data.num_nofuas,
++              S_IRUGO);
++MODULE_PARM_DESC(nofua, "true to ignore SCSI WRITE(10,12) FUA bit");
++
++module_param_named(luns, mod_data.nluns, uint, S_IRUGO);
++MODULE_PARM_DESC(luns, "number of LUNs");
++
++module_param_named(removable, mod_data.removable, bool, S_IRUGO);
++MODULE_PARM_DESC(removable, "true to simulate removable media");
++
++module_param_named(stall, mod_data.can_stall, bool, S_IRUGO);
++MODULE_PARM_DESC(stall, "false to prevent bulk stalls");
++
++module_param_named(cdrom, mod_data.cdrom, bool, S_IRUGO);
++MODULE_PARM_DESC(cdrom, "true to emulate cdrom instead of disk");
++
++/* In the non-TEST version, only the module parameters listed above
++ * are available. */
++#ifdef CONFIG_USB_FILE_STORAGE_TEST
++
++module_param_named(transport, mod_data.transport_parm, charp, S_IRUGO);
++MODULE_PARM_DESC(transport, "type of transport (BBB, CBI, or CB)");
++
++module_param_named(protocol, mod_data.protocol_parm, charp, S_IRUGO);
++MODULE_PARM_DESC(protocol, "type of protocol (RBC, 8020, QIC, UFI, "
++              "8070, or SCSI)");
++
++module_param_named(vendor, mod_data.vendor, ushort, S_IRUGO);
++MODULE_PARM_DESC(vendor, "USB Vendor ID");
++
++module_param_named(product, mod_data.product, ushort, S_IRUGO);
++MODULE_PARM_DESC(product, "USB Product ID");
++
++module_param_named(release, mod_data.release, ushort, S_IRUGO);
++MODULE_PARM_DESC(release, "USB release number");
++
++module_param_named(buflen, mod_data.buflen, uint, S_IRUGO);
++MODULE_PARM_DESC(buflen, "I/O buffer size");
++
++#endif /* CONFIG_USB_FILE_STORAGE_TEST */
++
++
++/*
++ * These definitions will permit the compiler to avoid generating code for
++ * parts of the driver that aren't used in the non-TEST version.  Even gcc
++ * can recognize when a test of a constant expression yields a dead code
++ * path.
++ */
++
++#ifdef CONFIG_USB_FILE_STORAGE_TEST
++
++#define transport_is_bbb()    (mod_data.transport_type == USB_PR_BULK)
++#define transport_is_cbi()    (mod_data.transport_type == USB_PR_CBI)
++#define protocol_is_scsi()    (mod_data.protocol_type == USB_SC_SCSI)
++
++#else
++
++#define transport_is_bbb()    1
++#define transport_is_cbi()    0
++#define protocol_is_scsi()    1
++
++#endif /* CONFIG_USB_FILE_STORAGE_TEST */
++
++
++/*-------------------------------------------------------------------------*/
++
++
++struct fsg_dev {
++      /* lock protects: state, all the req_busy's, and cbbuf_cmnd */
++      spinlock_t              lock;
++      struct usb_gadget       *gadget;
++
++      /* filesem protects: backing files in use */
++      struct rw_semaphore     filesem;
++
++      /* reference counting: wait until all LUNs are released */
++      struct kref             ref;
++
++      struct usb_ep           *ep0;           // Handy copy of gadget->ep0
++      struct usb_request      *ep0req;        // For control responses
++      unsigned int            ep0_req_tag;
++      const char              *ep0req_name;
++
++      struct usb_request      *intreq;        // For interrupt responses
++      int                     intreq_busy;
++      struct fsg_buffhd       *intr_buffhd;
++
++      unsigned int            bulk_out_maxpacket;
++      enum fsg_state          state;          // For exception handling
++      unsigned int            exception_req_tag;
++
++      u8                      config, new_config;
++
++      unsigned int            running : 1;
++      unsigned int            bulk_in_enabled : 1;
++      unsigned int            bulk_out_enabled : 1;
++      unsigned int            intr_in_enabled : 1;
++      unsigned int            phase_error : 1;
++      unsigned int            short_packet_received : 1;
++      unsigned int            bad_lun_okay : 1;
++
++      unsigned long           atomic_bitflags;
++#define REGISTERED            0
++#define IGNORE_BULK_OUT               1
++#define SUSPENDED             2
++
++      struct usb_ep           *bulk_in;
++      struct usb_ep           *bulk_out;
++      struct usb_ep           *intr_in;
++
++      struct fsg_buffhd       *next_buffhd_to_fill;
++      struct fsg_buffhd       *next_buffhd_to_drain;
++
++      int                     thread_wakeup_needed;
++      struct completion       thread_notifier;
++      struct task_struct      *thread_task;
++
++      int                     cmnd_size;
++      u8                      cmnd[MAX_COMMAND_SIZE];
++      enum data_direction     data_dir;
++      u32                     data_size;
++      u32                     data_size_from_cmnd;
++      u32                     tag;
++      unsigned int            lun;
++      u32                     residue;
++      u32                     usb_amount_left;
++
++      /* The CB protocol offers no way for a host to know when a command
++       * has completed.  As a result the next command may arrive early,
++       * and we will still have to handle it.  For that reason we need
++       * a buffer to store new commands when using CB (or CBI, which
++       * does not oblige a host to wait for command completion either). */
++      int                     cbbuf_cmnd_size;
++      u8                      cbbuf_cmnd[MAX_COMMAND_SIZE];
++
++      unsigned int            nluns;
++      struct fsg_lun          *luns;
++      struct fsg_lun          *curlun;
++      /* Must be the last entry */
++      struct fsg_buffhd       buffhds[];
++};
++
++typedef void (*fsg_routine_t)(struct fsg_dev *);
++
++static int exception_in_progress(struct fsg_dev *fsg)
++{
++      return (fsg->state > FSG_STATE_IDLE);
++}
++
++/* Make bulk-out requests be divisible by the maxpacket size */
++static void set_bulk_out_req_length(struct fsg_dev *fsg,
++              struct fsg_buffhd *bh, unsigned int length)
++{
++      unsigned int    rem;
++
++      bh->bulk_out_intended_length = length;
++      rem = length % fsg->bulk_out_maxpacket;
++      if (rem > 0)
++              length += fsg->bulk_out_maxpacket - rem;
++      bh->outreq->length = length;
++}
++
++static struct fsg_dev                 *the_fsg;
++static struct usb_gadget_driver               fsg_driver;
++
++
++/*-------------------------------------------------------------------------*/
++
++static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
++{
++      const char      *name;
++
++      if (ep == fsg->bulk_in)
++              name = "bulk-in";
++      else if (ep == fsg->bulk_out)
++              name = "bulk-out";
++      else
++              name = ep->name;
++      DBG(fsg, "%s set halt\n", name);
++      return usb_ep_set_halt(ep);
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++/*
++ * DESCRIPTORS ... most are static, but strings and (full) configuration
++ * descriptors are built on demand.  Also the (static) config and interface
++ * descriptors are adjusted during fsg_bind().
++ */
++
++/* There is only one configuration. */
++#define       CONFIG_VALUE            1
++
++static struct usb_device_descriptor
++device_desc = {
++      .bLength =              sizeof device_desc,
++      .bDescriptorType =      USB_DT_DEVICE,
++
++      .bcdUSB =               cpu_to_le16(0x0200),
++      .bDeviceClass =         USB_CLASS_PER_INTERFACE,
++
++      /* The next three values can be overridden by module parameters */
++      .idVendor =             cpu_to_le16(FSG_VENDOR_ID),
++      .idProduct =            cpu_to_le16(FSG_PRODUCT_ID),
++      .bcdDevice =            cpu_to_le16(0xffff),
++
++      .iManufacturer =        FSG_STRING_MANUFACTURER,
++      .iProduct =             FSG_STRING_PRODUCT,
++      .iSerialNumber =        FSG_STRING_SERIAL,
++      .bNumConfigurations =   1,
++};
++
++static struct usb_config_descriptor
++config_desc = {
++      .bLength =              sizeof config_desc,
++      .bDescriptorType =      USB_DT_CONFIG,
++
++      /* wTotalLength computed by usb_gadget_config_buf() */
++      .bNumInterfaces =       1,
++      .bConfigurationValue =  CONFIG_VALUE,
++      .iConfiguration =       FSG_STRING_CONFIG,
++      .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
++      .bMaxPower =            CONFIG_USB_GADGET_VBUS_DRAW / 2,
++};
++
++
++static struct usb_qualifier_descriptor
++dev_qualifier = {
++      .bLength =              sizeof dev_qualifier,
++      .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
++
++      .bcdUSB =               cpu_to_le16(0x0200),
++      .bDeviceClass =         USB_CLASS_PER_INTERFACE,
++
++      .bNumConfigurations =   1,
++};
++
++static int populate_bos(struct fsg_dev *fsg, u8 *buf)
++{
++      memcpy(buf, &fsg_bos_desc, USB_DT_BOS_SIZE);
++      buf += USB_DT_BOS_SIZE;
++
++      memcpy(buf, &fsg_ext_cap_desc, USB_DT_USB_EXT_CAP_SIZE);
++      buf += USB_DT_USB_EXT_CAP_SIZE;
++
++      memcpy(buf, &fsg_ss_cap_desc, USB_DT_USB_SS_CAP_SIZE);
++
++      return USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE
++              + USB_DT_USB_EXT_CAP_SIZE;
++}
++
++/*
++ * Config descriptors must agree with the code that sets configurations
++ * and with code managing interfaces and their altsettings.  They must
++ * also handle different speeds and other-speed requests.
++ */
++static int populate_config_buf(struct usb_gadget *gadget,
++              u8 *buf, u8 type, unsigned index)
++{
++      enum usb_device_speed                   speed = gadget->speed;
++      int                                     len;
++      const struct usb_descriptor_header      **function;
++
++      if (index > 0)
++              return -EINVAL;
++
++      if (gadget_is_dualspeed(gadget) && type == USB_DT_OTHER_SPEED_CONFIG)
++              speed = (USB_SPEED_FULL + USB_SPEED_HIGH) - speed;
++      function = gadget_is_dualspeed(gadget) && speed == USB_SPEED_HIGH
++              ? (const struct usb_descriptor_header **)fsg_hs_function
++              : (const struct usb_descriptor_header **)fsg_fs_function;
++
++      /* for now, don't advertise srp-only devices */
++      if (!gadget_is_otg(gadget))
++              function++;
++
++      len = usb_gadget_config_buf(&config_desc, buf, EP0_BUFSIZE, function);
++      ((struct usb_config_descriptor *) buf)->bDescriptorType = type;
++      return len;
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++/* These routines may be called in process context or in_irq */
++
++/* Caller must hold fsg->lock */
++static void wakeup_thread(struct fsg_dev *fsg)
++{
++      /* Tell the main thread that something has happened */
++      fsg->thread_wakeup_needed = 1;
++      if (fsg->thread_task)
++              wake_up_process(fsg->thread_task);
++}
++
++
++static void raise_exception(struct fsg_dev *fsg, enum fsg_state new_state)
++{
++      unsigned long           flags;
++
++      /* Do nothing if a higher-priority exception is already in progress.
++       * If a lower-or-equal priority exception is in progress, preempt it
++       * and notify the main thread by sending it a signal. */
++      spin_lock_irqsave(&fsg->lock, flags);
++      if (fsg->state <= new_state) {
++              fsg->exception_req_tag = fsg->ep0_req_tag;
++              fsg->state = new_state;
++              if (fsg->thread_task)
++                      send_sig_info(SIGUSR1, SEND_SIG_FORCED,
++                                      fsg->thread_task);
++      }
++      spin_unlock_irqrestore(&fsg->lock, flags);
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++/* The disconnect callback and ep0 routines.  These always run in_irq,
++ * except that ep0_queue() is called in the main thread to acknowledge
++ * completion of various requests: set config, set interface, and
++ * Bulk-only device reset. */
++
++static void fsg_disconnect(struct usb_gadget *gadget)
++{
++      struct fsg_dev          *fsg = get_gadget_data(gadget);
++
++      DBG(fsg, "disconnect or port reset\n");
++      raise_exception(fsg, FSG_STATE_DISCONNECT);
++}
++
++
++static int ep0_queue(struct fsg_dev *fsg)
++{
++      int     rc;
++
++      rc = usb_ep_queue(fsg->ep0, fsg->ep0req, GFP_ATOMIC);
++      if (rc != 0 && rc != -ESHUTDOWN) {
++
++              /* We can't do much more than wait for a reset */
++              WARNING(fsg, "error in submission: %s --> %d\n",
++                              fsg->ep0->name, rc);
++      }
++      return rc;
++}
++
++static void ep0_complete(struct usb_ep *ep, struct usb_request *req)
++{
++      struct fsg_dev          *fsg = ep->driver_data;
++
++      if (req->actual > 0)
++              dump_msg(fsg, fsg->ep0req_name, req->buf, req->actual);
++      if (req->status || req->actual != req->length)
++              DBG(fsg, "%s --> %d, %u/%u\n", __func__,
++                              req->status, req->actual, req->length);
++      if (req->status == -ECONNRESET)         // Request was cancelled
++              usb_ep_fifo_flush(ep);
++
++      if (req->status == 0 && req->context)
++              ((fsg_routine_t) (req->context))(fsg);
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++/* Bulk and interrupt endpoint completion handlers.
++ * These always run in_irq. */
++
++static void bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
++{
++      struct fsg_dev          *fsg = ep->driver_data;
++      struct fsg_buffhd       *bh = req->context;
++
++      if (req->status || req->actual != req->length)
++              DBG(fsg, "%s --> %d, %u/%u\n", __func__,
++                              req->status, req->actual, req->length);
++      if (req->status == -ECONNRESET)         // Request was cancelled
++              usb_ep_fifo_flush(ep);
++
++      /* Hold the lock while we update the request and buffer states */
++      smp_wmb();
++      spin_lock(&fsg->lock);
++      bh->inreq_busy = 0;
++      bh->state = BUF_STATE_EMPTY;
++      wakeup_thread(fsg);
++      spin_unlock(&fsg->lock);
++}
++
++static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
++{
++      struct fsg_dev          *fsg = ep->driver_data;
++      struct fsg_buffhd       *bh = req->context;
++
++      dump_msg(fsg, "bulk-out", req->buf, req->actual);
++      if (req->status || req->actual != bh->bulk_out_intended_length)
++              DBG(fsg, "%s --> %d, %u/%u\n", __func__,
++                              req->status, req->actual,
++                              bh->bulk_out_intended_length);
++      if (req->status == -ECONNRESET)         // Request was cancelled
++              usb_ep_fifo_flush(ep);
++
++      /* Hold the lock while we update the request and buffer states */
++      smp_wmb();
++      spin_lock(&fsg->lock);
++      bh->outreq_busy = 0;
++      bh->state = BUF_STATE_FULL;
++      wakeup_thread(fsg);
++      spin_unlock(&fsg->lock);
++}
++
++
++#ifdef CONFIG_USB_FILE_STORAGE_TEST
++static void intr_in_complete(struct usb_ep *ep, struct usb_request *req)
++{
++      struct fsg_dev          *fsg = ep->driver_data;
++      struct fsg_buffhd       *bh = req->context;
++
++      if (req->status || req->actual != req->length)
++              DBG(fsg, "%s --> %d, %u/%u\n", __func__,
++                              req->status, req->actual, req->length);
++      if (req->status == -ECONNRESET)         // Request was cancelled
++              usb_ep_fifo_flush(ep);
++
++      /* Hold the lock while we update the request and buffer states */
++      smp_wmb();
++      spin_lock(&fsg->lock);
++      fsg->intreq_busy = 0;
++      bh->state = BUF_STATE_EMPTY;
++      wakeup_thread(fsg);
++      spin_unlock(&fsg->lock);
++}
++
++#else
++static void intr_in_complete(struct usb_ep *ep, struct usb_request *req)
++{}
++#endif /* CONFIG_USB_FILE_STORAGE_TEST */
++
++
++/*-------------------------------------------------------------------------*/
++
++/* Ep0 class-specific handlers.  These always run in_irq. */
++
++#ifdef CONFIG_USB_FILE_STORAGE_TEST
++static void received_cbi_adsc(struct fsg_dev *fsg, struct fsg_buffhd *bh)
++{
++      struct usb_request      *req = fsg->ep0req;
++      static u8               cbi_reset_cmnd[6] = {
++                      SEND_DIAGNOSTIC, 4, 0xff, 0xff, 0xff, 0xff};
++
++      /* Error in command transfer? */
++      if (req->status || req->length != req->actual ||
++                      req->actual < 6 || req->actual > MAX_COMMAND_SIZE) {
++
++              /* Not all controllers allow a protocol stall after
++               * receiving control-out data, but we'll try anyway. */
++              fsg_set_halt(fsg, fsg->ep0);
++              return;                 // Wait for reset
++      }
++
++      /* Is it the special reset command? */
++      if (req->actual >= sizeof cbi_reset_cmnd &&
++                      memcmp(req->buf, cbi_reset_cmnd,
++                              sizeof cbi_reset_cmnd) == 0) {
++
++              /* Raise an exception to stop the current operation
++               * and reinitialize our state. */
++              DBG(fsg, "cbi reset request\n");
++              raise_exception(fsg, FSG_STATE_RESET);
++              return;
++      }
++
++      VDBG(fsg, "CB[I] accept device-specific command\n");
++      spin_lock(&fsg->lock);
++
++      /* Save the command for later */
++      if (fsg->cbbuf_cmnd_size)
++              WARNING(fsg, "CB[I] overwriting previous command\n");
++      fsg->cbbuf_cmnd_size = req->actual;
++      memcpy(fsg->cbbuf_cmnd, req->buf, fsg->cbbuf_cmnd_size);
++
++      wakeup_thread(fsg);
++      spin_unlock(&fsg->lock);
++}
++
++#else
++static void received_cbi_adsc(struct fsg_dev *fsg, struct fsg_buffhd *bh)
++{}
++#endif /* CONFIG_USB_FILE_STORAGE_TEST */
++
++
++static int class_setup_req(struct fsg_dev *fsg,
++              const struct usb_ctrlrequest *ctrl)
++{
++      struct usb_request      *req = fsg->ep0req;
++      int                     value = -EOPNOTSUPP;
++      u16                     w_index = le16_to_cpu(ctrl->wIndex);
++      u16                     w_value = le16_to_cpu(ctrl->wValue);
++      u16                     w_length = le16_to_cpu(ctrl->wLength);
++
++      if (!fsg->config)
++              return value;
++
++      /* Handle Bulk-only class-specific requests */
++      if (transport_is_bbb()) {
++              switch (ctrl->bRequest) {
++
++              case US_BULK_RESET_REQUEST:
++                      if (ctrl->bRequestType != (USB_DIR_OUT |
++                                      USB_TYPE_CLASS | USB_RECIP_INTERFACE))
++                              break;
++                      if (w_index != 0 || w_value != 0 || w_length != 0) {
++                              value = -EDOM;
++                              break;
++                      }
++
++                      /* Raise an exception to stop the current operation
++                       * and reinitialize our state. */
++                      DBG(fsg, "bulk reset request\n");
++                      raise_exception(fsg, FSG_STATE_RESET);
++                      value = DELAYED_STATUS;
++                      break;
++
++              case US_BULK_GET_MAX_LUN:
++                      if (ctrl->bRequestType != (USB_DIR_IN |
++                                      USB_TYPE_CLASS | USB_RECIP_INTERFACE))
++                              break;
++                      if (w_index != 0 || w_value != 0 || w_length != 1) {
++                              value = -EDOM;
++                              break;
++                      }
++                      VDBG(fsg, "get max LUN\n");
++                      *(u8 *) req->buf = fsg->nluns - 1;
++                      value = 1;
++                      break;
++              }
++      }
++
++      /* Handle CBI class-specific requests */
++      else {
++              switch (ctrl->bRequest) {
++
++              case USB_CBI_ADSC_REQUEST:
++                      if (ctrl->bRequestType != (USB_DIR_OUT |
++                                      USB_TYPE_CLASS | USB_RECIP_INTERFACE))
++                              break;
++                      if (w_index != 0 || w_value != 0) {
++                              value = -EDOM;
++                              break;
++                      }
++                      if (w_length > MAX_COMMAND_SIZE) {
++                              value = -EOVERFLOW;
++                              break;
++                      }
++                      value = w_length;
++                      fsg->ep0req->context = received_cbi_adsc;
++                      break;
++              }
++      }
++
++      if (value == -EOPNOTSUPP)
++              VDBG(fsg,
++                      "unknown class-specific control req "
++                      "%02x.%02x v%04x i%04x l%u\n",
++                      ctrl->bRequestType, ctrl->bRequest,
++                      le16_to_cpu(ctrl->wValue), w_index, w_length);
++      return value;
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++/* Ep0 standard request handlers.  These always run in_irq. */
++
++static int standard_setup_req(struct fsg_dev *fsg,
++              const struct usb_ctrlrequest *ctrl)
++{
++      struct usb_request      *req = fsg->ep0req;
++      int                     value = -EOPNOTSUPP;
++      u16                     w_index = le16_to_cpu(ctrl->wIndex);
++      u16                     w_value = le16_to_cpu(ctrl->wValue);
++
++      /* Usually this just stores reply data in the pre-allocated ep0 buffer,
++       * but config change events will also reconfigure hardware. */
++      switch (ctrl->bRequest) {
++
++      case USB_REQ_GET_DESCRIPTOR:
++              if (ctrl->bRequestType != (USB_DIR_IN | USB_TYPE_STANDARD |
++                              USB_RECIP_DEVICE))
++                      break;
++              switch (w_value >> 8) {
++
++              case USB_DT_DEVICE:
++                      VDBG(fsg, "get device descriptor\n");
++                      device_desc.bMaxPacketSize0 = fsg->ep0->maxpacket;
++                      value = sizeof device_desc;
++                      memcpy(req->buf, &device_desc, value);
++                      break;
++              case USB_DT_DEVICE_QUALIFIER:
++                      VDBG(fsg, "get device qualifier\n");
++                      if (!gadget_is_dualspeed(fsg->gadget) ||
++                                      fsg->gadget->speed == USB_SPEED_SUPER)
++                              break;
++                      /*
++                       * Assume ep0 uses the same maxpacket value for both
++                       * speeds
++                       */
++                      dev_qualifier.bMaxPacketSize0 = fsg->ep0->maxpacket;
++                      value = sizeof dev_qualifier;
++                      memcpy(req->buf, &dev_qualifier, value);
++                      break;
++
++              case USB_DT_OTHER_SPEED_CONFIG:
++                      VDBG(fsg, "get other-speed config descriptor\n");
++                      if (!gadget_is_dualspeed(fsg->gadget) ||
++                                      fsg->gadget->speed == USB_SPEED_SUPER)
++                              break;
++                      goto get_config;
++              case USB_DT_CONFIG:
++                      VDBG(fsg, "get configuration descriptor\n");
++get_config:
++                      value = populate_config_buf(fsg->gadget,
++                                      req->buf,
++                                      w_value >> 8,
++                                      w_value & 0xff);
++                      break;
++
++              case USB_DT_STRING:
++                      VDBG(fsg, "get string descriptor\n");
++
++                      /* wIndex == language code */
++                      value = usb_gadget_get_string(&fsg_stringtab,
++                                      w_value & 0xff, req->buf);
++                      break;
++
++              case USB_DT_BOS:
++                      VDBG(fsg, "get bos descriptor\n");
++
++                      if (gadget_is_superspeed(fsg->gadget))
++                              value = populate_bos(fsg, req->buf);
++                      break;
++              }
++
++              break;
++
++      /* One config, two speeds */
++      case USB_REQ_SET_CONFIGURATION:
++              if (ctrl->bRequestType != (USB_DIR_OUT | USB_TYPE_STANDARD |
++                              USB_RECIP_DEVICE))
++                      break;
++              VDBG(fsg, "set configuration\n");
++              if (w_value == CONFIG_VALUE || w_value == 0) {
++                      fsg->new_config = w_value;
++
++                      /* Raise an exception to wipe out previous transaction
++                       * state (queued bufs, etc) and set the new config. */
++                      raise_exception(fsg, FSG_STATE_CONFIG_CHANGE);
++                      value = DELAYED_STATUS;
++              }
++              break;
++      case USB_REQ_GET_CONFIGURATION:
++              if (ctrl->bRequestType != (USB_DIR_IN | USB_TYPE_STANDARD |
++                              USB_RECIP_DEVICE))
++                      break;
++              VDBG(fsg, "get configuration\n");
++              *(u8 *) req->buf = fsg->config;
++              value = 1;
++              break;
++
++      case USB_REQ_SET_INTERFACE:
++              if (ctrl->bRequestType != (USB_DIR_OUT| USB_TYPE_STANDARD |
++                              USB_RECIP_INTERFACE))
++                      break;
++              if (fsg->config && w_index == 0) {
++
++                      /* Raise an exception to wipe out previous transaction
++                       * state (queued bufs, etc) and install the new
++                       * interface altsetting. */
++                      raise_exception(fsg, FSG_STATE_INTERFACE_CHANGE);
++                      value = DELAYED_STATUS;
++              }
++              break;
++      case USB_REQ_GET_INTERFACE:
++              if (ctrl->bRequestType != (USB_DIR_IN | USB_TYPE_STANDARD |
++                              USB_RECIP_INTERFACE))
++                      break;
++              if (!fsg->config)
++                      break;
++              if (w_index != 0) {
++                      value = -EDOM;
++                      break;
++              }
++              VDBG(fsg, "get interface\n");
++              *(u8 *) req->buf = 0;
++              value = 1;
++              break;
++
++      default:
++              VDBG(fsg,
++                      "unknown control req %02x.%02x v%04x i%04x l%u\n",
++                      ctrl->bRequestType, ctrl->bRequest,
++                      w_value, w_index, le16_to_cpu(ctrl->wLength));
++      }
++
++      return value;
++}
++
++
++static int fsg_setup(struct usb_gadget *gadget,
++              const struct usb_ctrlrequest *ctrl)
++{
++      struct fsg_dev          *fsg = get_gadget_data(gadget);
++      int                     rc;
++      int                     w_length = le16_to_cpu(ctrl->wLength);
++
++      ++fsg->ep0_req_tag;             // Record arrival of a new request
++      fsg->ep0req->context = NULL;
++      fsg->ep0req->length = 0;
++      dump_msg(fsg, "ep0-setup", (u8 *) ctrl, sizeof(*ctrl));
++
++      if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_CLASS)
++              rc = class_setup_req(fsg, ctrl);
++      else
++              rc = standard_setup_req(fsg, ctrl);
++
++      /* Respond with data/status or defer until later? */
++      if (rc >= 0 && rc != DELAYED_STATUS) {
++              rc = min(rc, w_length);
++              fsg->ep0req->length = rc;
++              fsg->ep0req->zero = rc < w_length;
++              fsg->ep0req_name = (ctrl->bRequestType & USB_DIR_IN ?
++                              "ep0-in" : "ep0-out");
++              rc = ep0_queue(fsg);
++      }
++
++      /* Device either stalls (rc < 0) or reports success */
++      return rc;
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++/* All the following routines run in process context */
++
++
++/* Use this for bulk or interrupt transfers, not ep0 */
++static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
++              struct usb_request *req, int *pbusy,
++              enum fsg_buffer_state *state)
++{
++      int     rc;
++
++      if (ep == fsg->bulk_in)
++              dump_msg(fsg, "bulk-in", req->buf, req->length);
++      else if (ep == fsg->intr_in)
++              dump_msg(fsg, "intr-in", req->buf, req->length);
++
++      spin_lock_irq(&fsg->lock);
++      *pbusy = 1;
++      *state = BUF_STATE_BUSY;
++      spin_unlock_irq(&fsg->lock);
++      rc = usb_ep_queue(ep, req, GFP_KERNEL);
++      if (rc != 0) {
++              *pbusy = 0;
++              *state = BUF_STATE_EMPTY;
++
++              /* We can't do much more than wait for a reset */
++
++              /* Note: currently the net2280 driver fails zero-length
++               * submissions if DMA is enabled. */
++              if (rc != -ESHUTDOWN && !(rc == -EOPNOTSUPP &&
++                                              req->length == 0))
++                      WARNING(fsg, "error in submission: %s --> %d\n",
++                                      ep->name, rc);
++      }
++}
++
++
++static int sleep_thread(struct fsg_dev *fsg)
++{
++      int     rc = 0;
++
++      /* Wait until a signal arrives or we are woken up */
++      for (;;) {
++              try_to_freeze();
++              set_current_state(TASK_INTERRUPTIBLE);
++              if (signal_pending(current)) {
++                      rc = -EINTR;
++                      break;
++              }
++              if (fsg->thread_wakeup_needed)
++                      break;
++              schedule();
++      }
++      __set_current_state(TASK_RUNNING);
++      fsg->thread_wakeup_needed = 0;
++      return rc;
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static int do_read(struct fsg_dev *fsg)
++{
++      struct fsg_lun          *curlun = fsg->curlun;
++      u32                     lba;
++      struct fsg_buffhd       *bh;
++      int                     rc;
++      u32                     amount_left;
++      loff_t                  file_offset, file_offset_tmp;
++      unsigned int            amount;
++      ssize_t                 nread;
++
++      /* Get the starting Logical Block Address and check that it's
++       * not too big */
++      if (fsg->cmnd[0] == READ_6)
++              lba = get_unaligned_be24(&fsg->cmnd[1]);
++      else {
++              lba = get_unaligned_be32(&fsg->cmnd[2]);
++
++              /* We allow DPO (Disable Page Out = don't save data in the
++               * cache) and FUA (Force Unit Access = don't read from the
++               * cache), but we don't implement them. */
++              if ((fsg->cmnd[1] & ~0x18) != 0) {
++                      curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
++                      return -EINVAL;
++              }
++      }
++      if (lba >= curlun->num_sectors) {
++              curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
++              return -EINVAL;
++      }
++      file_offset = ((loff_t) lba) << curlun->blkbits;
++
++      /* Carry out the file reads */
++      amount_left = fsg->data_size_from_cmnd;
++      if (unlikely(amount_left == 0))
++              return -EIO;            // No default reply
++
++      for (;;) {
++
++              /* Figure out how much we need to read:
++               * Try to read the remaining amount.
++               * But don't read more than the buffer size.
++               * And don't try to read past the end of the file.
++               */
++              amount = min((unsigned int) amount_left, mod_data.buflen);
++              amount = min((loff_t) amount,
++                              curlun->file_length - file_offset);
++
++              /* Wait for the next buffer to become available */
++              bh = fsg->next_buffhd_to_fill;
++              while (bh->state != BUF_STATE_EMPTY) {
++                      rc = sleep_thread(fsg);
++                      if (rc)
++                              return rc;
++              }
++
++              /* If we were asked to read past the end of file,
++               * end with an empty buffer. */
++              if (amount == 0) {
++                      curlun->sense_data =
++                                      SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
++                      curlun->sense_data_info = file_offset >> curlun->blkbits;
++                      curlun->info_valid = 1;
++                      bh->inreq->length = 0;
++                      bh->state = BUF_STATE_FULL;
++                      break;
++              }
++
++              /* Perform the read */
++              file_offset_tmp = file_offset;
++              nread = vfs_read(curlun->filp,
++                              (char __user *) bh->buf,
++                              amount, &file_offset_tmp);
++              VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
++                              (unsigned long long) file_offset,
++                              (int) nread);
++              if (signal_pending(current))
++                      return -EINTR;
++
++              if (nread < 0) {
++                      LDBG(curlun, "error in file read: %d\n",
++                                      (int) nread);
++                      nread = 0;
++              } else if (nread < amount) {
++                      LDBG(curlun, "partial file read: %d/%u\n",
++                                      (int) nread, amount);
++                      nread = round_down(nread, curlun->blksize);
++              }
++              file_offset  += nread;
++              amount_left  -= nread;
++              fsg->residue -= nread;
++
++              /* Except at the end of the transfer, nread will be
++               * equal to the buffer size, which is divisible by the
++               * bulk-in maxpacket size.
++               */
++              bh->inreq->length = nread;
++              bh->state = BUF_STATE_FULL;
++
++              /* If an error occurred, report it and its position */
++              if (nread < amount) {
++                      curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
++                      curlun->sense_data_info = file_offset >> curlun->blkbits;
++                      curlun->info_valid = 1;
++                      break;
++              }
++
++              if (amount_left == 0)
++                      break;          // No more left to read
++
++              /* Send this buffer and go read some more */
++              bh->inreq->zero = 0;
++              start_transfer(fsg, fsg->bulk_in, bh->inreq,
++                              &bh->inreq_busy, &bh->state);
++              fsg->next_buffhd_to_fill = bh->next;
++      }
++
++      return -EIO;            // No default reply
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static int do_write(struct fsg_dev *fsg)
++{
++      struct fsg_lun          *curlun = fsg->curlun;
++      u32                     lba;
++      struct fsg_buffhd       *bh;
++      int                     get_some_more;
++      u32                     amount_left_to_req, amount_left_to_write;
++      loff_t                  usb_offset, file_offset, file_offset_tmp;
++      unsigned int            amount;
++      ssize_t                 nwritten;
++      int                     rc;
++
++      if (curlun->ro) {
++              curlun->sense_data = SS_WRITE_PROTECTED;
++              return -EINVAL;
++      }
++      spin_lock(&curlun->filp->f_lock);
++      curlun->filp->f_flags &= ~O_SYNC;       // Default is not to wait
++      spin_unlock(&curlun->filp->f_lock);
++
++      /* Get the starting Logical Block Address and check that it's
++       * not too big */
++      if (fsg->cmnd[0] == WRITE_6)
++              lba = get_unaligned_be24(&fsg->cmnd[1]);
++      else {
++              lba = get_unaligned_be32(&fsg->cmnd[2]);
++
++              /* We allow DPO (Disable Page Out = don't save data in the
++               * cache) and FUA (Force Unit Access = write directly to the
++               * medium).  We don't implement DPO; we implement FUA by
++               * performing synchronous output. */
++              if ((fsg->cmnd[1] & ~0x18) != 0) {
++                      curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
++                      return -EINVAL;
++              }
++              /* FUA */
++              if (!curlun->nofua && (fsg->cmnd[1] & 0x08)) {
++                      spin_lock(&curlun->filp->f_lock);
++                      curlun->filp->f_flags |= O_DSYNC;
++                      spin_unlock(&curlun->filp->f_lock);
++              }
++      }
++      if (lba >= curlun->num_sectors) {
++              curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
++              return -EINVAL;
++      }
++
++      /* Carry out the file writes */
++      get_some_more = 1;
++      file_offset = usb_offset = ((loff_t) lba) << curlun->blkbits;
++      amount_left_to_req = amount_left_to_write = fsg->data_size_from_cmnd;
++
++      while (amount_left_to_write > 0) {
++
++              /* Queue a request for more data from the host */
++              bh = fsg->next_buffhd_to_fill;
++              if (bh->state == BUF_STATE_EMPTY && get_some_more) {
++
++                      /* Figure out how much we want to get:
++                       * Try to get the remaining amount,
++                       * but not more than the buffer size.
++                       */
++                      amount = min(amount_left_to_req, mod_data.buflen);
++
++                      /* Beyond the end of the backing file? */
++                      if (usb_offset >= curlun->file_length) {
++                              get_some_more = 0;
++                              curlun->sense_data =
++                                      SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
++                              curlun->sense_data_info = usb_offset >> curlun->blkbits;
++                              curlun->info_valid = 1;
++                              continue;
++                      }
++
++                      /* Get the next buffer */
++                      usb_offset += amount;
++                      fsg->usb_amount_left -= amount;
++                      amount_left_to_req -= amount;
++                      if (amount_left_to_req == 0)
++                              get_some_more = 0;
++
++                      /* Except at the end of the transfer, amount will be
++                       * equal to the buffer size, which is divisible by
++                       * the bulk-out maxpacket size.
++                       */
++                      set_bulk_out_req_length(fsg, bh, amount);
++                      start_transfer(fsg, fsg->bulk_out, bh->outreq,
++                                      &bh->outreq_busy, &bh->state);
++                      fsg->next_buffhd_to_fill = bh->next;
++                      continue;
++              }
++
++              /* Write the received data to the backing file */
++              bh = fsg->next_buffhd_to_drain;
++              if (bh->state == BUF_STATE_EMPTY && !get_some_more)
++                      break;                  // We stopped early
++              if (bh->state == BUF_STATE_FULL) {
++                      smp_rmb();
++                      fsg->next_buffhd_to_drain = bh->next;
++                      bh->state = BUF_STATE_EMPTY;
++
++                      /* Did something go wrong with the transfer? */
++                      if (bh->outreq->status != 0) {
++                              curlun->sense_data = SS_COMMUNICATION_FAILURE;
++                              curlun->sense_data_info = file_offset >> curlun->blkbits;
++                              curlun->info_valid = 1;
++                              break;
++                      }
++
++                      amount = bh->outreq->actual;
++                      if (curlun->file_length - file_offset < amount) {
++                              LERROR(curlun,
++      "write %u @ %llu beyond end %llu\n",
++      amount, (unsigned long long) file_offset,
++      (unsigned long long) curlun->file_length);
++                              amount = curlun->file_length - file_offset;
++                      }
++
++                      /* Don't accept excess data.  The spec doesn't say
++                       * what to do in this case.  We'll ignore the error.
++                       */
++                      amount = min(amount, bh->bulk_out_intended_length);
++
++                      /* Don't write a partial block */
++                      amount = round_down(amount, curlun->blksize);
++                      if (amount == 0)
++                              goto empty_write;
++
++                      /* Perform the write */
++                      file_offset_tmp = file_offset;
++                      nwritten = vfs_write(curlun->filp,
++                                      (char __user *) bh->buf,
++                                      amount, &file_offset_tmp);
++                      VLDBG(curlun, "file write %u @ %llu -> %d\n", amount,
++                                      (unsigned long long) file_offset,
++                                      (int) nwritten);
++                      if (signal_pending(current))
++                              return -EINTR;          // Interrupted!
++
++                      if (nwritten < 0) {
++                              LDBG(curlun, "error in file write: %d\n",
++                                              (int) nwritten);
++                              nwritten = 0;
++                      } else if (nwritten < amount) {
++                              LDBG(curlun, "partial file write: %d/%u\n",
++                                              (int) nwritten, amount);
++                              nwritten = round_down(nwritten, curlun->blksize);
++                      }
++                      file_offset += nwritten;
++                      amount_left_to_write -= nwritten;
++                      fsg->residue -= nwritten;
++
++                      /* If an error occurred, report it and its position */
++                      if (nwritten < amount) {
++                              curlun->sense_data = SS_WRITE_ERROR;
++                              curlun->sense_data_info = file_offset >> curlun->blkbits;
++                              curlun->info_valid = 1;
++                              break;
++                      }
++
++ empty_write:
++                      /* Did the host decide to stop early? */
++                      if (bh->outreq->actual < bh->bulk_out_intended_length) {
++                              fsg->short_packet_received = 1;
++                              break;
++                      }
++                      continue;
++              }
++
++              /* Wait for something to happen */
++              rc = sleep_thread(fsg);
++              if (rc)
++                      return rc;
++      }
++
++      return -EIO;            // No default reply
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static int do_synchronize_cache(struct fsg_dev *fsg)
++{
++      struct fsg_lun  *curlun = fsg->curlun;
++      int             rc;
++
++      /* We ignore the requested LBA and write out all file's
++       * dirty data buffers. */
++      rc = fsg_lun_fsync_sub(curlun);
++      if (rc)
++              curlun->sense_data = SS_WRITE_ERROR;
++      return 0;
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static void invalidate_sub(struct fsg_lun *curlun)
++{
++      struct file     *filp = curlun->filp;
++      struct inode    *inode = filp->f_path.dentry->d_inode;
++      unsigned long   rc;
++
++      rc = invalidate_mapping_pages(inode->i_mapping, 0, -1);
++      VLDBG(curlun, "invalidate_mapping_pages -> %ld\n", rc);
++}
++
++static int do_verify(struct fsg_dev *fsg)
++{
++      struct fsg_lun          *curlun = fsg->curlun;
++      u32                     lba;
++      u32                     verification_length;
++      struct fsg_buffhd       *bh = fsg->next_buffhd_to_fill;
++      loff_t                  file_offset, file_offset_tmp;
++      u32                     amount_left;
++      unsigned int            amount;
++      ssize_t                 nread;
++
++      /* Get the starting Logical Block Address and check that it's
++       * not too big */
++      lba = get_unaligned_be32(&fsg->cmnd[2]);
++      if (lba >= curlun->num_sectors) {
++              curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
++              return -EINVAL;
++      }
++
++      /* We allow DPO (Disable Page Out = don't save data in the
++       * cache) but we don't implement it. */
++      if ((fsg->cmnd[1] & ~0x10) != 0) {
++              curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
++              return -EINVAL;
++      }
++
++      verification_length = get_unaligned_be16(&fsg->cmnd[7]);
++      if (unlikely(verification_length == 0))
++              return -EIO;            // No default reply
++
++      /* Prepare to carry out the file verify */
++      amount_left = verification_length << curlun->blkbits;
++      file_offset = ((loff_t) lba) << curlun->blkbits;
++
++      /* Write out all the dirty buffers before invalidating them */
++      fsg_lun_fsync_sub(curlun);
++      if (signal_pending(current))
++              return -EINTR;
++
++      invalidate_sub(curlun);
++      if (signal_pending(current))
++              return -EINTR;
++
++      /* Just try to read the requested blocks */
++      while (amount_left > 0) {
++
++              /* Figure out how much we need to read:
++               * Try to read the remaining amount, but not more than
++               * the buffer size.
++               * And don't try to read past the end of the file.
++               */
++              amount = min((unsigned int) amount_left, mod_data.buflen);
++              amount = min((loff_t) amount,
++                              curlun->file_length - file_offset);
++              if (amount == 0) {
++                      curlun->sense_data =
++                                      SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
++                      curlun->sense_data_info = file_offset >> curlun->blkbits;
++                      curlun->info_valid = 1;
++                      break;
++              }
++
++              /* Perform the read */
++              file_offset_tmp = file_offset;
++              nread = vfs_read(curlun->filp,
++                              (char __user *) bh->buf,
++                              amount, &file_offset_tmp);
++              VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
++                              (unsigned long long) file_offset,
++                              (int) nread);
++              if (signal_pending(current))
++                      return -EINTR;
++
++              if (nread < 0) {
++                      LDBG(curlun, "error in file verify: %d\n",
++                                      (int) nread);
++                      nread = 0;
++              } else if (nread < amount) {
++                      LDBG(curlun, "partial file verify: %d/%u\n",
++                                      (int) nread, amount);
++                      nread = round_down(nread, curlun->blksize);
++              }
++              if (nread == 0) {
++                      curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
++                      curlun->sense_data_info = file_offset >> curlun->blkbits;
++                      curlun->info_valid = 1;
++                      break;
++              }
++              file_offset += nread;
++              amount_left -= nread;
++      }
++      return 0;
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static int do_inquiry(struct fsg_dev *fsg, struct fsg_buffhd *bh)
++{
++      u8      *buf = (u8 *) bh->buf;
++
++      static char vendor_id[] = "Linux   ";
++      static char product_disk_id[] = "File-Stor Gadget";
++      static char product_cdrom_id[] = "File-CD Gadget  ";
++
++      if (!fsg->curlun) {             // Unsupported LUNs are okay
++              fsg->bad_lun_okay = 1;
++              memset(buf, 0, 36);
++              buf[0] = 0x7f;          // Unsupported, no device-type
++              buf[4] = 31;            // Additional length
++              return 36;
++      }
++
++      memset(buf, 0, 8);
++      buf[0] = (mod_data.cdrom ? TYPE_ROM : TYPE_DISK);
++      if (mod_data.removable)
++              buf[1] = 0x80;
++      buf[2] = 2;             // ANSI SCSI level 2
++      buf[3] = 2;             // SCSI-2 INQUIRY data format
++      buf[4] = 31;            // Additional length
++                              // No special options
++      sprintf(buf + 8, "%-8s%-16s%04x", vendor_id,
++                      (mod_data.cdrom ? product_cdrom_id :
++                              product_disk_id),
++                      mod_data.release);
++      return 36;
++}
++
++
++static int do_request_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
++{
++      struct fsg_lun  *curlun = fsg->curlun;
++      u8              *buf = (u8 *) bh->buf;
++      u32             sd, sdinfo;
++      int             valid;
++
++      /*
++       * From the SCSI-2 spec., section 7.9 (Unit attention condition):
++       *
++       * If a REQUEST SENSE command is received from an initiator
++       * with a pending unit attention condition (before the target
++       * generates the contingent allegiance condition), then the
++       * target shall either:
++       *   a) report any pending sense data and preserve the unit
++       *      attention condition on the logical unit, or,
++       *   b) report the unit attention condition, may discard any
++       *      pending sense data, and clear the unit attention
++       *      condition on the logical unit for that initiator.
++       *
++       * FSG normally uses option a); enable this code to use option b).
++       */
++#if 0
++      if (curlun && curlun->unit_attention_data != SS_NO_SENSE) {
++              curlun->sense_data = curlun->unit_attention_data;
++              curlun->unit_attention_data = SS_NO_SENSE;
++      }
++#endif
++
++      if (!curlun) {          // Unsupported LUNs are okay
++              fsg->bad_lun_okay = 1;
++              sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
++              sdinfo = 0;
++              valid = 0;
++      } else {
++              sd = curlun->sense_data;
++              sdinfo = curlun->sense_data_info;
++              valid = curlun->info_valid << 7;
++              curlun->sense_data = SS_NO_SENSE;
++              curlun->sense_data_info = 0;
++              curlun->info_valid = 0;
++      }
++
++      memset(buf, 0, 18);
++      buf[0] = valid | 0x70;                  // Valid, current error
++      buf[2] = SK(sd);
++      put_unaligned_be32(sdinfo, &buf[3]);    /* Sense information */
++      buf[7] = 18 - 8;                        // Additional sense length
++      buf[12] = ASC(sd);
++      buf[13] = ASCQ(sd);
++      return 18;
++}
++
++
++static int do_read_capacity(struct fsg_dev *fsg, struct fsg_buffhd *bh)
++{
++      struct fsg_lun  *curlun = fsg->curlun;
++      u32             lba = get_unaligned_be32(&fsg->cmnd[2]);
++      int             pmi = fsg->cmnd[8];
++      u8              *buf = (u8 *) bh->buf;
++
++      /* Check the PMI and LBA fields */
++      if (pmi > 1 || (pmi == 0 && lba != 0)) {
++              curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
++              return -EINVAL;
++      }
++
++      put_unaligned_be32(curlun->num_sectors - 1, &buf[0]);
++                                              /* Max logical block */
++      put_unaligned_be32(curlun->blksize, &buf[4]);   /* Block length */
++      return 8;
++}
++
++
++static int do_read_header(struct fsg_dev *fsg, struct fsg_buffhd *bh)
++{
++      struct fsg_lun  *curlun = fsg->curlun;
++      int             msf = fsg->cmnd[1] & 0x02;
++      u32             lba = get_unaligned_be32(&fsg->cmnd[2]);
++      u8              *buf = (u8 *) bh->buf;
++
++      if ((fsg->cmnd[1] & ~0x02) != 0) {              /* Mask away MSF */
++              curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
++              return -EINVAL;
++      }
++      if (lba >= curlun->num_sectors) {
++              curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
++              return -EINVAL;
++      }
++
++      memset(buf, 0, 8);
++      buf[0] = 0x01;          /* 2048 bytes of user data, rest is EC */
++      store_cdrom_address(&buf[4], msf, lba);
++      return 8;
++}
++
++
++static int do_read_toc(struct fsg_dev *fsg, struct fsg_buffhd *bh)
++{
++      struct fsg_lun  *curlun = fsg->curlun;
++      int             msf = fsg->cmnd[1] & 0x02;
++      int             start_track = fsg->cmnd[6];
++      u8              *buf = (u8 *) bh->buf;
++
++      if ((fsg->cmnd[1] & ~0x02) != 0 ||              /* Mask away MSF */
++                      start_track > 1) {
++              curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
++              return -EINVAL;
++      }
++
++      memset(buf, 0, 20);
++      buf[1] = (20-2);                /* TOC data length */
++      buf[2] = 1;                     /* First track number */
++      buf[3] = 1;                     /* Last track number */
++      buf[5] = 0x16;                  /* Data track, copying allowed */
++      buf[6] = 0x01;                  /* Only track is number 1 */
++      store_cdrom_address(&buf[8], msf, 0);
++
++      buf[13] = 0x16;                 /* Lead-out track is data */
++      buf[14] = 0xAA;                 /* Lead-out track number */
++      store_cdrom_address(&buf[16], msf, curlun->num_sectors);
++      return 20;
++}
++
++
++static int do_mode_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
++{
++      struct fsg_lun  *curlun = fsg->curlun;
++      int             mscmnd = fsg->cmnd[0];
++      u8              *buf = (u8 *) bh->buf;
++      u8              *buf0 = buf;
++      int             pc, page_code;
++      int             changeable_values, all_pages;
++      int             valid_page = 0;
++      int             len, limit;
++
++      if ((fsg->cmnd[1] & ~0x08) != 0) {              // Mask away DBD
++              curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
++              return -EINVAL;
++      }
++      pc = fsg->cmnd[2] >> 6;
++      page_code = fsg->cmnd[2] & 0x3f;
++      if (pc == 3) {
++              curlun->sense_data = SS_SAVING_PARAMETERS_NOT_SUPPORTED;
++              return -EINVAL;
++      }
++      changeable_values = (pc == 1);
++      all_pages = (page_code == 0x3f);
++
++      /* Write the mode parameter header.  Fixed values are: default
++       * medium type, no cache control (DPOFUA), and no block descriptors.
++       * The only variable value is the WriteProtect bit.  We will fill in
++       * the mode data length later. */
++      memset(buf, 0, 8);
++      if (mscmnd == MODE_SENSE) {
++              buf[2] = (curlun->ro ? 0x80 : 0x00);            // WP, DPOFUA
++              buf += 4;
++              limit = 255;
++      } else {                        // MODE_SENSE_10
++              buf[3] = (curlun->ro ? 0x80 : 0x00);            // WP, DPOFUA
++              buf += 8;
++              limit = 65535;          // Should really be mod_data.buflen
++      }
++
++      /* No block descriptors */
++
++      /* The mode pages, in numerical order.  The only page we support
++       * is the Caching page. */
++      if (page_code == 0x08 || all_pages) {
++              valid_page = 1;
++              buf[0] = 0x08;          // Page code
++              buf[1] = 10;            // Page length
++              memset(buf+2, 0, 10);   // None of the fields are changeable
++
++              if (!changeable_values) {
++                      buf[2] = 0x04;  // Write cache enable,
++                                      // Read cache not disabled
++                                      // No cache retention priorities
++                      put_unaligned_be16(0xffff, &buf[4]);
++                                      /* Don't disable prefetch */
++                                      /* Minimum prefetch = 0 */
++                      put_unaligned_be16(0xffff, &buf[8]);
++                                      /* Maximum prefetch */
++                      put_unaligned_be16(0xffff, &buf[10]);
++                                      /* Maximum prefetch ceiling */
++              }
++              buf += 12;
++      }
++
++      /* Check that a valid page was requested and the mode data length
++       * isn't too long. */
++      len = buf - buf0;
++      if (!valid_page || len > limit) {
++              curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
++              return -EINVAL;
++      }
++
++      /*  Store the mode data length */
++      if (mscmnd == MODE_SENSE)
++              buf0[0] = len - 1;
++      else
++              put_unaligned_be16(len - 2, buf0);
++      return len;
++}
++
++
++static int do_start_stop(struct fsg_dev *fsg)
++{
++      struct fsg_lun  *curlun = fsg->curlun;
++      int             loej, start;
++
++      if (!mod_data.removable) {
++              curlun->sense_data = SS_INVALID_COMMAND;
++              return -EINVAL;
++      }
++
++      // int immed = fsg->cmnd[1] & 0x01;
++      loej = fsg->cmnd[4] & 0x02;
++      start = fsg->cmnd[4] & 0x01;
++
++#ifdef CONFIG_USB_FILE_STORAGE_TEST
++      if ((fsg->cmnd[1] & ~0x01) != 0 ||              // Mask away Immed
++                      (fsg->cmnd[4] & ~0x03) != 0) {  // Mask LoEj, Start
++              curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
++              return -EINVAL;
++      }
++
++      if (!start) {
++
++              /* Are we allowed to unload the media? */
++              if (curlun->prevent_medium_removal) {
++                      LDBG(curlun, "unload attempt prevented\n");
++                      curlun->sense_data = SS_MEDIUM_REMOVAL_PREVENTED;
++                      return -EINVAL;
++              }
++              if (loej) {             // Simulate an unload/eject
++                      up_read(&fsg->filesem);
++                      down_write(&fsg->filesem);
++                      fsg_lun_close(curlun);
++                      up_write(&fsg->filesem);
++                      down_read(&fsg->filesem);
++              }
++      } else {
++
++              /* Our emulation doesn't support mounting; the medium is
++               * available for use as soon as it is loaded. */
++              if (!fsg_lun_is_open(curlun)) {
++                      curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
++                      return -EINVAL;
++              }
++      }
++#endif
++      return 0;
++}
++
++
++static int do_prevent_allow(struct fsg_dev *fsg)
++{
++      struct fsg_lun  *curlun = fsg->curlun;
++      int             prevent;
++
++      if (!mod_data.removable) {
++              curlun->sense_data = SS_INVALID_COMMAND;
++              return -EINVAL;
++      }
++
++      prevent = fsg->cmnd[4] & 0x01;
++      if ((fsg->cmnd[4] & ~0x01) != 0) {              // Mask away Prevent
++              curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
++              return -EINVAL;
++      }
++
++      if (curlun->prevent_medium_removal && !prevent)
++              fsg_lun_fsync_sub(curlun);
++      curlun->prevent_medium_removal = prevent;
++      return 0;
++}
++
++
++static int do_read_format_capacities(struct fsg_dev *fsg,
++                      struct fsg_buffhd *bh)
++{
++      struct fsg_lun  *curlun = fsg->curlun;
++      u8              *buf = (u8 *) bh->buf;
++
++      buf[0] = buf[1] = buf[2] = 0;
++      buf[3] = 8;             // Only the Current/Maximum Capacity Descriptor
++      buf += 4;
++
++      put_unaligned_be32(curlun->num_sectors, &buf[0]);
++                                              /* Number of blocks */
++      put_unaligned_be32(curlun->blksize, &buf[4]);   /* Block length */
++      buf[4] = 0x02;                          /* Current capacity */
++      return 12;
++}
++
++
++static int do_mode_select(struct fsg_dev *fsg, struct fsg_buffhd *bh)
++{
++      struct fsg_lun  *curlun = fsg->curlun;
++
++      /* We don't support MODE SELECT */
++      curlun->sense_data = SS_INVALID_COMMAND;
++      return -EINVAL;
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static int halt_bulk_in_endpoint(struct fsg_dev *fsg)
++{
++      int     rc;
++
++      rc = fsg_set_halt(fsg, fsg->bulk_in);
++      if (rc == -EAGAIN)
++              VDBG(fsg, "delayed bulk-in endpoint halt\n");
++      while (rc != 0) {
++              if (rc != -EAGAIN) {
++                      WARNING(fsg, "usb_ep_set_halt -> %d\n", rc);
++                      rc = 0;
++                      break;
++              }
++
++              /* Wait for a short time and then try again */
++              if (msleep_interruptible(100) != 0)
++                      return -EINTR;
++              rc = usb_ep_set_halt(fsg->bulk_in);
++      }
++      return rc;
++}
++
++static int wedge_bulk_in_endpoint(struct fsg_dev *fsg)
++{
++      int     rc;
++
++      DBG(fsg, "bulk-in set wedge\n");
++      rc = usb_ep_set_wedge(fsg->bulk_in);
++      if (rc == -EAGAIN)
++              VDBG(fsg, "delayed bulk-in endpoint wedge\n");
++      while (rc != 0) {
++              if (rc != -EAGAIN) {
++                      WARNING(fsg, "usb_ep_set_wedge -> %d\n", rc);
++                      rc = 0;
++                      break;
++              }
++
++              /* Wait for a short time and then try again */
++              if (msleep_interruptible(100) != 0)
++                      return -EINTR;
++              rc = usb_ep_set_wedge(fsg->bulk_in);
++      }
++      return rc;
++}
++
++static int throw_away_data(struct fsg_dev *fsg)
++{
++      struct fsg_buffhd       *bh;
++      u32                     amount;
++      int                     rc;
++
++      while ((bh = fsg->next_buffhd_to_drain)->state != BUF_STATE_EMPTY ||
++                      fsg->usb_amount_left > 0) {
++
++              /* Throw away the data in a filled buffer */
++              if (bh->state == BUF_STATE_FULL) {
++                      smp_rmb();
++                      bh->state = BUF_STATE_EMPTY;
++                      fsg->next_buffhd_to_drain = bh->next;
++
++                      /* A short packet or an error ends everything */
++                      if (bh->outreq->actual < bh->bulk_out_intended_length ||
++                                      bh->outreq->status != 0) {
++                              raise_exception(fsg, FSG_STATE_ABORT_BULK_OUT);
++                              return -EINTR;
++                      }
++                      continue;
++              }
++
++              /* Try to submit another request if we need one */
++              bh = fsg->next_buffhd_to_fill;
++              if (bh->state == BUF_STATE_EMPTY && fsg->usb_amount_left > 0) {
++                      amount = min(fsg->usb_amount_left,
++                                      (u32) mod_data.buflen);
++
++                      /* Except at the end of the transfer, amount will be
++                       * equal to the buffer size, which is divisible by
++                       * the bulk-out maxpacket size.
++                       */
++                      set_bulk_out_req_length(fsg, bh, amount);
++                      start_transfer(fsg, fsg->bulk_out, bh->outreq,
++                                      &bh->outreq_busy, &bh->state);
++                      fsg->next_buffhd_to_fill = bh->next;
++                      fsg->usb_amount_left -= amount;
++                      continue;
++              }
++
++              /* Otherwise wait for something to happen */
++              rc = sleep_thread(fsg);
++              if (rc)
++                      return rc;
++      }
++      return 0;
++}
++
++
++static int finish_reply(struct fsg_dev *fsg)
++{
++      struct fsg_buffhd       *bh = fsg->next_buffhd_to_fill;
++      int                     rc = 0;
++
++      switch (fsg->data_dir) {
++      case DATA_DIR_NONE:
++              break;                  // Nothing to send
++
++      /* If we don't know whether the host wants to read or write,
++       * this must be CB or CBI with an unknown command.  We mustn't
++       * try to send or receive any data.  So stall both bulk pipes
++       * if we can and wait for a reset. */
++      case DATA_DIR_UNKNOWN:
++              if (mod_data.can_stall) {
++                      fsg_set_halt(fsg, fsg->bulk_out);
++                      rc = halt_bulk_in_endpoint(fsg);
++              }
++              break;
++
++      /* All but the last buffer of data must have already been sent */
++      case DATA_DIR_TO_HOST:
++              if (fsg->data_size == 0)
++                      ;               // Nothing to send
++
++              /* If there's no residue, simply send the last buffer */
++              else if (fsg->residue == 0) {
++                      bh->inreq->zero = 0;
++                      start_transfer(fsg, fsg->bulk_in, bh->inreq,
++                                      &bh->inreq_busy, &bh->state);
++                      fsg->next_buffhd_to_fill = bh->next;
++              }
++
++              /* There is a residue.  For CB and CBI, simply mark the end
++               * of the data with a short packet.  However, if we are
++               * allowed to stall, there was no data at all (residue ==
++               * data_size), and the command failed (invalid LUN or
++               * sense data is set), then halt the bulk-in endpoint
++               * instead. */
++              else if (!transport_is_bbb()) {
++                      if (mod_data.can_stall &&
++                                      fsg->residue == fsg->data_size &&
++      (!fsg->curlun || fsg->curlun->sense_data != SS_NO_SENSE)) {
++                              bh->state = BUF_STATE_EMPTY;
++                              rc = halt_bulk_in_endpoint(fsg);
++                      } else {
++                              bh->inreq->zero = 1;
++                              start_transfer(fsg, fsg->bulk_in, bh->inreq,
++                                              &bh->inreq_busy, &bh->state);
++                              fsg->next_buffhd_to_fill = bh->next;
++                      }
++              }
++
++              /*
++               * For Bulk-only, mark the end of the data with a short
++               * packet.  If we are allowed to stall, halt the bulk-in
++               * endpoint.  (Note: This violates the Bulk-Only Transport
++               * specification, which requires us to pad the data if we
++               * don't halt the endpoint.  Presumably nobody will mind.)
++               */
++              else {
++                      bh->inreq->zero = 1;
++                      start_transfer(fsg, fsg->bulk_in, bh->inreq,
++                                      &bh->inreq_busy, &bh->state);
++                      fsg->next_buffhd_to_fill = bh->next;
++                      if (mod_data.can_stall)
++                              rc = halt_bulk_in_endpoint(fsg);
++              }
++              break;
++
++      /* We have processed all we want from the data the host has sent.
++       * There may still be outstanding bulk-out requests. */
++      case DATA_DIR_FROM_HOST:
++              if (fsg->residue == 0)
++                      ;               // Nothing to receive
++
++              /* Did the host stop sending unexpectedly early? */
++              else if (fsg->short_packet_received) {
++                      raise_exception(fsg, FSG_STATE_ABORT_BULK_OUT);
++                      rc = -EINTR;
++              }
++
++              /* We haven't processed all the incoming data.  Even though
++               * we may be allowed to stall, doing so would cause a race.
++               * The controller may already have ACK'ed all the remaining
++               * bulk-out packets, in which case the host wouldn't see a
++               * STALL.  Not realizing the endpoint was halted, it wouldn't
++               * clear the halt -- leading to problems later on. */
++#if 0
++              else if (mod_data.can_stall) {
++                      fsg_set_halt(fsg, fsg->bulk_out);
++                      raise_exception(fsg, FSG_STATE_ABORT_BULK_OUT);
++                      rc = -EINTR;
++              }
++#endif
++
++              /* We can't stall.  Read in the excess data and throw it
++               * all away. */
++              else
++                      rc = throw_away_data(fsg);
++              break;
++      }
++      return rc;
++}
++
++
++static int send_status(struct fsg_dev *fsg)
++{
++      struct fsg_lun          *curlun = fsg->curlun;
++      struct fsg_buffhd       *bh;
++      int                     rc;
++      u8                      status = US_BULK_STAT_OK;
++      u32                     sd, sdinfo = 0;
++
++      /* Wait for the next buffer to become available */
++      bh = fsg->next_buffhd_to_fill;
++      while (bh->state != BUF_STATE_EMPTY) {
++              rc = sleep_thread(fsg);
++              if (rc)
++                      return rc;
++      }
++
++      if (curlun) {
++              sd = curlun->sense_data;
++              sdinfo = curlun->sense_data_info;
++      } else if (fsg->bad_lun_okay)
++              sd = SS_NO_SENSE;
++      else
++              sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
++
++      if (fsg->phase_error) {
++              DBG(fsg, "sending phase-error status\n");
++              status = US_BULK_STAT_PHASE;
++              sd = SS_INVALID_COMMAND;
++      } else if (sd != SS_NO_SENSE) {
++              DBG(fsg, "sending command-failure status\n");
++              status = US_BULK_STAT_FAIL;
++              VDBG(fsg, "  sense data: SK x%02x, ASC x%02x, ASCQ x%02x;"
++                              "  info x%x\n",
++                              SK(sd), ASC(sd), ASCQ(sd), sdinfo);
++      }
++
++      if (transport_is_bbb()) {
++              struct bulk_cs_wrap     *csw = bh->buf;
++
++              /* Store and send the Bulk-only CSW */
++              csw->Signature = cpu_to_le32(US_BULK_CS_SIGN);
++              csw->Tag = fsg->tag;
++              csw->Residue = cpu_to_le32(fsg->residue);
++              csw->Status = status;
++
++              bh->inreq->length = US_BULK_CS_WRAP_LEN;
++              bh->inreq->zero = 0;
++              start_transfer(fsg, fsg->bulk_in, bh->inreq,
++                              &bh->inreq_busy, &bh->state);
++
++      } else if (mod_data.transport_type == USB_PR_CB) {
++
++              /* Control-Bulk transport has no status phase! */
++              return 0;
++
++      } else {                        // USB_PR_CBI
++              struct interrupt_data   *buf = bh->buf;
++
++              /* Store and send the Interrupt data.  UFI sends the ASC
++               * and ASCQ bytes.  Everything else sends a Type (which
++               * is always 0) and the status Value. */
++              if (mod_data.protocol_type == USB_SC_UFI) {
++                      buf->bType = ASC(sd);
++                      buf->bValue = ASCQ(sd);
++              } else {
++                      buf->bType = 0;
++                      buf->bValue = status;
++              }
++              fsg->intreq->length = CBI_INTERRUPT_DATA_LEN;
++
++              fsg->intr_buffhd = bh;          // Point to the right buffhd
++              fsg->intreq->buf = bh->inreq->buf;
++              fsg->intreq->context = bh;
++              start_transfer(fsg, fsg->intr_in, fsg->intreq,
++                              &fsg->intreq_busy, &bh->state);
++      }
++
++      fsg->next_buffhd_to_fill = bh->next;
++      return 0;
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++/* Check whether the command is properly formed and whether its data size
++ * and direction agree with the values we already have. */
++static int check_command(struct fsg_dev *fsg, int cmnd_size,
++              enum data_direction data_dir, unsigned int mask,
++              int needs_medium, const char *name)
++{
++      int                     i;
++      int                     lun = fsg->cmnd[1] >> 5;
++      static const char       dirletter[4] = {'u', 'o', 'i', 'n'};
++      char                    hdlen[20];
++      struct fsg_lun          *curlun;
++
++      /* Adjust the expected cmnd_size for protocol encapsulation padding.
++       * Transparent SCSI doesn't pad. */
++      if (protocol_is_scsi())
++              ;
++
++      /* There's some disagreement as to whether RBC pads commands or not.
++       * We'll play it safe and accept either form. */
++      else if (mod_data.protocol_type == USB_SC_RBC) {
++              if (fsg->cmnd_size == 12)
++                      cmnd_size = 12;
++
++      /* All the other protocols pad to 12 bytes */
++      } else
++              cmnd_size = 12;
++
++      hdlen[0] = 0;
++      if (fsg->data_dir != DATA_DIR_UNKNOWN)
++              sprintf(hdlen, ", H%c=%u", dirletter[(int) fsg->data_dir],
++                              fsg->data_size);
++      VDBG(fsg, "SCSI command: %s;  Dc=%d, D%c=%u;  Hc=%d%s\n",
++                      name, cmnd_size, dirletter[(int) data_dir],
++                      fsg->data_size_from_cmnd, fsg->cmnd_size, hdlen);
++
++      /* We can't reply at all until we know the correct data direction
++       * and size. */
++      if (fsg->data_size_from_cmnd == 0)
++              data_dir = DATA_DIR_NONE;
++      if (fsg->data_dir == DATA_DIR_UNKNOWN) {        // CB or CBI
++              fsg->data_dir = data_dir;
++              fsg->data_size = fsg->data_size_from_cmnd;
++
++      } else {                                        // Bulk-only
++              if (fsg->data_size < fsg->data_size_from_cmnd) {
++
++                      /* Host data size < Device data size is a phase error.
++                       * Carry out the command, but only transfer as much
++                       * as we are allowed. */
++                      fsg->data_size_from_cmnd = fsg->data_size;
++                      fsg->phase_error = 1;
++              }
++      }
++      fsg->residue = fsg->usb_amount_left = fsg->data_size;
++
++      /* Conflicting data directions is a phase error */
++      if (fsg->data_dir != data_dir && fsg->data_size_from_cmnd > 0) {
++              fsg->phase_error = 1;
++              return -EINVAL;
++      }
++
++      /* Verify the length of the command itself */
++      if (cmnd_size != fsg->cmnd_size) {
++
++              /* Special case workaround: There are plenty of buggy SCSI
++               * implementations. Many have issues with cbw->Length
++               * field passing a wrong command size. For those cases we
++               * always try to work around the problem by using the length
++               * sent by the host side provided it is at least as large
++               * as the correct command length.
++               * Examples of such cases would be MS-Windows, which issues
++               * REQUEST SENSE with cbw->Length == 12 where it should
++               * be 6, and xbox360 issuing INQUIRY, TEST UNIT READY and
++               * REQUEST SENSE with cbw->Length == 10 where it should
++               * be 6 as well.
++               */
++              if (cmnd_size <= fsg->cmnd_size) {
++                      DBG(fsg, "%s is buggy! Expected length %d "
++                                      "but we got %d\n", name,
++                                      cmnd_size, fsg->cmnd_size);
++                      cmnd_size = fsg->cmnd_size;
++              } else {
++                      fsg->phase_error = 1;
++                      return -EINVAL;
++              }
++      }
++
++      /* Check that the LUN values are consistent */
++      if (transport_is_bbb()) {
++              if (fsg->lun != lun)
++                      DBG(fsg, "using LUN %d from CBW, "
++                                      "not LUN %d from CDB\n",
++                                      fsg->lun, lun);
++      }
++
++      /* Check the LUN */
++      curlun = fsg->curlun;
++      if (curlun) {
++              if (fsg->cmnd[0] != REQUEST_SENSE) {
++                      curlun->sense_data = SS_NO_SENSE;
++                      curlun->sense_data_info = 0;
++                      curlun->info_valid = 0;
++              }
++      } else {
++              fsg->bad_lun_okay = 0;
++
++              /* INQUIRY and REQUEST SENSE commands are explicitly allowed
++               * to use unsupported LUNs; all others may not. */
++              if (fsg->cmnd[0] != INQUIRY &&
++                              fsg->cmnd[0] != REQUEST_SENSE) {
++                      DBG(fsg, "unsupported LUN %d\n", fsg->lun);
++                      return -EINVAL;
++              }
++      }
++
++      /* If a unit attention condition exists, only INQUIRY and
++       * REQUEST SENSE commands are allowed; anything else must fail. */
++      if (curlun && curlun->unit_attention_data != SS_NO_SENSE &&
++                      fsg->cmnd[0] != INQUIRY &&
++                      fsg->cmnd[0] != REQUEST_SENSE) {
++              curlun->sense_data = curlun->unit_attention_data;
++              curlun->unit_attention_data = SS_NO_SENSE;
++              return -EINVAL;
++      }
++
++      /* Check that only command bytes listed in the mask are non-zero */
++      fsg->cmnd[1] &= 0x1f;                   // Mask away the LUN
++      for (i = 1; i < cmnd_size; ++i) {
++              if (fsg->cmnd[i] && !(mask & (1 << i))) {
++                      if (curlun)
++                              curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
++                      return -EINVAL;
++              }
++      }
++
++      /* If the medium isn't mounted and the command needs to access
++       * it, return an error. */
++      if (curlun && !fsg_lun_is_open(curlun) && needs_medium) {
++              curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
++              return -EINVAL;
++      }
++
++      return 0;
++}
++
++/* wrapper of check_command for data size in blocks handling */
++static int check_command_size_in_blocks(struct fsg_dev *fsg, int cmnd_size,
++              enum data_direction data_dir, unsigned int mask,
++              int needs_medium, const char *name)
++{
++      if (fsg->curlun)
++              fsg->data_size_from_cmnd <<= fsg->curlun->blkbits;
++      return check_command(fsg, cmnd_size, data_dir,
++                      mask, needs_medium, name);
++}
++
++static int do_scsi_command(struct fsg_dev *fsg)
++{
++      struct fsg_buffhd       *bh;
++      int                     rc;
++      int                     reply = -EINVAL;
++      int                     i;
++      static char             unknown[16];
++
++      dump_cdb(fsg);
++
++      /* Wait for the next buffer to become available for data or status */
++      bh = fsg->next_buffhd_to_drain = fsg->next_buffhd_to_fill;
++      while (bh->state != BUF_STATE_EMPTY) {
++              rc = sleep_thread(fsg);
++              if (rc)
++                      return rc;
++      }
++      fsg->phase_error = 0;
++      fsg->short_packet_received = 0;
++
++      down_read(&fsg->filesem);       // We're using the backing file
++      switch (fsg->cmnd[0]) {
++
++      case INQUIRY:
++              fsg->data_size_from_cmnd = fsg->cmnd[4];
++              if ((reply = check_command(fsg, 6, DATA_DIR_TO_HOST,
++                              (1<<4), 0,
++                              "INQUIRY")) == 0)
++                      reply = do_inquiry(fsg, bh);
++              break;
++
++      case MODE_SELECT:
++              fsg->data_size_from_cmnd = fsg->cmnd[4];
++              if ((reply = check_command(fsg, 6, DATA_DIR_FROM_HOST,
++                              (1<<1) | (1<<4), 0,
++                              "MODE SELECT(6)")) == 0)
++                      reply = do_mode_select(fsg, bh);
++              break;
++
++      case MODE_SELECT_10:
++              fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]);
++              if ((reply = check_command(fsg, 10, DATA_DIR_FROM_HOST,
++                              (1<<1) | (3<<7), 0,
++                              "MODE SELECT(10)")) == 0)
++                      reply = do_mode_select(fsg, bh);
++              break;
++
++      case MODE_SENSE:
++              fsg->data_size_from_cmnd = fsg->cmnd[4];
++              if ((reply = check_command(fsg, 6, DATA_DIR_TO_HOST,
++                              (1<<1) | (1<<2) | (1<<4), 0,
++                              "MODE SENSE(6)")) == 0)
++                      reply = do_mode_sense(fsg, bh);
++              break;
++
++      case MODE_SENSE_10:
++              fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]);
++              if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
++                              (1<<1) | (1<<2) | (3<<7), 0,
++                              "MODE SENSE(10)")) == 0)
++                      reply = do_mode_sense(fsg, bh);
++              break;
++
++      case ALLOW_MEDIUM_REMOVAL:
++              fsg->data_size_from_cmnd = 0;
++              if ((reply = check_command(fsg, 6, DATA_DIR_NONE,
++                              (1<<4), 0,
++                              "PREVENT-ALLOW MEDIUM REMOVAL")) == 0)
++                      reply = do_prevent_allow(fsg);
++              break;
++
++      case READ_6:
++              i = fsg->cmnd[4];
++              fsg->data_size_from_cmnd = (i == 0) ? 256 : i;
++              if ((reply = check_command_size_in_blocks(fsg, 6,
++                              DATA_DIR_TO_HOST,
++                              (7<<1) | (1<<4), 1,
++                              "READ(6)")) == 0)
++                      reply = do_read(fsg);
++              break;
++
++      case READ_10:
++              fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]);
++              if ((reply = check_command_size_in_blocks(fsg, 10,
++                              DATA_DIR_TO_HOST,
++                              (1<<1) | (0xf<<2) | (3<<7), 1,
++                              "READ(10)")) == 0)
++                      reply = do_read(fsg);
++              break;
++
++      case READ_12:
++              fsg->data_size_from_cmnd = get_unaligned_be32(&fsg->cmnd[6]);
++              if ((reply = check_command_size_in_blocks(fsg, 12,
++                              DATA_DIR_TO_HOST,
++                              (1<<1) | (0xf<<2) | (0xf<<6), 1,
++                              "READ(12)")) == 0)
++                      reply = do_read(fsg);
++              break;
++
++      case READ_CAPACITY:
++              fsg->data_size_from_cmnd = 8;
++              if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
++                              (0xf<<2) | (1<<8), 1,
++                              "READ CAPACITY")) == 0)
++                      reply = do_read_capacity(fsg, bh);
++              break;
++
++      case READ_HEADER:
++              if (!mod_data.cdrom)
++                      goto unknown_cmnd;
++              fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]);
++              if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
++                              (3<<7) | (0x1f<<1), 1,
++                              "READ HEADER")) == 0)
++                      reply = do_read_header(fsg, bh);
++              break;
++
++      case READ_TOC:
++              if (!mod_data.cdrom)
++                      goto unknown_cmnd;
++              fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]);
++              if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
++                              (7<<6) | (1<<1), 1,
++                              "READ TOC")) == 0)
++                      reply = do_read_toc(fsg, bh);
++              break;
++
++      case READ_FORMAT_CAPACITIES:
++              fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]);
++              if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
++                              (3<<7), 1,
++                              "READ FORMAT CAPACITIES")) == 0)
++                      reply = do_read_format_capacities(fsg, bh);
++              break;
++
++      case REQUEST_SENSE:
++              fsg->data_size_from_cmnd = fsg->cmnd[4];
++              if ((reply = check_command(fsg, 6, DATA_DIR_TO_HOST,
++                              (1<<4), 0,
++                              "REQUEST SENSE")) == 0)
++                      reply = do_request_sense(fsg, bh);
++              break;
++
++      case START_STOP:
++              fsg->data_size_from_cmnd = 0;
++              if ((reply = check_command(fsg, 6, DATA_DIR_NONE,
++                              (1<<1) | (1<<4), 0,
++                              "START-STOP UNIT")) == 0)
++                      reply = do_start_stop(fsg);
++              break;
++
++      case SYNCHRONIZE_CACHE:
++              fsg->data_size_from_cmnd = 0;
++              if ((reply = check_command(fsg, 10, DATA_DIR_NONE,
++                              (0xf<<2) | (3<<7), 1,
++                              "SYNCHRONIZE CACHE")) == 0)
++                      reply = do_synchronize_cache(fsg);
++              break;
++
++      case TEST_UNIT_READY:
++              fsg->data_size_from_cmnd = 0;
++              reply = check_command(fsg, 6, DATA_DIR_NONE,
++                              0, 1,
++                              "TEST UNIT READY");
++              break;
++
++      /* Although optional, this command is used by MS-Windows.  We
++       * support a minimal version: BytChk must be 0. */
++      case VERIFY:
++              fsg->data_size_from_cmnd = 0;
++              if ((reply = check_command(fsg, 10, DATA_DIR_NONE,
++                              (1<<1) | (0xf<<2) | (3<<7), 1,
++                              "VERIFY")) == 0)
++                      reply = do_verify(fsg);
++              break;
++
++      case WRITE_6:
++              i = fsg->cmnd[4];
++              fsg->data_size_from_cmnd = (i == 0) ? 256 : i;
++              if ((reply = check_command_size_in_blocks(fsg, 6,
++                              DATA_DIR_FROM_HOST,
++                              (7<<1) | (1<<4), 1,
++                              "WRITE(6)")) == 0)
++                      reply = do_write(fsg);
++              break;
++
++      case WRITE_10:
++              fsg->data_size_from_cmnd = get_unaligned_be16(&fsg->cmnd[7]);
++              if ((reply = check_command_size_in_blocks(fsg, 10,
++                              DATA_DIR_FROM_HOST,
++                              (1<<1) | (0xf<<2) | (3<<7), 1,
++                              "WRITE(10)")) == 0)
++                      reply = do_write(fsg);
++              break;
++
++      case WRITE_12:
++              fsg->data_size_from_cmnd = get_unaligned_be32(&fsg->cmnd[6]);
++              if ((reply = check_command_size_in_blocks(fsg, 12,
++                              DATA_DIR_FROM_HOST,
++                              (1<<1) | (0xf<<2) | (0xf<<6), 1,
++                              "WRITE(12)")) == 0)
++                      reply = do_write(fsg);
++              break;
++
++      /* Some mandatory commands that we recognize but don't implement.
++       * They don't mean much in this setting.  It's left as an exercise
++       * for anyone interested to implement RESERVE and RELEASE in terms
++       * of Posix locks. */
++      case FORMAT_UNIT:
++      case RELEASE:
++      case RESERVE:
++      case SEND_DIAGNOSTIC:
++              // Fall through
++
++      default:
++ unknown_cmnd:
++              fsg->data_size_from_cmnd = 0;
++              sprintf(unknown, "Unknown x%02x", fsg->cmnd[0]);
++              if ((reply = check_command(fsg, fsg->cmnd_size,
++                              DATA_DIR_UNKNOWN, ~0, 0, unknown)) == 0) {
++                      fsg->curlun->sense_data = SS_INVALID_COMMAND;
++                      reply = -EINVAL;
++              }
++              break;
++      }
++      up_read(&fsg->filesem);
++
++      if (reply == -EINTR || signal_pending(current))
++              return -EINTR;
++
++      /* Set up the single reply buffer for finish_reply() */
++      if (reply == -EINVAL)
++              reply = 0;              // Error reply length
++      if (reply >= 0 && fsg->data_dir == DATA_DIR_TO_HOST) {
++              reply = min((u32) reply, fsg->data_size_from_cmnd);
++              bh->inreq->length = reply;
++              bh->state = BUF_STATE_FULL;
++              fsg->residue -= reply;
++      }                               // Otherwise it's already set
++
++      return 0;
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
++{
++      struct usb_request              *req = bh->outreq;
++      struct bulk_cb_wrap     *cbw = req->buf;
++
++      /* Was this a real packet?  Should it be ignored? */
++      if (req->status || test_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags))
++              return -EINVAL;
++
++      /* Is the CBW valid? */
++      if (req->actual != US_BULK_CB_WRAP_LEN ||
++                      cbw->Signature != cpu_to_le32(
++                              US_BULK_CB_SIGN)) {
++              DBG(fsg, "invalid CBW: len %u sig 0x%x\n",
++                              req->actual,
++                              le32_to_cpu(cbw->Signature));
++
++              /* The Bulk-only spec says we MUST stall the IN endpoint
++               * (6.6.1), so it's unavoidable.  It also says we must
++               * retain this state until the next reset, but there's
++               * no way to tell the controller driver it should ignore
++               * Clear-Feature(HALT) requests.
++               *
++               * We aren't required to halt the OUT endpoint; instead
++               * we can simply accept and discard any data received
++               * until the next reset. */
++              wedge_bulk_in_endpoint(fsg);
++              set_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
++              return -EINVAL;
++      }
++
++      /* Is the CBW meaningful? */
++      if (cbw->Lun >= FSG_MAX_LUNS || cbw->Flags & ~US_BULK_FLAG_IN ||
++                      cbw->Length <= 0 || cbw->Length > MAX_COMMAND_SIZE) {
++              DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, "
++                              "cmdlen %u\n",
++                              cbw->Lun, cbw->Flags, cbw->Length);
++
++              /* We can do anything we want here, so let's stall the
++               * bulk pipes if we are allowed to. */
++              if (mod_data.can_stall) {
++                      fsg_set_halt(fsg, fsg->bulk_out);
++                      halt_bulk_in_endpoint(fsg);
++              }
++              return -EINVAL;
++      }
++
++      /* Save the command for later */
++      fsg->cmnd_size = cbw->Length;
++      memcpy(fsg->cmnd, cbw->CDB, fsg->cmnd_size);
++      if (cbw->Flags & US_BULK_FLAG_IN)
++              fsg->data_dir = DATA_DIR_TO_HOST;
++      else
++              fsg->data_dir = DATA_DIR_FROM_HOST;
++      fsg->data_size = le32_to_cpu(cbw->DataTransferLength);
++      if (fsg->data_size == 0)
++              fsg->data_dir = DATA_DIR_NONE;
++      fsg->lun = cbw->Lun;
++      fsg->tag = cbw->Tag;
++      return 0;
++}
++
++
++static int get_next_command(struct fsg_dev *fsg)
++{
++      struct fsg_buffhd       *bh;
++      int                     rc = 0;
++
++      if (transport_is_bbb()) {
++
++              /* Wait for the next buffer to become available */
++              bh = fsg->next_buffhd_to_fill;
++              while (bh->state != BUF_STATE_EMPTY) {
++                      rc = sleep_thread(fsg);
++                      if (rc)
++                              return rc;
++              }
++
++              /* Queue a request to read a Bulk-only CBW */
++              set_bulk_out_req_length(fsg, bh, US_BULK_CB_WRAP_LEN);
++              start_transfer(fsg, fsg->bulk_out, bh->outreq,
++                              &bh->outreq_busy, &bh->state);
++
++              /* We will drain the buffer in software, which means we
++               * can reuse it for the next filling.  No need to advance
++               * next_buffhd_to_fill. */
++
++              /* Wait for the CBW to arrive */
++              while (bh->state != BUF_STATE_FULL) {
++                      rc = sleep_thread(fsg);
++                      if (rc)
++                              return rc;
++              }
++              smp_rmb();
++              rc = received_cbw(fsg, bh);
++              bh->state = BUF_STATE_EMPTY;
++
++      } else {                // USB_PR_CB or USB_PR_CBI
++
++              /* Wait for the next command to arrive */
++              while (fsg->cbbuf_cmnd_size == 0) {
++                      rc = sleep_thread(fsg);
++                      if (rc)
++                              return rc;
++              }
++
++              /* Is the previous status interrupt request still busy?
++               * The host is allowed to skip reading the status,
++               * so we must cancel it. */
++              if (fsg->intreq_busy)
++                      usb_ep_dequeue(fsg->intr_in, fsg->intreq);
++
++              /* Copy the command and mark the buffer empty */
++              fsg->data_dir = DATA_DIR_UNKNOWN;
++              spin_lock_irq(&fsg->lock);
++              fsg->cmnd_size = fsg->cbbuf_cmnd_size;
++              memcpy(fsg->cmnd, fsg->cbbuf_cmnd, fsg->cmnd_size);
++              fsg->cbbuf_cmnd_size = 0;
++              spin_unlock_irq(&fsg->lock);
++
++              /* Use LUN from the command */
++              fsg->lun = fsg->cmnd[1] >> 5;
++      }
++
++      /* Update current lun */
++      if (fsg->lun >= 0 && fsg->lun < fsg->nluns)
++              fsg->curlun = &fsg->luns[fsg->lun];
++      else
++              fsg->curlun = NULL;
++
++      return rc;
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static int enable_endpoint(struct fsg_dev *fsg, struct usb_ep *ep,
++              const struct usb_endpoint_descriptor *d)
++{
++      int     rc;
++
++      ep->driver_data = fsg;
++      ep->desc = d;
++      rc = usb_ep_enable(ep);
++      if (rc)
++              ERROR(fsg, "can't enable %s, result %d\n", ep->name, rc);
++      return rc;
++}
++
++static int alloc_request(struct fsg_dev *fsg, struct usb_ep *ep,
++              struct usb_request **preq)
++{
++      *preq = usb_ep_alloc_request(ep, GFP_ATOMIC);
++      if (*preq)
++              return 0;
++      ERROR(fsg, "can't allocate request for %s\n", ep->name);
++      return -ENOMEM;
++}
++
++/*
++ * Reset interface setting and re-init endpoint state (toggle etc).
++ * Call with altsetting < 0 to disable the interface.  The only other
++ * available altsetting is 0, which enables the interface.
++ */
++static int do_set_interface(struct fsg_dev *fsg, int altsetting)
++{
++      int     rc = 0;
++      int     i;
++      const struct usb_endpoint_descriptor    *d;
++
++      if (fsg->running)
++              DBG(fsg, "reset interface\n");
++
++reset:
++      /* Deallocate the requests */
++      for (i = 0; i < fsg_num_buffers; ++i) {
++              struct fsg_buffhd *bh = &fsg->buffhds[i];
++
++              if (bh->inreq) {
++                      usb_ep_free_request(fsg->bulk_in, bh->inreq);
++                      bh->inreq = NULL;
++              }
++              if (bh->outreq) {
++                      usb_ep_free_request(fsg->bulk_out, bh->outreq);
++                      bh->outreq = NULL;
++              }
++      }
++      if (fsg->intreq) {
++              usb_ep_free_request(fsg->intr_in, fsg->intreq);
++              fsg->intreq = NULL;
++      }
++
++      /* Disable the endpoints */
++      if (fsg->bulk_in_enabled) {
++              usb_ep_disable(fsg->bulk_in);
++              fsg->bulk_in_enabled = 0;
++      }
++      if (fsg->bulk_out_enabled) {
++              usb_ep_disable(fsg->bulk_out);
++              fsg->bulk_out_enabled = 0;
++      }
++      if (fsg->intr_in_enabled) {
++              usb_ep_disable(fsg->intr_in);
++              fsg->intr_in_enabled = 0;
++      }
++
++      fsg->running = 0;
++      if (altsetting < 0 || rc != 0)
++              return rc;
++
++      DBG(fsg, "set interface %d\n", altsetting);
++
++      /* Enable the endpoints */
++      d = fsg_ep_desc(fsg->gadget,
++                      &fsg_fs_bulk_in_desc, &fsg_hs_bulk_in_desc,
++                      &fsg_ss_bulk_in_desc);
++      if ((rc = enable_endpoint(fsg, fsg->bulk_in, d)) != 0)
++              goto reset;
++      fsg->bulk_in_enabled = 1;
++
++      d = fsg_ep_desc(fsg->gadget,
++                      &fsg_fs_bulk_out_desc, &fsg_hs_bulk_out_desc,
++                      &fsg_ss_bulk_out_desc);
++      if ((rc = enable_endpoint(fsg, fsg->bulk_out, d)) != 0)
++              goto reset;
++      fsg->bulk_out_enabled = 1;
++      fsg->bulk_out_maxpacket = usb_endpoint_maxp(d);
++      clear_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
++
++      if (transport_is_cbi()) {
++              d = fsg_ep_desc(fsg->gadget,
++                              &fsg_fs_intr_in_desc, &fsg_hs_intr_in_desc,
++                              &fsg_ss_intr_in_desc);
++              if ((rc = enable_endpoint(fsg, fsg->intr_in, d)) != 0)
++                      goto reset;
++              fsg->intr_in_enabled = 1;
++      }
++
++      /* Allocate the requests */
++      for (i = 0; i < fsg_num_buffers; ++i) {
++              struct fsg_buffhd       *bh = &fsg->buffhds[i];
++
++              if ((rc = alloc_request(fsg, fsg->bulk_in, &bh->inreq)) != 0)
++                      goto reset;
++              if ((rc = alloc_request(fsg, fsg->bulk_out, &bh->outreq)) != 0)
++                      goto reset;
++              bh->inreq->buf = bh->outreq->buf = bh->buf;
++              bh->inreq->context = bh->outreq->context = bh;
++              bh->inreq->complete = bulk_in_complete;
++              bh->outreq->complete = bulk_out_complete;
++      }
++      if (transport_is_cbi()) {
++              if ((rc = alloc_request(fsg, fsg->intr_in, &fsg->intreq)) != 0)
++                      goto reset;
++              fsg->intreq->complete = intr_in_complete;
++      }
++
++      fsg->running = 1;
++      for (i = 0; i < fsg->nluns; ++i)
++              fsg->luns[i].unit_attention_data = SS_RESET_OCCURRED;
++      return rc;
++}
++
++
++/*
++ * Change our operational configuration.  This code must agree with the code
++ * that returns config descriptors, and with interface altsetting code.
++ *
++ * It's also responsible for power management interactions.  Some
++ * configurations might not work with our current power sources.
++ * For now we just assume the gadget is always self-powered.
++ */
++static int do_set_config(struct fsg_dev *fsg, u8 new_config)
++{
++      int     rc = 0;
++
++      /* Disable the single interface */
++      if (fsg->config != 0) {
++              DBG(fsg, "reset config\n");
++              fsg->config = 0;
++              rc = do_set_interface(fsg, -1);
++      }
++
++      /* Enable the interface */
++      if (new_config != 0) {
++              fsg->config = new_config;
++              if ((rc = do_set_interface(fsg, 0)) != 0)
++                      fsg->config = 0;        // Reset on errors
++              else
++                      INFO(fsg, "%s config #%d\n",
++                           usb_speed_string(fsg->gadget->speed),
++                           fsg->config);
++      }
++      return rc;
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static void handle_exception(struct fsg_dev *fsg)
++{
++      siginfo_t               info;
++      int                     sig;
++      int                     i;
++      int                     num_active;
++      struct fsg_buffhd       *bh;
++      enum fsg_state          old_state;
++      u8                      new_config;
++      struct fsg_lun          *curlun;
++      unsigned int            exception_req_tag;
++      int                     rc;
++
++      /* Clear the existing signals.  Anything but SIGUSR1 is converted
++       * into a high-priority EXIT exception. */
++      for (;;) {
++              sig = dequeue_signal_lock(current, &current->blocked, &info);
++              if (!sig)
++                      break;
++              if (sig != SIGUSR1) {
++                      if (fsg->state < FSG_STATE_EXIT)
++                              DBG(fsg, "Main thread exiting on signal\n");
++                      raise_exception(fsg, FSG_STATE_EXIT);
++              }
++      }
++
++      /* Cancel all the pending transfers */
++      if (fsg->intreq_busy)
++              usb_ep_dequeue(fsg->intr_in, fsg->intreq);
++      for (i = 0; i < fsg_num_buffers; ++i) {
++              bh = &fsg->buffhds[i];
++              if (bh->inreq_busy)
++                      usb_ep_dequeue(fsg->bulk_in, bh->inreq);
++              if (bh->outreq_busy)
++                      usb_ep_dequeue(fsg->bulk_out, bh->outreq);
++      }
++
++      /* Wait until everything is idle */
++      for (;;) {
++              num_active = fsg->intreq_busy;
++              for (i = 0; i < fsg_num_buffers; ++i) {
++                      bh = &fsg->buffhds[i];
++                      num_active += bh->inreq_busy + bh->outreq_busy;
++              }
++              if (num_active == 0)
++                      break;
++              if (sleep_thread(fsg))
++                      return;
++      }
++
++      /* Clear out the controller's fifos */
++      if (fsg->bulk_in_enabled)
++              usb_ep_fifo_flush(fsg->bulk_in);
++      if (fsg->bulk_out_enabled)
++              usb_ep_fifo_flush(fsg->bulk_out);
++      if (fsg->intr_in_enabled)
++              usb_ep_fifo_flush(fsg->intr_in);
++
++      /* Reset the I/O buffer states and pointers, the SCSI
++       * state, and the exception.  Then invoke the handler. */
++      spin_lock_irq(&fsg->lock);
++
++      for (i = 0; i < fsg_num_buffers; ++i) {
++              bh = &fsg->buffhds[i];
++              bh->state = BUF_STATE_EMPTY;
++      }
++      fsg->next_buffhd_to_fill = fsg->next_buffhd_to_drain =
++                      &fsg->buffhds[0];
++
++      exception_req_tag = fsg->exception_req_tag;
++      new_config = fsg->new_config;
++      old_state = fsg->state;
++
++      if (old_state == FSG_STATE_ABORT_BULK_OUT)
++              fsg->state = FSG_STATE_STATUS_PHASE;
++      else {
++              for (i = 0; i < fsg->nluns; ++i) {
++                      curlun = &fsg->luns[i];
++                      curlun->prevent_medium_removal = 0;
++                      curlun->sense_data = curlun->unit_attention_data =
++                                      SS_NO_SENSE;
++                      curlun->sense_data_info = 0;
++                      curlun->info_valid = 0;
++              }
++              fsg->state = FSG_STATE_IDLE;
++      }
++      spin_unlock_irq(&fsg->lock);
++
++      /* Carry out any extra actions required for the exception */
++      switch (old_state) {
++      default:
++              break;
++
++      case FSG_STATE_ABORT_BULK_OUT:
++              send_status(fsg);
++              spin_lock_irq(&fsg->lock);
++              if (fsg->state == FSG_STATE_STATUS_PHASE)
++                      fsg->state = FSG_STATE_IDLE;
++              spin_unlock_irq(&fsg->lock);
++              break;
++
++      case FSG_STATE_RESET:
++              /* In case we were forced against our will to halt a
++               * bulk endpoint, clear the halt now.  (The SuperH UDC
++               * requires this.) */
++              if (test_and_clear_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags))
++                      usb_ep_clear_halt(fsg->bulk_in);
++
++              if (transport_is_bbb()) {
++                      if (fsg->ep0_req_tag == exception_req_tag)
++                              ep0_queue(fsg); // Complete the status stage
++
++              } else if (transport_is_cbi())
++                      send_status(fsg);       // Status by interrupt pipe
++
++              /* Technically this should go here, but it would only be
++               * a waste of time.  Ditto for the INTERFACE_CHANGE and
++               * CONFIG_CHANGE cases. */
++              // for (i = 0; i < fsg->nluns; ++i)
++              //      fsg->luns[i].unit_attention_data = SS_RESET_OCCURRED;
++              break;
++
++      case FSG_STATE_INTERFACE_CHANGE:
++              rc = do_set_interface(fsg, 0);
++              if (fsg->ep0_req_tag != exception_req_tag)
++                      break;
++              if (rc != 0)                    // STALL on errors
++                      fsg_set_halt(fsg, fsg->ep0);
++              else                            // Complete the status stage
++                      ep0_queue(fsg);
++              break;
++
++      case FSG_STATE_CONFIG_CHANGE:
++              rc = do_set_config(fsg, new_config);
++              if (fsg->ep0_req_tag != exception_req_tag)
++                      break;
++              if (rc != 0)                    // STALL on errors
++                      fsg_set_halt(fsg, fsg->ep0);
++              else                            // Complete the status stage
++                      ep0_queue(fsg);
++              break;
++
++      case FSG_STATE_DISCONNECT:
++              for (i = 0; i < fsg->nluns; ++i)
++                      fsg_lun_fsync_sub(fsg->luns + i);
++              do_set_config(fsg, 0);          // Unconfigured state
++              break;
++
++      case FSG_STATE_EXIT:
++      case FSG_STATE_TERMINATED:
++              do_set_config(fsg, 0);                  // Free resources
++              spin_lock_irq(&fsg->lock);
++              fsg->state = FSG_STATE_TERMINATED;      // Stop the thread
++              spin_unlock_irq(&fsg->lock);
++              break;
++      }
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static int fsg_main_thread(void *fsg_)
++{
++      struct fsg_dev          *fsg = fsg_;
++
++      /* Allow the thread to be killed by a signal, but set the signal mask
++       * to block everything but INT, TERM, KILL, and USR1. */
++      allow_signal(SIGINT);
++      allow_signal(SIGTERM);
++      allow_signal(SIGKILL);
++      allow_signal(SIGUSR1);
++
++      /* Allow the thread to be frozen */
++      set_freezable();
++
++      /* Arrange for userspace references to be interpreted as kernel
++       * pointers.  That way we can pass a kernel pointer to a routine
++       * that expects a __user pointer and it will work okay. */
++      set_fs(get_ds());
++
++      /* The main loop */
++      while (fsg->state != FSG_STATE_TERMINATED) {
++              if (exception_in_progress(fsg) || signal_pending(current)) {
++                      handle_exception(fsg);
++                      continue;
++              }
++
++              if (!fsg->running) {
++                      sleep_thread(fsg);
++                      continue;
++              }
++
++              if (get_next_command(fsg))
++                      continue;
++
++              spin_lock_irq(&fsg->lock);
++              if (!exception_in_progress(fsg))
++                      fsg->state = FSG_STATE_DATA_PHASE;
++              spin_unlock_irq(&fsg->lock);
++
++              if (do_scsi_command(fsg) || finish_reply(fsg))
++                      continue;
++
++              spin_lock_irq(&fsg->lock);
++              if (!exception_in_progress(fsg))
++                      fsg->state = FSG_STATE_STATUS_PHASE;
++              spin_unlock_irq(&fsg->lock);
++
++              if (send_status(fsg))
++                      continue;
++
++              spin_lock_irq(&fsg->lock);
++              if (!exception_in_progress(fsg))
++                      fsg->state = FSG_STATE_IDLE;
++              spin_unlock_irq(&fsg->lock);
++              }
++
++      spin_lock_irq(&fsg->lock);
++      fsg->thread_task = NULL;
++      spin_unlock_irq(&fsg->lock);
++
++      /* If we are exiting because of a signal, unregister the
++       * gadget driver. */
++      if (test_and_clear_bit(REGISTERED, &fsg->atomic_bitflags))
++              usb_gadget_unregister_driver(&fsg_driver);
++
++      /* Let the unbind and cleanup routines know the thread has exited */
++      complete_and_exit(&fsg->thread_notifier, 0);
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++
++/* The write permissions and store_xxx pointers are set in fsg_bind() */
++static DEVICE_ATTR(ro, 0444, fsg_show_ro, NULL);
++static DEVICE_ATTR(nofua, 0644, fsg_show_nofua, NULL);
++static DEVICE_ATTR(file, 0444, fsg_show_file, NULL);
++
++
++/*-------------------------------------------------------------------------*/
++
++static void fsg_release(struct kref *ref)
++{
++      struct fsg_dev  *fsg = container_of(ref, struct fsg_dev, ref);
++
++      kfree(fsg->luns);
++      kfree(fsg);
++}
++
++static void lun_release(struct device *dev)
++{
++      struct rw_semaphore     *filesem = dev_get_drvdata(dev);
++      struct fsg_dev          *fsg =
++              container_of(filesem, struct fsg_dev, filesem);
++
++      kref_put(&fsg->ref, fsg_release);
++}
++
++static void /* __init_or_exit */ fsg_unbind(struct usb_gadget *gadget)
++{
++      struct fsg_dev          *fsg = get_gadget_data(gadget);
++      int                     i;
++      struct fsg_lun          *curlun;
++      struct usb_request      *req = fsg->ep0req;
++
++      DBG(fsg, "unbind\n");
++      clear_bit(REGISTERED, &fsg->atomic_bitflags);
++
++      /* If the thread isn't already dead, tell it to exit now */
++      if (fsg->state != FSG_STATE_TERMINATED) {
++              raise_exception(fsg, FSG_STATE_EXIT);
++              wait_for_completion(&fsg->thread_notifier);
++
++              /* The cleanup routine waits for this completion also */
++              complete(&fsg->thread_notifier);
++      }
++
++      /* Unregister the sysfs attribute files and the LUNs */
++      for (i = 0; i < fsg->nluns; ++i) {
++              curlun = &fsg->luns[i];
++              if (curlun->registered) {
++                      device_remove_file(&curlun->dev, &dev_attr_nofua);
++                      device_remove_file(&curlun->dev, &dev_attr_ro);
++                      device_remove_file(&curlun->dev, &dev_attr_file);
++                      fsg_lun_close(curlun);
++                      device_unregister(&curlun->dev);
++                      curlun->registered = 0;
++              }
++      }
++
++      /* Free the data buffers */
++      for (i = 0; i < fsg_num_buffers; ++i)
++              kfree(fsg->buffhds[i].buf);
++
++      /* Free the request and buffer for endpoint 0 */
++      if (req) {
++              kfree(req->buf);
++              usb_ep_free_request(fsg->ep0, req);
++      }
++
++      set_gadget_data(gadget, NULL);
++}
++
++
++static int __init check_parameters(struct fsg_dev *fsg)
++{
++      int     prot;
++      int     gcnum;
++
++      /* Store the default values */
++      mod_data.transport_type = USB_PR_BULK;
++      mod_data.transport_name = "Bulk-only";
++      mod_data.protocol_type = USB_SC_SCSI;
++      mod_data.protocol_name = "Transparent SCSI";
++
++      /* Some peripheral controllers are known not to be able to
++       * halt bulk endpoints correctly.  If one of them is present,
++       * disable stalls.
++       */
++      if (gadget_is_at91(fsg->gadget))
++              mod_data.can_stall = 0;
++
++      if (mod_data.release == 0xffff) {       // Parameter wasn't set
++              gcnum = usb_gadget_controller_number(fsg->gadget);
++              if (gcnum >= 0)
++                      mod_data.release = 0x0300 + gcnum;
++              else {
++                      WARNING(fsg, "controller '%s' not recognized\n",
++                              fsg->gadget->name);
++                      mod_data.release = 0x0399;
++              }
++      }
++
++      prot = simple_strtol(mod_data.protocol_parm, NULL, 0);
++
++#ifdef CONFIG_USB_FILE_STORAGE_TEST
++      if (strnicmp(mod_data.transport_parm, "BBB", 10) == 0) {
++              ;               // Use default setting
++      } else if (strnicmp(mod_data.transport_parm, "CB", 10) == 0) {
++              mod_data.transport_type = USB_PR_CB;
++              mod_data.transport_name = "Control-Bulk";
++      } else if (strnicmp(mod_data.transport_parm, "CBI", 10) == 0) {
++              mod_data.transport_type = USB_PR_CBI;
++              mod_data.transport_name = "Control-Bulk-Interrupt";
++      } else {
++              ERROR(fsg, "invalid transport: %s\n", mod_data.transport_parm);
++              return -EINVAL;
++      }
++
++      if (strnicmp(mod_data.protocol_parm, "SCSI", 10) == 0 ||
++                      prot == USB_SC_SCSI) {
++              ;               // Use default setting
++      } else if (strnicmp(mod_data.protocol_parm, "RBC", 10) == 0 ||
++                      prot == USB_SC_RBC) {
++              mod_data.protocol_type = USB_SC_RBC;
++              mod_data.protocol_name = "RBC";
++      } else if (strnicmp(mod_data.protocol_parm, "8020", 4) == 0 ||
++                      strnicmp(mod_data.protocol_parm, "ATAPI", 10) == 0 ||
++                      prot == USB_SC_8020) {
++              mod_data.protocol_type = USB_SC_8020;
++              mod_data.protocol_name = "8020i (ATAPI)";
++      } else if (strnicmp(mod_data.protocol_parm, "QIC", 3) == 0 ||
++                      prot == USB_SC_QIC) {
++              mod_data.protocol_type = USB_SC_QIC;
++              mod_data.protocol_name = "QIC-157";
++      } else if (strnicmp(mod_data.protocol_parm, "UFI", 10) == 0 ||
++                      prot == USB_SC_UFI) {
++              mod_data.protocol_type = USB_SC_UFI;
++              mod_data.protocol_name = "UFI";
++      } else if (strnicmp(mod_data.protocol_parm, "8070", 4) == 0 ||
++                      prot == USB_SC_8070) {
++              mod_data.protocol_type = USB_SC_8070;
++              mod_data.protocol_name = "8070i";
++      } else {
++              ERROR(fsg, "invalid protocol: %s\n", mod_data.protocol_parm);
++              return -EINVAL;
++      }
++
++      mod_data.buflen &= PAGE_CACHE_MASK;
++      if (mod_data.buflen <= 0) {
++              ERROR(fsg, "invalid buflen\n");
++              return -ETOOSMALL;
++      }
++
++#endif /* CONFIG_USB_FILE_STORAGE_TEST */
++
++      /* Serial string handling.
++       * On a real device, the serial string would be loaded
++       * from permanent storage. */
++      if (mod_data.serial) {
++              const char *ch;
++              unsigned len = 0;
++
++              /* Sanity check :
++               * The CB[I] specification limits the serial string to
++               * 12 uppercase hexadecimal characters.
++               * BBB need at least 12 uppercase hexadecimal characters,
++               * with a maximum of 126. */
++              for (ch = mod_data.serial; *ch; ++ch) {
++                      ++len;
++                      if ((*ch < '0' || *ch > '9') &&
++                          (*ch < 'A' || *ch > 'F')) { /* not uppercase hex */
++                              WARNING(fsg,
++                                      "Invalid serial string character: %c\n",
++                                      *ch);
++                              goto no_serial;
++                      }
++              }
++              if (len > 126 ||
++                  (mod_data.transport_type == USB_PR_BULK && len < 12) ||
++                  (mod_data.transport_type != USB_PR_BULK && len > 12)) {
++                      WARNING(fsg, "Invalid serial string length!\n");
++                      goto no_serial;
++              }
++              fsg_strings[FSG_STRING_SERIAL - 1].s = mod_data.serial;
++      } else {
++              WARNING(fsg, "No serial-number string provided!\n");
++ no_serial:
++              device_desc.iSerialNumber = 0;
++      }
++
++      return 0;
++}
++
++
++static int __init fsg_bind(struct usb_gadget *gadget)
++{
++      struct fsg_dev          *fsg = the_fsg;
++      int                     rc;
++      int                     i;
++      struct fsg_lun          *curlun;
++      struct usb_ep           *ep;
++      struct usb_request      *req;
++      char                    *pathbuf, *p;
++
++      fsg->gadget = gadget;
++      set_gadget_data(gadget, fsg);
++      fsg->ep0 = gadget->ep0;
++      fsg->ep0->driver_data = fsg;
++
++      if ((rc = check_parameters(fsg)) != 0)
++              goto out;
++
++      if (mod_data.removable) {       // Enable the store_xxx attributes
++              dev_attr_file.attr.mode = 0644;
++              dev_attr_file.store = fsg_store_file;
++              if (!mod_data.cdrom) {
++                      dev_attr_ro.attr.mode = 0644;
++                      dev_attr_ro.store = fsg_store_ro;
++              }
++      }
++
++      /* Only for removable media? */
++      dev_attr_nofua.attr.mode = 0644;
++      dev_attr_nofua.store = fsg_store_nofua;
++
++      /* Find out how many LUNs there should be */
++      i = mod_data.nluns;
++      if (i == 0)
++              i = max(mod_data.num_filenames, 1u);
++      if (i > FSG_MAX_LUNS) {
++              ERROR(fsg, "invalid number of LUNs: %d\n", i);
++              rc = -EINVAL;
++              goto out;
++      }
++
++      /* Create the LUNs, open their backing files, and register the
++       * LUN devices in sysfs. */
++      fsg->luns = kzalloc(i * sizeof(struct fsg_lun), GFP_KERNEL);
++      if (!fsg->luns) {
++              rc = -ENOMEM;
++              goto out;
++      }
++      fsg->nluns = i;
++
++      for (i = 0; i < fsg->nluns; ++i) {
++              curlun = &fsg->luns[i];
++              curlun->cdrom = !!mod_data.cdrom;
++              curlun->ro = mod_data.cdrom || mod_data.ro[i];
++              curlun->initially_ro = curlun->ro;
++              curlun->removable = mod_data.removable;
++              curlun->nofua = mod_data.nofua[i];
++              curlun->dev.release = lun_release;
++              curlun->dev.parent = &gadget->dev;
++              curlun->dev.driver = &fsg_driver.driver;
++              dev_set_drvdata(&curlun->dev, &fsg->filesem);
++              dev_set_name(&curlun->dev,"%s-lun%d",
++                           dev_name(&gadget->dev), i);
++
++              kref_get(&fsg->ref);
++              rc = device_register(&curlun->dev);
++              if (rc) {
++                      INFO(fsg, "failed to register LUN%d: %d\n", i, rc);
++                      put_device(&curlun->dev);
++                      goto out;
++              }
++              curlun->registered = 1;
++
++              rc = device_create_file(&curlun->dev, &dev_attr_ro);
++              if (rc)
++                      goto out;
++              rc = device_create_file(&curlun->dev, &dev_attr_nofua);
++              if (rc)
++                      goto out;
++              rc = device_create_file(&curlun->dev, &dev_attr_file);
++              if (rc)
++                      goto out;
++
++              if (mod_data.file[i] && *mod_data.file[i]) {
++                      rc = fsg_lun_open(curlun, mod_data.file[i]);
++                      if (rc)
++                              goto out;
++              } else if (!mod_data.removable) {
++                      ERROR(fsg, "no file given for LUN%d\n", i);
++                      rc = -EINVAL;
++                      goto out;
++              }
++      }
++
++      /* Find all the endpoints we will use */
++      usb_ep_autoconfig_reset(gadget);
++      ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_in_desc);
++      if (!ep)
++              goto autoconf_fail;
++      ep->driver_data = fsg;          // claim the endpoint
++      fsg->bulk_in = ep;
++
++      ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_out_desc);
++      if (!ep)
++              goto autoconf_fail;
++      ep->driver_data = fsg;          // claim the endpoint
++      fsg->bulk_out = ep;
++
++      if (transport_is_cbi()) {
++              ep = usb_ep_autoconfig(gadget, &fsg_fs_intr_in_desc);
++              if (!ep)
++                      goto autoconf_fail;
++              ep->driver_data = fsg;          // claim the endpoint
++              fsg->intr_in = ep;
++      }
++
++      /* Fix up the descriptors */
++      device_desc.idVendor = cpu_to_le16(mod_data.vendor);
++      device_desc.idProduct = cpu_to_le16(mod_data.product);
++      device_desc.bcdDevice = cpu_to_le16(mod_data.release);
++
++      i = (transport_is_cbi() ? 3 : 2);       // Number of endpoints
++      fsg_intf_desc.bNumEndpoints = i;
++      fsg_intf_desc.bInterfaceSubClass = mod_data.protocol_type;
++      fsg_intf_desc.bInterfaceProtocol = mod_data.transport_type;
++      fsg_fs_function[i + FSG_FS_FUNCTION_PRE_EP_ENTRIES] = NULL;
++
++      if (gadget_is_dualspeed(gadget)) {
++              fsg_hs_function[i + FSG_HS_FUNCTION_PRE_EP_ENTRIES] = NULL;
++
++              /* Assume endpoint addresses are the same for both speeds */
++              fsg_hs_bulk_in_desc.bEndpointAddress =
++                      fsg_fs_bulk_in_desc.bEndpointAddress;
++              fsg_hs_bulk_out_desc.bEndpointAddress =
++                      fsg_fs_bulk_out_desc.bEndpointAddress;
++              fsg_hs_intr_in_desc.bEndpointAddress =
++                      fsg_fs_intr_in_desc.bEndpointAddress;
++      }
++
++      if (gadget_is_superspeed(gadget)) {
++              unsigned                max_burst;
++
++              fsg_ss_function[i + FSG_SS_FUNCTION_PRE_EP_ENTRIES] = NULL;
++
++              /* Calculate bMaxBurst, we know packet size is 1024 */
++              max_burst = min_t(unsigned, mod_data.buflen / 1024, 15);
++
++              /* Assume endpoint addresses are the same for both speeds */
++              fsg_ss_bulk_in_desc.bEndpointAddress =
++                      fsg_fs_bulk_in_desc.bEndpointAddress;
++              fsg_ss_bulk_in_comp_desc.bMaxBurst = max_burst;
++
++              fsg_ss_bulk_out_desc.bEndpointAddress =
++                      fsg_fs_bulk_out_desc.bEndpointAddress;
++              fsg_ss_bulk_out_comp_desc.bMaxBurst = max_burst;
++      }
++
++      if (gadget_is_otg(gadget))
++              fsg_otg_desc.bmAttributes |= USB_OTG_HNP;
++
++      rc = -ENOMEM;
++
++      /* Allocate the request and buffer for endpoint 0 */
++      fsg->ep0req = req = usb_ep_alloc_request(fsg->ep0, GFP_KERNEL);
++      if (!req)
++              goto out;
++      req->buf = kmalloc(EP0_BUFSIZE, GFP_KERNEL);
++      if (!req->buf)
++              goto out;
++      req->complete = ep0_complete;
++
++      /* Allocate the data buffers */
++      for (i = 0; i < fsg_num_buffers; ++i) {
++              struct fsg_buffhd       *bh = &fsg->buffhds[i];
++
++              /* Allocate for the bulk-in endpoint.  We assume that
++               * the buffer will also work with the bulk-out (and
++               * interrupt-in) endpoint. */
++              bh->buf = kmalloc(mod_data.buflen, GFP_KERNEL);
++              if (!bh->buf)
++                      goto out;
++              bh->next = bh + 1;
++      }
++      fsg->buffhds[fsg_num_buffers - 1].next = &fsg->buffhds[0];
++
++      /* This should reflect the actual gadget power source */
++      usb_gadget_set_selfpowered(gadget);
++
++      snprintf(fsg_string_manufacturer, sizeof fsg_string_manufacturer,
++                      "%s %s with %s",
++                      init_utsname()->sysname, init_utsname()->release,
++                      gadget->name);
++
++      fsg->thread_task = kthread_create(fsg_main_thread, fsg,
++                      "file-storage-gadget");
++      if (IS_ERR(fsg->thread_task)) {
++              rc = PTR_ERR(fsg->thread_task);
++              goto out;
++      }
++
++      INFO(fsg, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
++      INFO(fsg, "NOTE: This driver is deprecated.  "
++                      "Consider using g_mass_storage instead.\n");
++      INFO(fsg, "Number of LUNs=%d\n", fsg->nluns);
++
++      pathbuf = kmalloc(PATH_MAX, GFP_KERNEL);
++      for (i = 0; i < fsg->nluns; ++i) {
++              curlun = &fsg->luns[i];
++              if (fsg_lun_is_open(curlun)) {
++                      p = NULL;
++                      if (pathbuf) {
++                              p = d_path(&curlun->filp->f_path,
++                                         pathbuf, PATH_MAX);
++                              if (IS_ERR(p))
++                                      p = NULL;
++                      }
++                      LINFO(curlun, "ro=%d, nofua=%d, file: %s\n",
++                            curlun->ro, curlun->nofua, (p ? p : "(error)"));
++              }
++      }
++      kfree(pathbuf);
++
++      DBG(fsg, "transport=%s (x%02x)\n",
++                      mod_data.transport_name, mod_data.transport_type);
++      DBG(fsg, "protocol=%s (x%02x)\n",
++                      mod_data.protocol_name, mod_data.protocol_type);
++      DBG(fsg, "VendorID=x%04x, ProductID=x%04x, Release=x%04x\n",
++                      mod_data.vendor, mod_data.product, mod_data.release);
++      DBG(fsg, "removable=%d, stall=%d, cdrom=%d, buflen=%u\n",
++                      mod_data.removable, mod_data.can_stall,
++                      mod_data.cdrom, mod_data.buflen);
++      DBG(fsg, "I/O thread pid: %d\n", task_pid_nr(fsg->thread_task));
++
++      set_bit(REGISTERED, &fsg->atomic_bitflags);
++
++      /* Tell the thread to start working */
++      wake_up_process(fsg->thread_task);
++      return 0;
++
++autoconf_fail:
++      ERROR(fsg, "unable to autoconfigure all endpoints\n");
++      rc = -ENOTSUPP;
++
++out:
++      fsg->state = FSG_STATE_TERMINATED;      // The thread is dead
++      fsg_unbind(gadget);
++      complete(&fsg->thread_notifier);
++      return rc;
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static void fsg_suspend(struct usb_gadget *gadget)
++{
++      struct fsg_dev          *fsg = get_gadget_data(gadget);
++
++      DBG(fsg, "suspend\n");
++      set_bit(SUSPENDED, &fsg->atomic_bitflags);
++}
++
++static void fsg_resume(struct usb_gadget *gadget)
++{
++      struct fsg_dev          *fsg = get_gadget_data(gadget);
++
++      DBG(fsg, "resume\n");
++      clear_bit(SUSPENDED, &fsg->atomic_bitflags);
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static struct usb_gadget_driver               fsg_driver = {
++      .max_speed      = USB_SPEED_SUPER,
++      .function       = (char *) fsg_string_product,
++      .unbind         = fsg_unbind,
++      .disconnect     = fsg_disconnect,
++      .setup          = fsg_setup,
++      .suspend        = fsg_suspend,
++      .resume         = fsg_resume,
++
++      .driver         = {
++              .name           = DRIVER_NAME,
++              .owner          = THIS_MODULE,
++              // .release = ...
++              // .suspend = ...
++              // .resume = ...
++      },
++};
++
++
++static int __init fsg_alloc(void)
++{
++      struct fsg_dev          *fsg;
++
++      fsg = kzalloc(sizeof *fsg +
++                    fsg_num_buffers * sizeof *(fsg->buffhds), GFP_KERNEL);
++
++      if (!fsg)
++              return -ENOMEM;
++      spin_lock_init(&fsg->lock);
++      init_rwsem(&fsg->filesem);
++      kref_init(&fsg->ref);
++      init_completion(&fsg->thread_notifier);
++
++      the_fsg = fsg;
++      return 0;
++}
++
++
++static int __init fsg_init(void)
++{
++      int  &nbs