root/drivers/char/mem.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. read_ram
  2. write_ram
  3. read_mem
  4. write_mem
  5. mmap_mem
  6. read_kmem
  7. read_port
  8. write_port
  9. read_null
  10. write_null
  11. read_zero
  12. mmap_zero
  13. read_full
  14. write_full
  15. null_lseek
  16. memory_lseek
  17. memory_open
  18. chr_dev_init

   1 /*
   2  *  linux/drivers/char/mem.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6 
   7 #include <linux/config.h>
   8 #include <linux/types.h>
   9 #include <linux/errno.h>
  10 #include <linux/sched.h>
  11 #include <linux/kernel.h>
  12 #include <linux/major.h>
  13 #include <linux/tty.h>
  14 #include <linux/mouse.h>
  15 #include <linux/tpqic02.h>
  16 #include <linux/malloc.h>
  17 #include <linux/mman.h>
  18 
  19 #include <asm/segment.h>
  20 #include <asm/io.h>
  21 
  22 #ifdef CONFIG_SOUND
  23 extern long soundcard_init(long mem_start);
  24 #endif
  25 
  26 static int read_ram(struct inode * inode, struct file * file,char * buf, int count)
     /* [previous][next][first][last][top][bottom][index][help] */
  27 {
  28         return -EIO;
  29 }
  30 
  31 static int write_ram(struct inode * inode, struct file * file,char * buf, int count)
     /* [previous][next][first][last][top][bottom][index][help] */
  32 {
  33         return -EIO;
  34 }
  35 
  36 static int read_mem(struct inode * inode, struct file * file,char * buf, int count)
     /* [previous][next][first][last][top][bottom][index][help] */
  37 {
  38         unsigned long p = file->f_pos;
  39         int read;
  40 
  41         if (count < 0)
  42                 return -EINVAL;
  43         if (p >= high_memory)
  44                 return 0;
  45         if (count > high_memory - p)
  46                 count = high_memory - p;
  47         read = 0;
  48         while (p < PAGE_SIZE && count > 0) {
  49                 put_fs_byte(0,buf);
  50                 buf++;
  51                 p++;
  52                 count--;
  53                 read++;
  54         }
  55         memcpy_tofs(buf,(void *) p,count);
  56         read += count;
  57         file->f_pos += read;
  58         return read;
  59 }
  60 
  61 static int write_mem(struct inode * inode, struct file * file,char * buf, int count)
     /* [previous][next][first][last][top][bottom][index][help] */
  62 {
  63         unsigned long p = file->f_pos;
  64         int written;
  65 
  66         if (count < 0)
  67                 return -EINVAL;
  68         if (p >= high_memory)
  69                 return 0;
  70         if (count > high_memory - p)
  71                 count = high_memory - p;
  72         written = 0;
  73         while (p < PAGE_SIZE && count > 0) {
  74                 /* Hmm. Do something? */
  75                 buf++;
  76                 p++;
  77                 count--;
  78                 written++;
  79         }
  80         memcpy_fromfs((void *) p,buf,count);
  81         written += count;
  82         file->f_pos += written;
  83         return count;
  84 }
  85 
  86 static int mmap_mem(struct inode * inode, struct file * file, struct vm_area_struct * vma)
     /* [previous][next][first][last][top][bottom][index][help] */
  87 {
  88         if (vma->vm_offset & ~PAGE_MASK)
  89                 return -ENXIO;
  90 #ifdef __i386__
  91         if (x86 > 3 && vma->vm_offset >= high_memory)
  92                 vma->vm_page_prot |= PAGE_PCD;
  93 #endif
  94         if (remap_page_range(vma->vm_start, vma->vm_offset, vma->vm_end - vma->vm_start, vma->vm_page_prot))
  95                 return -EAGAIN;
  96         vma->vm_inode = inode;
  97         inode->i_count++;
  98         return 0;
  99 }
 100 
 101 static int read_kmem(struct inode *inode, struct file *file, char *buf, int count)
     /* [previous][next][first][last][top][bottom][index][help] */
 102 {
 103         int read1, read2;
 104 
 105         read1 = read_mem(inode, file, buf, count);
 106         if (read1 < 0)
 107                 return read1;
 108         read2 = vread(buf + read1, (char *) ((unsigned long) file->f_pos), count - read1);
 109         if (read2 < 0)
 110                 return read2;
 111         file->f_pos += read2;
 112         return read1 + read2;
 113 }
 114 
 115 static int read_port(struct inode * inode,struct file * file,char * buf, int count)
     /* [previous][next][first][last][top][bottom][index][help] */
 116 {
 117         unsigned int i = file->f_pos;
 118         char * tmp = buf;
 119 
 120         while (count-- > 0 && i < 65536) {
 121                 put_fs_byte(inb(i),tmp);
 122                 i++;
 123                 tmp++;
 124         }
 125         file->f_pos = i;
 126         return tmp-buf;
 127 }
 128 
 129 static int write_port(struct inode * inode,struct file * file,char * buf, int count)
     /* [previous][next][first][last][top][bottom][index][help] */
 130 {
 131         unsigned int i = file->f_pos;
 132         char * tmp = buf;
 133 
 134         while (count-- > 0 && i < 65536) {
 135                 outb(get_fs_byte(tmp),i);
 136                 i++;
 137                 tmp++;
 138         }
 139         file->f_pos = i;
 140         return tmp-buf;
 141 }
 142 
 143 static int read_null(struct inode * node,struct file * file,char * buf,int count)
     /* [previous][next][first][last][top][bottom][index][help] */
 144 {
 145         return 0;
 146 }
 147 
 148 static int write_null(struct inode * inode,struct file * file,char * buf, int count)
     /* [previous][next][first][last][top][bottom][index][help] */
 149 {
 150         return count;
 151 }
 152 
 153 static int read_zero(struct inode * node,struct file * file,char * buf,int count)
     /* [previous][next][first][last][top][bottom][index][help] */
 154 {
 155         int left;
 156 
 157         for (left = count; left > 0; left--) {
 158                 put_fs_byte(0,buf);
 159                 buf++;
 160         }
 161         return count;
 162 }
 163 
 164 static int mmap_zero(struct inode * inode, struct file * file, struct vm_area_struct * vma)
     /* [previous][next][first][last][top][bottom][index][help] */
 165 {
 166         if (vma->vm_page_prot & PAGE_RW)
 167                 return -EINVAL;
 168         if (zeromap_page_range(vma->vm_start, vma->vm_end - vma->vm_start, vma->vm_page_prot))
 169                 return -EAGAIN;
 170         return 0;
 171 }
 172 
 173 static int read_full(struct inode * node,struct file * file,char * buf,int count)
     /* [previous][next][first][last][top][bottom][index][help] */
 174 {
 175         return count;
 176 }
 177 
 178 static int write_full(struct inode * inode,struct file * file,char * buf, int count)
     /* [previous][next][first][last][top][bottom][index][help] */
 179 {
 180         return -ENOSPC;
 181 }
 182 
 183 /*
 184  * Special lseek() function for /dev/null and /dev/zero.  Most notably, you can fopen()
 185  * both devices with "a" now.  This was previously impossible.  SRB.
 186  */
 187 
 188 static int null_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
     /* [previous][next][first][last][top][bottom][index][help] */
 189 {
 190         return file->f_pos=0;
 191 }
 192 /*
 193  * The memory devices use the full 32 bits of the offset, and so we cannot
 194  * check against negative addresses: they are ok. The return value is weird,
 195  * though, in that case (0).
 196  *
 197  * also note that seeking relative to the "end of file" isn't supported:
 198  * it has no meaning, so it returns -EINVAL.
 199  */
 200 static int memory_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
     /* [previous][next][first][last][top][bottom][index][help] */
 201 {
 202         switch (orig) {
 203                 case 0:
 204                         file->f_pos = offset;
 205                         return file->f_pos;
 206                 case 1:
 207                         file->f_pos += offset;
 208                         return file->f_pos;
 209                 default:
 210                         return -EINVAL;
 211         }
 212         if (file->f_pos < 0)
 213                 return 0;
 214         return file->f_pos;
 215 }
 216 
 217 #define write_kmem      write_mem
 218 #define mmap_kmem       mmap_mem
 219 #define zero_lseek      null_lseek
 220 #define write_zero      write_null
 221 
 222 static struct file_operations ram_fops = {
 223         memory_lseek,
 224         read_ram,
 225         write_ram,
 226         NULL,           /* ram_readdir */
 227         NULL,           /* ram_select */
 228         NULL,           /* ram_ioctl */
 229         NULL,           /* ram_mmap */
 230         NULL,           /* no special open code */
 231         NULL,           /* no special release code */
 232         NULL            /* fsync */
 233 };
 234 
 235 static struct file_operations mem_fops = {
 236         memory_lseek,
 237         read_mem,
 238         write_mem,
 239         NULL,           /* mem_readdir */
 240         NULL,           /* mem_select */
 241         NULL,           /* mem_ioctl */
 242         mmap_mem,
 243         NULL,           /* no special open code */
 244         NULL,           /* no special release code */
 245         NULL            /* fsync */
 246 };
 247 
 248 static struct file_operations kmem_fops = {
 249         memory_lseek,
 250         read_kmem,
 251         write_kmem,
 252         NULL,           /* kmem_readdir */
 253         NULL,           /* kmem_select */
 254         NULL,           /* kmem_ioctl */
 255         mmap_kmem,
 256         NULL,           /* no special open code */
 257         NULL,           /* no special release code */
 258         NULL            /* fsync */
 259 };
 260 
 261 static struct file_operations null_fops = {
 262         null_lseek,
 263         read_null,
 264         write_null,
 265         NULL,           /* null_readdir */
 266         NULL,           /* null_select */
 267         NULL,           /* null_ioctl */
 268         NULL,           /* null_mmap */
 269         NULL,           /* no special open code */
 270         NULL,           /* no special release code */
 271         NULL            /* fsync */
 272 };
 273 
 274 static struct file_operations port_fops = {
 275         memory_lseek,
 276         read_port,
 277         write_port,
 278         NULL,           /* port_readdir */
 279         NULL,           /* port_select */
 280         NULL,           /* port_ioctl */
 281         NULL,           /* port_mmap */
 282         NULL,           /* no special open code */
 283         NULL,           /* no special release code */
 284         NULL            /* fsync */
 285 };
 286 
 287 static struct file_operations zero_fops = {
 288         zero_lseek,
 289         read_zero,
 290         write_zero,
 291         NULL,           /* zero_readdir */
 292         NULL,           /* zero_select */
 293         NULL,           /* zero_ioctl */
 294         mmap_zero,
 295         NULL,           /* no special open code */
 296         NULL            /* no special release code */
 297 };
 298 
 299 static struct file_operations full_fops = {
 300         memory_lseek,
 301         read_full,
 302         write_full,
 303         NULL,           /* full_readdir */
 304         NULL,           /* full_select */
 305         NULL,           /* full_ioctl */        
 306         NULL,           /* full_mmap */
 307         NULL,           /* no special open code */
 308         NULL            /* no special release code */
 309 };
 310 
 311 static int memory_open(struct inode * inode, struct file * filp)
     /* [previous][next][first][last][top][bottom][index][help] */
 312 {
 313         switch (MINOR(inode->i_rdev)) {
 314                 case 0:
 315                         filp->f_op = &ram_fops;
 316                         break;
 317                 case 1:
 318                         filp->f_op = &mem_fops;
 319                         break;
 320                 case 2:
 321                         filp->f_op = &kmem_fops;
 322                         break;
 323                 case 3:
 324                         filp->f_op = &null_fops;
 325                         break;
 326                 case 4:
 327                         filp->f_op = &port_fops;
 328                         break;
 329                 case 5:
 330                         filp->f_op = &zero_fops;
 331                         break;
 332                 case 7:
 333                         filp->f_op = &full_fops;
 334                         break;
 335                 default:
 336                         return -ENODEV;
 337         }
 338         if (filp->f_op && filp->f_op->open)
 339                 return filp->f_op->open(inode,filp);
 340         return 0;
 341 }
 342 
 343 static struct file_operations memory_fops = {
 344         NULL,           /* lseek */
 345         NULL,           /* read */
 346         NULL,           /* write */
 347         NULL,           /* readdir */
 348         NULL,           /* select */
 349         NULL,           /* ioctl */
 350         NULL,           /* mmap */
 351         memory_open,    /* just a selector for the real open */
 352         NULL,           /* release */
 353         NULL            /* fsync */
 354 };
 355 
 356 #ifdef CONFIG_FTAPE
 357 char* ftape_big_buffer;
 358 #endif
 359 
 360 long chr_dev_init(long mem_start, long mem_end)
     /* [previous][next][first][last][top][bottom][index][help] */
 361 {
 362         if (register_chrdev(MEM_MAJOR,"mem",&memory_fops))
 363                 printk("unable to get major %d for memory devs\n", MEM_MAJOR);
 364         mem_start = tty_init(mem_start);
 365 #ifdef CONFIG_PRINTER
 366         mem_start = lp_init(mem_start);
 367 #endif
 368 #if defined (CONFIG_BUSMOUSE) || defined (CONFIG_82C710_MOUSE) || \
 369     defined (CONFIG_PSMOUSE) || defined (CONFIG_MS_BUSMOUSE) || \
 370     defined (CONFIG_ATIXL_BUSMOUSE)
 371         mem_start = mouse_init(mem_start);
 372 #endif
 373 #ifdef CONFIG_SOUND
 374         mem_start = soundcard_init(mem_start);
 375 #endif
 376 #if CONFIG_QIC02_TAPE
 377         mem_start = qic02_tape_init(mem_start);
 378 #endif
 379 /*
 380  *      Rude way to allocate kernel memory buffer for tape device
 381  */
 382 #ifdef CONFIG_FTAPE
 383         /* allocate NR_FTAPE_BUFFERS 32Kb buffers at aligned address */
 384         ftape_big_buffer= (char*) ((mem_start + 0x7fff) & ~0x7fff);
 385         printk( "ftape: allocated %d buffers aligned at: %p\n",
 386                NR_FTAPE_BUFFERS, ftape_big_buffer);
 387         mem_start = (long) ftape_big_buffer + NR_FTAPE_BUFFERS * 0x8000;
 388 #endif 
 389         return mem_start;
 390 }

/* [previous][next][first][last][top][bottom][index][help] */