Previous

15994 Revisions

Next

r4095 Thursday 8th January, 2009 at 13:54:15 UTC by Miodrag Milanović
[AT45DBXX][SST39VFX] Converted to device

[docs]	messnew.txt
[src/mess/drivers]	cybiko.c
[src/mess/machine]	at45dbxx.c at45dbxx.h cybiko.c sst39vfx.c sst39vfx.h

src/mess/machine/at45dbxx.c

r4094	r4095
12	12
13	13	#include "at45dbxx.h"
14	14
	15	enum
	16	{
	17	TYPE_AT45DB041,
	18	TYPE_AT45DB081,
	19	TYPE_AT45DB161
	20	};
	21
15	22	#define LOG_LEVEL  1
16	23	#define _logerror(level,x)  do { if (LOG_LEVEL > level) logerror x; } while (0)
17	24
r4094	r4095
24	31	#define FLASH_MODE_SI  1 // input
25	32	#define FLASH_MODE_SO  2 // output
26	33
	34
	35	/***************************************************************************
	36	TYPE DEFINITIONS
	37	***************************************************************************/
	38
27	39	typedef struct
28	40	{
29	41	int cs;    // chip select
r4094	r4095
46	58	UINT32 size, pos;
47	59	} AT45DBXX_IO;
48	60
49		typedef struct
	61	typedef struct _at45dbxx_t at45dbxx_t;
	62	struct _at45dbxx_t
50	63	{
51	64	UINT8 *data;
52	65	UINT32 size;
r4094	r4095
56	69	UINT8 si_byte, si_bits, so_byte, so_bits;
57	70	AT45DBXX_CMD cmd;
58	71	AT45DBXX_IO io;
59		} AT45DBXX;
	72	};
60	73
61		static AT45DBXX flash;
62	74
63		static void at45dbxx_state_save(running_machine *machine);
64		static void at45dbxx_reset(running_machine *machine);
	75	/***************************************************************************
	76	INLINE FUNCTIONS
	77	***************************************************************************/
65	78
66		void at45dbxx_init(running_machine *machine, int type)
	79	INLINE at45dbxx_t *get_token(const device_config *device)
67	80	{
68		_logerror( 0, ("at45dbxx_init (%d)\n", type));
69		memset( &flash, 0, sizeof( flash));
70		switch (type)
	81	assert(device != NULL);
	82	return (at45dbxx_t *) device->token;
	83	}
	84
	85
	86	/***************************************************************************
	87	IMPLEMENTATION
	88	***************************************************************************/
	89
	90	static device_start_err common_start(const device_config *device, int device_type)
	91	{
	92	at45dbxx_t *flash = get_token(device);
	93
	94	_logerror( 0, ("at45dbxx_init (%d)\n", device_type));
	95	memset( flash, 0, sizeof( flash));
	96	switch (device_type)
71	97	{
72		case AT45DB041 : flash.pages = 2048; flash.page_size = 264; flash.devid = 0x18; break;
73		case AT45DB081 : flash.pages = 4096; flash.page_size = 264; flash.devid = 0x20; break;
74		case AT45DB161 : flash.pages = 4096; flash.page_size = 528; flash.devid = 0x28; break;
	98	case TYPE_AT45DB041 : flash->pages = 2048; flash->page_size = 264; flash->devid = 0x18; break;
	99	case TYPE_AT45DB081 : flash->pages = 4096; flash->page_size = 264; flash->devid = 0x20; break;
	100	case TYPE_AT45DB161 : flash->pages = 4096; flash->page_size = 528; flash->devid = 0x28; break;
75	101	}
76		flash.size = flash.pages * flash.page_size;
77		flash.data = auto_malloc( flash.size);
78		flash.buffer1 = auto_malloc( flash.page_size);
79		flash.buffer2 = auto_malloc( flash.page_size);
80		at45dbxx_state_save(machine);
	102	flash->size = flash->pages * flash->page_size;
	103	flash->data = auto_malloc( flash->size);
	104	flash->buffer1 = auto_malloc( flash->page_size);
	105	flash->buffer2 = auto_malloc( flash->page_size);
	106
	107	// data
	108	state_save_register_item_pointer(device->machine, "at45dbxx", device->tag, 0, flash->data, flash->size);
	109	// pins
	110	state_save_register_item(device->machine, "at45dbxx", device->tag, 0, flash->pin.cs);
	111	state_save_register_item(device->machine, "at45dbxx", device->tag, 0, flash->pin.sck);
	112	state_save_register_item(device->machine, "at45dbxx", device->tag, 0, flash->pin.si);
	113	state_save_register_item(device->machine, "at45dbxx", device->tag, 0, flash->pin.so);
	114	state_save_register_item(device->machine, "at45dbxx", device->tag, 0, flash->pin.wp);
	115	state_save_register_item(device->machine, "at45dbxx", device->tag, 0, flash->pin.reset);
	116	state_save_register_item(device->machine, "at45dbxx", device->tag, 0, flash->pin.busy);
	117	return DEVICE_START_OK;
	118	}
81	119
82		add_reset_callback(machine, at45dbxx_reset);
	120	static DEVICE_START( at45db041 )
	121	{
	122	return common_start(device, TYPE_AT45DB041);
83	123	}
84	124
85		static void at45dbxx_reset(running_machine *machine)
	125	static DEVICE_START( at45db081 )
86	126	{
	127	return common_start(device, TYPE_AT45DB081);
	128	}
	129
	130	static DEVICE_START( at45db161 )
	131	{
	132	return common_start(device, TYPE_AT45DB161);
	133	}
	134
	135	static DEVICE_RESET( at45dbxx )
	136	{
	137	at45dbxx_t *flash = get_token(device);
87	138	_logerror( 1, ("at45dbxx_reset\n"));
88	139	// mode
89		flash.mode = FLASH_MODE_SI;
	140	flash->mode = FLASH_MODE_SI;
90	141	// command
91		memset( &flash.cmd.data[0], 0, sizeof( flash.cmd.data));
92		flash.cmd.size = 0;
	142	memset( &flash->cmd.data[0], 0, sizeof( flash->cmd.data));
	143	flash->cmd.size = 0;
93	144	// input/output
94		flash.io.data = NULL;
95		flash.io.size = 0;
96		flash.io.pos  = 0;
	145	flash->io.data = NULL;
	146	flash->io.size = 0;
	147	flash->io.pos  = 0;
97	148	// pins
98		flash.pin.cs    = 0;
99		flash.pin.sck   = 0;
100		flash.pin.si    = 0;
101		flash.pin.so    = 0;
102		flash.pin.wp    = 0;
103		flash.pin.reset = 0;
104		flash.pin.busy  = 0;
	149	flash->pin.cs    = 0;
	150	flash->pin.sck   = 0;
	151	flash->pin.si    = 0;
	152	flash->pin.so    = 0;
	153	flash->pin.wp    = 0;
	154	flash->pin.reset = 0;
	155	flash->pin.busy  = 0;
105	156	// output
106		flash.so_byte = 0;
107		flash.so_bits = 0;
	157	flash->so_byte = 0;
	158	flash->so_bits = 0;
108	159	// input
109		flash.si_byte = 0;
110		flash.si_bits = 0;
	160	flash->si_byte = 0;
	161	flash->si_bits = 0;
111	162	}
112	163
113		static void at45dbxx_state_save(running_machine *machine)
	164	static UINT8 at45dbxx_read_byte( const device_config *device)
