Previous 15994 Revisions Next

r9718 Saturday 4th December, 2010 at 12:27:26 UTC by Nathan Woods
More global removal, converted ng_aes to driver state. [Atari Ace]
[src/mess/drivers]abc80x.c ng_aes.c sg1000.c
[src/mess/includes]c64.h gba.h pc8801.h pmd85.h poly88.h
[src/mess/machine]6551.c c64.c msm8251.c msm8251.h pmd85.c poly88.c serial.c serial.h thomson.c
[src/mess/video]gba.c pc8801.c

src/mess/machine/serial.c
r9717r9718
3737#define LOG(x) do { if (VERBOSE) logerror x; } while (0)
3838
3939/* a read/write bit stream. used to transmit data and to receive data */
40struct data_stream
40typedef struct _data_stream data_stream;
41struct _data_stream
4142{
4243   /* pointer to buffer */
4344   unsigned char *pData;
r9717r9718
5455struct _serial_t
5556{
5657   /* transmit data bit-stream */
57   struct data_stream transmit;
58   data_stream transmit;
5859   /* receive data bit-stream */
59   struct data_stream receive;
60   data_stream receive;
6061
6162   /* register to receive data */
62   struct serial_receive_register   receive_reg;
63   serial_receive_register   receive_reg;
6364   /* register to transmit data */
64   struct serial_transmit_register transmit_reg;
65   serial_transmit_register transmit_reg;
6566
6667   /* connection to transmit/receive data over */
67   struct serial_connection connection;
68   serial_connection connection;
6869
6970   /* data form to transmit/receive */
70   struct data_form data_form;
71   data_form form;
7172
7273   int transmit_state;
7374
r9717r9718
138139   serial_t *ser = get_safe_token(device);
139140
140141   ser->BaudRate = baud_rate;
141   ser->data_form.word_length = num_data_bits;
142   ser->data_form.stop_bit_count = stop_bit_count;
143   ser->data_form.parity = parity_code;
142   ser->form.word_length = num_data_bits;
143   ser->form.stop_bit_count = stop_bit_count;
144   ser->form.parity = parity_code;
144145   ser->timer = timer_alloc(device->machine, serial_device_baud_rate_callback, (void *)device);
145146
146147   serial_connection_init(device->machine,&ser->connection);
r9717r9718
157158   serial_connection_out(device->machine,&ser->connection);
158159   transmit_register_reset(&ser->transmit_reg);
159160   receive_register_reset(&ser->receive_reg);
160   receive_register_setup(&ser->receive_reg, &ser->data_form);
161   receive_register_setup(&ser->receive_reg, &ser->form);
161162}
162163
163164
r9717r9718
194195}
195196
196197/* get a bit from input stream */
197static int   data_stream_get_data_bit_from_data_byte(struct data_stream *stream)
198static int data_stream_get_data_bit_from_data_byte(data_stream *stream)
198199{
199200   int data_bit;
200201   int data_byte;
r9717r9718
230231}
231232
232233
233void   receive_register_setup(struct serial_receive_register *receive, struct data_form *data_form)
234void receive_register_setup(serial_receive_register *receive, data_form *data_form)
234235{
235236   receive->bit_count = data_form->word_length + data_form->stop_bit_count;
236237
r9717r9718
246247/* for them */
247248
248249/* receive a bit */
249void   receive_register_update_bit(struct serial_receive_register *receive, int bit)
250void receive_register_update_bit(serial_receive_register *receive, int bit)
250251{
251252   int previous_bit;
252253
r9717r9718
296297   }
297298}
298299
299void   receive_register_reset(struct serial_receive_register *receive_reg)
300void receive_register_reset(serial_receive_register *receive_reg)
300301{
301302   receive_reg->bit_count_received = 0;
302303   receive_reg->flags &=~RECEIVE_REGISTER_FULL;
r9717r9718
304305   receive_reg->flags |= RECEIVE_REGISTER_WAITING_FOR_START_BIT;
305306}
306307
307void   receive_register_extract(struct serial_receive_register *receive_reg, struct data_form *data_form)
308void receive_register_extract(serial_receive_register *receive_reg, data_form *data_form)
308309{
309310   unsigned long data_shift;
310311   UINT8 data;
r9717r9718
370371
371372/***** TRANSMIT REGISTER *****/
372373
373void   transmit_register_reset(struct serial_transmit_register *transmit_reg)
374void transmit_register_reset(serial_transmit_register *transmit_reg)
374375{
375376   transmit_reg->flags |=TRANSMIT_REGISTER_EMPTY;
376377}
377378
378379/* used to construct data in stream format */
379static void transmit_register_add_bit(struct serial_transmit_register *transmit_reg, int bit)
380static void transmit_register_add_bit(serial_transmit_register *transmit_reg, int bit)
380381{
381382   /* combine bit */
382383   transmit_reg->register_data = transmit_reg->register_data<<1;
r9717r9718
387388
388389
389390/* generate data in stream format ready for transfer */
390void transmit_register_setup(struct serial_transmit_register *transmit_reg, struct data_form *data_form,unsigned char data_byte)
391void transmit_register_setup(serial_transmit_register *transmit_reg, data_form *data_form,unsigned char data_byte)
391392{
392393   int i;
393394   unsigned char transmit_data;
r9717r9718
436437
437438
438439/* get a bit from the transmit register */
439static int transmit_register_get_data_bit(struct serial_transmit_register *transmit_reg)
440static int transmit_register_get_data_bit(serial_transmit_register *transmit_reg)
440441{
441442   int bit;
442443
r9717r9718
457458}
458459
459460
460void   transmit_register_send_bit(running_machine *machine, struct serial_transmit_register *transmit_reg, struct serial_connection *connection)
461void transmit_register_send_bit(running_machine *machine, serial_transmit_register *transmit_reg, serial_connection *connection)
461462{
462463   int data;
463464
r9717r9718
479480
480481   /* generate byte to transmit */
481482   data_byte = 0;
482   for (i=0; i<ser->data_form.word_length; i++)
483   for (i=0; i<ser->form.word_length; i++)
483484   {
484485      data_byte = data_byte<<1;
485486      bit = data_stream_get_data_bit_from_data_byte(&ser->transmit);
486487      data_byte = data_byte|bit;
487488   }
488489   /* setup register */
489   transmit_register_setup(&ser->transmit_reg,&ser->data_form, data_byte);
490   transmit_register_setup(&ser->transmit_reg,&ser->form, data_byte);
490491
491492   logerror("serial device transmitted char: %02x\n",data_byte);
492493}
r9717r9718
501502   if (ser->receive_reg.flags & RECEIVE_REGISTER_FULL)
502503   {
503504      //logerror("SERIAL DEVICE\n");
504      receive_register_extract(&ser->receive_reg, &ser->data_form);
505      receive_register_extract(&ser->receive_reg, &ser->form);
505506
506507      logerror("serial device receive char: %02x\n",ser->receive_reg.byte_received);
507508   }
r9717r9718
522523}
523524
524525/* connect the specified connection to this serial device */
525void serial_device_connect(running_device *device, struct serial_connection *connection)
526void serial_device_connect(running_device *device, serial_connection *connection)
526527{
527528   serial_t *ser = get_safe_token(device);
528529   serial_connection_link(device->machine, connection, &ser->connection);
r9717r9718
561562}
562563
563564/* reset position in stream */
564static void data_stream_reset(struct data_stream *stream)
565static void data_stream_reset(data_stream *stream)
565566{
566567   /* reset byte offset */
567568   stream->ByteCount= 0;
r9717r9718
570571}
571572
572573/* free stream */
573static void data_stream_free(struct data_stream *stream)
574static void data_stream_free(data_stream *stream)
574575{
575576   if (stream->pData!=NULL)
576577   {
r9717r9718
581582}
582583
583584/* initialise stream */
584static void data_stream_init(struct data_stream *stream, unsigned char *pData, unsigned long DataLength)
585static void data_stream_init(data_stream *stream, unsigned char *pData, unsigned long DataLength)
585586{
586587   stream->pData = pData;
587588   stream->DataLength = DataLength;
r9717r9718
688689
689690
690691/* setup callbacks for connection */
691void   serial_connection_init(running_machine *machine, struct serial_connection *connection)
692void serial_connection_init(running_machine *machine, serial_connection *connection)
692693{
693694   connection->out_callback = NULL;
694695   connection->in_callback = NULL;
695696}
696697
697698/* set callback which will be executed when in status has changed */
698void   serial_connection_set_in_callback(running_machine *machine, struct serial_connection *connection, void (*in_cb)(running_machine *machine, int id, unsigned long status))
699void serial_connection_set_in_callback(running_machine *machine, serial_connection *connection, void (*in_cb)(running_machine *machine, int id, unsigned long status))
699700{
700701   connection->in_callback = in_cb;
701702}
702703
703704/* output new state through connection */
704void   serial_connection_out(running_machine *machine, struct serial_connection *connection)
705void serial_connection_out(running_machine *machine, serial_connection *connection)
705706{
706707   if (connection->out_callback!=NULL)
707708   {
r9717r9718
714715}
715716
716717/* join two serial connections together */
717void   serial_connection_link(running_machine *machine, struct serial_connection *connection_a, struct serial_connection *connection_b)
718void serial_connection_link(running_machine *machine, serial_connection *connection_a, serial_connection *connection_b)
718719{
719720   /* both connections should have their in connection setup! */
720721   /* the in connection is the callback they use to update their state based
src/mess/machine/serial.h
r9717r9718
101101
102102
103103/* this structure represents a serial connection */
104struct serial_connection
104typedef struct _serial_connection serial_connection;
105struct _serial_connection
105106{
106107   int id;
107108   /* state of this side */
r9717r9718
121122/*----------- defined in machine/serial.c -----------*/
122123
123124/* setup out and in callbacks */
124void serial_connection_init(running_machine *machine, struct serial_connection *connection);
125void serial_connection_init(running_machine *machine, serial_connection *connection);
125126
126127/* set callback which will be executed when in status has changed */
127void serial_connection_set_in_callback(running_machine *machine, struct serial_connection *connection, void (*in_cb)(running_machine *machine, int id, unsigned long status));
128void serial_connection_set_in_callback(running_machine *machine, serial_connection *connection, void (*in_cb)(running_machine *machine, int id, unsigned long status));
128129
129130/* output status, if callback is setup it will be executed with the new status */
130void serial_connection_out(running_machine *machine, struct serial_connection *connection);
131void serial_connection_out(running_machine *machine, serial_connection *connection);
131132
132133/* join two serial connections */
133void serial_connection_link(running_machine *machine, struct serial_connection *connection_a, struct serial_connection *connection_b);
134void serial_connection_link(running_machine *machine, serial_connection *connection_a, serial_connection *connection_b);
134135
135136
136137/*******************************************************************************/
137138
138139/* form of data being transmitted and received */
139struct data_form
140typedef struct _data_form data_form;
141struct _data_form
140142{
141143   /* length of word in bits */
142144   unsigned long word_length;
r9717r9718
166168
167169/* the receive register holds data in receive form! */
168170/* this must be extracted to get the data byte received */
169struct serial_receive_register
171typedef struct _serial_receive_register serial_receive_register;
172struct _serial_receive_register
170173{
171174   /* data */
172175   unsigned long register_data;
r9717r9718
181184   unsigned char byte_received;
182185};
183186
184void   receive_register_setup(struct serial_receive_register *receive, struct data_form *data_form);
185void   receive_register_update_bit(struct serial_receive_register *receive, int bit_state);
186void   receive_register_extract(struct serial_receive_register *receive_reg, struct data_form *data_form);
187void   receive_register_reset(struct serial_receive_register *receive_reg);
187void   receive_register_setup(serial_receive_register *receive, data_form *data_form);
188void   receive_register_update_bit(serial_receive_register *receive, int bit_state);
189void   receive_register_extract(serial_receive_register *receive_reg, data_form *data_form);
190void   receive_register_reset(serial_receive_register *receive_reg);
188191
189192/* the transmit register is the final stage
190193in the serial transmit procedure */
r9717r9718
195198/* register is empty and ready to be filled with data */
196199#define TRANSMIT_REGISTER_EMPTY 0x0001
197200
198struct serial_transmit_register
201typedef struct _serial_transmit_register serial_transmit_register;
202struct _serial_transmit_register
199203{
200204   /* data */
201205   unsigned long register_data;
r9717r9718
208212};
209213
210214/* setup transmit reg ready for transmit */
211void transmit_register_setup(struct serial_transmit_register *transmit_reg, struct data_form *data_form,unsigned char data_byte);
212void   transmit_register_send_bit(running_machine *machine, struct serial_transmit_register *transmit_reg, struct serial_connection *connection);
213void   transmit_register_reset(struct serial_transmit_register *transmit_reg);
215void transmit_register_setup(serial_transmit_register *transmit_reg, data_form *data_form,unsigned char data_byte);
216void   transmit_register_send_bit(running_machine *machine, serial_transmit_register *transmit_reg, serial_connection *connection);
217void   transmit_register_reset(serial_transmit_register *transmit_reg);
214218
215219/*******************************************************************************/
216220/**** SERIAL HELPER ****/
r9717r9718
225229/* connect this device to the emulated serial chip */
226230/* id is the serial device to connect to */
227231/* connection is the serial connection to connect to the serial device */
228void serial_device_connect(running_device *image, struct serial_connection *connection);
232void serial_device_connect(running_device *image, serial_connection *connection);
229233
230234DECLARE_LEGACY_IMAGE_DEVICE(SERIAL, serial);
231235
src/mess/machine/thomson.c
r9717r9718
381381
382382
383383
384static struct serial_connection to7_io_line;
384static serial_connection to7_io_line;
385385
386386static DEVICE_START( thom_serial_cc90323 )
387387{
src/mess/machine/pmd85.c
r9717r9718
1616#include "includes/pmd85.h"
1717#include "machine/msm8251.h"
1818#include "machine/pit8253.h"
19#include "machine/serial.h"
2019#include "devices/messram.h"
2120
2221
r9717r9718
784783   DEVCB_HANDLER(mato_ppi_0_portc_w)
785784};
786785
787static struct serial_connection pmd85_cassette_serial_connection;
788786
789787static void pmd85_cassette_write(running_machine *machine, int id, unsigned long state)
790788{
791   pmd85_cassette_serial_connection.input_state = state;
789   pmd85_state *drvstate = machine->driver_data<pmd85_state>();
790   drvstate->cassette_serial_connection.input_state = state;
792791}
793792
794793static TIMER_CALLBACK(pmd85_cassette_timer_callback)
r9717r9718
818817                  {
819818                     data = (!state->previous_level && current_level) ? 1 : 0;
820819
821                     set_out_data_bit(pmd85_cassette_serial_connection.State, data);
822                     serial_connection_out(machine, &pmd85_cassette_serial_connection);
820                     set_out_data_bit(state->cassette_serial_connection.State, data);
821                     serial_connection_out(machine, &state->cassette_serial_connection);
823822                     msm8251_receive_clock(machine->device("uart"));
824823
825824                     state->clk_level_tape = 1;
r9717r9718
839838      /* tape writing */
840839      if (cassette_get_state(machine->device("cassette"))&CASSETTE_RECORD)
841840      {
842         data = get_in_data_bit(pmd85_cassette_serial_connection.input_state);
841         data = get_in_data_bit(state->cassette_serial_connection.input_state);
843842         data ^= state->clk_level_tape;
844843         cassette_output(machine->device("cassette"), data&0x01 ? 1 : -1);
845844
r9717r9718
879878   state->cassette_timer = timer_alloc(machine, pmd85_cassette_timer_callback, NULL);
880879   timer_adjust_periodic(state->cassette_timer, attotime_zero, 0, ATTOTIME_IN_HZ(2400));
881880
882   serial_connection_init(machine, &pmd85_cassette_serial_connection);
883   serial_connection_set_in_callback(machine, &pmd85_cassette_serial_connection, pmd85_cassette_write);
881   serial_connection_init(machine, &state->cassette_serial_connection);
882   serial_connection_set_in_callback(machine, &state->cassette_serial_connection, pmd85_cassette_write);
884883}
885884
886885DRIVER_INIT ( pmd851 )
r9717r9718
935934   pmd85_state *state = machine->driver_data<pmd85_state>();
936935   if (state->model != MATO)
937936   {
938      msm8251_connect(machine->device("uart"), &pmd85_cassette_serial_connection);
937      msm8251_connect(machine->device("uart"), &state->cassette_serial_connection);
939938   }
940939}
941940
src/mess/machine/poly88.c
r9717r9718
77****************************************************************************/
88
99#include "emu.h"
10#include "includes/poly88.h"
1110#include "cpu/i8085/i8085.h"
1211#include "devices/cassette.h"
13#include "machine/serial.h"
12#include "includes/poly88.h"
1413
1514
1615static TIMER_CALLBACK(poly88_usart_timer_callback)
r9717r9718
134133}
135134
136135
137static struct serial_connection poly88_cassette_serial_connection;
138136
139137static void poly88_cassette_write(running_machine *machine, int id, unsigned long state)
140138{
141   poly88_cassette_serial_connection.input_state = state;
139   poly88_state *drvstate = machine->driver_data<poly88_state>();
140   drvstate->cassette_serial_connection.input_state = state;
142141}
143142
144143static TIMER_CALLBACK(poly88_cassette_timer_callback)
r9717r9718
166165                  {
167166                     data = (!state->previous_level && current_level) ? 1 : 0;
168167//data = current_level;
169                     set_out_data_bit(poly88_cassette_serial_connection.State, data);
170                     serial_connection_out(machine, &poly88_cassette_serial_connection);
168                     set_out_data_bit(state->cassette_serial_connection.State, data);
169                     serial_connection_out(machine, &state->cassette_serial_connection);
171170                     msm8251_receive_clock(machine->device("uart"));
172171
173172                     state->clk_level_tape = 1;
r9717r9718
178177      /* tape writing */
179178      if (cassette_get_state(machine->device("cassette"))&CASSETTE_RECORD)
180179      {
181         data = get_in_data_bit(poly88_cassette_serial_connection.input_state);
180         data = get_in_data_bit(state->cassette_serial_connection.input_state);
182181         data ^= state->clk_level_tape;
183182         cassette_output(machine->device("cassette"), data&0x01 ? 1 : -1);
184183
r9717r9718
201200
202201static TIMER_CALLBACK( setup_machine_state )
203202{
204   msm8251_connect(machine->device("uart"), &poly88_cassette_serial_connection);
203   poly88_state *state = machine->driver_data<poly88_state>();
204   msm8251_connect(machine->device("uart"), &state->cassette_serial_connection);
205205}
206206
207207DRIVER_INIT ( poly88 )
r9717r9718
212212   state->cassette_timer = timer_alloc(machine, poly88_cassette_timer_callback, NULL);
213213   timer_adjust_periodic(state->cassette_timer, attotime_zero, 0, ATTOTIME_IN_HZ(600));
214214
215   serial_connection_init(machine, &poly88_cassette_serial_connection);
216   serial_connection_set_in_callback(machine, &poly88_cassette_serial_connection, poly88_cassette_write);
215   serial_connection_init(machine, &state->cassette_serial_connection);
216   serial_connection_set_in_callback(machine, &state->cassette_serial_connection, poly88_cassette_write);
217217
218218   timer_pulse(machine, ATTOTIME_IN_HZ(24000), NULL, 0, keyboard_callback);
219219}
src/mess/machine/6551.c
r9717r9718
3737
3838   void   (*irq_callback)(int);
3939
40   struct data_form data_form;
40   data_form form;
4141
4242   /* receive register */
43   struct serial_receive_register   receive_reg;
43   serial_receive_register   receive_reg;
4444   /* transmit register */
45   struct serial_transmit_register transmit_reg;
45   serial_transmit_register transmit_reg;
4646
47   struct serial_connection connection;
47   serial_connection connection;
4848};
4949
5050
r9717r9718
106106
107107   if (acia->receive_reg.flags & RECEIVE_REGISTER_FULL)
108108   {
109      receive_register_extract(&acia->receive_reg, &acia->data_form);
109      receive_register_extract(&acia->receive_reg, &acia->form);
110110      acia_6551_receive_char(device, acia->receive_reg.byte_received);
111111   }
112112
r9717r9718
117117      if (acia->transmit_reg.flags & TRANSMIT_REGISTER_EMPTY)
118118      {
119119         /* set it up */
120         transmit_register_setup(&acia->transmit_reg, &acia->data_form, acia->transmit_data_register);
120         transmit_register_setup(&acia->transmit_reg, &acia->form, acia->transmit_data_register);
121121         /* acia transmit reg now empty */
122122         acia->status_register |=(1<<4);
123123         /* and refresh ints */
r9717r9718
293293{
294294   acia6551_t *acia = get_token(device);
295295
296   acia->data_form.word_length = 8-((acia->control_register>>5) & 0x03);
297   acia->data_form.stop_bit_count = (acia->control_register>>7)+1;
296   acia->form.word_length = 8-((acia->control_register>>5) & 0x03);
297   acia->form.stop_bit_count = (acia->control_register>>7)+1;
298298
299299   if (acia->command_register & (1<<5))
300300   {
301      acia->data_form.parity = SERIAL_PARITY_ODD;
301      acia->form.parity = SERIAL_PARITY_ODD;
302302   }
303303   else
304304   {
305      acia->data_form.parity = SERIAL_PARITY_NONE;
305      acia->form.parity = SERIAL_PARITY_NONE;
306306   }
307307
308   receive_register_setup(&acia->receive_reg, &acia->data_form);
308   receive_register_setup(&acia->receive_reg, &acia->form);
309309}
310310
311311
src/mess/machine/c64.c
r9717r9718
4949
5050static void c64_nmi( running_machine *machine )
5151{
52   static int nmilevel = 0;
52   c64_state *state = machine->driver_data<c64_state>();
5353   running_device *cia_1 = machine->device("cia_1");
5454   int cia1irq = mos6526_irq_r(cia_1);
5555
56   if (nmilevel != (input_port_read(machine, "SPECIAL") & 0x80) || cia1irq)   /* KEY_RESTORE */
56   if (state->nmilevel != (input_port_read(machine, "SPECIAL") & 0x80) || cia1irq)   /* KEY_RESTORE */
5757   {
5858      cputag_set_input_line(machine, "maincpu", INPUT_LINE_NMI, (input_port_read(machine, "SPECIAL") & 0x80) || cia1irq);
5959
60      nmilevel = (input_port_read(machine, "SPECIAL") & 0x80) || cia1irq;
60      state->nmilevel = (input_port_read(machine, "SPECIAL") & 0x80) || cia1irq;
6161   }
6262}
6363
src/mess/machine/msm8251.c
r9717r9718
88
99#include "emu.h"
1010#include "msm8251.h"
11#include "machine/serial.h"
1211
1312
1413/***************************************************************************
r9717r9718
4544   UINT8 data;
4645
4746   /* receive reg */
48   struct serial_receive_register receive_reg;
47   serial_receive_register receive_reg;
4948   /* transmit reg */
50   struct serial_transmit_register transmit_reg;
49   serial_transmit_register transmit_reg;
5150
52   struct data_form data_form;
51   data_form form;
5352
5453   /* the serial connection that data is transfered over */
5554   /* this is usually connected to the serial device */
56   struct serial_connection connection;
55   serial_connection connection;
5756};
5857
5958
r9717r9718
186185
187186      if (uart->receive_reg.flags & RECEIVE_REGISTER_FULL)
188187      {
189         receive_register_extract(&uart->receive_reg, &uart->data_form);
188         receive_register_extract(&uart->receive_reg, &uart->form);
190189         msm8251_receive_character(device, uart->receive_reg.byte_received);
191190      }
192191   }
r9717r9718
213212         if ((uart->transmit_reg.flags & TRANSMIT_REGISTER_EMPTY)!=0)
214213         {
215214            /* set it up */
216            transmit_register_setup(&uart->transmit_reg, &uart->data_form, uart->data);
215            transmit_register_setup(&uart->transmit_reg, &uart->form, uart->data);
217216            /* msm8251 transmit reg now empty */
218217            uart->status |=MSM8251_STATUS_TX_EMPTY;
219218            /* ready for next transmit */
r9717r9718
487486               }
488487            }
489488
490            uart->data_form.word_length = ((data>>2) & 0x03)+5;
491            uart->data_form.parity = SERIAL_PARITY_NONE;
489            uart->form.word_length = ((data>>2) & 0x03)+5;
490            uart->form.parity = SERIAL_PARITY_NONE;
492491            switch ((data>>6) & 0x03)
493492            {
494493               case 0:
495494               case 1:
496                  uart->data_form.stop_bit_count =  1;
495                  uart->form.stop_bit_count =  1;
497496                  break;
498497               case 2:
499498               case 3:
500                  uart->data_form.stop_bit_count =  2;
499                  uart->form.stop_bit_count =  2;
501500                  break;
502501            }
503            receive_register_setup(&uart->receive_reg, &uart->data_form);
502            receive_register_setup(&uart->receive_reg, &uart->form);
504503
505504
506505#if 0
r9717r9718
777776    msm8251_connect
778777-------------------------------------------------*/
779778
780void msm8251_connect(running_device *device, struct serial_connection *other_connection)
779void msm8251_connect(running_device *device, serial_connection *other_connection)
781780{
782781   msm8251_t *uart = get_token(device);
783782   serial_connection_link(device->machine, &uart->connection, other_connection);
src/mess/machine/msm8251.h
r9717r9718
7878
7979/* connecting to serial output */
8080void msm8251_connect_to_serial_device(running_device *device, running_device *image);
81void msm8251_connect(running_device *device, struct serial_connection *other_connection);
81void msm8251_connect(running_device *device, serial_connection *other_connection);
8282
8383void msm8251_receive_character(running_device *device, UINT8 ch);
8484
src/mess/video/pc8801.c
r9717r9718
421421{
422422   pc88_state *state = screen->machine->driver_data<pc88_state>();
423423   int x, y, attr_new, text_new, i, a, tx, ty, oy, gx, gy, ct, cg;
424   static int blink_count;
425424   int full_refresh = 1;
426425
427   blink_count = (blink_count + 1) % (state->blink_period * 4);
426   state->blink_count = (state->blink_count + 1) % (state->blink_period * 4);
428427   /* attribute expand */
429428   for (y = 0; y < 25; y++)
430429   {
r9717r9718
509508         if (attr_new & TX_BL)
510509         {
511510            attr_new &= ~TX_BL;
512            if ((blink_count / state->blink_period) & 1)
511            if ((state->blink_count / state->blink_period) & 1)
513512               attr_new ^= TX_REV;
514513         }
515514
r9717r9718
522521               attr_new ^= TX_UL;
523522               break;
524523            case blink_underline:
525               if (blink_count / state->blink_period)
524               if (state->blink_count / state->blink_period)
526525                  attr_new ^= TX_UL;
527526               break;
528527            case noblink_block:
529528               attr_new ^= TX_REV;
530529               break;
531530            case blink_block:
532               if (blink_count / state->blink_period)
531               if (state->blink_count / state->blink_period)
533532                  attr_new ^= TX_REV;
534533               break;
535534            }
r9717r9718
10261025   pc88_state *state = space->machine->driver_data<pc88_state>();
10271026   int palno;
10281027   int i;
1029   static int r[10],g[10],b[10];
10301028
10311029   if (offset == 0)
10321030      palno = 16;
r9717r9718
10481046   {
10491047      if ((data & 0x40) == 0x00)
10501048      {
1051         b[offset] = ((data << 5) & 0xe0) | ((data << 2) & 0x1c) | ((data >> 1) & 0x03);
1052         r[offset] = ((data << 2) & 0xe0) | ((data >> 1) & 0x1c) | ((data >> 4) & 0x03);
1049         state->pal[offset].b = ((data << 5) & 0xe0) | ((data << 2) & 0x1c) | ((data >> 1) & 0x03);
1050         state->pal[offset].r = ((data << 2) & 0xe0) | ((data >> 1) & 0x1c) | ((data >> 4) & 0x03);
10531051      }
10541052      else
10551053      {
1056         g[offset] = ((data << 5) & 0xe0) | ((data << 2) & 0x1c) | ((data >> 1) & 0x03);
1054         state->pal[offset].g = ((data << 5) & 0xe0) | ((data << 2) & 0x1c) | ((data >> 1) & 0x03);
10571055      }
10581056   }
10591057   else
10601058   {
1061      b[offset] = (data & 1) ? 0xff : 0x00;
1062      r[offset] = (data & 2) ? 0xff : 0x00;
1063      g[offset] = (data & 4) ? 0xff : 0x00;
1059      state->pal[offset].b = (data & 1) ? 0xff : 0x00;
1060      state->pal[offset].r = (data & 2) ? 0xff : 0x00;
1061      state->pal[offset].g = (data & 4) ? 0xff : 0x00;
10641062   }
1065   colortable_palette_set_color(space->machine->colortable, palno, MAKE_RGB(r[offset], g[offset], b[offset]));
1063   colortable_palette_set_color(space->machine->colortable, palno, MAKE_RGB(state->pal[offset].r, state->pal[offset].g, state->pal[offset].b));
10661064}
src/mess/video/gba.c
r9717r9718
17661766   bitmap_t *bitmap = machine->generic.tmpbitmap;
17671767   UINT16 *scanline = BITMAP_ADDR16(bitmap, y, 0);
17681768   int i, x;
1769   static UINT32 xferscan[7][240+2048];   // up to 1024 pixels of slop on either side to allow easier clip handling
17701769   gba_state *state = machine->driver_data<gba_state>();
17711770   UINT8 submode = 0;
17721771   int bpp = 0;
r9717r9718
18101809         break;
18111810   }
18121811
1813   gba_draw_scanline_modes[state->DISPCNT & 7][submode](machine, state, y, &xferscan[0][1024], &xferscan[1][1024], &xferscan[2][1024], &xferscan[3][1024], &xferscan[4][1024], &xferscan[5][1024], &xferscan[6][1024], bpp);
1812   gba_draw_scanline_modes[state->DISPCNT & 7][submode](machine, state, y, &state->xferscan[0][1024], &state->xferscan[1][1024], &state->xferscan[2][1024], &state->xferscan[3][1024], &state->xferscan[4][1024], &state->xferscan[5][1024], &state->xferscan[6][1024], bpp);
18141813
18151814   for(x = 0; x < 240; x++)
18161815   {
1817      scanline[x] = xferscan[6][1024 + x] & 0x7fff;
1816      scanline[x] = state->xferscan[6][1024 + x] & 0x7fff;
18181817   }
18191818
18201819   return;
src/mess/includes/gba.h
r9717r9718
203203
204204   int fifo_a_ptr, fifo_b_ptr, fifo_a_in, fifo_b_in;
205205   UINT8 fifo_a[20], fifo_b[20];
206   UINT32 xferscan[7][240+2048];
206207};
207208
208209/*----------- defined in video/gba.c -----------*/
src/mess/includes/pmd85.h
r9717r9718
77#ifndef PMD85_H_
88#define PMD85_H_
99
10#include "machine/serial.h"
1011#include "machine/i8255a.h"
1112
1213class pmd85_state : public driver_device
r9717r9718
2526   UINT8 model;
2627   emu_timer * cassette_timer;
2728   void (*update_memory)(running_machine *);
29   serial_connection cassette_serial_connection;
2830};
2931
3032
src/mess/includes/pc8801.h
r9717r9718
9999   unsigned short *text_old;
100100   bitmap_t *wbm1;
101101   bitmap_t *wbm2;
102   int blink_count;
103   struct { UINT8 r,g,b; } pal[10];
102104};
103105
104106/*----------- defined in machine/pc8801.c -----------*/
src/mess/includes/poly88.h
r9717r9718
66
77#ifndef POLY88_H_
88#define POLY88_H_
9
10#include "machine/serial.h"
911#include "machine/msm8251.h"
1012#include "devices/snapquik.h"
1113
r9717r9718
2426   int previous_level;
2527   int clk_level;
2628   int clk_level_tape;
29   serial_connection cassette_serial_connection;
2730};
2831
2932
src/mess/includes/c64.h
r9717r9718
6767   UINT8 *io_ram_w_ptr;
6868   UINT8 *io_ram_r_ptr;
6969   c64_cart_t cart;
70   int nmilevel;
7071};
7172
7273
src/mess/drivers/sg1000.c
r9717r9718
7575#include "machine/ctronics.h"
7676#include "machine/i8255a.h"
7777#include "machine/msm8251.h"
78#include "machine/serial.h"
7978#include "machine/upd765.h"
8079#include "sound/sn76496.h"
8180#include "video/tms9928a.h"
src/mess/drivers/abc80x.c
r9717r9718
243243#include "devices/cassette.h"
244244#include "devices/printer.h"
245245#include "devices/messram.h"
246#include "machine/serial.h"
247246#include "machine/z80ctc.h"
248247#include "machine/z80dart.h"
249248#include "machine/abcbus.h"
src/mess/drivers/ng_aes.c
r9717r9718
4040#include "neogeo.lh"
4141
4242
43// CD-ROM / DMA control registers
44typedef struct
45{
46   UINT8 area_sel;
47   UINT8 pcm_bank_sel;
48   UINT8 spr_bank_sel;
49   UINT32 addr_source; // target if in fill mode
50   UINT32 addr_target;
51   UINT16 fill_word;
52   UINT32 word_count;
53   UINT16 dma_mode[10];
54} neocd_ctrl_t;
55
56class ng_aes_state : public neogeo_state
57{
58public:
59   ng_aes_state(running_machine &machine, const driver_device_config_base &config)
60      : neogeo_state(machine, config) { }
61
62   UINT8 *memcard_data;
63   neocd_ctrl_t neocd_ctrl;
64};
65
66
67
4368#define LOG_VIDEO_SYSTEM      (0)
4469#define LOG_CPU_COMM         (0)
4570#define LOG_MAIN_CPU_BANKING   (1)
r9717r9718
5681 *
5782 *************************************/
5883
59static UINT8 *memcard_data;
6084//static UINT16 *save_ram;
6185
62// CD-ROM / DMA control registers
63struct _neocd_ctrl
64{
65   UINT8 area_sel;
66   UINT8 pcm_bank_sel;
67   UINT8 spr_bank_sel;
68   UINT32 addr_source; // target if in fill mode
69   UINT32 addr_target;
70   UINT16 fill_word;
71   UINT32 word_count;
72   UINT16 dma_mode[10];
73} neocd_ctrl;
74
7586/*************************************
7687 *
7788 *  Forward declarations
r9717r9718
479490
480491static READ16_HANDLER( memcard_r )
481492{
493   ng_aes_state *state = space->machine->driver_data<ng_aes_state>();
482494   UINT16 ret;
483495
484496   if (memcard_present(space->machine) != -1)
485      ret = memcard_data[offset] | 0xff00;
497      ret = state->memcard_data[offset] | 0xff00;
486498   else
487499      ret = 0xffff;
488500
r9717r9718
492504
493505static WRITE16_HANDLER( memcard_w )
494506{
507   ng_aes_state *state = space->machine->driver_data<ng_aes_state>();
495508   if (ACCESSING_BITS_0_7)
496509   {
497510      if (memcard_present(space->machine) != -1)
498         memcard_data[offset] = data;
511         state->memcard_data[offset] = data;
499512   }
500513}
501514
502515/* The NeoCD has an 8kB internal memory card, instead of memcard slots like the MVS and AES */
503516static READ16_HANDLER( neocd_memcard_r )
504517{
505   return memcard_data[offset] | 0xff00;
518   ng_aes_state *state = space->machine->driver_data<ng_aes_state>();
519   return state->memcard_data[offset] | 0xff00;
506520}
507521
508522
509523static WRITE16_HANDLER( neocd_memcard_w )
510524{
525   ng_aes_state *state = space->machine->driver_data<ng_aes_state>();
511526   if (ACCESSING_BITS_0_7)
512527   {
513      memcard_data[offset] = data;
528      state->memcard_data[offset] = data;
514529   }
515530}
516531
517532static MEMCARD_HANDLER( neogeo )
518533{
534   ng_aes_state *state = machine->driver_data<ng_aes_state>();
519535   switch (action)
520536   {
521537   case MEMCARD_CREATE:
522      memset(memcard_data, 0, MEMCARD_SIZE);
523      mame_fwrite(file, memcard_data, MEMCARD_SIZE);
538      memset(state->memcard_data, 0, MEMCARD_SIZE);
539      mame_fwrite(file, state->memcard_data, MEMCARD_SIZE);
524540      break;
525541
526542   case MEMCARD_INSERT:
527      mame_fread(file, memcard_data, MEMCARD_SIZE);
543      mame_fread(file, state->memcard_data, MEMCARD_SIZE);
528544      break;
529545
530546   case MEMCARD_EJECT:
531      mame_fwrite(file, memcard_data, MEMCARD_SIZE);
547      mame_fwrite(file, state->memcard_data, MEMCARD_SIZE);
532548      break;
533549   }
534550}
r9717r9718
885901
886902static void neocd_do_dma(address_space* space)
887903{
904   ng_aes_state *state = space->machine->driver_data<ng_aes_state>();
888905   // TODO: Proper DMA timing and control
889906   int count;
890907//  UINT16 word;
891908
892   switch(neocd_ctrl.dma_mode[0])
909   switch(state->neocd_ctrl.dma_mode[0])
893910   {
894911   case 0xffdd:
895      for(count=0;count<neocd_ctrl.word_count;count++)
912      for(count=0;count<state->neocd_ctrl.word_count;count++)
896913      {
897         //word = space->read_word(neocd_ctrl.addr_source);
898         space->write_word(neocd_ctrl.addr_source+(count*2),neocd_ctrl.fill_word);
914         //word = space->read_word(state->neocd_ctrl.addr_source);
915         space->write_word(state->neocd_ctrl.addr_source+(count*2),state->neocd_ctrl.fill_word);
899916      }
900917      logerror("CTRL: DMA word-fill transfer of %i bytes\n",count*2);
901918      break;
902919   case 0xfef5:
903      for(count=0;count<neocd_ctrl.word_count;count++)
920      for(count=0;count<state->neocd_ctrl.word_count;count++)
904921      {
905         //word = space->read_word(neocd_ctrl.addr_source);
906         space->write_word(neocd_ctrl.addr_source+(count*4),(neocd_ctrl.addr_source+(count*4)) >> 16);
907         space->write_word(neocd_ctrl.addr_source+(count*4)+2,(neocd_ctrl.addr_source+(count*4)) & 0xffff);
922         //word = space->read_word(state->neocd_ctrl.addr_source);
923         space->write_word(state->neocd_ctrl.addr_source+(count*4),(state->neocd_ctrl.addr_source+(count*4)) >> 16);
924         space->write_word(state->neocd_ctrl.addr_source+(count*4)+2,(state->neocd_ctrl.addr_source+(count*4)) & 0xffff);
908925      }
909926      logerror("CTRL: DMA mode 2 transfer of %i bytes\n",count*4);
910927      break;
911928   case 0xcffd:
912      for(count=0;count<neocd_ctrl.word_count;count++)
929      for(count=0;count<state->neocd_ctrl.word_count;count++)
913930      {
914         //word = space->read_word(neocd_ctrl.addr_source);
915         space->write_word(neocd_ctrl.addr_source+(count*8),((neocd_ctrl.addr_source+(count*8)) >> 24) | 0xff00);
916         space->write_word(neocd_ctrl.addr_source+(count*8)+2,((neocd_ctrl.addr_source+(count*8)) >> 16) | 0xff00);
917         space->write_word(neocd_ctrl.addr_source+(count*8)+4,((neocd_ctrl.addr_source+(count*8)) >> 8) | 0xff00);
918         space->write_word(neocd_ctrl.addr_source+(count*8)+6,(neocd_ctrl.addr_source+(count*8)) | 0xff00);
931         //word = space->read_word(state->neocd_ctrl.addr_source);
932         space->write_word(state->neocd_ctrl.addr_source+(count*8),((state->neocd_ctrl.addr_source+(count*8)) >> 24) | 0xff00);
933         space->write_word(state->neocd_ctrl.addr_source+(count*8)+2,((state->neocd_ctrl.addr_source+(count*8)) >> 16) | 0xff00);
934         space->write_word(state->neocd_ctrl.addr_source+(count*8)+4,((state->neocd_ctrl.addr_source+(count*8)) >> 8) | 0xff00);
935         space->write_word(state->neocd_ctrl.addr_source+(count*8)+6,(state->neocd_ctrl.addr_source+(count*8)) | 0xff00);
919936      }
920937      logerror("CTRL: DMA mode 3 transfer of %i bytes\n",count*8);
921938      break;
922939   default:
923      logerror("CTRL: Unknown DMA transfer mode %04x\n",neocd_ctrl.dma_mode[0]);
940      logerror("CTRL: Unknown DMA transfer mode %04x\n",state->neocd_ctrl.dma_mode[0]);
924941   }
925942}
926943
927944static READ16_HANDLER( neocd_control_r )
928945{
946   ng_aes_state *state = space->machine->driver_data<ng_aes_state>();
929947
930948   switch(offset)
931949   {
932950   case 0x64/2: // source address, high word
933      return (neocd_ctrl.addr_source >> 16) & 0xffff;
951      return (state->neocd_ctrl.addr_source >> 16) & 0xffff;
934952   case 0x66/2: // source address, low word
935      return neocd_ctrl.addr_source & 0xffff;
953      return state->neocd_ctrl.addr_source & 0xffff;
936954   case 0x68/2: // target address, high word
937      return (neocd_ctrl.addr_target >> 16) & 0xffff;
955      return (state->neocd_ctrl.addr_target >> 16) & 0xffff;
938956   case 0x6a/2: // target address, low word
939      return neocd_ctrl.addr_target & 0xffff;
957      return state->neocd_ctrl.addr_target & 0xffff;
940958   case 0x6c/2: // fill word
941      return neocd_ctrl.fill_word;
959      return state->neocd_ctrl.fill_word;
942960   case 0x70/2: // word count
943      return (neocd_ctrl.word_count >> 16) & 0xffff;
961      return (state->neocd_ctrl.word_count >> 16) & 0xffff;
944962   case 0x72/2:
945      return neocd_ctrl.word_count & 0xffff;
963      return state->neocd_ctrl.word_count & 0xffff;
946964   case 0x7e/2:  // DMA parameters
947965   case 0x80/2:
948966   case 0x82/2:
r9717r9718
952970   case 0x8a/2:
953971   case 0x8c/2:
954972   case 0x8e/2:
955      return neocd_ctrl.dma_mode[offset-(0x7e/2)];
973      return state->neocd_ctrl.dma_mode[offset-(0x7e/2)];
956974      break;
957975   case 0x105/2:
958      return neocd_ctrl.area_sel;
976      return state->neocd_ctrl.area_sel;
959977   case 0x11c/2:
960978      logerror("CTRL: Read region code.\n");
961979      return 0x0600;  // we'll just force USA region for now
962980   case 0x1a0/2:
963      return neocd_ctrl.spr_bank_sel;
981      return state->neocd_ctrl.spr_bank_sel;
964982      break;
965983   case 0x1a2/2:
966      return neocd_ctrl.pcm_bank_sel;
984      return state->neocd_ctrl.pcm_bank_sel;
967985      break;
968986   default:
969987      logerror("CTRL: Read offset %04x\n",offset);
r9717r9718
974992
975993static WRITE16_HANDLER( neocd_control_w )
976994{
995   ng_aes_state *state = space->machine->driver_data<ng_aes_state>();
977996   switch(offset)
978997   {
979998   case 0x60/2: // Start DMA transfer
r9717r9718
9811000         neocd_do_dma(space);
9821001      break;
9831002   case 0x64/2: // source address, high word
984      neocd_ctrl.addr_source = (neocd_ctrl.addr_source & 0x0000ffff) | (data << 16);
985      logerror("CTRL: Set source address to %08x\n",neocd_ctrl.addr_source);
1003      state->neocd_ctrl.addr_source = (state->neocd_ctrl.addr_source & 0x0000ffff) | (data << 16);
1004      logerror("CTRL: Set source address to %08x\n",state->neocd_ctrl.addr_source);
9861005      break;
9871006   case 0x66/2: // source address, low word
988      neocd_ctrl.addr_source = (neocd_ctrl.addr_source & 0xffff0000) | data;
989      logerror("CTRL: Set source address to %08x\n",neocd_ctrl.addr_source);
1007      state->neocd_ctrl.addr_source = (state->neocd_ctrl.addr_source & 0xffff0000) | data;
1008      logerror("CTRL: Set source address to %08x\n",state->neocd_ctrl.addr_source);
9901009      break;
9911010   case 0x68/2: // target address, high word
992      neocd_ctrl.addr_target = (neocd_ctrl.addr_target & 0x0000ffff) | (data << 16);
993      logerror("CTRL: Set target address to %08x\n",neocd_ctrl.addr_target);
1011      state->neocd_ctrl.addr_target = (state->neocd_ctrl.addr_target & 0x0000ffff) | (data << 16);
1012      logerror("CTRL: Set target address to %08x\n",state->neocd_ctrl.addr_target);
9941013      break;
9951014   case 0x6a/2: // target address, low word
996      neocd_ctrl.addr_target = (neocd_ctrl.addr_target & 0xffff0000) | data;
997      logerror("CTRL: Set target address to %08x\n",neocd_ctrl.addr_target);
1015      state->neocd_ctrl.addr_target = (state->neocd_ctrl.addr_target & 0xffff0000) | data;
1016      logerror("CTRL: Set target address to %08x\n",state->neocd_ctrl.addr_target);
9981017      break;
9991018   case 0x6c/2: // fill word
1000      neocd_ctrl.fill_word = data;
1019      state->neocd_ctrl.fill_word = data;
10011020      logerror("CTRL: Set fill word to %04x\n",data);
10021021      break;
10031022   case 0x70/2: // word count
1004      neocd_ctrl.word_count = (neocd_ctrl.word_count & 0x0000ffff) | (data << 16);
1005      logerror("CTRL: Set word count to %i\n",neocd_ctrl.word_count);
1023      state->neocd_ctrl.word_count = (state->neocd_ctrl.word_count & 0x0000ffff) | (data << 16);
1024      logerror("CTRL: Set word count to %i\n",state->neocd_ctrl.word_count);
10061025      break;
10071026   case 0x72/2: // word count (low word)
1008      neocd_ctrl.word_count = (neocd_ctrl.word_count & 0xffff0000) | data;
1009      logerror("CTRL: Set word count to %i\n",neocd_ctrl.word_count);
1027      state->neocd_ctrl.word_count = (state->neocd_ctrl.word_count & 0xffff0000) | data;
1028      logerror("CTRL: Set word count to %i\n",state->neocd_ctrl.word_count);
10101029      break;
10111030   case 0x7e/2:  // DMA parameters
10121031   case 0x80/2:
r9717r9718
10171036   case 0x8a/2:
10181037   case 0x8c/2:
10191038   case 0x8e/2:
1020      neocd_ctrl.dma_mode[offset-(0x7e/2)] = data;
1039      state->neocd_ctrl.dma_mode[offset-(0x7e/2)] = data;
10211040      logerror("CTRL: DMA parameter %i set to %04x\n",offset-(0x7e/2),data);
10221041      break;
10231042   case 0x104/2:
1024      neocd_ctrl.area_sel = data & 0x00ff;
1043      state->neocd_ctrl.area_sel = data & 0x00ff;
10251044      logerror("CTRL: 0xExxxxx set to area %i\n",data & 0xff);
10261045      break;
10271046   case 0x140/2:  // end sprite transfer
r9717r9718
10361055      video_reset_neogeo(space->machine);
10371056      break;
10381057   case 0x1a0/2:
1039      neocd_ctrl.spr_bank_sel = data & 0xff;
1058      state->neocd_ctrl.spr_bank_sel = data & 0xff;
10401059      logerror("CTRL: Sprite area set to bank %i\n",data & 0xff);
10411060      break;
10421061   case 0x1a2/2:
1043      neocd_ctrl.pcm_bank_sel = data & 0xff;
1062      state->neocd_ctrl.pcm_bank_sel = data & 0xff;
10441063      logerror("CTRL: PCM area set to bank %i\n",data & 0xff);
10451064      break;
10461065   default:
r9717r9718
10551074
10561075static READ16_HANDLER(neocd_transfer_r)
10571076{
1077   ng_aes_state *state = space->machine->driver_data<ng_aes_state>();
10581078   UINT16 ret = 0x0000;
10591079   UINT8* Z80 = memory_region(space->machine,"audiocpu");
10601080   UINT8* PCM = memory_region(space->machine,"ymsnd");
10611081   UINT8* FIX = memory_region(space->machine,"fixed");
10621082   UINT16* SPR = (UINT16*)memory_region(space->machine,"sprites");
10631083
1064   switch(neocd_ctrl.area_sel)
1084   switch(state->neocd_ctrl.area_sel)
10651085   {
10661086   case NEOCD_AREA_AUDIO:
10671087      ret = Z80[offset & 0xffff];
10681088      break;
10691089   case NEOCD_AREA_PCM:
1070      ret = PCM[offset + (0x100000*neocd_ctrl.pcm_bank_sel)];
1090      ret = PCM[offset + (0x100000*state->neocd_ctrl.pcm_bank_sel)];
10711091      break;
10721092   case NEOCD_AREA_SPR:
1073      ret = SPR[offset + (0x80000*neocd_ctrl.spr_bank_sel)];
1093      ret = SPR[offset + (0x80000*state->neocd_ctrl.spr_bank_sel)];
10741094      break;
10751095   case NEOCD_AREA_FIX:
10761096      ret = FIX[offset & 0x1ffff] | 0xff00;
r9717r9718
10821102
10831103static WRITE16_HANDLER(neocd_transfer_w)
10841104{
1105   ng_aes_state *state = space->machine->driver_data<ng_aes_state>();
10851106   UINT8* Z80 = memory_region(space->machine,"audiocpu");
10861107   UINT8* PCM = memory_region(space->machine,"ymsnd");
10871108   UINT8* FIX = memory_region(space->machine,"fixed");
10881109   UINT16* SPR = (UINT16*)memory_region(space->machine,"sprites");
10891110
1090   switch(neocd_ctrl.area_sel)
1111   switch(state->neocd_ctrl.area_sel)
10911112   {
10921113   case NEOCD_AREA_AUDIO:
10931114      Z80[offset & 0xffff] = data & 0xff;
10941115      break;
10951116   case NEOCD_AREA_PCM:
1096      PCM[offset + (0x100000*neocd_ctrl.pcm_bank_sel)] = data & 0xff;
1117      PCM[offset + (0x100000*state->neocd_ctrl.pcm_bank_sel)] = data & 0xff;
10971118      break;
10981119   case NEOCD_AREA_SPR:
1099      COMBINE_DATA(SPR+(offset + (0x80000*neocd_ctrl.spr_bank_sel)));
1120      COMBINE_DATA(SPR+(offset + (0x80000*state->neocd_ctrl.spr_bank_sel)));
11001121      break;
11011122   case NEOCD_AREA_FIX:
11021123      FIX[offset & 0x1ffff] = data & 0xff;
r9717r9718
12521273
12531274static MACHINE_START( neogeo )
12541275{
1276   ng_aes_state *state = machine->driver_data<ng_aes_state>();
12551277   common_machine_start(machine);
12561278
12571279   /* initialize the memcard data structure */
1258   memcard_data = auto_alloc_array_clear(machine, UINT8, MEMCARD_SIZE);
1259   state_save_register_global_pointer(machine, memcard_data, 0x0800);
1280   state->memcard_data = auto_alloc_array_clear(machine, UINT8, MEMCARD_SIZE);
1281   state_save_register_global_pointer(machine, state->memcard_data, 0x0800);
12601282}
12611283
12621284static MACHINE_START(neocd)
12631285{
1286   ng_aes_state *state = machine->driver_data<ng_aes_state>();
12641287   UINT8* ROM = memory_region(machine,"mainbios");
12651288   UINT8* RAM = memory_region(machine,"maincpu");
12661289   UINT8* Z80bios = memory_region(machine,"audiobios");
r9717r9718
12711294
12721295   /* initialize the memcard data structure */
12731296   /* NeoCD doesn't have memcard slots, rather, it has a larger internal memory which works the same */
1274   memcard_data = auto_alloc_array_clear(machine, UINT8, 0x2000);
1275   state_save_register_global_pointer(machine, memcard_data, 0x2000);
1297   state->memcard_data = auto_alloc_array_clear(machine, UINT8, 0x2000);
1298   state_save_register_global_pointer(machine, state->memcard_data, 0x2000);
12761299
12771300   // copy initial 68k vectors into RAM
12781301   memcpy(RAM,ROM,0x80);
r9717r9718
16831706 *
16841707 *************************************/
16851708
1686static MACHINE_CONFIG_START( neogeo, neogeo_state )
1709static MACHINE_CONFIG_START( neogeo, ng_aes_state )
16871710
16881711   /* basic machine hardware */
16891712   MDRV_CPU_ADD("maincpu", M68000, NEOGEO_MAIN_CPU_CLOCK)

Previous 15994 Revisions Next


© 1998-2018 The MESS Team