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#include <linux/module.h>
65
66#include <linux/fd.h>
67#include <linux/delay.h>
68#include <linux/init.h>
69#include <linux/blkdev.h>
70
71#include <asm/atafd.h>
72#include <asm/atafdreg.h>
73#include <asm/atariints.h>
74#include <asm/atari_stdma.h>
75#include <asm/atari_stram.h>
76
77#define FD_MAX_UNITS 2
78
79#undef DEBUG
80
81static struct request_queue *floppy_queue;
82static struct request *fd_request;
83
84
85static struct atari_disk_type {
86 const char *name;
87 unsigned spt;
88 unsigned blocks;
89 unsigned fdc_speed;
90 unsigned stretch;
91} atari_disk_type[] = {
92 { "d360", 9, 720, 0, 0},
93 { "D360", 9, 720, 0, 1},
94 { "D720", 9,1440, 0, 0},
95 { "D820", 10,1640, 0, 0},
96
97#define MAX_TYPE_DD 3
98 { "h1200",15,2400, 3, 0},
99 { "H1440",18,2880, 3, 0},
100 { "H1640",20,3280, 3, 0},
101
102#define MAX_TYPE_HD 6
103 { "E2880",36,5760, 3, 0},
104 { "E3280",40,6560, 3, 0},
105
106#define MAX_TYPE_ED 8
107
108 { "H1680",21,3360, 3, 0},
109 { "h410",10,820, 0, 1},
110 { "h1476",18,2952, 3, 0},
111 { "H1722",21,3444, 3, 0},
112 { "h420",10,840, 0, 1},
113 { "H830",10,1660, 0, 0},
114 { "h1494",18,2952, 3, 0},
115 { "H1743",21,3486, 3, 0},
116 { "h880",11,1760, 0, 0},
117 { "D1040",13,2080, 0, 0},
118 { "D1120",14,2240, 0, 0},
119 { "h1600",20,3200, 3, 0},
120 { "H1760",22,3520, 3, 0},
121 { "H1920",24,3840, 3, 0},
122 { "E3200",40,6400, 3, 0},
123 { "E3520",44,7040, 3, 0},
124 { "E3840",48,7680, 3, 0},
125 { "H1840",23,3680, 3, 0},
126 { "D800",10,1600, 0, 0},
127};
128
129static int StartDiskType[] = {
130 MAX_TYPE_DD,
131 MAX_TYPE_HD,
132 MAX_TYPE_ED
133};
134
135#define TYPE_DD 0
136#define TYPE_HD 1
137#define TYPE_ED 2
138
139static int DriveType = TYPE_HD;
140
141static DEFINE_SPINLOCK(ataflop_lock);
142
143
144static struct {
145 int index;
146 unsigned drive_types;
147} minor2disktype[] = {
148 { 0, TYPE_DD },
149 { 4, TYPE_HD },
150 { 1, TYPE_DD },
151 { 2, TYPE_DD },
152 { 1, TYPE_DD },
153 { 2, TYPE_DD },
154 { 5, TYPE_HD },
155 { 7, TYPE_ED },
156
157 { 8, TYPE_ED },
158 { 5, TYPE_HD },
159 { 9, TYPE_HD },
160 { 10, TYPE_DD },
161 { 3, TYPE_DD },
162 { 11, TYPE_HD },
163 { 12, TYPE_HD },
164 { 13, TYPE_DD },
165 { 14, TYPE_DD },
166 { 15, TYPE_HD },
167 { 16, TYPE_HD },
168 { 17, TYPE_DD },
169 { 18, TYPE_DD },
170 { 19, TYPE_DD },
171 { 20, TYPE_HD },
172 { 21, TYPE_HD },
173 { 22, TYPE_HD },
174 { 23, TYPE_ED },
175 { 24, TYPE_ED },
176 { 25, TYPE_ED },
177 { 26, TYPE_HD },
178 { 27, TYPE_DD },
179 { 6, TYPE_HD },
180};
181
182#define NUM_DISK_MINORS ARRAY_SIZE(minor2disktype)
183
184
185
186
187
188#define MAX_DISK_SIZE 3280
189
190
191
192
193
194static struct atari_disk_type user_params[FD_MAX_UNITS];
195
196
197
198
199
200
201
202static struct atari_disk_type default_params[FD_MAX_UNITS];
203
204
205static struct atari_floppy_struct {
206 int connected;
207 int autoprobe;
208
209 struct atari_disk_type *disktype;
210
211 int track;
212
213 unsigned int steprate;
214 unsigned int wpstat;
215
216 int flags;
217 struct gendisk *disk;
218 int ref;
219 int type;
220} unit[FD_MAX_UNITS];
221
222#define UD unit[drive]
223#define UDT unit[drive].disktype
224#define SUD unit[SelectedDrive]
225#define SUDT unit[SelectedDrive].disktype
226
227
228#define FDC_READ(reg) ({ \
229 \
230 unsigned short __val; \
231 \
232 dma_wd.dma_mode_status = 0x80 | (reg); \
233 udelay(25); \
234 __val = dma_wd.fdc_acces_seccount; \
235 MFPDELAY(); \
236 \
237 __val & 0xff; \
238})
239
240#define FDC_WRITE(reg,val) \
241 do { \
242 \
243 \
244 dma_wd.dma_mode_status = 0x80 | (reg); \
245 udelay(25); \
246 dma_wd.fdc_acces_seccount = (val); \
247 MFPDELAY(); \
248 \
249 } while(0)
250
251
252
253
254
255
256
257
258
259static int MaxSectors[] = {
260 11, 22, 44
261};
262static int BufferSize[] = {
263 15*512, 30*512, 60*512
264};
265
266#define BUFFER_SIZE (BufferSize[DriveType])
267
268unsigned char *DMABuffer;
269static unsigned long PhysDMABuffer;
270
271static int UseTrackbuffer = -1;
272module_param(UseTrackbuffer, int, 0);
273
274unsigned char *TrackBuffer;
275static unsigned long PhysTrackBuffer;
276static int BufferDrive, BufferSide, BufferTrack;
277static int read_track;
278
279#define SECTOR_BUFFER(sec) (TrackBuffer + ((sec)-1)*512)
280#define IS_BUFFERED(drive,side,track) \
281 (BufferDrive == (drive) && BufferSide == (side) && BufferTrack == (track))
282
283
284
285
286
287
288static int SelectedDrive = 0;
289static int ReqCmd, ReqBlock;
290static int ReqSide, ReqTrack, ReqSector, ReqCnt;
291static int HeadSettleFlag = 0;
292static unsigned char *ReqData, *ReqBuffer;
293static int MotorOn = 0, MotorOffTrys;
294static int IsFormatting = 0, FormatError;
295
296static int UserSteprate[FD_MAX_UNITS] = { -1, -1 };
297module_param_array(UserSteprate, int, NULL, 0);
298
299
300static volatile int fdc_busy = 0;
301static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
302static DECLARE_WAIT_QUEUE_HEAD(format_wait);
303
304static unsigned long changed_floppies = 0xff, fake_change = 0;
305#define CHECK_CHANGE_DELAY HZ/2
306
307#define FD_MOTOR_OFF_DELAY (3*HZ)
308#define FD_MOTOR_OFF_MAXTRY (10*20)
309
310#define FLOPPY_TIMEOUT (6*HZ)
311#define RECALIBRATE_ERRORS 4
312
313#define MAX_ERRORS 8
314
315
316
317
318
319
320
321
322static int Probing = 0;
323
324
325
326
327static int NeedSeek = 0;
328
329
330#ifdef DEBUG
331#define DPRINT(a) printk a
332#else
333#define DPRINT(a)
334#endif
335
336
337
338static void fd_select_side( int side );
339static void fd_select_drive( int drive );
340static void fd_deselect( void );
341static void fd_motor_off_timer( unsigned long dummy );
342static void check_change( unsigned long dummy );
343static irqreturn_t floppy_irq (int irq, void *dummy);
344static void fd_error( void );
345static int do_format(int drive, int type, struct atari_format_descr *desc);
346static void do_fd_action( int drive );
347static void fd_calibrate( void );
348static void fd_calibrate_done( int status );
349static void fd_seek( void );
350static void fd_seek_done( int status );
351static void fd_rwsec( void );
352static void fd_readtrack_check( unsigned long dummy );
353static void fd_rwsec_done( int status );
354static void fd_rwsec_done1(int status);
355static void fd_writetrack( void );
356static void fd_writetrack_done( int status );
357static void fd_times_out( unsigned long dummy );
358static void finish_fdc( void );
359static void finish_fdc_done( int dummy );
360static void setup_req_params( int drive );
361static void redo_fd_request( void);
362static int fd_ioctl(struct block_device *bdev, fmode_t mode, unsigned int
363 cmd, unsigned long param);
364static void fd_probe( int drive );
365static int fd_test_drive_present( int drive );
366static void config_types( void );
367static int floppy_open(struct block_device *bdev, fmode_t mode);
368static int floppy_release(struct gendisk *disk, fmode_t mode);
369
370
371
372static DEFINE_TIMER(motor_off_timer, fd_motor_off_timer, 0, 0);
373static DEFINE_TIMER(readtrack_timer, fd_readtrack_check, 0, 0);
374static DEFINE_TIMER(timeout_timer, fd_times_out, 0, 0);
375static DEFINE_TIMER(fd_timer, check_change, 0, 0);
376
377static void fd_end_request_cur(int err)
378{
379 if (!__blk_end_request_cur(fd_request, err))
380 fd_request = NULL;
381}
382
383static inline void start_motor_off_timer(void)
384{
385 mod_timer(&motor_off_timer, jiffies + FD_MOTOR_OFF_DELAY);
386 MotorOffTrys = 0;
387}
388
389static inline void start_check_change_timer( void )
390{
391 mod_timer(&fd_timer, jiffies + CHECK_CHANGE_DELAY);
392}
393
394static inline void start_timeout(void)
395{
396 mod_timer(&timeout_timer, jiffies + FLOPPY_TIMEOUT);
397}
398
399static inline void stop_timeout(void)
400{
401 del_timer(&timeout_timer);
402}
403
404
405
406static void fd_select_side( int side )
407{
408 unsigned long flags;
409
410
411 local_irq_save(flags);
412
413 sound_ym.rd_data_reg_sel = 14;
414 sound_ym.wd_data = (side == 0) ? sound_ym.rd_data_reg_sel | 0x01 :
415 sound_ym.rd_data_reg_sel & 0xfe;
416
417 local_irq_restore(flags);
418}
419
420
421
422
423
424
425static void fd_select_drive( int drive )
426{
427 unsigned long flags;
428 unsigned char tmp;
429
430 if (drive == SelectedDrive)
431 return;
432
433
434 local_irq_save(flags);
435 sound_ym.rd_data_reg_sel = 14;
436 tmp = sound_ym.rd_data_reg_sel;
437 sound_ym.wd_data = (tmp | DSKDRVNONE) & ~(drive == 0 ? DSKDRV0 : DSKDRV1);
438 atari_dont_touch_floppy_select = 1;
439 local_irq_restore(flags);
440
441
442 FDC_WRITE( FDCREG_TRACK, UD.track );
443 udelay(25);
444
445
446 if (UDT)
447 if (ATARIHW_PRESENT(FDCSPEED))
448 dma_wd.fdc_speed = UDT->fdc_speed;
449
450 SelectedDrive = drive;
451}
452
453
454
455
456static void fd_deselect( void )
457{
458 unsigned long flags;
459
460
461 local_irq_save(flags);
462 atari_dont_touch_floppy_select = 0;
463 sound_ym.rd_data_reg_sel=14;
464 sound_ym.wd_data = (sound_ym.rd_data_reg_sel |
465 (MACH_IS_FALCON ? 3 : 7));
466
467
468 SelectedDrive = -1;
469 local_irq_restore(flags);
470}
471
472
473
474
475
476
477
478static void fd_motor_off_timer( unsigned long dummy )
479{
480 unsigned char status;
481
482 if (SelectedDrive < 0)
483
484 return;
485
486 if (stdma_islocked())
487 goto retry;
488
489 status = FDC_READ( FDCREG_STATUS );
490
491 if (!(status & 0x80)) {
492
493 MotorOn = 0;
494 fd_deselect();
495 return;
496 }
497
498
499 retry:
500
501
502
503
504
505 mod_timer(&motor_off_timer,
506 jiffies + (MotorOffTrys++ < FD_MOTOR_OFF_MAXTRY ? HZ/20 : HZ/2));
507}
508
509
510
511
512
513
514static void check_change( unsigned long dummy )
515{
516 static int drive = 0;
517
518 unsigned long flags;
519 unsigned char old_porta;
520 int stat;
521
522 if (++drive > 1 || !UD.connected)
523 drive = 0;
524
525
526 local_irq_save(flags);
527
528 if (!stdma_islocked()) {
529 sound_ym.rd_data_reg_sel = 14;
530 old_porta = sound_ym.rd_data_reg_sel;
531 sound_ym.wd_data = (old_porta | DSKDRVNONE) &
532 ~(drive == 0 ? DSKDRV0 : DSKDRV1);
533 stat = !!(FDC_READ( FDCREG_STATUS ) & FDCSTAT_WPROT);
534 sound_ym.wd_data = old_porta;
535
536 if (stat != UD.wpstat) {
537 DPRINT(( "wpstat[%d] = %d\n", drive, stat ));
538 UD.wpstat = stat;
539 set_bit (drive, &changed_floppies);
540 }
541 }
542 local_irq_restore(flags);
543
544 start_check_change_timer();
545}
546
547
548
549
550
551
552static inline void set_head_settle_flag(void)
553{
554 HeadSettleFlag = FDCCMDADD_E;
555}
556
557static inline int get_head_settle_flag(void)
558{
559 int tmp = HeadSettleFlag;
560 HeadSettleFlag = 0;
561 return( tmp );
562}
563
564static inline void copy_buffer(void *from, void *to)
565{
566 ulong *p1 = (ulong *)from, *p2 = (ulong *)to;
567 int cnt;
568
569 for (cnt = 512/4; cnt; cnt--)
570 *p2++ = *p1++;
571}
572
573
574
575
576
577
578static void (*FloppyIRQHandler)( int status ) = NULL;
579
580static irqreturn_t floppy_irq (int irq, void *dummy)
581{
582 unsigned char status;
583 void (*handler)( int );
584
585 handler = xchg(&FloppyIRQHandler, NULL);
586
587 if (handler) {
588 nop();
589 status = FDC_READ( FDCREG_STATUS );
590 DPRINT(("FDC irq, status = %02x handler = %08lx\n",status,(unsigned long)handler));
591 handler( status );
592 }
593 else {
594 DPRINT(("FDC irq, no handler\n"));
595 }
596 return IRQ_HANDLED;
597}
598
599
600
601
602
603
604static void fd_error( void )
605{
606 if (IsFormatting) {
607 IsFormatting = 0;
608 FormatError = 1;
609 wake_up( &format_wait );
610 return;
611 }
612
613 if (!fd_request)
614 return;
615
616 fd_request->errors++;
617 if (fd_request->errors >= MAX_ERRORS) {
618 printk(KERN_ERR "fd%d: too many errors.\n", SelectedDrive );
619 fd_end_request_cur(-EIO);
620 }
621 else if (fd_request->errors == RECALIBRATE_ERRORS) {
622 printk(KERN_WARNING "fd%d: recalibrating\n", SelectedDrive );
623 if (SelectedDrive != -1)
624 SUD.track = -1;
625 }
626 redo_fd_request();
627}
628
629
630
631#define SET_IRQ_HANDLER(proc) do { FloppyIRQHandler = (proc); } while(0)
632
633
634
635
636#define FILL(n,val) \
637 do { \
638 memset( p, val, n ); \
639 p += n; \
640 } while(0)
641
642static int do_format(int drive, int type, struct atari_format_descr *desc)
643{
644 unsigned char *p;
645 int sect, nsect;
646 unsigned long flags;
647
648 DPRINT(("do_format( dr=%d tr=%d he=%d offs=%d )\n",
649 drive, desc->track, desc->head, desc->sect_offset ));
650
651 local_irq_save(flags);
652 while( fdc_busy ) sleep_on( &fdc_wait );
653 fdc_busy = 1;
654 stdma_lock(floppy_irq, NULL);
655 atari_turnon_irq( IRQ_MFP_FDC );
656 local_irq_restore(flags);
657
658 if (type) {
659 if (--type >= NUM_DISK_MINORS ||
660 minor2disktype[type].drive_types > DriveType) {
661 redo_fd_request();
662 return -EINVAL;
663 }
664 type = minor2disktype[type].index;
665 UDT = &atari_disk_type[type];
666 }
667
668 if (!UDT || desc->track >= UDT->blocks/UDT->spt/2 || desc->head >= 2) {
669 redo_fd_request();
670 return -EINVAL;
671 }
672
673 nsect = UDT->spt;
674 p = TrackBuffer;
675
676
677 BufferDrive = -1;
678
679 del_timer( &motor_off_timer );
680
681 FILL( 60 * (nsect / 9), 0x4e );
682 for( sect = 0; sect < nsect; ++sect ) {
683 FILL( 12, 0 );
684 FILL( 3, 0xf5 );
685 *p++ = 0xfe;
686 *p++ = desc->track;
687 *p++ = desc->head;
688 *p++ = (nsect + sect - desc->sect_offset) % nsect + 1;
689 *p++ = 2;
690 *p++ = 0xf7;
691 FILL( 22, 0x4e );
692 FILL( 12, 0 );
693 FILL( 3, 0xf5 );
694 *p++ = 0xfb;
695 FILL( 512, 0xe5 );
696 *p++ = 0xf7;
697 FILL( 40, 0x4e );
698 }
699 FILL( TrackBuffer+BUFFER_SIZE-p, 0x4e );
700
701 IsFormatting = 1;
702 FormatError = 0;
703 ReqTrack = desc->track;
704 ReqSide = desc->head;
705 do_fd_action( drive );
706
707 sleep_on( &format_wait );
708
709 redo_fd_request();
710 return( FormatError ? -EIO : 0 );
711}
712
713
714
715
716
717
718
719
720
721
722
723static void do_fd_action( int drive )
724{
725 DPRINT(("do_fd_action\n"));
726
727 if (UseTrackbuffer && !IsFormatting) {
728 repeat:
729 if (IS_BUFFERED( drive, ReqSide, ReqTrack )) {
730 if (ReqCmd == READ) {
731 copy_buffer( SECTOR_BUFFER(ReqSector), ReqData );
732 if (++ReqCnt < blk_rq_cur_sectors(fd_request)) {
733
734 setup_req_params( drive );
735 goto repeat;
736 }
737 else {
738
739 fd_end_request_cur(0);
740 redo_fd_request();
741 return;
742 }
743 }
744 else {
745
746
747 copy_buffer( ReqData, SECTOR_BUFFER(ReqSector) );
748 }
749 }
750 }
751
752 if (SelectedDrive != drive)
753 fd_select_drive( drive );
754
755 if (UD.track == -1)
756 fd_calibrate();
757 else if (UD.track != ReqTrack << UDT->stretch)
758 fd_seek();
759 else if (IsFormatting)
760 fd_writetrack();
761 else
762 fd_rwsec();
763}
764
765
766
767
768static void fd_calibrate( void )
769{
770 if (SUD.track >= 0) {
771 fd_calibrate_done( 0 );
772 return;
773 }
774
775 if (ATARIHW_PRESENT(FDCSPEED))
776 dma_wd.fdc_speed = 0; ;
777 DPRINT(("fd_calibrate\n"));
778 SET_IRQ_HANDLER( fd_calibrate_done );
779
780 FDC_WRITE( FDCREG_CMD, FDCCMD_RESTORE | SUD.steprate );
781
782 NeedSeek = 1;
783 MotorOn = 1;
784 start_timeout();
785
786}
787
788
789static void fd_calibrate_done( int status )
790{
791 DPRINT(("fd_calibrate_done()\n"));
792 stop_timeout();
793
794
795 if (ATARIHW_PRESENT(FDCSPEED))
796 dma_wd.fdc_speed = SUDT->fdc_speed;
797 if (status & FDCSTAT_RECNF) {
798 printk(KERN_ERR "fd%d: restore failed\n", SelectedDrive );
799 fd_error();
800 }
801 else {
802 SUD.track = 0;
803 fd_seek();
804 }
805}
806
807
808
809
810
811
812static void fd_seek( void )
813{
814 if (SUD.track == ReqTrack << SUDT->stretch) {
815 fd_seek_done( 0 );
816 return;
817 }
818
819 if (ATARIHW_PRESENT(FDCSPEED)) {
820 dma_wd.fdc_speed = 0;
821 MFPDELAY();
822 }
823
824 DPRINT(("fd_seek() to track %d\n",ReqTrack));
825 FDC_WRITE( FDCREG_DATA, ReqTrack << SUDT->stretch);
826 udelay(25);
827 SET_IRQ_HANDLER( fd_seek_done );
828 FDC_WRITE( FDCREG_CMD, FDCCMD_SEEK | SUD.steprate );
829
830 MotorOn = 1;
831 set_head_settle_flag();
832 start_timeout();
833
834}
835
836
837static void fd_seek_done( int status )
838{
839 DPRINT(("fd_seek_done()\n"));
840 stop_timeout();
841
842
843 if (ATARIHW_PRESENT(FDCSPEED))
844 dma_wd.fdc_speed = SUDT->fdc_speed;
845 if (status & FDCSTAT_RECNF) {
846 printk(KERN_ERR "fd%d: seek error (to track %d)\n",
847 SelectedDrive, ReqTrack );
848
849 SUD.track = -1;
850 fd_error();
851 }
852 else {
853 SUD.track = ReqTrack << SUDT->stretch;
854 NeedSeek = 0;
855 if (IsFormatting)
856 fd_writetrack();
857 else
858 fd_rwsec();
859 }
860}
861
862
863
864
865
866
867static int MultReadInProgress = 0;
868
869
870static void fd_rwsec( void )
871{
872 unsigned long paddr, flags;
873 unsigned int rwflag, old_motoron;
874 unsigned int track;
875
876 DPRINT(("fd_rwsec(), Sec=%d, Access=%c\n",ReqSector, ReqCmd == WRITE ? 'w' : 'r' ));
877 if (ReqCmd == WRITE) {
878 if (ATARIHW_PRESENT(EXTD_DMA)) {
879 paddr = virt_to_phys(ReqData);
880 }
881 else {
882 copy_buffer( ReqData, DMABuffer );
883 paddr = PhysDMABuffer;
884 }
885 dma_cache_maintenance( paddr, 512, 1 );
886 rwflag = 0x100;
887 }
888 else {
889 if (read_track)
890 paddr = PhysTrackBuffer;
891 else
892 paddr = ATARIHW_PRESENT(EXTD_DMA) ?
893 virt_to_phys(ReqData) : PhysDMABuffer;
894 rwflag = 0;
895 }
896
897 fd_select_side( ReqSide );
898
899
900 FDC_WRITE( FDCREG_SECTOR, read_track ? 1 : ReqSector );
901 MFPDELAY();
902
903 if (SUDT->stretch) {
904 track = FDC_READ( FDCREG_TRACK);
905 MFPDELAY();
906 FDC_WRITE( FDCREG_TRACK, track >> SUDT->stretch);
907 }
908 udelay(25);
909
910
911 local_irq_save(flags);
912 dma_wd.dma_lo = (unsigned char)paddr;
913 MFPDELAY();
914 paddr >>= 8;
915 dma_wd.dma_md = (unsigned char)paddr;
916 MFPDELAY();
917 paddr >>= 8;
918 if (ATARIHW_PRESENT(EXTD_DMA))
919 st_dma_ext_dmahi = (unsigned short)paddr;
920 else
921 dma_wd.dma_hi = (unsigned char)paddr;
922 MFPDELAY();
923 local_irq_restore(flags);
924
925
926 dma_wd.dma_mode_status = 0x90 | rwflag;
927 MFPDELAY();
928 dma_wd.dma_mode_status = 0x90 | (rwflag ^ 0x100);
929 MFPDELAY();
930 dma_wd.dma_mode_status = 0x90 | rwflag;
931 MFPDELAY();
932
933
934 dma_wd.fdc_acces_seccount = read_track ? SUDT->spt : 1;
935
936 udelay(25);
937
938
939 dma_wd.dma_mode_status = FDCSELREG_STP | rwflag;
940 udelay(25);
941 SET_IRQ_HANDLER( fd_rwsec_done );
942 dma_wd.fdc_acces_seccount =
943 (get_head_settle_flag() |
944 (rwflag ? FDCCMD_WRSEC : (FDCCMD_RDSEC | (read_track ? FDCCMDADD_M : 0))));
945
946 old_motoron = MotorOn;
947 MotorOn = 1;
948 NeedSeek = 1;
949
950
951 if (read_track) {
952
953
954
955
956
957 MultReadInProgress = 1;
958 mod_timer(&readtrack_timer,
959
960 jiffies + HZ/5 + (old_motoron ? 0 : HZ));
961 }
962 start_timeout();
963}
964
965
966static void fd_readtrack_check( unsigned long dummy )
967{
968 unsigned long flags, addr, addr2;
969
970 local_irq_save(flags);
971
972 if (!MultReadInProgress) {
973
974
975
976
977
978
979 local_irq_restore(flags);
980 return;
981 }
982
983
984
985 addr = 0;
986 do {
987 addr2 = addr;
988 addr = dma_wd.dma_lo & 0xff;
989 MFPDELAY();
990 addr |= (dma_wd.dma_md & 0xff) << 8;
991 MFPDELAY();
992 if (ATARIHW_PRESENT( EXTD_DMA ))
993 addr |= (st_dma_ext_dmahi & 0xffff) << 16;
994 else
995 addr |= (dma_wd.dma_hi & 0xff) << 16;
996 MFPDELAY();
997 } while(addr != addr2);
998
999 if (addr >= PhysTrackBuffer + SUDT->spt*512) {
1000
1001
1002
1003 SET_IRQ_HANDLER( NULL );
1004 MultReadInProgress = 0;
1005 local_irq_restore(flags);
1006 DPRINT(("fd_readtrack_check(): done\n"));
1007 FDC_WRITE( FDCREG_CMD, FDCCMD_FORCI );
1008 udelay(25);
1009
1010
1011
1012
1013 fd_rwsec_done1(0);
1014 }
1015 else {
1016
1017 local_irq_restore(flags);
1018 DPRINT(("fd_readtrack_check(): not yet finished\n"));
1019 mod_timer(&readtrack_timer, jiffies + HZ/5/10);
1020 }
1021}
1022
1023
1024static void fd_rwsec_done( int status )
1025{
1026 DPRINT(("fd_rwsec_done()\n"));
1027
1028 if (read_track) {
1029 del_timer(&readtrack_timer);
1030 if (!MultReadInProgress)
1031 return;
1032 MultReadInProgress = 0;
1033 }
1034 fd_rwsec_done1(status);
1035}
1036
1037static void fd_rwsec_done1(int status)
1038{
1039 unsigned int track;
1040
1041 stop_timeout();
1042
1043
1044 if (SUDT->stretch) {
1045 track = FDC_READ( FDCREG_TRACK);
1046 MFPDELAY();
1047 FDC_WRITE( FDCREG_TRACK, track << SUDT->stretch);
1048 }
1049
1050 if (!UseTrackbuffer) {
1051 dma_wd.dma_mode_status = 0x90;
1052 MFPDELAY();
1053 if (!(dma_wd.dma_mode_status & 0x01)) {
1054 printk(KERN_ERR "fd%d: DMA error\n", SelectedDrive );
1055 goto err_end;
1056 }
1057 }
1058 MFPDELAY();
1059
1060 if (ReqCmd == WRITE && (status & FDCSTAT_WPROT)) {
1061 printk(KERN_NOTICE "fd%d: is write protected\n", SelectedDrive );
1062 goto err_end;
1063 }
1064 if ((status & FDCSTAT_RECNF) &&
1065
1066
1067 !(read_track && FDC_READ(FDCREG_SECTOR) > SUDT->spt)) {
1068 if (Probing) {
1069 if (SUDT > atari_disk_type) {
1070 if (SUDT[-1].blocks > ReqBlock) {
1071
1072 SUDT--;
1073 set_capacity(unit[SelectedDrive].disk,
1074 SUDT->blocks);
1075 } else
1076 Probing = 0;
1077 }
1078 else {
1079 if (SUD.flags & FTD_MSG)
1080 printk(KERN_INFO "fd%d: Auto-detected floppy type %s\n",
1081 SelectedDrive, SUDT->name );
1082 Probing=0;
1083 }
1084 } else {
1085
1086 if (SUD.autoprobe) {
1087 SUDT = atari_disk_type + StartDiskType[DriveType];
1088 set_capacity(unit[SelectedDrive].disk,
1089 SUDT->blocks);
1090 Probing = 1;
1091 }
1092 }
1093 if (Probing) {
1094 if (ATARIHW_PRESENT(FDCSPEED)) {
1095 dma_wd.fdc_speed = SUDT->fdc_speed;
1096 MFPDELAY();
1097 }
1098 setup_req_params( SelectedDrive );
1099 BufferDrive = -1;
1100 do_fd_action( SelectedDrive );
1101 return;
1102 }
1103
1104 printk(KERN_ERR "fd%d: sector %d not found (side %d, track %d)\n",
1105 SelectedDrive, FDC_READ (FDCREG_SECTOR), ReqSide, ReqTrack );
1106 goto err_end;
1107 }
1108 if (status & FDCSTAT_CRC) {
1109 printk(KERN_ERR "fd%d: CRC error (side %d, track %d, sector %d)\n",
1110 SelectedDrive, ReqSide, ReqTrack, FDC_READ (FDCREG_SECTOR) );
1111 goto err_end;
1112 }
1113 if (status & FDCSTAT_LOST) {
1114 printk(KERN_ERR "fd%d: lost data (side %d, track %d, sector %d)\n",
1115 SelectedDrive, ReqSide, ReqTrack, FDC_READ (FDCREG_SECTOR) );
1116 goto err_end;
1117 }
1118
1119 Probing = 0;
1120
1121 if (ReqCmd == READ) {
1122 if (!read_track) {
1123 void *addr;
1124 addr = ATARIHW_PRESENT( EXTD_DMA ) ? ReqData : DMABuffer;
1125 dma_cache_maintenance( virt_to_phys(addr), 512, 0 );
1126 if (!ATARIHW_PRESENT( EXTD_DMA ))
1127 copy_buffer (addr, ReqData);
1128 } else {
1129 dma_cache_maintenance( PhysTrackBuffer, MaxSectors[DriveType] * 512, 0 );
1130 BufferDrive = SelectedDrive;
1131 BufferSide = ReqSide;
1132 BufferTrack = ReqTrack;
1133 copy_buffer (SECTOR_BUFFER (ReqSector), ReqData);
1134 }
1135 }
1136
1137 if (++ReqCnt < blk_rq_cur_sectors(fd_request)) {
1138
1139 setup_req_params( SelectedDrive );
1140 do_fd_action( SelectedDrive );
1141 }
1142 else {
1143
1144 fd_end_request_cur(0);
1145 redo_fd_request();
1146 }
1147 return;
1148
1149 err_end:
1150 BufferDrive = -1;
1151 fd_error();
1152}
1153
1154
1155static void fd_writetrack( void )
1156{
1157 unsigned long paddr, flags;
1158 unsigned int track;
1159
1160 DPRINT(("fd_writetrack() Tr=%d Si=%d\n", ReqTrack, ReqSide ));
1161
1162 paddr = PhysTrackBuffer;
1163 dma_cache_maintenance( paddr, BUFFER_SIZE, 1 );
1164
1165 fd_select_side( ReqSide );
1166
1167
1168 if (SUDT->stretch) {
1169 track = FDC_READ( FDCREG_TRACK);
1170 MFPDELAY();
1171 FDC_WRITE(FDCREG_TRACK,track >> SUDT->stretch);
1172 }
1173 udelay(40);
1174
1175
1176 local_irq_save(flags);
1177 dma_wd.dma_lo = (unsigned char)paddr;
1178 MFPDELAY();
1179 paddr >>= 8;
1180 dma_wd.dma_md = (unsigned char)paddr;
1181 MFPDELAY();
1182 paddr >>= 8;
1183 if (ATARIHW_PRESENT( EXTD_DMA ))
1184 st_dma_ext_dmahi = (unsigned short)paddr;
1185 else
1186 dma_wd.dma_hi = (unsigned char)paddr;
1187 MFPDELAY();
1188 local_irq_restore(flags);
1189
1190
1191 dma_wd.dma_mode_status = 0x190;
1192 MFPDELAY();
1193 dma_wd.dma_mode_status = 0x90;
1194 MFPDELAY();
1195 dma_wd.dma_mode_status = 0x190;
1196 MFPDELAY();
1197
1198
1199 dma_wd.fdc_acces_seccount = BUFFER_SIZE/512;
1200 udelay(40);
1201
1202
1203 dma_wd.dma_mode_status = FDCSELREG_STP | 0x100;
1204 udelay(40);
1205 SET_IRQ_HANDLER( fd_writetrack_done );
1206 dma_wd.fdc_acces_seccount = FDCCMD_WRTRA | get_head_settle_flag();
1207
1208 MotorOn = 1;
1209 start_timeout();
1210
1211}
1212
1213
1214static void fd_writetrack_done( int status )
1215{
1216 DPRINT(("fd_writetrack_done()\n"));
1217
1218 stop_timeout();
1219
1220 if (status & FDCSTAT_WPROT) {
1221 printk(KERN_NOTICE "fd%d: is write protected\n", SelectedDrive );
1222 goto err_end;
1223 }
1224 if (status & FDCSTAT_LOST) {
1225 printk(KERN_ERR "fd%d: lost data (side %d, track %d)\n",
1226 SelectedDrive, ReqSide, ReqTrack );
1227 goto err_end;
1228 }
1229
1230 wake_up( &format_wait );
1231 return;
1232
1233 err_end:
1234 fd_error();
1235}
1236
1237static void fd_times_out( unsigned long dummy )
1238{
1239 atari_disable_irq( IRQ_MFP_FDC );
1240 if (!FloppyIRQHandler) goto end;
1241
1242
1243 SET_IRQ_HANDLER( NULL );
1244
1245
1246 if (UseTrackbuffer)
1247 del_timer( &readtrack_timer );
1248 FDC_WRITE( FDCREG_CMD, FDCCMD_FORCI );
1249 udelay( 25 );
1250
1251 printk(KERN_ERR "floppy timeout\n" );
1252 fd_error();
1253 end:
1254 atari_enable_irq( IRQ_MFP_FDC );
1255}
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265static void finish_fdc( void )
1266{
1267 if (!NeedSeek) {
1268 finish_fdc_done( 0 );
1269 }
1270 else {
1271 DPRINT(("finish_fdc: dummy seek started\n"));
1272 FDC_WRITE (FDCREG_DATA, SUD.track);
1273 SET_IRQ_HANDLER( finish_fdc_done );
1274 FDC_WRITE (FDCREG_CMD, FDCCMD_SEEK);
1275 MotorOn = 1;
1276 start_timeout();
1277
1278
1279
1280 }
1281}
1282
1283
1284static void finish_fdc_done( int dummy )
1285{
1286 unsigned long flags;
1287
1288 DPRINT(("finish_fdc_done entered\n"));
1289 stop_timeout();
1290 NeedSeek = 0;
1291
1292 if (timer_pending(&fd_timer) && time_before(fd_timer.expires, jiffies + 5))
1293
1294
1295
1296 mod_timer(&fd_timer, jiffies + 5);
1297 else
1298 start_check_change_timer();
1299 start_motor_off_timer();
1300
1301 local_irq_save(flags);
1302 stdma_release();
1303 fdc_busy = 0;
1304 wake_up( &fdc_wait );
1305 local_irq_restore(flags);
1306
1307 DPRINT(("finish_fdc() finished\n"));
1308}
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325static int check_floppy_change(struct gendisk *disk)
1326{
1327 struct atari_floppy_struct *p = disk->private_data;
1328 unsigned int drive = p - unit;
1329 if (test_bit (drive, &fake_change)) {
1330
1331 return 1;
1332 }
1333 if (test_bit (drive, &changed_floppies)) {
1334
1335 return 1;
1336 }
1337 if (UD.wpstat) {
1338
1339
1340
1341 return 1;
1342 }
1343
1344 return 0;
1345}
1346
1347static int floppy_revalidate(struct gendisk *disk)
1348{
1349 struct atari_floppy_struct *p = disk->private_data;
1350 unsigned int drive = p - unit;
1351
1352 if (test_bit(drive, &changed_floppies) ||
1353 test_bit(drive, &fake_change) ||
1354 p->disktype == 0) {
1355 if (UD.flags & FTD_MSG)
1356 printk(KERN_ERR "floppy: clear format %p!\n", UDT);
1357 BufferDrive = -1;
1358 clear_bit(drive, &fake_change);
1359 clear_bit(drive, &changed_floppies);
1360
1361
1362
1363 if (default_params[drive].blocks == 0)
1364 UDT = NULL;
1365 else
1366 UDT = &default_params[drive];
1367 }
1368 return 0;
1369}
1370
1371
1372
1373
1374static void setup_req_params( int drive )
1375{
1376 int block = ReqBlock + ReqCnt;
1377
1378 ReqTrack = block / UDT->spt;
1379 ReqSector = block - ReqTrack * UDT->spt + 1;
1380 ReqSide = ReqTrack & 1;
1381 ReqTrack >>= 1;
1382 ReqData = ReqBuffer + 512 * ReqCnt;
1383
1384 if (UseTrackbuffer)
1385 read_track = (ReqCmd == READ && fd_request->errors == 0);
1386 else
1387 read_track = 0;
1388
1389 DPRINT(("Request params: Si=%d Tr=%d Se=%d Data=%08lx\n",ReqSide,
1390 ReqTrack, ReqSector, (unsigned long)ReqData ));
1391}
1392
1393
1394static void redo_fd_request(void)
1395{
1396 int drive, type;
1397 struct atari_floppy_struct *floppy;
1398
1399 DPRINT(("redo_fd_request: fd_request=%p dev=%s fd_request->sector=%ld\n",
1400 fd_request, fd_request ? fd_request->rq_disk->disk_name : "",
1401 fd_request ? blk_rq_pos(fd_request) : 0 ));
1402
1403 IsFormatting = 0;
1404
1405repeat:
1406 if (!fd_request) {
1407 fd_request = blk_fetch_request(floppy_queue);
1408 if (!fd_request)
1409 goto the_end;
1410 }
1411
1412 floppy = fd_request->rq_disk->private_data;
1413 drive = floppy - unit;
1414 type = floppy->type;
1415
1416 if (!UD.connected) {
1417
1418 printk(KERN_ERR "Unknown Device: fd%d\n", drive );
1419 fd_end_request_cur(-EIO);
1420 goto repeat;
1421 }
1422
1423 if (type == 0) {
1424 if (!UDT) {
1425 Probing = 1;
1426 UDT = atari_disk_type + StartDiskType[DriveType];
1427 set_capacity(floppy->disk, UDT->blocks);
1428 UD.autoprobe = 1;
1429 }
1430 }
1431 else {
1432
1433 if (--type >= NUM_DISK_MINORS) {
1434 printk(KERN_WARNING "fd%d: invalid disk format", drive );
1435 fd_end_request_cur(-EIO);
1436 goto repeat;
1437 }
1438 if (minor2disktype[type].drive_types > DriveType) {
1439 printk(KERN_WARNING "fd%d: unsupported disk format", drive );
1440 fd_end_request_cur(-EIO);
1441 goto repeat;
1442 }
1443 type = minor2disktype[type].index;
1444 UDT = &atari_disk_type[type];
1445 set_capacity(floppy->disk, UDT->blocks);
1446 UD.autoprobe = 0;
1447 }
1448
1449 if (blk_rq_pos(fd_request) + 1 > UDT->blocks) {
1450 fd_end_request_cur(-EIO);
1451 goto repeat;
1452 }
1453
1454
1455 del_timer( &motor_off_timer );
1456
1457 ReqCnt = 0;
1458 ReqCmd = rq_data_dir(fd_request);
1459 ReqBlock = blk_rq_pos(fd_request);
1460 ReqBuffer = fd_request->buffer;
1461 setup_req_params( drive );
1462 do_fd_action( drive );
1463
1464 return;
1465
1466 the_end:
1467 finish_fdc();
1468}
1469
1470
1471void do_fd_request(struct request_queue * q)
1472{
1473 unsigned long flags;
1474
1475 DPRINT(("do_fd_request for pid %d\n",current->pid));
1476 while( fdc_busy ) sleep_on( &fdc_wait );
1477 fdc_busy = 1;
1478 stdma_lock(floppy_irq, NULL);
1479
1480 atari_disable_irq( IRQ_MFP_FDC );
1481 local_save_flags(flags);
1482
1483 redo_fd_request();
1484 local_irq_restore(flags);
1485 atari_enable_irq( IRQ_MFP_FDC );
1486}
1487
1488static int fd_ioctl(struct block_device *bdev, fmode_t mode,
1489 unsigned int cmd, unsigned long param)
1490{
1491 struct gendisk *disk = bdev->bd_disk;
1492 struct atari_floppy_struct *floppy = disk->private_data;
1493 int drive = floppy - unit;
1494 int type = floppy->type;
1495 struct atari_format_descr fmt_desc;
1496 struct atari_disk_type *dtp;
1497 struct floppy_struct getprm;
1498 int settype;
1499 struct floppy_struct setprm;
1500 void __user *argp = (void __user *)param;
1501
1502 switch (cmd) {
1503 case FDGETPRM:
1504 if (type) {
1505 if (--type >= NUM_DISK_MINORS)
1506 return -ENODEV;
1507 if (minor2disktype[type].drive_types > DriveType)
1508 return -ENODEV;
1509 type = minor2disktype[type].index;
1510 dtp = &atari_disk_type[type];
1511 if (UD.flags & FTD_MSG)
1512 printk (KERN_ERR "floppy%d: found dtp %p name %s!\n",
1513 drive, dtp, dtp->name);
1514 }
1515 else {
1516 if (!UDT)
1517 return -ENXIO;
1518 else
1519 dtp = UDT;
1520 }
1521 memset((void *)&getprm, 0, sizeof(getprm));
1522 getprm.size = dtp->blocks;
1523 getprm.sect = dtp->spt;
1524 getprm.head = 2;
1525 getprm.track = dtp->blocks/dtp->spt/2;
1526 getprm.stretch = dtp->stretch;
1527 if (copy_to_user(argp, &getprm, sizeof(getprm)))
1528 return -EFAULT;
1529 return 0;
1530 }
1531 switch (cmd) {
1532 case FDSETPRM:
1533 case FDDEFPRM:
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544 if (floppy->ref != 1 && floppy->ref != -1)
1545 return -EBUSY;
1546 if (copy_from_user(&setprm, argp, sizeof(setprm)))
1547 return -EFAULT;
1548
1549
1550
1551
1552
1553 if (check_floppy_change(disk))
1554 floppy_revalidate(disk);
1555
1556 if (UD.flags & FTD_MSG)
1557 printk (KERN_INFO "floppy%d: setting size %d spt %d str %d!\n",
1558 drive, setprm.size, setprm.sect, setprm.stretch);
1559
1560
1561 if (type) {
1562
1563 redo_fd_request();
1564 return -EINVAL;
1565 }
1566
1567
1568
1569
1570
1571
1572
1573
1574 for (settype = 0; settype < NUM_DISK_MINORS; settype++) {
1575 int setidx = 0;
1576 if (minor2disktype[settype].drive_types > DriveType) {
1577
1578 continue;
1579 }
1580 setidx = minor2disktype[settype].index;
1581 dtp = &atari_disk_type[setidx];
1582
1583
1584 if ( dtp->blocks == setprm.size
1585 && dtp->spt == setprm.sect
1586 && dtp->stretch == setprm.stretch ) {
1587 if (UD.flags & FTD_MSG)
1588 printk (KERN_INFO "floppy%d: setting %s %p!\n",
1589 drive, dtp->name, dtp);
1590 UDT = dtp;
1591 set_capacity(floppy->disk, UDT->blocks);
1592
1593 if (cmd == FDDEFPRM) {
1594
1595 default_params[drive].name = dtp->name;
1596 default_params[drive].spt = dtp->spt;
1597 default_params[drive].blocks = dtp->blocks;
1598 default_params[drive].fdc_speed = dtp->fdc_speed;
1599 default_params[drive].stretch = dtp->stretch;
1600 }
1601
1602 return 0;
1603 }
1604
1605 }
1606
1607
1608
1609 if (cmd == FDDEFPRM) {
1610
1611 dtp = &default_params[drive];
1612 } else
1613
1614 dtp = &user_params[drive];
1615
1616 dtp->name = "user format";
1617 dtp->blocks = setprm.size;
1618 dtp->spt = setprm.sect;
1619 if (setprm.sect > 14)
1620 dtp->fdc_speed = 3;
1621 else
1622 dtp->fdc_speed = 0;
1623 dtp->stretch = setprm.stretch;
1624
1625 if (UD.flags & FTD_MSG)
1626 printk (KERN_INFO "floppy%d: blk %d spt %d str %d!\n",
1627 drive, dtp->blocks, dtp->spt, dtp->stretch);
1628
1629
1630 if (setprm.track != dtp->blocks/dtp->spt/2 ||
1631 setprm.head != 2) {
1632 redo_fd_request();
1633 return -EINVAL;
1634 }
1635
1636 UDT = dtp;
1637 set_capacity(floppy->disk, UDT->blocks);
1638
1639 return 0;
1640 case FDMSGON:
1641 UD.flags |= FTD_MSG;
1642 return 0;
1643 case FDMSGOFF:
1644 UD.flags &= ~FTD_MSG;
1645 return 0;
1646 case FDSETEMSGTRESH:
1647 return -EINVAL;
1648 case FDFMTBEG:
1649 return 0;
1650 case FDFMTTRK:
1651 if (floppy->ref != 1 && floppy->ref != -1)
1652 return -EBUSY;
1653 if (copy_from_user(&fmt_desc, argp, sizeof(fmt_desc)))
1654 return -EFAULT;
1655 return do_format(drive, type, &fmt_desc);
1656 case FDCLRPRM:
1657 UDT = NULL;
1658
1659 default_params[drive].blocks = 0;
1660 set_capacity(floppy->disk, MAX_DISK_SIZE * 2);
1661 case FDFMTEND:
1662 case FDFLUSH:
1663
1664 BufferDrive = -1;
1665 set_bit(drive, &fake_change);
1666 check_disk_change(bdev);
1667 return 0;
1668 default:
1669 return -EINVAL;
1670 }
1671}
1672
1673
1674
1675
1676static void __init fd_probe( int drive )
1677{
1678 UD.connected = 0;
1679 UDT = NULL;
1680
1681 if (!fd_test_drive_present( drive ))
1682 return;
1683
1684 UD.connected = 1;
1685 UD.track = 0;
1686 switch( UserSteprate[drive] ) {
1687 case 2:
1688 UD.steprate = FDCSTEP_2;
1689 break;
1690 case 3:
1691 UD.steprate = FDCSTEP_3;
1692 break;
1693 case 6:
1694 UD.steprate = FDCSTEP_6;
1695 break;
1696 case 12:
1697 UD.steprate = FDCSTEP_12;
1698 break;
1699 default:
1700 if (ATARIHW_PRESENT( FDCSPEED ) || MACH_IS_MEDUSA)
1701 UD.steprate = FDCSTEP_3;
1702 else
1703 UD.steprate = FDCSTEP_6;
1704 break;
1705 }
1706 MotorOn = 1;
1707}
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719static int __init fd_test_drive_present( int drive )
1720{
1721 unsigned long timeout;
1722 unsigned char status;
1723 int ok;
1724
1725 if (drive >= (MACH_IS_FALCON ? 1 : 2)) return( 0 );
1726 fd_select_drive( drive );
1727
1728
1729 atari_turnoff_irq( IRQ_MFP_FDC );
1730 FDC_WRITE (FDCREG_TRACK, 0xff00);
1731 FDC_WRITE( FDCREG_CMD, FDCCMD_RESTORE | FDCCMDADD_H | FDCSTEP_6 );
1732
1733 timeout = jiffies + 2*HZ+HZ/2;
1734 while (time_before(jiffies, timeout))
1735 if (!(st_mfp.par_dt_reg & 0x20))
1736 break;
1737
1738 status = FDC_READ( FDCREG_STATUS );
1739 ok = (status & FDCSTAT_TR00) != 0;
1740
1741
1742
1743 FDC_WRITE( FDCREG_CMD, FDCCMD_FORCI );
1744 udelay(500);
1745 status = FDC_READ( FDCREG_STATUS );
1746 udelay(20);
1747
1748 if (ok) {
1749
1750 FDC_WRITE( FDCREG_DATA, 0 );
1751 FDC_WRITE( FDCREG_CMD, FDCCMD_SEEK );
1752 while( st_mfp.par_dt_reg & 0x20 )
1753 ;
1754 status = FDC_READ( FDCREG_STATUS );
1755 }
1756
1757 atari_turnon_irq( IRQ_MFP_FDC );
1758 return( ok );
1759}
1760
1761
1762
1763
1764
1765
1766static void __init config_types( void )
1767{
1768 int drive, cnt = 0;
1769
1770
1771 if (ATARIHW_PRESENT(FDCSPEED))
1772 dma_wd.fdc_speed = 0;
1773
1774 printk(KERN_INFO "Probing floppy drive(s):\n");
1775 for( drive = 0; drive < FD_MAX_UNITS; drive++ ) {
1776 fd_probe( drive );
1777 if (UD.connected) {
1778 printk(KERN_INFO "fd%d\n", drive);
1779 ++cnt;
1780 }
1781 }
1782
1783 if (FDC_READ( FDCREG_STATUS ) & FDCSTAT_BUSY) {
1784
1785
1786
1787
1788
1789
1790 FDC_WRITE( FDCREG_CMD, FDCCMD_FORCI );
1791 udelay(500);
1792 FDC_READ( FDCREG_STATUS );
1793 udelay(20);
1794 }
1795
1796 if (cnt > 0) {
1797 start_motor_off_timer();
1798 if (cnt == 1) fd_select_drive( 0 );
1799 start_check_change_timer();
1800 }
1801}
1802
1803
1804
1805
1806
1807
1808
1809static int floppy_open(struct block_device *bdev, fmode_t mode)
1810{
1811 struct atari_floppy_struct *p = bdev->bd_disk->private_data;
1812 int type = MINOR(bdev->bd_dev) >> 2;
1813
1814 DPRINT(("fd_open: type=%d\n",type));
1815 if (p->ref && p->type != type)
1816 return -EBUSY;
1817
1818 if (p->ref == -1 || (p->ref && mode & FMODE_EXCL))
1819 return -EBUSY;
1820
1821 if (mode & FMODE_EXCL)
1822 p->ref = -1;
1823 else
1824 p->ref++;
1825
1826 p->type = type;
1827
1828 if (mode & FMODE_NDELAY)
1829 return 0;
1830
1831 if (mode & (FMODE_READ|FMODE_WRITE)) {
1832 check_disk_change(bdev);
1833 if (mode & FMODE_WRITE) {
1834 if (p->wpstat) {
1835 if (p->ref < 0)
1836 p->ref = 0;
1837 else
1838 p->ref--;
1839 return -EROFS;
1840 }
1841 }
1842 }
1843 return 0;
1844}
1845
1846
1847static int floppy_release(struct gendisk *disk, fmode_t mode)
1848{
1849 struct atari_floppy_struct *p = disk->private_data;
1850 if (p->ref < 0)
1851 p->ref = 0;
1852 else if (!p->ref--) {
1853 printk(KERN_ERR "floppy_release with fd_ref == 0");
1854 p->ref = 0;
1855 }
1856 return 0;
1857}
1858
1859static const struct block_device_operations floppy_fops = {
1860 .owner = THIS_MODULE,
1861 .open = floppy_open,
1862 .release = floppy_release,
1863 .locked_ioctl = fd_ioctl,
1864 .media_changed = check_floppy_change,
1865 .revalidate_disk= floppy_revalidate,
1866};
1867
1868static struct kobject *floppy_find(dev_t dev, int *part, void *data)
1869{
1870 int drive = *part & 3;
1871 int type = *part >> 2;
1872 if (drive >= FD_MAX_UNITS || type > NUM_DISK_MINORS)
1873 return NULL;
1874 *part = 0;
1875 return get_disk(unit[drive].disk);
1876}
1877
1878static int __init atari_floppy_init (void)
1879{
1880 int i;
1881
1882 if (!MACH_IS_ATARI)
1883
1884 return -ENODEV;
1885
1886 if (register_blkdev(FLOPPY_MAJOR,"fd"))
1887 return -EBUSY;
1888
1889 for (i = 0; i < FD_MAX_UNITS; i++) {
1890 unit[i].disk = alloc_disk(1);
1891 if (!unit[i].disk)
1892 goto Enomem;
1893 }
1894
1895 if (UseTrackbuffer < 0)
1896
1897
1898
1899
1900 UseTrackbuffer = !MACH_IS_MEDUSA;
1901
1902
1903 SelectedDrive = -1;
1904 BufferDrive = -1;
1905
1906 DMABuffer = atari_stram_alloc(BUFFER_SIZE+512, "ataflop");
1907 if (!DMABuffer) {
1908 printk(KERN_ERR "atari_floppy_init: cannot get dma buffer\n");
1909 goto Enomem;
1910 }
1911 TrackBuffer = DMABuffer + 512;
1912 PhysDMABuffer = virt_to_phys(DMABuffer);
1913 PhysTrackBuffer = virt_to_phys(TrackBuffer);
1914 BufferDrive = BufferSide = BufferTrack = -1;
1915
1916 floppy_queue = blk_init_queue(do_fd_request, &ataflop_lock);
1917 if (!floppy_queue)
1918 goto Enomem;
1919
1920 for (i = 0; i < FD_MAX_UNITS; i++) {
1921 unit[i].track = -1;
1922 unit[i].flags = 0;
1923 unit[i].disk->major = FLOPPY_MAJOR;
1924 unit[i].disk->first_minor = i;
1925 sprintf(unit[i].disk->disk_name, "fd%d", i);
1926 unit[i].disk->fops = &floppy_fops;
1927 unit[i].disk->private_data = &unit[i];
1928 unit[i].disk->queue = floppy_queue;
1929 set_capacity(unit[i].disk, MAX_DISK_SIZE * 2);
1930 add_disk(unit[i].disk);
1931 }
1932
1933 blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE,
1934 floppy_find, NULL, NULL);
1935
1936 printk(KERN_INFO "Atari floppy driver: max. %cD, %strack buffering\n",
1937 DriveType == 0 ? 'D' : DriveType == 1 ? 'H' : 'E',
1938 UseTrackbuffer ? "" : "no ");
1939 config_types();
1940
1941 return 0;
1942Enomem:
1943 while (i--)
1944 put_disk(unit[i].disk);
1945 if (floppy_queue)
1946 blk_cleanup_queue(floppy_queue);
1947 unregister_blkdev(FLOPPY_MAJOR, "fd");
1948 return -ENOMEM;
1949}
1950
1951#ifndef MODULE
1952static int __init atari_floppy_setup(char *str)
1953{
1954 int ints[3 + FD_MAX_UNITS];
1955 int i;
1956
1957 if (!MACH_IS_ATARI)
1958 return 0;
1959
1960 str = get_options(str, 3 + FD_MAX_UNITS, ints);
1961
1962 if (ints[0] < 1) {
1963 printk(KERN_ERR "ataflop_setup: no arguments!\n" );
1964 return 0;
1965 }
1966 else if (ints[0] > 2+FD_MAX_UNITS) {
1967 printk(KERN_ERR "ataflop_setup: too many arguments\n" );
1968 }
1969
1970 if (ints[1] < 0 || ints[1] > 2)
1971 printk(KERN_ERR "ataflop_setup: bad drive type\n" );
1972 else
1973 DriveType = ints[1];
1974
1975 if (ints[0] >= 2)
1976 UseTrackbuffer = (ints[2] > 0);
1977
1978 for( i = 3; i <= ints[0] && i-3 < FD_MAX_UNITS; ++i ) {
1979 if (ints[i] != 2 && ints[i] != 3 && ints[i] != 6 && ints[i] != 12)
1980 printk(KERN_ERR "ataflop_setup: bad steprate\n" );
1981 else
1982 UserSteprate[i-3] = ints[i];
1983 }
1984 return 1;
1985}
1986
1987__setup("floppy=", atari_floppy_setup);
1988#endif
1989
1990static void __exit atari_floppy_exit(void)
1991{
1992 int i;
1993 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
1994 for (i = 0; i < FD_MAX_UNITS; i++) {
1995 del_gendisk(unit[i].disk);
1996 put_disk(unit[i].disk);
1997 }
1998 unregister_blkdev(FLOPPY_MAJOR, "fd");
1999
2000 blk_cleanup_queue(floppy_queue);
2001 del_timer_sync(&fd_timer);
2002 atari_stram_free( DMABuffer );
2003}
2004
2005module_init(atari_floppy_init)
2006module_exit(atari_floppy_exit)
2007
2008MODULE_LICENSE("GPL");
2009