fs/devfs.c

   1 /*
   2  * devfs.c - a device file system for barebox
   3  *
   4  * Copyright (c) 2007 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix
   5  *
   6  * See file CREDITS for list of people who contributed to this
   7  * project.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2
  11  * as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <common.h>
  24 #include <driver.h>
  25 #include <init.h>
  26 #include <malloc.h>
  27 #include <fs.h>
  28 #include <command.h>
  29 #include <errno.h>
  30 #include <xfuncs.h>
  31 #include <linux/stat.h>
  32 #include <ioctl.h>
  33 #include <nand.h>
  34 #include <linux/err.h>
  35 #include <linux/mtd/mtd.h>
  36 #include <linux/mtd/mtd-abi.h>
  37 #include <partition.h>
  38
  39 static LIST_HEAD(cdev_list);
  40
  41 struct cdev *cdev_by_name(const char *filename)
  42 {
  43         struct cdev *cdev;
  44
  45         list_for_each_entry(cdev, &cdev_list, list) {
  46                 if (!strcmp(cdev->name, filename))
  47                         return cdev;
  48         }
  49         return NULL;
  50 }
  51
  52 ssize_t cdev_read(struct cdev *cdev, void *buf, size_t count, ulong offset, ulong flags)
  53 {
  54         if (!cdev->ops->read)
  55                 return -ENOSYS;
  56
  57         return cdev->ops->read(cdev, buf, count, cdev->offset +offset, flags);
  58 }
  59
  60 ssize_t cdev_write(struct cdev *cdev, const void *buf, size_t count, ulong offset, ulong flags)
  61 {
  62         if (!cdev->ops->write)
  63                 return -ENOSYS;
  64
  65         return cdev->ops->write(cdev, buf, count, cdev->offset + offset, flags);
  66 }
  67
  68 static int devfs_read(struct device_d *_dev, FILE *f, void *buf, size_t size)
  69 {
  70         struct cdev *cdev = f->inode;
  71
  72         return cdev_read(cdev, buf, size, f->pos, f->flags);
  73 }
  74
  75 static int devfs_write(struct device_d *_dev, FILE *f, const void *buf, size_t size)
  76 {
  77         struct cdev *cdev = f->inode;
  78
  79         return cdev_write(cdev, buf, size, f->pos, f->flags);
  80 }
  81
  82 static off_t devfs_lseek(struct device_d *_dev, FILE *f, off_t pos)
  83 {
  84         struct cdev *cdev = f->inode;
  85         off_t ret = -1;
  86
  87         if (cdev->ops->lseek)
  88                 ret = cdev->ops->lseek(cdev, pos + cdev->offset);
  89
  90         if (ret != -1)
  91                 f->pos = pos;
  92
  93         return ret - cdev->offset;
  94 }
  95
  96 static int devfs_erase(struct device_d *_dev, FILE *f, size_t count, unsigned long offset)
  97 {
  98         struct cdev *cdev = f->inode;
  99
 100         if (!cdev->ops->erase)
 101                 return -ENOSYS;
 102
 103         return cdev->ops->erase(cdev, count, offset + cdev->offset);
 104 }
 105
 106 static int devfs_protect(struct device_d *_dev, FILE *f, size_t count, unsigned long offset, int prot)
 107 {
 108         struct cdev *cdev = f->inode;
 109
 110         if (!cdev->ops->protect)
 111                 return -ENOSYS;
 112
 113         return cdev->ops->protect(cdev, count, offset + cdev->offset, prot);
 114 }
 115
 116 static int devfs_memmap(struct device_d *_dev, FILE *f, void **map, int flags)
 117 {
 118         struct cdev *cdev = f->inode;
 119         int ret = -ENOSYS;
 120
 121         if (!cdev->ops->memmap)
 122                 return -EINVAL;
 123
 124         ret = cdev->ops->memmap(cdev, map, flags);
 125
 126         if (!ret)
 127                 *map = (void *)((unsigned long)*map + cdev->offset);
 128
 129         return ret;
 130 }
 131
 132 static int devfs_open(struct device_d *_dev, FILE *f, const char *filename)
 133 {
 134         struct cdev *cdev;
 135         int ret;
 136
 137         cdev = cdev_by_name(filename + 1);
 138
 139         if (!cdev)
 140                 return -ENOENT;
 141
 142         f->size = cdev->size;
 143         f->inode = cdev;
 144
 145         if (cdev->ops->open) {
 146                 ret = cdev->ops->open(cdev, f);
 147                 if (ret)
 148                         return ret;
 149         }
 150
 151         cdev->open++;
 152
 153         return 0;
 154 }
 155
 156 static int devfs_close(struct device_d *_dev, FILE *f)
 157 {
 158         struct cdev *cdev = f->inode;
 159         int ret;
 160
 161         if (cdev->ops->close) {
 162                 ret = cdev->ops->close(cdev, f);
 163                 if (ret)
 164                         return ret;
 165         }
 166
 167         cdev->open--;
 168
 169         return 0;
 170 }
 171
 172 static int partition_ioctl(struct cdev *cdev, int request, void *buf)
 173 {
 174         size_t offset;
 175         struct mtd_info_user *user = buf;
 176
 177         switch (request) {
 178         case MEMSETBADBLOCK:
 179         case MEMGETBADBLOCK:
 180                 offset = (off_t)buf;
 181                 offset += cdev->offset;
 182                 return cdev->ops->ioctl(cdev, request, (void *)offset);
 183         case MEMGETINFO:
 184                 if (cdev->mtd) {
 185                         user->type      = cdev->mtd->type;
 186                         user->flags     = cdev->mtd->flags;
 187                         user->size      = cdev->mtd->size;
 188                         user->erasesize = cdev->mtd->erasesize;
 189                         user->oobsize   = cdev->mtd->oobsize;
 190                         user->mtd       = cdev->mtd;
 191                         /* The below fields are obsolete */
 192                         user->ecctype   = -1;
 193                         user->eccsize   = 0;
 194                         return 0;
 195                 }
 196                 if (!cdev->ops->ioctl)
 197                         return -EINVAL;
 198                 return cdev->ops->ioctl(cdev, request, buf);
 199         default:
 200                 return -EINVAL;
 201         }
 202 }
 203
 204 static int devfs_ioctl(struct device_d *_dev, FILE *f, int request, void *buf)
 205 {
 206         struct cdev *cdev = f->inode;
 207
 208         if (cdev->flags & DEVFS_IS_PARTITION)
 209                 return partition_ioctl(cdev, request, buf);
 210
 211         if (!cdev->ops->ioctl)
 212                 return -EINVAL;
 213
 214         return cdev->ops->ioctl(cdev, request, buf);
 215 }
 216
 217 static int devfs_truncate(struct device_d *dev, FILE *f, ulong size)
 218 {
 219         if (size > f->dev->size)
 220                 return -ENOSPC;
 221         return 0;
 222 }
 223
 224 static DIR* devfs_opendir(struct device_d *dev, const char *pathname)
 225 {
 226         DIR *dir;
 227
 228         dir = xzalloc(sizeof(DIR));
 229
 230         if (!list_empty(&cdev_list))
 231                 dir->priv = list_first_entry(&cdev_list, struct cdev, list);
 232
 233         return dir;
 234 }
 235
 236 static struct dirent* devfs_readdir(struct device_d *_dev, DIR *dir)
 237 {
 238         struct cdev *cdev = dir->priv;
 239
 240         if (!cdev)
 241                 return NULL;
 242
 243         list_for_each_entry_from(cdev, &cdev_list, list) {
 244                 strcpy(dir->d.d_name, cdev->name);
 245                 dir->priv = list_entry(cdev->list.next, struct cdev, list);
 246                 return &dir->d;
 247         }
 248         return NULL;
 249 }
 250
 251 static int devfs_closedir(struct device_d *dev, DIR *dir)
 252 {
 253         free(dir);
 254         return 0;
 255 }
 256
 257 static int devfs_stat(struct device_d *_dev, const char *filename, struct stat *s)
 258 {
 259         struct cdev *cdev;
 260
 261         cdev = cdev_by_name(filename + 1);
 262         if (!cdev)
 263                 return -ENOENT;
 264
 265         s->st_mode = S_IFCHR;
 266         s->st_size = cdev->size;
 267         if (cdev->ops->write)
 268                 s->st_mode |= S_IWUSR;
 269         if (cdev->ops->read)
 270                 s->st_mode |= S_IRUSR;
 271
 272         return 0;
 273 }
 274
 275 static int devfs_probe(struct device_d *dev)
 276 {
 277         return 0;
 278 }
 279
 280 static void devfs_delete(struct device_d *dev)
 281 {
 282 }
 283
 284 static struct fs_driver_d devfs_driver = {
 285         .type      = FS_TYPE_DEVFS,
 286         .read      = devfs_read,
 287         .write     = devfs_write,
 288         .lseek     = devfs_lseek,
 289         .open      = devfs_open,
 290         .close     = devfs_close,
 291         .ioctl     = devfs_ioctl,
 292         .opendir   = devfs_opendir,
 293         .readdir   = devfs_readdir,
 294         .truncate  = devfs_truncate,
 295         .closedir  = devfs_closedir,
 296         .stat      = devfs_stat,
 297         .erase     = devfs_erase,
 298         .protect   = devfs_protect,
 299         .memmap    = devfs_memmap,
 300         .flags     = FS_DRIVER_NO_DEV,
 301         .drv = {
 302                 .probe  = devfs_probe,
 303                 .remove = devfs_delete,
 304                 .name = "devfs",
 305                 .type_data = &devfs_driver,
 306         }
 307 };
 308
 309 static int devfs_init(void)
 310 {
 311         return register_fs_driver(&devfs_driver);
 312 }
 313
 314 coredevice_initcall(devfs_init);
 315
 316 int devfs_create(struct cdev *new)
 317 {
 318         struct cdev *cdev;
 319
 320         cdev = cdev_by_name(new->name);
 321         if (cdev)
 322                 return -EEXIST;
 323
 324         list_add_tail(&new->list, &cdev_list);
 325         if (new->dev)
 326                 list_add_tail(&new->devices_list, &new->dev->cdevs);
 327
 328         return 0;
 329 }
 330
 331 int devfs_remove(struct cdev *cdev)
 332 {
 333         if (cdev->open)
 334                 return -EBUSY;
 335
 336         list_del(&cdev->list);
 337         if (cdev->dev)
 338                 list_del(&cdev->devices_list);
 339
 340         return 0;
 341 }
 342
 343 int devfs_add_partition(const char *devname, unsigned long offset, size_t size,
 344                 int flags, const char *name)
 345 {
 346         struct cdev *cdev, *new;
 347
 348         cdev = cdev_by_name(name);
 349         if (cdev)
 350                 return -EEXIST;
 351
 352         cdev = cdev_by_name(devname);
 353         if (!cdev)
 354                 return -ENOENT;
 355
 356         if (offset + size > cdev->size)
 357                 return -EINVAL;
 358
 359         new = xzalloc(sizeof (*new));
 360         new->name = strdup(name);
 361         new->ops = cdev->ops;
 362         new->priv = cdev->priv;
 363         new->size = size;
 364         new->offset = offset + cdev->offset;
 365         new->dev = cdev->dev;
 366         new->flags = flags | DEVFS_IS_PARTITION;
 367
 368 #ifdef CONFIG_PARTITION_NEED_MTD
 369         if (cdev->mtd) {
 370                 new->mtd = mtd_add_partition(cdev->mtd, offset, size, flags, name);
 371                 if (IS_ERR(new->mtd)) {
 372                         int ret = PTR_ERR(new->mtd);
 373                         free(new);
 374                         return ret;
 375                 }
 376         }
 377 #endif
 378
 379         devfs_create(new);
 380
 381         return 0;
 382 }
 383
 384 int devfs_del_partition(const char *name)
 385 {
 386         struct cdev *cdev;
 387         int ret;
 388
 389         cdev = cdev_by_name(name);
 390         if (!cdev)
 391                 return -ENOENT;
 392
 393         if (!(cdev->flags & DEVFS_IS_PARTITION))
 394                 return -EINVAL;
 395         if (cdev->flags & DEVFS_PARTITION_FIXED)
 396                 return -EPERM;
 397
 398 #ifdef CONFIG_PARTITION_NEED_MTD
 399         if (cdev->mtd)
 400                 mtd_del_partition(cdev->mtd);
 401 #endif
 402
 403         ret = devfs_remove(cdev);
 404         if (ret)
 405                 return ret;
 406
 407         free(cdev->name);
 408         free(cdev);
 409
 410         return 0;
 411 }
 412