Lines Matching refs:sc
583 static void sony_set_leds(struct sony_sc *sc);
585 static inline void sony_schedule_work(struct sony_sc *sc,
592 spin_lock_irqsave(&sc->lock, flags);
593 if (!sc->defer_initialization && sc->state_worker_initialized)
594 schedule_work(&sc->state_worker);
595 spin_unlock_irqrestore(&sc->lock, flags);
598 if (sc->hotplug_worker_initialized)
599 schedule_work(&sc->hotplug_worker);
609 struct sony_sc *sc = hid_get_drvdata(hdev);
611 return snprintf(buf, PAGE_SIZE, "%i\n", sc->ds4_bt_poll_interval);
619 struct sony_sc *sc = hid_get_drvdata(hdev);
629 spin_lock_irqsave(&sc->lock, flags);
630 sc->ds4_bt_poll_interval = interval;
631 spin_unlock_irqrestore(&sc->lock, flags);
633 sony_schedule_work(sc, SONY_WORKER_STATE);
646 struct sony_sc *sc = hid_get_drvdata(hdev);
648 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->fw_version);
658 struct sony_sc *sc = hid_get_drvdata(hdev);
660 return snprintf(buf, PAGE_SIZE, "0x%04x\n", sc->hw_version);
843 struct sony_sc *sc = hid_get_drvdata(hdev);
845 if (sc->quirks & (SINO_LITE_CONTROLLER | FUTUREMAX_DANCE_MAT))
852 if ((sc->quirks & VAIO_RDESC_CONSTANT) && *rsize >= 56 &&
864 if (sc->quirks & MOTION_CONTROLLER)
867 if (sc->quirks & PS3REMOTE)
874 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) && *rsize >= 45 &&
890 static void sixaxis_parse_report(struct sony_sc *sc, u8 *rd, int size)
903 offset = (sc->quirks & MOTION_CONTROLLER) ? 12 : 30;
916 spin_lock_irqsave(&sc->lock, flags);
917 sc->cable_state = cable_state;
918 sc->battery_capacity = battery_capacity;
919 sc->battery_charging = battery_charging;
920 spin_unlock_irqrestore(&sc->lock, flags);
922 if (sc->quirks & SIXAXIS_CONTROLLER) {
927 input_report_abs(sc->sensor_dev, ABS_X, val);
931 input_report_abs(sc->sensor_dev, ABS_Y, val);
934 input_report_abs(sc->sensor_dev, ABS_Z, val);
936 input_sync(sc->sensor_dev);
940 static void dualshock4_parse_report(struct sony_sc *sc, u8 *rd, int size)
942 struct hid_input *hidinput = list_entry(sc->hdev->inputs.next,
951 int data_offset = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 2 : 0;
955 input_report_key(sc->touchpad, BTN_LEFT, rd[offset+2] & 0x2);
1011 if (!sc->timestamp_initialized) {
1012 sc->timestamp_us = ((unsigned int)timestamp * 16) / 3;
1013 sc->timestamp_initialized = true;
1017 if (sc->prev_timestamp > timestamp)
1018 delta = (U16_MAX - sc->prev_timestamp + timestamp + 1);
1020 delta = timestamp - sc->prev_timestamp;
1021 sc->timestamp_us += (delta * 16) / 3;
1023 sc->prev_timestamp = timestamp;
1024 input_event(sc->sensor_dev, EV_MSC, MSC_TIMESTAMP, sc->timestamp_us);
1030 struct ds4_calibration_data *calib = &sc->ds4_calib_data[n];
1041 input_report_abs(sc->sensor_dev, calib->abs_code, calib_data);
1044 input_sync(sc->sensor_dev);
1071 spin_lock_irqsave(&sc->lock, flags);
1072 sc->cable_state = cable_state;
1073 sc->battery_capacity = battery_capacity;
1074 sc->battery_charging = battery_charging;
1075 spin_unlock_irqrestore(&sc->lock, flags);
1084 max_touch_data = (sc->quirks & DUALSHOCK4_CONTROLLER_BT) ? 4 : 3;
1111 input_mt_slot(sc->touchpad, n);
1112 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active);
1115 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1116 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y, y);
1121 input_mt_sync_frame(sc->touchpad);
1122 input_sync(sc->touchpad);
1126 static void nsg_mrxu_parse_report(struct sony_sc *sc, u8 *rd, int size)
1151 input_report_key(sc->touchpad, BTN_LEFT, rd[offset] & 0x0F);
1165 input_mt_slot(sc->touchpad, n);
1166 input_mt_report_slot_state(sc->touchpad, MT_TOOL_FINGER, active & 0x03);
1171 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1173 input_report_abs(sc->touchpad, ABS_MT_TOUCH_MINOR,
1175 input_report_abs(sc->touchpad, ABS_MT_ORIENTATION,
1177 input_report_abs(sc->touchpad, ABS_MT_POSITION_X, x);
1178 input_report_abs(sc->touchpad, ABS_MT_POSITION_Y,
1186 input_report_rel(sc->touchpad, REL_X, relx);
1187 input_report_rel(sc->touchpad, REL_Y, rely);
1195 input_mt_sync_frame(sc->touchpad);
1197 input_sync(sc->touchpad);
1203 struct sony_sc *sc = hid_get_drvdata(hdev);
1209 if ((sc->quirks & SIXAXIS_CONTROLLER) && rd[0] == 0x01 && size == 49) {
1226 sixaxis_parse_report(sc, rd, size);
1227 } else if ((sc->quirks & MOTION_CONTROLLER_BT) && rd[0] == 0x01 && size == 49) {
1228 sixaxis_parse_report(sc, rd, size);
1229 } else if ((sc->quirks & NAVIGATION_CONTROLLER) && rd[0] == 0x01 &&
1231 sixaxis_parse_report(sc, rd, size);
1232 } else if ((sc->quirks & DUALSHOCK4_CONTROLLER_USB) && rd[0] == 0x01 &&
1234 dualshock4_parse_report(sc, rd, size);
1235 } else if (((sc->quirks & DUALSHOCK4_CONTROLLER_BT) && rd[0] == 0x11 &&
1246 hid_dbg(sc->hdev, "DualShock 4 input report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1251 dualshock4_parse_report(sc, rd, size);
1252 } else if ((sc->quirks & DUALSHOCK4_DONGLE) && rd[0] == 0x01 &&
1264 spin_lock_irqsave(&sc->lock, flags);
1265 dongle_state = sc->ds4_dongle_state;
1266 spin_unlock_irqrestore(&sc->lock, flags);
1277 hid_info(sc->hdev, "DualShock 4 USB dongle: controller connected\n");
1278 sony_set_leds(sc);
1280 spin_lock_irqsave(&sc->lock, flags);
1281 sc->ds4_dongle_state = DONGLE_CALIBRATING;
1282 spin_unlock_irqrestore(&sc->lock, flags);
1284 sony_schedule_work(sc, SONY_WORKER_HOTPLUG);
1292 hid_info(sc->hdev, "DualShock 4 USB dongle: controller disconnected\n");
1294 spin_lock_irqsave(&sc->lock, flags);
1295 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
1296 spin_unlock_irqrestore(&sc->lock, flags);
1307 dualshock4_parse_report(sc, rd, size);
1309 } else if ((sc->quirks & NSG_MRXU_REMOTE) && rd[0] == 0x02) {
1310 nsg_mrxu_parse_report(sc, rd, size);
1314 if (sc->defer_initialization) {
1315 sc->defer_initialization = 0;
1316 sony_schedule_work(sc, SONY_WORKER_STATE);
1326 struct sony_sc *sc = hid_get_drvdata(hdev);
1328 if (sc->quirks & BUZZ_CONTROLLER) {
1351 if (sc->quirks & PS3REMOTE)
1354 if (sc->quirks & NAVIGATION_CONTROLLER)
1357 if (sc->quirks & SIXAXIS_CONTROLLER)
1360 if (sc->quirks & DUALSHOCK4_CONTROLLER)
1368 static int sony_register_touchpad(struct sony_sc *sc, int touch_count,
1375 sc->touchpad = devm_input_allocate_device(&sc->hdev->dev);
1376 if (!sc->touchpad)
1379 input_set_drvdata(sc->touchpad, sc);
1380 sc->touchpad->dev.parent = &sc->hdev->dev;
1381 sc->touchpad->phys = sc->hdev->phys;
1382 sc->touchpad->uniq = sc->hdev->uniq;
1383 sc->touchpad->id.bustype = sc->hdev->bus;
1384 sc->touchpad->id.vendor = sc->hdev->vendor;
1385 sc->touchpad->id.product = sc->hdev->product;
1386 sc->touchpad->id.version = sc->hdev->version;
1391 name_sz = strlen(sc->hdev->name) + sizeof(DS4_TOUCHPAD_SUFFIX);
1392 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1395 snprintf(name, name_sz, "%s" DS4_TOUCHPAD_SUFFIX, sc->hdev->name);
1396 sc->touchpad->name = name;
1399 __set_bit(EV_KEY, sc->touchpad->evbit);
1400 __set_bit(BTN_LEFT, sc->touchpad->keybit);
1401 __set_bit(INPUT_PROP_BUTTONPAD, sc->touchpad->propbit);
1403 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_X, 0, w, 0, 0);
1404 input_set_abs_params(sc->touchpad, ABS_MT_POSITION_Y, 0, h, 0, 0);
1407 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MAJOR,
1410 input_set_abs_params(sc->touchpad, ABS_MT_TOUCH_MINOR,
1413 input_set_abs_params(sc->touchpad, ABS_MT_ORIENTATION,
1417 if (sc->quirks & NSG_MRXU_REMOTE) {
1418 __set_bit(EV_REL, sc->touchpad->evbit);
1421 ret = input_mt_init_slots(sc->touchpad, touch_count, INPUT_MT_POINTER);
1425 ret = input_register_device(sc->touchpad);
1432 static int sony_register_sensors(struct sony_sc *sc)
1439 sc->sensor_dev = devm_input_allocate_device(&sc->hdev->dev);
1440 if (!sc->sensor_dev)
1443 input_set_drvdata(sc->sensor_dev, sc);
1444 sc->sensor_dev->dev.parent = &sc->hdev->dev;
1445 sc->sensor_dev->phys = sc->hdev->phys;
1446 sc->sensor_dev->uniq = sc->hdev->uniq;
1447 sc->sensor_dev->id.bustype = sc->hdev->bus;
1448 sc->sensor_dev->id.vendor = sc->hdev->vendor;
1449 sc->sensor_dev->id.product = sc->hdev->product;
1450 sc->sensor_dev->id.version = sc->hdev->version;
1455 name_sz = strlen(sc->hdev->name) + sizeof(SENSOR_SUFFIX);
1456 name = devm_kzalloc(&sc->hdev->dev, name_sz, GFP_KERNEL);
1459 snprintf(name, name_sz, "%s" SENSOR_SUFFIX, sc->hdev->name);
1460 sc->sensor_dev->name = name;
1462 if (sc->quirks & SIXAXIS_CONTROLLER) {
1469 input_set_abs_params(sc->sensor_dev, ABS_X, -512, 511, 4, 0);
1470 input_set_abs_params(sc->sensor_dev, ABS_Y, -512, 511, 4, 0);
1471 input_set_abs_params(sc->sensor_dev, ABS_Z, -512, 511, 4, 0);
1472 input_abs_set_res(sc->sensor_dev, ABS_X, SIXAXIS_ACC_RES_PER_G);
1473 input_abs_set_res(sc->sensor_dev, ABS_Y, SIXAXIS_ACC_RES_PER_G);
1474 input_abs_set_res(sc->sensor_dev, ABS_Z, SIXAXIS_ACC_RES_PER_G);
1475 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1477 input_set_abs_params(sc->sensor_dev, ABS_X, -range, range, 16, 0);
1478 input_set_abs_params(sc->sensor_dev, ABS_Y, -range, range, 16, 0);
1479 input_set_abs_params(sc->sensor_dev, ABS_Z, -range, range, 16, 0);
1480 input_abs_set_res(sc->sensor_dev, ABS_X, DS4_ACC_RES_PER_G);
1481 input_abs_set_res(sc->sensor_dev, ABS_Y, DS4_ACC_RES_PER_G);
1482 input_abs_set_res(sc->sensor_dev, ABS_Z, DS4_ACC_RES_PER_G);
1485 input_set_abs_params(sc->sensor_dev, ABS_RX, -range, range, 16, 0);
1486 input_set_abs_params(sc->sensor_dev, ABS_RY, -range, range, 16, 0);
1487 input_set_abs_params(sc->sensor_dev, ABS_RZ, -range, range, 16, 0);
1488 input_abs_set_res(sc->sensor_dev, ABS_RX, DS4_GYRO_RES_PER_DEG_S);
1489 input_abs_set_res(sc->sensor_dev, ABS_RY, DS4_GYRO_RES_PER_DEG_S);
1490 input_abs_set_res(sc->sensor_dev, ABS_RZ, DS4_GYRO_RES_PER_DEG_S);
1492 __set_bit(EV_MSC, sc->sensor_dev->evbit);
1493 __set_bit(MSC_TIMESTAMP, sc->sensor_dev->mscbit);
1496 __set_bit(INPUT_PROP_ACCELEROMETER, sc->sensor_dev->propbit);
1498 ret = input_register_device(sc->sensor_dev);
1512 struct sony_sc *sc = hid_get_drvdata(hdev);
1544 if (sc->quirks & SHANWAN_GAMEPAD)
1581 static int dualshock4_get_calibration_data(struct sony_sc *sc)
1599 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
1604 ret = hid_hw_raw_request(sc->hdev, 0x02, buf,
1621 ret = hid_hw_raw_request(sc->hdev, 0x05, buf,
1633 hid_warn(sc->hdev, "DualShock 4 calibration report's CRC check failed, received crc 0x%0x != 0x%0x\n",
1636 hid_warn(sc->hdev, "Retrying DualShock 4 get calibration report request\n");
1651 if (sc->quirks & DUALSHOCK4_CONTROLLER_USB) {
1680 sc->ds4_calib_data[0].abs_code = ABS_RX;
1681 sc->ds4_calib_data[0].bias = gyro_pitch_bias;
1682 sc->ds4_calib_data[0].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1683 sc->ds4_calib_data[0].sens_denom = gyro_pitch_plus - gyro_pitch_minus;
1685 sc->ds4_calib_data[1].abs_code = ABS_RY;
1686 sc->ds4_calib_data[1].bias = gyro_yaw_bias;
1687 sc->ds4_calib_data[1].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1688 sc->ds4_calib_data[1].sens_denom = gyro_yaw_plus - gyro_yaw_minus;
1690 sc->ds4_calib_data[2].abs_code = ABS_RZ;
1691 sc->ds4_calib_data[2].bias = gyro_roll_bias;
1692 sc->ds4_calib_data[2].sens_numer = speed_2x*DS4_GYRO_RES_PER_DEG_S;
1693 sc->ds4_calib_data[2].sens_denom = gyro_roll_plus - gyro_roll_minus;
1699 sc->ds4_calib_data[3].abs_code = ABS_X;
1700 sc->ds4_calib_data[3].bias = acc_x_plus - range_2g / 2;
1701 sc->ds4_calib_data[3].sens_numer = 2*DS4_ACC_RES_PER_G;
1702 sc->ds4_calib_data[3].sens_denom = range_2g;
1705 sc->ds4_calib_data[4].abs_code = ABS_Y;
1706 sc->ds4_calib_data[4].bias = acc_y_plus - range_2g / 2;
1707 sc->ds4_calib_data[4].sens_numer = 2*DS4_ACC_RES_PER_G;
1708 sc->ds4_calib_data[4].sens_denom = range_2g;
1711 sc->ds4_calib_data[5].abs_code = ABS_Z;
1712 sc->ds4_calib_data[5].bias = acc_z_plus - range_2g / 2;
1713 sc->ds4_calib_data[5].sens_numer = 2*DS4_ACC_RES_PER_G;
1714 sc->ds4_calib_data[5].sens_denom = range_2g;
1723 struct sony_sc *sc = container_of(work, struct sony_sc, hotplug_worker);
1728 ret = dualshock4_get_calibration_data(sc);
1736 hid_err(sc->hdev, "DualShock 4 USB dongle: calibration failed, disabling device\n");
1739 hid_info(sc->hdev, "DualShock 4 USB dongle: calibration completed\n");
1743 spin_lock_irqsave(&sc->lock, flags);
1744 sc->ds4_dongle_state = dongle_state;
1745 spin_unlock_irqrestore(&sc->lock, flags);
1748 static int dualshock4_get_version_info(struct sony_sc *sc)
1757 ret = hid_hw_raw_request(sc->hdev, 0xA3, buf,
1766 sc->hw_version = get_unaligned_le16(&buf[35]);
1767 sc->fw_version = get_unaligned_le16(&buf[41]);
1773 static void sixaxis_set_leds_from_id(struct sony_sc *sc)
1788 int id = sc->device_id;
1796 memcpy(sc->led_state, sixaxis_leds[id], sizeof(sixaxis_leds[id]));
1799 static void dualshock4_set_leds_from_id(struct sony_sc *sc)
1812 int id = sc->device_id;
1820 memcpy(sc->led_state, color_code[id], sizeof(color_code[id]));
1823 static void buzz_set_leds(struct sony_sc *sc)
1825 struct hid_device *hdev = sc->hdev;
1835 value[1] = sc->led_state[0] ? 0xff : 0x00;
1836 value[2] = sc->led_state[1] ? 0xff : 0x00;
1837 value[3] = sc->led_state[2] ? 0xff : 0x00;
1838 value[4] = sc->led_state[3] ? 0xff : 0x00;
1844 static void sony_set_leds(struct sony_sc *sc)
1846 if (!(sc->quirks & BUZZ_CONTROLLER))
1847 sony_schedule_work(sc, SONY_WORKER_STATE);
1849 buzz_set_leds(sc);
1964 static int sony_leds_init(struct sony_sc *sc)
1966 struct hid_device *hdev = sc->hdev;
1979 BUG_ON(!(sc->quirks & SONY_LED_SUPPORT));
1981 if (sc->quirks & BUZZ_CONTROLLER) {
1982 sc->led_count = 4;
1989 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
1990 dualshock4_set_leds_from_id(sc);
1991 sc->led_state[3] = 1;
1992 sc->led_count = 4;
1998 } else if (sc->quirks & MOTION_CONTROLLER) {
1999 sc->led_count = 3;
2004 } else if (sc->quirks & NAVIGATION_CONTROLLER) {
2007 memcpy(sc->led_state, navigation_leds, sizeof(navigation_leds));
2008 sc->led_count = 1;
2014 sixaxis_set_leds_from_id(sc);
2015 sc->led_count = 4;
2027 sony_set_leds(sc);
2031 for (n = 0; n < sc->led_count; n++) {
2049 led->brightness = sc->led_state[n];
2058 sc->leds[n] = led;
2070 static void sixaxis_send_output_report(struct sony_sc *sc)
2085 (struct sixaxis_output_report *)sc->output_report_dmabuf;
2092 report->rumble.right_motor_on = sc->right ? 1 : 0;
2093 report->rumble.left_motor_force = sc->left;
2096 report->leds_bitmap |= sc->led_state[0] << 1;
2097 report->leds_bitmap |= sc->led_state[1] << 2;
2098 report->leds_bitmap |= sc->led_state[2] << 3;
2099 report->leds_bitmap |= sc->led_state[3] << 4;
2115 if (sc->led_delay_on[n] || sc->led_delay_off[n]) {
2116 report->led[3 - n].duty_off = sc->led_delay_off[n];
2117 report->led[3 - n].duty_on = sc->led_delay_on[n];
2122 if (sc->quirks & SHANWAN_GAMEPAD)
2123 hid_hw_output_report(sc->hdev, (u8 *)report,
2126 hid_hw_raw_request(sc->hdev, report->report_id, (u8 *)report,
2131 static void dualshock4_send_output_report(struct sony_sc *sc)
2133 struct hid_device *hdev = sc->hdev;
2134 u8 *buf = sc->output_report_dmabuf;
2146 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2154 buf[1] = 0xC0 /* HID + CRC */ | sc->ds4_bt_poll_interval;
2160 buf[offset++] = sc->right;
2161 buf[offset++] = sc->left;
2167 if (sc->led_state[3]) {
2168 buf[offset++] = sc->led_state[0];
2169 buf[offset++] = sc->led_state[1];
2170 buf[offset++] = sc->led_state[2];
2176 buf[offset++] = sc->led_delay_on[3];
2177 buf[offset++] = sc->led_delay_off[3];
2179 if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2193 static void motion_send_output_report(struct sony_sc *sc)
2195 struct hid_device *hdev = sc->hdev;
2197 (struct motion_output_report_02 *)sc->output_report_dmabuf;
2202 report->r = sc->led_state[0];
2203 report->g = sc->led_state[1];
2204 report->b = sc->led_state[2];
2207 report->rumble = max(sc->right, sc->left);
2213 static inline void sony_send_output_report(struct sony_sc *sc)
2215 if (sc->send_output_report)
2216 sc->send_output_report(sc);
2221 struct sony_sc *sc = container_of(work, struct sony_sc, state_worker);
2223 sc->send_output_report(sc);
2226 static int sony_allocate_output_report(struct sony_sc *sc)
2228 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2229 (sc->quirks & NAVIGATION_CONTROLLER))
2230 sc->output_report_dmabuf =
2231 devm_kmalloc(&sc->hdev->dev,
2234 else if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2235 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2238 else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE))
2239 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2242 else if (sc->quirks & MOTION_CONTROLLER)
2243 sc->output_report_dmabuf = devm_kmalloc(&sc->hdev->dev,
2249 if (!sc->output_report_dmabuf)
2260 struct sony_sc *sc = hid_get_drvdata(hid);
2265 sc->left = effect->u.rumble.strong_magnitude / 256;
2266 sc->right = effect->u.rumble.weak_magnitude / 256;
2268 sony_schedule_work(sc, SONY_WORKER_STATE);
2272 static int sony_init_ff(struct sony_sc *sc)
2277 if (list_empty(&sc->hdev->inputs)) {
2278 hid_err(sc->hdev, "no inputs found\n");
2281 hidinput = list_entry(sc->hdev->inputs.next, struct hid_input, list);
2289 static int sony_init_ff(struct sony_sc *sc)
2300 struct sony_sc *sc = power_supply_get_drvdata(psy);
2305 spin_lock_irqsave(&sc->lock, flags);
2306 battery_charging = sc->battery_charging;
2307 battery_capacity = sc->battery_capacity;
2308 cable_state = sc->cable_state;
2309 spin_unlock_irqrestore(&sc->lock, flags);
2337 static int sony_battery_probe(struct sony_sc *sc, int append_dev_id)
2342 struct power_supply_config psy_cfg = { .drv_data = sc, };
2343 struct hid_device *hdev = sc->hdev;
2350 sc->battery_capacity = 100;
2352 sc->battery_desc.properties = sony_battery_props;
2353 sc->battery_desc.num_properties = ARRAY_SIZE(sony_battery_props);
2354 sc->battery_desc.get_property = sony_battery_get_property;
2355 sc->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
2356 sc->battery_desc.use_for_apm = 0;
2357 sc->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
2358 battery_str_fmt, sc->mac_address, sc->device_id);
2359 if (!sc->battery_desc.name)
2362 sc->battery = devm_power_supply_register(&hdev->dev, &sc->battery_desc,
2364 if (IS_ERR(sc->battery)) {
2365 ret = PTR_ERR(sc->battery);
2370 power_supply_powers(sc->battery, &hdev->dev);
2394 static int sony_check_add_dev_list(struct sony_sc *sc)
2403 ret = memcmp(sc->mac_address, entry->mac_address,
2404 sizeof(sc->mac_address));
2406 if (sony_compare_connection_type(sc, entry)) {
2410 hid_info(sc->hdev,
2412 sc->mac_address);
2419 list_add(&(sc->list_node), &sony_device_list);
2426 static void sony_remove_dev_list(struct sony_sc *sc)
2430 if (sc->list_node.next) {
2432 list_del(&(sc->list_node));
2437 static int sony_get_bt_devaddr(struct sony_sc *sc)
2442 ret = strlen(sc->hdev->uniq);
2446 ret = sscanf(sc->hdev->uniq,
2448 &sc->mac_address[5], &sc->mac_address[4], &sc->mac_address[3],
2449 &sc->mac_address[2], &sc->mac_address[1], &sc->mac_address[0]);
2457 static int sony_check_add(struct sony_sc *sc)
2462 if ((sc->quirks & DUALSHOCK4_CONTROLLER_BT) ||
2463 (sc->quirks & MOTION_CONTROLLER_BT) ||
2464 (sc->quirks & NAVIGATION_CONTROLLER_BT) ||
2465 (sc->quirks & SIXAXIS_CONTROLLER_BT)) {
2472 if (sony_get_bt_devaddr(sc) < 0) {
2473 hid_warn(sc->hdev, "UNIQ does not contain a MAC address; duplicate check skipped\n");
2476 } else if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) {
2486 ret = hid_hw_raw_request(sc->hdev, 0x81, buf,
2491 hid_err(sc->hdev, "failed to retrieve feature report 0x81 with the DualShock 4 MAC address\n");
2496 memcpy(sc->mac_address, &buf[1], sizeof(sc->mac_address));
2498 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2499 "%pMR", sc->mac_address);
2500 } else if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2501 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2511 ret = hid_hw_raw_request(sc->hdev, 0xf2, buf,
2516 hid_err(sc->hdev, "failed to retrieve feature report 0xf2 with the Sixaxis MAC address\n");
2526 sc->mac_address[5-n] = buf[4+n];
2528 snprintf(sc->hdev->uniq, sizeof(sc->hdev->uniq),
2529 "%pMR", sc->mac_address);
2534 ret = sony_check_add_dev_list(sc);
2543 static int sony_set_device_id(struct sony_sc *sc)
2551 if ((sc->quirks & SIXAXIS_CONTROLLER) ||
2552 (sc->quirks & DUALSHOCK4_CONTROLLER)) {
2556 sc->device_id = -1;
2559 sc->device_id = ret;
2561 sc->device_id = -1;
2567 static void sony_release_device_id(struct sony_sc *sc)
2569 if (sc->device_id >= 0) {
2570 ida_simple_remove(&sony_device_id_allocator, sc->device_id);
2571 sc->device_id = -1;
2575 static inline void sony_init_output_report(struct sony_sc *sc,
2578 sc->send_output_report = send_output_report;
2580 if (!sc->state_worker_initialized)
2581 INIT_WORK(&sc->state_worker, sony_state_worker);
2583 sc->state_worker_initialized = 1;
2586 static inline void sony_cancel_work_sync(struct sony_sc *sc)
2590 if (sc->hotplug_worker_initialized)
2591 cancel_work_sync(&sc->hotplug_worker);
2592 if (sc->state_worker_initialized) {
2593 spin_lock_irqsave(&sc->lock, flags);
2594 sc->state_worker_initialized = 0;
2595 spin_unlock_irqrestore(&sc->lock, flags);
2596 cancel_work_sync(&sc->state_worker);
2603 struct sony_sc *sc = hid_get_drvdata(hdev);
2607 ret = sony_set_device_id(sc);
2613 ret = append_dev_id = sony_check_add(sc);
2617 ret = sony_allocate_output_report(sc);
2623 if (sc->quirks & NAVIGATION_CONTROLLER_USB) {
2642 sc->defer_initialization = 1;
2650 sony_init_output_report(sc, sixaxis_send_output_report);
2651 } else if (sc->quirks & NAVIGATION_CONTROLLER_BT) {
2664 sony_init_output_report(sc, sixaxis_send_output_report);
2665 } else if (sc->quirks & SIXAXIS_CONTROLLER_USB) {
2674 sc->defer_initialization = 1;
2682 ret = sony_register_sensors(sc);
2684 hid_err(sc->hdev,
2689 sony_init_output_report(sc, sixaxis_send_output_report);
2690 } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
2703 ret = sony_register_sensors(sc);
2705 hid_err(sc->hdev,
2710 sony_init_output_report(sc, sixaxis_send_output_report);
2711 } else if (sc->quirks & DUALSHOCK4_CONTROLLER) {
2712 ret = dualshock4_get_calibration_data(sc);
2718 ret = dualshock4_get_version_info(sc);
2720 hid_err(sc->hdev, "Failed to get version data from Dualshock 4\n");
2724 ret = device_create_file(&sc->hdev->dev, &dev_attr_firmware_version);
2727 sc->fw_version = 0;
2728 sc->hw_version = 0;
2729 hid_err(sc->hdev, "can't create sysfs firmware_version attribute err: %d\n", ret);
2733 ret = device_create_file(&sc->hdev->dev, &dev_attr_hardware_version);
2735 sc->hw_version = 0;
2736 hid_err(sc->hdev, "can't create sysfs hardware_version attribute err: %d\n", ret);
2744 ret = sony_register_touchpad(sc, 2, 1920, 942, 0, 0, 0);
2746 hid_err(sc->hdev,
2752 ret = sony_register_sensors(sc);
2754 hid_err(sc->hdev,
2759 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT) {
2760 sc->ds4_bt_poll_interval = DS4_BT_DEFAULT_POLL_INTERVAL_MS;
2761 ret = device_create_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2763 hid_warn(sc->hdev,
2768 if (sc->quirks & DUALSHOCK4_DONGLE) {
2769 INIT_WORK(&sc->hotplug_worker, dualshock4_calibration_work);
2770 sc->hotplug_worker_initialized = 1;
2771 sc->ds4_dongle_state = DONGLE_DISCONNECTED;
2774 sony_init_output_report(sc, dualshock4_send_output_report);
2775 } else if (sc->quirks & NSG_MRXU_REMOTE) {
2780 ret = sony_register_touchpad(sc, 2,
2783 hid_err(sc->hdev,
2789 } else if (sc->quirks & MOTION_CONTROLLER) {
2790 sony_init_output_report(sc, motion_send_output_report);
2795 if (sc->quirks & SONY_LED_SUPPORT) {
2796 ret = sony_leds_init(sc);
2801 if (sc->quirks & SONY_BATTERY_SUPPORT) {
2802 ret = sony_battery_probe(sc, append_dev_id);
2814 if (sc->quirks & SONY_FF_SUPPORT) {
2815 ret = sony_init_ff(sc);
2828 if (sc->ds4_bt_poll_interval)
2829 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2830 if (sc->fw_version)
2831 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2832 if (sc->hw_version)
2833 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2834 sony_cancel_work_sync(sc);
2835 sony_remove_dev_list(sc);
2836 sony_release_device_id(sc);
2844 struct sony_sc *sc;
2853 sc = devm_kzalloc(&hdev->dev, sizeof(*sc), GFP_KERNEL);
2854 if (sc == NULL) {
2859 spin_lock_init(&sc->lock);
2861 sc->quirks = quirks;
2862 hid_set_drvdata(hdev, sc);
2863 sc->hdev = hdev;
2871 if (sc->quirks & VAIO_RDESC_CONSTANT)
2873 else if (sc->quirks & SIXAXIS_CONTROLLER)
2882 if (sc->quirks & (SIXAXIS_CONTROLLER | DUALSHOCK4_CONTROLLER))
2910 struct sony_sc *sc = hid_get_drvdata(hdev);
2914 if (sc->quirks & DUALSHOCK4_CONTROLLER_BT)
2915 device_remove_file(&sc->hdev->dev, &dev_attr_bt_poll_interval);
2917 if (sc->fw_version)
2918 device_remove_file(&sc->hdev->dev, &dev_attr_firmware_version);
2920 if (sc->hw_version)
2921 device_remove_file(&sc->hdev->dev, &dev_attr_hardware_version);
2923 sony_cancel_work_sync(sc);
2925 sony_remove_dev_list(sc);
2927 sony_release_device_id(sc);
2940 struct sony_sc *sc = hid_get_drvdata(hdev);
2942 sc->left = sc->right = 0;
2943 sony_send_output_report(sc);
2952 struct sony_sc *sc = hid_get_drvdata(hdev);
2958 if ((sc->quirks & SIXAXIS_CONTROLLER_USB) ||
2959 (sc->quirks & NAVIGATION_CONTROLLER_USB)) {
2960 sixaxis_set_operational_usb(sc->hdev);
2961 sc->defer_initialization = 1;