2 * Copyright (C) 1993-1996 Bas Laarhoven,
3 * (C) 1996-1997 Claus-Justus Heine.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; see the file COPYING. If not, write to
17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
20 * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/fdc-io.c,v $
21 * $Revision: 1.7.4.2 $
22 * $Date: 1997/11/16 14:48:17 $
24 * This file contains the low-level floppy disk interface code
25 * for the QIC-40/80/3010/3020 floppy-tape driver "ftape" for
29 #include <linux/config.h> /* for CONFIG_FT_* */
30 #include <linux/errno.h>
31 #include <linux/sched.h>
32 #include <linux/ioport.h>
33 #include <linux/interrupt.h>
34 #include <linux/kernel.h>
35 #include <asm/system.h>
40 #include <linux/ftape.h>
41 #include <linux/qic117.h>
42 #include "../lowlevel/ftape-tracing.h"
43 #include "../lowlevel/fdc-io.h"
44 #include "../lowlevel/fdc-isr.h"
45 #include "../lowlevel/ftape-io.h"
46 #include "../lowlevel/ftape-rw.h"
47 #include "../lowlevel/ftape-ctl.h"
48 #include "../lowlevel/ftape-calibr.h"
49 #include "../lowlevel/fc-10.h"
54 volatile int ftape_current_cylinder = -1;
55 volatile fdc_mode_enum fdc_mode = fdc_idle;
57 DECLARE_WAIT_QUEUE_HEAD(ftape_wait_intr);
59 unsigned int ft_fdc_base = CONFIG_FT_FDC_BASE;
60 unsigned int ft_fdc_irq = CONFIG_FT_FDC_IRQ;
61 unsigned int ft_fdc_dma = CONFIG_FT_FDC_DMA;
62 unsigned int ft_fdc_threshold = CONFIG_FT_FDC_THR; /* bytes */
63 unsigned int ft_fdc_rate_limit = CONFIG_FT_FDC_MAX_RATE; /* bits/sec */
64 int ft_probe_fc10 = CONFIG_FT_PROBE_FC10;
65 int ft_mach2 = CONFIG_FT_MACH2;
69 static spinlock_t fdc_io_lock;
70 static unsigned int fdc_calibr_count;
71 static unsigned int fdc_calibr_time;
72 static int fdc_status;
73 volatile __u8 fdc_head; /* FDC head from sector id */
74 volatile __u8 fdc_cyl; /* FDC track from sector id */
75 volatile __u8 fdc_sect; /* FDC sector from sector id */
76 static int fdc_data_rate = 500; /* data rate (Kbps) */
77 static int fdc_rate_code; /* data rate code (0 == 500 Kbps) */
78 static int fdc_seek_rate = 2; /* step rate (msec) */
79 static void (*do_ftape) (void);
80 static int fdc_fifo_state; /* original fifo setting - fifo enabled */
81 static int fdc_fifo_thr; /* original fifo setting - threshold */
82 static int fdc_lock_state; /* original lock setting - locked */
83 static int fdc_fifo_locked; /* has fifo && lock set ? */
84 static __u8 fdc_precomp; /* default precomp. value (nsec) */
85 static __u8 fdc_prec_code; /* fdc precomp. select code */
87 static char ftape_id[] = "ftape"; /* used by request irq and free irq */
89 void fdc_catch_stray_interrupts(int count)
93 spin_lock_irqsave(&fdc_io_lock, flags);
95 ft_expected_stray_interrupts = 0;
97 ft_expected_stray_interrupts += count;
99 spin_unlock_irqrestore(&fdc_io_lock, flags);
102 /* Wait during a timeout period for a given FDC status.
103 * If usecs == 0 then just test status, else wait at least for usecs.
104 * Returns -ETIME on timeout. Function must be calibrated first !
106 int fdc_wait(unsigned int usecs, __u8 mask, __u8 state)
108 int count_1 = (fdc_calibr_count * usecs +
109 fdc_calibr_count - 1) / fdc_calibr_time;
112 fdc_status = inb_p(fdc.msr);
113 if ((fdc_status & mask) == state) {
116 } while (count_1-- >= 0);
120 int fdc_ready_wait(unsigned int usecs)
122 return fdc_wait(usecs, FDC_DATA_READY | FDC_BUSY, FDC_DATA_READY);
125 /* Why can't we just use udelay()?
127 static void fdc_usec_wait(unsigned int usecs)
129 fdc_wait(usecs, 0, 1); /* will always timeout ! */
132 int fdc_ready_out_wait(unsigned int usecs)
134 fdc_usec_wait(FT_RQM_DELAY); /* wait for valid RQM status */
135 return fdc_wait(usecs, FDC_DATA_OUT_READY, FDC_DATA_OUT_READY);
138 int fdc_ready_in_wait(unsigned int usecs)
140 fdc_usec_wait(FT_RQM_DELAY); /* wait for valid RQM status */
141 return fdc_wait(usecs, FDC_DATA_OUT_READY, FDC_DATA_IN_READY);
144 void fdc_wait_calibrate(void)
146 ftape_calibrate("fdc_wait",
147 fdc_usec_wait, &fdc_calibr_count, &fdc_calibr_time);
150 /* Wait for a (short) while for the FDC to become ready
151 * and transfer the next command byte.
152 * Return -ETIME on timeout on getting ready (depends on hardware!).
154 static int fdc_write(const __u8 data)
156 fdc_usec_wait(FT_RQM_DELAY); /* wait for valid RQM status */
157 if (fdc_wait(150, FDC_DATA_READY_MASK, FDC_DATA_IN_READY) < 0) {
160 outb(data, fdc.fifo);
165 /* Wait for a (short) while for the FDC to become ready
166 * and transfer the next result byte.
167 * Return -ETIME if timeout on getting ready (depends on hardware!).
169 static int fdc_read(__u8 * data)
171 fdc_usec_wait(FT_RQM_DELAY); /* wait for valid RQM status */
172 if (fdc_wait(150, FDC_DATA_READY_MASK, FDC_DATA_OUT_READY) < 0) {
175 *data = inb(fdc.fifo);
180 /* Output a cmd_len long command string to the FDC.
181 * The FDC should be ready to receive a new command or
182 * an error (EBUSY or ETIME) will occur.
184 int fdc_command(const __u8 * cmd_data, int cmd_len)
191 static unsigned int last_time;
196 fdc_usec_wait(FT_RQM_DELAY); /* wait for valid RQM status */
197 spin_lock_irqsave(&fdc_io_lock, flags);
199 /* Yes, I know, too much comments inside this function
202 * Yet another bug in the original driver. All that
203 * havoc is caused by the fact that the isr() sends
204 * itself a command to the floppy tape driver (pause,
205 * micro step pause). Now, the problem is that
206 * commands are transmitted via the fdc_seek
207 * command. But: the fdc performs seeks in the
208 * background i.e. it doesn't signal busy while
209 * sending the step pulses to the drive. Therefore the
210 * non-interrupt level driver has no chance to tell
211 * whether the isr() just has issued a seek. Therefore
212 * we HAVE TO have a look at the ft_hide_interrupt
213 * flag: it signals the non-interrupt level part of
214 * the driver that it has to wait for the fdc until it
215 * has completet seeking.
217 * THIS WAS PRESUMABLY THE REASON FOR ALL THAT
218 * "fdc_read timeout" errors, I HOPE :-)
220 if (ft_hide_interrupt) {
221 restore_flags(flags);
223 "Waiting for the isr() completing fdc_seek()");
224 if (fdc_interrupt_wait(2 * FT_SECOND) < 0) {
226 "Warning: timeout waiting for isr() seek to complete");
228 if (ft_hide_interrupt || !ft_seek_completed) {
229 /* There cannot be another
230 * interrupt. The isr() only stops
231 * the tape and the next interrupt
232 * won't come until we have send our
233 * command to the drive.
235 TRACE_ABORT(-EIO, ft_t_bug,
236 "BUG? isr() is still seeking?\n"
237 KERN_INFO "hide: %d\n"
238 KERN_INFO "seek: %d",
243 fdc_usec_wait(FT_RQM_DELAY); /* wait for valid RQM status */
244 spin_lock_irqsave(&fdc_io_lock, flags);
246 fdc_status = inb(fdc.msr);
247 if ((fdc_status & FDC_DATA_READY_MASK) != FDC_DATA_IN_READY) {
248 spin_unlock_irqrestore(&fdc_io_lock, flags);
249 TRACE_ABORT(-EBUSY, ft_t_err, "fdc not ready");
251 fdc_mode = *cmd_data; /* used by isr */
253 if (fdc_mode == FDC_SEEK) {
254 time = ftape_timediff(last_time, ftape_timestamp());
256 TRACE(ft_t_bug,"Warning: short timeout between seek commands: %d",
261 if (!in_interrupt()) {
262 /* shouldn't be cleared if called from isr
264 ft_interrupt_seen = 0;
267 result = fdc_write(*cmd_data);
270 "fdc_mode = %02x, status = %02x at index %d",
271 (int) fdc_mode, (int) fdc_status,
274 TRACE(ft_t_warn, "fdc_write timeout, retry");
276 TRACE(ft_t_err, "fdc_write timeout, fatal");
286 if (fdc_mode == FDC_SEEK) {
287 last_time = ftape_timestamp();
290 spin_unlock_irqrestore(&fdc_io_lock, flags);
294 /* Input a res_len long result string from the FDC.
295 * The FDC should be ready to send the result or an error
296 * (EBUSY or ETIME) will occur.
298 int fdc_result(__u8 * res_data, int res_len)
306 spin_lock_irqsave(&fdc_io_lock, flags);
307 fdc_status = inb(fdc.msr);
308 if ((fdc_status & FDC_DATA_READY_MASK) != FDC_DATA_OUT_READY) {
309 TRACE(ft_t_err, "fdc not ready");
311 } else while (count) {
312 if (!(fdc_status & FDC_BUSY)) {
313 spin_unlock_irqrestore(&fdc_io_lock, flags);
314 TRACE_ABORT(-EIO, ft_t_err, "premature end of result phase");
316 result = fdc_read(res_data);
319 "fdc_mode = %02x, status = %02x at index %d",
324 TRACE(ft_t_warn, "fdc_read timeout, retry");
326 TRACE(ft_t_err, "fdc_read timeout, fatal");
336 spin_unlock_irqrestore(&fdc_io_lock, flags);
337 fdc_usec_wait(FT_RQM_DELAY); /* allow FDC to negate BSY */
341 /* Handle command and result phases for
342 * commands without data phase.
344 int fdc_issue_command(const __u8 * out_data, int out_count,
345 __u8 * in_data, int in_count)
350 TRACE_CATCH(fdc_command(out_data, out_count),);
352 /* will take 24 - 30 usec for fdc_sense_drive_status and
353 * fdc_sense_interrupt_status commands.
354 * 35 fails sometimes (5/9/93 SJL)
355 * On a loaded system it incidentally takes longer than
356 * this for the fdc to get ready ! ?????? WHY ??????
357 * So until we know what's going on use a very long timeout.
359 TRACE_CATCH(fdc_ready_out_wait(500 /* usec */),);
361 TRACE_CATCH(fdc_result(in_data, in_count),
362 TRACE(ft_t_err, "result phase aborted"));
367 /* Wait for FDC interrupt with timeout (in milliseconds).
368 * Signals are blocked so the wait will not be aborted.
369 * Note: interrupts must be enabled ! (23/05/93 SJL)
371 int fdc_interrupt_wait(unsigned int time)
373 DECLARE_WAITQUEUE(wait,current);
374 sigset_t old_sigmask;
375 static int resetting;
378 TRACE_FUN(ft_t_fdc_dma);
380 if (waitqueue_active(&ftape_wait_intr)) {
381 TRACE_ABORT(-EIO, ft_t_err, "error: nested call");
383 /* timeout time will be up to USPT microseconds too long ! */
384 timeout = (1000 * time + FT_USPT - 1) / FT_USPT;
386 spin_lock_irq(¤t->sighand->siglock);
387 old_sigmask = current->blocked;
388 sigfillset(¤t->blocked);
390 spin_unlock_irq(¤t->sighand->siglock);
392 set_current_state(TASK_INTERRUPTIBLE);
393 add_wait_queue(&ftape_wait_intr, &wait);
394 while (!ft_interrupt_seen && (current->state == TASK_INTERRUPTIBLE)) {
395 timeout = schedule_timeout(timeout);
398 spin_lock_irq(¤t->sighand->siglock);
399 current->blocked = old_sigmask;
401 spin_unlock_irq(¤t->sighand->siglock);
403 remove_wait_queue(&ftape_wait_intr, &wait);
404 /* the following IS necessary. True: as well
405 * wake_up_interruptible() as the schedule() set TASK_RUNNING
406 * when they wakeup a task, BUT: it may very well be that
407 * ft_interrupt_seen is already set to 1 when we enter here
408 * in which case schedule() gets never called, and
409 * TASK_RUNNING never set. This has the funny effect that we
410 * execute all the code until we leave kernel space, but then
411 * the task is stopped (a task CANNOT be preempted while in
412 * kernel mode. Sending a pair of SIGSTOP/SIGCONT to the
413 * tasks wakes it up again. Funny! :-)
415 current->state = TASK_RUNNING;
416 if (ft_interrupt_seen) { /* woken up by interrupt */
417 ft_interrupt_seen = 0;
421 * In first instance, next statement seems unnecessary since
422 * it will be cleared in fdc_command. However, a small part of
423 * the software seems to rely on this being cleared here
424 * (ftape_close might fail) so stick to it until things get fixed !
426 /* My deeply sought of knowledge:
427 * Behold NO! It is obvious. fdc_reset() doesn't call fdc_command()
428 * but nevertheless uses fdc_interrupt_wait(). OF COURSE this needs to
431 ft_interrupt_seen = 0; /* clear for next call */
433 resetting = 1; /* break infinite recursion if reset fails */
434 TRACE(ft_t_any, "cleanup reset");
438 TRACE_EXIT (signal_pending(current)) ? -EINTR : -ETIME;
441 /* Start/stop drive motor. Enable DMA mode.
443 void fdc_motor(int motor)
445 int unit = ft_drive_sel;
446 int data = unit | FDC_RESET_NOT | FDC_DMA_MODE;
451 data |= FDC_MOTOR_0 << unit;
452 TRACE(ft_t_noise, "turning motor %d on", unit);
454 TRACE(ft_t_noise, "turning motor %d off", unit);
457 outb_p(data, fdc.dor2);
459 outb_p(data, fdc.dor);
461 ftape_sleep(10 * FT_MILLISECOND);
465 static void fdc_update_dsr(void)
469 TRACE(ft_t_flow, "rate = %d Kbps, precomp = %d ns",
470 fdc_data_rate, fdc_precomp);
471 if (fdc.type >= i82077) {
472 outb_p((fdc_rate_code & 0x03) | fdc_prec_code, fdc.dsr);
474 outb_p(fdc_rate_code & 0x03, fdc.ccr);
479 void fdc_set_write_precomp(int precomp)
483 TRACE(ft_t_noise, "New precomp: %d nsec", precomp);
484 fdc_precomp = precomp;
485 /* write precompensation can be set in multiples of 41.67 nsec.
486 * round the parameter to the nearest multiple and convert it
487 * into a fdc setting. Note that 0 means default to the fdc,
488 * 7 is used instead of that.
490 fdc_prec_code = ((fdc_precomp + 21) / 42) << 2;
491 if (fdc_prec_code == 0 || fdc_prec_code > (6 << 2)) {
492 fdc_prec_code = 7 << 2;
498 /* Reprogram the 82078 registers to use Data Rate Table 1 on all drives.
500 void fdc_set_drive_specs(void)
502 __u8 cmd[] = { FDC_DRIVE_SPEC, 0x00, 0x00, 0x00, 0x00, 0xc0};
506 TRACE(ft_t_flow, "Setting of drive specs called");
507 if (fdc.type >= i82078_1) {
508 cmd[1] = (0 << 5) | (2 << 2);
509 cmd[2] = (1 << 5) | (2 << 2);
510 cmd[3] = (2 << 5) | (2 << 2);
511 cmd[4] = (3 << 5) | (2 << 2);
512 result = fdc_command(cmd, NR_ITEMS(cmd));
514 TRACE(ft_t_err, "Setting of drive specs failed");
520 /* Select clock for fdc, must correspond with tape drive setting !
521 * This also influences the fdc timing so we must adjust some values.
523 int fdc_set_data_rate(int rate)
528 /* Select clock for fdc, must correspond with tape drive setting !
529 * This also influences the fdc timing so we must adjust some values.
531 TRACE(ft_t_fdc_dma, "new rate = %d", rate);
534 fdc_rate_code = fdc_data_rate_250;
537 fdc_rate_code = fdc_data_rate_500;
540 if (fdc.type < i82077) {
543 fdc_rate_code = fdc_data_rate_1000;
547 if (fdc.type < i82078_1) {
550 fdc_rate_code = fdc_data_rate_2000;
558 ft_t_fdc_dma, "%d is not a valid data rate", rate);
560 fdc_data_rate = rate;
562 fdc_set_seek_rate(fdc_seek_rate); /* clock changed! */
567 /* keep the unit select if keep_select is != 0,
569 static void fdc_dor_reset(int keep_select)
571 __u8 fdc_ctl = ft_drive_sel;
573 if (keep_select != 0) {
574 fdc_ctl |= FDC_DMA_MODE;
576 fdc_ctl |= FDC_MOTOR_0 << ft_drive_sel;
579 ftape_udelay(10); /* ??? but seems to be necessary */
581 outb_p(fdc_ctl & 0x0f, fdc.dor);
582 outb_p(fdc_ctl, fdc.dor2);
584 outb_p(fdc_ctl, fdc.dor);
586 fdc_usec_wait(10); /* delay >= 14 fdc clocks */
587 if (keep_select == 0) {
590 fdc_ctl |= FDC_RESET_NOT;
592 outb_p(fdc_ctl & 0x0f, fdc.dor);
593 outb_p(fdc_ctl, fdc.dor2);
595 outb_p(fdc_ctl, fdc.dor);
599 /* Reset the floppy disk controller. Leave the ftape_unit selected.
609 spin_lock_irqsave(&fdc_io_lock, flags);
611 fdc_dor_reset(1); /* keep unit selected */
615 /* maybe the cli()/sti() pair is not necessary, BUT:
616 * the following line MUST be here. Otherwise fdc_interrupt_wait()
617 * won't wait. Note that fdc_reset() is called from
618 * ftape_dumb_stop() when the fdc is busy transferring data. In this
619 * case fdc_isr() MOST PROBABLY sets ft_interrupt_seen, and tries
620 * to get the result bytes from the fdc etc. CLASH.
622 ft_interrupt_seen = 0;
626 fdc_update_dsr(); /* restore data rate and precomp */
628 spin_unlock_irqrestore(&fdc_io_lock, flags);
631 * Wait for first polling cycle to complete
633 if (fdc_interrupt_wait(1 * FT_SECOND) < 0) {
634 TRACE(ft_t_err, "no drive polling interrupt!");
635 } else { /* clear all disk-changed statuses */
636 for (i = 0; i < 4; ++i) {
637 if(fdc_sense_interrupt_status(&st0, &dummy) != 0) {
638 TRACE(ft_t_err, "sense failed for %d", i);
640 if (i == ft_drive_sel) {
641 ftape_current_cylinder = dummy;
644 TRACE(ft_t_noise, "drive polling completed");
649 fdc_set_seek_rate(fdc_seek_rate);
651 * DRIVE SPECIFICATION COMMAND (if fdc type known)
653 if (fdc.type >= i82078_1) {
654 fdc_set_drive_specs();
659 #if !defined(CLK_48MHZ)
663 /* When we're done, put the fdc into reset mode so that the regular
664 * floppy disk driver will figure out that something is wrong and
665 * initialize the controller the way it wants.
667 void fdc_disable(void)
669 __u8 cmd1[] = {FDC_CONFIGURE, 0x00, 0x00, 0x00};
670 __u8 cmd2[] = {FDC_LOCK};
671 __u8 cmd3[] = {FDC_UNLOCK};
673 TRACE_FUN(ft_t_flow);
675 if (!fdc_fifo_locked) {
679 if (fdc_issue_command(cmd3, 1, stat, 1) < 0 || stat[0] != 0x00) {
681 TRACE_ABORT(/**/, ft_t_bug,
682 "couldn't unlock fifo, configuration remains changed");
685 if (CLK_48MHZ && fdc.type >= i82078) {
686 cmd1[0] |= FDC_CLK48_BIT;
688 cmd1[2] = ((fdc_fifo_state) ? 0 : 0x20) + (fdc_fifo_thr - 1);
689 if (fdc_command(cmd1, NR_ITEMS(cmd1)) < 0) {
691 TRACE_ABORT(/**/, ft_t_bug,
692 "couldn't reconfigure fifo to old state");
694 if (fdc_lock_state &&
695 fdc_issue_command(cmd2, 1, stat, 1) < 0) {
697 TRACE_ABORT(/**/, ft_t_bug, "couldn't lock old state again");
699 TRACE(ft_t_noise, "fifo restored: %sabled, thr. %d, %slocked",
700 fdc_fifo_state ? "en" : "dis",
701 fdc_fifo_thr, (fdc_lock_state) ? "" : "not ");
706 /* Specify FDC seek-rate (milliseconds)
708 int fdc_set_seek_rate(int seek_rate)
710 /* set step rate, dma mode, and minimal head load and unload times
712 __u8 in[3] = { FDC_SPECIFY, 1, (1 << 1)};
714 fdc_seek_rate = seek_rate;
715 in[1] |= (16 - (fdc_data_rate * fdc_seek_rate) / 500) << 4;
717 return fdc_command(in, 3);
720 /* Sense drive status: get unit's drive status (ST3)
722 int fdc_sense_drive_status(int *st3)
729 out[1] = ft_drive_sel;
730 TRACE_CATCH(fdc_issue_command(out, 2, in, 1),);
735 /* Sense Interrupt Status command:
736 * should be issued at the end of each seek.
737 * get ST0 and current cylinder.
739 int fdc_sense_interrupt_status(int *st0, int *current_cylinder)
746 TRACE_CATCH(fdc_issue_command(out, 1, in, 2),);
748 *current_cylinder = in[1];
754 int fdc_seek(int track)
764 out[1] = ft_drive_sel;
767 time = ftape_timestamp();
769 /* We really need this command to work !
771 ft_seek_completed = 0;
772 TRACE_CATCH(fdc_command(out, 3),
774 TRACE(ft_t_noise, "destination was: %d, resetting FDC...",
776 /* Handle interrupts until ft_seek_completed or timeout.
779 TRACE_CATCH(fdc_interrupt_wait(2 * FT_SECOND),);
780 if (ft_seek_completed) {
781 TRACE_CATCH(fdc_sense_interrupt_status(&st0, &pcn),);
782 if ((st0 & ST0_SEEK_END) == 0) {
783 TRACE_ABORT(-EIO, ft_t_err,
784 "no seek-end after seek completion !??");
790 time = ftape_timediff(time, ftape_timestamp()) / abs(track - ftape_current_cylinder);
791 if ((time < 900 || time > 3100) && abs(track - ftape_current_cylinder) > 5) {
792 TRACE(ft_t_warn, "Wrong FDC STEP interval: %d usecs (%d)",
793 time, track - ftape_current_cylinder);
796 /* Verify whether we issued the right tape command.
798 /* Verify that we seek to the proper track. */
800 TRACE_ABORT(-EIO, ft_t_err, "bad seek..");
802 ftape_current_cylinder = track;
806 /* Recalibrate and wait until home.
808 int fdc_recalibrate(void)
814 int old_seek_rate = fdc_seek_rate;
817 TRACE_CATCH(fdc_set_seek_rate(6),);
819 out[1] = ft_drive_sel;
820 ft_seek_completed = 0;
821 TRACE_CATCH(fdc_command(out, 2),);
822 /* Handle interrupts until ft_seek_completed or timeout.
824 for (retry = 0;; ++retry) {
825 TRACE_CATCH(fdc_interrupt_wait(2 * FT_SECOND),);
826 if (ft_seek_completed) {
827 TRACE_CATCH(fdc_sense_interrupt_status(&st0, &pcn),);
828 if ((st0 & ST0_SEEK_END) == 0) {
830 continue; /* some drives/fdc's
831 * give an extra interrupt
834 TRACE_ABORT(-EIO, ft_t_err,
835 "no seek-end after seek completion !??");
841 ftape_current_cylinder = pcn;
843 TRACE(ft_t_err, "failed: resulting track = %d", pcn);
845 TRACE_CATCH(fdc_set_seek_rate(old_seek_rate),);
849 static int perpend_mode; /* set if fdc is in perpendicular mode */
851 static int perpend_off(void)
853 __u8 perpend[] = {FDC_PERPEND, 0x00};
857 /* Turn off perpendicular mode */
859 TRACE_CATCH(fdc_command(perpend, 2),
860 TRACE(ft_t_err,"Perpendicular mode exit failed!"));
866 static int handle_perpend(int segment_id)
868 __u8 perpend[] = {FDC_PERPEND, 0x00};
871 /* When writing QIC-3020 tapes, turn on perpendicular mode
872 * if tape is moving in forward direction (even tracks).
874 if (ft_qic_std == QIC_TAPE_QIC3020 &&
875 ((segment_id / ft_segments_per_track) & 1) == 0) {
876 /* FIXME: some i82077 seem to support perpendicular mode as
880 if (fdc.type < i82077AA) {}
882 if (fdc.type < i82077 && ft_data_rate < 1000) {
884 /* fdc does not support perpendicular mode: complain
886 TRACE_ABORT(-EIO, ft_t_err,
887 "Your FDC does not support QIC-3020.");
889 perpend[1] = 0x03 /* 0x83 + (0x4 << ft_drive_sel) */ ;
890 TRACE_CATCH(fdc_command(perpend, 2),
891 TRACE(ft_t_err,"Perpendicular mode entry failed!"));
892 TRACE(ft_t_flow, "Perpendicular mode set");
896 TRACE_EXIT perpend_off();
899 static inline void fdc_setup_dma(char mode,
900 volatile void *addr, unsigned int count)
902 /* Program the DMA controller.
904 disable_dma(fdc.dma);
905 clear_dma_ff(fdc.dma);
906 set_dma_mode(fdc.dma, mode);
907 set_dma_addr(fdc.dma, virt_to_bus((void*)addr));
908 set_dma_count(fdc.dma, count);
912 /* Setup fdc and dma for formatting the next segment
914 int fdc_setup_formatting(buffer_struct * buff)
918 FDC_FORMAT, 0x00, 3, 4 * FT_SECTORS_PER_SEGMENT, 0x00, 0x6b
922 TRACE_CATCH(handle_perpend(buff->segment_id),);
923 /* Program the DMA controller.
926 "phys. addr. = %lx", virt_to_bus((void*) buff->ptr));
927 spin_lock_irqsave(&fdc_io_lock, flags);
928 fdc_setup_dma(DMA_MODE_WRITE, buff->ptr, FT_SECTORS_PER_SEGMENT * 4);
929 /* Issue FDC command to start reading/writing.
931 out[1] = ft_drive_sel;
933 TRACE_CATCH(fdc_setup_error = fdc_command(out, sizeof(out)),
934 restore_flags(flags); fdc_mode = fdc_idle);
935 spin_unlock_irqrestore(&fdc_io_lock, flags);
940 /* Setup Floppy Disk Controller and DMA to read or write the next cluster
941 * of good sectors from or to the current segment.
943 int fdc_setup_read_write(buffer_struct * buff, __u8 operation)
952 if (fdc.type < i82077) {
953 operation = FDC_READ;
956 case FDC_READ_DELETED:
957 dma_mode = DMA_MODE_READ;
958 TRACE(ft_t_fdc_dma, "xfer %d sectors to 0x%p",
959 buff->sector_count, buff->ptr);
960 TRACE_CATCH(perpend_off(),);
962 case FDC_WRITE_DELETED:
963 TRACE(ft_t_noise, "deleting segment %d", buff->segment_id);
965 dma_mode = DMA_MODE_WRITE;
966 /* When writing QIC-3020 tapes, turn on perpendicular mode
967 * if tape is moving in forward direction (even tracks).
969 TRACE_CATCH(handle_perpend(buff->segment_id),);
970 TRACE(ft_t_fdc_dma, "xfer %d sectors from 0x%p",
971 buff->sector_count, buff->ptr);
975 ft_t_bug, "bug: invalid operation parameter");
977 TRACE(ft_t_fdc_dma, "phys. addr. = %lx",virt_to_bus((void*)buff->ptr));
978 spin_lock_irqsave(&fdc_io_lock, flags);
979 if (operation != FDC_VERIFY) {
980 fdc_setup_dma(dma_mode, buff->ptr,
981 FT_SECTOR_SIZE * buff->sector_count);
983 /* Issue FDC command to start reading/writing.
986 out[1] = ft_drive_sel;
989 out[4] = buff->sect + buff->sector_offset;
990 out[5] = 3; /* Sector size of 1K. */
991 out[6] = out[4] + buff->sector_count - 1; /* last sector */
992 out[7] = 109; /* Gap length. */
993 out[8] = 0xff; /* No limit to transfer size. */
994 TRACE(ft_t_fdc_dma, "C: 0x%02x, H: 0x%02x, R: 0x%02x, cnt: 0x%02x",
995 out[2], out[3], out[4], out[6] - out[4] + 1);
996 spin_unlock_irqrestore(&fdc_io_lock, flags);
997 TRACE_CATCH(fdc_setup_error = fdc_command(out, 9),fdc_mode = fdc_idle);
1001 int fdc_fifo_threshold(__u8 threshold,
1002 int *fifo_state, int *lock_state, int *fifo_thr)
1004 const __u8 cmd0[] = {FDC_DUMPREGS};
1005 __u8 cmd1[] = {FDC_CONFIGURE, 0, (0x0f & (threshold - 1)), 0};
1006 const __u8 cmd2[] = {FDC_LOCK};
1007 const __u8 cmd3[] = {FDC_UNLOCK};
1012 TRACE_FUN(ft_t_any);
1014 if (CLK_48MHZ && fdc.type >= i82078) {
1015 cmd1[0] |= FDC_CLK48_BIT;
1017 /* Dump fdc internal registers for examination
1019 TRACE_CATCH(fdc_command(cmd0, NR_ITEMS(cmd0)),
1020 TRACE(ft_t_warn, "dumpreg cmd failed, fifo unchanged"));
1021 /* Now read fdc internal registers from fifo
1023 for (i = 0; i < (int)NR_ITEMS(reg); ++i) {
1025 TRACE(ft_t_fdc_dma, "Register %d = 0x%02x", i, reg[i]);
1027 if (fifo_state && lock_state && fifo_thr) {
1028 *fifo_state = (reg[8] & 0x20) == 0;
1029 *lock_state = reg[7] & 0x80;
1030 *fifo_thr = 1 + (reg[8] & 0x0f);
1033 "original fifo state: %sabled, threshold %d, %slocked",
1034 ((reg[8] & 0x20) == 0) ? "en" : "dis",
1035 1 + (reg[8] & 0x0f), (reg[7] & 0x80) ? "" : "not ");
1036 /* If fdc is already locked, unlock it first ! */
1037 if (reg[7] & 0x80) {
1038 fdc_ready_wait(100);
1039 TRACE_CATCH(fdc_issue_command(cmd3, NR_ITEMS(cmd3), &stat, 1),
1040 TRACE(ft_t_bug, "FDC unlock command failed, "
1041 "configuration unchanged"));
1043 fdc_fifo_locked = 0;
1044 /* Enable fifo and set threshold at xx bytes to allow a
1045 * reasonably large latency and reduce number of dma bursts.
1047 fdc_ready_wait(100);
1048 if ((result = fdc_command(cmd1, NR_ITEMS(cmd1))) < 0) {
1049 TRACE(ft_t_bug, "configure cmd failed, fifo unchanged");
1051 /* Now lock configuration so reset will not change it
1053 if(fdc_issue_command(cmd2, NR_ITEMS(cmd2), &stat, 1) < 0 ||
1055 TRACE_ABORT(-EIO, ft_t_bug,
1056 "FDC lock command failed, stat = 0x%02x", stat);
1058 fdc_fifo_locked = 1;
1062 static int fdc_fifo_enable(void)
1064 TRACE_FUN(ft_t_any);
1066 if (fdc_fifo_locked) {
1067 TRACE_ABORT(0, ft_t_warn, "Fifo not enabled because locked");
1069 TRACE_CATCH(fdc_fifo_threshold(ft_fdc_threshold /* bytes */,
1073 TRACE_CATCH(fdc_fifo_threshold(ft_fdc_threshold /* bytes */,
1074 NULL, NULL, NULL),);
1078 /* Determine fd controller type
1080 static __u8 fdc_save_state[2];
1085 __u8 stat[16]; /* must be able to hold dumpregs & save results */
1087 TRACE_FUN(ft_t_any);
1089 /* Try to find out what kind of fd controller we have to deal with
1090 * Scheme borrowed from floppy driver:
1091 * first try if FDC_DUMPREGS command works
1092 * (this indicates that we have a 82072 or better)
1093 * then try the FDC_VERSION command (82072 doesn't support this)
1094 * then try the FDC_UNLOCK command (some older 82077's don't support this)
1095 * then try the FDC_PARTID command (82078's support this)
1097 cmd[0] = FDC_DUMPREGS;
1098 if (fdc_issue_command(cmd, 1, stat, 1) != 0) {
1099 TRACE_ABORT(no_fdc, ft_t_bug, "No FDC found");
1101 if (stat[0] == 0x80) {
1102 /* invalid command: must be pre 82072 */
1104 ft_t_warn, "Type 8272A/765A compatible FDC found");
1106 fdc_result(&stat[1], 9);
1107 fdc_save_state[0] = stat[7];
1108 fdc_save_state[1] = stat[8];
1109 cmd[0] = FDC_VERSION;
1110 if (fdc_issue_command(cmd, 1, stat, 1) < 0 || stat[0] == 0x80) {
1111 TRACE_ABORT(i8272, ft_t_warn, "Type 82072 FDC found");
1113 if (*stat != 0x90) {
1114 TRACE_ABORT(i8272, ft_t_warn, "Unknown FDC found");
1116 cmd[0] = FDC_UNLOCK;
1117 if(fdc_issue_command(cmd, 1, stat, 1) < 0 || stat[0] != 0x00) {
1118 TRACE_ABORT(i8272, ft_t_warn,
1119 "Type pre-1991 82077 FDC found, "
1120 "treating it like a 82072");
1122 if (fdc_save_state[0] & 0x80) { /* was locked */
1123 cmd[0] = FDC_LOCK; /* restore lock */
1124 (void)fdc_issue_command(cmd, 1, stat, 1);
1125 TRACE(ft_t_warn, "FDC is already locked");
1127 /* Test for a i82078 FDC */
1128 cmd[0] = FDC_PARTID;
1129 if (fdc_issue_command(cmd, 1, stat, 1) < 0 || stat[0] == 0x80) {
1130 /* invalid command: not a i82078xx type FDC */
1131 for (i = 0; i < 4; ++i) {
1133 if ((inb_p(fdc.tdr) & 0x03) != i) {
1135 ft_t_warn, "Type 82077 FDC found");
1138 TRACE_ABORT(i82077AA, ft_t_warn, "Type 82077AA FDC found");
1140 /* FDC_PARTID cmd succeeded */
1141 switch (stat[0] >> 5) {
1143 /* i82078SL or i82078-1. The SL part cannot run at
1144 * 2Mbps (the SL and -1 dies are identical; they are
1145 * speed graded after production, according to Intel).
1146 * Some SL's can be detected by doing a SAVE cmd and
1147 * look at bit 7 of the first byte (the SEL3V# bit).
1148 * If it is 0, the part runs off 3Volts, and hence it
1152 if(fdc_issue_command(cmd, 1, stat, 16) < 0) {
1153 TRACE(ft_t_err, "FDC_SAVE failed. Dunno why");
1154 /* guess we better claim the fdc to be a i82078 */
1157 "Type i82078 FDC (i suppose) found");
1159 if ((stat[0] & FDC_SEL3V_BIT)) {
1160 /* fdc running off 5Volts; Pray that it's a i82078-1
1162 TRACE_ABORT(i82078_1, ft_t_warn,
1163 "Type i82078-1 or 5Volt i82078SL FDC found");
1165 TRACE_ABORT(i82078, ft_t_warn,
1166 "Type 3Volt i82078SL FDC (1Mbps) found");
1168 case 0x2: /* S82078B */
1169 /* The '78B isn't '78 compatible. Detect it as a '77AA */
1170 TRACE_ABORT(i82077AA, ft_t_warn, "Type i82077AA FDC found");
1171 case 0x3: /* NSC PC8744 core; used in several super-IO chips */
1172 TRACE_ABORT(i82077AA,
1173 ft_t_warn, "Type 82077AA compatible FDC found");
1175 TRACE(ft_t_warn, "A previously undetected FDC found");
1176 TRACE_ABORT(i82077AA, ft_t_warn,
1177 "Treating it as a 82077AA. Please report partid= %d",
1179 } /* switch(stat[ 0] >> 5) */
1183 static int fdc_request_regions(void)
1185 TRACE_FUN(ft_t_flow);
1187 if (ft_mach2 || ft_probe_fc10) {
1188 if (!request_region(fdc.sra, 8, "fdc (ft)")) {
1189 #ifndef BROKEN_FLOPPY_DRIVER
1193 "address 0x%03x occupied (by floppy driver?), using it anyway", fdc.sra);
1197 if (!request_region(fdc.sra, 6, "fdc (ft)")) {
1198 #ifndef BROKEN_FLOPPY_DRIVER
1202 "address 0x%03x occupied (by floppy driver?), using it anyway", fdc.sra);
1205 if (!request_region(fdc.sra + 7, 1, "fdc (ft)")) {
1206 #ifndef BROKEN_FLOPPY_DRIVER
1207 release_region(fdc.sra, 6);
1211 "address 0x%03x occupied (by floppy driver?), using it anyway", fdc.sra + 7);
1218 void fdc_release_regions(void)
1220 TRACE_FUN(ft_t_flow);
1223 if (fdc.dor2 != 0) {
1224 release_region(fdc.sra, 8);
1226 release_region(fdc.sra, 6);
1227 release_region(fdc.dir, 1);
1233 static int fdc_config_regs(unsigned int fdc_base,
1234 unsigned int fdc_irq,
1235 unsigned int fdc_dma)
1237 TRACE_FUN(ft_t_flow);
1242 fdc.srb = fdc_base + 1;
1243 fdc.dor = fdc_base + 2;
1244 fdc.tdr = fdc_base + 3;
1245 fdc.msr = fdc.dsr = fdc_base + 4;
1246 fdc.fifo = fdc_base + 5;
1247 fdc.dir = fdc.ccr = fdc_base + 7;
1248 fdc.dor2 = (ft_mach2 || ft_probe_fc10) ? fdc_base + 6 : 0;
1249 TRACE_CATCH(fdc_request_regions(), fdc.sra = 0);
1253 static int fdc_config(void)
1255 static int already_done;
1256 TRACE_FUN(ft_t_any);
1259 TRACE_CATCH(fdc_request_regions(),);
1260 *(fdc.hook) = fdc_isr; /* hook our handler in */
1263 if (ft_probe_fc10) {
1266 TRACE_CATCH(fdc_config_regs(ft_fdc_base,
1267 ft_fdc_irq, ft_fdc_dma),);
1268 fc_type = fc10_enable();
1270 TRACE(ft_t_warn, "FC-%c0 controller found", '0' + fc_type);
1272 fdc.hook = &do_ftape;
1273 *(fdc.hook) = fdc_isr; /* hook our handler in */
1277 TRACE(ft_t_warn, "FC-10/20 controller not found");
1278 fdc_release_regions();
1281 ft_fdc_base = 0x3f0;
1286 TRACE(ft_t_warn, "fdc base: 0x%x, irq: %d, dma: %d",
1287 ft_fdc_base, ft_fdc_irq, ft_fdc_dma);
1288 TRACE_CATCH(fdc_config_regs(ft_fdc_base, ft_fdc_irq, ft_fdc_dma),);
1289 fdc.hook = &do_ftape;
1290 *(fdc.hook) = fdc_isr; /* hook our handler in */
1295 static irqreturn_t ftape_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1297 void (*handler) (void) = *fdc.hook;
1299 TRACE_FUN(ft_t_any);
1306 TRACE(ft_t_bug, "Unexpected ftape interrupt");
1308 TRACE_EXIT IRQ_RETVAL(handled);
1311 int fdc_grab_irq_and_dma(void)
1313 TRACE_FUN(ft_t_any);
1315 if (fdc.hook == &do_ftape) {
1316 /* Get fast interrupt handler.
1318 if (request_irq(fdc.irq, ftape_interrupt,
1319 SA_INTERRUPT, "ft", ftape_id)) {
1320 TRACE_ABORT(-EIO, ft_t_bug,
1321 "Unable to grab IRQ%d for ftape driver",
1324 if (request_dma(fdc.dma, ftape_id)) {
1325 free_irq(fdc.irq, ftape_id);
1326 TRACE_ABORT(-EIO, ft_t_bug,
1327 "Unable to grab DMA%d for ftape driver",
1331 if (ft_fdc_base != 0x3f0 && (ft_fdc_dma == 2 || ft_fdc_irq == 6)) {
1332 /* Using same dma channel or irq as standard fdc, need
1333 * to disable the dma-gate on the std fdc. This
1334 * couldn't be done in the floppy driver as some
1335 * laptops are using the dma-gate to enter a low power
1336 * or even suspended state :-(
1338 outb_p(FDC_RESET_NOT, 0x3f2);
1339 TRACE(ft_t_noise, "DMA-gate on standard fdc disabled");
1344 int fdc_release_irq_and_dma(void)
1346 TRACE_FUN(ft_t_any);
1348 if (fdc.hook == &do_ftape) {
1349 disable_dma(fdc.dma); /* just in case... */
1351 free_irq(fdc.irq, ftape_id);
1353 if (ft_fdc_base != 0x3f0 && (ft_fdc_dma == 2 || ft_fdc_irq == 6)) {
1354 /* Using same dma channel as standard fdc, need to
1355 * disable the dma-gate on the std fdc. This couldn't
1356 * be done in the floppy driver as some laptops are
1357 * using the dma-gate to enter a low power or even
1358 * suspended state :-(
1360 outb_p(FDC_RESET_NOT | FDC_DMA_MODE, 0x3f2);
1361 TRACE(ft_t_noise, "DMA-gate on standard fdc enabled again");
1368 TRACE_FUN(ft_t_any);
1370 /* find a FDC to use */
1371 TRACE_CATCH(fdc_config(),);
1372 TRACE_CATCH(fdc_grab_irq_and_dma(), fdc_release_regions());
1374 fdc_catch_stray_interrupts(0); /* clear number of awainted
1377 fdc_catch_stray_interrupts(1); /* one always comes (?) */
1378 TRACE(ft_t_flow, "resetting fdc");
1379 fdc_set_seek_rate(2); /* use nominal QIC step rate */
1380 fdc_reset(); /* init fdc & clear track counters */
1381 if (fdc.type == no_fdc) { /* no FC-10 or FC-20 found */
1382 fdc.type = fdc_probe();
1383 fdc_reset(); /* update with new knowledge */
1385 if (fdc.type == no_fdc) {
1386 fdc_release_irq_and_dma();
1387 fdc_release_regions();
1390 if (fdc.type >= i82077) {
1391 if (fdc_fifo_enable() < 0) {
1392 TRACE(ft_t_warn, "couldn't enable fdc fifo !");
1394 TRACE(ft_t_flow, "fdc fifo enabled and locked");