projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
staging: unisys: remove DBGINF, DBGVER, DEBUGDEV, and DEBUGDRV macros
[deliverable/linux.git] / drivers / staging / unisys / visorchipset / visorchipset_main.c
CommitLineData
12e364b9
KC		 1/* visorchipset_main.c
2 *
f6d0c1e6 3 * Copyright (C) 2010 - 2013 UNISYS CORPORATION
12e364b9
KC		 4 * All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or (at
9 * your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
14 * NON INFRINGEMENT. See the GNU General Public License for more
15 * details.
16 */
17
18#include "globals.h"
12e364b9
KC		 19#include "visorchipset.h"
20#include "procobjecttree.h"
21#include "visorchannel.h"
22#include "periodic_work.h"
12e364b9
KC		 23#include "file.h"
24#include "parser.h"
25#include "uniklog.h"
26#include "uisutils.h"
12e364b9
KC		 27#include "controlvmcompletionstatus.h"
28#include "guestlinuxdebug.h"
12e364b9
KC		 29
30#include <linux/nls.h>
31#include <linux/netdevice.h>
32#include <linux/platform_device.h>
90addb02 33#include <linux/uuid.h>
12e364b9
KC		 34
35#define CURRENT_FILE_PC VISOR_CHIPSET_PC_visorchipset_main_c
36#define TEST_VNIC_PHYSITF "eth0" /* physical network itf for
37 * vnic loopback test */
38#define TEST_VNIC_SWITCHNO 1
39#define TEST_VNIC_BUSNO 9
40
41#define MAX_NAME_SIZE 128
42#define MAX_IP_SIZE 50
43#define MAXOUTSTANDINGCHANNELCOMMAND 256
44#define POLLJIFFIES_CONTROLVMCHANNEL_FAST 1
45#define POLLJIFFIES_CONTROLVMCHANNEL_SLOW 100
46
47/* When the controlvm channel is idle for at least MIN_IDLE_SECONDS,
48* we switch to slow polling mode. As soon as we get a controlvm
49* message, we switch back to fast polling mode.
50*/
51#define MIN_IDLE_SECONDS 10
bd5b9b32
KC		 52static ulong Poll_jiffies = POLLJIFFIES_CONTROLVMCHANNEL_FAST;
53static ulong Most_recent_message_jiffies; /* when we got our last
54 * controlvm message */
12e364b9
KC		 55static inline char *
56NONULLSTR(char *s)
57{
58 if (s)
59 return s;
e22a4a0f 60 return "";
12e364b9
KC		 61}
62
63static int serverregistered;
64static int clientregistered;
65
66#define MAX_CHIPSET_EVENTS 2
c242233e 67static u8 chipset_events[MAX_CHIPSET_EVENTS] = { 0, 0 };
12e364b9
KC		 68
69static struct delayed_work Periodic_controlvm_work;
70static struct workqueue_struct *Periodic_controlvm_workqueue;
bd5b9b32 71static DEFINE_SEMAPHORE(NotifierLock);
12e364b9 72
98d7b594
BR		 73static struct controlvm_message_header g_DiagMsgHdr;
74static struct controlvm_message_header g_ChipSetMsgHdr;
75static struct controlvm_message_header g_DelDumpMsgHdr;
90addb02 76static const uuid_le UltraDiagPoolChannelProtocolGuid =
9eee5d1f 77 SPAR_DIAG_POOL_CHANNEL_PROTOCOL_UUID;
12e364b9
KC		 78/* 0xffffff is an invalid Bus/Device number */
79static ulong g_diagpoolBusNo = 0xffffff;
80static ulong g_diagpoolDevNo = 0xffffff;
2ea5117b 81static struct controlvm_message_packet g_DeviceChangeStatePacket;
12e364b9
KC		 82
83/* Only VNIC and VHBA channels are sent to visorclientbus (aka
84 * "visorhackbus")
85 */
86#define FOR_VISORHACKBUS(channel_type_guid) \
9eee5d1f
BR		 87 (((uuid_le_cmp(channel_type_guid,\
88 spar_vnic_channel_protocol_uuid) == 0)\
89 || (uuid_le_cmp(channel_type_guid,\
90 spar_vhba_channel_protocol_uuid) == 0)))
12e364b9
KC		 91#define FOR_VISORBUS(channel_type_guid) (!(FOR_VISORHACKBUS(channel_type_guid)))
92
93#define is_diagpool_channel(channel_type_guid) \
90addb02 94 (uuid_le_cmp(channel_type_guid, UltraDiagPoolChannelProtocolGuid) == 0)
12e364b9 95
12e364b9
KC		 96static LIST_HEAD(BusInfoList);
97static LIST_HEAD(DevInfoList);
98
383df64e 99static struct visorchannel *ControlVm_channel;
12e364b9 100
84b11dfd 101struct controlvm_payload_info {
c242233e 102 u8 __iomem *ptr; /* pointer to base address of payload pool */
5fc0229a 103 u64 offset; /* offset from beginning of controlvm
12e364b9 104 * channel to beginning of payload * pool */
b3c55b13 105 u32 bytes; /* number of bytes in payload pool */
84b11dfd 106};
12e364b9
KC		 107
108/* Manages the request payload in the controlvm channel */
84b11dfd 109static struct controlvm_payload_info ControlVm_payload_info;
12e364b9 110
9fd1b95a 111static struct channel_header *Test_Vnic_channel;
12e364b9 112
84b11dfd 113struct livedump_info {
98d7b594
BR		 114 struct controlvm_message_header Dumpcapture_header;
115 struct controlvm_message_header Gettextdump_header;
116 struct controlvm_message_header Dumpcomplete_header;
12e364b9
KC		 117 BOOL Gettextdump_outstanding;
118 u32 crc32;
119 ulong length;
120 atomic_t buffers_in_use;
121 ulong destination;
84b11dfd 122};
12e364b9
KC		 123/* Manages the info for a CONTROLVM_DUMP_CAPTURESTATE /
124 * CONTROLVM_DUMP_GETTEXTDUMP / CONTROLVM_DUMP_COMPLETE conversation.
125 */
84b11dfd 126static struct livedump_info LiveDump_info;
12e364b9
KC		 127
128/* The following globals are used to handle the scenario where we are unable to
129 * offload the payload from a controlvm message due to memory requirements. In
130 * this scenario, we simply stash the controlvm message, then attempt to
131 * process it again the next time controlvm_periodic_work() runs.
132 */
3ab47701 133static struct controlvm_message ControlVm_Pending_Msg;
12e364b9
KC		 134static BOOL ControlVm_Pending_Msg_Valid = FALSE;
135
136/* Pool of struct putfile_buffer_entry, for keeping track of pending (incoming)
137 * TRANSMIT_FILE PutFile payloads.
138 */
139static struct kmem_cache *Putfile_buffer_list_pool;
140static const char Putfile_buffer_list_pool_name[] =
141 "controlvm_putfile_buffer_list_pool";
142
143/* This identifies a data buffer that has been received via a controlvm messages
144 * in a remote --> local CONTROLVM_TRANSMIT_FILE conversation.
145 */
146struct putfile_buffer_entry {
147 struct list_head next; /* putfile_buffer_entry list */
148 PARSER_CONTEXT *parser_ctx; /* points to buffer containing input data */
149};
150
151/* List of struct putfile_request *, via next_putfile_request member.
152 * Each entry in this list identifies an outstanding TRANSMIT_FILE
153 * conversation.
154 */
155static LIST_HEAD(Putfile_request_list);
156
157/* This describes a buffer and its current state of transfer (e.g., how many
158 * bytes have already been supplied as putfile data, and how many bytes are
159 * remaining) for a putfile_request.
160 */
161struct putfile_active_buffer {
162 /* a payload from a controlvm message, containing a file data buffer */
163 PARSER_CONTEXT *parser_ctx;
164 /* points within data area of parser_ctx to next byte of data */
165 u8 *pnext;
166 /* # bytes left from <pnext> to the end of this data buffer */
167 size_t bytes_remaining;
168};
169
170#define PUTFILE_REQUEST_SIG 0x0906101302281211
171/* This identifies a single remote --> local CONTROLVM_TRANSMIT_FILE
172 * conversation. Structs of this type are dynamically linked into
173 * <Putfile_request_list>.
174 */
175struct putfile_request {
176 u64 sig; /* PUTFILE_REQUEST_SIG */
177
178 /* header from original TransmitFile request */
98d7b594 179 struct controlvm_message_header controlvm_header;
12e364b9
KC		 180 u64 file_request_number; /* from original TransmitFile request */
181
182 /* link to next struct putfile_request */
183 struct list_head next_putfile_request;
184
185 /* most-recent sequence number supplied via a controlvm message */
186 u64 data_sequence_number;
187
188 /* head of putfile_buffer_entry list, which describes the data to be
189 * supplied as putfile data;
190 * - this list is added to when controlvm messages come in that supply
191 * file data
192 * - this list is removed from via the hotplug program that is actually
193 * consuming these buffers to write as file data */
194 struct list_head input_buffer_list;
195 spinlock_t req_list_lock; /* lock for input_buffer_list */
196
197 /* waiters for input_buffer_list to go non-empty */
198 wait_queue_head_t input_buffer_wq;
199
200 /* data not yet read within current putfile_buffer_entry */
201 struct putfile_active_buffer active_buf;
202
203 /* <0 = failed, 0 = in-progress, >0 = successful; */
204 /* note that this must be set with req_list_lock, and if you set <0, */
205 /* it is your responsibility to also free up all of the other objects */
206 /* in this struct (like input_buffer_list, active_buf.parser_ctx) */
207 /* before releasing the lock */
208 int completion_status;
209};
210
bd5b9b32 211static atomic_t Visorchipset_cache_buffers_in_use = ATOMIC_INIT(0);
12e364b9
KC		 212
213struct parahotplug_request {
214 struct list_head list;
215 int id;
216 unsigned long expiration;
3ab47701 217 struct controlvm_message msg;
12e364b9
KC		 218};
219
220static LIST_HEAD(Parahotplug_request_list);
221static DEFINE_SPINLOCK(Parahotplug_request_list_lock); /* lock for above */
222static void parahotplug_process_list(void);
223
224/* Manages the info for a CONTROLVM_DUMP_CAPTURESTATE /
225 * CONTROLVM_REPORTEVENT.
226 */
fe90d892
BR		 227static struct visorchipset_busdev_notifiers BusDev_Server_Notifiers;
228static struct visorchipset_busdev_notifiers BusDev_Client_Notifiers;
12e364b9
KC		 229
230static void bus_create_response(ulong busNo, int response);
231static void bus_destroy_response(ulong busNo, int response);
232static void device_create_response(ulong busNo, ulong devNo, int response);
233static void device_destroy_response(ulong busNo, ulong devNo, int response);
234static void device_resume_response(ulong busNo, ulong devNo, int response);
235
929aa8ae 236static struct visorchipset_busdev_responders BusDev_Responders = {
12e364b9
KC		 237 .bus_create = bus_create_response,
238 .bus_destroy = bus_destroy_response,
239 .device_create = device_create_response,
240 .device_destroy = device_destroy_response,
927c7927 241 .device_pause = visorchipset_device_pause_response,
12e364b9
KC		 242 .device_resume = device_resume_response,
243};
244
245/* info for /dev/visorchipset */
246static dev_t MajorDev = -1; /**< indicates major num for device */
247
19f6634f
BR		 248/* prototypes for attributes */
249static ssize_t toolaction_show(struct device *dev,
250 struct device_attribute *attr, char *buf);
251static ssize_t toolaction_store(struct device *dev,
252 struct device_attribute *attr, const char *buf, size_t count);
253static DEVICE_ATTR_RW(toolaction);
254
54b31229
BR		 255static ssize_t boottotool_show(struct device *dev,
256 struct device_attribute *attr, char *buf);
257static ssize_t boottotool_store(struct device *dev,
258 struct device_attribute *attr, const char *buf, size_t count);
259static DEVICE_ATTR_RW(boottotool);
260
422af17c
BR		 261static ssize_t error_show(struct device *dev, struct device_attribute *attr,
262 char *buf);
263static ssize_t error_store(struct device *dev, struct device_attribute *attr,
264 const char *buf, size_t count);
265static DEVICE_ATTR_RW(error);
266
267static ssize_t textid_show(struct device *dev, struct device_attribute *attr,
268 char *buf);
269static ssize_t textid_store(struct device *dev, struct device_attribute *attr,
270 const char *buf, size_t count);
271static DEVICE_ATTR_RW(textid);
272
273static ssize_t remaining_steps_show(struct device *dev,
274 struct device_attribute *attr, char *buf);
275static ssize_t remaining_steps_store(struct device *dev,
276 struct device_attribute *attr, const char *buf, size_t count);
277static DEVICE_ATTR_RW(remaining_steps);
278
18b87ed1
BR		 279static ssize_t chipsetready_store(struct device *dev,
280 struct device_attribute *attr, const char *buf, size_t count);
281static DEVICE_ATTR_WO(chipsetready);
282
e56fa7cd
BR		 283static ssize_t devicedisabled_store(struct device *dev,
284 struct device_attribute *attr, const char *buf, size_t count);
285static DEVICE_ATTR_WO(devicedisabled);
286
287static ssize_t deviceenabled_store(struct device *dev,
288 struct device_attribute *attr, const char *buf, size_t count);
289static DEVICE_ATTR_WO(deviceenabled);
290
19f6634f
BR		 291static struct attribute *visorchipset_install_attrs[] = {
292 &dev_attr_toolaction.attr,
54b31229 293 &dev_attr_boottotool.attr,
422af17c
BR		 294 &dev_attr_error.attr,
295 &dev_attr_textid.attr,
296 &dev_attr_remaining_steps.attr,
19f6634f
BR		 297 NULL
298};
299
300static struct attribute_group visorchipset_install_group = {
301 .name = "install",
302 .attrs = visorchipset_install_attrs
303};
304
18b87ed1
BR		 305static struct attribute *visorchipset_guest_attrs[] = {
306 &dev_attr_chipsetready.attr,
307 NULL
308};
309
310static struct attribute_group visorchipset_guest_group = {
311 .name = "guest",
312 .attrs = visorchipset_guest_attrs
313};
314
e56fa7cd
BR		 315static struct attribute *visorchipset_parahotplug_attrs[] = {
316 &dev_attr_devicedisabled.attr,
317 &dev_attr_deviceenabled.attr,
318 NULL
319};
320
321static struct attribute_group visorchipset_parahotplug_group = {
322 .name = "parahotplug",
323 .attrs = visorchipset_parahotplug_attrs
324};
325
19f6634f
BR		 326static const struct attribute_group *visorchipset_dev_groups[] = {
327 &visorchipset_install_group,
18b87ed1 328 &visorchipset_guest_group,
e56fa7cd 329 &visorchipset_parahotplug_group,
19f6634f
BR		 330 NULL
331};
332
12e364b9
KC		 333/* /sys/devices/platform/visorchipset */
334static struct platform_device Visorchipset_platform_device = {
335 .name = "visorchipset",
336 .id = -1,
19f6634f 337 .dev.groups = visorchipset_dev_groups,
12e364b9
KC		 338};
339
340/* Function prototypes */
98d7b594
BR		 341static void controlvm_respond(struct controlvm_message_header *msgHdr,
342 int response);
343static void controlvm_respond_chipset_init(
344 struct controlvm_message_header *msgHdr, int response,
345 enum ultra_chipset_feature features);
346static void controlvm_respond_physdev_changestate(
347 struct controlvm_message_header *msgHdr, int response,
348 struct spar_segment_state state);
12e364b9 349
d746cb55
VB		 350static ssize_t toolaction_show(struct device *dev,
351 struct device_attribute *attr,
352 char *buf)
19f6634f 353{
66e24b76 354 u8 toolAction;
19f6634f
BR		 355
356 visorchannel_read(ControlVm_channel,
d19642f6
BR		 357 offsetof(struct spar_controlvm_channel_protocol,
358 tool_action), &toolAction, sizeof(u8));
19f6634f
BR		 359 return scnprintf(buf, PAGE_SIZE, "%u\n", toolAction);
360}
361
d746cb55
VB		 362static ssize_t toolaction_store(struct device *dev,
363 struct device_attribute *attr,
364 const char *buf, size_t count)
19f6634f 365{
66e24b76
BR		 366 u8 toolAction;
367 int ret;
19f6634f 368
66e24b76
BR		 369 if (kstrtou8(buf, 10, &toolAction) != 0)
370 return -EINVAL;
371
372 ret = visorchannel_write(ControlVm_channel,
d19642f6 373 offsetof(struct spar_controlvm_channel_protocol, tool_action),
66e24b76
BR		 374 &toolAction, sizeof(u8));
375
376 if (ret)
377 return ret;
e22a4a0f 378 return count;
19f6634f
BR		 379}
380
d746cb55
VB		 381static ssize_t boottotool_show(struct device *dev,
382 struct device_attribute *attr,
383 char *buf)
54b31229 384{
755e2ecc 385 struct efi_spar_indication efiSparIndication;
54b31229
BR		 386
387 visorchannel_read(ControlVm_channel,
d19642f6
BR		 388 offsetof(struct spar_controlvm_channel_protocol,
389 efi_spar_ind), &efiSparIndication,
755e2ecc 390 sizeof(struct efi_spar_indication));
54b31229 391 return scnprintf(buf, PAGE_SIZE, "%u\n",
2450301a 392 efiSparIndication.boot_to_tool);
54b31229
BR		 393}
394
d746cb55
VB		 395static ssize_t boottotool_store(struct device *dev,
396 struct device_attribute *attr,
397 const char *buf, size_t count)
54b31229 398{
66e24b76 399 int val, ret;
755e2ecc 400 struct efi_spar_indication efiSparIndication;
54b31229 401
66e24b76
BR		 402 if (kstrtoint(buf, 10, &val) != 0)
403 return -EINVAL;
404
2450301a 405 efiSparIndication.boot_to_tool = val;
66e24b76 406 ret = visorchannel_write(ControlVm_channel,
d19642f6
BR		 407 offsetof(struct spar_controlvm_channel_protocol,
408 efi_spar_ind),
54b31229 409 &(efiSparIndication),
755e2ecc 410 sizeof(struct efi_spar_indication));
66e24b76
BR		 411
412 if (ret)
413 return ret;
e22a4a0f 414 return count;
54b31229 415}
422af17c
BR		 416
417static ssize_t error_show(struct device *dev, struct device_attribute *attr,
418 char *buf)
419{
420 u32 error;
421
422 visorchannel_read(ControlVm_channel, offsetof(
d19642f6 423 struct spar_controlvm_channel_protocol, installation_error),
422af17c
BR		 424 &error, sizeof(u32));
425 return scnprintf(buf, PAGE_SIZE, "%i\n", error);
426}
427
428static ssize_t error_store(struct device *dev, struct device_attribute *attr,
429 const char *buf, size_t count)
430{
431 u32 error;
66e24b76 432 int ret;
422af17c 433
66e24b76
BR		 434 if (kstrtou32(buf, 10, &error) != 0)
435 return -EINVAL;
436
437 ret = visorchannel_write(ControlVm_channel,
d19642f6
BR		 438 offsetof(struct spar_controlvm_channel_protocol,
439 installation_error),
66e24b76
BR		 440 &error, sizeof(u32));
441 if (ret)
442 return ret;
e22a4a0f 443 return count;
422af17c
BR		 444}
445
446static ssize_t textid_show(struct device *dev, struct device_attribute *attr,
447 char *buf)
448{
449 u32 textId;
450
451 visorchannel_read(ControlVm_channel, offsetof(
d19642f6 452 struct spar_controlvm_channel_protocol, installation_text_id),
422af17c
BR		 453 &textId, sizeof(u32));
454 return scnprintf(buf, PAGE_SIZE, "%i\n", textId);
455}
456
457static ssize_t textid_store(struct device *dev, struct device_attribute *attr,
458 const char *buf, size_t count)
459{
460 u32 textId;
66e24b76 461 int ret;
422af17c 462
66e24b76
BR		 463 if (kstrtou32(buf, 10, &textId) != 0)
464 return -EINVAL;
465
466 ret = visorchannel_write(ControlVm_channel,
d19642f6
BR		 467 offsetof(struct spar_controlvm_channel_protocol,
468 installation_text_id),
66e24b76
BR		 469 &textId, sizeof(u32));
470 if (ret)
471 return ret;
e22a4a0f 472 return count;
422af17c
BR		 473}
474
475
476static ssize_t remaining_steps_show(struct device *dev,
477 struct device_attribute *attr, char *buf)
478{
479 u16 remainingSteps;
480
481 visorchannel_read(ControlVm_channel,
d19642f6
BR		 482 offsetof(struct spar_controlvm_channel_protocol,
483 installation_remaining_steps),
422af17c
BR		 484 &remainingSteps,
485 sizeof(u16));
486 return scnprintf(buf, PAGE_SIZE, "%hu\n", remainingSteps);
487}
488
489static ssize_t remaining_steps_store(struct device *dev,
490 struct device_attribute *attr, const char *buf, size_t count)
491{
492 u16 remainingSteps;
66e24b76 493 int ret;
422af17c 494
66e24b76
BR		 495 if (kstrtou16(buf, 10, &remainingSteps) != 0)
496 return -EINVAL;
497
498 ret = visorchannel_write(ControlVm_channel,
d19642f6
BR		 499 offsetof(struct spar_controlvm_channel_protocol,
500 installation_remaining_steps),
66e24b76
BR		 501 &remainingSteps, sizeof(u16));
502 if (ret)
503 return ret;
e22a4a0f 504 return count;
422af17c
BR		 505}
506
12e364b9
KC		 507#if 0
508static void
509testUnicode(void)
510{
511 wchar_t unicodeString[] = { 'a', 'b', 'c', 0 };
512 char s[sizeof(unicodeString) * NLS_MAX_CHARSET_SIZE];
513 wchar_t unicode2[99];
514
515 /* NOTE: Either due to a bug, or feature I don't understand, the
516 * kernel utf8_mbstowcs() and utf_wcstombs() do NOT copy the
517 * trailed NUL byte!! REALLY!!!!! Arrrrgggghhhhh
518 */
519
520 LOGINF("sizeof(wchar_t) = %d", sizeof(wchar_t));
521 LOGINF("utf8_wcstombs=%d",
522 chrs = utf8_wcstombs(s, unicodeString, sizeof(s)));
523 if (chrs >= 0)
524 s[chrs] = '\0'; /* GRRRRRRRR */
525 LOGINF("s='%s'", s);
526 LOGINF("utf8_mbstowcs=%d", chrs = utf8_mbstowcs(unicode2, s, 100));
527 if (chrs >= 0)
528 unicode2[chrs] = 0; /* GRRRRRRRR */
529 if (memcmp(unicodeString, unicode2, sizeof(unicodeString)) == 0)
530 LOGINF("strings match... good");
531 else
532 LOGINF("strings did not match!!");
533}
534#endif
535
536static void
537busInfo_clear(void *v)
538{
33192fa1 539 struct visorchipset_bus_info *p = (struct visorchipset_bus_info *) (v);
12e364b9 540
33192fa1
BR		 541 if (p->proc_object) {
542 visor_proc_DestroyObject(p->proc_object);
543 p->proc_object = NULL;
12e364b9
KC		 544 }
545 kfree(p->name);
546 p->name = NULL;
547
548 kfree(p->description);
549 p->description = NULL;
550
551 p->state.created = 0;
33192fa1 552 memset(p, 0, sizeof(struct visorchipset_bus_info));
12e364b9
KC		 553}
554
555static void
556devInfo_clear(void *v)
557{
246e0cd0
BR		 558 struct visorchipset_device_info *p =
559 (struct visorchipset_device_info *)(v);
26eb2c0c 560
12e364b9 561 p->state.created = 0;
246e0cd0 562 memset(p, 0, sizeof(struct visorchipset_device_info));
12e364b9
KC		 563}
564
c242233e 565static u8
12e364b9
KC		 566check_chipset_events(void)
567{
568 int i;
c242233e 569 u8 send_msg = 1;
12e364b9
KC		 570 /* Check events to determine if response should be sent */
571 for (i = 0; i < MAX_CHIPSET_EVENTS; i++)
572 send_msg &= chipset_events[i];
573 return send_msg;
574}
575
576static void
577clear_chipset_events(void)
578{
579 int i;
580 /* Clear chipset_events */
581 for (i = 0; i < MAX_CHIPSET_EVENTS; i++)
582 chipset_events[i] = 0;
583}
584
585void
fe90d892
BR		 586visorchipset_register_busdev_server(
587 struct visorchipset_busdev_notifiers *notifiers,
929aa8ae 588 struct visorchipset_busdev_responders *responders,
1e7a59c1 589 struct ultra_vbus_deviceinfo *driver_info)
12e364b9 590{
f2170625 591 down(&NotifierLock);
12e364b9
KC		 592 if (notifiers == NULL) {
593 memset(&BusDev_Server_Notifiers, 0,
594 sizeof(BusDev_Server_Notifiers));
595 serverregistered = 0; /* clear flag */
596 } else {
597 BusDev_Server_Notifiers = *notifiers;
598 serverregistered = 1; /* set flag */
599 }
600 if (responders)
601 *responders = BusDev_Responders;
1e7a59c1
BR		 602 if (driver_info)
603 bus_device_info_init(driver_info, "chipset", "visorchipset",
836bee9e 604 VERSION, NULL);
12e364b9 605
f2170625 606 up(&NotifierLock);
12e364b9
KC		 607}
608EXPORT_SYMBOL_GPL(visorchipset_register_busdev_server);
609
610void
fe90d892
BR		 611visorchipset_register_busdev_client(
612 struct visorchipset_busdev_notifiers *notifiers,
929aa8ae 613 struct visorchipset_busdev_responders *responders,
43fce019 614 struct ultra_vbus_deviceinfo *driver_info)
12e364b9 615{
f2170625 616 down(&NotifierLock);
12e364b9
KC		 617 if (notifiers == NULL) {
618 memset(&BusDev_Client_Notifiers, 0,
619 sizeof(BusDev_Client_Notifiers));
620 clientregistered = 0; /* clear flag */
621 } else {
622 BusDev_Client_Notifiers = *notifiers;
623 clientregistered = 1; /* set flag */
624 }
625 if (responders)
626 *responders = BusDev_Responders;
43fce019
BR		 627 if (driver_info)
628 bus_device_info_init(driver_info, "chipset(bolts)",
629 "visorchipset", VERSION, NULL);
f2170625 630 up(&NotifierLock);
12e364b9
KC		 631}
632EXPORT_SYMBOL_GPL(visorchipset_register_busdev_client);
633
634static void
635cleanup_controlvm_structures(void)
636{
33192fa1 637 struct visorchipset_bus_info *bi, *tmp_bi;
246e0cd0 638 struct visorchipset_device_info *di, *tmp_di;
12e364b9 639
e6b1ea77 640 list_for_each_entry_safe(bi, tmp_bi, &BusInfoList, entry) {
12e364b9
KC		 641 busInfo_clear(bi);
642 list_del(&bi->entry);
643 kfree(bi);
644 }
645
e6b1ea77 646 list_for_each_entry_safe(di, tmp_di, &DevInfoList, entry) {
12e364b9
KC		 647 devInfo_clear(di);
648 list_del(&di->entry);
649 kfree(di);
650 }
651}
652
653static void
3ab47701 654chipset_init(struct controlvm_message *inmsg)
12e364b9
KC		 655{
656 static int chipset_inited;
b9b141e8 657 enum ultra_chipset_feature features = 0;
12e364b9
KC		 658 int rc = CONTROLVM_RESP_SUCCESS;
659
660 POSTCODE_LINUX_2(CHIPSET_INIT_ENTRY_PC, POSTCODE_SEVERITY_INFO);
661 if (chipset_inited) {
662 LOGERR("CONTROLVM_CHIPSET_INIT Failed: Already Done.");
22ad57ba
KC		 663 rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
664 goto Away;
12e364b9
KC		 665 }
666 chipset_inited = 1;
667 POSTCODE_LINUX_2(CHIPSET_INIT_EXIT_PC, POSTCODE_SEVERITY_INFO);
668
669 /* Set features to indicate we support parahotplug (if Command
670 * also supports it). */
671 features =
2ea5117b 672 inmsg->cmd.init_chipset.
12e364b9
KC		 673 features & ULTRA_CHIPSET_FEATURE_PARA_HOTPLUG;
674
675 /* Set the "reply" bit so Command knows this is a
676 * features-aware driver. */
677 features |= ULTRA_CHIPSET_FEATURE_REPLY;
678
679Away:
680 if (rc < 0)
681 cleanup_controlvm_structures();
98d7b594 682 if (inmsg->hdr.flags.response_expected)
12e364b9
KC		 683 controlvm_respond_chipset_init(&inmsg->hdr, rc, features);
684}
685
686static void
3ab47701 687controlvm_init_response(struct controlvm_message *msg,
98d7b594 688 struct controlvm_message_header *msgHdr, int response)
12e364b9 689{
3ab47701 690 memset(msg, 0, sizeof(struct controlvm_message));
98d7b594
BR		 691 memcpy(&msg->hdr, msgHdr, sizeof(struct controlvm_message_header));
692 msg->hdr.payload_bytes = 0;
693 msg->hdr.payload_vm_offset = 0;
694 msg->hdr.payload_max_bytes = 0;
12e364b9 695 if (response < 0) {
98d7b594
BR		 696 msg->hdr.flags.failed = 1;
697 msg->hdr.completion_status = (u32) (-response);
12e364b9
KC		 698 }
699}
700
701static void
98d7b594 702controlvm_respond(struct controlvm_message_header *msgHdr, int response)
12e364b9 703{
3ab47701 704 struct controlvm_message outmsg;
26eb2c0c 705
12e364b9
KC		 706 controlvm_init_response(&outmsg, msgHdr, response);
707 /* For DiagPool channel DEVICE_CHANGESTATE, we need to send
708 * back the deviceChangeState structure in the packet. */
98d7b594 709 if (msgHdr->id == CONTROLVM_DEVICE_CHANGESTATE
2ea5117b 710 && g_DeviceChangeStatePacket.device_change_state.bus_no ==
12e364b9 711 g_diagpoolBusNo
2ea5117b 712 && g_DeviceChangeStatePacket.device_change_state.dev_no ==
12e364b9
KC		 713 g_diagpoolDevNo)
714 outmsg.cmd = g_DeviceChangeStatePacket;
98d7b594 715 if (outmsg.hdr.flags.test_message == 1) {
12e364b9 716 LOGINF("%s controlvm_msg=0x%x response=%d for test message",
98d7b594 717 __func__, outmsg.hdr.id, response);
12e364b9
KC		 718 return;
719 }
720 if (!visorchannel_signalinsert(ControlVm_channel,
721 CONTROLVM_QUEUE_REQUEST, &outmsg)) {
722 LOGERR("signalinsert failed!");
723 return;
724 }
725}
726
727static void
98d7b594
BR		 728controlvm_respond_chipset_init(struct controlvm_message_header *msgHdr,
729 int response,
b9b141e8 730 enum ultra_chipset_feature features)
12e364b9 731{
3ab47701 732 struct controlvm_message outmsg;
26eb2c0c 733
12e364b9 734 controlvm_init_response(&outmsg, msgHdr, response);
2ea5117b 735 outmsg.cmd.init_chipset.features = features;
12e364b9
KC		 736 if (!visorchannel_signalinsert(ControlVm_channel,
737 CONTROLVM_QUEUE_REQUEST, &outmsg)) {
738 LOGERR("signalinsert failed!");
739 return;
740 }
741}
742
98d7b594
BR		 743static void controlvm_respond_physdev_changestate(
744 struct controlvm_message_header *msgHdr, int response,
745 struct spar_segment_state state)
12e364b9 746{
3ab47701 747 struct controlvm_message outmsg;
26eb2c0c 748
12e364b9 749 controlvm_init_response(&outmsg, msgHdr, response);
2ea5117b
BR		 750 outmsg.cmd.device_change_state.state = state;
751 outmsg.cmd.device_change_state.flags.phys_device = 1;
12e364b9
KC		 752 if (!visorchannel_signalinsert(ControlVm_channel,
753 CONTROLVM_QUEUE_REQUEST, &outmsg)) {
754 LOGERR("signalinsert failed!");
755 return;
756 }
757}
758
759void
2c683cde
BR		 760visorchipset_save_message(struct controlvm_message *msg,
761 enum crash_obj_type type)
12e364b9 762{
b3c55b13 763 u32 localSavedCrashMsgOffset;
b06bdf7d 764 u16 localSavedCrashMsgCount;
12e364b9
KC		 765
766 /* get saved message count */
767 if (visorchannel_read(ControlVm_channel,
d19642f6
BR		 768 offsetof(struct spar_controlvm_channel_protocol,
769 saved_crash_message_count),
b06bdf7d 770 &localSavedCrashMsgCount, sizeof(u16)) < 0) {
12e364b9
KC		 771 LOGERR("failed to get Saved Message Count");
772 POSTCODE_LINUX_2(CRASH_DEV_CTRL_RD_FAILURE_PC,
773 POSTCODE_SEVERITY_ERR);
774 return;
775 }
776
777 if (localSavedCrashMsgCount != CONTROLVM_CRASHMSG_MAX) {
778 LOGERR("Saved Message Count incorrect %d",
779 localSavedCrashMsgCount);
780 POSTCODE_LINUX_3(CRASH_DEV_COUNT_FAILURE_PC,
781 localSavedCrashMsgCount,
782 POSTCODE_SEVERITY_ERR);
783 return;
784 }
785
786 /* get saved crash message offset */
787 if (visorchannel_read(ControlVm_channel,
d19642f6
BR		 788 offsetof(struct spar_controlvm_channel_protocol,
789 saved_crash_message_offset),
b3c55b13 790 &localSavedCrashMsgOffset, sizeof(u32)) < 0) {
12e364b9
KC		 791 LOGERR("failed to get Saved Message Offset");
792 POSTCODE_LINUX_2(CRASH_DEV_CTRL_RD_FAILURE_PC,
793 POSTCODE_SEVERITY_ERR);
794 return;
795 }
796
2c683cde 797 if (type == CRASH_BUS) {
12e364b9
KC		 798 if (visorchannel_write(ControlVm_channel,
799 localSavedCrashMsgOffset,
3ab47701
BR		 800 msg,
801 sizeof(struct controlvm_message)) < 0) {
12e364b9
KC		 802 LOGERR("SAVE_MSG_BUS_FAILURE: Failed to write CrashCreateBusMsg!");
803 POSTCODE_LINUX_2(SAVE_MSG_BUS_FAILURE_PC,
804 POSTCODE_SEVERITY_ERR);
805 return;
806 }
807 } else {
808 if (visorchannel_write(ControlVm_channel,
809 localSavedCrashMsgOffset +
3ab47701
BR		 810 sizeof(struct controlvm_message), msg,
811 sizeof(struct controlvm_message)) < 0) {
12e364b9
KC		 812 LOGERR("SAVE_MSG_DEV_FAILURE: Failed to write CrashCreateDevMsg!");
813 POSTCODE_LINUX_2(SAVE_MSG_DEV_FAILURE_PC,
814 POSTCODE_SEVERITY_ERR);
815 return;
816 }
817 }
818}
819EXPORT_SYMBOL_GPL(visorchipset_save_message);
820
821static void
53bebb13 822bus_responder(enum controlvm_id cmdId, ulong busNo, int response)
12e364b9 823{
33192fa1 824 struct visorchipset_bus_info *p = NULL;
12e364b9
KC		 825 BOOL need_clear = FALSE;
826
827 p = findbus(&BusInfoList, busNo);
828 if (!p) {
829 LOGERR("internal error busNo=%lu", busNo);
830 return;
831 }
832 if (response < 0) {
833 if ((cmdId == CONTROLVM_BUS_CREATE) &&
834 (response != (-CONTROLVM_RESP_ERROR_ALREADY_DONE)))
835 /* undo the row we just created... */
836 delbusdevices(&DevInfoList, busNo);
837 } else {
838 if (cmdId == CONTROLVM_BUS_CREATE)
839 p->state.created = 1;
840 if (cmdId == CONTROLVM_BUS_DESTROY)
841 need_clear = TRUE;
842 }
843
33192fa1 844 if (p->pending_msg_hdr.id == CONTROLVM_INVALID) {
12e364b9
KC		 845 LOGERR("bus_responder no pending msg");
846 return; /* no controlvm response needed */
847 }
33192fa1
BR		 848 if (p->pending_msg_hdr.id != (u32) cmdId) {
849 LOGERR("expected=%d, found=%d", cmdId, p->pending_msg_hdr.id);
12e364b9
KC		 850 return;
851 }
33192fa1
BR		 852 controlvm_respond(&p->pending_msg_hdr, response);
853 p->pending_msg_hdr.id = CONTROLVM_INVALID;
12e364b9
KC		 854 if (need_clear) {
855 busInfo_clear(p);
856 delbusdevices(&DevInfoList, busNo);
857 }
858}
859
860static void
53bebb13 861device_changestate_responder(enum controlvm_id cmdId,
12e364b9 862 ulong busNo, ulong devNo, int response,
3f833b54 863 struct spar_segment_state responseState)
12e364b9 864{
246e0cd0 865 struct visorchipset_device_info *p = NULL;
3ab47701 866 struct controlvm_message outmsg;
12e364b9 867
12e364b9
KC		 868 p = finddevice(&DevInfoList, busNo, devNo);
869 if (!p) {
870 LOGERR("internal error; busNo=%lu, devNo=%lu", busNo, devNo);
871 return;
872 }
246e0cd0 873 if (p->pending_msg_hdr.id == CONTROLVM_INVALID) {
12e364b9
KC		 874 LOGERR("device_responder no pending msg");
875 return; /* no controlvm response needed */
876 }
246e0cd0
BR		 877 if (p->pending_msg_hdr.id != cmdId) {
878 LOGERR("expected=%d, found=%d", cmdId, p->pending_msg_hdr.id);
12e364b9
KC		 879 return;
880 }
881
246e0cd0 882 controlvm_init_response(&outmsg, &p->pending_msg_hdr, response);
12e364b9 883
2ea5117b
BR		 884 outmsg.cmd.device_change_state.bus_no = busNo;
885 outmsg.cmd.device_change_state.dev_no = devNo;
886 outmsg.cmd.device_change_state.state = responseState;
12e364b9
KC		 887
888 if (!visorchannel_signalinsert(ControlVm_channel,
889 CONTROLVM_QUEUE_REQUEST, &outmsg)) {
890 LOGERR("signalinsert failed!");
891 return;
892 }
893
246e0cd0 894 p->pending_msg_hdr.id = CONTROLVM_INVALID;
12e364b9
KC		 895}
896
897static void
53bebb13
BR		 898device_responder(enum controlvm_id cmdId, ulong busNo, ulong devNo,
899 int response)
12e364b9 900{
246e0cd0 901 struct visorchipset_device_info *p = NULL;
12e364b9
KC		 902 BOOL need_clear = FALSE;
903
904 p = finddevice(&DevInfoList, busNo, devNo);
905 if (!p) {
906 LOGERR("internal error; busNo=%lu, devNo=%lu", busNo, devNo);
907 return;
908 }
909 if (response >= 0) {
910 if (cmdId == CONTROLVM_DEVICE_CREATE)
911 p->state.created = 1;
912 if (cmdId == CONTROLVM_DEVICE_DESTROY)
913 need_clear = TRUE;
914 }
915
246e0cd0 916 if (p->pending_msg_hdr.id == CONTROLVM_INVALID) {
12e364b9
KC		 917 LOGERR("device_responder no pending msg");
918 return; /* no controlvm response needed */
919 }
246e0cd0
BR		 920 if (p->pending_msg_hdr.id != (u32) cmdId) {
921 LOGERR("expected=%d, found=%d", cmdId, p->pending_msg_hdr.id);
12e364b9
KC		 922 return;
923 }
246e0cd0
BR		 924 controlvm_respond(&p->pending_msg_hdr, response);
925 p->pending_msg_hdr.id = CONTROLVM_INVALID;
12e364b9
KC		 926 if (need_clear)
927 devInfo_clear(p);
928}
929
930static void
b3c55b13 931bus_epilog(u32 busNo,
98d7b594 932 u32 cmd, struct controlvm_message_header *msgHdr,
12e364b9
KC		 933 int response, BOOL needResponse)
934{
935 BOOL notified = FALSE;
936
33192fa1 937 struct visorchipset_bus_info *pBusInfo = findbus(&BusInfoList, busNo);
12e364b9
KC		 938
939 if (!pBusInfo) {
940 LOGERR("HUH? bad busNo=%d", busNo);
941 return;
942 }
943 if (needResponse) {
33192fa1 944 memcpy(&pBusInfo->pending_msg_hdr, msgHdr,
98d7b594 945 sizeof(struct controlvm_message_header));
12e364b9 946 } else
33192fa1 947 pBusInfo->pending_msg_hdr.id = CONTROLVM_INVALID;
12e364b9 948
f2170625 949 down(&NotifierLock);
12e364b9
KC		 950 if (response == CONTROLVM_RESP_SUCCESS) {
951 switch (cmd) {
952 case CONTROLVM_BUS_CREATE:
953 /* We can't tell from the bus_create
954 * information which of our 2 bus flavors the
955 * devices on this bus will ultimately end up.
956 * FORTUNATELY, it turns out it is harmless to
957 * send the bus_create to both of them. We can
958 * narrow things down a little bit, though,
959 * because we know: - BusDev_Server can handle
960 * either server or client devices
961 * - BusDev_Client can handle ONLY client
962 * devices */
963 if (BusDev_Server_Notifiers.bus_create) {
964 (*BusDev_Server_Notifiers.bus_create) (busNo);
965 notified = TRUE;
966 }
967 if ((!pBusInfo->flags.server) /*client */ &&
968 BusDev_Client_Notifiers.bus_create) {
969 (*BusDev_Client_Notifiers.bus_create) (busNo);
970 notified = TRUE;
971 }
972 break;
973 case CONTROLVM_BUS_DESTROY:
974 if (BusDev_Server_Notifiers.bus_destroy) {
975 (*BusDev_Server_Notifiers.bus_destroy) (busNo);
976 notified = TRUE;
977 }
978 if ((!pBusInfo->flags.server) /*client */ &&
979 BusDev_Client_Notifiers.bus_destroy) {
980 (*BusDev_Client_Notifiers.bus_destroy) (busNo);
981 notified = TRUE;
982 }
983 break;
984 }
985 }
986 if (notified)
987 /* The callback function just called above is responsible
929aa8ae 988 * for calling the appropriate visorchipset_busdev_responders
12e364b9
KC		 989 * function, which will call bus_responder()
990 */
991 ;
992 else
993 bus_responder(cmd, busNo, response);
f2170625 994 up(&NotifierLock);
12e364b9
KC		 995}
996
997static void
3f833b54 998device_epilog(u32 busNo, u32 devNo, struct spar_segment_state state, u32 cmd,
98d7b594 999 struct controlvm_message_header *msgHdr, int response,
12e364b9
KC		 1000 BOOL needResponse, BOOL for_visorbus)
1001{
fe90d892 1002 struct visorchipset_busdev_notifiers *notifiers = NULL;
12e364b9
KC		 1003 BOOL notified = FALSE;
1004
246e0cd0 1005 struct visorchipset_device_info *pDevInfo =
12e364b9
KC		 1006 finddevice(&DevInfoList, busNo, devNo);
1007 char *envp[] = {
1008 "SPARSP_DIAGPOOL_PAUSED_STATE = 1",
1009 NULL
1010 };
1011
1012 if (!pDevInfo) {
1013 LOGERR("HUH? bad busNo=%d, devNo=%d", busNo, devNo);
1014 return;
1015 }
1016 if (for_visorbus)
1017 notifiers = &BusDev_Server_Notifiers;
1018 else
1019 notifiers = &BusDev_Client_Notifiers;
1020 if (needResponse) {
246e0cd0 1021 memcpy(&pDevInfo->pending_msg_hdr, msgHdr,
98d7b594 1022 sizeof(struct controlvm_message_header));
12e364b9 1023 } else
246e0cd0 1024 pDevInfo->pending_msg_hdr.id = CONTROLVM_INVALID;
12e364b9 1025
f2170625 1026 down(&NotifierLock);
12e364b9
KC		 1027 if (response >= 0) {
1028 switch (cmd) {
1029 case CONTROLVM_DEVICE_CREATE:
1030 if (notifiers->device_create) {
1031 (*notifiers->device_create) (busNo, devNo);
1032 notified = TRUE;
1033 }
1034 break;
1035 case CONTROLVM_DEVICE_CHANGESTATE:
1036 /* ServerReady / ServerRunning / SegmentStateRunning */
bd0d2dcc
BR		 1037 if (state.alive == segment_state_running.alive &&
1038 state.operating ==
1039 segment_state_running.operating) {
12e364b9
KC		 1040 if (notifiers->device_resume) {
1041 (*notifiers->device_resume) (busNo,
1042 devNo);
1043 notified = TRUE;
1044 }
1045 }
1046 /* ServerNotReady / ServerLost / SegmentStateStandby */
bd0d2dcc 1047 else if (state.alive == segment_state_standby.alive &&
3f833b54 1048 state.operating ==
bd0d2dcc 1049 segment_state_standby.operating) {
12e364b9
KC		 1050 /* technically this is standby case
1051 * where server is lost
1052 */
1053 if (notifiers->device_pause) {
1054 (*notifiers->device_pause) (busNo,
1055 devNo);
1056 notified = TRUE;
1057 }
bd0d2dcc 1058 } else if (state.alive == segment_state_paused.alive &&
3f833b54 1059 state.operating ==
bd0d2dcc 1060 segment_state_paused.operating) {
12e364b9
KC		 1061 /* this is lite pause where channel is
1062 * still valid just 'pause' of it
1063 */
1064 if (busNo == g_diagpoolBusNo
1065 && devNo == g_diagpoolDevNo) {
1066 LOGINF("DEVICE_CHANGESTATE(DiagpoolChannel busNo=%d devNo=%d is pausing...)",
1067 busNo, devNo);
1068 /* this will trigger the
1069 * diag_shutdown.sh script in
1070 * the visorchipset hotplug */
1071 kobject_uevent_env
1072 (&Visorchipset_platform_device.dev.
1073 kobj, KOBJ_ONLINE, envp);
1074 }
1075 }
1076 break;
1077 case CONTROLVM_DEVICE_DESTROY:
1078 if (notifiers->device_destroy) {
1079 (*notifiers->device_destroy) (busNo, devNo);
1080 notified = TRUE;
1081 }
1082 break;
1083 }
1084 }
1085 if (notified)
1086 /* The callback function just called above is responsible
929aa8ae 1087 * for calling the appropriate visorchipset_busdev_responders
12e364b9
KC		 1088 * function, which will call device_responder()
1089 */
1090 ;
1091 else
1092 device_responder(cmd, busNo, devNo, response);
f2170625 1093 up(&NotifierLock);
12e364b9
KC		 1094}
1095
1096static void
3ab47701 1097bus_create(struct controlvm_message *inmsg)
12e364b9 1098{
2ea5117b
BR		 1099 struct controlvm_message_packet *cmd = &inmsg->cmd;
1100 ulong busNo = cmd->create_bus.bus_no;
12e364b9 1101 int rc = CONTROLVM_RESP_SUCCESS;
33192fa1 1102 struct visorchipset_bus_info *pBusInfo = NULL;
12e364b9
KC		 1103
1104
1105 pBusInfo = findbus(&BusInfoList, busNo);
1106 if (pBusInfo && (pBusInfo->state.created == 1)) {
1107 LOGERR("CONTROLVM_BUS_CREATE Failed: bus %lu already exists",
1108 busNo);
1109 POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, busNo,
1110 POSTCODE_SEVERITY_ERR);
22ad57ba
KC		 1111 rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
1112 goto Away;
12e364b9 1113 }
33192fa1 1114 pBusInfo = kzalloc(sizeof(struct visorchipset_bus_info), GFP_KERNEL);
12e364b9 1115 if (pBusInfo == NULL) {
12e364b9
KC		 1116 POSTCODE_LINUX_3(BUS_CREATE_FAILURE_PC, busNo,
1117 POSTCODE_SEVERITY_ERR);
22ad57ba
KC		 1118 rc = -CONTROLVM_RESP_ERROR_KMALLOC_FAILED;
1119 goto Away;
12e364b9
KC		 1120 }
1121
12e364b9 1122 INIT_LIST_HEAD(&pBusInfo->entry);
33192fa1
BR		 1123 pBusInfo->bus_no = busNo;
1124 pBusInfo->dev_no = cmd->create_bus.dev_count;
12e364b9
KC		 1125
1126 POSTCODE_LINUX_3(BUS_CREATE_ENTRY_PC, busNo, POSTCODE_SEVERITY_INFO);
1127
98d7b594 1128 if (inmsg->hdr.flags.test_message == 1)
33192fa1 1129 pBusInfo->chan_info.addr_type = ADDRTYPE_LOCALTEST;
12e364b9 1130 else
33192fa1 1131 pBusInfo->chan_info.addr_type = ADDRTYPE_LOCALPHYSICAL;
12e364b9 1132
98d7b594 1133 pBusInfo->flags.server = inmsg->hdr.flags.server;
33192fa1
BR		 1134 pBusInfo->chan_info.channel_addr = cmd->create_bus.channel_addr;
1135 pBusInfo->chan_info.n_channel_bytes = cmd->create_bus.channel_bytes;
1136 pBusInfo->chan_info.channel_type_uuid =
9b1caee7 1137 cmd->create_bus.bus_data_type_uuid;
33192fa1 1138 pBusInfo->chan_info.channel_inst_uuid = cmd->create_bus.bus_inst_uuid;
12e364b9
KC		 1139
1140 list_add(&pBusInfo->entry, &BusInfoList);
1141
1142 POSTCODE_LINUX_3(BUS_CREATE_EXIT_PC, busNo, POSTCODE_SEVERITY_INFO);
1143
1144Away:
1145 bus_epilog(busNo, CONTROLVM_BUS_CREATE, &inmsg->hdr,
98d7b594 1146 rc, inmsg->hdr.flags.response_expected == 1);
12e364b9
KC		 1147}
1148
1149static void
3ab47701 1150bus_destroy(struct controlvm_message *inmsg)
12e364b9 1151{
2ea5117b
BR		 1152 struct controlvm_message_packet *cmd = &inmsg->cmd;
1153 ulong busNo = cmd->destroy_bus.bus_no;
33192fa1 1154 struct visorchipset_bus_info *pBusInfo;
12e364b9
KC		 1155 int rc = CONTROLVM_RESP_SUCCESS;
1156
1157 pBusInfo = findbus(&BusInfoList, busNo);
1158 if (!pBusInfo) {
1159 LOGERR("CONTROLVM_BUS_DESTROY Failed: bus %lu invalid", busNo);
22ad57ba
KC		 1160 rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
1161 goto Away;
12e364b9
KC		 1162 }
1163 if (pBusInfo->state.created == 0) {
1164 LOGERR("CONTROLVM_BUS_DESTROY Failed: bus %lu already destroyed",
1165 busNo);
22ad57ba
KC		 1166 rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
1167 goto Away;
12e364b9
KC		 1168 }
1169
1170Away:
1171 bus_epilog(busNo, CONTROLVM_BUS_DESTROY, &inmsg->hdr,
98d7b594 1172 rc, inmsg->hdr.flags.response_expected == 1);
12e364b9
KC		 1173}
1174
1175static void
3ab47701 1176bus_configure(struct controlvm_message *inmsg, PARSER_CONTEXT *parser_ctx)
12e364b9 1177{
2ea5117b
BR		 1178 struct controlvm_message_packet *cmd = &inmsg->cmd;
1179 ulong busNo = cmd->configure_bus.bus_no;
33192fa1 1180 struct visorchipset_bus_info *pBusInfo = NULL;
12e364b9
KC		 1181 int rc = CONTROLVM_RESP_SUCCESS;
1182 char s[99];
1183
2ea5117b 1184 busNo = cmd->configure_bus.bus_no;
12e364b9
KC		 1185 POSTCODE_LINUX_3(BUS_CONFIGURE_ENTRY_PC, busNo, POSTCODE_SEVERITY_INFO);
1186
1187 pBusInfo = findbus(&BusInfoList, busNo);
1188 if (!pBusInfo) {
1189 LOGERR("CONTROLVM_BUS_CONFIGURE Failed: bus %lu invalid",
1190 busNo);
1191 POSTCODE_LINUX_3(BUS_CONFIGURE_FAILURE_PC, busNo,
1192 POSTCODE_SEVERITY_ERR);
22ad57ba
KC		 1193 rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
1194 goto Away;
12e364b9
KC		 1195 }
1196 if (pBusInfo->state.created == 0) {
1197 LOGERR("CONTROLVM_BUS_CONFIGURE Failed: Invalid bus %lu - not created yet",
1198 busNo);
1199 POSTCODE_LINUX_3(BUS_CONFIGURE_FAILURE_PC, busNo,
1200 POSTCODE_SEVERITY_ERR);
22ad57ba
KC		 1201 rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
1202 goto Away;
12e364b9
KC		 1203 }
1204 /* TBD - add this check to other commands also... */
33192fa1 1205 if (pBusInfo->pending_msg_hdr.id != CONTROLVM_INVALID) {
12e364b9 1206 LOGERR("CONTROLVM_BUS_CONFIGURE Failed: bus %lu MsgId=%u outstanding",
33192fa1 1207 busNo, (uint) pBusInfo->pending_msg_hdr.id);
12e364b9
KC		 1208 POSTCODE_LINUX_3(BUS_CONFIGURE_FAILURE_PC, busNo,
1209 POSTCODE_SEVERITY_ERR);
22ad57ba
KC		 1210 rc = -CONTROLVM_RESP_ERROR_MESSAGE_ID_INVALID_FOR_CLIENT;
1211 goto Away;
12e364b9
KC		 1212 }
1213
33192fa1
BR		 1214 pBusInfo->partition_handle = cmd->configure_bus.guest_handle;
1215 pBusInfo->partition_uuid = parser_id_get(parser_ctx);
12e364b9
KC		 1216 parser_param_start(parser_ctx, PARSERSTRING_NAME);
1217 pBusInfo->name = parser_string_get(parser_ctx);
1218
33192fa1 1219 visorchannel_uuid_id(&pBusInfo->partition_uuid, s);
12e364b9
KC		 1220 POSTCODE_LINUX_3(BUS_CONFIGURE_EXIT_PC, busNo, POSTCODE_SEVERITY_INFO);
1221Away:
1222 bus_epilog(busNo, CONTROLVM_BUS_CONFIGURE, &inmsg->hdr,
98d7b594 1223 rc, inmsg->hdr.flags.response_expected == 1);
12e364b9
KC		 1224}
1225
1226static void
3ab47701 1227my_device_create(struct controlvm_message *inmsg)
12e364b9 1228{
2ea5117b 1229 struct controlvm_message_packet *cmd = &inmsg->cmd;
f91b9262
BR		 1230 ulong busNo = cmd->create_device.bus_no;
1231 ulong devNo = cmd->create_device.dev_no;
246e0cd0 1232 struct visorchipset_device_info *pDevInfo = NULL;
33192fa1 1233 struct visorchipset_bus_info *pBusInfo = NULL;
12e364b9
KC		 1234 int rc = CONTROLVM_RESP_SUCCESS;
1235
1236 pDevInfo = finddevice(&DevInfoList, busNo, devNo);
1237 if (pDevInfo && (pDevInfo->state.created == 1)) {
1238 LOGERR("CONTROLVM_DEVICE_CREATE Failed: busNo=%lu, devNo=%lu already exists",
1239 busNo, devNo);
1240 POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
1241 POSTCODE_SEVERITY_ERR);
22ad57ba
KC		 1242 rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
1243 goto Away;
12e364b9
KC		 1244 }
1245 pBusInfo = findbus(&BusInfoList, busNo);
1246 if (!pBusInfo) {
1247 LOGERR("CONTROLVM_DEVICE_CREATE Failed: Invalid bus %lu - out of range",
1248 busNo);
1249 POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
1250 POSTCODE_SEVERITY_ERR);
22ad57ba
KC		 1251 rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
1252 goto Away;
12e364b9
KC		 1253 }
1254 if (pBusInfo->state.created == 0) {
1255 LOGERR("CONTROLVM_DEVICE_CREATE Failed: Invalid bus %lu - not created yet",
1256 busNo);
1257 POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
1258 POSTCODE_SEVERITY_ERR);
22ad57ba
KC		 1259 rc = -CONTROLVM_RESP_ERROR_BUS_INVALID;
1260 goto Away;
12e364b9 1261 }
246e0cd0 1262 pDevInfo = kzalloc(sizeof(struct visorchipset_device_info), GFP_KERNEL);
12e364b9 1263 if (pDevInfo == NULL) {
12e364b9
KC		 1264 POSTCODE_LINUX_4(DEVICE_CREATE_FAILURE_PC, devNo, busNo,
1265 POSTCODE_SEVERITY_ERR);
22ad57ba
KC		 1266 rc = -CONTROLVM_RESP_ERROR_KMALLOC_FAILED;
1267 goto Away;
12e364b9 1268 }
97a84f12 1269
12e364b9 1270 INIT_LIST_HEAD(&pDevInfo->entry);
246e0cd0
BR		 1271 pDevInfo->bus_no = busNo;
1272 pDevInfo->dev_no = devNo;
1273 pDevInfo->dev_inst_uuid = cmd->create_device.dev_inst_uuid;
12e364b9
KC		 1274 POSTCODE_LINUX_4(DEVICE_CREATE_ENTRY_PC, devNo, busNo,
1275 POSTCODE_SEVERITY_INFO);
1276
98d7b594 1277 if (inmsg->hdr.flags.test_message == 1)
246e0cd0 1278 pDevInfo->chan_info.addr_type = ADDRTYPE_LOCALTEST;
12e364b9 1279 else
246e0cd0
BR		 1280 pDevInfo->chan_info.addr_type = ADDRTYPE_LOCALPHYSICAL;
1281 pDevInfo->chan_info.channel_addr = cmd->create_device.channel_addr;
1282 pDevInfo->chan_info.n_channel_bytes = cmd->create_device.channel_bytes;
1283 pDevInfo->chan_info.channel_type_uuid =
9b1caee7 1284 cmd->create_device.data_type_uuid;
246e0cd0 1285 pDevInfo->chan_info.intr = cmd->create_device.intr;
12e364b9
KC		 1286 list_add(&pDevInfo->entry, &DevInfoList);
1287 POSTCODE_LINUX_4(DEVICE_CREATE_EXIT_PC, devNo, busNo,
1288 POSTCODE_SEVERITY_INFO);
1289Away:
1290 /* get the bus and devNo for DiagPool channel */
930a021f
SM		 1291 if (pDevInfo &&
1292 is_diagpool_channel(pDevInfo->chan_info.channel_type_uuid)) {
12e364b9
KC		 1293 g_diagpoolBusNo = busNo;
1294 g_diagpoolDevNo = devNo;
1295 LOGINF("CONTROLVM_DEVICE_CREATE for DiagPool channel: busNo=%lu, devNo=%lu",
1296 g_diagpoolBusNo, g_diagpoolDevNo);
1297 }
bd0d2dcc 1298 device_epilog(busNo, devNo, segment_state_running,
12e364b9 1299 CONTROLVM_DEVICE_CREATE, &inmsg->hdr, rc,
98d7b594 1300 inmsg->hdr.flags.response_expected == 1,
246e0cd0 1301 FOR_VISORBUS(pDevInfo->chan_info.channel_type_uuid));
12e364b9
KC		 1302}
1303
1304static void
3ab47701 1305my_device_changestate(struct controlvm_message *inmsg)
12e364b9 1306{
2ea5117b
BR		 1307 struct controlvm_message_packet *cmd = &inmsg->cmd;
1308 ulong busNo = cmd->device_change_state.bus_no;
1309 ulong devNo = cmd->device_change_state.dev_no;
1310 struct spar_segment_state state = cmd->device_change_state.state;
246e0cd0 1311 struct visorchipset_device_info *pDevInfo = NULL;
12e364b9
KC		 1312 int rc = CONTROLVM_RESP_SUCCESS;
1313
1314 pDevInfo = finddevice(&DevInfoList, busNo, devNo);
1315 if (!pDevInfo) {
1316 LOGERR("CONTROLVM_DEVICE_CHANGESTATE Failed: busNo=%lu, devNo=%lu invalid (doesn't exist)",
1317 busNo, devNo);
1318 POSTCODE_LINUX_4(DEVICE_CHANGESTATE_FAILURE_PC, devNo, busNo,
1319 POSTCODE_SEVERITY_ERR);
22ad57ba
KC		 1320 rc = -CONTROLVM_RESP_ERROR_DEVICE_INVALID;
1321 goto Away;
12e364b9
KC		 1322 }
1323 if (pDevInfo->state.created == 0) {
1324 LOGERR("CONTROLVM_DEVICE_CHANGESTATE Failed: busNo=%lu, devNo=%lu invalid (not created)",
1325 busNo, devNo);
1326 POSTCODE_LINUX_4(DEVICE_CHANGESTATE_FAILURE_PC, devNo, busNo,
1327 POSTCODE_SEVERITY_ERR);
22ad57ba 1328 rc = -CONTROLVM_RESP_ERROR_DEVICE_INVALID;
12e364b9
KC		 1329 }
1330Away:
1331 if ((rc >= CONTROLVM_RESP_SUCCESS) && pDevInfo)
1332 device_epilog(busNo, devNo, state, CONTROLVM_DEVICE_CHANGESTATE,
1333 &inmsg->hdr, rc,
98d7b594 1334 inmsg->hdr.flags.response_expected == 1,
9b1caee7 1335 FOR_VISORBUS(
246e0cd0 1336 pDevInfo->chan_info.channel_type_uuid));
12e364b9
KC		 1337}
1338
1339static void
3ab47701 1340my_device_destroy(struct controlvm_message *inmsg)
12e364b9 1341{
2ea5117b
BR		 1342 struct controlvm_message_packet *cmd = &inmsg->cmd;
1343 ulong busNo = cmd->destroy_device.bus_no;
1344 ulong devNo = cmd->destroy_device.dev_no;
246e0cd0 1345 struct visorchipset_device_info *pDevInfo = NULL;
12e364b9
KC		 1346 int rc = CONTROLVM_RESP_SUCCESS;
1347
1348 pDevInfo = finddevice(&DevInfoList, busNo, devNo);
1349 if (!pDevInfo) {
1350 LOGERR("CONTROLVM_DEVICE_DESTROY Failed: busNo=%lu, devNo=%lu invalid",
1351 busNo, devNo);
22ad57ba
KC		 1352 rc = -CONTROLVM_RESP_ERROR_DEVICE_INVALID;
1353 goto Away;
12e364b9
KC		 1354 }
1355 if (pDevInfo->state.created == 0) {
1356 LOGERR("CONTROLVM_DEVICE_DESTROY Failed: busNo=%lu, devNo=%lu already destroyed",
1357 busNo, devNo);
22ad57ba 1358 rc = -CONTROLVM_RESP_ERROR_ALREADY_DONE;
12e364b9
KC		 1359 }
1360
1361Away:
1362 if ((rc >= CONTROLVM_RESP_SUCCESS) && pDevInfo)
bd0d2dcc 1363 device_epilog(busNo, devNo, segment_state_running,
12e364b9 1364 CONTROLVM_DEVICE_DESTROY, &inmsg->hdr, rc,
98d7b594 1365 inmsg->hdr.flags.response_expected == 1,
9b1caee7 1366 FOR_VISORBUS(
246e0cd0 1367 pDevInfo->chan_info.channel_type_uuid));
12e364b9
KC		 1368}
1369
1370/* When provided with the physical address of the controlvm channel
1371 * (phys_addr), the offset to the payload area we need to manage
1372 * (offset), and the size of this payload area (bytes), fills in the
84b11dfd 1373 * controlvm_payload_info struct. Returns TRUE for success or FALSE
12e364b9
KC		 1374 * for failure.
1375 */
1376static int
5fc0229a 1377initialize_controlvm_payload_info(HOSTADDRESS phys_addr, u64 offset, u32 bytes,
84b11dfd 1378 struct controlvm_payload_info *info)
12e364b9 1379{
c242233e 1380 u8 __iomem *payload = NULL;
12e364b9
KC		 1381 int rc = CONTROLVM_RESP_SUCCESS;
1382
1383 if (info == NULL) {
1384 LOGERR("HUH ? CONTROLVM_PAYLOAD_INIT Failed : Programmer check at %s:%d",
1385 __FILE__, __LINE__);
22ad57ba
KC		 1386 rc = -CONTROLVM_RESP_ERROR_PAYLOAD_INVALID;
1387 goto Away;
12e364b9 1388 }
84b11dfd 1389 memset(info, 0, sizeof(struct controlvm_payload_info));
12e364b9 1390 if ((offset == 0) || (bytes == 0)) {
d19642f6 1391 LOGERR("CONTROLVM_PAYLOAD_INIT Failed: request_payload_offset=%llu request_payload_bytes=%llu!",
12e364b9 1392 (u64) offset, (u64) bytes);
22ad57ba
KC		 1393 rc = -CONTROLVM_RESP_ERROR_PAYLOAD_INVALID;
1394 goto Away;
12e364b9
KC		 1395 }
1396 payload = ioremap_cache(phys_addr + offset, bytes);
1397 if (payload == NULL) {
1398 LOGERR("CONTROLVM_PAYLOAD_INIT Failed: ioremap_cache %llu for %llu bytes failed",
1399 (u64) offset, (u64) bytes);
22ad57ba
KC		 1400 rc = -CONTROLVM_RESP_ERROR_IOREMAP_FAILED;
1401 goto Away;
12e364b9
KC		 1402 }
1403
1404 info->offset = offset;
1405 info->bytes = bytes;
1406 info->ptr = payload;
1407 LOGINF("offset=%llu, bytes=%lu, ptr=%p",
1408 (u64) (info->offset), (ulong) (info->bytes), info->ptr);
1409
1410Away:
1411 if (rc < 0) {
1412 if (payload != NULL) {
1413 iounmap(payload);
1414 payload = NULL;
1415 }
1416 }
1417 return rc;
1418}
1419
1420static void
84b11dfd 1421destroy_controlvm_payload_info(struct controlvm_payload_info *info)
12e364b9
KC		 1422{
1423 if (info->ptr != NULL) {
1424 iounmap(info->ptr);
1425 info->ptr = NULL;
1426 }
84b11dfd 1427 memset(info, 0, sizeof(struct controlvm_payload_info));
12e364b9
KC		 1428}
1429
1430static void
1431initialize_controlvm_payload(void)
1432{
1433 HOSTADDRESS phys_addr = visorchannel_get_physaddr(ControlVm_channel);
5fc0229a 1434 u64 payloadOffset = 0;
b3c55b13 1435 u32 payloadBytes = 0;
26eb2c0c 1436
12e364b9 1437 if (visorchannel_read(ControlVm_channel,
d19642f6
BR		 1438 offsetof(struct spar_controlvm_channel_protocol,
1439 request_payload_offset),
12e364b9
KC		 1440 &payloadOffset, sizeof(payloadOffset)) < 0) {
1441 LOGERR("CONTROLVM_PAYLOAD_INIT Failed to read controlvm channel!");
1442 POSTCODE_LINUX_2(CONTROLVM_INIT_FAILURE_PC,
1443 POSTCODE_SEVERITY_ERR);
1444 return;
1445 }
1446 if (visorchannel_read(ControlVm_channel,
d19642f6
BR		 1447 offsetof(struct spar_controlvm_channel_protocol,
1448 request_payload_bytes),
12e364b9
KC		 1449 &payloadBytes, sizeof(payloadBytes)) < 0) {
1450 LOGERR("CONTROLVM_PAYLOAD_INIT Failed to read controlvm channel!");
1451 POSTCODE_LINUX_2(CONTROLVM_INIT_FAILURE_PC,
1452 POSTCODE_SEVERITY_ERR);
1453 return;
1454 }
1455 initialize_controlvm_payload_info(phys_addr,
1456 payloadOffset, payloadBytes,
1457 &ControlVm_payload_info);
1458}
1459
1460/* Send ACTION=online for DEVPATH=/sys/devices/platform/visorchipset.
1461 * Returns CONTROLVM_RESP_xxx code.
1462 */
1463int
1464visorchipset_chipset_ready(void)
1465{
1466 kobject_uevent(&Visorchipset_platform_device.dev.kobj, KOBJ_ONLINE);
1467 return CONTROLVM_RESP_SUCCESS;
1468}
1469EXPORT_SYMBOL_GPL(visorchipset_chipset_ready);
1470
1471int
1472visorchipset_chipset_selftest(void)
1473{
1474 char env_selftest[20];
1475 char *envp[] = { env_selftest, NULL };
26eb2c0c 1476
12e364b9
KC		 1477 sprintf(env_selftest, "SPARSP_SELFTEST=%d", 1);
1478 kobject_uevent_env(&Visorchipset_platform_device.dev.kobj, KOBJ_CHANGE,
1479 envp);
1480 return CONTROLVM_RESP_SUCCESS;
1481}
1482EXPORT_SYMBOL_GPL(visorchipset_chipset_selftest);
1483
1484/* Send ACTION=offline for DEVPATH=/sys/devices/platform/visorchipset.
1485 * Returns CONTROLVM_RESP_xxx code.
1486 */
1487int
1488visorchipset_chipset_notready(void)
1489{
1490 kobject_uevent(&Visorchipset_platform_device.dev.kobj, KOBJ_OFFLINE);
1491 return CONTROLVM_RESP_SUCCESS;
1492}
1493EXPORT_SYMBOL_GPL(visorchipset_chipset_notready);
1494
1495static void
98d7b594 1496chipset_ready(struct controlvm_message_header *msgHdr)
12e364b9
KC		 1497{
1498 int rc = visorchipset_chipset_ready();
26eb2c0c 1499
12e364b9
KC		 1500 if (rc != CONTROLVM_RESP_SUCCESS)
1501 rc = -rc;
98d7b594 1502 if (msgHdr->flags.response_expected && !visorchipset_holdchipsetready)
12e364b9 1503 controlvm_respond(msgHdr, rc);
98d7b594 1504 if (msgHdr->flags.response_expected && visorchipset_holdchipsetready) {
12e364b9
KC		 1505 /* Send CHIPSET_READY response when all modules have been loaded
1506 * and disks mounted for the partition
1507 */
1508 g_ChipSetMsgHdr = *msgHdr;
1509 LOGINF("Holding CHIPSET_READY response");
1510 }
1511}
1512
1513static void
98d7b594 1514chipset_selftest(struct controlvm_message_header *msgHdr)
12e364b9
KC		 1515{
1516 int rc = visorchipset_chipset_selftest();
26eb2c0c 1517
12e364b9
KC		 1518 if (rc != CONTROLVM_RESP_SUCCESS)
1519 rc = -rc;
98d7b594 1520 if (msgHdr->flags.response_expected)
12e364b9
KC		 1521 controlvm_respond(msgHdr, rc);
1522}
1523
1524static void
98d7b594 1525chipset_notready(struct controlvm_message_header *msgHdr)
12e364b9
KC		 1526{
1527 int rc = visorchipset_chipset_notready();
26eb2c0c 1528
12e364b9
KC		 1529 if (rc != CONTROLVM_RESP_SUCCESS)
1530 rc = -rc;
98d7b594 1531 if (msgHdr->flags.response_expected)
12e364b9
KC		 1532 controlvm_respond(msgHdr, rc);
1533}
1534
1535/* This is your "one-stop" shop for grabbing the next message from the
1536 * CONTROLVM_QUEUE_EVENT queue in the controlvm channel.
1537 */
1538static BOOL
3ab47701 1539read_controlvm_event(struct controlvm_message *msg)
12e364b9
KC		 1540{
1541 if (visorchannel_signalremove(ControlVm_channel,
1542 CONTROLVM_QUEUE_EVENT, msg)) {
1543 /* got a message */
98d7b594
BR		 1544 if (msg->hdr.flags.test_message == 1) {
1545 LOGERR("ignoring bad CONTROLVM_QUEUE_EVENT msg with controlvm_msg_id=0x%x because Flags.testMessage is nonsensical (=1)",
1546 msg->hdr.id);
12e364b9 1547 return FALSE;
e22a4a0f
BR		 1548 }
1549 return TRUE;
12e364b9
KC		 1550 }
1551 return FALSE;
1552}
1553
1554/*
1555 * The general parahotplug flow works as follows. The visorchipset
1556 * driver receives a DEVICE_CHANGESTATE message from Command
1557 * specifying a physical device to enable or disable. The CONTROLVM
1558 * message handler calls parahotplug_process_message, which then adds
1559 * the message to a global list and kicks off a udev event which
1560 * causes a user level script to enable or disable the specified
1561 * device. The udev script then writes to
1562 * /proc/visorchipset/parahotplug, which causes parahotplug_proc_write
1563 * to get called, at which point the appropriate CONTROLVM message is
1564 * retrieved from the list and responded to.
1565 */
1566
1567#define PARAHOTPLUG_TIMEOUT_MS 2000
1568
1569/*
1570 * Generate unique int to match an outstanding CONTROLVM message with a
1571 * udev script /proc response
1572 */
1573static int
1574parahotplug_next_id(void)
1575{
1576 static atomic_t id = ATOMIC_INIT(0);
26eb2c0c 1577
12e364b9
KC		 1578 return atomic_inc_return(&id);
1579}
1580
1581/*
1582 * Returns the time (in jiffies) when a CONTROLVM message on the list
1583 * should expire -- PARAHOTPLUG_TIMEOUT_MS in the future
1584 */
1585static unsigned long
1586parahotplug_next_expiration(void)
1587{
2cc1a1b3 1588 return jiffies + msecs_to_jiffies(PARAHOTPLUG_TIMEOUT_MS);
12e364b9
KC		 1589}
1590
1591/*
1592 * Create a parahotplug_request, which is basically a wrapper for a
1593 * CONTROLVM_MESSAGE that we can stick on a list
1594 */
1595static struct parahotplug_request *
3ab47701 1596parahotplug_request_create(struct controlvm_message *msg)
12e364b9 1597{
ea0dcfcf
QL		 1598 struct parahotplug_request *req;
1599
1600 req = kmalloc(sizeof(*req), GFP_KERNEL|__GFP_NORETRY);
12e364b9
KC		 1601 if (req == NULL)
1602 return NULL;
1603
1604 req->id = parahotplug_next_id();
1605 req->expiration = parahotplug_next_expiration();
1606 req->msg = *msg;
1607
1608 return req;
1609}
1610
1611/*
1612 * Free a parahotplug_request.
1613 */
1614static void
1615parahotplug_request_destroy(struct parahotplug_request *req)
1616{
1617 kfree(req);
1618}
1619
1620/*
1621 * Cause uevent to run the user level script to do the disable/enable
1622 * specified in (the CONTROLVM message in) the specified
1623 * parahotplug_request
1624 */
1625static void
1626parahotplug_request_kickoff(struct parahotplug_request *req)
1627{
2ea5117b 1628 struct controlvm_message_packet *cmd = &req->msg.cmd;
12e364b9
KC		 1629 char env_cmd[40], env_id[40], env_state[40], env_bus[40], env_dev[40],
1630 env_func[40];
1631 char *envp[] = {
1632 env_cmd, env_id, env_state, env_bus, env_dev, env_func, NULL
1633 };
1634
1635 sprintf(env_cmd, "SPAR_PARAHOTPLUG=1");
1636 sprintf(env_id, "SPAR_PARAHOTPLUG_ID=%d", req->id);
1637 sprintf(env_state, "SPAR_PARAHOTPLUG_STATE=%d",
2ea5117b 1638 cmd->device_change_state.state.active);
12e364b9 1639 sprintf(env_bus, "SPAR_PARAHOTPLUG_BUS=%d",
2ea5117b 1640 cmd->device_change_state.bus_no);
12e364b9 1641 sprintf(env_dev, "SPAR_PARAHOTPLUG_DEVICE=%d",
2ea5117b 1642 cmd->device_change_state.dev_no >> 3);
12e364b9 1643 sprintf(env_func, "SPAR_PARAHOTPLUG_FUNCTION=%d",
2ea5117b 1644 cmd->device_change_state.dev_no & 0x7);
12e364b9
KC		 1645
1646 LOGINF("parahotplug_request_kickoff: state=%d, bdf=%d/%d/%d, id=%u\n",
2ea5117b
BR		 1647 cmd->device_change_state.state.active,
1648 cmd->device_change_state.bus_no,
1649 cmd->device_change_state.dev_no >> 3,
1650 cmd->device_change_state.dev_no & 7, req->id);
12e364b9
KC		 1651
1652 kobject_uevent_env(&Visorchipset_platform_device.dev.kobj, KOBJ_CHANGE,
1653 envp);
1654}
1655
1656/*
1657 * Remove any request from the list that's been on there too long and
1658 * respond with an error.
1659 */
1660static void
1661parahotplug_process_list(void)
1662{
1663 struct list_head *pos = NULL;
1664 struct list_head *tmp = NULL;
1665
1666 spin_lock(&Parahotplug_request_list_lock);
1667
1668 list_for_each_safe(pos, tmp, &Parahotplug_request_list) {
1669 struct parahotplug_request *req =
1670 list_entry(pos, struct parahotplug_request, list);
1671 if (time_after_eq(jiffies, req->expiration)) {
1672 list_del(pos);
98d7b594 1673 if (req->msg.hdr.flags.response_expected)
12e364b9
KC		 1674 controlvm_respond_physdev_changestate(
1675 &req->msg.hdr,
1676 CONTROLVM_RESP_ERROR_DEVICE_UDEV_TIMEOUT,
2ea5117b 1677 req->msg.cmd.device_change_state.state);
12e364b9
KC		 1678 parahotplug_request_destroy(req);
1679 }
1680 }
1681
1682 spin_unlock(&Parahotplug_request_list_lock);
1683}
1684
1685/*
1686 * Called from the /proc handler, which means the user script has
1687 * finished the enable/disable. Find the matching identifier, and
1688 * respond to the CONTROLVM message with success.
1689 */
1690static int
b06bdf7d 1691parahotplug_request_complete(int id, u16 active)
12e364b9
KC		 1692{
1693 struct list_head *pos = NULL;
1694 struct list_head *tmp = NULL;
1695
1696 spin_lock(&Parahotplug_request_list_lock);
1697
1698 /* Look for a request matching "id". */
1699 list_for_each_safe(pos, tmp, &Parahotplug_request_list) {
1700 struct parahotplug_request *req =
1701 list_entry(pos, struct parahotplug_request, list);
1702 if (req->id == id) {
1703 /* Found a match. Remove it from the list and
1704 * respond.
1705 */
1706 list_del(pos);
1707 spin_unlock(&Parahotplug_request_list_lock);
2ea5117b 1708 req->msg.cmd.device_change_state.state.active = active;
98d7b594 1709 if (req->msg.hdr.flags.response_expected)
12e364b9
KC		 1710 controlvm_respond_physdev_changestate(
1711 &req->msg.hdr, CONTROLVM_RESP_SUCCESS,
2ea5117b 1712 req->msg.cmd.device_change_state.state);
12e364b9
KC		 1713 parahotplug_request_destroy(req);
1714 return 0;
1715 }
1716 }
1717
1718 spin_unlock(&Parahotplug_request_list_lock);
1719 return -1;
1720}
1721
1722/*
1723 * Enables or disables a PCI device by kicking off a udev script
1724 */
bd5b9b32 1725static void
3ab47701 1726parahotplug_process_message(struct controlvm_message *inmsg)
12e364b9
KC		 1727{
1728 struct parahotplug_request *req;
1729
1730 req = parahotplug_request_create(inmsg);
1731
1732 if (req == NULL) {
1733 LOGERR("parahotplug_process_message: couldn't allocate request");
1734 return;
1735 }
1736
2ea5117b 1737 if (inmsg->cmd.device_change_state.state.active) {
12e364b9
KC		 1738 /* For enable messages, just respond with success
1739 * right away. This is a bit of a hack, but there are
1740 * issues with the early enable messages we get (with
1741 * either the udev script not detecting that the device
1742 * is up, or not getting called at all). Fortunately
1743 * the messages that get lost don't matter anyway, as
1744 * devices are automatically enabled at
1745 * initialization.
1746 */
1747 parahotplug_request_kickoff(req);
1748 controlvm_respond_physdev_changestate(&inmsg->hdr,
2ea5117b
BR		 1749 CONTROLVM_RESP_SUCCESS, inmsg->cmd.
1750 device_change_state.state);
12e364b9
KC		 1751 parahotplug_request_destroy(req);
1752 } else {
1753 /* For disable messages, add the request to the
1754 * request list before kicking off the udev script. It
1755 * won't get responded to until the script has
1756 * indicated it's done.
1757 */
1758 spin_lock(&Parahotplug_request_list_lock);
1759 list_add_tail(&(req->list), &Parahotplug_request_list);
1760 spin_unlock(&Parahotplug_request_list_lock);
1761
1762 parahotplug_request_kickoff(req);
1763 }
1764}
1765
12e364b9
KC		 1766/* Process a controlvm message.
1767 * Return result:
1768 * FALSE - this function will return FALSE only in the case where the
1769 * controlvm message was NOT processed, but processing must be
1770 * retried before reading the next controlvm message; a
1771 * scenario where this can occur is when we need to throttle
1772 * the allocation of memory in which to copy out controlvm
1773 * payload data
1774 * TRUE - processing of the controlvm message completed,
1775 * either successfully or with an error.
1776 */
1777static BOOL
3ab47701 1778handle_command(struct controlvm_message inmsg, HOSTADDRESS channel_addr)
12e364b9 1779{
2ea5117b 1780 struct controlvm_message_packet *cmd = &inmsg.cmd;
5fc0229a 1781 u64 parametersAddr = 0;
b3c55b13 1782 u32 parametersBytes = 0;
12e364b9
KC		 1783 PARSER_CONTEXT *parser_ctx = NULL;
1784 BOOL isLocalAddr = FALSE;
3ab47701 1785 struct controlvm_message ackmsg;
12e364b9
KC		 1786
1787 /* create parsing context if necessary */
98d7b594 1788 isLocalAddr = (inmsg.hdr.flags.test_message == 1);
12e364b9
KC		 1789 if (channel_addr == 0) {
1790 LOGERR("HUH? channel_addr is 0!");
1791 return TRUE;
1792 }
98d7b594
BR		 1793 parametersAddr = channel_addr + inmsg.hdr.payload_vm_offset;
1794 parametersBytes = inmsg.hdr.payload_bytes;
12e364b9
KC		 1795
1796 /* Parameter and channel addresses within test messages actually lie
1797 * within our OS-controlled memory. We need to know that, because it
1798 * makes a difference in how we compute the virtual address.
1799 */
1800 if (parametersAddr != 0 && parametersBytes != 0) {
1801 BOOL retry = FALSE;
26eb2c0c 1802
12e364b9
KC		 1803 parser_ctx =
1804 parser_init_byteStream(parametersAddr, parametersBytes,
1805 isLocalAddr, &retry);
1806 if (!parser_ctx) {
1807 if (retry) {
1808 LOGWRN("throttling to copy payload");
1809 return FALSE;
1810 }
1811 LOGWRN("parsing failed");
98d7b594 1812 LOGWRN("inmsg.hdr.Id=0x%lx", (ulong) inmsg.hdr.id);
12e364b9
KC		 1813 LOGWRN("parametersAddr=0x%llx", (u64) parametersAddr);
1814 LOGWRN("parametersBytes=%lu", (ulong) parametersBytes);
1815 LOGWRN("isLocalAddr=%d", isLocalAddr);
1816 }
1817 }
1818
1819 if (!isLocalAddr) {
1820 controlvm_init_response(&ackmsg, &inmsg.hdr,
1821 CONTROLVM_RESP_SUCCESS);
1822 if ((ControlVm_channel)
1823 &&
1824 (!visorchannel_signalinsert
1825 (ControlVm_channel, CONTROLVM_QUEUE_ACK, &ackmsg)))
1826 LOGWRN("failed to send ACK failed");
1827 }
98d7b594 1828 switch (inmsg.hdr.id) {
12e364b9
KC		 1829 case CONTROLVM_CHIPSET_INIT:
1830 LOGINF("CHIPSET_INIT(#busses=%lu,#switches=%lu)",
2ea5117b
BR		 1831 (ulong) inmsg.cmd.init_chipset.bus_count,
1832 (ulong) inmsg.cmd.init_chipset.switch_count);
12e364b9
KC		 1833 chipset_init(&inmsg);
1834 break;
1835 case CONTROLVM_BUS_CREATE:
1836 LOGINF("BUS_CREATE(%lu,#devs=%lu)",
2ea5117b
BR		 1837 (ulong) cmd->create_bus.bus_no,
1838 (ulong) cmd->create_bus.dev_count);
12e364b9
KC		 1839 bus_create(&inmsg);
1840 break;
1841 case CONTROLVM_BUS_DESTROY:
2ea5117b 1842 LOGINF("BUS_DESTROY(%lu)", (ulong) cmd->destroy_bus.bus_no);
12e364b9
KC		 1843 bus_destroy(&inmsg);
1844 break;
1845 case CONTROLVM_BUS_CONFIGURE:
2ea5117b 1846 LOGINF("BUS_CONFIGURE(%lu)", (ulong) cmd->configure_bus.bus_no);
12e364b9
KC		 1847 bus_configure(&inmsg, parser_ctx);
1848 break;
1849 case CONTROLVM_DEVICE_CREATE:
1850 LOGINF("DEVICE_CREATE(%lu,%lu)",
f91b9262
BR		 1851 (ulong) cmd->create_device.bus_no,
1852 (ulong) cmd->create_device.dev_no);
12e364b9
KC		 1853 my_device_create(&inmsg);
1854 break;
1855 case CONTROLVM_DEVICE_CHANGESTATE:
2ea5117b 1856 if (cmd->device_change_state.flags.phys_device) {
12e364b9 1857 LOGINF("DEVICE_CHANGESTATE for physical device (%lu,%lu, active=%lu)",
2ea5117b
BR		 1858 (ulong) cmd->device_change_state.bus_no,
1859 (ulong) cmd->device_change_state.dev_no,
1860 (ulong) cmd->device_change_state.state.active);
12e364b9
KC		 1861 parahotplug_process_message(&inmsg);
1862 } else {
1863 LOGINF("DEVICE_CHANGESTATE for virtual device (%lu,%lu, state.Alive=0x%lx)",
2ea5117b
BR		 1864 (ulong) cmd->device_change_state.bus_no,
1865 (ulong) cmd->device_change_state.dev_no,
1866 (ulong) cmd->device_change_state.state.alive);
12e364b9
KC		 1867 /* save the hdr and cmd structures for later use */
1868 /* when sending back the response to Command */
1869 my_device_changestate(&inmsg);
1870 g_DiagMsgHdr = inmsg.hdr;
1871 g_DeviceChangeStatePacket = inmsg.cmd;
1872 break;
1873 }
1874 break;
1875 case CONTROLVM_DEVICE_DESTROY:
1876 LOGINF("DEVICE_DESTROY(%lu,%lu)",
2ea5117b
BR		 1877 (ulong) cmd->destroy_device.bus_no,
1878 (ulong) cmd->destroy_device.dev_no);
12e364b9
KC		 1879 my_device_destroy(&inmsg);
1880 break;
1881 case CONTROLVM_DEVICE_CONFIGURE:
1882 LOGINF("DEVICE_CONFIGURE(%lu,%lu)",
e6ad00bb
BR		 1883 (ulong) cmd->configure_device.bus_no,
1884 (ulong) cmd->configure_device.dev_no);
12e364b9 1885 /* no op for now, just send a respond that we passed */
98d7b594 1886 if (inmsg.hdr.flags.response_expected)
12e364b9
KC		 1887 controlvm_respond(&inmsg.hdr, CONTROLVM_RESP_SUCCESS);
1888 break;
1889 case CONTROLVM_CHIPSET_READY:
1890 LOGINF("CHIPSET_READY");
1891 chipset_ready(&inmsg.hdr);
1892 break;
1893 case CONTROLVM_CHIPSET_SELFTEST:
1894 LOGINF("CHIPSET_SELFTEST");
1895 chipset_selftest(&inmsg.hdr);
1896 break;
1897 case CONTROLVM_CHIPSET_STOP:
1898 LOGINF("CHIPSET_STOP");
1899 chipset_notready(&inmsg.hdr);
1900 break;
1901 default:
98d7b594
BR		 1902 LOGERR("unrecognized controlvm cmd=%d", (int) inmsg.hdr.id);
1903 if (inmsg.hdr.flags.response_expected)
12e364b9
KC		 1904 controlvm_respond(&inmsg.hdr,
1905 -CONTROLVM_RESP_ERROR_MESSAGE_ID_UNKNOWN);
1906 break;
1907 }
1908
1909 if (parser_ctx != NULL) {
1910 parser_done(parser_ctx);
1911 parser_ctx = NULL;
1912 }
1913 return TRUE;
1914}
1915
d746cb55 1916static HOSTADDRESS controlvm_get_channel_address(void)
524b0b63 1917{
5fc0229a 1918 u64 addr = 0;
b3c55b13 1919 u32 size = 0;
524b0b63 1920
74658c56 1921 if (!VMCALL_SUCCESSFUL(issue_vmcall_io_controlvm_addr(&addr, &size))) {
524b0b63
BR		 1922 ERRDRV("%s - vmcall to determine controlvm channel addr failed",
1923 __func__);
1924 return 0;
1925 }
1926 INFODRV("controlvm addr=%Lx", addr);
1927 return addr;
1928}
1929
12e364b9
KC		 1930static void
1931controlvm_periodic_work(struct work_struct *work)
1932{
3ab47701 1933 struct controlvm_message inmsg;
12e364b9
KC		 1934 BOOL gotACommand = FALSE;
1935 BOOL handle_command_failed = FALSE;
5fc0229a 1936 static u64 Poll_Count;
12e364b9
KC		 1937
1938 /* make sure visorbus server is registered for controlvm callbacks */
1939 if (visorchipset_serverregwait && !serverregistered)
097f4c19 1940 goto Away;
12e364b9
KC		 1941 /* make sure visorclientbus server is regsitered for controlvm
1942 * callbacks
1943 */
1944 if (visorchipset_clientregwait && !clientregistered)
097f4c19 1945 goto Away;
12e364b9 1946
12e364b9 1947 Poll_Count++;
8a1182eb 1948 if (Poll_Count >= 250)
12e364b9
KC		 1949 ; /* keep going */
1950 else
097f4c19 1951 goto Away;
12e364b9
KC		 1952
1953 /* Check events to determine if response to CHIPSET_READY
1954 * should be sent
1955 */
1956 if (visorchipset_holdchipsetready
98d7b594 1957 && (g_ChipSetMsgHdr.id != CONTROLVM_INVALID)) {
12e364b9
KC		 1958 if (check_chipset_events() == 1) {
1959 LOGINF("Sending CHIPSET_READY response");
1960 controlvm_respond(&g_ChipSetMsgHdr, 0);
1961 clear_chipset_events();
1962 memset(&g_ChipSetMsgHdr, 0,
98d7b594 1963 sizeof(struct controlvm_message_header));
12e364b9
KC		 1964 }
1965 }
1966
8a1182eb
BR		 1967 while (visorchannel_signalremove(ControlVm_channel,
1968 CONTROLVM_QUEUE_RESPONSE,
1969 &inmsg)) {
98d7b594 1970 if (inmsg.hdr.payload_max_bytes != 0) {
8a1182eb 1971 LOGERR("Payload of size %lu returned @%lu with unexpected message id %d.",
98d7b594
BR		 1972 (ulong) inmsg.hdr.payload_max_bytes,
1973 (ulong) inmsg.hdr.payload_vm_offset,
1974 inmsg.hdr.id);
12e364b9
KC		 1975 }
1976 }
8a1182eb
BR		 1977 if (!gotACommand) {
1978 if (ControlVm_Pending_Msg_Valid) {
1979 /* we throttled processing of a prior
1980 * msg, so try to process it again
1981 * rather than reading a new one
1982 */
1983 inmsg = ControlVm_Pending_Msg;
1984 ControlVm_Pending_Msg_Valid = FALSE;
1985 gotACommand = TRUE;
1986 } else
1987 gotACommand = read_controlvm_event(&inmsg);
1988 }
12e364b9
KC		 1989
1990 handle_command_failed = FALSE;
1991 while (gotACommand && (!handle_command_failed)) {
1992 Most_recent_message_jiffies = jiffies;
8a1182eb
BR		 1993 if (handle_command(inmsg,
1994 visorchannel_get_physaddr
1995 (ControlVm_channel)))
1996 gotACommand = read_controlvm_event(&inmsg);
1997 else {
1998 /* this is a scenario where throttling
1999 * is required, but probably NOT an
2000 * error...; we stash the current
2001 * controlvm msg so we will attempt to
2002 * reprocess it on our next loop
2003 */
2004 handle_command_failed = TRUE;
2005 ControlVm_Pending_Msg = inmsg;
2006 ControlVm_Pending_Msg_Valid = TRUE;
12e364b9
KC		 2007 }
2008 }
2009
2010 /* parahotplug_worker */
2011 parahotplug_process_list();
2012
12e364b9
KC		 2013Away:
2014
2015 if (time_after(jiffies,
2016 Most_recent_message_jiffies + (HZ * MIN_IDLE_SECONDS))) {
2017 /* it's been longer than MIN_IDLE_SECONDS since we
2018 * processed our last controlvm message; slow down the
2019 * polling
2020 */
2021 if (Poll_jiffies != POLLJIFFIES_CONTROLVMCHANNEL_SLOW) {
2022 LOGINF("switched to slow controlvm polling");
2023 Poll_jiffies = POLLJIFFIES_CONTROLVMCHANNEL_SLOW;
2024 }
2025 } else {
2026 if (Poll_jiffies != POLLJIFFIES_CONTROLVMCHANNEL_FAST) {
2027 Poll_jiffies = POLLJIFFIES_CONTROLVMCHANNEL_FAST;
2028 LOGINF("switched to fast controlvm polling");
2029 }
2030 }
2031
4b4b535e
DY		 2032 queue_delayed_work(Periodic_controlvm_workqueue,
2033 &Periodic_controlvm_work, Poll_jiffies);
12e364b9
KC		 2034}
2035
2036static void
2037setup_crash_devices_work_queue(struct work_struct *work)
2038{
2039
3ab47701
BR		 2040 struct controlvm_message localCrashCreateBusMsg;
2041 struct controlvm_message localCrashCreateDevMsg;
2042 struct controlvm_message msg;
b3c55b13 2043 u32 localSavedCrashMsgOffset;
b06bdf7d 2044 u16 localSavedCrashMsgCount;
12e364b9
KC		 2045
2046 /* make sure visorbus server is registered for controlvm callbacks */
2047 if (visorchipset_serverregwait && !serverregistered)
097f4c19 2048 goto Away;
12e364b9
KC		 2049
2050 /* make sure visorclientbus server is regsitered for controlvm
2051 * callbacks
2052 */
2053 if (visorchipset_clientregwait && !clientregistered)
097f4c19 2054 goto Away;
12e364b9
KC		 2055
2056 POSTCODE_LINUX_2(CRASH_DEV_ENTRY_PC, POSTCODE_SEVERITY_INFO);
2057
2058 /* send init chipset msg */
98d7b594 2059 msg.hdr.id = CONTROLVM_CHIPSET_INIT;
2ea5117b
BR		 2060 msg.cmd.init_chipset.bus_count = 23;
2061 msg.cmd.init_chipset.switch_count = 0;
12e364b9
KC		 2062
2063 chipset_init(&msg);
2064
12e364b9
KC		 2065 /* get saved message count */
2066 if (visorchannel_read(ControlVm_channel,
d19642f6
BR		 2067 offsetof(struct spar_controlvm_channel_protocol,
2068 saved_crash_message_count),
b06bdf7d 2069 &localSavedCrashMsgCount, sizeof(u16)) < 0) {
12e364b9
KC		 2070 LOGERR("failed to get Saved Message Count");
2071 POSTCODE_LINUX_2(CRASH_DEV_CTRL_RD_FAILURE_PC,
2072 POSTCODE_SEVERITY_ERR);
2073 return;
2074 }
2075
2076 if (localSavedCrashMsgCount != CONTROLVM_CRASHMSG_MAX) {
2077 LOGERR("Saved Message Count incorrect %d",
2078 localSavedCrashMsgCount);
2079 POSTCODE_LINUX_3(CRASH_DEV_COUNT_FAILURE_PC,
2080 localSavedCrashMsgCount,
2081 POSTCODE_SEVERITY_ERR);
2082 return;
2083 }
2084
2085 /* get saved crash message offset */
2086 if (visorchannel_read(ControlVm_channel,
d19642f6
BR		 2087 offsetof(struct spar_controlvm_channel_protocol,
2088 saved_crash_message_offset),
b3c55b13 2089 &localSavedCrashMsgOffset, sizeof(u32)) < 0) {
12e364b9
KC		 2090 LOGERR("failed to get Saved Message Offset");
2091 POSTCODE_LINUX_2(CRASH_DEV_CTRL_RD_FAILURE_PC,
2092 POSTCODE_SEVERITY_ERR);
2093 return;
2094 }
2095
2096 /* read create device message for storage bus offset */
2097 if (visorchannel_read(ControlVm_channel,
2098 localSavedCrashMsgOffset,
2099 &localCrashCreateBusMsg,
3ab47701 2100 sizeof(struct controlvm_message)) < 0) {
12e364b9
KC		 2101 LOGERR("CRASH_DEV_RD_BUS_FAIULRE: Failed to read CrashCreateBusMsg!");
2102 POSTCODE_LINUX_2(CRASH_DEV_RD_BUS_FAIULRE_PC,
2103 POSTCODE_SEVERITY_ERR);
2104 return;
2105 }
2106
2107 /* read create device message for storage device */
2108 if (visorchannel_read(ControlVm_channel,
2109 localSavedCrashMsgOffset +
3ab47701 2110 sizeof(struct controlvm_message),
12e364b9 2111 &localCrashCreateDevMsg,
3ab47701 2112 sizeof(struct controlvm_message)) < 0) {
12e364b9
KC		 2113 LOGERR("CRASH_DEV_RD_DEV_FAIULRE: Failed to read CrashCreateDevMsg!");
2114 POSTCODE_LINUX_2(CRASH_DEV_RD_DEV_FAIULRE_PC,
2115 POSTCODE_SEVERITY_ERR);
2116 return;
2117 }
2118
2119 /* reuse IOVM create bus message */
2ea5117b 2120 if (localCrashCreateBusMsg.cmd.create_bus.channel_addr != 0)
12e364b9
KC		 2121 bus_create(&localCrashCreateBusMsg);
2122 else {
2123 LOGERR("CrashCreateBusMsg is null, no dump will be taken");
2124 POSTCODE_LINUX_2(CRASH_DEV_BUS_NULL_FAILURE_PC,
2125 POSTCODE_SEVERITY_ERR);
2126 return;
2127 }
2128
2129 /* reuse create device message for storage device */
f91b9262 2130 if (localCrashCreateDevMsg.cmd.create_device.channel_addr != 0)
12e364b9
KC		 2131 my_device_create(&localCrashCreateDevMsg);
2132 else {
2133 LOGERR("CrashCreateDevMsg is null, no dump will be taken");
2134 POSTCODE_LINUX_2(CRASH_DEV_DEV_NULL_FAILURE_PC,
2135 POSTCODE_SEVERITY_ERR);
2136 return;
2137 }
2138 LOGINF("Bus and device ready for dumping");
2139 POSTCODE_LINUX_2(CRASH_DEV_EXIT_PC, POSTCODE_SEVERITY_INFO);
2140 return;
2141
2142Away:
2143
2144 Poll_jiffies = POLLJIFFIES_CONTROLVMCHANNEL_SLOW;
2145
4b4b535e
DY		 2146 queue_delayed_work(Periodic_controlvm_workqueue,
2147 &Periodic_controlvm_work, Poll_jiffies);
12e364b9
KC		 2148}
2149
2150static void
2151bus_create_response(ulong busNo, int response)
2152{
2153 bus_responder(CONTROLVM_BUS_CREATE, busNo, response);
2154}
2155
2156static void
2157bus_destroy_response(ulong busNo, int response)
2158{
2159 bus_responder(CONTROLVM_BUS_DESTROY, busNo, response);
2160}
2161
2162static void
2163device_create_response(ulong busNo, ulong devNo, int response)
2164{
2165 device_responder(CONTROLVM_DEVICE_CREATE, busNo, devNo, response);
2166}
2167
2168static void
2169device_destroy_response(ulong busNo, ulong devNo, int response)
2170{
2171 device_responder(CONTROLVM_DEVICE_DESTROY, busNo, devNo, response);
2172}
2173
2174void
8420f417 2175visorchipset_device_pause_response(ulong bus_no, ulong dev_no, int response)
12e364b9
KC		 2176{
2177
2178 device_changestate_responder(CONTROLVM_DEVICE_CHANGESTATE,
8420f417 2179 bus_no, dev_no, response,
bd0d2dcc 2180 segment_state_standby);
12e364b9 2181}
927c7927 2182EXPORT_SYMBOL_GPL(visorchipset_device_pause_response);
12e364b9
KC		 2183
2184static void
2185device_resume_response(ulong busNo, ulong devNo, int response)
2186{
2187 device_changestate_responder(CONTROLVM_DEVICE_CHANGESTATE,
2188 busNo, devNo, response,
bd0d2dcc 2189 segment_state_running);
12e364b9
KC		 2190}
2191
2192BOOL
77db7127 2193visorchipset_get_bus_info(ulong bus_no, struct visorchipset_bus_info *bus_info)
12e364b9 2194{
77db7127 2195 void *p = findbus(&BusInfoList, bus_no);
26eb2c0c 2196
12e364b9 2197 if (!p) {
77db7127 2198 LOGERR("(%lu) failed", bus_no);
12e364b9
KC		 2199 return FALSE;
2200 }
77db7127 2201 memcpy(bus_info, p, sizeof(struct visorchipset_bus_info));
12e364b9
KC		 2202 return TRUE;
2203}
2204EXPORT_SYMBOL_GPL(visorchipset_get_bus_info);
2205
2206BOOL
58dd8f2d 2207visorchipset_set_bus_context(ulong bus_no, void *context)
12e364b9 2208{
58dd8f2d 2209 struct visorchipset_bus_info *p = findbus(&BusInfoList, bus_no);
26eb2c0c 2210
12e364b9 2211 if (!p) {
58dd8f2d 2212 LOGERR("(%lu) failed", bus_no);
12e364b9
KC		 2213 return FALSE;
2214 }
2215 p->bus_driver_context = context;
2216 return TRUE;
2217}
2218EXPORT_SYMBOL_GPL(visorchipset_set_bus_context);
2219
2220BOOL
b486df19
BR		 2221visorchipset_get_device_info(ulong bus_no, ulong dev_no,
2222 struct visorchipset_device_info *dev_info)
12e364b9 2223{
b486df19 2224 void *p = finddevice(&DevInfoList, bus_no, dev_no);
26eb2c0c 2225
12e364b9 2226 if (!p) {
b486df19 2227 LOGERR("(%lu,%lu) failed", bus_no, dev_no);
12e364b9
KC		 2228 return FALSE;
2229 }
b486df19 2230 memcpy(dev_info, p, sizeof(struct visorchipset_device_info));
12e364b9
KC		 2231 return TRUE;
2232}
2233EXPORT_SYMBOL_GPL(visorchipset_get_device_info);
2234
2235BOOL
cf0bd0b5 2236visorchipset_set_device_context(ulong bus_no, ulong dev_no, void *context)
12e364b9 2237{
246e0cd0 2238 struct visorchipset_device_info *p =
cf0bd0b5 2239 finddevice(&DevInfoList, bus_no, dev_no);
26eb2c0c 2240
12e364b9 2241 if (!p) {
cf0bd0b5 2242 LOGERR("(%lu,%lu) failed", bus_no, dev_no);
12e364b9
KC		 2243 return FALSE;
2244 }
2245 p->bus_driver_context = context;
2246 return TRUE;
2247}
2248EXPORT_SYMBOL_GPL(visorchipset_set_device_context);
2249
2250/* Generic wrapper function for allocating memory from a kmem_cache pool.
2251 */
2252void *
2253visorchipset_cache_alloc(struct kmem_cache *pool, BOOL ok_to_block,
2254 char *fn, int ln)
2255{
2256 gfp_t gfp;
2257 void *p;
2258
2259 if (ok_to_block)
2260 gfp = GFP_KERNEL;
2261 else
2262 gfp = GFP_ATOMIC;
2263 /* __GFP_NORETRY means "ok to fail", meaning
2264 * kmem_cache_alloc() can return NULL, implying the caller CAN
2265 * cope with failure. If you do NOT specify __GFP_NORETRY,
2266 * Linux will go to extreme measures to get memory for you
2267 * (like, invoke oom killer), which will probably cripple the
2268 * system.
2269 */
2270 gfp |= __GFP_NORETRY;
2271 p = kmem_cache_alloc(pool, gfp);
2272 if (!p) {
2273 LOGERR("kmem_cache_alloc failed early @%s:%d\n", fn, ln);
2274 return NULL;
2275 }
2276 atomic_inc(&Visorchipset_cache_buffers_in_use);
2277 return p;
2278}
2279
2280/* Generic wrapper function for freeing memory from a kmem_cache pool.
2281 */
2282void
2283visorchipset_cache_free(struct kmem_cache *pool, void *p, char *fn, int ln)
2284{
2285 if (!p) {
2286 LOGERR("NULL pointer @%s:%d\n", fn, ln);
2287 return;
2288 }
2289 atomic_dec(&Visorchipset_cache_buffers_in_use);
2290 kmem_cache_free(pool, p);
2291}
2292
18b87ed1
BR		 2293static ssize_t chipsetready_store(struct device *dev,
2294 struct device_attribute *attr, const char *buf, size_t count)
12e364b9 2295{
18b87ed1 2296 char msgtype[64];
12e364b9 2297
66e24b76
BR		 2298 if (sscanf(buf, "%63s", msgtype) != 1)
2299 return -EINVAL;
2300
2301 if (strcmp(msgtype, "CALLHOMEDISK_MOUNTED") == 0) {
2302 chipset_events[0] = 1;
2303 return count;
2304 } else if (strcmp(msgtype, "MODULES_LOADED") == 0) {
2305 chipset_events[1] = 1;
2306 return count;
e22a4a0f
BR		 2307 }
2308 return -EINVAL;
12e364b9
KC		 2309}
2310
e56fa7cd
BR		 2311/* The parahotplug/devicedisabled interface gets called by our support script
2312 * when an SR-IOV device has been shut down. The ID is passed to the script
2313 * and then passed back when the device has been removed.
2314 */
2315static ssize_t devicedisabled_store(struct device *dev,
2316 struct device_attribute *attr, const char *buf, size_t count)
2317{
2318 uint id;
2319
2320 if (kstrtouint(buf, 10, &id) != 0)
2321 return -EINVAL;
2322
2323 parahotplug_request_complete(id, 0);
2324 return count;
2325}
2326
2327/* The parahotplug/deviceenabled interface gets called by our support script
2328 * when an SR-IOV device has been recovered. The ID is passed to the script
2329 * and then passed back when the device has been brought back up.
2330 */
2331static ssize_t deviceenabled_store(struct device *dev,
2332 struct device_attribute *attr, const char *buf, size_t count)
2333{
2334 uint id;
2335
2336 if (kstrtouint(buf, 10, &id) != 0)
2337 return -EINVAL;
2338
2339 parahotplug_request_complete(id, 1);
2340 return count;
2341}
2342
12e364b9
KC		 2343static int __init
2344visorchipset_init(void)
2345{
2346 int rc = 0, x = 0;
8a1182eb 2347 char s[64];
8a1182eb 2348 HOSTADDRESS addr;
12e364b9 2349
fcd0157e
KC		 2350 if (!unisys_spar_platform)
2351 return -ENODEV;
2352
12e364b9
KC		 2353 LOGINF("chipset driver version %s loaded", VERSION);
2354 /* process module options */
2355 POSTCODE_LINUX_2(DRIVER_ENTRY_PC, POSTCODE_SEVERITY_INFO);
2356
2357 LOGINF("option - testvnic=%d", visorchipset_testvnic);
2358 LOGINF("option - testvnicclient=%d", visorchipset_testvnicclient);
2359 LOGINF("option - testmsg=%d", visorchipset_testmsg);
2360 LOGINF("option - testteardown=%d", visorchipset_testteardown);
2361 LOGINF("option - major=%d", visorchipset_major);
2362 LOGINF("option - serverregwait=%d", visorchipset_serverregwait);
2363 LOGINF("option - clientregwait=%d", visorchipset_clientregwait);
2364 LOGINF("option - holdchipsetready=%d", visorchipset_holdchipsetready);
2365
2366 memset(&BusDev_Server_Notifiers, 0, sizeof(BusDev_Server_Notifiers));
2367 memset(&BusDev_Client_Notifiers, 0, sizeof(BusDev_Client_Notifiers));
2368 memset(&ControlVm_payload_info, 0, sizeof(ControlVm_payload_info));
2369 memset(&LiveDump_info, 0, sizeof(LiveDump_info));
2370 atomic_set(&LiveDump_info.buffers_in_use, 0);
2371
9f8d0e8b
KC		 2372 if (visorchipset_testvnic) {
2373 ERRDRV("testvnic option no longer supported: (status = %d)\n",
2374 x);
2375 POSTCODE_LINUX_3(CHIPSET_INIT_FAILURE_PC, x, DIAG_SEVERITY_ERR);
2376 rc = x;
2377 goto Away;
2378 }
12e364b9 2379
8a1182eb
BR		 2380 addr = controlvm_get_channel_address();
2381 if (addr != 0) {
2382 ControlVm_channel =
2383 visorchannel_create_with_lock
2384 (addr,
d19642f6 2385 sizeof(struct spar_controlvm_channel_protocol),
5fbaa4b3 2386 spar_controlvm_channel_protocol_uuid);
93a84565
BR		 2387 if (SPAR_CONTROLVM_CHANNEL_OK_CLIENT(
2388 visorchannel_get_header(ControlVm_channel))) {
8a1182eb
BR		 2389 LOGINF("Channel %s (ControlVm) discovered",
2390 visorchannel_id(ControlVm_channel, s));
2391 initialize_controlvm_payload();
2392 } else {
2393 LOGERR("controlvm channel is invalid");
2394 visorchannel_destroy(ControlVm_channel);
2395 ControlVm_channel = NULL;
2396 return -ENODEV;
2397 }
2398 } else {
2399 LOGERR("no controlvm channel discovered");
2400 return -ENODEV;
2401 }
2402
12e364b9 2403 MajorDev = MKDEV(visorchipset_major, 0);
9f8d0e8b 2404 rc = visorchipset_file_init(MajorDev, &ControlVm_channel);
4cb005a9
KC		 2405 if (rc < 0) {
2406 ERRDRV("visorchipset_file_init(MajorDev, &ControlVm_channel): error (status=%d)\n", rc);
2407 POSTCODE_LINUX_2(CHIPSET_INIT_FAILURE_PC, DIAG_SEVERITY_ERR);
2408 goto Away;
2409 }
9f8d0e8b 2410
98d7b594 2411 memset(&g_DiagMsgHdr, 0, sizeof(struct controlvm_message_header));
12e364b9 2412
98d7b594 2413 memset(&g_ChipSetMsgHdr, 0, sizeof(struct controlvm_message_header));
12e364b9 2414
98d7b594 2415 memset(&g_DelDumpMsgHdr, 0, sizeof(struct controlvm_message_header));
12e364b9 2416
12e364b9
KC		 2417 Putfile_buffer_list_pool =
2418 kmem_cache_create(Putfile_buffer_list_pool_name,
2419 sizeof(struct putfile_buffer_entry),
2420 0, SLAB_HWCACHE_ALIGN, NULL);
2421 if (!Putfile_buffer_list_pool) {
4cb005a9
KC		 2422 ERRDRV("failed to alloc Putfile_buffer_list_pool: (status=-1)\n");
2423 POSTCODE_LINUX_2(CHIPSET_INIT_FAILURE_PC, DIAG_SEVERITY_ERR);
2424 rc = -1;
2425 goto Away;
12e364b9
KC		 2426 }
2427 if (visorchipset_disable_controlvm) {
2428 LOGINF("visorchipset_init:controlvm disabled");
2429 } else {
2430 /* if booting in a crash kernel */
2431 if (visorchipset_crash_kernel)
2432 INIT_DELAYED_WORK(&Periodic_controlvm_work,
2433 setup_crash_devices_work_queue);
2434 else
2435 INIT_DELAYED_WORK(&Periodic_controlvm_work,
2436 controlvm_periodic_work);
2437 Periodic_controlvm_workqueue =
2438 create_singlethread_workqueue("visorchipset_controlvm");
2439
4cb005a9
KC		 2440 if (Periodic_controlvm_workqueue == NULL) {
2441 ERRDRV("cannot create controlvm workqueue: (status=%d)\n",
2442 -ENOMEM);
2443 POSTCODE_LINUX_2(CREATE_WORKQUEUE_FAILED_PC,
2444 DIAG_SEVERITY_ERR);
2445 rc = -ENOMEM;
2446 goto Away;
2447 }
12e364b9
KC		 2448 Most_recent_message_jiffies = jiffies;
2449 Poll_jiffies = POLLJIFFIES_CONTROLVMCHANNEL_FAST;
9f8d0e8b
KC		 2450 rc = queue_delayed_work(Periodic_controlvm_workqueue,
2451 &Periodic_controlvm_work, Poll_jiffies);
4cb005a9
KC		 2452 if (rc < 0) {
2453 ERRDRV("queue_delayed_work(Periodic_controlvm_workqueue, &Periodic_controlvm_work, Poll_jiffies): error (status=%d)\n", rc);
2454 POSTCODE_LINUX_2(QUEUE_DELAYED_WORK_PC,
2455 DIAG_SEVERITY_ERR);
2456 goto Away;
2457 }
9f8d0e8b 2458
12e364b9
KC		 2459 }
2460
2461 Visorchipset_platform_device.dev.devt = MajorDev;
4cb005a9
KC		 2462 if (platform_device_register(&Visorchipset_platform_device) < 0) {
2463 ERRDRV("platform_device_register(visorchipset) failed: (status=-1)\n");
2464 POSTCODE_LINUX_2(DEVICE_REGISTER_FAILURE_PC, DIAG_SEVERITY_ERR);
2465 rc = -1;
2466 goto Away;
2467 }
12e364b9
KC		 2468 LOGINF("visorchipset device created");
2469 POSTCODE_LINUX_2(CHIPSET_INIT_SUCCESS_PC, POSTCODE_SEVERITY_INFO);
22ad57ba 2470 rc = 0;
12e364b9 2471Away:
12e364b9
KC		 2472 if (rc) {
2473 LOGERR("visorchipset_init failed");
2474 POSTCODE_LINUX_3(CHIPSET_INIT_FAILURE_PC, rc,
2475 POSTCODE_SEVERITY_ERR);
2476 }
2477 return rc;
2478}
2479
2480static void
2481visorchipset_exit(void)
2482{
2483 char s[99];
26eb2c0c 2484
12e364b9
KC		 2485 POSTCODE_LINUX_2(DRIVER_EXIT_PC, POSTCODE_SEVERITY_INFO);
2486
2487 if (visorchipset_disable_controlvm) {
2488 ;
2489 } else {
2490 cancel_delayed_work(&Periodic_controlvm_work);
2491 flush_workqueue(Periodic_controlvm_workqueue);
2492 destroy_workqueue(Periodic_controlvm_workqueue);
2493 Periodic_controlvm_workqueue = NULL;
2494 destroy_controlvm_payload_info(&ControlVm_payload_info);
2495 }
2496 Test_Vnic_channel = NULL;
2497 if (Putfile_buffer_list_pool) {
2498 kmem_cache_destroy(Putfile_buffer_list_pool);
2499 Putfile_buffer_list_pool = NULL;
2500 }
1783319f 2501
12e364b9
KC		 2502 cleanup_controlvm_structures();
2503
98d7b594 2504 memset(&g_DiagMsgHdr, 0, sizeof(struct controlvm_message_header));
12e364b9 2505
98d7b594 2506 memset(&g_ChipSetMsgHdr, 0, sizeof(struct controlvm_message_header));
12e364b9 2507
98d7b594 2508 memset(&g_DelDumpMsgHdr, 0, sizeof(struct controlvm_message_header));
12e364b9 2509
8a1182eb
BR		 2510 LOGINF("Channel %s (ControlVm) disconnected",
2511 visorchannel_id(ControlVm_channel, s));
2512 visorchannel_destroy(ControlVm_channel);
2513
12e364b9
KC		 2514 visorchipset_file_cleanup();
2515 POSTCODE_LINUX_2(DRIVER_EXIT_PC, POSTCODE_SEVERITY_INFO);
2516 LOGINF("chipset driver unloaded");
2517}
2518
2519module_param_named(testvnic, visorchipset_testvnic, int, S_IRUGO);
2520MODULE_PARM_DESC(visorchipset_testvnic, "1 to test vnic, using dummy VNIC connected via a loopback to a physical ethernet");
2521int visorchipset_testvnic = 0;
2522
2523module_param_named(testvnicclient, visorchipset_testvnicclient, int, S_IRUGO);
2524MODULE_PARM_DESC(visorchipset_testvnicclient, "1 to test vnic, using real VNIC channel attached to a separate IOVM guest");
2525int visorchipset_testvnicclient = 0;
2526
2527module_param_named(testmsg, visorchipset_testmsg, int, S_IRUGO);
2528MODULE_PARM_DESC(visorchipset_testmsg,
2529 "1 to manufacture the chipset, bus, and switch messages");
2530int visorchipset_testmsg = 0;
2531
2532module_param_named(major, visorchipset_major, int, S_IRUGO);
2533MODULE_PARM_DESC(visorchipset_major, "major device number to use for the device node");
2534int visorchipset_major = 0;
2535
2536module_param_named(serverregwait, visorchipset_serverregwait, int, S_IRUGO);
2537MODULE_PARM_DESC(visorchipset_serverreqwait,
2538 "1 to have the module wait for the visor bus to register");
2539int visorchipset_serverregwait = 0; /* default is off */
2540module_param_named(clientregwait, visorchipset_clientregwait, int, S_IRUGO);
2541MODULE_PARM_DESC(visorchipset_clientregwait, "1 to have the module wait for the visorclientbus to register");
2542int visorchipset_clientregwait = 1; /* default is on */
2543module_param_named(testteardown, visorchipset_testteardown, int, S_IRUGO);
2544MODULE_PARM_DESC(visorchipset_testteardown,
2545 "1 to test teardown of the chipset, bus, and switch");
2546int visorchipset_testteardown = 0; /* default is off */
2547module_param_named(disable_controlvm, visorchipset_disable_controlvm, int,
2548 S_IRUGO);
2549MODULE_PARM_DESC(visorchipset_disable_controlvm,
2550 "1 to disable polling of controlVm channel");
2551int visorchipset_disable_controlvm = 0; /* default is off */
2552module_param_named(crash_kernel, visorchipset_crash_kernel, int, S_IRUGO);
2553MODULE_PARM_DESC(visorchipset_crash_kernel,
2554 "1 means we are running in crash kernel");
2555int visorchipset_crash_kernel = 0; /* default is running in non-crash kernel */
2556module_param_named(holdchipsetready, visorchipset_holdchipsetready,
2557 int, S_IRUGO);
2558MODULE_PARM_DESC(visorchipset_holdchipsetready,
2559 "1 to hold response to CHIPSET_READY");
2560int visorchipset_holdchipsetready = 0; /* default is to send CHIPSET_READY
2561 * response immediately */
2562module_init(visorchipset_init);
2563module_exit(visorchipset_exit);
2564
2565MODULE_AUTHOR("Unisys");
2566MODULE_LICENSE("GPL");
2567MODULE_DESCRIPTION("Supervisor chipset driver for service partition: ver "
2568 VERSION);
2569MODULE_VERSION(VERSION);
Linux kernel - Deliverables
This page took 0.474533 seconds and 5 git commands to generate.