Lines Matching refs:ctlr
485 #define jc_type_is_joycon(ctlr) \
486 (ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_JOYCONL || \
487 ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_JOYCONR || \
488 ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_CHRGGRIP)
489 #define jc_type_is_procon(ctlr) \
490 (ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_PROCON)
491 #define jc_type_is_chrggrip(ctlr) \
492 (ctlr->hdev->product == USB_DEVICE_ID_NINTENDO_CHRGGRIP)
495 #define jc_type_has_left(ctlr) \
496 (ctlr->ctlr_type == JOYCON_CTLR_TYPE_JCL || \
497 ctlr->ctlr_type == JOYCON_CTLR_TYPE_PRO)
500 #define jc_type_has_right(ctlr) \
501 (ctlr->ctlr_type == JOYCON_CTLR_TYPE_JCR || \
502 ctlr->ctlr_type == JOYCON_CTLR_TYPE_PRO)
519 static void joycon_wait_for_input_report(struct joycon_ctlr *ctlr)
528 if (ctlr->ctlr_state == JOYCON_CTLR_STATE_READ) {
531 spin_lock_irqsave(&ctlr->lock, flags);
532 ctlr->received_input_report = false;
533 spin_unlock_irqrestore(&ctlr->lock, flags);
534 ret = wait_event_timeout(ctlr->wait,
535 ctlr->received_input_report,
539 hid_warn(ctlr->hdev,
555 #define JC_SUBCMD_RATE_LIMITER_MS(ctlr) ((ctlr)->hdev->bus == BUS_USB ? JC_SUBCMD_RATE_LIMITER_USB_MS : JC_SUBCMD_RATE_LIMITER_BT_MS)
556 static void joycon_enforce_subcmd_rate(struct joycon_ctlr *ctlr)
564 if (unlikely(ctlr->ctlr_state != JOYCON_CTLR_STATE_READ))
568 joycon_wait_for_input_report(ctlr);
570 subcmd_delta = current_ms - ctlr->last_subcmd_sent_msecs;
572 spin_lock_irqsave(&ctlr->lock, flags);
573 consecutive_valid_deltas = ctlr->consecutive_valid_report_deltas;
574 spin_unlock_irqrestore(&ctlr->lock, flags);
578 subcmd_delta < JC_SUBCMD_RATE_LIMITER_MS(ctlr)) &&
579 ctlr->ctlr_state == JOYCON_CTLR_STATE_READ &&
583 hid_warn(ctlr->hdev, "%s: exceeded max attempts", __func__);
587 ctlr->last_subcmd_sent_msecs = current_ms;
598 static int joycon_hid_send_sync(struct joycon_ctlr *ctlr, u8 *data, size_t len,
609 joycon_enforce_subcmd_rate(ctlr);
611 ret = __joycon_hid_send(ctlr->hdev, data, len);
613 memset(ctlr->input_buf, 0, JC_MAX_RESP_SIZE);
617 ret = wait_event_timeout(ctlr->wait, ctlr->received_resp,
620 hid_dbg(ctlr->hdev,
623 hid_dbg(ctlr->hdev,
626 memset(ctlr->input_buf, 0, JC_MAX_RESP_SIZE);
634 ctlr->received_resp = false;
638 static int joycon_send_usb(struct joycon_ctlr *ctlr, u8 cmd, u32 timeout)
644 ctlr->usb_ack_match = cmd;
645 ctlr->msg_type = JOYCON_MSG_TYPE_USB;
646 ret = joycon_hid_send_sync(ctlr, buf, sizeof(buf), timeout);
648 hid_dbg(ctlr->hdev, "send usb command failed; ret=%d\n", ret);
652 static int joycon_send_subcmd(struct joycon_ctlr *ctlr,
659 spin_lock_irqsave(&ctlr->lock, flags);
664 if (ctlr->ctlr_state == JOYCON_CTLR_STATE_REMOVED) {
665 spin_unlock_irqrestore(&ctlr->lock, flags);
668 memcpy(subcmd->rumble_data, ctlr->rumble_data[ctlr->rumble_queue_tail],
670 spin_unlock_irqrestore(&ctlr->lock, flags);
673 subcmd->packet_num = ctlr->subcmd_num;
674 if (++ctlr->subcmd_num > 0xF)
675 ctlr->subcmd_num = 0;
676 ctlr->subcmd_ack_match = subcmd->subcmd_id;
677 ctlr->msg_type = JOYCON_MSG_TYPE_SUBCMD;
679 ret = joycon_hid_send_sync(ctlr, (u8 *)subcmd,
682 hid_dbg(ctlr->hdev, "send subcommand failed; ret=%d\n", ret);
689 static int joycon_set_player_leds(struct joycon_ctlr *ctlr, u8 flash, u8 on)
698 hid_dbg(ctlr->hdev, "setting player leds\n");
699 return joycon_send_subcmd(ctlr, req, 1, HZ/4);
702 static int joycon_request_spi_flash_read(struct joycon_ctlr *ctlr,
720 hid_dbg(ctlr->hdev, "requesting SPI flash data\n");
721 ret = joycon_send_subcmd(ctlr, req, 5, HZ);
723 hid_err(ctlr->hdev, "failed reading SPI flash; ret=%d\n", ret);
725 report = (struct joycon_input_report *)ctlr->input_buf;
736 static int joycon_check_for_cal_magic(struct joycon_ctlr *ctlr, u32 flash_addr)
741 ret = joycon_request_spi_flash_read(ctlr, flash_addr,
749 static int joycon_read_stick_calibration(struct joycon_ctlr *ctlr, u16 cal_addr,
761 ret = joycon_request_spi_flash_read(ctlr, cal_addr,
768 x_max_above = hid_field_extract(ctlr->hdev, (raw_cal + 0), 0,
770 y_max_above = hid_field_extract(ctlr->hdev, (raw_cal + 1), 4,
772 cal_x->center = hid_field_extract(ctlr->hdev, (raw_cal + 3), 0,
774 cal_y->center = hid_field_extract(ctlr->hdev, (raw_cal + 4), 4,
776 x_min_below = hid_field_extract(ctlr->hdev, (raw_cal + 6), 0,
778 y_min_below = hid_field_extract(ctlr->hdev, (raw_cal + 7), 4,
781 cal_x->center = hid_field_extract(ctlr->hdev, (raw_cal + 0), 0,
783 cal_y->center = hid_field_extract(ctlr->hdev, (raw_cal + 1), 4,
785 x_min_below = hid_field_extract(ctlr->hdev, (raw_cal + 3), 0,
787 y_min_below = hid_field_extract(ctlr->hdev, (raw_cal + 4), 4,
789 x_max_above = hid_field_extract(ctlr->hdev, (raw_cal + 6), 0,
791 y_max_above = hid_field_extract(ctlr->hdev, (raw_cal + 7), 4,
825 static int joycon_request_calibration(struct joycon_ctlr *ctlr)
831 hid_dbg(ctlr->hdev, "requesting cal data\n");
834 if (!joycon_check_for_cal_magic(ctlr, JC_CAL_USR_LEFT_MAGIC_ADDR)) {
836 hid_info(ctlr->hdev, "using user cal for left stick\n");
838 hid_info(ctlr->hdev, "using factory cal for left stick\n");
840 if (!joycon_check_for_cal_magic(ctlr, JC_CAL_USR_RIGHT_MAGIC_ADDR)) {
842 hid_info(ctlr->hdev, "using user cal for right stick\n");
844 hid_info(ctlr->hdev, "using factory cal for right stick\n");
848 ret = joycon_read_stick_calibration(ctlr, left_stick_addr,
849 &ctlr->left_stick_cal_x,
850 &ctlr->left_stick_cal_y,
854 joycon_use_default_calibration(ctlr->hdev,
855 &ctlr->left_stick_cal_x,
856 &ctlr->left_stick_cal_y,
860 ret = joycon_read_stick_calibration(ctlr, right_stick_addr,
861 &ctlr->right_stick_cal_x,
862 &ctlr->right_stick_cal_y,
866 joycon_use_default_calibration(ctlr->hdev,
867 &ctlr->right_stick_cal_x,
868 &ctlr->right_stick_cal_y,
871 hid_dbg(ctlr->hdev, "calibration:\n"
876 ctlr->left_stick_cal_x.center,
877 ctlr->left_stick_cal_x.max,
878 ctlr->left_stick_cal_x.min,
879 ctlr->left_stick_cal_y.center,
880 ctlr->left_stick_cal_y.max,
881 ctlr->left_stick_cal_y.min,
882 ctlr->right_stick_cal_x.center,
883 ctlr->right_stick_cal_x.max,
884 ctlr->right_stick_cal_x.min,
885 ctlr->right_stick_cal_y.center,
886 ctlr->right_stick_cal_y.max,
887 ctlr->right_stick_cal_y.min);
897 static void joycon_calc_imu_cal_divisors(struct joycon_ctlr *ctlr)
902 ctlr->imu_cal_accel_divisor[i] = ctlr->accel_cal.scale[i] -
903 ctlr->accel_cal.offset[i];
904 ctlr->imu_cal_gyro_divisor[i] = ctlr->gyro_cal.scale[i] -
905 ctlr->gyro_cal.offset[i];
907 if (ctlr->imu_cal_accel_divisor[i] == 0) {
908 ctlr->imu_cal_accel_divisor[i] = 1;
912 if (ctlr->imu_cal_gyro_divisor[i] == 0) {
913 ctlr->imu_cal_gyro_divisor[i] = 1;
919 hid_warn(ctlr->hdev, "inaccurate IMU divisors (%d)\n", divz);
926 static int joycon_request_imu_calibration(struct joycon_ctlr *ctlr)
934 if (!joycon_check_for_cal_magic(ctlr, JC_IMU_CAL_USR_MAGIC_ADDR)) {
936 hid_info(ctlr->hdev, "using user cal for IMU\n");
938 hid_info(ctlr->hdev, "using factory cal for IMU\n");
942 hid_dbg(ctlr->hdev, "requesting IMU cal data\n");
943 ret = joycon_request_spi_flash_read(ctlr, imu_cal_addr,
946 hid_warn(ctlr->hdev,
951 ctlr->accel_cal.offset[i] = DFLT_ACCEL_OFFSET;
952 ctlr->accel_cal.scale[i] = DFLT_ACCEL_SCALE;
953 ctlr->gyro_cal.offset[i] = DFLT_GYRO_OFFSET;
954 ctlr->gyro_cal.scale[i] = DFLT_GYRO_SCALE;
956 joycon_calc_imu_cal_divisors(ctlr);
964 ctlr->accel_cal.offset[i] = get_unaligned_le16(raw_cal + j);
965 ctlr->accel_cal.scale[i] = get_unaligned_le16(raw_cal + j + 6);
966 ctlr->gyro_cal.offset[i] = get_unaligned_le16(raw_cal + j + 12);
967 ctlr->gyro_cal.scale[i] = get_unaligned_le16(raw_cal + j + 18);
970 joycon_calc_imu_cal_divisors(ctlr);
972 hid_dbg(ctlr->hdev, "IMU calibration:\n"
977 ctlr->accel_cal.offset[0],
978 ctlr->accel_cal.offset[1],
979 ctlr->accel_cal.offset[2],
980 ctlr->accel_cal.scale[0],
981 ctlr->accel_cal.scale[1],
982 ctlr->accel_cal.scale[2],
983 ctlr->gyro_cal.offset[0],
984 ctlr->gyro_cal.offset[1],
985 ctlr->gyro_cal.offset[2],
986 ctlr->gyro_cal.scale[0],
987 ctlr->gyro_cal.scale[1],
988 ctlr->gyro_cal.scale[2]);
993 static int joycon_set_report_mode(struct joycon_ctlr *ctlr)
1002 hid_dbg(ctlr->hdev, "setting controller report mode\n");
1003 return joycon_send_subcmd(ctlr, req, 1, HZ);
1006 static int joycon_enable_rumble(struct joycon_ctlr *ctlr)
1015 hid_dbg(ctlr->hdev, "enabling rumble\n");
1016 return joycon_send_subcmd(ctlr, req, 1, HZ/4);
1019 static int joycon_enable_imu(struct joycon_ctlr *ctlr)
1028 hid_dbg(ctlr->hdev, "enabling IMU\n");
1029 return joycon_send_subcmd(ctlr, req, 1, HZ);
1050 static void joycon_input_report_parse_imu_data(struct joycon_ctlr *ctlr,
1071 static void joycon_parse_imu_report(struct joycon_ctlr *ctlr,
1075 struct input_dev *idev = ctlr->imu_input;
1077 unsigned int last_msecs = ctlr->imu_last_pkt_ms;
1081 joycon_input_report_parse_imu_data(ctlr, rep, imu_data);
1130 if (!ctlr->imu_first_packet_received) {
1131 ctlr->imu_timestamp_us = 0;
1132 ctlr->imu_delta_samples_count = 0;
1133 ctlr->imu_delta_samples_sum = 0;
1134 ctlr->imu_avg_delta_ms = JC_IMU_DFLT_AVG_DELTA_MS;
1135 ctlr->imu_first_packet_received = true;
1142 ctlr->imu_delta_samples_sum += delta;
1143 ctlr->imu_delta_samples_count++;
1144 if (ctlr->imu_delta_samples_count >=
1146 ctlr->imu_avg_delta_ms = ctlr->imu_delta_samples_sum /
1147 ctlr->imu_delta_samples_count;
1148 ctlr->imu_delta_samples_count = 0;
1149 ctlr->imu_delta_samples_sum = 0;
1153 if (ctlr->imu_avg_delta_ms == 0) {
1154 ctlr->imu_avg_delta_ms = 1;
1155 hid_warn(ctlr->hdev, "calculated avg imu delta of 0\n");
1159 hid_dbg(ctlr->hdev,
1161 msecs, last_msecs, delta, ctlr->imu_avg_delta_ms);
1164 dropped_threshold = ctlr->imu_avg_delta_ms * 3 / 2;
1166 ctlr->imu_avg_delta_ms;
1167 ctlr->imu_timestamp_us += 1000 * ctlr->imu_avg_delta_ms;
1169 hid_warn(ctlr->hdev,
1172 hid_warn(ctlr->hdev,
1174 delta, ctlr->imu_avg_delta_ms);
1177 ctlr->imu_last_pkt_ms = msecs;
1182 ctlr->imu_timestamp_us);
1204 ctlr->gyro_cal.offset[0])),
1205 ctlr->gyro_cal.scale[0],
1206 ctlr->imu_cal_gyro_divisor[0]);
1209 ctlr->gyro_cal.offset[1])),
1210 ctlr->gyro_cal.scale[1],
1211 ctlr->imu_cal_gyro_divisor[1]);
1214 ctlr->gyro_cal.offset[2])),
1215 ctlr->gyro_cal.scale[2],
1216 ctlr->imu_cal_gyro_divisor[2]);
1219 ctlr->accel_cal.scale[0]) /
1220 ctlr->imu_cal_accel_divisor[0];
1222 ctlr->accel_cal.scale[1]) /
1223 ctlr->imu_cal_accel_divisor[1];
1225 ctlr->accel_cal.scale[2]) /
1226 ctlr->imu_cal_accel_divisor[2];
1228 hid_dbg(ctlr->hdev, "raw_gyro: g_x=%d g_y=%d g_z=%d\n",
1231 hid_dbg(ctlr->hdev, "raw_accel: a_x=%d a_y=%d a_z=%d\n",
1245 if (jc_type_is_joycon(ctlr) && jc_type_has_right(ctlr)) {
1264 ctlr->imu_timestamp_us += ctlr->imu_avg_delta_ms * 1000 / 3;
1268 static void joycon_parse_report(struct joycon_ctlr *ctlr,
1271 struct input_dev *dev = ctlr->input;
1276 unsigned long report_delta_ms = msecs - ctlr->last_input_report_msecs;
1278 spin_lock_irqsave(&ctlr->lock, flags);
1280 ctlr->ctlr_state != JOYCON_CTLR_STATE_REMOVED &&
1281 (msecs - ctlr->rumble_msecs) >= JC_RUMBLE_PERIOD_MS &&
1282 (ctlr->rumble_queue_head != ctlr->rumble_queue_tail ||
1283 ctlr->rumble_zero_countdown > 0)) {
1290 if (ctlr->rumble_zero_countdown > 0)
1291 ctlr->rumble_zero_countdown--;
1292 queue_work(ctlr->rumble_queue, &ctlr->rumble_worker);
1297 ctlr->host_powered = tmp & BIT(0);
1298 ctlr->battery_charging = tmp & BIT(4);
1302 ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1305 ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
1308 ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
1311 ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
1314 ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1317 ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
1318 hid_warn(ctlr->hdev, "Invalid battery status\n");
1321 spin_unlock_irqrestore(&ctlr->lock, flags);
1324 btns = hid_field_extract(ctlr->hdev, rep->button_status, 0, 24);
1326 if (jc_type_has_left(ctlr)) {
1333 raw_x = hid_field_extract(ctlr->hdev, rep->left_stick, 0, 12);
1334 raw_y = hid_field_extract(ctlr->hdev,
1337 x = joycon_map_stick_val(&ctlr->left_stick_cal_x, raw_x);
1338 y = -joycon_map_stick_val(&ctlr->left_stick_cal_y, raw_y);
1350 if (jc_type_is_joycon(ctlr)) {
1382 if (jc_type_has_right(ctlr)) {
1389 raw_x = hid_field_extract(ctlr->hdev, rep->right_stick, 0, 12);
1390 raw_y = hid_field_extract(ctlr->hdev,
1393 x = joycon_map_stick_val(&ctlr->right_stick_cal_x, raw_x);
1394 y = -joycon_map_stick_val(&ctlr->right_stick_cal_y, raw_y);
1402 if (jc_type_is_joycon(ctlr)) {
1418 spin_lock_irqsave(&ctlr->lock, flags);
1419 ctlr->last_input_report_msecs = msecs;
1427 if (ctlr->consecutive_valid_report_deltas < JC_SUBCMD_VALID_DELTA_REQ)
1428 ctlr->consecutive_valid_report_deltas++;
1430 ctlr->consecutive_valid_report_deltas = 0;
1438 if (ctlr->hdev->bus == BUS_USB)
1439 ctlr->consecutive_valid_report_deltas = JC_SUBCMD_VALID_DELTA_REQ;
1441 spin_unlock_irqrestore(&ctlr->lock, flags);
1448 if (unlikely(mutex_is_locked(&ctlr->output_mutex))) {
1449 spin_lock_irqsave(&ctlr->lock, flags);
1450 ctlr->received_input_report = true;
1451 spin_unlock_irqrestore(&ctlr->lock, flags);
1452 wake_up(&ctlr->wait);
1457 joycon_parse_imu_report(ctlr, rep);
1460 static int joycon_send_rumble_data(struct joycon_ctlr *ctlr)
1466 spin_lock_irqsave(&ctlr->lock, flags);
1471 if (ctlr->ctlr_state == JOYCON_CTLR_STATE_REMOVED) {
1472 spin_unlock_irqrestore(&ctlr->lock, flags);
1476 ctlr->rumble_data[ctlr->rumble_queue_tail],
1478 spin_unlock_irqrestore(&ctlr->lock, flags);
1481 rumble_output.packet_num = ctlr->subcmd_num;
1482 if (++ctlr->subcmd_num > 0xF)
1483 ctlr->subcmd_num = 0;
1485 joycon_enforce_subcmd_rate(ctlr);
1487 ret = __joycon_hid_send(ctlr->hdev, (u8 *)&rumble_output,
1494 struct joycon_ctlr *ctlr = container_of(work, struct joycon_ctlr,
1501 mutex_lock(&ctlr->output_mutex);
1502 ret = joycon_send_rumble_data(ctlr);
1503 mutex_unlock(&ctlr->output_mutex);
1506 spin_lock_irqsave(&ctlr->lock, flags);
1508 ctlr->ctlr_state != JOYCON_CTLR_STATE_REMOVED)
1509 hid_warn(ctlr->hdev, "Failed to set rumble; e=%d", ret);
1511 ctlr->rumble_msecs = jiffies_to_msecs(jiffies);
1512 if (ctlr->rumble_queue_tail != ctlr->rumble_queue_head) {
1513 if (++ctlr->rumble_queue_tail >= JC_RUMBLE_QUEUE_SIZE)
1514 ctlr->rumble_queue_tail = 0;
1518 spin_unlock_irqrestore(&ctlr->lock, flags);
1576 static void joycon_clamp_rumble_freqs(struct joycon_ctlr *ctlr)
1580 spin_lock_irqsave(&ctlr->lock, flags);
1581 ctlr->rumble_ll_freq = clamp(ctlr->rumble_ll_freq,
1584 ctlr->rumble_lh_freq = clamp(ctlr->rumble_lh_freq,
1587 ctlr->rumble_rl_freq = clamp(ctlr->rumble_rl_freq,
1590 ctlr->rumble_rh_freq = clamp(ctlr->rumble_rh_freq,
1593 spin_unlock_irqrestore(&ctlr->lock, flags);
1596 static int joycon_set_rumble(struct joycon_ctlr *ctlr, u16 amp_r, u16 amp_l,
1608 spin_lock_irqsave(&ctlr->lock, flags);
1609 freq_r_low = ctlr->rumble_rl_freq;
1610 freq_r_high = ctlr->rumble_rh_freq;
1611 freq_l_low = ctlr->rumble_ll_freq;
1612 freq_l_high = ctlr->rumble_lh_freq;
1615 ctlr->rumble_zero_countdown = JC_RUMBLE_ZERO_AMP_PKT_CNT;
1616 spin_unlock_irqrestore(&ctlr->lock, flags);
1626 spin_lock_irqsave(&ctlr->lock, flags);
1628 next_rq_head = ctlr->rumble_queue_head + 1;
1635 if (next_rq_head == ctlr->rumble_queue_tail) {
1636 hid_dbg(ctlr->hdev, "rumble queue is full");
1638 next_rq_head = ctlr->rumble_queue_head;
1641 ctlr->rumble_queue_head = next_rq_head;
1642 memcpy(ctlr->rumble_data[ctlr->rumble_queue_head], data,
1646 if (schedule_now && ctlr->ctlr_state != JOYCON_CTLR_STATE_REMOVED)
1647 queue_work(ctlr->rumble_queue, &ctlr->rumble_worker);
1649 spin_unlock_irqrestore(&ctlr->lock, flags);
1657 struct joycon_ctlr *ctlr = input_get_drvdata(dev);
1662 return joycon_set_rumble(ctlr,
1688 static int joycon_input_create(struct joycon_ctlr *ctlr)
1696 hdev = ctlr->hdev;
1704 if (jc_type_has_left(ctlr)) {
1725 ctlr->input = devm_input_allocate_device(&hdev->dev);
1726 if (!ctlr->input)
1728 ctlr->input->id.bustype = hdev->bus;
1729 ctlr->input->id.vendor = hdev->vendor;
1730 ctlr->input->id.product = hdev->product;
1731 ctlr->input->id.version = hdev->version;
1732 ctlr->input->uniq = ctlr->mac_addr_str;
1733 ctlr->input->name = name;
1734 ctlr->input->phys = hdev->phys;
1735 input_set_drvdata(ctlr->input, ctlr);
1738 if (jc_type_has_left(ctlr)) {
1739 input_set_abs_params(ctlr->input, ABS_X,
1742 input_set_abs_params(ctlr->input, ABS_Y,
1747 input_set_capability(ctlr->input, EV_KEY,
1753 input_set_capability(ctlr->input, EV_KEY,
1756 input_set_abs_params(ctlr->input, ABS_HAT0X,
1759 input_set_abs_params(ctlr->input, ABS_HAT0Y,
1764 if (jc_type_has_right(ctlr)) {
1765 input_set_abs_params(ctlr->input, ABS_RX,
1768 input_set_abs_params(ctlr->input, ABS_RY,
1773 input_set_capability(ctlr->input, EV_KEY,
1779 input_set_capability(ctlr->input, EV_KEY, BTN_TR);
1780 input_set_capability(ctlr->input, EV_KEY, BTN_TR2);
1782 input_set_capability(ctlr->input, EV_KEY, BTN_TL);
1783 input_set_capability(ctlr->input, EV_KEY, BTN_TL2);
1788 input_set_capability(ctlr->input, EV_FF, FF_RUMBLE);
1789 input_ff_create_memless(ctlr->input, NULL, joycon_play_effect);
1790 ctlr->rumble_ll_freq = JC_RUMBLE_DFLT_LOW_FREQ;
1791 ctlr->rumble_lh_freq = JC_RUMBLE_DFLT_HIGH_FREQ;
1792 ctlr->rumble_rl_freq = JC_RUMBLE_DFLT_LOW_FREQ;
1793 ctlr->rumble_rh_freq = JC_RUMBLE_DFLT_HIGH_FREQ;
1794 joycon_clamp_rumble_freqs(ctlr);
1795 joycon_set_rumble(ctlr, 0, 0, false);
1796 ctlr->rumble_msecs = jiffies_to_msecs(jiffies);
1799 ret = input_register_device(ctlr->input);
1804 ctlr->imu_input = devm_input_allocate_device(&hdev->dev);
1805 if (!ctlr->imu_input)
1808 ctlr->imu_input->id.bustype = hdev->bus;
1809 ctlr->imu_input->id.vendor = hdev->vendor;
1810 ctlr->imu_input->id.product = hdev->product;
1811 ctlr->imu_input->id.version = hdev->version;
1812 ctlr->imu_input->uniq = ctlr->mac_addr_str;
1813 ctlr->imu_input->name = imu_name;
1814 ctlr->imu_input->phys = hdev->phys;
1815 input_set_drvdata(ctlr->imu_input, ctlr);
1818 input_set_abs_params(ctlr->imu_input, ABS_X,
1821 input_set_abs_params(ctlr->imu_input, ABS_Y,
1824 input_set_abs_params(ctlr->imu_input, ABS_Z,
1827 input_abs_set_res(ctlr->imu_input, ABS_X, JC_IMU_ACCEL_RES_PER_G);
1828 input_abs_set_res(ctlr->imu_input, ABS_Y, JC_IMU_ACCEL_RES_PER_G);
1829 input_abs_set_res(ctlr->imu_input, ABS_Z, JC_IMU_ACCEL_RES_PER_G);
1831 input_set_abs_params(ctlr->imu_input, ABS_RX,
1834 input_set_abs_params(ctlr->imu_input, ABS_RY,
1837 input_set_abs_params(ctlr->imu_input, ABS_RZ,
1841 input_abs_set_res(ctlr->imu_input, ABS_RX, JC_IMU_GYRO_RES_PER_DPS);
1842 input_abs_set_res(ctlr->imu_input, ABS_RY, JC_IMU_GYRO_RES_PER_DPS);
1843 input_abs_set_res(ctlr->imu_input, ABS_RZ, JC_IMU_GYRO_RES_PER_DPS);
1845 __set_bit(EV_MSC, ctlr->imu_input->evbit);
1846 __set_bit(MSC_TIMESTAMP, ctlr->imu_input->mscbit);
1847 __set_bit(INPUT_PROP_ACCELEROMETER, ctlr->imu_input->propbit);
1849 ret = input_register_device(ctlr->imu_input);
1861 struct joycon_ctlr *ctlr;
1867 ctlr = hid_get_drvdata(hdev);
1868 if (!ctlr) {
1875 if (&ctlr->leds[num] == led)
1881 mutex_lock(&ctlr->output_mutex);
1886 val |= ctlr->leds[i].brightness << i;
1888 ret = joycon_set_player_leds(ctlr, 0, val);
1889 mutex_unlock(&ctlr->output_mutex);
1899 struct joycon_ctlr *ctlr;
1905 ctlr = hid_get_drvdata(hdev);
1906 if (!ctlr) {
1921 mutex_lock(&ctlr->output_mutex);
1922 ret = joycon_send_subcmd(ctlr, req, 5, HZ/4);
1923 mutex_unlock(&ctlr->output_mutex);
1929 static int joycon_leds_create(struct joycon_ctlr *ctlr)
1931 struct hid_device *hdev = ctlr->hdev;
1942 mutex_lock(&ctlr->output_mutex);
1943 ret = joycon_set_player_leds(ctlr, 0, 0xF >> (4 - input_num));
1945 hid_warn(ctlr->hdev, "Failed to set leds; ret=%d\n", ret);
1946 mutex_unlock(&ctlr->output_mutex);
1959 led = &ctlr->leds[i];
1980 if (jc_type_has_right(ctlr)) {
1988 led = &ctlr->home_led;
2014 struct joycon_ctlr *ctlr = power_supply_get_drvdata(supply);
2021 spin_lock_irqsave(&ctlr->lock, flags);
2022 capacity = ctlr->battery_capacity;
2023 charging = ctlr->battery_charging;
2024 powered = ctlr->host_powered;
2025 spin_unlock_irqrestore(&ctlr->lock, flags);
2060 static int joycon_power_supply_create(struct joycon_ctlr *ctlr)
2062 struct hid_device *hdev = ctlr->hdev;
2063 struct power_supply_config supply_config = { .drv_data = ctlr, };
2068 ctlr->battery_capacity = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
2071 ctlr->battery_desc.properties = joycon_battery_props;
2072 ctlr->battery_desc.num_properties =
2074 ctlr->battery_desc.get_property = joycon_battery_get_property;
2075 ctlr->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2076 ctlr->battery_desc.use_for_apm = 0;
2077 ctlr->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
2080 if (!ctlr->battery_desc.name)
2083 ctlr->battery = devm_power_supply_register(&hdev->dev,
2084 &ctlr->battery_desc,
2086 if (IS_ERR(ctlr->battery)) {
2087 ret = PTR_ERR(ctlr->battery);
2092 return power_supply_powers(ctlr->battery, &hdev->dev);
2095 static int joycon_read_info(struct joycon_ctlr *ctlr)
2104 mutex_lock(&ctlr->output_mutex);
2105 ret = joycon_send_subcmd(ctlr, &req, 0, HZ);
2106 mutex_unlock(&ctlr->output_mutex);
2108 hid_err(ctlr->hdev, "Failed to get joycon info; ret=%d\n", ret);
2112 report = (struct joycon_input_report *)ctlr->input_buf;
2115 ctlr->mac_addr[j] = report->subcmd_reply.data[i];
2117 ctlr->mac_addr_str = devm_kasprintf(&ctlr->hdev->dev, GFP_KERNEL,
2119 ctlr->mac_addr[0],
2120 ctlr->mac_addr[1],
2121 ctlr->mac_addr[2],
2122 ctlr->mac_addr[3],
2123 ctlr->mac_addr[4],
2124 ctlr->mac_addr[5]);
2125 if (!ctlr->mac_addr_str)
2127 hid_info(ctlr->hdev, "controller MAC = %s\n", ctlr->mac_addr_str);
2130 ctlr->ctlr_type = report->subcmd_reply.data[2];
2137 struct joycon_ctlr *ctlr = hid_get_drvdata(hdev);
2140 mutex_lock(&ctlr->output_mutex);
2142 if ((jc_type_is_procon(ctlr) || jc_type_is_chrggrip(ctlr)) &&
2143 !joycon_send_usb(ctlr, JC_USB_CMD_HANDSHAKE, HZ)) {
2146 ret = joycon_send_usb(ctlr, JC_USB_CMD_BAUDRATE_3M, HZ);
2152 ret = joycon_send_usb(ctlr, JC_USB_CMD_HANDSHAKE, HZ);
2161 joycon_send_usb(ctlr, JC_USB_CMD_NO_TIMEOUT, HZ/10);
2162 } else if (jc_type_is_chrggrip(ctlr)) {
2169 ret = joycon_request_calibration(ctlr);
2179 ret = joycon_request_imu_calibration(ctlr);
2189 ret = joycon_set_report_mode(ctlr);
2196 ret = joycon_enable_rumble(ctlr);
2203 ret = joycon_enable_imu(ctlr);
2210 mutex_unlock(&ctlr->output_mutex);
2215 static int joycon_ctlr_read_handler(struct joycon_ctlr *ctlr, u8 *data,
2221 joycon_parse_report(ctlr,
2228 static int joycon_ctlr_handle_event(struct joycon_ctlr *ctlr, u8 *data,
2235 if (unlikely(mutex_is_locked(&ctlr->output_mutex)) &&
2236 ctlr->msg_type != JOYCON_MSG_TYPE_NONE) {
2237 switch (ctlr->msg_type) {
2242 data[1] == ctlr->usb_ack_match)
2250 if (report->subcmd_reply.id == ctlr->subcmd_ack_match)
2258 memcpy(ctlr->input_buf, data,
2260 ctlr->msg_type = JOYCON_MSG_TYPE_NONE;
2261 ctlr->received_resp = true;
2262 wake_up(&ctlr->wait);
2269 if (ctlr->ctlr_state == JOYCON_CTLR_STATE_READ)
2270 ret = joycon_ctlr_read_handler(ctlr, data, size);
2278 struct joycon_ctlr *ctlr = hid_get_drvdata(hdev);
2283 return joycon_ctlr_handle_event(ctlr, raw_data, size);
2290 struct joycon_ctlr *ctlr;
2294 ctlr = devm_kzalloc(&hdev->dev, sizeof(*ctlr), GFP_KERNEL);
2295 if (!ctlr) {
2300 ctlr->hdev = hdev;
2301 ctlr->ctlr_state = JOYCON_CTLR_STATE_INIT;
2302 ctlr->rumble_queue_head = 0;
2303 ctlr->rumble_queue_tail = 0;
2304 hid_set_drvdata(hdev, ctlr);
2305 mutex_init(&ctlr->output_mutex);
2306 init_waitqueue_head(&ctlr->wait);
2307 spin_lock_init(&ctlr->lock);
2308 ctlr->rumble_queue = alloc_workqueue("hid-nintendo-rumble_wq",
2310 if (!ctlr->rumble_queue) {
2314 INIT_WORK(&ctlr->rumble_worker, joycon_rumble_worker);
2351 ret = joycon_read_info(ctlr);
2359 ret = joycon_leds_create(ctlr);
2366 ret = joycon_power_supply_create(ctlr);
2372 ret = joycon_input_create(ctlr);
2378 ctlr->ctlr_state = JOYCON_CTLR_STATE_READ;
2388 destroy_workqueue(ctlr->rumble_queue);
2396 struct joycon_ctlr *ctlr = hid_get_drvdata(hdev);
2402 spin_lock_irqsave(&ctlr->lock, flags);
2403 ctlr->ctlr_state = JOYCON_CTLR_STATE_REMOVED;
2404 spin_unlock_irqrestore(&ctlr->lock, flags);
2406 destroy_workqueue(ctlr->rumble_queue);