ARM: SoC cleanups for v4.3

A large cleanup branch this release, with a healthy 10k negative line delta.
 
 Most of this is removal of legacy (non-DT) support of shmobile
 platforms. There is also removal of two non-DT platforms on OMAP,
 and the plat-samsung directory is cleaned out by moving most of the
 previously shared-location-but-not-actually-shared files from there to
 the appropriate mach directories instead.
 
 There are other sets of changes in here as well:
 
  - Rob Herring removed use of set_irq_flags under all platforms and
    moved to genirq alternatives
  - A series of timer API conversions to set-state interface
  - ep93xx, nomadik and ux500 cleanups from Linus Walleij
  - __init annotation fixes from Nicolas Pitre
  + a bunch of other changes that all add up to a nice set of cleanups
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABAgAGBQJV16zRAAoJEIwa5zzehBx30OYQAIM2TaHWxDzcK0jOfrPEOyU0
 jhnT3B2/FbIpYbt3UwcDOqJacHzA/syU4UjplCcWWhKYtTucXQIjOxi0BgRq5V3X
 EFrgEbQMLXshhMGquBd4Nl6XhpRrlZcnnY4iFPGf7pR5jQfwQhZCiHEOXCLe4qlz
 m9GorKjEmiSk2ID/PFpyOUx20XiiqkU2MOCsNqNiGwFfmQfpVo0vXtKgxlL6d6q+
 9mrWFFTqgiOBMAU/X1j18U9jpFT6NOe8JcXp3F3tm4Cq5nJ2pTPZcaYWOORD0bGc
 7Os1HRTN9SMNsb8sSvQa1N/Fy2AAFuvGdg8q4oLzgtXJogInRmxE4oGLbffq0As/
 q81mEuWkdHjGPs5oyPNQdP2grYhflNP+M1+fA6QaUG/mDl5RFFcld9nfhCiBeIZW
 oHAHZhz7//BImpFsmNiXOew9fmQaHxQ6Jy0K4YvhqaxwQ0N54ZadUPH47wmmxW5E
 X5IY5Oo7xg3e4EU4/t1nFDTxMG936ZxLVtuq79dRHrl+AT6KVbzdUI4LLyrvEULh
 ETbWIZUAHvE9i2N8GbsfDzc9YlpG/c5SpN8T5dg2R0BQpgE192iG6s5XoGyu80MG
 MbtbEBml0y3tr36Bd9tCpsSrBjzZLUk5WRo6Rd/zWKlRkslV74iacKLvC7C5oa7n
 GYL4xUSPE1RhJxnXezp0
 =acy4
 -----END PGP SIGNATURE-----

Merge tag 'armsoc-cleanup' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc

Pull ARM SoC cleanups from Olof Johansson:
 "A large cleanup branch this release, with a healthy 10k negative line
  delta.

  Most of this is removal of legacy (non-DT) support of shmobile
  platforms.  There is also removal of two non-DT platforms on OMAP, and
  the plat-samsung directory is cleaned out by moving most of the
  previously shared-location-but-not-actually-shared files from there to
  the appropriate mach directories instead.

  There are other sets of changes in here as well:

   - Rob Herring removed use of set_irq_flags under all platforms and
     moved to genirq alternatives

   - a series of timer API conversions to set-state interface

   - ep93xx, nomadik and ux500 cleanups from Linus Walleij

   - __init annotation fixes from Nicolas Pitre

   + a bunch of other changes that all add up to a nice set of cleanups"

* tag 'armsoc-cleanup' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc: (108 commits)
  ARM/fb: ep93xx: switch framebuffer to use modedb only
  ARM: gemini: Setup timer3 as free running timer
  ARM: gemini: Use timer1 for clockevent
  ARM: gemini: Add missing register definitions for gemini timer
  ARM: ep93xx/timer: Migrate to new 'set-state' interface
  ARM: nomadik: push accelerometer down to boards
  ARM: nomadik: move l2x0 setup to device tree
  ARM: nomadik: selectively enable UART0 on boards
  ARM: nomadik: move hog code to use DT hogs
  ARM: shmobile: Fix mismerges
  ARM: ux500: simplify secondary CPU boot
  ARM: SAMSUNG: remove keypad-core header in plat-samsung
  ARM: SAMSUNG: local watchdog-reset header in mach-s3c64xx
  ARM: SAMSUNG: local onenand-core header in mach-s3c64xx
  ARM: SAMSUNG: local irq-uart header in mach-s3c64xx
  ARM: SAMSUNG: local backlight header in mach-s3c64xx
  ARM: SAMSUNG: local ata-core header in mach-s3c64xx
  ARM: SAMSUNG: local regs-usb-hsotg-phy header in mach-s3c64xx
  ARM: SAMSUNG: local spi-core header in mach-s3c24xx
  ARM: SAMSUNG: local nand-core header in mach-s3c24xx
  ...
This commit is contained in:
Linus Torvalds 2015-09-01 12:10:20 -07:00
commit c5fc249862
196 changed files with 1287 additions and 10489 deletions

View file

@ -8,10 +8,10 @@ Required properties:
- interrupts : The interrupt from the HDA controller. - interrupts : The interrupt from the HDA controller.
- clocks : Must contain an entry for each required entry in clock-names. - clocks : Must contain an entry for each required entry in clock-names.
See ../clocks/clock-bindings.txt for details. See ../clocks/clock-bindings.txt for details.
- clock-names : Must include the following entries: hda, hdacodec_2x, hda2hdmi - clock-names : Must include the following entries: hda, hda2hdmi, hda2codec_2x
- resets : Must contain an entry for each entry in reset-names. - resets : Must contain an entry for each entry in reset-names.
See ../reset/reset.txt for details. See ../reset/reset.txt for details.
- reset-names : Must include the following entries: hda, hdacodec_2x, hda2hdmi - reset-names : Must include the following entries: hda, hda2hdmi, hda2codec_2x
Example: Example:
@ -24,7 +24,7 @@ hda@0,70030000 {
<&tegra_car TEGRA124_CLK_HDA2CODEC_2X>; <&tegra_car TEGRA124_CLK_HDA2CODEC_2X>;
clock-names = "hda", "hda2hdmi", "hda2codec_2x"; clock-names = "hda", "hda2hdmi", "hda2codec_2x";
resets = <&tegra_car 125>, /* hda */ resets = <&tegra_car 125>, /* hda */
<&tegra_car 128>; /* hda2hdmi */ <&tegra_car 128>, /* hda2hdmi */
<&tegra_car 111>, /* hda2codec_2x */ <&tegra_car 111>; /* hda2codec_2x */
reset-names = "hda", "hda2hdmi", "hda2codec_2x"; reset-names = "hda", "hda2hdmi", "hda2codec_2x";
}; };

View file

@ -1471,9 +1471,7 @@ F: arch/arm/boot/dts/emev2*
F: arch/arm/boot/dts/r7s* F: arch/arm/boot/dts/r7s*
F: arch/arm/boot/dts/r8a* F: arch/arm/boot/dts/r8a*
F: arch/arm/boot/dts/sh* F: arch/arm/boot/dts/sh*
F: arch/arm/configs/armadillo800eva_defconfig
F: arch/arm/configs/bockw_defconfig F: arch/arm/configs/bockw_defconfig
F: arch/arm/configs/kzm9g_defconfig
F: arch/arm/configs/marzen_defconfig F: arch/arm/configs/marzen_defconfig
F: arch/arm/configs/shmobile_defconfig F: arch/arm/configs/shmobile_defconfig
F: arch/arm/include/debug/renesas-scif.S F: arch/arm/include/debug/renesas-scif.S

View file

@ -268,7 +268,6 @@ config PHYS_OFFSET
depends on !ARM_PATCH_PHYS_VIRT depends on !ARM_PATCH_PHYS_VIRT
default DRAM_BASE if !MMU default DRAM_BASE if !MMU
default 0x00000000 if ARCH_EBSA110 || \ default 0x00000000 if ARCH_EBSA110 || \
EP93XX_SDCE3_SYNC_PHYS_OFFSET || \
ARCH_FOOTBRIDGE || \ ARCH_FOOTBRIDGE || \
ARCH_INTEGRATOR || \ ARCH_INTEGRATOR || \
ARCH_IOP13XX || \ ARCH_IOP13XX || \
@ -277,10 +276,7 @@ config PHYS_OFFSET
default 0x10000000 if ARCH_OMAP1 || ARCH_RPC default 0x10000000 if ARCH_OMAP1 || ARCH_RPC
default 0x20000000 if ARCH_S5PV210 default 0x20000000 if ARCH_S5PV210
default 0x70000000 if REALVIEW_HIGH_PHYS_OFFSET default 0x70000000 if REALVIEW_HIGH_PHYS_OFFSET
default 0xc0000000 if EP93XX_SDCE0_PHYS_OFFSET || ARCH_SA1100 default 0xc0000000 if ARCH_SA1100
default 0xd0000000 if EP93XX_SDCE1_PHYS_OFFSET
default 0xe0000000 if EP93XX_SDCE2_PHYS_OFFSET
default 0xf0000000 if EP93XX_SDCE3_ASYNC_PHYS_OFFSET
help help
Please provide the physical address corresponding to the Please provide the physical address corresponding to the
location of main memory in your system. location of main memory in your system.
@ -418,11 +414,14 @@ config ARCH_EP93XX
bool "EP93xx-based" bool "EP93xx-based"
select ARCH_HAS_HOLES_MEMORYMODEL select ARCH_HAS_HOLES_MEMORYMODEL
select ARCH_REQUIRE_GPIOLIB select ARCH_REQUIRE_GPIOLIB
select ARCH_USES_GETTIMEOFFSET
select ARM_AMBA select ARM_AMBA
select ARM_PATCH_PHYS_VIRT
select ARM_VIC select ARM_VIC
select AUTO_ZRELADDR
select CLKDEV_LOOKUP select CLKDEV_LOOKUP
select CLKSRC_MMIO
select CPU_ARM920T select CPU_ARM920T
select GENERIC_CLOCKEVENTS
help help
This enables support for the Cirrus EP93xx series of CPUs. This enables support for the Cirrus EP93xx series of CPUs.

View file

@ -51,10 +51,6 @@ else
endif endif
endif endif
ifeq ($(CONFIG_ARCH_SHMOBILE_LEGACY),y)
OBJS += head-shmobile.o
endif
# #
# We now have a PIC decompressor implementation. Decompressors running # We now have a PIC decompressor implementation. Decompressors running
# from RAM should not define ZTEXTADDR. Decompressors running directly # from RAM should not define ZTEXTADDR. Decompressors running directly

View file

