1 /*
2 * Copyright (c) 2009, Microsoft Corporation.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15 * Place - Suite 330, Boston, MA 02111-1307 USA.
16 *
17 * Authors:
18 * Haiyang Zhang <haiyangz@microsoft.com>
19 * Hank Janssen <hjanssen@microsoft.com>
20 * K. Y. Srinivasan <kys@microsoft.com>
21 *
22 */
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24
25 #include <linux/init.h>
26 #include <linux/module.h>
27 #include <linux/device.h>
28 #include <linux/irq.h>
29 #include <linux/interrupt.h>
30 #include <linux/sysctl.h>
31 #include <linux/slab.h>
32 #include <linux/acpi.h>
33 #include <acpi/acpi_bus.h>
34 #include <linux/completion.h>
35 #include <linux/hyperv.h>
36 #include <asm/hyperv.h>
37 #include "hyperv_vmbus.h"
38
39
40 static struct acpi_device *hv_acpi_dev;
41
42 static struct tasklet_struct msg_dpc;
43 static struct tasklet_struct event_dpc;
44 static struct completion probe_event;
45 static int irq;
46
47 struct hv_device_info {
48 u32 chn_id;
49 u32 chn_state;
50 uuid_le chn_type;
51 uuid_le chn_instance;
52
53 u32 monitor_id;
54 u32 server_monitor_pending;
55 u32 server_monitor_latency;
56 u32 server_monitor_conn_id;
57 u32 client_monitor_pending;
58 u32 client_monitor_latency;
59 u32 client_monitor_conn_id;
60
61 struct hv_dev_port_info inbound;
62 struct hv_dev_port_info outbound;
63 };
64
vmbus_exists(void)65 static int vmbus_exists(void)
66 {
67 if (hv_acpi_dev == NULL)
68 return -ENODEV;
69
70 return 0;
71 }
72
73
get_channel_info(struct hv_device * device,struct hv_device_info * info)74 static void get_channel_info(struct hv_device *device,
75 struct hv_device_info *info)
76 {
77 struct vmbus_channel_debug_info debug_info;
78
79 if (!device->channel)
80 return;
81
82 vmbus_get_debug_info(device->channel, &debug_info);
83
84 info->chn_id = debug_info.relid;
85 info->chn_state = debug_info.state;
86 memcpy(&info->chn_type, &debug_info.interfacetype,
87 sizeof(uuid_le));
88 memcpy(&info->chn_instance, &debug_info.interface_instance,
89 sizeof(uuid_le));
90
91 info->monitor_id = debug_info.monitorid;
92
93 info->server_monitor_pending = debug_info.servermonitor_pending;
94 info->server_monitor_latency = debug_info.servermonitor_latency;
95 info->server_monitor_conn_id = debug_info.servermonitor_connectionid;
96
97 info->client_monitor_pending = debug_info.clientmonitor_pending;
98 info->client_monitor_latency = debug_info.clientmonitor_latency;
99 info->client_monitor_conn_id = debug_info.clientmonitor_connectionid;
100
101 info->inbound.int_mask = debug_info.inbound.current_interrupt_mask;
102 info->inbound.read_idx = debug_info.inbound.current_read_index;
103 info->inbound.write_idx = debug_info.inbound.current_write_index;
104 info->inbound.bytes_avail_toread =
105 debug_info.inbound.bytes_avail_toread;
106 info->inbound.bytes_avail_towrite =
107 debug_info.inbound.bytes_avail_towrite;
108
109 info->outbound.int_mask =
110 debug_info.outbound.current_interrupt_mask;
111 info->outbound.read_idx = debug_info.outbound.current_read_index;
112 info->outbound.write_idx = debug_info.outbound.current_write_index;
113 info->outbound.bytes_avail_toread =
114 debug_info.outbound.bytes_avail_toread;
115 info->outbound.bytes_avail_towrite =
116 debug_info.outbound.bytes_avail_towrite;
117 }
118
119 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
print_alias_name(struct hv_device * hv_dev,char * alias_name)120 static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
121 {
122 int i;
123 for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
124 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
125 }
126
127 /*
128 * vmbus_show_device_attr - Show the device attribute in sysfs.
129 *
130 * This is invoked when user does a
131 * "cat /sys/bus/vmbus/devices/<busdevice>/<attr name>"
132 */
vmbus_show_device_attr(struct device * dev,struct device_attribute * dev_attr,char * buf)133 static ssize_t vmbus_show_device_attr(struct device *dev,
134 struct device_attribute *dev_attr,
135 char *buf)
136 {
137 struct hv_device *hv_dev = device_to_hv_device(dev);
138 struct hv_device_info *device_info;
139 char alias_name[VMBUS_ALIAS_LEN + 1];
140 int ret = 0;
141
142 device_info = kzalloc(sizeof(struct hv_device_info), GFP_KERNEL);
143 if (!device_info)
144 return ret;
145
146 get_channel_info(hv_dev, device_info);
147
148 if (!strcmp(dev_attr->attr.name, "class_id")) {
149 ret = sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-"
150 "%02x%02x%02x%02x%02x%02x%02x%02x}\n",
151 device_info->chn_type.b[3],
152 device_info->chn_type.b[2],
153 device_info->chn_type.b[1],
154 device_info->chn_type.b[0],
155 device_info->chn_type.b[5],
156 device_info->chn_type.b[4],
157 device_info->chn_type.b[7],
158 device_info->chn_type.b[6],
159 device_info->chn_type.b[8],
160 device_info->chn_type.b[9],
161 device_info->chn_type.b[10],
162 device_info->chn_type.b[11],
163 device_info->chn_type.b[12],
164 device_info->chn_type.b[13],
165 device_info->chn_type.b[14],
166 device_info->chn_type.b[15]);
167 } else if (!strcmp(dev_attr->attr.name, "device_id")) {
168 ret = sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-"
169 "%02x%02x%02x%02x%02x%02x%02x%02x}\n",
170 device_info->chn_instance.b[3],
171 device_info->chn_instance.b[2],
172 device_info->chn_instance.b[1],
173 device_info->chn_instance.b[0],
174 device_info->chn_instance.b[5],
175 device_info->chn_instance.b[4],
176 device_info->chn_instance.b[7],
177 device_info->chn_instance.b[6],
178 device_info->chn_instance.b[8],
179 device_info->chn_instance.b[9],
180 device_info->chn_instance.b[10],
181 device_info->chn_instance.b[11],
182 device_info->chn_instance.b[12],
183 device_info->chn_instance.b[13],
184 device_info->chn_instance.b[14],
185 device_info->chn_instance.b[15]);
186 } else if (!strcmp(dev_attr->attr.name, "modalias")) {
187 print_alias_name(hv_dev, alias_name);
188 ret = sprintf(buf, "vmbus:%s\n", alias_name);
189 } else if (!strcmp(dev_attr->attr.name, "state")) {
190 ret = sprintf(buf, "%d\n", device_info->chn_state);
191 } else if (!strcmp(dev_attr->attr.name, "id")) {
192 ret = sprintf(buf, "%d\n", device_info->chn_id);
193 } else if (!strcmp(dev_attr->attr.name, "out_intr_mask")) {
194 ret = sprintf(buf, "%d\n", device_info->outbound.int_mask);
195 } else if (!strcmp(dev_attr->attr.name, "out_read_index")) {
196 ret = sprintf(buf, "%d\n", device_info->outbound.read_idx);
197 } else if (!strcmp(dev_attr->attr.name, "out_write_index")) {
198 ret = sprintf(buf, "%d\n", device_info->outbound.write_idx);
199 } else if (!strcmp(dev_attr->attr.name, "out_read_bytes_avail")) {
200 ret = sprintf(buf, "%d\n",
201 device_info->outbound.bytes_avail_toread);
202 } else if (!strcmp(dev_attr->attr.name, "out_write_bytes_avail")) {
203 ret = sprintf(buf, "%d\n",
204 device_info->outbound.bytes_avail_towrite);
205 } else if (!strcmp(dev_attr->attr.name, "in_intr_mask")) {
206 ret = sprintf(buf, "%d\n", device_info->inbound.int_mask);
207 } else if (!strcmp(dev_attr->attr.name, "in_read_index")) {
208 ret = sprintf(buf, "%d\n", device_info->inbound.read_idx);
209 } else if (!strcmp(dev_attr->attr.name, "in_write_index")) {
210 ret = sprintf(buf, "%d\n", device_info->inbound.write_idx);
211 } else if (!strcmp(dev_attr->attr.name, "in_read_bytes_avail")) {
212 ret = sprintf(buf, "%d\n",
213 device_info->inbound.bytes_avail_toread);
214 } else if (!strcmp(dev_attr->attr.name, "in_write_bytes_avail")) {
215 ret = sprintf(buf, "%d\n",
216 device_info->inbound.bytes_avail_towrite);
217 } else if (!strcmp(dev_attr->attr.name, "monitor_id")) {
218 ret = sprintf(buf, "%d\n", device_info->monitor_id);
219 } else if (!strcmp(dev_attr->attr.name, "server_monitor_pending")) {
220 ret = sprintf(buf, "%d\n", device_info->server_monitor_pending);
221 } else if (!strcmp(dev_attr->attr.name, "server_monitor_latency")) {
222 ret = sprintf(buf, "%d\n", device_info->server_monitor_latency);
223 } else if (!strcmp(dev_attr->attr.name, "server_monitor_conn_id")) {
224 ret = sprintf(buf, "%d\n",
225 device_info->server_monitor_conn_id);
226 } else if (!strcmp(dev_attr->attr.name, "client_monitor_pending")) {
227 ret = sprintf(buf, "%d\n", device_info->client_monitor_pending);
228 } else if (!strcmp(dev_attr->attr.name, "client_monitor_latency")) {
229 ret = sprintf(buf, "%d\n", device_info->client_monitor_latency);
230 } else if (!strcmp(dev_attr->attr.name, "client_monitor_conn_id")) {
231 ret = sprintf(buf, "%d\n",
232 device_info->client_monitor_conn_id);
233 }
234
235 kfree(device_info);
236 return ret;
237 }
238
239 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
240 static struct device_attribute vmbus_device_attrs[] = {
241 __ATTR(id, S_IRUGO, vmbus_show_device_attr, NULL),
242 __ATTR(state, S_IRUGO, vmbus_show_device_attr, NULL),
243 __ATTR(class_id, S_IRUGO, vmbus_show_device_attr, NULL),
244 __ATTR(device_id, S_IRUGO, vmbus_show_device_attr, NULL),
245 __ATTR(monitor_id, S_IRUGO, vmbus_show_device_attr, NULL),
246 __ATTR(modalias, S_IRUGO, vmbus_show_device_attr, NULL),
247
248 __ATTR(server_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL),
249 __ATTR(server_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL),
250 __ATTR(server_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL),
251
252 __ATTR(client_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL),
253 __ATTR(client_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL),
254 __ATTR(client_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL),
255
256 __ATTR(out_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
257 __ATTR(out_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
258 __ATTR(out_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
259 __ATTR(out_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
260 __ATTR(out_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
261
262 __ATTR(in_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
263 __ATTR(in_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
264 __ATTR(in_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
265 __ATTR(in_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
266 __ATTR(in_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
267 __ATTR_NULL
268 };
269
270
271 /*
272 * vmbus_uevent - add uevent for our device
273 *
274 * This routine is invoked when a device is added or removed on the vmbus to
275 * generate a uevent to udev in the userspace. The udev will then look at its
276 * rule and the uevent generated here to load the appropriate driver
277 *
278 * The alias string will be of the form vmbus:guid where guid is the string
279 * representation of the device guid (each byte of the guid will be
280 * represented with two hex characters.
281 */
vmbus_uevent(struct device * device,struct kobj_uevent_env * env)282 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
283 {
284 struct hv_device *dev = device_to_hv_device(device);
285 int ret;
286 char alias_name[VMBUS_ALIAS_LEN + 1];
287
288 print_alias_name(dev, alias_name);
289 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
290 return ret;
291 }
292
293 static uuid_le null_guid;
294
is_null_guid(const __u8 * guid)295 static inline bool is_null_guid(const __u8 *guid)
296 {
297 if (memcmp(guid, &null_guid, sizeof(uuid_le)))
298 return false;
299 return true;
300 }
301
302 /*
303 * Return a matching hv_vmbus_device_id pointer.
304 * If there is no match, return NULL.
305 */
hv_vmbus_get_id(const struct hv_vmbus_device_id * id,__u8 * guid)306 static const struct hv_vmbus_device_id *hv_vmbus_get_id(
307 const struct hv_vmbus_device_id *id,
308 __u8 *guid)
309 {
310 for (; !is_null_guid(id->guid); id++)
311 if (!memcmp(&id->guid, guid, sizeof(uuid_le)))
312 return id;
313
314 return NULL;
315 }
316
317
318
319 /*
320 * vmbus_match - Attempt to match the specified device to the specified driver
321 */
vmbus_match(struct device * device,struct device_driver * driver)322 static int vmbus_match(struct device *device, struct device_driver *driver)
323 {
324 struct hv_driver *drv = drv_to_hv_drv(driver);
325 struct hv_device *hv_dev = device_to_hv_device(device);
326
327 if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b))
328 return 1;
329
330 return 0;
331 }
332
333 /*
334 * vmbus_probe - Add the new vmbus's child device
335 */
vmbus_probe(struct device * child_device)336 static int vmbus_probe(struct device *child_device)
337 {
338 int ret = 0;
339 struct hv_driver *drv =
340 drv_to_hv_drv(child_device->driver);
341 struct hv_device *dev = device_to_hv_device(child_device);
342 const struct hv_vmbus_device_id *dev_id;
343
344 dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b);
345 if (drv->probe) {
346 ret = drv->probe(dev, dev_id);
347 if (ret != 0)
348 pr_err("probe failed for device %s (%d)\n",
349 dev_name(child_device), ret);
350
351 } else {
352 pr_err("probe not set for driver %s\n",
353 dev_name(child_device));
354 ret = -ENODEV;
355 }
356 return ret;
357 }
358
359 /*
360 * vmbus_remove - Remove a vmbus device
361 */
vmbus_remove(struct device * child_device)362 static int vmbus_remove(struct device *child_device)
363 {
364 struct hv_driver *drv = drv_to_hv_drv(child_device->driver);
365 struct hv_device *dev = device_to_hv_device(child_device);
366
367 if (drv->remove)
368 drv->remove(dev);
369 else
370 pr_err("remove not set for driver %s\n",
371 dev_name(child_device));
372
373 return 0;
374 }
375
376
377 /*
378 * vmbus_shutdown - Shutdown a vmbus device
379 */
vmbus_shutdown(struct device * child_device)380 static void vmbus_shutdown(struct device *child_device)
381 {
382 struct hv_driver *drv;
383 struct hv_device *dev = device_to_hv_device(child_device);
384
385
386 /* The device may not be attached yet */
387 if (!child_device->driver)
388 return;
389
390 drv = drv_to_hv_drv(child_device->driver);
391
392 if (drv->shutdown)
393 drv->shutdown(dev);
394
395 return;
396 }
397
398
399 /*
400 * vmbus_device_release - Final callback release of the vmbus child device
401 */
vmbus_device_release(struct device * device)402 static void vmbus_device_release(struct device *device)
403 {
404 struct hv_device *hv_dev = device_to_hv_device(device);
405
406 kfree(hv_dev);
407
408 }
409
410 /* The one and only one */
411 static struct bus_type hv_bus = {
412 .name = "vmbus",
413 .match = vmbus_match,
414 .shutdown = vmbus_shutdown,
415 .remove = vmbus_remove,
416 .probe = vmbus_probe,
417 .uevent = vmbus_uevent,
418 .dev_attrs = vmbus_device_attrs,
419 };
420
421 static const char *driver_name = "hyperv";
422
423
424 struct onmessage_work_context {
425 struct work_struct work;
426 struct hv_message msg;
427 };
428
vmbus_onmessage_work(struct work_struct * work)429 static void vmbus_onmessage_work(struct work_struct *work)
430 {
431 struct onmessage_work_context *ctx;
432
433 ctx = container_of(work, struct onmessage_work_context,
434 work);
435 vmbus_onmessage(&ctx->msg);
436 kfree(ctx);
437 }
438
vmbus_on_msg_dpc(unsigned long data)439 static void vmbus_on_msg_dpc(unsigned long data)
440 {
441 int cpu = smp_processor_id();
442 void *page_addr = hv_context.synic_message_page[cpu];
443 struct hv_message *msg = (struct hv_message *)page_addr +
444 VMBUS_MESSAGE_SINT;
445 struct onmessage_work_context *ctx;
446
447 while (1) {
448 if (msg->header.message_type == HVMSG_NONE) {
449 /* no msg */
450 break;
451 } else {
452 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
453 if (ctx == NULL)
454 continue;
455 INIT_WORK(&ctx->work, vmbus_onmessage_work);
456 memcpy(&ctx->msg, msg, sizeof(*msg));
457 queue_work(vmbus_connection.work_queue, &ctx->work);
458 }
459
460 msg->header.message_type = HVMSG_NONE;
461
462 /*
463 * Make sure the write to MessageType (ie set to
464 * HVMSG_NONE) happens before we read the
465 * MessagePending and EOMing. Otherwise, the EOMing
466 * will not deliver any more messages since there is
467 * no empty slot
468 */
469 mb();
470
471 if (msg->header.message_flags.msg_pending) {
472 /*
473 * This will cause message queue rescan to
474 * possibly deliver another msg from the
475 * hypervisor
476 */
477 wrmsrl(HV_X64_MSR_EOM, 0);
478 }
479 }
480 }
481
vmbus_isr(int irq,void * dev_id)482 static irqreturn_t vmbus_isr(int irq, void *dev_id)
483 {
484 int cpu = smp_processor_id();
485 void *page_addr;
486 struct hv_message *msg;
487 union hv_synic_event_flags *event;
488 bool handled = false;
489
490 /*
491 * Check for events before checking for messages. This is the order
492 * in which events and messages are checked in Windows guests on
493 * Hyper-V, and the Windows team suggested we do the same.
494 */
495
496 page_addr = hv_context.synic_event_page[cpu];
497 event = (union hv_synic_event_flags *)page_addr + VMBUS_MESSAGE_SINT;
498
499 /* Since we are a child, we only need to check bit 0 */
500 if (sync_test_and_clear_bit(0, (unsigned long *) &event->flags32[0])) {
501 handled = true;
502 tasklet_schedule(&event_dpc);
503 }
504
505 page_addr = hv_context.synic_message_page[cpu];
506 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
507
508 /* Check if there are actual msgs to be processed */
509 if (msg->header.message_type != HVMSG_NONE) {
510 handled = true;
511 tasklet_schedule(&msg_dpc);
512 }
513
514 if (handled)
515 return IRQ_HANDLED;
516 else
517 return IRQ_NONE;
518 }
519
520 /*
521 * vmbus_bus_init -Main vmbus driver initialization routine.
522 *
523 * Here, we
524 * - initialize the vmbus driver context
525 * - invoke the vmbus hv main init routine
526 * - get the irq resource
527 * - retrieve the channel offers
528 */
vmbus_bus_init(int irq)529 static int vmbus_bus_init(int irq)
530 {
531 int ret;
532 unsigned int vector;
533
534 /* Hypervisor initialization...setup hypercall page..etc */
535 ret = hv_init();
536 if (ret != 0) {
537 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
538 return ret;
539 }
540
541 tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
542 tasklet_init(&event_dpc, vmbus_on_event, 0);
543
544 ret = bus_register(&hv_bus);
545 if (ret)
546 goto err_cleanup;
547
548 ret = request_irq(irq, vmbus_isr, IRQF_SAMPLE_RANDOM,
549 driver_name, hv_acpi_dev);
550
551 if (ret != 0) {
552 pr_err("Unable to request IRQ %d\n",
553 irq);
554 goto err_unregister;
555 }
556
557 vector = IRQ0_VECTOR + irq;
558
559 /*
560 * Notify the hypervisor of our irq and
561 * connect to the host.
562 */
563 on_each_cpu(hv_synic_init, (void *)&vector, 1);
564 ret = vmbus_connect();
565 if (ret)
566 goto err_irq;
567
568 vmbus_request_offers();
569
570 return 0;
571
572 err_irq:
573 free_irq(irq, hv_acpi_dev);
574
575 err_unregister:
576 bus_unregister(&hv_bus);
577
578 err_cleanup:
579 hv_cleanup();
580
581 return ret;
582 }
583
584 /**
585 * __vmbus_child_driver_register - Register a vmbus's driver
586 * @drv: Pointer to driver structure you want to register
587 * @owner: owner module of the drv
588 * @mod_name: module name string
589 *
590 * Registers the given driver with Linux through the 'driver_register()' call
591 * and sets up the hyper-v vmbus handling for this driver.
592 * It will return the state of the 'driver_register()' call.
593 *
594 */
__vmbus_driver_register(struct hv_driver * hv_driver,struct module * owner,const char * mod_name)595 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
596 {
597 int ret;
598
599 pr_info("registering driver %s\n", hv_driver->name);
600
601 ret = vmbus_exists();
602 if (ret < 0)
603 return ret;
604
605 hv_driver->driver.name = hv_driver->name;
606 hv_driver->driver.owner = owner;
607 hv_driver->driver.mod_name = mod_name;
608 hv_driver->driver.bus = &hv_bus;
609
610 ret = driver_register(&hv_driver->driver);
611
612 vmbus_request_offers();
613
614 return ret;
615 }
616 EXPORT_SYMBOL_GPL(__vmbus_driver_register);
617
618 /**
619 * vmbus_driver_unregister() - Unregister a vmbus's driver
620 * @drv: Pointer to driver structure you want to un-register
621 *
622 * Un-register the given driver that was previous registered with a call to
623 * vmbus_driver_register()
624 */
vmbus_driver_unregister(struct hv_driver * hv_driver)625 void vmbus_driver_unregister(struct hv_driver *hv_driver)
626 {
627 pr_info("unregistering driver %s\n", hv_driver->name);
628
629 if (!vmbus_exists())
630 driver_unregister(&hv_driver->driver);
631 }
632 EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
633
634 /*
635 * vmbus_device_create - Creates and registers a new child device
636 * on the vmbus.
637 */
vmbus_device_create(uuid_le * type,uuid_le * instance,struct vmbus_channel * channel)638 struct hv_device *vmbus_device_create(uuid_le *type,
639 uuid_le *instance,
640 struct vmbus_channel *channel)
641 {
642 struct hv_device *child_device_obj;
643
644 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
645 if (!child_device_obj) {
646 pr_err("Unable to allocate device object for child device\n");
647 return NULL;
648 }
649
650 child_device_obj->channel = channel;
651 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
652 memcpy(&child_device_obj->dev_instance, instance,
653 sizeof(uuid_le));
654
655
656 return child_device_obj;
657 }
658
659 /*
660 * vmbus_device_register - Register the child device
661 */
vmbus_device_register(struct hv_device * child_device_obj)662 int vmbus_device_register(struct hv_device *child_device_obj)
663 {
664 int ret = 0;
665
666 static atomic_t device_num = ATOMIC_INIT(0);
667
668 dev_set_name(&child_device_obj->device, "vmbus_0_%d",
669 atomic_inc_return(&device_num));
670
671 child_device_obj->device.bus = &hv_bus;
672 child_device_obj->device.parent = &hv_acpi_dev->dev;
673 child_device_obj->device.release = vmbus_device_release;
674
675 /*
676 * Register with the LDM. This will kick off the driver/device
677 * binding...which will eventually call vmbus_match() and vmbus_probe()
678 */
679 ret = device_register(&child_device_obj->device);
680
681 if (ret)
682 pr_err("Unable to register child device\n");
683 else
684 pr_info("child device %s registered\n",
685 dev_name(&child_device_obj->device));
686
687 return ret;
688 }
689
690 /*
691 * vmbus_device_unregister - Remove the specified child device
692 * from the vmbus.
693 */
vmbus_device_unregister(struct hv_device * device_obj)694 void vmbus_device_unregister(struct hv_device *device_obj)
695 {
696 /*
697 * Kick off the process of unregistering the device.
698 * This will call vmbus_remove() and eventually vmbus_device_release()
699 */
700 device_unregister(&device_obj->device);
701
702 pr_info("child device %s unregistered\n",
703 dev_name(&device_obj->device));
704 }
705
706
707 /*
708 * VMBUS is an acpi enumerated device. Get the the IRQ information
709 * from DSDT.
710 */
711
vmbus_walk_resources(struct acpi_resource * res,void * irq)712 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *irq)
713 {
714
715 if (res->type == ACPI_RESOURCE_TYPE_IRQ) {
716 struct acpi_resource_irq *irqp;
717 irqp = &res->data.irq;
718
719 *((unsigned int *)irq) = irqp->interrupts[0];
720 }
721
722 return AE_OK;
723 }
724
vmbus_acpi_add(struct acpi_device * device)725 static int vmbus_acpi_add(struct acpi_device *device)
726 {
727 acpi_status result;
728
729 hv_acpi_dev = device;
730
731 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
732 vmbus_walk_resources, &irq);
733
734 if (ACPI_FAILURE(result)) {
735 complete(&probe_event);
736 return -ENODEV;
737 }
738 complete(&probe_event);
739 return 0;
740 }
741
742 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
743 {"VMBUS", 0},
744 {"VMBus", 0},
745 {"", 0},
746 };
747 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
748
749 static struct acpi_driver vmbus_acpi_driver = {
750 .name = "vmbus",
751 .ids = vmbus_acpi_device_ids,
752 .ops = {
753 .add = vmbus_acpi_add,
754 },
755 };
756
hv_acpi_init(void)757 static int __init hv_acpi_init(void)
758 {
759 int ret, t;
760
761 init_completion(&probe_event);
762
763 /*
764 * Get irq resources first.
765 */
766
767 ret = acpi_bus_register_driver(&vmbus_acpi_driver);
768
769 if (ret)
770 return ret;
771
772 t = wait_for_completion_timeout(&probe_event, 5*HZ);
773 if (t == 0) {
774 ret = -ETIMEDOUT;
775 goto cleanup;
776 }
777
778 if (irq <= 0) {
779 ret = -ENODEV;
780 goto cleanup;
781 }
782
783 ret = vmbus_bus_init(irq);
784 if (ret)
785 goto cleanup;
786
787 return 0;
788
789 cleanup:
790 acpi_bus_unregister_driver(&vmbus_acpi_driver);
791 hv_acpi_dev = NULL;
792 return ret;
793 }
794
vmbus_exit(void)795 static void __exit vmbus_exit(void)
796 {
797
798 free_irq(irq, hv_acpi_dev);
799 vmbus_free_channels();
800 bus_unregister(&hv_bus);
801 hv_cleanup();
802 acpi_bus_unregister_driver(&vmbus_acpi_driver);
803 }
804
805
806 MODULE_LICENSE("GPL");
807 MODULE_VERSION(HV_DRV_VERSION);
808
809 subsys_initcall(hv_acpi_init);
810 module_exit(vmbus_exit);
811