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., 675 Mass Ave, Cambridge, MA 02139, 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 } 385
