irlap.c

sparc硬件平台上的红外协议

}

/*
* Function irlap_validate_ns_received (ns)
*
*    Validate the next to send (ns) field from received frame.
*/
int irlap_validate_ns_received(struct irlap_cb *self, int ns)
{
	/*  ns as expected?  */
	if (ns == self->vr)
		return NS_EXPECTED;
		/*
		*  Stations are allowed to treat invalid NS as unexpected NS
		*  IrLAP, Recv ... with-invalid-Ns. p. 84
	*/
	return NS_UNEXPECTED;
	
	/* return NR_INVALID; */
}
/*
* Function irlap_validate_nr_received (nr)
*
*    Validate the next to receive (nr) field from received frame.
*
*/
int irlap_validate_nr_received(struct irlap_cb *self, int nr)
{
	/*  nr as expected?  */
	if (nr == self->vs) {
		IRDA_DEBUG(1, "%s(), expected!\n", __FUNCTION__);
		return NR_EXPECTED;
	}
	
	/*
	*  unexpected nr? (but within current window), first we check if the
	*  ns numbers of the frames in the current window wrap.
	*/
	if (self->va < self->vs) {
		if ((nr >= self->va) && (nr <= self->vs))
		{
			IRDA_DEBUG(4, "%s(), NR_UNEXPECTED!\n", __FUNCTION__);
			return NR_UNEXPECTED;
		}
	} else {
		if ((nr >= self->va) || (nr <= self->vs))
		{
			IRDA_DEBUG(4, "%s(), NR_UNEXPECTED!\n", __FUNCTION__);
			return NR_UNEXPECTED;
		}
	}
	IRDA_DEBUG(4, "%s(), NR_UNEXPECTED!\n", __FUNCTION__);
	/* Invalid nr!  */
	return NR_INVALID;
}

/*
* Function irlap_initiate_connection_state ()
*
*    Initialize the connection state parameters
*
*/
void irlap_initiate_connection_state(struct irlap_cb *self)
{
	IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
	
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
	
	/* Next to send and next to receive */
	self->vs = self->vr = 0;
	
	/* Last frame which got acked (0 - 1) % 8 */
	self->va = 7;
	
	self->window = 1;
	
	self->remote_busy = FALSE;
	self->retry_count = 0;
}

/*
* Function irlap_wait_min_turn_around (self, qos)
*
*    Wait negotiated minimum turn around time, this function actually sets
*    the number of BOS's that must be sent before the next transmitted
*    frame in order to delay for the specified amount of time. This is
*    done to avoid using timers, and the forbidden udelay!
*/
void irlap_wait_min_turn_around(struct irlap_cb *self, struct qos_info *qos)
{
	__u32 min_turn_time;
	__u32 speed;
	
	/* Get QoS values.  */
	speed = qos->baud_rate.value;
	min_turn_time = qos->min_turn_time.value;
	
	/* No need to calculate XBOFs for speeds over 115200 bps */
	if (speed > 115200) {
		self->mtt_required = min_turn_time;
		return;
	}
	
	/*
	*  Send additional BOF's for the next frame for the requested
	*  min turn time, so now we must calculate how many chars (XBOF's) we
	*  must send for the requested time period (min turn time)
	*/
	self->xbofs_delay = irlap_min_turn_time_in_bytes(speed, min_turn_time);
}

/*
* Function irlap_flush_all_queues (void)
*
*    Flush all queues
*
*/
void irlap_flush_all_queues(struct irlap_cb *self)
{
	struct sk_buff* skb;
	
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
	
	/* Free transmission queue */
	while ((skb = skb_dequeue(&self->txq)) != NULL)
		dev_kfree_skb(skb);
	
	while ((skb = skb_dequeue(&self->txq_ultra)) != NULL)
		dev_kfree_skb(skb);
	
	/* Free sliding window buffered packets */
	while ((skb = skb_dequeue(&self->wx_list)) != NULL)
		dev_kfree_skb(skb);
}

/*
* Function irlap_setspeed (self, speed)
*
*    Change the speed of the IrDA port
*
*/
static void irlap_change_speed(struct irlap_cb *self, __u32 speed, int now)
{
	struct sk_buff *skb;
	
	IRDA_DEBUG(0, "%s(), setting speed to %d\n", __FUNCTION__, speed);
	
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
	
	self->speed = speed;
	
	/* Change speed now, or just piggyback speed on frames */
	//modify by xugangan
	if (now) {
		/* Send down empty frame to trigger speed change */
		skb = skb_alloc(0);
		if (skb)
			irlap_queue_xmit(self, skb);
	}
}

