cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

board-ams-delta.c (23833B)


      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 * linux/arch/arm/mach-omap1/board-ams-delta.c
      4 *
      5 * Modified from board-generic.c
      6 *
      7 * Board specific inits for the Amstrad E3 (codename Delta) videophone
      8 *
      9 * Copyright (C) 2006 Jonathan McDowell <noodles@earth.li>
     10 */
     11#include <linux/gpio/driver.h>
     12#include <linux/gpio/machine.h>
     13#include <linux/gpio/consumer.h>
     14#include <linux/gpio.h>
     15#include <linux/kernel.h>
     16#include <linux/init.h>
     17#include <linux/input.h>
     18#include <linux/interrupt.h>
     19#include <linux/leds.h>
     20#include <linux/mtd/nand-gpio.h>
     21#include <linux/mtd/partitions.h>
     22#include <linux/platform_device.h>
     23#include <linux/regulator/consumer.h>
     24#include <linux/regulator/fixed.h>
     25#include <linux/regulator/machine.h>
     26#include <linux/serial_8250.h>
     27#include <linux/export.h>
     28#include <linux/omapfb.h>
     29#include <linux/io.h>
     30#include <linux/platform_data/gpio-omap.h>
     31#include <linux/soc/ti/omap1-mux.h>
     32
     33#include <asm/serial.h>
     34#include <asm/mach-types.h>
     35#include <asm/mach/arch.h>
     36#include <asm/mach/map.h>
     37
     38#include <linux/platform_data/keypad-omap.h>
     39
     40#include "hardware.h"
     41#include "usb.h"
     42#include "ams-delta-fiq.h"
     43#include "board-ams-delta.h"
     44#include "iomap.h"
     45#include "common.h"
     46
     47static const unsigned int ams_delta_keymap[] = {
     48	KEY(0, 0, KEY_F1),		/* Advert    */
     49
     50	KEY(0, 3, KEY_COFFEE),		/* Games     */
     51	KEY(0, 2, KEY_QUESTION),	/* Directory */
     52	KEY(2, 3, KEY_CONNECT),		/* Internet  */
     53	KEY(1, 2, KEY_SHOP),		/* Services  */
     54	KEY(1, 1, KEY_PHONE),		/* VoiceMail */
     55
     56	KEY(0, 1, KEY_DELETE),		/* Delete    */
     57	KEY(2, 2, KEY_PLAY),		/* Play      */
     58	KEY(1, 0, KEY_PAGEUP),		/* Up        */
     59	KEY(1, 3, KEY_PAGEDOWN),	/* Down      */
     60	KEY(2, 0, KEY_EMAIL),		/* ReadEmail */
     61	KEY(2, 1, KEY_STOP),		/* Stop      */
     62
     63	/* Numeric keypad portion */
     64	KEY(0, 7, KEY_KP1),
     65	KEY(0, 6, KEY_KP2),
     66	KEY(0, 5, KEY_KP3),
     67	KEY(1, 7, KEY_KP4),
     68	KEY(1, 6, KEY_KP5),
     69	KEY(1, 5, KEY_KP6),
     70	KEY(2, 7, KEY_KP7),
     71	KEY(2, 6, KEY_KP8),
     72	KEY(2, 5, KEY_KP9),
     73	KEY(3, 6, KEY_KP0),
     74	KEY(3, 7, KEY_KPASTERISK),
     75	KEY(3, 5, KEY_KPDOT),		/* # key     */
     76	KEY(7, 2, KEY_NUMLOCK),		/* Mute      */
     77	KEY(7, 1, KEY_KPMINUS),		/* Recall    */
     78	KEY(6, 1, KEY_KPPLUS),		/* Redial    */
     79	KEY(7, 6, KEY_KPSLASH),		/* Handsfree */
     80	KEY(6, 0, KEY_ENTER),		/* Video     */
     81
     82	KEY(7, 4, KEY_CAMERA),		/* Photo     */
     83
     84	KEY(0, 4, KEY_F2),		/* Home      */
     85	KEY(1, 4, KEY_F3),		/* Office    */
     86	KEY(2, 4, KEY_F4),		/* Mobile    */
     87	KEY(7, 7, KEY_F5),		/* SMS       */
     88	KEY(7, 5, KEY_F6),		/* Email     */
     89
     90	/* QWERTY portion of keypad */
     91	KEY(3, 4, KEY_Q),
     92	KEY(3, 3, KEY_W),
     93	KEY(3, 2, KEY_E),
     94	KEY(3, 1, KEY_R),
     95	KEY(3, 0, KEY_T),
     96	KEY(4, 7, KEY_Y),
     97	KEY(4, 6, KEY_U),
     98	KEY(4, 5, KEY_I),
     99	KEY(4, 4, KEY_O),
    100	KEY(4, 3, KEY_P),
    101
    102	KEY(4, 2, KEY_A),
    103	KEY(4, 1, KEY_S),
    104	KEY(4, 0, KEY_D),
    105	KEY(5, 7, KEY_F),
    106	KEY(5, 6, KEY_G),
    107	KEY(5, 5, KEY_H),
    108	KEY(5, 4, KEY_J),
    109	KEY(5, 3, KEY_K),
    110	KEY(5, 2, KEY_L),
    111
    112	KEY(5, 1, KEY_Z),
    113	KEY(5, 0, KEY_X),
    114	KEY(6, 7, KEY_C),
    115	KEY(6, 6, KEY_V),
    116	KEY(6, 5, KEY_B),
    117	KEY(6, 4, KEY_N),
    118	KEY(6, 3, KEY_M),
    119	KEY(6, 2, KEY_SPACE),
    120
    121	KEY(7, 0, KEY_LEFTSHIFT),	/* Vol up    */
    122	KEY(7, 3, KEY_LEFTCTRL),	/* Vol down  */
    123};
    124
    125#define LATCH1_PHYS	0x01000000
    126#define LATCH1_VIRT	0xEA000000
    127#define MODEM_PHYS	0x04000000
    128#define MODEM_VIRT	0xEB000000
    129#define LATCH2_PHYS	0x08000000
    130#define LATCH2_VIRT	0xEC000000
    131
    132static struct map_desc ams_delta_io_desc[] __initdata = {
    133	/* AMS_DELTA_LATCH1 */
    134	{
    135		.virtual	= LATCH1_VIRT,
    136		.pfn		= __phys_to_pfn(LATCH1_PHYS),
    137		.length		= 0x01000000,
    138		.type		= MT_DEVICE
    139	},
    140	/* AMS_DELTA_LATCH2 */
    141	{
    142		.virtual	= LATCH2_VIRT,
    143		.pfn		= __phys_to_pfn(LATCH2_PHYS),
    144		.length		= 0x01000000,
    145		.type		= MT_DEVICE
    146	},
    147	/* AMS_DELTA_MODEM */
    148	{
    149		.virtual	= MODEM_VIRT,
    150		.pfn		= __phys_to_pfn(MODEM_PHYS),
    151		.length		= 0x01000000,
    152		.type		= MT_DEVICE
    153	}
    154};
    155
    156static const struct omap_lcd_config ams_delta_lcd_config __initconst = {
    157	.ctrl_name	= "internal",
    158};
    159
    160static struct omap_usb_config ams_delta_usb_config __initdata = {
    161	.register_host	= 1,
    162	.hmc_mode	= 16,
    163	.pins[0]	= 2,
    164};
    165
    166#define LATCH1_NGPIO		8
    167
    168static struct resource latch1_resources[] = {
    169	[0] = {
    170		.name	= "dat",
    171		.start	= LATCH1_PHYS,
    172		.end	= LATCH1_PHYS + (LATCH1_NGPIO - 1) / 8,
    173		.flags	= IORESOURCE_MEM,
    174	},
    175};
    176
    177#define LATCH1_LABEL	"latch1"
    178
    179static struct bgpio_pdata latch1_pdata = {
    180	.label	= LATCH1_LABEL,
    181	.base	= -1,
    182	.ngpio	= LATCH1_NGPIO,
    183};
    184
    185static struct platform_device latch1_gpio_device = {
    186	.name		= "basic-mmio-gpio",
    187	.id		= 0,
    188	.resource	= latch1_resources,
    189	.num_resources	= ARRAY_SIZE(latch1_resources),
    190	.dev		= {
    191		.platform_data	= &latch1_pdata,
    192	},
    193};
    194
    195#define LATCH1_PIN_LED_CAMERA		0
    196#define LATCH1_PIN_LED_ADVERT		1
    197#define LATCH1_PIN_LED_MAIL		2
    198#define LATCH1_PIN_LED_HANDSFREE	3
    199#define LATCH1_PIN_LED_VOICEMAIL	4
    200#define LATCH1_PIN_LED_VOICE		5
    201#define LATCH1_PIN_DOCKIT1		6
    202#define LATCH1_PIN_DOCKIT2		7
    203
    204#define LATCH2_NGPIO			16
    205
    206static struct resource latch2_resources[] = {
    207	[0] = {
    208		.name	= "dat",
    209		.start	= LATCH2_PHYS,
    210		.end	= LATCH2_PHYS + (LATCH2_NGPIO - 1) / 8,
    211		.flags	= IORESOURCE_MEM,
    212	},
    213};
    214
    215#define LATCH2_LABEL	"latch2"
    216
    217static struct bgpio_pdata latch2_pdata = {
    218	.label	= LATCH2_LABEL,
    219	.base	= -1,
    220	.ngpio	= LATCH2_NGPIO,
    221};
    222
    223static struct platform_device latch2_gpio_device = {
    224	.name		= "basic-mmio-gpio",
    225	.id		= 1,
    226	.resource	= latch2_resources,
    227	.num_resources	= ARRAY_SIZE(latch2_resources),
    228	.dev		= {
    229		.platform_data	= &latch2_pdata,
    230	},
    231};
    232
    233#define LATCH2_PIN_LCD_VBLEN		0
    234#define LATCH2_PIN_LCD_NDISP		1
    235#define LATCH2_PIN_NAND_NCE		2
    236#define LATCH2_PIN_NAND_NRE		3
    237#define LATCH2_PIN_NAND_NWP		4
    238#define LATCH2_PIN_NAND_NWE		5
    239#define LATCH2_PIN_NAND_ALE		6
    240#define LATCH2_PIN_NAND_CLE		7
    241#define LATCH2_PIN_KEYBRD_PWR		8
    242#define LATCH2_PIN_KEYBRD_DATAOUT	9
    243#define LATCH2_PIN_SCARD_RSTIN		10
    244#define LATCH2_PIN_SCARD_CMDVCC		11
    245#define LATCH2_PIN_MODEM_NRESET		12
    246#define LATCH2_PIN_MODEM_CODEC		13
    247#define LATCH2_PIN_HANDSFREE_MUTE	14
    248#define LATCH2_PIN_HANDSET_MUTE		15
    249
    250static struct regulator_consumer_supply modem_nreset_consumers[] = {
    251	REGULATOR_SUPPLY("RESET#", "serial8250.1"),
    252	REGULATOR_SUPPLY("POR", "cx20442-codec"),
    253};
    254
    255static struct regulator_init_data modem_nreset_data = {
    256	.constraints		= {
    257		.valid_ops_mask		= REGULATOR_CHANGE_STATUS,
    258		.boot_on		= 1,
    259	},
    260	.num_consumer_supplies	= ARRAY_SIZE(modem_nreset_consumers),
    261	.consumer_supplies	= modem_nreset_consumers,
    262};
    263
    264static struct fixed_voltage_config modem_nreset_config = {
    265	.supply_name		= "modem_nreset",
    266	.microvolts		= 3300000,
    267	.startup_delay		= 25000,
    268	.enabled_at_boot	= 1,
    269	.init_data		= &modem_nreset_data,
    270};
    271
    272static struct platform_device modem_nreset_device = {
    273	.name	= "reg-fixed-voltage",
    274	.id	= -1,
    275	.dev	= {
    276		.platform_data	= &modem_nreset_config,
    277	},
    278};
    279
    280static struct gpiod_lookup_table ams_delta_nreset_gpiod_table = {
    281	.dev_id = "reg-fixed-voltage",
    282	.table = {
    283		GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_MODEM_NRESET,
    284			    NULL, GPIO_ACTIVE_HIGH),
    285		{ },
    286	},
    287};
    288
    289struct modem_private_data {
    290	struct regulator *regulator;
    291};
    292
    293static struct modem_private_data modem_priv;
    294
    295/*
    296 * Define partitions for flash device
    297 */
    298
    299static struct mtd_partition partition_info[] = {
    300	{ .name		= "Kernel",
    301	  .offset	= 0,
    302	  .size		= 3 * SZ_1M + SZ_512K },
    303	{ .name		= "u-boot",
    304	  .offset	= 3 * SZ_1M + SZ_512K,
    305	  .size		= SZ_256K },
    306	{ .name		= "u-boot params",
    307	  .offset	= 3 * SZ_1M + SZ_512K + SZ_256K,
    308	  .size		= SZ_256K },
    309	{ .name		= "Amstrad LDR",
    310	  .offset	= 4 * SZ_1M,
    311	  .size		= SZ_256K },
    312	{ .name		= "File system",
    313	  .offset	= 4 * SZ_1M + 1 * SZ_256K,
    314	  .size		= 27 * SZ_1M },
    315	{ .name		= "PBL reserved",
    316	  .offset	= 32 * SZ_1M - 3 * SZ_256K,
    317	  .size		=  3 * SZ_256K },
    318};
    319
    320static struct gpio_nand_platdata nand_platdata = {
    321	.parts		= partition_info,
    322	.num_parts	= ARRAY_SIZE(partition_info),
    323};
    324
    325static struct platform_device ams_delta_nand_device = {
    326	.name	= "ams-delta-nand",
    327	.id	= -1,
    328	.dev	= {
    329		.platform_data = &nand_platdata,
    330	},
    331};
    332
    333#define OMAP_GPIO_LABEL		"gpio-0-15"
    334#define OMAP_MPUIO_LABEL	"mpuio"
    335
    336static struct gpiod_lookup_table ams_delta_nand_gpio_table = {
    337	.table = {
    338		GPIO_LOOKUP(OMAP_GPIO_LABEL, AMS_DELTA_GPIO_PIN_NAND_RB, "rdy",
    339			    0),
    340		GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NCE, "nce",
    341			    GPIO_ACTIVE_LOW),
    342		GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NRE, "nre",
    343			    GPIO_ACTIVE_LOW),
    344		GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NWP, "nwp",
    345			    GPIO_ACTIVE_LOW),
    346		GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_NWE, "nwe",
    347			    GPIO_ACTIVE_LOW),
    348		GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_ALE, "ale", 0),
    349		GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_NAND_CLE, "cle", 0),
    350		GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 0, "data", 0, 0),
    351		GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 1, "data", 1, 0),
    352		GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 2, "data", 2, 0),
    353		GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 3, "data", 3, 0),
    354		GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 4, "data", 4, 0),
    355		GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 5, "data", 5, 0),
    356		GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 6, "data", 6, 0),
    357		GPIO_LOOKUP_IDX(OMAP_MPUIO_LABEL, 7, "data", 7, 0),
    358		{ },
    359	},
    360};
    361
    362static struct resource ams_delta_kp_resources[] = {
    363	[0] = {
    364		.start	= INT_KEYBOARD,
    365		.end	= INT_KEYBOARD,
    366		.flags	= IORESOURCE_IRQ,
    367	},
    368};
    369
    370static const struct matrix_keymap_data ams_delta_keymap_data = {
    371	.keymap		= ams_delta_keymap,
    372	.keymap_size	= ARRAY_SIZE(ams_delta_keymap),
    373};
    374
    375static struct omap_kp_platform_data ams_delta_kp_data = {
    376	.rows		= 8,
    377	.cols		= 8,
    378	.keymap_data	= &ams_delta_keymap_data,
    379	.delay		= 9,
    380};
    381
    382static struct platform_device ams_delta_kp_device = {
    383	.name		= "omap-keypad",
    384	.id		= -1,
    385	.dev		= {
    386		.platform_data = &ams_delta_kp_data,
    387	},
    388	.num_resources	= ARRAY_SIZE(ams_delta_kp_resources),
    389	.resource	= ams_delta_kp_resources,
    390};
    391
    392static struct platform_device ams_delta_lcd_device = {
    393	.name	= "lcd_ams_delta",
    394	.id	= -1,
    395};
    396
    397static struct gpiod_lookup_table ams_delta_lcd_gpio_table = {
    398	.table = {
    399		GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_LCD_VBLEN, "vblen", 0),
    400		GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_LCD_NDISP, "ndisp", 0),
    401		{ },
    402	},
    403};
    404
    405static struct gpio_led gpio_leds[] __initdata = {
    406	[LATCH1_PIN_LED_CAMERA] = {
    407		.name		 = "camera",
    408		.default_state	 = LEDS_GPIO_DEFSTATE_OFF,
    409	},
    410	[LATCH1_PIN_LED_ADVERT] = {
    411		.name		 = "advert",
    412		.default_state	 = LEDS_GPIO_DEFSTATE_OFF,
    413	},
    414	[LATCH1_PIN_LED_MAIL] = {
    415		.name		 = "email",
    416		.default_state	 = LEDS_GPIO_DEFSTATE_OFF,
    417	},
    418	[LATCH1_PIN_LED_HANDSFREE] = {
    419		.name		 = "handsfree",
    420		.default_state	 = LEDS_GPIO_DEFSTATE_OFF,
    421	},
    422	[LATCH1_PIN_LED_VOICEMAIL] = {
    423		.name		 = "voicemail",
    424		.default_state	 = LEDS_GPIO_DEFSTATE_OFF,
    425	},
    426	[LATCH1_PIN_LED_VOICE] = {
    427		.name		 = "voice",
    428		.default_state	 = LEDS_GPIO_DEFSTATE_OFF,
    429	},
    430};
    431
    432static const struct gpio_led_platform_data leds_pdata __initconst = {
    433	.leds		= gpio_leds,
    434	.num_leds	= ARRAY_SIZE(gpio_leds),
    435};
    436
    437static struct gpiod_lookup_table leds_gpio_table = {
    438	.table = {
    439		GPIO_LOOKUP_IDX(LATCH1_LABEL, LATCH1_PIN_LED_CAMERA, NULL,
    440				LATCH1_PIN_LED_CAMERA, 0),
    441		GPIO_LOOKUP_IDX(LATCH1_LABEL, LATCH1_PIN_LED_ADVERT, NULL,
    442				LATCH1_PIN_LED_ADVERT, 0),
    443		GPIO_LOOKUP_IDX(LATCH1_LABEL, LATCH1_PIN_LED_MAIL, NULL,
    444				LATCH1_PIN_LED_MAIL, 0),
    445		GPIO_LOOKUP_IDX(LATCH1_LABEL, LATCH1_PIN_LED_HANDSFREE, NULL,
    446				LATCH1_PIN_LED_HANDSFREE, 0),
    447		GPIO_LOOKUP_IDX(LATCH1_LABEL, LATCH1_PIN_LED_VOICEMAIL, NULL,
    448				LATCH1_PIN_LED_VOICEMAIL, 0),
    449		GPIO_LOOKUP_IDX(LATCH1_LABEL, LATCH1_PIN_LED_VOICE, NULL,
    450				LATCH1_PIN_LED_VOICE, 0),
    451		{ },
    452	},
    453};
    454
    455static struct platform_device ams_delta_audio_device = {
    456	.name   = "ams-delta-audio",
    457	.id     = -1,
    458};
    459
    460static struct gpiod_lookup_table ams_delta_audio_gpio_table = {
    461	.table = {
    462		GPIO_LOOKUP(OMAP_GPIO_LABEL, AMS_DELTA_GPIO_PIN_HOOK_SWITCH,
    463			    "hook_switch", 0),
    464		GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_MODEM_CODEC,
    465			    "modem_codec", 0),
    466		GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_HANDSFREE_MUTE,
    467			    "handsfree_mute", 0),
    468		GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_HANDSET_MUTE,
    469			    "handset_mute", 0),
    470		{ },
    471	},
    472};
    473
    474static struct platform_device cx20442_codec_device = {
    475	.name   = "cx20442-codec",
    476	.id     = -1,
    477};
    478
    479static struct resource ams_delta_serio_resources[] = {
    480	{
    481		.flags	= IORESOURCE_IRQ,
    482		/*
    483		 * Initialize IRQ resource with invalid IRQ number.
    484		 * It will be replaced with dynamically allocated GPIO IRQ
    485		 * obtained from GPIO chip as soon as the chip is available.
    486		 */
    487		.start	= -EINVAL,
    488		.end	= -EINVAL,
    489	},
    490};
    491
    492static struct platform_device ams_delta_serio_device = {
    493	.name		= "ams-delta-serio",
    494	.id		= PLATFORM_DEVID_NONE,
    495	.dev		= {
    496		/*
    497		 * Initialize .platform_data explicitly with NULL to
    498		 * indicate it is going to be used.  It will be replaced
    499		 * with FIQ buffer address as soon as FIQ is initialized.
    500		 */
    501		.platform_data = NULL,
    502	},
    503	.num_resources	= ARRAY_SIZE(ams_delta_serio_resources),
    504	.resource	= ams_delta_serio_resources,
    505};
    506
    507static struct regulator_consumer_supply keybrd_pwr_consumers[] = {
    508	/*
    509	 * Initialize supply .dev_name with NULL.  It will be replaced
    510	 * with serio dev_name() as soon as the serio device is registered.
    511	 */
    512	REGULATOR_SUPPLY("vcc", NULL),
    513};
    514
    515static struct regulator_init_data keybrd_pwr_initdata = {
    516	.constraints		= {
    517		.valid_ops_mask		= REGULATOR_CHANGE_STATUS,
    518	},
    519	.num_consumer_supplies	= ARRAY_SIZE(keybrd_pwr_consumers),
    520	.consumer_supplies	= keybrd_pwr_consumers,
    521};
    522
    523static struct fixed_voltage_config keybrd_pwr_config = {
    524	.supply_name		= "keybrd_pwr",
    525	.microvolts		= 5000000,
    526	.init_data		= &keybrd_pwr_initdata,
    527};
    528
    529static struct platform_device keybrd_pwr_device = {
    530	.name	= "reg-fixed-voltage",
    531	.id	= PLATFORM_DEVID_AUTO,
    532	.dev	= {
    533		.platform_data	= &keybrd_pwr_config,
    534	},
    535};
    536
    537static struct gpiod_lookup_table keybrd_pwr_gpio_table = {
    538	.table = {
    539		GPIO_LOOKUP(LATCH2_LABEL, LATCH2_PIN_KEYBRD_PWR, NULL,
    540			    GPIO_ACTIVE_HIGH),
    541		{ },
    542	},
    543};
    544
    545static struct platform_device *ams_delta_devices[] __initdata = {
    546	&latch1_gpio_device,
    547	&latch2_gpio_device,
    548	&ams_delta_kp_device,
    549	&ams_delta_audio_device,
    550	&ams_delta_serio_device,
    551	&ams_delta_nand_device,
    552	&ams_delta_lcd_device,
    553	&cx20442_codec_device,
    554};
    555
    556static struct gpiod_lookup_table *ams_delta_gpio_tables[] __initdata = {
    557	&ams_delta_nreset_gpiod_table,
    558	&ams_delta_audio_gpio_table,
    559	&keybrd_pwr_gpio_table,
    560	&ams_delta_lcd_gpio_table,
    561	&ams_delta_nand_gpio_table,
    562};
    563
    564/*
    565 * Some drivers may not use GPIO lookup tables but need to be provided
    566 * with GPIO numbers.  The same applies to GPIO based IRQ lines - some
    567 * drivers may even not use GPIO layer but expect just IRQ numbers.
    568 * We could either define GPIO lookup tables then use them on behalf
    569 * of those devices, or we can use GPIO driver level methods for
    570 * identification of GPIO and IRQ numbers. For the purpose of the latter,
    571 * defina a helper function which identifies GPIO chips by their labels.
    572 */
    573static int gpiochip_match_by_label(struct gpio_chip *chip, void *data)
    574{
    575	char *label = data;
    576
    577	return !strcmp(label, chip->label);
    578}
    579
    580static struct gpiod_hog ams_delta_gpio_hogs[] = {
    581	GPIO_HOG(LATCH2_LABEL, LATCH2_PIN_KEYBRD_DATAOUT, "keybrd_dataout",
    582		 GPIO_ACTIVE_HIGH, GPIOD_OUT_LOW),
    583	{},
    584};
    585
    586static struct plat_serial8250_port ams_delta_modem_ports[];
    587
    588/*
    589 * Obtain MODEM IRQ GPIO descriptor using its hardware pin
    590 * number and assign related IRQ number to the MODEM port.
    591 * Keep the GPIO descriptor open so nobody steps in.
    592 */
    593static void __init modem_assign_irq(struct gpio_chip *chip)
    594{
    595	struct gpio_desc *gpiod;
    596
    597	gpiod = gpiochip_request_own_desc(chip, AMS_DELTA_GPIO_PIN_MODEM_IRQ,
    598					  "modem_irq", GPIO_ACTIVE_HIGH,
    599					  GPIOD_IN);
    600	if (IS_ERR(gpiod)) {
    601		pr_err("%s: modem IRQ GPIO request failed (%ld)\n", __func__,
    602		       PTR_ERR(gpiod));
    603	} else {
    604		ams_delta_modem_ports[0].irq = gpiod_to_irq(gpiod);
    605	}
    606}
    607
    608/*
    609 * The purpose of this function is to take care of proper initialization of
    610 * devices and data structures which depend on GPIO lines provided by OMAP GPIO
    611 * banks but their drivers don't use GPIO lookup tables or GPIO layer at all.
    612 * The function may be called as soon as OMAP GPIO devices are probed.
    613 * Since that happens at postcore_initcall, it can be called successfully
    614 * from init_machine or later.
    615 * Dependent devices may be registered from within this function or later.
    616 */
    617static void __init omap_gpio_deps_init(void)
    618{
    619	struct gpio_chip *chip;
    620
    621	chip = gpiochip_find(OMAP_GPIO_LABEL, gpiochip_match_by_label);
    622	if (!chip) {
    623		pr_err("%s: OMAP GPIO chip not found\n", __func__);
    624		return;
    625	}
    626
    627	/*
    628	 * Start with FIQ initialization as it may have to request
    629	 * and release successfully each OMAP GPIO pin in turn.
    630	 */
    631	ams_delta_init_fiq(chip, &ams_delta_serio_device);
    632
    633	modem_assign_irq(chip);
    634}
    635
    636/*
    637 * Initialize latch2 pins with values which are safe for dependent on-board
    638 * devices or useful for their successull initialization even before GPIO
    639 * driver takes control over the latch pins:
    640 * - LATCH2_PIN_LCD_VBLEN	= 0
    641 * - LATCH2_PIN_LCD_NDISP	= 0	Keep LCD device powered off before its
    642 *					driver takes control over it.
    643 * - LATCH2_PIN_NAND_NCE	= 0
    644 * - LATCH2_PIN_NAND_NWP	= 0	Keep NAND device down and write-
    645 *					protected before its driver takes
    646 *					control over it.
    647 * - LATCH2_PIN_KEYBRD_PWR	= 0	Keep keyboard powered off before serio
    648 *					driver takes control over it.
    649 * - LATCH2_PIN_KEYBRD_DATAOUT	= 0	Keep low to avoid corruption of first
    650 *					byte of data received from attached
    651 *					keyboard when serio device is probed;
    652 *					the pin is also hogged low by the latch2
    653 *					GPIO driver as soon as it is ready.
    654 * - LATCH2_PIN_MODEM_NRESET	= 1	Enable voice MODEM device, allowing for
    655 *					its successful probe even before a
    656 *					regulator it depends on, which in turn
    657 *					takes control over the pin, is set up.
    658 * - LATCH2_PIN_MODEM_CODEC	= 1	Attach voice MODEM CODEC data port
    659 *					to the MODEM so the CODEC is under
    660 *					control even if audio driver doesn't
    661 *					take it over.
    662 */
    663static void __init ams_delta_latch2_init(void)
    664{
    665	u16 latch2 = 1 << LATCH2_PIN_MODEM_NRESET | 1 << LATCH2_PIN_MODEM_CODEC;
    666
    667	__raw_writew(latch2, IOMEM(LATCH2_VIRT));
    668}
    669
    670static void __init ams_delta_init(void)
    671{
    672	struct platform_device *leds_pdev;
    673
    674	/* mux pins for uarts */
    675	omap_cfg_reg(UART1_TX);
    676	omap_cfg_reg(UART1_RTS);
    677
    678	/* parallel camera interface */
    679	omap_cfg_reg(H19_1610_CAM_EXCLK);
    680	omap_cfg_reg(J15_1610_CAM_LCLK);
    681	omap_cfg_reg(L18_1610_CAM_VS);
    682	omap_cfg_reg(L15_1610_CAM_HS);
    683	omap_cfg_reg(L19_1610_CAM_D0);
    684	omap_cfg_reg(K14_1610_CAM_D1);
    685	omap_cfg_reg(K15_1610_CAM_D2);
    686	omap_cfg_reg(K19_1610_CAM_D3);
    687	omap_cfg_reg(K18_1610_CAM_D4);
    688	omap_cfg_reg(J14_1610_CAM_D5);
    689	omap_cfg_reg(J19_1610_CAM_D6);
    690	omap_cfg_reg(J18_1610_CAM_D7);
    691
    692	omap_gpio_deps_init();
    693	ams_delta_latch2_init();
    694	gpiod_add_hogs(ams_delta_gpio_hogs);
    695
    696	omap_serial_init();
    697	omap_register_i2c_bus(1, 100, NULL, 0);
    698
    699	omap1_usb_init(&ams_delta_usb_config);
    700	platform_add_devices(ams_delta_devices, ARRAY_SIZE(ams_delta_devices));
    701
    702	/*
    703	 * As soon as regulator consumers have been registered, assign their
    704	 * dev_names to consumer supply entries of respective regulators.
    705	 */
    706	keybrd_pwr_consumers[0].dev_name =
    707			dev_name(&ams_delta_serio_device.dev);
    708
    709	/*
    710	 * Once consumer supply entries are populated with dev_names,
    711	 * register regulator devices.  At this stage only the keyboard
    712	 * power regulator has its consumer supply table fully populated.
    713	 */
    714	platform_device_register(&keybrd_pwr_device);
    715
    716	/*
    717	 * As soon as GPIO consumers have been registered, assign
    718	 * their dev_names to respective GPIO lookup tables.
    719	 */
    720	ams_delta_audio_gpio_table.dev_id =
    721			dev_name(&ams_delta_audio_device.dev);
    722	keybrd_pwr_gpio_table.dev_id = dev_name(&keybrd_pwr_device.dev);
    723	ams_delta_nand_gpio_table.dev_id = dev_name(&ams_delta_nand_device.dev);
    724	ams_delta_lcd_gpio_table.dev_id = dev_name(&ams_delta_lcd_device.dev);
    725
    726	/*
    727	 * Once GPIO lookup tables are populated with dev_names, register them.
    728	 */
    729	gpiod_add_lookup_tables(ams_delta_gpio_tables,
    730				ARRAY_SIZE(ams_delta_gpio_tables));
    731
    732	leds_pdev = gpio_led_register_device(PLATFORM_DEVID_NONE, &leds_pdata);
    733	if (!IS_ERR_OR_NULL(leds_pdev)) {
    734		leds_gpio_table.dev_id = dev_name(&leds_pdev->dev);
    735		gpiod_add_lookup_table(&leds_gpio_table);
    736	}
    737
    738	omap_writew(omap_readw(ARM_RSTCT1) | 0x0004, ARM_RSTCT1);
    739
    740	omapfb_set_lcd_config(&ams_delta_lcd_config);
    741}
    742
    743static void modem_pm(struct uart_port *port, unsigned int state, unsigned old)
    744{
    745	struct modem_private_data *priv = port->private_data;
    746	int ret;
    747
    748	if (!priv)
    749		return;
    750
    751	if (IS_ERR(priv->regulator))
    752		return;
    753
    754	if (state == old)
    755		return;
    756
    757	if (state == 0)
    758		ret = regulator_enable(priv->regulator);
    759	else if (old == 0)
    760		ret = regulator_disable(priv->regulator);
    761	else
    762		ret = 0;
    763
    764	if (ret)
    765		dev_warn(port->dev,
    766			 "ams_delta modem_pm: failed to %sable regulator: %d\n",
    767			 state ? "dis" : "en", ret);
    768}
    769
    770static struct plat_serial8250_port ams_delta_modem_ports[] = {
    771	{
    772		.membase	= IOMEM(MODEM_VIRT),
    773		.mapbase	= MODEM_PHYS,
    774		.irq		= IRQ_NOTCONNECTED, /* changed later */
    775		.flags		= UPF_BOOT_AUTOCONF,
    776		.irqflags	= IRQF_TRIGGER_RISING,
    777		.iotype		= UPIO_MEM,
    778		.regshift	= 1,
    779		.uartclk	= BASE_BAUD * 16,
    780		.pm		= modem_pm,
    781		.private_data	= &modem_priv,
    782	},
    783	{ },
    784};
    785
    786static struct platform_device ams_delta_modem_device = {
    787	.name	= "serial8250",
    788	.id	= PLAT8250_DEV_PLATFORM1,
    789	.dev		= {
    790		.platform_data = ams_delta_modem_ports,
    791	},
    792};
    793
    794static int __init modem_nreset_init(void)
    795{
    796	int err;
    797
    798	err = platform_device_register(&modem_nreset_device);
    799	if (err)
    800		pr_err("Couldn't register the modem regulator device\n");
    801
    802	return err;
    803}
    804
    805
    806/*
    807 * This function expects MODEM IRQ number already assigned to the port.
    808 * The MODEM device requires its RESET# pin kept high during probe.
    809 * That requirement can be fulfilled in several ways:
    810 * - with a descriptor of already functional modem_nreset regulator
    811 *   assigned to the MODEM private data,
    812 * - with the regulator not yet controlled by modem_pm function but
    813 *   already enabled by default on probe,
    814 * - before the modem_nreset regulator is probed, with the pin already
    815 *   set high explicitly.
    816 * The last one is already guaranteed by ams_delta_latch2_init() called
    817 * from machine_init.
    818 * In order to avoid taking over ttyS0 device slot, the MODEM device
    819 * should be registered after OMAP serial ports.  Since those ports
    820 * are registered at arch_initcall, this function can be called safely
    821 * at arch_initcall_sync earliest.
    822 */
    823static int __init ams_delta_modem_init(void)
    824{
    825	int err;
    826
    827	if (!machine_is_ams_delta())
    828		return -ENODEV;
    829
    830	omap_cfg_reg(M14_1510_GPIO2);
    831
    832	/* Initialize the modem_nreset regulator consumer before use */
    833	modem_priv.regulator = ERR_PTR(-ENODEV);
    834
    835	err = platform_device_register(&ams_delta_modem_device);
    836
    837	return err;
    838}
    839arch_initcall_sync(ams_delta_modem_init);
    840
    841static int __init late_init(void)
    842{
    843	int err;
    844
    845	err = modem_nreset_init();
    846	if (err)
    847		return err;
    848
    849	/*
    850	 * Once the modem device is registered, the modem_nreset
    851	 * regulator can be requested on behalf of that device.
    852	 */
    853	modem_priv.regulator = regulator_get(&ams_delta_modem_device.dev,
    854			"RESET#");
    855	if (IS_ERR(modem_priv.regulator)) {
    856		err = PTR_ERR(modem_priv.regulator);
    857		goto unregister;
    858	}
    859	return 0;
    860
    861unregister:
    862	platform_device_unregister(&ams_delta_modem_device);
    863	return err;
    864}
    865
    866static void __init ams_delta_init_late(void)
    867{
    868	omap1_init_late();
    869	late_init();
    870}
    871
    872static void __init ams_delta_map_io(void)
    873{
    874	omap15xx_map_io();
    875	iotable_init(ams_delta_io_desc, ARRAY_SIZE(ams_delta_io_desc));
    876}
    877
    878MACHINE_START(AMS_DELTA, "Amstrad E3 (Delta)")
    879	/* Maintainer: Jonathan McDowell <noodles@earth.li> */
    880	.atag_offset	= 0x100,
    881	.map_io		= ams_delta_map_io,
    882	.init_early	= omap1_init_early,
    883	.init_irq	= omap1_init_irq,
    884	.handle_irq	= omap1_handle_irq,
    885	.init_machine	= ams_delta_init,
    886	.init_late	= ams_delta_init_late,
    887	.init_time	= omap1_timer_init,
    888	.restart	= omap1_restart,
    889MACHINE_END