@ -1,71 +0,0 @@
/*
* The head-file for SH-Mobile ARM platforms
*
* Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
* Simon Horman <horms@verge.net.au>
*
* 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 of the License.
*
* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifdef CONFIG_ZBOOT_ROM
.section ".start", "ax"
/* load board-specific initialization code */
#include <mach/zboot.h>
adr r0, dtb_info
ldmia r0, {r1, r3, r4, r5, r7}
sub r0, r0, r1 @ calculate the delta offset
add r5, r5, r0 @ _edata
ldr lr, [r5, #0] @ check if valid DTB is present
cmp lr, r3
bne 0f
add r9, r7, #31 @ rounded up to a multiple
bic r9, r9, #31 @ ... of 32 bytes
add r6, r9, r5 @ copy from _edata
add r9, r9, r4 @ to MEMORY_START
1: ldmdb r6!, {r0 - r3, r10 - r12, lr}
cmp r6, r5
stmdb r9!, {r0 - r3, r10 - r12, lr}
bhi 1b
/* Success: Zero board ID, pointer to start of memory for atag/dtb */
mov r7, #0
mov r8, r4
b 2f
.align 2
dtb_info:
.word dtb_info
#ifndef __ARMEB__
.word 0xedfe0dd0 @ sig is 0xd00dfeed big endian
#else
.word 0xd00dfeed
#endif
.word MEMORY_START
.word _edata
.word 0x4000 @ maximum DTB size
0:
/* Failure: Zero board ID, NULL atag/dtb */
mov r7, #0
mov r8, #0 @ pass null pointer as atag
2 :
#endif /* CONFIG_ZBOOT_ROM */

View file

@ -501,11 +501,8 @@ dtb-$(CONFIG_ARCH_S5PV210) += \
s5pv210-smdkv210.dtb \ s5pv210-smdkv210.dtb \
s5pv210-torbreck.dtb s5pv210-torbreck.dtb
dtb-$(CONFIG_ARCH_SHMOBILE_LEGACY) += \ dtb-$(CONFIG_ARCH_SHMOBILE_LEGACY) += \
r8a7740-armadillo800eva.dtb \
r8a7778-bockw.dtb \ r8a7778-bockw.dtb \
r8a7778-bockw-reference.dtb \ r8a7778-bockw-reference.dtb
r8a7779-marzen.dtb \
sh73a0-kzm9g.dtb
dtb-$(CONFIG_ARCH_SHMOBILE_MULTI) += \ dtb-$(CONFIG_ARCH_SHMOBILE_MULTI) += \
emev2-kzm9d.dtb \ emev2-kzm9d.dtb \
r7s72100-genmai.dtb \ r7s72100-genmai.dtb \

View file

@ -17,12 +17,22 @@
}; };
aliases { aliases {
serial0 = &uart0;
serial1 = &uart1; serial1 = &uart1;
stmpe-i2c0 = &stmpe0; stmpe-i2c0 = &stmpe0;
stmpe-i2c1 = &stmpe1; stmpe-i2c1 = &stmpe1;
}; };
pinctrl { pinctrl {
uart0 {
uart0_nhk_mode: uart0_mux {
u0_default_mux {
function = "u0";
groups = "u0txrx_a_1", "u0ctsrts_a_1";
};
};
};
stmpe2401_1 { stmpe2401_1 {
stmpe2401_1_nhk_mode: stmpe2401_1_nhk { stmpe2401_1_nhk_mode: stmpe2401_1_nhk {
nhk_cfg1 { nhk_cfg1 {
@ -73,6 +83,11 @@
}; };
i2c0 { i2c0 {
lis3lv02dl@1d {
/* Accelerometer */
compatible = "st,lis3lv02dl-accel";
reg = <0x1d>;
};
stmpe0: stmpe2401@43 { stmpe0: stmpe2401@43 {
compatible = "st,stmpe2401"; compatible = "st,stmpe2401";
reg = <0x43>; reg = <0x43>;
@ -131,22 +146,30 @@
#gpio-cells = <2>; #gpio-cells = <2>;
interrupt-controller; interrupt-controller;
#interrupt-cells = <2>; #interrupt-cells = <2>;
/*
* This will turn off SATA so that MMC/SD
* can thrive
*/
mmcsd-gpio {
gpio-hog;
gpios = <2 0x0>;
output-low;
line-name = "SATA EN";
};
}; };
}; };
}; };
amba { amba {
/* Activate RX/TX and CTS/RTS on UART 0 */
uart0: uart@101fd000 {
pinctrl-names = "default";
pinctrl-0 = <&uart0_nhk_mode>;
status = "okay";
};
mmcsd: sdi@101f6000 { mmcsd: sdi@101f6000 {
cd-gpios = <&stmpe_gpio44 7 GPIO_ACTIVE_LOW>; cd-gpios = <&stmpe_gpio44 7 GPIO_ACTIVE_LOW>;
wp-gpios = <&stmpe_gpio44 18 GPIO_ACTIVE_HIGH>; wp-gpios = <&stmpe_gpio44 18 GPIO_ACTIVE_HIGH>;
}; };
}; };
/* Custom board node with GPIO pins to active etc */
usb-s8815 {
/* This will turn off SATA so that MMC/SD can thrive */
mmcsd-gpio {
gpios = <&stmpe_gpio44 2 0x1>;
};
};
}; };

View file

@ -16,9 +16,20 @@
}; };
aliases { aliases {
serial0 = &uart0;
serial1 = &uart1; serial1 = &uart1;
}; };
gpio3: gpio@101e7000 {
/* This hog will bias the MMC/SD card detect line */
mmcsd-gpio {
gpio-hog;
gpios = <16 0x0>;
output-low;
line-name = "card detect bias";
};
};
src@101e0000 { src@101e0000 {
/* These chrystal drivers are not used on this board */ /* These chrystal drivers are not used on this board */
disable-sxtalo; disable-sxtalo;
@ -30,6 +41,15 @@
pinctrl-names = "default"; pinctrl-names = "default";
pinctrl-0 = <&cd_default_mode>; pinctrl-0 = <&cd_default_mode>;
uart0 {
/* Only use RX/TX pins */
uart0_s8815_mode: uart0_mux {
u0_default_mux {
function = "u0";
groups = "u0txrx_a_1";
};
};
};
mmcsd-cd { mmcsd-cd {
cd_default_mode: cd_default { cd_default_mode: cd_default {
cd_default_cfg1 { cd_default_cfg1 {
@ -85,6 +105,14 @@
}; };
}; };
i2c1 {
lis3lv02dl@1d {
/* Accelerometer */
compatible = "st,lis3lv02dl-accel";
reg = <0x1d>;
};
};
/* GPIO I2C connected to the USB portions of the STw4811 only */ /* GPIO I2C connected to the USB portions of the STw4811 only */
gpio-i2c { gpio-i2c {
compatible = "i2c-gpio"; compatible = "i2c-gpio";
@ -102,21 +130,19 @@
}; };
/* Configure card detect for the uSD slot */
amba { amba {
/* Activate RXTX on UART 0 */
uart0: uart@101fd000 {
pinctrl-names = "default";
pinctrl-0 = <&uart0_s8815_mode>;
status = "okay";
};
/* Configure card detect for the uSD slot */
mmcsd: sdi@101f6000 { mmcsd: sdi@101f6000 {
cd-gpios = <&gpio3 15 GPIO_ACTIVE_LOW>; cd-gpios = <&gpio3 15 GPIO_ACTIVE_LOW>;
}; };
}; };
/* Custom board node with GPIO pins to active etc */
usb-s8815 {
/* This will bias the MMC/SD card detect line */
mmcsd-gpio {
gpios = <&gpio3 16 0x1>;
};
};
/* The user LED on the board is set up to be used for heartbeat */ /* The user LED on the board is set up to be used for heartbeat */
leds { leds {
compatible = "gpio-leds"; compatible = "gpio-leds";

View file

@ -21,6 +21,13 @@
interrupts = <30>; interrupts = <30>;
cache-unified; cache-unified;
cache-level = <2>; cache-level = <2>;
cache-size = <131072>;
cache-sets = <512>;
cache-line-size = <32>;
/* At full speed latency must be >=2 */
arm,tag-latency = <2>;
arm,data-latency = <2 2>;
arm,dirty-latency = <2>;
}; };
mtu0: mtu@101e2000 { mtu0: mtu@101e2000 {
@ -97,14 +104,6 @@
pinctrl { pinctrl {
compatible = "stericsson,stn8815-pinctrl"; compatible = "stericsson,stn8815-pinctrl";
/* Pin configurations */ /* Pin configurations */
uart0 {
uart0_default_mux: uart0_mux {
u0_default_mux {
function = "u0";
groups = "u0_a_1";
};
};
};
uart1 { uart1 {
uart1_default_mux: uart1_mux { uart1_default_mux: uart1_mux {
u1_default_mux { u1_default_mux {
@ -721,11 +720,6 @@
compatible = "st,stw5095"; compatible = "st,stw5095";
reg = <0x1a>; reg = <0x1a>;
}; };
lis3lv02dl@1d {
/* Accelerometer */
compatible = "st,lis3lv02dl-accel";
reg = <0x1d>;
};
}; };
amba { amba {
@ -755,8 +749,6 @@
interrupts = <12>; interrupts = <12>;
clocks = <&uart0clk>, <&pclkuart0>; clocks = <&uart0clk>, <&pclkuart0>;
clock-names = "uartclk", "apb_pclk"; clock-names = "uartclk", "apb_pclk";
pinctrl-names = "default";
pinctrl-0 = <&uart0_default_mux>;
status = "disabled"; status = "disabled";
}; };

View file

@ -91,7 +91,7 @@ void it8152_init_irq(void)
for (irq = IT8152_IRQ(0); irq <= IT8152_LAST_IRQ; irq++) { for (irq = IT8152_IRQ(0); irq <= IT8152_LAST_IRQ; irq++) {
irq_set_chip_and_handler(irq, &it8152_irq_chip, irq_set_chip_and_handler(irq, &it8152_irq_chip,
handle_level_irq); handle_level_irq);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); irq_clear_status_flags(irq, IRQ_NOREQUEST | IRQ_NOPROBE);
} }
} }

View file

@ -138,9 +138,9 @@ static struct locomo_dev_info locomo_devices[] = {
}, },
}; };
static void locomo_handler(unsigned int irq, struct irq_desc *desc) static void locomo_handler(unsigned int __irq, struct irq_desc *desc)
{ {
struct locomo *lchip = irq_get_chip_data(irq); struct locomo *lchip = irq_desc_get_chip_data(desc);
int req, i; int req, i;
/* Acknowledge the parent IRQ */ /* Acknowledge the parent IRQ */
@ -150,6 +150,8 @@ static void locomo_handler(unsigned int irq, struct irq_desc *desc)
req = locomo_readl(lchip->base + LOCOMO_ICR) & 0x0f00; req = locomo_readl(lchip->base + LOCOMO_ICR) & 0x0f00;
if (req) { if (req) {
unsigned int irq;
/* generate the next interrupt(s) */ /* generate the next interrupt(s) */
irq = lchip->irq_base; irq = lchip->irq_base;
for (i = 0; i <= 3; i++, irq++) { for (i = 0; i <= 3; i++, irq++) {
@ -205,7 +207,7 @@ static void locomo_setup_irq(struct locomo *lchip)
for ( ; irq <= lchip->irq_base + 3; irq++) { for ( ; irq <= lchip->irq_base + 3; irq++) {
irq_set_chip_and_handler(irq, &locomo_chip, handle_level_irq); irq_set_chip_and_handler(irq, &locomo_chip, handle_level_irq);
irq_set_chip_data(irq, lchip); irq_set_chip_data(irq, lchip);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); irq_clear_status_flags(irq, IRQ_NOREQUEST | IRQ_NOPROBE);
} }
} }
@ -475,8 +477,7 @@ static void __locomo_remove(struct locomo *lchip)
device_for_each_child(lchip->dev, NULL, locomo_remove_child); device_for_each_child(lchip->dev, NULL, locomo_remove_child);
if (lchip->irq != NO_IRQ) { if (lchip->irq != NO_IRQ) {
irq_set_chained_handler(lchip->irq, NULL); irq_set_chained_handler_and_data(lchip->irq, NULL, NULL);
irq_set_handler_data(lchip->irq, NULL);
} }
iounmap(lchip->base); iounmap(lchip->base);

View file

@ -197,10 +197,11 @@ static struct sa1111_dev_info sa1111_devices[] = {
* will call us again if there are more interrupts to process. * will call us again if there are more interrupts to process.
*/ */
static void static void
sa1111_irq_handler(unsigned int irq, struct irq_desc *desc) sa1111_irq_handler(unsigned int __irq, struct irq_desc *desc)
{ {
unsigned int irq = irq_desc_get_irq(desc);
unsigned int stat0, stat1, i; unsigned int stat0, stat1, i;
struct sa1111 *sachip = irq_get_handler_data(irq); struct sa1111 *sachip = irq_desc_get_handler_data(desc);
void __iomem *mapbase = sachip->base + SA1111_INTC; void __iomem *mapbase = sachip->base + SA1111_INTC;
stat0 = sa1111_readl(mapbase + SA1111_INTSTATCLR0); stat0 = sa1111_readl(mapbase + SA1111_INTSTATCLR0);
@ -486,7 +487,7 @@ static int sa1111_setup_irq(struct sa1111 *sachip, unsigned irq_base)
irq_set_chip_and_handler(irq, &sa1111_low_chip, irq_set_chip_and_handler(irq, &sa1111_low_chip,
handle_edge_irq); handle_edge_irq);
irq_set_chip_data(irq, sachip); irq_set_chip_data(irq, sachip);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); irq_clear_status_flags(irq, IRQ_NOREQUEST | IRQ_NOPROBE);
} }
for (i = AUDXMTDMADONEA; i <= IRQ_S1_BVD1_STSCHG; i++) { for (i = AUDXMTDMADONEA; i <= IRQ_S1_BVD1_STSCHG; i++) {
@ -494,7 +495,7 @@ static int sa1111_setup_irq(struct sa1111 *sachip, unsigned irq_base)
irq_set_chip_and_handler(irq, &sa1111_high_chip, irq_set_chip_and_handler(irq, &sa1111_high_chip,
handle_edge_irq); handle_edge_irq);
irq_set_chip_data(irq, sachip); irq_set_chip_data(irq, sachip);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); irq_clear_status_flags(irq, IRQ_NOREQUEST | IRQ_NOPROBE);
} }
/* /*

View file

@ -1,162 +0,0 @@
CONFIG_EXPERIMENTAL=y
CONFIG_SYSVIPC=y
CONFIG_IKCONFIG=y
CONFIG_IKCONFIG_PROC=y
CONFIG_LOG_BUF_SHIFT=16
# CONFIG_UTS_NS is not set
# CONFIG_IPC_NS is not set
# CONFIG_PID_NS is not set
CONFIG_CC_OPTIMIZE_FOR_SIZE=y
CONFIG_PERF_EVENTS=y
CONFIG_SLAB=y
CONFIG_MODULES=y
CONFIG_MODULE_UNLOAD=y
CONFIG_MODULE_FORCE_UNLOAD=y
# CONFIG_BLK_DEV_BSG is not set
# CONFIG_IOSCHED_DEADLINE is not set
# CONFIG_IOSCHED_CFQ is not set
CONFIG_ARCH_SHMOBILE_LEGACY=y
CONFIG_ARCH_R8A7740=y
CONFIG_MACH_ARMADILLO800EVA=y
# CONFIG_SH_TIMER_TMU is not set
CONFIG_ARM_THUMB=y
CONFIG_CACHE_L2X0=y
CONFIG_ARM_ERRATA_430973=y
CONFIG_ARM_ERRATA_458693=y
CONFIG_ARM_ERRATA_460075=y
CONFIG_PL310_ERRATA_588369=y
CONFIG_ARM_ERRATA_720789=y
CONFIG_PL310_ERRATA_727915=y
CONFIG_ARM_ERRATA_743622=y
CONFIG_ARM_ERRATA_751472=y
CONFIG_PL310_ERRATA_753970=y
CONFIG_ARM_ERRATA_754322=y
CONFIG_PL310_ERRATA_769419=y
CONFIG_ARM_ERRATA_775420=y
CONFIG_AEABI=y
# CONFIG_OABI_COMPAT is not set
CONFIG_FORCE_MAX_ZONEORDER=13
CONFIG_ZBOOT_ROM_TEXT=0x0
CONFIG_ZBOOT_ROM_BSS=0x0
CONFIG_ARM_APPENDED_DTB=y
CONFIG_KEXEC=y
CONFIG_VFP=y
CONFIG_NEON=y
# CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS is not set
CONFIG_PM=y
CONFIG_NET=y
CONFIG_PACKET=y
CONFIG_UNIX=y
CONFIG_INET=y
CONFIG_IP_PNP=y
CONFIG_IP_PNP_DHCP=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_INET_LRO is not set
# CONFIG_INET_DIAG is not set
# CONFIG_IPV6 is not set
# CONFIG_WIRELESS is not set
CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
CONFIG_DEVTMPFS=y
CONFIG_DEVTMPFS_MOUNT=y
CONFIG_SCSI=y
CONFIG_BLK_DEV_SD=y
CONFIG_MD=y
CONFIG_BLK_DEV_DM=y
CONFIG_NETDEVICES=y
# CONFIG_NET_VENDOR_BROADCOM is not set
# CONFIG_NET_VENDOR_CHELSIO is not set
# CONFIG_NET_VENDOR_CIRRUS is not set
# CONFIG_NET_VENDOR_FARADAY 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_SH_ETH=y
# CONFIG_NET_VENDOR_SEEQ is not set
# CONFIG_NET_VENDOR_SMSC is not set
# CONFIG_NET_VENDOR_STMICRO is not set
# CONFIG_WLAN is not set
# CONFIG_INPUT_MOUSEDEV_PSAUX is not set
CONFIG_INPUT_EVDEV=y
# CONFIG_KEYBOARD_ATKBD is not set
CONFIG_KEYBOARD_GPIO=y
# CONFIG_INPUT_MOUSE is not set
CONFIG_INPUT_TOUCHSCREEN=y
CONFIG_TOUCHSCREEN_ST1232=y
# CONFIG_SERIO is not set
# CONFIG_LEGACY_PTYS is not set
CONFIG_SERIAL_SH_SCI=y
CONFIG_SERIAL_SH_SCI_NR_UARTS=9
CONFIG_SERIAL_SH_SCI_CONSOLE=y
# CONFIG_HW_RANDOM is not set
CONFIG_I2C=y
CONFIG_I2C_GPIO=y
CONFIG_I2C_SH_MOBILE=y
# CONFIG_HWMON is not set
CONFIG_REGULATOR=y
CONFIG_REGULATOR_GPIO=y
CONFIG_MEDIA_SUPPORT=y
CONFIG_VIDEO_DEV=y
CONFIG_MEDIA_CAMERA_SUPPORT=y
CONFIG_V4L_PLATFORM_DRIVERS=y
CONFIG_SOC_CAMERA=y
CONFIG_SOC_CAMERA_MT9T112=y
CONFIG_VIDEO_SH_MOBILE_CEU=y
CONFIG_FB=y
CONFIG_FB_SH_MOBILE_LCDC=y
CONFIG_FB_SH_MOBILE_HDMI=y
CONFIG_LCD_CLASS_DEVICE=y
CONFIG_BACKLIGHT_PWM=y
CONFIG_FRAMEBUFFER_CONSOLE=y
CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
CONFIG_LOGO=y
# CONFIG_LOGO_LINUX_MONO is not set
# CONFIG_LOGO_LINUX_VGA16 is not set
# CONFIG_SND_SUPPORT_OLD_API is not set
# CONFIG_SND_VERBOSE_PROCFS is not set
# CONFIG_SND_DRIVERS is not set
# CONFIG_SND_ARM is not set
CONFIG_SND_SOC_SH4_FSI=y
# CONFIG_HID_SUPPORT is not set
CONFIG_USB=y
CONFIG_USB_RENESAS_USBHS=y
CONFIG_USB_GADGET=y
CONFIG_USB_RENESAS_USBHS_UDC=y
CONFIG_USB_ETH=m
CONFIG_MMC=y
CONFIG_MMC_SDHI=y
CONFIG_MMC_SH_MMCIF=y
CONFIG_NEW_LEDS=y
CONFIG_LEDS_CLASS=y
CONFIG_LEDS_GPIO=y
CONFIG_RTC_CLASS=y
CONFIG_RTC_DRV_S35390A=y
CONFIG_DMADEVICES=y
CONFIG_SH_DMAE=y
CONFIG_UIO=y
CONFIG_UIO_PDRV_GENIRQ=y
CONFIG_PWM=y
CONFIG_PWM_RENESAS_TPU=y
# CONFIG_DNOTIFY is not set
CONFIG_MSDOS_FS=y
CONFIG_VFAT_FS=y
CONFIG_TMPFS=y
# CONFIG_MISC_FILESYSTEMS is not set
CONFIG_NFS_FS=y
CONFIG_NFS_V3_ACL=y
CONFIG_NFS_V4=y
CONFIG_NFS_V4_1=y
CONFIG_ROOT_NFS=y
CONFIG_NLS_CODEPAGE_437=y
CONFIG_NLS_ISO8859_1=y
# CONFIG_ENABLE_WARN_DEPRECATED is not set
# CONFIG_ENABLE_MUST_CHECK is not set
# CONFIG_ARM_UNWIND is not set
CONFIG_CRYPTO=y
CONFIG_CRYPTO_CBC=y
CONFIG_CRYPTO_MD5=y
CONFIG_CRYPTO_DES=y
CONFIG_CRYPTO_ANSI_CPRNG=y
CONFIG_XZ_DEC=y

View file

@ -1,154 +0,0 @@
# CONFIG_ARM_PATCH_PHYS_VIRT is not set
CONFIG_EXPERIMENTAL=y
# CONFIG_LOCALVERSION_AUTO is not set
CONFIG_SYSVIPC=y
CONFIG_IKCONFIG=y
CONFIG_IKCONFIG_PROC=y
CONFIG_LOG_BUF_SHIFT=16
CONFIG_NAMESPACES=y
# CONFIG_UTS_NS is not set
# CONFIG_IPC_NS is not set
# CONFIG_USER_NS is not set
# CONFIG_PID_NS is not set
# CONFIG_NET_NS is not set
CONFIG_CC_OPTIMIZE_FOR_SIZE=y
CONFIG_SYSCTL_SYSCALL=y
CONFIG_EMBEDDED=y
CONFIG_PERF_EVENTS=y
CONFIG_SLAB=y
CONFIG_MODULES=y
CONFIG_MODULE_FORCE_LOAD=y
CONFIG_MODULE_UNLOAD=y
# CONFIG_BLK_DEV_BSG is not set
# CONFIG_IOSCHED_DEADLINE is not set
# CONFIG_IOSCHED_CFQ is not set
CONFIG_ARCH_SHMOBILE_LEGACY=y
CONFIG_ARCH_SH73A0=y
CONFIG_MACH_KZM9G=y
CONFIG_MEMORY_START=0x41000000
CONFIG_MEMORY_SIZE=0x1f000000
CONFIG_ARM_ERRATA_743622=y
CONFIG_ARM_ERRATA_754322=y
CONFIG_NO_HZ=y
CONFIG_HIGH_RES_TIMERS=y
CONFIG_SMP=y
CONFIG_SCHED_MC=y
CONFIG_AEABI=y
# CONFIG_OABI_COMPAT is not set
CONFIG_HIGHMEM=y
CONFIG_ZBOOT_ROM_TEXT=0x0
CONFIG_ZBOOT_ROM_BSS=0x0
CONFIG_ARM_APPENDED_DTB=y
CONFIG_KEXEC=y
CONFIG_VFP=y
CONFIG_NEON=y
# CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS is not set
CONFIG_PM=y
CONFIG_NET=y
CONFIG_PACKET=y
CONFIG_UNIX=y
CONFIG_INET=y
CONFIG_IP_PNP=y
CONFIG_IP_PNP_DHCP=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_INET_LRO is not set
# CONFIG_INET_DIAG is not set
# CONFIG_IPV6 is not set
CONFIG_IRDA=y
CONFIG_SH_IRDA=y
# CONFIG_WIRELESS is not set
CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
CONFIG_DEVTMPFS=y
CONFIG_DEVTMPFS_MOUNT=y
CONFIG_SCSI=y
CONFIG_BLK_DEV_SD=y
CONFIG_NETDEVICES=y
CONFIG_SMSC911X=y
# CONFIG_WLAN is not set
CONFIG_INPUT_SPARSEKMAP=y
# CONFIG_INPUT_MOUSEDEV is not set
CONFIG_INPUT_EVDEV=y
# CONFIG_KEYBOARD_ATKBD is not set
CONFIG_KEYBOARD_GPIO=y
# CONFIG_INPUT_MOUSE is not set
CONFIG_INPUT_TOUCHSCREEN=y
CONFIG_TOUCHSCREEN_ST1232=y
CONFIG_INPUT_MISC=y
CONFIG_INPUT_ADXL34X=y
# CONFIG_LEGACY_PTYS is not set
CONFIG_SERIAL_SH_SCI=y
CONFIG_SERIAL_SH_SCI_NR_UARTS=9
CONFIG_SERIAL_SH_SCI_CONSOLE=y
# CONFIG_HW_RANDOM is not set
CONFIG_I2C_CHARDEV=y
CONFIG_I2C_SH_MOBILE=y
CONFIG_GPIO_PCF857X=y
# CONFIG_HWMON is not set
CONFIG_MFD_AS3711=y
CONFIG_REGULATOR=y
CONFIG_REGULATOR_AS3711=y
CONFIG_FB=y
CONFIG_FB_SH_MOBILE_LCDC=y
CONFIG_BACKLIGHT_AS3711=y
CONFIG_FRAMEBUFFER_CONSOLE=y
CONFIG_LOGO=y
CONFIG_FB_SH_MOBILE_MERAM=y
CONFIG_SOUND=y
CONFIG_SND=y
# CONFIG_SND_SUPPORT_OLD_API is not set
# CONFIG_SND_VERBOSE_PROCFS is not set
# CONFIG_SND_DRIVERS is not set
# CONFIG_SND_ARM is not set
# CONFIG_SND_USB is not set
CONFIG_SND_SOC=y
CONFIG_SND_SOC_SH4_FSI=y
# CONFIG_HID_SUPPORT is not set
CONFIG_USB=y
CONFIG_USB_R8A66597_HCD=y
CONFIG_USB_RENESAS_USBHS=y
CONFIG_USB_STORAGE=y
CONFIG_USB_GADGET=y
CONFIG_USB_RENESAS_USBHS_UDC=y
CONFIG_USB_ETH=m
CONFIG_USB_MASS_STORAGE=m
CONFIG_MMC=y
# CONFIG_MMC_BLOCK_BOUNCE is not set
CONFIG_MMC_SDHI=y
CONFIG_MMC_SH_MMCIF=y
CONFIG_NEW_LEDS=y
CONFIG_LEDS_CLASS=y
CONFIG_LEDS_GPIO=y
CONFIG_RTC_CLASS=y
CONFIG_RTC_DRV_RS5C372=y
CONFIG_DMADEVICES=y
CONFIG_SH_DMAE=y
CONFIG_ASYNC_TX_DMA=y
CONFIG_STAGING=y
CONFIG_IIO=y
CONFIG_AK8975=y
# CONFIG_DNOTIFY is not set
CONFIG_VFAT_FS=y
CONFIG_TMPFS=y
# CONFIG_MISC_FILESYSTEMS is not set
CONFIG_NFS_FS=y
CONFIG_NFS_V3=y
CONFIG_NFS_V3_ACL=y
CONFIG_NFS_V4=y
CONFIG_NFS_V4_1=y
CONFIG_ROOT_NFS=y
CONFIG_NLS_CODEPAGE_437=y
CONFIG_NLS_ISO8859_1=y
# CONFIG_ENABLE_WARN_DEPRECATED is not set
# CONFIG_ENABLE_MUST_CHECK is not set
# CONFIG_SCHED_DEBUG is not set
# CONFIG_DEBUG_PREEMPT is not set
# CONFIG_DEBUG_BUGVERBOSE is not set
# CONFIG_FTRACE is not set
# CONFIG_ARM_UNWIND is not set
CONFIG_CRYPTO=y
CONFIG_CRYPTO_CBC=y
CONFIG_CRYPTO_MD5=y
CONFIG_CRYPTO_DES=y
CONFIG_CRC16=y

View file

@ -140,7 +140,7 @@ int __init arch_probe_nr_irqs(void)
static bool migrate_one_irq(struct irq_desc *desc) static bool migrate_one_irq(struct irq_desc *desc)
{ {
struct irq_data *d = irq_desc_get_irq_data(desc); struct irq_data *d = irq_desc_get_irq_data(desc);
const struct cpumask *affinity = d->affinity; const struct cpumask *affinity = irq_data_get_affinity_mask(d);
struct irq_chip *c; struct irq_chip *c;
bool ret = false; bool ret = false;
@ -160,7 +160,7 @@ static bool migrate_one_irq(struct irq_desc *desc)
if (!c->irq_set_affinity) if (!c->irq_set_affinity)
pr_debug("IRQ%u: unable to set affinity\n", d->irq); pr_debug("IRQ%u: unable to set affinity\n", d->irq);
else if (c->irq_set_affinity(d, affinity, false) == IRQ_SET_MASK_OK && ret) else if (c->irq_set_affinity(d, affinity, false) == IRQ_SET_MASK_OK && ret)
cpumask_copy(d->affinity, affinity); cpumask_copy(irq_data_get_affinity_mask(d), affinity);
return ret; return ret;
} }

View file

@ -278,7 +278,7 @@ out_put_node:
return err; return err;
} }
static const struct of_device_id psci_of_match[] __initconst = { static const struct of_device_id const psci_of_match[] __initconst = {
{ .compatible = "arm,psci", .data = psci_0_1_init}, { .compatible = "arm,psci", .data = psci_0_1_init},
{ .compatible = "arm,psci-0.2", .data = psci_0_2_init}, { .compatible = "arm,psci-0.2", .data = psci_0_2_init},
{}, {},

View file

@ -36,29 +36,30 @@ static DEFINE_PER_CPU(bool, percpu_setup_called);
static struct clock_event_device __percpu *twd_evt; static struct clock_event_device __percpu *twd_evt;
static int twd_ppi; static int twd_ppi;
static void twd_set_mode(enum clock_event_mode mode, static int twd_shutdown(struct clock_event_device *clk)
struct clock_event_device *clk)
{ {
unsigned long ctrl; writel_relaxed(0, twd_base + TWD_TIMER_CONTROL);
return 0;
}
switch (mode) { static int twd_set_oneshot(struct clock_event_device *clk)
case CLOCK_EVT_MODE_PERIODIC: {
ctrl = TWD_TIMER_CONTROL_ENABLE | TWD_TIMER_CONTROL_IT_ENABLE /* period set, and timer enabled in 'next_event' hook */
| TWD_TIMER_CONTROL_PERIODIC; writel_relaxed(TWD_TIMER_CONTROL_IT_ENABLE | TWD_TIMER_CONTROL_ONESHOT,
writel_relaxed(DIV_ROUND_CLOSEST(twd_timer_rate, HZ), twd_base + TWD_TIMER_CONTROL);
twd_base + TWD_TIMER_LOAD); return 0;
break; }
case CLOCK_EVT_MODE_ONESHOT:
/* period set, and timer enabled in 'next_event' hook */
ctrl = TWD_TIMER_CONTROL_IT_ENABLE | TWD_TIMER_CONTROL_ONESHOT;
break;
case CLOCK_EVT_MODE_UNUSED:
case CLOCK_EVT_MODE_SHUTDOWN:
default:
ctrl = 0;
}
static int twd_set_periodic(struct clock_event_device *clk)
{
unsigned long ctrl = TWD_TIMER_CONTROL_ENABLE |
TWD_TIMER_CONTROL_IT_ENABLE |
TWD_TIMER_CONTROL_PERIODIC;
writel_relaxed(DIV_ROUND_CLOSEST(twd_timer_rate, HZ),
twd_base + TWD_TIMER_LOAD);
writel_relaxed(ctrl, twd_base + TWD_TIMER_CONTROL); writel_relaxed(ctrl, twd_base + TWD_TIMER_CONTROL);
return 0;
} }
static int twd_set_next_event(unsigned long evt, static int twd_set_next_event(unsigned long evt,
@ -94,7 +95,7 @@ static void twd_timer_stop(void)
{ {
struct clock_event_device *clk = raw_cpu_ptr(twd_evt); struct clock_event_device *clk = raw_cpu_ptr(twd_evt);
twd_set_mode(CLOCK_EVT_MODE_UNUSED, clk); twd_shutdown(clk);
disable_percpu_irq(clk->irq); disable_percpu_irq(clk->irq);
} }
@ -296,7 +297,10 @@ static void twd_timer_setup(void)
clk->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT | clk->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT |
CLOCK_EVT_FEAT_C3STOP; CLOCK_EVT_FEAT_C3STOP;
clk->rating = 350; clk->rating = 350;
clk->set_mode = twd_set_mode; clk->set_state_shutdown = twd_shutdown;
clk->set_state_periodic = twd_set_periodic;
clk->set_state_oneshot = twd_set_oneshot;
clk->tick_resume = twd_shutdown;
clk->set_next_event = twd_set_next_event; clk->set_next_event = twd_set_next_event;
clk->irq = twd_ppi; clk->irq = twd_ppi;
clk->cpumask = cpumask_of(cpu); clk->cpumask = cpumask_of(cpu);

View file

@ -37,7 +37,7 @@ static void __init at91rm9200_dt_device_init(void)
at91rm9200_pm_init(); at91rm9200_pm_init();
} }
static const char *at91rm9200_dt_board_compat[] __initconst = { static const char *const at91rm9200_dt_board_compat[] __initconst = {
"atmel,at91rm9200", "atmel,at91rm9200",
NULL NULL
}; };

View file

@ -72,7 +72,7 @@ static void __init at91sam9_dt_device_init(void)
at91sam9260_pm_init(); at91sam9260_pm_init();
} }
static const char *at91_dt_board_compat[] __initconst = { static const char *const at91_dt_board_compat[] __initconst = {
"atmel,at91sam9", "atmel,at91sam9",
NULL NULL
}; };
@ -89,7 +89,7 @@ static void __init at91sam9g45_dt_device_init(void)
at91sam9g45_pm_init(); at91sam9g45_pm_init();
} }
static const char *at91sam9g45_board_compat[] __initconst = { static const char *const at91sam9g45_board_compat[] __initconst = {
"atmel,at91sam9g45", "atmel,at91sam9g45",
NULL NULL
}; };
@ -106,7 +106,7 @@ static void __init at91sam9x5_dt_device_init(void)
at91sam9x5_pm_init(); at91sam9x5_pm_init();
} }
static const char *at91sam9x5_board_compat[] __initconst = { static const char *const at91sam9x5_board_compat[] __initconst = {
"atmel,at91sam9x5", "atmel,at91sam9x5",
"atmel,at91sam9n12", "atmel,at91sam9n12",
NULL NULL

View file

@ -311,7 +311,7 @@ static void at91sam9_sdram_standby(void)
at91_ramc_write(1, AT91_SDRAMC_LPR, saved_lpr1); at91_ramc_write(1, AT91_SDRAMC_LPR, saved_lpr1);
} }
static const struct of_device_id ramc_ids[] __initconst = { static const struct of_device_id const ramc_ids[] __initconst = {
{ .compatible = "atmel,at91rm9200-sdramc", .data = at91rm9200_standby }, { .compatible = "atmel,at91rm9200-sdramc", .data = at91rm9200_standby },
{ .compatible = "atmel,at91sam9260-sdramc", .data = at91sam9_sdram_standby }, { .compatible = "atmel,at91sam9260-sdramc", .data = at91sam9_sdram_standby },
{ .compatible = "atmel,at91sam9g45-ddramc", .data = at91_ddr_standby }, { .compatible = "atmel,at91sam9g45-ddramc", .data = at91_ddr_standby },

View file

@ -52,7 +52,7 @@ static void __init sama5_dt_device_init(void)
at91sam9x5_pm_init(); at91sam9x5_pm_init();
} }
static const char *sama5_dt_board_compat[] __initconst = { static const char *const sama5_dt_board_compat[] __initconst = {
"atmel,sama5", "atmel,sama5",
NULL NULL
}; };
@ -63,7 +63,7 @@ DT_MACHINE_START(sama5_dt, "Atmel SAMA5")
.dt_compat = sama5_dt_board_compat, .dt_compat = sama5_dt_board_compat,
MACHINE_END MACHINE_END
static const char *sama5_alt_dt_board_compat[] __initconst = { static const char *const sama5_alt_dt_board_compat[] __initconst = {
"atmel,sama5d4", "atmel,sama5d4",
NULL NULL
}; };

View file

@ -39,10 +39,8 @@ obj-$(CONFIG_ARCH_BCM_5301X) += bcm_5301x.o
# BCM63XXx # BCM63XXx
ifeq ($(CONFIG_ARCH_BCM_63XX),y) ifeq ($(CONFIG_ARCH_BCM_63XX),y)
CFLAGS_bcm63xx_headsmp.o += -march=armv7-a
obj-y += bcm63xx.o obj-y += bcm63xx.o
obj-$(CONFIG_SMP) += bcm63xx_smp.o bcm63xx_headsmp.o \ obj-$(CONFIG_SMP) += bcm63xx_smp.o bcm63xx_pmb.o
bcm63xx_pmb.o
endif endif
ifeq ($(CONFIG_ARCH_BRCMSTB),y) ifeq ($(CONFIG_ARCH_BRCMSTB),y)

View file

@ -1,23 +0,0 @@
/*
* Copyright (C) 2015, Broadcom Corporation
* All Rights Reserved
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include <linux/linkage.h>
#include <linux/init.h>
#include <asm/assembler.h>
ENTRY(bcm63138_secondary_startup)
ARM_BE8(setend be)
/*
* L1 cache does have unpredictable contents at power-up clean its
* contents without flushing
*/
bl v7_invalidate_l1
nop
b secondary_startup
ENDPROC(bcm63138_secondary_startup)

View file

@ -127,7 +127,7 @@ static int bcm63138_smp_boot_secondary(unsigned int cpu,
} }
/* Locate the secondary CPU node */ /* Locate the secondary CPU node */
dn = of_get_cpu_node(cpu_logical_map(cpu), NULL); dn = of_get_cpu_node(cpu, NULL);
if (!dn) { if (!dn) {
pr_err("SMP: failed to locate secondary CPU%d node\n", cpu); pr_err("SMP: failed to locate secondary CPU%d node\n", cpu);
ret = -ENODEV; ret = -ENODEV;
@ -135,7 +135,7 @@ static int bcm63138_smp_boot_secondary(unsigned int cpu,
} }
/* Write the secondary init routine to the BootLUT reset vector */ /* Write the secondary init routine to the BootLUT reset vector */
val = virt_to_phys(bcm63138_secondary_startup); val = virt_to_phys(secondary_startup);
writel_relaxed(val, bootlut_base + BOOTLUT_RESET_VECT); writel_relaxed(val, bootlut_base + BOOTLUT_RESET_VECT);
/* Power up the core, will jump straight to its reset vector when we /* Power up the core, will jump straight to its reset vector when we

View file

@ -3,7 +3,6 @@
struct device_node; struct device_node;
extern void bcm63138_secondary_startup(void);
extern int bcm63xx_pmb_power_on_cpu(struct device_node *dn); extern int bcm63xx_pmb_power_on_cpu(struct device_node *dn);
#endif /* __BCM63XX_SMP_H */ #endif /* __BCM63XX_SMP_H */

View file

@ -44,7 +44,7 @@ static void __init bcm5301x_init_early(void)
"imprecise external abort"); "imprecise external abort");
} }
static const char __initconst *bcm5301x_dt_compat[] = { static const char *const bcm5301x_dt_compat[] __initconst = {
"brcm,bcm4708", "brcm,bcm4708",
NULL, NULL,
}; };

