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