← Back to branch summary

~ubuntu-branches/ubuntu/lucid/skyeye/lucid-proposed

« back to all changes in this revision

Viewing changes to arch/bfin/common/iomem.c

  • Committer: Bazaar Package Importer
  • Author(s): Yu Guanghui
  • Date: 2007-02-09 20:24:29 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20070209202429-jknfb98t9ggaoz02
Tags: 1.2.1-2
Disable DBCT again.

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/bfin/common/iomem.c
8
8
//#define IO_ERR {printf("\n%s io error!addr=0x%x\n",__FUNCTION__,addr);exit(-1);}
9
9
 
10
10
#define IO_ERR {printf("\n%s io error!addr=0x%x,pc=0x%x,oldpc=0x%x,sp=0x%x\n",__FUNCTION__,addr,PCREG,OLDPCREG,SPREG);}
11
 
//0xf11c4
12
11
 
13
12
static void
14
13
isram_write_word (bu32 addr, bu16 v)
49
48
{
50
49
 
51
50
        int offset = addr - SSRAM_START;
52
 
        printf("ssram_write_long addr %p\n",addr);
 
51
        //printf("ssram_write_long addr %p\n",addr);
53
52
        //saved_state.ssram[offset] = (bu16)v;
54
53
        saved_state.ssram[offset] = v;
55
54
        saved_state.ssram[offset + 1] = v >> 8;
62
61
ssram_read_long (bu32 addr)
63
62
{
64
63
        int offset = addr - SSRAM_START;
65
 
               printf("ssram_read_long addr %p\n",addr);
 
64
        //printf("ssram_read_long addr %p\n",addr);
66
65
        //return (bu16)(saved_state.ssram[offset]);
67
66
        return (saved_state.ssram[offset] | 
68
67
               (saved_state.ssram[offset + 1] << 8) |
74
73
ssram_write_word (bu32 addr, bu16 v)
75
74
{
76
75
        int offset = addr - SSRAM_START;
77
 
        printf("ssram_write_word addr %p\n",addr);
 
76
        //printf("ssram_write_word addr %p\n",addr);
78
77
        //saved_state.ssram[offset] = (bu16)v;
79
78
        saved_state.ssram[offset] = v;
80
79
        saved_state.ssram[offset + 1] = v >> 8;
85
84
ssram_read_word (bu32 addr)
86
85
{
87
86
        int offset = addr - SSRAM_START;
88
 
        printf("ssram_read_word addr %p\n",addr);
 
87
        //printf("ssram_read_word addr %p\n",addr);
89
88
        //return (bu16)(saved_state.ssram[offset]);
90
89
        return saved_state.ssram[offset] | (saved_state.
91
90
                                            ssram[offset + 1] << 8);
95
94
ssram_write_byte (bu32 addr, bu8 v)
96
95
{
97
96
        int offset = addr - SSRAM_START;
98
 
        printf("ssram_read_byte addr %p\n",addr);
 
97
        //printf("ssram_read_byte addr %p\n",addr);
99
98
        saved_state.ssram[offset] = v;
100
99
}
101
100
 
103
102
ssram_read_byte (bu32 addr)
104
103
{
105
104
        int offset = addr - SSRAM_START;
106
 
        printf("ssram_write_byte addr %p\n",addr);
 
105
        //printf("ssram_read_byte addr %p\n",addr);
107
106
        return saved_state.ssram[offset];
108
107
}
109
108
 
125
124
void
126
125
put_byte (unsigned char *memory, bu32 addr, bu8 v)
127
126
{
 
127
        if(addr == 0xc0900){    
 
128
                fprintf(PF,"KSDBG:addr=0xc0900,PC=0x%x\n",PCREG);
 
129
        }
128
130
        if ((addr >= IO_START) && (addr < IO_END)) {
129
131
                saved_state.p_mach->io_write_byte (addr, v);
130
132
 
141
143
        else if (addr >= SDRAM_START && addr < SDRAM_END) {
142
144
                memory[addr] = v;
143
145
        }
 
146
        else if (addr >= BANK0_START && addr < BANK3_END) {
 
147
        }
144
148
        else {
145
149
                IO_ERR;
 
150
                exit(-1);
146
151
        }
147
152
 
148
153
}
150
155
void
151
156
put_word (unsigned char *memory, bu32 addr, bu16 v)
152
157
{
 
158
        if(addr == 0xc0900){    
 
159
                fprintf(PF,"KSDBG:addr=0xc0900,PC=0x%x\n",PCREG);
 
160
        }
153
161
        if ((addr >= IO_START) && (addr < IO_END)) {
154
162
                saved_state.p_mach->io_write_word (addr, v);
155
163
        }
164
172
                //memory[addr] = (bu16)v;
165
173
                    memory[addr] = v;
166
174
                        memory[addr + 1] = v >> 8;
167
 
 
168
175
        }
169
176
        else {
170
177
                IO_ERR;
175
182
void
176
183
put_long (unsigned char *memory, bu32 addr, bu32 v)
177
184
{
 
185
        if(addr == 0xc0900){    
 
186
                fprintf(PF,"KSDBG:addr=0xc0900,v=0x%x,PC=0x%x\n", v, PCREG);
 
187
        }
178
188
        if ((addr > IO_START) && (addr < IO_END)) {
179
 
 
180
189
                saved_state.p_mach->io_write_long (addr, v);
181
190
        } // PSW 061606
182
191
        else if (addr >= SSRAM_START && addr < SSRAM_END) {
184
193
        }
185
194
        else if (addr >= SDRAM_START && addr < SDRAM_END) {
186
195
                //memory[addr] = (bu32)v;
187
 
                 memory[addr] = v;
 
196
                memory[addr] = v;
188
197
                memory[addr + 1] = v >> 8;
189
198
                memory[addr + 2] = v >> 16;
190
199
                memory[addr + 3] = v >> 24;