sdl.c

OpenSS7 This the fourth public release of the OpenSS7 Master Package. See README in the release for

		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
lmi_iocsconfig(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		psw_t flags;
		lmi_config_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		spin_lock_irqsave(&s->lock, flags);
		{
			s->i_version = arg->version;
			s->i_style = arg->style;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
lmi_ioctconfig(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		lmi_config_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		return lmi_test_config(s, arg);
	}
	rare();
	return (-EINVAL);
}
STATIC int
lmi_ioccconfig(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		lmi_config_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		return lmi_commit_config(s, arg);
	}
	rare();
	return (-EINVAL);
}
STATIC int
lmi_iocgstatem(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		psw_t flags;
		lmi_statem_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		spin_lock_irqsave(&s->lock, flags);
		{
			arg->state = s->i_state;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
lmi_ioccmreset(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		lmi_statem_t *arg = (typeof(arg)) mp->b_cont->b_rptr;
		int ret = 0;
		psw_t flags;

		spin_lock_irqsave(&s->lock, flags);
		{
			s->i_state = LMI_UNUSABLE;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (ret);
	}
	rare();
	return (-EINVAL);
}
STATIC int
lmi_iocgstatsp(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		lmi_sta_t *arg = (typeof(arg)) mp->b_cont->b_rptr;
		int ret = 0;
		psw_t flags;

		spin_lock_irqsave(&s->lock, flags);
		{
			*arg = s->statsp;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (ret);
	}
	rare();
	return (-EINVAL);
}
STATIC int
lmi_iocsstatsp(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		lmi_sta_t *arg = (typeof(arg)) mp->b_cont->b_rptr;
		int ret = 0;
		psw_t flags;

		spin_lock_irqsave(&s->lock, flags);
		{
			s->statsp = *arg;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (ret);
	}
	rare();
	return (-EINVAL);
}
STATIC int
lmi_iocgstats(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		lmi_stats_t *arg = (typeof(arg)) mp->b_cont->b_rptr;
		int ret;
		psw_t flags;

		spin_lock_irqsave(&s->lock, flags);
		{
			ret = -EOPNOTSUPP;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (ret);
	}
	rare();
	return (-EINVAL);
}
STATIC int
lmi_ioccstats(queue_t *q, mblk_t *mp)
{
	struct sdl *s = SDL_PRIV(q);
	int ret;
	psw_t flags;

	(void) mp;
	spin_lock_irqsave(&s->lock, flags);
	{
		ret = -EOPNOTSUPP;
	}
	spin_unlock_irqrestore(&s->lock, flags);
	return (ret);
}
STATIC int
lmi_iocgnotify(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		lmi_notify_t *arg = (typeof(arg)) mp->b_cont->b_rptr;
		int ret;
		psw_t flags;

		spin_lock_irqsave(&s->lock, flags);
		{
			ret = -EOPNOTSUPP;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (ret);
	}
	rare();
	return (-EINVAL);
}
STATIC int
lmi_iocsnotify(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		lmi_notify_t *arg = (typeof(arg)) mp->b_cont->b_rptr;
		int ret;
		psw_t flags;

		spin_lock_irqsave(&s->lock, flags);
		{
			ret = -EOPNOTSUPP;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (ret);
	}
	rare();
	return (-EINVAL);
}
STATIC int
lmi_ioccnotify(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		lmi_notify_t *arg = (typeof(arg)) mp->b_cont->b_rptr;
		int ret;
		psw_t flags;

		spin_lock_irqsave(&s->lock, flags);
		{
			ret = -EOPNOTSUPP;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (ret);
	}
	rare();
	return (-EINVAL);
}

/*
 *  -------------------------------------------------------------------------
 *
 *  SDL IO Controls
 *
 *  -------------------------------------------------------------------------
 */
STATIC int
sdl_test_config(struct sdl *s, sdl_config_t * arg)
{
	(void) s;
	(void) arg;
	// fixme(("%s: FIXME: write this function\n", MOD_NAME));
	return (0);
}
STATIC void
sdl_commit_config(struct sdl *s, sdl_config_t * arg)
{
	s->config = *arg;
	/* 
	   reshape traffic */
	if (s->timestamp > jiffies) {
		sdl_timer_stop(s, t9);
		s->bytecount += s->tickbytes * (s->timestamp - jiffies);
	}
	if (s->timestamp < jiffies) {
		s->bytecount = 0;
		s->stats.tx_underruns++;
	}
	s->timestamp = jiffies;
	s->tickbytes = s->config.ifrate / HZ / 8;
	ensure(s->tickbytes > 0, s->tickbytes = 1);
	while (s->bytecount >= s->tickbytes) {
		s->bytecount -= s->tickbytes;
		s->timestamp++;
	}
	if (s->timestamp > jiffies) {
		printd(("%s: %p: %s sleeping for %ld ms\n", MOD_NAME, s, __FUNCTION__,
			s->timestamp - jiffies));
		sdl_timer_start(s, t9);
	}
}
STATIC int
sdl_iocgoptions(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		psw_t flags;
		lmi_option_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		spin_lock_irqsave(&s->lock, flags);
		{
			*arg = s->option;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
sdl_iocsoptions(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		psw_t flags;
		lmi_option_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		spin_lock_irqsave(&s->lock, flags);
		{
			s->option = *arg;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
sdl_iocgconfig(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		psw_t flags;
		sdl_config_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		spin_lock_irqsave(&s->lock, flags);
		{
			*arg = s->config;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
sdl_iocsconfig(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		int ret;
		psw_t flags;
		sdl_config_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		spin_lock_irqsave(&s->lock, flags);
		{
			if (!(ret = sdl_test_config(s, arg)))
				sdl_commit_config(s, arg);
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (ret);
	}
	rare();
	return (-EINVAL);
}
STATIC int
sdl_ioctconfig(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		sdl_config_t *arg = (typeof(arg)) mp->b_cont->b_rptr;
		int ret;
		psw_t flags;

		spin_lock_irqsave(&s->lock, flags);
		{
			ret = sdl_test_config(s, arg);
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (ret);
	}
	rare();
	return (-EINVAL);
}
STATIC int
sdl_ioccconfig(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		sdl_config_t *arg = (typeof(arg)) mp->b_cont->b_rptr;
		psw_t flags;

		spin_lock_irqsave(&s->lock, flags);
		{
			sdl_commit_config(s, arg);
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
sdl_iocgstatem(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		psw_t flags;
		sdl_statem_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		spin_lock_irqsave(&s->lock, flags);
		{
			*arg = s->statem;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
sdl_ioccmreset(queue_t *q, mblk_t *mp)
{
	struct sdl *s = SDL_PRIV(q);

	(void) s;
	(void) mp;
	// fixme(("%s: FIXME: Support master reset\n", MOD_NAME));
	return (-EOPNOTSUPP);
}
STATIC int
sdl_iocgstatsp(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		psw_t flags;
		lmi_sta_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		spin_lock_irqsave(&s->lock, flags);
		{
			*arg = s->statsp;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
sdl_iocsstatsp(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		psw_t flags;
		lmi_sta_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		spin_lock_irqsave(&s->lock, flags);
		{
			s->statsp = *arg;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
sdl_iocgstats(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		psw_t flags;
		sdl_stats_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		spin_lock_irqsave(&s->lock, flags);
		{
			*arg = s->stats;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
sdl_ioccstats(queue_t *q, mblk_t *mp)
{
	psw_t flags;
	struct sdl *s = SDL_PRIV(q);

	(void) mp;
	spin_lock_irqsave(&s->lock, flags);
	{
		bzero(&s->stats, sizeof(s->stats));
	}
	spin_unlock_irqrestore(&s->lock, flags);
	return (0);
}
STATIC int
sdl_iocgnotify(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		psw_t flags;
		sdl_notify_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		spin_lock_irqsave(&s->lock, flags);
		{
			*arg = s->notify;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
sdl_iocsnotify(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		psw_t flags;
		sdl_notify_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		spin_lock_irqsave(&s->lock, flags);
		{
			s->notify = *arg;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
sdl_ioccnotify(queue_t *q, mblk_t *mp)
{
	if (mp->b_cont) {
		struct sdl *s = SDL_PRIV(q);
		psw_t flags;
		sdl_notify_t *arg = (typeof(arg)) mp->b_cont->b_rptr;

		spin_lock_irqsave(&s->lock, flags);
		{
			s->notify.events &= ~arg->events;
		}
		spin_unlock_irqrestore(&s->lock, flags);
		return (0);
	}
	rare();
	return (-EINVAL);
}
STATIC int
sdl_ioccdisctx(queue_t *q, mblk_t *mp)
{
	struct sdl *s = SDL_PRIV(q);
	psw_t flags;

	spin_lock_irqsave(&s->lock, flags);
	{
		s->config.ifflags &= ~SDL_IF_TX_RUNNING;
		s->statem.tx_state = SDL_STATE_IDLE;
	}
	spin_unlock_irqrestore(&s->lock, flags);
	return (0);
}
STATIC int
sdl_ioccconntx(queue_t *q, mblk_t *mp)
{
	struct sdl *s = SDL_PRIV(q);
	psw_t flags;

	spin_lock_irqsave(&s->lock, flags);
	{
		s->config.ifflags |= SDL_IF_TX_RUNNING;
		s->statem.tx_state = SDL_STATE_IN_SERVICE;
	}
	spin_unlock_irqrestore(&s->lock, flags);
	return (0);
}

/*
 *  ========================================================================
 *
 *  STREAMS Message Handling
 *
 *  ========================================================================
 *
 *  M_IOCTL Handling
 *  -----------------------------------------------------------------------
 */
STATIC int
sdl_w_ioctl(queue_t *q, mblk_t *mp)
{
	struct sdl *s = SDL_PRIV(q);
	struct iocblk *iocp = (struct iocblk *) mp->b_rptr;
	void *arg = mp->b_cont ? mp->b_cont->b_rptr : NULL;
	int cmd = iocp->ioc_cmd, count = iocp->ioc_count;
	int type = _IOC_TYPE(cmd), nr = _IOC_NR(cmd), size = _IOC_SIZE(cmd);
	struct linkblk *lp = (struct linkblk *) arg;
	int ret = 0;

	switch (type) {
	case __SID:
	{
		switch (nr) {
		case _IOC_NR(I_STR):
		case _IOC_NR(I_LINK):
		case _IOC_NR(I_PLINK):
		case _IOC_NR(I_UNLINK):
		case _IOC_NR(I_PUNLINK):
			(void) lp;
			ptrace(("%s: %p: ERROR: Unsupported STREAMS ioctl %d\n", MOD_NAME, s, nr));
			ret = (-EINVAL);
			break;
		default:
			ptrace(("%s: %p: ERROR: Unsupported STREAMS ioctl %d\n", MOD_NAME, s, nr));
			ret = (-EOPNOTSUPP);