arch/arm/mach-sa1100/generic.c

   1 /*
   2  * linux/arch/arm/mach-sa1100/generic.c
   3  *
   4  * Author: Nicolas Pitre
   5  *
   6  * Code common to all SA11x0 machines.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12 #include <linux/config.h>
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/init.h>
  16 #include <linux/delay.h>
  17 #include <linux/pm.h>
  18 #include <linux/cpufreq.h>
  19 #include <linux/ioport.h>
  20
  21 #include <asm/div64.h>
  22 #include <asm/hardware.h>
  23 #include <asm/system.h>
  24 #include <asm/pgtable.h>
  25 #include <asm/mach/map.h>
  26 #include <asm/irq.h>
  27
  28 #include "generic.h"
  29
  30 #define NR_FREQS        16
  31
  32 /*
  33  * This table is setup for a 3.6864MHz Crystal.
  34  */
  35 static const unsigned short cclk_frequency_100khz[NR_FREQS] = {
  36          590,   /*  59.0 MHz */
  37          737,   /*  73.7 MHz */
  38          885,   /*  88.5 MHz */
  39         1032,   /* 103.2 MHz */
  40         1180,   /* 118.0 MHz */
  41         1327,   /* 132.7 MHz */
  42         1475,   /* 147.5 MHz */
  43         1622,   /* 162.2 MHz */
  44         1769,   /* 176.9 MHz */
  45         1917,   /* 191.7 MHz */
  46         2064,   /* 206.4 MHz */
  47         2212,   /* 221.2 MHz */
  48         2359,   /* 235.9 MHz */
  49         2507,   /* 250.7 MHz */
  50         2654,   /* 265.4 MHz */
  51         2802    /* 280.2 MHz */
  52 };
  53
  54 #if defined(CONFIG_CPU_FREQ_SA1100) || defined(CONFIG_CPU_FREQ_SA1110)
  55 /* rounds up(!)  */
  56 unsigned int sa11x0_freq_to_ppcr(unsigned int khz)
  57 {
  58         int i;
  59
  60         khz /= 100;
  61
  62         for (i = 0; i < NR_FREQS; i++)
  63                 if (cclk_frequency_100khz[i] >= khz)
  64                         break;
  65
  66         return i;
  67 }
  68
  69 unsigned int sa11x0_ppcr_to_freq(unsigned int idx)
  70 {
  71         unsigned int freq = 0;
  72         if (idx < NR_FREQS)
  73                 freq = cclk_frequency_100khz[idx] * 100;
  74         return freq;
  75 }
  76
  77
  78 /* make sure that only the "userspace" governor is run -- anything else wouldn't make sense on
  79  * this platform, anyway.
  80  */
  81 int sa11x0_verify_speed(struct cpufreq_policy *policy)
  82 {
  83         unsigned int tmp;
  84         if (policy->cpu)
  85                 return -EINVAL;
  86
  87         cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq, policy->cpuinfo.max_freq);
  88
  89         /* make sure that at least one frequency is within the policy */
  90         tmp = cclk_frequency_100khz[sa11x0_freq_to_ppcr(policy->min)] * 100;
  91         if (tmp > policy->max)
  92                 policy->max = tmp;
  93
  94         cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq, policy->cpuinfo.max_freq);
  95
  96         return 0;
  97 }
  98
  99 unsigned int sa11x0_getspeed(void)
 100 {
 101         return cclk_frequency_100khz[PPCR & 0xf] * 100;
 102 }
 103 EXPORT_SYMBOL(sa11x0_getspeed);
 104 #else
 105 /*
 106  * We still need to provide this so building without cpufreq works.
 107  */
 108 unsigned int cpufreq_get(unsigned int cpu)
 109 {
 110         return cclk_frequency_100khz[PPCR & 0xf] * 100;
 111 }
 112 EXPORT_SYMBOL(cpufreq_get);
 113 #endif
 114
 115 /*
 116  * This is the SA11x0 sched_clock implementation.  This has
 117  * a resolution of 271ns, and a maximum value of 1165s.
 118  *  ( * 1E9 / 3686400 => * 78125 / 288)
 119  */
 120 unsigned long long sched_clock(void)
 121 {
 122         unsigned long long v;
 123
 124         v = (unsigned long long)OSCR * 78125;
 125         do_div(v, 288);
 126
 127         return v;
 128 }
 129
 130 /*
 131  * Default power-off for SA1100
 132  */
 133 static void sa1100_power_off(void)
 134 {
 135         mdelay(100);
 136         local_irq_disable();
 137         /* disable internal oscillator, float CS lines */
 138         PCFR = (PCFR_OPDE | PCFR_FP | PCFR_FS);
 139         /* enable wake-up on GPIO0 (Assabet...) */
 140         PWER = GFER = GRER = 1;
 141         /*
 142          * set scratchpad to zero, just in case it is used as a
 143          * restart address by the bootloader.
 144          */
 145         PSPR = 0;
 146         /* enter sleep mode */
 147         PMCR = PMCR_SF;
 148 }
 149
 150 static struct resource sa11x0udc_resources[] = {
 151         [0] = {
 152                 .start  = 0x80000000,
 153                 .end    = 0x8000ffff,
 154                 .flags  = IORESOURCE_MEM,
 155         },
 156 };
 157
 158 static u64 sa11x0udc_dma_mask = 0xffffffffUL;
 159
 160 static struct platform_device sa11x0udc_device = {
 161         .name           = "sa11x0-udc",
 162         .id             = 0,
 163         .dev            = {
 164                 .dma_mask = &sa11x0udc_dma_mask,
 165                 .coherent_dma_mask = 0xffffffff,
 166         },
 167         .num_resources  = ARRAY_SIZE(sa11x0udc_resources),
 168         .resource       = sa11x0udc_resources,
 169 };
 170
 171 static struct resource sa11x0uart1_resources[] = {
 172         [0] = {
 173                 .start  = 0x80010000,
 174                 .end    = 0x8001ffff,
 175                 .flags  = IORESOURCE_MEM,
 176         },
 177 };
 178
 179 static struct platform_device sa11x0uart1_device = {
 180         .name           = "sa11x0-uart",
 181         .id             = 1,
 182         .num_resources  = ARRAY_SIZE(sa11x0uart1_resources),
 183         .resource       = sa11x0uart1_resources,
 184 };
 185
 186 static struct resource sa11x0uart3_resources[] = {
 187         [0] = {
 188                 .start  = 0x80050000,
 189                 .end    = 0x8005ffff,
 190                 .flags  = IORESOURCE_MEM,
 191         },
 192 };
 193
 194 static struct platform_device sa11x0uart3_device = {
 195         .name           = "sa11x0-uart",
 196         .id             = 3,
 197         .num_resources  = ARRAY_SIZE(sa11x0uart3_resources),
 198         .resource       = sa11x0uart3_resources,
 199 };
 200
 201 static struct resource sa11x0mcp_resources[] = {
 202         [0] = {
 203                 .start  = 0x80060000,
 204                 .end    = 0x8006ffff,
 205                 .flags  = IORESOURCE_MEM,
 206         },
 207 };
 208
 209 static u64 sa11x0mcp_dma_mask = 0xffffffffUL;
 210
 211 static struct platform_device sa11x0mcp_device = {
 212         .name           = "sa11x0-mcp",
 213         .id             = 0,
 214         .dev = {
 215                 .dma_mask = &sa11x0mcp_dma_mask,
 216                 .coherent_dma_mask = 0xffffffff,
 217         },
 218         .num_resources  = ARRAY_SIZE(sa11x0mcp_resources),
 219         .resource       = sa11x0mcp_resources,
 220 };
 221
 222 static struct resource sa11x0ssp_resources[] = {
 223         [0] = {
 224                 .start  = 0x80070000,
 225                 .end    = 0x8007ffff,
 226                 .flags  = IORESOURCE_MEM,
 227         },
 228 };
 229
 230 static u64 sa11x0ssp_dma_mask = 0xffffffffUL;
 231
 232 static struct platform_device sa11x0ssp_device = {
 233         .name           = "sa11x0-ssp",
 234         .id             = 0,
 235         .dev = {
 236                 .dma_mask = &sa11x0ssp_dma_mask,
 237                 .coherent_dma_mask = 0xffffffff,
 238         },
 239         .num_resources  = ARRAY_SIZE(sa11x0ssp_resources),
 240         .resource       = sa11x0ssp_resources,
 241 };
 242
 243 static struct resource sa11x0fb_resources[] = {
 244         [0] = {
 245                 .start  = 0xb0100000,
 246                 .end    = 0xb010ffff,
 247                 .flags  = IORESOURCE_MEM,
 248         },
 249         [1] = {
 250                 .start  = IRQ_LCD,
 251                 .end    = IRQ_LCD,
 252                 .flags  = IORESOURCE_IRQ,
 253         },
 254 };
 255
 256 static struct platform_device sa11x0fb_device = {
 257         .name           = "sa11x0-fb",
 258         .id             = 0,
 259         .dev = {
 260                 .coherent_dma_mask = 0xffffffff,
 261         },
 262         .num_resources  = ARRAY_SIZE(sa11x0fb_resources),
 263         .resource       = sa11x0fb_resources,
 264 };
 265
 266 static struct platform_device sa11x0pcmcia_device = {
 267         .name           = "sa11x0-pcmcia",
 268         .id             = 0,
 269 };
 270
 271 static struct platform_device *sa11x0_devices[] __initdata = {
 272         &sa11x0udc_device,
 273         &sa11x0uart1_device,
 274         &sa11x0uart3_device,
 275         &sa11x0mcp_device,
 276         &sa11x0ssp_device,
 277         &sa11x0pcmcia_device,
 278         &sa11x0fb_device,
 279 };
 280
 281 static int __init sa1100_init(void)
 282 {
 283         pm_power_off = sa1100_power_off;
 284
 285         return platform_add_devices(sa11x0_devices, ARRAY_SIZE(sa11x0_devices));
 286 }
 287
 288 arch_initcall(sa1100_init);
 289
 290 void (*sa1100fb_backlight_power)(int on);
 291 void (*sa1100fb_lcd_power)(int on);
 292
 293 EXPORT_SYMBOL(sa1100fb_backlight_power);
 294 EXPORT_SYMBOL(sa1100fb_lcd_power);
 295
 296
 297 /*
 298  * Common I/O mapping:
 299  *
 300  * Typically, static virtual address mappings are as follow:
 301  *
 302  * 0xf0000000-0xf3ffffff:       miscellaneous stuff (CPLDs, etc.)
 303  * 0xf4000000-0xf4ffffff:       SA-1111
 304  * 0xf5000000-0xf5ffffff:       reserved (used by cache flushing area)
 305  * 0xf6000000-0xfffeffff:       reserved (internal SA1100 IO defined above)
 306  * 0xffff0000-0xffff0fff:       SA1100 exception vectors
 307  * 0xffff2000-0xffff2fff:       Minicache copy_user_page area
 308  *
 309  * Below 0xe8000000 is reserved for vm allocation.
 310  *
 311  * The machine specific code must provide the extra mapping beside the
 312  * default mapping provided here.
 313  */
 314
 315 static struct map_desc standard_io_desc[] __initdata = {
 316  /* virtual     physical    length      type */
 317   { 0xf8000000, 0x80000000, 0x00100000, MT_DEVICE }, /* PCM */
 318   { 0xfa000000, 0x90000000, 0x00100000, MT_DEVICE }, /* SCM */
 319   { 0xfc000000, 0xa0000000, 0x00100000, MT_DEVICE }, /* MER */
 320   { 0xfe000000, 0xb0000000, 0x00200000, MT_DEVICE }  /* LCD + DMA */
 321 };
 322
 323 void __init sa1100_map_io(void)
 324 {
 325         iotable_init(standard_io_desc, ARRAY_SIZE(standard_io_desc));
 326 }
 327
 328 /*
 329  * Disable the memory bus request/grant signals on the SA1110 to
 330  * ensure that we don't receive spurious memory requests.  We set
 331  * the MBGNT signal false to ensure the SA1111 doesn't own the
 332  * SDRAM bus.
 333  */
 334 void __init sa1110_mb_disable(void)
 335 {
 336         unsigned long flags;
 337
 338         local_irq_save(flags);
 339
 340         PGSR &= ~GPIO_MBGNT;
 341         GPCR = GPIO_MBGNT;
 342         GPDR = (GPDR & ~GPIO_MBREQ) | GPIO_MBGNT;
 343
 344         GAFR &= ~(GPIO_MBGNT | GPIO_MBREQ);
 345
 346         local_irq_restore(flags);
 347 }
 348
 349 /*
 350  * If the system is going to use the SA-1111 DMA engines, set up
 351  * the memory bus request/grant pins.
 352  */
 353 void __init sa1110_mb_enable(void)
 354 {
 355         unsigned long flags;
 356
 357         local_irq_save(flags);
 358
 359         PGSR &= ~GPIO_MBGNT;
 360         GPCR = GPIO_MBGNT;
 361         GPDR = (GPDR & ~GPIO_MBREQ) | GPIO_MBGNT;
 362
 363         GAFR |= (GPIO_MBGNT | GPIO_MBREQ);
 364         TUCR |= TUCR_MR;
 365
 366         local_irq_restore(flags);
 367 }
 368