irlap.c

《嵌入式系统设计与实例开发实验教材二源码》Linux内核移植与编译实验

 *    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;

	ASSERT(self != NULL, return;);
	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
 *
 */
void irlap_change_speed(struct irlap_cb *self, __u32 speed, int now)
{
	struct sk_buff *skb;

	IRDA_DEBUG(0, __FUNCTION__ "(), setting speed to %d\n", speed);

	ASSERT(self != NULL, return;);
	ASSERT(self->magic == LAP_MAGIC, return;);

	self->speed = speed;

	/* Change speed now, or just piggyback speed on frames */
	if (now) {
		/* Send down empty frame to trigger speed change */
		skb = dev_alloc_skb(0);
		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.
 */
void irlap_init_qos_capabilities(struct irlap_cb *self,
				 struct qos_info *qos_user)
{
	ASSERT(self != NULL, return;);
	ASSERT(self->magic == LAP_MAGIC, return;);
	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, __FUNCTION__ "(), Found user specified QoS!\n");

		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(4, __FUNCTION__ "()\n");

	ASSERT(self != NULL, return;);
	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, TRUE);

	/* 
	 * 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(4, __FUNCTION__ "()\n");
	
	ASSERT(self != NULL, return;);
	ASSERT(self->magic == LAP_MAGIC, return;);

	/* Set the negociated xbofs value */
	self->next_bofs   = self->qos_tx.additional_bofs.value;
	if (now)
		self->bofs_count = self->next_bofs;

	/* Set the negociated 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;

	/*
	 *  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);

	
	/* 
	 *  Initialize timeout values, some of the rules are listed on 
	 *  page 92 in IrLAP.
	 */
	ASSERT(self->qos_tx.max_turn_time.value != 0, return;);
	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;

	/*
	 * 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(4, "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(4, "Setting N2 = %d\n", self->N2);
}

/*
 * Function irlap_set_local_busy (self, status)
 *
 *    
 *
 */
void irlap_set_local_busy(struct irlap_cb *self, int status)
{
	IRDA_DEBUG(0, __FUNCTION__ "()\n");

	self->local_busy = status;
	
	if (status)
		IRDA_DEBUG(0, __FUNCTION__ "(), local busy ON\n");
	else
		IRDA_DEBUG(0, __FUNCTION__ "(), local busy OFF\n");
}

#ifdef CONFIG_PROC_FS
/*
 * Function irlap_proc_read (buf, start, offset, len, unused)
 *
 *    Give some info to the /proc file system
 *
 */
int irlap_proc_read(char *buf, char **start, off_t offset, int len)
{
	struct irlap_cb *self;
	unsigned long flags;
	int i = 0;
     
	save_flags(flags);
	cli();

	len = 0;

	self = (struct irlap_cb *) hashbin_get_first(irlap);
	while (self != NULL) {
		ASSERT(self != NULL, return -ENODEV;);
		ASSERT(self->magic == LAP_MAGIC, return -EBADR;);

		len += sprintf(buf+len, "irlap%d ", i++);
		len += sprintf(buf+len, "state: %s\n", 
			       irlap_state[self->state]);
		
		len += sprintf(buf+len, "  device name: %s, ",
			       (self->netdev) ? self->netdev->name : "bug");
		len += sprintf(buf+len, "hardware name: %s\n", self->hw_name);

		len += sprintf(buf+len, "  caddr: %#02x, ", self->caddr);
		len += sprintf(buf+len, "saddr: %#08x, ", self->saddr);
		len += sprintf(buf+len, "daddr: %#08x\n", self->daddr);
		
		len += sprintf(buf+len, "  win size: %d, ", 
			       self->window_size);
		len += sprintf(buf+len, "win: %d, ", self->window);
#if CONFIG_IRDA_DYNAMIC_WINDOW
		len += sprintf(buf+len, "line capacity: %d, ", 
			       self->line_capacity);
		len += sprintf(buf+len, "bytes left: %d\n", self->bytes_left);
#endif /* CONFIG_IRDA_DYNAMIC_WINDOW */
		len += sprintf(buf+len, "  tx queue len: %d ", 
			       skb_queue_len(&self->txq));
		len += sprintf(buf+len, "win queue len: %d ", 
			       skb_queue_len(&self->wx_list));
		len += sprintf(buf+len, "rbusy: %s", self->remote_busy ?
			       "TRUE" : "FALSE");
		len += sprintf(buf+len, " mbusy: %s\n", self->media_busy ?
			       "TRUE" : "FALSE");
		
		len += sprintf(buf+len, "  retrans: %d ", self->retry_count);
		len += sprintf(buf+len, "vs: %d ", self->vs);
		len += sprintf(buf+len, "vr: %d ", self->vr);
		len += sprintf(buf+len, "va: %d\n", self->va);
		
		len += sprintf(buf+len, "  qos\tbps\tmaxtt\tdsize\twinsize\taddbofs\tmintt\tldisc\tcomp\n");
		
		len += sprintf(buf+len, "  tx\t%d\t", 
			       self->qos_tx.baud_rate.value);
		len += sprintf(buf+len, "%d\t", 
			       self->qos_tx.max_turn_time.value);
		len += sprintf(buf+len, "%d\t",
			       self->qos_tx.data_size.value);
		len += sprintf(buf+len, "%d\t",
			       self->qos_tx.window_size.value);
		len += sprintf(buf+len, "%d\t",
			       self->qos_tx.additional_bofs.value);
		len += sprintf(buf+len, "%d\t", 
			       self->qos_tx.min_turn_time.value);
		len += sprintf(buf+len, "%d\t", 
			       self->qos_tx.link_disc_time.value);
		len += sprintf(buf+len, "\n");

		len += sprintf(buf+len, "  rx\t%d\t", 
			       self->qos_rx.baud_rate.value);
		len += sprintf(buf+len, "%d\t", 
			       self->qos_rx.max_turn_time.value);
		len += sprintf(buf+len, "%d\t",
			       self->qos_rx.data_size.value);
		len += sprintf(buf+len, "%d\t",
			       self->qos_rx.window_size.value);
		len += sprintf(buf+len, "%d\t",
			       self->qos_rx.additional_bofs.value);
		len += sprintf(buf+len, "%d\t", 
			       self->qos_rx.min_turn_time.value);
		len += sprintf(buf+len, "%d\t", 
			       self->qos_rx.link_disc_time.value);
		len += sprintf(buf+len, "\n");
		
		self = (struct irlap_cb *) hashbin_get_next(irlap);
	}
	restore_flags(flags);

	return len;
}

#endif /* CONFIG_PROC_FS */