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