Lines Matching refs:ddev
177 struct sdtx_device *ddev;
189 struct sdtx_device *ddev = container_of(kref, struct sdtx_device, kref);
191 mutex_destroy(&ddev->write_lock);
192 kfree(ddev);
195 static struct sdtx_device *sdtx_device_get(struct sdtx_device *ddev)
197 if (ddev)
198 kref_get(&ddev->kref);
200 return ddev;
203 static void sdtx_device_put(struct sdtx_device *ddev)
205 if (ddev)
206 kref_put(&ddev->kref, __sdtx_device_release);
212 static u16 sdtx_translate_base_state(struct sdtx_device *ddev, u8 state)
225 dev_err(ddev->dev, "unknown base state: %#04x\n", state);
230 static u16 sdtx_translate_latch_status(struct sdtx_device *ddev, u8 status)
249 dev_err(ddev->dev, "unknown latch status: %#04x\n", status);
254 static u16 sdtx_translate_cancel_reason(struct sdtx_device *ddev, u8 reason)
273 dev_err(ddev->dev, "unknown cancel reason: %#04x\n", reason);
281 static int sdtx_ioctl_get_base_info(struct sdtx_device *ddev,
288 lockdep_assert_held_read(&ddev->lock);
290 status = ssam_retry(ssam_bas_get_base, ddev->ctrl, &raw);
294 info.state = sdtx_translate_base_state(ddev, raw.state);
303 static int sdtx_ioctl_get_device_mode(struct sdtx_device *ddev, u16 __user *buf)
308 lockdep_assert_held_read(&ddev->lock);
310 status = ssam_retry(ssam_bas_get_device_mode, ddev->ctrl, &mode);
317 static int sdtx_ioctl_get_latch_status(struct sdtx_device *ddev, u16 __user *buf)
322 lockdep_assert_held_read(&ddev->lock);
324 status = ssam_retry(ssam_bas_get_latch_status, ddev->ctrl, &latch);
328 return put_user(sdtx_translate_latch_status(ddev, latch), buf);
333 struct sdtx_device *ddev = client->ddev;
335 lockdep_assert_held_read(&ddev->lock);
347 return ssam_retry(ssam_bas_latch_lock, ddev->ctrl);
350 return ssam_retry(ssam_bas_latch_unlock, ddev->ctrl);
353 return ssam_retry(ssam_bas_latch_request, ddev->ctrl);
356 return ssam_retry(ssam_bas_latch_confirm, ddev->ctrl);
359 return ssam_retry(ssam_bas_latch_heartbeat, ddev->ctrl);
362 return ssam_retry(ssam_bas_latch_cancel, ddev->ctrl);
365 return sdtx_ioctl_get_base_info(ddev, (struct sdtx_base_info __user *)arg);
368 return sdtx_ioctl_get_device_mode(ddev, (u16 __user *)arg);
371 return sdtx_ioctl_get_latch_status(ddev, (u16 __user *)arg);
383 if (down_read_killable(&client->ddev->lock))
386 if (test_bit(SDTX_DEVICE_SHUTDOWN_BIT, &client->ddev->flags)) {
387 up_read(&client->ddev->lock);
393 up_read(&client->ddev->lock);
402 struct sdtx_device *ddev = container_of(file->private_data, struct sdtx_device, mdev);
410 client->ddev = sdtx_device_get(ddev);
420 down_write(&ddev->client_lock);
428 if (test_bit(SDTX_DEVICE_SHUTDOWN_BIT, &ddev->flags)) {
429 up_write(&ddev->client_lock);
431 sdtx_device_put(client->ddev);
436 list_add_tail(&client->node, &ddev->client_list);
437 up_write(&ddev->client_lock);
448 down_write(&client->ddev->client_lock);
450 up_write(&client->ddev->client_lock);
453 sdtx_device_put(client->ddev);
463 struct sdtx_device *ddev = client->ddev;
467 if (down_read_killable(&ddev->lock))
471 if (test_bit(SDTX_DEVICE_SHUTDOWN_BIT, &ddev->flags)) {
472 up_read(&ddev->lock);
479 up_read(&ddev->lock);
484 status = wait_event_interruptible(ddev->waitq,
487 &ddev->flags));
491 if (down_read_killable(&ddev->lock))
495 if (test_bit(SDTX_DEVICE_SHUTDOWN_BIT, &ddev->flags)) {
496 up_read(&ddev->lock);
503 up_read(&ddev->lock);
511 up_read(&ddev->lock);
517 up_read(&ddev->lock);
522 up_read(&ddev->lock);
531 if (test_bit(SDTX_DEVICE_SHUTDOWN_BIT, &client->ddev->flags))
534 poll_wait(file, &client->ddev->waitq, pt);
594 static void sdtx_update_device_mode(struct sdtx_device *ddev, unsigned long delay);
596 /* Must be executed with ddev->write_lock held. */
597 static void sdtx_push_event(struct sdtx_device *ddev, struct sdtx_event *evt)
602 lockdep_assert_held(&ddev->write_lock);
604 down_read(&ddev->client_lock);
605 list_for_each_entry(client, &ddev->client_list, node) {
612 dev_warn(ddev->dev, "event buffer overrun\n");
616 up_read(&ddev->client_lock);
618 wake_up_interruptible(&ddev->waitq);
623 struct sdtx_device *ddev = container_of(nf, struct sdtx_device, notif);
650 dev_err(ddev->dev,
656 mutex_lock(&ddev->write_lock);
661 clear_bit(SDTX_DEVICE_DIRTY_BASE_BIT, &ddev->flags);
664 if (ddev->state.base.state == in->data[0] &&
665 ddev->state.base.base_id == in->data[1])
668 ddev->state.base.state = in->data[0];
669 ddev->state.base.base_id = in->data[1];
673 event.base.v.state = sdtx_translate_base_state(ddev, in->data[0]);
685 event.status.v = sdtx_translate_cancel_reason(ddev, in->data[0]);
689 clear_bit(SDTX_DEVICE_DIRTY_LATCH_BIT, &ddev->flags);
692 if (ddev->state.latch_status == in->data[0])
695 ddev->state.latch_status = in->data[0];
699 event.status.v = sdtx_translate_latch_status(ddev, in->data[0]);
703 sdtx_push_event(ddev, &event.common);
710 sdtx_update_device_mode(ddev, delay);
714 mutex_unlock(&ddev->write_lock);
731 struct sdtx_device *ddev = container_of(work, struct sdtx_device, mode_work.work);
738 status = ssam_retry(ssam_bas_get_device_mode, ddev->ctrl, &mode);
740 dev_err(ddev->dev, "failed to get device mode: %d\n", status);
745 status = ssam_retry(ssam_bas_get_base, ddev->ctrl, &base);
747 dev_err(ddev->dev, "failed to get base info: %d\n", status);
758 dev_dbg(ddev->dev, "device mode is invalid, trying again\n");
759 sdtx_update_device_mode(ddev, SDTX_DEVICE_MODE_DELAY_RECHECK);
763 mutex_lock(&ddev->write_lock);
764 clear_bit(SDTX_DEVICE_DIRTY_MODE_BIT, &ddev->flags);
767 if (ddev->state.device_mode == mode) {
768 mutex_unlock(&ddev->write_lock);
772 ddev->state.device_mode = mode;
778 sdtx_push_event(ddev, &event.e);
782 input_report_switch(ddev->mode_switch, SW_TABLET_MODE, tablet);
783 input_sync(ddev->mode_switch);
785 mutex_unlock(&ddev->write_lock);
788 static void sdtx_update_device_mode(struct sdtx_device *ddev, unsigned long delay)
790 schedule_delayed_work(&ddev->mode_work, delay);
793 /* Must be executed with ddev->write_lock held. */
794 static void __sdtx_device_state_update_base(struct sdtx_device *ddev,
799 lockdep_assert_held(&ddev->write_lock);
802 if (ddev->state.base.state == info.state &&
803 ddev->state.base.base_id == info.base_id)
806 ddev->state.base = info;
810 event.v.state = sdtx_translate_base_state(ddev, info.state);
813 sdtx_push_event(ddev, &event.e);
816 /* Must be executed with ddev->write_lock held. */
817 static void __sdtx_device_state_update_mode(struct sdtx_device *ddev, u8 mode)
828 lockdep_assert_held(&ddev->write_lock);
830 if (sdtx_device_mode_invalid(mode, ddev->state.base.state)) {
831 dev_dbg(ddev->dev, "device mode is invalid, trying again\n");
832 sdtx_update_device_mode(ddev, SDTX_DEVICE_MODE_DELAY_RECHECK);
837 if (ddev->state.device_mode == mode)
840 ddev->state.device_mode = mode;
847 sdtx_push_event(ddev, &event.e);
851 input_report_switch(ddev->mode_switch, SW_TABLET_MODE, tablet);
852 input_sync(ddev->mode_switch);
855 /* Must be executed with ddev->write_lock held. */
856 static void __sdtx_device_state_update_latch(struct sdtx_device *ddev, u8 status)
860 lockdep_assert_held(&ddev->write_lock);
863 if (ddev->state.latch_status == status)
866 ddev->state.latch_status = status;
870 event.v = sdtx_translate_latch_status(ddev, status);
872 sdtx_push_event(ddev, &event.e);
877 struct sdtx_device *ddev = container_of(work, struct sdtx_device, state_work.work);
883 set_bit(SDTX_DEVICE_DIRTY_BASE_BIT, &ddev->flags);
884 set_bit(SDTX_DEVICE_DIRTY_MODE_BIT, &ddev->flags);
885 set_bit(SDTX_DEVICE_DIRTY_LATCH_BIT, &ddev->flags);
895 status = ssam_retry(ssam_bas_get_base, ddev->ctrl, &base);
897 dev_err(ddev->dev, "failed to get base state: %d\n", status);
901 status = ssam_retry(ssam_bas_get_device_mode, ddev->ctrl, &mode);
903 dev_err(ddev->dev, "failed to get device mode: %d\n", status);
907 status = ssam_retry(ssam_bas_get_latch_status, ddev->ctrl, &latch);
909 dev_err(ddev->dev, "failed to get latch status: %d\n", status);
913 mutex_lock(&ddev->write_lock);
923 if (test_and_clear_bit(SDTX_DEVICE_DIRTY_BASE_BIT, &ddev->flags))
924 __sdtx_device_state_update_base(ddev, base);
926 if (test_and_clear_bit(SDTX_DEVICE_DIRTY_MODE_BIT, &ddev->flags))
927 __sdtx_device_state_update_mode(ddev, mode);
929 if (test_and_clear_bit(SDTX_DEVICE_DIRTY_LATCH_BIT, &ddev->flags))
930 __sdtx_device_state_update_latch(ddev, latch);
932 mutex_unlock(&ddev->write_lock);
935 static void sdtx_update_device_state(struct sdtx_device *ddev, unsigned long delay)
937 schedule_delayed_work(&ddev->state_work, delay);
943 static int sdtx_device_init(struct sdtx_device *ddev, struct device *dev,
949 kref_init(&ddev->kref);
950 init_rwsem(&ddev->lock);
951 ddev->dev = dev;
952 ddev->ctrl = ctrl;
954 ddev->mdev.minor = MISC_DYNAMIC_MINOR;
955 ddev->mdev.name = "surface_dtx";
956 ddev->mdev.nodename = "surface/dtx";
957 ddev->mdev.fops = &surface_dtx_fops;
959 ddev->notif.base.priority = 1;
960 ddev->notif.base.fn = sdtx_notifier;
961 ddev->notif.event.reg = SSAM_EVENT_REGISTRY_SAM;
962 ddev->notif.event.id.target_category = SSAM_SSH_TC_BAS;
963 ddev->notif.event.id.instance = 0;
964 ddev->notif.event.mask = SSAM_EVENT_MASK_NONE;
965 ddev->notif.event.flags = SSAM_EVENT_SEQUENCED;
967 init_waitqueue_head(&ddev->waitq);
968 mutex_init(&ddev->write_lock);
969 init_rwsem(&ddev->client_lock);
970 INIT_LIST_HEAD(&ddev->client_list);
972 INIT_DELAYED_WORK(&ddev->mode_work, sdtx_device_mode_workfn);
973 INIT_DELAYED_WORK(&ddev->state_work, sdtx_device_state_workfn);
986 status = ssam_retry(ssam_bas_get_base, ddev->ctrl, &ddev->state.base);
990 status = ssam_retry(ssam_bas_get_device_mode, ddev->ctrl, &ddev->state.device_mode);
994 status = ssam_retry(ssam_bas_get_latch_status, ddev->ctrl, &ddev->state.latch_status);
999 ddev->mode_switch = input_allocate_device();
1000 if (!ddev->mode_switch)
1003 ddev->mode_switch->name = "Microsoft Surface DTX Device Mode Switch";
1004 ddev->mode_switch->phys = "ssam/01:11:01:00:00/input0";
1005 ddev->mode_switch->id.bustype = BUS_HOST;
1006 ddev->mode_switch->dev.parent = ddev->dev;
1008 tablet_mode = (ddev->state.device_mode != SDTX_DEVICE_MODE_LAPTOP);
1009 input_set_capability(ddev->mode_switch, EV_SW, SW_TABLET_MODE);
1010 input_report_switch(ddev->mode_switch, SW_TABLET_MODE, tablet_mode);
1012 status = input_register_device(ddev->mode_switch);
1014 input_free_device(ddev->mode_switch);
1019 status = ssam_notifier_register(ddev->ctrl, &ddev->notif);
1024 status = misc_register(&ddev->mdev);
1032 sdtx_update_device_state(ddev, 0);
1036 ssam_notifier_unregister(ddev->ctrl, &ddev->notif);
1037 cancel_delayed_work_sync(&ddev->mode_work);
1039 input_unregister_device(ddev->mode_switch);
1045 struct sdtx_device *ddev;
1048 ddev = kzalloc(sizeof(*ddev), GFP_KERNEL);
1049 if (!ddev)
1052 status = sdtx_device_init(ddev, dev, ctrl);
1054 sdtx_device_put(ddev);
1058 return ddev;
1061 static void sdtx_device_destroy(struct sdtx_device *ddev)
1069 set_bit(SDTX_DEVICE_SHUTDOWN_BIT, &ddev->flags);
1072 ssam_notifier_unregister(ddev->ctrl, &ddev->notif);
1075 cancel_delayed_work_sync(&ddev->mode_work);
1078 cancel_delayed_work_sync(&ddev->state_work);
1081 input_unregister_device(ddev->mode_switch);
1084 down_write(&ddev->client_lock);
1085 list_for_each_entry(client, &ddev->client_list, node) {
1088 up_write(&ddev->client_lock);
1091 wake_up_interruptible(&ddev->waitq);
1098 down_write(&ddev->lock);
1099 ddev->dev = NULL;
1100 ddev->ctrl = NULL;
1101 up_write(&ddev->lock);
1104 misc_deregister(&ddev->mdev);
1110 sdtx_device_put(ddev);
1120 struct sdtx_device *ddev = dev_get_drvdata(dev);
1137 sdtx_update_device_state(ddev, msecs_to_jiffies(1000));
1156 struct sdtx_device *ddev;
1163 ddev = sdtx_device_create(&pdev->dev, ctrl);
1164 if (IS_ERR(ddev))
1165 return PTR_ERR(ddev);
1167 platform_set_drvdata(pdev, ddev);
1201 struct sdtx_device *ddev;
1203 ddev = sdtx_device_create(&sdev->dev, sdev->ctrl);
1204 if (IS_ERR(ddev))
1205 return PTR_ERR(ddev);
1207 ssam_device_set_drvdata(sdev, ddev);