114	165	{
115		const char *name = "at45dbxx";
116		// data
117		state_save_register_item_pointer(machine, name, NULL, 0, flash.data, flash.size);
118		// pins
119		state_save_register_item(machine, name, NULL, 0, flash.pin.cs);
120		state_save_register_item(machine, name, NULL, 0, flash.pin.sck);
121		state_save_register_item(machine, name, NULL, 0, flash.pin.si);
122		state_save_register_item(machine, name, NULL, 0, flash.pin.so);
123		state_save_register_item(machine, name, NULL, 0, flash.pin.wp);
124		state_save_register_item(machine, name, NULL, 0, flash.pin.reset);
125		state_save_register_item(machine, name, NULL, 0, flash.pin.busy);
126		}
127
128		static UINT8 at45dbxx_read_byte( running_machine *machine)
129		{
130	166	UINT8 data;
	167	at45dbxx_t *flash = get_token(device);
131	168	// check mode
132		if ((flash.mode != FLASH_MODE_SO) || (!flash.io.data)) return 0;
	169	if ((flash->mode != FLASH_MODE_SO) || (!flash->io.data)) return 0;
133	170	// read byte
134		data = flash.io.data[flash.io.pos++];
135		_logerror( 2, ("at45dbxx_read_byte (%02X) (%03d/%03d)\n", data, flash.io.pos, flash.io.size));
136		if (flash.io.pos == flash.io.size) flash.io.pos = 0;
	171	data = flash->io.data[flash->io.pos++];
	172	_logerror( 2, ("at45dbxx_read_byte (%02X) (%03d/%03d)\n", data, flash->io.pos, flash->io.size));
	173	if (flash->io.pos == flash->io.size) flash->io.pos = 0;
137	174	return data;
138	175	}
139	176
140		static void flash_set_io( running_machine *machine, UINT8* data, UINT32 size, UINT32 pos)
	177	static void flash_set_io( const device_config *device, UINT8* data, UINT32 size, UINT32 pos)
141	178	{
142		flash.io.data = data;
143		flash.io.size = size;
144		flash.io.pos  = pos;
	179	at45dbxx_t *flash = get_token(device);
	180	flash->io.data = data;
	181	flash->io.size = size;
	182	flash->io.pos  = pos;
145	183	}
146	184
147		static UINT32 flash_get_page_addr( running_machine *machine)
	185	static UINT32 flash_get_page_addr( const device_config *device)
148	186	{
149		switch (flash.devid)
	187	at45dbxx_t *flash = get_token(device);
	188	switch (flash->devid)
150	189	{
151		case 0x18 : return ((flash.cmd.data[1] & 0x0F) << 7) | ((flash.cmd.data[2] & 0xFE) >> 1);
152		case 0x20 : return ((flash.cmd.data[1] & 0x1F) << 7) | ((flash.cmd.data[2] & 0xFE) >> 1);
153		case 0x28 : return ((flash.cmd.data[1] & 0x3F) << 6) | ((flash.cmd.data[2] & 0xFC) >> 2);
	190	case 0x18 : return ((flash->cmd.data[1] & 0x0F) << 7) | ((flash->cmd.data[2] & 0xFE) >> 1);
	191	case 0x20 : return ((flash->cmd.data[1] & 0x1F) << 7) | ((flash->cmd.data[2] & 0xFE) >> 1);
	192	case 0x28 : return ((flash->cmd.data[1] & 0x3F) << 6) | ((flash->cmd.data[2] & 0xFC) >> 2);
154	193	default   : return 0;
155	194	}
156	195	}
157	196
158		static UINT32 flash_get_byte_addr( running_machine *machine)
	197	static UINT32 flash_get_byte_addr( const device_config *device)
159	198	{
160		switch (flash.devid)
	199	at45dbxx_t *flash = get_token(device);
	200	switch (flash->devid)
161	201	{
162	202	case 0x18 : // fall-through
163		case 0x20 : return ((flash.cmd.data[2] & 0x01) << 8) | ((flash.cmd.data[3] & 0xFF) >> 0);
164		case 0x28 : return ((flash.cmd.data[2] & 0x03) << 8) | ((flash.cmd.data[3] & 0xFF) >> 0);
	203	case 0x20 : return ((flash->cmd.data[2] & 0x01) << 8) | ((flash->cmd.data[3] & 0xFF) >> 0);
	204	case 0x28 : return ((flash->cmd.data[2] & 0x03) << 8) | ((flash->cmd.data[3] & 0xFF) >> 0);
165	205	default   : return 0;
166	206	}
167	207	}
168	208
169		static void at45dbxx_write_byte(running_machine *machine,  UINT8 data)
	209	static void at45dbxx_write_byte(const device_config *device,  UINT8 data)
