xref: /openbmc/linux/drivers/hv/vmbus_drv.c (revision 4da722ca)
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/interrupt.h>
29 #include <linux/sysctl.h>
30 #include <linux/slab.h>
31 #include <linux/acpi.h>
32 #include <linux/completion.h>
33 #include <linux/hyperv.h>
34 #include <linux/kernel_stat.h>
35 #include <linux/clockchips.h>
36 #include <linux/cpu.h>
37 #include <linux/sched/task_stack.h>
38 
39 #include <asm/hyperv.h>
40 #include <asm/hypervisor.h>
41 #include <asm/mshyperv.h>
42 #include <linux/notifier.h>
43 #include <linux/ptrace.h>
44 #include <linux/screen_info.h>
45 #include <linux/kdebug.h>
46 #include <linux/efi.h>
47 #include <linux/random.h>
48 #include "hyperv_vmbus.h"
49 
50 struct vmbus_dynid {
51 	struct list_head node;
52 	struct hv_vmbus_device_id id;
53 };
54 
55 static struct acpi_device  *hv_acpi_dev;
56 
57 static struct completion probe_event;
58 
59 static int hyperv_cpuhp_online;
60 
61 static int hyperv_panic_event(struct notifier_block *nb, unsigned long val,
62 			      void *args)
63 {
64 	struct pt_regs *regs;
65 
66 	regs = current_pt_regs();
67 
68 	hyperv_report_panic(regs);
69 	return NOTIFY_DONE;
70 }
71 
72 static int hyperv_die_event(struct notifier_block *nb, unsigned long val,
73 			    void *args)
74 {
75 	struct die_args *die = (struct die_args *)args;
76 	struct pt_regs *regs = die->regs;
77 
78 	hyperv_report_panic(regs);
79 	return NOTIFY_DONE;
80 }
81 
82 static struct notifier_block hyperv_die_block = {
83 	.notifier_call = hyperv_die_event,
84 };
85 static struct notifier_block hyperv_panic_block = {
86 	.notifier_call = hyperv_panic_event,
87 };
88 
89 static const char *fb_mmio_name = "fb_range";
90 static struct resource *fb_mmio;
91 static struct resource *hyperv_mmio;
92 static DEFINE_SEMAPHORE(hyperv_mmio_lock);
93 
94 static int vmbus_exists(void)
95 {
96 	if (hv_acpi_dev == NULL)
97 		return -ENODEV;
98 
99 	return 0;
100 }
101 
102 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
103 static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
104 {
105 	int i;
106 	for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
107 		sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
108 }
109 
110 static u8 channel_monitor_group(struct vmbus_channel *channel)
111 {
112 	return (u8)channel->offermsg.monitorid / 32;
113 }
114 
115 static u8 channel_monitor_offset(struct vmbus_channel *channel)
116 {
117 	return (u8)channel->offermsg.monitorid % 32;
118 }
119 
120 static u32 channel_pending(struct vmbus_channel *channel,
121 			   struct hv_monitor_page *monitor_page)
122 {
123 	u8 monitor_group = channel_monitor_group(channel);
124 	return monitor_page->trigger_group[monitor_group].pending;
125 }
126 
127 static u32 channel_latency(struct vmbus_channel *channel,
128 			   struct hv_monitor_page *monitor_page)
129 {
130 	u8 monitor_group = channel_monitor_group(channel);
131 	u8 monitor_offset = channel_monitor_offset(channel);
132 	return monitor_page->latency[monitor_group][monitor_offset];
133 }
134 
135 static u32 channel_conn_id(struct vmbus_channel *channel,
136 			   struct hv_monitor_page *monitor_page)
137 {
138 	u8 monitor_group = channel_monitor_group(channel);
139 	u8 monitor_offset = channel_monitor_offset(channel);
140 	return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
141 }
142 
143 static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
144 		       char *buf)
145 {
146 	struct hv_device *hv_dev = device_to_hv_device(dev);
147 
148 	if (!hv_dev->channel)
149 		return -ENODEV;
150 	return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
151 }
152 static DEVICE_ATTR_RO(id);
153 
154 static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
155 			  char *buf)
156 {
157 	struct hv_device *hv_dev = device_to_hv_device(dev);
158 
159 	if (!hv_dev->channel)
160 		return -ENODEV;
161 	return sprintf(buf, "%d\n", hv_dev->channel->state);
162 }
163 static DEVICE_ATTR_RO(state);
164 
165 static ssize_t monitor_id_show(struct device *dev,
166 			       struct device_attribute *dev_attr, char *buf)
167 {
168 	struct hv_device *hv_dev = device_to_hv_device(dev);
169 
170 	if (!hv_dev->channel)
171 		return -ENODEV;
172 	return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
173 }
174 static DEVICE_ATTR_RO(monitor_id);
175 
176 static ssize_t class_id_show(struct device *dev,
177 			       struct device_attribute *dev_attr, char *buf)
178 {
179 	struct hv_device *hv_dev = device_to_hv_device(dev);
180 
181 	if (!hv_dev->channel)
182 		return -ENODEV;
183 	return sprintf(buf, "{%pUl}\n",
184 		       hv_dev->channel->offermsg.offer.if_type.b);
185 }
186 static DEVICE_ATTR_RO(class_id);
187 
188 static ssize_t device_id_show(struct device *dev,
189 			      struct device_attribute *dev_attr, char *buf)
190 {
191 	struct hv_device *hv_dev = device_to_hv_device(dev);
192 
193 	if (!hv_dev->channel)
194 		return -ENODEV;
195 	return sprintf(buf, "{%pUl}\n",
196 		       hv_dev->channel->offermsg.offer.if_instance.b);
197 }
198 static DEVICE_ATTR_RO(device_id);
199 
200 static ssize_t modalias_show(struct device *dev,
201 			     struct device_attribute *dev_attr, char *buf)
202 {
203 	struct hv_device *hv_dev = device_to_hv_device(dev);
204 	char alias_name[VMBUS_ALIAS_LEN + 1];
205 
206 	print_alias_name(hv_dev, alias_name);
207 	return sprintf(buf, "vmbus:%s\n", alias_name);
208 }
209 static DEVICE_ATTR_RO(modalias);
210 
211 static ssize_t server_monitor_pending_show(struct device *dev,
212 					   struct device_attribute *dev_attr,
213 					   char *buf)
214 {
215 	struct hv_device *hv_dev = device_to_hv_device(dev);
216 
217 	if (!hv_dev->channel)
218 		return -ENODEV;
219 	return sprintf(buf, "%d\n",
220 		       channel_pending(hv_dev->channel,
221 				       vmbus_connection.monitor_pages[1]));
222 }
223 static DEVICE_ATTR_RO(server_monitor_pending);
224 
225 static ssize_t client_monitor_pending_show(struct device *dev,
226 					   struct device_attribute *dev_attr,
227 					   char *buf)
228 {
229 	struct hv_device *hv_dev = device_to_hv_device(dev);
230 
231 	if (!hv_dev->channel)
232 		return -ENODEV;
233 	return sprintf(buf, "%d\n",
234 		       channel_pending(hv_dev->channel,
235 				       vmbus_connection.monitor_pages[1]));
236 }
237 static DEVICE_ATTR_RO(client_monitor_pending);
238 
239 static ssize_t server_monitor_latency_show(struct device *dev,
240 					   struct device_attribute *dev_attr,
241 					   char *buf)
242 {
243 	struct hv_device *hv_dev = device_to_hv_device(dev);
244 
245 	if (!hv_dev->channel)
246 		return -ENODEV;
247 	return sprintf(buf, "%d\n",
248 		       channel_latency(hv_dev->channel,
249 				       vmbus_connection.monitor_pages[0]));
250 }
251 static DEVICE_ATTR_RO(server_monitor_latency);
252 
253 static ssize_t client_monitor_latency_show(struct device *dev,
254 					   struct device_attribute *dev_attr,
255 					   char *buf)
256 {
257 	struct hv_device *hv_dev = device_to_hv_device(dev);
258 
259 	if (!hv_dev->channel)
260 		return -ENODEV;
261 	return sprintf(buf, "%d\n",
262 		       channel_latency(hv_dev->channel,
263 				       vmbus_connection.monitor_pages[1]));
264 }
265 static DEVICE_ATTR_RO(client_monitor_latency);
266 
267 static ssize_t server_monitor_conn_id_show(struct device *dev,
268 					   struct device_attribute *dev_attr,
269 					   char *buf)
270 {
271 	struct hv_device *hv_dev = device_to_hv_device(dev);
272 
273 	if (!hv_dev->channel)
274 		return -ENODEV;
275 	return sprintf(buf, "%d\n",
276 		       channel_conn_id(hv_dev->channel,
277 				       vmbus_connection.monitor_pages[0]));
278 }
279 static DEVICE_ATTR_RO(server_monitor_conn_id);
280 
281 static ssize_t client_monitor_conn_id_show(struct device *dev,
282 					   struct device_attribute *dev_attr,
283 					   char *buf)
284 {
285 	struct hv_device *hv_dev = device_to_hv_device(dev);
286 
287 	if (!hv_dev->channel)
288 		return -ENODEV;
289 	return sprintf(buf, "%d\n",
290 		       channel_conn_id(hv_dev->channel,
291 				       vmbus_connection.monitor_pages[1]));
292 }
293 static DEVICE_ATTR_RO(client_monitor_conn_id);
294 
295 static ssize_t out_intr_mask_show(struct device *dev,
296 				  struct device_attribute *dev_attr, char *buf)
297 {
298 	struct hv_device *hv_dev = device_to_hv_device(dev);
299 	struct hv_ring_buffer_debug_info outbound;
300 
301 	if (!hv_dev->channel)
302 		return -ENODEV;
303 	hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
304 	return sprintf(buf, "%d\n", outbound.current_interrupt_mask);
305 }
306 static DEVICE_ATTR_RO(out_intr_mask);
307 
308 static ssize_t out_read_index_show(struct device *dev,
309 				   struct device_attribute *dev_attr, char *buf)
310 {
311 	struct hv_device *hv_dev = device_to_hv_device(dev);
312 	struct hv_ring_buffer_debug_info outbound;
313 
314 	if (!hv_dev->channel)
315 		return -ENODEV;
316 	hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
317 	return sprintf(buf, "%d\n", outbound.current_read_index);
318 }
319 static DEVICE_ATTR_RO(out_read_index);
320 
321 static ssize_t out_write_index_show(struct device *dev,
322 				    struct device_attribute *dev_attr,
323 				    char *buf)
324 {
325 	struct hv_device *hv_dev = device_to_hv_device(dev);
326 	struct hv_ring_buffer_debug_info outbound;
327 
328 	if (!hv_dev->channel)
329 		return -ENODEV;
330 	hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
331 	return sprintf(buf, "%d\n", outbound.current_write_index);
332 }
333 static DEVICE_ATTR_RO(out_write_index);
334 
335 static ssize_t out_read_bytes_avail_show(struct device *dev,
336 					 struct device_attribute *dev_attr,
337 					 char *buf)
338 {
339 	struct hv_device *hv_dev = device_to_hv_device(dev);
340 	struct hv_ring_buffer_debug_info outbound;
341 
342 	if (!hv_dev->channel)
343 		return -ENODEV;
344 	hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
345 	return sprintf(buf, "%d\n", outbound.bytes_avail_toread);
346 }
347 static DEVICE_ATTR_RO(out_read_bytes_avail);
348 
349 static ssize_t out_write_bytes_avail_show(struct device *dev,
350 					  struct device_attribute *dev_attr,
351 					  char *buf)
352 {
353 	struct hv_device *hv_dev = device_to_hv_device(dev);
354 	struct hv_ring_buffer_debug_info outbound;
355 
356 	if (!hv_dev->channel)
357 		return -ENODEV;
358 	hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
359 	return sprintf(buf, "%d\n", outbound.bytes_avail_towrite);
360 }
361 static DEVICE_ATTR_RO(out_write_bytes_avail);
362 
363 static ssize_t in_intr_mask_show(struct device *dev,
364 				 struct device_attribute *dev_attr, char *buf)
365 {
366 	struct hv_device *hv_dev = device_to_hv_device(dev);
367 	struct hv_ring_buffer_debug_info inbound;
368 
369 	if (!hv_dev->channel)
370 		return -ENODEV;
371 	hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
372 	return sprintf(buf, "%d\n", inbound.current_interrupt_mask);
373 }
374 static DEVICE_ATTR_RO(in_intr_mask);
375 
376 static ssize_t in_read_index_show(struct device *dev,
377 				  struct device_attribute *dev_attr, char *buf)
378 {
379 	struct hv_device *hv_dev = device_to_hv_device(dev);
380 	struct hv_ring_buffer_debug_info inbound;
381 
382 	if (!hv_dev->channel)
383 		return -ENODEV;
384 	hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
385 	return sprintf(buf, "%d\n", inbound.current_read_index);
386 }
387 static DEVICE_ATTR_RO(in_read_index);
388 
389 static ssize_t in_write_index_show(struct device *dev,
390 				   struct device_attribute *dev_attr, char *buf)
391 {
392 	struct hv_device *hv_dev = device_to_hv_device(dev);
393 	struct hv_ring_buffer_debug_info inbound;
394 
395 	if (!hv_dev->channel)
396 		return -ENODEV;
397 	hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
398 	return sprintf(buf, "%d\n", inbound.current_write_index);
399 }
400 static DEVICE_ATTR_RO(in_write_index);
401 
402 static ssize_t in_read_bytes_avail_show(struct device *dev,
403 					struct device_attribute *dev_attr,
404 					char *buf)
405 {
406 	struct hv_device *hv_dev = device_to_hv_device(dev);
407 	struct hv_ring_buffer_debug_info inbound;
408 
409 	if (!hv_dev->channel)
410 		return -ENODEV;
411 	hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
412 	return sprintf(buf, "%d\n", inbound.bytes_avail_toread);
413 }
414 static DEVICE_ATTR_RO(in_read_bytes_avail);
415 
416 static ssize_t in_write_bytes_avail_show(struct device *dev,
417 					 struct device_attribute *dev_attr,
418 					 char *buf)
419 {
420 	struct hv_device *hv_dev = device_to_hv_device(dev);
421 	struct hv_ring_buffer_debug_info inbound;
422 
423 	if (!hv_dev->channel)
424 		return -ENODEV;
425 	hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
426 	return sprintf(buf, "%d\n", inbound.bytes_avail_towrite);
427 }
428 static DEVICE_ATTR_RO(in_write_bytes_avail);
429 
430 static ssize_t channel_vp_mapping_show(struct device *dev,
431 				       struct device_attribute *dev_attr,
432 				       char *buf)
433 {
434 	struct hv_device *hv_dev = device_to_hv_device(dev);
435 	struct vmbus_channel *channel = hv_dev->channel, *cur_sc;
436 	unsigned long flags;
437 	int buf_size = PAGE_SIZE, n_written, tot_written;
438 	struct list_head *cur;
439 
440 	if (!channel)
441 		return -ENODEV;
442 
443 	tot_written = snprintf(buf, buf_size, "%u:%u\n",
444 		channel->offermsg.child_relid, channel->target_cpu);
445 
446 	spin_lock_irqsave(&channel->lock, flags);
447 
448 	list_for_each(cur, &channel->sc_list) {
449 		if (tot_written >= buf_size - 1)
450 			break;
451 
452 		cur_sc = list_entry(cur, struct vmbus_channel, sc_list);
453 		n_written = scnprintf(buf + tot_written,
454 				     buf_size - tot_written,
455 				     "%u:%u\n",
456 				     cur_sc->offermsg.child_relid,
457 				     cur_sc->target_cpu);
458 		tot_written += n_written;
459 	}
460 
461 	spin_unlock_irqrestore(&channel->lock, flags);
462 
463 	return tot_written;
464 }
465 static DEVICE_ATTR_RO(channel_vp_mapping);
466 
467 static ssize_t vendor_show(struct device *dev,
468 			   struct device_attribute *dev_attr,
469 			   char *buf)
470 {
471 	struct hv_device *hv_dev = device_to_hv_device(dev);
472 	return sprintf(buf, "0x%x\n", hv_dev->vendor_id);
473 }
474 static DEVICE_ATTR_RO(vendor);
475 
476 static ssize_t device_show(struct device *dev,
477 			   struct device_attribute *dev_attr,
478 			   char *buf)
479 {
480 	struct hv_device *hv_dev = device_to_hv_device(dev);
481 	return sprintf(buf, "0x%x\n", hv_dev->device_id);
482 }
483 static DEVICE_ATTR_RO(device);
484 
485 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
486 static struct attribute *vmbus_dev_attrs[] = {
487 	&dev_attr_id.attr,
488 	&dev_attr_state.attr,
489 	&dev_attr_monitor_id.attr,
490 	&dev_attr_class_id.attr,
491 	&dev_attr_device_id.attr,
492 	&dev_attr_modalias.attr,
493 	&dev_attr_server_monitor_pending.attr,
494 	&dev_attr_client_monitor_pending.attr,
495 	&dev_attr_server_monitor_latency.attr,
496 	&dev_attr_client_monitor_latency.attr,
497 	&dev_attr_server_monitor_conn_id.attr,
498 	&dev_attr_client_monitor_conn_id.attr,
499 	&dev_attr_out_intr_mask.attr,
500 	&dev_attr_out_read_index.attr,
501 	&dev_attr_out_write_index.attr,
502 	&dev_attr_out_read_bytes_avail.attr,
503 	&dev_attr_out_write_bytes_avail.attr,
504 	&dev_attr_in_intr_mask.attr,
505 	&dev_attr_in_read_index.attr,
506 	&dev_attr_in_write_index.attr,
507 	&dev_attr_in_read_bytes_avail.attr,
508 	&dev_attr_in_write_bytes_avail.attr,
509 	&dev_attr_channel_vp_mapping.attr,
510 	&dev_attr_vendor.attr,
511 	&dev_attr_device.attr,
512 	NULL,
513 };
514 ATTRIBUTE_GROUPS(vmbus_dev);
515 
516 /*
517  * vmbus_uevent - add uevent for our device
518  *
519  * This routine is invoked when a device is added or removed on the vmbus to
520  * generate a uevent to udev in the userspace. The udev will then look at its
521  * rule and the uevent generated here to load the appropriate driver
522  *
523  * The alias string will be of the form vmbus:guid where guid is the string
524  * representation of the device guid (each byte of the guid will be
525  * represented with two hex characters.
526  */
527 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
528 {
529 	struct hv_device *dev = device_to_hv_device(device);
530 	int ret;
531 	char alias_name[VMBUS_ALIAS_LEN + 1];
532 
533 	print_alias_name(dev, alias_name);
534 	ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
535 	return ret;
536 }
537 
538 static const uuid_le null_guid;
539 
540 static inline bool is_null_guid(const uuid_le *guid)
541 {
542 	if (uuid_le_cmp(*guid, null_guid))
543 		return false;
544 	return true;
545 }
546 
547 /*
548  * Return a matching hv_vmbus_device_id pointer.
549  * If there is no match, return NULL.
550  */
551 static const struct hv_vmbus_device_id *hv_vmbus_get_id(struct hv_driver *drv,
552 					const uuid_le *guid)
553 {
554 	const struct hv_vmbus_device_id *id = NULL;
555 	struct vmbus_dynid *dynid;
556 
557 	/* Look at the dynamic ids first, before the static ones */
558 	spin_lock(&drv->dynids.lock);
559 	list_for_each_entry(dynid, &drv->dynids.list, node) {
560 		if (!uuid_le_cmp(dynid->id.guid, *guid)) {
561 			id = &dynid->id;
562 			break;
563 		}
564 	}
565 	spin_unlock(&drv->dynids.lock);
566 
567 	if (id)
568 		return id;
569 
570 	id = drv->id_table;
571 	if (id == NULL)
572 		return NULL; /* empty device table */
573 
574 	for (; !is_null_guid(&id->guid); id++)
575 		if (!uuid_le_cmp(id->guid, *guid))
576 			return id;
577 
578 	return NULL;
579 }
580 
581 /* vmbus_add_dynid - add a new device ID to this driver and re-probe devices */
582 static int vmbus_add_dynid(struct hv_driver *drv, uuid_le *guid)
583 {
584 	struct vmbus_dynid *dynid;
585 
586 	dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
587 	if (!dynid)
588 		return -ENOMEM;
589 
590 	dynid->id.guid = *guid;
591 
592 	spin_lock(&drv->dynids.lock);
593 	list_add_tail(&dynid->node, &drv->dynids.list);
594 	spin_unlock(&drv->dynids.lock);
595 
596 	return driver_attach(&drv->driver);
597 }
598 
599 static void vmbus_free_dynids(struct hv_driver *drv)
600 {
601 	struct vmbus_dynid *dynid, *n;
602 
603 	spin_lock(&drv->dynids.lock);
604 	list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
605 		list_del(&dynid->node);
606 		kfree(dynid);
607 	}
608 	spin_unlock(&drv->dynids.lock);
609 }
610 
611 /*
612  * store_new_id - sysfs frontend to vmbus_add_dynid()
613  *
614  * Allow GUIDs to be added to an existing driver via sysfs.
615  */
616 static ssize_t new_id_store(struct device_driver *driver, const char *buf,
617 			    size_t count)
618 {
619 	struct hv_driver *drv = drv_to_hv_drv(driver);
620 	uuid_le guid;
621 	ssize_t retval;
622 
623 	retval = uuid_le_to_bin(buf, &guid);
624 	if (retval)
625 		return retval;
626 
627 	if (hv_vmbus_get_id(drv, &guid))
628 		return -EEXIST;
629 
630 	retval = vmbus_add_dynid(drv, &guid);
631 	if (retval)
632 		return retval;
633 	return count;
634 }
635 static DRIVER_ATTR_WO(new_id);
636 
637 /*
638  * store_remove_id - remove a PCI device ID from this driver
639  *
640  * Removes a dynamic pci device ID to this driver.
641  */
642 static ssize_t remove_id_store(struct device_driver *driver, const char *buf,
643 			       size_t count)
644 {
645 	struct hv_driver *drv = drv_to_hv_drv(driver);
646 	struct vmbus_dynid *dynid, *n;
647 	uuid_le guid;
648 	ssize_t retval;
649 
650 	retval = uuid_le_to_bin(buf, &guid);
651 	if (retval)
652 		return retval;
653 
654 	retval = -ENODEV;
655 	spin_lock(&drv->dynids.lock);
656 	list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
657 		struct hv_vmbus_device_id *id = &dynid->id;
658 
659 		if (!uuid_le_cmp(id->guid, guid)) {
660 			list_del(&dynid->node);
661 			kfree(dynid);
662 			retval = count;
663 			break;
664 		}
665 	}
666 	spin_unlock(&drv->dynids.lock);
667 
668 	return retval;
669 }
670 static DRIVER_ATTR_WO(remove_id);
671 
672 static struct attribute *vmbus_drv_attrs[] = {
673 	&driver_attr_new_id.attr,
674 	&driver_attr_remove_id.attr,
675 	NULL,
676 };
677 ATTRIBUTE_GROUPS(vmbus_drv);
678 
679 
680 /*
681  * vmbus_match - Attempt to match the specified device to the specified driver
682  */
683 static int vmbus_match(struct device *device, struct device_driver *driver)
684 {
685 	struct hv_driver *drv = drv_to_hv_drv(driver);
686 	struct hv_device *hv_dev = device_to_hv_device(device);
687 
688 	/* The hv_sock driver handles all hv_sock offers. */
689 	if (is_hvsock_channel(hv_dev->channel))
690 		return drv->hvsock;
691 
692 	if (hv_vmbus_get_id(drv, &hv_dev->dev_type))
693 		return 1;
694 
695 	return 0;
696 }
697 
698 /*
699  * vmbus_probe - Add the new vmbus's child device
700  */
701 static int vmbus_probe(struct device *child_device)
702 {
703 	int ret = 0;
704 	struct hv_driver *drv =
705 			drv_to_hv_drv(child_device->driver);
706 	struct hv_device *dev = device_to_hv_device(child_device);
707 	const struct hv_vmbus_device_id *dev_id;
708 
709 	dev_id = hv_vmbus_get_id(drv, &dev->dev_type);
710 	if (drv->probe) {
711 		ret = drv->probe(dev, dev_id);
712 		if (ret != 0)
713 			pr_err("probe failed for device %s (%d)\n",
714 			       dev_name(child_device), ret);
715 
716 	} else {
717 		pr_err("probe not set for driver %s\n",
718 		       dev_name(child_device));
719 		ret = -ENODEV;
720 	}
721 	return ret;
722 }
723 
724 /*
725  * vmbus_remove - Remove a vmbus device
726  */
727 static int vmbus_remove(struct device *child_device)
728 {
729 	struct hv_driver *drv;
730 	struct hv_device *dev = device_to_hv_device(child_device);
731 
732 	if (child_device->driver) {
733 		drv = drv_to_hv_drv(child_device->driver);
734 		if (drv->remove)
735 			drv->remove(dev);
736 	}
737 
738 	return 0;
739 }
740 
741 
742 /*
743  * vmbus_shutdown - Shutdown a vmbus device
744  */
745 static void vmbus_shutdown(struct device *child_device)
746 {
747 	struct hv_driver *drv;
748 	struct hv_device *dev = device_to_hv_device(child_device);
749 
750 
751 	/* The device may not be attached yet */
752 	if (!child_device->driver)
753 		return;
754 
755 	drv = drv_to_hv_drv(child_device->driver);
756 
757 	if (drv->shutdown)
758 		drv->shutdown(dev);
759 }
760 
761 
762 /*
763  * vmbus_device_release - Final callback release of the vmbus child device
764  */
765 static void vmbus_device_release(struct device *device)
766 {
767 	struct hv_device *hv_dev = device_to_hv_device(device);
768 	struct vmbus_channel *channel = hv_dev->channel;
769 
770 	mutex_lock(&vmbus_connection.channel_mutex);
771 	hv_process_channel_removal(channel,
772 				   channel->offermsg.child_relid);
773 	mutex_unlock(&vmbus_connection.channel_mutex);
774 	kfree(hv_dev);
775 
776 }
777 
778 /* The one and only one */
779 static struct bus_type  hv_bus = {
780 	.name =		"vmbus",
781 	.match =		vmbus_match,
782 	.shutdown =		vmbus_shutdown,
783 	.remove =		vmbus_remove,
784 	.probe =		vmbus_probe,
785 	.uevent =		vmbus_uevent,
786 	.dev_groups =		vmbus_dev_groups,
787 	.drv_groups =		vmbus_drv_groups,
788 };
789 
790 struct onmessage_work_context {
791 	struct work_struct work;
792 	struct hv_message msg;
793 };
794 
795 static void vmbus_onmessage_work(struct work_struct *work)
796 {
797 	struct onmessage_work_context *ctx;
798 
799 	/* Do not process messages if we're in DISCONNECTED state */
800 	if (vmbus_connection.conn_state == DISCONNECTED)
801 		return;
802 
803 	ctx = container_of(work, struct onmessage_work_context,
804 			   work);
805 	vmbus_onmessage(&ctx->msg);
806 	kfree(ctx);
807 }
808 
809 static void hv_process_timer_expiration(struct hv_message *msg,
810 					struct hv_per_cpu_context *hv_cpu)
811 {
812 	struct clock_event_device *dev = hv_cpu->clk_evt;
813 
814 	if (dev->event_handler)
815 		dev->event_handler(dev);
816 
817 	vmbus_signal_eom(msg, HVMSG_TIMER_EXPIRED);
818 }
819 
820 void vmbus_on_msg_dpc(unsigned long data)
821 {
822 	struct hv_per_cpu_context *hv_cpu = (void *)data;
823 	void *page_addr = hv_cpu->synic_message_page;
824 	struct hv_message *msg = (struct hv_message *)page_addr +
825 				  VMBUS_MESSAGE_SINT;
826 	struct vmbus_channel_message_header *hdr;
827 	const struct vmbus_channel_message_table_entry *entry;
828 	struct onmessage_work_context *ctx;
829 	u32 message_type = msg->header.message_type;
830 
831 	if (message_type == HVMSG_NONE)
832 		/* no msg */
833 		return;
834 
835 	hdr = (struct vmbus_channel_message_header *)msg->u.payload;
836 
837 	if (hdr->msgtype >= CHANNELMSG_COUNT) {
838 		WARN_ONCE(1, "unknown msgtype=%d\n", hdr->msgtype);
839 		goto msg_handled;
840 	}
841 
842 	entry = &channel_message_table[hdr->msgtype];
843 	if (entry->handler_type	== VMHT_BLOCKING) {
844 		ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
845 		if (ctx == NULL)
846 			return;
847 
848 		INIT_WORK(&ctx->work, vmbus_onmessage_work);
849 		memcpy(&ctx->msg, msg, sizeof(*msg));
850 
851 		/*
852 		 * The host can generate a rescind message while we
853 		 * may still be handling the original offer. We deal with
854 		 * this condition by ensuring the processing is done on the
855 		 * same CPU.
856 		 */
857 		switch (hdr->msgtype) {
858 		case CHANNELMSG_RESCIND_CHANNELOFFER:
859 			/*
860 			 * If we are handling the rescind message;
861 			 * schedule the work on the global work queue.
862 			 */
863 			schedule_work_on(vmbus_connection.connect_cpu,
864 					 &ctx->work);
865 			break;
866 
867 		case CHANNELMSG_OFFERCHANNEL:
868 			atomic_inc(&vmbus_connection.offer_in_progress);
869 			queue_work_on(vmbus_connection.connect_cpu,
870 				      vmbus_connection.work_queue,
871 				      &ctx->work);
872 			break;
873 
874 		default:
875 			queue_work(vmbus_connection.work_queue, &ctx->work);
876 		}
877 	} else
878 		entry->message_handler(hdr);
879 
880 msg_handled:
881 	vmbus_signal_eom(msg, message_type);
882 }
883 
884 
885 /*
886  * Direct callback for channels using other deferred processing
887  */
888 static void vmbus_channel_isr(struct vmbus_channel *channel)
889 {
890 	void (*callback_fn)(void *);
891 
892 	callback_fn = READ_ONCE(channel->onchannel_callback);
893 	if (likely(callback_fn != NULL))
894 		(*callback_fn)(channel->channel_callback_context);
895 }
896 
897 /*
898  * Schedule all channels with events pending
899  */
900 static void vmbus_chan_sched(struct hv_per_cpu_context *hv_cpu)
901 {
902 	unsigned long *recv_int_page;
903 	u32 maxbits, relid;
904 
905 	if (vmbus_proto_version < VERSION_WIN8) {
906 		maxbits = MAX_NUM_CHANNELS_SUPPORTED;
907 		recv_int_page = vmbus_connection.recv_int_page;
908 	} else {
909 		/*
910 		 * When the host is win8 and beyond, the event page
911 		 * can be directly checked to get the id of the channel
912 		 * that has the interrupt pending.
913 		 */
914 		void *page_addr = hv_cpu->synic_event_page;
915 		union hv_synic_event_flags *event
916 			= (union hv_synic_event_flags *)page_addr +
917 						 VMBUS_MESSAGE_SINT;
918 
919 		maxbits = HV_EVENT_FLAGS_COUNT;
920 		recv_int_page = event->flags;
921 	}
922 
923 	if (unlikely(!recv_int_page))
924 		return;
925 
926 	for_each_set_bit(relid, recv_int_page, maxbits) {
927 		struct vmbus_channel *channel;
928 
929 		if (!sync_test_and_clear_bit(relid, recv_int_page))
930 			continue;
931 
932 		/* Special case - vmbus channel protocol msg */
933 		if (relid == 0)
934 			continue;
935 
936 		rcu_read_lock();
937 
938 		/* Find channel based on relid */
939 		list_for_each_entry_rcu(channel, &hv_cpu->chan_list, percpu_list) {
940 			if (channel->offermsg.child_relid != relid)
941 				continue;
942 
943 			switch (channel->callback_mode) {
944 			case HV_CALL_ISR:
945 				vmbus_channel_isr(channel);
946 				break;
947 
948 			case HV_CALL_BATCHED:
949 				hv_begin_read(&channel->inbound);
950 				/* fallthrough */
951 			case HV_CALL_DIRECT:
952 				tasklet_schedule(&channel->callback_event);
953 			}
954 		}
955 
956 		rcu_read_unlock();
957 	}
958 }
959 
960 static void vmbus_isr(void)
961 {
962 	struct hv_per_cpu_context *hv_cpu
963 		= this_cpu_ptr(hv_context.cpu_context);
964 	void *page_addr = hv_cpu->synic_event_page;
965 	struct hv_message *msg;
966 	union hv_synic_event_flags *event;
967 	bool handled = false;
968 
969 	if (unlikely(page_addr == NULL))
970 		return;
971 
972 	event = (union hv_synic_event_flags *)page_addr +
973 					 VMBUS_MESSAGE_SINT;
974 	/*
975 	 * Check for events before checking for messages. This is the order
976 	 * in which events and messages are checked in Windows guests on
977 	 * Hyper-V, and the Windows team suggested we do the same.
978 	 */
979 
980 	if ((vmbus_proto_version == VERSION_WS2008) ||
981 		(vmbus_proto_version == VERSION_WIN7)) {
982 
983 		/* Since we are a child, we only need to check bit 0 */
984 		if (sync_test_and_clear_bit(0, event->flags))
985 			handled = true;
986 	} else {
987 		/*
988 		 * Our host is win8 or above. The signaling mechanism
989 		 * has changed and we can directly look at the event page.
990 		 * If bit n is set then we have an interrup on the channel
991 		 * whose id is n.
992 		 */
993 		handled = true;
994 	}
995 
996 	if (handled)
997 		vmbus_chan_sched(hv_cpu);
998 
999 	page_addr = hv_cpu->synic_message_page;
1000 	msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
1001 
1002 	/* Check if there are actual msgs to be processed */
1003 	if (msg->header.message_type != HVMSG_NONE) {
1004 		if (msg->header.message_type == HVMSG_TIMER_EXPIRED)
1005 			hv_process_timer_expiration(msg, hv_cpu);
1006 		else
1007 			tasklet_schedule(&hv_cpu->msg_dpc);
1008 	}
1009 
1010 	add_interrupt_randomness(HYPERVISOR_CALLBACK_VECTOR, 0);
1011 }
1012 
1013 
1014 /*
1015  * vmbus_bus_init -Main vmbus driver initialization routine.
1016  *
1017  * Here, we
1018  *	- initialize the vmbus driver context
1019  *	- invoke the vmbus hv main init routine
1020  *	- retrieve the channel offers
1021  */
1022 static int vmbus_bus_init(void)
1023 {
1024 	int ret;
1025 
1026 	/* Hypervisor initialization...setup hypercall page..etc */
1027 	ret = hv_init();
1028 	if (ret != 0) {
1029 		pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
1030 		return ret;
1031 	}
1032 
1033 	ret = bus_register(&hv_bus);
1034 	if (ret)
1035 		return ret;
1036 
1037 	hv_setup_vmbus_irq(vmbus_isr);
1038 
1039 	ret = hv_synic_alloc();
1040 	if (ret)
1041 		goto err_alloc;
1042 	/*
1043 	 * Initialize the per-cpu interrupt state and
1044 	 * connect to the host.
1045 	 */
1046 	ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "x86/hyperv:online",
1047 				hv_synic_init, hv_synic_cleanup);
1048 	if (ret < 0)
1049 		goto err_alloc;
1050 	hyperv_cpuhp_online = ret;
1051 
1052 	ret = vmbus_connect();
1053 	if (ret)
1054 		goto err_connect;
1055 
1056 	/*
1057 	 * Only register if the crash MSRs are available
1058 	 */
1059 	if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
1060 		register_die_notifier(&hyperv_die_block);
1061 		atomic_notifier_chain_register(&panic_notifier_list,
1062 					       &hyperv_panic_block);
1063 	}
1064 
1065 	vmbus_request_offers();
1066 
1067 	return 0;
1068 
1069 err_connect:
1070 	cpuhp_remove_state(hyperv_cpuhp_online);
1071 err_alloc:
1072 	hv_synic_free();
1073 	hv_remove_vmbus_irq();
1074 
1075 	bus_unregister(&hv_bus);
1076 
1077 	return ret;
1078 }
1079 
1080 /**
1081  * __vmbus_child_driver_register() - Register a vmbus's driver
1082  * @hv_driver: Pointer to driver structure you want to register
1083  * @owner: owner module of the drv
1084  * @mod_name: module name string
1085  *
1086  * Registers the given driver with Linux through the 'driver_register()' call
1087  * and sets up the hyper-v vmbus handling for this driver.
1088  * It will return the state of the 'driver_register()' call.
1089  *
1090  */
1091 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
1092 {
1093 	int ret;
1094 
1095 	pr_info("registering driver %s\n", hv_driver->name);
1096 
1097 	ret = vmbus_exists();
1098 	if (ret < 0)
1099 		return ret;
1100 
1101 	hv_driver->driver.name = hv_driver->name;
1102 	hv_driver->driver.owner = owner;
1103 	hv_driver->driver.mod_name = mod_name;
1104 	hv_driver->driver.bus = &hv_bus;
1105 
1106 	spin_lock_init(&hv_driver->dynids.lock);
1107 	INIT_LIST_HEAD(&hv_driver->dynids.list);
1108 
1109 	ret = driver_register(&hv_driver->driver);
1110 
1111 	return ret;
1112 }
1113 EXPORT_SYMBOL_GPL(__vmbus_driver_register);
1114 
1115 /**
1116  * vmbus_driver_unregister() - Unregister a vmbus's driver
1117  * @hv_driver: Pointer to driver structure you want to
1118  *             un-register
1119  *
1120  * Un-register the given driver that was previous registered with a call to
1121  * vmbus_driver_register()
1122  */
1123 void vmbus_driver_unregister(struct hv_driver *hv_driver)
1124 {
1125 	pr_info("unregistering driver %s\n", hv_driver->name);
1126 
1127 	if (!vmbus_exists()) {
1128 		driver_unregister(&hv_driver->driver);
1129 		vmbus_free_dynids(hv_driver);
1130 	}
1131 }
1132 EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
1133 
1134 /*
1135  * vmbus_device_create - Creates and registers a new child device
1136  * on the vmbus.
1137  */
1138 struct hv_device *vmbus_device_create(const uuid_le *type,
1139 				      const uuid_le *instance,
1140 				      struct vmbus_channel *channel)
1141 {
1142 	struct hv_device *child_device_obj;
1143 
1144 	child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
1145 	if (!child_device_obj) {
1146 		pr_err("Unable to allocate device object for child device\n");
1147 		return NULL;
1148 	}
1149 
1150 	child_device_obj->channel = channel;
1151 	memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
1152 	memcpy(&child_device_obj->dev_instance, instance,
1153 	       sizeof(uuid_le));
1154 	child_device_obj->vendor_id = 0x1414; /* MSFT vendor ID */
1155 
1156 
1157 	return child_device_obj;
1158 }
1159 
1160 /*
1161  * vmbus_device_register - Register the child device
1162  */
1163 int vmbus_device_register(struct hv_device *child_device_obj)
1164 {
1165 	int ret = 0;
1166 
1167 	dev_set_name(&child_device_obj->device, "%pUl",
1168 		     child_device_obj->channel->offermsg.offer.if_instance.b);
1169 
1170 	child_device_obj->device.bus = &hv_bus;
1171 	child_device_obj->device.parent = &hv_acpi_dev->dev;
1172 	child_device_obj->device.release = vmbus_device_release;
1173 
1174 	/*
1175 	 * Register with the LDM. This will kick off the driver/device
1176 	 * binding...which will eventually call vmbus_match() and vmbus_probe()
1177 	 */
1178 	ret = device_register(&child_device_obj->device);
1179 
1180 	if (ret)
1181 		pr_err("Unable to register child device\n");
1182 	else
1183 		pr_debug("child device %s registered\n",
1184 			dev_name(&child_device_obj->device));
1185 
1186 	return ret;
1187 }
1188 
1189 /*
1190  * vmbus_device_unregister - Remove the specified child device
1191  * from the vmbus.
1192  */
1193 void vmbus_device_unregister(struct hv_device *device_obj)
1194 {
1195 	pr_debug("child device %s unregistered\n",
1196 		dev_name(&device_obj->device));
1197 
1198 	/*
1199 	 * Kick off the process of unregistering the device.
1200 	 * This will call vmbus_remove() and eventually vmbus_device_release()
1201 	 */
1202 	device_unregister(&device_obj->device);
1203 }
1204 
1205 
1206 /*
1207  * VMBUS is an acpi enumerated device. Get the information we
1208  * need from DSDT.
1209  */
1210 #define VTPM_BASE_ADDRESS 0xfed40000
1211 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx)
1212 {
1213 	resource_size_t start = 0;
1214 	resource_size_t end = 0;
1215 	struct resource *new_res;
1216 	struct resource **old_res = &hyperv_mmio;
1217 	struct resource **prev_res = NULL;
1218 
1219 	switch (res->type) {
1220 
1221 	/*
1222 	 * "Address" descriptors are for bus windows. Ignore
1223 	 * "memory" descriptors, which are for registers on
1224 	 * devices.
1225 	 */
1226 	case ACPI_RESOURCE_TYPE_ADDRESS32:
1227 		start = res->data.address32.address.minimum;
1228 		end = res->data.address32.address.maximum;
1229 		break;
1230 
1231 	case ACPI_RESOURCE_TYPE_ADDRESS64:
1232 		start = res->data.address64.address.minimum;
1233 		end = res->data.address64.address.maximum;
1234 		break;
1235 
1236 	default:
1237 		/* Unused resource type */
1238 		return AE_OK;
1239 
1240 	}
1241 	/*
1242 	 * Ignore ranges that are below 1MB, as they're not
1243 	 * necessary or useful here.
1244 	 */
1245 	if (end < 0x100000)
1246 		return AE_OK;
1247 
1248 	new_res = kzalloc(sizeof(*new_res), GFP_ATOMIC);
1249 	if (!new_res)
1250 		return AE_NO_MEMORY;
1251 
1252 	/* If this range overlaps the virtual TPM, truncate it. */
1253 	if (end > VTPM_BASE_ADDRESS && start < VTPM_BASE_ADDRESS)
1254 		end = VTPM_BASE_ADDRESS;
1255 
1256 	new_res->name = "hyperv mmio";
1257 	new_res->flags = IORESOURCE_MEM;
1258 	new_res->start = start;
1259 	new_res->end = end;
1260 
1261 	/*
1262 	 * If two ranges are adjacent, merge them.
1263 	 */
1264 	do {
1265 		if (!*old_res) {
1266 			*old_res = new_res;
1267 			break;
1268 		}
1269 
1270 		if (((*old_res)->end + 1) == new_res->start) {
1271 			(*old_res)->end = new_res->end;
1272 			kfree(new_res);
1273 			break;
1274 		}
1275 
1276 		if ((*old_res)->start == new_res->end + 1) {
1277 			(*old_res)->start = new_res->start;
1278 			kfree(new_res);
1279 			break;
1280 		}
1281 
1282 		if ((*old_res)->start > new_res->end) {
1283 			new_res->sibling = *old_res;
1284 			if (prev_res)
1285 				(*prev_res)->sibling = new_res;
1286 			*old_res = new_res;
1287 			break;
1288 		}
1289 
1290 		prev_res = old_res;
1291 		old_res = &(*old_res)->sibling;
1292 
1293 	} while (1);
1294 
1295 	return AE_OK;
1296 }
1297 
1298 static int vmbus_acpi_remove(struct acpi_device *device)
1299 {
1300 	struct resource *cur_res;
1301 	struct resource *next_res;
1302 
1303 	if (hyperv_mmio) {
1304 		if (fb_mmio) {
1305 			__release_region(hyperv_mmio, fb_mmio->start,
1306 					 resource_size(fb_mmio));
1307 			fb_mmio = NULL;
1308 		}
1309 
1310 		for (cur_res = hyperv_mmio; cur_res; cur_res = next_res) {
1311 			next_res = cur_res->sibling;
1312 			kfree(cur_res);
1313 		}
1314 	}
1315 
1316 	return 0;
1317 }
1318 
1319 static void vmbus_reserve_fb(void)
1320 {
1321 	int size;
1322 	/*
1323 	 * Make a claim for the frame buffer in the resource tree under the
1324 	 * first node, which will be the one below 4GB.  The length seems to
1325 	 * be underreported, particularly in a Generation 1 VM.  So start out
1326 	 * reserving a larger area and make it smaller until it succeeds.
1327 	 */
1328 
1329 	if (screen_info.lfb_base) {
1330 		if (efi_enabled(EFI_BOOT))
1331 			size = max_t(__u32, screen_info.lfb_size, 0x800000);
1332 		else
1333 			size = max_t(__u32, screen_info.lfb_size, 0x4000000);
1334 
1335 		for (; !fb_mmio && (size >= 0x100000); size >>= 1) {
1336 			fb_mmio = __request_region(hyperv_mmio,
1337 						   screen_info.lfb_base, size,
1338 						   fb_mmio_name, 0);
1339 		}
1340 	}
1341 }
1342 
1343 /**
1344  * vmbus_allocate_mmio() - Pick a memory-mapped I/O range.
1345  * @new:		If successful, supplied a pointer to the
1346  *			allocated MMIO space.
1347  * @device_obj:		Identifies the caller
1348  * @min:		Minimum guest physical address of the
1349  *			allocation
1350  * @max:		Maximum guest physical address
1351  * @size:		Size of the range to be allocated
1352  * @align:		Alignment of the range to be allocated
1353  * @fb_overlap_ok:	Whether this allocation can be allowed
1354  *			to overlap the video frame buffer.
1355  *
1356  * This function walks the resources granted to VMBus by the
1357  * _CRS object in the ACPI namespace underneath the parent
1358  * "bridge" whether that's a root PCI bus in the Generation 1
1359  * case or a Module Device in the Generation 2 case.  It then
1360  * attempts to allocate from the global MMIO pool in a way that
1361  * matches the constraints supplied in these parameters and by
1362  * that _CRS.
1363  *
1364  * Return: 0 on success, -errno on failure
1365  */
1366 int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj,
1367 			resource_size_t min, resource_size_t max,
1368 			resource_size_t size, resource_size_t align,
1369 			bool fb_overlap_ok)
1370 {
1371 	struct resource *iter, *shadow;
1372 	resource_size_t range_min, range_max, start;
1373 	const char *dev_n = dev_name(&device_obj->device);
1374 	int retval;
1375 
1376 	retval = -ENXIO;
1377 	down(&hyperv_mmio_lock);
1378 
1379 	/*
1380 	 * If overlaps with frame buffers are allowed, then first attempt to
1381 	 * make the allocation from within the reserved region.  Because it
1382 	 * is already reserved, no shadow allocation is necessary.
1383 	 */
1384 	if (fb_overlap_ok && fb_mmio && !(min > fb_mmio->end) &&
1385 	    !(max < fb_mmio->start)) {
1386 
1387 		range_min = fb_mmio->start;
1388 		range_max = fb_mmio->end;
1389 		start = (range_min + align - 1) & ~(align - 1);
1390 		for (; start + size - 1 <= range_max; start += align) {
1391 			*new = request_mem_region_exclusive(start, size, dev_n);
1392 			if (*new) {
1393 				retval = 0;
1394 				goto exit;
1395 			}
1396 		}
1397 	}
1398 
1399 	for (iter = hyperv_mmio; iter; iter = iter->sibling) {
1400 		if ((iter->start >= max) || (iter->end <= min))
1401 			continue;
1402 
1403 		range_min = iter->start;
1404 		range_max = iter->end;
1405 		start = (range_min + align - 1) & ~(align - 1);
1406 		for (; start + size - 1 <= range_max; start += align) {
1407 			shadow = __request_region(iter, start, size, NULL,
1408 						  IORESOURCE_BUSY);
1409 			if (!shadow)
1410 				continue;
1411 
1412 			*new = request_mem_region_exclusive(start, size, dev_n);
1413 			if (*new) {
1414 				shadow->name = (char *)*new;
1415 				retval = 0;
1416 				goto exit;
1417 			}
1418 
1419 			__release_region(iter, start, size);
1420 		}
1421 	}
1422 
1423 exit:
1424 	up(&hyperv_mmio_lock);
1425 	return retval;
1426 }
1427 EXPORT_SYMBOL_GPL(vmbus_allocate_mmio);
1428 
1429 /**
1430  * vmbus_free_mmio() - Free a memory-mapped I/O range.
1431  * @start:		Base address of region to release.
1432  * @size:		Size of the range to be allocated
1433  *
1434  * This function releases anything requested by
1435  * vmbus_mmio_allocate().
1436  */
1437 void vmbus_free_mmio(resource_size_t start, resource_size_t size)
1438 {
1439 	struct resource *iter;
1440 
1441 	down(&hyperv_mmio_lock);
1442 	for (iter = hyperv_mmio; iter; iter = iter->sibling) {
1443 		if ((iter->start >= start + size) || (iter->end <= start))
1444 			continue;
1445 
1446 		__release_region(iter, start, size);
1447 	}
1448 	release_mem_region(start, size);
1449 	up(&hyperv_mmio_lock);
1450 
1451 }
1452 EXPORT_SYMBOL_GPL(vmbus_free_mmio);
1453 
1454 /**
1455  * vmbus_cpu_number_to_vp_number() - Map CPU to VP.
1456  * @cpu_number: CPU number in Linux terms
1457  *
1458  * This function returns the mapping between the Linux processor
1459  * number and the hypervisor's virtual processor number, useful
1460  * in making hypercalls and such that talk about specific
1461  * processors.
1462  *
1463  * Return: Virtual processor number in Hyper-V terms
1464  */
1465 int vmbus_cpu_number_to_vp_number(int cpu_number)
1466 {
1467 	return hv_context.vp_index[cpu_number];
1468 }
1469 EXPORT_SYMBOL_GPL(vmbus_cpu_number_to_vp_number);
1470 
1471 static int vmbus_acpi_add(struct acpi_device *device)
1472 {
1473 	acpi_status result;
1474 	int ret_val = -ENODEV;
1475 	struct acpi_device *ancestor;
1476 
1477 	hv_acpi_dev = device;
1478 
1479 	result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
1480 					vmbus_walk_resources, NULL);
1481 
1482 	if (ACPI_FAILURE(result))
1483 		goto acpi_walk_err;
1484 	/*
1485 	 * Some ancestor of the vmbus acpi device (Gen1 or Gen2
1486 	 * firmware) is the VMOD that has the mmio ranges. Get that.
1487 	 */
1488 	for (ancestor = device->parent; ancestor; ancestor = ancestor->parent) {
1489 		result = acpi_walk_resources(ancestor->handle, METHOD_NAME__CRS,
1490 					     vmbus_walk_resources, NULL);
1491 
1492 		if (ACPI_FAILURE(result))
1493 			continue;
1494 		if (hyperv_mmio) {
1495 			vmbus_reserve_fb();
1496 			break;
1497 		}
1498 	}
1499 	ret_val = 0;
1500 
1501 acpi_walk_err:
1502 	complete(&probe_event);
1503 	if (ret_val)
1504 		vmbus_acpi_remove(device);
1505 	return ret_val;
1506 }
1507 
1508 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
1509 	{"VMBUS", 0},
1510 	{"VMBus", 0},
1511 	{"", 0},
1512 };
1513 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
1514 
1515 static struct acpi_driver vmbus_acpi_driver = {
1516 	.name = "vmbus",
1517 	.ids = vmbus_acpi_device_ids,
1518 	.ops = {
1519 		.add = vmbus_acpi_add,
1520 		.remove = vmbus_acpi_remove,
1521 	},
1522 };
1523 
1524 static void hv_kexec_handler(void)
1525 {
1526 	hv_synic_clockevents_cleanup();
1527 	vmbus_initiate_unload(false);
1528 	vmbus_connection.conn_state = DISCONNECTED;
1529 	/* Make sure conn_state is set as hv_synic_cleanup checks for it */
1530 	mb();
1531 	cpuhp_remove_state(hyperv_cpuhp_online);
1532 	hyperv_cleanup();
1533 };
1534 
1535 static void hv_crash_handler(struct pt_regs *regs)
1536 {
1537 	vmbus_initiate_unload(true);
1538 	/*
1539 	 * In crash handler we can't schedule synic cleanup for all CPUs,
1540 	 * doing the cleanup for current CPU only. This should be sufficient
1541 	 * for kdump.
1542 	 */
1543 	vmbus_connection.conn_state = DISCONNECTED;
1544 	hv_synic_cleanup(smp_processor_id());
1545 	hyperv_cleanup();
1546 };
1547 
1548 static int __init hv_acpi_init(void)
1549 {
1550 	int ret, t;
1551 
1552 	if (x86_hyper != &x86_hyper_ms_hyperv)
1553 		return -ENODEV;
1554 
1555 	init_completion(&probe_event);
1556 
1557 	/*
1558 	 * Get ACPI resources first.
1559 	 */
1560 	ret = acpi_bus_register_driver(&vmbus_acpi_driver);
1561 
1562 	if (ret)
1563 		return ret;
1564 
1565 	t = wait_for_completion_timeout(&probe_event, 5*HZ);
1566 	if (t == 0) {
1567 		ret = -ETIMEDOUT;
1568 		goto cleanup;
1569 	}
1570 
1571 	ret = vmbus_bus_init();
1572 	if (ret)
1573 		goto cleanup;
1574 
1575 	hv_setup_kexec_handler(hv_kexec_handler);
1576 	hv_setup_crash_handler(hv_crash_handler);
1577 
1578 	return 0;
1579 
1580 cleanup:
1581 	acpi_bus_unregister_driver(&vmbus_acpi_driver);
1582 	hv_acpi_dev = NULL;
1583 	return ret;
1584 }
1585 
1586 static void __exit vmbus_exit(void)
1587 {
1588 	int cpu;
1589 
1590 	hv_remove_kexec_handler();
1591 	hv_remove_crash_handler();
1592 	vmbus_connection.conn_state = DISCONNECTED;
1593 	hv_synic_clockevents_cleanup();
1594 	vmbus_disconnect();
1595 	hv_remove_vmbus_irq();
1596 	for_each_online_cpu(cpu) {
1597 		struct hv_per_cpu_context *hv_cpu
1598 			= per_cpu_ptr(hv_context.cpu_context, cpu);
1599 
1600 		tasklet_kill(&hv_cpu->msg_dpc);
1601 	}
1602 	vmbus_free_channels();
1603 
1604 	if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
1605 		unregister_die_notifier(&hyperv_die_block);
1606 		atomic_notifier_chain_unregister(&panic_notifier_list,
1607 						 &hyperv_panic_block);
1608 	}
1609 	bus_unregister(&hv_bus);
1610 
1611 	cpuhp_remove_state(hyperv_cpuhp_online);
1612 	hv_synic_free();
1613 	acpi_bus_unregister_driver(&vmbus_acpi_driver);
1614 }
1615 
1616 
1617 MODULE_LICENSE("GPL");
1618 
1619 subsys_initcall(hv_acpi_init);
1620 module_exit(vmbus_exit);
1621