Lines Matching refs:self
60 extern void irlap_queue_xmit(struct irlap_cb *self, struct sk_buff *skb);
61 static void __irlap_close(struct irlap_cb *self);
62 static void irlap_init_qos_capabilities(struct irlap_cb *self,
114 struct irlap_cb *self;
119 self = kzalloc(sizeof(struct irlap_cb), GFP_KERNEL);
120 if (self == NULL)
123 self->magic = LAP_MAGIC;
126 self->netdev = dev;
127 self->qos_dev = qos;
130 strlcpy(self->hw_name, hw_name, sizeof(self->hw_name));
132 self->hw_name[0] = '\0';
135 dev->atalk_ptr = self;
137 self->state = LAP_OFFLINE;
140 skb_queue_head_init(&self->txq);
141 skb_queue_head_init(&self->txq_ultra);
142 skb_queue_head_init(&self->wx_list);
150 get_random_bytes(&self->saddr, sizeof(self->saddr));
151 } while ((self->saddr == 0x0) || (self->saddr == BROADCAST) ||
152 (hashbin_lock_find(irlap, self->saddr, NULL)) );
154 memcpy(dev->dev_addr, &self->saddr, 4);
156 init_timer(&self->slot_timer);
157 init_timer(&self->query_timer);
158 init_timer(&self->discovery_timer);
159 init_timer(&self->final_timer);
160 init_timer(&self->poll_timer);
161 init_timer(&self->wd_timer);
162 init_timer(&self->backoff_timer);
163 init_timer(&self->media_busy_timer);
165 irlap_apply_default_connection_parameters(self);
167 self->N3 = 3; /* # connections attemts to try before giving up */
169 self->state = LAP_NDM;
171 hashbin_insert(irlap, (irda_queue_t *) self, self->saddr, NULL);
173 irlmp_register_link(self, self->saddr, &self->notify);
175 return self;
180 * Function __irlap_close (self)
185 static void __irlap_close(struct irlap_cb *self)
187 IRDA_ASSERT(self != NULL, return;);
188 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
191 del_timer(&self->slot_timer);
192 del_timer(&self->query_timer);
193 del_timer(&self->discovery_timer);
194 del_timer(&self->final_timer);
195 del_timer(&self->poll_timer);
196 del_timer(&self->wd_timer);
197 del_timer(&self->backoff_timer);
198 del_timer(&self->media_busy_timer);
200 irlap_flush_all_queues(self);
202 self->magic = 0;
204 kfree(self);
208 * Function irlap_close (self)
213 void irlap_close(struct irlap_cb *self)
219 IRDA_ASSERT(self != NULL, return;);
220 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
227 irlmp_unregister_link(self->saddr);
228 self->notify.instance = NULL;
231 lap = hashbin_remove(irlap, self->saddr, NULL);
241 * Function irlap_connect_indication (self, skb)
246 void irlap_connect_indication(struct irlap_cb *self, struct sk_buff *skb)
250 IRDA_ASSERT(self != NULL, return;);
251 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
253 irlap_init_qos_capabilities(self, NULL); /* No user QoS! */
255 irlmp_link_connect_indication(self->notify.instance, self->saddr,
256 self->daddr, &self->qos_tx, skb);
260 * Function irlap_connect_response (self, skb)
265 void irlap_connect_response(struct irlap_cb *self, struct sk_buff *userdata)
269 irlap_do_event(self, CONNECT_RESPONSE, userdata, NULL);
273 * Function irlap_connect_request (self, daddr, qos_user, sniff)
279 void irlap_connect_request(struct irlap_cb *self, __u32 daddr,
284 IRDA_ASSERT(self != NULL, return;);
285 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
287 self->daddr = daddr;
293 irlap_init_qos_capabilities(self, qos_user);
295 if ((self->state == LAP_NDM) && !self->media_busy)
296 irlap_do_event(self, CONNECT_REQUEST, NULL, NULL);
298 self->connect_pending = TRUE;
302 * Function irlap_connect_confirm (self, skb)
307 void irlap_connect_confirm(struct irlap_cb *self, struct sk_buff *skb)
311 IRDA_ASSERT(self != NULL, return;);
312 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
314 irlmp_link_connect_confirm(self->notify.instance, &self->qos_tx, skb);
318 * Function irlap_data_indication (self, skb)
324 void irlap_data_indication(struct irlap_cb *self, struct sk_buff *skb,
330 irlmp_link_data_indication(self->notify.instance, skb, unreliable);
335 * Function irlap_data_request (self, skb)
340 void irlap_data_request(struct irlap_cb *self, struct sk_buff *skb,
343 IRDA_ASSERT(self != NULL, return;);
344 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
365 skb_queue_tail(&self->txq, skb);
367 if ((self->state == LAP_XMIT_P) || (self->state == LAP_XMIT_S)) {
370 if((skb_queue_len(&self->txq) <= 1) && (!self->local_busy))
371 irlap_do_event(self, DATA_REQUEST, skb, NULL);
378 * Function irlap_unitdata_request (self, skb)
384 void irlap_unitdata_request(struct irlap_cb *self, struct sk_buff *skb)
386 IRDA_ASSERT(self != NULL, return;);
387 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
400 skb_queue_tail(&self->txq_ultra, skb);
402 irlap_do_event(self, SEND_UI_FRAME, NULL, NULL);
407 * Function irlap_udata_indication (self, skb)
413 void irlap_unitdata_indication(struct irlap_cb *self, struct sk_buff *skb)
417 IRDA_ASSERT(self != NULL, return;);
418 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
424 irlmp_link_unitdata_indication(self->notify.instance, skb);
433 void irlap_disconnect_request(struct irlap_cb *self)
437 IRDA_ASSERT(self != NULL, return;);
438 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
441 if (!skb_queue_empty(&self->txq)) {
442 self->disconnect_pending = TRUE;
447 switch (self->state) {
453 irlap_do_event(self, DISCONNECT_REQUEST, NULL, NULL);
457 self->disconnect_pending = TRUE;
468 void irlap_disconnect_indication(struct irlap_cb *self, LAP_REASON reason)
472 IRDA_ASSERT(self != NULL, return;);
473 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
476 irlap_flush_all_queues(self);
481 irlap_do_event(self, RESET_REQUEST, NULL, NULL);
487 irlmp_link_disconnect_indication(self->notify.instance, self,
501 void irlap_discovery_request(struct irlap_cb *self, discovery_t *discovery)
505 IRDA_ASSERT(self != NULL, return;);
506 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
516 if (self->state != LAP_NDM) {
519 irlap_discovery_confirm(self, NULL);
531 if (self->discovery_log != NULL) {
532 hashbin_delete(self->discovery_log, (FREE_FUNC) kfree);
533 self->discovery_log = NULL;
537 self->discovery_log = hashbin_new(HB_NOLOCK);
539 if (self->discovery_log == NULL) {
548 self->discovery_cmd = discovery;
552 self->slot_timeout = sysctl_slot_timeout * HZ / 1000;
554 irlap_do_event(self, DISCOVERY_REQUEST, NULL, &info);
563 void irlap_discovery_confirm(struct irlap_cb *self, hashbin_t *discovery_log)
565 IRDA_ASSERT(self != NULL, return;);
566 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
568 IRDA_ASSERT(self->notify.instance != NULL, return;);
582 irda_device_set_media_busy(self->netdev, FALSE);
585 irlmp_link_discovery_confirm(self->notify.instance, discovery_log);
594 void irlap_discovery_indication(struct irlap_cb *self, discovery_t *discovery)
598 IRDA_ASSERT(self != NULL, return;);
599 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
602 IRDA_ASSERT(self->notify.instance != NULL, return;);
613 irda_device_set_media_busy(self->netdev, SMALL);
615 irlmp_link_discovery_indication(self->notify.instance, discovery);
621 void irlap_status_indication(struct irlap_cb *self, int quality_of_link)
633 irlmp_status_indication(self->notify.instance,
640 void irlap_reset_indication(struct irlap_cb *self)
644 IRDA_ASSERT(self != NULL, return;);
645 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
647 if (self->state == LAP_RESET_WAIT)
648 irlap_do_event(self, RESET_REQUEST, NULL, NULL);
650 irlap_do_event(self, RESET_RESPONSE, NULL, NULL);
693 void irlap_update_nr_received(struct irlap_cb *self, int nr)
707 if (nr == self->vs) {
708 while ((skb = skb_dequeue(&self->wx_list)) != NULL) {
712 self->va = nr - 1;
715 while ((skb_peek(&self->wx_list) != NULL) &&
716 (((self->va+1) % 8) != nr))
718 skb = skb_dequeue(&self->wx_list);
721 self->va = (self->va + 1) % 8;
727 self->window = self->window_size - skb_queue_len(&self->wx_list);
735 int irlap_validate_ns_received(struct irlap_cb *self, int ns)
738 if (ns == self->vr)
754 int irlap_validate_nr_received(struct irlap_cb *self, int nr)
757 if (nr == self->vs) {
766 if (self->va < self->vs) {
767 if ((nr >= self->va) && (nr <= self->vs))
770 if ((nr >= self->va) || (nr <= self->vs))
784 void irlap_initiate_connection_state(struct irlap_cb *self)
788 IRDA_ASSERT(self != NULL, return;);
789 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
792 self->vs = self->vr = 0;
795 self->va = 7;
797 self->window = 1;
799 self->remote_busy = FALSE;
800 self->retry_count = 0;
804 * Function irlap_wait_min_turn_around (self, qos)
811 void irlap_wait_min_turn_around(struct irlap_cb *self, struct qos_info *qos)
822 self->mtt_required = min_turn_time;
831 self->xbofs_delay = irlap_min_turn_time_in_bytes(speed, min_turn_time);
840 void irlap_flush_all_queues(struct irlap_cb *self)
844 IRDA_ASSERT(self != NULL, return;);
845 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
848 while ((skb = skb_dequeue(&self->txq)) != NULL)
851 while ((skb = skb_dequeue(&self->txq_ultra)) != NULL)
855 while ((skb = skb_dequeue(&self->wx_list)) != NULL)
860 * Function irlap_setspeed (self, speed)
865 static void irlap_change_speed(struct irlap_cb *self, __u32 speed, int now)
871 IRDA_ASSERT(self != NULL, return;);
872 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
874 self->speed = speed;
881 irlap_queue_xmit(self, skb);
886 * Function irlap_init_qos_capabilities (self, qos)
893 static void irlap_init_qos_capabilities(struct irlap_cb *self,
896 IRDA_ASSERT(self != NULL, return;);
897 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
898 IRDA_ASSERT(self->netdev != NULL, return;);
901 irda_init_max_qos_capabilies(&self->qos_rx);
904 irda_qos_compute_intersection(&self->qos_rx, self->qos_dev);
915 self->qos_rx.baud_rate.bits &= qos_user->baud_rate.bits;
918 self->qos_rx.max_turn_time.bits &= qos_user->max_turn_time.bits;
920 self->qos_rx.data_size.bits &= qos_user->data_size.bits;
923 self->qos_rx.link_disc_time.bits &= qos_user->link_disc_time.bits;
927 self->qos_rx.max_turn_time.bits &= 0x01;
930 /*self->qos_rx.data_size.bits &= 0x03;*/
932 irda_qos_bits_to_value(&self->qos_rx);
940 void irlap_apply_default_connection_parameters(struct irlap_cb *self)
944 IRDA_ASSERT(self != NULL, return;);
945 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
948 self->next_bofs = 12;
949 self->bofs_count = 12;
952 irlap_change_speed(self, 9600, TRUE);
955 irda_device_set_media_busy(self->netdev, TRUE);
961 while ((self->caddr == 0x00) || (self->caddr == 0xfe)) {
962 get_random_bytes(&self->caddr, sizeof(self->caddr));
963 self->caddr &= 0xfe;
967 self->slot_timeout = sysctl_slot_timeout;
968 self->final_timeout = FINAL_TIMEOUT;
969 self->poll_timeout = POLL_TIMEOUT;
970 self->wd_timeout = WD_TIMEOUT;
973 self->qos_tx.baud_rate.value = 9600;
974 self->qos_rx.baud_rate.value = 9600;
975 self->qos_tx.max_turn_time.value = 0;
976 self->qos_rx.max_turn_time.value = 0;
977 self->qos_tx.min_turn_time.value = 0;
978 self->qos_rx.min_turn_time.value = 0;
979 self->qos_tx.data_size.value = 64;
980 self->qos_rx.data_size.value = 64;
981 self->qos_tx.window_size.value = 1;
982 self->qos_rx.window_size.value = 1;
983 self->qos_tx.additional_bofs.value = 12;
984 self->qos_rx.additional_bofs.value = 12;
985 self->qos_tx.link_disc_time.value = 0;
986 self->qos_rx.link_disc_time.value = 0;
988 irlap_flush_all_queues(self);
990 self->disconnect_pending = FALSE;
991 self->connect_pending = FALSE;
1003 void irlap_apply_connection_parameters(struct irlap_cb *self, int now)
1007 IRDA_ASSERT(self != NULL, return;);
1008 IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
1011 self->next_bofs = self->qos_tx.additional_bofs.value;
1013 self->bofs_count = self->next_bofs;
1016 irlap_change_speed(self, self->qos_tx.baud_rate.value, now);
1018 self->window_size = self->qos_tx.window_size.value;
1019 self->window = self->qos_tx.window_size.value;
1026 self->line_capacity =
1027 irlap_max_line_capacity(self->qos_tx.baud_rate.value,
1028 self->qos_tx.max_turn_time.value);
1029 self->bytes_left = self->line_capacity;
1037 IRDA_ASSERT(self->qos_tx.max_turn_time.value != 0, return;);
1038 IRDA_ASSERT(self->qos_rx.max_turn_time.value != 0, return;);
1045 self->poll_timeout = self->qos_tx.max_turn_time.value * HZ / 1000;
1051 self->final_timeout = self->qos_rx.max_turn_time.value * HZ / 1000;
1057 self->wd_timeout = self->final_timeout * 2;
1074 if (self->qos_tx.link_disc_time.value == sysctl_warn_noreply_time)
1080 self->N1 = -2; /* Disable - Need to be multiple of 2*/
1082 self->N1 = sysctl_warn_noreply_time * 1000 /
1083 self->qos_rx.max_turn_time.value;
1085 IRDA_DEBUG(4, "Setting N1 = %d\n", self->N1);
1088 self->N2 = self->qos_tx.link_disc_time.value * 1000 /
1089 self->qos_rx.max_turn_time.value;
1090 IRDA_DEBUG(4, "Setting N2 = %d\n", self->N2);
1101 struct irlap_cb *self;
1107 for (self = (struct irlap_cb *) hashbin_get_first(irlap);
1108 self; self = (struct irlap_cb *) hashbin_get_next(irlap)) {
1114 return self;
1134 const struct irlap_cb *self = v;
1136 IRDA_ASSERT(self->magic == LAP_MAGIC, return -EINVAL;);
1140 irlap_state[self->state]);
1143 (self->netdev) ? self->netdev->name : "bug");
1144 seq_printf(seq, "hardware name: %s\n", self->hw_name);
1146 seq_printf(seq, " caddr: %#02x, ", self->caddr);
1147 seq_printf(seq, "saddr: %#08x, ", self->saddr);
1148 seq_printf(seq, "daddr: %#08x\n", self->daddr);
1151 self->window_size);
1152 seq_printf(seq, "win: %d, ", self->window);
1155 self->line_capacity);
1156 seq_printf(seq, "bytes left: %d\n", self->bytes_left);
1159 skb_queue_len(&self->txq));
1161 skb_queue_len(&self->wx_list));
1162 seq_printf(seq, "rbusy: %s", self->remote_busy ?
1164 seq_printf(seq, " mbusy: %s\n", self->media_busy ?
1167 seq_printf(seq, " retrans: %d ", self->retry_count);
1168 seq_printf(seq, "vs: %d ", self->vs);
1169 seq_printf(seq, "vr: %d ", self->vr);
1170 seq_printf(seq, "va: %d\n", self->va);
1175 self->qos_tx.baud_rate.value);
1177 self->qos_tx.max_turn_time.value);
1179 self->qos_tx.data_size.value);
1181 self->qos_tx.window_size.value);
1183 self->qos_tx.additional_bofs.value);
1185 self->qos_tx.min_turn_time.value);
1187 self->qos_tx.link_disc_time.value);
1191 self->qos_rx.baud_rate.value);
1193 self->qos_rx.max_turn_time.value);
1195 self->qos_rx.data_size.value);
1197 self->qos_rx.window_size.value);
1199 self->qos_rx.additional_bofs.value);
1201 self->qos_rx.min_turn_time.value);
1203 self->qos_rx.link_disc_time.value);