2 * udev database library
14 static TDB_CONTEXT *busdb;
15 static TDB_CONTEXT *classdb;
16 static TDB_CONTEXT *namedb;
19 * busdb_record - bus and id are keys to look up name of device
26 * classdb_record - class name and class device name used as keys to find
29 struct classdb_record {
34 * namedb_record - device name is key, remaining udevice info stored here.
36 struct namedb_record {
37 char sysfs_path[PATH_SIZE];
38 char class_dev_name[NAME_SIZE];
39 char class_name[NAME_SIZE];
42 char driver[NAME_SIZE];
50 * busdb_close: close busdb database
52 static void busdb_close(void)
61 * classdb_close: close classdb database
63 static void classdb_close(void)
65 if (classdb != NULL) {
72 * namedb_close: close name database
74 static void namedb_close(void)
83 * busdb_open: open busdb's database
85 static int busdb_open(void)
87 busdb = tdb_open(BUS_DB, 0, 0, O_RDWR | O_CREAT, 0644);
94 * classdb_open: open classdb's database
96 static int classdb_open(void)
98 classdb = tdb_open(CLASS_DB, 0, 0, O_RDWR | O_CREAT, 0644);
105 * namedb_open: open name database
107 static int namedb_open(void)
109 namedb = tdb_open(NAME_DB, 0, 0, O_RDWR | O_CREAT, 0644);
118 static struct busdb_record *busdb_fetch(const char *bus, const char *id)
121 char keystr[BUS_SIZE+ID_SIZE+2];
122 struct busdb_record *rec = NULL;
124 if (bus == NULL || id == NULL)
126 if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
129 if ((busdb_open()) != 0)
132 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
134 strcat(keystr, UDEVDB_DEL);
137 key.dptr = (void *)keystr;
138 key.dsize = strlen(keystr) + 1;
140 data = tdb_fetch(busdb, key);
142 if (data.dptr == NULL || data.dsize == 0)
145 rec = (struct busdb_record *)malloc(sizeof(struct busdb_record));
151 memcpy(rec, data.dptr, sizeof(struct busdb_record));
160 static struct classdb_record *classdb_fetch(const char *cls,
164 char keystr[NAME_SIZE+NAME_SIZE+2];
165 struct classdb_record *rec = NULL;
167 if (cls == NULL || cls_dev == NULL)
169 if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
172 if ((classdb_open()) != 0)
175 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
177 strcat(keystr, UDEVDB_DEL);
178 strcat(keystr, cls_dev);
180 key.dptr = (void *)keystr;
181 key.dsize = strlen(keystr) + 1;
183 data = tdb_fetch(classdb, key);
185 if (data.dptr == NULL || data.dsize == 0)
188 rec = (struct classdb_record *)malloc(sizeof(struct classdb_record));
194 memcpy(rec, data.dptr, sizeof(struct classdb_record));
203 static struct namedb_record *namedb_fetch(const char *name)
206 char nm_keystr[NAME_SIZE];
207 struct namedb_record *nrec = NULL;
211 if (strlen(name) >= NAME_SIZE)
214 if ((namedb_open()) != 0)
217 memset(nm_keystr, 0, NAME_SIZE);
218 strcpy(nm_keystr, name);
220 key.dptr = (void *)nm_keystr;
221 key.dsize = strlen(nm_keystr) + 1;
223 data = tdb_fetch(namedb, key);
226 if (data.dptr == NULL || data.dsize == 0)
229 nrec = (struct namedb_record *)malloc(sizeof(struct namedb_record));
235 memcpy(nrec, data.dptr, sizeof(struct namedb_record));
244 static int busdb_store(const struct udevice *dev)
247 char keystr[BUS_SIZE+ID_SIZE+2];
248 struct busdb_record rec;
254 if ((retval = busdb_open()) != 0)
257 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
258 strcpy(keystr, dev->bus_name);
259 strcat(keystr, UDEVDB_DEL);
260 strcat(keystr, dev->bus_id);
262 key.dptr = (void *)keystr;
263 key.dsize = strlen(keystr) + 1;
265 strcpy(rec.name, dev->name);
267 data.dptr = (void *) &rec;
268 data.dsize = sizeof(rec);
270 retval = tdb_store(busdb, key, data, TDB_REPLACE);
279 static int classdb_store(const struct udevice *dev)
282 char keystr[NAME_SIZE+NAME_SIZE+2];
283 struct classdb_record rec;
289 if ((retval = classdb_open()) != 0)
292 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
293 strcpy(keystr, dev->class_name);
294 strcat(keystr, UDEVDB_DEL);
295 strcat(keystr, dev->class_dev_name);
297 key.dptr = (void *)keystr;
298 key.dsize = strlen(keystr) + 1;
300 strcpy(rec.name, dev->name);
302 data.dptr = (void *) &rec;
303 data.dsize = sizeof(rec);
305 retval = tdb_store(classdb, key, data, TDB_REPLACE);
314 static int namedb_store(const struct udevice *dev)
317 char keystr[NAME_SIZE];
318 struct namedb_record rec;
324 if ((retval = namedb_open()) != 0)
327 memset(keystr, 0, NAME_SIZE);
328 strcpy(keystr, dev->name);
330 key.dptr = (void *)keystr;
331 key.dsize = strlen(keystr) + 1;
333 strcpy(rec.sysfs_path, dev->sysfs_path);
334 strcpy(rec.bus, dev->bus_name);
335 strcpy(rec.id, dev->bus_id);
336 strcpy(rec.class_dev_name, dev->class_dev_name);
337 strcpy(rec.class_name, dev->class_name);
338 strcpy(rec.driver, dev->driver);
339 rec.type = dev->type;
340 rec.major = dev->major;
341 rec.minor = dev->minor;
342 rec.mode = dev->mode;
344 data.dptr = (void *) &rec;
345 data.dsize = sizeof(rec);
347 retval = tdb_store(namedb, key, data, TDB_REPLACE);
356 static int busdb_delete(const char *bus, const char *id)
359 char keystr[BUS_SIZE+ID_SIZE+2];
362 if (bus == NULL || id == NULL)
364 if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
367 if ((busdb_open()) != 0)
370 memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
372 strcat(keystr, UDEVDB_DEL);
375 key.dptr = (void *)keystr;
376 key.dsize = strlen(keystr) + 1;
378 retval = tdb_delete(busdb, key);
387 static int classdb_delete(const char *cls, const char *cls_dev)
390 char keystr[NAME_SIZE+NAME_SIZE+2];
393 if (cls == NULL || cls_dev == NULL)
395 if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
398 if ((classdb_open()) != 0)
401 memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
403 strcat(keystr, UDEVDB_DEL);
404 strcat(keystr, cls_dev);
406 key.dptr = (void *)keystr;
407 key.dsize = strlen(keystr) + 1;
409 retval = tdb_delete(classdb, key);
418 static int namedb_delete(const char *name)
421 char keystr[NAME_SIZE];
426 if (strlen(name) >= NAME_SIZE)
429 if ((namedb_open()) != 0)
432 memset(keystr, 0, NAME_SIZE);
433 strcpy(keystr, name);
435 key.dptr = (void *)keystr;
436 key.dsize = strlen(keystr) + 1;
438 retval = tdb_delete(namedb, key);
447 static int namedb_exists(const char *name)
450 char keystr[NAME_SIZE];
455 if (strlen(name) >= NAME_SIZE)
458 if ((namedb_open()) != 0)
461 memset(keystr, 0, NAME_SIZE);
462 strcpy(keystr, name);
464 key.dptr = (void *)keystr;
465 key.dsize = strlen(keystr) + 1;
467 retval = tdb_exists(namedb, key);
474 * udevdb_delete_udevice
476 int udevdb_delete_udevice(const char *name)
478 struct namedb_record *nrec = NULL;
483 nrec = namedb_fetch(name);
487 busdb_delete(nrec->bus, nrec->id);
488 classdb_delete(nrec->class_name, nrec->class_dev_name);
496 * udevdb_add_udevice: adds udevice to database
498 int udevdb_add_udevice(const struct udevice *dev)
503 if ((busdb_store(dev)) != 0)
505 if ((classdb_store(dev)) != 0)
507 if ((namedb_store(dev)) != 0)
514 * udevdb_get_device: grab's device by name
516 struct udevice *udevdb_get_udevice(const char *name)
518 struct namedb_record *nrec = NULL;
519 struct udevice *dev = NULL;
524 nrec = namedb_fetch(name);
528 dev = (struct udevice *)malloc(sizeof(struct udevice));
534 strcpy(dev->name, name);
535 strcpy(dev->sysfs_path, nrec->sysfs_path);
536 strcpy(dev->class_dev_name, nrec->class_dev_name);
537 strcpy(dev->class_name, nrec->class_name);
538 strcpy(dev->bus_name, nrec->bus);
539 strcpy(dev->bus_id, nrec->id);
540 dev->type = nrec->type;
541 dev->major = nrec->major;
542 dev->minor = nrec->minor;
543 dev->mode = nrec->mode;
551 * udevdb_get_device_by_bus
553 struct udevice *udevdb_get_udevice_by_bus(const char *bus, const char *id)
555 struct busdb_record *brec = NULL;
556 struct udevice *dev = NULL;
558 if (bus == NULL || id == NULL)
561 brec = busdb_fetch(bus, id);
565 dev = udevdb_get_udevice(brec->name);
572 * udevdb_get_udevice_by_class
574 struct udevice *udevdb_get_udevice_by_class(const char *cls,
577 struct classdb_record *crec = NULL;
578 struct udevice *dev = NULL;
580 if (cls == NULL || cls_dev == NULL)
583 crec = classdb_fetch(cls, cls_dev);
587 dev = udevdb_get_udevice(crec->name);