1 /* Copyright (C) 2007-2008 The Android Open Source Project
2 **
3 ** This software is licensed under the terms of the GNU General Public
4 ** License version 2, as published by the Free Software Foundation, and
5 ** may be copied, distributed, and modified under those terms.
6 **
7 ** This program is distributed in the hope that it will be useful,
8 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
9 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 ** GNU General Public License for more details.
11 */
12 #include "qemu_file.h"
13 #include "qemu-char.h"
14 #include "goldfish_device.h"
15 #include "goldfish_vmem.h"
16
17 enum {
18 TTY_PUT_CHAR = 0x00,
19 TTY_BYTES_READY = 0x04,
20 TTY_CMD = 0x08,
21
22 TTY_DATA_PTR = 0x10,
23 TTY_DATA_LEN = 0x14,
24
25 TTY_CMD_INT_DISABLE = 0,
26 TTY_CMD_INT_ENABLE = 1,
27 TTY_CMD_WRITE_BUFFER = 2,
28 TTY_CMD_READ_BUFFER = 3,
29 };
30
31 struct tty_state {
32 struct goldfish_device dev;
33 CharDriverState *cs;
34 uint32_t ptr;
35 uint32_t ptr_len;
36 uint32_t ready;
37 uint8_t data[128];
38 uint32_t data_count;
39 };
40
41 #define GOLDFISH_TTY_SAVE_VERSION 1
42
goldfish_tty_save(QEMUFile * f,void * opaque)43 static void goldfish_tty_save(QEMUFile* f, void* opaque)
44 {
45 struct tty_state* s = opaque;
46
47 qemu_put_be32( f, s->ptr );
48 qemu_put_be32( f, s->ptr_len );
49 qemu_put_byte( f, s->ready );
50 qemu_put_byte( f, s->data_count );
51 qemu_put_buffer( f, s->data, s->data_count );
52 }
53
goldfish_tty_load(QEMUFile * f,void * opaque,int version_id)54 static int goldfish_tty_load(QEMUFile* f, void* opaque, int version_id)
55 {
56 struct tty_state* s = opaque;
57
58 if (version_id != GOLDFISH_TTY_SAVE_VERSION)
59 return -1;
60
61 s->ptr = qemu_get_be32(f);
62 s->ptr_len = qemu_get_be32(f);
63 s->ready = qemu_get_byte(f);
64 s->data_count = qemu_get_byte(f);
65 qemu_get_buffer(f, s->data, s->data_count);
66
67 return 0;
68 }
69
goldfish_tty_read(void * opaque,target_phys_addr_t offset)70 static uint32_t goldfish_tty_read(void *opaque, target_phys_addr_t offset)
71 {
72 struct tty_state *s = (struct tty_state *)opaque;
73
74 //printf("goldfish_tty_read %x %x\n", offset, size);
75
76 switch (offset) {
77 case TTY_BYTES_READY:
78 return s->data_count;
79 default:
80 cpu_abort (cpu_single_env, "goldfish_tty_read: Bad offset %x\n", offset);
81 return 0;
82 }
83 }
84
goldfish_tty_write(void * opaque,target_phys_addr_t offset,uint32_t value)85 static void goldfish_tty_write(void *opaque, target_phys_addr_t offset, uint32_t value)
86 {
87 struct tty_state *s = (struct tty_state *)opaque;
88
89 //printf("goldfish_tty_read %x %x %x\n", offset, value, size);
90
91 switch(offset) {
92 case TTY_PUT_CHAR: {
93 uint8_t ch = value;
94 if(s->cs)
95 qemu_chr_write(s->cs, &ch, 1);
96 } break;
97
98 case TTY_CMD:
99 switch(value) {
100 case TTY_CMD_INT_DISABLE:
101 if(s->ready) {
102 if(s->data_count > 0)
103 goldfish_device_set_irq(&s->dev, 0, 0);
104 s->ready = 0;
105 }
106 break;
107
108 case TTY_CMD_INT_ENABLE:
109 if(!s->ready) {
110 if(s->data_count > 0)
111 goldfish_device_set_irq(&s->dev, 0, 1);
112 s->ready = 1;
113 }
114 break;
115
116 case TTY_CMD_WRITE_BUFFER:
117 if(s->cs) {
118 int len;
119 target_phys_addr_t buf;
120
121 buf = s->ptr;
122 len = s->ptr_len;
123
124 while (len) {
125 char temp[64];
126 int to_write = sizeof(temp);
127 if (to_write > len)
128 to_write = len;
129
130 safe_memory_rw_debug(cpu_single_env, buf, (uint8_t*)temp, to_write, 0);
131 qemu_chr_write(s->cs, (const uint8_t*)temp, to_write);
132 buf += to_write;
133 len -= to_write;
134 }
135 //printf("goldfish_tty_write: got %d bytes from %x\n", s->ptr_len, s->ptr);
136 }
137 break;
138
139 case TTY_CMD_READ_BUFFER:
140 if(s->ptr_len > s->data_count)
141 cpu_abort (cpu_single_env, "goldfish_tty_write: reading more data than available %d %d\n", s->ptr_len, s->data_count);
142 safe_memory_rw_debug(cpu_single_env,s->ptr, s->data, s->ptr_len,1);
143 //printf("goldfish_tty_write: read %d bytes to %x\n", s->ptr_len, s->ptr);
144 if(s->data_count > s->ptr_len)
145 memmove(s->data, s->data + s->ptr_len, s->data_count - s->ptr_len);
146 s->data_count -= s->ptr_len;
147 if(s->data_count == 0 && s->ready)
148 goldfish_device_set_irq(&s->dev, 0, 0);
149 break;
150
151 default:
152 cpu_abort (cpu_single_env, "goldfish_tty_write: Bad command %x\n", value);
153 };
154 break;
155
156 case TTY_DATA_PTR:
157 s->ptr = value;
158 break;
159
160 case TTY_DATA_LEN:
161 s->ptr_len = value;
162 break;
163
164 default:
165 cpu_abort (cpu_single_env, "goldfish_tty_write: Bad offset %x\n", offset);
166 }
167 }
168
tty_can_receive(void * opaque)169 static int tty_can_receive(void *opaque)
170 {
171 struct tty_state *s = opaque;
172
173 return (sizeof(s->data) - s->data_count);
174 }
175
tty_receive(void * opaque,const uint8_t * buf,int size)176 static void tty_receive(void *opaque, const uint8_t *buf, int size)
177 {
178 struct tty_state *s = opaque;
179
180 memcpy(s->data + s->data_count, buf, size);
181 s->data_count += size;
182 if(s->data_count > 0 && s->ready)
183 goldfish_device_set_irq(&s->dev, 0, 1);
184 }
185
186 static CPUReadMemoryFunc *goldfish_tty_readfn[] = {
187 goldfish_tty_read,
188 goldfish_tty_read,
189 goldfish_tty_read
190 };
191
192 static CPUWriteMemoryFunc *goldfish_tty_writefn[] = {
193 goldfish_tty_write,
194 goldfish_tty_write,
195 goldfish_tty_write
196 };
197
goldfish_tty_add(CharDriverState * cs,int id,uint32_t base,int irq)198 int goldfish_tty_add(CharDriverState *cs, int id, uint32_t base, int irq)
199 {
200 int ret;
201 struct tty_state *s;
202 static int instance_id = 0;
203
204 s = qemu_mallocz(sizeof(*s));
205 s->dev.name = "goldfish_tty";
206 s->dev.id = id;
207 s->dev.base = base;
208 s->dev.size = 0x1000;
209 s->dev.irq = irq;
210 s->dev.irq_count = 1;
211 s->cs = cs;
212
213 if(cs) {
214 qemu_chr_add_handlers(cs, tty_can_receive, tty_receive, NULL, s);
215 }
216
217 ret = goldfish_device_add(&s->dev, goldfish_tty_readfn, goldfish_tty_writefn, s);
218 if(ret) {
219 qemu_free(s);
220 } else {
221 register_savevm( "goldfish_tty", instance_id++, GOLDFISH_TTY_SAVE_VERSION,
222 goldfish_tty_save, goldfish_tty_load, s);
223 }
224 return ret;
225 }
226
227