170	210	{
	211	at45dbxx_t *flash = get_token(device);
171	212	// check mode
172		if (flash.mode != FLASH_MODE_SI) return;
	213	if (flash->mode != FLASH_MODE_SI) return;
173	214	// process byte
174		if (flash.cmd.size < 8)
	215	if (flash->cmd.size < 8)
175	216	{
176	217	UINT8 opcode;
177	218	_logerror( 2, ("at45dbxx_write_byte (%02X)\n", data));
178	219	// add to command buffer
179		flash.cmd.data[flash.cmd.size++] = data;
	220	flash->cmd.data[flash->cmd.size++] = data;
180	221	// check opcode
181		opcode = flash.cmd.data[0];
	222	opcode = flash->cmd.data[0];
182	223	switch (opcode)
183	224	{
184	225	// status register read
185	226	case FLASH_CMD_57 :
186	227	{
187	228	// 8 bits command
188		if (flash.cmd.size == 1)
	229	if (flash->cmd.size == 1)
189	230	{
190	231	_logerror( 1, ("at45dbxx opcode %02X - status register read\n", opcode));
191		flash.status = (flash.status & 0xC7) | flash.devid; // 80 = busy / 40 = compare fail
192		flash_set_io( machine, &flash.status, 1, 0);
193		flash.mode = FLASH_MODE_SO;
194		flash.cmd.size = 8;
	232	flash->status = (flash->status & 0xC7) | flash->devid; // 80 = busy / 40 = compare fail
	233	flash_set_io( device, &flash->status, 1, 0);
	234	flash->mode = FLASH_MODE_SO;
	235	flash->cmd.size = 8;
195	236	}
196	237	}
197	238	break;
r4094	r4095
199	240	case FLASH_CMD_60 :
200	241	{
201	242	// 8 bits command + 4 bits reserved + 11 bits page address + 9 bits don't care
202		if (flash.cmd.size == 4)
	243	if (flash->cmd.size == 4)
203	244	{
204	245	UINT32 page;
205	246	UINT8 comp;
206		page = flash_get_page_addr(machine);
	247	page = flash_get_page_addr(device);
207	248	_logerror( 1, ("at45dbxx opcode %02X - main memory page to buffer 1 compare [%04X]\n", opcode, page));
208		comp = memcmp( flash.data + page * flash.page_size, flash.buffer1, flash.page_size) == 0 ? 0 : 1;
209		if (comp) flash.status |= 0x40; else flash.status &= ~0x40;
	249	comp = memcmp( flash->data + page * flash->page_size, flash->buffer1, flash->page_size) == 0 ? 0 : 1;
	250	if (comp) flash->status |= 0x40; else flash->status &= ~0x40;
210	251	_logerror( 1, ("at45dbxx page compare %s\n", comp ? "failure" : "success"));
211		flash.mode = FLASH_MODE_SI;
212		flash.cmd.size = 8;
	252	flash->mode = FLASH_MODE_SI;
	253	flash->cmd.size = 8;
213	254	}
214	255	}
215	256	break;
r4094	r4095
217	258	case FLASH_CMD_52 :
218	259	{
219	260	// 8 bits command + 4 bits reserved + 11 bits page address + 9 bits buffer address + 32 bits don't care
220		if (flash.cmd.size == 8)
	261	if (flash->cmd.size == 8)
221	262	{
222	263	UINT32 page, byte;
223		page = flash_get_page_addr(machine);
224		byte = flash_get_byte_addr(machine);
	264	page = flash_get_page_addr(device);
	265	byte = flash_get_byte_addr(device);
225	266	_logerror( 1, ("at45dbxx opcode %02X - main memory page read [%04X/%04X]\n", opcode, page, byte));
226		flash_set_io( machine, flash.data + page * flash.page_size, flash.page_size, byte);
227		flash.mode = FLASH_MODE_SO;
228		flash.cmd.size = 8;
	267	flash_set_io( device, flash->data + page * flash->page_size, flash->page_size, byte);
	268	flash->mode = FLASH_MODE_SO;
	269	flash->cmd.size = 8;
229	270	}
230	271	}
231	272	break;
r4094	r4095
233	274	case FLASH_CMD_82 :
234	275	{
235	276	// 8 bits command + 4 bits reserved + 11 bits page address + 9 bits buffer address
236		if (flash.cmd.size == 4)
	277	if (flash->cmd.size == 4)
237	278	{
238	279	UINT32 page, byte;
239		page = flash_get_page_addr(machine);
240		byte = flash_get_byte_addr(machine);
	280	page = flash_get_page_addr(device);
	281	byte = flash_get_byte_addr(device);
241	282	_logerror( 1, ("at45dbxx opcode %02X - main memory page program through buffer 1 [%04X/%04X]\n",opcode, page, byte));
242		flash_set_io( machine, flash.buffer1, flash.page_size, byte);
243		memset( flash.buffer1, 0xFF, flash.page_size);
244		flash.mode = FLASH_MODE_SI;
245		flash.cmd.size = 8;
	283	flash_set_io( device, flash->buffer1, flash->page_size, byte);
	284	memset( flash->buffer1, 0xFF, flash->page_size);
	285	flash->mode = FLASH_MODE_SI;
	286	flash->cmd.size = 8;
246	287	}
247	288	}
248	289	break;
r4094	r4095
250	291	default :
251	292	{
252	293	_logerror( 1, ("at45dbxx opcode %02X - unknown\n", opcode));
253		flash.cmd.data[0] = 0;
254		flash.cmd.size = 0;
	294	flash->cmd.data[0] = 0;
	295	flash->cmd.size = 0;
255	296	}
256	297	break;
257	298	}
258	299	}
259	300	else
260	301	{
261		_logerror( 2, ("at45dbxx_write_byte (%02X) (%03d/%03d)\n", data, flash.io.pos + 1, flash.io.size));
	302	_logerror( 2, ("at45dbxx_write_byte (%02X) (%03d/%03d)\n", data, flash->io.pos + 1, flash->io.size));
262	303	// store byte
263		flash.io.data[flash.io.pos] = data;
264		flash.io.pos++;
265		if (flash.io.pos == flash.io.size) flash.io.pos = 0;
	304	flash->io.data[flash->io.pos] = data;
	305	flash->io.pos++;
	306	if (flash->io.pos == flash->io.size) flash->io.pos = 0;
266	307	}
267	308	}
268	309
269		int at45dbxx_pin_so( running_machine *machine)
	310	int at45dbxx_pin_so( const device_config *device)
270	311	{
271		if (flash.pin.cs == 0) return 0;
272		return flash.pin.so;
	312	at45dbxx_t *flash = get_token(device);
	313	if (flash->pin.cs == 0) return 0;
	314	return flash->pin.so;
273	315	}
274	316
275		void at45dbxx_pin_si(running_machine *machine,  int data)
	317	void at45dbxx_pin_si(const device_config *device,  int data)
276	318	{
277		if (flash.pin.cs == 0) return;
278		flash.pin.si = data;
	319	at45dbxx_t *flash = get_token(device);
	320	if (flash->pin.cs == 0) return;
	321	flash->pin.si = data;
279	322	}
280	323
281		void at45dbxx_pin_cs(running_machine *machine,  int data)
	324	void at45dbxx_pin_cs(const device_config *device,  int data)
