path: root/src/external/bsd/meinberg/mbgclock/mbgclock_main.c

/*
 * $Header$
 *
 * NetBSD Meinberg mbgclock driver, Frank Kardel
 *
 * $Created: Sat Mar 26 15:03:37 2011 $
 *
 */

#include <sys/param.h>
#include <sys/lwp.h>
#include <sys/device.h>
#include <sys/conf.h>
#include <dev/pci/pcidevs.h>
#include <dev/pci/pcivar.h>
#include <sys/errno.h>

#include <pcpsdrvr.h>
#include <mbgddmsg.h>

#ifndef PCI_BAR
#define PCI_BAR(__n)            (0x10 + 4 * (__n))
#endif

#define REV_NUM          0x100
#define REV_NUM_STR      "1.00"
#define MBG_COPYRIGHT    "(c) Meinberg 2011"
#define MBG_DRVR_NAME    "mbgclock"

const char pcps_driver_name[] = MBG_DRVR_NAME;

static MBG_DBG_DATA mbg_dbg_data;
static MBG_DBG_PORT mbg_dbg_port = 0x378 + 0;  //##++
static PCPS_IO_ADDR_MAPPED mbg_dbg_port_mapped;  //##++
static PCPS_DRVR_INFO drvr_info = { REV_NUM, 0, MBG_DRVR_NAME " radio clock driver" };

#include <macioctl.h>

static dev_type_open(mbgclockopen);
static dev_type_close(mbgclockclose);
static dev_type_read(mbgclockread);
static dev_type_write(mbgclockwrite);
static dev_type_ioctl(mbgclockioctl);
static int	mbgclock_match(device_t, cfdata_t, void *);
static void	mbgclock_attach(device_t, device_t, void *);
static int	mbgclock_detach(device_t, int);

struct mbgclock_softc 
{
	device_t               dev;	/* device backling */
	struct pci_attach_args pa;	/* attach argument */
	PCPS_DDEV             *pddev;	/* driver handle */
};

#define MBG_UNITBITS    6	                /* up to 64 devices */
#define MBG_UNITMASK	((1<<MBG_UNITBITS)-1)
#define MBG_UNIT(x)     (minor(x) & MBG_UNITMASK)
#define MBG_UNITTYPE(x)	(minor(x) >> MBG_UNITBITS)

const struct cdevsw mbgclock_cdevsw = {
	.d_open     = mbgclockopen,
	.d_close    = mbgclockclose,
	.d_read     = mbgclockread,
	.d_write    = mbgclockwrite,
	.d_ioctl    = mbgclockioctl,
	.d_stop     = nostop,
	.d_tty      = notty,
	.d_poll     = nopoll,
	.d_mmap     = nommap,
	.d_kqfilter = nokqfilter,
	D_OTHER|D_MPSAFE
};

#ifdef CFATTACH_DECL3_NEW
CFATTACH_DECL3_NEW(mbgclock,
		   sizeof(struct mbgclock_softc),
		   mbgclock_match,
		   mbgclock_attach,
		   mbgclock_detach,
		   NULL,
		   NULL,
		   NULL,
		   DVF_DETACH_SHUTDOWN);
#else
CFATTACH_DECL2_NEW(mbgclock,
		   sizeof(struct mbgclock_softc),
		   mbgclock_match,
		   mbgclock_attach,
		   mbgclock_detach,
		   NULL,
		   NULL,
		   NULL);
#endif

extern struct cfdriver mbgclock_cd;

#if defined( MBG_DEBUG )
int debug = MBG_DEBUG;
#endif

#if defined( DEBUG )
static int mbgclockdebug = ~0;
#define DB_FOLLOW	0x00000001
#define DPRINTF(_X_, _Y_) do {			\
		if (mbgclockdebug & (_X_)) {	\
			printf _Y_;		\
		}				\
	}					\
	while (/*CONST_COND*/0)
#else
#define DPRINTF(_X_, _Y_) /* empty */
#endif