/*
* Function irlap_init_qos_capabilities (self, qos)
*
*    Initialize QoS for this IrLAP session, What we do is to compute the
*    intersection of the QoS capabilities for the user, driver and for
*    IrLAP itself. Normally, IrLAP will not specify any values, but it can
*    be used to restrict certain values.
*/
static void irlap_init_qos_capabilities(struct irlap_cb *self,
										struct qos_info *qos_user)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
	IRDA_ASSERT(self->netdev != NULL, return;);
	
	/* Start out with the maximum QoS support possible */
	irda_init_max_qos_capabilies(&self->qos_rx);
	
	/* Apply drivers QoS capabilities */
	irda_qos_compute_intersection(&self->qos_rx, self->qos_dev);
	
	/*
	*  Check for user supplied QoS parameters. The service user is only
	*  allowed to supply these values. We check each parameter since the
	*  user may not have set all of them.
	*/
	if (qos_user) {
		IRDA_DEBUG(1, "%s(), Found user specified QoS!\n", __FUNCTION__);
		
		if (qos_user->baud_rate.bits)
			self->qos_rx.baud_rate.bits &= qos_user->baud_rate.bits;
		
		if (qos_user->max_turn_time.bits)
			self->qos_rx.max_turn_time.bits &= qos_user->max_turn_time.bits;
		if (qos_user->data_size.bits)
			self->qos_rx.data_size.bits &= qos_user->data_size.bits;
		
		if (qos_user->link_disc_time.bits)
			self->qos_rx.link_disc_time.bits &= qos_user->link_disc_time.bits;
	}
	
	/* Use 500ms in IrLAP for now */
	self->qos_rx.max_turn_time.bits &= 0x01;
	
	/* Set data size */
	/*self->qos_rx.data_size.bits &= 0x03;*/
	
	irda_qos_bits_to_value(&self->qos_rx);
}

/*
* Function irlap_apply_default_connection_parameters (void, now)
*
*    Use the default connection and transmission parameters
*/
void irlap_apply_default_connection_parameters(struct irlap_cb *self)
{
	IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
	
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
	
	/* xbofs : Default value in NDM */
	self->next_bofs   = 12;
	self->bofs_count  = 12;
	
	/* NDM Speed is 9600 */
	
	
	irlap_change_speed(self, 9600, TRUE);
	
	
	/* Set mbusy when going to NDM state */
	irda_device_set_media_busy(self->netdev, FALSE);
	
	
	/*
	* Generate random connection address for this session, which must
	* be 7 bits wide and different from 0x00 and 0xfe
	*/
	while ((self->caddr == 0x00) || (self->caddr == 0xfe)) {
		get_random_bytes(&self->caddr, sizeof(self->caddr));
		self->caddr &= 0xfe;
	}
	/* Use default values until connection has been negitiated */
	self->slot_timeout = sysctl_slot_timeout;
	self->final_timeout = FINAL_TIMEOUT;
	self->poll_timeout = POLL_TIMEOUT;
	self->wd_timeout = WD_TIMEOUT;
	
	/* Set some default values */
	self->qos_tx.baud_rate.value = 9600;
	self->qos_rx.baud_rate.value = 9600;
	self->qos_tx.max_turn_time.value = 0;
	self->qos_rx.max_turn_time.value = 0;
	self->qos_tx.min_turn_time.value = 0;
	self->qos_rx.min_turn_time.value = 0;
	self->qos_tx.data_size.value = 64;
	self->qos_rx.data_size.value = 64;
	self->qos_tx.window_size.value = 1;
	self->qos_rx.window_size.value = 1;
	self->qos_tx.additional_bofs.value = 12;
	self->qos_rx.additional_bofs.value = 12;
	self->qos_tx.link_disc_time.value = 0;
	self->qos_rx.link_disc_time.value = 0;
	
	irlap_flush_all_queues(self);
	
	self->disconnect_pending = FALSE;
	self->connect_pending = FALSE;
	
}

