trunk/RomCheater.EmuMMAPPlugin/EmuMEMMapDockControl.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using WeifenLuo.WinFormsUI.Docking;

namespace RomCheater.EmuMMAPPlugin
{
    public partial class EmuMEMMapDockControl : DockContent
    {
        private List<DeviceMemoryMap> DeviceMemoryMaps = new List<DeviceMemoryMap>();
        public EmuMEMMapDockControl()
        {
            InitializeComponent();
            CreateMaps();
        }
        private void EmuMEMMapDockControl_Shown(object sender, EventArgs e)
        {
            txtDeviceMap.Clear();
            txtDeviceMap.AppendText(string.Format("Device Memory Map(s):{0}", System.Environment.NewLine));
            foreach (var k in DeviceMemoryMaps)
            {
                string devicename = k.DeviceName;
                txtDeviceMap.AppendText(string.Format("{0}:{1}", devicename, System.Environment.NewLine));
                var map = k.MemoryMap;
                foreach (var mapped in map)
                {
                    var mapped_name = mapped.Key;
                    var mapped_data = mapped.Value;
                    var t = mapped_data.ToString();
                    txtDeviceMap.AppendText(string.Format("\t{0}{1}", t, System.Environment.NewLine));
                }
            }
        }
        private void CreateMaps()
        {
            var map = new DeviceMemoryMap();

            #region NES
            map = CreateNESMemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            #region SNES
            map = CreateSNESMemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            #region PS1
            map = CreatePS1MemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            #region PS2
            map = CreatePS2MemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            #region N64
            map = CreateN64MemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            #region NGC
            map = CreateNGCMemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            #region WII
            map = CreateWIIMemMap();
            DeviceMemoryMaps.Add(map);
            #endregion
            map = null;
        }