/*----- loadables -----*/
#if defined (_LKM) || defined(_MODULE)

CFDRIVER_DECL(mbgclock, DV_DULL, NULL);

static int mbgclock_loc[] = { -1, -1 };

static struct cfparent pciparent = {
	"pci", "pci", DVUNIT_ANY
};

static struct cfdata mbgclock_cfdata[] = {
	{
		.cf_name   = "mbgclock",
		.cf_atname = "mbgclock",
		.cf_unit   = 0,
		.cf_fstate = FSTATE_STAR,
		.cf_loc    = mbgclock_loc,
		.cf_flags  = 0,
		.cf_pspec  = &pciparent,
	},
	{ NULL }
};

#endif

/*----- module -----*/
#ifdef _MODULE

#include <sys/module.h>

MODULE(MODULE_CLASS_DRIVER, mbgclock, NULL);
static int
mbgclock_modcmd(modcmd_t cmd, void *arg)
{
	int bmajor = -1, cmajor = -1,  error = 0;
	
	switch (cmd) {
	case MODULE_CMD_INIT:
		DPRINTF(DB_FOLLOW, ("%s: MOD_CMD_INIT\n", mbgclock_cd.cd_name));

		error = config_cfdriver_attach(&mbgclock_cd);
		if (error)
			break;

		error = config_cfattach_attach(mbgclock_cd.cd_name, &mbgclock_ca);
	        if (error) {
			config_cfdriver_detach(&mbgclock_cd);
			aprint_error("%s: unable to register cfattach\n",
			    mbgclock_cd.cd_name);
			break;
		}

		/* s = splaudio(); */
		error = config_cfdata_attach(mbgclock_cfdata, 1);
		/* splx(s); */

		if (error == 0) 
		{
			error = devsw_attach("mbgclock", NULL, &bmajor,
					     &mbgclock_cdevsw, &cmajor);
		}
		
		if (error) {
			config_cfattach_detach(mbgclock_cd.cd_name, &mbgclock_ca);
			config_cfdriver_detach(&mbgclock_cd);
			break;
		} else {
			DPRINTF(DB_FOLLOW, ("%s: registered character major = %d\n",
					    mbgclock_cd.cd_name, cmajor));
		}
		
		break;

	case MODULE_CMD_FINI:
		DPRINTF(DB_FOLLOW, ("%s: MOD_CMD_FINI\n", mbgclock_cd.cd_name));
		error = config_cfattach_detach(mbgclock_cd.cd_name, &mbgclock_ca);
		if (error)
			break;
		config_cfdriver_detach(&mbgclock_cd);
		devsw_detach(NULL, &mbgclock_cdevsw);
		break;

	case MODULE_CMD_STAT:
		return ENOTTY;

	default:
		return ENOTTY;
	}

	DPRINTF(DB_FOLLOW, ("modcmd rc = %d\n", error));
	
	return error;
}
#endif

/*------ LKM -----*/
#if defined(_LKM) && !defined(_MODULE)

#include <sys/lkm.h>

int mbgclock_lkmentry(struct lkm_table *, int, int);

static struct cfdriver *mbgclock_cfdrivers[] = {
        &mbgclock_cd,
        NULL
};
static struct cfattach *mbgclock_cfattachs[] = {
        &mbgclock_ca,
        NULL
};
static const struct cfattachlkminit mbgclock_cfattachinit[] = {
        { "mbgclock", mbgclock_cfattachs },
        { NULL }
};

MOD_DRV("mbgclock",
        mbgclock_cfdrivers,
        mbgclock_cfattachinit,
        mbgclock_cfdata);

static int
mbgclock_lkmload(struct lkm_table *lkm, int cmd)
{
	int bmajor = -1;
	int cmajor = -1;
	int error;

	error = devsw_attach("mbgclock", NULL, &bmajor,
			&mbgclock_cdevsw, &cmajor);

#ifdef DEBUG
	if (error == 0) {
		DPRINTF(DB_FOLLOW, ("%s: registered character major = %d\n",
				    mbgclock_cd.cd_name, cmajor));
	} else {
		DPRINTF(DB_FOLLOW, ("%s: device driver registry failed errno = %d\n",
				    mbgclock_cd.cd_name, error));
	}
#endif
	return error;
}

