SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/misc/sgi-gru/grukservices.c

   1 /*
   2  * SN Platform GRU Driver
   3  *
   4  *              KERNEL SERVICES THAT USE THE GRU
   5  *
   6  *  Copyright (c) 2008 Silicon Graphics, Inc.  All Rights Reserved.
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21  */
  22
  23 #include <linux/kernel.h>
  24 #include <linux/errno.h>
  25 #include <linux/slab.h>
  26 #include <linux/mm.h>
  27 #include <linux/smp_lock.h>
  28 #include <linux/spinlock.h>
  29 #include <linux/device.h>
  30 #include <linux/miscdevice.h>
  31 #include <linux/proc_fs.h>
  32 #include <linux/interrupt.h>
  33 #include <linux/uaccess.h>
  34 #include "gru.h"
  35 #include "grulib.h"
  36 #include "grutables.h"
  37 #include "grukservices.h"
  38 #include "gru_instructions.h"
  39 #include <asm/uv/uv_hub.h>
  40
  41 /*
  42  * Kernel GRU Usage
  43  *
  44  * The following is an interim algorithm for management of kernel GRU
  45  * resources. This will likely be replaced when we better understand the
  46  * kernel/user requirements.
  47  *
  48  * At boot time, the kernel permanently reserves a fixed number of
  49  * CBRs/DSRs for each cpu to use. The resources are all taken from
  50  * the GRU chiplet 1 on the blade. This leaves the full set of resources
  51  * of chiplet 0 available to be allocated to a single user.
  52  */
  53
  54 /* Blade percpu resources PERMANENTLY reserved for kernel use */
  55 #define GRU_NUM_KERNEL_CBR      1
  56 #define GRU_NUM_KERNEL_DSR_BYTES 256
  57 #define KERNEL_CTXNUM           15
  58
  59 /* GRU instruction attributes for all instructions */
  60 #define IMA                     IMA_CB_DELAY
  61
  62 /* GRU cacheline size is always 64 bytes - even on arches with 128 byte lines */
  63 #define __gru_cacheline_aligned__                               \
  64         __attribute__((__aligned__(GRU_CACHE_LINE_BYTES)))
  65
  66 #define MAGIC   0x1234567887654321UL
  67
  68 /* Default retry count for GRU errors on kernel instructions */
  69 #define EXCEPTION_RETRY_LIMIT   3
  70
  71 /* Status of message queue sections */
  72 #define MQS_EMPTY               0
  73 #define MQS_FULL                1
  74 #define MQS_NOOP                2
  75
  76 /*----------------- RESOURCE MANAGEMENT -------------------------------------*/
  77 /* optimized for x86_64 */
  78 struct message_queue {
  79         union gru_mesqhead      head __gru_cacheline_aligned__; /* CL 0 */
  80         int                     qlines;                         /* DW 1 */
  81         long                    hstatus[2];
  82         void                    *next __gru_cacheline_aligned__;/* CL 1 */
  83         void                    *limit;
  84         void                    *start;
  85         void                    *start2;
  86         char                    data ____cacheline_aligned;     /* CL 2 */
  87 };
  88
  89 /* First word in every message - used by mesq interface */
  90 struct message_header {
  91         char    present;
  92         char    present2;
  93         char    lines;
  94         char    fill;
  95 };
  96
  97 #define QLINES(mq)      ((mq) + offsetof(struct message_queue, qlines))
  98 #define HSTATUS(mq, h)  ((mq) + offsetof(struct message_queue, hstatus[h]))
  99
 100 static int gru_get_cpu_resources(int dsr_bytes, void **cb, void **dsr)
 101 {
 102         struct gru_blade_state *bs;
 103         int lcpu;
 104
 105         BUG_ON(dsr_bytes > GRU_NUM_KERNEL_DSR_BYTES);
 106         preempt_disable();
 107         bs = gru_base[uv_numa_blade_id()];
 108         lcpu = uv_blade_processor_id();
 109         *cb = bs->kernel_cb + lcpu * GRU_HANDLE_STRIDE;
 110         *dsr = bs->kernel_dsr + lcpu * GRU_NUM_KERNEL_DSR_BYTES;
 111         return 0;
 112 }
 113
 114 static void gru_free_cpu_resources(void *cb, void *dsr)
 115 {
 116         preempt_enable();
 117 }
 118
 119 int gru_get_cb_exception_detail(void *cb,
 120                 struct control_block_extended_exc_detail *excdet)
 121 {
 122         struct gru_control_block_extended *cbe;
 123
 124         cbe = get_cbe(GRUBASE(cb), get_cb_number(cb));
 125         prefetchw(cbe);         /* Harmless on hardware, required for emulator */
 126         excdet->opc = cbe->opccpy;
 127         excdet->exopc = cbe->exopccpy;
 128         excdet->ecause = cbe->ecause;
 129         excdet->exceptdet0 = cbe->idef1upd;
 130         excdet->exceptdet1 = cbe->idef3upd;
 131         return 0;
 132 }
 133
 134 char *gru_get_cb_exception_detail_str(int ret, void *cb,
 135                                       char *buf, int size)
 136 {
 137         struct gru_control_block_status *gen = (void *)cb;
 138         struct control_block_extended_exc_detail excdet;
 139
 140         if (ret > 0 && gen->istatus == CBS_EXCEPTION) {
 141                 gru_get_cb_exception_detail(cb, &excdet);
 142                 snprintf(buf, size,
 143                         "GRU exception: cb %p, opc %d, exopc %d, ecause 0x%x,"
 144                         "excdet0 0x%lx, excdet1 0x%x",
 145                         gen, excdet.opc, excdet.exopc, excdet.ecause,
 146                         excdet.exceptdet0, excdet.exceptdet1);
 147         } else {
 148                 snprintf(buf, size, "No exception");
 149         }
 150         return buf;
 151 }
 152
 153 static int gru_wait_idle_or_exception(struct gru_control_block_status *gen)
 154 {
 155         while (gen->istatus >= CBS_ACTIVE) {
 156                 cpu_relax();
 157                 barrier();
 158         }
 159         return gen->istatus;
 160 }
 161
 162 static int gru_retry_exception(void *cb)
 163 {
 164         struct gru_control_block_status *gen = (void *)cb;
 165         struct control_block_extended_exc_detail excdet;
 166         int retry = EXCEPTION_RETRY_LIMIT;
 167
 168         while (1)  {
 169                 if (gru_get_cb_message_queue_substatus(cb))
 170                         break;
 171                 if (gru_wait_idle_or_exception(gen) == CBS_IDLE)
 172                         return CBS_IDLE;
 173
 174                 gru_get_cb_exception_detail(cb, &excdet);
 175                 if (excdet.ecause & ~EXCEPTION_RETRY_BITS)
 176                         break;
 177                 if (retry-- == 0)
 178                         break;
 179                 gen->icmd = 1;
 180                 gru_flush_cache(gen);
 181         }
 182         return CBS_EXCEPTION;
 183 }
 184
 185 int gru_check_status_proc(void *cb)
 186 {
 187         struct gru_control_block_status *gen = (void *)cb;
 188         int ret;
 189
 190         ret = gen->istatus;
 191         if (ret != CBS_EXCEPTION)
 192                 return ret;
 193         return gru_retry_exception(cb);
 194
 195 }
 196
 197 int gru_wait_proc(void *cb)
 198 {
 199         struct gru_control_block_status *gen = (void *)cb;
 200         int ret;
 201
 202         ret = gru_wait_idle_or_exception(gen);
 203         if (ret == CBS_EXCEPTION)
 204                 ret = gru_retry_exception(cb);
 205
 206         return ret;
 207 }
 208
 209 void gru_abort(int ret, void *cb, char *str)
 210 {
 211         char buf[GRU_EXC_STR_SIZE];
 212
 213         panic("GRU FATAL ERROR: %s - %s\n", str,
 214               gru_get_cb_exception_detail_str(ret, cb, buf, sizeof(buf)));
 215 }
 216
 217 void gru_wait_abort_proc(void *cb)
 218 {
 219         int ret;
 220
 221         ret = gru_wait_proc(cb);
 222         if (ret)
 223                 gru_abort(ret, cb, "gru_wait_abort");
 224 }
 225
 226
 227 /*------------------------------ MESSAGE QUEUES -----------------------------*/
 228
 229 /* Internal status . These are NOT returned to the user. */
 230 #define MQIE_AGAIN              -1      /* try again */
 231
 232
 233 /*
 234  * Save/restore the "present" flag that is in the second line of 2-line
 235  * messages
 236  */
 237 static inline int get_present2(void *p)
 238 {
 239         struct message_header *mhdr = p + GRU_CACHE_LINE_BYTES;
 240         return mhdr->present;
 241 }
 242
 243 static inline void restore_present2(void *p, int val)
 244 {
 245         struct message_header *mhdr = p + GRU_CACHE_LINE_BYTES;
 246         mhdr->present = val;
 247 }
 248
 249 /*
 250  * Create a message queue.
 251  *      qlines - message queue size in cache lines. Includes 2-line header.
 252  */
 253 int gru_create_message_queue(void *p, unsigned int bytes)
 254 {
 255         struct message_queue *mq = p;
 256         unsigned int qlines;
 257
 258         qlines = bytes / GRU_CACHE_LINE_BYTES - 2;
 259         memset(mq, 0, bytes);
 260         mq->start = &mq->data;
 261         mq->start2 = &mq->data + (qlines / 2 - 1) * GRU_CACHE_LINE_BYTES;
 262         mq->next = &mq->data;
 263         mq->limit = &mq->data + (qlines - 2) * GRU_CACHE_LINE_BYTES;
 264         mq->qlines = qlines;
 265         mq->hstatus[0] = 0;
 266         mq->hstatus[1] = 1;
 267         mq->head = gru_mesq_head(2, qlines / 2 + 1);
 268         return 0;
 269 }
 270 EXPORT_SYMBOL_GPL(gru_create_message_queue);
 271
 272 /*
 273  * Send a NOOP message to a message queue
 274  *      Returns:
 275  *               0 - if queue is full after the send. This is the normal case
 276  *                   but various races can change this.
 277  *              -1 - if mesq sent successfully but queue not full
 278  *              >0 - unexpected error. MQE_xxx returned
 279  */
 280 static int send_noop_message(void *cb,
 281                                 unsigned long mq, void *mesg)
 282 {
 283         const struct message_header noop_header = {
 284                                         .present = MQS_NOOP, .lines = 1};
 285         unsigned long m;
 286         int substatus, ret;
 287         struct message_header save_mhdr, *mhdr = mesg;
 288
 289         STAT(mesq_noop);
 290         save_mhdr = *mhdr;
 291         *mhdr = noop_header;
 292         gru_mesq(cb, mq, gru_get_tri(mhdr), 1, IMA);
 293         ret = gru_wait(cb);
 294
 295         if (ret) {
 296                 substatus = gru_get_cb_message_queue_substatus(cb);
 297                 switch (substatus) {
 298                 case CBSS_NO_ERROR:
 299                         STAT(mesq_noop_unexpected_error);
 300                         ret = MQE_UNEXPECTED_CB_ERR;
 301                         break;
 302                 case CBSS_LB_OVERFLOWED:
 303                         STAT(mesq_noop_lb_overflow);
 304                         ret = MQE_CONGESTION;
 305                         break;
 306                 case CBSS_QLIMIT_REACHED:
 307                         STAT(mesq_noop_qlimit_reached);
 308                         ret = 0;
 309                         break;
 310                 case CBSS_AMO_NACKED:
 311                         STAT(mesq_noop_amo_nacked);
 312                         ret = MQE_CONGESTION;
 313                         break;
 314                 case CBSS_PUT_NACKED:
 315                         STAT(mesq_noop_put_nacked);
 316                         m = mq + (gru_get_amo_value_head(cb) << 6);
 317                         gru_vstore(cb, m, gru_get_tri(mesg), XTYPE_CL, 1, 1,
 318                                                 IMA);
 319                         if (gru_wait(cb) == CBS_IDLE)
 320                                 ret = MQIE_AGAIN;
 321                         else
 322                                 ret = MQE_UNEXPECTED_CB_ERR;
 323                         break;
 324                 case CBSS_PAGE_OVERFLOW:
 325                 default:
 326                         BUG();
 327                 }
 328         }
 329         *mhdr = save_mhdr;
 330         return ret;
 331 }
 332
 333 /*
 334  * Handle a gru_mesq full.
 335  */
 336 static int send_message_queue_full(void *cb,
 337                            unsigned long mq, void *mesg, int lines)
 338 {
 339         union gru_mesqhead mqh;
 340         unsigned int limit, head;
 341         unsigned long avalue;
 342         int half, qlines, save;
 343
 344         /* Determine if switching to first/second half of q */
 345         avalue = gru_get_amo_value(cb);
 346         head = gru_get_amo_value_head(cb);
 347         limit = gru_get_amo_value_limit(cb);
 348
 349         /*
 350          * Fetch "qlines" from the queue header. Since the queue may be
 351          * in memory that can't be accessed using socket addresses, use
 352          * the GRU to access the data. Use DSR space from the message.
 353          */
 354         save = *(int *)mesg;
 355         gru_vload(cb, QLINES(mq), gru_get_tri(mesg), XTYPE_W, 1, 1, IMA);
 356         if (gru_wait(cb) != CBS_IDLE)
 357                 goto cberr;
 358         qlines = *(int *)mesg;
 359         *(int *)mesg = save;
 360         half = (limit != qlines);
 361
 362         if (half)
 363                 mqh = gru_mesq_head(qlines / 2 + 1, qlines);
 364         else
 365                 mqh = gru_mesq_head(2, qlines / 2 + 1);
 366
 367         /* Try to get lock for switching head pointer */
 368         gru_gamir(cb, EOP_IR_CLR, HSTATUS(mq, half), XTYPE_DW, IMA);
 369         if (gru_wait(cb) != CBS_IDLE)
 370                 goto cberr;
 371         if (!gru_get_amo_value(cb)) {
 372                 STAT(mesq_qf_locked);
 373                 return MQE_QUEUE_FULL;
 374         }
 375
 376         /* Got the lock. Send optional NOP if queue not full, */
 377         if (head != limit) {
 378                 if (send_noop_message(cb, mq, mesg)) {
 379                         gru_gamir(cb, EOP_IR_INC, HSTATUS(mq, half),
 380                                         XTYPE_DW, IMA);
 381                         if (gru_wait(cb) != CBS_IDLE)
 382                                 goto cberr;
 383                         STAT(mesq_qf_noop_not_full);
 384                         return MQIE_AGAIN;
 385                 }
 386                 avalue++;
 387         }
 388
 389         /* Then flip queuehead to other half of queue. */
 390         gru_gamer(cb, EOP_ERR_CSWAP, mq, XTYPE_DW, mqh.val, avalue, IMA);
 391         if (gru_wait(cb) != CBS_IDLE)
 392                 goto cberr;
 393
 394         /* If not successfully in swapping queue head, clear the hstatus lock */
 395         if (gru_get_amo_value(cb) != avalue) {
 396                 STAT(mesq_qf_switch_head_failed);
 397                 gru_gamir(cb, EOP_IR_INC, HSTATUS(mq, half), XTYPE_DW, IMA);
 398                 if (gru_wait(cb) != CBS_IDLE)
 399                         goto cberr;
 400         }
 401         return MQIE_AGAIN;
 402 cberr:
 403         STAT(mesq_qf_unexpected_error);
 404         return MQE_UNEXPECTED_CB_ERR;
 405 }
 406
 407
 408 /*
 409  * Handle a gru_mesq failure. Some of these failures are software recoverable
 410  * or retryable.
 411  */
 412 static int send_message_failure(void *cb,
 413                                 unsigned long mq,
 414                                 void *mesg,
 415                                 int lines)
 416 {
 417         int substatus, ret = 0;
 418         unsigned long m;
 419
 420         substatus = gru_get_cb_message_queue_substatus(cb);
 421         switch (substatus) {
 422         case CBSS_NO_ERROR:
 423                 STAT(mesq_send_unexpected_error);
 424                 ret = MQE_UNEXPECTED_CB_ERR;
 425                 break;
 426         case CBSS_LB_OVERFLOWED:
 427                 STAT(mesq_send_lb_overflow);
 428                 ret = MQE_CONGESTION;
 429                 break;
 430         case CBSS_QLIMIT_REACHED:
 431                 STAT(mesq_send_qlimit_reached);
 432                 ret = send_message_queue_full(cb, mq, mesg, lines);
 433                 break;
 434         case CBSS_AMO_NACKED:
 435                 STAT(mesq_send_amo_nacked);
 436                 ret = MQE_CONGESTION;
 437                 break;
 438         case CBSS_PUT_NACKED:
 439                 STAT(mesq_send_put_nacked);
 440                 m =mq + (gru_get_amo_value_head(cb) << 6);
 441                 gru_vstore(cb, m, gru_get_tri(mesg), XTYPE_CL, lines, 1, IMA);
 442                 if (gru_wait(cb) == CBS_IDLE)
 443                         ret = MQE_OK;
 444                 else
 445                         ret = MQE_UNEXPECTED_CB_ERR;
 446                 break;
 447         default:
 448                 BUG();
 449         }
 450         return ret;
 451 }
 452
 453 /*
 454  * Send a message to a message queue
 455  *      cb      GRU control block to use to send message
 456  *      mq      message queue
 457  *      mesg    message. ust be vaddr within a GSEG
 458  *      bytes   message size (<= 2 CL)
 459  */
 460 int gru_send_message_gpa(unsigned long mq, void *mesg, unsigned int bytes)
 461 {
 462         struct message_header *mhdr;
 463         void *cb;
 464         void *dsr;
 465         int istatus, clines, ret;
 466
 467         STAT(mesq_send);
 468         BUG_ON(bytes < sizeof(int) || bytes > 2 * GRU_CACHE_LINE_BYTES);
 469
 470         clines = DIV_ROUND_UP(bytes, GRU_CACHE_LINE_BYTES);
 471         if (gru_get_cpu_resources(bytes, &cb, &dsr))
 472                 return MQE_BUG_NO_RESOURCES;
 473         memcpy(dsr, mesg, bytes);
 474         mhdr = dsr;
 475         mhdr->present = MQS_FULL;
 476         mhdr->lines = clines;
 477         if (clines == 2) {
 478                 mhdr->present2 = get_present2(mhdr);
 479                 restore_present2(mhdr, MQS_FULL);
 480         }
 481
 482         do {
 483                 ret = MQE_OK;
 484                 gru_mesq(cb, mq, gru_get_tri(mhdr), clines, IMA);
 485                 istatus = gru_wait(cb);
 486                 if (istatus != CBS_IDLE)
 487                         ret = send_message_failure(cb, mq, dsr, clines);
 488         } while (ret == MQIE_AGAIN);
 489         gru_free_cpu_resources(cb, dsr);
 490
 491         if (ret)
 492                 STAT(mesq_send_failed);
 493         return ret;
 494 }
 495 EXPORT_SYMBOL_GPL(gru_send_message_gpa);
 496
 497 /*
 498  * Advance the receive pointer for the queue to the next message.
 499  */
 500 void gru_free_message(void *rmq, void *mesg)
 501 {
 502         struct message_queue *mq = rmq;
 503         struct message_header *mhdr = mq->next;
 504         void *next, *pnext;
 505         int half = -1;
 506         int lines = mhdr->lines;
 507
 508         if (lines == 2)
 509                 restore_present2(mhdr, MQS_EMPTY);
 510         mhdr->present = MQS_EMPTY;
 511
 512         pnext = mq->next;
 513         next = pnext + GRU_CACHE_LINE_BYTES * lines;
 514         if (next == mq->limit) {
 515                 next = mq->start;
 516                 half = 1;
 517         } else if (pnext < mq->start2 && next >= mq->start2) {
 518                 half = 0;
 519         }
 520
 521         if (half >= 0)
 522                 mq->hstatus[half] = 1;
 523         mq->next = next;
 524 }
 525 EXPORT_SYMBOL_GPL(gru_free_message);
 526
 527 /*
 528  * Get next message from message queue. Return NULL if no message
 529  * present. User must call next_message() to move to next message.
 530  *      rmq     message queue
 531  */
 532 void *gru_get_next_message(void *rmq)
 533 {
 534         struct message_queue *mq = rmq;
 535         struct message_header *mhdr = mq->next;
 536         int present = mhdr->present;
 537
 538         /* skip NOOP messages */
 539         STAT(mesq_receive);
 540         while (present == MQS_NOOP) {
 541                 gru_free_message(rmq, mhdr);
 542                 mhdr = mq->next;
 543                 present = mhdr->present;
 544         }
 545
 546         /* Wait for both halves of 2 line messages */
 547         if (present == MQS_FULL && mhdr->lines == 2 &&
 548                                 get_present2(mhdr) == MQS_EMPTY)
 549                 present = MQS_EMPTY;
 550
 551         if (!present) {
 552                 STAT(mesq_receive_none);
 553                 return NULL;
 554         }
 555
 556         if (mhdr->lines == 2)
 557                 restore_present2(mhdr, mhdr->present2);
 558
 559         return mhdr;
 560 }
 561 EXPORT_SYMBOL_GPL(gru_get_next_message);
 562
 563 /* ---------------------- GRU DATA COPY FUNCTIONS ---------------------------*/
 564
 565 /*
 566  * Copy a block of data using the GRU resources
 567  */
 568 int gru_copy_gpa(unsigned long dest_gpa, unsigned long src_gpa,
 569                                 unsigned int bytes)
 570 {
 571         void *cb;
 572         void *dsr;
 573         int ret;
 574
 575         STAT(copy_gpa);
 576         if (gru_get_cpu_resources(GRU_NUM_KERNEL_DSR_BYTES, &cb, &dsr))
 577                 return MQE_BUG_NO_RESOURCES;
 578         gru_bcopy(cb, src_gpa, dest_gpa, gru_get_tri(dsr),
 579                   XTYPE_B, bytes, GRU_NUM_KERNEL_DSR_BYTES, IMA);
 580         ret = gru_wait(cb);
 581         gru_free_cpu_resources(cb, dsr);
 582         return ret;
 583 }
 584 EXPORT_SYMBOL_GPL(gru_copy_gpa);
 585
 586 /* ------------------- KERNEL QUICKTESTS RUN AT STARTUP ----------------*/
 587 /*      Temp - will delete after we gain confidence in the GRU          */
 588 static __cacheline_aligned unsigned long word0;
 589 static __cacheline_aligned unsigned long word1;
 590
 591 static int quicktest(struct gru_state *gru)
 592 {
 593         void *cb;
 594         void *ds;
 595         unsigned long *p;
 596
 597         cb = get_gseg_base_address_cb(gru->gs_gru_base_vaddr, KERNEL_CTXNUM, 0);
 598         ds = get_gseg_base_address_ds(gru->gs_gru_base_vaddr, KERNEL_CTXNUM, 0);
 599         p = ds;
 600         word0 = MAGIC;
 601
 602         gru_vload(cb, uv_gpa(&word0), 0, XTYPE_DW, 1, 1, IMA);
 603         if (gru_wait(cb) != CBS_IDLE)
 604                 BUG();
 605
 606         if (*(unsigned long *)ds != MAGIC)
 607                 BUG();
 608         gru_vstore(cb, uv_gpa(&word1), 0, XTYPE_DW, 1, 1, IMA);
 609         if (gru_wait(cb) != CBS_IDLE)
 610                 BUG();
 611
 612         if (word0 != word1 || word0 != MAGIC) {
 613                 printk
 614                     ("GRU quicktest err: gru %d, found 0x%lx, expected 0x%lx\n",
 615                      gru->gs_gid, word1, MAGIC);
 616                 BUG();          /* ZZZ should not be fatal */
 617         }
 618
 619         return 0;
 620 }
 621
 622
 623 int gru_kservices_init(struct gru_state *gru)
 624 {
 625         struct gru_blade_state *bs;
 626         struct gru_context_configuration_handle *cch;
 627         unsigned long cbr_map, dsr_map;
 628         int err, num, cpus_possible;
 629
 630         /*
 631          * Currently, resources are reserved ONLY on the second chiplet
 632          * on each blade. This leaves ALL resources on chiplet 0 available
 633          * for user code.
 634          */
 635         bs = gru->gs_blade;
 636         if (gru != &bs->bs_grus[1])
 637                 return 0;
 638
 639         cpus_possible = uv_blade_nr_possible_cpus(gru->gs_blade_id);
 640
 641         num = GRU_NUM_KERNEL_CBR * cpus_possible;
 642         cbr_map = gru_reserve_cb_resources(gru, GRU_CB_COUNT_TO_AU(num), NULL);
 643         gru->gs_reserved_cbrs += num;
 644
 645         num = GRU_NUM_KERNEL_DSR_BYTES * cpus_possible;
 646         dsr_map = gru_reserve_ds_resources(gru, GRU_DS_BYTES_TO_AU(num), NULL);
 647         gru->gs_reserved_dsr_bytes += num;
 648
 649         gru->gs_active_contexts++;
 650         __set_bit(KERNEL_CTXNUM, &gru->gs_context_map);
 651         cch = get_cch(gru->gs_gru_base_vaddr, KERNEL_CTXNUM);
 652
 653         bs->kernel_cb = get_gseg_base_address_cb(gru->gs_gru_base_vaddr,
 654                                         KERNEL_CTXNUM, 0);
 655         bs->kernel_dsr = get_gseg_base_address_ds(gru->gs_gru_base_vaddr,
 656                                         KERNEL_CTXNUM, 0);
 657
 658         lock_cch_handle(cch);
 659         cch->tfm_fault_bit_enable = 0;
 660         cch->tlb_int_enable = 0;
 661         cch->tfm_done_bit_enable = 0;
 662         cch->unmap_enable = 1;
 663         err = cch_allocate(cch, 0, cbr_map, dsr_map);
 664         if (err) {
 665                 gru_dbg(grudev,
 666                         "Unable to allocate kernel CCH: gru %d, err %d\n",
 667                         gru->gs_gid, err);
 668                 BUG();
 669         }
 670         if (cch_start(cch)) {
 671                 gru_dbg(grudev, "Unable to start kernel CCH: gru %d, err %d\n",
 672                         gru->gs_gid, err);
 673                 BUG();
 674         }
 675         unlock_cch_handle(cch);
 676
 677         if (gru_options & GRU_QUICKLOOK)
 678                 quicktest(gru);
 679         return 0;
 680 }