[thirdparty/pciutils.git] / lib / fbsd-device.c

/*
 *	The PCI Library -- FreeBSD /dev/pci access
 *
 *	Copyright (c) 1999 Jari Kirma <kirma@cs.hut.fi>
 *	Updated in 2003 by Samy Al Bahra <samy@kerneled.com>
 *	Updated in 2017 by Imre Vadász <imrevdsz@gmail.com>
 *
 *	Can be freely distributed and used under the terms of the GNU GPL.
 */

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <osreldate.h>
#include <stdint.h>

#ifdef __FreeBSD_kernel_version
#  ifndef __FreeBSD_version
#    define __FreeBSD_version __FreeBSD_kernel_version
#  endif
#endif

#if __FreeBSD_version < 430000 && !defined(__DragonFly__)
#  include <pci/pcivar.h>
#  include <pci/pci_ioctl.h>
#else
#  include <sys/pciio.h>
#endif

#include "internal.h"

static void
fbsd_config(struct pci_access *a)
{
  pci_define_param(a, "fbsd.path", PCI_PATH_FBSD_DEVICE, "Path to the FreeBSD PCI device");
}

static int
fbsd_detect(struct pci_access *a)
{
  char *name = pci_get_param(a, "fbsd.path");

  if (access(name, R_OK))
    {
      a->warning("Cannot open %s", name);
      return 0;
    }
  a->debug("...using %s", name);
  return 1;
}

static void
fbsd_init(struct pci_access *a)
{
  char *name = pci_get_param(a, "fbsd.path");
  int fd;

  a->fd = -1;
  a->fd_rw = -1;
  /*
   * When opening /dev/pci as read-write fails, retry with readonly which
   * will still allow us to gain some information via the PCIOCGETCONF and
   * PCIOCGETBAR IOCTLs, even without generic read access to the PCI config
   * space.
   */
  fd = open(name, O_RDWR, 0);
  if (fd < 0)
    {
      fd = open(name, O_RDONLY, 0);
      if (fd < 0)
	a->error("fbsd_init: %s open failed", name);
      else
	{
	  a->debug("fbsd_init: Fallback to read-only opened %s", name);
	  a->fd = fd;
	}
    }
  else
    a->fd_rw = fd;
}

static void
fbsd_cleanup(struct pci_access *a)
{
  if (a->fd >= 0)
    {
      close(a->fd);
      a->fd = -1;
    }
  if (a->fd_rw >= 0)
    {
      close(a->fd_rw);
      a->fd_rw = -1;
    }
}

static void
fbsd_scan(struct pci_access *a)
{
  struct pci_conf_io conf;
  struct pci_conf *matches;
  struct pci_dev *t;
  uint32_t offset = 0;
  unsigned int i;

  matches = calloc(32, sizeof(struct pci_conf));
  if (matches == NULL)
    {
      a->error("calloc: %s", strerror(errno));
      return;
    }

  conf.generation = 0;
  do
    {
      conf.pat_buf_len = 0;
      conf.num_patterns = 0;
      conf.patterns = NULL;
      conf.match_buf_len = 32 * sizeof(struct pci_conf);
      conf.num_matches = 32;
      conf.matches = matches;
      conf.offset = offset;
      conf.status = 0;
      if (ioctl(a->fd_rw >= 0 ? a->fd_rw : a->fd, PCIOCGETCONF, &conf) < 0)
	{
	  if (errno == ENODEV)
	    break;
	  a->error("fbsd_scan: ioctl(PCIOCGETCONF) failed: %s",
	      strerror(errno));
	}
      /* PCI_GETCONF_LIST_CHANGED would require us to start over. */
      if (conf.status == PCI_GETCONF_ERROR ||
	  conf.status == PCI_GETCONF_LIST_CHANGED)
	{
	  a->error("fbsd_scan: ioctl(PCIOCGETCONF) failed");
	  break;
	}
      for (i = 0; i < conf.num_matches; i++)
        {
	  t = pci_alloc_dev(a);
	  t->bus = matches[i].pc_sel.pc_bus;
	  t->dev = matches[i].pc_sel.pc_dev;
	  t->func = matches[i].pc_sel.pc_func;
	  t->domain = matches[i].pc_sel.pc_domain;
	  t->domain_16 = matches[i].pc_sel.pc_domain;
	  t->vendor_id = matches[i].pc_vendor;
	  t->device_id = matches[i].pc_device;
	  t->known_fields = PCI_FILL_IDENT;
	  t->hdrtype = matches[i].pc_hdr;
	  pci_link_dev(a, t);
	}
      offset += conf.num_matches;
    }
  while (conf.status == PCI_GETCONF_MORE_DEVS);

  free(matches);
}

