Lines Matching refs:up
85 /* wake up can transceiver from low-power sleep mode */
263 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);
635 static void ucan_tx_complete_msg(struct ucan_priv *up,
646 netdev_err(up->netdev, "invalid tx complete length\n");
654 if (echo_index >= up->device_info.tx_fifo) {
655 up->netdev->stats.tx_errors++;
656 netdev_err(up->netdev,
663 context = &up->context_array[echo_index];
668 if (!ucan_release_context(up, context))
671 spin_lock_irqsave(&up->echo_skb_lock, flags);
675 up->netdev->stats.tx_packets++;
676 up->netdev->stats.tx_bytes +=
677 can_get_echo_skb(up->netdev, echo_index, NULL);
679 up->netdev->stats.tx_dropped++;
680 can_free_echo_skb(up->netdev, echo_index, NULL);
682 spin_unlock_irqrestore(&up->echo_skb_lock, flags);
691 struct ucan_priv *up = urb->context;
692 struct net_device *netdev = up->netdev;
695 /* the device is not up and the driver should not receive any
698 if (WARN_ON(!up->context_array)) {
699 usb_free_coherent(up->udev,
700 up->in_ep_size,
716 usb_free_coherent(up->udev,
717 up->in_ep_size,
720 netdev_dbg(up->netdev, "not resubmitting urb; status: %d\n",
738 netdev_warn(up->netdev,
751 netdev_warn(up->netdev,
768 ucan_rx_can_msg(up, m);
771 ucan_tx_complete_msg(up, m);
774 netdev_warn(up->netdev,
788 usb_fill_bulk_urb(urb, up->udev,
789 usb_rcvbulkpipe(up->udev,
790 up->in_ep_addr),
792 up->in_ep_size,
794 up);
796 usb_anchor_urb(urb, &up->rx_urbs);
800 netdev_err(up->netdev,
805 usb_free_coherent(up->udev,
806 up->in_ep_size,
819 struct ucan_priv *up;
826 /* free up our allocated buffer */
832 up = context->up;
833 if (WARN_ON_ONCE(!up))
837 if (!netif_device_present(up->netdev))
842 netdev_warn(up->netdev,
847 spin_lock_irqsave(&up->echo_skb_lock, flags);
848 can_free_echo_skb(up->netdev, context - up->context_array, NULL);
849 spin_unlock_irqrestore(&up->echo_skb_lock, flags);
851 up->netdev->stats.tx_dropped++;
854 if (!ucan_release_context(up, context))
855 netdev_err(up->netdev,
860 static void ucan_cleanup_rx_urbs(struct ucan_priv *up, struct urb **urbs)
867 usb_free_coherent(up->udev,
868 up->in_ep_size,
878 static int ucan_prepare_and_anchor_rx_urbs(struct ucan_priv *up,
892 buf = usb_alloc_coherent(up->udev,
893 up->in_ep_size,
902 usb_fill_bulk_urb(urbs[i], up->udev,
903 usb_rcvbulkpipe(up->udev,
904 up->in_ep_addr),
906 up->in_ep_size,
908 up);
912 usb_anchor_urb(urbs[i], &up->rx_urbs);
918 ucan_cleanup_rx_urbs(up, urbs);
927 static int ucan_submit_rx_urbs(struct ucan_priv *up, struct urb **urbs)
937 netdev_err(up->netdev,
953 ucan_cleanup_rx_urbs(up, urbs);
956 usb_kill_anchored_urbs(&up->rx_urbs);
967 struct ucan_priv *up = netdev_priv(netdev);
969 ret = ucan_alloc_context_array(up);
976 ret = ucan_prepare_and_anchor_rx_urbs(up, urbs);
982 if (up->can.ctrlmode & CAN_CTRLMODE_LOOPBACK)
984 if (up->can.ctrlmode & CAN_CTRLMODE_LISTENONLY)
986 if (up->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
988 if (up->can.ctrlmode & CAN_CTRLMODE_ONE_SHOT)
995 up->ctl_msg_buffer->cmd_start.mode = cpu_to_le16(ctrlmode);
998 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_START, 0, 2);
1000 netdev_err(up->netdev,
1012 ret = ucan_submit_rx_urbs(up, urbs);
1016 up->can.state = CAN_STATE_ERROR_ACTIVE;
1025 ret_cleanup = ucan_ctrl_command_out(up, UCAN_COMMAND_STOP, 0, 0);
1027 netdev_err(up->netdev,
1035 ret_cleanup = ucan_ctrl_command_out(up, UCAN_COMMAND_RESET, 0, 0);
1037 netdev_err(up->netdev,
1041 /* clean up unsubmitted urbs */
1042 ucan_cleanup_rx_urbs(up, urbs);
1045 ucan_release_context_array(up);
1049 static struct urb *ucan_prepare_tx_urb(struct ucan_priv *up,
1061 netdev_err(up->netdev, "no memory left for URBs\n");
1065 m = usb_alloc_coherent(up->udev,
1070 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, 0);
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, NULL);
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);
1249 struct ucan_priv *up = netdev_priv(netdev);
1252 cmd_set_bittiming = &up->ctl_msg_buffer->cmd_set_bittiming;
1253 cmd_set_bittiming->tq = cpu_to_le32(up->can.bittiming.tq);
1254 cmd_set_bittiming->brp = cpu_to_le16(up->can.bittiming.brp);
1256 cpu_to_le16(up->can.bittiming.sample_point);
1257 cmd_set_bittiming->prop_seg = up->can.bittiming.prop_seg;
1258 cmd_set_bittiming->phase_seg1 = up->can.bittiming.phase_seg1;
1259 cmd_set_bittiming->phase_seg2 = up->can.bittiming.phase_seg2;
1260 cmd_set_bittiming->sjw = up->can.bittiming.sjw;
1262 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_SET_BITTIMING, 0,
1274 struct ucan_priv *up = netdev_priv(netdev);
1278 netdev_dbg(up->netdev, "restarting device\n");
1280 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_RESTART, 0, 0);
1281 up->can.state = CAN_STATE_ERROR_ACTIVE;
1284 * up->available_tx_urbs must be protected by the
1287 spin_lock_irqsave(&up->context_lock, flags);
1289 if (up->available_tx_urbs > 0)
1290 netif_wake_queue(up->netdev);
1292 spin_unlock_irqrestore(&up->context_lock, flags);
1310 struct ucan_priv *up;
1414 * because `up` is initialised in Stage 3
1453 * because `up` is initialised in Stage 3
1499 up = netdev_priv(netdev);
1502 up->udev = udev;
1503 up->netdev = netdev;
1504 up->intf_index = iface_desc->desc.bInterfaceNumber;
1505 up->in_ep_addr = in_ep_addr;
1506 up->out_ep_addr = out_ep_addr;
1507 up->in_ep_size = in_ep_size;
1508 up->ctl_msg_buffer = ctl_msg_buffer;
1509 up->context_array = NULL;
1510 up->available_tx_urbs = 0;
1512 up->can.state = CAN_STATE_STOPPED;
1513 up->can.bittiming_const = &up->device_info.bittiming_const;
1514 up->can.do_set_bittiming = ucan_set_bittiming;
1515 up->can.do_set_mode = &ucan_set_mode;
1516 spin_lock_init(&up->context_lock);
1517 spin_lock_init(&up->echo_skb_lock);
1521 usb_set_intfdata(intf, up);
1526 * up->ctl_msg_buffer
1528 ucan_parse_device_info(up, &ctl_msg_buffer->cmd_get_device_info);
1531 ret = ucan_device_request_in(up, UCAN_DEVICE_GET_FW_STRING, 0,
1535 strscpy(firmware_str, up->ctl_msg_buffer->raw,
1542 ret = ucan_ctrl_command_out(up, UCAN_COMMAND_RESET, 0, 0);
1546 init_usb_anchor(&up->rx_urbs);
1547 init_usb_anchor(&up->tx_urbs);
1549 up->can.state = CAN_STATE_STOPPED;
1557 netdev_info(up->netdev, "registered device\n");
1558 netdev_info(up->netdev, "firmware string: %s\n", firmware_str);
1577 struct ucan_priv *up = usb_get_intfdata(intf);
1581 if (up) {
1582 unregister_candev(up->netdev);
1583 free_candev(up->netdev);