282	325	{
	326	at45dbxx_t *flash = get_token(device);
283	327	// check if changed
284		if (flash.pin.cs == data) return;
	328	if (flash->pin.cs == data) return;
285	329	// cs low-to-high
286	330	if (data != 0)
287	331	{
288	332	// complete program command
289		if ((flash.cmd.size >= 4) && (flash.cmd.data[0] == FLASH_CMD_82))
	333	if ((flash->cmd.size >= 4) && (flash->cmd.data[0] == FLASH_CMD_82))
290	334	{
291	335	UINT32 page, byte;
292		page = flash_get_page_addr(machine);
293		byte = flash_get_byte_addr(machine);
	336	page = flash_get_page_addr(device);
	337	byte = flash_get_byte_addr(device);
294	338	_logerror( 1, ("at45dbxx - program data stored in buffer 1 into selected page in main memory [%04X/%04X]\n", page, byte));
295		memcpy( flash.data + page * flash.page_size, flash.buffer1, flash.page_size);
	339	memcpy( flash->data + page * flash->page_size, flash->buffer1, flash->page_size);
296	340	}
297	341	// reset
298		at45dbxx_reset(machine);
	342	device_reset_at45dbxx(device);
299	343	}
300	344	// save cs
301		flash.pin.cs = data;
	345	flash->pin.cs = data;
302	346	}
303	347
304		void at45dbxx_pin_sck(running_machine *machine,  int data)
	348	void at45dbxx_pin_sck(const device_config *device,  int data)
305	349	{
	350	at45dbxx_t *flash = get_token(device);
306	351	// check if changed
307		if (flash.pin.sck == data) return;
	352	if (flash->pin.sck == data) return;
308	353	// sck high-to-low
309	354	if (data == 0)
310	355	{
311	356	// output (part 1)
312		if (flash.so_bits == 8)
	357	if (flash->so_bits == 8)
313	358	{
314		flash.so_bits = 0;
315		flash.so_byte = at45dbxx_read_byte(machine);
	359	flash->so_bits = 0;
	360	flash->so_byte = at45dbxx_read_byte(device);
316	361	}
317	362	// input
318		if (flash.pin.si) flash.si_byte = flash.si_byte | (1 << flash.si_bits);
319		flash.si_bits++;
320		if (flash.si_bits == 8)
	363	if (flash->pin.si) flash->si_byte = flash->si_byte | (1 << flash->si_bits);
	364	flash->si_bits++;
	365	if (flash->si_bits == 8)
321	366	{
322		flash.si_bits = 0;
323		at45dbxx_write_byte( machine, flash.si_byte);
324		flash.si_byte = 0;
	367	flash->si_bits = 0;
	368	at45dbxx_write_byte( device, flash->si_byte);
	369	flash->si_byte = 0;
325	370	}
326	371	// output (part 2)
327		flash.pin.so = (flash.so_byte >> flash.so_bits) & 1;
328		flash.so_bits++;
	372	flash->pin.so = (flash->so_byte >> flash->so_bits) & 1;
	373	flash->so_bits++;
329	374	}
330	375	// save sck
331		flash.pin.sck = data;
	376	flash->pin.sck = data;
332	377	}
333	378
334		void at45dbxx_load(running_machine *machine, mame_file *file)
	379	void at45dbxx_load(const device_config *device, mame_file *file)
335	380	{
	381	at45dbxx_t *flash = get_token(device);
336	382	_logerror( 0, ("at45dbxx_load (%p)\n", file));
337		mame_fread( file, flash.data, flash.size);
	383	mame_fread( file, flash->data, flash->size);
338	384	}
339	385
340		void at45dbxx_save(running_machine *machine, mame_file *file)
	386	void at45dbxx_save(const device_config *device, mame_file *file)
341	387	{
	388	at45dbxx_t *flash = get_token(device);
342	389	_logerror( 0, ("at45dbxx_save (%p)\n", file));
343		mame_fwrite( file, flash.data, flash.size);
	390	mame_fwrite( file, flash->data, flash->size);
344	391	}
345	392
346	393	/*
r4094	r4095
359	406	}
360	407	else
361	408	{
362		memset( flash.data, 0xFF, flash.size);
	409	memset( flash->data, 0xFF, flash->size);
363	410	}
364	411	}
365	412	}
366	413	*/
	414
	415
	416	/*-------------------------------------------------
	417	DEVICE_SET_INFO( at45dbxx )
	418	-------------------------------------------------*/
	419
	420	static DEVICE_SET_INFO( at45dbxx )
	421	{
	422	switch (state)
	423	{
	424	/* no parameters to set */
	425	}
	426	}
	427
	428
	429
	430	/*-------------------------------------------------
	431	DEVICE_GET_INFO( at45db041 )
	432	-------------------------------------------------*/
	433
	434	DEVICE_GET_INFO( at45db041 )
	435	{
	436	switch (state)
	437	{
	438	/* --- the following bits of info are returned as 64-bit signed integers --- */
	439	case DEVINFO_INT_TOKEN_BYTES:               info->i = sizeof(at45dbxx_t);            break;
	440	case DEVINFO_INT_INLINE_CONFIG_BYTES:         info->i = 0;                        break;
	441	case DEVINFO_INT_CLASS:                     info->i = DEVICE_CLASS_PERIPHERAL;         break;
	442
	443	/* --- the following bits of info are returned as pointers to data or functions --- */
	444	case DEVINFO_FCT_SET_INFO:                  info->set_info = DEVICE_SET_INFO_NAME(at45dbxx); break;
	445	case DEVINFO_FCT_START:                     info->start = DEVICE_START_NAME(at45db041);   break;
	446	case DEVINFO_FCT_STOP:                     /* Nothing */                        break;
	447	case DEVINFO_FCT_RESET:                     info->reset = DEVICE_RESET_NAME(at45dbxx);   break;
	448
	449	/* --- the following bits of info are returned as NULL-terminated strings --- */
	450	case DEVINFO_STR_NAME:                     strcpy(info->s, "AT45DB041");               break;
	451	case DEVINFO_STR_FAMILY:                  strcpy(info->s, "AT45DBxx");               break;
	452	case DEVINFO_STR_VERSION:                  strcpy(info->s, "1.0");                     break;
	453	case DEVINFO_STR_SOURCE_FILE:               strcpy(info->s, __FILE__);                  break;
	454	case DEVINFO_STR_CREDITS:                  /* Nothing */                        break;
	455	}
	456	}
	457
	458	DEVICE_GET_INFO( at45db081 )
	459	{
	460	switch (state)
	461	{
	462	/* --- the following bits of info are returned as NULL-terminated strings --- */
	463	case DEVINFO_STR_NAME:                     strcpy(info->s, "AT45DB081");            break;
	464
	465	/* --- the following bits of info are returned as pointers to data or functions --- */
	466	case DEVINFO_FCT_START:                     info->start = DEVICE_START_NAME(at45db081);   break;
	467
	468	default:                               DEVICE_GET_INFO_CALL(at45db041);            break;
	469	}
	470	}
	471
	472	DEVICE_GET_INFO( at45db161 )
	473	{
	474	switch (state)
	475	{
	476	/* --- the following bits of info are returned as NULL-terminated strings --- */
	477	case DEVINFO_STR_NAME:                     strcpy(info->s, "AT45DB161");            break;
	478
	479	/* --- the following bits of info are returned as pointers to data or functions --- */
	480	case DEVINFO_FCT_START:                     info->start = DEVICE_START_NAME(at45db161);   break;
	481
	482	default:                               DEVICE_GET_INFO_CALL(at45db041);            break;
	483	}
	484	}