View file

@ -33,7 +33,7 @@ struct bcm_kona_smc_data {
unsigned result; unsigned result;
}; };
static const struct of_device_id bcm_kona_smc_ids[] __initconst = { static const struct of_device_id const bcm_kona_smc_ids[] __initconst = {
{.compatible = "brcm,kona-smc"}, {.compatible = "brcm,kona-smc"},
{.compatible = "bcm,kona-smc"}, /* deprecated name */ {.compatible = "bcm,kona-smc"}, /* deprecated name */
{}, {},

View file

@ -160,7 +160,7 @@ static struct platform_device autcpu12_mmgpio_pdev __initdata = {
}, },
}; };
static const struct gpio autcpu12_gpios[] __initconst = { static const struct gpio const autcpu12_gpios[] __initconst = {
{ AUTCPU12_DPOT_CS, GPIOF_OUT_INIT_HIGH, "DPOT CS" }, { AUTCPU12_DPOT_CS, GPIOF_OUT_INIT_HIGH, "DPOT CS" },
{ AUTCPU12_DPOT_CLK, GPIOF_OUT_INIT_LOW, "DPOT CLK" }, { AUTCPU12_DPOT_CLK, GPIOF_OUT_INIT_LOW, "DPOT CLK" },
{ AUTCPU12_DPOT_UD, GPIOF_OUT_INIT_LOW, "DPOT UD" }, { AUTCPU12_DPOT_UD, GPIOF_OUT_INIT_LOW, "DPOT UD" },

View file

@ -113,30 +113,33 @@ void cns3xxx_power_off(void)
*/ */
static void __iomem *cns3xxx_tmr1; static void __iomem *cns3xxx_tmr1;
static void cns3xxx_timer_set_mode(enum clock_event_mode mode, static int cns3xxx_shutdown(struct clock_event_device *clk)
struct clock_event_device *clk) {
writel(0, cns3xxx_tmr1 + TIMER1_2_CONTROL_OFFSET);
return 0;
}
static int cns3xxx_set_oneshot(struct clock_event_device *clk)
{
unsigned long ctrl = readl(cns3xxx_tmr1 + TIMER1_2_CONTROL_OFFSET);
/* period set, and timer enabled in 'next_event' hook */
ctrl |= (1 << 2) | (1 << 9);
writel(ctrl, cns3xxx_tmr1 + TIMER1_2_CONTROL_OFFSET);
return 0;
}
static int cns3xxx_set_periodic(struct clock_event_device *clk)
{ {
unsigned long ctrl = readl(cns3xxx_tmr1 + TIMER1_2_CONTROL_OFFSET); unsigned long ctrl = readl(cns3xxx_tmr1 + TIMER1_2_CONTROL_OFFSET);
int pclk = cns3xxx_cpu_clock() / 8; int pclk = cns3xxx_cpu_clock() / 8;
int reload; int reload;
switch (mode) { reload = pclk * 20 / (3 * HZ) * 0x25000;
case CLOCK_EVT_MODE_PERIODIC: writel(reload, cns3xxx_tmr1 + TIMER1_AUTO_RELOAD_OFFSET);
reload = pclk * 20 / (3 * HZ) * 0x25000; ctrl |= (1 << 0) | (1 << 2) | (1 << 9);
writel(reload, cns3xxx_tmr1 + TIMER1_AUTO_RELOAD_OFFSET);
ctrl |= (1 << 0) | (1 << 2) | (1 << 9);
break;
case CLOCK_EVT_MODE_ONESHOT:
/* period set, and timer enabled in 'next_event' hook */
ctrl |= (1 << 2) | (1 << 9);
break;
case CLOCK_EVT_MODE_UNUSED:
case CLOCK_EVT_MODE_SHUTDOWN:
default:
ctrl = 0;
}
writel(ctrl, cns3xxx_tmr1 + TIMER1_2_CONTROL_OFFSET); writel(ctrl, cns3xxx_tmr1 + TIMER1_2_CONTROL_OFFSET);
return 0;
} }
static int cns3xxx_timer_set_next_event(unsigned long evt, static int cns3xxx_timer_set_next_event(unsigned long evt,
@ -151,12 +154,16 @@ static int cns3xxx_timer_set_next_event(unsigned long evt,
} }
static struct clock_event_device cns3xxx_tmr1_clockevent = { static struct clock_event_device cns3xxx_tmr1_clockevent = {
.name = "cns3xxx timer1", .name = "cns3xxx timer1",
.features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, .features = CLOCK_EVT_FEAT_PERIODIC |
.set_mode = cns3xxx_timer_set_mode, CLOCK_EVT_FEAT_ONESHOT,
.set_next_event = cns3xxx_timer_set_next_event, .set_state_shutdown = cns3xxx_shutdown,
.rating = 350, .set_state_periodic = cns3xxx_set_periodic,
.cpumask = cpu_all_mask, .set_state_oneshot = cns3xxx_set_oneshot,
.tick_resume = cns3xxx_shutdown,
.set_next_event = cns3xxx_timer_set_next_event,
.rating = 350,
.cpumask = cpu_all_mask,
}; };
static void __init cns3xxx_clockevents_init(unsigned int timer_irq) static void __init cns3xxx_clockevents_init(unsigned int timer_irq)
@ -339,7 +346,7 @@ static struct usb_ohci_pdata cns3xxx_usb_ohci_pdata = {
.power_off = csn3xxx_usb_power_off, .power_off = csn3xxx_usb_power_off,
}; };
static struct of_dev_auxdata cns3xxx_auxdata[] __initconst = { static const struct of_dev_auxdata const cns3xxx_auxdata[] __initconst = {
{ "intel,usb-ehci", CNS3XXX_USB_BASE, "ehci-platform", &cns3xxx_usb_ehci_pdata }, { "intel,usb-ehci", CNS3XXX_USB_BASE, "ehci-platform", &cns3xxx_usb_ehci_pdata },
{ "intel,usb-ohci", CNS3XXX_USB_OHCI_BASE, "ohci-platform", &cns3xxx_usb_ohci_pdata }, { "intel,usb-ohci", CNS3XXX_USB_OHCI_BASE, "ohci-platform", &cns3xxx_usb_ohci_pdata },
{ "cavium,cns3420-ahci", CNS3XXX_SATA2_BASE, "ahci", NULL }, { "cavium,cns3420-ahci", CNS3XXX_SATA2_BASE, "ahci", NULL },
@ -392,7 +399,7 @@ static void __init cns3xxx_init(void)
cns3xxx_auxdata, NULL); cns3xxx_auxdata, NULL);
} }
static const char *cns3xxx_dt_compat[] __initdata = { static const char *const cns3xxx_dt_compat[] __initconst = {
"cavium,cns3410", "cavium,cns3410",
"cavium,cns3420", "cavium,cns3420",
NULL, NULL,

View file

@ -112,7 +112,7 @@ static int cp_intc_host_map(struct irq_domain *h, unsigned int virq,
pr_debug("cp_intc_host_map(%d, 0x%lx)\n", virq, hw); pr_debug("cp_intc_host_map(%d, 0x%lx)\n", virq, hw);
irq_set_chip(virq, &cp_intc_irq_chip); irq_set_chip(virq, &cp_intc_irq_chip);
set_irq_flags(virq, IRQF_VALID | IRQF_PROBE); irq_set_probe(virq);
irq_set_handler(virq, handle_edge_irq); irq_set_handler(virq, handle_edge_irq);
return 0; return 0;
} }

View file

@ -715,7 +715,7 @@ const short da850_lcdcntl_pins[] __initconst = {
-1 -1
}; };
const short da850_vpif_capture_pins[] __initdata = { const short da850_vpif_capture_pins[] __initconst = {
DA850_VPIF_DIN0, DA850_VPIF_DIN1, DA850_VPIF_DIN2, DA850_VPIF_DIN3, DA850_VPIF_DIN0, DA850_VPIF_DIN1, DA850_VPIF_DIN2, DA850_VPIF_DIN3,
DA850_VPIF_DIN4, DA850_VPIF_DIN5, DA850_VPIF_DIN6, DA850_VPIF_DIN7, DA850_VPIF_DIN4, DA850_VPIF_DIN5, DA850_VPIF_DIN6, DA850_VPIF_DIN7,
DA850_VPIF_DIN8, DA850_VPIF_DIN9, DA850_VPIF_DIN10, DA850_VPIF_DIN11, DA850_VPIF_DIN8, DA850_VPIF_DIN9, DA850_VPIF_DIN10, DA850_VPIF_DIN11,
@ -725,7 +725,7 @@ const short da850_vpif_capture_pins[] __initdata = {
-1 -1
}; };
const short da850_vpif_display_pins[] __initdata = { const short da850_vpif_display_pins[] __initconst = {
DA850_VPIF_DOUT0, DA850_VPIF_DOUT1, DA850_VPIF_DOUT2, DA850_VPIF_DOUT3, DA850_VPIF_DOUT0, DA850_VPIF_DOUT1, DA850_VPIF_DOUT2, DA850_VPIF_DOUT3,
DA850_VPIF_DOUT4, DA850_VPIF_DOUT5, DA850_VPIF_DOUT6, DA850_VPIF_DOUT7, DA850_VPIF_DOUT4, DA850_VPIF_DOUT5, DA850_VPIF_DOUT6, DA850_VPIF_DOUT7,
DA850_VPIF_DOUT8, DA850_VPIF_DOUT9, DA850_VPIF_DOUT10, DA850_VPIF_DOUT8, DA850_VPIF_DOUT9, DA850_VPIF_DOUT10,

View file

@ -20,7 +20,7 @@
#define DA8XX_NUM_UARTS 3 #define DA8XX_NUM_UARTS 3
static const struct of_device_id da8xx_irq_match[] __initconst = { static const struct of_device_id const da8xx_irq_match[] __initconst = {
{ .compatible = "ti,cp-intc", .data = cp_intc_of_init, }, { .compatible = "ti,cp-intc", .data = cp_intc_of_init, },
{ } { }
}; };
@ -59,7 +59,7 @@ static void __init da850_init_machine(void)
} }
static const char *da850_boards_compat[] __initdata = { static const char *const da850_boards_compat[] __initconst = {
"enbw,cmc", "enbw,cmc",
"ti,da850-evm", "ti,da850-evm",
"ti,da850", "ti,da850",

View file

@ -303,36 +303,42 @@ static int davinci_set_next_event(unsigned long cycles,
return 0; return 0;
} }
static void davinci_set_mode(enum clock_event_mode mode, static int davinci_shutdown(struct clock_event_device *evt)
struct clock_event_device *evt)
{ {
struct timer_s *t = &timers[TID_CLOCKEVENT]; struct timer_s *t = &timers[TID_CLOCKEVENT];
switch (mode) { t->opts &= ~TIMER_OPTS_STATE_MASK;
case CLOCK_EVT_MODE_PERIODIC: t->opts |= TIMER_OPTS_DISABLED;
t->period = davinci_clock_tick_rate / (HZ); return 0;
t->opts &= ~TIMER_OPTS_STATE_MASK; }
t->opts |= TIMER_OPTS_PERIODIC;
timer32_config(t); static int davinci_set_oneshot(struct clock_event_device *evt)
break; {
case CLOCK_EVT_MODE_ONESHOT: struct timer_s *t = &timers[TID_CLOCKEVENT];
t->opts &= ~TIMER_OPTS_STATE_MASK;
t->opts |= TIMER_OPTS_ONESHOT; t->opts &= ~TIMER_OPTS_STATE_MASK;
break; t->opts |= TIMER_OPTS_ONESHOT;
case CLOCK_EVT_MODE_UNUSED: return 0;
case CLOCK_EVT_MODE_SHUTDOWN: }
t->opts &= ~TIMER_OPTS_STATE_MASK;
t->opts |= TIMER_OPTS_DISABLED; static int davinci_set_periodic(struct clock_event_device *evt)
break; {
case CLOCK_EVT_MODE_RESUME: struct timer_s *t = &timers[TID_CLOCKEVENT];
break;
} t->period = davinci_clock_tick_rate / (HZ);
t->opts &= ~TIMER_OPTS_STATE_MASK;
t->opts |= TIMER_OPTS_PERIODIC;
timer32_config(t);
return 0;
} }
static struct clock_event_device clockevent_davinci = { static struct clock_event_device clockevent_davinci = {
.features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, .features = CLOCK_EVT_FEAT_PERIODIC |
.set_next_event = davinci_set_next_event, CLOCK_EVT_FEAT_ONESHOT,
.set_mode = davinci_set_mode, .set_next_event = davinci_set_next_event,
.set_state_shutdown = davinci_shutdown,
.set_state_periodic = davinci_set_periodic,
.set_state_oneshot = davinci_set_oneshot,
}; };

View file

@ -8,7 +8,7 @@
#include <asm/mach/arch.h> #include <asm/mach/arch.h>
static const char *digicolor_dt_compat[] __initconst = { static const char *const digicolor_dt_compat[] __initconst = {
"cnxt,cx92755", "cnxt,cx92755",
NULL, NULL,
}; };

View file

@ -69,8 +69,9 @@ static struct irq_chip pmu_irq_chip = {
.irq_ack = pmu_irq_ack, .irq_ack = pmu_irq_ack,
}; };
static void pmu_irq_handler(unsigned int irq, struct irq_desc *desc) static void pmu_irq_handler(unsigned int __irq, struct irq_desc *desc)
{ {
unsigned int irq = irq_desc_get_irq(desc);
unsigned long cause = readl(PMU_INTERRUPT_CAUSE); unsigned long cause = readl(PMU_INTERRUPT_CAUSE);
cause &= readl(PMU_INTERRUPT_MASK); cause &= readl(PMU_INTERRUPT_MASK);
@ -172,7 +173,7 @@ void __init dove_init_irq(void)
for (i = IRQ_DOVE_PMU_START; i < NR_IRQS; i++) { for (i = IRQ_DOVE_PMU_START; i < NR_IRQS; i++) {
irq_set_chip_and_handler(i, &pmu_irq_chip, handle_level_irq); irq_set_chip_and_handler(i, &pmu_irq_chip, handle_level_irq);
irq_set_status_flags(i, IRQ_LEVEL); irq_set_status_flags(i, IRQ_LEVEL);
set_irq_flags(i, IRQF_VALID); irq_clear_status_flags(i, IRQ_NOREQUEST);
} }
irq_set_chained_handler(IRQ_DOVE_PMU, pmu_irq_handler); irq_set_chained_handler(IRQ_DOVE_PMU, pmu_irq_handler);
} }

View file

@ -65,7 +65,7 @@ static void __init ebsa110_init_irq(void)
for (irq = 0; irq < NR_IRQS; irq++) { for (irq = 0; irq < NR_IRQS; irq++) {
irq_set_chip_and_handler(irq, &ebsa110_irq_chip, irq_set_chip_and_handler(irq, &ebsa110_irq_chip,
handle_level_irq); handle_level_irq);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); irq_clear_status_flags(irq, IRQ_NOREQUEST | IRQ_NOPROBE);
} }
} }

View file

@ -15,45 +15,8 @@ config CRUNCH
comment "EP93xx Platforms" comment "EP93xx Platforms"
choice
prompt "EP93xx first SDRAM bank selection"
default EP93XX_SDCE3_SYNC_PHYS_OFFSET
config EP93XX_SDCE3_SYNC_PHYS_OFFSET
bool "0x00000000 - SDCE3/SyncBoot"
help
Select this option if you want support for EP93xx boards with the
first SDRAM bank at 0x00000000.
config EP93XX_SDCE0_PHYS_OFFSET
bool "0xc0000000 - SDCEO"
help
Select this option if you want support for EP93xx boards with the
first SDRAM bank at 0xc0000000.
config EP93XX_SDCE1_PHYS_OFFSET
bool "0xd0000000 - SDCE1"
help
Select this option if you want support for EP93xx boards with the
first SDRAM bank at 0xd0000000.
config EP93XX_SDCE2_PHYS_OFFSET
bool "0xe0000000 - SDCE2"
help
Select this option if you want support for EP93xx boards with the
first SDRAM bank at 0xe0000000.
config EP93XX_SDCE3_ASYNC_PHYS_OFFSET
bool "0xf0000000 - SDCE3/AsyncBoot"
help
Select this option if you want support for EP93xx boards with the
first SDRAM bank at 0xf0000000.
endchoice
config MACH_ADSSPHERE config MACH_ADSSPHERE
bool "Support ADS Sphere" bool "Support ADS Sphere"
depends on EP93XX_SDCE3_SYNC_PHYS_OFFSET
help help
Say 'Y' here if you want your kernel to support the ADS Say 'Y' here if you want your kernel to support the ADS
Sphere board. Sphere board.
@ -63,7 +26,6 @@ config MACH_EDB93XX
config MACH_EDB9301 config MACH_EDB9301
bool "Support Cirrus Logic EDB9301" bool "Support Cirrus Logic EDB9301"
depends on EP93XX_SDCE3_SYNC_PHYS_OFFSET
select MACH_EDB93XX select MACH_EDB93XX
help help
Say 'Y' here if you want your kernel to support the Cirrus Say 'Y' here if you want your kernel to support the Cirrus
@ -71,7 +33,6 @@ config MACH_EDB9301
config MACH_EDB9302 config MACH_EDB9302
bool "Support Cirrus Logic EDB9302" bool "Support Cirrus Logic EDB9302"
depends on EP93XX_SDCE3_SYNC_PHYS_OFFSET
select MACH_EDB93XX select MACH_EDB93XX
help help
Say 'Y' here if you want your kernel to support the Cirrus Say 'Y' here if you want your kernel to support the Cirrus
@ -79,7 +40,6 @@ config MACH_EDB9302
config MACH_EDB9302A config MACH_EDB9302A
bool "Support Cirrus Logic EDB9302A" bool "Support Cirrus Logic EDB9302A"
depends on EP93XX_SDCE0_PHYS_OFFSET
select MACH_EDB93XX select MACH_EDB93XX
help help
Say 'Y' here if you want your kernel to support the Cirrus Say 'Y' here if you want your kernel to support the Cirrus
@ -87,7 +47,6 @@ config MACH_EDB9302A
config MACH_EDB9307 config MACH_EDB9307
bool "Support Cirrus Logic EDB9307" bool "Support Cirrus Logic EDB9307"
depends on EP93XX_SDCE3_SYNC_PHYS_OFFSET
select MACH_EDB93XX select MACH_EDB93XX
help help
Say 'Y' here if you want your kernel to support the Cirrus Say 'Y' here if you want your kernel to support the Cirrus
@ -95,7 +54,6 @@ config MACH_EDB9307
config MACH_EDB9307A config MACH_EDB9307A
bool "Support Cirrus Logic EDB9307A" bool "Support Cirrus Logic EDB9307A"
depends on EP93XX_SDCE0_PHYS_OFFSET
select MACH_EDB93XX select MACH_EDB93XX
help help
Say 'Y' here if you want your kernel to support the Cirrus Say 'Y' here if you want your kernel to support the Cirrus
@ -103,7 +61,6 @@ config MACH_EDB9307A
config MACH_EDB9312 config MACH_EDB9312
bool "Support Cirrus Logic EDB9312" bool "Support Cirrus Logic EDB9312"
depends on EP93XX_SDCE3_SYNC_PHYS_OFFSET
select MACH_EDB93XX select MACH_EDB93XX
help help
Say 'Y' here if you want your kernel to support the Cirrus Say 'Y' here if you want your kernel to support the Cirrus
@ -111,7 +68,6 @@ config MACH_EDB9312
config MACH_EDB9315 config MACH_EDB9315
bool "Support Cirrus Logic EDB9315" bool "Support Cirrus Logic EDB9315"
depends on EP93XX_SDCE3_SYNC_PHYS_OFFSET
select MACH_EDB93XX select MACH_EDB93XX
help help
Say 'Y' here if you want your kernel to support the Cirrus Say 'Y' here if you want your kernel to support the Cirrus
@ -119,14 +75,12 @@ config MACH_EDB9315
config MACH_EDB9315A config MACH_EDB9315A
bool "Support Cirrus Logic EDB9315A" bool "Support Cirrus Logic EDB9315A"
depends on EP93XX_SDCE0_PHYS_OFFSET
select MACH_EDB93XX select MACH_EDB93XX
help help
Say 'Y' here if you want your kernel to support the Cirrus Say 'Y' here if you want your kernel to support the Cirrus
Logic EDB9315A Evaluation Board. Logic EDB9315A Evaluation Board.
config MACH_GESBC9312 config MACH_GESBC9312
depends on EP93XX_SDCE3_SYNC_PHYS_OFFSET
bool "Support Glomation GESBC-9312-sx" bool "Support Glomation GESBC-9312-sx"
help help
Say 'Y' here if you want your kernel to support the Glomation Say 'Y' here if you want your kernel to support the Glomation
@ -137,7 +91,6 @@ config MACH_MICRO9
config MACH_MICRO9H config MACH_MICRO9H
bool "Support Contec Micro9-High" bool "Support Contec Micro9-High"
depends on EP93XX_SDCE3_SYNC_PHYS_OFFSET
select MACH_MICRO9 select MACH_MICRO9
help help
Say 'Y' here if you want your kernel to support the Say 'Y' here if you want your kernel to support the
@ -145,7 +98,6 @@ config MACH_MICRO9H
config MACH_MICRO9M config MACH_MICRO9M
bool "Support Contec Micro9-Mid" bool "Support Contec Micro9-Mid"
depends on EP93XX_SDCE3_ASYNC_PHYS_OFFSET
select MACH_MICRO9 select MACH_MICRO9
help help
Say 'Y' here if you want your kernel to support the Say 'Y' here if you want your kernel to support the
@ -153,7 +105,6 @@ config MACH_MICRO9M
config MACH_MICRO9L config MACH_MICRO9L
bool "Support Contec Micro9-Lite" bool "Support Contec Micro9-Lite"
depends on EP93XX_SDCE3_SYNC_PHYS_OFFSET
select MACH_MICRO9 select MACH_MICRO9
help help
Say 'Y' here if you want your kernel to support the Say 'Y' here if you want your kernel to support the
@ -161,7 +112,6 @@ config MACH_MICRO9L
config MACH_MICRO9S config MACH_MICRO9S
bool "Support Contec Micro9-Slim" bool "Support Contec Micro9-Slim"
depends on EP93XX_SDCE3_ASYNC_PHYS_OFFSET
select MACH_MICRO9 select MACH_MICRO9
help help
Say 'Y' here if you want your kernel to support the Say 'Y' here if you want your kernel to support the
@ -169,28 +119,24 @@ config MACH_MICRO9S
config MACH_SIM_ONE config MACH_SIM_ONE
bool "Support Simplemachines Sim.One board" bool "Support Simplemachines Sim.One board"
depends on EP93XX_SDCE0_PHYS_OFFSET
help help
Say 'Y' here if you want your kernel to support the Say 'Y' here if you want your kernel to support the
Simplemachines Sim.One board. Simplemachines Sim.One board.
config MACH_SNAPPER_CL15 config MACH_SNAPPER_CL15
bool "Support Bluewater Systems Snapper CL15 Module" bool "Support Bluewater Systems Snapper CL15 Module"
depends on EP93XX_SDCE0_PHYS_OFFSET
help help
Say 'Y' here if you want your kernel to support the Bluewater Say 'Y' here if you want your kernel to support the Bluewater
Systems Snapper CL15 Module. Systems Snapper CL15 Module.
config MACH_TS72XX config MACH_TS72XX
bool "Support Technologic Systems TS-72xx SBC" bool "Support Technologic Systems TS-72xx SBC"
depends on EP93XX_SDCE3_SYNC_PHYS_OFFSET
help help
Say 'Y' here if you want your kernel to support the Say 'Y' here if you want your kernel to support the
Technologic Systems TS-72xx board. Technologic Systems TS-72xx board.
config MACH_VISION_EP9307 config MACH_VISION_EP9307
bool "Support Vision Engraving Systems EP9307 SoM" bool "Support Vision Engraving Systems EP9307 SoM"
depends on EP93XX_SDCE0_PHYS_OFFSET
help help
Say 'Y' here if you want your kernel to support the Say 'Y' here if you want your kernel to support the
Vision Engraving Systems EP9307 SoM. Vision Engraving Systems EP9307 SoM.

