Return to fbsd-device.c CVS log

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

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

1.1       misho       1: /*
                      2:  *     The PCI Library -- FreeBSD /dev/pci access
                      3:  *
                      4:  *     Copyright (c) 1999 Jari Kirma <kirma@cs.hut.fi>
                      5:  *     Updated in 2003 by Samy Al Bahra <samy@kerneled.com>
                      6:  *
                      7:  *     Can be freely distributed and used under the terms of the GNU GPL.
                      8:  */
                      9: 
                     10: #include <errno.h>
                     11: #include <fcntl.h>
                     12: #include <stdio.h>
                     13: #include <string.h>
                     14: #include <unistd.h>
                     15: #include <osreldate.h>
                     16: #include <stdint.h>
                     17: 
                     18: #ifdef __FreeBSD_kernel_version
                     19: #  ifndef __FreeBSD_version
                     20: #    define __FreeBSD_version __FreeBSD_kernel_version
                     21: #  endif
                     22: #endif
                     23: 
                     24: #if __FreeBSD_version < 430000 && !defined(__DragonFly__)
                     25: #  include <pci/pcivar.h>
                     26: #  include <pci/pci_ioctl.h>
                     27: #else
                     28: #  include <sys/pciio.h>
                     29: #endif
                     30: 
                     31: #include "internal.h"
                     32: 
                     33: static void
                     34: fbsd_config(struct pci_access *a)
                     35: {
                     36:   pci_define_param(a, "fbsd.path", PCI_PATH_FBSD_DEVICE, "Path to the FreeBSD PCI device");
                     37: }
                     38: 
                     39: static int
                     40: fbsd_detect(struct pci_access *a)
                     41: {
                     42:   char *name = pci_get_param(a, "fbsd.path");
                     43: 
                     44:   if (access(name, R_OK))
                     45:     {
                     46:       a->warning("Cannot open %s", name);
                     47:       return 0;
                     48:     }
                     49:   a->debug("...using %s", name);
                     50:   return 1;
                     51: }
                     52: 
                     53: static void
                     54: fbsd_init(struct pci_access *a)
                     55: {
                     56:   char *name = pci_get_param(a, "fbsd.path");
                     57: 
                     58:   a->fd = open(name, O_RDWR, 0);
                     59:   if (a->fd < 0)
                     60:     a->error("fbsd_init: %s open failed", name);
                     61: }
                     62: 
                     63: static void
                     64: fbsd_cleanup(struct pci_access *a)
                     65: {
                     66:   close(a->fd);
                     67: }
                     68: 
                     69: static int
                     70: fbsd_read(struct pci_dev *d, int pos, byte *buf, int len)
                     71: {
                     72:   struct pci_io pi;
                     73: 
                     74:   if (!(len == 1 || len == 2 || len == 4))
                     75:     return pci_generic_block_read(d, pos, buf, len);
                     76: 
                     77:   if (pos >= 256)
                     78:     return 0;
                     79: 
                     80: #if __FreeBSD_version >= 700053
                     81:   pi.pi_sel.pc_domain = d->domain;
                     82: #endif
                     83:   pi.pi_sel.pc_bus = d->bus;
                     84:   pi.pi_sel.pc_dev = d->dev;
                     85:   pi.pi_sel.pc_func = d->func;
                     86: 
                     87:   pi.pi_reg = pos;
                     88:   pi.pi_width = len;
                     89: 
                     90:   if (ioctl(d->access->fd, PCIOCREAD, &pi) < 0)
                     91:     {
                     92:       if (errno == ENODEV)
                     93:        return 0;
                     94:       d->access->error("fbsd_read: ioctl(PCIOCREAD) failed: %s", strerror(errno));
                     95:     }
                     96: 
                     97:   switch (len)
                     98:     {
                     99:     case 1:
                    100:       buf[0] = (u8) pi.pi_data;
                    101:       break;
                    102:     case 2:
                    103:       ((u16 *) buf)[0] = cpu_to_le16((u16) pi.pi_data);
                    104:       break;
                    105:     case 4:
                    106:       ((u32 *) buf)[0] = cpu_to_le32((u32) pi.pi_data);
                    107:       break;
                    108:     }
                    109:   return 1;
                    110: }
                    111: 
                    112: static int
                    113: fbsd_write(struct pci_dev *d, int pos, byte *buf, int len)
                    114: {
                    115:   struct pci_io pi;
                    116: 
                    117:   if (!(len == 1 || len == 2 || len == 4))
                    118:     return pci_generic_block_write(d, pos, buf, len);
                    119: 
                    120:   if (pos >= 256)
                    121:     return 0;
                    122: 
                    123: #if __FreeBSD_version >= 700053
                    124:   pi.pi_sel.pc_domain = d->domain;
                    125: #endif
                    126:   pi.pi_sel.pc_bus = d->bus;
                    127:   pi.pi_sel.pc_dev = d->dev;
                    128:   pi.pi_sel.pc_func = d->func;
                    129: 
                    130:   pi.pi_reg = pos;
                    131:   pi.pi_width = len;
                    132: 
                    133:   switch (len)
                    134:     {
                    135:     case 1:
                    136:       pi.pi_data = buf[0];
                    137:       break;
                    138:     case 2:
                    139:       pi.pi_data = le16_to_cpu(((u16 *) buf)[0]);
                    140:       break;
                    141:     case 4:
                    142:       pi.pi_data = le32_to_cpu(((u32 *) buf)[0]);
                    143:       break;
                    144:     }
                    145: 
                    146:   if (ioctl(d->access->fd, PCIOCWRITE, &pi) < 0)
                    147:     {
                    148:       if (errno == ENODEV)
                    149:        return 0;
                    150:       d->access->error("fbsd_write: ioctl(PCIOCWRITE) failed: %s", strerror(errno));
                    151:     }
                    152: 
                    153:   return 1;
                    154: }
                    155: 
                    156: struct pci_methods pm_fbsd_device = {
                    157:   "fbsd-device",
                    158:   "FreeBSD /dev/pci device",
                    159:   fbsd_config,
                    160:   fbsd_detect,
                    161:   fbsd_init,
                    162:   fbsd_cleanup,
                    163:   pci_generic_scan,
                    164:   pci_generic_fill_info,
                    165:   fbsd_read,
                    166:   fbsd_write,
                    167:   NULL,                                 /* read_vpd */
                    168:   NULL,                                 /* dev_init */
                    169:   NULL                                  /* dev_cleanup */
                    170: };