oslib/libmtd_legacy.c

   1 /*
   2  * Copyright (C) 2009 Nokia Corporation
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
  12  * the GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * Author: Artem Bityutskiy
  19  *
  20  * This file  is part of the MTD library. Implements pre-2.6.30 kernels support,
  21  * where MTD did not have sysfs interface. The main limitation of the old
  22  * kernels was that the sub-page size was not exported to user-space, so it was
  23  * not possible to get sub-page size.
  24  */
  25
  26 /* Imported from mtd-utils by dehrenberg */
  27
  28 #include <limits.h>
  29 #include <fcntl.h>
  30 #include <unistd.h>
  31 #include <stdlib.h>
  32 #include <errno.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <sys/ioctl.h>
  36 #include <mtd/mtd-user.h>
  37
  38 #include "libmtd.h"
  39 #include "libmtd_int.h"
  40 #include "libmtd_common.h"
  41
  42 #define MTD_PROC_FILE "/proc/mtd"
  43 #define MTD_DEV_PATT  "/dev/mtd%d"
  44 #define MTD_DEV_MAJOR 90
  45
  46 #define PROC_MTD_FIRST     "dev:    size   erasesize  name\n"
  47 #define PROC_MTD_FIRST_LEN (sizeof(PROC_MTD_FIRST) - 1)
  48 #define PROC_MTD_MAX_LEN   4096
  49 #define PROC_MTD_PATT      "mtd%d: %llx %x"
  50
  51 /**
  52  * struct proc_parse_info - /proc/mtd parsing information.
  53  * @mtd_num: MTD device number
  54  * @size: device size
  55  * @eb_size: eraseblock size
  56  * @name: device name
  57  * @buf: contents of /proc/mtd
  58  * @data_size: how much data was read into @buf
  59  * @pos: next string in @buf to parse
  60  */
  61 struct proc_parse_info
  62 {
  63         int mtd_num;
  64         long long size;
  65         char name[MTD_NAME_MAX + 1];
  66         int eb_size;
  67         char *buf;
  68         int data_size;
  69         char *next;
  70 };
  71
  72 static int proc_parse_start(struct proc_parse_info *pi)
  73 {
  74         int fd, ret;
  75
  76         fd = open(MTD_PROC_FILE, O_RDONLY);
  77         if (fd == -1)
  78                 return -1;
  79
  80         pi->buf = xmalloc(PROC_MTD_MAX_LEN);
  81
  82         ret = read(fd, pi->buf, PROC_MTD_MAX_LEN);
  83         if (ret == -1) {
  84                 sys_errmsg("cannot read \"%s\"", MTD_PROC_FILE);
  85                 goto out_free;
  86         }
  87
  88         if (ret < PROC_MTD_FIRST_LEN ||
  89             memcmp(pi->buf, PROC_MTD_FIRST, PROC_MTD_FIRST_LEN)) {
  90                 errmsg("\"%s\" does not start with \"%s\"", MTD_PROC_FILE,
  91                        PROC_MTD_FIRST);
  92                 goto out_free;
  93         }
  94
  95         pi->data_size = ret;
  96         pi->next = pi->buf + PROC_MTD_FIRST_LEN;
  97
  98         close(fd);
  99         return 0;
 100
 101 out_free:
 102         free(pi->buf);
 103         close(fd);
 104         return -1;
 105 }
 106
 107 static int proc_parse_next(struct proc_parse_info *pi)
 108 {
 109         int ret, len, pos = pi->next - pi->buf;
 110         char *p, *p1;
 111
 112         if (pos >= pi->data_size) {
 113                 free(pi->buf);
 114                 return 0;
 115         }
 116
 117         ret = sscanf(pi->next, PROC_MTD_PATT, &pi->mtd_num, &pi->size,
 118                      &pi->eb_size);
 119         if (ret != 3)
 120                 return errmsg("\"%s\" pattern not found", PROC_MTD_PATT);
 121
 122         p = memchr(pi->next, '\"', pi->data_size - pos);
 123         if (!p)
 124                 return errmsg("opening \" not found");
 125         p += 1;
 126         pos = p - pi->buf;
 127         if (pos >= pi->data_size)
 128                 return errmsg("opening \" not found");
 129
 130         p1 = memchr(p, '\"', pi->data_size - pos);
 131         if (!p1)
 132                 return errmsg("closing \" not found");
 133         pos = p1 - pi->buf;
 134         if (pos >= pi->data_size)
 135                 return errmsg("closing \" not found");
 136
 137         len = p1 - p;
 138         if (len > MTD_NAME_MAX)
 139                 return errmsg("too long mtd%d device name", pi->mtd_num);
 140
 141         memcpy(pi->name, p, len);
 142         pi->name[len] = '\0';
 143
 144         if (p1[1] != '\n')
 145                 return errmsg("opening \"\n\" not found");
 146         pi->next = p1 + 2;
 147         return 1;
 148 }
 149
 150 /**
 151  * legacy_libmtd_open - legacy version of 'libmtd_open()'.
 152  *
 153  * This function is just checks that MTD is present in the system. Returns
 154  * zero in case of success and %-1 in case of failure. In case of failure,
 155  * errno contains zero if MTD is not present in the system, or contains the
 156  * error code if a real error happened. This is similar to the 'libmtd_open()'
 157  * return conventions.
 158  */
 159 int legacy_libmtd_open(void)
 160 {
 161         int fd;
 162
 163         fd = open(MTD_PROC_FILE, O_RDONLY);
 164         if (fd == -1) {
 165                 if (errno == ENOENT)
 166                         errno = 0;
 167                 return -1;
 168         }
 169
 170         close(fd);
 171         return 0;
 172 }
 173
 174 /**
 175  * legacy_dev_presentl - legacy version of 'mtd_dev_present()'.
 176  * @info: the MTD device information is returned here
 177  *
 178  * When the kernel does not provide sysfs files for the MTD subsystem,
 179  * fall-back to parsing the /proc/mtd file to determine whether an mtd device
 180  * number @mtd_num is present.
 181  */
 182 int legacy_dev_present(int mtd_num)
 183 {
 184         int ret;
 185         struct proc_parse_info pi;
 186
 187         ret = proc_parse_start(&pi);
 188         if (ret)
 189                 return -1;
 190
 191         while (proc_parse_next(&pi)) {
 192                 if (pi.mtd_num == mtd_num)
 193                         return 1;
 194         }
 195
 196         return 0;
 197 }
 198
 199 /**
 200  * legacy_mtd_get_info - legacy version of 'mtd_get_info()'.
 201  * @info: the MTD device information is returned here
 202  *
 203  * This function is similar to 'mtd_get_info()' and has the same conventions.
 204  */
 205 int legacy_mtd_get_info(struct mtd_info *info)
 206 {
 207         int ret;
 208         struct proc_parse_info pi;
 209
 210         ret = proc_parse_start(&pi);
 211         if (ret)
 212                 return -1;
 213
 214         info->lowest_mtd_num = INT_MAX;
 215         while (proc_parse_next(&pi)) {
 216                 info->mtd_dev_cnt += 1;
 217                 if (pi.mtd_num > info->highest_mtd_num)
 218                         info->highest_mtd_num = pi.mtd_num;
 219                 if (pi.mtd_num < info->lowest_mtd_num)
 220                         info->lowest_mtd_num = pi.mtd_num;
 221         }
 222
 223         return 0;
 224 }
 225
 226 /**
 227  * legacy_get_dev_info - legacy version of 'mtd_get_dev_info()'.
 228  * @node: name of the MTD device node
 229  * @mtd: the MTD device information is returned here
 230  *
 231  * This function is similar to 'mtd_get_dev_info()' and has the same
 232  * conventions.
 233  */
 234 int legacy_get_dev_info(const char *node, struct mtd_dev_info *mtd)
 235 {
 236         struct stat st;
 237         struct mtd_info_user ui;
 238         int fd, ret;
 239         loff_t offs = 0;
 240         struct proc_parse_info pi;
 241
 242         if (stat(node, &st)) {
 243                 sys_errmsg("cannot open \"%s\"", node);
 244                 if (errno == ENOENT)
 245                         normsg("MTD subsystem is old and does not support "
 246                                "sysfs, so MTD character device nodes have "
 247                                "to exist");
 248         }
 249
 250         if (!S_ISCHR(st.st_mode)) {
 251                 errno = EINVAL;
 252                 return errmsg("\"%s\" is not a character device", node);
 253         }
 254
 255         memset(mtd, '\0', sizeof(struct mtd_dev_info));
 256         mtd->major = major(st.st_rdev);
 257         mtd->minor = minor(st.st_rdev);
 258
 259         if (mtd->major != MTD_DEV_MAJOR) {
 260                 errno = EINVAL;
 261                 return errmsg("\"%s\" has major number %d, MTD devices have "
 262                               "major %d", node, mtd->major, MTD_DEV_MAJOR);
 263         }
 264
 265         mtd->mtd_num = mtd->minor / 2;
 266
 267         fd = open(node, O_RDONLY);
 268         if (fd == -1)
 269                 return sys_errmsg("cannot open \"%s\"", node);
 270
 271         if (ioctl(fd, MEMGETINFO, &ui)) {
 272                 sys_errmsg("MEMGETINFO ioctl request failed");
 273                 goto out_close;
 274         }
 275
 276         ret = ioctl(fd, MEMGETBADBLOCK, &offs);
 277         if (ret == -1) {
 278                 if (errno != EOPNOTSUPP) {
 279                         sys_errmsg("MEMGETBADBLOCK ioctl failed");
 280                         goto out_close;
 281                 }
 282                 errno = 0;
 283                 mtd->bb_allowed = 0;
 284         } else
 285                 mtd->bb_allowed = 1;
 286
 287         mtd->type = ui.type;
 288         mtd->size = ui.size;
 289         mtd->eb_size = ui.erasesize;
 290         mtd->min_io_size = ui.writesize;
 291         mtd->oob_size = ui.oobsize;
 292
 293         if (mtd->min_io_size <= 0) {
 294                 errmsg("mtd%d (%s) has insane min. I/O unit size %d",
 295                        mtd->mtd_num, node, mtd->min_io_size);
 296                 goto out_close;
 297         }
 298         if (mtd->eb_size <= 0 || mtd->eb_size < mtd->min_io_size) {
 299                 errmsg("mtd%d (%s) has insane eraseblock size %d",
 300                        mtd->mtd_num, node, mtd->eb_size);
 301                 goto out_close;
 302         }
 303         if (mtd->size <= 0 || mtd->size < mtd->eb_size) {
 304                 errmsg("mtd%d (%s) has insane size %lld",
 305                        mtd->mtd_num, node, mtd->size);
 306                 goto out_close;
 307         }
 308         mtd->eb_cnt = mtd->size / mtd->eb_size;
 309
 310         switch(mtd->type) {
 311         case MTD_ABSENT:
 312                 errmsg("mtd%d (%s) is removable and is not present",
 313                        mtd->mtd_num, node);
 314                 goto out_close;
 315         case MTD_RAM:
 316                 strcpy((char *)mtd->type_str, "ram");
 317                 break;
 318         case MTD_ROM:
 319                 strcpy((char *)mtd->type_str, "rom");
 320                 break;
 321         case MTD_NORFLASH:
 322                 strcpy((char *)mtd->type_str, "nor");
 323                 break;
 324         case MTD_NANDFLASH:
 325                 strcpy((char *)mtd->type_str, "nand");
 326                 break;
 327         case MTD_MLCNANDFLASH:
 328                 strcpy((char *)mtd->type_str, "mlc-nand");
 329                 break;
 330         case MTD_DATAFLASH:
 331                 strcpy((char *)mtd->type_str, "dataflash");
 332                 break;
 333         case MTD_UBIVOLUME:
 334                 strcpy((char *)mtd->type_str, "ubi");
 335                 break;
 336         default:
 337                 goto out_close;
 338         }
 339
 340         if (ui.flags & MTD_WRITEABLE)
 341                 mtd->writable = 1;
 342         mtd->subpage_size = mtd->min_io_size;
 343
 344         close(fd);
 345
 346         /*
 347          * Unfortunately, the device name is not available via ioctl, and
 348          * we have to parse /proc/mtd to get it.
 349          */
 350         ret = proc_parse_start(&pi);
 351         if (ret)
 352                 return -1;
 353
 354         while (proc_parse_next(&pi)) {
 355                 if (pi.mtd_num == mtd->mtd_num) {
 356                         strcpy((char *)mtd->name, pi.name);
 357                         return 0;
 358                 }
 359         }
 360
 361         errmsg("mtd%d not found in \"%s\"", mtd->mtd_num, MTD_PROC_FILE);
 362         errno = ENOENT;
 363         return -1;
 364
 365 out_close:
 366         close(fd);
 367         return -1;
 368 }
 369
 370 /**
 371  * legacy_get_dev_info1 - legacy version of 'mtd_get_dev_info1()'.
 372  * @node: name of the MTD device node
 373  * @mtd: the MTD device information is returned here
 374  *
 375  * This function is similar to 'mtd_get_dev_info1()' and has the same
 376  * conventions.
 377  */
 378 int legacy_get_dev_info1(int mtd_num, struct mtd_dev_info *mtd)
 379 {
 380         char node[sizeof(MTD_DEV_PATT) + 20];
 381
 382         sprintf(node, MTD_DEV_PATT, mtd_num);
 383         return legacy_get_dev_info(node, mtd);
 384 }