Lines Matching defs:steam
129 static int steam_recv_report(struct steam_device *steam,
136 r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0];
138 hid_err(steam->hdev, "No HID_FEATURE_REPORT submitted - nothing to read\n");
155 ret = hid_hw_raw_request(steam->hdev, 0x00,
164 static int steam_send_report(struct steam_device *steam,
172 r = steam->hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[0];
174 hid_err(steam->hdev, "No HID_FEATURE_REPORT submitted - nothing to read\n");
195 ret = hid_hw_raw_request(steam->hdev, 0,
205 hid_err(steam->hdev, "%s: error %d (%*ph)\n", __func__,
210 static inline int steam_send_report_byte(struct steam_device *steam, u8 cmd)
212 return steam_send_report(steam, &cmd, 1);
215 static int steam_write_registers(struct steam_device *steam,
224 va_start(args, steam);
237 return steam_send_report(steam, cmd, 2 + cmd[1]);
240 static int steam_get_serial(struct steam_device *steam)
250 ret = steam_send_report(steam, cmd, sizeof(cmd));
253 ret = steam_recv_report(steam, reply, sizeof(reply));
259 strlcpy(steam->serial_no, reply + 3, sizeof(steam->serial_no));
268 static inline int steam_request_conn_status(struct steam_device *steam)
270 return steam_send_report_byte(steam, STEAM_CMD_REQUEST_COMM_STATUS);
273 static void steam_set_lizard_mode(struct steam_device *steam, bool enable)
277 steam_send_report_byte(steam, STEAM_CMD_DEFAULT_MAPPINGS);
279 steam_send_report_byte(steam, STEAM_CMD_DEFAULT_MOUSE);
280 steam_write_registers(steam,
285 steam_send_report_byte(steam, STEAM_CMD_CLEAR_MAPPINGS);
286 steam_write_registers(steam,
295 struct steam_device *steam = input_get_drvdata(dev);
297 mutex_lock(&steam->mutex);
298 if (!steam->client_opened && lizard_mode)
299 steam_set_lizard_mode(steam, false);
300 mutex_unlock(&steam->mutex);
306 struct steam_device *steam = input_get_drvdata(dev);
308 mutex_lock(&steam->mutex);
309 if (!steam->client_opened && lizard_mode)
310 steam_set_lizard_mode(steam, true);
311 mutex_unlock(&steam->mutex);
325 struct steam_device *steam = power_supply_get_drvdata(psy);
331 spin_lock_irqsave(&steam->lock, flags);
332 volts = steam->voltage;
333 batt = steam->battery_charge;
334 spin_unlock_irqrestore(&steam->lock, flags);
356 static int steam_battery_register(struct steam_device *steam)
359 struct power_supply_config battery_cfg = { .drv_data = steam, };
363 steam->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
364 steam->battery_desc.properties = steam_battery_props;
365 steam->battery_desc.num_properties = ARRAY_SIZE(steam_battery_props);
366 steam->battery_desc.get_property = steam_battery_get_property;
367 steam->battery_desc.name = devm_kasprintf(&steam->hdev->dev,
368 GFP_KERNEL, "steam-controller-%s-battery",
369 steam->serial_no);
370 if (!steam->battery_desc.name)
374 spin_lock_irqsave(&steam->lock, flags);
375 steam->voltage = 3000;
376 steam->battery_charge = 100;
377 spin_unlock_irqrestore(&steam->lock, flags);
379 battery = power_supply_register(&steam->hdev->dev,
380 &steam->battery_desc, &battery_cfg);
383 hid_err(steam->hdev,
388 rcu_assign_pointer(steam->battery, battery);
389 power_supply_powers(battery, &steam->hdev->dev);
393 static int steam_input_register(struct steam_device *steam)
395 struct hid_device *hdev = steam->hdev;
400 input = rcu_dereference(steam->input);
411 input_set_drvdata(input, steam);
416 input->name = (steam->quirks & STEAM_QUIRK_WIRELESS) ?
420 input->uniq = steam->serial_no;
473 rcu_assign_pointer(steam->input, input);
481 static void steam_input_unregister(struct steam_device *steam)
485 input = rcu_dereference(steam->input);
489 RCU_INIT_POINTER(steam->input, NULL);
494 static void steam_battery_unregister(struct steam_device *steam)
499 battery = rcu_dereference(steam->battery);
504 RCU_INIT_POINTER(steam->battery, NULL);
509 static int steam_register(struct steam_device *steam)
520 if (!steam->serial_no[0]) {
525 mutex_lock(&steam->mutex);
526 if (steam_get_serial(steam) < 0)
527 strlcpy(steam->serial_no, "XXXXXXXXXX",
528 sizeof(steam->serial_no));
529 mutex_unlock(&steam->mutex);
531 hid_info(steam->hdev, "Steam Controller '%s' connected",
532 steam->serial_no);
535 if (steam->quirks & STEAM_QUIRK_WIRELESS)
536 steam_battery_register(steam);
539 if (list_empty(&steam->list))
540 list_add(&steam->list, &steam_devices);
544 mutex_lock(&steam->mutex);
545 client_opened = steam->client_opened;
547 steam_set_lizard_mode(steam, lizard_mode);
548 mutex_unlock(&steam->mutex);
551 ret = steam_input_register(steam);
558 static void steam_unregister(struct steam_device *steam)
560 steam_battery_unregister(steam);
561 steam_input_unregister(steam);
562 if (steam->serial_no[0]) {
563 hid_info(steam->hdev, "Steam Controller '%s' disconnected",
564 steam->serial_no);
566 list_del_init(&steam->list);
568 steam->serial_no[0] = 0;
574 struct steam_device *steam = container_of(work, struct steam_device,
580 spin_lock_irqsave(&steam->lock, flags);
581 connected = steam->connected;
582 spin_unlock_irqrestore(&steam->lock, flags);
585 ret = steam_register(steam);
587 hid_err(steam->hdev,
592 steam_unregister(steam);
617 struct steam_device *steam = hdev->driver_data;
619 return hid_parse_report(hdev, steam->hdev->dev_rdesc,
620 steam->hdev->dev_rsize);
634 struct steam_device *steam = hdev->driver_data;
636 mutex_lock(&steam->mutex);
637 steam->client_opened = true;
638 mutex_unlock(&steam->mutex);
640 steam_input_unregister(steam);
647 struct steam_device *steam = hdev->driver_data;
652 spin_lock_irqsave(&steam->lock, flags);
653 connected = steam->connected;
654 spin_unlock_irqrestore(&steam->lock, flags);
656 mutex_lock(&steam->mutex);
657 steam->client_opened = false;
659 steam_set_lizard_mode(steam, lizard_mode);
660 mutex_unlock(&steam->mutex);
663 steam_input_register(steam);
671 struct steam_device *steam = hdev->driver_data;
673 return hid_hw_raw_request(steam->hdev, reportnum, buf, count,
718 struct steam_device *steam;
741 steam = devm_kzalloc(&hdev->dev, sizeof(*steam), GFP_KERNEL);
742 if (!steam) {
746 steam->hdev = hdev;
747 hid_set_drvdata(hdev, steam);
748 spin_lock_init(&steam->lock);
749 mutex_init(&steam->mutex);
750 steam->quirks = id->driver_data;
751 INIT_WORK(&steam->work_connect, steam_work_connect_cb);
752 INIT_LIST_HEAD(&steam->list);
754 steam->client_hdev = steam_create_client_hid(hdev);
755 if (IS_ERR(steam->client_hdev)) {
756 ret = PTR_ERR(steam->client_hdev);
759 steam->client_hdev->driver_data = steam;
762 * With the real steam controller interface, do not connect hidraw.
769 ret = hid_add_device(steam->client_hdev);
781 if (steam->quirks & STEAM_QUIRK_WIRELESS) {
784 steam->connected = false;
785 steam_request_conn_status(steam);
788 steam->connected = true;
789 ret = steam_register(steam);
805 hid_destroy_device(steam->client_hdev);
807 cancel_work_sync(&steam->work_connect);
816 struct steam_device *steam = hid_get_drvdata(hdev);
818 if (!steam || hdev->group == HID_GROUP_STEAM) {
823 hid_destroy_device(steam->client_hdev);
824 steam->client_opened = false;
825 cancel_work_sync(&steam->work_connect);
826 if (steam->quirks & STEAM_QUIRK_WIRELESS) {
831 steam_unregister(steam);
834 static void steam_do_connect_event(struct steam_device *steam, bool connected)
839 spin_lock_irqsave(&steam->lock, flags);
840 changed = steam->connected != connected;
841 steam->connected = connected;
842 spin_unlock_irqrestore(&steam->lock, flags);
844 if (changed && schedule_work(&steam->work_connect) == 0)
914 * 9.5 | BTN_MODE | steam logo
927 static void steam_do_input_event(struct steam_device *steam,
1006 static void steam_do_battery_event(struct steam_device *steam,
1016 battery = rcu_dereference(steam->battery);
1018 spin_lock_irqsave(&steam->lock, flags);
1019 steam->voltage = volts;
1020 steam->battery_charge = batt;
1021 spin_unlock_irqrestore(&steam->lock, flags);
1031 struct steam_device *steam = hid_get_drvdata(hdev);
1035 if (!steam)
1038 if (steam->client_opened)
1039 hid_input_report(steam->client_hdev, HID_FEATURE_REPORT,
1062 if (steam->client_opened)
1065 input = rcu_dereference(steam->input);
1067 steam_do_input_event(steam, input, data);
1078 steam_do_connect_event(steam, false);
1081 steam_do_connect_event(steam, true);
1086 if (steam->quirks & STEAM_QUIRK_WIRELESS) {
1088 battery = rcu_dereference(steam->battery);
1090 steam_do_battery_event(steam, battery, data);
1095 steam_do_connect_event(steam, true);
1107 struct steam_device *steam;
1115 list_for_each_entry(steam, &steam_devices, list) {
1116 mutex_lock(&steam->mutex);
1117 if (!steam->client_opened)
1118 steam_set_lizard_mode(steam, lizard_mode);
1119 mutex_unlock(&steam->mutex);
1150 .name = "hid-steam",