← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to hw/sb16.c

  • Committer: ths
  • Date: 2007-10-08 12:45:38 UTC
  • Revision ID: git-v1:450d4ff553af32fc9d83fef20d7106b0151526b8
CRIS disassembler, originally from binutils, by Edgar E. Iglesias.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3356 c046a42c-6fe2-441c-8c8c-71466251a162

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/sb16.c
21
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
22
 * THE SOFTWARE.
23
23
 */
24
 
#include "hw.h"
25
 
#include "audiodev.h"
26
 
#include "audio/audio.h"
27
 
#include "isa.h"
28
 
#include "qemu-timer.h"
 
24
#include "vl.h"
29
25
 
30
26
#define LENOFA(a) ((int) (sizeof(a)/sizeof(a[0])))
31
27
 
1193
1189
    SB16State *s = opaque;
1194
1190
    int till, copy, written, free;
1195
1191
 
1196
 
    if (s->block_size <= 0) {
1197
 
        dolog ("invalid block size=%d nchan=%d dma_pos=%d dma_len=%d\n",
1198
 
               s->block_size, nchan, dma_pos, dma_len);
1199
 
        return dma_pos;
1200
 
    }
1201
 
 
1202
1192
    if (s->left_till_irq < 0) {
1203
1193
        s->left_till_irq = s->block_size;
1204
1194
    }
1263
1253
{
1264
1254
    SB16State *s = opaque;
1265
1255
 
1266
 
    qemu_put_be32 (f, s->irq);
1267
 
    qemu_put_be32 (f, s->dma);
1268
 
    qemu_put_be32 (f, s->hdma);
1269
 
    qemu_put_be32 (f, s->port);
1270
 
    qemu_put_be32 (f, s->ver);
1271
 
    qemu_put_be32 (f, s->in_index);
1272
 
    qemu_put_be32 (f, s->out_data_len);
1273
 
    qemu_put_be32 (f, s->fmt_stereo);
1274
 
    qemu_put_be32 (f, s->fmt_signed);
1275
 
    qemu_put_be32 (f, s->fmt_bits);
 
1256
    qemu_put_be32s (f, &s->irq);
 
1257
    qemu_put_be32s (f, &s->dma);
 
1258
    qemu_put_be32s (f, &s->hdma);
 
1259
    qemu_put_be32s (f, &s->port);
 
1260
    qemu_put_be32s (f, &s->ver);
 
1261
    qemu_put_be32s (f, &s->in_index);
 
1262
    qemu_put_be32s (f, &s->out_data_len);
 
1263
    qemu_put_be32s (f, &s->fmt_stereo);
 
1264
    qemu_put_be32s (f, &s->fmt_signed);
 
1265
    qemu_put_be32s (f, &s->fmt_bits);
1276
1266
    qemu_put_be32s (f, &s->fmt);
1277
 
    qemu_put_be32 (f, s->dma_auto);
1278
 
    qemu_put_be32 (f, s->block_size);
1279
 
    qemu_put_be32 (f, s->fifo);
1280
 
    qemu_put_be32 (f, s->freq);
1281
 
    qemu_put_be32 (f, s->time_const);
1282
 
    qemu_put_be32 (f, s->speaker);
1283
 
    qemu_put_be32 (f, s->needed_bytes);
1284
 
    qemu_put_be32 (f, s->cmd);
1285
 
    qemu_put_be32 (f, s->use_hdma);
1286
 
    qemu_put_be32 (f, s->highspeed);
1287
 
    qemu_put_be32 (f, s->can_write);
1288
 
    qemu_put_be32 (f, s->v2x6);
 
1267
    qemu_put_be32s (f, &s->dma_auto);
 
1268
    qemu_put_be32s (f, &s->block_size);
 
1269
    qemu_put_be32s (f, &s->fifo);
 
1270
    qemu_put_be32s (f, &s->freq);
 
1271
    qemu_put_be32s (f, &s->time_const);
 
1272
    qemu_put_be32s (f, &s->speaker);
 
1273
    qemu_put_be32s (f, &s->needed_bytes);
 
1274
    qemu_put_be32s (f, &s->cmd);
 
1275
    qemu_put_be32s (f, &s->use_hdma);
 
1276
    qemu_put_be32s (f, &s->highspeed);
 
1277
    qemu_put_be32s (f, &s->can_write);
 
1278
    qemu_put_be32s (f, &s->v2x6);
1289
1279
 
1290
1280
    qemu_put_8s (f, &s->csp_param);
1291
1281
    qemu_put_8s (f, &s->csp_value);
1294
1284
    qemu_put_buffer (f, s->csp_regs, 256);
1295
1285
    qemu_put_8s (f, &s->csp_index);
1296
1286
    qemu_put_buffer (f, s->csp_reg83, 4);
1297
 
    qemu_put_be32 (f, s->csp_reg83r);
1298
 
    qemu_put_be32 (f, s->csp_reg83w);
 
1287
    qemu_put_be32s (f, &s->csp_reg83r);
 
1288
    qemu_put_be32s (f, &s->csp_reg83w);
1299
1289
 
1300
1290
    qemu_put_buffer (f, s->in2_data, sizeof (s->in2_data));
1301
1291
    qemu_put_buffer (f, s->out_data, sizeof (s->out_data));
1302
1292
    qemu_put_8s (f, &s->test_reg);
1303
1293
    qemu_put_8s (f, &s->last_read_byte);
1304
1294
 
1305
 
    qemu_put_be32 (f, s->nzero);
1306
 
    qemu_put_be32 (f, s->left_till_irq);
1307
 
    qemu_put_be32 (f, s->dma_running);
1308
 
    qemu_put_be32 (f, s->bytes_per_second);
1309
 
    qemu_put_be32 (f, s->align);
 
1295
    qemu_put_be32s (f, &s->nzero);
 
1296
    qemu_put_be32s (f, &s->left_till_irq);
 
1297
    qemu_put_be32s (f, &s->dma_running);
 
1298
    qemu_put_be32s (f, &s->bytes_per_second);
 
1299
    qemu_put_be32s (f, &s->align);
1310
1300
 
1311
 
    qemu_put_be32 (f, s->mixer_nreg);
 
1301
    qemu_put_be32s (f, &s->mixer_nreg);
1312
1302
    qemu_put_buffer (f, s->mixer_regs, 256);
1313
1303
}
1314
1304
 