static int
mbgclock_lkmunload(struct lkm_table *lkm, int cmd)
{
		devsw_detach(NULL, &mbgclock_cdevsw);
		return 0;
}

int
mbgclock_lkmentry(struct lkm_table *lkmtp, int cmd, int ver)
{
        DISPATCH(lkmtp, cmd, ver, mbgclock_lkmload, mbgclock_lkmunload, lkm_nofunc);
}
#endif

/*----- autoconf -----*/

/* PCI Support Functions */

static void
mbg_deallocate_resource( device_t device, BSD_RSRC_INFO *p_ri)
{
	if ( p_ri->valid )
	{
		bus_space_unmap( p_ri->bst, p_ri->bsh, p_ri->size);
		p_ri->valid = 0;
	}
}

/*
 * deallocate resources
 */
static void
mbg_dealloc_rsrcs( device_t device )
{
  struct mbgclock_softc *psc = device_private( device );
  PCPS_DDEV *pddev = psc->pddev;
  PCPS_RSRC_INFO *prsrci = &pddev->rsrc_info;
  int i;

/*  mbg_deallocate_resource( device, &prsrci->irq.bsd, SYS_RES_IRQ ); */

  for ( i = 0; i < N_PCPS_MEM_RSRC; i++ )
    mbg_deallocate_resource( device, &prsrci->mem[i].bsd);

  for ( i = 0; i < N_PCPS_PORT_RSRC; i++ )
    mbg_deallocate_resource( device, &prsrci->port[i].bsd);

}

static void
mbg_alloc_rsrc( device_t device, int reg, BSD_RSRC_INFO *p_ri, int type )
{
	struct mbgclock_softc *psc = device_private(device);

	p_ri->reg  = reg;
	p_ri->type = type;

	if (!pci_mapreg_map(&psc->pa, reg, type, 0,  //##++ BUS_SPACE_MAP_LINEAR ?
			    &p_ri->bst, &p_ri->bsh, &p_ri->base, &p_ri->size))
	{
		p_ri->valid = 1;
	} else {
		p_ri->valid = 0;
	}
	/* bus_space_vaddr() */
}

