?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: serial generic resume function fix
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / misc / sgi-xp / xpc_uv.c
blob29c0502a96b26fd9e9436d65f133136ccfce5410
1 /*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Copyright (c) 2008-2009 Silicon Graphics, Inc. All Rights Reserved.
7 */
8
9 /*
10 * Cross Partition Communication (XPC) uv-based functions.
11 *
12 * Architecture specific implementation of common functions.
13 *
14 */
15
16 #include <linux/kernel.h>
17 #include <linux/mm.h>
18 #include <linux/interrupt.h>
19 #include <linux/delay.h>
20 #include <linux/device.h>
21 #include <linux/err.h>
22 #include <asm/uv/uv_hub.h>
23 #if defined CONFIG_X86_64
24 #include <asm/uv/bios.h>
25 #include <asm/uv/uv_irq.h>
26 #elif defined CONFIG_IA64_GENERIC || defined CONFIG_IA64_SGI_UV
27 #include <asm/sn/intr.h>
28 #include <asm/sn/sn_sal.h>
29 #endif
30 #include "../sgi-gru/gru.h"
31 #include "../sgi-gru/grukservices.h"
32 #include "xpc.h"
33
34 static atomic64_t xpc_heartbeat_uv;
35 static DECLARE_BITMAP(xpc_heartbeating_to_mask_uv, XP_MAX_NPARTITIONS_UV);
36
37 #define XPC_ACTIVATE_MSG_SIZE_UV (1 * GRU_CACHE_LINE_BYTES)
38 #define XPC_ACTIVATE_MQ_SIZE_UV (4 * XP_MAX_NPARTITIONS_UV * \
39 XPC_ACTIVATE_MSG_SIZE_UV)
40 #define XPC_ACTIVATE_IRQ_NAME "xpc_activate"
41
42 #define XPC_NOTIFY_MSG_SIZE_UV (2 * GRU_CACHE_LINE_BYTES)
43 #define XPC_NOTIFY_MQ_SIZE_UV (4 * XP_MAX_NPARTITIONS_UV * \
44 XPC_NOTIFY_MSG_SIZE_UV)
45 #define XPC_NOTIFY_IRQ_NAME "xpc_notify"
46
47 static struct xpc_gru_mq_uv *xpc_activate_mq_uv;
48 static struct xpc_gru_mq_uv *xpc_notify_mq_uv;
49
50 static int
51 xpc_setup_partitions_sn_uv(void)
52 {
53 short partid;
54 struct xpc_partition_uv *part_uv;
55
56 for (partid = 0; partid < XP_MAX_NPARTITIONS_UV; partid++) {
57 part_uv = &xpc_partitions[partid].sn.uv;
58
59 spin_lock_init(&part_uv->flags_lock);
60 part_uv->remote_act_state = XPC_P_AS_INACTIVE;
61 }
62 return 0;
63 }
64
65 static int
66 xpc_get_gru_mq_irq_uv(struct xpc_gru_mq_uv *mq, int cpu, char *irq_name)
67 {
68 #if defined CONFIG_X86_64
69 mq->irq = uv_setup_irq(irq_name, cpu, mq->mmr_blade, mq->mmr_offset);
70 if (mq->irq < 0) {
71 dev_err(xpc_part, "uv_setup_irq() returned error=%d\n",
72 mq->irq);
73 }
74
75 #elif defined CONFIG_IA64_GENERIC || defined CONFIG_IA64_SGI_UV
76 int mmr_pnode;
77 unsigned long mmr_value;
78
79 if (strcmp(irq_name, XPC_ACTIVATE_IRQ_NAME) == 0)
80 mq->irq = SGI_XPC_ACTIVATE;
81 else if (strcmp(irq_name, XPC_NOTIFY_IRQ_NAME) == 0)
82 mq->irq = SGI_XPC_NOTIFY;
83 else
84 return -EINVAL;
85
86 mmr_pnode = uv_blade_to_pnode(mq->mmr_blade);
87 mmr_value = (unsigned long)cpu_physical_id(cpu) << 32 | mq->irq;
88
89 uv_write_global_mmr64(mmr_pnode, mq->mmr_offset, mmr_value);
90 #else
91 #error not a supported configuration
92 #endif
93
94 return 0;
95 }
96
97 static void
98 xpc_release_gru_mq_irq_uv(struct xpc_gru_mq_uv *mq)
99 {
100 #if defined CONFIG_X86_64
101 uv_teardown_irq(mq->irq, mq->mmr_blade, mq->mmr_offset);
102
103 #elif defined CONFIG_IA64_GENERIC || defined CONFIG_IA64_SGI_UV
104 int mmr_pnode;
105 unsigned long mmr_value;
106
107 mmr_pnode = uv_blade_to_pnode(mq->mmr_blade);
108 mmr_value = 1UL << 16;
109
110 uv_write_global_mmr64(mmr_pnode, mq->mmr_offset, mmr_value);
111 #else
112 #error not a supported configuration
113 #endif
114 }
115
116 static int
117 xpc_gru_mq_watchlist_alloc_uv(struct xpc_gru_mq_uv *mq)
118 {
119 int ret;
120
121 #if defined CONFIG_X86_64
122 ret = uv_bios_mq_watchlist_alloc(mq->mmr_blade, uv_gpa(mq->address),
123 mq->order, &mq->mmr_offset);
124 if (ret < 0) {
125 dev_err(xpc_part, "uv_bios_mq_watchlist_alloc() failed, "
126 "ret=%d\n", ret);
127 return ret;
128 }
129 #elif defined CONFIG_IA64_GENERIC || defined CONFIG_IA64_SGI_UV
130 ret = sn_mq_watchlist_alloc(mq->mmr_blade, uv_gpa(mq->address),
131 mq->order, &mq->mmr_offset);
132 if (ret < 0) {
133 dev_err(xpc_part, "sn_mq_watchlist_alloc() failed, ret=%d\n",
134 ret);
135 return -EBUSY;
136 }
137 #else
138 #error not a supported configuration
139 #endif
140
141 mq->watchlist_num = ret;
142 return 0;
143 }
144
145 static void
146 xpc_gru_mq_watchlist_free_uv(struct xpc_gru_mq_uv *mq)
147 {
148 int ret;
149
150 #if defined CONFIG_X86_64
151 ret = uv_bios_mq_watchlist_free(mq->mmr_blade, mq->watchlist_num);
152 BUG_ON(ret != BIOS_STATUS_SUCCESS);
153 #elif defined CONFIG_IA64_GENERIC || defined CONFIG_IA64_SGI_UV
154 ret = sn_mq_watchlist_free(mq->mmr_blade, mq->watchlist_num);
155 BUG_ON(ret != SALRET_OK);
156 #else
157 #error not a supported configuration
158 #endif
159 }
160
161 static struct xpc_gru_mq_uv *
162 xpc_create_gru_mq_uv(unsigned int mq_size, int cpu, char *irq_name,
163 irq_handler_t irq_handler)
164 {
165 enum xp_retval xp_ret;
166 int ret;
167 int nid;
168 int pg_order;
169 struct page *page;
170 struct xpc_gru_mq_uv *mq;
171
172 mq = kmalloc(sizeof(struct xpc_gru_mq_uv), GFP_KERNEL);
173 if (mq == NULL) {
174 dev_err(xpc_part, "xpc_create_gru_mq_uv() failed to kmalloc() "
175 "a xpc_gru_mq_uv structure\n");
176 ret = -ENOMEM;
177 goto out_1;
178 }
179
180 pg_order = get_order(mq_size);
181 mq->order = pg_order + PAGE_SHIFT;
182 mq_size = 1UL << mq->order;
183
184 mq->mmr_blade = uv_cpu_to_blade_id(cpu);
185
186 nid = cpu_to_node(cpu);
187 page = alloc_pages_node(nid, GFP_KERNEL | __GFP_ZERO | GFP_THISNODE,
188 pg_order);
189 if (page == NULL) {
190 dev_err(xpc_part, "xpc_create_gru_mq_uv() failed to alloc %d "
191 "bytes of memory on nid=%d for GRU mq\n", mq_size, nid);
192 ret = -ENOMEM;
193 goto out_2;
194 }
195 mq->address = page_address(page);
196
197 ret = gru_create_message_queue(mq->address, mq_size);
198 if (ret != 0) {
199 dev_err(xpc_part, "gru_create_message_queue() returned "
200 "error=%d\n", ret);
201 ret = -EINVAL;
202 goto out_3;
203 }
204
205 /* enable generation of irq when GRU mq operation occurs to this mq */
206 ret = xpc_gru_mq_watchlist_alloc_uv(mq);
207 if (ret != 0)
208 goto out_3;
209
210 ret = xpc_get_gru_mq_irq_uv(mq, cpu, irq_name);
211 if (ret != 0)
212 goto out_4;
213
214 ret = request_irq(mq->irq, irq_handler, 0, irq_name, NULL);
215 if (ret != 0) {
216 dev_err(xpc_part, "request_irq(irq=%d) returned error=%d\n",
217 mq->irq, ret);
218 goto out_5;
219 }
220
221 /* allow other partitions to access this GRU mq */
222 xp_ret = xp_expand_memprotect(xp_pa(mq->address), mq_size);
223 if (xp_ret != xpSuccess) {
224 ret = -EACCES;
225 goto out_6;
226 }
227
228 return mq;
229
230 /* something went wrong */
231 out_6:
232 free_irq(mq->irq, NULL);
233 out_5:
234 xpc_release_gru_mq_irq_uv(mq);
235 out_4:
236 xpc_gru_mq_watchlist_free_uv(mq);
237 out_3:
238 free_pages((unsigned long)mq->address, pg_order);
239 out_2:
240 kfree(mq);
241 out_1:
242 return ERR_PTR(ret);
243 }
244
245 static void
246 xpc_destroy_gru_mq_uv(struct xpc_gru_mq_uv *mq)
247 {
248 unsigned int mq_size;
249 int pg_order;
250 int ret;
251
252 /* disallow other partitions to access GRU mq */
253 mq_size = 1UL << mq->order;
254 ret = xp_restrict_memprotect(xp_pa(mq->address), mq_size);
255 BUG_ON(ret != xpSuccess);
256
257 /* unregister irq handler and release mq irq/vector mapping */
258 free_irq(mq->irq, NULL);
259 xpc_release_gru_mq_irq_uv(mq);
260
261 /* disable generation of irq when GRU mq op occurs to this mq */
262 xpc_gru_mq_watchlist_free_uv(mq);
263
264 pg_order = mq->order - PAGE_SHIFT;
265 free_pages((unsigned long)mq->address, pg_order);
266
267 kfree(mq);
268 }
269
270 static enum xp_retval
271 xpc_send_gru_msg(unsigned long mq_gpa, void *msg, size_t msg_size)
272 {
273 enum xp_retval xp_ret;
274 int ret;
275
276 while (1) {
277 ret = gru_send_message_gpa(mq_gpa, msg, msg_size);
278 if (ret == MQE_OK) {
279 xp_ret = xpSuccess;
280 break;
281 }
282
283 if (ret == MQE_QUEUE_FULL) {
284 dev_dbg(xpc_chan, "gru_send_message_gpa() returned "
285 "error=MQE_QUEUE_FULL\n");
286 /* !!! handle QLimit reached; delay & try again */
287 /* ??? Do we add a limit to the number of retries? */
288 (void)msleep_interruptible(10);
289 } else if (ret == MQE_CONGESTION) {
290 dev_dbg(xpc_chan, "gru_send_message_gpa() returned "
291 "error=MQE_CONGESTION\n");
292 /* !!! handle LB Overflow; simply try again */
293 /* ??? Do we add a limit to the number of retries? */
294 } else {
295 /* !!! Currently this is MQE_UNEXPECTED_CB_ERR */
296 dev_err(xpc_chan, "gru_send_message_gpa() returned "
297 "error=%d\n", ret);
298 xp_ret = xpGruSendMqError;
299 break;
300 }
301 }
302 return xp_ret;
303 }
304
305 static void
306 xpc_process_activate_IRQ_rcvd_uv(void)
307 {
308 unsigned long irq_flags;
309 short partid;
310 struct xpc_partition *part;
311 u8 act_state_req;
312
313 DBUG_ON(xpc_activate_IRQ_rcvd == 0);
314
315 spin_lock_irqsave(&xpc_activate_IRQ_rcvd_lock, irq_flags);
316 for (partid = 0; partid < XP_MAX_NPARTITIONS_UV; partid++) {
317 part = &xpc_partitions[partid];
318
319 if (part->sn.uv.act_state_req == 0)
320 continue;
321
322 xpc_activate_IRQ_rcvd--;
323 BUG_ON(xpc_activate_IRQ_rcvd < 0);
324
325 act_state_req = part->sn.uv.act_state_req;
326 part->sn.uv.act_state_req = 0;
327 spin_unlock_irqrestore(&xpc_activate_IRQ_rcvd_lock, irq_flags);
328
329 if (act_state_req == XPC_P_ASR_ACTIVATE_UV) {
330 if (part->act_state == XPC_P_AS_INACTIVE)
331 xpc_activate_partition(part);
332 else if (part->act_state == XPC_P_AS_DEACTIVATING)
333 XPC_DEACTIVATE_PARTITION(part, xpReactivating);
334
335 } else if (act_state_req == XPC_P_ASR_REACTIVATE_UV) {
336 if (part->act_state == XPC_P_AS_INACTIVE)
337 xpc_activate_partition(part);
338 else
339 XPC_DEACTIVATE_PARTITION(part, xpReactivating);
340
341 } else if (act_state_req == XPC_P_ASR_DEACTIVATE_UV) {
342 XPC_DEACTIVATE_PARTITION(part, part->sn.uv.reason);
343
344 } else {
345 BUG();
346 }
347
348 spin_lock_irqsave(&xpc_activate_IRQ_rcvd_lock, irq_flags);
349 if (xpc_activate_IRQ_rcvd == 0)
350 break;
351 }
352 spin_unlock_irqrestore(&xpc_activate_IRQ_rcvd_lock, irq_flags);
353
354 }
355
356 static void
357 xpc_handle_activate_mq_msg_uv(struct xpc_partition *part,
358 struct xpc_activate_mq_msghdr_uv *msg_hdr,
359 int *wakeup_hb_checker)
360 {
361 unsigned long irq_flags;
362 struct xpc_partition_uv *part_uv = &part->sn.uv;
363 struct xpc_openclose_args *args;
364
365 part_uv->remote_act_state = msg_hdr->act_state;
366
367 switch (msg_hdr->type) {
368 case XPC_ACTIVATE_MQ_MSG_SYNC_ACT_STATE_UV:
369 /* syncing of remote_act_state was just done above */
370 break;
371
372 case XPC_ACTIVATE_MQ_MSG_INC_HEARTBEAT_UV: {
373 struct xpc_activate_mq_msg_heartbeat_req_uv *msg;
374
375 msg = container_of(msg_hdr,
376 struct xpc_activate_mq_msg_heartbeat_req_uv,
377 hdr);
378 part_uv->heartbeat = msg->heartbeat;
379 break;
380 }
381 case XPC_ACTIVATE_MQ_MSG_OFFLINE_HEARTBEAT_UV: {
382 struct xpc_activate_mq_msg_heartbeat_req_uv *msg;
383
384 msg = container_of(msg_hdr,
385 struct xpc_activate_mq_msg_heartbeat_req_uv,
386 hdr);
387 part_uv->heartbeat = msg->heartbeat;
388
389 spin_lock_irqsave(&part_uv->flags_lock, irq_flags);
390 part_uv->flags |= XPC_P_HEARTBEAT_OFFLINE_UV;
391 spin_unlock_irqrestore(&part_uv->flags_lock, irq_flags);
392 break;
393 }
394 case XPC_ACTIVATE_MQ_MSG_ONLINE_HEARTBEAT_UV: {
395 struct xpc_activate_mq_msg_heartbeat_req_uv *msg;
396
397 msg = container_of(msg_hdr,
398 struct xpc_activate_mq_msg_heartbeat_req_uv,
399 hdr);
400 part_uv->heartbeat = msg->heartbeat;
401
402 spin_lock_irqsave(&part_uv->flags_lock, irq_flags);
403 part_uv->flags &= ~XPC_P_HEARTBEAT_OFFLINE_UV;
404 spin_unlock_irqrestore(&part_uv->flags_lock, irq_flags);
405 break;
406 }
407 case XPC_ACTIVATE_MQ_MSG_ACTIVATE_REQ_UV: {
408 struct xpc_activate_mq_msg_activate_req_uv *msg;
409
410 /*
411 * ??? Do we deal here with ts_jiffies being different
412 * ??? if act_state != XPC_P_AS_INACTIVE instead of
413 * ??? below?
414 */
415 msg = container_of(msg_hdr, struct
416 xpc_activate_mq_msg_activate_req_uv, hdr);
417
418 spin_lock_irqsave(&xpc_activate_IRQ_rcvd_lock, irq_flags);
419 if (part_uv->act_state_req == 0)
420 xpc_activate_IRQ_rcvd++;
421 part_uv->act_state_req = XPC_P_ASR_ACTIVATE_UV;
422 part->remote_rp_pa = msg->rp_gpa; /* !!! _pa is _gpa */
423 part->remote_rp_ts_jiffies = msg_hdr->rp_ts_jiffies;
424 part_uv->remote_activate_mq_gpa = msg->activate_mq_gpa;
425 spin_unlock_irqrestore(&xpc_activate_IRQ_rcvd_lock, irq_flags);
426
427 (*wakeup_hb_checker)++;
428 break;
429 }
430 case XPC_ACTIVATE_MQ_MSG_DEACTIVATE_REQ_UV: {
431 struct xpc_activate_mq_msg_deactivate_req_uv *msg;
432
433 msg = container_of(msg_hdr, struct
434 xpc_activate_mq_msg_deactivate_req_uv, hdr);
435
436 spin_lock_irqsave(&xpc_activate_IRQ_rcvd_lock, irq_flags);
437 if (part_uv->act_state_req == 0)
438 xpc_activate_IRQ_rcvd++;
439 part_uv->act_state_req = XPC_P_ASR_DEACTIVATE_UV;
440 part_uv->reason = msg->reason;
441 spin_unlock_irqrestore(&xpc_activate_IRQ_rcvd_lock, irq_flags);
442
443 (*wakeup_hb_checker)++;
444 return;
445 }
446 case XPC_ACTIVATE_MQ_MSG_CHCTL_CLOSEREQUEST_UV: {
447 struct xpc_activate_mq_msg_chctl_closerequest_uv *msg;
448
449 msg = container_of(msg_hdr, struct
450 xpc_activate_mq_msg_chctl_closerequest_uv,
451 hdr);
452 args = &part->remote_openclose_args[msg->ch_number];
453 args->reason = msg->reason;
454
455 spin_lock_irqsave(&part->chctl_lock, irq_flags);
456 part->chctl.flags[msg->ch_number] |= XPC_CHCTL_CLOSEREQUEST;
457 spin_unlock_irqrestore(&part->chctl_lock, irq_flags);
458
459 xpc_wakeup_channel_mgr(part);
460 break;
461 }
462 case XPC_ACTIVATE_MQ_MSG_CHCTL_CLOSEREPLY_UV: {
463 struct xpc_activate_mq_msg_chctl_closereply_uv *msg;
464
465 msg = container_of(msg_hdr, struct
466 xpc_activate_mq_msg_chctl_closereply_uv,
467 hdr);
468
469 spin_lock_irqsave(&part->chctl_lock, irq_flags);
470 part->chctl.flags[msg->ch_number] |= XPC_CHCTL_CLOSEREPLY;
471 spin_unlock_irqrestore(&part->chctl_lock, irq_flags);
472
473 xpc_wakeup_channel_mgr(part);
474 break;
475 }
476 case XPC_ACTIVATE_MQ_MSG_CHCTL_OPENREQUEST_UV: {
477 struct xpc_activate_mq_msg_chctl_openrequest_uv *msg;
478
479 msg = container_of(msg_hdr, struct
480 xpc_activate_mq_msg_chctl_openrequest_uv,
481 hdr);
482 args = &part->remote_openclose_args[msg->ch_number];
483 args->entry_size = msg->entry_size;
484 args->local_nentries = msg->local_nentries;
485
486 spin_lock_irqsave(&part->chctl_lock, irq_flags);
487 part->chctl.flags[msg->ch_number] |= XPC_CHCTL_OPENREQUEST;
488 spin_unlock_irqrestore(&part->chctl_lock, irq_flags);
489
490 xpc_wakeup_channel_mgr(part);
491 break;
492 }
493 case XPC_ACTIVATE_MQ_MSG_CHCTL_OPENREPLY_UV: {
494 struct xpc_activate_mq_msg_chctl_openreply_uv *msg;
495
496 msg = container_of(msg_hdr, struct
497 xpc_activate_mq_msg_chctl_openreply_uv, hdr);
498 args = &part->remote_openclose_args[msg->ch_number];
499 args->remote_nentries = msg->remote_nentries;
500 args->local_nentries = msg->local_nentries;
501 args->local_msgqueue_pa = msg->local_notify_mq_gpa;
502
503 spin_lock_irqsave(&part->chctl_lock, irq_flags);
504 part->chctl.flags[msg->ch_number] |= XPC_CHCTL_OPENREPLY;
505 spin_unlock_irqrestore(&part->chctl_lock, irq_flags);
506
507 xpc_wakeup_channel_mgr(part);
508 break;
509 }
510 case XPC_ACTIVATE_MQ_MSG_MARK_ENGAGED_UV:
511 spin_lock_irqsave(&part_uv->flags_lock, irq_flags);
512 part_uv->flags |= XPC_P_ENGAGED_UV;
513 spin_unlock_irqrestore(&part_uv->flags_lock, irq_flags);
514 break;
515
516 case XPC_ACTIVATE_MQ_MSG_MARK_DISENGAGED_UV:
517 spin_lock_irqsave(&part_uv->flags_lock, irq_flags);
518 part_uv->flags &= ~XPC_P_ENGAGED_UV;
519 spin_unlock_irqrestore(&part_uv->flags_lock, irq_flags);
520 break;
521
522 default:
523 dev_err(xpc_part, "received unknown activate_mq msg type=%d "
524 "from partition=%d\n", msg_hdr->type, XPC_PARTID(part));
525
526 /* get hb checker to deactivate from the remote partition */
527 spin_lock_irqsave(&xpc_activate_IRQ_rcvd_lock, irq_flags);
528 if (part_uv->act_state_req == 0)
529 xpc_activate_IRQ_rcvd++;
530 part_uv->act_state_req = XPC_P_ASR_DEACTIVATE_UV;
531 part_uv->reason = xpBadMsgType;
532 spin_unlock_irqrestore(&xpc_activate_IRQ_rcvd_lock, irq_flags);
533
534 (*wakeup_hb_checker)++;
535 return;
536 }
537
538 if (msg_hdr->rp_ts_jiffies != part->remote_rp_ts_jiffies &&
539 part->remote_rp_ts_jiffies != 0) {
540 /*
541 * ??? Does what we do here need to be sensitive to
542 * ??? act_state or remote_act_state?
543 */
544 spin_lock_irqsave(&xpc_activate_IRQ_rcvd_lock, irq_flags);
545 if (part_uv->act_state_req == 0)
546 xpc_activate_IRQ_rcvd++;
547 part_uv->act_state_req = XPC_P_ASR_REACTIVATE_UV;
548 spin_unlock_irqrestore(&xpc_activate_IRQ_rcvd_lock, irq_flags);
549
550 (*wakeup_hb_checker)++;
551 }
552 }
553
554 static irqreturn_t
555 xpc_handle_activate_IRQ_uv(int irq, void *dev_id)
556 {
557 struct xpc_activate_mq_msghdr_uv *msg_hdr;
558 short partid;
559 struct xpc_partition *part;
560 int wakeup_hb_checker = 0;
561
562 while (1) {
563 msg_hdr = gru_get_next_message(xpc_activate_mq_uv->address);
564 if (msg_hdr == NULL)
565 break;
566
567 partid = msg_hdr->partid;
568 if (partid < 0 || partid >= XP_MAX_NPARTITIONS_UV) {
569 dev_err(xpc_part, "xpc_handle_activate_IRQ_uv() "
570 "received invalid partid=0x%x in message\n",
571 partid);
572 } else {
573 part = &xpc_partitions[partid];
574 if (xpc_part_ref(part)) {
575 xpc_handle_activate_mq_msg_uv(part, msg_hdr,
576 &wakeup_hb_checker);
577 xpc_part_deref(part);
578 }
579 }
580
581 gru_free_message(xpc_activate_mq_uv->address, msg_hdr);
582 }
583
584 if (wakeup_hb_checker)
585 wake_up_interruptible(&xpc_activate_IRQ_wq);
586
587 return IRQ_HANDLED;
588 }
589
590 static enum xp_retval
591 xpc_send_activate_IRQ_uv(struct xpc_partition *part, void *msg, size_t msg_size,
592 int msg_type)
593 {
594 struct xpc_activate_mq_msghdr_uv *msg_hdr = msg;
595
596 DBUG_ON(msg_size > XPC_ACTIVATE_MSG_SIZE_UV);
597
598 msg_hdr->type = msg_type;
599 msg_hdr->partid = XPC_PARTID(part);
600 msg_hdr->act_state = part->act_state;
601 msg_hdr->rp_ts_jiffies = xpc_rsvd_page->ts_jiffies;
602
603 /* ??? Is holding a spin_lock (ch->lock) during this call a bad idea? */
604 return xpc_send_gru_msg(part->sn.uv.remote_activate_mq_gpa, msg,
605 msg_size);
606 }
607
608 static void
609 xpc_send_activate_IRQ_part_uv(struct xpc_partition *part, void *msg,
610 size_t msg_size, int msg_type)
611 {
612 enum xp_retval ret;
613
614 ret = xpc_send_activate_IRQ_uv(part, msg, msg_size, msg_type);
615 if (unlikely(ret != xpSuccess))
616 XPC_DEACTIVATE_PARTITION(part, ret);
617 }
618
619 static void
620 xpc_send_activate_IRQ_ch_uv(struct xpc_channel *ch, unsigned long *irq_flags,
621 void *msg, size_t msg_size, int msg_type)
622 {
623 struct xpc_partition *part = &xpc_partitions[ch->number];
624 enum xp_retval ret;
625
626 ret = xpc_send_activate_IRQ_uv(part, msg, msg_size, msg_type);
627 if (unlikely(ret != xpSuccess)) {
628 if (irq_flags != NULL)
629 spin_unlock_irqrestore(&ch->lock, *irq_flags);
630
631 XPC_DEACTIVATE_PARTITION(part, ret);
632
633 if (irq_flags != NULL)
634 spin_lock_irqsave(&ch->lock, *irq_flags);
635 }
636 }
637
638 static void
639 xpc_send_local_activate_IRQ_uv(struct xpc_partition *part, int act_state_req)
640 {
641 unsigned long irq_flags;
642 struct xpc_partition_uv *part_uv = &part->sn.uv;
643
644 /*
645 * !!! Make our side think that the remote partition sent an activate
646 * !!! message our way by doing what the activate IRQ handler would
647 * !!! do had one really been sent.
648 */
649
650 spin_lock_irqsave(&xpc_activate_IRQ_rcvd_lock, irq_flags);
651 if (part_uv->act_state_req == 0)
652 xpc_activate_IRQ_rcvd++;
653 part_uv->act_state_req = act_state_req;
654 spin_unlock_irqrestore(&xpc_activate_IRQ_rcvd_lock, irq_flags);
655
656 wake_up_interruptible(&xpc_activate_IRQ_wq);
657 }
658
659 static enum xp_retval
660 xpc_get_partition_rsvd_page_pa_uv(void *buf, u64 *cookie, unsigned long *rp_pa,
661 size_t *len)
662 {
663 s64 status;
664 enum xp_retval ret;
665
666 #if defined CONFIG_X86_64
667 status = uv_bios_reserved_page_pa((u64)buf, cookie, (u64 *)rp_pa,
668 (u64 *)len);
669 if (status == BIOS_STATUS_SUCCESS)
670 ret = xpSuccess;
671 else if (status == BIOS_STATUS_MORE_PASSES)
672 ret = xpNeedMoreInfo;
673 else
674 ret = xpBiosError;
675
676 #elif defined CONFIG_IA64_GENERIC || defined CONFIG_IA64_SGI_UV
677 status = sn_partition_reserved_page_pa((u64)buf, cookie, rp_pa, len);
678 if (status == SALRET_OK)
679 ret = xpSuccess;
680 else if (status == SALRET_MORE_PASSES)
681 ret = xpNeedMoreInfo;
682 else
683 ret = xpSalError;
684
685 #else
686 #error not a supported configuration
687 #endif
688
689 return ret;
690 }
691
692 static int
693 xpc_setup_rsvd_page_sn_uv(struct xpc_rsvd_page *rp)
694 {
695 rp->sn.activate_mq_gpa = uv_gpa(xpc_activate_mq_uv->address);
696 return 0;
697 }
698
699 static void
700 xpc_send_heartbeat_uv(int msg_type)
701 {
702 short partid;
703 struct xpc_partition *part;
704 struct xpc_activate_mq_msg_heartbeat_req_uv msg;
705
706 /*
707 * !!! On uv we're broadcasting a heartbeat message every 5 seconds.
708 * !!! Whereas on sn2 we're bte_copy'ng the heartbeat info every 20
709 * !!! seconds. This is an increase in numalink traffic.
710 * ??? Is this good?
711 */
712
713 msg.heartbeat = atomic64_inc_return(&xpc_heartbeat_uv);
714
715 partid = find_first_bit(xpc_heartbeating_to_mask_uv,
716 XP_MAX_NPARTITIONS_UV);
717
718 while (partid < XP_MAX_NPARTITIONS_UV) {
719 part = &xpc_partitions[partid];
720
721 xpc_send_activate_IRQ_part_uv(part, &msg, sizeof(msg),
722 msg_type);
723
724 partid = find_next_bit(xpc_heartbeating_to_mask_uv,
725 XP_MAX_NPARTITIONS_UV, partid + 1);
726 }
727 }
728
729 static void
730 xpc_increment_heartbeat_uv(void)
731 {
732 xpc_send_heartbeat_uv(XPC_ACTIVATE_MQ_MSG_INC_HEARTBEAT_UV);
733 }
734
735 static void
736 xpc_offline_heartbeat_uv(void)
737 {
738 xpc_send_heartbeat_uv(XPC_ACTIVATE_MQ_MSG_OFFLINE_HEARTBEAT_UV);
739 }
740
741 static void
742 xpc_online_heartbeat_uv(void)
743 {
744 xpc_send_heartbeat_uv(XPC_ACTIVATE_MQ_MSG_ONLINE_HEARTBEAT_UV);
745 }
746
747 static void
748 xpc_heartbeat_init_uv(void)
749 {
750 atomic64_set(&xpc_heartbeat_uv, 0);
751 bitmap_zero(xpc_heartbeating_to_mask_uv, XP_MAX_NPARTITIONS_UV);
752 xpc_heartbeating_to_mask = &xpc_heartbeating_to_mask_uv[0];
753 }
754
755 static void
756 xpc_heartbeat_exit_uv(void)
757 {
758 xpc_send_heartbeat_uv(XPC_ACTIVATE_MQ_MSG_OFFLINE_HEARTBEAT_UV);
759 }
760
761 static enum xp_retval
762 xpc_get_remote_heartbeat_uv(struct xpc_partition *part)
763 {
764 struct xpc_partition_uv *part_uv = &part->sn.uv;
765 enum xp_retval ret = xpNoHeartbeat;
766
767 if (part_uv->remote_act_state != XPC_P_AS_INACTIVE &&
768 part_uv->remote_act_state != XPC_P_AS_DEACTIVATING) {
769
770 if (part_uv->heartbeat != part->last_heartbeat ||
771 (part_uv->flags & XPC_P_HEARTBEAT_OFFLINE_UV)) {
772
773 part->last_heartbeat = part_uv->heartbeat;
774 ret = xpSuccess;
775 }
776 }
777 return ret;
778 }
779
780 static void
781 xpc_request_partition_activation_uv(struct xpc_rsvd_page *remote_rp,
782 unsigned long remote_rp_gpa, int nasid)
783 {
784 short partid = remote_rp->SAL_partid;
785 struct xpc_partition *part = &xpc_partitions[partid];
786 struct xpc_activate_mq_msg_activate_req_uv msg;
787
788 part->remote_rp_pa = remote_rp_gpa; /* !!! _pa here is really _gpa */
789 part->remote_rp_ts_jiffies = remote_rp->ts_jiffies;
790 part->sn.uv.remote_activate_mq_gpa = remote_rp->sn.activate_mq_gpa;
791
792 /*
793 * ??? Is it a good idea to make this conditional on what is
794 * ??? potentially stale state information?
795 */
796 if (part->sn.uv.remote_act_state == XPC_P_AS_INACTIVE) {
797 msg.rp_gpa = uv_gpa(xpc_rsvd_page);
798 msg.activate_mq_gpa = xpc_rsvd_page->sn.activate_mq_gpa;
799 xpc_send_activate_IRQ_part_uv(part, &msg, sizeof(msg),
800 XPC_ACTIVATE_MQ_MSG_ACTIVATE_REQ_UV);
801 }
802
803 if (part->act_state == XPC_P_AS_INACTIVE)
804 xpc_send_local_activate_IRQ_uv(part, XPC_P_ASR_ACTIVATE_UV);
805 }
806
807 static void
808 xpc_request_partition_reactivation_uv(struct xpc_partition *part)
809 {
810 xpc_send_local_activate_IRQ_uv(part, XPC_P_ASR_ACTIVATE_UV);
811 }
812
813 static void
814 xpc_request_partition_deactivation_uv(struct xpc_partition *part)
815 {
816 struct xpc_activate_mq_msg_deactivate_req_uv msg;
817
818 /*
819 * ??? Is it a good idea to make this conditional on what is
820 * ??? potentially stale state information?
821 */
822 if (part->sn.uv.remote_act_state != XPC_P_AS_DEACTIVATING &&
823 part->sn.uv.remote_act_state != XPC_P_AS_INACTIVE) {
824
825 msg.reason = part->reason;
826 xpc_send_activate_IRQ_part_uv(part, &msg, sizeof(msg),
827 XPC_ACTIVATE_MQ_MSG_DEACTIVATE_REQ_UV);
828 }
829 }
830
831 static void
832 xpc_cancel_partition_deactivation_request_uv(struct xpc_partition *part)
833 {
834 /* nothing needs to be done */
835 return;
836 }
837
838 static void
839 xpc_init_fifo_uv(struct xpc_fifo_head_uv *head)
840 {
841 head->first = NULL;
842 head->last = NULL;
843 spin_lock_init(&head->lock);
844 head->n_entries = 0;
845 }
846
847 static void *
848 xpc_get_fifo_entry_uv(struct xpc_fifo_head_uv *head)
849 {
850 unsigned long irq_flags;
851 struct xpc_fifo_entry_uv *first;
852
853 spin_lock_irqsave(&head->lock, irq_flags);
854 first = head->first;
855 if (head->first != NULL) {
856 head->first = first->next;
857 if (head->first == NULL)
858 head->last = NULL;
859 }
860 head->n_entries++;
861 spin_unlock_irqrestore(&head->lock, irq_flags);
862 first->next = NULL;
863 return first;
864 }
865
866 static void
867 xpc_put_fifo_entry_uv(struct xpc_fifo_head_uv *head,
868 struct xpc_fifo_entry_uv *last)
869 {
870 unsigned long irq_flags;
871
872 last->next = NULL;
873 spin_lock_irqsave(&head->lock, irq_flags);
874 if (head->last != NULL)
875 head->last->next = last;
876 else
877 head->first = last;
878 head->last = last;
879 head->n_entries--;
880 BUG_ON(head->n_entries < 0);
881 spin_unlock_irqrestore(&head->lock, irq_flags);
882 }
883
884 static int
885 xpc_n_of_fifo_entries_uv(struct xpc_fifo_head_uv *head)
886 {
887 return head->n_entries;
888 }
889
890 /*
891 * Setup the channel structures that are uv specific.
892 */
893 static enum xp_retval
894 xpc_setup_ch_structures_sn_uv(struct xpc_partition *part)
895 {
896 struct xpc_channel_uv *ch_uv;
897 int ch_number;
898
899 for (ch_number = 0; ch_number < part->nchannels; ch_number++) {
900 ch_uv = &part->channels[ch_number].sn.uv;
901
902 xpc_init_fifo_uv(&ch_uv->msg_slot_free_list);
903 xpc_init_fifo_uv(&ch_uv->recv_msg_list);
904 }
905
906 return xpSuccess;
907 }
908
909 /*
910 * Teardown the channel structures that are uv specific.
911 */
912 static void
913 xpc_teardown_ch_structures_sn_uv(struct xpc_partition *part)
914 {
915 /* nothing needs to be done */
916 return;
917 }
918
919 static enum xp_retval
920 xpc_make_first_contact_uv(struct xpc_partition *part)
921 {
922 struct xpc_activate_mq_msg_uv msg;
923
924 /*
925 * We send a sync msg to get the remote partition's remote_act_state
926 * updated to our current act_state which at this point should
927 * be XPC_P_AS_ACTIVATING.
928 */
929 xpc_send_activate_IRQ_part_uv(part, &msg, sizeof(msg),
930 XPC_ACTIVATE_MQ_MSG_SYNC_ACT_STATE_UV);
931
932 while (part->sn.uv.remote_act_state != XPC_P_AS_ACTIVATING) {
933
934 dev_dbg(xpc_part, "waiting to make first contact with "
935 "partition %d\n", XPC_PARTID(part));
936
937 /* wait a 1/4 of a second or so */
938 (void)msleep_interruptible(250);
939
940 if (part->act_state == XPC_P_AS_DEACTIVATING)
941 return part->reason;
942 }
943
944 return xpSuccess;
945 }
946
947 static u64
948 xpc_get_chctl_all_flags_uv(struct xpc_partition *part)
949 {
950 unsigned long irq_flags;
951 union xpc_channel_ctl_flags chctl;
952
953 spin_lock_irqsave(&part->chctl_lock, irq_flags);
954 chctl = part->chctl;
955 if (chctl.all_flags != 0)
956 part->chctl.all_flags = 0;
957
958 spin_unlock_irqrestore(&part->chctl_lock, irq_flags);
959 return chctl.all_flags;
960 }
961
962 static enum xp_retval
963 xpc_allocate_send_msg_slot_uv(struct xpc_channel *ch)
964 {
965 struct xpc_channel_uv *ch_uv = &ch->sn.uv;
966 struct xpc_send_msg_slot_uv *msg_slot;
967 unsigned long irq_flags;
968 int nentries;
969 int entry;
970 size_t nbytes;
971
972 for (nentries = ch->local_nentries; nentries > 0; nentries--) {
973 nbytes = nentries * sizeof(struct xpc_send_msg_slot_uv);
974 ch_uv->send_msg_slots = kzalloc(nbytes, GFP_KERNEL);
975 if (ch_uv->send_msg_slots == NULL)
976 continue;
977
978 for (entry = 0; entry < nentries; entry++) {
979 msg_slot = &ch_uv->send_msg_slots[entry];
980
981 msg_slot->msg_slot_number = entry;
982 xpc_put_fifo_entry_uv(&ch_uv->msg_slot_free_list,
983 &msg_slot->next);
984 }
985
986 spin_lock_irqsave(&ch->lock, irq_flags);
987 if (nentries < ch->local_nentries)
988 ch->local_nentries = nentries;
989 spin_unlock_irqrestore(&ch->lock, irq_flags);
990 return xpSuccess;
991 }
992
993 return xpNoMemory;
994 }
995
996 static enum xp_retval
997 xpc_allocate_recv_msg_slot_uv(struct xpc_channel *ch)
998 {
999 struct xpc_channel_uv *ch_uv = &ch->sn.uv;
1000 struct xpc_notify_mq_msg_uv *msg_slot;
1001 unsigned long irq_flags;
1002 int nentries;
1003 int entry;
1004 size_t nbytes;
1005
1006 for (nentries = ch->remote_nentries; nentries > 0; nentries--) {
1007 nbytes = nentries * ch->entry_size;
1008 ch_uv->recv_msg_slots = kzalloc(nbytes, GFP_KERNEL);
1009 if (ch_uv->recv_msg_slots == NULL)
1010 continue;
1011
1012 for (entry = 0; entry < nentries; entry++) {
1013 msg_slot = ch_uv->recv_msg_slots +
1014 entry * ch->entry_size;
1015
1016 msg_slot->hdr.msg_slot_number = entry;
1017 }
1018
1019 spin_lock_irqsave(&ch->lock, irq_flags);
1020 if (nentries < ch->remote_nentries)
1021 ch->remote_nentries = nentries;
1022 spin_unlock_irqrestore(&ch->lock, irq_flags);
1023 return xpSuccess;
1024 }
1025
1026 return xpNoMemory;
1027 }
1028
1029 /*
1030 * Allocate msg_slots associated with the channel.
1031 */
1032 static enum xp_retval
1033 xpc_setup_msg_structures_uv(struct xpc_channel *ch)
1034 {
1035 static enum xp_retval ret;
1036 struct xpc_channel_uv *ch_uv = &ch->sn.uv;
1037
1038 DBUG_ON(ch->flags & XPC_C_SETUP);
1039
1040 ret = xpc_allocate_send_msg_slot_uv(ch);
1041 if (ret == xpSuccess) {
1042
1043 ret = xpc_allocate_recv_msg_slot_uv(ch);
1044 if (ret != xpSuccess) {
1045 kfree(ch_uv->send_msg_slots);
1046 xpc_init_fifo_uv(&ch_uv->msg_slot_free_list);
1047 }
1048 }
1049 return ret;
1050 }
1051
1052 /*
1053 * Free up msg_slots and clear other stuff that were setup for the specified
1054 * channel.
1055 */
1056 static void
1057 xpc_teardown_msg_structures_uv(struct xpc_channel *ch)
1058 {
1059 struct xpc_channel_uv *ch_uv = &ch->sn.uv;
1060
1061 DBUG_ON(!spin_is_locked(&ch->lock));
1062
1063 ch_uv->remote_notify_mq_gpa = 0;
1064
1065 if (ch->flags & XPC_C_SETUP) {
1066 xpc_init_fifo_uv(&ch_uv->msg_slot_free_list);
1067 kfree(ch_uv->send_msg_slots);
1068 xpc_init_fifo_uv(&ch_uv->recv_msg_list);
1069 kfree(ch_uv->recv_msg_slots);
1070 }
1071 }
1072
1073 static void
1074 xpc_send_chctl_closerequest_uv(struct xpc_channel *ch, unsigned long *irq_flags)
1075 {
1076 struct xpc_activate_mq_msg_chctl_closerequest_uv msg;
1077
1078 msg.ch_number = ch->number;
1079 msg.reason = ch->reason;
1080 xpc_send_activate_IRQ_ch_uv(ch, irq_flags, &msg, sizeof(msg),
1081 XPC_ACTIVATE_MQ_MSG_CHCTL_CLOSEREQUEST_UV);
1082 }
1083
1084 static void
1085 xpc_send_chctl_closereply_uv(struct xpc_channel *ch, unsigned long *irq_flags)
1086 {
1087 struct xpc_activate_mq_msg_chctl_closereply_uv msg;
1088
1089 msg.ch_number = ch->number;
1090 xpc_send_activate_IRQ_ch_uv(ch, irq_flags, &msg, sizeof(msg),
1091 XPC_ACTIVATE_MQ_MSG_CHCTL_CLOSEREPLY_UV);
1092 }
1093
1094 static void
1095 xpc_send_chctl_openrequest_uv(struct xpc_channel *ch, unsigned long *irq_flags)
1096 {
1097 struct xpc_activate_mq_msg_chctl_openrequest_uv msg;
1098
1099 msg.ch_number = ch->number;
1100 msg.entry_size = ch->entry_size;
1101 msg.local_nentries = ch->local_nentries;
1102 xpc_send_activate_IRQ_ch_uv(ch, irq_flags, &msg, sizeof(msg),
1103 XPC_ACTIVATE_MQ_MSG_CHCTL_OPENREQUEST_UV);
1104 }
1105
1106 static void
1107 xpc_send_chctl_openreply_uv(struct xpc_channel *ch, unsigned long *irq_flags)
1108 {
1109 struct xpc_activate_mq_msg_chctl_openreply_uv msg;
1110
1111 msg.ch_number = ch->number;
1112 msg.local_nentries = ch->local_nentries;
1113 msg.remote_nentries = ch->remote_nentries;
1114 msg.local_notify_mq_gpa = uv_gpa(xpc_notify_mq_uv);
1115 xpc_send_activate_IRQ_ch_uv(ch, irq_flags, &msg, sizeof(msg),
1116 XPC_ACTIVATE_MQ_MSG_CHCTL_OPENREPLY_UV);
1117 }
1118
1119 static void
1120 xpc_send_chctl_local_msgrequest_uv(struct xpc_partition *part, int ch_number)
1121 {
1122 unsigned long irq_flags;
1123
1124 spin_lock_irqsave(&part->chctl_lock, irq_flags);
1125 part->chctl.flags[ch_number] |= XPC_CHCTL_MSGREQUEST;
1126 spin_unlock_irqrestore(&part->chctl_lock, irq_flags);
1127
1128 xpc_wakeup_channel_mgr(part);
1129 }
1130
1131 static void
1132 xpc_save_remote_msgqueue_pa_uv(struct xpc_channel *ch,
1133 unsigned long msgqueue_pa)
1134 {
1135 ch->sn.uv.remote_notify_mq_gpa = msgqueue_pa;
1136 }
1137
1138 static void
1139 xpc_indicate_partition_engaged_uv(struct xpc_partition *part)
1140 {
1141 struct xpc_activate_mq_msg_uv msg;
1142
1143 xpc_send_activate_IRQ_part_uv(part, &msg, sizeof(msg),
1144 XPC_ACTIVATE_MQ_MSG_MARK_ENGAGED_UV);
1145 }
1146
1147 static void
1148 xpc_indicate_partition_disengaged_uv(struct xpc_partition *part)
1149 {
1150 struct xpc_activate_mq_msg_uv msg;
1151
1152 xpc_send_activate_IRQ_part_uv(part, &msg, sizeof(msg),
1153 XPC_ACTIVATE_MQ_MSG_MARK_DISENGAGED_UV);
1154 }
1155
1156 static void
1157 xpc_assume_partition_disengaged_uv(short partid)
1158 {
1159 struct xpc_partition_uv *part_uv = &xpc_partitions[partid].sn.uv;
1160 unsigned long irq_flags;
1161
1162 spin_lock_irqsave(&part_uv->flags_lock, irq_flags);
1163 part_uv->flags &= ~XPC_P_ENGAGED_UV;
1164 spin_unlock_irqrestore(&part_uv->flags_lock, irq_flags);
1165 }
1166
1167 static int
1168 xpc_partition_engaged_uv(short partid)
1169 {
1170 return (xpc_partitions[partid].sn.uv.flags & XPC_P_ENGAGED_UV) != 0;
1171 }
1172
1173 static int
1174 xpc_any_partition_engaged_uv(void)
1175 {
1176 struct xpc_partition_uv *part_uv;
1177 short partid;
1178
1179 for (partid = 0; partid < XP_MAX_NPARTITIONS_UV; partid++) {
1180 part_uv = &xpc_partitions[partid].sn.uv;
1181 if ((part_uv->flags & XPC_P_ENGAGED_UV) != 0)
1182 return 1;
1183 }
1184 return 0;
1185 }
1186
1187 static enum xp_retval
1188 xpc_allocate_msg_slot_uv(struct xpc_channel *ch, u32 flags,
1189 struct xpc_send_msg_slot_uv **address_of_msg_slot)
1190 {
1191 enum xp_retval ret;
1192 struct xpc_send_msg_slot_uv *msg_slot;
1193 struct xpc_fifo_entry_uv *entry;
1194
1195 while (1) {
1196 entry = xpc_get_fifo_entry_uv(&ch->sn.uv.msg_slot_free_list);
1197 if (entry != NULL)
1198 break;
1199
1200 if (flags & XPC_NOWAIT)
1201 return xpNoWait;
1202
1203 ret = xpc_allocate_msg_wait(ch);
1204 if (ret != xpInterrupted && ret != xpTimeout)
1205 return ret;
1206 }
1207
1208 msg_slot = container_of(entry, struct xpc_send_msg_slot_uv, next);
1209 *address_of_msg_slot = msg_slot;
1210 return xpSuccess;
1211 }
1212
1213 static void
1214 xpc_free_msg_slot_uv(struct xpc_channel *ch,
1215 struct xpc_send_msg_slot_uv *msg_slot)
1216 {
1217 xpc_put_fifo_entry_uv(&ch->sn.uv.msg_slot_free_list, &msg_slot->next);
1218
1219 /* wakeup anyone waiting for a free msg slot */
1220 if (atomic_read(&ch->n_on_msg_allocate_wq) > 0)
1221 wake_up(&ch->msg_allocate_wq);
1222 }
1223
1224 static void
1225 xpc_notify_sender_uv(struct xpc_channel *ch,
1226 struct xpc_send_msg_slot_uv *msg_slot,
1227 enum xp_retval reason)
1228 {
1229 xpc_notify_func func = msg_slot->func;
1230
1231 if (func != NULL && cmpxchg(&msg_slot->func, func, NULL) == func) {
1232
1233 atomic_dec(&ch->n_to_notify);
1234
1235 dev_dbg(xpc_chan, "msg_slot->func() called, msg_slot=0x%p "
1236 "msg_slot_number=%d partid=%d channel=%d\n", msg_slot,
1237 msg_slot->msg_slot_number, ch->partid, ch->number);
1238
1239 func(reason, ch->partid, ch->number, msg_slot->key);
1240
1241 dev_dbg(xpc_chan, "msg_slot->func() returned, msg_slot=0x%p "
1242 "msg_slot_number=%d partid=%d channel=%d\n", msg_slot,
1243 msg_slot->msg_slot_number, ch->partid, ch->number);
1244 }
1245 }
1246
1247 static void
1248 xpc_handle_notify_mq_ack_uv(struct xpc_channel *ch,
1249 struct xpc_notify_mq_msg_uv *msg)
1250 {
1251 struct xpc_send_msg_slot_uv *msg_slot;
1252 int entry = msg->hdr.msg_slot_number % ch->local_nentries;
1253
1254 msg_slot = &ch->sn.uv.send_msg_slots[entry];
1255
1256 BUG_ON(msg_slot->msg_slot_number != msg->hdr.msg_slot_number);
1257 msg_slot->msg_slot_number += ch->local_nentries;
1258
1259 if (msg_slot->func != NULL)
1260 xpc_notify_sender_uv(ch, msg_slot, xpMsgDelivered);
1261
1262 xpc_free_msg_slot_uv(ch, msg_slot);
1263 }
1264
1265 static void
1266 xpc_handle_notify_mq_msg_uv(struct xpc_partition *part,
1267 struct xpc_notify_mq_msg_uv *msg)
1268 {
1269 struct xpc_partition_uv *part_uv = &part->sn.uv;
1270 struct xpc_channel *ch;
1271 struct xpc_channel_uv *ch_uv;
1272 struct xpc_notify_mq_msg_uv *msg_slot;
1273 unsigned long irq_flags;
1274 int ch_number = msg->hdr.ch_number;
1275
1276 if (unlikely(ch_number >= part->nchannels)) {
1277 dev_err(xpc_part, "xpc_handle_notify_IRQ_uv() received invalid "
1278 "channel number=0x%x in message from partid=%d\n",
1279 ch_number, XPC_PARTID(part));
1280
1281 /* get hb checker to deactivate from the remote partition */
1282 spin_lock_irqsave(&xpc_activate_IRQ_rcvd_lock, irq_flags);
1283 if (part_uv->act_state_req == 0)
1284 xpc_activate_IRQ_rcvd++;
1285 part_uv->act_state_req = XPC_P_ASR_DEACTIVATE_UV;
1286 part_uv->reason = xpBadChannelNumber;
1287 spin_unlock_irqrestore(&xpc_activate_IRQ_rcvd_lock, irq_flags);
1288
1289 wake_up_interruptible(&xpc_activate_IRQ_wq);
1290 return;
1291 }
1292
1293 ch = &part->channels[ch_number];
1294 xpc_msgqueue_ref(ch);
1295
1296 if (!(ch->flags & XPC_C_CONNECTED)) {
1297 xpc_msgqueue_deref(ch);
1298 return;
1299 }
1300
1301 /* see if we're really dealing with an ACK for a previously sent msg */
1302 if (msg->hdr.size == 0) {
1303 xpc_handle_notify_mq_ack_uv(ch, msg);
1304 xpc_msgqueue_deref(ch);
1305 return;
1306 }
1307
1308 /* we're dealing with a normal message sent via the notify_mq */
1309 ch_uv = &ch->sn.uv;
1310
1311 msg_slot = ch_uv->recv_msg_slots +
1312 (msg->hdr.msg_slot_number % ch->remote_nentries) * ch->entry_size;
1313
1314 BUG_ON(msg->hdr.msg_slot_number != msg_slot->hdr.msg_slot_number);
1315 BUG_ON(msg_slot->hdr.size != 0);
1316
1317 memcpy(msg_slot, msg, msg->hdr.size);
1318
1319 xpc_put_fifo_entry_uv(&ch_uv->recv_msg_list, &msg_slot->hdr.u.next);
1320
1321 if (ch->flags & XPC_C_CONNECTEDCALLOUT_MADE) {
1322 /*
1323 * If there is an existing idle kthread get it to deliver
1324 * the payload, otherwise we'll have to get the channel mgr
1325 * for this partition to create a kthread to do the delivery.
1326 */
1327 if (atomic_read(&ch->kthreads_idle) > 0)
1328 wake_up_nr(&ch->idle_wq, 1);
1329 else
1330 xpc_send_chctl_local_msgrequest_uv(part, ch->number);
1331 }
1332 xpc_msgqueue_deref(ch);
1333 }
1334
1335 static irqreturn_t
1336 xpc_handle_notify_IRQ_uv(int irq, void *dev_id)
1337 {
1338 struct xpc_notify_mq_msg_uv *msg;
1339 short partid;
1340 struct xpc_partition *part;
1341
1342 while ((msg = gru_get_next_message(xpc_notify_mq_uv)) != NULL) {
1343
1344 partid = msg->hdr.partid;
1345 if (partid < 0 || partid >= XP_MAX_NPARTITIONS_UV) {
1346 dev_err(xpc_part, "xpc_handle_notify_IRQ_uv() received "
1347 "invalid partid=0x%x in message\n", partid);
1348 } else {
1349 part = &xpc_partitions[partid];
1350
1351 if (xpc_part_ref(part)) {
1352 xpc_handle_notify_mq_msg_uv(part, msg);
1353 xpc_part_deref(part);
1354 }
1355 }
1356
1357 gru_free_message(xpc_notify_mq_uv, msg);
1358 }
1359
1360 return IRQ_HANDLED;
1361 }
1362
1363 static int
1364 xpc_n_of_deliverable_payloads_uv(struct xpc_channel *ch)
1365 {
1366 return xpc_n_of_fifo_entries_uv(&ch->sn.uv.recv_msg_list);
1367 }
1368
1369 static void
1370 xpc_process_msg_chctl_flags_uv(struct xpc_partition *part, int ch_number)
1371 {
1372 struct xpc_channel *ch = &part->channels[ch_number];
1373 int ndeliverable_payloads;
1374
1375 xpc_msgqueue_ref(ch);
1376
1377 ndeliverable_payloads = xpc_n_of_deliverable_payloads_uv(ch);
1378
1379 if (ndeliverable_payloads > 0 &&
1380 (ch->flags & XPC_C_CONNECTED) &&
1381 (ch->flags & XPC_C_CONNECTEDCALLOUT_MADE)) {
1382
1383 xpc_activate_kthreads(ch, ndeliverable_payloads);
1384 }
1385
1386 xpc_msgqueue_deref(ch);
1387 }
1388
1389 static enum xp_retval
1390 xpc_send_payload_uv(struct xpc_channel *ch, u32 flags, void *payload,
1391 u16 payload_size, u8 notify_type, xpc_notify_func func,
1392 void *key)
1393 {
1394 enum xp_retval ret = xpSuccess;
1395 struct xpc_send_msg_slot_uv *msg_slot = NULL;
1396 struct xpc_notify_mq_msg_uv *msg;
1397 u8 msg_buffer[XPC_NOTIFY_MSG_SIZE_UV];
1398 size_t msg_size;
1399
1400 DBUG_ON(notify_type != XPC_N_CALL);
1401
1402 msg_size = sizeof(struct xpc_notify_mq_msghdr_uv) + payload_size;
1403 if (msg_size > ch->entry_size)
1404 return xpPayloadTooBig;
1405
1406 xpc_msgqueue_ref(ch);
1407
1408 if (ch->flags & XPC_C_DISCONNECTING) {
1409 ret = ch->reason;
1410 goto out_1;
1411 }
1412 if (!(ch->flags & XPC_C_CONNECTED)) {
1413 ret = xpNotConnected;
1414 goto out_1;
1415 }
1416
1417 ret = xpc_allocate_msg_slot_uv(ch, flags, &msg_slot);
1418 if (ret != xpSuccess)
1419 goto out_1;
1420
1421 if (func != NULL) {
1422 atomic_inc(&ch->n_to_notify);
1423
1424 msg_slot->key = key;
1425 smp_wmb(); /* a non-NULL func must hit memory after the key */
1426 msg_slot->func = func;
1427
1428 if (ch->flags & XPC_C_DISCONNECTING) {
1429 ret = ch->reason;
1430 goto out_2;
1431 }
1432 }
1433
1434 msg = (struct xpc_notify_mq_msg_uv *)&msg_buffer;
1435 msg->hdr.partid = xp_partition_id;
1436 msg->hdr.ch_number = ch->number;
1437 msg->hdr.size = msg_size;
1438 msg->hdr.msg_slot_number = msg_slot->msg_slot_number;
1439 memcpy(&msg->payload, payload, payload_size);
1440
1441 ret = xpc_send_gru_msg(ch->sn.uv.remote_notify_mq_gpa, msg, msg_size);
1442 if (ret == xpSuccess)
1443 goto out_1;
1444
1445 XPC_DEACTIVATE_PARTITION(&xpc_partitions[ch->partid], ret);
1446 out_2:
1447 if (func != NULL) {
1448 /*
1449 * Try to NULL the msg_slot's func field. If we fail, then
1450 * xpc_notify_senders_of_disconnect_uv() beat us to it, in which
1451 * case we need to pretend we succeeded to send the message
1452 * since the user will get a callout for the disconnect error
1453 * by xpc_notify_senders_of_disconnect_uv(), and to also get an
1454 * error returned here will confuse them. Additionally, since
1455 * in this case the channel is being disconnected we don't need
1456 * to put the the msg_slot back on the free list.
1457 */
1458 if (cmpxchg(&msg_slot->func, func, NULL) != func) {
1459 ret = xpSuccess;
1460 goto out_1;
1461 }
1462
1463 msg_slot->key = NULL;
1464 atomic_dec(&ch->n_to_notify);
1465 }
1466 xpc_free_msg_slot_uv(ch, msg_slot);
1467 out_1:
1468 xpc_msgqueue_deref(ch);
1469 return ret;
1470 }
1471
1472 /*
1473 * Tell the callers of xpc_send_notify() that the status of their payloads
1474 * is unknown because the channel is now disconnecting.
1475 *
1476 * We don't worry about putting these msg_slots on the free list since the
1477 * msg_slots themselves are about to be kfree'd.
1478 */
1479 static void
1480 xpc_notify_senders_of_disconnect_uv(struct xpc_channel *ch)
1481 {
1482 struct xpc_send_msg_slot_uv *msg_slot;
1483 int entry;
1484
1485 DBUG_ON(!(ch->flags & XPC_C_DISCONNECTING));
1486
1487 for (entry = 0; entry < ch->local_nentries; entry++) {
1488
1489 if (atomic_read(&ch->n_to_notify) == 0)
1490 break;
1491
1492 msg_slot = &ch->sn.uv.send_msg_slots[entry];
1493 if (msg_slot->func != NULL)
1494 xpc_notify_sender_uv(ch, msg_slot, ch->reason);
1495 }
1496 }
1497
1498 /*
1499 * Get the next deliverable message's payload.
1500 */
1501 static void *
1502 xpc_get_deliverable_payload_uv(struct xpc_channel *ch)
1503 {
1504 struct xpc_fifo_entry_uv *entry;
1505 struct xpc_notify_mq_msg_uv *msg;
1506 void *payload = NULL;
1507
1508 if (!(ch->flags & XPC_C_DISCONNECTING)) {
1509 entry = xpc_get_fifo_entry_uv(&ch->sn.uv.recv_msg_list);
1510 if (entry != NULL) {
1511 msg = container_of(entry, struct xpc_notify_mq_msg_uv,
1512 hdr.u.next);
1513 payload = &msg->payload;
1514 }
1515 }
1516 return payload;
1517 }
1518
1519 static void
1520 xpc_received_payload_uv(struct xpc_channel *ch, void *payload)
1521 {
1522 struct xpc_notify_mq_msg_uv *msg;
1523 enum xp_retval ret;
1524
1525 msg = container_of(payload, struct xpc_notify_mq_msg_uv, payload);
1526
1527 /* return an ACK to the sender of this message */
1528
1529 msg->hdr.partid = xp_partition_id;
1530 msg->hdr.size = 0; /* size of zero indicates this is an ACK */
1531
1532 ret = xpc_send_gru_msg(ch->sn.uv.remote_notify_mq_gpa, msg,
1533 sizeof(struct xpc_notify_mq_msghdr_uv));
1534 if (ret != xpSuccess)
1535 XPC_DEACTIVATE_PARTITION(&xpc_partitions[ch->partid], ret);
1536
1537 msg->hdr.msg_slot_number += ch->remote_nentries;
1538 }
1539
1540 int
1541 xpc_init_uv(void)
1542 {
1543 xpc_setup_partitions_sn = xpc_setup_partitions_sn_uv;
1544 xpc_process_activate_IRQ_rcvd = xpc_process_activate_IRQ_rcvd_uv;
1545 xpc_get_partition_rsvd_page_pa = xpc_get_partition_rsvd_page_pa_uv;
1546 xpc_setup_rsvd_page_sn = xpc_setup_rsvd_page_sn_uv;
1547 xpc_increment_heartbeat = xpc_increment_heartbeat_uv;
1548 xpc_offline_heartbeat = xpc_offline_heartbeat_uv;
1549 xpc_online_heartbeat = xpc_online_heartbeat_uv;
1550 xpc_heartbeat_init = xpc_heartbeat_init_uv;
1551 xpc_heartbeat_exit = xpc_heartbeat_exit_uv;
1552 xpc_get_remote_heartbeat = xpc_get_remote_heartbeat_uv;
1553
1554 xpc_request_partition_activation = xpc_request_partition_activation_uv;
1555 xpc_request_partition_reactivation =
1556 xpc_request_partition_reactivation_uv;
1557 xpc_request_partition_deactivation =
1558 xpc_request_partition_deactivation_uv;
1559 xpc_cancel_partition_deactivation_request =
1560 xpc_cancel_partition_deactivation_request_uv;
1561
1562 xpc_setup_ch_structures_sn = xpc_setup_ch_structures_sn_uv;
1563 xpc_teardown_ch_structures_sn = xpc_teardown_ch_structures_sn_uv;
1564
1565 xpc_make_first_contact = xpc_make_first_contact_uv;
1566
1567 xpc_get_chctl_all_flags = xpc_get_chctl_all_flags_uv;
1568 xpc_send_chctl_closerequest = xpc_send_chctl_closerequest_uv;
1569 xpc_send_chctl_closereply = xpc_send_chctl_closereply_uv;
1570 xpc_send_chctl_openrequest = xpc_send_chctl_openrequest_uv;
1571 xpc_send_chctl_openreply = xpc_send_chctl_openreply_uv;
1572
1573 xpc_save_remote_msgqueue_pa = xpc_save_remote_msgqueue_pa_uv;
1574
1575 xpc_setup_msg_structures = xpc_setup_msg_structures_uv;
1576 xpc_teardown_msg_structures = xpc_teardown_msg_structures_uv;
1577
1578 xpc_indicate_partition_engaged = xpc_indicate_partition_engaged_uv;
1579 xpc_indicate_partition_disengaged =
1580 xpc_indicate_partition_disengaged_uv;
1581 xpc_assume_partition_disengaged = xpc_assume_partition_disengaged_uv;
1582 xpc_partition_engaged = xpc_partition_engaged_uv;
1583 xpc_any_partition_engaged = xpc_any_partition_engaged_uv;
1584
1585 xpc_n_of_deliverable_payloads = xpc_n_of_deliverable_payloads_uv;
1586 xpc_process_msg_chctl_flags = xpc_process_msg_chctl_flags_uv;
1587 xpc_send_payload = xpc_send_payload_uv;
1588 xpc_notify_senders_of_disconnect = xpc_notify_senders_of_disconnect_uv;
1589 xpc_get_deliverable_payload = xpc_get_deliverable_payload_uv;
1590 xpc_received_payload = xpc_received_payload_uv;
1591
1592 if (sizeof(struct xpc_notify_mq_msghdr_uv) > XPC_MSG_HDR_MAX_SIZE) {
1593 dev_err(xpc_part, "xpc_notify_mq_msghdr_uv is larger than %d\n",
1594 XPC_MSG_HDR_MAX_SIZE);
1595 return -E2BIG;
1596 }
1597
1598 xpc_activate_mq_uv = xpc_create_gru_mq_uv(XPC_ACTIVATE_MQ_SIZE_UV, 0,
1599 XPC_ACTIVATE_IRQ_NAME,
1600 xpc_handle_activate_IRQ_uv);
1601 if (IS_ERR(xpc_activate_mq_uv))
1602 return PTR_ERR(xpc_activate_mq_uv);
1603
1604 xpc_notify_mq_uv = xpc_create_gru_mq_uv(XPC_NOTIFY_MQ_SIZE_UV, 0,
1605 XPC_NOTIFY_IRQ_NAME,
1606 xpc_handle_notify_IRQ_uv);
1607 if (IS_ERR(xpc_notify_mq_uv)) {
1608 xpc_destroy_gru_mq_uv(xpc_activate_mq_uv);
1609 return PTR_ERR(xpc_notify_mq_uv);
1610 }
1611
1612 return 0;
1613 }
1614
1615 void
1616 xpc_exit_uv(void)
1617 {
1618 xpc_destroy_gru_mq_uv(xpc_notify_mq_uv);
1619 xpc_destroy_gru_mq_uv(xpc_activate_mq_uv);
1620 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree