← Back to branch summary

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

« back to all changes in this revision

Viewing changes to hw/stellaris_enet.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-22 10:13:17 UTC
  • mfrom: (1.2.1 upstream) (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20090322101317-iigjtnu5qil35dtb
Tags: 0.10.1-1
http://bugs.debian.org/501400
[ Aurelien Jarno ]
* New upstream stable release:
  - patches/80_stable-branch.patch: remove.
* debian/control: 
  - Remove depends on proll.
  - Move depends on device-tree-compiler to build-depends.
  - Bump Standards-Version to 3.8.1 (no changes).
* patches/82_qemu-img_decimal.patch: new patch from upstream to make
  qemu-img accept sizes with decimal values (closes: bug#501400).

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/stellaris_enet.c
44
44
#define SE_TCTL_DUPLEX  0x08
45
45
 
46
46
typedef struct {
47
 
    uint32_t base;
48
47
    uint32_t ris;
49
48
    uint32_t im;
50
49
    uint32_t rctl;
133
132
    stellaris_enet_state *s = (stellaris_enet_state *)opaque;
134
133
    uint32_t val;
135
134
 
136
 
    offset -= s->base;
137
135
    switch (offset) {
138
136
    case 0x00: /* RIS */
139
137
        DPRINTF("IRQ status %02x\n", s->ris);
202
200
{
203
201
    stellaris_enet_state *s = (stellaris_enet_state *)opaque;
204
202
 
205
 
    offset -= s->base;
206
203
    switch (offset) {
207
204
    case 0x00: /* IACK */
208
205
        s->ris &= ~value;
326
323
    s->tx_frame_len = -1;
327
324
}
328
325
 
 
326
static void stellaris_enet_save(QEMUFile *f, void *opaque)
 
327
{
 
328
    stellaris_enet_state *s = (stellaris_enet_state *)opaque;
 
329
    int i;
 
330
 
 
331
    qemu_put_be32(f, s->ris);
 
332
    qemu_put_be32(f, s->im);
 
333
    qemu_put_be32(f, s->rctl);
 
334
    qemu_put_be32(f, s->tctl);
 
335
    qemu_put_be32(f, s->thr);
 
336
    qemu_put_be32(f, s->mctl);
 
337
    qemu_put_be32(f, s->mdv);
 
338
    qemu_put_be32(f, s->mtxd);
 
339
    qemu_put_be32(f, s->mrxd);
 
340
    qemu_put_be32(f, s->np);
 
341
    qemu_put_be32(f, s->tx_frame_len);
 
342
    qemu_put_be32(f, s->tx_fifo_len);
 
343
    qemu_put_buffer(f, s->tx_fifo, sizeof(s->tx_fifo));
 
344
    for (i = 0; i < 31; i++) {
 
345
        qemu_put_be32(f, s->rx[i].len);
 
346
        qemu_put_buffer(f, s->rx[i].data, sizeof(s->rx[i].data));
 
347
 
 
348
    }
 
349
    qemu_put_be32(f, s->next_packet);
 
350
    qemu_put_be32(f, s->rx_fifo - s->rx[s->next_packet].data);
 
351
    qemu_put_be32(f, s->rx_fifo_len);
 
352
}
 
353
 
 
354
static int stellaris_enet_load(QEMUFile *f, void *opaque, int version_id)
 
355
{
 
356
    stellaris_enet_state *s = (stellaris_enet_state *)opaque;
 
357
    int i;
 
358
 
 
359
    if (version_id != 1)
 
360
        return -EINVAL;
 
361
 
 
362
    s->ris = qemu_get_be32(f);
 
363
    s->im = qemu_get_be32(f);
 
364
    s->rctl = qemu_get_be32(f);
 
365
    s->tctl = qemu_get_be32(f);
 
366
    s->thr = qemu_get_be32(f);
 
367
    s->mctl = qemu_get_be32(f);
 
368
    s->mdv = qemu_get_be32(f);
 
369
    s->mtxd = qemu_get_be32(f);
 
370
    s->mrxd = qemu_get_be32(f);
 
371
    s->np = qemu_get_be32(f);
 
372
    s->tx_frame_len = qemu_get_be32(f);
 
373
    s->tx_fifo_len = qemu_get_be32(f);
 
374
    qemu_get_buffer(f, s->tx_fifo, sizeof(s->tx_fifo));
 
375
    for (i = 0; i < 31; i++) {
 
376
        s->rx[i].len = qemu_get_be32(f);
 
377
        qemu_get_buffer(f, s->rx[i].data, sizeof(s->rx[i].data));
 
378
 
 
379
    }
 
380
    s->next_packet = qemu_get_be32(f);
 
381
    s->rx_fifo = s->rx[s->next_packet].data + qemu_get_be32(f);
 
382
    s->rx_fifo_len = qemu_get_be32(f);
 
383
 
 
384
    return 0;
 
385
}
 
386
 
329
387
void stellaris_enet_init(NICInfo *nd, uint32_t base, qemu_irq irq)
330
388
{
331
389
    stellaris_enet_state *s;
332
390
    int iomemtype;
333
391
 
 
392
    qemu_check_nic_model(nd, "stellaris");
 
393
 
334
394
    s = (stellaris_enet_state *)qemu_mallocz(sizeof(stellaris_enet_state));
335
395
    iomemtype = cpu_register_io_memory(0, stellaris_enet_readfn,
336
396
                                       stellaris_enet_writefn, s);
337
397
    cpu_register_physical_memory(base, 0x00001000, iomemtype);
338
 
    s->base = base;
339
398
    s->irq = irq;
340
399
    memcpy(s->macaddr, nd->macaddr, 6);
341
400
 
342
 
    if (nd->vlan)
343
 
        s->vc = qemu_new_vlan_client(nd->vlan, stellaris_enet_receive,
344
 
                                     stellaris_enet_can_receive, s);
 
401
    if (nd->vlan) {
 
402
        s->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
 
403
                                     stellaris_enet_receive, stellaris_enet_can_receive, s);
 
404
        qemu_format_nic_info_str(s->vc, s->macaddr);
 
405
    }
345
406
 
346
407
    stellaris_enet_reset(s);
 
408
    register_savevm("stellaris_enet", -1, 1,
 
409
                    stellaris_enet_save, stellaris_enet_load, s);
347
410
}