← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to arch/arm/mach-aaec2000/core.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno
  • Date: 2011-06-07 12:14:05 UTC
  • mfrom: (43.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20110607121405-i3h1rd7nrnd2b73h
Tags: 2.6.39-2
http://bugs.debian.org/627492
http://bugs.debian.org/596626
http://bugs.debian.org/628932
http://bugs.debian.org/628191
http://bugs.debian.org/627837
http://bugs.debian.org/622997
http://bugs.debian.org/622745
http://bugs.debian.org/619827
http://bugs.debian.org/629401
[ Ben Hutchings ]
* [x86] Enable BACKLIGHT_APPLE, replacing BACKLIGHT_MBP_NVIDIA
  (Closes: #627492)
* cgroups: Disable memory resource controller by default. Allow it
  to be enabled using kernel parameter 'cgroup_enable=memory'.
* rt2800usb: Enable support for more USB devices including
  Linksys WUSB600N (Closes: #596626) (this change was accidentally
  omitted from 2.6.39-1)
* [x86] Remove Celeron from list of processors supporting PAE. Most
  'Celeron M' models do not.
* Update debconf template translations:
  - Swedish (Martin Bagge) (Closes: #628932)
  - French (David Prévot) (Closes: #628191)
* aufs: Update for 2.6.39 (Closes: #627837)
* Add stable 2.6.39.1, including:
  - ext4: dont set PageUptodate in ext4_end_bio()
  - pata_cmd64x: fix boot crash on parisc (Closes: #622997, #622745)
  - ext3: Fix fs corruption when make_indexed_dir() fails
  - netfilter: nf_ct_sip: validate Content-Length in TCP SIP messages
  - sctp: fix race between sctp_bind_addr_free() and
    sctp_bind_addr_conflict()
  - sctp: fix memory leak of the ASCONF queue when free asoc
  - md/bitmap: fix saving of events_cleared and other state
  - cdc_acm: Fix oops when Droids MuIn LCD is connected
  - cx88: Fix conversion from BKL to fine-grained locks (Closes: #619827)
  - keys: Set cred->user_ns in key_replace_session_keyring (CVE-2011-2184)
  - tmpfs: fix race between truncate and writepage
  - nfs41: Correct offset for LAYOUTCOMMIT
  - xen/mmu: fix a race window causing leave_mm BUG()
  - ext4: fix possible use-after-free in ext4_remove_li_request()
  For the complete list of changes, see:
   http://www.kernel.org/pub/linux/kernel/v2.6/ChangeLog-2.6.39.1
* Bump ABI to 2
* netfilter: Enable IP_SET, IP_SET_BITMAP_IP, IP_SET_BITMAP_IPMAC,
  IP_SET_BITMAP_PORT, IP_SET_HASH_IP, IP_SET_HASH_IPPORT,
  IP_SET_HASH_IPPORTIP, IP_SET_HASH_IPPORTNET, IP_SET_HASH_NET,
  IP_SET_HASH_NETPORT, IP_SET_LIST_SET, NETFILTER_XT_SET as modules
  (Closes: #629401)

[ Aurelien Jarno ]
* [mipsel/loongson-2f] Disable_SCSI_LPFC to workaround GCC ICE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/arm/mach-aaec2000/core.c
1
 
/*
2
 
 *  linux/arch/arm/mach-aaec2000/core.c
3
 
 *
4
 
 *  Code common to all AAEC-2000 machines
5
 
 *
6
 
 *  Copyright (c) 2005 Nicolas Bellido Y Ortega
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/module.h>
13
 
#include <linux/kernel.h>
14
 
#include <linux/init.h>
15
 
#include <linux/platform_device.h>
16
 
#include <linux/list.h>
17
 
#include <linux/errno.h>
18
 
#include <linux/dma-mapping.h>
19
 
#include <linux/interrupt.h>
20
 
#include <linux/timex.h>
21
 
#include <linux/signal.h>
22
 
#include <linux/clk.h>
23
 
#include <linux/gfp.h>
24
 
 
25
 
#include <mach/hardware.h>
26
 
#include <asm/irq.h>
27
 
#include <asm/sizes.h>
28
 
 
29
 
#include <asm/mach/flash.h>
30
 
#include <asm/mach/irq.h>
31
 
#include <asm/mach/time.h>
32
 
#include <asm/mach/map.h>
33
 
 
34
 
#include "core.h"
35
 
 
36
 
/*
37
 
 * Common I/O mapping:
38
 
 *
39
 
 * Static virtual address mappings are as follow:
40
 
 *
41
 
 * 0xf8000000-0xf8001ffff: Devices connected to APB bus
42
 
 * 0xf8002000-0xf8003ffff: Devices connected to AHB bus
43
 
 *
44
 
 * Below 0xe8000000 is reserved for vm allocation.
45
 
 *
46
 
 * The machine specific code must provide the extra mapping beside the
47
 
 * default mapping provided here.
48
 
 */
49
 
static struct map_desc standard_io_desc[] __initdata = {
50
 
        {
51
 
                .virtual        = VIO_APB_BASE,
52
 
                .pfn            = __phys_to_pfn(PIO_APB_BASE),
53
 
                .length         = IO_APB_LENGTH,
54
 
                .type           = MT_DEVICE
55
 
        }, {
56
 
                .virtual        = VIO_AHB_BASE,
57
 
                .pfn            = __phys_to_pfn(PIO_AHB_BASE),
58
 
                .length         = IO_AHB_LENGTH,
59
 
                .type           = MT_DEVICE
60
 
        }
61
 
};
62
 
 
63
 
void __init aaec2000_map_io(void)
64
 
{
65
 
        iotable_init(standard_io_desc, ARRAY_SIZE(standard_io_desc));
66
 
}
67
 
 
68
 
/*
69
 
 * Interrupt handling routines
70
 
 */
71
 
static void aaec2000_int_ack(struct irq_data *d)
72
 
{
73
 
        IRQ_INTSR = 1 << d->irq;
74
 
}
75
 
 
76
 
static void aaec2000_int_mask(struct irq_data *d)
77
 
{
78
 
        IRQ_INTENC |= (1 << d->irq);
79
 
}
80
 
 
81
 
static void aaec2000_int_unmask(struct irq_data *d)
82
 
{
83
 
        IRQ_INTENS |= (1 << d->irq);
84
 
}
85
 
 
86
 
static struct irq_chip aaec2000_irq_chip = {
87
 
        .irq_ack        = aaec2000_int_ack,
88
 
        .irq_mask       = aaec2000_int_mask,
89
 
        .irq_unmask     = aaec2000_int_unmask,
90
 
};
91
 
 
92
 
void __init aaec2000_init_irq(void)
93
 
{
94
 
        unsigned int i;
95
 
 
96
 
        for (i = 0; i < NR_IRQS; i++) {
97
 
                set_irq_handler(i, handle_level_irq);
98
 
                set_irq_chip(i, &aaec2000_irq_chip);
99
 
                set_irq_flags(i, IRQF_VALID);
100
 
        }
101
 
 
102
 
        /* Disable all interrupts */
103
 
        IRQ_INTENC = 0xffffffff;
104
 
 
105
 
        /* Clear any pending interrupts */
106
 
        IRQ_INTSR = IRQ_INTSR;
107
 
}
108
 
 
109
 
/*
110
 
 * Time keeping
111
 
 */
112
 
/* IRQs are disabled before entering here from do_gettimeofday() */
113
 
static unsigned long aaec2000_gettimeoffset(void)
114
 
{
115
 
        unsigned long ticks_to_match, elapsed, usec;
116
 
 
117
 
        /* Get ticks before next timer match */
118
 
        ticks_to_match = TIMER1_LOAD - TIMER1_VAL;
119
 
 
120
 
        /* We need elapsed ticks since last match */
121
 
        elapsed = LATCH - ticks_to_match;
122
 
 
123
 
        /* Now, convert them to usec */
124
 
        usec = (unsigned long)(elapsed * (tick_nsec / 1000))/LATCH;
125
 
 
126
 
        return usec;
127
 
}
128
 
 
129
 
/* We enter here with IRQs enabled */
130
 
static irqreturn_t
131
 
aaec2000_timer_interrupt(int irq, void *dev_id)
132
 
{
133
 
        /* TODO: Check timer accuracy */
134
 
        timer_tick();
135
 
        TIMER1_CLEAR = 1;
136
 
 
137
 
        return IRQ_HANDLED;
138
 
}
139
 
 
140
 
static struct irqaction aaec2000_timer_irq = {
141
 
        .name           = "AAEC-2000 Timer Tick",
142
 
        .flags          = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,
143
 
        .handler        = aaec2000_timer_interrupt,
144
 
};
145
 
 
146
 
static void __init aaec2000_timer_init(void)
147
 
{
148
 
        /* Disable timer 1 */
149
 
        TIMER1_CTRL = 0;
150
 
 
151
 
        /* We have somehow to generate a 100Hz clock.
152
 
         * We then use the 508KHz timer in periodic mode.
153
 
         */
154
 
        TIMER1_LOAD = LATCH;
155
 
        TIMER1_CLEAR = 1; /* Clear interrupt */
156
 
 
157
 
        setup_irq(INT_TMR1_OFL, &aaec2000_timer_irq);
158
 
 
159
 
        TIMER1_CTRL = TIMER_CTRL_ENABLE |
160
 
                        TIMER_CTRL_PERIODIC |
161
 
                        TIMER_CTRL_CLKSEL_508K;
162
 
}
163
 
 
164
 
struct sys_timer aaec2000_timer = {
165
 
        .init           = aaec2000_timer_init,
166
 
        .offset         = aaec2000_gettimeoffset,
167
 
};
168
 
 
169
 
static struct clcd_panel mach_clcd_panel;
170
 
 
171
 
static int aaec2000_clcd_setup(struct clcd_fb *fb)
172
 
{
173
 
        dma_addr_t dma;
174
 
 
175
 
        fb->panel = &mach_clcd_panel;
176
 
 
177
 
        fb->fb.screen_base = dma_alloc_writecombine(&fb->dev->dev, SZ_1M,
178
 
                        &dma, GFP_KERNEL);
179
 
 
180
 
        if (!fb->fb.screen_base) {
181
 
                printk(KERN_ERR "CLCD: unable to map framebuffer\n");
182
 
                return -ENOMEM;
183
 
        }
184
 
 
185
 
        fb->fb.fix.smem_start = dma;
186
 
        fb->fb.fix.smem_len = SZ_1M;
187
 
 
188
 
        return 0;
189
 
}
190
 
 
191
 
static int aaec2000_clcd_mmap(struct clcd_fb *fb, struct vm_area_struct *vma)
192
 
{
193
 
        return dma_mmap_writecombine(&fb->dev->dev, vma,
194
 
                        fb->fb.screen_base,
195
 
                        fb->fb.fix.smem_start,
196
 
                        fb->fb.fix.smem_len);
197
 
}
198
 
 
199
 
static void aaec2000_clcd_remove(struct clcd_fb *fb)
200
 
{
201
 
        dma_free_writecombine(&fb->dev->dev, fb->fb.fix.smem_len,
202
 
                        fb->fb.screen_base, fb->fb.fix.smem_start);
203
 
}
204
 
 
205
 
static struct clcd_board clcd_plat_data = {
206
 
        .name   = "AAEC-2000",
207
 
        .check  = clcdfb_check,
208
 
        .decode = clcdfb_decode,
209
 
        .setup  = aaec2000_clcd_setup,
210
 
        .mmap   = aaec2000_clcd_mmap,
211
 
        .remove = aaec2000_clcd_remove,
212
 
};
213
 
 
214
 
static struct amba_device clcd_device = {
215
 
        .dev            = {
216
 
                .init_name              = "mb:16",
217
 
                .coherent_dma_mask      = ~0,
218
 
                .platform_data          = &clcd_plat_data,
219
 
        },
220
 
        .res            = {
221
 
                .start                  = AAEC_CLCD_PHYS,
222
 
                .end                    = AAEC_CLCD_PHYS + SZ_4K - 1,
223
 
                .flags                  = IORESOURCE_MEM,
224
 
        },
225
 
        .irq            = { INT_LCD, NO_IRQ },
226
 
        .periphid       = 0x41110,
227
 
};
228
 
 
229
 
static struct amba_device *amba_devs[] __initdata = {
230
 
        &clcd_device,
231
 
};
232
 
 
233
 
void clk_disable(struct clk *clk)
234
 
{
235
 
}
236
 
 
237
 
int clk_set_rate(struct clk *clk, unsigned long rate)
238
 
{
239
 
        return 0;
240
 
}
241
 
 
242
 
int clk_enable(struct clk *clk)
243
 
{
244
 
        return 0;
245
 
}
246
 
 
247
 
struct clk *clk_get(struct device *dev, const char *id)
248
 
{
249
 
        return dev && strcmp(dev_name(dev), "mb:16") == 0 ? NULL : ERR_PTR(-ENOENT);
250
 
}
251
 
 
252
 
void clk_put(struct clk *clk)
253
 
{
254
 
}
255
 
 
256
 
void __init aaec2000_set_clcd_plat_data(struct aaec2000_clcd_info *clcd)
257
 
{
258
 
        clcd_plat_data.enable = clcd->enable;
259
 
        clcd_plat_data.disable = clcd->disable;
260
 
        memcpy(&mach_clcd_panel, &clcd->panel, sizeof(struct clcd_panel));
261
 
}
262
 
 
263
 
static struct flash_platform_data aaec2000_flash_data = {
264
 
        .map_name       = "cfi_probe",
265
 
        .width          = 4,
266
 
};
267
 
 
268
 
static struct resource aaec2000_flash_resource = {
269
 
        .start          = AAEC_FLASH_BASE,
270
 
        .end            = AAEC_FLASH_BASE + AAEC_FLASH_SIZE,
271
 
        .flags          = IORESOURCE_MEM,
272
 
};
273
 
 
274
 
static struct platform_device aaec2000_flash_device = {
275
 
        .name           = "armflash",
276
 
        .id             = 0,
277
 
        .dev            = {
278
 
                .platform_data  = &aaec2000_flash_data,
279
 
        },
280
 
        .num_resources  = 1,
281
 
        .resource       = &aaec2000_flash_resource,
282
 
};
283
 
 
284
 
static int __init aaec2000_init(void)
285
 
{
286
 
        int i;
287
 
 
288
 
        for (i = 0; i < ARRAY_SIZE(amba_devs); i++) {
289
 
                struct amba_device *d = amba_devs[i];
290
 
                amba_device_register(d, &iomem_resource);
291
 
        }
292
 
 
293
 
        platform_device_register(&aaec2000_flash_device);
294
 
 
295
 
        return 0;
296
 
};
297
 
arch_initcall(aaec2000_init);
298