        #region NES
        private DeviceMemoryMap CreateNESMemMap()
        {
            /* http://en.wikibooks.org/wiki/NES_Programming */
            const string name = "NES";
            DeviceMemoryMap map = new DeviceMemoryMap();            
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            //maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
            maprange.Add(new MemMap("Zero Page", 0x0000, 0x00FF));
            maprange.Add(new MemMap("Stack", 0x0100, 0x01FF));
            maprange.Add(new MemMap("Ram", 0x0200, 0x07FF));

            // mirror
            maprange.Add(new MemMap("ZeroPage/Stack/Ram Mirror1", 0x0800, 0x0FFF));
            // mirror
            maprange.Add(new MemMap("ZeroPage/Stack/Ram Mirror2", 0x1000, 0x17FF));
            // mirror
            maprange.Add(new MemMap("ZeroPage/Stack/Ram Mirror3", 0x1800, 0x1FFF));
          
            maprange.Add(new MemMap("IO Reg1", 0x2000, 0x2007));
            maprange.Add(new MemMap("IO reg1 mirror - repeated", 0x2000, 0x3FFF));
            maprange.Add(new MemMap("IO Reg2", 0x4000, 0x401F));
            maprange.Add(new MemMap("Expansion ROM", 0x4020, 0x5FFF));
            maprange.Add(new MemMap("SRAM", 0x6000, 0x7FFF));
            maprange.Add(new MemMap("PRG-ROM", 0x8000, 0xFFFF));

            maprange.Add(new MemMap("Address of NMI Interrupt handler", 0xFFFA, 0xFFFB));
            maprange.Add(new MemMap("Address of Power on reset handler", 0xFFFC, 0xFFFD));
            maprange.Add(new MemMap("Address of BRK handler routine", 0xFFFE, 0xFFFF));
            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
        #region SNES
        private DeviceMemoryMap CreateSNESMemMap()
        {
            /* http://www.emulatronia.com/doctec/consolas/snes/SNESMem.txt */
            const string name = "SNES";
            DeviceMemoryMap map = new DeviceMemoryMap();
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            //maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
            maprange.Add(new MemMap("LowRAM", 0x0000, 0x1fff));
            maprange.Add(new MemMap("HighRAM", 0x2000, 0x7fff));
            maprange.Add(new MemMap("Expanded RAM", 0x8000, 0xffff));
            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
        #region PS1
        private DeviceMemoryMap CreatePS1MemMap()
        {
            /* http://rveach.romhack.org/PSXInfo/psx%20hardware%20info.txt */
            const string name = "PS1";
            DeviceMemoryMap map = new DeviceMemoryMap();
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            //maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));            
            maprange.Add(new MemMap("Kernel Memory", 0x00000000, 0x0000ffff));
            maprange.Add(new MemMap("User Memory", 0x00010000, 0x001FFFFF));
            maprange.Add(new MemMap("Parallel Port", 0x1f000000, 0x1f00ffff));
            maprange.Add(new MemMap("Scratch Pad", 0x1f800000, 0x1f8003ff));
            maprange.Add(new MemMap("HW Registers", 0x1f801000, 0x1f802fff));            
            maprange.Add(new MemMap("BIOS", 0x1FC00000, 0x1FC7FFFF));

            maprange.Add(new MemMap("Kernel & User Memory (cached)", 0x80000000, 0x801fffff));
            maprange.Add(new MemMap("Kernel & User Memory (uncached)", 0xa0000000, 0xa01fffff));

            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
        #region PS2
        private DeviceMemoryMap CreatePS2MemMap()
        {
            /* http://psx-scene.com/forums/attachments/f19/17285d1280158606-ps2-memory-hardware-mapped-registers-layout-ps2-memory-hardware-mapped-registers-layout.txt */
            /* http://psx-scene.com/forums/f19/ps2-memory-hardware-mapped-registers-layout-64760/ */
            const string name = "PS2";
            DeviceMemoryMap map = new DeviceMemoryMap();
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            //maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
            maprange.Add(new MemMap("EE Kernel", 0x80000000, 0x800FFFFF));
            maprange.Add(new MemMap("EE RAM (Cached)", 0x00100000, 0x01FFFFFF));
            maprange.Add(new MemMap("EE RAM (Uncached)", 0x20100000, 0x21FFFFFF));
            maprange.Add(new MemMap("EE RAM (Uncached&accelerated)", 0x30100000, 0x31FFFFFF));
            maprange.Add(new MemMap("EE Registers (uncached)", 0x10000000, 0x11FFFFFF));
            maprange.Add(new MemMap("GS Registers (uncached)", 0x12000000, 0x13FFFFFF));
            maprange.Add(new MemMap("Boot ROM0 (uncached)", 0x1FC00000, 0x1FFFFFFF));
            maprange.Add(new MemMap("Boot ROM09 (cached)", 0x9FC00000, 0x9FFFFFFF));
            maprange.Add(new MemMap("Boot ROM0b (uncached)", 0xBFC00000, 0xBFFFFFFF));
            maprange.Add(new MemMap("Boot ROM1", 0xBE000000, 0xBE040000));
            maprange.Add(new MemMap("Boot ROM2", 0xBE400000, 0xBE440000));
            maprange.Add(new MemMap("IOP RAM", 0xBC000000, 0xBC1FFFFF));
            maprange.Add(new MemMap("Scratch Pad", 0x70000000, 0x70003FFF));
            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
        #region N64
        private DeviceMemoryMap CreateN64MemMap()
        {
            const string name = "N64";
            DeviceMemoryMap map = new DeviceMemoryMap();
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
        #region NGC
        private DeviceMemoryMap CreateNGCMemMap()
        {
            const string name = "NGC";
            DeviceMemoryMap map = new DeviceMemoryMap();
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
        #region WII
        private DeviceMemoryMap CreateWIIMemMap()
        {
            const string name = "WII";
            DeviceMemoryMap map = new DeviceMemoryMap();
            List<IMemMap> maprange = new List<IMemMap>();
            #region memory maps
            maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
            #endregion
            map = new DeviceMemoryMap(name, maprange);
            return map;
        }
        #endregion
    }

    #region Memory Map Helper Classes
    internal interface IMemMap
    {
        string MapName { get; }
        string MapStart { get; }
        string MapEnd { get; }
        string MapSize { get; }
        string ToString();
    }
    internal interface IDeviceMemoryMap
    {
        string DeviceName { get; }
        IDictionary<string, IMemMap> MemoryMap { get; }
        string ToString();
    }

    internal class MemMap : IMemMap
    {
        public MemMap() : this(string.Empty, 0, 0) { }
        public MemMap(string name)
        {
            this.MapName = name;
        }
        public MemMap(string name, ulong start, ulong end) : this(name, string.Format("0x{0}", start.ToString("X")), string.Format("0x{0}", end.ToString("X")), end-start) { }
        public MemMap(string name, string start, string end, ulong size)
            : this(name)
        {
            this.MapStart = start;
            this.MapEnd = end;

            ulong _size = size + 1;
            double t = 1024.0 * 1024.0;
            double __size = (double)_size/t;
            this.MapSize = string.Format("0x{0}={1:0.000000}MB", _size.ToString("X"), __size);
        }
        #region IMappedMemRange Members
        public string MapName { get; private set; }
        public string MapStart { get; private set; }
        public string MapEnd { get; private set; }
        public string MapSize { get; private set; }
        public override string ToString()
        {
            return string.Format("[{0}]==>[{1}-{2}] [{3}]", MapName, MapStart, MapEnd, MapSize);
        }
        #endregion
    }

    internal class DeviceMemoryMap : IDeviceMemoryMap
    {
        public DeviceMemoryMap() { this.DeviceName = string.Empty; this.MemoryMap = this.MemoryMap = new Dictionary<string, IMemMap>(); }
        public DeviceMemoryMap(string device, List<IMemMap> memorymap)
        {
            this.DeviceName = device;
            this.MemoryMap = new Dictionary<string, IMemMap>();

            foreach (var map in memorymap)
            {
                this.MemoryMap.Add(map.MapName, map);
            }

        }

        #region IDeviceMemoryMap Members
        public string DeviceName { get; private set; }
        public IDictionary<string, IMemMap> MemoryMap { get; private set; }
        public override string ToString()
        {
            return string.Format("[{0}]==>{1} mapped memory range(s)", DeviceName, MemoryMap.Count);
        }
        #endregion
    }

    #endregion
}

Revision:	650
Committed:	Sun Jun 9 00:04:18 2013 UTC (9 years, 11 months ago) by william
File size:	12147 byte(s)
Log Message:
#	Content
1	using System;
2	using System.Collections.Generic;
3	using System.ComponentModel;
4	using System.Data;
5	using System.Drawing;
6	using System.Linq;
7	using System.Text;
8	using System.Windows.Forms;
9	using WeifenLuo.WinFormsUI.Docking;
10
11	namespace RomCheater.EmuMMAPPlugin
12	{
13	public partial class EmuMEMMapDockControl : DockContent
14	{
15	private List<DeviceMemoryMap> DeviceMemoryMaps = new List<DeviceMemoryMap>();
16	public EmuMEMMapDockControl()
17	{
18	InitializeComponent();
19	CreateMaps();
20	}
21	private void EmuMEMMapDockControl_Shown(object sender, EventArgs e)
22	{
23	txtDeviceMap.Clear();
24	txtDeviceMap.AppendText(string.Format("Device Memory Map(s):{0}", System.Environment.NewLine));
25	foreach (var k in DeviceMemoryMaps)
26	{
27	string devicename = k.DeviceName;
28	txtDeviceMap.AppendText(string.Format("{0}:{1}", devicename, System.Environment.NewLine));
29	var map = k.MemoryMap;
30	foreach (var mapped in map)
31	{
32	var mapped_name = mapped.Key;
33	var mapped_data = mapped.Value;
34	var t = mapped_data.ToString();
35	txtDeviceMap.AppendText(string.Format("\t{0}{1}", t, System.Environment.NewLine));
36	}
37	}
38	}
39	private void CreateMaps()
40	{
41	var map = new DeviceMemoryMap();
42
43	#region NES
44	map = CreateNESMemMap();
45	DeviceMemoryMaps.Add(map);
46	#endregion
47	#region SNES
48	map = CreateSNESMemMap();
49	DeviceMemoryMaps.Add(map);
50	#endregion
51	#region PS1
52	map = CreatePS1MemMap();
53	DeviceMemoryMaps.Add(map);
54	#endregion
55	#region PS2
56	map = CreatePS2MemMap();
57	DeviceMemoryMaps.Add(map);
58	#endregion
59	#region N64
60	map = CreateN64MemMap();
61	DeviceMemoryMaps.Add(map);
62	#endregion
63	#region NGC
64	map = CreateNGCMemMap();
65	DeviceMemoryMaps.Add(map);
66	#endregion
67	#region WII
68	map = CreateWIIMemMap();
69	DeviceMemoryMaps.Add(map);
70	#endregion
71	map = null;
72	}
73
74	#region NES
75	private DeviceMemoryMap CreateNESMemMap()
76	{
77	/* http://en.wikibooks.org/wiki/NES_Programming */
78	const string name = "NES";
79	DeviceMemoryMap map = new DeviceMemoryMap();
80	List<IMemMap> maprange = new List<IMemMap>();
81	#region memory maps
82	//maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
83	maprange.Add(new MemMap("Zero Page", 0x0000, 0x00FF));
84	maprange.Add(new MemMap("Stack", 0x0100, 0x01FF));
85	maprange.Add(new MemMap("Ram", 0x0200, 0x07FF));
86
87	// mirror
88	maprange.Add(new MemMap("ZeroPage/Stack/Ram Mirror1", 0x0800, 0x0FFF));
89	// mirror
90	maprange.Add(new MemMap("ZeroPage/Stack/Ram Mirror2", 0x1000, 0x17FF));
91	// mirror
92	maprange.Add(new MemMap("ZeroPage/Stack/Ram Mirror3", 0x1800, 0x1FFF));
93
94	maprange.Add(new MemMap("IO Reg1", 0x2000, 0x2007));
95	maprange.Add(new MemMap("IO reg1 mirror - repeated", 0x2000, 0x3FFF));
96	maprange.Add(new MemMap("IO Reg2", 0x4000, 0x401F));
97	maprange.Add(new MemMap("Expansion ROM", 0x4020, 0x5FFF));
98	maprange.Add(new MemMap("SRAM", 0x6000, 0x7FFF));
99	maprange.Add(new MemMap("PRG-ROM", 0x8000, 0xFFFF));
100
101	maprange.Add(new MemMap("Address of NMI Interrupt handler", 0xFFFA, 0xFFFB));
102	maprange.Add(new MemMap("Address of Power on reset handler", 0xFFFC, 0xFFFD));
103	maprange.Add(new MemMap("Address of BRK handler routine", 0xFFFE, 0xFFFF));
104	#endregion
105	map = new DeviceMemoryMap(name, maprange);
106	return map;
107	}
108	#endregion
109	#region SNES
110	private DeviceMemoryMap CreateSNESMemMap()
111	{
112	/* http://www.emulatronia.com/doctec/consolas/snes/SNESMem.txt */
113	const string name = "SNES";
114	DeviceMemoryMap map = new DeviceMemoryMap();
115	List<IMemMap> maprange = new List<IMemMap>();
116	#region memory maps
117	//maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
118	maprange.Add(new MemMap("LowRAM", 0x0000, 0x1fff));
119	maprange.Add(new MemMap("HighRAM", 0x2000, 0x7fff));
120	maprange.Add(new MemMap("Expanded RAM", 0x8000, 0xffff));
121	#endregion
122	map = new DeviceMemoryMap(name, maprange);
123	return map;
124	}
125	#endregion
126	#region PS1
127	private DeviceMemoryMap CreatePS1MemMap()
128	{
129	/* http://rveach.romhack.org/PSXInfo/psx%20hardware%20info.txt */
130	const string name = "PS1";
131	DeviceMemoryMap map = new DeviceMemoryMap();
132	List<IMemMap> maprange = new List<IMemMap>();
133	#region memory maps
134	//maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
135	maprange.Add(new MemMap("Kernel Memory", 0x00000000, 0x0000ffff));
136	maprange.Add(new MemMap("User Memory", 0x00010000, 0x001FFFFF));
137	maprange.Add(new MemMap("Parallel Port", 0x1f000000, 0x1f00ffff));
138	maprange.Add(new MemMap("Scratch Pad", 0x1f800000, 0x1f8003ff));
139	maprange.Add(new MemMap("HW Registers", 0x1f801000, 0x1f802fff));
140	maprange.Add(new MemMap("BIOS", 0x1FC00000, 0x1FC7FFFF));
141
142	maprange.Add(new MemMap("Kernel & User Memory (cached)", 0x80000000, 0x801fffff));
143	maprange.Add(new MemMap("Kernel & User Memory (uncached)", 0xa0000000, 0xa01fffff));
144
145	#endregion
146	map = new DeviceMemoryMap(name, maprange);
147	return map;
148	}
149	#endregion
150	#region PS2
151	private DeviceMemoryMap CreatePS2MemMap()
152	{
153	/* http://psx-scene.com/forums/attachments/f19/17285d1280158606-ps2-memory-hardware-mapped-registers-layout-ps2-memory-hardware-mapped-registers-layout.txt */
154	/* http://psx-scene.com/forums/f19/ps2-memory-hardware-mapped-registers-layout-64760/ */
155	const string name = "PS2";
156	DeviceMemoryMap map = new DeviceMemoryMap();
157	List<IMemMap> maprange = new List<IMemMap>();
158	#region memory maps
159	//maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
160	maprange.Add(new MemMap("EE Kernel", 0x80000000, 0x800FFFFF));
161	maprange.Add(new MemMap("EE RAM (Cached)", 0x00100000, 0x01FFFFFF));
162	maprange.Add(new MemMap("EE RAM (Uncached)", 0x20100000, 0x21FFFFFF));
163	maprange.Add(new MemMap("EE RAM (Uncached&accelerated)", 0x30100000, 0x31FFFFFF));
164	maprange.Add(new MemMap("EE Registers (uncached)", 0x10000000, 0x11FFFFFF));
165	maprange.Add(new MemMap("GS Registers (uncached)", 0x12000000, 0x13FFFFFF));
166	maprange.Add(new MemMap("Boot ROM0 (uncached)", 0x1FC00000, 0x1FFFFFFF));
167	maprange.Add(new MemMap("Boot ROM09 (cached)", 0x9FC00000, 0x9FFFFFFF));
168	maprange.Add(new MemMap("Boot ROM0b (uncached)", 0xBFC00000, 0xBFFFFFFF));
169	maprange.Add(new MemMap("Boot ROM1", 0xBE000000, 0xBE040000));
170	maprange.Add(new MemMap("Boot ROM2", 0xBE400000, 0xBE440000));
171	maprange.Add(new MemMap("IOP RAM", 0xBC000000, 0xBC1FFFFF));
172	maprange.Add(new MemMap("Scratch Pad", 0x70000000, 0x70003FFF));
173	#endregion
174	map = new DeviceMemoryMap(name, maprange);
175	return map;
176	}
177	#endregion
178	#region N64
179	private DeviceMemoryMap CreateN64MemMap()
180	{
181	const string name = "N64";
182	DeviceMemoryMap map = new DeviceMemoryMap();
183	List<IMemMap> maprange = new List<IMemMap>();
184	#region memory maps
185	maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
186	#endregion
187	map = new DeviceMemoryMap(name, maprange);
188	return map;
189	}
190	#endregion
191	#region NGC
192	private DeviceMemoryMap CreateNGCMemMap()
193	{
194	const string name = "NGC";
195	DeviceMemoryMap map = new DeviceMemoryMap();
196	List<IMemMap> maprange = new List<IMemMap>();
197	#region memory maps
198	maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
199	#endregion
200	map = new DeviceMemoryMap(name, maprange);
201	return map;
202	}
203	#endregion
204	#region WII
205	private DeviceMemoryMap CreateWIIMemMap()
206	{
207	const string name = "WII";
208	DeviceMemoryMap map = new DeviceMemoryMap();
209	List<IMemMap> maprange = new List<IMemMap>();
210	#region memory maps
211	maprange.Add(new MemMap(string.Format("{0}_test", name), 0, 0));
212	#endregion
213	map = new DeviceMemoryMap(name, maprange);
214	return map;
215	}
216	#endregion
217	}
218
219	#region Memory Map Helper Classes
220	internal interface IMemMap
221	{
222	string MapName { get; }
223	string MapStart { get; }
224	string MapEnd { get; }
225	string MapSize { get; }
226	string ToString();
227	}
228	internal interface IDeviceMemoryMap
229	{
230	string DeviceName { get; }
231	IDictionary<string, IMemMap> MemoryMap { get; }
232	string ToString();
233	}
234
235	internal class MemMap : IMemMap
236	{
237	public MemMap() : this(string.Empty, 0, 0) { }
238	public MemMap(string name)
239	{
240	this.MapName = name;
241	}
242	public MemMap(string name, ulong start, ulong end) : this(name, string.Format("0x{0}", start.ToString("X")), string.Format("0x{0}", end.ToString("X")), end-start) { }
243	public MemMap(string name, string start, string end, ulong size)
244	: this(name)
245	{
246	this.MapStart = start;
247	this.MapEnd = end;
248
249	ulong _size = size + 1;
250	double t = 1024.0 * 1024.0;
251	double __size = (double)_size/t;
252	this.MapSize = string.Format("0x{0}={1:0.000000}MB", _size.ToString("X"), __size);
253	}
254	#region IMappedMemRange Members
255	public string MapName { get; private set; }
256	public string MapStart { get; private set; }
257	public string MapEnd { get; private set; }
258	public string MapSize { get; private set; }
259	public override string ToString()
260	{
261	return string.Format("[{0}]==>[{1}-{2}] [{3}]", MapName, MapStart, MapEnd, MapSize);
262	}
263	#endregion
264	}
265
266	internal class DeviceMemoryMap : IDeviceMemoryMap
267	{
268	public DeviceMemoryMap() { this.DeviceName = string.Empty; this.MemoryMap = this.MemoryMap = new Dictionary<string, IMemMap>(); }
269	public DeviceMemoryMap(string device, List<IMemMap> memorymap)
270	{
271	this.DeviceName = device;
272	this.MemoryMap = new Dictionary<string, IMemMap>();
273
274	foreach (var map in memorymap)
275	{
276	this.MemoryMap.Add(map.MapName, map);
277	}
278
279	}
280
281	#region IDeviceMemoryMap Members
282	public string DeviceName { get; private set; }
283	public IDictionary<string, IMemMap> MemoryMap { get; private set; }
284	public override string ToString()
285	{
286	return string.Format("[{0}]==>{1} mapped memory range(s)", DeviceName, MemoryMap.Count);
287	}
288	#endregion
289	}
290
291	#endregion
292	}
293