static int
fbsd_fill_info(struct pci_dev *d, int flags)
{
  struct pci_conf_io conf;
  struct pci_bar_io bar;
  struct pci_match_conf pattern;
  struct pci_conf match;
  int i;

  if (d->access->fd_rw >= 0)
    return pci_generic_fill_info(d, flags);

  /*
   * Can only handle PCI_FILL_IDENT, PCI_FILL_CLASS, PCI_FILL_BASES and
   * PCI_FILL_SIZES requests with the PCIOCGETCONF and PCIOCGETBAR IOCTLs.
   */

  conf.pat_buf_len = sizeof(struct pci_match_conf);
  conf.num_patterns = 1;
  conf.patterns = &pattern;
  conf.match_buf_len = sizeof(struct pci_conf);
  conf.num_matches = 1;
  conf.matches = &match;
  conf.offset = 0;
  conf.generation = 0;
  conf.status = 0;

  pattern.pc_sel.pc_domain = d->domain;
  pattern.pc_sel.pc_bus = d->bus;
  pattern.pc_sel.pc_dev = d->dev;
  pattern.pc_sel.pc_func = d->func;
  pattern.flags = PCI_GETCONF_MATCH_DOMAIN | PCI_GETCONF_MATCH_BUS |
	  PCI_GETCONF_MATCH_DEV | PCI_GETCONF_MATCH_FUNC;

  if (ioctl(d->access->fd, PCIOCGETCONF, &conf) < 0)
    {
      if (errno == ENODEV)
        return 0;
      d->access->error("fbsd_fill_info: ioctl(PCIOCGETCONF) failed: %s", strerror(errno));
    }

  if (flags & PCI_FILL_IDENT)
    {
      d->vendor_id = match.pc_vendor;
      d->device_id = match.pc_device;
    }
  if (flags & PCI_FILL_CLASS)
    {
      d->device_class = match.pc_class | (match.pc_subclass << 8);
    }
  if (flags & (PCI_FILL_BASES | PCI_FILL_SIZES))
    {
      d->rom_base_addr = 0;
      d->rom_size = 0;
      for (i = 0; i < 6; i++)
        {
	  bar.pbi_sel.pc_domain = d->domain;
	  bar.pbi_sel.pc_bus = d->bus;
	  bar.pbi_sel.pc_dev = d->dev;
	  bar.pbi_sel.pc_func = d->func;
	  bar.pbi_reg = 0x10 + 4*i;
	  bar.pbi_enabled = 0;
	  bar.pbi_base = 0;
	  bar.pbi_length = 0;
	  if (ioctl(d->access->fd, PCIOCGETBAR, &bar) < 0)
	    {
	      if (errno == ENODEV)
		return 0;
	      if (errno == EINVAL)
	        {
		  d->base_addr[i] = 0;
		  d->size[i] = 0;
		}
	      else
	        d->access->error("fbsd_fill_info: ioctl(PCIOCGETBAR) failed: %s", strerror(errno));
	    }
	  else
	    {
	      d->base_addr[i] = bar.pbi_base;
	      d->size[i] = bar.pbi_length;
	    }
	}
    }

  return flags & (PCI_FILL_IDENT | PCI_FILL_CLASS | PCI_FILL_BASES |
		  PCI_FILL_SIZES);
}

static int
fbsd_read(struct pci_dev *d, int pos, byte *buf, int len)
{
  struct pci_io pi;

  if (d->access->fd_rw < 0)
    {
      d->access->warning("fbsd_read: missing permissions");
      return 0;
    }

  if (!(len == 1 || len == 2 || len == 4))
    return pci_generic_block_read(d, pos, buf, len);

  if (pos >= 4096)
    return 0;

#if __FreeBSD_version >= 700053 || defined(__DragonFly__)
  pi.pi_sel.pc_domain = d->domain;
#endif
  pi.pi_sel.pc_bus = d->bus;
  pi.pi_sel.pc_dev = d->dev;
  pi.pi_sel.pc_func = d->func;

  pi.pi_reg = pos;
  pi.pi_width = len;

  if (ioctl(d->access->fd_rw, PCIOCREAD, &pi) < 0)
    {
      if (errno == ENODEV)
	return 0;
      d->access->error("fbsd_read: ioctl(PCIOCREAD) failed: %s", strerror(errno));
    }

  switch (len)
    {
    case 1:
      buf[0] = (u8) pi.pi_data;
      break;
    case 2:
      ((u16 *) buf)[0] = cpu_to_le16((u16) pi.pi_data);
      break;
    case 4:
      ((u32 *) buf)[0] = cpu_to_le32((u32) pi.pi_data);
      break;
    }
  return 1;
}

