target/linux/xburst/patches-2.6.34/001-core.patch

   1 From e1828438bbdd0623cf7f9c6672f2fe65b1349aa6 Mon Sep 17 00:00:00 2001
   2 From: Lars-Peter Clausen <lars@metafoo.de>
   3 Date: Sat, 24 Apr 2010 17:35:05 +0200
   4 Subject: [PATCH] Add JZ4740 SoC core support
   5
   6 ---
   7  arch/mips/Kconfig                            |    4 +
   8  arch/mips/Makefile                           |    6 +
   9  arch/mips/include/asm/bootinfo.h             |    6 +
  10  arch/mips/include/asm/cpu.h                  |   13 +-
  11  arch/mips/include/asm/mach-jz4740/base.h     |   28 +
  12  arch/mips/include/asm/mach-jz4740/clock.h    |   28 +
  13  arch/mips/include/asm/mach-jz4740/dma.h      |   90 +++
  14  arch/mips/include/asm/mach-jz4740/gpio.h     |  398 +++++++++++
  15  arch/mips/include/asm/mach-jz4740/irq.h      |   55 ++
  16  arch/mips/include/asm/mach-jz4740/platform.h |   34 +
  17  arch/mips/include/asm/mach-jz4740/serial.h   |   30 +
  18  arch/mips/include/asm/mach-jz4740/timer.h    |   22 +
  19  arch/mips/include/asm/mach-jz4740/war.h      |   25 +
  20  arch/mips/jz4740/Kconfig                     |   29 +
  21  arch/mips/jz4740/Makefile                    |   18 +
  22  arch/mips/jz4740/clock-debugfs.c             |  109 +++
  23  arch/mips/jz4740/clock.c                     |  935 ++++++++++++++++++++++++++
  24  arch/mips/jz4740/clock.h                     |   75 ++
  25  arch/mips/jz4740/dma.c                       |  336 +++++++++
  26  arch/mips/jz4740/gpio.c                      |  598 ++++++++++++++++
  27  arch/mips/jz4740/irq.c                       |  170 +++++
  28  arch/mips/jz4740/irq.h                       |   21 +
  29  arch/mips/jz4740/platform.c                  |  246 +++++++
  30  arch/mips/jz4740/pm.c                        |   59 ++
  31  arch/mips/jz4740/prom.c                      |   69 ++
  32  arch/mips/jz4740/pwm.c                       |  167 +++++
  33  arch/mips/jz4740/reset.c                     |   81 +++
  34  arch/mips/jz4740/reset.h                     |    7 +
  35  arch/mips/jz4740/setup.c                     |   64 ++
  36  arch/mips/jz4740/time.c                      |  144 ++++
  37  arch/mips/jz4740/timer.c                     |   48 ++
  38  arch/mips/jz4740/timer.h                     |  130 ++++
  39  arch/mips/kernel/cpu-probe.c                 |   20 +
  40  arch/mips/mm/tlbex.c                         |    5 +
  41  34 files changed, 4069 insertions(+), 1 deletions(-)
  42  create mode 100644 arch/mips/include/asm/mach-jz4740/base.h
  43  create mode 100644 arch/mips/include/asm/mach-jz4740/clock.h
  44  create mode 100644 arch/mips/include/asm/mach-jz4740/dma.h
  45  create mode 100644 arch/mips/include/asm/mach-jz4740/gpio.h
  46  create mode 100644 arch/mips/include/asm/mach-jz4740/irq.h
  47  create mode 100644 arch/mips/include/asm/mach-jz4740/platform.h
  48  create mode 100644 arch/mips/include/asm/mach-jz4740/serial.h
  49  create mode 100644 arch/mips/include/asm/mach-jz4740/timer.h
  50  create mode 100644 arch/mips/include/asm/mach-jz4740/war.h
  51  create mode 100644 arch/mips/jz4740/Kconfig
  52  create mode 100644 arch/mips/jz4740/Makefile
  53  create mode 100644 arch/mips/jz4740/clock-debugfs.c
  54  create mode 100644 arch/mips/jz4740/clock.c
  55  create mode 100644 arch/mips/jz4740/clock.h
  56  create mode 100644 arch/mips/jz4740/dma.c
  57  create mode 100644 arch/mips/jz4740/gpio.c
  58  create mode 100644 arch/mips/jz4740/irq.c
  59  create mode 100644 arch/mips/jz4740/irq.h
  60  create mode 100644 arch/mips/jz4740/platform.c
  61  create mode 100644 arch/mips/jz4740/pm.c
  62  create mode 100644 arch/mips/jz4740/prom.c
  63  create mode 100644 arch/mips/jz4740/pwm.c
  64  create mode 100644 arch/mips/jz4740/reset.c
  65  create mode 100644 arch/mips/jz4740/reset.h
  66  create mode 100644 arch/mips/jz4740/setup.c
  67  create mode 100644 arch/mips/jz4740/time.c
  68  create mode 100644 arch/mips/jz4740/timer.c
  69  create mode 100644 arch/mips/jz4740/timer.h
  70
  71 diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig
  72 index 7e6fd1c..e902f02 100644
  73 --- a/arch/mips/Kconfig
  74 +++ b/arch/mips/Kconfig
  75 @@ -162,6 +162,9 @@ config MACH_JAZZ
  76          Members include the Acer PICA, MIPS Magnum 4000, MIPS Millennium and
  77          Olivetti M700-10 workstations.
  78
  79 +config MACH_JZ
  80 +       bool "Ingenic JZ4720/JZ4740 based machines"
  81 +
  82  config LASAT
  83         bool "LASAT Networks platforms"
  84         select CEVT_R4K
  85 @@ -686,6 +689,7 @@ endchoice
  86  source "arch/mips/alchemy/Kconfig"
  87  source "arch/mips/bcm63xx/Kconfig"
  88  source "arch/mips/jazz/Kconfig"
  89 +source "arch/mips/jz4740/Kconfig"
  90  source "arch/mips/lasat/Kconfig"
  91  source "arch/mips/pmc-sierra/Kconfig"
  92  source "arch/mips/powertv/Kconfig"
  93 diff --git a/arch/mips/Makefile b/arch/mips/Makefile
  94 index 0b9c01a..007a82e 100644
  95 --- a/arch/mips/Makefile
  96 +++ b/arch/mips/Makefile
  97 @@ -659,6 +659,12 @@ else
  98  load-$(CONFIG_CPU_CAVIUM_OCTEON)       += 0xffffffff81100000
  99  endif
 100
 101 +# Ingenic JZ4740
 102 +#
 103 +core-$(CONFIG_SOC_JZ4740)  += arch/mips/jz4740/
 104 +cflags-$(CONFIG_SOC_JZ4740)    += -I$(srctree)/arch/mips/include/asm/mach-jz4740
 105 +load-$(CONFIG_SOC_JZ4740)  += 0xffffffff80010000
 106 +
 107  cflags-y                       += -I$(srctree)/arch/mips/include/asm/mach-generic
 108  drivers-$(CONFIG_PCI)          += arch/mips/pci/
 109
 110 diff --git a/arch/mips/include/asm/bootinfo.h b/arch/mips/include/asm/bootinfo.h
 111 index 09eee09..15a8ef0 100644
 112 --- a/arch/mips/include/asm/bootinfo.h
 113 +++ b/arch/mips/include/asm/bootinfo.h
 114 @@ -71,6 +71,12 @@
 115  #define MACH_LEMOTE_LL2F       7
 116  #define MACH_LOONGSON_END      8
 117
 118 +/*
 119 + * Valid machtype for group INGENIC
 120 + */
 121 +#define  MACH_INGENIC_JZ4730   0       /* JZ4730 SOC           */
 122 +#define  MACH_INGENIC_JZ4740   1       /* JZ4740 SOC           */
 123 +
 124  extern char *system_type;
 125  const char *get_system_type(void);
 126
 127 diff --git a/arch/mips/include/asm/cpu.h b/arch/mips/include/asm/cpu.h
 128 index a5acda4..e67aebb 100644
 129 --- a/arch/mips/include/asm/cpu.h
 130 +++ b/arch/mips/include/asm/cpu.h
 131 @@ -34,7 +34,7 @@
 132  #define PRID_COMP_LSI          0x080000
 133  #define PRID_COMP_LEXRA                0x0b0000
 134  #define PRID_COMP_CAVIUM       0x0d0000
 135 -
 136 +#define PRID_COMP_INGENIC      0xd00000
 137
 138  /*
 139   * Assigned values for the product ID register.  In order to detect a
 140 @@ -133,6 +133,12 @@
 141  #define PRID_IMP_CAVIUM_CN52XX 0x0700
 142
 143  /*
 144 + * These are the PRID's for when 23:16 == PRID_COMP_INGENIC
 145 + */
 146 +
 147 +#define PRID_IMP_JZRISC        0x0200
 148 +
 149 +/*
 150   * Definitions for 7:0 on legacy processors
 151   */
 152
 153 @@ -226,6 +232,11 @@ enum cpu_type_enum {
 154         CPU_5KC, CPU_20KC, CPU_25KF, CPU_SB1, CPU_SB1A, CPU_LOONGSON2,
 155         CPU_CAVIUM_OCTEON, CPU_CAVIUM_OCTEON_PLUS,
 156
 157 +       /*
 158 +        * Ingenic class processors
 159 +        */
 160 +       CPU_JZRISC, CPU_XBURST,
 161 +
 162         CPU_LAST
 163  };
 164
 165 diff --git a/arch/mips/include/asm/mach-jz4740/base.h b/arch/mips/include/asm/mach-jz4740/base.h
 166 new file mode 100644
 167 index 0000000..a281972
 168 --- /dev/null
 169 +++ b/arch/mips/include/asm/mach-jz4740/base.h
 170 @@ -0,0 +1,28 @@
 171 +#ifndef __JZ4740_BASE_ADDR_H__
 172 +#define __JZ4740_BASE_ADDR_H__
 173 +
 174 +#define        JZ4740_CPM_BASE_ADDR    0xb0000000
 175 +#define        JZ4740_INTC_BASE_ADDR   0xb0001000
 176 +#define        JZ4740_TCU_BASE_ADDR    0xb0002000
 177 +#define        JZ4740_WDT_BASE_ADDR    0xb0002000
 178 +#define        JZ4740_RTC_BASE_ADDR    0xb0003000
 179 +#define        JZ4740_GPIO_BASE_ADDR   0xb0010000
 180 +#define        JZ4740_AIC_BASE_ADDR    0xb0020000
 181 +#define        JZ4740_ICDC_BASE_ADDR   0xb0020000
 182 +#define        JZ4740_MSC_BASE_ADDR    0xb0021000
 183 +#define        JZ4740_UART0_BASE_ADDR  0xb0030000
 184 +#define        JZ4740_UART1_BASE_ADDR  0xb0031000
 185 +#define        JZ4740_I2C_BASE_ADDR    0xb0042000
 186 +#define        JZ4740_SSI_BASE_ADDR    0xb0043000
 187 +#define        JZ4740_SADC_BASE_ADDR   0xb0070000
 188 +#define        JZ4740_EMC_BASE_ADDR    0xb3010000
 189 +#define        JZ4740_DMAC_BASE_ADDR   0xb3020000
 190 +#define        JZ4740_UHC_BASE_ADDR    0xb3030000
 191 +#define        JZ4740_UDC_BASE_ADDR    0xb3040000
 192 +#define        JZ4740_LCD_BASE_ADDR    0xb3050000
 193 +#define        JZ4740_SLCD_BASE_ADDR   0xb3050000
 194 +#define        JZ4740_CIM_BASE_ADDR    0xb3060000
 195 +#define JZ4740_IPU_BASE_ADDR   0xb3080000
 196 +#define        JZ4740_ETH_BASE_ADDR    0xb3100000
 197 +
 198 +#endif
 199 diff --git a/arch/mips/include/asm/mach-jz4740/clock.h b/arch/mips/include/asm/mach-jz4740/clock.h
 200 new file mode 100644
 201 index 0000000..9069727
 202 --- /dev/null
 203 +++ b/arch/mips/include/asm/mach-jz4740/clock.h
 204 @@ -0,0 +1,28 @@
 205 +/*
 206 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
 207 + *
 208 + *  This program is free software; you can redistribute         it and/or modify it
 209 + *  under  the terms of         the GNU General  Public License as published by the
 210 + *  Free Software Foundation;  either version 2 of the License, or (at your
 211 + *  option) any later version.
 212 + *
 213 + *  You should have received a copy of the  GNU General Public License along
 214 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
 215 + *  675 Mass Ave, Cambridge, MA 02139, USA.
 216 + *
 217 + */
 218 +
 219 +#ifndef __ASM_JZ4740_CLOCK_H__
 220 +#define __ASM_JZ4740_CLOCK_H__
 221 +
 222 +enum jz4740_wait_mode {
 223 +       JZ4740_WAIT_MODE_IDLE,
 224 +       JZ4740_WAIT_MODE_SLEEP,
 225 +};
 226 +
 227 +void jz4740_clock_set_wait_mode(enum jz4740_wait_mode mode);
 228 +
 229 +void jz4740_clock_udc_enable_auto_suspend(void);
 230 +void jz4740_clock_udc_disable_auto_suspend(void);
 231 +
 232 +#endif
 233 diff --git a/arch/mips/include/asm/mach-jz4740/dma.h b/arch/mips/include/asm/mach-jz4740/dma.h
 234 new file mode 100644
 235 index 0000000..bb7fc1e
 236 --- /dev/null
 237 +++ b/arch/mips/include/asm/mach-jz4740/dma.h
 238 @@ -0,0 +1,90 @@
 239 +/*
 240 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
 241 + *  JZ7420/JZ4740 DMA definitions
 242 + *
 243 + *  This program is free software; you can redistribute         it and/or modify it
 244 + *  under  the terms of         the GNU General  Public License as published by the
 245 + *  Free Software Foundation;  either version 2 of the License, or (at your
 246 + *  option) any later version.
 247 + *
 248 + *  You should have received a copy of the  GNU General Public License along
 249 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
 250 + *  675 Mass Ave, Cambridge, MA 02139, USA.
 251 + *
 252 + */
 253 +
 254 +#ifndef __ASM_MACH_JZ4740_DMA_H__
 255 +#define __ASM_MACH_JZ4740_DMA_H__
 256 +
 257 +struct jz4740_dma_chan;
 258 +
 259 +enum jz4740_dma_request_type {
 260 +       JZ4740_DMA_TYPE_AUTO_REQUEST =   8,
 261 +       JZ4740_DMA_TYPE_UART_TRANSMIT = 20,
 262 +       JZ4740_DMA_TYPE_UART_RECEIVE =  21,
 263 +       JZ4740_DMA_TYPE_SPI_TRANSMIT =  22,
 264 +       JZ4740_DMA_TYPE_SPI_RECEIVE =   23,
 265 +       JZ4740_DMA_TYPE_AIC_TRANSMIT =  24,
 266 +       JZ4740_DMA_TYPE_AIC_RECEIVE =   25,
 267 +       JZ4740_DMA_TYPE_MMC_TRANSMIT =  26,
 268 +       JZ4740_DMA_TYPE_MMC_RECEIVE =   27,
 269 +       JZ4740_DMA_TYPE_TCU =           28,
 270 +       JZ4740_DMA_TYPE_SADC =          29,
 271 +       JZ4740_DMA_TYPE_SLCD =          30,
 272 +};
 273 +
 274 +enum jz4740_dma_width {
 275 +       JZ4740_DMA_WIDTH_32BIT  = 0,
 276 +       JZ4740_DMA_WIDTH_8BIT   = 1,
 277 +       JZ4740_DMA_WIDTH_16BIT  = 2,
 278 +};
 279 +
 280 +enum jz4740_dma_transfer_size {
 281 +       JZ4740_DMA_TRANSFER_SIZE_4BYTE  = 0,
 282 +       JZ4740_DMA_TRANSFER_SIZE_1BYTE  = 1,
 283 +       JZ4740_DMA_TRANSFER_SIZE_2BYTE  = 2,
 284 +       JZ4740_DMA_TRANSFER_SIZE_16BYTE = 3,
 285 +       JZ4740_DMA_TRANSFER_SIZE_32BYTE = 4,
 286 +};
 287 +
 288 +enum jz4740_dma_flags {
 289 +       JZ4740_DMA_SRC_AUTOINC = 0x2,
 290 +       JZ4740_DMA_DST_AUTOINC = 0x1,
 291 +};
 292 +
 293 +enum jz4740_dma_mode {
 294 +       JZ4740_DMA_MODE_SINGLE = 0,
 295 +       JZ4740_DMA_MODE_BLOCK = 1,
 296 +};
 297 +
 298 +struct jz4740_dma_config {
 299 +       enum jz4740_dma_width src_width;
 300 +       enum jz4740_dma_width dst_width;
 301 +       enum jz4740_dma_transfer_size transfer_size;
 302 +       enum jz4740_dma_request_type request_type;
 303 +       enum jz4740_dma_flags flags;
 304 +       enum jz4740_dma_mode mode;
 305 +};
 306 +
 307 +typedef void (*jz4740_dma_complete_callback_t)(struct jz4740_dma_chan *, int, void *);
 308 +
 309 +struct jz4740_dma_chan *jz4740_dma_request(void *dev, const char *name);
 310 +void jz4740_dma_free(struct jz4740_dma_chan *dma);
 311 +
 312 +void jz4740_dma_configure(struct jz4740_dma_chan *dma,
 313 +       const struct jz4740_dma_config *config);
 314 +
 315 +
 316 +void jz4740_dma_enable(struct jz4740_dma_chan *dma);
 317 +void jz4740_dma_disable(struct jz4740_dma_chan *dma);
 318 +
 319 +void jz4740_dma_set_src_addr(struct jz4740_dma_chan *dma, dma_addr_t src);
 320 +void jz4740_dma_set_dst_addr(struct jz4740_dma_chan *dma, dma_addr_t dst);
 321 +void jz4740_dma_set_transfer_count(struct jz4740_dma_chan *dma, uint32_t count);
 322 +
 323 +uint32_t jz4740_dma_get_residue(const struct jz4740_dma_chan *dma);
 324 +
 325 +void jz4740_dma_set_complete_cb(struct jz4740_dma_chan *dma,
 326 +       jz4740_dma_complete_callback_t cb);
 327 +
 328 +#endif  /* __ASM_JZ4740_DMA_H__ */
 329 diff --git a/arch/mips/include/asm/mach-jz4740/gpio.h b/arch/mips/include/asm/mach-jz4740/gpio.h
 330 new file mode 100644
 331 index 0000000..5f175d7
 332 --- /dev/null
 333 +++ b/arch/mips/include/asm/mach-jz4740/gpio.h
 334 @@ -0,0 +1,398 @@
 335 +/*
 336 + *  Copyright (C) 2009, Lars-Peter Clausen <lars@metafoo.de>
 337 + *  JZ7420/JZ4740 GPIO pin definitions
 338 + *
 339 + *  This program is free software; you can redistribute         it and/or modify it
 340 + *  under  the terms of         the GNU General  Public License as published by the
 341 + *  Free Software Foundation;  either version 2 of the License, or (at your
 342 + *  option) any later version.
 343 + *
 344 + *  You should have received a copy of the  GNU General Public License along
 345 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
 346 + *  675 Mass Ave, Cambridge, MA 02139, USA.
 347 + *
 348 + */
 349 +
 350 +#ifndef _JZ_GPIO_H
 351 +#define _JZ_GPIO_H
 352 +
 353 +#include <linux/types.h>
 354 +
 355 +enum jz_gpio_function {
 356 +    JZ_GPIO_FUNC_NONE,
 357 +    JZ_GPIO_FUNC1,
 358 +    JZ_GPIO_FUNC2,
 359 +    JZ_GPIO_FUNC3,
 360 +};
 361 +
 362 +
 363 +/*
 364 + Usually a driver for a SoC component has to request several gpio pins and
 365 + configure them as funcion pins.
 366 + jz_gpio_bulk_request can be used to ease this process.
 367 + Usually one would do something like:
 368 +
 369 + const static struct jz_gpio_bulk_request i2c_pins[] = {
 370 +       JZ_GPIO_BULK_PIN(I2C_SDA),
 371 +       JZ_GPIO_BULK_PIN(I2C_SCK),
 372 + };
 373 +
 374 + inside the probe function:
 375 +
 376 +    ret = jz_gpio_bulk_request(i2c_pins, ARRAY_SIZE(i2c_pins));
 377 +    if (ret) {
 378 +       ...
 379 +
 380 + inside the remove function:
 381 +
 382 +    jz_gpio_bulk_free(i2c_pins, ARRAY_SIZE(i2c_pins));
 383 +
 384 +
 385 +*/
 386 +struct jz_gpio_bulk_request {
 387 +       int gpio;
 388 +       const char *name;
 389 +       enum jz_gpio_function function;
 390 +};
 391 +
 392 +#define JZ_GPIO_BULK_PIN(pin) { \
 393 +    .gpio = JZ_GPIO_ ## pin, \
 394 +    .name = #pin, \
 395 +    .function = JZ_GPIO_FUNC_ ## pin \
 396 +}
 397 +
 398 +int jz_gpio_bulk_request(const struct jz_gpio_bulk_request *request, size_t num);
 399 +void jz_gpio_bulk_free(const struct jz_gpio_bulk_request *request, size_t num);
 400 +void jz_gpio_bulk_suspend(const struct jz_gpio_bulk_request *request, size_t num);
 401 +void jz_gpio_bulk_resume(const struct jz_gpio_bulk_request *request, size_t num);
 402 +void jz_gpio_enable_pullup(unsigned gpio);
 403 +void jz_gpio_disable_pullup(unsigned gpio);
 404 +int jz_gpio_set_function(int gpio, enum jz_gpio_function function);
 405 +
 406 +int jz_gpio_port_direction_input(int port, uint32_t mask);
 407 +int jz_gpio_port_direction_output(int port, uint32_t mask);
 408 +void jz_gpio_port_set_value(int port, uint32_t value, uint32_t mask);
 409 +uint32_t jz_gpio_port_get_value(int port, uint32_t mask);
 410 +
 411 +#include <asm/mach-generic/gpio.h>
 412 +
 413 +#define JZ_GPIO_PORTA(x) ((x) + 32 * 0)
 414 +#define JZ_GPIO_PORTB(x) ((x) + 32 * 1)
 415 +#define JZ_GPIO_PORTC(x) ((x) + 32 * 2)
 416 +#define JZ_GPIO_PORTD(x) ((x) + 32 * 3)
 417 +
 418 +/* Port A function pins */
 419 +#define JZ_GPIO_MEM_DATA0              JZ_GPIO_PORTA(0)
 420 +#define JZ_GPIO_MEM_DATA1              JZ_GPIO_PORTA(1)
 421 +#define JZ_GPIO_MEM_DATA2              JZ_GPIO_PORTA(2)
 422 +#define JZ_GPIO_MEM_DATA3              JZ_GPIO_PORTA(3)
 423 +#define JZ_GPIO_MEM_DATA4              JZ_GPIO_PORTA(4)
 424 +#define JZ_GPIO_MEM_DATA5              JZ_GPIO_PORTA(5)
 425 +#define JZ_GPIO_MEM_DATA6              JZ_GPIO_PORTA(6)
 426 +#define JZ_GPIO_MEM_DATA7              JZ_GPIO_PORTA(7)
 427 +#define JZ_GPIO_MEM_DATA8              JZ_GPIO_PORTA(8)
 428 +#define JZ_GPIO_MEM_DATA9              JZ_GPIO_PORTA(9)
 429 +#define JZ_GPIO_MEM_DATA10             JZ_GPIO_PORTA(10)
 430 +#define JZ_GPIO_MEM_DATA11             JZ_GPIO_PORTA(11)
 431 +#define JZ_GPIO_MEM_DATA12             JZ_GPIO_PORTA(12)
 432 +#define JZ_GPIO_MEM_DATA13             JZ_GPIO_PORTA(13)
 433 +#define JZ_GPIO_MEM_DATA14             JZ_GPIO_PORTA(14)
 434 +#define JZ_GPIO_MEM_DATA15             JZ_GPIO_PORTA(15)
 435 +#define JZ_GPIO_MEM_DATA16             JZ_GPIO_PORTA(16)
 436 +#define JZ_GPIO_MEM_DATA17             JZ_GPIO_PORTA(17)
 437 +#define JZ_GPIO_MEM_DATA18             JZ_GPIO_PORTA(18)
 438 +#define JZ_GPIO_MEM_DATA19             JZ_GPIO_PORTA(19)
 439 +#define JZ_GPIO_MEM_DATA20             JZ_GPIO_PORTA(20)
 440 +#define JZ_GPIO_MEM_DATA21             JZ_GPIO_PORTA(21)
 441 +#define JZ_GPIO_MEM_DATA22             JZ_GPIO_PORTA(22)
 442 +#define JZ_GPIO_MEM_DATA23             JZ_GPIO_PORTA(23)
 443 +#define JZ_GPIO_MEM_DATA24             JZ_GPIO_PORTA(24)
 444 +#define JZ_GPIO_MEM_DATA25             JZ_GPIO_PORTA(25)
 445 +#define JZ_GPIO_MEM_DATA26             JZ_GPIO_PORTA(26)
 446 +#define JZ_GPIO_MEM_DATA27             JZ_GPIO_PORTA(27)
 447 +#define JZ_GPIO_MEM_DATA28             JZ_GPIO_PORTA(28)
 448 +#define JZ_GPIO_MEM_DATA29             JZ_GPIO_PORTA(29)
 449 +#define JZ_GPIO_MEM_DATA30             JZ_GPIO_PORTA(30)
 450 +#define JZ_GPIO_MEM_DATA31             JZ_GPIO_PORTA(31)
 451 +
 452 +#define JZ_GPIO_FUNC_MEM_DATA0         JZ_GPIO_FUNC1
 453 +#define JZ_GPIO_FUNC_MEM_DATA1         JZ_GPIO_FUNC1
 454 +#define JZ_GPIO_FUNC_MEM_DATA2         JZ_GPIO_FUNC1
 455 +#define JZ_GPIO_FUNC_MEM_DATA3         JZ_GPIO_FUNC1
 456 +#define JZ_GPIO_FUNC_MEM_DATA4         JZ_GPIO_FUNC1
 457 +#define JZ_GPIO_FUNC_MEM_DATA5         JZ_GPIO_FUNC1
 458 +#define JZ_GPIO_FUNC_MEM_DATA6         JZ_GPIO_FUNC1
 459 +#define JZ_GPIO_FUNC_MEM_DATA7         JZ_GPIO_FUNC1
 460 +#define JZ_GPIO_FUNC_MEM_DATA8         JZ_GPIO_FUNC1
 461 +#define JZ_GPIO_FUNC_MEM_DATA9         JZ_GPIO_FUNC1
 462 +#define JZ_GPIO_FUNC_MEM_DATA10                JZ_GPIO_FUNC1
 463 +#define JZ_GPIO_FUNC_MEM_DATA11                JZ_GPIO_FUNC1
 464 +#define JZ_GPIO_FUNC_MEM_DATA12                JZ_GPIO_FUNC1
 465 +#define JZ_GPIO_FUNC_MEM_DATA13                JZ_GPIO_FUNC1
 466 +#define JZ_GPIO_FUNC_MEM_DATA14                JZ_GPIO_FUNC1
 467 +#define JZ_GPIO_FUNC_MEM_DATA15                JZ_GPIO_FUNC1
 468 +#define JZ_GPIO_FUNC_MEM_DATA16                JZ_GPIO_FUNC1
 469 +#define JZ_GPIO_FUNC_MEM_DATA17                JZ_GPIO_FUNC1
 470 +#define JZ_GPIO_FUNC_MEM_DATA18                JZ_GPIO_FUNC1
 471 +#define JZ_GPIO_FUNC_MEM_DATA19                JZ_GPIO_FUNC1
 472 +#define JZ_GPIO_FUNC_MEM_DATA20                JZ_GPIO_FUNC1
 473 +#define JZ_GPIO_FUNC_MEM_DATA21                JZ_GPIO_FUNC1
 474 +#define JZ_GPIO_FUNC_MEM_DATA22                JZ_GPIO_FUNC1
 475 +#define JZ_GPIO_FUNC_MEM_DATA23                JZ_GPIO_FUNC1
 476 +#define JZ_GPIO_FUNC_MEM_DATA24                JZ_GPIO_FUNC1
 477 +#define JZ_GPIO_FUNC_MEM_DATA25                JZ_GPIO_FUNC1
 478 +#define JZ_GPIO_FUNC_MEM_DATA26                JZ_GPIO_FUNC1
 479 +#define JZ_GPIO_FUNC_MEM_DATA27                JZ_GPIO_FUNC1
 480 +#define JZ_GPIO_FUNC_MEM_DATA28                JZ_GPIO_FUNC1
 481 +#define JZ_GPIO_FUNC_MEM_DATA29                JZ_GPIO_FUNC1
 482 +#define JZ_GPIO_FUNC_MEM_DATA30                JZ_GPIO_FUNC1
 483 +#define JZ_GPIO_FUNC_MEM_DATA31                JZ_GPIO_FUNC1
 484 +
 485 +/* Port B function pins */
 486 +#define JZ_GPIO_MEM_ADDR0              JZ_GPIO_PORTB(0)
 487 +#define JZ_GPIO_MEM_ADDR1              JZ_GPIO_PORTB(1)
 488 +#define JZ_GPIO_MEM_ADDR2              JZ_GPIO_PORTB(2)
 489 +#define JZ_GPIO_MEM_ADDR3              JZ_GPIO_PORTB(3)
 490 +#define JZ_GPIO_MEM_ADDR4              JZ_GPIO_PORTB(4)
 491 +#define JZ_GPIO_MEM_ADDR5              JZ_GPIO_PORTB(5)
 492 +#define JZ_GPIO_MEM_ADDR6              JZ_GPIO_PORTB(6)
 493 +#define JZ_GPIO_MEM_ADDR7              JZ_GPIO_PORTB(7)
 494 +#define JZ_GPIO_MEM_ADDR8              JZ_GPIO_PORTB(8)
 495 +#define JZ_GPIO_MEM_ADDR9              JZ_GPIO_PORTB(9)
 496 +#define JZ_GPIO_MEM_ADDR10             JZ_GPIO_PORTB(10)
 497 +#define JZ_GPIO_MEM_ADDR11             JZ_GPIO_PORTB(11)
 498 +#define JZ_GPIO_MEM_ADDR12             JZ_GPIO_PORTB(12)
 499 +#define JZ_GPIO_MEM_ADDR13             JZ_GPIO_PORTB(13)
 500 +#define JZ_GPIO_MEM_ADDR14             JZ_GPIO_PORTB(14)
 501 +#define JZ_GPIO_MEM_ADDR15             JZ_GPIO_PORTB(15)
 502 +#define JZ_GPIO_MEM_ADDR16             JZ_GPIO_PORTB(16)
 503 +#define JZ_GPIO_MEM_CLS                        JZ_GPIO_PORTB(17)
 504 +#define JZ_GPIO_MEM_SPL                        JZ_GPIO_PORTB(18)
 505 +#define JZ_GPIO_MEM_DCS                        JZ_GPIO_PORTB(19)
 506 +#define JZ_GPIO_MEM_RAS                        JZ_GPIO_PORTB(20)
 507 +#define JZ_GPIO_MEM_CAS                        JZ_GPIO_PORTB(21)
 508 +#define JZ_GPIO_MEM_SDWE               JZ_GPIO_PORTB(22)
 509 +#define JZ_GPIO_MEM_CKE                        JZ_GPIO_PORTB(23)
 510 +#define JZ_GPIO_MEM_CKO                        JZ_GPIO_PORTB(24)
 511 +#define JZ_GPIO_MEM_CS0                        JZ_GPIO_PORTB(25)
 512 +#define JZ_GPIO_MEM_CS1                        JZ_GPIO_PORTB(26)
 513 +#define JZ_GPIO_MEM_CS2                        JZ_GPIO_PORTB(27)
 514 +#define JZ_GPIO_MEM_CS3                        JZ_GPIO_PORTB(28)
 515 +#define JZ_GPIO_MEM_RD                 JZ_GPIO_PORTB(29)
 516 +#define JZ_GPIO_MEM_WR                 JZ_GPIO_PORTB(30)
 517 +#define JZ_GPIO_MEM_WE0                        JZ_GPIO_PORTB(31)
 518 +
 519 +#define JZ_GPIO_FUNC_MEM_ADDR0         JZ_GPIO_FUNC1
 520 +#define JZ_GPIO_FUNC_MEM_ADDR1         JZ_GPIO_FUNC1
 521 +#define JZ_GPIO_FUNC_MEM_ADDR2         JZ_GPIO_FUNC1
 522 +#define JZ_GPIO_FUNC_MEM_ADDR3         JZ_GPIO_FUNC1
 523 +#define JZ_GPIO_FUNC_MEM_ADDR4         JZ_GPIO_FUNC1
 524 +#define JZ_GPIO_FUNC_MEM_ADDR5         JZ_GPIO_FUNC1
 525 +#define JZ_GPIO_FUNC_MEM_ADDR6         JZ_GPIO_FUNC1
 526 +#define JZ_GPIO_FUNC_MEM_ADDR7         JZ_GPIO_FUNC1
 527 +#define JZ_GPIO_FUNC_MEM_ADDR8         JZ_GPIO_FUNC1
 528 +#define JZ_GPIO_FUNC_MEM_ADDR9         JZ_GPIO_FUNC1
 529 +#define JZ_GPIO_FUNC_MEM_ADDR10                JZ_GPIO_FUNC1
 530 +#define JZ_GPIO_FUNC_MEM_ADDR11                JZ_GPIO_FUNC1
 531 +#define JZ_GPIO_FUNC_MEM_ADDR12                JZ_GPIO_FUNC1
 532 +#define JZ_GPIO_FUNC_MEM_ADDR13                JZ_GPIO_FUNC1
 533 +#define JZ_GPIO_FUNC_MEM_ADDR14                JZ_GPIO_FUNC1
 534 +#define JZ_GPIO_FUNC_MEM_ADDR15                JZ_GPIO_FUNC1
 535 +#define JZ_GPIO_FUNC_MEM_ADDR16                JZ_GPIO_FUNC1
 536 +#define JZ_GPIO_FUNC_MEM_CLS           JZ_GPIO_FUNC1
 537 +#define JZ_GPIO_FUNC_MEM_SPL           JZ_GPIO_FUNC1
 538 +#define JZ_GPIO_FUNC_MEM_DCS           JZ_GPIO_FUNC1
 539 +#define JZ_GPIO_FUNC_MEM_RAS           JZ_GPIO_FUNC1
 540 +#define JZ_GPIO_FUNC_MEM_CAS           JZ_GPIO_FUNC1
 541 +#define JZ_GPIO_FUNC_MEM_SDWE          JZ_GPIO_FUNC1
 542 +#define JZ_GPIO_FUNC_MEM_CKE           JZ_GPIO_FUNC1
 543 +#define JZ_GPIO_FUNC_MEM_CKO           JZ_GPIO_FUNC1
 544 +#define JZ_GPIO_FUNC_MEM_CS0           JZ_GPIO_FUNC1
 545 +#define JZ_GPIO_FUNC_MEM_CS1           JZ_GPIO_FUNC1
 546 +#define JZ_GPIO_FUNC_MEM_CS2           JZ_GPIO_FUNC1
 547 +#define JZ_GPIO_FUNC_MEM_CS3           JZ_GPIO_FUNC1
 548 +#define JZ_GPIO_FUNC_MEM_RD            JZ_GPIO_FUNC1
 549 +#define JZ_GPIO_FUNC_MEM_WR            JZ_GPIO_FUNC1
 550 +#define JZ_GPIO_FUNC_MEM_WE0           JZ_GPIO_FUNC1
 551 +
 552 +
 553 +#define JZ_GPIO_MEM_ADDR21             JZ_GPIO_PORTB(17)
 554 +#define JZ_GPIO_MEM_ADDR22             JZ_GPIO_PORTB(18)
 555 +
 556 +#define JZ_GPIO_FUNC_MEM_ADDR21                JZ_GPIO_FUNC2
 557 +#define JZ_GPIO_FUNC_MEM_ADDR22                JZ_GPIO_FUNC2
 558 +
 559 +/* Port C function pins */
 560 +#define JZ_GPIO_LCD_DATA0              JZ_GPIO_PORTC(0)
 561 +#define JZ_GPIO_LCD_DATA1              JZ_GPIO_PORTC(1)
 562 +#define JZ_GPIO_LCD_DATA2              JZ_GPIO_PORTC(2)
 563 +#define JZ_GPIO_LCD_DATA3              JZ_GPIO_PORTC(3)
 564 +#define JZ_GPIO_LCD_DATA4              JZ_GPIO_PORTC(4)
 565 +#define JZ_GPIO_LCD_DATA5              JZ_GPIO_PORTC(5)
 566 +#define JZ_GPIO_LCD_DATA6              JZ_GPIO_PORTC(6)
 567 +#define JZ_GPIO_LCD_DATA7              JZ_GPIO_PORTC(7)
 568 +#define JZ_GPIO_LCD_DATA8              JZ_GPIO_PORTC(8)
 569 +#define JZ_GPIO_LCD_DATA9              JZ_GPIO_PORTC(9)
 570 +#define JZ_GPIO_LCD_DATA10             JZ_GPIO_PORTC(10)
 571 +#define JZ_GPIO_LCD_DATA11             JZ_GPIO_PORTC(11)
 572 +#define JZ_GPIO_LCD_DATA12             JZ_GPIO_PORTC(12)
 573 +#define JZ_GPIO_LCD_DATA13             JZ_GPIO_PORTC(13)
 574 +#define JZ_GPIO_LCD_DATA14             JZ_GPIO_PORTC(14)
 575 +#define JZ_GPIO_LCD_DATA15             JZ_GPIO_PORTC(15)
 576 +#define JZ_GPIO_LCD_DATA16             JZ_GPIO_PORTC(16)
 577 +#define JZ_GPIO_LCD_DATA17             JZ_GPIO_PORTC(17)
 578 +#define JZ_GPIO_LCD_PCLK               JZ_GPIO_PORTC(18)
 579 +#define JZ_GPIO_LCD_HSYNC              JZ_GPIO_PORTC(19)
 580 +#define JZ_GPIO_LCD_VSYNC              JZ_GPIO_PORTC(20)
 581 +#define JZ_GPIO_LCD_DE                 JZ_GPIO_PORTC(21)
 582 +#define JZ_GPIO_LCD_PS                 JZ_GPIO_PORTC(22)
 583 +#define JZ_GPIO_LCD_REV                        JZ_GPIO_PORTC(23)
 584 +#define JZ_GPIO_MEM_WE1                        JZ_GPIO_PORTC(24)
 585 +#define JZ_GPIO_MEM_WE2                        JZ_GPIO_PORTC(25)
 586 +#define JZ_GPIO_MEM_WE3                        JZ_GPIO_PORTC(26)
 587 +#define JZ_GPIO_MEM_WAIT               JZ_GPIO_PORTC(27)
 588 +#define JZ_GPIO_MEM_FRE                        JZ_GPIO_PORTC(28)
 589 +#define JZ_GPIO_MEM_FWE                        JZ_GPIO_PORTC(29)
 590 +
 591 +#define JZ_GPIO_FUNC_LCD_DATA0         JZ_GPIO_FUNC1
 592 +#define JZ_GPIO_FUNC_LCD_DATA1         JZ_GPIO_FUNC1
 593 +#define JZ_GPIO_FUNC_LCD_DATA2         JZ_GPIO_FUNC1
 594 +#define JZ_GPIO_FUNC_LCD_DATA3         JZ_GPIO_FUNC1
 595 +#define JZ_GPIO_FUNC_LCD_DATA4         JZ_GPIO_FUNC1
 596 +#define JZ_GPIO_FUNC_LCD_DATA5         JZ_GPIO_FUNC1
 597 +#define JZ_GPIO_FUNC_LCD_DATA6         JZ_GPIO_FUNC1
 598 +#define JZ_GPIO_FUNC_LCD_DATA7         JZ_GPIO_FUNC1
 599 +#define JZ_GPIO_FUNC_LCD_DATA8         JZ_GPIO_FUNC1
 600 +#define JZ_GPIO_FUNC_LCD_DATA9         JZ_GPIO_FUNC1
 601 +#define JZ_GPIO_FUNC_LCD_DATA10                JZ_GPIO_FUNC1
 602 +#define JZ_GPIO_FUNC_LCD_DATA11                JZ_GPIO_FUNC1
 603 +#define JZ_GPIO_FUNC_LCD_DATA12                JZ_GPIO_FUNC1
 604 +#define JZ_GPIO_FUNC_LCD_DATA13                JZ_GPIO_FUNC1
 605 +#define JZ_GPIO_FUNC_LCD_DATA14                JZ_GPIO_FUNC1
 606 +#define JZ_GPIO_FUNC_LCD_DATA15                JZ_GPIO_FUNC1
 607 +#define JZ_GPIO_FUNC_LCD_DATA16                JZ_GPIO_FUNC1
 608 +#define JZ_GPIO_FUNC_LCD_DATA17                JZ_GPIO_FUNC1
 609 +#define JZ_GPIO_FUNC_LCD_PCLK          JZ_GPIO_FUNC1
 610 +#define JZ_GPIO_FUNC_LCD_VSYNC         JZ_GPIO_FUNC1
 611 +#define JZ_GPIO_FUNC_LCD_HSYNC         JZ_GPIO_FUNC1
 612 +#define JZ_GPIO_FUNC_LCD_DE            JZ_GPIO_FUNC1
 613 +#define JZ_GPIO_FUNC_LCD_PS            JZ_GPIO_FUNC1
 614 +#define JZ_GPIO_FUNC_LCD_REV           JZ_GPIO_FUNC1
 615 +#define JZ_GPIO_FUNC_MEM_WE1           JZ_GPIO_FUNC1
 616 +#define JZ_GPIO_FUNC_MEM_WE2           JZ_GPIO_FUNC1
 617 +#define JZ_GPIO_FUNC_MEM_WE3           JZ_GPIO_FUNC1
 618 +#define JZ_GPIO_FUNC_MEM_WAIT          JZ_GPIO_FUNC1
 619 +#define JZ_GPIO_FUNC_MEM_FRE           JZ_GPIO_FUNC1
 620 +#define JZ_GPIO_FUNC_MEM_FWE           JZ_GPIO_FUNC1
 621 +
 622 +
 623 +#define JZ_GPIO_MEM_ADDR19             JZ_GPIO_PORTB(22)
 624 +#define JZ_GPIO_MEM_ADDR20             JZ_GPIO_PORTB(23)
 625 +
 626 +#define JZ_GPIO_FUNC_MEM_ADDR19                JZ_GPIO_FUNC2
 627 +#define JZ_GPIO_FUNC_MEM_ADDR20                JZ_GPIO_FUNC2
 628 +
 629 +/* Port D function pins */
 630 +#define JZ_GPIO_CIM_DATA0              JZ_GPIO_PORTD(0)
 631 +#define JZ_GPIO_CIM_DATA1              JZ_GPIO_PORTD(1)
 632 +#define JZ_GPIO_CIM_DATA2              JZ_GPIO_PORTD(2)
 633 +#define JZ_GPIO_CIM_DATA3              JZ_GPIO_PORTD(3)
 634 +#define JZ_GPIO_CIM_DATA4              JZ_GPIO_PORTD(4)
 635 +#define JZ_GPIO_CIM_DATA5              JZ_GPIO_PORTD(5)
 636 +#define JZ_GPIO_CIM_DATA6              JZ_GPIO_PORTD(6)
 637 +#define JZ_GPIO_CIM_DATA7              JZ_GPIO_PORTD(7)
 638 +#define JZ_GPIO_MSC_CMD                        JZ_GPIO_PORTD(8)
 639 +#define JZ_GPIO_MSC_CLK                        JZ_GPIO_PORTD(9)
 640 +#define JZ_GPIO_MSC_DATA0              JZ_GPIO_PORTD(10)
 641 +#define JZ_GPIO_MSC_DATA1              JZ_GPIO_PORTD(11)
 642 +#define JZ_GPIO_MSC_DATA2              JZ_GPIO_PORTD(12)
 643 +#define JZ_GPIO_MSC_DATA3              JZ_GPIO_PORTD(13)
 644 +#define JZ_GPIO_CIM_MCLK               JZ_GPIO_PORTD(14)
 645 +#define JZ_GPIO_CIM_PCLK               JZ_GPIO_PORTD(15)
 646 +#define JZ_GPIO_CIM_VSYNC              JZ_GPIO_PORTD(16)
 647 +#define JZ_GPIO_CIM_HSYNC              JZ_GPIO_PORTD(17)
 648 +#define JZ_GPIO_SPI_CLK                        JZ_GPIO_PORTD(18)
 649 +#define JZ_GPIO_SPI_CE0                        JZ_GPIO_PORTD(19)
 650 +#define JZ_GPIO_SPI_DT                 JZ_GPIO_PORTD(20)
 651 +#define JZ_GPIO_SPI_DR                 JZ_GPIO_PORTD(21)
 652 +#define JZ_GPIO_SPI_CE1                        JZ_GPIO_PORTD(22)
 653 +#define JZ_GPIO_PWM0                   JZ_GPIO_PORTD(23)
 654 +#define JZ_GPIO_PWM1                   JZ_GPIO_PORTD(24)
 655 +#define JZ_GPIO_PWM2                   JZ_GPIO_PORTD(25)
 656 +#define JZ_GPIO_PWM3                   JZ_GPIO_PORTD(26)
 657 +#define JZ_GPIO_PWM4                   JZ_GPIO_PORTD(27)
 658 +#define JZ_GPIO_PWM5                   JZ_GPIO_PORTD(28)
 659 +#define JZ_GPIO_PWM6                   JZ_GPIO_PORTD(30)
 660 +#define JZ_GPIO_PWM7                   JZ_GPIO_PORTD(31)
 661 +
 662 +#define JZ_GPIO_FUNC_CIM_DATA          JZ_GPIO_FUNC1
 663 +#define JZ_GPIO_FUNC_CIM_DATA0         JZ_GPIO_FUNC_CIM_DATA
 664 +#define JZ_GPIO_FUNC_CIM_DATA1         JZ_GPIO_FUNC_CIM_DATA
 665 +#define JZ_GPIO_FUNC_CIM_DATA2         JZ_GPIO_FUNC_CIM_DATA
 666 +#define JZ_GPIO_FUNC_CIM_DATA3         JZ_GPIO_FUNC_CIM_DATA
 667 +#define JZ_GPIO_FUNC_CIM_DATA4         JZ_GPIO_FUNC_CIM_DATA
 668 +#define JZ_GPIO_FUNC_CIM_DATA5         JZ_GPIO_FUNC_CIM_DATA
 669 +#define JZ_GPIO_FUNC_CIM_DATA6         JZ_GPIO_FUNC_CIM_DATA
 670 +#define JZ_GPIO_FUNC_CIM_DATA7         JZ_GPIO_FUNC_CIM_DATA
 671 +#define JZ_GPIO_FUNC_MSC_CMD           JZ_GPIO_FUNC1
 672 +#define JZ_GPIO_FUNC_MSC_CLK           JZ_GPIO_FUNC1
 673 +#define JZ_GPIO_FUNC_MSC_DATA          JZ_GPIO_FUNC1
 674 +#define JZ_GPIO_FUNC_MSC_DATA0         JZ_GPIO_FUNC_MSC_DATA
 675 +#define JZ_GPIO_FUNC_MSC_DATA1         JZ_GPIO_FUNC_MSC_DATA
 676 +#define JZ_GPIO_FUNC_MSC_DATA2         JZ_GPIO_FUNC_MSC_DATA
 677 +#define JZ_GPIO_FUNC_MSC_DATA3         JZ_GPIO_FUNC_MSC_DATA
 678 +#define JZ_GPIO_FUNC_CIM_MCLK          JZ_GPIO_FUNC1
 679 +#define JZ_GPIO_FUNC_CIM_PCLK          JZ_GPIO_FUNC1
 680 +#define JZ_GPIO_FUNC_CIM_VSYNC         JZ_GPIO_FUNC1
 681 +#define JZ_GPIO_FUNC_CIM_HSYNC         JZ_GPIO_FUNC1
 682 +#define JZ_GPIO_FUNC_SPI_CLK           JZ_GPIO_FUNC1
 683 +#define JZ_GPIO_FUNC_SPI_CE0           JZ_GPIO_FUNC1
 684 +#define JZ_GPIO_FUNC_SPI_DT            JZ_GPIO_FUNC1
 685 +#define JZ_GPIO_FUNC_SPI_DR            JZ_GPIO_FUNC1
 686 +#define JZ_GPIO_FUNC_SPI_CE1           JZ_GPIO_FUNC1
 687 +
 688 +#define JZ_GPIO_FUNC_PWM               JZ_GPIO_FUNC1
 689 +#define JZ_GPIO_FUNC_PWM0              JZ_GPIO_FUNC_PWM
 690 +#define JZ_GPIO_FUNC_PWM1              JZ_GPIO_FUNC_PWM
 691 +#define JZ_GPIO_FUNC_PWM2              JZ_GPIO_FUNC_PWM
 692 +#define JZ_GPIO_FUNC_PWM3              JZ_GPIO_FUNC_PWM
 693 +#define JZ_GPIO_FUNC_PWM4              JZ_GPIO_FUNC_PWM
 694 +#define JZ_GPIO_FUNC_PWM5              JZ_GPIO_FUNC_PWM
 695 +#define JZ_GPIO_FUNC_PWM6              JZ_GPIO_FUNC_PWM
 696 +#define JZ_GPIO_FUNC_PWM7              JZ_GPIO_FUNC_PWM
 697 +
 698 +#define JZ_GPIO_MEM_SCLK_RSTN          JZ_GPIO_PORTD(18)
 699 +#define JZ_GPIO_MEM_BCLK               JZ_GPIO_PORTD(19)
 700 +#define JZ_GPIO_MEM_SDATO              JZ_GPIO_PORTD(20)
 701 +#define JZ_GPIO_MEM_SDATI              JZ_GPIO_PORTD(21)
 702 +#define JZ_GPIO_MEM_SYNC               JZ_GPIO_PORTD(22)
 703 +#define JZ_GPIO_I2C_SDA                        JZ_GPIO_PORTD(23)
 704 +#define JZ_GPIO_I2C_SCK                        JZ_GPIO_PORTD(24)
 705 +#define JZ_GPIO_UART0_TXD              JZ_GPIO_PORTD(25)
 706 +#define JZ_GPIO_UART0_RXD              JZ_GPIO_PORTD(26)
 707 +#define JZ_GPIO_MEM_ADDR17             JZ_GPIO_PORTD(27)
 708 +#define JZ_GPIO_MEM_ADDR18             JZ_GPIO_PORTD(28)
 709 +#define JZ_GPIO_UART0_CTS              JZ_GPIO_PORTD(30)
 710 +#define JZ_GPIO_UART0_RTS              JZ_GPIO_PORTD(31)
 711 +
 712 +#define JZ_GPIO_FUNC_MEM_SCLK_RSTN     JZ_GPIO_FUNC2
 713 +#define JZ_GPIO_FUNC_MEM_BCLK          JZ_GPIO_FUNC2
 714 +#define JZ_GPIO_FUNC_MEM_SDATO         JZ_GPIO_FUNC2
 715 +#define JZ_GPIO_FUNC_MEM_SDATI         JZ_GPIO_FUNC2
 716 +#define JZ_GPIO_FUNC_MEM_SYNC          JZ_GPIO_FUNC2
 717 +#define JZ_GPIO_FUNC_I2C_SDA           JZ_GPIO_FUNC2
 718 +#define JZ_GPIO_FUNC_I2C_SCK           JZ_GPIO_FUNC2
 719 +#define JZ_GPIO_FUNC_UART0_TXD         JZ_GPIO_FUNC2
 720 +#define JZ_GPIO_FUNC_UART0_RXD         JZ_GPIO_FUNC2
 721 +#define JZ_GPIO_FUNC_MEM_ADDR17                JZ_GPIO_FUNC2
 722 +#define JZ_GPIO_FUNC_MEM_ADDR18                JZ_GPIO_FUNC2
 723 +#define JZ_GPIO_FUNC_UART0_CTS         JZ_GPIO_FUNC2
 724 +#define JZ_GPIO_FUNC_UART0_RTS         JZ_GPIO_FUNC2
 725 +
 726 +#define JZ_GPIO_UART1_RXD              JZ_GPIO_PORTD(30)
 727 +#define JZ_GPIO_UART1_TXD              JZ_GPIO_PORTD(31)
 728 +
 729 +#define JZ_GPIO_FUNC_UART1_RXD         JZ_GPIO_FUNC3
 730 +#define JZ_GPIO_FUNC_UART1_TXD         JZ_GPIO_FUNC3
 731 +
 732 +#endif
 733 diff --git a/arch/mips/include/asm/mach-jz4740/irq.h b/arch/mips/include/asm/mach-jz4740/irq.h
 734 new file mode 100644
 735 index 0000000..5e27b78
 736 --- /dev/null
 737 +++ b/arch/mips/include/asm/mach-jz4740/irq.h
 738 @@ -0,0 +1,55 @@
 739 +/*
 740 + *  Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
 741 + *  JZ7420/JZ4740 IRQ definitions
 742 + *
 743 + *  This program is free software; you can redistribute         it and/or modify it
 744 + *  under  the terms of         the GNU General  Public License as published by the
 745 + *  Free Software Foundation;  either version 2 of the License, or (at your
 746 + *  option) any later version.
 747 + *
 748 + *  You should have received a copy of the  GNU General Public License along
 749 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
 750 + *  675 Mass Ave, Cambridge, MA 02139, USA.
 751 + *
 752 + */
 753 +
 754 +#ifndef __ASM_MACH_JZ4740_IRQ_H__
 755 +#define __ASM_MACH_JZ4740_IRQ_H__
 756 +
 757 +#define MIPS_CPU_IRQ_BASE 0
 758 +#define JZ4740_IRQ_BASE 8
 759 +
 760 +/* 1st-level interrupts */
 761 +#define JZ4740_IRQ(x)  (JZ4740_IRQ_BASE + (x))
 762 +#define JZ4740_IRQ_I2C JZ4740_IRQ(1)
 763 +#define JZ4740_IRQ_UHC JZ4740_IRQ(3)
 764 +#define JZ4740_IRQ_UART1       JZ4740_IRQ(8)
 765 +#define JZ4740_IRQ_UART0       JZ4740_IRQ(9)
 766 +#define JZ4740_IRQ_SADC        JZ4740_IRQ(12)
 767 +#define JZ4740_IRQ_MSC JZ4740_IRQ(14)
 768 +#define JZ4740_IRQ_RTC JZ4740_IRQ(15)
 769 +#define JZ4740_IRQ_SSI JZ4740_IRQ(16)
 770 +#define JZ4740_IRQ_CIM JZ4740_IRQ(17)
 771 +#define JZ4740_IRQ_AIC JZ4740_IRQ(18)
 772 +#define JZ4740_IRQ_ETH JZ4740_IRQ(19)
 773 +#define JZ4740_IRQ_DMAC        JZ4740_IRQ(20)
 774 +#define JZ4740_IRQ_TCU2        JZ4740_IRQ(21)
 775 +#define JZ4740_IRQ_TCU1        JZ4740_IRQ(22)
 776 +#define JZ4740_IRQ_TCU0        JZ4740_IRQ(23)
 777 +#define JZ4740_IRQ_UDC JZ4740_IRQ(24)
 778 +#define JZ4740_IRQ_GPIO3       JZ4740_IRQ(25)
 779 +#define JZ4740_IRQ_GPIO2       JZ4740_IRQ(26)
 780 +#define JZ4740_IRQ_GPIO1       JZ4740_IRQ(27)
 781 +#define JZ4740_IRQ_GPIO0       JZ4740_IRQ(28)
 782 +#define JZ4740_IRQ_IPU JZ4740_IRQ(29)
 783 +#define JZ4740_IRQ_LCD JZ4740_IRQ(30)
 784 +
 785 +/* 2nd-level interrupts */
 786 +#define JZ4740_IRQ_DMA(x)      ((x) + JZ4740_IRQ(32))
 787 +
 788 +#define JZ4740_IRQ_INTC_GPIO(x)        (JZ4740_IRQ_GPIO0 - (x))
 789 +#define JZ4740_IRQ_GPIO(x)             (JZ4740_IRQ(48) + (x))
 790 +
 791 +#define NR_IRQS (JZ4740_IRQ_GPIO(127) + 1)
 792 +
 793 +#endif
 794 diff --git a/arch/mips/include/asm/mach-jz4740/platform.h b/arch/mips/include/asm/mach-jz4740/platform.h
 795 new file mode 100644
 796 index 0000000..a2e2871
 797 --- /dev/null
 798 +++ b/arch/mips/include/asm/mach-jz4740/platform.h
 799 @@ -0,0 +1,34 @@
 800 +/*
 801 + *  Copyright (C) 2009, Lars-Peter Clausen <lars@metafoo.de>
 802 + *  JZ7420/JZ4740 platform device definitions
 803 + *
 804 + *  This program is free software; you can redistribute         it and/or modify it
 805 + *  under  the terms of         the GNU General  Public License as published by the
 806 + *  Free Software Foundation;  either version 2 of the License, or (at your
 807 + *  option) any later version.
 808 + *
 809 + *  You should have received a copy of the  GNU General Public License along
 810 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
 811 + *  675 Mass Ave, Cambridge, MA 02139, USA.
 812 + *
 813 + */
 814 +
 815 +
 816 +#ifndef __JZ4740_PLATFORM_H
 817 +#define __JZ4740_PLATFORM_H
 818 +
 819 +#include <linux/platform_device.h>
 820 +
 821 +extern struct platform_device jz4740_usb_ohci_device;
 822 +extern struct platform_device jz4740_usb_gdt_device;
 823 +extern struct platform_device jz4740_mmc_device;
 824 +extern struct platform_device jz4740_rtc_device;
 825 +extern struct platform_device jz4740_i2c_device;
 826 +extern struct platform_device jz4740_nand_device;
 827 +extern struct platform_device jz4740_framebuffer_device;
 828 +extern struct platform_device jz4740_i2s_device;
 829 +extern struct platform_device jz4740_codec_device;
 830 +extern struct platform_device jz4740_adc_device;
 831 +extern struct platform_device jz4740_battery_device;
 832 +
 833 +#endif
 834 diff --git a/arch/mips/include/asm/mach-jz4740/serial.h b/arch/mips/include/asm/mach-jz4740/serial.h
 835 new file mode 100644
 836 index 0000000..c4819b9
 837 --- /dev/null
 838 +++ b/arch/mips/include/asm/mach-jz4740/serial.h
 839 @@ -0,0 +1,30 @@
 840 +/*
 841 + *  linux/include/asm-mips/mach-jz4740/serial.h
 842 + *
 843 + *  Ingenic's JZ4740 common include.
 844 + *
 845 + *  Copyright (C) 2006 - 2007 Ingenic Semiconductor Inc.
 846 + *
 847 + *  Author: <yliu@ingenic.cn>
 848 + *
 849 + * This program is free software; you can redistribute it and/or modify
 850 + * it under the terms of the GNU General Public License version 2 as
 851 + * published by the Free Software Foundation.
 852 + */
 853 +
 854 +#ifndef __ASM_BOARD_SERIAL_H__
 855 +#define __ASM_BOARD_SERIAL_H__
 856 +
 857 +#ifndef CONFIG_SERIAL_MANY_PORTS
 858 +#undef RS_TABLE_SIZE
 859 +#define RS_TABLE_SIZE  1
 860 +#endif
 861 +
 862 +#define JZ_BASE_BAUD   (12000000/16)
 863 +
 864 +#define JZ_SERIAL_PORT_DEFNS \
 865 +       { .baud_base = JZ_BASE_BAUD, .irq = IRQ_UART0, \
 866 +         .flags = STD_COM_FLAGS, .iomem_base = (u8 *)UART0_BASE, \
 867 +         .iomem_reg_shift = 2, .io_type = SERIAL_IO_MEM },
 868 +
 869 +#endif /* __ASM_BORAD_SERIAL_H__ */
 870 diff --git a/arch/mips/include/asm/mach-jz4740/timer.h b/arch/mips/include/asm/mach-jz4740/timer.h
 871 new file mode 100644
 872 index 0000000..30153ff
 873 --- /dev/null
 874 +++ b/arch/mips/include/asm/mach-jz4740/timer.h
 875 @@ -0,0 +1,22 @@
 876 +/*
 877 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
 878 + *     JZ4740 platform timer support
 879 + *
 880 + *  This program is free software; you can redistribute         it and/or modify it
 881 + *  under  the terms of         the GNU General  Public License as published by the
 882 + *  Free Software Foundation;  either version 2 of the License, or (at your
 883 + *  option) any later version.
 884 + *
 885 + *  You should have received a copy of the  GNU General Public License along
 886 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
 887 + *  675 Mass Ave, Cambridge, MA 02139, USA.
 888 + *
 889 + */
 890 +
 891 +#ifndef __ASM_MACH_JZ4740_TIMER
 892 +#define __ASM_MACH_JZ4740_TIMER
 893 +
 894 +void jz4740_timer_enable_watchdog(void);
 895 +void jz4740_timer_disable_watchdog(void);
 896 +
 897 +#endif
 898 diff --git a/arch/mips/include/asm/mach-jz4740/war.h b/arch/mips/include/asm/mach-jz4740/war.h
 899 new file mode 100644
 900 index 0000000..3a5bc17
 901 --- /dev/null
 902 +++ b/arch/mips/include/asm/mach-jz4740/war.h
 903 @@ -0,0 +1,25 @@
 904 +/*
 905 + * This file is subject to the terms and conditions of the GNU General Public
 906 + * License.  See the file "COPYING" in the main directory of this archive
 907 + * for more details.
 908 + *
 909 + * Copyright (C) 2002, 2004, 2007 by Ralf Baechle <ralf@linux-mips.org>
 910 + */
 911 +#ifndef __ASM_MIPS_MACH_JZ4740_WAR_H
 912 +#define __ASM_MIPS_MACH_JZ4740_WAR_H
 913 +
 914 +#define R4600_V1_INDEX_ICACHEOP_WAR    0
 915 +#define R4600_V1_HIT_CACHEOP_WAR       0
 916 +#define R4600_V2_HIT_CACHEOP_WAR       0
 917 +#define R5432_CP0_INTERRUPT_WAR                0
 918 +#define BCM1250_M3_WAR                 0
 919 +#define SIBYTE_1956_WAR                        0
 920 +#define MIPS4K_ICACHE_REFILL_WAR       0
 921 +#define MIPS_CACHE_SYNC_WAR            0
 922 +#define TX49XX_ICACHE_INDEX_INV_WAR    0
 923 +#define RM9000_CDEX_SMP_WAR            0
 924 +#define ICACHE_REFILLS_WORKAROUND_WAR  0
 925 +#define R10000_LLSC_WAR                        0
 926 +#define MIPS34K_MISSED_ITLB_WAR                0
 927 +
 928 +#endif /* __ASM_MIPS_MACH_JZ4740_WAR_H */
 929 diff --git a/arch/mips/jz4740/Kconfig b/arch/mips/jz4740/Kconfig
 930 new file mode 100644
 931 index 0000000..b959769
 932 --- /dev/null
 933 +++ b/arch/mips/jz4740/Kconfig
 934 @@ -0,0 +1,29 @@
 935 +choice
 936 +       prompt "Machine type"
 937 +       depends on MACH_JZ
 938 +       default JZ4740_QI_LB60
 939 +
 940 +endchoice
 941 +
 942 +config HAVE_PWM
 943 +       bool
 944 +
 945 +config SOC_JZ4740
 946 +       bool
 947 +       select JZSOC
 948 +       select GENERIC_GPIO
 949 +       select ARCH_REQUIRE_GPIOLIB
 950 +       select SYS_HAS_EARLY_PRINTK
 951 +       select SYS_SUPPORTS_LITTLE_ENDIAN
 952 +       select IRQ_CPU
 953 +       select DMA_NONCOHERENT
 954 +       select HAVE_PWM
 955 +
 956 +config JZSOC
 957 +       bool
 958 +       select JZRISC
 959 +       select SYS_HAS_CPU_MIPS32_R1
 960 +       select SYS_SUPPORTS_32BIT_KERNEL
 961 +
 962 +config JZRISC
 963 +       bool
 964 diff --git a/arch/mips/jz4740/Makefile b/arch/mips/jz4740/Makefile
 965 new file mode 100644
 966 index 0000000..398ee91
 967 --- /dev/null
 968 +++ b/arch/mips/jz4740/Makefile
 969 @@ -0,0 +1,18 @@
 970 +#
 971 +# Makefile for the Ingenic JZ4740.
 972 +#
 973 +
 974 +# Object file lists.
 975 +
 976 +obj-y += prom.o irq.o time.o reset.o setup.o dma.o \
 977 +       gpio.o clock.o platform.o timer.o pwm.o
 978 +
 979 +obj-$(CONFIG_DEBUG_FS) += clock-debugfs.o
 980 +
 981 +# board specific support
 982 +
 983 +# PM support
 984 +
 985 +obj-$(CONFIG_PM) += pm.o
 986 +
 987 +EXTRA_CFLAGS += -Werror -Wall
 988 diff --git a/arch/mips/jz4740/clock-debugfs.c b/arch/mips/jz4740/clock-debugfs.c
 989 new file mode 100644
 990 index 0000000..993b91b
 991 --- /dev/null
 992 +++ b/arch/mips/jz4740/clock-debugfs.c
 993 @@ -0,0 +1,109 @@
 994 +/*
 995 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
 996 + *  JZ4740 SoC clock support debugfs entries
 997 + *
 998 + *  This program is free software; you can redistribute         it and/or modify it
 999 + *  under  the terms of         the GNU General  Public License as published by the
1000 + *  Free Software Foundation;  either version 2 of the License, or (at your
1001 + *  option) any later version.
1002 + *
1003 + *  You should have received a copy of the  GNU General Public License along
1004 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
1005 + *  675 Mass Ave, Cambridge, MA 02139, USA.
1006 + *
1007 + */
1008 +
1009 +#include <linux/kernel.h>
1010 +#include <linux/module.h>
1011 +#include <linux/clk.h>
1012 +#include <linux/err.h>
1013 +
1014 +#include <linux/debugfs.h>
1015 +#include <linux/uaccess.h>
1016 +
1017 +#include <asm/mach-jz4740/clock.h>
1018 +#include "clock.h"
1019 +
1020 +static struct dentry *jz4740_clock_debugfs;
1021 +
1022 +static int jz4740_clock_debugfs_show_enabled(void *data, uint64_t *value)
1023 +{
1024 +       struct clk *clk = data;
1025 +       *value = clk_is_enabled(clk);
1026 +
1027 +       return 0;
1028 +}
1029 +
1030 +static int jz4740_clock_debugfs_set_enabled(void *data, uint64_t value)
1031 +{
1032 +       struct clk *clk = data;
1033 +
1034 +       if (value)
1035 +               return clk_enable(clk);
1036 +       else
1037 +               clk_disable(clk);
1038 +
1039 +       return 0;
1040 +}
1041 +
1042 +DEFINE_SIMPLE_ATTRIBUTE(jz4740_clock_debugfs_ops_enabled,
1043 +       jz4740_clock_debugfs_show_enabled,
1044 +       jz4740_clock_debugfs_set_enabled,
1045 +       "%llu\n");
1046 +
1047 +static int jz4740_clock_debugfs_show_rate(void *data, uint64_t *value)
1048 +{
1049 +       struct clk *clk = data;
1050 +       *value = clk_get_rate(clk);
1051 +
1052 +       return 0;
1053 +}
1054 +
1055 +DEFINE_SIMPLE_ATTRIBUTE(jz4740_clock_debugfs_ops_rate,
1056 +       jz4740_clock_debugfs_show_rate,
1057 +       NULL,
1058 +       "%llu\n");
1059 +
1060 +void jz4740_clock_debugfs_add_clk(struct clk *clk)
1061 +{
1062 +       if (!jz4740_clock_debugfs)
1063 +               return;
1064 +
1065 +       clk->debugfs_entry = debugfs_create_dir(clk->name, jz4740_clock_debugfs);
1066 +       debugfs_create_file("rate", S_IWUGO | S_IRUGO, clk->debugfs_entry, clk,
1067 +                               &jz4740_clock_debugfs_ops_rate);
1068 +       debugfs_create_file("enabled", S_IRUGO, clk->debugfs_entry, clk,
1069 +                               &jz4740_clock_debugfs_ops_enabled);
1070 +
1071 +       if (clk->parent) {
1072 +               char parent_path[100];
1073 +               snprintf(parent_path, 100, "../%s", clk->parent->name);
1074 +               clk->debugfs_parent_entry = debugfs_create_symlink("parent",
1075 +                                               clk->debugfs_entry,
1076 +                                               parent_path);
1077 +       }
1078 +}
1079 +
1080 +/* TODO: Locking */
1081 +void jz4740_clock_debugfs_update_parent(struct clk *clk)
1082 +{
1083 +       if (clk->debugfs_parent_entry)
1084 +               debugfs_remove(clk->debugfs_parent_entry);
1085 +
1086 +       if (clk->parent) {
1087 +               char parent_path[100];
1088 +               snprintf(parent_path, 100, "../%s", clk->parent->name);
1089 +               clk->debugfs_parent_entry = debugfs_create_symlink("parent",
1090 +                                               clk->debugfs_entry,
1091 +                                               parent_path);
1092 +       } else {
1093 +               clk->debugfs_parent_entry = NULL;
1094 +       }
1095 +}
1096 +
1097 +void jz4740_clock_debugfs_init(void)
1098 +{
1099 +       jz4740_clock_debugfs = debugfs_create_dir("jz4740-clock", NULL);
1100 +       if (IS_ERR(jz4740_clock_debugfs))
1101 +               jz4740_clock_debugfs = NULL;
1102 +}
1103 diff --git a/arch/mips/jz4740/clock.c b/arch/mips/jz4740/clock.c
1104 new file mode 100644
1105 index 0000000..df0d6d3
1106 --- /dev/null
1107 +++ b/arch/mips/jz4740/clock.c
1108 @@ -0,0 +1,935 @@
1109 +/*
1110 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
1111 + *  JZ4740 SoC clock support
1112 + *
1113 + *  This program is free software; you can redistribute         it and/or modify it
1114 + *  under  the terms of         the GNU General  Public License as published by the
1115 + *  Free Software Foundation;  either version 2 of the License, or (at your
1116 + *  option) any later version.
1117 + *
1118 + *  You should have received a copy of the  GNU General Public License along
1119 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
1120 + *  675 Mass Ave, Cambridge, MA 02139, USA.
1121 + *
1122 + */
1123 +
1124 +#include <linux/kernel.h>
1125 +#include <linux/errno.h>
1126 +#include <linux/clk.h>
1127 +#include <linux/spinlock.h>
1128 +#include <linux/io.h>
1129 +#include <linux/module.h>
1130 +#include <linux/list.h>
1131 +#include <linux/err.h>
1132 +
1133 +#include <asm/mach-jz4740/clock.h>
1134 +#include <asm/mach-jz4740/base.h>
1135 +
1136 +#include "clock.h"
1137 +
1138 +#define JZ_REG_CLOCK_CTRL      0x00
1139 +#define JZ_REG_CLOCK_LOW_POWER 0x04
1140 +#define JZ_REG_CLOCK_PLL       0x10
1141 +#define JZ_REG_CLOCK_GATE      0x20
1142 +#define JZ_REG_CLOCK_SLEEP_CTRL        0x24
1143 +#define JZ_REG_CLOCK_I2S       0x60
1144 +#define JZ_REG_CLOCK_LCD       0x64
1145 +#define JZ_REG_CLOCK_MMC       0x68
1146 +#define JZ_REG_CLOCK_UHC       0x6C
1147 +#define JZ_REG_CLOCK_SPI       0x74
1148 +
1149 +#define JZ_CLOCK_CTRL_I2S_SRC_PLL      BIT(31)
1150 +#define JZ_CLOCK_CTRL_KO_ENABLE                BIT(30)
1151 +#define JZ_CLOCK_CTRL_UDC_SRC_PLL      BIT(29)
1152 +#define JZ_CLOCK_CTRL_UDIV_MASK                0x1f800000
1153 +#define JZ_CLOCK_CTRL_CHANGE_ENABLE    BIT(22)
1154 +#define JZ_CLOCK_CTRL_PLL_HALF         BIT(21)
1155 +#define JZ_CLOCK_CTRL_LDIV_MASK                0x001f0000
1156 +#define JZ_CLOCK_CTRL_UDIV_OFFSET      23
1157 +#define JZ_CLOCK_CTRL_LDIV_OFFSET      16
1158 +#define JZ_CLOCK_CTRL_MDIV_OFFSET      12
1159 +#define JZ_CLOCK_CTRL_PDIV_OFFSET       8
1160 +#define JZ_CLOCK_CTRL_HDIV_OFFSET       4
1161 +#define JZ_CLOCK_CTRL_CDIV_OFFSET       0
1162 +
1163 +#define JZ_CLOCK_GATE_UART0    BIT(0)
1164 +#define JZ_CLOCK_GATE_TCU      BIT(1)
1165 +#define JZ_CLOCK_GATE_RTC      BIT(2)
1166 +#define JZ_CLOCK_GATE_I2C      BIT(3)
1167 +#define JZ_CLOCK_GATE_SPI      BIT(4)
1168 +#define JZ_CLOCK_GATE_AIC      BIT(5)
1169 +#define JZ_CLOCK_GATE_I2S      BIT(6)
1170 +#define JZ_CLOCK_GATE_MMC      BIT(7)
1171 +#define JZ_CLOCK_GATE_ADC      BIT(8)
1172 +#define JZ_CLOCK_GATE_CIM      BIT(9)
1173 +#define JZ_CLOCK_GATE_LCD      BIT(10)
1174 +#define JZ_CLOCK_GATE_UDC      BIT(11)
1175 +#define JZ_CLOCK_GATE_DMAC     BIT(12)
1176 +#define JZ_CLOCK_GATE_IPU      BIT(13)
1177 +#define JZ_CLOCK_GATE_UHC      BIT(14)
1178 +#define JZ_CLOCK_GATE_UART1    BIT(15)
1179 +
1180 +#define JZ_CLOCK_I2S_DIV_MASK          0x01ff
1181 +
1182 +#define JZ_CLOCK_LCD_DIV_MASK          0x01ff
1183 +
1184 +#define JZ_CLOCK_MMC_DIV_MASK          0x001f
1185 +
1186 +#define JZ_CLOCK_UHC_DIV_MASK          0x000f
1187 +
1188 +#define JZ_CLOCK_SPI_SRC_PLL           BIT(31)
1189 +#define JZ_CLOCK_SPI_DIV_MASK          0x000f
1190 +
1191 +#define JZ_CLOCK_PLL_M_MASK            0x01ff
1192 +#define JZ_CLOCK_PLL_N_MASK            0x001f
1193 +#define JZ_CLOCK_PLL_OD_MASK           0x0003
1194 +#define JZ_CLOCK_PLL_STABLE            BIT(10)
1195 +#define JZ_CLOCK_PLL_BYPASS            BIT(9)
1196 +#define JZ_CLOCK_PLL_ENABLED           BIT(8)
1197 +#define JZ_CLOCK_PLL_STABLIZE_MASK     0x000f
1198 +#define JZ_CLOCK_PLL_M_OFFSET          23
1199 +#define JZ_CLOCK_PLL_N_OFFSET          18
1200 +#define JZ_CLOCK_PLL_OD_OFFSET         16
1201 +
1202 +#define JZ_CLOCK_LOW_POWER_MODE_DOZE BIT(2)
1203 +#define JZ_CLOCK_LOW_POWER_MODE_SLEEP BIT(0)
1204 +
1205 +#define JZ_CLOCK_SLEEP_CTRL_SUSPEND_UHC BIT(7)
1206 +#define JZ_CLOCK_SLEEP_CTRL_ENABLE_UDC BIT(6)
1207 +
1208 +static void __iomem *jz_clock_base;
1209 +static spinlock_t jz_clock_lock;
1210 +static LIST_HEAD(jz_clocks);
1211 +
1212 +struct main_clk {
1213 +       struct clk clk;
1214 +       uint32_t div_offset;
1215 +};
1216 +
1217 +struct divided_clk {
1218 +       struct clk clk;
1219 +       uint32_t reg;
1220 +       uint32_t mask;
1221 +};
1222 +
1223 +struct static_clk {
1224 +       struct clk clk;
1225 +       unsigned long rate;
1226 +};
1227 +
1228 +static uint32_t jz_clk_reg_read(int reg)
1229 +{
1230 +       return readl(jz_clock_base + reg);
1231 +}
1232 +
1233 +static void jz_clk_reg_write_mask(int reg, uint32_t val, uint32_t mask)
1234 +{
1235 +       uint32_t val2;
1236 +
1237 +       spin_lock(&jz_clock_lock);
1238 +       val2 = readl(jz_clock_base + reg);
1239 +       val2 &= ~mask;
1240 +       val2 |= val;
1241 +       writel(val2, jz_clock_base + reg);
1242 +       spin_unlock(&jz_clock_lock);
1243 +}
1244 +
1245 +static void jz_clk_reg_set_bits(int reg, uint32_t mask)
1246 +{
1247 +       uint32_t val;
1248 +
1249 +       spin_lock(&jz_clock_lock);
1250 +       val = readl(jz_clock_base + reg);
1251 +       val |= mask;
1252 +       writel(val, jz_clock_base + reg);
1253 +       spin_unlock(&jz_clock_lock);
1254 +}
1255 +
1256 +static void jz_clk_reg_clear_bits(int reg, uint32_t mask)
1257 +{
1258 +       uint32_t val;
1259 +
1260 +       spin_lock(&jz_clock_lock);
1261 +       val = readl(jz_clock_base + reg);
1262 +       val &= ~mask;
1263 +       writel(val, jz_clock_base + reg);
1264 +       spin_unlock(&jz_clock_lock);
1265 +}
1266 +
1267 +static int jz_clk_enable_gating(struct clk *clk)
1268 +{
1269 +       if (clk->gate_bit == JZ4740_CLK_NOT_GATED)
1270 +               return -EINVAL;
1271 +
1272 +       jz_clk_reg_clear_bits(JZ_REG_CLOCK_GATE, clk->gate_bit);
1273 +       return 0;
1274 +}
1275 +
1276 +static int jz_clk_disable_gating(struct clk *clk)
1277 +{
1278 +       if (clk->gate_bit == JZ4740_CLK_NOT_GATED)
1279 +               return -EINVAL;
1280 +
1281 +       jz_clk_reg_set_bits(JZ_REG_CLOCK_GATE, clk->gate_bit);
1282 +       return 0;
1283 +}
1284 +
1285 +static int jz_clk_is_enabled_gating(struct clk *clk)
1286 +{
1287 +       if (clk->gate_bit == JZ4740_CLK_NOT_GATED)
1288 +               return 1;
1289 +
1290 +       return !(jz_clk_reg_read(JZ_REG_CLOCK_GATE) & clk->gate_bit);
1291 +}
1292 +
1293 +static unsigned long jz_clk_static_get_rate(struct clk *clk)
1294 +{
1295 +       return ((struct static_clk *)clk)->rate;
1296 +}
1297 +
1298 +static int jz_clk_ko_enable(struct clk *clk)
1299 +{
1300 +       jz_clk_reg_set_bits(JZ_REG_CLOCK_CTRL, JZ_CLOCK_CTRL_KO_ENABLE);
1301 +       return 0;
1302 +}
1303 +
1304 +static int jz_clk_ko_disable(struct clk *clk)
1305 +{
1306 +       jz_clk_reg_clear_bits(JZ_REG_CLOCK_CTRL, JZ_CLOCK_CTRL_KO_ENABLE);
1307 +       return 0;
1308 +}
1309 +
1310 +static int jz_clk_ko_is_enabled(struct clk *clk)
1311 +{
1312 +       return !!(jz_clk_reg_read(JZ_REG_CLOCK_CTRL) & JZ_CLOCK_CTRL_KO_ENABLE);
1313 +}
1314 +
1315 +static const int pllno[] = {1, 2, 2, 4};
1316 +
1317 +static unsigned long jz_clk_pll_get_rate(struct clk *clk)
1318 +{
1319 +       uint32_t val;
1320 +       int m;
1321 +       int n;
1322 +       int od;
1323 +
1324 +       val = jz_clk_reg_read(JZ_REG_CLOCK_PLL);
1325 +
1326 +       if (val & JZ_CLOCK_PLL_BYPASS)
1327 +               return clk_get_rate(clk->parent);
1328 +
1329 +       m = ((val >> 23) & 0x1ff) + 2;
1330 +       n = ((val >> 18) & 0x1f) + 2;
1331 +       od = (val >> 16) & 0x3;
1332 +
1333 +       return clk_get_rate(clk->parent) * (m / n) / pllno[od];
1334 +}
1335 +
1336 +static unsigned long jz_clk_pll_half_get_rate(struct clk *clk)
1337 +{
1338 +       uint32_t reg;
1339 +
1340 +       reg = jz_clk_reg_read(JZ_REG_CLOCK_CTRL);
1341 +       if (reg & JZ_CLOCK_CTRL_PLL_HALF)
1342 +               return jz_clk_pll_get_rate(clk->parent);
1343 +       return jz_clk_pll_get_rate(clk->parent) >> 1;
1344 +}
1345 +
1346 +static const int jz_clk_main_divs[] = {1, 2, 3, 4, 6, 8, 12, 16, 24, 32};
1347 +
1348 +static unsigned long jz_clk_main_round_rate(struct clk *clk, unsigned long rate)
1349 +{
1350 +       unsigned long parent_rate = jz_clk_pll_get_rate(clk->parent);
1351 +       int div;
1352 +
1353 +       div = parent_rate / rate;
1354 +       if (div > 32)
1355 +               return parent_rate / 32;
1356 +       else if (div < 1)
1357 +               return parent_rate;
1358 +
1359 +       div &= (0x3 << (ffs(div) - 1));
1360 +
1361 +       return parent_rate / div;
1362 +}
1363 +
1364 +static unsigned long jz_clk_main_get_rate(struct clk *clk)
1365 +{
1366 +       struct main_clk *mclk = (struct main_clk *)clk;
1367 +       uint32_t div;
1368 +
1369 +       div = jz_clk_reg_read(JZ_REG_CLOCK_CTRL);
1370 +
1371 +       div >>= mclk->div_offset;
1372 +       div &= 0xf;
1373 +
1374 +       if (div >= ARRAY_SIZE(jz_clk_main_divs))
1375 +               div = ARRAY_SIZE(jz_clk_main_divs) - 1;
1376 +
1377 +       return jz_clk_pll_get_rate(clk->parent) / jz_clk_main_divs[div];
1378 +}
1379 +
1380 +static int jz_clk_main_set_rate(struct clk *clk, unsigned long rate)
1381 +{
1382 +       struct main_clk *mclk = (struct main_clk *)clk;
1383 +       int i;
1384 +       int div;
1385 +       unsigned long parent_rate = jz_clk_pll_get_rate(clk->parent);
1386 +
1387 +       rate = jz_clk_main_round_rate(clk, rate);
1388 +
1389 +       div = parent_rate / rate;
1390 +
1391 +       i = (ffs(div) - 1) << 1;
1392 +       if (i > 0 && !(div & BIT(i-1)))
1393 +               i -= 1;
1394 +
1395 +       jz_clk_reg_write_mask(JZ_REG_CLOCK_CTRL, i << mclk->div_offset,
1396 +                               0xf << mclk->div_offset);
1397 +
1398 +       return 0;
1399 +}
1400 +
1401 +static struct clk_ops jz_clk_static_ops = {
1402 +       .get_rate = jz_clk_static_get_rate,
1403 +       .enable = jz_clk_enable_gating,
1404 +       .disable = jz_clk_disable_gating,
1405 +       .is_enabled = jz_clk_is_enabled_gating,
1406 +};
1407 +
1408 +static struct static_clk jz_clk_ext = {
1409 +       .clk = {
1410 +               .name = "ext",
1411 +               .gate_bit = JZ4740_CLK_NOT_GATED,
1412 +               .ops = &jz_clk_static_ops,
1413 +       },
1414 +};
1415 +
1416 +static struct clk_ops jz_clk_pll_ops = {
1417 +       .get_rate = jz_clk_static_get_rate,
1418 +};
1419 +
1420 +static struct clk jz_clk_pll = {
1421 +       .name = "pll",
1422 +       .parent = &jz_clk_ext.clk,
1423 +       .ops = &jz_clk_pll_ops,
1424 +};
1425 +
1426 +static struct clk_ops jz_clk_pll_half_ops = {
1427 +       .get_rate = jz_clk_pll_half_get_rate,
1428 +};
1429 +
1430 +static struct clk jz_clk_pll_half = {
1431 +       .name = "pll half",
1432 +       .parent = &jz_clk_pll,
1433 +       .ops = &jz_clk_pll_half_ops,
1434 +};
1435 +
1436 +static const struct clk_ops jz_clk_main_ops = {
1437 +       .get_rate = jz_clk_main_get_rate,
1438 +       .set_rate = jz_clk_main_set_rate,
1439 +       .round_rate = jz_clk_main_round_rate,
1440 +};
1441 +
1442 +static struct main_clk jz_clk_cpu = {
1443 +       .clk = {
1444 +               .name = "cclk",
1445 +               .parent = &jz_clk_pll,
1446 +               .ops = &jz_clk_main_ops,
1447 +       },
1448 +       .div_offset = JZ_CLOCK_CTRL_CDIV_OFFSET,
1449 +};
1450 +
1451 +static struct main_clk jz_clk_memory = {
1452 +       .clk = {
1453 +               .name = "mclk",
1454 +               .parent = &jz_clk_pll,
1455 +               .ops = &jz_clk_main_ops,
1456 +       },
1457 +       .div_offset = JZ_CLOCK_CTRL_MDIV_OFFSET,
1458 +};
1459 +
1460 +static struct main_clk jz_clk_high_speed_peripheral = {
1461 +       .clk = {
1462 +               .name = "hclk",
1463 +               .parent = &jz_clk_pll,
1464 +               .ops = &jz_clk_main_ops,
1465 +       },
1466 +       .div_offset = JZ_CLOCK_CTRL_HDIV_OFFSET,
1467 +};
1468 +
1469 +
1470 +static struct main_clk jz_clk_low_speed_peripheral = {
1471 +       .clk = {
1472 +               .name = "pclk",
1473 +               .parent = &jz_clk_pll,
1474 +               .ops = &jz_clk_main_ops,
1475 +       },
1476 +       .div_offset = JZ_CLOCK_CTRL_PDIV_OFFSET,
1477 +};
1478 +
1479 +static const struct clk_ops jz_clk_ko_ops = {
1480 +       .enable = jz_clk_ko_enable,
1481 +       .disable = jz_clk_ko_disable,
1482 +       .is_enabled = jz_clk_ko_is_enabled,
1483 +};
1484 +
1485 +static struct clk jz_clk_ko = {
1486 +       .name = "cko",
1487 +       .parent = &jz_clk_memory.clk,
1488 +       .ops = &jz_clk_ko_ops,
1489 +};
1490 +
1491 +static int jz_clk_spi_set_parent(struct clk *clk, struct clk *parent)
1492 +{
1493 +       if (parent == &jz_clk_pll)
1494 +               jz_clk_reg_set_bits(JZ_CLOCK_SPI_SRC_PLL, JZ_REG_CLOCK_SPI);
1495 +       else if (parent == &jz_clk_ext.clk)
1496 +               jz_clk_reg_clear_bits(JZ_CLOCK_SPI_SRC_PLL, JZ_REG_CLOCK_SPI);
1497 +       else
1498 +               return -EINVAL;
1499 +
1500 +       clk->parent = parent;
1501 +
1502 +       return 0;
1503 +}
1504 +
1505 +static int jz_clk_i2s_set_parent(struct clk *clk, struct clk *parent)
1506 +{
1507 +       if (parent == &jz_clk_pll_half)
1508 +               jz_clk_reg_set_bits(JZ_REG_CLOCK_CTRL, JZ_CLOCK_CTRL_I2S_SRC_PLL);
1509 +       else if (parent == &jz_clk_ext.clk)
1510 +               jz_clk_reg_clear_bits(JZ_REG_CLOCK_CTRL, JZ_CLOCK_CTRL_I2S_SRC_PLL);
1511 +       else
1512 +               return -EINVAL;
1513 +
1514 +       clk->parent = parent;
1515 +
1516 +       return 0;
1517 +}
1518 +
1519 +static int jz_clk_udc_enable(struct clk *clk)
1520 +{
1521 +       jz_clk_reg_set_bits(JZ_REG_CLOCK_SLEEP_CTRL,
1522 +                       JZ_CLOCK_SLEEP_CTRL_ENABLE_UDC);
1523 +
1524 +       return 0;
1525 +}
1526 +
1527 +static int jz_clk_udc_disable(struct clk *clk)
1528 +{
1529 +       jz_clk_reg_clear_bits(JZ_REG_CLOCK_SLEEP_CTRL,
1530 +                       JZ_CLOCK_SLEEP_CTRL_ENABLE_UDC);
1531 +
1532 +       return 0;
1533 +}
1534 +
1535 +static int jz_clk_udc_is_enabled(struct clk *clk)
1536 +{
1537 +       return !!(jz_clk_reg_read(JZ_REG_CLOCK_SLEEP_CTRL) &
1538 +                       JZ_CLOCK_SLEEP_CTRL_ENABLE_UDC);
1539 +}
1540 +static int jz_clk_udc_set_parent(struct clk *clk, struct clk *parent)
1541 +{
1542 +       if (parent == &jz_clk_pll_half)
1543 +               jz_clk_reg_set_bits(JZ_REG_CLOCK_CTRL, JZ_CLOCK_CTRL_UDC_SRC_PLL);
1544 +       else if (parent == &jz_clk_ext.clk)
1545 +               jz_clk_reg_clear_bits(JZ_REG_CLOCK_CTRL, JZ_CLOCK_CTRL_UDC_SRC_PLL);
1546 +       else
1547 +               return -EINVAL;
1548 +
1549 +       clk->parent = parent;
1550 +
1551 +       return 0;
1552 +}
1553 +
1554 +static int jz_clk_udc_set_rate(struct clk *clk, unsigned long rate)
1555 +{
1556 +       int div;
1557 +
1558 +       if (clk->parent == &jz_clk_ext.clk)
1559 +               return -EINVAL;
1560 +
1561 +       div = clk_get_rate(clk->parent) / rate - 1;
1562 +
1563 +       if (div < 0)
1564 +               div = 0;
1565 +       else if (div > 63)
1566 +               div = 63;
1567 +
1568 +       jz_clk_reg_write_mask(JZ_REG_CLOCK_CTRL, div << JZ_CLOCK_CTRL_UDIV_OFFSET,
1569 +                               JZ_CLOCK_CTRL_UDIV_MASK);
1570 +       return 0;
1571 +}
1572 +
1573 +static unsigned long jz_clk_udc_get_rate(struct clk *clk)
1574 +{
1575 +       int div;
1576 +
1577 +       if (clk->parent == &jz_clk_ext.clk)
1578 +               return clk_get_rate(clk->parent);
1579 +
1580 +       div = (jz_clk_reg_read(JZ_REG_CLOCK_CTRL) & JZ_CLOCK_CTRL_UDIV_MASK);
1581 +       div >>= JZ_CLOCK_CTRL_UDIV_OFFSET;
1582 +       div += 1;
1583 +
1584 +       return clk_get_rate(clk->parent) / div;
1585 +}
1586 +
1587 +static unsigned long jz_clk_divided_get_rate(struct clk *clk)
1588 +{
1589 +       struct divided_clk *dclk = (struct divided_clk *)clk;
1590 +       int div;
1591 +
1592 +       if (clk->parent == &jz_clk_ext.clk)
1593 +               return clk_get_rate(clk->parent);
1594 +
1595 +       div = (jz_clk_reg_read(dclk->reg) & dclk->mask) + 1;
1596 +
1597 +       return clk_get_rate(clk->parent) / div;
1598 +}
1599 +
1600 +static int jz_clk_divided_set_rate(struct clk *clk, unsigned long rate)
1601 +{
1602 +       struct divided_clk *dclk = (struct divided_clk *)clk;
1603 +       int div;
1604 +
1605 +       if (clk->parent == &jz_clk_ext.clk)
1606 +               return -EINVAL;
1607 +
1608 +       div = clk_get_rate(clk->parent) / rate - 1;
1609 +
1610 +       if (div < 0)
1611 +               div = 0;
1612 +       else if (div > dclk->mask)
1613 +               div = dclk->mask;
1614 +
1615 +       jz_clk_reg_write_mask(dclk->reg, div, dclk->mask);
1616 +
1617 +       return 0;
1618 +}
1619 +
1620 +static unsigned long jz_clk_ldclk_round_rate(struct clk *clk, unsigned long rate)
1621 +{
1622 +       int div;
1623 +       unsigned long parent_rate = jz_clk_pll_half_get_rate(clk->parent);
1624 +
1625 +       if (rate > 150000000)
1626 +               return 150000000;
1627 +
1628 +       div = parent_rate / rate;
1629 +       if (div < 1)
1630 +               div = 1;
1631 +       else if (div > 32)
1632 +               div = 32;
1633 +
1634 +       return parent_rate / div;
1635 +}
1636 +
1637 +static int jz_clk_ldclk_set_rate(struct clk *clk, unsigned long rate)
1638 +{
1639 +       int div;
1640 +
1641 +       if (rate > 150000000)
1642 +               return -EINVAL;
1643 +
1644 +       div = jz_clk_pll_half_get_rate(clk->parent) / rate - 1;
1645 +       if (div < 0)
1646 +               div = 0;
1647 +       else if (div > 31)
1648 +               div = 31;
1649 +
1650 +       jz_clk_reg_write_mask(JZ_REG_CLOCK_CTRL, div << JZ_CLOCK_CTRL_LDIV_OFFSET,
1651 +                               JZ_CLOCK_CTRL_LDIV_MASK);
1652 +
1653 +       return 0;
1654 +}
1655 +
1656 +static unsigned long jz_clk_ldclk_get_rate(struct clk *clk)
1657 +{
1658 +       int div;
1659 +
1660 +       div = jz_clk_reg_read(JZ_REG_CLOCK_CTRL) & JZ_CLOCK_CTRL_LDIV_MASK;
1661 +       div >>= JZ_CLOCK_CTRL_LDIV_OFFSET;
1662 +
1663 +       return jz_clk_pll_half_get_rate(clk->parent) / (div + 1);
1664 +}
1665 +
1666 +static const struct clk_ops jz_clk_ops_ld = {
1667 +       .set_rate = jz_clk_ldclk_set_rate,
1668 +       .get_rate = jz_clk_ldclk_get_rate,
1669 +       .round_rate = jz_clk_ldclk_round_rate,
1670 +       .enable = jz_clk_enable_gating,
1671 +       .disable = jz_clk_disable_gating,
1672 +       .is_enabled = jz_clk_is_enabled_gating,
1673 +};
1674 +
1675 +static struct clk jz_clk_ld = {
1676 +       .name = "lcd",
1677 +       .gate_bit = JZ_CLOCK_GATE_LCD,
1678 +       .parent = &jz_clk_pll_half,
1679 +       .ops = &jz_clk_ops_ld,
1680 +};
1681 +
1682 +/* TODO: ops!!! */
1683 +static struct clk jz_clk_cim_mclk = {
1684 +       .name = "cim_mclk",
1685 +       .parent = &jz_clk_high_speed_peripheral.clk,
1686 +};
1687 +
1688 +static struct static_clk jz_clk_cim_pclk = {
1689 +       .clk = {
1690 +               .name = "cim_pclk",
1691 +               .gate_bit = JZ_CLOCK_GATE_CIM,
1692 +               .ops = &jz_clk_static_ops,
1693 +       },
1694 +};
1695 +
1696 +static const struct clk_ops jz_clk_i2s_ops = {
1697 +       .set_rate = jz_clk_divided_set_rate,
1698 +       .get_rate = jz_clk_divided_get_rate,
1699 +       .enable = jz_clk_enable_gating,
1700 +       .disable = jz_clk_disable_gating,
1701 +       .is_enabled = jz_clk_is_enabled_gating,
1702 +       .set_parent = jz_clk_i2s_set_parent,
1703 +};
1704 +
1705 +static const struct clk_ops jz_clk_spi_ops = {
1706 +       .set_rate = jz_clk_divided_set_rate,
1707 +       .get_rate = jz_clk_divided_get_rate,
1708 +       .enable = jz_clk_enable_gating,
1709 +       .disable = jz_clk_disable_gating,
1710 +       .is_enabled = jz_clk_is_enabled_gating,
1711 +       .set_parent = jz_clk_spi_set_parent,
1712 +};
1713 +
1714 +static const struct clk_ops jz_clk_divided_ops = {
1715 +       .set_rate = jz_clk_divided_set_rate,
1716 +       .get_rate = jz_clk_divided_get_rate,
1717 +       .enable = jz_clk_enable_gating,
1718 +       .disable = jz_clk_disable_gating,
1719 +       .is_enabled = jz_clk_is_enabled_gating,
1720 +};
1721 +
1722 +static struct divided_clk jz4740_clock_divided_clks[] = {
1723 +       {
1724 +               .clk = {
1725 +                       .name = "lcd_pclk",
1726 +                       .parent = &jz_clk_pll_half,
1727 +                       .gate_bit = JZ4740_CLK_NOT_GATED,
1728 +                       .ops = &jz_clk_divided_ops,
1729 +               },
1730 +               .reg = JZ_REG_CLOCK_LCD,
1731 +               .mask = JZ_CLOCK_LCD_DIV_MASK,
1732 +       },
1733 +       {
1734 +               .clk = {
1735 +                       .name = "i2s",
1736 +                       .parent = &jz_clk_ext.clk,
1737 +                       .gate_bit = JZ_CLOCK_GATE_I2S,
1738 +                       .ops = &jz_clk_i2s_ops,
1739 +               },
1740 +               .reg = JZ_REG_CLOCK_I2S,
1741 +               .mask = JZ_CLOCK_I2S_DIV_MASK,
1742 +       },
1743 +       {
1744 +               .clk = {
1745 +                       .name = "spi",
1746 +                       .parent = &jz_clk_ext.clk,
1747 +                       .gate_bit = JZ_CLOCK_GATE_SPI,
1748 +                       .ops = &jz_clk_spi_ops,
1749 +               },
1750 +               .reg = JZ_REG_CLOCK_SPI,
1751 +               .mask = JZ_CLOCK_SPI_DIV_MASK,
1752 +       },
1753 +       {
1754 +               .clk = {
1755 +                       .name = "mmc",
1756 +                       .parent = &jz_clk_pll_half,
1757 +                       .gate_bit = JZ_CLOCK_GATE_MMC,
1758 +                       .ops = &jz_clk_divided_ops,
1759 +               },
1760 +               .reg = JZ_REG_CLOCK_MMC,
1761 +               .mask = JZ_CLOCK_MMC_DIV_MASK,
1762 +       },
1763 +       {
1764 +               .clk = {
1765 +                       .name = "uhc",
1766 +                       .parent = &jz_clk_pll_half,
1767 +                       .gate_bit = JZ_CLOCK_GATE_UHC,
1768 +                       .ops = &jz_clk_divided_ops,
1769 +               },
1770 +               .reg = JZ_REG_CLOCK_UHC,
1771 +               .mask = JZ_CLOCK_UHC_DIV_MASK,
1772 +       },
1773 +};
1774 +
1775 +static const struct clk_ops jz_clk_udc_ops = {
1776 +       .set_parent = jz_clk_udc_set_parent,
1777 +       .set_rate = jz_clk_udc_set_rate,
1778 +       .get_rate = jz_clk_udc_get_rate,
1779 +       .enable = jz_clk_udc_enable,
1780 +       .disable = jz_clk_udc_disable,
1781 +       .is_enabled = jz_clk_udc_is_enabled,
1782 +};
1783 +
1784 +static const struct clk_ops jz_clk_simple_ops = {
1785 +       .enable = jz_clk_enable_gating,
1786 +       .disable = jz_clk_disable_gating,
1787 +       .is_enabled = jz_clk_is_enabled_gating,
1788 +};
1789 +
1790 +static struct clk jz4740_clock_simple_clks[] = {
1791 +       {
1792 +               .name = "udc",
1793 +               .parent = &jz_clk_ext.clk,
1794 +               .ops = &jz_clk_udc_ops,
1795 +       },
1796 +       {
1797 +               .name = "uart0",
1798 +               .parent = &jz_clk_ext.clk,
1799 +               .gate_bit = JZ_CLOCK_GATE_UART0,
1800 +               .ops = &jz_clk_simple_ops,
1801 +       },
1802 +       {
1803 +               .name = "uart1",
1804 +               .parent = &jz_clk_ext.clk,
1805 +               .gate_bit = JZ_CLOCK_GATE_UART1,
1806 +               .ops = &jz_clk_simple_ops,
1807 +       },
1808 +       {
1809 +               .name = "dma",
1810 +               .parent = &jz_clk_high_speed_peripheral.clk,
1811 +               .gate_bit = JZ_CLOCK_GATE_UART0,
1812 +               .ops = &jz_clk_simple_ops,
1813 +       },
1814 +       {
1815 +               .name = "ipu",
1816 +               .parent = &jz_clk_high_speed_peripheral.clk,
1817 +               .gate_bit = JZ_CLOCK_GATE_IPU,
1818 +               .ops = &jz_clk_simple_ops,
1819 +       },
1820 +       {
1821 +               .name = "adc",
1822 +               .parent = &jz_clk_ext.clk,
1823 +               .gate_bit = JZ_CLOCK_GATE_ADC,
1824 +               .ops = &jz_clk_simple_ops,
1825 +       },
1826 +       {
1827 +               .name = "i2c",
1828 +               .parent = &jz_clk_ext.clk,
1829 +               .gate_bit = JZ_CLOCK_GATE_I2C,
1830 +               .ops = &jz_clk_simple_ops,
1831 +       },
1832 +       {
1833 +               .name = "aic",
1834 +               .parent = &jz_clk_ext.clk,
1835 +               .gate_bit = JZ_CLOCK_GATE_AIC,
1836 +               .ops = &jz_clk_simple_ops,
1837 +       },
1838 +};
1839 +
1840 +static struct static_clk jz_clk_rtc = {
1841 +       .clk = {
1842 +               .name = "rtc",
1843 +               .gate_bit = JZ_CLOCK_GATE_RTC,
1844 +               .ops = &jz_clk_static_ops,
1845 +       },
1846 +       .rate = 32768,
1847 +};
1848 +
1849 +int clk_enable(struct clk *clk)
1850 +{
1851 +       if (!clk->ops->enable)
1852 +               return -EINVAL;
1853 +
1854 +       return clk->ops->enable(clk);
1855 +}
1856 +EXPORT_SYMBOL_GPL(clk_enable);
1857 +
1858 +void clk_disable(struct clk *clk)
1859 +{
1860 +       if (clk->ops->disable)
1861 +               clk->ops->disable(clk);
1862 +}
1863 +EXPORT_SYMBOL_GPL(clk_disable);
1864 +
1865 +int clk_is_enabled(struct clk *clk)
1866 +{
1867 +       if (clk->ops->is_enabled)
1868 +               return clk->ops->is_enabled(clk);
1869 +
1870 +       return 1;
1871 +}
1872 +
1873 +unsigned long clk_get_rate(struct clk *clk)
1874 +{
1875 +       if (clk->ops->get_rate)
1876 +               return clk->ops->get_rate(clk);
1877 +       if (clk->parent)
1878 +               return clk_get_rate(clk->parent);
1879 +
1880 +       return -EINVAL;
1881 +}
1882 +EXPORT_SYMBOL_GPL(clk_get_rate);
1883 +
1884 +int clk_set_rate(struct clk *clk, unsigned long rate)
1885 +{
1886 +       if (!clk->ops->set_rate)
1887 +               return -EINVAL;
1888 +       return clk->ops->set_rate(clk, rate);
1889 +}
1890 +EXPORT_SYMBOL_GPL(clk_set_rate);
1891 +
1892 +long clk_round_rate(struct clk *clk, unsigned long rate)
1893 +{
1894 +       if (clk->ops->round_rate)
1895 +               return clk->ops->round_rate(clk, rate);
1896 +
1897 +       return -EINVAL;
1898 +}
1899 +EXPORT_SYMBOL_GPL(clk_round_rate);
1900 +
1901 +int clk_set_parent(struct clk *clk, struct clk *parent)
1902 +{
1903 +       int ret;
1904 +
1905 +       if (!clk->ops->set_parent)
1906 +               return -EINVAL;
1907 +
1908 +       clk_disable(clk);
1909 +       ret = clk->ops->set_parent(clk, parent);
1910 +       clk_enable(clk);
1911 +
1912 +       jz4740_clock_debugfs_update_parent(clk);
1913 +
1914 +       return ret;
1915 +}
1916 +EXPORT_SYMBOL_GPL(clk_set_parent);
1917 +
1918 +struct clk *clk_get(struct device *dev, const char *name)
1919 +{
1920 +       struct clk *clk;
1921 +
1922 +       list_for_each_entry(clk, &jz_clocks, list) {
1923 +               if (strcmp(clk->name, name) == 0)
1924 +                       return clk;
1925 +       }
1926 +       return ERR_PTR(-ENOENT);
1927 +}
1928 +EXPORT_SYMBOL_GPL(clk_get);
1929 +
1930 +void clk_put(struct clk *clk)
1931 +{
1932 +}
1933 +EXPORT_SYMBOL_GPL(clk_put);
1934 +
1935 +
1936 +static inline void clk_add(struct clk *clk)
1937 +{
1938 +       list_add_tail(&clk->list, &jz_clocks);
1939 +
1940 +       jz4740_clock_debugfs_add_clk(clk);
1941 +}
1942 +
1943 +static void clk_register_clks(void)
1944 +{
1945 +       size_t i;
1946 +
1947 +       clk_add(&jz_clk_ext.clk);
1948 +       clk_add(&jz_clk_pll);
1949 +       clk_add(&jz_clk_pll_half);
1950 +       clk_add(&jz_clk_cpu.clk);
1951 +       clk_add(&jz_clk_high_speed_peripheral.clk);
1952 +       clk_add(&jz_clk_low_speed_peripheral.clk);
1953 +       clk_add(&jz_clk_ko);
1954 +       clk_add(&jz_clk_ld);
1955 +       clk_add(&jz_clk_cim_mclk);
1956 +       clk_add(&jz_clk_cim_pclk.clk);
1957 +       clk_add(&jz_clk_rtc.clk);
1958 +
1959 +       for (i = 0; i < ARRAY_SIZE(jz4740_clock_divided_clks); ++i)
1960 +               clk_add(&jz4740_clock_divided_clks[i].clk);
1961 +
1962 +       for (i = 0; i < ARRAY_SIZE(jz4740_clock_simple_clks); ++i)
1963 +               clk_add(&jz4740_clock_simple_clks[i]);
1964 +}
1965 +
1966 +void jz4740_clock_set_wait_mode(enum jz4740_wait_mode mode)
1967 +{
1968 +       switch (mode) {
1969 +       case JZ4740_WAIT_MODE_IDLE:
1970 +               jz_clk_reg_clear_bits(JZ_REG_CLOCK_LOW_POWER, JZ_CLOCK_LOW_POWER_MODE_SLEEP);
1971 +               break;
1972 +       case JZ4740_WAIT_MODE_SLEEP:
1973 +               jz_clk_reg_set_bits(JZ_REG_CLOCK_LOW_POWER, JZ_CLOCK_LOW_POWER_MODE_SLEEP);
1974 +               break;
1975 +       }
1976 +}
1977 +
1978 +void jz4740_clock_udc_disable_auto_suspend(void)
1979 +{
1980 +       jz_clk_reg_clear_bits(JZ_REG_CLOCK_GATE, JZ_CLOCK_GATE_UDC);
1981 +}
1982 +EXPORT_SYMBOL_GPL(jz4740_clock_udc_disable_auto_suspend);
1983 +
1984 +void jz4740_clock_udc_enable_auto_suspend(void)
1985 +{
1986 +       jz_clk_reg_set_bits(JZ_REG_CLOCK_GATE, JZ_CLOCK_GATE_UDC);
1987 +}
1988 +EXPORT_SYMBOL_GPL(jz4740_clock_udc_enable_auto_suspend);
1989 +
1990 +void jz4740_clock_suspend(void)
1991 +{
1992 +       jz_clk_reg_set_bits(JZ_REG_CLOCK_GATE,
1993 +               JZ_CLOCK_GATE_TCU | JZ_CLOCK_GATE_DMAC | JZ_CLOCK_GATE_UART0);
1994 +
1995 +       jz_clk_reg_clear_bits(JZ_REG_CLOCK_PLL, JZ_CLOCK_PLL_ENABLED);
1996 +}
1997 +
1998 +void jz4740_clock_resume(void)
1999 +{
2000 +       uint32_t pll;
2001 +
2002 +       jz_clk_reg_set_bits(JZ_REG_CLOCK_PLL, JZ_CLOCK_PLL_ENABLED);
2003 +
2004 +       do {
2005 +               pll = jz_clk_reg_read(JZ_REG_CLOCK_PLL);
2006 +       } while (!(pll & JZ_CLOCK_PLL_STABLE));
2007 +
2008 +       jz_clk_reg_clear_bits(JZ_REG_CLOCK_GATE,
2009 +               JZ_CLOCK_GATE_TCU | JZ_CLOCK_GATE_DMAC | JZ_CLOCK_GATE_UART0);
2010 +}
2011 +
2012 +int jz4740_clock_init(void)
2013 +{
2014 +       uint32_t val;
2015 +
2016 +       jz_clock_base = ioremap(CPHYSADDR(JZ4740_CPM_BASE_ADDR), 0x100);
2017 +       if (!jz_clock_base)
2018 +               return -EBUSY;
2019 +
2020 +       spin_lock_init(&jz_clock_lock);
2021 +
2022 +       jz_clk_ext.rate = jz4740_clock_bdata.ext_rate;
2023 +       jz_clk_rtc.rate = jz4740_clock_bdata.rtc_rate;
2024 +
2025 +       val = jz_clk_reg_read(JZ_REG_CLOCK_SPI);
2026 +
2027 +       if (val & JZ_CLOCK_SPI_SRC_PLL)
2028 +               jz4740_clock_divided_clks[1].clk.parent = &jz_clk_pll_half;
2029 +
2030 +       val = jz_clk_reg_read(JZ_REG_CLOCK_CTRL);
2031 +
2032 +       if (val & JZ_CLOCK_CTRL_I2S_SRC_PLL)
2033 +               jz4740_clock_divided_clks[0].clk.parent = &jz_clk_pll_half;
2034 +
2035 +       if (val & JZ_CLOCK_CTRL_UDC_SRC_PLL)
2036 +               jz4740_clock_simple_clks[0].parent = &jz_clk_pll_half;
2037 +
2038 +       jz4740_clock_debugfs_init();
2039 +
2040 +       clk_register_clks();
2041 +
2042 +       return 0;
2043 +}
2044 diff --git a/arch/mips/jz4740/clock.h b/arch/mips/jz4740/clock.h
2045 new file mode 100644
2046 index 0000000..96010a4
2047 --- /dev/null
2048 +++ b/arch/mips/jz4740/clock.h
2049 @@ -0,0 +1,75 @@
2050 +/*
2051 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
2052 + *  JZ4740 SoC clock support
2053 + *
2054 + *  This program is free software; you can redistribute         it and/or modify it
2055 + *  under  the terms of         the GNU General  Public License as published by the
2056 + *  Free Software Foundation;  either version 2 of the License, or (at your
2057 + *  option) any later version.
2058 + *
2059 + *  You should have received a copy of the  GNU General Public License along
2060 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
2061 + *  675 Mass Ave, Cambridge, MA 02139, USA.
2062 + *
2063 + */
2064 +
2065 +#ifndef __JZ4740_CLOCK_H__
2066 +#define __JZ4740_CLOCK_H__
2067 +
2068 +struct jz4740_clock_board_data {
2069 +       unsigned long ext_rate;
2070 +       unsigned long rtc_rate;
2071 +};
2072 +
2073 +extern struct jz4740_clock_board_data jz4740_clock_bdata;
2074 +
2075 +int jz4740_clock_init(void);
2076 +void jz4740_clock_suspend(void);
2077 +void jz4740_clock_resume(void);
2078 +
2079 +struct clk;
2080 +
2081 +struct clk_ops {
2082 +       unsigned long (*get_rate)(struct clk *clk);
2083 +       unsigned long (*round_rate)(struct clk *clk, unsigned long rate);
2084 +       int (*set_rate)(struct clk *clk, unsigned long rate);
2085 +       int (*enable)(struct clk *clk);
2086 +       int (*disable)(struct clk *clk);
2087 +       int (*is_enabled)(struct clk *clk);
2088 +
2089 +       int (*set_parent)(struct clk *clk, struct clk *parent);
2090 +
2091 +};
2092 +
2093 +struct clk {
2094 +       const char *name;
2095 +       struct clk *parent;
2096 +
2097 +       uint32_t gate_bit;
2098 +
2099 +       const struct clk_ops *ops;
2100 +
2101 +       struct list_head list;
2102 +
2103 +#ifdef CONFIG_DEBUG_FS
2104 +       struct dentry *debugfs_entry;
2105 +       struct dentry *debugfs_parent_entry;
2106 +#endif
2107 +
2108 +};
2109 +
2110 +#define JZ4740_CLK_NOT_GATED ((uint32_t)-1)
2111 +
2112 +int clk_is_enabled(struct clk *clk);
2113 +
2114 +#ifdef CONFIG_DEBUG_FS
2115 +void jz4740_clock_debugfs_init(void);
2116 +void jz4740_clock_debugfs_add_clk(struct clk *clk);
2117 +void jz4740_clock_debugfs_update_parent(struct clk *clk);
2118 +#else
2119 +static inline void jz4740_clock_debugfs_init(void) {};
2120 +static inline void jz4740_clock_debugfs_add_clk(struct clk *clk) {};
2121 +static inline void jz4740_clock_debugfs_update_parent(struct clk *clk) {};
2122 +#endif
2123 +
2124 +#endif
2125 diff --git a/arch/mips/jz4740/dma.c b/arch/mips/jz4740/dma.c
2126 new file mode 100644
2127 index 0000000..b712afc
2128 --- /dev/null
2129 +++ b/arch/mips/jz4740/dma.c
2130 @@ -0,0 +1,336 @@
2131 +/*
2132 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
2133 + *  JZ4740 SoC DMA support
2134 + *
2135 + *  This program is free software; you can redistribute         it and/or modify it
2136 + *  under  the terms of         the GNU General  Public License as published by the
2137 + *  Free Software Foundation;  either version 2 of the License, or (at your
2138 + *  option) any later version.
2139 + *
2140 + *  You should have received a copy of the  GNU General Public License along
2141 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
2142 + *  675 Mass Ave, Cambridge, MA 02139, USA.
2143 + *
2144 + */
2145 +
2146 +#include <linux/kernel.h>
2147 +#include <linux/module.h>
2148 +#include <linux/spinlock.h>
2149 +#include <linux/interrupt.h>
2150 +
2151 +#include <linux/dma-mapping.h>
2152 +#include <asm/mach-jz4740/dma.h>
2153 +#include <asm/mach-jz4740/base.h>
2154 +
2155 +#define JZ_REG_DMA_SRC_ADDR(x)         (0x00 + (x) * 0x20)
2156 +#define JZ_REG_DMA_DST_ADDR(x)         (0x04 + (x) * 0x20)
2157 +#define JZ_REG_DMA_TRANSFER_COUNT(x)   (0x08 + (x) * 0x20)
2158 +#define JZ_REG_DMA_REQ_TYPE(x)         (0x0C + (x) * 0x20)
2159 +#define JZ_REG_DMA_STATUS_CTRL(x)      (0x10 + (x) * 0x20)
2160 +#define JZ_REG_DMA_CMD(x)              (0x14 + (x) * 0x20)
2161 +#define JZ_REG_DMA_DESC_ADDR(x)                (0x18 + (x) * 0x20)
2162 +
2163 +#define JZ_REG_DMA_CTRL                        0x300
2164 +#define JZ_REG_DMA_IRQ                 0x304
2165 +#define JZ_REG_DMA_DOORBELL            0x308
2166 +#define JZ_REG_DMA_DOORBELL_SET                0x30C
2167 +
2168 +#define JZ_DMA_STATUS_CTRL_NO_DESC             BIT(31)
2169 +#define JZ_DMA_STATUS_CTRL_DESC_INV            BIT(6)
2170 +#define JZ_DMA_STATUS_CTRL_ADDR_ERR            BIT(4)
2171 +#define JZ_DMA_STATUS_CTRL_TRANSFER_DONE       BIT(3)
2172 +#define JZ_DMA_STATUS_CTRL_HALT                        BIT(2)
2173 +#define JZ_DMA_STATUS_CTRL_COUNT_TERMINATE     BIT(1)
2174 +#define JZ_DMA_STATUS_CTRL_ENABLE              BIT(0)
2175 +
2176 +#define JZ_DMA_CMD_SRC_INC                     BIT(23)
2177 +#define JZ_DMA_CMD_DST_INC                     BIT(22)
2178 +#define JZ_DMA_CMD_RDIL_MASK                   (0xf << 16)
2179 +#define JZ_DMA_CMD_SRC_WIDTH_MASK              (0x3 << 14)
2180 +#define JZ_DMA_CMD_DST_WIDTH_MASK              (0x3 << 12)
2181 +#define JZ_DMA_CMD_INTERVAL_LENGTH_MASK                (0x7 << 8)
2182 +#define JZ_DMA_CMD_BLOCK_MODE                  BIT(7)
2183 +#define JZ_DMA_CMD_DESC_VALID                  BIT(4)
2184 +#define JZ_DMA_CMD_DESC_VALID_MODE             BIT(3)
2185 +#define JZ_DMA_CMD_VALID_IRQ_ENABLE            BIT(2)
2186 +#define JZ_DMA_CMD_TRANSFER_IRQ_ENABLE         BIT(1)
2187 +#define JZ_DMA_CMD_LINK_ENABLE                 BIT(0)
2188 +
2189 +#define JZ_DMA_CMD_FLAGS_OFFSET 22
2190 +#define JZ_DMA_CMD_RDIL_OFFSET 16
2191 +#define JZ_DMA_CMD_SRC_WIDTH_OFFSET 14
2192 +#define JZ_DMA_CMD_DST_WIDTH_OFFSET 12
2193 +#define JZ_DMA_CMD_TRANSFER_SIZE_OFFSET 8
2194 +#define JZ_DMA_CMD_MODE_OFFSET 7
2195 +
2196 +#define JZ_DMA_CTRL_PRIORITY_MASK      (0x3 << 8)
2197 +#define JZ_DMA_CTRL_HALT               BIT(3)
2198 +#define JZ_DMA_CTRL_ADDRESS_ERROR      BIT(2)
2199 +#define JZ_DMA_CTRL_ENABLE             BIT(0)
2200 +
2201 +
2202 +static void __iomem *jz4740_dma_base;
2203 +static spinlock_t jz4740_dma_lock;
2204 +
2205 +static inline uint32_t jz4740_dma_read(size_t reg)
2206 +{
2207 +       return readl(jz4740_dma_base + reg);
2208 +}
2209 +
2210 +static inline void jz4740_dma_write(size_t reg, uint32_t val)
2211 +{
2212 +       writel(val, jz4740_dma_base + reg);
2213 +}
2214 +
2215 +static inline void jz4740_dma_write_mask(size_t reg, uint32_t val, uint32_t mask)
2216 +{
2217 +       uint32_t val2;
2218 +       val2 = jz4740_dma_read(reg);
2219 +       val2 &= ~mask;
2220 +       val2 |= val;
2221 +       jz4740_dma_write(reg, val2);
2222 +}
2223 +
2224 +struct jz4740_dma_chan {
2225 +       unsigned int id;
2226 +       void *dev;
2227 +       const char *name;
2228 +
2229 +       enum jz4740_dma_flags flags;
2230 +       uint32_t transfer_shift;
2231 +
2232 +       jz4740_dma_complete_callback_t complete_cb;
2233 +
2234 +       unsigned used:1;
2235 +};
2236 +
2237 +#define JZ4740_DMA_CHANNEL(_id) { .id = _id }
2238 +
2239 +struct jz4740_dma_chan jz4740_dma_channels[] = {
2240 +       JZ4740_DMA_CHANNEL(0),
2241 +       JZ4740_DMA_CHANNEL(1),
2242 +       JZ4740_DMA_CHANNEL(2),
2243 +       JZ4740_DMA_CHANNEL(3),
2244 +       JZ4740_DMA_CHANNEL(4),
2245 +       JZ4740_DMA_CHANNEL(5),
2246 +};
2247 +
2248 +struct jz4740_dma_chan *jz4740_dma_request(void *dev, const char *name)
2249 +{
2250 +       unsigned int i;
2251 +       struct jz4740_dma_chan *dma = NULL;
2252 +
2253 +       spin_lock(&jz4740_dma_lock);
2254 +
2255 +       for (i = 0; i < ARRAY_SIZE(jz4740_dma_channels); ++i) {
2256 +               if (!jz4740_dma_channels[i].used) {
2257 +                       dma = &jz4740_dma_channels[i];
2258 +                       dma->used = 1;
2259 +                       break;
2260 +               }
2261 +       }
2262 +
2263 +       spin_unlock(&jz4740_dma_lock);
2264 +
2265 +       if (!dma)
2266 +               return NULL;
2267 +
2268 +       dma->dev = dev;
2269 +       dma->name = name;
2270 +
2271 +       return dma;
2272 +}
2273 +EXPORT_SYMBOL_GPL(jz4740_dma_request);
2274 +
2275 +void jz4740_dma_configure(struct jz4740_dma_chan *dma,
2276 +       const struct jz4740_dma_config *config)
2277 +{
2278 +       uint32_t cmd;
2279 +
2280 +       switch (config->transfer_size) {
2281 +       case JZ4740_DMA_TRANSFER_SIZE_2BYTE:
2282 +               dma->transfer_shift = 1;
2283 +               break;
2284 +       case JZ4740_DMA_TRANSFER_SIZE_4BYTE:
2285 +               dma->transfer_shift = 2;
2286 +               break;
2287 +       case JZ4740_DMA_TRANSFER_SIZE_16BYTE:
2288 +               dma->transfer_shift = 4;
2289 +               break;
2290 +       case JZ4740_DMA_TRANSFER_SIZE_32BYTE:
2291 +               dma->transfer_shift = 5;
2292 +               break;
2293 +       default:
2294 +               dma->transfer_shift = 0;
2295 +               break;
2296 +       }
2297 +
2298 +       cmd = config->flags << JZ_DMA_CMD_FLAGS_OFFSET;
2299 +       cmd |= config->src_width << JZ_DMA_CMD_SRC_WIDTH_OFFSET;
2300 +       cmd |= config->dst_width << JZ_DMA_CMD_DST_WIDTH_OFFSET;
2301 +       cmd |= config->transfer_size << JZ_DMA_CMD_TRANSFER_SIZE_OFFSET;
2302 +       cmd |= config->mode << JZ_DMA_CMD_MODE_OFFSET;
2303 +       cmd |= JZ_DMA_CMD_TRANSFER_IRQ_ENABLE;
2304 +
2305 +       jz4740_dma_write(JZ_REG_DMA_CMD(dma->id), cmd);
2306 +       jz4740_dma_write(JZ_REG_DMA_STATUS_CTRL(dma->id), 0);
2307 +       jz4740_dma_write(JZ_REG_DMA_REQ_TYPE(dma->id), config->request_type);
2308 +}
2309 +EXPORT_SYMBOL_GPL(jz4740_dma_configure);
2310 +
2311 +void jz4740_dma_set_src_addr(struct jz4740_dma_chan *dma, dma_addr_t src)
2312 +{
2313 +       jz4740_dma_write(JZ_REG_DMA_SRC_ADDR(dma->id), src);
2314 +}
2315 +EXPORT_SYMBOL_GPL(jz4740_dma_set_src_addr);
2316 +
2317 +void jz4740_dma_set_dst_addr(struct jz4740_dma_chan *dma, dma_addr_t dst)
2318 +{
2319 +       jz4740_dma_write(JZ_REG_DMA_DST_ADDR(dma->id), dst);
2320 +}
2321 +EXPORT_SYMBOL_GPL(jz4740_dma_set_dst_addr);
2322 +
2323 +void jz4740_dma_set_transfer_count(struct jz4740_dma_chan *dma, uint32_t count)
2324 +{
2325 +       count >>= dma->transfer_shift;
2326 +       jz4740_dma_write(JZ_REG_DMA_TRANSFER_COUNT(dma->id), count);
2327 +}
2328 +EXPORT_SYMBOL_GPL(jz4740_dma_set_transfer_count);
2329 +
2330 +void jz4740_dma_set_complete_cb(struct jz4740_dma_chan *dma,
2331 +       jz4740_dma_complete_callback_t cb)
2332 +{
2333 +       dma->complete_cb = cb;
2334 +}
2335 +EXPORT_SYMBOL_GPL(jz4740_dma_set_complete_cb);
2336 +
2337 +void jz4740_dma_free(struct jz4740_dma_chan *dma)
2338 +{
2339 +       dma->dev = NULL;
2340 +       dma->complete_cb = NULL;
2341 +       dma->used = 0;
2342 +}
2343 +EXPORT_SYMBOL_GPL(jz4740_dma_free);
2344 +
2345 +void jz4740_dma_enable(struct jz4740_dma_chan *dma)
2346 +{
2347 +       jz4740_dma_write_mask(JZ_REG_DMA_STATUS_CTRL(dma->id),
2348 +                       JZ_DMA_STATUS_CTRL_NO_DESC | JZ_DMA_STATUS_CTRL_ENABLE,
2349 +                       JZ_DMA_STATUS_CTRL_HALT | JZ_DMA_STATUS_CTRL_NO_DESC |
2350 +                       JZ_DMA_STATUS_CTRL_ENABLE);
2351 +
2352 +       jz4740_dma_write_mask(JZ_REG_DMA_CTRL,
2353 +                       JZ_DMA_CTRL_ENABLE,
2354 +                       JZ_DMA_CTRL_HALT | JZ_DMA_CTRL_ENABLE);
2355 +}
2356 +EXPORT_SYMBOL_GPL(jz4740_dma_enable);
2357 +
2358 +void jz4740_dma_disable(struct jz4740_dma_chan *dma)
2359 +{
2360 +       jz4740_dma_write_mask(JZ_REG_DMA_STATUS_CTRL(dma->id), 0,
2361 +                       JZ_DMA_STATUS_CTRL_ENABLE);
2362 +}
2363 +EXPORT_SYMBOL_GPL(jz4740_dma_disable);
2364 +
2365 +uint32_t jz4740_dma_get_residue(const struct jz4740_dma_chan *dma)
2366 +{
2367 +       uint32_t residue;
2368 +       residue = jz4740_dma_read(JZ_REG_DMA_TRANSFER_COUNT(dma->id));
2369 +       return residue << dma->transfer_shift;
2370 +}
2371 +EXPORT_SYMBOL_GPL(jz4740_dma_get_residue);
2372 +
2373 +static void jz4740_dma_chan_irq(struct jz4740_dma_chan *dma)
2374 +{
2375 +       uint32_t status;
2376 +
2377 +       status = jz4740_dma_read(JZ_REG_DMA_STATUS_CTRL(dma->id));
2378 +
2379 +       jz4740_dma_write_mask(JZ_REG_DMA_STATUS_CTRL(dma->id), 0,
2380 +               JZ_DMA_STATUS_CTRL_ENABLE | JZ_DMA_STATUS_CTRL_TRANSFER_DONE);
2381 +
2382 +       if (dma->complete_cb)
2383 +               dma->complete_cb(dma, 0, dma->dev);
2384 +}
2385 +
2386 +static irqreturn_t jz4740_dma_irq(int irq, void *dev_id)
2387 +{
2388 +       uint32_t irq_status;
2389 +       unsigned int i;
2390 +
2391 +       irq_status = readl(jz4740_dma_base + JZ_REG_DMA_IRQ);
2392 +
2393 +       for (i = 0; i < 6; ++i) {
2394 +               if (irq_status & (1 << i))
2395 +                       jz4740_dma_chan_irq(&jz4740_dma_channels[i]);
2396 +       }
2397 +
2398 +       return IRQ_HANDLED;
2399 +}
2400 +
2401 +#if 0
2402 +static struct jz4740_dma_config dma_test_config = {
2403 +       .src_width = JZ4740_DMA_WIDTH_32BIT,
2404 +       .dst_width = JZ4740_DMA_WIDTH_32BIT,
2405 +       .transfer_size = JZ4740_DMA_TRANSFER_SIZE_4BYTE,
2406 +       .request_type = JZ4740_DMA_TYPE_AUTO_REQUEST,
2407 +       .flags = JZ4740_DMA_SRC_AUTOINC | JZ4740_DMA_DST_AUTOINC,
2408 +       .mode = JZ4740_DMA_MODE_BLOCK,
2409 +};
2410 +
2411 +static void jz4740_dma_test(void)
2412 +{
2413 +       uint32_t *buf1, *buf2;
2414 +       dma_addr_t addr1, addr2;
2415 +       struct jz4740_dma_chan *dma = jz4740_dma_request(NULL, "dma test");
2416 +       int i;
2417 +
2418 +       printk("STARTING DMA TEST\n");
2419 +
2420 +       buf1 = dma_alloc_coherent(NULL,
2421 +                                               0x1000,
2422 +                                               &addr1, GFP_KERNEL);
2423 +       buf2 = dma_alloc_coherent(NULL,
2424 +                                               0x1000,
2425 +                                               &addr2, GFP_KERNEL);
2426 +
2427 +       for (i = 0; i < 0x400; ++i)
2428 +               buf1[i] = i;
2429 +
2430 +
2431 +       jz4740_dma_configure(dma, &dma_test_config);
2432 +       jz4740_dma_set_src_addr(dma, addr1);
2433 +       jz4740_dma_set_dst_addr(dma, addr2);
2434 +       jz4740_dma_set_transfer_count(dma, 0x1000);
2435 +
2436 +       jz4740_dma_enable(dma);
2437 +       mdelay(2000);
2438 +
2439 +       for (i = 0; i < 0x400; ++i) {
2440 +               if (buf2[i] != i)
2441 +                       printk("OH MY GOD: %x %x\n", i, buf2[i]);
2442 +       }
2443 +
2444 +       printk("DMA TEST DONE\n");
2445 +}
2446 +#endif
2447 +
2448 +static int jz4740_dma_init(void)
2449 +{
2450 +       unsigned int ret;
2451 +
2452 +       jz4740_dma_base = ioremap(CPHYSADDR(JZ4740_DMAC_BASE_ADDR), 0x400);
2453 +
2454 +       if (!jz4740_dma_base)
2455 +               return -EBUSY;
2456 +
2457 +       spin_lock_init(&jz4740_dma_lock);
2458 +
2459 +       ret = request_irq(JZ4740_IRQ_DMAC, jz4740_dma_irq, 0, "DMA", NULL);
2460 +
2461 +       if (ret)
2462 +               printk(KERN_ERR "JZ4740 DMA: Failed to request irq: %d\n", ret);
2463 +
2464 +       return ret;
2465 +}
2466 +arch_initcall(jz4740_dma_init);
2467 diff --git a/arch/mips/jz4740/gpio.c b/arch/mips/jz4740/gpio.c
2468 new file mode 100644
2469 index 0000000..84f4ef9
2470 --- /dev/null
2471 +++ b/arch/mips/jz4740/gpio.c
2472 @@ -0,0 +1,598 @@
2473 +/*
2474 + *  Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
2475 + *  JZ4740 platform GPIO support
2476 + *
2477 + *  This program is free software; you can redistribute         it and/or modify it
2478 + *  under  the terms of         the GNU General  Public License as published by the
2479 + *  Free Software Foundation;  either version 2 of the License, or (at your
2480 + *  option) any later version.
2481 + *
2482 + *  You should have received a copy of the  GNU General Public License along
2483 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
2484 + *  675 Mass Ave, Cambridge, MA 02139, USA.
2485 + *
2486 + */
2487 +
2488 +#include <linux/kernel.h>
2489 +#include <linux/module.h>
2490 +#include <linux/init.h>
2491 +
2492 +#include <linux/spinlock.h>
2493 +#include <linux/sysdev.h>
2494 +#include <linux/io.h>
2495 +#include <linux/gpio.h>
2496 +#include <linux/delay.h>
2497 +#include <linux/interrupt.h>
2498 +#include <linux/bitops.h>
2499 +
2500 +#include <linux/debugfs.h>
2501 +#include <linux/seq_file.h>
2502 +
2503 +#include <asm/mach-jz4740/base.h>
2504 +
2505 +#define JZ4740_GPIO_BASE_A (32*0)
2506 +#define JZ4740_GPIO_BASE_B (32*1)
2507 +#define JZ4740_GPIO_BASE_C (32*2)
2508 +#define JZ4740_GPIO_BASE_D (32*3)
2509 +
2510 +#define JZ4740_GPIO_NUM_A 32
2511 +#define JZ4740_GPIO_NUM_B 32
2512 +#define JZ4740_GPIO_NUM_C 31
2513 +#define JZ4740_GPIO_NUM_D 32
2514 +
2515 +#define JZ4740_IRQ_GPIO_BASE_A (JZ4740_IRQ_GPIO(0) + JZ4740_GPIO_BASE_A)
2516 +#define JZ4740_IRQ_GPIO_BASE_B (JZ4740_IRQ_GPIO(0) + JZ4740_GPIO_BASE_B)
2517 +#define JZ4740_IRQ_GPIO_BASE_C (JZ4740_IRQ_GPIO(0) + JZ4740_GPIO_BASE_C)
2518 +#define JZ4740_IRQ_GPIO_BASE_D (JZ4740_IRQ_GPIO(0) + JZ4740_GPIO_BASE_D)
2519 +
2520 +#define JZ4740_IRQ_GPIO_A(num) (JZ4740_IRQ_GPIO_BASE_A + num)
2521 +#define JZ4740_IRQ_GPIO_B(num) (JZ4740_IRQ_GPIO_BASE_B + num)
2522 +#define JZ4740_IRQ_GPIO_C(num) (JZ4740_IRQ_GPIO_BASE_C + num)
2523 +#define JZ4740_IRQ_GPIO_D(num) (JZ4740_IRQ_GPIO_BASE_D + num)
2524 +
2525 +#define JZ_REG_GPIO_PIN                        0x00
2526 +#define JZ_REG_GPIO_DATA               0x10
2527 +#define JZ_REG_GPIO_DATA_SET           0x14
2528 +#define JZ_REG_GPIO_DATA_CLEAR         0x18
2529 +#define JZ_REG_GPIO_MASK               0x20
2530 +#define JZ_REG_GPIO_MASK_SET           0x24
2531 +#define JZ_REG_GPIO_MASK_CLEAR         0x28
2532 +#define JZ_REG_GPIO_PULL               0x30
2533 +#define JZ_REG_GPIO_PULL_SET           0x34
2534 +#define JZ_REG_GPIO_PULL_CLEAR         0x38
2535 +#define JZ_REG_GPIO_FUNC               0x40
2536 +#define JZ_REG_GPIO_FUNC_SET           0x44
2537 +#define JZ_REG_GPIO_FUNC_CLEAR         0x48
2538 +#define JZ_REG_GPIO_SELECT             0x50
2539 +#define JZ_REG_GPIO_SELECT_SET         0x54
2540 +#define JZ_REG_GPIO_SELECT_CLEAR       0x58
2541 +#define JZ_REG_GPIO_DIRECTION          0x60
2542 +#define JZ_REG_GPIO_DIRECTION_SET      0x64
2543 +#define JZ_REG_GPIO_DIRECTION_CLEAR    0x68
2544 +#define JZ_REG_GPIO_TRIGGER            0x70
2545 +#define JZ_REG_GPIO_TRIGGER_SET                0x74
2546 +#define JZ_REG_GPIO_TRIGGER_CLEAR      0x78
2547 +#define JZ_REG_GPIO_FLAG               0x80
2548 +#define JZ_REG_GPIO_FLAG_CLEAR         0x14
2549 +
2550 +
2551 +#define GPIO_TO_BIT(gpio) BIT(gpio & 0x1f)
2552 +#define GPIO_TO_REG(gpio, reg) (gpio_to_jz_gpio_chip(gpio)->base + (reg))
2553 +#define CHIP_TO_REG(chip, reg) (gpio_chip_to_jz_gpio_chip(chip)->base + (reg))
2554 +
2555 +struct jz_gpio_chip {
2556 +       unsigned int irq;
2557 +       unsigned int irq_base;
2558 +       uint32_t wakeup;
2559 +       uint32_t suspend_mask;
2560 +       uint32_t edge_trigger_both;
2561 +
2562 +       void __iomem *base;
2563 +
2564 +       spinlock_t lock;
2565 +
2566 +       struct gpio_chip gpio_chip;
2567 +       struct irq_chip irq_chip;
2568 +       struct sys_device sysdev;
2569 +};
2570 +
2571 +
2572 +static struct jz_gpio_chip jz4740_gpio_chips[];
2573 +
2574 +static inline struct jz_gpio_chip *gpio_to_jz_gpio_chip(unsigned int gpio)
2575 +{
2576 +       return &jz4740_gpio_chips[gpio >> 5];
2577 +}
2578 +
2579 +static inline struct jz_gpio_chip *gpio_chip_to_jz_gpio_chip(struct gpio_chip *gpio_chip)
2580 +{
2581 +       return container_of(gpio_chip, struct jz_gpio_chip, gpio_chip);
2582 +}
2583 +
2584 +static inline struct jz_gpio_chip *irq_to_jz_gpio_chip(unsigned int irq)
2585 +{
2586 +       return get_irq_chip_data(irq);
2587 +}
2588 +
2589 +static inline void jz_gpio_write_bit(unsigned int gpio, unsigned int reg)
2590 +{
2591 +       writel(GPIO_TO_BIT(gpio), GPIO_TO_REG(gpio, reg));
2592 +}
2593 +
2594 +int jz_gpio_set_function(int gpio, enum jz_gpio_function function)
2595 +{
2596 +       if (function == JZ_GPIO_FUNC_NONE) {
2597 +               jz_gpio_write_bit(gpio, JZ_REG_GPIO_FUNC_CLEAR);
2598 +               jz_gpio_write_bit(gpio, JZ_REG_GPIO_SELECT_CLEAR);
2599 +               jz_gpio_write_bit(gpio, JZ_REG_GPIO_TRIGGER_CLEAR);
2600 +       } else {
2601 +               jz_gpio_write_bit(gpio, JZ_REG_GPIO_FUNC_SET);
2602 +               jz_gpio_write_bit(gpio, JZ_REG_GPIO_TRIGGER_CLEAR);
2603 +               switch (function) {
2604 +               case JZ_GPIO_FUNC1:
2605 +                       jz_gpio_write_bit(gpio, JZ_REG_GPIO_SELECT_CLEAR);
2606 +                       break;
2607 +               case JZ_GPIO_FUNC3:
2608 +                       jz_gpio_write_bit(gpio, JZ_REG_GPIO_TRIGGER_SET);
2609 +               case JZ_GPIO_FUNC2: /* Falltrough */
2610 +                       jz_gpio_write_bit(gpio, JZ_REG_GPIO_SELECT_SET);
2611 +                       break;
2612 +               default:
2613 +                       BUG();
2614 +                       break;
2615 +               }
2616 +       }
2617 +
2618 +       return 0;
2619 +}
2620 +EXPORT_SYMBOL_GPL(jz_gpio_set_function);
2621 +
2622 +int jz_gpio_bulk_request(const struct jz_gpio_bulk_request *request, size_t num)
2623 +{
2624 +       size_t i;
2625 +       int ret;
2626 +
2627 +       for (i = 0; i < num; ++i, ++request) {
2628 +               ret = gpio_request(request->gpio, request->name);
2629 +               if (ret)
2630 +                       goto err;
2631 +               jz_gpio_set_function(request->gpio, request->function);
2632 +       }
2633 +
2634 +       return 0;
2635 +
2636 +err:
2637 +       for (--request; i > 0; --i, --request) {
2638 +               gpio_free(request->gpio);
2639 +               jz_gpio_set_function(request->gpio, JZ_GPIO_FUNC_NONE);
2640 +       }
2641 +
2642 +       return ret;
2643 +}
2644 +EXPORT_SYMBOL_GPL(jz_gpio_bulk_request);
2645 +
2646 +void jz_gpio_bulk_free(const struct jz_gpio_bulk_request *request, size_t num)
2647 +{
2648 +       size_t i;
2649 +
2650 +       for (i = 0; i < num; ++i, ++request) {
2651 +               gpio_free(request->gpio);
2652 +               jz_gpio_set_function(request->gpio, JZ_GPIO_FUNC_NONE);
2653 +       }
2654 +
2655 +}
2656 +EXPORT_SYMBOL_GPL(jz_gpio_bulk_free);
2657 +
2658 +void jz_gpio_bulk_suspend(const struct jz_gpio_bulk_request *request, size_t num)
2659 +{
2660 +       size_t i;
2661 +
2662 +       for (i = 0; i < num; ++i, ++request) {
2663 +               jz_gpio_set_function(request->gpio, JZ_GPIO_FUNC_NONE);
2664 +               jz_gpio_write_bit(request->gpio, JZ_REG_GPIO_DIRECTION_CLEAR);
2665 +               jz_gpio_write_bit(request->gpio, JZ_REG_GPIO_PULL_SET);
2666 +       }
2667 +}
2668 +EXPORT_SYMBOL_GPL(jz_gpio_bulk_suspend);
2669 +
2670 +void jz_gpio_bulk_resume(const struct jz_gpio_bulk_request *request, size_t num)
2671 +{
2672 +       size_t i;
2673 +
2674 +       for (i = 0; i < num; ++i, ++request)
2675 +               jz_gpio_set_function(request->gpio, request->function);
2676 +}
2677 +EXPORT_SYMBOL_GPL(jz_gpio_bulk_resume);
2678 +
2679 +void jz_gpio_enable_pullup(unsigned gpio)
2680 +{
2681 +       jz_gpio_write_bit(gpio, JZ_REG_GPIO_PULL_CLEAR);
2682 +}
2683 +EXPORT_SYMBOL_GPL(jz_gpio_enable_pullup);
2684 +
2685 +void jz_gpio_disable_pullup(unsigned gpio)
2686 +{
2687 +       jz_gpio_write_bit(gpio, JZ_REG_GPIO_PULL_SET);
2688 +}
2689 +EXPORT_SYMBOL_GPL(jz_gpio_disable_pullup);
2690 +
2691 +static int jz_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
2692 +{
2693 +       return !!(readl(CHIP_TO_REG(chip, JZ_REG_GPIO_PIN)) & BIT(gpio));
2694 +}
2695 +
2696 +static void jz_gpio_set_value(struct gpio_chip *chip, unsigned gpio, int value)
2697 +{
2698 +       uint32_t __iomem *reg = CHIP_TO_REG(chip, JZ_REG_GPIO_DATA_SET);
2699 +       reg += !value;
2700 +       writel(BIT(gpio), reg);
2701 +}
2702 +
2703 +static int jz_gpio_direction_output(struct gpio_chip *chip, unsigned gpio,
2704 +       int value)
2705 +{
2706 +       writel(BIT(gpio), CHIP_TO_REG(chip, JZ_REG_GPIO_DIRECTION_SET));
2707 +       jz_gpio_set_value(chip, gpio, value);
2708 +
2709 +       return 0;
2710 +}
2711 +
2712 +static int jz_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
2713 +{
2714 +       writel(BIT(gpio), CHIP_TO_REG(chip, JZ_REG_GPIO_DIRECTION_CLEAR));
2715 +
2716 +       return 0;
2717 +}
2718 +
2719 +int jz_gpio_port_direction_input(int port, uint32_t mask)
2720 +{
2721 +       writel(mask, GPIO_TO_REG(port, JZ_REG_GPIO_DIRECTION_CLEAR));
2722 +
2723 +       return 0;
2724 +}
2725 +EXPORT_SYMBOL(jz_gpio_port_direction_input);
2726 +
2727 +int jz_gpio_port_direction_output(int port, uint32_t mask)
2728 +{
2729 +       writel(mask, GPIO_TO_REG(port, JZ_REG_GPIO_DIRECTION_SET));
2730 +
2731 +       return 0;
2732 +}
2733 +EXPORT_SYMBOL(jz_gpio_port_direction_output);
2734 +
2735 +void jz_gpio_port_set_value(int port, uint32_t value, uint32_t mask)
2736 +{
2737 +       writel(~value & mask, GPIO_TO_REG(port, JZ_REG_GPIO_DATA_CLEAR));
2738 +       writel(value & mask, GPIO_TO_REG(port, JZ_REG_GPIO_DATA_SET));
2739 +}
2740 +EXPORT_SYMBOL(jz_gpio_port_set_value);
2741 +
2742 +uint32_t jz_gpio_port_get_value(int port, uint32_t mask)
2743 +{
2744 +       uint32_t value = readl(GPIO_TO_REG(port, JZ_REG_GPIO_PIN));
2745 +
2746 +       return value & mask;
2747 +}
2748 +EXPORT_SYMBOL(jz_gpio_port_get_value);
2749 +
2750 +
2751 +#define IRQ_TO_GPIO(irq) (irq - JZ4740_IRQ_GPIO(0))
2752 +#define IRQ_TO_BIT(irq) BIT(IRQ_TO_GPIO(irq) & 0x1f)
2753 +
2754 +#define IRQ_TO_REG(irq, reg)  GPIO_TO_REG(IRQ_TO_GPIO(irq), reg)
2755 +
2756 +static void jz_gpio_irq_demux_handler(unsigned int irq, struct irq_desc *desc)
2757 +{
2758 +       uint32_t flag;
2759 +       unsigned int gpio_irq;
2760 +       unsigned int gpio_bank;
2761 +       struct jz_gpio_chip *chip = get_irq_desc_data(desc);
2762 +
2763 +       gpio_bank = JZ4740_IRQ_GPIO0 - irq;
2764 +
2765 +       flag = readl(chip->base + JZ_REG_GPIO_FLAG);
2766 +
2767 +       gpio_irq = ffs(flag) - 1;
2768 +
2769 +       if (chip->edge_trigger_both & BIT(gpio_irq)) {
2770 +               uint32_t value = readl(chip->base + JZ_REG_GPIO_PIN);
2771 +               if (value & BIT(gpio_irq)) {
2772 +                       writel(BIT(gpio_irq),
2773 +                               chip->base + JZ_REG_GPIO_DIRECTION_CLEAR);
2774 +               } else {
2775 +                       writel(BIT(gpio_irq),
2776 +                               chip->base + JZ_REG_GPIO_DIRECTION_SET);
2777 +               }
2778 +       }
2779 +
2780 +       gpio_irq += (gpio_bank << 5) + JZ4740_IRQ_GPIO(0);
2781 +
2782 +       generic_handle_irq(gpio_irq);
2783 +};
2784 +
2785 +static inline void jz_gpio_set_irq_bit(unsigned int irq, unsigned int reg)
2786 +{
2787 +       writel(IRQ_TO_BIT(irq), IRQ_TO_REG(irq, reg));
2788 +}
2789 +
2790 +static void jz_gpio_irq_mask(unsigned int irq)
2791 +{
2792 +       jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_MASK_SET);
2793 +};
2794 +
2795 +static void jz_gpio_irq_unmask(unsigned int irq)
2796 +{
2797 +       jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_MASK_CLEAR);
2798 +};
2799 +
2800 +
2801 +/* TODO: Check if function is gpio */
2802 +static unsigned int jz_gpio_irq_startup(unsigned int irq)
2803 +{
2804 +       struct irq_desc *desc = irq_to_desc(irq);
2805 +
2806 +       jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_SELECT_SET);
2807 +
2808 +       desc->status &= ~IRQ_MASKED;
2809 +       jz_gpio_irq_unmask(irq);
2810 +
2811 +       return 0;
2812 +}
2813 +
2814 +static void jz_gpio_irq_shutdown(unsigned int irq)
2815 +{
2816 +       struct irq_desc *desc = irq_to_desc(irq);
2817 +
2818 +       jz_gpio_irq_mask(irq);
2819 +       desc->status |= IRQ_MASKED;
2820 +
2821 +       /* Set direction to input */
2822 +       jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_DIRECTION_CLEAR);
2823 +       jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_SELECT_CLEAR);
2824 +}
2825 +
2826 +static void jz_gpio_irq_ack(unsigned int irq)
2827 +{
2828 +       jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_FLAG_CLEAR);
2829 +};
2830 +
2831 +static int jz_gpio_irq_set_type(unsigned int irq, unsigned int flow_type)
2832 +{
2833 +       struct jz_gpio_chip *chip = irq_to_jz_gpio_chip(irq);
2834 +       struct irq_desc *desc = irq_to_desc(irq);
2835 +
2836 +       jz_gpio_irq_mask(irq);
2837 +
2838 +       if (flow_type == IRQ_TYPE_EDGE_BOTH) {
2839 +               uint32_t value = readl(IRQ_TO_REG(irq, JZ_REG_GPIO_PIN));
2840 +               if (value & IRQ_TO_BIT(irq))
2841 +                       flow_type = IRQ_TYPE_EDGE_FALLING;
2842 +               else
2843 +                       flow_type = IRQ_TYPE_EDGE_RISING;
2844 +               chip->edge_trigger_both |= IRQ_TO_BIT(irq);
2845 +       } else {
2846 +               chip->edge_trigger_both &= ~IRQ_TO_BIT(irq);
2847 +       }
2848 +
2849 +       switch (flow_type) {
2850 +       case IRQ_TYPE_EDGE_RISING:
2851 +               jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_DIRECTION_SET);
2852 +               jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_TRIGGER_SET);
2853 +               break;
2854 +       case IRQ_TYPE_EDGE_FALLING:
2855 +               jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_DIRECTION_CLEAR);
2856 +               jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_TRIGGER_SET);
2857 +               break;
2858 +       case IRQ_TYPE_LEVEL_HIGH:
2859 +               jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_DIRECTION_SET);
2860 +               jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_TRIGGER_CLEAR);
2861 +               break;
2862 +       case IRQ_TYPE_LEVEL_LOW:
2863 +               jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_DIRECTION_CLEAR);
2864 +               jz_gpio_set_irq_bit(irq, JZ_REG_GPIO_TRIGGER_CLEAR);
2865 +               break;
2866 +       default:
2867 +               return -EINVAL;
2868 +       }
2869 +
2870 +       if (!(desc->status & IRQ_MASKED))
2871 +               jz_gpio_irq_unmask(irq);
2872 +
2873 +       return 0;
2874 +}
2875 +
2876 +static int jz_gpio_irq_set_wake(unsigned int irq, unsigned int on)
2877 +{
2878 +       struct jz_gpio_chip *chip = irq_to_jz_gpio_chip(irq);
2879 +       spin_lock(&chip->lock);
2880 +       if (on)
2881 +               chip->wakeup |= IRQ_TO_BIT(irq);
2882 +       else
2883 +               chip->wakeup &= ~IRQ_TO_BIT(irq);
2884 +       spin_unlock(&chip->lock);
2885 +
2886 +       set_irq_wake(chip->irq, on);
2887 +       return 0;
2888 +}
2889 +
2890 +int gpio_to_irq(unsigned gpio)
2891 +{
2892 +       return JZ4740_IRQ_GPIO(0) + gpio;
2893 +}
2894 +EXPORT_SYMBOL_GPL(gpio_to_irq);
2895 +
2896 +int irq_to_gpio(unsigned gpio)
2897 +{
2898 +       return IRQ_TO_GPIO(gpio);
2899 +}
2900 +EXPORT_SYMBOL_GPL(irq_to_gpio);
2901 +
2902 +/*
2903 + * This lock class tells lockdep that GPIO irqs are in a different
2904 + * category than their parents, so it won't report false recursion.
2905 + */
2906 +static struct lock_class_key gpio_lock_class;
2907 +
2908 +#define JZ4740_GPIO_CHIP(_bank) { \
2909 +       .irq_base = JZ4740_IRQ_GPIO_BASE_ ## _bank, \
2910 +       .gpio_chip = { \
2911 +               .label = "Bank " # _bank, \
2912 +               .owner = THIS_MODULE, \
2913 +               .set = jz_gpio_set_value, \
2914 +               .get = jz_gpio_get_value, \
2915 +               .direction_output = jz_gpio_direction_output, \
2916 +               .direction_input = jz_gpio_direction_input, \
2917 +               .base = JZ4740_GPIO_BASE_ ## _bank, \
2918 +               .ngpio = JZ4740_GPIO_NUM_ ## _bank, \
2919 +       }, \
2920 +       .irq_chip =  { \
2921 +               .name = "GPIO Bank " # _bank, \
2922 +               .mask = jz_gpio_irq_mask, \
2923 +               .unmask = jz_gpio_irq_unmask, \
2924 +               .ack = jz_gpio_irq_ack, \
2925 +               .startup = jz_gpio_irq_startup, \
2926 +               .shutdown = jz_gpio_irq_shutdown, \
2927 +               .set_type = jz_gpio_irq_set_type, \
2928 +               .set_wake = jz_gpio_irq_set_wake, \
2929 +       }, \
2930 +}
2931 +
2932 +static struct jz_gpio_chip jz4740_gpio_chips[] = {
2933 +       JZ4740_GPIO_CHIP(A),
2934 +       JZ4740_GPIO_CHIP(B),
2935 +       JZ4740_GPIO_CHIP(C),
2936 +       JZ4740_GPIO_CHIP(D),
2937 +};
2938 +
2939 +static inline struct jz_gpio_chip *sysdev_to_chip(struct sys_device *dev)
2940 +{
2941 +       return container_of(dev, struct jz_gpio_chip, sysdev);
2942 +}
2943 +
2944 +static int jz4740_gpio_suspend(struct sys_device *dev, pm_message_t state)
2945 +{
2946 +       struct jz_gpio_chip *chip = sysdev_to_chip(dev);
2947 +
2948 +       chip->suspend_mask = readl(chip->base + JZ_REG_GPIO_MASK);
2949 +       writel(~(chip->wakeup), chip->base + JZ_REG_GPIO_MASK_SET);
2950 +       writel(chip->wakeup, chip->base + JZ_REG_GPIO_MASK_CLEAR);
2951 +
2952 +       return 0;
2953 +}
2954 +
2955 +static int jz4740_gpio_resume(struct sys_device *dev)
2956 +{
2957 +       struct jz_gpio_chip *chip = sysdev_to_chip(dev);
2958 +       uint32_t mask = chip->suspend_mask;
2959 +
2960 +       writel(~mask, chip->base + JZ_REG_GPIO_MASK_CLEAR);
2961 +       writel(mask, chip->base + JZ_REG_GPIO_MASK_SET);
2962 +
2963 +       return 0;
2964 +}
2965 +
2966 +static struct sysdev_class jz4740_gpio_sysdev_class = {
2967 +       .name = "gpio",
2968 +       .suspend = jz4740_gpio_suspend,
2969 +       .resume = jz4740_gpio_resume,
2970 +};
2971 +
2972 +static int jz4740_gpio_chip_init(struct jz_gpio_chip *chip, unsigned int id)
2973 +{
2974 +       int ret, irq;
2975 +
2976 +       chip->sysdev.id = id;
2977 +       chip->sysdev.cls = &jz4740_gpio_sysdev_class;
2978 +       ret = sysdev_register(&chip->sysdev);
2979 +
2980 +       if (ret)
2981 +               return ret;
2982 +
2983 +       spin_lock_init(&chip->lock);
2984 +
2985 +       chip->base = ioremap(CPHYSADDR(JZ4740_GPIO_BASE_ADDR) + (id * 0x100), 0x100);
2986 +
2987 +       gpiochip_add(&chip->gpio_chip);
2988 +
2989 +       chip->irq = JZ4740_IRQ_INTC_GPIO(id);
2990 +       set_irq_data(chip->irq, chip);
2991 +       set_irq_chained_handler(chip->irq, jz_gpio_irq_demux_handler);
2992 +
2993 +       for (irq = chip->irq_base; irq < chip->irq_base + chip->gpio_chip.ngpio; ++irq) {
2994 +               lockdep_set_class(&irq_desc[irq].lock, &gpio_lock_class);
2995 +               set_irq_chip_and_handler(irq, &chip->irq_chip, handle_level_irq);
2996 +               set_irq_chip_data(irq, chip);
2997 +       }
2998 +
2999 +       return 0;
3000 +}
3001 +
3002 +int __init jz_gpiolib_init(void)
3003 +{
3004 +       unsigned int i;
3005 +       int ret;
3006 +
3007 +       ret = sysdev_class_register(&jz4740_gpio_sysdev_class);
3008 +       if (ret)
3009 +               return ret;
3010 +
3011 +       for (i = 0; i < ARRAY_SIZE(jz4740_gpio_chips); ++i) {
3012 +               jz4740_gpio_chip_init(&jz4740_gpio_chips[i], i);
3013 +       }
3014 +
3015 +       printk(KERN_INFO "JZ4740 GPIO initalized\n");
3016 +
3017 +       return 0;
3018 +}
3019 +
3020 +#ifdef CONFIG_DEBUG_FS
3021 +
3022 +static inline void gpio_seq_reg(struct seq_file *s, struct jz_gpio_chip *chip,
3023 +       const char *name, unsigned int reg)
3024 +{
3025 +       seq_printf(s, "\t%s: %08x\n", name, readl(chip->base + reg));
3026 +}
3027 +
3028 +
3029 +static int gpio_regs_show(struct seq_file *s, void *unused)
3030 +{
3031 +       struct jz_gpio_chip *chip = jz4740_gpio_chips;
3032 +       int i;
3033 +
3034 +       for (i = 0; i < ARRAY_SIZE(jz4740_gpio_chips); ++i, ++chip) {
3035 +               seq_printf(s, "GPIO %d: \n", i);
3036 +               gpio_seq_reg(s, chip, "Pin", JZ_REG_GPIO_PIN);
3037 +               gpio_seq_reg(s, chip, "Data", JZ_REG_GPIO_DATA);
3038 +               gpio_seq_reg(s, chip, "Mask", JZ_REG_GPIO_MASK);
3039 +               gpio_seq_reg(s, chip, "Pull", JZ_REG_GPIO_PULL);
3040 +               gpio_seq_reg(s, chip, "Func", JZ_REG_GPIO_FUNC);
3041 +               gpio_seq_reg(s, chip, "Select", JZ_REG_GPIO_SELECT);
3042 +               gpio_seq_reg(s, chip, "Direction", JZ_REG_GPIO_DIRECTION);
3043 +               gpio_seq_reg(s, chip, "Trigger", JZ_REG_GPIO_TRIGGER);
3044 +               gpio_seq_reg(s, chip, "Flag", JZ_REG_GPIO_FLAG);
3045 +       }
3046 +
3047 +       return 0;
3048 +}
3049 +
3050 +static int gpio_regs_open(struct inode *inode, struct file *file)
3051 +{
3052 +       return single_open(file, gpio_regs_show, NULL);
3053 +}
3054 +
3055 +static const struct file_operations gpio_regs_operations = {
3056 +       .open           = gpio_regs_open,
3057 +       .read           = seq_read,
3058 +       .llseek         = seq_lseek,
3059 +       .release        = single_release,
3060 +};
3061 +
3062 +static int __init gpio_debugfs_init(void)
3063 +{
3064 +       (void) debugfs_create_file("jz_regs_gpio", S_IFREG | S_IRUGO,
3065 +                               NULL, NULL, &gpio_regs_operations);
3066 +       return 0;
3067 +}
3068 +subsys_initcall(gpio_debugfs_init);
3069 +
3070 +#endif
3071 diff --git a/arch/mips/jz4740/irq.c b/arch/mips/jz4740/irq.c
3072 new file mode 100644
3073 index 0000000..46a03ee
3074 --- /dev/null
3075 +++ b/arch/mips/jz4740/irq.c
3076 @@ -0,0 +1,170 @@
3077 +/*
3078 + *  Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
3079 + *  JZ4740 platform IRQ support
3080 + *
3081 + *  This program is free software; you can redistribute         it and/or modify it
3082 + *  under  the terms of         the GNU General  Public License as published by the
3083 + *  Free Software Foundation;  either version 2 of the License, or (at your
3084 + *  option) any later version.
3085 + *
3086 + *  You should have received a copy of the  GNU General Public License along
3087 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
3088 + *  675 Mass Ave, Cambridge, MA 02139, USA.
3089 + *
3090 + */
3091 +
3092 +#include <linux/errno.h>
3093 +#include <linux/init.h>
3094 +#include <linux/types.h>
3095 +#include <linux/interrupt.h>
3096 +#include <linux/ioport.h>
3097 +#include <linux/timex.h>
3098 +#include <linux/slab.h>
3099 +#include <linux/delay.h>
3100 +
3101 +#include <linux/debugfs.h>
3102 +#include <linux/seq_file.h>
3103 +
3104 +#include <asm/io.h>
3105 +#include <asm/mipsregs.h>
3106 +#include <asm/irq_cpu.h>
3107 +
3108 +#include <asm/mach-jz4740/base.h>
3109 +
3110 +static void __iomem *jz_intc_base;
3111 +static uint32_t jz_intc_wakeup;
3112 +static uint32_t jz_intc_saved;
3113 +
3114 +#define JZ_REG_INTC_STATUS     0x00
3115 +#define JZ_REG_INTC_MASK       0x04
3116 +#define JZ_REG_INTC_SET_MASK   0x08
3117 +#define JZ_REG_INTC_CLEAR_MASK 0x0c
3118 +#define JZ_REG_INTC_PENDING    0x10
3119 +
3120 +#define IRQ_BIT(x) BIT((x) - JZ4740_IRQ_BASE)
3121 +
3122 +static void intc_irq_unmask(unsigned int irq)
3123 +{
3124 +       writel(IRQ_BIT(irq), jz_intc_base + JZ_REG_INTC_CLEAR_MASK);
3125 +}
3126 +
3127 +static void intc_irq_mask(unsigned int irq)
3128 +{
3129 +       writel(IRQ_BIT(irq), jz_intc_base + JZ_REG_INTC_SET_MASK);
3130 +}
3131 +
3132 +static int intc_irq_set_wake(unsigned int irq, unsigned int on)
3133 +{
3134 +       if (on)
3135 +               jz_intc_wakeup |= IRQ_BIT(irq);
3136 +       else
3137 +               jz_intc_wakeup &= ~IRQ_BIT(irq);
3138 +
3139 +       return 0;
3140 +}
3141 +
3142 +static struct irq_chip intc_irq_type = {
3143 +       .name =         "INTC",
3144 +       .mask =         intc_irq_mask,
3145 +       .mask_ack =     intc_irq_mask,
3146 +       .unmask =       intc_irq_unmask,
3147 +       .set_wake =     intc_irq_set_wake,
3148 +};
3149 +
3150 +static irqreturn_t jz4740_cascade(int irq, void *data)
3151 +{
3152 +       uint32_t irq_reg;
3153 +       int intc_irq;
3154 +
3155 +       irq_reg = readl(jz_intc_base + JZ_REG_INTC_PENDING);
3156 +
3157 +       intc_irq = ffs(irq_reg);
3158 +       if (intc_irq)
3159 +               generic_handle_irq(intc_irq - 1 + JZ4740_IRQ_BASE);
3160 +
3161 +       return IRQ_HANDLED;
3162 +}
3163 +
3164 +static struct irqaction jz4740_cascade_action = {
3165 +       .handler = jz4740_cascade,
3166 +       .name = "JZ4740 cascade interrupt",
3167 +       .flags = IRQF_DISABLED,
3168 +};
3169 +
3170 +void __init arch_init_irq(void)
3171 +{
3172 +       int i;
3173 +       mips_cpu_irq_init();
3174 +
3175 +       jz_intc_base = ioremap(CPHYSADDR(JZ4740_INTC_BASE_ADDR), 0x14);
3176 +
3177 +       for (i = JZ4740_IRQ_BASE; i < JZ4740_IRQ_BASE + 32; i++) {
3178 +               intc_irq_mask(i);
3179 +               set_irq_chip_and_handler(i, &intc_irq_type, handle_level_irq);
3180 +       }
3181 +
3182 +       setup_irq(2, &jz4740_cascade_action);
3183 +}
3184 +
3185 +asmlinkage void plat_irq_dispatch(void)
3186 +{
3187 +       unsigned int pending = read_c0_status() & read_c0_cause() & ST0_IM;
3188 +       if (pending & STATUSF_IP2)
3189 +               do_IRQ(2);
3190 +       else if (pending & STATUSF_IP3)
3191 +               do_IRQ(3);
3192 +       else
3193 +               spurious_interrupt();
3194 +}
3195 +
3196 +void jz4740_intc_suspend(void)
3197 +{
3198 +       jz_intc_saved = readl(jz_intc_base + JZ_REG_INTC_MASK);
3199 +       writel(~jz_intc_wakeup, jz_intc_base + JZ_REG_INTC_SET_MASK);
3200 +       writel(jz_intc_wakeup, jz_intc_base + JZ_REG_INTC_CLEAR_MASK);
3201 +}
3202 +
3203 +void jz4740_intc_resume(void)
3204 +{
3205 +       writel(~jz_intc_saved, jz_intc_base + JZ_REG_INTC_CLEAR_MASK);
3206 +       writel(jz_intc_saved, jz_intc_base + JZ_REG_INTC_SET_MASK);
3207 +}
3208 +
3209 +#ifdef CONFIG_DEBUG_FS
3210 +
3211 +static inline void intc_seq_reg(struct seq_file *s, const char *name,
3212 +       unsigned int reg)
3213 +{
3214 +       seq_printf(s, "%s:\t\t%08x\n", name, readl(jz_intc_base + reg));
3215 +}
3216 +
3217 +static int intc_regs_show(struct seq_file *s, void *unused)
3218 +{
3219 +       intc_seq_reg(s, "Status", JZ_REG_INTC_STATUS);
3220 +       intc_seq_reg(s, "Mask", JZ_REG_INTC_MASK);
3221 +       intc_seq_reg(s, "Pending", JZ_REG_INTC_PENDING);
3222 +
3223 +       return 0;
3224 +}
3225 +
3226 +static int intc_regs_open(struct inode *inode, struct file *file)
3227 +{
3228 +       return single_open(file, intc_regs_show, NULL);
3229 +}
3230 +
3231 +static const struct file_operations intc_regs_operations = {
3232 +       .open           = intc_regs_open,
3233 +       .read           = seq_read,
3234 +       .llseek         = seq_lseek,
3235 +       .release        = single_release,
3236 +};
3237 +
3238 +static int __init intc_debugfs_init(void)
3239 +{
3240 +       (void) debugfs_create_file("jz_regs_intc", S_IFREG | S_IRUGO,
3241 +                               NULL, NULL, &intc_regs_operations);
3242 +       return 0;
3243 +}
3244 +subsys_initcall(intc_debugfs_init);
3245 +
3246 +#endif
3247 diff --git a/arch/mips/jz4740/irq.h b/arch/mips/jz4740/irq.h
3248 new file mode 100644
3249 index 0000000..dadbd5f
3250 --- /dev/null
3251 +++ b/arch/mips/jz4740/irq.h
3252 @@ -0,0 +1,21 @@
3253 +/*
3254 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
3255 + *
3256 + *  This program is free software; you can redistribute         it and/or modify it
3257 + *  under  the terms of         the GNU General  Public License as published by the
3258 + *  Free Software Foundation;  either version 2 of the License, or (at your
3259 + *  option) any later version.
3260 + *
3261 + *  You should have received a copy of the  GNU General Public License along
3262 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
3263 + *  675 Mass Ave, Cambridge, MA 02139, USA.
3264 + *
3265 + */
3266 +
3267 +#ifndef __MIPS_JZ4740_IRQ_H__
3268 +#define __MIPS_JZ4740_IRQ_H__
3269 +
3270 +extern void jz4740_intc_suspend(void);
3271 +extern void jz4740_intc_resume(void);
3272 +
3273 +#endif
3274 diff --git a/arch/mips/jz4740/platform.c b/arch/mips/jz4740/platform.c
3275 new file mode 100644
3276 index 0000000..6bb0778
3277 --- /dev/null
3278 +++ b/arch/mips/jz4740/platform.c
3279 @@ -0,0 +1,246 @@
3280 +/*
3281 + *  Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
3282 + *  JZ4740 platform devices
3283 + *
3284 + *  This program is free software; you can redistribute         it and/or modify it
3285 + *  under  the terms of         the GNU General  Public License as published by the
3286 + *  Free Software Foundation;  either version 2 of the License, or (at your
3287 + *  option) any later version.
3288 + *
3289 + *  You should have received a copy of the  GNU General Public License along
3290 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
3291 + *  675 Mass Ave, Cambridge, MA 02139, USA.
3292 + *
3293 + */
3294 +
3295 +#include <linux/device.h>
3296 +#include <linux/platform_device.h>
3297 +#include <linux/kernel.h>
3298 +#include <linux/init.h>
3299 +#include <linux/resource.h>
3300 +
3301 +#include <asm/mach-jz4740/platform.h>
3302 +#include <asm/mach-jz4740/base.h>
3303 +#include <asm/mach-jz4740/irq.h>
3304 +
3305 +/* OHCI (USB full speed host controller) */
3306 +static struct resource jz4740_usb_ohci_resources[] = {
3307 +       [0] = {
3308 +               .start  = CPHYSADDR(JZ4740_UHC_BASE_ADDR),
3309 +               .end    = CPHYSADDR(JZ4740_UHC_BASE_ADDR) + 0x10000 - 1,
3310 +               .flags  = IORESOURCE_MEM,
3311 +       },
3312 +       [1] = {
3313 +               .start  = JZ4740_IRQ_UHC,
3314 +               .end    = JZ4740_IRQ_UHC,
3315 +               .flags  = IORESOURCE_IRQ,
3316 +       },
3317 +};
3318 +
3319 +/* The dmamask must be set for OHCI to work */
3320 +static u64 ohci_dmamask = ~(u32)0;
3321 +
3322 +struct platform_device jz4740_usb_ohci_device = {
3323 +       .name           = "jz4740-ohci",
3324 +       .id             = -1,
3325 +       .dev = {
3326 +               .dma_mask               = &ohci_dmamask,
3327 +               .coherent_dma_mask      = 0xffffffff,
3328 +       },
3329 +       .num_resources  = ARRAY_SIZE(jz4740_usb_ohci_resources),
3330 +       .resource       = jz4740_usb_ohci_resources,
3331 +};
3332 +
3333 +/* UDC (USB gadget controller) */
3334 +static struct resource jz4740_usb_gdt_resources[] = {
3335 +       [0] = {
3336 +               .start  = CPHYSADDR(JZ4740_UDC_BASE_ADDR),
3337 +               .end    = CPHYSADDR(JZ4740_UDC_BASE_ADDR) + 0x10000 - 1,
3338 +               .flags  = IORESOURCE_MEM,
3339 +       },
3340 +       [1] = {
3341 +               .start  = JZ4740_IRQ_UDC,
3342 +               .end    = JZ4740_IRQ_UDC,
3343 +               .flags  = IORESOURCE_IRQ,
3344 +       },
3345 +};
3346 +
3347 +static u64 jz4740_udc_dmamask = ~(u32)0;
3348 +
3349 +struct platform_device jz4740_usb_gdt_device = {
3350 +       .name           = "jz-udc",
3351 +       .id             = -1,
3352 +       .dev = {
3353 +               .dma_mask               = &jz4740_udc_dmamask,
3354 +               .coherent_dma_mask      = 0xffffffff,
3355 +       },
3356 +       .num_resources  = ARRAY_SIZE(jz4740_usb_gdt_resources),
3357 +       .resource       = jz4740_usb_gdt_resources,
3358 +};
3359 +
3360 +/** MMC/SD controller **/
3361 +static struct resource jz4740_mmc_resources[] = {
3362 +       [0] = {
3363 +               .start  = CPHYSADDR(JZ4740_MSC_BASE_ADDR),
3364 +               .end    = CPHYSADDR(JZ4740_MSC_BASE_ADDR) + 0x10000 - 1,
3365 +               .flags  = IORESOURCE_MEM,
3366 +       },
3367 +       [1] = {
3368 +               .start  = JZ4740_IRQ_MSC,
3369 +               .end    = JZ4740_IRQ_MSC,
3370 +               .flags  = IORESOURCE_IRQ,
3371 +       }
3372 +};
3373 +
3374 +static u64 jz4740_mmc_dmamask =  ~(u32)0;
3375 +
3376 +struct platform_device jz4740_mmc_device = {
3377 +       .name = "jz4740-mmc",
3378 +       .id = 0,
3379 +       .dev = {
3380 +               .dma_mask               = &jz4740_mmc_dmamask,
3381 +               .coherent_dma_mask      = 0xffffffff,
3382 +       },
3383 +       .num_resources  = ARRAY_SIZE(jz4740_mmc_resources),
3384 +       .resource       = jz4740_mmc_resources,
3385 +};
3386 +
3387 +static struct resource jz4740_rtc_resources[] = {
3388 +       [0] = {
3389 +               .start  = CPHYSADDR(JZ4740_RTC_BASE_ADDR),
3390 +               .end    = CPHYSADDR(JZ4740_RTC_BASE_ADDR) + 0x38 - 1,
3391 +               .flags  = IORESOURCE_MEM,
3392 +       },
3393 +       [1] = {
3394 +               .start  = JZ4740_IRQ_RTC,
3395 +               .end    = JZ4740_IRQ_RTC,
3396 +               .flags  = IORESOURCE_IRQ,
3397 +       },
3398 +};
3399 +
3400 +struct platform_device jz4740_rtc_device = {
3401 +       .name   = "jz4740-rtc",
3402 +       .id     = -1,
3403 +       .num_resources  = ARRAY_SIZE(jz4740_rtc_resources),
3404 +       .resource       = jz4740_rtc_resources,
3405 +};
3406 +
3407 +/** I2C controller **/
3408 +static struct resource jz4740_i2c_resources[] = {
3409 +       [0] = {
3410 +               .start  = CPHYSADDR(JZ4740_I2C_BASE_ADDR),
3411 +               .end    = CPHYSADDR(JZ4740_I2C_BASE_ADDR) + 0x10000 - 1,
3412 +               .flags  = IORESOURCE_MEM,
3413 +       },
3414 +       [1] = {
3415 +               .start  = JZ4740_IRQ_I2C,
3416 +               .end    = JZ4740_IRQ_I2C,
3417 +               .flags  = IORESOURCE_IRQ,
3418 +       }
3419 +};
3420 +
3421 +static u64 jz4740_i2c_dmamask =  ~(u32)0;
3422 +
3423 +struct platform_device jz4740_i2c_device = {
3424 +       .name = "jz_i2c",
3425 +       .id = 0,
3426 +       .dev = {
3427 +               .dma_mask               = &jz4740_i2c_dmamask,
3428 +               .coherent_dma_mask      = 0xffffffff,
3429 +       },
3430 +       .num_resources  = ARRAY_SIZE(jz4740_i2c_resources),
3431 +       .resource       = jz4740_i2c_resources,
3432 +};
3433 +
3434 +static struct resource jz4740_nand_resources[] = {
3435 +       [0] = {
3436 +               .start  = CPHYSADDR(JZ4740_EMC_BASE_ADDR),
3437 +               .end    = CPHYSADDR(JZ4740_EMC_BASE_ADDR) + 0x10000 - 1,
3438 +               .flags  = IORESOURCE_MEM,
3439 +       },
3440 +};
3441 +
3442 +struct platform_device jz4740_nand_device = {
3443 +       .name = "jz4740-nand",
3444 +       .num_resources = ARRAY_SIZE(jz4740_nand_resources),
3445 +       .resource = jz4740_nand_resources,
3446 +};
3447 +
3448 +static struct resource jz4740_framebuffer_resources[] = {
3449 +       [0] = {
3450 +               .start  = CPHYSADDR(JZ4740_LCD_BASE_ADDR),
3451 +               .end    = CPHYSADDR(JZ4740_LCD_BASE_ADDR) + 0x10000 - 1,
3452 +               .flags  = IORESOURCE_MEM,
3453 +       },
3454 +};
3455 +
3456 +static u64 jz4740_fb_dmamask = ~(u32)0;
3457 +
3458 +struct platform_device jz4740_framebuffer_device = {
3459 +       .name = "jz4740-fb",
3460 +       .id = -1,
3461 +       .num_resources = ARRAY_SIZE(jz4740_framebuffer_resources),
3462 +       .resource = jz4740_framebuffer_resources,
3463 +       .dev = {
3464 +               .dma_mask = &jz4740_fb_dmamask,
3465 +               .coherent_dma_mask = 0xffffffff,
3466 +       },
3467 +};
3468 +
3469 +static struct resource jz4740_i2s_resources[] = {
3470 +       [0] = {
3471 +               .start  = CPHYSADDR(JZ4740_AIC_BASE_ADDR),
3472 +               .end    = CPHYSADDR(JZ4740_AIC_BASE_ADDR) + 0x38 - 1,
3473 +               .flags  = IORESOURCE_MEM,
3474 +       },
3475 +};
3476 +
3477 +struct platform_device jz4740_i2s_device = {
3478 +       .name = "jz4740-i2s",
3479 +       .id = -1,
3480 +       .num_resources = ARRAY_SIZE(jz4740_i2s_resources),
3481 +       .resource = jz4740_i2s_resources,
3482 +};
3483 +
3484 +static struct resource jz4740_codec_resources[] = {
3485 +       [0] = {
3486 +               .start  = CPHYSADDR(JZ4740_AIC_BASE_ADDR) + 0x80,
3487 +               .end    = CPHYSADDR(JZ4740_AIC_BASE_ADDR) + 0x88 - 1,
3488 +               .flags  = IORESOURCE_MEM,
3489 +       },
3490 +};
3491 +
3492 +struct platform_device jz4740_codec_device = {
3493 +       .name           = "jz4740-codec",
3494 +       .id             = -1,
3495 +       .num_resources  = ARRAY_SIZE(jz4740_codec_resources),
3496 +       .resource       = jz4740_codec_resources,
3497 +};
3498 +
3499 +static struct resource jz4740_adc_resources[] = {
3500 +       [0] = {
3501 +               .start  = CPHYSADDR(JZ4740_SADC_BASE_ADDR),
3502 +               .end    = CPHYSADDR(JZ4740_SADC_BASE_ADDR) + 0x30,
3503 +               .flags  = IORESOURCE_MEM,
3504 +       },
3505 +       [1] = {
3506 +               .start  = JZ4740_IRQ_SADC,
3507 +               .end    = JZ4740_IRQ_SADC,
3508 +               .flags  = IORESOURCE_IRQ,
3509 +       },
3510 +};
3511 +
3512 +struct platform_device jz4740_adc_device = {
3513 +       .name           = "jz4740-adc",
3514 +       .id             = -1,
3515 +       .num_resources  = ARRAY_SIZE(jz4740_adc_resources),
3516 +       .resource       = jz4740_adc_resources,
3517 +};
3518 +
3519 +struct platform_device jz4740_battery_device = {
3520 +       .name = "jz4740-battery",
3521 +       .id = -1,
3522 +       .dev = {
3523 +               .parent = &jz4740_adc_device.dev
3524 +       },
3525 +};
3526 diff --git a/arch/mips/jz4740/pm.c b/arch/mips/jz4740/pm.c
3527 new file mode 100644
3528 index 0000000..4ca3156
3529 --- /dev/null
3530 +++ b/arch/mips/jz4740/pm.c
3531 @@ -0,0 +1,59 @@
3532 +/*
3533 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
3534 + *     JZ4740 SoC power management support
3535 + *
3536 + *  This program is free software; you can redistribute         it and/or modify it
3537 + *  under  the terms of         the GNU General  Public License as published by the
3538 + *  Free Software Foundation;  either version 2 of the License, or (at your
3539 + *  option) any later version.
3540 + *
3541 + *  You should have received a copy of the  GNU General Public License along
3542 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
3543 + *  675 Mass Ave, Cambridge, MA 02139, USA.
3544 + *
3545 + */
3546 +
3547 +#include <linux/init.h>
3548 +#include <linux/pm.h>
3549 +#include <linux/delay.h>
3550 +#include <linux/suspend.h>
3551 +
3552 +#include <asm/mach-jz4740/clock.h>
3553 +
3554 +#include "clock.h"
3555 +#include "irq.h"
3556 +
3557 +static int jz_pm_enter(suspend_state_t state)
3558 +{
3559 +       jz4740_intc_suspend();
3560 +       jz4740_clock_suspend();
3561 +
3562 +       jz4740_clock_set_wait_mode(JZ4740_WAIT_MODE_SLEEP);
3563 +
3564 +       __asm__(".set\tmips3\n\t"
3565 +               "wait\n\t"
3566 +               ".set\tmips0");
3567 +
3568 +       jz4740_clock_set_wait_mode(JZ4740_WAIT_MODE_IDLE);
3569 +
3570 +       jz4740_clock_resume();
3571 +       jz4740_intc_resume();
3572 +
3573 +       return 0;
3574 +}
3575 +
3576 +static struct platform_suspend_ops jz_pm_ops = {
3577 +       .valid          = suspend_valid_only_mem,
3578 +       .enter          = jz_pm_enter,
3579 +};
3580 +
3581 +/*
3582 + * Initialize power interface
3583 + */
3584 +int __init jz_pm_init(void)
3585 +{
3586 +       suspend_set_ops(&jz_pm_ops);
3587 +       return 0;
3588 +
3589 +}
3590 +late_initcall(jz_pm_init);
3591 diff --git a/arch/mips/jz4740/prom.c b/arch/mips/jz4740/prom.c
3592 new file mode 100644
3593 index 0000000..4f99ea3
3594 --- /dev/null
3595 +++ b/arch/mips/jz4740/prom.c
3596 @@ -0,0 +1,69 @@
3597 +/*
3598 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
3599 + *  JZ4740 SoC prom code
3600 + *
3601 + *  This program is free software; you can redistribute         it and/or modify it
3602 + *  under  the terms of         the GNU General  Public License as published by the
3603 + *  Free Software Foundation;  either version 2 of the License, or (at your
3604 + *  option) any later version.
3605 + *
3606 + *  You should have received a copy of the  GNU General Public License along
3607 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
3608 + *  675 Mass Ave, Cambridge, MA 02139, USA.
3609 + *
3610 + */
3611 +
3612 +
3613 +#include <linux/module.h>
3614 +#include <linux/kernel.h>
3615 +#include <linux/init.h>
3616 +#include <linux/string.h>
3617 +
3618 +#include <linux/serial_reg.h>
3619 +
3620 +#include <asm/bootinfo.h>
3621 +#include <asm/mach-jz4740/base.h>
3622 +
3623 +void jz4740_init_cmdline(int argc, char *argv[])
3624 +{
3625 +       unsigned int count = COMMAND_LINE_SIZE - 1;
3626 +       int i;
3627 +       char *dst = &(arcs_cmdline[0]);
3628 +       char *src;
3629 +
3630 +       for (i = 1; i < argc && count; ++i) {
3631 +               src = argv[i];
3632 +               while (*src && count) {
3633 +                       *dst++ = *src++;
3634 +                       --count;
3635 +               }
3636 +               *dst++ = ' ';
3637 +       }
3638 +       if (i > 1)
3639 +               --dst;
3640 +
3641 +       *dst = 0;
3642 +}
3643 +
3644 +void __init prom_init(void)
3645 +{
3646 +       jz4740_init_cmdline((int)fw_arg0, (char **)fw_arg1);
3647 +       mips_machtype = MACH_INGENIC_JZ4740;
3648 +}
3649 +
3650 +void __init prom_free_prom_memory(void)
3651 +{
3652 +}
3653 +
3654 +#define UART_REG(offset) ((void __iomem*)(JZ4740_UART0_BASE_ADDR + (offset << 2)))
3655 +
3656 +void prom_putchar(char c)
3657 +{
3658 +       uint8_t lsr;
3659 +
3660 +       do {
3661 +               lsr = readb(UART_REG(UART_LSR));
3662 +       } while ((lsr & UART_LSR_TEMT) == 0);
3663 +
3664 +       writeb(c, UART_REG(UART_TX));
3665 +}
3666 diff --git a/arch/mips/jz4740/pwm.c b/arch/mips/jz4740/pwm.c
3667 new file mode 100644
3668 index 0000000..0ff8c1d
3669 --- /dev/null
3670 +++ b/arch/mips/jz4740/pwm.c
3671 @@ -0,0 +1,167 @@
3672 +/*
3673 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
3674 + *  JZ4740 platform PWM support
3675 + *
3676 + *  This program is free software; you can redistribute         it and/or modify it
3677 + *  under  the terms of         the GNU General  Public License as published by the
3678 + *  Free Software Foundation;  either version 2 of the License, or (at your
3679 + *  option) any later version.
3680 + *
3681 + *  You should have received a copy of the  GNU General Public License along
3682 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
3683 + *  675 Mass Ave, Cambridge, MA 02139, USA.
3684 + *
3685 + */
3686 +
3687 +
3688 +#include <linux/kernel.h>
3689 +
3690 +#include <linux/clk.h>
3691 +#include <linux/err.h>
3692 +#include <linux/pwm.h>
3693 +#include <linux/gpio.h>
3694 +
3695 +#include <asm/mach-jz4740/gpio.h>
3696 +#include "timer.h"
3697 +
3698 +static struct clk *jz4740_pwm_clk;
3699 +
3700 +DEFINE_MUTEX(jz4740_pwm_mutex);
3701 +
3702 +struct pwm_device {
3703 +       unsigned int id;
3704 +       unsigned int gpio;
3705 +       bool used;
3706 +};
3707 +
3708 +static struct pwm_device jz4740_pwm_list[] = {
3709 +       { 2, JZ_GPIO_PWM2, false },
3710 +       { 3, JZ_GPIO_PWM3, false },
3711 +       { 4, JZ_GPIO_PWM4, false },
3712 +       { 5, JZ_GPIO_PWM5, false },
3713 +       { 6, JZ_GPIO_PWM6, false },
3714 +       { 7, JZ_GPIO_PWM7, false },
3715 +};
3716 +
3717 +struct pwm_device *pwm_request(int id, const char *label)
3718 +{
3719 +       int ret = 0;
3720 +       struct pwm_device *pwm;
3721 +
3722 +       if (!jz4740_pwm_clk) {
3723 +               jz4740_pwm_clk = clk_get(NULL, "pclk");
3724 +
3725 +               if (IS_ERR(jz4740_pwm_clk))
3726 +                       return ERR_PTR(PTR_ERR(jz4740_pwm_clk));
3727 +       }
3728 +
3729 +       if (id < 2 || id > 7) {
3730 +               return ERR_PTR(-ENOENT);
3731 +       }
3732 +
3733 +       mutex_lock(&jz4740_pwm_mutex);
3734 +
3735 +       pwm = &jz4740_pwm_list[id - 2];
3736 +       if (pwm->used)
3737 +               ret = -EBUSY;
3738 +       else
3739 +               pwm->used = true;
3740 +
3741 +       mutex_unlock(&jz4740_pwm_mutex);
3742 +
3743 +       if (ret) {
3744 +               return ERR_PTR(ret);
3745 +       }
3746 +
3747 +       ret = gpio_request(pwm->gpio, label);
3748 +
3749 +       if (ret) {
3750 +               printk("Failed to request pwm gpio: %d\n", ret);
3751 +               pwm->used = false;
3752 +               return ERR_PTR(ret);
3753 +       }
3754 +
3755 +       jz_gpio_set_function(pwm->gpio, JZ_GPIO_FUNC_PWM);
3756 +
3757 +       jz4740_timer_start(id);
3758 +
3759 +       return pwm;
3760 +}
3761 +
3762 +void pwm_free(struct pwm_device *pwm)
3763 +{
3764 +       pwm_disable(pwm);
3765 +       jz4740_timer_set_ctrl(pwm->id, 0);
3766 +
3767 +       jz_gpio_set_function(pwm->gpio, JZ_GPIO_FUNC_NONE);
3768 +       gpio_free(pwm->gpio);
3769 +
3770 +       jz4740_timer_stop(pwm->id);
3771 +
3772 +       pwm->used = false;
3773 +
3774 +}
3775 +
3776 +int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
3777 +{
3778 +       unsigned long long tmp;
3779 +       unsigned long period, duty;
3780 +       unsigned int prescaler = 0;
3781 +       unsigned int id = pwm->id;
3782 +       uint16_t ctrl;
3783 +       bool is_enabled;
3784 +
3785 +       if (duty_ns < 0 || duty_ns > period_ns)
3786 +               return -EINVAL;
3787 +
3788 +       tmp = (unsigned long long)clk_get_rate(jz4740_pwm_clk) * period_ns;
3789 +
3790 +       do_div(tmp, 1000000000);
3791 +
3792 +       period = tmp;
3793 +
3794 +       while (period > 0xffff && prescaler < 6) {
3795 +               period >>= 2;
3796 +               ++prescaler;
3797 +       }
3798 +
3799 +       if (prescaler == 6)
3800 +               return -EINVAL;
3801 +
3802 +
3803 +       tmp = (unsigned long long)period * duty_ns;
3804 +       do_div(tmp, period_ns);
3805 +       duty = tmp;
3806 +
3807 +       if (duty >= period)
3808 +               duty = period - 1;
3809 +
3810 +       is_enabled = jz4740_timer_is_enabled(id);
3811 +       jz4740_timer_disable(id);
3812 +
3813 +       jz4740_timer_set_count(id, 0);
3814 +       jz4740_timer_set_duty(id, duty);
3815 +       jz4740_timer_set_period(id, period);
3816 +
3817 +       ctrl = JZ_TIMER_CTRL_PRESCALER(prescaler) | JZ_TIMER_CTRL_PWM_ENABLE |
3818 +               JZ_TIMER_CTRL_SRC_PCLK;
3819 +
3820 +       jz4740_timer_set_ctrl(id, ctrl);
3821 +
3822 +       if (is_enabled)
3823 +               jz4740_timer_enable(id);
3824 +
3825 +       return 0;
3826 +}
3827 +
3828 +int pwm_enable(struct pwm_device *pwm)
3829 +{
3830 +       jz4740_timer_enable(pwm->id);
3831 +
3832 +       return 0;
3833 +}
3834 +
3835 +void pwm_disable(struct pwm_device *pwm)
3836 +{
3837 +       jz4740_timer_disable(pwm->id);
3838 +}
3839 diff --git a/arch/mips/jz4740/reset.c b/arch/mips/jz4740/reset.c
3840 new file mode 100644
3841 index 0000000..448a7da
3842 --- /dev/null
3843 +++ b/arch/mips/jz4740/reset.c
3844 @@ -0,0 +1,81 @@
3845 +/*
3846 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
3847 + *
3848 + *  This program is free software; you can redistribute         it and/or modify it
3849 + *  under  the terms of         the GNU General  Public License as published by the
3850 + *  Free Software Foundation;  either version 2 of the License, or (at your
3851 + *  option) any later version.
3852 + *
3853 + *  You should have received a copy of the  GNU General Public License along
3854 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
3855 + *  675 Mass Ave, Cambridge, MA 02139, USA.
3856 + *
3857 + */
3858 +
3859 +#include <linux/io.h>
3860 +#include <linux/kernel.h>
3861 +#include <linux/pm.h>
3862 +
3863 +#include <linux/delay.h>
3864 +
3865 +#include <asm/reboot.h>
3866 +
3867 +#include <asm/mach-jz4740/base.h>
3868 +#include <asm/mach-jz4740/timer.h>
3869 +
3870 +static void jz4740_halt(void)
3871 +{
3872 +       while (1) {
3873 +               __asm__(".set push;\n"
3874 +                       ".set mips3;\n"
3875 +                       "wait;\n"
3876 +                       ".set pop;\n"
3877 +               );
3878 +       }
3879 +}
3880 +
3881 +#define JZ_REG_WDT_DATA 0x00
3882 +#define JZ_REG_WDT_COUNTER_ENABLE 0x04
3883 +#define JZ_REG_WDT_COUNTER 0x08
3884 +#define JZ_REG_WDT_CTRL 0x0c
3885 +
3886 +static void jz4740_restart(char *command)
3887 +{
3888 +       void __iomem *wdt_base = ioremap(CPHYSADDR(JZ4740_WDT_BASE_ADDR), 0x0f);
3889 +
3890 +       jz4740_timer_enable_watchdog();
3891 +
3892 +       writeb(0, wdt_base + JZ_REG_WDT_COUNTER_ENABLE);
3893 +
3894 +       writew(0, wdt_base + JZ_REG_WDT_COUNTER);
3895 +       writew(0, wdt_base + JZ_REG_WDT_DATA);
3896 +       writew(BIT(2), wdt_base + JZ_REG_WDT_CTRL);
3897 +
3898 +       writeb(1, wdt_base + JZ_REG_WDT_COUNTER_ENABLE);
3899 +       jz4740_halt();
3900 +}
3901 +
3902 +#define JZ_REG_RTC_CTRL                0x00
3903 +#define JZ_REG_RTC_HIBERNATE   0x20
3904 +
3905 +#define JZ_RTC_CTRL_WRDY       BIT(7)
3906 +
3907 +static void jz4740_power_off(void)
3908 +{
3909 +       void __iomem *rtc_base = ioremap(CPHYSADDR(JZ4740_RTC_BASE_ADDR), 0x24);
3910 +       uint32_t ctrl;
3911 +
3912 +       do {
3913 +               ctrl = readl(rtc_base + JZ_REG_RTC_CTRL);
3914 +       } while (!(ctrl & JZ_RTC_CTRL_WRDY));
3915 +
3916 +       writel(1, rtc_base + JZ_REG_RTC_HIBERNATE);
3917 +       jz4740_halt();
3918 +}
3919 +
3920 +void jz4740_reset_init(void)
3921 +{
3922 +       _machine_restart = jz4740_restart;
3923 +       _machine_halt = jz4740_halt;
3924 +       pm_power_off = jz4740_power_off;
3925 +}
3926 diff --git a/arch/mips/jz4740/reset.h b/arch/mips/jz4740/reset.h
3927 new file mode 100644
3928 index 0000000..c57a829
3929 --- /dev/null
3930 +++ b/arch/mips/jz4740/reset.h
3931 @@ -0,0 +1,7 @@
3932 +#ifndef __MIPS_JZ4740_RESET_H__
3933 +#define __MIPS_JZ4740_RESET_H__
3934 +
3935 +extern void jz4740_reset_init(void);
3936 +
3937 +#endif
3938 +
3939 diff --git a/arch/mips/jz4740/setup.c b/arch/mips/jz4740/setup.c
3940 new file mode 100644
3941 index 0000000..a6628f4
3942 --- /dev/null
3943 +++ b/arch/mips/jz4740/setup.c
3944 @@ -0,0 +1,64 @@
3945 +/*
3946 + *  Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
3947 + *  JZ4740 setup code
3948 + *
3949 + *  This program is free software; you can redistribute         it and/or modify it
3950 + *  under  the terms of         the GNU General  Public License as published by the
3951 + *  Free Software Foundation;  either version 2 of the License, or (at your
3952 + *  option) any later version.
3953 + *
3954 + *  You should have received a copy of the  GNU General Public License along
3955 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
3956 + *  675 Mass Ave, Cambridge, MA 02139, USA.
3957 + *
3958 + */
3959 +
3960 +
3961 +#include <linux/init.h>
3962 +#include <linux/kernel.h>
3963 +#include <linux/serial.h>
3964 +#include <linux/serial_core.h>
3965 +#include <linux/serial_8250.h>
3966 +
3967 +#include <asm/mach-jz4740/base.h>
3968 +#include <asm/mach-jz4740/clock.h>
3969 +#include <asm/mach-jz4740/serial.h>
3970 +
3971 +#include "reset.h"
3972 +#include "clock.h"
3973 +
3974 +static void __init jz4740_serial_setup(void)
3975 +{
3976 +#ifdef CONFIG_SERIAL_8250
3977 +       struct uart_port s;
3978 +       memset(&s, 0, sizeof(s));
3979 +       s.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
3980 +       s.iotype = SERIAL_IO_MEM;
3981 +       s.regshift = 2;
3982 +       s.uartclk = jz4740_clock_bdata.ext_rate;
3983 +
3984 +       s.line = 0;
3985 +       s.membase = (u8 *)JZ4740_UART0_BASE_ADDR;
3986 +       s.irq = JZ4740_IRQ_UART0;
3987 +       if (early_serial_setup(&s) != 0) {
3988 +               printk(KERN_ERR "Serial ttyS0 setup failed!\n");
3989 +       }
3990 +
3991 +       s.line = 1;
3992 +       s.membase = (u8 *)JZ4740_UART1_BASE_ADDR;
3993 +       s.irq = JZ4740_IRQ_UART1;
3994 +       if (early_serial_setup(&s) != 0) {
3995 +               printk(KERN_ERR "Serial ttyS1 setup failed!\n");
3996 +       }
3997 +#endif
3998 +}
3999 +void __init plat_mem_setup(void)
4000 +{
4001 +       jz4740_reset_init();
4002 +       jz4740_serial_setup();
4003 +}
4004 +
4005 +const char *get_system_type(void)
4006 +{
4007 +       return "JZ4740";
4008 +}
4009 diff --git a/arch/mips/jz4740/time.c b/arch/mips/jz4740/time.c
4010 new file mode 100644
4011 index 0000000..da8183f
4012 --- /dev/null
4013 +++ b/arch/mips/jz4740/time.c
4014 @@ -0,0 +1,144 @@
4015 +/*
4016 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
4017 + *  JZ4740 platform time support
4018 + *
4019 + *  This program is free software; you can redistribute         it and/or modify it
4020 + *  under  the terms of         the GNU General  Public License as published by the
4021 + *  Free Software Foundation;  either version 2 of the License, or (at your
4022 + *  option) any later version.
4023 + *
4024 + *  You should have received a copy of the  GNU General Public License along
4025 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
4026 + *  675 Mass Ave, Cambridge, MA 02139, USA.
4027 + *
4028 + */
4029 +
4030 +#include <linux/interrupt.h>
4031 +#include <linux/kernel.h>
4032 +#include <linux/time.h>
4033 +
4034 +#include <linux/clockchips.h>
4035 +
4036 +#include <asm/mach-jz4740/irq.h>
4037 +#include <asm/time.h>
4038 +
4039 +#include "clock.h"
4040 +#include "timer.h"
4041 +
4042 +#define TIMER_CLOCKEVENT 0
4043 +#define TIMER_CLOCKSOURCE 1
4044 +
4045 +static uint16_t jz4740_jiffies_per_tick;
4046 +
4047 +static cycle_t jz4740_clocksource_read(struct clocksource *cs)
4048 +{
4049 +       return jz4740_timer_get_count(TIMER_CLOCKSOURCE);
4050 +}
4051 +
4052 +static struct clocksource jz4740_clocksource = {
4053 +       .name = "jz4740-timer",
4054 +       .rating = 200,
4055 +       .read = jz4740_clocksource_read,
4056 +       .mask = CLOCKSOURCE_MASK(16),
4057 +       .flags = CLOCK_SOURCE_IS_CONTINUOUS,
4058 +};
4059 +
4060 +static irqreturn_t jz4740_clockevent_irq(int irq, void *devid)
4061 +{
4062 +       struct clock_event_device *cd = devid;
4063 +
4064 +       jz4740_timer_ack_full(TIMER_CLOCKEVENT);
4065 +
4066 +       if (cd->mode != CLOCK_EVT_MODE_PERIODIC)
4067 +               jz4740_timer_disable(TIMER_CLOCKEVENT);
4068 +
4069 +       cd->event_handler(cd);
4070 +
4071 +       return IRQ_HANDLED;
4072 +}
4073 +
4074 +static void jz4740_clockevent_set_mode(enum clock_event_mode mode,
4075 +       struct clock_event_device *cd)
4076 +{
4077 +       switch (mode) {
4078 +       case CLOCK_EVT_MODE_PERIODIC:
4079 +               jz4740_timer_set_count(TIMER_CLOCKEVENT, 0);
4080 +               jz4740_timer_set_period(TIMER_CLOCKEVENT, jz4740_jiffies_per_tick);
4081 +       case CLOCK_EVT_MODE_RESUME:
4082 +               jz4740_timer_irq_full_enable(TIMER_CLOCKEVENT);
4083 +               jz4740_timer_enable(TIMER_CLOCKEVENT);
4084 +               break;
4085 +       case CLOCK_EVT_MODE_ONESHOT:
4086 +       case CLOCK_EVT_MODE_SHUTDOWN:
4087 +               jz4740_timer_disable(TIMER_CLOCKEVENT);
4088 +               break;
4089 +       default:
4090 +               break;
4091 +       }
4092 +}
4093 +
4094 +static int jz4740_clockevent_set_next(unsigned long evt,
4095 +       struct clock_event_device *cd)
4096 +{
4097 +       jz4740_timer_set_count(TIMER_CLOCKEVENT, 0);
4098 +       jz4740_timer_set_period(TIMER_CLOCKEVENT, evt);
4099 +       jz4740_timer_enable(TIMER_CLOCKEVENT);
4100 +
4101 +       return 0;
4102 +}
4103 +
4104 +static struct clock_event_device jz4740_clockevent = {
4105 +       .name = "jz4740-timer",
4106 +       .features = CLOCK_EVT_FEAT_PERIODIC,
4107 +       .set_next_event = jz4740_clockevent_set_next,
4108 +       .set_mode = jz4740_clockevent_set_mode,
4109 +       .rating = 200,
4110 +       .irq = JZ4740_IRQ_TCU0,
4111 +};
4112 +
4113 +static struct irqaction timer_irqaction = {
4114 +       .handler        = jz4740_clockevent_irq,
4115 +       .flags          = IRQF_PERCPU | IRQF_TIMER | IRQF_DISABLED,
4116 +       .name           = "jz4740-timerirq",
4117 +       .dev_id         = &jz4740_clockevent,
4118 +};
4119 +
4120 +void __init plat_time_init(void)
4121 +{
4122 +       int ret;
4123 +       uint32_t clk_rate;
4124 +       uint16_t ctrl;
4125 +
4126 +       jz4740_timer_init();
4127 +
4128 +       clk_rate = jz4740_clock_bdata.ext_rate >> 4;
4129 +       jz4740_jiffies_per_tick = DIV_ROUND_CLOSEST(clk_rate, HZ);
4130 +
4131 +       clockevent_set_clock(&jz4740_clockevent, clk_rate);
4132 +       jz4740_clockevent.min_delta_ns = clockevent_delta2ns(100, &jz4740_clockevent);
4133 +       jz4740_clockevent.max_delta_ns = clockevent_delta2ns(0xffff, &jz4740_clockevent);
4134 +       jz4740_clockevent.cpumask = cpumask_of(0);
4135 +
4136 +       clockevents_register_device(&jz4740_clockevent);
4137 +
4138 +       clocksource_set_clock(&jz4740_clocksource, clk_rate);
4139 +       ret = clocksource_register(&jz4740_clocksource);
4140 +
4141 +       if (ret)
4142 +               printk(KERN_ERR "Failed to register clocksource: %d\n", ret);
4143 +
4144 +       setup_irq(JZ4740_IRQ_TCU0, &timer_irqaction);
4145 +
4146 +       ctrl = JZ_TIMER_CTRL_PRESCALE_16 | JZ_TIMER_CTRL_SRC_EXT;
4147 +
4148 +       jz4740_timer_set_ctrl(TIMER_CLOCKEVENT, ctrl);
4149 +       jz4740_timer_set_ctrl(TIMER_CLOCKSOURCE, ctrl);
4150 +
4151 +       jz4740_timer_set_period(TIMER_CLOCKEVENT, jz4740_jiffies_per_tick);
4152 +       jz4740_timer_irq_full_enable(TIMER_CLOCKEVENT);
4153 +
4154 +       jz4740_timer_set_period(TIMER_CLOCKSOURCE, 0xffff);
4155 +
4156 +       jz4740_timer_enable(TIMER_CLOCKEVENT);
4157 +       jz4740_timer_enable(TIMER_CLOCKSOURCE);
4158 +}
4159 diff --git a/arch/mips/jz4740/timer.c b/arch/mips/jz4740/timer.c
4160 new file mode 100644
4161 index 0000000..6e09cae
4162 --- /dev/null
4163 +++ b/arch/mips/jz4740/timer.c
4164 @@ -0,0 +1,48 @@
4165 +/*
4166 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
4167 + *  JZ4740 platform timer support
4168 + *
4169 + *  This program is free software; you can redistribute         it and/or modify it
4170 + *  under  the terms of         the GNU General  Public License as published by the
4171 + *  Free Software Foundation;  either version 2 of the License, or (at your
4172 + *  option) any later version.
4173 + *
4174 + *  You should have received a copy of the  GNU General Public License along
4175 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
4176 + *  675 Mass Ave, Cambridge, MA 02139, USA.
4177 + *
4178 + */
4179 +
4180 +#include <linux/io.h>
4181 +#include <linux/kernel.h>
4182 +#include <linux/module.h>
4183 +
4184 +#include "timer.h"
4185 +
4186 +#include <asm/mach-jz4740/base.h>
4187 +
4188 +void __iomem *jz4740_timer_base;
4189 +
4190 +void jz4740_timer_enable_watchdog(void)
4191 +{
4192 +       writel(BIT(16), jz4740_timer_base + JZ_REG_TIMER_STOP_CLEAR);
4193 +}
4194 +
4195 +void jz4740_timer_disable_watchdog(void)
4196 +{
4197 +       writel(BIT(16), jz4740_timer_base + JZ_REG_TIMER_STOP_SET);
4198 +}
4199 +
4200 +void __init jz4740_timer_init(void)
4201 +{
4202 +       jz4740_timer_base = ioremap(CPHYSADDR(JZ4740_TCU_BASE_ADDR), 0x100);
4203 +
4204 +       if (!jz4740_timer_base)
4205 +               panic("Failed to ioremap timer registers");
4206 +
4207 +       /* Disable all timer clocks except for those used as system timers */
4208 +       writel(0x000100fc, jz4740_timer_base + JZ_REG_TIMER_STOP_SET);
4209 +
4210 +       /* Timer irqs are unmasked by default, mask them */
4211 +       writel(0x00ff00ff, jz4740_timer_base + JZ_REG_TIMER_MASK_SET);
4212 +}
4213 diff --git a/arch/mips/jz4740/timer.h b/arch/mips/jz4740/timer.h
4214 new file mode 100644
4215 index 0000000..77d748c
4216 --- /dev/null
4217 +++ b/arch/mips/jz4740/timer.h
4218 @@ -0,0 +1,130 @@
4219 +/*
4220 + *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
4221 + *  JZ4740 platform timer support
4222 + *
4223 + *  This program is free software; you can redistribute         it and/or modify it
4224 + *  under  the terms of         the GNU General  Public License as published by the
4225 + *  Free Software Foundation;  either version 2 of the License, or (at your
4226 + *  option) any later version.
4227 + *
4228 + *  You should have received a copy of the  GNU General Public License along
4229 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
4230 + *  675 Mass Ave, Cambridge, MA 02139, USA.
4231 + *
4232 + */
4233 +
4234 +#ifndef __MIPS_JZ4740_TIMER_H__
4235 +#define __MIPS_JZ4740_TIMER_H__
4236 +
4237 +#include <linux/module.h>
4238 +#include <linux/io.h>
4239 +
4240 +#define JZ_REG_TIMER_STOP              0x1C
4241 +#define JZ_REG_TIMER_STOP_SET          0x2C
4242 +#define JZ_REG_TIMER_STOP_CLEAR                0x3C
4243 +#define JZ_REG_TIMER_ENABLE            0x10
4244 +#define JZ_REG_TIMER_ENABLE_SET                0x14
4245 +#define JZ_REG_TIMER_ENABLE_CLEAR      0x18
4246 +#define JZ_REG_TIMER_FLAG              0x20
4247 +#define JZ_REG_TIMER_FLAG_SET          0x24
4248 +#define JZ_REG_TIMER_FLAG_CLEAR                0x28
4249 +#define JZ_REG_TIMER_MASK              0x30
4250 +#define JZ_REG_TIMER_MASK_SET          0x34
4251 +#define JZ_REG_TIMER_MASK_CLEAR                0x38
4252 +
4253 +#define JZ_REG_TIMER_DFR(x) (((x) * 0x10) + 0x40)
4254 +#define JZ_REG_TIMER_DHR(x) (((x) * 0x10) + 0x44)
4255 +#define JZ_REG_TIMER_CNT(x) (((x) * 0x10) + 0x48)
4256 +#define JZ_REG_TIMER_CTRL(x) (((x) * 0x10) + 0x4C)
4257 +
4258 +#define JZ_TIMER_IRQ_HALF(x) BIT((x) + 0x10)
4259 +#define JZ_TIMER_IRQ_FULL(x) BIT(x)
4260 +
4261 +#define JZ_TIMER_CTRL_PWM_ACTIVE_LOW   BIT(8)
4262 +#define JZ_TIMER_CTRL_PWM_ENABLE       BIT(7)
4263 +#define JZ_TIMER_CTRL_PRESCALE_MASK    0x1c
4264 +#define JZ_TIMER_CTRL_PRESCALE_OFFSET  0x3
4265 +#define JZ_TIMER_CTRL_PRESCALE_1       (0 << 3)
4266 +#define JZ_TIMER_CTRL_PRESCALE_4       (1 << 3)
4267 +#define JZ_TIMER_CTRL_PRESCALE_16      (2 << 3)
4268 +#define JZ_TIMER_CTRL_PRESCALE_64      (3 << 3)
4269 +#define JZ_TIMER_CTRL_PRESCALE_256     (4 << 3)
4270 +#define JZ_TIMER_CTRL_PRESCALE_1024    (5 << 3)
4271 +
4272 +#define JZ_TIMER_CTRL_PRESCALER(x) ((x) << JZ_TIMER_CTRL_PRESCALE_OFFSET)
4273 +
4274 +#define JZ_TIMER_CTRL_SRC_EXT          BIT(2)
4275 +#define JZ_TIMER_CTRL_SRC_RTC          BIT(1)
4276 +#define JZ_TIMER_CTRL_SRC_PCLK         BIT(0)
4277 +
4278 +extern void __iomem *jz4740_timer_base;
4279 +void __init jz4740_timer_init(void);
4280 +
4281 +static inline void jz4740_timer_stop(unsigned int timer)
4282 +{
4283 +       writel(BIT(timer), jz4740_timer_base + JZ_REG_TIMER_STOP_SET);
4284 +}
4285 +
4286 +static inline void jz4740_timer_start(unsigned int timer)
4287 +{
4288 +       writel(BIT(timer), jz4740_timer_base + JZ_REG_TIMER_STOP_CLEAR);
4289 +}
4290 +
4291 +static inline bool jz4740_timer_is_enabled(unsigned int timer)
4292 +{
4293 +       return readb(jz4740_timer_base + JZ_REG_TIMER_ENABLE) & BIT(timer);
4294 +}
4295 +
4296 +static inline void jz4740_timer_enable(unsigned int timer)
4297 +{
4298 +       writeb(BIT(timer), jz4740_timer_base + JZ_REG_TIMER_ENABLE_SET);
4299 +}
4300 +
4301 +static inline void jz4740_timer_disable(unsigned int timer)
4302 +{
4303 +       writeb(BIT(timer), jz4740_timer_base + JZ_REG_TIMER_ENABLE_CLEAR);
4304 +}
4305 +
4306 +
4307 +static inline void jz4740_timer_set_period(unsigned int timer, uint16_t period)
4308 +{
4309 +       writew(period, jz4740_timer_base + JZ_REG_TIMER_DFR(timer));
4310 +}
4311 +
4312 +static inline void jz4740_timer_set_duty(unsigned int timer, uint16_t duty)
4313 +{
4314 +       writew(duty, jz4740_timer_base + JZ_REG_TIMER_DHR(timer));
4315 +}
4316 +
4317 +static inline void jz4740_timer_set_count(unsigned int timer, uint16_t count)
4318 +{
4319 +       writew(count, jz4740_timer_base + JZ_REG_TIMER_CNT(timer));
4320 +}
4321 +
4322 +static inline uint16_t jz4740_timer_get_count(unsigned int timer)
4323 +{
4324 +       return readw(jz4740_timer_base + JZ_REG_TIMER_CNT(timer));
4325 +}
4326 +
4327 +static inline void jz4740_timer_ack_full(unsigned int timer)
4328 +{
4329 +       writel(JZ_TIMER_IRQ_FULL(timer), jz4740_timer_base + JZ_REG_TIMER_FLAG_CLEAR);
4330 +}
4331 +
4332 +static inline void jz4740_timer_irq_full_enable(unsigned int timer)
4333 +{
4334 +       writel(JZ_TIMER_IRQ_FULL(timer), jz4740_timer_base + JZ_REG_TIMER_FLAG_CLEAR);
4335 +       writel(JZ_TIMER_IRQ_FULL(timer), jz4740_timer_base + JZ_REG_TIMER_MASK_CLEAR);
4336 +}
4337 +
4338 +static inline void jz4740_timer_irq_full_disable(unsigned int timer)
4339 +{
4340 +       writel(JZ_TIMER_IRQ_FULL(timer), jz4740_timer_base + JZ_REG_TIMER_MASK_SET);
4341 +}
4342 +
4343 +static inline void jz4740_timer_set_ctrl(unsigned int timer, uint16_t ctrl)
4344 +{
4345 +       writew(ctrl, jz4740_timer_base + JZ_REG_TIMER_CTRL(timer));
4346 +}
4347 +
4348 +#endif
4349 diff --git a/arch/mips/kernel/cpu-probe.c b/arch/mips/kernel/cpu-probe.c
4350 index be5bb16..926c260 100644
4351 --- a/arch/mips/kernel/cpu-probe.c
4352 +++ b/arch/mips/kernel/cpu-probe.c
4353 @@ -163,6 +163,7 @@ void __init check_wait(void)
4354         case CPU_BCM6358:
4355         case CPU_CAVIUM_OCTEON:
4356         case CPU_CAVIUM_OCTEON_PLUS:
4357 +       case CPU_JZRISC:
4358                 cpu_wait = r4k_wait;
4359                 break;
4360
4361 @@ -932,6 +933,22 @@ platform:
4362         }
4363  }
4364
4365 +static inline void cpu_probe_ingenic(struct cpuinfo_mips *c, unsigned int cpu)
4366 +{
4367 +       decode_configs(c);
4368 +       /* JZRISC does not implement the CP0 counter. */
4369 +       c->options &= ~MIPS_CPU_COUNTER;
4370 +       switch (c->processor_id & 0xff00) {
4371 +       case PRID_IMP_JZRISC:
4372 +               c->cputype = CPU_JZRISC;
4373 +               __cpu_name[cpu] = "Ingenic JZRISC";
4374 +               break;
4375 +       default:
4376 +               panic("Unknown Ingenic Processor ID!");
4377 +               break;
4378 +       }
4379 +}
4380 +
4381  const char *__cpu_name[NR_CPUS];
4382  const char *__elf_platform;
4383
4384 @@ -970,6 +987,9 @@ __cpuinit void cpu_probe(void)
4385         case PRID_COMP_CAVIUM:
4386                 cpu_probe_cavium(c, cpu);
4387                 break;
4388 +       case PRID_COMP_INGENIC:
4389 +               cpu_probe_ingenic(c, cpu);
4390 +               break;
4391         }
4392
4393         BUG_ON(!__cpu_name[cpu]);
4394 diff --git a/arch/mips/mm/tlbex.c b/arch/mips/mm/tlbex.c
4395 index 86f004d..4510e61 100644
4396 --- a/arch/mips/mm/tlbex.c
4397 +++ b/arch/mips/mm/tlbex.c
4398 @@ -409,6 +409,11 @@ static void __cpuinit build_tlb_write_entry(u32 **p, struct uasm_label **l,
4399                 tlbw(p);
4400                 break;
4401
4402 +       case CPU_JZRISC:
4403 +               tlbw(p);
4404 +               uasm_i_nop(p);
4405 +               break;
4406 +
4407         default:
4408                 panic("No TLB refill handler yet (CPU type: %d)",
4409                       current_cpu_data.cputype);
4410 --
4411 1.5.6.5
4412