src/mess/machine/at45dbxx.h

r4094	r4095
15	15
16	16	#include "driver.h"
17	17
18		enum
19		{
20		AT45DB041,
21		AT45DB081,
22		AT45DB161
23		};
24	18
25		// init/exit/reset
26		void at45dbxx_init(running_machine *machine, int type);
	19	/***************************************************************************
	20	MACROS
	21	***************************************************************************/
27	22
	23	#define AT45DB041      DEVICE_GET_INFO_NAME(at45db041)
	24
	25	#define MDRV_AT45DB041_ADD(_tag) \
	26	MDRV_DEVICE_ADD(_tag, AT45DB041, 0) \
	27
	28	#define MDRV_AT45DB041_REMOVE(_tag) \
	29	MDRV_DEVICE_REMOVE(_tag, AT45DB041)
	30
	31	#define AT45DB081      DEVICE_GET_INFO_NAME(at45db081)
	32
	33	#define MDRV_AT45DB081_ADD(_tag) \
	34	MDRV_DEVICE_ADD(_tag, AT45DB081, 0) \
	35
	36	#define MDRV_AT45DB081_REMOVE(_tag) \
	37	MDRV_DEVICE_REMOVE(_tag, AT45DB081)
	38
	39	#define AT45DB161      DEVICE_GET_INFO_NAME(at45db161)
	40
	41	#define MDRV_AT45DB161_ADD(_tag) \
	42	MDRV_DEVICE_ADD(_tag, AT45DB161, 0) \
	43
	44	#define MDRV_AT45DB161_REMOVE(_tag) \
	45	MDRV_DEVICE_REMOVE(_tag, AT45DB161)
	46
	47
	48	/***************************************************************************
	49	FUNCTION PROTOTYPES
	50	***************************************************************************/
	51
	52	DEVICE_GET_INFO(at45db041);
	53	DEVICE_GET_INFO(at45db081);
	54	DEVICE_GET_INFO(at45db161);
	55
28	56	// pins
29		void at45dbxx_pin_cs(running_machine *machine,  int data);
30		void at45dbxx_pin_sck(running_machine *machine,  int data);
31		void at45dbxx_pin_si(running_machine *machine,  int data);
32		int  at45dbxx_pin_so(running_machine *machine);
	57	void at45dbxx_pin_cs(const device_config *device, int data);
	58	void at45dbxx_pin_sck(const device_config *device,  int data);
	59	void at45dbxx_pin_si(const device_config *device,  int data);
	60	int  at45dbxx_pin_so(const device_config *device);
33	61
34	62	// load/save
35		void at45dbxx_load(running_machine *machine, mame_file *file);
36		void at45dbxx_save(running_machine *machine, mame_file *file);
	63	void at45dbxx_load(const device_config *device, mame_file *file);
	64	void at45dbxx_save(const device_config *device, mame_file *file);
37	65
38	66	// non-volatile ram handler
39	67	/*

src/mess/machine/sst39vfx.c

r4094	r4095
14	14	#define LOG_LEVEL  1
15	15	#define _logerror(level,x)  do { if (LOG_LEVEL > level) logerror x; } while (0)
16	16
17		typedef struct
	17	/***************************************************************************
	18	TYPE DEFINITIONS
	19	***************************************************************************/
	20
	21	typedef struct _sst39vfx_t sst39vfx_t;
	22	struct _sst39vfx_t
18	23	{
19	24	UINT8 *data;
20	25	UINT32 size;
21	26	UINT8 swap;
22		} SST39VFX;
	27	};
23	28
24		static SST39VFX flash;
	29	enum
	30	{
	31	TYPE_SST39VF020,
	32	TYPE_SST39VF400A
	33	};
25	34
26		static void sst39vfx_state_save(running_machine *machine);
	35	/***************************************************************************
	36	INLINE FUNCTIONS
	37	***************************************************************************/
27	38
28		void sst39vfx_init(running_machine *machine, int type, int cpu_datawidth, int cpu_endianess)
	39	INLINE sst39vfx_t *get_token(const device_config *device)
29	40	{
30		_logerror( 0, ("sst39vfx_init (%d)\n", type));
31		memset( &flash, 0, sizeof( flash));
32		switch (type)
	41	assert(device != NULL);
	42	return (sst39vfx_t *) device->token;
	43	}
	44
	45	INLINE const sst39vfx_config *get_config(const device_config *device)
	46	{
	47	assert(device != NULL);
	48	return (const sst39vfx_config *) device->inline_config;
	49	}
	50
	51
	52	/***************************************************************************
	53	IMPLEMENTATION
	54	***************************************************************************/
	55
	56	static device_start_err common_start(const device_config *device, int device_type)
	57	{
	58	sst39vfx_t *flash = get_token(device);
	59	const sst39vfx_config *config = get_config(device);
	60
	61	_logerror( 0, ("sst39vfx_init (%d)\n", device_type));
	62	memset( flash, 0, sizeof( flash));
	63	switch (device_type)
33	64	{
34		case SST39VF020  : flash.size = 256 * 1024; break;
35		case SST39VF400A : flash.size = 512 * 1024; break;
	65	case TYPE_SST39VF020  : flash->size = 256 * 1024; break;
	66	case TYPE_SST39VF400A : flash->size = 512 * 1024; break;
36	67	}
37		flash.data = auto_malloc( flash.size);
	68	flash->data = auto_malloc( flash->size);
38	69	#ifdef LSB_FIRST
39		if (cpu_endianess != ENDIANNESS_LITTLE) flash.swap = cpu_datawidth / 8; else flash.swap = 0;
	70	if (config->cpu_endianess != ENDIANNESS_LITTLE) flash->swap = config->cpu_datawidth / 8; else flash->swap = 0;
40	71	#else
41		if (cpu_endianess != ENDIANNESS_BIG) flash.swap = cpu_datawidth / 8; else flash.swap = 0;
	72	if (config->cpu_endianess != ENDIANNESS_BIG) flash->swap = config->cpu_datawidth / 8; else flash->swap = 0;
42	73	#endif
43		sst39vfx_state_save(machine);
	74
	75	state_save_register_item_pointer(device->machine, "sst39vfx", device->tag, 0, flash->data, flash->size);
	76	state_save_register_item(device->machine, "sst39vfx", device->tag, 0, flash->swap);
	77
	78	return DEVICE_START_OK;
44	79	}
45	80
46		static void sst39vfx_state_save(running_machine *machine)
	81
	82	static DEVICE_START( sst39vf020 )
