kern/kfile.h

   1 /**
   2  * \file
   3  * <!--
   4  * This file is part of BeRTOS.
   5  *
   6  * Bertos 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 of the License, or
   9  * (at your option) 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; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  * As a special exception, you may use this file as part of a free software
  21  * library without restriction.  Specifically, if other files instantiate
  22  * templates or use macros or inline functions from this file, or you compile
  23  * this file and link it with other files to produce an executable, this
  24  * file does not by itself cause the resulting executable to be covered by
  25  * the GNU General Public License.  This exception does not however
  26  * invalidate any other reasons why the executable file might be covered by
  27  * the GNU General Public License.
  28  *
  29  * Copyright 2004 Develer S.r.l. (http://www.develer.com/)
  30  * Copyright 1999, 2000, 2001, 2003 Bernardo Innocenti <bernie@develer.com>
  31  *
  32  * -->
  33  *
  34  * \brief Virtual KFile I/O interface.
  35  * KFile is a generic interface for file I/O.
  36  * Uses an of object oriented model to supply
  37  * a generic interface for drivers to communicate.
  38  * This module contains only definitions,data structure
  39  * and an API.
  40  * Each KFile user should implement at least some core functions.
  41  * E.G.
  42  * If you have a serial driver and want to comply to KFile interface,
  43  * you have to declare your context structure:
  44  *
  45  * \code
  46  * typedef struct KFileSerial
  47  * {
  48  *      KFile fd;
  49  *      Serial *ser;
  50  * } KFileSerial;
  51  * \endcode
  52  *
  53  * You should also supply a macro for casting KFile to KFileSerial:
  54  *
  55  * \code
  56  * INLINE KFileSerial * KFILESERIAL(KFile *fd)
  57  * {
  58  *      ASSERT(fd->_type == KFT_SERIAL);
  59  *      return (KFileSerial *)fd;
  60  * }
  61  * \endcode
  62  *
  63  * Then you can implement as much interface functions as you like
  64  * and leave the others to NULL.
  65  * ser_close implementation example:
  66  *
  67  * \code
  68  * static int ser_kfile_close(struct KFile *fd)
  69  * {
  70  *      KFileSerial *fds = KFILESERIAL(fd);
  71  *      ser_close(fds->ser);
  72  *      return 0;
  73  * }
  74  * \endcode
  75  * KFILESERIAL macro helps to ensure that obj passed is really a Serial.
  76  *
  77  * KFile interface do not supply the open function: this is done deliberately,
  78  * because in embedded systems each device has its own init parameters.
  79  * For the same reason specific file settings (like baudrate for Serial, for example)
  80  * are demanded to specific driver implementation.
  81  *
  82  * \version $Id$
  83  * \author Bernardo Innocenti <bernie@develer.com>
  84  * \author Francesco Sacchi <batt@develer.com>
  85  * \author Daniele Basile <asterix@develer.com>
  86  */
  87
  88 #ifndef KERN_KFILE_H
  89 #define KERN_KFILE_H
  90
  91 #include <cfg/compiler.h>
  92 #include <cfg/debug.h>
  93
  94 /* fwd decl */
  95 struct KFile;
  96
  97 typedef int32_t kfile_off_t; ///< KFile offset type, used by kfile_seek function.
  98
  99 /**
 100  * Costants for repositioning read/write file offset.
 101  * These are needed because on some embedded platforms
 102  * ANSI I/O library may not be present.
 103  */
 104 typedef enum KSeekMode
 105 {
 106         KSM_SEEK_SET, ///< Seek from file beginning.
 107         KSM_SEEK_CUR, ///< Seek from file current position.
 108         KSM_SEEK_END, ///< Seek from file end.
 109 } KSeekMode;
 110
 111 /**
 112  * Prototypes for KFile access functions.
 113  * I/O file function must be ANSI compliant.
 114  * \note A KFile user can choose which function subset to implement,
 115  *       but has to set to NULL unimplemented features.
 116  * \{
 117  */
 118
 119 /**
 120  * Read from file.
 121  * \return the number of bytes read.
 122  */
 123 typedef size_t (*ReadFunc_t) (struct KFile *fd, void *buf, size_t size);
 124
 125 /**
 126  * Write to file.
 127  * \return the number of bytes written.
 128  */
 129 typedef size_t (*WriteFunc_t) (struct KFile *fd, const void *buf, size_t size);
 130
 131 /**
 132  * Seek into file (if seekable).
 133  * \return the new file offset or EOF on errors.
 134  */
 135 typedef kfile_off_t (*SeekFunc_t) (struct KFile *fd, kfile_off_t offset, KSeekMode whence);
 136
 137 /**
 138  * Close and reopen file \a fd.
 139  * The reopening is done with the former file parameters and access modes.
 140  */
 141 typedef struct KFile * (*ReOpenFunc_t) (struct KFile *fd);
 142
 143 /**
 144  * Close file.
 145  * \return 0 on success, EOF on errors.
 146  */
 147 typedef int (*CloseFunc_t) (struct KFile *fd);
 148
 149 /**
 150  * Flush file I/O.
 151  * \return 0 on success, EOF on errors.
 152  */
 153 typedef int (*FlushFunc_t) (struct KFile *fd);
 154
 155 /**
 156  * Get file error mask.
 157  * \return 0 on success or file error code, device specific.
 158  */
 159 typedef int (*ErrorFunc_t) (struct KFile *fd);
 160
 161 /**
 162  * Clear errors.
 163  */
 164 typedef void (*ClearErrFunc_t) (struct KFile *fd);
 165 /* \} */
 166
 167 /**
 168  * Context data for callback functions which operate on
 169  * pseudo files.
 170  * \note If you change interface, remember to add corresponding access function.
 171  */
 172 typedef struct KFile
 173 {
 174         ReadFunc_t     read;
 175         WriteFunc_t    write;
 176         ReOpenFunc_t   reopen;
 177         CloseFunc_t    close;
 178         SeekFunc_t     seek;
 179         FlushFunc_t    flush;
 180         ErrorFunc_t    error;
 181         ClearErrFunc_t clearerr;
 182         DB(id_t _type); ///< Used to keep trace, at runtime, of obj type.
 183
 184         /* NOTE: these must _NOT_ be size_t on 16bit CPUs! */
 185         uint32_t seek_pos;
 186         uint32_t size;
 187 } KFile;
 188
 189 /**
 190  * Generic implementation of kfile_seek.
 191  */
 192 kfile_off_t kfile_genericSeek(struct KFile *fd, kfile_off_t offset, KSeekMode whence);
 193
 194 /**
 195  * Generic implementation of kfile_reopen.
 196  */
 197 struct KFile * kfile_genericReopen(struct KFile *fd);
 198
 199 int kfile_putc(int c, struct KFile *fd); ///< Generic putc implementation using kfile_write.
 200 int kfile_getc(struct KFile *fd);  ///< Generic getc implementation using kfile_read.
 201 int kfile_printf(struct KFile *fd, const char *format, ...);
 202 int kfile_print(struct KFile *fd, const char *s);
 203 int kfile_gets(struct KFile *fd, char *buf, int size);
 204 int kfile_gets_echo(struct KFile *fd, char *buf, int size, bool echo);
 205
 206 /**
 207  * Interface functions for KFile access.
 208  * \note Remember to change following functions if KFile interface changes.
 209  * \{
 210  */
 211 INLINE size_t kfile_read(struct KFile *fd, void *buf, size_t size)
 212 {
 213         ASSERT(fd->read);
 214         return fd->read(fd, buf, size);
 215 }
 216
 217 INLINE size_t kfile_write(struct KFile *fd, const void *buf, size_t size)
 218 {
 219         ASSERT(fd->write);
 220         return fd->write(fd, buf, size);
 221 }
 222
 223 INLINE KFile * kfile_reopen(struct KFile *fd)
 224 {
 225         ASSERT(fd->reopen);
 226         return fd->reopen(fd);
 227 }
 228
 229 INLINE int kfile_close(struct KFile *fd)
 230 {
 231         ASSERT(fd->close);
 232         return fd->close(fd);
 233 }
 234
 235 INLINE kfile_off_t kfile_seek(struct KFile *fd, kfile_off_t offset, KSeekMode whence)
 236 {
 237         ASSERT(fd->seek);
 238         return fd->seek(fd, offset, whence);
 239 }
 240
 241 INLINE int kfile_flush(struct KFile *fd)
 242 {
 243         ASSERT(fd->flush);
 244         return fd->flush(fd);
 245 }
 246
 247 INLINE int kfile_error(struct KFile *fd)
 248 {
 249         ASSERT(fd->error);
 250         return fd->error(fd);
 251 }
 252
 253 INLINE void kfile_clearerr(struct KFile *fd)
 254 {
 255         ASSERT(fd->clearerr);
 256         fd->clearerr(fd);
 257 }
 258 /* \} */
 259
 260 /**
 261  * Kfile test function.
 262  */
 263 bool kfile_test(KFile *fd, uint8_t *test_buf, uint8_t *save_buf, size_t size);
 264
 265 #endif /* KERN_KFILE_H */