static void
mbg_alloc_rsrcs( device_t device )
{
  struct mbgclock_softc *psc = device_private( device );
  PCPS_DDEV *pddev           = psc->pddev;
  PCPS_RSRC_INFO *prsrci     = &pddev->rsrc_info;
  BSD_RSRC_INFO ri;
  int bar;

  for ( bar = 0; bar < 6; bar ++ )
  {
	  int type;
	  int reg = PCI_BAR( bar );

	  _mbgddmsg_4( MBG_DBG_INIT_DEV,
		       "%s: alloc I/O range %i: PCI device 0x%04X:0x%04X supported",
		       pcps_driver_name, bar, PCI_VENDOR(psc->pa.pa_id),
		       PCI_PRODUCT(psc->pa.pa_id) );

	  switch ((type = pci_mapreg_type(psc->pa.pa_pc, psc->pa.pa_tag, reg)))
	  {
	  case PCI_MAPREG_TYPE_IO:
		  if ( prsrci->num_rsrc_io < N_PCPS_PORT_RSRC )
		  {
			  mbg_alloc_rsrc( device, reg, &ri, type );

			  if ( ri.valid )
			  {
				  prsrci->port[prsrci->num_rsrc_io].bsd = ri;
#if 1  //##++
				  pcps_add_rsrc_io( pddev, ri.base, ri.size );
#else
				  pcps_add_rsrc_io( pddev,
						    (MBG_MEM_ADDR)bus_space_vaddr(ri.bst,
								    ri.bsh),
						    (ulong)ri.size );
#endif
				  continue;
			  }
			  else
			  {
				  _mbgddmsg_2( MBG_DBG_INIT_DEV,
					       "%s: alloc I/O range %i failed",
					       pcps_driver_name, bar );
			  }
		  }
		  break;

	  case PCI_MAPREG_MEM_TYPE_64BIT:
#if __LP64__
		  /* XXX */
		  aprint_error_dev(device,
				   "WARNING: ignoring 64-bit BAR @ 0x%02x\n", reg);
		  continue;
#else
		/*FALLTHROUGH*/
#endif
	  case PCI_MAPREG_TYPE_MEM:
		  /* case PCI_MAPREG_TYPE_ROM: currently same as above */
		  if ( prsrci->num_rsrc_mem < N_PCPS_MEM_RSRC )
		  {
			  mbg_alloc_rsrc( device, reg, &ri, type );

			  if ( ri.valid )
			  {
				  prsrci->mem[prsrci->num_rsrc_mem].bsd = ri;
				  pcps_add_rsrc_mem( pddev,
						     (MBG_MEM_ADDR)bus_space_vaddr( ri.bst, ri.bsh),
						     ri.size );
				  continue;
			  }
		  }
		  break;

	  default:
		  printf("XXX unsupported type from pci_mapreg_type: %d\n", type);
		  break;
	  }
  }

  /* single IRQ resource */
#if 0  /* currently not used / required */
  mbg_alloc_rsrc( device, 0, &ri, SYS_RES_IRQ, RF_SHAREABLE | RF_ACTIVE );

  if ( ri.res )
  {
    prsrci->port[prsrci->num_rsrc_irq].bsd = ri;
    pcps_add_rsrc_irq( pddev, rman_get_start( ri.res ) );
  }
#endif

} 

static int
mbgclock_match(struct device *parent, struct cfdata *match, void *aux)
{
	struct pci_attach_args *pa;
	int16_t vend_id;
	int16_t dev_id;

	DPRINTF(DB_FOLLOW, ("mbgclock_match(0x%p, 0x%p, 0x%p)\n", parent, match, aux));

	pa = aux;
	vend_id = PCI_VENDOR(pa->pa_id);
	dev_id = PCI_PRODUCT(pa->pa_id);

	if (vend_id == PCI_VENDOR_MEINBERG)
	{
		PCPS_DEV_TYPE *pdt;

		pdt = pcps_get_dev_type( PCPS_BUS_PCI, dev_id );

		if (pdt != NULL)
		{
			_mbgddmsg_3( MBG_DBG_INIT_DEV,
				     "%s: probe: PCI device 0x%04X:0x%04X supported",
				     pcps_driver_name, vend_id, dev_id );

			return 1;
		}
	}

	_mbgddmsg_3( MBG_DBG_INIT_DEV, "%s: probe: PCI device 0x%04X:0x%04X not supported",
		     pcps_driver_name, vend_id, dev_id );
	return 0;
}