47	83	{
48		const char *name = "sst39vfx";
49		state_save_register_item_pointer(machine, name, NULL, 0, flash.data, flash.size);
50		state_save_register_item(machine, name, NULL, 0, flash.swap);
	84	return common_start(device, TYPE_SST39VF020);
51	85	}
52	86
53		UINT8* sst39vfx_get_base( void)
	87	static DEVICE_START( sst39vf400a )
54	88	{
55		return flash.data;
	89	return common_start(device, TYPE_SST39VF400A);
56	90	}
57	91
58		UINT32 sst39vfx_get_size( void)
	92	UINT8* sst39vfx_get_base( const device_config *device)
59	93	{
60		return flash.size;
	94	sst39vfx_t *flash = get_token(device);
	95	return flash->data;
61	96	}
62	97
	98	UINT32 sst39vfx_get_size( const device_config *device)
	99	{
	100	sst39vfx_t *flash = get_token(device);
	101	return flash->size;
	102	}
	103
63	104	/*
64	105	#define OFFSET_SWAP(offset,width) (offset & (~(width - 1))) | (width - 1 - (offset & (width - 1)))
65	106	*/
r4094	r4095
68	109	READ8_HANDLER( sst39vfx_r )
69	110	{
70	111	_logerror( 1, ("sst39vfx_r (%08X)\n", offset));
71		if (flash.swap) offset = OFFSET_SWAP( offset, flash.swap);
72		return flash.data[offset];
	112	if (flash->swap) offset = OFFSET_SWAP( offset, flash->swap);
	113	return flash->data[offset];
73	114	}
74	115	*/
75	116
r4094	r4095
77	118	WRITE8_HANDLER( sst39vfx_w )
78	119	{
79	120	_logerror( 1, ("sst39vfx_w (%08X/%02X)\n", offset, data));
80		if (flash.swap) offset = OFFSET_SWAP( offset, flash.swap);
81		flash.data[offset] = data;
	121	if (flash->swap) offset = OFFSET_SWAP( offset, flash->swap);
	122	flash->data[offset] = data;
82	123	}
83	124	*/
84	125
85		static void sst39vfx_swap( void)
	126	static void sst39vfx_swap( const device_config *device)
86	127	{
87	128	int i, j;
88	129	UINT8 *base, temp[8];
89		base = flash.data;
90		for (i=0;i<flash.size;i+=flash.swap)
	130	sst39vfx_t *flash = get_token(device);
	131
	132	base = flash->data;
	133	for (i=0;i<flash->size;i+=flash->swap)
91	134	{
92		memcpy( temp, base, flash.swap);
93		for (j=flash.swap-1;j>=0;j--) *base++ = temp[j];
	135	memcpy( temp, base, flash->swap);
	136	for (j=flash->swap-1;j>=0;j--) *base++ = temp[j];
94	137	}
95	138	}
96	139
97		void sst39vfx_load(running_machine *machine, mame_file *file)
	140	void sst39vfx_load(const device_config *device, mame_file *file)
98	141	{
	142	sst39vfx_t *flash = get_token(device);
	143
99	144	_logerror( 0, ("sst39vfx_load (%p)\n", file));
100		mame_fread( file, flash.data, flash.size);
101		if (flash.swap) sst39vfx_swap();
	145	mame_fread( file, flash->data, flash->size);
	146	if (flash->swap) sst39vfx_swap(device);
102	147	}
103	148
104		void sst39vfx_save(running_machine *machine, mame_file *file)
	149	void sst39vfx_save(const device_config *device, mame_file *file)
105	150	{
	151	sst39vfx_t *flash = get_token(device);
	152
106	153	_logerror( 0, ("sst39vfx_save (%p)\n", file));
107		if (flash.swap) sst39vfx_swap();
108		mame_fwrite( file, flash.data, flash.size);
109		if (flash.swap) sst39vfx_swap();
	154	if (flash->swap) sst39vfx_swap(device);
	155	mame_fwrite( file, flash->data, flash->size);
	156	if (flash->swap) sst39vfx_swap(device);
110	157	}
111	158
112	159	/*
r4094	r4095
125	172	}
126	173	else
127	174	{
128		memset( flash.data, 0xFF, flash.size);
	175	memset( flash->data, 0xFF, flash->size);
129	176	}
130	177	}
131	178	}
132	179	*/
	180	/*-------------------------------------------------
	181	DEVICE_SET_INFO( sst39vfx )
	182	-------------------------------------------------*/
	183
	184	static DEVICE_SET_INFO( sst39vfx )
	185	{
	186	switch (state)
	187	{
	188	/* no parameters to set */
	189	}
	190	}
	191
	192
	193
	194	/*-------------------------------------------------
	195	DEVICE_GET_INFO( sst39vf020 )
	196	-------------------------------------------------*/
	197
	198	DEVICE_GET_INFO( sst39vf020 )
	199	{
	200	switch (state)
	201	{
	202	/* --- the following bits of info are returned as 64-bit signed integers --- */
	203	case DEVINFO_INT_TOKEN_BYTES:               info->i = sizeof(sst39vfx_t);            break;
	204	case DEVINFO_INT_INLINE_CONFIG_BYTES:         info->i = sizeof(sst39vfx_config);         break;
	205	case DEVINFO_INT_CLASS:                     info->i = DEVICE_CLASS_PERIPHERAL;         break;
	206
	207	/* --- the following bits of info are returned as pointers to data or functions --- */
	208	case DEVINFO_FCT_SET_INFO:                  info->set_info = DEVICE_SET_INFO_NAME(sst39vfx); break;
	209	case DEVINFO_FCT_START:                     info->start = DEVICE_START_NAME(sst39vf020);   break;
	210	case DEVINFO_FCT_STOP:                     /* Nothing */                           break;
	211	case DEVINFO_FCT_RESET:                     /* Nothing */                           break;
	212
	213	/* --- the following bits of info are returned as NULL-terminated strings --- */
	214	case DEVINFO_STR_NAME:                     strcpy(info->s, "SST39VF020");               break;
	215	case DEVINFO_STR_FAMILY:                  strcpy(info->s, "SST39VFxx");               break;
	216	case DEVINFO_STR_VERSION:                  strcpy(info->s, "1.0");                     break;
	217	case DEVINFO_STR_SOURCE_FILE:               strcpy(info->s, __FILE__);                  break;
	218	case DEVINFO_STR_CREDITS:                  /* Nothing */                           break;
	219	}
	220	}
	221
	222	DEVICE_GET_INFO( sst39vf400a )
	223	{
	224	switch (state)
	225	{
	226	/* --- the following bits of info are returned as NULL-terminated strings --- */
	227	case DEVINFO_STR_NAME:                     strcpy(info->s, "SST39VF400A");            break;
	228
	229	/* --- the following bits of info are returned as pointers to data or functions --- */
	230	case DEVINFO_FCT_START:                     info->start = DEVICE_START_NAME(sst39vf400a);   break;
	231
	232	default:                               DEVICE_GET_INFO_CALL(sst39vf020);            break;
	233	}
	234	}

