2 * udev database library
15 static TDB_CONTEXT *busdb;
16 static TDB_CONTEXT *classdb;
17 static TDB_CONTEXT *namedb;
20 * busdb_record - bus and id are keys to look up name of device
27 * classdb_record - class name and class device name used as keys to find
30 struct classdb_record {
35 * namedb_record - device name is key, remaining udevice info stored here.
37 struct namedb_record {
38 char sysfs_path[PATH_SIZE];
39 char class_dev_name[NAME_SIZE];
40 char class_name[NAME_SIZE];
43 char driver[NAME_SIZE];
51 * busdb_close: close busdb database
53 static void busdb_close(void)
62 * classdb_close: close classdb database
64 static void classdb_close(void)
66 if (classdb != NULL) {
73 * namedb_close: close name database
75 static void namedb_close(void)
84 * busdb_open: open busdb's database
86 static int busdb_open(void)
88 busdb = tdb_open(BUS_DB, 0, 0, O_RDWR | O_CREAT, 0644);
95 * classdb_open: open classdb's database
97 static int classdb_open(void)
99 classdb = tdb_open(CLASS_DB, 0, 0, O_RDWR | O_CREAT, 0644);
106 * namedb_open: open name database
108 static int namedb_open(void)
110 namedb = tdb_open(NAME_DB, 0, 0, O_RDWR | O_CREAT, 0644);
119 static struct busdb_record *busdb_fetch(const char *bus, const char *id)
122 char keystr[BUS_SIZE+ID_SIZE+2];
123 struct busdb_record *rec = NULL;
125 if (bus == NULL || id == NULL)
127 if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
130 if ((busdb_open()) != 0)
133 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
135 strcat(keystr, UDEVDB_DEL);
138 key.dptr = (void *)keystr;
139 key.dsize = strlen(keystr) + 1;
141 data = tdb_fetch(busdb, key);
143 if (data.dptr == NULL || data.dsize == 0)
146 rec = (struct busdb_record *)malloc(sizeof(struct busdb_record));
152 memcpy(rec, data.dptr, sizeof(struct busdb_record));
161 static struct classdb_record *classdb_fetch(const char *cls,
165 char keystr[NAME_SIZE+NAME_SIZE+2];
166 struct classdb_record *rec = NULL;
168 if (cls == NULL || cls_dev == NULL)
170 if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
173 if ((classdb_open()) != 0)
176 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
178 strcat(keystr, UDEVDB_DEL);
179 strcat(keystr, cls_dev);
181 key.dptr = (void *)keystr;
182 key.dsize = strlen(keystr) + 1;
184 data = tdb_fetch(classdb, key);
186 if (data.dptr == NULL || data.dsize == 0)
189 rec = (struct classdb_record *)malloc(sizeof(struct classdb_record));
195 memcpy(rec, data.dptr, sizeof(struct classdb_record));
204 static struct namedb_record *namedb_fetch(const char *name)
207 char nm_keystr[NAME_SIZE];
208 struct namedb_record *nrec = NULL;
212 if (strlen(name) >= NAME_SIZE)
215 if ((namedb_open()) != 0)
218 memset(nm_keystr, 0, NAME_SIZE);
219 strcpy(nm_keystr, name);
221 key.dptr = (void *)nm_keystr;
222 key.dsize = strlen(nm_keystr) + 1;
224 data = tdb_fetch(namedb, key);
227 if (data.dptr == NULL || data.dsize == 0)
230 nrec = (struct namedb_record *)malloc(sizeof(struct namedb_record));
236 memcpy(nrec, data.dptr, sizeof(struct namedb_record));
245 static int busdb_store(const struct udevice *dev)
248 char keystr[BUS_SIZE+ID_SIZE+2];
249 struct busdb_record rec;
255 if ((retval = busdb_open()) != 0)
258 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
259 strcpy(keystr, dev->bus_name);
260 strcat(keystr, UDEVDB_DEL);
261 strcat(keystr, dev->bus_id);
263 key.dptr = (void *)keystr;
264 key.dsize = strlen(keystr) + 1;
266 strcpy(rec.name, dev->name);
268 data.dptr = (void *) &rec;
269 data.dsize = sizeof(rec);
271 retval = tdb_store(busdb, key, data, TDB_REPLACE);
280 static int classdb_store(const struct udevice *dev)
283 char keystr[NAME_SIZE+NAME_SIZE+2];
284 struct classdb_record rec;
290 if ((retval = classdb_open()) != 0)
293 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
294 strcpy(keystr, dev->class_name);
295 strcat(keystr, UDEVDB_DEL);
296 strcat(keystr, dev->class_dev_name);
298 key.dptr = (void *)keystr;
299 key.dsize = strlen(keystr) + 1;
301 strcpy(rec.name, dev->name);
303 data.dptr = (void *) &rec;
304 data.dsize = sizeof(rec);
306 retval = tdb_store(classdb, key, data, TDB_REPLACE);
315 static int namedb_store(const struct udevice *dev)
318 char keystr[NAME_SIZE];
319 struct namedb_record rec;
325 if ((retval = namedb_open()) != 0)
328 memset(keystr, 0, NAME_SIZE);
329 strcpy(keystr, dev->name);
331 key.dptr = (void *)keystr;
332 key.dsize = strlen(keystr) + 1;
334 strcpy(rec.sysfs_path, dev->sysfs_path);
335 strcpy(rec.bus, dev->bus_name);
336 strcpy(rec.id, dev->bus_id);
337 strcpy(rec.class_dev_name, dev->class_dev_name);
338 strcpy(rec.class_name, dev->class_name);
339 strcpy(rec.driver, dev->driver);
340 rec.type = dev->type;
341 rec.major = dev->major;
342 rec.minor = dev->minor;
343 rec.mode = dev->mode;
345 data.dptr = (void *) &rec;
346 data.dsize = sizeof(rec);
348 retval = tdb_store(namedb, key, data, TDB_REPLACE);
357 static int busdb_delete(const char *bus, const char *id)
360 char keystr[BUS_SIZE+ID_SIZE+2];
363 if (bus == NULL || id == NULL)
365 if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
368 if ((busdb_open()) != 0)
371 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
373 strcat(keystr, UDEVDB_DEL);
376 key.dptr = (void *)keystr;
377 key.dsize = strlen(keystr) + 1;
379 retval = tdb_delete(busdb, key);
388 static int classdb_delete(const char *cls, const char *cls_dev)
391 char keystr[NAME_SIZE+NAME_SIZE+2];
394 if (cls == NULL || cls_dev == NULL)
396 if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
399 if ((classdb_open()) != 0)
402 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
404 strcat(keystr, UDEVDB_DEL);
405 strcat(keystr, cls_dev);
407 key.dptr = (void *)keystr;
408 key.dsize = strlen(keystr) + 1;
410 retval = tdb_delete(classdb, key);
419 static int namedb_delete(const char *name)
422 char keystr[NAME_SIZE];
427 if (strlen(name) >= NAME_SIZE)
430 if ((namedb_open()) != 0)
433 memset(keystr, 0, NAME_SIZE);
434 strcpy(keystr, name);
436 key.dptr = (void *)keystr;
437 key.dsize = strlen(keystr) + 1;
439 retval = tdb_delete(namedb, key);
448 static int namedb_exists(const char *name)
451 char keystr[NAME_SIZE];
456 if (strlen(name) >= NAME_SIZE)
459 if ((namedb_open()) != 0)
462 memset(keystr, 0, NAME_SIZE);
463 strcpy(keystr, name);
465 key.dptr = (void *)keystr;
466 key.dsize = strlen(keystr) + 1;
468 retval = tdb_exists(namedb, key);
475 * udevdb_delete_udevice
477 int udevdb_delete_udevice(const char *name)
479 struct namedb_record *nrec = NULL;
484 nrec = namedb_fetch(name);
488 busdb_delete(nrec->bus, nrec->id);
489 classdb_delete(nrec->class_name, nrec->class_dev_name);
497 * udevdb_add_udevice: adds udevice to database
499 int udevdb_add_udevice(const struct udevice *dev)
504 if ((busdb_store(dev)) != 0)
506 if ((classdb_store(dev)) != 0)
508 if ((namedb_store(dev)) != 0)
515 * udevdb_get_device: grab's device by name
517 struct udevice *udevdb_get_udevice(const char *name)
519 struct namedb_record *nrec = NULL;
520 struct udevice *dev = NULL;
525 nrec = namedb_fetch(name);
529 dev = (struct udevice *)malloc(sizeof(struct udevice));
535 strcpy(dev->name, name);
536 strcpy(dev->sysfs_path, nrec->sysfs_path);
537 strcpy(dev->class_dev_name, nrec->class_dev_name);
538 strcpy(dev->class_name, nrec->class_name);
539 strcpy(dev->bus_name, nrec->bus);
540 strcpy(dev->bus_id, nrec->id);
541 dev->type = nrec->type;
542 dev->major = nrec->major;
543 dev->minor = nrec->minor;
544 dev->mode = nrec->mode;
552 * udevdb_get_device_by_bus
554 struct udevice *udevdb_get_udevice_by_bus(const char *bus, const char *id)
556 struct busdb_record *brec = NULL;
557 struct udevice *dev = NULL;
559 if (bus == NULL || id == NULL)
562 brec = busdb_fetch(bus, id);
566 dev = udevdb_get_udevice(brec->name);
573 * udevdb_get_udevice_by_class
575 struct udevice *udevdb_get_udevice_by_class(const char *cls,
578 struct classdb_record *crec = NULL;
579 struct udevice *dev = NULL;
581 if (cls == NULL || cls_dev == NULL)
584 crec = classdb_fetch(cls, cls_dev);
588 dev = udevdb_get_udevice(crec->name);