static int
fbsd_write(struct pci_dev *d, int pos, byte *buf, int len)
{
  struct pci_io pi;

  if (d->access->fd_rw < 0)
    {
      d->access->warning("fbsd_write: missing permissions");
      return 0;
    }

  if (!(len == 1 || len == 2 || len == 4))
    return pci_generic_block_write(d, pos, buf, len);

  if (pos >= 4096)
    return 0;

#if __FreeBSD_version >= 700053 || defined(__DragonFly__)
  pi.pi_sel.pc_domain = d->domain;
#endif
  pi.pi_sel.pc_bus = d->bus;
  pi.pi_sel.pc_dev = d->dev;
  pi.pi_sel.pc_func = d->func;

  pi.pi_reg = pos;
  pi.pi_width = len;

  switch (len)
    {
    case 1:
      pi.pi_data = buf[0];
      break;
    case 2:
      pi.pi_data = le16_to_cpu(((u16 *) buf)[0]);
      break;
    case 4:
      pi.pi_data = le32_to_cpu(((u32 *) buf)[0]);
      break;
    }

  if (ioctl(d->access->fd_rw, PCIOCWRITE, &pi) < 0)
    {
      if (errno == ENODEV)
	return 0;
      d->access->error("fbsd_write: ioctl(PCIOCWRITE) failed: %s", strerror(errno));
    }

  return 1;
}

struct pci_methods pm_fbsd_device = {
  "fbsd-device",
  "FreeBSD /dev/pci device",
  fbsd_config,
  fbsd_detect,
  fbsd_init,
  fbsd_cleanup,
  fbsd_scan,
  fbsd_fill_info,
  fbsd_read,
  fbsd_write,
  NULL,                                 /* read_vpd */
  NULL,                                 /* dev_init */
  NULL                                  /* dev_cleanup */
};
Commit	Line	Data
168b4f46 MM	1	/*
	2	* The PCI Library -- FreeBSD /dev/pci access
	3	*
	4	* Copyright (c) 1999 Jari Kirma <kirma@cs.hut.fi>
ab12277e	5	* Updated in 2003 by Samy Al Bahra <samy@kerneled.com>
0f3d0ca7	6	* Updated in 2017 by Imre Vadász <imrevdsz@gmail.com>
168b4f46 MM	7	*
	8	* Can be freely distributed and used under the terms of the GNU GPL.
	9	*/
	10
ac9956a8	11	#include <errno.h>
168b4f46	12	#include <fcntl.h>
ac9956a8	13	#include <stdio.h>
0f3d0ca7	14	#include <stdlib.h>
168b4f46 MM	15	#include <string.h>
168b4f46 MM	16	#include <unistd.h>
ab12277e	17	#include <osreldate.h>
d1058e9d MM	18	#include <stdint.h>
	19
	20	#ifdef __FreeBSD_kernel_version
	21	# ifndef __FreeBSD_version
	22	# define __FreeBSD_version __FreeBSD_kernel_version
	23	# endif
	24	#endif
ab12277e	25
99091df9	26	#if __FreeBSD_version < 430000 && !defined(__DragonFly__)
ac9956a8	27	# include <pci/pcivar.h>
ab12277e MM	28	# include <pci/pci_ioctl.h>
	29	#else
	30	# include <sys/pciio.h>
	31	#endif
