isa_fake.cc (3502:1ba705a3754b) isa_fake.cc (3814:33bd4ec9d66a)
1/*
2 * Copyright (c) 2004-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;

--- 33 unchanged lines hidden (view full) ---

42using namespace std;
43
44IsaFake::IsaFake(Params *p)
45 : BasicPioDevice(p)
46{
47 if (!params()->retBadAddr)
48 pioSize = p->pio_size;
49
1/*
2 * Copyright (c) 2004-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;

--- 33 unchanged lines hidden (view full) ---

42using namespace std;
43
44IsaFake::IsaFake(Params *p)
45 : BasicPioDevice(p)
46{
47 if (!params()->retBadAddr)
48 pioSize = p->pio_size;
49
50 memset(&retData, p->retData, sizeof(retData));
50 retData8 = params()->retData8;
51 retData16 = params()->retData16;
52 retData32 = params()->retData32;
53 retData64 = params()->retData64;
51}
52
53Tick
54IsaFake::read(PacketPtr pkt)
55{
56 assert(pkt->result == Packet::Unknown);
57
54}
55
56Tick
57IsaFake::read(PacketPtr pkt)
58{
59 assert(pkt->result == Packet::Unknown);
60
61 if (params()->warnAccess != "")
62 warn("Device %s accessed by read to address %#x size=%d\n",
63 name(), pkt->getAddr(), pkt->getSize());
58 if (params()->retBadAddr) {
59 DPRINTF(Tsunami, "read to bad address va=%#x size=%d\n",
60 pkt->getAddr(), pkt->getSize());
61 pkt->result = Packet::BadAddress;
62 } else {
63 assert(pkt->getAddr() >= pioAddr && pkt->getAddr() < pioAddr + pioSize);
64 DPRINTF(Tsunami, "read va=%#x size=%d\n",
65 pkt->getAddr(), pkt->getSize());
66 switch (pkt->getSize()) {
67 case sizeof(uint64_t):
64 if (params()->retBadAddr) {
65 DPRINTF(Tsunami, "read to bad address va=%#x size=%d\n",
66 pkt->getAddr(), pkt->getSize());
67 pkt->result = Packet::BadAddress;
68 } else {
69 assert(pkt->getAddr() >= pioAddr && pkt->getAddr() < pioAddr + pioSize);
70 DPRINTF(Tsunami, "read va=%#x size=%d\n",
71 pkt->getAddr(), pkt->getSize());
72 switch (pkt->getSize()) {
73 case sizeof(uint64_t):
68 pkt->set(retData);
74 pkt->set(retData64);
69 break;
70 case sizeof(uint32_t):
75 break;
76 case sizeof(uint32_t):
71 pkt->set((uint32_t)retData);
77 pkt->set(retData32);
72 break;
73 case sizeof(uint16_t):
78 break;
79 case sizeof(uint16_t):
74 pkt->set((uint16_t)retData);
80 pkt->set(retData16);
75 break;
76 case sizeof(uint8_t):
81 break;
82 case sizeof(uint8_t):
77 pkt->set((uint8_t)retData);
83 pkt->set(retData8);
78 break;
79 default:
80 panic("invalid access size!\n");
81 }
82 pkt->result = Packet::Success;
83 }
84 return pioDelay;
85}
86
87Tick
88IsaFake::write(PacketPtr pkt)
89{
84 break;
85 default:
86 panic("invalid access size!\n");
87 }
88 pkt->result = Packet::Success;
89 }
90 return pioDelay;
91}
92
93Tick
94IsaFake::write(PacketPtr pkt)
95{
96 if (params()->warnAccess != "") {
97 uint64_t data;
98 switch (pkt->getSize()) {
99 case sizeof(uint64_t):
100 data = pkt->get<uint64_t>();
101 break;
102 case sizeof(uint32_t):
103 data = pkt->get<uint32_t>();
104 break;
105 case sizeof(uint16_t):
106 data = pkt->get<uint16_t>();
107 break;
108 case sizeof(uint8_t):
109 data = pkt->get<uint8_t>();
110 break;
111 default:
112 panic("invalid access size!\n");
113 }
114 warn("Device %s accessed by write to address %#x size=%d data=%#x\n",
115 name(), pkt->getAddr(), pkt->getSize(), data);
116 }
90 if (params()->retBadAddr) {
91 DPRINTF(Tsunami, "write to bad address va=%#x size=%d \n",
92 pkt->getAddr(), pkt->getSize());
93 pkt->result = Packet::BadAddress;
94 } else {
95 DPRINTF(Tsunami, "write - va=%#x size=%d \n",
96 pkt->getAddr(), pkt->getSize());
117 if (params()->retBadAddr) {
118 DPRINTF(Tsunami, "write to bad address va=%#x size=%d \n",
119 pkt->getAddr(), pkt->getSize());
120 pkt->result = Packet::BadAddress;
121 } else {
122 DPRINTF(Tsunami, "write - va=%#x size=%d \n",
123 pkt->getAddr(), pkt->getSize());
124
125 if (params()->updateData) {
126 switch (pkt->getSize()) {
127 case sizeof(uint64_t):
128 retData64 = pkt->get<uint64_t>();
129 break;
130 case sizeof(uint32_t):
131 retData32 = pkt->get<uint32_t>();
132 break;
133 case sizeof(uint16_t):
134 retData16 = pkt->get<uint16_t>();
135 break;
136 case sizeof(uint8_t):
137 retData8 = pkt->get<uint8_t>();
138 break;
139 default:
140 panic("invalid access size!\n");
141 }
142 }
97 pkt->result = Packet::Success;
98 }
99 return pioDelay;
100}
101
102BEGIN_DECLARE_SIM_OBJECT_PARAMS(IsaFake)
103
104 Param<Addr> pio_addr;
105 Param<Tick> pio_latency;
106 Param<Addr> pio_size;
107 Param<bool> ret_bad_addr;
143 pkt->result = Packet::Success;
144 }
145 return pioDelay;
146}
147
148BEGIN_DECLARE_SIM_OBJECT_PARAMS(IsaFake)
149
150 Param<Addr> pio_addr;
151 Param<Tick> pio_latency;
152 Param<Addr> pio_size;
153 Param<bool> ret_bad_addr;
108 Param<uint8_t> ret_data;
154 Param<bool> update_data;
155 Param<std::string> warn_access;
156 Param<uint8_t> ret_data8;
157 Param<uint16_t> ret_data16;
158 Param<uint32_t> ret_data32;
159 Param<uint64_t> ret_data64;
109 SimObjectParam<Platform *> platform;
110 SimObjectParam<System *> system;
111
112END_DECLARE_SIM_OBJECT_PARAMS(IsaFake)
113
114BEGIN_INIT_SIM_OBJECT_PARAMS(IsaFake)
115
116 INIT_PARAM(pio_addr, "Device Address"),
117 INIT_PARAM(pio_latency, "Programmed IO latency"),
118 INIT_PARAM(pio_size, "Size of address range"),
119 INIT_PARAM(ret_bad_addr, "Return pkt status BadAddr"),
160 SimObjectParam<Platform *> platform;
161 SimObjectParam<System *> system;
162
163END_DECLARE_SIM_OBJECT_PARAMS(IsaFake)
164
165BEGIN_INIT_SIM_OBJECT_PARAMS(IsaFake)
166
167 INIT_PARAM(pio_addr, "Device Address"),
168 INIT_PARAM(pio_latency, "Programmed IO latency"),
169 INIT_PARAM(pio_size, "Size of address range"),
170 INIT_PARAM(ret_bad_addr, "Return pkt status BadAddr"),
120 INIT_PARAM(ret_data, "Data to return if not bad addr"),
171 INIT_PARAM(update_data, "Update returned data"),
172 INIT_PARAM(warn_access, "Warn if this device is touched"),
173 INIT_PARAM(ret_data8, "Data to return if not bad addr"),
174 INIT_PARAM(ret_data16, "Data to return if not bad addr"),
175 INIT_PARAM(ret_data32, "Data to return if not bad addr"),
176 INIT_PARAM(ret_data64, "Data to return if not bad addr"),
121 INIT_PARAM(platform, "platform"),
122 INIT_PARAM(system, "system object")
123
124END_INIT_SIM_OBJECT_PARAMS(IsaFake)
125
126CREATE_SIM_OBJECT(IsaFake)
127{
128 IsaFake::Params *p = new IsaFake::Params;
129 p->name = getInstanceName();
130 p->pio_addr = pio_addr;
131 p->pio_delay = pio_latency;
132 p->pio_size = pio_size;
133 p->retBadAddr = ret_bad_addr;
177 INIT_PARAM(platform, "platform"),
178 INIT_PARAM(system, "system object")
179
180END_INIT_SIM_OBJECT_PARAMS(IsaFake)
181
182CREATE_SIM_OBJECT(IsaFake)
183{
184 IsaFake::Params *p = new IsaFake::Params;
185 p->name = getInstanceName();
186 p->pio_addr = pio_addr;
187 p->pio_delay = pio_latency;
188 p->pio_size = pio_size;
189 p->retBadAddr = ret_bad_addr;
134 p->retData = ret_data;
190 p->updateData = update_data;
191 p->warnAccess = warn_access;
192 p->retData8= ret_data8;
193 p->retData16 = ret_data16;
194 p->retData32 = ret_data32;
195 p->retData64 = ret_data64;
135 p->platform = platform;
136 p->system = system;
137 return new IsaFake(p);
138}
139
140REGISTER_SIM_OBJECT("IsaFake", IsaFake)
196 p->platform = platform;
197 p->system = system;
198 return new IsaFake(p);
199}
200
201REGISTER_SIM_OBJECT("IsaFake", IsaFake)