Return to obsd-device.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pciutils / lib

Annotation of embedaddon/pciutils/lib/obsd-device.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  *     The PCI Library -- OpenBSD /dev/pci access
                      3:  *
                      4:  *     Adapted from fbsd-device.c by Matthieu Herrb <matthieu.herrb@laas.fr>, 2006
                      5:  *
                      6:  *     Can be freely distributed and used under the terms of the GNU GPL.
                      7:  */
                      8: 
                      9: #include <fcntl.h>
                     10: #include <string.h>
                     11: #include <unistd.h>
                     12: #include <errno.h>
                     13: #include <sys/endian.h>
                     14: #include <sys/types.h>
                     15: #include <sys/ioctl.h>
                     16: #include <sys/pciio.h>
                     17: #include "internal.h"
                     18: 
                     19: static void
                     20: obsd_config(struct pci_access *a)
                     21: {
                     22:   pci_define_param(a, "obsd.path", PCI_PATH_OBSD_DEVICE, "Path to the OpenBSD PCI device");
                     23: }
                     24: 
                     25: static int
                     26: obsd_detect(struct pci_access *a)
                     27: {
                     28:   char *name = pci_get_param(a, "obsd.path");
                     29: 
                     30:   if (access(name, R_OK))
                     31:     {
                     32:       a->warning("Cannot open %s", name);
                     33:       return 0;
                     34:     }
                     35:   a->debug("...using %s", name);
                     36:   return 1;
                     37: }
                     38: 
                     39: static void
                     40: obsd_init(struct pci_access *a)
                     41: {
                     42:   char *name = pci_get_param(a, "obsd.path");
                     43: 
                     44:   a->fd = open(name, O_RDWR, 0);
                     45:   if (a->fd < 0)
                     46:     a->error("obsd_init: %s open failed", name);
                     47: }
                     48: 
                     49: static void
                     50: obsd_cleanup(struct pci_access *a)
                     51: {
                     52:   close(a->fd);
                     53: }
                     54: 
                     55: static int
                     56: obsd_read(struct pci_dev *d, int pos, byte *buf, int len)
                     57: {
                     58:   struct pci_io pi;
                     59:   union {
                     60:          u_int32_t u32;
                     61:          u_int16_t u16[2];
                     62:          u_int8_t u8[4];
                     63:   } u;
                     64: 
                     65:   if (!(len == 1 || len == 2 || len == 4))
                     66:     return pci_generic_block_read(d, pos, buf, len);
                     67: 
                     68:   if (pos >= 256)
                     69:     return 0;
                     70: 
                     71:   pi.pi_sel.pc_bus = d->bus;
                     72:   pi.pi_sel.pc_dev = d->dev;
                     73:   pi.pi_sel.pc_func = d->func;
                     74: 
                     75:   pi.pi_reg = pos - (pos % 4);
                     76:   pi.pi_width = 4;
                     77: 
                     78:   if (ioctl(d->access->fd, PCIOCREAD, &pi) < 0) {
                     79:          if (errno == ENXIO)
                     80:                  pi.pi_data = 0xffffffff;
                     81:          else
                     82:                  d->access->error("obsd_read: ioctl(PCIOCREAD) failed");
                     83:   }
                     84:   u.u32 = pi.pi_data;
                     85: 
                     86:   switch (len)
                     87:     {
                     88:     case 1:
                     89:       buf[0] = (u8) u.u8[pos % 4];
                     90:       break;
                     91:     case 2:
                     92:       ((u16 *) buf)[0] = letoh16(u.u16[(pos % 4) / 2]);
                     93:       break;
                     94:     case 4:
                     95:       ((u32 *) buf)[0] = (u32) letoh32(pi.pi_data);
                     96:       break;
                     97:     }
                     98:   return 1;
                     99: }
                    100: 
                    101: static int
                    102: obsd_write(struct pci_dev *d, int pos, byte *buf, int len)
                    103: {
                    104:   struct pci_io pi;
                    105: 
                    106:   if (!(len == 1 || len == 2 || len == 4))
                    107:     return pci_generic_block_write(d, pos, buf, len);
                    108: 
                    109:   if (pos >= 256)
                    110:     return 0;
                    111: 
                    112:   pi.pi_sel.pc_bus = d->bus;
                    113:   pi.pi_sel.pc_dev = d->dev;
                    114:   pi.pi_sel.pc_func = d->func;
                    115: 
                    116:   pi.pi_reg = pos;
                    117:   pi.pi_width = len;
                    118: 
                    119:   switch (len)
                    120:     {
                    121:     case 1:
                    122:       pi.pi_data = buf[0];
                    123:       break;
                    124:     case 2:
                    125:       pi.pi_data = ((u16 *) buf)[0];
                    126:       break;
                    127:     case 4:
                    128:       pi.pi_data = ((u32 *) buf)[0];
                    129:       break;
                    130:     }
                    131: 
                    132:   if (ioctl(d->access->fd, PCIOCWRITE, &pi) < 0)
                    133:     d->access->error("obsd_write: ioctl(PCIOCWRITE) failed");
                    134: 
                    135:   return 1;
                    136: }
                    137: 
                    138: struct pci_methods pm_obsd_device = {
                    139:   "obsd-device",
                    140:   "/dev/pci on OpenBSD",
                    141:   obsd_config,
                    142:   obsd_detect,
                    143:   obsd_init,
                    144:   obsd_cleanup,
                    145:   pci_generic_scan,
                    146:   pci_generic_fill_info,
                    147:   obsd_read,
                    148:   obsd_write,
                    149:   NULL,                                 /* read_vpd */
                    150:   NULL,                                 /* dev_init */
                    151:   NULL                                  /* dev_cleanup */
                    152: };