1320
1310
        return -EINVAL;
1321
1311
    }
1322
1312
 
1323
 
    s->irq=qemu_get_be32 (f);
1324
 
    s->dma=qemu_get_be32 (f);
1325
 
    s->hdma=qemu_get_be32 (f);
1326
 
    s->port=qemu_get_be32 (f);
1327
 
    s->ver=qemu_get_be32 (f);
1328
 
    s->in_index=qemu_get_be32 (f);
1329
 
    s->out_data_len=qemu_get_be32 (f);
1330
 
    s->fmt_stereo=qemu_get_be32 (f);
1331
 
    s->fmt_signed=qemu_get_be32 (f);
1332
 
    s->fmt_bits=qemu_get_be32 (f);
 
1313
    qemu_get_be32s (f, &s->irq);
 
1314
    qemu_get_be32s (f, &s->dma);
 
1315
    qemu_get_be32s (f, &s->hdma);
 
1316
    qemu_get_be32s (f, &s->port);
 
1317
    qemu_get_be32s (f, &s->ver);
 
1318
    qemu_get_be32s (f, &s->in_index);
 
1319
    qemu_get_be32s (f, &s->out_data_len);
 
1320
    qemu_get_be32s (f, &s->fmt_stereo);
 
1321
    qemu_get_be32s (f, &s->fmt_signed);
 
1322
    qemu_get_be32s (f, &s->fmt_bits);
1333
1323
    qemu_get_be32s (f, &s->fmt);
1334
 
    s->dma_auto=qemu_get_be32 (f);
1335
 
    s->block_size=qemu_get_be32 (f);
1336
 
    s->fifo=qemu_get_be32 (f);
1337
 
    s->freq=qemu_get_be32 (f);
1338
 
    s->time_const=qemu_get_be32 (f);
1339
 
    s->speaker=qemu_get_be32 (f);
1340
 
    s->needed_bytes=qemu_get_be32 (f);
1341
 
    s->cmd=qemu_get_be32 (f);
1342
 
    s->use_hdma=qemu_get_be32 (f);
1343
 
    s->highspeed=qemu_get_be32 (f);
1344
 
    s->can_write=qemu_get_be32 (f);
1345
 
    s->v2x6=qemu_get_be32 (f);
 
1324
    qemu_get_be32s (f, &s->dma_auto);
 
1325
    qemu_get_be32s (f, &s->block_size);
 
1326
    qemu_get_be32s (f, &s->fifo);
 
1327
    qemu_get_be32s (f, &s->freq);
 
1328
    qemu_get_be32s (f, &s->time_const);
 
1329
    qemu_get_be32s (f, &s->speaker);
 
1330
    qemu_get_be32s (f, &s->needed_bytes);
 
1331
    qemu_get_be32s (f, &s->cmd);
 
1332
    qemu_get_be32s (f, &s->use_hdma);
 
1333
    qemu_get_be32s (f, &s->highspeed);
 
1334
    qemu_get_be32s (f, &s->can_write);
 
1335
    qemu_get_be32s (f, &s->v2x6);
1346
1336
 
1347
1337
    qemu_get_8s (f, &s->csp_param);
1348
1338
    qemu_get_8s (f, &s->csp_value);
1351
1341
    qemu_get_buffer (f, s->csp_regs, 256);
1352
1342
    qemu_get_8s (f, &s->csp_index);
1353
1343
    qemu_get_buffer (f, s->csp_reg83, 4);
1354
 
    s->csp_reg83r=qemu_get_be32 (f);
1355
 
    s->csp_reg83w=qemu_get_be32 (f);
 
1344
    qemu_get_be32s (f, &s->csp_reg83r);
 
1345
    qemu_get_be32s (f, &s->csp_reg83w);
1356
1346
 
1357
1347
    qemu_get_buffer (f, s->in2_data, sizeof (s->in2_data));
1358
1348
    qemu_get_buffer (f, s->out_data, sizeof (s->out_data));
1359
1349
    qemu_get_8s (f, &s->test_reg);
1360
1350
    qemu_get_8s (f, &s->last_read_byte);
1361
1351
 
1362
 
    s->nzero=qemu_get_be32 (f);
1363
 
    s->left_till_irq=qemu_get_be32 (f);
1364
 
    s->dma_running=qemu_get_be32 (f);
1365
 
    s->bytes_per_second=qemu_get_be32 (f);
1366
 
    s->align=qemu_get_be32 (f);
 
1352
    qemu_get_be32s (f, &s->nzero);
 
1353
    qemu_get_be32s (f, &s->left_till_irq);
 
1354
    qemu_get_be32s (f, &s->dma_running);
 
1355
    qemu_get_be32s (f, &s->bytes_per_second);
 
1356
    qemu_get_be32s (f, &s->align);
1367
1357
 
1368
 
    s->mixer_nreg=qemu_get_be32 (f);
 
1358
    qemu_get_be32s (f, &s->mixer_nreg);
1369
1359
    qemu_get_buffer (f, s->mixer_regs, 256);
1370
1360
 
1371
1361
    if (s->voice) {