static void
mbgclock_attach(struct device *parent, struct device *self, void *aux)
{
	int rc = 0;
	char devinfo[256];
	struct mbgclock_softc *psc = device_private(self);
	struct pci_attach_args *pa = aux;
	uint16_t dev_id = PCI_PRODUCT(pa->pa_id);

	DPRINTF(DB_FOLLOW, ("mbgclock_attach(0x%p, 0x%p, 0x%p)\n", parent, self, aux));

	psc->dev = self;
	psc->pa  = *pa;

	pci_devinfo(pa->pa_id, pa->pa_class, 0, devinfo, sizeof(devinfo));
	aprint_naive("\n");
	aprint_normal(": %s (rev. 0x%02x)\n", devinfo,
	    PCI_REVISION(pa->pa_class));

	_mbgddmsg_2( MBG_DBG_INIT_DEV, "%s: attach for device 0x%04X",
		     pcps_driver_name, dev_id );

	psc->pddev = pcps_alloc_ddev();

	if ( psc->pddev == NULL )
	{
		_mbgddmsg_2( MBG_DBG_INIT_DEV, "%s: attach device 0x%04X: pcps_alloc_ddev() failed",
			     pcps_driver_name, dev_id );
		goto fail;
	}

	rc = pcps_init_ddev( psc->pddev, PCPS_BUS_PCI, dev_id );

	if ( rc != PCPS_SUCCESS )
	{
		_mbgddmsg_3( MBG_DBG_INIT_DEV, "%s: attach device 0x%04X: pcps_init_ddev() failed, rc: %i",
			     pcps_driver_name, dev_id, rc );
		goto fail;
	}

	mbg_alloc_rsrcs( self );

	rc = pcps_start_device( psc->pddev, 0, 0 );

	if ( rc != PCPS_SUCCESS )
	{
		_mbgddmsg_3( MBG_DBG_INIT_DEV, "%s: attach device 0x%04X: pcps_start_device() failed, rc: %i",
			     pcps_driver_name, dev_id, rc );
		goto fail;
	}

	_mbgddmsg_2( MBG_DBG_INIT_DEV, "%s: device 0x%04X attached successfully",
		     pcps_driver_name, dev_id );

	if (!pmf_device_register(self, NULL, NULL))
		aprint_error_dev(self, "couldn't establish power handler\n");
	
	return;

fail:
	mbg_dealloc_rsrcs( self );
	
	if ( psc->pddev )
		pcps_free_ddev( psc->pddev );

	_mbgddmsg_2( MBG_DBG_INIT_DEV, "%s: failed to attach device 0x%04X",
		     pcps_driver_name, dev_id );
	return;
}

static int
mbgclock_detach(struct device *self, int flags)
{
  /* int error; */
	/*	struct vnd_softc *sc = device_private(self); */
	DPRINTF(DB_FOLLOW, ("mbgclock_detach(0x%p, 0x%x)\n", self, flags));

	pmf_device_deregister(self);

	return 0;
}

#if 0
static int
mbgclock_activate(struct device *self, enum devact act)
{
  /* struct mbgclock_softc *sc; */
	/* int error = 0; */
	DPRINTF(DB_FOLLOW, ("mbgclock_activate(0x%"PRIx64", %d)\n", dev, (int)act));
	
	return 0;
}
#endif

/*------- driver -------*/

static
int mbgclockopen(dev_t dev, int flags, int mode, struct lwp *l)
{
	struct mbgclock_softc *psc = device_lookup_private(&mbgclock_cd, MBG_UNIT(dev));

	_mbgddmsg_1( MBG_DBG_INIT_DEV, "%s: open called", pcps_driver_name );
	DPRINTF(DB_FOLLOW, ("mbgclockopen(0x%"PRIx64", 0x%x, 0x%x, %p)\n", dev, flags, mode, l));

	if (psc == NULL)
		return ENXIO;
	
	return 0;
}

static
int mbgclockclose(dev_t dev, int flags, int mode, struct lwp *l)
{
	struct mbgclock_softc *psc = device_lookup_private(&mbgclock_cd, MBG_UNIT(dev));

	_mbgddmsg_1( MBG_DBG_INIT_DEV, "%s: close called", pcps_driver_name );
	DPRINTF(DB_FOLLOW,("mbgclockclose(0x%"PRIx64", 0x%x, 0x%x, %p)\n", dev, flags, mode, l));

	if (psc == NULL)
		return ENXIO;

	return 0;
}

static
int mbgclockread(dev_t dev, struct uio *uio, int flags)
{
	struct mbgclock_softc *psc = device_lookup_private(&mbgclock_cd, MBG_UNIT(dev));

	_mbgddmsg_1( MBG_DBG_INIT_DEV, "%s: read called", pcps_driver_name );
	DPRINTF(DB_FOLLOW,("mbgclockread(0x%"PRIx64", %p)\n", dev, uio));

	if (psc == NULL)
		return ENXIO;

	return 0;
}

