Пример #1
0
        public static void WriteField(ACPIObject val, ACPIObject.FieldUnitData fd, IMachineInterface mi)
        {
            ACPIObject.OpRegionData oprd = fd.OpRegion.Data as ACPIObject.OpRegionData;
            ulong addr = oprd.Offset;

            if ((fd.BitOffset % 8) != 0)
            {
                throw new NotImplementedException();
            }
            addr += (ulong)(fd.BitOffset / 8);

            ulong mask    = 0xffffffffffffffff;
            int   alength = 0;

            switch (fd.Access)
            {
            case ACPIObject.FieldUnitData.AccessType.ByteAcc:
                alength = 8;
                break;

            case ACPIObject.FieldUnitData.AccessType.WordAcc:
                alength = 16;
                break;

            case ACPIObject.FieldUnitData.AccessType.DWordAcc:
                alength = 32;
                break;

            case ACPIObject.FieldUnitData.AccessType.QWordAcc:
                alength = 64;
                break;

            case ACPIObject.FieldUnitData.AccessType.AnyAcc:
                alength = fd.BitLength;
                break;
            }

            if (alength <= 8)
            {
                alength = 8;
            }
            else if (alength <= 16)
            {
                alength = 16;
            }
            else if (alength <= 32)
            {
                alength = 32;
            }
            else if (alength <= 64)
            {
                alength = 64;
            }
            else
            {
                throw new Exception("Unsupported access length: " + alength.ToString());
            }

            switch (oprd.RegionSpace)
            {
            case 0:
                // SystemMemory
                switch (alength)
                {
                case 8:
                    mi.WriteMemoryByte(addr, (byte)val);
                    break;

                case 16:
                    mi.WriteMemoryWord(addr, (ushort)val);
                    break;

                case 32:
                    mi.WriteMemoryDWord(addr, (uint)val);
                    break;

                case 64:
                    mi.WriteMemoryQWord(addr, val);
                    break;
                }
                break;

            case 1:
                // SystemIO
                switch (alength)
                {
                case 8:
                    mi.WriteIOByte(addr, (byte)val);
                    break;

                case 16:
                    mi.WriteIOWord(addr, (ushort)val);
                    break;

                case 32:
                    mi.WriteIODWord(addr, (uint)val);
                    break;

                case 64:
                    mi.WriteIOQWord(addr, val);
                    break;
                }
                break;

            default:
                throw new NotImplementedException();
            }
        }
