ps3vuart_port.c

   1 /*-
   2  * Copyright (C) 2011, 2012 glevand <geoffrey.levand@mail.ru>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer,
  10  *    without modification, immediately at the beginning of the file.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/module.h>
  34 #include <sys/kernel.h>
  35 #include <sys/systm.h>
  36 #include <sys/malloc.h>
  37 #include <sys/lock.h>
  38 #include <sys/mutex.h>
  39
  40 #include <vm/vm.h>
  41 #include <vm/pmap.h>
  42
  43 #include <powerpc/ps3/ps3-hvcall.h>
  44
  45 #include "ps3vuart_port.h"
  46
  47 #define PS3VUART_PORT_LOCK_INIT(_vp) \
  48     mtx_init(&(_vp)->vp_mtx, "ps3vuart_port", NULL, MTX_DEF)
  49 #define PS3VUART_PORT_LOCK_DESTROY(_vp)         mtx_destroy(&(_vp)->vp_mtx)
  50 #define PS3VUART_PORT_LOCK(_vp)                 mtx_lock(&(_vp)->vp_mtx)
  51 #define PS3VUART_PORT_UNLOCK(_vp)               mtx_unlock(&(_vp)->vp_mtx)
  52 #define PS3VUART_PORT_ASSERT_LOCKED(_vp)        mtx_assert(&(_vp)->vp_mtx, MA_OWNED)
  53 #define PS3VUART_PORT_ASSERT_UNLOCKED(_vp)      mtx_assert(&(_vp)->vp_mtx, MA_NOTOWNED)
  54
  55 static MALLOC_DEFINE(M_PS3VUART_PORT, "ps3vuart_port", "PS3 VUART Port");
  56
  57 static int
  58 ps3vuart_port_set_intr_mask(struct ps3vuart_port *vp, uint64_t mask)
  59 {
  60         int err;
  61
  62         PS3VUART_PORT_ASSERT_LOCKED(vp);
  63
  64         if (vp->vp_intr_mask == mask)
  65                 return (0);
  66
  67         err = lv1_set_virtual_uart_param(vp->vp_port,
  68             PS3VUART_PORT_PARAM_INTR_MASK, mask);
  69         if (err)
  70                 return (err);
  71
  72         vp->vp_intr_mask = mask;
  73
  74         return (0);
  75 }
  76
  77 static int
  78 p3vuart_port_discard_rx_bytes(struct ps3vuart_port *vp, int bytes,
  79     int *discarded)
  80 {
  81         uint64_t waiting, read;
  82         void *buf;
  83         int err;
  84
  85         PS3VUART_PORT_ASSERT_LOCKED(vp);
  86
  87         if (!bytes) {
  88                 err = lv1_get_virtual_uart_param(vp->vp_port,
  89                     PS3VUART_PORT_PARAM_RX_BYTES, &waiting);
  90                 if (err)
  91                         return (err);
  92
  93                 bytes = waiting;
  94         }
  95
  96         if (!bytes) {
  97                 if (discarded)
  98                         *discarded = 0;
  99                 return (0);
 100         }
 101
 102         bytes += 128;
 103
 104         buf = malloc(bytes, M_PS3VUART_PORT, M_WAITOK);
 105         if (!buf)
 106                 return (ENOMEM);
 107
 108         err = lv1_read_virtual_uart(vp->vp_port, vtophys(buf),
 109             bytes, &read);
 110
 111         free(buf, M_PS3VUART_PORT);
 112
 113         if (err)
 114                 return (err);
 115
 116         if (discarded)
 117                 *discarded = read;
 118
 119         return (0);
 120 }
 121
 122 static int
 123 ps3vuart_port_push(struct ps3vuart_port *vp, int *pushed)
 124 {
 125         struct ps3vuart_port_buf *vb, *tmp;
 126         uint64_t written;
 127         int bytes, err;
 128
 129         PS3VUART_PORT_ASSERT_LOCKED(vp);
 130
 131         if (pushed)
 132                 *pushed = 0;
 133
 134         TAILQ_FOREACH_SAFE(vb, &vp->vp_tx_bufq, vb_queue, tmp) {
 135                 bytes = vb->vb_tail - vb->vb_head;
 136
 137                 err = lv1_write_virtual_uart(vp->vp_port,
 138                     vtophys(vb->vb_head), bytes, &written);
 139                 if (err)
 140                         return (err);
 141
 142                 vp->vp_tx_bufq_bytes -= written;
 143                 vp->vp_stat.vs_tx_bytes += written;
 144
 145                 if (pushed)
 146                         *pushed += written;
 147
 148                 if (written < bytes) {
 149                         /* VUART Tx buffer is full */
 150                         vb->vb_head += written;
 151                         return (0);
 152                 }
 153
 154                 TAILQ_REMOVE(&vp->vp_tx_bufq, vb, vb_queue);
 155                 free(vb, M_PS3VUART_PORT);
 156         }
 157
 158         /* Tx queue is empty, disable Tx interrupts */
 159
 160         err = ps3vuart_port_set_intr_mask(vp,
 161             vp->vp_intr_mask & ~PS3VUART_PORT_INTR_TX);
 162
 163         return (err);
 164 }
 165
 166 static int
 167 ps3vuart_port_pull(struct ps3vuart_port *vp, int *pulled)
 168 {
 169         struct ps3vuart_port_buf *vb;
 170         uint64_t waiting, read;
 171         int err;
 172
 173         PS3VUART_PORT_ASSERT_LOCKED(vp);
 174
 175         err = lv1_get_virtual_uart_param(vp->vp_port,
 176             PS3VUART_PORT_PARAM_RX_BYTES, &waiting);
 177         if (err)
 178                 return (err);
 179
 180         if (!waiting) {
 181                 if (pulled)
 182                         *pulled = 0;
 183                 return (0);
 184         }
 185
 186         waiting += 128;
 187
 188         vb = malloc(sizeof(*vb) + waiting, M_PS3VUART_PORT, M_WAITOK);
 189         if (!vb)
 190                 return (ENOMEM);
 191
 192         err = lv1_read_virtual_uart(vp->vp_port,
 193             vtophys(vb->vb_data), waiting, &read);
 194         if (err)
 195                 return (err);
 196
 197         vb->vb_head = vb->vb_data;
 198         vb->vb_tail = vb->vb_head + read;
 199
 200         TAILQ_INSERT_TAIL(&vp->vp_rx_bufq, vb, vb_queue);
 201
 202         vp->vp_rx_bufq_bytes += read;
 203
 204         if (pulled)
 205                 *pulled = read;
 206
 207         return (0);
 208 }
 209
 210 int
 211 ps3vuart_port_init(struct ps3vuart_port *vp, int port)
 212 {
 213         uint64_t status, bufsize;
 214         int err;
 215
 216         vp->vp_port = port;
 217
 218         PS3VUART_PORT_LOCK_INIT(vp);
 219
 220         PS3VUART_PORT_LOCK(vp);
 221
 222         /* Assert that VUART is connected */
 223
 224         err = lv1_get_virtual_uart_param(vp->vp_port,
 225             PS3VUART_PORT_PARAM_INTR_STAT, &status);
 226         if (err)
 227                 goto out;
 228
 229         if (!(status & PS3VUART_PORT_INTR_CONNECT)) {
 230                 err = ENODEV;
 231                 goto out;
 232         }
 233
 234         /* Disable all interrupts */
 235
 236         vp->vp_intr_mask = 0;
 237
 238         err = lv1_set_virtual_uart_param(vp->vp_port,
 239             PS3VUART_PORT_PARAM_INTR_MASK, vp->vp_intr_mask);
 240         if (err)
 241                 goto out;
 242
 243         /* Init Tx/Rx queues */
 244
 245         TAILQ_INIT(&vp->vp_rx_bufq);
 246         vp->vp_rx_bufq_bytes = 0;
 247
 248         TAILQ_INIT(&vp->vp_tx_bufq);
 249         vp->vp_tx_bufq_bytes = 0;
 250
 251         /* Reset statistic counters */
 252
 253         memset(&vp->vp_stat, 0, sizeof(struct ps3vuart_port_stat));
 254
 255         /* Discard stale Rx bytes */
 256
 257         err = p3vuart_port_discard_rx_bytes(vp, 0, NULL);
 258         if (err)
 259                 goto out;
 260
 261         /* Set Tx trigger level */
 262
 263         /*
 264          * An Tx interrupt is generated whenever the amount of
 265          * occupied space in VUART Tx buffer becomes less than or
 266          * equal the Tx trigger level.
 267          */
 268
 269         err = lv1_set_virtual_uart_param(vp->vp_port,
 270             PS3VUART_PORT_PARAM_TX_TRIG, 1);
 271         if (err)
 272                 goto out;
 273
 274         /* Set Rx trigger level */
 275
 276         /*
 277          * An Rx interrupt is generated whenever the amount of
 278          * free space in VUART Rx buffer becomes less than or
 279          * equal the Rx trigger level.
 280          */
 281
 282         err = lv1_get_virtual_uart_param(vp->vp_port,
 283             PS3VUART_PORT_PARAM_RX_BUFSIZE, &bufsize);
 284         if (err)
 285                 goto out;
 286
 287         err = lv1_set_virtual_uart_param(vp->vp_port,
 288             PS3VUART_PORT_PARAM_RX_TRIG, bufsize - 1);
 289         if (err)
 290                 goto out;
 291
 292         /* Enable Rx and disconnect interrupts */
 293
 294         err = ps3vuart_port_set_intr_mask(vp,
 295             PS3VUART_PORT_INTR_RX | PS3VUART_PORT_INTR_DISCONNECT);
 296
 297 out:
 298
 299         PS3VUART_PORT_UNLOCK(vp);
 300
 301         if (err)
 302                 PS3VUART_PORT_LOCK_DESTROY(vp);
 303
 304         return (err);
 305 }
 306
 307 void
 308 ps3vuart_port_fini(struct ps3vuart_port *vp)
 309 {
 310         struct ps3vuart_port_buf *vb;
 311
 312         PS3VUART_PORT_LOCK(vp);
 313
 314         /* Disable interrupts */
 315
 316         ps3vuart_port_set_intr_mask(vp, 0);
 317
 318         /* Free Rx queue */
 319
 320         while ((vb = TAILQ_FIRST(&vp->vp_rx_bufq))) {
 321                 TAILQ_REMOVE(&vp->vp_rx_bufq, vb, vb_queue);
 322                 free(vb, M_PS3VUART_PORT);
 323         }
 324
 325         /* Free Tx queue */
 326
 327         while ((vb = TAILQ_FIRST(&vp->vp_tx_bufq))) {
 328                 TAILQ_REMOVE(&vp->vp_tx_bufq, vb, vb_queue);
 329                 free(vb, M_PS3VUART_PORT);
 330         }
 331
 332         PS3VUART_PORT_UNLOCK(vp);
 333
 334         PS3VUART_PORT_LOCK_DESTROY(vp);
 335 }
 336
 337 int
 338 ps3vuart_port_write(struct ps3vuart_port *vp, const char *buf, int size,
 339     int *written)
 340 {
 341         struct ps3vuart_port_buf *vb;
 342         uint64_t bytes;
 343         int err = 0;
 344
 345         PS3VUART_PORT_LOCK(vp);
 346
 347         *written = 0;
 348
 349         /* Try to send as many bytes as possible to VUART */
 350
 351         if (TAILQ_EMPTY(&vp->vp_tx_bufq)) {
 352                 err = lv1_write_virtual_uart(vp->vp_port,
 353                     vtophys(buf), size, &bytes);
 354                 if (err) {
 355                         err = ENXIO;
 356                         goto out;
 357                 }
 358
 359                 buf += bytes;
 360                 size -= bytes;
 361                 *written += bytes;
 362                 vp->vp_stat.vs_tx_bytes += bytes;
 363         }
 364
 365         if (!size)
 366                 goto out;
 367
 368         /* Enqueue remaining bytes in Tx queue */
 369
 370         vb = malloc(sizeof(*vb) + size, M_PS3VUART_PORT, M_WAITOK);
 371         if (!vb) {
 372                 err = ENOMEM;
 373                 goto out;
 374         }
 375
 376         bcopy(buf, vb->vb_data, size);
 377
 378         vb->vb_head = vb->vb_data;
 379         vb->vb_tail = vb->vb_head + size;
 380
 381         TAILQ_INSERT_TAIL(&vp->vp_tx_bufq, vb, vb_queue);
 382
 383         *written += size;
 384         vp->vp_tx_bufq_bytes += size;
 385
 386         /* Enable Tx interrupts */
 387
 388         err = ps3vuart_port_set_intr_mask(vp,
 389             vp->vp_intr_mask | PS3VUART_PORT_INTR_TX);
 390
 391 out:
 392
 393         PS3VUART_PORT_UNLOCK(vp);
 394
 395         return (err);
 396 }
 397
 398 int
 399 ps3vuart_port_read(struct ps3vuart_port *vp, char *buf, int size,
 400     int *read)
 401 {
 402         struct ps3vuart_port_buf *vb, *tmp;
 403         int bytes;
 404         int err = 0;
 405
 406         PS3VUART_PORT_LOCK(vp);
 407
 408         err = ps3vuart_port_pull(vp, NULL);
 409         if (err) {
 410                 err = ENXIO;
 411                 goto out;
 412         }
 413
 414         *read = 0;
 415
 416         TAILQ_FOREACH_SAFE(vb, &vp->vp_rx_bufq, vb_queue, tmp) {
 417                 bytes = min(vb->vb_tail - vb->vb_head, size);
 418
 419                 bcopy(vb->vb_head, buf, bytes);
 420
 421                 buf += bytes;
 422                 size -= bytes;
 423                 *read += bytes;
 424                 vp->vp_rx_bufq_bytes -= bytes;
 425
 426                 if (bytes < (vb->vb_tail - vb->vb_head)) {
 427                         vb->vb_head += bytes;
 428                         goto out;
 429                 }
 430
 431                 TAILQ_REMOVE(&vp->vp_rx_bufq, vb, vb_queue);
 432                 free(vb, M_PS3VUART_PORT);
 433         }
 434
 435 out:
 436
 437         PS3VUART_PORT_UNLOCK(vp);
 438
 439         return (err);
 440 }
 441
 442 int
 443 ps3vuart_port_set_param(struct ps3vuart_port *vp, int param, uint64_t val)
 444 {
 445         int err;
 446
 447         PS3VUART_PORT_LOCK(vp);
 448
 449         if (param == PS3VUART_PORT_PARAM_INTR_MASK)
 450                 err = ps3vuart_port_set_intr_mask(vp, val);
 451         else
 452                 err = lv1_set_virtual_uart_param(vp->vp_port, param, val);
 453
 454         PS3VUART_PORT_UNLOCK(vp);
 455
 456         return (err);
 457 }
 458
 459 int
 460 ps3vuart_port_get_param(struct ps3vuart_port *vp, int param, uint64_t *val)
 461 {
 462         int err;
 463
 464         PS3VUART_PORT_LOCK(vp);
 465
 466         err = lv1_get_virtual_uart_param(vp->vp_port, param, val);
 467         if (err)
 468                 goto out;
 469
 470         switch (param) {
 471         case PS3VUART_PORT_PARAM_RX_BYTES:
 472                 *val += vp->vp_rx_bufq_bytes;
 473         break;
 474         case PS3VUART_PORT_PARAM_INTR_STAT:
 475                 *val &= vp->vp_intr_mask;
 476         break;
 477         }
 478
 479 out:
 480
 481         PS3VUART_PORT_UNLOCK(vp);
 482
 483         return (err);
 484 }
 485
 486 void
 487 ps3vuart_port_intr(struct ps3vuart_port *vp)
 488 {
 489         uint64_t status;
 490         int err;
 491
 492         PS3VUART_PORT_LOCK(vp);
 493
 494         err = lv1_get_virtual_uart_param(vp->vp_port,
 495             PS3VUART_PORT_PARAM_INTR_STAT, &status);
 496         if (err)
 497                 goto out;
 498
 499         KASSERT(status & PS3VUART_PORT_INTR_CONNECT,
 500             ("port %d disconnected", vp->vp_port));
 501         KASSERT(!(status & PS3VUART_PORT_INTR_DISCONNECT),
 502             ("port %d disconnected", vp->vp_port));
 503
 504         status &= vp->vp_intr_mask;
 505
 506         if (status & PS3VUART_PORT_INTR_RX) {
 507                 vp->vp_stat.vs_rx_intrs++;
 508                 ps3vuart_port_pull(vp, NULL);
 509         }
 510
 511         if (status & PS3VUART_PORT_INTR_TX) {
 512                 vp->vp_stat.vs_tx_intrs++;
 513                 ps3vuart_port_push(vp, NULL);
 514         }
 515
 516 out:
 517
 518         PS3VUART_PORT_UNLOCK(vp);
 519 }
 520
 521 void
 522 ps3vuart_port_get_stat(struct ps3vuart_port *vp,
 523     struct ps3vuart_port_stat *stat)
 524 {
 525         PS3VUART_PORT_LOCK(vp);
 526
 527         *stat = vp->vp_stat;
 528
 529         PS3VUART_PORT_UNLOCK(vp);
 530 }
 531
 532 static int
 533 ps3vuart_port_modevent(module_t mod, int type, void *data)
 534 {
 535         int err = 0;
 536
 537         switch (type) {
 538         case MOD_LOAD:
 539         case MOD_UNLOAD:
 540         break;
 541         default:
 542                 err = EOPNOTSUPP;
 543         }
 544
 545         return (err);
 546 }
 547
 548 static moduledata_t ps3vuart_port_mod = {
 549         "ps3vuart_port",
 550         ps3vuart_port_modevent,
 551         NULL
 552 };
 553
 554 DECLARE_MODULE(ps3vuart_port, ps3vuart_port_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
 555 MODULE_VERSION(ps3vuart_port, 1);