1 /* 2 * Core registration and callback routines for MTD 3 * drivers and users. 4 * 5 */ 6 7 #include <linux/module.h> 8 #include <linux/kernel.h> 9 #include <linux/ptrace.h> 10 #include <linux/slab.h> 11 #include <linux/string.h> 12 #include <linux/timer.h> 13 #include <linux/major.h> 14 #include <linux/fs.h> 15 #include <linux/err.h> 16 #include <linux/ioctl.h> 17 #include <linux/init.h> 18 #include <linux/mtd/compatmac.h> 19 #include <linux/proc_fs.h> 20 21 #include <linux/mtd/mtd.h> 22 23 #include "mtdcore.h" 24 25 /* These are exported solely for the purpose of mtd_blkdevs.c. You 26 should not use them for _anything_ else */ 27 DEFINE_MUTEX(mtd_table_mutex); 28 struct mtd_info *mtd_table[MAX_MTD_DEVICES]; 29 30 EXPORT_SYMBOL_GPL(mtd_table_mutex); 31 EXPORT_SYMBOL_GPL(mtd_table); 32 33 static LIST_HEAD(mtd_notifiers); 34 35 /** 36 * add_mtd_device - register an MTD device 37 * @mtd: pointer to new MTD device info structure 38 * 39 * Add a device to the list of MTD devices present in the system, and 40 * notify each currently active MTD 'user' of its arrival. Returns 41 * zero on success or 1 on failure, which currently will only happen 42 * if the number of present devices exceeds MAX_MTD_DEVICES (i.e. 16) 43 */ 44 45 int add_mtd_device(struct mtd_info *mtd) 46 { 47 int i; 48 49 BUG_ON(mtd->writesize == 0); 50 mutex_lock(&mtd_table_mutex); 51 52 for (i=0; i < MAX_MTD_DEVICES; i++) 53 if (!mtd_table[i]) { 54 struct mtd_notifier *not; 55 56 mtd_table[i] = mtd; 57 mtd->index = i; 58 mtd->usecount = 0; 59 60 /* Some chips always power up locked. Unlock them now */ 61 if ((mtd->flags & MTD_WRITEABLE) 62 && (mtd->flags & MTD_POWERUP_LOCK) && mtd->unlock) { 63 if (mtd->unlock(mtd, 0, mtd->size)) 64 printk(KERN_WARNING 65 "%s: unlock failed, " 66 "writes may not work\n", 67 mtd->name); 68 } 69 70 DEBUG(0, "mtd: Giving out device %d to %s\n",i, mtd->name); 71 /* No need to get a refcount on the module containing 72 the notifier, since we hold the mtd_table_mutex */ 73 list_for_each_entry(not, &mtd_notifiers, list) 74 not->add(mtd); 75 76 mutex_unlock(&mtd_table_mutex); 77 /* We _know_ we aren't being removed, because 78 our caller is still holding us here. So none 79 of this try_ nonsense, and no bitching about it 80 either. :) */ 81 __module_get(THIS_MODULE); 82 return 0; 83 } 84 85 mutex_unlock(&mtd_table_mutex); 86 return 1; 87 } 88 89 /** 90 * del_mtd_device - unregister an MTD device 91 * @mtd: pointer to MTD device info structure 92 * 93 * Remove a device from the list of MTD devices present in the system, 94 * and notify each currently active MTD 'user' of its departure. 95 * Returns zero on success or 1 on failure, which currently will happen 96 * if the requested device does not appear to be present in the list. 97 */ 98 99 int del_mtd_device (struct mtd_info *mtd) 100 { 101 int ret; 102 103 mutex_lock(&mtd_table_mutex); 104 105 if (mtd_table[mtd->index] != mtd) { 106 ret = -ENODEV; 107 } else if (mtd->usecount) { 108 printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n", 109 mtd->index, mtd->name, mtd->usecount); 110 ret = -EBUSY; 111 } else { 112 struct mtd_notifier *not; 113 114 /* No need to get a refcount on the module containing 115 the notifier, since we hold the mtd_table_mutex */ 116 list_for_each_entry(not, &mtd_notifiers, list) 117 not->remove(mtd); 118 119 mtd_table[mtd->index] = NULL; 120 121 module_put(THIS_MODULE); 122 ret = 0; 123 } 124 125 mutex_unlock(&mtd_table_mutex); 126 return ret; 127 } 128 129 /** 130 * register_mtd_user - register a 'user' of MTD devices. 131 * @new: pointer to notifier info structure 132 * 133 * Registers a pair of callbacks function to be called upon addition 134 * or removal of MTD devices. Causes the 'add' callback to be immediately 135 * invoked for each MTD device currently present in the system. 136 */ 137 138 void register_mtd_user (struct mtd_notifier *new) 139 { 140 int i; 141 142 mutex_lock(&mtd_table_mutex); 143 144 list_add(&new->list, &mtd_notifiers); 145 146 __module_get(THIS_MODULE); 147 148 for (i=0; i< MAX_MTD_DEVICES; i++) 149 if (mtd_table[i]) 150 new->add(mtd_table[i]); 151 152 mutex_unlock(&mtd_table_mutex); 153 } 154 155 /** 156 * unregister_mtd_user - unregister a 'user' of MTD devices. 157 * @old: pointer to notifier info structure 158 * 159 * Removes a callback function pair from the list of 'users' to be 160 * notified upon addition or removal of MTD devices. Causes the 161 * 'remove' callback to be immediately invoked for each MTD device 162 * currently present in the system. 163 */ 164 165 int unregister_mtd_user (struct mtd_notifier *old) 166 { 167 int i; 168 169 mutex_lock(&mtd_table_mutex); 170 171 module_put(THIS_MODULE); 172 173 for (i=0; i< MAX_MTD_DEVICES; i++) 174 if (mtd_table[i]) 175 old->remove(mtd_table[i]); 176 177 list_del(&old->list); 178 mutex_unlock(&mtd_table_mutex); 179 return 0; 180 } 181 182 183 /** 184 * get_mtd_device - obtain a validated handle for an MTD device 185 * @mtd: last known address of the required MTD device 186 * @num: internal device number of the required MTD device 187 * 188 * Given a number and NULL address, return the num'th entry in the device 189 * table, if any. Given an address and num == -1, search the device table 190 * for a device with that address and return if it's still present. Given 191 * both, return the num'th driver only if its address matches. Return 192 * error code if not. 193 */ 194 195 struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num) 196 { 197 struct mtd_info *ret = NULL; 198 int i, err = -ENODEV; 199 200 mutex_lock(&mtd_table_mutex); 201 202 if (num == -1) { 203 for (i=0; i< MAX_MTD_DEVICES; i++) 204 if (mtd_table[i] == mtd) 205 ret = mtd_table[i]; 206 } else if (num < MAX_MTD_DEVICES) { 207 ret = mtd_table[num]; 208 if (mtd && mtd != ret) 209 ret = NULL; 210 } 211 212 if (!ret) 213 goto out_unlock; 214 215 if (!try_module_get(ret->owner)) 216 goto out_unlock; 217 218 if (ret->get_device) { 219 err = ret->get_device(ret); 220 if (err) 221 goto out_put; 222 } 223 224 ret->usecount++; 225 mutex_unlock(&mtd_table_mutex); 226 return ret; 227 228 out_put: 229 module_put(ret->owner); 230 out_unlock: 231 mutex_unlock(&mtd_table_mutex); 232 return ERR_PTR(err); 233 } 234 235 /** 236 * get_mtd_device_nm - obtain a validated handle for an MTD device by 237 * device name 238 * @name: MTD device name to open 239 * 240 * This function returns MTD device description structure in case of 241 * success and an error code in case of failure. 242 */ 243 244 struct mtd_info *get_mtd_device_nm(const char *name) 245 { 246 int i, err = -ENODEV; 247 struct mtd_info *mtd = NULL; 248 249 mutex_lock(&mtd_table_mutex); 250 251 for (i = 0; i < MAX_MTD_DEVICES; i++) { 252 if (mtd_table[i] && !strcmp(name, mtd_table[i]->name)) { 253 mtd = mtd_table[i]; 254 break; 255 } 256 } 257 258 if (!mtd) 259 goto out_unlock; 260 261 if (!try_module_get(mtd->owner)) 262 goto out_unlock; 263 264 if (mtd->get_device) { 265 err = mtd->get_device(mtd); 266 if (err) 267 goto out_put; 268 } 269 270 mtd->usecount++; 271 mutex_unlock(&mtd_table_mutex); 272 return mtd; 273 274 out_put: 275 module_put(mtd->owner); 276 out_unlock: 277 mutex_unlock(&mtd_table_mutex); 278 return ERR_PTR(err); 279 } 280 281 void put_mtd_device(struct mtd_info *mtd) 282 { 283 int c; 284 285 mutex_lock(&mtd_table_mutex); 286 c = --mtd->usecount; 287 if (mtd->put_device) 288 mtd->put_device(mtd); 289 mutex_unlock(&mtd_table_mutex); 290 BUG_ON(c < 0); 291 292 module_put(mtd->owner); 293 } 294 295 /* default_mtd_writev - default mtd writev method for MTD devices that 296 * don't implement their own 297 */ 298 299 int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs, 300 unsigned long count, loff_t to, size_t *retlen) 301 { 302 unsigned long i; 303 size_t totlen = 0, thislen; 304 int ret = 0; 305 306 if(!mtd->write) { 307 ret = -EROFS; 308 } else { 309 for (i=0; i<count; i++) { 310 if (!vecs[i].iov_len) 311 continue; 312 ret = mtd->write(mtd, to, vecs[i].iov_len, &thislen, vecs[i].iov_base); 313 totlen += thislen; 314 if (ret || thislen != vecs[i].iov_len) 315 break; 316 to += vecs[i].iov_len; 317 } 318 } 319 if (retlen) 320 *retlen = totlen; 321 return ret; 322 } 323 324 EXPORT_SYMBOL_GPL(add_mtd_device); 325 EXPORT_SYMBOL_GPL(del_mtd_device); 326 EXPORT_SYMBOL_GPL(get_mtd_device); 327 EXPORT_SYMBOL_GPL(get_mtd_device_nm); 328 EXPORT_SYMBOL_GPL(put_mtd_device); 329 EXPORT_SYMBOL_GPL(register_mtd_user); 330 EXPORT_SYMBOL_GPL(unregister_mtd_user); 331 EXPORT_SYMBOL_GPL(default_mtd_writev); 332 333 #ifdef CONFIG_PROC_FS 334 335 /*====================================================================*/ 336 /* Support for /proc/mtd */ 337 338 static struct proc_dir_entry *proc_mtd; 339 340 static inline int mtd_proc_info (char *buf, int i) 341 { 342 struct mtd_info *this = mtd_table[i]; 343 344 if (!this) 345 return 0; 346 347 return sprintf(buf, "mtd%d: %8.8x %8.8x \"%s\"\n", i, this->size, 348 this->erasesize, this->name); 349 } 350 351 static int mtd_read_proc (char *page, char **start, off_t off, int count, 352 int *eof, void *data_unused) 353 { 354 int len, l, i; 355 off_t begin = 0; 356 357 mutex_lock(&mtd_table_mutex); 358 359 len = sprintf(page, "dev: size erasesize name\n"); 360 for (i=0; i< MAX_MTD_DEVICES; i++) { 361 362 l = mtd_proc_info(page + len, i); 363 len += l; 364 if (len+begin > off+count) 365 goto done; 366 if (len+begin < off) { 367 begin += len; 368 len = 0; 369 } 370 } 371 372 *eof = 1; 373 374 done: 375 mutex_unlock(&mtd_table_mutex); 376 if (off >= len+begin) 377 return 0; 378 *start = page + (off-begin); 379 return ((count < begin+len-off) ? count : begin+len-off); 380 } 381 382 /*====================================================================*/ 383 /* Init code */ 384 385 static int __init init_mtd(void) 386 { 387 if ((proc_mtd = create_proc_entry( "mtd", 0, NULL ))) 388 proc_mtd->read_proc = mtd_read_proc; 389 return 0; 390 } 391 392 static void __exit cleanup_mtd(void) 393 { 394 if (proc_mtd) 395 remove_proc_entry( "mtd", NULL); 396 } 397 398 module_init(init_mtd); 399 module_exit(cleanup_mtd); 400 401 #endif /* CONFIG_PROC_FS */ 402 403 404 MODULE_LICENSE("GPL"); 405 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>"); 406 MODULE_DESCRIPTION("Core MTD registration and access routines"); 407