168b4f46 MM	32
	33	#include "internal.h"
	34
	35	static void
	36	fbsd_config(struct pci_access *a)
	37	{
cb6ee324	38	pci_define_param(a, "fbsd.path", PCI_PATH_FBSD_DEVICE, "Path to the FreeBSD PCI device");
168b4f46 MM	39	}
	40
	41	static int
	42	fbsd_detect(struct pci_access *a)
	43	{
cb6ee324	44	char *name = pci_get_param(a, "fbsd.path");
168b4f46 MM	45
	46	if (access(name, R_OK))
	47	{
	48	a->warning("Cannot open %s", name);
	49	return 0;
	50	}
	51	a->debug("...using %s", name);
	52	return 1;
	53	}
	54
	55	static void
	56	fbsd_init(struct pci_access *a)
	57	{
cb6ee324	58	char *name = pci_get_param(a, "fbsd.path");
0f3d0ca7	59	int fd;
168b4f46	60
0f3d0ca7 IV	61	a->fd = -1;
	62	a->fd_rw = -1;
	63	/*
	64	* When opening /dev/pci as read-write fails, retry with readonly which
	65	* will still allow us to gain some information via the PCIOCGETCONF and
	66	* PCIOCGETBAR IOCTLs, even without generic read access to the PCI config
	67	* space.
	68	*/
	69	fd = open(name, O_RDWR, 0);
	70	if (fd < 0)
	71	{
	72	fd = open(name, O_RDONLY, 0);
	73	if (fd < 0)
	74	a->error("fbsd_init: %s open failed", name);
	75	else
	76	{
	77	a->debug("fbsd_init: Fallback to read-only opened %s", name);
	78	a->fd = fd;
	79	}
	80	}
	81	else
	82	a->fd_rw = fd;
168b4f46 MM	83	}
	84
	85	static void
	86	fbsd_cleanup(struct pci_access *a)
	87	{
0f3d0ca7 IV	88	if (a->fd >= 0)
	89	{
	90	close(a->fd);
	91	a->fd = -1;
	92	}
	93	if (a->fd_rw >= 0)
	94	{
	95	close(a->fd_rw);
	96	a->fd_rw = -1;
	97	}
	98	}
	99
	100	static void
	101	fbsd_scan(struct pci_access *a)
	102	{
	103	struct pci_conf_io conf;
	104	struct pci_conf *matches;
	105	struct pci_dev *t;
	106	uint32_t offset = 0;
	107	unsigned int i;
	108
	109	matches = calloc(32, sizeof(struct pci_conf));
	110	if (matches == NULL)
	111	{
	112	a->error("calloc: %s", strerror(errno));
	113	return;
	114	}
	115
	116	conf.generation = 0;
	117	do
	118	{
	119	conf.pat_buf_len = 0;
	120	conf.num_patterns = 0;
	121	conf.patterns = NULL;
	122	conf.match_buf_len = 32 * sizeof(struct pci_conf);
	123	conf.num_matches = 32;
	124	conf.matches = matches;
	125	conf.offset = offset;
	126	conf.status = 0;
	127	if (ioctl(a->fd_rw >= 0 ? a->fd_rw : a->fd, PCIOCGETCONF, &conf) < 0)
	128	{
	129	if (errno == ENODEV)
	130	break;
	131	a->error("fbsd_scan: ioctl(PCIOCGETCONF) failed: %s",
	132	strerror(errno));
	133	}
	134	/* PCI_GETCONF_LIST_CHANGED would require us to start over. */
	135	if (conf.status == PCI_GETCONF_ERROR \|\|
	136	conf.status == PCI_GETCONF_LIST_CHANGED)
	137	{
	138	a->error("fbsd_scan: ioctl(PCIOCGETCONF) failed");
	139	break;
	140	}
	141	for (i = 0; i < conf.num_matches; i++)
	142	{
	143	t = pci_alloc_dev(a);
	144	t->bus = matches[i].pc_sel.pc_bus;
	145	t->dev = matches[i].pc_sel.pc_dev;
58d9f25f	146	t->func = matches[i].pc_sel.pc_func;
0f3d0ca7 IV	147	t->domain = matches[i].pc_sel.pc_domain;
	148	t->domain_16 = matches[i].pc_sel.pc_domain;
	149	t->vendor_id = matches[i].pc_vendor;
	150	t->device_id = matches[i].pc_device;
	151	t->known_fields = PCI_FILL_IDENT;
	152	t->hdrtype = matches[i].pc_hdr;
	153	pci_link_dev(a, t);
	154	}
	155	offset += conf.num_matches;
	156	}
	157	while (conf.status == PCI_GETCONF_MORE_DEVS);
	158
	159	free(matches);
	160	}
	161
	162	static int
	163	fbsd_fill_info(struct pci_dev *d, int flags)
	164	{
	165	struct pci_conf_io conf;
	166	struct pci_bar_io bar;
	167	struct pci_match_conf pattern;
	168	struct pci_conf match;
	169	int i;
	170
	171	if (d->access->fd_rw >= 0)
	172	return pci_generic_fill_info(d, flags);
	173
	174	/*
	175	* Can only handle PCI_FILL_IDENT, PCI_FILL_CLASS, PCI_FILL_BASES and
	176	* PCI_FILL_SIZES requests with the PCIOCGETCONF and PCIOCGETBAR IOCTLs.
	177	*/
	178
	179	conf.pat_buf_len = sizeof(struct pci_match_conf);
	180	conf.num_patterns = 1;
	181	conf.patterns = &pattern;
	182	conf.match_buf_len = sizeof(struct pci_conf);
	183	conf.num_matches = 1;
	184	conf.matches = &match;
	185	conf.offset = 0;
	186	conf.generation = 0;
	187	conf.status = 0;
	188
	189	pattern.pc_sel.pc_domain = d->domain;
	190	pattern.pc_sel.pc_bus = d->bus;
	191	pattern.pc_sel.pc_dev = d->dev;
	192	pattern.pc_sel.pc_func = d->func;
	193	pattern.flags = PCI_GETCONF_MATCH_DOMAIN \| PCI_GETCONF_MATCH_BUS \|
	194	PCI_GETCONF_MATCH_DEV \| PCI_GETCONF_MATCH_FUNC;
	195
	196	if (ioctl(d->access->fd, PCIOCGETCONF, &conf) < 0)
	197	{
	198	if (errno == ENODEV)
	199	return 0;
	200	d->access->error("fbsd_fill_info: ioctl(PCIOCGETCONF) failed: %s", strerror(errno));
	201	}
	202
	203	if (flags & PCI_FILL_IDENT)
	204	{
	205	d->vendor_id = match.pc_vendor;
	206	d->device_id = match.pc_device;
	207	}
	208	if (flags & PCI_FILL_CLASS)
	209	{
	210	d->device_class = match.pc_class \| (match.pc_subclass << 8);
211	}
212	if (flags & (PCI_FILL_BASES \| PCI_FILL_SIZES))
213	{
214	d->rom_base_addr = 0;
215	d->rom_size = 0;
216	for (i = 0; i < 6; i++)
217	{
218	bar.pbi_sel.pc_domain = d->domain;
219	bar.pbi_sel.pc_bus = d->bus;
220	bar.pbi_sel.pc_dev = d->dev;
221	bar.pbi_sel.pc_func = d->func;
222	bar.pbi_reg = 0x10 + 4*i;
223	bar.pbi_enabled = 0;
224	bar.pbi_base = 0;
225	bar.pbi_length = 0;
226	if (ioctl(d->access->fd, PCIOCGETBAR, &bar) < 0)
227	{
228	if (errno == ENODEV)
229	return 0;
230	if (errno == EINVAL)
231	{
232	d->base_addr[i] = 0;
233	d->size[i] = 0;
234	}
235	else
236	d->access->error("fbsd_fill_info: ioctl(PCIOCGETBAR) failed: %s", strerror(errno));
237	}
238	else
239	{
240	d->base_addr[i] = bar.pbi_base;
241	d->size[i] = bar.pbi_length;
242	}
243	}
244	}
245
246	return flags & (PCI_FILL_IDENT \| PCI_FILL_CLASS \| PCI_FILL_BASES \|
247	PCI_FILL_SIZES);
168b4f46 MM	248	}
	249
	250	static int
	251	fbsd_read(struct pci_dev d, int pos, byte buf, int len)
	252	{
	253	struct pci_io pi;
	254
0f3d0ca7 IV	255	if (d->access->fd_rw < 0)
0f3d0ca7 IV	256	{
6d2d713d	257	d->access->warning("fbsd_read: missing permissions");
0f3d0ca7 IV	258	return 0;
	259	}
	260
168b4f46	261	if (!(len == 1 \|\| len == 2 \|\| len == 4))
9c79fcc4	262	return pci_generic_block_read(d, pos, buf, len);
168b4f46	263
7663958f	264	if (pos >= 4096)
09817437 MM	265	return 0;
09817437 MM	266
f4dbe106	267	#if __FreeBSD_version >= 700053 \|\| defined(__DragonFly__)
ac9956a8 MM	268	pi.pi_sel.pc_domain = d->domain;
ac9956a8 MM	269	#endif
168b4f46 MM	270	pi.pi_sel.pc_bus = d->bus;
	271	pi.pi_sel.pc_dev = d->dev;
	272	pi.pi_sel.pc_func = d->func;
	273
	274	pi.pi_reg = pos;
	275	pi.pi_width = len;
94db5c82	276
0f3d0ca7	277	if (ioctl(d->access->fd_rw, PCIOCREAD, &pi) < 0)
ac9956a8 MM	278	{
ac9956a8 MM	279	if (errno == ENODEV)
9c79fcc4	280	return 0;
ac9956a8 MM	281	d->access->error("fbsd_read: ioctl(PCIOCREAD) failed: %s", strerror(errno));
ac9956a8 MM	282	}
94db5c82	283
168b4f46 MM	284	switch (len)
	285	{
	286	case 1:
	287	buf[0] = (u8) pi.pi_data;
	288	break;
	289	case 2:
ac9956a8	290	((u16 *) buf)[0] = cpu_to_le16((u16) pi.pi_data);
168b4f46 MM	291	break;
168b4f46 MM	292	case 4:
ac9956a8	293	((u32 *) buf)[0] = cpu_to_le32((u32) pi.pi_data);
168b4f46 MM	294	break;
	295	}
	296	return 1;
	297	}
	298
	299	static int
	300	fbsd_write(struct pci_dev d, int pos, byte buf, int len)
	301	{
	302	struct pci_io pi;
	303
0f3d0ca7 IV	304	if (d->access->fd_rw < 0)
0f3d0ca7 IV	305	{
6d2d713d	306	d->access->warning("fbsd_write: missing permissions");
0f3d0ca7 IV	307	return 0;
	308	}
	309
168b4f46	310	if (!(len == 1 \|\| len == 2 \|\| len == 4))
9c79fcc4	311	return pci_generic_block_write(d, pos, buf, len);
168b4f46	312
7663958f	313	if (pos >= 4096)
09817437 MM	314	return 0;
09817437 MM	315
f4dbe106	316	#if __FreeBSD_version >= 700053 \|\| defined(__DragonFly__)
ac9956a8 MM	317	pi.pi_sel.pc_domain = d->domain;
ac9956a8 MM	318	#endif
168b4f46 MM	319	pi.pi_sel.pc_bus = d->bus;
	320	pi.pi_sel.pc_dev = d->dev;
	321	pi.pi_sel.pc_func = d->func;
	322
	323	pi.pi_reg = pos;
	324	pi.pi_width = len;
94db5c82	325
168b4f46 MM	326	switch (len)
	327	{
	328	case 1:
	329	pi.pi_data = buf[0];
	330	break;
	331	case 2:
ac9956a8	332	pi.pi_data = le16_to_cpu(((u16 *) buf)[0]);
168b4f46 MM	333	break;
168b4f46 MM	334	case 4:
ac9956a8	335	pi.pi_data = le32_to_cpu(((u32 *) buf)[0]);
168b4f46 MM	336	break;
168b4f46 MM	337	}
94db5c82	338
0f3d0ca7	339	if (ioctl(d->access->fd_rw, PCIOCWRITE, &pi) < 0)
168b4f46	340	{
ac9956a8	341	if (errno == ENODEV)
9c79fcc4	342	return 0;
ac9956a8	343	d->access->error("fbsd_write: ioctl(PCIOCWRITE) failed: %s", strerror(errno));
168b4f46 MM	344	}
	345
	346	return 1;
	347	}
	348
	349	struct pci_methods pm_fbsd_device = {
9ff67879 MM	350	"fbsd-device",
9ff67879 MM	351	"FreeBSD /dev/pci device",
168b4f46 MM	352	fbsd_config,
	353	fbsd_detect,
	354	fbsd_init,
	355	fbsd_cleanup,
0f3d0ca7 IV	356	fbsd_scan,
0f3d0ca7 IV	357	fbsd_fill_info,
168b4f46 MM	358	fbsd_read,
168b4f46 MM	359	fbsd_write,
52c81519	360	NULL, /* read_vpd */
168b4f46 MM	361	NULL, /* dev_init */
	362	NULL /* dev_cleanup */
	363	};