trunk/src/emu/devcb.c
| r18446 | r18447 | |
|---|
| 927 | 927 | } |
| 928 | 928 | |
| 929 | 929 | //************************************************************************** |
| 930 | // DEVCB RESOLVED READ32 |
| 931 | //************************************************************************** |
| 932 | |
| 933 | //------------------------------------------------- |
| 934 | // devcb_resolved_read32 - empty constructor |
| 935 | //------------------------------------------------- |
| 936 | |
| 937 | devcb_resolved_read32::devcb_resolved_read32() |
| 938 | { |
| 939 | m_object.port = NULL; |
| 940 | m_helper.read_line = NULL; |
| 941 | } |
| 942 | |
| 943 | |
| 944 | //------------------------------------------------- |
| 945 | // resolve - resolve to a delegate from a static |
| 946 | // structure definition |
| 947 | //------------------------------------------------- |
| 948 | |
| 949 | void devcb_resolved_read32::resolve(const devcb_read32 &desc, device_t &device) |
| 950 | { |
| 951 | switch (desc.type) |
| 952 | { |
| 953 | default: |
| 954 | case DEVCB_TYPE_NULL: |
| 955 | m_object.constant = 0; |
| 956 | m_helper.null_indicator = &s_null; |
| 957 | *static_cast<devcb_read32_delegate *>(this) = devcb_read32_delegate(&devcb_resolved_read32::from_constant, "(null)", this); |
| 958 | break; |
| 959 | |
| 960 | case DEVCB_TYPE_IOPORT: |
| 961 | m_object.port = devcb_resolver::resolve_port(desc.tag, device); |
| 962 | *static_cast<devcb_read32_delegate *>(this) = devcb_read32_delegate(&devcb_resolved_read32::from_port, desc.tag, this); |
| 963 | break; |
| 964 | |
| 965 | case DEVCB_TYPE_DEVICE: |
| 966 | m_object.device = devcb_resolver::resolve_device(desc.index, desc.tag, device); |
| 967 | if (desc.readdevice != NULL) |
| 968 | { |
| 969 | m_helper.read32_device = desc.readdevice; |
| 970 | *static_cast<devcb_read32_delegate *>(this) = devcb_read32_delegate(&devcb_resolved_read32::from_read32, desc.name, this); |
| 971 | } |
| 972 | else |
| 973 | { |
| 974 | m_helper.read_line = desc.readline; |
| 975 | *static_cast<devcb_read32_delegate *>(this) = devcb_read32_delegate(&devcb_resolved_read32::from_readline, desc.name, this); |
| 976 | } |
| 977 | break; |
| 978 | |
| 979 | case DEVCB_TYPE_LEGACY_SPACE: |
| 980 | m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device); |
| 981 | *static_cast<devcb_read32_delegate *>(this) = devcb_read32_delegate(desc.readspace, desc.name, m_object.space); |
| 982 | break; |
| 983 | |
| 984 | case DEVCB_TYPE_CONSTANT: |
| 985 | m_object.constant = desc.index; |
| 986 | *static_cast<devcb_read32_delegate *>(this) = devcb_read32_delegate(&devcb_resolved_read32::from_constant, "constant", this); |
| 987 | break; |
| 988 | |
| 989 | case DEVCB_TYPE_UNMAP: |
| 990 | m_helper.null_indicator = &s_null; |
| 991 | m_object.device = &device; |
| 992 | *static_cast<devcb_read32_delegate *>(this) = devcb_read32_delegate(&devcb_resolved_read32::from_unmap, "unmap", this); |
| 993 | break; |
| 994 | } |
| 995 | } |
| 996 | |
| 997 | |
| 998 | //------------------------------------------------- |
| 999 | // from_port - helper to convert from an I/O port |
| 1000 | // value to a 32-bit value |
| 1001 | //------------------------------------------------- |
| 1002 | |
| 1003 | UINT32 devcb_resolved_read32::from_port(offs_t offset, UINT32 mask) |
| 1004 | { |
| 1005 | return m_object.port->read(); |
| 1006 | } |
| 1007 | |
| 1008 | |
| 1009 | //------------------------------------------------- |
| 1010 | // from_read32 - helper to convert from a device |
| 1011 | // line read value to a 32-bit value |
| 1012 | //------------------------------------------------- |
| 1013 | |
| 1014 | UINT32 devcb_resolved_read32::from_read32(offs_t offset, UINT32 mask) |
| 1015 | { |
| 1016 | return (*m_helper.read32_device)(m_object.device, m_object.device->machine().driver_data()->generic_space(), offset, mask); |
| 1017 | } |
| 1018 | |
| 1019 | |
| 1020 | //------------------------------------------------- |
| 1021 | // from_read32 - helper to convert from a device |
| 1022 | // line read value to a 32-bit value |
| 1023 | //------------------------------------------------- |
| 1024 | |
| 1025 | UINT32 devcb_resolved_read32::from_readline(offs_t offset, UINT32 mask) |
| 1026 | { |
| 1027 | return (*m_helper.read_line)(m_object.device); |
| 1028 | } |
| 1029 | |
| 1030 | |
| 1031 | //------------------------------------------------- |
| 1032 | // from_constant - helper to convert from a |
| 1033 | // constant value to a 32-bit value |
| 1034 | //------------------------------------------------- |
| 1035 | |
| 1036 | UINT32 devcb_resolved_read32::from_constant(offs_t offset, UINT32 mask) |
| 1037 | { |
| 1038 | return m_object.constant; |
| 1039 | } |
| 1040 | |
| 1041 | //------------------------------------------------- |
| 1042 | // from_constant - helper to convert from a |
| 1043 | // unmap value to a 32-bit value |
| 1044 | //------------------------------------------------- |
| 1045 | |
| 1046 | UINT32 devcb_resolved_read32::from_unmap(offs_t offset, UINT32 mem_mask) |
| 1047 | { |
| 1048 | logerror("%s: unmapped devcb read\n", |
| 1049 | m_object.device->tag()); |
| 1050 | return 0; |
| 1051 | } |
| 1052 | |
| 1053 | //************************************************************************** |
| 930 | 1054 | // DEVCB RESOLVED WRITE32 |
| 931 | 1055 | //************************************************************************** |
| 932 | 1056 | |
| r18446 | r18447 | |
|---|
| 1060 | 1184 | } |
| 1061 | 1185 | |
| 1062 | 1186 | //************************************************************************** |
| 1187 | // DEVCB RESOLVED READ64 |
| 1188 | //************************************************************************** |
| 1189 | |
| 1190 | //------------------------------------------------- |
| 1191 | // devcb_resolved_read64 - empty constructor |
| 1192 | //------------------------------------------------- |
| 1193 | |
| 1194 | devcb_resolved_read64::devcb_resolved_read64() |
| 1195 | { |
| 1196 | m_object.port = NULL; |
| 1197 | m_helper.read_line = NULL; |
| 1198 | } |
| 1199 | |
| 1200 | |
| 1201 | //------------------------------------------------- |
| 1202 | // resolve - resolve to a delegate from a static |
| 1203 | // structure definition |
| 1204 | //------------------------------------------------- |
| 1205 | |
| 1206 | void devcb_resolved_read64::resolve(const devcb_read64 &desc, device_t &device) |
| 1207 | { |
| 1208 | switch (desc.type) |
| 1209 | { |
| 1210 | default: |
| 1211 | case DEVCB_TYPE_NULL: |
| 1212 | m_object.constant = 0; |
| 1213 | m_helper.null_indicator = &s_null; |
| 1214 | *static_cast<devcb_read64_delegate *>(this) = devcb_read64_delegate(&devcb_resolved_read64::from_constant, "(null)", this); |
| 1215 | break; |
| 1216 | |
| 1217 | case DEVCB_TYPE_IOPORT: |
| 1218 | m_object.port = devcb_resolver::resolve_port(desc.tag, device); |
| 1219 | *static_cast<devcb_read64_delegate *>(this) = devcb_read64_delegate(&devcb_resolved_read64::from_port, desc.tag, this); |
| 1220 | break; |
| 1221 | |
| 1222 | case DEVCB_TYPE_DEVICE: |
| 1223 | m_object.device = devcb_resolver::resolve_device(desc.index, desc.tag, device); |
| 1224 | if (desc.readdevice != NULL) |
| 1225 | { |
| 1226 | m_helper.read64_device = desc.readdevice; |
| 1227 | *static_cast<devcb_read64_delegate *>(this) = devcb_read64_delegate(&devcb_resolved_read64::from_read64, desc.name, this); |
| 1228 | } |
| 1229 | else |
| 1230 | { |
| 1231 | m_helper.read_line = desc.readline; |
| 1232 | *static_cast<devcb_read64_delegate *>(this) = devcb_read64_delegate(&devcb_resolved_read64::from_readline, desc.name, this); |
| 1233 | } |
| 1234 | break; |
| 1235 | |
| 1236 | case DEVCB_TYPE_LEGACY_SPACE: |
| 1237 | m_object.space = &devcb_resolver::resolve_space(desc.index, desc.tag, device); |
| 1238 | *static_cast<devcb_read64_delegate *>(this) = devcb_read64_delegate(desc.readspace, desc.name, m_object.space); |
| 1239 | break; |
| 1240 | |
| 1241 | case DEVCB_TYPE_CONSTANT: |
| 1242 | m_object.constant = desc.index; |
| 1243 | *static_cast<devcb_read64_delegate *>(this) = devcb_read64_delegate(&devcb_resolved_read64::from_constant, "constant", this); |
| 1244 | break; |
| 1245 | |
| 1246 | case DEVCB_TYPE_UNMAP: |
| 1247 | m_helper.null_indicator = &s_null; |
| 1248 | m_object.device = &device; |
| 1249 | *static_cast<devcb_read64_delegate *>(this) = devcb_read64_delegate(&devcb_resolved_read64::from_unmap, "unmap", this); |
| 1250 | break; |
| 1251 | } |
| 1252 | } |
| 1253 | |
| 1254 | |
| 1255 | //------------------------------------------------- |
| 1256 | // from_port - helper to convert from an I/O port |
| 1257 | // value to a 64-bit value |
| 1258 | //------------------------------------------------- |
| 1259 | |
| 1260 | UINT64 devcb_resolved_read64::from_port(offs_t offset, UINT64 mask) |
| 1261 | { |
| 1262 | return m_object.port->read(); |
| 1263 | } |
| 1264 | |
| 1265 | |
| 1266 | //------------------------------------------------- |
| 1267 | // from_read64 - helper to convert from a device |
| 1268 | // line read value to a 64-bit value |
| 1269 | //------------------------------------------------- |
| 1270 | |
| 1271 | UINT64 devcb_resolved_read64::from_read64(offs_t offset, UINT64 mask) |
| 1272 | { |
| 1273 | return (*m_helper.read64_device)(m_object.device, m_object.device->machine().driver_data()->generic_space(), offset, mask); |
| 1274 | } |
| 1275 | |
| 1276 | |
| 1277 | //------------------------------------------------- |
| 1278 | // from_read64 - helper to convert from a device |
| 1279 | // line read value to a 64-bit value |
| 1280 | //------------------------------------------------- |
| 1281 | |
| 1282 | UINT64 devcb_resolved_read64::from_readline(offs_t offset, UINT64 mask) |
| 1283 | { |
| 1284 | return (*m_helper.read_line)(m_object.device); |
| 1285 | } |
| 1286 | |
| 1287 | |
| 1288 | //------------------------------------------------- |
| 1289 | // from_constant - helper to convert from a |
| 1290 | // constant value to a 64-bit value |
| 1291 | //------------------------------------------------- |
| 1292 | |
| 1293 | UINT64 devcb_resolved_read64::from_constant(offs_t offset, UINT64 mask) |
| 1294 | { |
| 1295 | return m_object.constant; |
| 1296 | } |
| 1297 | |
| 1298 | //------------------------------------------------- |
| 1299 | // from_constant - helper to convert from a |
| 1300 | // unmap value to a 64-bit value |
| 1301 | //------------------------------------------------- |
| 1302 | |
| 1303 | UINT64 devcb_resolved_read64::from_unmap(offs_t offset, UINT64 mem_mask) |
| 1304 | { |
| 1305 | logerror("%s: unmapped devcb read\n", |
| 1306 | m_object.device->tag()); |
| 1307 | return 0; |
| 1308 | } |
| 1309 | |
| 1310 | //************************************************************************** |
| 1063 | 1311 | // DEVCB RESOLVED WRITE64 |
| 1064 | 1312 | //************************************************************************** |
| 1065 | 1313 | |