← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to hw/ds1225y.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-07 06:20:34 UTC
  • mfrom: (1.1.9 upstream)
  • mto: This revision was merged to the branch mainline in revision 7.
  • Revision ID: james.westby@ubuntu.com-20090307062034-i3pead4mw653v2el
Tags: 0.10.0-1
http://bugs.debian.org/514462
http://bugs.debian.org/470231
http://bugs.debian.org/415996
http://bugs.debian.org/513210
http://bugs.debian.org/297572
[ Aurelien Jarno ]
* New upstream release:
  - Fix fr-be keyboard mapping (closes: bug#514462).
  - Fix stat64 structure on ppc-linux-user (closes: bug#470231).
  - Add a chroot option (closes: bug#415996).
  - Add evdev support (closes: bug#513210).
  - Fix loop on symlinks in user mode (closes: bug#297572).
  - Bump depends on openbios-sparc.
  - Depends on openbios-ppc.
  - Update 12_signal_powerpc_support.patch.
  - Update 21_net_soopts.patch.
  - Drop 44_socklen_t_check.patch (merged upstream).
  - Drop 49_null_check.patch (merged upstream).
  - Update 64_ppc_asm_constraints.patch.
  - Drop security/CVE-2008-0928-fedora.patch (merged upstream).
  - Drop security/CVE-2007-5730.patch (merged upstream).
* patches/80_stable-branch.patch: add patches from stable branch:
  - Fix race condition between signal handler/execution loop (closes:
    bug#474386, bug#501731).
* debian/copyright: update.
* Compile and install .dtb files:
  - debian/control: build-depends on device-tree-compiler.
  - debian/patches/81_compile_dtb.patch: new patch from upstream.
  - debian/rules: compile and install bamboo.dtb and mpc8544.dtb.

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/ds1225y.c
1
 
/*
2
 
 * QEMU NVRAM emulation for DS1225Y chip
3
 
 * 
4
 
 * Copyright (c) 2007 Herv� Poussineau
5
 
 * 
6
 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 
 * of this software and associated documentation files (the "Software"), to deal
8
 
 * in the Software without restriction, including without limitation the rights
9
 
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 
 * copies of the Software, and to permit persons to whom the Software is
11
 
 * furnished to do so, subject to the following conditions:
12
 
 *
13
 
 * The above copyright notice and this permission notice shall be included in
14
 
 * all copies or substantial portions of the Software.
15
 
 *
16
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 
 * THE SOFTWARE.
23
 
 */
24
 
 
25
 
#include "hw.h"
26
 
#include "mips.h"
27
 
#include "nvram.h"
28
 
 
29
 
typedef enum
30
 
{
31
 
    none = 0,
32
 
    readmode,
33
 
    writemode,
34
 
} nvram_open_mode;
35
 
 
36
 
struct ds1225y_t
37
 
{
38
 
    target_phys_addr_t mem_base;
39
 
    uint32_t capacity;
40
 
    const char *filename;
41
 
    QEMUFile *file;
42
 
    nvram_open_mode open_mode;
43
 
};
44
 
 
45
 
static int ds1225y_set_to_mode(ds1225y_t *NVRAM, nvram_open_mode mode, const char *filemode)
46
 
{
47
 
    if (NVRAM->open_mode != mode)
48
 
    {
49
 
        if (NVRAM->file)
50
 
            qemu_fclose(NVRAM->file);
51
 
        NVRAM->file = qemu_fopen(NVRAM->filename, filemode);
52
 
        NVRAM->open_mode = mode;
53
 
    }
54
 
    return (NVRAM->file != NULL);
55
 
}
56
 
 
57
 
static uint32_t nvram_readb (void *opaque, target_phys_addr_t addr)
58
 
{
59
 
    ds1225y_t *NVRAM = opaque;
60
 
    int64_t pos;
61
 
 
62
 
    pos = addr - NVRAM->mem_base;
63
 
    if (addr >= NVRAM->capacity)
64
 
        addr -= NVRAM->capacity;
65
 
 
66
 
    if (!ds1225y_set_to_mode(NVRAM, readmode, "rb"))
67
 
        return 0;
68
 
    qemu_fseek(NVRAM->file, pos, SEEK_SET);
69
 
    return (uint32_t)qemu_get_byte(NVRAM->file);
70
 
}
71
 
 
72
 
static void nvram_writeb (void *opaque, target_phys_addr_t addr, uint32_t value)
73
 
{
74
 
    ds1225y_t *NVRAM = opaque;
75
 
    int64_t pos;
76
 
 
77
 
    pos = addr - NVRAM->mem_base;
78
 
    if (ds1225y_set_to_mode(NVRAM, writemode, "wb"))
79
 
    {
80
 
        qemu_fseek(NVRAM->file, pos, SEEK_SET);
81
 
        qemu_put_byte(NVRAM->file, (int)value);
82
 
    }
83
 
}
84
 
 
85
 
static CPUReadMemoryFunc *nvram_read[] = {
86
 
    &nvram_readb,
87
 
    NULL,
88
 
    NULL,
89
 
};
90
 
 
91
 
static CPUWriteMemoryFunc *nvram_write[] = {
92
 
    &nvram_writeb,
93
 
    NULL,
94
 
    NULL,
95
 
};
96
 
 
97
 
static CPUWriteMemoryFunc *nvram_none[] = {
98
 
    NULL,
99
 
    NULL,
100
 
    NULL,
101
 
};
102
 
 
103
 
/* Initialisation routine */
104
 
ds1225y_t *ds1225y_init(target_phys_addr_t mem_base, const char *filename)
105
 
{
106
 
    ds1225y_t *s;
107
 
    int mem_index1, mem_index2;
108
 
 
109
 
    s = qemu_mallocz(sizeof(ds1225y_t));
110
 
    if (!s)
111
 
        return NULL;
112
 
    s->mem_base = mem_base;
113
 
    s->capacity = 0x2000; /* Fixed for ds1225y chip: 8K */
114
 
    s->filename = filename;
115
 
 
116
 
    /* Read/write memory */
117
 
    mem_index1 = cpu_register_io_memory(0, nvram_read, nvram_write, s);
118
 
    cpu_register_physical_memory(mem_base, s->capacity, mem_index1);
119
 
    /* Read-only memory */
120
 
    mem_index2 = cpu_register_io_memory(0, nvram_read, nvram_none, s);
121
 
    cpu_register_physical_memory(mem_base + s->capacity, s->capacity, mem_index2);
122
 
    return s;
123
 
}
 
1
/*
 
2
 * QEMU NVRAM emulation for DS1225Y chip
 
3
 *
 
4
 * Copyright (c) 2007-2008 Herv� Poussineau
 
5
 *
 
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 
7
 * of this software and associated documentation files (the "Software"), to deal
 
8
 * in the Software without restriction, including without limitation the rights
 
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
10
 * copies of the Software, and to permit persons to whom the Software is
 
11
 * furnished to do so, subject to the following conditions:
 
12
 *
 
13
 * The above copyright notice and this permission notice shall be included in
 
14
 * all copies or substantial portions of the Software.
 
15
 *
 
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
22
 * THE SOFTWARE.
 
23
 */
 
24
 
 
25
#include "hw.h"
 
26
#include "mips.h"
 
27
#include "nvram.h"
 
28
 
 
29
//#define DEBUG_NVRAM
 
30
 
 
31
typedef struct ds1225y_t
 
32
{
 
33
    uint32_t chip_size;
 
34
    QEMUFile *file;
 
35
    uint8_t *contents;
 
36
    uint8_t protection;
 
37
} ds1225y_t;
 
38
 
 
39
 
 
40
static uint32_t nvram_readb (void *opaque, target_phys_addr_t addr)
 
41
{
 
42
    ds1225y_t *s = opaque;
 
43
    uint32_t val;
 
44
 
 
45
    val = s->contents[addr];
 
46
 
 
47
#ifdef DEBUG_NVRAM
 
48
    printf("nvram: read 0x%x at " TARGET_FMT_lx "\n", val, addr);
 
49
#endif
 
50
    return val;
 
51
}
 
52
 
 
53
static uint32_t nvram_readw (void *opaque, target_phys_addr_t addr)
 
54
{
 
55
    uint32_t v;
 
56
    v = nvram_readb(opaque, addr);
 
57
    v |= nvram_readb(opaque, addr + 1) << 8;
 
58
    return v;
 
59
}
 
60
 
 
61
static uint32_t nvram_readl (void *opaque, target_phys_addr_t addr)
 
62
{
 
63
    uint32_t v;
 
64
    v = nvram_readb(opaque, addr);
 
65
    v |= nvram_readb(opaque, addr + 1) << 8;
 
66
    v |= nvram_readb(opaque, addr + 2) << 16;
 
67
    v |= nvram_readb(opaque, addr + 3) << 24;
 
68
    return v;
 
69
}
 
70
 
 
71
static void nvram_writeb (void *opaque, target_phys_addr_t addr, uint32_t val)
 
72
{
 
73
    ds1225y_t *s = opaque;
 
74
 
 
75
#ifdef DEBUG_NVRAM
 
76
    printf("nvram: write 0x%x at " TARGET_FMT_lx "\n", val, addr);
 
77
#endif
 
78
 
 
79
    s->contents[addr] = val & 0xff;
 
80
    if (s->file) {
 
81
        qemu_fseek(s->file, addr, SEEK_SET);
 
82
        qemu_put_byte(s->file, (int)val);
 
83
        qemu_fflush(s->file);
 
84
    }
 
85
}
 
86
 
 
87
static void nvram_writew (void *opaque, target_phys_addr_t addr, uint32_t val)
 
88
{
 
89
    nvram_writeb(opaque, addr, val & 0xff);
 
90
    nvram_writeb(opaque, addr + 1, (val >> 8) & 0xff);
 
91
}
 
92
 
 
93
static void nvram_writel (void *opaque, target_phys_addr_t addr, uint32_t val)
 
94
{
 
95
    nvram_writeb(opaque, addr, val & 0xff);
 
96
    nvram_writeb(opaque, addr + 1, (val >> 8) & 0xff);
 
97
    nvram_writeb(opaque, addr + 2, (val >> 16) & 0xff);
 
98
    nvram_writeb(opaque, addr + 3, (val >> 24) & 0xff);
 
99
}
 
100
 
 
101
static void nvram_writeb_protected (void *opaque, target_phys_addr_t addr, uint32_t val)
 
102
{
 
103
    ds1225y_t *s = opaque;
 
104
 
 
105
    if (s->protection != 7) {
 
106
#ifdef DEBUG_NVRAM
 
107
    printf("nvram: prevent write of 0x%x at " TARGET_FMT_lx "\n", val, addr);
 
108
#endif
 
109
        return;
 
110
    }
 
111
 
 
112
    nvram_writeb(opaque, addr, val);
 
113
}
 
114
 
 
115
static void nvram_writew_protected (void *opaque, target_phys_addr_t addr, uint32_t val)
 
116
{
 
117
    nvram_writeb_protected(opaque, addr, val & 0xff);
 
118
    nvram_writeb_protected(opaque, addr + 1, (val >> 8) & 0xff);
 
119
}
 
120
 
 
121
static void nvram_writel_protected (void *opaque, target_phys_addr_t addr, uint32_t val)
 
122
{
 
123
    nvram_writeb_protected(opaque, addr, val & 0xff);
 
124
    nvram_writeb_protected(opaque, addr + 1, (val >> 8) & 0xff);
 
125
    nvram_writeb_protected(opaque, addr + 2, (val >> 16) & 0xff);
 
126
    nvram_writeb_protected(opaque, addr + 3, (val >> 24) & 0xff);
 
127
}
 
128
 
 
129
static CPUReadMemoryFunc *nvram_read[] = {
 
130
    &nvram_readb,
 
131
    &nvram_readw,
 
132
    &nvram_readl,
 
133
};
 
134
 
 
135
static CPUWriteMemoryFunc *nvram_write[] = {
 
136
    &nvram_writeb,
 
137
    &nvram_writew,
 
138
    &nvram_writel,
 
139
};
 
140
 
 
141
static CPUWriteMemoryFunc *nvram_write_protected[] = {
 
142
    &nvram_writeb_protected,
 
143
    &nvram_writew_protected,
 
144
    &nvram_writel_protected,
 
145
};
 
146
 
 
147
/* Initialisation routine */
 
148
void *ds1225y_init(target_phys_addr_t mem_base, const char *filename)
 
149
{
 
150
    ds1225y_t *s;
 
151
    int mem_indexRW, mem_indexRP;
 
152
    QEMUFile *file;
 
153
 
 
154
    s = qemu_mallocz(sizeof(ds1225y_t));
 
155
    s->chip_size = 0x2000; /* Fixed for ds1225y chip: 8 KiB */
 
156
    s->contents = qemu_mallocz(s->chip_size);
 
157
    s->protection = 7;
 
158
 
 
159
    /* Read current file */
 
160
    file = qemu_fopen(filename, "rb");
 
161
    if (file) {
 
162
        /* Read nvram contents */
 
163
        qemu_get_buffer(file, s->contents, s->chip_size);
 
164
        qemu_fclose(file);
 
165
    }
 
166
    s->file = qemu_fopen(filename, "wb");
 
167
    if (s->file) {
 
168
        /* Write back contents, as 'wb' mode cleaned the file */
 
169
        qemu_put_buffer(s->file, s->contents, s->chip_size);
 
170
        qemu_fflush(s->file);
 
171
    }
 
172
 
 
173
    /* Read/write memory */
 
174
    mem_indexRW = cpu_register_io_memory(0, nvram_read, nvram_write, s);
 
175
    cpu_register_physical_memory(mem_base, s->chip_size, mem_indexRW);
 
176
    /* Read/write protected memory */
 
177
    mem_indexRP = cpu_register_io_memory(0, nvram_read, nvram_write_protected, s);
 
178
    cpu_register_physical_memory(mem_base + s->chip_size, s->chip_size, mem_indexRP);
 
179
    return s;
 
180
}