View file

@ -1,7 +1,7 @@
# #
# Makefile for the linux kernel. # Makefile for the linux kernel.
# #
obj-y := core.o clock.o obj-y := core.o clock.o timer-ep93xx.o
obj-$(CONFIG_EP93XX_DMA) += dma.o obj-$(CONFIG_EP93XX_DMA) += dma.o

View file

@ -1,14 +1 @@
zreladdr-$(CONFIG_EP93XX_SDCE3_SYNC_PHYS_OFFSET) += 0x00008000 # Empty file waiting for deletion once Makefile.boot isn't needed any more.
params_phys-$(CONFIG_EP93XX_SDCE3_SYNC_PHYS_OFFSET) := 0x00000100
zreladdr-$(CONFIG_EP93XX_SDCE0_PHYS_OFFSET) += 0xc0008000
params_phys-$(CONFIG_EP93XX_SDCE0_PHYS_OFFSET) := 0xc0000100
zreladdr-$(CONFIG_EP93XX_SDCE1_PHYS_OFFSET) += 0xd0008000
params_phys-$(CONFIG_EP93XX_SDCE1_PHYS_OFFSET) := 0xd0000100
zreladdr-$(CONFIG_EP93XX_SDCE2_PHYS_OFFSET) += 0xe0008000
params_phys-$(CONFIG_EP93XX_SDCE2_PHYS_OFFSET) := 0xe0000100
zreladdr-$(CONFIG_EP93XX_SDCE3_ASYNC_PHYS_OFFSET) += 0xf0008000
params_phys-$(CONFIG_EP93XX_SDCE3_ASYNC_PHYS_OFFSET) := 0xf0000100

View file

@ -22,7 +22,6 @@
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/dma-mapping.h> #include <linux/dma-mapping.h>
#include <linux/sys_soc.h> #include <linux/sys_soc.h>
#include <linux/timex.h>
#include <linux/irq.h> #include <linux/irq.h>
#include <linux/io.h> #include <linux/io.h>
#include <linux/gpio.h> #include <linux/gpio.h>
@ -38,6 +37,7 @@
#include <linux/irqchip/arm-vic.h> #include <linux/irqchip/arm-vic.h>
#include <linux/reboot.h> #include <linux/reboot.h>
#include <linux/usb/ohci_pdriver.h> #include <linux/usb/ohci_pdriver.h>
#include <linux/random.h>
#include <mach/hardware.h> #include <mach/hardware.h>
#include <linux/platform_data/video-ep93xx.h> #include <linux/platform_data/video-ep93xx.h>
@ -47,7 +47,6 @@
#include <asm/mach/arch.h> #include <asm/mach/arch.h>
#include <asm/mach/map.h> #include <asm/mach/map.h>
#include <asm/mach/time.h>
#include "soc.h" #include "soc.h"
@ -73,113 +72,6 @@ void __init ep93xx_map_io(void)
iotable_init(ep93xx_io_desc, ARRAY_SIZE(ep93xx_io_desc)); iotable_init(ep93xx_io_desc, ARRAY_SIZE(ep93xx_io_desc));
} }
/*************************************************************************
* Timer handling for EP93xx
*************************************************************************
* The ep93xx has four internal timers. Timers 1, 2 (both 16 bit) and
* 3 (32 bit) count down at 508 kHz, are self-reloading, and can generate
* an interrupt on underflow. Timer 4 (40 bit) counts down at 983.04 kHz,
* is free-running, and can't generate interrupts.
*
* The 508 kHz timers are ideal for use for the timer interrupt, as the
* most common values of HZ divide 508 kHz nicely. We pick one of the 16
* bit timers (timer 1) since we don't need more than 16 bits of reload
* value as long as HZ >= 8.
*
* The higher clock rate of timer 4 makes it a better choice than the
* other timers for use in gettimeoffset(), while the fact that it can't
* generate interrupts means we don't have to worry about not being able
* to use this timer for something else. We also use timer 4 for keeping
* track of lost jiffies.
*/
#define EP93XX_TIMER_REG(x) (EP93XX_TIMER_BASE + (x))
#define EP93XX_TIMER1_LOAD EP93XX_TIMER_REG(0x00)
#define EP93XX_TIMER1_VALUE EP93XX_TIMER_REG(0x04)
#define EP93XX_TIMER1_CONTROL EP93XX_TIMER_REG(0x08)
#define EP93XX_TIMER123_CONTROL_ENABLE (1 << 7)
#define EP93XX_TIMER123_CONTROL_MODE (1 << 6)
#define EP93XX_TIMER123_CONTROL_CLKSEL (1 << 3)
#define EP93XX_TIMER1_CLEAR EP93XX_TIMER_REG(0x0c)
#define EP93XX_TIMER2_LOAD EP93XX_TIMER_REG(0x20)
#define EP93XX_TIMER2_VALUE EP93XX_TIMER_REG(0x24)
#define EP93XX_TIMER2_CONTROL EP93XX_TIMER_REG(0x28)
#define EP93XX_TIMER2_CLEAR EP93XX_TIMER_REG(0x2c)
#define EP93XX_TIMER4_VALUE_LOW EP93XX_TIMER_REG(0x60)
#define EP93XX_TIMER4_VALUE_HIGH EP93XX_TIMER_REG(0x64)
#define EP93XX_TIMER4_VALUE_HIGH_ENABLE (1 << 8)
#define EP93XX_TIMER3_LOAD EP93XX_TIMER_REG(0x80)
#define EP93XX_TIMER3_VALUE EP93XX_TIMER_REG(0x84)
#define EP93XX_TIMER3_CONTROL EP93XX_TIMER_REG(0x88)
#define EP93XX_TIMER3_CLEAR EP93XX_TIMER_REG(0x8c)
#define EP93XX_TIMER123_CLOCK 508469
#define EP93XX_TIMER4_CLOCK 983040
#define TIMER1_RELOAD ((EP93XX_TIMER123_CLOCK / HZ) - 1)
#define TIMER4_TICKS_PER_JIFFY DIV_ROUND_CLOSEST(EP93XX_TIMER4_CLOCK, HZ)
static unsigned int last_jiffy_time;
static irqreturn_t ep93xx_timer_interrupt(int irq, void *dev_id)
{
/* Writing any value clears the timer interrupt */
__raw_writel(1, EP93XX_TIMER1_CLEAR);
/* Recover lost jiffies */
while ((signed long)
(__raw_readl(EP93XX_TIMER4_VALUE_LOW) - last_jiffy_time)
>= TIMER4_TICKS_PER_JIFFY) {
last_jiffy_time += TIMER4_TICKS_PER_JIFFY;
timer_tick();
}
return IRQ_HANDLED;
}
static struct irqaction ep93xx_timer_irq = {
.name = "ep93xx timer",
.flags = IRQF_TIMER | IRQF_IRQPOLL,
.handler = ep93xx_timer_interrupt,
};
static u32 ep93xx_gettimeoffset(void)
{
int offset;
offset = __raw_readl(EP93XX_TIMER4_VALUE_LOW) - last_jiffy_time;
/*
* Timer 4 is based on a 983.04 kHz reference clock,
* so dividing by 983040 gives the fraction of a second,
* so dividing by 0.983040 converts to uS.
* Refactor the calculation to avoid overflow.
* Finally, multiply by 1000 to give nS.
*/
return (offset + (53 * offset / 3072)) * 1000;
}
void __init ep93xx_timer_init(void)
{
u32 tmode = EP93XX_TIMER123_CONTROL_MODE |
EP93XX_TIMER123_CONTROL_CLKSEL;
arch_gettimeoffset = ep93xx_gettimeoffset;
/* Enable periodic HZ timer. */
__raw_writel(tmode, EP93XX_TIMER1_CONTROL);
__raw_writel(TIMER1_RELOAD, EP93XX_TIMER1_LOAD);
__raw_writel(tmode | EP93XX_TIMER123_CONTROL_ENABLE,
EP93XX_TIMER1_CONTROL);
/* Enable lost jiffy timer. */
__raw_writel(EP93XX_TIMER4_VALUE_HIGH_ENABLE,
EP93XX_TIMER4_VALUE_HIGH);
setup_irq(IRQ_EP93XX_TIMER1, &ep93xx_timer_irq);
}
/************************************************************************* /*************************************************************************
* EP93xx IRQ handling * EP93xx IRQ handling
*************************************************************************/ *************************************************************************/
@ -971,6 +863,12 @@ static const char __init *ep93xx_get_soc_id(void)
if (id != id2) if (id != id2)
return "invalid"; return "invalid";
/* Toss the unique ID into the entropy pool */
add_device_randomness(&id2, 4);
add_device_randomness(&id3, 4);
add_device_randomness(&id4, 4);
add_device_randomness(&id5, 4);
snprintf(ep93xx_soc_id, sizeof(ep93xx_soc_id), snprintf(ep93xx_soc_id, sizeof(ep93xx_soc_id),
"%08x%08x%08x%08x", id2, id3, id4, id5); "%08x%08x%08x%08x", id2, id3, id4, id5);

View file

@ -205,8 +205,6 @@ static void __init edb93xx_register_pwm(void)
* EDB93xx framebuffer * EDB93xx framebuffer
*************************************************************************/ *************************************************************************/
static struct ep93xxfb_mach_info __initdata edb93xxfb_info = { static struct ep93xxfb_mach_info __initdata edb93xxfb_info = {
.num_modes = EP93XXFB_USE_MODEDB,
.bpp = 16,
.flags = 0, .flags = 0,
}; };

View file

@ -40,8 +40,6 @@ static struct ep93xx_eth_data __initdata simone_eth_data = {
}; };
static struct ep93xxfb_mach_info __initdata simone_fb_info = { static struct ep93xxfb_mach_info __initdata simone_fb_info = {
.num_modes = EP93XXFB_USE_MODEDB,
.bpp = 16,
.flags = EP93XXFB_USE_SDCSN0 | EP93XXFB_PCLK_FALLING, .flags = EP93XXFB_USE_SDCSN0 | EP93XXFB_PCLK_FALLING,
}; };
@ -169,6 +167,7 @@ static struct spi_board_info simone_spi_devices[] __initdata = {
static struct ep93xx_spi_info simone_spi_info __initdata = { static struct ep93xx_spi_info simone_spi_info __initdata = {
.num_chipselect = ARRAY_SIZE(simone_spi_devices), .num_chipselect = ARRAY_SIZE(simone_spi_devices),
.use_dma = 1,
}; };
static struct i2c_gpio_platform_data __initdata simone_i2c_gpio_data = { static struct i2c_gpio_platform_data __initdata simone_i2c_gpio_data = {

View file

@ -144,8 +144,6 @@ static struct i2c_board_info __initdata snappercl15_i2c_data[] = {
}; };
static struct ep93xxfb_mach_info __initdata snappercl15_fb_info = { static struct ep93xxfb_mach_info __initdata snappercl15_fb_info = {
.num_modes = EP93XXFB_USE_MODEDB,
.bpp = 16,
}; };
static struct platform_device snappercl15_audio_device = { static struct platform_device snappercl15_audio_device = {

View file

@ -0,0 +1,143 @@
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/clocksource.h>
#include <linux/clockchips.h>
#include <linux/sched_clock.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/io.h>
#include <asm/mach/time.h>
#include "soc.h"
/*************************************************************************
* Timer handling for EP93xx
*************************************************************************
* The ep93xx has four internal timers. Timers 1, 2 (both 16 bit) and
* 3 (32 bit) count down at 508 kHz, are self-reloading, and can generate
* an interrupt on underflow. Timer 4 (40 bit) counts down at 983.04 kHz,
* is free-running, and can't generate interrupts.
*
* The 508 kHz timers are ideal for use for the timer interrupt, as the
* most common values of HZ divide 508 kHz nicely. We pick the 32 bit
* timer (timer 3) to get as long sleep intervals as possible when using
* CONFIG_NO_HZ.
*
* The higher clock rate of timer 4 makes it a better choice than the
* other timers for use as clock source and for sched_clock(), providing
* a stable 40 bit time base.
*************************************************************************
*/
#define EP93XX_TIMER_REG(x) (EP93XX_TIMER_BASE + (x))
#define EP93XX_TIMER1_LOAD EP93XX_TIMER_REG(0x00)
#define EP93XX_TIMER1_VALUE EP93XX_TIMER_REG(0x04)
#define EP93XX_TIMER1_CONTROL EP93XX_TIMER_REG(0x08)
#define EP93XX_TIMER123_CONTROL_ENABLE (1 << 7)
#define EP93XX_TIMER123_CONTROL_MODE (1 << 6)
#define EP93XX_TIMER123_CONTROL_CLKSEL (1 << 3)
#define EP93XX_TIMER1_CLEAR EP93XX_TIMER_REG(0x0c)
#define EP93XX_TIMER2_LOAD EP93XX_TIMER_REG(0x20)
#define EP93XX_TIMER2_VALUE EP93XX_TIMER_REG(0x24)
#define EP93XX_TIMER2_CONTROL EP93XX_TIMER_REG(0x28)
#define EP93XX_TIMER2_CLEAR EP93XX_TIMER_REG(0x2c)
#define EP93XX_TIMER4_VALUE_LOW EP93XX_TIMER_REG(0x60)
#define EP93XX_TIMER4_VALUE_HIGH EP93XX_TIMER_REG(0x64)
#define EP93XX_TIMER4_VALUE_HIGH_ENABLE (1 << 8)
#define EP93XX_TIMER3_LOAD EP93XX_TIMER_REG(0x80)
#define EP93XX_TIMER3_VALUE EP93XX_TIMER_REG(0x84)
#define EP93XX_TIMER3_CONTROL EP93XX_TIMER_REG(0x88)
#define EP93XX_TIMER3_CLEAR EP93XX_TIMER_REG(0x8c)
#define EP93XX_TIMER123_RATE 508469
#define EP93XX_TIMER4_RATE 983040
static u64 notrace ep93xx_read_sched_clock(void)
{
u64 ret;
ret = readl(EP93XX_TIMER4_VALUE_LOW);
ret |= ((u64) (readl(EP93XX_TIMER4_VALUE_HIGH) & 0xff) << 32);
return ret;
}
cycle_t ep93xx_clocksource_read(struct clocksource *c)
{
u64 ret;
ret = readl(EP93XX_TIMER4_VALUE_LOW);
ret |= ((u64) (readl(EP93XX_TIMER4_VALUE_HIGH) & 0xff) << 32);
return (cycle_t) ret;
}
static int ep93xx_clkevt_set_next_event(unsigned long next,
struct clock_event_device *evt)
{
/* Default mode: periodic, off, 508 kHz */
u32 tmode = EP93XX_TIMER123_CONTROL_MODE |
EP93XX_TIMER123_CONTROL_CLKSEL;
/* Clear timer */
writel(tmode, EP93XX_TIMER3_CONTROL);
/* Set next event */
writel(next, EP93XX_TIMER3_LOAD);
writel(tmode | EP93XX_TIMER123_CONTROL_ENABLE,
EP93XX_TIMER3_CONTROL);
return 0;
}
static int ep93xx_clkevt_shutdown(struct clock_event_device *evt)
{
/* Disable timer */
writel(0, EP93XX_TIMER3_CONTROL);
return 0;
}
static struct clock_event_device ep93xx_clockevent = {
.name = "timer1",
.features = CLOCK_EVT_FEAT_ONESHOT,
.set_state_shutdown = ep93xx_clkevt_shutdown,
.set_state_oneshot = ep93xx_clkevt_shutdown,
.tick_resume = ep93xx_clkevt_shutdown,
.set_next_event = ep93xx_clkevt_set_next_event,
.rating = 300,
};
static irqreturn_t ep93xx_timer_interrupt(int irq, void *dev_id)
{
struct clock_event_device *evt = dev_id;
/* Writing any value clears the timer interrupt */
writel(1, EP93XX_TIMER3_CLEAR);
evt->event_handler(evt);
return IRQ_HANDLED;
}
static struct irqaction ep93xx_timer_irq = {
.name = "ep93xx timer",
.flags = IRQF_TIMER | IRQF_IRQPOLL,
.handler = ep93xx_timer_interrupt,
.dev_id = &ep93xx_clockevent,
};
void __init ep93xx_timer_init(void)
{
/* Enable and register clocksource and sched_clock on timer 4 */
writel(EP93XX_TIMER4_VALUE_HIGH_ENABLE,
EP93XX_TIMER4_VALUE_HIGH);
clocksource_mmio_init(NULL, "timer4",
EP93XX_TIMER4_RATE, 200, 40,
ep93xx_clocksource_read);
sched_clock_register(ep93xx_read_sched_clock, 40,
EP93XX_TIMER4_RATE);
/* Set up clockevent on timer 3 */
setup_irq(IRQ_EP93XX_TIMER3, &ep93xx_timer_irq);
clockevents_config_and_register(&ep93xx_clockevent,
EP93XX_TIMER123_RATE,
1,
0xffffffffU);
}

View file

@ -29,6 +29,8 @@
#include <linux/spi/mmc_spi.h> #include <linux/spi/mmc_spi.h>
#include <linux/mmc/host.h> #include <linux/mmc/host.h>
#include <sound/cs4271.h>
#include <mach/hardware.h> #include <mach/hardware.h>
#include <linux/platform_data/video-ep93xx.h> #include <linux/platform_data/video-ep93xx.h>
#include <linux/platform_data/spi-ep93xx.h> #include <linux/platform_data/spi-ep93xx.h>
@ -104,8 +106,6 @@ static void vision_lcd_blank(int blank_mode, struct fb_info *info)
} }
static struct ep93xxfb_mach_info ep93xxfb_info __initdata = { static struct ep93xxfb_mach_info ep93xxfb_info __initdata = {
.num_modes = EP93XXFB_USE_MODEDB,
.bpp = 16,
.flags = EP93XXFB_USE_SDCSN0 | EP93XXFB_PCLK_FALLING, .flags = EP93XXFB_USE_SDCSN0 | EP93XXFB_PCLK_FALLING,
.setup = vision_lcd_setup, .setup = vision_lcd_setup,
.teardown = vision_lcd_teardown, .teardown = vision_lcd_teardown,
@ -168,6 +168,35 @@ static struct i2c_board_info vision_i2c_info[] __initdata = {
}, },
}; };
/*************************************************************************
* SPI CS4271 Audio Codec
*************************************************************************/
static struct cs4271_platform_data vision_cs4271_data = {
.gpio_nreset = EP93XX_GPIO_LINE_H(2),
};
static int vision_cs4271_hw_setup(struct spi_device *spi)
{
return gpio_request_one(EP93XX_GPIO_LINE_EGPIO6,
GPIOF_OUT_INIT_HIGH, spi->modalias);
}
static void vision_cs4271_hw_cleanup(struct spi_device *spi)
{
gpio_free(EP93XX_GPIO_LINE_EGPIO6);
}
static void vision_cs4271_hw_cs_control(struct spi_device *spi, int value)
{
gpio_set_value(EP93XX_GPIO_LINE_EGPIO6, value);
}
static struct ep93xx_spi_chip_ops vision_cs4271_hw = {
.setup = vision_cs4271_hw_setup,
.cleanup = vision_cs4271_hw_cleanup,
.cs_control = vision_cs4271_hw_cs_control,
};
/************************************************************************* /*************************************************************************
* SPI Flash * SPI Flash
*************************************************************************/ *************************************************************************/
@ -262,12 +291,20 @@ static struct ep93xx_spi_chip_ops vision_spi_mmc_hw = {
*************************************************************************/ *************************************************************************/
static struct spi_board_info vision_spi_board_info[] __initdata = { static struct spi_board_info vision_spi_board_info[] __initdata = {
{ {
.modalias = "cs4271",
.platform_data = &vision_cs4271_data,
.controller_data = &vision_cs4271_hw,
.max_speed_hz = 6000000,
.bus_num = 0,
.chip_select = 0,
.mode = SPI_MODE_3,
}, {
.modalias = "sst25l", .modalias = "sst25l",
.platform_data = &vision_spi_flash_data, .platform_data = &vision_spi_flash_data,
.controller_data = &vision_spi_flash_hw, .controller_data = &vision_spi_flash_hw,
.max_speed_hz = 20000000, .max_speed_hz = 20000000,
.bus_num = 0, .bus_num = 0,
.chip_select = 0, .chip_select = 1,
.mode = SPI_MODE_3, .mode = SPI_MODE_3,
}, { }, {
.modalias = "mmc_spi", .modalias = "mmc_spi",
@ -275,15 +312,30 @@ static struct spi_board_info vision_spi_board_info[] __initdata = {
.controller_data = &vision_spi_mmc_hw, .controller_data = &vision_spi_mmc_hw,
.max_speed_hz = 20000000, .max_speed_hz = 20000000,
.bus_num = 0, .bus_num = 0,
.chip_select = 1, .chip_select = 2,
.mode = SPI_MODE_3, .mode = SPI_MODE_3,
}, },
}; };
static struct ep93xx_spi_info vision_spi_master __initdata = { static struct ep93xx_spi_info vision_spi_master __initdata = {
.num_chipselect = ARRAY_SIZE(vision_spi_board_info), .num_chipselect = ARRAY_SIZE(vision_spi_board_info),
.use_dma = 1,
}; };
/*************************************************************************
* I2S Audio
*************************************************************************/
static struct platform_device vision_audio_device = {
.name = "edb93xx-audio",
.id = -1,
};
static void __init vision_register_i2s(void)
{
ep93xx_register_i2s();
platform_device_register(&vision_audio_device);
}
/************************************************************************* /*************************************************************************
* Machine Initialization * Machine Initialization
*************************************************************************/ *************************************************************************/
@ -309,6 +361,7 @@ static void __init vision_init_machine(void)
ARRAY_SIZE(vision_i2c_info)); ARRAY_SIZE(vision_i2c_info));
ep93xx_register_spi(&vision_spi_master, vision_spi_board_info, ep93xx_register_spi(&vision_spi_master, vision_spi_board_info,
ARRAY_SIZE(vision_spi_board_info)); ARRAY_SIZE(vision_spi_board_info));
vision_register_i2s();
} }
MACHINE_START(VISION_EP9307, "Vision Engraving Systems EP9307") MACHINE_START(VISION_EP9307, "Vision Engraving Systems EP9307")

View file

@ -30,6 +30,11 @@ menuconfig ARCH_EXYNOS
if ARCH_EXYNOS if ARCH_EXYNOS
config S5P_DEV_MFC
bool
help
Compile in setup memory (init) code for MFC
config ARCH_EXYNOS3 config ARCH_EXYNOS3
bool "SAMSUNG EXYNOS3" bool "SAMSUNG EXYNOS3"
select ARM_CPU_SUSPEND if PM select ARM_CPU_SUSPEND if PM

View file

@ -23,3 +23,5 @@ AFLAGS_sleep.o :=-Wa,-march=armv7-a$(plus_sec)
obj-$(CONFIG_EXYNOS5420_MCPM) += mcpm-exynos.o obj-$(CONFIG_EXYNOS5420_MCPM) += mcpm-exynos.o
CFLAGS_mcpm-exynos.o += -march=armv7-a CFLAGS_mcpm-exynos.o += -march=armv7-a
obj-$(CONFIG_S5P_DEV_MFC) += s5p-dev-mfc.o

View file

@ -128,6 +128,12 @@ void exynos_firmware_init(void);
/* CPU BOOT mode flag for Exynos3250 SoC bootloader */ /* CPU BOOT mode flag for Exynos3250 SoC bootloader */
#define C2_STATE (1 << 3) #define C2_STATE (1 << 3)
/*
* Magic values for bootloader indicating chosen low power mode.
* See also Documentation/arm/Samsung/Bootloader-interface.txt
*/
#define EXYNOS_SLEEP_MAGIC 0x00000bad
#define EXYNOS_AFTR_MAGIC 0xfcba0d10
void exynos_set_boot_flag(unsigned int cpu, unsigned int mode); void exynos_set_boot_flag(unsigned int cpu, unsigned int mode);
void exynos_clear_boot_flag(unsigned int cpu, unsigned int mode); void exynos_clear_boot_flag(unsigned int cpu, unsigned int mode);

View file

@ -25,8 +25,6 @@
#include "common.h" #include "common.h"
#include "smc.h" #include "smc.h"
#define EXYNOS_SLEEP_MAGIC 0x00000bad
#define EXYNOS_AFTR_MAGIC 0xfcba0d10
#define EXYNOS_BOOT_ADDR 0x8 #define EXYNOS_BOOT_ADDR 0x8
#define EXYNOS_BOOT_FLAG 0xc #define EXYNOS_BOOT_FLAG 0xc

View file

