GNU Linux-libre 4.19.314-gnu1
[releases.git] / arch / arm / mach-sa1100 / h3xxx.c
1 /*
2  * Support for Compaq iPAQ H3100 and H3600 handheld computers (common code)
3  *
4  * Copyright (c) 2000,1 Compaq Computer Corporation. (Author: Jamey Hicks)
5  * Copyright (c) 2009 Dmitry Artamonow <mad_soft@inbox.ru>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  */
12
13 #include <linux/kernel.h>
14 #include <linux/gpio/machine.h>
15 #include <linux/gpio.h>
16 #include <linux/gpio_keys.h>
17 #include <linux/input.h>
18 #include <linux/mtd/mtd.h>
19 #include <linux/mtd/partitions.h>
20 #include <linux/platform_data/gpio-htc-egpio.h>
21 #include <linux/platform_data/sa11x0-serial.h>
22 #include <linux/platform_device.h>
23 #include <linux/serial_core.h>
24
25 #include <asm/mach/flash.h>
26 #include <asm/mach/map.h>
27
28 #include <mach/h3xxx.h>
29 #include <mach/irqs.h>
30
31 #include "generic.h"
32
33 /*
34  * H3xxx flash support
35  */
36 static struct mtd_partition h3xxx_partitions[] = {
37         {
38                 .name           = "H3XXX boot firmware",
39                 .size           = 0x00040000,
40                 .offset         = 0,
41                 .mask_flags     = MTD_WRITEABLE,  /* force read-only */
42         }, {
43                 .name           = "H3XXX rootfs",
44                 .size           = MTDPART_SIZ_FULL,
45                 .offset         = 0x00040000,
46         }
47 };
48
49 static void h3xxx_set_vpp(int vpp)
50 {
51         gpio_set_value(H3XXX_EGPIO_VPP_ON, vpp);
52 }
53
54 static int h3xxx_flash_init(void)
55 {
56         int err = gpio_request(H3XXX_EGPIO_VPP_ON, "Flash Vpp");
57         if (err) {
58                 pr_err("%s: can't request H3XXX_EGPIO_VPP_ON\n", __func__);
59                 return err;
60         }
61
62         err = gpio_direction_output(H3XXX_EGPIO_VPP_ON, 0);
63         if (err)
64                 gpio_free(H3XXX_EGPIO_VPP_ON);
65
66         return err;
67 }
68
69 static void h3xxx_flash_exit(void)
70 {
71         gpio_free(H3XXX_EGPIO_VPP_ON);
72 }
73
74 static struct flash_platform_data h3xxx_flash_data = {
75         .map_name       = "cfi_probe",
76         .set_vpp        = h3xxx_set_vpp,
77         .init           = h3xxx_flash_init,
78         .exit           = h3xxx_flash_exit,
79         .parts          = h3xxx_partitions,
80         .nr_parts       = ARRAY_SIZE(h3xxx_partitions),
81 };
82
83 static struct resource h3xxx_flash_resource =
84         DEFINE_RES_MEM(SA1100_CS0_PHYS, SZ_32M);
85
86
87 /*
88  * H3xxx uart support
89  */
90 static struct gpio h3xxx_uart_gpio[] = {
91         { H3XXX_GPIO_COM_DCD,   GPIOF_IN,               "COM DCD" },
92         { H3XXX_GPIO_COM_CTS,   GPIOF_IN,               "COM CTS" },
93         { H3XXX_GPIO_COM_RTS,   GPIOF_OUT_INIT_LOW,     "COM RTS" },
94 };
95
96 static bool h3xxx_uart_request_gpios(void)
97 {
98         static bool h3xxx_uart_gpio_ok;
99         int rc;
100
101         if (h3xxx_uart_gpio_ok)
102                 return true;
103
104         rc = gpio_request_array(h3xxx_uart_gpio, ARRAY_SIZE(h3xxx_uart_gpio));
105         if (rc)
106                 pr_err("h3xxx_uart_request_gpios: error %d\n", rc);
107         else
108                 h3xxx_uart_gpio_ok = true;
109
110         return h3xxx_uart_gpio_ok;
111 }
112
113 static void h3xxx_uart_set_mctrl(struct uart_port *port, u_int mctrl)
114 {
115         if (port->mapbase == _Ser3UTCR0) {
116                 if (!h3xxx_uart_request_gpios())
117                         return;
118                 gpio_set_value(H3XXX_GPIO_COM_RTS, !(mctrl & TIOCM_RTS));
119         }
120 }
121
122 static u_int h3xxx_uart_get_mctrl(struct uart_port *port)
123 {
124         u_int ret = TIOCM_CD | TIOCM_CTS | TIOCM_DSR;
125
126         if (port->mapbase == _Ser3UTCR0) {
127                 if (!h3xxx_uart_request_gpios())
128                         return ret;
129                 /*
130                  * DCD and CTS bits are inverted in GPLR by RS232 transceiver
131                  */
132                 if (gpio_get_value(H3XXX_GPIO_COM_DCD))
133                         ret &= ~TIOCM_CD;
134                 if (gpio_get_value(H3XXX_GPIO_COM_CTS))
135                         ret &= ~TIOCM_CTS;
136         }
137
138         return ret;
139 }
140
141 static void h3xxx_uart_pm(struct uart_port *port, u_int state, u_int oldstate)
142 {
143         if (port->mapbase == _Ser3UTCR0) {
144                 if (!gpio_request(H3XXX_EGPIO_RS232_ON, "RS232 transceiver")) {
145                         gpio_direction_output(H3XXX_EGPIO_RS232_ON, !state);
146                         gpio_free(H3XXX_EGPIO_RS232_ON);
147                 } else {
148                         pr_err("%s: can't request H3XXX_EGPIO_RS232_ON\n",
149                                 __func__);
150                 }
151         }
152 }
153
154 /*
155  * Enable/Disable wake up events for this serial port.
156  * Obviously, we only support this on the normal COM port.
157  */
158 static int h3xxx_uart_set_wake(struct uart_port *port, u_int enable)
159 {
160         int err = -EINVAL;
161
162         if (port->mapbase == _Ser3UTCR0) {
163                 if (enable)
164                         PWER |= PWER_GPIO23 | PWER_GPIO25; /* DCD and CTS */
165                 else
166                         PWER &= ~(PWER_GPIO23 | PWER_GPIO25); /* DCD and CTS */
167                 err = 0;
168         }
169         return err;
170 }
171
172 static struct sa1100_port_fns h3xxx_port_fns __initdata = {
173         .set_mctrl      = h3xxx_uart_set_mctrl,
174         .get_mctrl      = h3xxx_uart_get_mctrl,
175         .pm             = h3xxx_uart_pm,
176         .set_wake       = h3xxx_uart_set_wake,
177 };
178
179 /*
180  * EGPIO
181  */
182
183 static struct resource egpio_resources[] = {
184         [0] = DEFINE_RES_MEM(H3600_EGPIO_PHYS, 0x4),
185 };
186
187 static struct htc_egpio_chip egpio_chips[] = {
188         [0] = {
189                 .reg_start      = 0,
190                 .gpio_base      = H3XXX_EGPIO_BASE,
191                 .num_gpios      = 16,
192                 .direction      = HTC_EGPIO_OUTPUT,
193                 .initial_values = 0x0080, /* H3XXX_EGPIO_RS232_ON */
194         },
195 };
196
197 static struct htc_egpio_platform_data egpio_info = {
198         .reg_width      = 16,
199         .bus_width      = 16,
200         .chip           = egpio_chips,
201         .num_chips      = ARRAY_SIZE(egpio_chips),
202 };
203
204 static struct platform_device h3xxx_egpio = {
205         .name           = "htc-egpio",
206         .id             = -1,
207         .resource       = egpio_resources,
208         .num_resources  = ARRAY_SIZE(egpio_resources),
209         .dev            = {
210                 .platform_data = &egpio_info,
211         },
212 };
213
214 /*
215  * GPIO keys
216  */
217
218 static struct gpio_keys_button h3xxx_button_table[] = {
219         {
220                 .code           = KEY_POWER,
221                 .gpio           = H3XXX_GPIO_PWR_BUTTON,
222                 .desc           = "Power Button",
223                 .active_low     = 1,
224                 .type           = EV_KEY,
225                 .wakeup         = 1,
226         }, {
227                 .code           = KEY_ENTER,
228                 .gpio           = H3XXX_GPIO_ACTION_BUTTON,
229                 .active_low     = 1,
230                 .desc           = "Action button",
231                 .type           = EV_KEY,
232                 .wakeup         = 0,
233         },
234 };
235
236 static struct gpio_keys_platform_data h3xxx_keys_data = {
237         .buttons  = h3xxx_button_table,
238         .nbuttons = ARRAY_SIZE(h3xxx_button_table),
239 };
240
241 static struct platform_device h3xxx_keys = {
242         .name   = "gpio-keys",
243         .id     = -1,
244         .dev    = {
245                 .platform_data = &h3xxx_keys_data,
246         },
247 };
248
249 static struct resource h3xxx_micro_resources[] = {
250         DEFINE_RES_MEM(0x80010000, SZ_4K),
251         DEFINE_RES_MEM(0x80020000, SZ_4K),
252         DEFINE_RES_IRQ(IRQ_Ser1UART),
253 };
254
255 struct platform_device h3xxx_micro_asic = {
256         .name = "ipaq-h3xxx-micro",
257         .id = -1,
258         .resource = h3xxx_micro_resources,
259         .num_resources = ARRAY_SIZE(h3xxx_micro_resources),
260 };
261
262 static struct platform_device *h3xxx_devices[] = {
263         &h3xxx_egpio,
264         &h3xxx_keys,
265         &h3xxx_micro_asic,
266 };
267
268 static struct gpiod_lookup_table h3xxx_pcmcia_gpio_table = {
269         .dev_id = "sa11x0-pcmcia",
270         .table = {
271                 GPIO_LOOKUP("gpio", H3XXX_GPIO_PCMCIA_CD0,
272                             "pcmcia0-detect", GPIO_ACTIVE_LOW),
273                 GPIO_LOOKUP("gpio", H3XXX_GPIO_PCMCIA_IRQ0,
274                             "pcmcia0-ready", GPIO_ACTIVE_HIGH),
275                 GPIO_LOOKUP("gpio", H3XXX_GPIO_PCMCIA_CD1,
276                             "pcmcia1-detect", GPIO_ACTIVE_LOW),
277                 GPIO_LOOKUP("gpio", H3XXX_GPIO_PCMCIA_IRQ1,
278                             "pcmcia1-ready", GPIO_ACTIVE_HIGH),
279                 { },
280         },
281 };
282
283 void __init h3xxx_mach_init(void)
284 {
285         gpiod_add_lookup_table(&h3xxx_pcmcia_gpio_table);
286         sa1100_register_uart_fns(&h3xxx_port_fns);
287         sa11x0_register_mtd(&h3xxx_flash_data, &h3xxx_flash_resource, 1);
288         platform_add_devices(h3xxx_devices, ARRAY_SIZE(h3xxx_devices));
289 }
290
291 static struct map_desc h3600_io_desc[] __initdata = {
292         {       /* static memory bank 2  CS#2 */
293                 .virtual        =  H3600_BANK_2_VIRT,
294                 .pfn            = __phys_to_pfn(SA1100_CS2_PHYS),
295                 .length         = 0x02800000,
296                 .type           = MT_DEVICE
297         }, {    /* static memory bank 4  CS#4 */
298                 .virtual        =  H3600_BANK_4_VIRT,
299                 .pfn            = __phys_to_pfn(SA1100_CS4_PHYS),
300                 .length         = 0x00800000,
301                 .type           = MT_DEVICE
302         }, {    /* EGPIO 0              CS#5 */
303                 .virtual        =  H3600_EGPIO_VIRT,
304                 .pfn            = __phys_to_pfn(H3600_EGPIO_PHYS),
305                 .length         = 0x01000000,
306                 .type           = MT_DEVICE
307         }
308 };
309
310 /*
311  * Common map_io initialization
312  */
313
314 void __init h3xxx_map_io(void)
315 {
316         sa1100_map_io();
317         iotable_init(h3600_io_desc, ARRAY_SIZE(h3600_io_desc));
318
319         sa1100_register_uart(0, 3); /* Common serial port */
320 //      sa1100_register_uart(1, 1); /* Microcontroller on 3100/3600 */
321
322         /* Ensure those pins are outputs and driving low  */
323         PPDR |= PPC_TXD4 | PPC_SCLK | PPC_SFRM;
324         PPSR &= ~(PPC_TXD4 | PPC_SCLK | PPC_SFRM);
325
326         /* Configure suspend conditions */
327         PGSR = 0;
328         PCFR = PCFR_OPDE;
329         PSDR = 0;
330
331         GPCR = 0x0fffffff;      /* All outputs are set low by default */
332         GPDR = 0;               /* Configure all GPIOs as input */
333 }
334