static
int mbgclockwrite(dev_t dev, struct uio *uio, int flags)
{
	struct mbgclock_softc *psc = device_lookup_private(&mbgclock_cd, MBG_UNIT(dev));

	_mbgddmsg_1( MBG_DBG_INIT_DEV, "%s: write called", pcps_driver_name );
	DPRINTF(DB_FOLLOW, ("mbgclockwrite(0x%"PRIx64", %p)\n", dev, uio));

	if (psc == NULL)
		return ENXIO;

	return 0;
}

#include <sys/ioctl.h>

static
int mbgclockioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
	struct mbgclock_softc *psc = device_lookup_private(&mbgclock_cd, MBG_UNIT(dev));
	PCPS_DDEV           *pddev;
	int rc;

	_mbgddmsg_1( MBG_DBG_INIT_DEV, "%s: ioctl called", pcps_driver_name );
	DPRINTF(DB_FOLLOW, ("mbgclockioctl(0x%"PRIx64", 0x%lx, %p, 0x%x, %p)\n",
			    dev, cmd, data, flag, l->l_proc));

	if (psc == NULL)
		return ENXIO;

	pddev = psc->pddev;

	rc = ioctl_switch( pddev, cmd, (void *) data, (void *) data );

	/* On success we return quickly.*/

	if ( rc == MBG_SUCCESS )
	{
		_mbgddmsg_6( MBG_DBG_INFO, "%s: %d,%d IOCTL 0x%02lX: success, dev %p_%s",
			     pcps_driver_name, major(dev), minor(dev), cmd, _pcps_ddev_type_name( pddev ), _pcps_ddev_sernum( pddev ) );
		rc = 0;
		goto out;
	}


	/* An error has occurred. */
	/* Generate an appropriate debug/error message */
	/* and return an error status. */

	switch ( rc )
	{
	case MBG_ERR_INV_DEV_REQUEST:
		_mbgddmsg_7( MBG_DBG_WARN, "%s: %d,%d ioctl 0x%04lX: invalid cmd %04lX, dev %s_%s",
			     pcps_driver_name, major(dev), minor(dev), cmd, IOCBASECMD( cmd ),
			     _pcps_ddev_type_name( pddev ), _pcps_ddev_sernum( pddev ) );
		rc = EINVAL;
		break;


	case MBG_ERR_NOT_SUPP_BY_DEV:
		_mbgddmsg_6( MBG_DBG_WARN, "%s: %d,%d ioctl 0x%02lX: not supported by dev %s_%s",
			     pcps_driver_name, major(dev), minor(dev), cmd, _pcps_ddev_type_name( pddev ), _pcps_ddev_sernum( pddev ) );
		rc = EIO; /* XXX ENODEV */
		break;


	case MBG_ERR_NO_MEM:
		_mbgddmsg_6( MBG_DBG_WARN, "%s: %d,%d ioctl 0x%02lX: unable to allocate buffer for dev %s_%s",
			     pcps_driver_name, major(dev), minor(dev), cmd, _pcps_ddev_type_name( pddev ), _pcps_ddev_sernum( pddev ) );
		rc = EFAULT; /* XXX ENOMEM */
		break;


	case MBG_ERR_IRQ_UNSAFE:
		_mbgddmsg_6( MBG_DBG_DETAIL, "%s: %d,%d ioctl 0x%02lX: busy since unsafe IRQ enabled, dev %s_%s",
			     pcps_driver_name, major(dev), minor(dev), cmd, _pcps_ddev_type_name( pddev ), _pcps_ddev_sernum( pddev ) );
		rc = EBUSY;
		break;


	default:  /* any access error code returned by the low level routine */
		/* or copying from or to user space */
		_mbgddmsg_7( MBG_DBG_WARN, "%s: %d,%d ioctl 0x%02lX: error %i accessing dev %s_%s",
			     pcps_driver_name, major(dev), minor(dev), cmd, rc, _pcps_ddev_type_name( pddev ), _pcps_ddev_sernum( pddev ) );
		rc = EFAULT; /* XXX EFAULT is inappropriate */

	}


out:
	return rc;
}