* Data types
*/
struct hv_input_dev_info {
+ unsigned int size;
unsigned short vendor;
unsigned short product;
unsigned short version;
- char name[128];
+ unsigned short reserved[11];
};
/* The maximum size of a synthetic input message. */
struct mousevsc_prt_msg protocol_req;
struct mousevsc_prt_msg protocol_resp;
/* Synchronize the request/response if needed */
- wait_queue_head_t protocol_wait_event;
- wait_queue_head_t dev_info_wait_event;
- int protocol_wait_condition;
- int device_wait_condition;
+ struct completion wait_event;
int dev_info_status;
struct hid_descriptor *hid_desc;
unsigned char *report_desc;
u32 report_desc_size;
struct hv_input_dev_info hid_dev_info;
-};
-
-struct input_device_context {
- struct hv_device *device_ctx;
- struct hid_device *hid_device;
- struct hv_input_dev_info device_info;
int connected;
+ struct hid_device *hid_device;
};
+
static struct mousevsc_dev *alloc_input_device(struct hv_device *device)
{
struct mousevsc_dev *input_dev;
atomic_cmpxchg(&input_dev->ref_count, 0, 2);
input_dev->device = device;
- device->ext = input_dev;
+ hv_set_drvdata(device, input_dev);
+ init_completion(&input_dev->wait_event);
return input_dev;
}
static void free_input_device(struct mousevsc_dev *device)
{
- WARN_ON(atomic_read(&device->ref_count) == 0);
+ WARN_ON(atomic_read(&device->ref_count) != 0);
kfree(device);
}
{
struct mousevsc_dev *input_dev;
- input_dev = (struct mousevsc_dev *)device->ext;
+ input_dev = hv_get_drvdata(device);
/*
* FIXME
{
struct mousevsc_dev *input_dev;
- input_dev = (struct mousevsc_dev *)device->ext;
+ input_dev = hv_get_drvdata(device);
if (input_dev && atomic_read(&input_dev->ref_count))
atomic_inc(&input_dev->ref_count);
{
struct mousevsc_dev *input_dev;
- input_dev = (struct mousevsc_dev *)device->ext;
+ input_dev = hv_get_drvdata(device);
atomic_dec(&input_dev->ref_count);
}
{
struct mousevsc_dev *input_dev;
- input_dev = (struct mousevsc_dev *)device->ext;
+ input_dev = hv_get_drvdata(device);
/* Busy wait until the ref drop to 2, then set it to 1 */
while (atomic_cmpxchg(&input_dev->ref_count, 2, 1) != 2)
{
struct mousevsc_dev *input_dev;
- input_dev = (struct mousevsc_dev *)device->ext;
+ input_dev = hv_get_drvdata(device);
/* Busy wait until the ref drop to 1, then set it to 0 */
while (atomic_cmpxchg(&input_dev->ref_count, 1, 0) != 1)
udelay(100);
- device->ext = NULL;
+ hv_set_drvdata(device, NULL);
return input_dev;
}
/* Save the hid desc */
desc = &device_info->hid_descriptor;
- WARN_ON(desc->bLength > 0);
+ WARN_ON(desc->bLength == 0);
- input_device->hid_desc = kzalloc(desc->bLength, GFP_KERNEL);
+ input_device->hid_desc = kzalloc(desc->bLength, GFP_ATOMIC);
if (!input_device->hid_desc) {
- pr_err("unable to allocate hid descriptor - size %d", desc->bLength);
+ pr_err("unable to allocate hid descriptor - size %d",
+ desc->bLength);
goto cleanup;
}
/* Save the report desc */
input_device->report_desc_size = desc->desc[0].wDescriptorLength;
+ if (input_device->report_desc_size == 0)
+ goto cleanup;
input_device->report_desc = kzalloc(input_device->report_desc_size,
- GFP_KERNEL);
+ GFP_ATOMIC);
if (!input_device->report_desc) {
pr_err("unable to allocate report descriptor - size %d",
goto cleanup;
}
- input_device->device_wait_condition = 1;
- wake_up(&input_device->dev_info_wait_event);
+ complete(&input_device->wait_event);
return;
input_device->report_desc = NULL;
input_device->dev_info_status = -1;
- input_device->device_wait_condition = 1;
- wake_up(&input_device->dev_info_wait_event);
+ complete(&input_device->wait_event);
}
static void mousevsc_on_receive_input_report(struct mousevsc_dev *input_device,
struct synthhid_input_report *input_report)
{
struct hv_driver *input_drv;
- struct input_device_context *input_dev_ctx;
if (!input_device->init_complete) {
pr_info("Initialization incomplete...ignoring input_report msg");
input_drv = drv_to_hv_drv(input_device->device->device.driver);
- input_dev_ctx = dev_get_drvdata(&input_device->device->device);
- hid_input_report(input_dev_ctx->hid_device,
+ hid_input_report(input_device->hid_device,
HID_INPUT_REPORT, input_report->buffer, input_report->header.size, 1);
}
memcpy(&input_dev->protocol_resp, pipe_msg,
pipe_msg->size + sizeof(struct pipe_prt_msg) -
sizeof(unsigned char));
- input_dev->protocol_wait_condition = 1;
- wake_up(&input_dev->protocol_wait_event);
+ complete(&input_dev->wait_event);
break;
case SynthHidInitialDeviceInfo:
- WARN_ON(pipe_msg->size >= sizeof(struct hv_input_dev_info));
+ WARN_ON(pipe_msg->size < sizeof(struct hv_input_dev_info));
/*
* Parse out the device info into device attr,
} else if (ret == -ENOBUFS) {
/* Handle large packet */
bufferlen = bytes_recvd;
- buffer = kzalloc(bytes_recvd, GFP_KERNEL);
+ buffer = kzalloc(bytes_recvd, GFP_ATOMIC);
if (buffer == NULL) {
buffer = packet;
static int mousevsc_connect_to_vsp(struct hv_device *device)
{
int ret = 0;
+ int t;
struct mousevsc_dev *input_dev;
struct mousevsc_prt_msg *request;
struct mousevsc_prt_msg *response;
return -1;
}
- init_waitqueue_head(&input_dev->protocol_wait_event);
- init_waitqueue_head(&input_dev->dev_info_wait_event);
request = &input_dev->protocol_req;
request->size = sizeof(struct synthhid_protocol_request);
request->request.header.type = SynthHidProtocolRequest;
- request->request.header.size = sizeof(unsigned long);
+ request->request.header.size = sizeof(unsigned int);
request->request.version_requested.version = SYNTHHID_INPUT_VERSION;
pr_info("synthhid protocol request...");
ret = vmbus_sendpacket(device->channel, request,
- sizeof(struct pipe_prt_msg) -
- sizeof(unsigned char) +
- sizeof(struct synthhid_protocol_request),
- (unsigned long)request,
- VM_PKT_DATA_INBAND,
- VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
+ sizeof(struct pipe_prt_msg) -
+ sizeof(unsigned char) +
+ sizeof(struct synthhid_protocol_request),
+ (unsigned long)request,
+ VM_PKT_DATA_INBAND,
+ VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
if (ret != 0) {
pr_err("unable to send synthhid protocol request.");
goto cleanup;
}
- input_dev->protocol_wait_condition = 0;
- wait_event_timeout(input_dev->protocol_wait_event,
- input_dev->protocol_wait_condition, msecs_to_jiffies(1000));
- if (input_dev->protocol_wait_condition == 0) {
+ t = wait_for_completion_timeout(&input_dev->wait_event, 5*HZ);
+ if (t == 0) {
ret = -ETIMEDOUT;
goto cleanup;
}
goto cleanup;
}
- input_dev->device_wait_condition = 0;
- wait_event_timeout(input_dev->dev_info_wait_event,
- input_dev->device_wait_condition, msecs_to_jiffies(1000));
- if (input_dev->device_wait_condition == 0) {
+ t = wait_for_completion_timeout(&input_dev->wait_event, 5*HZ);
+ if (t == 0) {
ret = -ETIMEDOUT;
goto cleanup;
}
static void reportdesc_callback(struct hv_device *dev, void *packet, u32 len)
{
- struct input_device_context *input_device_ctx =
- dev_get_drvdata(&dev->device);
struct hid_device *hid_dev;
+ struct mousevsc_dev *input_device = hv_get_drvdata(dev);
/* hid_debug = -1; */
hid_dev = kmalloc(sizeof(struct hid_device), GFP_KERNEL);
hid_dev->ll_driver->close = mousevsc_hid_close;
hid_dev->bus = BUS_VIRTUAL;
- hid_dev->vendor = input_device_ctx->device_info.vendor;
- hid_dev->product = input_device_ctx->device_info.product;
- hid_dev->version = input_device_ctx->device_info.version;
+ hid_dev->vendor = input_device->hid_dev_info.vendor;
+ hid_dev->product = input_device->hid_dev_info.product;
+ hid_dev->version = input_device->hid_dev_info.version;
hid_dev->dev = dev->device;
sprintf(hid_dev->name, "%s",
- input_device_ctx->device_info.name);
+ "Microsoft Vmbus HID-compliant Mouse");
/*
* HJ Do we want to call it with a 0
if (!hidinput_connect(hid_dev, 0)) {
hid_dev->claimed |= HID_CLAIMED_INPUT;
- input_device_ctx->connected = 1;
+ input_device->connected = 1;
DPRINT_INFO(INPUTVSC_DRV,
"HID device claimed by input\n");
"input or hiddev\n");
}
- input_device_ctx->hid_device = hid_dev;
+ input_device->hid_device = hid_dev;
}
kfree(hid_dev);
int ret = 0;
struct mousevsc_dev *input_dev;
struct hv_driver *input_drv;
- struct hv_input_dev_info dev_info;
- struct input_device_context *input_device_ctx;
input_dev = alloc_input_device(device);
input_drv = drv_to_hv_drv(input_dev->device->device.driver);
- dev_info.vendor = input_dev->hid_dev_info.vendor;
- dev_info.product = input_dev->hid_dev_info.product;
- dev_info.version = input_dev->hid_dev_info.version;
- strcpy(dev_info.name, "Microsoft Vmbus HID-compliant Mouse");
- /* Send the device info back up */
- input_device_ctx = dev_get_drvdata(&device->device);
- memcpy(&input_device_ctx->device_info, &dev_info,
- sizeof(struct hv_input_dev_info));
/* Send the report desc back up */
/* workaround SA-167 */
int ret = 0;
pr_info("disabling input device (%p)...",
- device->ext);
+ hv_get_drvdata(device));
input_dev = release_input_device(device);
udelay(100);
}
- pr_info("removing input device (%p)...", device->ext);
+ pr_info("removing input device (%p)...", hv_get_drvdata(device));
input_dev = final_release_input_device(device);
}
-static int mousevsc_probe(struct hv_device *dev)
+static int mousevsc_probe(struct hv_device *dev,
+ const struct hv_vmbus_device_id *dev_id)
{
int ret = 0;
- struct input_device_context *input_dev_ctx;
-
- input_dev_ctx = kmalloc(sizeof(struct input_device_context),
- GFP_KERNEL);
-
- dev_set_drvdata(&dev->device, input_dev_ctx);
/* Call to the vsc driver to add the device */
ret = mousevsc_on_device_add(dev, NULL);
static int mousevsc_remove(struct hv_device *dev)
{
- struct input_device_context *input_dev_ctx;
+ struct mousevsc_dev *input_dev = hv_get_drvdata(dev);
int ret;
- input_dev_ctx = dev_get_drvdata(&dev->device);
- if (input_dev_ctx->connected) {
- hidinput_disconnect(input_dev_ctx->hid_device);
- input_dev_ctx->connected = 0;
+ if (input_dev->connected) {
+ hidinput_disconnect(input_dev->hid_device);
+ input_dev->connected = 0;
}
/*
"unable to remove vsc device (ret %d)", ret);
}
- kfree(input_dev_ctx);
-
return ret;
}
git.openpandora.org / pandora-kernel.git / blobdiff