sys/arch/ews4800mips/stand/common/datafs.c

   1 /*      $NetBSD: datafs.c,v 1.1 2005/12/29 15:20:09 tsutsui Exp $       */
   2
   3 /*-
   4  * Copyright (c) 2004 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by UCHIYAMA Yasushi.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <lib/libsa/stand.h>
  33 #include <lib/libkern/libkern.h>
  34
  35 #include "local.h"
  36
  37 FS_DEF(data);
  38
  39 struct fs_ops datafs_ops = {
  40         data_open, data_close, data_read, data_write, data_seek, data_stat
  41 };
  42
  43 struct datafs {
  44         uint8_t *ptr;
  45         uint8_t *end;
  46         uint8_t *start;
  47         size_t size;
  48 } __data;
  49
  50 void
  51 data_attach(void *addr, size_t size)
  52 {
  53
  54         __data.start = addr;
  55         __data.size = size;
  56 }
  57
  58 int
  59 data_open(const char *name, struct open_file *f)
  60 {
  61
  62         if (__data.size == 0) {
  63                 printf("no data\n");
  64                 return -1;
  65         }
  66
  67         __data.ptr = __data.start;
  68         __data.end = __data.ptr + __data.size;
  69
  70         return 0;
  71 }
  72
  73 int
  74 data_close(struct open_file *f)
  75 {
  76
  77         return 0;
  78 }
  79
  80 int
  81 data_read(struct open_file *f, void *buf, size_t size, size_t *resid)
  82 {
  83         uint8_t *b = buf;
  84         size_t sz;
  85
  86         twiddle();
  87         if (__data.ptr + size < __data.end) {
  88                 sz = size;
  89                 memcpy(b, __data.ptr, sz);
  90                 __data.ptr += sz;
  91         } else {
  92                 sz = (size_t)(__data.end - __data.ptr);
  93                 while (__data.ptr < __data.end)
  94                         *b++ = *__data.ptr++;
  95         }
  96
  97         if (resid)
  98                 *resid = size - sz;
  99
 100         return 0;
 101 }
 102
 103 int
 104 data_write(struct open_file *f, void *start, size_t size, size_t *resid)
 105 {
 106
 107         return 0;
 108 }
 109
 110 off_t
 111 data_seek(struct open_file *f, off_t offset, int where)
 112 {
 113         uint8_t *p = 0;
 114
 115         switch (where) {
 116         case SEEK_SET:
 117                 p = __data.start + offset;
 118                 break;
 119         case SEEK_CUR:
 120                 p = __data.ptr + offset;
 121                 break;
 122         case SEEK_END:
 123                 p = __data.end + offset;
 124                 break;
 125         default:
 126                 return EINVAL;
 127         }
 128
 129         if (p < __data.start || p >= __data.end) {
 130                 return EINVAL;
 131         }
 132
 133         __data.ptr = p;
 134
 135         return (off_t)(p - __data.start);
 136 }
 137
 138 int
 139 data_stat(struct open_file *f, struct stat *stat)
 140 {
 141
 142         stat->st_size = __data.size;
 143
 144         return 0;
 145 }