@ -698,7 +698,7 @@ static void exynos_power_off(void)
; ;
} }
void exynos5420_powerdown_conf(enum sys_powerdown mode) static void exynos5420_powerdown_conf(enum sys_powerdown mode)
{ {
u32 this_cluster; u32 this_cluster;
@ -991,7 +991,6 @@ static int exynos_pmu_probe(struct platform_device *pdev)
static struct platform_driver exynos_pmu_driver = { static struct platform_driver exynos_pmu_driver = {
.driver = { .driver = {
.name = "exynos-pmu", .name = "exynos-pmu",
.owner = THIS_MODULE,
.of_match_table = exynos_pmu_of_device_ids, .of_match_table = exynos_pmu_of_device_ids,
}, },
.probe = exynos_pmu_probe, .probe = exynos_pmu_probe,

View file

@ -1,5 +1,4 @@
/* linux/arch/arm/plat-samsung/include/plat/regs-srom.h /*
*
* Copyright (c) 2010 Samsung Electronics Co., Ltd. * Copyright (c) 2010 Samsung Electronics Co., Ltd.
* http://www.samsung.com * http://www.samsung.com
* *

View file

@ -32,13 +32,11 @@
#include <asm/suspend.h> #include <asm/suspend.h>
#include <plat/pm-common.h> #include <plat/pm-common.h>
#include <plat/regs-srom.h>
#include "common.h" #include "common.h"
#include "regs-pmu.h"
#include "exynos-pmu.h" #include "exynos-pmu.h"
#include "regs-pmu.h"
#define S5P_CHECK_SLEEP 0x00000BAD #include "regs-srom.h"
#define REG_TABLE_END (-1U) #define REG_TABLE_END (-1U)
@ -331,7 +329,7 @@ static void exynos_pm_enter_sleep_mode(void)
{ {
/* Set value of power down register for sleep mode */ /* Set value of power down register for sleep mode */
exynos_sys_powerdown_conf(SYS_SLEEP); exynos_sys_powerdown_conf(SYS_SLEEP);
pmu_raw_writel(S5P_CHECK_SLEEP, S5P_INFORM1); pmu_raw_writel(EXYNOS_SLEEP_MAGIC, S5P_INFORM1);
} }
static void exynos_pm_prepare(void) static void exynos_pm_prepare(void)

View file

@ -106,7 +106,7 @@ static void __init __fb_init_irq(void)
for (irq = _DC21285_IRQ(0); irq < _DC21285_IRQ(20); irq++) { for (irq = _DC21285_IRQ(0); irq < _DC21285_IRQ(20); irq++) {
irq_set_chip_and_handler(irq, &fb_chip, handle_level_irq); irq_set_chip_and_handler(irq, &fb_chip, handle_level_irq);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); irq_clear_status_flags(irq, IRQ_NOREQUEST | IRQ_NOPROBE);
} }
} }

View file

@ -57,34 +57,32 @@ static int ckevt_dc21285_set_next_event(unsigned long delta,
return 0; return 0;
} }
static void ckevt_dc21285_set_mode(enum clock_event_mode mode, static int ckevt_dc21285_shutdown(struct clock_event_device *c)
struct clock_event_device *c)
{ {
switch (mode) { *CSR_TIMER1_CNTL = 0;
case CLOCK_EVT_MODE_RESUME: return 0;
case CLOCK_EVT_MODE_PERIODIC: }
*CSR_TIMER1_CLR = 0;
*CSR_TIMER1_LOAD = (mem_fclk_21285 + 8 * HZ) / (16 * HZ);
*CSR_TIMER1_CNTL = TIMER_CNTL_ENABLE | TIMER_CNTL_AUTORELOAD |
TIMER_CNTL_DIV16;
break;
case CLOCK_EVT_MODE_ONESHOT: static int ckevt_dc21285_set_periodic(struct clock_event_device *c)
case CLOCK_EVT_MODE_UNUSED: {
case CLOCK_EVT_MODE_SHUTDOWN: *CSR_TIMER1_CLR = 0;
*CSR_TIMER1_CNTL = 0; *CSR_TIMER1_LOAD = (mem_fclk_21285 + 8 * HZ) / (16 * HZ);
break; *CSR_TIMER1_CNTL = TIMER_CNTL_ENABLE | TIMER_CNTL_AUTORELOAD |
} TIMER_CNTL_DIV16;
return 0;
} }
static struct clock_event_device ckevt_dc21285 = { static struct clock_event_device ckevt_dc21285 = {
.name = "dc21285_timer1", .name = "dc21285_timer1",
.features = CLOCK_EVT_FEAT_PERIODIC | .features = CLOCK_EVT_FEAT_PERIODIC |
CLOCK_EVT_FEAT_ONESHOT, CLOCK_EVT_FEAT_ONESHOT,
.rating = 200, .rating = 200,
.irq = IRQ_TIMER1, .irq = IRQ_TIMER1,
.set_next_event = ckevt_dc21285_set_next_event, .set_next_event = ckevt_dc21285_set_next_event,
.set_mode = ckevt_dc21285_set_mode, .set_state_shutdown = ckevt_dc21285_shutdown,
.set_state_periodic = ckevt_dc21285_set_periodic,
.set_state_oneshot = ckevt_dc21285_shutdown,
.tick_resume = ckevt_dc21285_set_periodic,
}; };
static irqreturn_t timer1_interrupt(int irq, void *dev_id) static irqreturn_t timer1_interrupt(int irq, void *dev_id)
@ -94,7 +92,7 @@ static irqreturn_t timer1_interrupt(int irq, void *dev_id)
*CSR_TIMER1_CLR = 0; *CSR_TIMER1_CLR = 0;
/* Stop the timer if in one-shot mode */ /* Stop the timer if in one-shot mode */
if (ce->mode == CLOCK_EVT_MODE_ONESHOT) if (clockevent_state_oneshot(ce))
*CSR_TIMER1_CNTL = 0; *CSR_TIMER1_CNTL = 0;
ce->event_handler(ce); ce->event_handler(ce);

View file

@ -153,13 +153,13 @@ void __init isa_init_irq(unsigned int host_irq)
for (irq = _ISA_IRQ(0); irq < _ISA_IRQ(8); irq++) { for (irq = _ISA_IRQ(0); irq < _ISA_IRQ(8); irq++) {
irq_set_chip_and_handler(irq, &isa_lo_chip, irq_set_chip_and_handler(irq, &isa_lo_chip,
handle_level_irq); handle_level_irq);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); irq_clear_status_flags(irq, IRQ_NOREQUEST | IRQ_NOPROBE);
} }
for (irq = _ISA_IRQ(8); irq < _ISA_IRQ(16); irq++) { for (irq = _ISA_IRQ(8); irq < _ISA_IRQ(16); irq++) {
irq_set_chip_and_handler(irq, &isa_hi_chip, irq_set_chip_and_handler(irq, &isa_hi_chip,
handle_level_irq); handle_level_irq);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); irq_clear_status_flags(irq, IRQ_NOREQUEST | IRQ_NOPROBE);
} }
request_resource(&ioport_resource, &pic1_resource); request_resource(&ioport_resource, &pic1_resource);
@ -175,8 +175,8 @@ void __init isa_init_irq(unsigned int host_irq)
* resistor on this line. * resistor on this line.
*/ */
if (machine_is_netwinder()) if (machine_is_netwinder())
set_irq_flags(_ISA_IRQ(11), IRQF_VALID | irq_modify_status(_ISA_IRQ(11),
IRQF_PROBE | IRQF_NOAUTOEN); IRQ_NOREQUEST | IRQ_NOPROBE, IRQ_NOAUTOEN);
} }
} }

View file

@ -220,7 +220,7 @@ void __init gemini_gpio_init(void)
j < GPIO_IRQ_BASE + (i + 1) * 32; j++) { j < GPIO_IRQ_BASE + (i + 1) * 32; j++) {
irq_set_chip_and_handler(j, &gpio_irq_chip, irq_set_chip_and_handler(j, &gpio_irq_chip,
handle_edge_irq); handle_edge_irq);
set_irq_flags(j, IRQF_VALID); irq_clear_status_flags(j, IRQ_NOREQUEST);
} }
irq_set_chained_handler_and_data(IRQ_GPIO(i), gpio_irq_handler, irq_set_chained_handler_and_data(IRQ_GPIO(i), gpio_irq_handler,

View file

@ -57,9 +57,6 @@
#define GEMINI_USB1_BASE 0x69000000 #define GEMINI_USB1_BASE 0x69000000
#define GEMINI_BIG_ENDIAN_BASE 0x80000000 #define GEMINI_BIG_ENDIAN_BASE 0x80000000
#define GEMINI_TIMER1_BASE GEMINI_TIMER_BASE
#define GEMINI_TIMER2_BASE (GEMINI_TIMER_BASE + 0x10)
#define GEMINI_TIMER3_BASE (GEMINI_TIMER_BASE + 0x20)
/* /*
* UART Clock when System clk is 150MHz * UART Clock when System clk is 150MHz

View file

@ -92,7 +92,7 @@ void __init gemini_init_irq(void)
} else { } else {
irq_set_handler(i, handle_level_irq); irq_set_handler(i, handle_level_irq);
} }
set_irq_flags(i, IRQF_VALID | IRQF_PROBE); irq_clear_status_flags(i, IRQ_NOREQUEST | IRQ_NOPROBE);
} }
/* Disable all interrupts */ /* Disable all interrupts */

View file

@ -15,93 +15,147 @@
#include <asm/mach/time.h> #include <asm/mach/time.h>
#include <linux/clockchips.h> #include <linux/clockchips.h>
#include <linux/clocksource.h> #include <linux/clocksource.h>
#include <linux/sched_clock.h>
/* /*
* Register definitions for the timers * Register definitions for the timers
*/ */
#define TIMER_COUNT(BASE_ADDR) (BASE_ADDR + 0x00)
#define TIMER_LOAD(BASE_ADDR) (BASE_ADDR + 0x04)
#define TIMER_MATCH1(BASE_ADDR) (BASE_ADDR + 0x08)
#define TIMER_MATCH2(BASE_ADDR) (BASE_ADDR + 0x0C)
#define TIMER_CR(BASE_ADDR) (BASE_ADDR + 0x30)
#define TIMER_1_CR_ENABLE (1 << 0) #define TIMER1_BASE GEMINI_TIMER_BASE
#define TIMER_1_CR_CLOCK (1 << 1) #define TIMER2_BASE (GEMINI_TIMER_BASE + 0x10)
#define TIMER_1_CR_INT (1 << 2) #define TIMER3_BASE (GEMINI_TIMER_BASE + 0x20)
#define TIMER_2_CR_ENABLE (1 << 3)
#define TIMER_2_CR_CLOCK (1 << 4) #define TIMER_COUNT(BASE) (IO_ADDRESS(BASE) + 0x00)
#define TIMER_2_CR_INT (1 << 5) #define TIMER_LOAD(BASE) (IO_ADDRESS(BASE) + 0x04)
#define TIMER_3_CR_ENABLE (1 << 6) #define TIMER_MATCH1(BASE) (IO_ADDRESS(BASE) + 0x08)
#define TIMER_3_CR_CLOCK (1 << 7) #define TIMER_MATCH2(BASE) (IO_ADDRESS(BASE) + 0x0C)
#define TIMER_3_CR_INT (1 << 8) #define TIMER_CR (IO_ADDRESS(GEMINI_TIMER_BASE) + 0x30)
#define TIMER_INTR_STATE (IO_ADDRESS(GEMINI_TIMER_BASE) + 0x34)
#define TIMER_INTR_MASK (IO_ADDRESS(GEMINI_TIMER_BASE) + 0x38)
#define TIMER_1_CR_ENABLE (1 << 0)
#define TIMER_1_CR_CLOCK (1 << 1)
#define TIMER_1_CR_INT (1 << 2)
#define TIMER_2_CR_ENABLE (1 << 3)
#define TIMER_2_CR_CLOCK (1 << 4)
#define TIMER_2_CR_INT (1 << 5)
#define TIMER_3_CR_ENABLE (1 << 6)
#define TIMER_3_CR_CLOCK (1 << 7)
#define TIMER_3_CR_INT (1 << 8)
#define TIMER_1_CR_UPDOWN (1 << 9)
#define TIMER_2_CR_UPDOWN (1 << 10)
#define TIMER_3_CR_UPDOWN (1 << 11)
#define TIMER_DEFAULT_FLAGS (TIMER_1_CR_UPDOWN | \
TIMER_3_CR_ENABLE | \
TIMER_3_CR_UPDOWN)
#define TIMER_1_INT_MATCH1 (1 << 0)
#define TIMER_1_INT_MATCH2 (1 << 1)
#define TIMER_1_INT_OVERFLOW (1 << 2)
#define TIMER_2_INT_MATCH1 (1 << 3)
#define TIMER_2_INT_MATCH2 (1 << 4)
#define TIMER_2_INT_OVERFLOW (1 << 5)
#define TIMER_3_INT_MATCH1 (1 << 6)
#define TIMER_3_INT_MATCH2 (1 << 7)
#define TIMER_3_INT_OVERFLOW (1 << 8)
#define TIMER_INT_ALL_MASK 0x1ff
static unsigned int tick_rate; static unsigned int tick_rate;
static u64 notrace gemini_read_sched_clock(void)
{
return readl(TIMER_COUNT(TIMER3_BASE));
}
static int gemini_timer_set_next_event(unsigned long cycles, static int gemini_timer_set_next_event(unsigned long cycles,
struct clock_event_device *evt) struct clock_event_device *evt)
{ {
u32 cr; u32 cr;
cr = readl(TIMER_CR(IO_ADDRESS(GEMINI_TIMER_BASE))); /* Setup the match register */
cr = readl(TIMER_COUNT(TIMER1_BASE));
/* This may be overdoing it, feel free to test without this */ writel(cr + cycles, TIMER_MATCH1(TIMER1_BASE));
cr &= ~TIMER_2_CR_ENABLE; if (readl(TIMER_COUNT(TIMER1_BASE)) - cr > cycles)
cr &= ~TIMER_2_CR_INT; return -ETIME;
writel(cr, TIMER_CR(IO_ADDRESS(GEMINI_TIMER_BASE)));
/* Set next event */
writel(cycles, TIMER_COUNT(IO_ADDRESS(GEMINI_TIMER2_BASE)));
writel(cycles, TIMER_LOAD(IO_ADDRESS(GEMINI_TIMER2_BASE)));
cr |= TIMER_2_CR_ENABLE;
cr |= TIMER_2_CR_INT;
writel(cr, TIMER_CR(IO_ADDRESS(GEMINI_TIMER_BASE)));
return 0; return 0;
} }
static void gemini_timer_set_mode(enum clock_event_mode mode, static int gemini_timer_shutdown(struct clock_event_device *evt)
struct clock_event_device *evt) {
u32 cr;
/*
* Disable also for oneshot: the set_next() call will arm the timer
* instead.
*/
/* Stop timer and interrupt. */
cr = readl(TIMER_CR);
cr &= ~(TIMER_1_CR_ENABLE | TIMER_1_CR_INT);
writel(cr, TIMER_CR);
/* Setup counter start from 0 */
writel(0, TIMER_COUNT(TIMER1_BASE));
writel(0, TIMER_LOAD(TIMER1_BASE));
/* enable interrupt */
cr = readl(TIMER_INTR_MASK);
cr &= ~(TIMER_1_INT_OVERFLOW | TIMER_1_INT_MATCH2);
cr |= TIMER_1_INT_MATCH1;
writel(cr, TIMER_INTR_MASK);
/* start the timer */
cr = readl(TIMER_CR);
cr |= TIMER_1_CR_ENABLE;
writel(cr, TIMER_CR);
return 0;
}
static int gemini_timer_set_periodic(struct clock_event_device *evt)
{ {
u32 period = DIV_ROUND_CLOSEST(tick_rate, HZ); u32 period = DIV_ROUND_CLOSEST(tick_rate, HZ);
u32 cr; u32 cr;
switch (mode) { /* Stop timer and interrupt */
case CLOCK_EVT_MODE_PERIODIC: cr = readl(TIMER_CR);
/* Start the timer */ cr &= ~(TIMER_1_CR_ENABLE | TIMER_1_CR_INT);
writel(period, writel(cr, TIMER_CR);
TIMER_COUNT(IO_ADDRESS(GEMINI_TIMER2_BASE)));
writel(period, /* Setup timer to fire at 1/HT intervals. */
TIMER_LOAD(IO_ADDRESS(GEMINI_TIMER2_BASE))); cr = 0xffffffff - (period - 1);
cr = readl(TIMER_CR(IO_ADDRESS(GEMINI_TIMER_BASE))); writel(cr, TIMER_COUNT(TIMER1_BASE));
cr |= TIMER_2_CR_ENABLE; writel(cr, TIMER_LOAD(TIMER1_BASE));
cr |= TIMER_2_CR_INT;
writel(cr, TIMER_CR(IO_ADDRESS(GEMINI_TIMER_BASE))); /* enable interrupt on overflow */
break; cr = readl(TIMER_INTR_MASK);
case CLOCK_EVT_MODE_ONESHOT: cr &= ~(TIMER_1_INT_MATCH1 | TIMER_1_INT_MATCH2);
case CLOCK_EVT_MODE_UNUSED: cr |= TIMER_1_INT_OVERFLOW;
case CLOCK_EVT_MODE_SHUTDOWN: writel(cr, TIMER_INTR_MASK);
case CLOCK_EVT_MODE_RESUME:
/* /* Start the timer */
* Disable also for oneshot: the set_next() call will cr = readl(TIMER_CR);
* arm the timer instead. cr |= TIMER_1_CR_ENABLE;
*/ cr |= TIMER_1_CR_INT;
cr = readl(TIMER_CR(IO_ADDRESS(GEMINI_TIMER_BASE))); writel(cr, TIMER_CR);
cr &= ~TIMER_2_CR_ENABLE;
cr &= ~TIMER_2_CR_INT; return 0;
writel(cr, TIMER_CR(IO_ADDRESS(GEMINI_TIMER_BASE)));
break;
default:
break;
}
} }
/* Use TIMER2 as clock event */ /* Use TIMER1 as clock event */
static struct clock_event_device gemini_clockevent = { static struct clock_event_device gemini_clockevent = {
.name = "TIMER2", .name = "TIMER1",
.rating = 300, /* Reasonably fast and accurate clock event */ /* Reasonably fast and accurate clock event */
.features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, .rating = 300,
.set_next_event = gemini_timer_set_next_event, .shift = 32,
.set_mode = gemini_timer_set_mode, .features = CLOCK_EVT_FEAT_PERIODIC |
CLOCK_EVT_FEAT_ONESHOT,
.set_next_event = gemini_timer_set_next_event,
.set_state_shutdown = gemini_timer_shutdown,
.set_state_periodic = gemini_timer_set_periodic,
.set_state_oneshot = gemini_timer_shutdown,
.tick_resume = gemini_timer_shutdown,
}; };
/* /*
@ -151,20 +205,35 @@ void __init gemini_timer_init(void)
} }
/* /*
* Make irqs happen for the system timer * Reset the interrupt mask and status
*/ */
setup_irq(IRQ_TIMER2, &gemini_timer_irq); writel(TIMER_INT_ALL_MASK, TIMER_INTR_MASK);
writel(0, TIMER_INTR_STATE);
writel(TIMER_DEFAULT_FLAGS, TIMER_CR);
/* Enable and use TIMER1 as clock source */ /*
writel(0xffffffff, TIMER_COUNT(IO_ADDRESS(GEMINI_TIMER1_BASE))); * Setup free-running clocksource timer (interrupts
writel(0xffffffff, TIMER_LOAD(IO_ADDRESS(GEMINI_TIMER1_BASE))); * disabled.)
writel(TIMER_1_CR_ENABLE, TIMER_CR(IO_ADDRESS(GEMINI_TIMER_BASE))); */
if (clocksource_mmio_init(TIMER_COUNT(IO_ADDRESS(GEMINI_TIMER1_BASE)), writel(0, TIMER_COUNT(TIMER3_BASE));
"TIMER1", tick_rate, 300, 32, writel(0, TIMER_LOAD(TIMER3_BASE));
clocksource_mmio_readl_up)) writel(0, TIMER_MATCH1(TIMER3_BASE));
pr_err("timer: failed to initialize gemini clock source\n"); writel(0, TIMER_MATCH2(TIMER3_BASE));
clocksource_mmio_init(TIMER_COUNT(TIMER3_BASE),
"gemini_clocksource", tick_rate,
300, 32, clocksource_mmio_readl_up);
sched_clock_register(gemini_read_sched_clock, 32, tick_rate);
/* Configure and register the clockevent */ /*
* Setup clockevent timer (interrupt-driven.)
*/
writel(0, TIMER_COUNT(TIMER1_BASE));
writel(0, TIMER_LOAD(TIMER1_BASE));
writel(0, TIMER_MATCH1(TIMER1_BASE));
writel(0, TIMER_MATCH2(TIMER1_BASE));
setup_irq(IRQ_TIMER1, &gemini_timer_irq);
gemini_clockevent.cpumask = cpumask_of(0);
clockevents_config_and_register(&gemini_clockevent, tick_rate, clockevents_config_and_register(&gemini_clockevent, tick_rate,
1, 0xffffffff); 1, 0xffffffff);
} }

View file

@ -195,7 +195,7 @@ int __init mxc_expio_init(u32 base, u32 intr_gpio)
for (i = irq_base; i < irq_base + MXC_MAX_EXP_IO_LINES; i++) { for (i = irq_base; i < irq_base + MXC_MAX_EXP_IO_LINES; i++) {
irq_set_chip_and_handler(i, &expio_irq_chip, handle_level_irq); irq_set_chip_and_handler(i, &expio_irq_chip, handle_level_irq);
set_irq_flags(i, IRQF_VALID); irq_clear_status_flags(i, IRQ_NOREQUEST);
} }
irq_set_irq_type(p_irq, IRQF_TRIGGER_LOW); irq_set_irq_type(p_irq, IRQF_TRIGGER_LOW);
irq_set_chained_handler(p_irq, mxc_expio_irq_handler); irq_set_chained_handler(p_irq, mxc_expio_irq_handler);

View file

