Lines Matching refs:self
110 static void irda_usb_init_qos(struct irda_usb_cb *self) ;
113 static void irda_usb_change_speed_xbofs(struct irda_usb_cb *self);
116 static int irda_usb_open(struct irda_usb_cb *self);
117 static void irda_usb_close(struct irda_usb_cb *self);
135 * Function irda_usb_build_header(self, skb, header)
149 static void irda_usb_build_header(struct irda_usb_cb *self,
157 if (self->capability & IUC_STIR421X &&
158 ((self->new_speed != -1) || (self->new_xbofs != -1))) {
163 if (self->new_speed == -1)
164 self->new_speed = self->speed ;
166 if (self->new_xbofs == -1)
167 self->new_xbofs = self->xbofs ;
171 if (self->new_speed != -1) {
176 if ((self->capability & IUC_SPEED_BUG) &&
177 (!force) && (self->speed != -1)) {
185 IRDA_DEBUG(2, "%s(), changing speed to %d\n", __func__, self->new_speed);
186 self->speed = self->new_speed;
187 /* We will do ` self->new_speed = -1; ' in the completion
190 switch (self->speed) {
218 self->new_xbofs = 0;
222 self->new_xbofs = 0;
230 if (self->new_xbofs != -1) {
231 IRDA_DEBUG(2, "%s(), changing xbofs to %d\n", __func__, self->new_xbofs);
232 self->xbofs = self->new_xbofs;
233 /* We will do ` self->new_xbofs = -1; ' in the completion
236 switch (self->xbofs) {
299 static void irda_usb_change_speed_xbofs(struct irda_usb_cb *self)
306 self->new_speed, self->new_xbofs);
309 urb = self->speed_urb;
316 frame = self->speed_buff;
319 irda_usb_build_header(self, frame, 1);
321 if (self->capability & IUC_STIR421X) {
328 usb_fill_bulk_urb(urb, self->usbdev,
329 usb_sndbulkpipe(self->usbdev, self->bulk_out_ep),
331 speed_bulk_callback, self);
332 urb->transfer_buffer_length = self->header_length;
348 struct irda_usb_cb *self = urb->context;
353 IRDA_ASSERT(self != NULL, return;);
355 IRDA_ASSERT(urb == self->speed_urb, return;);
374 self->new_speed = -1;
375 self->new_xbofs = -1;
378 netif_wake_queue(self->netdev);
388 struct irda_usb_cb *self = netdev_priv(netdev);
389 struct urb *urb = self->tx_urb;
400 spin_lock_irqsave(&self->lock, flags);
403 * We need to check self->present under the spinlock because
405 if (!self->present) {
412 if ((xbofs != self->xbofs) && (xbofs != -1)) {
413 self->new_xbofs = xbofs;
418 if ((speed != self->speed) && (speed != -1)) {
420 self->new_speed = speed;
431 irda_usb_change_speed_xbofs(self);
443 skb_copy_from_linear_data(skb, self->tx_buff + self->header_length, skb->len);
446 if (self->capability & IUC_STIR421X) {
448 __u8* frame = self->tx_buff;
450 irda_usb_build_header(self, frame, 0);
462 irda_usb_build_header(self, self->tx_buff, 0);
465 ((struct irda_skb_cb *)skb->cb)->context = self;
467 usb_fill_bulk_urb(urb, self->usbdev,
468 usb_sndbulkpipe(self->usbdev, self->bulk_out_ep),
469 self->tx_buff, skb->len + self->header_length,
492 if (self->capability & IUC_NO_TURN) {
496 do_gettimeofday(&self->now);
497 diff = self->now.tv_usec - self->stamp.tv_usec;
535 spin_unlock_irqrestore(&self->lock, flags);
542 spin_unlock_irqrestore(&self->lock, flags);
554 struct irda_usb_cb *self = ((struct irda_skb_cb *) skb->cb)->context;
559 IRDA_ASSERT(self != NULL, return;);
561 IRDA_ASSERT(urb == self->tx_urb, return;);
584 /* Make sure we read self->present properly */
585 spin_lock_irqsave(&self->lock, flags);
588 if ((!self->netopen) || (!self->present)) {
590 spin_unlock_irqrestore(&self->lock, flags);
595 if ((self->new_speed != -1) || (self->new_xbofs != -1)) {
596 if ((self->new_speed != self->speed) ||
597 (self->new_xbofs != self->xbofs)) {
601 irda_usb_change_speed_xbofs(self);
604 self->new_speed = -1;
605 self->new_xbofs = -1;
607 netif_wake_queue(self->netdev);
611 netif_wake_queue(self->netdev);
613 spin_unlock_irqrestore(&self->lock, flags);
628 struct irda_usb_cb *self = netdev_priv(netdev);
633 IRDA_ASSERT(self != NULL, return;);
636 spin_lock_irqsave(&self->lock, flags);
638 /* self->present *MUST* be read under spinlock */
639 if (!self->present) {
642 spin_unlock_irqrestore(&self->lock, flags);
647 urb = self->speed_urb;
663 netif_wake_queue(self->netdev);
670 urb = self->tx_urb;
681 if(self->new_speed == -1)
682 self->new_speed = self->speed;
683 if(self->new_xbofs == -1)
684 self->new_xbofs = self->xbofs;
685 irda_usb_change_speed_xbofs(self);
706 netif_wake_queue(self->netdev);
711 spin_unlock_irqrestore(&self->lock, flags);
754 static void irda_usb_submit(struct irda_usb_cb *self, struct sk_buff *skb, struct urb *urb)
767 cb->context = self;
770 usb_fill_bulk_urb(urb, self->usbdev,
771 usb_rcvbulkpipe(self->usbdev, self->bulk_in_ep),
796 struct irda_usb_cb *self;
808 self = (struct irda_usb_cb *) cb->context;
809 IRDA_ASSERT(self != NULL, return;);
812 if ((!self->netopen) || (!self->present)) {
822 self->netdev->stats.rx_crc_errors++;
835 self->netdev->stats.rx_errors++;
849 self->rx_defer_timer.function = irda_usb_rx_defer_expired;
850 self->rx_defer_timer.data = (unsigned long) urb;
851 mod_timer(&self->rx_defer_timer, jiffies + (10 * HZ / 1000));
856 if (urb->actual_length <= self->header_length) {
866 do_gettimeofday(&self->stamp);
877 if (self->capability & IUC_STIR421X)
886 self->netdev->stats.rx_dropped++;
913 skb_pull(dataskb, self->header_length);
916 dataskb->dev = self->netdev;
923 self->netdev->stats.rx_bytes += len;
924 self->netdev->stats.rx_packets++;
938 next_urb = self->idle_rx_urb;
942 self->idle_rx_urb = urb;
946 irda_usb_submit(self, skb, next_urb);
958 struct irda_usb_cb *self;
967 self = (struct irda_usb_cb *) cb->context;
968 IRDA_ASSERT(self != NULL, return;);
971 next_urb = self->idle_rx_urb;
973 self->idle_rx_urb = urb;
974 irda_usb_submit(self, skb, next_urb);
982 static int irda_usb_is_receiving(struct irda_usb_cb *self)
1012 * Function stir421x_fwupload (struct irda_usb_cb *self,
1018 static int stir421x_fw_upload(struct irda_usb_cb *self,
1042 ret = usb_bulk_msg(self->usbdev,
1043 usb_sndbulkpipe(self->usbdev,
1044 self->bulk_out_ep),
1062 * Function stir421x_patch_device(struct irda_usb_cb *self)
1066 static int stir421x_patch_device(struct irda_usb_cb *self)
1080 self->usbdev->descriptor.bcdDevice);
1081 ret = request_firmware(&fw, stir421x_fw_name, &self->usbdev->dev);
1115 if (self->usbdev->descriptor.bcdDevice == cpu_to_le16(fw_version)) {
1131 ret = stir421x_fw_upload(self, &fw->data[i],
1158 * Note : don't mess with self->netopen - Jean II
1162 struct irda_usb_cb *self;
1170 self = netdev_priv(netdev);
1171 IRDA_ASSERT(self != NULL, return -1;);
1173 spin_lock_irqsave(&self->lock, flags);
1175 if(!self->present) {
1176 spin_unlock_irqrestore(&self->lock, flags);
1181 if(self->needspatch) {
1182 spin_unlock_irqrestore(&self->lock, flags);
1189 self->speed = -1;
1190 self->xbofs = -1;
1191 self->new_speed = -1;
1192 self->new_xbofs = -1;
1196 self->netopen = 1;
1197 spin_unlock_irqrestore(&self->lock, flags);
1204 sprintf(hwname, "usb#%d", self->usbdev->devnum);
1205 self->irlap = irlap_open(netdev, &self->qos, hwname);
1206 IRDA_ASSERT(self->irlap != NULL, return -1;);
1215 self->idle_rx_urb = self->rx_urb[IU_MAX_ACTIVE_RX_URBS];
1216 self->idle_rx_urb->context = NULL;
1230 irda_usb_submit(self, skb, self->rx_urb[i]);
1239 * Function irda_usb_net_close (self)
1246 struct irda_usb_cb *self;
1252 self = netdev_priv(netdev);
1253 IRDA_ASSERT(self != NULL, return -1;);
1257 self->netopen = 0;
1263 del_timer(&self->rx_defer_timer);
1266 for (i = 0; i < self->max_rx_urb; i++) {
1267 struct urb *urb = self->rx_urb[i];
1278 usb_kill_urb(self->tx_urb);
1279 usb_kill_urb(self->speed_urb);
1282 if (self->irlap)
1283 irlap_close(self->irlap);
1284 self->irlap = NULL;
1297 struct irda_usb_cb *self;
1301 self = netdev_priv(dev);
1302 IRDA_ASSERT(self != NULL, return -1;);
1311 spin_lock_irqsave(&self->lock, flags);
1313 if(self->present) {
1315 self->new_speed = irq->ifr_baudrate;
1316 irda_usb_change_speed_xbofs(self);
1318 spin_unlock_irqrestore(&self->lock, flags);
1324 if(self->netopen)
1325 irda_device_set_media_busy(self->netdev, TRUE);
1328 irq->ifr_receiving = irda_usb_is_receiving(self);
1350 static inline void irda_usb_init_qos(struct irda_usb_cb *self)
1356 desc = self->irda_desc;
1359 irda_init_max_qos_capabilies(&self->qos);
1364 self->qos.baud_rate.bits = le16_to_cpu(desc->wBaudRate);
1365 self->qos.min_turn_time.bits = desc->bmMinTurnaroundTime;
1366 self->qos.additional_bofs.bits = desc->bmAdditionalBOFs;
1367 self->qos.window_size.bits = desc->bmWindowSize;
1368 self->qos.data_size.bits = desc->bmDataSize;
1371 __func__, self->qos.baud_rate.bits, self->qos.data_size.bits, self->qos.window_size.bits, self->qos.additional_bofs.bits, self->qos.min_turn_time.bits);
1374 if(self->capability & IUC_SIR_ONLY)
1375 self->qos.baud_rate.bits &= 0x00ff;
1376 if(self->capability & IUC_SMALL_PKT)
1377 self->qos.data_size.bits = 0x07;
1378 if(self->capability & IUC_NO_WINDOW)
1379 self->qos.window_size.bits = 0x01;
1380 if(self->capability & IUC_MAX_WINDOW)
1381 self->qos.window_size.bits = 0x7f;
1382 if(self->capability & IUC_MAX_XBOFS)
1383 self->qos.additional_bofs.bits = 0x01;
1387 self->qos.min_turn_time.bits = qos_mtt_bits;
1392 irda_qos_bits_to_value(&self->qos);
1408 static inline int irda_usb_open(struct irda_usb_cb *self)
1410 struct net_device *netdev = self->netdev;
1416 irda_usb_init_qos(self);
1426 static inline void irda_usb_close(struct irda_usb_cb *self)
1431 unregister_netdev(self->netdev);
1434 kfree(self->speed_buff);
1435 self->speed_buff = NULL;
1437 kfree(self->tx_buff);
1438 self->tx_buff = NULL;
1460 static inline int irda_usb_parse_endpoints(struct irda_usb_cb *self, struct usb_host_endpoint *endpoint, int ennum)
1465 self->bulk_in_ep = 0;
1466 self->bulk_out_ep = 0;
1467 self->bulk_int_ep = 0;
1489 self->bulk_in_ep = ep;
1492 self->bulk_out_ep = ep;
1493 self->bulk_out_mtu = psize;
1499 self->bulk_int_ep = ep;
1507 __func__, self->bulk_in_ep, self->bulk_out_ep, self->bulk_out_mtu, self->bulk_int_ep);
1509 return((self->bulk_in_ep != 0) && (self->bulk_out_ep != 0));
1607 struct irda_usb_cb *self;
1622 net = alloc_irdadev(sizeof(*self));
1627 self = netdev_priv(net);
1628 self->netdev = net;
1629 spin_lock_init(&self->lock);
1630 init_timer(&self->rx_defer_timer);
1632 self->capability = id->driver_info;
1633 self->needspatch = ((self->capability & IUC_STIR421X) != 0);
1636 if (self->capability & IUC_STIR421X) {
1637 self->max_rx_urb = IU_SIGMATEL_MAX_RX_URBS;
1638 self->header_length = USB_IRDA_STIR421X_HEADER;
1640 self->max_rx_urb = IU_MAX_RX_URBS;
1641 self->header_length = USB_IRDA_HEADER;
1644 self->rx_urb = kcalloc(self->max_rx_urb, sizeof(struct urb *),
1646 if (!self->rx_urb)
1649 for (i = 0; i < self->max_rx_urb; i++) {
1650 self->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
1651 if (!self->rx_urb[i]) {
1655 self->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
1656 if (!self->tx_urb) {
1659 self->speed_urb = usb_alloc_urb(0, GFP_KERNEL);
1660 if (!self->speed_urb) {
1694 if(!irda_usb_parse_endpoints(self, interface->endpoint,
1701 self->usbdev = dev;
1709 if (self->needspatch) {
1710 ret = usb_control_msg (self->usbdev, usb_sndctrlpipe (self->usbdev, 0),
1720 self->irda_desc = irda_desc;
1721 self->present = 1;
1722 self->netopen = 0;
1723 self->usbintf = intf;
1729 self->speed_buff = kzalloc(IRDA_USB_SPEED_MTU, GFP_KERNEL);
1730 if (!self->speed_buff)
1733 self->tx_buff = kzalloc(IRDA_SKB_MAX_MTU + self->header_length,
1735 if (!self->tx_buff)
1738 ret = irda_usb_open(self);
1743 usb_set_intfdata(intf, self);
1745 if (self->needspatch) {
1747 ret = stir421x_patch_device(self);
1748 self->needspatch = (ret < 0);
1749 if (self->needspatch) {
1755 irda_desc = irda_usb_find_class_desc (self->usbintf);
1760 kfree(self->irda_desc);
1761 self->irda_desc = irda_desc;
1762 irda_usb_init_qos(self);
1767 unregister_netdev(self->netdev);
1769 kfree(self->tx_buff);
1771 kfree(self->speed_buff);
1774 usb_free_urb(self->speed_urb);
1776 usb_free_urb(self->tx_urb);
1778 for (i = 0; i < self->max_rx_urb; i++)
1779 usb_free_urb(self->rx_urb[i]);
1780 kfree(self->rx_urb);
1802 struct irda_usb_cb *self = usb_get_intfdata(intf);
1808 if (!self)
1812 spin_lock_irqsave(&self->lock, flags);
1816 self->present = 0;
1819 del_timer(&self->rx_defer_timer);
1823 spin_unlock_irqrestore(&self->lock, flags);
1826 if((self->netopen) || (self->irlap)) {
1828 /*netif_device_detach(self->netdev);*/
1829 netif_stop_queue(self->netdev);
1831 for (i = 0; i < self->max_rx_urb; i++)
1832 usb_kill_urb(self->rx_urb[i]);
1835 usb_kill_urb(self->tx_urb);
1836 usb_kill_urb(self->speed_urb);
1840 irda_usb_close(self);
1842 self->usbdev = NULL;
1843 self->usbintf = NULL;
1846 for (i = 0; i < self->max_rx_urb; i++)
1847 usb_free_urb(self->rx_urb[i]);
1848 kfree(self->rx_urb);
1850 usb_free_urb(self->tx_urb);
1851 usb_free_urb(self->speed_urb);
1853 /* Free self and network device */
1854 free_netdev(self->netdev);
1862 struct irda_usb_cb *self = usb_get_intfdata(intf);
1865 netif_device_detach(self->netdev);
1867 if (self->tx_urb != NULL)
1868 usb_kill_urb(self->tx_urb);
1869 if (self->speed_urb != NULL)
1870 usb_kill_urb(self->speed_urb);
1871 for (i = 0; i < self->max_rx_urb; i++) {
1872 if (self->rx_urb[i] != NULL)
1873 usb_kill_urb(self->rx_urb[i]);
1881 struct irda_usb_cb *self = usb_get_intfdata(intf);
1884 for (i = 0; i < self->max_rx_urb; i++) {
1885 if (self->rx_urb[i] != NULL)
1886 usb_submit_urb(self->rx_urb[i], GFP_KERNEL);
1889 netif_device_attach(self->netdev);