1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148#undef FLOPPY_SILENT_DCL_CLEAR
149
150#define REALLY_SLOW_IO
151
152#define DEBUGT 2
153
154#define DPRINT(format, args...) \
155 pr_info("floppy%d: " format, current_drive, ##args)
156
157#define DCL_DEBUG
158#ifdef DCL_DEBUG
159#define debug_dcl(test, fmt, args...) \
160 do { if ((test) & FD_DEBUG) DPRINT(fmt, ##args); } while (0)
161#else
162#define debug_dcl(test, fmt, args...) \
163 do { if (0) DPRINT(fmt, ##args); } while (0)
164#endif
165
166
167static int print_unex = 1;
168#include <linux/module.h>
169#include <linux/sched.h>
170#include <linux/fs.h>
171#include <linux/kernel.h>
172#include <linux/timer.h>
173#include <linux/workqueue.h>
174#include <linux/fdreg.h>
175#include <linux/fd.h>
176#include <linux/hdreg.h>
177#include <linux/errno.h>
178#include <linux/slab.h>
179#include <linux/mm.h>
180#include <linux/bio.h>
181#include <linux/string.h>
182#include <linux/jiffies.h>
183#include <linux/fcntl.h>
184#include <linux/delay.h>
185#include <linux/mc146818rtc.h>
186#include <linux/ioport.h>
187#include <linux/interrupt.h>
188#include <linux/init.h>
189#include <linux/platform_device.h>
190#include <linux/mod_devicetable.h>
191#include <linux/mutex.h>
192#include <linux/io.h>
193#include <linux/uaccess.h>
194#include <linux/async.h>
195#include <linux/compat.h>
196
197
198
199
200
201
202static DEFINE_MUTEX(floppy_mutex);
203static int slow_floppy;
204
205#include <asm/dma.h>
206#include <asm/irq.h>
207
208static int FLOPPY_IRQ = 6;
209static int FLOPPY_DMA = 2;
210static int can_use_virtual_dma = 2;
211
212
213
214
215
216
217
218
219static int use_virtual_dma;
220
221
222
223
224
225
226
227
228
229
230
231static DEFINE_SPINLOCK(floppy_lock);
232
233static unsigned short virtual_dma_port = 0x3f0;
234irqreturn_t floppy_interrupt(int irq, void *dev_id);
235static int set_dor(int fdc, char mask, char data);
236
237#define K_64 0x10000
238
239
240
241
242
243
244
245
246
247
248
249static int allowed_drive_mask = 0x33;
250
251#include <asm/floppy.h>
252
253static int irqdma_allocated;
254
255#include <linux/blk-mq.h>
256#include <linux/blkpg.h>
257#include <linux/cdrom.h>
258#include <linux/completion.h>
259
260static LIST_HEAD(floppy_reqs);
261static struct request *current_req;
262static int set_next_request(void);
263
264#ifndef fd_get_dma_residue
265#define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
266#endif
267
268
269
270#ifndef fd_dma_mem_free
271#define fd_dma_mem_free(addr, size) free_pages(addr, get_order(size))
272#endif
273
274#ifndef fd_dma_mem_alloc
275#define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL, get_order(size))
276#endif
277
278#ifndef fd_cacheflush
279#define fd_cacheflush(addr, size)
280#endif
281
282static inline void fallback_on_nodma_alloc(char **addr, size_t l)
283{
284#ifdef FLOPPY_CAN_FALLBACK_ON_NODMA
285 if (*addr)
286 return;
287 if (can_use_virtual_dma != 2)
288 return;
289 pr_info("DMA memory shortage. Temporarily falling back on virtual DMA\n");
290 *addr = (char *)nodma_mem_alloc(l);
291#else
292 return;
293#endif
294}
295
296
297
298static unsigned long fake_change;
299static bool initialized;
300
301#define ITYPE(x) (((x) >> 2) & 0x1f)
302#define TOMINOR(x) ((x & 3) | ((x & 4) << 5))
303#define UNIT(x) ((x) & 0x03)
304#define FDC(x) (((x) & 0x04) >> 2)
305
306#define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
307
308#define PH_HEAD(floppy, head) (((((floppy)->stretch & 2) >> 1) ^ head) << 2)
309#define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
310
311
312#define COMMAND 0
313#define DR_SELECT 1
314#define TRACK 2
315#define HEAD 3
316#define SECTOR 4
317#define SIZECODE 5
318#define SECT_PER_TRACK 6
319#define GAP 7
320#define SIZECODE2 8
321#define NR_RW 9
322
323
324#define F_SIZECODE 2
325#define F_SECT_PER_TRACK 3
326#define F_GAP 4
327#define F_FILL 5
328#define NR_F 6
329
330
331
332
333
334
335#define MAX_DISK_SIZE 4
336
337
338
339
340static unsigned char reply_buffer[FD_RAW_REPLY_SIZE];
341static int inr;
342#define ST0 0
343#define ST1 1
344#define ST2 2
345#define ST3 0
346#define R_TRACK 3
347#define R_HEAD 4
348#define R_SECTOR 5
349#define R_SIZECODE 6
350
351#define SEL_DLY (2 * HZ / 100)
352
353
354
355
356static struct {
357 struct floppy_drive_params params;
358 const char *name;
359} default_drive_params[] = {
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375{{0, 500, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 80, 3*HZ, 20, {3,1,2,0,2}, 0,
376 0, { 7, 4, 8, 2, 1, 5, 3,10}, 3*HZ/2, 0 }, "unknown" },
377
378{{1, 300, 16, 16, 8000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 40, 3*HZ, 17, {3,1,2,0,2}, 0,
379 0, { 1, 0, 0, 0, 0, 0, 0, 0}, 3*HZ/2, 1 }, "360K PC" },
380
381{{2, 500, 16, 16, 6000, 4*HZ/10, 3*HZ, 14, SEL_DLY, 6, 83, 3*HZ, 17, {3,1,2,0,2}, 0,
382 0, { 2, 5, 6,23,10,20,12, 0}, 3*HZ/2, 2 }, "1.2M" },
383
384{{3, 250, 16, 16, 3000, 1*HZ, 3*HZ, 0, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
385 0, { 4,22,21,30, 3, 0, 0, 0}, 3*HZ/2, 4 }, "720k" },
386
387{{4, 500, 16, 16, 4000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 20, {3,1,2,0,2}, 0,
388 0, { 7, 4,25,22,31,21,29,11}, 3*HZ/2, 7 }, "1.44M" },
389
390{{5, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
391 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M AMI BIOS" },
392
393{{6, 1000, 15, 8, 3000, 4*HZ/10, 3*HZ, 10, SEL_DLY, 5, 83, 3*HZ, 40, {3,1,2,0,2}, 0,
394 0, { 7, 8, 4,25,28,22,31,21}, 3*HZ/2, 8 }, "2.88M" }
395
396
397
398
399};
400
401static struct floppy_drive_params drive_params[N_DRIVE];
402static struct floppy_drive_struct drive_state[N_DRIVE];
403static struct floppy_write_errors write_errors[N_DRIVE];
404static struct timer_list motor_off_timer[N_DRIVE];
405static struct gendisk *disks[N_DRIVE];
406static struct blk_mq_tag_set tag_sets[N_DRIVE];
407static struct block_device *opened_bdev[N_DRIVE];
408static DEFINE_MUTEX(open_lock);
409static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442static struct floppy_struct floppy_type[32] = {
443 { 0, 0,0, 0,0,0x00,0x00,0x00,0x00,NULL },
444 { 720, 9,2,40,0,0x2A,0x02,0xDF,0x50,"d360" },
445 { 2400,15,2,80,0,0x1B,0x00,0xDF,0x54,"h1200" },
446 { 720, 9,1,80,0,0x2A,0x02,0xDF,0x50,"D360" },
447 { 1440, 9,2,80,0,0x2A,0x02,0xDF,0x50,"D720" },
448 { 720, 9,2,40,1,0x23,0x01,0xDF,0x50,"h360" },
449 { 1440, 9,2,80,0,0x23,0x01,0xDF,0x50,"h720" },
450 { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,"H1440" },
451 { 5760,36,2,80,0,0x1B,0x43,0xAF,0x54,"E2880" },
452 { 6240,39,2,80,0,0x1B,0x43,0xAF,0x28,"E3120" },
453
454 { 2880,18,2,80,0,0x25,0x00,0xDF,0x02,"h1440" },
455 { 3360,21,2,80,0,0x1C,0x00,0xCF,0x0C,"H1680" },
456 { 820,10,2,41,1,0x25,0x01,0xDF,0x2E,"h410" },
457 { 1640,10,2,82,0,0x25,0x02,0xDF,0x2E,"H820" },
458 { 2952,18,2,82,0,0x25,0x00,0xDF,0x02,"h1476" },
459 { 3444,21,2,82,0,0x25,0x00,0xDF,0x0C,"H1722" },
460 { 840,10,2,42,1,0x25,0x01,0xDF,0x2E,"h420" },
461 { 1660,10,2,83,0,0x25,0x02,0xDF,0x2E,"H830" },
462 { 2988,18,2,83,0,0x25,0x00,0xDF,0x02,"h1494" },
463 { 3486,21,2,83,0,0x25,0x00,0xDF,0x0C,"H1743" },
464
465 { 1760,11,2,80,0,0x1C,0x09,0xCF,0x00,"h880" },
466 { 2080,13,2,80,0,0x1C,0x01,0xCF,0x00,"D1040" },
467 { 2240,14,2,80,0,0x1C,0x19,0xCF,0x00,"D1120" },
468 { 3200,20,2,80,0,0x1C,0x20,0xCF,0x2C,"h1600" },
469 { 3520,22,2,80,0,0x1C,0x08,0xCF,0x2e,"H1760" },
470 { 3840,24,2,80,0,0x1C,0x20,0xCF,0x00,"H1920" },
471 { 6400,40,2,80,0,0x25,0x5B,0xCF,0x00,"E3200" },
472 { 7040,44,2,80,0,0x25,0x5B,0xCF,0x00,"E3520" },
473 { 7680,48,2,80,0,0x25,0x63,0xCF,0x00,"E3840" },
474 { 3680,23,2,80,0,0x1C,0x10,0xCF,0x00,"H1840" },
475
476 { 1600,10,2,80,0,0x25,0x02,0xDF,0x2E,"D800" },
477 { 3200,20,2,80,0,0x1C,0x00,0xCF,0x2C,"H1600" },
478};
479
480#define SECTSIZE (_FD_SECTSIZE(*floppy))
481
482
483static struct floppy_struct *current_type[N_DRIVE];
484
485
486
487
488
489static struct floppy_struct user_params[N_DRIVE];
490
491static sector_t floppy_sizes[256];
492
493static char floppy_device_name[] = "floppy";
494
495
496
497
498
499
500static int probing;
501
502
503#define FD_COMMAND_NONE -1
504#define FD_COMMAND_ERROR 2
505#define FD_COMMAND_OKAY 3
506
507static volatile int command_status = FD_COMMAND_NONE;
508static unsigned long fdc_busy;
509static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
510static DECLARE_WAIT_QUEUE_HEAD(command_done);
511
512
513static int format_errors;
514
515
516static struct format_descr format_req;
517
518
519
520
521
522
523
524
525
526
527
528
529
530static char *floppy_track_buffer;
531static int max_buffer_sectors;
532
533static int *errors;
534typedef void (*done_f)(int);
535static const struct cont_t {
536 void (*interrupt)(void);
537
538
539 void (*redo)(void);
540 void (*error)(void);
541 done_f done;
542
543} *cont;
544
545static void floppy_ready(void);
546static void floppy_start(void);
547static void process_fd_request(void);
548static void recalibrate_floppy(void);
549static void floppy_shutdown(struct work_struct *);
550
551static int floppy_request_regions(int);
552static void floppy_release_regions(int);
553static int floppy_grab_irq_and_dma(void);
554static void floppy_release_irq_and_dma(void);
555
556
557
558
559
560
561
562
563static void reset_fdc(void);
564
565
566
567
568
569
570#define NO_TRACK -1
571#define NEED_1_RECAL -2
572#define NEED_2_RECAL -3
573
574static atomic_t usage_count = ATOMIC_INIT(0);
575
576
577static int buffer_track = -1;
578static int buffer_drive = -1;
579static int buffer_min = -1;
580static int buffer_max = -1;
581
582
583static struct floppy_fdc_state fdc_state[N_FDC];
584static int current_fdc;
585
586static struct workqueue_struct *floppy_wq;
587
588static struct floppy_struct *_floppy = floppy_type;
589static unsigned char current_drive;
590static long current_count_sectors;
591static unsigned char fsector_t;
592static unsigned char in_sector_offset;
593
594
595static inline unsigned char fdc_inb(int fdc, int reg)
596{
597 return fd_inb(fdc_state[fdc].address, reg);
598}
599
600static inline void fdc_outb(unsigned char value, int fdc, int reg)
601{
602 fd_outb(value, fdc_state[fdc].address, reg);
603}
604
605static inline bool drive_no_geom(int drive)
606{
607 return !current_type[drive] && !ITYPE(drive_state[drive].fd_device);
608}
609
610#ifndef fd_eject
611static inline int fd_eject(int drive)
612{
613 return -EINVAL;
614}
615#endif
616
617
618
619
620
621#ifdef DEBUGT
622static long unsigned debugtimer;
623
624static inline void set_debugt(void)
625{
626 debugtimer = jiffies;
627}
628
629static inline void debugt(const char *func, const char *msg)
630{
631 if (drive_params[current_drive].flags & DEBUGT)
632 pr_info("%s:%s dtime=%lu\n", func, msg, jiffies - debugtimer);
633}
634#else
635static inline void set_debugt(void) { }
636static inline void debugt(const char *func, const char *msg) { }
637#endif
638
639
640static DECLARE_DELAYED_WORK(fd_timeout, floppy_shutdown);
641static const char *timeout_message;
642
643static void is_alive(const char *func, const char *message)
644{
645
646 if (test_bit(0, &fdc_busy) && command_status < 2 &&
647 !delayed_work_pending(&fd_timeout)) {
648 DPRINT("%s: timeout handler died. %s\n", func, message);
649 }
650}
651
652static void (*do_floppy)(void) = NULL;
653
654#define OLOGSIZE 20
655
656static void (*lasthandler)(void);
657static unsigned long interruptjiffies;
658static unsigned long resultjiffies;
659static int resultsize;
660static unsigned long lastredo;
661
662static struct output_log {
663 unsigned char data;
664 unsigned char status;
665 unsigned long jiffies;
666} output_log[OLOGSIZE];
667
668static int output_log_pos;
669
670#define MAXTIMEOUT -2
671
672static void __reschedule_timeout(int drive, const char *message)
673{
674 unsigned long delay;
675
676 if (drive < 0 || drive >= N_DRIVE) {
677 delay = 20UL * HZ;
678 drive = 0;
679 } else
680 delay = drive_params[drive].timeout;
681
682 mod_delayed_work(floppy_wq, &fd_timeout, delay);
683 if (drive_params[drive].flags & FD_DEBUG)
684 DPRINT("reschedule timeout %s\n", message);
685 timeout_message = message;
686}
687
688static void reschedule_timeout(int drive, const char *message)
689{
690 unsigned long flags;
691
692 spin_lock_irqsave(&floppy_lock, flags);
693 __reschedule_timeout(drive, message);
694 spin_unlock_irqrestore(&floppy_lock, flags);
695}
696
697#define INFBOUND(a, b) (a) = max_t(int, a, b)
698#define SUPBOUND(a, b) (a) = min_t(int, a, b)
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733static int disk_change(int drive)
734{
735 int fdc = FDC(drive);
736
737 if (time_before(jiffies, drive_state[drive].select_date + drive_params[drive].select_delay))
738 DPRINT("WARNING disk change called early\n");
739 if (!(fdc_state[fdc].dor & (0x10 << UNIT(drive))) ||
740 (fdc_state[fdc].dor & 3) != UNIT(drive) || fdc != FDC(drive)) {
741 DPRINT("probing disk change on unselected drive\n");
742 DPRINT("drive=%d fdc=%d dor=%x\n", drive, FDC(drive),
743 (unsigned int)fdc_state[fdc].dor);
744 }
745
746 debug_dcl(drive_params[drive].flags,
747 "checking disk change line for drive %d\n", drive);
748 debug_dcl(drive_params[drive].flags, "jiffies=%lu\n", jiffies);
749 debug_dcl(drive_params[drive].flags, "disk change line=%x\n",
750 fdc_inb(fdc, FD_DIR) & 0x80);
751 debug_dcl(drive_params[drive].flags, "flags=%lx\n",
752 drive_state[drive].flags);
753
754 if (drive_params[drive].flags & FD_BROKEN_DCL)
755 return test_bit(FD_DISK_CHANGED_BIT,
756 &drive_state[drive].flags);
757 if ((fdc_inb(fdc, FD_DIR) ^ drive_params[drive].flags) & 0x80) {
758 set_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
759
760
761 if (drive_state[drive].maxblock)
762 set_bit(FD_DISK_CHANGED_BIT,
763 &drive_state[drive].flags);
764
765
766 if (drive_state[drive].keep_data >= 0) {
767 if ((drive_params[drive].flags & FTD_MSG) &&
768 current_type[drive] != NULL)
769 DPRINT("Disk type is undefined after disk change\n");
770 current_type[drive] = NULL;
771 floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
772 }
773
774 return 1;
775 } else {
776 drive_state[drive].last_checked = jiffies;
777 clear_bit(FD_DISK_NEWCHANGE_BIT, &drive_state[drive].flags);
778 }
779 return 0;
780}
781
782static inline int is_selected(int dor, int unit)
783{
784 return ((dor & (0x10 << unit)) && (dor & 3) == unit);
785}
786
787static bool is_ready_state(int status)
788{
789 int state = status & (STATUS_READY | STATUS_DIR | STATUS_DMA);
790 return state == STATUS_READY;
791}
792
793static int set_dor(int fdc, char mask, char data)
794{
795 unsigned char unit;
796 unsigned char drive;
797 unsigned char newdor;
798 unsigned char olddor;
799
800 if (fdc_state[fdc].address == -1)
801 return -1;
802
803 olddor = fdc_state[fdc].dor;
804 newdor = (olddor & mask) | data;
805 if (newdor != olddor) {
806 unit = olddor & 0x3;
807 if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
808 drive = REVDRIVE(fdc, unit);
809 debug_dcl(drive_params[drive].flags,
810 "calling disk change from set_dor\n");
811 disk_change(drive);
812 }
813 fdc_state[fdc].dor = newdor;
814 fdc_outb(newdor, fdc, FD_DOR);
815
816 unit = newdor & 0x3;
817 if (!is_selected(olddor, unit) && is_selected(newdor, unit)) {
818 drive = REVDRIVE(fdc, unit);
819 drive_state[drive].select_date = jiffies;
820 }
821 }
822 return olddor;
823}
824
825static void twaddle(int fdc, int drive)
826{
827 if (drive_params[drive].select_delay)
828 return;
829 fdc_outb(fdc_state[fdc].dor & ~(0x10 << UNIT(drive)),
830 fdc, FD_DOR);
831 fdc_outb(fdc_state[fdc].dor, fdc, FD_DOR);
832 drive_state[drive].select_date = jiffies;
833}
834
835
836
837
838
839static void reset_fdc_info(int fdc, int mode)
840{
841 int drive;
842
843 fdc_state[fdc].spec1 = fdc_state[fdc].spec2 = -1;
844 fdc_state[fdc].need_configure = 1;
845 fdc_state[fdc].perp_mode = 1;
846 fdc_state[fdc].rawcmd = 0;
847 for (drive = 0; drive < N_DRIVE; drive++)
848 if (FDC(drive) == fdc &&
849 (mode || drive_state[drive].track != NEED_1_RECAL))
850 drive_state[drive].track = NEED_2_RECAL;
851}
852
853
854
855
856
857static void set_fdc(int drive)
858{
859 unsigned int fdc;
860
861 if (drive < 0 || drive >= N_DRIVE) {
862 pr_info("bad drive value %d\n", drive);
863 return;
864 }
865
866 fdc = FDC(drive);
867 if (fdc >= N_FDC) {
868 pr_info("bad fdc value\n");
869 return;
870 }
871
872 set_dor(fdc, ~0, 8);
873#if N_FDC > 1
874 set_dor(1 - fdc, ~8, 0);
875#endif
876 if (fdc_state[fdc].rawcmd == 2)
877 reset_fdc_info(fdc, 1);
878 if (fdc_inb(fdc, FD_STATUS) != STATUS_READY)
879 fdc_state[fdc].reset = 1;
880
881 current_drive = drive;
882 current_fdc = fdc;
883}
884
885
886
887
888
889static int lock_fdc(int drive)
890{
891 if (WARN(atomic_read(&usage_count) == 0,
892 "Trying to lock fdc while usage count=0\n"))
893 return -1;
894
895 if (wait_event_interruptible(fdc_wait, !test_and_set_bit(0, &fdc_busy)))
896 return -EINTR;
897
898 command_status = FD_COMMAND_NONE;
899
900 reschedule_timeout(drive, "lock fdc");
901 set_fdc(drive);
902 return 0;
903}
904
905
906static void unlock_fdc(void)
907{
908 if (!test_bit(0, &fdc_busy))
909 DPRINT("FDC access conflict!\n");
910
911 raw_cmd = NULL;
912 command_status = FD_COMMAND_NONE;
913 cancel_delayed_work(&fd_timeout);
914 do_floppy = NULL;
915 cont = NULL;
916 clear_bit(0, &fdc_busy);
917 wake_up(&fdc_wait);
918}
919
920
921static void motor_off_callback(struct timer_list *t)
922{
923 unsigned long nr = t - motor_off_timer;
924 unsigned char mask = ~(0x10 << UNIT(nr));
925
926 if (WARN_ON_ONCE(nr >= N_DRIVE))
927 return;
928
929 set_dor(FDC(nr), mask, 0);
930}
931
932
933static void floppy_off(unsigned int drive)
934{
935 unsigned long volatile delta;
936 int fdc = FDC(drive);
937
938 if (!(fdc_state[fdc].dor & (0x10 << UNIT(drive))))
939 return;
940
941 del_timer(motor_off_timer + drive);
942
943
944
945 if (drive_params[drive].rps) {
946 delta = jiffies - drive_state[drive].first_read_date + HZ -
947 drive_params[drive].spindown_offset;
948 delta = ((delta * drive_params[drive].rps) % HZ) / drive_params[drive].rps;
949 motor_off_timer[drive].expires =
950 jiffies + drive_params[drive].spindown - delta;
951 }
952 add_timer(motor_off_timer + drive);
953}
954
955
956
957
958
959
960static void scandrives(void)
961{
962 int i;
963 int drive;
964 int saved_drive;
965
966 if (drive_params[current_drive].select_delay)
967 return;
968
969 saved_drive = current_drive;
970 for (i = 0; i < N_DRIVE; i++) {
971 drive = (saved_drive + i + 1) % N_DRIVE;
972 if (drive_state[drive].fd_ref == 0 || drive_params[drive].select_delay != 0)
973 continue;
974 set_fdc(drive);
975 if (!(set_dor(current_fdc, ~3, UNIT(drive) | (0x10 << UNIT(drive))) &
976 (0x10 << UNIT(drive))))
977
978
979 set_dor(current_fdc, ~(0x10 << UNIT(drive)), 0);
980 }
981 set_fdc(saved_drive);
982}
983
984static void empty(void)
985{
986}
987
988static void (*floppy_work_fn)(void);
989
990static void floppy_work_workfn(struct work_struct *work)
991{
992 floppy_work_fn();
993}
994
995static DECLARE_WORK(floppy_work, floppy_work_workfn);
996
997static void schedule_bh(void (*handler)(void))
998{
999 WARN_ON(work_pending(&floppy_work));
1000
1001 floppy_work_fn = handler;
1002 queue_work(floppy_wq, &floppy_work);
1003}
1004
1005static void (*fd_timer_fn)(void) = NULL;
1006
1007static void fd_timer_workfn(struct work_struct *work)
1008{
1009 fd_timer_fn();
1010}
1011
1012static DECLARE_DELAYED_WORK(fd_timer, fd_timer_workfn);
1013
1014static void cancel_activity(void)
1015{
1016 do_floppy = NULL;
1017 cancel_delayed_work_sync(&fd_timer);
1018 cancel_work_sync(&floppy_work);
1019}
1020
1021
1022
1023static void fd_watchdog(void)
1024{
1025 debug_dcl(drive_params[current_drive].flags,
1026 "calling disk change from watchdog\n");
1027
1028 if (disk_change(current_drive)) {
1029 DPRINT("disk removed during i/o\n");
1030 cancel_activity();
1031 cont->done(0);
1032 reset_fdc();
1033 } else {
1034 cancel_delayed_work(&fd_timer);
1035 fd_timer_fn = fd_watchdog;
1036 queue_delayed_work(floppy_wq, &fd_timer, HZ / 10);
1037 }
1038}
1039
1040static void main_command_interrupt(void)
1041{
1042 cancel_delayed_work(&fd_timer);
1043 cont->interrupt();
1044}
1045
1046
1047static int fd_wait_for_completion(unsigned long expires,
1048 void (*function)(void))
1049{
1050 if (fdc_state[current_fdc].reset) {
1051 reset_fdc();
1052
1053
1054 return 1;
1055 }
1056
1057 if (time_before(jiffies, expires)) {
1058 cancel_delayed_work(&fd_timer);
1059 fd_timer_fn = function;
1060 queue_delayed_work(floppy_wq, &fd_timer, expires - jiffies);
1061 return 1;
1062 }
1063 return 0;
1064}
1065
1066static void setup_DMA(void)
1067{
1068 unsigned long f;
1069
1070 if (raw_cmd->length == 0) {
1071 print_hex_dump(KERN_INFO, "zero dma transfer size: ",
1072 DUMP_PREFIX_NONE, 16, 1,
1073 raw_cmd->fullcmd, raw_cmd->cmd_count, false);
1074 cont->done(0);
1075 fdc_state[current_fdc].reset = 1;
1076 return;
1077 }
1078 if (((unsigned long)raw_cmd->kernel_data) % 512) {
1079 pr_info("non aligned address: %p\n", raw_cmd->kernel_data);
1080 cont->done(0);
1081 fdc_state[current_fdc].reset = 1;
1082 return;
1083 }
1084 f = claim_dma_lock();
1085 fd_disable_dma();
1086#ifdef fd_dma_setup
1087 if (fd_dma_setup(raw_cmd->kernel_data, raw_cmd->length,
1088 (raw_cmd->flags & FD_RAW_READ) ?
1089 DMA_MODE_READ : DMA_MODE_WRITE,
1090 fdc_state[current_fdc].address) < 0) {
1091 release_dma_lock(f);
1092 cont->done(0);
1093 fdc_state[current_fdc].reset = 1;
1094 return;
1095 }
1096 release_dma_lock(f);
1097#else
1098 fd_clear_dma_ff();
1099 fd_cacheflush(raw_cmd->kernel_data, raw_cmd->length);
1100 fd_set_dma_mode((raw_cmd->flags & FD_RAW_READ) ?
1101 DMA_MODE_READ : DMA_MODE_WRITE);
1102 fd_set_dma_addr(raw_cmd->kernel_data);
1103 fd_set_dma_count(raw_cmd->length);
1104 virtual_dma_port = fdc_state[current_fdc].address;
1105 fd_enable_dma();
1106 release_dma_lock(f);
1107#endif
1108}
1109
1110static void show_floppy(int fdc);
1111
1112
1113static int wait_til_ready(int fdc)
1114{
1115 int status;
1116 int counter;
1117
1118 if (fdc_state[fdc].reset)
1119 return -1;
1120 for (counter = 0; counter < 10000; counter++) {
1121 status = fdc_inb(fdc, FD_STATUS);
1122 if (status & STATUS_READY)
1123 return status;
1124 }
1125 if (initialized) {
1126 DPRINT("Getstatus times out (%x) on fdc %d\n", status, fdc);
1127 show_floppy(fdc);
1128 }
1129 fdc_state[fdc].reset = 1;
1130 return -1;
1131}
1132
1133
1134static int output_byte(int fdc, char byte)
1135{
1136 int status = wait_til_ready(fdc);
1137
1138 if (status < 0)
1139 return -1;
1140
1141 if (is_ready_state(status)) {
1142 fdc_outb(byte, fdc, FD_DATA);
1143 output_log[output_log_pos].data = byte;
1144 output_log[output_log_pos].status = status;
1145 output_log[output_log_pos].jiffies = jiffies;
1146 output_log_pos = (output_log_pos + 1) % OLOGSIZE;
1147 return 0;
1148 }
1149 fdc_state[fdc].reset = 1;
1150 if (initialized) {
1151 DPRINT("Unable to send byte %x to FDC. Fdc=%x Status=%x\n",
1152 byte, fdc, status);
1153 show_floppy(fdc);
1154 }
1155 return -1;
1156}
1157
1158
1159static int result(int fdc)
1160{
1161 int i;
1162 int status = 0;
1163
1164 for (i = 0; i < FD_RAW_REPLY_SIZE; i++) {
1165 status = wait_til_ready(fdc);
1166 if (status < 0)
1167 break;
1168 status &= STATUS_DIR | STATUS_READY | STATUS_BUSY | STATUS_DMA;
1169 if ((status & ~STATUS_BUSY) == STATUS_READY) {
1170 resultjiffies = jiffies;
1171 resultsize = i;
1172 return i;
1173 }
1174 if (status == (STATUS_DIR | STATUS_READY | STATUS_BUSY))
1175 reply_buffer[i] = fdc_inb(fdc, FD_DATA);
1176 else
1177 break;
1178 }
1179 if (initialized) {
1180 DPRINT("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
1181 fdc, status, i);
1182 show_floppy(fdc);
1183 }
1184 fdc_state[fdc].reset = 1;
1185 return -1;
1186}
1187
1188#define MORE_OUTPUT -2
1189
1190static int need_more_output(int fdc)
1191{
1192 int status = wait_til_ready(fdc);
1193
1194 if (status < 0)
1195 return -1;
1196
1197 if (is_ready_state(status))
1198 return MORE_OUTPUT;
1199
1200 return result(fdc);
1201}
1202
1203
1204
1205
1206static void perpendicular_mode(int fdc)
1207{
1208 unsigned char perp_mode;
1209
1210 if (raw_cmd->rate & 0x40) {
1211 switch (raw_cmd->rate & 3) {
1212 case 0:
1213 perp_mode = 2;
1214 break;
1215 case 3:
1216 perp_mode = 3;
1217 break;
1218 default:
1219 DPRINT("Invalid data rate for perpendicular mode!\n");
1220 cont->done(0);
1221 fdc_state[fdc].reset = 1;
1222
1223
1224
1225
1226
1227 return;
1228 }
1229 } else
1230 perp_mode = 0;
1231
1232 if (fdc_state[fdc].perp_mode == perp_mode)
1233 return;
1234 if (fdc_state[fdc].version >= FDC_82077_ORIG) {
1235 output_byte(fdc, FD_PERPENDICULAR);
1236 output_byte(fdc, perp_mode);
1237 fdc_state[fdc].perp_mode = perp_mode;
1238 } else if (perp_mode) {
1239 DPRINT("perpendicular mode not supported by this FDC.\n");
1240 }
1241}
1242
1243static int fifo_depth = 0xa;
1244static int no_fifo;
1245
1246static int fdc_configure(int fdc)
1247{
1248
1249 output_byte(fdc, FD_CONFIGURE);
1250 if (need_more_output(fdc) != MORE_OUTPUT)
1251 return 0;
1252 output_byte(fdc, 0);
1253 output_byte(fdc, 0x10 | (no_fifo & 0x20) | (fifo_depth & 0xf));
1254 output_byte(fdc, 0);
1255 return 1;
1256}
1257
1258#define NOMINAL_DTR 500
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279static void fdc_specify(int fdc, int drive)
1280{
1281 unsigned char spec1;
1282 unsigned char spec2;
1283 unsigned long srt;
1284 unsigned long hlt;
1285 unsigned long hut;
1286 unsigned long dtr = NOMINAL_DTR;
1287 unsigned long scale_dtr = NOMINAL_DTR;
1288 int hlt_max_code = 0x7f;
1289 int hut_max_code = 0xf;
1290
1291 if (fdc_state[fdc].need_configure &&
1292 fdc_state[fdc].version >= FDC_82072A) {
1293 fdc_configure(fdc);
1294 fdc_state[fdc].need_configure = 0;
1295 }
1296
1297 switch (raw_cmd->rate & 0x03) {
1298 case 3:
1299 dtr = 1000;
1300 break;
1301 case 1:
1302 dtr = 300;
1303 if (fdc_state[fdc].version >= FDC_82078) {
1304
1305
1306 output_byte(fdc, FD_DRIVESPEC);
1307 if (need_more_output(fdc) == MORE_OUTPUT) {
1308 output_byte(fdc, UNIT(drive));
1309 output_byte(fdc, 0xc0);
1310 }
1311 }
1312 break;
1313 case 2:
1314 dtr = 250;
1315 break;
1316 }
1317
1318 if (fdc_state[fdc].version >= FDC_82072) {
1319 scale_dtr = dtr;
1320 hlt_max_code = 0x00;
1321 hut_max_code = 0x0;
1322 }
1323
1324
1325 srt = 16 - DIV_ROUND_UP(drive_params[drive].srt * scale_dtr / 1000,
1326 NOMINAL_DTR);
1327 if (slow_floppy)
1328 srt = srt / 4;
1329
1330 SUPBOUND(srt, 0xf);
1331 INFBOUND(srt, 0);
1332
1333 hlt = DIV_ROUND_UP(drive_params[drive].hlt * scale_dtr / 2,
1334 NOMINAL_DTR);
1335 if (hlt < 0x01)
1336 hlt = 0x01;
1337 else if (hlt > 0x7f)
1338 hlt = hlt_max_code;
1339
1340 hut = DIV_ROUND_UP(drive_params[drive].hut * scale_dtr / 16,
1341 NOMINAL_DTR);
1342 if (hut < 0x1)
1343 hut = 0x1;
1344 else if (hut > 0xf)
1345 hut = hut_max_code;
1346
1347 spec1 = (srt << 4) | hut;
1348 spec2 = (hlt << 1) | (use_virtual_dma & 1);
1349
1350
1351 if (fdc_state[fdc].spec1 != spec1 ||
1352 fdc_state[fdc].spec2 != spec2) {
1353
1354 output_byte(fdc, FD_SPECIFY);
1355 output_byte(fdc, fdc_state[fdc].spec1 = spec1);
1356 output_byte(fdc, fdc_state[fdc].spec2 = spec2);
1357 }
1358}
1359
1360
1361
1362
1363
1364static int fdc_dtr(void)
1365{
1366
1367 if ((raw_cmd->rate & 3) == fdc_state[current_fdc].dtr)
1368 return 0;
1369
1370
1371 fdc_outb(raw_cmd->rate & 3, current_fdc, FD_DCR);
1372
1373
1374
1375
1376
1377
1378 fdc_state[current_fdc].dtr = raw_cmd->rate & 3;
1379 return fd_wait_for_completion(jiffies + 2UL * HZ / 100, floppy_ready);
1380}
1381
1382static void tell_sector(void)
1383{
1384 pr_cont(": track %d, head %d, sector %d, size %d",
1385 reply_buffer[R_TRACK], reply_buffer[R_HEAD],
1386 reply_buffer[R_SECTOR],
1387 reply_buffer[R_SIZECODE]);
1388}
1389
1390static void print_errors(void)
1391{
1392 DPRINT("");
1393 if (reply_buffer[ST0] & ST0_ECE) {
1394 pr_cont("Recalibrate failed!");
1395 } else if (reply_buffer[ST2] & ST2_CRC) {
1396 pr_cont("data CRC error");
1397 tell_sector();
1398 } else if (reply_buffer[ST1] & ST1_CRC) {
1399 pr_cont("CRC error");
1400 tell_sector();
1401 } else if ((reply_buffer[ST1] & (ST1_MAM | ST1_ND)) ||
1402 (reply_buffer[ST2] & ST2_MAM)) {
1403 if (!probing) {
1404 pr_cont("sector not found");
1405 tell_sector();
1406 } else
1407 pr_cont("probe failed...");
1408 } else if (reply_buffer[ST2] & ST2_WC) {
1409 pr_cont("wrong cylinder");
1410 } else if (reply_buffer[ST2] & ST2_BC) {
1411 pr_cont("bad cylinder");
1412 } else {
1413 pr_cont("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",
1414 reply_buffer[ST0], reply_buffer[ST1],
1415 reply_buffer[ST2]);
1416 tell_sector();
1417 }
1418 pr_cont("\n");
1419}
1420
1421
1422
1423
1424
1425
1426
1427
1428static int interpret_errors(void)
1429{
1430 char bad;
1431
1432 if (inr != 7) {
1433 DPRINT("-- FDC reply error\n");
1434 fdc_state[current_fdc].reset = 1;
1435 return 1;
1436 }
1437
1438
1439 switch (reply_buffer[ST0] & ST0_INTR) {
1440 case 0x40:
1441 if (reply_buffer[ST1] & ST1_EOC)
1442 return 0;
1443 bad = 1;
1444 if (reply_buffer[ST1] & ST1_WP) {
1445 DPRINT("Drive is write protected\n");
1446 clear_bit(FD_DISK_WRITABLE_BIT,
1447 &drive_state[current_drive].flags);
1448 cont->done(0);
1449 bad = 2;
1450 } else if (reply_buffer[ST1] & ST1_ND) {
1451 set_bit(FD_NEED_TWADDLE_BIT,
1452 &drive_state[current_drive].flags);
1453 } else if (reply_buffer[ST1] & ST1_OR) {
1454 if (drive_params[current_drive].flags & FTD_MSG)
1455 DPRINT("Over/Underrun - retrying\n");
1456 bad = 0;
1457 } else if (*errors >= drive_params[current_drive].max_errors.reporting) {
1458 print_errors();
1459 }
1460 if (reply_buffer[ST2] & ST2_WC || reply_buffer[ST2] & ST2_BC)
1461
1462 drive_state[current_drive].track = NEED_2_RECAL;
1463 return bad;
1464 case 0x80:
1465 DPRINT("Invalid FDC command given!\n");
1466 cont->done(0);
1467 return 2;
1468 case 0xc0:
1469 DPRINT("Abnormal termination caused by polling\n");
1470 cont->error();
1471 return 2;
1472 default:
1473 return 0;
1474 }
1475}
1476
1477
1478
1479
1480
1481
1482static void setup_rw_floppy(void)
1483{
1484 int i;
1485 int r;
1486 int flags;
1487 unsigned long ready_date;
1488 void (*function)(void);
1489
1490 flags = raw_cmd->flags;
1491 if (flags & (FD_RAW_READ | FD_RAW_WRITE))
1492 flags |= FD_RAW_INTR;
1493
1494 if ((flags & FD_RAW_SPIN) && !(flags & FD_RAW_NO_MOTOR)) {
1495 ready_date = drive_state[current_drive].spinup_date + drive_params[current_drive].spinup;
1496
1497
1498
1499
1500 if (time_after(ready_date, jiffies + drive_params[current_drive].select_delay)) {
1501 ready_date -= drive_params[current_drive].select_delay;
1502 function = floppy_start;
1503 } else
1504 function = setup_rw_floppy;
1505
1506
1507 if (fd_wait_for_completion(ready_date, function))
1508 return;
1509 }
1510 if ((flags & FD_RAW_READ) || (flags & FD_RAW_WRITE))
1511 setup_DMA();
1512
1513 if (flags & FD_RAW_INTR)
1514 do_floppy = main_command_interrupt;
1515
1516 r = 0;
1517 for (i = 0; i < raw_cmd->cmd_count; i++)
1518 r |= output_byte(current_fdc, raw_cmd->fullcmd[i]);
1519
1520 debugt(__func__, "rw_command");
1521
1522 if (r) {
1523 cont->error();
1524 reset_fdc();
1525 return;
1526 }
1527
1528 if (!(flags & FD_RAW_INTR)) {
1529 inr = result(current_fdc);
1530 cont->interrupt();
1531 } else if (flags & FD_RAW_NEED_DISK)
1532 fd_watchdog();
1533}
1534
1535static int blind_seek;
1536
1537
1538
1539
1540
1541static void seek_interrupt(void)
1542{
1543 debugt(__func__, "");
1544 if (inr != 2 || (reply_buffer[ST0] & 0xF8) != 0x20) {
1545 DPRINT("seek failed\n");
1546 drive_state[current_drive].track = NEED_2_RECAL;
1547 cont->error();
1548 cont->redo();
1549 return;
1550 }
1551 if (drive_state[current_drive].track >= 0 &&
1552 drive_state[current_drive].track != reply_buffer[ST1] &&
1553 !blind_seek) {
1554 debug_dcl(drive_params[current_drive].flags,
1555 "clearing NEWCHANGE flag because of effective seek\n");
1556 debug_dcl(drive_params[current_drive].flags, "jiffies=%lu\n",
1557 jiffies);
1558 clear_bit(FD_DISK_NEWCHANGE_BIT,
1559 &drive_state[current_drive].flags);
1560
1561 drive_state[current_drive].select_date = jiffies;
1562 }
1563 drive_state[current_drive].track = reply_buffer[ST1];
1564 floppy_ready();
1565}
1566
1567static void check_wp(int fdc, int drive)
1568{
1569 if (test_bit(FD_VERIFY_BIT, &drive_state[drive].flags)) {
1570
1571 output_byte(fdc, FD_GETSTATUS);
1572 output_byte(fdc, UNIT(drive));
1573 if (result(fdc) != 1) {
1574 fdc_state[fdc].reset = 1;
1575 return;
1576 }
1577 clear_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
1578 clear_bit(FD_NEED_TWADDLE_BIT,
1579 &drive_state[drive].flags);
1580 debug_dcl(drive_params[drive].flags,
1581 "checking whether disk is write protected\n");
1582 debug_dcl(drive_params[drive].flags, "wp=%x\n",
1583 reply_buffer[ST3] & 0x40);
1584 if (!(reply_buffer[ST3] & 0x40))
1585 set_bit(FD_DISK_WRITABLE_BIT,
1586 &drive_state[drive].flags);
1587 else
1588 clear_bit(FD_DISK_WRITABLE_BIT,
1589 &drive_state[drive].flags);
1590 }
1591}
1592
1593static void seek_floppy(void)
1594{
1595 int track;
1596
1597 blind_seek = 0;
1598
1599 debug_dcl(drive_params[current_drive].flags,
1600 "calling disk change from %s\n", __func__);
1601
1602 if (!test_bit(FD_DISK_NEWCHANGE_BIT, &drive_state[current_drive].flags) &&
1603 disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
1604
1605
1606
1607
1608 set_bit(FD_DISK_CHANGED_BIT,
1609 &drive_state[current_drive].flags);
1610 cont->done(0);
1611 cont->redo();
1612 return;
1613 }
1614 if (drive_state[current_drive].track <= NEED_1_RECAL) {
1615 recalibrate_floppy();
1616 return;
1617 } else if (test_bit(FD_DISK_NEWCHANGE_BIT, &drive_state[current_drive].flags) &&
1618 (raw_cmd->flags & FD_RAW_NEED_DISK) &&
1619 (drive_state[current_drive].track <= NO_TRACK || drive_state[current_drive].track == raw_cmd->track)) {
1620
1621
1622 if (raw_cmd->track)
1623 track = raw_cmd->track - 1;
1624 else {
1625 if (drive_params[current_drive].flags & FD_SILENT_DCL_CLEAR) {
1626 set_dor(current_fdc, ~(0x10 << UNIT(current_drive)), 0);
1627 blind_seek = 1;
1628 raw_cmd->flags |= FD_RAW_NEED_SEEK;
1629 }
1630 track = 1;
1631 }
1632 } else {
1633 check_wp(current_fdc, current_drive);
1634 if (raw_cmd->track != drive_state[current_drive].track &&
1635 (raw_cmd->flags & FD_RAW_NEED_SEEK))
1636 track = raw_cmd->track;
1637 else {
1638 setup_rw_floppy();
1639 return;
1640 }
1641 }
1642
1643 do_floppy = seek_interrupt;
1644 output_byte(current_fdc, FD_SEEK);
1645 output_byte(current_fdc, UNIT(current_drive));
1646 if (output_byte(current_fdc, track) < 0) {
1647 reset_fdc();
1648 return;
1649 }
1650 debugt(__func__, "");
1651}
1652
1653static void recal_interrupt(void)
1654{
1655 debugt(__func__, "");
1656 if (inr != 2)
1657 fdc_state[current_fdc].reset = 1;
1658 else if (reply_buffer[ST0] & ST0_ECE) {
1659 switch (drive_state[current_drive].track) {
1660 case NEED_1_RECAL:
1661 debugt(__func__, "need 1 recal");
1662
1663
1664
1665
1666 cont->error();
1667 cont->redo();
1668 return;
1669 case NEED_2_RECAL:
1670 debugt(__func__, "need 2 recal");
1671
1672
1673
1674
1675
1676
1677 debug_dcl(drive_params[current_drive].flags,
1678 "clearing NEWCHANGE flag because of second recalibrate\n");
1679
1680 clear_bit(FD_DISK_NEWCHANGE_BIT,
1681 &drive_state[current_drive].flags);
1682 drive_state[current_drive].select_date = jiffies;
1683 fallthrough;
1684 default:
1685 debugt(__func__, "default");
1686
1687
1688
1689
1690
1691
1692 drive_state[current_drive].track = NEED_1_RECAL;
1693 break;
1694 }
1695 } else
1696 drive_state[current_drive].track = reply_buffer[ST1];
1697 floppy_ready();
1698}
1699
1700static void print_result(char *message, int inr)
1701{
1702 int i;
1703
1704 DPRINT("%s ", message);
1705 if (inr >= 0)
1706 for (i = 0; i < inr; i++)
1707 pr_cont("repl[%d]=%x ", i, reply_buffer[i]);
1708 pr_cont("\n");
1709}
1710
1711
1712irqreturn_t floppy_interrupt(int irq, void *dev_id)
1713{
1714 int do_print;
1715 unsigned long f;
1716 void (*handler)(void) = do_floppy;
1717
1718 lasthandler = handler;
1719 interruptjiffies = jiffies;
1720
1721 f = claim_dma_lock();
1722 fd_disable_dma();
1723 release_dma_lock(f);
1724
1725 do_floppy = NULL;
1726 if (current_fdc >= N_FDC || fdc_state[current_fdc].address == -1) {
1727
1728 pr_info("DOR0=%x\n", fdc_state[0].dor);
1729 pr_info("floppy interrupt on bizarre fdc %d\n", current_fdc);
1730 pr_info("handler=%ps\n", handler);
1731 is_alive(__func__, "bizarre fdc");
1732 return IRQ_NONE;
1733 }
1734
1735 fdc_state[current_fdc].reset = 0;
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745 do_print = !handler && print_unex && initialized;
1746
1747 inr = result(current_fdc);
1748 if (do_print)
1749 print_result("unexpected interrupt", inr);
1750 if (inr == 0) {
1751 int max_sensei = 4;
1752 do {
1753 output_byte(current_fdc, FD_SENSEI);
1754 inr = result(current_fdc);
1755 if (do_print)
1756 print_result("sensei", inr);
1757 max_sensei--;
1758 } while ((reply_buffer[ST0] & 0x83) != UNIT(current_drive) &&
1759 inr == 2 && max_sensei);
1760 }
1761 if (!handler) {
1762 fdc_state[current_fdc].reset = 1;
1763 return IRQ_NONE;
1764 }
1765 schedule_bh(handler);
1766 is_alive(__func__, "normal interrupt end");
1767
1768
1769 return IRQ_HANDLED;
1770}
1771
1772static void recalibrate_floppy(void)
1773{
1774 debugt(__func__, "");
1775 do_floppy = recal_interrupt;
1776 output_byte(current_fdc, FD_RECALIBRATE);
1777 if (output_byte(current_fdc, UNIT(current_drive)) < 0)
1778 reset_fdc();
1779}
1780
1781
1782
1783
1784static void reset_interrupt(void)
1785{
1786 debugt(__func__, "");
1787 result(current_fdc);
1788 if (fdc_state[current_fdc].reset) {
1789 pr_info("reset set in interrupt, calling %ps\n", cont->error);
1790 cont->error();
1791 }
1792 cont->redo();
1793}
1794
1795
1796
1797
1798
1799
1800
1801static void reset_fdc(void)
1802{
1803 unsigned long flags;
1804
1805 do_floppy = reset_interrupt;
1806 fdc_state[current_fdc].reset = 0;
1807 reset_fdc_info(current_fdc, 0);
1808
1809
1810
1811
1812 flags = claim_dma_lock();
1813 fd_disable_dma();
1814 release_dma_lock(flags);
1815
1816 if (fdc_state[current_fdc].version >= FDC_82072A)
1817 fdc_outb(0x80 | (fdc_state[current_fdc].dtr & 3),
1818 current_fdc, FD_STATUS);
1819 else {
1820 fdc_outb(fdc_state[current_fdc].dor & ~0x04, current_fdc, FD_DOR);
1821 udelay(FD_RESET_DELAY);
1822 fdc_outb(fdc_state[current_fdc].dor, current_fdc, FD_DOR);
1823 }
1824}
1825
1826static void show_floppy(int fdc)
1827{
1828 int i;
1829
1830 pr_info("\n");
1831 pr_info("floppy driver state\n");
1832 pr_info("-------------------\n");
1833 pr_info("now=%lu last interrupt=%lu diff=%lu last called handler=%ps\n",
1834 jiffies, interruptjiffies, jiffies - interruptjiffies,
1835 lasthandler);
1836
1837 pr_info("timeout_message=%s\n", timeout_message);
1838 pr_info("last output bytes:\n");
1839 for (i = 0; i < OLOGSIZE; i++)
1840 pr_info("%2x %2x %lu\n",
1841 output_log[(i + output_log_pos) % OLOGSIZE].data,
1842 output_log[(i + output_log_pos) % OLOGSIZE].status,
1843 output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
1844 pr_info("last result at %lu\n", resultjiffies);
1845 pr_info("last redo_fd_request at %lu\n", lastredo);
1846 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 1,
1847 reply_buffer, resultsize, true);
1848
1849 pr_info("status=%x\n", fdc_inb(fdc, FD_STATUS));
1850 pr_info("fdc_busy=%lu\n", fdc_busy);
1851 if (do_floppy)
1852 pr_info("do_floppy=%ps\n", do_floppy);
1853 if (work_pending(&floppy_work))
1854 pr_info("floppy_work.func=%ps\n", floppy_work.func);
1855 if (delayed_work_pending(&fd_timer))
1856 pr_info("delayed work.function=%p expires=%ld\n",
1857 fd_timer.work.func,
1858 fd_timer.timer.expires - jiffies);
1859 if (delayed_work_pending(&fd_timeout))
1860 pr_info("timer_function=%p expires=%ld\n",
1861 fd_timeout.work.func,
1862 fd_timeout.timer.expires - jiffies);
1863
1864 pr_info("cont=%p\n", cont);
1865 pr_info("current_req=%p\n", current_req);
1866 pr_info("command_status=%d\n", command_status);
1867 pr_info("\n");
1868}
1869
1870static void floppy_shutdown(struct work_struct *arg)
1871{
1872 unsigned long flags;
1873
1874 if (initialized)
1875 show_floppy(current_fdc);
1876 cancel_activity();
1877
1878 flags = claim_dma_lock();
1879 fd_disable_dma();
1880 release_dma_lock(flags);
1881
1882
1883
1884 if (initialized)
1885 DPRINT("floppy timeout called\n");
1886 fdc_state[current_fdc].reset = 1;
1887 if (cont) {
1888 cont->done(0);
1889 cont->redo();
1890 } else {
1891 pr_info("no cont in shutdown!\n");
1892 process_fd_request();
1893 }
1894 is_alive(__func__, "");
1895}
1896
1897
1898static int start_motor(void (*function)(void))
1899{
1900 int mask;
1901 int data;
1902
1903 mask = 0xfc;
1904 data = UNIT(current_drive);
1905 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR)) {
1906 if (!(fdc_state[current_fdc].dor & (0x10 << UNIT(current_drive)))) {
1907 set_debugt();
1908
1909 drive_state[current_drive].first_read_date = 0;
1910
1911 drive_state[current_drive].spinup_date = jiffies;
1912 data |= (0x10 << UNIT(current_drive));
1913 }
1914 } else if (fdc_state[current_fdc].dor & (0x10 << UNIT(current_drive)))
1915 mask &= ~(0x10 << UNIT(current_drive));
1916
1917
1918 del_timer(motor_off_timer + current_drive);
1919 set_dor(current_fdc, mask, data);
1920
1921
1922 return fd_wait_for_completion(drive_state[current_drive].select_date + drive_params[current_drive].select_delay,
1923 function);
1924}
1925
1926static void floppy_ready(void)
1927{
1928 if (fdc_state[current_fdc].reset) {
1929 reset_fdc();
1930 return;
1931 }
1932 if (start_motor(floppy_ready))
1933 return;
1934 if (fdc_dtr())
1935 return;
1936
1937 debug_dcl(drive_params[current_drive].flags,
1938 "calling disk change from floppy_ready\n");
1939 if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
1940 disk_change(current_drive) && !drive_params[current_drive].select_delay)
1941 twaddle(current_fdc, current_drive);
1942
1943
1944#ifdef fd_chose_dma_mode
1945 if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
1946 unsigned long flags = claim_dma_lock();
1947 fd_chose_dma_mode(raw_cmd->kernel_data, raw_cmd->length);
1948 release_dma_lock(flags);
1949 }
1950#endif
1951
1952 if (raw_cmd->flags & (FD_RAW_NEED_SEEK | FD_RAW_NEED_DISK)) {
1953 perpendicular_mode(current_fdc);
1954 fdc_specify(current_fdc, current_drive);
1955 seek_floppy();
1956 } else {
1957 if ((raw_cmd->flags & FD_RAW_READ) ||
1958 (raw_cmd->flags & FD_RAW_WRITE))
1959 fdc_specify(current_fdc, current_drive);
1960 setup_rw_floppy();
1961 }
1962}
1963
1964static void floppy_start(void)
1965{
1966 reschedule_timeout(current_drive, "floppy start");
1967
1968 scandrives();
1969 debug_dcl(drive_params[current_drive].flags,
1970 "setting NEWCHANGE in floppy_start\n");
1971 set_bit(FD_DISK_NEWCHANGE_BIT, &drive_state[current_drive].flags);
1972 floppy_ready();
1973}
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989static void do_wakeup(void)
1990{
1991 reschedule_timeout(MAXTIMEOUT, "do wakeup");
1992 cont = NULL;
1993 command_status += 2;
1994 wake_up(&command_done);
1995}
1996
1997static const struct cont_t wakeup_cont = {
1998 .interrupt = empty,
1999 .redo = do_wakeup,
2000 .error = empty,
2001 .done = (done_f)empty
2002};
2003
2004static const struct cont_t intr_cont = {
2005 .interrupt = empty,
2006 .redo = process_fd_request,
2007 .error = empty,
2008 .done = (done_f)empty
2009};
2010
2011
2012
2013
2014static int wait_til_done(void (*handler)(void), bool interruptible)
2015{
2016 int ret;
2017
2018 schedule_bh(handler);
2019
2020 if (interruptible)
2021 wait_event_interruptible(command_done, command_status >= 2);
2022 else
2023 wait_event(command_done, command_status >= 2);
2024
2025 if (command_status < 2) {
2026 cancel_activity();
2027 cont = &intr_cont;
2028 reset_fdc();
2029 return -EINTR;
2030 }
2031
2032 if (fdc_state[current_fdc].reset)
2033 command_status = FD_COMMAND_ERROR;
2034 if (command_status == FD_COMMAND_OKAY)
2035 ret = 0;
2036 else
2037 ret = -EIO;
2038 command_status = FD_COMMAND_NONE;
2039 return ret;
2040}
2041
2042static void generic_done(int result)
2043{
2044 command_status = result;
2045 cont = &wakeup_cont;
2046}
2047
2048static void generic_success(void)
2049{
2050 cont->done(1);
2051}
2052
2053static void generic_failure(void)
2054{
2055 cont->done(0);
2056}
2057
2058static void success_and_wakeup(void)
2059{
2060 generic_success();
2061 cont->redo();
2062}
2063
2064
2065
2066
2067
2068
2069static int next_valid_format(int drive)
2070{
2071 int probed_format;
2072
2073 probed_format = drive_state[drive].probed_format;
2074 while (1) {
2075 if (probed_format >= FD_AUTODETECT_SIZE ||
2076 !drive_params[drive].autodetect[probed_format]) {
2077 drive_state[drive].probed_format = 0;
2078 return 1;
2079 }
2080 if (floppy_type[drive_params[drive].autodetect[probed_format]].sect) {
2081 drive_state[drive].probed_format = probed_format;
2082 return 0;
2083 }
2084 probed_format++;
2085 }
2086}
2087
2088static void bad_flp_intr(void)
2089{
2090 int err_count;
2091
2092 if (probing) {
2093 drive_state[current_drive].probed_format++;
2094 if (!next_valid_format(current_drive))
2095 return;
2096 }
2097 err_count = ++(*errors);
2098 INFBOUND(write_errors[current_drive].badness, err_count);
2099 if (err_count > drive_params[current_drive].max_errors.abort)
2100 cont->done(0);
2101 if (err_count > drive_params[current_drive].max_errors.reset)
2102 fdc_state[current_fdc].reset = 1;
2103 else if (err_count > drive_params[current_drive].max_errors.recal)
2104 drive_state[current_drive].track = NEED_2_RECAL;
2105}
2106
2107static void set_floppy(int drive)
2108{
2109 int type = ITYPE(drive_state[drive].fd_device);
2110
2111 if (type)
2112 _floppy = floppy_type + type;
2113 else
2114 _floppy = current_type[drive];
2115}
2116
2117
2118
2119
2120
2121static void format_interrupt(void)
2122{
2123 switch (interpret_errors()) {
2124 case 1:
2125 cont->error();
2126 case 2:
2127 break;
2128 case 0:
2129 cont->done(1);
2130 }
2131 cont->redo();
2132}
2133
2134#define FM_MODE(x, y) ((y) & ~(((x)->rate & 0x80) >> 1))
2135#define CT(x) ((x) | 0xc0)
2136
2137static void setup_format_params(int track)
2138{
2139 int n;
2140 int il;
2141 int count;
2142 int head_shift;
2143 int track_shift;
2144 struct fparm {
2145 unsigned char track, head, sect, size;
2146 } *here = (struct fparm *)floppy_track_buffer;
2147
2148 raw_cmd = &default_raw_cmd;
2149 raw_cmd->track = track;
2150
2151 raw_cmd->flags = (FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
2152 FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK);
2153 raw_cmd->rate = _floppy->rate & 0x43;
2154 raw_cmd->cmd_count = NR_F;
2155 raw_cmd->cmd[COMMAND] = FM_MODE(_floppy, FD_FORMAT);
2156 raw_cmd->cmd[DR_SELECT] = UNIT(current_drive) + PH_HEAD(_floppy, format_req.head);
2157 raw_cmd->cmd[F_SIZECODE] = FD_SIZECODE(_floppy);
2158 raw_cmd->cmd[F_SECT_PER_TRACK] = _floppy->sect << 2 >> raw_cmd->cmd[F_SIZECODE];
2159 raw_cmd->cmd[F_GAP] = _floppy->fmt_gap;
2160 raw_cmd->cmd[F_FILL] = FD_FILL_BYTE;
2161
2162 raw_cmd->kernel_data = floppy_track_buffer;
2163 raw_cmd->length = 4 * raw_cmd->cmd[F_SECT_PER_TRACK];
2164
2165 if (!raw_cmd->cmd[F_SECT_PER_TRACK])
2166 return;
2167
2168
2169 head_shift = (raw_cmd->cmd[F_SECT_PER_TRACK] + 5) / 6;
2170
2171
2172 track_shift = 2 * head_shift + 3;
2173
2174
2175 n = (track_shift * format_req.track + head_shift * format_req.head)
2176 % raw_cmd->cmd[F_SECT_PER_TRACK];
2177
2178
2179 il = 1;
2180 if (_floppy->fmt_gap < 0x22)
2181 il++;
2182
2183
2184 for (count = 0; count < raw_cmd->cmd[F_SECT_PER_TRACK]; ++count) {
2185 here[count].track = format_req.track;
2186 here[count].head = format_req.head;
2187 here[count].sect = 0;
2188 here[count].size = raw_cmd->cmd[F_SIZECODE];
2189 }
2190
2191 for (count = 1; count <= raw_cmd->cmd[F_SECT_PER_TRACK]; ++count) {
2192 here[n].sect = count;
2193 n = (n + il) % raw_cmd->cmd[F_SECT_PER_TRACK];
2194 if (here[n].sect) {
2195 ++n;
2196 if (n >= raw_cmd->cmd[F_SECT_PER_TRACK]) {
2197 n -= raw_cmd->cmd[F_SECT_PER_TRACK];
2198 while (here[n].sect)
2199 ++n;
2200 }
2201 }
2202 }
2203 if (_floppy->stretch & FD_SECTBASEMASK) {
2204 for (count = 0; count < raw_cmd->cmd[F_SECT_PER_TRACK]; count++)
2205 here[count].sect += FD_SECTBASE(_floppy) - 1;
2206 }
2207}
2208
2209static void redo_format(void)
2210{
2211 buffer_track = -1;
2212 setup_format_params(format_req.track << STRETCH(_floppy));
2213 floppy_start();
2214 debugt(__func__, "queue format request");
2215}
2216
2217static const struct cont_t format_cont = {
2218 .interrupt = format_interrupt,
2219 .redo = redo_format,
2220 .error = bad_flp_intr,
2221 .done = generic_done
2222};
2223
2224static int do_format(int drive, struct format_descr *tmp_format_req)
2225{
2226 int ret;
2227
2228 if (lock_fdc(drive))
2229 return -EINTR;
2230
2231 set_floppy(drive);
2232 if (!_floppy ||
2233 _floppy->track > drive_params[current_drive].tracks ||
2234 tmp_format_req->track >= _floppy->track ||
2235 tmp_format_req->head >= _floppy->head ||
2236 (_floppy->sect << 2) % (1 << FD_SIZECODE(_floppy)) ||
2237 !_floppy->fmt_gap) {
2238 process_fd_request();
2239 return -EINVAL;
2240 }
2241 format_req = *tmp_format_req;
2242 format_errors = 0;
2243 cont = &format_cont;
2244 errors = &format_errors;
2245 ret = wait_til_done(redo_format, true);
2246 if (ret == -EINTR)
2247 return -EINTR;
2248 process_fd_request();
2249 return ret;
2250}
2251
2252
2253
2254
2255
2256
2257static void floppy_end_request(struct request *req, blk_status_t error)
2258{
2259 unsigned int nr_sectors = current_count_sectors;
2260 unsigned int drive = (unsigned long)req->rq_disk->private_data;
2261
2262
2263 if (error)
2264 nr_sectors = blk_rq_cur_sectors(req);
2265 if (blk_update_request(req, error, nr_sectors << 9))
2266 return;
2267 __blk_mq_end_request(req, error);
2268
2269
2270 floppy_off(drive);
2271 current_req = NULL;
2272}
2273
2274
2275
2276static void request_done(int uptodate)
2277{
2278 struct request *req = current_req;
2279 int block;
2280 char msg[sizeof("request done ") + sizeof(int) * 3];
2281
2282 probing = 0;
2283 snprintf(msg, sizeof(msg), "request done %d", uptodate);
2284 reschedule_timeout(MAXTIMEOUT, msg);
2285
2286 if (!req) {
2287 pr_info("floppy.c: no request in request_done\n");
2288 return;
2289 }
2290
2291 if (uptodate) {
2292
2293
2294 block = current_count_sectors + blk_rq_pos(req);
2295 INFBOUND(drive_state[current_drive].maxblock, block);
2296 if (block > _floppy->sect)
2297 drive_state[current_drive].maxtrack = 1;
2298
2299 floppy_end_request(req, 0);
2300 } else {
2301 if (rq_data_dir(req) == WRITE) {
2302
2303 write_errors[current_drive].write_errors++;
2304 if (write_errors[current_drive].write_errors == 1) {
2305 write_errors[current_drive].first_error_sector = blk_rq_pos(req);
2306 write_errors[current_drive].first_error_generation = drive_state[current_drive].generation;
2307 }
2308 write_errors[current_drive].last_error_sector = blk_rq_pos(req);
2309 write_errors[current_drive].last_error_generation = drive_state[current_drive].generation;
2310 }
2311 floppy_end_request(req, BLK_STS_IOERR);
2312 }
2313}
2314
2315
2316static void rw_interrupt(void)
2317{
2318 int eoc;
2319 int ssize;
2320 int heads;
2321 int nr_sectors;
2322
2323 if (reply_buffer[R_HEAD] >= 2) {
2324
2325
2326
2327 return;
2328 }
2329
2330 if (!drive_state[current_drive].first_read_date)
2331 drive_state[current_drive].first_read_date = jiffies;
2332
2333 nr_sectors = 0;
2334 ssize = DIV_ROUND_UP(1 << raw_cmd->cmd[SIZECODE], 4);
2335
2336 if (reply_buffer[ST1] & ST1_EOC)
2337 eoc = 1;
2338 else
2339 eoc = 0;
2340
2341 if (raw_cmd->cmd[COMMAND] & 0x80)
2342 heads = 2;
2343 else
2344 heads = 1;
2345
2346 nr_sectors = (((reply_buffer[R_TRACK] - raw_cmd->cmd[TRACK]) * heads +
2347 reply_buffer[R_HEAD] - raw_cmd->cmd[HEAD]) * raw_cmd->cmd[SECT_PER_TRACK] +
2348 reply_buffer[R_SECTOR] - raw_cmd->cmd[SECTOR] + eoc) << raw_cmd->cmd[SIZECODE] >> 2;
2349
2350 if (nr_sectors / ssize >
2351 DIV_ROUND_UP(in_sector_offset + current_count_sectors, ssize)) {
2352 DPRINT("long rw: %x instead of %lx\n",
2353 nr_sectors, current_count_sectors);
2354 pr_info("rs=%d s=%d\n", reply_buffer[R_SECTOR],
2355 raw_cmd->cmd[SECTOR]);
2356 pr_info("rh=%d h=%d\n", reply_buffer[R_HEAD],
2357 raw_cmd->cmd[HEAD]);
2358 pr_info("rt=%d t=%d\n", reply_buffer[R_TRACK],
2359 raw_cmd->cmd[TRACK]);
2360 pr_info("heads=%d eoc=%d\n", heads, eoc);
2361 pr_info("spt=%d st=%d ss=%d\n",
2362 raw_cmd->cmd[SECT_PER_TRACK], fsector_t, ssize);
2363 pr_info("in_sector_offset=%d\n", in_sector_offset);
2364 }
2365
2366 nr_sectors -= in_sector_offset;
2367 INFBOUND(nr_sectors, 0);
2368 SUPBOUND(current_count_sectors, nr_sectors);
2369
2370 switch (interpret_errors()) {
2371 case 2:
2372 cont->redo();
2373 return;
2374 case 1:
2375 if (!current_count_sectors) {
2376 cont->error();
2377 cont->redo();
2378 return;
2379 }
2380 break;
2381 case 0:
2382 if (!current_count_sectors) {
2383 cont->redo();
2384 return;
2385 }
2386 current_type[current_drive] = _floppy;
2387 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2388 break;
2389 }
2390
2391 if (probing) {
2392 if (drive_params[current_drive].flags & FTD_MSG)
2393 DPRINT("Auto-detected floppy type %s in fd%d\n",
2394 _floppy->name, current_drive);
2395 current_type[current_drive] = _floppy;
2396 floppy_sizes[TOMINOR(current_drive)] = _floppy->size;
2397 probing = 0;
2398 }
2399
2400 if (CT(raw_cmd->cmd[COMMAND]) != FD_READ ||
2401 raw_cmd->kernel_data == bio_data(current_req->bio)) {
2402
2403 cont->done(1);
2404 } else if (CT(raw_cmd->cmd[COMMAND]) == FD_READ) {
2405 buffer_track = raw_cmd->track;
2406 buffer_drive = current_drive;
2407 INFBOUND(buffer_max, nr_sectors + fsector_t);
2408 }
2409 cont->redo();
2410}
2411
2412
2413static int buffer_chain_size(void)
2414{
2415 struct bio_vec bv;
2416 int size;
2417 struct req_iterator iter;
2418 char *base;
2419
2420 base = bio_data(current_req->bio);
2421 size = 0;
2422
2423 rq_for_each_segment(bv, current_req, iter) {
2424 if (page_address(bv.bv_page) + bv.bv_offset != base + size)
2425 break;
2426
2427 size += bv.bv_len;
2428 }
2429
2430 return size >> 9;
2431}
2432
2433
2434static int transfer_size(int ssize, int max_sector, int max_size)
2435{
2436 SUPBOUND(max_sector, fsector_t + max_size);
2437
2438
2439 max_sector -= (max_sector % _floppy->sect) % ssize;
2440
2441
2442 current_count_sectors = max_sector - fsector_t;
2443
2444 return max_sector;
2445}
2446
2447
2448
2449
2450static void copy_buffer(int ssize, int max_sector, int max_sector_2)
2451{
2452 int remaining;
2453 struct bio_vec bv;
2454 char *buffer;
2455 char *dma_buffer;
2456 int size;
2457 struct req_iterator iter;
2458
2459 max_sector = transfer_size(ssize,
2460 min(max_sector, max_sector_2),
2461 blk_rq_sectors(current_req));
2462
2463 if (current_count_sectors <= 0 && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE &&
2464 buffer_max > fsector_t + blk_rq_sectors(current_req))
2465 current_count_sectors = min_t(int, buffer_max - fsector_t,
2466 blk_rq_sectors(current_req));
2467
2468 remaining = current_count_sectors << 9;
2469 if (remaining > blk_rq_bytes(current_req) && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {
2470 DPRINT("in copy buffer\n");
2471 pr_info("current_count_sectors=%ld\n", current_count_sectors);
2472 pr_info("remaining=%d\n", remaining >> 9);
2473 pr_info("current_req->nr_sectors=%u\n",
2474 blk_rq_sectors(current_req));
2475 pr_info("current_req->current_nr_sectors=%u\n",
2476 blk_rq_cur_sectors(current_req));
2477 pr_info("max_sector=%d\n", max_sector);
2478 pr_info("ssize=%d\n", ssize);
2479 }
2480
2481 buffer_max = max(max_sector, buffer_max);
2482
2483 dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
2484
2485 size = blk_rq_cur_bytes(current_req);
2486
2487 rq_for_each_segment(bv, current_req, iter) {
2488 if (!remaining)
2489 break;
2490
2491 size = bv.bv_len;
2492 SUPBOUND(size, remaining);
2493
2494 buffer = page_address(bv.bv_page) + bv.bv_offset;
2495 if (dma_buffer + size >
2496 floppy_track_buffer + (max_buffer_sectors << 10) ||
2497 dma_buffer < floppy_track_buffer) {
2498 DPRINT("buffer overrun in copy buffer %d\n",
2499 (int)((floppy_track_buffer - dma_buffer) >> 9));
2500 pr_info("fsector_t=%d buffer_min=%d\n",
2501 fsector_t, buffer_min);
2502 pr_info("current_count_sectors=%ld\n",
2503 current_count_sectors);
2504 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ)
2505 pr_info("read\n");
2506 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE)
2507 pr_info("write\n");
2508 break;
2509 }
2510 if (((unsigned long)buffer) % 512)
2511 DPRINT("%p buffer not aligned\n", buffer);
2512
2513 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ)
2514 memcpy(buffer, dma_buffer, size);
2515 else
2516 memcpy(dma_buffer, buffer, size);
2517
2518 remaining -= size;
2519 dma_buffer += size;
2520 }
2521 if (remaining) {
2522 if (remaining > 0)
2523 max_sector -= remaining >> 9;
2524 DPRINT("weirdness: remaining %d\n", remaining >> 9);
2525 }
2526}
2527
2528
2529
2530
2531
2532
2533
2534
2535static void virtualdmabug_workaround(void)
2536{
2537 int hard_sectors;
2538 int end_sector;
2539
2540 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {
2541 raw_cmd->cmd[COMMAND] &= ~0x80;
2542
2543 hard_sectors = raw_cmd->length >> (7 + raw_cmd->cmd[SIZECODE]);
2544 end_sector = raw_cmd->cmd[SECTOR] + hard_sectors - 1;
2545 if (end_sector > raw_cmd->cmd[SECT_PER_TRACK]) {
2546 pr_info("too many sectors %d > %d\n",
2547 end_sector, raw_cmd->cmd[SECT_PER_TRACK]);
2548 return;
2549 }
2550 raw_cmd->cmd[SECT_PER_TRACK] = end_sector;
2551
2552
2553 }
2554}
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566static int make_raw_rw_request(void)
2567{
2568 int aligned_sector_t;
2569 int max_sector;
2570 int max_size;
2571 int tracksize;
2572 int ssize;
2573
2574 if (WARN(max_buffer_sectors == 0, "VFS: Block I/O scheduled on unopened device\n"))
2575 return 0;
2576
2577 set_fdc((long)current_req->rq_disk->private_data);
2578
2579 raw_cmd = &default_raw_cmd;
2580 raw_cmd->flags = FD_RAW_SPIN | FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
2581 raw_cmd->cmd_count = NR_RW;
2582 if (rq_data_dir(current_req) == READ) {
2583 raw_cmd->flags |= FD_RAW_READ;
2584 raw_cmd->cmd[COMMAND] = FM_MODE(_floppy, FD_READ);
2585 } else if (rq_data_dir(current_req) == WRITE) {
2586 raw_cmd->flags |= FD_RAW_WRITE;
2587 raw_cmd->cmd[COMMAND] = FM_MODE(_floppy, FD_WRITE);
2588 } else {
2589 DPRINT("%s: unknown command\n", __func__);
2590 return 0;
2591 }
2592
2593 max_sector = _floppy->sect * _floppy->head;
2594
2595 raw_cmd->cmd[TRACK] = (int)blk_rq_pos(current_req) / max_sector;
2596 fsector_t = (int)blk_rq_pos(current_req) % max_sector;
2597 if (_floppy->track && raw_cmd->cmd[TRACK] >= _floppy->track) {
2598 if (blk_rq_cur_sectors(current_req) & 1) {
2599 current_count_sectors = 1;
2600 return 1;
2601 } else
2602 return 0;
2603 }
2604 raw_cmd->cmd[HEAD] = fsector_t / _floppy->sect;
2605
2606 if (((_floppy->stretch & (FD_SWAPSIDES | FD_SECTBASEMASK)) ||
2607 test_bit(FD_NEED_TWADDLE_BIT, &drive_state[current_drive].flags)) &&
2608 fsector_t < _floppy->sect)
2609 max_sector = _floppy->sect;
2610
2611
2612 if ((_floppy->rate & FD_2M) && (!raw_cmd->cmd[TRACK]) && (!raw_cmd->cmd[HEAD])) {
2613 max_sector = 2 * _floppy->sect / 3;
2614 if (fsector_t >= max_sector) {
2615 current_count_sectors =
2616 min_t(int, _floppy->sect - fsector_t,
2617 blk_rq_sectors(current_req));
2618 return 1;
2619 }
2620 raw_cmd->cmd[SIZECODE] = 2;
2621 } else
2622 raw_cmd->cmd[SIZECODE] = FD_SIZECODE(_floppy);
2623 raw_cmd->rate = _floppy->rate & 0x43;
2624 if ((_floppy->rate & FD_2M) &&
2625 (raw_cmd->cmd[TRACK] || raw_cmd->cmd[HEAD]) && raw_cmd->rate == 2)
2626 raw_cmd->rate = 1;
2627
2628 if (raw_cmd->cmd[SIZECODE])
2629 raw_cmd->cmd[SIZECODE2] = 0xff;
2630 else
2631 raw_cmd->cmd[SIZECODE2] = 0x80;
2632 raw_cmd->track = raw_cmd->cmd[TRACK] << STRETCH(_floppy);
2633 raw_cmd->cmd[DR_SELECT] = UNIT(current_drive) + PH_HEAD(_floppy, raw_cmd->cmd[HEAD]);
2634 raw_cmd->cmd[GAP] = _floppy->gap;
2635 ssize = DIV_ROUND_UP(1 << raw_cmd->cmd[SIZECODE], 4);
2636 raw_cmd->cmd[SECT_PER_TRACK] = _floppy->sect << 2 >> raw_cmd->cmd[SIZECODE];
2637 raw_cmd->cmd[SECTOR] = ((fsector_t % _floppy->sect) << 2 >> raw_cmd->cmd[SIZECODE]) +
2638 FD_SECTBASE(_floppy);
2639
2640
2641
2642
2643 tracksize = _floppy->sect - _floppy->sect % ssize;
2644 if (tracksize < _floppy->sect) {
2645 raw_cmd->cmd[SECT_PER_TRACK]++;
2646 if (tracksize <= fsector_t % _floppy->sect)
2647 raw_cmd->cmd[SECTOR]--;
2648
2649
2650 while (tracksize <= fsector_t % _floppy->sect) {
2651 while (tracksize + ssize > _floppy->sect) {
2652 raw_cmd->cmd[SIZECODE]--;
2653 ssize >>= 1;
2654 }
2655 raw_cmd->cmd[SECTOR]++;
2656 raw_cmd->cmd[SECT_PER_TRACK]++;
2657 tracksize += ssize;
2658 }
2659 max_sector = raw_cmd->cmd[HEAD] * _floppy->sect + tracksize;
2660 } else if (!raw_cmd->cmd[TRACK] && !raw_cmd->cmd[HEAD] && !(_floppy->rate & FD_2M) && probing) {
2661 max_sector = _floppy->sect;
2662 } else if (!raw_cmd->cmd[HEAD] && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {
2663
2664 max_sector = _floppy->sect;
2665 }
2666
2667 in_sector_offset = (fsector_t % _floppy->sect) % ssize;
2668 aligned_sector_t = fsector_t - in_sector_offset;
2669 max_size = blk_rq_sectors(current_req);
2670 if ((raw_cmd->track == buffer_track) &&
2671 (current_drive == buffer_drive) &&
2672 (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
2673
2674 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ) {
2675 copy_buffer(1, max_sector, buffer_max);
2676 return 1;
2677 }
2678 } else if (in_sector_offset || blk_rq_sectors(current_req) < ssize) {
2679 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {
2680 unsigned int sectors;
2681
2682 sectors = fsector_t + blk_rq_sectors(current_req);
2683 if (sectors > ssize && sectors < ssize + ssize)
2684 max_size = ssize + ssize;
2685 else
2686 max_size = ssize;
2687 }
2688 raw_cmd->flags &= ~FD_RAW_WRITE;
2689 raw_cmd->flags |= FD_RAW_READ;
2690 raw_cmd->cmd[COMMAND] = FM_MODE(_floppy, FD_READ);
2691 } else if ((unsigned long)bio_data(current_req->bio) < MAX_DMA_ADDRESS) {
2692 unsigned long dma_limit;
2693 int direct, indirect;
2694
2695 indirect =
2696 transfer_size(ssize, max_sector,
2697 max_buffer_sectors * 2) - fsector_t;
2698
2699
2700
2701
2702
2703 max_size = buffer_chain_size();
2704 dma_limit = (MAX_DMA_ADDRESS -
2705 ((unsigned long)bio_data(current_req->bio))) >> 9;
2706 if ((unsigned long)max_size > dma_limit)
2707 max_size = dma_limit;
2708
2709 if (CROSS_64KB(bio_data(current_req->bio), max_size << 9))
2710 max_size = (K_64 -
2711 ((unsigned long)bio_data(current_req->bio)) %
2712 K_64) >> 9;
2713 direct = transfer_size(ssize, max_sector, max_size) - fsector_t;
2714
2715
2716
2717
2718
2719
2720
2721 if (!direct ||
2722 (indirect * 2 > direct * 3 &&
2723 *errors < drive_params[current_drive].max_errors.read_track &&
2724 ((!probing ||
2725 (drive_params[current_drive].read_track & (1 << drive_state[current_drive].probed_format)))))) {
2726 max_size = blk_rq_sectors(current_req);
2727 } else {
2728 raw_cmd->kernel_data = bio_data(current_req->bio);
2729 raw_cmd->length = current_count_sectors << 9;
2730 if (raw_cmd->length == 0) {
2731 DPRINT("%s: zero dma transfer attempted\n", __func__);
2732 DPRINT("indirect=%d direct=%d fsector_t=%d\n",
2733 indirect, direct, fsector_t);
2734 return 0;
2735 }
2736 virtualdmabug_workaround();
2737 return 2;
2738 }
2739 }
2740
2741 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ)
2742 max_size = max_sector;
2743
2744
2745 if (buffer_track != raw_cmd->track ||
2746 buffer_drive != current_drive ||
2747 fsector_t > buffer_max ||
2748 fsector_t < buffer_min ||
2749 ((CT(raw_cmd->cmd[COMMAND]) == FD_READ ||
2750 (!in_sector_offset && blk_rq_sectors(current_req) >= ssize)) &&
2751 max_sector > 2 * max_buffer_sectors + buffer_min &&
2752 max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)) {
2753
2754 buffer_track = -1;
2755 buffer_drive = current_drive;
2756 buffer_max = buffer_min = aligned_sector_t;
2757 }
2758 raw_cmd->kernel_data = floppy_track_buffer +
2759 ((aligned_sector_t - buffer_min) << 9);
2760
2761 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {
2762
2763
2764
2765
2766 if (in_sector_offset && buffer_track == -1)
2767 DPRINT("internal error offset !=0 on write\n");
2768 buffer_track = raw_cmd->track;
2769 buffer_drive = current_drive;
2770 copy_buffer(ssize, max_sector,
2771 2 * max_buffer_sectors + buffer_min);
2772 } else
2773 transfer_size(ssize, max_sector,
2774 2 * max_buffer_sectors + buffer_min -
2775 aligned_sector_t);
2776
2777
2778 raw_cmd->length = in_sector_offset + current_count_sectors;
2779 raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
2780 raw_cmd->length <<= 9;
2781 if ((raw_cmd->length < current_count_sectors << 9) ||
2782 (raw_cmd->kernel_data != bio_data(current_req->bio) &&
2783 CT(raw_cmd->cmd[COMMAND]) == FD_WRITE &&
2784 (aligned_sector_t + (raw_cmd->length >> 9) > buffer_max ||
2785 aligned_sector_t < buffer_min)) ||
2786 raw_cmd->length % (128 << raw_cmd->cmd[SIZECODE]) ||
2787 raw_cmd->length <= 0 || current_count_sectors <= 0) {
2788 DPRINT("fractionary current count b=%lx s=%lx\n",
2789 raw_cmd->length, current_count_sectors);
2790 if (raw_cmd->kernel_data != bio_data(current_req->bio))
2791 pr_info("addr=%d, length=%ld\n",
2792 (int)((raw_cmd->kernel_data -
2793 floppy_track_buffer) >> 9),
2794 current_count_sectors);
2795 pr_info("st=%d ast=%d mse=%d msi=%d\n",
2796 fsector_t, aligned_sector_t, max_sector, max_size);
2797 pr_info("ssize=%x SIZECODE=%d\n", ssize, raw_cmd->cmd[SIZECODE]);
2798 pr_info("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
2799 raw_cmd->cmd[COMMAND], raw_cmd->cmd[SECTOR],
2800 raw_cmd->cmd[HEAD], raw_cmd->cmd[TRACK]);
2801 pr_info("buffer drive=%d\n", buffer_drive);
2802 pr_info("buffer track=%d\n", buffer_track);
2803 pr_info("buffer_min=%d\n", buffer_min);
2804 pr_info("buffer_max=%d\n", buffer_max);
2805 return 0;
2806 }
2807
2808 if (raw_cmd->kernel_data != bio_data(current_req->bio)) {
2809 if (raw_cmd->kernel_data < floppy_track_buffer ||
2810 current_count_sectors < 0 ||
2811 raw_cmd->length < 0 ||
2812 raw_cmd->kernel_data + raw_cmd->length >
2813 floppy_track_buffer + (max_buffer_sectors << 10)) {
2814 DPRINT("buffer overrun in schedule dma\n");
2815 pr_info("fsector_t=%d buffer_min=%d current_count=%ld\n",
2816 fsector_t, buffer_min, raw_cmd->length >> 9);
2817 pr_info("current_count_sectors=%ld\n",
2818 current_count_sectors);
2819 if (CT(raw_cmd->cmd[COMMAND]) == FD_READ)
2820 pr_info("read\n");
2821 if (CT(raw_cmd->cmd[COMMAND]) == FD_WRITE)
2822 pr_info("write\n");
2823 return 0;
2824 }
2825 } else if (raw_cmd->length > blk_rq_bytes(current_req) ||
2826 current_count_sectors > blk_rq_sectors(current_req)) {
2827 DPRINT("buffer overrun in direct transfer\n");
2828 return 0;
2829 } else if (raw_cmd->length < current_count_sectors << 9) {
2830 DPRINT("more sectors than bytes\n");
2831 pr_info("bytes=%ld\n", raw_cmd->length >> 9);
2832 pr_info("sectors=%ld\n", current_count_sectors);
2833 }
2834 if (raw_cmd->length == 0) {
2835 DPRINT("zero dma transfer attempted from make_raw_request\n");
2836 return 0;
2837 }
2838
2839 virtualdmabug_workaround();
2840 return 2;
2841}
2842
2843static int set_next_request(void)
2844{
2845 current_req = list_first_entry_or_null(&floppy_reqs, struct request,
2846 queuelist);
2847 if (current_req) {
2848 current_req->error_count = 0;
2849 list_del_init(¤t_req->queuelist);
2850 }
2851 return current_req != NULL;
2852}
2853
2854
2855
2856
2857static void redo_fd_request(void)
2858{
2859 int drive;
2860 int tmp;
2861
2862 lastredo = jiffies;
2863 if (current_drive < N_DRIVE)
2864 floppy_off(current_drive);
2865
2866do_request:
2867 if (!current_req) {
2868 int pending;
2869
2870 spin_lock_irq(&floppy_lock);
2871 pending = set_next_request();
2872 spin_unlock_irq(&floppy_lock);
2873 if (!pending) {
2874 do_floppy = NULL;
2875 unlock_fdc();
2876 return;
2877 }
2878 }
2879 drive = (long)current_req->rq_disk->private_data;
2880 set_fdc(drive);
2881 reschedule_timeout(current_drive, "redo fd request");
2882
2883 set_floppy(drive);
2884 raw_cmd = &default_raw_cmd;
2885 raw_cmd->flags = 0;
2886 if (start_motor(redo_fd_request))
2887 return;
2888
2889 disk_change(current_drive);
2890 if (test_bit(current_drive, &fake_change) ||
2891 test_bit(FD_DISK_CHANGED_BIT, &drive_state[current_drive].flags)) {
2892 DPRINT("disk absent or changed during operation\n");
2893 request_done(0);
2894 goto do_request;
2895 }
2896 if (!_floppy) {
2897 if (!probing) {
2898 drive_state[current_drive].probed_format = 0;
2899 if (next_valid_format(current_drive)) {
2900 DPRINT("no autodetectable formats\n");
2901 _floppy = NULL;
2902 request_done(0);
2903 goto do_request;
2904 }
2905 }
2906 probing = 1;
2907 _floppy = floppy_type + drive_params[current_drive].autodetect[drive_state[current_drive].probed_format];
2908 } else
2909 probing = 0;
2910 errors = &(current_req->error_count);
2911 tmp = make_raw_rw_request();
2912 if (tmp < 2) {
2913 request_done(tmp);
2914 goto do_request;
2915 }
2916
2917 if (test_bit(FD_NEED_TWADDLE_BIT, &drive_state[current_drive].flags))
2918 twaddle(current_fdc, current_drive);
2919 schedule_bh(floppy_start);
2920 debugt(__func__, "queue fd request");
2921 return;
2922}
2923
2924static const struct cont_t rw_cont = {
2925 .interrupt = rw_interrupt,
2926 .redo = redo_fd_request,
2927 .error = bad_flp_intr,
2928 .done = request_done
2929};
2930
2931
2932static void process_fd_request(void)
2933{
2934 cont = &rw_cont;
2935 schedule_bh(redo_fd_request);
2936}
2937
2938static blk_status_t floppy_queue_rq(struct blk_mq_hw_ctx *hctx,
2939 const struct blk_mq_queue_data *bd)
2940{
2941 blk_mq_start_request(bd->rq);
2942
2943 if (WARN(max_buffer_sectors == 0,
2944 "VFS: %s called on non-open device\n", __func__))
2945 return BLK_STS_IOERR;
2946
2947 if (WARN(atomic_read(&usage_count) == 0,
2948 "warning: usage count=0, current_req=%p sect=%ld flags=%llx\n",
2949 current_req, (long)blk_rq_pos(current_req),
2950 (unsigned long long) current_req->cmd_flags))
2951 return BLK_STS_IOERR;
2952
2953 if (test_and_set_bit(0, &fdc_busy)) {
2954
2955
2956 is_alive(__func__, "old request running");
2957 return BLK_STS_RESOURCE;
2958 }
2959
2960 spin_lock_irq(&floppy_lock);
2961 list_add_tail(&bd->rq->queuelist, &floppy_reqs);
2962 spin_unlock_irq(&floppy_lock);
2963
2964 command_status = FD_COMMAND_NONE;
2965 __reschedule_timeout(MAXTIMEOUT, "fd_request");
2966 set_fdc(0);
2967 process_fd_request();
2968 is_alive(__func__, "");
2969 return BLK_STS_OK;
2970}
2971
2972static const struct cont_t poll_cont = {
2973 .interrupt = success_and_wakeup,
2974 .redo = floppy_ready,
2975 .error = generic_failure,
2976 .done = generic_done
2977};
2978
2979static int poll_drive(bool interruptible, int flag)
2980{
2981
2982 raw_cmd = &default_raw_cmd;
2983 raw_cmd->flags = flag;
2984 raw_cmd->track = 0;
2985 raw_cmd->cmd_count = 0;
2986 cont = &poll_cont;
2987 debug_dcl(drive_params[current_drive].flags,
2988 "setting NEWCHANGE in poll_drive\n");
2989 set_bit(FD_DISK_NEWCHANGE_BIT, &drive_state[current_drive].flags);
2990
2991 return wait_til_done(floppy_ready, interruptible);
2992}
2993
2994
2995
2996
2997
2998
2999static void reset_intr(void)
3000{
3001 pr_info("weird, reset interrupt called\n");
3002}
3003
3004static const struct cont_t reset_cont = {
3005 .interrupt = reset_intr,
3006 .redo = success_and_wakeup,
3007 .error = generic_failure,
3008 .done = generic_done
3009};
3010
3011
3012
3013
3014
3015static int user_reset_fdc(int drive, int arg, bool interruptible)
3016{
3017 int ret;
3018
3019 if (lock_fdc(drive))
3020 return -EINTR;
3021
3022 if (arg == FD_RESET_ALWAYS)
3023 fdc_state[current_fdc].reset = 1;
3024 if (fdc_state[current_fdc].reset) {
3025
3026
3027
3028 cont = &reset_cont;
3029 ret = wait_til_done(reset_fdc, interruptible);
3030 if (ret == -EINTR)
3031 return -EINTR;
3032 }
3033 process_fd_request();
3034 return 0;
3035}
3036
3037
3038
3039
3040
3041static inline int fd_copyout(void __user *param, const void *address,
3042 unsigned long size)
3043{
3044 return copy_to_user(param, address, size) ? -EFAULT : 0;
3045}
3046
3047static inline int fd_copyin(void __user *param, void *address,
3048 unsigned long size)
3049{
3050 return copy_from_user(address, param, size) ? -EFAULT : 0;
3051}
3052
3053static const char *drive_name(int type, int drive)
3054{
3055 struct floppy_struct *floppy;
3056
3057 if (type)
3058 floppy = floppy_type + type;
3059 else {
3060 if (drive_params[drive].native_format)
3061 floppy = floppy_type + drive_params[drive].native_format;
3062 else
3063 return "(null)";
3064 }
3065 if (floppy->name)
3066 return floppy->name;
3067 else
3068 return "(null)";
3069}
3070
3071
3072static void raw_cmd_done(int flag)
3073{
3074 int i;
3075
3076 if (!flag) {
3077 raw_cmd->flags |= FD_RAW_FAILURE;
3078 raw_cmd->flags |= FD_RAW_HARDFAILURE;
3079 } else {
3080 raw_cmd->reply_count = inr;
3081 if (raw_cmd->reply_count > FD_RAW_REPLY_SIZE)
3082 raw_cmd->reply_count = 0;
3083 for (i = 0; i < raw_cmd->reply_count; i++)
3084 raw_cmd->reply[i] = reply_buffer[i];
3085
3086 if (raw_cmd->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3087 unsigned long flags;
3088 flags = claim_dma_lock();
3089 raw_cmd->length = fd_get_dma_residue();
3090 release_dma_lock(flags);
3091 }
3092
3093 if ((raw_cmd->flags & FD_RAW_SOFTFAILURE) &&
3094 (!raw_cmd->reply_count || (raw_cmd->reply[0] & 0xc0)))
3095 raw_cmd->flags |= FD_RAW_FAILURE;
3096
3097 if (disk_change(current_drive))
3098 raw_cmd->flags |= FD_RAW_DISK_CHANGE;
3099 else
3100 raw_cmd->flags &= ~FD_RAW_DISK_CHANGE;
3101 if (raw_cmd->flags & FD_RAW_NO_MOTOR_AFTER)
3102 motor_off_callback(&motor_off_timer[current_drive]);
3103
3104 if (raw_cmd->next &&
3105 (!(raw_cmd->flags & FD_RAW_FAILURE) ||
3106 !(raw_cmd->flags & FD_RAW_STOP_IF_FAILURE)) &&
3107 ((raw_cmd->flags & FD_RAW_FAILURE) ||
3108 !(raw_cmd->flags & FD_RAW_STOP_IF_SUCCESS))) {
3109 raw_cmd = raw_cmd->next;
3110 return;
3111 }
3112 }
3113 generic_done(flag);
3114}
3115
3116static const struct cont_t raw_cmd_cont = {
3117 .interrupt = success_and_wakeup,
3118 .redo = floppy_start,
3119 .error = generic_failure,
3120 .done = raw_cmd_done
3121};
3122
3123static int raw_cmd_copyout(int cmd, void __user *param,
3124 struct floppy_raw_cmd *ptr)
3125{
3126 int ret;
3127
3128 while (ptr) {
3129 struct floppy_raw_cmd cmd = *ptr;
3130 cmd.next = NULL;
3131 cmd.kernel_data = NULL;
3132 ret = copy_to_user(param, &cmd, sizeof(cmd));
3133 if (ret)
3134 return -EFAULT;
3135 param += sizeof(struct floppy_raw_cmd);
3136 if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
3137 if (ptr->length >= 0 &&
3138 ptr->length <= ptr->buffer_length) {
3139 long length = ptr->buffer_length - ptr->length;
3140 ret = fd_copyout(ptr->data, ptr->kernel_data,
3141 length);
3142 if (ret)
3143 return ret;
3144 }
3145 }
3146 ptr = ptr->next;
3147 }
3148
3149 return 0;
3150}
3151
3152static void raw_cmd_free(struct floppy_raw_cmd **ptr)
3153{
3154 struct floppy_raw_cmd *next;
3155 struct floppy_raw_cmd *this;
3156
3157 this = *ptr;
3158 *ptr = NULL;
3159 while (this) {
3160 if (this->buffer_length) {
3161 fd_dma_mem_free((unsigned long)this->kernel_data,
3162 this->buffer_length);
3163 this->buffer_length = 0;
3164 }
3165 next = this->next;
3166 kfree(this);
3167 this = next;
3168 }
3169}
3170
3171static int raw_cmd_copyin(int cmd, void __user *param,
3172 struct floppy_raw_cmd **rcmd)
3173{
3174 struct floppy_raw_cmd *ptr;
3175 int ret;
3176 int i;
3177
3178 *rcmd = NULL;
3179
3180loop:
3181 ptr = kmalloc(sizeof(struct floppy_raw_cmd), GFP_KERNEL);
3182 if (!ptr)
3183 return -ENOMEM;
3184 *rcmd = ptr;
3185 ret = copy_from_user(ptr, param, sizeof(*ptr));
3186 ptr->next = NULL;
3187 ptr->buffer_length = 0;
3188 ptr->kernel_data = NULL;
3189 if (ret)
3190 return -EFAULT;
3191 param += sizeof(struct floppy_raw_cmd);
3192 if (ptr->cmd_count > FD_RAW_CMD_FULLSIZE)
3193 return -EINVAL;
3194
3195 for (i = 0; i < FD_RAW_REPLY_SIZE; i++)
3196 ptr->reply[i] = 0;
3197 ptr->resultcode = 0;
3198
3199 if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
3200 if (ptr->length <= 0)
3201 return -EINVAL;
3202 ptr->kernel_data = (char *)fd_dma_mem_alloc(ptr->length);
3203 fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
3204 if (!ptr->kernel_data)
3205 return -ENOMEM;
3206 ptr->buffer_length = ptr->length;
3207 }
3208 if (ptr->flags & FD_RAW_WRITE) {
3209 ret = fd_copyin(ptr->data, ptr->kernel_data, ptr->length);
3210 if (ret)
3211 return ret;
3212 }
3213
3214 if (ptr->flags & FD_RAW_MORE) {
3215 rcmd = &(ptr->next);
3216 ptr->rate &= 0x43;
3217 goto loop;
3218 }
3219
3220 return 0;
3221}
3222
3223static int raw_cmd_ioctl(int cmd, void __user *param)
3224{
3225 struct floppy_raw_cmd *my_raw_cmd;
3226 int drive;
3227 int ret2;
3228 int ret;
3229
3230 if (fdc_state[current_fdc].rawcmd <= 1)
3231 fdc_state[current_fdc].rawcmd = 1;
3232 for (drive = 0; drive < N_DRIVE; drive++) {
3233 if (FDC(drive) != current_fdc)
3234 continue;
3235 if (drive == current_drive) {
3236 if (drive_state[drive].fd_ref > 1) {
3237 fdc_state[current_fdc].rawcmd = 2;
3238 break;
3239 }
3240 } else if (drive_state[drive].fd_ref) {
3241 fdc_state[current_fdc].rawcmd = 2;
3242 break;
3243 }
3244 }
3245
3246 if (fdc_state[current_fdc].reset)
3247 return -EIO;
3248
3249 ret = raw_cmd_copyin(cmd, param, &my_raw_cmd);
3250 if (ret) {
3251 raw_cmd_free(&my_raw_cmd);
3252 return ret;
3253 }
3254
3255 raw_cmd = my_raw_cmd;
3256 cont = &raw_cmd_cont;
3257 ret = wait_til_done(floppy_start, true);
3258 debug_dcl(drive_params[current_drive].flags,
3259 "calling disk change from raw_cmd ioctl\n");
3260
3261 if (ret != -EINTR && fdc_state[current_fdc].reset)
3262 ret = -EIO;
3263
3264 drive_state[current_drive].track = NO_TRACK;
3265
3266 ret2 = raw_cmd_copyout(cmd, param, my_raw_cmd);
3267 if (!ret)
3268 ret = ret2;
3269 raw_cmd_free(&my_raw_cmd);
3270 return ret;
3271}
3272
3273static int invalidate_drive(struct block_device *bdev)
3274{
3275
3276 set_bit((long)bdev->bd_disk->private_data, &fake_change);
3277 process_fd_request();
3278 check_disk_change(bdev);
3279 return 0;
3280}
3281
3282static int set_geometry(unsigned int cmd, struct floppy_struct *g,
3283 int drive, int type, struct block_device *bdev)
3284{
3285 int cnt;
3286
3287
3288 if ((int)g->sect <= 0 ||
3289 (int)g->head <= 0 ||
3290
3291 (int)(g->sect * g->head) <= 0 ||
3292
3293 (unsigned char)((g->sect << 2) >> FD_SIZECODE(g)) == 0 ||
3294 g->track <= 0 || g->track > drive_params[drive].tracks >> STRETCH(g) ||
3295
3296 (g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_SECTBASEMASK)) != 0)
3297 return -EINVAL;
3298 if (type) {
3299 if (!capable(CAP_SYS_ADMIN))
3300 return -EPERM;
3301 mutex_lock(&open_lock);
3302 if (lock_fdc(drive)) {
3303 mutex_unlock(&open_lock);
3304 return -EINTR;
3305 }
3306 floppy_type[type] = *g;
3307 floppy_type[type].name = "user format";
3308 for (cnt = type << 2; cnt < (type << 2) + 4; cnt++)
3309 floppy_sizes[cnt] = floppy_sizes[cnt + 0x80] =
3310 floppy_type[type].size + 1;
3311 process_fd_request();
3312 for (cnt = 0; cnt < N_DRIVE; cnt++) {
3313 struct block_device *bdev = opened_bdev[cnt];
3314 if (!bdev || ITYPE(drive_state[cnt].fd_device) != type)
3315 continue;
3316 __invalidate_device(bdev, true);
3317 }
3318 mutex_unlock(&open_lock);
3319 } else {
3320 int oldStretch;
3321
3322 if (lock_fdc(drive))
3323 return -EINTR;
3324 if (cmd != FDDEFPRM) {
3325
3326
3327 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
3328 return -EINTR;
3329 }
3330 oldStretch = g->stretch;
3331 user_params[drive] = *g;
3332 if (buffer_drive == drive)
3333 SUPBOUND(buffer_max, user_params[drive].sect);
3334 current_type[drive] = &user_params[drive];
3335 floppy_sizes[drive] = user_params[drive].size;
3336 if (cmd == FDDEFPRM)
3337 drive_state[current_drive].keep_data = -1;
3338 else
3339 drive_state[current_drive].keep_data = 1;
3340
3341
3342
3343
3344
3345 if (drive_state[current_drive].maxblock > user_params[drive].sect ||
3346 drive_state[current_drive].maxtrack ||
3347 ((user_params[drive].sect ^ oldStretch) &
3348 (FD_SWAPSIDES | FD_SECTBASEMASK)))
3349 invalidate_drive(bdev);
3350 else
3351 process_fd_request();
3352 }
3353 return 0;
3354}
3355
3356
3357static unsigned int ioctl_table[] = {
3358 FDCLRPRM,
3359 FDSETPRM,
3360 FDDEFPRM,
3361 FDGETPRM,
3362 FDMSGON,
3363 FDMSGOFF,
3364 FDFMTBEG,
3365 FDFMTTRK,
3366 FDFMTEND,
3367 FDSETEMSGTRESH,
3368 FDFLUSH,
3369 FDSETMAXERRS,
3370 FDGETMAXERRS,
3371 FDGETDRVTYP,
3372 FDSETDRVPRM,
3373 FDGETDRVPRM,
3374 FDGETDRVSTAT,
3375 FDPOLLDRVSTAT,
3376 FDRESET,
3377 FDGETFDCSTAT,
3378 FDWERRORCLR,
3379 FDWERRORGET,
3380 FDRAWCMD,
3381 FDEJECT,
3382 FDTWADDLE
3383};
3384
3385static int normalize_ioctl(unsigned int *cmd, int *size)
3386{
3387 int i;
3388
3389 for (i = 0; i < ARRAY_SIZE(ioctl_table); i++) {
3390 if ((*cmd & 0xffff) == (ioctl_table[i] & 0xffff)) {
3391 *size = _IOC_SIZE(*cmd);
3392 *cmd = ioctl_table[i];
3393 if (*size > _IOC_SIZE(*cmd)) {
3394 pr_info("ioctl not yet supported\n");
3395 return -EFAULT;
3396 }
3397 return 0;
3398 }
3399 }
3400 return -EINVAL;
3401}
3402
3403static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
3404{
3405 if (type)
3406 *g = &floppy_type[type];
3407 else {
3408 if (lock_fdc(drive))
3409 return -EINTR;
3410 if (poll_drive(false, 0) == -EINTR)
3411 return -EINTR;
3412 process_fd_request();
3413 *g = current_type[drive];
3414 }
3415 if (!*g)
3416 return -ENODEV;
3417 return 0;
3418}
3419
3420static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3421{
3422 int drive = (long)bdev->bd_disk->private_data;
3423 int type = ITYPE(drive_state[drive].fd_device);
3424 struct floppy_struct *g;
3425 int ret;
3426
3427 ret = get_floppy_geometry(drive, type, &g);
3428 if (ret)
3429 return ret;
3430
3431 geo->heads = g->head;
3432 geo->sectors = g->sect;
3433 geo->cylinders = g->track;
3434 return 0;
3435}
3436
3437static bool valid_floppy_drive_params(const short autodetect[FD_AUTODETECT_SIZE],
3438 int native_format)
3439{
3440 size_t floppy_type_size = ARRAY_SIZE(floppy_type);
3441 size_t i = 0;
3442
3443 for (i = 0; i < FD_AUTODETECT_SIZE; ++i) {
3444 if (autodetect[i] < 0 ||
3445 autodetect[i] >= floppy_type_size)
3446 return false;
3447 }
3448
3449 if (native_format < 0 || native_format >= floppy_type_size)
3450 return false;
3451
3452 return true;
3453}
3454
3455static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
3456 unsigned long param)
3457{
3458 int drive = (long)bdev->bd_disk->private_data;
3459 int type = ITYPE(drive_state[drive].fd_device);
3460 int i;
3461 int ret;
3462 int size;
3463 union inparam {
3464 struct floppy_struct g;
3465 struct format_descr f;
3466 struct floppy_max_errors max_errors;
3467 struct floppy_drive_params dp;
3468 } inparam;
3469 const void *outparam;
3470
3471
3472
3473
3474 if (cmd == CDROMEJECT ||
3475 cmd == 0x6470) {
3476 DPRINT("obsolete eject ioctl\n");
3477 DPRINT("please use floppycontrol --eject\n");
3478 cmd = FDEJECT;
3479 }
3480
3481 if (!((cmd & 0xff00) == 0x0200))
3482 return -EINVAL;
3483
3484
3485 ret = normalize_ioctl(&cmd, &size);
3486 if (ret)
3487 return ret;
3488
3489
3490 if (((cmd & 0x40) && !(mode & (FMODE_WRITE | FMODE_WRITE_IOCTL))) ||
3491 ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
3492 return -EPERM;
3493
3494 if (WARN_ON(size < 0 || size > sizeof(inparam)))
3495 return -EINVAL;
3496
3497
3498 memset(&inparam, 0, sizeof(inparam));
3499 if (_IOC_DIR(cmd) & _IOC_WRITE) {
3500 ret = fd_copyin((void __user *)param, &inparam, size);
3501 if (ret)
3502 return ret;
3503 }
3504
3505 switch (cmd) {
3506 case FDEJECT:
3507 if (drive_state[drive].fd_ref != 1)
3508
3509 return -EBUSY;
3510 if (lock_fdc(drive))
3511 return -EINTR;
3512
3513
3514
3515 ret = fd_eject(UNIT(drive));
3516
3517 set_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags);
3518 set_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
3519 process_fd_request();
3520 return ret;
3521 case FDCLRPRM:
3522 if (lock_fdc(drive))
3523 return -EINTR;
3524 current_type[drive] = NULL;
3525 floppy_sizes[drive] = MAX_DISK_SIZE << 1;
3526 drive_state[drive].keep_data = 0;
3527 return invalidate_drive(bdev);
3528 case FDSETPRM:
3529 case FDDEFPRM:
3530 return set_geometry(cmd, &inparam.g, drive, type, bdev);
3531 case FDGETPRM:
3532 ret = get_floppy_geometry(drive, type,
3533 (struct floppy_struct **)&outparam);
3534 if (ret)
3535 return ret;
3536 memcpy(&inparam.g, outparam,
3537 offsetof(struct floppy_struct, name));
3538 outparam = &inparam.g;
3539 break;
3540 case FDMSGON:
3541 drive_params[drive].flags |= FTD_MSG;
3542 return 0;
3543 case FDMSGOFF:
3544 drive_params[drive].flags &= ~FTD_MSG;
3545 return 0;
3546 case FDFMTBEG:
3547 if (lock_fdc(drive))
3548 return -EINTR;
3549 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
3550 return -EINTR;
3551 ret = drive_state[drive].flags;
3552 process_fd_request();
3553 if (ret & FD_VERIFY)
3554 return -ENODEV;
3555 if (!(ret & FD_DISK_WRITABLE))
3556 return -EROFS;
3557 return 0;
3558 case FDFMTTRK:
3559 if (drive_state[drive].fd_ref != 1)
3560 return -EBUSY;
3561 return do_format(drive, &inparam.f);
3562 case FDFMTEND:
3563 case FDFLUSH:
3564 if (lock_fdc(drive))
3565 return -EINTR;
3566 return invalidate_drive(bdev);
3567 case FDSETEMSGTRESH:
3568 drive_params[drive].max_errors.reporting = (unsigned short)(param & 0x0f);
3569 return 0;
3570 case FDGETMAXERRS:
3571 outparam = &drive_params[drive].max_errors;
3572 break;
3573 case FDSETMAXERRS:
3574 drive_params[drive].max_errors = inparam.max_errors;
3575 break;
3576 case FDGETDRVTYP:
3577 outparam = drive_name(type, drive);
3578 SUPBOUND(size, strlen((const char *)outparam) + 1);
3579 break;
3580 case FDSETDRVPRM:
3581 if (!valid_floppy_drive_params(inparam.dp.autodetect,
3582 inparam.dp.native_format))
3583 return -EINVAL;
3584 drive_params[drive] = inparam.dp;
3585 break;
3586 case FDGETDRVPRM:
3587 outparam = &drive_params[drive];
3588 break;
3589 case FDPOLLDRVSTAT:
3590 if (lock_fdc(drive))
3591 return -EINTR;
3592 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
3593 return -EINTR;
3594 process_fd_request();
3595 fallthrough;
3596 case FDGETDRVSTAT:
3597 outparam = &drive_state[drive];
3598 break;
3599 case FDRESET:
3600 return user_reset_fdc(drive, (int)param, true);
3601 case FDGETFDCSTAT:
3602 outparam = &fdc_state[FDC(drive)];
3603 break;
3604 case FDWERRORCLR:
3605 memset(&write_errors[drive], 0, sizeof(write_errors[drive]));
3606 return 0;
3607 case FDWERRORGET:
3608 outparam = &write_errors[drive];
3609 break;
3610 case FDRAWCMD:
3611 if (type)
3612 return -EINVAL;
3613 if (lock_fdc(drive))
3614 return -EINTR;
3615 set_floppy(drive);
3616 i = raw_cmd_ioctl(cmd, (void __user *)param);
3617 if (i == -EINTR)
3618 return -EINTR;
3619 process_fd_request();
3620 return i;
3621 case FDTWADDLE:
3622 if (lock_fdc(drive))
3623 return -EINTR;
3624 twaddle(current_fdc, current_drive);
3625 process_fd_request();
3626 return 0;
3627 default:
3628 return -EINVAL;
3629 }
3630
3631 if (_IOC_DIR(cmd) & _IOC_READ)
3632 return fd_copyout((void __user *)param, outparam, size);
3633
3634 return 0;
3635}
3636
3637static int fd_ioctl(struct block_device *bdev, fmode_t mode,
3638 unsigned int cmd, unsigned long param)
3639{
3640 int ret;
3641
3642 mutex_lock(&floppy_mutex);
3643 ret = fd_locked_ioctl(bdev, mode, cmd, param);
3644 mutex_unlock(&floppy_mutex);
3645
3646 return ret;
3647}
3648
3649#ifdef CONFIG_COMPAT
3650
3651struct compat_floppy_drive_params {
3652 char cmos;
3653 compat_ulong_t max_dtr;
3654 compat_ulong_t hlt;
3655 compat_ulong_t hut;
3656 compat_ulong_t srt;
3657 compat_ulong_t spinup;
3658 compat_ulong_t spindown;
3659 unsigned char spindown_offset;
3660 unsigned char select_delay;
3661 unsigned char rps;
3662 unsigned char tracks;
3663 compat_ulong_t timeout;
3664 unsigned char interleave_sect;
3665 struct floppy_max_errors max_errors;
3666 char flags;
3667 char read_track;
3668 short autodetect[FD_AUTODETECT_SIZE];
3669 compat_int_t checkfreq;
3670 compat_int_t native_format;
3671};
3672
3673struct compat_floppy_drive_struct {
3674 signed char flags;
3675 compat_ulong_t spinup_date;
3676 compat_ulong_t select_date;
3677 compat_ulong_t first_read_date;
3678 short probed_format;
3679 short track;
3680 short maxblock;
3681 short maxtrack;
3682 compat_int_t generation;
3683 compat_int_t keep_data;
3684 compat_int_t fd_ref;
3685 compat_int_t fd_device;
3686 compat_int_t last_checked;
3687 compat_caddr_t dmabuf;
3688 compat_int_t bufblocks;
3689};
3690
3691struct compat_floppy_fdc_state {
3692 compat_int_t spec1;
3693 compat_int_t spec2;
3694 compat_int_t dtr;
3695 unsigned char version;
3696 unsigned char dor;
3697 compat_ulong_t address;
3698 unsigned int rawcmd:2;
3699 unsigned int reset:1;
3700 unsigned int need_configure:1;
3701 unsigned int perp_mode:2;
3702 unsigned int has_fifo:1;
3703 unsigned int driver_version;
3704 unsigned char track[4];
3705};
3706
3707struct compat_floppy_write_errors {
3708 unsigned int write_errors;
3709 compat_ulong_t first_error_sector;
3710 compat_int_t first_error_generation;
3711 compat_ulong_t last_error_sector;
3712 compat_int_t last_error_generation;
3713 compat_uint_t badness;
3714};
3715
3716#define FDSETPRM32 _IOW(2, 0x42, struct compat_floppy_struct)
3717#define FDDEFPRM32 _IOW(2, 0x43, struct compat_floppy_struct)
3718#define FDSETDRVPRM32 _IOW(2, 0x90, struct compat_floppy_drive_params)
3719#define FDGETDRVPRM32 _IOR(2, 0x11, struct compat_floppy_drive_params)
3720#define FDGETDRVSTAT32 _IOR(2, 0x12, struct compat_floppy_drive_struct)
3721#define FDPOLLDRVSTAT32 _IOR(2, 0x13, struct compat_floppy_drive_struct)
3722#define FDGETFDCSTAT32 _IOR(2, 0x15, struct compat_floppy_fdc_state)
3723#define FDWERRORGET32 _IOR(2, 0x17, struct compat_floppy_write_errors)
3724
3725static int compat_set_geometry(struct block_device *bdev, fmode_t mode, unsigned int cmd,
3726 struct compat_floppy_struct __user *arg)
3727{
3728 struct floppy_struct v;
3729 int drive, type;
3730 int err;
3731
3732 BUILD_BUG_ON(offsetof(struct floppy_struct, name) !=
3733 offsetof(struct compat_floppy_struct, name));
3734
3735 if (!(mode & (FMODE_WRITE | FMODE_WRITE_IOCTL)))
3736 return -EPERM;
3737
3738 memset(&v, 0, sizeof(struct floppy_struct));
3739 if (copy_from_user(&v, arg, offsetof(struct floppy_struct, name)))
3740 return -EFAULT;
3741
3742 mutex_lock(&floppy_mutex);
3743 drive = (long)bdev->bd_disk->private_data;
3744 type = ITYPE(drive_state[drive].fd_device);
3745 err = set_geometry(cmd == FDSETPRM32 ? FDSETPRM : FDDEFPRM,
3746 &v, drive, type, bdev);
3747 mutex_unlock(&floppy_mutex);
3748 return err;
3749}
3750
3751static int compat_get_prm(int drive,
3752 struct compat_floppy_struct __user *arg)
3753{
3754 struct compat_floppy_struct v;
3755 struct floppy_struct *p;
3756 int err;
3757
3758 memset(&v, 0, sizeof(v));
3759 mutex_lock(&floppy_mutex);
3760 err = get_floppy_geometry(drive, ITYPE(drive_state[drive].fd_device),
3761 &p);
3762 if (err) {
3763 mutex_unlock(&floppy_mutex);
3764 return err;
3765 }
3766 memcpy(&v, p, offsetof(struct floppy_struct, name));
3767 mutex_unlock(&floppy_mutex);
3768 if (copy_to_user(arg, &v, sizeof(struct compat_floppy_struct)))
3769 return -EFAULT;
3770 return 0;
3771}
3772
3773static int compat_setdrvprm(int drive,
3774 struct compat_floppy_drive_params __user *arg)
3775{
3776 struct compat_floppy_drive_params v;
3777
3778 if (!capable(CAP_SYS_ADMIN))
3779 return -EPERM;
3780 if (copy_from_user(&v, arg, sizeof(struct compat_floppy_drive_params)))
3781 return -EFAULT;
3782 if (!valid_floppy_drive_params(v.autodetect, v.native_format))
3783 return -EINVAL;
3784 mutex_lock(&floppy_mutex);
3785 drive_params[drive].cmos = v.cmos;
3786 drive_params[drive].max_dtr = v.max_dtr;
3787 drive_params[drive].hlt = v.hlt;
3788 drive_params[drive].hut = v.hut;
3789 drive_params[drive].srt = v.srt;
3790 drive_params[drive].spinup = v.spinup;
3791 drive_params[drive].spindown = v.spindown;
3792 drive_params[drive].spindown_offset = v.spindown_offset;
3793 drive_params[drive].select_delay = v.select_delay;
3794 drive_params[drive].rps = v.rps;
3795 drive_params[drive].tracks = v.tracks;
3796 drive_params[drive].timeout = v.timeout;
3797 drive_params[drive].interleave_sect = v.interleave_sect;
3798 drive_params[drive].max_errors = v.max_errors;
3799 drive_params[drive].flags = v.flags;
3800 drive_params[drive].read_track = v.read_track;
3801 memcpy(drive_params[drive].autodetect, v.autodetect,
3802 sizeof(v.autodetect));
3803 drive_params[drive].checkfreq = v.checkfreq;
3804 drive_params[drive].native_format = v.native_format;
3805 mutex_unlock(&floppy_mutex);
3806 return 0;
3807}
3808
3809static int compat_getdrvprm(int drive,
3810 struct compat_floppy_drive_params __user *arg)
3811{
3812 struct compat_floppy_drive_params v;
3813
3814 memset(&v, 0, sizeof(struct compat_floppy_drive_params));
3815 mutex_lock(&floppy_mutex);
3816 v.cmos = drive_params[drive].cmos;
3817 v.max_dtr = drive_params[drive].max_dtr;
3818 v.hlt = drive_params[drive].hlt;
3819 v.hut = drive_params[drive].hut;
3820 v.srt = drive_params[drive].srt;
3821 v.spinup = drive_params[drive].spinup;
3822 v.spindown = drive_params[drive].spindown;
3823 v.spindown_offset = drive_params[drive].spindown_offset;
3824 v.select_delay = drive_params[drive].select_delay;
3825 v.rps = drive_params[drive].rps;
3826 v.tracks = drive_params[drive].tracks;
3827 v.timeout = drive_params[drive].timeout;
3828 v.interleave_sect = drive_params[drive].interleave_sect;
3829 v.max_errors = drive_params[drive].max_errors;
3830 v.flags = drive_params[drive].flags;
3831 v.read_track = drive_params[drive].read_track;
3832 memcpy(v.autodetect, drive_params[drive].autodetect,
3833 sizeof(v.autodetect));
3834 v.checkfreq = drive_params[drive].checkfreq;
3835 v.native_format = drive_params[drive].native_format;
3836 mutex_unlock(&floppy_mutex);
3837
3838 if (copy_to_user(arg, &v, sizeof(struct compat_floppy_drive_params)))
3839 return -EFAULT;
3840 return 0;
3841}
3842
3843static int compat_getdrvstat(int drive, bool poll,
3844 struct compat_floppy_drive_struct __user *arg)
3845{
3846 struct compat_floppy_drive_struct v;
3847
3848 memset(&v, 0, sizeof(struct compat_floppy_drive_struct));
3849 mutex_lock(&floppy_mutex);
3850
3851 if (poll) {
3852 if (lock_fdc(drive))
3853 goto Eintr;
3854 if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
3855 goto Eintr;
3856 process_fd_request();
3857 }
3858 v.spinup_date = drive_state[drive].spinup_date;
3859 v.select_date = drive_state[drive].select_date;
3860 v.first_read_date = drive_state[drive].first_read_date;
3861 v.probed_format = drive_state[drive].probed_format;
3862 v.track = drive_state[drive].track;
3863 v.maxblock = drive_state[drive].maxblock;
3864 v.maxtrack = drive_state[drive].maxtrack;
3865 v.generation = drive_state[drive].generation;
3866 v.keep_data = drive_state[drive].keep_data;
3867 v.fd_ref = drive_state[drive].fd_ref;
3868 v.fd_device = drive_state[drive].fd_device;
3869 v.last_checked = drive_state[drive].last_checked;
3870 v.dmabuf = (uintptr_t) drive_state[drive].dmabuf;
3871 v.bufblocks = drive_state[drive].bufblocks;
3872 mutex_unlock(&floppy_mutex);
3873
3874 if (copy_to_user(arg, &v, sizeof(struct compat_floppy_drive_struct)))
3875 return -EFAULT;
3876 return 0;
3877Eintr:
3878 mutex_unlock(&floppy_mutex);
3879 return -EINTR;
3880}
3881
3882static int compat_getfdcstat(int drive,
3883 struct compat_floppy_fdc_state __user *arg)
3884{
3885 struct compat_floppy_fdc_state v32;
3886 struct floppy_fdc_state v;
3887
3888 mutex_lock(&floppy_mutex);
3889 v = fdc_state[FDC(drive)];
3890 mutex_unlock(&floppy_mutex);
3891
3892 memset(&v32, 0, sizeof(struct compat_floppy_fdc_state));
3893 v32.spec1 = v.spec1;
3894 v32.spec2 = v.spec2;
3895 v32.dtr = v.dtr;
3896 v32.version = v.version;
3897 v32.dor = v.dor;
3898 v32.address = v.address;
3899 v32.rawcmd = v.rawcmd;
3900 v32.reset = v.reset;
3901 v32.need_configure = v.need_configure;
3902 v32.perp_mode = v.perp_mode;
3903 v32.has_fifo = v.has_fifo;
3904 v32.driver_version = v.driver_version;
3905 memcpy(v32.track, v.track, 4);
3906 if (copy_to_user(arg, &v32, sizeof(struct compat_floppy_fdc_state)))
3907 return -EFAULT;
3908 return 0;
3909}
3910
3911static int compat_werrorget(int drive,
3912 struct compat_floppy_write_errors __user *arg)
3913{
3914 struct compat_floppy_write_errors v32;
3915 struct floppy_write_errors v;
3916
3917 memset(&v32, 0, sizeof(struct compat_floppy_write_errors));
3918 mutex_lock(&floppy_mutex);
3919 v = write_errors[drive];
3920 mutex_unlock(&floppy_mutex);
3921 v32.write_errors = v.write_errors;
3922 v32.first_error_sector = v.first_error_sector;
3923 v32.first_error_generation = v.first_error_generation;
3924 v32.last_error_sector = v.last_error_sector;
3925 v32.last_error_generation = v.last_error_generation;
3926 v32.badness = v.badness;
3927 if (copy_to_user(arg, &v32, sizeof(struct compat_floppy_write_errors)))
3928 return -EFAULT;
3929 return 0;
3930}
3931
3932static int fd_compat_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
3933 unsigned long param)
3934{
3935 int drive = (long)bdev->bd_disk->private_data;
3936 switch (cmd) {
3937 case CDROMEJECT:
3938 case 0x6470:
3939
3940 case FDMSGON:
3941 case FDMSGOFF:
3942 case FDSETEMSGTRESH:
3943 case FDFLUSH:
3944 case FDWERRORCLR:
3945 case FDEJECT:
3946 case FDCLRPRM:
3947 case FDFMTBEG:
3948 case FDRESET:
3949 case FDTWADDLE:
3950 return fd_ioctl(bdev, mode, cmd, param);
3951 case FDSETMAXERRS:
3952 case FDGETMAXERRS:
3953 case FDGETDRVTYP:
3954 case FDFMTEND:
3955 case FDFMTTRK:
3956 case FDRAWCMD:
3957 return fd_ioctl(bdev, mode, cmd,
3958 (unsigned long)compat_ptr(param));
3959 case FDSETPRM32:
3960 case FDDEFPRM32:
3961 return compat_set_geometry(bdev, mode, cmd, compat_ptr(param));
3962 case FDGETPRM32:
3963 return compat_get_prm(drive, compat_ptr(param));
3964 case FDSETDRVPRM32:
3965 return compat_setdrvprm(drive, compat_ptr(param));
3966 case FDGETDRVPRM32:
3967 return compat_getdrvprm(drive, compat_ptr(param));
3968 case FDPOLLDRVSTAT32:
3969 return compat_getdrvstat(drive, true, compat_ptr(param));
3970 case FDGETDRVSTAT32:
3971 return compat_getdrvstat(drive, false, compat_ptr(param));
3972 case FDGETFDCSTAT32:
3973 return compat_getfdcstat(drive, compat_ptr(param));
3974 case FDWERRORGET32:
3975 return compat_werrorget(drive, compat_ptr(param));
3976 }
3977 return -EINVAL;
3978}
3979#endif
3980
3981static void __init config_types(void)
3982{
3983 bool has_drive = false;
3984 int drive;
3985
3986
3987 drive = 0;
3988 if (!drive_params[drive].cmos)
3989 drive_params[drive].cmos = FLOPPY0_TYPE;
3990 drive = 1;
3991 if (!drive_params[drive].cmos)
3992 drive_params[drive].cmos = FLOPPY1_TYPE;
3993
3994
3995
3996 for (drive = 0; drive < N_DRIVE; drive++) {
3997 unsigned int type = drive_params[drive].cmos;
3998 struct floppy_drive_params *params;
3999 const char *name = NULL;
4000 char temparea[32];
4001
4002 if (type < ARRAY_SIZE(default_drive_params)) {
4003 params = &default_drive_params[type].params;
4004 if (type) {
4005 name = default_drive_params[type].name;
4006 allowed_drive_mask |= 1 << drive;
4007 } else
4008 allowed_drive_mask &= ~(1 << drive);
4009 } else {
4010 params = &default_drive_params[0].params;
4011 snprintf(temparea, sizeof(temparea),
4012 "unknown type %d (usb?)", type);
4013 name = temparea;
4014 }
4015 if (name) {
4016 const char *prepend;
4017 if (!has_drive) {
4018 prepend = "";
4019 has_drive = true;
4020 pr_info("Floppy drive(s):");
4021 } else {
4022 prepend = ",";
4023 }
4024
4025 pr_cont("%s fd%d is %s", prepend, drive, name);
4026 }
4027 drive_params[drive] = *params;
4028 }
4029
4030 if (has_drive)
4031 pr_cont("\n");
4032}
4033
4034static void floppy_release(struct gendisk *disk, fmode_t mode)
4035{
4036 int drive = (long)disk->private_data;
4037
4038 mutex_lock(&floppy_mutex);
4039 mutex_lock(&open_lock);
4040 if (!drive_state[drive].fd_ref--) {
4041 DPRINT("floppy_release with fd_ref == 0");
4042 drive_state[drive].fd_ref = 0;
4043 }
4044 if (!drive_state[drive].fd_ref)
4045 opened_bdev[drive] = NULL;
4046 mutex_unlock(&open_lock);
4047 mutex_unlock(&floppy_mutex);
4048}
4049
4050
4051
4052
4053
4054
4055static int floppy_open(struct block_device *bdev, fmode_t mode)
4056{
4057 int drive = (long)bdev->bd_disk->private_data;
4058 int old_dev, new_dev;
4059 int try;
4060 int res = -EBUSY;
4061 char *tmp;
4062
4063 mutex_lock(&floppy_mutex);
4064 mutex_lock(&open_lock);
4065 old_dev = drive_state[drive].fd_device;
4066 if (opened_bdev[drive] && opened_bdev[drive] != bdev)
4067 goto out2;
4068
4069 if (!drive_state[drive].fd_ref && (drive_params[drive].flags & FD_BROKEN_DCL)) {
4070 set_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags);
4071 set_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
4072 }
4073
4074 drive_state[drive].fd_ref++;
4075
4076 opened_bdev[drive] = bdev;
4077
4078 res = -ENXIO;
4079
4080 if (!floppy_track_buffer) {
4081
4082
4083 if ((drive_params[drive].cmos == 6) || (drive_params[drive].cmos == 5))
4084 try = 64;
4085 else
4086 try = 32;
4087
4088 tmp = (char *)fd_dma_mem_alloc(1024 * try);
4089 if (!tmp && !floppy_track_buffer) {
4090 try >>= 1;
4091 INFBOUND(try, 16);
4092 tmp = (char *)fd_dma_mem_alloc(1024 * try);
4093 }
4094 if (!tmp && !floppy_track_buffer)
4095 fallback_on_nodma_alloc(&tmp, 2048 * try);
4096 if (!tmp && !floppy_track_buffer) {
4097 DPRINT("Unable to allocate DMA memory\n");
4098 goto out;
4099 }
4100 if (floppy_track_buffer) {
4101 if (tmp)
4102 fd_dma_mem_free((unsigned long)tmp, try * 1024);
4103 } else {
4104 buffer_min = buffer_max = -1;
4105 floppy_track_buffer = tmp;
4106 max_buffer_sectors = try;
4107 }
4108 }
4109
4110 new_dev = MINOR(bdev->bd_dev);
4111 drive_state[drive].fd_device = new_dev;
4112 set_capacity(disks[drive], floppy_sizes[new_dev]);
4113 if (old_dev != -1 && old_dev != new_dev) {
4114 if (buffer_drive == drive)
4115 buffer_track = -1;
4116 }
4117
4118 if (fdc_state[FDC(drive)].rawcmd == 1)
4119 fdc_state[FDC(drive)].rawcmd = 2;
4120
4121 if (!(mode & FMODE_NDELAY)) {
4122 if (mode & (FMODE_READ|FMODE_WRITE)) {
4123 drive_state[drive].last_checked = 0;
4124 clear_bit(FD_OPEN_SHOULD_FAIL_BIT,
4125 &drive_state[drive].flags);
4126 check_disk_change(bdev);
4127 if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags))
4128 goto out;
4129 if (test_bit(FD_OPEN_SHOULD_FAIL_BIT, &drive_state[drive].flags))
4130 goto out;
4131 }
4132 res = -EROFS;
4133 if ((mode & FMODE_WRITE) &&
4134 !test_bit(FD_DISK_WRITABLE_BIT, &drive_state[drive].flags))
4135 goto out;
4136 }
4137 mutex_unlock(&open_lock);
4138 mutex_unlock(&floppy_mutex);
4139 return 0;
4140out:
4141 drive_state[drive].fd_ref--;
4142
4143 if (!drive_state[drive].fd_ref)
4144 opened_bdev[drive] = NULL;
4145out2:
4146 mutex_unlock(&open_lock);
4147 mutex_unlock(&floppy_mutex);
4148 return res;
4149}
4150
4151
4152
4153
4154static unsigned int floppy_check_events(struct gendisk *disk,
4155 unsigned int clearing)
4156{
4157 int drive = (long)disk->private_data;
4158
4159 if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4160 test_bit(FD_VERIFY_BIT, &drive_state[drive].flags))
4161 return DISK_EVENT_MEDIA_CHANGE;
4162
4163 if (time_after(jiffies, drive_state[drive].last_checked + drive_params[drive].checkfreq)) {
4164 if (lock_fdc(drive))
4165 return 0;
4166 poll_drive(false, 0);
4167 process_fd_request();
4168 }
4169
4170 if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4171 test_bit(FD_VERIFY_BIT, &drive_state[drive].flags) ||
4172 test_bit(drive, &fake_change) ||
4173 drive_no_geom(drive))
4174 return DISK_EVENT_MEDIA_CHANGE;
4175 return 0;
4176}
4177
4178
4179
4180
4181
4182
4183
4184struct rb0_cbdata {
4185 int drive;
4186 struct completion complete;
4187};
4188
4189static void floppy_rb0_cb(struct bio *bio)
4190{
4191 struct rb0_cbdata *cbdata = (struct rb0_cbdata *)bio->bi_private;
4192 int drive = cbdata->drive;
4193
4194 if (bio->bi_status) {
4195 pr_info("floppy: error %d while reading block 0\n",
4196 bio->bi_status);
4197 set_bit(FD_OPEN_SHOULD_FAIL_BIT, &drive_state[drive].flags);
4198 }
4199 complete(&cbdata->complete);
4200}
4201
4202static int __floppy_read_block_0(struct block_device *bdev, int drive)
4203{
4204 struct bio bio;
4205 struct bio_vec bio_vec;
4206 struct page *page;
4207 struct rb0_cbdata cbdata;
4208
4209 page = alloc_page(GFP_NOIO);
4210 if (!page) {
4211 process_fd_request();
4212 return -ENOMEM;
4213 }
4214
4215 cbdata.drive = drive;
4216
4217 bio_init(&bio, &bio_vec, 1);
4218 bio_set_dev(&bio, bdev);
4219 bio_add_page(&bio, page, block_size(bdev), 0);
4220
4221 bio.bi_iter.bi_sector = 0;
4222 bio.bi_flags |= (1 << BIO_QUIET);
4223 bio.bi_private = &cbdata;
4224 bio.bi_end_io = floppy_rb0_cb;
4225 bio_set_op_attrs(&bio, REQ_OP_READ, 0);
4226
4227 init_completion(&cbdata.complete);
4228
4229 submit_bio(&bio);
4230 process_fd_request();
4231
4232 wait_for_completion(&cbdata.complete);
4233
4234 __free_page(page);
4235
4236 return 0;
4237}
4238
4239
4240
4241
4242
4243static int floppy_revalidate(struct gendisk *disk)
4244{
4245 int drive = (long)disk->private_data;
4246 int cf;
4247 int res = 0;
4248
4249 if (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4250 test_bit(FD_VERIFY_BIT, &drive_state[drive].flags) ||
4251 test_bit(drive, &fake_change) ||
4252 drive_no_geom(drive)) {
4253 if (WARN(atomic_read(&usage_count) == 0,
4254 "VFS: revalidate called on non-open device.\n"))
4255 return -EFAULT;
4256
4257 res = lock_fdc(drive);
4258 if (res)
4259 return res;
4260 cf = (test_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags) ||
4261 test_bit(FD_VERIFY_BIT, &drive_state[drive].flags));
4262 if (!(cf || test_bit(drive, &fake_change) || drive_no_geom(drive))) {
4263 process_fd_request();
4264 return 0;
4265 }
4266 drive_state[drive].maxblock = 0;
4267 drive_state[drive].maxtrack = 0;
4268 if (buffer_drive == drive)
4269 buffer_track = -1;
4270 clear_bit(drive, &fake_change);
4271 clear_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags);
4272 if (cf)
4273 drive_state[drive].generation++;
4274 if (drive_no_geom(drive)) {
4275
4276 res = __floppy_read_block_0(opened_bdev[drive], drive);
4277 } else {
4278 if (cf)
4279 poll_drive(false, FD_RAW_NEED_DISK);
4280 process_fd_request();
4281 }
4282 }
4283 set_capacity(disk, floppy_sizes[drive_state[drive].fd_device]);
4284 return res;
4285}
4286
4287static const struct block_device_operations floppy_fops = {
4288 .owner = THIS_MODULE,
4289 .open = floppy_open,
4290 .release = floppy_release,
4291 .ioctl = fd_ioctl,
4292 .getgeo = fd_getgeo,
4293 .check_events = floppy_check_events,
4294 .revalidate_disk = floppy_revalidate,
4295#ifdef CONFIG_COMPAT
4296 .compat_ioctl = fd_compat_ioctl,
4297#endif
4298};
4299
4300
4301
4302
4303
4304
4305
4306
4307static char __init get_fdc_version(int fdc)
4308{
4309 int r;
4310
4311 output_byte(fdc, FD_DUMPREGS);
4312 if (fdc_state[fdc].reset)
4313 return FDC_NONE;
4314 r = result(fdc);
4315 if (r <= 0x00)
4316 return FDC_NONE;
4317 if ((r == 1) && (reply_buffer[0] == 0x80)) {
4318 pr_info("FDC %d is an 8272A\n", fdc);
4319 return FDC_8272A;
4320 }
4321 if (r != 10) {
4322 pr_info("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
4323 fdc, r);
4324 return FDC_UNKNOWN;
4325 }
4326
4327 if (!fdc_configure(fdc)) {
4328 pr_info("FDC %d is an 82072\n", fdc);
4329 return FDC_82072;
4330 }
4331
4332 output_byte(fdc, FD_PERPENDICULAR);
4333 if (need_more_output(fdc) == MORE_OUTPUT) {
4334 output_byte(fdc, 0);
4335 } else {
4336 pr_info("FDC %d is an 82072A\n", fdc);
4337 return FDC_82072A;
4338 }
4339
4340 output_byte(fdc, FD_UNLOCK);
4341 r = result(fdc);
4342 if ((r == 1) && (reply_buffer[0] == 0x80)) {
4343 pr_info("FDC %d is a pre-1991 82077\n", fdc);
4344 return FDC_82077_ORIG;
4345
4346 }
4347 if ((r != 1) || (reply_buffer[0] != 0x00)) {
4348 pr_info("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
4349 fdc, r);
4350 return FDC_UNKNOWN;
4351 }
4352 output_byte(fdc, FD_PARTID);
4353 r = result(fdc);
4354 if (r != 1) {
4355 pr_info("FDC %d init: PARTID: unexpected return of %d bytes.\n",
4356 fdc, r);
4357 return FDC_UNKNOWN;
4358 }
4359 if (reply_buffer[0] == 0x80) {
4360 pr_info("FDC %d is a post-1991 82077\n", fdc);
4361 return FDC_82077;
4362 }
4363 switch (reply_buffer[0] >> 5) {
4364 case 0x0:
4365
4366 pr_info("FDC %d is an 82078.\n", fdc);
4367 return FDC_82078;
4368 case 0x1:
4369 pr_info("FDC %d is a 44pin 82078\n", fdc);
4370 return FDC_82078;
4371 case 0x2:
4372 pr_info("FDC %d is a S82078B\n", fdc);
4373 return FDC_S82078B;
4374 case 0x3:
4375 pr_info("FDC %d is a National Semiconductor PC87306\n", fdc);
4376 return FDC_87306;
4377 default:
4378 pr_info("FDC %d init: 82078 variant with unknown PARTID=%d.\n",
4379 fdc, reply_buffer[0] >> 5);
4380 return FDC_82078_UNKN;
4381 }
4382}
4383
4384
4385
4386static void __init floppy_set_flags(int *ints, int param, int param2)
4387{
4388 int i;
4389
4390 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4391 if (param)
4392 default_drive_params[i].params.flags |= param2;
4393 else
4394 default_drive_params[i].params.flags &= ~param2;
4395 }
4396 DPRINT("%s flag 0x%x\n", param2 ? "Setting" : "Clearing", param);
4397}
4398
4399static void __init daring(int *ints, int param, int param2)
4400{
4401 int i;
4402
4403 for (i = 0; i < ARRAY_SIZE(default_drive_params); i++) {
4404 if (param) {
4405 default_drive_params[i].params.select_delay = 0;
4406 default_drive_params[i].params.flags |=
4407 FD_SILENT_DCL_CLEAR;
4408 } else {
4409 default_drive_params[i].params.select_delay =
4410 2 * HZ / 100;
4411 default_drive_params[i].params.flags &=
4412 ~FD_SILENT_DCL_CLEAR;
4413 }
4414 }
4415 DPRINT("Assuming %s floppy hardware\n", param ? "standard" : "broken");
4416}
4417
4418static void __init set_cmos(int *ints, int dummy, int dummy2)
4419{
4420 int current_drive = 0;
4421
4422 if (ints[0] != 2) {
4423 DPRINT("wrong number of parameters for CMOS\n");
4424 return;
4425 }
4426 current_drive = ints[1];
4427 if (current_drive < 0 || current_drive >= 8) {
4428 DPRINT("bad drive for set_cmos\n");
4429 return;
4430 }
4431#if N_FDC > 1
4432 if (current_drive >= 4 && !FDC2)
4433 FDC2 = 0x370;
4434#endif
4435 drive_params[current_drive].cmos = ints[2];
4436 DPRINT("setting CMOS code to %d\n", ints[2]);
4437}
4438
4439static struct param_table {
4440 const char *name;
4441 void (*fn) (int *ints, int param, int param2);
4442 int *var;
4443 int def_param;
4444 int param2;
4445} config_params[] __initdata = {
4446 {"allowed_drive_mask", NULL, &allowed_drive_mask, 0xff, 0},
4447 {"all_drives", NULL, &allowed_drive_mask, 0xff, 0},
4448 {"asus_pci", NULL, &allowed_drive_mask, 0x33, 0},
4449 {"irq", NULL, &FLOPPY_IRQ, 6, 0},
4450 {"dma", NULL, &FLOPPY_DMA, 2, 0},
4451 {"daring", daring, NULL, 1, 0},
4452#if N_FDC > 1
4453 {"two_fdc", NULL, &FDC2, 0x370, 0},
4454 {"one_fdc", NULL, &FDC2, 0, 0},
4455#endif
4456 {"thinkpad", floppy_set_flags, NULL, 1, FD_INVERTED_DCL},
4457 {"broken_dcl", floppy_set_flags, NULL, 1, FD_BROKEN_DCL},
4458 {"messages", floppy_set_flags, NULL, 1, FTD_MSG},
4459 {"silent_dcl_clear", floppy_set_flags, NULL, 1, FD_SILENT_DCL_CLEAR},
4460 {"debug", floppy_set_flags, NULL, 1, FD_DEBUG},
4461 {"nodma", NULL, &can_use_virtual_dma, 1, 0},
4462 {"omnibook", NULL, &can_use_virtual_dma, 1, 0},
4463 {"yesdma", NULL, &can_use_virtual_dma, 0, 0},
4464 {"fifo_depth", NULL, &fifo_depth, 0xa, 0},
4465 {"nofifo", NULL, &no_fifo, 0x20, 0},
4466 {"usefifo", NULL, &no_fifo, 0, 0},
4467 {"cmos", set_cmos, NULL, 0, 0},
4468 {"slow", NULL, &slow_floppy, 1, 0},
4469 {"unexpected_interrupts", NULL, &print_unex, 1, 0},
4470 {"no_unexpected_interrupts", NULL, &print_unex, 0, 0},
4471 {"L40SX", NULL, &print_unex, 0, 0}
4472
4473 EXTRA_FLOPPY_PARAMS
4474};
4475
4476static int __init floppy_setup(char *str)
4477{
4478 int i;
4479 int param;
4480 int ints[11];
4481
4482 str = get_options(str, ARRAY_SIZE(ints), ints);
4483 if (str) {
4484 for (i = 0; i < ARRAY_SIZE(config_params); i++) {
4485 if (strcmp(str, config_params[i].name) == 0) {
4486 if (ints[0])
4487 param = ints[1];
4488 else
4489 param = config_params[i].def_param;
4490 if (config_params[i].fn)
4491 config_params[i].fn(ints, param,
4492 config_params[i].
4493 param2);
4494 if (config_params[i].var) {
4495 DPRINT("%s=%d\n", str, param);
4496 *config_params[i].var = param;
4497 }
4498 return 1;
4499 }
4500 }
4501 }
4502 if (str) {
4503 DPRINT("unknown floppy option [%s]\n", str);
4504
4505 DPRINT("allowed options are:");
4506 for (i = 0; i < ARRAY_SIZE(config_params); i++)
4507 pr_cont(" %s", config_params[i].name);
4508 pr_cont("\n");
4509 } else
4510 DPRINT("botched floppy option\n");
4511 DPRINT("Read Documentation/admin-guide/blockdev/floppy.rst\n");
4512 return 0;
4513}
4514
4515static int have_no_fdc = -ENODEV;
4516
4517static ssize_t floppy_cmos_show(struct device *dev,
4518 struct device_attribute *attr, char *buf)
4519{
4520 struct platform_device *p = to_platform_device(dev);
4521 int drive;
4522
4523 drive = p->id;
4524 return sprintf(buf, "%X\n", drive_params[drive].cmos);
4525}
4526
4527static DEVICE_ATTR(cmos, 0444, floppy_cmos_show, NULL);
4528
4529static struct attribute *floppy_dev_attrs[] = {
4530 &dev_attr_cmos.attr,
4531 NULL
4532};
4533
4534ATTRIBUTE_GROUPS(floppy_dev);
4535
4536static void floppy_device_release(struct device *dev)
4537{
4538}
4539
4540static int floppy_resume(struct device *dev)
4541{
4542 int fdc;
4543 int saved_drive;
4544
4545 saved_drive = current_drive;
4546 for (fdc = 0; fdc < N_FDC; fdc++)
4547 if (fdc_state[fdc].address != -1)
4548 user_reset_fdc(REVDRIVE(fdc, 0), FD_RESET_ALWAYS, false);
4549 set_fdc(saved_drive);
4550 return 0;
4551}
4552
4553static const struct dev_pm_ops floppy_pm_ops = {
4554 .resume = floppy_resume,
4555 .restore = floppy_resume,
4556};
4557
4558static struct platform_driver floppy_driver = {
4559 .driver = {
4560 .name = "floppy",
4561 .pm = &floppy_pm_ops,
4562 },
4563};
4564
4565static const struct blk_mq_ops floppy_mq_ops = {
4566 .queue_rq = floppy_queue_rq,
4567};
4568
4569static struct platform_device floppy_device[N_DRIVE];
4570
4571static bool floppy_available(int drive)
4572{
4573 if (!(allowed_drive_mask & (1 << drive)))
4574 return false;
4575 if (fdc_state[FDC(drive)].version == FDC_NONE)
4576 return false;
4577 return true;
4578}
4579
4580static struct kobject *floppy_find(dev_t dev, int *part, void *data)
4581{
4582 int drive = (*part & 3) | ((*part & 0x80) >> 5);
4583 if (drive >= N_DRIVE || !floppy_available(drive))
4584 return NULL;
4585 if (((*part >> 2) & 0x1f) >= ARRAY_SIZE(floppy_type))
4586 return NULL;
4587 *part = 0;
4588 return get_disk_and_module(disks[drive]);
4589}
4590
4591static int __init do_floppy_init(void)
4592{
4593 int i, unit, drive, err;
4594
4595 set_debugt();
4596 interruptjiffies = resultjiffies = jiffies;
4597
4598#if defined(CONFIG_PPC)
4599 if (check_legacy_ioport(FDC1))
4600 return -ENODEV;
4601#endif
4602
4603 raw_cmd = NULL;
4604
4605 floppy_wq = alloc_ordered_workqueue("floppy", 0);
4606 if (!floppy_wq)
4607 return -ENOMEM;
4608
4609 for (drive = 0; drive < N_DRIVE; drive++) {
4610 disks[drive] = alloc_disk(1);
4611 if (!disks[drive]) {
4612 err = -ENOMEM;
4613 goto out_put_disk;
4614 }
4615
4616 disks[drive]->queue = blk_mq_init_sq_queue(&tag_sets[drive],
4617 &floppy_mq_ops, 2,
4618 BLK_MQ_F_SHOULD_MERGE);
4619 if (IS_ERR(disks[drive]->queue)) {
4620 err = PTR_ERR(disks[drive]->queue);
4621 disks[drive]->queue = NULL;
4622 goto out_put_disk;
4623 }
4624
4625 blk_queue_bounce_limit(disks[drive]->queue, BLK_BOUNCE_HIGH);
4626 blk_queue_max_hw_sectors(disks[drive]->queue, 64);
4627 disks[drive]->major = FLOPPY_MAJOR;
4628 disks[drive]->first_minor = TOMINOR(drive);
4629 disks[drive]->fops = &floppy_fops;
4630 disks[drive]->events = DISK_EVENT_MEDIA_CHANGE;
4631 sprintf(disks[drive]->disk_name, "fd%d", drive);
4632
4633 timer_setup(&motor_off_timer[drive], motor_off_callback, 0);
4634 }
4635
4636 err = register_blkdev(FLOPPY_MAJOR, "fd");
4637 if (err)
4638 goto out_put_disk;
4639
4640 err = platform_driver_register(&floppy_driver);
4641 if (err)
4642 goto out_unreg_blkdev;
4643
4644 blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
4645 floppy_find, NULL, NULL);
4646
4647 for (i = 0; i < 256; i++)
4648 if (ITYPE(i))
4649 floppy_sizes[i] = floppy_type[ITYPE(i)].size;
4650 else
4651 floppy_sizes[i] = MAX_DISK_SIZE << 1;
4652
4653 reschedule_timeout(MAXTIMEOUT, "floppy init");
4654 config_types();
4655
4656 for (i = 0; i < N_FDC; i++) {
4657 memset(&fdc_state[i], 0, sizeof(*fdc_state));
4658 fdc_state[i].dtr = -1;
4659 fdc_state[i].dor = 0x4;
4660#if defined(__sparc__) || defined(__mc68000__)
4661
4662#ifdef __mc68000__
4663 if (MACH_IS_SUN3X)
4664#endif
4665 fdc_state[i].version = FDC_82072A;
4666#endif
4667 }
4668
4669 use_virtual_dma = can_use_virtual_dma & 1;
4670 fdc_state[0].address = FDC1;
4671 if (fdc_state[0].address == -1) {
4672 cancel_delayed_work(&fd_timeout);
4673 err = -ENODEV;
4674 goto out_unreg_region;
4675 }
4676#if N_FDC > 1
4677 fdc_state[1].address = FDC2;
4678#endif
4679
4680 current_fdc = 0;
4681 err = floppy_grab_irq_and_dma();
4682 if (err) {
4683 cancel_delayed_work(&fd_timeout);
4684 err = -EBUSY;
4685 goto out_unreg_region;
4686 }
4687
4688
4689 for (drive = 0; drive < N_DRIVE; drive++) {
4690 memset(&drive_state[drive], 0, sizeof(drive_state[drive]));
4691 memset(&write_errors[drive], 0, sizeof(write_errors[drive]));
4692 set_bit(FD_DISK_NEWCHANGE_BIT, &drive_state[drive].flags);
4693 set_bit(FD_DISK_CHANGED_BIT, &drive_state[drive].flags);
4694 set_bit(FD_VERIFY_BIT, &drive_state[drive].flags);
4695 drive_state[drive].fd_device = -1;
4696 floppy_track_buffer = NULL;
4697 max_buffer_sectors = 0;
4698 }
4699
4700
4701
4702
4703
4704 msleep(10);
4705
4706 for (i = 0; i < N_FDC; i++) {
4707 fdc_state[i].driver_version = FD_DRIVER_VERSION;
4708 for (unit = 0; unit < 4; unit++)
4709 fdc_state[i].track[unit] = 0;
4710 if (fdc_state[i].address == -1)
4711 continue;
4712 fdc_state[i].rawcmd = 2;
4713 if (user_reset_fdc(REVDRIVE(i, 0), FD_RESET_ALWAYS, false)) {
4714
4715 floppy_release_regions(i);
4716 fdc_state[i].address = -1;
4717 fdc_state[i].version = FDC_NONE;
4718 continue;
4719 }
4720
4721 fdc_state[i].version = get_fdc_version(i);
4722 if (fdc_state[i].version == FDC_NONE) {
4723
4724 floppy_release_regions(i);
4725 fdc_state[i].address = -1;
4726 continue;
4727 }
4728 if (can_use_virtual_dma == 2 &&
4729 fdc_state[i].version < FDC_82072A)
4730 can_use_virtual_dma = 0;
4731
4732 have_no_fdc = 0;
4733
4734
4735
4736
4737 user_reset_fdc(REVDRIVE(i, 0), FD_RESET_ALWAYS, false);
4738 }
4739 current_fdc = 0;
4740 cancel_delayed_work(&fd_timeout);
4741 current_drive = 0;
4742 initialized = true;
4743 if (have_no_fdc) {
4744 DPRINT("no floppy controllers found\n");
4745 err = have_no_fdc;
4746 goto out_release_dma;
4747 }
4748
4749 for (drive = 0; drive < N_DRIVE; drive++) {
4750 if (!floppy_available(drive))
4751 continue;
4752
4753 floppy_device[drive].name = floppy_device_name;
4754 floppy_device[drive].id = drive;
4755 floppy_device[drive].dev.release = floppy_device_release;
4756 floppy_device[drive].dev.groups = floppy_dev_groups;
4757
4758 err = platform_device_register(&floppy_device[drive]);
4759 if (err)
4760 goto out_remove_drives;
4761
4762
4763 disks[drive]->private_data = (void *)(long)drive;
4764 disks[drive]->flags |= GENHD_FL_REMOVABLE;
4765 device_add_disk(&floppy_device[drive].dev, disks[drive], NULL);
4766 }
4767
4768 return 0;
4769
4770out_remove_drives:
4771 while (drive--) {
4772 if (floppy_available(drive)) {
4773 del_gendisk(disks[drive]);
4774 platform_device_unregister(&floppy_device[drive]);
4775 }
4776 }
4777out_release_dma:
4778 if (atomic_read(&usage_count))
4779 floppy_release_irq_and_dma();
4780out_unreg_region:
4781 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
4782 platform_driver_unregister(&floppy_driver);
4783out_unreg_blkdev:
4784 unregister_blkdev(FLOPPY_MAJOR, "fd");
4785out_put_disk:
4786 destroy_workqueue(floppy_wq);
4787 for (drive = 0; drive < N_DRIVE; drive++) {
4788 if (!disks[drive])
4789 break;
4790 if (disks[drive]->queue) {
4791 del_timer_sync(&motor_off_timer[drive]);
4792 blk_cleanup_queue(disks[drive]->queue);
4793 disks[drive]->queue = NULL;
4794 blk_mq_free_tag_set(&tag_sets[drive]);
4795 }
4796 put_disk(disks[drive]);
4797 }
4798 return err;
4799}
4800
4801#ifndef MODULE
4802static __init void floppy_async_init(void *data, async_cookie_t cookie)
4803{
4804 do_floppy_init();
4805}
4806#endif
4807
4808static int __init floppy_init(void)
4809{
4810#ifdef MODULE
4811 return do_floppy_init();
4812#else
4813
4814 async_schedule(floppy_async_init, NULL);
4815 return 0;
4816#endif
4817}
4818
4819static const struct io_region {
4820 int offset;
4821 int size;
4822} io_regions[] = {
4823 { 2, 1 },
4824
4825 { 4, 2 },
4826
4827
4828 { 7, 1 },
4829};
4830
4831static void floppy_release_allocated_regions(int fdc, const struct io_region *p)
4832{
4833 while (p != io_regions) {
4834 p--;
4835 release_region(fdc_state[fdc].address + p->offset, p->size);
4836 }
4837}
4838
4839#define ARRAY_END(X) (&((X)[ARRAY_SIZE(X)]))
4840
4841static int floppy_request_regions(int fdc)
4842{
4843 const struct io_region *p;
4844
4845 for (p = io_regions; p < ARRAY_END(io_regions); p++) {
4846 if (!request_region(fdc_state[fdc].address + p->offset,
4847 p->size, "floppy")) {
4848 DPRINT("Floppy io-port 0x%04lx in use\n",
4849 fdc_state[fdc].address + p->offset);
4850 floppy_release_allocated_regions(fdc, p);
4851 return -EBUSY;
4852 }
4853 }
4854 return 0;
4855}
4856
4857static void floppy_release_regions(int fdc)
4858{
4859 floppy_release_allocated_regions(fdc, ARRAY_END(io_regions));
4860}
4861
4862static int floppy_grab_irq_and_dma(void)
4863{
4864 int fdc;
4865
4866 if (atomic_inc_return(&usage_count) > 1)
4867 return 0;
4868
4869
4870
4871
4872
4873 flush_workqueue(floppy_wq);
4874
4875 if (fd_request_irq()) {
4876 DPRINT("Unable to grab IRQ%d for the floppy driver\n",
4877 FLOPPY_IRQ);
4878 atomic_dec(&usage_count);
4879 return -1;
4880 }
4881 if (fd_request_dma()) {
4882 DPRINT("Unable to grab DMA%d for the floppy driver\n",
4883 FLOPPY_DMA);
4884 if (can_use_virtual_dma & 2)
4885 use_virtual_dma = can_use_virtual_dma = 1;
4886 if (!(can_use_virtual_dma & 1)) {
4887 fd_free_irq();
4888 atomic_dec(&usage_count);
4889 return -1;
4890 }
4891 }
4892
4893 for (fdc = 0; fdc < N_FDC; fdc++) {
4894 if (fdc_state[fdc].address != -1) {
4895 if (floppy_request_regions(fdc))
4896 goto cleanup;
4897 }
4898 }
4899 for (fdc = 0; fdc < N_FDC; fdc++) {
4900 if (fdc_state[fdc].address != -1) {
4901 reset_fdc_info(fdc, 1);
4902 fdc_outb(fdc_state[fdc].dor, fdc, FD_DOR);
4903 }
4904 }
4905
4906 set_dor(0, ~0, 8);
4907
4908 for (fdc = 0; fdc < N_FDC; fdc++)
4909 if (fdc_state[fdc].address != -1)
4910 fdc_outb(fdc_state[fdc].dor, fdc, FD_DOR);
4911
4912
4913
4914
4915 current_fdc = 0;
4916 irqdma_allocated = 1;
4917 return 0;
4918cleanup:
4919 fd_free_irq();
4920 fd_free_dma();
4921 while (--fdc >= 0)
4922 floppy_release_regions(fdc);
4923 current_fdc = 0;
4924 atomic_dec(&usage_count);
4925 return -1;
4926}
4927
4928static void floppy_release_irq_and_dma(void)
4929{
4930 int fdc;
4931#ifndef __sparc__
4932 int drive;
4933#endif
4934 long tmpsize;
4935 unsigned long tmpaddr;
4936
4937 if (!atomic_dec_and_test(&usage_count))
4938 return;
4939
4940 if (irqdma_allocated) {
4941 fd_disable_dma();
4942 fd_free_dma();
4943 fd_free_irq();
4944 irqdma_allocated = 0;
4945 }
4946 set_dor(0, ~0, 8);
4947#if N_FDC > 1
4948 set_dor(1, ~8, 0);
4949#endif
4950
4951 if (floppy_track_buffer && max_buffer_sectors) {
4952 tmpsize = max_buffer_sectors * 1024;
4953 tmpaddr = (unsigned long)floppy_track_buffer;
4954 floppy_track_buffer = NULL;
4955 max_buffer_sectors = 0;
4956 buffer_min = buffer_max = -1;
4957 fd_dma_mem_free(tmpaddr, tmpsize);
4958 }
4959#ifndef __sparc__
4960 for (drive = 0; drive < N_FDC * 4; drive++)
4961 if (timer_pending(motor_off_timer + drive))
4962 pr_info("motor off timer %d still active\n", drive);
4963#endif
4964
4965 if (delayed_work_pending(&fd_timeout))
4966 pr_info("floppy timer still active:%s\n", timeout_message);
4967 if (delayed_work_pending(&fd_timer))
4968 pr_info("auxiliary floppy timer still active\n");
4969 if (work_pending(&floppy_work))
4970 pr_info("work still pending\n");
4971 for (fdc = 0; fdc < N_FDC; fdc++)
4972 if (fdc_state[fdc].address != -1)
4973 floppy_release_regions(fdc);
4974}
4975
4976#ifdef MODULE
4977
4978static char *floppy;
4979
4980static void __init parse_floppy_cfg_string(char *cfg)
4981{
4982 char *ptr;
4983
4984 while (*cfg) {
4985 ptr = cfg;
4986 while (*cfg && *cfg != ' ' && *cfg != '\t')
4987 cfg++;
4988 if (*cfg) {
4989 *cfg = '\0';
4990 cfg++;
4991 }
4992 if (*ptr)
4993 floppy_setup(ptr);
4994 }
4995}
4996
4997static int __init floppy_module_init(void)
4998{
4999 if (floppy)
5000 parse_floppy_cfg_string(floppy);
5001 return floppy_init();
5002}
5003module_init(floppy_module_init);
5004
5005static void __exit floppy_module_exit(void)
5006{
5007 int drive;
5008
5009 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
5010 unregister_blkdev(FLOPPY_MAJOR, "fd");
5011 platform_driver_unregister(&floppy_driver);
5012
5013 destroy_workqueue(floppy_wq);
5014
5015 for (drive = 0; drive < N_DRIVE; drive++) {
5016 del_timer_sync(&motor_off_timer[drive]);
5017
5018 if (floppy_available(drive)) {
5019 del_gendisk(disks[drive]);
5020 platform_device_unregister(&floppy_device[drive]);
5021 }
5022 blk_cleanup_queue(disks[drive]->queue);
5023 blk_mq_free_tag_set(&tag_sets[drive]);
5024
5025
5026
5027
5028
5029 if (!(allowed_drive_mask & (1 << drive)) ||
5030 fdc_state[FDC(drive)].version == FDC_NONE)
5031 disks[drive]->queue = NULL;
5032
5033 put_disk(disks[drive]);
5034 }
5035
5036 cancel_delayed_work_sync(&fd_timeout);
5037 cancel_delayed_work_sync(&fd_timer);
5038
5039 if (atomic_read(&usage_count))
5040 floppy_release_irq_and_dma();
5041
5042
5043 fd_eject(0);
5044}
5045
5046module_exit(floppy_module_exit);
5047
5048module_param(floppy, charp, 0);
5049module_param(FLOPPY_IRQ, int, 0);
5050module_param(FLOPPY_DMA, int, 0);
5051MODULE_AUTHOR("Alain L. Knaff");
5052MODULE_SUPPORTED_DEVICE("fd");
5053MODULE_LICENSE("GPL");
5054
5055
5056static const struct pnp_device_id floppy_pnpids[] = {
5057 {"PNP0700", 0},
5058 {}
5059};
5060
5061MODULE_DEVICE_TABLE(pnp, floppy_pnpids);
5062
5063#else
5064
5065__setup("floppy=", floppy_setup);
5066module_init(floppy_init)
5067#endif
5068
5069MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR);
5070