src/mess/machine/sst39vfx.h

r4094	r4095
14	14
15	15	#include "driver.h"
16	16
17		enum
	17	/***************************************************************************
	18	TYPE DEFINITIONS
	19	***************************************************************************/
	20
	21	typedef struct _sst39vfx_config sst39vfx_config;
	22	struct _sst39vfx_config
18	23	{
19		SST39VF020,
20		SST39VF400A
	24	int cpu_datawidth;
	25	int cpu_endianess;
21	26	};
22	27
23		// init/exit/reset
24		void sst39vfx_init(running_machine *machine, int type, int cpu_datawidth, int cpu_endianess);
	28	/***************************************************************************
	29	MACROS
	30	***************************************************************************/
25	31
	32	#define SST39VF020      DEVICE_GET_INFO_NAME(sst39vf020)
	33
	34	#define MDRV_SST39VF020_ADD(_tag,_cpu_datawidth,_cpu_endianess) \
	35	MDRV_DEVICE_ADD(_tag, SST39VF020, 0) \
	36	MDRV_DEVICE_CONFIG_DATA32(sst39vfx_config, cpu_datawidth, _cpu_datawidth) \
	37	MDRV_DEVICE_CONFIG_DATA32(sst39vfx_config, cpu_endianess, _cpu_endianess)
	38
	39	#define MDRV_SST39VF020_REMOVE(_tag) \
	40	MDRV_DEVICE_REMOVE(_tag, SST39VF020)
	41
	42	#define SST39VF400A      DEVICE_GET_INFO_NAME(sst39vf400a)
	43
	44	#define MDRV_SST39VF400A_ADD(_tag,_cpu_datawidth,_cpu_endianess) \
	45	MDRV_DEVICE_ADD(_tag, SST39VF400A, 0) \
	46	MDRV_DEVICE_CONFIG_DATA32(sst39vfx_config, cpu_datawidth, _cpu_datawidth) \
	47	MDRV_DEVICE_CONFIG_DATA32(sst39vfx_config, cpu_endianess, _cpu_endianess)
	48
	49	#define MDRV_SST39VF400A_REMOVE(_tag) \
	50	MDRV_DEVICE_REMOVE(_tag, SST39VF400A)
	51
	52	/***************************************************************************
	53	FUNCTION PROTOTYPES
	54	***************************************************************************/
	55
	56	DEVICE_GET_INFO(sst39vf020);
	57	DEVICE_GET_INFO(sst39vf400a);
	58
26	59	// get base/size
27		UINT8* sst39vfx_get_base( void);
28		UINT32 sst39vfx_get_size( void);
	60	UINT8* sst39vfx_get_base( const device_config *device );
	61	UINT32 sst39vfx_get_size( const device_config *device );
29	62
30	63	// read/write handler
31	64	/*
r4094	r4095
34	67	*/
35	68
36	69	// load/save
37		void sst39vfx_load(running_machine *machine, mame_file *file);
38		void sst39vfx_save(running_machine *machine, mame_file *file);
	70	void sst39vfx_load(const device_config *device, mame_file *file);
	71	void sst39vfx_save(const device_config *device, mame_file *file);
