Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/cpufreq
[linux-2.6] / drivers / char / ftape / lowlevel / ftape-io.c
1 /*
2  *      Copyright (C) 1993-1996 Bas Laarhoven,
3  *                (C) 1996      Kai Harrekilde-Petersen,
4  *                (C) 1997      Claus-Justus Heine.
5
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 2, or (at your option)
9  any later version.
10
11  This program is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  GNU General Public License for more details.
15
16  You should have received a copy of the GNU General Public License
17  along with this program; see the file COPYING.  If not, write to
18  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
19
20  *
21  * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-io.c,v $
22  * $Revision: 1.4 $
23  * $Date: 1997/11/11 14:02:36 $
24  *
25  *      This file contains the general control functions for the
26  *      QIC-40/80/3010/3020 floppy-tape driver "ftape" for Linux.
27  */
28
29 #include <linux/errno.h>
30 #include <linux/sched.h>
31 #include <linux/mm.h>
32 #include <asm/system.h>
33 #include <linux/ioctl.h>
34 #include <linux/mtio.h>
35 #include <linux/delay.h>
36
37 #include <linux/ftape.h>
38 #include <linux/qic117.h>
39 #include "../lowlevel/ftape-tracing.h"
40 #include "../lowlevel/fdc-io.h"
41 #include "../lowlevel/ftape-io.h"
42 #include "../lowlevel/ftape-ctl.h"
43 #include "../lowlevel/ftape-rw.h"
44 #include "../lowlevel/ftape-write.h"
45 #include "../lowlevel/ftape-read.h"
46 #include "../lowlevel/ftape-init.h"
47 #include "../lowlevel/ftape-calibr.h"
48
49 /*      Global vars.
50  */
51 /* NOTE: sectors start numbering at 1, all others at 0 ! */
52 ft_timeout_table ftape_timeout;
53 unsigned int ftape_tape_len;
54 volatile qic117_cmd_t ftape_current_command;
55 const struct qic117_command_table qic117_cmds[] = QIC117_COMMANDS;
56 int ftape_might_be_off_track;
57
58 /*      Local vars.
59  */
60 static int diagnostic_mode;
61 static unsigned int ftape_udelay_count;
62 static unsigned int ftape_udelay_time;
63
64 void ftape_udelay(unsigned int usecs)
65 {
66         volatile int count = (ftape_udelay_count * usecs +
67                               ftape_udelay_count - 1) / ftape_udelay_time;
68         volatile int i;
69
70         while (count-- > 0) {
71                 for (i = 0; i < 20; ++i);
72         }
73 }
74
75 void ftape_udelay_calibrate(void)
76 {
77         ftape_calibrate("ftape_udelay",
78                         ftape_udelay, &ftape_udelay_count, &ftape_udelay_time);
79 }
80
81 /*      Delay (msec) routine.
82  */
83 void ftape_sleep(unsigned int time)
84 {
85         TRACE_FUN(ft_t_any);
86
87         time *= 1000;   /* msecs -> usecs */
88         if (time < FT_USPT) {
89                 /*  Time too small for scheduler, do a busy wait ! */
90                 ftape_udelay(time);
91         } else {
92                 long timeout;
93                 unsigned long flags;
94                 unsigned int ticks = (time + FT_USPT - 1) / FT_USPT;
95
96                 TRACE(ft_t_any, "%d msec, %d ticks", time/1000, ticks);
97                 timeout = ticks;
98                 save_flags(flags);
99                 sti();
100                 msleep_interruptible(jiffies_to_msecs(timeout));
101                 /*  Mmm. Isn't current->blocked == 0xffffffff ?
102                  */
103                 if (signal_pending(current)) {
104                         TRACE(ft_t_err, "awoken by non-blocked signal :-(");
105                 }
106                 restore_flags(flags);
107         }
108         TRACE_EXIT;
109 }
110
111 /*  send a command or parameter to the drive
112  *  Generates # of step pulses.
113  */
114 static inline int ft_send_to_drive(int arg)
115 {
116         /*  Always wait for a command_timeout period to separate
117          *  individuals commands and/or parameters.
118          */
119         ftape_sleep(3 * FT_MILLISECOND);
120         /*  Keep cylinder nr within range, step towards home if possible.
121          */
122         if (ftape_current_cylinder >= arg) {
123                 return fdc_seek(ftape_current_cylinder - arg);
124         } else {
125                 return fdc_seek(ftape_current_cylinder + arg);
126         }
127 }
128
129 /* forward */ int ftape_report_raw_drive_status(int *status);
130
131 static int ft_check_cmd_restrictions(qic117_cmd_t command)
132 {
133         int status = -1;
134         TRACE_FUN(ft_t_any);
135         
136         TRACE(ft_t_flow, "%s", qic117_cmds[command].name);
137         /* A new motion command during an uninterruptible (motion)
138          *  command requires a ready status before the new command can
139          *  be issued. Otherwise a new motion command needs to be
140          *  checked against required status.
141          */
142         if (qic117_cmds[command].cmd_type == motion &&
143             qic117_cmds[ftape_current_command].non_intr) {
144                 ftape_report_raw_drive_status(&status);
145                 if ((status & QIC_STATUS_READY) == 0) {
146                         TRACE(ft_t_noise,
147                               "motion cmd (%d) during non-intr cmd (%d)",
148                               command, ftape_current_command);
149                         TRACE(ft_t_noise, "waiting until drive gets ready");
150                         ftape_ready_wait(ftape_timeout.seek,
151                                          &status);
152                 }
153         }
154         if (qic117_cmds[command].mask != 0) {
155                 __u8 difference;
156                 /*  Some commands do require a certain status:
157                  */
158                 if (status == -1) {     /* not yet set */
159                         ftape_report_raw_drive_status(&status);
160                 }
161                 difference = ((status ^ qic117_cmds[command].state) &
162                               qic117_cmds[command].mask);
163                 /*  Wait until the drive gets
164                  *  ready. This may last forever if
165                  *  the drive never gets ready... 
166                  */
167                 while ((difference & QIC_STATUS_READY) != 0) {
168                         TRACE(ft_t_noise, "command %d issued while not ready",
169                               command);
170                         TRACE(ft_t_noise, "waiting until drive gets ready");
171                         if (ftape_ready_wait(ftape_timeout.seek,
172                                              &status) == -EINTR) {
173                                 /*  Bail out on signal !
174                                  */
175                                 TRACE_ABORT(-EINTR, ft_t_warn,
176                                       "interrupted by non-blockable signal");
177                         }
178                         difference = ((status ^ qic117_cmds[command].state) &
179                                       qic117_cmds[command].mask);
180                 }
181                 while ((difference & QIC_STATUS_ERROR) != 0) {
182                         int err;
183                         qic117_cmd_t cmd;
184
185                         TRACE(ft_t_noise,
186                               "command %d issued while error pending",
187                               command);
188                         TRACE(ft_t_noise, "clearing error status");
189                         ftape_report_error(&err, &cmd, 1);
190                         ftape_report_raw_drive_status(&status);
191                         difference = ((status ^ qic117_cmds[command].state) &
192                                       qic117_cmds[command].mask);
193                         if ((difference & QIC_STATUS_ERROR) != 0) {
194                                 /*  Bail out on fatal signal !
195                                  */
196                                 FT_SIGNAL_EXIT(_NEVER_BLOCK);
197                         }
198                 }
199                 if (difference) {
200                         /*  Any remaining difference can't be solved
201                          *  here.  
202                          */
203                         if (difference & (QIC_STATUS_CARTRIDGE_PRESENT |
204                                           QIC_STATUS_NEW_CARTRIDGE |
205                                           QIC_STATUS_REFERENCED)) {
206                                 TRACE(ft_t_warn,
207                                       "Fatal: tape removed or reinserted !");
208                                 ft_failure = 1;
209                         } else {
210                                 TRACE(ft_t_err, "wrong state: 0x%02x should be: 0x%02x",
211                                       status & qic117_cmds[command].mask,
212                                       qic117_cmds[command].state);
213                         }
214                         TRACE_EXIT -EIO;
215                 }
216                 if (~status & QIC_STATUS_READY & qic117_cmds[command].mask) {
217                         TRACE_ABORT(-EBUSY, ft_t_err, "Bad: still busy!");
218                 }
219         }
220         TRACE_EXIT 0;
221 }
222
223 /*      Issue a tape command:
224  */
225 int ftape_command(qic117_cmd_t command)
226 {
227         int result = 0;
228         static int level;
229         TRACE_FUN(ft_t_any);
230
231         if ((unsigned int)command > NR_ITEMS(qic117_cmds)) {
232                 /*  This is a bug we'll want to know about too.
233                  */
234                 TRACE_ABORT(-EIO, ft_t_bug, "bug - bad command: %d", command);
235         }
236         if (++level > 5) { /*  This is a bug we'll want to know about. */
237                 --level;
238                 TRACE_ABORT(-EIO, ft_t_bug, "bug - recursion for command: %d",
239                             command);
240         }
241         /*  disable logging and restriction check for some commands,
242          *  check all other commands that have a prescribed starting
243          *  status.
244          */
245         if (diagnostic_mode) {
246                 TRACE(ft_t_flow, "diagnostic command %d", command);
247         } else if (command == QIC_REPORT_DRIVE_STATUS ||
248                    command == QIC_REPORT_NEXT_BIT) {
249                 TRACE(ft_t_any, "%s", qic117_cmds[command].name);
250         } else {
251                 TRACE_CATCH(ft_check_cmd_restrictions(command), --level);
252         }
253         /*  Now all conditions are met or result was < 0.
254          */
255         result = ft_send_to_drive((unsigned int)command);
256         if (qic117_cmds[command].cmd_type == motion &&
257             command != QIC_LOGICAL_FORWARD && command != QIC_STOP_TAPE) {
258                 ft_location.known = 0;
259         }
260         ftape_current_command = command;
261         --level;
262         TRACE_EXIT result;
263 }
264
265 /*      Send a tape command parameter:
266  *      Generates command # of step pulses.
267  *      Skips tape-status call !
268  */
269 int ftape_parameter(unsigned int parameter)
270 {
271         TRACE_FUN(ft_t_any);
272
273         TRACE(ft_t_flow, "called with parameter = %d", parameter);
274         TRACE_EXIT ft_send_to_drive(parameter + 2);
275 }
276
277 /*      Wait for the drive to get ready.
278  *      timeout time in milli-seconds
279  *      Returned status is valid if result != -EIO
280  *
281  *      Should we allow to be killed by SIGINT?  (^C)
282  *      Would be nice at least for large timeouts.
283  */
284 int ftape_ready_wait(unsigned int timeout, int *status)
285 {
286         unsigned long t0;
287         unsigned int poll_delay;
288         int signal_retries;
289         TRACE_FUN(ft_t_any);
290
291         /*  the following ** REALLY ** reduces the system load when
292          *  e.g. one simply rewinds or retensions. The tape is slow 
293          *  anyway. It is really not necessary to detect error 
294          *  conditions with 1/10 seconds granularity
295          *
296          *  On my AMD 133MHZ 486: 100 ms: 23% system load
297          *                        1  sec:  5%
298          *                        5  sec:  0.6%, yeah
299          */
300         if (timeout <= FT_SECOND) {
301                 poll_delay = 100 * FT_MILLISECOND;
302                 signal_retries = 20; /* two seconds */
303         } else if (timeout < 20 * FT_SECOND) {
304                 TRACE(ft_t_flow, "setting poll delay to 1 second");
305                 poll_delay = FT_SECOND;
306                 signal_retries = 2; /* two seconds */
307         } else {
308                 TRACE(ft_t_flow, "setting poll delay to 5 seconds");
309                 poll_delay = 5 * FT_SECOND;
310                 signal_retries = 1; /* five seconds */
311         }
312         for (;;) {
313                 t0 = jiffies;
314                 TRACE_CATCH(ftape_report_raw_drive_status(status),);
315                 if (*status & QIC_STATUS_READY) {
316                         TRACE_EXIT 0;
317                 }
318                 if (!signal_retries--) {
319                         FT_SIGNAL_EXIT(_NEVER_BLOCK);
320                 }
321                 if ((int)timeout >= 0) {
322                         /* this will fail when jiffies wraps around about
323                          * once every year :-)
324                          */
325                         timeout -= ((jiffies - t0) * FT_SECOND) / HZ;
326                         if (timeout <= 0) {
327                                 TRACE_ABORT(-ETIME, ft_t_err, "timeout");
328                         }
329                         ftape_sleep(poll_delay);
330                         timeout -= poll_delay;
331                 } else {
332                         ftape_sleep(poll_delay);
333                 }
334         }
335         TRACE_EXIT -ETIME;
336 }
337
338 /*      Issue command and wait up to timeout milli seconds for drive ready
339  */
340 int ftape_command_wait(qic117_cmd_t command, unsigned int timeout, int *status)
341 {
342         int result;
343
344         /* Drive should be ready, issue command
345          */
346         result = ftape_command(command);
347         if (result >= 0) {
348                 result = ftape_ready_wait(timeout, status);
349         }
350         return result;
351 }
352
353 static int ftape_parameter_wait(unsigned int parm, unsigned int timeout, int *status)
354 {
355         int result;
356
357         /* Drive should be ready, issue command
358          */
359         result = ftape_parameter(parm);
360         if (result >= 0) {
361                 result = ftape_ready_wait(timeout, status);
362         }
363         return result;
364 }
365
366 /*--------------------------------------------------------------------------
367  *      Report operations
368  */
369
370 /* Query the drive about its status.  The command is sent and
371    result_length bits of status are returned (2 extra bits are read
372    for start and stop). */
373
374 int ftape_report_operation(int *status,
375                            qic117_cmd_t command,
376                            int result_length)
377 {
378         int i, st3;
379         unsigned int t0;
380         unsigned int dt;
381         TRACE_FUN(ft_t_any);
382
383         TRACE_CATCH(ftape_command(command),);
384         t0 = ftape_timestamp();
385         i = 0;
386         do {
387                 ++i;
388                 ftape_sleep(3 * FT_MILLISECOND);        /* see remark below */
389                 TRACE_CATCH(fdc_sense_drive_status(&st3),);
390                 dt = ftape_timediff(t0, ftape_timestamp());
391                 /*  Ack should be asserted within Ttimout + Tack = 6 msec.
392                  *  Looks like some drives fail to do this so extend this
393                  *  period to 300 msec.
394                  */
395         } while (!(st3 & ST3_TRACK_0) && dt < 300000);
396         if (!(st3 & ST3_TRACK_0)) {
397                 TRACE(ft_t_err,
398                       "No acknowledge after %u msec. (%i iter)", dt / 1000, i);
399                 TRACE_ABORT(-EIO, ft_t_err, "timeout on Acknowledge");
400         }
401         /*  dt may be larger than expected because of other tasks
402          *  scheduled while we were sleeping.
403          */
404         if (i > 1 && dt > 6000) {
405                 TRACE(ft_t_err, "Acknowledge after %u msec. (%i iter)",
406                       dt / 1000, i);
407         }
408         *status = 0;
409         for (i = 0; i < result_length + 1; i++) {
410                 TRACE_CATCH(ftape_command(QIC_REPORT_NEXT_BIT),);
411                 TRACE_CATCH(fdc_sense_drive_status(&st3),);
412                 if (i < result_length) {
413                         *status |= ((st3 & ST3_TRACK_0) ? 1 : 0) << i;
414                 } else if ((st3 & ST3_TRACK_0) == 0) {
415                         TRACE_ABORT(-EIO, ft_t_err, "missing status stop bit");
416                 }
417         }
418         /* this command will put track zero and index back into normal state */
419         (void)ftape_command(QIC_REPORT_NEXT_BIT);
420         TRACE_EXIT 0;
421 }
422
423 /* Report the current drive status. */
424
425 int ftape_report_raw_drive_status(int *status)
426 {
427         int result;
428         int count = 0;
429         TRACE_FUN(ft_t_any);
430
431         do {
432                 result = ftape_report_operation(status,
433                                                 QIC_REPORT_DRIVE_STATUS, 8);
434         } while (result < 0 && ++count <= 3);
435         if (result < 0) {
436                 TRACE_ABORT(-EIO, ft_t_err,
437                             "report_operation failed after %d trials", count);
438         }
439         if ((*status & 0xff) == 0xff) {
440                 TRACE_ABORT(-EIO, ft_t_err,
441                             "impossible drive status 0xff");
442         }
443         if (*status & QIC_STATUS_READY) {
444                 ftape_current_command = QIC_NO_COMMAND; /* completed */
445         }
446         ft_last_status.status.drive_status = (__u8)(*status & 0xff);
447         TRACE_EXIT 0;
448 }
449
450 int ftape_report_drive_status(int *status)
451 {
452         TRACE_FUN(ft_t_any);
453
454         TRACE_CATCH(ftape_report_raw_drive_status(status),);
455         if (*status & QIC_STATUS_NEW_CARTRIDGE ||
456             !(*status & QIC_STATUS_CARTRIDGE_PRESENT)) {
457                 ft_failure = 1; /* will inhibit further operations */
458                 TRACE_EXIT -EIO;
459         }
460         if (*status & QIC_STATUS_READY && *status & QIC_STATUS_ERROR) {
461                 /*  Let caller handle all errors */
462                 TRACE_ABORT(1, ft_t_warn, "warning: error status set!");
463         }
464         TRACE_EXIT 0;
465 }
466
467 int ftape_report_error(unsigned int *error,
468                        qic117_cmd_t *command, int report)
469 {
470         static const ftape_error ftape_errors[] = QIC117_ERRORS;
471         int code;
472         TRACE_FUN(ft_t_any);
473
474         TRACE_CATCH(ftape_report_operation(&code, QIC_REPORT_ERROR_CODE, 16),);
475         *error   = (unsigned int)(code & 0xff);
476         *command = (qic117_cmd_t)((code>>8)&0xff);
477         /*  remember hardware status, maybe useful for status ioctls
478          */
479         ft_last_error.error.command = (__u8)*command;
480         ft_last_error.error.error   = (__u8)*error;
481         if (!report) {
482                 TRACE_EXIT 0;
483         }
484         if (*error == 0) {
485                 TRACE_ABORT(0, ft_t_info, "No error");
486         }
487         TRACE(ft_t_info, "errorcode: %d", *error);
488         if (*error < NR_ITEMS(ftape_errors)) {
489                 TRACE(ft_t_noise, "%sFatal ERROR:",
490                       (ftape_errors[*error].fatal ? "" : "Non-"));
491                 TRACE(ft_t_noise, "%s ...", ftape_errors[*error].message);
492         } else {
493                 TRACE(ft_t_noise, "Unknown ERROR !");
494         }
495         if ((unsigned int)*command < NR_ITEMS(qic117_cmds) &&
496             qic117_cmds[*command].name != NULL) {
497                 TRACE(ft_t_noise, "... caused by command \'%s\'",
498                       qic117_cmds[*command].name);
499         } else {
500                 TRACE(ft_t_noise, "... caused by unknown command %d",
501                       *command);
502         }
503         TRACE_EXIT 0;
504 }
505
506 int ftape_report_configuration(qic_model *model,
507                                unsigned int *rate,
508                                int *qic_std,
509                                int *tape_len)
510 {
511         int result;
512         int config;
513         int status;
514         static const unsigned int qic_rates[ 4] = { 250, 2000, 500, 1000 };
515         TRACE_FUN(ft_t_any);
516
517         result = ftape_report_operation(&config,
518                                         QIC_REPORT_DRIVE_CONFIGURATION, 8);
519         if (result < 0) {
520                 ft_last_status.status.drive_config = (__u8)0x00;
521                 *model = prehistoric;
522                 *rate = 500;
523                 *qic_std = QIC_TAPE_QIC40;
524                 *tape_len = 205;
525                 TRACE_EXIT 0;
526         } else {
527                 ft_last_status.status.drive_config = (__u8)(config & 0xff);
528         }
529         *rate = qic_rates[(config & QIC_CONFIG_RATE_MASK) >> QIC_CONFIG_RATE_SHIFT];
530         result = ftape_report_operation(&status, QIC_REPORT_TAPE_STATUS, 8);
531         if (result < 0) {
532                 ft_last_status.status.tape_status = (__u8)0x00;
533                 /* pre- QIC117 rev C spec. drive, QIC_CONFIG_80 bit is valid.
534                  */
535                 *qic_std = (config & QIC_CONFIG_80) ?
536                         QIC_TAPE_QIC80 : QIC_TAPE_QIC40;
537                 /* ?? how's about 425ft tapes? */
538                 *tape_len = (config & QIC_CONFIG_LONG) ? 307 : 0;
539                 *model = pre_qic117c;
540                 result = 0;
541         } else {
542                 ft_last_status.status.tape_status = (__u8)(status & 0xff);
543                 *model = post_qic117b;
544                 TRACE(ft_t_any, "report tape status result = %02x", status);
545                 /* post- QIC117 rev C spec. drive, QIC_CONFIG_80 bit is
546                  * invalid. 
547                  */
548                 switch (status & QIC_TAPE_STD_MASK) {
549                 case QIC_TAPE_QIC40:
550                 case QIC_TAPE_QIC80:
551                 case QIC_TAPE_QIC3020:
552                 case QIC_TAPE_QIC3010:
553                         *qic_std = status & QIC_TAPE_STD_MASK;
554                         break;
555                 default:
556                         *qic_std = -1;
557                         break;
558                 }
559                 switch (status & QIC_TAPE_LEN_MASK) {
560                 case QIC_TAPE_205FT:
561                         /* 205 or 425+ ft 550 Oe tape */
562                         *tape_len = 0;
563                         break;
564                 case QIC_TAPE_307FT:
565                         /* 307.5 ft 550 Oe Extended Length (XL) tape */
566                         *tape_len = 307;
567                         break;
568                 case QIC_TAPE_VARIABLE:
569                         /* Variable length 550 Oe tape */
570                         *tape_len = 0;
571                         break;
572                 case QIC_TAPE_1100FT:
573                         /* 1100 ft 550 Oe tape */
574                         *tape_len = 1100;
575                         break;
576                 case QIC_TAPE_FLEX:
577                         /* Variable length 900 Oe tape */
578                         *tape_len = 0;
579                         break;
580                 default:
581                         *tape_len = -1;
582                         break;
583                 }
584                 if (*qic_std == -1 || *tape_len == -1) {
585                         TRACE(ft_t_any,
586                               "post qic-117b spec drive with unknown tape");
587                 }
588                 result = *tape_len == -1 ? -EIO : 0;
589                 if (status & QIC_TAPE_WIDE) {
590                         switch (*qic_std) {
591                         case QIC_TAPE_QIC80:
592                                 TRACE(ft_t_info, "TR-1 tape detected");
593                                 break;
594                         case QIC_TAPE_QIC3010:
595                                 TRACE(ft_t_info, "TR-2 tape detected");
596                                 break;
597                         case QIC_TAPE_QIC3020:
598                                 TRACE(ft_t_info, "TR-3 tape detected");
599                                 break;
600                         default:
601                                 TRACE(ft_t_warn,
602                                       "Unknown Travan tape type detected");
603                                 break;
604                         }
605                 }
606         }
607         TRACE_EXIT (result < 0) ? -EIO : 0;
608 }
609
610 static int ftape_report_rom_version(int *version)
611 {
612
613         if (ftape_report_operation(version, QIC_REPORT_ROM_VERSION, 8) < 0) {
614                 return -EIO;
615         } else {
616                 return 0;
617         }
618 }
619
620 void ftape_report_vendor_id(unsigned int *id)
621 {
622         int result;
623         TRACE_FUN(ft_t_any);
624
625         /* We'll try to get a vendor id from the drive.  First
626          * according to the QIC-117 spec, a 16-bit id is requested.
627          * If that fails we'll try an 8-bit version, otherwise we'll
628          * try an undocumented query.
629          */
630         result = ftape_report_operation((int *) id, QIC_REPORT_VENDOR_ID, 16);
631         if (result < 0) {
632                 result = ftape_report_operation((int *) id,
633                                                 QIC_REPORT_VENDOR_ID, 8);
634                 if (result < 0) {
635                         /* The following is an undocumented call found
636                          * in the CMS code.
637                          */
638                         result = ftape_report_operation((int *) id, 24, 8);
639                         if (result < 0) {
640                                 *id = UNKNOWN_VENDOR;
641                         } else {
642                                 TRACE(ft_t_noise, "got old 8 bit id: %04x",
643                                       *id);
644                                 *id |= 0x20000;
645                         }
646                 } else {
647                         TRACE(ft_t_noise, "got 8 bit id: %04x", *id);
648                         *id |= 0x10000;
649                 }
650         } else {
651                 TRACE(ft_t_noise, "got 16 bit id: %04x", *id);
652         }
653         if (*id == 0x0047) {
654                 int version;
655                 int sign;
656
657                 if (ftape_report_rom_version(&version) < 0) {
658                         TRACE(ft_t_bug, "report rom version failed");
659                         TRACE_EXIT;
660                 }
661                 TRACE(ft_t_noise, "CMS rom version: %d", version);
662                 ftape_command(QIC_ENTER_DIAGNOSTIC_1);
663                 ftape_command(QIC_ENTER_DIAGNOSTIC_1);
664                 diagnostic_mode = 1;
665                 if (ftape_report_operation(&sign, 9, 8) < 0) {
666                         unsigned int error;
667                         qic117_cmd_t command;
668
669                         ftape_report_error(&error, &command, 1);
670                         ftape_command(QIC_ENTER_PRIMARY_MODE);
671                         diagnostic_mode = 0;
672                         TRACE_EXIT;     /* failure ! */
673                 } else {
674                         TRACE(ft_t_noise, "CMS signature: %02x", sign);
675                 }
676                 if (sign == 0xa5) {
677                         result = ftape_report_operation(&sign, 37, 8);
678                         if (result < 0) {
679                                 if (version >= 63) {
680                                         *id = 0x8880;
681                                         TRACE(ft_t_noise,
682                                               "This is an Iomega drive !");
683                                 } else {
684                                         *id = 0x0047;
685                                         TRACE(ft_t_noise,
686                                               "This is a real CMS drive !");
687                                 }
688                         } else {
689                                 *id = 0x0047;
690                                 TRACE(ft_t_noise, "CMS status: %d", sign);
691                         }
692                 } else {
693                         *id = UNKNOWN_VENDOR;
694                 }
695                 ftape_command(QIC_ENTER_PRIMARY_MODE);
696                 diagnostic_mode = 0;
697         }
698         TRACE_EXIT;
699 }
700
701 static int qic_rate_code(unsigned int rate)
702 {
703         switch (rate) {
704         case 250:
705                 return QIC_CONFIG_RATE_250;
706         case 500:
707                 return QIC_CONFIG_RATE_500;
708         case 1000:
709                 return QIC_CONFIG_RATE_1000;
710         case 2000:
711                 return QIC_CONFIG_RATE_2000;
712         default:
713                 return QIC_CONFIG_RATE_500;
714         }
715 }
716
717 static int ftape_set_rate_test(unsigned int *max_rate)
718 {
719         unsigned int error;
720         qic117_cmd_t command;
721         int status;
722         int supported = 0;
723         TRACE_FUN(ft_t_any);
724
725         /*  Check if the drive does support the select rate command
726          *  by testing all different settings. If any one is accepted
727          *  we assume the command is supported, else not.
728          */
729         for (*max_rate = 2000; *max_rate >= 250; *max_rate /= 2) {
730                 if (ftape_command(QIC_SELECT_RATE) < 0) {
731                         continue;
732                 }               
733                 if (ftape_parameter_wait(qic_rate_code(*max_rate),
734                                          1 * FT_SECOND, &status) < 0) {
735                         continue;
736                 }
737                 if (status & QIC_STATUS_ERROR) {
738                         ftape_report_error(&error, &command, 0);
739                         continue;
740                 }
741                 supported = 1; /* did accept a request */
742                 break;
743         }
744         TRACE(ft_t_noise, "Select Rate command is%s supported", 
745               supported ? "" : " not");
746         TRACE_EXIT supported;
747 }
748
749 int ftape_set_data_rate(unsigned int new_rate /* Kbps */, unsigned int qic_std)
750 {
751         int status;
752         int result = 0;
753         unsigned int data_rate = new_rate;
754         static int supported;
755         int rate_changed = 0;
756         qic_model dummy_model;
757         unsigned int dummy_qic_std, dummy_tape_len;
758         TRACE_FUN(ft_t_any);
759
760         if (ft_drive_max_rate == 0) { /* first time */
761                 supported = ftape_set_rate_test(&ft_drive_max_rate);
762         }
763         if (supported) {
764                 ftape_command(QIC_SELECT_RATE);
765                 result = ftape_parameter_wait(qic_rate_code(new_rate),
766                                               1 * FT_SECOND, &status);
767                 if (result >= 0 && !(status & QIC_STATUS_ERROR)) {
768                         rate_changed = 1;
769                 }
770         }
771         TRACE_CATCH(result = ftape_report_configuration(&dummy_model,
772                                                         &data_rate, 
773                                                         &dummy_qic_std,
774                                                         &dummy_tape_len),);
775         if (data_rate != new_rate) {
776                 if (!supported) {
777                         TRACE(ft_t_warn, "Rate change not supported!");
778                 } else if (rate_changed) {
779                         TRACE(ft_t_warn, "Requested: %d, got %d",
780                               new_rate, data_rate);
781                 } else {
782                         TRACE(ft_t_warn, "Rate change failed!");
783                 }
784                 result = -EINVAL;
785         }
786         /*
787          *  Set data rate and write precompensation as specified:
788          *
789          *            |  QIC-40/80  | QIC-3010/3020
790          *   rate     |   precomp   |    precomp
791          *  ----------+-------------+--------------
792          *  250 Kbps. |   250 ns.   |     0 ns.
793          *  500 Kbps. |   125 ns.   |     0 ns.
794          *    1 Mbps. |    42 ns.   |     0 ns.
795          *    2 Mbps  |      N/A    |     0 ns.
796          */
797         if ((qic_std == QIC_TAPE_QIC40 && data_rate > 500) || 
798             (qic_std == QIC_TAPE_QIC80 && data_rate > 1000)) {
799                 TRACE_ABORT(-EINVAL,
800                             ft_t_warn, "Datarate too high for QIC-mode");
801         }
802         TRACE_CATCH(fdc_set_data_rate(data_rate),_res = -EINVAL);
803         ft_data_rate = data_rate;
804         if (qic_std == QIC_TAPE_QIC40 || qic_std == QIC_TAPE_QIC80) {
805                 switch (data_rate) {
806                 case 250:
807                         fdc_set_write_precomp(250);
808                         break;
809                 default:
810                 case 500:
811                         fdc_set_write_precomp(125);
812                         break;
813                 case 1000:
814                         fdc_set_write_precomp(42);
815                         break;
816                 }
817         } else {
818                 fdc_set_write_precomp(0);
819         }
820         TRACE_EXIT result;
821 }
822
823 /*  The next two functions are used to cope with excessive overrun errors
824  */
825 int ftape_increase_threshold(void)
826 {
827         TRACE_FUN(ft_t_flow);
828
829         if (fdc.type < i82077 || ft_fdc_threshold >= 12) {
830                 TRACE_ABORT(-EIO, ft_t_err, "cannot increase fifo threshold");
831         }
832         if (fdc_fifo_threshold(++ft_fdc_threshold, NULL, NULL, NULL) < 0) {
833                 TRACE(ft_t_err, "cannot increase fifo threshold");
834                 ft_fdc_threshold --;
835                 fdc_reset();
836         }
837         TRACE(ft_t_info, "New FIFO threshold: %d", ft_fdc_threshold);
838         TRACE_EXIT 0;
839 }
840
841 int ftape_half_data_rate(void)
842 {
843         if (ft_data_rate < 500) {
844                 return -1;
845         }
846         if (ftape_set_data_rate(ft_data_rate / 2, ft_qic_std) < 0) {
847                 return -EIO;
848         }
849         ftape_calc_timeouts(ft_qic_std, ft_data_rate, ftape_tape_len);
850         return 0;
851 }
852
853 /*      Seek the head to the specified track.
854  */
855 int ftape_seek_head_to_track(unsigned int track)
856 {
857         int status;
858         TRACE_FUN(ft_t_any);
859
860         ft_location.track = -1; /* remains set in case of error */
861         if (track >= ft_tracks_per_tape) {
862                 TRACE_ABORT(-EINVAL, ft_t_bug, "track out of bounds");
863         }
864         TRACE(ft_t_flow, "seeking track %d", track);
865         TRACE_CATCH(ftape_command(QIC_SEEK_HEAD_TO_TRACK),);
866         TRACE_CATCH(ftape_parameter_wait(track, ftape_timeout.head_seek,
867                                          &status),);
868         ft_location.track = track;
869         ftape_might_be_off_track = 0;
870         TRACE_EXIT 0;
871 }
872
873 int ftape_wakeup_drive(wake_up_types method)
874 {
875         int status;
876         int motor_on = 0;
877         TRACE_FUN(ft_t_any);
878
879         switch (method) {
880         case wake_up_colorado:
881                 TRACE_CATCH(ftape_command(QIC_PHANTOM_SELECT),);
882                 TRACE_CATCH(ftape_parameter(0 /* ft_drive_sel ?? */),);
883                 break;
884         case wake_up_mountain:
885                 TRACE_CATCH(ftape_command(QIC_SOFT_SELECT),);
886                 ftape_sleep(FT_MILLISECOND);    /* NEEDED */
887                 TRACE_CATCH(ftape_parameter(18),);
888                 break;
889         case wake_up_insight:
890                 ftape_sleep(100 * FT_MILLISECOND);
891                 motor_on = 1;
892                 fdc_motor(motor_on);    /* enable is done by motor-on */
893         case no_wake_up:
894                 break;
895         default:
896                 TRACE_EXIT -ENODEV;     /* unknown wakeup method */
897                 break;
898         }
899         /*  If wakeup succeeded we shouldn't get an error here..
900          */
901         TRACE_CATCH(ftape_report_raw_drive_status(&status),
902                     if (motor_on) {
903                             fdc_motor(0);
904                     });
905         TRACE_EXIT 0;
906 }
907
908 int ftape_put_drive_to_sleep(wake_up_types method)
909 {
910         TRACE_FUN(ft_t_any);
911
912         switch (method) {
913         case wake_up_colorado:
914                 TRACE_CATCH(ftape_command(QIC_PHANTOM_DESELECT),);
915                 break;
916         case wake_up_mountain:
917                 TRACE_CATCH(ftape_command(QIC_SOFT_DESELECT),);
918                 break;
919         case wake_up_insight:
920                 fdc_motor(0);   /* enable is done by motor-on */
921         case no_wake_up:        /* no wakeup / no sleep ! */
922                 break;
923         default:
924                 TRACE_EXIT -ENODEV;     /* unknown wakeup method */
925         }
926         TRACE_EXIT 0;
927 }
928
929 int ftape_reset_drive(void)
930 {
931         int result = 0;
932         int status;
933         unsigned int err_code;
934         qic117_cmd_t err_command;
935         int i;
936         TRACE_FUN(ft_t_any);
937
938         /*  We want to re-establish contact with our drive.  Fire a
939          *  number of reset commands (single step pulses) and pray for
940          *  success.
941          */
942         for (i = 0; i < 2; ++i) {
943                 TRACE(ft_t_flow, "Resetting fdc");
944                 fdc_reset();
945                 ftape_sleep(10 * FT_MILLISECOND);
946                 TRACE(ft_t_flow, "Reset command to drive");
947                 result = ftape_command(QIC_RESET);
948                 if (result == 0) {
949                         ftape_sleep(1 * FT_SECOND); /*  drive not
950                                                      *  accessible
951                                                      *  during 1 second
952                                                      */
953                         TRACE(ft_t_flow, "Re-selecting drive");
954
955                         /* Strange, the QIC-117 specs don't mention
956                          * this but the drive gets deselected after a
957                          * soft reset !  So we need to enable it
958                          * again.
959                          */
960                         if (ftape_wakeup_drive(ft_drive_type.wake_up) < 0) {
961                                 TRACE(ft_t_err, "Wakeup failed !");
962                         }
963                         TRACE(ft_t_flow, "Waiting until drive gets ready");
964                         result= ftape_ready_wait(ftape_timeout.reset, &status);
965                         if (result == 0 && (status & QIC_STATUS_ERROR)) {
966                                 result = ftape_report_error(&err_code,
967                                                             &err_command, 1);
968                                 if (result == 0 && err_code == 27) {
969                                         /*  Okay, drive saw reset
970                                          *  command and responded as it
971                                          *  should
972                                          */
973                                         break;
974                                 } else {
975                                         result = -EIO;
976                                 }
977                         } else {
978                                 result = -EIO;
979                         }
980                 }
981                 FT_SIGNAL_EXIT(_DONT_BLOCK);
982         }
983         if (result != 0) {
984                 TRACE(ft_t_err, "General failure to reset tape drive");
985         } else {
986                 /*  Restore correct settings: keep original rate 
987                  */
988                 ftape_set_data_rate(ft_data_rate, ft_qic_std);
989         }
990         ftape_init_drive_needed = 1;
991         TRACE_EXIT result;
992 }