arch/tile/gxio/iorpc_mpipe.c

   1 /*
   2  * Copyright 2012 Tilera Corporation. All Rights Reserved.
   3  *
   4  *   This program is free software; you can redistribute it and/or
   5  *   modify it under the terms of the GNU General Public License
   6  *   as published by the Free Software Foundation, version 2.
   7  *
   8  *   This program is distributed in the hope that it will be useful, but
   9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  11  *   NON INFRINGEMENT.  See the GNU General Public License for
  12  *   more details.
  13  */
  14
  15 /* This file is machine-generated; DO NOT EDIT! */
  16 #include "gxio/iorpc_mpipe.h"
  17
  18 struct alloc_buffer_stacks_param {
  19         unsigned int count;
  20         unsigned int first;
  21         unsigned int flags;
  22 };
  23
  24 int gxio_mpipe_alloc_buffer_stacks(gxio_mpipe_context_t * context,
  25                                    unsigned int count, unsigned int first,
  26                                    unsigned int flags)
  27 {
  28         struct alloc_buffer_stacks_param temp;
  29         struct alloc_buffer_stacks_param *params = &temp;
  30
  31         params->count = count;
  32         params->first = first;
  33         params->flags = flags;
  34
  35         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
  36                              sizeof(*params),
  37                              GXIO_MPIPE_OP_ALLOC_BUFFER_STACKS);
  38 }
  39
  40 EXPORT_SYMBOL(gxio_mpipe_alloc_buffer_stacks);
  41
  42 struct init_buffer_stack_aux_param {
  43         union iorpc_mem_buffer buffer;
  44         unsigned int stack;
  45         unsigned int buffer_size_enum;
  46 };
  47
  48 int gxio_mpipe_init_buffer_stack_aux(gxio_mpipe_context_t * context,
  49                                      void *mem_va, size_t mem_size,
  50                                      unsigned int mem_flags, unsigned int stack,
  51                                      unsigned int buffer_size_enum)
  52 {
  53         int __result;
  54         unsigned long long __cpa;
  55         pte_t __pte;
  56         struct init_buffer_stack_aux_param temp;
  57         struct init_buffer_stack_aux_param *params = &temp;
  58
  59         __result = va_to_cpa_and_pte(mem_va, &__cpa, &__pte);
  60         if (__result != 0)
  61                 return __result;
  62         params->buffer.kernel.cpa = __cpa;
  63         params->buffer.kernel.size = mem_size;
  64         params->buffer.kernel.pte = __pte;
  65         params->buffer.kernel.flags = mem_flags;
  66         params->stack = stack;
  67         params->buffer_size_enum = buffer_size_enum;
  68
  69         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
  70                              sizeof(*params),
  71                              GXIO_MPIPE_OP_INIT_BUFFER_STACK_AUX);
  72 }
  73
  74 EXPORT_SYMBOL(gxio_mpipe_init_buffer_stack_aux);
  75
  76
  77 struct alloc_notif_rings_param {
  78         unsigned int count;
  79         unsigned int first;
  80         unsigned int flags;
  81 };
  82
  83 int gxio_mpipe_alloc_notif_rings(gxio_mpipe_context_t * context,
  84                                  unsigned int count, unsigned int first,
  85                                  unsigned int flags)
  86 {
  87         struct alloc_notif_rings_param temp;
  88         struct alloc_notif_rings_param *params = &temp;
  89
  90         params->count = count;
  91         params->first = first;
  92         params->flags = flags;
  93
  94         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
  95                              sizeof(*params), GXIO_MPIPE_OP_ALLOC_NOTIF_RINGS);
  96 }
  97
  98 EXPORT_SYMBOL(gxio_mpipe_alloc_notif_rings);
  99
 100 struct init_notif_ring_aux_param {
 101         union iorpc_mem_buffer buffer;
 102         unsigned int ring;
 103 };
 104
 105 int gxio_mpipe_init_notif_ring_aux(gxio_mpipe_context_t * context, void *mem_va,
 106                                    size_t mem_size, unsigned int mem_flags,
 107                                    unsigned int ring)
 108 {
 109         int __result;
 110         unsigned long long __cpa;
 111         pte_t __pte;
 112         struct init_notif_ring_aux_param temp;
 113         struct init_notif_ring_aux_param *params = &temp;
 114
 115         __result = va_to_cpa_and_pte(mem_va, &__cpa, &__pte);
 116         if (__result != 0)
 117                 return __result;
 118         params->buffer.kernel.cpa = __cpa;
 119         params->buffer.kernel.size = mem_size;
 120         params->buffer.kernel.pte = __pte;
 121         params->buffer.kernel.flags = mem_flags;
 122         params->ring = ring;
 123
 124         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 125                              sizeof(*params),
 126                              GXIO_MPIPE_OP_INIT_NOTIF_RING_AUX);
 127 }
 128
 129 EXPORT_SYMBOL(gxio_mpipe_init_notif_ring_aux);
 130
 131 struct request_notif_ring_interrupt_param {
 132         union iorpc_interrupt interrupt;
 133         unsigned int ring;
 134 };
 135
 136 int gxio_mpipe_request_notif_ring_interrupt(gxio_mpipe_context_t * context,
 137                                             int inter_x, int inter_y,
 138                                             int inter_ipi, int inter_event,
 139                                             unsigned int ring)
 140 {
 141         struct request_notif_ring_interrupt_param temp;
 142         struct request_notif_ring_interrupt_param *params = &temp;
 143
 144         params->interrupt.kernel.x = inter_x;
 145         params->interrupt.kernel.y = inter_y;
 146         params->interrupt.kernel.ipi = inter_ipi;
 147         params->interrupt.kernel.event = inter_event;
 148         params->ring = ring;
 149
 150         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 151                              sizeof(*params),
 152                              GXIO_MPIPE_OP_REQUEST_NOTIF_RING_INTERRUPT);
 153 }
 154
 155 EXPORT_SYMBOL(gxio_mpipe_request_notif_ring_interrupt);
 156
 157 struct enable_notif_ring_interrupt_param {
 158         unsigned int ring;
 159 };
 160
 161 int gxio_mpipe_enable_notif_ring_interrupt(gxio_mpipe_context_t * context,
 162                                            unsigned int ring)
 163 {
 164         struct enable_notif_ring_interrupt_param temp;
 165         struct enable_notif_ring_interrupt_param *params = &temp;
 166
 167         params->ring = ring;
 168
 169         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 170                              sizeof(*params),
 171                              GXIO_MPIPE_OP_ENABLE_NOTIF_RING_INTERRUPT);
 172 }
 173
 174 EXPORT_SYMBOL(gxio_mpipe_enable_notif_ring_interrupt);
 175
 176 struct alloc_notif_groups_param {
 177         unsigned int count;
 178         unsigned int first;
 179         unsigned int flags;
 180 };
 181
 182 int gxio_mpipe_alloc_notif_groups(gxio_mpipe_context_t * context,
 183                                   unsigned int count, unsigned int first,
 184                                   unsigned int flags)
 185 {
 186         struct alloc_notif_groups_param temp;
 187         struct alloc_notif_groups_param *params = &temp;
 188
 189         params->count = count;
 190         params->first = first;
 191         params->flags = flags;
 192
 193         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 194                              sizeof(*params), GXIO_MPIPE_OP_ALLOC_NOTIF_GROUPS);
 195 }
 196
 197 EXPORT_SYMBOL(gxio_mpipe_alloc_notif_groups);
 198
 199 struct init_notif_group_param {
 200         unsigned int group;
 201         gxio_mpipe_notif_group_bits_t bits;
 202 };
 203
 204 int gxio_mpipe_init_notif_group(gxio_mpipe_context_t * context,
 205                                 unsigned int group,
 206                                 gxio_mpipe_notif_group_bits_t bits)
 207 {
 208         struct init_notif_group_param temp;
 209         struct init_notif_group_param *params = &temp;
 210
 211         params->group = group;
 212         params->bits = bits;
 213
 214         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 215                              sizeof(*params), GXIO_MPIPE_OP_INIT_NOTIF_GROUP);
 216 }
 217
 218 EXPORT_SYMBOL(gxio_mpipe_init_notif_group);
 219
 220 struct alloc_buckets_param {
 221         unsigned int count;
 222         unsigned int first;
 223         unsigned int flags;
 224 };
 225
 226 int gxio_mpipe_alloc_buckets(gxio_mpipe_context_t * context, unsigned int count,
 227                              unsigned int first, unsigned int flags)
 228 {
 229         struct alloc_buckets_param temp;
 230         struct alloc_buckets_param *params = &temp;
 231
 232         params->count = count;
 233         params->first = first;
 234         params->flags = flags;
 235
 236         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 237                              sizeof(*params), GXIO_MPIPE_OP_ALLOC_BUCKETS);
 238 }
 239
 240 EXPORT_SYMBOL(gxio_mpipe_alloc_buckets);
 241
 242 struct init_bucket_param {
 243         unsigned int bucket;
 244         MPIPE_LBL_INIT_DAT_BSTS_TBL_t bucket_info;
 245 };
 246
 247 int gxio_mpipe_init_bucket(gxio_mpipe_context_t * context, unsigned int bucket,
 248                            MPIPE_LBL_INIT_DAT_BSTS_TBL_t bucket_info)
 249 {
 250         struct init_bucket_param temp;
 251         struct init_bucket_param *params = &temp;
 252
 253         params->bucket = bucket;
 254         params->bucket_info = bucket_info;
 255
 256         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 257                              sizeof(*params), GXIO_MPIPE_OP_INIT_BUCKET);
 258 }
 259
 260 EXPORT_SYMBOL(gxio_mpipe_init_bucket);
 261
 262 struct alloc_edma_rings_param {
 263         unsigned int count;
 264         unsigned int first;
 265         unsigned int flags;
 266 };
 267
 268 int gxio_mpipe_alloc_edma_rings(gxio_mpipe_context_t * context,
 269                                 unsigned int count, unsigned int first,
 270                                 unsigned int flags)
 271 {
 272         struct alloc_edma_rings_param temp;
 273         struct alloc_edma_rings_param *params = &temp;
 274
 275         params->count = count;
 276         params->first = first;
 277         params->flags = flags;
 278
 279         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 280                              sizeof(*params), GXIO_MPIPE_OP_ALLOC_EDMA_RINGS);
 281 }
 282
 283 EXPORT_SYMBOL(gxio_mpipe_alloc_edma_rings);
 284
 285 struct init_edma_ring_aux_param {
 286         union iorpc_mem_buffer buffer;
 287         unsigned int ring;
 288         unsigned int channel;
 289 };
 290
 291 int gxio_mpipe_init_edma_ring_aux(gxio_mpipe_context_t * context, void *mem_va,
 292                                   size_t mem_size, unsigned int mem_flags,
 293                                   unsigned int ring, unsigned int channel)
 294 {
 295         int __result;
 296         unsigned long long __cpa;
 297         pte_t __pte;
 298         struct init_edma_ring_aux_param temp;
 299         struct init_edma_ring_aux_param *params = &temp;
 300
 301         __result = va_to_cpa_and_pte(mem_va, &__cpa, &__pte);
 302         if (__result != 0)
 303                 return __result;
 304         params->buffer.kernel.cpa = __cpa;
 305         params->buffer.kernel.size = mem_size;
 306         params->buffer.kernel.pte = __pte;
 307         params->buffer.kernel.flags = mem_flags;
 308         params->ring = ring;
 309         params->channel = channel;
 310
 311         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 312                              sizeof(*params), GXIO_MPIPE_OP_INIT_EDMA_RING_AUX);
 313 }
 314
 315 EXPORT_SYMBOL(gxio_mpipe_init_edma_ring_aux);
 316
 317
 318 int gxio_mpipe_commit_rules(gxio_mpipe_context_t * context, const void *blob,
 319                             size_t blob_size)
 320 {
 321         const void *params = blob;
 322
 323         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params, blob_size,
 324                              GXIO_MPIPE_OP_COMMIT_RULES);
 325 }
 326
 327 EXPORT_SYMBOL(gxio_mpipe_commit_rules);
 328
 329 struct register_client_memory_param {
 330         unsigned int iotlb;
 331         HV_PTE pte;
 332         unsigned int flags;
 333 };
 334
 335 int gxio_mpipe_register_client_memory(gxio_mpipe_context_t * context,
 336                                       unsigned int iotlb, HV_PTE pte,
 337                                       unsigned int flags)
 338 {
 339         struct register_client_memory_param temp;
 340         struct register_client_memory_param *params = &temp;
 341
 342         params->iotlb = iotlb;
 343         params->pte = pte;
 344         params->flags = flags;
 345
 346         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 347                              sizeof(*params),
 348                              GXIO_MPIPE_OP_REGISTER_CLIENT_MEMORY);
 349 }
 350
 351 EXPORT_SYMBOL(gxio_mpipe_register_client_memory);
 352
 353 struct link_open_aux_param {
 354         _gxio_mpipe_link_name_t name;
 355         unsigned int flags;
 356 };
 357
 358 int gxio_mpipe_link_open_aux(gxio_mpipe_context_t * context,
 359                              _gxio_mpipe_link_name_t name, unsigned int flags)
 360 {
 361         struct link_open_aux_param temp;
 362         struct link_open_aux_param *params = &temp;
 363
 364         params->name = name;
 365         params->flags = flags;
 366
 367         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 368                              sizeof(*params), GXIO_MPIPE_OP_LINK_OPEN_AUX);
 369 }
 370
 371 EXPORT_SYMBOL(gxio_mpipe_link_open_aux);
 372
 373 struct link_close_aux_param {
 374         int mac;
 375 };
 376
 377 int gxio_mpipe_link_close_aux(gxio_mpipe_context_t * context, int mac)
 378 {
 379         struct link_close_aux_param temp;
 380         struct link_close_aux_param *params = &temp;
 381
 382         params->mac = mac;
 383
 384         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 385                              sizeof(*params), GXIO_MPIPE_OP_LINK_CLOSE_AUX);
 386 }
 387
 388 EXPORT_SYMBOL(gxio_mpipe_link_close_aux);
 389
 390
 391 struct get_timestamp_aux_param {
 392         uint64_t sec;
 393         uint64_t nsec;
 394         uint64_t cycles;
 395 };
 396
 397 int gxio_mpipe_get_timestamp_aux(gxio_mpipe_context_t * context, uint64_t * sec,
 398                                  uint64_t * nsec, uint64_t * cycles)
 399 {
 400         int __result;
 401         struct get_timestamp_aux_param temp;
 402         struct get_timestamp_aux_param *params = &temp;
 403
 404         __result =
 405             hv_dev_pread(context->fd, 0, (HV_VirtAddr) params, sizeof(*params),
 406                          GXIO_MPIPE_OP_GET_TIMESTAMP_AUX);
 407         *sec = params->sec;
 408         *nsec = params->nsec;
 409         *cycles = params->cycles;
 410
 411         return __result;
 412 }
 413
 414 EXPORT_SYMBOL(gxio_mpipe_get_timestamp_aux);
 415
 416 struct set_timestamp_aux_param {
 417         uint64_t sec;
 418         uint64_t nsec;
 419         uint64_t cycles;
 420 };
 421
 422 int gxio_mpipe_set_timestamp_aux(gxio_mpipe_context_t * context, uint64_t sec,
 423                                  uint64_t nsec, uint64_t cycles)
 424 {
 425         struct set_timestamp_aux_param temp;
 426         struct set_timestamp_aux_param *params = &temp;
 427
 428         params->sec = sec;
 429         params->nsec = nsec;
 430         params->cycles = cycles;
 431
 432         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 433                              sizeof(*params), GXIO_MPIPE_OP_SET_TIMESTAMP_AUX);
 434 }
 435
 436 EXPORT_SYMBOL(gxio_mpipe_set_timestamp_aux);
 437
 438 struct adjust_timestamp_aux_param {
 439         int64_t nsec;
 440 };
 441
 442 int gxio_mpipe_adjust_timestamp_aux(gxio_mpipe_context_t * context,
 443                                     int64_t nsec)
 444 {
 445         struct adjust_timestamp_aux_param temp;
 446         struct adjust_timestamp_aux_param *params = &temp;
 447
 448         params->nsec = nsec;
 449
 450         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 451                              sizeof(*params),
 452                              GXIO_MPIPE_OP_ADJUST_TIMESTAMP_AUX);
 453 }
 454
 455 EXPORT_SYMBOL(gxio_mpipe_adjust_timestamp_aux);
 456
 457 struct arm_pollfd_param {
 458         union iorpc_pollfd pollfd;
 459 };
 460
 461 int gxio_mpipe_arm_pollfd(gxio_mpipe_context_t * context, int pollfd_cookie)
 462 {
 463         struct arm_pollfd_param temp;
 464         struct arm_pollfd_param *params = &temp;
 465
 466         params->pollfd.kernel.cookie = pollfd_cookie;
 467
 468         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 469                              sizeof(*params), GXIO_MPIPE_OP_ARM_POLLFD);
 470 }
 471
 472 EXPORT_SYMBOL(gxio_mpipe_arm_pollfd);
 473
 474 struct close_pollfd_param {
 475         union iorpc_pollfd pollfd;
 476 };
 477
 478 int gxio_mpipe_close_pollfd(gxio_mpipe_context_t * context, int pollfd_cookie)
 479 {
 480         struct close_pollfd_param temp;
 481         struct close_pollfd_param *params = &temp;
 482
 483         params->pollfd.kernel.cookie = pollfd_cookie;
 484
 485         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 486                              sizeof(*params), GXIO_MPIPE_OP_CLOSE_POLLFD);
 487 }
 488
 489 EXPORT_SYMBOL(gxio_mpipe_close_pollfd);
 490
 491 struct get_mmio_base_param {
 492         HV_PTE base;
 493 };
 494
 495 int gxio_mpipe_get_mmio_base(gxio_mpipe_context_t * context, HV_PTE *base)
 496 {
 497         int __result;
 498         struct get_mmio_base_param temp;
 499         struct get_mmio_base_param *params = &temp;
 500
 501         __result =
 502             hv_dev_pread(context->fd, 0, (HV_VirtAddr) params, sizeof(*params),
 503                          GXIO_MPIPE_OP_GET_MMIO_BASE);
 504         *base = params->base;
 505
 506         return __result;
 507 }
 508
 509 EXPORT_SYMBOL(gxio_mpipe_get_mmio_base);
 510
 511 struct check_mmio_offset_param {
 512         unsigned long offset;
 513         unsigned long size;
 514 };
 515
 516 int gxio_mpipe_check_mmio_offset(gxio_mpipe_context_t * context,
 517                                  unsigned long offset, unsigned long size)
 518 {
 519         struct check_mmio_offset_param temp;
 520         struct check_mmio_offset_param *params = &temp;
 521
 522         params->offset = offset;
 523         params->size = size;
 524
 525         return hv_dev_pwrite(context->fd, 0, (HV_VirtAddr) params,
 526                              sizeof(*params), GXIO_MPIPE_OP_CHECK_MMIO_OFFSET);
 527 }
 528
 529 EXPORT_SYMBOL(gxio_mpipe_check_mmio_offset);