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 */
245 #define SELMASK(drive) (1 << (3 + (drive & 3)))
282 static volatile int selected = -1; /* currently selected drive */
359 static inline int try_fdc(int drive)
361 drive &= 3;
362 return ((fdc_busy < 0) || (fdc_busy == drive));
365 static void get_fdc(int drive)
369 drive &= 3;
371 printk("get_fdc: drive %d fdc_busy %d fdc_nested %d\n",drive,fdc_busy,fdc_nested);
374 wait_event(fdc_wait, try_fdc(drive));
375 fdc_busy = drive;
394 static void fd_select (int drive)
398 drive&=3;
400 printk("selecting %d\n",drive);
402 if (drive == selected)
404 get_fdc(drive);
405 selected = drive;
407 if (unit[drive].track % 2 != 0)
409 if (unit[drive].motor == 1)
413 prb &= ~SELMASK(drive);
418 static void fd_deselect (int drive)
423 drive&=3;
425 printk("deselecting %d\n",drive);
427 if (drive != selected) {
428 printk(KERN_WARNING "Deselecting drive %d while %d was selected!\n",drive,selected);
432 get_fdc(drive);
481 printk (KERN_WARNING "DSKRDY not set after 1.5 seconds - assuming drive is spinning notwithstanding\n");
490 unsigned long drive = ((unsigned long)timer -
494 drive&=3;
495 if (!try_fdc(drive)) {
501 unit[drive].motor = 0;
502 fd_select(drive);
504 fd_deselect(drive);
509 int drive;
511 drive = nr & 3;
512 mod_timer(motor_off_timer + drive, jiffies + 3*HZ);
515 static int fd_calibrate(int drive)
520 drive &= 3;
521 get_fdc(drive);
522 if (!fd_motor_on (drive))
524 fd_select (drive);
529 for (n = unit[drive].type->tracks/2; n != 0; --n) {
537 ms_delay(unit[drive].type->step_delay);
539 ms_delay (unit[drive].type->settle_time);
541 n = unit[drive].type->tracks + 20;
548 ms_delay(unit[drive].type->step_delay + 1);
552 printk (KERN_ERR "fd%d: calibrate failed, turning motor off\n", drive);
553 fd_motor_off (motor_off_timer + drive);
554 unit[drive].track = -1;
559 unit[drive].track = 0;
560 ms_delay(unit[drive].type->settle_time);
563 fd_deselect(drive);
567 static int fd_seek(int drive, int track)
573 printk("seeking drive %d to track %d\n",drive,track);
575 drive &= 3;
576 get_fdc(drive);
577 if (unit[drive].track == track) {
581 if (!fd_motor_on(drive)) {
585 if (unit[drive].track < 0 && !fd_calibrate(drive)) {
590 fd_select (drive);
591 cnt = unit[drive].track/2 - track/2;
601 if (track % 2 != unit[drive].track % 2)
602 ms_delay (unit[drive].type->side_time);
603 unit[drive].track = track;
606 fd_deselect(drive);
615 ms_delay (unit[drive].type->step_delay);
617 ms_delay (unit[drive].type->settle_time);
620 fd_deselect(drive);
624 static unsigned long fd_get_drive_id(int drive)
629 drive&=3;
630 get_fdc(drive);
634 SELECT(SELMASK(drive));
636 DESELECT(SELMASK(drive));
640 SELECT(SELMASK(drive));
642 DESELECT(SELMASK(drive));
647 SELECT(SELMASK(drive));
654 DESELECT(SELMASK(drive));
661 * As every (real) Amiga has at least a 3.5" DD drive as df0:
665 if(drive == 0 && id == FD_NODRIVE)
668 printk(KERN_NOTICE "fd: drive 0 didn't identify, setting default %08lx\n", (ulong)fd_def_df0);
692 static void raw_read(int drive)
694 drive&=3;
695 get_fdc(drive);
697 fd_select(drive);
706 custom.dsklen = unit[drive].type->read_size/sizeof(short) | DSKLEN_DMAEN;
707 custom.dsklen = unit[drive].type->read_size/sizeof(short) | DSKLEN_DMAEN;
714 fd_deselect(drive);
718 static int raw_write(int drive)
722 drive&=3;
723 get_fdc(drive); /* corresponds to rel_fdc() in post_write() */
729 fd_select(drive);
734 if ((ulong)unit[drive].track >= unit[drive].type->precomp2)
736 else if ((ulong)unit[drive].track >= unit[drive].type->precomp1)
742 custom.dsklen = unit[drive].type->write_size/sizeof(short) | DSKLEN_DMAEN|DSKLEN_WRITE;
743 custom.dsklen = unit[drive].type->write_size/sizeof(short) | DSKLEN_DMAEN|DSKLEN_WRITE;
753 static void post_write (unsigned long drive)
756 printk("post_write for drive %ld\n",drive);
758 drive &= 3;
763 unit[drive].dirty = 0;
765 fd_deselect(drive);
836 static int amiga_read(int drive)
844 drive&=3;
846 end = raw + unit[drive].type->read_size;
848 for (scnt = 0;scnt < unit[drive].dtype->sects * unit[drive].type->sect_mult; scnt++) {
875 if (hdr.track != unit[drive].track) {
876 printk(KERN_INFO "MFM_TRACK: %d, %d\n", hdr.track, unit[drive].track);
880 raw = decode ((ulong *)(unit[drive].trackbuf + hdr.sect*512),
882 csum = checksum((ulong *)(unit[drive].trackbuf + hdr.sect*512), 512);
889 ((ulong *)(unit[drive].trackbuf+hdr.sect*512))[0],
890 ((ulong *)(unit[drive].trackbuf+hdr.sect*512))[1],
891 ((ulong *)(unit[drive].trackbuf+hdr.sect*512))[2],
892 ((ulong *)(unit[drive].trackbuf+hdr.sect*512))[3]);
1151 static int dos_read(int drive)
1159 drive&=3;
1161 end = raw + unit[drive].type->read_size;
1163 for (scnt=0; scnt < unit[drive].dtype->sects * unit[drive].type->sect_mult; scnt++) {
1168 unit[drive].track,drive,scnt);
1189 if (hdr.track != unit[drive].track/unit[drive].type->heads) {
1192 unit[drive].track/unit[drive].type->heads);
1196 if (hdr.side != unit[drive].track%unit[drive].type->heads) {
1199 unit[drive].track%unit[drive].type->heads);
1214 unit[drive].track, drive, scnt, hdr.sec);
1229 raw = dos_decode((unsigned char *)(unit[drive].trackbuf + (hdr.sec - 1) * 512), (ushort *) raw, 512);
1231 crc = dos_data_crc(unit[drive].trackbuf + (hdr.sec - 1) * 512);
1238 ((ulong *)(unit[drive].trackbuf+(hdr.sec-1)*512))[0],
1239 ((ulong *)(unit[drive].trackbuf+(hdr.sec-1)*512))[1],
1240 ((ulong *)(unit[drive].trackbuf+(hdr.sec-1)*512))[2],
1241 ((ulong *)(unit[drive].trackbuf+(hdr.sec-1)*512))[3]);
1272 static unsigned long *ms_putsec(int drive, unsigned long *raw, int cnt)
1279 drive&=3;
1289 hdr.track=unit[drive].track/unit[drive].type->heads;
1290 hdr.side=unit[drive].track%unit[drive].type->heads;
1308 (unsigned char *)unit[drive].trackbuf+cnt*512,512);
1312 crc[0]=dos_data_crc(unit[drive].trackbuf+cnt*512);
1363 /* FIXME: this assumes the drive is still spinning -
1424 static int get_track(int drive, int track)
1428 drive&=3;
1429 if (unit[drive].track == track)
1431 get_fdc(drive);
1432 if (!fd_motor_on(drive)) {
1437 if (unit[drive].dirty == 1) {
1438 del_timer (flush_track_timer + drive);
1439 non_int_flush_track (drive);
1443 if (!fd_seek(drive, track))
1445 raw_read(drive);
1446 error = (*unit[drive].dtype->read_fkt)(drive);
1452 unit[drive].track = -1;
1462 int drive = floppy - unit;
1481 if (get_track(drive, track) == -1)
1489 /* keep the drive spinning while writes are scheduled */
1490 if (!fd_motor_on(drive))
1498 mod_timer (flush_track_timer + drive, jiffies + 1);
1528 int drive = MINOR(bdev->bd_dev) & 3;
1530 geo->heads = unit[drive].type->heads;
1531 geo->sectors = unit[drive].dtype->sects * unit[drive].type->sect_mult;
1532 geo->cylinders = unit[drive].type->tracks;
1540 int drive = p - unit;
1546 get_fdc(drive);
1547 if (fd_ref[drive] > 1) {
1551 if (fd_motor_on(drive) == 0) {
1555 if (fd_calibrate(drive) == 0) {
1559 floppy_off(drive);
1565 get_fdc(drive);
1566 if (fd_seek(drive,param) != 0){
1569 non_int_flush_track(drive);
1571 floppy_off(drive);
1578 floppy_off(drive);
1594 del_timer (flush_track_timer + drive);
1595 non_int_flush_track(drive);
1626 int drive;
1628 drive = dev & 3;
1629 code = fd_get_drive_id(drive);
1631 /* get drive type */
1637 printk(KERN_WARNING "fd_probe: unsupported drive type "
1639 unit[drive].type = &drive_types[num_dr_types-1]; /* FD_NODRIVE */
1643 unit[drive].type = drive_types + type;
1644 unit[drive].track = -1;
1646 unit[drive].disk = -1;
1647 unit[drive].motor = 0;
1648 unit[drive].busy = 0;
1649 unit[drive].status = -1;
1655 * drive with different device numbers.
1659 int drive = disk->first_minor & 3;
1665 old_dev = fd_device[drive];
1667 if (fd_ref[drive] && old_dev != system) {
1672 if (unit[drive].type->code == FD_NODRIVE) {
1681 get_fdc(drive);
1682 fd_select (drive);
1684 fd_deselect (drive);
1694 fd_ref[drive]++;
1695 fd_device[drive] = system;
1698 unit[drive].dtype=&data_types[system];
1699 unit[drive].blocks=unit[drive].type->heads*unit[drive].type->tracks*
1700 data_types[system].sects*unit[drive].type->sect_mult;
1701 set_capacity(unit[drive].gendisk[system], unit[drive].blocks);
1703 printk(KERN_INFO "fd%d: accessing %s-disk with %s-layout\n",drive,
1704 unit[drive].type->name, data_types[system].name);
1713 int drive = p - unit;
1716 if (unit[drive].dirty == 1) {
1717 del_timer (flush_track_timer + drive);
1718 non_int_flush_track (drive);
1721 if (!fd_ref[drive]--) {
1723 fd_ref[drive] = 0;
1726 floppy_off (drive);
1734 * to the desired drive, but it will probably not survive the sleep if
1740 int drive = p - unit;
1747 get_fdc(drive);
1748 fd_select (drive);
1750 fd_deselect (drive);
1755 fd_probe(drive);
1778 static int fd_alloc_disk(int drive, int system)
1786 disk = blk_mq_alloc_disk(&unit[drive].tag_set, &lim, NULL);
1791 disk->first_minor = drive + system;
1797 sprintf(disk->disk_name, "fd%d_msdos", drive);
1799 sprintf(disk->disk_name, "fd%d", drive);
1800 disk->private_data = &unit[drive];
1803 unit[drive].gendisk[system] = disk;
1810 static int fd_alloc_drive(int drive)
1812 unit[drive].trackbuf = kmalloc(FLOPPY_MAX_SECTORS * 512, GFP_KERNEL);
1813 if (!unit[drive].trackbuf)
1816 memset(&unit[drive].tag_set, 0, sizeof(unit[drive].tag_set));
1817 unit[drive].tag_set.ops = &amiflop_mq_ops;
1818 unit[drive].tag_set.nr_hw_queues = 1;
1819 unit[drive].tag_set.nr_maps = 1;
1820 unit[drive].tag_set.queue_depth = 2;
1821 unit[drive].tag_set.numa_node = NUMA_NO_NODE;
1822 if (blk_mq_alloc_tag_set(&unit[drive].tag_set))
1825 pr_cont(" fd%d", drive);
1827 if (fd_alloc_disk(drive, 0) || fd_alloc_disk(drive, 1))
1832 blk_mq_free_tag_set(&unit[drive].tag_set);
1834 kfree(unit[drive].trackbuf);
1836 unit[drive].type->code = FD_NODRIVE;
1842 int drive,drives,nomem;
1847 for(drive=0;drive<FD_MAX_UNITS;drive++) {
1848 fd_probe(drive);
1849 if (unit[drive].type->code == FD_NODRIVE)
1852 if (fd_alloc_drive(drive) < 0) {
1853 pr_cont(" no mem for fd%d", drive);