← Back to branch summary

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

« back to all changes in this revision

Viewing changes to hw/cbus.c

  • Committer: Bazaar Package Importer
  • Author(s): Riku Voipio, Josh Triplett, Riku Voipio
  • Date: 2009-07-29 13:28:05 UTC
  • mfrom: (1.4.1 upstream)
  • mto: (12.1.1 sid) (10.1.13 sid)
  • mto: This revision was merged to the branch mainline in revision 13.
  • Revision ID: james.westby@ubuntu.com-20090729132805-cau7rfexh7dawyb8
Tags: 0.10.50+git20090729-1
[ Josh Triplett ]
* Remove myself from Uploaders.

[ Riku Voipio ]
* new upstream RC version
* nuke all linux-user patches (applied upstream)
  06_exit_segfault
  12_signal_powerpc_support
  21_net_soopts
  30_syscall_ipc
  32_syscall_sysctl
  35_syscall_sockaddr
  48_signal_terminate
  55_unmux_socketcall
* nuke all other applied-upstream patches
  01_nostrip (better version upstream)
  07_i386_exec_name (can be reintroduced in debian/rules)
  50_linuxbios_isa_bios_ram (shouldn't be needed anymore)
  51_linuxbios_piix_ram_size (applied)
  56_dhcp (crap)
  60_ppc_ld (reintroduce if needed)
  64_ppc_asm_constraints (ditto)
  66_tls_ld.patch (ditto)
  81_compile_dtb.patch (applied upstream)
  82_qemu-img_decimal (ditto)
* move to git
* simplify build rules
* Correct my email address

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/cbus.c
17
17
 * GNU General Public License for more details.
18
18
 *
19
19
 * You should have received a copy of the GNU General Public License along
20
 
 * with this program; if not, write to the Free Software Foundation, Inc.,
21
 
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
20
 * with this program; if not, see <http://www.gnu.org/licenses/>.
22
21
 */
23
22
 
24
23
#include "qemu-common.h"
28
27
 
29
28
//#define DEBUG
30
29
 
31
 
struct cbus_slave_s;
32
 
struct cbus_priv_s {
33
 
    struct cbus_s cbus;
 
30
typedef struct {
 
31
    void *opaque;
 
32
    void (*io)(void *opaque, int rw, int reg, uint16_t *val);
 
33
    int addr;
 
34
} CBusSlave;
 
35
 
 
36
typedef struct {
 
37
    CBus cbus;
34
38
 
35
39
    int sel;
36
40
    int dat;
48
52
        cbus_value,
49
53
    } cycle;
50
54
 
51
 
    struct cbus_slave_s *slave[8];
52
 
};
53
 
 
54
 
struct cbus_slave_s {
55
 
    void *opaque;
56
 
    void (*io)(void *opaque, int rw, int reg, uint16_t *val);
57
 
    int addr;
58
 
};
59
 
 
60
 
static void cbus_io(struct cbus_priv_s *s)
 
55
    CBusSlave *slave[8];
 
56
} CBusPriv;
 
57
 
 
58
static void cbus_io(CBusPriv *s)
61
59
{
62
60
    if (s->slave[s->addr])
63
61
        s->slave[s->addr]->io(s->slave[s->addr]->opaque,
64
62
                        s->rw, s->reg, &s->val);
65
63
    else
66
 
        cpu_abort(cpu_single_env, "%s: bad slave address %i\n",
67
 
                        __FUNCTION__, s->addr);
 
64
        hw_error("%s: bad slave address %i\n", __FUNCTION__, s->addr);
68
65
}
69
66
 
70
 
static void cbus_cycle(struct cbus_priv_s *s)
 