@ -57,7 +57,6 @@
#include "hardware.h" #include "hardware.h"
static struct clock_event_device clockevent_epit; static struct clock_event_device clockevent_epit;
static enum clock_event_mode clockevent_mode = CLOCK_EVT_MODE_UNUSED;
static void __iomem *timer_base; static void __iomem *timer_base;
@ -106,8 +105,8 @@ static int epit_set_next_event(unsigned long evt,
return 0; return 0;
} }
static void epit_set_mode(enum clock_event_mode mode, /* Left event sources disabled, no more interrupts appear */
struct clock_event_device *evt) static int epit_shutdown(struct clock_event_device *evt)
{ {
unsigned long flags; unsigned long flags;
@ -120,39 +119,41 @@ static void epit_set_mode(enum clock_event_mode mode,
/* Disable interrupt in GPT module */ /* Disable interrupt in GPT module */
epit_irq_disable(); epit_irq_disable();
if (mode != clockevent_mode) { /* Clear pending interrupt */
/* Set event time into far-far future */ epit_irq_acknowledge();
/* Clear pending interrupt */
epit_irq_acknowledge();
}
/* Remember timer mode */
clockevent_mode = mode;
local_irq_restore(flags); local_irq_restore(flags);
switch (mode) { return 0;
case CLOCK_EVT_MODE_PERIODIC: }
printk(KERN_ERR "epit_set_mode: Periodic mode is not "
"supported for i.MX EPIT\n"); static int epit_set_oneshot(struct clock_event_device *evt)
break; {
case CLOCK_EVT_MODE_ONESHOT: unsigned long flags;
/*
* The timer interrupt generation is disabled at least
* for enough time to call epit_set_next_event()
*/
local_irq_save(flags);
/* Disable interrupt in GPT module */
epit_irq_disable();
/* Clear pending interrupt, only while switching mode */
if (!clockevent_state_oneshot(evt))
epit_irq_acknowledge();
/* /*
* Do not put overhead of interrupt enable/disable into * Do not put overhead of interrupt enable/disable into
* epit_set_next_event(), the core has about 4 minutes * epit_set_next_event(), the core has about 4 minutes
* to call epit_set_next_event() or shutdown clock after * to call epit_set_next_event() or shutdown clock after
* mode switching * mode switching
*/ */
local_irq_save(flags); epit_irq_enable();
epit_irq_enable(); local_irq_restore(flags);
local_irq_restore(flags);
break; return 0;
case CLOCK_EVT_MODE_SHUTDOWN:
case CLOCK_EVT_MODE_UNUSED:
case CLOCK_EVT_MODE_RESUME:
/* Left event sources disabled, no more interrupts appear */
break;
}
} }
/* /*
@ -176,11 +177,13 @@ static struct irqaction epit_timer_irq = {
}; };
static struct clock_event_device clockevent_epit = { static struct clock_event_device clockevent_epit = {
.name = "epit", .name = "epit",
.features = CLOCK_EVT_FEAT_ONESHOT, .features = CLOCK_EVT_FEAT_ONESHOT,
.set_mode = epit_set_mode, .set_state_shutdown = epit_shutdown,
.set_next_event = epit_set_next_event, .tick_resume = epit_shutdown,
.rating = 200, .set_state_oneshot = epit_set_oneshot,
.set_next_event = epit_set_next_event,
.rating = 200,
}; };
static int __init epit_clockevent_init(struct clk *timer_clk) static int __init epit_clockevent_init(struct clk *timer_clk)

View file

@ -31,7 +31,7 @@ static void __init imx7d_init_irq(void)
irqchip_init(); irqchip_init();
} }
static const char *imx7d_dt_compat[] __initconst = { static const char *const imx7d_dt_compat[] __initconst = {
"fsl,imx7d", "fsl,imx7d",
NULL, NULL,
}; };

View file

@ -238,7 +238,7 @@ static void __init mx31ads_init_expio(void)
for (i = irq_base; i < irq_base + MXC_MAX_EXP_IO_LINES; i++) { for (i = irq_base; i < irq_base + MXC_MAX_EXP_IO_LINES; i++) {
irq_set_chip_and_handler(i, &expio_irq_chip, handle_level_irq); irq_set_chip_and_handler(i, &expio_irq_chip, handle_level_irq);
set_irq_flags(i, IRQF_VALID); irq_clear_status_flags(i, IRQ_NOREQUEST);
} }
irq = gpio_to_irq(IOMUX_TO_GPIO(MX31_PIN_GPIO1_4)); irq = gpio_to_irq(IOMUX_TO_GPIO(MX31_PIN_GPIO1_4));
irq_set_irq_type(irq, IRQ_TYPE_LEVEL_HIGH); irq_set_irq_type(irq, IRQ_TYPE_LEVEL_HIGH);

View file

@ -233,7 +233,7 @@ void __init iop13xx_init_irq(void)
irq_set_chip(i, &iop13xx_irqchip4); irq_set_chip(i, &iop13xx_irqchip4);
irq_set_handler(i, handle_level_irq); irq_set_handler(i, handle_level_irq);
set_irq_flags(i, IRQF_VALID | IRQF_PROBE); irq_clear_status_flags(i, IRQ_NOREQUEST | IRQ_NOPROBE);
} }
iop13xx_msi_init(); iop13xx_msi_init();

View file

@ -69,6 +69,6 @@ void __init iop32x_init_irq(void)
for (i = 0; i < NR_IRQS; i++) { for (i = 0; i < NR_IRQS; i++) {
irq_set_chip_and_handler(i, &ext_chip, handle_level_irq); irq_set_chip_and_handler(i, &ext_chip, handle_level_irq);
set_irq_flags(i, IRQF_VALID | IRQF_PROBE); irq_clear_status_flags(i, IRQ_NOREQUEST | IRQ_NOPROBE);
} }
} }

View file

@ -113,6 +113,6 @@ void __init iop33x_init_irq(void)
irq_set_chip_and_handler(i, irq_set_chip_and_handler(i,
(i < 32) ? &iop33x_irqchip1 : &iop33x_irqchip2, (i < 32) ? &iop33x_irqchip1 : &iop33x_irqchip2,
handle_level_irq); handle_level_irq);
set_irq_flags(i, IRQF_VALID | IRQF_PROBE); irq_clear_status_flags(i, IRQ_NOREQUEST | IRQ_NOPROBE);
} }
} }

View file

@ -296,7 +296,7 @@ void __init ixp4xx_init_irq(void)
for(i = 0; i < NR_IRQS; i++) { for(i = 0; i < NR_IRQS; i++) {
irq_set_chip_and_handler(i, &ixp4xx_irq_chip, irq_set_chip_and_handler(i, &ixp4xx_irq_chip,
handle_level_irq); handle_level_irq);
set_irq_flags(i, IRQF_VALID); irq_clear_status_flags(i, IRQ_NOREQUEST);
} }
} }
@ -521,43 +521,55 @@ static int ixp4xx_set_next_event(unsigned long evt,
return 0; return 0;
} }
static void ixp4xx_set_mode(enum clock_event_mode mode, static int ixp4xx_shutdown(struct clock_event_device *evt)
struct clock_event_device *evt)
{ {
unsigned long opts = *IXP4XX_OSRT1 & IXP4XX_OST_RELOAD_MASK; unsigned long opts = *IXP4XX_OSRT1 & IXP4XX_OST_RELOAD_MASK;
unsigned long osrt = *IXP4XX_OSRT1 & ~IXP4XX_OST_RELOAD_MASK; unsigned long osrt = *IXP4XX_OSRT1 & ~IXP4XX_OST_RELOAD_MASK;
switch (mode) { opts &= ~IXP4XX_OST_ENABLE;
case CLOCK_EVT_MODE_PERIODIC: *IXP4XX_OSRT1 = osrt | opts;
osrt = IXP4XX_LATCH & ~IXP4XX_OST_RELOAD_MASK; return 0;
opts = IXP4XX_OST_ENABLE; }
break;
case CLOCK_EVT_MODE_ONESHOT: static int ixp4xx_set_oneshot(struct clock_event_device *evt)
/* period set by 'set next_event' */ {
osrt = 0; unsigned long opts = IXP4XX_OST_ENABLE | IXP4XX_OST_ONE_SHOT;
opts = IXP4XX_OST_ENABLE | IXP4XX_OST_ONE_SHOT; unsigned long osrt = 0;
break;
case CLOCK_EVT_MODE_SHUTDOWN: /* period set by 'set next_event' */
opts &= ~IXP4XX_OST_ENABLE; *IXP4XX_OSRT1 = osrt | opts;
break; return 0;
case CLOCK_EVT_MODE_RESUME: }
opts |= IXP4XX_OST_ENABLE;
break; static int ixp4xx_set_periodic(struct clock_event_device *evt)
case CLOCK_EVT_MODE_UNUSED: {
default: unsigned long opts = IXP4XX_OST_ENABLE;
osrt = opts = 0; unsigned long osrt = IXP4XX_LATCH & ~IXP4XX_OST_RELOAD_MASK;
break;
}
*IXP4XX_OSRT1 = osrt | opts; *IXP4XX_OSRT1 = osrt | opts;
return 0;
}
static int ixp4xx_resume(struct clock_event_device *evt)
{
unsigned long opts = *IXP4XX_OSRT1 & IXP4XX_OST_RELOAD_MASK;
unsigned long osrt = *IXP4XX_OSRT1 & ~IXP4XX_OST_RELOAD_MASK;
opts |= IXP4XX_OST_ENABLE;
*IXP4XX_OSRT1 = osrt | opts;
return 0;
} }
static struct clock_event_device clockevent_ixp4xx = { static struct clock_event_device clockevent_ixp4xx = {
.name = "ixp4xx timer1", .name = "ixp4xx timer1",
.features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, .features = CLOCK_EVT_FEAT_PERIODIC |
.rating = 200, CLOCK_EVT_FEAT_ONESHOT,
.set_mode = ixp4xx_set_mode, .rating = 200,
.set_next_event = ixp4xx_set_next_event, .set_state_shutdown = ixp4xx_shutdown,
.set_state_periodic = ixp4xx_set_periodic,
.set_state_oneshot = ixp4xx_set_oneshot,
.tick_resume = ixp4xx_resume,
.set_next_event = ixp4xx_set_next_event,
}; };
static void __init ixp4xx_clockevent_init(void) static void __init ixp4xx_clockevent_init(void)

View file

@ -172,6 +172,6 @@ void __init ks8695_init_irq(void)
handle_edge_irq); handle_edge_irq);
} }
set_irq_flags(irq, IRQF_VALID); irq_clear_status_flags(irq, IRQ_NOREQUEST);
} }
} }

View file

@ -54,28 +54,25 @@
/* Timer0 Timeout Counter Register */ /* Timer0 Timeout Counter Register */
#define T0TC_WATCHDOG (0xff) /* Enable watchdog mode */ #define T0TC_WATCHDOG (0xff) /* Enable watchdog mode */
static void ks8695_set_mode(enum clock_event_mode mode, static int ks8695_set_periodic(struct clock_event_device *evt)
struct clock_event_device *evt)
{ {
u32 rate = DIV_ROUND_CLOSEST(KS8695_CLOCK_RATE, HZ);
u32 half = DIV_ROUND_CLOSEST(rate, 2);
u32 tmcon; u32 tmcon;
if (mode == CLOCK_EVT_FEAT_PERIODIC) { /* Disable timer 1 */
u32 rate = DIV_ROUND_CLOSEST(KS8695_CLOCK_RATE, HZ); tmcon = readl_relaxed(KS8695_TMR_VA + KS8695_TMCON);
u32 half = DIV_ROUND_CLOSEST(rate, 2); tmcon &= ~TMCON_T1EN;
writel_relaxed(tmcon, KS8695_TMR_VA + KS8695_TMCON);
/* Disable timer 1 */ /* Both registers need to count down */
tmcon = readl_relaxed(KS8695_TMR_VA + KS8695_TMCON); writel_relaxed(half, KS8695_TMR_VA + KS8695_T1TC);
tmcon &= ~TMCON_T1EN; writel_relaxed(half, KS8695_TMR_VA + KS8695_T1PD);
writel_relaxed(tmcon, KS8695_TMR_VA + KS8695_TMCON);
/* Both registers need to count down */ /* Re-enable timer1 */
writel_relaxed(half, KS8695_TMR_VA + KS8695_T1TC); tmcon |= TMCON_T1EN;
writel_relaxed(half, KS8695_TMR_VA + KS8695_T1PD); writel_relaxed(tmcon, KS8695_TMR_VA + KS8695_TMCON);
return 0;
/* Re-enable timer1 */
tmcon |= TMCON_T1EN;
writel_relaxed(tmcon, KS8695_TMR_VA + KS8695_TMCON);
}
} }
static int ks8695_set_next_event(unsigned long cycles, static int ks8695_set_next_event(unsigned long cycles,
@ -102,11 +99,13 @@ static int ks8695_set_next_event(unsigned long cycles,
} }
static struct clock_event_device clockevent_ks8695 = { static struct clock_event_device clockevent_ks8695 = {
.name = "ks8695_t1tc", .name = "ks8695_t1tc",
.rating = 300, /* Reasonably fast and accurate clock event */ /* Reasonably fast and accurate clock event */
.features = CLOCK_EVT_FEAT_ONESHOT | CLOCK_EVT_FEAT_PERIODIC, .rating = 300,
.set_next_event = ks8695_set_next_event, .features = CLOCK_EVT_FEAT_ONESHOT |
.set_mode = ks8695_set_mode, CLOCK_EVT_FEAT_PERIODIC,
.set_next_event = ks8695_set_next_event,
.set_state_periodic = ks8695_set_periodic,
}; };
/* /*

View file

@ -283,25 +283,25 @@ static int lpc32xx_set_irq_type(struct irq_data *d, unsigned int type)
case IRQ_TYPE_EDGE_RISING: case IRQ_TYPE_EDGE_RISING:
/* Rising edge sensitive */ /* Rising edge sensitive */
__lpc32xx_set_irq_type(d->hwirq, 1, 1); __lpc32xx_set_irq_type(d->hwirq, 1, 1);
__irq_set_handler_locked(d->irq, handle_edge_irq); irq_set_handler_locked(d, handle_edge_irq);
break; break;
case IRQ_TYPE_EDGE_FALLING: case IRQ_TYPE_EDGE_FALLING:
/* Falling edge sensitive */ /* Falling edge sensitive */
__lpc32xx_set_irq_type(d->hwirq, 0, 1); __lpc32xx_set_irq_type(d->hwirq, 0, 1);
__irq_set_handler_locked(d->irq, handle_edge_irq); irq_set_handler_locked(d, handle_edge_irq);
break; break;
case IRQ_TYPE_LEVEL_LOW: case IRQ_TYPE_LEVEL_LOW:
/* Low level sensitive */ /* Low level sensitive */
__lpc32xx_set_irq_type(d->hwirq, 0, 0); __lpc32xx_set_irq_type(d->hwirq, 0, 0);
__irq_set_handler_locked(d->irq, handle_level_irq); irq_set_handler_locked(d, handle_level_irq);
break; break;
case IRQ_TYPE_LEVEL_HIGH: case IRQ_TYPE_LEVEL_HIGH:
/* High level sensitive */ /* High level sensitive */
__lpc32xx_set_irq_type(d->hwirq, 1, 0); __lpc32xx_set_irq_type(d->hwirq, 1, 0);
__irq_set_handler_locked(d->irq, handle_level_irq); irq_set_handler_locked(d, handle_level_irq);
break; break;
/* Other modes are not supported */ /* Other modes are not supported */
@ -434,7 +434,7 @@ void __init lpc32xx_init_irq(void)
for (i = 0; i < NR_IRQS; i++) { for (i = 0; i < NR_IRQS; i++) {
irq_set_chip_and_handler(i, &lpc32xx_irq_chip, irq_set_chip_and_handler(i, &lpc32xx_irq_chip,
handle_level_irq); handle_level_irq);
set_irq_flags(i, IRQF_VALID); irq_clear_status_flags(i, IRQ_NOREQUEST);
} }
/* Set default mappings */ /* Set default mappings */

View file

@ -212,7 +212,7 @@ static struct lpc32xx_mlc_platform_data lpc32xx_mlc_data = {
.dma_filter = pl08x_filter_id, .dma_filter = pl08x_filter_id,
}; };
static const struct of_dev_auxdata lpc32xx_auxdata_lookup[] __initconst = { static const struct of_dev_auxdata const lpc32xx_auxdata_lookup[] __initconst = {
OF_DEV_AUXDATA("arm,pl022", 0x20084000, "dev:ssp0", NULL), OF_DEV_AUXDATA("arm,pl022", 0x20084000, "dev:ssp0", NULL),
OF_DEV_AUXDATA("arm,pl022", 0x2008C000, "dev:ssp1", NULL), OF_DEV_AUXDATA("arm,pl022", 0x2008C000, "dev:ssp1", NULL),
OF_DEV_AUXDATA("arm,pl110", 0x31040000, "dev:clcd", &lpc32xx_clcd_data), OF_DEV_AUXDATA("arm,pl110", 0x31040000, "dev:clcd", &lpc32xx_clcd_data),
@ -248,7 +248,7 @@ static void __init lpc3250_machine_init(void)
lpc32xx_auxdata_lookup, NULL); lpc32xx_auxdata_lookup, NULL);
} }
static char const *lpc32xx_dt_compat[] __initdata = { static const char *const lpc32xx_dt_compat[] __initconst = {
"nxp,lpc3220", "nxp,lpc3220",
"nxp,lpc3230", "nxp,lpc3230",
"nxp,lpc3240", "nxp,lpc3240",

View file

@ -43,36 +43,24 @@ static int lpc32xx_clkevt_next_event(unsigned long delta,
return 0; return 0;
} }
static void lpc32xx_clkevt_mode(enum clock_event_mode mode, static int lpc32xx_shutdown(struct clock_event_device *evt)
struct clock_event_device *dev)
{ {
switch (mode) { /*
case CLOCK_EVT_MODE_PERIODIC: * Disable the timer. When using oneshot, we must also
WARN_ON(1); * disable the timer to wait for the first call to
break; * set_next_event().
*/
case CLOCK_EVT_MODE_ONESHOT: __raw_writel(0, LPC32XX_TIMER_TCR(LPC32XX_TIMER0_BASE));
case CLOCK_EVT_MODE_SHUTDOWN: return 0;
/*
* Disable the timer. When using oneshot, we must also
* disable the timer to wait for the first call to
* set_next_event().
*/
__raw_writel(0, LPC32XX_TIMER_TCR(LPC32XX_TIMER0_BASE));
break;
case CLOCK_EVT_MODE_UNUSED:
case CLOCK_EVT_MODE_RESUME:
break;
}
} }
static struct clock_event_device lpc32xx_clkevt = { static struct clock_event_device lpc32xx_clkevt = {
.name = "lpc32xx_clkevt", .name = "lpc32xx_clkevt",
.features = CLOCK_EVT_FEAT_ONESHOT, .features = CLOCK_EVT_FEAT_ONESHOT,
.rating = 300, .rating = 300,
.set_next_event = lpc32xx_clkevt_next_event, .set_next_event = lpc32xx_clkevt_next_event,
.set_mode = lpc32xx_clkevt_mode, .set_state_shutdown = lpc32xx_shutdown,
.set_state_oneshot = lpc32xx_shutdown,
}; };
static irqreturn_t lpc32xx_timer_interrupt(int irq, void *dev_id) static irqreturn_t lpc32xx_timer_interrupt(int irq, void *dev_id)

View file

@ -20,12 +20,12 @@
extern void __init mmp_dt_init_timer(void); extern void __init mmp_dt_init_timer(void);
static const char *pxa168_dt_board_compat[] __initdata = { static const char *const pxa168_dt_board_compat[] __initconst = {
"mrvl,pxa168-aspenite", "mrvl,pxa168-aspenite",
NULL, NULL,
}; };
static const char *pxa910_dt_board_compat[] __initdata = { static const char *const pxa910_dt_board_compat[] __initconst = {
"mrvl,pxa910-dkb", "mrvl,pxa910-dkb",
NULL, NULL,
}; };

View file

@ -30,7 +30,7 @@ static void __init mmp_init_time(void)
of_clk_init(NULL); of_clk_init(NULL);
} }
static const char *mmp2_dt_board_compat[] __initdata = { static const char *const mmp2_dt_board_compat[] __initconst = {
"mrvl,mmp2-brownstone", "mrvl,mmp2-brownstone",
NULL, NULL,
}; };

View file

@ -124,32 +124,25 @@ static int timer_set_next_event(unsigned long delta,
return 0; return 0;
} }
static void timer_set_mode(enum clock_event_mode mode, static int timer_set_shutdown(struct clock_event_device *evt)
struct clock_event_device *dev)
{ {
unsigned long flags; unsigned long flags;
local_irq_save(flags); local_irq_save(flags);
switch (mode) { /* disable the matching interrupt */
case CLOCK_EVT_MODE_ONESHOT: __raw_writel(0x00, mmp_timer_base + TMR_IER(0));
case CLOCK_EVT_MODE_UNUSED:
case CLOCK_EVT_MODE_SHUTDOWN:
/* disable the matching interrupt */
__raw_writel(0x00, mmp_timer_base + TMR_IER(0));
break;
case CLOCK_EVT_MODE_RESUME:
case CLOCK_EVT_MODE_PERIODIC:
break;
}
local_irq_restore(flags); local_irq_restore(flags);
return 0;
} }
static struct clock_event_device ckevt = { static struct clock_event_device ckevt = {
.name = "clockevent", .name = "clockevent",
.features = CLOCK_EVT_FEAT_ONESHOT, .features = CLOCK_EVT_FEAT_ONESHOT,
.rating = 200, .rating = 200,
.set_next_event = timer_set_next_event, .set_next_event = timer_set_next_event,
.set_mode = timer_set_mode, .set_state_shutdown = timer_set_shutdown,
.set_state_oneshot = timer_set_shutdown,
}; };
static cycle_t clksrc_read(struct clocksource *cs) static cycle_t clksrc_read(struct clocksource *cs)

View file

