Lines Matching refs:drive
53 * - added trackbuffer for each drive to speed things up
102 #define DSKSEL3 (0x1<<6) /* select drive 3 when low */
103 #define DSKSEL2 (0x1<<5) /* select drive 2 when low */
104 #define DSKSEL1 (0x1<<4) /* select drive 1 when low */
105 #define DSKSEL0 (0x1<<3) /* select drive 0 when low */
176 unsigned long code; /* code returned from drive */
177 char *name; /* description of drive */
199 int disk; /* disk in drive (-1 == unknown) */
201 int busy; /* true when drive is active */
227 #define FD_DD_3 0xffffffff /* double-density 3.5" (880K) drive */
228 #define FD_HD_3 0x55555555 /* high-density 3.5" (1760K) drive */
229 #define FD_DD_5 0xaaaaaaaa /* double-density 5.25" (440K) drive */
244 #define SELMASK(drive) (1 << (3 + (drive & 3)))
281 static volatile int selected = -1; /* currently selected drive */
358 static inline int try_fdc(int drive)
360 drive &= 3;
361 return ((fdc_busy < 0) || (fdc_busy == drive));
364 static void get_fdc(int drive)
368 drive &= 3;
370 printk("get_fdc: drive %d fdc_busy %d fdc_nested %d\n",drive,fdc_busy,fdc_nested);
373 wait_event(fdc_wait, try_fdc(drive));
374 fdc_busy = drive;
393 static void fd_select (int drive)
397 drive&=3;
399 printk("selecting %d\n",drive);
401 if (drive == selected)
403 get_fdc(drive);
404 selected = drive;
406 if (unit[drive].track % 2 != 0)
408 if (unit[drive].motor == 1)
412 prb &= ~SELMASK(drive);
417 static void fd_deselect (int drive)
422 drive&=3;
424 printk("deselecting %d\n",drive);
426 if (drive != selected) {
427 printk(KERN_WARNING "Deselecting drive %d while %d was selected!\n",drive,selected);
431 get_fdc(drive);
480 printk (KERN_WARNING "DSKRDY not set after 1.5 seconds - assuming drive is spinning notwithstanding\n");
489 unsigned long drive = ((unsigned long)timer -
493 drive&=3;
494 if (!try_fdc(drive)) {
500 unit[drive].motor = 0;
501 fd_select(drive);
503 fd_deselect(drive);
508 int drive;
510 drive = nr & 3;
511 mod_timer(motor_off_timer + drive, jiffies + 3*HZ);
514 static int fd_calibrate(int drive)
519 drive &= 3;
520 get_fdc(drive);
521 if (!fd_motor_on (drive))
523 fd_select (drive);
528 for (n = unit[drive].type->tracks/2; n != 0; --n) {
536 ms_delay(unit[drive].type->step_delay);
538 ms_delay (unit[drive].type->settle_time);
540 n = unit[drive].type->tracks + 20;
547 ms_delay(unit[drive].type->step_delay + 1);
551 printk (KERN_ERR "fd%d: calibrate failed, turning motor off\n", drive);
552 fd_motor_off (motor_off_timer + drive);
553 unit[drive].track = -1;
558 unit[drive].track = 0;
559 ms_delay(unit[drive].type->settle_time);
562 fd_deselect(drive);
566 static int fd_seek(int drive, int track)
572 printk("seeking drive %d to track %d\n",drive,track);
574 drive &= 3;
575 get_fdc(drive);
576 if (unit[drive].track == track) {
580 if (!fd_motor_on(drive)) {
584 if (unit[drive].track < 0 && !fd_calibrate(drive)) {
589 fd_select (drive);
590 cnt = unit[drive].track/2 - track/2;
600 if (track % 2 != unit[drive].track % 2)
601 ms_delay (unit[drive].type->side_time);
602 unit[drive].track = track;
605 fd_deselect(drive);
614 ms_delay (unit[drive].type->step_delay);
616 ms_delay (unit[drive].type->settle_time);
619 fd_deselect(drive);
623 static unsigned long fd_get_drive_id(int drive)
628 drive&=3;
629 get_fdc(drive);
633 SELECT(SELMASK(drive));
635 DESELECT(SELMASK(drive));
639 SELECT(SELMASK(drive));
641 DESELECT(SELMASK(drive));
646 SELECT(SELMASK(drive));
653 DESELECT(SELMASK(drive));
660 * As every (real) Amiga has at least a 3.5" DD drive as df0:
664 if(drive == 0 && id == FD_NODRIVE)
667 printk(KERN_NOTICE "fd: drive 0 didn't identify, setting default %08lx\n", (ulong)fd_def_df0);
691 static void raw_read(int drive)
693 drive&=3;
694 get_fdc(drive);
696 fd_select(drive);
705 custom.dsklen = unit[drive].type->read_size/sizeof(short) | DSKLEN_DMAEN;
706 custom.dsklen = unit[drive].type->read_size/sizeof(short) | DSKLEN_DMAEN;
713 fd_deselect(drive);
717 static int raw_write(int drive)
721 drive&=3;
722 get_fdc(drive); /* corresponds to rel_fdc() in post_write() */
728 fd_select(drive);
733 if ((ulong)unit[drive].track >= unit[drive].type->precomp2)
735 else if ((ulong)unit[drive].track >= unit[drive].type->precomp1)
741 custom.dsklen = unit[drive].type->write_size/sizeof(short) | DSKLEN_DMAEN|DSKLEN_WRITE;
742 custom.dsklen = unit[drive].type->write_size/sizeof(short) | DSKLEN_DMAEN|DSKLEN_WRITE;
752 static void post_write (unsigned long drive)
755 printk("post_write for drive %ld\n",drive);
757 drive &= 3;
762 unit[drive].dirty = 0;
764 fd_deselect(drive);
835 static int amiga_read(int drive)
843 drive&=3;
845 end = raw + unit[drive].type->read_size;
847 for (scnt = 0;scnt < unit[drive].dtype->sects * unit[drive].type->sect_mult; scnt++) {
874 if (hdr.track != unit[drive].track) {
875 printk(KERN_INFO "MFM_TRACK: %d, %d\n", hdr.track, unit[drive].track);
879 raw = decode ((ulong *)(unit[drive].trackbuf + hdr.sect*512),
881 csum = checksum((ulong *)(unit[drive].trackbuf + hdr.sect*512), 512);
888 ((ulong *)(unit[drive].trackbuf+hdr.sect*512))[0],
889 ((ulong *)(unit[drive].trackbuf+hdr.sect*512))[1],
890 ((ulong *)(unit[drive].trackbuf+hdr.sect*512))[2],
891 ((ulong *)(unit[drive].trackbuf+hdr.sect*512))[3]);
1150 static int dos_read(int drive)
1158 drive&=3;
1160 end = raw + unit[drive].type->read_size;
1162 for (scnt=0; scnt < unit[drive].dtype->sects * unit[drive].type->sect_mult; scnt++) {
1167 unit[drive].track,drive,scnt);
1188 if (hdr.track != unit[drive].track/unit[drive].type->heads) {
1191 unit[drive].track/unit[drive].type->heads);
1195 if (hdr.side != unit[drive].track%unit[drive].type->heads) {
1198 unit[drive].track%unit[drive].type->heads);
1213 unit[drive].track, drive, scnt, hdr.sec);
1228 raw = dos_decode((unsigned char *)(unit[drive].trackbuf + (hdr.sec - 1) * 512), (ushort *) raw, 512);
1230 crc = dos_data_crc(unit[drive].trackbuf + (hdr.sec - 1) * 512);
1237 ((ulong *)(unit[drive].trackbuf+(hdr.sec-1)*512))[0],
1238 ((ulong *)(unit[drive].trackbuf+(hdr.sec-1)*512))[1],
1239 ((ulong *)(unit[drive].trackbuf+(hdr.sec-1)*512))[2],
1240 ((ulong *)(unit[drive].trackbuf+(hdr.sec-1)*512))[3]);
1271 static unsigned long *ms_putsec(int drive, unsigned long *raw, int cnt)
1278 drive&=3;
1288 hdr.track=unit[drive].track/unit[drive].type->heads;
1289 hdr.side=unit[drive].track%unit[drive].type->heads;
1307 (unsigned char *)unit[drive].trackbuf+cnt*512,512);
1311 crc[0]=dos_data_crc(unit[drive].trackbuf+cnt*512);
1362 /* FIXME: this assumes the drive is still spinning -
1423 static int get_track(int drive, int track)
1427 drive&=3;
1428 if (unit[drive].track == track)
1430 get_fdc(drive);
1431 if (!fd_motor_on(drive)) {
1436 if (unit[drive].dirty == 1) {
1437 del_timer (flush_track_timer + drive);
1438 non_int_flush_track (drive);
1442 if (!fd_seek(drive, track))
1444 raw_read(drive);
1445 error = (*unit[drive].dtype->read_fkt)(drive);
1451 unit[drive].track = -1;
1461 int drive = floppy - unit;
1480 if (get_track(drive, track) == -1)
1488 /* keep the drive spinning while writes are scheduled */
1489 if (!fd_motor_on(drive))
1497 mod_timer (flush_track_timer + drive, jiffies + 1);
1527 int drive = MINOR(bdev->bd_dev) & 3;
1529 geo->heads = unit[drive].type->heads;
1530 geo->sectors = unit[drive].dtype->sects * unit[drive].type->sect_mult;
1531 geo->cylinders = unit[drive].type->tracks;
1539 int drive = p - unit;
1545 get_fdc(drive);
1546 if (fd_ref[drive] > 1) {
1550 if (fd_motor_on(drive) == 0) {
1554 if (fd_calibrate(drive) == 0) {
1558 floppy_off(drive);
1564 get_fdc(drive);
1565 if (fd_seek(drive,param) != 0){
1568 non_int_flush_track(drive);
1570 floppy_off(drive);
1577 floppy_off(drive);
1593 del_timer (flush_track_timer + drive);
1594 non_int_flush_track(drive);
1625 int drive;
1627 drive = dev & 3;
1628 code = fd_get_drive_id(drive);
1630 /* get drive type */
1636 printk(KERN_WARNING "fd_probe: unsupported drive type "
1638 unit[drive].type = &drive_types[num_dr_types-1]; /* FD_NODRIVE */
1642 unit[drive].type = drive_types + type;
1643 unit[drive].track = -1;
1645 unit[drive].disk = -1;
1646 unit[drive].motor = 0;
1647 unit[drive].busy = 0;
1648 unit[drive].status = -1;
1654 * drive with different device numbers.
1658 int drive = disk->first_minor & 3;
1664 old_dev = fd_device[drive];
1666 if (fd_ref[drive] && old_dev != system) {
1671 if (unit[drive].type->code == FD_NODRIVE) {
1680 get_fdc(drive);
1681 fd_select (drive);
1683 fd_deselect (drive);
1693 fd_ref[drive]++;
1694 fd_device[drive] = system;
1697 unit[drive].dtype=&data_types[system];
1698 unit[drive].blocks=unit[drive].type->heads*unit[drive].type->tracks*
1699 data_types[system].sects*unit[drive].type->sect_mult;
1700 set_capacity(unit[drive].gendisk[system], unit[drive].blocks);
1702 printk(KERN_INFO "fd%d: accessing %s-disk with %s-layout\n",drive,
1703 unit[drive].type->name, data_types[system].name);
1712 int drive = p - unit;
1715 if (unit[drive].dirty == 1) {
1716 del_timer (flush_track_timer + drive);
1717 non_int_flush_track (drive);
1720 if (!fd_ref[drive]--) {
1722 fd_ref[drive] = 0;
1725 floppy_off (drive);
1733 * to the desired drive, but it will probably not survive the sleep if
1739 int drive = p - unit;
1746 get_fdc(drive);
1747 fd_select (drive);
1749 fd_deselect (drive);
1754 fd_probe(drive);
1777 static int fd_alloc_disk(int drive, int system)
1782 disk = blk_mq_alloc_disk(&unit[drive].tag_set, NULL);
1787 disk->first_minor = drive + system;
1793 sprintf(disk->disk_name, "fd%d_msdos", drive);
1795 sprintf(disk->disk_name, "fd%d", drive);
1796 disk->private_data = &unit[drive];
1799 unit[drive].gendisk[system] = disk;
1806 static int fd_alloc_drive(int drive)
1808 unit[drive].trackbuf = kmalloc(FLOPPY_MAX_SECTORS * 512, GFP_KERNEL);
1809 if (!unit[drive].trackbuf)
1812 memset(&unit[drive].tag_set, 0, sizeof(unit[drive].tag_set));
1813 unit[drive].tag_set.ops = &amiflop_mq_ops;
1814 unit[drive].tag_set.nr_hw_queues = 1;
1815 unit[drive].tag_set.nr_maps = 1;
1816 unit[drive].tag_set.queue_depth = 2;
1817 unit[drive].tag_set.numa_node = NUMA_NO_NODE;
1818 unit[drive].tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
1819 if (blk_mq_alloc_tag_set(&unit[drive].tag_set))
1822 pr_cont(" fd%d", drive);
1824 if (fd_alloc_disk(drive, 0) || fd_alloc_disk(drive, 1))
1829 blk_mq_free_tag_set(&unit[drive].tag_set);
1831 kfree(unit[drive].trackbuf);
1833 unit[drive].type->code = FD_NODRIVE;
1839 int drive,drives,nomem;
1844 for(drive=0;drive<FD_MAX_UNITS;drive++) {
1845 fd_probe(drive);
1846 if (unit[drive].type->code == FD_NODRIVE)
1849 if (fd_alloc_drive(drive) < 0) {
1850 pr_cont(" no mem for fd%d", drive);