Пример #2
0
        internal void Write(ACPIObject d, int Offset, IMachineInterface mi, Namespace.State s, Namespace n)
        {
            if (Type == DataType.Uninitialized ||
                (Type == DataType.ObjectReference &&
                 ((ObjRefData)Data).Object == null) ||
                (Type == DataType.Integer &&
                 (ulong)Data == 0UL))
            {
                return;
            }

            //System.Diagnostics.Debugger.Log(0, "acpipc", "Write: " + d.Type.ToString() + " to " + Type.ToString());

            switch (Type)
            {
            case DataType.Local:
                s.Locals[(int)Data] = d;
                return;

            case DataType.Arg:
                s.Args[(int)Data] = d;
                return;

            case DataType.Buffer:
            {
                ACPIObject new_buf = d.EvaluateTo(DataType.Buffer, mi, s, n);
                byte[]     dst     = (byte[])Data;
                byte[]     src     = (byte[])new_buf.Data;
                for (int i = Offset; i < Offset + dst.Length; i++)
                {
                    if (i < src.Length)
                    {
                        dst[i] = src[i];
                    }
                    else
                    {
                        dst[i] = 0;
                    }
                }
                return;
            }

            case DataType.ObjectReference:
            {
                ObjRefData ord = Data as ObjRefData;
                ACPIObject dst = ord.Object;

                switch (dst.Type)
                {
                case DataType.Buffer:
                    dst.Write(d, ord.Index, mi, s, n);
                    return;

                case DataType.BufferField:
                    dst.Write(d, mi, s, n);
                    return;

                case DataType.FieldUnit:
                    dst.Write(d, mi, s, n);
                    return;

                case DataType.Integer:
                    dst.Data = d.EvaluateTo(DataType.Integer, mi, s, n).IntegerData;
                    return;

                default:
                    throw new NotSupportedException("Write: " + d.Type + " to ObjectReference(" + dst.Type + ")");
                }
            }

            case DataType.BufferField:
            {
                BufferFieldData bfd         = Data as BufferFieldData;
                ACPIObject      new_buf_src = d.EvaluateTo(DataType.Buffer, mi, s, n);
                ACPIObject      new_buf_dst = bfd.Buffer.EvaluateTo(DataType.Buffer, mi, s, n);

                if (bfd.BitOffset % 8 != 0)
                {
                    throw new NotImplementedException("BitOffset not divisible by 8");
                }
                if (bfd.BitLength % 8 != 0)
                {
                    throw new NotImplementedException("BitLength not divisible by 8");
                }

                int byte_offset = bfd.BitOffset / 8;
                int byte_length = bfd.BitLength / 8;

                byte[] src = (byte[])new_buf_src.Data;
                byte[] dst = (byte[])new_buf_dst.Data;

                for (int i = 0; i < byte_length; i++)
                {
                    dst[byte_offset + i] = src[i];
                }

                return;
            }

            case DataType.FieldUnit:
                if (Data is FieldUnitData)
                {
                    FieldUnitData fud       = Data as FieldUnitData;
                    ACPIObject    op_region = fud.OpRegion;
                    if (op_region.Type != DataType.OpRegion)
                    {
                        throw new Exception("Write to FieldUnit with invalid OpRegion type (" + op_region.Type.ToString() + ")");
                    }
                    OpRegionData ord = op_region.Data as OpRegionData;

                    /* Ensure the requested field index is within the opregion */
                    int byte_offset = fud.BitOffset / 8;
                    int byte_length = fud.BitLength / 8;

                    if ((ulong)byte_offset + (ulong)byte_length > ord.Length)
                    {
                        throw new Exception("Write: attempt to write to field beyond length of opregion (offset: " + byte_offset.ToString() + ", length: " + byte_length.ToString() + ", OpRegion.Length: " + ord.Length + ")");
                    }

                    if (fud.BitOffset % 8 != 0)
                    {
                        throw new NotImplementedException("Write: non-byte aligned offset (" + fud.BitOffset.ToString() + ")");
                    }
                    if (fud.BitLength % 8 != 0)
                    {
                        throw new NotImplementedException("Write: non-byte aligned length (" + fud.BitLength.ToString() + ")");
                    }

                    /* Get the data */
                    ulong int_val = d.EvaluateTo(DataType.Integer, mi, s, n).IntegerData;

                    /* Do the write depending on the op region type */
                    switch (ord.RegionSpace)
                    {
                    case 0:
                        // Memory
                        switch (byte_length)
                        {
                        case 1:
                            mi.WriteMemoryByte(ord.Offset + (ulong)byte_offset, (byte)(int_val & 0xff));
                            return;

                        case 2:
                            mi.WriteMemoryWord(ord.Offset + (ulong)byte_offset, (ushort)(int_val & 0xffff));
                            return;

                        case 4:
                            mi.WriteMemoryDWord(ord.Offset + (ulong)byte_offset, (uint)(int_val & 0xffffff));
                            return;

                        case 8:
                            mi.WriteMemoryQWord(ord.Offset + (ulong)byte_offset, int_val);
                            return;

                        default:
                            throw new NotImplementedException("Write: unsupported byte length: " + byte_length.ToString());
                        }

                    case 1:
                        // IO
                        switch (byte_length)
                        {
                        case 1:
                            mi.WriteIOByte(ord.Offset + (ulong)byte_offset, (byte)(int_val & 0xff));
                            return;

                        case 2:
                            mi.WriteIOWord(ord.Offset + (ulong)byte_offset, (ushort)(int_val & 0xffff));
                            return;

                        case 4:
                            mi.WriteIODWord(ord.Offset + (ulong)byte_offset, (uint)(int_val & 0xffffff));
                            return;

                        case 8:
                            mi.WriteIOQWord(ord.Offset + (ulong)byte_offset, int_val);
                            return;

                        default:
                            throw new NotImplementedException("Write: unsupported byte length: " + byte_length.ToString());
                        }

                    case 2:
                        // PCI Configuration space
                    {
                        // try and get the _ADR object for the current device
                        ACPIObject adr = n.Evaluate(ord.Device.ToString() + "._ADR", mi).EvaluateTo(DataType.Integer, mi, s, n);
                        if (adr == null)
                        {
                            throw new Exception(ord.Device.ToString() + "._ADR failed");
                        }

                        uint bus    = 0;
                        uint device = ((uint)adr.IntegerData >> 16) & 0xffffU;
                        uint func   = (uint)adr.IntegerData & 0xffffU;

                        uint offset = (uint)ord.Offset + (uint)byte_offset;

                        switch (byte_length)
                        {
                        case 1:
                            mi.WritePCIByte(bus, device, func, offset, (byte)int_val);
                            return;

                        case 2:
                            mi.WritePCIWord(bus, device, func, offset, (ushort)int_val);
                            return;

                        case 4:
                            mi.WritePCIDWord(bus, device, func, offset, (uint)int_val);
                            return;

                        default:
                            throw new NotImplementedException("Write: unsupported byte length: " + byte_length.ToString());
                        }
                    }

                    default:
                        throw new NotImplementedException("Write: unsupported OpRegion type: " + ord.ToString());
                    }
                }
                else if (Data is IndexFieldUnitData)
                {
                    var ifud = Data as IndexFieldUnitData;

                    /* Ensure the requested field index is byte aligned */
                    int byte_offset = ifud.BitOffset / 8;
                    int byte_length = ifud.BitLength / 8;

                    if (ifud.BitOffset % 8 != 0)
                    {
                        throw new NotImplementedException("Read: non-byte aligned offset (" + ifud.BitOffset.ToString() + ")");
                    }
                    if (ifud.BitLength % 8 != 0)
                    {
                        throw new NotImplementedException("Read: non-byte aligned length (" + ifud.BitLength.ToString() + ")");
                    }

                    /* Get the data */
                    ulong int_val = d.EvaluateTo(DataType.Integer, mi, s, n).IntegerData;

                    /* Write to index port, write to data port */
                    ifud.Index.Write((ulong)byte_offset, mi, s, n);
                    ifud.Data.Write(int_val, mi, s, n);

                    return;
                }
                else
                {
                    throw new NotSupportedException("Invalid FieldUnit data type: " + Data.ToString());
                }

            default:
                throw new NotImplementedException("Write: " + Type.ToString());
            }
            throw new NotImplementedException();
        }