@ -415,7 +415,7 @@ static __init int armada_38x_cpuidle_init(void)
void __iomem *mpsoc_base; void __iomem *mpsoc_base;
u32 reg; u32 reg;
pr_warn("CPU idle is currently broken on Armada 38x: disabling"); pr_warn("CPU idle is currently broken on Armada 38x: disabling\n");
return 0; return 0;
np = of_find_compatible_node(NULL, NULL, np = of_find_compatible_node(NULL, NULL,
@ -486,7 +486,7 @@ static int __init mvebu_v7_cpu_pm_init(void)
*/ */
if (of_machine_is_compatible("marvell,armada380")) { if (of_machine_is_compatible("marvell,armada380")) {
cpu_hotplug_disable(); cpu_hotplug_disable();
pr_warn("CPU hotplug support is currently broken on Armada 38x: disabling"); pr_warn("CPU hotplug support is currently broken on Armada 38x: disabling\n");
} }
if (of_machine_is_compatible("marvell,armadaxp")) if (of_machine_is_compatible("marvell,armadaxp"))

View file

@ -282,7 +282,7 @@ static void __init apx4devkit_init(void)
#define TX28_FEC_PHY_RESET MXS_GPIO_NR(4, 13) #define TX28_FEC_PHY_RESET MXS_GPIO_NR(4, 13)
#define TX28_FEC_nINT MXS_GPIO_NR(4, 5) #define TX28_FEC_nINT MXS_GPIO_NR(4, 5)
static const struct gpio tx28_gpios[] __initconst = { static const struct gpio const tx28_gpios[] __initconst = {
{ ENET0_MDC__GPIO_4_0, GPIOF_OUT_INIT_LOW, "GPIO_4_0" }, { ENET0_MDC__GPIO_4_0, GPIOF_OUT_INIT_LOW, "GPIO_4_0" },
{ ENET0_MDIO__GPIO_4_1, GPIOF_OUT_INIT_LOW, "GPIO_4_1" }, { ENET0_MDIO__GPIO_4_1, GPIOF_OUT_INIT_LOW, "GPIO_4_1" },
{ ENET0_RX_EN__GPIO_4_2, GPIOF_OUT_INIT_LOW, "GPIO_4_2" }, { ENET0_RX_EN__GPIO_4_2, GPIOF_OUT_INIT_LOW, "GPIO_4_2" },
@ -528,7 +528,7 @@ static void mxs_restart(enum reboot_mode mode, const char *cmd)
soft_restart(0); soft_restart(0);
} }
static const char *mxs_dt_compat[] __initdata = { static const char *const mxs_dt_compat[] __initconst = {
"fsl,imx28", "fsl,imx28",
"fsl,imx23", "fsl,imx23",
NULL, NULL,

View file

@ -174,7 +174,7 @@ void __init netx_init_irq(void)
for (irq = NETX_IRQ_HIF_CHAINED(0); irq <= NETX_IRQ_HIF_LAST; irq++) { for (irq = NETX_IRQ_HIF_CHAINED(0); irq <= NETX_IRQ_HIF_LAST; irq++) {
irq_set_chip_and_handler(irq, &netx_hif_chip, irq_set_chip_and_handler(irq, &netx_hif_chip,
handle_level_irq); handle_level_irq);
set_irq_flags(irq, IRQF_VALID); irq_clear_status_flags(irq, IRQ_NOREQUEST);
} }
writel(NETX_DPMAS_INT_EN_GLB_EN, NETX_DPMAS_INT_EN); writel(NETX_DPMAS_INT_EN_GLB_EN, NETX_DPMAS_INT_EN);

View file

@ -34,40 +34,40 @@
#define TIMER_CLOCKEVENT 0 #define TIMER_CLOCKEVENT 0
#define TIMER_CLOCKSOURCE 1 #define TIMER_CLOCKSOURCE 1
static void netx_set_mode(enum clock_event_mode mode, static inline void timer_shutdown(struct clock_event_device *evt)
struct clock_event_device *clk)
{ {
u32 tmode;
/* disable timer */ /* disable timer */
writel(0, NETX_GPIO_COUNTER_CTRL(TIMER_CLOCKEVENT)); writel(0, NETX_GPIO_COUNTER_CTRL(TIMER_CLOCKEVENT));
}
switch (mode) { static int netx_shutdown(struct clock_event_device *evt)
case CLOCK_EVT_MODE_PERIODIC: {
writel(NETX_LATCH, NETX_GPIO_COUNTER_MAX(TIMER_CLOCKEVENT)); timer_shutdown(evt);
tmode = NETX_GPIO_COUNTER_CTRL_RST_EN |
NETX_GPIO_COUNTER_CTRL_IRQ_EN |
NETX_GPIO_COUNTER_CTRL_RUN;
break;
case CLOCK_EVT_MODE_ONESHOT: return 0;
writel(0, NETX_GPIO_COUNTER_MAX(TIMER_CLOCKEVENT)); }
tmode = NETX_GPIO_COUNTER_CTRL_IRQ_EN |
NETX_GPIO_COUNTER_CTRL_RUN;
break;
default: static int netx_set_oneshot(struct clock_event_device *evt)
WARN(1, "%s: unhandled mode %d\n", __func__, mode); {
/* fall through */ u32 tmode = NETX_GPIO_COUNTER_CTRL_IRQ_EN | NETX_GPIO_COUNTER_CTRL_RUN;
case CLOCK_EVT_MODE_SHUTDOWN:
case CLOCK_EVT_MODE_UNUSED:
case CLOCK_EVT_MODE_RESUME:
tmode = 0;
break;
}
timer_shutdown(evt);
writel(0, NETX_GPIO_COUNTER_MAX(TIMER_CLOCKEVENT));
writel(tmode, NETX_GPIO_COUNTER_CTRL(TIMER_CLOCKEVENT)); writel(tmode, NETX_GPIO_COUNTER_CTRL(TIMER_CLOCKEVENT));
return 0;
}
static int netx_set_periodic(struct clock_event_device *evt)
{
u32 tmode = NETX_GPIO_COUNTER_CTRL_RST_EN |
NETX_GPIO_COUNTER_CTRL_IRQ_EN | NETX_GPIO_COUNTER_CTRL_RUN;
timer_shutdown(evt);
writel(NETX_LATCH, NETX_GPIO_COUNTER_MAX(TIMER_CLOCKEVENT));
writel(tmode, NETX_GPIO_COUNTER_CTRL(TIMER_CLOCKEVENT));
return 0;
} }
static int netx_set_next_event(unsigned long evt, static int netx_set_next_event(unsigned long evt,
@ -81,7 +81,10 @@ static struct clock_event_device netx_clockevent = {
.name = "netx-timer" __stringify(TIMER_CLOCKEVENT), .name = "netx-timer" __stringify(TIMER_CLOCKEVENT),
.features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, .features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,
.set_next_event = netx_set_next_event, .set_next_event = netx_set_next_event,
.set_mode = netx_set_mode, .set_state_shutdown = netx_shutdown,
.set_state_periodic = netx_set_periodic,
.set_state_oneshot = netx_set_oneshot,
.tick_resume = netx_shutdown,
}; };
/* /*

View file

@ -26,10 +26,8 @@
#include <linux/irq.h> #include <linux/irq.h>
#include <linux/dma-mapping.h> #include <linux/dma-mapping.h>
#include <linux/of_irq.h> #include <linux/of_irq.h>
#include <linux/of_gpio.h>
#include <linux/of_address.h> #include <linux/of_address.h>
#include <linux/of_platform.h> #include <linux/of_platform.h>
#include <linux/gpio.h>
#include <asm/mach/arch.h> #include <asm/mach/arch.h>
#include <asm/mach/map.h> #include <asm/mach/map.h>
@ -109,40 +107,6 @@ static void cpu8815_restart(enum reboot_mode mode, const char *cmd)
writel(1, srcbase + 0x18); writel(1, srcbase + 0x18);
} }
/*
* This GPIO pin turns on a line that is used to detect card insertion
* on this board.
*/
static int __init cpu8815_mmcsd_init(void)
{
struct device_node *cdbias;
int gpio, err;
cdbias = of_find_node_by_path("/usb-s8815/mmcsd-gpio");
if (!cdbias) {
pr_info("could not find MMC/SD card detect bias node\n");
return 0;
}
gpio = of_get_gpio(cdbias, 0);
if (gpio < 0) {
pr_info("could not obtain MMC/SD card detect bias GPIO\n");
return 0;
}
err = gpio_request(gpio, "card detect bias");
if (err) {
pr_info("failed to request card detect bias GPIO %d\n", gpio);
return -ENODEV;
}
err = gpio_direction_output(gpio, 0);
if (err){
pr_info("failed to set GPIO %d as output, low\n", gpio);
return err;
}
pr_info("enabled USB-S8815 CD bias GPIO %d, low\n", gpio);
return 0;
}
device_initcall(cpu8815_mmcsd_init);
static const char * cpu8815_board_compat[] = { static const char * cpu8815_board_compat[] = {
"st,nomadik-nhk-15", "st,nomadik-nhk-15",
"calaosystems,usb-s8815", "calaosystems,usb-s8815",
@ -150,9 +114,8 @@ static const char * cpu8815_board_compat[] = {
}; };
DT_MACHINE_START(NOMADIK_DT, "Nomadik STn8815") DT_MACHINE_START(NOMADIK_DT, "Nomadik STn8815")
/* At full speed latency must be >=2, so 0x249 in low bits */ .l2c_aux_val = 0,
.l2c_aux_val = 0x00700249, .l2c_aux_mask = ~0,
.l2c_aux_mask = 0xfe0fefff,
.map_io = cpu8815_map_io, .map_io = cpu8815_map_io,
.restart = cpu8815_restart, .restart = cpu8815_restart,
.dt_compat = cpu8815_board_compat, .dt_compat = cpu8815_board_compat,

View file

@ -169,7 +169,7 @@ void omap1510_fpga_init_irq(void)
} }
irq_set_handler(i, handle_edge_irq); irq_set_handler(i, handle_edge_irq);
set_irq_flags(i, IRQF_VALID); irq_clear_status_flags(i, IRQ_NOREQUEST);
} }
/* /*

View file

@ -262,7 +262,7 @@ void __init omap1_init_irq(void)
irq_trigger = irq_banks[i].trigger_map >> IRQ_BIT(j); irq_trigger = irq_banks[i].trigger_map >> IRQ_BIT(j);
omap_irq_set_cfg(j, 0, 0, irq_trigger); omap_irq_set_cfg(j, 0, 0, irq_trigger);
set_irq_flags(j, IRQF_VALID); irq_clear_status_flags(j, IRQ_NOREQUEST);
} }
omap_alloc_gc(irq_banks[i].va, irq_base + i * 32, 32); omap_alloc_gc(irq_banks[i].va, irq_base + i * 32, 32);
} }

View file

@ -124,29 +124,26 @@ static int omap_mpu_set_next_event(unsigned long cycles,
return 0; return 0;
} }
static void omap_mpu_set_mode(enum clock_event_mode mode, static int omap_mpu_set_oneshot(struct clock_event_device *evt)
struct clock_event_device *evt)
{ {
switch (mode) { omap_mpu_timer_stop(0);
case CLOCK_EVT_MODE_PERIODIC: omap_mpu_remove_autoreset(0);
omap_mpu_set_autoreset(0); return 0;
break; }
case CLOCK_EVT_MODE_ONESHOT:
omap_mpu_timer_stop(0); static int omap_mpu_set_periodic(struct clock_event_device *evt)
omap_mpu_remove_autoreset(0); {
break; omap_mpu_set_autoreset(0);
case CLOCK_EVT_MODE_UNUSED: return 0;
case CLOCK_EVT_MODE_SHUTDOWN:
case CLOCK_EVT_MODE_RESUME:
break;
}
} }
static struct clock_event_device clockevent_mpu_timer1 = { static struct clock_event_device clockevent_mpu_timer1 = {
.name = "mpu_timer1", .name = "mpu_timer1",
.features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, .features = CLOCK_EVT_FEAT_PERIODIC |
.set_next_event = omap_mpu_set_next_event, CLOCK_EVT_FEAT_ONESHOT,
.set_mode = omap_mpu_set_mode, .set_next_event = omap_mpu_set_next_event,
.set_state_periodic = omap_mpu_set_periodic,
.set_state_oneshot = omap_mpu_set_oneshot,
}; };
static irqreturn_t omap_mpu_timer1_interrupt(int irq, void *dev_id) static irqreturn_t omap_mpu_timer1_interrupt(int irq, void *dev_id)

View file

@ -114,29 +114,28 @@ static int omap_32k_timer_set_next_event(unsigned long delta,
return 0; return 0;
} }
static void omap_32k_timer_set_mode(enum clock_event_mode mode, static int omap_32k_timer_shutdown(struct clock_event_device *evt)
struct clock_event_device *evt)
{ {
omap_32k_timer_stop(); omap_32k_timer_stop();
return 0;
}
switch (mode) { static int omap_32k_timer_set_periodic(struct clock_event_device *evt)
case CLOCK_EVT_MODE_PERIODIC: {
omap_32k_timer_start(OMAP_32K_TIMER_TICK_PERIOD); omap_32k_timer_stop();
break; omap_32k_timer_start(OMAP_32K_TIMER_TICK_PERIOD);
case CLOCK_EVT_MODE_ONESHOT: return 0;
case CLOCK_EVT_MODE_UNUSED:
case CLOCK_EVT_MODE_SHUTDOWN:
break;
case CLOCK_EVT_MODE_RESUME:
break;
}
} }
static struct clock_event_device clockevent_32k_timer = { static struct clock_event_device clockevent_32k_timer = {
.name = "32k-timer", .name = "32k-timer",
.features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, .features = CLOCK_EVT_FEAT_PERIODIC |
.set_next_event = omap_32k_timer_set_next_event, CLOCK_EVT_FEAT_ONESHOT,
.set_mode = omap_32k_timer_set_mode, .set_next_event = omap_32k_timer_set_next_event,
.set_state_shutdown = omap_32k_timer_shutdown,
.set_state_periodic = omap_32k_timer_set_periodic,
.set_state_oneshot = omap_32k_timer_shutdown,
.tick_resume = omap_32k_timer_shutdown,
}; };
static irqreturn_t omap_32k_timer_interrupt(int irq, void *dev_id) static irqreturn_t omap_32k_timer_interrupt(int irq, void *dev_id)

View file

@ -178,26 +178,6 @@ config MACH_OMAP_LDP
default y default y
select OMAP_PACKAGE_CBB select OMAP_PACKAGE_CBB
config MACH_OMAP3530_LV_SOM
bool "OMAP3 Logic 3530 LV SOM board"
depends on ARCH_OMAP3
default y
select OMAP_PACKAGE_CBB
help
Support for the LogicPD OMAP3530 SOM Development kit
for full description please see the products webpage at
http://www.logicpd.com/products/development-kits/texas-instruments-zoom%E2%84%A2-omap35x-development-kit
config MACH_OMAP3_TORPEDO
bool "OMAP3 Logic 35x Torpedo board"
depends on ARCH_OMAP3
default y
select OMAP_PACKAGE_CBB
help
Support for the LogicPD OMAP35x Torpedo Development kit
for full description please see the products webpage at
http://www.logicpd.com/products/development-kits/zoom-omap35x-torpedo-development-kit
config MACH_OMAP3517EVM config MACH_OMAP3517EVM
bool "OMAP3517/ AM3517 EVM board" bool "OMAP3517/ AM3517 EVM board"
depends on ARCH_OMAP3 depends on ARCH_OMAP3

View file

@ -235,9 +235,6 @@ obj-$(CONFIG_SOC_OMAP2420) += msdi.o
# Specific board support # Specific board support
obj-$(CONFIG_MACH_OMAP_GENERIC) += board-generic.o pdata-quirks.o obj-$(CONFIG_MACH_OMAP_GENERIC) += board-generic.o pdata-quirks.o
obj-$(CONFIG_MACH_OMAP_LDP) += board-ldp.o obj-$(CONFIG_MACH_OMAP_LDP) += board-ldp.o
obj-$(CONFIG_MACH_OMAP3530_LV_SOM) += board-omap3logic.o
obj-$(CONFIG_MACH_OMAP3_TORPEDO) += board-omap3logic.o
obj-$(CONFIG_MACH_OMAP3_PANDORA) += board-omap3pandora.o
obj-$(CONFIG_MACH_NOKIA_N8X0) += board-n8x0.o obj-$(CONFIG_MACH_NOKIA_N8X0) += board-n8x0.o
obj-$(CONFIG_MACH_NOKIA_RX51) += board-rx51.o sdram-nokia.o obj-$(CONFIG_MACH_NOKIA_RX51) += board-rx51.o sdram-nokia.o
obj-$(CONFIG_MACH_NOKIA_RX51) += board-rx51-peripherals.o obj-$(CONFIG_MACH_NOKIA_RX51) += board-rx51-peripherals.o

View file

@ -1,249 +0,0 @@
/*
* linux/arch/arm/mach-omap2/board-omap3logic.c
*
* Copyright (C) 2010 Li-Pro.Net
* Stephan Linz <linz@li-pro.net>
*
* Copyright (C) 2010-2012 Logic Product Development, Inc.
* Peter Barada <peter.barada@logicpd.com>
* Ashwin BIhari <ashwin.bihari@logicpd.com>
*
* Modified from Beagle, EVM, and RX51
*
* 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/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/clk.h>
#include <linux/io.h>
#include <linux/gpio.h>
#include <linux/regulator/fixed.h>
#include <linux/regulator/machine.h>
#include <linux/i2c/twl.h>
#include <linux/mmc/host.h>
#include <linux/usb/phy.h>
#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include "common.h"
#include "mux.h"
#include "hsmmc.h"
#include "control.h"
#include "common-board-devices.h"
#include "gpmc.h"
#include "gpmc-smsc911x.h"
#define OMAP3LOGIC_SMSC911X_CS 1
#define OMAP3530_LV_SOM_MMC_GPIO_CD 110
#define OMAP3530_LV_SOM_MMC_GPIO_WP 126
#define OMAP3530_LV_SOM_SMSC911X_GPIO_IRQ 152
#define OMAP3_TORPEDO_MMC_GPIO_CD 127
#define OMAP3_TORPEDO_SMSC911X_GPIO_IRQ 129
static struct regulator_consumer_supply omap3logic_vmmc1_supply[] = {
REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
};
/* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
static struct regulator_init_data omap3logic_vmmc1 = {
.constraints = {
.name = "VMMC1",
.min_uV = 1850000,
.max_uV = 3150000,
.valid_modes_mask = REGULATOR_MODE_NORMAL
| REGULATOR_MODE_STANDBY,
.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
| REGULATOR_CHANGE_MODE
| REGULATOR_CHANGE_STATUS,
},
.num_consumer_supplies = ARRAY_SIZE(omap3logic_vmmc1_supply),
.consumer_supplies = omap3logic_vmmc1_supply,
};
static struct twl4030_gpio_platform_data omap3logic_gpio_data = {
.use_leds = true,
.pullups = BIT(1),
.pulldowns = BIT(2) | BIT(6) | BIT(7) | BIT(8)
| BIT(13) | BIT(15) | BIT(16) | BIT(17),
};
static struct twl4030_usb_data omap3logic_usb_data = {
.usb_mode = T2_USB_MODE_ULPI,
};
static struct twl4030_platform_data omap3logic_twldata = {
/* platform_data for children goes here */
.gpio = &omap3logic_gpio_data,
.vmmc1 = &omap3logic_vmmc1,
.usb = &omap3logic_usb_data,
};
static int __init omap3logic_i2c_init(void)
{
omap3_pmic_init("twl4030", &omap3logic_twldata);
return 0;
}
static struct omap2_hsmmc_info __initdata board_mmc_info[] = {
{
.name = "external",
.mmc = 1,
.caps = MMC_CAP_4_BIT_DATA,
.gpio_cd = -EINVAL,
.gpio_wp = -EINVAL,
},
{} /* Terminator */
};
static void __init board_mmc_init(void)
{
if (machine_is_omap3530_lv_som()) {
/* OMAP3530 LV SOM board */
board_mmc_info[0].gpio_cd = OMAP3530_LV_SOM_MMC_GPIO_CD;
board_mmc_info[0].gpio_wp = OMAP3530_LV_SOM_MMC_GPIO_WP;
omap_mux_init_signal("gpio_110", OMAP_PIN_OUTPUT);
omap_mux_init_signal("gpio_126", OMAP_PIN_OUTPUT);
} else if (machine_is_omap3_torpedo()) {
/* OMAP3 Torpedo board */
board_mmc_info[0].gpio_cd = OMAP3_TORPEDO_MMC_GPIO_CD;
omap_mux_init_signal("gpio_127", OMAP_PIN_OUTPUT);
} else {
/* unsupported board */
printk(KERN_ERR "%s(): unknown machine type\n", __func__);
return;
}
omap_hsmmc_init(board_mmc_info);
}
static struct omap_smsc911x_platform_data __initdata board_smsc911x_data = {
.cs = OMAP3LOGIC_SMSC911X_CS,
.gpio_irq = -EINVAL,
.gpio_reset = -EINVAL,
};
/* TODO/FIXME (comment by Peter Barada, LogicPD):
* Fix the PBIAS voltage for Torpedo MMC1 pins that
* are used for other needs (IRQs, etc). */
static void omap3torpedo_fix_pbias_voltage(void)
{
u16 control_pbias_offset = OMAP343X_CONTROL_PBIAS_LITE;
u32 reg;
if (machine_is_omap3_torpedo())
{
/* Set the bias for the pin */
reg = omap_ctrl_readl(control_pbias_offset);
reg &= ~OMAP343X_PBIASLITEPWRDNZ1;
omap_ctrl_writel(reg, control_pbias_offset);
/* 100ms delay required for PBIAS configuration */
msleep(100);
reg |= OMAP343X_PBIASLITEVMODE1;
reg |= OMAP343X_PBIASLITEPWRDNZ1;
omap_ctrl_writel(reg | 0x300, control_pbias_offset);
}
}
static inline void __init board_smsc911x_init(void)
{
if (machine_is_omap3530_lv_som()) {
/* OMAP3530 LV SOM board */
board_smsc911x_data.gpio_irq =
OMAP3530_LV_SOM_SMSC911X_GPIO_IRQ;
omap_mux_init_signal("gpio_152", OMAP_PIN_INPUT);
} else if (machine_is_omap3_torpedo()) {
/* OMAP3 Torpedo board */
board_smsc911x_data.gpio_irq = OMAP3_TORPEDO_SMSC911X_GPIO_IRQ;
omap_mux_init_signal("gpio_129", OMAP_PIN_INPUT);
} else {
/* unsupported board */
printk(KERN_ERR "%s(): unknown machine type\n", __func__);
return;
}
gpmc_smsc911x_init(&board_smsc911x_data);
}
#ifdef CONFIG_OMAP_MUX
static struct omap_board_mux board_mux[] __initdata = {
/* mUSB */
OMAP3_MUX(HSUSB0_CLK, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
OMAP3_MUX(HSUSB0_STP, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT),
OMAP3_MUX(HSUSB0_DIR, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
OMAP3_MUX(HSUSB0_NXT, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
OMAP3_MUX(HSUSB0_DATA0, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
OMAP3_MUX(HSUSB0_DATA1, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
OMAP3_MUX(HSUSB0_DATA2, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
OMAP3_MUX(HSUSB0_DATA3, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
OMAP3_MUX(HSUSB0_DATA4, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
OMAP3_MUX(HSUSB0_DATA5, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
OMAP3_MUX(HSUSB0_DATA6, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
OMAP3_MUX(HSUSB0_DATA7, OMAP_MUX_MODE0 | OMAP_PIN_INPUT),
{ .reg_offset = OMAP_MUX_TERMINATOR },
};
#endif
static struct regulator_consumer_supply dummy_supplies[] = {
REGULATOR_SUPPLY("vddvario", "smsc911x.0"),
REGULATOR_SUPPLY("vdd33a", "smsc911x.0"),
};
static void __init omap3logic_init(void)
{
regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies));
omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
omap3torpedo_fix_pbias_voltage();
omap3logic_i2c_init();
omap_serial_init();
omap_sdrc_init(NULL, NULL);
board_mmc_init();
board_smsc911x_init();
usb_bind_phy("musb-hdrc.0.auto", 0, "twl4030_usb");
usb_musb_init(NULL);
/* Ensure SDRC pins are mux'd for self-refresh */
omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
}
MACHINE_START(OMAP3_TORPEDO, "Logic OMAP3 Torpedo board")
.atag_offset = 0x100,
.reserve = omap_reserve,
.map_io = omap3_map_io,
.init_early = omap35xx_init_early,
.init_irq = omap3_init_irq,
.init_machine = omap3logic_init,
.init_late = omap35xx_init_late,
.init_time = omap3_sync32k_timer_init,
.restart = omap3xxx_restart,
MACHINE_END
MACHINE_START(OMAP3530_LV_SOM, "OMAP Logic 3530 LV SOM board")
.atag_offset = 0x100,
.reserve = omap_reserve,
.map_io = omap3_map_io,
.init_early = omap35xx_init_early,
.init_irq = omap3_init_irq,
.init_machine = omap3logic_init,
.init_late = omap35xx_init_late,
.init_time = omap3_sync32k_timer_init,
.restart = omap3xxx_restart,
MACHINE_END

View file

@ -1,633 +0,0 @@
/*
* board-omap3pandora.c (Pandora Handheld Console)
*
* 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.
*
* 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., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA
*
*/
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/spi/spi.h>
#include <linux/regulator/machine.h>
#include <linux/i2c/twl.h>
#include <linux/omap-gpmc.h>
#include <linux/wl12xx.h>
#include <linux/mtd/partitions.h>
#include <linux/mtd/nand.h>
#include <linux/leds.h>
#include <linux/input.h>
#include <linux/input/matrix_keypad.h>
#include <linux/gpio.h>
#include <linux/gpio_keys.h>
#include <linux/mmc/host.h>
#include <linux/mmc/card.h>
#include <linux/regulator/fixed.h>
#include <linux/usb/phy.h>
#include <linux/platform_data/spi-omap2-mcspi.h>
#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include "common.h"
#include <video/omapdss.h>
#include <video/omap-panel-data.h>
#include <linux/platform_data/mtd-nand-omap2.h>
#include "mux.h"
#include "sdram-micron-mt46h32m32lf-6.h"
#include "hsmmc.h"
#include "common-board-devices.h"
#define PANDORA_WIFI_IRQ_GPIO 21
#define PANDORA_WIFI_NRESET_GPIO 23
#define OMAP3_PANDORA_TS_GPIO 94
static struct mtd_partition omap3pandora_nand_partitions[] = {
{
.name = "xloader",
.offset = 0,
.size = 4 * NAND_BLOCK_SIZE,
.mask_flags = MTD_WRITEABLE
}, {
.name = "uboot",
.offset = MTDPART_OFS_APPEND,
.size = 15 * NAND_BLOCK_SIZE,
}, {
.name = "uboot-env",
.offset = MTDPART_OFS_APPEND,
.size = 1 * NAND_BLOCK_SIZE,
}, {
.name = "boot",
.offset = MTDPART_OFS_APPEND,
.size = 80 * NAND_BLOCK_SIZE,
}, {
.name = "rootfs",
.offset = MTDPART_OFS_APPEND,
.size = MTDPART_SIZ_FULL,
},
};
static struct omap_nand_platform_data pandora_nand_data = {
.cs = 0,
.devsize = NAND_BUSWIDTH_16,
.xfer_type = NAND_OMAP_PREFETCH_DMA,
.parts = omap3pandora_nand_partitions,
.nr_parts = ARRAY_SIZE(omap3pandora_nand_partitions),
};
static struct gpio_led pandora_gpio_leds[] = {
{
.name = "pandora::sd1",
.default_trigger = "mmc0",
.gpio = 128,
}, {
.name = "pandora::sd2",
.default_trigger = "mmc1",
.gpio = 129,
}, {
.name = "pandora::bluetooth",
.gpio = 158,
}, {
.name = "pandora::wifi",
.gpio = 159,
},
};
static struct gpio_led_platform_data pandora_gpio_led_data = {
.leds = pandora_gpio_leds,
.num_leds = ARRAY_SIZE(pandora_gpio_leds),
};
static struct platform_device pandora_leds_gpio = {
.name = "leds-gpio",
.id = -1,
.dev = {
.platform_data = &pandora_gpio_led_data,
},
};
static struct platform_device pandora_backlight = {
.name = "pandora-backlight",
.id = -1,
};
#define GPIO_BUTTON(gpio_num, ev_type, ev_code, act_low, descr) \
{ \
.gpio = gpio_num, \
.type = ev_type, \
.code = ev_code, \
.active_low = act_low, \
.debounce_interval = 4, \
.desc = "btn " descr, \
}
#define GPIO_BUTTON_LOW(gpio_num, event_code, description) \
GPIO_BUTTON(gpio_num, EV_KEY, event_code, 1, description)
static struct gpio_keys_button pandora_gpio_keys[] = {
GPIO_BUTTON_LOW(110, KEY_UP, "up"),
GPIO_BUTTON_LOW(103, KEY_DOWN, "down"),
GPIO_BUTTON_LOW(96, KEY_LEFT, "left"),
GPIO_BUTTON_LOW(98, KEY_RIGHT, "right"),
GPIO_BUTTON_LOW(109, KEY_PAGEUP, "game 1"),
GPIO_BUTTON_LOW(111, KEY_END, "game 2"),
GPIO_BUTTON_LOW(106, KEY_PAGEDOWN, "game 3"),
GPIO_BUTTON_LOW(101, KEY_HOME, "game 4"),
GPIO_BUTTON_LOW(102, KEY_RIGHTSHIFT, "l"),
GPIO_BUTTON_LOW(97, KEY_KPPLUS, "l2"),
GPIO_BUTTON_LOW(105, KEY_RIGHTCTRL, "r"),
GPIO_BUTTON_LOW(107, KEY_KPMINUS, "r2"),
GPIO_BUTTON_LOW(104, KEY_LEFTCTRL, "ctrl"),
GPIO_BUTTON_LOW(99, KEY_MENU, "menu"),
GPIO_BUTTON_LOW(176, KEY_COFFEE, "hold"),
GPIO_BUTTON(100, EV_KEY, KEY_LEFTALT, 0, "alt"),
GPIO_BUTTON(108, EV_SW, SW_LID, 1, "lid"),
};
static struct gpio_keys_platform_data pandora_gpio_key_info = {
.buttons = pandora_gpio_keys,
.nbuttons = ARRAY_SIZE(pandora_gpio_keys),
};
static struct platform_device pandora_keys_gpio = {
.name = "gpio-keys",
.id = -1,
.dev = {
.platform_data = &pandora_gpio_key_info,
},
};
static const uint32_t board_keymap[] = {
/* row, col, code */
KEY(0, 0, KEY_9),
KEY(0, 1, KEY_8),
KEY(0, 2, KEY_I),
KEY(0, 3, KEY_J),
KEY(0, 4, KEY_N),
KEY(0, 5, KEY_M),
KEY(1, 0, KEY_0),
KEY(1, 1, KEY_7),
KEY(1, 2, KEY_U),
KEY(1, 3, KEY_H),
KEY(1, 4, KEY_B),
KEY(1, 5, KEY_SPACE),
KEY(2, 0, KEY_BACKSPACE),
KEY(2, 1, KEY_6),
KEY(2, 2, KEY_Y),
KEY(2, 3, KEY_G),
KEY(2, 4, KEY_V),
KEY(2, 5, KEY_FN),
KEY(3, 0, KEY_O),
KEY(3, 1, KEY_5),
KEY(3, 2, KEY_T),
KEY(3, 3, KEY_F),
KEY(3, 4, KEY_C),
KEY(4, 0, KEY_P),
KEY(4, 1, KEY_4),
KEY(4, 2, KEY_R),
KEY(4, 3, KEY_D),
KEY(4, 4, KEY_X),
KEY(5, 0, KEY_K),
KEY(5, 1, KEY_3),
KEY(5, 2, KEY_E),
KEY(5, 3, KEY_S),
KEY(5, 4, KEY_Z),
KEY(6, 0, KEY_L),
KEY(6, 1, KEY_2),
KEY(6, 2, KEY_W),
KEY(6, 3, KEY_A),
KEY(6, 4, KEY_DOT),
KEY(7, 0, KEY_ENTER),
KEY(7, 1, KEY_1),
KEY(7, 2, KEY_Q),
KEY(7, 3, KEY_LEFTSHIFT),
KEY(7, 4, KEY_COMMA),
};
static struct matrix_keymap_data board_map_data = {
.keymap = board_keymap,
.keymap_size = ARRAY_SIZE(board_keymap),
};
static struct twl4030_keypad_data pandora_kp_data = {
.keymap_data = &board_map_data,
.rows = 8,
.cols = 6,
.rep = 1,
};
static struct connector_atv_platform_data pandora_tv_pdata = {
.name = "tv",
.source = "venc.0",
.connector_type = OMAP_DSS_VENC_TYPE_SVIDEO,
.invert_polarity = false,
};
static struct platform_device pandora_tv_connector_device = {
.name = "connector-analog-tv",
.id = 0,
.dev.platform_data = &pandora_tv_pdata,
};
static struct omap_dss_board_info pandora_dss_data = {
.default_display_name = "lcd",
};
static void pandora_wl1251_init_card(struct mmc_card *card)
{
/*
* We have TI wl1251 attached to MMC3. Pass this information to
* SDIO core because it can't be probed by normal methods.
*/
if (card->type == MMC_TYPE_SDIO || card->type == MMC_TYPE_SD_COMBO) {
card->quirks |= MMC_QUIRK_NONSTD_SDIO;
card->cccr.wide_bus = 1;
card->cis.vendor = 0x104c;
card->cis.device = 0x9066;
card->cis.blksize = 512;
card->cis.max_dtr = 20000000;
}
}
static struct omap2_hsmmc_info omap3pandora_mmc[] = {
{
.mmc = 1,
.caps = MMC_CAP_4_BIT_DATA,
.gpio_cd = -EINVAL,
.gpio_wp = 126,
.ext_clock = 0,
.deferred = true,
},
{
.mmc = 2,
.caps = MMC_CAP_4_BIT_DATA,
.gpio_cd = -EINVAL,
.gpio_wp = 127,
.ext_clock = 1,
.transceiver = true,
.deferred = true,
},
{
.mmc = 3,
.caps = MMC_CAP_4_BIT_DATA | MMC_CAP_POWER_OFF_CARD,
.gpio_cd = -EINVAL,
.gpio_wp = -EINVAL,
.init_card = pandora_wl1251_init_card,
},
{} /* Terminator */
};
static int omap3pandora_twl_gpio_setup(struct device *dev,
unsigned gpio, unsigned ngpio)
{
int ret, gpio_32khz;
/* gpio + {0,1} is "mmc{0,1}_cd" (input/IRQ) */
omap3pandora_mmc[0].gpio_cd = gpio + 0;
omap3pandora_mmc[1].gpio_cd = gpio + 1;
omap_hsmmc_late_init(omap3pandora_mmc);
/* gpio + 13 drives 32kHz buffer for wifi module */
gpio_32khz = gpio + 13;
ret = gpio_request_one(gpio_32khz, GPIOF_OUT_INIT_HIGH, "wifi 32kHz");
if (ret < 0) {
pr_err("Cannot get GPIO line %d, ret=%d\n", gpio_32khz, ret);
return -ENODEV;
}
return 0;
}
static struct twl4030_gpio_platform_data omap3pandora_gpio_data = {
.setup = omap3pandora_twl_gpio_setup,
};
static struct regulator_consumer_supply pandora_vmmc1_supply[] = {
REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
};
static struct regulator_consumer_supply pandora_vmmc2_supply[] = {
REGULATOR_SUPPLY("vmmc", "omap_hsmmc.1")
};
static struct regulator_consumer_supply pandora_vmmc3_supply[] = {
REGULATOR_SUPPLY("vmmc", "omap_hsmmc.2"),
};
static struct regulator_consumer_supply pandora_vdds_supplies[] = {
REGULATOR_SUPPLY("vdds_sdi", "omapdss"),
REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
REGULATOR_SUPPLY("vdds_dsi", "omapdss_dpi.0"),
REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.0"),
};
static struct regulator_consumer_supply pandora_vcc_lcd_supply[] = {
REGULATOR_SUPPLY("vcc", "spi1.1"),
};
static struct regulator_consumer_supply pandora_usb_phy_supply[] = {
REGULATOR_SUPPLY("vcc", "usb_phy_gen_xceiv.2"), /* hsusb port 2 */
};
/* ads7846 on SPI and 2 nub controllers on I2C */
static struct regulator_consumer_supply pandora_vaux4_supplies[] = {
REGULATOR_SUPPLY("vcc", "spi1.0"),
REGULATOR_SUPPLY("vcc", "3-0066"),
REGULATOR_SUPPLY("vcc", "3-0067"),
};
static struct regulator_consumer_supply pandora_adac_supply[] = {
REGULATOR_SUPPLY("vcc", "soc-audio"),
};
/* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
static struct regulator_init_data pandora_vmmc1 = {
.constraints = {
.min_uV = 1850000,
.max_uV = 3150000,
.valid_modes_mask = REGULATOR_MODE_NORMAL
| REGULATOR_MODE_STANDBY,
.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
| REGULATOR_CHANGE_MODE
| REGULATOR_CHANGE_STATUS,
},
.num_consumer_supplies = ARRAY_SIZE(pandora_vmmc1_supply),
.consumer_supplies = pandora_vmmc1_supply,
};
/* VMMC2 for MMC2 pins CMD, CLK, DAT0..DAT3 (max 100 mA) */
static struct regulator_init_data pandora_vmmc2 = {
.constraints = {
.min_uV = 1850000,
.max_uV = 3150000,
.valid_modes_mask = REGULATOR_MODE_NORMAL
| REGULATOR_MODE_STANDBY,
.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
| REGULATOR_CHANGE_MODE
| REGULATOR_CHANGE_STATUS,
},
.num_consumer_supplies = ARRAY_SIZE(pandora_vmmc2_supply),
.consumer_supplies = pandora_vmmc2_supply,
};
/* VAUX1 for LCD */
static struct regulator_init_data pandora_vaux1 = {
.constraints = {
.min_uV = 3000000,
.max_uV = 3000000,
.apply_uV = true,
.valid_modes_mask = REGULATOR_MODE_NORMAL
| REGULATOR_MODE_STANDBY,
.valid_ops_mask = REGULATOR_CHANGE_MODE
| REGULATOR_CHANGE_STATUS,
},
.num_consumer_supplies = ARRAY_SIZE(pandora_vcc_lcd_supply),
.consumer_supplies = pandora_vcc_lcd_supply,
};
/* VAUX2 for USB host PHY */
static struct regulator_init_data pandora_vaux2 = {
.constraints = {
.min_uV = 1800000,
.max_uV = 1800000,
.apply_uV = true,
.valid_modes_mask = REGULATOR_MODE_NORMAL
| REGULATOR_MODE_STANDBY,
.valid_ops_mask = REGULATOR_CHANGE_MODE
| REGULATOR_CHANGE_STATUS,
},
.num_consumer_supplies = ARRAY_SIZE(pandora_usb_phy_supply),
.consumer_supplies = pandora_usb_phy_supply,
};
/* VAUX4 for ads7846 and nubs */
static struct regulator_init_data pandora_vaux4 = {
.constraints = {
.min_uV = 2800000,
.max_uV = 2800000,
.apply_uV = true,
.valid_modes_mask = REGULATOR_MODE_NORMAL
| REGULATOR_MODE_STANDBY,
.valid_ops_mask = REGULATOR_CHANGE_MODE
| REGULATOR_CHANGE_STATUS,
},
.num_consumer_supplies = ARRAY_SIZE(pandora_vaux4_supplies),
.consumer_supplies = pandora_vaux4_supplies,
};
/* VSIM for audio DAC */
static struct regulator_init_data pandora_vsim = {
.constraints = {
.min_uV = 2800000,
.max_uV = 2800000,
.apply_uV = true,
.valid_modes_mask = REGULATOR_MODE_NORMAL
| REGULATOR_MODE_STANDBY,
.valid_ops_mask = REGULATOR_CHANGE_MODE
| REGULATOR_CHANGE_STATUS,
},
.num_consumer_supplies = ARRAY_SIZE(pandora_adac_supply),
.consumer_supplies = pandora_adac_supply,
};
/* Fixed regulator internal to Wifi module */
static struct regulator_init_data pandora_vmmc3 = {
.constraints = {
.valid_ops_mask = REGULATOR_CHANGE_STATUS,
},
.num_consumer_supplies = ARRAY_SIZE(pandora_vmmc3_supply),
.consumer_supplies = pandora_vmmc3_supply,
};
static struct fixed_voltage_config pandora_vwlan = {
.supply_name = "vwlan",
.microvolts = 1800000, /* 1.8V */
.gpio = PANDORA_WIFI_NRESET_GPIO,
.startup_delay = 50000, /* 50ms */
.enable_high = 1,
.enabled_at_boot = 0,
.init_data = &pandora_vmmc3,
};
static struct platform_device pandora_vwlan_device = {
.name = "reg-fixed-voltage",
.id = 1,
.dev = {
.platform_data = &pandora_vwlan,
},
};
static struct twl4030_bci_platform_data pandora_bci_data;
static struct twl4030_power_data pandora_power_data = {
.use_poweroff = true,
};
static struct twl4030_platform_data omap3pandora_twldata = {
.gpio = &omap3pandora_gpio_data,
.vmmc1 = &pandora_vmmc1,
.vmmc2 = &pandora_vmmc2,
.vaux1 = &pandora_vaux1,
.vaux2 = &pandora_vaux2,
.vaux4 = &pandora_vaux4,
.vsim = &pandora_vsim,
.keypad = &pandora_kp_data,
.bci = &pandora_bci_data,
.power = &pandora_power_data,
};
static struct i2c_board_info __initdata omap3pandora_i2c3_boardinfo[] = {
{
I2C_BOARD_INFO("bq27500", 0x55),
.flags = I2C_CLIENT_WAKE,
},
};
static int __init omap3pandora_i2c_init(void)
{
omap3_pmic_get_config(&omap3pandora_twldata,
TWL_COMMON_PDATA_USB | TWL_COMMON_PDATA_AUDIO,
TWL_COMMON_REGULATOR_VDAC | TWL_COMMON_REGULATOR_VPLL2);
omap3pandora_twldata.vdac->constraints.apply_uV = true;
omap3pandora_twldata.vpll2->constraints.apply_uV = true;
omap3pandora_twldata.vpll2->num_consumer_supplies =
ARRAY_SIZE(pandora_vdds_supplies);
omap3pandora_twldata.vpll2->consumer_supplies = pandora_vdds_supplies;
omap3_pmic_init("tps65950", &omap3pandora_twldata);
/* i2c2 pins are not connected */
omap_register_i2c_bus(3, 100, omap3pandora_i2c3_boardinfo,
ARRAY_SIZE(omap3pandora_i2c3_boardinfo));
return 0;
}
static struct panel_tpo_td043mtea1_platform_data pandora_lcd_pdata = {
.name = "lcd",
.source = "dpi.0",
.data_lines = 24,
.nreset_gpio = 157,
};
static struct spi_board_info omap3pandora_spi_board_info[] __initdata = {
{
.modalias = "panel-tpo-td043mtea1",
.bus_num = 1,
.chip_select = 1,
.max_speed_hz = 375000,
.platform_data = &pandora_lcd_pdata,
}
};
static void __init pandora_wl1251_init(void)
{
struct wl1251_platform_data pandora_wl1251_pdata;
int ret;
memset(&pandora_wl1251_pdata, 0, sizeof(pandora_wl1251_pdata));
pandora_wl1251_pdata.power_gpio = -1;
ret = gpio_request_one(PANDORA_WIFI_IRQ_GPIO, GPIOF_IN, "wl1251 irq");
if (ret < 0)
goto fail;
pandora_wl1251_pdata.irq = gpio_to_irq(PANDORA_WIFI_IRQ_GPIO);
if (pandora_wl1251_pdata.irq < 0)
goto fail_irq;
pandora_wl1251_pdata.use_eeprom = true;
ret = wl1251_set_platform_data(&pandora_wl1251_pdata);
if (ret < 0)
goto fail_irq;
return;
fail_irq:
gpio_free(PANDORA_WIFI_IRQ_GPIO);
fail:
printk(KERN_ERR "wl1251 board initialisation failed\n");
}
static struct usbhs_phy_data phy_data[] __initdata = {
{
.port = 2,
.reset_gpio = 16,
.vcc_gpio = -EINVAL,
},
};
static struct platform_device *omap3pandora_devices[] __initdata = {
&pandora_leds_gpio,
&pandora_keys_gpio,
&pandora_vwlan_device,
&pandora_backlight,
&pandora_tv_connector_device,
};
static struct usbhs_omap_platform_data usbhs_bdata __initdata = {
.port_mode[1] = OMAP_EHCI_PORT_MODE_PHY,
};
#ifdef CONFIG_OMAP_MUX
static struct omap_board_mux board_mux[] __initdata = {
{ .reg_offset = OMAP_MUX_TERMINATOR },
};
#endif
static void __init omap3pandora_init(void)
{
omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
omap_hsmmc_init(omap3pandora_mmc);
omap3pandora_i2c_init();
pandora_wl1251_init();
platform_add_devices(omap3pandora_devices,
ARRAY_SIZE(omap3pandora_devices));
omap_display_init(&pandora_dss_data);
omap_serial_init();
omap_sdrc_init(mt46h32m32lf6_sdrc_params,
mt46h32m32lf6_sdrc_params);
spi_register_board_info(omap3pandora_spi_board_info,
ARRAY_SIZE(omap3pandora_spi_board_info));
omap_ads7846_init(1, OMAP3_PANDORA_TS_GPIO, 0, NULL);
usbhs_init_phys(phy_data, ARRAY_SIZE(phy_data));
usbhs_init(&usbhs_bdata);
usb_bind_phy("musb-hdrc.0.auto", 0, "twl4030_usb");
usb_musb_init(NULL);
gpmc_nand_init(&pandora_nand_data, NULL);
/* Ensure SDRC pins are mux'd for self-refresh */
omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
}
MACHINE_START(OMAP3_PANDORA, "Pandora Handheld Console")
.atag_offset = 0x100,
.reserve = omap_reserve,
.map_io = omap3_map_io,
.init_early = omap35xx_init_early,
.init_irq = omap3_init_irq,
.init_machine = omap3pandora_init,
.init_late = omap35xx_init_late,
.init_time = omap3_sync32k_timer_init,
.restart = omap3xxx_restart,
MACHINE_END

View file

@ -705,7 +705,7 @@ static struct omap_prcm_init_data scrm_data __initdata = {
}; };
#endif #endif
static const struct of_device_id omap_prcm_dt_match_table[] __initconst = { static const struct of_device_id const omap_prcm_dt_match_table[] __initconst = {
#ifdef CONFIG_SOC_AM33XX #ifdef CONFIG_SOC_AM33XX
{ .compatible = "ti,am3-prcm", .data = &am3_prm_data }, { .compatible = "ti,am3-prcm", .data = &am3_prm_data },
#endif #endif

View file

@ -102,38 +102,38 @@ static int omap2_gp_timer_set_next_event(unsigned long cycles,
return 0; return 0;
} }
static void omap2_gp_timer_set_mode(enum clock_event_mode mode, static int omap2_gp_timer_shutdown(struct clock_event_device *evt)
struct clock_event_device *evt) {
__omap_dm_timer_stop(&clkev, OMAP_TIMER_POSTED, clkev.rate);
return 0;
}
static int omap2_gp_timer_set_periodic(struct clock_event_device *evt)
{ {
u32 period; u32 period;
__omap_dm_timer_stop(&clkev, OMAP_TIMER_POSTED, clkev.rate); __omap_dm_timer_stop(&clkev, OMAP_TIMER_POSTED, clkev.rate);
switch (mode) { period = clkev.rate / HZ;
case CLOCK_EVT_MODE_PERIODIC: period -= 1;
period = clkev.rate / HZ; /* Looks like we need to first set the load value separately */
period -= 1; __omap_dm_timer_write(&clkev, OMAP_TIMER_LOAD_REG, 0xffffffff - period,
/* Looks like we need to first set the load value separately */ OMAP_TIMER_POSTED);
__omap_dm_timer_write(&clkev, OMAP_TIMER_LOAD_REG, __omap_dm_timer_load_start(&clkev,
0xffffffff - period, OMAP_TIMER_POSTED); OMAP_TIMER_CTRL_AR | OMAP_TIMER_CTRL_ST,
__omap_dm_timer_load_start(&clkev, 0xffffffff - period, OMAP_TIMER_POSTED);
OMAP_TIMER_CTRL_AR | OMAP_TIMER_CTRL_ST, return 0;
0xffffffff - period, OMAP_TIMER_POSTED);
break;
case CLOCK_EVT_MODE_ONESHOT:
break;
case CLOCK_EVT_MODE_UNUSED:
case CLOCK_EVT_MODE_SHUTDOWN:
case CLOCK_EVT_MODE_RESUME:
break;
}
} }
static struct clock_event_device clockevent_gpt = { static struct clock_event_device clockevent_gpt = {
.features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, .features = CLOCK_EVT_FEAT_PERIODIC |
.rating = 300, CLOCK_EVT_FEAT_ONESHOT,
.set_next_event = omap2_gp_timer_set_next_event, .rating = 300,
.set_mode = omap2_gp_timer_set_mode, .set_next_event = omap2_gp_timer_set_next_event,
.set_state_shutdown = omap2_gp_timer_shutdown,
.set_state_periodic = omap2_gp_timer_set_periodic,
.set_state_oneshot = omap2_gp_timer_shutdown,
.tick_resume = omap2_gp_timer_shutdown,
}; };
static struct property device_disabled = { static struct property device_disabled = {

View file

@ -563,7 +563,7 @@ struct i2c_init_data {
u8 hsscll_12; u8 hsscll_12;
}; };
static const __initdata struct i2c_init_data omap4_i2c_timing_data[] = { static const struct i2c_init_data const omap4_i2c_timing_data[] __initconst = {
{ {
.load = 50, .load = 50,
.loadbits = 0x3, .loadbits = 0x3,

View file

@ -95,7 +95,7 @@ static struct voltagedomain *voltagedomains_am35xx[] __initdata = {
}; };
static const char *sys_clk_name __initdata = "sys_ck"; static const char *const sys_clk_name __initconst = "sys_ck";
void __init omap3xxx_voltagedomains_init(void) void __init omap3xxx_voltagedomains_init(void)
{ {

View file

@ -92,7 +92,7 @@ static struct voltagedomain *voltagedomains_omap4[] __initdata = {
NULL, NULL,
}; };
static const char *sys_clk_name __initdata = "sys_clkin_ck"; static const char *const sys_clk_name __initconst = "sys_clkin_ck";
void __init omap44xx_voltagedomains_init(void) void __init omap44xx_voltagedomains_init(void)
{ {

View file

@ -78,7 +78,7 @@ static struct voltagedomain *voltagedomains_omap5[] __initdata = {
NULL, NULL,
}; };
static const char *sys_clk_name __initdata = "sys_clkin"; static const char *const sys_clk_name __initconst = "sys_clkin";
void __init omap54xx_voltagedomains_init(void) void __init omap54xx_voltagedomains_init(void)
{ {

View file

@ -236,9 +236,7 @@ static int __init dns323_read_mac_addr(void)
} }
iounmap(mac_page); iounmap(mac_page);
printk("DNS-323: Found ethernet MAC address: "); printk("DNS-323: Found ethernet MAC address: %pM\n", addr);
for (i = 0; i < 6; i++)
printk("%.2x%s", addr[i], (i < 5) ? ":" : ".\n");
memcpy(dns323_eth_data.mac_addr, addr, 6); memcpy(dns323_eth_data.mac_addr, addr, 6);

View file

@ -101,9 +101,7 @@ static int __init qnap_tsx09_check_mac_addr(const char *addr_str)
addr[i] = byte; addr[i] = byte;
} }
printk(KERN_INFO "tsx09: found ethernet mac address "); printk(KERN_INFO "tsx09: found ethernet mac address %pM\n", addr);
for (i = 0; i < 6; i++)
printk("%.2x%s", addr[i], (i < 5) ? ":" : ".\n");
memcpy(qnap_tsx09_eth_data.mac_addr, addr, 6); memcpy(qnap_tsx09_eth_data.mac_addr, addr, 6);

View file

@ -496,18 +496,18 @@ static struct irq_chip balloon3_irq_chip = {
.irq_unmask = balloon3_unmask_irq, .irq_unmask = balloon3_unmask_irq,
}; };
static void balloon3_irq_handler(unsigned int irq, struct irq_desc *desc) static void balloon3_irq_handler(unsigned int __irq, struct irq_desc *desc)
{ {
unsigned long pending = __raw_readl(BALLOON3_INT_CONTROL_REG) & unsigned long pending = __raw_readl(BALLOON3_INT_CONTROL_REG) &
balloon3_irq_enabled; balloon3_irq_enabled;
do { do {
/* clear useless edge notification */ struct irq_data *d = irq_desc_get_irq_data(desc);
if (desc->irq_data.chip->irq_ack) { struct irq_chip *chip = irq_data_get_chip(d);
struct irq_data *d; unsigned int irq;
d = irq_get_irq_data(BALLOON3_AUX_NIRQ); /* clear useless edge notification */
desc->irq_data.chip->irq_ack(d); if (chip->irq_ack)
} chip->irq_ack(d);
while (pending) { while (pending) {
irq = BALLOON3_IRQ(0) + __ffs(pending); irq = BALLOON3_IRQ(0) + __ffs(pending);
@ -528,7 +528,7 @@ static void __init balloon3_init_irq(void)
for (irq = BALLOON3_IRQ(0); irq <= BALLOON3_IRQ(7); irq++) { for (irq = BALLOON3_IRQ(0); irq <= BALLOON3_IRQ(7); irq++) {
irq_set_chip_and_handler(irq, &balloon3_irq_chip, irq_set_chip_and_handler(irq, &balloon3_irq_chip,
handle_level_irq); handle_level_irq);
set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); irq_clear_status_flags(irq, IRQ_NOREQUEST | IRQ_NOPROBE);
} }
irq_set_chained_handler(BALLOON3_AUX_NIRQ, balloon3_irq_handler); irq_set_chained_handler(BALLOON3_AUX_NIRQ, balloon3_irq_handler);

View file

@ -29,8 +29,9 @@
void __iomem *it8152_base_address; void __iomem *it8152_base_address;
static int cmx2xx_it8152_irq_gpio; static int cmx2xx_it8152_irq_gpio;
static void cmx2xx_it8152_irq_demux(unsigned int irq, struct irq_desc *desc) static void cmx2xx_it8152_irq_demux(unsigned int __irq, struct irq_desc *desc)
{ {
unsigned int irq = irq_desc_get_irq(desc);
/* clear our parent irq */ /* clear our parent irq */
desc->irq_data.chip->irq_ack(&desc->irq_data); desc->irq_data.chip->irq_ack(&desc->irq_data);

View file

@ -133,7 +133,6 @@ static int pxa_irq_map(struct irq_domain *h, unsigned int virq,
irq_set_chip_and_handler(virq, &pxa_internal_irq_chip, irq_set_chip_and_handler(virq, &pxa_internal_irq_chip,
handle_level_irq); handle_level_irq);
irq_set_chip_data(virq, base); irq_set_chip_data(virq, base);
set_irq_flags(virq, IRQF_VALID);
return 0; return 0;
} }

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