Merge Linux 4.1.37 to newkernel-4.1
Change-Id: I9c2feb2ac204703880761fd83ab23b3f90996ec8
diff --git a/Documentation/networking/ip-sysctl.txt b/Documentation/networking/ip-sysctl.txt
index 07fad3d..4e2f2f9 100644
--- a/Documentation/networking/ip-sysctl.txt
+++ b/Documentation/networking/ip-sysctl.txt
@@ -375,6 +375,14 @@
Defaults are calculated at boot time from amount of available
memory.
+tcp_min_rtt_wlen - INTEGER
+ The window length of the windowed min filter to track the minimum RTT.
+ A shorter window lets a flow more quickly pick up new (higher)
+ minimum RTT when it is moved to a longer path (e.g., due to traffic
+ engineering). A longer window makes the filter more resistant to RTT
+ inflations such as transient congestion. The unit is seconds.
+ Default: 300
+
tcp_moderate_rcvbuf - BOOLEAN
If set, TCP performs receive buffer auto-tuning, attempting to
automatically size the buffer (no greater than tcp_rmem[2]) to
diff --git a/Documentation/networking/ls1024a-fastforwarding.txt b/Documentation/networking/ls1024a-fastforwarding.txt
new file mode 100644
index 0000000..72edad1
--- /dev/null
+++ b/Documentation/networking/ls1024a-fastforwarding.txt
@@ -0,0 +1,100 @@
+NXP's (formerly Freescale) QorIQ LS1024A SoC (formerly known as Mindspeed
+Comcerto 2000) provides fast hardware forwarding between its three Ethernet
+MACs. For forwarding between an Ethernet MAC and WLAN, it depends on the ARM
+CPU to pass frames between the forwarding engine called PPFE (programmable
+packet forwarding engine) and the WLAN hardware connected via PCIe. Most
+forwarding decisions as well as NAT are handled inside the PPFE hardware. The
+role of Linux is reduced to forwarding descriptors between PPFE and the WLAN
+hardware. Linux rarely accesses the data inside the Ethernet frames.
+
+Performance can be improved by using DMA coherent memory for data buffers
+because they do not require L1/L2 cache flushing, invalidation, etc. which
+turned out to be expensive on the LS1024A. The PPFE driver allocates buffers
+using dma_alloc_coherent() and builds an skb around it. A few changes to the
+kernel were necessary to support DMA coherent skbs. We added the field
+dma_coherent to struct sk_buff to indicate that the skb head is in DMA coherent
+memory. skb_free_head() in skbuff.c checks for this flag and calls
+dma_free_coherent() instead of put_page() or kfree() on skb->head.
+
+dma_alloc_coherent() returns two values: (1) the CPU address which is a regular
+pointer i.e. a virtual address and (2) a dma handle which is basically a
+physical address that can be communicated to the hardware. For our fast
+forwarding approach to work, the virtual address must be in lowmem which means
+that there is a simple mapping from virtual address space to physical address
+space. In many situation, dma_alloc_coherent() returns an address from the
+vmalloc space which does not work for our purposes because dma_map_single()
+uses virt_to_page() to map a pointer (virtual address) to a page, and
+virt_to_page() does not work with addresses from the vmalloc space. For
+dma_alloc_coherent() to return an address in lowmem, a few conditions need to
+be met: (1) The caller needs to pass in GFP_ATOMIC for arm_dma_alloc() to
+allocate memory from its atomic pool. (2) The atomic pool needs to be allocated
+from CMA (CONFIG_CMA and CONFIG_DMA_CMA need to be set)
+
+dma_free_coherent() requires the cpu address (virtual address) and the dma
+handle (physical address) to be passed in. However, in our approach, the dma
+handle gets lost, because we do not store it in the skb. This turns out not to
+be a problem because the dma handle is not required if the memory came from the
+atomic pool. Although it does work in practice, the DMA-API debug feature
+complains about the incorrect dma handle passed into dma_free_coherent().
+Examples of these error messages can be found below. They can be ignored.
+
+December 9, 2015
+Daniel Mentz <danielmentz@google.com>
+
+
+[ 10.468709] ------------[ cut here ]------------
+[ 10.473383] WARNING: CPU: 0 PID: 0 at lib/dma-debug.c:1093 check_unmap+0x695/0x84c()
+[ 10.481163] NULL NULL: DMA-API: device driver tries to free DMA memory it has not allocated [device address=0x0000000000000000] [size=2048 bytes]
+[ 10.494246] Modules linked in: pfe(O)
+[ 10.497952] CPU: 0 PID: 0 Comm: swapper/0 Tainted: G O 4.1.0-gfiber0+ #298
+[ 10.505988] Hardware name: Generic Freescale LS1024A (Flattened Device Tree)
+[ 10.513095] [<800142a5>] (unwind_backtrace) from [<80011441>] (show_stack+0x11/0x14)
+[ 10.520885] [<80011441>] (show_stack) from [<803dd59b>] (dump_stack+0x6f/0x98)
+[ 10.528139] [<803dd59b>] (dump_stack) from [<80020f87>] (warn_slowpath_common+0x6b/0x94)
+[ 10.536270] [<80020f87>] (warn_slowpath_common) from [<80020fd3>] (warn_slowpath_fmt+0x23/0x2c)
+[ 10.545009] [<80020fd3>] (warn_slowpath_fmt) from [<802097d5>] (check_unmap+0x695/0x84c)
+[ 10.553139] [<802097d5>] (check_unmap) from [<80209a41>] (debug_dma_free_coherent+0x61/0x68)
+[ 10.561692] [<80209a41>] (debug_dma_free_coherent) from [<7f8042eb>] (pfe_eth_poll+0x3f6/0x644 [pfe])
+[ 10.571001] [<7f8042eb>] (pfe_eth_poll [pfe]) from [<7f8045e7>] (pfe_eth_low_poll+0x36/0x3c [pfe])
+[ 10.580027] [<7f8045e7>] (pfe_eth_low_poll [pfe]) from [<8031be17>] (net_rx_action+0x153/0x240)
+[ 10.588759] [<8031be17>] (net_rx_action) from [<800233d1>] (__do_softirq+0xd5/0x294)
+[ 10.596541] [<800233d1>] (__do_softirq) from [<80023813>] (irq_exit+0x8f/0xd8)
+[ 10.603803] [<80023813>] (irq_exit) from [<8004b4a1>] (__handle_domain_irq+0x49/0x84)
+[ 10.611670] [<8004b4a1>] (__handle_domain_irq) from [<800092ef>] (gic_handle_irq+0x27/0x50)
+[ 10.620069] [<800092ef>] (gic_handle_irq) from [<803e1b3f>] (__irq_svc+0x3f/0x88)
+[ 10.627573] Exception stack(0x80631f58 to 0x80631fa0)
+[ 10.632649] 1f40: 00000000 80633350
+[ 10.640861] 1f60: 00000000 00000000 80630000 806324e8 80632400 8069b6b4 806324a0 8062a304
+[ 10.649064] 1f80: 803e6a00 8069b6b4 8063003c 80631fa0 8000f14b 8000f14c 40070033 ffffffff
+[ 10.657285] [<803e1b3f>] (__irq_svc) from [<8000f14c>] (arch_cpu_idle+0x30/0x34)
+[ 10.664728] [<8000f14c>] (arch_cpu_idle) from [<80045fdb>] (cpu_startup_entry+0x11f/0x204)
+[ 10.673035] [<80045fdb>] (cpu_startup_entry) from [<805dba31>] (start_kernel+0x309/0x314)
+[ 10.681244] ---[ end trace 62a3b00cc739c0de ]---
+
+[ 11.212979] ------------[ cut here ]------------
+[ 11.217643] WARNING: CPU: 0 PID: 0 at lib/dma-debug.c:509 add_dma_entry+0xb1/0xd4()
+[ 11.225323] DMA-API: exceeded 7 overlapping mappings of cacheline 0x03e00000
+[ 11.232390] Modules linked in: pfe(O)
+[ 11.236094] CPU: 0 PID: 0 Comm: swapper/0 Tainted: G W O 4.1.0-gfiber0+ #298
+[ 11.244121] Hardware name: Generic Freescale LS1024A (Flattened Device Tree)
+[ 11.251216] [<800142a5>] (unwind_backtrace) from [<80011441>] (show_stack+0x11/0x14)
+[ 11.258994] [<80011441>] (show_stack) from [<803dd59b>] (dump_stack+0x6f/0x98)
+[ 11.266247] [<803dd59b>] (dump_stack) from [<80020f87>] (warn_slowpath_common+0x6b/0x94)
+[ 11.274366] [<80020f87>] (warn_slowpath_common) from [<80020fd3>] (warn_slowpath_fmt+0x23/0x2c)
+[ 11.283094] [<80020fd3>] (warn_slowpath_fmt) from [<80208efd>] (add_dma_entry+0xb1/0xd4)
+[ 11.291283] [<80208efd>] (add_dma_entry) from [<7f801861>] (pfe_hif_rx_poll+0x1c8/0x594 [pfe])
+[ 11.299949] [<7f801861>] (pfe_hif_rx_poll [pfe]) from [<8031be17>] (net_rx_action+0x153/0x240)
+[ 11.308593] [<8031be17>] (net_rx_action) from [<800233d1>] (__do_softirq+0xd5/0x294)
+[ 11.316363] [<800233d1>] (__do_softirq) from [<80023813>] (irq_exit+0x8f/0xd8)
+[ 11.323616] [<80023813>] (irq_exit) from [<8004b4a1>] (__handle_domain_irq+0x49/0x84)
+[ 11.331474] [<8004b4a1>] (__handle_domain_irq) from [<800092ef>] (gic_handle_irq+0x27/0x50)
+[ 11.339863] [<800092ef>] (gic_handle_irq) from [<803e1b3f>] (__irq_svc+0x3f/0x88)
+[ 11.347366] Exception stack(0x80631f58 to 0x80631fa0)
+[ 11.352433] 1f40: 00000000 80633350
+[ 11.360636] 1f60: 00000000 00000000 80630000 806324e8 80632400 8069b6b4 806324a0 8062a304
+[ 11.368838] 1f80: 803e6a00 8069b6b4 8063003c 80631fa0 8000f14b 8000f14c 400f0033 ffffffff
+[ 11.377049] [<803e1b3f>] (__irq_svc) from [<8000f14c>] (arch_cpu_idle+0x30/0x34)
+[ 11.384480] [<8000f14c>] (arch_cpu_idle) from [<80045fdb>] (cpu_startup_entry+0x11f/0x204)
+[ 11.392776] [<80045fdb>] (cpu_startup_entry) from [<805dba31>] (start_kernel+0x309/0x314)
+[ 11.400978] ---[ end trace 62a3b00cc739c0df ]---
+
diff --git a/Makefile b/Makefile
index df72b64..5529123 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
VERSION = 4
PATCHLEVEL = 1
SUBLEVEL = 37
-EXTRAVERSION =
+EXTRAVERSION = -gfiber0
NAME = Series 4800
# *DOCUMENTATION*
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 19f4cc6..6a83e0e 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -842,6 +842,8 @@
source "arch/arm/mach-cns3xxx/Kconfig"
+source "arch/arm/mach-comcerto/Kconfig"
+
source "arch/arm/mach-davinci/Kconfig"
source "arch/arm/mach-digicolor/Kconfig"
diff --git a/arch/arm/Kconfig.debug b/arch/arm/Kconfig.debug
index f775d71..bbfdfec 100644
--- a/arch/arm/Kconfig.debug
+++ b/arch/arm/Kconfig.debug
@@ -184,6 +184,14 @@
If you have a Broadcom STB chip and would like early print
messages to appear over the UART, select this option.
+ config DEBUG_COMCERTO2000_UART
+ bool "Freescale Comcerto 2000 SoC Debug UART"
+ depends on ARCH_COMCERTO
+ select DEBUG_UART_8250
+ help
+ Say Y here if you want kernel low-level debugging support
+ on Freescale Comcerto 2000 SoC based platforms.
+
config DEBUG_CLPS711X_UART1
bool "Kernel low-level debugging messages via UART1"
depends on ARCH_CLPS711X
@@ -1371,6 +1379,7 @@
default 0x80230000 if DEBUG_PICOXCELL_UART
default 0x808c0000 if ARCH_EP93XX
default 0x90020000 if DEBUG_NSPIRE_CLASSIC_UART || DEBUG_NSPIRE_CX_UART
+ default 0x96400000 if DEBUG_COMCERTO2000_UART
default 0xb0060000 if DEBUG_SIRFPRIMA2_UART1
default 0xb0090000 if DEBUG_VEXPRESS_UART0_CRX
default 0xc0013000 if DEBUG_U300_UART
@@ -1439,6 +1448,7 @@
default 0xf1009000 if DEBUG_MT8135_UART3
default 0xf11f1000 if ARCH_VERSATILE
default 0xf1600000 if ARCH_INTEGRATOR
+ default 0xf1a00000 if DEBUG_COMCERTO2000_UART
default 0xf1c28000 if DEBUG_SUNXI_UART0
default 0xf1c28400 if DEBUG_SUNXI_UART1
default 0xf1f02800 if DEBUG_SUNXI_R_UART
diff --git a/arch/arm/Makefile b/arch/arm/Makefile
index 47f10e7..6ac8554 100644
--- a/arch/arm/Makefile
+++ b/arch/arm/Makefile
@@ -157,6 +157,7 @@
machine-$(CONFIG_ARCH_BERLIN) += berlin
machine-$(CONFIG_ARCH_CLPS711X) += clps711x
machine-$(CONFIG_ARCH_CNS3XXX) += cns3xxx
+machine-$(CONFIG_ARCH_COMCERTO) += comcerto
machine-$(CONFIG_ARCH_DAVINCI) += davinci
machine-$(CONFIG_ARCH_DIGICOLOR) += digicolor
machine-$(CONFIG_ARCH_DOVE) += dove
diff --git a/arch/arm/boot/dts/Makefile b/arch/arm/boot/dts/Makefile
index 992736b..82f0059 100644
--- a/arch/arm/boot/dts/Makefile
+++ b/arch/arm/boot/dts/Makefile
@@ -80,6 +80,9 @@
berlin2q-marvell-dmp.dtb
dtb-$(CONFIG_ARCH_BRCMSTB) += \
bcm7445-bcm97445svmb.dtb
+dtb-$(CONFIG_ARCH_COMCERTO) += \
+ optimus.dtb \
+ gfsc100.dtb
dtb-$(CONFIG_ARCH_DAVINCI) += \
da850-enbw-cmc.dtb \
da850-evm.dtb
diff --git a/arch/arm/boot/dts/gfsc100.dts b/arch/arm/boot/dts/gfsc100.dts
new file mode 100644
index 0000000..5a96f39
--- /dev/null
+++ b/arch/arm/boot/dts/gfsc100.dts
@@ -0,0 +1,200 @@
+/dts-v1/;
+
+#include "ls1024a.dtsi"
+/ {
+ model = "Google SpaceCast (GFSC100)";
+ compatible = "google,gfsc100", "fsl,ls1024a";
+
+ chosen {
+ bootargs = "log_buf_len=8M";
+ };
+
+ memory {
+ device_type = "memory";
+ reg = <0x80000000 0x40000000>; /* 1 GB */
+ };
+
+ pwmleds {
+ compatible = "pwm-leds";
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_gfsc100_leds>;
+
+ pwmledblue: pwmledblue {
+ label = "blue";
+ pwms = <&pwm 4 1000000>;
+ max-brightness = <200>;
+ };
+ pwmledred: pwmledred {
+ label = "red";
+ pwms = <&pwm 5 1000000>;
+ max-brightness = <200>;
+ linux,default-trigger = "default-on";
+ };
+ };
+};
+
+&pinctrl0 {
+ tpm_int {
+ gpio-hog;
+ gpios = <0 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "tpm_int";
+ };
+ fan_control_alert {
+ gpio-hog;
+ gpios = <1 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "fan_control_alert";
+ };
+ usb_brg_rst_n {
+ gpio-hog;
+ gpios = <9 GPIO_ACTIVE_LOW>;
+ output-low;
+ line-name = "usb_brg_rst_n";
+ };
+ m88rs6k_rst_n {
+ gpio-hog;
+ gpios = <11 GPIO_ACTIVE_LOW>;
+ output-low;
+ line-name = "m88rs6k_rst_n";
+ };
+ mv88E1512_rst_n {
+ gpio-hog;
+ gpios = <14 GPIO_ACTIVE_LOW>;
+ output-low;
+ line-name = "mv88e1512_rst_n";
+ };
+ usb_power {
+ gpio-hog;
+ gpios = <15 GPIO_ACTIVE_HIGH>;
+ output-high;
+ line-name = "usb_power";
+ };
+ lnb_fault_n {
+ gpio-hog;
+ gpios = <47 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "lnb_fault_n";
+ };
+ lnb_pwr_sel {
+ gpio-hog;
+ gpios = <51 GPIO_ACTIVE_HIGH>;
+ output-low;
+ line-name = "lnb_pwr_sel";
+ };
+ hw_rev_0 {
+ gpio-hog;
+ gpios = <52 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "hw_rev_0";
+ };
+ hw_rev_1 {
+ gpio-hog;
+ gpios = <53 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "hw_rev_1";
+ };
+ hw_rev_2 {
+ gpio-hog;
+ gpios = <54 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "hw_rev_2";
+ };
+ board_id_0 {
+ gpio-hog;
+ gpios = <55 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "board_id_0";
+ };
+ board_id_1 {
+ gpio-hog;
+ gpios = <56 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "board_id_1";
+ };
+ board_id_2 {
+ gpio-hog;
+ gpios = <57 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "board_id_2";
+ };
+ pinctrl_gfsc100_leds: gfsc100-leds-grp {
+ leds {
+ groups = "pwm4", "pwm5";
+ function = "pwm";
+ };
+ };
+ pinctrl_i2c: i2cgrp {
+ i2c {
+ groups = "i2c";
+ function = "i2c";
+ };
+ };
+};
+
+/* TODO(mka@): specify the partition layout only in the bootloader */
+&nor0 {
+ uloader@0 {
+ label = "uloader";
+ reg = <0x0 0x20000>;
+ };
+ loader0@20000 {
+ label = "loader0";
+ reg = <0x20000 0x80000>;
+ };
+ loader1@a0000 {
+ label = "loader1";
+ reg = <0xa0000 0x80000>;
+ };
+ env@120000 {
+ label = "env";
+ reg = <0x120000 0x20000>;
+ };
+ hnvram@140000 {
+ label = "hnvram";
+ reg = <0x140000 0x200000>;
+ };
+ kernel0@340000 {
+ label = "kernel0";
+ reg = <0x340000 0x600000>;
+ };
+ kernel1@940000 {
+ label = "kernel1";
+ reg = <0x940000 0x600000>;
+ };
+ norreserved0@F40000 {
+ label = "norreserved0";
+ reg = <0xF40000 0x00c0000>;
+ };
+};
+
+&i2c0 {
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_i2c>;
+ tpm_i2c_infineon: tpm_i2c_infineon@20 {
+ compatible = "infineon,tpm_i2c_infineon";
+ reg = <0x20>;
+ };
+ lm63: lm63@4c {
+ compatible = "national,lm63";
+ reg = <0x4c>;
+ };
+};
+
+&usb2_phy {
+ status = "okay";
+};
+
+&usb2 {
+ status = "okay";
+ dr_mode = "host";
+};
+
+&usb3_phy {
+ status = "okay";
+};
+
+&usb3 {
+ status = "okay";
+ dr_mode = "host";
+};
diff --git a/arch/arm/boot/dts/ls1024a.dtsi b/arch/arm/boot/dts/ls1024a.dtsi
new file mode 100644
index 0000000..f07c80d
--- /dev/null
+++ b/arch/arm/boot/dts/ls1024a.dtsi
@@ -0,0 +1,507 @@
+#include <dt-bindings/gpio/gpio.h>
+#include <dt-bindings/interrupt-controller/arm-gic.h>
+#include <dt-bindings/pinctrl/omap.h>
+#include <dt-bindings/phy/phy.h>
+#include <dt-bindings/reset-controller/ls1024a-resets.h>
+
+#include "skeleton.dtsi"
+
+/ {
+ compatible = "fsl,ls1024a";
+ interrupt-parent = <&gic>;
+
+ cpus {
+ #address-cells = <1>;
+ #size-cells = <0>;
+ enable-method = "fsl,ls1024a-smp";
+
+ cpu@900 {
+ compatible = "arm,cortex-a9";
+ device_type = "cpu";
+ next-level-cache = <&L2>;
+ reg = <0x900>;
+
+ clocks = <&arm_clk>;
+ clock-names = "cpu";
+
+ // clock-latency = <300000>; /* From omap-cpufreq driver */
+ };
+ cpu@901 {
+ compatible = "arm,cortex-a9";
+ device_type = "cpu";
+ next-level-cache = <&L2>;
+ reg = <0x901>;
+ };
+ };
+
+ pmu {
+ compatible = "arm,cortex-a9-pmu";
+ interrupts = <GIC_SPI 9 IRQ_TYPE_LEVEL_HIGH>,
+ <GIC_SPI 10 IRQ_TYPE_LEVEL_HIGH>;
+ };
+
+ clk_rst_syscon: clk_rst_syscon@904B0000 {
+ compatible = "syscon";
+ reg = <0x904B0000 0x1AC>;
+ #address-cells = <1>;
+ #size-cells = <1>;
+ };
+
+ reboot: syscon-reboot {
+ compatible = "syscon-reboot";
+ regmap = <&clk_rst_syscon>;
+ offset = <0x0>;
+ mask = <0x1>;
+ };
+
+ gic: interrupt-controller@fff01000 {
+ compatible = "arm,cortex-a9-gic";
+ interrupt-controller;
+ #interrupt-cells = <3>;
+ reg = <0xFFF01000 0x1000>,
+ <0xFFF00100 0x0100>;
+ };
+
+ L2: l2-cache-controller@fff10000 {
+ compatible = "arm,pl310-cache";
+ reg = <0xFFF10000 0x1000>;
+ arm,data-latency = <1 1 1>;
+ arm,tag-latency = <1 1 1>;
+ arm,filter-ranges = <0x0 0x80000000>;
+ cache-unified;
+ cache-level = <2>;
+ };
+
+ reset: reset-controller {
+ compatible = "fsl,ls1024a-reset";
+ #reset-cells = <1>;
+ syscon = <&clk_rst_syscon>;
+ };
+
+ ref_clk: ref_clk {
+ #clock-cells = <0>;
+ compatible = "fixed-clock";
+ clock-frequency = <24000000>;
+ };
+
+ pll0: pll0 {
+ #clock-cells = <0>;
+ compatible = "fixed-factor-clock";
+ clock-div = <6>;
+ clock-mult = <450>;
+ clocks = <&ref_clk>;
+ };
+
+ pll1: pll1 {
+ #clock-cells = <0>;
+ compatible = "fixed-factor-clock";
+ clock-div = <12>;
+ clock-mult = <500>;
+ clocks = <&ref_clk>;
+ };
+
+ pll2: pll2 {
+ #clock-cells = <0>;
+ compatible = "fixed-factor-clock";
+ clock-div = <6>;
+ clock-mult = <375>;
+ clocks = <&ref_clk>;
+ };
+
+ pll3: pll3 {
+ #clock-cells = <0>;
+ compatible = "fixed-clock";
+ clock-frequency = <1066000000>;
+ };
+
+ gemtx_clk: gemtx_clk {
+ #clock-cells = <0>;
+ reg = <0x904B0130 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ ddr_clk: ddr_clk {
+ #clock-cells = <0>;
+ reg = <0x904B00F0 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ arm_clk: arm_clk {
+ #clock-cells = <0>;
+ reg = <0x904B0080 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ l2cc_clk: l2cc_clk {
+ #clock-cells = <0>;
+ reg = <0x904B0090 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ axi_clk: axi_clk {
+ #clock-cells = <0>;
+ reg = <0x904B0040 0x10>;
+ fsl,divreg-offset = <0xC>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ ipsec_eape_clk: ipsec_eape_clk {
+ #clock-cells = <0>;
+ reg = <0x904B0110 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ hfe_core_clk: hfe_core_clk {
+ #clock-cells = <0>;
+ reg = <0x904B0100 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ ntgref_clk: ntgref_clk {
+ #clock-cells = <0>;
+ reg = <0x904B0140 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ sata_oob_clk: sata_oob_clk {
+ #clock-cells = <0>;
+ reg = <0x904B0170 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ sata_pmu_clk: sata_pmu_clk {
+ #clock-cells = <0>;
+ reg = <0x904B0160 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ ext_phy0_clk: ext_phy0_clk {
+ #clock-cells = <0>;
+ reg = <0x904B00C0 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ ext_phy1_clk: ext_phy1_clk {
+ #clock-cells = <0>;
+ reg = <0x904B00D0 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ ext_phy2_clk: ext_phy2_clk {
+ #clock-cells = <0>;
+ reg = <0x904B00E0 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ tpi_clk: tpi_clk {
+ #clock-cells = <0>;
+ reg = <0x904B00A0 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ csys_clk: csys_clk {
+ #clock-cells = <0>;
+ reg = <0x904B00B0 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ tsuntg_clk: tsuntg_clk {
+ #clock-cells = <0>;
+ reg = <0x904B0150 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ sata_occ_clk: sata_occ_clk {
+ #clock-cells = <0>;
+ reg = <0x904B0180 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ pcie_occ_clk: pcie_occ_clk {
+ #clock-cells = <0>;
+ reg = <0x904B0190 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+
+ sgmii_occ_clk: sgmii_occ_clk {
+ #clock-cells = <0>;
+ reg = <0x904B01A0 0x8>;
+ compatible = "fsl,ls1024a-clock";
+ clocks = <&pll0 &pll1 &pll2 &pll3 &ref_clk>;
+ };
+ local-timer@fff00600 {
+ compatible = "arm,cortex-a9-twd-timer";
+ clocks = <&axi_clk>;
+ reg = <0xFFF00600 0x20>;
+ interrupts = <GIC_PPI 13 (GIC_CPU_MASK_RAW(3) | IRQ_TYPE_LEVEL_HIGH)>;
+ };
+ gp-timer@90450000 {
+ compatible = "fsl,ls1024a-gpt";
+ clocks = <&axi_clk>;
+ reg = <0x90450000 0xD0>;
+ interrupts = <GIC_SPI 55 IRQ_TYPE_EDGE_RISING
+ GIC_SPI 56 IRQ_TYPE_EDGE_RISING
+ GIC_SPI 57 IRQ_TYPE_EDGE_RISING
+ GIC_SPI 58 IRQ_TYPE_EDGE_RISING
+ GIC_SPI 59 IRQ_TYPE_EDGE_RISING
+ GIC_SPI 60 IRQ_TYPE_EDGE_RISING>;
+ };
+
+ watchdog@904500D0 {
+ compatible = "fsl,ls1024a-wdt";
+ reg = <0x904500D0 0xC>;
+ regmap = <&clk_rst_syscon>;
+ clocks = <&axi_clk>;
+ };
+
+ nor0: flash@c0000000 {
+ compatible = "cfi-flash";
+ reg = <0xc0000000 0x04000000>;
+ bank-width = <2>;
+ #address-cells = <1>;
+ #size-cells = <1>;
+ };
+
+ nand0: nand@c8300000 {
+ compatible = "fsl,ls1024a-nand";
+ #address-cells = <1>;
+ #size-cells = <1>;
+ reg = <0xc8300000 0x2000
+ 0xCFFF0000 0x2c>;
+ ce-gpios = <&pinctrl0 28 GPIO_ACTIVE_HIGH>;
+ br-gpios = <&pinctrl0 29 GPIO_ACTIVE_HIGH>;
+ };
+
+ otp0: otp@904F0000 {
+ compatible = "fsl,ls1024a-otp";
+ reg = <0x904F0000 0x58>;
+ clocks = <&axi_clk>;
+ };
+
+ pwm: pwm@12dd0000 {
+ compatible = "fsl,ls1024a-pwm";
+ reg = <0x90458000 0x38>;
+ #pwm-cells = <2>;
+ clocks = <&axi_clk>;
+ };
+
+ pinctrl0: pinctrl@90470000 {
+ compatible = "fsl,ls1024a-pinctrl";
+ reg = <0x90470000 0x100>;
+ gpio-controller;
+ #gpio-cells = <2>;
+ gpio-ranges = <&pinctrl0 0 0 0>;
+ gpio-ranges-group-names = "gpio";
+ interrupt-controller;
+ #interrupt-cells = <2>;
+ interrupt-parent = <&gic>;
+ interrupts = <GIC_SPI 45 IRQ_TYPE_NONE>;
+ };
+
+ /* We are not using uart0, only uart1 */
+ uart1: serial@96400000 {
+ compatible = "snps,dw-apb-uart";
+ reg = <0x96400000 0x100>;
+ interrupts = <GIC_SPI 27 IRQ_TYPE_LEVEL_HIGH>;
+ reg-shift = <2>;
+ reg-io-width = <4>;
+ clocks = <&axi_clk>;
+ clock-names = "baudclk";
+ };
+
+ spi0: spi@fff00000 {
+ compatible = "snps,dw-apb-ssi";
+ #address-cells = <1>;
+ #size-cells = <0>;
+ reg = <0x96500000 0x1000>;
+ interrupts = <GIC_SPI 28 IRQ_TYPE_LEVEL_HIGH>;
+ num-cs = <1>;
+ clocks = <&axi_clk>; /* TODO: Should be DUS clock */
+ };
+
+ i2c0: i2c@9049C000 {
+ compatible = "fsl,ls1024a-i2c";
+ #address-cells = <1>;
+ #size-cells = <0>;
+ reg = <0x9049C000 0x1000>;
+ interrupts = <GIC_SPI 30 IRQ_TYPE_LEVEL_HIGH>;
+ clocks = <&axi_clk>; /* TODO: Should be spi_i2c */
+ };
+
+ snowbush_phy: phy@90590000 {
+ compatible = "fsl,ls1024a-snowbush-phy";
+ #address-cells = <1>;
+ #size-cells = <1>;
+ ranges;
+
+ phy_port0: port@90590000 {
+ #phy-cells = <1>;
+ reg = <0x90590000 0x4000>, <0x9041002C 0x10>;
+ reg-names = "serdes", "dwc1_cfg";
+ resets = <&reset LS1024A_SERDES0_RESET>,
+ <&reset LS1024A_SERDES_PCIE0_RESET>;
+ reset-names = "serdes", "serdes_pcie";
+ };
+
+ phy_port1: port@90594000 {
+ #phy-cells = <1>;
+ reg = <0x90594000 0x4000>, <0x9041003C 0x10>;
+ reg-names = "serdes", "dwc1_cfg";
+ resets = <&reset LS1024A_SERDES1_RESET>,
+ <&reset LS1024A_SERDES_PCIE1_RESET>,
+ <&reset LS1024A_SERDES_SATA0_RESET>;
+ reset-names = "serdes", "serdes_pcie", "serdes_sata";
+ };
+ phy_port2: port@90598000 {
+ #phy-cells = <1>;
+ reg = <0x90598000 0x4000>, <0x9041004C 0x10>;
+ reg-names = "serdes", "dwc1_cfg";
+ resets = <&reset LS1024A_SERDES2_RESET>,
+ <&reset LS1024A_SERDES_SATA1_RESET>;
+ reset-names = "serdes", "serdes_sata";
+ };
+ };
+
+ pci_sata_usb_ctrl: pci_sata_usb_ctrl@90460000 {
+ compatible = "syscon";
+ reg = <0x90460000 0x120>;
+ #address-cells = <1>;
+ #size-cells = <1>;
+ };
+ ahci0: ahci@9d000000 {
+ compatible = "generic-ahci";
+ reg = <0x9d000000 0x10000>;
+ interrupts = <GIC_SPI 16 IRQ_TYPE_LEVEL_HIGH>;
+ ports-implemented = <0x3>;
+ #address-cells = <1>;
+ #size-cells = <0>;
+ sata0: sata-port@0 {
+ reg = <0>;
+ };
+ sata1: sata-port@1 {
+ reg = <1>;
+ phys = <&phy_port2 PHY_TYPE_SATA>;
+ };
+ };
+ pcie0: pcie@98000000 {
+ compatible = "fsl,ls1024a-pcie", "snps,dw-pcie";
+ reg = <0x98000000 0x04000>, /* TODO: verify size */
+ <0xaff10000 0x20000>;
+ reg-names = "dbi", "config";
+ app-syscon = <&pci_sata_usb_ctrl>;
+ app-profile = <0>;
+ #address-cells = <3>;
+ #size-cells = <2>;
+ device_type = "pci";
+ ranges = <0x81000000 0 0 0xaff00000 0 0x00010000 /* downstream I/O */
+ 0x82000000 0 0xa0000000 0xa0000000 0 0x0fe00000>; /* non-prefetchable memory */
+ num-lanes = <1>;
+ phys = <&phy_port0 PHY_TYPE_PCIE>;
+ phy-names = "pcie-phy";
+ interrupts = <GIC_SPI 43 IRQ_TYPE_LEVEL_HIGH>;
+ interrupt-names = "msi";
+ #interrupt-cells = <1>;
+ interrupt-map-mask = <0 0 0 0>;
+ interrupt-map = <0 0 0 0 &gic GIC_SPI 43 IRQ_TYPE_LEVEL_HIGH>;
+ clocks = <&axi_clk>; /* TODO: Should be pcie0 */
+ clock-names = "pcie";
+ resets = <&reset LS1024A_AXI_PCIE0_RESET>;
+ reset-names = "axi";
+ };
+
+ pcie1: pcie@99000000 {
+ compatible = "fsl,ls1024a-pcie", "snps,dw-pcie";
+ reg = <0x99000000 0x04000>, /* TODO: verify size */
+ <0xbff10000 0x20000>;
+ reg-names = "dbi", "config";
+ app-syscon = <&pci_sata_usb_ctrl>;
+ app-profile = <1>;
+ #address-cells = <3>;
+ #size-cells = <2>;
+ device_type = "pci";
+ ranges = <0x81000000 0 0 0xbff00000 0 0x00010000 /* downstream I/O */
+ 0x82000000 0 0xb0000000 0xb0000000 0 0x0fe00000>; /* non-prefetchable memory */
+ num-lanes = <1>;
+ phys = <&phy_port1 PHY_TYPE_PCIE>;
+ phy-names = "pcie-phy";
+ interrupts = <GIC_SPI 44 IRQ_TYPE_LEVEL_HIGH>;
+ interrupt-names = "msi";
+ #interrupt-cells = <1>;
+ interrupt-map-mask = <0 0 0 0>;
+ interrupt-map = <0 0 0 0 &gic GIC_SPI 44 IRQ_TYPE_LEVEL_HIGH>;
+ clocks = <&axi_clk>; /* TODO: Should be pcie1 */
+ clock-names = "pcie";
+ resets = <&reset LS1024A_AXI_PCIE1_RESET>;
+ reset-names = "axi";
+ };
+
+ usb2_phy: usb2_phy@90410000 {
+ compatible = "fsl,ls1024a-usb2-phy";
+ reg = <0x90410000 0x4>;
+ syscon = <&pci_sata_usb_ctrl>;
+ #phy-cells = <0>;
+ resets = <&reset LS1024A_USB0_PHY_RESET &reset LS1024A_UTMI_USB0_RESET &reset LS1024A_AXI_USB0_RESET>;
+ reset-names = "phy", "utmi", "axi";
+ clocks = <&axi_clk>; /* TODO: Should be usb0 */
+ clock-names = "usb";
+ status = "disabled";
+ };
+
+ /* USB 2.0 Synopsys DesignWare controller */
+ usb2: usb2@92000000 {
+ compatible = "snps,dwc2";
+ reg = <0x92000000 0x1000000>;
+ interrupts = <GIC_SPI 21 IRQ_TYPE_LEVEL_HIGH>;
+ phys = <&usb2_phy>;
+ phy-names = "usb2-phy";
+ status = "disabled";
+ };
+
+ usb3_phy: usb3_phy@904a0000 {
+ compatible = "fsl,ls1024a-usb3-phy";
+ reg = <0x904A0000 0x100>;
+ #phy-cells = <0>;
+ resets = <&reset LS1024A_USB1_PHY_RESET>;
+ reset-names = "phy";
+ status = "disabled";
+ };
+
+ usb3: usb3 {
+ compatible = "fsl,ls1024a-dwc3";
+ clocks = <&axi_clk>; /* TODO: Should be usb1 */
+ clock-names = "usb";
+ resets = <&reset LS1024A_UTMI_USB1_RESET &reset LS1024A_AXI_USB1_RESET>;
+ reset-names = "utmi", "axi";
+ #address-cells = <1>;
+ #size-cells = <1>;
+ ranges;
+ status = "disabled";
+
+ dwc3: dwc3@9f000000 {
+ compatible = "snps,dwc3";
+ reg = <0x9F000000 0x00800000>;
+ interrupts = <GIC_SPI 22 IRQ_TYPE_LEVEL_HIGH>;
+ phys = <&usb3_phy>;
+ phy-names = "usb3-phy";
+ };
+ };
+
+};
diff --git a/arch/arm/boot/dts/optimus.dts b/arch/arm/boot/dts/optimus.dts
new file mode 100644
index 0000000..668ac74
--- /dev/null
+++ b/arch/arm/boot/dts/optimus.dts
@@ -0,0 +1,242 @@
+/dts-v1/;
+
+#include "ls1024a.dtsi"
+/ {
+ model = "Google Fiber Optimus";
+ compatible = "google,optimus", "fsl,ls1024a";
+
+ chosen {
+ bootargs = "log_buf_len=8M";
+ };
+
+ memory {
+ device_type = "memory";
+ reg = <0x80000000 0x40000000>; /* 1 GB */
+ };
+
+ pwmleds {
+ compatible = "pwm-leds";
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_optimus_leds>;
+
+ pwmledblue: pwmledblue {
+ label = "blue";
+ pwms = <&pwm 4 1000000>;
+ max-brightness = <200>;
+ };
+ pwmledred: pwmledred {
+ label = "red";
+ pwms = <&pwm 5 1000000>;
+ max-brightness = <200>;
+ linux,default-trigger = "default-on";
+ };
+ };
+};
+
+&pinctrl0 {
+ fan_control_alert {
+ gpio-hog;
+ gpios = <1 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "fan_control_alert";
+ };
+ moca_sideband_0 {
+ gpio-hog;
+ gpios = <2 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "moca_sideband_0";
+ };
+ moca_sideband_1 {
+ gpio-hog;
+ gpios = <3 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "moca_sideband_1";
+ };
+ mini_wake0n {
+ gpio-hog;
+ gpios = <4 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "mini_wake0n";
+ };
+ mini_wake1n {
+ gpio-hog;
+ gpios = <5 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "mini_wake1n";
+ };
+ qca8337n_reset {
+ gpio-hog;
+ gpios = <14 GPIO_ACTIVE_LOW>;
+ output-low;
+ line-name = "qca8337n_reset";
+ };
+ usb_power {
+ gpio-hog;
+ gpios = <15 GPIO_ACTIVE_HIGH>;
+ output-high;
+ line-name = "usb_power";
+ };
+ 11ac_power {
+ gpio-hog;
+ gpios = <48 GPIO_ACTIVE_HIGH>;
+ output-high;
+ line-name = "wifi_11ac_power";
+ };
+ hw_rev_0 {
+ gpio-hog;
+ gpios = <52 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "hw_rev_0";
+ };
+ hw_rev_1 {
+ gpio-hog;
+ gpios = <53 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "hw_rev_1";
+ };
+ hw_rev_2 {
+ gpio-hog;
+ gpios = <54 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "hw_rev_2";
+ };
+ board_id_0 {
+ gpio-hog;
+ gpios = <55 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "board_id_0";
+ };
+ board_id_1 {
+ gpio-hog;
+ gpios = <56 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "board_id_1";
+ };
+ board_id_2 {
+ gpio-hog;
+ gpios = <57 GPIO_ACTIVE_HIGH>;
+ input;
+ line-name = "board_id_2";
+ };
+ pinctrl_optimus_leds: optimus-leds-grp {
+ leds {
+ groups = "pwm4", "pwm5";
+ function = "pwm";
+ };
+ };
+ pinctrl_i2c: i2cgrp {
+ i2c {
+ groups = "i2c";
+ function = "i2c";
+ };
+ };
+ pinctrl_spi: spigrp {
+ spi {
+ groups = "spi_2", "spi_2_ss0";
+ function = "spi_2";
+ };
+ };
+};
+
+&nor0 {
+ uloader@0 {
+ label = "uloader";
+ reg = <0x0 0x20000>;
+ };
+ loader0@20000 {
+ label = "loader0";
+ reg = <0x20000 0x80000>;
+ };
+ loader1@a0000 {
+ label = "loader1";
+ reg = <0xa0000 0x80000>;
+ };
+ env@120000 {
+ label = "env";
+ reg = <0x120000 0x20000>;
+ };
+ hnvram@140000 {
+ label = "hnvram";
+ reg = <0x140000 0x200000>;
+ };
+ norreserved0@340000 {
+ label = "norreserved0";
+ reg = <0x340000 0x3cc0000>;
+ };
+};
+
+&nand0 {
+ reserved@0 {
+ label = "reserved";
+ reg = <0x0 0x800000>;
+ };
+ kernel0@800000 {
+ label = "kernel0";
+ reg = <0x800000 0x2000000>;
+ };
+ kernel1@2800000 {
+ label = "kernel1";
+ reg = <0x2800000 0x2000000>;
+ };
+ rootfs0@4800000 {
+ label = "rootfs0";
+ reg = <0x4800000 0x12000000>;
+ };
+ rootfs1@16800000 {
+ label = "rootfs1";
+ reg = <0x16800000 0x12000000>;
+ };
+ emergency@28800000 {
+ label = "emergency";
+ reg = <0x28800000 0x2000000>;
+ };
+ data+ubi@2a800000 {
+ label = "data+ubi";
+ reg = <0x2a800000 0x55800000>;
+ };
+};
+
+&pcie0 {
+ reset-gpios = <&pinctrl0 62 GPIO_ACTIVE_LOW>;
+};
+
+&pcie1 {
+ reset-gpios = <&pinctrl0 27 GPIO_ACTIVE_LOW>;
+};
+
+&spi0 {
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_spi>;
+ BCM6803@0 {
+ compatible = "brcm,bcm6803-spi";
+ spi-max-frequency = <20000000>;
+ interrupt-parent = <&pinctrl0>;
+ interrupts = <0 IRQ_TYPE_LEVEL_HIGH>;
+ reg = <0>;
+ spi-cpol;
+ spi-cpha;
+ rf-band = "ext_d";
+ i2c-base = <0x10406200>;
+ i2c-addr = <0x70>;
+ reset-gpios = <&pinctrl0 11 GPIO_ACTIVE_LOW>;
+ if-name = "moca0";
+ };
+};
+
+&i2c0 {
+ pinctrl-names = "default";
+ pinctrl-0 = <&pinctrl_i2c>;
+ lm63: lm63@4c {
+ compatible = "national,lm63";
+ reg = <0x4c>;
+ };
+};
+
+&usb3_phy {
+ status = "okay";
+};
+
+&usb3 {
+ status = "okay";
+ dr_mode = "host";
+};
diff --git a/arch/arm/configs/gfrg200_defconfig b/arch/arm/configs/gfrg200_defconfig
new file mode 100644
index 0000000..81ba863
--- /dev/null
+++ b/arch/arm/configs/gfrg200_defconfig
@@ -0,0 +1,346 @@
+# CONFIG_LOCALVERSION_AUTO is not set
+# CONFIG_SWAP is not set
+CONFIG_SYSVIPC=y
+CONFIG_IRQ_DOMAIN_DEBUG=y
+CONFIG_NO_HZ=y
+CONFIG_HIGH_RES_TIMERS=y
+CONFIG_BSD_PROCESS_ACCT=y
+CONFIG_IKCONFIG=y
+CONFIG_IKCONFIG_PROC=y
+CONFIG_LOG_BUF_SHIFT=14
+CONFIG_NAMESPACES=y
+CONFIG_RELAY=y
+CONFIG_ANTIREBOOTLOOP=y
+CONFIG_BLK_DEV_INITRD=y
+# CONFIG_RD_BZIP2 is not set
+# CONFIG_RD_LZMA is not set
+# CONFIG_RD_XZ is not set
+# CONFIG_RD_LZO is not set
+# CONFIG_RD_LZ4 is not set
+CONFIG_EXPERT=y
+CONFIG_PRINTK_PERSIST=y
+CONFIG_PROFILING=y
+CONFIG_KPROBES=y
+CONFIG_MODULES=y
+CONFIG_MODULE_FORCE_LOAD=y
+CONFIG_MODULE_UNLOAD=y
+CONFIG_MODULE_FORCE_UNLOAD=y
+CONFIG_MODVERSIONS=y
+CONFIG_MODULE_SRCVERSION_ALL=y
+CONFIG_PARTITION_ADVANCED=y
+CONFIG_ARCH_COMCERTO=y
+CONFIG_COMCERTO_DMA_COHERENT_SKB=y
+# CONFIG_ARM_ERRATA_643719 is not set
+CONFIG_ARM_ERRATA_720789=y
+CONFIG_ARM_ERRATA_754322=y
+CONFIG_ARM_ERRATA_764369=y
+CONFIG_PCI=y
+CONFIG_PCI_MSI=y
+CONFIG_PCI_DEBUG=y
+CONFIG_PCI_LS1024A=y
+CONFIG_SMP=y
+CONFIG_HAVE_ARM_ARCH_TIMER=y
+CONFIG_VMSPLIT_2G=y
+CONFIG_NR_CPUS=2
+CONFIG_PREEMPT=y
+CONFIG_THUMB2_KERNEL=y
+CONFIG_CMA=y
+CONFIG_ZBOOT_ROM_TEXT=0x0
+CONFIG_ZBOOT_ROM_BSS=0x0
+CONFIG_ARM_APPENDED_DTB=y
+CONFIG_ARM_ATAG_DTB_COMPAT=y
+CONFIG_ARM_ATAG_DTB_COMPAT_CMDLINE_EXTEND=y
+CONFIG_VFP=y
+CONFIG_NEON=y
+CONFIG_BINFMT_MISC=y
+# CONFIG_SUSPEND is not set
+CONFIG_NET=y
+CONFIG_PACKET=y
+CONFIG_UNIX=y
+CONFIG_INET=y
+CONFIG_IP_MULTICAST=y
+CONFIG_IP_ADVANCED_ROUTER=y
+CONFIG_IP_ROUTE_VERBOSE=y
+CONFIG_IP_MROUTE=y
+CONFIG_SYN_COOKIES=y
+CONFIG_TCP_CONG_ADVANCED=y
+CONFIG_TCP_CONG_BIC=y
+CONFIG_TCP_CONG_WESTWOOD=y
+CONFIG_TCP_CONG_HTCP=y
+CONFIG_TCP_CONG_HSTCP=y
+CONFIG_TCP_CONG_HYBLA=y
+CONFIG_TCP_CONG_SCALABLE=y
+CONFIG_TCP_CONG_LP=y
+CONFIG_TCP_CONG_VENO=y
+CONFIG_TCP_CONG_YEAH=y
+CONFIG_TCP_CONG_ILLINOIS=y
+CONFIG_IPV6=y
+CONFIG_NETFILTER=y
+# CONFIG_BRIDGE_NETFILTER is not set
+CONFIG_NF_CONNTRACK=m
+CONFIG_NF_CONNTRACK_EVENTS=y
+CONFIG_NF_CONNTRACK_FTP=m
+CONFIG_NF_CONNTRACK_H323=m
+CONFIG_NF_CONNTRACK_IRC=m
+CONFIG_NF_CONNTRACK_PPTP=m
+CONFIG_NF_CONNTRACK_RTSP=m
+CONFIG_NF_CONNTRACK_SIP=m
+CONFIG_NF_CONNTRACK_TFTP=m
+CONFIG_NF_CT_NETLINK=m
+CONFIG_NETFILTER_XT_TARGET_CLASSIFY=m
+CONFIG_NETFILTER_XT_TARGET_CONNMARK=m
+CONFIG_NETFILTER_XT_TARGET_DSCP=m
+CONFIG_NETFILTER_XT_TARGET_HL=m
+CONFIG_NETFILTER_XT_TARGET_LOG=m
+CONFIG_NETFILTER_XT_TARGET_NETMAP=m
+CONFIG_NETFILTER_XT_TARGET_REDIRECT=m
+CONFIG_NETFILTER_XT_TARGET_TRACE=m
+CONFIG_NETFILTER_XT_TARGET_TCPMSS=m
+CONFIG_NETFILTER_XT_MATCH_COMMENT=m
+CONFIG_NETFILTER_XT_MATCH_CONNBYTES=m
+CONFIG_NETFILTER_XT_MATCH_CONNTRACK=m
+CONFIG_NETFILTER_XT_MATCH_DSCP=m
+CONFIG_NETFILTER_XT_MATCH_ECN=m
+CONFIG_NETFILTER_XT_MATCH_HELPER=m
+CONFIG_NETFILTER_XT_MATCH_HL=m
+CONFIG_NETFILTER_XT_MATCH_IPRANGE=m
+CONFIG_NETFILTER_XT_MATCH_LENGTH=m
+CONFIG_NETFILTER_XT_MATCH_LIMIT=m
+CONFIG_NETFILTER_XT_MATCH_MAC=m
+CONFIG_NETFILTER_XT_MATCH_MARK=m
+CONFIG_NETFILTER_XT_MATCH_MULTIPORT=m
+CONFIG_NETFILTER_XT_MATCH_OWNER=m
+CONFIG_NETFILTER_XT_MATCH_PKTTYPE=m
+CONFIG_NETFILTER_XT_MATCH_QUOTA=m
+CONFIG_NETFILTER_XT_MATCH_RECENT=m
+CONFIG_NETFILTER_XT_MATCH_STATE=m
+CONFIG_NETFILTER_XT_MATCH_STATISTIC=m
+CONFIG_NETFILTER_XT_MATCH_STRING=m
+CONFIG_NETFILTER_XT_MATCH_TCPMSS=m
+CONFIG_NETFILTER_XT_MATCH_TIME=m
+CONFIG_NF_CONNTRACK_IPV4=m
+CONFIG_IP_NF_IPTABLES=m
+CONFIG_IP_NF_FILTER=m
+CONFIG_IP_NF_TARGET_REJECT=m
+CONFIG_IP_NF_NAT=m
+CONFIG_IP_NF_TARGET_MASQUERADE=m
+CONFIG_IP_NF_MANGLE=m
+CONFIG_IP_NF_TARGET_ECN=m
+CONFIG_IP_NF_RAW=m
+CONFIG_NF_CONNTRACK_IPV6=m
+CONFIG_IP6_NF_IPTABLES=m
+CONFIG_IP6_NF_MATCH_AH=m
+CONFIG_IP6_NF_MATCH_EUI64=m
+CONFIG_IP6_NF_MATCH_FRAG=m
+CONFIG_IP6_NF_MATCH_OPTS=m
+CONFIG_IP6_NF_MATCH_IPV6HEADER=m
+CONFIG_IP6_NF_MATCH_MH=m
+CONFIG_IP6_NF_MATCH_RT=m
+CONFIG_IP6_NF_FILTER=m
+CONFIG_IP6_NF_TARGET_REJECT=m
+CONFIG_IP6_NF_MANGLE=m
+CONFIG_IP6_NF_RAW=m
+CONFIG_IP6_NF_NAT=m
+CONFIG_BRIDGE=y
+CONFIG_VLAN_8021Q=y
+CONFIG_NET_SCHED=y
+CONFIG_NET_SCH_CBQ=m
+CONFIG_NET_SCH_HTB=m
+CONFIG_NET_SCH_CSZ=m
+CONFIG_NET_SCH_HFSC=m
+CONFIG_NET_SCH_PRIO=m
+CONFIG_NET_SCH_MULTIQ=m
+CONFIG_NET_SCH_RED=m
+CONFIG_NET_SCH_SFB=m
+CONFIG_NET_SCH_SFQ=m
+CONFIG_NET_SCH_TEQL=m
+CONFIG_NET_SCH_TBF=m
+CONFIG_NET_SCH_GRED=m
+CONFIG_NET_SCH_DSMARK=m
+CONFIG_NET_SCH_NETEM=m
+CONFIG_NET_SCH_DRR=m
+CONFIG_NET_SCH_MQPRIO=m
+CONFIG_NET_SCH_CHOKE=m
+CONFIG_NET_SCH_QFQ=m
+CONFIG_NET_SCH_CODEL=m
+CONFIG_NET_SCH_FQ_CODEL=m
+CONFIG_NET_SCH_FQ=m
+CONFIG_NET_SCH_HHF=m
+CONFIG_NET_SCH_PIE=m
+CONFIG_NET_SCH_INGRESS=m
+CONFIG_NET_CLS=y
+CONFIG_NET_CLS_ACT=y
+CONFIG_NET_CLS_TCINDEX=m
+CONFIG_NET_CLS_ROUTE4=m
+CONFIG_NET_CLS_ROUTE=y
+CONFIG_NET_CLS_FW=m
+CONFIG_NET_CLS_U32=m
+CONFIG_NET_CLS_RSVP=m
+CONFIG_NET_CLS_RSVP6=m
+CONFIG_NET_ACT_SKBEDIT=m
+CONFIG_NET_CLS_POLICE=y
+CONFIG_NET_ESTIMATOR=y
+CONFIG_NET_PKTGEN=m
+CONFIG_NET_QOS=y
+CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
+CONFIG_DEVTMPFS=y
+CONFIG_DEVTMPFS_MOUNT=y
+CONFIG_DMA_CMA=y
+CONFIG_CMA_SIZE_MBYTES=32
+CONFIG_MTD=y
+CONFIG_MTD_BLOCK=y
+CONFIG_MTD_CFI=y
+CONFIG_MTD_CFI_INTELEXT=y
+CONFIG_MTD_CFI_AMDSTD=y
+CONFIG_MTD_CFI_STAA=y
+CONFIG_MTD_PHYSMAP_OF=y
+CONFIG_MTD_NAND=y
+CONFIG_MTD_NAND_ECC_BCH=y
+CONFIG_MTD_NAND_LS1024A=y
+CONFIG_MTD_UBI=y
+CONFIG_MTD_UBI_WL_THRESHOLD=128
+CONFIG_MTD_UBI_BEB_LIMIT=25
+CONFIG_MTD_UBI_GLUEBI=y
+CONFIG_BLK_DEV_LOOP=y
+CONFIG_BLK_DEV_RAM=y
+CONFIG_BLK_DEV_RAM_SIZE=16384
+CONFIG_EEPROM_93CX6=y
+CONFIG_BLK_DEV_SD=y
+CONFIG_SCSI_CONSTANTS=y
+# CONFIG_SCSI_LOWLEVEL is not set
+CONFIG_ATA=y
+# CONFIG_SATA_PMP is not set
+CONFIG_SATA_AHCI_PLATFORM=y
+# CONFIG_ATA_SFF is not set
+CONFIG_MD=y
+CONFIG_BLK_DEV_DM=y
+CONFIG_DM_VERITY=y
+CONFIG_NETDEVICES=y
+CONFIG_TUN=y
+# CONFIG_NET_VENDOR_ARC is not set
+# CONFIG_NET_CADENCE is not set
+# CONFIG_NET_VENDOR_BROADCOM is not set
+# CONFIG_NET_VENDOR_CIRRUS is not set
+# CONFIG_NET_VENDOR_FARADAY is not set
+# CONFIG_NET_VENDOR_HISILICON is not set
+# CONFIG_NET_VENDOR_INTEL is not set
+# CONFIG_NET_VENDOR_MARVELL is not set
+# CONFIG_NET_VENDOR_MICREL is not set
+# CONFIG_NET_VENDOR_NATSEMI is not set
+# CONFIG_NET_VENDOR_QUALCOMM is not set
+# CONFIG_NET_VENDOR_ROCKER is not set
+# CONFIG_NET_VENDOR_SAMSUNG is not set
+# CONFIG_NET_VENDOR_SEEQ is not set
+# CONFIG_NET_VENDOR_SMSC is not set
+# CONFIG_NET_VENDOR_STMICRO is not set
+# CONFIG_NET_VENDOR_VIA is not set
+# CONFIG_NET_VENDOR_WIZNET is not set
+CONFIG_PHYLIB=y
+CONFIG_AT803X_PHY=y
+CONFIG_FIXED_PHY=y
+# CONFIG_WLAN is not set
+# CONFIG_INPUT_MOUSEDEV is not set
+# CONFIG_INPUT_KEYBOARD is not set
+# CONFIG_INPUT_MOUSE is not set
+# CONFIG_LEGACY_PTYS is not set
+CONFIG_SERIAL_8250=y
+# CONFIG_SERIAL_8250_DEPRECATED_OPTIONS is not set
+CONFIG_SERIAL_8250_CONSOLE=y
+CONFIG_SERIAL_8250_DW=y
+# CONFIG_HW_RANDOM is not set
+CONFIG_I2C=y
+# CONFIG_I2C_COMPAT is not set
+CONFIG_I2C_CHARDEV=y
+CONFIG_I2C_LS1024A=y
+CONFIG_SPI=y
+CONFIG_SPI_DESIGNWARE=y
+CONFIG_SPI_DW_MMIO=y
+CONFIG_GPIOLIB=y
+CONFIG_GPIO_SYSFS=y
+CONFIG_POWER_SUPPLY=y
+CONFIG_POWER_RESET=y
+CONFIG_POWER_RESET_SYSCON=y
+CONFIG_SENSORS_LM63=y
+CONFIG_WATCHDOG=y
+CONFIG_LS1024A_WATCHDOG=y
+CONFIG_USB=y
+CONFIG_USB_XHCI_HCD=y
+CONFIG_USB_STORAGE=y
+CONFIG_USB_DWC3=y
+# CONFIG_USB_DWC3_PCI is not set
+CONFIG_USB_SERIAL=y
+CONFIG_USB_SERIAL_FTDI_SIO=y
+CONFIG_USB_SERIAL_KEYSPAN=y
+CONFIG_USB_SERIAL_PL2303=y
+CONFIG_NEW_LEDS=y
+CONFIG_LEDS_CLASS=y
+CONFIG_LEDS_CLASS_FLASH=y
+CONFIG_LEDS_GPIO=y
+CONFIG_LEDS_PWM=y
+CONFIG_LEDS_TRIGGERS=y
+CONFIG_LEDS_TRIGGER_TIMER=y
+CONFIG_LEDS_TRIGGER_ONESHOT=y
+CONFIG_LEDS_TRIGGER_HEARTBEAT=y
+CONFIG_LEDS_TRIGGER_BACKLIGHT=y
+CONFIG_LEDS_TRIGGER_CPU=y
+CONFIG_LEDS_TRIGGER_GPIO=y
+CONFIG_LEDS_TRIGGER_DEFAULT_ON=y
+# CONFIG_IOMMU_SUPPORT is not set
+CONFIG_PWM=y
+CONFIG_PWM_LS1024A=y
+CONFIG_PHY_LS1024A_SNOWBUSH=y
+CONFIG_PHY_LS1024A_USB3=y
+CONFIG_FIRMWARE_MEMMAP=y
+CONFIG_EXT4_FS=y
+CONFIG_MSDOS_FS=y
+CONFIG_VFAT_FS=y
+CONFIG_TMPFS=y
+CONFIG_UBIFS_FS=y
+CONFIG_SQUASHFS=y
+CONFIG_SQUASHFS_DECOMP_MULTI=y
+CONFIG_SQUASHFS_XZ=y
+CONFIG_SQUASHFS_EMBEDDED=y
+CONFIG_NFS_FS=y
+CONFIG_NFS_V4=y
+CONFIG_NFS_V4_1=y
+CONFIG_NFS_V4_2=y
+CONFIG_NLS_CODEPAGE_437=y
+CONFIG_NLS_ISO8859_1=y
+CONFIG_NLS_UTF8=y
+CONFIG_PRINTK_TIME=y
+CONFIG_DYNAMIC_DEBUG=y
+CONFIG_DEBUG_SECTION_MISMATCH=y
+CONFIG_MAGIC_SYSRQ=y
+CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE=0x0
+CONFIG_DEBUG_STACK_USAGE=y
+CONFIG_DEBUG_MEMORY_INIT=y
+CONFIG_LOCKUP_DETECTOR=y
+CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC=y
+CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=30
+CONFIG_BOOTPARAM_HUNG_TASK_PANIC=y
+CONFIG_PANIC_ON_OOPS=y
+CONFIG_PANIC_TIMEOUT=3
+CONFIG_SCHEDSTATS=y
+CONFIG_SCHED_STACK_END_CHECK=y
+CONFIG_DEBUG_TIMEKEEPING=y
+CONFIG_TIMER_STATS=y
+CONFIG_DEBUG_SPINLOCK=y
+CONFIG_DEBUG_MUTEXES=y
+CONFIG_FUNCTION_TRACER=y
+CONFIG_IRQSOFF_TRACER=y
+CONFIG_FUNCTION_PROFILER=y
+CONFIG_DEBUG_LL=y
+CONFIG_EARLY_PRINTK=y
+CONFIG_CRYPTO_CCM=y
+CONFIG_CRYPTO_GCM=y
+CONFIG_CRYPTO_ARC4=y
+# CONFIG_CRYPTO_ANSI_CPRNG is not set
+# CONFIG_CRYPTO_HW is not set
+CONFIG_ARM_CRYPTO=y
+CONFIG_CRYPTO_SHA1_ARM=y
+CONFIG_CRYPTO_SHA256_ARM=y
+CONFIG_CRC_CCITT=y
+CONFIG_CRC_T10DIF=y
+CONFIG_CRC_ITU_T=y
+CONFIG_CRC7=y
+CONFIG_LIBCRC32C=y
diff --git a/arch/arm/configs/gfsc100_defconfig b/arch/arm/configs/gfsc100_defconfig
new file mode 100644
index 0000000..03f2522
--- /dev/null
+++ b/arch/arm/configs/gfsc100_defconfig
@@ -0,0 +1,374 @@
+# CONFIG_LOCALVERSION_AUTO is not set
+CONFIG_KERNEL_XZ=y
+# CONFIG_SWAP is not set
+CONFIG_SYSVIPC=y
+CONFIG_IRQ_DOMAIN_DEBUG=y
+CONFIG_NO_HZ=y
+CONFIG_HIGH_RES_TIMERS=y
+CONFIG_BSD_PROCESS_ACCT=y
+CONFIG_IKCONFIG=y
+CONFIG_IKCONFIG_PROC=y
+CONFIG_LOG_BUF_SHIFT=14
+CONFIG_RELAY=y
+CONFIG_ANTIREBOOTLOOP=y
+CONFIG_BLK_DEV_INITRD=y
+# CONFIG_RD_BZIP2 is not set
+# CONFIG_RD_LZMA is not set
+# CONFIG_RD_LZO is not set
+# CONFIG_RD_LZ4 is not set
+CONFIG_EXPERT=y
+CONFIG_PRINTK_PERSIST=y
+CONFIG_PERF_EVENTS=y
+CONFIG_KPROBES=y
+CONFIG_MODULES=y
+CONFIG_MODULE_FORCE_LOAD=y
+CONFIG_MODULE_UNLOAD=y
+CONFIG_MODULE_FORCE_UNLOAD=y
+CONFIG_MODVERSIONS=y
+CONFIG_MODULE_SRCVERSION_ALL=y
+CONFIG_PARTITION_ADVANCED=y
+CONFIG_ARCH_COMCERTO=y
+# CONFIG_COMCERTO_FP is not set
+# CONFIG_ARM_ERRATA_643719 is not set
+CONFIG_ARM_ERRATA_720789=y
+CONFIG_ARM_ERRATA_754322=y
+CONFIG_ARM_ERRATA_764369=y
+CONFIG_SMP=y
+CONFIG_HAVE_ARM_ARCH_TIMER=y
+CONFIG_VMSPLIT_2G=y
+CONFIG_NR_CPUS=2
+CONFIG_PREEMPT=y
+CONFIG_THUMB2_KERNEL=y
+CONFIG_ZBOOT_ROM_TEXT=0x0
+CONFIG_ZBOOT_ROM_BSS=0x0
+CONFIG_ARM_APPENDED_DTB=y
+CONFIG_ARM_ATAG_DTB_COMPAT=y
+CONFIG_ARM_ATAG_DTB_COMPAT_CMDLINE_EXTEND=y
+CONFIG_VFP=y
+CONFIG_NEON=y
+CONFIG_BINFMT_MISC=y
+# CONFIG_SUSPEND is not set
+CONFIG_NET=y
+CONFIG_PACKET=y
+CONFIG_UNIX=y
+CONFIG_INET=y
+CONFIG_IP_MULTICAST=y
+CONFIG_IP_MROUTE=y
+CONFIG_SYN_COOKIES=y
+# CONFIG_INET_XFRM_MODE_TRANSPORT is not set
+# CONFIG_INET_XFRM_MODE_TUNNEL is not set
+# CONFIG_INET_XFRM_MODE_BEET is not set
+CONFIG_IPV6=y
+CONFIG_NETFILTER=y
+# CONFIG_NETFILTER_ADVANCED is not set
+# CONFIG_NETFILTER_NETLINK_LOG is not set
+# CONFIG_NF_CONNTRACK is not set
+# CONFIG_NETFILTER_XT_MARK is not set
+# CONFIG_NETFILTER_XT_TARGET_NFLOG is not set
+# CONFIG_NETFILTER_XT_TARGET_TCPMSS is not set
+# CONFIG_NETFILTER_XT_MATCH_ADDRTYPE is not set
+# CONFIG_NETFILTER_XT_MATCH_POLICY is not set
+# CONFIG_NF_LOG_ARP is not set
+# CONFIG_IP6_NF_MATCH_IPV6HEADER is not set
+CONFIG_BRIDGE=y
+CONFIG_NET_PKTGEN=m
+# CONFIG_WIRELESS is not set
+CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
+CONFIG_DEVTMPFS=y
+CONFIG_DEVTMPFS_MOUNT=y
+CONFIG_MTD=y
+CONFIG_MTD_BLOCK=y
+CONFIG_MTD_CFI=y
+CONFIG_MTD_CFI_INTELEXT=y
+CONFIG_MTD_CFI_AMDSTD=y
+CONFIG_MTD_CFI_STAA=y
+CONFIG_MTD_PHYSMAP_OF=y
+CONFIG_BLK_DEV_LOOP=y
+CONFIG_BLK_DEV_RAM=y
+CONFIG_BLK_DEV_RAM_SIZE=16384
+CONFIG_EEPROM_93CX6=y
+CONFIG_BLK_DEV_SD=y
+CONFIG_SCSI_CONSTANTS=y
+# CONFIG_SCSI_LOWLEVEL is not set
+CONFIG_ATA=y
+# CONFIG_SATA_PMP is not set
+CONFIG_SATA_AHCI_PLATFORM=y
+# CONFIG_ATA_SFF is not set
+CONFIG_MD=y
+CONFIG_BLK_DEV_DM=y
+CONFIG_DM_CRYPT=m
+CONFIG_DM_VERITY=y
+CONFIG_NETDEVICES=y
+CONFIG_TUN=y
+# CONFIG_NET_VENDOR_ARC is not set
+# CONFIG_NET_CADENCE is not set
+# CONFIG_NET_VENDOR_BROADCOM is not set
+# CONFIG_NET_VENDOR_CIRRUS is not set
+# CONFIG_NET_VENDOR_FARADAY is not set
+# CONFIG_NET_VENDOR_HISILICON is not set
+# CONFIG_NET_VENDOR_INTEL is not set
+# CONFIG_NET_VENDOR_MARVELL is not set
+# CONFIG_NET_VENDOR_MICREL is not set
+# CONFIG_NET_VENDOR_NATSEMI is not set
+# CONFIG_NET_VENDOR_QUALCOMM is not set
+# CONFIG_NET_VENDOR_ROCKER is not set
+# CONFIG_NET_VENDOR_SAMSUNG is not set
+# CONFIG_NET_VENDOR_SEEQ is not set
+# CONFIG_NET_VENDOR_SMSC is not set
+# CONFIG_NET_VENDOR_STMICRO is not set
+# CONFIG_NET_VENDOR_VIA is not set
+# CONFIG_NET_VENDOR_WIZNET is not set
+CONFIG_PHYLIB=y
+CONFIG_MARVELL_PHY=y
+CONFIG_FIXED_PHY=y
+# CONFIG_WLAN is not set
+# CONFIG_INPUT_MOUSEDEV is not set
+# CONFIG_INPUT_KEYBOARD is not set
+# CONFIG_INPUT_MOUSE is not set
+# CONFIG_LEGACY_PTYS is not set
+CONFIG_SERIAL_8250=y
+# CONFIG_SERIAL_8250_DEPRECATED_OPTIONS is not set
+CONFIG_SERIAL_8250_CONSOLE=y
+CONFIG_SERIAL_8250_DW=y
+# CONFIG_HW_RANDOM is not set
+CONFIG_TCG_TPM=y
+CONFIG_TCG_TIS_I2C_INFINEON=y
+CONFIG_I2C=y
+# CONFIG_I2C_COMPAT is not set
+CONFIG_I2C_CHARDEV=y
+CONFIG_I2C_MUX=y
+CONFIG_I2C_LS1024A=y
+CONFIG_SPI=y
+CONFIG_SPI_DESIGNWARE=y
+CONFIG_SPI_DW_MMIO=y
+CONFIG_GPIOLIB=y
+CONFIG_GPIO_SYSFS=y
+CONFIG_POWER_SUPPLY=y
+CONFIG_POWER_RESET=y
+CONFIG_POWER_RESET_SYSCON=y
+CONFIG_SENSORS_LM63=y
+CONFIG_WATCHDOG=y
+CONFIG_LS1024A_WATCHDOG=y
+CONFIG_MEDIA_SUPPORT=y
+CONFIG_MEDIA_DIGITAL_TV_SUPPORT=y
+CONFIG_MEDIA_USB_SUPPORT=y
+CONFIG_DVB_USB_V2=y
+CONFIG_DVB_USB_SC100=m
+CONFIG_CYPRESS_FIRMWARE=y
+# CONFIG_MEDIA_SUBDRV_AUTOSELECT is not set
+# CONFIG_MEDIA_TUNER_SIMPLE is not set
+# CONFIG_MEDIA_TUNER_TDA8290 is not set
+# CONFIG_MEDIA_TUNER_TDA827X is not set
+# CONFIG_MEDIA_TUNER_TDA18271 is not set
+# CONFIG_MEDIA_TUNER_TDA9887 is not set
+# CONFIG_MEDIA_TUNER_TEA5761 is not set
+# CONFIG_MEDIA_TUNER_TEA5767 is not set
+# CONFIG_MEDIA_TUNER_MT20XX is not set
+# CONFIG_MEDIA_TUNER_MT2060 is not set
+# CONFIG_MEDIA_TUNER_MT2063 is not set
+# CONFIG_MEDIA_TUNER_MT2266 is not set
+# CONFIG_MEDIA_TUNER_MT2131 is not set
+# CONFIG_MEDIA_TUNER_QT1010 is not set
+# CONFIG_MEDIA_TUNER_XC2028 is not set
+# CONFIG_MEDIA_TUNER_XC5000 is not set
+# CONFIG_MEDIA_TUNER_XC4000 is not set
+# CONFIG_MEDIA_TUNER_MXL5005S is not set
+# CONFIG_MEDIA_TUNER_MXL5007T is not set
+# CONFIG_MEDIA_TUNER_MC44S803 is not set
+# CONFIG_MEDIA_TUNER_MAX2165 is not set
+# CONFIG_MEDIA_TUNER_TDA18218 is not set
+# CONFIG_MEDIA_TUNER_FC0011 is not set
+# CONFIG_MEDIA_TUNER_FC0012 is not set
+# CONFIG_MEDIA_TUNER_FC0013 is not set
+# CONFIG_MEDIA_TUNER_TDA18212 is not set
+# CONFIG_MEDIA_TUNER_E4000 is not set
+# CONFIG_MEDIA_TUNER_FC2580 is not set
+CONFIG_MEDIA_TUNER_M88RS6000T=y
+# CONFIG_MEDIA_TUNER_TUA9001 is not set
+# CONFIG_MEDIA_TUNER_SI2157 is not set
+# CONFIG_MEDIA_TUNER_IT913X is not set
+# CONFIG_MEDIA_TUNER_R820T is not set
+# CONFIG_MEDIA_TUNER_MXL301RF is not set
+# CONFIG_MEDIA_TUNER_QM1D1C0042 is not set
+# CONFIG_DVB_STB0899 is not set
+# CONFIG_DVB_STB6100 is not set
+# CONFIG_DVB_STV090x is not set
+# CONFIG_DVB_STV6110x is not set
+CONFIG_DVB_M88DS3103=y
+CONFIG_DVB_M88DS3103_M88RS6000_FIRMWARE="dvbsky-firmware/dvb-demod-m88rs6000.fw"
+# CONFIG_DVB_DRXK is not set
+# CONFIG_DVB_TDA18271C2DD is not set
+# CONFIG_DVB_SI2165 is not set
+# CONFIG_DVB_CX24110 is not set
+# CONFIG_DVB_CX24123 is not set
+# CONFIG_DVB_MT312 is not set
+# CONFIG_DVB_ZL10036 is not set
+# CONFIG_DVB_ZL10039 is not set
+# CONFIG_DVB_S5H1420 is not set
+# CONFIG_DVB_STV0288 is not set
+# CONFIG_DVB_STB6000 is not set
+# CONFIG_DVB_STV0299 is not set
+# CONFIG_DVB_STV6110 is not set
+# CONFIG_DVB_STV0900 is not set
+# CONFIG_DVB_TDA8083 is not set
+# CONFIG_DVB_TDA10086 is not set
+# CONFIG_DVB_TDA8261 is not set
+# CONFIG_DVB_VES1X93 is not set
+# CONFIG_DVB_TUNER_ITD1000 is not set
+# CONFIG_DVB_TUNER_CX24113 is not set
+# CONFIG_DVB_TDA826X is not set
+# CONFIG_DVB_TUA6100 is not set
+# CONFIG_DVB_CX24116 is not set
+# CONFIG_DVB_CX24117 is not set
+# CONFIG_DVB_SI21XX is not set
+# CONFIG_DVB_TS2020 is not set
+# CONFIG_DVB_DS3000 is not set
+# CONFIG_DVB_MB86A16 is not set
+# CONFIG_DVB_TDA10071 is not set
+# CONFIG_DVB_SP8870 is not set
+# CONFIG_DVB_SP887X is not set
+# CONFIG_DVB_CX22700 is not set
+# CONFIG_DVB_CX22702 is not set
+# CONFIG_DVB_S5H1432 is not set
+# CONFIG_DVB_DRXD is not set
+# CONFIG_DVB_L64781 is not set
+# CONFIG_DVB_TDA1004X is not set
+# CONFIG_DVB_NXT6000 is not set
+# CONFIG_DVB_MT352 is not set
+# CONFIG_DVB_ZL10353 is not set
+# CONFIG_DVB_DIB3000MB is not set
+# CONFIG_DVB_DIB3000MC is not set
+# CONFIG_DVB_DIB7000M is not set
+# CONFIG_DVB_DIB7000P is not set
+# CONFIG_DVB_DIB9000 is not set
+# CONFIG_DVB_TDA10048 is not set
+# CONFIG_DVB_AF9013 is not set
+# CONFIG_DVB_EC100 is not set
+# CONFIG_DVB_HD29L2 is not set
+# CONFIG_DVB_STV0367 is not set
+# CONFIG_DVB_CXD2820R is not set
+# CONFIG_DVB_RTL2830 is not set
+# CONFIG_DVB_RTL2832 is not set
+# CONFIG_DVB_SI2168 is not set
+# CONFIG_DVB_VES1820 is not set
+# CONFIG_DVB_TDA10021 is not set
+# CONFIG_DVB_TDA10023 is not set
+# CONFIG_DVB_STV0297 is not set
+# CONFIG_DVB_NXT200X is not set
+# CONFIG_DVB_OR51211 is not set
+# CONFIG_DVB_OR51132 is not set
+# CONFIG_DVB_BCM3510 is not set
+# CONFIG_DVB_LGDT330X is not set
+# CONFIG_DVB_LGDT3305 is not set
+# CONFIG_DVB_LGDT3306A is not set
+# CONFIG_DVB_LG2160 is not set
+# CONFIG_DVB_S5H1409 is not set
+# CONFIG_DVB_AU8522_DTV is not set
+# CONFIG_DVB_S5H1411 is not set
+# CONFIG_DVB_S921 is not set
+# CONFIG_DVB_DIB8000 is not set
+# CONFIG_DVB_MB86A20S is not set
+# CONFIG_DVB_TC90522 is not set
+# CONFIG_DVB_PLL is not set
+# CONFIG_DVB_TUNER_DIB0070 is not set
+# CONFIG_DVB_TUNER_DIB0090 is not set
+# CONFIG_DVB_DRX39XYJ is not set
+# CONFIG_DVB_LNBP21 is not set
+# CONFIG_DVB_LNBP22 is not set
+# CONFIG_DVB_ISL6405 is not set
+# CONFIG_DVB_ISL6421 is not set
+# CONFIG_DVB_ISL6423 is not set
+# CONFIG_DVB_A8293 is not set
+# CONFIG_DVB_SP2 is not set
+# CONFIG_DVB_LGS8GL5 is not set
+# CONFIG_DVB_LGS8GXX is not set
+# CONFIG_DVB_ATBM8830 is not set
+# CONFIG_DVB_TDA665x is not set
+# CONFIG_DVB_IX2505V is not set
+# CONFIG_DVB_M88RS2000 is not set
+# CONFIG_DVB_AF9033 is not set
+CONFIG_USB=y
+CONFIG_USB_XHCI_HCD=y
+CONFIG_USB_STORAGE=y
+CONFIG_USB_DWC3=y
+CONFIG_USB_DWC2=y
+CONFIG_USB_SERIAL=y
+CONFIG_USB_SERIAL_FTDI_SIO=y
+CONFIG_USB_SERIAL_KEYSPAN=y
+CONFIG_USB_SERIAL_PL2303=y
+CONFIG_NEW_LEDS=y
+CONFIG_LEDS_CLASS=y
+CONFIG_LEDS_CLASS_FLASH=y
+CONFIG_LEDS_GPIO=y
+CONFIG_LEDS_PWM=y
+CONFIG_LEDS_TRIGGERS=y
+CONFIG_LEDS_TRIGGER_TIMER=y
+CONFIG_LEDS_TRIGGER_ONESHOT=y
+CONFIG_LEDS_TRIGGER_HEARTBEAT=y
+CONFIG_LEDS_TRIGGER_BACKLIGHT=y
+CONFIG_LEDS_TRIGGER_CPU=y
+CONFIG_LEDS_TRIGGER_GPIO=y
+CONFIG_LEDS_TRIGGER_DEFAULT_ON=y
+# CONFIG_IOMMU_SUPPORT is not set
+CONFIG_PWM=y
+CONFIG_PWM_LS1024A=y
+CONFIG_PHY_LS1024A_SNOWBUSH=y
+CONFIG_PHY_LS1024A_USB2=y
+CONFIG_PHY_LS1024A_USB3=y
+CONFIG_FIRMWARE_MEMMAP=y
+CONFIG_EXT4_FS=m
+CONFIG_MSDOS_FS=m
+CONFIG_VFAT_FS=m
+CONFIG_TMPFS=y
+CONFIG_CONFIGFS_FS=m
+CONFIG_SQUASHFS=y
+CONFIG_SQUASHFS_DECOMP_MULTI=y
+CONFIG_SQUASHFS_XZ=y
+CONFIG_SQUASHFS_EMBEDDED=y
+CONFIG_NFS_FS=y
+CONFIG_NFS_V4=y
+CONFIG_NFS_V4_1=y
+CONFIG_NFS_V4_2=y
+CONFIG_NLS_CODEPAGE_437=y
+CONFIG_NLS_ISO8859_1=y
+CONFIG_NLS_UTF8=y
+CONFIG_PRINTK_TIME=y
+CONFIG_DYNAMIC_DEBUG=y
+CONFIG_DEBUG_SECTION_MISMATCH=y
+CONFIG_MAGIC_SYSRQ=y
+CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE=0x0
+CONFIG_DEBUG_STACK_USAGE=y
+CONFIG_DEBUG_MEMORY_INIT=y
+CONFIG_LOCKUP_DETECTOR=y
+CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC=y
+CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=120
+CONFIG_BOOTPARAM_HUNG_TASK_PANIC=y
+CONFIG_PANIC_ON_OOPS=y
+CONFIG_PANIC_TIMEOUT=3
+CONFIG_SCHEDSTATS=y
+CONFIG_SCHED_STACK_END_CHECK=y
+CONFIG_DEBUG_TIMEKEEPING=y
+CONFIG_TIMER_STATS=y
+CONFIG_DEBUG_SPINLOCK=y
+CONFIG_DEBUG_MUTEXES=y
+CONFIG_FUNCTION_TRACER=y
+CONFIG_IRQSOFF_TRACER=y
+CONFIG_FUNCTION_PROFILER=y
+CONFIG_DEBUG_LL=y
+CONFIG_EARLY_PRINTK=y
+CONFIG_CRYPTO_CCM=y
+CONFIG_CRYPTO_GCM=y
+CONFIG_CRYPTO_ARC4=y
+CONFIG_CRYPTO_DEFLATE=y
+CONFIG_CRYPTO_LZO=y
+# CONFIG_CRYPTO_ANSI_CPRNG is not set
+# CONFIG_CRYPTO_HW is not set
+CONFIG_ARM_CRYPTO=y
+CONFIG_CRYPTO_SHA1_ARM=y
+CONFIG_CRYPTO_SHA256_ARM=y
+CONFIG_CRC_CCITT=y
+CONFIG_CRC16=y
+CONFIG_CRC_T10DIF=y
+CONFIG_CRC_ITU_T=y
+CONFIG_CRC7=y
+CONFIG_LIBCRC32C=y
diff --git a/arch/arm/kernel/devtree.c b/arch/arm/kernel/devtree.c
index 11c54de..cf03bb4 100644
--- a/arch/arm/kernel/devtree.c
+++ b/arch/arm/kernel/devtree.c
@@ -8,6 +8,8 @@
* published by the Free Software Foundation.
*/
+#define DEBUG
+
#include <linux/init.h>
#include <linux/export.h>
#include <linux/errno.h>
@@ -86,6 +88,7 @@
if (!cpus)
return;
+ pr_debug("is_smp %d MPIDR %08x\n", is_smp(), read_cpuid_mpidr());
for_each_child_of_node(cpus, cpu) {
u32 hwid;
diff --git a/arch/arm/mach-comcerto/Kconfig b/arch/arm/mach-comcerto/Kconfig
new file mode 100644
index 0000000..d2b2f13
--- /dev/null
+++ b/arch/arm/mach-comcerto/Kconfig
@@ -0,0 +1,29 @@
+menu "Freescale Comerto 2000"
+ depends on ARCH_MULTI_V7
+
+config ARCH_COMCERTO
+ bool "Freescale Comerto 2000"
+ depends on ARCH_MULTI_V7
+ select ARM_GIC
+ select PCI_DOMAINS if PCI
+ select CLKSRC_MMIO
+ select MFD_SYSCON
+ select HAVE_ARM_SCU if SMP
+ select HAVE_ARM_TWD if SMP
+ select ARCH_HAS_RESET_CONTROLLER
+ select PINCTRL
+ select PINCTRL_LS1024A
+ select MII
+
+endmenu
+
+config COMCERTO_FP
+ bool "Comcerto Fast Path Support"
+ depends on ARCH_COMCERTO
+ default y
+
+config COMCERTO_DMA_COHERENT_SKB
+ bool "Support for DMA coherent SKB heads"
+ depends on ARCH_COMCERTO
+ depends on DMA_CMA
+ default n
diff --git a/arch/arm/mach-comcerto/Makefile b/arch/arm/mach-comcerto/Makefile
new file mode 100644
index 0000000..87dd2c7
--- /dev/null
+++ b/arch/arm/mach-comcerto/Makefile
@@ -0,0 +1,7 @@
+ccflags-$(CONFIG_ARCH_MULTIPLATFORM) := -I$(srctree)/$(src)/include
+
+obj-y := board-generic.o comcerto-restart.o common.o io.o clk-comcerto2000.o \
+ platsmp.o comcerto-vwd.o
+
+obj-$(CONFIG_SMP) += headsmp.o
+AFLAGS_headsmp.o :=-Wa,-march=armv7-a
diff --git a/arch/arm/mach-comcerto/board-generic.c b/arch/arm/mach-comcerto/board-generic.c
new file mode 100644
index 0000000..4421f0c
--- /dev/null
+++ b/arch/arm/mach-comcerto/board-generic.c
@@ -0,0 +1,529 @@
+#include <linux/clk.h>
+#include <linux/clk-provider.h>
+#include <linux/clocksource.h>
+#include <linux/clockchips.h>
+#include <linux/sched_clock.h>
+#include <linux/io.h>
+#include <linux/of_address.h>
+#include <linux/of_irq.h>
+#include <linux/of_platform.h>
+#include <linux/printk.h>
+#include <linux/irqdomain.h>
+#include <linux/interrupt.h>
+
+#include <asm/hardware/cache-l2x0.h>
+
+/* PFE */
+#include <linux/phy.h>
+#include <linux/clkdev.h>
+
+#include <asm/mach/arch.h>
+#include <asm/irq.h>
+#include <mach/hardware.h>
+#include "common.h"
+
+static unsigned int persistent_mult, persistent_shift;
+unsigned long axi_clk_rate;
+static void __iomem *timer_base;
+
+
+/* We need to explicitly enable certain clocks. Otherwise, they are considered
+ * unused and clk_disable_unused() will disable them and freeze our system. */
+static const char *clks_to_enable[] = {
+ "arm_clk",
+ "axi_clk",
+ "ddr_clk",
+ "l2cc_clk",
+
+ "hfe_core_clk", /* PFE */
+
+ "sata_oob_clk", /* SATA */
+ "sata_pmu_clk", /* SATA */
+ NULL
+};
+static int __init c2k_enable_clks(void)
+{
+ const char **c;
+ struct device_node *node;
+ struct clk *clk;
+ struct of_phandle_args clkspec;
+ for (c = clks_to_enable; *c != NULL; c++) {
+ node = of_find_node_by_name(NULL, *c);
+ clkspec.np = node;
+ clkspec.args_count = 0;
+ clk = of_clk_get_from_provider(&clkspec);
+
+ if (!IS_ERR(clk)) {
+ clk_prepare(clk);
+ clk_enable(clk);
+ } else {
+ pr_warn("failed to lookup clock node %s\n",
+ *c);
+ }
+ }
+ return 0;
+
+
+ /* Set the SATA PMU clock to 30 MHZ and OOB clock to 125MHZ */
+ node = of_find_node_by_name(NULL, "sata_oob_clk");
+ clkspec.np = node;
+ clkspec.args_count = 0;
+ clk = of_clk_get_from_provider(&clkspec);
+
+ if (!IS_ERR(clk)) {
+ clk_set_rate(clk,125000000);
+ } else {
+ BUG();
+ }
+ node = of_find_node_by_name(NULL, "sata_pmu_clk");
+ clkspec.np = node;
+ clkspec.args_count = 0;
+ clk = of_clk_get_from_provider(&clkspec);
+
+ if (!IS_ERR(clk)) {
+ clk_set_rate(clk,30000000);
+ } else {
+ BUG();
+ }
+
+}
+
+late_initcall(c2k_enable_clks);
+
+struct clk_lookup axi_lk = {
+ .dev_id = NULL,
+ .con_id = "axi",
+};
+
+struct clk_lookup gemtx_lk = {
+ .dev_id = NULL,
+ .con_id = "gemtx",
+};
+
+static int __init c2k_register_clks(void)
+{
+ struct device_node *node;
+ struct clk *clk;
+ struct of_phandle_args clkspec;
+ node = of_find_node_by_name(NULL, "axi_clk");
+ clkspec.np = node;
+ clkspec.args_count = 0;
+ clk = of_clk_get_from_provider(&clkspec);
+ if (!IS_ERR(clk)) {
+ axi_lk.clk = clk;
+ clkdev_add(&axi_lk);
+ } else {
+ pr_warn("failed to lookup clock node axi_clk\n");
+ }
+
+
+ node = of_find_node_by_name(NULL, "gemtx_clk");
+ clkspec.np = node;
+ clkspec.args_count = 0;
+ clk = of_clk_get_from_provider(&clkspec);
+ if (!IS_ERR(clk)) {
+ gemtx_lk.clk = clk;
+ clkdev_add(&gemtx_lk);
+ } else {
+ pr_warn("failed to lookup clock node gemtx_clk\n");
+ }
+ return 0;
+}
+
+late_initcall(c2k_register_clks);
+
+static int c2k_timer_set_next_event(unsigned long cycles,
+ struct clock_event_device *evt);
+static void c2k_timer_set_mode(enum clock_event_mode mode,
+ struct clock_event_device *evt);
+
+static struct clock_event_device clockevent_c2k = {
+ .features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, // TODO
+ .rating = 300,
+ .set_next_event = c2k_timer_set_next_event,
+ .set_mode = c2k_timer_set_mode,
+ .name = "timer1",
+};
+
+#define timer_mask(timer) (1 << timer)
+
+/*
+ * Routine to catch timer interrupts
+ */
+static irqreturn_t comcerto_timer1_interrupt(int irq, void *dev_id)
+{
+ u32 status;
+ struct clock_event_device *dev = &clockevent_c2k;
+
+ status = __raw_readl(timer_base + COMCERTO_TIMER_STATUS) & __raw_readl(timer_base + COMCERTO_TIMER_IRQ_MASK);
+
+ /* timer1 expired */
+ if (status & timer_mask(1)) {
+ /* we need to disable interrupt to simulate ONESHOT mode,
+ do it before clearing the interrupt to avoid race */
+ if (dev->mode != CLOCK_EVT_MODE_PERIODIC)
+ __raw_writel(__raw_readl(timer_base + COMCERTO_TIMER_IRQ_MASK) & ~(1 << (1)), timer_base + COMCERTO_TIMER_IRQ_MASK);
+
+ __raw_writel(1 << (1), timer_base + COMCERTO_TIMER_STATUS_CLR);
+ dev->event_handler(dev);
+ return IRQ_HANDLED;
+ }
+
+ return IRQ_NONE;
+}
+
+static struct irqaction comcerto_timer1_irq = {
+ .name = "timer1",
+ .flags = IRQF_TIMER,
+ .handler = comcerto_timer1_interrupt,
+};
+
+
+static int c2k_timer_set_next_event(unsigned long cycles,
+ struct clock_event_device *evt)
+{
+ pr_err("%s cycles %lu\n", __func__, cycles);
+ /* now write correct bound and clear interrupt status.
+ Writing high bound register automatically resets count to low bound value.
+ For very small bound values it's possible that we ack the interrupt _after_ the timer has already expired,
+ this is not very serious because the interrupt will be asserted again in a very short time */
+ __raw_writel(cycles & 0x3FFFFFFF, timer_base + COMCERTO_TIMER1_HIGH_BOUND);
+ __raw_writel(1 << 1, timer_base + COMCERTO_TIMER_STATUS_CLR);
+
+ /* enable interrupt for ONESHOT mode */
+ if (evt->mode == CLOCK_EVT_MODE_ONESHOT)
+ __raw_writel(__raw_readl(timer_base + COMCERTO_TIMER_IRQ_MASK) | (1 << 1), timer_base + COMCERTO_TIMER_IRQ_MASK);
+
+ return 0;
+}
+
+static void c2k_timer_set_mode(enum clock_event_mode mode,
+ struct clock_event_device *evt)
+{
+ u32 period;
+ pr_err("%s mode %d\n", __func__, mode);
+
+ __raw_writel(__raw_readl(timer_base + COMCERTO_TIMER_IRQ_MASK) & ~(1 << (1)), timer_base + COMCERTO_TIMER_IRQ_MASK);
+
+ switch (mode) {
+ case CLOCK_EVT_MODE_PERIODIC:
+ period = axi_clk_rate / HZ;
+ period -= 1;
+ __raw_writel(period & 0x3FFFFFFF, timer_base + COMCERTO_TIMER1_HIGH_BOUND);
+ __raw_writel(__raw_readl(timer_base + COMCERTO_TIMER_IRQ_MASK) | (1 << (1)), timer_base + COMCERTO_TIMER_IRQ_MASK);
+ break;
+ case CLOCK_EVT_MODE_ONESHOT:
+ break;
+ case CLOCK_EVT_MODE_UNUSED:
+ case CLOCK_EVT_MODE_SHUTDOWN:
+ case CLOCK_EVT_MODE_RESUME:
+ break;
+ }
+}
+
+static void __init c2k_clockevent_init(int timer1_irq) {
+ /* Clear all the timers except timer0 */
+ __raw_writel(COMCERTO_TIMER_CSP, timer_base + COMCERTO_TIMER_STATUS);
+
+ /* Register interrupt handler for interrupt on IRQ_TIMERB*/
+ irq_set_irq_type(timer1_irq, IRQ_TYPE_EDGE_RISING);
+ setup_irq(timer1_irq, &comcerto_timer1_irq);
+ clockevent_c2k.cpumask = cpu_possible_mask;
+ clockevent_c2k.irq = timer1_irq;
+ clockevents_config_and_register(&clockevent_c2k, axi_clk_rate,
+ 1,
+ 0x3fffffff);
+}
+
+
+static u64 notrace c2k_read_sched_clock(void)
+{
+ return readl_relaxed(timer_base + COMCERTO_TIMER2_CURRENT_COUNT);
+}
+
+static void __init _ls1024a_timer_init(int timer1_irq, struct clk *clk_axi)
+{
+ int ret;
+
+ axi_clk_rate = clk_get_rate(clk_axi);
+ /*
+ err = twd_local_timer_register(&twd_local_timer);
+ if (err)
+ pr_err("twd_local_timer_register failed %d\n", err);
+ */
+ __raw_writel(0, timer_base + COMCERTO_TIMER2_CTRL);
+ __raw_writel(0, timer_base + COMCERTO_TIMER2_LOW_BOUND);
+ __raw_writel(0xffffffff, timer_base + COMCERTO_TIMER2_HIGH_BOUND);
+ ret = clocksource_mmio_init(timer_base + COMCERTO_TIMER2_CURRENT_COUNT, "timer2", axi_clk_rate,
+ 250, 32, clocksource_mmio_readl_up);
+ clocks_calc_mult_shift(&persistent_mult, &persistent_shift,
+ axi_clk_rate, NSEC_PER_SEC, 120000);
+ sched_clock_register(c2k_read_sched_clock, 32, axi_clk_rate);
+ c2k_clockevent_init(timer1_irq);
+}
+
+static void __init ls1024a_timer_init_dt(struct device_node *np)
+{
+ struct clk *clk_axi;
+ int irq;
+
+ timer_base = of_iomap(np, 0);
+ WARN_ON(!timer_base);
+ irq = irq_of_parse_and_map(np, 1);
+
+ clk_axi = of_clk_get(np, 0);
+ if (IS_ERR(clk_axi)) {
+ pr_err("LS1024A timer: unable to get AXI clk\n");
+ return;
+ }
+
+ _ls1024a_timer_init(irq, clk_axi);
+}
+
+CLOCKSOURCE_OF_DECLARE(ls1024a_timer, "fsl,ls1024a-gpt", ls1024a_timer_init_dt);
+
+
+static struct resource comcerto_pfe_resources[] = {
+ {
+ .name = "apb",
+ .start = COMCERTO_APB_PFE_BASE,
+ .end = COMCERTO_APB_PFE_BASE + COMCERTO_APB_PFE_SIZE - 1,
+ .flags = IORESOURCE_MEM,
+ },
+ {
+ .name = "axi",
+ .start = COMCERTO_AXI_PFE_BASE,
+ .end = COMCERTO_AXI_PFE_BASE + COMCERTO_AXI_PFE_SIZE - 1,
+ .flags = IORESOURCE_MEM,
+ },
+ {
+ .name = "ddr",
+ .start = COMCERTO_PFE_DDR_BASE,
+ .end = COMCERTO_PFE_DDR_BASE + COMCERTO_PFE_DDR_SIZE - 1,
+ .flags = IORESOURCE_MEM,
+ },
+ {
+ .name = "iram",
+ .start = COMCERTO_PFE_IRAM_BASE,
+ .end = COMCERTO_PFE_IRAM_BASE + COMCERTO_PFE_IRAM_SIZE - 1,
+ .flags = IORESOURCE_MEM,
+ },
+ {
+ .name = "ipsec",
+ .start = COMCERTO_AXI_IPSEC_BASE,
+ .end = COMCERTO_AXI_IPSEC_BASE + COMCERTO_AXI_IPSEC_SIZE - 1,
+ .flags = IORESOURCE_MEM,
+ },
+
+};
+
+static struct comcerto_pfe_platform_data optimus_pfe_pdata = {
+ .comcerto_eth_pdata[0] = {
+ .name = "lan0",
+ .device_flags = CONFIG_COMCERTO_GEMAC,
+ .mii_config = CONFIG_COMCERTO_USE_RGMII,
+ .gemac_mode = GEMAC_SW_CONF | GEMAC_SW_FULL_DUPLEX | GEMAC_SW_SPEED_1G,
+ .phy_flags = GEMAC_NO_PHY,
+ .gem_id = 0,
+ .mac_addr = (u8[])GEM0_MAC,
+ },
+
+ .comcerto_eth_pdata[1] = {
+ .name = "wan0",
+ .device_flags = CONFIG_COMCERTO_GEMAC,
+ .mii_config = CONFIG_COMCERTO_USE_RGMII,
+ .gemac_mode = GEMAC_SW_CONF | GEMAC_SW_FULL_DUPLEX | GEMAC_SW_SPEED_1G,
+ .phy_flags = GEMAC_PHY_RGMII_ADD_DELAY,
+ .bus_id = 0,
+ .phy_id = 4,
+ .gem_id = 1,
+ .mac_addr = (u8[])GEM1_MAC,
+ },
+
+ .comcerto_eth_pdata[2] = {
+ .name = "moca0",
+ .device_flags = CONFIG_COMCERTO_GEMAC,
+ .mii_config = CONFIG_COMCERTO_USE_RGMII,
+ .gemac_mode = GEMAC_SW_CONF | GEMAC_SW_FULL_DUPLEX | GEMAC_SW_SPEED_1G,
+ .phy_flags = GEMAC_NO_PHY,
+ .gem_id = 2,
+ .mac_addr = (u8[])GEM2_MAC,
+ },
+
+ /**
+ * There is a single mdio bus coming out of C2K. And that's the one
+ * connected to GEM0. All PHY's, switchs will be connected to the same
+ * bus using different addresses. Typically .bus_id is always 0, only
+ * .phy_id will change in the different comcerto_eth_pdata[] structures above.
+ */
+ .comcerto_mdio_pdata[0] = {
+ .enabled = 1,
+ .phy_mask = 0xFFFFFFEF,
+ .mdc_div = 96,
+ .irq = {
+ [4] = PHY_POLL,
+ },
+ },
+};
+
+static struct comcerto_pfe_platform_data gfsc100_pfe_pdata = {
+ .comcerto_eth_pdata[0] = {
+ .name = "unused",
+ .phy_flags = GEMAC_NO_PHY,
+ .gem_id = 0,
+ },
+
+ .comcerto_eth_pdata[1] = {
+ .name = "lan0",
+ .device_flags = CONFIG_COMCERTO_GEMAC,
+ .mii_config = CONFIG_COMCERTO_USE_RGMII,
+ .gemac_mode = GEMAC_SW_CONF | GEMAC_SW_FULL_DUPLEX | GEMAC_SW_SPEED_1G,
+ .phy_flags = GEMAC_PHY_RGMII_ADD_DELAY,
+ .bus_id = 0,
+ .phy_id = 1,
+ .gem_id = 1,
+ .mac_addr = (u8[])GEM1_MAC,
+ },
+
+ .comcerto_eth_pdata[2] = {
+ .name = "unused",
+ .phy_flags = GEMAC_NO_PHY,
+ .gem_id = 2,
+ },
+
+ /**
+ * There is a single mdio bus coming out of C2K. And that's the one
+ * connected to GEM0. All PHY's, switchs will be connected to the same
+ * bus using different addresses. Typically .bus_id is always 0, only
+ * .phy_id will change in the different comcerto_eth_pdata[] structures above.
+ */
+ .comcerto_mdio_pdata[0] = {
+ .enabled = 1,
+ .phy_mask = 0xFFFFFFFD,
+ .mdc_div = 96,
+ .irq = {
+ [1] = PHY_POLL,
+ },
+ },
+};
+
+static u64 comcerto_pfe_dma_mask = DMA_BIT_MASK(32);
+
+static struct platform_device comcerto_pfe_device = {
+ .name = "pfe",
+ .id = 0,
+ .dev = {
+ .dma_mask = &comcerto_pfe_dma_mask,
+ .coherent_dma_mask = DMA_BIT_MASK(32),
+ },
+ .num_resources = ARRAY_SIZE(comcerto_pfe_resources),
+ .resource = comcerto_pfe_resources,
+};
+
+static int is_mac_zero(u8 *buf)
+{
+ unsigned long dm;
+ for (dm = 0; dm < 6; dm++){
+ if ((*(buf+dm)) != 0)
+ return 1;
+ }
+ return 0;
+}
+
+static int __init mac_addr_atoi(u8 mac_addr[], char *mac_addr_str)
+{
+ int i, j, k;
+ int str_incr_cnt = 0;
+
+ if (*mac_addr_str == ',') {
+ mac_addr_str++;
+ str_incr_cnt++;
+ return str_incr_cnt;
+ }
+
+ for (i = 0; i < 6; i++) {
+
+ j = hex_to_bin(*mac_addr_str++);
+ str_incr_cnt++;
+ if (j == -1)
+ return str_incr_cnt;
+
+ k = hex_to_bin(*mac_addr_str++);
+ str_incr_cnt++;
+ if (k == -1)
+ return str_incr_cnt;
+
+ mac_addr_str++;
+ str_incr_cnt++;
+ mac_addr[i] = (j << 4) + k;
+ }
+
+ return str_incr_cnt;
+}
+
+static u8 c2k_mac_addr[3][14];
+
+static int __init mac_addr_setup(char *str)
+{
+ int str_incr_cnt = 0;
+
+ if (*str++ != '=' || !*str) /* No mac addr specified */
+ return -1;
+
+ str_incr_cnt = mac_addr_atoi(c2k_mac_addr[0], str);
+
+ str += str_incr_cnt;
+
+ str_incr_cnt = mac_addr_atoi(c2k_mac_addr[1], str);
+
+ str += str_incr_cnt;
+
+ mac_addr_atoi(c2k_mac_addr[2], str);
+
+ return 0;
+}
+__setup("mac_addr", mac_addr_setup);
+
+void __init mac_addr_init(struct comcerto_pfe_platform_data * comcerto_pfe_data_ptr)
+{
+ u8 gem_port_id;
+
+ for (gem_port_id = 0; gem_port_id < NUM_GEMAC_SUPPORT; gem_port_id++) {
+ if (is_mac_zero(c2k_mac_addr[gem_port_id])) /* If mac is non-zero */
+ comcerto_pfe_data_ptr->comcerto_eth_pdata[gem_port_id].mac_addr = c2k_mac_addr[gem_port_id];
+ }
+
+}
+
+static void __init pfe_init_pdata(void) {
+ if (of_machine_is_compatible("google,gfsc100")) {
+ comcerto_pfe_device.dev.platform_data = &gfsc100_pfe_pdata;
+ } else {
+ comcerto_pfe_device.dev.platform_data = &optimus_pfe_pdata;
+ }
+}
+
+static int __init register_pfe_device(void) {
+ int rc;
+ pfe_init_pdata();
+ mac_addr_init(comcerto_pfe_device.dev.platform_data);
+ rc = platform_device_register(&comcerto_pfe_device);
+ return 0;
+}
+late_initcall(register_pfe_device);
+
+
+static const char * const c2k_boards_compat[] __initconst = {
+ "fsl,ls1024a",
+ NULL,
+};
+
+DT_MACHINE_START(C2K_DT, "Generic Freescale LS1024A (Flattened Device Tree)")
+ .l2c_aux_val = L2C_AUX_CTRL_SHARED_OVERRIDE | (1<<L220_AUX_CTRL_FWA_SHIFT), // 0,
+ .l2c_aux_mask = ~( L2C_AUX_CTRL_SHARED_OVERRIDE | L220_AUX_CTRL_FWA_MASK ), //~0,
+ .reserve = c2k_reserve,
+ .map_io = c2k_map_io,
+ .init_early = c2k_init_early,
+ .init_late = c2k_init_late,
+ .dt_compat = c2k_boards_compat,
+MACHINE_END
diff --git a/arch/arm/mach-comcerto/clk-comcerto2000.c b/arch/arm/mach-comcerto/clk-comcerto2000.c
new file mode 100644
index 0000000..99dc9d8
--- /dev/null
+++ b/arch/arm/mach-comcerto/clk-comcerto2000.c
@@ -0,0 +1,192 @@
+#include <linux/clk-provider.h>
+#include <linux/slab.h>
+#include <linux/of_address.h>
+#include <mach/hardware.h>
+#include "clock.h"
+
+struct clk_hw_comcerto2000 {
+ struct clk_hw hw;
+ void __iomem *reg;
+ u32 divreg_offset;
+ int div_bypass;
+};
+
+/*
+ * CLKGEN Divider registers
+ * The divider bypass bit in several configuration registers
+ * can only be written (if you read back you get zero).
+ *
+ * The Bug is in registers: 0x84 (A9DP_CLKDIV_CNTRL), 0x84 + 16 (L2CC_CLKDIV_CNTRL), 0x84 + 32
+ * (TPI_CLKDIV_CNTRL), etc... until PLL_ADDR_SPACE at 0x1C0.
+ */
+
+/*
+ * Barebox uses IRAM to mirror the clock divider registers
+ * Linux will relocate this mirror from IRAM to DDR to free up IRAM.
+ */
+#define IRAM_CLK_REG_MIRROR (0x8300FC00 - COMCERTO_AXI_IRAM_BASE + IRAM_MEMORY_VADDR)
+#define CLK_REG_DIV_BUG_BASE AXI_CLK_DIV_CNTRL
+#define CLK_REG_DIV_BUG_SIZE (PLL0_M_LSB - AXI_CLK_DIV_CNTRL)
+
+static u8 clk_div_backup_table [CLK_REG_DIV_BUG_SIZE];
+
+void c2k_clk_div_backup_relocate_table (void)
+{
+ memcpy (clk_div_backup_table, (void*) IRAM_CLK_REG_MIRROR, CLK_REG_DIV_BUG_SIZE);
+}
+EXPORT_SYMBOL(c2k_clk_div_backup_relocate_table);
+
+#define to_clk_hw_comcerto2000(_hw) container_of(_hw, struct clk_hw_comcerto2000, hw)
+
+unsigned long comcerto2000_recalc(struct clk_hw *hw,
+ unsigned long parent_rate) {
+ struct clk_hw_comcerto2000 *clk_hw = to_clk_hw_comcerto2000(hw);
+ unsigned long rate;
+ u32 div;
+
+ if (!parent_rate)
+ return 0;
+
+ if (clk_hw->div_bypass)
+ div = 1;
+ else {
+ /* Get clock divider bypass value from IRAM Clock Divider registers mirror location */
+ div = readl(clk_hw->reg + clk_hw->divreg_offset); //TODO(danielmentz): #define for div offset
+ div &= 0x1f;
+ }
+
+ rate = parent_rate / div;
+
+ // pr_err("clock %s running at %lu div %u parent rate %lu\n", __clk_get_name(hw->clk), rate, div, parent_rate);
+
+ return rate;
+}
+
+long comcerto2000_round_rate(struct clk_hw *hw, unsigned long target_rate,
+ unsigned long *parent_rate) {
+ u32 div;
+
+ /* Get the divider value for clock */
+ div = (*parent_rate + target_rate - 1) / target_rate;
+ if (div == 0 || div > 0x1f)
+ return -EINVAL;
+ return *parent_rate / div;
+}
+
+int comcerto2000_set_rate(struct clk_hw *hw, unsigned long rate,
+ unsigned long parent_rate) {
+ struct clk_hw_comcerto2000 *clk_hw = to_clk_hw_comcerto2000(hw);
+ u32 div, val;
+
+ /* Get the divider value for clock */
+ div = (parent_rate + rate - 1) / rate;
+ if (div == 0 || div > 0x1f)
+ return -EINVAL;
+
+ val = readl(clk_hw->reg + clk_hw->divreg_offset);
+ if (div == 1) {
+ //TODO(danielmentz): bypass bug
+ /* Enable the Bypass bit in hw reg (clk_div_bypass in div_reg) */
+ val |= CLK_DIV_BYPASS;
+ clk_hw->div_bypass = 1;
+ } else {
+ //TODO(danielmentz): bypass bug
+ /* Clear the Bypass bit in hw reg (clk_div_bypass in div_reg) */
+ clk_hw->div_bypass = 0;
+ val &= ~CLK_DIV_BYPASS;
+ val &= ~0x1f;
+ val |= div;
+ }
+ writel(val, clk_hw->reg + clk_hw->divreg_offset);
+
+ return 0;
+}
+
+
+const struct clk_ops comcerto2000_clk_ops = {
+ .set_rate = &comcerto2000_set_rate,
+ .recalc_rate = &comcerto2000_recalc,
+ .round_rate = &comcerto2000_round_rate,
+};
+
+static void __init of_c2k_clk_setup(struct device_node *node) {
+ const char *name;
+ int num_parents;
+ const char **parent_names = NULL;
+ struct clk *clk;
+ struct clk_mux *mux = NULL;
+ struct clk_gate *gate = NULL;
+ struct clk_hw_comcerto2000 *rate = NULL;
+ void __iomem *regbase;
+ resource_size_t regbase_phys;
+ struct resource res;
+ u32 div_reg;
+ int i;
+
+ name = node->name;
+ of_property_read_string(node, "clock-output-names", &name);
+ num_parents = of_clk_get_parent_count(node);
+ if (num_parents != 5) {
+ pr_err("%s must have five parents\n", node->name);
+ goto cleanup;
+ }
+ parent_names = kzalloc(sizeof(char *) * num_parents, GFP_KERNEL);
+ if (!parent_names)
+ goto cleanup;
+ for (i = 0; i < num_parents; i++)
+ parent_names[i] = of_clk_get_parent_name(node, i);
+ regbase = of_iomap(node, 0);
+ WARN_ON(!regbase);
+ if (of_address_to_resource(node, 0, &res))
+ goto cleanup;
+ regbase_phys = res.start;
+ mux = kzalloc(sizeof(*mux), GFP_KERNEL);
+ if (!mux)
+ goto cleanup;
+ mux->reg = regbase + 0; // TODO(danielmentz): #define for mux offset
+ mux->shift = CLK_PLL_SRC_SHIFT;
+ mux->mask = CLK_PLL_SRC_MASK;
+ mux->flags = CLK_MUX_READ_ONLY;
+ mux->lock = 0; //TODO(danielmentz)
+
+ gate = kzalloc(sizeof(*gate), GFP_KERNEL);
+ if (!gate)
+ goto cleanup;
+ gate->flags = 0;
+ gate->reg = regbase + 0; // TODO(danielmentz): #define for gate offset
+ gate->bit_idx = 0; //TODO(danielmentz): #define for bit_idx
+ gate->lock = 0; //TODO(danielmentz)
+
+ rate = kzalloc(sizeof(*rate), GFP_KERNEL);
+ if (!rate)
+ goto cleanup;
+ rate->reg = regbase;
+ rate->divreg_offset = 4;// TODO(danielmentz): #define for div offset == 4
+ of_property_read_u32(node, "fsl,divreg-offset", &rate->divreg_offset);
+ div_reg = *((u32 *) (regbase_phys + rate->divreg_offset -
+ CLK_REG_DIV_BUG_BASE + clk_div_backup_table));
+ rate->div_bypass = (div_reg & CLK_DIV_BYPASS) ? 1 : 0;
+ clk = clk_register_composite(NULL, name,
+ parent_names, num_parents,
+ &mux->hw, &clk_mux_ro_ops,
+ &rate->hw, &comcerto2000_clk_ops,
+ &gate->hw, &clk_gate_ops,
+ 0); // TODO: flags)
+ if (IS_ERR(clk))
+ goto cleanup;
+ of_clk_add_provider(node, of_clk_src_simple_get, clk);
+
+ goto out;
+
+cleanup:
+ kfree(mux);
+ kfree(gate);
+ kfree(rate);
+out:
+ /*
+ * We don't need to retain parent_names. This array is only used for
+ * initialization.
+ * */
+ kfree(parent_names);
+}
+CLK_OF_DECLARE(c2k_pll_clock, "fsl,ls1024a-clock", of_c2k_clk_setup);
diff --git a/arch/arm/mach-comcerto/clock.h b/arch/arm/mach-comcerto/clock.h
new file mode 100644
index 0000000..27dc628
--- /dev/null
+++ b/arch/arm/mach-comcerto/clock.h
@@ -0,0 +1,28 @@
+/*
+ * arch/arm/mach-comcerto/clock.h
+ *
+ * Clock control driver for Comcerto C2K device - internal header file
+ *
+ * This file is licensed under
+ * the terms of the GNU General Public License version 2. This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+#ifndef __ARCH_ARM_C2K_CLOCK_H__
+#define __ARCH_ARM_C2K_CLOCK_H__
+
+#define CLK_DOMAIN_MASK (1<<0)
+#define CLK_DOMAIN_SPI_I2C_MASK (1<<5)
+#define CLK_DOMAIN_TDMNTG_MASK (1<<4)
+#define CLK_DOMAIN_UART_MASK (1<<6)
+#define CLK_DOMAIN_PCIE0_MASK (1<<0)
+#define CLK_DOMAIN_PCIE1_MASK (1<<1)
+#define CLK_DOMAIN_IPSEC_SPACC_MASK (1<<2)
+#define CLK_DOMAIN_DPI_CIE_MASK (1<<5)
+#define CLK_DOMAIN_DPI_DECOMP_MASK (1<<6)
+#define CLK_DOMAIN_USB0_MASK (1<<3)
+#define CLK_DOMAIN_USB1_MASK (1<<4)
+#define CLK_DOMAIN_DUS_MASK (1<<0)
+#define CLK_DOMAIN_SATA_MASK (1<<2)
+
+#endif
diff --git a/arch/arm/mach-comcerto/comcerto-restart.c b/arch/arm/mach-comcerto/comcerto-restart.c
new file mode 100644
index 0000000..a7ff5e2
--- /dev/null
+++ b/arch/arm/mach-comcerto/comcerto-restart.c
@@ -0,0 +1,5 @@
+#include "common.h"
+
+void c2k_restart(enum reboot_mode mode, const char *cmd)
+{
+}
diff --git a/arch/arm/mach-comcerto/comcerto-vwd.c b/arch/arm/mach-comcerto/comcerto-vwd.c
new file mode 100644
index 0000000..d6d9933
--- /dev/null
+++ b/arch/arm/mach-comcerto/comcerto-vwd.c
@@ -0,0 +1,53 @@
+/*
+ * linux/arch/arm/mach-comcerto/comcerto-vwd.c
+ *
+ * Copyright (C) 2011 Mindspeed Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#include <linux/module.h>
+#include <linux/skbuff.h>
+
+static int comcerto_wifi_rx_dummy_hdlr(struct sk_buff *skb)
+{
+ return -1;
+}
+
+static int (*vwd_rx_hdlr)(struct sk_buff *) = comcerto_wifi_rx_dummy_hdlr;
+
+int comcerto_wifi_rx_fastpath_register(int (*hdlr)(struct sk_buff *skb))
+{
+ printk(KERN_INFO "%s:%d VWD Tx function registered\n", __func__, __LINE__);
+ vwd_rx_hdlr = hdlr;
+
+ return 0;
+}
+
+void comcerto_wifi_rx_fastpath_unregister(void)
+{
+ printk(KERN_INFO "%s:%d VWD Tx function unregistered\n", __func__, __LINE__);
+ vwd_rx_hdlr = comcerto_wifi_rx_dummy_hdlr;
+
+ return;
+}
+
+int comcerto_wifi_rx_fastpath(struct sk_buff *skb)
+{
+ return (*vwd_rx_hdlr)(skb);
+}
+
+EXPORT_SYMBOL(comcerto_wifi_rx_fastpath_register);
+EXPORT_SYMBOL(comcerto_wifi_rx_fastpath_unregister);
+EXPORT_SYMBOL(comcerto_wifi_rx_fastpath);
diff --git a/arch/arm/mach-comcerto/common.c b/arch/arm/mach-comcerto/common.c
new file mode 100644
index 0000000..d7d4d56
--- /dev/null
+++ b/arch/arm/mach-comcerto/common.c
@@ -0,0 +1,38 @@
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/irqchip.h>
+
+#include <linux/memblock.h>
+#include <linux/antirebootloop.h>
+
+#include <mach/hardware.h>
+
+#include "common.h"
+
+void __init c2k_reserve(void)
+{
+ /* boot_secondary() in arch/arm/mach-comcerto/platsmp.c uses this range
+ * to store a jump instruction. The second CPU executes this
+ * instruction when it comes out of reset.*/
+ if (memblock_reserve(0, 0x24) < 0)
+ BUG();
+
+ if (memblock_reserve((phys_addr_t) get_antirebootloop_ptr(),
+ PAGE_SIZE) < 0)
+ BUG();
+
+ /* Allocate DDR block used by PFE/MSP, the base address is fixed so that util-pe code can
+ be linked at a fixed address */
+ if (memblock_reserve(COMCERTO_DDR_SHARED_BASE, COMCERTO_DDR_SHARED_SIZE) < 0)
+ BUG();
+
+ if (memblock_free(COMCERTO_DDR_SHARED_BASE, COMCERTO_DDR_SHARED_SIZE) < 0)
+ BUG();
+
+ if (memblock_remove(COMCERTO_DDR_SHARED_BASE, COMCERTO_DDR_SHARED_SIZE) < 0)
+ BUG();
+}
+
+phys_addr_t get_antirebootloop_ptr(void) {
+ return COMCERTO_AXI_DDR_BASE + (1 * PAGE_SIZE);
+}
diff --git a/arch/arm/mach-comcerto/common.h b/arch/arm/mach-comcerto/common.h
new file mode 100644
index 0000000..db13544
--- /dev/null
+++ b/arch/arm/mach-comcerto/common.h
@@ -0,0 +1,10 @@
+#include <linux/reboot.h>
+
+extern void ls1024a_secondary_startup(void);
+extern void c2k_local_timer_init(void);
+void c2k_init_early(void);
+void c2k_init_late(void);
+void c2k_restart(enum reboot_mode mode, const char *cmd);
+void __init c2k_map_io(void);
+void c2k_gic_of_init(void);
+extern void c2k_reserve(void);
diff --git a/arch/arm/mach-comcerto/headsmp.S b/arch/arm/mach-comcerto/headsmp.S
new file mode 100644
index 0000000..57202ef
--- /dev/null
+++ b/arch/arm/mach-comcerto/headsmp.S
@@ -0,0 +1,6 @@
+#include <linux/linkage.h>
+
+ENTRY(ls1024a_secondary_startup)
+ bl v7_invalidate_l1
+ b secondary_startup
+ENDPROC(ls1024a_secondary_startup)
diff --git a/arch/arm/mach-comcerto/include/mach/comcerto-2000.h b/arch/arm/mach-comcerto/include/mach/comcerto-2000.h
new file mode 100644
index 0000000..1e7c4b9
--- /dev/null
+++ b/arch/arm/mach-comcerto/include/mach/comcerto-2000.h
@@ -0,0 +1,244 @@
+/*
+ * arch/arm/arch-comcerto/include/mach/comcerto-2000.h
+ *
+ * Copyright (C) 2011 Mindspeed Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef __ASM_ARCH_HARDWARE_H
+#error "Do not include this directly, instead #include <asm/hardware.h>"
+#endif
+
+#ifndef __ASM_ARCH_COMCERTO2000_H__
+#define __ASM_ARCH_COMCERTO2000_H__
+
+
+/*
+ * System Clock Frequencies
+ */
+#ifdef CONFIG_RTSM_C2K
+#define COMCERTO_DEFAULTAXICLK (600000000/3) /* Hz */
+#else
+#define COMCERTO_DEFAULTAXICLK 200000000 /* Hz */
+#endif
+
+
+/*
+ * SCU registers
+ */
+#define COMCERTO_SCU_BASE 0xFFF00000
+#define COMCERTO_GIC_CPU_BASE (COMCERTO_SCU_BASE + 0x100)
+#define COMCERTO_TWD_BASE (COMCERTO_SCU_BASE + 0x600)
+#define COMCERTO_TWD_PERCPU_BASE (COMCERTO_SCU_BASE + 0x700)
+#define COMCERTO_GIC_DIST_BASE (COMCERTO_SCU_BASE + 0x1000)
+#define COMCERTO_L310_BASE (COMCERTO_SCU_BASE + 0x10000)
+
+#define COMCERTO_L2CC_ASSOCIATIVITY_SHIFT 16
+#define COMCERTO_L2CC_ASSOCIATIVITY_MASK 0x00010000
+#define COMCERTO_L2CC_ASSOCIATIVITY_8WAY 0x0
+#define COMCERTO_L2CC_ASSOCIATIVITY_16WAY 0x1
+
+#define COMCERTO_L2CC_WAYSIZE_SHIFT 17
+#define COMCERTO_L2CC_WAYSIZE_MASK 0x000E0000
+#define COMCERTO_L2CC_ASSOCIATIVITY_32KB 0x2
+
+#define COMCERTO_L2CC_WR_LAT_SHIFT 8
+#define COMCERTO_L2CC_RD_LAT_SHIFT 4
+
+
+/*
+ * Physical address of IO on APB Bus
+ */
+
+#define COMCERTO_APB_TDM_BASE 0x90400000
+#define COMCERTO_APB_USBPHY_SERDES_STAT_BASE 0x90410000
+#define COMCERTO_APB_TDMA_BASE 0x90420000
+#define COMCERTO_APB_TIMER_BASE 0x90450000
+#define COMCERTO_APB_PCI_SATA_USB_CTRL_BASE 0x90460000
+#define COMCERTO_APB_GPIO_BASE 0x90470000
+#define COMCERTO_APB_UART0_BASE 0x90490000
+#define COMCERTO_APB_SPI_BASE 0x90498000
+#define COMCERTO_APB_I2C_BASE 0x9049C000
+#define COMCERTO_APB_USB3_BASE 0x904A0000
+#define COMCERTO_APB_CLK_BASE 0x904B0000
+#define COMCERTO_APB_RTC_BASE 0x904E0000
+#define COMCERTO_APB_OTP_BASE 0x904F0000
+#define COMCERTO_APB_PFE_BASE 0x90500000
+#define COMCERTO_APB_SERDES_CONF_BASE 0x90590000
+#define COMCERTO_APB_EXPBUS_BASE 0x905A0000
+#define COMCERTO_APB_DDRPHY_BASE 0x905B0000
+#define COMCERTO_APB_TDMA2_BASE 0x905D0000
+#define COMCERTO_APB_MDMA_BASE 0x905E0000
+#define COMCERTO_APB_A9CS_BASE 0x90600000
+
+
+/*
+ * Physical address on AXI Bus
+ */
+#define COMCERTO_AXI_HIGHMEMDDR_BASE 0xFFFF0000
+#define COMCERTO_AXI_DDR_BASE 0x00000000
+#define COMCERTO_AXI_ACP_BASE 0x80000000 /* 48MB */
+#define COMCERTO_AXI_IRAM_BASE 0x83000000
+#define COMCERTO_AXI_IBR_BASE 0x90000000
+#define COMCERTO_AXI_APB_BASE 0x90400000 /* 12MB */
+#define COMCERTO_AXI_SEMA_BASE 0x91000000 /* 16MB */
+#define COMCERTO_AXI_USB2P0_BASE 0x92000000
+#define COMCERTO_AXI_TRUSTZONE_BASE 0x93000000
+#define COMCERTO_AXI_DPI0_BASE 0x94000000 /* 16MB */
+#define COMCERTO_AXI_DPI1_BASE 0x95000000 /* 16MB */
+#define COMCERTO_AXI_UART_SPI_BASE 0x96000000 /* 16MB */
+#define COMCERTO_AXI_UART0_BASE (COMCERTO_AXI_UART_SPI_BASE + 0x00300000)
+#define COMCERTO_AXI_UART1_BASE (COMCERTO_AXI_UART_SPI_BASE + 0x00400000)
+#define COMCERTO_AXI_SPI_BASE (COMCERTO_AXI_UART_SPI_BASE + 0x00500000)
+#define COMCERTO_AXI_DDRCONFIG_BASE 0x97000000
+#define COMCERTO_AXI_PCIe1_BASE 0x99000000
+#define COMCERTO_AXI_PCIe0_BASE 0x98000000
+#define COMCERTO_AXI_IPSEC_BASE 0x9A000000
+#define COMCERTO_AXI_SPACC_PDU_BASE 0x9B000000 /* 16MB */
+#define COMCERTO_AXI_PFE_BASE 0x9C000000 /* 16MB */
+#define COMCERTO_AXI_SATA_BASE 0x9D000000 /* 16MB */
+#define COMCERTO_AXI_DECT_BASE 0x9E000000 /* 16MB */
+#define COMCERTO_AXI_USB3P0_BASE 0x9F000000 /* 16MB */
+#define COMCERTO_AXI_PCIe0_SLAVE_BASE 0xA0000000
+#define COMCERTO_AXI_PCIe1_SLAVE_BASE 0xB0000000
+#define COMCERTO_AXI_EXP_BASE 0xC0000000
+#define COMCERTO_AXI_EXP_ECC_BASE 0xCFFF0000 /* 64KB */
+
+#define COMCERTO_AXI_ACP_SIZE (1 << 24)
+
+#define COMCERTO_DDR_SHARED_BASE (COMCERTO_AXI_DDR_BASE + 0x2C00000)
+#define COMCERTO_DDR_SHARED_SIZE (SZ_16M + SZ_4M)
+
+/* MSP memory map */
+#define COMCERTO_MSP_DDR_BASE COMCERTO_DDR_SHARED_BASE
+#define COMCERTO_MSP_DDR_SIZE_CB (SZ_1M * 5)
+#define COMCERTO_MSP_DDR_SIZE_NCNB (SZ_1M * 3)
+#define COMCERTO_MSP_DDR_SIZE (COMCERTO_MSP_DDR_SIZE_CB + COMCERTO_MSP_DDR_SIZE_NCNB)
+
+/* PFE memory map */
+#define COMCERTO_APB_PFE_SIZE SZ_64K
+#define COMCERTO_AXI_PFE_SIZE SZ_16M
+#define COMCERTO_AXI_IPSEC_SIZE SZ_16M
+#define COMCERTO_PFE_DDR_BASE (COMCERTO_DDR_SHARED_BASE + SZ_8M)
+#define COMCERTO_PFE_DDR_SIZE (SZ_8M + SZ_4M)
+#define COMCERTO_PFE_IRAM_BASE (COMCERTO_AXI_IRAM_BASE + 0x0000)
+#define COMCERTO_PFE_IRAM_SIZE SZ_8K
+
+/* MDMA memory map */
+#define COMCERTO_APB_MDMA_SIZE SZ_1K+SZ_4
+
+/*
+ * Virtual address mapping
+ */
+#define COMCERTO_MSP_VADDR 0xf0000000
+#define COMCERTO_PFE_VADDR 0xfa000000
+#define COMCERTO_PFE_AXI_VADDR 0xfc000000
+// TODO: #define COMCERTO_SCU_VADDR COMCERTO_SCU_BASE
+#define COMCERTO_SCU_VADDR 0xf0000000
+#define COMCERTO_GIC_CPU_VADDR (COMCERTO_SCU_VADDR + 0x100)
+#define COMCERTO_GIC_GLOBAL_TIMER_VADDR (COMCERTO_SCU_VADDR + 0x200)
+#define COMCERTO_TWD_VADDR (COMCERTO_SCU_VADDR + 0x600)
+#define COMCERTO_GIC_DIST_VADDR (COMCERTO_SCU_VADDR + 0x1000)
+#define COMCERTO_L310_VADDR (COMCERTO_SCU_VADDR + 0x10000)
+
+#define COMCERTO_DISTR_INT_SET_PENDING (COMCERTO_GIC_DIST_VADDR + 0x200)
+#define COMCERTO_DISTR_INT_SET_PENDING_OFFSET_4 (COMCERTO_DISTR_INT_SET_PENDING + 0x4)
+#define COMCERTO_DISTR_INT_SET_PENDING_OFFSET_8 (COMCERTO_DISTR_INT_SET_PENDING + 0x8)
+
+#define IRAM_MEMORY_VADDR 0xf0800000
+#define COMCERTO_APB_VADDR 0xf0900000 /* VA of IO on APB bus */
+#define COMCERTO_APB_SIZE 0x00C00000
+#define COMCERTO_AXI_UART_SPI_VADDR 0xF1600000
+#define COMCERTO_AXI_UART_SPI_SIZE 0x01000000
+#define COMCERTO_AXI_DMA_VADDR (COMCERTO_AXI_UART_SPI_VADDR+0x00000000)
+#define COMCERTO_AXI_UART0_VADDR (COMCERTO_AXI_UART_SPI_VADDR+0x00300000)
+#define COMCERTO_AXI_UART1_VADDR (COMCERTO_AXI_UART_SPI_VADDR+0x00400000)
+#define COMCERTO_AXI_SSI_VADDR (COMCERTO_AXI_UART_SPI_VADDR+0x00500000)
+
+#define COMCERTO_SEMA_VADDR 0xf4000000
+#define COMCERTO_AXI_PCIe0_VADDR_BASE 0xf5000000
+#define COMCERTO_AXI_PCIe1_VADDR_BASE 0xf6000000
+#define COMCERTO_DECT_VADDR 0xf7000000
+
+/*
+ * Reference Clock Option in Boot Strap Register
+ *
+ * BIT [9:8] System PLL Refclk Select
+ * '00' - USB XTAL
+ * '01' - Serdes #0 Refclk
+ * '10' - Serdes #1 Refclk
+ * '11' - Serdes XTAL
+ *
+ * BIT[7] Serdes OSC PAD - Reference clock frequency selection bootstrap (inverted value of SF1)
+ * '0' - 30MHz ~ 50MHz
+ * '1' - 15MHz ~ 30MHz
+ * Note: SF0 is tied to 1 in GPIO block and might later on be controlled during DFT
+ *
+ * BIT[5] USB/Sys PLL OSC PAD - Reference clock frequency selection bootstrap (inverted value of SF1)
+ *'0' - 30MHz ~ 50MHz
+ * '1' - 15MHz ~ 30MHz
+ * Note: SF0 is tied to 1 in GPIO block and might later on be controlled during DFT
+ *
+ */
+
+#define GPIO_SYS_PLL_REF_CLK_MASK (0x00000100 | 0x00000200)
+#define GPIO_SYS_PLL_REF_CLK_SHIFT 8
+
+#define USB_XTAL_REF_CLK 0
+#define SERDES_0_REF_CLK 1
+#define SERDES_2_REF_CLK 2
+#define SERDES_XTAL_REF_CLK 3
+
+#define GPIO_SERDES_OSC_PAD_MASK (0x00000080)
+#define GPIO_SERDES_OSC_PAD_SHIFT 7
+
+#define GPIO_USB_OSC_PAD_MASK (0x00000020)
+#define GPIO_USB_OSC_PAD_SHIFT 5
+
+#define REF_CLK_24MHZ 24000000 /* 24 MHz */
+#define REF_CLK_48MHZ 48000000 /* 48 MHz */
+
+
+/* USB 2.0 */
+#define USB2_PHY_BASE APB_VADDR(COMCERTO_APB_PCI_SATA_USB_CTRL_BASE)
+
+/* USB 3.0 */
+#define USB3_PHY_BASE APB_VADDR(COMCERTO_APB_USB3_BASE)
+
+#define USBPHY_SERDES_STAT_BASE APB_VADDR(COMCERTO_APB_USBPHY_SERDES_STAT_BASE)
+
+/* Includes */
+#include <mach/comcerto-2000/clk-rst.h>
+#include <mach/comcerto-2000/timer.h>
+#include <mach/comcerto-2000/memory.h>
+
+#define comcerto_timer4_set(hbound) __raw_writel((hbound), COMCERTO_TIMER4_HIGH_BOUND)
+
+#define comcerto_timer4_get() __raw_readl(COMCERTO_TIMER4_CURRENT_COUNT)
+
+
+#define comcerto_timer5_set(lbound, hbound, ctrl) do { \
+ __raw_writel((ctrl) & 0x1, COMCERTO_TIMER5_CTRL); \
+ __raw_writel((lbound), COMCERTO_TIMER5_LOW_BOUND); \
+ __raw_writel((hbound), COMCERTO_TIMER5_HIGH_BOUND); \
+ } while(0)
+
+#define comcerto_timer5_get() __raw_readl(COMCERTO_TIMER5_CURRENT_COUNT)
+
+/* Number of gemacs supported in comcerto 2000 */
+#define NUM_GEMAC_SUPPORT 3
+
+#endif
diff --git a/arch/arm/mach-comcerto/include/mach/comcerto-2000/clk-rst.h b/arch/arm/mach-comcerto/include/mach/comcerto-2000/clk-rst.h
new file mode 100644
index 0000000..8cdb717
--- /dev/null
+++ b/arch/arm/mach-comcerto/include/mach/comcerto-2000/clk-rst.h
@@ -0,0 +1,252 @@
+/*
+ * linux/arch/arm/mach-comcerto/include/mach/comcerto-2000/clk-rst.h
+ *
+ * Copyright (C) 2008 Mindspeed Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef __CLK_H__
+#define __CLK_H__
+
+/*
+ * Clock Reset Registers
+ */
+#define DEVICE_RST_CNTRL (COMCERTO_APB_CLK_BASE + 0x000)
+#define SERDES_RST_CNTRL (COMCERTO_APB_CLK_BASE + 0x004)
+#define PCIe_SATA_RST_CNTRL (COMCERTO_APB_CLK_BASE + 0x008)
+#define USB_RST_CNTRL (COMCERTO_APB_CLK_BASE + 0x00C)
+#define GNRL_DEVICE_CNFG_0 (COMCERTO_APB_CLK_BASE + 0x010)
+#define GNRL_DEVICE_CNFG_1 (COMCERTO_APB_CLK_BASE + 0x014)
+#define GNRL_DEVICE_STATUS (COMCERTO_APB_CLK_BASE + 0x018)
+#define A9DP_PWR_STAT (COMCERTO_APB_CLK_BASE + 0x028)
+#define A9DP_PWR_CNTRL (COMCERTO_APB_CLK_BASE + 0x02C)
+#define GNRL_CLK_CNTRL_0 (COMCERTO_APB_CLK_BASE + 0x030)
+#define GNRL_CLK_CNTRL_1 (COMCERTO_APB_CLK_BASE + 0x034)
+#define PLLS_GLOBAL_CNTRL (COMCERTO_APB_CLK_BASE + 0x038)
+#define AXI_CLK_CNTRL_0 (COMCERTO_APB_CLK_BASE + 0x040)
+#define AXI_CLK_CNTRL_1 (COMCERTO_APB_CLK_BASE + 0x044)
+#define AXI_CLK_CNTRL_2 (COMCERTO_APB_CLK_BASE + 0x048)
+#define AXI_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x04C)
+#define AXI_RESET_0 (COMCERTO_APB_CLK_BASE + 0x050)
+#define AXI_RESET_1 (COMCERTO_APB_CLK_BASE + 0x054)
+#define AXI_RESET_2 (COMCERTO_APB_CLK_BASE + 0x058)
+#define A9DP_MPU_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x68)
+#define A9DP_MPU_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x6C)
+#define A9DP_MPU_RESET (COMCERTO_APB_CLK_BASE + 0x70)
+#define A9DP_CPU_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x74)
+#define A9DP_CPU_RESET (COMCERTO_APB_CLK_BASE + 0x78)
+#define A9DP_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x80)
+#define A9DP_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x84)
+#define A9DP_RESET (COMCERTO_APB_CLK_BASE + 0x88)
+#define L2CC_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x090)
+#define L2CC_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x094)
+#define L2CC_RESET (COMCERTO_APB_CLK_BASE + 0x098)
+#define TPI_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x0A0)
+#define TPI_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x0A4)
+#define TPI_RESET (COMCERTO_APB_CLK_BASE + 0x0A8)
+#define CSYS_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x0B0)
+#define CSYS_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x0B4)
+#define CSYS_RESET (COMCERTO_APB_CLK_BASE + 0x0B8)
+#define EXTPHY0_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x0C0)
+#define EXTPHY0_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x0C4)
+#define EXTPHY0_RESET (COMCERTO_APB_CLK_BASE + 0x0C8)
+#define EXTPHY1_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x0D0)
+#define EXTPHY1_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x0D4)
+#define EXTPHY1_RESET (COMCERTO_APB_CLK_BASE + 0x0D8)
+#define EXTPHY2_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x0E0)
+#define EXTPHY2_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x0E4)
+#define EXTPHY2_RESET (COMCERTO_APB_CLK_BASE + 0x0E8)
+#define DDR_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x0F0)
+#define DDR_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x0F4)
+#define DDR_RESET (COMCERTO_APB_CLK_BASE + 0x0F8)
+#define PFE_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x100)
+#define PFE_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x104)
+#define PFE_RESET (COMCERTO_APB_CLK_BASE + 0x108)
+#define IPSEC_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x110)
+#define IPSEC_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x114)
+#define IPSEC_RESET (COMCERTO_APB_CLK_BASE + 0x118)
+#define DECT_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x120)
+#define DECT_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x124)
+#define DECT_RESET (COMCERTO_APB_CLK_BASE + 0x128)
+#define GEMTX_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x130)
+#define GEMTX_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x134)
+#define GEMTX_RESET (COMCERTO_APB_CLK_BASE + 0x138)
+#define TDMNTG_REF_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x140)
+#define TDMNTG_REF_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x144)
+#define TDMNTG_RESET (COMCERTO_APB_CLK_BASE + 0x148)
+#define TDM_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x14C)
+#define TSUNTG_REF_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x150)
+#define TSUNTG_REF_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x154)
+#define TSUNTG_RESET (COMCERTO_APB_CLK_BASE + 0x158)
+#define SATA_PMU_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x160)
+#define SATA_PMU_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x164)
+#define SATA_PMU_RESET (COMCERTO_APB_CLK_BASE + 0x168)
+#define SATA_OOB_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x170)
+#define SATA_OOB_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x174)
+#define SATA_OOB_RESET (COMCERTO_APB_CLK_BASE + 0x178)
+#define SATA_OCC_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x180)
+#define SATA_OCC_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x184)
+#define SATA_OCC_RESET (COMCERTO_APB_CLK_BASE + 0x188)
+#define PCIE_OCC_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x190)
+#define PCIE_OCC_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x194)
+#define PCIE_OCC_RESET (COMCERTO_APB_CLK_BASE + 0x198)
+#define SGMII_OCC_CLK_CNTRL (COMCERTO_APB_CLK_BASE + 0x1A0)
+#define SGMII_OCC_CLK_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x1A4)
+#define SGMII_OCC_RESET (COMCERTO_APB_CLK_BASE + 0x1A8)
+#define PLL0_M_LSB (COMCERTO_APB_CLK_BASE + 0x1C0)
+#define PLL0_M_MSB (COMCERTO_APB_CLK_BASE + 0x1C4)
+#define PLL0_P (COMCERTO_APB_CLK_BASE + 0x1C8)
+#define PLL0_S (COMCERTO_APB_CLK_BASE + 0x1CC)
+#define PLL0_CNTRL (COMCERTO_APB_CLK_BASE + 0x1D0)
+#define PLL0_TEST (COMCERTO_APB_CLK_BASE + 0x1D4)
+#define PLL0_STATUS (COMCERTO_APB_CLK_BASE + 0x1D8)
+#define PLL0_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x1DC)
+#define PLL1_M_LSB (COMCERTO_APB_CLK_BASE + 0x1E0)
+#define PLL1_M_MSB (COMCERTO_APB_CLK_BASE + 0x1E4)
+#define PLL1_P (COMCERTO_APB_CLK_BASE + 0x1E8)
+#define PLL1_S (COMCERTO_APB_CLK_BASE + 0x1EC)
+#define PLL1_CNTRL (COMCERTO_APB_CLK_BASE + 0x1F0)
+#define PLL1_TEST (COMCERTO_APB_CLK_BASE + 0x1F4)
+#define PLL1_STATUS (COMCERTO_APB_CLK_BASE + 0x1F8)
+#define PLL1_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x1FC)
+#define PLL2_M_LSB (COMCERTO_APB_CLK_BASE + 0x200)
+#define PLL2_M_MSB (COMCERTO_APB_CLK_BASE + 0x204)
+#define PLL2_P (COMCERTO_APB_CLK_BASE + 0x208)
+#define PLL2_S (COMCERTO_APB_CLK_BASE + 0x20C)
+#define PLL2_CNTRL (COMCERTO_APB_CLK_BASE + 0x210)
+#define PLL2_TEST (COMCERTO_APB_CLK_BASE + 0x214)
+#define PLL2_STATUS (COMCERTO_APB_CLK_BASE + 0x218)
+#define PLL2_DIV_CNTRL (COMCERTO_APB_CLK_BASE + 0x21C)
+#define PLL3_M_LSB (COMCERTO_APB_CLK_BASE + 0x220)
+#define PLL3_M_MSB (COMCERTO_APB_CLK_BASE + 0x224)
+#define PLL3_P (COMCERTO_APB_CLK_BASE + 0x228)
+#define PLL3_S (COMCERTO_APB_CLK_BASE + 0x22c)
+#define PLL3_CNTRL (COMCERTO_APB_CLK_BASE + 0x230)
+#define PLL3_TEST (COMCERTO_APB_CLK_BASE + 0x234)
+#define PLL3_STATUS (COMCERTO_APB_CLK_BASE + 0x238)
+#define PLL3_DITHER_CNTRL (COMCERTO_APB_CLK_BASE + 0x23C)
+#define PLL3_K_LSB (COMCERTO_APB_CLK_BASE + 0x240)
+#define PLL3_K_MSB (COMCERTO_APB_CLK_BASE + 0x244)
+#define PLL3_MFR (COMCERTO_APB_CLK_BASE + 0x248)
+#define PLL3_MRR (COMCERTO_APB_CLK_BASE + 0x24C)
+
+#define PLL0 0
+#define PLL1 1
+#define PLL2 2
+#define PLL3 3
+
+/* Device Reset Control Register (DEVICE_RST_CNTRL)*/
+
+#define CLK_DIV_RESTART (1 << 7)
+#define WD_STATUS_CLR (1 << 6)
+#define AXI_WD_RST_EN (1 << 5)
+#define DEBUG_RST (1 << 4)
+#define CLKRST_SCLR_RST (1 << 3)
+#define FUNC_SCLR_RST (1 << 2)
+#define GLB_SCLR_RST (1 << 1)
+#define PWR_ON_SOFT_RST (1 << 0)
+
+/* General Device Configuration Status Register (GNRL_DEVICE_STATUS) */
+#define CPU1_WD_RST_ACTIVATED (1 << 2)
+#define CPU0_WD_RST_ACTIVATED (1 << 1)
+#define AXI_WD_RST_ACTIVATED (1 << 0)
+
+/* Clock Control Register */
+#define CLOCK_DOMAIN_ENABLE 1
+#define CLOCK_DOMAIN_ENABLE_SHIFT 0
+
+#define CLOCK_SOURCE_PLL0 0
+#define CLOCK_SOURCE_PLL1 1
+#define CLOCK_SOURCE_PLL2 2
+#define CLOCK_SOURCE_PLL3 3
+#define CLOCK_SOURCE_PLL4 4
+
+#define CLOCK_SOURCE_SHIFT 1
+
+#define CLK_DIV_BYPASS (1 << 7)
+#define CLK_DIV_RATIO_MASK 0x1f
+
+#define PLL_VSEL (1 << 6)
+#define PLL_LOCK_EN (1 << 5)
+#define PLL_BYPASS (1 << 4)
+#define PLL_RESET (1 << 0)
+
+#define PLL_LOCK (1 << 0)
+
+#define CLK_PLL_SRC_MASK 0x7
+#define CLK_PLL_SRC_SHIFT 1
+#define CLK_A9DP_PERI_DIV_BYPASS (1 << 3)
+
+
+/* TDMNTG */
+#define TDMNTG_ADDR_SPACE_BASEADDR (COMCERTO_APB_CLK_BASE + 0x280)
+
+#define TDM_NTG_CLK_CTRL (TDMNTG_ADDR_SPACE_BASEADDR + 0x00)
+#define TDM_NTG_INCR (TDMNTG_ADDR_SPACE_BASEADDR + 0x04)
+#define TDM_FSYNC_GEN_CTRL (TDMNTG_ADDR_SPACE_BASEADDR + 0x08)
+#define TDM_FSYNC_LOW (TDMNTG_ADDR_SPACE_BASEADDR + 0x0C)
+#define TDM_FSYNC_HIGH (TDMNTG_ADDR_SPACE_BASEADDR + 0x10)
+
+#define FSYNC_FALL_EDGE (1 << 1)
+#define NTG_DIV_RST_N (1 << 5)
+#define NTG_EN (1 << 0)
+
+
+/* TSUNTG */
+#define TSUNTG_ADDR_SPACE_BASEADDR (COMCERTO_APB_CLK_BASE + 0x2C0)
+
+/* USB 3.0 */
+#define USB1_UTMI_RST (1 << 5)
+#define USB1_PHY_RST (1 << 4)
+#define USB1_AXI_RST (1 << 4)
+
+/* USB 2.0 */
+#define USB0_PHY_RST (1 << 0)
+#define USB0_UTMI_RST (1 << 1)
+#define USB0_AXI_RST (1 << 3)
+
+/* CPU */
+#define CPU0_RST (1 << 0)
+#define NEON0_RST (1 << 1)
+#define CPU1_RST (1 << 2)
+#define NEON1_RST (1 << 3)
+
+#define CPU0_CLK_ENABLE (1 << 0)
+#define NEON0_CLK_ENABLE (1 << 1)
+#define CPU1_CLK_ENABLE (1 << 2)
+#define NEON1_CLK_ENABLE (1 << 3)
+
+#define GLOBAL_CLK_ENABLE (1 << 0)
+
+#define CLAMP_CORE0 (1 << 4)
+#define CLAMP_CORE1 (1 << 6)
+#define CORE_PWRDWN0 (1 << 5)
+#define CORE_PWRDWN1 (1 << 7)
+#define MP_PWRDWN (1 << 0)
+
+#define SCPRE (1 << 4)
+#define SCALL (1 << 5)
+#define ISO_EN (1 << 6)
+
+#ifndef __ASSEMBLY__
+
+/* Function Declaration */
+extern void HAL_clk_div_backup_relocate_table (void);
+extern unsigned long HAL_get_ref_clk (void);
+#endif
+
+
+#endif
diff --git a/arch/arm/mach-comcerto/include/mach/comcerto-2000/memory.h b/arch/arm/mach-comcerto/include/mach/comcerto-2000/memory.h
new file mode 100644
index 0000000..8253848
--- /dev/null
+++ b/arch/arm/mach-comcerto/include/mach/comcerto-2000/memory.h
@@ -0,0 +1,38 @@
+/*
+ * arch/arm/arch-comcerto/include/mach/comcerto-2000/memory.h
+ *
+ * Copyright (C) 2011 Mindspeed Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+
+#ifndef __MEMORY_H__
+#define __MEMORY_H__
+
+ /* Physical addresses of memories */
+ #define IRAM_MEMORY_SIZE SZ_64K
+
+/*
+ * Virtual view <-> DMA view memory address translations
+ * virt_to_bus: Used to translate the virtual address to an
+ * address suitable to be passed to set_dma_addr
+ * bus_to_virt: Used to convert an address for DMA operations
+ * to an address that the kernel can use.
+ */
+
+#define aram_to_virt(p) (void*)(((unsigned long)p - COMCERTO_AXI_IRAM_BASE) + IRAM_MEMORY_VADDR)
+#define virt_to_aram(v) (((unsigned long)v - IRAM_MEMORY_VADDR) + COMCERTO_AXI_IRAM_BASE)
+#endif
diff --git a/arch/arm/mach-comcerto/include/mach/comcerto-2000/timer.h b/arch/arm/mach-comcerto/include/mach/comcerto-2000/timer.h
new file mode 100644
index 0000000..2320313
--- /dev/null
+++ b/arch/arm/mach-comcerto/include/mach/comcerto-2000/timer.h
@@ -0,0 +1,101 @@
+/*
+ * linux/include/asm-arm/arch-comcerto/comcerto-1000/timer.h
+ *
+ * Copyright (C) 2004-2008 Mindspeed Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef __TIMER_H__
+#define __TIMER_H__
+
+
+/* Comcerto Timers */
+#define COMCERTO_TIMER0_HIGH_BOUND 0x00
+#define COMCERTO_TIMER0_CURRENT_COUNT 0x04
+#define COMCERTO_TIMER1_HIGH_BOUND 0x08
+#define COMCERTO_TIMER1_CURRENT_COUNT 0x0C
+#define COMCERTO_TIMER2_LOW_BOUND 0x10
+#define COMCERTO_TIMER2_HIGH_BOUND 0x14
+#define COMCERTO_TIMER2_CTRL 0x18
+#define COMCERTO_TIMER2_CURRENT_COUNT 0x1C
+#define COMCERTO_TIMER3_LOW_BOUND 0x20
+#define COMCERTO_TIMER3_HIGH_BOUND 0x24
+#define COMCERTO_TIMER3_CTRL 0x28
+#define COMCERTO_TIMER3_CURRENT_COUNT 0x2C
+#define COMCERTO_TIMER4_HIGH_BOUND 0x30
+#define COMCERTO_TIMER4_CURRENT_COUNT 0x34
+#define COMCERTO_TIMER5_LOW_BOUND 0x38
+#define COMCERTO_TIMER5_HIGH_BOUND 0x3C
+#define COMCERTO_TIMER5_CURRENT_COUNT 0x40
+#define COMCERTO_TIMER5_CTRL 0x44
+#define COMCERTO_TIMER_IRQ_MASK 0x48
+#define COMCERTO_TIMER_STATUS 0x50
+#define COMCERTO_TIMER_STATUS_CLR 0x50
+
+/*COMCERTO_TIMER_IRQ_MASK*/
+#define COMCERTO_TIMER0 0x01
+#define COMCERTO_TIMER1 0x02
+#define COMCERTO_TIMER2 0x04
+#define COMCERTO_TIMER3 0x08
+#define COMCERTO_TIMER4 0x10
+#define COMCERTO_TIMER5 0x20
+#define COMCERTO_ALL 0xFF
+#define COMCERTO_TIMER_CSP (COMCERTO_TIMER1 | COMCERTO_TIMER2 | COMCERTO_TIMER3 | COMCERTO_TIMER4 | COMCERTO_TIMER5)
+
+/*
+ * TIMERS
+ */
+
+
+/*Hardware Timer API*/
+#define COMCERTO_TIMER_RUN_ONCE (1 << 0)
+#define __comcerto_timer_enable(t) __raw_writel(__raw_readl(COMCERTO_TIMER_IRQ_MASK) | (1 << (t)), COMCERTO_TIMER_IRQ_MASK)
+#define __comcerto_timer_disable(t) __raw_writel(__raw_readl(COMCERTO_TIMER_IRQ_MASK) & ~(1 << (t)), COMCERTO_TIMER_IRQ_MASK)
+#define comcerto_timer_ack(t) __raw_writel(1 << (t), COMCERTO_TIMER_STATUS_CLR)
+
+#define comcerto_timer0_set(hbound) __raw_writel((hbound), COMCERTO_TIMER0_HIGH_BOUND)
+#define comcerto_timer0_get() __raw_readl(COMCERTO_TIMER0_CURRENT_COUNT)
+
+#define comcerto_timer1_set(hbound) __raw_writel((hbound) & 0x3FFFFFFF, COMCERTO_TIMER1_HIGH_BOUND)
+#define comcerto_timer1_get() __raw_readl(COMCERTO_TIMER1_CURRENT_COUNT)
+
+#define comcerto_timer2_set(lbound, hbound, ctrl) do {\
+ __raw_writel((ctrl) & 0x1, COMCERTO_TIMER2_CTRL); \
+ __raw_writel((lbound), COMCERTO_TIMER2_LOW_BOUND); \
+ __raw_writel((hbound), COMCERTO_TIMER2_HIGH_BOUND); \
+ } while (0)
+
+#define comcerto_timer2_get() __raw_readl(COMCERTO_TIMER2_CURRENT_COUNT)
+
+
+#define comcerto_timer3_set(lbound, hbound, ctrl) do { \
+ __raw_writel((ctrl) & 0x1, COMCERTO_TIMER3_CTRL); \
+ __raw_writel((lbound), COMCERTO_TIMER3_LOW_BOUND); \
+ __raw_writel((hbound), COMCERTO_TIMER3_HIGH_BOUND); \
+ } while(0)
+
+#define comcerto_timer3_get() __raw_readl(COMCERTO_TIMER3_CURRENT_COUNT)
+
+#ifndef __ASSEMBLY__
+struct comcerto_timer {
+ unsigned long timeout;
+ void (*func) (unsigned long data);
+ unsigned long data;
+ unsigned char flags;
+ unsigned long thw;
+};
+#endif
+#endif
diff --git a/arch/arm/mach-comcerto/include/mach/comcerto-common.h b/arch/arm/mach-comcerto/include/mach/comcerto-common.h
new file mode 100644
index 0000000..1403f44
--- /dev/null
+++ b/arch/arm/mach-comcerto/include/mach/comcerto-common.h
@@ -0,0 +1,166 @@
+/*
+ * arch/arm/mach-comcerto/include/mach/comcerto-common.h
+ *
+ * Copyright (C) 2012 Mindspeed Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef __ASM_ARCH_HARDWARE_H
+#error "Do not include this directly, instead #include <asm/arch/hardware.h>"
+#endif
+
+#ifndef __ASM_COMCERTO_COMMON_H__
+#define __ASM_COMCERTO_COMMON_H__
+
+#include <asm/types.h>
+
+#define APB_VADDR(x) ((void __iomem *)((x) - COMCERTO_AXI_APB_BASE + COMCERTO_APB_VADDR)) /* macro to get virtual address of IO on APB Bus from Physical address*/
+#define AXI_VADDR(x) ((x) - COMCERTO_AXI_SPI_BASE + COMCERTO_AXI_SSI_VADDR) /* macro to get virtual address of IO on AXI Bus from Physical address*/
+
+#define BIT_0_MSK 0x00000001
+#define BIT_1_MSK 0x00000002
+#define BIT_2_MSK 0x00000004
+#define BIT_3_MSK 0x00000008
+#define BIT_4_MSK 0x00000010
+#define BIT_5_MSK 0x00000020
+#define BIT_6_MSK 0x00000040
+#define BIT_7_MSK 0x00000080
+#define BIT_8_MSK 0x00000100
+#define BIT_9_MSK 0x00000200
+#define BIT_10_MSK 0x00000400
+#define BIT_11_MSK 0x00000800
+#define BIT_12_MSK 0x00001000
+#define BIT_13_MSK 0x00002000
+#define BIT_14_MSK 0x00004000
+#define BIT_15_MSK 0x00008000
+#define BIT_16_MSK 0x00010000
+#define BIT_17_MSK 0x00020000
+#define BIT_18_MSK 0x00040000
+#define BIT_19_MSK 0x00080000
+#define BIT_20_MSK 0x00100000
+#define BIT_21_MSK 0x00200000
+#define BIT_22_MSK 0x00400000
+#define BIT_23_MSK 0x00800000
+#define BIT_24_MSK 0x01000000
+#define BIT_25_MSK 0x02000000
+#define BIT_26_MSK 0x04000000
+#define BIT_27_MSK 0x08000000
+#define BIT_28_MSK 0x10000000
+#define BIT_29_MSK 0x20000000
+#define BIT_30_MSK 0x40000000
+#define BIT_31_MSK 0x80000000
+
+/*
+ * GPIO
+ */
+/* Set gpio pins specified by gpiomask to be outputs */
+#define comcerto_gpio_enable_output(gpiomask) __raw_writel(__raw_readl(COMCERTO_GPIO_OE_REG) | (gpiomask), COMCERTO_GPIO_OE_REG)
+
+/* Set output pins specified by gpiomask to low */
+#define comcerto_gpio_set_0(gpiomask) __raw_writel(__raw_readl(COMCERTO_GPIO_OUTPUT_REG) & ~(gpiomask), COMCERTO_GPIO_OUTPUT_REG)
+
+/* Set output pins specified by gpiomask to high */
+#define comcerto_gpio_set_1(gpiomask) __raw_writel(__raw_readl(COMCERTO_GPIO_OUTPUT_REG) | (gpiomask), COMCERTO_GPIO_OUTPUT_REG)
+
+/* Read status of input pins specified by gpiomask */
+#define comcerto_gpio_read(gpiomask) (__raw_readl(COMCERTO_GPIO_INPUT_REG) & (gpiomask))
+
+
+#ifndef __ASSEMBLY__
+#define CONFIG_COMCERTO_GEMAC 1
+
+#define CONFIG_COMCERTO_USE_MII 1
+#define CONFIG_COMCERTO_USE_RMII 2
+#define CONFIG_COMCERTO_USE_GMII 4
+#define CONFIG_COMCERTO_USE_RGMII 8
+#define CONFIG_COMCERTO_USE_SGMII 0x10
+
+#define GEMAC_SW_CONF (1 << 8) | (1 << 11) // GEMAC configured by SW
+#define GEMAC_PHY_CONF 0 // GEMAC configured by phy lines (not for MII/GMII)
+#define GEMAC_SW_FULL_DUPLEX (1 << 9)
+#define GEMAC_SW_SPEED_10M (0 << 12)
+#define GEMAC_SW_SPEED_100M (1 << 12)
+#define GEMAC_SW_SPEED_1G (2 << 12)
+
+#define GEMAC_NO_PHY (1 << 0) // set if no phy connected to MAC (ex ethernet switch). In this case use MAC fixed configuration
+#define GEMAC_PHY_RGMII_ADD_DELAY (1 << 1)
+
+#define GEM0_MAC { 0x00, 0xED, 0xCD, 0xEF, 0xAA, 0xCC }
+#define GEM1_MAC { 0x00, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E }
+#define GEM2_MAC { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 }
+
+struct comcerto_eth_platform_data {
+ /* device specific information */
+ u32 device_flags;
+ char name[16];
+
+
+ /* board specific information */
+ u32 mii_config;
+ u32 gemac_mode;
+ u32 phy_flags;
+ u32 gem_id;
+ u32 bus_id;
+ u32 phy_id;
+ u8 *mac_addr;
+};
+
+struct comcerto_mdio_platform_data {
+ int enabled;
+ int irq[32];
+ u32 phy_mask;
+ int mdc_div;
+};
+
+struct comcerto_pfe_platform_data
+{
+ struct comcerto_eth_platform_data comcerto_eth_pdata[3];
+ struct comcerto_mdio_platform_data comcerto_mdio_pdata[3];
+};
+
+struct comcerto_tdm_data {
+ u8 fsoutput; /* Generic Pad Control and Version ID Register[2] */
+ u8 fspolarity; /* 28 FSYNC_FALL(RISE)_EDGE */
+ u16 fshwidth; /* High_Phase_Width[10:0] */
+ u16 fslwidth; /* Low_Phase_Width[26:16]] */
+ u32 clockhz; /* INC_VALUE[29:0] According to the desired TDM clock output frequency, this field should be configured */
+ u8 clockout; /* IO Control Register[21] hardware or software control selection IO Control Register[20] pads are input (output) */
+ u8 tdmmux;
+#if 0
+ u32 tdmck;
+ u32 tdmfs;
+ u32 tdmdx;
+ u32 tdmdr;
+#endif
+};
+
+/* L210 cache controller value
+ // Configure Aux:
+ // [11:9]=[8:6]=[2:0]=001 RAM LAT = 2 cycles
+ // [5:3]=000 Data write latency is 1
+ // [12]=0 WRAP access is enabled
+ // [16:13]=1000 8-way cache
+ // [19:17]=001 16KB way
+ // [20]=1 Event bus is enabled
+ // [21]=1 Parity is enabled
+ // [22]=0 Shared accesses treated as noncacheable
+ // [23]=0 HPROT is used
+ // [24]=1 Abort generation of exclusive access disabled
+*/
+#define L210_AUX_CTRL_REG 0x01330241
+
+#endif
+#endif
diff --git a/arch/arm/mach-comcerto/include/mach/hardware.h b/arch/arm/mach-comcerto/include/mach/hardware.h
new file mode 100644
index 0000000..c7dc18e
--- /dev/null
+++ b/arch/arm/mach-comcerto/include/mach/hardware.h
@@ -0,0 +1,49 @@
+/*
+ * arch/arm/mach-comcerto/include/mach/hardware.h
+ *
+ * Copyright (C) 2012 Mindspeed Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef __ASM_ARCH_HARDWARE_H
+#define __ASM_ARCH_HARDWARE_H
+
+#include <linux/types.h>
+
+#include <mach/comcerto-2000.h>
+
+
+#if 0
+ /***** Board *****/
+ #if defined(CONFIG_C2K_ASIC)
+ #include <mach/board-c2kasic.h>
+ #elif defined(CONFIG_GOOGLE_FIBER_OPTIMUS)
+ #include <mach/board-optimus.h>
+ #elif defined(CONFIG_C2K_EVM)
+ #include <mach/board-c2kevm.h>
+ #elif defined(CONFIG_C2K_MFCN_EVM)
+ #include <mach/board-c2kmfcnevm.h>
+ #elif defined(CONFIG_RTSM_C2K)
+ #include <mach/board-c2krtsm.h>
+
+ #else
+ #error "mach/board_XXX.h : Unknown board"
+ #endif
+#endif
+
+#include <mach/comcerto-common.h>
+
+#endif
diff --git a/arch/arm/mach-comcerto/io.c b/arch/arm/mach-comcerto/io.c
new file mode 100644
index 0000000..0080cca
--- /dev/null
+++ b/arch/arm/mach-comcerto/io.c
@@ -0,0 +1,68 @@
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+
+#include <asm/tlb.h>
+#include <asm/mach/map.h>
+
+#include <mach/hardware.h>
+
+
+static struct map_desc c2k_io_desc[] __initdata = {
+#if defined(CONFIG_PCI)
+ {
+ .virtual = COMCERTO_AXI_PCIe0_VADDR_BASE,
+ .pfn = __phys_to_pfn(COMCERTO_AXI_PCIe0_BASE),
+ .length = SZ_16M,
+ .type = MT_DEVICE
+ },
+ {
+ .virtual = COMCERTO_AXI_PCIe1_VADDR_BASE,
+ .pfn = __phys_to_pfn(COMCERTO_AXI_PCIe1_BASE),
+ .length = SZ_16M,
+ .type = MT_DEVICE
+ },
+#endif
+ {
+ .virtual = COMCERTO_SCU_VADDR,
+ .pfn = __phys_to_pfn(COMCERTO_SCU_BASE),
+ .length = SZ_128K,
+ .type = MT_DEVICE
+ },
+ {
+ .virtual = IRAM_MEMORY_VADDR,
+ .pfn = __phys_to_pfn(COMCERTO_AXI_IRAM_BASE),
+ .length = IRAM_MEMORY_SIZE,
+ .type = MT_DEVICE
+ },
+ {
+ .virtual = COMCERTO_APB_VADDR,
+ .pfn = __phys_to_pfn(COMCERTO_AXI_APB_BASE),
+ .length = COMCERTO_APB_SIZE,
+ .type = MT_DEVICE
+ },
+ {
+ .virtual = COMCERTO_AXI_UART_SPI_VADDR,
+ .pfn = __phys_to_pfn(COMCERTO_AXI_UART_SPI_BASE),
+ .length = COMCERTO_AXI_UART_SPI_SIZE,
+ .type = MT_DEVICE
+ },
+};
+
+void __init c2k_map_io(void)
+{
+ iotable_init(c2k_io_desc, ARRAY_SIZE(c2k_io_desc));
+}
+
+extern void c2k_clk_div_backup_relocate_table (void);
+
+void __init c2k_init_early(void)
+{
+ c2k_clk_div_backup_relocate_table();
+}
+void __init c2k_init_late(void)
+{
+}
diff --git a/arch/arm/mach-comcerto/platsmp.c b/arch/arm/mach-comcerto/platsmp.c
new file mode 100644
index 0000000..f31e578
--- /dev/null
+++ b/arch/arm/mach-comcerto/platsmp.c
@@ -0,0 +1,103 @@
+#include <linux/smp.h>
+#include <linux/io.h>
+#include <mach/hardware.h>
+#include <asm/cacheflush.h>
+#include <asm/smp_scu.h>
+#include <asm/unified.h>
+
+#include <linux/delay.h>
+
+#include "common.h"
+
+#define JUMP_TO_KERNEL_START_1 0xe3a00020 /* mov r0, #32 */
+#define JUMP_TO_KERNEL_START_2 0xe590f000 /* ldr pc, [r0] */
+
+/* SCU base address */
+static void __iomem *scu_base;
+
+static DEFINE_SPINLOCK(boot_lock);
+
+void __iomem *ls1024a_get_scu_base(void)
+{
+ return scu_base;
+}
+
+/*
+ * Initialise the CPU possible map early - this describes the CPUs
+ * which may be present or become present in the system.
+ */
+static void __init ls1024a_smp_init_cpus(void)
+{
+ int i, ncores;
+
+ scu_base = (void *) COMCERTO_SCU_VADDR;
+ ncores = scu_get_core_count(scu_base);
+
+ /* sanity check */
+ if (ncores > nr_cpu_ids) {
+ pr_warn("SMP: %u cores greater than maximum (%u), clipping\n",
+ ncores, nr_cpu_ids);
+ ncores = nr_cpu_ids;
+ }
+
+ for (i = 0; i < ncores; i++)
+ set_cpu_possible(i, true);
+}
+
+static void __init ls1024a_smp_prepare_cpus(unsigned int max_cpus)
+{
+ scu_enable(scu_base);
+}
+
+static int ls1024a_boot_secondary(unsigned int cpu, struct task_struct *idle)
+{
+ /*
+ * Set synchronisation state between this boot processor
+ * and the secondary one
+ */
+ spin_lock(&boot_lock);
+
+ /*
+ * Install the comcerto_secondary_startup pointer at 0x20
+ * Physical Address
+ */
+ __raw_writel(virt_to_phys(ls1024a_secondary_startup), phys_to_virt(0x20));
+ __raw_writel((unsigned int)JUMP_TO_KERNEL_START_1 , phys_to_virt(0x00));
+ __raw_writel((unsigned int)JUMP_TO_KERNEL_START_2 , phys_to_virt(0x04));
+ smp_wmb();
+ __cpuc_flush_dcache_area((void *)phys_to_virt(0x00), 0x24);
+ outer_clean_range(__pa(phys_to_virt(0x00)), __pa(phys_to_virt(0x24)));
+
+ /* Get CPU 1 out of reset */
+ __raw_writel((__raw_readl(APB_VADDR(A9DP_CPU_RESET)) & ~CPU1_RST), APB_VADDR(A9DP_CPU_RESET));
+ __raw_writel((__raw_readl(APB_VADDR(A9DP_PWR_CNTRL)) & ~CLAMP_CORE1), APB_VADDR(A9DP_PWR_CNTRL));
+ __raw_writel((__raw_readl(APB_VADDR(A9DP_CPU_CLK_CNTRL)) | CPU1_CLK_ENABLE), APB_VADDR(A9DP_CPU_CLK_CNTRL));
+
+#ifdef CONFIG_NEON
+ /* Get NEON 1 out of reset */
+ __raw_writel((__raw_readl(APB_VADDR(A9DP_CPU_RESET)) & ~NEON1_RST), APB_VADDR(A9DP_CPU_RESET));
+ __raw_writel((__raw_readl(APB_VADDR(A9DP_CPU_CLK_CNTRL)) | NEON1_CLK_ENABLE), APB_VADDR(A9DP_CPU_CLK_CNTRL));
+#endif
+
+ /*
+ * Now the secondary core is starting up let it run its
+ * calibrations, then wait for it to finish
+ */
+ spin_unlock(&boot_lock);
+
+ return 0;
+}
+
+struct smp_operations ls1024a_smp_ops __initdata = {
+ .smp_init_cpus = ls1024a_smp_init_cpus,
+ .smp_prepare_cpus = ls1024a_smp_prepare_cpus,
+ //.smp_secondary_init = ls1024a_secondary_init,
+ .smp_boot_secondary = ls1024a_boot_secondary,
+#if 0
+#ifdef CONFIG_HOTPLUG_CPU
+ .cpu_die = ls1024a_cpu_die,
+#endif
+#endif
+};
+
+CPU_METHOD_OF_DECLARE(fsl_ls1024a_smp, "fsl,ls1024a-smp", &ls1024a_smp_ops);
diff --git a/arch/arm/mm/dma-mapping.c b/arch/arm/mm/dma-mapping.c
index 64d7486..75f1003 100644
--- a/arch/arm/mm/dma-mapping.c
+++ b/arch/arm/mm/dma-mapping.c
@@ -41,6 +41,26 @@
#include "mm.h"
+#ifndef CONFIG_COMCERTO_DMA_COHERENT_SKB
+#define DEFAULT_DMA_COHERENT_POOL_SIZE SZ_256K
+#else
+/*
+ * Experiments showed that, on the NXP (formerly Freescale) QorIQ LS1024A (fka
+ * Mindspeed Comcerto 2000), we need approx. 10 MB of DMA coherent memory for
+ * fast forwarding between wired Ethernet ports and ath10k.
+ */
+#define DEFAULT_DMA_COHERENT_POOL_SIZE SZ_16M
+#endif
+
+static struct gen_pool *atomic_pool;
+static size_t atomic_pool_size = DEFAULT_DMA_COHERENT_POOL_SIZE;
+
+static inline bool __in_atomic_pool(void *start, size_t size)
+{
+ return atomic_pool && addr_in_gen_pool(atomic_pool,
+ (unsigned long)start, size);
+}
+
/*
* The DMA API is built upon the notion of "buffer ownership". A buffer
* is either exclusively owned by the CPU (and therefore may be accessed
@@ -76,8 +96,13 @@
unsigned long offset, size_t size, enum dma_data_direction dir,
struct dma_attrs *attrs)
{
- if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
- __dma_page_cpu_to_dev(page, offset, size, dir);
+ if (unlikely(!__in_atomic_pool(phys_to_virt(page_to_phys(page)),
+ size))) {
+ if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+ __dma_page_cpu_to_dev(page, offset, size, dir);
+ } else {
+ wmb();
+ }
return pfn_to_dma(dev, page_to_pfn(page)) + offset;
}
@@ -106,9 +131,11 @@
size_t size, enum dma_data_direction dir,
struct dma_attrs *attrs)
{
- if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
- __dma_page_dev_to_cpu(pfn_to_page(dma_to_pfn(dev, handle)),
- handle & ~PAGE_MASK, size, dir);
+ if (unlikely(!__in_atomic_pool(phys_to_virt(handle), size))) {
+ if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+ __dma_page_dev_to_cpu(pfn_to_page(dma_to_pfn(dev, handle)),
+ handle & ~PAGE_MASK, size, dir);
+ }
}
static void arm_dma_sync_single_for_cpu(struct device *dev,
@@ -314,10 +341,6 @@
VM_ARM_DMA_CONSISTENT | VM_USERMAP);
}
-#define DEFAULT_DMA_COHERENT_POOL_SIZE SZ_256K
-static struct gen_pool *atomic_pool;
-
-static size_t atomic_pool_size = DEFAULT_DMA_COHERENT_POOL_SIZE;
static int __init early_coherent_pool(char *p)
{
@@ -347,7 +370,9 @@
static int __init atomic_pool_init(void)
{
pgprot_t prot = pgprot_dmacoherent(PAGE_KERNEL);
+#ifndef CONFIG_COMCERTO_DMA_COHERENT_SKB
gfp_t gfp = GFP_KERNEL | GFP_DMA;
+#endif
struct page *page;
void *ptr;
@@ -358,9 +383,24 @@
if (dev_get_cma_area(NULL))
ptr = __alloc_from_contiguous(NULL, atomic_pool_size, prot,
&page, atomic_pool_init, true);
- else
+ else {
+#ifdef CONFIG_COMCERTO_DMA_COHERENT_SKB
+ /*
+ * For CONFIG_COMCERTO_DMA_COHERENT_SKB, we must not use
+ * __alloc_remap_buffer(), because it maps the DMA coherent
+ * pages into vmalloc space which is incompatible with
+ * dma_map_single(). You can't pass a pointer from vmalloc
+ * space into dma_map_single().
+ */
+ WARN(1, "If CONFIG_COMCERTO_DMA_COHERENT_SKB is enabled, the "
+ "DMA coherent pool must come from CMA. "
+ "Consider enabling CMA.");
+ ptr = 0;
+#else
ptr = __alloc_remap_buffer(NULL, atomic_pool_size, gfp, prot,
&page, atomic_pool_init, true);
+#endif
+ }
if (ptr) {
int ret;
@@ -509,11 +549,6 @@
return ptr;
}
-static bool __in_atomic_pool(void *start, size_t size)
-{
- return addr_in_gen_pool(atomic_pool, (unsigned long)start, size);
-}
-
static int __free_from_pool(void *start, size_t size)
{
if (!__in_atomic_pool(start, size))
diff --git a/arch/arm/mm/mmu.c b/arch/arm/mm/mmu.c
index 7186382..6fe3de9 100644
--- a/arch/arm/mm/mmu.c
+++ b/arch/arm/mm/mmu.c
@@ -854,6 +854,7 @@
return;
}
+ printk("Virtual 0x%08lx phys 0x%08llx length 0x%08lx\n", md->virtual, (long long)__pfn_to_phys((u64)md->pfn), md->length);
if ((md->type == MT_DEVICE || md->type == MT_ROM) &&
md->virtual >= PAGE_OFFSET &&
(md->virtual < VMALLOC_START || md->virtual >= VMALLOC_END)) {
diff --git a/arch/arm/mm/proc-v7.S b/arch/arm/mm/proc-v7.S
index 7911f14..9887a8d 100644
--- a/arch/arm/mm/proc-v7.S
+++ b/arch/arm/mm/proc-v7.S
@@ -261,6 +261,7 @@
__v7_ca9mp_setup:
__v7_cr7mp_setup:
mov r10, #(1 << 0) @ Cache/TLB ops broadcasting
+ orr r10, #(3 << 1) @ L1 data prefetch, L2 prefetch hints enable
b 1f
__v7_ca7mp_setup:
__v7_ca12mp_setup:
diff --git a/drivers/char/tpm/tpm_i2c_infineon.c b/drivers/char/tpm/tpm_i2c_infineon.c
index 33c5f36..e7d97fb 100644
--- a/drivers/char/tpm/tpm_i2c_infineon.c
+++ b/drivers/char/tpm/tpm_i2c_infineon.c
@@ -23,6 +23,7 @@
*/
#include <linux/i2c.h>
#include <linux/module.h>
+#include <linux/reboot.h>
#include <linux/wait.h>
#include "tpm.h"
@@ -69,6 +70,8 @@
u8 buf[TPM_BUFSIZE + sizeof(u8)]; /* max. buffer size + addr */
struct tpm_chip *chip;
enum i2c_chip_type chip_type;
+ bool reboot_in_progress;
+ struct mutex reboot_lock;
};
static struct tpm_inf_dev tpm_dev;
@@ -114,6 +117,16 @@
/* Lock the adapter for the duration of the whole sequence. */
if (!tpm_dev.client->adapter->algo->master_xfer)
return -EOPNOTSUPP;
+
+ mutex_lock(&tpm_dev.reboot_lock);
+
+ if (tpm_dev.reboot_in_progress) {
+ dev_warn(tpm_dev.chip->pdev, "reboot in progress, aborting %s\n",
+ __func__);
+ mutex_unlock(&tpm_dev.reboot_lock);
+ return -EIO;
+ }
+
i2c_lock_adapter(tpm_dev.client->adapter);
if (tpm_dev.chip_type == SLB9645) {
@@ -156,6 +169,9 @@
out:
i2c_unlock_adapter(tpm_dev.client->adapter);
+
+ mutex_unlock(&tpm_dev.reboot_lock);
+
/* take care of 'guard time' */
usleep_range(SLEEP_DURATION_LOW, SLEEP_DURATION_HI);
@@ -187,6 +203,13 @@
if (!tpm_dev.client->adapter->algo->master_xfer)
return -EOPNOTSUPP;
+
+ if (tpm_dev.reboot_in_progress) {
+ dev_warn(tpm_dev.chip->pdev, "reboot in progress, aborting %s\n",
+ __func__);
+ return -EIO;
+ }
+
i2c_lock_adapter(tpm_dev.client->adapter);
/* prepend the 'register address' to the buffer */
@@ -642,6 +665,22 @@
MODULE_DEVICE_TABLE(i2c, tpm_tis_i2c_table);
+static int tpm_reboot_handler(struct notifier_block *nb,unsigned long action, void *data)
+{
+ /* The assignment of the variable is atomic, the main purpose of the
+ lock is to avoid returning from the handler while communicating with
+ the TPM in iic_tpm_read() */
+ mutex_lock(&tpm_dev.reboot_lock);
+ tpm_dev.reboot_in_progress = true;
+ mutex_unlock(&tpm_dev.reboot_lock);
+
+ return 0;
+}
+
+static struct notifier_block tpm_reboot_notifier = {
+ .notifier_call = tpm_reboot_handler
+};
+
#ifdef CONFIG_OF
static const struct of_device_id tpm_tis_i2c_of_match[] = {
{
@@ -685,12 +724,18 @@
return -ENODEV;
}
+ mutex_init(&tpm_dev.reboot_lock);
+
tpm_dev.client = client;
rc = tpm_tis_i2c_init(&client->dev);
if (rc != 0) {
tpm_dev.client = NULL;
rc = -ENODEV;
}
+
+ tpm_dev.reboot_in_progress = false;
+ register_reboot_notifier(&tpm_reboot_notifier);
+
return rc;
}
diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index 9f9cadd..c09767b 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
@@ -524,6 +524,7 @@
if (clk->flags & CLK_IGNORE_UNUSED)
goto unlock_out;
+ pr_err("Disabling unused clock %s\n", clk->name);
/*
* some gate clocks have special needs during the disable-unused
* sequence. call .disable_unused if available, otherwise fall
diff --git a/drivers/hwmon/lm63.c b/drivers/hwmon/lm63.c
index 33bfdb4..d4b8c27 100644
--- a/drivers/hwmon/lm63.c
+++ b/drivers/hwmon/lm63.c
@@ -44,10 +44,12 @@
#include <linux/i2c.h>
#include <linux/hwmon-sysfs.h>
#include <linux/hwmon.h>
+#include <linux/ktime.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/sysfs.h>
#include <linux/types.h>
+#include <linux/delay.h>
/*
* Addresses to scan
@@ -73,6 +75,7 @@
#define LM63_REG_TACH_LIMIT_MSB 0x49
#define LM63_REG_TACH_LIMIT_LSB 0x48
+#define LM63_REG_SPINUP 0x4B
#define LM63_REG_PWM_VALUE 0x4C
#define LM63_REG_PWM_FREQ 0x4D
#define LM63_REG_LUT_TEMP_HYST 0x4F
@@ -187,6 +190,64 @@
bool trutherm;
};
+#define MAX_SMBUS_RETRIES 10
+
+static s32 lm63_i2c_smbus_write_byte_data(const struct i2c_client *client,
+ u8 command, u8 value) {
+ s32 ret;
+ int retries = MAX_SMBUS_RETRIES;
+ ktime_t start_time;
+ s64 d;
+ while (retries-- > 0) {
+ start_time = ktime_get();
+ ret = i2c_smbus_write_byte_data(client, command, value);
+ if (!ret) {
+ d = ktime_us_delta(ktime_get(), start_time);
+ if (d <= 22000) return 0;
+ dev_printk(KERN_DEBUG, &client->dev,
+ "I2C transaction took too long: %lld us.\n",
+ (long long) d);
+ ret = -ETIME;
+ }
+ dev_printk(KERN_DEBUG, &client->dev,
+ "Failed to write value 0x%02x to register 0x%02x: rc %d. Retries left: %d\n",
+ value, command, ret, retries);
+ msleep(100);
+ }
+ dev_warn(&client->dev,
+ "Failed %d times to write value 0x%02x to register 0x%02x: rc %d\n",
+ MAX_SMBUS_RETRIES, value, command, ret);
+ return ret;
+}
+
+static s32 lm63_i2c_smbus_read_byte_data(const struct i2c_client *client,
+ u8 command) {
+ s32 ret;
+ int retries = MAX_SMBUS_RETRIES;
+ ktime_t start_time;
+ s64 d;
+ while (retries-- > 0) {
+ start_time = ktime_get();
+ ret = i2c_smbus_read_byte_data(client, command);
+ if (ret >= 0) {
+ d = ktime_us_delta(ktime_get(), start_time);
+ if (d <= 22000) return ret;
+ dev_printk(KERN_DEBUG, &client->dev,
+ "I2C transaction took too long: %lld us.\n",
+ (long long) d);
+ ret = -ETIME;
+ }
+ dev_printk(KERN_DEBUG, &client->dev,
+ "Failed to read from register 0x%02x: rc %d. Retries left: %d\n",
+ command, ret, retries);
+ msleep(100);
+ }
+ dev_warn(&client->dev,
+ "Failed %d times to read from register 0x%02x: rc %d\n",
+ MAX_SMBUS_RETRIES, command, ret);
+ return ret;
+}
+
static inline int temp8_from_reg(struct lm63_data *data, int nr)
{
if (data->remote_unsigned)
@@ -220,12 +281,12 @@
if (time_after(jiffies, data->lut_last_updated + 5 * HZ) ||
!data->lut_valid) {
for (i = 0; i < data->lut_size; i++) {
- data->pwm1[1 + i] = i2c_smbus_read_byte_data(client,
+ data->pwm1[1 + i] = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_LUT_PWM(i));
- data->temp8[3 + i] = i2c_smbus_read_byte_data(client,
+ data->temp8[3 + i] = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_LUT_TEMP(i));
}
- data->lut_temp_hyst = i2c_smbus_read_byte_data(client,
+ data->lut_temp_hyst = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_LUT_TEMP_HYST);
data->lut_last_updated = jiffies;
@@ -246,58 +307,58 @@
if (time_after(jiffies, next_update) || !data->valid) {
if (data->config & 0x04) { /* tachometer enabled */
/* order matters for fan1_input */
- data->fan[0] = i2c_smbus_read_byte_data(client,
+ data->fan[0] = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_TACH_COUNT_LSB) & 0xFC;
- data->fan[0] |= i2c_smbus_read_byte_data(client,
+ data->fan[0] |= lm63_i2c_smbus_read_byte_data(client,
LM63_REG_TACH_COUNT_MSB) << 8;
- data->fan[1] = (i2c_smbus_read_byte_data(client,
+ data->fan[1] = (lm63_i2c_smbus_read_byte_data(client,
LM63_REG_TACH_LIMIT_LSB) & 0xFC)
- | (i2c_smbus_read_byte_data(client,
+ | (lm63_i2c_smbus_read_byte_data(client,
LM63_REG_TACH_LIMIT_MSB) << 8);
}
- data->pwm1_freq = i2c_smbus_read_byte_data(client,
+ data->pwm1_freq = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_PWM_FREQ);
if (data->pwm1_freq == 0)
data->pwm1_freq = 1;
- data->pwm1[0] = i2c_smbus_read_byte_data(client,
+ data->pwm1[0] = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_PWM_VALUE);
- data->temp8[0] = i2c_smbus_read_byte_data(client,
+ data->temp8[0] = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_LOCAL_TEMP);
- data->temp8[1] = i2c_smbus_read_byte_data(client,
+ data->temp8[1] = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_LOCAL_HIGH);
/* order matters for temp2_input */
- data->temp11[0] = i2c_smbus_read_byte_data(client,
+ data->temp11[0] = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_TEMP_MSB) << 8;
- data->temp11[0] |= i2c_smbus_read_byte_data(client,
+ data->temp11[0] |= lm63_i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_TEMP_LSB);
- data->temp11[1] = (i2c_smbus_read_byte_data(client,
+ data->temp11[1] = (lm63_i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_LOW_MSB) << 8)
- | i2c_smbus_read_byte_data(client,
+ | lm63_i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_LOW_LSB);
- data->temp11[2] = (i2c_smbus_read_byte_data(client,
+ data->temp11[2] = (lm63_i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_HIGH_MSB) << 8)
- | i2c_smbus_read_byte_data(client,
+ | lm63_i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_HIGH_LSB);
- data->temp11[3] = (i2c_smbus_read_byte_data(client,
+ data->temp11[3] = (lm63_i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_OFFSET_MSB) << 8)
- | i2c_smbus_read_byte_data(client,
+ | lm63_i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_OFFSET_LSB);
if (data->kind == lm96163)
- data->temp11u = (i2c_smbus_read_byte_data(client,
+ data->temp11u = (lm63_i2c_smbus_read_byte_data(client,
LM96163_REG_REMOTE_TEMP_U_MSB) << 8)
- | i2c_smbus_read_byte_data(client,
+ | lm63_i2c_smbus_read_byte_data(client,
LM96163_REG_REMOTE_TEMP_U_LSB);
- data->temp8[2] = i2c_smbus_read_byte_data(client,
+ data->temp8[2] = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_TCRIT);
- data->temp2_crit_hyst = i2c_smbus_read_byte_data(client,
+ data->temp2_crit_hyst = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_REMOTE_TCRIT_HYST);
- data->alarms = i2c_smbus_read_byte_data(client,
+ data->alarms = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_ALERT_STATUS) & 0x7F;
data->last_updated = jiffies;
@@ -362,9 +423,9 @@
mutex_lock(&data->update_lock);
data->fan[1] = FAN_TO_REG(val);
- i2c_smbus_write_byte_data(client, LM63_REG_TACH_LIMIT_LSB,
+ lm63_i2c_smbus_write_byte_data(client, LM63_REG_TACH_LIMIT_LSB,
data->fan[1] & 0xFF);
- i2c_smbus_write_byte_data(client, LM63_REG_TACH_LIMIT_MSB,
+ lm63_i2c_smbus_write_byte_data(client, LM63_REG_TACH_LIMIT_MSB,
data->fan[1] >> 8);
mutex_unlock(&data->update_lock);
return count;
@@ -412,7 +473,7 @@
mutex_lock(&data->update_lock);
data->pwm1[nr] = data->pwm_highres ? val :
(val * data->pwm1_freq * 2 + 127) / 255;
- i2c_smbus_write_byte_data(client, reg, data->pwm1[nr]);
+ lm63_i2c_smbus_write_byte_data(client, reg, data->pwm1[nr]);
mutex_unlock(&data->update_lock);
return count;
}
@@ -447,13 +508,13 @@
return -EPERM;
mutex_lock(&data->update_lock);
- data->config_fan = i2c_smbus_read_byte_data(client,
+ data->config_fan = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_CONFIG_FAN);
if (val == 1)
data->config_fan |= 0x20;
else
data->config_fan &= ~0x20;
- i2c_smbus_write_byte_data(client, LM63_REG_CONFIG_FAN,
+ lm63_i2c_smbus_write_byte_data(client, LM63_REG_CONFIG_FAN,
data->config_fan);
mutex_unlock(&data->update_lock);
return count;
@@ -528,7 +589,7 @@
temp = lut_temp_to_reg(data, val);
}
data->temp8[nr] = temp;
- i2c_smbus_write_byte_data(client, reg, temp);
+ lm63_i2c_smbus_write_byte_data(client, reg, temp);
mutex_unlock(&data->update_lock);
return count;
}
@@ -588,9 +649,9 @@
else
data->temp11[nr] = TEMP11_TO_REG(val - data->temp2_offset);
- i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
+ lm63_i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
data->temp11[nr] >> 8);
- i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
+ lm63_i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
data->temp11[nr] & 0xff);
mutex_unlock(&data->update_lock);
return count;
@@ -640,7 +701,7 @@
mutex_lock(&data->update_lock);
hyst = temp8_from_reg(data, 2) + data->temp2_offset - val;
- i2c_smbus_write_byte_data(client, LM63_REG_REMOTE_TCRIT_HYST,
+ lm63_i2c_smbus_write_byte_data(client, LM63_REG_REMOTE_TCRIT_HYST,
HYST_TO_REG(hyst));
mutex_unlock(&data->update_lock);
return count;
@@ -666,7 +727,7 @@
if (interval >= update_interval * 3 / 4)
break;
- i2c_smbus_write_byte_data(client, LM63_REG_CONVRATE, i);
+ lm63_i2c_smbus_write_byte_data(client, LM63_REG_CONVRATE, i);
data->update_interval = UPDATE_INTERVAL(data->max_convrate_hz, i);
}
@@ -722,8 +783,8 @@
mutex_lock(&data->update_lock);
data->trutherm = val == 1;
- reg = i2c_smbus_read_byte_data(client, LM96163_REG_TRUTHERM) & ~0x02;
- i2c_smbus_write_byte_data(client, LM96163_REG_TRUTHERM,
+ reg = lm63_i2c_smbus_read_byte_data(client, LM96163_REG_TRUTHERM) & ~0x02;
+ lm63_i2c_smbus_write_byte_data(client, LM96163_REG_TRUTHERM,
reg | (data->trutherm ? 0x02 : 0x00));
data->valid = 0;
mutex_unlock(&data->update_lock);
@@ -989,14 +1050,14 @@
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -ENODEV;
- man_id = i2c_smbus_read_byte_data(client, LM63_REG_MAN_ID);
- chip_id = i2c_smbus_read_byte_data(client, LM63_REG_CHIP_ID);
+ man_id = lm63_i2c_smbus_read_byte_data(client, LM63_REG_MAN_ID);
+ chip_id = lm63_i2c_smbus_read_byte_data(client, LM63_REG_CHIP_ID);
- reg_config1 = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG1);
- reg_config2 = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG2);
- reg_alert_status = i2c_smbus_read_byte_data(client,
+ reg_config1 = lm63_i2c_smbus_read_byte_data(client, LM63_REG_CONFIG1);
+ reg_config2 = lm63_i2c_smbus_read_byte_data(client, LM63_REG_CONFIG2);
+ reg_alert_status = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_ALERT_STATUS);
- reg_alert_mask = i2c_smbus_read_byte_data(client, LM63_REG_ALERT_MASK);
+ reg_alert_mask = lm63_i2c_smbus_read_byte_data(client, LM63_REG_ALERT_MASK);
if (man_id != 0x01 /* National Semiconductor */
|| (reg_config1 & 0x18) != 0x00
@@ -1030,24 +1091,38 @@
struct i2c_client *client = data->client;
struct device *dev = &client->dev;
u8 convrate;
+ u8 config2;
- data->config = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG1);
- data->config_fan = i2c_smbus_read_byte_data(client,
+ data->config = lm63_i2c_smbus_read_byte_data(client, LM63_REG_CONFIG1);
+ data->config_fan = lm63_i2c_smbus_read_byte_data(client,
LM63_REG_CONFIG_FAN);
/* Start converting if needed */
if (data->config & 0x40) { /* standby */
dev_dbg(dev, "Switching to operational mode\n");
data->config &= 0xA7;
- i2c_smbus_write_byte_data(client, LM63_REG_CONFIG1,
+ lm63_i2c_smbus_write_byte_data(client, LM63_REG_CONFIG1,
data->config);
}
+
+ /* Enable digital filter */
+ /* From the LM96063 datasheet:
+ * "In order to suppress erroneous remote temperature readings due to
+ * noise as well as increase the resolution of the temperature, the
+ * LM96063 incorporates a digital filter for remote temperature
+ * readings." */
+ config2 = lm63_i2c_smbus_read_byte_data(client, LM63_REG_CONFIG2);
+ config2 |= 0x6; /* Enhanced Filter (Filter with transient noise
+ clipping) */
+ lm63_i2c_smbus_write_byte_data(client, LM63_REG_CONFIG2,
+ config2);
+
/* Tachometer is always enabled on LM64 */
if (data->kind == lm64)
data->config |= 0x04;
/* We may need pwm1_freq before ever updating the client data */
- data->pwm1_freq = i2c_smbus_read_byte_data(client, LM63_REG_PWM_FREQ);
+ data->pwm1_freq = lm63_i2c_smbus_read_byte_data(client, LM63_REG_PWM_FREQ);
if (data->pwm1_freq == 0)
data->pwm1_freq = 1;
@@ -1061,11 +1136,11 @@
data->max_convrate_hz = LM96163_MAX_CONVRATE_HZ;
data->lut_size = 12;
data->trutherm
- = i2c_smbus_read_byte_data(client,
+ = lm63_i2c_smbus_read_byte_data(client,
LM96163_REG_TRUTHERM) & 0x02;
break;
}
- convrate = i2c_smbus_read_byte_data(client, LM63_REG_CONVRATE);
+ convrate = lm63_i2c_smbus_read_byte_data(client, LM63_REG_CONVRATE);
if (unlikely(convrate > LM63_MAX_CONVRATE))
convrate = LM63_MAX_CONVRATE;
data->update_interval = UPDATE_INTERVAL(data->max_convrate_hz,
@@ -1077,7 +1152,7 @@
*/
if (data->kind == lm96163) {
u8 config_enhanced
- = i2c_smbus_read_byte_data(client,
+ = lm63_i2c_smbus_read_byte_data(client,
LM96163_REG_CONFIG_ENHANCED);
if (config_enhanced & 0x20)
data->lut_temp_highres = true;
@@ -1088,6 +1163,9 @@
data->remote_unsigned = true;
}
+ /* 50% spinup for 3.2 seconds */
+ lm63_i2c_smbus_write_byte_data(client, LM63_REG_SPINUP, 0x0f);
+
/* Show some debug info about the LM63 configuration */
if (data->kind == lm63)
dev_dbg(dev, "Alert/tach pin configured for %s\n",
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 2255af2..4509845 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -602,6 +602,16 @@
This driver can also be built as a module. If so, the module
will be called i2c-kempld.
+config I2C_LS1024A
+ tristate "Freescale LS1024A I2C interface"
+ depends on ARCH_COMCERTO
+ help
+ Say Y here if you want to use the I2C bus controller on
+ the Freescale LS1024A SoC.
+
+ This driver can also be built as a module. If so, the module
+ will be called i2c-ls1024a.
+
config I2C_MESON
tristate "Amlogic Meson I2C controller"
depends on ARCH_MESON
diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile
index cdf941d..ca8e1ec 100644
--- a/drivers/i2c/busses/Makefile
+++ b/drivers/i2c/busses/Makefile
@@ -58,6 +58,7 @@
obj-$(CONFIG_I2C_IOP3XX) += i2c-iop3xx.o
obj-$(CONFIG_I2C_JZ4780) += i2c-jz4780.o
obj-$(CONFIG_I2C_KEMPLD) += i2c-kempld.o
+obj-$(CONFIG_I2C_LS1024A) += i2c-ls1024a.o
obj-$(CONFIG_I2C_MESON) += i2c-meson.o
obj-$(CONFIG_I2C_MPC) += i2c-mpc.o
obj-$(CONFIG_I2C_MV64XXX) += i2c-mv64xxx.o
diff --git a/drivers/i2c/busses/i2c-ls1024a.c b/drivers/i2c/busses/i2c-ls1024a.c
new file mode 100644
index 0000000..5a5bb01
--- /dev/null
+++ b/drivers/i2c/busses/i2c-ls1024a.c
@@ -0,0 +1,626 @@
+/*
+ * Copyright (C) 2008 Mindspeed Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+
+struct ls1024a_i2c_dev {
+ struct device *dev;
+ struct i2c_adapter adapter;
+ void __iomem *membase;
+ int irq;
+ struct clk *clk;
+ wait_queue_head_t wait;
+ struct i2c_msg *msg;
+ int msg_state;
+ int msg_status; /* < 0: error, == 0: success, > 0: message in progress */
+ int msg_len;
+ int msg_retries;
+};
+
+#define SPEED_NORMAL_KHZ 100
+
+#define COMCERTO_I2C_ADDR (0x00*4)
+#define COMCERTO_I2C_DATA (0x01*4)
+#define COMCERTO_I2C_CNTR (0x02*4)
+#define COMCERTO_I2C_STAT (0x03*4)
+#define COMCERTO_I2C_CCRFS (0x03*4)
+#define COMCERTO_I2C_XADDR (0x04*4)
+#define COMCERTO_I2C_CCRH (0x05*4)
+#define COMCERTO_I2C_RESET (0x07*4)
+
+/* CNTR - Control register bits */
+#define CNTR_IEN (1<<7)
+#define CNTR_ENAB (1<<6)
+#define CNTR_STA (1<<5)
+#define CNTR_STP (1<<4)
+#define CNTR_IFLG (1<<3)
+#define CNTR_AAK (1<<2)
+
+/* STAT - Status codes */
+#define STAT_BUS_ERROR 0x00 /* Bus error in master mode only */
+#define STAT_START 0x08 /* Start condition transmitted */
+#define STAT_START_REPEATED 0x10 /* Repeated Start condition transmited */
+#define STAT_ADDR_WR_ACK 0x18 /* Address + Write bit transmitted, ACK received */
+#define STAT_ADDR_WR_NACK 0x20 /* Address + Write bit transmitted, NACK received */
+#define STAT_DATA_WR_ACK 0x28 /* Data byte transmitted in master mode , ACK received */
+#define STAT_DATA_WR_NACK 0x30 /* Data byte transmitted in master mode , NACK received */
+#define STAT_ARBIT_LOST 0x38 /* Arbitration lost in address or data byte */
+#define STAT_ADDR_RD_ACK 0x40 /* Address + Read bit transmitted, ACK received */
+#define STAT_ADDR_RD_NACK 0x48 /* Address + Read bit transmitted, NACK received */
+#define STAT_DATA_RD_ACK 0x50 /* Data byte received in master mode, ACK transmitted */
+#define STAT_DATA_RD_NACK 0x58 /* Data byte received in master mode, NACK transmitted*/
+#define STAT_ARBIT_LOST_ADDR 0x68 /* Arbitration lost in address */
+#define STAT_GENERAL_CALL 0x70 /* General Call, ACK transmitted */
+#define STAT_NO_RELEVANT_INFO 0xF8 /* No relevant status information, IFLF=0 */
+
+#define REG_ADDR(i2c, offset) ((i2c)->membase + (offset))
+#define RD_REG(i2c, offset) readb(REG_ADDR(i2c, offset))
+#define WR_REG(i2c, offset, byte) writeb(byte, REG_ADDR(i2c, offset))
+#define RD_DATA(i2c) RD_REG(i2c, COMCERTO_I2C_DATA)
+#define WR_DATA(i2c, byte) WR_REG(i2c, COMCERTO_I2C_DATA, byte)
+#define RD_CNTR(i2c) RD_REG(i2c, COMCERTO_I2C_CNTR)
+#define WR_CNTR(i2c, byte) WR_REG(i2c, COMCERTO_I2C_CNTR, byte)
+#define RD_STAT(i2c) RD_REG(i2c, COMCERTO_I2C_STAT)
+#define WR_CCRFS(i2c, byte) WR_REG(i2c, COMCERTO_I2C_CCRFS, byte)
+#define WR_CCRH(i2c, byte) WR_REG(i2c, COMCERTO_I2C_CCRH, byte)
+#define WR_RESET(i2c, byte) WR_REG(i2c, COMCERTO_I2C_RESET, byte)
+
+enum
+{
+ TR_IDLE = 0,
+ TR_START_ACK,
+ TR_ADDR_ACK,
+ TR_DATA_ACK,
+ RX_DATA_NACK,
+};
+
+static u8 comcerto_i2c_calculate_dividers(struct ls1024a_i2c_dev *i2c)
+{
+ int m, n, hz, speed_hz;
+ int saved_n, saved_m, saved_hz;
+ u8 dividers;
+ unsigned int i2c_clk;
+
+ /* Get the i2c clock rate */
+ i2c_clk = clk_get_rate(i2c->clk);
+
+ speed_hz = SPEED_NORMAL_KHZ * 1000;
+ saved_hz = saved_n = saved_m = 0;
+
+ for (m = 0; m < 16; m++) {
+ for (n = 0; n < 8; n++) {
+ hz = i2c_clk / ((1 << n) * (m + 1) * 10);
+ if (!saved_hz || abs(speed_hz - hz) < abs(speed_hz - saved_hz)) {
+ saved_n = n;
+ saved_m = m;
+ saved_hz = hz;
+ }
+ }
+ }
+
+ dividers = (saved_m << 3) | saved_n;
+ dev_dbg(i2c->dev, "%s: speed=%dkHz, M=%d, N=%d, dividers=0x%02x\n", __FUNCTION__,
+ saved_hz/1000, saved_m, saved_n, dividers);
+ printk("%s: speed=%dkHz, M=%d, N=%d, dividers=0x%02x\n", __FUNCTION__, saved_hz/1000, saved_m, saved_n, dividers);
+
+ return dividers;
+}
+
+/*
+ * Returns the timeout (in jiffies) for the given message.
+ */
+static int comcerto_i2c_calculate_timeout(struct ls1024a_i2c_dev *i2c, struct i2c_msg *msg)
+{
+ int timeout;
+
+ /* if no timeout was specified, calculate it */
+ if (i2c->adapter.timeout <= 0) {
+ if (i2c->irq >= 0) {
+ /* for the interrupt mode calculate timeout for 'full' message */
+ timeout = ((int)msg->len) * 10; /* convert approx. to bits */
+ timeout /= SPEED_NORMAL_KHZ; /* convert to bits per ms (note of kHz scale) */
+ timeout += timeout >> 1; /* add 50% */
+ timeout = timeout*HZ / 1000; /* convert to jiffies */
+ if (timeout < HZ / 5) /* at least 200ms */
+ timeout = HZ / 5;
+ }
+ else
+ timeout = HZ; /* 1 second for the polling mode */
+ }
+ else
+ timeout = i2c->adapter.timeout;
+
+ return timeout;
+}
+
+/*
+ * Initialize I2C core. Zero CNTR and DATA, try RESET. Short busy wait and check core status.
+ * After that set dividers for choosen speed.
+ */
+static void comcerto_i2c_reset(struct ls1024a_i2c_dev *i2c)
+{
+ u8 status, dividers;
+
+ dev_dbg(i2c->dev, "%s\n", __FUNCTION__);
+
+ WR_CNTR(i2c, 0);
+ WR_DATA(i2c, 0);
+ WR_RESET(i2c, 1);
+
+ udelay(10);
+
+ status = RD_STAT(i2c);
+ if (status != STAT_NO_RELEVANT_INFO)
+ dev_printk(KERN_DEBUG, i2c->dev, "%s: unexpected status after reset: 0x%02x\n", __FUNCTION__, status);
+
+ /* dividers should be placed in CCRH for high-sped mode and in CCRFS for standard/full modes */
+ dividers = comcerto_i2c_calculate_dividers(i2c);
+ WR_CCRFS(i2c, dividers);
+}
+
+static inline void comcerto_i2c_message_complete(struct ls1024a_i2c_dev *i2c, int status)
+{
+ WR_CNTR(i2c, CNTR_STP);
+
+ i2c->msg_status = status;
+}
+
+static inline int comcerto_i2c_message_in_progress(struct ls1024a_i2c_dev *i2c)
+{
+ return i2c->msg_status > 0;
+}
+
+/*
+ * Wait event. This function sleeps in polling mode, in interrupt
+ * mode it enables IRQ from I2C core and exits immediately.
+ */
+static int comcerto_i2c_wait(struct ls1024a_i2c_dev *i2c, u8 cntr)
+{
+ cntr &= ~(CNTR_IFLG | CNTR_IEN); /* clear both IFLG and IEN */
+
+ if (i2c->irq < 0) {
+ ulong jiffies_mark = jiffies + comcerto_i2c_calculate_timeout(i2c, i2c->msg);
+
+ WR_CNTR(i2c, cntr);
+ while ((RD_CNTR(i2c) & CNTR_IFLG) == 0) {
+ if (need_resched())
+ schedule();
+
+ if (time_after(jiffies, jiffies_mark)) {
+ dev_printk(KERN_DEBUG, i2c->dev, "%s: polling transfer timeout\n", __FUNCTION__);
+ comcerto_i2c_message_complete(i2c, -ETIME);
+ comcerto_i2c_reset(i2c);
+ break;
+ }
+ }
+ }
+ else {
+ /* enable interrupt */
+ WR_CNTR(i2c, cntr | CNTR_IEN);
+ }
+
+ return 0;
+}
+
+static void comcerto_i2c_state_idle(struct ls1024a_i2c_dev *i2c, u8 *cntr)
+{
+ if (unlikely(i2c->msg->flags & I2C_M_NOSTART)) {
+ i2c->msg_state = TR_ADDR_ACK;
+ }
+ else {
+ *cntr = CNTR_STP|CNTR_STA; /* SPT|STA to auto recover from bus error state transparently at the start of the transfer */
+ i2c->msg_state = TR_START_ACK;
+ }
+}
+
+static void comcerto_i2c_state_start_ack(struct ls1024a_i2c_dev *i2c, u8 *cntr)
+{
+ u8 status, addr;
+
+ *cntr = 0; /* zero IFLG, IEN (for the interrupt mode it will be enabled in wait function) */
+
+ status = RD_STAT(i2c);
+
+ if (status == STAT_START || status == STAT_START_REPEATED) {
+ i2c->msg_state = TR_ADDR_ACK;
+
+ addr = i2c->msg->addr << 1;
+ if (i2c->msg->flags & I2C_M_RD)
+ addr |= 1;
+ if (i2c->msg->flags & I2C_M_REV_DIR_ADDR)
+ addr ^= 1; /* invert RW bit if it's requested */
+
+ WR_DATA(i2c, addr); /* write address and read/write bit */
+ } else {
+ dev_printk(KERN_DEBUG, i2c->dev, "%s: unexpected state (%#x) on start phase, %s\n",
+ __FUNCTION__, status, i2c->msg_retries > 1 ? "retrying":"aborting");
+
+ if (--i2c->msg_retries < 0)
+ comcerto_i2c_message_complete(i2c, -1);
+ else
+ comcerto_i2c_state_idle(i2c, cntr);
+ }
+}
+
+static void comcerto_i2c_rx(struct ls1024a_i2c_dev *i2c)
+{
+ u8 status, cntr = 0;
+
+restart:
+ switch (i2c->msg_state) {
+ case TR_IDLE:
+ comcerto_i2c_state_idle(i2c, &cntr);
+ if (unlikely(i2c->msg->flags & I2C_M_NOSTART))
+ goto restart; /* needed to avoid event loss in interrupt mode */
+ break;
+
+ case TR_START_ACK:
+ comcerto_i2c_state_start_ack(i2c, &cntr);
+ break;
+
+ case TR_ADDR_ACK:
+ if (unlikely(i2c->msg->flags & I2C_M_NOSTART)) {
+ /* we can enter this state if skip start/addr flag is set, so fake good ack */
+ status = STAT_ADDR_RD_ACK;
+ }
+ else {
+ status = RD_STAT(i2c);
+ /* check whether we should ignore NACK */
+ if (status == STAT_DATA_RD_NACK && (i2c->msg->flags & I2C_M_IGNORE_NAK))
+ status = STAT_DATA_RD_ACK;
+ }
+
+ if (likely(status == STAT_ADDR_RD_ACK)) {
+ /* start reception phase - wait until data is ready and loop in RX_DATA_ACK state
+ * until we read all the data, sending ACK after each byte (but the last)
+ */
+ i2c->msg_len = 0;
+ if (i2c->msg->len > 1) {
+ i2c->msg_state = TR_DATA_ACK;
+ cntr = CNTR_AAK;
+ }
+ else if (i2c->msg->len == 1) {
+ i2c->msg_state = RX_DATA_NACK;
+ }
+ else { /* nothing to receive, send STOP and signal success */
+ comcerto_i2c_message_complete(i2c, 0);
+ }
+ }
+ else {
+ dev_printk(KERN_DEBUG, i2c->dev, "%s: unexpected state (%#x) on address phase, %s\n",
+ __FUNCTION__, status, i2c->msg_retries > 1 ? "retrying":"aborting");
+
+ if (--i2c->msg_retries < 0)
+ comcerto_i2c_message_complete(i2c, -1);
+ else
+ comcerto_i2c_state_idle(i2c, &cntr);
+ }
+ break;
+
+ case TR_DATA_ACK:
+ status = RD_STAT(i2c);
+
+ if (likely(status == STAT_DATA_RD_ACK)) {
+ i2c->msg->buf[i2c->msg_len++] = RD_DATA(i2c);
+ if (likely(i2c->msg->len - i2c->msg_len > 1)) {
+ cntr = CNTR_AAK;
+ }
+ else {
+ i2c->msg_state = RX_DATA_NACK;
+ /* NACK should be transmitted on the last byte */
+ }
+ }
+ else {
+ dev_printk(KERN_DEBUG, i2c->dev, "%s: unexpected state (%#x) on read phase\n", __FUNCTION__, status);
+ comcerto_i2c_message_complete(i2c, -1);
+ }
+ break;
+
+ case RX_DATA_NACK:
+ status = RD_STAT(i2c);
+ if (likely(status == STAT_DATA_RD_NACK)) {
+ i2c->msg->buf[i2c->msg_len++] = RD_DATA(i2c);
+ comcerto_i2c_message_complete(i2c, 0);
+ }
+ else {
+ dev_printk(KERN_DEBUG, i2c->dev, "%s: unexpected state (%#x) on finishing read phase\n", __FUNCTION__, status);
+ comcerto_i2c_message_complete(i2c, -1);
+ }
+ }
+
+ /* no wait if we completed message */
+ if (comcerto_i2c_message_in_progress(i2c))
+ comcerto_i2c_wait(i2c, cntr);
+}
+
+static void comcerto_i2c_tx(struct ls1024a_i2c_dev *i2c)
+{
+ u8 status, cntr = 0;
+
+restart:
+ switch (i2c->msg_state) {
+ case TR_IDLE:
+ comcerto_i2c_state_idle(i2c, &cntr);
+ if (unlikely(i2c->msg->flags & I2C_M_NOSTART))
+ goto restart; /* needed to avoid event loss in interrupt mode */
+ break;
+
+ case TR_START_ACK:
+ comcerto_i2c_state_start_ack(i2c, &cntr);
+ break;
+
+ case TR_ADDR_ACK:
+ if (unlikely(i2c->msg->flags & I2C_M_NOSTART)) {
+ /* we can enter this state if skip start/addr flag is set, so fake good ack */
+ status = STAT_ADDR_WR_ACK;
+ }
+ else {
+ status = RD_STAT(i2c);
+ if (status == STAT_DATA_WR_NACK && (i2c->msg->flags & I2C_M_IGNORE_NAK))
+ status = STAT_DATA_WR_ACK;
+ }
+
+ if (likely(status == STAT_ADDR_WR_ACK)) {
+ /* start reception phase - wait until data is ready and loop in TX_DATA_ACK state
+ * until we read all the data, sending ACK after each byte (but the last)
+ */
+ i2c->msg_state = TR_DATA_ACK;
+ i2c->msg_len = 0;
+ if (likely(i2c->msg->len != 0)) {
+ WR_DATA(i2c, i2c->msg->buf[i2c->msg_len++]);
+ //printk("comcerto_i2c_tx: i2c->msg->buf[i2c->msg_len - 1]=%d\n", i2c->msg->buf[i2c->msg_len - 1]);
+ }
+ else {
+ /* nothing to transmit, send STOP and signal success */
+ comcerto_i2c_message_complete(i2c, 0);
+ }
+ }
+ else {
+ dev_printk(KERN_DEBUG, i2c->dev, "%s: unexpected state (%#x) on address phase, %s\n",
+ __FUNCTION__, status, i2c->msg_retries > 1 ? "retrying":"aborting");
+
+ if (--i2c->msg_retries < 0)
+ comcerto_i2c_message_complete(i2c, -1);
+ else
+ comcerto_i2c_state_idle(i2c, &cntr);
+ }
+ break;
+
+ case TR_DATA_ACK:
+ status = RD_STAT(i2c);
+ if (status == STAT_DATA_WR_NACK && (i2c->msg->flags & I2C_M_IGNORE_NAK))
+ status = STAT_DATA_WR_ACK;
+
+ if (likely(status == STAT_DATA_WR_ACK)) {
+ if (i2c->msg->len > i2c->msg_len)
+ WR_DATA(i2c, i2c->msg->buf[i2c->msg_len++]);
+ else
+ comcerto_i2c_message_complete(i2c, 0);
+ }
+ else {
+ dev_printk(KERN_DEBUG, i2c->dev, "%s: unexpected state (%#x) on read data phase\n", __FUNCTION__, status);
+ comcerto_i2c_message_complete(i2c, -1);
+ }
+ break;
+ }
+
+ if (comcerto_i2c_message_in_progress(i2c))
+ comcerto_i2c_wait(i2c, cntr);
+}
+
+static irqreturn_t comcerto_i2c_interrupt(int irq, void *dev_id)
+{
+ struct ls1024a_i2c_dev *i2c = dev_id;
+
+ if (!(RD_CNTR(i2c) & CNTR_IFLG))
+ goto none;
+
+ /* IRQ enable/disable logic is hidden in state handlers, all we need is to wake
+ * process when message completed.
+ */
+ if (i2c->msg->flags & I2C_M_RD)
+ comcerto_i2c_rx(i2c);
+ else
+ comcerto_i2c_tx(i2c);
+
+ if (!comcerto_i2c_message_in_progress(i2c)) {
+ WR_CNTR(i2c, RD_CNTR(i2c) & ~CNTR_IEN); /* disable interrupt unconditionally */
+ wake_up(&i2c->wait);
+ }
+
+ return IRQ_HANDLED;
+none:
+ return IRQ_NONE;
+}
+
+static void comcerto_i2c_message_process(struct ls1024a_i2c_dev *i2c, struct i2c_msg *msg)
+{
+ i2c->msg = msg;
+ i2c->msg_state = TR_IDLE;
+ i2c->msg_status = 1;
+ i2c->msg_retries = i2c->adapter.retries;
+
+polling_mode:
+ if (msg->flags & I2C_M_RD)
+ comcerto_i2c_rx(i2c);
+ else
+ comcerto_i2c_tx(i2c);
+
+ if (i2c->irq < 0) {
+ /*if (i2c->msg != NULL)*/
+ goto polling_mode;
+ }
+ else {
+ int timeout, res;
+ ulong flags;
+
+ timeout = comcerto_i2c_calculate_timeout(i2c, msg);
+
+ res = wait_event_timeout(i2c->wait, i2c->msg_status <= 0, timeout);
+
+ local_irq_save(flags);
+
+ /* check if we timed out and set respective error codes */
+ if (res == 0) {
+ if (comcerto_i2c_message_in_progress(i2c)) {
+ dev_printk(KERN_DEBUG, i2c->dev, "%s: interrupt transfer timeout\n", __FUNCTION__);
+ comcerto_i2c_message_complete(i2c, -ETIME);
+ comcerto_i2c_reset(i2c);
+ }
+ }
+
+ local_irq_restore(flags);
+ }
+}
+
+/*
+ * Generic master transfer entrypoint.
+ * Returns the number of processed messages or error value
+ */
+static int comcerto_i2c_master_xfer(struct i2c_adapter *adapter, struct i2c_msg msgs[], int num)
+{
+ struct ls1024a_i2c_dev *i2c = i2c_get_adapdata(adapter);
+ int i;
+
+ dev_dbg(i2c->dev, "%s: %d messages to process\n", __FUNCTION__, num);
+
+ for (i = 0; i < num; i++) {
+ dev_dbg(i2c->dev, "%s: message #%d: addr=%#x, flags=%#x, len=%u\n", __FUNCTION__,
+ i, msgs[i].addr, msgs[i].flags, msgs[i].len);
+
+ comcerto_i2c_message_process(i2c, &msgs[i]);
+
+ if (i2c->msg_status < 0) {
+ dev_printk(KERN_DEBUG, i2c->dev, "%s: transfer failed on message #%d (addr=%#x, flags=%#x, len=%u)\n",
+ __FUNCTION__, i, msgs[i].addr, msgs[i].flags, msgs[i].len);
+ break;
+ }
+ }
+
+ if (i2c->msg_status == -1)
+ i2c->msg_status = -EIO;
+
+ if (i2c->msg_status == 0)
+ i2c->msg_status = num;
+
+ return i2c->msg_status;
+}
+
+
+static u32 comcerto_i2c_functionality(struct i2c_adapter *adap)
+{
+ return (I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL);
+}
+
+static struct i2c_algorithm ls1024a_i2c_algo = {
+ .master_xfer = comcerto_i2c_master_xfer,
+ .functionality = comcerto_i2c_functionality,
+};
+
+static int ls1024a_i2c_probe(struct platform_device *pdev)
+{
+ struct ls1024a_i2c_dev *priv;
+ struct resource *res;
+ int err = 0;
+
+ priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ priv->membase = devm_ioremap_resource(&pdev->dev, res);
+ if (IS_ERR(priv->membase))
+ return PTR_ERR(priv->membase);
+
+ priv->clk = devm_clk_get(&pdev->dev, NULL);
+ if (IS_ERR(priv->clk))
+ return PTR_ERR(priv->clk);
+
+ clk_prepare_enable(priv->clk);
+
+ priv->irq = platform_get_irq(pdev, 0);
+ if (priv->irq <= 0) {
+ dev_err(&pdev->dev, "invalid irq\n");
+ return priv->irq;
+ }
+
+ err = devm_request_irq(&pdev->dev, priv->irq, comcerto_i2c_interrupt, 0,
+ pdev->name, priv);
+ if (err) {
+ dev_err(&pdev->dev, "IRQ request failed\n");
+ return err;
+ }
+
+ init_waitqueue_head(&priv->wait);
+ priv->adapter.dev.parent = &pdev->dev;
+ priv->adapter.algo = &ls1024a_i2c_algo;
+ priv->adapter.dev.of_node = pdev->dev.of_node;
+ priv->dev = &pdev->dev;
+
+ snprintf(priv->adapter.name, sizeof(priv->adapter.name), "ls1024a-i2c");
+ i2c_set_adapdata(&priv->adapter, priv);
+
+ comcerto_i2c_reset(priv);
+
+ err = i2c_add_adapter(&priv->adapter);
+ if (err) {
+ dev_err(&pdev->dev, "failed to add I2C adapter\n");
+ return err;
+ }
+
+ platform_set_drvdata(pdev, priv);
+ dev_dbg(&pdev->dev, "I2C bus:%d added\n", priv->adapter.nr);
+
+ return 0;
+}
+
+static int ls1024a_i2c_remove(struct platform_device *pdev)
+{
+ struct ls1024a_i2c_dev *priv;
+
+ priv = platform_get_drvdata(pdev);
+ synchronize_irq(priv->irq);
+ i2c_del_adapter(&priv->adapter);
+
+ return 0;
+}
+
+static const struct of_device_id ls1024a_i2c_of_match[] = {
+ { .compatible = "fsl,ls1024a-i2c", },
+ { /* sentinel */ },
+};
+
+static struct platform_driver ls1024a_i2c_driver = {
+ .probe = ls1024a_i2c_probe,
+ .remove = ls1024a_i2c_remove,
+ .driver = {
+ .name = "ls1024a-i2c",
+ .of_match_table = ls1024a_i2c_of_match,
+ },
+};
+
+module_platform_driver(ls1024a_i2c_driver);
+
+MODULE_DESCRIPTION("Freescale LS1024A I2C Bus Controller Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/i2c/i2c-mux.c b/drivers/i2c/i2c-mux.c
index 2ba7c0f..8fdef6a 100644
--- a/drivers/i2c/i2c-mux.c
+++ b/drivers/i2c/i2c-mux.c
@@ -37,6 +37,7 @@
u32 chan_id;
int (*select)(struct i2c_adapter *, void *mux_priv, u32 chan_id);
+ int (*select_num)(struct i2c_adapter *, void *mux_priv, u32 chan_id, int num);
int (*deselect)(struct i2c_adapter *, void *mux_priv, u32 chan_id);
};
@@ -49,7 +50,12 @@
/* Switch to the right mux port and perform the transfer. */
- ret = priv->select(parent, priv->mux_priv, priv->chan_id);
+ if (priv->select_num)
+ ret = priv->select_num(parent, priv->mux_priv, priv->chan_id,
+ num);
+ else
+ ret = priv->select(parent, priv->mux_priv, priv->chan_id);
+
if (ret >= 0)
ret = __i2c_transfer(parent, msgs, num);
if (priv->deselect)
@@ -69,7 +75,12 @@
/* Select the right mux port and perform the transfer. */
- ret = priv->select(parent, priv->mux_priv, priv->chan_id);
+ if (priv->select_num)
+ ret = priv->select_num(parent, priv->mux_priv,
+ priv->chan_id, read_write? 2 : 1);
+ else
+ ret = priv->select(parent, priv->mux_priv, priv->chan_id);
+
if (ret >= 0)
ret = parent->algo->smbus_xfer(parent, addr, flags,
read_write, command, size, data);
@@ -101,12 +112,14 @@
return class;
}
-struct i2c_adapter *i2c_add_mux_adapter(struct i2c_adapter *parent,
+static struct i2c_adapter *__i2c_add_mux_adapter(struct i2c_adapter *parent,
struct device *mux_dev,
void *mux_priv, u32 force_nr, u32 chan_id,
unsigned int class,
int (*select) (struct i2c_adapter *,
void *, u32),
+ int (*select_num) (struct i2c_adapter *,
+ void *, u32, int),
int (*deselect) (struct i2c_adapter *,
void *, u32))
{
@@ -124,6 +137,7 @@
priv->mux_priv = mux_priv;
priv->chan_id = chan_id;
priv->select = select;
+ priv->select_num = select_num;
priv->deselect = deselect;
/* Need to do algo dynamically because we don't know ahead
@@ -198,8 +212,35 @@
return &priv->adap;
}
+
+struct i2c_adapter *i2c_add_mux_adapter(struct i2c_adapter *parent,
+ struct device *mux_dev,
+ void *mux_priv, u32 force_nr, u32 chan_id,
+ unsigned int class,
+ int (*select) (struct i2c_adapter *,
+ void *, u32),
+ int (*deselect) (struct i2c_adapter *,
+ void *, u32))
+{
+ return __i2c_add_mux_adapter(parent, mux_dev, mux_priv, force_nr,
+ chan_id, class, select, NULL, deselect);
+}
EXPORT_SYMBOL_GPL(i2c_add_mux_adapter);
+struct i2c_adapter *i2c_add_mux_adapter_num(struct i2c_adapter *parent,
+ struct device *mux_dev,
+ void *mux_priv, u32 force_nr, u32 chan_id,
+ unsigned int class,
+ int (*select_num) (struct i2c_adapter *,
+ void *, u32, int),
+ int (*deselect) (struct i2c_adapter *,
+ void *, u32))
+{
+ return __i2c_add_mux_adapter(parent, mux_dev, mux_priv, force_nr,
+ chan_id, class, NULL, select_num, deselect);
+}
+EXPORT_SYMBOL_GPL(i2c_add_mux_adapter_num);
+
void i2c_del_mux_adapter(struct i2c_adapter *adap)
{
struct i2c_mux_priv *priv = adap->algo_data;
diff --git a/drivers/leds/led-triggers.c b/drivers/leds/led-triggers.c
index e8b1120..9e49f2e 100644
--- a/drivers/leds/led-triggers.c
+++ b/drivers/leds/led-triggers.c
@@ -115,8 +115,10 @@
char *envp[2];
const char *name;
- name = trig ? trig->name : "none";
- event = kasprintf(GFP_KERNEL, "TRIGGER=%s", name);
+ if (trig != led_cdev->trigger) {
+ name = trig ? trig->name : "none";
+ event = kasprintf(GFP_KERNEL, "TRIGGER=%s", name);
+ }
/* Remove any existing trigger */
if (led_cdev->trigger) {
diff --git a/drivers/media/dvb-core/dvb-usb-ids.h b/drivers/media/dvb-core/dvb-usb-ids.h
index c117fb3..ab57020 100644
--- a/drivers/media/dvb-core/dvb-usb-ids.h
+++ b/drivers/media/dvb-core/dvb-usb-ids.h
@@ -388,4 +388,6 @@
#define USB_PID_PCTV_2002E_SE 0x025d
#define USB_PID_SVEON_STV27 0xd3af
#define USB_PID_TURBOX_DTT_2000 0xd3a4
+#define USB_PID_SC100_COLD 0x8613
+#define USB_PID_SC100_WARM 0x1003
#endif
diff --git a/drivers/media/dvb-core/dvb_net.c b/drivers/media/dvb-core/dvb_net.c
index a694fb1..69f7796 100644
--- a/drivers/media/dvb-core/dvb_net.c
+++ b/drivers/media/dvb-core/dvb_net.c
@@ -344,7 +344,7 @@
/* Check TS error conditions: sync_byte, transport_error_indicator, scrambling_control . */
if ((ts[0] != TS_SYNC) || (ts[1] & TS_TEI) || ((ts[3] & TS_SC) != 0)) {
- printk(KERN_WARNING "%lu: Invalid TS cell: SYNC %#x, TEI %u, SC %#x.\n",
+ printk_ratelimited(KERN_WARNING "%lu: Invalid TS cell: SYNC %#x, TEI %u, SC %#x.\n",
priv->ts_count, ts[0],
(ts[1] & TS_TEI) >> 7,
(ts[3] & TS_SC) >> 6);
@@ -376,7 +376,7 @@
priv->tscc = ts[3] & 0x0F;
/* There is a pointer field here. */
if (ts[4] > ts_remain) {
- printk(KERN_ERR "%lu: Invalid ULE packet "
+ printk_ratelimited(KERN_ERR "%lu: Invalid ULE packet "
"(pointer field %d)\n", priv->ts_count, ts[4]);
ts += TS_SZ;
priv->ts_count++;
@@ -400,7 +400,7 @@
priv->tscc = (priv->tscc + 1) & 0x0F;
else {
/* TS discontinuity handling: */
- printk(KERN_WARNING "%lu: TS discontinuity: got %#x, "
+ printk_ratelimited(KERN_WARNING "%lu: TS discontinuity: got %#x, "
"expected %#x.\n", priv->ts_count, ts[3] & 0x0F, priv->tscc);
/* Drop partly decoded SNDU, reset state, resync on PUSI. */
if (priv->ule_skb) {
@@ -423,7 +423,7 @@
if (! priv->need_pusi) {
if (!(*from_where < (ts_remain-1)) || *from_where != priv->ule_sndu_remain) {
/* Pointer field is invalid. Drop this TS cell and any started ULE SNDU. */
- printk(KERN_WARNING "%lu: Invalid pointer "
+ printk_ratelimited(KERN_WARNING "%lu: Invalid pointer "
"field: %u.\n", priv->ts_count, *from_where);
/* Drop partly decoded SNDU, reset state, resync on PUSI. */
@@ -454,7 +454,7 @@
* current TS cell. */
dev->stats.rx_errors++;
dev->stats.rx_length_errors++;
- printk(KERN_WARNING "%lu: Expected %d more SNDU bytes, but "
+ printk_ratelimited(KERN_WARNING "%lu: Expected %d more SNDU bytes, but "
"got PUSI (pf %d, ts_remain %d). Flushing incomplete payload.\n",
priv->ts_count, priv->ule_sndu_remain, ts[4], ts_remain);
dev_kfree_skb(priv->ule_skb);
@@ -475,7 +475,7 @@
* TS.
* Check ts_remain has to be >= 2 here. */
if (ts_remain < 2) {
- printk(KERN_WARNING "Invalid payload packing: only %d "
+ printk_ratelimited(KERN_WARNING "Invalid payload packing: only %d "
"bytes left in TS. Resyncing.\n", ts_remain);
priv->ule_sndu_len = 0;
priv->need_pusi = 1;
@@ -494,7 +494,7 @@
priv->ule_dbit = 0;
if (priv->ule_sndu_len < 5) {
- printk(KERN_WARNING "%lu: Invalid ULE SNDU length %u. "
+ printk_ratelimited(KERN_WARNING "%lu: Invalid ULE SNDU length %u. "
"Resyncing.\n", priv->ts_count, priv->ule_sndu_len);
dev->stats.rx_errors++;
dev->stats.rx_length_errors++;
@@ -550,7 +550,7 @@
* prepare for the largest case: bridged SNDU with MAC address (dbit = 0). */
priv->ule_skb = dev_alloc_skb( priv->ule_sndu_len + ETH_HLEN + ETH_ALEN );
if (priv->ule_skb == NULL) {
- printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n",
+ printk_ratelimited(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n",
dev->name);
dev->stats.rx_dropped++;
return;
@@ -595,7 +595,7 @@
*(tail - 2) << 8 |
*(tail - 1);
if (ule_crc != expected_crc) {
- printk(KERN_WARNING "%lu: CRC32 check FAILED: %08x / %08x, SNDU len %d type %#x, ts_remain %d, next 2: %x.\n",
+ printk_ratelimited(KERN_WARNING "%lu: CRC32 check FAILED: %08x / %08x, SNDU len %d type %#x, ts_remain %d, next 2: %x.\n",
priv->ts_count, ule_crc, expected_crc, priv->ule_sndu_len, priv->ule_sndu_type, ts_remain, ts_remain > 2 ? *(unsigned short *)from_where : 0);
#ifdef ULE_DEBUG
diff --git a/drivers/media/dvb-frontends/Kconfig b/drivers/media/dvb-frontends/Kconfig
index 97c151d..4b15378 100644
--- a/drivers/media/dvb-frontends/Kconfig
+++ b/drivers/media/dvb-frontends/Kconfig
@@ -42,6 +42,13 @@
help
Say Y when you want to support this frontend.
+config DVB_M88DS3103_M88RS6000_FIRMWARE
+ string "M88RS6000 firmware"
+ depends on DVB_M88DS3103
+ default "dvb-demod-m88rs6000.fw"
+ help
+ Name of the M88RS6000 firmware file.
+
comment "Multistandard (cable + terrestrial) frontends"
depends on DVB_CORE
diff --git a/drivers/media/dvb-frontends/m88ds3103.c b/drivers/media/dvb-frontends/m88ds3103.c
index d3d928e..070c941 100644
--- a/drivers/media/dvb-frontends/m88ds3103.c
+++ b/drivers/media/dvb-frontends/m88ds3103.c
@@ -16,6 +16,8 @@
#include "m88ds3103_priv.h"
+#define TS_PACKET_SIZE 188
+
static struct dvb_frontend_ops m88ds3103_ops;
/* write multiple registers */
@@ -991,6 +993,9 @@
int ret;
unsigned int utmp;
u8 buf[3], u8tmp;
+ u32 err_count;
+ u64 u64tmp;
+ uint32_t bch_payload, ts_packets;
dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
@@ -1011,27 +1016,74 @@
if (ret)
goto err;
- priv->ber = (buf[1] << 8) | (buf[0] << 0);
+ err_count = (buf[1] << 8) | (buf[0] << 0);
+ if (u8tmp & 0x08) {
+ /* counter represents byte errors */
+ err_count *= 8;
+ }
/* restart counters */
ret = m88ds3103_wr_reg(priv, 0xf8, u8tmp);
if (ret)
goto err;
+
+ u64tmp = 1000000000ULL * err_count;
+ /* counter / total number of bits */
+ do_div(u64tmp, 0x800000);
+
+ priv->ber = (u32)u64tmp;
}
break;
case SYS_DVBS2:
+ /* DVB-S2 uses the FER (Frame Error Rate) as approximate BER */
+
+ switch (c->fec_inner) {
+ /* THe FEC coding equation:
+ * FEC length (64800b) * (LDPC ratio)
+ * = K(LDPC)
+ * = K(BCH) + T(BCH) * 16
+ * = BB Header (80b) + data + padding + T(BCH) * 16
+ * FEC Frame - LDPC - K(BCH) - K(LDPC) - T(BCH)
+ * 64800 - 1/4 - 16008 - 16200 - 12
+ * 64800 - 1/3 - 21408 - 21600 - 12
+ * 64800 - 2/5 - 25728 - 25920 - 12
+ * 64800 - 1/2 - 32208 - 32400 - 12
+ * 64800 - 3/5 - 38688 - 38880 - 12
+ * 64800 - 2/3 - 43040 - 43200 - 10
+ * 64800 - 3/4 - 48408 - 48600 - 12
+ * 64800 - 4/5 - 51648 - 51840 - 12
+ * 64800 - 5/6 - 53840 - 54000 - 10
+ * 64800 - 8/9 - 57472 - 57600 - 8
+ * 64800 - 9/10 - 58192 - 58320 - 8
+ */
+ case FEC_1_2: bch_payload = 32128; break;
+ case FEC_3_5: bch_payload = 38608; break;
+ case FEC_2_3: bch_payload = 42960; break;
+ case FEC_3_4: bch_payload = 48328; break;
+ case FEC_4_5: bch_payload = 51568; break;
+ case FEC_5_6: bch_payload = 53760; break;
+ case FEC_8_9: bch_payload = 57392; break;
+ case FEC_9_10: bch_payload = 58112; break;
+ /* FEC_1_4 is not supported in this kernel */
+ /* FEC_1_3 is not supported in this kernel */
+ /* FEC_2_5 is not supported in this kernel */
+ default: return -EINVAL;
+ }
+
+ /* determine number of LDPC frames */
ret = m88ds3103_rd_regs(priv, 0xd5, buf, 3);
if (ret)
goto err;
-
utmp = (buf[2] << 16) | (buf[1] << 8) | (buf[0] << 0);
if (utmp > 3000) {
+ ts_packets = bch_payload * utmp / (TS_PACKET_SIZE * 8);
+
+ /* get UPL (User Package Length) CRC error counter */
ret = m88ds3103_rd_regs(priv, 0xf7, buf, 2);
if (ret)
goto err;
-
- priv->ber = (buf[1] << 8) | (buf[0] << 0);
+ err_count = (buf[1] << 8) | (buf[0] << 0);
/* restart counters */
ret = m88ds3103_wr_reg(priv, 0xd1, 0x01);
@@ -1049,6 +1101,10 @@
ret = m88ds3103_wr_reg(priv, 0xd1, 0x00);
if (ret)
goto err;
+
+ u64tmp = 1000000000ULL * err_count;
+ do_div(u64tmp, ts_packets);
+ priv->ber = (u32)u64tmp;
}
break;
default:
@@ -1066,6 +1122,76 @@
return ret;
}
+static int m88ds3103_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
+{
+ struct m88ds3103_priv *priv = fe->demodulator_priv;
+ struct dtv_frontend_properties *c = &fe->dtv_property_cache;
+ int ret;
+ u8 buf[3], u8tmp;
+
+ switch (c->delivery_system) {
+ case SYS_DVBS:
+ /* hold packet counter */
+ ret = m88ds3103_rd_reg(priv, 0xf8, &u8tmp);
+ if (ret)
+ goto err;
+ u8tmp |= 0x40;
+ ret = m88ds3103_wr_reg(priv, 0xf8, u8tmp);
+ if (ret)
+ goto err;
+
+ ret = m88ds3103_rd_regs(priv, 0xf4, buf, 2);
+ if (ret)
+ goto err;
+ *ucblocks = (buf[1] << 8) | (buf[0] << 0);
+
+ /* clear packet counter */
+ u8tmp &= ~0x20;
+ ret = m88ds3103_wr_reg(priv, 0xf8, u8tmp);
+ if (ret)
+ goto err;
+ u8tmp |= 0x20;
+
+ /* re-enable packet counter update */
+ u8tmp &= ~0x40;
+ ret = m88ds3103_wr_reg(priv, 0xf8, u8tmp);
+ if (ret)
+ goto err;
+
+ break;
+ case SYS_DVBS2:
+ ret = m88ds3103_rd_regs(priv, 0xd8, buf, 3);
+ if (ret)
+ goto err;
+ *ucblocks = (buf[2] << 16) | (buf[1] << 8) | (buf[0] << 0);
+
+ /* clear LDPC counter */
+ ret = m88ds3103_rd_reg(priv, 0xd1, &u8tmp);
+ if (ret)
+ goto err;
+
+ u8tmp |= 0x01;
+ ret = m88ds3103_wr_reg(priv, 0xd1, u8tmp);
+ if (ret)
+ goto err;
+
+ u8tmp &= ~0x01;
+ ret = m88ds3103_wr_reg(priv, 0xd1, u8tmp);
+ if (ret)
+ goto err;
+
+ break;
+ default:
+ break;
+ }
+
+ return 0;
+
+err:
+ dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
+ return ret;
+}
+
static int m88ds3103_set_tone(struct dvb_frontend *fe,
fe_sec_tone_mode_t fe_sec_tone_mode)
{
@@ -1320,19 +1446,24 @@
kfree(priv);
}
-static int m88ds3103_select(struct i2c_adapter *adap, void *mux_priv, u32 chan)
+static int m88ds3103_select(struct i2c_adapter *adap, void *mux_priv, u32 chan,
+ int num)
{
struct m88ds3103_priv *priv = mux_priv;
int ret;
+ u8 buf[2] = {0x03, 0x10};
struct i2c_msg gate_open_msg[1] = {
{
.addr = priv->cfg->i2c_addr,
.flags = 0,
.len = 2,
- .buf = "\x03\x11",
+ .buf = buf,
}
};
+ BUG_ON(num+0x10 > U8_MAX);
+ buf[1] += (u8)num;
+
mutex_lock(&priv->i2c_mutex);
/* open tuner I2C repeater for 1 xfer, closes automatically */
@@ -1432,7 +1563,7 @@
goto err;
/* create mux i2c adapter for tuner */
- priv->i2c_adapter = i2c_add_mux_adapter(i2c, &i2c->dev, priv, 0, 0, 0,
+ priv->i2c_adapter = i2c_add_mux_adapter_num(i2c, &i2c->dev, priv, 0, 0, 0,
m88ds3103_select, m88ds3103_deselect);
if (priv->i2c_adapter == NULL)
goto err;
@@ -1491,6 +1622,7 @@
.read_status = m88ds3103_read_status,
.read_snr = m88ds3103_read_snr,
.read_ber = m88ds3103_read_ber,
+ .read_ucblocks = m88ds3103_read_ucblocks,
.diseqc_send_master_cmd = m88ds3103_diseqc_send_master_cmd,
.diseqc_send_burst = m88ds3103_diseqc_send_burst,
diff --git a/drivers/media/dvb-frontends/m88ds3103_priv.h b/drivers/media/dvb-frontends/m88ds3103_priv.h
index a2c0958..c9a8f56 100644
--- a/drivers/media/dvb-frontends/m88ds3103_priv.h
+++ b/drivers/media/dvb-frontends/m88ds3103_priv.h
@@ -25,7 +25,7 @@
#include <linux/math64.h>
#define M88DS3103_FIRMWARE "dvb-demod-m88ds3103.fw"
-#define M88RS6000_FIRMWARE "dvb-demod-m88rs6000.fw"
+#define M88RS6000_FIRMWARE CONFIG_DVB_M88DS3103_M88RS6000_FIRMWARE
#define M88DS3103_MCLK_KHZ 96000
#define M88RS6000_CHIP_ID 0x74
#define M88DS3103_CHIP_ID 0x70
diff --git a/drivers/media/tuners/m88rs6000t.c b/drivers/media/tuners/m88rs6000t.c
index d4c13fe..5009324 100644
--- a/drivers/media/tuners/m88rs6000t.c
+++ b/drivers/media/tuners/m88rs6000t.c
@@ -494,9 +494,29 @@
static int m88rs6000t_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
{
struct m88rs6000t_dev *dev = fe->tuner_priv;
+ struct dtv_frontend_properties *c = &fe->dtv_property_cache;
+ static u32 bb_list_dBm_negated[16][16] =
+ {
+ {5000, 4999, 4397, 4044, 3795, 3601, 3442, 3309, 3193, 3090, 2999, 2916, 2840, 2771, 2706, 2647},
+ {2590, 2538, 2488, 2441, 2397, 2354, 2314, 2275, 2238, 2203, 2169, 2136, 2104, 2074, 2044, 2016},
+ {1988, 1962, 1936, 1911, 1886, 1862, 1839, 1817, 1795, 1773, 1752, 1732, 1712, 1692, 1673, 1655},
+ {1636, 1618, 1601, 1584, 1567, 1550, 1534, 1518, 1502, 1487, 1472, 1457, 1442, 1428, 1414, 1400},
+ {1386, 1373, 1360, 1347, 1334, 1321, 1309, 1296, 1284, 1272, 1260, 1249, 1237, 1226, 1215, 1203},
+ {1193, 1182, 1171, 1161, 1150, 1140, 1130, 1120, 1110, 1100, 1090, 1081, 1071, 1062, 1052, 1043},
+ {1034, 1025, 1016, 1007, 999, 990, 982, 973, 965, 956, 948, 940, 932, 924, 916, 908},
+ { 900, 893, 885, 877, 870, 862, 855, 848, 840, 833, 826, 819, 812, 805, 798, 791},
+ { 784, 778, 771, 764, 758, 751, 745, 738, 732, 725, 719, 713, 706, 700, 694, 688},
+ { 682, 676, 670, 664, 658, 652, 647, 641, 635, 629, 624, 618, 612, 607, 601, 596},
+ { 590, 585, 580, 574, 569, 564, 558, 553, 548, 543, 538, 533, 528, 523, 518, 513},
+ { 508, 503, 498, 493, 488, 483, 479, 474, 469, 464, 460, 455, 450, 446, 441, 437},
+ { 432, 428, 423, 419, 414, 410, 405, 401, 397, 392, 388, 384, 379, 375, 371, 367},
+ { 363, 358, 354, 350, 346, 342, 338, 334, 330, 326, 322, 318, 314, 310, 306, 302},
+ { 298, 294, 290, 287, 283, 279, 275, 271, 268, 264, 260, 257, 253, 249, 246, 242},
+ { 238, 235, 231, 227, 224, 220, 217, 213, 210, 206, 203, 199, 196, 192, 189, 186}
+ };
+
unsigned int val, i;
int ret;
- u16 gain;
u32 PGA2_cri_GS = 46, PGA2_crf_GS = 290, TIA_GS = 290;
u32 RF_GC = 1200, IF_GC = 1100, BB_GC = 300;
u32 PGA2_GC = 300, TIA_GC = 300, PGA2_cri = 0, PGA2_crf = 0;
@@ -507,16 +527,25 @@
295, 285, 290, 295, 295, 310};
u32 BBGS[14] = {0, 286, 275, 290, 294, 300, 290,
290, 285, 283, 260, 295, 290, 260};
+ u32 bb_power, total_gain, delta, freq_mhz;
ret = regmap_read(dev->regmap, 0x5A, &val);
if (ret)
goto err;
RF_GC = val & 0x0f;
+ if (RF_GC >= ARRAY_SIZE(RFGS)) {
+ dev_err(&dev->client->dev, "Invalid, RFGC=%d\n", RF_GC);
+ return -EINVAL;
+ }
ret = regmap_read(dev->regmap, 0x5F, &val);
if (ret)
goto err;
IF_GC = val & 0x0f;
+ if (IF_GC >= ARRAY_SIZE(IFGS)) {
+ dev_err(&dev->client->dev, "Invalid, IFGC=%d\n", IF_GC);
+ return -EINVAL;
+ }
ret = regmap_read(dev->regmap, 0x3F, &val);
if (ret)
@@ -527,6 +556,10 @@
if (ret)
goto err;
BB_GC = (val >> 4) & 0x0f;
+ if (BB_GC >= ARRAY_SIZE(BBGS)) {
+ dev_err(&dev->client->dev, "Invalid, BBGC=%d\n", __func__, BB_GC);
+ return -EINVAL;
+ }
ret = regmap_read(dev->regmap, 0x76, &val);
if (ret)
@@ -557,11 +590,25 @@
PGA2G = PGA2_cri * PGA2_cri_GS + PGA2_crf * PGA2_crf_GS;
- gain = RFG + IFG - TIAG + BBG + PGA2G;
+ total_gain = RFG + IFG - TIAG + BBG + PGA2G;
- /* scale value to 0x0000-0xffff */
- gain = clamp_val(gain, 1000U, 10500U);
- *strength = (10500 - gain) * 0xffff / (10500 - 1000);
+ ret = regmap_read(dev->regmap, 0x96, &val);
+ if (ret)
+ goto err;
+ bb_power = bb_list_dBm_negated[(val >> 4) & 0x0f][val & 0x0f];
+
+ freq_mhz = (c->frequency + 500) / 1000;
+ if (freq_mhz > 1750) {
+ delta = 14;
+ } else if (freq_mhz > 1350) {
+ delta = 12;
+ } else {
+ delta = 13;
+ }
+
+ val = (total_gain + bb_power) / 100;
+ *strength = val < delta ? 0 : val - delta;
+
err:
if (ret)
dev_dbg(&dev->client->dev, "failed=%d\n", ret);
diff --git a/drivers/media/usb/dvb-usb-v2/Kconfig b/drivers/media/usb/dvb-usb-v2/Kconfig
index 9facc92..ed37337 100644
--- a/drivers/media/usb/dvb-usb-v2/Kconfig
+++ b/drivers/media/usb/dvb-usb-v2/Kconfig
@@ -151,3 +151,12 @@
select DVB_SP2 if MEDIA_SUBDRV_AUTOSELECT
help
Say Y here to support the USB receivers from DVBSky.
+
+config DVB_USB_SC100
+ tristate "Google SC100 DVB-S USB2.0 support"
+ depends on DVB_USB_V2
+ select DVB_M88DS3103
+ select MEDIA_TUNER_M88RS6000T
+ select CYPRESS_FIRMWARE
+ help
+ Say Y here to support the Google SC-100 DVB-S USB2.0 receiver.
diff --git a/drivers/media/usb/dvb-usb-v2/Makefile b/drivers/media/usb/dvb-usb-v2/Makefile
index f10d4df..98a8fa3 100644
--- a/drivers/media/usb/dvb-usb-v2/Makefile
+++ b/drivers/media/usb/dvb-usb-v2/Makefile
@@ -40,6 +40,9 @@
dvb-usb-dvbsky-objs := dvbsky.o
obj-$(CONFIG_DVB_USB_DVBSKY) += dvb-usb-dvbsky.o
+dvb-usb-sc100-objs := sc100.o
+obj-$(CONFIG_DVB_USB_SC100) += dvb-usb-sc100.o
+
ccflags-y += -I$(srctree)/drivers/media/dvb-core
ccflags-y += -I$(srctree)/drivers/media/dvb-frontends
ccflags-y += -I$(srctree)/drivers/media/tuners
diff --git a/drivers/media/usb/dvb-usb-v2/sc100.c b/drivers/media/usb/dvb-usb-v2/sc100.c
new file mode 100644
index 0000000..38884e1
--- /dev/null
+++ b/drivers/media/usb/dvb-usb-v2/sc100.c
@@ -0,0 +1,240 @@
+/*
+ * Driver for SC100 DVB-S USB2.0 receiver
+ *
+ * The hardware design is based on a Montage M88RS6000 tuner/demodulator,
+ * a Cypress CY7C68013A USB bridge and a TI TPS65233 voltage regulator.
+ * The M88RS6000 chip integrates a M88RS6000 tuner and a M88DS3103
+ * demodulator. The demodulator is directly connected to the I2C bus.
+ * The tuner is connected internally to the M88DS3103 and can be
+ * accessed through an I2C mux. The CY7C68013A USB bridge is connected
+ * to the MPEG-TS interface of the M88RS6000 and makes the data on the
+ * MPEG-TS available to the host through an USB bulk endpoint. The
+ * TPS65233 has an I2C interface, however in the sc100 design it is
+ * controlled through pins driven by the M88RS6000 chip.
+ *
+ * Copyright (C) 2015 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "dvb_usb.h"
+#include "m88ds3103.h"
+#include "m88rs6000t.h"
+#include "cypress_firmware.h"
+
+static char *mac_addr_str = "90:09:1e:f1:be:33";
+module_param_named(mac_addr, mac_addr_str, charp, 0000);
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+struct sc100_state {
+ struct mutex stream_mutex;
+ struct i2c_client *i2c_client_tuner;
+};
+
+static int sc100_read_mac_addr(struct dvb_usb_adapter *adap, u8 mac[6])
+{
+ if (!mac_pton(mac_addr_str, mac)) {
+ return -EINVAL;
+ }
+ return 0;
+}
+
+static int sc100_download_firmware(struct dvb_usb_device *d,
+ const struct firmware *fw)
+{
+ pr_debug("Loading dvb-usb-sc100 firmware\n");
+
+ return cypress_load_firmware(d->udev, fw, CYPRESS_FX2);
+}
+
+static int sc100_identify_state(struct dvb_usb_device *d, const char **name)
+{
+ if (d->udev->descriptor.idProduct == USB_PID_SC100_WARM)
+ return WARM;
+ else
+ return COLD;
+}
+
+static int sc100_stream_ctrl(struct dvb_usb_device *d, u8 onoff)
+{
+ struct sc100_state *state = d_to_priv(d);
+ int ret = 0;
+
+ mutex_lock(&state->stream_mutex);
+
+ if (onoff) {
+ /* Configure the TS parameters */
+ /* TODO: details? */
+ ret = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev, 0),
+ 0xa4, USB_TYPE_VENDOR, 0, 0, 0, 0, 5000);
+ }
+
+ mutex_unlock(&state->stream_mutex);
+
+ return ret;
+}
+
+static int sc100_streaming_ctrl(struct dvb_frontend *fe, int onoff)
+{
+ struct dvb_usb_device *d = fe_to_d(fe);
+
+ return sc100_stream_ctrl(d, (onoff == 0) ? 0 : 1);
+}
+
+static const struct m88ds3103_config sc100_m88rs6000_cfg = {
+ .i2c_addr = 0x69,
+ .clock = 27000000,
+ .i2c_wr_max = 33,
+ .ts_mode = M88DS3103_TS_CI,
+ .ts_clk = 16000,
+ .ts_clk_pol = 1,
+ .agc = 0x99,
+ .lnb_hv_pol = 0,
+ .lnb_en_pol = 1,
+};
+
+static int sc100_attach(struct dvb_usb_adapter *adap)
+{
+ struct sc100_state *state = adap_to_priv(adap);
+ struct dvb_usb_device *d = adap_to_d(adap);
+ int ret = 0;
+ struct i2c_adapter *sc100_i2c_adap = i2c_get_adapter(0);
+ /* demod I2C adapter */
+ struct i2c_adapter *i2c_adapter;
+ struct i2c_client *client_tuner;
+ struct i2c_board_info info;
+ struct m88rs6000t_config m88rs6000t_config;
+ memset(&info, 0, sizeof(struct i2c_board_info));
+
+ /* attach demod */
+ adap->fe[0] = dvb_attach(m88ds3103_attach,
+ &sc100_m88rs6000_cfg,
+ sc100_i2c_adap,
+ &i2c_adapter);
+ if (!adap->fe[0]) {
+ dev_err(&d->udev->dev, "sc100_attach fail.\n");
+ ret = -ENODEV;
+ goto fail_attach;
+ }
+
+ /* attach tuner */
+ m88rs6000t_config.fe = adap->fe[0];
+ strlcpy(info.type, "m88rs6000t", I2C_NAME_SIZE);
+ info.addr = 0x21;
+ info.platform_data = &m88rs6000t_config;
+ request_module(info.type);
+ client_tuner = i2c_new_device(i2c_adapter, &info);
+ if (client_tuner == NULL || client_tuner->dev.driver == NULL) {
+ dvb_frontend_detach(adap->fe[0]);
+ ret = -ENODEV;
+ goto fail_attach;
+ }
+ state->i2c_client_tuner = client_tuner;
+
+ if (!try_module_get(client_tuner->dev.driver->owner)) {
+ i2c_unregister_device(client_tuner);
+ dvb_frontend_detach(adap->fe[0]);
+ ret = -ENODEV;
+ goto fail_attach;
+ }
+
+ /* delegate signal strength measurement to tuner */
+ adap->fe[0]->ops.read_signal_strength =
+ adap->fe[0]->ops.tuner_ops.get_rf_strength;
+
+ return ret;
+
+fail_attach:
+ return ret;
+}
+
+static int sc100_init(struct dvb_usb_device *d)
+{
+ struct sc100_state *state = d_to_priv(d);
+
+ mutex_init(&state->stream_mutex);
+
+ return 0;
+}
+
+static void sc100_exit(struct dvb_usb_device *d)
+{
+ struct sc100_state *state = d_to_priv(d);
+ struct i2c_client *client;
+
+ client = state->i2c_client_tuner;
+ /* remove I2C tuner */
+ if (client) {
+ module_put(client->dev.driver->owner);
+ i2c_unregister_device(client);
+ }
+}
+
+static struct dvb_usb_device_properties sc100_props = {
+ .firmware = "dvb-usb-sc100.fw",
+
+ .driver_name = KBUILD_MODNAME,
+ .owner = THIS_MODULE,
+ .adapter_nr = adapter_nr,
+ .size_of_priv = sizeof(struct sc100_state),
+
+ .frontend_attach = sc100_attach,
+ .init = sc100_init,
+ .streaming_ctrl = sc100_streaming_ctrl,
+ .identify_state = sc100_identify_state,
+ .exit = sc100_exit,
+ .read_mac_address = sc100_read_mac_addr,
+ .download_firmware = sc100_download_firmware,
+
+ .num_adapters = 1,
+ .adapter = {
+ {
+ .stream = DVB_USB_STREAM_BULK(
+ 0x82, MAX_NO_URBS_FOR_DATA_STREAM, 16384),
+ }
+ }
+};
+
+static const struct usb_device_id sc100_id_table[] = {
+ { DVB_USB_DEVICE(USB_VID_CYPRESS,
+ USB_PID_SC100_COLD,
+ &sc100_props, "Google DVB-S SC100 USB2.0",
+ NULL) },
+ { DVB_USB_DEVICE(USB_VID_CYPRESS,
+ USB_PID_SC100_WARM,
+ &sc100_props, "Google DVB-S SC100 USB2.0",
+ NULL) },
+ { }
+};
+MODULE_DEVICE_TABLE(usb, sc100_id_table);
+
+static struct usb_driver sc100_usb_driver = {
+ .name = KBUILD_MODNAME,
+ .id_table = sc100_id_table,
+ .probe = dvb_usbv2_probe,
+ .disconnect = dvb_usbv2_disconnect,
+ .suspend = dvb_usbv2_suspend,
+ .resume = dvb_usbv2_resume,
+ .reset_resume = dvb_usbv2_reset_resume,
+ .no_dynamic_id = 1,
+ .soft_unbind = 1,
+};
+
+module_usb_driver(sc100_usb_driver);
+
+MODULE_AUTHOR("Matthias Kaehlcke <mka@google.com>");
+MODULE_DESCRIPTION("Driver for sc100 USB satellite receiver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index d5ad04d..8d67d7f 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -849,6 +849,16 @@
programmable memory) support. This exposes a sysfs file to read
out OTP values.
+config LS1024A_OTP
+ tristate "Freescale LS1024A On-Chip OTP Memory Support"
+ depends on ARCH_COMCERTO
+ default y
+ help
+ If you say Y here, you will get support for a proc file,
+ /proc/otp/islocked, that reports whether the LS1024A
+ One-Time Programmable (and thus the device) is locked or
+ not.
+
config AB8500_CORE
bool "ST-Ericsson AB8500 Mixed Signal Power Management chip"
depends on ABX500_CORE && MFD_DB8500_PRCMU
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 0e5cfeb..a3abfe1 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -131,6 +131,7 @@
obj-$(CONFIG_ABX500_CORE) += abx500-core.o
obj-$(CONFIG_AB3100_CORE) += ab3100-core.o
obj-$(CONFIG_AB3100_OTP) += ab3100-otp.o
+obj-$(CONFIG_LS1024A_OTP) += ls1024a-otp.o
obj-$(CONFIG_AB8500_DEBUG) += ab8500-debugfs.o
obj-$(CONFIG_AB8500_GPADC) += ab8500-gpadc.o
obj-$(CONFIG_MFD_DB8500_PRCMU) += db8500-prcmu.o
diff --git a/drivers/mfd/ls1024a-otp.c b/drivers/mfd/ls1024a-otp.c
new file mode 100644
index 0000000..c39f4d0a
--- /dev/null
+++ b/drivers/mfd/ls1024a-otp.c
@@ -0,0 +1,229 @@
+/*
+ * Freescale LS1024A OTP access
+ *
+ * (C) Copyright 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <linux/module.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+
+#define DRIVER_NAME "ls1024a-otp"
+
+#define OTP_CONFIG_LOCK_0 0x00
+#define OTP_CONFIG_LOCK_1 0x04
+#define OTP_CEB_INPUT 0x0C
+#define OTP_RSTB_INPUT 0x10
+#define OTP_ADDR_INPUT 0x14
+#define OTP_READEN_INPUT 0x18
+#define OTP_DATA_OUT_COUNTER 0x4C
+#define OTP_DATA_OUTPUT 0x50
+
+struct ls1024a_otp {
+ struct device *dev;
+ void __iomem *reg;
+ struct clk *clk;
+ spinlock_t lock;
+};
+
+/* Taken from repo://barebox/mindspeed/drivers/otp/c2k_otp.c */
+static void otp_read(struct ls1024a_otp *otp, u32 offset, u8 *read_data, int size)
+{
+ int i;
+ unsigned long flags;
+ u32 read_tmp = 0;
+ u32 dataout_counter;
+ u32 axi_clk;
+
+ if (NULL == read_data)
+ return;
+
+ if (size <= 0)
+ return;
+
+ axi_clk = clk_get_rate(otp->clk);
+ /* 70 nSec */
+ dataout_counter = ((axi_clk * 7 + 99999999) / 100000000) & 0x1FF;
+
+ spin_lock_irqsave(&otp->lock, flags);
+
+ /* configure the OTP_DATA_OUT_COUNTER for read operation.
+ 70 nsec is needed except for blank check test, in which 1.5 usec is needed.*/
+ writel(dataout_counter, otp->reg + OTP_DATA_OUT_COUNTER);
+
+ /* Unlock the write protection. */
+ writel(0xEBCF0000, otp->reg + OTP_CONFIG_LOCK_0); /* config lock0 */
+ writel(0xEBCF1111, otp->reg + OTP_CONFIG_LOCK_1); /* config lock1 */
+ writel(0x0, otp->reg + OTP_CEB_INPUT);
+
+ udelay(1);
+
+ /* rstb drive 0 */
+ writel(0x0, otp->reg + OTP_RSTB_INPUT);
+ /* Wait for at least 20nsec */
+ ndelay(20);
+ /* rstb drive 1 to have pulse */
+ writel(0x1, otp->reg + OTP_RSTB_INPUT);
+ /* Wait for at least 1usec */
+ udelay(1);
+
+ /* Write the desired address to the ADDR register */
+ writel(offset, otp->reg + OTP_ADDR_INPUT);
+ /* read_enable drive */
+ writel(0x1, otp->reg + OTP_READEN_INPUT);
+ /* Wait for at least 70nsec/1.5usec depends on operation type */
+ ndelay(70);
+
+ /* Read First Byte */
+ read_tmp = readl(otp->reg + OTP_DATA_OUTPUT);
+ *read_data = read_tmp & 0xFF;
+
+ /* For consecutive read */
+ for(i = 1 ; i < size ; i++)
+ {
+ offset = offset + 8;
+
+ /* start reading from data out register */
+ writel(offset, otp->reg + OTP_ADDR_INPUT);
+ /* Wait for at least 70nsec/1.5usec depends on operation type */
+ ndelay(70);
+
+ read_tmp = readl(otp->reg + OTP_DATA_OUTPUT);
+ *(read_data + i) = read_tmp & 0xFF;
+ }
+
+ /* reading is done make the read_enable low */
+ writel(0x0, otp->reg + OTP_READEN_INPUT);
+
+ /* lock CEB register, return to standby mode */
+ writel(0x1, otp->reg + OTP_CEB_INPUT);
+
+ spin_unlock_irqrestore(&otp->lock, flags);
+}
+
+static int islocked_proc_show(struct seq_file *m, void *v)
+{
+ struct ls1024a_otp *otp = (struct ls1024a_otp *) m->private;
+ char status_buf[1];
+
+ otp_read(otp, 8, status_buf, 1);
+
+ seq_printf(m, "%d\n", (*status_buf & 0x2) == 0x2);
+ return 0;
+}
+
+static int islocked_proc_open(struct inode *inode, struct file *filp)
+{
+ struct ls1024a_otp *otp = PDE_DATA(inode);
+ return single_open(filp, islocked_proc_show, otp);
+}
+
+static struct file_operations islocked_proc_fops = {
+ .owner = THIS_MODULE,
+ .open = islocked_proc_open,
+ .read = seq_read,
+ .llseek = seq_lseek,
+ .release = single_release,
+};
+
+static int ls1024a_otp_probe(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct resource *res;
+ struct ls1024a_otp *otp;
+ int rc;
+ struct proc_dir_entry *otp_dir;
+ struct proc_dir_entry *islocked_proc_file;
+
+ otp = devm_kzalloc(dev, sizeof(*otp), GFP_KERNEL);
+ if (!otp)
+ return -ENOMEM;
+
+ otp->dev = &pdev->dev;
+
+ platform_set_drvdata(pdev, otp);
+
+ spin_lock_init(&otp->lock);
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ otp->reg = devm_ioremap_resource(dev, res);
+ if (IS_ERR(otp->reg)) {
+ rc = PTR_ERR(otp->reg);
+ goto err1;
+ }
+
+ otp->clk = devm_clk_get(&pdev->dev, NULL);
+ if (IS_ERR(otp->clk)) {
+ rc = PTR_ERR(otp->clk);
+ goto err2;
+ }
+ rc = clk_prepare_enable(otp->clk);
+ if (rc)
+ goto err2;
+
+ otp_dir = proc_mkdir("otp", NULL);
+ if (otp_dir == NULL) {
+ dev_err(otp->dev, "Unable to create /proc/otp directory\n");
+ rc = -ENOMEM;
+ goto err3;
+ }
+
+ islocked_proc_file = proc_create_data("islocked", 0, otp_dir, &islocked_proc_fops, otp);
+ if (islocked_proc_file == NULL) {
+ dev_err(otp->dev, "Unable to create /proc/otp/islocked\n");
+ rc = -ENOMEM;
+ goto err4;
+ }
+ return 0;
+
+err4:
+ remove_proc_entry("otp", NULL);
+err3:
+ clk_disable_unprepare(otp->clk);
+err2:
+ devm_iounmap(dev, otp->reg);
+err1:
+ platform_set_drvdata(pdev, NULL);
+ devm_kfree(dev, otp);
+ return rc;
+}
+
+static const struct of_device_id ls1024a_otp_of_match[] = {
+ {
+ .compatible = "fsl,ls1024a-otp",
+ },
+ {},
+};
+MODULE_DEVICE_TABLE(of, ls1024a_otp_of_match);
+static struct platform_driver ls1024a_otp_driver = {
+ .probe = ls1024a_otp_probe,
+ .driver = {
+ .name = DRIVER_NAME,
+ .of_match_table = ls1024a_otp_of_match,
+ },
+};
+module_platform_driver(ls1024a_otp_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Stephen McGruer <smcgruer@google.com>");
+MODULE_DESCRIPTION("LS1024A OTP driver");
diff --git a/drivers/mtd/chips/cfi_cmdset_0002.c b/drivers/mtd/chips/cfi_cmdset_0002.c
index c50d8cf..7aa8442 100644
--- a/drivers/mtd/chips/cfi_cmdset_0002.c
+++ b/drivers/mtd/chips/cfi_cmdset_0002.c
@@ -809,7 +809,9 @@
return 0;
case FL_ERASING:
- if (!cfip || !(cfip->EraseSuspend & (0x1|0x2)) ||
+ /* Apply OpenWRT patch from */
+ /* https://dev.openwrt.org/browser/trunk/target/linux/generic/patches-3.19/460-mtd-cfi_cmdset_0002-no-erase_suspend.patch */
+ if (1 /* no suspend */ || !cfip || !(cfip->EraseSuspend & (0x1|0x2)) ||
!(mode == FL_READY || mode == FL_POINT ||
(mode == FL_WRITING && (cfip->EraseSuspend & 0x2))))
goto sleep;
diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index 5897d8d..5b1c07e 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -448,6 +448,25 @@
Enables support for NAND Flash chips wired onto Freescale PowerPC
processor localbus with User-Programmable Machine support.
+config MTD_NAND_LS1024A
+ tristate "Support for NAND on Freescale LS1024A"
+ depends on ARCH_COMCERTO
+ help
+ Enables support for NAND flash controller on the Freescale LS1024A
+ SoC.
+
+config NAND_LS1024A_ECC_8_HW_BCH
+ bool
+ depends on MTD_NAND_LS1024A
+ default n
+ prompt "LS1024A ECC-8 syndrome calculation using BCH"
+
+config NAND_LS1024A_ECC_24_HW_BCH
+ bool
+ depends on MTD_NAND_LS1024A
+ default y
+ prompt "LS1024A ECC-24 syndrome calculation using BCH"
+
config MTD_NAND_MPC5121_NFC
tristate "MPC5121 built-in NAND Flash Controller support"
depends on PPC_MPC512x
diff --git a/drivers/mtd/nand/Makefile b/drivers/mtd/nand/Makefile
index 582bbd05..dc5f41b 100644
--- a/drivers/mtd/nand/Makefile
+++ b/drivers/mtd/nand/Makefile
@@ -37,6 +37,7 @@
obj-$(CONFIG_MTD_NAND_FSL_ELBC) += fsl_elbc_nand.o
obj-$(CONFIG_MTD_NAND_FSL_IFC) += fsl_ifc_nand.o
obj-$(CONFIG_MTD_NAND_FSL_UPM) += fsl_upm.o
+obj-$(CONFIG_MTD_NAND_LS1024A) += ls1024a_nand.o
obj-$(CONFIG_MTD_NAND_SLC_LPC32XX) += lpc32xx_slc.o
obj-$(CONFIG_MTD_NAND_MLC_LPC32XX) += lpc32xx_mlc.o
obj-$(CONFIG_MTD_NAND_SH_FLCTL) += sh_flctl.o
diff --git a/drivers/mtd/nand/ls1024a_nand.c b/drivers/mtd/nand/ls1024a_nand.c
new file mode 100644
index 0000000..1b9e9a6
--- /dev/null
+++ b/drivers/mtd/nand/ls1024a_nand.c
@@ -0,0 +1,1113 @@
+/*
+ * linux/drivers/mtd/nand/ls1024a_nand.c
+ *
+ * Copyright (C) Mindspeed Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Overview:
+ * This is a device driver for the NAND flash device found on the
+ * Comcerto board which utilizes the Toshiba TC58V64AFT part. This is
+ * a 128Mibit (8MiB x 8 bits) NAND flash device.
+ */
+
+#include <linux/device.h>
+#include <linux/gpio.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/partitions.h>
+#include <linux/bch.h>
+#include <linux/bitrev.h>
+#include <asm/io.h>
+#include <linux/delay.h>
+#include <linux/ratelimit.h>
+#include <linux/platform_device.h>
+#if 0
+#include <mach/ecc.h>
+#include <linux/mtd/exp_lock.h>
+#endif
+
+/* ECC Register Set */
+/********************/
+/* ECC Control Registers */
+#define ECC_SHIFT_EN_CFG (0x0)
+#define ECC_GEN_CFG (0x4)
+#define ECC_TAG_CFG (0x8)
+#define ECC_INIT_CFG (0xC)
+#define ECC_PRTY_OUT_SEL_CFG (0x10)
+#define ECC_POLY_START_CFG (0x14)
+#define ECC_CS_SEL_CFG (0x18)
+/* ECC Status Registers */
+#define ECC_IDLE_STAT (0x1C)
+#define ECC_POLY_STAT (0x20)
+#define ECC_CORR_STAT (0x24)
+#define ECC_CORR_DONE_STAT (0x28)
+#define ECC_CORR_DATA_STAT (0x2C)
+
+/* ECC general configuration register parameters */
+#define HAMM_MODE BIT(28)
+#define BCH_MODE (~ HAMM_MODE)
+
+#define PRTY_MODE_MASK BIT_MASK(24)
+#define PRTY_CALC PRTY_MODE_MASK
+#define SYNDROME_CALC (~ PRTY_CALC)
+
+#define ECC_LVL_MASK 0x3F0000
+#define ECC_LVL_SHIFT 16
+
+#define BLK_SIZE_MASK 0x7FF
+
+#define ECC_LVL_2 0x2
+#define ECC_LVL_4 0x4
+#define ECC_LVL_6 0x6
+#define ECC_LVL_8 0x8
+#define ECC_LVL_10 0xA
+#define ECC_LVL_12 0xC
+#define ECC_LVL_14 0xE
+#define ECC_LVL_16 0x10
+#define ECC_LVL_18 0x12
+#define ECC_LVL_20 0x14
+#define ECC_LVL_22 0x16
+#define ECC_LVL_24 0x18
+#define ECC_LVL_26 0x1A
+#define ECC_LVL_28 0x1C
+#define ECC_LVL_30 0x1E
+#define ECC_LVL_32 0x20
+
+#if defined (CONFIG_NAND_LS1024A_ECC_24_HW_BCH)
+ #define ECC_LVL_VAL ECC_LVL_24 /* ECC Level 24 is used */
+#elif defined (CONFIG_NAND_LS1024A_ECC_8_HW_BCH)
+ #define ECC_LVL_VAL ECC_LVL_8 /* ECC Level 8 is used */
+#endif
+
+/* Block size used in Bytes*/
+#define ECC_BLOCK_SIZE_512 512
+#define ECC_BLOCK_SIZE_1024 1024
+
+/* Maximum value of ECC Block size is 2k-(1+14*ECC_LVL/8) Bytes */
+#define ECC_BLOCK_SIZE ECC_BLOCK_SIZE_1024
+#define ECC_BLOCK_SIZE_SHIFT ECC_BLOCK_SIZE_1024_SHIFT
+
+#define ECC_CS4_SEL 0x10
+#define ECC_CS3_SEL 0x08
+#define ECC_CS2_SEL 0x04
+#define ECC_CS1_SEL 0x02
+#define ECC_CS0_SEL 0x01
+
+#define ECC_INIT 0x1
+#define ECC_SHIFT_ENABLE 0x1
+#define ECC_SHIFT_DISABLE 0x0
+#define ECC_PARITY_OUT_EN 0x1
+#define ECC_PARITY_OUT_DISABLE 0x0
+
+/* Polynomial Start Configuration (ECC_POLY_START_CFG) */
+#define ECC_POLY_START (1 << 0)
+
+/* Idle Status (ECC_IDLE_STAT) */
+#define ECC_IDLE (1 << 0)
+
+/* Polynomial Status (ECC_POLY_STAT) */
+#define ECC_CORR_REQ (1 << 0)
+#define ECC_ERASED_PAGE (1 << 1)
+#define ECC_UNCORR_ERR_HAMM (1 << 2)
+
+/* Correction Status (ECC_CORR_STAT) */
+#define ECC_TAG_MASK 0xFFFF
+#define ECC_NUM_ERR_MASK 0x3F
+#define ECC_NUM_ERR_SHIFT 16
+#define ECC_UNCORR (1 << 24)
+
+/* Correction Done Status (ECC_CORR_DONE_STAT) */
+#define ECC_DONE (1 << 0)
+
+/* Correction Data Status (ECC_CORR_DATA_STAT), BCH Mode */
+#define ECC_BCH_MASK 0xFFFF
+#define ECC_BCH_INDEX_MASK 0x7FF
+#define ECC_BCH_INDEX_SHIFT 16
+#define ECC_BCH_VALID (1 << 31)
+
+/* Correction Data Status (ECC_CORR_DATA_STAT), Hamming Mode */
+#define ECC_HAMM_MASK 0xF
+#define ECC_HAMM_INDEX_MASK 0x1FF
+#define ECC_HAMM_INDEX_SHIFT 16
+#define ECC_HAMM_VALID (1 << 31)
+
+struct comcerto_bch_control {
+ struct bch_control *bch;
+ unsigned int *errloc;
+};
+
+/*
+ * MTD structure for Comcerto board
+ */
+struct comcerto_nand_info {
+ struct nand_chip chip;
+ struct mtd_info mtd;
+ struct gpio_desc *ce_gpio;
+ struct gpio_desc *br_gpio;
+ uint8_t *bit_reversed;
+ struct comcerto_bch_control cbc;
+};
+
+static inline
+struct comcerto_nand_info *to_comerto_nand_info(struct nand_chip *chip)
+{
+ return container_of(chip, struct comcerto_nand_info, chip);
+}
+
+static void __iomem *ecc_base_addr;
+
+/*
+ * Define partitions for flash device
+ */
+
+uint32_t COMCERTO_NAND_ALE = 0x00000200;
+uint32_t COMCERTO_NAND_CLE = 0x00000400;
+
+#ifdef CONFIG_NAND_LS1024A_ECC_24_HW_BCH
+/*
+ * spare area layout for BCH ECC bytes calculated over 512-Bytes ECC block size
+ */
+static struct nand_ecclayout comcerto_ecc_info_512_bch = {
+ .eccbytes = 42,
+ .eccpos = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+ 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+ 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41},
+ .oobfree = {
+ {.offset = 43, .length = 13}
+ }
+};
+
+/*
+ * spare area layout for BCH ECC bytes calculated over 1024-Bytes ECC block size
+ */
+static struct nand_ecclayout comcerto_ecc_info_1024_bch = {
+ .eccbytes = 42,
+ .eccpos = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+ 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+ 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41},
+ .oobfree = {
+ {.offset = 43, .length = 13}
+ }
+};
+
+#elif defined(CONFIG_NAND_LS1024A_ECC_8_HW_BCH)
+
+/*
+ * spare area layout for BCH ECC bytes calculated over 512-Bytes ECC block size
+ */
+static struct nand_ecclayout comcerto_ecc_info_512_bch = {
+ .eccbytes = 14,
+ .eccpos = {0, 1, 2, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13},
+ .oobfree = {
+ {.offset = 15, .length = 1}
+ }
+};
+
+/*
+ * spare area layout for BCH ECC bytes calculated over 1024-Bytes ECC block size
+ */
+static struct nand_ecclayout comcerto_ecc_info_1024_bch = {
+ .eccbytes = 14,
+ .eccpos = {0, 1, 2, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13},
+ .oobfree = {
+ {.offset = 15, .length = 17}
+ }
+};
+
+#else
+
+/*
+ * spare area layout for Hamming ECC bytes calculated over 512-Bytes ECC block
+ * size
+ */
+static struct nand_ecclayout comcerto_ecc_info_512_hamm = {
+ .eccbytes = 4,
+ .eccpos = {0, 1, 2, 3},
+ .oobfree = {
+ {.offset = 5, .length = 12}
+ }
+};
+
+/*
+ * spare area layout for Hamming ECC bytes calculated over 1024-Bytes ECC block
+ * size
+ */
+static struct nand_ecclayout comcerto_ecc_info_1024_hamm = {
+ .eccbytes = 4,
+ .eccpos = {0, 1, 2, 3},
+ .oobfree = {
+ {.offset = 5, .length = 28}
+ }
+};
+#endif
+
+static uint8_t bbt_pattern[] = { 'B', 'b', 't', '0' };
+static uint8_t mirror_pattern[] = { '1', 't', 'b', 'B' };
+
+static struct nand_bbt_descr bbt_main_descr = {
+ .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
+ | NAND_BBT_8BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
+ .offs = 44,
+ .len = 4,
+ .veroffs = 48,
+ .maxblocks = 8,
+ .pattern = bbt_pattern,
+};
+
+static struct nand_bbt_descr bbt_mirror_descr = {
+ .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
+ | NAND_BBT_8BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
+ .offs = 44,
+ .len = 4,
+ .veroffs = 48,
+ .maxblocks = 8,
+ .pattern = mirror_pattern,
+};
+
+static uint8_t scan_ff_pattern[] = { 0xff };
+
+#ifdef CONFIG_NAND_LS1024A_ECC_24_HW_BCH
+static struct nand_bbt_descr c2000_badblock_pattern = {
+ .offs = 42,
+ .len = 1,
+ .pattern = scan_ff_pattern
+};
+#elif defined(CONFIG_NAND_LS1024A_ECC_8_HW_BCH)
+static struct nand_bbt_descr c2000_badblock_pattern = {
+ .offs = 14,
+ .len = 1,
+ .pattern = scan_ff_pattern
+};
+#endif
+
+/** Disable/Enable shifting of data to parity module
+ *
+ * @param[in] en_dis_shift Enable or disable shift to parity module.
+ *
+ */
+static void comcerto_ecc_shift(uint8_t en_dis_shift)
+{
+ writel_relaxed(en_dis_shift, ecc_base_addr + ECC_SHIFT_EN_CFG);
+}
+
+/** Initializes h/w ECC with proper configuration values.
+ *
+ * @param[in] mtd MTD device structure
+ * @param[in] mode Select between BCH and Hamming
+ *
+ */
+static void comcerto_enable_hw_ecc(struct mtd_info *mtd, int mode)
+{
+ struct nand_chip *nand_device = (struct nand_chip *)(mtd->priv);
+ uint32_t ecc_gen_cfg_val = 0;
+
+ if (mode == NAND_ECC_READSYN) return;
+ /* CS4 will have the option for ECC calculation */
+ writel_relaxed(ECC_CS4_SEL, ecc_base_addr + ECC_CS_SEL_CFG);
+
+ /* parity calculation for write, syndrome calculation for read.*/
+ (mode == NAND_ECC_WRITE) ? (ecc_gen_cfg_val |= PRTY_CALC) : (ecc_gen_cfg_val &= SYNDROME_CALC);
+
+#if defined (CONFIG_NAND_LS1024A_ECC_8_HW_BCH) || defined (CONFIG_NAND_LS1024A_ECC_24_HW_BCH)
+ ecc_gen_cfg_val &= BCH_MODE;
+ ecc_gen_cfg_val = (ecc_gen_cfg_val & ~(ECC_LVL_MASK)) | (ECC_LVL_VAL << ECC_LVL_SHIFT);
+#else
+ ecc_gen_cfg_val |= HAMM_MODE;
+#endif
+
+ ecc_gen_cfg_val = (ecc_gen_cfg_val & ~(BLK_SIZE_MASK)) | nand_device->ecc.size;
+
+ writel_relaxed(ecc_gen_cfg_val, ecc_base_addr + ECC_GEN_CFG);
+ /* Reset parity module and latch configured values */
+ writel_relaxed(ECC_INIT, ecc_base_addr + ECC_INIT_CFG);
+ comcerto_ecc_shift(ECC_SHIFT_ENABLE);
+ return;
+}
+
+/** writes ECC bytes generated by the parity module into the flash
+ *
+ * @param[in] mtd MTD device structure
+ * @param[in] dat raw data
+ * @param[in] ecc_code buffer for ECC
+ *
+ */
+static int comcerto_calculate_ecc(struct mtd_info *mtd,
+ const uint8_t *dat,
+ uint8_t *ecc_code)
+{
+ struct nand_chip *nand_device = mtd->priv;
+ int ecc_bytes = nand_device->ecc.bytes;
+ uint8_t *ecc_calc = nand_device->buffers->ecccalc;
+ unsigned long timeo;
+
+ comcerto_ecc_shift(ECC_SHIFT_DISABLE);
+
+ /* Wait for syndrome calculation to complete */
+ timeo = jiffies + 4;
+ for (;;) {
+ int is_timeout = time_after_eq(jiffies, timeo);
+ int is_idle = readl_relaxed(ecc_base_addr + ECC_IDLE_STAT) & ECC_IDLE;
+ if (is_idle)
+ break;
+ if (is_timeout) {
+ pr_err("ECC Timeout waiting for parity module to become idle 1\n");
+ return -EIO;
+ }
+ touch_softlockup_watchdog();
+ }
+
+ comcerto_ecc_shift(ECC_SHIFT_ENABLE);
+
+ writel_relaxed(ECC_PARITY_OUT_EN, ecc_base_addr + ECC_PRTY_OUT_SEL_CFG);
+
+ /* Even though we do a dummy write to NAND flash, actual ECC bytes are
+ * written to the ECC location in the flash. The contents of ecc_calc
+ * are irrelevant. The ECC engine overwrites it with real ECC data. */
+ nand_device->write_buf(mtd, ecc_calc, ecc_bytes);
+
+ comcerto_ecc_shift(ECC_SHIFT_DISABLE);
+ writel_relaxed(ECC_PARITY_OUT_DISABLE, ecc_base_addr + ECC_PRTY_OUT_SEL_CFG);
+
+ return 0;
+}
+
+/** Checks ECC registers for errors and will correct them, if correctable
+ *
+ * @param[in] mtd MTD device structure
+ * @param[in] dat raw data
+ * @param[in] read_ecc ECC read out from flash
+ * @param[in] calc_ecc ECC calculated over the raw data
+ *
+ */
+static int comcerto_correct_ecc(struct mtd_info *mtd, uint8_t *dat,
+ uint8_t *read_ecc, uint8_t *calc_ecc)
+{
+ struct nand_chip *nand_device = mtd->priv;
+ int num_zero_bits = 0;
+ int empty = 0;
+#if defined (CONFIG_NAND_LS1024A_ECC_8_HW_BCH) || defined (CONFIG_NAND_LS1024A_ECC_24_HW_BCH)
+ uint8_t err_count = 0;
+ uint32_t err_corr_data_prev;
+#endif
+ uint32_t err_corr_data;
+ uint16_t mask, index;
+ unsigned long timeo;
+ int ret;
+
+ num_zero_bits = nand_check_erased_ecc_chunk(dat, nand_device->ecc.size,
+ read_ecc, nand_device->ecc.bytes,
+ NULL, 0,
+ nand_device->ecc.strength);
+ if (num_zero_bits >= 0) {
+ /* Consider ECC chunk empty */
+ empty = 1;
+ if (num_zero_bits > 2) {
+ pr_err_ratelimited("ECC: ECC chunk is mostly empty but has %d zero bits\n", num_zero_bits);
+ }
+ /*
+ * Even though the ECC chunk is empty, we still continue, wait
+ * for the syndrome calculation to complete and read out all
+ * syndromes even though there should be none.
+ * */
+ }
+
+ /* Wait for syndrome calculation to complete */
+ timeo = jiffies + 4;
+ for (;;) {
+ int is_timeout = time_after_eq(jiffies, timeo);
+ int is_idle = readl_relaxed(ecc_base_addr + ECC_IDLE_STAT) & ECC_IDLE;
+ if (is_idle)
+ break;
+ if (is_timeout) {
+ pr_err("ECC Timeout waiting for parity module to become idle 2\n");
+ ret = -EIO;
+ goto out;
+ }
+ touch_softlockup_watchdog();
+ }
+
+ /* If no correction is required */
+ if (likely(!((readl_relaxed(ecc_base_addr + ECC_POLY_STAT)) & ECC_CORR_REQ))) {
+ ret = 0;
+ goto out;
+ }
+
+ /* Error found! Correction required */
+#if defined (CONFIG_NAND_LS1024A_ECC_8_HW_BCH) || defined (CONFIG_NAND_LS1024A_ECC_24_HW_BCH)
+ /* Initiate correction operation */
+ writel_relaxed(ECC_POLY_START, ecc_base_addr + ECC_POLY_START_CFG);
+
+ udelay(25);
+
+ timeo = jiffies + 4;
+ err_corr_data_prev = 0;
+ /* Read Correction data status register till header is 0x7FD */
+ for (;;) {
+ int is_startcode;
+ int is_timeout = time_after_eq(jiffies, timeo);
+ err_corr_data_prev = readl_relaxed(ecc_base_addr + ECC_CORR_DATA_STAT);
+ is_startcode = (err_corr_data_prev >> ECC_BCH_INDEX_SHIFT) == 0x87FD;
+ if (is_startcode)
+ break;
+ if (is_timeout) {
+ pr_err("Timeout waiting for ECC correction data, reg=%08x\n",
+ err_corr_data_prev);
+ ret = -EIO;
+ goto out;
+ }
+ touch_softlockup_watchdog();
+ }
+
+ udelay(25);
+ err_corr_data = 0x0;
+ /* start reading error locations */
+ while (((err_corr_data >> 16) != 0x87FE)) {
+ err_corr_data = readl_relaxed(ecc_base_addr + ECC_CORR_DATA_STAT);
+ if ((err_corr_data >> 16) == 0x87FE)
+ break;
+ if (err_corr_data == err_corr_data_prev)
+ continue;
+ err_corr_data_prev = err_corr_data;
+ /*
+ * If we determined that the ECC chunk is empty, we ignore all
+ * syndromes.
+ * */
+ if (empty)
+ continue;
+ index = (err_corr_data >> 16) & 0x7FF;
+ mask = err_corr_data & 0xFFFF;
+ if (index * 2 >= nand_device->ecc.size) {
+ pr_err("ECC correction index out of "
+ "bounds. ECC_CORR_DATA_STAT %08x\n",
+ err_corr_data);
+ continue;
+ }
+ *((uint16_t *)(dat + (index * 2))) ^= mask;
+ while (mask) {
+ if (mask & 1)
+ err_count++;
+ mask >>= 1;
+ }
+ }
+
+ if (!((readl_relaxed(ecc_base_addr + ECC_CORR_DONE_STAT)) & ECC_DONE)) {
+ pr_err("ECC: uncorrectable error 1 !!!\n");
+ ret = -1;
+ goto out;
+ }
+
+ /* Check if the block has uncorrectable number of errors */
+ if ((readl_relaxed(ecc_base_addr + ECC_CORR_STAT)) & ECC_UNCORR) {
+ if (!empty)
+ pr_err("ECC: uncorrectable error 2 !!!\n");
+ ret = -EIO;
+ goto out;
+ }
+
+#else /* Hamming Mode */
+ if (readl_relaxed(ecc_base_addr + ECC_POLY_STAT) == ECC_UNCORR_ERR_HAMM) {
+ /* 2 or more errors detected and hence cannot
+ be corrected */
+ ret = -1; /* uncorrectable */
+ goto out;
+ } else { /* 1-bit correctable error */
+ err_corr_data = readl_relaxed(ecc_base_addr + ECC_CORR_DATA_STAT);
+ index = (err_corr_data >> 16) & 0x1FF;
+
+ if (nand_device->options & NAND_BUSWIDTH_16) {
+ mask = 1 << (err_corr_data & 0xF);
+ *((uint16_t *)(dat + index)) ^= mask;
+ } else {
+ mask = 1 << (err_corr_data & 0x7);
+ *(dat + index) ^= mask;
+ }
+ ret = 1;
+ goto out;
+
+ }
+#endif
+
+ ret = err_count;
+out:
+
+ if (empty) {
+ /*
+ * If we previously determined that this ECC chunk is empty,
+ * just ignore whatever errors were detected while reading
+ * syndromes from the ECC engine.
+ * */
+ ret = num_zero_bits;
+ }
+
+ comcerto_ecc_shift(ECC_SHIFT_DISABLE);
+
+ return ret;
+}
+
+/** writes single page to the NAND device along with the ECC bytes
+ *
+ * @param[in] mtd MTD device structure
+ * @param[in] chip nand chip info structure
+ * @param[in] buf data buffer
+ *
+ */
+static int comcerto_nand_write_page_hwecc(struct mtd_info *mtd,
+ struct nand_chip *chip,
+ const uint8_t *buf, int oob_required)
+{
+ int i, eccsize = chip->ecc.size;
+ int eccbytes = chip->ecc.bytes;
+ int eccsteps = chip->ecc.steps;
+ const uint8_t *p = buf;
+ uint8_t *oob = chip->oob_poi;
+
+ for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
+
+ chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
+ chip->write_buf(mtd, p, eccsize);
+
+ chip->ecc.calculate(mtd, p, oob);
+ oob += eccbytes;
+
+ if (chip->ecc.postpad) {
+ chip->write_buf(mtd, oob, chip->ecc.postpad);
+ oob += chip->ecc.postpad;
+ }
+ }
+
+ /* Calculate remaining oob bytes */
+ i = mtd->oobsize - (oob - chip->oob_poi);
+ if (i)
+ chip->write_buf(mtd, oob, i);
+
+ return 0;
+}
+
+
+static void comcerto_hybrid_hwctl (struct mtd_info *mtd, int mode) {
+ if (mode == NAND_ECC_READ) comcerto_enable_hw_ecc(mtd, mode);
+}
+
+#if 0
+static void comcerto_fake_hwctl (struct mtd_info *mtd, int mode) {
+}
+#endif
+
+/* Replicate the LS1024A HW ECC engine in software. Compared to the BCH
+ * implemenation in Linux, the LS1024A HW ECC engine (seemingly licensed from
+ * Cyclic Design) does a few things differently:
+ *
+ * - They use 0x4443 as the primitive polynomial for BCH (Linux uses 0x402b by
+ * default).
+ * - They reverse the 8 bits in every byte before they calculate the ECC code.
+ * They then also reverse the bits in the ECC code before they write it to
+ * flash.
+ * - They don't XOR the inverse of the ECC code of an empty page (all 0xFF's)
+ * onto every calculated ECC code. (Linux does this to ensure that an empty
+ * page has a valid ECC code).
+ * */
+static int comcerto_bch_calculate_ecc (struct mtd_info *mtd, const uint8_t *dat,
+ uint8_t *ecc_code) {
+ struct nand_chip *chip = mtd->priv;
+ struct comcerto_nand_info *info = to_comerto_nand_info(chip);
+ int i;
+
+ for (i=0;i<chip->ecc.size;i++) {
+ info->bit_reversed[i] = bitrev8(dat[i]);
+ }
+ memset(ecc_code, 0, chip->ecc.bytes);
+ encode_bch(info->cbc.bch, info->bit_reversed, chip->ecc.size, ecc_code);
+ for (i=0;i<chip->ecc.bytes;i++) {
+ ecc_code[i] = bitrev8(ecc_code[i]);
+ }
+ return 0;
+}
+
+/* We currently don't need comcerto_bch_correct_ecc() because we are using a
+ * hybrid approach where we use the HW ECC engine when we read from NAND. We
+ * only calculate the ECC code in software when we write to the flash. */
+#if 0
+/*
+ * This function replicates the Cyclic Design ECC engine that can
+ * be found in the LS1024A. It calculates the ECC code a little different from
+ * nand_bch_correct_data() (nand_bch.c)
+ * */
+static int comcerto_bch_correct_ecc (struct mtd_info *mtd, uint8_t *dat, uint8_t *read_ecc,
+ uint8_t *dummy) {
+ struct nand_chip *chip = mtd->priv;
+ struct comcerto_nand_info *info = to_comerto_nand_info(chip);
+ int num_zero_bits = 0;
+ int i, count;
+
+ num_zero_bits = nand_check_erased_ecc_chunk(dat, chip->ecc.size,
+ read_ecc, chip->ecc.bytes,
+ NULL, 0,
+ chip->ecc.strength);
+ if (num_zero_bits >= 0) {
+ if (num_zero_bits > 2) {
+ pr_err_ratelimited("ECC: ECC chunk is mostly empty but has %d zero bits\n", num_zero_bits);
+ }
+ return num_zero_bits;
+ }
+
+ for (i=0;i<chip->ecc.size;i++) {
+ info->bit_reversed[i] = bitrev8(dat[i]);
+ }
+ for (i=0;i<chip->ecc.bytes;i++) {
+ read_ecc[i] = bitrev8(read_ecc[i]);
+ }
+ count = decode_bch(info->cbc.bch, info->bit_reversed, chip->ecc.size, read_ecc, NULL,
+ NULL, info->cbc.errloc);
+ if (count > 0) {
+ for (i = 0; i < count; i++) {
+ if (info->cbc.errloc[i] < (chip->ecc.size*8))
+ /* error is located in data, correct it */
+ dat[info->cbc.errloc[i] >> 3] ^= (1 << (7 - (info->cbc.errloc[i] & 7)));
+ /* else error in ecc, no action needed */
+ }
+ } else if (count < 0) {
+ pr_err_ratelimited("ecc unrecoverable error\n");
+ count = -1;
+ }
+ return count;
+}
+#endif
+
+/** reads single page from the NAND device and will read ECC bytes from flash. A
+ * function call to comcerto_correct_ecc() will be used to validate the data.
+ *
+ * @param[in] mtd MTD device structure
+ * @param[in] chip nand chip info structure
+ * @param[in] buf data buffer
+ *
+ */
+#if 0
+static int comcerto_nand_read_page_hwecc(struct mtd_info *mtd,
+ struct nand_chip *chip, uint8_t *buf, int page)
+{
+ struct nand_chip *nand_device = mtd->priv;
+ int i, eccsize = nand_device->ecc.size;
+ int eccbytes = nand_device->ecc.bytes;
+ int eccsteps = nand_device->ecc.steps;
+ uint8_t *p = buf;
+ uint8_t *ecc_code = nand_device->buffers->ecccode;
+ int ecc_bytes = nand_device->ecc.bytes;
+ int stat;
+ uint8_t *oob = nand_device->oob_poi;
+
+
+ for (; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
+
+ chip->ecc.hwctl(mtd, NAND_ECC_READ);
+ chip->read_buf(mtd, p, eccsize);
+ chip->read_buf(mtd, ecc_code, ecc_bytes);
+
+ stat = chip->ecc.correct(mtd, p, oob, NULL);
+ if (stat < 0) {
+ mtd->ecc_stats.failed++;
+ pr_err("ECC correction failed for page 0x%08x\n", page);
+ } else {
+ int idx = eccsteps;
+ if (idx >= MTD_ECC_STAT_SUBPAGES) {
+ idx = MTD_ECC_STAT_SUBPAGES - 1;
+ }
+
+ mtd->ecc_stats.corrected += stat;
+ mtd->ecc_subpage_stats.subpage_corrected[idx] += stat;
+ }
+
+ if (chip->ecc.postpad) {
+ chip->read_buf(mtd, oob, chip->ecc.postpad);
+ oob += chip->ecc.postpad;
+ }
+ }
+ /* Calculate remaining oob bytes */
+ i = mtd->oobsize - (oob - chip->oob_poi);
+ if (i)
+ chip->read_buf(mtd, oob, i);
+
+ return 0;
+}
+#endif
+
+/*********************************************************************
+ * NAND Hardware functions
+ *
+ *********************************************************************/
+
+/*
+ * hardware specific access to control-lines
+*/
+void comcerto_nand_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)
+{
+ struct nand_chip *chip = mtd->priv;
+ struct comcerto_nand_info *info = to_comerto_nand_info(chip);
+
+ if (ctrl & NAND_CTRL_CHANGE) {
+ gpiod_set_value(info->ce_gpio, !(ctrl & NAND_NCE));
+ }
+
+ if (cmd == NAND_CMD_NONE)
+ return;
+
+ if (ctrl & NAND_CLE)
+ writeb(cmd, chip->IO_ADDR_W + COMCERTO_NAND_CLE);
+ else if (ctrl & NAND_ALE)
+ writeb(cmd, chip->IO_ADDR_W + COMCERTO_NAND_ALE);
+ else
+ return;
+
+}
+
+int comcerto_nand_ready(struct mtd_info *mtd)
+{
+ struct nand_chip *chip = mtd->priv;
+ struct comcerto_nand_info *info = to_comerto_nand_info(chip);
+
+ return gpiod_get_value(info->br_gpio);
+}
+
+/*********************************************************************
+ * NAND Probe
+ *
+ *********************************************************************/
+static int comcerto_nand_probe(struct platform_device *pdev)
+{
+ struct comcerto_nand_info *info;
+ struct mtd_info *mtd;
+ struct nand_chip *chip;
+ struct resource *res;
+ int err = 0;
+ struct mtd_part_parser_data ppdata = {};
+
+ /* Allocate memory for info structure */
+ info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
+ if (!info)
+ return -ENOMEM;
+
+ mtd = &info->mtd;
+ chip = &info->chip;
+ mtd->owner = THIS_MODULE;
+
+ /* Link the private data with the MTD structure */
+ mtd->priv = &info->chip;
+
+ info->ce_gpio = devm_gpiod_get(&pdev->dev, "ce",
+ GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT);
+ if (IS_ERR(info->ce_gpio)) {
+ dev_err(&pdev->dev, "Failed to get CE GPIO.\n");
+ goto out_info;
+ }
+ info->br_gpio = devm_gpiod_get(&pdev->dev, "br",
+ GPIOD_FLAGS_BIT_DIR_SET);
+ if (IS_ERR(info->br_gpio)) {
+ dev_err(&pdev->dev, "Failed to get BR GPIO.\n");
+ goto out_info;
+ }
+
+ /*Map physical address of nand into virtual space */
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ chip->IO_ADDR_R = devm_ioremap_resource(&pdev->dev, res);
+
+ if (IS_ERR(chip->IO_ADDR_R)) {
+ pr_err("LS1024A NAND: cannot map nand memory\n");
+ err = PTR_ERR(chip->IO_ADDR_R);
+ goto out_info;
+ }
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+ ecc_base_addr = devm_ioremap_resource(&pdev->dev, res);
+ if (IS_ERR(ecc_base_addr)) {
+ pr_err("LS1024A NAND: cannot map ecc config\n");
+ err = PTR_ERR(chip->IO_ADDR_R);
+ goto out_iorc;
+ }
+
+ /* This is the same address to read and write */
+ chip->IO_ADDR_W = chip->IO_ADDR_R;
+
+ /* Set address of hardware control function */
+ chip->cmd_ctrl = comcerto_nand_hwcontrol;
+ chip->dev_ready = comcerto_nand_ready;
+ chip->ecc.mode = NAND_ECC_HW_SYNDROME;
+// chip->ecc.mode = NAND_ECC_SOFT_BCH;
+
+#if defined(CONFIG_C2K_ASIC) && defined(CONFIG_NAND_TYPE_SLC)
+ chip->options = NAND_BUSWIDTH_16;
+#else
+ chip->options = 0;
+#endif
+
+ /* Scan to find existence of the device */
+ if (nand_scan_ident(mtd, 1, NULL)) {
+ err = -ENXIO;
+ goto out_ior;
+ }
+
+ if (1 && chip->ecc.mode == NAND_ECC_HW_SYNDROME) {
+ /* We use a hybrid approach here where we use the ECC hardware
+ * in the read path to correct ECC errors on read. For writing,
+ * we calculate the ECC code in software. The reason for this
+ * is to work around a silicon bug where the ECC hardware would
+ * disturb and corrupt the NOR flash if the user tries to write
+ * to NOR flash and NAND flash concurrently.
+ */
+ unsigned int m, t;
+
+ chip->ecc.hwctl = comcerto_hybrid_hwctl;
+ chip->ecc.calculate = comcerto_bch_calculate_ecc;
+ chip->ecc.correct = comcerto_correct_ecc;
+ dev_info(&pdev->dev, "Using hybrid hw/sw ECC\n");
+ chip->ecc.size = 1024;
+ chip->ecc.layout = &comcerto_ecc_info_1024_bch;
+ chip->ecc.strength = 24;
+ chip->ecc.prepad = 0;
+ chip->ecc.postpad = 14;
+
+ chip->ecc.steps = mtd->writesize / chip->ecc.size;
+ if(chip->ecc.steps * chip->ecc.size != mtd->writesize) {
+ dev_err(&pdev->dev, "Invalid ecc parameters\n");
+ BUG();
+ }
+ chip->ecc.total = chip->ecc.steps * chip->ecc.bytes;
+ chip->ecc.bytes = DIV_ROUND_UP(
+ chip->ecc.strength * fls(8 * chip->ecc.size), 8);
+ if (chip->ecc.bytes != 42) {
+ dev_warn(&pdev->dev, "ecc->bytes != 42\n");
+ }
+
+ m = fls(1+8*chip->ecc.size);
+ t = (chip->ecc.bytes*8)/m;
+
+ /* The LS1024A HW ECC engine (seemingly licensed from Cyclic
+ * Design) uses 0x4443 as the primitive polynomial for BCH
+ * (Linux uses 0x402b by default). */
+ info->cbc.bch = init_bch(m, t, 0x4443);
+ if (!info->cbc.bch) {
+ err = -EINVAL;
+ goto out_ior;
+ }
+
+ /* verify that eccbytes has the expected value */
+ if (info->cbc.bch->ecc_bytes != chip->ecc.bytes) {
+ dev_warn(&pdev->dev, "invalid eccbytes %u, should be %u\n",
+ chip->ecc.bytes, info->cbc.bch->ecc_bytes);
+ free_bch(info->cbc.bch);
+ err = -EINVAL;
+ goto out_ior;
+ }
+
+ /* sanity checks */
+ if (8*(chip->ecc.size+chip->ecc.bytes) >= (1 << m)) {
+ dev_warn(&pdev->dev, "eccsize %u is too large\n", chip->ecc.size);
+ free_bch(info->cbc.bch);
+ err = -EINVAL;
+ goto out_ior;
+ }
+
+#if 0
+ info->cbc.errloc = devm_kmalloc(&pdev->dev, t*sizeof(*info->cbc.errloc), GFP_KERNEL);
+ if (!info->cbc.errloc) {
+ free_bch(info->cbc.bch);
+ err = -ENOMEM;
+ goto out_ior;
+ }
+#endif
+
+ info->bit_reversed = devm_kzalloc(&pdev->dev, chip->ecc.size, GFP_KERNEL);
+ if (!info->bit_reversed) {
+ free_bch(info->cbc.bch);
+ err = -ENOMEM;
+ goto out_ior;
+ }
+ chip->bbt_td = &bbt_main_descr;
+ chip->bbt_md = &bbt_mirror_descr;
+ chip->badblock_pattern = &c2000_badblock_pattern;
+ chip->bbt_options |= NAND_BBT_USE_FLASH;
+
+ } else if (chip->ecc.mode == NAND_ECC_HW_SYNDROME) {
+ chip->ecc.hwctl = comcerto_enable_hw_ecc;
+ chip->ecc.write_page = comcerto_nand_write_page_hwecc;
+ // chip->ecc.read_page = comcerto_nand_read_page_hwecc;
+ chip->ecc.calculate = comcerto_calculate_ecc;
+ chip->ecc.correct = comcerto_correct_ecc;
+ pr_info("hw_syndrome correction %d.\n", mtd->writesize);
+
+ switch (mtd->writesize) {
+ case 512:
+ chip->ecc.size = mtd->writesize;
+#if defined (CONFIG_NAND_LS1024A_ECC_24_HW_BCH)
+ chip->ecc.layout = &comcerto_ecc_info_512_bch;
+ chip->ecc.bytes = 42;
+ chip->ecc.strength = 24;
+ chip->ecc.prepad = 0;
+ chip->ecc.postpad = 14;
+#elif defined(CONFIG_NAND_LS1024A_ECC_8_HW_BCH)
+ chip->ecc.layout = &comcerto_ecc_info_512_bch;
+ chip->ecc.bytes = 14;
+ chip->ecc.strength = 8;
+ chip->ecc.prepad = 0;
+ chip->ecc.postpad = 2;
+#else
+ chip->ecc.layout = &comcerto_ecc_info_512_hamm;
+ chip->ecc.bytes = 4;
+ chip->ecc.prepad = 0;
+ chip->ecc.postpad = 2;
+#endif
+ break;
+ case 1024:
+ chip->ecc.size = mtd->writesize;
+#ifdef CONFIG_NAND_LS1024A_ECC_24_HW_BCH
+ chip->ecc.layout = &comcerto_ecc_info_1024_bch;
+ chip->ecc.bytes = 42;
+ chip->ecc.strength = 24;
+ chip->ecc.prepad = 0;
+ chip->ecc.postpad = 14;
+#elif defined(CONFIG_NAND_LS1024A_ECC_8_HW_BCH)
+ chip->ecc.layout = &comcerto_ecc_info_1024_bch;
+ chip->ecc.bytes = 14;
+ chip->ecc.strength = 8;
+ chip->ecc.prepad = 0;
+ chip->ecc.postpad = 18;
+#else
+ chip->ecc.layout = &comcerto_ecc_info_1024_hamm;
+ chip->ecc.bytes = 4;
+ chip->ecc.prepad = 0;
+ chip->ecc.postpad = 18;
+#endif
+ break;
+ default:
+ pr_err("Using default values for hw ecc\n");
+ chip->ecc.size = 1024;
+#ifdef CONFIG_NAND_LS1024A_ECC_24_HW_BCH
+ chip->ecc.layout = &comcerto_ecc_info_1024_bch;
+ chip->ecc.bytes = 42;
+ chip->ecc.strength = 24;
+ chip->ecc.prepad = 0;
+ chip->ecc.postpad = 14;
+#elif defined(CONFIG_NAND_LS1024A_ECC_8_HW_BCH)
+ chip->ecc.layout = &comcerto_ecc_info_1024_bch;
+ chip->ecc.bytes = 14;
+ chip->ecc.strength = 8;
+ chip->ecc.prepad = 0;
+ chip->ecc.postpad = 18;
+#else
+ chip->ecc.layout = &comcerto_ecc_info_1024_hamm;
+ chip->ecc.bytes = 4;
+ chip->ecc.prepad = 0;
+ chip->ecc.postpad = 18;
+#endif
+ break;
+ }
+ chip->ecc.steps = mtd->writesize / chip->ecc.size;
+ if(chip->ecc.steps * chip->ecc.size != mtd->writesize) {
+ pr_err("Invalid ecc parameters\n");
+ BUG();
+ }
+ chip->ecc.total = chip->ecc.steps * chip->ecc.bytes;
+
+
+ chip->bbt_td = &bbt_main_descr;
+ chip->bbt_md = &bbt_mirror_descr;
+ chip->badblock_pattern = &c2000_badblock_pattern;
+ chip->bbt_options |= NAND_BBT_USE_FLASH;
+
+ } else {
+ pr_info("using soft ecc.\n");
+ chip->ecc.size = 1024;
+ chip->ecc.strength = 24;
+ chip->ecc.bytes = 42;
+ chip->ecc.mode = NAND_ECC_SOFT_BCH;
+ }
+
+
+ chip->options |= NAND_NO_SUBPAGE_WRITE;
+
+ if(nand_scan_tail(mtd)) {
+ pr_err("nand_scan_tail returned error\n");
+ err = -ENXIO;
+ goto out_ior;
+ }
+
+ /* Name of the mtd device */
+ mtd->name = dev_name(&pdev->dev);
+
+ /* Link the info stucture with platform_device */
+ platform_set_drvdata(pdev, info);
+
+ ppdata.of_node = pdev->dev.of_node;
+ err = mtd_device_parse_register(mtd, NULL, &ppdata, NULL, 0);
+ if (err) {
+ nand_release(mtd);
+ goto out_ior;
+ }
+
+ goto out;
+
+ out_ior:
+ devm_iounmap(&pdev->dev, ecc_base_addr);
+ out_iorc:
+ devm_iounmap(&pdev->dev, chip->IO_ADDR_R);
+ out_info:
+ devm_kfree(&pdev->dev, info);
+ out:
+ return err;
+}
+
+/*********************************************************************
+ * NAND Remove
+ *
+ *********************************************************************/
+static int comcerto_nand_remove(struct platform_device *pdev)
+{
+ struct comcerto_nand_info *info =
+ (struct comcerto_nand_info *)platform_get_drvdata(pdev);
+
+ platform_set_drvdata(pdev, NULL);
+
+ /* Release resources, unregister device */
+ nand_release(&info->mtd);
+
+ /*Deregister virtual address */
+ iounmap(info->chip.IO_ADDR_R);
+ iounmap(ecc_base_addr);
+ return 0;
+}
+
+/*********************************************************************
+ * Driver Registration
+ *
+ *********************************************************************/
+
+static const struct of_device_id fsl_ls1024a_nand_match[] = {
+ {
+ .compatible = "fsl,ls1024a-nand",
+ },
+ { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, fsl_ls1024a_nand_match);
+
+static struct platform_driver ls1024a_nand_driver = {
+ .probe = comcerto_nand_probe,
+ .remove = comcerto_nand_remove,
+ .driver = {
+ .name = "ls1024a_nand",
+ .of_match_table = fsl_ls1024a_nand_match,
+ },
+};
+
+module_platform_driver(ls1024a_nand_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Board-specific glue layer for NAND flash on Comcerto board");
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index fa5cd51..ffdaddf 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -544,23 +544,32 @@
}
}
-/* Wait for the ready pin, after a command. The timeout is caught later. */
+/**
+ * nand_wait_ready - [GENERIC] Wait for the ready pin after commands.
+ * @mtd: MTD device structure
+ *
+ * Wait for the ready pin after a command, and warn if a timeout occurs.
+ */
void nand_wait_ready(struct mtd_info *mtd)
{
struct nand_chip *chip = mtd->priv;
- unsigned long timeo = jiffies + msecs_to_jiffies(20);
+ unsigned long timeo = 400;
- /* 400ms timeout */
if (in_interrupt() || oops_in_progress)
- return panic_nand_wait_ready(mtd, 400);
+ return panic_nand_wait_ready(mtd, timeo);
led_trigger_event(nand_led_trigger, LED_FULL);
/* Wait until command is processed or timeout occurs */
+ timeo = jiffies + msecs_to_jiffies(timeo);
do {
if (chip->dev_ready(mtd))
- break;
- touch_softlockup_watchdog();
+ goto out;
+ cond_resched();
} while (time_before(jiffies, timeo));
+
+ pr_warn_ratelimited(
+ "timeout while waiting for chip to become ready\n");
+out:
led_trigger_event(nand_led_trigger, LED_OFF);
}
EXPORT_SYMBOL_GPL(nand_wait_ready);
@@ -886,15 +895,13 @@
* @mtd: MTD device structure
* @chip: NAND chip structure
*
- * Wait for command done. This applies to erase and program only. Erase can
- * take up to 400ms and program up to 20ms according to general NAND and
- * SmartMedia specs.
+ * Wait for command done. This applies to erase and program only.
*/
static int nand_wait(struct mtd_info *mtd, struct nand_chip *chip)
{
- int status, state = chip->state;
- unsigned long timeo = (state == FL_ERASING ? 400 : 20);
+ int status;
+ unsigned long timeo = 400;
led_trigger_event(nand_led_trigger, LED_FULL);
@@ -910,7 +917,7 @@
panic_nand_wait(mtd, chip, timeo);
else {
timeo = jiffies + msecs_to_jiffies(timeo);
- while (time_before(jiffies, timeo)) {
+ do {
if (chip->dev_ready) {
if (chip->dev_ready(mtd))
break;
@@ -919,7 +926,7 @@
break;
}
cond_resched();
- }
+ } while (time_before(jiffies, timeo));
}
led_trigger_event(nand_led_trigger, LED_OFF);
@@ -1102,6 +1109,134 @@
EXPORT_SYMBOL(nand_lock);
/**
+ * nand_check_erased_buf - check if a buffer contains (almost) only 0xff data
+ * @buf: buffer to test
+ * @len: buffer length
+ * @bitflips_threshold: maximum number of bitflips
+ *
+ * Check if a buffer contains only 0xff, which means the underlying region
+ * has been erased and is ready to be programmed.
+ * The bitflips_threshold specify the maximum number of bitflips before
+ * considering the region is not erased.
+ * Note: The logic of this function has been extracted from the memweight
+ * implementation, except that nand_check_erased_buf function exit before
+ * testing the whole buffer if the number of bitflips exceed the
+ * bitflips_threshold value.
+ *
+ * Returns a positive number of bitflips less than or equal to
+ * bitflips_threshold, or -ERROR_CODE for bitflips in excess of the
+ * threshold.
+ */
+static int nand_check_erased_buf(void *buf, int len, int bitflips_threshold)
+{
+ const unsigned char *bitmap = buf;
+ int bitflips = 0;
+ int weight;
+
+ for (; len && ((uintptr_t)bitmap) % sizeof(long);
+ len--, bitmap++) {
+ weight = hweight8(*bitmap);
+ bitflips += BITS_PER_BYTE - weight;
+ if (unlikely(bitflips > bitflips_threshold))
+ return -EBADMSG;
+ }
+
+ for (; len >= sizeof(long);
+ len -= sizeof(long), bitmap += sizeof(long)) {
+ weight = hweight_long(*((unsigned long *)bitmap));
+ bitflips += BITS_PER_LONG - weight;
+ if (unlikely(bitflips > bitflips_threshold))
+ return -EBADMSG;
+ }
+
+ for (; len > 0; len--, bitmap++) {
+ weight = hweight8(*bitmap);
+ bitflips += BITS_PER_BYTE - weight;
+ if (unlikely(bitflips > bitflips_threshold))
+ return -EBADMSG;
+ }
+
+ return bitflips;
+}
+
+/**
+ * nand_check_erased_ecc_chunk - check if an ECC chunk contains (almost) only
+ * 0xff data
+ * @data: data buffer to test
+ * @datalen: data length
+ * @ecc: ECC buffer
+ * @ecclen: ECC length
+ * @extraoob: extra OOB buffer
+ * @extraooblen: extra OOB length
+ * @bitflips_threshold: maximum number of bitflips
+ *
+ * Check if a data buffer and its associated ECC and OOB data contains only
+ * 0xff pattern, which means the underlying region has been erased and is
+ * ready to be programmed.
+ * The bitflips_threshold specify the maximum number of bitflips before
+ * considering the region as not erased.
+ *
+ * Note:
+ * 1/ ECC algorithms are working on pre-defined block sizes which are usually
+ * different from the NAND page size. When fixing bitflips, ECC engines will
+ * report the number of errors per chunk, and the NAND core infrastructure
+ * expect you to return the maximum number of bitflips for the whole page.
+ * This is why you should always use this function on a single chunk and
+ * not on the whole page. After checking each chunk you should update your
+ * max_bitflips value accordingly.
+ * 2/ When checking for bitflips in erased pages you should not only check
+ * the payload data but also their associated ECC data, because a user might
+ * have programmed almost all bits to 1 but a few. In this case, we
+ * shouldn't consider the chunk as erased, and checking ECC bytes prevent
+ * this case.
+ * 3/ The extraoob argument is optional, and should be used if some of your OOB
+ * data are protected by the ECC engine.
+ * It could also be used if you support subpages and want to attach some
+ * extra OOB data to an ECC chunk.
+ *
+ * Returns a positive number of bitflips less than or equal to
+ * bitflips_threshold, or -ERROR_CODE for bitflips in excess of the
+ * threshold. In case of success, the passed buffers are filled with 0xff.
+ */
+int nand_check_erased_ecc_chunk(void *data, int datalen,
+ void *ecc, int ecclen,
+ void *extraoob, int extraooblen,
+ int bitflips_threshold)
+{
+ int data_bitflips = 0, ecc_bitflips = 0, extraoob_bitflips = 0;
+
+ data_bitflips = nand_check_erased_buf(data, datalen,
+ bitflips_threshold);
+ if (data_bitflips < 0)
+ return data_bitflips;
+
+ bitflips_threshold -= data_bitflips;
+
+ ecc_bitflips = nand_check_erased_buf(ecc, ecclen, bitflips_threshold);
+ if (ecc_bitflips < 0)
+ return ecc_bitflips;
+
+ bitflips_threshold -= ecc_bitflips;
+
+ extraoob_bitflips = nand_check_erased_buf(extraoob, extraooblen,
+ bitflips_threshold);
+ if (extraoob_bitflips < 0)
+ return extraoob_bitflips;
+
+ if (data_bitflips)
+ memset(data, 0xff, datalen);
+
+ if (ecc_bitflips)
+ memset(ecc, 0xff, ecclen);
+
+ if (extraoob_bitflips)
+ memset(extraoob, 0xff, extraooblen);
+
+ return data_bitflips + ecc_bitflips + extraoob_bitflips;
+}
+EXPORT_SYMBOL(nand_check_erased_ecc_chunk);
+
+/**
* nand_read_page_raw - [INTERN] read raw page data without ecc
* @mtd: mtd info structure
* @chip: nand chip info structure
diff --git a/drivers/net/phy/at803x.c b/drivers/net/phy/at803x.c
index fabf11d..a285cd5 100644
--- a/drivers/net/phy/at803x.c
+++ b/drivers/net/phy/at803x.c
@@ -42,6 +42,7 @@
#define ATH8030_PHY_ID 0x004dd076
#define ATH8031_PHY_ID 0x004dd074
#define ATH8035_PHY_ID 0x004dd072
+#define ATH8337_PHY_ID 0x004dd036
MODULE_DESCRIPTION("Atheros 803x PHY driver");
MODULE_AUTHOR("Matus Ujhelyi");
@@ -351,6 +352,25 @@
.driver = {
.owner = THIS_MODULE,
},
+}, {
+ /* ATHEROS 8337 */
+ .phy_id = ATH8337_PHY_ID,
+ .name = "Atheros 8337 ethernet",
+ .phy_id_mask = 0xffffffff,
+ .probe = at803x_probe,
+ .config_init = at803x_config_init,
+ .link_change_notify = at803x_link_change_notify,
+ .set_wol = at803x_set_wol,
+ .get_wol = at803x_get_wol,
+ .suspend = at803x_suspend,
+ .resume = at803x_resume,
+ .features = PHY_GBIT_FEATURES,
+ .flags = PHY_HAS_INTERRUPT,
+ .config_aneg = genphy_config_aneg,
+ .read_status = genphy_read_status,
+ .driver = {
+ .owner = THIS_MODULE,
+ },
} };
module_phy_driver(at803x_driver);
@@ -359,6 +379,7 @@
{ ATH8030_PHY_ID, 0xffffffef },
{ ATH8031_PHY_ID, 0xffffffef },
{ ATH8035_PHY_ID, 0xffffffef },
+ { ATH8337_PHY_ID, 0xffffffff },
{ }
};
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index 47cd578..7124895 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -421,8 +421,13 @@
mii_data->reg_num, val);
if (mii_data->reg_num == MII_BMCR &&
- val & BMCR_RESET)
+ val & BMCR_RESET) {
+#ifdef CONFIG_ARCH_COMCERTO
+ if (mii_data->phy_id >= 16)
+ return 0;
+#endif
return phy_init_hw(phydev);
+ }
if (change_autoneg)
return phy_start_aneg(phydev);
diff --git a/drivers/pci/host/Kconfig b/drivers/pci/host/Kconfig
index 1dfb567..e2ee75f 100644
--- a/drivers/pci/host/Kconfig
+++ b/drivers/pci/host/Kconfig
@@ -30,6 +30,12 @@
select PCIEPORTBUS
select PCIE_DW
+config PCI_LS1024A
+ bool "Freescale LS1024A PCIe controller"
+ depends on ARCH_COMCERTO
+ select PCIEPORTBUS
+ select PCIE_DW
+
config PCI_TEGRA
bool "NVIDIA Tegra PCIe controller"
depends on ARCH_TEGRA && !ARM64
diff --git a/drivers/pci/host/Makefile b/drivers/pci/host/Makefile
index f733b4e..028de0d 100644
--- a/drivers/pci/host/Makefile
+++ b/drivers/pci/host/Makefile
@@ -2,6 +2,7 @@
obj-$(CONFIG_PCI_DRA7XX) += pci-dra7xx.o
obj-$(CONFIG_PCI_EXYNOS) += pci-exynos.o
obj-$(CONFIG_PCI_IMX6) += pci-imx6.o
+obj-$(CONFIG_PCI_LS1024A) += pci-ls1024a.o
obj-$(CONFIG_PCI_MVEBU) += pci-mvebu.o
obj-$(CONFIG_PCI_TEGRA) += pci-tegra.o
obj-$(CONFIG_PCI_RCAR_GEN2) += pci-rcar-gen2.o
diff --git a/drivers/pci/host/pci-ls1024a.c b/drivers/pci/host/pci-ls1024a.c
new file mode 100644
index 0000000..2afcb6b
--- /dev/null
+++ b/drivers/pci/host/pci-ls1024a.c
@@ -0,0 +1,382 @@
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/gpio/consumer.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/mfd/syscon.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/phy/phy.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/types.h>
+#include <linux/reset.h>
+
+#include "pcie-designware.h"
+
+#define to_ls1024a_pcie(x) container_of(x, struct ls1024a_pcie, pp)
+
+struct ls1024a_pcie {
+ int reset_gpio;
+ struct reset_control *axi_rst;
+ struct clk *pcie;
+ struct phy *phy;
+ struct pcie_port pp;
+ struct regmap *app;
+ int app_profile;
+ struct gpio_desc *gpiod_reset;
+};
+
+
+/* The following register definitions are as per "DWC_regs_rev04.doc" document */
+
+struct pcie_app_reg {
+ u32 cfg0;
+ u32 cfg1;
+ u32 cfg2;
+ u32 cfg3;
+ u32 cfg4;
+ u32 cfg5;
+ u32 cfg6;
+ u32 sts0;
+ u32 sts1;
+ u32 sts2;
+ u32 sts3;
+ u32 pwr_cfg_bdgt_data;
+ u32 pwr_cfg_bdgt_fn;
+ u32 radm_sts;
+ u32 pwr_sts_bdgt;
+ u32 intr_sts;
+ u32 intr_en;
+ u32 intr_msi_sts;
+ u32 intr_msi_en;
+};
+
+#define MAX_PCIE_PORTS 2
+/* DWC PCIEe configuration register offsets on APB */
+struct pcie_app_reg app_regs[MAX_PCIE_PORTS] = {
+ /* PCIe0 */
+ {
+ 0x00000000, /* cfg0 */
+ 0x00000004,
+ 0x00000008,
+ 0x0000000C,
+ 0x00000010,
+ 0x00000014,
+ 0x00000018, /* cfg6 */
+ 0x00000040, /* sts0 */
+ 0x00000044,
+ 0x00000048,
+ 0x00000058, /* sts3 */
+ 0x00000080,
+ 0x00000084,
+ 0x000000C0, /* radm_sts */
+ 0x000000C4,
+ 0x00000100, /* intr_sts */
+ 0x00000104,
+ 0x00000108,
+ 0x0000010C
+ },
+ /* PCIe1 */
+ {
+ 0x00000020,
+ 0x00000024,
+ 0x00000028,
+ 0x0000002C,
+ 0x00000030,
+ 0x00000034,
+ 0x00000038,
+ 0x0000004C,
+ 0x00000050,
+ 0x00000054,
+ 0x0000005C,
+ 0x00000088,
+ 0x0000008C,
+ 0x000000C8,
+ 0x000000CC,
+ 0x00000110,
+ 0x00000114,
+ 0x00000118,
+ 0x0000011C
+ }
+};
+
+/* INTR_STS and INTR_EN Register definitions */
+#define INTR_CTRL_INTA_ASSERT 0x0001
+#define INTR_CTRL_INTA_DEASSERT 0x0002
+#define INTR_CTRL_INTB_ASSERT 0x0004
+#define INTR_CTRL_INTB_DEASSERT 0x0008
+#define INTR_CTRL_INTC_ASSERT 0x0010
+#define INTR_CTRL_INTC_DEASSERT 0x0020
+#define INTR_CTRL_INTD_ASSERT 0x0040
+#define INTR_CTRL_INTD_DEASSERT 0x0080
+#define INTR_CTRL_AER 0x0100
+#define INTR_CTRL_PME 0x0200
+#define INTR_CTRL_HP 0x0400
+#define INTR_CTRL_LINK_AUTO_BW 0x0800
+#define INTR_CTRL_MSI 0x1000
+static irqreturn_t ls1024a_pcie_msi_handler(int irq, void *arg)
+{
+ struct pcie_port *pp = arg;
+ struct ls1024a_pcie *ls1024a_pcie = to_ls1024a_pcie(pp);
+ irqreturn_t ret = IRQ_NONE;
+ u32 status = 0;
+
+ regmap_read(ls1024a_pcie->app, app_regs[ls1024a_pcie->app_profile].intr_sts, &status);
+ if (status & INTR_CTRL_MSI) {
+ regmap_write(ls1024a_pcie->app, app_regs[ls1024a_pcie->app_profile].intr_sts, INTR_CTRL_MSI);
+ status &= ~INTR_CTRL_MSI;
+ ret = dw_handle_msi_irq(pp);
+ }
+ regmap_write(ls1024a_pcie->app, app_regs[ls1024a_pcie->app_profile].intr_sts, status);
+ if (status)
+ return IRQ_NONE;
+ else
+ return ret;
+
+}
+
+static int ls1024a_pcie_wait_for_link(struct pcie_port *pp)
+{
+ int count = 200;
+
+ while (!dw_pcie_link_up(pp)) {
+ usleep_range(100, 1000);
+ if (--count)
+ continue;
+
+ dev_err(pp->dev, "phy link never came up\n");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+/* Port Logic Registers */
+#define PCIE_ALRT_REG 0x700
+#define PCIE_AFL0L1_REG 0x70C
+#define PCIE_SYMNUM_REG 0x718
+#define PCIE_G2CTRL_REG 0x80C
+
+#define PCIE_CAP_BASE 0x70
+#define PCIE_LCAP_REG (PCIE_CAP_BASE + 0x0C)
+#define PCIE_LCNT2_REG (PCIE_CAP_BASE + 0x30)
+
+static void ls1024a_pcie_host_init(struct pcie_port *pp)
+{
+ struct ls1024a_pcie *ls1024a_pcie = to_ls1024a_pcie(pp);
+ int ret;
+ u32 val;
+
+ ret = reset_control_deassert(ls1024a_pcie->axi_rst);
+ ret = phy_init(ls1024a_pcie->phy);
+ /* TODO: Do we really need this delay */
+ mdelay(1); //After CMU locks wait for sometime
+
+ /* TODO: PCIe_SATA_RST_CNTRL */
+#define CFG5_APP_INIT_RST 0x01
+#define CFG5_LTSSM_ENABLE 0x02
+ //Hold the LTSSM in detect state
+ regmap_update_bits(ls1024a_pcie->app, app_regs[ls1024a_pcie->app_profile].cfg5, CFG5_LTSSM_ENABLE, 0);
+
+ //FIXME : Bit:27 definition is not clear from document
+ // This register setting is copied from simulation code.
+ regmap_update_bits(ls1024a_pcie->app, app_regs[ls1024a_pcie->app_profile].cfg0, 0x08007FF0, 0x08007FF0);
+
+ val = readl(pp->dbi_base + PCIE_AFL0L1_REG);
+ val &= ~(0x00FFFF00);
+ val |= 0x00F1F100;
+ writel(val, pp->dbi_base + PCIE_AFL0L1_REG);
+
+ if(0) // if (pcie_gen1_only)
+ {
+ writel(0x1, pp->dbi_base + PCIE_LCNT2_REG);
+ writel(0x1, pp->dbi_base + PCIE_LCAP_REG);
+ }
+ else
+ {
+ val = readl(pp->dbi_base + PCIE_G2CTRL_REG);
+ val &= ~(0xFF);
+ val |= 0xF1;
+ writel(val, pp->dbi_base + PCIE_G2CTRL_REG);
+
+ // instruct pcie to switch to gen2 after init
+ val = readl(pp->dbi_base + PCIE_G2CTRL_REG);
+ val |= (1 << 17);
+ writel(val, pp->dbi_base + PCIE_G2CTRL_REG);
+ }
+
+ dw_pcie_setup_rc(pp);
+
+ //Enable LTSSM to start link initialization
+ regmap_update_bits(ls1024a_pcie->app, app_regs[ls1024a_pcie->app_profile].cfg5,
+ (CFG5_APP_INIT_RST | CFG5_LTSSM_ENABLE),
+ (CFG5_APP_INIT_RST | CFG5_LTSSM_ENABLE));
+
+ ls1024a_pcie_wait_for_link(&ls1024a_pcie->pp);
+
+ if (IS_ENABLED(CONFIG_PCI_MSI))
+ dw_pcie_msi_init(pp);
+
+}
+
+#define STS0_RDLH_LINK_UP 0x10000
+static int ls1024a_pcie_link_up(struct pcie_port *pp)
+{
+ struct ls1024a_pcie *ls1024a_pcie = to_ls1024a_pcie(pp);
+ u32 rc = 0;
+
+ regmap_read(ls1024a_pcie->app, app_regs[ls1024a_pcie->app_profile].sts0, &rc);
+ return !!(rc & STS0_RDLH_LINK_UP);
+}
+
+static struct pcie_host_ops ls1024a_pcie_host_ops = {
+ .link_up = ls1024a_pcie_link_up,
+ .host_init = ls1024a_pcie_host_init,
+};
+
+static int __init ls1024a_add_pcie_port(struct pcie_port *pp,
+ struct platform_device *pdev)
+{
+ int ret;
+
+ if (IS_ENABLED(CONFIG_PCI_MSI)) {
+ pp->msi_irq = platform_get_irq_byname(pdev, "msi");
+ if (pp->msi_irq <= 0) {
+ dev_err(&pdev->dev, "failed to get MSI irq\n");
+ return -ENODEV;
+ }
+
+ ret = devm_request_irq(&pdev->dev, pp->msi_irq,
+ ls1024a_pcie_msi_handler,
+ IRQF_SHARED, "ls1024a-pcie-msi", pp);
+ if (ret) {
+ dev_err(&pdev->dev, "failed to request MSI irq\n");
+ return -ENODEV;
+ }
+ }
+
+ pp->root_bus_nr = -1;
+ pp->ops = &ls1024a_pcie_host_ops;
+
+ ret = dw_pcie_host_init(pp);
+ if (ret) {
+ dev_err(&pdev->dev, "failed to initialize host\n");
+ return ret;
+ }
+
+ return 0;
+}
+
+static int __init ls1024a_pcie_probe(struct platform_device *pdev)
+{
+ struct ls1024a_pcie *ls1024a_pcie;
+ struct pcie_port *pp;
+ struct device_node *np = pdev->dev.of_node;
+ struct resource *dbi_base;
+ int ret;
+
+ ls1024a_pcie = devm_kzalloc(&pdev->dev, sizeof(*ls1024a_pcie), GFP_KERNEL);
+ if (!ls1024a_pcie)
+ return -ENOMEM;
+
+ pp = &ls1024a_pcie->pp;
+ pp->dev = &pdev->dev;
+
+ /* Added for PCI abort handling */
+#if 0
+ hook_fault_code(16 + 6, ls1024aq_pcie_abort_handler, SIGBUS, 0,
+ "imprecise external abort");
+#endif
+
+ dbi_base = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dbi");
+ pp->dbi_base = devm_ioremap_resource(&pdev->dev, dbi_base);
+ if (IS_ERR(pp->dbi_base))
+ return PTR_ERR(pp->dbi_base);
+#if 0
+ app = platform_get_resource_byname(pdev, IORESOURCE_MEM, "app");
+ ls1024a_pcie->app = devm_ioremap_resource(&pdev->dev, app);
+ if (IS_ERR(ls1024a_pcie->app))
+ return PTR_ERR(ls1024a_pcie->app);
+#endif
+
+ ls1024a_pcie->app = syscon_regmap_lookup_by_phandle(np, "app-syscon");
+ if (IS_ERR(ls1024a_pcie->app)) {
+ dev_err(&pdev->dev,
+ "Error retrieving pci_sata_usb_ctrl syscon\n");
+ return PTR_ERR(ls1024a_pcie->app);
+ }
+
+ ls1024a_pcie->app_profile = 0;
+ of_property_read_u32(np, "app-profile", &ls1024a_pcie->app_profile);
+ /* Fetch clocks */
+ ls1024a_pcie->pcie = devm_clk_get(&pdev->dev, "pcie");
+ if (IS_ERR(ls1024a_pcie->pcie)) {
+ dev_err(&pdev->dev,
+ "pcie clock source missing or invalid\n");
+ return PTR_ERR(ls1024a_pcie->pcie);
+ }
+ ls1024a_pcie->phy = devm_of_phy_get(pp->dev, np, NULL);
+ if (IS_ERR(ls1024a_pcie->phy)) {
+ ret = PTR_ERR(ls1024a_pcie->phy);
+ if (ret == -EPROBE_DEFER) {
+ return ret;
+ } else if (ret != -ENOSYS && ret != -ENODEV) {
+ dev_err(pp->dev,
+ "Error retrieving PCIe phy: %d\n", ret);
+ return ret;
+ }
+ }
+
+ ls1024a_pcie->axi_rst = devm_reset_control_get(pp->dev, "axi");
+ if (IS_ERR(ls1024a_pcie->axi_rst))
+ return PTR_ERR(ls1024a_pcie->axi_rst);
+
+ ls1024a_pcie->gpiod_reset = devm_gpiod_get_optional(pp->dev, "reset", GPIOD_OUT_LOW);
+ if (IS_ERR(ls1024a_pcie->gpiod_reset)) {
+ ls1024a_pcie->gpiod_reset = 0;
+ }
+ if (ls1024a_pcie->gpiod_reset) {
+ pr_err("Pulsing GPIO reset line\n");
+ gpiod_set_value(ls1024a_pcie->gpiod_reset, 1);
+ msleep(1);
+ gpiod_set_value(ls1024a_pcie->gpiod_reset, 0);
+ msleep(1);
+ }
+ /* TODO */
+#define CFG0_DEV_TYPE_RC 0x04
+ regmap_update_bits(ls1024a_pcie->app, app_regs[ls1024a_pcie->app_profile].cfg0, 0xf, CFG0_DEV_TYPE_RC);
+
+ ret = ls1024a_add_pcie_port(pp, pdev);
+ if (ret < 0)
+ return ret;
+ /* TODO */
+ regmap_update_bits(ls1024a_pcie->app, app_regs[ls1024a_pcie->app_profile].intr_en, INTR_CTRL_INTA_ASSERT, INTR_CTRL_INTA_ASSERT);
+ regmap_update_bits(ls1024a_pcie->app, app_regs[ls1024a_pcie->app_profile].intr_en, INTR_CTRL_MSI, INTR_CTRL_MSI);
+
+ platform_set_drvdata(pdev, ls1024a_pcie);
+ return 0;
+}
+
+static const struct of_device_id ls1024a_pcie_of_match[] = {
+ { .compatible = "fsl,ls1024a-pcie", },
+ {},
+};
+MODULE_DEVICE_TABLE(of, ls1024a_pcie_of_match);
+
+static struct platform_driver ls1024a_pcie_driver = {
+ .driver = {
+ .name = "ls1024a-pcie",
+ .of_match_table = ls1024a_pcie_of_match,
+ },
+};
+
+static int __init ls1024a_pcie_init(void)
+{
+ return platform_driver_probe(&ls1024a_pcie_driver, ls1024a_pcie_probe);
+}
+module_init(ls1024a_pcie_init);
+
+MODULE_AUTHOR("Daniel Mentz <danielmentz@google.com>");
+MODULE_DESCRIPTION("Freescale LS1024A PCIe host controller driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/pci/host/pcie-designware.c b/drivers/pci/host/pcie-designware.c
index 2e9f84f..836351e 100644
--- a/drivers/pci/host/pcie-designware.c
+++ b/drivers/pci/host/pcie-designware.c
@@ -158,6 +158,9 @@
.irq_unmask = pci_msi_unmask_irq,
};
+static void dw_pcie_msi_clear_irq(struct pcie_port *pp, int irq);
+static void dw_pcie_msi_set_irq(struct pcie_port *pp, int irq);
+
/* MSI int handler */
irqreturn_t dw_handle_msi_irq(struct pcie_port *pp)
{
@@ -174,9 +177,22 @@
while ((pos = find_next_bit(&val, 32, pos)) != 32) {
irq = irq_find_mapping(pp->irq_domain,
i * 32 + pos);
+ /* On the Freescale LS1024A (formerly Mindspeed
+ * Comcerto 2000) SoC, it appears to be
+ * necessary for the interrupt to be masked
+ * while we clear it. We found this workaround
+ * in the source code provided by Mindspeed.
+ * They added the following comment:
+ *
+ * FIXME : WA for bz69520
+ * To avoid race condition during avk the interrupt disabling interrupt before
+ * Ack and enabling after Ack.
+ */
+ dw_pcie_msi_clear_irq(pp, i * 32 + pos);
dw_pcie_wr_own_conf(pp,
PCIE_MSI_INTR0_STATUS + i * 12,
4, 1 << pos);
+ dw_pcie_msi_set_irq(pp, i * 32 + pos);
generic_handle_irq(irq);
pos++;
}
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 993ff22..05195da 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -1945,6 +1945,7 @@
pci_bus_assign_domain_nr(b, parent);
b2 = pci_find_bus(pci_domain_nr(b), bus);
if (b2) {
+ dump_stack();
/* If we already got to this bus through a different bridge, ignore it */
dev_dbg(&b2->dev, "bus already known\n");
goto err_out;
diff --git a/drivers/phy/Kconfig b/drivers/phy/Kconfig
index fc9b9f0..0d67d05 100644
--- a/drivers/phy/Kconfig
+++ b/drivers/phy/Kconfig
@@ -313,4 +313,29 @@
help
Support for UFS PHY on QCOM chipsets.
+config PHY_LS1024A_SNOWBUSH
+ tristate "LS1024A Snowbush PHY driver"
+ depends on OF && ARCH_COMCERTO
+ select GENERIC_PHY
+ help
+ Support for Snowbush PHY in Freescale's LS1024A. This is required for
+ PCIe and SATA support.
+
+config PHY_LS1024A_USB2
+ tristate "NXP QorIQ LS1024A USB2 PHY driver"
+ depends on OF && ARCH_COMCERTO
+ select GENERIC_PHY
+ help
+ Support for USB2 PHY in NXP's QorIQ LS1024A. This is required
+ for USB2 support.
+
+config PHY_LS1024A_USB3
+ tristate "Freescale QorIQ LS1024A USB3 PHY driver"
+ depends on OF && ARCH_COMCERTO
+ select GENERIC_PHY
+ help
+ Support for USB3 PHY in Freescale's QorIQ LS1024A. This is required
+ for USB3 support.
+
+
endmenu
diff --git a/drivers/phy/Makefile b/drivers/phy/Makefile
index f126251..9e523ff 100644
--- a/drivers/phy/Makefile
+++ b/drivers/phy/Makefile
@@ -40,3 +40,6 @@
obj-$(CONFIG_PHY_QCOM_UFS) += phy-qcom-ufs.o
obj-$(CONFIG_PHY_QCOM_UFS) += phy-qcom-ufs-qmp-20nm.o
obj-$(CONFIG_PHY_QCOM_UFS) += phy-qcom-ufs-qmp-14nm.o
+obj-$(CONFIG_PHY_LS1024A_SNOWBUSH) += phy-snowbush.o
+obj-$(CONFIG_PHY_LS1024A_USB2) += phy-ls1024a-usb2.o
+obj-$(CONFIG_PHY_LS1024A_USB3) += phy-ls1024a-usb3.o
diff --git a/drivers/phy/phy-ls1024a-usb2.c b/drivers/phy/phy-ls1024a-usb2.c
new file mode 100644
index 0000000..d177239
--- /dev/null
+++ b/drivers/phy/phy-ls1024a-usb2.c
@@ -0,0 +1,173 @@
+/*
+ * PHY driver for NXP QorIQ LS1024A USB 2.0 OTG PHY
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/mfd/syscon.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/phy/phy.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/reset.h>
+#include <linux/io.h>
+
+#define USB0_PHY_CTRL_REG0 0x000
+#define DWC_CFG_REGF 0x03C
+
+struct ls1024a_usb2_otg_phy {
+ struct phy *phy;
+ struct clk *clk;
+ void __iomem *reg;
+ struct regmap *pci_sata_usb_ctrl_reg;
+ struct reset_control *rstc_phy;
+ struct reset_control *rstc_utmi;
+ struct reset_control *rstc_axi;
+};
+
+static int ls1024a_usb2_otg_phy_init(struct phy *phy)
+{
+ struct ls1024a_usb2_otg_phy *lu2p = phy_get_drvdata(phy);
+ int ret;
+
+ ret = clk_prepare_enable(lu2p->clk);
+ if (ret)
+ return ret;
+
+ /*
+ * DWC_CFG_REGF
+ *
+ * Bit[8]: USB0_iddig select line either from PHY utmiotg_iddig or from
+ * the register bit:
+ * 0: Selects iddig from PHY.
+ * 1: Selects from the register bit (Bit[9])
+ * Bit[9]:Sets whether the connected plug is a mini-A or mini-B plug RW
+ * if usb0_id_sel register is programmed to be 1:
+ * 0: sets Mini-A
+ * 1: sets Mini-B
+ *
+ * Bit[12] and Bit[13] are the equivalents of Bit[8] and Bit[9] for the
+ * second USB port. (The LS1024A has only one USB2.0 port anyway)
+ *
+ * We force both ports to Mini-A because we always operate in host
+ * mode. Also, we are not using Mini-USB connectors in the first place.
+ * All our boards have Type A receptacles.
+ */
+ regmap_update_bits(lu2p->pci_sata_usb_ctrl_reg, DWC_CFG_REGF, 0x0000FF00, 0x00001100);
+
+ reset_control_assert(lu2p->rstc_utmi);
+ reset_control_assert(lu2p->rstc_phy);
+ reset_control_assert(lu2p->rstc_axi);
+
+ reset_control_deassert(lu2p->rstc_phy);
+ reset_control_deassert(lu2p->rstc_utmi);
+ reset_control_deassert(lu2p->rstc_axi);
+
+ return 0;
+}
+
+static int ls1024a_usb2_otg_phy_exit(struct phy *phy)
+{
+ struct ls1024a_usb2_otg_phy *lu2p = phy_get_drvdata(phy);
+
+ reset_control_assert(lu2p->rstc_utmi);
+ reset_control_assert(lu2p->rstc_phy);
+ reset_control_assert(lu2p->rstc_axi);
+
+ clk_disable_unprepare(lu2p->clk);
+
+ return 0;
+}
+
+static const struct phy_ops ls1024a_usb2_otg_phy_ops = {
+ .init = ls1024a_usb2_otg_phy_init,
+ .exit = ls1024a_usb2_otg_phy_exit,
+ .owner = THIS_MODULE,
+};
+
+static int ls1024a_usb2_otg_phy_probe(struct platform_device *pdev)
+{
+ struct phy_provider *phy_provider;
+ struct ls1024a_usb2_otg_phy *lu2p;
+ struct resource *res;
+
+ lu2p = devm_kzalloc(&pdev->dev, sizeof(*lu2p), GFP_KERNEL);
+ if (!lu2p)
+ return -ENOMEM;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ lu2p->reg = devm_ioremap_resource(&pdev->dev, res);
+ if (IS_ERR(lu2p->reg)) {
+ dev_err(&pdev->dev, "Failed to map register memory (phy)\n");
+ return PTR_ERR(lu2p->reg);
+ }
+
+ lu2p->pci_sata_usb_ctrl_reg =
+ syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "syscon");
+ if (IS_ERR(lu2p->pci_sata_usb_ctrl_reg)) {
+ dev_err(&pdev->dev, "Failed to get pci_sata_usb_ctrl syscon regmap\n");
+ return PTR_ERR(lu2p->pci_sata_usb_ctrl_reg);
+ }
+
+ lu2p->clk = devm_clk_get(&pdev->dev, "usb");
+ if (IS_ERR(lu2p->clk)) {
+ dev_err(&pdev->dev, "Failed to get clock of phy controller\n");
+ return PTR_ERR(lu2p->clk);
+ }
+
+ lu2p->rstc_phy = devm_reset_control_get(&pdev->dev, "phy");
+ if (IS_ERR(lu2p->rstc_phy)) {
+ dev_err(&pdev->dev, "Failed to get phy reset control\n");
+ return PTR_ERR(lu2p->rstc_phy);
+ }
+
+ lu2p->rstc_utmi = devm_reset_control_get(&pdev->dev, "utmi");
+ if (IS_ERR(lu2p->rstc_utmi)) {
+ dev_err(&pdev->dev, "Failed to get utmi reset control\n");
+ return PTR_ERR(lu2p->rstc_utmi);
+ }
+
+ lu2p->rstc_axi = devm_reset_control_get(&pdev->dev, "axi");
+ if (IS_ERR(lu2p->rstc_axi)) {
+ dev_err(&pdev->dev, "Failed to get axi reset control\n");
+ return PTR_ERR(lu2p->rstc_axi);
+ }
+
+ lu2p->phy = devm_phy_create(&pdev->dev, NULL, &ls1024a_usb2_otg_phy_ops);
+ if (IS_ERR(lu2p->phy)) {
+ dev_err(&pdev->dev, "Failed to create phy\n");
+ return PTR_ERR(lu2p->phy);
+ }
+
+ phy_set_drvdata(lu2p->phy, lu2p);
+
+ phy_provider = devm_of_phy_provider_register(&pdev->dev,
+ of_phy_simple_xlate);
+
+ return PTR_ERR_OR_ZERO(phy_provider);
+}
+
+static const struct of_device_id ls1024a_usb2_otg_phy_match[] = {
+ { .compatible = "fsl,ls1024a-usb2-phy", },
+ { },
+};
+MODULE_DEVICE_TABLE(of, ls1024a_usb2_otg_phy_match);
+
+static struct platform_driver ls1024a_usb2_otg_phy_driver = {
+ .probe = ls1024a_usb2_otg_phy_probe,
+ .driver = {
+ .name = "ls1024a-usb2-phy",
+ .of_match_table = ls1024a_usb2_otg_phy_match,
+ },
+};
+module_platform_driver(ls1024a_usb2_otg_phy_driver);
+
+MODULE_DESCRIPTION("NXP QorIQ LS1024A USB2 PHY");
+MODULE_AUTHOR("Daniel Mentz <danielmentz@google.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/phy/phy-ls1024a-usb3.c b/drivers/phy/phy-ls1024a-usb3.c
new file mode 100644
index 0000000..274ac0b
--- /dev/null
+++ b/drivers/phy/phy-ls1024a-usb3.c
@@ -0,0 +1,132 @@
+/*
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2 or later. This program is licensed "as is"
+ * without any warranty of any kind, whether express or implied.
+ */
+
+#include <dt-bindings/phy/phy.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/phy/phy.h>
+#include <linux/platform_device.h>
+#include <linux/reset.h>
+
+struct ls1024a_usb3_phy {
+ struct phy *phy;
+ void __iomem *reg;
+ struct reset_control *rstc;
+};
+
+static int ls1024a_usb_phy_init(struct phy *phy)
+{
+ struct ls1024a_usb3_phy *lu_phy;
+ u32 val;
+
+ lu_phy = phy_get_drvdata(phy);
+ if (!lu_phy)
+ return -ENODEV;
+
+ if (!reset_control_status(lu_phy->rstc)) {
+ reset_control_assert(lu_phy->rstc);
+ udelay(1000);
+ }
+
+ writel(0x00E00080, lu_phy->reg + 0x10);
+
+ /* TODO: Support 48 MHz refclock and external clock */
+#if 0
+ //Configuration for internal clock
+ if(usb3_clk_internal)
+ {
+ printk(KERN_INFO "USB3.0 clock selected: internal\n", __func__);
+
+ if(HAL_get_ref_clk() == REF_CLK_24MHZ)
+#endif
+ val = 0x420E82A8;
+#if 0
+ else
+ val = 0x420E82A9;
+ }
+ else
+ {
+ val = 0x4209927A;
+ printk(KERN_INFO "USB3.0 clock selected: external\n", __func__);
+ }
+#endif
+
+ writel(val, lu_phy->reg + 0x20);
+ writel(0x69C34F53, lu_phy->reg + 0x24);
+ writel(0x0005D815, lu_phy->reg + 0x28);
+ writel(0x00000801, lu_phy->reg + 0x2C);
+
+ reset_control_deassert(lu_phy->rstc);
+ udelay(1000);
+
+ return 0;
+}
+
+static struct phy_ops ls1024a_usb_phy_ops = {
+ .init = ls1024a_usb_phy_init,
+ .owner = THIS_MODULE,
+};
+
+static int ls1024a_usb_phy_probe(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct phy *phy;
+ struct phy_provider *phy_provider;
+ void __iomem *reg;
+ struct reset_control *rstc;
+ struct resource *res;
+ struct ls1024a_usb3_phy *lu_phy;
+
+ lu_phy = devm_kzalloc(dev, sizeof(*lu_phy), GFP_KERNEL);
+ if (!lu_phy)
+ return -ENOMEM;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ reg = devm_ioremap_resource(&pdev->dev, res);
+ if (IS_ERR(reg))
+ return PTR_ERR(reg);
+
+ rstc = devm_reset_control_get(&pdev->dev, "phy");
+ if (IS_ERR(rstc))
+ return PTR_ERR(rstc);
+
+ phy = devm_phy_create(dev, NULL, &ls1024a_usb_phy_ops);
+ if (IS_ERR(phy))
+ return PTR_ERR(phy);
+
+ lu_phy->phy = phy;
+ lu_phy->reg = reg;
+ lu_phy->rstc = rstc;
+
+ dev_set_drvdata(dev, lu_phy);
+ phy_set_drvdata(phy, lu_phy);
+
+ phy_provider = devm_of_phy_provider_register(&pdev->dev,
+ of_phy_simple_xlate);
+ return PTR_ERR_OR_ZERO(phy_provider);
+}
+
+static const struct of_device_id phy_of_match[] = {
+ { .compatible = "fsl,ls1024a-usb3-phy", },
+ { /* end of list */ },
+};
+MODULE_DEVICE_TABLE(of, phy_of_match);
+
+static struct platform_driver ls1024a_usb_phy_driver = {
+ .probe = ls1024a_usb_phy_probe,
+ .driver = {
+ .of_match_table = phy_of_match,
+ .name = "ls1024a-usb3-phy",
+ .owner = THIS_MODULE,
+ }
+};
+module_platform_driver(ls1024a_usb_phy_driver);
+
+MODULE_DESCRIPTION("Freescale QorIQ LS1024A USB3 PHY");
+MODULE_AUTHOR("Daniel Mentz <danielmentz@google.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/phy/phy-snowbush-regs.h b/drivers/phy/phy-snowbush-regs.h
new file mode 100644
index 0000000..7899897
--- /dev/null
+++ b/drivers/phy/phy-snowbush-regs.h
@@ -0,0 +1,1657 @@
+
+/*
+ * Copyright (C) Mindspeed Technologies, Inc. 2011. All rights reserved.
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ *
+ * @file serdes.h
+ * @brief this header file will contain all required data structure
+ * and function definitions for Snowbush SerDes PHY interface.
+ * @date 10/02/2011
+ */
+/* SER-DES Address space */
+
+
+struct serdes_regs_s
+{
+ unsigned short ofst;
+ unsigned short val;
+};
+
+ /* Initialize values of the Snowbush PHY (Serdes1) for SATA0 */
+
+/* 48MHz internal ref clock configuration */
+static struct serdes_regs_s sata_phy_reg_file_48[] __maybe_unused = {
+ { 0x000 << 2, 0x06},
+ { 0x001 << 2, 0x00},
+ { 0x002 << 2, 0x88},
+ { 0x003 << 2, 0x00},
+ { 0x004 << 2, 0x84},
+ { 0x005 << 2, 0x10},
+ { 0x006 << 2, 0x20},
+ { 0x007 << 2, 0x00},
+ { 0x008 << 2, 0x00},
+ { 0x009 << 2, 0x00},
+ { 0x00A << 2, 0x00},
+ { 0x00B << 2, 0x00},
+ { 0x00C << 2, 0x00},
+ { 0x00D << 2, 0x00},
+ { 0x00E << 2, 0x00},
+ { 0x00F << 2, 0x00},
+ { 0x010 << 2, 0x00},
+ { 0x011 << 2, 0x00},
+ { 0x012 << 2, 0x00},
+ { 0x013 << 2, 0x00},
+ { 0x014 << 2, 0x00},
+ { 0x015 << 2, 0x00},
+ { 0x016 << 2, 0x00},
+ { 0x017 << 2, 0x00},
+ { 0x018 << 2, 0x00},
+ { 0x019 << 2, 0x00},
+ { 0x01A << 2, 0x00},
+ { 0x01B << 2, 0x00},
+ { 0x01C << 2, 0x00},
+ { 0x01D << 2, 0x00},
+ { 0x01E << 2, 0x00},
+ { 0x01F << 2, 0x00},
+ { 0x020 << 2, 0x00},
+ { 0x021 << 2, 0x00},
+ { 0x022 << 2, 0xa0},
+ { 0x023 << 2, 0x62},
+ { 0x024 << 2, 0x00},
+ { 0x025 << 2, 0x00},
+ { 0x026 << 2, 0x00},
+ { 0x027 << 2, 0x00},
+ { 0x028 << 2, 0x00},
+ { 0x029 << 2, 0x00},
+ { 0x02A << 2, 0x00},
+ { 0x02B << 2, 0x00},
+ { 0x02C << 2, 0x00},
+ { 0x02D << 2, 0x00},
+ { 0x02E << 2, 0x04},
+ { 0x02F << 2, 0x50},
+ { 0x030 << 2, 0x70},
+ { 0x031 << 2, 0x02},
+ { 0x032 << 2, 0x25},
+ { 0x033 << 2, 0x40},
+ { 0x034 << 2, 0x01},
+ { 0x035 << 2, 0x40},
+ { 0x036 << 2, 0x00},
+ { 0x037 << 2, 0x00},
+ { 0x038 << 2, 0x00},
+ { 0x039 << 2, 0x00},
+ { 0x03A << 2, 0x00},
+ { 0x03B << 2, 0x00},
+ { 0x03C << 2, 0x00},
+ { 0x03D << 2, 0x00},
+ { 0x03E << 2, 0x00},
+ { 0x03F << 2, 0x00},
+ { 0x040 << 2, 0x00},
+ { 0x041 << 2, 0x00},
+ { 0x042 << 2, 0x00},
+ { 0x043 << 2, 0x00},
+ { 0x044 << 2, 0x00},
+ { 0x045 << 2, 0x00},
+ { 0x046 << 2, 0x00},
+ { 0x047 << 2, 0x00},
+ { 0x048 << 2, 0x00},
+ { 0x049 << 2, 0x00},
+ { 0x04A << 2, 0x00},
+ { 0x04B << 2, 0x00},
+ { 0x04C << 2, 0x00},
+ { 0x04D << 2, 0x00},
+ { 0x04E << 2, 0x00},
+ { 0x04F << 2, 0x00},
+ { 0x050 << 2, 0x00},
+ { 0x051 << 2, 0x00},
+ { 0x052 << 2, 0x00},
+ { 0x053 << 2, 0x00},
+ { 0x054 << 2, 0x00},
+ { 0x055 << 2, 0x00},
+ { 0x056 << 2, 0x00},
+ { 0x057 << 2, 0x00},
+ { 0x058 << 2, 0x00},
+ { 0x059 << 2, 0x00},
+ { 0x05A << 2, 0x00},
+ { 0x05B << 2, 0x00},
+ { 0x05C << 2, 0x00},
+ { 0x05D << 2, 0x00},
+ { 0x05E << 2, 0x00},
+ { 0x05F << 2, 0x00},
+ { 0x060 << 2, 0x00},
+ { 0x061 << 2, 0x2e},
+ { 0x062 << 2, 0x08},
+ { 0x063 << 2, 0x5e},
+ { 0x064 << 2, 0x00},
+ { 0x065 << 2, 0x42},
+ { 0x066 << 2, 0xd1},
+ { 0x067 << 2, 0xa0},
+ { 0x068 << 2, 0x28},
+ { 0x069 << 2, 0x78},
+ { 0x06A << 2, 0xcc},
+ { 0x06B << 2, 0xc1},
+ { 0x06C << 2, 0x4e},
+ { 0x06D << 2, 0x03},
+ { 0x06E << 2, 0x00},
+ { 0x06F << 2, 0x00},
+ { 0x070 << 2, 0x00},
+ { 0x071 << 2, 0x00},
+ { 0x072 << 2, 0x00},
+ { 0x200 << 2, 0x02},
+ { 0x201 << 2, 0x00},
+ { 0x202 << 2, 0x00},
+ { 0x203 << 2, 0x00},
+ { 0x204 << 2, 0x00},
+ { 0x205 << 2, 0x10},
+ { 0x206 << 2, 0x84},
+ { 0x207 << 2, 0x3C},
+ { 0x208 << 2, 0xe0},
+ { 0x210 << 2, 0x23},
+ { 0x211 << 2, 0x00},
+ { 0x212 << 2, 0x40},
+ { 0x213 << 2, 0x05},
+ { 0x214 << 2, 0x20},/* */
+ { 0x215 << 2, 0x17},
+ { 0x216 << 2, 0x00},
+ { 0x217 << 2, 0x68},
+ { 0x218 << 2, 0xe2},
+ { 0x219 << 2, 0x1e},
+ { 0x21A << 2, 0x18},
+ { 0x21B << 2, 0x0d},
+ { 0x21C << 2, 0x0c},
+ { 0x21D << 2, 0x00},
+ { 0x21E << 2, 0x00},
+ { 0x21F << 2, 0x00},
+ { 0x220 << 2, 0x00},
+ { 0x221 << 2, 0x00},
+ { 0x222 << 2, 0x00},
+ { 0x223 << 2, 0x00},
+ { 0x224 << 2, 0x00},
+ { 0x225 << 2, 0x00},
+ { 0x226 << 2, 0x00},
+ { 0x227 << 2, 0x00},
+ { 0x228 << 2, 0x00},
+ { 0x229 << 2, 0x00},
+ { 0x22A << 2, 0x00},
+ { 0x22B << 2, 0x00},
+ { 0x22C << 2, 0x00},
+ { 0x22D << 2, 0x00},
+ { 0x22E << 2, 0x00},
+ { 0x22F << 2, 0x00},
+ { 0x230 << 2, 0x00},
+ { 0x231 << 2, 0x00},
+ { 0x232 << 2, 0x00},
+ { 0x233 << 2, 0x00},
+ { 0x234 << 2, 0x00},
+ { 0x235 << 2, 0x00},
+ { 0x236 << 2, 0x00},
+ { 0x237 << 2, 0x00},
+ { 0x238 << 2, 0x00},
+ { 0x239 << 2, 0x00},
+ { 0x23A << 2, 0x00},
+ { 0x23B << 2, 0x00},
+ { 0x23C << 2, 0x00},
+ { 0x23D << 2, 0x00},
+ { 0x23E << 2, 0x00},
+ { 0x23F << 2, 0x00},
+ { 0x240 << 2, 0x00},
+ { 0x241 << 2, 0x00},
+ { 0x242 << 2, 0x00},
+ { 0x243 << 2, 0x00},
+ { 0x244 << 2, 0x00},
+ { 0x245 << 2, 0x00},
+ { 0x246 << 2, 0x00},
+ { 0x247 << 2, 0x00},
+ { 0x248 << 2, 0x00},
+ { 0x249 << 2, 0x00},
+ { 0x24A << 2, 0x00},
+ { 0x24B << 2, 0x00},
+ { 0x24C << 2, 0x00},
+ { 0x24D << 2, 0x00},
+ { 0x24E << 2, 0x00},
+ { 0x24F << 2, 0x00},
+ { 0x250 << 2, 0x60},
+ { 0x251 << 2, 0x0f},
+ { 0xA00 << 2, 0x00},
+ { 0xA01 << 2, 0x20},
+ { 0xA02 << 2, 0x00},
+ { 0xA03 << 2, 0x40},
+ { 0xA04 << 2, 0x24},
+ { 0xA05 << 2, 0xae},
+ { 0xA06 << 2, 0x19},
+ { 0xA07 << 2, 0x49},
+ { 0xA08 << 2, 0x04},
+ { 0xA09 << 2, 0xc3},
+ { 0xA0A << 2, 0x2a},
+ { 0xA0B << 2, 0xc6},
+ { 0xA0C << 2, 0x01},
+ { 0xA0D << 2, 0x03},
+ { 0xA0E << 2, 0x28},
+ { 0xA0F << 2, 0x98},
+ { 0xA10 << 2, 0x19},
+ { 0xA11 << 2, 0x00},
+ { 0xA12 << 2, 0x00},
+ { 0xA13 << 2, 0x80},
+ { 0xA14 << 2, 0xf0},
+ { 0xA15 << 2, 0xd0},
+ { 0xA16 << 2, 0x00},
+ { 0xA17 << 2, 0x00},
+ { 0xA30 << 2, 0x00},
+ { 0xA31 << 2, 0x00},
+ { 0xA32 << 2, 0x00},
+ { 0xA33 << 2, 0x00},
+ { 0xA34 << 2, 0x00},
+ { 0xA35 << 2, 0x00},
+ { 0xA36 << 2, 0x00},
+ { 0xA37 << 2, 0x00},
+ { 0xA38 << 2, 0x00},
+ { 0xA39 << 2, 0xa0},
+ { 0xA3A << 2, 0xa0},
+ { 0xA3B << 2, 0xa0},
+ { 0xA3C << 2, 0xa0},
+ { 0xA3D << 2, 0xa0},
+ { 0xA3E << 2, 0xa0},
+ { 0xA3F << 2, 0xa0},
+ { 0xA40 << 2, 0x62},
+ { 0xA41 << 2, 0x00},
+ { 0xA42 << 2, 0x80},
+ { 0xA43 << 2, 0x58},
+ { 0xA44 << 2, 0x00},
+ { 0xA45 << 2, 0x44},
+ { 0xA46 << 2, 0x5c},
+ { 0xA47 << 2, 0x86},
+ { 0xA48 << 2, 0x8d},
+ { 0xA49 << 2, 0xd0},
+ { 0xA4A << 2, 0x09},
+ { 0xA4B << 2, 0x90},
+ { 0xA4C << 2, 0x07},
+ { 0xA4D << 2, 0x40},
+ { 0xA4E << 2, 0x00},
+ { 0xA4F << 2, 0x00},
+ { 0xA50 << 2, 0x00},
+ { 0xA51 << 2, 0x20},
+ { 0xA52 << 2, 0x32},
+ { 0xA53 << 2, 0x00},
+ { 0xA54 << 2, 0x00},
+ { 0xA55 << 2, 0x00},
+ { 0xA56 << 2, 0x00},
+ { 0xA57 << 2, 0x00},
+ { 0xA58 << 2, 0x00},
+ { 0xA59 << 2, 0x00},
+ { 0xA5A << 2, 0x00},
+ { 0xA5B << 2, 0x00},
+ { 0xA5C << 2, 0x00},
+ { 0xA5D << 2, 0x00},
+ { 0xA5E << 2, 0x00},
+ { 0xA5F << 2, 0x00},
+ { 0xA60 << 2, 0x00},
+ { 0xA61 << 2, 0x00},
+ { 0xA62 << 2, 0x00},
+ { 0xA63 << 2, 0x00},
+ { 0xA64 << 2, 0x00},
+ { 0xA65 << 2, 0x00},
+ { 0xA66 << 2, 0x00},
+ { 0xA67 << 2, 0x00},
+ { 0xA68 << 2, 0x00},
+ { 0xA69 << 2, 0x00},
+ { 0xA6A << 2, 0x00},
+ { 0xA6B << 2, 0x00},
+ { 0xA6C << 2, 0x00},
+ { 0xA6D << 2, 0x00},
+ { 0xA6E << 2, 0x00},
+ { 0xA6F << 2, 0x00},
+ { 0xA70 << 2, 0x00},
+ { 0xA71 << 2, 0x00},
+ { 0xA72 << 2, 0x00},
+ { 0xA73 << 2, 0x00},
+ { 0xA74 << 2, 0x00},
+ { 0xA75 << 2, 0x00},
+ { 0xA76 << 2, 0x00},
+ { 0xA77 << 2, 0x00},
+ { 0xA78 << 2, 0x00},
+ { 0xA79 << 2, 0x00},
+ { 0xA7A << 2, 0x00},
+ { 0xA7B << 2, 0x00},
+ { 0xA7C << 2, 0x00},
+ { 0xA7D << 2, 0x00},
+ { 0xA7E << 2, 0x00},
+ { 0xA7F << 2, 0xd8},
+ { 0xA80 << 2, 0x1a},
+ { 0xA81 << 2, 0xff},
+ { 0xA82 << 2, 0x11},
+ { 0xA83 << 2, 0x00},
+ { 0xA84 << 2, 0x00},
+ { 0xA85 << 2, 0x00},
+ { 0xA86 << 2, 0x00},
+ { 0xA87 << 2, 0xf0},
+ { 0xA88 << 2, 0xff},
+ { 0xA89 << 2, 0xff},
+ { 0xA8A << 2, 0xff},
+ { 0xA8B << 2, 0xff},
+ { 0xA8C << 2, 0x1c},
+ { 0xA8D << 2, 0xc2},
+ { 0xA8E << 2, 0xc3},
+ { 0xA8F << 2, 0x3f},
+ { 0xA90 << 2, 0x0a},
+ { 0xA91 << 2, 0x00},
+ { 0xA92 << 2, 0x00},
+ { 0xA93 << 2, 0x00},
+ { 0xA94 << 2, 0x00},
+ { 0xA95 << 2, 0x00},
+ { 0xA96 << 2, 0xf8},
+ { 0x000 << 2, 0x07}
+};
+
+/* 24MHz internal ref clock configuration */
+static struct serdes_regs_s sata_phy_reg_file_24[] = {
+ { 0x000 << 2, 0x06},
+ { 0x001 << 2, 0x00},
+ { 0x002 << 2, 0x88},
+ { 0x003 << 2, 0x00},
+ { 0x004 << 2, 0x7b},
+ { 0x005 << 2, 0xc9},
+ { 0x006 << 2, 0x03},
+ { 0x007 << 2, 0x00},
+ { 0x008 << 2, 0x00},
+ { 0x009 << 2, 0x00},
+ { 0x00A << 2, 0x00},
+ { 0x00B << 2, 0x00},
+ { 0x00C << 2, 0x00},
+ { 0x00D << 2, 0x00},
+ { 0x00E << 2, 0x00},
+ { 0x00F << 2, 0x00},
+ { 0x010 << 2, 0x00},
+ { 0x011 << 2, 0x00},
+ { 0x012 << 2, 0x00},
+ { 0x013 << 2, 0x00},
+ { 0x014 << 2, 0x00},
+ { 0x015 << 2, 0x00},
+ { 0x016 << 2, 0x00},
+ { 0x017 << 2, 0x00},
+ { 0x018 << 2, 0x00},
+ { 0x019 << 2, 0x00},
+ { 0x01A << 2, 0x00},
+ { 0x01B << 2, 0x00},
+ { 0x01C << 2, 0x00},
+ { 0x01D << 2, 0x00},
+ { 0x01E << 2, 0x00},
+ { 0x01F << 2, 0x00},
+ { 0x020 << 2, 0x00},
+ { 0x021 << 2, 0x00},
+ { 0x022 << 2, 0xa0},
+ { 0x023 << 2, 0x54},
+ { 0x024 << 2, 0x00},
+ { 0x025 << 2, 0x00},
+ { 0x026 << 2, 0x00},
+ { 0x027 << 2, 0x00},
+ { 0x028 << 2, 0x00},
+ { 0x029 << 2, 0x00},
+ { 0x02A << 2, 0x00},
+ { 0x02B << 2, 0x00},
+ { 0x02C << 2, 0x00},
+ { 0x02D << 2, 0x00},
+ { 0x02E << 2, 0x04},
+ { 0x02F << 2, 0x50},
+ { 0x030 << 2, 0x70},
+ { 0x031 << 2, 0x02},
+ { 0x032 << 2, 0x25},
+ { 0x033 << 2, 0x40},
+ { 0x034 << 2, 0x01},
+ { 0x035 << 2, 0x40},
+ { 0x036 << 2, 0x00},
+ { 0x037 << 2, 0x00},
+ { 0x038 << 2, 0x00},
+ { 0x039 << 2, 0x00},
+ { 0x03A << 2, 0x00},
+ { 0x03B << 2, 0x00},
+ { 0x03C << 2, 0x00},
+ { 0x03D << 2, 0x00},
+ { 0x03E << 2, 0x00},
+ { 0x03F << 2, 0x00},
+ { 0x040 << 2, 0x00},
+ { 0x041 << 2, 0x00},
+ { 0x042 << 2, 0x00},
+ { 0x043 << 2, 0x00},
+ { 0x044 << 2, 0x00},
+ { 0x045 << 2, 0x00},
+ { 0x046 << 2, 0x00},
+ { 0x047 << 2, 0x00},
+ { 0x048 << 2, 0x00},
+ { 0x049 << 2, 0x00},
+ { 0x04A << 2, 0x00},
+ { 0x04B << 2, 0x00},
+ { 0x04C << 2, 0x00},
+ { 0x04D << 2, 0x00},
+ { 0x04E << 2, 0x00},
+ { 0x04F << 2, 0x00},
+ { 0x050 << 2, 0x00},
+ { 0x051 << 2, 0x00},
+ { 0x052 << 2, 0x00},
+ { 0x053 << 2, 0x00},
+ { 0x054 << 2, 0x00},
+ { 0x055 << 2, 0x00},
+ { 0x056 << 2, 0x00},
+ { 0x057 << 2, 0x00},
+ { 0x058 << 2, 0x00},
+ { 0x059 << 2, 0x00},
+ { 0x05A << 2, 0x00},
+ { 0x05B << 2, 0x00},
+ { 0x05C << 2, 0x00},
+ { 0x05D << 2, 0x00},
+ { 0x05E << 2, 0x00},
+ { 0x05F << 2, 0x00},
+ { 0x060 << 2, 0x00},
+ //{ 0x061 << 2, 0x2e}, //for Rev-A0 device
+ { 0x061 << 2, 0x2e}, //for Rev-A1 device
+ { 0x062 << 2, 0x00},
+ { 0x063 << 2, 0x5e},
+ { 0x064 << 2, 0x00},
+ { 0x065 << 2, 0x42},
+ { 0x066 << 2, 0xd1},
+ { 0x067 << 2, 0x20},
+ { 0x068 << 2, 0x28},
+ { 0x069 << 2, 0x78},
+ { 0x06A << 2, 0x2c},
+ { 0x06B << 2, 0xb9},
+ { 0x06C << 2, 0x5e},
+ { 0x06D << 2, 0x03},
+ { 0x06E << 2, 0x00},
+ { 0x06F << 2, 0x00},
+ { 0x070 << 2, 0x00},
+ { 0x071 << 2, 0x00},
+ { 0x072 << 2, 0x00},
+ { 0x200 << 2, 0x02},
+ { 0x201 << 2, 0x00},
+ { 0x202 << 2, 0x00},
+ { 0x203 << 2, 0x00},
+ { 0x204 << 2, 0x00},
+ { 0x205 << 2, 0x10},
+ { 0x206 << 2, 0x84},
+ { 0x207 << 2, 0x3c},
+ { 0x208 << 2, 0xe0},
+ { 0x210 << 2, 0x23},
+ { 0x211 << 2, 0x00},
+ { 0x212 << 2, 0x40},
+ { 0x213 << 2, 0x05},
+ { 0x214 << 2, 0xd0},/* */
+ { 0x215 << 2, 0x17},
+ { 0x216 << 2, 0x00},
+ { 0x217 << 2, 0x68},
+ { 0x218 << 2, 0xf2},
+ { 0x219 << 2, 0x1e},
+ { 0x21A << 2, 0x18},
+ { 0x21B << 2, 0x0d},
+ { 0x21C << 2, 0x0c},
+ { 0x21D << 2, 0x00},
+ { 0x21E << 2, 0x00},
+ { 0x21F << 2, 0x00},
+ { 0x220 << 2, 0x00},
+ { 0x221 << 2, 0x00},
+ { 0x222 << 2, 0x00},
+ { 0x223 << 2, 0x00},
+ { 0x224 << 2, 0x00},
+ { 0x225 << 2, 0x00},
+ { 0x226 << 2, 0x00},
+ { 0x227 << 2, 0x00},
+ { 0x228 << 2, 0x00},
+ { 0x229 << 2, 0x00},
+ { 0x22A << 2, 0x00},
+ { 0x22B << 2, 0x00},
+ { 0x22C << 2, 0x00},
+ { 0x22D << 2, 0x00},
+ { 0x22E << 2, 0x00},
+ { 0x22F << 2, 0x00},
+ { 0x230 << 2, 0x00},
+ { 0x231 << 2, 0x00},
+ { 0x232 << 2, 0x00},
+ { 0x233 << 2, 0x00},
+ { 0x234 << 2, 0x00},
+ { 0x235 << 2, 0x00},
+ { 0x236 << 2, 0x00},
+ { 0x237 << 2, 0x00},
+ { 0x238 << 2, 0x00},
+ { 0x239 << 2, 0x00},
+ { 0x23A << 2, 0x00},
+ { 0x23B << 2, 0x00},
+ { 0x23C << 2, 0x00},
+ { 0x23D << 2, 0x00},
+ { 0x23E << 2, 0x00},
+ { 0x23F << 2, 0x00},
+ { 0x240 << 2, 0x00},
+ { 0x241 << 2, 0x00},
+ { 0x242 << 2, 0x00},
+ { 0x243 << 2, 0x00},
+ { 0x244 << 2, 0x00},
+ { 0x245 << 2, 0x00},
+ { 0x246 << 2, 0x00},
+ { 0x247 << 2, 0x00},
+ { 0x248 << 2, 0x00},
+ { 0x249 << 2, 0x00},
+ { 0x24A << 2, 0x00},
+ { 0x24B << 2, 0x00},
+ { 0x24C << 2, 0x00},
+ { 0x24D << 2, 0x00},
+ { 0x24E << 2, 0x00},
+ { 0x24F << 2, 0x00},
+ { 0x250 << 2, 0x60},
+ { 0x251 << 2, 0x0f},
+ { 0xA00 << 2, 0x00},
+ { 0xA01 << 2, 0x20},
+ { 0xA02 << 2, 0x00},
+ { 0xA03 << 2, 0x40},
+ { 0xA04 << 2, 0x24},
+ { 0xA05 << 2, 0xae},
+ { 0xA06 << 2, 0x19},
+ { 0xA07 << 2, 0x49},
+ { 0xA08 << 2, 0x04},
+ { 0xA09 << 2, 0x83},
+ { 0xA0A << 2, 0x4b},
+ { 0xA0B << 2, 0xc5},
+ { 0xA0C << 2, 0x01},
+ { 0xA0D << 2, 0x03},
+ { 0xA0E << 2, 0x28},
+ { 0xA0F << 2, 0x98},
+ { 0xA10 << 2, 0x19},
+ { 0xA11 << 2, 0x00},
+ { 0xA12 << 2, 0x00},
+ { 0xA13 << 2, 0x80},
+ { 0xA14 << 2, 0xf0},
+ { 0xA15 << 2, 0xd0},
+ { 0xA16 << 2, 0x00},
+ { 0xA17 << 2, 0x00},
+ { 0xA30 << 2, 0x00},
+ { 0xA31 << 2, 0x00},
+ { 0xA32 << 2, 0x00},
+ { 0xA33 << 2, 0x00},
+ { 0xA34 << 2, 0x00},
+ { 0xA35 << 2, 0x00},
+ { 0xA36 << 2, 0x00},
+ { 0xA37 << 2, 0x00},
+ { 0xA38 << 2, 0x00},
+ { 0xA39 << 2, 0xa0},
+ { 0xA3A << 2, 0xa0},
+ { 0xA3B << 2, 0xa0},
+ { 0xA3C << 2, 0xa0},
+ { 0xA3D << 2, 0xa0},
+ { 0xA3E << 2, 0xa0},
+ { 0xA3F << 2, 0x54},
+ { 0xA40 << 2, 0x62},
+ { 0xA41 << 2, 0x00},
+ { 0xA42 << 2, 0x80},
+ { 0xA43 << 2, 0x58},
+ { 0xA44 << 2, 0x00},
+ { 0xA45 << 2, 0x44},
+ { 0xA46 << 2, 0x5c},
+ { 0xA47 << 2, 0x86},
+ { 0xA48 << 2, 0x8d},
+ { 0xA49 << 2, 0xd0},
+ { 0xA4A << 2, 0x09},
+ { 0xA4B << 2, 0x90},
+ { 0xA4C << 2, 0x07},
+ { 0xA4D << 2, 0x40},
+ { 0xA4E << 2, 0x00},
+ { 0xA4F << 2, 0x00},
+ { 0xA50 << 2, 0x00},
+ { 0xA51 << 2, 0x20},
+ { 0xA52 << 2, 0x32},
+ { 0xA53 << 2, 0x00},
+ { 0xA54 << 2, 0x00},
+ { 0xA55 << 2, 0x00},
+ { 0xA56 << 2, 0x00},
+ { 0xA57 << 2, 0x00},
+ { 0xA58 << 2, 0x00},
+ { 0xA59 << 2, 0x00},
+ { 0xA5A << 2, 0x00},
+ { 0xA5B << 2, 0x00},
+ { 0xA5C << 2, 0x00},
+ { 0xA5D << 2, 0x00},
+ { 0xA5E << 2, 0x00},
+ { 0xA5F << 2, 0x00},
+ { 0xA60 << 2, 0x00},
+ { 0xA61 << 2, 0x00},
+ { 0xA62 << 2, 0x00},
+ { 0xA63 << 2, 0x00},
+ { 0xA64 << 2, 0x00},
+ { 0xA65 << 2, 0x00},
+ { 0xA66 << 2, 0x00},
+ { 0xA67 << 2, 0x00},
+ { 0xA68 << 2, 0x00},
+ { 0xA69 << 2, 0x00},
+ { 0xA6A << 2, 0x00},
+ { 0xA6B << 2, 0x00},
+ { 0xA6C << 2, 0x00},
+ { 0xA6D << 2, 0x00},
+ { 0xA6E << 2, 0x00},
+ { 0xA6F << 2, 0x00},
+ { 0xA70 << 2, 0x00},
+ { 0xA71 << 2, 0x00},
+ { 0xA72 << 2, 0x00},
+ { 0xA73 << 2, 0x00},
+ { 0xA74 << 2, 0x00},
+ { 0xA75 << 2, 0x00},
+ { 0xA76 << 2, 0x00},
+ { 0xA77 << 2, 0x00},
+ { 0xA78 << 2, 0x00},
+ { 0xA79 << 2, 0x00},
+ { 0xA7A << 2, 0x00},
+ { 0xA7B << 2, 0x00},
+ { 0xA7C << 2, 0x00},
+ { 0xA7D << 2, 0x00},
+ { 0xA7E << 2, 0x00},
+ { 0xA7F << 2, 0xd8},
+ { 0xA80 << 2, 0x1a},
+ { 0xA81 << 2, 0xff},
+ { 0xA82 << 2, 0x11},
+ { 0xA83 << 2, 0x00},
+ { 0xA84 << 2, 0x00},
+ { 0xA85 << 2, 0x00},
+ { 0xA86 << 2, 0x00},
+ { 0xA87 << 2, 0xf0},
+ { 0xA88 << 2, 0xff},
+ { 0xA89 << 2, 0xff},
+ { 0xA8A << 2, 0xff},
+ { 0xA8B << 2, 0xff},
+ { 0xA8C << 2, 0x1c},
+ { 0xA8D << 2, 0xc2},
+ { 0xA8E << 2, 0xc3},
+ { 0xA8F << 2, 0x3f},
+ { 0xA90 << 2, 0x0a},
+ { 0xA91 << 2, 0x00},
+ { 0xA92 << 2, 0x00},
+ { 0xA93 << 2, 0x00},
+ { 0xA94 << 2, 0x00},
+ { 0xA95 << 2, 0x00},
+ { 0xA96 << 2, 0xf8},
+ { 0x000 << 2, 0x07}
+};
+
+/* PCIe SERDES is using internal clock */
+static struct serdes_regs_s pcie_phy_reg_file_48[] __maybe_unused = {
+ /* Common CMU block */
+ { 0x000 << 2, 0x06},
+ { 0x001 << 2, 0x00},
+ { 0x002 << 2, 0x09},
+ { 0x003 << 2, 0x00},
+ { 0x004 << 2, 0x60},
+ { 0x005 << 2, 0x09},
+ { 0x006 << 2, 0x0e},
+ { 0x007 << 2, 0x00},
+ { 0x008 << 2, 0x00},
+ { 0x009 << 2, 0x00},
+ { 0x00A << 2, 0x00},
+ { 0x00B << 2, 0x00},
+ { 0x00C << 2, 0x00},
+ { 0x00D << 2, 0x00},
+ { 0x00E << 2, 0x00},
+ { 0x00F << 2, 0x00},
+ { 0x010 << 2, 0x00},
+ { 0x011 << 2, 0x00},
+ { 0x012 << 2, 0x00},
+ { 0x013 << 2, 0x00},
+ { 0x014 << 2, 0x00},
+ { 0x015 << 2, 0x00},
+ { 0x016 << 2, 0x00},
+ { 0x017 << 2, 0x00},
+ { 0x018 << 2, 0x00},
+ { 0x019 << 2, 0x00},
+ { 0x01A << 2, 0x00},
+ { 0x01B << 2, 0x00},
+ { 0x01C << 2, 0x00},
+ { 0x01D << 2, 0x00},
+ { 0x01E << 2, 0x00},
+ { 0x01F << 2, 0x00},
+ { 0x020 << 2, 0x00},
+ { 0x021 << 2, 0x00},
+ { 0x022 << 2, 0xa0},
+ { 0x023 << 2, 0x6c},
+ { 0x024 << 2, 0x00},
+ { 0x025 << 2, 0x00},
+ { 0x026 << 2, 0x00},
+ { 0x027 << 2, 0x00},
+ { 0x028 << 2, 0x00},
+ { 0x029 << 2, 0x00},
+ { 0x02A << 2, 0x00},
+ { 0x02B << 2, 0x00},
+ { 0x02C << 2, 0x00},
+ { 0x02D << 2, 0x00},
+ { 0x02E << 2, 0x04},
+ { 0x02F << 2, 0x50},
+ { 0x030 << 2, 0x70},
+ { 0x031 << 2, 0x02},
+ { 0x032 << 2, 0x25},
+ { 0x033 << 2, 0x40},
+ { 0x034 << 2, 0x01},
+ { 0x035 << 2, 0x40},
+ { 0x036 << 2, 0x00},
+ { 0x037 << 2, 0x00},
+ { 0x038 << 2, 0x00},
+ { 0x039 << 2, 0x00},
+ { 0x03A << 2, 0x00},
+ { 0x03B << 2, 0x00},
+ { 0x03C << 2, 0x00},
+ { 0x03D << 2, 0x00},
+ { 0x03E << 2, 0x00},
+ { 0x03F << 2, 0x00},
+ { 0x040 << 2, 0x00},
+ { 0x041 << 2, 0x00},
+ { 0x042 << 2, 0x00},
+ { 0x043 << 2, 0x00},
+ { 0x044 << 2, 0x00},
+ { 0x045 << 2, 0x00},
+ { 0x046 << 2, 0x00},
+ { 0x047 << 2, 0x00},
+ { 0x048 << 2, 0x00},
+ { 0x049 << 2, 0x00},
+ { 0x04A << 2, 0x00},
+ { 0x04B << 2, 0x00},
+ { 0x04C << 2, 0x00},
+ { 0x04D << 2, 0x00},
+ { 0x04E << 2, 0x00},
+ { 0x04F << 2, 0x00},
+ { 0x050 << 2, 0x00},
+ { 0x051 << 2, 0x00},
+ { 0x052 << 2, 0x00},
+ { 0x053 << 2, 0x00},
+ { 0x054 << 2, 0x00},
+ { 0x055 << 2, 0x00},
+ { 0x056 << 2, 0x00},
+ { 0x057 << 2, 0x00},
+ { 0x058 << 2, 0x00},
+ { 0x059 << 2, 0x00},
+ { 0x05A << 2, 0x00},
+ { 0x05B << 2, 0x00},
+ { 0x05C << 2, 0x00},
+ { 0x05D << 2, 0x00},
+ { 0x05E << 2, 0x00},
+ { 0x05F << 2, 0x00},
+ { 0x060 << 2, 0x00},
+ { 0x061 << 2, 0x2e},
+ { 0x062 << 2, 0x08},
+ { 0x063 << 2, 0x5e},
+ { 0x064 << 2, 0x00},
+ { 0x065 << 2, 0x42},
+ { 0x066 << 2, 0xd1},
+ { 0x067 << 2, 0x90},
+ { 0x068 << 2, 0x08},
+ { 0x069 << 2, 0x90},
+ { 0x06A << 2, 0x2c},
+ { 0x06B << 2, 0x32},
+ { 0x06C << 2, 0x59},
+ { 0x06D << 2, 0x03},
+ { 0x06E << 2, 0x00},
+ { 0x06F << 2, 0x00},
+ { 0x070 << 2, 0x00},
+ { 0x071 << 2, 0x00},
+ { 0x072 << 2, 0x00},
+ /* Lane0 Block */
+ { 0x200 << 2, 0x00},
+ { 0x201 << 2, 0x00},
+ { 0x202 << 2, 0x00},
+ { 0x203 << 2, 0x00},
+ { 0x204 << 2, 0x00},
+ { 0x205 << 2, 0x10},
+ { 0x206 << 2, 0x84},
+ { 0x207 << 2, 0x04},
+ { 0x208 << 2, 0xe0},
+ { 0x210 << 2, 0x23},
+ { 0x211 << 2, 0x00},
+ { 0x212 << 2, 0x00},
+ { 0x213 << 2, 0x04},
+ { 0x214 << 2, 0xc0},
+ { 0x215 << 2, 0x18},
+ { 0x216 << 2, 0x00},
+ { 0x217 << 2, 0x68},
+ { 0x218 << 2, 0xa2},
+ { 0x219 << 2, 0x1e},
+ { 0x21A << 2, 0x18},
+ { 0x21B << 2, 0x0d},
+ { 0x21C << 2, 0x0d},
+ { 0x21D << 2, 0x00},
+ { 0x21E << 2, 0x00},
+ { 0x21F << 2, 0x00},
+ { 0x220 << 2, 0x00},
+ { 0x221 << 2, 0x00},
+ { 0x222 << 2, 0x00},
+ { 0x223 << 2, 0x00},
+ { 0x224 << 2, 0x00},
+ { 0x225 << 2, 0x00},
+ { 0x226 << 2, 0x00},
+ { 0x227 << 2, 0x00},
+ { 0x228 << 2, 0x00},
+ { 0x229 << 2, 0x00},
+ { 0x22A << 2, 0x00},
+ { 0x22B << 2, 0x00},
+ { 0x22C << 2, 0x00},
+ { 0x22D << 2, 0x00},
+ { 0x22E << 2, 0x00},
+ { 0x22F << 2, 0x00},
+ { 0x230 << 2, 0x00},
+ { 0x231 << 2, 0x00},
+ { 0x232 << 2, 0x00},
+ { 0x233 << 2, 0x00},
+ { 0x234 << 2, 0x00},
+ { 0x235 << 2, 0x00},
+ { 0x236 << 2, 0x00},
+ { 0x237 << 2, 0x00},
+ { 0x238 << 2, 0x00},
+ { 0x239 << 2, 0x00},
+ { 0x23A << 2, 0x00},
+ { 0x23B << 2, 0x00},
+ { 0x23C << 2, 0x00},
+ { 0x23D << 2, 0x00},
+ { 0x23E << 2, 0x00},
+ { 0x23F << 2, 0x00},
+ { 0x240 << 2, 0x00},
+ { 0x241 << 2, 0x00},
+ { 0x242 << 2, 0x00},
+ { 0x243 << 2, 0x00},
+ { 0x244 << 2, 0x00},
+ { 0x245 << 2, 0x00},
+ { 0x246 << 2, 0x00},
+ { 0x247 << 2, 0x00},
+ { 0x248 << 2, 0x00},
+ { 0x249 << 2, 0x00},
+ { 0x24A << 2, 0x00},
+ { 0x24B << 2, 0x00},
+ { 0x24C << 2, 0x00},
+ { 0x24D << 2, 0x00},
+ { 0x24E << 2, 0x00},
+ { 0x24F << 2, 0x00},
+ { 0x250 << 2, 0x60},
+ { 0x251 << 2, 0x0f},
+ /* Common Lane Block */
+ { 0xA00 << 2, 0xc0},
+ { 0xA01 << 2, 0x90},
+ { 0xA02 << 2, 0x02},
+ { 0xA03 << 2, 0x40},
+ { 0xA04 << 2, 0x3c},
+ { 0xA05 << 2, 0x00},
+ { 0xA06 << 2, 0x00},
+ { 0xA07 << 2, 0x00},
+ { 0xA08 << 2, 0x00},
+ { 0xA09 << 2, 0xc3},
+ { 0xA0A << 2, 0xca},
+ { 0xA0B << 2, 0xc6},
+ { 0xA0C << 2, 0x01},
+ { 0xA0D << 2, 0x03},
+ { 0xA0E << 2, 0x28},
+ { 0xA0F << 2, 0x98},
+ { 0xA10 << 2, 0x19},
+ { 0xA11 << 2, 0x28},
+ { 0xA12 << 2, 0x78},
+ { 0xA13 << 2, 0xe1},
+ { 0xA14 << 2, 0xf0},
+ { 0xA15 << 2, 0x10},
+ { 0xA16 << 2, 0xf4},
+ { 0xA17 << 2, 0x00},
+ { 0xA30 << 2, 0x00},
+ { 0xA31 << 2, 0x00},
+ { 0xA32 << 2, 0x00},
+ { 0xA33 << 2, 0x00},
+ { 0xA34 << 2, 0x00},
+ { 0xA35 << 2, 0x00},
+ { 0xA36 << 2, 0x00},
+ { 0xA37 << 2, 0x00},
+ { 0xA38 << 2, 0x00},
+ { 0xA39 << 2, 0xa0},
+ { 0xA3A << 2, 0xa0},
+ { 0xA3B << 2, 0xa0},
+ { 0xA3C << 2, 0xa0},
+ { 0xA3D << 2, 0xa0},
+ { 0xA3E << 2, 0xa0},
+ { 0xA3F << 2, 0xa0},
+ { 0xA40 << 2, 0x6c},
+ { 0xA41 << 2, 0x00},
+ { 0xA42 << 2, 0xc0},
+ { 0xA43 << 2, 0x9f},
+ { 0xA44 << 2, 0x01},
+ { 0xA45 << 2, 0x00},
+ { 0xA46 << 2, 0x00},
+ { 0xA47 << 2, 0x00},
+ { 0xA48 << 2, 0x00},
+ { 0xA49 << 2, 0x00},
+ { 0xA4A << 2, 0x00},
+ { 0xA4B << 2, 0x00},
+ { 0xA4C << 2, 0x30},
+ { 0xA4D << 2, 0x41},
+ { 0xA4E << 2, 0x7e},
+ { 0xA4F << 2, 0xd0},
+ { 0xA50 << 2, 0xcc},
+ { 0xA51 << 2, 0x85},
+ { 0xA52 << 2, 0x52},
+ { 0xA53 << 2, 0x93},
+ { 0xA54 << 2, 0xe0},
+ { 0xA55 << 2, 0x49},
+ { 0xA56 << 2, 0xdd},
+ { 0xA57 << 2, 0xb0},
+ { 0xA58 << 2, 0x0b},
+ { 0xA59 << 2, 0x02},
+ { 0xA5A << 2, 0x00},
+ { 0xA5B << 2, 0x00},
+ { 0xA5C << 2, 0x00},
+ { 0xA5D << 2, 0x00},
+ { 0xA5E << 2, 0x00},
+ { 0xA5F << 2, 0x00},
+ { 0xA60 << 2, 0x00},
+ { 0xA61 << 2, 0x00},
+ { 0xA62 << 2, 0x00},
+ { 0xA63 << 2, 0x00},
+ { 0xA64 << 2, 0x00},
+ { 0xA65 << 2, 0x00},
+ { 0xA66 << 2, 0x00},
+ { 0xA67 << 2, 0x00},
+ { 0xA68 << 2, 0x00},
+ { 0xA69 << 2, 0x00},
+ { 0xA6A << 2, 0x00},
+ { 0xA6B << 2, 0x00},
+ { 0xA6C << 2, 0x00},
+ { 0xA6D << 2, 0x00},
+ { 0xA6E << 2, 0x00},
+ { 0xA6F << 2, 0x00},
+ { 0xA70 << 2, 0x00},
+ { 0xA71 << 2, 0x00},
+ { 0xA72 << 2, 0x00},
+ { 0xA73 << 2, 0x00},
+ { 0xA74 << 2, 0x00},
+ { 0xA75 << 2, 0x00},
+ { 0xA76 << 2, 0x00},
+ { 0xA77 << 2, 0x00},
+ { 0xA78 << 2, 0x00},
+ { 0xA79 << 2, 0x00},
+ { 0xA7A << 2, 0x00},
+ { 0xA7B << 2, 0x00},
+ { 0xA7C << 2, 0x00},
+ { 0xA7D << 2, 0x00},
+ { 0xA7E << 2, 0x00},
+ { 0xA7F << 2, 0xd8},
+ { 0xA80 << 2, 0x1a},
+ { 0xA81 << 2, 0xff},
+ { 0xA82 << 2, 0x01},
+ { 0xA83 << 2, 0x00},
+ { 0xA84 << 2, 0x00},
+ { 0xA85 << 2, 0x00},
+ { 0xA86 << 2, 0x00},
+ { 0xA87 << 2, 0xf0},
+ { 0xA88 << 2, 0xff},
+ { 0xA89 << 2, 0xff},
+ { 0xA8A << 2, 0xff},
+ { 0xA8B << 2, 0xff},
+ { 0xA8C << 2, 0x1c},
+ { 0xA8D << 2, 0xc2},
+ { 0xA8E << 2, 0xc3},
+ { 0xA8F << 2, 0x3f},
+ { 0xA90 << 2, 0x0a},
+ { 0xA91 << 2, 0x00},
+ { 0xA92 << 2, 0x00},
+ { 0xA93 << 2, 0x00},
+ { 0xA94 << 2, 0x00},
+ { 0xA95 << 2, 0x00},
+ { 0xA96 << 2, 0xf8},
+ { 0x000 << 2, 0x07}
+};
+
+static struct serdes_regs_s pcie_phy_reg_file_100[] __maybe_unused = {
+ /* Common CMU block */
+ { 0x000 << 2, 0x06},
+ { 0x001 << 2, 0x00},
+ { 0x002 << 2, 0x09},
+ { 0x003 << 2, 0x00},
+ { 0x004 << 2, 0x00},
+ { 0x005 << 2, 0x00},
+ { 0x006 << 2, 0x00},
+ { 0x007 << 2, 0x00},
+ { 0x008 << 2, 0x00},
+ { 0x009 << 2, 0x00},
+ { 0x00A << 2, 0x00},
+ { 0x00B << 2, 0x00},
+ { 0x00C << 2, 0x00},
+ { 0x00D << 2, 0x00},
+ { 0x00E << 2, 0x00},
+ { 0x00F << 2, 0x00},
+ { 0x010 << 2, 0x00},
+ { 0x011 << 2, 0x00},
+ { 0x012 << 2, 0x00},
+ { 0x013 << 2, 0x00},
+ { 0x014 << 2, 0x00},
+ { 0x015 << 2, 0x00},
+ { 0x016 << 2, 0x00},
+ { 0x017 << 2, 0x00},
+ { 0x018 << 2, 0x00},
+ { 0x019 << 2, 0x00},
+ { 0x01A << 2, 0x00},
+ { 0x01B << 2, 0x00},
+ { 0x01C << 2, 0x00},
+ { 0x01D << 2, 0x00},
+ { 0x01E << 2, 0x00},
+ { 0x01F << 2, 0x00},
+ { 0x020 << 2, 0x00},
+ { 0x021 << 2, 0x00},
+ { 0x022 << 2, 0xa0},
+ { 0x023 << 2, 0x64},
+ { 0x024 << 2, 0x00},
+ { 0x025 << 2, 0x00},
+ { 0x026 << 2, 0x00},
+ { 0x027 << 2, 0x00},
+ { 0x028 << 2, 0x00},
+ { 0x029 << 2, 0x00},
+ { 0x02A << 2, 0x00},
+ { 0x02B << 2, 0x00},
+ { 0x02C << 2, 0x00},
+ { 0x02D << 2, 0x00},
+ { 0x02E << 2, 0x04},
+ { 0x02F << 2, 0x50},
+ { 0x030 << 2, 0x70},
+ { 0x031 << 2, 0x02},
+ { 0x032 << 2, 0x25},
+ { 0x033 << 2, 0x40},
+ { 0x034 << 2, 0x01},
+ { 0x035 << 2, 0x40},
+ { 0x036 << 2, 0x00},
+ { 0x037 << 2, 0x00},
+ { 0x038 << 2, 0x00},
+ { 0x039 << 2, 0x00},
+ { 0x03A << 2, 0x00},
+ { 0x03B << 2, 0x00},
+ { 0x03C << 2, 0x00},
+ { 0x03D << 2, 0x00},
+ { 0x03E << 2, 0x00},
+ { 0x03F << 2, 0x00},
+ { 0x040 << 2, 0x00},
+ { 0x041 << 2, 0x00},
+ { 0x042 << 2, 0x00},
+ { 0x043 << 2, 0x00},
+ { 0x044 << 2, 0x00},
+ { 0x045 << 2, 0x00},
+ { 0x046 << 2, 0x00},
+ { 0x047 << 2, 0x00},
+ { 0x048 << 2, 0x00},
+ { 0x049 << 2, 0x00},
+ { 0x04A << 2, 0x00},
+ { 0x04B << 2, 0x00},
+ { 0x04C << 2, 0x00},
+ { 0x04D << 2, 0x00},
+ { 0x04E << 2, 0x00},
+ { 0x04F << 2, 0x00},
+ { 0x050 << 2, 0x00},
+ { 0x051 << 2, 0x00},
+ { 0x052 << 2, 0x00},
+ { 0x053 << 2, 0x00},
+ { 0x054 << 2, 0x00},
+ { 0x055 << 2, 0x00},
+ { 0x056 << 2, 0x00},
+ { 0x057 << 2, 0x00},
+ { 0x058 << 2, 0x00},
+ { 0x059 << 2, 0x00},
+ { 0x05A << 2, 0x00},
+ { 0x05B << 2, 0x00},
+ { 0x05C << 2, 0x00},
+ { 0x05D << 2, 0x00},
+ { 0x05E << 2, 0x00},
+ { 0x05F << 2, 0x00},
+ { 0x060 << 2, 0x00},
+ { 0x061 << 2, 0x2e},//for Rev1 modified in code
+ { 0x062 << 2, 0x00},
+ { 0x063 << 2, 0x5e},
+ { 0x064 << 2, 0x00},
+ { 0x065 << 2, 0x42},
+ { 0x066 << 2, 0xd1},
+ { 0x067 << 2, 0x90},
+ { 0x068 << 2, 0x08},
+ { 0x069 << 2, 0x50},
+ { 0x06A << 2, 0x44},
+ { 0x06B << 2, 0xce},
+ { 0x06C << 2, 0x0b},
+ { 0x06D << 2, 0x00},
+ { 0x06E << 2, 0x00},
+ { 0x06F << 2, 0x00},
+ { 0x070 << 2, 0x00},
+ { 0x071 << 2, 0x00},
+ { 0x072 << 2, 0x00},
+ /* Lane0 Block */
+ { 0x200 << 2, 0x00},
+ { 0x201 << 2, 0x00},
+ { 0x202 << 2, 0x00},
+ { 0x203 << 2, 0x00},
+ { 0x204 << 2, 0x00},
+ { 0x205 << 2, 0x10},
+ { 0x206 << 2, 0x04},
+ { 0x207 << 2, 0x18},
+ { 0x208 << 2, 0xe0},
+ { 0x210 << 2, 0x23},
+ { 0x211 << 2, 0x00},
+ { 0x212 << 2, 0x00},
+ { 0x213 << 2, 0x03},
+ { 0x214 << 2, 0x3C},
+ { 0x215 << 2, 0x04},
+ { 0x216 << 2, 0x00},
+ { 0x217 << 2, 0x68},
+ { 0x218 << 2, 0xa2},
+ { 0x219 << 2, 0x1e},
+ { 0x21A << 2, 0x18},
+ { 0x21B << 2, 0x0d},
+ { 0x21C << 2, 0x0d},
+ { 0x21D << 2, 0x00},
+ { 0x21E << 2, 0x00},
+ { 0x21F << 2, 0x00},
+ { 0x220 << 2, 0x00},
+ { 0x221 << 2, 0x00},
+ { 0x222 << 2, 0x00},
+ { 0x223 << 2, 0x00},
+ { 0x224 << 2, 0x00},
+ { 0x225 << 2, 0x00},
+ { 0x226 << 2, 0x00},
+ { 0x227 << 2, 0x00},
+ { 0x228 << 2, 0x00},
+ { 0x229 << 2, 0x00},
+ { 0x22A << 2, 0x00},
+ { 0x22B << 2, 0x00},
+ { 0x22C << 2, 0x00},
+ { 0x22D << 2, 0x00},
+ { 0x22E << 2, 0x00},
+ { 0x22F << 2, 0x00},
+ { 0x230 << 2, 0x00},
+ { 0x231 << 2, 0x00},
+ { 0x232 << 2, 0x00},
+ { 0x233 << 2, 0x00},
+ { 0x234 << 2, 0x00},
+ { 0x235 << 2, 0x00},
+ { 0x236 << 2, 0x00},
+ { 0x237 << 2, 0x00},
+ { 0x238 << 2, 0x00},
+ { 0x239 << 2, 0x00},
+ { 0x23A << 2, 0x00},
+ { 0x23B << 2, 0x00},
+ { 0x23C << 2, 0x00},
+ { 0x23D << 2, 0x00},
+ { 0x23E << 2, 0x00},
+ { 0x23F << 2, 0x00},
+ { 0x240 << 2, 0x00},
+ { 0x241 << 2, 0x00},
+ { 0x242 << 2, 0x00},
+ { 0x243 << 2, 0x00},
+ { 0x244 << 2, 0x00},
+ { 0x245 << 2, 0x00},
+ { 0x246 << 2, 0x00},
+ { 0x247 << 2, 0x00},
+ { 0x248 << 2, 0x00},
+ { 0x249 << 2, 0x00},
+ { 0x24A << 2, 0x00},
+ { 0x24B << 2, 0x00},
+ { 0x24C << 2, 0x00},
+ { 0x24D << 2, 0x00},
+ { 0x24E << 2, 0x00},
+ { 0x24F << 2, 0x00},
+ { 0x250 << 2, 0xf6},
+ { 0x251 << 2, 0x03},
+ /* Common Lane Block */
+ { 0xA00 << 2, 0xc0},
+ { 0xA01 << 2, 0x90},
+ { 0xA02 << 2, 0x02},
+ { 0xA03 << 2, 0x40},
+ { 0xA04 << 2, 0x3c},
+ { 0xA05 << 2, 0x00},
+ { 0xA06 << 2, 0x00},
+ { 0xA07 << 2, 0x00},
+ { 0xA08 << 2, 0x00},
+ { 0xA09 << 2, 0x63},
+ { 0xA0A << 2, 0x49},
+ { 0xA0B << 2, 0xc6},
+ { 0xA0C << 2, 0x01},
+ { 0xA0D << 2, 0x03},
+ { 0xA0E << 2, 0x28},
+ { 0xA0F << 2, 0x98},
+ { 0xA10 << 2, 0x19},
+ { 0xA11 << 2, 0x28},
+ { 0xA12 << 2, 0x78},
+ { 0xA13 << 2, 0xe1},
+ { 0xA14 << 2, 0xf0},
+ { 0xA15 << 2, 0x10},
+ { 0xA16 << 2, 0xf4},
+ { 0xA17 << 2, 0x00},
+ { 0xA30 << 2, 0x00},
+ { 0xA31 << 2, 0x00},
+ { 0xA32 << 2, 0x00},
+ { 0xA33 << 2, 0x00},
+ { 0xA34 << 2, 0x00},
+ { 0xA35 << 2, 0x00},
+ { 0xA36 << 2, 0x00},
+ { 0xA37 << 2, 0x00},
+ { 0xA38 << 2, 0x00},
+ { 0xA39 << 2, 0xa0},
+ { 0xA3A << 2, 0xa0},
+ { 0xA3B << 2, 0xa0},
+ { 0xA3C << 2, 0xa0},
+ { 0xA3D << 2, 0xa0},
+ { 0xA3E << 2, 0xa0},
+ { 0xA3F << 2, 0xa0},
+ { 0xA40 << 2, 0x64},
+ { 0xA41 << 2, 0x00},
+ { 0xA42 << 2, 0xc0},
+ { 0xA43 << 2, 0x9f},
+ { 0xA44 << 2, 0x01},
+ { 0xA45 << 2, 0x00},
+ { 0xA46 << 2, 0x00},
+ { 0xA47 << 2, 0x00},
+ { 0xA48 << 2, 0x00},
+ { 0xA49 << 2, 0x00},
+ { 0xA4A << 2, 0x00},
+ { 0xA4B << 2, 0x00},
+ { 0xA4C << 2, 0x30},
+ { 0xA4D << 2, 0x41},
+ { 0xA4E << 2, 0x7e},
+ { 0xA4F << 2, 0xd0},
+ { 0xA50 << 2, 0xcc},
+ { 0xA51 << 2, 0x85},
+ { 0xA52 << 2, 0x52},
+ { 0xA53 << 2, 0x93},
+ { 0xA54 << 2, 0xe0},
+ { 0xA55 << 2, 0x49},
+ { 0xA56 << 2, 0xdd},
+ { 0xA57 << 2, 0xb0},
+ { 0xA58 << 2, 0x0b},
+ { 0xA59 << 2, 0x02},
+ { 0xA5A << 2, 0x00},
+ { 0xA5B << 2, 0x00},
+ { 0xA5C << 2, 0x00},
+ { 0xA5D << 2, 0x00},
+ { 0xA5E << 2, 0x00},
+ { 0xA5F << 2, 0x00},
+ { 0xA60 << 2, 0x00},
+ { 0xA61 << 2, 0x00},
+ { 0xA62 << 2, 0x00},
+ { 0xA63 << 2, 0x00},
+ { 0xA64 << 2, 0x00},
+ { 0xA65 << 2, 0x00},
+ { 0xA66 << 2, 0x00},
+ { 0xA67 << 2, 0x00},
+ { 0xA68 << 2, 0x00},
+ { 0xA69 << 2, 0x00},
+ { 0xA6A << 2, 0x00},
+ { 0xA6B << 2, 0x00},
+ { 0xA6C << 2, 0x00},
+ { 0xA6D << 2, 0x00},
+ { 0xA6E << 2, 0x00},
+ { 0xA6F << 2, 0x00},
+ { 0xA70 << 2, 0x00},
+ { 0xA71 << 2, 0x00},
+ { 0xA72 << 2, 0x00},
+ { 0xA73 << 2, 0x00},
+ { 0xA74 << 2, 0x00},
+ { 0xA75 << 2, 0x00},
+ { 0xA76 << 2, 0x00},
+ { 0xA77 << 2, 0x00},
+ { 0xA78 << 2, 0x00},
+ { 0xA79 << 2, 0x00},
+ { 0xA7A << 2, 0x00},
+ { 0xA7B << 2, 0x00},
+ { 0xA7C << 2, 0x00},
+ { 0xA7D << 2, 0x00},
+ { 0xA7E << 2, 0x00},
+ { 0xA7F << 2, 0xd8},
+ { 0xA80 << 2, 0x1a},
+ { 0xA81 << 2, 0xff},
+ { 0xA82 << 2, 0x01},
+ { 0xA83 << 2, 0x00},
+ { 0xA84 << 2, 0x00},
+ { 0xA85 << 2, 0x00},
+ { 0xA86 << 2, 0x00},
+ { 0xA87 << 2, 0xf0},
+ { 0xA88 << 2, 0xff},
+ { 0xA89 << 2, 0xff},
+ { 0xA8A << 2, 0xff},
+ { 0xA8B << 2, 0xff},
+ { 0xA8C << 2, 0x1c},
+ { 0xA8D << 2, 0xc2},
+ { 0xA8E << 2, 0xc3},
+ { 0xA8F << 2, 0x3f},
+ { 0xA90 << 2, 0x0a},
+ { 0xA91 << 2, 0x00},
+ { 0xA92 << 2, 0x00},
+ { 0xA93 << 2, 0x00},
+ { 0xA94 << 2, 0x00},
+ { 0xA95 << 2, 0x00},
+ { 0xA96 << 2, 0xf8},
+ { 0x000 << 2, 0x07}
+};
+
+
+/* PCIe SERDES is using internal clock */
+static struct serdes_regs_s pcie_phy_reg_file_24[] = {
+ /* Common CMU block */
+ { 0x000 << 2, 0x06},
+ { 0x001 << 2, 0x00},
+ { 0x002 << 2, 0x09},
+ { 0x003 << 2, 0x00},
+ { 0x004 << 2, 0x60},
+ { 0x005 << 2, 0x09},
+ { 0x006 << 2, 0x0e},
+ { 0x007 << 2, 0x00},
+ { 0x008 << 2, 0x00},
+ { 0x009 << 2, 0x00},
+ { 0x00A << 2, 0x00},
+ { 0x00B << 2, 0x00},
+ { 0x00C << 2, 0x00},
+ { 0x00D << 2, 0x00},
+ { 0x00E << 2, 0x00},
+ { 0x00F << 2, 0x00},
+ { 0x010 << 2, 0x00},
+ { 0x011 << 2, 0x00},
+ { 0x012 << 2, 0x00},
+ { 0x013 << 2, 0x00},
+ { 0x014 << 2, 0x00},
+ { 0x015 << 2, 0x00},
+ { 0x016 << 2, 0x00},
+ { 0x017 << 2, 0x00},
+ { 0x018 << 2, 0x00},
+ { 0x019 << 2, 0x00},
+ { 0x01A << 2, 0x00},
+ { 0x01B << 2, 0x00},
+ { 0x01C << 2, 0x00},
+ { 0x01D << 2, 0x00},
+ { 0x01E << 2, 0x00},
+ { 0x01F << 2, 0x00},
+ { 0x020 << 2, 0x00},
+ { 0x021 << 2, 0x00},
+ { 0x022 << 2, 0xa0},
+ { 0x023 << 2, 0x68},
+ { 0x024 << 2, 0x00},
+ { 0x025 << 2, 0x00},
+ { 0x026 << 2, 0x00},
+ { 0x027 << 2, 0x00},
+ { 0x028 << 2, 0x00},
+ { 0x029 << 2, 0x00},
+ { 0x02A << 2, 0x00},
+ { 0x02B << 2, 0x00},
+ { 0x02C << 2, 0x00},
+ { 0x02D << 2, 0x00},
+ { 0x02E << 2, 0x04},
+ { 0x02F << 2, 0x50},
+ { 0x030 << 2, 0x70},
+ { 0x031 << 2, 0x02},
+ { 0x032 << 2, 0x25},
+ { 0x033 << 2, 0x40},
+ { 0x034 << 2, 0x01},
+ { 0x035 << 2, 0x40},
+ { 0x036 << 2, 0x00},
+ { 0x037 << 2, 0x00},
+ { 0x038 << 2, 0x00},
+ { 0x039 << 2, 0x00},
+ { 0x03A << 2, 0x00},
+ { 0x03B << 2, 0x00},
+ { 0x03C << 2, 0x00},
+ { 0x03D << 2, 0x00},
+ { 0x03E << 2, 0x00},
+ { 0x03F << 2, 0x00},
+ { 0x040 << 2, 0x00},
+ { 0x041 << 2, 0x00},
+ { 0x042 << 2, 0x00},
+ { 0x043 << 2, 0x00},
+ { 0x044 << 2, 0x00},
+ { 0x045 << 2, 0x00},
+ { 0x046 << 2, 0x00},
+ { 0x047 << 2, 0x00},
+ { 0x048 << 2, 0x00},
+ { 0x049 << 2, 0x00},
+ { 0x04A << 2, 0x00},
+ { 0x04B << 2, 0x00},
+ { 0x04C << 2, 0x00},
+ { 0x04D << 2, 0x00},
+ { 0x04E << 2, 0x00},
+ { 0x04F << 2, 0x00},
+ { 0x050 << 2, 0x00},
+ { 0x051 << 2, 0x00},
+ { 0x052 << 2, 0x00},
+ { 0x053 << 2, 0x00},
+ { 0x054 << 2, 0x00},
+ { 0x055 << 2, 0x00},
+ { 0x056 << 2, 0x00},
+ { 0x057 << 2, 0x00},
+ { 0x058 << 2, 0x00},
+ { 0x059 << 2, 0x00},
+ { 0x05A << 2, 0x00},
+ { 0x05B << 2, 0x00},
+ { 0x05C << 2, 0x00},
+ { 0x05D << 2, 0x00},
+ { 0x05E << 2, 0x00},
+ { 0x05F << 2, 0x00},
+ { 0x060 << 2, 0x00},
+ { 0x061 << 2, 0x2e}, //for Rev-A0 device
+ { 0x062 << 2, 0x00},
+ { 0x063 << 2, 0x5e},
+ { 0x064 << 2, 0x00},
+ { 0x065 << 2, 0x42},
+ { 0x066 << 2, 0x91},
+ { 0x067 << 2, 0x10},
+ { 0x068 << 2, 0x48},
+ { 0x069 << 2, 0x90},
+ { 0x06A << 2, 0x0c},
+ { 0x06B << 2, 0x4c},
+ { 0x06C << 2, 0x73},
+ { 0x06D << 2, 0x03},
+ { 0x06E << 2, 0x00},
+ { 0x06F << 2, 0x00},
+ { 0x070 << 2, 0x00},
+ { 0x071 << 2, 0x00},
+ { 0x072 << 2, 0x00},
+ /* Lane0 Block */
+ { 0x200 << 2, 0x00},
+ { 0x201 << 2, 0x00},
+ { 0x202 << 2, 0x00},
+ { 0x203 << 2, 0x00},
+ { 0x204 << 2, 0x00},
+ { 0x205 << 2, 0x10},
+ { 0x206 << 2, 0x04},
+ { 0x207 << 2, 0x18},
+ { 0x208 << 2, 0xe0},
+ { 0x210 << 2, 0x23},
+ { 0x211 << 2, 0x00},
+ { 0x212 << 2, 0x00},
+ { 0x213 << 2, 0x04},
+ { 0x214 << 2, 0x38},
+ { 0x215 << 2, 0x10},
+ { 0x216 << 2, 0x00},
+ { 0x217 << 2, 0x68},
+ { 0x218 << 2, 0xa2},
+ { 0x219 << 2, 0x1e},
+ { 0x21A << 2, 0x18},
+ { 0x21B << 2, 0x0d},
+ { 0x21C << 2, 0x0c},
+ { 0x21D << 2, 0x00},
+ { 0x21E << 2, 0x00},
+ { 0x21F << 2, 0x00},
+ { 0x220 << 2, 0x00},
+ { 0x221 << 2, 0x00},
+ { 0x222 << 2, 0x00},
+ { 0x223 << 2, 0x00},
+ { 0x224 << 2, 0x00},
+ { 0x225 << 2, 0x00},
+ { 0x226 << 2, 0x00},
+ { 0x227 << 2, 0x00},
+ { 0x228 << 2, 0x00},
+ { 0x229 << 2, 0x00},
+ { 0x22A << 2, 0x00},
+ { 0x22B << 2, 0x00},
+ { 0x22C << 2, 0x00},
+ { 0x22D << 2, 0x00},
+ { 0x22E << 2, 0x00},
+ { 0x22F << 2, 0x00},
+ { 0x230 << 2, 0x00},
+ { 0x231 << 2, 0x00},
+ { 0x232 << 2, 0x00},
+ { 0x233 << 2, 0x00},
+ { 0x234 << 2, 0x00},
+ { 0x235 << 2, 0x00},
+ { 0x236 << 2, 0x00},
+ { 0x237 << 2, 0x00},
+ { 0x238 << 2, 0x00},
+ { 0x239 << 2, 0x00},
+ { 0x23A << 2, 0x00},
+ { 0x23B << 2, 0x00},
+ { 0x23C << 2, 0x00},
+ { 0x23D << 2, 0x00},
+ { 0x23E << 2, 0x00},
+ { 0x23F << 2, 0x00},
+ { 0x240 << 2, 0x00},
+ { 0x241 << 2, 0x00},
+ { 0x242 << 2, 0x00},
+ { 0x243 << 2, 0x00},
+ { 0x244 << 2, 0x00},
+ { 0x245 << 2, 0x00},
+ { 0x246 << 2, 0x00},
+ { 0x247 << 2, 0x00},
+ { 0x248 << 2, 0x00},
+ { 0x249 << 2, 0x00},
+ { 0x24A << 2, 0x00},
+ { 0x24B << 2, 0x00},
+ { 0x24C << 2, 0x00},
+ { 0x24D << 2, 0x00},
+ { 0x24E << 2, 0x00},
+ { 0x24F << 2, 0x00},
+ { 0x250 << 2, 0xf6},
+ { 0x251 << 2, 0x03},
+ /* Common Lane Block */
+ { 0xA00 << 2, 0xc0},
+ { 0xA01 << 2, 0x90},
+ { 0xA02 << 2, 0x02},
+ { 0xA03 << 2, 0x40},
+ { 0xA04 << 2, 0x3c},
+ { 0xA05 << 2, 0x00},
+ { 0xA06 << 2, 0x00},
+ { 0xA07 << 2, 0x00},
+ { 0xA08 << 2, 0x00},
+ { 0xA09 << 2, 0x83},
+ { 0xA0A << 2, 0x8b},
+ { 0xA0B << 2, 0xc6},
+ { 0xA0C << 2, 0x01},
+ { 0xA0D << 2, 0x03},
+ { 0xA0E << 2, 0x28},
+ { 0xA0F << 2, 0x98},
+ { 0xA10 << 2, 0x19},
+ { 0xA11 << 2, 0x28},
+ { 0xA12 << 2, 0x78},
+ { 0xA13 << 2, 0xe1},
+ { 0xA14 << 2, 0xf0},
+ { 0xA15 << 2, 0x10},
+ { 0xA16 << 2, 0xf4},
+ { 0xA17 << 2, 0x00},
+ { 0xA30 << 2, 0x00},
+ { 0xA31 << 2, 0x00},
+ { 0xA32 << 2, 0x00},
+ { 0xA33 << 2, 0x00},
+ { 0xA34 << 2, 0x00},
+ { 0xA35 << 2, 0x00},
+ { 0xA36 << 2, 0x00},
+ { 0xA37 << 2, 0x00},
+ { 0xA38 << 2, 0x00},
+ { 0xA39 << 2, 0xa0},
+ { 0xA3A << 2, 0xa0},
+ { 0xA3B << 2, 0xa0},
+ { 0xA3C << 2, 0xa0},
+ { 0xA3D << 2, 0xa0},
+ { 0xA3E << 2, 0xa0},
+ { 0xA3F << 2, 0xa0},
+ { 0xA40 << 2, 0x68},
+ { 0xA41 << 2, 0x00},
+ { 0xA42 << 2, 0xc0},
+ { 0xA43 << 2, 0x9f},
+ { 0xA44 << 2, 0x01},
+ { 0xA45 << 2, 0x00},
+ { 0xA46 << 2, 0x00},
+ { 0xA47 << 2, 0x00},
+ { 0xA48 << 2, 0x00},
+ { 0xA49 << 2, 0x00},
+ { 0xA4A << 2, 0x00},
+ { 0xA4B << 2, 0x00},
+ { 0xA4C << 2, 0x30},
+ { 0xA4D << 2, 0x41},
+ { 0xA4E << 2, 0x7e},
+ { 0xA4F << 2, 0xd0},
+ { 0xA50 << 2, 0xcc},
+ { 0xA51 << 2, 0x85},
+ { 0xA52 << 2, 0x52},
+ { 0xA53 << 2, 0x93},
+ { 0xA54 << 2, 0xe0},
+ { 0xA55 << 2, 0x49},
+ { 0xA56 << 2, 0xdd},
+ { 0xA57 << 2, 0xb0},
+ { 0xA58 << 2, 0x0b},
+ { 0xA59 << 2, 0x02},
+ { 0xA5A << 2, 0x00},
+ { 0xA5B << 2, 0x00},
+ { 0xA5C << 2, 0x00},
+ { 0xA5D << 2, 0x00},
+ { 0xA5E << 2, 0x00},
+ { 0xA5F << 2, 0x00},
+ { 0xA60 << 2, 0x00},
+ { 0xA61 << 2, 0x00},
+ { 0xA62 << 2, 0x00},
+ { 0xA63 << 2, 0x00},
+ { 0xA64 << 2, 0x00},
+ { 0xA65 << 2, 0x00},
+ { 0xA66 << 2, 0x00},
+ { 0xA67 << 2, 0x00},
+ { 0xA68 << 2, 0x00},
+ { 0xA69 << 2, 0x00},
+ { 0xA6A << 2, 0x00},
+ { 0xA6B << 2, 0x00},
+ { 0xA6C << 2, 0x00},
+ { 0xA6D << 2, 0x00},
+ { 0xA6E << 2, 0x00},
+ { 0xA6F << 2, 0x00},
+ { 0xA70 << 2, 0x00},
+ { 0xA71 << 2, 0x00},
+ { 0xA72 << 2, 0x00},
+ { 0xA73 << 2, 0x00},
+ { 0xA74 << 2, 0x00},
+ { 0xA75 << 2, 0x00},
+ { 0xA76 << 2, 0x00},
+ { 0xA77 << 2, 0x00},
+ { 0xA78 << 2, 0x00},
+ { 0xA79 << 2, 0x00},
+ { 0xA7A << 2, 0x00},
+ { 0xA7B << 2, 0x00},
+ { 0xA7C << 2, 0x00},
+ { 0xA7D << 2, 0x00},
+ { 0xA7E << 2, 0x00},
+ { 0xA7F << 2, 0xd8},
+ { 0xA80 << 2, 0x1a},
+ { 0xA81 << 2, 0xff},
+ { 0xA82 << 2, 0x01},
+ { 0xA83 << 2, 0x00},
+ { 0xA84 << 2, 0x00},
+ { 0xA85 << 2, 0x00},
+ { 0xA86 << 2, 0x00},
+ { 0xA87 << 2, 0xf0},
+ { 0xA88 << 2, 0xff},
+ { 0xA89 << 2, 0xff},
+ { 0xA8A << 2, 0xff},
+ { 0xA8B << 2, 0xff},
+ { 0xA8C << 2, 0x1c},
+ { 0xA8D << 2, 0xc2},
+ { 0xA8E << 2, 0xc3},
+ { 0xA8F << 2, 0x3f},
+ { 0xA90 << 2, 0x0a},
+ { 0xA91 << 2, 0x00},
+ { 0xA92 << 2, 0x00},
+ { 0xA93 << 2, 0x00},
+ { 0xA94 << 2, 0x00},
+ { 0xA95 << 2, 0x00},
+ { 0xA96 << 2, 0xf8},
+ { 0x000 << 2, 0x07}
+};
diff --git a/drivers/phy/phy-snowbush.c b/drivers/phy/phy-snowbush.c
new file mode 100644
index 0000000..fdc76a4
--- /dev/null
+++ b/drivers/phy/phy-snowbush.c
@@ -0,0 +1,409 @@
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/phy/phy.h>
+#include <linux/sched.h>
+#include <linux/reset.h>
+
+#include <dt-bindings/phy/phy.h>
+
+#include "phy-snowbush-regs.h"
+
+struct snowbush_phy {
+ struct phy *phy;
+ void __iomem *base;
+ void __iomem *dwc1_serdes_cfg_base;
+ struct reset_control *reset;
+ struct reset_control *pcie_rst;
+ struct reset_control *sata_rst;
+ bool pcie_tx_pol_inv;
+ bool sata_tx_pol_inv;
+ u32 sata_gen;
+ u32 ctrlreg;
+ u8 type;
+};
+
+struct snowbush_dev {
+ struct device *dev;
+ struct regmap *regmap;
+ struct mutex sbphy_mutex;
+ struct snowbush_phy **phys;
+ int nphys;
+};
+
+
+#define SD_COMMON_LANE 0xA00
+
+#define SD_PHY_STS_REG_OFST 0x00
+#define SD_PHY_CTRL1_REG_OFST 0x04
+#define SD_PHY_CTRL2_REG_OFST 0x08
+#define SD_PHY_CTRL3_REG_OFST 0x0C
+
+#define MAX_LANE_OK_WAIT_JIFFIES (200 * HZ) / 1000 /* 200ms */
+#define MAX_CMU_OK_WAIT_JIFFIES (2000 * HZ) / 1000 /* 2 Seconds */
+
+/**
+ * This function Wait for the 'Lane OK' to be signaled by the
+ * Snowbush Serdes PHY.
+ * @param sbphy_num SerDes PHY intefrace number.
+ */
+static int wait_lane_ok(struct snowbush_phy *sbphy_phy,
+ struct snowbush_dev *sbphy_dev)
+{
+ u32 rd_data = 0, masked_data = 0;
+ u32 lane_ok_dtctd_mask = 0x00001000;
+ unsigned long deadline = jiffies + MAX_LANE_OK_WAIT_JIFFIES;
+
+ /* Keep looping until you see the lane_ok_o of Serdes */
+ do
+ {
+ rd_data = readl(sbphy_phy->dwc1_serdes_cfg_base + SD_PHY_STS_REG_OFST);
+
+ /* Mask lane_ok Status */
+ masked_data = rd_data & lane_ok_dtctd_mask;
+
+ if(masked_data == lane_ok_dtctd_mask) {
+ /* Lane OK Detected on Serdes Port */
+ dev_info(&sbphy_phy->phy->dev, "Serdes: Lane OK passed\n");
+ return 1;
+ }
+
+ cond_resched();
+
+ } while (!time_after_eq(jiffies, deadline));
+
+ dev_warn(&sbphy_phy->phy->dev, "Serdes: Lane OK failed\n");
+ return 0;
+}
+
+
+/**
+ * This function wait for the 'CMU OK' to be signaled by the
+ * Snowbush Serdes PHY.
+ * @param sbphy_num SerDes PHY intefrace number.
+ */
+static int wait_cmu_ok(struct snowbush_phy *sbphy_phy,
+ struct snowbush_dev *sbphy_dev)
+{
+ u32 rd_data = 0, masked_data = 0;
+ u32 cmu_ok_dtctd_mask = 0x00004000;
+ volatile void __iomem *CMU_Offset;
+ unsigned long deadline = jiffies + MAX_CMU_OK_WAIT_JIFFIES;
+
+ CMU_Offset = sbphy_phy->dwc1_serdes_cfg_base + SD_PHY_STS_REG_OFST;
+
+ /* Keep looping until you see the cmu_ok_o of Serdes */
+ do
+ {
+ rd_data = readl(CMU_Offset);
+
+ /* Mask cmu_ok Status */
+ masked_data = rd_data & cmu_ok_dtctd_mask;
+
+ if(masked_data == cmu_ok_dtctd_mask) {
+ /* CMU OK Detected on Serdes Port */
+ dev_info(&sbphy_phy->phy->dev, "Serdes: CMU OK Passed\n");
+ return 1;
+ }
+
+ cond_resched();
+
+ } while (!time_after_eq(jiffies, deadline));
+
+ dev_warn(&sbphy_phy->phy->dev, "Serdes: CMU OK failed\n");
+
+ return 0;
+}
+
+
+/**
+ * This function wait for the specified configured Snowbush PHY
+ * (Serdes) to issue it's CMU-OK, and it's Lane to become Ready
+ * after releasing the CMU & Lane resets.
+ * @param sbphy_num SerDes PHY intefrace number.
+ */
+static int wait_sb_cmu_lane_rdy(struct snowbush_phy *sbphy_phy,
+ struct snowbush_dev *sbphy_dev)
+{
+ volatile void __iomem *sd_ctl2_reg_offset;
+ u32 cmu_rst_mask = 0x00010000;
+ u32 lane_rst_mask = 0x00000040;
+ u32 tmp = 0;
+
+ sd_ctl2_reg_offset =
+ sbphy_phy->dwc1_serdes_cfg_base + SD_PHY_CTRL2_REG_OFST;
+
+ /* Releasing the CMU Reset */
+ tmp = readl(sd_ctl2_reg_offset);
+ tmp = tmp & (~cmu_rst_mask);
+ tmp = tmp | cmu_rst_mask;
+
+ writel(tmp, sd_ctl2_reg_offset );
+
+ /* Waiting for CMU OK */
+ if( !wait_cmu_ok(sbphy_phy, sbphy_dev) )
+ return -1;
+
+ if (sbphy_phy->type == PHY_TYPE_PCIE)
+ writel(0xC3, sbphy_phy->base + (SD_COMMON_LANE << 2));
+ else
+ writel(0x03, sbphy_phy->base + (SD_COMMON_LANE << 2));
+
+ /* Releasing the Lane Reset */
+ tmp = readl(sd_ctl2_reg_offset);
+ tmp = tmp & (~lane_rst_mask);
+ tmp = tmp | lane_rst_mask;
+
+ writel(tmp, sd_ctl2_reg_offset);
+
+ /* Waiting for the Lane Ready */
+ if (sbphy_phy->type != PHY_TYPE_PCIE) {
+ if( !wait_lane_ok(sbphy_phy, sbphy_dev) )
+ return -1;
+ }
+
+ return 0;
+}
+
+
+/**
+ * This function initialize the Snowbush PHY (Serdes) for operation
+ * with the one of the PCIE,SATA or SGMII IP blocks, and then waiting
+ * until it issue it's CMU-OK, and it's Lane to become Ready after
+ * releasing the CMU & Lane Resets.
+ * @param phy_num SerDes PHY intefrace number.
+ * @param *regs Register file (Array of registers and coresponding
+ * values to be programmed).
+ * @param size Number of registers to be programmed.
+ */
+static int serdes_phy_init(struct snowbush_phy *sbphy_phy,
+ struct snowbush_dev *sbphy_dev)
+{
+ int i, size, ret;
+ struct serdes_regs_s *regs;
+
+ static int misc = 0;
+ ret = reset_control_deassert(sbphy_phy->reset);
+ if (ret)
+ return ret;
+
+ if (sbphy_phy->type == PHY_TYPE_PCIE && sbphy_phy->pcie_rst) {
+ ret = reset_control_deassert(sbphy_phy->pcie_rst);
+ if (ret)
+ return ret;
+ }
+ if (sbphy_phy->type == PHY_TYPE_SATA && sbphy_phy->sata_rst) {
+ ret = reset_control_deassert(sbphy_phy->sata_rst);
+ if (ret)
+ return ret;
+ }
+ if (!misc) {
+ /* Move SATA controller to DDRC2 port */
+ writel(readl((void*) 0xF097006C) | 0x2, (void*) 0xF097006C); // TODO:COMCERTO_GPIO_FABRIC_CTRL_REG
+
+ writel(readl((void*) 0xF09B0058) & ~4, (void*) 0xF09B0058); // AXI_RESET_2 TODO: SATA_AXI
+
+ writel(readl((void*) 0xF09B0048) | 3, (void*) 0xF09B0048); // AXI_CLK_CNTRL_2
+ writel(readl((void*) 0xF09B0048) | 4, (void*) 0xF09B0048); // AXI_CLK_CNTRL_2: SATA
+
+ writel(readl((void*) 0xF09B0168) & ~1, (void*) 0xF09B0168); // TODO: SATA_PMU
+ writel(readl((void*) 0xF09B0178) & ~1, (void*) 0xF09B0178); // TODO: SATA_OOB
+
+ misc = 1;
+ }
+
+
+ if (sbphy_phy->type == PHY_TYPE_PCIE) {
+ /* SW select for ck_soc_div_i SOC clock */
+ writel(0xFF3C, sbphy_phy->dwc1_serdes_cfg_base + SD_PHY_CTRL3_REG_OFST);
+ writel(readl(sbphy_phy->dwc1_serdes_cfg_base + SD_PHY_CTRL2_REG_OFST) & ~0x3,
+ sbphy_phy->dwc1_serdes_cfg_base + SD_PHY_CTRL2_REG_OFST);
+ }
+
+ if (sbphy_phy->type == PHY_TYPE_SATA) {
+ regs = sata_phy_reg_file_24; /* TODO: Support for 48MHz crystal */
+ size = ARRAY_SIZE(sata_phy_reg_file_24);
+ } else if (sbphy_phy->type == PHY_TYPE_PCIE) {
+ regs = pcie_phy_reg_file_24;
+ size = ARRAY_SIZE(pcie_phy_reg_file_24);
+ if (1) { // (system_rev == 1) { /* TODO */
+ // C2K RevA1 devices use a different serdes clk divider
+ regs[0x61].val = 0x6;
+ }
+
+ } else {
+ BUG();
+ }
+
+ /* Initilize serdes phy registers */
+ for(i = 0; i < size; i++ )
+ writel(regs[i].val, sbphy_phy->base + regs[i].ofst);
+
+ /* Wait for the initialization of Serdes-1 Port/Lane to become Ready */
+ return wait_sb_cmu_lane_rdy(sbphy_phy, sbphy_dev);
+}
+
+static int snowbush_init(struct phy *phy)
+{
+ struct snowbush_phy *sbphy_phy = phy_get_drvdata(phy);
+ struct snowbush_dev *sbphy_dev = dev_get_drvdata(phy->dev.parent);
+ int ret = 0;
+
+ mutex_lock(&sbphy_dev->sbphy_mutex);
+ serdes_phy_init(sbphy_phy, sbphy_dev);
+ mutex_unlock(&sbphy_dev->sbphy_mutex);
+
+ return ret;
+}
+
+static struct phy *snowbush_xlate(struct device *dev,
+ struct of_phandle_args *args)
+{
+ struct snowbush_dev *sbphy_dev = dev_get_drvdata(dev);
+ struct snowbush_phy *sbphy_phy = NULL;
+ struct device_node *phynode = args->np;
+ int index;
+
+ if (!of_device_is_available(phynode)) {
+ dev_warn(dev, "Requested PHY is disabled\n");
+ return ERR_PTR(-ENODEV);
+ }
+
+ if (args->args_count != 1) {
+ dev_err(dev, "Invalid number of cells in 'phy' property\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ for (index = 0; index < sbphy_dev->nphys; index++)
+ if (phynode == sbphy_dev->phys[index]->phy->dev.of_node) {
+ sbphy_phy = sbphy_dev->phys[index];
+ break;
+ }
+
+ if (!sbphy_phy) {
+ dev_err(dev, "Failed to find appropriate phy\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ sbphy_phy->type = args->args[0];
+
+ if (!(sbphy_phy->type == PHY_TYPE_SATA ||
+ sbphy_phy->type == PHY_TYPE_PCIE)) {
+ dev_err(dev, "Unsupported device type: %d\n", sbphy_phy->type);
+ return ERR_PTR(-EINVAL);
+ }
+
+ return sbphy_phy->phy;
+}
+
+static struct phy_ops snowbush_ops = {
+ .init = snowbush_init,
+ .owner = THIS_MODULE,
+};
+
+static int snowbush_of_probe(struct device_node *phynode,
+ struct snowbush_phy *sbphy_phy)
+{
+ sbphy_phy->base = of_iomap(phynode, 0);
+ if (!sbphy_phy->base) {
+ dev_err(&sbphy_phy->phy->dev, "Failed to map %s\n", phynode->full_name);
+ return -EINVAL;
+ }
+ sbphy_phy->dwc1_serdes_cfg_base = of_iomap(phynode, 1);
+ if (!sbphy_phy->dwc1_serdes_cfg_base) {
+ dev_err(&sbphy_phy->phy->dev, "Failed to map %s dwc1_serdes_cfg_base\n", phynode->full_name);
+ return -EINVAL;
+ }
+ sbphy_phy->reset = devm_reset_control_get(&sbphy_phy->phy->dev, "serdes");
+ if (IS_ERR(sbphy_phy->reset)) {
+ dev_err(&sbphy_phy->phy->dev, "failed to get reset control\n");
+ return PTR_ERR(sbphy_phy->reset);
+ }
+ sbphy_phy->pcie_rst = devm_reset_control_get(&sbphy_phy->phy->dev, "serdes_pcie");
+ if (IS_ERR(sbphy_phy->pcie_rst)) {
+ sbphy_phy->pcie_rst = 0;
+ }
+ sbphy_phy->sata_rst = devm_reset_control_get(&sbphy_phy->phy->dev, "serdes_sata");
+ if (IS_ERR(sbphy_phy->sata_rst)) {
+ sbphy_phy->sata_rst = 0;
+ }
+ /* TODO */
+ return 0;
+}
+
+static int snowbush_probe(struct platform_device *pdev)
+{
+ struct device_node *child, *np = pdev->dev.of_node;
+ struct snowbush_dev *sbphy_dev;
+ struct phy_provider *provider;
+ struct phy *phy;
+ int ret, port = 0;
+
+ sbphy_dev = devm_kzalloc(&pdev->dev, sizeof(*sbphy_dev), GFP_KERNEL);
+ if (!sbphy_dev)
+ return -ENOMEM;
+
+ sbphy_dev->nphys = of_get_child_count(np);
+ sbphy_dev->phys = devm_kcalloc(&pdev->dev, sbphy_dev->nphys,
+ sizeof(*sbphy_dev->phys), GFP_KERNEL);
+ if (!sbphy_dev->phys)
+ return -ENOMEM;
+
+ sbphy_dev->dev = &pdev->dev;
+
+ dev_set_drvdata(&pdev->dev, sbphy_dev);
+
+ mutex_init(&sbphy_dev->sbphy_mutex);
+
+ for_each_child_of_node(np, child) {
+ struct snowbush_phy *sbphy_phy;
+
+ sbphy_phy = devm_kzalloc(&pdev->dev, sizeof(*sbphy_phy),
+ GFP_KERNEL);
+ if (!sbphy_phy)
+ return -ENOMEM;
+
+ sbphy_dev->phys[port] = sbphy_phy;
+
+ phy = devm_phy_create(&pdev->dev, child, &snowbush_ops);
+ if (IS_ERR(phy)) {
+ dev_err(&pdev->dev, "failed to create PHY\n");
+ return PTR_ERR(phy);
+ }
+
+ sbphy_dev->phys[port]->phy = phy;
+
+ ret = snowbush_of_probe(child, sbphy_phy);
+ if (ret)
+ return ret;
+
+ phy_set_drvdata(phy, sbphy_dev->phys[port]);
+
+ port++;
+ }
+
+ provider = devm_of_phy_provider_register(&pdev->dev, snowbush_xlate);
+ return PTR_ERR_OR_ZERO(provider);
+}
+
+static const struct of_device_id snowbush_of_match[] = {
+ { .compatible = "fsl,ls1024a-snowbush-phy", },
+ { },
+};
+MODULE_DEVICE_TABLE(of, snowbush_of_match);
+
+static struct platform_driver snowbush_driver = {
+ .probe = snowbush_probe,
+ .driver = {
+ .name = "snowbush-phy",
+ .of_match_table = snowbush_of_match,
+ }
+};
+module_platform_driver(snowbush_driver);
+
+MODULE_AUTHOR("Daniel Mentz <danielmentz@google.com>");
+MODULE_DESCRIPTION("Snowbush PHY driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/pinctrl/Kconfig b/drivers/pinctrl/Kconfig
index aeb5729..e9e0c21 100644
--- a/drivers/pinctrl/Kconfig
+++ b/drivers/pinctrl/Kconfig
@@ -93,6 +93,12 @@
depends on SOC_FALCON
depends on PINCTRL_LANTIQ
+config PINCTRL_LS1024A
+ bool
+ depends on OF
+ select PINMUX
+ select GENERIC_PINCONF
+
config PINCTRL_MESON
bool
depends on OF
diff --git a/drivers/pinctrl/Makefile b/drivers/pinctrl/Makefile
index 6eadf04..816f4a4 100644
--- a/drivers/pinctrl/Makefile
+++ b/drivers/pinctrl/Makefile
@@ -16,6 +16,7 @@
obj-$(CONFIG_PINCTRL_AT91) += pinctrl-at91.o
obj-$(CONFIG_PINCTRL_AMD) += pinctrl-amd.o
obj-$(CONFIG_PINCTRL_FALCON) += pinctrl-falcon.o
+obj-$(CONFIG_PINCTRL_LS1024A) += pinctrl-ls1024a.o
obj-$(CONFIG_PINCTRL_MESON) += meson/
obj-$(CONFIG_PINCTRL_PALMAS) += pinctrl-palmas.o
obj-$(CONFIG_PINCTRL_ROCKCHIP) += pinctrl-rockchip.o
diff --git a/drivers/pinctrl/pinctrl-ls1024a.c b/drivers/pinctrl/pinctrl-ls1024a.c
new file mode 100644
index 0000000..25bd8bd
--- /dev/null
+++ b/drivers/pinctrl/pinctrl-ls1024a.c
@@ -0,0 +1,927 @@
+#include <linux/gpio.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_irq.h>
+#include <linux/platform_device.h>
+#include <linux/printk.h>
+#include <linux/pinctrl/pinctrl.h>
+#include <linux/pinctrl/pinmux.h>
+#include <linux/pinctrl/pinconf-generic.h>
+
+#include "pinctrl-utils.h"
+#include "core.h"
+
+#define LS1024A_GPIO_OUTPUT_REG 0x00
+#define LS1024A_GPIO_OE_REG 0x04
+#define LS1024A_GPIO_INT_CFG_REG 0x08
+#define LS1024A_GPIO_INPUT_REG 0x10
+#define LS1024A_PIN_SELECT_15_0_REG 0x58
+#define LS1024A_PIN_SELECT_31_16_REG 0x5C
+#define LS1024A_MISC_PIN_SELECT 0x60
+#define LS1024A_GPIO_63_32_PIN_OUTPUT 0xD0
+#define LS1024A_GPIO_63_32_PIN_OUTPUT_EN 0xD4
+#define LS1024A_GPIO_63_32_PIN_INPUT 0xD8
+#define LS1024A_GPIO_63_32_PIN_SELECT 0xDC
+
+#define LS1024A_GPIO_NUM_IRQS 8
+
+struct ls1024a_pinctrl {
+ struct device *dev;
+ struct pinctrl_dev *pctrl;
+ struct gpio_chip gc;
+ struct irq_chip *irqchip;
+ struct irq_domain *irq_domain;
+
+ void __iomem *reg;
+
+ struct of_phandle_args parent_phandle_args;
+
+ /*
+ * Used to lock ls1024a_pinctrl->data. Also, this is needed to keep
+ * shadowed and real data registers writes together.
+ */
+ spinlock_t lock;
+
+ /* Shadowed data register to clear/set bits safely. */
+ u32 data[2];
+
+ /* Shadowed direction registers to clear/set direction safely. */
+ u32 dir[2];
+};
+
+static inline struct ls1024a_pinctrl *gc_to_ls1024a_pinctrl(struct gpio_chip *gc)
+{
+ return container_of(gc, struct ls1024a_pinctrl, gc);
+}
+
+#define LS1024A_PIN_GEM0_RXD0 1
+#define LS1024A_PIN_GEM0_RXD1 2
+#define LS1024A_PIN_GEM0_RXD2 3
+#define LS1024A_PIN_GEM0_RXD3 4
+#define LS1024A_PIN_GEM0_RX_CTL 5
+#define LS1024A_PIN_GEM0_RXC 6
+#define LS1024A_PIN_GEM0_TXD0 7
+#define LS1024A_PIN_GEM0_TXD1 8
+#define LS1024A_PIN_GEM0_TXD2 9
+#define LS1024A_PIN_GEM0_TXD3 10
+#define LS1024A_PIN_GEM0_TX_CTL 11
+#define LS1024A_PIN_GEM0_TXC 12
+#define LS1024A_PIN_GEM1_RXD0 13
+#define LS1024A_PIN_GEM1_RXD1 14
+#define LS1024A_PIN_GEM1_RXD2 15
+#define LS1024A_PIN_GEM1_RXD3 16
+#define LS1024A_PIN_GEM1_RX_CTL 17
+#define LS1024A_PIN_GEM1_RXC 18
+#define LS1024A_PIN_GEM1_TXD0 19
+#define LS1024A_PIN_GEM1_TXD1 20
+#define LS1024A_PIN_GEM1_TXD2 21
+#define LS1024A_PIN_GEM1_TXD3 22
+#define LS1024A_PIN_GEM1_TX_CTL 23
+#define LS1024A_PIN_GEM1_TXC 24
+#define LS1024A_PIN_GEM2_RXD0 25
+#define LS1024A_PIN_GEM2_RXD1 26
+#define LS1024A_PIN_GEM2_RXD2 27
+#define LS1024A_PIN_GEM2_RXD3 28
+#define LS1024A_PIN_GEM2_RX_CTL 29
+#define LS1024A_PIN_GEM2_RXC 30
+#define LS1024A_PIN_GEM2_TXD0 31
+#define LS1024A_PIN_GEM2_TXD1 32
+#define LS1024A_PIN_GEM2_TXD2 33
+#define LS1024A_PIN_GEM2_TXD3 34
+#define LS1024A_PIN_GEM2_TX_CTL 35
+#define LS1024A_PIN_GEM2_TXC 36
+#define LS1024A_PIN_GEM2_REFCLK 37
+#define LS1024A_PIN_GPIO00 38
+#define LS1024A_PIN_GPIO01 39
+#define LS1024A_PIN_GPIO02 40
+#define LS1024A_PIN_GPIO03 41
+#define LS1024A_PIN_GPIO04 42
+#define LS1024A_PIN_GPIO05 43
+#define LS1024A_PIN_GPIO06 44
+#define LS1024A_PIN_GPIO07 45
+#define LS1024A_PIN_GPIO08 46
+#define LS1024A_PIN_GPIO09 47
+#define LS1024A_PIN_GPIO10 48
+#define LS1024A_PIN_GPIO11 49
+#define LS1024A_PIN_GPIO12 50
+#define LS1024A_PIN_GPIO13 51
+#define LS1024A_PIN_GPIO14 52
+#define LS1024A_PIN_GPIO15 53
+#define LS1024A_PIN_I2C_SCL 54
+#define LS1024A_PIN_I2C_SDA 55
+#define LS1024A_PIN_SPI_SS0_N 56
+#define LS1024A_PIN_SPI_SS1_N 57
+#define LS1024A_PIN_SPI_2_SS1_N 58
+#define LS1024A_PIN_SPI_SS2_N 59
+#define LS1024A_PIN_SPI_SS3_N 60
+#define LS1024A_PIN_EXP_CS2_N 61
+#define LS1024A_PIN_EXP_CS3_N 62
+#define LS1024A_PIN_EXP_ALE 63
+#define LS1024A_PIN_EXP_RDY 64
+#define LS1024A_PIN_TM_EXT_RESET 65
+#define LS1024A_PIN_EXP_NAND_CS 66
+#define LS1024A_PIN_EXP_NAND_RDY 67
+#define LS1024A_PIN_SPI_TXD 68
+#define LS1024A_PIN_SPI_SCLK 69
+#define LS1024A_PIN_SPI_RXD 70
+#define LS1024A_PIN_SPI_2_RXD 71
+#define LS1024A_PIN_SPI_2_SS0_N 72
+#define LS1024A_PIN_EXP_DQ08 73
+#define LS1024A_PIN_EXP_DQ09 74
+#define LS1024A_PIN_EXP_DQ10 75
+#define LS1024A_PIN_EXP_DQ11 76
+#define LS1024A_PIN_EXP_DQ12 77
+#define LS1024A_PIN_EXP_DQ13 78
+#define LS1024A_PIN_EXP_DQ14 79
+#define LS1024A_PIN_EXP_DQ15 80
+#define LS1024A_PIN_EXP_DM1 81
+#define LS1024A_PIN_CORESIGHT_D0 82
+#define LS1024A_PIN_CORESIGHT_D1 83
+#define LS1024A_PIN_CORESIGHT_D2 84
+#define LS1024A_PIN_CORESIGHT_D3 85
+#define LS1024A_PIN_CORESIGHT_D4 86
+#define LS1024A_PIN_CORESIGHT_D5 87
+#define LS1024A_PIN_CORESIGHT_D6 88
+#define LS1024A_PIN_CORESIGHT_D7 89
+#define LS1024A_PIN_CORESIGHT_D8 90
+#define LS1024A_PIN_CORESIGHT_D9 91
+#define LS1024A_PIN_CORESIGHT_D10 92
+#define LS1024A_PIN_CORESIGHT_D11 93
+#define LS1024A_PIN_CORESIGHT_D12 94
+#define LS1024A_PIN_CORESIGHT_D13 95
+#define LS1024A_PIN_CORESIGHT_D14 96
+#define LS1024A_PIN_CORESIGHT_D15 97
+#define LS1024A_PIN_UART1_RX 98
+#define LS1024A_PIN_UART1_TX 99
+#define LS1024A_PIN_TDM_CK 100
+#define LS1024A_PIN_TDM_FS 101
+#define LS1024A_PIN_TDM_DR 102
+#define LS1024A_PIN_TDM_DX 103
+
+
+
+static const struct pinctrl_pin_desc ls1024a_pins_desc[] = {
+ PINCTRL_PIN(LS1024A_PIN_GEM0_RXD0, "gem0_rxd0"),
+ PINCTRL_PIN(LS1024A_PIN_GEM0_RXD1, "gem0_rxd1"),
+ PINCTRL_PIN(LS1024A_PIN_GEM0_RXD2, "gem0_rxd2"),
+ PINCTRL_PIN(LS1024A_PIN_GEM0_RXD3, "gem0_rxd3"),
+ PINCTRL_PIN(LS1024A_PIN_GEM0_RX_CTL, "gem0_rx_ctl"),
+ PINCTRL_PIN(LS1024A_PIN_GEM0_RXC, "gem0_rxc"),
+ PINCTRL_PIN(LS1024A_PIN_GEM0_TXD0, "gem0_txd0"),
+ PINCTRL_PIN(LS1024A_PIN_GEM0_TXD1, "gem0_txd1"),
+ PINCTRL_PIN(LS1024A_PIN_GEM0_TXD2, "gem0_txd2"),
+ PINCTRL_PIN(LS1024A_PIN_GEM0_TXD3, "gem0_txd3"),
+ PINCTRL_PIN(LS1024A_PIN_GEM0_TX_CTL, "gem0_tx_ctl"),
+ PINCTRL_PIN(LS1024A_PIN_GEM0_TXC, "gem0_txc"),
+ PINCTRL_PIN(LS1024A_PIN_GEM1_RXD0, "gem1_rxd0"),
+ PINCTRL_PIN(LS1024A_PIN_GEM1_RXD1, "gem1_rxd1"),
+ PINCTRL_PIN(LS1024A_PIN_GEM1_RXD2, "gem1_rxd2"),
+ PINCTRL_PIN(LS1024A_PIN_GEM1_RXD3, "gem1_rxd3"),
+ PINCTRL_PIN(LS1024A_PIN_GEM1_RX_CTL, "gem1_rx_ctl"),
+ PINCTRL_PIN(LS1024A_PIN_GEM1_RXC, "gem1_rxc"),
+ PINCTRL_PIN(LS1024A_PIN_GEM1_TXD0, "gem1_txd0"),
+ PINCTRL_PIN(LS1024A_PIN_GEM1_TXD1, "gem1_txd1"),
+ PINCTRL_PIN(LS1024A_PIN_GEM1_TXD2, "gem1_txd2"),
+ PINCTRL_PIN(LS1024A_PIN_GEM1_TXD3, "gem1_txd3"),
+ PINCTRL_PIN(LS1024A_PIN_GEM1_TX_CTL, "gem1_tx_ctl"),
+ PINCTRL_PIN(LS1024A_PIN_GEM1_TXC, "gem1_txc"),
+ PINCTRL_PIN(LS1024A_PIN_GEM2_RXD0, "gem2_rxd0"),
+ PINCTRL_PIN(LS1024A_PIN_GEM2_RXD1, "gem2_rxd1"),
+ PINCTRL_PIN(LS1024A_PIN_GEM2_RXD2, "gem2_rxd2"),
+ PINCTRL_PIN(LS1024A_PIN_GEM2_RXD3, "gem2_rxd3"),
+ PINCTRL_PIN(LS1024A_PIN_GEM2_RX_CTL, "gem2_rx_ctl"),
+ PINCTRL_PIN(LS1024A_PIN_GEM2_RXC, "gem2_rxc"),
+ PINCTRL_PIN(LS1024A_PIN_GEM2_TXD0, "gem2_txd0"),
+ PINCTRL_PIN(LS1024A_PIN_GEM2_TXD1, "gem2_txd1"),
+ PINCTRL_PIN(LS1024A_PIN_GEM2_TXD2, "gem2_txd2"),
+ PINCTRL_PIN(LS1024A_PIN_GEM2_TXD3, "gem2_txd3"),
+ PINCTRL_PIN(LS1024A_PIN_GEM2_TX_CTL, "gem2_tx_ctl"),
+ PINCTRL_PIN(LS1024A_PIN_GEM2_TXC, "gem2_txc"),
+ PINCTRL_PIN(LS1024A_PIN_GEM2_REFCLK, "gem2_refclk"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO00, "gpio00"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO01, "gpio01"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO02, "gpio02"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO03, "gpio03"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO04, "gpio04"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO05, "gpio05"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO06, "gpio06"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO07, "gpio07"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO08, "gpio08"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO09, "gpio09"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO10, "gpio10"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO11, "gpio11"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO12, "gpio12"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO13, "gpio13"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO14, "gpio14"),
+ PINCTRL_PIN(LS1024A_PIN_GPIO15, "gpio15"),
+ PINCTRL_PIN(LS1024A_PIN_I2C_SCL, "i2c_scl"), /* GPIO 16 */
+ PINCTRL_PIN(LS1024A_PIN_I2C_SDA, "i2c_sda"), /* GPIO 17 */
+ PINCTRL_PIN(LS1024A_PIN_SPI_SS0_N, "spi_ss0_n"), /* GPIO 18 */
+ PINCTRL_PIN(LS1024A_PIN_SPI_SS1_N, "spi_ss1_n"), /* GPIO 19 */
+ PINCTRL_PIN(LS1024A_PIN_SPI_2_SS1_N, "spi_2_ss1_n"), /* GPIO 20 */
+ PINCTRL_PIN(LS1024A_PIN_SPI_SS2_N, "spi_ss2_n"), /* GPIO 21 */
+ PINCTRL_PIN(LS1024A_PIN_SPI_SS3_N, "spi_ss3_n"), /* GPIO 22 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_CS2_N, "exp_cs2_n"), /* GPIO 23 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_CS3_N, "exp_cs3_n"), /* GPIO 24 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_ALE, "exp_ale"), /* GPIO 25 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_RDY, "exp_rdy"), /* GPIO 26 */
+ PINCTRL_PIN(LS1024A_PIN_TM_EXT_RESET, "tm_ext_reset"), /* GPIO 27 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_NAND_CS, "exp_nand_cs"), /* GPIO 28 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_NAND_RDY, "exp_nand_rdy"), /* GPIO 29 */
+ PINCTRL_PIN(LS1024A_PIN_SPI_TXD, "spi_txd"), /* GPIO 30 */
+ PINCTRL_PIN(LS1024A_PIN_SPI_SCLK, "spi_sclk"), /* GPIO 31 */
+ PINCTRL_PIN(LS1024A_PIN_SPI_RXD, "spi_rxd"), /* GPIO 32 */
+ PINCTRL_PIN(LS1024A_PIN_SPI_2_RXD, "spi_2_rxd"), /* GPIO 33 */
+ PINCTRL_PIN(LS1024A_PIN_SPI_2_SS0_N, "spi_2_ss0_n"), /* GPIO 34 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_DQ08, "exp_dq08"), /* GPIO 35 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_DQ09, "exp_dq09"), /* GPIO 36 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_DQ10, "exp_dq10"), /* GPIO 37 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_DQ11, "exp_dq11"), /* GPIO 38 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_DQ12, "exp_dq12"), /* GPIO 39 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_DQ13, "exp_dq13"), /* GPIO 40 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_DQ14, "exp_dq14"), /* GPIO 41 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_DQ15, "exp_dq15"), /* GPIO 42 */
+ PINCTRL_PIN(LS1024A_PIN_EXP_DM1, "exp_dm1"), /* GPIO 43 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D0, "coresight_d0"), /* GPIO 44 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D1, "coresight_d1"), /* GPIO 45 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D2, "coresight_d2"), /* GPIO 46 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D3, "coresight_d3"), /* GPIO 47 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D4, "coresight_d4"), /* GPIO 48 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D5, "coresight_d5"), /* GPIO 49 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D6, "coresight_d6"), /* GPIO 50 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D7, "coresight_d7"), /* GPIO 51 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D8, "coresight_d8"), /* GPIO 52 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D9, "coresight_d9"), /* GPIO 53 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D10, "coresight_d10"), /* GPIO 54 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D11, "coresight_d11"), /* GPIO 55 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D12, "coresight_d12"), /* GPIO 56 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D13, "coresight_d13"), /* GPIO 57 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D14, "coresight_d14"), /* GPIO 58 */
+ PINCTRL_PIN(LS1024A_PIN_CORESIGHT_D15, "coresight_d15"), /* GPIO 59 */
+ PINCTRL_PIN(LS1024A_PIN_UART1_RX, "uart1_rx"), /* not usable as GPIO */
+ PINCTRL_PIN(LS1024A_PIN_UART1_TX, "uart1_tx"), /* not usable as GPIO */
+ /* Warning: Following four GPIOs are in reverse order */
+ PINCTRL_PIN(LS1024A_PIN_TDM_CK, "tdm_ck"), /* GPIO 63 */
+ PINCTRL_PIN(LS1024A_PIN_TDM_FS, "tdm_fs"), /* GPIO 62 */
+ PINCTRL_PIN(LS1024A_PIN_TDM_DR, "tdm_dr"), /* GPIO 61 */
+ PINCTRL_PIN(LS1024A_PIN_TDM_DX, "tdm_dx"), /* GPIO 60 */
+};
+
+struct ls1024a_group {
+ const char *name;
+ const unsigned int *pins;
+ const unsigned num_pins;
+ const unsigned reg;
+ const unsigned shift;
+ const unsigned bits;
+};
+
+static const unsigned pwm0_pins[] = { LS1024A_PIN_GPIO04 };
+static const unsigned pwm1_pins[] = { LS1024A_PIN_GPIO05 };
+static const unsigned pwm2_pins[] = { LS1024A_PIN_GPIO06 };
+static const unsigned pwm3_pins[] = { LS1024A_PIN_GPIO07 };
+static const unsigned pwm4_pins[] = { LS1024A_PIN_GPIO12 };
+static const unsigned pwm5_pins[] = { LS1024A_PIN_GPIO13 };
+static const unsigned i2c_pins[] = { LS1024A_PIN_I2C_SCL, LS1024A_PIN_I2C_SDA };
+static const unsigned uart0_pins[] = { LS1024A_PIN_GPIO08, LS1024A_PIN_GPIO09, LS1024A_PIN_GPIO10, LS1024A_PIN_GPIO11 };
+static const unsigned uart1_pins[] = { LS1024A_PIN_UART1_RX, LS1024A_PIN_UART1_TX };
+static const unsigned spi_2_pins[] = { LS1024A_PIN_SPI_2_RXD }; /* SPI_2_TXD and SPI_2_SCLK are not muxed */
+static const unsigned spi_2_ss0_pins[] = { LS1024A_PIN_SPI_2_SS0_N };
+static const unsigned spi_2_ss1_pins[] = { LS1024A_PIN_SPI_2_SS1_N };
+static const unsigned gpio_pins[] = {
+ LS1024A_PIN_GPIO00, LS1024A_PIN_GPIO01, LS1024A_PIN_GPIO02,
+ LS1024A_PIN_GPIO03, LS1024A_PIN_GPIO04, LS1024A_PIN_GPIO05,
+ LS1024A_PIN_GPIO06, LS1024A_PIN_GPIO07, LS1024A_PIN_GPIO08,
+ LS1024A_PIN_GPIO09, LS1024A_PIN_GPIO10, LS1024A_PIN_GPIO11,
+ LS1024A_PIN_GPIO12, LS1024A_PIN_GPIO13, LS1024A_PIN_GPIO14,
+ LS1024A_PIN_GPIO15, LS1024A_PIN_I2C_SCL, LS1024A_PIN_I2C_SDA,
+ LS1024A_PIN_SPI_SS0_N, LS1024A_PIN_SPI_SS1_N, LS1024A_PIN_SPI_2_SS1_N,
+ LS1024A_PIN_SPI_SS2_N, LS1024A_PIN_SPI_SS3_N, LS1024A_PIN_EXP_CS2_N,
+ LS1024A_PIN_EXP_CS3_N, LS1024A_PIN_EXP_ALE, LS1024A_PIN_EXP_RDY,
+ LS1024A_PIN_TM_EXT_RESET, LS1024A_PIN_EXP_NAND_CS,
+ LS1024A_PIN_EXP_NAND_RDY, LS1024A_PIN_SPI_TXD, LS1024A_PIN_SPI_SCLK,
+ LS1024A_PIN_SPI_RXD, LS1024A_PIN_SPI_2_RXD, LS1024A_PIN_SPI_2_SS0_N,
+ LS1024A_PIN_EXP_DQ08, LS1024A_PIN_EXP_DQ09, LS1024A_PIN_EXP_DQ10,
+ LS1024A_PIN_EXP_DQ11, LS1024A_PIN_EXP_DQ12, LS1024A_PIN_EXP_DQ13,
+ LS1024A_PIN_EXP_DQ14, LS1024A_PIN_EXP_DQ15, LS1024A_PIN_EXP_DM1,
+ LS1024A_PIN_CORESIGHT_D0, LS1024A_PIN_CORESIGHT_D1,
+ LS1024A_PIN_CORESIGHT_D2, LS1024A_PIN_CORESIGHT_D3,
+ LS1024A_PIN_CORESIGHT_D4, LS1024A_PIN_CORESIGHT_D5,
+ LS1024A_PIN_CORESIGHT_D6, LS1024A_PIN_CORESIGHT_D7,
+ LS1024A_PIN_CORESIGHT_D8, LS1024A_PIN_CORESIGHT_D9,
+ LS1024A_PIN_CORESIGHT_D10, LS1024A_PIN_CORESIGHT_D11,
+ LS1024A_PIN_CORESIGHT_D12, LS1024A_PIN_CORESIGHT_D13,
+ LS1024A_PIN_CORESIGHT_D14, LS1024A_PIN_CORESIGHT_D15,
+ /* The last four GPIOs are in a non-intuitive order, i.e. they are in
+ * reverse order compared to how the pins are defined. */
+ LS1024A_PIN_TDM_DX, LS1024A_PIN_TDM_DR, LS1024A_PIN_TDM_FS, LS1024A_PIN_TDM_CK,
+};
+
+static const struct ls1024a_group ls1024a_groups[] = {
+ {
+ .name = "gpio",
+ .pins = gpio_pins,
+ .num_pins = ARRAY_SIZE(gpio_pins),
+ },
+ {
+ .name = "pwm0",
+ .pins = pwm0_pins,
+ .num_pins = ARRAY_SIZE(pwm0_pins),
+ .reg = LS1024A_PIN_SELECT_15_0_REG,
+ .shift = 8,
+ .bits = 2,
+ },
+ {
+ .name = "pwm1",
+ .pins = pwm1_pins,
+ .num_pins = ARRAY_SIZE(pwm1_pins),
+ .reg = LS1024A_PIN_SELECT_15_0_REG,
+ .shift = 10,
+ .bits = 2,
+ },
+ {
+ .name = "pwm2",
+ .pins = pwm2_pins,
+ .num_pins = ARRAY_SIZE(pwm2_pins),
+ .reg = LS1024A_PIN_SELECT_15_0_REG,
+ .shift = 12,
+ .bits = 2,
+ },
+ {
+ .name = "pwm3",
+ .pins = pwm3_pins,
+ .num_pins = ARRAY_SIZE(pwm3_pins),
+ .reg = LS1024A_PIN_SELECT_15_0_REG,
+ .shift = 14,
+ .bits = 2,
+ },
+ {
+ .name = "pwm4",
+ .pins = pwm4_pins,
+ .num_pins = ARRAY_SIZE(pwm4_pins),
+ .reg = LS1024A_PIN_SELECT_15_0_REG,
+ .shift = 24,
+ .bits = 2,
+ },
+ {
+ .name = "pwm5",
+ .pins = pwm5_pins,
+ .num_pins = ARRAY_SIZE(pwm5_pins),
+ .reg = LS1024A_PIN_SELECT_15_0_REG,
+ .shift = 26,
+ .bits = 2,
+ },
+ {
+ .name = "i2c",
+ .pins = i2c_pins,
+ .num_pins = ARRAY_SIZE(i2c_pins),
+ .reg = LS1024A_PIN_SELECT_31_16_REG,
+ .shift = 0,
+ .bits = 4,
+ },
+ {
+ .name = "uart0",
+ .pins = uart0_pins,
+ .num_pins = ARRAY_SIZE(uart0_pins),
+ },
+ {
+ .name = "uart1",
+ .pins = uart1_pins,
+ .num_pins = ARRAY_SIZE(uart1_pins),
+ },
+ {
+ .name = "spi_2",
+ .pins = spi_2_pins,
+ .num_pins = ARRAY_SIZE(spi_2_pins),
+ .reg = LS1024A_GPIO_63_32_PIN_SELECT,
+ .shift = 1,
+ .bits = 1,
+ },
+ {
+ .name = "spi_2_ss0",
+ .pins = spi_2_ss0_pins,
+ .num_pins = ARRAY_SIZE(spi_2_ss0_pins),
+ .reg = LS1024A_GPIO_63_32_PIN_SELECT,
+ .shift = 2,
+ .bits = 1,
+ },
+ {
+ .name = "spi_2_ss1",
+ .pins = spi_2_ss1_pins,
+ .num_pins = ARRAY_SIZE(spi_2_ss1_pins),
+ .reg = LS1024A_PIN_SELECT_31_16_REG,
+ .shift = 8, /* TODO */
+ .bits = 2,
+ },
+};
+
+static const char * const pwm_groups[] = { "pwm0", "pwm1", "pwm2", "pwm3", "pwm4", "pwm5" };
+static const char * const i2c_groups[] = { "i2c" };
+static const char * const uart0_groups[] = { "uart0" };
+static const char * const uart1_groups[] = { "uart1" };
+static const char * const spi_2_groups[] = { "spi_2", "spi_2_ss0", "spi_2_ss1" };
+
+struct ls1024a_pmx_func {
+ const char *name;
+ const char * const *groups;
+ const unsigned num_groups;
+ const unsigned muxsetting;
+};
+
+static const struct ls1024a_pmx_func ls1024a_functions[] = {
+ {
+ .name = "pwm",
+ .groups = pwm_groups,
+ .num_groups = ARRAY_SIZE(pwm_groups),
+ .muxsetting = 1,
+ },
+ {
+ .name = "i2c",
+ .groups = i2c_groups,
+ .num_groups = ARRAY_SIZE(i2c_groups),
+ .muxsetting = 0,
+ },
+ {
+ .name = "uart0",
+ .groups = uart0_groups,
+ .num_groups = ARRAY_SIZE(uart0_groups),
+ .muxsetting = 2,
+ },
+ {
+ .name = "uart1",
+ .groups = uart1_groups,
+ .num_groups = ARRAY_SIZE(uart1_groups),
+ .muxsetting = 0,
+ },
+ {
+ .name = "spi_2",
+ .groups = spi_2_groups,
+ .num_groups = ARRAY_SIZE(spi_2_groups),
+ .muxsetting = 0,
+ },
+};
+
+static int ls1024a_get_groups_count(struct pinctrl_dev *pctldev)
+{
+ return ARRAY_SIZE(ls1024a_groups);
+}
+
+static const char *ls1024a_get_group_name(struct pinctrl_dev *pctldev,
+ unsigned group)
+{
+ return ls1024a_groups[group].name;
+}
+
+static int ls1024a_get_group_pins(struct pinctrl_dev *pctldev,
+ unsigned group,
+ const unsigned **pins,
+ unsigned *num_pins)
+{
+ *pins = ls1024a_groups[group].pins;
+ *num_pins = ls1024a_groups[group].num_pins;
+ return 0;
+}
+
+static int ls1024a_get_functions_count(struct pinctrl_dev *pctldev)
+{
+ return ARRAY_SIZE(ls1024a_functions);
+}
+
+static const char *ls1024a_get_function_name(struct pinctrl_dev *pctldev,
+ unsigned function)
+{
+ return ls1024a_functions[function].name;
+}
+
+static int ls1024a_get_function_groups(struct pinctrl_dev *pctldev,
+ unsigned function,
+ const char * const **groups,
+ unsigned * const num_groups)
+{
+ *groups = ls1024a_functions[function].groups;
+ *num_groups = ls1024a_functions[function].num_groups;
+ return 0;
+}
+
+static int ls1024a_pinmux_set_mux(struct pinctrl_dev *pctldev,
+ unsigned function,
+ unsigned group)
+{
+ struct ls1024a_pinctrl *lpc = pinctrl_dev_get_drvdata(pctldev);
+ const struct ls1024a_group *g;
+ const struct ls1024a_pmx_func *f;
+ unsigned long flags;
+ u32 val;
+ u32 mask;
+
+ g = &ls1024a_groups[group];
+ f = &ls1024a_functions[function];
+
+ spin_lock_irqsave(&lpc->lock, flags);
+
+ val = readl(lpc->reg + g->reg);
+ mask = GENMASK(g->shift + g->bits - 1, g->shift);
+ val &= ~mask;
+ val |= f->muxsetting << g->shift;
+ writel(val, lpc->reg + g->reg);
+
+ spin_unlock_irqrestore(&lpc->lock, flags);
+
+ return 0;
+}
+
+static void _ls1024a_gpio_set_direction(struct ls1024a_pinctrl *lpc, unsigned int gpio, int out);
+
+static inline unsigned int pin_to_gpio(struct pinctrl_gpio_range *range,
+ unsigned int pin)
+{
+ int idx;
+ BUG_ON(!range->pins);
+ for (idx = 0; idx < range->npins; idx++) {
+ if (pin == range->pins[idx])
+ break;
+ }
+ BUG_ON(idx >= range->npins);
+ return idx;
+}
+
+static int ls1024a_gpio_request_enable (struct pinctrl_dev *pctldev,
+ struct pinctrl_gpio_range *range,
+ unsigned offset)
+{
+ struct ls1024a_pinctrl *lpc = pinctrl_dev_get_drvdata(pctldev);
+ unsigned long flags;
+ unsigned int gpio;
+ u32 val;
+ u32 newval;
+ unsigned int i;
+
+ gpio = pin_to_gpio(range, offset);
+
+ spin_lock_irqsave(&lpc->lock, flags);
+ if (offset >= LS1024A_PIN_TDM_CK && offset <= LS1024A_PIN_TDM_DX) {
+ /* GPIO 60 to GPIO 63 */
+ val = readl(lpc->reg + LS1024A_MISC_PIN_SELECT);
+ newval = (val & ~GENMASK(5,4)) | 2<<4;
+ if (newval != val) {
+ BUILD_BUG_ON(!(LS1024A_PIN_TDM_CK < LS1024A_PIN_TDM_DX));
+ for (i = LS1024A_PIN_TDM_CK; i <= LS1024A_PIN_TDM_DX; i++) {
+ gpio = pin_to_gpio(range, i);
+ _ls1024a_gpio_set_direction(lpc, gpio, 0);
+ }
+ writel(newval, lpc->reg + LS1024A_MISC_PIN_SELECT);
+ }
+ } else if (offset >= LS1024A_PIN_SPI_RXD && offset <= LS1024A_PIN_CORESIGHT_D15) {
+ /* GPIO 32 to GPIO 59 */
+ i = offset - LS1024A_PIN_SPI_RXD;
+ val = readl(lpc->reg + LS1024A_GPIO_63_32_PIN_SELECT);
+ newval = val | BIT(i);
+ if (newval != val) {
+ _ls1024a_gpio_set_direction(lpc, gpio, 0);
+ writel(newval, lpc->reg + LS1024A_GPIO_63_32_PIN_SELECT);
+ }
+ } else if ( (offset >= LS1024A_PIN_I2C_SCL && offset <= LS1024A_PIN_EXP_RDY) ||
+ (offset >= LS1024A_PIN_SPI_TXD && offset <= LS1024A_PIN_SPI_SCLK) ) {
+ /* GPIO 16 to GPIO 26 and GPIO 30 to GPIO 31
+ * From the datasheet:
+ * "GPIO[27] is used as TM_EXT_RESET and is not muxed
+ * GPIO[28] is used as EXP_NAND_CS and is not muxed
+ * GPIO[29] is used as EXP_NAND_RDY and is not muxed"
+ * */
+ i = offset - LS1024A_PIN_I2C_SCL;
+ val = readl(lpc->reg + LS1024A_PIN_SELECT_31_16_REG);
+ newval = (val & ~GENMASK(i*2 + 1, i*2)) | (1<<i*2);
+ if (newval != val) {
+ _ls1024a_gpio_set_direction(lpc, gpio, 0);
+ writel(newval, lpc->reg + LS1024A_PIN_SELECT_31_16_REG);
+ }
+ } else if (offset >= LS1024A_PIN_GPIO04 && offset <= LS1024A_PIN_GPIO15) {
+ /* GPIO 4 to GPIO 15 */
+ i = offset - LS1024A_PIN_GPIO00;
+ val = readl(lpc->reg + LS1024A_PIN_SELECT_15_0_REG);
+ newval = val & ~GENMASK(i*2 + 1, i*2);
+ if (newval != val) {
+ _ls1024a_gpio_set_direction(lpc, gpio, 0);
+ writel(newval, lpc->reg + LS1024A_PIN_SELECT_15_0_REG);
+ }
+ } else if (offset >= LS1024A_PIN_GPIO00 && offset <= LS1024A_PIN_GPIO03) {
+ /* No work change needed. GPIOs 0 through 3 are always selected. */
+ }
+
+ spin_unlock_irqrestore(&lpc->lock, flags);
+ return 0;
+}
+
+static const struct pinmux_ops ls1024a_pinmux_ops = {
+ .get_functions_count = ls1024a_get_functions_count,
+ .get_function_name = ls1024a_get_function_name,
+ .get_function_groups = ls1024a_get_function_groups,
+ .set_mux = ls1024a_pinmux_set_mux,
+ .gpio_request_enable = ls1024a_gpio_request_enable,
+};
+
+static const struct pinctrl_ops ls1024a_pinctrl_ops = {
+ .get_groups_count = ls1024a_get_groups_count,
+ .get_group_name = ls1024a_get_group_name,
+ .get_group_pins = ls1024a_get_group_pins,
+ .dt_node_to_map = pinconf_generic_dt_node_to_map_group,
+ .dt_free_map = pinctrl_utils_dt_free_map,
+};
+
+static struct pinctrl_desc ls1024a_pinctrl_desc = {
+ .pins = ls1024a_pins_desc,
+ .npins = ARRAY_SIZE(ls1024a_pins_desc),
+ .pctlops = &ls1024a_pinctrl_ops,
+ .pmxops = &ls1024a_pinmux_ops,
+ .owner = THIS_MODULE,
+};
+
+
+
+static int ls1024a_gpio_get(struct gpio_chip *gc, unsigned pin)
+{
+ u32 val;
+ struct ls1024a_pinctrl *lpc = gc_to_ls1024a_pinctrl(gc);
+
+ if (pin >= gc->ngpio)
+ return -EINVAL;
+
+ if (pin < 32) {
+ val = readl(lpc->reg + LS1024A_GPIO_INPUT_REG);
+ } else {
+ val = readl(lpc->reg + LS1024A_GPIO_63_32_PIN_INPUT);
+ }
+
+ if (val & BIT_MASK(pin))
+ return 1;
+
+ return 0;
+}
+
+static void ls1024a_gpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
+{
+ struct ls1024a_pinctrl *lpc = gc_to_ls1024a_pinctrl(gc);
+ unsigned long flags;
+
+ if (gpio >= gc->ngpio)
+ return;
+
+ spin_lock_irqsave(&lpc->lock, flags);
+
+ if (val)
+ lpc->data[BIT_WORD(gpio)] |= BIT_MASK(gpio);
+ else
+ lpc->data[BIT_WORD(gpio)] &= ~BIT_MASK(gpio);
+
+ writel(lpc->data[0], lpc->reg + LS1024A_GPIO_OUTPUT_REG);
+ writel(lpc->data[1], lpc->reg + LS1024A_GPIO_63_32_PIN_OUTPUT);
+
+ spin_unlock_irqrestore(&lpc->lock, flags);
+}
+
+static void _ls1024a_gpio_set_direction(struct ls1024a_pinctrl *lpc, unsigned int gpio, int out) {
+ if (out)
+ lpc->dir[BIT_WORD(gpio)] |= BIT_MASK(gpio);
+ else
+ lpc->dir[BIT_WORD(gpio)] &= ~BIT_MASK(gpio);
+
+ writel(lpc->dir[0], lpc->reg + LS1024A_GPIO_OE_REG);
+ /* LS1024A_GPIO_63_32_PIN_OUTPUT_EN uses inverse logic */
+ writel(~lpc->dir[1], lpc->reg + LS1024A_GPIO_63_32_PIN_OUTPUT_EN);
+}
+
+static int ls1024a_gpio_set_direction(struct gpio_chip *gc, unsigned int gpio, int out) {
+ struct ls1024a_pinctrl *lpc = gc_to_ls1024a_pinctrl(gc);
+ unsigned long flags;
+
+ if (gpio >= gc->ngpio)
+ return -EINVAL;
+
+ spin_lock_irqsave(&lpc->lock, flags);
+
+ _ls1024a_gpio_set_direction(lpc, gpio, out);
+
+ spin_unlock_irqrestore(&lpc->lock, flags);
+
+ return 0;
+}
+
+static int ls1024a_dir_in(struct gpio_chip *gc, unsigned int gpio)
+{
+ return ls1024a_gpio_set_direction(gc, gpio, 0);
+}
+
+static int ls1024a_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
+{
+ ls1024a_gpio_set(gc, gpio, val);
+ return ls1024a_gpio_set_direction(gc, gpio, 1);
+}
+
+static int ls1024a_gpio_request(struct gpio_chip *chip, unsigned gpio_pin)
+{
+ if (gpio_pin < chip->ngpio)
+ return pinctrl_request_gpio(chip->base + gpio_pin);
+
+ return -EINVAL;
+}
+
+static void ls1024a_gpio_free(struct gpio_chip *chip, unsigned gpio_pin)
+{
+ pinctrl_free_gpio(chip->base + gpio_pin);
+}
+
+static int ls1024a_set_type(struct irq_data *data, unsigned int type)
+{
+ struct ls1024a_pinctrl *lpc = irq_data_get_irq_chip_data(data);
+ int ls1024a_type;
+ int ret;
+ unsigned long flags;
+ u32 value;
+ switch(type) {
+ case IRQ_TYPE_EDGE_RISING:
+ ls1024a_type = 0x2;
+ break;
+ case IRQ_TYPE_EDGE_FALLING:
+ ls1024a_type = 0x1;
+ break;
+ case IRQ_TYPE_LEVEL_HIGH:
+ ls1024a_type = 0x3;
+ break;
+ default:
+ WARN_ON(1);
+ /* Fall through */
+ case IRQ_TYPE_NONE:
+ ls1024a_type = 0x0;
+ break;
+ }
+ spin_lock_irqsave(&lpc->lock, flags);
+ value = readl(lpc->reg + LS1024A_GPIO_INT_CFG_REG);
+ value &= ~(0x3 << data->hwirq*2);
+ value |= ls1024a_type << data->hwirq*2;
+ writel(value, lpc->reg + LS1024A_GPIO_INT_CFG_REG);
+ spin_unlock_irqrestore(&lpc->lock, flags);
+
+ data = data->parent_data;
+ ret = data->chip->irq_set_type(data, type);
+ return ret;
+}
+
+static struct irq_chip ls1024a_gpio_irq_chip = {
+ .name = "GPIO",
+ .irq_mask = irq_chip_mask_parent,
+ .irq_unmask = irq_chip_unmask_parent,
+ .irq_eoi = irq_chip_eoi_parent,
+ .irq_set_type = ls1024a_set_type,
+ .irq_retrigger = irq_chip_retrigger_hierarchy,
+ .irq_set_affinity = irq_chip_set_affinity_parent,
+};
+
+static int ls1024a_domain_alloc(struct irq_domain *domain, unsigned int virq,
+ unsigned int nr_irqs, void *arg)
+{
+ int i, ret;
+ irq_hw_number_t hwirq;
+ unsigned int type;
+ struct of_phandle_args *irq_data = arg;
+ struct of_phandle_args gic_data = *irq_data;
+ struct ls1024a_pinctrl *lpc = domain->host_data;
+
+ if (irq_data->args_count != 2)
+ return -EINVAL;
+
+ ret = domain->ops->xlate(domain, irq_data->np, irq_data->args,
+ irq_data->args_count, &hwirq, &type);
+ if (ret)
+ return ret;
+ for (i = 0; i < nr_irqs; i++)
+ irq_domain_set_hwirq_and_chip(domain, virq + i, hwirq + i,
+ &ls1024a_gpio_irq_chip,
+ domain->host_data);
+ gic_data = lpc->parent_phandle_args;
+ gic_data.args[1] += hwirq;
+ gic_data.args[2] = type;
+ return irq_domain_alloc_irqs_parent(domain, virq, nr_irqs, &gic_data);
+}
+
+static struct irq_domain_ops ls1024a_domain_ops = {
+ .xlate = irq_domain_xlate_twocell,
+ .alloc = ls1024a_domain_alloc,
+ .free = irq_domain_free_irqs_common,
+};
+
+
+static int ls1024a_pinctrl_probe(struct platform_device *pdev)
+{
+ struct device *dev = &pdev->dev;
+ struct device_node *node = dev->of_node;
+ struct resource *res;
+ struct ls1024a_pinctrl *lpc;
+ struct irq_domain *domain_parent;
+ unsigned long flags;
+ int rc;
+
+ lpc = devm_kzalloc(&pdev->dev, sizeof(*lpc), GFP_KERNEL);
+ if (!lpc)
+ return -ENOMEM;
+ lpc->dev = &pdev->dev;
+
+ lpc->gc.dev = dev;
+#ifdef CONFIG_OF_GPIO
+ lpc->gc.of_node = of_node_get(node);
+#endif
+ spin_lock_init(&lpc->lock);
+ lpc->gc.dev = dev;
+ lpc->gc.label = dev_name(dev);
+ lpc->gc.base = 0;
+ lpc->gc.ngpio = 64;
+ lpc->gc.request = ls1024a_gpio_request;
+ lpc->gc.free = ls1024a_gpio_free;
+
+ lpc->gc.direction_input = ls1024a_dir_in;
+ lpc->gc.direction_output = ls1024a_dir_out;
+ lpc->gc.set = ls1024a_gpio_set;
+ lpc->gc.get = ls1024a_gpio_get;
+ lpc->gc.can_sleep = false;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ lpc->reg = devm_ioremap_resource(&pdev->dev, res);
+ if (IS_ERR(lpc->reg)) {
+ rc = PTR_ERR(lpc->reg);
+ goto err;
+ }
+
+ platform_set_drvdata(pdev, lpc);
+
+ ls1024a_pinctrl_desc.name = dev_name(&pdev->dev);
+ lpc->pctrl = pinctrl_register(&ls1024a_pinctrl_desc, &pdev->dev, lpc);
+ if (!lpc->pctrl) {
+ dev_err(&pdev->dev, "Couldn't register pinctrl driver\n");
+ rc = -ENODEV;
+ goto err_iounmap;
+ }
+
+ rc = of_irq_parse_one(node, 0, &lpc->parent_phandle_args);
+ if (rc) {
+ goto err_unregister_pinctrl;
+ }
+ domain_parent = irq_find_host(lpc->parent_phandle_args.np);
+ if (!domain_parent) {
+ dev_err(dev, "cannot find irq parent domain\n");
+ rc = -EPROBE_DEFER;
+ goto err_unregister_pinctrl;
+ }
+ lpc->irq_domain = irq_domain_add_hierarchy(domain_parent, 0,
+ LS1024A_GPIO_NUM_IRQS, node,
+ &ls1024a_domain_ops, lpc);
+ if (!lpc->irq_domain) {
+ rc = -ENOMEM;
+ goto err_unregister_pinctrl;
+ }
+
+ spin_lock_irqsave(&lpc->lock, flags);
+ lpc->dir[0] = readl(lpc->reg + LS1024A_GPIO_OE_REG);
+ /* LS1024A_GPIO_63_32_PIN_OUTPUT_EN uses inverse logic */
+ lpc->dir[1] = ~readl(lpc->reg + LS1024A_GPIO_63_32_PIN_OUTPUT_EN);
+ lpc->data[0] = readl(lpc->reg + LS1024A_GPIO_OUTPUT_REG);
+ lpc->data[1] = readl(lpc->reg + LS1024A_GPIO_63_32_PIN_OUTPUT);
+ spin_unlock_irqrestore(&lpc->lock, flags);
+
+ lpc->gc.owner = THIS_MODULE;
+
+ rc = gpiochip_add(&lpc->gc);
+ if (rc)
+ goto err_remove_domain;
+ return 0;
+
+err_remove_domain:
+ irq_domain_remove(lpc->irq_domain);
+err_unregister_pinctrl:
+ pinctrl_unregister(lpc->pctrl);
+err_iounmap:
+ devm_iounmap(dev, lpc->reg);
+err:
+ platform_set_drvdata(pdev, NULL);
+ devm_kfree(dev, lpc);
+ return rc;
+}
+
+static const struct of_device_id ls1024a_pinctrl_of_match[] = {
+ { .compatible = "fsl,ls1024a-pinctrl", },
+ { },
+};
+
+static struct platform_driver ls1024a_pinctrl_driver = {
+ .driver = {
+ .name = "ls1024a-pinctrl",
+ .of_match_table = ls1024a_pinctrl_of_match,
+ },
+ .probe = ls1024a_pinctrl_probe,
+};
+
+module_platform_driver(ls1024a_pinctrl_driver);
+
+MODULE_AUTHOR("Daniel Mentz <danielmentz@google.com>");
+MODULE_DESCRIPTION("Freescale QorIQ LS1024A pinctrl driver");
+MODULE_LICENSE("GPL v2");
+MODULE_DEVICE_TABLE(of, ls1024a_pinctrl_of_match);
diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig
index b1541f4..5166de5 100644
--- a/drivers/pwm/Kconfig
+++ b/drivers/pwm/Kconfig
@@ -211,6 +211,15 @@
To compile this driver as a module, choose M here: the module
will be called pwm-lpss-platform.
+config PWM_LS1024A
+ tristate "Freescale QorIQ LS1024A PWM support"
+ depends on ARCH_COMCERTO && OF
+ help
+ PWM framework driver for Freescale QorIQ LS1024A
+
+ To compile this driver as a module, choose M here: the module
+ will be called pwm-ls1024a.
+
config PWM_MXS
tristate "Freescale MXS PWM support"
depends on ARCH_MXS && OF
diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile
index ec50eb5..2156996 100644
--- a/drivers/pwm/Makefile
+++ b/drivers/pwm/Makefile
@@ -18,6 +18,7 @@
obj-$(CONFIG_PWM_LPSS) += pwm-lpss.o
obj-$(CONFIG_PWM_LPSS_PCI) += pwm-lpss-pci.o
obj-$(CONFIG_PWM_LPSS_PLATFORM) += pwm-lpss-platform.o
+obj-$(CONFIG_PWM_LS1024A) += pwm-ls1024a.o
obj-$(CONFIG_PWM_MXS) += pwm-mxs.o
obj-$(CONFIG_PWM_PCA9685) += pwm-pca9685.o
obj-$(CONFIG_PWM_PUV3) += pwm-puv3.o
diff --git a/drivers/pwm/pwm-ls1024a.c b/drivers/pwm/pwm-ls1024a.c
new file mode 100644
index 0000000..ba0acbe
--- /dev/null
+++ b/drivers/pwm/pwm-ls1024a.c
@@ -0,0 +1,215 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2.
+ */
+
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/pwm.h>
+#include <linux/spinlock.h>
+#include <asm/div64.h>
+
+#define NUMBER_OF_PWMS 6
+
+#define CLK_DIV_VALUE 0xFF /* Maximum value */
+
+#define PWM_VALUE_MASK GENMASK(19,0)
+#define CLK_DIV_ENABLE BIT(31)
+#define PWM_ENABLE BIT(31)
+
+#define CLK_DIV_CTRL_REG 0
+#define ENABLE_MAX(x) (((x) * 0x8) + 0x8)
+#define LOW_DUTY(x) (((x) * 0x8) + 0xC)
+
+struct ls1024a_pwm {
+ struct pwm_chip chip;
+ struct device *dev;
+ unsigned long scaler;
+ unsigned long enabled_pwms;
+ void __iomem *base;
+ struct clk *clk;
+ spinlock_t lock;
+};
+
+static inline struct ls1024a_pwm *to_ls1024a_pwm(struct pwm_chip *chip)
+{
+ return container_of(chip, struct ls1024a_pwm, chip);
+}
+
+static int ls1024a_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
+ int duty_ns, int period_ns)
+{
+ struct ls1024a_pwm *pc = to_ls1024a_pwm(chip);
+ unsigned long flags;
+ u32 value;
+ unsigned long duty_ticks, period_ticks;
+
+ if (period_ns <= (int) pc->scaler) {
+ dev_err(pc->dev, "period %d not supported, minimum %lu\n",
+ period_ns, pc->scaler);
+ return -EINVAL;
+ }
+
+ spin_lock_irqsave(&pc->lock, flags);
+
+ period_ticks = DIV_ROUND_CLOSEST(period_ns, pc->scaler);
+ period_ticks = max(period_ticks, (unsigned long) 1) - 1;
+ value = readl(pc->base + ENABLE_MAX(pwm->hwpwm));
+ value &= ~PWM_VALUE_MASK;
+ value |= period_ticks & PWM_VALUE_MASK;
+ writel(value , pc->base + ENABLE_MAX(pwm->hwpwm));
+
+ duty_ticks = DIV_ROUND_CLOSEST(period_ns - duty_ns, pc->scaler);
+ duty_ticks = max(duty_ticks, (unsigned long) 1) - 1;
+ value = readl(pc->base + LOW_DUTY(pwm->hwpwm));
+ value &= ~PWM_VALUE_MASK;
+ value |= duty_ticks & PWM_VALUE_MASK;
+ writel(value, pc->base + LOW_DUTY(pwm->hwpwm));
+
+ spin_unlock_irqrestore(&pc->lock, flags);
+
+ return 0;
+}
+
+static int ls1024a_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
+{
+ struct ls1024a_pwm *pc = to_ls1024a_pwm(chip);
+ unsigned long flags;
+ u32 value;
+
+ spin_lock_irqsave(&pc->lock, flags);
+
+ value = readl(pc->base + ENABLE_MAX(pwm->hwpwm));
+ value |= PWM_ENABLE;
+ writel(value, pc->base + ENABLE_MAX(pwm->hwpwm));
+
+ pc->enabled_pwms |= BIT(pwm->hwpwm);
+
+ /* Enable clock divider */
+ value = readl(pc->base + CLK_DIV_CTRL_REG);
+ if (!(value & CLK_DIV_ENABLE)) {
+ value = CLK_DIV_ENABLE | CLK_DIV_VALUE;
+ writel(value, pc->base + CLK_DIV_CTRL_REG);
+ }
+
+ spin_unlock_irqrestore(&pc->lock, flags);
+
+ return 0;
+}
+
+static void ls1024a_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
+{
+ struct ls1024a_pwm *pc = to_ls1024a_pwm(chip);
+ unsigned long flags;
+ u32 value;
+
+ spin_lock_irqsave(&pc->lock, flags);
+
+ value = readl(pc->base + ENABLE_MAX(pwm->hwpwm));
+ value &= ~PWM_ENABLE;
+ writel(value, pc->base + ENABLE_MAX(pwm->hwpwm));
+
+ pc->enabled_pwms &= ~BIT(pwm->hwpwm);
+
+ /* If we disabled the last PWM, shut down the clock divider, too. */
+ if (!pc->enabled_pwms) {
+ value = readl(pc->base + CLK_DIV_CTRL_REG);
+ if (value & CLK_DIV_ENABLE) {
+ value &= ~CLK_DIV_ENABLE;
+ writel(value, pc->base + CLK_DIV_CTRL_REG);
+ }
+ }
+
+ spin_unlock_irqrestore(&pc->lock, flags);
+}
+
+static const struct pwm_ops ls1024a_pwm_ops = {
+ .config = ls1024a_pwm_config,
+ .enable = ls1024a_pwm_enable,
+ .disable = ls1024a_pwm_disable,
+ .owner = THIS_MODULE,
+};
+
+static int ls1024a_pwm_probe(struct platform_device *pdev)
+{
+ struct ls1024a_pwm *pc;
+ struct resource *res;
+ int ret;
+
+ pc = devm_kzalloc(&pdev->dev, sizeof(*pc), GFP_KERNEL);
+ if (!pc)
+ return -ENOMEM;
+
+ pc->dev = &pdev->dev;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ pc->base = devm_ioremap_resource(&pdev->dev, res);
+ if (IS_ERR(pc->base))
+ return PTR_ERR(pc->base);
+
+ pc->clk = devm_clk_get(&pdev->dev, NULL);
+ if (IS_ERR(pc->clk)) {
+ dev_err(&pdev->dev, "clock not found: %ld\n", PTR_ERR(pc->clk));
+ return PTR_ERR(pc->clk);
+ }
+
+ ret = clk_prepare_enable(pc->clk);
+ if (ret)
+ return ret;
+
+ pc->scaler = DIV_ROUND_CLOSEST_ULL((u64) NSEC_PER_SEC *
+ (CLK_DIV_VALUE + 1),
+ clk_get_rate(pc->clk));
+
+ pc->chip.dev = &pdev->dev;
+ pc->chip.ops = &ls1024a_pwm_ops;
+ pc->chip.npwm = NUMBER_OF_PWMS;
+
+ spin_lock_init(&pc->lock);
+
+ platform_set_drvdata(pdev, pc);
+
+ ret = pwmchip_add(&pc->chip);
+ if (ret < 0)
+ goto add_fail;
+
+ return 0;
+
+add_fail:
+ clk_disable_unprepare(pc->clk);
+ return ret;
+}
+
+static int ls1024a_pwm_remove(struct platform_device *pdev)
+{
+ struct ls1024a_pwm *pc = platform_get_drvdata(pdev);
+
+ clk_disable_unprepare(pc->clk);
+
+ return pwmchip_remove(&pc->chip);
+}
+
+static const struct of_device_id ls1024a_pwm_of_match[] = {
+ { .compatible = "fsl,ls1024a-pwm", },
+ { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, ls1024a_pwm_of_match);
+
+static struct platform_driver ls1024a_pwm_driver = {
+ .driver = {
+ .name = "ls1024a-pwm",
+ .of_match_table = ls1024a_pwm_of_match,
+ },
+ .probe = ls1024a_pwm_probe,
+ .remove = ls1024a_pwm_remove,
+};
+module_platform_driver(ls1024a_pwm_driver);
+
+MODULE_AUTHOR("Daniel Mentz <danielmentz@google.com");
+MODULE_DESCRIPTION("Freescale LS1024A PWM driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/reset/Makefile b/drivers/reset/Makefile
index 157d421..9d92fe2 100644
--- a/drivers/reset/Makefile
+++ b/drivers/reset/Makefile
@@ -2,4 +2,5 @@
obj-$(CONFIG_ARCH_SOCFPGA) += reset-socfpga.o
obj-$(CONFIG_ARCH_BERLIN) += reset-berlin.o
obj-$(CONFIG_ARCH_SUNXI) += reset-sunxi.o
+obj-$(CONFIG_ARCH_COMCERTO) += reset-ls1024a.o
obj-$(CONFIG_ARCH_STI) += sti/
diff --git a/drivers/reset/reset-ls1024a.c b/drivers/reset/reset-ls1024a.c
new file mode 100644
index 0000000..4cce5ef
--- /dev/null
+++ b/drivers/reset/reset-ls1024a.c
@@ -0,0 +1,228 @@
+/*
+ * Freescale LS1024A SoCs Reset Controller driver
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/reset-controller.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/regmap.h>
+#include <linux/mfd/syscon.h>
+#include <linux/module.h>
+#include <dt-bindings/reset-controller/ls1024a-resets.h>
+
+/**
+ * Reset channel regmap configuration
+ *
+ * @reset: regmap field for the channel's reset bit.
+ */
+struct reset_channel {
+ struct regmap_field *reset;
+};
+
+struct ls1024a_reset_data {
+ spinlock_t lock;
+ struct regmap *regmap;
+ struct reset_channel *channels;
+ struct reset_controller_dev rcdev;
+};
+
+#define DEVICE_RST_CNTRL 0x000
+#define SERDES_RST_CNTRL 0x004
+#define PCIe_SATA_RST_CNTRL 0x008
+#define USB_RST_CNTRL 0x00C
+#define AXI_RESET_0 0x050
+#define AXI_RESET_1 0x054
+#define AXI_RESET_2 0x058
+#define A9DP_MPU_RESET 0x070
+#define A9DP_CPU_RESET 0x078
+#define A9DP_RESET 0x088
+#define L2CC_RESET_CNTRL 0x098
+#define TPI_RESET 0x0A8
+#define CSYS_RESET 0x0B8
+#define EXTPHY0_RESET 0x0C8
+#define EXTPHY1_RESET 0x0D8
+#define EXTPHY2_RESET 0x0E8
+#define DDR_RESET 0x0F8
+#define PFE_RESET 0x108
+#define IPSEC_RESET 0x118
+#define DECT_RESET_CNTRL 0x128
+#define GEMTX_RESET_CNTRL 0x138
+#define TDMNTG_RESET_CNTRL 0x148
+#define TSUNTG_RESET 0x158
+#define SATA_PMU_RESET_CNTRL 0x168
+#define SATA_OOB_RESET_CNTRL 0x178
+#define SATA_OCC_RESET 0x188
+#define PCIE_OCC_RESET 0x198
+#define SGMII_OCC_RESET 0x1A8
+
+#define RESET_BIT(_rr, _rb) REG_FIELD((_rr), (_rb), (_rb))
+
+static const struct reg_field reset_bits[] = {
+ [LS1024A_AXI_DPI_CIE_RESET] = RESET_BIT(AXI_RESET_0, 5),
+ [LS1024A_AXI_DPI_DECOMP_RESET] = RESET_BIT(AXI_RESET_0, 6),
+ [LS1024A_AXI_IPSEC_EAPE_RESET] = RESET_BIT(AXI_RESET_1, 1),
+ [LS1024A_AXI_IPSEC_SPACC_RESET] = RESET_BIT(AXI_RESET_1, 2),
+ [LS1024A_PFE_SYS_RESET] = RESET_BIT(AXI_RESET_1, 3),
+ [LS1024A_AXI_TDM_RESET] = RESET_BIT(AXI_RESET_1, 4),
+ [LS1024A_AXI_RTC_RESET] = RESET_BIT(AXI_RESET_1, 7),
+ [LS1024A_AXI_PCIE0_RESET] = RESET_BIT(AXI_RESET_2, 0),
+ [LS1024A_AXI_PCIE1_RESET] = RESET_BIT(AXI_RESET_2, 1),
+ [LS1024A_AXI_SATA_RESET] = RESET_BIT(AXI_RESET_2, 2),
+ [LS1024A_AXI_USB0_RESET] = RESET_BIT(AXI_RESET_2, 3),
+ [LS1024A_AXI_USB1_RESET] = RESET_BIT(AXI_RESET_2, 4),
+ [LS1024A_USB0_PHY_RESET] = RESET_BIT(USB_RST_CNTRL, 0),
+ [LS1024A_UTMI_USB0_RESET] = RESET_BIT(USB_RST_CNTRL, 1),
+ [LS1024A_USB1_PHY_RESET] = RESET_BIT(USB_RST_CNTRL, 4),
+ [LS1024A_UTMI_USB1_RESET] = RESET_BIT(USB_RST_CNTRL, 5),
+ [LS1024A_SERDES_PCIE0_RESET] = REG_FIELD(PCIe_SATA_RST_CNTRL, 0, 1),
+ [LS1024A_SERDES_PCIE1_RESET] = REG_FIELD(PCIe_SATA_RST_CNTRL, 2, 3),
+ [LS1024A_SERDES_SATA0_RESET] = REG_FIELD(PCIe_SATA_RST_CNTRL, 4, 5),
+ [LS1024A_SERDES_SATA1_RESET] = REG_FIELD(PCIe_SATA_RST_CNTRL, 6, 7),
+ [LS1024A_PFE_CORE_RESET] = RESET_BIT(PFE_RESET, 0),
+ [LS1024A_IPSEC_EAPE_CORE_RESET] = RESET_BIT(IPSEC_RESET, 0),
+ [LS1024A_GEMTX_RESET] = RESET_BIT(GEMTX_RESET_CNTRL, 0),
+ [LS1024A_DECT_RESET] = RESET_BIT(DECT_RESET_CNTRL, 0),
+ [LS1024A_DDR_CNTLR_RESET] = RESET_BIT(DDR_RESET, 1),
+ [LS1024A_DDR_PHY_RESET] = RESET_BIT(DDR_RESET, 0),
+ [LS1024A_SERDES0_RESET] = RESET_BIT(SERDES_RST_CNTRL, 0),
+ [LS1024A_SERDES1_RESET] = RESET_BIT(SERDES_RST_CNTRL, 1),
+ [LS1024A_SERDES2_RESET] = RESET_BIT(SERDES_RST_CNTRL, 2),
+ [LS1024A_SGMII_RESET] = RESET_BIT(SGMII_OCC_RESET, 0),
+ [LS1024A_SATA_PMU_RESET] = RESET_BIT(SATA_PMU_RESET_CNTRL, 0),
+ [LS1024A_SATA_OOB_RESET] = RESET_BIT(SATA_OOB_RESET_CNTRL, 0),
+ [LS1024A_TDMNTG_RESET] = RESET_BIT(TDMNTG_RESET_CNTRL, 0),
+};
+
+#define to_ls1024a_reset_data(_rst) \
+ container_of(_rst, struct ls1024a_reset_data, rcdev)
+
+static int ls1024a_reset_program_hw(struct reset_controller_dev *rcdev,
+ unsigned long idx, int assert)
+{
+ struct ls1024a_reset_data *rst = to_ls1024a_reset_data(rcdev);
+ const struct reset_channel *ch;
+ u32 ctrl_val = assert ? 0xFFFFFFFF : 0;
+ int err;
+
+ if (idx >= rcdev->nr_resets)
+ return -EINVAL;
+
+ ch = &rst->channels[idx];
+
+ err = regmap_field_write(ch->reset, ctrl_val);
+ if (err)
+ return err;
+
+ return 0;
+}
+
+static int ls1024a_reset_assert(struct reset_controller_dev *rcdev,
+ unsigned long idx)
+{
+ return ls1024a_reset_program_hw(rcdev, idx, true);
+}
+
+static int ls1024a_reset_deassert(struct reset_controller_dev *rcdev,
+ unsigned long idx)
+{
+ return ls1024a_reset_program_hw(rcdev, idx, false);
+}
+
+static int ls1024a_reset_status(struct reset_controller_dev *rcdev,
+ unsigned long idx)
+{
+ struct ls1024a_reset_data *rst = to_ls1024a_reset_data(rcdev);
+ const struct reset_channel *ch;
+ unsigned cur_val;
+ int err;
+
+ if (idx >= rcdev->nr_resets)
+ return -EINVAL;
+
+ ch = &rst->channels[idx];
+
+ err = regmap_field_read(ch->reset, &cur_val);
+ if (err)
+ return err;
+
+ return cur_val;
+}
+
+static struct reset_control_ops ls1024a_reset_ops = {
+ .assert = ls1024a_reset_assert,
+ .deassert = ls1024a_reset_deassert,
+ .status = ls1024a_reset_status,
+};
+
+static int ls1024a_reset_probe(struct platform_device *pdev)
+{
+ struct ls1024a_reset_data *data;
+ size_t size;
+ int i;
+
+ data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
+ if (!data)
+ return -ENOMEM;
+
+ size = sizeof(struct reset_channel) * ARRAY_SIZE(reset_bits);
+
+ data->channels = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
+ if (!data->channels)
+ return -ENOMEM;
+
+ data->regmap = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "syscon");
+ if (IS_ERR(data->regmap)) {
+ dev_err(&pdev->dev,
+ "Error retrieving reset syscon\n");
+ return PTR_ERR(data->regmap);
+ }
+ spin_lock_init(&data->lock);
+
+ data->rcdev.owner = THIS_MODULE;
+ data->rcdev.nr_resets = ARRAY_SIZE(reset_bits);
+ data->rcdev.ops = &ls1024a_reset_ops;
+ data->rcdev.of_node = pdev->dev.of_node;
+
+ for (i = 0; i < ARRAY_SIZE(reset_bits); i++) {
+ struct regmap_field *f;
+ const struct reg_field zero = {0};
+
+ if (memcmp(&reset_bits[i], &zero, sizeof(zero))) {
+ f = devm_regmap_field_alloc(&pdev->dev, data->regmap, reset_bits[i]);
+ if (IS_ERR(f))
+ return PTR_ERR(f);
+ data->channels[i].reset = f;
+ }
+
+ }
+
+ return reset_controller_register(&data->rcdev);
+}
+
+static const struct of_device_id ls1024a_reset_dt_ids[] = {
+ { .compatible = "fsl,ls1024a-reset", },
+ { /* sentinel */ },
+};
+MODULE_DEVICE_TABLE(of, ls1024a_reset_dt_ids);
+
+static struct platform_driver ls1024a_reset_driver = {
+ .probe = ls1024a_reset_probe,
+ .driver = {
+ .name = "ls1024a-reset",
+ .of_match_table = ls1024a_reset_dt_ids,
+ },
+};
+static int __init ls1024a_reset_init(void)
+{
+ return platform_driver_register(&ls1024a_reset_driver);
+}
+
+arch_initcall(ls1024a_reset_init);
+
+MODULE_DESCRIPTION("Freescale LS1024A SoCs Reset Controller Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi-dw.c b/drivers/spi/spi-dw.c
index 4fbfcdc..851bb67 100644
--- a/drivers/spi/spi-dw.c
+++ b/drivers/spi/spi-dw.c
@@ -138,17 +138,27 @@
}
#endif /* CONFIG_DEBUG_FS */
-static void dw_spi_set_cs(struct spi_device *spi, bool enable)
+static void __dw_spi_set_cs(struct spi_device *spi, bool enable)
{
struct dw_spi *dws = spi_master_get_devdata(spi->master);
+
+ if (!enable)
+ dw_writel(dws, DW_SPI_SER, BIT(spi->chip_select));
+ else
+ dw_writel(dws, DW_SPI_SER, 0);
+}
+
+static void dw_spi_set_cs(struct spi_device *spi, bool enable)
+{
+
struct chip_data *chip = spi_get_ctldata(spi);
/* Chip select logic is inverted from spi_set_cs() */
if (chip && chip->cs_control)
chip->cs_control(!enable);
- if (!enable)
- dw_writel(dws, DW_SPI_SER, BIT(spi->chip_select));
+ if (enable)
+ __dw_spi_set_cs(spi, enable);
}
/* Return the max entries we can fill into tx fifo */
@@ -197,6 +207,7 @@
dw_write_io_reg(dws, DW_SPI_DR, txw);
dws->tx += dws->n_bytes;
}
+ __dw_spi_set_cs(dws->master->cur_msg->spi, 0);
}
static void dw_reader(struct dw_spi *dws)
@@ -316,7 +327,8 @@
speed = transfer->speed_hz;
/* clk_div doesn't support odd number */
- clk_div = (dws->max_freq / speed + 1) & 0xfffe;
+ clk_div = (DIV_ROUND_UP(dws->max_freq, speed) + 1) &
+ 0xfffe;
chip->speed_hz = speed;
chip->clk_div = clk_div;
@@ -370,6 +382,7 @@
if (dws->dma_mapped) {
ret = dws->dma_ops->dma_setup(dws, transfer);
if (ret < 0) {
+ __dw_spi_set_cs(spi, 0);
spi_enable_chip(dws, 1);
return ret;
}
diff --git a/drivers/tty/serial/8250/8250_core.c b/drivers/tty/serial/8250/8250_core.c
index a64d53f..7bc2148 100644
--- a/drivers/tty/serial/8250/8250_core.c
+++ b/drivers/tty/serial/8250/8250_core.c
@@ -1634,6 +1634,15 @@
DEBUG_INTR("status = %x...", status);
+ /* The Synopsys DesignWare UART (DW_apb_uart) sometimes gets into a
+ * weird state where the IIR reads "Character timeout" but the Data
+ * Ready bit in the LSR is not set. To avoid a stuck interrupt, we need
+ * to clear it by reading the receive buffer register. We achieve this
+ * by faking the Data Ready bit (DR) */
+ if ( (iir & UART_IIR_TOD) == UART_IIR_TOD && ! (status & UART_LSR_DR)) {
+ status |= UART_LSR_DR;
+ }
+
if (status & (UART_LSR_DR | UART_LSR_BI)) {
if (up->dma)
dma_err = up->dma->rx_dma(up, iir);
diff --git a/drivers/tty/serial/8250/8250_dw.c b/drivers/tty/serial/8250/8250_dw.c
index 176f18f..d7352d9 100644
--- a/drivers/tty/serial/8250/8250_dw.c
+++ b/drivers/tty/serial/8250/8250_dw.c
@@ -181,7 +181,6 @@
d->last_mcr = value;
writel(value, p->membase + (offset << p->regshift));
-
/* Make sure LCR write wasn't ignored */
if (offset == UART_LCR) {
int tries = 1000;
diff --git a/drivers/tty/tty_io.c b/drivers/tty/tty_io.c
index be96970..ee6d368 100644
--- a/drivers/tty/tty_io.c
+++ b/drivers/tty/tty_io.c
@@ -3216,10 +3216,18 @@
static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
unsigned int index, unsigned int count)
{
+ int err;
+
/* init here, since reused cdevs cause crashes */
- cdev_init(&driver->cdevs[index], &tty_fops);
- driver->cdevs[index].owner = driver->owner;
- return cdev_add(&driver->cdevs[index], dev, count);
+ driver->cdevs[index] = cdev_alloc();
+ if (!driver->cdevs[index])
+ return -ENOMEM;
+ driver->cdevs[index]->ops = &tty_fops;
+ driver->cdevs[index]->owner = driver->owner;
+ err = cdev_add(driver->cdevs[index], dev, count);
+ if (err)
+ kobject_put(&driver->cdevs[index]->kobj);
+ return err;
}
/**
@@ -3325,8 +3333,10 @@
error:
put_device(dev);
- if (cdev)
- cdev_del(&driver->cdevs[index]);
+ if (cdev) {
+ cdev_del(driver->cdevs[index]);
+ driver->cdevs[index] = NULL;
+ }
return ERR_PTR(retval);
}
EXPORT_SYMBOL_GPL(tty_register_device_attr);
@@ -3346,8 +3356,10 @@
{
device_destroy(tty_class,
MKDEV(driver->major, driver->minor_start) + index);
- if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC))
- cdev_del(&driver->cdevs[index]);
+ if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
+ cdev_del(driver->cdevs[index]);
+ driver->cdevs[index] = NULL;
+ }
}
EXPORT_SYMBOL(tty_unregister_device);
@@ -3412,6 +3424,7 @@
kfree(driver->ports);
kfree(driver->ttys);
kfree(driver->termios);
+ kfree(driver->cdevs);
kfree(driver);
return ERR_PTR(err);
}
@@ -3440,7 +3453,7 @@
}
proc_tty_unregister_driver(driver);
if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
- cdev_del(&driver->cdevs[0]);
+ cdev_del(driver->cdevs[0]);
}
kfree(driver->cdevs);
kfree(driver->ports);
diff --git a/drivers/usb/dwc3/Kconfig b/drivers/usb/dwc3/Kconfig
index 827c4f8..b905889 100644
--- a/drivers/usb/dwc3/Kconfig
+++ b/drivers/usb/dwc3/Kconfig
@@ -97,6 +97,14 @@
Recent Qualcomm SoCs ship with one DesignWare Core USB3 IP inside,
say 'Y' or 'M' if you have one such device.
+config USB_DWC3_LS1024A
+ tristate "Freescale QorIQ LS1024A"
+ depends on ARCH_COMCERTO || COMPILE_TEST
+ default USB_DWC3
+ help
+ Freescale QorIQ LS1024A with one DesignWare Core USB3 IP inside,
+ say 'Y' or 'M' if you have one such device.
+
comment "Debugging features"
config USB_DWC3_DEBUG
diff --git a/drivers/usb/dwc3/Makefile b/drivers/usb/dwc3/Makefile
index 46172f4..6f51230 100644
--- a/drivers/usb/dwc3/Makefile
+++ b/drivers/usb/dwc3/Makefile
@@ -35,5 +35,6 @@
obj-$(CONFIG_USB_DWC3_EXYNOS) += dwc3-exynos.o
obj-$(CONFIG_USB_DWC3_PCI) += dwc3-pci.o
obj-$(CONFIG_USB_DWC3_KEYSTONE) += dwc3-keystone.o
+obj-$(CONFIG_USB_DWC3_LS1024A) += dwc3-ls1024a.o
obj-$(CONFIG_USB_DWC3_QCOM) += dwc3-qcom.o
obj-$(CONFIG_USB_DWC3_ST) += dwc3-st.o
diff --git a/drivers/usb/dwc3/dwc3-ls1024a.c b/drivers/usb/dwc3/dwc3-ls1024a.c
new file mode 100644
index 0000000..a344502
--- /dev/null
+++ b/drivers/usb/dwc3/dwc3-ls1024a.c
@@ -0,0 +1,112 @@
+/**
+ * dwc3-ls1024a.c Support for dwc3 platform devices on Freescale QorIQ LS1024A
+ *
+ * This is a small driver for the dwc3 to provide the glue logic
+ * to configure the controller.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/reset.h>
+
+struct ls1024a_dwc {
+ struct device *dev;
+ struct reset_control *rstc_utmi;
+ struct reset_control *rstc_axi;
+ struct clk *clk;
+};
+
+static int ls1024a_dwc_probe(struct platform_device *pdev)
+{
+ struct ls1024a_dwc *dwc3_data;
+ struct device *dev = &pdev->dev;
+ struct device_node *node = dev->of_node;
+ int ret;
+
+ dwc3_data = devm_kzalloc(dev, sizeof(*dwc3_data), GFP_KERNEL);
+ if (!dwc3_data)
+ return -ENOMEM;
+
+ dwc3_data->dev = dev;
+
+ dwc3_data->clk = devm_clk_get(dev, "usb");
+ if (IS_ERR(dwc3_data->clk)) {
+ ret = PTR_ERR(dwc3_data->clk);
+ goto undo_platform_dev_alloc;
+ }
+ clk_prepare_enable(dwc3_data->clk);
+
+ dwc3_data->rstc_utmi = devm_reset_control_get(dev, "utmi");
+ if (IS_ERR(dwc3_data->rstc_utmi)) {
+ ret = PTR_ERR(dwc3_data->rstc_utmi);
+ goto undo_clk;
+ }
+
+ if (reset_control_status(dwc3_data->rstc_utmi)) {
+ reset_control_deassert(dwc3_data->rstc_utmi);
+ udelay(1000);
+ }
+
+ dwc3_data->rstc_axi = devm_reset_control_get(dev, "axi");
+ if (IS_ERR(dwc3_data->rstc_axi)) {
+ ret = PTR_ERR(dwc3_data->rstc_axi);
+ goto undo_utmi;
+ }
+
+ if (reset_control_status(dwc3_data->rstc_axi)) {
+ reset_control_deassert(dwc3_data->rstc_axi);
+ udelay(1000);
+ }
+
+ /* Allocate and initialize the core */
+ ret = of_platform_populate(node, NULL, NULL, dev);
+ if (ret) {
+ dev_err(dev, "failed to add dwc3 core\n");
+ goto undo_axi;
+ }
+
+ platform_set_drvdata(pdev, dwc3_data);
+ return 0;
+
+undo_axi:
+ reset_control_assert(dwc3_data->rstc_axi);
+undo_utmi:
+ reset_control_assert(dwc3_data->rstc_utmi);
+undo_clk:
+ clk_disable_unprepare(dwc3_data->clk);
+undo_platform_dev_alloc:
+ platform_device_put(pdev);
+ return ret;
+}
+
+static const struct of_device_id ls1024a_dwc_match[] = {
+ { .compatible = "fsl,ls1024a-dwc3" },
+ { /* sentinel */ },
+};
+
+MODULE_DEVICE_TABLE(of, ls1024a_dwc_match);
+
+static struct platform_driver ls1024a_dwc_driver = {
+ .probe = ls1024a_dwc_probe,
+ .driver = {
+ .name = "usb-ls1024a-dwc3",
+ .of_match_table = ls1024a_dwc_match,
+ },
+};
+
+module_platform_driver(ls1024a_dwc_driver);
+
+MODULE_AUTHOR("Daniel Mentz <danielmentz@google.com>");
+MODULE_DESCRIPTION("DesignWare USB3 Freescale QorIQ LS1024a Glue Layer");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index e5e7c55..9d8f79a 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -514,6 +514,15 @@
To compile this driver as a module, choose M here: the
module will be called mtk_wdt.
+config LS1024A_WATCHDOG
+ tristate "LS1024A Watchdog"
+ depends on ARCH_COMCERTO
+ help
+ Say Y here to include support for the watchdog timer
+ in Freescale QorIQ LS1024A device.
+ To compile this driver as a module, choose M here: the
+ module will be called ls1024a_wdt.
+
# AVR32 Architecture
config AT32AP700X_WDT
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index 5c19294..96a705a 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -64,6 +64,7 @@
obj-$(CONFIG_TEGRA_WATCHDOG) += tegra_wdt.o
obj-$(CONFIG_MESON_WATCHDOG) += meson_wdt.o
obj-$(CONFIG_MEDIATEK_WATCHDOG) += mtk_wdt.o
+obj-$(CONFIG_LS1024A_WATCHDOG) += ls1024a_wdt.o
# AVR32 Architecture
obj-$(CONFIG_AT32AP700X_WDT) += at32ap700x_wdt.o
diff --git a/drivers/watchdog/ls1024a_wdt.c b/drivers/watchdog/ls1024a_wdt.c
new file mode 100644
index 0000000..5d0ec0a
--- /dev/null
+++ b/drivers/watchdog/ls1024a_wdt.c
@@ -0,0 +1,501 @@
+/*
+ * drivers/watchdog/ls1024a_wdt.c
+ *
+ * Copyright (C) 2004,2005,2013 Mindspeed Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/platform_device.h>
+#include <linux/types.h>
+#include <linux/watchdog.h>
+#include <linux/clk.h>
+#include <linux/timer.h>
+#include <linux/io.h>
+#include <linux/regmap.h>
+#include <linux/mfd/syscon.h>
+#include <asm/bitops.h>
+#include <asm/uaccess.h>
+
+#define LS1024A_TIMER_WDT_HIGH_BOUND 0x0
+#define LS1024A_TIMER_WDT_CONTROL 0x4
+#define LS1024A_TIMER_WDT_CONTROL_TIMER_ENABLE BIT(0)
+#define LS1024A_TIMER_WDT_CURRENT_COUNT 0x8
+
+#define LS1024A_DEVICE_RST_CNTRL 0x0
+#define LS1024A_WD_STATUS_CLR BIT(6)
+#define LS1024A_AXI_WD_RST_EN BIT(5)
+#define LS1024A_GNRL_DEVICE_STATUS 0x18
+#define LS1024A_AXI_WD_RST_ACTIVATED BIT(0)
+
+#define WDT_NAME "comcerto_wdt"
+
+/* these are the actual wdt limits */
+#define WDT_DEFAULT_TIMEOUT 5
+#define WDT_MAX_TIMEOUT (0xffffffff / LS1024A_AHBCLK)
+
+/* these are for the virtual wdt */
+#define WDT_DEFAULT_TIME 70 /* seconds */
+#define WDT_MAX_TIME 255 /* seconds */
+
+static unsigned long LS1024A_AHBCLK;
+static int wd_heartbeat = WDT_DEFAULT_TIMEOUT;
+static int wd_time = WDT_DEFAULT_TIME;
+static int nowayout = WATCHDOG_NOWAYOUT;
+static struct clk *axi_clk;
+static struct regmap *clk_rst_map;
+static void __iomem *ls1024a_wdt_base;
+
+module_param(wd_heartbeat, int, 0);
+MODULE_PARM_DESC(wd_heartbeat, "Watchdog heartbeat in seconds. (default="__MODULE_STRING(WDT_DEFAULT_TIMEOUT) ")");
+
+module_param(wd_time, int, 0);
+MODULE_PARM_DESC(wd_time, "Watchdog time in seconds. (default="__MODULE_STRING(WDT_DEFAULT_TIME) ")");
+
+#ifdef CONFIG_WATCHDOG_NOWAYOUT
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+#endif
+
+static struct timer_list wdt_timer;
+
+static unsigned long ls1024a_wdt_busy;
+static char expect_close;
+static spinlock_t wdt_lock;
+static atomic_t ticks;
+
+/*
+ * Inform whether the boot was caused by AXI watchdog or not.
+ * If the boot was caused by AXI WDT, the WD status is cleared from
+ * reset control register.
+ */
+static int ls1024a_wdt_rst_status(void)
+{
+ unsigned long flags;
+ u32 val;
+ int ret = 0;
+
+ spin_lock_irqsave(&wdt_lock, flags);
+
+ regmap_read(clk_rst_map, LS1024A_GNRL_DEVICE_STATUS, &val);
+
+ if (val & LS1024A_AXI_WD_RST_ACTIVATED) {
+ regmap_update_bits(clk_rst_map, LS1024A_DEVICE_RST_CNTRL,
+ LS1024A_WD_STATUS_CLR,
+ LS1024A_WD_STATUS_CLR);
+ ret = 1;
+ }
+
+ spin_unlock_irqrestore(&wdt_lock, flags);
+
+ return ret;
+}
+
+/*
+ * Set a new heartbeat value for the watchdog device. If the heartbeat value is
+ * incorrect we keep the old value and return -EINVAL. If successfull we return 0.
+ */
+static int ls1024a_wdt_set_heartbeat(int t)
+{
+ if (t < 1 || t > WDT_MAX_TIMEOUT)
+ return -EINVAL;
+
+ wd_heartbeat = t;
+ return 0;
+}
+
+/*
+ * Write wd_heartbeat to high bound register.
+ */
+static void ls1024a_wdt_pet_watchdog_physical(void)
+{
+ __raw_writel(wd_heartbeat * LS1024A_AHBCLK,
+ ls1024a_wdt_base + LS1024A_TIMER_WDT_HIGH_BOUND);
+}
+
+/*
+ * reset virtual wdt timer
+ */
+static void ls1024a_wdt_pet_watchdog_virtual(void)
+{
+ atomic_set(&ticks, wd_time);
+}
+
+/*
+ * set virtual wd timeout reset value
+ */
+static int ls1024a_wdt_settimeout(int new_time)
+{
+ if ((new_time <= 0) || (new_time > WDT_MAX_TIME))
+ return -EINVAL;
+
+ wd_time = new_time;
+ return 0;
+}
+
+/*
+ * implement virtual wdt on physical wdt with timer
+ */
+static void ls1024a_timer_tick(unsigned long unused)
+{
+ if (!atomic_dec_and_test(&ticks)) {
+ ls1024a_wdt_pet_watchdog_physical();
+ mod_timer(&wdt_timer, jiffies + HZ);
+ } else {
+ printk(KERN_CRIT "%s: Watchdog will fire soon!!!\n", WDT_NAME);
+ }
+}
+
+/*
+ * Disable the watchdog.
+ */
+static void ls1024a_wdt_stop(void)
+{
+ unsigned long flags;
+ u32 wdt_control;
+
+ spin_lock_irqsave(&wdt_lock, flags);
+
+ del_timer(&wdt_timer);
+
+ wdt_control = __raw_readl(ls1024a_wdt_base + LS1024A_TIMER_WDT_CONTROL);
+ wdt_control &= ~LS1024A_TIMER_WDT_CONTROL_TIMER_ENABLE;
+ __raw_writel(wdt_control, ls1024a_wdt_base + LS1024A_TIMER_WDT_CONTROL);
+
+ spin_unlock_irqrestore(&wdt_lock, flags);
+
+ ls1024a_wdt_pet_watchdog_physical();
+}
+
+/*
+ * Enable the watchdog.
+ */
+static void ls1024a_wdt_start(void)
+{
+ unsigned long flags;
+ u32 wdt_control;
+
+ spin_lock_irqsave(&wdt_lock, flags);
+
+ wdt_control = __raw_readl(ls1024a_wdt_base + LS1024A_TIMER_WDT_CONTROL);
+ wdt_control |= LS1024A_TIMER_WDT_CONTROL_TIMER_ENABLE;
+ __raw_writel(wdt_control, ls1024a_wdt_base + LS1024A_TIMER_WDT_CONTROL);
+
+ regmap_update_bits(clk_rst_map, LS1024A_DEVICE_RST_CNTRL,
+ LS1024A_AXI_WD_RST_EN, LS1024A_AXI_WD_RST_EN);
+
+ mod_timer(&wdt_timer, jiffies + HZ);
+
+ spin_unlock_irqrestore(&wdt_lock, flags);
+}
+
+/*
+ * Disable WDT and:
+ * - set max. possible timeout to avoid reset, it can occur
+ * since current counter value could be bigger then
+ * high bound one at the moment
+ * Function is called once at start (while configuration),
+ * and it's safe not to disable/enable IRQs.
+ */
+static void ls1024a_wdt_config(void)
+{
+ ls1024a_wdt_stop();
+
+ __raw_writel(~0, ls1024a_wdt_base + LS1024A_TIMER_WDT_HIGH_BOUND); /* write max timeout */
+}
+
+/*
+ * Watchdog device is opened, and watchdog starts running.
+ */
+static int ls1024a_wdt_open(struct inode *inode, struct file *file)
+{
+ if (test_and_set_bit(0, &ls1024a_wdt_busy))
+ return -EBUSY;
+
+ ls1024a_wdt_pet_watchdog_virtual();
+ ls1024a_wdt_pet_watchdog_physical();
+ ls1024a_wdt_start();
+
+ return nonseekable_open(inode, file);
+}
+
+/*
+ * Release the watchdog device.
+ * If CONFIG_WATCHDOG_NOWAYOUT is NOT defined and expect_close == 42
+ * i.e. magic char 'V' has been passed while write() then the watchdog
+ * is also disabled.
+ */
+static int ls1024a_wdt_release(struct inode *inode, struct file *file)
+{
+ if (expect_close == 42) {
+ ls1024a_wdt_stop(); /* disable the watchdog when file is closed */
+ clear_bit(0, &ls1024a_wdt_busy);
+ } else {
+ printk(KERN_CRIT "%s: closed unexpectedly. WDT will not stop!\n", WDT_NAME);
+ }
+
+ expect_close = 0;
+ return 0;
+}
+
+/*
+ * Handle commands from user-space.
+ */
+static long ls1024a_wdt_ioctl(struct file *file, uint cmd, ulong arg)
+{
+ void __user *argp = (void __user *)arg;
+ int __user *p = argp;
+ int new_value;
+ int err;
+ static struct watchdog_info ls1024a_wdt_info = {
+ .options = WDIOF_SETTIMEOUT |
+ WDIOF_MAGICCLOSE |
+ WDIOF_KEEPALIVEPING,
+ .firmware_version = 1,
+ };
+
+ switch(cmd) {
+ case WDIOC_KEEPALIVE:
+ ls1024a_wdt_pet_watchdog_virtual();
+ break;
+
+ case WDIOC_GETSUPPORT:
+ strncpy(ls1024a_wdt_info.identity, WDT_NAME, sizeof(ls1024a_wdt_info.identity));
+ if (copy_to_user(argp, &ls1024a_wdt_info, sizeof(ls1024a_wdt_info)) != 0) {
+ err = -EFAULT;
+ goto err;
+ }
+ break;
+
+ case WDIOC_SETTIMEOUT:
+ if (get_user(new_value, p)) {
+ err = -EFAULT;
+ goto err;
+ }
+
+ if (ls1024a_wdt_settimeout(new_value)) {
+ err = -EINVAL;
+ goto err;
+ }
+
+ ls1024a_wdt_pet_watchdog_virtual();
+
+ return put_user(wd_time, p);
+ break;
+
+ case WDIOC_GETTIMEOUT:
+ return put_user(wd_time, p);
+ break;
+
+ case WDIOC_GETSTATUS:
+ return put_user(0, p);
+ break;
+
+ case WDIOC_GETBOOTSTATUS:
+ return put_user(ls1024a_wdt_rst_status(), p);
+ break;
+
+ case WDIOC_SETOPTIONS:
+ if (get_user(new_value, p)) {
+ err = -EFAULT;
+ goto err;
+ }
+
+ if (new_value & WDIOS_DISABLECARD)
+ ls1024a_wdt_stop();
+
+ if (new_value & WDIOS_ENABLECARD)
+ ls1024a_wdt_start();
+
+ break;
+
+ default:
+ err = -ENOIOCTLCMD;
+ goto err;
+ break;
+ }
+
+ return 0;
+
+err:
+ return err;
+}
+
+/*
+ * Pat the watchdog whenever device is written to.
+ */
+static ssize_t ls1024a_wdt_write(struct file *file, const char *buf, size_t len, loff_t *ppos)
+{
+ if (len) {
+ if (!nowayout) {
+ size_t i;
+ char c;
+
+ /* in case it was set long ago */
+ expect_close = 0;
+
+ for (i = 0; i != len; i++) {
+ if (get_user(c, buf + i))
+ return -EFAULT;
+
+ if (c == 'V')
+ expect_close = 42;
+ }
+ }
+
+ ls1024a_wdt_pet_watchdog_virtual();
+ }
+
+ return len;
+}
+
+static const struct file_operations ls1024a_wdt_fops = {
+ .owner = THIS_MODULE,
+ .llseek = no_llseek,
+ .unlocked_ioctl = ls1024a_wdt_ioctl,
+ .open = ls1024a_wdt_open,
+ .release = ls1024a_wdt_release,
+ .write = ls1024a_wdt_write,
+};
+
+static struct miscdevice ls1024a_wdt_miscdev = {
+ .minor = WATCHDOG_MINOR,
+ .name = WDT_NAME,
+ .fops = &ls1024a_wdt_fops,
+};
+
+static int ls1024a_wdt_probe(struct platform_device *pdev)
+{
+ int res;
+ struct resource *iores_mem;
+ struct device *dev = &pdev->dev;
+
+ if (ls1024a_wdt_miscdev.parent)
+ return -EBUSY;
+
+ spin_lock_init(&wdt_lock);
+
+ axi_clk = devm_clk_get(dev, NULL);
+ if (IS_ERR(axi_clk)) {
+ dev_err(dev, "unable to obtain AXI clock: %ld\n", PTR_ERR(axi_clk));
+ return -ENODEV;
+ }
+
+ res = clk_prepare_enable(axi_clk);
+ if (res) {
+ dev_err(dev, "failed to enable AXI clock\n");
+ goto err_clk;
+ }
+
+ LS1024A_AHBCLK = clk_get_rate(axi_clk);
+
+ iores_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (!iores_mem) {
+ dev_err(dev, "unable to obtain IORESOURCE_MEM\n");
+ goto err_mem;
+ }
+
+ ls1024a_wdt_base = devm_ioremap_resource(dev, iores_mem);
+ if (IS_ERR(ls1024a_wdt_base)) {
+ dev_err(dev, "devm_ioremap_resource failed: %ld\n", PTR_ERR(ls1024a_wdt_base));
+ goto err_mem;
+ }
+
+ clk_rst_map = syscon_regmap_lookup_by_phandle(dev->of_node, "regmap");
+ if (IS_ERR(clk_rst_map)) {
+ dev_err(dev, "unable to obtain regmap: %ld\n", PTR_ERR(clk_rst_map));
+ goto err_misc;
+ }
+
+ setup_timer(&wdt_timer, ls1024a_timer_tick, 0L);
+
+ ls1024a_wdt_miscdev.parent = dev;
+ ls1024a_wdt_config();
+
+ res = misc_register(&ls1024a_wdt_miscdev);
+ if (res)
+ goto err_misc;
+
+ /* check that the heartbeat value is within range; if not reset to the default */
+ if (ls1024a_wdt_set_heartbeat(wd_heartbeat)) {
+ ls1024a_wdt_set_heartbeat(WDT_DEFAULT_TIMEOUT);
+
+ dev_err(dev, "wd_heartbeat value is out of range: 1..%lu, using %d\n",
+ WDT_MAX_TIMEOUT, WDT_DEFAULT_TIMEOUT);
+ }
+
+ /* check that the time value is within range; if not reset to the default */
+ if (ls1024a_wdt_settimeout(wd_time)) {
+ ls1024a_wdt_settimeout(WDT_DEFAULT_TIMEOUT);
+
+ dev_err(dev, "wd_time value is out of range: 1..%d, using %d\n",
+ WDT_MAX_TIME, WDT_DEFAULT_TIME);
+ }
+
+ return 0;
+
+err_misc:
+ devm_iounmap(dev, ls1024a_wdt_base);
+err_mem:
+ clk_disable_unprepare(axi_clk);
+err_clk:
+ devm_clk_put(dev, axi_clk);
+
+ return res;
+}
+
+static int ls1024a_wdt_remove(struct platform_device *pdev)
+{
+ int res;
+
+ res = misc_deregister(&ls1024a_wdt_miscdev);
+ if (!res)
+ ls1024a_wdt_miscdev.parent = NULL;
+
+ devm_iounmap(&pdev->dev, ls1024a_wdt_base);
+ clk_disable_unprepare(axi_clk);
+ devm_clk_put(&pdev->dev, axi_clk);
+
+ return res;
+}
+
+static const struct of_device_id ls1024a_wdt_of_match[] = {
+ { .compatible = "fsl,ls1024a-wdt", },
+ {},
+};
+MODULE_DEVICE_TABLE(of, ls1024a_wdt_of_match);
+
+static struct platform_driver ls1024a_wdt_driver = {
+ .driver = {
+ .name = WDT_NAME,
+ .of_match_table = ls1024a_wdt_of_match,
+ },
+ .probe = ls1024a_wdt_probe,
+ .remove = ls1024a_wdt_remove,
+};
+
+module_platform_driver(ls1024a_wdt_driver);
+
+MODULE_AUTHOR("Mindspeed Technologies, Inc.");
+MODULE_DESCRIPTION("Watchdog driver for Freescale QorIQ LS1024A devices");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 145d6ba..d2962a5 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1032,6 +1032,7 @@
#define EXT4_MOUNT_POSIX_ACL 0x08000 /* POSIX Access Control Lists */
#define EXT4_MOUNT_NO_AUTO_DA_ALLOC 0x10000 /* No auto delalloc mapping */
#define EXT4_MOUNT_BARRIER 0x20000 /* Use block barriers */
+#define EXT4_MOUNT_PIN_BLOCK_BITMAPS 0x40000 /* Pin block bitmaps */
#define EXT4_MOUNT_QUOTA 0x80000 /* Some quota option set */
#define EXT4_MOUNT_USRQUOTA 0x100000 /* "old" user quota */
#define EXT4_MOUNT_GRPQUOTA 0x200000 /* "old" group quota */
@@ -1342,6 +1343,9 @@
unsigned long s_mb_last_group;
unsigned long s_mb_last_start;
+ /* gid that's allowed to see stale data via falloc flag. */
+ kgid_t nohide_stale_gid;
+
/* stats for buddy allocator */
atomic_t s_bal_reqs; /* number of reqs with len > 1 */
atomic_t s_bal_success; /* we found long enough chunks */
@@ -2680,6 +2684,7 @@
#ifdef DOUBLE_CHECK
void *bb_bitmap;
#endif
+ struct buffer_head *bb_bh;
struct rw_semaphore alloc_sem;
ext4_grpblk_t bb_counters[]; /* Nr of free power-of-two-block
* regions, index is order.
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index a3276bf..e8e57ff 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -4685,6 +4685,9 @@
if (len <= EXT_UNWRITTEN_MAX_LEN)
flags |= EXT4_GET_BLOCKS_NO_NORMALIZE;
+ if (mode & FALLOC_FL_NO_HIDE_STALE)
+ flags &= ~EXT4_GET_BLOCKS_UNWRIT_EXT;
+
/*
* credits to insert 1 extent into extent tree
*/
@@ -4907,6 +4910,7 @@
int flags;
ext4_lblk_t lblk;
unsigned int blkbits = inode->i_blkbits;
+ struct ext4_sb_info *sbi;
/*
* Encrypted inodes can't handle collapse range or insert
@@ -4924,9 +4928,20 @@
/* Return error if mode is not supported */
if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
+ FALLOC_FL_NO_HIDE_STALE |
FALLOC_FL_COLLAPSE_RANGE | FALLOC_FL_ZERO_RANGE))
return -EOPNOTSUPP;
+ sbi = EXT4_SB(inode->i_sb);
+ /* Must have RAWIO to see stale data. */
+ if ((mode & FALLOC_FL_NO_HIDE_STALE) &&
+ !in_egroup_p(sbi->nohide_stale_gid))
+ return -EACCES;
+
+ /* preallocation to directories is currently not supported */
+ if (S_ISDIR(inode->i_mode))
+ return -ENODEV;
+
if (mode & FALLOC_FL_PUNCH_HOLE)
return ext4_punch_hole(inode, offset, len);
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 4723d8b..cdabf73 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -730,6 +730,33 @@
}
/*
+ * Manage pinning (and unpinning) block bitmaps
+ */
+static void ext4_pin_block_bitmaps(struct super_block *sb)
+{
+ ext4_group_t i, ngroups = ext4_get_groups_count(sb);
+ struct ext4_group_info *grinfo;
+
+ for (i = 0; i < ngroups; i++) {
+ grinfo = ext4_get_group_info(sb, i);
+ if (!grinfo->bb_bh)
+ grinfo->bb_bh = ext4_read_block_bitmap(sb, i);
+ }
+}
+
+static void ext4_unpin_block_bitmaps(struct super_block *sb)
+{
+ ext4_group_t i, ngroups = ext4_get_groups_count(sb);
+ struct ext4_group_info *grinfo;
+
+ for (i = 0; i < ngroups; i++) {
+ grinfo = ext4_get_group_info(sb, i);
+ brelse(grinfo->bb_bh);
+ grinfo->bb_bh = NULL;
+ }
+}
+
+/*
* Release the journal device
*/
static void ext4_blkdev_put(struct block_device *bdev)
@@ -792,6 +819,7 @@
ext4_es_unregister_shrinker(sbi);
del_timer_sync(&sbi->s_err_report);
ext4_release_system_zone(sb);
+ ext4_unpin_block_bitmaps(sb);
ext4_mb_release(sb);
ext4_ext_release(sb);
ext4_xattr_put_super(sb);
@@ -1147,6 +1175,8 @@
Opt_no_mbcache,
Opt_discard, Opt_nodiscard, Opt_init_itable, Opt_noinit_itable,
Opt_max_dir_size_kb, Opt_nojournal_checksum,
+ Opt_nohide_stale_gid,
+ Opt_pin_block_bitmaps, Opt_nopin_block_bitmaps,
};
static const match_table_t tokens = {
@@ -1228,6 +1258,9 @@
{Opt_noinit_itable, "noinit_itable"},
{Opt_max_dir_size_kb, "max_dir_size_kb=%u"},
{Opt_test_dummy_encryption, "test_dummy_encryption"},
+ {Opt_nohide_stale_gid, "nohide_stale_gid=%u"},
+ {Opt_pin_block_bitmaps, "pin_block_bitmaps"},
+ {Opt_nopin_block_bitmaps, "nopin_block_bitmaps"},
{Opt_removed, "check=none"}, /* mount option from ext2/3 */
{Opt_removed, "nocheck"}, /* mount option from ext2/3 */
{Opt_removed, "reservation"}, /* mount option from ext2/3 */
@@ -1431,6 +1464,9 @@
{Opt_jqfmt_vfsv1, QFMT_VFS_V1, MOPT_QFMT},
{Opt_max_dir_size_kb, 0, MOPT_GTE0},
{Opt_test_dummy_encryption, 0, MOPT_GTE0},
+ {Opt_nohide_stale_gid, 0, MOPT_GTE0},
+ {Opt_pin_block_bitmaps, EXT4_MOUNT_PIN_BLOCK_BITMAPS, MOPT_SET},
+ {Opt_nopin_block_bitmaps, EXT4_MOUNT_PIN_BLOCK_BITMAPS, MOPT_CLEAR},
{Opt_err, 0, 0}
};
@@ -1538,6 +1574,13 @@
sbi->s_li_wait_mult = arg;
} else if (token == Opt_max_dir_size_kb) {
sbi->s_max_dir_size_kb = arg;
+ } else if (token == Opt_nohide_stale_gid) {
+ gid = make_kgid(&init_user_ns, arg);
+ if (!gid_valid(gid)) {
+ ext4_msg(sb, KERN_ERR, "Invalid gid value %d", arg);
+ return -1;
+ }
+ sbi->nohide_stale_gid = gid;
} else if (token == Opt_stripe) {
sbi->s_stripe = arg;
} else if (token == Opt_resuid) {
@@ -1860,6 +1903,10 @@
SEQ_OPTS_PRINT("init_itable=%u", sbi->s_li_wait_mult);
if (nodefs || sbi->s_max_dir_size_kb)
SEQ_OPTS_PRINT("max_dir_size_kb=%u", sbi->s_max_dir_size_kb);
+ if (gid_valid(sbi->nohide_stale_gid))
+ SEQ_OPTS_PRINT("nohide_stale_gid=%u",
+ from_kgid_munged(&init_user_ns,
+ sbi->nohide_stale_gid));
ext4_show_quota_options(seq, sb);
return 0;
@@ -3630,6 +3677,9 @@
sbi->s_min_batch_time = EXT4_DEF_MIN_BATCH_TIME;
sbi->s_max_batch_time = EXT4_DEF_MAX_BATCH_TIME;
+ /* Default to having no-hide-stale disabled. */
+ sbi->nohide_stale_gid = INVALID_GID;
+
if ((def_mount_opts & EXT4_DEFM_NOBARRIER) == 0)
set_opt(sb, BARRIER);
@@ -4310,6 +4360,8 @@
"the device does not support discard");
}
+ if (test_opt(sb, PIN_BLOCK_BITMAPS))
+ ext4_pin_block_bitmaps(sb);
ext4_msg(sb, KERN_INFO, "mounted filesystem with%s. "
"Opts: %s%s%s", descr, sbi->s_es->s_mount_opts,
*sbi->s_es->s_mount_opts ? "; " : "", orig_data);
@@ -5137,6 +5189,11 @@
}
#endif
+ if (test_opt(sb, PIN_BLOCK_BITMAPS))
+ ext4_pin_block_bitmaps(sb);
+ if (!test_opt(sb, PIN_BLOCK_BITMAPS))
+ ext4_unpin_block_bitmaps(sb);
+
*flags = (*flags & ~MS_LAZYTIME) | (sb->s_flags & MS_LAZYTIME);
ext4_msg(sb, KERN_INFO, "re-mounted. Opts: %s", orig_data);
kfree(orig_data);
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index 2dc8ce4..b072f87 100644
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -170,6 +170,7 @@
}
ubifs_err(c, "cannot read page %lu of inode %lu, error %d",
page->index, inode->i_ino, err);
+ ubifs_ro_mode(c, err);
goto error;
}
diff --git a/include/dt-bindings/reset-controller/ls1024a-resets.h b/include/dt-bindings/reset-controller/ls1024a-resets.h
new file mode 100644
index 0000000..8af45e2
--- /dev/null
+++ b/include/dt-bindings/reset-controller/ls1024a-resets.h
@@ -0,0 +1,48 @@
+/*
+ * This header provides constants for the reset controller based peripheral
+ * powerdown requests on the Freescale LS1024A SoC.
+ */
+#ifndef _DT_BINDINGS_RESET_CONTROLLER_LS1024A
+#define _DT_BINDINGS_RESET_CONTROLLER_LS1024A
+
+#define LS1024A_AXI_RTC_RESET 1
+#define LS1024A_AXI_LEGACY_SPI_RESET 2
+#define LS1024A_AXI_I2C_RESET 3
+#define LS1024A_AXI_DMA_RESET 4
+#define LS1024A_AXI_FAST_UART_RESET 5
+#define LS1024A_AXI_FAST_SPI_RESET 6
+#define LS1024A_AXI_TDM_RESET 7
+#define LS1024A_PFE_SYS_RESET 8
+#define LS1024A_AXI_IPSEC_EAPE_RESET 9
+#define LS1024A_AXI_IPSEC_SPACC_RESET 10
+#define LS1024A_AXI_DPI_CIE_RESET 11
+#define LS1024A_AXI_DPI_DECOMP_RESET 12
+#define LS1024A_AXI_USB1_RESET 13 /* USB controller1, AXI Clock Domain reset control */
+#define LS1024A_UTMI_USB1_RESET 14 /* USB controller1,UTMI Clock Domain reset control*/
+#define LS1024A_USB1_PHY_RESET 15 /* USB PHY1 Reset control */
+#define LS1024A_AXI_USB0_RESET 16 /* USB controller0, AXI Clock Domain reset control*/
+#define LS1024A_UTMI_USB0_RESET 17 /* USB controller0. UTMI Clock Domain reset control */
+#define LS1024A_USB0_PHY_RESET 18 /* USB PHY0 Reset Control */
+#define LS1024A_AXI_SATA_RESET 19 /* SATA controller AXI Clock Domain Control Both for SATA 0/1*/
+#define LS1024A_SERDES_SATA0_RESET 20 /* SATA serdes Controller0 TX,Core Logic and RX clock domain control*/
+#define LS1024A_SERDES_SATA1_RESET 21 /* SATA serdes Controller1 TX,Core Logic and RX clock domain control*/
+#define LS1024A_AXI_PCIE1_RESET 22 /* PCIE Controller1,AXI Clock Domain reset control*/
+#define LS1024A_SERDES_PCIE1_RESET 23 /* PCIE serdes Controller1 Striky register and power register*/
+#define LS1024A_AXI_PCIE0_RESET 24 /* PCIE Controller0,AXI Clock Domain reset control*/
+#define LS1024A_SERDES_PCIE0_RESET 25 /* PCIE Controller1,TX,Core Logic and RX clock domain control*/
+#define LS1024A_PFE_CORE_RESET 26
+#define LS1024A_IPSEC_EAPE_CORE_RESET 27
+#define LS1024A_GEMTX_RESET 28
+#define LS1024A_L2CC_RESET 29
+#define LS1024A_DECT_RESET 30
+#define LS1024A_DDR_CNTLR_RESET 31
+#define LS1024A_DDR_PHY_RESET 32
+#define LS1024A_SERDES0_RESET 33
+#define LS1024A_SERDES1_RESET 34
+#define LS1024A_SERDES2_RESET 35
+#define LS1024A_SGMII_RESET 36
+#define LS1024A_SATA_PMU_RESET 37
+#define LS1024A_SATA_OOB_RESET 38
+#define LS1024A_TDMNTG_RESET 39
+
+#endif /* _DT_BINDINGS_RESET_CONTROLLER_LS1024A */
diff --git a/include/linux/antirebootloop.h b/include/linux/antirebootloop.h
new file mode 100644
index 0000000..78b48ff
--- /dev/null
+++ b/include/linux/antirebootloop.h
@@ -0,0 +1,28 @@
+#ifndef __ANTIREBOOTLOOP_H
+#define __ANTIREBOOTLOOP_H
+
+#ifdef CONFIG_ANTIREBOOTLOOP
+
+#include <linux/types.h>
+
+#define ARL_MAGIC 0x1c93f311
+#define ARL_KERNEL_VERSION 1
+
+struct arl_marker {
+ u32 magic[16]; /* Use a 64 byte magic value to increase the likelihood
+ of detecting bit flips. magic[i] = ARL_MAGIC + i for
+ 0<i<15. */
+ u32 counter; /* bootloader increments this counter on every boot
+ attempt. Kernel resets it to 0. */
+ /* The term version refers to this anti-reboot-loop mechanism not to
+ * the barebox or kernel version number */
+ u32 bootloader_version; /* ARL version supported by bootloader */
+ u32 kernel_version; /* ARL version supported by bootloader. Filled in
+ by kernel. */
+};
+
+phys_addr_t get_antirebootloop_ptr(void);
+
+#endif
+
+#endif
diff --git a/include/linux/falloc.h b/include/linux/falloc.h
index 9961110..aa57335 100644
--- a/include/linux/falloc.h
+++ b/include/linux/falloc.h
@@ -23,6 +23,7 @@
#define FALLOC_FL_SUPPORTED_MASK (FALLOC_FL_KEEP_SIZE | \
FALLOC_FL_PUNCH_HOLE | \
+ FALLOC_FL_NO_HIDE_STALE | \
FALLOC_FL_COLLAPSE_RANGE | \
FALLOC_FL_ZERO_RANGE | \
FALLOC_FL_INSERT_RANGE)
diff --git a/include/linux/i2c-mux.h b/include/linux/i2c-mux.h
index b5f9a00..f6f8230 100644
--- a/include/linux/i2c-mux.h
+++ b/include/linux/i2c-mux.h
@@ -42,6 +42,23 @@
int (*deselect) (struct i2c_adapter *,
void *mux_dev, u32 chan_id));
+/*
+ * Called to create a i2c bus on a multiplexed bus segment.
+ * The mux_dev and chan_id parameters are passed to the select
+ * and deselect callback functions to perform hardware-specific
+ * mux control. Additionaly the number of i2c transfers is passed
+ * to the select callback.
+ */
+struct i2c_adapter *i2c_add_mux_adapter_num(struct i2c_adapter *parent,
+ struct device *mux_dev,
+ void *mux_priv, u32 force_nr, u32 chan_id,
+ unsigned int class,
+ int (*select_num) (struct i2c_adapter *,
+ void *mux_dev, u32 chan_id,
+ int num),
+ int (*deselect) (struct i2c_adapter *,
+ void *mux_dev, u32 chan_id));
+
void i2c_del_mux_adapter(struct i2c_adapter *adap);
#endif /* __KERNEL__ */
diff --git a/include/linux/if_bridge.h b/include/linux/if_bridge.h
index dad8b00..96d3c6f 100644
--- a/include/linux/if_bridge.h
+++ b/include/linux/if_bridge.h
@@ -56,6 +56,21 @@
struct list_head *br_ip_list);
bool br_multicast_has_querier_anywhere(struct net_device *dev, int proto);
bool br_multicast_has_querier_adjacent(struct net_device *dev, int proto);
+#if defined(CONFIG_ARCH_COMCERTO)
+struct brevent_fdb_update{
+ char * mac_addr;
+ struct net_device * dev;
+};
+
+enum brevent_notif_type {
+ BREVENT_PORT_DOWN = 1, /* arg is struct net_device ptr */
+ BREVENT_FDB_UPDATE /* arg is struct brevent_fdb_update ptr */
+};
+
+int register_brevent_notifier(struct notifier_block *nb);
+int unregister_brevent_notifier(struct notifier_block *nb);
+int call_brevent_notifiers(unsigned long val, void *v);
+#endif
#else
static inline int br_multicast_list_adjacent(struct net_device *dev,
struct list_head *br_ip_list)
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index 12b75f3..3b6564d 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -1026,4 +1026,9 @@
/* get timing characteristics from ONFI timing mode. */
const struct nand_sdr_timings *onfi_async_timing_mode_to_sdr_timings(int mode);
+
+int nand_check_erased_ecc_chunk(void *data, int datalen,
+ void *ecc, int ecclen,
+ void *extraoob, int extraooblen,
+ int threshold);
#endif /* __LINUX_MTD_NAND_H */
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index ddd47c3..73a5445 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -1550,6 +1550,9 @@
netdev_features_t hw_enc_features;
netdev_features_t mpls_features;
+ /* This is pointing to network device that offload WiFi data to PFE */
+ struct net_device *wifi_offload_dev;
+
int ifindex;
int group;
@@ -2201,6 +2204,7 @@
return dev_queue_xmit_sk(skb->sk, skb);
}
int dev_queue_xmit_accel(struct sk_buff *skb, void *accel_priv);
+int original_dev_queue_xmit(struct sk_buff *skb);
int register_netdevice(struct net_device *dev);
void unregister_netdevice_queue(struct net_device *dev, struct list_head *head);
void unregister_netdevice_many(struct list_head *head);
@@ -2983,6 +2987,7 @@
{
return netif_receive_skb_sk(skb->sk, skb);
}
+int capture_receive_skb(struct sk_buff *skb);
gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb);
void napi_gro_flush(struct napi_struct *napi, bool flush_old);
struct sk_buff *napi_get_frags(struct napi_struct *napi);
diff --git a/include/linux/netfilter/netfilter_helpers.h b/include/linux/netfilter/netfilter_helpers.h
new file mode 100644
index 0000000..903f374
--- /dev/null
+++ b/include/linux/netfilter/netfilter_helpers.h
@@ -0,0 +1,133 @@
+/*
+ * Helpers for netfiler modules. This file provides implementations for basic
+ * functions such as strncasecmp(), etc.
+ *
+ * gcc will warn for defined but unused functions, so we only include the
+ * functions requested. The following macros are used:
+ * NF_NEED_STRNCASECMP nf_strncasecmp()
+ * NF_NEED_STRTOU16 nf_strtou16()
+ * NF_NEED_STRTOU32 nf_strtou32()
+ */
+#ifndef _NETFILTER_HELPERS_H
+#define _NETFILTER_HELPERS_H
+
+/* Only include these functions for kernel code. */
+#ifdef __KERNEL__
+
+#include <linux/ctype.h>
+#define iseol(c) ( (c) == '\r' || (c) == '\n' )
+
+/*
+ * The standard strncasecmp()
+ */
+#ifdef NF_NEED_STRNCASECMP
+static int
+nf_strncasecmp(const char* s1, const char* s2, u_int32_t len)
+{
+ if (s1 == NULL || s2 == NULL)
+ {
+ if (s1 == NULL && s2 == NULL)
+ {
+ return 0;
+ }
+ return (s1 == NULL) ? -1 : 1;
+ }
+ while (len > 0 && tolower(*s1) == tolower(*s2))
+ {
+ len--;
+ s1++;
+ s2++;
+ }
+ return ( (len == 0) ? 0 : (tolower(*s1) - tolower(*s2)) );
+}
+#endif /* NF_NEED_STRNCASECMP */
+
+/*
+ * Parse a string containing a 16-bit unsigned integer.
+ * Returns the number of chars used, or zero if no number is found.
+ */
+#ifdef NF_NEED_STRTOU16
+static int
+nf_strtou16(const char* pbuf, u_int16_t* pval)
+{
+ int n = 0;
+
+ *pval = 0;
+ while (isdigit(pbuf[n]))
+ {
+ *pval = (*pval * 10) + (pbuf[n] - '0');
+ n++;
+ }
+
+ return n;
+}
+#endif /* NF_NEED_STRTOU16 */
+
+/*
+ * Parse a string containing a 32-bit unsigned integer.
+ * Returns the number of chars used, or zero if no number is found.
+ */
+#ifdef NF_NEED_STRTOU32
+static int
+nf_strtou32(const char* pbuf, u_int32_t* pval)
+{
+ int n = 0;
+
+ *pval = 0;
+ while (pbuf[n] >= '0' && pbuf[n] <= '9')
+ {
+ *pval = (*pval * 10) + (pbuf[n] - '0');
+ n++;
+ }
+
+ return n;
+}
+#endif /* NF_NEED_STRTOU32 */
+
+/*
+ * Given a buffer and length, advance to the next line and mark the current
+ * line.
+ */
+#ifdef NF_NEED_NEXTLINE
+static int
+nf_nextline(char* p, uint len, uint* poff, uint* plineoff, uint* plinelen)
+{
+ uint off = *poff;
+ uint physlen = 0;
+
+ if (off >= len)
+ {
+ return 0;
+ }
+
+ while (p[off] != '\n')
+ {
+ if (len-off <= 1)
+ {
+ return 0;
+ }
+
+ physlen++;
+ off++;
+ }
+
+ /* if we saw a crlf, physlen needs adjusted */
+ if (physlen > 0 && p[off] == '\n' && p[off-1] == '\r')
+ {
+ physlen--;
+ }
+
+ /* advance past the newline */
+ off++;
+
+ *plineoff = *poff;
+ *plinelen = physlen;
+ *poff = off;
+
+ return 1;
+}
+#endif /* NF_NEED_NEXTLINE */
+
+#endif /* __KERNEL__ */
+
+#endif /* _NETFILTER_HELPERS_H */
diff --git a/include/linux/netfilter/netfilter_mime.h b/include/linux/netfilter/netfilter_mime.h
new file mode 100644
index 0000000..7eeb183
--- /dev/null
+++ b/include/linux/netfilter/netfilter_mime.h
@@ -0,0 +1,89 @@
+/*
+ * MIME functions for netfilter modules. This file provides implementations
+ * for basic MIME parsing. MIME headers are used in many protocols, such as
+ * HTTP, RTSP, SIP, etc.
+ *
+ * gcc will warn for defined but unused functions, so we only include the
+ * functions requested. The following macros are used:
+ * NF_NEED_MIME_NEXTLINE nf_mime_nextline()
+ */
+#ifndef _NETFILTER_MIME_H
+#define _NETFILTER_MIME_H
+
+/* Only include these functions for kernel code. */
+#ifdef __KERNEL__
+
+#include <linux/ctype.h>
+
+/*
+ * Given a buffer and length, advance to the next line and mark the current
+ * line. If the current line is empty, *plinelen will be set to zero. If
+ * not, it will be set to the actual line length (including CRLF).
+ *
+ * 'line' in this context means logical line (includes LWS continuations).
+ * Returns 1 on success, 0 on failure.
+ */
+#ifdef NF_NEED_MIME_NEXTLINE
+static int
+nf_mime_nextline(char* p, uint len, uint* poff, uint* plineoff, uint* plinelen)
+{
+ uint off = *poff;
+ uint physlen = 0;
+ int is_first_line = 1;
+
+ if (off >= len)
+ {
+ return 0;
+ }
+
+ do
+ {
+ while (p[off] != '\n')
+ {
+ if (len-off <= 1)
+ {
+ return 0;
+ }
+
+ physlen++;
+ off++;
+ }
+
+ /* if we saw a crlf, physlen needs adjusted */
+ if (physlen > 0 && p[off] == '\n' && p[off-1] == '\r')
+ {
+ physlen--;
+ }
+
+ /* advance past the newline */
+ off++;
+
+ /* check for an empty line */
+ if (physlen == 0)
+ {
+ break;
+ }
+
+ /* check for colon on the first physical line */
+ if (is_first_line)
+ {
+ is_first_line = 0;
+ if (memchr(p+(*poff), ':', physlen) == NULL)
+ {
+ return 0;
+ }
+ }
+ }
+ while (p[off] == ' ' || p[off] == '\t');
+
+ *plineoff = *poff;
+ *plinelen = (physlen == 0) ? 0 : (off - *poff);
+ *poff = off;
+
+ return 1;
+}
+#endif /* NF_NEED_MIME_NEXTLINE */
+
+#endif /* __KERNEL__ */
+
+#endif /* _NETFILTER_MIME_H */
diff --git a/include/linux/netfilter/nf_conntrack_rtsp.h b/include/linux/netfilter/nf_conntrack_rtsp.h
new file mode 100644
index 0000000..7965755
--- /dev/null
+++ b/include/linux/netfilter/nf_conntrack_rtsp.h
@@ -0,0 +1,72 @@
+/*
+ * RTSP extension for IP connection tracking.
+ * (C) 2003 by Tom Marshall <tmarshall at real.com>
+ * based on ip_conntrack_irc.h
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * 2013-03-04: Il'inykh Sergey <sergeyi at inango-sw.com>. Inango Systems Ltd
+ * - conditional compilation for kernel 3.7
+ * - port mapping improvements
+*/
+#ifndef _IP_CONNTRACK_RTSP_H
+#define _IP_CONNTRACK_RTSP_H
+
+#include <linux/version.h>
+
+//#define IP_NF_RTSP_DEBUG 1
+#define IP_NF_RTSP_VERSION "0.7"
+
+#ifdef __KERNEL__
+/* port block types */
+typedef enum {
+ pb_single, /* client_port=x */
+ pb_range, /* client_port=x-y */
+ pb_discon /* client_port=x/y (rtspbis) */
+} portblock_t;
+
+/* We record seq number and length of rtsp headers here, all in host order. */
+
+/*
+ * This structure is per expected connection. It is a member of struct
+ * ip_conntrack_expect. The TCP SEQ for the conntrack expect is stored
+ * there and we are expected to only store the length of the data which
+ * needs replaced. If a packet contains multiple RTSP messages, we create
+ * one expected connection per message.
+ *
+ * We use these variables to mark the entire header block. This may seem
+ * like overkill, but the nature of RTSP requires it. A header may appear
+ * multiple times in a message. We must treat two Transport headers the
+ * same as one Transport header with two entries.
+ */
+struct ip_ct_rtsp_expect
+{
+ u_int32_t len; /* length of header block */
+ portblock_t pbtype; /* Type of port block that was requested */
+ u_int16_t loport; /* Port that was requested, low or first */
+ u_int16_t hiport; /* Port that was requested, high or second */
+#if 0
+ uint method; /* RTSP method */
+ uint cseq; /* CSeq from request */
+#endif
+};
+
+extern unsigned int (*nf_nat_rtsp_hook)(struct sk_buff *skb,
+ enum ip_conntrack_info ctinfo,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ unsigned int protoff,
+#endif
+ unsigned int matchoff,
+ unsigned int matchlen,
+ struct ip_ct_rtsp_expect *prtspexp,
+ struct nf_conntrack_expect *rtp_exp,
+ struct nf_conntrack_expect *rtcp_exp);
+
+#define RTSP_PORT 554
+
+#endif /* __KERNEL__ */
+
+#endif /* _IP_CONNTRACK_RTSP_H */
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index 7b8e260..3d3b09e 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -13,6 +13,9 @@
u32 group, struct nlmsghdr *nlh, gfp_t flags);
extern void rtnl_set_sk_err(struct net *net, u32 group, int error);
extern int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics);
+#ifdef CONFIG_ARCH_COMCERTO
+extern int rtnetlink_put_metrics_2(struct sk_buff *skb, u32 *metrics, struct dst_entry *dst);
+#endif
extern int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst,
u32 id, long expires, u32 error);
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index ca2e26a..ad687a4 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -568,8 +568,8 @@
fclone:2,
peeked:1,
head_frag:1,
- xmit_more:1;
- /* one bit hole */
+ xmit_more:1,
+ dma_coherent:1;
kmemcheck_bitfield_end(flags1);
/* fields enclosed in headers_start/headers_end are copied
@@ -634,6 +634,7 @@
};
__u32 priority;
int skb_iif;
+ int skb_orig_iif;
__u32 hash;
__be16 vlan_proto;
__u16 vlan_tci;
@@ -777,6 +778,7 @@
int node);
struct sk_buff *__build_skb(void *data, unsigned int frag_size);
struct sk_buff *build_skb(void *data, unsigned int frag_size);
+struct sk_buff *alloc_dma_coherent_skb(unsigned int size);
static inline struct sk_buff *alloc_skb(unsigned int size,
gfp_t priority)
{
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index e8bbf40..ac9833f 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -210,6 +210,9 @@
u32 mdev_max_us; /* maximal mdev for the last rtt period */
u32 rttvar_us; /* smoothed mdev_max */
u32 rtt_seq; /* sequence number to update rttvar */
+ struct rtt_meas {
+ u32 rtt, ts; /* RTT in usec and sampling time in jiffies. */
+ } rtt_min[3];
u32 packets_out; /* Packets which are "in flight" */
u32 retrans_out; /* Retransmitted packets out */
@@ -328,6 +331,10 @@
* socket. Used to retransmit SYNACKs etc.
*/
struct request_sock *fastopen_rsk;
+
+/* TCP congestion control overrides */
+ u8 is_rate_controlled:1; /* Is flow using externally set rate? */
+ u8 is_aggressive_rto:1; /* Using aggressive retry timeout? */
};
enum tsq_flags {
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
index 92e337c..1610524 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -296,7 +296,7 @@
struct tty_driver {
int magic; /* magic number for this structure */
struct kref kref; /* Reference management */
- struct cdev *cdevs;
+ struct cdev **cdevs;
struct module *owner;
const char *driver_name;
const char *name;
diff --git a/include/net/netfilter/nf_conntrack.h b/include/net/netfilter/nf_conntrack.h
index 095433b..00ab649 100644
--- a/include/net/netfilter/nf_conntrack.h
+++ b/include/net/netfilter/nf_conntrack.h
@@ -71,6 +71,14 @@
#include <net/netfilter/ipv4/nf_conntrack_ipv4.h>
#include <net/netfilter/ipv6/nf_conntrack_ipv6.h>
+#if defined(CONFIG_COMCERTO_FP)
+struct comcerto_fp_info {
+ int ifindex;
+ int iif;
+ u32 mark;
+};
+#endif
+
struct nf_conn {
/* Usage count in here is 1 for hash table/destruct timer, 1 per skb,
* plus 1 for any connection(s) we are `master' for
@@ -111,6 +119,10 @@
u_int32_t secmark;
#endif
+#if defined(CONFIG_COMCERTO_FP)
+ struct comcerto_fp_info fp_info[IP_CT_DIR_MAX];
+#endif
+
/* Extensions */
struct nf_ct_ext *ext;
diff --git a/include/net/netfilter/nf_conntrack_core.h b/include/net/netfilter/nf_conntrack_core.h
index f2f0fa3..c934b6d 100644
--- a/include/net/netfilter/nf_conntrack_core.h
+++ b/include/net/netfilter/nf_conntrack_core.h
@@ -86,4 +86,8 @@
extern spinlock_t nf_conntrack_expect_lock;
+#ifdef CONFIG_COMCERTO_FP
+#define COMCERTO_PERMANENT_TIMEOUT 1000
+#endif
+
#endif /* _NF_CONNTRACK_CORE_H */
diff --git a/include/net/sock.h b/include/net/sock.h
index 4c4b21c..667eb99 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -713,6 +713,7 @@
SOCK_TIMESTAMPING_RX_SOFTWARE, /* %SOF_TIMESTAMPING_RX_SOFTWARE */
SOCK_FASYNC, /* fasync() active */
SOCK_RXQ_OVFL,
+ SOCK_RXQ_ALLOC,
SOCK_ZEROCOPY, /* buffers from userspace */
SOCK_WIFI_STATUS, /* push wifi status to userspace */
SOCK_NOFCS, /* Tell NIC not to do the Ethernet FCS.
@@ -2160,6 +2161,14 @@
sk->sk_stamp = skb->tstamp;
}
+void __sock_recv_alloc(struct msghdr *msg, struct sock *sk);
+
+static inline void sock_recv_alloc(struct msghdr *msg, struct sock *sk)
+{
+ if (sock_flag(sk, SOCK_RXQ_ALLOC))
+ __sock_recv_alloc(msg, sk);
+}
+
void __sock_tx_timestamp(const struct sock *sk, __u8 *tx_flags);
/**
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 3d3a365..ed82d4e 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -279,6 +279,7 @@
extern int sysctl_tcp_challenge_ack_limit;
extern unsigned int sysctl_tcp_notsent_lowat;
extern int sysctl_tcp_min_tso_segs;
+extern int sysctl_tcp_min_rtt_wlen;
extern int sysctl_tcp_autocorking;
extern int sysctl_tcp_invalid_ratelimit;
@@ -442,6 +443,7 @@
struct tcp_options_received *opt_rx,
int estab, struct tcp_fastopen_cookie *foc);
const u8 *tcp_parse_md5sig_option(const struct tcphdr *th);
+extern bool tcp_rate_control(struct sock *sk);
/*
* TCP v4 functions exported for the inet6 API
@@ -591,6 +593,12 @@
void tcp_mtup_init(struct sock *sk);
void tcp_init_buffer_space(struct sock *sk);
+/* Minimum RTT in usec. ~0 means not available. */
+static inline u32 tcp_min_rtt(const struct tcp_sock *tp)
+{
+ return min(tp->rtt_min[0].rtt, tp->srtt_us>>3);
+}
+
static inline void tcp_bound_rto(const struct sock *sk)
{
if (inet_csk(sk)->icsk_rto > TCP_RTO_MAX)
@@ -599,7 +607,10 @@
static inline u32 __tcp_set_rto(const struct tcp_sock *tp)
{
- return usecs_to_jiffies((tp->srtt_us >> 3) + tp->rttvar_us);
+ return usecs_to_jiffies(
+ tp->is_aggressive_rto
+ ? ((tcp_min_rtt(tp) + (tp->srtt_us >> 3)) / 2)
+ : ((tp->srtt_us >> 3) + tp->rttvar_us));
}
static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
@@ -828,6 +839,8 @@
void (*in_ack_event)(struct sock *sk, u32 flags);
/* new value of cwnd after loss (optional) */
u32 (*undo_cwnd)(struct sock *sk);
+ /* adjust fixed-rate stream rate control (optional) */
+ bool (*rate_control)(struct sock *sk, unsigned int current_mss);
/* hook for packet ack accounting (optional) */
void (*pkts_acked)(struct sock *sk, u32 num_acked, s32 rtt_us);
/* get info for inet_diag (optional) */
@@ -1549,7 +1562,8 @@
*/
static inline bool tcp_stream_is_thin(struct tcp_sock *tp)
{
- return tp->packets_out < 4 && !tcp_in_initial_slowstart(tp);
+ return (tp->packets_out < 4 && !tcp_in_initial_slowstart(tp))
+ || tp->is_rate_controlled;
}
/* /proc */
diff --git a/include/uapi/asm-generic/socket.h b/include/uapi/asm-generic/socket.h
index 5c15c2a..c996bd4 100644
--- a/include/uapi/asm-generic/socket.h
+++ b/include/uapi/asm-generic/socket.h
@@ -87,4 +87,6 @@
#define SO_ATTACH_BPF 50
#define SO_DETACH_BPF SO_DETACH_FILTER
+#define SO_RXQ_ALLOC 101 /* non-upstreamed sockopt */
+
#endif /* __ASM_GENERIC_SOCKET_H */
diff --git a/include/uapi/linux/if.h b/include/uapi/linux/if.h
index 9cf2394..5e71f42 100644
--- a/include/uapi/linux/if.h
+++ b/include/uapi/linux/if.h
@@ -87,6 +87,7 @@
IFF_LOWER_UP = 1<<16, /* volatile */
IFF_DORMANT = 1<<17, /* volatile */
IFF_ECHO = 1<<18, /* volatile */
+ IFF_WIFI_OFLD = 1<<19,
};
#define IFF_UP IFF_UP
@@ -108,6 +109,7 @@
#define IFF_LOWER_UP IFF_LOWER_UP
#define IFF_DORMANT IFF_DORMANT
#define IFF_ECHO IFF_ECHO
+#define IFF_WIFI_OFLD IFF_WIFI_OFLD
#define IFF_VOLATILE (IFF_LOOPBACK|IFF_POINTOPOINT|IFF_BROADCAST|IFF_ECHO|\
IFF_MASTER|IFF_SLAVE|IFF_RUNNING|IFF_LOWER_UP|IFF_DORMANT)
diff --git a/include/uapi/linux/netfilter/nf_conntrack_common.h b/include/uapi/linux/netfilter/nf_conntrack_common.h
index 319f471..106d15b 100644
--- a/include/uapi/linux/netfilter/nf_conntrack_common.h
+++ b/include/uapi/linux/netfilter/nf_conntrack_common.h
@@ -91,6 +91,10 @@
/* Conntrack got a helper explicitly attached via CT target. */
IPS_HELPER_BIT = 13,
IPS_HELPER = (1 << IPS_HELPER_BIT),
+
+ /* Connection cannot expire */
+ IPS_PERMANENT_BIT = 24,
+ IPS_PERMANENT = (1 << IPS_PERMANENT_BIT),
};
/* Connection tracking event types */
diff --git a/include/uapi/linux/netfilter/nfnetlink_conntrack.h b/include/uapi/linux/netfilter/nfnetlink_conntrack.h
index acad6c5..5d344fc 100644
--- a/include/uapi/linux/netfilter/nfnetlink_conntrack.h
+++ b/include/uapi/linux/netfilter/nfnetlink_conntrack.h
@@ -53,6 +53,8 @@
CTA_MARK_MASK,
CTA_LABELS,
CTA_LABELS_MASK,
+ CTA_COMCERTO_FP_ORIG = 32,
+ CTA_COMCERTO_FP_REPLY,
__CTA_MAX
};
#define CTA_MAX (__CTA_MAX - 1)
@@ -260,4 +262,13 @@
};
#define CTA_STATS_EXP_MAX (__CTA_STATS_EXP_MAX - 1)
+enum ctattr_comcerto_fp {
+ CTA_COMCERTO_FP_UNSPEC,
+ CTA_COMCERTO_FP_MARK,
+ CTA_COMCERTO_FP_IFINDEX,
+ CTA_COMCERTO_FP_IIF,
+ __CTA_COMCERTO_FP_MAX
+};
+#define CTA_COMCERTO_FP_MAX (__CTA_COMCERTO_FP_MAX - 1)
+
#endif /* _IPCONNTRACK_NETLINK_H */
diff --git a/include/uapi/linux/netlink.h b/include/uapi/linux/netlink.h
index 1a85940..9466ef1 100644
--- a/include/uapi/linux/netlink.h
+++ b/include/uapi/linux/netlink.h
@@ -28,9 +28,13 @@
#define NETLINK_RDMA 20
#define NETLINK_CRYPTO 21 /* Crypto layer */
+/* Freescale LS1024A specific. */
+#define NETLINK_FF 30
+#define NETLINK_L2FLOW 33
+
#define NETLINK_INET_DIAG NETLINK_SOCK_DIAG
-#define MAX_LINKS 32
+#define MAX_LINKS 34
struct sockaddr_nl {
__kernel_sa_family_t nl_family; /* AF_NETLINK */
diff --git a/init/Kconfig b/init/Kconfig
index dc24dec..6af0411 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -1275,6 +1275,17 @@
If unsure, say N.
+config ANTIREBOOTLOOP
+ bool "Anti reboot loop"
+ depends on HAVE_MEMBLOCK
+ help
+ The anti reboot loop feature is a communication protocol between the
+ kernel and the bootloader. It is basically a counter at a pre-defined
+ location in DRAM that is incremented by the bootloader and reset to
+ zero by the kernel when some user space process determined that the
+ system came up ok. This mechanism allows the bootloader to switch to
+ a different kernel/rootfs image if the system keeps on rebooting.
+
config BLK_DEV_INITRD
bool "Initial RAM filesystem and RAM disk (initramfs/initrd) support"
depends on BROKEN || !FRV
@@ -1445,6 +1456,27 @@
very difficult to diagnose system problems, saying N here is
strongly discouraged.
+config PRINTK_PERSIST
+ default n
+ bool "printk log persists across reboots" if PRINTK
+ help
+ This option tries to keep the printk memory buffer in a well-known
+ location in physical memory. It isn't cleared on reboot (unless RAM
+ is wiped by your boot loader or BIOS) so if your system crashes
+ or panics, you might get to examine all the log messages next time you
+ boot. The persisted log messages show up in your 'dmesg' output.
+ Note: you must supply the log_buf_len= kernel parameter to
+ activate this feature.
+
+config BOOTLOG_COPY
+ default n
+ bool "copy boot log to printk log" if PRINTK
+ help
+ This option copies the boot log stored in bootlog memory and save it
+ in the printk log.
+ Note: you must supply the bootlog= and log_buf_len= kernel parameters
+ to activate this feature.
+
config BUG
bool "BUG() support" if EXPERT
default y
diff --git a/kernel/Makefile b/kernel/Makefile
index 60c302c..952af40 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -98,6 +98,7 @@
obj-$(CONFIG_JUMP_LABEL) += jump_label.o
obj-$(CONFIG_CONTEXT_TRACKING) += context_tracking.o
obj-$(CONFIG_TORTURE_TEST) += torture.o
+obj-$(CONFIG_ANTIREBOOTLOOP) += antirebootloop.o
$(obj)/configs.o: $(obj)/config_data.h
diff --git a/kernel/antirebootloop.c b/kernel/antirebootloop.c
new file mode 100644
index 0000000..ba82c8a
--- /dev/null
+++ b/kernel/antirebootloop.c
@@ -0,0 +1,96 @@
+#include <linux/antirebootloop.h>
+#include <asm/memory.h>
+#include <linux/uaccess.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+
+static struct arl_marker *antirebootloop_marker = 0;
+static u32 bootloader_version;
+
+static int verify_magic(struct arl_marker *m) {
+ int i;
+ for (i=0; i < ARRAY_SIZE(m->magic); i++) {
+ if (m->magic[i] != ARL_MAGIC + i) return -1;
+ }
+ return 0;
+}
+
+static int arl_proc_show(struct seq_file *m, void *v)
+{
+ seq_printf(m, "counter: %u\n", antirebootloop_marker->counter);
+ seq_printf(m, "bootloader_version: %u\n",
+ bootloader_version);
+ seq_printf(m, "kernel_version: %u\n",
+ antirebootloop_marker->kernel_version);
+ return 0;
+}
+
+#define MAX_ARL_WRITE 8
+static ssize_t arl_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *ppos)
+{
+ char kbuf[MAX_ARL_WRITE + 1];
+ u32 counter;
+
+ if (count > MAX_ARL_WRITE)
+ return -EINVAL;
+ if (copy_from_user(&kbuf, buffer, count))
+ return -EFAULT;
+ kbuf[MAX_ARL_WRITE] = '\0';
+
+ if (sscanf(kbuf, "%d", &counter) != 1)
+ return -EINVAL;
+
+ antirebootloop_marker->counter = counter;
+ pr_info("Set antirebootloop counter to %u\n",
+ antirebootloop_marker->counter);
+ return count;
+}
+
+static int arl_proc_open(struct inode *inode, struct file *file) {
+ if (!antirebootloop_marker)
+ return -ENOENT;
+ return single_open(file, arl_proc_show, NULL);
+}
+
+static const struct file_operations arl_proc_fops = {
+ .open = arl_proc_open,
+ .read = seq_read,
+ .write = arl_write,
+ .llseek = seq_lseek,
+ .release = single_release,
+};
+
+static int __init init_marker(void) {
+ phys_addr_t a;
+ static struct arl_marker *m;
+ a = get_antirebootloop_ptr();
+ if (!a)
+ return 0;
+ m = __va(a);
+ if (!verify_magic(m)) {
+ pr_info("Found antirebootloop marker. "
+ "counter %u bootloader_version %u "
+ "kernel_version %u\n",
+ m->counter, m->bootloader_version, m->kernel_version);
+ /* We need to make a copy of bootloader_version and then reset
+ * it to 0. Otherwise, we might read a stale value if someone
+ * downgrades from an ARL to an old, non-ARL bootloader.
+ * */
+ bootloader_version = m->bootloader_version;
+ m->bootloader_version = 0;
+ m->kernel_version = ARL_KERNEL_VERSION;
+ antirebootloop_marker = m;
+ }
+ return 0;
+}
+
+static int __init create_procfs_entry(void) {
+ pr_info("Creating ARL proc fs entry\n");
+ if (antirebootloop_marker)
+ proc_create("antirebootloop", 0, NULL, &arl_proc_fops);
+ return 0;
+}
+
+early_initcall(init_marker);
+core_initcall(create_procfs_entry);
diff --git a/kernel/hung_task.c b/kernel/hung_task.c
index e0f90c2..fc04209 100644
--- a/kernel/hung_task.c
+++ b/kernel/hung_task.c
@@ -108,6 +108,14 @@
* Ok, the task did not get scheduled for more than 2 minutes,
* complain:
*/
+ if (sysctl_hung_task_panic) {
+ /* If we are going to panic later, then run console_verbose()
+ * now to ensure important debug information is printed to the
+ * console. The information printed by panic() alone is less
+ * useful.
+ * */
+ console_verbose();
+ }
pr_err("INFO: task %s:%d blocked for more than %ld seconds.\n",
t->comm, t->pid, timeout);
pr_err(" %s %s %.*s\n",
diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c
index 3c1aca0..dc54a34 100644
--- a/kernel/printk/printk.c
+++ b/kernel/printk/printk.c
@@ -46,8 +46,10 @@
#include <linux/utsname.h>
#include <linux/ctype.h>
#include <linux/uio.h>
+#include <linux/crc32.h>
#include <asm/uaccess.h>
+#include <asm/cacheflush.h>
#define CREATE_TRACE_POINTS
#include <trace/events/printk.h>
@@ -218,6 +220,9 @@
u16 text_len; /* length of text buffer */
u16 dict_len; /* length of dictionary buffer */
u8 facility; /* syslog facility */
+#ifdef CONFIG_PRINTK_PERSIST
+ u32 crc; /* the flags may change, so don't include them */
+#endif
u8 flags:5; /* internal record flags */
u8 level:3; /* syslog level */
};
@@ -231,6 +236,99 @@
#ifdef CONFIG_PRINTK
DECLARE_WAIT_QUEUE_HEAD(log_wait);
+
+#define PREFIX_MAX 32
+#define LOG_LINE_MAX (1024 - PREFIX_MAX)
+
+/* record buffer */
+#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
+#define LOG_ALIGN 4
+#else
+#define LOG_ALIGN __alignof__(struct printk_log)
+#endif
+#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
+static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);
+static char *log_buf = __log_buf;
+
+static int log_make_free_space(u32 msg_size);
+static int log_store(int facility, int level,
+ enum log_flags flags, u64 ts_nsec,
+ const char *dict, u16 dict_len,
+ const char *text, u16 text_len);
+
+#ifdef CONFIG_BOOTLOG_COPY
+#define BOOTLOG_MAGIC (0x1090091e)
+struct bloghdr {
+ unsigned int magic; /* for kernel verification */
+ unsigned int offset; /* current log offset */
+};
+
+extern unsigned long bootlog_get_addr(void);
+extern unsigned long bootlog_get_size(void);
+
+static __init inline struct bloghdr *get_bootlog_hdr(void)
+{
+ unsigned long bootlog_size = bootlog_get_size();
+ if (bootlog_size) {
+ struct bloghdr *blog_hdr = (struct bloghdr *)
+ phys_to_virt(bootlog_get_addr());
+ if (BOOTLOG_MAGIC != blog_hdr->magic ||
+ (blog_hdr->offset + sizeof(struct bloghdr) >
+ bootlog_size)) {
+ printk(KERN_INFO "bootlog: header invalid m:0x%08x "
+ "o:0x%08x s:0x%08lx\n", blog_hdr->magic,
+ blog_hdr->offset, bootlog_size);
+ return NULL;
+ }
+ return blog_hdr;
+ }
+ printk(KERN_INFO "bootlog: bootlog_size was 0.\n");
+ return NULL;
+}
+
+#define printable(c) (((c)=='\t') || ((c)=='\n') || (0x20<=(c) && (c)<=0x7e))
+
+static inline void __init copy_bootlog(struct bloghdr *blog_hdr)
+{
+ if (blog_hdr) {
+ char *blog_buf = (char *)(blog_hdr + 1);
+ int i,j;
+ char *tmp;
+ /* Strip out nonprintable characters from the bootlog. */
+ for (i=0,j=0; i < blog_hdr->offset; i++) {
+ if (printable(blog_buf[i])) {
+ blog_buf[j++] = blog_buf[i];
+ }
+ }
+ /* Loop over each line in the boot loader log, and insert them into the
+ * kernel log one at a time. Attempting to insert the entire thing fails due
+ * to some logic that truncates long messages.
+ */
+ tmp = &blog_buf[0];
+ for (i=0; i < j; i++) {
+ if (blog_buf[i] == '\n') {
+ /* Insert with facility=0, level=INFO, time=0, No dict. */
+ log_store(0, 6, LOG_NEWLINE, 0,
+ NULL, 0, tmp, &blog_buf[i] - tmp);
+ tmp = &blog_buf[i+1];
+ }
+ }
+
+ /* Insert any trailing line into the kernel buffer. */
+ if (tmp != &blog_buf[i]) {
+ log_store(0, 6, 0, 0,
+ NULL, 0, tmp, &blog_buf[i] - tmp);
+ }
+ }
+}
+
+static inline void __init free_bootlog(void)
+{
+ free_bootmem(bootlog_get_addr(), bootlog_get_size());
+}
+#endif
+
+#ifndef CONFIG_PRINTK_PERSIST
/* the next printk record to read by syslog(READ) or /proc/kmsg */
static u64 syslog_seq;
static u32 syslog_idx;
@@ -254,20 +352,210 @@
static u64 clear_seq;
static u32 clear_idx;
-#define PREFIX_MAX 32
-#define LOG_LINE_MAX (1024 - PREFIX_MAX)
-
-/* record buffer */
-#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
-#define LOG_ALIGN 4
-#else
-#define LOG_ALIGN __alignof__(struct printk_log)
-#endif
-#define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
-static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);
-static char *log_buf = __log_buf;
static u32 log_buf_len = __LOG_BUF_LEN;
+#else /* CONFIG_PRINTK_PERSIST */
+
+struct logbits {
+ /* Cache line 1 (32 bytes) */
+ int magic; /* needed to verify the memory across reboots */
+ u32 _log_buf_len; /* leading _ so they aren't replaced by #define */
+ u64 _log_first_seq;
+ u64 _log_next_seq;
+ u32 _log_first_idx;
+ u32 _log_next_idx;
+
+ /*
+ * All fields up to but not including _console_seq are flushed from the
+ * L1 and L2 caches at certain times to ensure that most of the printk
+ * buffer can be recovered after a watchdog reset. If you make changes
+ * to this struct, make sure to take the cache flushing code into
+ * account. Search for __sync_cache_range_w.
+ */
+
+ /* Cache line 2 (32 bytes) */
+ u64 _console_seq;
+ u64 _syslog_seq;
+ u64 _clear_seq;
+ u32 _console_idx;
+ u32 _syslog_idx;
+
+ /* Cache line 3 (first 16 bytes only) */
+ u32 _clear_idx;
+ enum log_flags _syslog_prev;
+ size_t _syslog_partial;
+ enum log_flags _console_prev;
+};
+
+static struct logbits __logbits = {
+ ._log_buf_len = __LOG_BUF_LEN,
+};
+static struct logbits *logbits = &__logbits;
+
+#define log_buf_len logbits->_log_buf_len
+#define syslog_seq logbits->_syslog_seq
+#define syslog_idx logbits->_syslog_idx
+#define syslog_prev logbits->_syslog_prev
+#define syslog_partial logbits->_syslog_partial
+#define log_first_seq logbits->_log_first_seq
+#define log_first_idx logbits->_log_first_idx
+#define log_next_seq logbits->_log_next_seq
+#define log_next_idx logbits->_log_next_idx
+#define console_seq logbits->_console_seq
+#define console_idx logbits->_console_idx
+#define console_prev logbits->_console_prev
+#define clear_seq logbits->_clear_seq
+#define clear_idx logbits->_clear_idx
+
+#define PERSIST_SEARCH_START 0
+#define PERSIST_SEARCH_END 0xfe000000
+#define PERSIST_SEARCH_JUMP (16*1024*1024)
+#define PERSIST_MAGIC 0xba5eba11
+
+/*
+ * arm uses one memory model, mips uses another
+ */
+static __init phys_addr_t physmem_reserve(phys_addr_t size) {
+#ifdef CONFIG_NO_BOOTMEM
+ phys_addr_t alloc;
+ alloc = memblock_find_in_range_node(size, SMP_CACHE_BYTES,
+ PERSIST_SEARCH_START, PERSIST_SEARCH_END,
+ NUMA_NO_NODE);
+ if (!alloc) return alloc;
+ if (memblock_reserve(alloc, size)) {
+ pr_err("printk_persist: memblock_reserve failed\n");
+ return 0;
+ }
+ return alloc;
+#else
+ unsigned long where;
+ for (where = PERSIST_SEARCH_END - size;
+ where >= PERSIST_SEARCH_START && where <= PERSIST_SEARCH_END - size;
+ where -= PERSIST_SEARCH_JUMP) {
+ if (reserve_bootmem(where, size, BOOTMEM_EXCLUSIVE))
+ continue;
+ else
+ return where;
+ }
+ return 0;
+#endif
+}
+
+/*
+ * size is a power of 2 so that the printk offset mask will work. We'll add
+ * a bit more space to the end of the buffer for our extra data, but that
+ * won't change the offset of the buffers.
+ */
+static __init struct logbits *log_buf_alloc(unsigned long size, char **new_logbuf)
+{
+ char *buf;
+ phys_addr_t alloc;
+ unsigned long full_size = size + sizeof(struct logbits);
+ struct logbits *new_logbits;
+ u64 seq;
+ int idx, lost_entries, recovered_entries;
+ struct printk_log *prlog;
+ u32 curr_crc;
+
+ alloc = physmem_reserve(full_size);
+ if (alloc) {
+ const char *bad_header;
+ buf = phys_to_virt(alloc);
+ *new_logbuf = buf;
+ new_logbits = (void*)buf + size;
+ printk(KERN_INFO "printk_persist: memory reserved @ 0x%p size %lu\n",
+ buf, size);
+ printk(KERN_INFO "printk_persist: header:\n"
+ " magic=0x%08x\n"
+ " log_buf_len=%u\n"
+ " log_first_idx=%u\n"
+ " log_next_idx=%u\n"
+ " log_first_seq=%llu\n"
+ " log_next_seq=%llu\n",
+ new_logbits->magic,
+ new_logbits->_log_buf_len,
+ new_logbits->_log_first_idx,
+ new_logbits->_log_next_idx,
+ new_logbits->_log_first_seq,
+ new_logbits->_log_next_seq);
+ bad_header = NULL;
+ if (new_logbits->magic != PERSIST_MAGIC) {
+ bad_header = "incorrect magic value";
+ } else if (new_logbits->_log_buf_len != size) {
+ bad_header = "log_buf_len does not match";
+ } else if (new_logbits->_log_first_seq > new_logbits->_log_next_seq) {
+ bad_header = "log_first_seq > log_next_seq";
+ } else if (new_logbits->_log_next_seq - new_logbits->_log_first_seq >
+ size / sizeof(struct printk_log)) {
+ bad_header = "too many entries";
+ } else if (new_logbits->_log_first_idx > size) {
+ bad_header = "log_first_idx > size";
+ } else if (new_logbits->_log_next_idx > size) {
+ bad_header = "log_next_idx > size";
+ }
+ if (bad_header) {
+ printk(KERN_INFO "printk_persist: header invalid (%s), cleared.\n", bad_header);
+ /*
+ * full_size includes struct logbits at the end of the
+ * message buffer
+ */
+ memset(buf, 0, full_size);
+ new_logbits->magic = PERSIST_MAGIC;
+ new_logbits->_log_buf_len = size;
+ } else {
+ int corruption = 0;
+ for (seq = new_logbits->_log_first_seq, idx = new_logbits->_log_first_idx;
+ seq < new_logbits->_log_next_seq; ++seq) {
+ prlog = (struct printk_log *) &buf[idx];
+ // Verify validity of this record. If its bad, then move the next
+ // pointer to be where this record is at.
+ curr_crc = crc32(~0, prlog, offsetof(struct printk_log, crc));
+ if (prlog->crc != curr_crc) {
+ lost_entries = (int)(new_logbits->_log_next_seq - seq);
+ recovered_entries = (int)(seq - new_logbits->_log_first_seq);
+ printk(KERN_INFO "printk_persist: corruption found at %p, "
+ "recovered %d entries, lost %d entries\n",
+ prlog, recovered_entries, lost_entries);
+ printk(KERN_INFO "Expected CRC %08x, stored CRC %08x\n",
+ curr_crc, prlog->crc);
+ {
+ char *p = (char*) (((unsigned) prlog) & ~0x1f) - 256;
+ unsigned size = new_logbits->_log_next_idx - idx + ((char*)prlog - p);
+ if (size > 1024) size = 1024;
+ print_hex_dump(KERN_INFO, "corrupt: ", DUMP_PREFIX_ADDRESS, 16, 1, p, size, 1);
+ }
+ new_logbits->_log_next_seq = seq;
+ new_logbits->_log_next_idx = idx;
+ corruption = 1;
+ break;
+ }
+ if (prlog->len == 0) {
+ idx = 0;
+ // Do not increment the sequence counter for the
+ // record that's used to indicate wrapping. We
+ // do still want to verify its CRC above though.
+ --seq;
+ }
+ else
+ idx += prlog->len;
+ }
+ if (!corruption)
+ printk(KERN_INFO "printk_persist: successfully validated %llu entries\n",
+ (new_logbits->_log_next_seq - new_logbits->_log_first_seq));
+ }
+ } else {
+ /* replace the buffer, but don't bother to swap struct logbits */
+ printk(KERN_ERR "printk_persist: failed to reserve bootmem area. disabled.\n");
+ buf = alloc_bootmem(full_size);
+ *new_logbuf = buf;
+ new_logbits = (struct logbits*)(buf + size);
+ memset(buf, 0, full_size);
+ }
+
+ return new_logbits;
+}
+#endif
+
/* Return log buffer address */
char *log_buf_addr_get(void)
{
@@ -433,11 +721,23 @@
* to signify a wrap around.
*/
memset(log_buf + log_next_idx, 0, sizeof(struct printk_log));
+#ifdef CONFIG_PRINTK_PERSIST
+ ((struct printk_log*) (log_buf + log_next_idx))->crc =
+ crc32(~0, log_buf + log_next_idx, offsetof(struct printk_log, crc));
+#endif
+ /* Flush L1 and L2 cache */
+ __sync_cache_range_w(log_buf + log_next_idx, sizeof(struct printk_log));
log_next_idx = 0;
}
+ /* insert message */
+ log_next_idx += size;
+ log_next_seq++;
+ /* Flush L1 and L2 cache */
+ __sync_cache_range_w(logbits, offsetof(struct logbits, _console_seq));
+
/* fill message */
- msg = (struct printk_log *)(log_buf + log_next_idx);
+ msg = (struct printk_log *)(log_buf + log_next_idx - size);
memcpy(log_text(msg), text, text_len);
msg->text_len = text_len;
if (trunc_msg_len) {
@@ -455,10 +755,11 @@
msg->ts_nsec = local_clock();
memset(log_dict(msg) + dict_len, 0, pad_len);
msg->len = size;
-
- /* insert message */
- log_next_idx += msg->len;
- log_next_seq++;
+#ifdef CONFIG_PRINTK_PERSIST
+ msg->crc = crc32(~0, msg, offsetof(struct printk_log, crc));
+#endif
+ /* Flush L1 and L2 cache */
+ __sync_cache_range_w(msg, size);
return msg->text_len;
}
@@ -693,6 +994,10 @@
struct devkmsg_user *user = file->private_data;
loff_t ret = 0;
+ /* glibc's fdopen() calls _llseek(..., SEEK_CUR). Let's make it happy
+ * by returning 0 instead of an error. */
+ if (offset == 0 && whence == SEEK_CUR)
+ return 0;
if (!user)
return -EBADF;
if (offset)
@@ -887,6 +1192,17 @@
unsigned long flags;
char *new_log_buf;
int free;
+#ifdef CONFIG_PRINTK_PERSIST
+ struct logbits *new_logbits;
+ struct logbits *old_logbits;
+ struct printk_log *prlog;
+ u64 seq;
+ int idx;
+ int console_found=0, syslog_found=0;
+#endif
+#ifdef CONFIG_BOOTLOG_COPY
+ struct bloghdr *blog_hdr = NULL;
+#endif
if (log_buf != __log_buf)
return;
@@ -897,6 +1213,7 @@
if (!new_log_buf_len)
return;
+#ifndef CONFIG_PRINTK_PERSIST
if (early) {
new_log_buf =
memblock_virt_alloc(new_log_buf_len, LOG_ALIGN);
@@ -904,6 +1221,9 @@
new_log_buf = memblock_virt_alloc_nopanic(new_log_buf_len,
LOG_ALIGN);
}
+#else
+ new_logbits = log_buf_alloc(new_log_buf_len, &new_log_buf);
+#endif
if (unlikely(!new_log_buf)) {
pr_err("log_buf_len: %ld bytes not available\n",
@@ -911,17 +1231,100 @@
return;
}
+#ifdef CONFIG_BOOTLOG_COPY
+ /* Read out the blog_hdr before logbuf is locked in case print
+ * is needed. */
+ blog_hdr = get_bootlog_hdr();
+#endif
+
raw_spin_lock_irqsave(&logbuf_lock, flags);
log_buf_len = new_log_buf_len;
log_buf = new_log_buf;
new_log_buf_len = 0;
free = __LOG_BUF_LEN - log_next_idx;
+
+#ifndef CONFIG_PRINTK_PERSIST
memcpy(log_buf, __log_buf, __LOG_BUF_LEN);
+#else
+ /* We have to copy over entries one at a time from the old
+ * buffer to the new buffer.
+ */
+ old_logbits = logbits;
+ logbits = new_logbits;
+
+#ifdef CONFIG_BOOTLOG_COPY
+ copy_bootlog(blog_hdr);
+#endif
+
+ for (seq = old_logbits->_log_first_seq, idx = old_logbits->_log_first_idx;
+ seq < old_logbits->_log_next_seq; ++seq) {
+ prlog = (struct printk_log *)&__log_buf[idx];
+ if (prlog->len == 0) {
+ idx = 0;
+ prlog = (struct printk_log *)&__log_buf[0];
+ }
+
+ if (log_make_free_space(prlog->len)) {
+ pr_err("not copying entry due to it being too huge\n");
+ idx += prlog->len;
+ continue;
+ }
+
+ if (log_next_idx + prlog->len + sizeof(struct printk_log) > log_buf_len) {
+ /*
+ * This message + an additional empty header does not fit
+ * at the end of the buffer. Add an empty header with len == 0
+ * to signify a wrap around.
+ */
+ memset(log_buf + log_next_idx, 0, sizeof(struct printk_log));
+#ifdef CONFIG_PRINTK_PERSIST
+ ((struct printk_log*) (log_buf + log_next_idx))->crc =
+ crc32(~0, log_buf + log_next_idx, offsetof(struct printk_log, crc));
+#endif
+ log_next_idx = 0;
+ }
+ memcpy(&log_buf[log_next_idx], &__log_buf[idx], prlog->len);
+ __sync_cache_range_w(&log_buf[log_next_idx], prlog->len);
+
+ if (old_logbits->_syslog_seq == seq) {
+ syslog_seq = log_next_seq;
+ syslog_idx = log_next_idx;
+ syslog_found = 1;
+ }
+
+ if (old_logbits->_console_seq == seq) {
+ console_seq = log_next_seq;
+ console_idx = log_next_idx;
+ console_found = 1;
+ }
+
+ idx += prlog->len;
+ log_next_seq++;
+ log_next_idx += prlog->len;
+ }
+
+ if (!syslog_found) {
+ syslog_seq = log_next_seq;
+ syslog_idx = log_next_idx;
+ }
+
+ if (!console_found) {
+ console_seq = log_next_seq;
+ console_idx = log_next_idx;
+ }
+ clear_seq = log_first_seq;
+ clear_idx = log_first_idx;
+ __sync_cache_range_w(logbits, offsetof(struct logbits, _console_seq));
+#endif
raw_spin_unlock_irqrestore(&logbuf_lock, flags);
- pr_info("log_buf_len: %d bytes\n", log_buf_len);
- pr_info("early log buf free: %d(%d%%)\n",
- free, (free * 100) / __LOG_BUF_LEN);
+#ifdef CONFIG_BOOTLOG_COPY
+ free_bootlog();
+#endif
+
+ if (free < __LOG_BUF_LEN / 2)
+ pr_info("early log buf free: %d(%d%%)\n",
+ free, (free * 100) / __LOG_BUF_LEN);
}
static bool __read_mostly ignore_loglevel;
@@ -2792,6 +3195,8 @@
struct kmsg_dumper *dumper;
unsigned long flags;
+ cont_flush(LOG_NEWLINE);
+
if ((reason > KMSG_DUMP_OOPS) && !always_kmsg_dump)
return;
diff --git a/net/bridge/br.c b/net/bridge/br.c
index c72e01c..12d6db4 100644
--- a/net/bridge/br.c
+++ b/net/bridge/br.c
@@ -266,6 +266,60 @@
br_fdb_fini();
}
+#if defined(CONFIG_ARCH_COMCERTO)
+static ATOMIC_NOTIFIER_HEAD(brevent_notif_chain);
+
+/**
+ * register_brevent_notifier - register a netevent notifier block
+ * @nb: notifier
+ *
+ * Register a notifier to be called when a bridge event occurs.
+ * The notifier passed is linked into the kernel structures and must
+ * not be reused until it has been unregistered. A negative errno code
+ * is returned on a failure.
+ */
+int register_brevent_notifier(struct notifier_block *nb)
+{
+ int err;
+
+ err = atomic_notifier_chain_register(&brevent_notif_chain, nb);
+ return err;
+}
+
+/**
+ * unregister_brevent_notifier - unregister a netevent notifier block
+ * @nb: notifier
+ *
+ * Unregister a notifier previously registered by
+ * register_neigh_notifier(). The notifier is unlinked into the
+ * kernel structures and may then be reused. A negative errno code
+ * is returned on a failure.
+ */
+
+int unregister_brevent_notifier(struct notifier_block *nb)
+{
+ return atomic_notifier_chain_unregister(&brevent_notif_chain, nb);
+}
+
+/**
+ * call_brevent_notifiers - call all netevent notifier blocks
+ * @val: value passed unmodified to notifier function
+ * @v: pointer passed unmodified to notifier function
+ *
+ * Call all neighbour notifier blocks. Parameters and return value
+ * are as for notifier_call_chain().
+ */
+
+int call_brevent_notifiers(unsigned long val, void *v)
+{
+ return atomic_notifier_call_chain(&brevent_notif_chain, val, v);
+}
+
+EXPORT_SYMBOL_GPL(register_brevent_notifier);
+EXPORT_SYMBOL_GPL(unregister_brevent_notifier);
+EXPORT_SYMBOL_GPL(call_brevent_notifiers);
+#endif
+
module_init(br_init)
module_exit(br_deinit)
MODULE_LICENSE("GPL");
diff --git a/net/bridge/br_fdb.c b/net/bridge/br_fdb.c
index 659fb96..f081204 100644
--- a/net/bridge/br_fdb.c
+++ b/net/bridge/br_fdb.c
@@ -37,6 +37,11 @@
static u32 fdb_salt __read_mostly;
+#if defined(CONFIG_ARCH_COMCERTO)
+ int(*br_fdb_can_expire)(unsigned char *mac_addr, struct net_device *dev) = NULL;
+ DEFINE_SPINLOCK(br_fdb_cb_lock);
+#endif
+
int __init br_fdb_init(void)
{
br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
@@ -47,6 +52,9 @@
return -ENOMEM;
get_random_bytes(&fdb_salt, sizeof(fdb_salt));
+#if defined(CONFIG_ARCH_COMCERTO)
+ spin_lock_init(&br_fdb_cb_lock);
+#endif
return 0;
}
@@ -98,17 +106,23 @@
ASSERT_RTNL();
list_for_each_entry(p, &br->port_list, list) {
- if (!br_promisc_port(p)) {
+ /* Program all local unicast addresses of the bridge into
+ * Ethernet interface. Required for NXP QorIQ LS1024A fast
+ * forwarding feature. */
+ if (IS_ENABLED(CONFIG_ARCH_COMCERTO) || !br_promisc_port(p)) {
err = dev_uc_add(p->dev, addr);
- if (err)
+ if (err) {
+ pr_err("bridge: dev_uc_add(%s, %pM) failed with %d\n",
+ netdev_name(p->dev), addr, err);
goto undo;
+ }
}
}
return;
undo:
list_for_each_entry_continue_reverse(p, &br->port_list, list) {
- if (!br_promisc_port(p))
+ if (IS_ENABLED(CONFIG_ARCH_COMCERTO) || !br_promisc_port(p))
dev_uc_del(p->dev, addr);
}
}
@@ -125,7 +139,10 @@
ASSERT_RTNL();
list_for_each_entry(p, &br->port_list, list) {
- if (!br_promisc_port(p))
+ /* Remove all previously added local unicast addresses of the
+ * bridge from Ethernet interface. Required for NXP QorIQ
+ * LS1024A fast forwarding feature. */
+ if (IS_ENABLED(CONFIG_ARCH_COMCERTO) || !br_promisc_port(p))
dev_uc_del(p->dev, addr);
}
}
@@ -282,6 +299,15 @@
unsigned long this_timer;
if (f->is_static)
continue;
+#if defined(CONFIG_ARCH_COMCERTO)
+ spin_lock(&br_fdb_cb_lock);
+ if(br_fdb_can_expire && !(*br_fdb_can_expire)(f->addr.addr, f->dst->dev)){
+ f->updated = jiffies;
+ spin_unlock(&br_fdb_cb_lock);
+ continue;
+ }
+ spin_unlock(&br_fdb_cb_lock);
+#endif
this_timer = f->updated + delay;
if (time_before_eq(this_timer, jiffies))
fdb_delete(br, f);
@@ -558,6 +584,18 @@
source->dev->name);
} else {
/* fastpath: update of existing entry */
+#if defined(CONFIG_ARCH_COMCERTO)
+ if (fdb->dst != source) {
+ struct brevent_fdb_update fdb_update;
+
+ fdb_update.dev = source->dev;
+ fdb_update.mac_addr = fdb->addr.addr;
+ //FIXME
+ //__rtmsg_ifinfo(RTM_NEWLINK, br->dev, 0, GFP_ATOMIC);
+ //FIXME
+ call_brevent_notifiers(BREVENT_FDB_UPDATE, &fdb_update);
+ }
+#endif
if (unlikely(source != fdb->dst)) {
fdb->dst = source;
fdb_modified = true;
@@ -585,6 +623,24 @@
}
}
+#if defined(CONFIG_ARCH_COMCERTO)
+void br_fdb_register_can_expire_cb(int(*cb)(unsigned char *mac_addr, struct net_device *dev))
+{
+ spin_lock_bh(&br_fdb_cb_lock);
+ br_fdb_can_expire = cb;
+ spin_unlock_bh(&br_fdb_cb_lock);
+}
+EXPORT_SYMBOL(br_fdb_register_can_expire_cb);
+
+void br_fdb_deregister_can_expire_cb()
+{
+ spin_lock_bh(&br_fdb_cb_lock);
+ br_fdb_can_expire = NULL;
+ spin_unlock_bh(&br_fdb_cb_lock);
+}
+EXPORT_SYMBOL(br_fdb_deregister_can_expire_cb);
+#endif
+
static int fdb_to_nud(const struct net_bridge_fdb_entry *fdb)
{
if (fdb->is_local)
@@ -950,8 +1006,11 @@
continue;
err = dev_uc_add(p->dev, fdb->addr.addr);
- if (err)
+ if (err) {
+ pr_err("bridge: dev_uc_add(%s, %pM) failed with %d\n",
+ netdev_name(p->dev), fdb->addr.addr, err);
goto rollback;
+ }
}
}
return 0;
diff --git a/net/bridge/br_if.c b/net/bridge/br_if.c
index 1849d96..baaee74 100644
--- a/net/bridge/br_if.c
+++ b/net/bridge/br_if.c
@@ -96,7 +96,12 @@
if (err)
return;
+#ifndef CONFIG_ARCH_COMCERTO
+ /* Even if we set the interface to promiscuous mode, we want all local
+ * MAC addresses programmed into the interface.
+ * Required for NXP QorIQ LS1024A fast forwarding feature. */
br_fdb_unsync_static(p->br, p);
+#endif
p->flags |= BR_PROMISC;
}
@@ -133,6 +138,11 @@
struct net_bridge_port *p;
bool set_all = false;
+#ifdef CONFIG_ARCH_COMCERTO
+ /* Always use promiscuous mode */
+ set_all = true;
+#endif
+
/* If vlan filtering is disabled or bridge interface is placed
* into promiscuous mode, place all ports in promiscuous mode.
*/
@@ -186,7 +196,12 @@
dev_set_allmulti(p->dev, -1);
if (br_promisc_port(p))
dev_set_promiscuity(p->dev, -1);
+#ifndef CONFIG_ARCH_COMCERTO
else
+ /* We always program the unicast MAC addresses even if the interface is
+ * in promiscuous mode.
+ * Required for NXP QorIQ LS1024A fast forwarding feature. */
+#endif
br_fdb_unsync_static(p->br, p);
}
@@ -499,6 +514,13 @@
nbp_update_port_count(br);
+#ifdef CONFIG_ARCH_COMCERTO
+ /* Program all local unicast addresses of the bridge into Ethernet
+ * interface. Required for NXP QorIQ LS1024A fast forwarding feature.
+ * */
+ br_fdb_sync_static(p->br, p);
+#endif
+
netdev_update_features(br->dev);
if (br->dev->needed_headroom < dev->needed_headroom)
diff --git a/net/bridge/br_input.c b/net/bridge/br_input.c
index f921a5d..6c2301f 100644
--- a/net/bridge/br_input.c
+++ b/net/bridge/br_input.c
@@ -151,6 +151,10 @@
BR_INPUT_SKB_CB(skb)->brdev = br->dev;
+#if defined(CONFIG_ARCH_COMCERTO)
+ skb->cb[4] = 0;
+#endif
+
/* The packet skb2 goes to the local host (NULL to skip). */
skb2 = NULL;
@@ -191,6 +195,10 @@
if (skb) {
if (dst) {
dst->used = jiffies;
+#if defined(CONFIG_ARCH_COMCERTO)
+ /* Used by ABM module */
+ skb->cb[4] = 1;
+#endif
br_forward(dst->dst, skb, skb2);
} else
br_flood_forward(br, skb, skb2, unicast);
diff --git a/net/bridge/br_private.h b/net/bridge/br_private.h
index 3362c29..4b3388a 100644
--- a/net/bridge/br_private.h
+++ b/net/bridge/br_private.h
@@ -395,6 +395,10 @@
void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
const unsigned char *addr, u16 vid, bool added_by_user);
+#if defined(CONFIG_ARCH_COMCERTO)
+ extern void br_fdb_register_can_expire_cb(int(*cb)(unsigned char *mac_addr, struct net_device *dev));
+ extern void br_fdb_deregister_can_expire_cb(void);
+#endif
int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
struct net_device *dev, const unsigned char *addr, u16 vid);
int br_fdb_add(struct ndmsg *nlh, struct nlattr *tb[], struct net_device *dev,
diff --git a/net/bridge/br_stp_if.c b/net/bridge/br_stp_if.c
index ce658ab..dcc99a9 100644
--- a/net/bridge/br_stp_if.c
+++ b/net/bridge/br_stp_if.c
@@ -120,6 +120,10 @@
if (br_is_root_bridge(br) && !wasroot)
br_become_root_bridge(br);
+
+#if defined(CONFIG_ARCH_COMCERTO)
+ call_brevent_notifiers(BREVENT_PORT_DOWN, p->dev);
+#endif
}
static void br_stp_start(struct net_bridge *br)
diff --git a/net/core/dev.c b/net/core/dev.c
index 56d820f..05c3937 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -3673,6 +3673,8 @@
another_round:
skb->skb_iif = skb->dev->ifindex;
+ if (!skb->skb_orig_iif)
+ skb->skb_orig_iif = skb->dev->ifindex;
__this_cpu_inc(softnet_data.processed);
@@ -3724,9 +3726,12 @@
ret = deliver_skb(skb, pt_prev, orig_dev);
pt_prev = NULL;
}
- if (vlan_do_receive(&skb))
+ if (vlan_do_receive(&skb)) {
+ /* For VLANs, we want skb_orig_iif to point to the
+ * virtual VLAN device not the physical device. */
+ skb->skb_orig_iif = 0;
goto another_round;
- else if (unlikely(!skb))
+ } else if (unlikely(!skb))
goto out;
}
@@ -4216,6 +4221,7 @@
skb->vlan_tci = 0;
skb->dev = napi->dev;
skb->skb_iif = 0;
+ skb->skb_orig_iif = 0;
skb->encapsulation = 0;
skb_shinfo(skb)->gso_type = 0;
skb->truesize = SKB_TRUESIZE(skb_end_offset(skb));
diff --git a/net/core/pktgen.c b/net/core/pktgen.c
index 043ea186..b28a732 100644
--- a/net/core/pktgen.c
+++ b/net/core/pktgen.c
@@ -262,6 +262,7 @@
u64 delay; /* nano-seconds */
__u64 count; /* Default No packets to send */
+ __u64 duration; /* Duration to send in microseconds */
__u64 sofar; /* How many pkts we've sent so far */
__u64 tx_bytes; /* How many bytes we've transmitted */
__u64 errors; /* Errors when trying to transmit, */
@@ -550,6 +551,9 @@
pkt_dev->queue_map_min,
pkt_dev->queue_map_max);
+ seq_printf(seq, " duration: %llu\n",
+ (unsigned long long)pkt_dev->duration);
+
if (pkt_dev->skb_priority)
seq_printf(seq, " skb_priority: %u\n",
pkt_dev->skb_priority);
@@ -1100,6 +1104,16 @@
(unsigned long long)pkt_dev->count);
return count;
}
+ if (!strcmp(name, "duration")) {
+ len = num_arg(&user_buffer[i], 10, &value);
+ if (len < 0)
+ return len;
+ i += len;
+ pkt_dev->duration = value;
+ sprintf(pg_result, "OK: duration=%llu",
+ (unsigned long long)pkt_dev->duration);
+ return count;
+ }
if (!strcmp(name, "src_mac_count")) {
len = num_arg(&user_buffer[i], 10, &value);
if (len < 0)
@@ -2181,6 +2195,7 @@
pkt_dev->cur_daddr = pkt_dev->daddr_min;
pkt_dev->cur_udp_dst = pkt_dev->udp_dst_min;
pkt_dev->cur_udp_src = pkt_dev->udp_src_min;
+ pkt_dev->cur_queue_map = pkt_dev->queue_map_min;
pkt_dev->nflows = 0;
}
@@ -3318,6 +3333,7 @@
struct net_device *odev = pkt_dev->odev;
struct netdev_queue *txq;
int ret;
+ u64 elapsed;
/* If device is offline, then don't send */
if (unlikely(!netif_running(odev) || !netif_carrier_ok(odev))) {
@@ -3403,8 +3419,10 @@
local_bh_enable();
- /* If pkt_dev->count is zero, then run forever */
- if ((pkt_dev->count != 0) && (pkt_dev->sofar >= pkt_dev->count)) {
+ /* If pkt_dev->count and pkt_dev->duration are zero, then run forever */
+ elapsed = ktime_us_delta(ktime_get(), pkt_dev->started_at);
+ if (((pkt_dev->count != 0) && (pkt_dev->sofar >= pkt_dev->count)) ||
+ ((pkt_dev->duration != 0) && (elapsed >= pkt_dev->duration))) {
pktgen_wait_for_skb(pkt_dev);
/* Done with this */
@@ -3587,6 +3605,7 @@
pkt_dev->nfrags = 0;
pkt_dev->delay = pg_delay_d;
pkt_dev->count = pg_count_d;
+ pkt_dev->duration = 0;
pkt_dev->sofar = 0;
pkt_dev->udp_src_min = 9; /* sink port */
pkt_dev->udp_src_max = 9;
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index e9c4b51..f760a00 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -698,7 +698,51 @@
return -EMSGSIZE;
}
EXPORT_SYMBOL(rtnetlink_put_metrics);
+#ifdef CONFIG_ARCH_COMCERTO
+int rtnetlink_put_metrics_2(struct sk_buff *skb, u32 *metrics, struct dst_entry *dst)
+{
+ struct nlattr *mx;
+ int i, valid = 0;
+ mx = nla_nest_start(skb, RTA_METRICS);
+ if (mx == NULL)
+ return -ENOBUFS;
+
+ for (i = 0; i < RTAX_MAX; i++) {
+ if (metrics[i]) {
+ if (i == RTAX_CC_ALGO - 1) {
+ char tmp[TCP_CA_NAME_MAX], *name;
+
+ name = tcp_ca_get_name_by_key(metrics[i], tmp);
+ if (!name)
+ continue;
+ if (nla_put_string(skb, i + 1, name))
+ goto nla_put_failure;
+ } else {
+ if (nla_put_u32(skb, i + 1, metrics[i]))
+ goto nla_put_failure;
+ }
+ valid++;
+ }
+ else if ((i + 1) == RTAX_MTU){
+ valid++;
+ nla_put_u32(skb, i+1, dst_mtu(dst));
+ }
+ }
+
+ if (!valid) {
+ nla_nest_cancel(skb, mx);
+ return 0;
+ }
+
+ return nla_nest_end(skb, mx);
+
+nla_put_failure:
+ nla_nest_cancel(skb, mx);
+ return -EMSGSIZE;
+}
+EXPORT_SYMBOL(rtnetlink_put_metrics_2);
+#endif
int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
long expires, u32 error)
{
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index c9793c6..c24904b 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -330,6 +330,7 @@
return skb;
}
+EXPORT_SYMBOL(__build_skb);
/* build_skb() is wrapper over __build_skb(), that specifically
* takes care of skb->head and skb->pfmemalloc
@@ -349,6 +350,28 @@
}
EXPORT_SYMBOL(build_skb);
+struct sk_buff *alloc_dma_coherent_skb(unsigned int size)
+{
+ struct sk_buff *skb = NULL;
+ dma_addr_t dma_handle;
+ void *buf;
+
+ size = SKB_DATA_ALIGN(size);
+ size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+ buf = dma_alloc_coherent(NULL, size, &dma_handle, GFP_ATOMIC);
+ if (buf) {
+ skb = __build_skb(buf, size);
+ if (skb) {
+ skb->dma_coherent = 1;
+ } else {
+ dma_free_coherent(NULL, size, buf, dma_handle);
+ }
+ }
+ return skb;
+ /* dma_handle is thrown away */
+}
+EXPORT_SYMBOL(alloc_dma_coherent_skb);
+
struct netdev_alloc_cache {
struct page_frag frag;
/* we maintain a pagecount bias, so that we dont dirty cache line
@@ -615,7 +638,12 @@
{
if (skb->head_frag)
put_page(virt_to_head_page(skb->head));
- else
+ else if (skb->dma_coherent) {
+ unsigned int size;
+ size = skb->end - skb->head;
+ size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+ dma_free_coherent(NULL, size, skb->head, 0);
+ } else
kfree(skb->head);
}
@@ -829,6 +857,7 @@
CHECK_SKB_FIELD(hash);
CHECK_SKB_FIELD(priority);
CHECK_SKB_FIELD(skb_iif);
+ CHECK_SKB_FIELD(skb_orig_iif);
CHECK_SKB_FIELD(vlan_proto);
CHECK_SKB_FIELD(vlan_tci);
CHECK_SKB_FIELD(transport_header);
@@ -863,6 +892,7 @@
*/
static struct sk_buff *__skb_clone(struct sk_buff *n, struct sk_buff *skb)
{
+ BUG_ON(skb->dma_coherent);
#define C(x) n->x = skb->x
n->next = n->prev = NULL;
@@ -880,6 +910,7 @@
C(end);
C(head);
C(head_frag);
+ C(dma_coherent);
C(data);
C(truesize);
atomic_set(&n->users, 1);
@@ -993,6 +1024,9 @@
if (skb_orphan_frags(skb, gfp_mask))
return NULL;
+ if (skb->dma_coherent)
+ return skb_copy(skb, gfp_mask);
+
if (skb->fclone == SKB_FCLONE_ORIG &&
atomic_read(&fclones->fclone_ref) == 1) {
n = &fclones->skb2;
@@ -1219,6 +1253,7 @@
skb->head = data;
skb->head_frag = 0;
+ skb->dma_coherent = 0;
skb->data += off;
#ifdef NET_SKBUFF_DATA_USES_OFFSET
skb->end = size;
@@ -4149,6 +4184,7 @@
skb->tstamp.tv64 = 0;
skb->pkt_type = PACKET_HOST;
skb->skb_iif = 0;
+ skb->skb_orig_iif = 0;
skb->ignore_df = 0;
skb_dst_drop(skb);
skb_sender_cpu_clear(skb);
diff --git a/net/core/sock.c b/net/core/sock.c
index 47fc8bb..df2d262 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -947,6 +947,10 @@
sock_valbool_flag(sk, SOCK_RXQ_OVFL, valbool);
break;
+ case SO_RXQ_ALLOC:
+ sock_valbool_flag(sk, SOCK_RXQ_ALLOC, valbool);
+ break;
+
case SO_WIFI_STATUS:
sock_valbool_flag(sk, SOCK_WIFI_STATUS, valbool);
break;
@@ -1196,6 +1200,10 @@
v.val = sock_flag(sk, SOCK_RXQ_OVFL);
break;
+ case SO_RXQ_ALLOC:
+ v.val = sock_flag(sk, SOCK_RXQ_ALLOC);
+ break;
+
case SO_WIFI_STATUS:
v.val = sock_flag(sk, SOCK_WIFI_STATUS);
break;
diff --git a/net/ipv4/Kconfig b/net/ipv4/Kconfig
index bd29016..173079d 100644
--- a/net/ipv4/Kconfig
+++ b/net/ipv4/Kconfig
@@ -485,6 +485,42 @@
among other techniques.
See http://www.csc.ncsu.edu/faculty/rhee/export/bitcp/cubic-paper.pdf
+config TCP_CONG_ACUBIC
+ tristate "ACUBIC TCP"
+ default m
+ ---help---
+ ACUBIC is just CUBIC TCP, but with a much more agressive RTO
+ (retransmit timeout). This prevents long dropouts when packets get
+ lost in a large burst on a low-quality link. It is somewhat
+ dangerous to use on the open Internet, but may be useful in some
+ cases on LANs, where congestion collapse is very unlikely due to the
+ small number of participants, and "real" round trip times are small.
+ ACUBIC stands for "aggressive CUBIC." It definitely does not stand
+ for "Avery's CUBIC."
+
+config TCP_CONG_TRANSONIC
+ tristate "Transonic TCP"
+ default m
+ ---help---
+ Transonic switches to a hard coded fixed-rate congestion control
+ system. It refuses to back off in the face of congestion, which is
+ a very bad idea on the open Internet, but which may be useful in
+ some cases on LANs. The congestion window scales up and down
+ relative to the desired(!) throughput (rather than the observed
+ throughput) and the round trip time, which keeps latency reasonably
+ low.
+
+config TCP_CONG_TURBULENT
+ tristate "Turbulent TCP"
+ default m
+ ---help---
+ Turbulent is similar to transonic, but always uses an oversized
+ congestion window. This leads to large queues and a large number of
+ retries. The advantage is that it fills the receiver window as fast
+ as it can, allowing for more lost data to be retransmitted per round
+ trip time when the link is extremely bad. You should never use this
+ on the open Internet, because it actively disrupts other traffic.
+
config TCP_CONG_WESTWOOD
tristate "TCP Westwood+"
default m
diff --git a/net/ipv4/Makefile b/net/ipv4/Makefile
index 518c04e..64e3102 100644
--- a/net/ipv4/Makefile
+++ b/net/ipv4/Makefile
@@ -43,6 +43,9 @@
obj-$(CONFIG_NET_TCPPROBE) += tcp_probe.o
obj-$(CONFIG_TCP_CONG_BIC) += tcp_bic.o
obj-$(CONFIG_TCP_CONG_CUBIC) += tcp_cubic.o
+obj-$(CONFIG_TCP_CONG_ACUBIC) += tcp_acubic.o
+obj-$(CONFIG_TCP_CONG_TRANSONIC) += tcp_transonic.o
+obj-$(CONFIG_TCP_CONG_TURBULENT) += tcp_turbulent.o
obj-$(CONFIG_TCP_CONG_DCTCP) += tcp_dctcp.o
obj-$(CONFIG_TCP_CONG_WESTWOOD) += tcp_westwood.o
obj-$(CONFIG_TCP_CONG_HSTCP) += tcp_highspeed.o
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index eb1d983..e5ef8cd 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -2419,7 +2419,11 @@
memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
if (rt->rt_pmtu && expires)
metrics[RTAX_MTU - 1] = rt->rt_pmtu;
+#ifdef CONFIG_ARCH_COMCERTO
+ if (rtnetlink_put_metrics_2(skb, metrics, &rt->dst) < 0)
+#else
if (rtnetlink_put_metrics(skb, metrics) < 0)
+#endif
goto nla_put_failure;
if (fl4->flowi4_mark &&
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index f0e8297..81ecc92 100644
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -570,6 +570,13 @@
.proc_handler = proc_dointvec
},
{
+ .procname = "tcp_min_rtt_wlen",
+ .data = &sysctl_tcp_min_rtt_wlen,
+ .maxlen = sizeof(int),
+ .mode = 0644,
+ .proc_handler = proc_dointvec
+ },
+ {
.procname = "tcp_low_latency",
.data = &sysctl_tcp_low_latency,
.maxlen = sizeof(int),
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 19d385a..e5e6c1e 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -389,6 +389,7 @@
icsk->icsk_rto = TCP_TIMEOUT_INIT;
tp->mdev_us = jiffies_to_usecs(TCP_TIMEOUT_INIT);
+ tp->rtt_min[0].rtt = ~0U;
/* So many TCP implementations out there (incorrectly) count the
* initial SYN frame in their delayed-ACK and congestion control
diff --git a/net/ipv4/tcp_acubic.c b/net/ipv4/tcp_acubic.c
new file mode 100644
index 0000000..637a91e
--- /dev/null
+++ b/net/ipv4/tcp_acubic.c
@@ -0,0 +1,55 @@
+/*
+ * TCP ACubic: a variation on CUBIC but with a more aggressive RTO.
+ * You shouldn't do this on the open Internet; it could cause congestion
+ * collapse problems. It might be okay in a more controlled environment.
+ */
+
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/math64.h>
+#include <net/tcp.h>
+
+static void (*old_cubic_init)(struct sock *sk);
+
+static void acubic_init(struct sock *sk)
+{
+ struct tcp_sock *tp = tcp_sk(sk);
+ old_cubic_init(sk);
+ tp->is_aggressive_rto = 1;
+}
+
+static struct tcp_congestion_ops acubictcp __read_mostly;
+
+static int __init acubic_register(void)
+{
+ struct tcp_congestion_ops *ca;
+ u32 key = tcp_ca_get_key_by_name("cubic");
+ if (key == TCP_CA_UNSPEC)
+ return -EEXIST;
+ ca = tcp_ca_find_key(key);
+ if (!ca)
+ return -EINVAL;
+
+ // Wrap CUBIC's implementation, but replace the name and init
+ // function. This way we can measure performance differences by
+ // tracking just the name of the congestion algorithm.
+ memcpy(&acubictcp, ca, sizeof(struct tcp_congestion_ops));
+ strncpy(acubictcp.name, "acubic", sizeof(acubictcp.name));
+ old_cubic_init = ca->init;
+ acubictcp.owner = THIS_MODULE;
+ acubictcp.init = acubic_init;
+ return tcp_register_congestion_control(&acubictcp);
+}
+
+static void __exit acubic_unregister(void)
+{
+ tcp_unregister_congestion_control(&acubictcp);
+}
+
+module_init(acubic_register);
+module_exit(acubic_unregister);
+
+MODULE_AUTHOR("Avery Pennarun");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("ACubic TCP");
+MODULE_VERSION("1.0");
diff --git a/net/ipv4/tcp_cong.c b/net/ipv4/tcp_cong.c
index 84be008..56de1dd 100644
--- a/net/ipv4/tcp_cong.c
+++ b/net/ipv4/tcp_cong.c
@@ -59,6 +59,7 @@
return NULL;
}
+EXPORT_SYMBOL_GPL(tcp_ca_find_key);
/*
* Attach new congestion control algorithm to the list
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 36b93ad..828cc4b 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -95,6 +95,7 @@
int sysctl_tcp_rfc1337 __read_mostly;
int sysctl_tcp_max_orphans __read_mostly = NR_FILE;
int sysctl_tcp_frto __read_mostly = 2;
+int sysctl_tcp_min_rtt_wlen __read_mostly = 300;
int sysctl_tcp_thin_dupack __read_mostly;
@@ -275,6 +276,11 @@
return false;
}
+static inline bool tcp_is_rate_controlled(const struct sock *sk)
+{
+ return tcp_sk(sk)->is_rate_controlled;
+}
+
/* Buffer size and advertised window tuning.
*
* 1. Tuning sk->sk_sndbuf, when connection enters established state.
@@ -758,6 +764,9 @@
/* set sk_pacing_rate to 200 % of current rate (mss * cwnd / srtt) */
rate = (u64)tp->mss_cache * 2 * (USEC_PER_SEC << 3);
+ if (tcp_is_rate_controlled(sk))
+ return;
+
rate *= max(tp->snd_cwnd, tp->packets_out);
if (likely(tp->srtt_us))
@@ -1915,6 +1924,18 @@
tp->undo_retrans = tp->retrans_out ? : -1;
}
+/* Disable built-in CC by fixing cwnd based on qdisc or user specified rate,
+ * and min RTT. The minimum of qdisc and user rate is used to adjust cwnd.
+ * Returns true if built-in CC is overridden, and false otherwise.
+ */
+bool tcp_rate_control(struct sock *sk)
+{
+ const struct inet_connection_sock *icsk = inet_csk(sk);
+ if (!tcp_is_rate_controlled(sk) || !icsk->icsk_ca_ops->rate_control)
+ return false;
+ return icsk->icsk_ca_ops->rate_control(sk, tcp_current_mss(sk));
+}
+
/* Enter Loss state. If we detect SACK reneging, forget all SACK information
* and reset tags completely, otherwise preserve SACKs. If receiver
* dropped its ofo queue, we will know this due to reneging detection.
@@ -1937,9 +1958,11 @@
tcp_ca_event(sk, CA_EVENT_LOSS);
tcp_init_undo(tp);
}
- tp->snd_cwnd = 1;
- tp->snd_cwnd_cnt = 0;
- tp->snd_cwnd_stamp = tcp_time_stamp;
+ if (!tcp_is_rate_controlled(sk)) {
+ tp->snd_cwnd = 1;
+ tp->snd_cwnd_cnt = 0;
+ tp->snd_cwnd_stamp = tcp_time_stamp;
+ }
tp->retrans_out = 0;
tp->lost_out = 0;
@@ -2390,6 +2413,10 @@
tcp_clear_all_retrans_hints(tp);
}
+ tp->undo_marker = 0;
+ if (tcp_is_rate_controlled(sk))
+ return;
+
if (tp->prior_ssthresh) {
const struct inet_connection_sock *icsk = inet_csk(sk);
@@ -2406,7 +2433,6 @@
tp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh);
}
tp->snd_cwnd_stamp = tcp_time_stamp;
- tp->undo_marker = 0;
}
static inline bool tcp_may_undo(const struct tcp_sock *tp)
@@ -2438,7 +2464,8 @@
/* Hold old state until something *above* high_seq
* is ACKed. For Reno it is MUST to prevent false
* fast retransmits (RFC2582). SACK TCP is safe. */
- tcp_moderate_cwnd(tp);
+ if (!tcp_is_rate_controlled(sk))
+ tcp_moderate_cwnd(tp);
if (!tcp_any_retrans_done(sk))
tp->retrans_stamp = 0;
return true;
@@ -2515,6 +2542,9 @@
int newly_acked_sacked = prior_unsacked -
(tp->packets_out - tp->sacked_out);
+ if (tcp_is_rate_controlled(sk))
+ return;
+
tp->prr_delivered += newly_acked_sacked;
if (tcp_packets_in_flight(tp) > tp->snd_ssthresh) {
u64 dividend = (u64)tp->snd_ssthresh * tp->prr_delivered +
@@ -2534,6 +2564,9 @@
{
struct tcp_sock *tp = tcp_sk(sk);
+ if (tcp_is_rate_controlled(sk))
+ return;
+
/* Reset cwnd to ssthresh in CWR or Recovery (unless it's undone) */
if (inet_csk(sk)->icsk_ca_state == TCP_CA_CWR ||
(tp->undo_marker && tp->snd_ssthresh < TCP_INFINITE_SSTHRESH)) {
@@ -2899,8 +2932,71 @@
tcp_xmit_retransmit_queue(sk);
}
+/* Kathleen Nichols' algorithm for tracking the minimum value of
+ * a data stream over some fixed time interval. (E.g., the minimum
+ * RTT over the past five minutes.) It uses constant space and constant
+ * time per update yet almost always delivers the same minimum as an
+ * implementation that has to keep all the data in the window.
+ *
+ * The algorithm keeps track of the best, 2nd best & 3rd best min
+ * values, maintaining an invariant that the measurement time of the
+ * n'th best >= n-1'th best. It also makes sure that the three values
+ * are widely separated in the time window since that bounds the worse
+ * case error when that data is monotonically increasing over the window.
+ *
+ * Upon getting a new min, we can forget everything earlier because it
+ * has no value - the new min is <= everything else in the window by
+ * definition and it's the most recent. So we restart fresh on every new min
+ * and overwrites 2nd & 3rd choices. The same property holds for 2nd & 3rd
+ * best.
+ */
+static void tcp_update_rtt_min(struct sock *sk, u32 rtt_us)
+{
+ const u32 now = tcp_time_stamp, wlen = sysctl_tcp_min_rtt_wlen * HZ;
+ struct rtt_meas *m = tcp_sk(sk)->rtt_min;
+ struct rtt_meas rttm = { .rtt = (rtt_us ? : 1), .ts = now };
+ u32 elapsed;
+
+ if (!rtt_us) return;
+
+ /* Check if the new measurement updates the 1st, 2nd, or 3rd choices */
+ if (unlikely(rttm.rtt <= m[0].rtt))
+ m[0] = m[1] = m[2] = rttm;
+ else if (rttm.rtt <= m[1].rtt)
+ m[1] = m[2] = rttm;
+ else if (rttm.rtt <= m[2].rtt)
+ m[2] = rttm;
+
+ elapsed = now - m[0].ts;
+ if (unlikely(elapsed > wlen)) {
+ /* Passed entire window without a new min so make 2nd choice
+ * the new min & 3rd choice the new 2nd. So forth and so on.
+ */
+ m[0] = m[1];
+ m[1] = m[2];
+ m[2] = rttm;
+ if (now - m[0].ts > wlen) {
+ m[0] = m[1];
+ m[1] = rttm;
+ if (now - m[0].ts > wlen)
+ m[0] = rttm;
+ }
+ } else if (m[1].ts == m[0].ts && elapsed > wlen / 4) {
+ /* Passed a quarter of the window without a new min so
+ * take 2nd choice from the 2nd quarter of the window.
+ */
+ m[2] = m[1] = rttm;
+ } else if (m[2].ts == m[1].ts && elapsed > wlen / 2) {
+ /* Passed half the window without a new min so take the 3rd
+ * choice from the last half of the window.
+ */
+ m[2] = rttm;
+ }
+}
+
static inline bool tcp_ack_update_rtt(struct sock *sk, const int flag,
- long seq_rtt_us, long sack_rtt_us)
+ long seq_rtt_us, long sack_rtt_us,
+ long ca_rtt_us)
{
const struct tcp_sock *tp = tcp_sk(sk);
@@ -2923,11 +3019,16 @@
*/
if (seq_rtt_us < 0 && tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
flag & FLAG_ACKED)
- seq_rtt_us = jiffies_to_usecs(tcp_time_stamp - tp->rx_opt.rcv_tsecr);
-
+ seq_rtt_us = ca_rtt_us = jiffies_to_usecs(tcp_time_stamp -
+ tp->rx_opt.rcv_tsecr);
if (seq_rtt_us < 0)
return false;
+ /* ca_rtt_us >= 0 is counting on the invariant that ca_rtt_us is
+ * always taken together with ACK, SACK, or TS-opts. Any negative
+ * values will be skipped with the seq_rtt_us < 0 check above.
+ */
+ tcp_update_rtt_min(sk, ca_rtt_us);
tcp_rtt_estimator(sk, seq_rtt_us);
tcp_set_rto(sk);
@@ -2949,13 +3050,16 @@
* sent in SYN_RECV, SYNACK RTT is the smooth RTT computed in tcp_ack()
*/
if (!tp->srtt_us)
- tcp_ack_update_rtt(sk, FLAG_SYN_ACKED, seq_rtt_us, -1L);
+ tcp_ack_update_rtt(sk, FLAG_SYN_ACKED, seq_rtt_us, -1L, seq_rtt_us);
}
static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
{
const struct inet_connection_sock *icsk = inet_csk(sk);
+ if (tcp_is_rate_controlled(sk))
+ return;
+
icsk->icsk_ca_ops->cong_avoid(sk, ack, acked);
tcp_sk(sk)->snd_cwnd_stamp = tcp_time_stamp;
}
@@ -3156,7 +3260,8 @@
ca_seq_rtt_us = skb_mstamp_us_delta(&now, &last_ackt);
}
- rtt_update = tcp_ack_update_rtt(sk, flag, seq_rtt_us, sack_rtt_us);
+ rtt_update = tcp_ack_update_rtt(sk, flag, seq_rtt_us, sack_rtt_us,
+ ca_seq_rtt_us);
if (flag & FLAG_ACKED) {
const struct tcp_congestion_ops *ca_ops
@@ -3450,6 +3555,8 @@
/* ACK advances: there was a loss, so reduce cwnd. Reset
* tlp_high_seq in tcp_init_cwnd_reduction()
*/
+ if (tcp_is_rate_controlled(sk))
+ return;
tcp_init_cwnd_reduction(sk);
tcp_set_ca_state(sk, TCP_CA_CWR);
tcp_end_cwnd_reduction(sk);
@@ -3516,6 +3623,8 @@
icsk->icsk_retransmits = 0;
}
+ tcp_rate_control(sk);
+
prior_fackets = tp->fackets_out;
/* ts_recent update must be made after we are sure that the packet
diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
index fec2907..e84b057 100644
--- a/net/ipv4/tcp_minisocks.c
+++ b/net/ipv4/tcp_minisocks.c
@@ -461,6 +461,7 @@
newtp->srtt_us = 0;
newtp->mdev_us = jiffies_to_usecs(TCP_TIMEOUT_INIT);
+ newtp->rtt_min[0].rtt = ~0U;
newicsk->icsk_rto = TCP_TIMEOUT_INIT;
newtp->packets_out = 0;
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index ae66c84..176b621 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -2103,7 +2103,7 @@
break;
/* TCP Small Queues :
- * Control number of packets in qdisc/devices to two packets / or ~1 ms.
+ * Control number of packets in qdisc/devices to two packets / or ~16 ms.
* This allows for :
* - better RTT estimation and ACK scheduling
* - faster recovery
@@ -2112,7 +2112,7 @@
* of queued bytes to ensure line rate.
* One example is wifi aggregation (802.11 AMPDU)
*/
- limit = max(2 * skb->truesize, sk->sk_pacing_rate >> 10);
+ limit = max(2 * skb->truesize, sk->sk_pacing_rate >> 6);
limit = min_t(u32, limit, sysctl_tcp_limit_output_bytes);
if (atomic_read(&sk->sk_wmem_alloc) > limit) {
diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c
index c8f9785..08d34d5 100644
--- a/net/ipv4/tcp_timer.c
+++ b/net/ipv4/tcp_timer.c
@@ -469,8 +469,10 @@
* implemented ftp to mars will work nicely. We will have to fix
* the 120 second clamps though!
*/
- icsk->icsk_backoff++;
- icsk->icsk_retransmits++;
+ if (!tcp_stream_is_thin(tp)) {
+ icsk->icsk_backoff++;
+ icsk->icsk_retransmits++;
+ }
out_reset_timer:
/* If stream is thin, use linear timeouts. Since 'icsk_backoff' is
@@ -483,8 +485,9 @@
* linear-timeout retransmissions into a black hole
*/
if (sk->sk_state == TCP_ESTABLISHED &&
+ (tp->is_aggressive_rto || (
(tp->thin_lto || sysctl_tcp_thin_linear_timeouts) &&
- tcp_stream_is_thin(tp) &&
+ tcp_stream_is_thin(tp))) &&
icsk->icsk_retransmits <= TCP_THIN_LINEAR_RETRIES) {
icsk->icsk_backoff = 0;
icsk->icsk_rto = min(__tcp_set_rto(tp), TCP_RTO_MAX);
diff --git a/net/ipv4/tcp_transonic.c b/net/ipv4/tcp_transonic.c
new file mode 100644
index 0000000..bbceced
--- /dev/null
+++ b/net/ipv4/tcp_transonic.c
@@ -0,0 +1,75 @@
+/*
+ * TCP Transonic: a congestion controller that simply activates the TCP
+ * layer's built in fixed-rate congestion control tweaks.
+ *
+ * Only use this with fixed-rate streams that won't try to saturate the
+ * network, and only use it on a LAN. It would be very rude to use this
+ * on the open Internet (and it also probably wouldn't work).
+ */
+
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/math64.h>
+#include <net/tcp.h>
+
+static void transonic_init(struct sock *sk)
+{
+ struct tcp_sock *tp = tcp_sk(sk);
+ tp->is_rate_controlled = 1;
+ tp->is_aggressive_rto = 1;
+}
+
+static void transonic_cong_avoid(struct sock *sk, u32 ack, u32 acked)
+{
+}
+
+static u32 transonic_recalc_ssthresh(struct sock *sk)
+{
+ return 0;
+}
+
+static bool transonic_rate_control(struct sock *sk, unsigned int current_mss)
+{
+ static DEFINE_RATELIMIT_STATE(transonic_rate, 2 * HZ, 1);
+ struct tcp_sock *tp = tcp_sk(sk);
+ u64 rate = 50*1000*1000/8; // max allowed streaming rate in bytes/sec
+ u32 agg_time_us = 25*1000, min_rtt;
+
+ if (!tp->is_rate_controlled)
+ return false;
+
+ /* Goal: cwnd of at least 2 aggregates. */
+ min_rtt = max_t(u32, 2 * agg_time_us, tcp_min_rtt(tp));
+ tp->snd_cwnd = DIV_ROUND_UP_ULL(2 * rate * min_rtt,
+ USEC_PER_SEC * current_mss);
+ /* avoid cwnd=1, just in case. */
+ tp->snd_cwnd = max(tp->snd_cwnd, 2U);
+ return true;
+}
+
+static struct tcp_congestion_ops transonic __read_mostly = {
+ .init = transonic_init,
+ .cong_avoid = transonic_cong_avoid,
+ .ssthresh = transonic_recalc_ssthresh,
+ .rate_control = transonic_rate_control,
+ .owner = THIS_MODULE,
+ .name = "transonic",
+};
+
+static int __init transonic_register(void)
+{
+ return tcp_register_congestion_control(&transonic);
+}
+
+static void __exit transonic_unregister(void)
+{
+ tcp_unregister_congestion_control(&transonic);
+}
+
+module_init(transonic_register);
+module_exit(transonic_unregister);
+
+MODULE_AUTHOR("Avery Pennarun");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Transonic TCP");
+MODULE_VERSION("0.5");
diff --git a/net/ipv4/tcp_turbulent.c b/net/ipv4/tcp_turbulent.c
new file mode 100644
index 0000000..e4dab99
--- /dev/null
+++ b/net/ipv4/tcp_turbulent.c
@@ -0,0 +1,78 @@
+/*
+ * TCP Turbulent: just always use a large, fixed cwnd. This overfills
+ * buffers, causes packet loss, and is generally a disaster. But under
+ * certain very specific circumstances, this can sacrifice latency for
+ * a tiny bit of improved throughput.
+ */
+
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/math64.h>
+#include <net/tcp.h>
+
+/*
+ * To handle 30 Mbps at 1000ms of latency with 1448 byte mss,
+ * bandwidth-delay product = 30e6 / 8 * 1 / 1448 = 2589 packets.
+ * Round to the next higher power of 2. (This calculation assumes very low
+ * packet loss, or you need more than one rtt to guarantee delivery.)
+ */
+#define MIN_SSTHRESH 2
+#define MIN_CWND 4096
+
+static void reset_values(struct sock *sk)
+{
+ struct tcp_sock *tp = tcp_sk(sk);
+
+ tp->is_rate_controlled = 1;
+ tp->is_aggressive_rto = 1;
+ tp->snd_ssthresh = MIN_SSTHRESH;
+ tp->snd_cwnd = tp->snd_cwnd_clamp = max_t(u64, MIN_CWND, tp->snd_cwnd);
+}
+
+static void turbulent_init(struct sock *sk)
+{
+ reset_values(sk);
+}
+
+static void turbulent_cong_avoid(struct sock *sk, u32 ack, u32 acked)
+{
+ reset_values(sk);
+}
+
+static u32 turbulent_recalc_ssthresh(struct sock *sk)
+{
+ return MIN_SSTHRESH;
+}
+
+static bool turbulent_rate_control(struct sock *sk, unsigned int current_mss)
+{
+ reset_values(sk);
+ return true;
+}
+
+static struct tcp_congestion_ops turbulenttcp __read_mostly = {
+ .init = turbulent_init,
+ .cong_avoid = turbulent_cong_avoid,
+ .ssthresh = turbulent_recalc_ssthresh,
+ .rate_control = turbulent_rate_control,
+ .owner = THIS_MODULE,
+ .name = "turbulent",
+};
+
+static int __init turbulent_register(void)
+{
+ return tcp_register_congestion_control(&turbulenttcp);
+}
+
+static void __exit turbulent_unregister(void)
+{
+ tcp_unregister_congestion_control(&turbulenttcp);
+}
+
+module_init(turbulent_register);
+module_exit(turbulent_unregister);
+
+MODULE_AUTHOR("Avery Pennarun");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Turbulent TCP");
+MODULE_VERSION("1.0");
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 031752e..7721106 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -1319,6 +1319,7 @@
UDP_MIB_INDATAGRAMS, is_udplite);
sock_recv_ts_and_drops(msg, sk, skb);
+ sock_recv_alloc(msg, sk);
/* Copy the address. */
if (sin) {
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index fe70bd6..cabab6e 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -2868,7 +2868,11 @@
goto nla_put_failure;
}
+#ifdef CONFIG_ARCH_COMCERTO
+ if (rtnetlink_put_metrics_2(skb, dst_metrics_ptr(&rt->dst), &rt->dst) < 0)
+#else
if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
+#endif
goto nla_put_failure;
if (rt->rt6i_flags & RTF_GATEWAY) {
diff --git a/net/netfilter/Kconfig b/net/netfilter/Kconfig
index a0f3e6a3..e494659 100644
--- a/net/netfilter/Kconfig
+++ b/net/netfilter/Kconfig
@@ -287,6 +287,15 @@
To compile it as a module, choose M here. If unsure, say N.
+config NF_CONNTRACK_RTSP
+ tristate "RTSP protocol support"
+ depends on NETFILTER_ADVANCED
+ help
+ Support the RTSP protocol. This allows UDP transports to be setup
+ properly, including RTP and RDT.
+
+ To compile it as a module, choose M here. If unsure, say N.
+
config NF_CONNTRACK_SANE
tristate "SANE protocol support"
depends on NETFILTER_ADVANCED
@@ -401,6 +410,11 @@
depends on NF_CONNTRACK && NF_NAT
default NF_NAT && NF_CONNTRACK_IRC
+config NF_NAT_RTSP
+ tristate
+ depends on NF_CONNTRACK && NF_NAT
+ default NF_NAT && NF_CONNTRACK_RTSP
+
config NF_NAT_SIP
tristate
depends on NF_CONNTRACK && NF_NAT
diff --git a/net/netfilter/Makefile b/net/netfilter/Makefile
index a87d8b8..d2c7b18 100644
--- a/net/netfilter/Makefile
+++ b/net/netfilter/Makefile
@@ -8,6 +8,8 @@
obj-$(CONFIG_NETFILTER) = netfilter.o
+obj-$(CONFIG_COMCERTO_FP) += comcerto_fp_netfilter.o
+
obj-$(CONFIG_NETFILTER_NETLINK) += nfnetlink.o
obj-$(CONFIG_NETFILTER_NETLINK_ACCT) += nfnetlink_acct.o
nfnetlink_queue-y := nfnetlink_queue_core.o
@@ -40,6 +42,7 @@
obj-$(CONFIG_NF_CONNTRACK_NETBIOS_NS) += nf_conntrack_netbios_ns.o
obj-$(CONFIG_NF_CONNTRACK_SNMP) += nf_conntrack_snmp.o
obj-$(CONFIG_NF_CONNTRACK_PPTP) += nf_conntrack_pptp.o
+obj-$(CONFIG_NF_CONNTRACK_RTSP) += nf_conntrack_rtsp.o
obj-$(CONFIG_NF_CONNTRACK_SANE) += nf_conntrack_sane.o
obj-$(CONFIG_NF_CONNTRACK_SIP) += nf_conntrack_sip.o
obj-$(CONFIG_NF_CONNTRACK_TFTP) += nf_conntrack_tftp.o
@@ -62,6 +65,7 @@
obj-$(CONFIG_NF_NAT_AMANDA) += nf_nat_amanda.o
obj-$(CONFIG_NF_NAT_FTP) += nf_nat_ftp.o
obj-$(CONFIG_NF_NAT_IRC) += nf_nat_irc.o
+obj-$(CONFIG_NF_NAT_RTSP) += nf_nat_rtsp.o
obj-$(CONFIG_NF_NAT_SIP) += nf_nat_sip.o
obj-$(CONFIG_NF_NAT_TFTP) += nf_nat_tftp.o
diff --git a/net/netfilter/comcerto_fp_netfilter.c b/net/netfilter/comcerto_fp_netfilter.c
new file mode 100644
index 0000000..b885a47
--- /dev/null
+++ b/net/netfilter/comcerto_fp_netfilter.c
@@ -0,0 +1,133 @@
+/*
+ * linux/drivers/net/comcerto/fp_netfilter.c
+ *
+ * Copyright (C) 2010 Mindspeed Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/kernel.h>
+#include <linux/skbuff.h>
+#include <linux/netfilter.h>
+#include <net/netfilter/nf_conntrack.h>
+
+static unsigned int fp_netfilter_pre_routing(int family, struct sk_buff *skb)
+{
+ struct nf_conn *ct;
+ u_int8_t protonum;
+ enum ip_conntrack_info ctinfo;
+ struct comcerto_fp_info *fp_info;
+ int dir;
+
+ ct = nf_ct_get(skb, &ctinfo);
+ if (!ct)
+ goto done;
+
+ protonum = nf_ct_protonum(ct);
+ if ((protonum != IPPROTO_TCP) && (protonum != IPPROTO_UDP) && (protonum != IPPROTO_IPIP))
+ goto done;
+
+ dir = CTINFO2DIR(ctinfo);
+
+// if (printk_ratelimit())
+// printk(KERN_INFO "ct: %lx, dir: %x, mark: %x, ifindex: %d iif: %d\n", (unsigned long)ct, dir, skb->mark, skb->dev->ifindex, skb->skb_orig_iif);
+
+ /* We could also check for changes and notify userspace (or print message) */
+ if (dir == IP_CT_DIR_ORIGINAL) {
+ fp_info = &ct->fp_info[IP_CT_DIR_ORIGINAL];
+ } else {
+ fp_info = &ct->fp_info[IP_CT_DIR_REPLY];
+ }
+
+ if (fp_info->mark && (fp_info->mark != skb->mark))
+ if (printk_ratelimit())
+ printk(KERN_INFO "ct: mark changed %x, %x\n", fp_info->mark, skb->mark);
+
+ if (fp_info->ifindex && (fp_info->ifindex != skb->dev->ifindex))
+ if (printk_ratelimit())
+ printk(KERN_INFO "ct: ifindex changed %d, %d\n", fp_info->ifindex, skb->dev->ifindex);
+
+ if (fp_info->iif && (fp_info->iif != skb->skb_orig_iif))
+ if (printk_ratelimit())
+ printk(KERN_INFO "ct: iif changed %d, %d\n", fp_info->iif, skb->skb_orig_iif);
+
+ fp_info->mark = skb->mark;
+ fp_info->ifindex = skb->dev->ifindex;
+ fp_info->iif = skb->skb_orig_iif;
+
+done:
+ return NF_ACCEPT;
+}
+
+static unsigned int fp_ipv4_netfilter_pre_routing(const struct nf_hook_ops *ops,
+ struct sk_buff *skb,
+ const struct nf_hook_state *state)
+{
+
+ return fp_netfilter_pre_routing(PF_INET, skb);
+}
+
+static unsigned int fp_ipv6_netfilter_pre_routing(const struct nf_hook_ops *ops,
+ struct sk_buff *skb,
+ const struct nf_hook_state *state)
+{
+
+ return fp_netfilter_pre_routing(PF_INET6, skb);
+}
+
+
+static struct nf_hook_ops fp_netfilter_ops[] __read_mostly = {
+ {
+ .hook = fp_ipv4_netfilter_pre_routing,
+ .owner = THIS_MODULE,
+ .pf = NFPROTO_IPV4,
+ .hooknum = NF_INET_PRE_ROUTING,
+ .priority = NF_IP_PRI_LAST,
+ },
+ {
+ .hook = fp_ipv6_netfilter_pre_routing,
+ .owner = THIS_MODULE,
+ .pf = NFPROTO_IPV6,
+ .hooknum = NF_INET_PRE_ROUTING,
+ .priority = NF_IP_PRI_LAST,
+ },
+};
+
+static int __init fp_netfilter_init(void)
+{
+ int rc;
+
+ rc = nf_register_hooks(fp_netfilter_ops, ARRAY_SIZE(fp_netfilter_ops));
+ if (rc < 0) {
+ printk(KERN_ERR "fp_netfilter_ops: can't register hooks.\n");
+ goto err0;
+ }
+
+ return 0;
+
+err0:
+ return rc;
+}
+
+
+static void __exit fp_netfilter_exit(void)
+{
+ nf_unregister_hooks(fp_netfilter_ops, ARRAY_SIZE(fp_netfilter_ops));
+}
+
+module_init(fp_netfilter_init);
+module_exit(fp_netfilter_exit);
diff --git a/net/netfilter/nf_conntrack_core.c b/net/netfilter/nf_conntrack_core.c
index bc3f791..b7b4b82 100644
--- a/net/netfilter/nf_conntrack_core.c
+++ b/net/netfilter/nf_conntrack_core.c
@@ -382,7 +382,29 @@
static void death_by_timeout(unsigned long ul_conntrack)
{
+#ifdef CONFIG_COMCERTO_FP
+ struct nf_conn *ct = (void *)ul_conntrack;
+ struct nf_conntrack_l4proto *l4proto;
+ u_int8_t l4proto_num;
+
+ rcu_read_lock();
+
+ l4proto = __nf_ct_l4proto_find(nf_ct_l3num(ct), nf_ct_protonum(ct));
+ l4proto_num = l4proto->l4proto;
+
+ rcu_read_unlock();
+
+ if (test_bit(IPS_DYING_BIT, &ct->status) ||
+ (!test_bit(IPS_PERMANENT_BIT, &ct->status)) ||
+ ((l4proto_num == IPPROTO_TCP) && (ct->proto.tcp.state != TCP_CONNTRACK_ESTABLISHED))) {
+ nf_ct_delete((struct nf_conn *)ul_conntrack, 0, 0);
+ } else {
+ ct->timeout.expires = jiffies + COMCERTO_PERMANENT_TIMEOUT * HZ;
+ add_timer(&ct->timeout);
+ }
+#else
nf_ct_delete((struct nf_conn *)ul_conntrack, 0, 0);
+#endif
}
static inline bool
@@ -762,7 +784,13 @@
if (!ct)
return dropped;
+#ifdef CONFIG_COMCERTO_FP
+ clear_bit(IPS_PERMANENT_BIT, &ct->status);
+ /* Avoid race with timer expiration */
+ if (del_timer_sync(&ct->timeout)) {
+#else
if (del_timer(&ct->timeout)) {
+#endif
if (nf_ct_delete(ct, 0, 0)) {
dropped = 1;
NF_CT_STAT_INC_ATOMIC(net, early_drop);
@@ -1260,7 +1288,13 @@
}
}
+#ifdef CONFIG_COMCERTO_FP
+ clear_bit(IPS_PERMANENT_BIT, &ct->status);
+ /* Avoid race with timer expiration */
+ if (del_timer_sync(&ct->timeout)) {
+#else
if (del_timer(&ct->timeout)) {
+#endif
ct->timeout.function((unsigned long)ct);
return true;
}
@@ -1399,7 +1433,13 @@
while ((ct = get_next_corpse(net, iter, data, &bucket)) != NULL) {
/* Time to push up daises... */
+#ifdef CONFIG_COMCERTO_FP
+ clear_bit(IPS_PERMANENT_BIT, &ct->status);
+ /* Avoid race with timer expiration */
+ if (del_timer_sync(&ct->timeout))
+#else
if (del_timer(&ct->timeout))
+#endif
nf_ct_delete(ct, portid, report);
/* ... else the timer will get him soon. */
diff --git a/net/netfilter/nf_conntrack_netlink.c b/net/netfilter/nf_conntrack_netlink.c
index 6b8b0ab..c979a8b 100644
--- a/net/netfilter/nf_conntrack_netlink.c
+++ b/net/netfilter/nf_conntrack_netlink.c
@@ -330,6 +330,41 @@
#define ctnetlink_dump_secctx(a, b) (0)
#endif
+#if defined(CONFIG_COMCERTO_FP)
+static int
+ctnetlink_dump_comcerto_fp(struct sk_buff *skb, const struct nf_conn *ct)
+{
+ struct nlattr *nest_count;
+
+ nest_count = nla_nest_start(skb, CTA_COMCERTO_FP_ORIG | NLA_F_NESTED);
+ if (!nest_count)
+ goto nla_put_failure;
+
+ nla_put_u32(skb, CTA_COMCERTO_FP_MARK, ct->fp_info[IP_CT_DIR_ORIGINAL].mark);
+ nla_put_u32(skb, CTA_COMCERTO_FP_IFINDEX, ct->fp_info[IP_CT_DIR_ORIGINAL].ifindex);
+ nla_put_u32(skb, CTA_COMCERTO_FP_IIF, ct->fp_info[IP_CT_DIR_ORIGINAL].iif);
+
+ nla_nest_end(skb, nest_count);
+
+ nest_count = nla_nest_start(skb, CTA_COMCERTO_FP_REPLY | NLA_F_NESTED);
+ if (!nest_count)
+ goto nla_put_failure;
+
+ nla_put_u32(skb, CTA_COMCERTO_FP_MARK, ct->fp_info[IP_CT_DIR_REPLY].mark);
+ nla_put_u32(skb, CTA_COMCERTO_FP_IFINDEX, ct->fp_info[IP_CT_DIR_REPLY].ifindex);
+ nla_put_u32(skb, CTA_COMCERTO_FP_IIF, ct->fp_info[IP_CT_DIR_REPLY].iif);
+
+ nla_nest_end(skb, nest_count);
+
+ return 0;
+
+nla_put_failure:
+ return -1;
+}
+#else
+#define ctnetlink_dump_comcerto_fp(a, b) (0)
+#endif
+
#ifdef CONFIG_NF_CONNTRACK_LABELS
static int ctnetlink_label_size(const struct nf_conn *ct)
{
@@ -499,6 +534,7 @@
ctnetlink_dump_helpinfo(skb, ct) < 0 ||
ctnetlink_dump_mark(skb, ct) < 0 ||
ctnetlink_dump_secctx(skb, ct) < 0 ||
+ ctnetlink_dump_comcerto_fp(skb, ct) < 0 ||
ctnetlink_dump_labels(skb, ct) < 0 ||
ctnetlink_dump_id(skb, ct) < 0 ||
ctnetlink_dump_use(skb, ct) < 0 ||
@@ -590,6 +626,12 @@
+ nla_total_size(0) /* CTA_HELP */
+ nla_total_size(NF_CT_HELPER_NAME_LEN) /* CTA_HELP_NAME */
+ ctnetlink_secctx_size(ct)
+#ifdef CONFIG_COMCERTO_FP
+ + 2 * nla_total_size(0) /* CTA_COMCERTO_FP_ORIG|REPL */
+ + 2 * nla_total_size(sizeof(uint32_t)) /* CTA_COMCERTO_FP_MARK */
+ + 2 * nla_total_size(sizeof(uint32_t)) /* CTA_COMCERTO_FP_IFINDEX */
+ + 2 * nla_total_size(sizeof(uint32_t)) /* CTA_COMCERTO_FP_IIF */
+#endif
#ifdef CONFIG_NF_NAT_NEEDED
+ 2 * nla_total_size(0) /* CTA_NAT_SEQ_ADJ_ORIG|REPL */
+ 6 * nla_total_size(sizeof(u_int32_t)) /* CTA_NAT_SEQ_OFFSET */
@@ -673,6 +715,9 @@
nla_put_be16(skb, CTA_ZONE, htons(nf_ct_zone(ct))))
goto nla_put_failure;
+ if (ctnetlink_dump_comcerto_fp(skb, ct) < 0)
+ goto nla_put_failure;
+
if (ctnetlink_dump_id(skb, ct) < 0)
goto nla_put_failure;
@@ -1371,6 +1416,37 @@
return 0;
}
+#if defined(CONFIG_COMCERTO_FP)
+/*
+ * This function detects ctnetlink messages that require
+ * to set the conntrack status to IPS_PERMANENT.
+ * It updates only this bit regardless of other possible
+ * changes.
+ * Return 0 if succesfull
+ */
+static int
+ctnetlink_change_permanent(struct nf_conn *ct, const struct nlattr * const cda[])
+{
+ unsigned int status;
+ u_int32_t id;
+
+ if (cda[CTA_STATUS] && cda[CTA_ID]) {
+ status = ntohl(nla_get_be32(cda[CTA_STATUS]));
+ id = ntohl(nla_get_be32(cda[CTA_ID]));
+
+ if (status & IPS_PERMANENT) {
+ if ((u32)(unsigned long)ct == id) {
+ ct->status |= IPS_PERMANENT;
+ return 0;
+ }
+ else
+ return -ENOENT;
+ }
+ }
+ return -1;
+}
+#endif
+
static int
ctnetlink_setup_nat(struct nf_conn *ct, const struct nlattr * const cda[])
{
@@ -1870,6 +1946,13 @@
ct = nf_ct_tuplehash_to_ctrack(h);
if (!(nlh->nlmsg_flags & NLM_F_EXCL)) {
spin_lock_bh(&nf_conntrack_expect_lock);
+#if defined(CONFIG_COMCERTO_FP)
+ /* If the permanent status has been set, this is a specific
+ * message. Don't broadcast the event and don't update the ct */
+ err = ctnetlink_change_permanent(ct, cda);
+ if ((err == 0) || (err == -ENOENT))
+ return err;
+#endif
err = ctnetlink_change_conntrack(ct, cda);
spin_unlock_bh(&nf_conntrack_expect_lock);
if (err == 0) {
diff --git a/net/netfilter/nf_conntrack_rtsp.c b/net/netfilter/nf_conntrack_rtsp.c
new file mode 100644
index 0000000..310e6da
--- /dev/null
+++ b/net/netfilter/nf_conntrack_rtsp.c
@@ -0,0 +1,576 @@
+/*
+ * RTSP extension for IP connection tracking
+ * (C) 2003 by Tom Marshall <tmarshall at real.com>
+ *
+ * 2005-02-13: Harald Welte <laforge at netfilter.org>
+ * - port to 2.6
+ * - update to recent post-2.6.11 api changes
+ * 2006-09-14: Steven Van Acker <deepstar at singularity.be>
+ * - removed calls to NAT code from conntrack helper: NAT no longer needed to use rtsp-conntrack
+ * 2007-04-18: Michael Guntsche <mike at it-loops.com>
+ * - Port to new NF API
+ * 2013-03-04: Il'inykh Sergey <sergeyi at inango-sw.com>. Inango Systems Ltd
+ * - fixed rtcp nat mapping and other port mapping fixes
+ * - simple TEARDOWN request handling
+ * - codestyle fixes and other less significant bug fixes
+ *
+ * based on ip_conntrack_irc.c
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Module load syntax:
+ * insmod nf_conntrack_rtsp.o ports=port1,port2,...port<MAX_PORTS>
+ * max_outstanding=n setup_timeout=secs
+ *
+ * If no ports are specified, the default will be port 554.
+ *
+ * With max_outstanding you can define the maximum number of not yet
+ * answered SETUP requests per RTSP session (default 8).
+ * With setup_timeout you can specify how long the system waits for
+ * an expected data channel (default 300 seconds).
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/netfilter.h>
+#include <linux/ip.h>
+#include <linux/inet.h>
+#include <net/tcp.h>
+
+#include <net/netfilter/nf_conntrack.h>
+#include <net/netfilter/nf_conntrack_expect.h>
+#include <net/netfilter/nf_conntrack_helper.h>
+#include <linux/netfilter/nf_conntrack_rtsp.h>
+
+#define NF_NEED_STRNCASECMP
+#define NF_NEED_STRTOU16
+#define NF_NEED_STRTOU32
+#define NF_NEED_NEXTLINE
+#include <linux/netfilter/netfilter_helpers.h>
+#define NF_NEED_MIME_NEXTLINE
+#include <linux/netfilter/netfilter_mime.h>
+
+#include <linux/ctype.h>
+
+#define MAX_PORTS 8
+static int ports[MAX_PORTS];
+static int num_ports = 0;
+static int max_outstanding = 8;
+static unsigned int setup_timeout = 300;
+
+MODULE_AUTHOR("Tom Marshall <tmarshall at real.com>");
+MODULE_DESCRIPTION("RTSP connection tracking module");
+MODULE_LICENSE("GPL");
+module_param_array(ports, int, &num_ports, 0400);
+MODULE_PARM_DESC(ports, "port numbers of RTSP servers");
+module_param(max_outstanding, int, 0400);
+MODULE_PARM_DESC(max_outstanding, "max number of outstanding SETUP requests per RTSP session");
+module_param(setup_timeout, int, 0400);
+MODULE_PARM_DESC(setup_timeout, "timeout on for unestablished data channels");
+
+static char *rtsp_buffer;
+static DEFINE_SPINLOCK(rtsp_buffer_lock);
+
+static struct nf_conntrack_expect_policy rtsp_exp_policy;
+
+unsigned int (*nf_nat_rtsp_hook)(struct sk_buff *skb,
+ enum ip_conntrack_info ctinfo,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ unsigned int protoff,
+#endif
+ unsigned int matchoff, unsigned int matchlen,
+ struct ip_ct_rtsp_expect* prtspexp,
+ struct nf_conntrack_expect *rtp_exp,
+ struct nf_conntrack_expect *rtcp_exp);
+
+EXPORT_SYMBOL_GPL(nf_nat_rtsp_hook);
+
+/*
+ * Max mappings we will allow for one RTSP connection (for RTP, the number
+ * of allocated ports is twice this value). Note that SMIL burns a lot of
+ * ports so keep this reasonably high. If this is too low, you will see a
+ * lot of "no free client map entries" messages.
+ */
+#define MAX_PORT_MAPS 16
+
+/*** default port list was here in the masq code: 554, 3030, 4040 ***/
+
+#define SKIP_WSPACE(ptr,len,off) while(off < len && isspace(*(ptr+off))) { off++; }
+
+/*
+ * Parse an RTSP packet.
+ *
+ * Returns zero if parsing failed.
+ *
+ * Parameters:
+ * IN ptcp tcp data pointer
+ * IN tcplen tcp data len
+ * IN/OUT ptcpoff points to current tcp offset
+ * OUT phdrsoff set to offset of rtsp headers
+ * OUT phdrslen set to length of rtsp headers
+ * OUT pcseqoff set to offset of CSeq header
+ * OUT pcseqlen set to length of CSeq header
+ */
+static int
+rtsp_parse_message(char* ptcp, uint tcplen, uint* ptcpoff,
+ uint* phdrsoff, uint* phdrslen,
+ uint* pcseqoff, uint* pcseqlen,
+ uint* transoff, uint* translen)
+{
+ uint entitylen = 0;
+ uint lineoff;
+ uint linelen;
+
+ if (!nf_nextline(ptcp, tcplen, ptcpoff, &lineoff, &linelen))
+ return 0;
+
+ *phdrsoff = *ptcpoff;
+ while (nf_mime_nextline(ptcp, tcplen, ptcpoff, &lineoff, &linelen)) {
+ if (linelen == 0) {
+ if (entitylen > 0)
+ *ptcpoff += min(entitylen, tcplen - *ptcpoff);
+ break;
+ }
+ if (lineoff+linelen > tcplen) {
+ pr_info("!! overrun !!\n");
+ break;
+ }
+
+ if (nf_strncasecmp(ptcp+lineoff, "CSeq:", 5) == 0) {
+ *pcseqoff = lineoff;
+ *pcseqlen = linelen;
+ }
+
+ if (nf_strncasecmp(ptcp+lineoff, "Transport:", 10) == 0) {
+ *transoff = lineoff;
+ *translen = linelen;
+ }
+
+ if (nf_strncasecmp(ptcp+lineoff, "Content-Length:", 15) == 0) {
+ uint off = lineoff+15;
+ SKIP_WSPACE(ptcp+lineoff, linelen, off);
+ nf_strtou32(ptcp+off, &entitylen);
+ }
+ }
+ *phdrslen = (*ptcpoff) - (*phdrsoff);
+
+ return 1;
+}
+
+/*
+ * Find lo/hi client ports (if any) in transport header
+ * In:
+ * ptcp, tcplen = packet
+ * tranoff, tranlen = buffer to search
+ *
+ * Out:
+ * pport_lo, pport_hi = lo/hi ports (host endian)
+ *
+ * Returns nonzero if any client ports found
+ *
+ * Note: it is valid (and expected) for the client to request multiple
+ * transports, so we need to parse the entire line.
+ */
+static int
+rtsp_parse_transport(char* ptran, uint tranlen,
+ struct ip_ct_rtsp_expect* prtspexp)
+{
+ int rc = 0;
+ uint off = 0;
+
+ if (tranlen < 10 || !iseol(ptran[tranlen-1]) ||
+ nf_strncasecmp(ptran, "Transport:", 10) != 0) {
+ pr_info("sanity check failed\n");
+ return 0;
+ }
+
+ pr_debug("tran='%.*s'\n", (int)tranlen, ptran);
+ off += 10;
+ SKIP_WSPACE(ptran, tranlen, off);
+
+ /* Transport: tran;field;field=val,tran;field;field=val,... */
+ while (off < tranlen) {
+ const char* pparamend;
+ uint nextparamoff;
+
+ pparamend = memchr(ptran+off, ',', tranlen-off);
+ pparamend = (pparamend == NULL) ? ptran+tranlen : pparamend+1;
+ nextparamoff = pparamend-ptran;
+
+ while (off < nextparamoff) {
+ const char* pfieldend;
+ uint nextfieldoff;
+
+ pfieldend = memchr(ptran+off, ';', nextparamoff-off);
+ nextfieldoff = (pfieldend == NULL) ? nextparamoff : pfieldend-ptran+1;
+
+ if (strncmp(ptran+off, "client_port=", 12) == 0) {
+ u_int16_t port;
+ uint numlen;
+
+ off += 12;
+ numlen = nf_strtou16(ptran+off, &port);
+ off += numlen;
+ if (prtspexp->loport != 0 && prtspexp->loport != port)
+ pr_debug("multiple ports found, port %hu ignored\n", port);
+ else {
+ pr_debug("lo port found : %hu\n", port);
+ prtspexp->loport = prtspexp->hiport = port;
+ if (ptran[off] == '-') {
+ off++;
+ numlen = nf_strtou16(ptran+off, &port);
+ off += numlen;
+ prtspexp->pbtype = pb_range;
+ prtspexp->hiport = port;
+
+ // If we have a range, assume rtp:
+ // loport must be even, hiport must be loport+1
+ if ((prtspexp->loport & 0x0001) != 0 ||
+ prtspexp->hiport != prtspexp->loport+1) {
+ pr_debug("incorrect range: %hu-%hu, correcting\n",
+ prtspexp->loport, prtspexp->hiport);
+ prtspexp->loport &= 0xfffe;
+ prtspexp->hiport = prtspexp->loport+1;
+ }
+ } else if (ptran[off] == '/') {
+ off++;
+ numlen = nf_strtou16(ptran+off, &port);
+ off += numlen;
+ prtspexp->pbtype = pb_discon;
+ prtspexp->hiport = port;
+ }
+ rc = 1;
+ }
+ }
+
+ /*
+ * Note we don't look for the destination parameter here.
+ * If we are using NAT, the NAT module will handle it. If not,
+ * and the client is sending packets elsewhere, the expectation
+ * will quietly time out.
+ */
+
+ off = nextfieldoff;
+ }
+
+ off = nextparamoff;
+ }
+
+ return rc;
+}
+
+
+/*** conntrack functions ***/
+
+/* outbound packet: client->server */
+
+static inline int
+help_out(struct sk_buff *skb, unsigned char *rb_ptr, unsigned int datalen,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ struct nf_conn *ct, enum ip_conntrack_info ctinfo,
+ unsigned int protoff)
+#else
+ struct nf_conn *ct, enum ip_conntrack_info ctinfo)
+#endif
+{
+ struct ip_ct_rtsp_expect expinfo;
+
+ int dir = CTINFO2DIR(ctinfo); /* = IP_CT_DIR_ORIGINAL */
+ //struct tcphdr* tcph = (void*)iph + iph->ihl * 4;
+ //uint tcplen = pktlen - iph->ihl * 4;
+ char* pdata = rb_ptr;
+ //uint datalen = tcplen - tcph->doff * 4;
+ uint dataoff = 0;
+ int ret = NF_ACCEPT;
+
+ struct nf_conntrack_expect *rtp_exp;
+ struct nf_conntrack_expect *rtcp_exp = NULL;
+
+ __be16 be_loport;
+ __be16 be_hiport;
+
+ typeof(nf_nat_rtsp_hook) nf_nat_rtsp;
+
+ memset(&expinfo, 0, sizeof(expinfo));
+
+ while (dataoff < datalen) {
+ uint cmdoff = dataoff;
+ uint hdrsoff = 0;
+ uint hdrslen = 0;
+ uint cseqoff = 0;
+ uint cseqlen = 0;
+ uint transoff = 0;
+ uint translen = 0;
+ uint off;
+
+ if (!rtsp_parse_message(pdata, datalen, &dataoff,
+ &hdrsoff, &hdrslen,
+ &cseqoff, &cseqlen,
+ &transoff, &translen))
+ break; /* not a valid message */
+
+ if (strncmp(pdata+cmdoff, "TEARDOWN ", 9) == 0) {
+ pr_debug("teardown handled\n");
+ nf_ct_remove_expectations(ct); /* FIXME must be session id aware */
+ break;
+ }
+
+ if (strncmp(pdata+cmdoff, "SETUP ", 6) != 0)
+ continue; /* not a SETUP message */
+
+ pr_debug("found a setup message\n");
+
+ off = 0;
+ if(translen)
+ rtsp_parse_transport(pdata+transoff, translen, &expinfo);
+
+ if (expinfo.loport == 0) {
+ pr_debug("no udp transports found\n");
+ continue; /* no udp transports found */
+ }
+
+ pr_debug("udp transport found, ports=(%d,%hu,%hu)\n",
+ (int)expinfo.pbtype, expinfo.loport, expinfo.hiport);
+
+
+ be_loport = htons(expinfo.loport);
+
+ rtp_exp = nf_ct_expect_alloc(ct);
+ if (rtp_exp == NULL) {
+ ret = NF_DROP;
+ goto out;
+ }
+
+ nf_ct_expect_init(rtp_exp, NF_CT_EXPECT_CLASS_DEFAULT,
+ nf_ct_l3num(ct),
+ &ct->tuplehash[!dir].tuple.src.u3,
+ &ct->tuplehash[!dir].tuple.dst.u3,
+ IPPROTO_UDP, NULL, &be_loport);
+
+ rtp_exp->flags = 0;
+
+ if (expinfo.pbtype == pb_range) {
+ pr_debug("setup expectation for rtcp\n");
+
+ be_hiport = htons(expinfo.hiport);
+ rtcp_exp = nf_ct_expect_alloc(ct);
+ if (rtcp_exp == NULL) {
+ ret = NF_DROP;
+ goto out1;
+ }
+
+ nf_ct_expect_init(rtcp_exp, NF_CT_EXPECT_CLASS_DEFAULT,
+ nf_ct_l3num(ct),
+ &ct->tuplehash[!dir].tuple.src.u3,
+ &ct->tuplehash[!dir].tuple.dst.u3,
+ IPPROTO_UDP, NULL, &be_hiport);
+
+ rtcp_exp->flags = 0;
+
+ pr_debug("expect_related %pI4:%u-%u-%pI4:%u-%u\n",
+ &rtp_exp->tuple.src.u3.ip,
+ ntohs(rtp_exp->tuple.src.u.udp.port),
+ ntohs(rtcp_exp->tuple.src.u.udp.port),
+ &rtp_exp->tuple.dst.u3.ip,
+ ntohs(rtp_exp->tuple.dst.u.udp.port),
+ ntohs(rtcp_exp->tuple.dst.u.udp.port));
+ } else {
+ pr_debug("expect_related %pI4:%u-%pI4:%u\n",
+ &rtp_exp->tuple.src.u3.ip,
+ ntohs(rtp_exp->tuple.src.u.udp.port),
+ &rtp_exp->tuple.dst.u3.ip,
+ ntohs(rtp_exp->tuple.dst.u.udp.port));
+ }
+
+ nf_nat_rtsp = rcu_dereference(nf_nat_rtsp_hook);
+ if (nf_nat_rtsp && ct->status & IPS_NAT_MASK)
+ /* pass the request off to the nat helper */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ ret = nf_nat_rtsp(skb, ctinfo, protoff, hdrsoff, hdrslen,
+ &expinfo, rtp_exp, rtcp_exp);
+#else
+ ret = nf_nat_rtsp(skb, ctinfo, hdrsoff, hdrslen,
+ &expinfo, rtp_exp, rtcp_exp);
+#endif
+ else {
+ if (nf_ct_expect_related(rtp_exp) == 0) {
+ if (rtcp_exp && nf_ct_expect_related(rtcp_exp) != 0) {
+ nf_ct_unexpect_related(rtp_exp);
+ pr_info("nf_conntrack_expect_related failed for rtcp\n");
+ ret = NF_DROP;
+ }
+ } else {
+ pr_info("nf_conntrack_expect_related failed for rtp\n");
+ ret = NF_DROP;
+ }
+ }
+ if (rtcp_exp) {
+ nf_ct_expect_put(rtcp_exp);
+ }
+out1:
+ nf_ct_expect_put(rtp_exp);
+ goto out;
+ }
+out:
+
+ return ret;
+}
+
+
+static inline int
+help_in(struct sk_buff *skb, size_t pktlen,
+ struct nf_conn* ct, enum ip_conntrack_info ctinfo)
+{
+ return NF_ACCEPT;
+}
+
+static int help(struct sk_buff *skb, unsigned int protoff,
+ struct nf_conn *ct, enum ip_conntrack_info ctinfo)
+{
+ struct tcphdr _tcph, *th;
+ unsigned int dataoff, datalen;
+ char *rb_ptr;
+ int ret = NF_DROP;
+
+ /* Until there's been traffic both ways, don't look in packets. */
+ if (ctinfo != IP_CT_ESTABLISHED &&
+ ctinfo != IP_CT_ESTABLISHED + IP_CT_IS_REPLY) {
+ pr_debug("conntrackinfo = %u\n", ctinfo);
+ return NF_ACCEPT;
+ }
+
+ /* Not whole TCP header? */
+ th = skb_header_pointer(skb, protoff, sizeof(_tcph), &_tcph);
+
+ if (!th)
+ return NF_ACCEPT;
+
+ /* No data ? */
+ dataoff = protoff + th->doff*4;
+ datalen = skb->len - dataoff;
+ if (dataoff >= skb->len)
+ return NF_ACCEPT;
+
+ spin_lock_bh(&rtsp_buffer_lock);
+ rb_ptr = skb_header_pointer(skb, dataoff,
+ skb->len - dataoff, rtsp_buffer);
+ BUG_ON(rb_ptr == NULL);
+
+#if 0
+ /* Checksum invalid? Ignore. */
+ /* FIXME: Source route IP option packets --RR */
+ if (tcp_v4_check(tcph, tcplen, iph->saddr, iph->daddr,
+ csum_partial((char*)tcph, tcplen, 0)))
+ {
+ DEBUGP("bad csum: %p %u %u.%u.%u.%u %u.%u.%u.%u\n",
+ tcph, tcplen, NIPQUAD(iph->saddr), NIPQUAD(iph->daddr));
+ return NF_ACCEPT;
+ }
+#endif
+
+ switch (CTINFO2DIR(ctinfo)) {
+ case IP_CT_DIR_ORIGINAL:
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ ret = help_out(skb, rb_ptr, datalen, ct, ctinfo, protoff);
+#else
+ ret = help_out(skb, rb_ptr, datalen, ct, ctinfo);
+#endif
+ break;
+ case IP_CT_DIR_REPLY:
+ pr_debug("IP_CT_DIR_REPLY\n");
+ /* inbound packet: server->client */
+ ret = NF_ACCEPT;
+ break;
+ }
+
+ spin_unlock_bh(&rtsp_buffer_lock);
+
+ return ret;
+}
+
+static struct nf_conntrack_helper rtsp_helpers[MAX_PORTS];
+static char rtsp_names[MAX_PORTS][10];
+
+/* This function is intentionally _NOT_ defined as __exit */
+static void
+fini(void)
+{
+ int i;
+ for (i = 0; i < num_ports; i++) {
+ pr_debug("unregistering port %d\n", ports[i]);
+ nf_conntrack_helper_unregister(&rtsp_helpers[i]);
+ }
+ kfree(rtsp_buffer);
+}
+
+static int __init
+init(void)
+{
+ int i, ret;
+ struct nf_conntrack_helper *hlpr;
+ char *tmpname;
+
+ printk("nf_conntrack_rtsp v" IP_NF_RTSP_VERSION " loading\n");
+
+ if (max_outstanding < 1) {
+ printk("nf_conntrack_rtsp: max_outstanding must be a positive integer\n");
+ return -EBUSY;
+ }
+ if (setup_timeout < 0) {
+ printk("nf_conntrack_rtsp: setup_timeout must be a positive integer\n");
+ return -EBUSY;
+ }
+
+ rtsp_exp_policy.max_expected = max_outstanding;
+ rtsp_exp_policy.timeout = setup_timeout;
+
+ rtsp_buffer = kmalloc(65536, GFP_KERNEL);
+ if (!rtsp_buffer)
+ return -ENOMEM;
+
+ /* If no port given, default to standard rtsp port */
+ if (ports[0] == 0) {
+ ports[0] = RTSP_PORT;
+ num_ports = 1;
+ }
+
+ for (i = 0; (i < MAX_PORTS) && ports[i]; i++) {
+ hlpr = &rtsp_helpers[i];
+ memset(hlpr, 0, sizeof(struct nf_conntrack_helper));
+ hlpr->tuple.src.l3num = AF_INET;
+ hlpr->tuple.src.u.tcp.port = htons(ports[i]);
+ hlpr->tuple.dst.protonum = IPPROTO_TCP;
+ hlpr->expect_policy = &rtsp_exp_policy;
+ hlpr->me = THIS_MODULE;
+ hlpr->help = help;
+
+ tmpname = &rtsp_names[i][0];
+ if (ports[i] == RTSP_PORT) {
+ sprintf(tmpname, "rtsp");
+ } else {
+ sprintf(tmpname, "rtsp-%d", i);
+ }
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)
+ strlcpy(hlpr->name, tmpname, sizeof(hlpr->name));
+#else
+ hlpr->name = tmpname;
+#endif
+ pr_debug("port #%d: %d\n", i, ports[i]);
+
+ ret = nf_conntrack_helper_register(hlpr);
+
+ if (ret) {
+ printk("nf_conntrack_rtsp: ERROR registering port %d\n", ports[i]);
+ fini();
+ return -EBUSY;
+ }
+ }
+ return 0;
+}
+
+module_init(init);
+module_exit(fini);
diff --git a/net/netfilter/nf_conntrack_standalone.c b/net/netfilter/nf_conntrack_standalone.c
index fc823fa..ccc572c 100644
--- a/net/netfilter/nf_conntrack_standalone.c
+++ b/net/netfilter/nf_conntrack_standalone.c
@@ -220,6 +220,12 @@
if (test_bit(IPS_ASSURED_BIT, &ct->status))
seq_printf(s, "[ASSURED] ");
+#ifdef CONFIG_COMCERTO_FP
+ if (test_bit(IPS_PERMANENT_BIT, &ct->status))
+ if (seq_printf(s, "[PERMANENT] "))
+ goto release;
+#endif
+
if (seq_has_overflowed(s))
goto release;
diff --git a/net/netfilter/nf_nat_rtsp.c b/net/netfilter/nf_nat_rtsp.c
new file mode 100644
index 0000000..56d2603
--- /dev/null
+++ b/net/netfilter/nf_nat_rtsp.c
@@ -0,0 +1,617 @@
+/*
+ * RTSP extension for TCP NAT alteration
+ * (C) 2003 by Tom Marshall <tmarshall at real.com>
+ *
+ * 2013-03-04: Il'inykh Sergey <sergeyi at inango-sw.com>. Inango Systems Ltd
+ * - fixed rtcp nat mapping and other port mapping fixes
+ * - fixed system hard lock because of bug in the parser
+ * - codestyle fixes and less significant fixes
+ *
+ * based on ip_nat_irc.c
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Module load syntax:
+ * insmod nf_nat_rtsp.o ports=port1,port2,...port<MAX_PORTS>
+ * stunaddr=<address>
+ * destaction=[auto|strip|none]
+ *
+ * If no ports are specified, the default will be port 554 only.
+ *
+ * stunaddr specifies the address used to detect that a client is using STUN.
+ * If this address is seen in the destination parameter, it is assumed that
+ * the client has already punched a UDP hole in the firewall, so we don't
+ * mangle the client_port. If none is specified, it is autodetected. It
+ * only needs to be set if you have multiple levels of NAT. It should be
+ * set to the external address that the STUN clients detect. Note that in
+ * this case, it will not be possible for clients to use UDP with servers
+ * between the NATs.
+ *
+ * If no destaction is specified, auto is used.
+ * destaction=auto: strip destination parameter if it is not stunaddr.
+ * destaction=strip: always strip destination parameter (not recommended).
+ * destaction=none: do not touch destination parameter (not recommended).
+ */
+
+#include <linux/module.h>
+#include <linux/version.h>
+#include <net/tcp.h>
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+# include <net/netfilter/nf_nat.h>
+#else
+# include <net/netfilter/nf_nat_rule.h>
+#endif
+#include <net/netfilter/nf_nat_helper.h>
+#include <linux/netfilter/nf_conntrack_rtsp.h>
+#include <net/netfilter/nf_conntrack_expect.h>
+
+#include <linux/inet.h>
+#include <linux/ctype.h>
+#define NF_NEED_STRNCASECMP
+#define NF_NEED_STRTOU16
+#include <linux/netfilter/netfilter_helpers.h>
+#define NF_NEED_MIME_NEXTLINE
+#include <linux/netfilter/netfilter_mime.h>
+
+#define MAX_PORTS 8
+#define DSTACT_AUTO 0
+#define DSTACT_STRIP 1
+#define DSTACT_NONE 2
+
+static char* stunaddr = NULL;
+static char* destaction = NULL;
+
+static u_int32_t extip = 0;
+static int dstact = 0;
+
+static void nf_nat_rtsp_expected(struct nf_conn* ct, struct nf_conntrack_expect *exp);
+
+MODULE_AUTHOR("Tom Marshall <tmarshall at real.com>");
+MODULE_DESCRIPTION("RTSP network address translation module");
+MODULE_LICENSE("GPL");
+module_param(stunaddr, charp, 0644);
+MODULE_PARM_DESC(stunaddr, "Address for detecting STUN");
+module_param(destaction, charp, 0644);
+MODULE_PARM_DESC(destaction, "Action for destination parameter (auto/strip/none)");
+
+#define SKIP_WSPACE(ptr,len,off) while(off < len && isspace(*(ptr+off))) { off++; }
+
+/*** helper functions ***/
+
+static void
+get_skb_tcpdata(struct sk_buff* skb, char** pptcpdata, uint* ptcpdatalen)
+{
+ struct iphdr* iph = ip_hdr(skb);
+ struct tcphdr* tcph = (void *)iph + ip_hdrlen(skb);
+
+ *pptcpdata = (char*)tcph + tcph->doff*4;
+ *ptcpdatalen = ((char*)skb_transport_header(skb) + skb->len) - *pptcpdata;
+}
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+/* copy of sip_sprintf_addr */
+static int rtsp_sprintf_addr(const struct nf_conn *ct, char *buffer,
+ const union nf_inet_addr *addr, bool delim)
+{
+ if (nf_ct_l3num(ct) == NFPROTO_IPV4) {
+ return sprintf(buffer, "%pI4", &addr->ip);
+ } else {
+ if (delim)
+ return sprintf(buffer, "[%pI6c]", &addr->ip6);
+ else
+ return sprintf(buffer, "%pI6c", &addr->ip6);
+ }
+}
+#endif
+
+/*** nat functions ***/
+
+/*
+ * Mangle the "Transport:" header:
+ * - Replace all occurences of "client_port=<spec>"
+ * - Handle destination parameter
+ *
+ * In:
+ * ct, ctinfo = conntrack context
+ * skb = packet
+ * tranoff = Transport header offset from TCP data
+ * tranlen = Transport header length (incl. CRLF)
+ * rport_lo = replacement low port (host endian)
+ * rport_hi = replacement high port (host endian)
+ *
+ * Returns packet size difference.
+ *
+ * Assumes that a complete transport header is present, ending with CR or LF
+ */
+static int
+rtsp_mangle_tran(enum ip_conntrack_info ctinfo,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ unsigned int protoff,
+#endif
+ struct nf_conntrack_expect* rtp_exp,
+ struct nf_conntrack_expect* rtcp_exp,
+ struct ip_ct_rtsp_expect* prtspexp,
+ struct sk_buff* skb, uint tranoff, uint tranlen)
+{
+ char* ptcp;
+ uint tcplen;
+ char* ptran;
+ char rbuf1[16]; /* Replacement buffer (one port) */
+ uint rbuf1len; /* Replacement len (one port) */
+ char rbufa[16]; /* Replacement buffer (all ports) */
+ uint rbufalen; /* Replacement len (all ports) */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ union nf_inet_addr newip;
+#else
+ u_int32_t newip;
+#endif
+ u_int16_t loport, hiport;
+ uint off = 0;
+ uint diff; /* Number of bytes we removed */
+
+ struct nf_conn *ct = rtp_exp->master;
+ /* struct nf_conn *ct = nf_ct_get(skb, &ctinfo); */
+ struct nf_conntrack_tuple *rtp_t;
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ char szextaddr[INET6_ADDRSTRLEN];
+#else
+ char szextaddr[INET_ADDRSTRLEN];
+#endif
+ uint extaddrlen;
+ int is_stun;
+
+ get_skb_tcpdata(skb, &ptcp, &tcplen);
+ ptran = ptcp+tranoff;
+
+ if (tranoff+tranlen > tcplen || tcplen-tranoff < tranlen ||
+ tranlen < 10 || !iseol(ptran[tranlen-1]) ||
+ nf_strncasecmp(ptran, "Transport:", 10) != 0) {
+ pr_info("sanity check failed\n");
+ return 0;
+ }
+ off += 10;
+ SKIP_WSPACE(ptcp+tranoff, tranlen, off);
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ newip = ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u3;
+ rtp_t = &rtp_exp->tuple;
+ rtp_t->dst.u3 = newip;
+ if (rtcp_exp) {
+ rtcp_exp->tuple.dst.u3 = newip;
+ }
+ extaddrlen = rtsp_sprintf_addr(ct, szextaddr, &newip, true); // FIXME handle extip
+ pr_debug("stunaddr=%s (auto)\n", szextaddr);
+#else
+ newip = ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u3.ip;
+ rtp_t = &rtp_exp->tuple;
+ rtp_t->dst.u3.ip = newip;
+ if (rtcp_exp) {
+ rtcp_exp->tuple.dst.u3.ip = newip;
+ }
+ extaddrlen = extip ? sprintf(szextaddr, "%pI4", &extip)
+ : sprintf(szextaddr, "%pI4", &newip);
+ pr_debug("stunaddr=%s (%s)\n", szextaddr, (extip?"forced":"auto"));
+#endif
+ hiport = 0;
+ rbuf1len = rbufalen = 0;
+ switch (prtspexp->pbtype) {
+ case pb_single:
+ for (loport = prtspexp->loport; loport != 0; loport++) { /* XXX: improper wrap? */
+ rtp_t->dst.u.udp.port = htons(loport);
+ if (nf_ct_expect_related(rtp_exp) == 0) {
+ pr_debug("using port %hu\n", loport);
+ break;
+ }
+ }
+ if (loport != 0) {
+ rbuf1len = sprintf(rbuf1, "%hu", loport);
+ rbufalen = sprintf(rbufa, "%hu", loport);
+ }
+ break;
+ case pb_range:
+ for (loport = prtspexp->loport; loport != 0; loport += 2) { /* XXX: improper wrap? */
+ rtp_t->dst.u.udp.port = htons(loport);
+ if (nf_ct_expect_related(rtp_exp) != 0) {
+ continue;
+ }
+ hiport = loport + 1;
+ rtcp_exp->tuple.dst.u.udp.port = htons(hiport);
+ if (nf_ct_expect_related(rtcp_exp) != 0) {
+ nf_ct_unexpect_related(rtp_exp);
+ continue;
+ }
+
+ /* FIXME: invalid print in case of ipv6 */
+ pr_debug("nat expect_related %pI4:%u-%u-%pI4:%u-%u\n",
+ &rtp_exp->tuple.src.u3.ip,
+ ntohs(rtp_exp->tuple.src.u.udp.port),
+ ntohs(rtcp_exp->tuple.src.u.udp.port),
+ &rtp_exp->tuple.dst.u3.ip,
+ ntohs(rtp_exp->tuple.dst.u.udp.port),
+ ntohs(rtcp_exp->tuple.dst.u.udp.port));
+ break;
+ }
+ if (loport != 0) {
+ rbuf1len = sprintf(rbuf1, "%hu", loport);
+ rbufalen = sprintf(rbufa, "%hu-%hu", loport, hiport);
+ }
+ break;
+ case pb_discon:
+ for (loport = prtspexp->loport; loport != 0; loport++) { /* XXX: improper wrap? */
+ rtp_t->dst.u.udp.port = htons(loport);
+ if (nf_ct_expect_related(rtp_exp) == 0) {
+ pr_debug("using port %hu (1 of 2)\n", loport);
+ break;
+ }
+ }
+ for (hiport = prtspexp->hiport; hiport != 0; hiport++) { /* XXX: improper wrap? */
+ rtp_t->dst.u.udp.port = htons(hiport);
+ if (nf_ct_expect_related(rtp_exp) == 0) {
+ pr_debug("using port %hu (2 of 2)\n", hiport);
+ break;
+ }
+ }
+ if (loport != 0 && hiport != 0) {
+ rbuf1len = sprintf(rbuf1, "%hu", loport);
+ rbufalen = sprintf(rbufa, hiport == loport+1 ?
+ "%hu-%hu":"%hu/%hu", loport, hiport);
+ }
+ break;
+ }
+
+ if (rbuf1len == 0)
+ return 0; /* cannot get replacement port(s) */
+
+ /* Transport: tran;field;field=val,tran;field;field=val,...
+ `off` is set to the start of Transport value from start of line
+ */
+ while (off < tranlen) {
+ uint saveoff;
+ const char* pparamend;
+ uint nextparamoff;
+
+ pparamend = memchr(ptran+off, ',', tranlen-off);
+ pparamend = (pparamend == NULL) ? ptran+tranlen : pparamend+1;
+ nextparamoff = pparamend-ptran;
+
+ /*
+ * We pass over each param twice. On the first pass, we look for a
+ * destination= field. It is handled by the security policy. If it
+ * is present, allowed, and equal to our external address, we assume
+ * that STUN is being used and we leave the client_port= field alone.
+ */
+ is_stun = 0;
+ saveoff = off;
+ while (off < nextparamoff) {
+ const char* pfieldend;
+ uint nextfieldoff;
+
+ pfieldend = memchr(ptran+off, ';', nextparamoff-off);
+ nextfieldoff = (pfieldend == NULL) ? nextparamoff : pfieldend-ptran+1;
+
+ if (dstact != DSTACT_NONE && strncmp(ptran+off, "destination=", 12) == 0) {
+ if (strncmp(ptran+off+12, szextaddr, extaddrlen) == 0)
+ is_stun = 1;
+
+ if (dstact == DSTACT_STRIP || (dstact == DSTACT_AUTO && !is_stun)) {
+ uint dstoff = (ptran-ptcp)+off;
+ uint dstlen = nextfieldoff-off;
+ char* pdstrep = NULL;
+ uint dstreplen = 0;
+ diff = dstlen;
+ if (dstact == DSTACT_AUTO && !is_stun) {
+ pr_debug("RTSP: replace dst addr\n");
+ dstoff += 12;
+ dstlen -= 13;
+ pdstrep = szextaddr;
+ dstreplen = extaddrlen;
+ diff = nextfieldoff-off-13-extaddrlen;
+ }
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ if (!nf_nat_mangle_tcp_packet(skb, ct, ctinfo, protoff,
+ dstoff, dstlen, pdstrep, dstreplen)) {
+#else
+ if (!nf_nat_mangle_tcp_packet(skb, ct, ctinfo,
+ dstoff, dstlen, pdstrep, dstreplen)) {
+#endif
+ /* mangle failed, all we can do is bail */
+ nf_ct_unexpect_related(rtp_exp);
+ if (rtcp_exp)
+ nf_ct_unexpect_related(rtcp_exp);
+ return 0;
+ }
+ get_skb_tcpdata(skb, &ptcp, &tcplen);
+ ptran = ptcp+tranoff;
+ tranlen -= diff;
+ nextparamoff -= diff;
+ nextfieldoff -= diff;
+ }
+ }
+
+ off = nextfieldoff;
+ }
+
+ if (is_stun)
+ continue;
+
+ off = saveoff;
+ while (off < nextparamoff) {
+ const char* pfieldend;
+ uint nextfieldoff;
+
+ pfieldend = memchr(ptran+off, ';', nextparamoff-off);
+ nextfieldoff = (pfieldend == NULL) ? nextparamoff : pfieldend-ptran+1;
+
+ if (strncmp(ptran+off, "client_port=", 12) == 0) {
+ u_int16_t port;
+ uint numlen;
+ uint origoff;
+ uint origlen;
+ char* rbuf = rbuf1;
+ uint rbuflen = rbuf1len;
+
+ off += 12;
+ origoff = (ptran-ptcp)+off;
+ origlen = 0;
+ numlen = nf_strtou16(ptran+off, &port);
+ off += numlen;
+ origlen += numlen;
+ if (port != prtspexp->loport) {
+ pr_debug("multiple ports found, port %hu ignored\n", port);
+ } else {
+ if (ptran[off] == '-' || ptran[off] == '/') {
+ off++;
+ origlen++;
+ numlen = nf_strtou16(ptran+off, &port);
+ off += numlen;
+ origlen += numlen;
+ rbuf = rbufa;
+ rbuflen = rbufalen;
+ }
+
+ /*
+ * note we cannot just memcpy() if the sizes are the same.
+ * the mangle function does skb resizing, checks for a
+ * cloned skb, and updates the checksums.
+ *
+ * parameter 4 below is offset from start of tcp data.
+ */
+ diff = origlen-rbuflen;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ if (!nf_nat_mangle_tcp_packet(skb, ct, ctinfo, protoff,
+ origoff, origlen, rbuf, rbuflen)) {
+#else
+ if (!nf_nat_mangle_tcp_packet(skb, ct, ctinfo,
+ origoff, origlen, rbuf, rbuflen)) {
+#endif
+ /* mangle failed, all we can do is bail */
+ nf_ct_unexpect_related(rtp_exp);
+ if (rtcp_exp)
+ nf_ct_unexpect_related(rtcp_exp);
+ return 0;
+ }
+ get_skb_tcpdata(skb, &ptcp, &tcplen);
+ ptran = ptcp+tranoff;
+ tranlen -= diff;
+ nextparamoff -= diff;
+ nextfieldoff -= diff;
+ }
+ }
+
+ off = nextfieldoff;
+ }
+
+ off = nextparamoff;
+ }
+
+ return 1;
+}
+
+static uint
+help_out(struct sk_buff *skb, enum ip_conntrack_info ctinfo,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ unsigned int protoff,
+#endif
+ unsigned int matchoff, unsigned int matchlen,
+ struct ip_ct_rtsp_expect* prtspexp,
+ struct nf_conntrack_expect* rtp_exp,
+ struct nf_conntrack_expect* rtcp_exp)
+{
+ char* ptcp;
+ uint tcplen;
+ uint hdrsoff;
+ uint hdrslen;
+ uint lineoff;
+ uint linelen;
+ uint off;
+ int dir = CTINFO2DIR(ctinfo);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ union nf_inet_addr saddr = rtp_exp->master->tuplehash[dir].tuple.src.u3;
+#else
+ __be32 saddr = rtp_exp->master->tuplehash[dir].tuple.src.u3.ip;
+#endif
+
+ //struct iphdr* iph = (struct iphdr*)(*pskb)->nh.iph;
+ //struct tcphdr* tcph = (struct tcphdr*)((void*)iph + iph->ihl*4);
+
+ get_skb_tcpdata(skb, &ptcp, &tcplen);
+ hdrsoff = matchoff;//exp->seq - ntohl(tcph->seq);
+ hdrslen = matchlen;
+ off = hdrsoff;
+ pr_debug("NAT rtsp help_out\n");
+
+ while (nf_mime_nextline(ptcp, hdrsoff+hdrslen, &off, &lineoff, &linelen)) {
+ if (linelen == 0)
+ break;
+
+ if (off > hdrsoff+hdrslen) {
+ pr_info("!! overrun !!");
+ break;
+ }
+ pr_debug("hdr: len=%u, %.*s", linelen, (int)linelen, ptcp+lineoff);
+
+ if (nf_strncasecmp(ptcp+lineoff, "Transport:", 10) == 0) {
+ uint oldtcplen = tcplen;
+ pr_debug("hdr: Transport\n");
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ if (!rtsp_mangle_tran(ctinfo, protoff, rtp_exp, rtcp_exp,
+ prtspexp, skb, lineoff, linelen)) {
+#else
+ if (!rtsp_mangle_tran(ctinfo, rtp_exp, rtcp_exp, prtspexp,
+ skb, lineoff, linelen)) {
+#endif
+ pr_debug("hdr: Transport mangle failed");
+ break;
+ }
+ rtp_exp->expectfn = nf_nat_rtsp_expected;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ rtp_exp->saved_addr = saddr;
+#else
+ rtp_exp->saved_ip = saddr;
+#endif
+ rtp_exp->saved_proto.udp.port = htons(prtspexp->loport);
+ rtp_exp->dir = !dir;
+ if (rtcp_exp) {
+ rtcp_exp->expectfn = nf_nat_rtsp_expected;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ rtcp_exp->saved_addr = saddr;
+#else
+ rtcp_exp->saved_ip = saddr;
+#endif
+ rtcp_exp->saved_proto.udp.port = htons(prtspexp->hiport);
+ rtcp_exp->dir = !dir;
+ }
+ get_skb_tcpdata(skb, &ptcp, &tcplen);
+ hdrslen -= (oldtcplen-tcplen);
+ off -= (oldtcplen-tcplen);
+ lineoff -= (oldtcplen-tcplen);
+ linelen -= (oldtcplen-tcplen);
+ pr_debug("rep: len=%u, %.*s", linelen, (int)linelen, ptcp+lineoff);
+ }
+ }
+
+ return NF_ACCEPT;
+}
+
+static unsigned int
+nf_nat_rtsp(struct sk_buff *skb, enum ip_conntrack_info ctinfo,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ unsigned int protoff,
+#endif
+ unsigned int matchoff, unsigned int matchlen,
+ struct ip_ct_rtsp_expect* prtspexp,
+ struct nf_conntrack_expect* rtp_exp,
+ struct nf_conntrack_expect* rtcp_exp)
+{
+ int dir = CTINFO2DIR(ctinfo);
+ int rc = NF_ACCEPT;
+
+ switch (dir) {
+ case IP_CT_DIR_ORIGINAL:
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ rc = help_out(skb, ctinfo, protoff, matchoff, matchlen, prtspexp,
+ rtp_exp, rtcp_exp);
+#else
+ rc = help_out(skb, ctinfo, matchoff, matchlen, prtspexp,
+ rtp_exp, rtcp_exp);
+#endif
+ break;
+ case IP_CT_DIR_REPLY:
+ pr_debug("unmangle ! %u\n", ctinfo);
+ /* XXX: unmangle */
+ rc = NF_ACCEPT;
+ break;
+ }
+ //UNLOCK_BH(&ip_rtsp_lock);
+
+ return rc;
+}
+
+static void nf_nat_rtsp_expected(struct nf_conn* ct, struct nf_conntrack_expect *exp)
+{
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0) || LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ struct nf_nat_range range;
+#else
+ struct nf_nat_ipv4_range range;
+#endif
+
+ /* This must be a fresh one. */
+ BUG_ON(ct->status & IPS_NAT_DONE_MASK);
+
+ /* For DST manip, map port here to where it's expected. */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ range.min_proto = range.max_proto = exp->saved_proto;
+ range.min_addr = range.max_addr = exp->saved_addr;
+#else
+ range.min = range.max = exp->saved_proto;
+ range.min_ip = range.max_ip = exp->saved_ip;
+#endif
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0)
+ range.flags = (NF_NAT_RANGE_MAP_IPS | NF_NAT_RANGE_PROTO_SPECIFIED);
+ nf_nat_setup_info(ct, &range, NF_NAT_MANIP_DST);
+#else
+ range.flags = (IP_NAT_RANGE_MAP_IPS | IP_NAT_RANGE_PROTO_SPECIFIED);
+ nf_nat_setup_info(ct, &range, IP_NAT_MANIP_DST);
+#endif
+
+ /* Change src to where master sends to, but only if the connection
+ * actually came from the same source. */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+ if (nf_inet_addr_cmp(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u3,
+ &ct->master->tuplehash[exp->dir].tuple.src.u3)) {
+ range.min_addr = range.max_addr
+ = ct->master->tuplehash[!exp->dir].tuple.dst.u3;
+#else
+ if (ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u3.ip ==
+ ct->master->tuplehash[exp->dir].tuple.src.u3.ip) {
+ range.min_ip = range.max_ip
+ = ct->master->tuplehash[!exp->dir].tuple.dst.u3.ip;
+#endif
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0)
+ range.flags = NF_NAT_RANGE_MAP_IPS;
+ nf_nat_setup_info(ct, &range, NF_NAT_MANIP_SRC);
+#else
+ range.flags = IP_NAT_RANGE_MAP_IPS;
+ nf_nat_setup_info(ct, &range, IP_NAT_MANIP_SRC);
+#endif
+ }
+}
+
+
+static void __exit fini(void)
+{
+ rcu_assign_pointer(nf_nat_rtsp_hook, NULL);
+ synchronize_net();
+}
+
+static int __init init(void)
+{
+ printk("nf_nat_rtsp v" IP_NF_RTSP_VERSION " loading\n");
+
+ BUG_ON(nf_nat_rtsp_hook);
+ rcu_assign_pointer(nf_nat_rtsp_hook, nf_nat_rtsp);
+
+ if (stunaddr != NULL)
+ extip = in_aton(stunaddr);
+
+ if (destaction != NULL) {
+ if (strcmp(destaction, "auto") == 0)
+ dstact = DSTACT_AUTO;
+
+ if (strcmp(destaction, "strip") == 0)
+ dstact = DSTACT_STRIP;
+
+ if (strcmp(destaction, "none") == 0)
+ dstact = DSTACT_NONE;
+ }
+
+ return 0;
+}
+
+module_init(init);
+module_exit(fini);
diff --git a/net/socket.c b/net/socket.c
index e66e4f3..d28c1fe 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -709,6 +709,18 @@
}
EXPORT_SYMBOL_GPL(__sock_recv_ts_and_drops);
+void __sock_recv_alloc(struct msghdr *msg, struct sock *sk)
+{
+ __u32 rmem_alloc;
+
+ if (sock_flag(sk, SOCK_RXQ_ALLOC)) {
+ rmem_alloc = atomic_read(&sk->sk_rmem_alloc);
+ put_cmsg(msg, SOL_SOCKET, SO_RXQ_ALLOC,
+ sizeof(rmem_alloc), &rmem_alloc);
+ }
+}
+EXPORT_SYMBOL_GPL(__sock_recv_alloc);
+
static inline int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,
size_t size, int flags)
{