67
static void cbus_cycle(CBusPriv *s)
71
68
{
72
69
    switch (s->cycle) {
73
70
    case cbus_address:
98
95
 
99
96
static void cbus_clk(void *opaque, int line, int level)
100
97
{
101
 
    struct cbus_priv_s *s = (struct cbus_priv_s *) opaque;
 
98
    CBusPriv *s = (CBusPriv *) opaque;
102
99
 
103
100
    if (!s->sel && level && !s->clk) {
104
101
        if (s->dir)
115
112
 
116
113
static void cbus_dat(void *opaque, int line, int level)
117
114
{
118
 
    struct cbus_priv_s *s = (struct cbus_priv_s *) opaque;
 
115
    CBusPriv *s = (CBusPriv *) opaque;
119
116
 
120
117
    s->dat = level;
121
118
}
122
119
 
123
120
static void cbus_sel(void *opaque, int line, int level)
124
121
{
125
 
    struct cbus_priv_s *s = (struct cbus_priv_s *) opaque;
 
122
    CBusPriv *s = (CBusPriv *) opaque;
126
123
 
127
124
    if (!level) {
128
125
        s->dir = 1;
133
130
    s->sel = level;
134
131
}
135
132
 
136
 
struct cbus_s *cbus_init(qemu_irq dat)
 
133
CBus *cbus_init(qemu_irq dat)
137
134
{
138
 
    struct cbus_priv_s *s = (struct cbus_priv_s *) qemu_mallocz(sizeof(*s));
 
135
    CBusPriv *s = (CBusPriv *) qemu_mallocz(sizeof(*s));
139
136
 
140
137
    s->dat_out = dat;
141
138
    s->cbus.clk = qemu_allocate_irqs(cbus_clk, s, 1)[0];
149
146
    return &s->cbus;
150
147
}
151
148
 
152
 
void cbus_attach(struct cbus_s *bus, void *slave_opaque)
 
149
void cbus_attach(CBus *bus, void *slave_opaque)
153
150
{
154
 
    struct cbus_slave_s *slave = (struct cbus_slave_s *) slave_opaque;
155
 
    struct cbus_priv_s *s = (struct cbus_priv_s *) bus;
 
151
    CBusSlave *slave = (CBusSlave *) slave_opaque;
 
152
    CBusPriv *s = (CBusPriv *) bus;
156
153
 
157
154
    s->slave[slave->addr] = slave;
158
155
}
159
156
 
160
157
/* Retu/Vilma */
161
 
struct cbus_retu_s {
 
158
typedef struct {
162
159
    uint16_t irqst;
163
160
    uint16_t irqen;
164
161
    uint16_t cc[2];
173
170
 
174
171
    int is_vilma;
175
172
    qemu_irq irq;
176
 
    struct cbus_slave_s cbus;
177
 
};
 
173
    CBusSlave cbus;
 
174
} CBusRetu;
178
175
 
179
 
static void retu_interrupt_update(struct cbus_retu_s *s)
 
176
static void retu_interrupt_update(CBusRetu *s)
180
177
{
181
178
    qemu_set_irq(s->irq, s->irqst & ~s->irqen);
182
179
}
238
235
    retu_adc_self_temp  = 13,   /* RETU temperature */
239
236
};
240
237
 
241
 
static inline uint16_t retu_read(struct cbus_retu_s *s, int reg)
 
238
static inline uint16_t retu_read(CBusRetu *s, int reg)
242
239
{
243
240
#ifdef DEBUG
244
241
    printf("RETU read at %02x\n", reg);
301
298
        return 0x0000;
302
299
 
303
300
    default:
304
 
        cpu_abort(cpu_single_env, "%s: bad register %02x\n",
305
 
                        __FUNCTION__, reg);
 
301
        hw_error("%s: bad register %02x\n", __FUNCTION__, reg);
306
302
    }
307
303
}
308
304
 
309
 
static inline void retu_write(struct cbus_retu_s *s, int reg, uint16_t val)
 
305
static inline void retu_write(CBusRetu *s, int reg, uint16_t val)
310
306
{
311
307
#ifdef DEBUG
312
308
    printf("RETU write of %04x at %02x\n", val, reg);
375
371
        break;
376
372
 
377
373
    default:
378
 
        cpu_abort(cpu_single_env, "%s: bad register %02x\n",
379
 
                        __FUNCTION__, reg);
 
374
        hw_error("%s: bad register %02x\n", __FUNCTION__, reg);
380
375
    }
381
376
}
382
377
 
383
378
static void retu_io(void *opaque, int rw, int reg, uint16_t *val)
384
379
{
385
 
    struct cbus_retu_s *s = (struct cbus_retu_s *) opaque;
 
380
    CBusRetu *s = (CBusRetu *) opaque;
386
381
 
387
382
    if (rw)
388
383
        *val = retu_read(s, reg);
392
387
 
393
388
void *retu_init(qemu_irq irq, int vilma)
394
389
{
395
 
    struct cbus_retu_s *s = (struct cbus_retu_s *) qemu_mallocz(sizeof(*s));
 
390
    CBusRetu *s = (CBusRetu *) qemu_mallocz(sizeof(*s));
396
391
 
397
392
    s->irq = irq;
398
393
    s->irqen = 0xffff;
422
417
 
423
418
void retu_key_event(void *retu, int state)
424
419
{
425
 
    struct cbus_slave_s *slave = (struct cbus_slave_s *) retu;
426
 
    struct cbus_retu_s *s = (struct cbus_retu_s *) slave->opaque;
 
420
    CBusSlave *slave = (CBusSlave *) retu;
 
421
    CBusRetu *s = (CBusRetu *) slave->opaque;
427
422
 
428
423
    s->irqst |= 1 << retu_int_pwr;
429
424
    retu_interrupt_update(s);
437
432
#if 0
438
433
static void retu_head_event(void *retu, int state)
439
434
{
440
 
    struct cbus_slave_s *slave = (struct cbus_slave_s *) retu;
441
 
    struct cbus_retu_s *s = (struct cbus_retu_s *) slave->opaque;
 
435
    CBusSlave *slave = (CBusSlave *) retu;
 
436
    CBusRetu *s = (CBusRetu *) slave->opaque;
442
437
 
443
438
    if ((s->cc[0] & 0x500) == 0x500) {  /* TODO: Which bits? */
444
439
        /* TODO: reissue the interrupt every 100ms or so.  */
454
449
 
455
450
static void retu_hook_event(void *retu, int state)
456
451
{
457
 
    struct cbus_slave_s *slave = (struct cbus_slave_s *) retu;
458
 
    struct cbus_retu_s *s = (struct cbus_retu_s *) slave->opaque;
 
452
    CBusSlave *slave = (CBusSlave *) retu;
 
453
    CBusRetu *s = (CBusRetu *) slave->opaque;
459
454
 
460
455
    if ((s->cc[0] & 0x500) == 0x500) {
461
456
        /* TODO: reissue the interrupt every 100ms or so.  */
471
466
#endif
472
467
 
473
468
/* Tahvo/Betty */
474
 
struct cbus_tahvo_s {
 
469
typedef struct {
475
470
    uint16_t irqst;
476
471
    uint16_t irqen;
477
472
    uint8_t charger;
481
476
 
482
477
    int is_betty;
483
478
    qemu_irq irq;
484
 
    struct cbus_slave_s cbus;
485
 
};
 
479
    CBusSlave cbus;
 
480
} CBusTahvo;
486
481
 
487
 
static void tahvo_interrupt_update(struct cbus_tahvo_s *s)
 
482
static void tahvo_interrupt_update(CBusTahvo *s)
488
483
{
489
484
    qemu_set_irq(s->irq, s->irqst & ~s->irqen);
490
485
}
504
499
#define TAHVO_REG_NOPR          0x0c    /* (RW) Number of periods */
505
500
#define TAHVO_REG_FRR           0x0d    /* (RO) FR */
506
501
 
507
 
static inline uint16_t tahvo_read(struct cbus_tahvo_s *s, int reg)
 
502
static inline uint16_t tahvo_read(CBusTahvo *s, int reg)
508
503
{
509
504
#ifdef DEBUG
510
505
    printf("TAHVO read at %02x\n", reg);
542
537
        return 0x0000;
543
538
 
544
539
    default:
545
 
        cpu_abort(cpu_single_env, "%s: bad register %02x\n",
546
 
                        __FUNCTION__, reg);
 
540
        hw_error("%s: bad register %02x\n", __FUNCTION__, reg);
547
541
    }
548
542
}
549
543
 
550
 
static inline void tahvo_write(struct cbus_tahvo_s *s, int reg, uint16_t val)
 
544
static inline void tahvo_write(CBusTahvo *s, int reg, uint16_t val)
551
545
{
552
546
#ifdef DEBUG
553
547
    printf("TAHVO write of %04x at %02x\n", val, reg);
593
587
        break;
594
588
 
595
589
    default:
596
 
        cpu_abort(cpu_single_env, "%s: bad register %02x\n",
597
 
                        __FUNCTION__, reg);
 
590
        hw_error("%s: bad register %02x\n", __FUNCTION__, reg);
598
591
    }
599
592
}
600
593
 
601
594
static void tahvo_io(void *opaque, int rw, int reg, uint16_t *val)
602
595
{
603
 
    struct cbus_tahvo_s *s = (struct cbus_tahvo_s *) opaque;
 
596
    CBusTahvo *s = (CBusTahvo *) opaque;
604
597
 
605
598
    if (rw)
606
599
        *val = tahvo_read(s, reg);
610
603
 
611
604
void *tahvo_init(qemu_irq irq, int betty)
612
605
{
613
 
    struct cbus_tahvo_s *s = (struct cbus_tahvo_s *) qemu_mallocz(sizeof(*s));
 
606
    CBusTahvo *s = (CBusTahvo *) qemu_mallocz(sizeof(*s));
614
607
 
615
608
    s->irq = irq;
616
609
    s->irqen = 0xffff;