SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/char/ftape/lowlevel/ftape-proc.c

   1 /*
   2  *      Copyright (C) 1997 Claus-Justus Heine
   3
   4  This program is free software; you can redistribute it and/or modify
   5  it under the terms of the GNU General Public License as published by
   6  the Free Software Foundation; either version 2, or (at your option)
   7  any later version.
   8
   9  This program is distributed in the hope that it will be useful,
  10  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  GNU General Public License for more details.
  13
  14  You should have received a copy of the GNU General Public License
  15  along with this program; see the file COPYING.  If not, write to
  16  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18  *
  19  * $Source: /homes/cvs/ftape-stacked/ftape/lowlevel/ftape-proc.c,v $
  20  * $Revision: 1.11 $
  21  * $Date: 1997/10/24 14:47:37 $
  22  *
  23  *      This file contains the procfs interface for the
  24  *      QIC-40/80/3010/3020 floppy-tape driver "ftape" for Linux.
  25
  26  *      Old code removed, switched to dynamic proc entry.
  27  */
  28
  29
  30 #if defined(CONFIG_PROC_FS) && defined(CONFIG_FT_PROC_FS)
  31
  32 #include <linux/proc_fs.h>
  33
  34 #include <linux/ftape.h>
  35 #include <linux/init.h>
  36 #include <linux/qic117.h>
  37
  38 #include "../lowlevel/ftape-io.h"
  39 #include "../lowlevel/ftape-ctl.h"
  40 #include "../lowlevel/ftape-proc.h"
  41 #include "../lowlevel/ftape-tracing.h"
  42
  43 static size_t get_driver_info(char *buf)
  44 {
  45         const char *debug_level[] = { "bugs"  ,
  46                                       "errors",
  47                                       "warnings",
  48                                       "informational",
  49                                       "noisy",
  50                                       "program flow",
  51                                       "fdc and dma",
  52                                       "data flow",
  53                                       "anything" };
  54
  55         return sprintf(buf,
  56                        "version       : %s\n"
  57                        "used data rate: %d kbit/sec\n"
  58                        "dma memory    : %d kb\n"
  59                        "debug messages: %s\n",
  60                        FTAPE_VERSION,
  61                        ft_data_rate,
  62                        FT_BUFF_SIZE * ft_nr_buffers >> 10,
  63                        debug_level[TRACE_LEVEL]);
  64 }
  65
  66 static size_t get_tapedrive_info(char *buf)
  67 {
  68         return sprintf(buf,
  69                        "vendor id : 0x%04x\n"
  70                        "drive name: %s\n"
  71                        "wind speed: %d ips\n"
  72                        "wakeup    : %s\n"
  73                        "max. rate : %d kbit/sec\n",
  74                        ft_drive_type.vendor_id,
  75                        ft_drive_type.name,
  76                        ft_drive_type.speed,
  77                        ((ft_drive_type.wake_up == no_wake_up)
  78                         ? "No wakeup needed" :
  79                         ((ft_drive_type.wake_up == wake_up_colorado)
  80                          ? "Colorado" :
  81                          ((ft_drive_type.wake_up == wake_up_mountain)
  82                           ? "Mountain" :
  83                           ((ft_drive_type.wake_up == wake_up_insight)
  84                            ? "Motor on" :
  85                            "Unknown")))),
  86                        ft_drive_max_rate);
  87 }
  88
  89 static size_t get_cartridge_info(char *buf)
  90 {
  91         if (ftape_init_drive_needed) {
  92                 return sprintf(buf, "uninitialized\n");
  93         }
  94         if (ft_no_tape) {
  95                 return sprintf(buf, "no cartridge inserted\n");
  96         }
  97         return sprintf(buf,
  98                        "segments  : %5d\n"
  99                        "tracks    : %5d\n"
 100                        "length    : %5dft\n"
 101                        "formatted : %3s\n"
 102                        "writable  : %3s\n"
 103                        "QIC spec. : QIC-%s\n"
 104                        "fmt-code  : %1d\n",
 105                        ft_segments_per_track,
 106                        ft_tracks_per_tape,
 107                        ftape_tape_len,
 108                        (ft_formatted == 1) ? "yes" : "no",
 109                        (ft_write_protected == 1) ? "no" : "yes",
 110                        ((ft_qic_std == QIC_TAPE_QIC40) ? "40" :
 111                         ((ft_qic_std == QIC_TAPE_QIC80) ? "80" :
 112                          ((ft_qic_std == QIC_TAPE_QIC3010) ? "3010" :
 113                           ((ft_qic_std == QIC_TAPE_QIC3020) ? "3020" :
 114                            "???")))),
 115                        ft_format_code);
 116 }
 117
 118 static size_t get_controller_info(char *buf)
 119 {
 120         const char  *fdc_name[] = { "no fdc",
 121                                     "i8272",
 122                                     "i82077",
 123                                     "i82077AA",
 124                                     "Colorado FC-10 or FC-20",
 125                                     "i82078",
 126                                     "i82078_1" };
 127
 128         return sprintf(buf,
 129                        "FDC type  : %s\n"
 130                        "FDC base  : 0x%03x\n"
 131                        "FDC irq   : %d\n"
 132                        "FDC dma   : %d\n"
 133                        "FDC thr.  : %d\n"
 134                        "max. rate : %d kbit/sec\n",
 135                        ft_mach2 ? "Mountain MACH-2" : fdc_name[fdc.type],
 136                        fdc.sra, fdc.irq, fdc.dma,
 137                        ft_fdc_threshold, ft_fdc_max_rate);
 138 }
 139
 140 static size_t get_history_info(char *buf)
 141 {
 142         size_t len;
 143
 144         len  = sprintf(buf,
 145                        "\nFDC isr statistics\n"
 146                        " id_am_errors     : %3d\n"
 147                        " id_crc_errors    : %3d\n"
 148                        " data_am_errors   : %3d\n"
 149                        " data_crc_errors  : %3d\n"
 150                        " overrun_errors   : %3d\n"
 151                        " no_data_errors   : %3d\n"
 152                        " retries          : %3d\n",
 153                        ft_history.id_am_errors,   ft_history.id_crc_errors,
 154                        ft_history.data_am_errors, ft_history.data_crc_errors,
 155                        ft_history.overrun_errors, ft_history.no_data_errors,
 156                        ft_history.retries);
 157         len += sprintf(buf + len,
 158                        "\nECC statistics\n"
 159                        " crc_errors       : %3d\n"
 160                        " crc_failures     : %3d\n"
 161                        " ecc_failures     : %3d\n"
 162                        " sectors corrected: %3d\n",
 163                        ft_history.crc_errors,   ft_history.crc_failures,
 164                        ft_history.ecc_failures, ft_history.corrected);
 165         len += sprintf(buf + len,
 166                        "\ntape quality statistics\n"
 167                        " media defects    : %3d\n",
 168                        ft_history.defects);
 169         len += sprintf(buf + len,
 170                        "\ntape motion statistics\n"
 171                        " repositions      : %3d\n",
 172                        ft_history.rewinds);
 173         return len;
 174 }
 175
 176 static int ftape_read_proc(char *page, char **start, off_t off,
 177                            int count, int *eof, void *data)
 178 {
 179         char *ptr = page;
 180         size_t len;
 181
 182         ptr += sprintf(ptr, "Kernel Driver\n\n");
 183         ptr += get_driver_info(ptr);
 184         ptr += sprintf(ptr, "\nTape Drive\n\n");
 185         ptr += get_tapedrive_info(ptr);
 186         ptr += sprintf(ptr, "\nFDC Controller\n\n");
 187         ptr += get_controller_info(ptr);
 188         ptr += sprintf(ptr, "\nTape Cartridge\n\n");
 189         ptr += get_cartridge_info(ptr);
 190         ptr += sprintf(ptr, "\nHistory Record\n\n");
 191         ptr += get_history_info(ptr);
 192
 193         len = strlen(page);
 194         *start = NULL;
 195         if (off+count >= len) {
 196                 *eof = 1;
 197         } else {
 198                 *eof = 0;
 199         }
 200         return len;
 201 }
 202
 203 int __init ftape_proc_init(void)
 204 {
 205         return create_proc_read_entry("ftape", 0, &proc_root,
 206                 ftape_read_proc, NULL) != NULL;
 207 }
 208
 209 void ftape_proc_destroy(void)
 210 {
 211         remove_proc_entry("ftape", &proc_root);
 212 }
 213
 214 #endif /* defined(CONFIG_PROC_FS) && defined(CONFIG_FT_PROC_FS) */