/*
* Function irlap_apply_connection_parameters (qos, now)
*
*    Initialize IrLAP with the negotiated QoS values
*
* If 'now' is false, the speed and xbofs will be changed after the next
* frame is sent.
* If 'now' is true, the speed and xbofs is changed immediately
*/
void irlap_apply_connection_parameters(struct irlap_cb *self, int now)
{
	IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
	
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
	
	/* Set the negotiated xbofs value */
	self->next_bofs   = self->qos_tx.additional_bofs.value;
	if (now)
		self->bofs_count = self->next_bofs;
	
	/* Set the negotiated link speed (may need the new xbofs value) */
	irlap_change_speed(self, self->qos_tx.baud_rate.value, now);
	
	self->window_size = self->qos_tx.window_size.value;
	self->window      = self->qos_tx.window_size.value;
	
#ifdef CONFIG_IRDA_DYNAMIC_WINDOW
	/*
	*  Calculate how many bytes it is possible to transmit before the
	*  link must be turned around
	*/
	self->line_capacity =
		irlap_max_line_capacity(self->qos_tx.baud_rate.value,
		self->qos_tx.max_turn_time.value);
	self->bytes_left = self->line_capacity;
#endif /* CONFIG_IRDA_DYNAMIC_WINDOW */
	
	
	/*
	*  Initialize timeout values, some of the rules are listed on
	*  page 92 in IrLAP.
	*/
	IRDA_ASSERT(self->qos_tx.max_turn_time.value != 0, return;);
	IRDA_ASSERT(self->qos_rx.max_turn_time.value != 0, return;);
	/* The poll timeout applies only to the primary station.
	* It defines the maximum time the primary stay in XMIT mode
	* before timeout and turning the link around (sending a RR).
	* Or, this is how much we can keep the pf bit in primary mode.
	* Therefore, it must be lower or equal than our *OWN* max turn around.
	* Jean II */
	self->poll_timeout = self->qos_tx.max_turn_time.value * HZ / 1000;
	/* The Final timeout applies only to the primary station.
	* It defines the maximum time the primary wait (mostly in RECV mode)
	* for an answer from the secondary station before polling it again.
	* Therefore, it must be greater or equal than our *PARTNER*
	* max turn around time - Jean II */
	self->final_timeout = self->qos_rx.max_turn_time.value * HZ / 1000;
	/* The Watchdog Bit timeout applies only to the secondary station.
	* It defines the maximum time the secondary wait (mostly in RECV mode)
	* for poll from the primary station before getting annoyed.
	* Therefore, it must be greater or equal than our *PARTNER*
	* max turn around time - Jean II */
	self->wd_timeout = self->final_timeout * 2;
#ifndef EMMI_SPARC
#ifdef TEST_IRDA
	self->poll_timeout = self->qos_tx.max_turn_time.value * HZ / 1000 + 500;
	self->final_timeout = self->qos_rx.max_turn_time.value * HZ / 1000 + 500;
	self->wd_timeout = self->final_timeout * 20;
#endif
#endif
	/*
	* N1 and N2 are maximum retry count for *both* the final timer
	* and the wd timer (with a factor 2) as defined above.
	* After N1 retry of a timer, we give a warning to the user.
	* After N2 retry, we consider the link dead and disconnect it.
	* Jean II
	*/
	
	/*
	*  Set N1 to 0 if Link Disconnect/Threshold Time = 3 and set it to
	*  3 seconds otherwise. See page 71 in IrLAP for more details.
	*  Actually, it's not always 3 seconds, as we allow to set
	*  it via sysctl... Max maxtt is 500ms, and N1 need to be multiple
	*  of 2, so 1 second is minimum we can allow. - Jean II
	*/
	if (self->qos_tx.link_disc_time.value == sysctl_warn_noreply_time)
	/*
	* If we set N1 to 0, it will trigger immediately, which is
	* not what we want. What we really want is to disable it,
	* Jean II
	*/
	self->N1 = -2; /* Disable - Need to be multiple of 2*/
	else
		self->N1 = sysctl_warn_noreply_time * 1000 /
		self->qos_rx.max_turn_time.value;
	
	IRDA_DEBUG(1, "Setting N1 = %d\n", self->N1);
	
	/* Set N2 to match our own disconnect time */
	self->N2 = self->qos_tx.link_disc_time.value * 1000 /
		self->qos_rx.max_turn_time.value;
	IRDA_DEBUG(1, "Setting N2 = %d\n", self->N2);
}