trunk/src/emu/machine/wd_fdc.c
| r19401 | r19402 | |
| 263 | 263 | track += last_dir ? -1 : 1; |
| 264 | 264 | counter++; |
| 265 | 265 | sub_state = SEEK_WAIT_STEP_TIME; |
| 266 | | delay_cycles(t_gen, step_time(command & 3)); |
| 266 | delay_cycles(t_gen, step_times[command & 3]); |
| 267 | 267 | return; |
| 268 | 268 | |
| 269 | 269 | case SEEK_WAIT_STEP_TIME: |
| r19401 | r19402 | |
| 429 | 429 | live_start(SEARCH_ADDRESS_MARK_HEADER); |
| 430 | 430 | return; |
| 431 | 431 | } |
| 432 | | // TODO WD2795/7 alternate sector size |
| 433 | | sector_size = 128 << (cur_live.idbuf[3] & 3); |
| 432 | sector_size = calc_sector_size(cur_live.idbuf[3], command); |
| 434 | 433 | sub_state = SECTOR_READ; |
| 435 | 434 | live_start(SEARCH_ADDRESS_MARK_DATA); |
| 436 | 435 | return; |
| r19401 | r19402 | |
| 747 | 746 | live_start(SEARCH_ADDRESS_MARK_HEADER); |
| 748 | 747 | return; |
| 749 | 748 | } |
| 750 | | // TODO WD2795/7 alternate sector size |
| 751 | | sector_size = 128 << (cur_live.idbuf[3] & 3); |
| 749 | sector_size = calc_sector_size(cur_live.idbuf[3], command); |
| 752 | 750 | sub_state = SECTOR_WRITE; |
| 753 | 751 | live_start(WRITE_SECTOR_PRE); |
| 754 | 752 | return; |
| r19401 | r19402 | |
| 911 | 909 | |
| 912 | 910 | cmd_buffer = val; |
| 913 | 911 | |
| 914 | | delay_cycles(t_cmd, dden ? 1 : 1); |
| 912 | delay_cycles(t_cmd, dden ? delay_command_commit*2 : delay_command_commit); |
| 915 | 913 | } |
| 916 | 914 | |
| 917 | 915 | UINT8 wd_fdc_t::status_r() |
| r19401 | r19402 | |
| 972 | 970 | return; |
| 973 | 971 | |
| 974 | 972 | track_buffer = val; |
| 975 | | delay_cycles(t_track, dden ? 32 : 16); |
| 973 | delay_cycles(t_track, dden ? delay_register_commit*2 : delay_register_commit); |
| 976 | 974 | } |
| 977 | 975 | |
| 978 | 976 | UINT8 wd_fdc_t::track_r() |
| r19401 | r19402 | |
| 998 | 996 | return; |
| 999 | 997 | |
| 1000 | 998 | sector_buffer = val; |
| 1001 | | delay_cycles(t_sector, dden ? 32 : 16); |
| 999 | delay_cycles(t_sector, dden ? delay_register_commit*2 : delay_register_commit); |
| 1002 | 1000 | } |
| 1003 | 1001 | |
| 1004 | 1002 | UINT8 wd_fdc_t::sector_r() |
| r19401 | r19402 | |
| 1901 | 1899 | } |
| 1902 | 1900 | } |
| 1903 | 1901 | |
| 1904 | | int wd_fdc_t::step_time(int mode) const |
| 1902 | int wd_fdc_t::calc_sector_size(UINT8 size, UINT8 command) const |
| 1905 | 1903 | { |
| 1906 | | const static int step_times[4] = { 12000, 24000, 40000, 60000 }; |
| 1907 | | return step_times[mode]/10; |
| 1904 | return 128 << (size & 3); |
| 1908 | 1905 | } |
| 1909 | 1906 | |
| 1910 | 1907 | int wd_fdc_t::settle_time() const |
| r19401 | r19402 | |
| 1965 | 1962 | clock_ratio = 4; |
| 1966 | 1963 | } |
| 1967 | 1964 | |
| 1965 | const int wd_fdc_digital_t::wd_digital_step_times[4] = { 12000, 24000, 40000, 60000 }; |
| 1966 | |
| 1968 | 1967 | void wd_fdc_digital_t::pll_reset(bool fm, attotime when) |
| 1969 | 1968 | { |
| 1970 | 1969 | cur_pll.reset(when); |
| r19401 | r19402 | |
| 2163 | 2162 | |
| 2164 | 2163 | fd1771_t::fd1771_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, FD1771x, "FD1771", tag, owner, clock) |
| 2165 | 2164 | { |
| 2165 | const static int fd1771_step_times[4] = { 12000, 12000, 20000, 40000 }; |
| 2166 | |
| 2167 | step_times = fd1771_step_times; |
| 2168 | delay_register_commit = 16; |
| 2169 | delay_command_commit = 20; // x2 due to fm |
| 2166 | 2170 | disable_mfm = true; |
| 2167 | 2171 | inverted_bus = true; |
| 2168 | 2172 | side_control = false; |
| r19401 | r19402 | |
| 2172 | 2176 | ready_hooked = true; |
| 2173 | 2177 | } |
| 2174 | 2178 | |
| 2179 | int fd1771_t::calc_sector_size(UINT8 size, UINT8 command) const |
| 2180 | { |
| 2181 | if(command & 0x08) |
| 2182 | return 128 << (size & 3); |
| 2183 | else |
| 2184 | return size ? size << 4 : 4096; |
| 2185 | } |
| 2186 | |
| 2175 | 2187 | fd1781_t::fd1781_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, FD1781x, "FD1781", tag, owner, clock) |
| 2176 | 2188 | { |
| 2189 | const static int fd1781_step_times[4] = { 6000, 12000, 20000, 40000 }; |
| 2190 | |
| 2191 | step_times = fd1781_step_times; |
| 2192 | delay_register_commit = 16; |
| 2193 | delay_command_commit = 12; |
| 2177 | 2194 | disable_mfm = false; |
| 2178 | 2195 | inverted_bus = true; |
| 2179 | 2196 | side_control = false; |
| r19401 | r19402 | |
| 2183 | 2200 | ready_hooked = true; |
| 2184 | 2201 | } |
| 2185 | 2202 | |
| 2203 | int fd1781_t::calc_sector_size(UINT8 size, UINT8 command) const |
| 2204 | { |
| 2205 | if(command & 0x08) |
| 2206 | return 128 << (size & 3); |
| 2207 | else |
| 2208 | return size ? size << 4 : 4096; |
| 2209 | } |
| 2210 | |
| 2211 | const int wd_fdc_t::fd179x_step_times[4] = { 6000, 12000, 20000, 30000 }; |
| 2212 | const int wd_fdc_t::fd176x_step_times[4] = { 12000, 24000, 40000, 60000 }; |
| 2213 | |
| 2186 | 2214 | fd1791_t::fd1791_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, FD1791x, "FD1791", tag, owner, clock) |
| 2187 | 2215 | { |
| 2216 | step_times = fd179x_step_times; |
| 2217 | delay_register_commit = 16; |
| 2218 | delay_command_commit = 12; |
| 2188 | 2219 | disable_mfm = false; |
| 2189 | 2220 | inverted_bus = true; |
| 2190 | 2221 | side_control = false; |
| r19401 | r19402 | |
| 2196 | 2227 | |
| 2197 | 2228 | fd1792_t::fd1792_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, FD1792x, "FD1792", tag, owner, clock) |
| 2198 | 2229 | { |
| 2230 | step_times = fd179x_step_times; |
| 2231 | delay_register_commit = 16; |
| 2232 | delay_command_commit = 12; |
| 2199 | 2233 | disable_mfm = true; |
| 2200 | 2234 | inverted_bus = true; |
| 2201 | 2235 | side_control = false; |
| r19401 | r19402 | |
| 2207 | 2241 | |
| 2208 | 2242 | fd1793_t::fd1793_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, FD1793x, "FD1793", tag, owner, clock) |
| 2209 | 2243 | { |
| 2244 | step_times = fd179x_step_times; |
| 2245 | delay_register_commit = 16; |
| 2246 | delay_command_commit = 12; |
| 2210 | 2247 | disable_mfm = false; |
| 2211 | 2248 | inverted_bus = false; |
| 2212 | 2249 | side_control = false; |
| r19401 | r19402 | |
| 2218 | 2255 | |
| 2219 | 2256 | fd1794_t::fd1794_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, FD1794x, "FD1794", tag, owner, clock) |
| 2220 | 2257 | { |
| 2258 | step_times = fd179x_step_times; |
| 2259 | delay_register_commit = 16; |
| 2260 | delay_command_commit = 12; |
| 2221 | 2261 | disable_mfm = true; |
| 2222 | 2262 | inverted_bus = false; |
| 2223 | 2263 | side_control = false; |
| r19401 | r19402 | |
| 2229 | 2269 | |
| 2230 | 2270 | fd1795_t::fd1795_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, FD1795x, "FD1795", tag, owner, clock) |
| 2231 | 2271 | { |
| 2272 | step_times = fd179x_step_times; |
| 2273 | delay_register_commit = 16; |
| 2274 | delay_command_commit = 12; |
| 2232 | 2275 | disable_mfm = false; |
| 2233 | 2276 | inverted_bus = true; |
| 2234 | 2277 | side_control = true; |
| r19401 | r19402 | |
| 2238 | 2281 | ready_hooked = true; |
| 2239 | 2282 | } |
| 2240 | 2283 | |
| 2284 | int fd1795_t::calc_sector_size(UINT8 size, UINT8 command) const |
| 2285 | { |
| 2286 | if(command & 0x08) |
| 2287 | return 128 << (size & 3); |
| 2288 | else |
| 2289 | return 128 << ((size + 1) & 3); |
| 2290 | } |
| 2291 | |
| 2241 | 2292 | fd1797_t::fd1797_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, FD1797x, "FD1797", tag, owner, clock) |
| 2242 | 2293 | { |
| 2294 | step_times = fd179x_step_times; |
| 2295 | delay_register_commit = 16; |
| 2296 | delay_command_commit = 12; |
| 2243 | 2297 | disable_mfm = false; |
| 2244 | 2298 | inverted_bus = false; |
| 2245 | 2299 | side_control = true; |
| r19401 | r19402 | |
| 2249 | 2303 | ready_hooked = true; |
| 2250 | 2304 | } |
| 2251 | 2305 | |
| 2306 | int fd1797_t::calc_sector_size(UINT8 size, UINT8 command) const |
| 2307 | { |
| 2308 | if(command & 0x08) |
| 2309 | return 128 << (size & 3); |
| 2310 | else |
| 2311 | return 128 << ((size + 1) & 3); |
| 2312 | } |
| 2313 | |
| 2252 | 2314 | mb8866_t::mb8866_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, MB8866x, "MB8866", tag, owner, clock) |
| 2253 | 2315 | { |
| 2316 | step_times = fd179x_step_times; |
| 2317 | delay_register_commit = 16; |
| 2318 | delay_command_commit = 12; |
| 2254 | 2319 | disable_mfm = false; |
| 2255 | 2320 | inverted_bus = true; |
| 2256 | 2321 | side_control = false; |
| r19401 | r19402 | |
| 2262 | 2327 | |
| 2263 | 2328 | mb8876_t::mb8876_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, MB8876x, "MB8876", tag, owner, clock) |
| 2264 | 2329 | { |
| 2330 | step_times = fd179x_step_times; |
| 2331 | delay_register_commit = 16; |
| 2332 | delay_command_commit = 12; |
| 2265 | 2333 | disable_mfm = false; |
| 2266 | 2334 | inverted_bus = true; |
| 2267 | 2335 | side_control = false; |
| r19401 | r19402 | |
| 2273 | 2341 | |
| 2274 | 2342 | mb8877_t::mb8877_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, MB8877x, "MB8877", tag, owner, clock) |
| 2275 | 2343 | { |
| 2344 | step_times = fd179x_step_times; |
| 2345 | delay_register_commit = 16; |
| 2346 | delay_command_commit = 12; |
| 2276 | 2347 | disable_mfm = false; |
| 2277 | 2348 | inverted_bus = false; |
| 2278 | 2349 | side_control = false; |
| r19401 | r19402 | |
| 2284 | 2355 | |
| 2285 | 2356 | fd1761_t::fd1761_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, FD1761x, "FD1761", tag, owner, clock) |
| 2286 | 2357 | { |
| 2358 | step_times = fd176x_step_times; |
| 2359 | delay_register_commit = 16; |
| 2360 | delay_command_commit = 12; |
| 2287 | 2361 | disable_mfm = false; |
| 2288 | 2362 | inverted_bus = true; |
| 2289 | 2363 | side_control = false; |
| r19401 | r19402 | |
| 2295 | 2369 | |
| 2296 | 2370 | fd1763_t::fd1763_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, FD1763x, "FD1763", tag, owner, clock) |
| 2297 | 2371 | { |
| 2372 | step_times = fd176x_step_times; |
| 2373 | delay_register_commit = 16; |
| 2374 | delay_command_commit = 12; |
| 2298 | 2375 | disable_mfm = false; |
| 2299 | 2376 | inverted_bus = false; |
| 2300 | 2377 | side_control = false; |
| r19401 | r19402 | |
| 2306 | 2383 | |
| 2307 | 2384 | fd1765_t::fd1765_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, FD1765x, "FD1765", tag, owner, clock) |
| 2308 | 2385 | { |
| 2386 | step_times = fd176x_step_times; |
| 2387 | delay_register_commit = 16; |
| 2388 | delay_command_commit = 12; |
| 2309 | 2389 | disable_mfm = false; |
| 2310 | 2390 | inverted_bus = true; |
| 2311 | 2391 | side_control = true; |
| r19401 | r19402 | |
| 2315 | 2395 | ready_hooked = true; |
| 2316 | 2396 | } |
| 2317 | 2397 | |
| 2398 | int fd1765_t::calc_sector_size(UINT8 size, UINT8 command) const |
| 2399 | { |
| 2400 | if(command & 0x08) |
| 2401 | return 128 << (size & 3); |
| 2402 | else |
| 2403 | return 128 << ((size + 1) & 3); |
| 2404 | } |
| 2405 | |
| 2318 | 2406 | fd1767_t::fd1767_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, FD1767x, "FD1767", tag, owner, clock) |
| 2319 | 2407 | { |
| 2408 | step_times = fd179x_step_times; |
| 2409 | delay_register_commit = 16; |
| 2410 | delay_command_commit = 12; |
| 2320 | 2411 | disable_mfm = false; |
| 2321 | 2412 | inverted_bus = false; |
| 2322 | 2413 | side_control = true; |
| r19401 | r19402 | |
| 2326 | 2417 | ready_hooked = true; |
| 2327 | 2418 | } |
| 2328 | 2419 | |
| 2420 | int fd1767_t::calc_sector_size(UINT8 size, UINT8 command) const |
| 2421 | { |
| 2422 | if(command & 0x08) |
| 2423 | return 128 << (size & 3); |
| 2424 | else |
| 2425 | return 128 << ((size + 1) & 3); |
| 2426 | } |
| 2427 | |
| 2329 | 2428 | wd2791_t::wd2791_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, WD2791x, "WD2791", tag, owner, clock) |
| 2330 | 2429 | { |
| 2430 | step_times = fd179x_step_times; |
| 2431 | delay_register_commit = 16; |
| 2432 | delay_command_commit = 12; |
| 2331 | 2433 | disable_mfm = false; |
| 2332 | 2434 | inverted_bus = true; |
| 2333 | 2435 | side_control = false; |
| r19401 | r19402 | |
| 2339 | 2441 | |
| 2340 | 2442 | wd2793_t::wd2793_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, WD2793x, "WD2793", tag, owner, clock) |
| 2341 | 2443 | { |
| 2444 | step_times = fd179x_step_times; |
| 2445 | delay_register_commit = 16; |
| 2446 | delay_command_commit = 12; |
| 2342 | 2447 | disable_mfm = false; |
| 2343 | 2448 | inverted_bus = false; |
| 2344 | 2449 | side_control = false; |
| r19401 | r19402 | |
| 2350 | 2455 | |
| 2351 | 2456 | wd2795_t::wd2795_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, WD2795x, "WD2795", tag, owner, clock) |
| 2352 | 2457 | { |
| 2458 | step_times = fd179x_step_times; |
| 2459 | delay_register_commit = 16; |
| 2460 | delay_command_commit = 12; |
| 2353 | 2461 | disable_mfm = false; |
| 2354 | 2462 | inverted_bus = true; |
| 2355 | 2463 | side_control = true; |
| r19401 | r19402 | |
| 2359 | 2467 | ready_hooked = true; |
| 2360 | 2468 | } |
| 2361 | 2469 | |
| 2470 | int wd2795_t::calc_sector_size(UINT8 size, UINT8 command) const |
| 2471 | { |
| 2472 | if(command & 0x08) |
| 2473 | return 128 << (size & 3); |
| 2474 | else |
| 2475 | return 128 << ((size + 1) & 3); |
| 2476 | } |
| 2477 | |
| 2362 | 2478 | wd2797_t::wd2797_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_analog_t(mconfig, WD2797x, "WD2797", tag, owner, clock) |
| 2363 | 2479 | { |
| 2480 | step_times = fd179x_step_times; |
| 2481 | delay_register_commit = 16; |
| 2482 | delay_command_commit = 12; |
| 2364 | 2483 | disable_mfm = false; |
| 2365 | 2484 | inverted_bus = false; |
| 2366 | 2485 | side_control = true; |
| r19401 | r19402 | |
| 2370 | 2489 | ready_hooked = true; |
| 2371 | 2490 | } |
| 2372 | 2491 | |
| 2492 | int wd2797_t::calc_sector_size(UINT8 size, UINT8 command) const |
| 2493 | { |
| 2494 | if(command & 0x08) |
| 2495 | return 128 << (size & 3); |
| 2496 | else |
| 2497 | return 128 << ((size + 1) & 3); |
| 2498 | } |
| 2499 | |
| 2373 | 2500 | wd1770_t::wd1770_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_digital_t(mconfig, WD1770x, "WD1770", tag, owner, clock) |
| 2374 | 2501 | { |
| 2502 | step_times = wd_digital_step_times; |
| 2503 | delay_register_commit = 32; |
| 2504 | delay_command_commit = 48; |
| 2375 | 2505 | disable_mfm = false; |
| 2376 | 2506 | inverted_bus = false; |
| 2377 | 2507 | side_control = false; |
| r19401 | r19402 | |
| 2383 | 2513 | |
| 2384 | 2514 | wd1772_t::wd1772_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_digital_t(mconfig, WD1772x, "WD1772", tag, owner, clock) |
| 2385 | 2515 | { |
| 2516 | const static int wd1772_step_times[4] = { 12000, 24000, 4000, 6000 }; |
| 2517 | |
| 2518 | step_times = wd1772_step_times; |
| 2519 | delay_register_commit = 32; |
| 2520 | delay_command_commit = 48; |
| 2386 | 2521 | disable_mfm = false; |
| 2387 | 2522 | inverted_bus = false; |
| 2388 | 2523 | side_control = false; |
| r19401 | r19402 | |
| 2392 | 2527 | ready_hooked = false; |
| 2393 | 2528 | } |
| 2394 | 2529 | |
| 2395 | | int wd1772_t::step_time(int mode) const |
| 2396 | | { |
| 2397 | | const static int step_times[4] = { 12000, 24000, 4000, 6000 }; |
| 2398 | | return step_times[mode]; |
| 2399 | | } |
| 2400 | | |
| 2401 | 2530 | int wd1772_t::settle_time() const |
| 2402 | 2531 | { |
| 2403 | 2532 | return 30000; |
| r19401 | r19402 | |
| 2405 | 2534 | |
| 2406 | 2535 | wd1773_t::wd1773_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) : wd_fdc_digital_t(mconfig, WD1773x, "WD1773", tag, owner, clock) |
| 2407 | 2536 | { |
| 2537 | step_times = wd_digital_step_times; |
| 2538 | delay_register_commit = 32; |
| 2539 | delay_command_commit = 48; |
| 2408 | 2540 | disable_mfm = false; |
| 2409 | 2541 | inverted_bus = false; |
| 2410 | 2542 | side_control = false; |
trunk/src/emu/machine/wd_fdc.h
| r19401 | r19402 | |
| 164 | 164 | bool motor_control; |
| 165 | 165 | bool ready_hooked; |
| 166 | 166 | int clock_ratio; |
| 167 | const int *step_times; |
| 168 | int delay_register_commit; |
| 169 | int delay_command_commit; |
| 167 | 170 | |
| 171 | static const int fd179x_step_times[4]; |
| 172 | static const int fd176x_step_times[4]; |
| 173 | |
| 168 | 174 | virtual void device_start(); |
| 169 | 175 | virtual void device_reset(); |
| 170 | 176 | virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr); |
| 171 | 177 | |
| 172 | | virtual int step_time(int mode) const; |
| 178 | virtual int calc_sector_size(UINT8 size, UINT8 command) const; |
| 173 | 179 | virtual int settle_time() const; |
| 174 | 180 | |
| 175 | 181 | virtual void pll_reset(bool fm, attotime when) = 0; |
| r19401 | r19402 | |
| 429 | 435 | wd_fdc_digital_t(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock); |
| 430 | 436 | |
| 431 | 437 | protected: |
| 438 | static const int wd_digital_step_times[4]; |
| 439 | |
| 432 | 440 | virtual void pll_reset(bool fm, attotime when); |
| 433 | 441 | virtual void pll_start_writing(attotime tm); |
| 434 | 442 | virtual void pll_commit(floppy_image_device *floppy, attotime tm); |
| r19401 | r19402 | |
| 469 | 477 | class fd1771_t : public wd_fdc_analog_t { |
| 470 | 478 | public: |
| 471 | 479 | fd1771_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 480 | |
| 481 | protected: |
| 482 | virtual int calc_sector_size(UINT8 size, UINT8 command) const; |
| 472 | 483 | }; |
| 473 | 484 | |
| 474 | 485 | class fd1781_t : public wd_fdc_analog_t { |
| 475 | 486 | public: |
| 476 | 487 | fd1781_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 488 | |
| 489 | protected: |
| 490 | virtual int calc_sector_size(UINT8 size, UINT8 command) const; |
| 477 | 491 | }; |
| 478 | 492 | |
| 479 | 493 | class fd1791_t : public wd_fdc_analog_t { |
| r19401 | r19402 | |
| 499 | 513 | class fd1795_t : public wd_fdc_analog_t { |
| 500 | 514 | public: |
| 501 | 515 | fd1795_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 516 | |
| 517 | protected: |
| 518 | virtual int calc_sector_size(UINT8 size, UINT8 command) const; |
| 502 | 519 | }; |
| 503 | 520 | |
| 504 | 521 | class fd1797_t : public wd_fdc_analog_t { |
| 505 | 522 | public: |
| 506 | 523 | fd1797_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 524 | |
| 525 | protected: |
| 526 | virtual int calc_sector_size(UINT8 size, UINT8 command) const; |
| 507 | 527 | }; |
| 508 | 528 | |
| 509 | 529 | class mb8866_t : public wd_fdc_analog_t { |
| r19401 | r19402 | |
| 534 | 554 | class fd1765_t : public wd_fdc_analog_t { |
| 535 | 555 | public: |
| 536 | 556 | fd1765_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 557 | |
| 558 | protected: |
| 559 | virtual int calc_sector_size(UINT8 size, UINT8 command) const; |
| 537 | 560 | }; |
| 538 | 561 | |
| 539 | 562 | class fd1767_t : public wd_fdc_analog_t { |
| 540 | 563 | public: |
| 541 | 564 | fd1767_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 565 | |
| 566 | protected: |
| 567 | virtual int calc_sector_size(UINT8 size, UINT8 command) const; |
| 542 | 568 | }; |
| 543 | 569 | |
| 544 | 570 | class wd2791_t : public wd_fdc_analog_t { |
| r19401 | r19402 | |
| 554 | 580 | class wd2795_t : public wd_fdc_analog_t { |
| 555 | 581 | public: |
| 556 | 582 | wd2795_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 583 | |
| 584 | protected: |
| 585 | virtual int calc_sector_size(UINT8 size, UINT8 command) const; |
| 557 | 586 | }; |
| 558 | 587 | |
| 559 | 588 | class wd2797_t : public wd_fdc_analog_t { |
| 560 | 589 | public: |
| 561 | 590 | wd2797_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 591 | |
| 592 | protected: |
| 593 | virtual int calc_sector_size(UINT8 size, UINT8 command) const; |
| 562 | 594 | }; |
| 563 | 595 | |
| 564 | 596 | class wd1770_t : public wd_fdc_digital_t { |
| r19401 | r19402 | |
| 571 | 603 | wd1772_t(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 572 | 604 | |
| 573 | 605 | protected: |
| 574 | | virtual int step_time(int mode) const; |
| 575 | 606 | virtual int settle_time() const; |
| 576 | 607 | }; |
| 577 | 608 | |