Lines Matching refs:up
84 /* wake up can transceiver from low-power sleep mode */
261 struct ucan_priv *up;
314 static void ucan_release_context_array(struct ucan_priv *up)
316 if (!up->context_array)
320 up->available_tx_urbs = 0;
322 kfree(up->context_array);
323 up->context_array = NULL;
326 static int ucan_alloc_context_array(struct ucan_priv *up)
331 ucan_release_context_array(up);
333 up->context_array = kcalloc(up->device_info.tx_fifo,
334 sizeof(*up->context_array),
336 if (!up->context_array) {
337 netdev_err(up->netdev,
342 for (i = 0; i < up->device_info.tx_fifo; i++) {
343 up->context_array[i].allocated = false;
344 up->context_array[i].up = up;
348 up->available_tx_urbs = up->device_info.tx_fifo;
353 static struct ucan_urb_context *ucan_alloc_context(struct ucan_priv *up)
359 if (WARN_ON_ONCE(!up->context_array))
363 spin_lock_irqsave(&up->context_lock, flags);
365 for (i = 0; i < up->device_info.tx_fifo; i++) {
366 if (!up->context_array[i].allocated) {
368 ret = &up->context_array[i];
369 up->context_array[i].allocated = true;
372 up->available_tx_urbs--;
373 if (!up->available_tx_urbs)
374 netif_stop_queue(up->netdev);
380 spin_unlock_irqrestore(&up->context_lock, flags);
384 static bool ucan_release_context(struct ucan_priv *up,
390 if (WARN_ON_ONCE(!up->context_array))
394 spin_lock_irqsave(&up->context_lock, flags);
401 if (!up->available_tx_urbs)
402 netif_wake_queue(up->netdev);
403 up->available_tx_urbs++;
408 spin_unlock_irqrestore(&up->context_lock, flags);
412 static int ucan_ctrl_command_out(struct ucan_priv *up,
415 return usb_control_msg(up->udev,
416 usb_sndctrlpipe(up->udev, 0),
421 up->intf_index,
422 up->ctl_msg_buffer,
427 static int ucan_device_request_in(struct ucan_priv *up,
430 return usb_control_msg(up->udev,
431 usb_rcvctrlpipe(up->udev, 0),
436 up->ctl_msg_buffer,
444 static void ucan_parse_device_info(struct ucan_priv *up,
448 &up->device_info.bittiming_const;
452 up->can.clock.freq = le32_to_cpu(device_info->freq);
453 up->device_info.tx_fifo = device_info->tx_fifo;
466 up->can.ctrlmode_supported = 0;
469 up->can.ctrlmode_supported |= CAN_CTRLMODE_LOOPBACK;
471 up->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY;
473 up->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
475 up->can.ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT;
477 up->can.ctrlmode_supported |= CAN_CTRLMODE_BERR_REPORTING;
483 static bool ucan_handle_error_frame(struct ucan_priv *up,
487 enum can_state new_state = up->can.state;
488 struct net_device_stats *net_stats = &up->netdev->stats;
489 struct can_device_stats *can_stats = &up->can.can_stats;
532 if (up->can.state == new_state)
536 if (up->can.state > new_state) {
537 up->can.state = new_state;
542 up->can.state = new_state;
546 can_bus_off(up->netdev);
565 static void ucan_rx_can_msg(struct ucan_priv *up, struct ucan_message_in *m)
571 struct net_device_stats *stats = &up->netdev->stats;
578 netdev_warn(up->netdev, "invalid input message len: %d\n", len);
585 bool busstate_changed = ucan_handle_error_frame(up, m, canid);
588 if (!(up->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING) &&
601 netdev_warn(up->netdev,
609 skb = alloc_can_skb(up->netdev, &cf);
632 static void ucan_tx_complete_msg(struct ucan_priv *up,
643 netdev_err(up->netdev, "invalid tx complete length\n");
651 if (echo_index >= up->device_info.tx_fifo) {
652 up->netdev->stats.tx_errors++;
653 netdev_err(up->netdev,
660 context = &up->context_array[echo_index];
666 if (!ucan_release_context(up, context))
669 spin_lock_irqsave(&up->echo_skb_lock, flags);
673 up->netdev->stats.tx_packets++;
674 up->netdev->stats.tx_bytes += dlc;
675 can_get_echo_skb(up->netdev, echo_index);
677 up->netdev->stats.tx_dropped++;
678 can_free_echo_skb(up->netdev, echo_index);
680 spin_unlock_irqrestore(&up->echo_skb_lock, flags);
689 struct ucan_priv *up = urb->context;
690 struct net_device *netdev = up->netdev;
693 /* the device is not up and the driver should not receive any
696 if (WARN_ON(!up->context_array)) {
697 usb_free_coherent(up->udev,
698 up->in_ep_size,
714 usb_free_coherent(up->udev,
715 up->in_ep_size,
718 netdev_dbg(up->netdev, "not resubmitting urb; status: %d\n",
736 netdev_warn(up->netdev,
749 netdev_warn(up->netdev,
766 ucan_rx_can_msg(up, m);
769 ucan_tx_complete_msg(up, m);
772 netdev_warn(up->netdev,
786 usb_fill_bulk_urb(urb, up->udev,
787 usb_rcvbulkpipe(up->udev,
788 up->in_ep_addr),
790 up->in_ep_size,
792 up);
794 usb_anchor_urb(urb, &up->rx_urbs);
798 netdev_err(up->netdev,
803 usb_free_coherent(up->udev,
804 up->in_ep_size,
817 struct ucan_priv *up;
824 /* free up our allocated buffer */
830 up = context->up;
831 if (WARN_ON_ONCE(!up))
835 if (!netif_device_present(up->netdev))
840 netdev_warn(up->netdev,
845 spin_lock_irqsave(&up->echo_skb_lock, flags);
846 can_free_echo_skb(up->netdev, context - up->context_array);
847 spin_unlock_irqrestore(&up->echo_skb_lock, flags);
849 up->netdev->stats.tx_dropped++;
852 if (!ucan_release_context(up, context))
853 netdev_err(up->netdev,
858 static void ucan_cleanup_rx_urbs(struct ucan_priv *up, struct urb **urbs)
865 usb_free_coherent(up->udev,
866 up->in_ep_size,
876 static int ucan_prepare_and_anchor_rx_urbs(struct ucan_priv *up,
890 buf = usb_alloc_coherent(up->udev,
891 up->in_ep_size,
900 usb_fill_bulk_urb(urbs[i], up->udev,
901 usb_rcvbulkpipe(up->udev,
902 up->in_ep_addr),
904 up->in_ep_size,
906 up);
910 usb_anchor_urb(urbs[i], &up->rx_urbs);
916 ucan_cleanup_rx_urbs(up, urbs);
925 static int ucan_submit_rx_urbs(struct ucan_priv *up, struct urb **urbs)
935 netdev_err(up->netdev,
951 ucan_cleanup_rx_urbs(up, urbs);
954 usb_kill_anchored_urbs(&up->rx_urbs);
965 struct ucan_priv *up = netdev_priv(netdev);
967 ret = ucan_alloc_context_array(up);
974 ret = ucan_prepare_and_anchor_rx_urbs(up, urbs);
980 if (up->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
982 if (up->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
984 if (up->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
986 if (up->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT)
993 up->ctl_msg_buffer->cmd_start.mode = cpu_to_le16(ctrlmode);
996 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_START, 0, 2);
998 netdev_err(up->netdev,
1010 ret = ucan_submit_rx_urbs(up, urbs);
1014 up->can.state = CAN_STATE_ERROR_ACTIVE;
1023 ret_cleanup = ucan_ctrl_command_out(up, UCAN_COMMAND_STOP, 0, 0);
1025 netdev_err(up->netdev,
1033 ret_cleanup = ucan_ctrl_command_out(up, UCAN_COMMAND_RESET, 0, 0);
1035 netdev_err(up->netdev,
1039 /* clean up unsubmitted urbs */
1040 ucan_cleanup_rx_urbs(up, urbs);
1043 ucan_release_context_array(up);
1047 static struct urb *ucan_prepare_tx_urb(struct ucan_priv *up,
1059 netdev_err(up->netdev, "no memory left for URBs\n");
1063 m = usb_alloc_coherent(up->udev,
1068 netdev_err(up->netdev, "no memory left for USB buffer\n");
1094 usb_fill_bulk_urb(urb, up->udev,
1095 usb_sndbulkpipe(up->udev,
1096 up->out_ep_addr),
1103 static void ucan_clean_up_tx_urb(struct ucan_priv *up, struct urb *urb)
1105 usb_free_coherent(up->udev, sizeof(struct ucan_message_out),
1119 struct ucan_priv *up = netdev_priv(netdev);
1127 context = ucan_alloc_context(up);
1128 echo_index = context - up->context_array;
1134 urb = ucan_prepare_tx_urb(up, context, cf, echo_index);
1139 spin_lock_irqsave(&up->echo_skb_lock, flags);
1140 can_put_echo_skb(skb, up->netdev, echo_index);
1141 spin_unlock_irqrestore(&up->echo_skb_lock, flags);
1144 usb_anchor_urb(urb, &up->tx_urbs);
1149 /* on error, clean up */
1151 ucan_clean_up_tx_urb(up, urb);
1152 if (!ucan_release_context(up, context))
1153 netdev_err(up->netdev,
1159 spin_lock_irqsave(&up->echo_skb_lock, flags);
1160 can_free_echo_skb(up->netdev, echo_index);
1161 spin_unlock_irqrestore(&up->echo_skb_lock, flags);
1164 netif_device_detach(up->netdev);
1166 netdev_warn(up->netdev,
1169 up->netdev->stats.tx_dropped++;
1182 if (!ucan_release_context(up, context))
1183 netdev_err(up->netdev,
1186 up->netdev->stats.tx_dropped++;
1193 * Clean up used resources
1198 struct ucan_priv *up = netdev_priv(netdev);
1200 up->can.state = CAN_STATE_STOPPED;
1203 usb_kill_anchored_urbs(&up->tx_urbs);
1206 usb_kill_anchored_urbs(&up->rx_urbs);
1209 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_STOP, 0, 0);
1211 netdev_err(up->netdev,
1215 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_RESET, 0, 0);
1217 netdev_err(up->netdev,
1223 ucan_release_context_array(up);
1225 close_candev(up->netdev);
1245 struct ucan_priv *up = netdev_priv(netdev);
1248 cmd_set_bittiming = &up->ctl_msg_buffer->cmd_set_bittiming;
1249 cmd_set_bittiming->tq = cpu_to_le32(up->can.bittiming.tq);
1250 cmd_set_bittiming->brp = cpu_to_le16(up->can.bittiming.brp);
1252 cpu_to_le16(up->can.bittiming.sample_point);
1253 cmd_set_bittiming->prop_seg = up->can.bittiming.prop_seg;
1254 cmd_set_bittiming->phase_seg1 = up->can.bittiming.phase_seg1;
1255 cmd_set_bittiming->phase_seg2 = up->can.bittiming.phase_seg2;
1256 cmd_set_bittiming->sjw = up->can.bittiming.sjw;
1258 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_SET_BITTIMING, 0,
1270 struct ucan_priv *up = netdev_priv(netdev);
1274 netdev_dbg(up->netdev, "restarting device\n");
1276 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_RESTART, 0, 0);
1277 up->can.state = CAN_STATE_ERROR_ACTIVE;
1280 * up->available_tx_urbs must be protected by the
1283 spin_lock_irqsave(&up->context_lock, flags);
1285 if (up->available_tx_urbs > 0)
1286 netif_wake_queue(up->netdev);
1288 spin_unlock_irqrestore(&up->context_lock, flags);
1306 struct ucan_priv *up;
1410 * because `up` is initialised in Stage 3
1449 * because `up` is initialised in Stage 3
1495 up = netdev_priv(netdev);
1498 up->udev = udev;
1499 up->intf = intf;
1500 up->netdev = netdev;
1501 up->intf_index = iface_desc->desc.bInterfaceNumber;
1502 up->in_ep_addr = in_ep_addr;
1503 up->out_ep_addr = out_ep_addr;
1504 up->in_ep_size = in_ep_size;
1505 up->ctl_msg_buffer = ctl_msg_buffer;
1506 up->context_array = NULL;
1507 up->available_tx_urbs = 0;
1509 up->can.state = CAN_STATE_STOPPED;
1510 up->can.bittiming_const = &up->device_info.bittiming_const;
1511 up->can.do_set_bittiming = ucan_set_bittiming;
1512 up->can.do_set_mode = &ucan_set_mode;
1513 spin_lock_init(&up->context_lock);
1514 spin_lock_init(&up->echo_skb_lock);
1517 usb_set_intfdata(intf, up);
1522 * up->ctl_msg_buffer
1524 ucan_parse_device_info(up, &ctl_msg_buffer->cmd_get_device_info);
1527 ret = ucan_device_request_in(up, UCAN_DEVICE_GET_FW_STRING, 0,
1531 strncpy(firmware_str, up->ctl_msg_buffer->raw,
1539 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_RESET, 0, 0);
1543 init_usb_anchor(&up->rx_urbs);
1544 init_usb_anchor(&up->tx_urbs);
1546 up->can.state = CAN_STATE_STOPPED;
1554 netdev_info(up->netdev, "registered device\n");
1555 netdev_info(up->netdev, "firmware string: %s\n", firmware_str);
1574 struct ucan_priv *up = usb_get_intfdata(intf);
1578 if (up) {
1579 unregister_netdev(up->netdev);
1580 free_candev(up->netdev);