arch/sparc64/kernel/ds.c

   1 /* ds.c: Domain Services driver for Logical Domains
   2  *
   3  * Copyright (C) 2007 David S. Miller <davem@davemloft.net>
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/module.h>
   8 #include <linux/types.h>
   9 #include <linux/module.h>
  10 #include <linux/string.h>
  11 #include <linux/slab.h>
  12 #include <linux/sched.h>
  13 #include <linux/delay.h>
  14 #include <linux/mutex.h>
  15 #include <linux/workqueue.h>
  16 #include <linux/cpu.h>
  17
  18 #include <asm/ldc.h>
  19 #include <asm/vio.h>
  20 #include <asm/power.h>
  21 #include <asm/mdesc.h>
  22 #include <asm/head.h>
  23 #include <asm/io.h>
  24 #include <asm/hvtramp.h>
  25
  26 #define DRV_MODULE_NAME         "ds"
  27 #define PFX DRV_MODULE_NAME     ": "
  28 #define DRV_MODULE_VERSION      "1.0"
  29 #define DRV_MODULE_RELDATE      "Jul 11, 2007"
  30
  31 static char version[] __devinitdata =
  32         DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
  33 MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
  34 MODULE_DESCRIPTION("Sun LDOM domain services driver");
  35 MODULE_LICENSE("GPL");
  36 MODULE_VERSION(DRV_MODULE_VERSION);
  37
  38 struct ds_msg_tag {
  39         __u32                   type;
  40 #define DS_INIT_REQ             0x00
  41 #define DS_INIT_ACK             0x01
  42 #define DS_INIT_NACK            0x02
  43 #define DS_REG_REQ              0x03
  44 #define DS_REG_ACK              0x04
  45 #define DS_REG_NACK             0x05
  46 #define DS_UNREG_REQ            0x06
  47 #define DS_UNREG_ACK            0x07
  48 #define DS_UNREG_NACK           0x08
  49 #define DS_DATA                 0x09
  50 #define DS_NACK                 0x0a
  51
  52         __u32                   len;
  53 };
  54
  55 /* Result codes */
  56 #define DS_OK                   0x00
  57 #define DS_REG_VER_NACK         0x01
  58 #define DS_REG_DUP              0x02
  59 #define DS_INV_HDL              0x03
  60 #define DS_TYPE_UNKNOWN         0x04
  61
  62 struct ds_version {
  63         __u16                   major;
  64         __u16                   minor;
  65 };
  66
  67 struct ds_ver_req {
  68         struct ds_msg_tag       tag;
  69         struct ds_version       ver;
  70 };
  71
  72 struct ds_ver_ack {
  73         struct ds_msg_tag       tag;
  74         __u16                   minor;
  75 };
  76
  77 struct ds_ver_nack {
  78         struct ds_msg_tag       tag;
  79         __u16                   major;
  80 };
  81
  82 struct ds_reg_req {
  83         struct ds_msg_tag       tag;
  84         __u64                   handle;
  85         __u16                   major;
  86         __u16                   minor;
  87         char                    svc_id[0];
  88 };
  89
  90 struct ds_reg_ack {
  91         struct ds_msg_tag       tag;
  92         __u64                   handle;
  93         __u16                   minor;
  94 };
  95
  96 struct ds_reg_nack {
  97         struct ds_msg_tag       tag;
  98         __u64                   handle;
  99         __u16                   major;
 100 };
 101
 102 struct ds_unreg_req {
 103         struct ds_msg_tag       tag;
 104         __u64                   handle;
 105 };
 106
 107 struct ds_unreg_ack {
 108         struct ds_msg_tag       tag;
 109         __u64                   handle;
 110 };
 111
 112 struct ds_unreg_nack {
 113         struct ds_msg_tag       tag;
 114         __u64                   handle;
 115 };
 116
 117 struct ds_data {
 118         struct ds_msg_tag       tag;
 119         __u64                   handle;
 120 };
 121
 122 struct ds_data_nack {
 123         struct ds_msg_tag       tag;
 124         __u64                   handle;
 125         __u64                   result;
 126 };
 127
 128 struct ds_cap_state {
 129         __u64                   handle;
 130
 131         void                    (*data)(struct ldc_channel *lp,
 132                                         struct ds_cap_state *cp,
 133                                         void *buf, int len);
 134
 135         const char              *service_id;
 136
 137         u8                      state;
 138 #define CAP_STATE_UNKNOWN       0x00
 139 #define CAP_STATE_REG_SENT      0x01
 140 #define CAP_STATE_REGISTERED    0x02
 141 };
 142
 143 static void md_update_data(struct ldc_channel *lp, struct ds_cap_state *cp,
 144                            void *buf, int len);
 145 static void domain_shutdown_data(struct ldc_channel *lp,
 146                                  struct ds_cap_state *cp,
 147                                  void *buf, int len);
 148 static void domain_panic_data(struct ldc_channel *lp,
 149                               struct ds_cap_state *cp,
 150                               void *buf, int len);
 151 static void dr_cpu_data(struct ldc_channel *lp,
 152                         struct ds_cap_state *cp,
 153                         void *buf, int len);
 154 static void ds_pri_data(struct ldc_channel *lp,
 155                         struct ds_cap_state *cp,
 156                         void *buf, int len);
 157 static void ds_var_data(struct ldc_channel *lp,
 158                         struct ds_cap_state *cp,
 159                         void *buf, int len);
 160
 161 struct ds_cap_state ds_states[] = {
 162         {
 163                 .service_id     = "md-update",
 164                 .data           = md_update_data,
 165         },
 166         {
 167                 .service_id     = "domain-shutdown",
 168                 .data           = domain_shutdown_data,
 169         },
 170         {
 171                 .service_id     = "domain-panic",
 172                 .data           = domain_panic_data,
 173         },
 174         {
 175                 .service_id     = "dr-cpu",
 176                 .data           = dr_cpu_data,
 177         },
 178         {
 179                 .service_id     = "pri",
 180                 .data           = ds_pri_data,
 181         },
 182         {
 183                 .service_id     = "var-config",
 184                 .data           = ds_var_data,
 185         },
 186         {
 187                 .service_id     = "var-config-backup",
 188                 .data           = ds_var_data,
 189         },
 190 };
 191
 192 static DEFINE_SPINLOCK(ds_lock);
 193
 194 struct ds_info {
 195         struct ldc_channel      *lp;
 196         u8                      hs_state;
 197 #define DS_HS_START             0x01
 198 #define DS_HS_DONE              0x02
 199
 200         void                    *rcv_buf;
 201         int                     rcv_buf_len;
 202 };
 203
 204 static struct ds_info *ds_info;
 205
 206 static struct ds_cap_state *find_cap(u64 handle)
 207 {
 208         unsigned int index = handle >> 32;
 209
 210         if (index >= ARRAY_SIZE(ds_states))
 211                 return NULL;
 212         return &ds_states[index];
 213 }
 214
 215 static struct ds_cap_state *find_cap_by_string(const char *name)
 216 {
 217         int i;
 218
 219         for (i = 0; i < ARRAY_SIZE(ds_states); i++) {
 220                 if (strcmp(ds_states[i].service_id, name))
 221                         continue;
 222
 223                 return &ds_states[i];
 224         }
 225         return NULL;
 226 }
 227
 228 static int ds_send(struct ldc_channel *lp, void *data, int len)
 229 {
 230         int err, limit = 1000;
 231
 232         err = -EINVAL;
 233         while (limit-- > 0) {
 234                 err = ldc_write(lp, data, len);
 235                 if (!err || (err != -EAGAIN))
 236                         break;
 237                 udelay(1);
 238         }
 239
 240         return err;
 241 }
 242
 243 struct ds_md_update_req {
 244         __u64                           req_num;
 245 };
 246
 247 struct ds_md_update_res {
 248         __u64                           req_num;
 249         __u32                           result;
 250 };
 251
 252 static void md_update_data(struct ldc_channel *lp,
 253                            struct ds_cap_state *dp,
 254                            void *buf, int len)
 255 {
 256         struct ds_data *dpkt = buf;
 257         struct ds_md_update_req *rp;
 258         struct {
 259                 struct ds_data          data;
 260                 struct ds_md_update_res res;
 261         } pkt;
 262
 263         rp = (struct ds_md_update_req *) (dpkt + 1);
 264
 265         printk(KERN_INFO PFX "Machine description update.\n");
 266
 267         memset(&pkt, 0, sizeof(pkt));
 268         pkt.data.tag.type = DS_DATA;
 269         pkt.data.tag.len = sizeof(pkt) - sizeof(struct ds_msg_tag);
 270         pkt.data.handle = dp->handle;
 271         pkt.res.req_num = rp->req_num;
 272         pkt.res.result = DS_OK;
 273
 274         ds_send(lp, &pkt, sizeof(pkt));
 275
 276         mdesc_update();
 277 }
 278
 279 struct ds_shutdown_req {
 280         __u64                           req_num;
 281         __u32                           ms_delay;
 282 };
 283
 284 struct ds_shutdown_res {
 285         __u64                           req_num;
 286         __u32                           result;
 287         char                            reason[1];
 288 };
 289
 290 static void domain_shutdown_data(struct ldc_channel *lp,
 291                                  struct ds_cap_state *dp,
 292                                  void *buf, int len)
 293 {
 294         struct ds_data *dpkt = buf;
 295         struct ds_shutdown_req *rp;
 296         struct {
 297                 struct ds_data          data;
 298                 struct ds_shutdown_res  res;
 299         } pkt;
 300
 301         rp = (struct ds_shutdown_req *) (dpkt + 1);
 302
 303         printk(KERN_ALERT PFX "Shutdown request from "
 304                "LDOM manager received.\n");
 305
 306         memset(&pkt, 0, sizeof(pkt));
 307         pkt.data.tag.type = DS_DATA;
 308         pkt.data.tag.len = sizeof(pkt) - sizeof(struct ds_msg_tag);
 309         pkt.data.handle = dp->handle;
 310         pkt.res.req_num = rp->req_num;
 311         pkt.res.result = DS_OK;
 312         pkt.res.reason[0] = 0;
 313
 314         ds_send(lp, &pkt, sizeof(pkt));
 315
 316         wake_up_powerd();
 317 }
 318
 319 struct ds_panic_req {
 320         __u64                           req_num;
 321 };
 322
 323 struct ds_panic_res {
 324         __u64                           req_num;
 325         __u32                           result;
 326         char                            reason[1];
 327 };
 328
 329 static void domain_panic_data(struct ldc_channel *lp,
 330                               struct ds_cap_state *dp,
 331                               void *buf, int len)
 332 {
 333         struct ds_data *dpkt = buf;
 334         struct ds_panic_req *rp;
 335         struct {
 336                 struct ds_data          data;
 337                 struct ds_panic_res     res;
 338         } pkt;
 339
 340         rp = (struct ds_panic_req *) (dpkt + 1);
 341
 342         printk(KERN_ALERT PFX "Panic request from "
 343                "LDOM manager received.\n");
 344
 345         memset(&pkt, 0, sizeof(pkt));
 346         pkt.data.tag.type = DS_DATA;
 347         pkt.data.tag.len = sizeof(pkt) - sizeof(struct ds_msg_tag);
 348         pkt.data.handle = dp->handle;
 349         pkt.res.req_num = rp->req_num;
 350         pkt.res.result = DS_OK;
 351         pkt.res.reason[0] = 0;
 352
 353         ds_send(lp, &pkt, sizeof(pkt));
 354
 355         panic("PANIC requested by LDOM manager.");
 356 }
 357
 358 struct dr_cpu_tag {
 359         __u64                           req_num;
 360         __u32                           type;
 361 #define DR_CPU_CONFIGURE                0x43
 362 #define DR_CPU_UNCONFIGURE              0x55
 363 #define DR_CPU_FORCE_UNCONFIGURE        0x46
 364 #define DR_CPU_STATUS                   0x53
 365
 366 /* Responses */
 367 #define DR_CPU_OK                       0x6f
 368 #define DR_CPU_ERROR                    0x65
 369
 370         __u32                           num_records;
 371 };
 372
 373 struct dr_cpu_resp_entry {
 374         __u32                           cpu;
 375         __u32                           result;
 376 #define DR_CPU_RES_OK                   0x00
 377 #define DR_CPU_RES_FAILURE              0x01
 378 #define DR_CPU_RES_BLOCKED              0x02
 379 #define DR_CPU_RES_CPU_NOT_RESPONDING   0x03
 380 #define DR_CPU_RES_NOT_IN_MD            0x04
 381
 382         __u32                           stat;
 383 #define DR_CPU_STAT_NOT_PRESENT         0x00
 384 #define DR_CPU_STAT_UNCONFIGURED        0x01
 385 #define DR_CPU_STAT_CONFIGURED          0x02
 386
 387         __u32                           str_off;
 388 };
 389
 390 /* XXX Put this in some common place. XXX */
 391 static unsigned long kimage_addr_to_ra(void *p)
 392 {
 393         unsigned long val = (unsigned long) p;
 394
 395         return kern_base + (val - KERNBASE);
 396 }
 397
 398 void ldom_startcpu_cpuid(unsigned int cpu, unsigned long thread_reg)
 399 {
 400         extern unsigned long sparc64_ttable_tl0;
 401         extern unsigned long kern_locked_tte_data;
 402         extern int bigkernel;
 403         struct hvtramp_descr *hdesc;
 404         unsigned long trampoline_ra;
 405         struct trap_per_cpu *tb;
 406         u64 tte_vaddr, tte_data;
 407         unsigned long hv_err;
 408
 409         hdesc = kzalloc(sizeof(*hdesc), GFP_KERNEL);
 410         if (!hdesc) {
 411                 printk(KERN_ERR PFX "ldom_startcpu_cpuid: Cannot allocate "
 412                        "hvtramp_descr.\n");
 413                 return;
 414         }
 415
 416         hdesc->cpu = cpu;
 417         hdesc->num_mappings = (bigkernel ? 2 : 1);
 418
 419         tb = &trap_block[cpu];
 420         tb->hdesc = hdesc;
 421
 422         hdesc->fault_info_va = (unsigned long) &tb->fault_info;
 423         hdesc->fault_info_pa = kimage_addr_to_ra(&tb->fault_info);
 424
 425         hdesc->thread_reg = thread_reg;
 426
 427         tte_vaddr = (unsigned long) KERNBASE;
 428         tte_data = kern_locked_tte_data;
 429
 430         hdesc->maps[0].vaddr = tte_vaddr;
 431         hdesc->maps[0].tte   = tte_data;
 432         if (bigkernel) {
 433                 tte_vaddr += 0x400000;
 434                 tte_data  += 0x400000;
 435                 hdesc->maps[1].vaddr = tte_vaddr;
 436                 hdesc->maps[1].tte   = tte_data;
 437         }
 438
 439         trampoline_ra = kimage_addr_to_ra(hv_cpu_startup);
 440
 441         hv_err = sun4v_cpu_start(cpu, trampoline_ra,
 442                                  kimage_addr_to_ra(&sparc64_ttable_tl0),
 443                                  __pa(hdesc));
 444 }
 445
 446 /* DR cpu requests get queued onto the work list by the
 447  * dr_cpu_data() callback.  The list is protected by
 448  * ds_lock, and processed by dr_cpu_process() in order.
 449  */
 450 static LIST_HEAD(dr_cpu_work_list);
 451
 452 struct dr_cpu_queue_entry {
 453         struct list_head                list;
 454         char                            req[0];
 455 };
 456
 457 static void __dr_cpu_send_error(struct ds_cap_state *cp, struct ds_data *data)
 458 {
 459         struct dr_cpu_tag *tag = (struct dr_cpu_tag *) (data + 1);
 460         struct ds_info *dp = ds_info;
 461         struct {
 462                 struct ds_data          data;
 463                 struct dr_cpu_tag       tag;
 464         } pkt;
 465         int msg_len;
 466
 467         memset(&pkt, 0, sizeof(pkt));
 468         pkt.data.tag.type = DS_DATA;
 469         pkt.data.handle = cp->handle;
 470         pkt.tag.req_num = tag->req_num;
 471         pkt.tag.type = DR_CPU_ERROR;
 472         pkt.tag.num_records = 0;
 473
 474         msg_len = (sizeof(struct ds_data) +
 475                    sizeof(struct dr_cpu_tag));
 476
 477         pkt.data.tag.len = msg_len - sizeof(struct ds_msg_tag);
 478
 479         ds_send(dp->lp, &pkt, msg_len);
 480 }
 481
 482 static void dr_cpu_send_error(struct ds_cap_state *cp, struct ds_data *data)
 483 {
 484         unsigned long flags;
 485
 486         spin_lock_irqsave(&ds_lock, flags);
 487         __dr_cpu_send_error(cp, data);
 488         spin_unlock_irqrestore(&ds_lock, flags);
 489 }
 490
 491 #define CPU_SENTINEL    0xffffffff
 492
 493 static void purge_dups(u32 *list, u32 num_ents)
 494 {
 495         unsigned int i;
 496
 497         for (i = 0; i < num_ents; i++) {
 498                 u32 cpu = list[i];
 499                 unsigned int j;
 500
 501                 if (cpu == CPU_SENTINEL)
 502                         continue;
 503
 504                 for (j = i + 1; j < num_ents; j++) {
 505                         if (list[j] == cpu)
 506                                 list[j] = CPU_SENTINEL;
 507                 }
 508         }
 509 }
 510
 511 static int dr_cpu_size_response(int ncpus)
 512 {
 513         return (sizeof(struct ds_data) +
 514                 sizeof(struct dr_cpu_tag) +
 515                 (sizeof(struct dr_cpu_resp_entry) * ncpus));
 516 }
 517
 518 static void dr_cpu_init_response(struct ds_data *resp, u64 req_num,
 519                                  u64 handle, int resp_len, int ncpus,
 520                                  cpumask_t *mask, u32 default_stat)
 521 {
 522         struct dr_cpu_resp_entry *ent;
 523         struct dr_cpu_tag *tag;
 524         int i, cpu;
 525
 526         tag = (struct dr_cpu_tag *) (resp + 1);
 527         ent = (struct dr_cpu_resp_entry *) (tag + 1);
 528
 529         resp->tag.type = DS_DATA;
 530         resp->tag.len = resp_len - sizeof(struct ds_msg_tag);
 531         resp->handle = handle;
 532         tag->req_num = req_num;
 533         tag->type = DR_CPU_OK;
 534         tag->num_records = ncpus;
 535
 536         i = 0;
 537         for_each_cpu_mask(cpu, *mask) {
 538                 ent[i].cpu = cpu;
 539                 ent[i].result = DR_CPU_RES_OK;
 540                 ent[i].stat = default_stat;
 541                 i++;
 542         }
 543         BUG_ON(i != ncpus);
 544 }
 545
 546 static void dr_cpu_mark(struct ds_data *resp, int cpu, int ncpus,
 547                         u32 res, u32 stat)
 548 {
 549         struct dr_cpu_resp_entry *ent;
 550         struct dr_cpu_tag *tag;
 551         int i;
 552
 553         tag = (struct dr_cpu_tag *) (resp + 1);
 554         ent = (struct dr_cpu_resp_entry *) (tag + 1);
 555
 556         for (i = 0; i < ncpus; i++) {
 557                 if (ent[i].cpu != cpu)
 558                         continue;
 559                 ent[i].result = res;
 560                 ent[i].stat = stat;
 561                 break;
 562         }
 563 }
 564
 565 static int dr_cpu_configure(struct ds_cap_state *cp, u64 req_num,
 566                             cpumask_t *mask)
 567 {
 568         struct ds_data *resp;
 569         int resp_len, ncpus, cpu;
 570         unsigned long flags;
 571
 572         ncpus = cpus_weight(*mask);
 573         resp_len = dr_cpu_size_response(ncpus);
 574         resp = kzalloc(resp_len, GFP_KERNEL);
 575         if (!resp)
 576                 return -ENOMEM;
 577
 578         dr_cpu_init_response(resp, req_num, cp->handle,
 579                              resp_len, ncpus, mask,
 580                              DR_CPU_STAT_CONFIGURED);
 581
 582         mdesc_fill_in_cpu_data(*mask);
 583
 584         for_each_cpu_mask(cpu, *mask) {
 585                 int err;
 586
 587                 printk(KERN_INFO PFX "Starting cpu %d...\n", cpu);
 588                 err = cpu_up(cpu);
 589                 if (err)
 590                         dr_cpu_mark(resp, cpu, ncpus,
 591                                     DR_CPU_RES_FAILURE,
 592                                     DR_CPU_STAT_UNCONFIGURED);
 593         }
 594
 595         spin_lock_irqsave(&ds_lock, flags);
 596         ds_send(ds_info->lp, resp, resp_len);
 597         spin_unlock_irqrestore(&ds_lock, flags);
 598
 599         kfree(resp);
 600
 601         return 0;
 602 }
 603
 604 static int dr_cpu_unconfigure(struct ds_cap_state *cp, u64 req_num,
 605                               cpumask_t *mask)
 606 {
 607         struct ds_data *resp;
 608         int resp_len, ncpus;
 609
 610         ncpus = cpus_weight(*mask);
 611         resp_len = dr_cpu_size_response(ncpus);
 612         resp = kzalloc(resp_len, GFP_KERNEL);
 613         if (!resp)
 614                 return -ENOMEM;
 615
 616         dr_cpu_init_response(resp, req_num, cp->handle,
 617                              resp_len, ncpus, mask,
 618                              DR_CPU_STAT_UNCONFIGURED);
 619
 620         kfree(resp);
 621
 622         return -EOPNOTSUPP;
 623 }
 624
 625 static void dr_cpu_process(struct work_struct *work)
 626 {
 627         struct dr_cpu_queue_entry *qp, *tmp;
 628         struct ds_cap_state *cp;
 629         unsigned long flags;
 630         LIST_HEAD(todo);
 631         cpumask_t mask;
 632
 633         cp = find_cap_by_string("dr-cpu");
 634
 635         spin_lock_irqsave(&ds_lock, flags);
 636         list_splice(&dr_cpu_work_list, &todo);
 637         spin_unlock_irqrestore(&ds_lock, flags);
 638
 639         list_for_each_entry_safe(qp, tmp, &todo, list) {
 640                 struct ds_data *data = (struct ds_data *) qp->req;
 641                 struct dr_cpu_tag *tag = (struct dr_cpu_tag *) (data + 1);
 642                 u32 *cpu_list = (u32 *) (tag + 1);
 643                 u64 req_num = tag->req_num;
 644                 unsigned int i;
 645                 int err;
 646
 647                 switch (tag->type) {
 648                 case DR_CPU_CONFIGURE:
 649                 case DR_CPU_UNCONFIGURE:
 650                 case DR_CPU_FORCE_UNCONFIGURE:
 651                         break;
 652
 653                 default:
 654                         dr_cpu_send_error(cp, data);
 655                         goto next;
 656                 }
 657
 658                 purge_dups(cpu_list, tag->num_records);
 659
 660                 cpus_clear(mask);
 661                 for (i = 0; i < tag->num_records; i++) {
 662                         if (cpu_list[i] == CPU_SENTINEL)
 663                                 continue;
 664
 665                         if (cpu_list[i] < NR_CPUS)
 666                                 cpu_set(cpu_list[i], mask);
 667                 }
 668
 669                 if (tag->type == DR_CPU_CONFIGURE)
 670                         err = dr_cpu_configure(cp, req_num, &mask);
 671                 else
 672                         err = dr_cpu_unconfigure(cp, req_num, &mask);
 673
 674                 if (err)
 675                         dr_cpu_send_error(cp, data);
 676
 677 next:
 678                 list_del(&qp->list);
 679                 kfree(qp);
 680         }
 681 }
 682
 683 static DECLARE_WORK(dr_cpu_work, dr_cpu_process);
 684
 685 static void dr_cpu_data(struct ldc_channel *lp,
 686                         struct ds_cap_state *dp,
 687                         void *buf, int len)
 688 {
 689         struct dr_cpu_queue_entry *qp;
 690         struct ds_data *dpkt = buf;
 691         struct dr_cpu_tag *rp;
 692
 693         rp = (struct dr_cpu_tag *) (dpkt + 1);
 694
 695         qp = kmalloc(sizeof(struct dr_cpu_queue_entry) + len, GFP_ATOMIC);
 696         if (!qp) {
 697                 struct ds_cap_state *cp;
 698
 699                 cp = find_cap_by_string("dr-cpu");
 700                 __dr_cpu_send_error(cp, dpkt);
 701         } else {
 702                 memcpy(&qp->req, buf, len);
 703                 list_add_tail(&qp->list, &dr_cpu_work_list);
 704                 schedule_work(&dr_cpu_work);
 705         }
 706 }
 707
 708 struct ds_pri_msg {
 709         __u64                           req_num;
 710         __u64                           type;
 711 #define DS_PRI_REQUEST                  0x00
 712 #define DS_PRI_DATA                     0x01
 713 #define DS_PRI_UPDATE                   0x02
 714 };
 715
 716 static void ds_pri_data(struct ldc_channel *lp,
 717                         struct ds_cap_state *dp,
 718                         void *buf, int len)
 719 {
 720         struct ds_data *dpkt = buf;
 721         struct ds_pri_msg *rp;
 722
 723         rp = (struct ds_pri_msg *) (dpkt + 1);
 724
 725         printk(KERN_INFO PFX "PRI REQ [%lx:%lx], len=%d\n",
 726                rp->req_num, rp->type, len);
 727 }
 728
 729 struct ds_var_hdr {
 730         __u32                           type;
 731 #define DS_VAR_SET_REQ                  0x00
 732 #define DS_VAR_DELETE_REQ               0x01
 733 #define DS_VAR_SET_RESP                 0x02
 734 #define DS_VAR_DELETE_RESP              0x03
 735 };
 736
 737 struct ds_var_set_msg {
 738         struct ds_var_hdr               hdr;
 739         char                            name_and_value[0];
 740 };
 741
 742 struct ds_var_delete_msg {
 743         struct ds_var_hdr               hdr;
 744         char                            name[0];
 745 };
 746
 747 struct ds_var_resp {
 748         struct ds_var_hdr               hdr;
 749         __u32                           result;
 750 #define DS_VAR_SUCCESS                  0x00
 751 #define DS_VAR_NO_SPACE                 0x01
 752 #define DS_VAR_INVALID_VAR              0x02
 753 #define DS_VAR_INVALID_VAL              0x03
 754 #define DS_VAR_NOT_PRESENT              0x04
 755 };
 756
 757 static DEFINE_MUTEX(ds_var_mutex);
 758 static int ds_var_doorbell;
 759 static int ds_var_response;
 760
 761 static void ds_var_data(struct ldc_channel *lp,
 762                         struct ds_cap_state *dp,
 763                         void *buf, int len)
 764 {
 765         struct ds_data *dpkt = buf;
 766         struct ds_var_resp *rp;
 767
 768         rp = (struct ds_var_resp *) (dpkt + 1);
 769
 770         if (rp->hdr.type != DS_VAR_SET_RESP &&
 771             rp->hdr.type != DS_VAR_DELETE_RESP)
 772                 return;
 773
 774         ds_var_response = rp->result;
 775         wmb();
 776         ds_var_doorbell = 1;
 777 }
 778
 779 void ldom_set_var(const char *var, const char *value)
 780 {
 781         struct ds_info *dp = ds_info;
 782         struct ds_cap_state *cp;
 783
 784         cp = find_cap_by_string("var-config");
 785         if (cp->state != CAP_STATE_REGISTERED)
 786                 cp = find_cap_by_string("var-config-backup");
 787
 788         if (cp->state == CAP_STATE_REGISTERED) {
 789                 union {
 790                         struct {
 791                                 struct ds_data          data;
 792                                 struct ds_var_set_msg   msg;
 793                         } header;
 794                         char                    all[512];
 795                 } pkt;
 796                 unsigned long flags;
 797                 char  *base, *p;
 798                 int msg_len, loops;
 799
 800                 memset(&pkt, 0, sizeof(pkt));
 801                 pkt.header.data.tag.type = DS_DATA;
 802                 pkt.header.data.handle = cp->handle;
 803                 pkt.header.msg.hdr.type = DS_VAR_SET_REQ;
 804                 base = p = &pkt.header.msg.name_and_value[0];
 805                 strcpy(p, var);
 806                 p += strlen(var) + 1;
 807                 strcpy(p, value);
 808                 p += strlen(value) + 1;
 809
 810                 msg_len = (sizeof(struct ds_data) +
 811                            sizeof(struct ds_var_set_msg) +
 812                            (p - base));
 813                 msg_len = (msg_len + 3) & ~3;
 814                 pkt.header.data.tag.len = msg_len - sizeof(struct ds_msg_tag);
 815
 816                 mutex_lock(&ds_var_mutex);
 817
 818                 spin_lock_irqsave(&ds_lock, flags);
 819                 ds_var_doorbell = 0;
 820                 ds_var_response = -1;
 821
 822                 ds_send(dp->lp, &pkt, msg_len);
 823                 spin_unlock_irqrestore(&ds_lock, flags);
 824
 825                 loops = 1000;
 826                 while (ds_var_doorbell == 0) {
 827                         if (loops-- < 0)
 828                                 break;
 829                         barrier();
 830                         udelay(100);
 831                 }
 832
 833                 mutex_unlock(&ds_var_mutex);
 834
 835                 if (ds_var_doorbell == 0 ||
 836                     ds_var_response != DS_VAR_SUCCESS)
 837                         printk(KERN_ERR PFX "var-config [%s:%s] "
 838                                "failed, response(%d).\n",
 839                                var, value,
 840                                ds_var_response);
 841         } else {
 842                 printk(KERN_ERR PFX "var-config not registered so "
 843                        "could not set (%s) variable to (%s).\n",
 844                        var, value);
 845         }
 846 }
 847
 848 void ldom_reboot(const char *boot_command)
 849 {
 850         /* Don't bother with any of this if the boot_command
 851          * is empty.
 852          */
 853         if (boot_command && strlen(boot_command)) {
 854                 char full_boot_str[256];
 855
 856                 strcpy(full_boot_str, "boot ");
 857                 strcpy(full_boot_str + strlen("boot "), boot_command);
 858
 859                 ldom_set_var("reboot-command", full_boot_str);
 860         }
 861         sun4v_mach_sir();
 862 }
 863
 864 void ldom_power_off(void)
 865 {
 866         sun4v_mach_exit(0);
 867 }
 868
 869 static void ds_conn_reset(struct ds_info *dp)
 870 {
 871         printk(KERN_ERR PFX "ds_conn_reset() from %p\n",
 872                __builtin_return_address(0));
 873 }
 874
 875 static int register_services(struct ds_info *dp)
 876 {
 877         struct ldc_channel *lp = dp->lp;
 878         int i;
 879
 880         for (i = 0; i < ARRAY_SIZE(ds_states); i++) {
 881                 struct {
 882                         struct ds_reg_req req;
 883                         u8 id_buf[256];
 884                 } pbuf;
 885                 struct ds_cap_state *cp = &ds_states[i];
 886                 int err, msg_len;
 887                 u64 new_count;
 888
 889                 if (cp->state == CAP_STATE_REGISTERED)
 890                         continue;
 891
 892                 new_count = sched_clock() & 0xffffffff;
 893                 cp->handle = ((u64) i << 32) | new_count;
 894
 895                 msg_len = (sizeof(struct ds_reg_req) +
 896                            strlen(cp->service_id));
 897
 898                 memset(&pbuf, 0, sizeof(pbuf));
 899                 pbuf.req.tag.type = DS_REG_REQ;
 900                 pbuf.req.tag.len = (msg_len - sizeof(struct ds_msg_tag));
 901                 pbuf.req.handle = cp->handle;
 902                 pbuf.req.major = 1;
 903                 pbuf.req.minor = 0;
 904                 strcpy(pbuf.req.svc_id, cp->service_id);
 905
 906                 err = ds_send(lp, &pbuf, msg_len);
 907                 if (err > 0)
 908                         cp->state = CAP_STATE_REG_SENT;
 909         }
 910         return 0;
 911 }
 912
 913 static int ds_handshake(struct ds_info *dp, struct ds_msg_tag *pkt)
 914 {
 915
 916         if (dp->hs_state == DS_HS_START) {
 917                 if (pkt->type != DS_INIT_ACK)
 918                         goto conn_reset;
 919
 920                 dp->hs_state = DS_HS_DONE;
 921
 922                 return register_services(dp);
 923         }
 924
 925         if (dp->hs_state != DS_HS_DONE)
 926                 goto conn_reset;
 927
 928         if (pkt->type == DS_REG_ACK) {
 929                 struct ds_reg_ack *ap = (struct ds_reg_ack *) pkt;
 930                 struct ds_cap_state *cp = find_cap(ap->handle);
 931
 932                 if (!cp) {
 933                         printk(KERN_ERR PFX "REG ACK for unknown handle %lx\n",
 934                                ap->handle);
 935                         return 0;
 936                 }
 937                 printk(KERN_INFO PFX "Registered %s service.\n",
 938                        cp->service_id);
 939                 cp->state = CAP_STATE_REGISTERED;
 940         } else if (pkt->type == DS_REG_NACK) {
 941                 struct ds_reg_nack *np = (struct ds_reg_nack *) pkt;
 942                 struct ds_cap_state *cp = find_cap(np->handle);
 943
 944                 if (!cp) {
 945                         printk(KERN_ERR PFX "REG NACK for "
 946                                "unknown handle %lx\n",
 947                                np->handle);
 948                         return 0;
 949                 }
 950                 printk(KERN_INFO PFX "Could not register %s service\n",
 951                        cp->service_id);
 952                 cp->state = CAP_STATE_UNKNOWN;
 953         }
 954
 955         return 0;
 956
 957 conn_reset:
 958         ds_conn_reset(dp);
 959         return -ECONNRESET;
 960 }
 961
 962 static int ds_data(struct ds_info *dp, struct ds_msg_tag *pkt, int len)
 963 {
 964         struct ds_data *dpkt = (struct ds_data *) pkt;
 965         struct ds_cap_state *cp = find_cap(dpkt->handle);
 966
 967         if (!cp) {
 968                 struct ds_data_nack nack = {
 969                         .tag = {
 970                                 .type = DS_NACK,
 971                                 .len = (sizeof(struct ds_data_nack) -
 972                                         sizeof(struct ds_msg_tag)),
 973                         },
 974                         .handle = dpkt->handle,
 975                         .result = DS_INV_HDL,
 976                 };
 977
 978                 printk(KERN_ERR PFX "Data for unknown handle %lu\n",
 979                        dpkt->handle);
 980                 ds_send(dp->lp, &nack, sizeof(nack));
 981         } else {
 982                 cp->data(dp->lp, cp, dpkt, len);
 983         }
 984         return 0;
 985 }
 986
 987 static void ds_up(struct ds_info *dp)
 988 {
 989         struct ldc_channel *lp = dp->lp;
 990         struct ds_ver_req req;
 991         int err;
 992
 993         req.tag.type = DS_INIT_REQ;
 994         req.tag.len = sizeof(req) - sizeof(struct ds_msg_tag);
 995         req.ver.major = 1;
 996         req.ver.minor = 0;
 997
 998         err = ds_send(lp, &req, sizeof(req));
 999         if (err > 0)
1000                 dp->hs_state = DS_HS_START;
1001 }
1002
1003 static void ds_event(void *arg, int event)
1004 {
1005         struct ds_info *dp = arg;
1006         struct ldc_channel *lp = dp->lp;
1007         unsigned long flags;
1008         int err;
1009
1010         spin_lock_irqsave(&ds_lock, flags);
1011
1012         if (event == LDC_EVENT_UP) {
1013                 ds_up(dp);
1014                 spin_unlock_irqrestore(&ds_lock, flags);
1015                 return;
1016         }
1017
1018         if (event != LDC_EVENT_DATA_READY) {
1019                 printk(KERN_WARNING PFX "Unexpected LDC event %d\n", event);
1020                 spin_unlock_irqrestore(&ds_lock, flags);
1021                 return;
1022         }
1023
1024         err = 0;
1025         while (1) {
1026                 struct ds_msg_tag *tag;
1027
1028                 err = ldc_read(lp, dp->rcv_buf, sizeof(*tag));
1029
1030                 if (unlikely(err < 0)) {
1031                         if (err == -ECONNRESET)
1032                                 ds_conn_reset(dp);
1033                         break;
1034                 }
1035                 if (err == 0)
1036                         break;
1037
1038                 tag = dp->rcv_buf;
1039                 err = ldc_read(lp, tag + 1, tag->len);
1040
1041                 if (unlikely(err < 0)) {
1042                         if (err == -ECONNRESET)
1043                                 ds_conn_reset(dp);
1044                         break;
1045                 }
1046                 if (err < tag->len)
1047                         break;
1048
1049                 if (tag->type < DS_DATA)
1050                         err = ds_handshake(dp, dp->rcv_buf);
1051                 else
1052                         err = ds_data(dp, dp->rcv_buf,
1053                                       sizeof(*tag) + err);
1054                 if (err == -ECONNRESET)
1055                         break;
1056         }
1057
1058         spin_unlock_irqrestore(&ds_lock, flags);
1059 }
1060
1061 static int __devinit ds_probe(struct vio_dev *vdev,
1062                               const struct vio_device_id *id)
1063 {
1064         static int ds_version_printed;
1065         struct ldc_channel_config ds_cfg = {
1066                 .event          = ds_event,
1067                 .mtu            = 4096,
1068                 .mode           = LDC_MODE_STREAM,
1069         };
1070         struct ldc_channel *lp;
1071         struct ds_info *dp;
1072         int err;
1073
1074         if (ds_version_printed++ == 0)
1075                 printk(KERN_INFO "%s", version);
1076
1077         dp = kzalloc(sizeof(*dp), GFP_KERNEL);
1078         err = -ENOMEM;
1079         if (!dp)
1080                 goto out_err;
1081
1082         dp->rcv_buf = kzalloc(4096, GFP_KERNEL);
1083         if (!dp->rcv_buf)
1084                 goto out_free_dp;
1085
1086         dp->rcv_buf_len = 4096;
1087
1088         ds_cfg.tx_irq = vdev->tx_irq;
1089         ds_cfg.rx_irq = vdev->rx_irq;
1090
1091         lp = ldc_alloc(vdev->channel_id, &ds_cfg, dp);
1092         if (IS_ERR(lp)) {
1093                 err = PTR_ERR(lp);
1094                 goto out_free_rcv_buf;
1095         }
1096         dp->lp = lp;
1097
1098         err = ldc_bind(lp, "DS");
1099         if (err)
1100                 goto out_free_ldc;
1101
1102         ds_info = dp;
1103
1104         start_powerd();
1105
1106         return err;
1107
1108 out_free_ldc:
1109         ldc_free(dp->lp);
1110
1111 out_free_rcv_buf:
1112         kfree(dp->rcv_buf);
1113
1114 out_free_dp:
1115         kfree(dp);
1116
1117 out_err:
1118         return err;
1119 }
1120
1121 static int ds_remove(struct vio_dev *vdev)
1122 {
1123         return 0;
1124 }
1125
1126 static struct vio_device_id ds_match[] = {
1127         {
1128                 .type = "domain-services-port",
1129         },
1130         {},
1131 };
1132
1133 static struct vio_driver ds_driver = {
1134         .id_table       = ds_match,
1135         .probe          = ds_probe,
1136         .remove         = ds_remove,
1137         .driver         = {
1138                 .name   = "ds",
1139                 .owner  = THIS_MODULE,
1140         }
1141 };
1142
1143 static int __init ds_init(void)
1144 {
1145         int i;
1146
1147         for (i = 0; i < ARRAY_SIZE(ds_states); i++)
1148                 ds_states[i].handle = ((u64)i << 32);
1149
1150         return vio_register_driver(&ds_driver);
1151 }
1152
1153 subsys_initcall(ds_init);