2006-04-02 16:46:30 +00:00
|
|
|
/*
|
|
|
|
* linux/arch/arm/mach-omap1/board-ams-delta.c
|
|
|
|
*
|
|
|
|
* Modified from board-generic.c
|
|
|
|
*
|
|
|
|
* Board specific inits for the Amstrad E3 (codename Delta) videophone
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006 Jonathan McDowell <noodles@earth.li>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
#include <linux/basic_mmio_gpio.h>
|
2011-07-26 09:53:52 +00:00
|
|
|
#include <linux/gpio.h>
|
2006-04-02 16:46:30 +00:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/init.h>
|
2006-12-07 01:13:52 +00:00
|
|
|
#include <linux/input.h>
|
2009-08-28 17:51:37 +00:00
|
|
|
#include <linux/interrupt.h>
|
2010-10-01 23:37:01 +00:00
|
|
|
#include <linux/leds.h>
|
2006-04-02 16:46:30 +00:00
|
|
|
#include <linux/platform_device.h>
|
2009-08-28 17:51:37 +00:00
|
|
|
#include <linux/serial_8250.h>
|
2011-07-31 20:17:29 +00:00
|
|
|
#include <linux/export.h>
|
2006-04-02 16:46:30 +00:00
|
|
|
|
2010-10-01 23:37:00 +00:00
|
|
|
#include <media/soc_camera.h>
|
|
|
|
|
2009-08-28 17:51:37 +00:00
|
|
|
#include <asm/serial.h>
|
2008-08-05 15:14:15 +00:00
|
|
|
#include <mach/hardware.h>
|
2006-04-02 16:46:30 +00:00
|
|
|
#include <asm/mach-types.h>
|
|
|
|
#include <asm/mach/arch.h>
|
|
|
|
#include <asm/mach/map.h>
|
|
|
|
|
2010-11-18 17:59:50 +00:00
|
|
|
#include <plat/io.h>
|
2009-10-20 16:40:47 +00:00
|
|
|
#include <plat/board-ams-delta.h>
|
|
|
|
#include <plat/keypad.h>
|
|
|
|
#include <plat/mux.h>
|
|
|
|
#include <plat/usb.h>
|
|
|
|
#include <plat/board.h>
|
2011-11-10 21:45:17 +00:00
|
|
|
#include "common.h"
|
2010-10-01 23:37:00 +00:00
|
|
|
#include <mach/camera.h>
|
2006-04-02 16:46:30 +00:00
|
|
|
|
2010-04-28 01:07:42 +00:00
|
|
|
#include <mach/ams-delta-fiq.h>
|
|
|
|
|
2010-12-20 21:09:22 +00:00
|
|
|
static const unsigned int ams_delta_keymap[] = {
|
2006-12-07 21:58:17 +00:00
|
|
|
KEY(0, 0, KEY_F1), /* Advert */
|
2006-12-07 01:13:52 +00:00
|
|
|
|
2010-12-20 21:09:22 +00:00
|
|
|
KEY(0, 3, KEY_COFFEE), /* Games */
|
|
|
|
KEY(0, 2, KEY_QUESTION), /* Directory */
|
|
|
|
KEY(2, 3, KEY_CONNECT), /* Internet */
|
|
|
|
KEY(1, 2, KEY_SHOP), /* Services */
|
2006-12-07 21:58:17 +00:00
|
|
|
KEY(1, 1, KEY_PHONE), /* VoiceMail */
|
2006-12-07 01:13:52 +00:00
|
|
|
|
2010-12-20 21:09:22 +00:00
|
|
|
KEY(0, 1, KEY_DELETE), /* Delete */
|
2006-12-07 21:58:17 +00:00
|
|
|
KEY(2, 2, KEY_PLAY), /* Play */
|
2010-12-20 21:09:22 +00:00
|
|
|
KEY(1, 0, KEY_PAGEUP), /* Up */
|
|
|
|
KEY(1, 3, KEY_PAGEDOWN), /* Down */
|
|
|
|
KEY(2, 0, KEY_EMAIL), /* ReadEmail */
|
|
|
|
KEY(2, 1, KEY_STOP), /* Stop */
|
2006-12-07 01:13:52 +00:00
|
|
|
|
|
|
|
/* Numeric keypad portion */
|
2010-12-20 21:09:22 +00:00
|
|
|
KEY(0, 7, KEY_KP1),
|
|
|
|
KEY(0, 6, KEY_KP2),
|
|
|
|
KEY(0, 5, KEY_KP3),
|
|
|
|
KEY(1, 7, KEY_KP4),
|
|
|
|
KEY(1, 6, KEY_KP5),
|
|
|
|
KEY(1, 5, KEY_KP6),
|
|
|
|
KEY(2, 7, KEY_KP7),
|
|
|
|
KEY(2, 6, KEY_KP8),
|
|
|
|
KEY(2, 5, KEY_KP9),
|
|
|
|
KEY(3, 6, KEY_KP0),
|
|
|
|
KEY(3, 7, KEY_KPASTERISK),
|
|
|
|
KEY(3, 5, KEY_KPDOT), /* # key */
|
|
|
|
KEY(7, 2, KEY_NUMLOCK), /* Mute */
|
|
|
|
KEY(7, 1, KEY_KPMINUS), /* Recall */
|
|
|
|
KEY(6, 1, KEY_KPPLUS), /* Redial */
|
|
|
|
KEY(7, 6, KEY_KPSLASH), /* Handsfree */
|
|
|
|
KEY(6, 0, KEY_ENTER), /* Video */
|
|
|
|
|
|
|
|
KEY(7, 4, KEY_CAMERA), /* Photo */
|
|
|
|
|
|
|
|
KEY(0, 4, KEY_F2), /* Home */
|
|
|
|
KEY(1, 4, KEY_F3), /* Office */
|
|
|
|
KEY(2, 4, KEY_F4), /* Mobile */
|
2006-12-07 21:58:17 +00:00
|
|
|
KEY(7, 7, KEY_F5), /* SMS */
|
2010-12-20 21:09:22 +00:00
|
|
|
KEY(7, 5, KEY_F6), /* Email */
|
2006-12-07 01:13:52 +00:00
|
|
|
|
|
|
|
/* QWERTY portion of keypad */
|
2010-12-20 21:09:22 +00:00
|
|
|
KEY(3, 4, KEY_Q),
|
2006-12-07 01:13:52 +00:00
|
|
|
KEY(3, 3, KEY_W),
|
2010-12-20 21:09:22 +00:00
|
|
|
KEY(3, 2, KEY_E),
|
|
|
|
KEY(3, 1, KEY_R),
|
|
|
|
KEY(3, 0, KEY_T),
|
|
|
|
KEY(4, 7, KEY_Y),
|
|
|
|
KEY(4, 6, KEY_U),
|
|
|
|
KEY(4, 5, KEY_I),
|
2006-12-07 01:13:52 +00:00
|
|
|
KEY(4, 4, KEY_O),
|
2010-12-20 21:09:22 +00:00
|
|
|
KEY(4, 3, KEY_P),
|
2006-12-07 01:13:52 +00:00
|
|
|
|
2010-12-20 21:09:22 +00:00
|
|
|
KEY(4, 2, KEY_A),
|
|
|
|
KEY(4, 1, KEY_S),
|
|
|
|
KEY(4, 0, KEY_D),
|
|
|
|
KEY(5, 7, KEY_F),
|
|
|
|
KEY(5, 6, KEY_G),
|
2006-12-07 01:13:52 +00:00
|
|
|
KEY(5, 5, KEY_H),
|
2010-12-20 21:09:22 +00:00
|
|
|
KEY(5, 4, KEY_J),
|
|
|
|
KEY(5, 3, KEY_K),
|
|
|
|
KEY(5, 2, KEY_L),
|
2006-12-07 01:13:52 +00:00
|
|
|
|
2010-12-20 21:09:22 +00:00
|
|
|
KEY(5, 1, KEY_Z),
|
|
|
|
KEY(5, 0, KEY_X),
|
|
|
|
KEY(6, 7, KEY_C),
|
2006-12-07 01:13:52 +00:00
|
|
|
KEY(6, 6, KEY_V),
|
2010-12-20 21:09:22 +00:00
|
|
|
KEY(6, 5, KEY_B),
|
|
|
|
KEY(6, 4, KEY_N),
|
|
|
|
KEY(6, 3, KEY_M),
|
|
|
|
KEY(6, 2, KEY_SPACE),
|
2006-12-07 01:13:52 +00:00
|
|
|
|
2010-12-20 21:09:22 +00:00
|
|
|
KEY(7, 0, KEY_LEFTSHIFT), /* Vol up */
|
|
|
|
KEY(7, 3, KEY_LEFTCTRL), /* Vol down */
|
2006-12-07 01:13:52 +00:00
|
|
|
};
|
|
|
|
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
#define LATCH1_PHYS 0x01000000
|
|
|
|
#define LATCH1_VIRT 0xEA000000
|
|
|
|
#define MODEM_PHYS 0x04000000
|
|
|
|
#define MODEM_VIRT 0xEB000000
|
|
|
|
#define LATCH2_PHYS 0x08000000
|
|
|
|
#define LATCH2_VIRT 0xEC000000
|
2006-04-02 16:46:30 +00:00
|
|
|
|
|
|
|
static struct map_desc ams_delta_io_desc[] __initdata = {
|
2007-12-14 02:27:15 +00:00
|
|
|
/* AMS_DELTA_LATCH1 */
|
2006-04-02 16:46:30 +00:00
|
|
|
{
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
.virtual = LATCH1_VIRT,
|
|
|
|
.pfn = __phys_to_pfn(LATCH1_PHYS),
|
2006-04-02 16:46:30 +00:00
|
|
|
.length = 0x01000000,
|
|
|
|
.type = MT_DEVICE
|
|
|
|
},
|
2007-12-14 02:27:15 +00:00
|
|
|
/* AMS_DELTA_LATCH2 */
|
2006-04-02 16:46:30 +00:00
|
|
|
{
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
.virtual = LATCH2_VIRT,
|
|
|
|
.pfn = __phys_to_pfn(LATCH2_PHYS),
|
2006-04-02 16:46:30 +00:00
|
|
|
.length = 0x01000000,
|
|
|
|
.type = MT_DEVICE
|
|
|
|
},
|
2007-12-14 02:27:15 +00:00
|
|
|
/* AMS_DELTA_MODEM */
|
2006-04-02 16:46:30 +00:00
|
|
|
{
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
.virtual = MODEM_VIRT,
|
|
|
|
.pfn = __phys_to_pfn(MODEM_PHYS),
|
2006-04-02 16:46:30 +00:00
|
|
|
.length = 0x01000000,
|
|
|
|
.type = MT_DEVICE
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
arm: omap1: fix a bunch of section mismatches
Fix the following section mismatches:
WARNING: arch/arm/mach-omap1/built-in.o(.data+0x491c): Section mismatch
in reference from the variable fsample_config to the (unknown reference)
.init.data:(unknown)
The variable fsample_config references
the (unknown reference) __initdata (unknown)
If the reference is valid then annotate the
variable with __init* or __refdata (see linux/init.h) or name the
variable:
*_template, *_timer, *_sht, *_ops, *_probe, *_probe_one, *_console,
WARNING: arch/arm/mach-omap1/built-in.o(.data+0x8f0c): Section mismatch
in reference from the variable ams_delta_config to the (unknown
reference) .init.data:(unknown)
The variable ams_delta_config references
the (unknown reference) __initdata (unknown)
If the reference is valid then annotate the
variable with __init* or __refdata (see linux/init.h) or name the
variable:
*_template, *_timer, *_sht, *_ops, *_probe, *_probe_one, *_console,
WARNING: arch/arm/mach-omap1/built-in.o(.data+0x93ac): Section mismatch
in reference from the variable ams_delta_camera_device to the (unknown
reference) .init.data:(unknown)
The variable ams_delta_camera_device references
the (unknown reference) __initdata (unknown)
If the reference is valid then annotate the
variable with __init* or __refdata (see linux/init.h) or name the
variable:
*_template, *_timer, *_sht, *_ops, *_probe, *_probe_one, *_console,
WARNING: vmlinux.o(.data+0x5e94): Section mismatch in reference from the
variable fsample_config to the (unknown reference) .init.data:(unknown)
The variable fsample_config references
the (unknown reference) __initdata (unknown)
If the reference is valid then annotate the
variable with __init* or __refdata (see linux/init.h) or name the
variable:
*_template, *_timer, *_sht, *_ops, *_probe, *_probe_one, *_console,
WARNING: vmlinux.o(.data+0xa484): Section mismatch in reference from the
variable ams_delta_config to the (unknown reference)
.init.data:(unknown)
The variable ams_delta_config references
the (unknown reference) __initdata (unknown)
If the reference is valid then annotate the
variable with __init* or __refdata (see linux/init.h) or name the
variable:
*_template, *_timer, *_sht, *_ops, *_probe, *_probe_one, *_console,
WARNING: vmlinux.o(.data+0xa924): Section mismatch in reference from the
variable ams_delta_camera_device to the (unknown reference)
.init.data:(unknown)
The variable ams_delta_camera_device references
the (unknown reference) __initdata (unknown)
If the reference is valid then annotate the
variable with __init* or __refdata (see linux/init.h) or name the
variable:
*_template, *_timer, *_sht, *_ops, *_probe, *_probe_one, *_console,
Signed-off-by: Felipe Balbi <balbi@ti.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-01-28 00:39:42 +00:00
|
|
|
static struct omap_lcd_config ams_delta_lcd_config = {
|
2006-12-07 21:58:17 +00:00
|
|
|
.ctrl_name = "internal",
|
|
|
|
};
|
|
|
|
|
2006-06-26 23:16:01 +00:00
|
|
|
static struct omap_usb_config ams_delta_usb_config __initdata = {
|
|
|
|
.register_host = 1,
|
|
|
|
.hmc_mode = 16,
|
|
|
|
.pins[0] = 2,
|
|
|
|
};
|
|
|
|
|
2011-02-09 20:40:10 +00:00
|
|
|
static struct omap_board_config_kernel ams_delta_config[] __initdata = {
|
2006-12-07 21:58:17 +00:00
|
|
|
{ OMAP_TAG_LCD, &ams_delta_lcd_config },
|
2006-04-02 16:46:30 +00:00
|
|
|
};
|
|
|
|
|
2011-12-19 23:08:53 +00:00
|
|
|
#define LATCH1_GPIO_BASE 232
|
|
|
|
#define LATCH1_NGPIO 8
|
|
|
|
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
static struct resource latch1_resources[] __initconst = {
|
|
|
|
[0] = {
|
|
|
|
.name = "dat",
|
|
|
|
.start = LATCH1_PHYS,
|
2011-12-19 23:08:53 +00:00
|
|
|
.end = LATCH1_PHYS + (LATCH1_NGPIO - 1) / 8,
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
.flags = IORESOURCE_MEM,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct bgpio_pdata latch1_pdata __initconst = {
|
2011-12-19 23:08:53 +00:00
|
|
|
.base = LATCH1_GPIO_BASE,
|
|
|
|
.ngpio = LATCH1_NGPIO,
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device latch1_gpio_device = {
|
|
|
|
.name = "basic-mmio-gpio",
|
|
|
|
.id = 0,
|
|
|
|
.resource = latch1_resources,
|
|
|
|
.num_resources = ARRAY_SIZE(latch1_resources),
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &latch1_pdata,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct resource latch2_resources[] __initconst = {
|
|
|
|
[0] = {
|
|
|
|
.name = "dat",
|
|
|
|
.start = LATCH2_PHYS,
|
|
|
|
.end = LATCH2_PHYS + (AMS_DELTA_LATCH2_NGPIO - 1) / 8,
|
|
|
|
.flags = IORESOURCE_MEM,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct bgpio_pdata latch2_pdata __initconst = {
|
|
|
|
.base = AMS_DELTA_LATCH2_GPIO_BASE,
|
|
|
|
.ngpio = AMS_DELTA_LATCH2_NGPIO,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device latch2_gpio_device = {
|
|
|
|
.name = "basic-mmio-gpio",
|
|
|
|
.id = 1,
|
|
|
|
.resource = latch2_resources,
|
|
|
|
.num_resources = ARRAY_SIZE(latch2_resources),
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &latch2_pdata,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct gpio latch_gpios[] __initconst = {
|
|
|
|
{
|
2011-12-19 23:08:53 +00:00
|
|
|
.gpio = LATCH1_GPIO_BASE + 6,
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
.flags = GPIOF_OUT_INIT_LOW,
|
|
|
|
.label = "dockit1",
|
|
|
|
},
|
|
|
|
{
|
2011-12-19 23:08:53 +00:00
|
|
|
.gpio = LATCH1_GPIO_BASE + 7,
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
.flags = GPIOF_OUT_INIT_LOW,
|
|
|
|
.label = "dockit2",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.gpio = AMS_DELTA_GPIO_PIN_SCARD_RSTIN,
|
|
|
|
.flags = GPIOF_OUT_INIT_LOW,
|
|
|
|
.label = "scard_rstin",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.gpio = AMS_DELTA_GPIO_PIN_SCARD_CMDVCC,
|
|
|
|
.flags = GPIOF_OUT_INIT_LOW,
|
|
|
|
.label = "scard_cmdvcc",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.gpio = AMS_DELTA_GPIO_PIN_MODEM_NRESET,
|
|
|
|
.flags = GPIOF_OUT_INIT_LOW,
|
|
|
|
.label = "modem_nreset",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.gpio = AMS_DELTA_GPIO_PIN_MODEM_CODEC,
|
|
|
|
.flags = GPIOF_OUT_INIT_LOW,
|
|
|
|
.label = "modem_codec",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.gpio = AMS_DELTA_LATCH2_GPIO_BASE + 14,
|
|
|
|
.flags = GPIOF_OUT_INIT_LOW,
|
|
|
|
.label = "hookflash1",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.gpio = AMS_DELTA_LATCH2_GPIO_BASE + 15,
|
|
|
|
.flags = GPIOF_OUT_INIT_LOW,
|
|
|
|
.label = "hookflash2",
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
void ams_delta_latch_write(int base, int ngpio, u16 mask, u16 value)
|
|
|
|
{
|
|
|
|
int bit = 0;
|
|
|
|
u16 bitpos = 1 << bit;
|
|
|
|
|
|
|
|
for (; bit < ngpio; bit++, bitpos = bitpos << 1) {
|
|
|
|
if (!(mask & bitpos))
|
|
|
|
continue;
|
|
|
|
gpio_set_value(base + bit, (value & bitpos) != 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ams_delta_latch_write);
|
|
|
|
|
2010-12-15 14:43:44 +00:00
|
|
|
static struct resource ams_delta_nand_resources[] = {
|
|
|
|
[0] = {
|
|
|
|
.start = OMAP1_MPUIO_BASE,
|
|
|
|
.end = OMAP1_MPUIO_BASE +
|
|
|
|
OMAP_MPUIO_IO_CNTL + sizeof(u32) - 1,
|
|
|
|
.flags = IORESOURCE_MEM,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2010-12-14 20:09:40 +00:00
|
|
|
static struct platform_device ams_delta_nand_device = {
|
|
|
|
.name = "ams-delta-nand",
|
2010-12-15 14:43:44 +00:00
|
|
|
.id = -1,
|
|
|
|
.num_resources = ARRAY_SIZE(ams_delta_nand_resources),
|
|
|
|
.resource = ams_delta_nand_resources,
|
2010-12-14 20:09:40 +00:00
|
|
|
};
|
|
|
|
|
2006-12-07 01:13:52 +00:00
|
|
|
static struct resource ams_delta_kp_resources[] = {
|
|
|
|
[0] = {
|
|
|
|
.start = INT_KEYBOARD,
|
|
|
|
.end = INT_KEYBOARD,
|
|
|
|
.flags = IORESOURCE_IRQ,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2010-12-20 21:09:22 +00:00
|
|
|
static const struct matrix_keymap_data ams_delta_keymap_data = {
|
|
|
|
.keymap = ams_delta_keymap,
|
|
|
|
.keymap_size = ARRAY_SIZE(ams_delta_keymap),
|
|
|
|
};
|
|
|
|
|
arm: omap1: fix a bunch of section mismatches
Fix the following section mismatches:
WARNING: arch/arm/mach-omap1/built-in.o(.data+0x491c): Section mismatch
in reference from the variable fsample_config to the (unknown reference)
.init.data:(unknown)
The variable fsample_config references
the (unknown reference) __initdata (unknown)
If the reference is valid then annotate the
variable with __init* or __refdata (see linux/init.h) or name the
variable:
*_template, *_timer, *_sht, *_ops, *_probe, *_probe_one, *_console,
WARNING: arch/arm/mach-omap1/built-in.o(.data+0x8f0c): Section mismatch
in reference from the variable ams_delta_config to the (unknown
reference) .init.data:(unknown)
The variable ams_delta_config references
the (unknown reference) __initdata (unknown)
If the reference is valid then annotate the
variable with __init* or __refdata (see linux/init.h) or name the
variable:
*_template, *_timer, *_sht, *_ops, *_probe, *_probe_one, *_console,
WARNING: arch/arm/mach-omap1/built-in.o(.data+0x93ac): Section mismatch
in reference from the variable ams_delta_camera_device to the (unknown
reference) .init.data:(unknown)
The variable ams_delta_camera_device references
the (unknown reference) __initdata (unknown)
If the reference is valid then annotate the
variable with __init* or __refdata (see linux/init.h) or name the
variable:
*_template, *_timer, *_sht, *_ops, *_probe, *_probe_one, *_console,
WARNING: vmlinux.o(.data+0x5e94): Section mismatch in reference from the
variable fsample_config to the (unknown reference) .init.data:(unknown)
The variable fsample_config references
the (unknown reference) __initdata (unknown)
If the reference is valid then annotate the
variable with __init* or __refdata (see linux/init.h) or name the
variable:
*_template, *_timer, *_sht, *_ops, *_probe, *_probe_one, *_console,
WARNING: vmlinux.o(.data+0xa484): Section mismatch in reference from the
variable ams_delta_config to the (unknown reference)
.init.data:(unknown)
The variable ams_delta_config references
the (unknown reference) __initdata (unknown)
If the reference is valid then annotate the
variable with __init* or __refdata (see linux/init.h) or name the
variable:
*_template, *_timer, *_sht, *_ops, *_probe, *_probe_one, *_console,
WARNING: vmlinux.o(.data+0xa924): Section mismatch in reference from the
variable ams_delta_camera_device to the (unknown reference)
.init.data:(unknown)
The variable ams_delta_camera_device references
the (unknown reference) __initdata (unknown)
If the reference is valid then annotate the
variable with __init* or __refdata (see linux/init.h) or name the
variable:
*_template, *_timer, *_sht, *_ops, *_probe, *_probe_one, *_console,
Signed-off-by: Felipe Balbi <balbi@ti.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-01-28 00:39:42 +00:00
|
|
|
static struct omap_kp_platform_data ams_delta_kp_data __initdata = {
|
2006-12-07 01:13:52 +00:00
|
|
|
.rows = 8,
|
|
|
|
.cols = 8,
|
2010-12-20 21:09:22 +00:00
|
|
|
.keymap_data = &ams_delta_keymap_data,
|
2006-12-07 01:13:52 +00:00
|
|
|
.delay = 9,
|
|
|
|
};
|
|
|
|
|
2011-07-04 10:56:15 +00:00
|
|
|
static struct platform_device ams_delta_kp_device = {
|
2006-12-07 01:13:52 +00:00
|
|
|
.name = "omap-keypad",
|
|
|
|
.id = -1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &ams_delta_kp_data,
|
|
|
|
},
|
|
|
|
.num_resources = ARRAY_SIZE(ams_delta_kp_resources),
|
|
|
|
.resource = ams_delta_kp_resources,
|
|
|
|
};
|
|
|
|
|
2011-07-04 10:56:15 +00:00
|
|
|
static struct platform_device ams_delta_lcd_device = {
|
2006-12-07 21:58:17 +00:00
|
|
|
.name = "lcd_ams_delta",
|
|
|
|
.id = -1,
|
|
|
|
};
|
|
|
|
|
2011-12-19 23:08:53 +00:00
|
|
|
static struct gpio_led gpio_leds[] __initconst = {
|
|
|
|
{
|
|
|
|
.name = "camera",
|
|
|
|
.gpio = LATCH1_GPIO_BASE + 0,
|
|
|
|
.default_state = LEDS_GPIO_DEFSTATE_OFF,
|
|
|
|
#ifdef CONFIG_LEDS_TRIGGERS
|
|
|
|
.default_trigger = "ams_delta_camera",
|
|
|
|
#endif
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "advert",
|
|
|
|
.gpio = LATCH1_GPIO_BASE + 1,
|
|
|
|
.default_state = LEDS_GPIO_DEFSTATE_OFF,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "email",
|
|
|
|
.gpio = LATCH1_GPIO_BASE + 2,
|
|
|
|
.default_state = LEDS_GPIO_DEFSTATE_OFF,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "handsfree",
|
|
|
|
.gpio = LATCH1_GPIO_BASE + 3,
|
|
|
|
.default_state = LEDS_GPIO_DEFSTATE_OFF,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "voicemail",
|
|
|
|
.gpio = LATCH1_GPIO_BASE + 4,
|
|
|
|
.default_state = LEDS_GPIO_DEFSTATE_OFF,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "voice",
|
|
|
|
.gpio = LATCH1_GPIO_BASE + 5,
|
|
|
|
.default_state = LEDS_GPIO_DEFSTATE_OFF,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct gpio_led_platform_data leds_pdata __initconst = {
|
|
|
|
.leds = gpio_leds,
|
|
|
|
.num_leds = ARRAY_SIZE(gpio_leds),
|
2006-06-23 09:05:33 +00:00
|
|
|
};
|
|
|
|
|
2010-10-01 23:37:00 +00:00
|
|
|
static struct i2c_board_info ams_delta_camera_board_info[] = {
|
|
|
|
{
|
|
|
|
I2C_BOARD_INFO("ov6650", 0x60),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2010-10-01 23:37:01 +00:00
|
|
|
#ifdef CONFIG_LEDS_TRIGGERS
|
|
|
|
DEFINE_LED_TRIGGER(ams_delta_camera_led_trigger);
|
|
|
|
|
|
|
|
static int ams_delta_camera_power(struct device *dev, int power)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* turn on camera LED
|
|
|
|
*/
|
|
|
|
if (power)
|
|
|
|
led_trigger_event(ams_delta_camera_led_trigger, LED_FULL);
|
|
|
|
else
|
|
|
|
led_trigger_event(ams_delta_camera_led_trigger, LED_OFF);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define ams_delta_camera_power NULL
|
|
|
|
#endif
|
|
|
|
|
2011-02-09 20:40:10 +00:00
|
|
|
static struct soc_camera_link ams_delta_iclink = {
|
2010-10-01 23:37:00 +00:00
|
|
|
.bus_id = 0, /* OMAP1 SoC camera bus */
|
|
|
|
.i2c_adapter_id = 1,
|
|
|
|
.board_info = &ams_delta_camera_board_info[0],
|
|
|
|
.module_name = "ov6650",
|
2010-10-01 23:37:01 +00:00
|
|
|
.power = ams_delta_camera_power,
|
2010-10-01 23:37:00 +00:00
|
|
|
};
|
|
|
|
|
2011-07-04 10:56:15 +00:00
|
|
|
static struct platform_device ams_delta_camera_device = {
|
2010-10-01 23:37:00 +00:00
|
|
|
.name = "soc-camera-pdrv",
|
|
|
|
.id = 0,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &ams_delta_iclink,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct omap1_cam_platform_data ams_delta_camera_platform_data = {
|
|
|
|
.camexclk_khz = 12000, /* default 12MHz clock, no extra DPLL */
|
|
|
|
.lclk_khz_max = 1334, /* results in 5fps CIF, 10fps QCIF */
|
|
|
|
};
|
|
|
|
|
2006-06-23 09:05:33 +00:00
|
|
|
static struct platform_device *ams_delta_devices[] __initdata = {
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
&latch1_gpio_device,
|
|
|
|
&latch2_gpio_device,
|
2006-12-07 01:13:52 +00:00
|
|
|
&ams_delta_kp_device,
|
2010-10-01 23:37:00 +00:00
|
|
|
&ams_delta_camera_device,
|
2006-06-23 09:05:33 +00:00
|
|
|
};
|
|
|
|
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
static struct platform_device *late_devices[] __initconst = {
|
ARM: OMAP1: ams-delta: register latch dependent devices later
In preparation to converting Amstrad Delta on-board latches to
basic_mmio_gpio devices, registration of platform devices which depend
on latches and will require initialization of their GPIO pins first,
should be moved out of .machine_init down to late_initcall level, as the
gpio-generic driver is not available until device_initcall time. The
latch reset operation, which will be replaced with GPIO initialization,
must also be moved to late_initcall for the same reason.
Since there was already another, separate arch_initcall function for
setting up one of those latch dependent devices, the on-board modem
device, reuse that function, i.e., rename it to a name that matches the
new purpose, extend with other device setup relocated from
.machine_init, and move down to the late_initcall level.
While being at it, add missing gpio_free() in case the modem platform
device registration fails.
Thanks to Tony Lindgren <tony@atomide.com> who suggested this approach
instead of shifting up the gpio-generic driver initialization.
In addition, defer registration of the Amstrad Delta ASoC and serio
devices, done from their device driver files, until late_initcall time,
as those drivers will depend on their GPIO pins already requested from
the board late_init() function until updated to register their GPIO pins
themselves.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Acked-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 21:54:18 +00:00
|
|
|
&ams_delta_nand_device,
|
2006-12-07 21:58:17 +00:00
|
|
|
&ams_delta_lcd_device,
|
2006-06-23 09:05:33 +00:00
|
|
|
};
|
|
|
|
|
2006-04-02 16:46:30 +00:00
|
|
|
static void __init ams_delta_init(void)
|
|
|
|
{
|
2009-10-22 21:47:42 +00:00
|
|
|
/* mux pins for uarts */
|
|
|
|
omap_cfg_reg(UART1_TX);
|
|
|
|
omap_cfg_reg(UART1_RTS);
|
|
|
|
|
2010-10-01 23:37:00 +00:00
|
|
|
/* parallel camera interface */
|
|
|
|
omap_cfg_reg(H19_1610_CAM_EXCLK);
|
|
|
|
omap_cfg_reg(J15_1610_CAM_LCLK);
|
|
|
|
omap_cfg_reg(L18_1610_CAM_VS);
|
|
|
|
omap_cfg_reg(L15_1610_CAM_HS);
|
|
|
|
omap_cfg_reg(L19_1610_CAM_D0);
|
|
|
|
omap_cfg_reg(K14_1610_CAM_D1);
|
|
|
|
omap_cfg_reg(K15_1610_CAM_D2);
|
|
|
|
omap_cfg_reg(K19_1610_CAM_D3);
|
|
|
|
omap_cfg_reg(K18_1610_CAM_D4);
|
|
|
|
omap_cfg_reg(J14_1610_CAM_D5);
|
|
|
|
omap_cfg_reg(J19_1610_CAM_D6);
|
|
|
|
omap_cfg_reg(J18_1610_CAM_D7);
|
|
|
|
|
2006-04-02 16:46:30 +00:00
|
|
|
omap_board_config = ams_delta_config;
|
|
|
|
omap_board_config_size = ARRAY_SIZE(ams_delta_config);
|
|
|
|
omap_serial_init();
|
2007-11-07 04:54:32 +00:00
|
|
|
omap_register_i2c_bus(1, 100, NULL, 0);
|
2006-04-02 16:46:30 +00:00
|
|
|
|
2010-07-05 13:31:30 +00:00
|
|
|
omap1_usb_init(&ams_delta_usb_config);
|
2010-10-01 23:37:00 +00:00
|
|
|
omap1_set_camera_info(&ams_delta_camera_platform_data);
|
2010-10-01 23:37:01 +00:00
|
|
|
#ifdef CONFIG_LEDS_TRIGGERS
|
|
|
|
led_trigger_register_simple("ams_delta_camera",
|
|
|
|
&ams_delta_camera_led_trigger);
|
|
|
|
#endif
|
2011-12-19 23:08:53 +00:00
|
|
|
gpio_led_register_device(-1, &leds_pdata);
|
2006-06-23 09:05:33 +00:00
|
|
|
platform_add_devices(ams_delta_devices, ARRAY_SIZE(ams_delta_devices));
|
2009-10-22 21:47:42 +00:00
|
|
|
|
2010-04-28 01:07:42 +00:00
|
|
|
ams_delta_init_fiq();
|
|
|
|
|
2009-10-22 21:47:42 +00:00
|
|
|
omap_writew(omap_readw(ARM_RSTCT1) | 0x0004, ARM_RSTCT1);
|
2006-04-02 16:46:30 +00:00
|
|
|
}
|
|
|
|
|
2009-08-28 17:51:37 +00:00
|
|
|
static struct plat_serial8250_port ams_delta_modem_ports[] = {
|
|
|
|
{
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
.membase = IOMEM(MODEM_VIRT),
|
|
|
|
.mapbase = MODEM_PHYS,
|
2009-08-28 17:51:37 +00:00
|
|
|
.irq = -EINVAL, /* changed later */
|
|
|
|
.flags = UPF_BOOT_AUTOCONF,
|
|
|
|
.irqflags = IRQF_TRIGGER_RISING,
|
|
|
|
.iotype = UPIO_MEM,
|
|
|
|
.regshift = 1,
|
|
|
|
.uartclk = BASE_BAUD * 16,
|
|
|
|
},
|
|
|
|
{ },
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device ams_delta_modem_device = {
|
|
|
|
.name = "serial8250",
|
|
|
|
.id = PLAT8250_DEV_PLATFORM1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = ams_delta_modem_ports,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
ARM: OMAP1: ams-delta: register latch dependent devices later
In preparation to converting Amstrad Delta on-board latches to
basic_mmio_gpio devices, registration of platform devices which depend
on latches and will require initialization of their GPIO pins first,
should be moved out of .machine_init down to late_initcall level, as the
gpio-generic driver is not available until device_initcall time. The
latch reset operation, which will be replaced with GPIO initialization,
must also be moved to late_initcall for the same reason.
Since there was already another, separate arch_initcall function for
setting up one of those latch dependent devices, the on-board modem
device, reuse that function, i.e., rename it to a name that matches the
new purpose, extend with other device setup relocated from
.machine_init, and move down to the late_initcall level.
While being at it, add missing gpio_free() in case the modem platform
device registration fails.
Thanks to Tony Lindgren <tony@atomide.com> who suggested this approach
instead of shifting up the gpio-generic driver initialization.
In addition, defer registration of the Amstrad Delta ASoC and serio
devices, done from their device driver files, until late_initcall time,
as those drivers will depend on their GPIO pins already requested from
the board late_init() function until updated to register their GPIO pins
themselves.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Acked-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 21:54:18 +00:00
|
|
|
static int __init late_init(void)
|
2009-08-28 17:51:37 +00:00
|
|
|
{
|
2010-04-28 01:05:47 +00:00
|
|
|
int err;
|
|
|
|
|
2010-12-10 17:46:24 +00:00
|
|
|
if (!machine_is_ams_delta())
|
|
|
|
return -ENODEV;
|
|
|
|
|
ARM: OMAP1: ams-delta: convert latches to basic_mmio_gpio
Once ready, ams-delta specific device drivers currently calling custom
ams_delta_latch[12]_write() functions can be updated to call generic
gpio_set_value() instead, which will make them less platform dependent.
Even more, some custom ams-delta only drivers can perhaps be dropped
from the tree after converting selected ams-delta platform devices to
follow generic GPIO based device models.
The latch_gpios[] table is initially filled with all latch1 and latch2
GPIO pins in order to register and initialize them from the board file
until those are handled by respective existing device drivers (leds,
nand, lcd, serio, asoc, serial). That table will get almost empty after
the transision process is completed, holding only pins not used by any
drivers / connected to unused devices, in order to initialize them from
the board file for power saving purposes.
The new ams_delta_latch_write() function is a unified replacement for
those removed ams_delta_latch[12]_write(), and serves as a temporary
wrapper over gpio_set_value(), providing the old API for those not yet
updated device drivers, and will be removed after all custom drivers are
converted or replaced.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 02:24:21 +00:00
|
|
|
err = gpio_request_array(latch_gpios, ARRAY_SIZE(latch_gpios));
|
|
|
|
if (err) {
|
|
|
|
pr_err("Couldn't take over latch1/latch2 GPIO pins\n");
|
|
|
|
return err;
|
|
|
|
}
|
ARM: OMAP1: ams-delta: register latch dependent devices later
In preparation to converting Amstrad Delta on-board latches to
basic_mmio_gpio devices, registration of platform devices which depend
on latches and will require initialization of their GPIO pins first,
should be moved out of .machine_init down to late_initcall level, as the
gpio-generic driver is not available until device_initcall time. The
latch reset operation, which will be replaced with GPIO initialization,
must also be moved to late_initcall for the same reason.
Since there was already another, separate arch_initcall function for
setting up one of those latch dependent devices, the on-board modem
device, reuse that function, i.e., rename it to a name that matches the
new purpose, extend with other device setup relocated from
.machine_init, and move down to the late_initcall level.
While being at it, add missing gpio_free() in case the modem platform
device registration fails.
Thanks to Tony Lindgren <tony@atomide.com> who suggested this approach
instead of shifting up the gpio-generic driver initialization.
In addition, defer registration of the Amstrad Delta ASoC and serio
devices, done from their device driver files, until late_initcall time,
as those drivers will depend on their GPIO pins already requested from
the board late_init() function until updated to register their GPIO pins
themselves.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Acked-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 21:54:18 +00:00
|
|
|
|
|
|
|
platform_add_devices(late_devices, ARRAY_SIZE(late_devices));
|
|
|
|
|
2009-08-28 17:51:37 +00:00
|
|
|
omap_cfg_reg(M14_1510_GPIO2);
|
2010-04-28 01:05:47 +00:00
|
|
|
ams_delta_modem_ports[0].irq =
|
|
|
|
gpio_to_irq(AMS_DELTA_GPIO_PIN_MODEM_IRQ);
|
|
|
|
|
|
|
|
err = gpio_request(AMS_DELTA_GPIO_PIN_MODEM_IRQ, "modem");
|
|
|
|
if (err) {
|
|
|
|
pr_err("Couldn't request gpio pin for modem\n");
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
gpio_direction_input(AMS_DELTA_GPIO_PIN_MODEM_IRQ);
|
2009-08-28 17:51:37 +00:00
|
|
|
|
|
|
|
ams_delta_latch2_write(
|
|
|
|
AMS_DELTA_LATCH2_MODEM_NRESET | AMS_DELTA_LATCH2_MODEM_CODEC,
|
|
|
|
AMS_DELTA_LATCH2_MODEM_NRESET | AMS_DELTA_LATCH2_MODEM_CODEC);
|
|
|
|
|
ARM: OMAP1: ams-delta: register latch dependent devices later
In preparation to converting Amstrad Delta on-board latches to
basic_mmio_gpio devices, registration of platform devices which depend
on latches and will require initialization of their GPIO pins first,
should be moved out of .machine_init down to late_initcall level, as the
gpio-generic driver is not available until device_initcall time. The
latch reset operation, which will be replaced with GPIO initialization,
must also be moved to late_initcall for the same reason.
Since there was already another, separate arch_initcall function for
setting up one of those latch dependent devices, the on-board modem
device, reuse that function, i.e., rename it to a name that matches the
new purpose, extend with other device setup relocated from
.machine_init, and move down to the late_initcall level.
While being at it, add missing gpio_free() in case the modem platform
device registration fails.
Thanks to Tony Lindgren <tony@atomide.com> who suggested this approach
instead of shifting up the gpio-generic driver initialization.
In addition, defer registration of the Amstrad Delta ASoC and serio
devices, done from their device driver files, until late_initcall time,
as those drivers will depend on their GPIO pins already requested from
the board late_init() function until updated to register their GPIO pins
themselves.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Acked-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 21:54:18 +00:00
|
|
|
err = platform_device_register(&ams_delta_modem_device);
|
|
|
|
if (err)
|
|
|
|
goto gpio_free;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
gpio_free:
|
|
|
|
gpio_free(AMS_DELTA_GPIO_PIN_MODEM_IRQ);
|
|
|
|
return err;
|
2009-08-28 17:51:37 +00:00
|
|
|
}
|
ARM: OMAP1: ams-delta: register latch dependent devices later
In preparation to converting Amstrad Delta on-board latches to
basic_mmio_gpio devices, registration of platform devices which depend
on latches and will require initialization of their GPIO pins first,
should be moved out of .machine_init down to late_initcall level, as the
gpio-generic driver is not available until device_initcall time. The
latch reset operation, which will be replaced with GPIO initialization,
must also be moved to late_initcall for the same reason.
Since there was already another, separate arch_initcall function for
setting up one of those latch dependent devices, the on-board modem
device, reuse that function, i.e., rename it to a name that matches the
new purpose, extend with other device setup relocated from
.machine_init, and move down to the late_initcall level.
While being at it, add missing gpio_free() in case the modem platform
device registration fails.
Thanks to Tony Lindgren <tony@atomide.com> who suggested this approach
instead of shifting up the gpio-generic driver initialization.
In addition, defer registration of the Amstrad Delta ASoC and serio
devices, done from their device driver files, until late_initcall time,
as those drivers will depend on their GPIO pins already requested from
the board late_init() function until updated to register their GPIO pins
themselves.
Signed-off-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Acked-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Tony Lindgren <tony@atomide.com>
2011-12-20 21:54:18 +00:00
|
|
|
late_initcall(late_init);
|
2009-08-28 17:51:37 +00:00
|
|
|
|
2011-11-09 23:29:31 +00:00
|
|
|
static void __init ams_delta_map_io(void)
|
|
|
|
{
|
|
|
|
omap15xx_map_io();
|
|
|
|
iotable_init(ams_delta_io_desc, ARRAY_SIZE(ams_delta_io_desc));
|
|
|
|
}
|
|
|
|
|
2006-04-02 16:46:30 +00:00
|
|
|
MACHINE_START(AMS_DELTA, "Amstrad E3 (Delta)")
|
|
|
|
/* Maintainer: Jonathan McDowell <noodles@earth.li> */
|
2011-07-06 02:38:15 +00:00
|
|
|
.atag_offset = 0x100,
|
2011-11-09 23:29:31 +00:00
|
|
|
.map_io = ams_delta_map_io,
|
2011-10-05 22:14:02 +00:00
|
|
|
.init_early = omap1_init_early,
|
2010-05-23 09:18:16 +00:00
|
|
|
.reserve = omap_reserve,
|
2011-10-05 22:14:02 +00:00
|
|
|
.init_irq = omap1_init_irq,
|
2006-04-02 16:46:30 +00:00
|
|
|
.init_machine = ams_delta_init,
|
2011-03-29 22:54:48 +00:00
|
|
|
.timer = &omap1_timer,
|
2011-11-05 17:06:28 +00:00
|
|
|
.restart = omap1_restart,
|
2006-04-02 16:46:30 +00:00
|
|
|
MACHINE_END
|