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