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  * It uses an object-oriented model to supply
  37  * a generic interface for drivers to communicate.
  38  * This module contains only definitions, the instance structure
  39  * and an API.
  40  * Each KFile user should implement at least some methods.
  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 deliberate,
  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 #include <cfg/macros.h>
  94
  95 /* fwd decl */
  96 struct KFile;
  97
  98 typedef int32_t kfile_off_t; ///< KFile offset type, used by kfile_seek function.
  99
 100 /**
 101  * Costants for repositioning read/write file offset.
 102  * These are needed because on some embedded platforms
 103  * ANSI I/O library may not be present.
 104  */
 105 typedef enum KSeekMode
 106 {
 107         KSM_SEEK_SET, ///< Seek from file beginning.
 108         KSM_SEEK_CUR, ///< Seek from file current position.
 109         KSM_SEEK_END, ///< Seek from file end.
 110 } KSeekMode;
 111
 112 /**
 113  * Prototypes for KFile access functions.
 114  * I/O file functions must be ANSI compliant.
 115  * \note A KFile user can choose which function subset to implement,
 116  *       but has to set to NULL unimplemented features.
 117  * \{
 118  */
 119
 120 /**
 121  * Read from file.
 122  * \return the number of bytes read.
 123  */
 124 typedef size_t (*ReadFunc_t) (struct KFile *fd, void *buf, size_t size);
 125
 126 /**
 127  * Write to file.
 128  * \return the number of bytes written.
 129  */
 130 typedef size_t (*WriteFunc_t) (struct KFile *fd, const void *buf, size_t size);
 131
 132 /**
 133  * Seek into file (if seekable).
 134  * \return the new file offset or EOF on errors.
 135  */
 136 typedef kfile_off_t (*SeekFunc_t) (struct KFile *fd, kfile_off_t offset, KSeekMode whence);
 137
 138 /**
 139  * Close and reopen file \a fd.
 140  * The reopening is done with the former file parameters and access modes.
 141  */
 142 typedef struct KFile * (*ReOpenFunc_t) (struct KFile *fd);
 143
 144 /**
 145  * Close file.
 146  * \return 0 on success, EOF on errors.
 147  */
 148 typedef int (*CloseFunc_t) (struct KFile *fd);
 149
 150 /**
 151  * Flush file I/O.
 152  * \return 0 on success, EOF on errors.
 153  */
 154 typedef int (*FlushFunc_t) (struct KFile *fd);
 155
 156 /**
 157  * Get file error mask.
 158  * \return 0 on success or file error code, device specific.
 159  */
 160 typedef int (*ErrorFunc_t) (struct KFile *fd);
 161
 162 /**
 163  * Clear errors.
 164  */
 165 typedef void (*ClearErrFunc_t) (struct KFile *fd);
 166 /* \} */
 167
 168 /**
 169  * Context data for callback functions which operate on
 170  * pseudo files.
 171  * \note If you change interface, remember to add corresponding access function.
 172  */
 173 typedef struct KFile
 174 {
 175         ReadFunc_t     read;
 176         WriteFunc_t    write;
 177         ReOpenFunc_t   reopen;
 178         CloseFunc_t    close;
 179         SeekFunc_t     seek;
 180         FlushFunc_t    flush;
 181         ErrorFunc_t    error;
 182         ClearErrFunc_t clearerr;
 183         DB(id_t _type); ///< Used to keep trace, at runtime, of obj type.
 184
 185         /* NOTE: these must _NOT_ be size_t on 16bit CPUs! */
 186         uint32_t seek_pos;
 187         uint32_t size;
 188 } KFile;
 189
 190 /**
 191  * Generic implementation of kfile_seek.
 192  */
 193 kfile_off_t kfile_genericSeek(struct KFile *fd, kfile_off_t offset, KSeekMode whence);
 194
 195 /**
 196  * Generic implementation of kfile_reopen.
 197  */
 198 struct KFile * kfile_genericReopen(struct KFile *fd);
 199
 200 int kfile_putc(int c, struct KFile *fd); ///< Generic putc implementation using kfile_write.
 201 int kfile_getc(struct KFile *fd);  ///< Generic getc implementation using kfile_read.
 202 int kfile_printf(struct KFile *fd, const char *format, ...);
 203 int kfile_print(struct KFile *fd, const char *s);
 204 int kfile_gets(struct KFile *fd, char *buf, int size);
 205 int kfile_gets_echo(struct KFile *fd, char *buf, int size, bool echo);
 206
 207 /**
 208  * Interface functions for KFile access.
 209  * \note Remember to change following functions if KFile interface changes.
 210  * \{
 211  */
 212 INLINE size_t kfile_read(struct KFile *fd, void *buf, size_t size)
 213 {
 214         ASSERT(fd->read);
 215         return fd->read(fd, buf, size);
 216 }
 217
 218 INLINE size_t kfile_write(struct KFile *fd, const void *buf, size_t size)
 219 {
 220         ASSERT(fd->write);
 221         return fd->write(fd, buf, size);
 222 }
 223
 224 INLINE KFile * kfile_reopen(struct KFile *fd)
 225 {
 226         ASSERT(fd->reopen);
 227         return fd->reopen(fd);
 228 }
 229
 230 INLINE int kfile_close(struct KFile *fd)
 231 {
 232         ASSERT(fd->close);
 233         return fd->close(fd);
 234 }
 235
 236 INLINE kfile_off_t kfile_seek(struct KFile *fd, kfile_off_t offset, KSeekMode whence)
 237 {
 238         ASSERT(fd->seek);
 239         return fd->seek(fd, offset, whence);
 240 }
 241
 242 INLINE int kfile_flush(struct KFile *fd)
 243 {
 244         ASSERT(fd->flush);
 245         return fd->flush(fd);
 246 }
 247
 248 INLINE int kfile_error(struct KFile *fd)
 249 {
 250         ASSERT(fd->error);
 251         return fd->error(fd);
 252 }
 253
 254 INLINE void kfile_clearerr(struct KFile *fd)
 255 {
 256         ASSERT(fd->clearerr);
 257         fd->clearerr(fd);
 258 }
 259 /* \} */
 260
 261 /**
 262  * Kfile test function.
 263  */
 264 bool kfile_test(KFile *fd, uint8_t *test_buf, uint8_t *save_buf, size_t size);
 265
 266 #endif /* KERN_KFILE_H */