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