39	72
40	73	// non-volatile ram handler
41	74	/*

src/mess/machine/cybiko.c

r4094	r4095
195	195	pcf8593_save(device, file);
196	196	}
197	197
	198	static void cybiko_at45dbxx_load(running_machine *machine, mame_file *file)
	199	{
	200	const device_config *device = devtag_get_device(machine, AT45DB041, "flash1");
	201	at45dbxx_load(device, file);
	202	}
	203
	204	static void cybiko_at45dbxx_save(running_machine *machine, mame_file *file)
	205	{
	206	const device_config *device = devtag_get_device(machine, AT45DB041, "flash1");
	207	at45dbxx_save(device, file);
	208	}
	209
	210	static void cybiko_sst39vfx_load(running_machine *machine, mame_file *file)
	211	{
	212	const device_config *device = devtag_get_device(machine, SST39VF020, "flash2");
	213	sst39vfx_load(device, file);
	214	}
	215
	216	static void cybiko_sst39vfx_save(running_machine *machine, mame_file *file)
	217	{
	218	const device_config *device = devtag_get_device(machine, SST39VF020, "flash2");
	219	sst39vfx_save(device, file);
	220	}
	221
198	222	MACHINE_START( cybikov1 )
199	223	{
200	224	_logerror( 0, ("machine_start_cybikov1\n"));
201	225	// real-time clock
202	226	nvram_system_load( machine, "rtc", cybiko_pcf8593_load, 0);
203	227	// serial dataflash
204		at45dbxx_init(machine, AT45DB041);
205		nvram_system_load( machine, "flash1", &at45dbxx_load, 1);
	228	nvram_system_load( machine, "flash1", cybiko_at45dbxx_load, 1);
206	229	// serial port
207	230	cybiko_rs232_init();
208	231	// other
r4094	r4095
211	234
212	235	MACHINE_START( cybikov2 )
213	236	{
	237	const device_config *flash2 = devtag_get_device(machine, SST39VF020, "flash2");
	238
214	239	_logerror( 0, ("machine_start_cybikov2\n"));
215	240	// real-time clock
216	241	nvram_system_load( machine, "rtc", cybiko_pcf8593_load, 0);
217	242	// serial dataflash
218		at45dbxx_init(machine, AT45DB041);
219		nvram_system_load( machine, "flash1", &at45dbxx_load, 1);
	243	nvram_system_load( machine, "flash1", cybiko_at45dbxx_load, 1);
220	244	// multi-purpose flash
221		sst39vfx_init(machine, SST39VF020, 16, ENDIANNESS_BIG);
222		nvram_system_load( machine, "flash2", &sst39vfx_load, 1);
223		memory_set_bankptr( machine, 2, sst39vfx_get_base());
	245	nvram_system_load( machine, "flash2", cybiko_sst39vfx_load, 1);
	246	memory_set_bankptr( machine, 2, sst39vfx_get_base(flash2));
224	247	// serial port
225	248	cybiko_rs232_init();
226	249	// other
r4094	r4095
229	252
230	253	MACHINE_START( cybikoxt )
231	254	{
	255	const device_config *flash2 = devtag_get_device(machine, SST39VF020, "flash2");
232	256	_logerror( 0, ("machine_start_cybikoxt\n"));
233	257	// real-time clock
234	258	nvram_system_load( machine, "rtc", cybiko_pcf8593_load, 0);
235	259	// multi-purpose flash
236		sst39vfx_init(machine, SST39VF400A, 16, ENDIANNESS_BIG);
237		nvram_system_load( machine, "flash1", &sst39vfx_load, 1);
238		memory_set_bankptr( machine, 2, sst39vfx_get_base());
	260	nvram_system_load( machine, "flash1", cybiko_sst39vfx_load, 1);
	261	memory_set_bankptr( machine, 2, sst39vfx_get_base(flash2));
239	262	// serial port
240	263	cybiko_rs232_init();
241	264	// other
r4094	r4095
274	297	// real-time clock
275	298	nvram_system_save( machine, "rtc", cybiko_pcf8593_save);
276	299	// serial dataflash
277		nvram_system_save( machine, "flash1", &at45dbxx_save);
	300	nvram_system_save( machine, "flash1", cybiko_at45dbxx_save);
278	301	// serial port
279	302	cybiko_rs232_exit();
280	303	}
r4094	r4095
285	308	// real-time clock
286	309	nvram_system_save( machine, "rtc", cybiko_pcf8593_save);
287	310	// serial dataflash
288		nvram_system_save( machine, "flash1", &at45dbxx_save);
	311	nvram_system_save( machine, "flash1", cybiko_at45dbxx_save);
289	312	// multi-purpose flash
290		nvram_system_save( machine, "flash2", &sst39vfx_save);
	313	nvram_system_save( machine, "flash2", cybiko_sst39vfx_save);
291	314	// serial port
292	315	cybiko_rs232_exit();
293	316	}
r4094	r4095
298	321	// real-time clock
299	322	nvram_system_save( machine, "rtc", cybiko_pcf8593_save);
300	323	// multi-purpose flash
301		nvram_system_save( machine, "flash1", &sst39vfx_save);
	324	nvram_system_save( machine, "flash1", cybiko_sst39vfx_save);
302	325	// serial port
303	326	cybiko_rs232_exit();
304	327	}
r4094	r4095
456	479	}
457	480	break;
458	481	// serial dataflash
459		case H8S_IO_PORT3 : if (at45dbxx_pin_so(space->machine)) data = data | H8S_P3_RXD1; break;
	482	case H8S_IO_PORT3 :  {
	483	const device_config *device = devtag_get_device(space->machine, AT45DB041, "flash1");
	484	if (at45dbxx_pin_so(device)) data = data | H8S_P3_RXD1;
	485	}
	486	break;
	487
460	488	// rs232
461	489	case H8S_IO_PORT5 : if (cybiko_rs232_pin_rxd()) data = data | H8S_P5_RXD2; break;
462	490	// real-time clock
r4094	r4095
489	517	// serial dataflash
490	518	case H8S_IO_P3DR :
491	519	{
492		at45dbxx_pin_cs ( space->machine, (data & H8S_P3_SCK0) ? 0 : 1);
493		at45dbxx_pin_si ( space->machine, (data & H8S_P3_TXD1) ? 1 : 0);
494		at45dbxx_pin_sck( space->machine, (data & H8S_P3_SCK1) ? 1 : 0);
	520	const device_config *device = devtag_get_device(space->machine, AT45DB041, "flash1");
	521	at45dbxx_pin_cs ( device, (data & H8S_P3_SCK0) ? 0 : 1);
	522	at45dbxx_pin_si ( device, (data & H8S_P3_TXD1) ? 1 : 0);
	523	at45dbxx_pin_sck( device, (data & H8S_P3_SCK1) ? 1 : 0);
495	524	}
496	525	break;
497	526	// rs232

src/mess/drivers/cybiko.c

r4094	r4095
18	18	//#include "cpu/h8s2xxx/h8s2xxx.h"
19	19	#include "video/hd66421.h"
20	20	#include "machine/pcf8593.h"
21
	21	#include "machine/at45dbxx.h"
	22	#include "machine/sst39vfx.h"
22	23	/* Layout */
23	24	#include "cybiko.lh"
24	25
r4094	r4095
285	286	//  MDRV_NVRAM_HANDLER( cybikov1)
286	287	/* rtc */
287	288	MDRV_PCF8593_ADD("rtc")
	289	MDRV_AT45DB041_ADD("flash1")
288	290	MACHINE_DRIVER_END
289	291
290	292	static MACHINE_DRIVER_START( cybikov2 )
r4094	r4095
299	301	MDRV_MACHINE_RESET( cybikov2)
300	302	// non-volatile ram
301	303	//  MDRV_NVRAM_HANDLER( cybikov2)
	304	MDRV_SST39VF020_ADD("flash2",16, ENDIANNESS_BIG)
302	305	MACHINE_DRIVER_END
303	306
304	307	static MACHINE_DRIVER_START( cybikoxt )
r4094	r4095
316	319	MDRV_MACHINE_RESET( cybikoxt)
317	320	// non-volatile ram
318	321	//  MDRV_NVRAM_HANDLER( cybikoxt)
	322	MDRV_AT45DB041_REMOVE("flash1")
	323	MDRV_SST39VF020_ADD("flash2",16, ENDIANNESS_BIG)
319	324	MACHINE_DRIVER_END
320	325
321	326	//////////////

docs/messnew.txt

r4094	r4095
27	27	Source Changes:
28	28	----------------
29	29	- Changed the DS1315 implementation to be a device.  [Nathan Woods]
	30	- Changed the AT45DBxx and SST39VFxx to be a device [Miodrag Milanovic]
30	31
31	32
32
33	33	0.129
34	34
35	35	New System Drivers Supported (in no particular order):

Previous

15994 Revisions

Next

---

© 1998-2018 The MESS Team