Lines Matching +full:fails +full:- +full:without +full:- +full:test +full:- +full:cd
1 // SPDX-License-Identifier: GPL-2.0-only
11 * 02.12.91 - Changed to static variables to indicate need for reset
29 * call "floppy-on" directly, but have to set a special timer interrupt
34 * 28.02.92 - made track-buffering routines, based on the routines written
39 * Automatic floppy-detection and formatting written by Werner Almesberger
41 * the floppy-change signal detection.
45 * 1992/7/22 -- Hennus Bergman: Added better error reporting, fixed
49 * 1992/9/17: Added DMA allocation & DMA functions. -- hhb.
56 * modeled after the freeware MS-DOS program fdformat/88 V1.8 by
65 * 1993/4/29 -- Linus -- cleaned up the timer handling in the kernel, and
70 /* 1994/6/24 --bbroad-- added the floppy table entries and made
74 /* 1994/7/13 -- Paul Vojta -- modified the probing code to allow three or more
79 * 1994/8/8 -- Alain Knaff -- Switched to fdpatch driver: Support for bigger
83 /* 1994/9/17 -- Koen Holtman -- added logging of physical floppy write
87 /* 1995/4/24 -- Dan Fandrich -- added support for Commodore 1581 3.5" disks
90 * drives are "upside-down").
94 * 1995/8/26 -- Andreas Busse -- added Mips support.
98 * 1995/10/18 -- Ralf Baechle -- Portability cleanup; move machine dependent
103 * 1998/1/21 -- Richard Gooch <rgooch@atnf.csiro.au> -- devfs support
107 * 1998/05/07 -- Russell King -- More portability cleanups; moved definition of
113 * 1998/06/07 -- Alan Cox -- Merged the 2.0.34 fixes for resource allocation
118 * 1998/09/20 -- David Weinehall -- Added slow-down code for buggy PS/2-drives.
122 * 1999/08/13 -- Paul Slootman -- floppy stopped working on Alpha after 24
128 * 2000/08/28 -- Arnaldo Carvalho de Melo <acme@conectiva.com.br>
129 * - get rid of check_region
130 * - s/suser/capable/
134 * 2001/08/26 -- Paul Gortmaker - fix insmod oops on machines with no
139 * 2002/02/07 -- Anton Altaparmakov - Fix io ports reservation to correct range
140 * (0x3f2-0x3f5, 0x3f7). This fix is a bit of a hack but the proper fix
141 * requires many non-obvious changes in arch dependent code.
144 /* 2003/07/28 -- Daniele Bellucci <bellucda@tiscali.it>.
159 #define debug_dcl(test, fmt, args...) \ argument
160 do { if ((test) & FD_DEBUG) DPRINT(fmt, ##args); } while (0)
162 #define debug_dcl(test, fmt, args...) \ argument
246 * some ports reference this variable from there. -DaveM
255 #include <linux/blk-mq.h>
308 #define PH_HEAD(floppy, head) (((((floppy)->stretch & 2) >> 1) ^ head) << 2)
309 #define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
374 | | | | | | | | | | | | | -Max Errors- flags */
395 /* | --autodetected formats--- | | |
417 * are located on side 1 of the disk but with a side 0 ID, and vice-versa.
418 * This is the same as the Sharp MZ-80 5.25" CP/M disk format, except that the
430 * Other parameters should be self-explanatory (see also setfdprm(8)).
482 /* Auto-detection: Disk type used until the next media change occurs. */
486 * User-provided type information. current_type points to
503 #define FD_COMMAND_NONE -1
571 #define NO_TRACK -1
572 #define NEED_1_RECAL -2
573 #define NEED_2_RECAL -3
578 static int buffer_track = -1;
579 static int buffer_drive = -1;
580 static int buffer_min = -1;
581 static int buffer_max = -1;
614 return -EINVAL; in fd_eject()
633 pr_info("%s:%s dtime=%lu\n", func, msg, jiffies - debugtimer); in debugt()
671 #define MAXTIMEOUT -2
706 * and also the main service loop (seek-configure-spinup-command)
801 if (fdc_state[fdc].address == -1) in set_dor()
802 return -1; in set_dor()
844 fdc_state[fdc].spec1 = fdc_state[fdc].spec2 = -1; in reset_fdc_info()
875 set_dor(1 - fdc, ~8, 0); in set_fdc()
894 return -1; in lock_fdc()
897 return -EINTR; in lock_fdc()
924 unsigned long nr = t - motor_off_timer; in motor_off_callback()
947 delta = jiffies - drive_state[drive].first_read_date + HZ - in floppy_off()
951 jiffies + drive_params[drive].spindown - delta; in floppy_off()
1032 cont->done(0); in fd_watchdog()
1044 cont->interrupt(); in main_command_interrupt()
1061 queue_delayed_work(floppy_wq, &fd_timer, expires - jiffies); in fd_wait_for_completion()
1071 if (raw_cmd->length == 0) { in setup_DMA()
1074 raw_cmd->fullcmd, raw_cmd->cmd_count, false); in setup_DMA()
1075 cont->done(0); in setup_DMA()
1079 if (((unsigned long)raw_cmd->kernel_data) % 512) { in setup_DMA()
1080 pr_info("non aligned address: %p\n", raw_cmd->kernel_data); in setup_DMA()
1081 cont->done(0); in setup_DMA()
1088 if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length, in setup_DMA()
1089 (raw_cmd->flags & FD_RAW_READ) ? in setup_DMA()
1093 cont->done(0); in setup_DMA()
1100 fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length); in setup_DMA()
1101 fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ) ? in setup_DMA()
1103 fd_set_dma_addr(raw_cmd->kernel_data); in setup_DMA()
1104 fd_set_dma_count(raw_cmd->length); in setup_DMA()
1120 return -1; in wait_til_ready()
1131 return -1; in wait_til_ready()
1140 return -1; in output_byte()
1156 return -1; in output_byte()
1186 return -1; in result()
1189 #define MORE_OUTPUT -2
1196 return -1; in need_more_output()
1205 * 82077 Now tested. 1Mbps data rate only possible with 82077-1.
1211 if (raw_cmd->rate & 0x40) { in perpendicular_mode()
1212 switch (raw_cmd->rate & 3) { in perpendicular_mode()
1221 cont->done(0); in perpendicular_mode()
1225 * redo without too much hassle in perpendicular_mode()
1255 output_byte(fdc, 0); /* pre-compensation from track 0 upwards */ in fdc_configure()
1265 * to account for the data rate-based scaling done by the 82072 and 82077
1298 switch (raw_cmd->rate & 0x03) { in fdc_specify()
1326 srt = 16 - DIV_ROUND_UP(drive_params[drive].srt * scale_dtr / 1000, in fdc_specify()
1368 if ((raw_cmd->rate & 3) == fdc_state[current_fdc].dtr) in fdc_dtr()
1372 fdc_outb(raw_cmd->rate & 3, current_fdc, FD_DCR); in fdc_dtr()
1379 fdc_state[current_fdc].dtr = raw_cmd->rate & 3; in fdc_dtr()
1434 DPRINT("-- FDC reply error\n"); in interpret_errors()
1443 return 0; /* occurs with pseudo-DMA */ in interpret_errors()
1449 cont->done(0); in interpret_errors()
1456 DPRINT("Over/Underrun - retrying\n"); in interpret_errors()
1467 cont->done(0); in interpret_errors()
1471 cont->error(); in interpret_errors()
1491 flags = raw_cmd->flags; in setup_rw_floppy()
1502 ready_date -= drive_params[current_drive].select_delay; in setup_rw_floppy()
1518 for (i = 0; i < raw_cmd->cmd_count; i++) in setup_rw_floppy()
1519 r |= output_byte(current_fdc, raw_cmd->fullcmd[i]); in setup_rw_floppy()
1524 cont->error(); in setup_rw_floppy()
1531 cont->interrupt(); in setup_rw_floppy()
1548 cont->error(); in seek_interrupt()
1549 cont->redo(); in seek_interrupt()
1604 disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) { in seek_floppy()
1611 cont->done(0); in seek_floppy()
1612 cont->redo(); in seek_floppy()
1619 (raw_cmd->flags & FD_RAW_NEED_DISK) && in seek_floppy()
1620 …(drive_state[current_drive].track <= NO_TRACK || drive_state[current_drive].track == raw_cmd->trac… in seek_floppy()
1621 /* we seek to clear the media-changed condition. Does anybody in seek_floppy()
1623 if (raw_cmd->track) in seek_floppy()
1624 track = raw_cmd->track - 1; in seek_floppy()
1629 raw_cmd->flags |= FD_RAW_NEED_SEEK; in seek_floppy()
1635 if (raw_cmd->track != drive_state[current_drive].track && in seek_floppy()
1636 (raw_cmd->flags & FD_RAW_NEED_SEEK)) in seek_floppy()
1637 track = raw_cmd->track; in seek_floppy()
1666 * computers possessed by the Devil :-) */ in recal_interrupt()
1667 cont->error(); in recal_interrupt()
1668 cont->redo(); in recal_interrupt()
1727 if (current_fdc >= N_FDC || fdc_state[current_fdc].address == -1) { in floppy_interrupt()
1758 max_sensei--; in floppy_interrupt()
1790 pr_info("reset set in interrupt, calling %ps\n", cont->error); in reset_interrupt()
1791 cont->error(); /* a reset just after a reset. BAD! */ in reset_interrupt()
1793 cont->redo(); in reset_interrupt()
1800 * cont's ->redo() to be called via reset_interrupt().
1810 /* Pseudo-DMA may intercept 'reset finished' interrupt. */ in reset_fdc()
1833 pr_info("-------------------\n"); in show_floppy()
1835 jiffies, interruptjiffies, jiffies - interruptjiffies, in show_floppy()
1859 fd_timer.timer.expires - jiffies); in show_floppy()
1863 fd_timeout.timer.expires - jiffies); in show_floppy()
1889 cont->done(0); in floppy_shutdown()
1890 cont->redo(); /* this will recall reset when needed */ in floppy_shutdown()
1898 /* start motor, check media-changed condition and write protection */
1906 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) { in start_motor()
1940 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) && in floppy_ready()
1946 if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) { in floppy_ready()
1948 fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length); in floppy_ready()
1953 if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) { in floppy_ready()
1958 if ((raw_cmd->flags & FD_RAW_READ) || in floppy_ready()
1959 (raw_cmd->flags & FD_RAW_WRITE)) in floppy_ready()
2013 * return -EINTR, in which case the driver will automatically be unlocked.
2030 return -EINTR; in wait_til_done()
2038 ret = -EIO; in wait_til_done()
2051 cont->done(1); in generic_success()
2056 cont->done(0); in generic_failure()
2062 cont->redo(); in success_and_wakeup()
2101 cont->done(0); in bad_flp_intr()
2126 cont->error(); in format_interrupt()
2130 cont->done(1); in format_interrupt()
2132 cont->redo(); in format_interrupt()
2135 #define FM_MODE(x, y) ((y) & ~(((x)->rate & 0x80) >> 1))
2150 raw_cmd->track = track; in setup_format_params()
2152 raw_cmd->flags = (FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN | in setup_format_params()
2154 raw_cmd->rate = _floppy->rate & 0x43; in setup_format_params()
2155 raw_cmd->cmd_count = NR_F; in setup_format_params()
2156 raw_cmd->cmd[COMMAND] = FM_MODE(_floppy, FD_FORMAT); in setup_format_params()
2157 raw_cmd->cmd[DR_SELECT] = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head); in setup_format_params()
2158 raw_cmd->cmd[F_SIZECODE] = FD_SIZECODE(_floppy); in setup_format_params()
2159 raw_cmd->cmd[F_SECT_PER_TRACK] = _floppy->sect << 2 >> raw_cmd->cmd[F_SIZECODE]; in setup_format_params()
2160 raw_cmd->cmd[F_GAP] = _floppy->fmt_gap; in setup_format_params()
2161 raw_cmd->cmd[F_FILL] = FD_FILL_BYTE; in setup_format_params()
2163 raw_cmd->kernel_data = floppy_track_buffer; in setup_format_params()
2164 raw_cmd->length = 4 * raw_cmd->cmd[F_SECT_PER_TRACK]; in setup_format_params()
2166 if (!raw_cmd->cmd[F_SECT_PER_TRACK]) in setup_format_params()
2170 head_shift = (raw_cmd->cmd[F_SECT_PER_TRACK] + 5) / 6; in setup_format_params()
2177 % raw_cmd->cmd[F_SECT_PER_TRACK]; in setup_format_params()
2181 if (_floppy->fmt_gap < 0x22) in setup_format_params()
2185 for (count = 0; count < raw_cmd->cmd[F_SECT_PER_TRACK]; ++count) { in setup_format_params()
2189 here[count].size = raw_cmd->cmd[F_SIZECODE]; in setup_format_params()
2192 for (count = 1; count <= raw_cmd->cmd[F_SECT_PER_TRACK]; ++count) { in setup_format_params()
2194 n = (n + il) % raw_cmd->cmd[F_SECT_PER_TRACK]; in setup_format_params()
2197 if (n >= raw_cmd->cmd[F_SECT_PER_TRACK]) { in setup_format_params()
2198 n -= raw_cmd->cmd[F_SECT_PER_TRACK]; in setup_format_params()
2204 if (_floppy->stretch & FD_SECTBASEMASK) { in setup_format_params()
2205 for (count = 0; count < raw_cmd->cmd[F_SECT_PER_TRACK]; count++) in setup_format_params()
2206 here[count].sect += FD_SECTBASE(_floppy) - 1; in setup_format_params()
2212 buffer_track = -1; in redo_format()
2230 return -EINTR; in do_format()
2234 _floppy->track > drive_params[current_drive].tracks || in do_format()
2235 tmp_format_req->track >= _floppy->track || in do_format()
2236 tmp_format_req->head >= _floppy->head || in do_format()
2237 (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) || in do_format()
2238 !_floppy->fmt_gap) { in do_format()
2240 return -EINVAL; in do_format()
2247 if (ret == -EINTR) in do_format()
2248 return -EINTR; in do_format()
2261 unsigned int drive = (unsigned long)req->rq_disk->private_data; in floppy_end_request()
2297 if (block > _floppy->sect) in request_done()
2335 ssize = DIV_ROUND_UP(1 << raw_cmd->cmd[SIZECODE], 4); in rw_interrupt()
2342 if (raw_cmd->cmd[COMMAND] & 0x80) in rw_interrupt()
2347 nr_sectors = (((reply_buffer[R_TRACK] - raw_cmd->cmd[TRACK]) * heads + in rw_interrupt()
2348 reply_buffer[R_HEAD] - raw_cmd->cmd[HEAD]) * raw_cmd->cmd[SECT_PER_TRACK] + in rw_interrupt()
2349 reply_buffer[R_SECTOR] - raw_cmd->cmd[SECTOR] + eoc) << raw_cmd->cmd[SIZECODE] >> 2; in rw_interrupt()
2356 raw_cmd->cmd[SECTOR]); in rw_interrupt()
2358 raw_cmd->cmd[HEAD]); in rw_interrupt()
2360 raw_cmd->cmd[TRACK]); in rw_interrupt()
2363 raw_cmd->cmd[SECT_PER_TRACK], fsector_t, ssize); in rw_interrupt()
2367 nr_sectors -= in_sector_offset; in rw_interrupt()
2373 cont->redo(); in rw_interrupt()
2377 cont->error(); in rw_interrupt()
2378 cont->redo(); in rw_interrupt()
2384 cont->redo(); in rw_interrupt()
2388 floppy_sizes[TOMINOR(current_drive)] = _floppy->size; in rw_interrupt()
2394 DPRINT("Auto-detected floppy type %s in fd%d\n", in rw_interrupt()
2395 _floppy->name, current_drive); in rw_interrupt()
2397 floppy_sizes[TOMINOR(current_drive)] = _floppy->size; in rw_interrupt()
2401 if (CT(raw_cmd->cmd[COMMAND]) != FD_READ || in rw_interrupt()
2402 raw_cmd->kernel_data == bio_data(current_req->bio)) { in rw_interrupt()
2404 cont->done(1); in rw_interrupt()
2405 } else if (CT(raw_cmd->cmd[COMMAND]) == FD_READ) { in rw_interrupt()
2406 buffer_track = raw_cmd->track; in rw_interrupt()
2410 cont->redo(); in rw_interrupt()
2421 base = bio_data(current_req->bio); in buffer_chain_size()
2440 max_sector -= (max_sector % _floppy->sect) % ssize; in transfer_size()
2443 current_count_sectors = max_sector - fsector_t; in transfer_size()
2453 int remaining; /* number of transferred 512-byte sectors */ in copy_buffer()
2464 if (current_count_sectors <= 0 && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE && in copy_buffer()
2466 current_count_sectors = min_t(int, buffer_max - fsector_t, in copy_buffer()
2470 if (remaining > blk_rq_bytes(current_req) && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) { in copy_buffer()
2474 pr_info("current_req->nr_sectors=%u\n", in copy_buffer()
2476 pr_info("current_req->current_nr_sectors=%u\n", in copy_buffer()
2484 dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9); in copy_buffer()
2500 (int)((floppy_track_buffer - dma_buffer) >> 9)); in copy_buffer()
2505 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ) in copy_buffer()
2507 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) in copy_buffer()
2514 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ) in copy_buffer()
2519 remaining -= size; in copy_buffer()
2524 max_sector -= remaining >> 9; in copy_buffer()
2532 * transfer length: We use raw_cmd->cmd[SECT_PER_TRACK]. Unfortunately, this
2541 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) { in virtualdmabug_workaround()
2542 raw_cmd->cmd[COMMAND] &= ~0x80; /* switch off multiple track mode */ in virtualdmabug_workaround()
2544 hard_sectors = raw_cmd->length >> (7 + raw_cmd->cmd[SIZECODE]); in virtualdmabug_workaround()
2545 end_sector = raw_cmd->cmd[SECTOR] + hard_sectors - 1; in virtualdmabug_workaround()
2546 if (end_sector > raw_cmd->cmd[SECT_PER_TRACK]) { in virtualdmabug_workaround()
2548 end_sector, raw_cmd->cmd[SECT_PER_TRACK]); in virtualdmabug_workaround()
2551 raw_cmd->cmd[SECT_PER_TRACK] = end_sector; in virtualdmabug_workaround()
2552 /* make sure raw_cmd->cmd[SECT_PER_TRACK] in virtualdmabug_workaround()
2578 set_fdc((long)current_req->rq_disk->private_data); in make_raw_rw_request()
2581 raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK; in make_raw_rw_request()
2582 raw_cmd->cmd_count = NR_RW; in make_raw_rw_request()
2584 raw_cmd->flags |= FD_RAW_READ; in make_raw_rw_request()
2585 raw_cmd->cmd[COMMAND] = FM_MODE(_floppy, FD_READ); in make_raw_rw_request()
2587 raw_cmd->flags |= FD_RAW_WRITE; in make_raw_rw_request()
2588 raw_cmd->cmd[COMMAND] = FM_MODE(_floppy, FD_WRITE); in make_raw_rw_request()
2594 max_sector = _floppy->sect * _floppy->head; in make_raw_rw_request()
2596 raw_cmd->cmd[TRACK] = (int)blk_rq_pos(current_req) / max_sector; in make_raw_rw_request()
2598 if (_floppy->track && raw_cmd->cmd[TRACK] >= _floppy->track) { in make_raw_rw_request()
2605 raw_cmd->cmd[HEAD] = fsector_t / _floppy->sect; in make_raw_rw_request()
2607 if (((_floppy->stretch & (FD_SWAPSIDES | FD_SECTBASEMASK)) || in make_raw_rw_request()
2609 fsector_t < _floppy->sect) in make_raw_rw_request()
2610 max_sector = _floppy->sect; in make_raw_rw_request()
2613 if ((_floppy->rate & FD_2M) && (!raw_cmd->cmd[TRACK]) && (!raw_cmd->cmd[HEAD])) { in make_raw_rw_request()
2614 max_sector = 2 * _floppy->sect / 3; in make_raw_rw_request()
2617 min_t(int, _floppy->sect - fsector_t, in make_raw_rw_request()
2621 raw_cmd->cmd[SIZECODE] = 2; in make_raw_rw_request()
2623 raw_cmd->cmd[SIZECODE] = FD_SIZECODE(_floppy); in make_raw_rw_request()
2624 raw_cmd->rate = _floppy->rate & 0x43; in make_raw_rw_request()
2625 if ((_floppy->rate & FD_2M) && in make_raw_rw_request()
2626 (raw_cmd->cmd[TRACK] || raw_cmd->cmd[HEAD]) && raw_cmd->rate == 2) in make_raw_rw_request()
2627 raw_cmd->rate = 1; in make_raw_rw_request()
2629 if (raw_cmd->cmd[SIZECODE]) in make_raw_rw_request()
2630 raw_cmd->cmd[SIZECODE2] = 0xff; in make_raw_rw_request()
2632 raw_cmd->cmd[SIZECODE2] = 0x80; in make_raw_rw_request()
2633 raw_cmd->track = raw_cmd->cmd[TRACK] << STRETCH(_floppy); in make_raw_rw_request()
2634 raw_cmd->cmd[DR_SELECT] = UNIT(current_drive) + PH_HEAD(_floppy, raw_cmd->cmd[HEAD]); in make_raw_rw_request()
2635 raw_cmd->cmd[GAP] = _floppy->gap; in make_raw_rw_request()
2636 ssize = DIV_ROUND_UP(1 << raw_cmd->cmd[SIZECODE], 4); in make_raw_rw_request()
2637 raw_cmd->cmd[SECT_PER_TRACK] = _floppy->sect << 2 >> raw_cmd->cmd[SIZECODE]; in make_raw_rw_request()
2638 raw_cmd->cmd[SECTOR] = ((fsector_t % _floppy->sect) << 2 >> raw_cmd->cmd[SIZECODE]) + in make_raw_rw_request()
2644 tracksize = _floppy->sect - _floppy->sect % ssize; in make_raw_rw_request()
2645 if (tracksize < _floppy->sect) { in make_raw_rw_request()
2646 raw_cmd->cmd[SECT_PER_TRACK]++; in make_raw_rw_request()
2647 if (tracksize <= fsector_t % _floppy->sect) in make_raw_rw_request()
2648 raw_cmd->cmd[SECTOR]--; in make_raw_rw_request()
2651 while (tracksize <= fsector_t % _floppy->sect) { in make_raw_rw_request()
2652 while (tracksize + ssize > _floppy->sect) { in make_raw_rw_request()
2653 raw_cmd->cmd[SIZECODE]--; in make_raw_rw_request()
2656 raw_cmd->cmd[SECTOR]++; in make_raw_rw_request()
2657 raw_cmd->cmd[SECT_PER_TRACK]++; in make_raw_rw_request()
2660 max_sector = raw_cmd->cmd[HEAD] * _floppy->sect + tracksize; in make_raw_rw_request()
2661 } else if (!raw_cmd->cmd[TRACK] && !raw_cmd->cmd[HEAD] && !(_floppy->rate & FD_2M) && probing) { in make_raw_rw_request()
2662 max_sector = _floppy->sect; in make_raw_rw_request()
2663 } else if (!raw_cmd->cmd[HEAD] && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) { in make_raw_rw_request()
2665 max_sector = _floppy->sect; in make_raw_rw_request()
2668 in_sector_offset = (fsector_t % _floppy->sect) % ssize; in make_raw_rw_request()
2669 aligned_sector_t = fsector_t - in_sector_offset; in make_raw_rw_request()
2671 if ((raw_cmd->track == buffer_track) && in make_raw_rw_request()
2675 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ) { in make_raw_rw_request()
2680 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) { in make_raw_rw_request()
2689 raw_cmd->flags &= ~FD_RAW_WRITE; in make_raw_rw_request()
2690 raw_cmd->flags |= FD_RAW_READ; in make_raw_rw_request()
2691 raw_cmd->cmd[COMMAND] = FM_MODE(_floppy, FD_READ); in make_raw_rw_request()
2692 } else if ((unsigned long)bio_data(current_req->bio) < MAX_DMA_ADDRESS) { in make_raw_rw_request()
2698 max_buffer_sectors * 2) - fsector_t; in make_raw_rw_request()
2701 * Do NOT use minimum() here---MAX_DMA_ADDRESS is 64 bits wide in make_raw_rw_request()
2705 dma_limit = (MAX_DMA_ADDRESS - in make_raw_rw_request()
2706 ((unsigned long)bio_data(current_req->bio))) >> 9; in make_raw_rw_request()
2710 if (CROSS_64KB(bio_data(current_req->bio), max_size << 9)) in make_raw_rw_request()
2711 max_size = (K_64 - in make_raw_rw_request()
2712 ((unsigned long)bio_data(current_req->bio)) % in make_raw_rw_request()
2714 direct = transfer_size(ssize, max_sector, max_size) - fsector_t; in make_raw_rw_request()
2729 raw_cmd->kernel_data = bio_data(current_req->bio); in make_raw_rw_request()
2730 raw_cmd->length = current_count_sectors << 9; in make_raw_rw_request()
2731 if (raw_cmd->length == 0) { in make_raw_rw_request()
2742 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ) in make_raw_rw_request()
2746 if (buffer_track != raw_cmd->track || /* bad track */ in make_raw_rw_request()
2750 ((CT(raw_cmd->cmd[COMMAND]) == FD_READ || in make_raw_rw_request()
2755 buffer_track = -1; in make_raw_rw_request()
2759 raw_cmd->kernel_data = floppy_track_buffer + in make_raw_rw_request()
2760 ((aligned_sector_t - buffer_min) << 9); in make_raw_rw_request()
2762 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) { in make_raw_rw_request()
2767 if (in_sector_offset && buffer_track == -1) in make_raw_rw_request()
2769 buffer_track = raw_cmd->track; in make_raw_rw_request()
2775 2 * max_buffer_sectors + buffer_min - in make_raw_rw_request()
2779 raw_cmd->length = in_sector_offset + current_count_sectors; in make_raw_rw_request()
2780 raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1; in make_raw_rw_request()
2781 raw_cmd->length <<= 9; in make_raw_rw_request()
2782 if ((raw_cmd->length < current_count_sectors << 9) || in make_raw_rw_request()
2783 (raw_cmd->kernel_data != bio_data(current_req->bio) && in make_raw_rw_request()
2784 CT(raw_cmd->cmd[COMMAND]) == FD_WRITE && in make_raw_rw_request()
2785 (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max || in make_raw_rw_request()
2787 raw_cmd->length % (128 << raw_cmd->cmd[SIZECODE]) || in make_raw_rw_request()
2788 raw_cmd->length <= 0 || current_count_sectors <= 0) { in make_raw_rw_request()
2790 raw_cmd->length, current_count_sectors); in make_raw_rw_request()
2791 if (raw_cmd->kernel_data != bio_data(current_req->bio)) in make_raw_rw_request()
2793 (int)((raw_cmd->kernel_data - in make_raw_rw_request()
2798 pr_info("ssize=%x SIZECODE=%d\n", ssize, raw_cmd->cmd[SIZECODE]); in make_raw_rw_request()
2800 raw_cmd->cmd[COMMAND], raw_cmd->cmd[SECTOR], in make_raw_rw_request()
2801 raw_cmd->cmd[HEAD], raw_cmd->cmd[TRACK]); in make_raw_rw_request()
2809 if (raw_cmd->kernel_data != bio_data(current_req->bio)) { in make_raw_rw_request()
2810 if (raw_cmd->kernel_data < floppy_track_buffer || in make_raw_rw_request()
2812 raw_cmd->length < 0 || in make_raw_rw_request()
2813 raw_cmd->kernel_data + raw_cmd->length > in make_raw_rw_request()
2817 fsector_t, buffer_min, raw_cmd->length >> 9); in make_raw_rw_request()
2820 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ) in make_raw_rw_request()
2822 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) in make_raw_rw_request()
2826 } else if (raw_cmd->length > blk_rq_bytes(current_req) || in make_raw_rw_request()
2830 } else if (raw_cmd->length < current_count_sectors << 9) { in make_raw_rw_request()
2832 pr_info("bytes=%ld\n", raw_cmd->length >> 9); in make_raw_rw_request()
2835 if (raw_cmd->length == 0) { in make_raw_rw_request()
2849 current_req->error_count = 0; in set_next_request()
2850 list_del_init(¤t_req->queuelist); in set_next_request()
2880 drive = (long)current_req->rq_disk->private_data; in redo_fd_request()
2886 raw_cmd->flags = 0; in redo_fd_request()
2911 errors = &(current_req->error_count); in redo_fd_request()
2942 blk_mq_start_request(bd->rq); in floppy_queue_rq()
2945 "VFS: %s called on non-open device\n", __func__)) in floppy_queue_rq()
2951 (unsigned long long) current_req->cmd_flags)) in floppy_queue_rq()
2962 list_add_tail(&bd->rq->queuelist, &floppy_reqs); in floppy_queue_rq()
2982 /* no auto-sense, just clear dcl */ in poll_drive()
2984 raw_cmd->flags = flag; in poll_drive()
2985 raw_cmd->track = 0; in poll_drive()
2986 raw_cmd->cmd_count = 0; in poll_drive()
3021 return -EINTR; in user_reset_fdc()
3031 if (ret == -EINTR) in user_reset_fdc()
3032 return -EINTR; in user_reset_fdc()
3045 return copy_to_user(param, address, size) ? -EFAULT : 0; in fd_copyout()
3051 return copy_from_user(address, param, size) ? -EFAULT : 0; in fd_copyin()
3066 if (floppy->name) in drive_name()
3067 return floppy->name; in drive_name()
3078 raw_cmd->flags |= FD_RAW_FAILURE; in raw_cmd_done()
3079 raw_cmd->flags |= FD_RAW_HARDFAILURE; in raw_cmd_done()
3081 raw_cmd->reply_count = inr; in raw_cmd_done()
3082 if (raw_cmd->reply_count > FD_RAW_REPLY_SIZE) in raw_cmd_done()
3083 raw_cmd->reply_count = 0; in raw_cmd_done()
3084 for (i = 0; i < raw_cmd->reply_count; i++) in raw_cmd_done()
3085 raw_cmd->reply[i] = reply_buffer[i]; in raw_cmd_done()
3087 if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) { in raw_cmd_done()
3090 raw_cmd->length = fd_get_dma_residue(); in raw_cmd_done()
3094 if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) && in raw_cmd_done()
3095 (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0))) in raw_cmd_done()
3096 raw_cmd->flags |= FD_RAW_FAILURE; in raw_cmd_done()
3099 raw_cmd->flags |= FD_RAW_DISK_CHANGE; in raw_cmd_done()
3101 raw_cmd->flags &= ~FD_RAW_DISK_CHANGE; in raw_cmd_done()
3102 if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER) in raw_cmd_done()
3105 if (raw_cmd->next && in raw_cmd_done()
3106 (!(raw_cmd->flags & FD_RAW_FAILURE) || in raw_cmd_done()
3107 !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) && in raw_cmd_done()
3108 ((raw_cmd->flags & FD_RAW_FAILURE) || in raw_cmd_done()
3109 !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) { in raw_cmd_done()
3110 raw_cmd = raw_cmd->next; in raw_cmd_done()
3135 return -EFAULT; in raw_cmd_copyout()
3137 if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) { in raw_cmd_copyout()
3138 if (ptr->length >= 0 && in raw_cmd_copyout()
3139 ptr->length <= ptr->buffer_length) { in raw_cmd_copyout()
3140 long length = ptr->buffer_length - ptr->length; in raw_cmd_copyout()
3141 ret = fd_copyout(ptr->data, ptr->kernel_data, in raw_cmd_copyout()
3147 ptr = ptr->next; in raw_cmd_copyout()
3161 if (this->buffer_length) { in raw_cmd_free()
3162 fd_dma_mem_free((unsigned long)this->kernel_data, in raw_cmd_free()
3163 this->buffer_length); in raw_cmd_free()
3164 this->buffer_length = 0; in raw_cmd_free()
3166 next = this->next; in raw_cmd_free()
3184 return -ENOMEM; in raw_cmd_copyin()
3187 ptr->next = NULL; in raw_cmd_copyin()
3188 ptr->buffer_length = 0; in raw_cmd_copyin()
3189 ptr->kernel_data = NULL; in raw_cmd_copyin()
3191 return -EFAULT; in raw_cmd_copyin()
3193 if (ptr->cmd_count > FD_RAW_CMD_FULLSIZE) in raw_cmd_copyin()
3194 return -EINVAL; in raw_cmd_copyin()
3197 ptr->reply[i] = 0; in raw_cmd_copyin()
3198 ptr->resultcode = 0; in raw_cmd_copyin()
3200 if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) { in raw_cmd_copyin()
3201 if (ptr->length <= 0) in raw_cmd_copyin()
3202 return -EINVAL; in raw_cmd_copyin()
3203 ptr->kernel_data = (char *)fd_dma_mem_alloc(ptr->length); in raw_cmd_copyin()
3204 fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length); in raw_cmd_copyin()
3205 if (!ptr->kernel_data) in raw_cmd_copyin()
3206 return -ENOMEM; in raw_cmd_copyin()
3207 ptr->buffer_length = ptr->length; in raw_cmd_copyin()
3209 if (ptr->flags & FD_RAW_WRITE) { in raw_cmd_copyin()
3210 ret = fd_copyin(ptr->data, ptr->kernel_data, ptr->length); in raw_cmd_copyin()
3215 if (ptr->flags & FD_RAW_MORE) { in raw_cmd_copyin()
3216 rcmd = &(ptr->next); in raw_cmd_copyin()
3217 ptr->rate &= 0x43; in raw_cmd_copyin()
3248 return -EIO; in raw_cmd_ioctl()
3262 if (ret != -EINTR && fdc_state[current_fdc].reset) in raw_cmd_ioctl()
3263 ret = -EIO; in raw_cmd_ioctl()
3277 set_bit((long)bdev->bd_disk->private_data, &fake_change); in invalidate_drive()
3280 floppy_revalidate(bdev->bd_disk); in invalidate_drive()
3290 if ((int)g->sect <= 0 || in set_geometry()
3291 (int)g->head <= 0 || in set_geometry()
3293 (int)(g->sect * g->head) <= 0 || in set_geometry()
3294 /* check for zero in raw_cmd->cmd[F_SECT_PER_TRACK] */ in set_geometry()
3295 (unsigned char)((g->sect << 2) >> FD_SIZECODE(g)) == 0 || in set_geometry()
3296 g->track <= 0 || g->track > drive_params[drive].tracks >> STRETCH(g) || in set_geometry()
3298 (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_SECTBASEMASK)) != 0) in set_geometry()
3299 return -EINVAL; in set_geometry()
3302 return -EPERM; in set_geometry()
3306 return -EINTR; in set_geometry()
3325 return -EINTR; in set_geometry()
3329 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR) in set_geometry()
3330 return -EINTR; in set_geometry()
3332 oldStretch = g->stretch; in set_geometry()
3339 drive_state[current_drive].keep_data = -1; in set_geometry()
3397 return -EFAULT; in normalize_ioctl()
3402 return -EINVAL; in normalize_ioctl()
3411 return -EINTR; in get_floppy_geometry()
3412 if (poll_drive(false, 0) == -EINTR) in get_floppy_geometry()
3413 return -EINTR; in get_floppy_geometry()
3418 return -ENODEV; in get_floppy_geometry()
3424 int drive = (long)bdev->bd_disk->private_data; in fd_getgeo()
3433 geo->heads = g->head; in fd_getgeo()
3434 geo->sectors = g->sect; in fd_getgeo()
3435 geo->cylinders = g->track; in fd_getgeo()
3460 int drive = (long)bdev->bd_disk->private_data; in fd_locked_ioctl()
3476 if (cmd == CDROMEJECT || /* CD-ROM eject */ in fd_locked_ioctl()
3479 DPRINT("please use floppycontrol --eject\n"); in fd_locked_ioctl()
3484 return -EINVAL; in fd_locked_ioctl()
3494 return -EPERM; in fd_locked_ioctl()
3497 return -EINVAL; in fd_locked_ioctl()
3511 return -EBUSY; in fd_locked_ioctl()
3513 return -EINTR; in fd_locked_ioctl()
3515 /* do the actual eject. Fails on in fd_locked_ioctl()
3516 * non-Sparc architectures */ in fd_locked_ioctl()
3525 return -EINTR; in fd_locked_ioctl()
3550 return -EINTR; in fd_locked_ioctl()
3551 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR) in fd_locked_ioctl()
3552 return -EINTR; in fd_locked_ioctl()
3556 return -ENODEV; in fd_locked_ioctl()
3558 return -EROFS; in fd_locked_ioctl()
3562 return -EBUSY; in fd_locked_ioctl()
3567 return -EINTR; in fd_locked_ioctl()
3585 return -EINVAL; in fd_locked_ioctl()
3593 return -EINTR; in fd_locked_ioctl()
3594 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR) in fd_locked_ioctl()
3595 return -EINTR; in fd_locked_ioctl()
3614 return -EINVAL; in fd_locked_ioctl()
3616 return -EINTR; in fd_locked_ioctl()
3619 if (i == -EINTR) in fd_locked_ioctl()
3620 return -EINTR; in fd_locked_ioctl()
3625 return -EINTR; in fd_locked_ioctl()
3630 return -EINVAL; in fd_locked_ioctl()
3738 return -EPERM; in compat_set_geometry()
3742 return -EFAULT; in compat_set_geometry()
3745 drive = (long)bdev->bd_disk->private_data; in compat_set_geometry()
3771 return -EFAULT; in compat_get_prm()
3781 return -EPERM; in compat_setdrvprm()
3783 return -EFAULT; in compat_setdrvprm()
3785 return -EINVAL; in compat_setdrvprm()
3841 return -EFAULT; in compat_getdrvprm()
3856 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR) in compat_getdrvstat()
3877 return -EFAULT; in compat_getdrvstat()
3881 return -EINTR; in compat_getdrvstat()
3909 return -EFAULT; in compat_getfdcstat()
3930 return -EFAULT; in compat_werrorget()
3937 int drive = (long)bdev->bd_disk->private_data; in fd_compat_ioctl()
3939 case CDROMEJECT: /* CD-ROM eject */ in fd_compat_ioctl()
3979 return -EINVAL; in fd_compat_ioctl()
4038 int drive = (long)disk->private_data; in floppy_release()
4042 if (!drive_state[drive].fd_ref--) { in floppy_release()
4059 int drive = (long)bdev->bd_disk->private_data; in floppy_open()
4062 int res = -EBUSY; in floppy_open()
4080 res = -ENXIO; in floppy_open()
4106 buffer_min = buffer_max = -1; in floppy_open()
4112 new_dev = MINOR(bdev->bd_dev); in floppy_open()
4115 if (old_dev != -1 && old_dev != new_dev) { in floppy_open()
4117 buffer_track = -1; in floppy_open()
4129 floppy_revalidate(bdev->bd_disk); in floppy_open()
4135 res = -EROFS; in floppy_open()
4144 drive_state[drive].fd_ref--; in floppy_open()
4160 int drive = (long)disk->private_data; in floppy_check_events()
4194 struct rb0_cbdata *cbdata = (struct rb0_cbdata *)bio->bi_private; in floppy_rb0_cb()
4195 int drive = cbdata->drive; in floppy_rb0_cb()
4197 if (bio->bi_status) { in floppy_rb0_cb()
4199 bio->bi_status); in floppy_rb0_cb()
4202 complete(&cbdata->complete); in floppy_rb0_cb()
4215 return -ENOMEM; in __floppy_read_block_0()
4248 int drive = (long)disk->private_data; in floppy_revalidate()
4257 "VFS: revalidate called on non-open device.\n")) in floppy_revalidate()
4258 return -EFAULT; in floppy_revalidate()
4272 buffer_track = -1; in floppy_revalidate()
4278 /* auto-sensing */ in floppy_revalidate()
4345 pr_info("FDC %d is a pre-1991 82077\n", fdc); in get_fdc_version()
4346 return FDC_82077_ORIG; /* Pre-1991 82077, doesn't know in get_fdc_version()
4362 pr_info("FDC %d is a post-1991 82077\n", fdc); in get_fdc_version()
4367 /* Either a 82078-1 or a 82078SL running at 5Volt */ in get_fdc_version()
4513 DPRINT("Read Documentation/admin-guide/blockdev/floppy.rst\n"); in floppy_setup()
4517 static int have_no_fdc = -ENODEV;
4525 drive = p->id; in floppy_cmos_show()
4549 if (fdc_state[fdc].address != -1) in floppy_resume()
4602 return -ENODEV; in do_floppy_init()
4609 return -ENOMEM; in do_floppy_init()
4614 err = -ENOMEM; in do_floppy_init()
4618 disks[drive]->queue = blk_mq_init_sq_queue(&tag_sets[drive], in do_floppy_init()
4621 if (IS_ERR(disks[drive]->queue)) { in do_floppy_init()
4622 err = PTR_ERR(disks[drive]->queue); in do_floppy_init()
4623 disks[drive]->queue = NULL; in do_floppy_init()
4627 blk_queue_bounce_limit(disks[drive]->queue, BLK_BOUNCE_HIGH); in do_floppy_init()
4628 blk_queue_max_hw_sectors(disks[drive]->queue, 64); in do_floppy_init()
4629 disks[drive]->major = FLOPPY_MAJOR; in do_floppy_init()
4630 disks[drive]->first_minor = TOMINOR(drive); in do_floppy_init()
4631 disks[drive]->fops = &floppy_fops; in do_floppy_init()
4632 disks[drive]->events = DISK_EVENT_MEDIA_CHANGE; in do_floppy_init()
4633 sprintf(disks[drive]->disk_name, "fd%d", drive); in do_floppy_init()
4660 fdc_state[i].dtr = -1; in do_floppy_init()
4673 if (fdc_state[0].address == -1) { in do_floppy_init()
4675 err = -ENODEV; in do_floppy_init()
4686 err = -EBUSY; in do_floppy_init()
4697 drive_state[drive].fd_device = -1; in do_floppy_init()
4712 if (fdc_state[i].address == -1) in do_floppy_init()
4718 fdc_state[i].address = -1; in do_floppy_init()
4727 fdc_state[i].address = -1; in do_floppy_init()
4765 disks[drive]->private_data = (void *)(long)drive; in do_floppy_init()
4766 disks[drive]->flags |= GENHD_FL_REMOVABLE; in do_floppy_init()
4773 while (drive--) { in do_floppy_init()
4792 if (disks[drive]->queue) { in do_floppy_init()
4794 blk_cleanup_queue(disks[drive]->queue); in do_floppy_init()
4795 disks[drive]->queue = NULL; in do_floppy_init()
4829 * Unfortunately, Adaptec doesn't know this :-(, */
4836 p--; in floppy_release_allocated_regions()
4837 release_region(fdc_state[fdc].address + p->offset, p->size); in floppy_release_allocated_regions()
4848 if (!request_region(fdc_state[fdc].address + p->offset, in floppy_request_regions()
4849 p->size, "floppy")) { in floppy_request_regions()
4850 DPRINT("Floppy io-port 0x%04lx in use\n", in floppy_request_regions()
4851 fdc_state[fdc].address + p->offset); in floppy_request_regions()
4853 return -EBUSY; in floppy_request_regions()
4881 return -1; in floppy_grab_irq_and_dma()
4891 return -1; in floppy_grab_irq_and_dma()
4896 if (fdc_state[fdc].address != -1) { in floppy_grab_irq_and_dma()
4902 if (fdc_state[fdc].address != -1) { in floppy_grab_irq_and_dma()
4911 if (fdc_state[fdc].address != -1) in floppy_grab_irq_and_dma()
4923 while (--fdc >= 0) in floppy_grab_irq_and_dma()
4927 return -1; in floppy_grab_irq_and_dma()
4958 buffer_min = buffer_max = -1; in floppy_release_irq_and_dma()
4974 if (fdc_state[fdc].address != -1) in floppy_release_irq_and_dma()
5024 blk_cleanup_queue(disks[drive]->queue); in floppy_module_exit()
5033 disks[drive]->queue = NULL; in floppy_module_exit()