irlap.c

Linux内核源代码 为压缩文件 是<<Linux内核>>一书中的源代码

}

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

#ifdef CONFIG_IRDA_RECYCLE_RR
	if (self->recycle_rr_skb) { 
 		dev_kfree_skb(self->recycle_rr_skb);
 		self->recycle_rr_skb = NULL;
 	}
#endif
}

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

#ifdef CONFIG_IRDA_COMPRESSION
void irlap_init_comp_qos_capabilities(struct irlap_cb *self)
{
	struct irda_compressor *comp;
	__u8 mask; /* Current bit tested */
	int i;

	ASSERT(self != NULL, return;);
	ASSERT(self->magic == LAP_MAGIC, return;);
	
	/* 
	 *  Find out which compressors we support. We do this be checking that
	 *  the corresponding compressor for each bit set in the QoS bits has 
	 *  actually been loaded. Ths is sort of hairy code but that is what 
	 *  you get when you do a little bit flicking :-)
	 */
	IRDA_DEBUG(4, __FUNCTION__ "(), comp bits 0x%02x\n", 
		   self->qos_rx.compression.bits); 
	mask = 0x80; /* Start with testing MSB */
	for (i=0;i<8;i++) {
		IRDA_DEBUG(4, __FUNCTION__ "(), testing bit %d\n", 8-i);
		if (self->qos_rx.compression.bits & mask) {
			IRDA_DEBUG(4, __FUNCTION__ 
				   "(), bit %d is set by defalt\n", 8-i);
			comp = hashbin_find(irlap_compressors, 
					    compressions[msb_index(mask)], 
					    NULL);
			if (!comp) {
				/* Protocol not supported, so clear the bit */
				IRDA_DEBUG(4, __FUNCTION__ "(), Compression "
					   "protocol %d has not been loaded!\n", 
					   compressions[msb_index(mask)]);
				self->qos_rx.compression.bits &= ~mask;
				IRDA_DEBUG(4, __FUNCTION__ 
					   "(), comp bits 0x%02x\n", 
					   self->qos_rx.compression.bits); 
			}
		}
		/* Try the next bit */
		mask >>= 1;
	}
}
#endif	

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

#ifdef CONFIG_IRDA_COMPRESSION
	irlap_init_comp_qos_capabilities(self);
#endif

	/* 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;
#ifdef CONFIG_IRDA_COMPRESSION
		self->qos_rx.compression.bits &= qos_user->compression.bits;
#endif
	}

	/* Use 500ms in IrLAP for now */
	self->qos_rx.max_turn_time.bits &= 0x01;

	/* Set data size */
	/*self->qos_rx.data_size.bits &= 0x03;*/

	/* Set disconnect time -> done properly in qos.c */
	/*self->qos_rx.link_disc_time.bits &= 0x07;*/

	irda_qos_bits_to_value(&self->qos_rx);
}

/*
 * Function irlap_apply_default_connection_parameters (void)
 *
 *    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;);

	irlap_change_speed(self, 9600, TRUE);

	/* Set mbusy when going to NDM state */
	irda_device_set_media_busy(self->netdev, TRUE);

	/* Default value in NDM */
	self->bofs_count = 12;

	/* 
	 * 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)
 *
 *    Initialize IrLAP with the negotiated QoS values
 *
 */
void irlap_apply_connection_parameters(struct irlap_cb *self) 
{
	IRDA_DEBUG(4, __FUNCTION__ "()\n");
	
	ASSERT(self != NULL, return;);
	ASSERT(self->magic == LAP_MAGIC, return;);

	irlap_change_speed(self, self->qos_tx.baud_rate.value, FALSE);

	self->window_size = self->qos_tx.window_size.value;
	self->window      = self->qos_tx.window_size.value;
	self->bofs_count  = self->qos_tx.additional_bofs.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);
	/*
	 *  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.
	 *  TODO: these values should be calculated from the final timer
         *  as well
	 */
	ASSERT(self->qos_tx.max_turn_time.value != 0, return;);
	if (self->qos_tx.link_disc_time.value == 3)
		/* 
		 * 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 = -1; /* Disable */
	else
		self->N1 = 3000 / self->qos_tx.max_turn_time.value;
	
	IRDA_DEBUG(4, "Setting N1 = %d\n", self->N1);
	
	
	self->N2 = self->qos_tx.link_disc_time.value * 1000 / 
		self->qos_tx.max_turn_time.value;
	IRDA_DEBUG(4, "Setting N2 = %d\n", self->N2);

	/* 
	 *  Initialize timeout values, some of the rules are listed on 
	 *  page 92 in IrLAP.
	 */
	self->poll_timeout = self->qos_tx.max_turn_time.value * HZ / 1000;
	self->wd_timeout = self->poll_timeout * 2;

	/* 
	 * Be careful to keep our promises to the peer device about how long
	 * time it can keep the pf bit. So here we must use the rx_qos value
	 */
	self->final_timeout = self->qos_rx.max_turn_time.value * HZ / 1000;

#ifdef CONFIG_IRDA_COMPRESSION
	if (self->qos_tx.compression.value) {
		IRDA_DEBUG(1, __FUNCTION__ "(), Initializing compression\n");
		irda_set_compression(self, self->qos_tx.compression.value);

		irlap_compressor_init(self, 0);
	}
#endif
}

/*
 * 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, "  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);
#ifdef CONFIG_IRDA_COMPRESSION
		len += sprintf(buf+len, "%d",
			       self->qos_tx.compression.value);
#endif
		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);
#ifdef CONFIG_IRDA_COMPRESSION
		len += sprintf(buf+len, "%d",
			       self->qos_rx.compression.value);
#endif
		len += sprintf(buf+len, "\n");
		
		self = (struct irlap_cb *) hashbin_get_next(irlap);
	}
	restore_flags(flags);

	return len;
}

#endif /* CONFIG_PROC_FS */