Previous 15994 Revisions Next

r9657 Wednesday 24th November, 2010 at 18:44:22 UTC by Sandro Ronco
[PSION] Refactored driver to define ADDRESS_MAP_MODERN and added save state.
[src/mess/drivers]psion.c
[src/mess/includes]psion.h*

src/mess/includes/psion.h
r0r9657
1/***************************************************************************
2
3        Psion Organiser II series
4
5****************************************************************************/
6
7#pragma once
8
9#ifndef _PSION_H_
10#define _PSION_H_
11
12class datapack
13{
14public:
15   UINT8 update(UINT8 data);
16   void control_lines_w(UINT8 data);
17   UINT8 control_lines_r();
18   int load(device_image_interface &image);
19   void unload(device_image_interface &image);
20   void reset();
21
22private:
23   device_image_interface *d_image;
24   UINT8 id;
25   UINT8 len;
26   UINT16 counter;
27   UINT8 page;
28   UINT8 segment;
29   UINT8 control_lines;
30   UINT8 *buffer;
31   bool write_flag;
32};
33
34class psion_state : public driver_device
35{
36public:
37   psion_state(running_machine &machine, const driver_device_config_base &config)
38      : driver_device(machine, config),
39        m_maincpu(*this, "maincpu"),
40        m_lcdc(*this, "hd44780"),
41        m_beep(*this, "beep")
42      { }
43
44   required_device<cpu_device> m_maincpu;
45   required_device<hd44780_device> m_lcdc;
46   required_device<device_t> m_beep;
47
48   UINT16 m_kb_counter;
49   UINT8 m_enable_nmi;
50   UINT8 *m_sys_register;
51   UINT8 m_tcsr_value;
52   UINT8 m_stby_pwr;
53   UINT8 m_pulse;
54
55   UINT8 m_port2_ddr;   // datapack i/o ddr
56   UINT8 m_port2;      // datapack i/o data bus
57   UINT8 m_port6_ddr;   // datapack control lines ddr
58   UINT8 m_port6;      // datapack control lines
59
60   // RAM/ROM banks
61   UINT8 *m_ram;
62   size_t m_ram_size;
63   UINT8 *m_paged_ram;
64   UINT8 m_rom_bank;
65   UINT8 m_ram_bank;
66   UINT8 m_ram_bank_count;
67   UINT8 m_rom_bank_count;
68
69   datapack m_pack1;
70   datapack m_pack2;
71
72   virtual void machine_start();
73   virtual void machine_reset();
74   bool video_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect);
75
76   UINT8 kb_read(running_machine *machine);
77   void update_banks(running_machine *machine);
78   datapack *get_active_slot(UINT8 data);
79   WRITE8_MEMBER( hd63701_int_reg_w );
80   READ8_MEMBER( hd63701_int_reg_r );
81   void io_rw(address_space &space, UINT16 offset);
82   WRITE8_MEMBER( io_w );
83   READ8_MEMBER( io_r );
84};
85
86#endif   // _PSION_H_
src/mess/drivers/psion.c
r9656r9657
55        Driver by Sandro Ronco
66
77        TODO:
8        - add save state
8        - move datapack into device
99        - dump CGROM of the HD44780
10      - emulate other devices in slot C(Comms Link, printer)
10        - emulate other devices in slot C(Comms Link, printer)
1111
1212        Note:
1313        - 4 lines display has an custom LCD controller derived from an HD66780
1414        - NVRAM works only if the machine is turned off (with OFF menu) before closing MESS
1515
16        16/07/2010 Skeleton driver.
16        More info:
17            http://archive.psion2.org/org2/techref/index.htm
1718
18        Memory map info :
19            http://archive.psion2.org/org2/techref/memory.htm
20
2119****************************************************************************/
2220
21#define ADDRESS_MAP_MODERN
22
2323#include "emu.h"
2424#include "cpu/m6800/m6800.h"
2525#include "sound/beep.h"
2626#include "devices/cartslot.h"
2727#include "video/hd44780.h"
28#include "includes/psion.h"
2829
29struct datapack
30{
31   device_image_interface *image;
32   UINT8 id;
33   UINT8 len;
34   UINT16 counter;
35   UINT8 page;
36   UINT8 segment;
37   UINT8 control_lines;
38   UINT8* data;
39
40   bool write_flag;
41};
42
43class psion_state : public driver_device
44{
45public:
46   psion_state(running_machine &machine, const driver_device_config_base &config)
47      : driver_device(machine, config) { }
48
49   UINT16 kb_counter;
50   UINT8 enable_nmi;
51   UINT8 *sys_register;
52   UINT8 tcsr_value;
53   UINT8 stby_pwr;
54   UINT8 pulse;
55
56   /* RAM/ROM banks */
57   UINT8 *ram;
58   size_t ram_size;
59   UINT8 *paged_ram;
60   UINT8 rom_bank;
61   UINT8 ram_bank;
62   UINT8 ram_bank_count;
63   UINT8 rom_bank_count;
64
65   UINT8 port2_ddr;
66   UINT8 port2;
67   UINT8 port6_ddr;
68   UINT8 port6;
69
70   datapack pack1;
71   datapack pack2;
72
73   // devices
74   hd44780_device *hd44780;
75   device_t *beep;
76};
77
78
7930/***********************************************
8031
8132    Datapack
8233
8334***********************************************/
8435
85static UINT8 datapack_update(datapack *pack, UINT8 data)
86{
87   assert(pack != NULL);
36//Datapack control line
37#define DP_LINE_CLOCK         0x01
38#define DP_LINE_RESET         0x02
39#define DP_LINE_PROGRAM         0x04
40#define DP_LINE_OUTPUT_ENABLE   0x08
41#define DP_LINE_POWER_ON      0x80
8842
89   if (pack->len == 0 || (pack->control_lines & 0x80))
43//Datapack ID
44#define DP_ID_EPROM            0x02
45#define DP_ID_PAGED            0x04
46#define DP_ID_WRITE            0x08
47#define DP_ID_BOOT            0x10
48#define DP_ID_COPY            0x20
49
50UINT8 datapack::update(UINT8 data)
51{
52   if (len == 0 || (control_lines & DP_LINE_POWER_ON))
9053      return 0;
9154
92   UINT32 pack_addr = pack->counter + ((pack->id & 0x04) ? 0x100 * pack->page : 0);
55   UINT32 pack_addr = counter + ((id & DP_ID_PAGED) ? 0x100 * page : 0);
9356
9457   // if the datapack is 128k or more is treated as segmented
95   if (pack->len >= 0x10)
96      pack_addr += (pack->segment * 0x4000);
58   if (len >= 0x10)
59      pack_addr += (segment * 0x4000);
9760
98   if (pack_addr < pack->len * 0x2000)
61   if (pack_addr < len * 0x2000)
9962   {
100      if ((pack->control_lines&0x08) && !(pack->control_lines & 0x02))
63      if ((control_lines & DP_LINE_OUTPUT_ENABLE) && !(control_lines & DP_LINE_RESET))
10164      {
10265         //write latched data
103         pack->data[pack_addr] = data;
104         pack->write_flag = true;
66         buffer[pack_addr] = data;
67         write_flag = true;
10568      }
106      else if ((pack->control_lines&0x08) && (pack->control_lines & 0x02))
69      else if ((control_lines & DP_LINE_OUTPUT_ENABLE) && (control_lines & DP_LINE_RESET))
10770      {
10871         //write datapack segment
109         if (pack->len <= 0x10)
110            pack->segment = data & 0x07;
111         else if (pack->len <= 0x20)
112            pack->segment = data & 0x0f;
113         else if (pack->len <= 0x40)
114            pack->segment = data & 0x1f;
115         else if (pack->len <= 0x80)
116            pack->segment = data & 0x3f;
72         if (len <= 0x10)
73            segment = data & 0x07;
74         else if (len <= 0x20)
75            segment = data & 0x0f;
76         else if (len <= 0x40)
77            segment = data & 0x1f;
78         else if (len <= 0x80)
79            segment = data & 0x3f;
11780         else
118            pack->segment = data;
81            segment = data;
11982      }
120      else if (!(pack->control_lines&0x08) && !(pack->control_lines & 0x02))
83      else if (!(control_lines & DP_LINE_OUTPUT_ENABLE) && !(control_lines & DP_LINE_RESET))
12184      {
12285         //latch data
123         data = pack->data[pack_addr];
86         data = buffer[pack_addr];
12487      }
125      else if (!(pack->control_lines&0x08) && (pack->control_lines & 0x02))
88      else if (!(control_lines & DP_LINE_OUTPUT_ENABLE) && (control_lines & DP_LINE_RESET))
12689      {
12790         //read datapack ID
128         if (pack->id & 0x02)
129            data = pack->data[0];
91         if (id & DP_ID_EPROM)
92            data = buffer[0];
13093         else
13194            data = 1;
13295      }
r9656r9657
13598   return data;
13699}
137100
138static void datapack_control_lines_w(datapack *pack, UINT8 data)
101void datapack::control_lines_w(UINT8 data)
139102{
140   assert(pack != NULL);
141
142   if ((pack->control_lines & 0x01) != (data & 0x01))
103   if ((control_lines & DP_LINE_CLOCK) != (data & DP_LINE_CLOCK))
143104   {
144      pack->counter++;
105      counter++;
145106
146      if (pack->counter >= ((pack->id & 0x04) ? 0x100 : (pack->len * 0x2000)))
147         pack->counter = 0;
107      if (counter >= ((id & DP_ID_PAGED) ? 0x100 : (len * 0x2000)))
108         counter = 0;
148109   }
149110
150   if ((pack->control_lines & 0x04) && !(data & 0x04))
111   if ((control_lines & DP_LINE_PROGRAM) && !(data & DP_LINE_PROGRAM))
151112   {
152      pack->page++;
113      page++;
153114
154      if (pack->page >= (pack->len * 0x2000) / 0x100)
155         pack->page = 0;
115      if (page >= (len * 0x2000) / 0x100)
116         page = 0;
156117   }
157118
158   if (data & 0x02)
119   if (data & DP_LINE_RESET)
159120   {
160      pack->counter = 0;
161      pack->page = 0;
121      counter = 0;
122      page = 0;
162123   }
163124
164   pack->control_lines = data;
125   control_lines = data;
165126}
166127
167static UINT8 datapack_control_lines_r(datapack *pack)
128UINT8 datapack::control_lines_r()
168129{
169   assert(pack != NULL);
170
171   return pack->control_lines;
130   return control_lines;
172131}
173132
174static int datapack_load(device_image_interface &image, datapack &pack)
133int datapack::load(device_image_interface &image)
175134{
176135   running_machine *machine = image.device().machine;
177   char opk_head[6];
178   UINT8 pack_id, pack_len;
136   UINT8 *data;
137   UINT32 length;
179138
180   image.fread(opk_head, 6);
181   image.fread(&pack_id, 1);
182   image.fread(&pack_len, 1);
139   if (image.software_entry() == NULL)
140   {
141      length = image.length();
142      data = auto_alloc_array(machine, UINT8, length);
143      image.fread(data, image.length());
144   }
145   else
146   {
147      length = image.get_software_region_length("rom");
148      data = auto_alloc_array(machine, UINT8, length);
149      memcpy(data, image.get_software_region("rom"), length);
150   }
183151
184   if(strcmp(opk_head, "OPK") || pack_len * 0x2000 < image.length() - 6)
152   //check the OPK head
153   if(strncmp((const char*)data, "OPK", 3) || data[7] * 0x2000 < length - 6)
185154      return IMAGE_INIT_FAIL;
186155
187   pack.image = &image;
188   pack.write_flag = false;
189   pack.id = pack_id;
190   pack.len = pack_len;
191   image.fseek(6, SEEK_SET);
192   pack.data = auto_alloc_array(machine, UINT8, pack.len * 0x2000);
193   memset(pack.data, 0xff, pack.len * 0x2000);
194   image.fread(pack.data, image.length() - 6);
156   d_image = &image;
157   write_flag = false;
158   id = data[6];
159   len = data[7];
160   buffer = auto_alloc_array(machine, UINT8, len * 0x2000);
161   memset(buffer, 0xff, len * 0x2000);
162   memcpy(buffer, data + 6, length - 6);
195163
196164   /* load battery */
197   UINT8 *opk = auto_alloc_array(machine, UINT8, pack.len * 0x2000 + 6);
198   image.battery_load(opk, pack.len * 0x2000 + 6, 0xff);
165   UINT8 *opk = auto_alloc_array(machine, UINT8, len * 0x2000 + 6);
166   image.battery_load(opk, len * 0x2000 + 6, 0xff);
199167   if(!strncmp((char*)opk, "OPK", 3))
200      memcpy(pack.data, opk + 6, pack.len * 0x2000);
168      memcpy(buffer, opk + 6, len * 0x2000);
201169
202170   return IMAGE_INIT_PASS;
203171}
204172
205static void datapack_unload(device_image_interface &image, datapack &pack)
173void datapack::unload(device_image_interface &image)
206174{
207175   running_machine *machine = image.device().machine;
208176
209177   // save battery only if a write-access occurs
210   if (pack.len > 0 && pack.write_flag)
178   if (len > 0 && write_flag)
211179   {
212      UINT8 opk_magic[6] = {'O', 'P', 'K', 0x00, 0x00, 0x00};
213      UINT8 *opk = auto_alloc_array(machine, UINT8, pack.len * 0x2000 + 6);
180      const UINT8 opk_magic[6] = {'O', 'P', 'K', 0x00, 0x00, 0x00};
181      UINT8 *opk = auto_alloc_array(machine, UINT8, len * 0x2000 + 6);
214182
215183      memcpy(opk, opk_magic, 6);
216      memcpy(opk + 6, pack.data, pack.len * 0x2000);
184      memcpy(opk + 6, buffer, len * 0x2000);
217185
218      pack.image->battery_save(opk, pack.len * 0x2000 + 6);
186      d_image->battery_save(opk, len * 0x2000 + 6);
219187
220188      auto_free(machine, opk);
221189   }
222190
223   auto_free(machine, pack.data);
224   pack.len = 0;
191   auto_free(machine, buffer);
192   len = 0;
225193}
226194
195void datapack::reset()
196{
197   d_image = NULL;
198   id = 0;
199   len = 0;
200   counter = 0;
201   page = 0;
202   segment = 0;
203   control_lines = 0;
204   buffer = NULL;
205   write_flag = false;
206}
207
227208/***********************************************
228209
229210    basic machine
r9656r9657
234215{
235216   psion_state *state = machine->driver_data<psion_state>();
236217
237   if (state->enable_nmi)
218   if (state->m_enable_nmi)
238219      cputag_set_input_line(machine, "maincpu", INPUT_LINE_NMI, PULSE_LINE);
239220}
240221
241static UINT8 kb_read(running_machine *machine)
222UINT8 psion_state::kb_read(running_machine *machine)
242223{
243   psion_state *state = machine->driver_data<psion_state>();
244224   static const char *const bitnames[] = {"K1", "K2", "K3", "K4", "K5", "K6", "K7"};
245225   UINT8 line, data = 0x7c;
246226
247   if (state->kb_counter)
227   if (m_kb_counter)
248228   {
249229      for (line = 0; line < 7; line++)
250         if (state->kb_counter == (0x7f & ~(1 << line)))
230         if (m_kb_counter == (0x7f & ~(1 << line)))
251231            data = input_port_read(machine, bitnames[line]);
252232   }
253233   else
254234   {
235      //Read all the input lines
255236      for (line = 0; line < 7; line++)
256237         data &= input_port_read(machine, bitnames[line]);
257238   }
r9656r9657
259240   return data & 0x7c;
260241}
261242
262static void update_bank(running_machine *machine)
243void psion_state::update_banks(running_machine *machine)
263244{
264   psion_state *state = machine->driver_data<psion_state>();
245   if (m_ram_bank < m_ram_bank_count && m_ram_bank_count)
246      memory_set_bank(machine, "rambank", m_ram_bank);
265247
266   if (state->ram_bank < state->ram_bank_count && state->ram_bank_count)
267      memory_set_bankptr(machine,"rambank", state->paged_ram + state->ram_bank*0x4000);
268
269   if (state->rom_bank_count)
270   {
271      if (state->rom_bank==0)
272         memory_set_bankptr(machine,"rombank", memory_region(machine, "maincpu") + 0x8000);
273      else if (state->rom_bank < state->rom_bank_count)
274         memory_set_bankptr(machine,"rombank", memory_region(machine, "maincpu") + state->rom_bank*0x4000 + 0xc000);
275   }
248   if (m_rom_bank < m_rom_bank_count && m_rom_bank_count)
249      memory_set_bank(machine, "rombank", m_rom_bank);
276250}
277251
278static struct datapack *get_active_slot(running_machine *machine, UINT8 data)
252datapack* psion_state::get_active_slot(UINT8 data)
279253{
280   psion_state *state = machine->driver_data<psion_state>();
281
282254   switch(data & 0x70)
283255   {
284256      case 0x60:
285         return &state->pack1;
257         return &m_pack1;
286258      case 0x50:
287         return &state->pack2;
259         return &m_pack2;
260      case 0x30:
261         //Unemulated slot C
262         return NULL;
288263   }
289264
290265   return NULL;
291266}
292267
293static WRITE8_HANDLER( hd63701_int_reg_w )
268WRITE8_MEMBER( psion_state::hd63701_int_reg_w )
294269{
295   psion_state *state = space->machine->driver_data<psion_state>();
296
297270   switch (offset)
298271   {
299272   case 0x01:
300      state->port2_ddr = data;
273      m_port2_ddr = data;
301274      break;
302275   case 0x03:
303276      /* datapack i/o data bus */
304      if (state->port2_ddr == 0xff)
277      if (m_port2_ddr == 0xff)
305278      {
306         datapack *pack = get_active_slot(space->machine, state->port6);
279         datapack *pack = get_active_slot(m_port6);
307280
308281         if (pack)
309            state->port2 = datapack_update(pack, data);
282            m_port2 = pack->update(data);
310283         else
311            state->port2 = data;
284            m_port2 = data;
312285      }
313286      break;
314287   case 0x08:
315      state->tcsr_value = data;
288      m_tcsr_value = data;
316289      break;
317290   case 0x15:
318291      /* read-only */
319292      break;
320293   case 0x16:
321      state->port6_ddr = data;
294      m_port6_ddr = data;
322295      break;
323296   case 0x17:
324297      /*
r9656r9657
333306        ---- ---x clock line
334307        */
335308      {
336         state->port6 = (data & state->port6_ddr) | (state->port6 & ~state->port6_ddr);
337         datapack *pack = get_active_slot(space->machine, state->port6);
309         m_port6 = (data & m_port6_ddr) | (m_port6 & ~m_port6_ddr);
310         datapack *pack = get_active_slot(m_port6);
338311
339312         if (pack != NULL)
340313         {
341            datapack_control_lines_w(pack, state->port6);
342            datapack_update(pack, state->port2);
314            pack->control_lines_w(m_port6);
315            pack->update(m_port2);
343316         }
344317      }
345318      break;
346319   }
347320
348   hd63701_internal_registers_w(space, offset, data);
321   hd63701_internal_registers_w(&space, offset, data);
349322}
350323
351static READ8_HANDLER( hd63701_int_reg_r )
324READ8_MEMBER( psion_state::hd63701_int_reg_r )
352325{
353   psion_state *state = space->machine->driver_data<psion_state>();
354
355326   switch (offset)
356327   {
357328   case 0x03:
358329      /* datapack i/o data bus */
359      if (state->port2_ddr == 0)
330      if (m_port2_ddr == 0)
360331      {
361         datapack *pack = get_active_slot(space->machine, state->port6);
332         datapack *pack = get_active_slot(m_port6);
362333
363334         if (pack)
364            state->port2 = datapack_update(pack, state->port2);
335            m_port2 = pack->update(m_port2);
365336         else
366            state->port2 = 0;
337            m_port2 = 0;
367338
368         return state->port2;
339         return m_port2;
369340      }
370341      else
371342         return 0;
372343   case 0x14:
373      return (hd63701_internal_registers_r(space, offset)&0x7f) | (state->stby_pwr<<7);
344      return (hd63701_internal_registers_r(&space, offset)&0x7f) | (m_stby_pwr<<7);
374345   case 0x15:
375346      /*
376347        x--- ---- ON key active high
r9656r9657
378349        ---- --x- pulse
379350        ---- ---x battery status
380351        */
381      return kb_read(space->machine) | input_port_read(space->machine, "BATTERY") | input_port_read(space->machine, "ON") | (state->kb_counter == 0x7ff)<<1 | state->pulse<<1;
352      return kb_read(space.machine) | input_port_read(space.machine, "BATTERY") | input_port_read(space.machine, "ON") | (m_kb_counter == 0x7ff)<<1 | m_pulse<<1;
382353   case 0x17:
383354      /* datapack control lines */
384355      {
385         datapack *pack = get_active_slot(space->machine, state->port6);
356         datapack *pack = get_active_slot(m_port6);
386357
387358         if (pack)
388            return datapack_control_lines_r(pack);
359            return pack->control_lines_r();
389360         else
390            return state->port6;
361            return m_port6;
391362      }
392363   case 0x08:
393      hd63701_internal_registers_w(space, offset, state->tcsr_value);
364      hd63701_internal_registers_w(&space, offset, m_tcsr_value);
394365   default:
395      return hd63701_internal_registers_r(space, offset);
366      return hd63701_internal_registers_r(&space, offset);
396367   }
397368}
398369
399370/* Read/Write common */
400static void io_rw(address_space* space, UINT16 offset)
371void psion_state::io_rw(address_space &space, UINT16 offset)
401372{
402   psion_state *state = space->machine->driver_data<psion_state>();
403
404   if (space->debugger_access())
373   if (space.debugger_access())
405374      return;
406375
407376   switch (offset & 0xffc0)
408377   {
409378   case 0xc0:
410379      /* switch off, CPU goes into standby mode */
411      state->enable_nmi = 0;
412      state->stby_pwr = 1;
413      space->machine->device<cpu_device>("maincpu")->suspend(SUSPEND_REASON_HALT, 1);
380      m_enable_nmi = 0;
381      m_stby_pwr = 1;
382      space.machine->device<cpu_device>("maincpu")->suspend(SUSPEND_REASON_HALT, 1);
414383      break;
415384   case 0x100:
416      state->pulse = 1;
385      m_pulse = 1;
417386      break;
418387   case 0x140:
419      state->pulse = 0;
388      m_pulse = 0;
420389      break;
421390   case 0x200:
422      state->kb_counter = 0;
391      m_kb_counter = 0;
423392      break;
424393   case 0x180:
425      beep_set_state(state->beep, 1);
394      beep_set_state(m_beep, 1);
426395      break;
427396   case 0x1c0:
428      beep_set_state(state->beep, 0);
397      beep_set_state(m_beep, 0);
429398      break;
430399   case 0x240:
431      if (offset == 0x260 && (state->rom_bank_count || state->ram_bank_count))
400      if (offset == 0x260 && (m_rom_bank_count || m_ram_bank_count))
432401      {
433         state->ram_bank=0;
434         state->rom_bank=0;
435         update_bank(space->machine);
402         m_ram_bank=0;
403         m_rom_bank=0;
404         update_banks(space.machine);
436405      }
437406      else
438         state->kb_counter++;
407         m_kb_counter++;
439408      break;
440409   case 0x280:
441      if (offset == 0x2a0 && state->ram_bank_count)
410      if (offset == 0x2a0 && m_ram_bank_count)
442411      {
443         state->ram_bank++;
444         update_bank(space->machine);
412         m_ram_bank++;
413         update_banks(space.machine);
445414      }
446415      else
447         state->enable_nmi = 1;
416         m_enable_nmi = 1;
448417      break;
449418   case 0x2c0:
450      if (offset == 0x2e0 && state->rom_bank_count)
419      if (offset == 0x2e0 && m_rom_bank_count)
451420      {
452         state->rom_bank++;
453         update_bank(space->machine);
421         m_rom_bank++;
422         update_banks(space.machine);
454423      }
455424      else
456         state->enable_nmi = 0;
425         m_enable_nmi = 0;
457426      break;
458427   }
459428}
460429
461static WRITE8_HANDLER( io_w )
430WRITE8_MEMBER( psion_state::io_w )
462431{
463   psion_state *state = space->machine->driver_data<psion_state>();
464
465432   switch (offset & 0x0ffc0)
466433   {
467434   case 0x80:
468435      if (offset & 1)
469         state->hd44780->data_write(offset, data);
436         m_lcdc->data_write(offset, data);
470437      else
471         state->hd44780->control_write(offset, data);
438         m_lcdc->control_write(offset, data);
472439      break;
473440   default:
474441      io_rw(space, offset);
475442   }
476443}
477444
478static READ8_HANDLER( io_r )
445READ8_MEMBER( psion_state::io_r )
479446{
480      psion_state *state = space->machine->driver_data<psion_state>();
481
482447   switch (offset & 0xffc0)
483448   {
484449   case 0x80:
485      if (offset& 1)
486         return state->hd44780->data_read(offset);
450      if (offset & 1)
451         return m_lcdc->data_read(offset);
487452      else
488         return state->hd44780->control_read(offset);
453         return m_lcdc->control_read(offset);
489454   default:
490455      io_rw(space, offset);
491456   }
r9656r9657
502467      cpu->reset();
503468}
504469
505static ADDRESS_MAP_START(psioncm_mem, ADDRESS_SPACE_PROGRAM, 8)
470static ADDRESS_MAP_START(psioncm_mem, ADDRESS_SPACE_PROGRAM, 8, psion_state)
506471   ADDRESS_MAP_UNMAP_LOW
507472   AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
508   AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE_MEMBER(psion_state, sys_register)
473   AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(m_sys_register)
509474   AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
510   AM_RANGE(0x2000, 0x3fff) AM_RAM AM_BASE_SIZE_MEMBER(psion_state, ram, ram_size)
475   AM_RANGE(0x2000, 0x3fff) AM_RAM AM_BASE(m_ram) AM_SIZE(psion_state, m_ram_size)
511476   AM_RANGE(0x8000, 0xffff) AM_ROM
512477ADDRESS_MAP_END
513478
514static ADDRESS_MAP_START(psionla_mem, ADDRESS_SPACE_PROGRAM, 8)
479static ADDRESS_MAP_START(psionla_mem, ADDRESS_SPACE_PROGRAM, 8, psion_state)
515480   ADDRESS_MAP_UNMAP_LOW
516481   AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
517   AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE_MEMBER(psion_state, sys_register)
482   AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(m_sys_register)
518483   AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
519   AM_RANGE(0x0400, 0x5fff) AM_RAM AM_BASE_SIZE_MEMBER(psion_state, ram, ram_size)
484   AM_RANGE(0x0400, 0x5fff) AM_RAM AM_BASE(m_ram) AM_SIZE(psion_state, m_ram_size)
520485   AM_RANGE(0x8000, 0xffff) AM_ROM
521486ADDRESS_MAP_END
522487
523static ADDRESS_MAP_START(psionp350_mem, ADDRESS_SPACE_PROGRAM, 8)
488static ADDRESS_MAP_START(psionp350_mem, ADDRESS_SPACE_PROGRAM, 8, psion_state)
524489   ADDRESS_MAP_UNMAP_LOW
525490   AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
526   AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE_MEMBER(psion_state, sys_register)
491   AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(m_sys_register)
527492   AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
528   AM_RANGE(0x0400, 0x3fff) AM_RAM AM_BASE_SIZE_MEMBER(psion_state, ram, ram_size)
493   AM_RANGE(0x0400, 0x3fff) AM_RAM AM_BASE(m_ram) AM_SIZE(psion_state, m_ram_size)
529494   AM_RANGE(0x4000, 0x7fff) AM_RAMBANK("rambank")
530495   AM_RANGE(0x8000, 0xffff) AM_ROM
531496ADDRESS_MAP_END
532497
533static ADDRESS_MAP_START(psionlam_mem, ADDRESS_SPACE_PROGRAM, 8)
498static ADDRESS_MAP_START(psionlam_mem, ADDRESS_SPACE_PROGRAM, 8, psion_state)
534499   ADDRESS_MAP_UNMAP_LOW
535500   AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
536   AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE_MEMBER(psion_state, sys_register)
501   AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(m_sys_register)
537502   AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
538   AM_RANGE(0x0400, 0x7fff) AM_RAM AM_BASE_SIZE_MEMBER(psion_state, ram, ram_size)
503   AM_RANGE(0x0400, 0x7fff) AM_RAM AM_BASE(m_ram) AM_SIZE(psion_state, m_ram_size)
539504   AM_RANGE(0x8000, 0xbfff) AM_ROMBANK("rombank")
540505   AM_RANGE(0xc000, 0xffff) AM_ROM
541506ADDRESS_MAP_END
542507
543static ADDRESS_MAP_START(psionlz_mem, ADDRESS_SPACE_PROGRAM, 8)
508static ADDRESS_MAP_START(psionlz_mem, ADDRESS_SPACE_PROGRAM, 8, psion_state)
544509   ADDRESS_MAP_UNMAP_LOW
545510   AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
546   AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE_MEMBER(psion_state, sys_register)
511   AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(m_sys_register)
547512   AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
548   AM_RANGE(0x0400, 0x3fff) AM_RAM AM_BASE_SIZE_MEMBER(psion_state, ram, ram_size)
513   AM_RANGE(0x0400, 0x3fff) AM_RAM AM_BASE(m_ram) AM_SIZE(psion_state, m_ram_size)
549514   AM_RANGE(0x4000, 0x7fff) AM_RAMBANK("rambank")
550515   AM_RANGE(0x8000, 0xbfff) AM_ROMBANK("rombank")
551516   AM_RANGE(0xc000, 0xffff) AM_ROM
r9656r9657
559524      PORT_CONFSETTING( 0x01, "Low Battery" )
560525
561526   PORT_START("ON")
562      PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ON/CLEAR") PORT_CODE(KEYCODE_F10)  PORT_CHANGED(psion_on, 0)
527      PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ON/CLEAR") PORT_CODE(KEYCODE_MINUS)  PORT_CHANGED(psion_on, 0)
563528
564529   PORT_START("K1")
565530      PORT_BIT(0x04, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("MODE") PORT_CODE(KEYCODE_EQUALS)
r9656r9657
615580{
616581   psion_state *state = image.device().machine->driver_data<psion_state>();
617582
618   return datapack_load(image, state->pack1);
583   return state->m_pack1.load(image);
619584}
620585
621586static DEVICE_IMAGE_UNLOAD( psion_pack1 )
622587{
623588   psion_state *state = image.device().machine->driver_data<psion_state>();
624589
625   datapack_unload(image, state->pack1);
590   state->m_pack1.unload(image);
626591}
627592
628593static DEVICE_IMAGE_LOAD( psion_pack2 )
629594{
630595   psion_state *state = image.device().machine->driver_data<psion_state>();
631596
632   return datapack_load(image, state->pack2);
597   return state->m_pack2.load(image);
633598}
634599
635600static DEVICE_IMAGE_UNLOAD( psion_pack2 )
636601{
637602   psion_state *state = image.device().machine->driver_data<psion_state>();
638603
639   datapack_unload(image, state->pack2);
604   state->m_pack2.unload(image);
640605}
641606
642607static NVRAM_HANDLER( psion )
r9656r9657
645610
646611   if (read_or_write)
647612   {
648      mame_fwrite(file, state->sys_register, 0xc0);
649      mame_fwrite(file, state->ram, state->ram_size);
650      if (state->ram_bank_count)
651         mame_fwrite(file, state->paged_ram, state->ram_bank_count * 0x4000);
613      mame_fwrite(file, state->m_sys_register, 0xc0);
614      mame_fwrite(file, state->m_ram, state->m_ram_size);
615      if (state->m_ram_bank_count)
616         mame_fwrite(file, state->m_paged_ram, state->m_ram_bank_count * 0x4000);
652617   }
653618   else
654619   {
655620      if (file)
656621      {
657         mame_fread(file, state->sys_register, 0xc0);
658         mame_fread(file, state->ram, state->ram_size);
659         if (state->ram_bank_count)
660            mame_fread(file, state->paged_ram, state->ram_bank_count * 0x4000);
622         mame_fread(file, state->m_sys_register, 0xc0);
623         mame_fread(file, state->m_ram, state->m_ram_size);
624         if (state->m_ram_bank_count)
625            mame_fread(file, state->m_paged_ram, state->m_ram_bank_count * 0x4000);
661626
662         state->stby_pwr = 1;
627         //warm start
628         state->m_stby_pwr = 1;
663629      }
664630      else
665         state->stby_pwr = 0;
631         //cold start
632         state->m_stby_pwr = 0;
666633   }
667634}
668635
669static MACHINE_START(psion)
636void psion_state::machine_start()
670637{
671   psion_state *state = machine->driver_data<psion_state>();
672
673638   if (!strcmp(machine->gamedrv->name, "psionlam"))
674639   {
675      state->rom_bank_count = 3;
676      state->ram_bank_count = 0;
640      m_rom_bank_count = 3;
641      m_ram_bank_count = 0;
677642   }
678643   else if (!strcmp(machine->gamedrv->name, "psionp350"))
679644   {
680      state->rom_bank_count = 0;
681      state->ram_bank_count = 5;
645      m_rom_bank_count = 0;
646      m_ram_bank_count = 5;
682647   }
683648   else if (!strncmp(machine->gamedrv->name, "psionlz", 7))
684649   {
685      state->rom_bank_count = 3;
686      state->ram_bank_count = 3;
650      m_rom_bank_count = 3;
651      m_ram_bank_count = 3;
687652   }
688653   else if (!strcmp(machine->gamedrv->name, "psionp464"))
689654   {
690      state->rom_bank_count = 3;
691      state->ram_bank_count = 9;
655      m_rom_bank_count = 3;
656      m_ram_bank_count = 9;
692657   }
693658   else
694659   {
695      state->rom_bank_count = 0;
696      state->ram_bank_count = 0;
660      m_rom_bank_count = 0;
661      m_ram_bank_count = 0;
697662   }
698663
699   if (state->ram_bank_count)
700      state->paged_ram = auto_alloc_array(machine, UINT8, state->ram_bank_count * 0x4000);
664   if (m_rom_bank_count)
665   {
666      UINT8* rom_base = (UINT8 *)memory_region(machine, "maincpu");
701667
702   timer_pulse(machine, ATTOTIME_IN_SEC(1), NULL, 0, nmi_timer);
668      memory_configure_bank(machine, "rombank", 0, 1, rom_base + 0x8000, 0x4000);
669      memory_configure_bank(machine, "rombank", 1, m_rom_bank_count-1, rom_base + 0x10000, 0x4000);
670      memory_set_bank(machine, "rombank", 0);
671   }
703672
704   state->hd44780 = machine->device<hd44780_device>("hd44780");
705   state->beep = machine->device<device_t>("beep");
706}
673   if (m_ram_bank_count)
674   {
675      m_paged_ram = auto_alloc_array(machine, UINT8, m_ram_bank_count * 0x4000);
676      memory_configure_bank(machine, "rambank", 0, m_ram_bank_count, m_paged_ram, 0x4000);
677      memory_set_bank(machine, "rambank", 0);
678   }
707679
708static MACHINE_RESET(psion)
709{
710   psion_state *state = machine->driver_data<psion_state>();
680   timer_pulse(machine, ATTOTIME_IN_SEC(1), NULL, 0, nmi_timer);
711681
712   state->enable_nmi=0;
713   state->kb_counter=0;
714   state->ram_bank=0;
715   state->rom_bank=0;
716   state->pulse=0;
717
718   if (state->rom_bank_count || state->ram_bank_count)
719      update_bank(machine);
682   state_save_register_global(machine, m_kb_counter);
683   state_save_register_global(machine, m_enable_nmi);
684   state_save_register_global(machine, m_tcsr_value);
685   state_save_register_global(machine, m_stby_pwr);
686   state_save_register_global(machine, m_pulse);
687   state_save_register_global(machine, m_rom_bank);
688   state_save_register_global(machine, m_ram_bank);
689   state_save_register_global(machine, m_port2_ddr);
690   state_save_register_global(machine, m_port2);
691   state_save_register_global(machine, m_port6_ddr);
692   state_save_register_global(machine, m_port6);
693   state_save_register_global_pointer(machine, m_paged_ram, m_ram_bank_count * 0x4000);
720694}
721695
722static VIDEO_START( psion )
696void psion_state::machine_reset()
723697{
724}
698   m_enable_nmi=0;
699   m_kb_counter=0;
700   m_ram_bank=0;
701   m_rom_bank=0;
702   m_pulse=0;
725703
726static VIDEO_UPDATE( psion_2lines )
727{
728   psion_state *state = screen->machine->driver_data<psion_state>();
704   m_pack1.reset();
705   m_pack2.reset();
729706
730   return state->hd44780->video_update( bitmap, cliprect );
707   if (m_rom_bank_count || m_ram_bank_count)
708      update_banks(machine);
731709}
732710
733static VIDEO_UPDATE( psion_4lines )
711bool psion_state::video_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect)
734712{
735   psion_state *state = screen->machine->driver_data<psion_state>();
736
737   return state->hd44780->video_update( bitmap, cliprect );
713   return m_lcdc->video_update( &bitmap, &cliprect );
738714}
739715
740716static PALETTE_INIT( psion )
r9656r9657
785761/* basic configuration for 2 lines display */
786762static MACHINE_CONFIG_START( psion_2lines, psion_state )
787763   /* basic machine hardware */
788    MDRV_CPU_ADD("maincpu",HD63701, 980000) // should be HD6303 at 0.98MHz
764    MDRV_CPU_ADD("maincpu", HD63701, 980000) // should be HD6303 at 0.98MHz
789765
790   MDRV_MACHINE_START(psion)
791    MDRV_MACHINE_RESET(psion)
792
793766    /* video hardware */
794767    MDRV_SCREEN_ADD("screen", RASTER)
795768    MDRV_SCREEN_REFRESH_RATE(50)
r9656r9657
804777
805778   MDRV_HD44780_ADD("hd44780", psion_2line_display)
806779
807    MDRV_VIDEO_START(psion)
808    MDRV_VIDEO_UPDATE(psion_2lines)
809
810780   /* sound hardware */
811781   MDRV_SPEAKER_STANDARD_MONO( "mono" )
812782   MDRV_SOUND_ADD( "beep", BEEP, 0 )
r9656r9657
817787   MDRV_FRAGMENT_ADD( psion_slot )
818788MACHINE_CONFIG_END
819789
820const UINT8 psion_4line_layout[] =
790static const UINT8 psion_4line_layout[] =
821791{
822792   0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
823793   0x40, 0x41, 0x42, 0x43, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
r9656r9657
837807   /* basic machine hardware */
838808    MDRV_CPU_ADD("maincpu",HD63701, 980000) // should be HD6303 at 0.98MHz
839809
840   MDRV_MACHINE_START(psion)
841    MDRV_MACHINE_RESET(psion)
842
843810    /* video hardware */
844811    MDRV_SCREEN_ADD("screen", RASTER)
845812    MDRV_SCREEN_REFRESH_RATE(50)
r9656r9657
854821
855822   MDRV_HD44780_ADD("hd44780", psion_4line_display)
856823
857    MDRV_VIDEO_START(psion)
858    MDRV_VIDEO_UPDATE(psion_4lines)
859
860824   /* sound hardware */
861825   MDRV_SPEAKER_STANDARD_MONO( "mono" )
862826   MDRV_SOUND_ADD( "beep", BEEP, 0 )
r9656r9657
975939/* Driver */
976940
977941/*    YEAR  NAME    PARENT  COMPAT   MACHINE    INPUT    INIT COMPANY   FULLNAME       FLAGS */
978COMP( 1986, psioncm,   0,       0,    psioncm,      psion,    0,   "Psion",   "Organiser II CM",      GAME_IMPERFECT_GRAPHICS)
979COMP( 198?, psionla,   psioncm, 0,    psionla,       psion,    0,   "Psion",   "Organiser II LA",      GAME_IMPERFECT_GRAPHICS)
980COMP( 198?, psionp350,   psioncm, 0,    psionp350,       psion,    0,   "Psion",   "Organiser II P350",   GAME_IMPERFECT_GRAPHICS)
981COMP( 198?, psionlam,   psioncm, 0,    psionlam,       psion,    0,   "Psion",   "Organiser II LAM",   GAME_IMPERFECT_GRAPHICS)
982COMP( 1989, psionlz64,  psioncm, 0,    psionlz,       psion,    0,   "Psion",   "Organiser II LZ64",   GAME_IMPERFECT_GRAPHICS)
983COMP( 1989, psionlz64s,   psioncm, 0,    psionlz,       psion,    0,   "Psion",   "Organiser II LZ64S",   GAME_IMPERFECT_GRAPHICS)
984COMP( 1989, psionlz,   psioncm, 0,    psionlz,       psion,    0,   "Psion",   "Organiser II LZ",      GAME_IMPERFECT_GRAPHICS)
985COMP( 198?, psionp464,   psioncm, 0,    psionlz,       psion,    0,   "Psion",   "Organiser II P464",   GAME_IMPERFECT_GRAPHICS)
942COMP( 1986, psioncm,   0,       0,    psioncm,      psion,    0,   "Psion",   "Organiser II CM",      GAME_SUPPORTS_SAVE | GAME_IMPERFECT_GRAPHICS)
943COMP( 1986, psionla,   psioncm, 0,    psionla,       psion,    0,   "Psion",   "Organiser II LA",      GAME_SUPPORTS_SAVE | GAME_IMPERFECT_GRAPHICS)
944COMP( 1986, psionp350,   psioncm, 0,    psionp350,       psion,    0,   "Psion",   "Organiser II P350",   GAME_SUPPORTS_SAVE | GAME_IMPERFECT_GRAPHICS)
945COMP( 1986, psionlam,   psioncm, 0,    psionlam,       psion,    0,   "Psion",   "Organiser II LAM",   GAME_SUPPORTS_SAVE | GAME_IMPERFECT_GRAPHICS)
946COMP( 1989, psionlz,   0,       0,    psionlz,       psion,    0,   "Psion",   "Organiser II LZ",      GAME_SUPPORTS_SAVE | GAME_IMPERFECT_GRAPHICS)
947COMP( 1989, psionlz64,  psionlz, 0,    psionlz,       psion,    0,   "Psion",   "Organiser II LZ64",   GAME_SUPPORTS_SAVE | GAME_IMPERFECT_GRAPHICS)
948COMP( 1989, psionlz64s,   psionlz, 0,    psionlz,       psion,    0,   "Psion",   "Organiser II LZ64S",   GAME_SUPPORTS_SAVE | GAME_IMPERFECT_GRAPHICS)
949COMP( 1989, psionp464,   psionlz, 0,    psionlz,       psion,    0,   "Psion",   "Organiser II P464",   GAME_SUPPORTS_SAVE | GAME_IMPERFECT_GRAPHICS)

Previous 15994 Revisions Next


© 1998-2018 The MESS Team