drivers/block/paride/bpck6.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
bpck6_read_regr
bpck6_write_regr
bpck6_write_block
bpck6_read_block
bpck6_connect
bpck6_disconnect
bpck6_test_port
bpck6_probe_unit
bpck6_log_adapter
bpck6_init_proto
bpck6_release_proto
bpck6_init
bpck6_exit
   1 /*
   2         backpack.c (c) 2001 Micro Solutions Inc.
   3                 Released under the terms of the GNU General Public license
   4 
   5         backpack.c is a low-level protocol driver for the Micro Solutions
   6                 "BACKPACK" parallel port IDE adapter
   7                 (Works on Series 6 drives)
   8 
   9         Written by: Ken Hahn     (linux-dev@micro-solutions.com)
  10                     Clive Turvey (linux-dev@micro-solutions.com)
  11 
  12 */
  13 
  14 /*
  15    This is Ken's linux wrapper for the PPC library
  16    Version 1.0.0 is the backpack driver for which source is not available
  17    Version 2.0.0 is the first to have source released 
  18    Version 2.0.1 is the "Cox-ified" source code 
  19    Version 2.0.2 - fixed version string usage, and made ppc functions static 
  20 */
  21 
  22 
  23 #define BACKPACK_VERSION "2.0.2"
  24 
  25 #include <linux/module.h>
  26 #include <linux/init.h>
  27 #include <linux/kernel.h>
  28 #include <linux/slab.h>
  29 #include <linux/types.h>
  30 #include <asm/io.h>
  31 #include <linux/parport.h>
  32 
  33 #include "ppc6lnx.c"
  34 #include "paride.h"
  35 
  36 /* PARAMETERS */
  37 static bool verbose; /* set this to 1 to see debugging messages and whatnot */
  38  
  39 
  40 #define PPCSTRUCT(pi) ((Interface *)(pi->private))
  41 
  42 /****************************************************************/
  43 /*
  44  ATAPI CDROM DRIVE REGISTERS
  45 */
  46 #define ATAPI_DATA       0      /* data port                  */
  47 #define ATAPI_ERROR      1      /* error register (read)      */
  48 #define ATAPI_FEATURES   1      /* feature register (write)   */
  49 #define ATAPI_INT_REASON 2      /* interrupt reason register  */
  50 #define ATAPI_COUNT_LOW  4      /* byte count register (low)  */
  51 #define ATAPI_COUNT_HIGH 5      /* byte count register (high) */
  52 #define ATAPI_DRIVE_SEL  6      /* drive select register      */
  53 #define ATAPI_STATUS     7      /* status port (read)         */
  54 #define ATAPI_COMMAND    7      /* command port (write)       */
  55 #define ATAPI_ALT_STATUS 0x0e /* alternate status reg (read) */
  56 #define ATAPI_DEVICE_CONTROL 0x0e /* device control (write)   */
  57 /****************************************************************/
  58 
  59 static int bpck6_read_regr(PIA *pi, int cont, int reg)
  60 {
  61         unsigned int out;
  62 
  63         /* check for bad settings */
  64         if (reg<0 || reg>7 || cont<0 || cont>2)
  65         {
  66                 return(-1);
  67         }
  68         out=ppc6_rd_port(PPCSTRUCT(pi),cont?reg|8:reg);
  69         return(out);
  70 }
  71 
  72 static void bpck6_write_regr(PIA *pi, int cont, int reg, int val)
  73 {
  74         /* check for bad settings */
  75         if (reg>=0 && reg<=7 && cont>=0 && cont<=1)
  76         {
  77                 ppc6_wr_port(PPCSTRUCT(pi),cont?reg|8:reg,(u8)val);
  78         }
  79 }
  80 
  81 static void bpck6_write_block( PIA *pi, char * buf, int len )
  82 {
  83         ppc6_wr_port16_blk(PPCSTRUCT(pi),ATAPI_DATA,buf,(u32)len>>1); 
  84 }
  85 
  86 static void bpck6_read_block( PIA *pi, char * buf, int len )
  87 {
  88         ppc6_rd_port16_blk(PPCSTRUCT(pi),ATAPI_DATA,buf,(u32)len>>1);
  89 }
  90 
  91 static void bpck6_connect ( PIA *pi  )
  92 {
  93         if(verbose)
  94         {
  95                 printk(KERN_DEBUG "connect\n");
  96         }
  97 
  98         if(pi->mode >=2)
  99         {
 100                 PPCSTRUCT(pi)->mode=4+pi->mode-2;       
 101         }
 102         else if(pi->mode==1)
 103         {
 104                 PPCSTRUCT(pi)->mode=3;  
 105         }
 106         else
 107         {
 108                 PPCSTRUCT(pi)->mode=1;          
 109         }
 110 
 111         ppc6_open(PPCSTRUCT(pi));  
 112         ppc6_wr_extout(PPCSTRUCT(pi),0x3);
 113 }
 114 
 115 static void bpck6_disconnect ( PIA *pi )
 116 {
 117         if(verbose)
 118         {
 119                 printk("disconnect\n");
 120         }
 121         ppc6_wr_extout(PPCSTRUCT(pi),0x0);
 122         ppc6_close(PPCSTRUCT(pi));
 123 }
 124 
 125 static int bpck6_test_port ( PIA *pi )   /* check for 8-bit port */
 126 {
 127         if(verbose)
 128         {
 129                 printk(KERN_DEBUG "PARPORT indicates modes=%x for lp=0x%lx\n",
 130                         ((struct pardevice*)(pi->pardev))->port->modes,
 131                         ((struct pardevice *)(pi->pardev))->port->base); 
 132         }
 133 
 134         /*copy over duplicate stuff.. initialize state info*/
 135         PPCSTRUCT(pi)->ppc_id=pi->unit;
 136         PPCSTRUCT(pi)->lpt_addr=pi->port;
 137 
 138         /* look at the parport device to see if what modes we can use */
 139         if(((struct pardevice *)(pi->pardev))->port->modes & 
 140                 (PARPORT_MODE_EPP)
 141           )
 142         {
 143                 return 5; /* Can do EPP*/
 144         }
 145         else if(((struct pardevice *)(pi->pardev))->port->modes & 
 146                         (PARPORT_MODE_TRISTATE)
 147                )
 148         {
 149                 return 2;
 150         }
 151         else /*Just flat SPP*/
 152         {
 153                 return 1;
 154         }
 155 }
 156 
 157 static int bpck6_probe_unit ( PIA *pi )
 158 {
 159         int out;
 160 
 161         if(verbose)
 162         {
 163                 printk(KERN_DEBUG "PROBE UNIT %x on port:%x\n",pi->unit,pi->port);
 164         }
 165 
 166         /*SET PPC UNIT NUMBER*/
 167         PPCSTRUCT(pi)->ppc_id=pi->unit;
 168 
 169         /*LOWER DOWN TO UNIDIRECTIONAL*/
 170         PPCSTRUCT(pi)->mode=1;          
 171 
 172         out=ppc6_open(PPCSTRUCT(pi));
 173 
 174         if(verbose)
 175         {
 176                 printk(KERN_DEBUG "ppc_open returned %2x\n",out);
 177         }
 178 
 179         if(out)
 180         {
 181                 ppc6_close(PPCSTRUCT(pi));
 182                 if(verbose)
 183                 {
 184                         printk(KERN_DEBUG "leaving probe\n");
 185                 }
 186                return(1);
 187         }
 188         else
 189         {
 190                 if(verbose)
 191                 {
 192                         printk(KERN_DEBUG "Failed open\n");
 193                 }
 194                 return(0);
 195         }
 196 }
 197 
 198 static void bpck6_log_adapter( PIA *pi, char * scratch, int verbose )
 199 {
 200         char *mode_string[5]=
 201                 {"4-bit","8-bit","EPP-8","EPP-16","EPP-32"};
 202 
 203         printk("%s: BACKPACK Protocol Driver V"BACKPACK_VERSION"\n",pi->device);
 204         printk("%s: Copyright 2001 by Micro Solutions, Inc., DeKalb IL.\n",pi->device);
 205         printk("%s: BACKPACK %s, Micro Solutions BACKPACK Drive at 0x%x\n",
 206                 pi->device,BACKPACK_VERSION,pi->port);
 207         printk("%s: Unit: %d Mode:%d (%s) Delay %d\n",pi->device,
 208                 pi->unit,pi->mode,mode_string[pi->mode],pi->delay);
 209 }
 210 
 211 static int bpck6_init_proto(PIA *pi)
 212 {
 213         Interface *p = kzalloc(sizeof(Interface), GFP_KERNEL);
 214 
 215         if (p) {
 216                 pi->private = (unsigned long)p;
 217                 return 0;
 218         }
 219 
 220         printk(KERN_ERR "%s: ERROR COULDN'T ALLOCATE MEMORY\n", pi->device); 
 221         return -1;
 222 }
 223 
 224 static void bpck6_release_proto(PIA *pi)
 225 {
 226         kfree((void *)(pi->private)); 
 227 }
 228 
 229 static struct pi_protocol bpck6 = {
 230         .owner          = THIS_MODULE,
 231         .name           = "bpck6",
 232         .max_mode       = 5,
 233         .epp_first      = 2, /* 2-5 use epp (need 8 ports) */
 234         .max_units      = 255,
 235         .write_regr     = bpck6_write_regr,
 236         .read_regr      = bpck6_read_regr,
 237         .write_block    = bpck6_write_block,
 238         .read_block     = bpck6_read_block,
 239         .connect        = bpck6_connect,
 240         .disconnect     = bpck6_disconnect,
 241         .test_port      = bpck6_test_port,
 242         .probe_unit     = bpck6_probe_unit,
 243         .log_adapter    = bpck6_log_adapter,
 244         .init_proto     = bpck6_init_proto,
 245         .release_proto  = bpck6_release_proto,
 246 };
 247 
 248 static int __init bpck6_init(void)
 249 {
 250         printk(KERN_INFO "bpck6: BACKPACK Protocol Driver V"BACKPACK_VERSION"\n");
 251         printk(KERN_INFO "bpck6: Copyright 2001 by Micro Solutions, Inc., DeKalb IL. USA\n");
 252         if(verbose)
 253                 printk(KERN_DEBUG "bpck6: verbose debug enabled.\n");
 254         return paride_register(&bpck6);
 255 }
 256 
 257 static void __exit bpck6_exit(void)
 258 {
 259         paride_unregister(&bpck6);
 260 }
 261 
 262 MODULE_LICENSE("GPL");
 263 MODULE_AUTHOR("Micro Solutions Inc.");
 264 MODULE_DESCRIPTION("BACKPACK Protocol module, compatible with PARIDE");
 265 module_param(verbose, bool, 0644);
 266 module_init(bpck6_init)
 267 module_exit(bpck6_exit)
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/block/paride/bpck6.c

DEFINITIONS
