sys/arm/ti/ti_adc.c

   1 /*-
   2  * Copyright 2014 Luiz Otavio O Souza <loos@freebsd.org>
   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  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include "opt_evdev.h"
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/bus.h>
  35
  36 #include <sys/conf.h>
  37 #include <sys/kernel.h>
  38 #include <sys/limits.h>
  39 #include <sys/lock.h>
  40 #include <sys/module.h>
  41 #include <sys/mutex.h>
  42 #include <sys/condvar.h>
  43 #include <sys/resource.h>
  44 #include <sys/rman.h>
  45 #include <sys/sysctl.h>
  46 #include <sys/selinfo.h>
  47 #include <sys/poll.h>
  48 #include <sys/uio.h>
  49
  50 #include <machine/bus.h>
  51
  52 #include <dev/ofw/openfirm.h>
  53 #include <dev/ofw/ofw_bus.h>
  54 #include <dev/ofw/ofw_bus_subr.h>
  55
  56 #ifdef EVDEV_SUPPORT
  57 #include <dev/evdev/input.h>
  58 #include <dev/evdev/evdev.h>
  59 #endif
  60
  61 #include <arm/ti/ti_prcm.h>
  62 #include <arm/ti/ti_adcreg.h>
  63 #include <arm/ti/ti_adcvar.h>
  64
  65 #undef  DEBUG_TSC
  66
  67 #define DEFAULT_CHARGE_DELAY    0x400
  68 #define STEPDLY_OPEN            0x98
  69
  70 #define ORDER_XP        0
  71 #define ORDER_XN        1
  72 #define ORDER_YP        2
  73 #define ORDER_YN        3
  74
  75 /* Define our 8 steps, one for each input channel. */
  76 static struct ti_adc_input ti_adc_inputs[TI_ADC_NPINS] = {
  77         { .stepconfig = ADC_STEPCFG(1), .stepdelay = ADC_STEPDLY(1) },
  78         { .stepconfig = ADC_STEPCFG(2), .stepdelay = ADC_STEPDLY(2) },
  79         { .stepconfig = ADC_STEPCFG(3), .stepdelay = ADC_STEPDLY(3) },
  80         { .stepconfig = ADC_STEPCFG(4), .stepdelay = ADC_STEPDLY(4) },
  81         { .stepconfig = ADC_STEPCFG(5), .stepdelay = ADC_STEPDLY(5) },
  82         { .stepconfig = ADC_STEPCFG(6), .stepdelay = ADC_STEPDLY(6) },
  83         { .stepconfig = ADC_STEPCFG(7), .stepdelay = ADC_STEPDLY(7) },
  84         { .stepconfig = ADC_STEPCFG(8), .stepdelay = ADC_STEPDLY(8) },
  85 };
  86
  87 static int ti_adc_samples[5] = { 0, 2, 4, 8, 16 };
  88
  89 static int ti_adc_detach(device_t dev);
  90
  91 #ifdef EVDEV_SUPPORT
  92 static void
  93 ti_adc_ev_report(struct ti_adc_softc *sc)
  94 {
  95
  96         evdev_push_event(sc->sc_evdev, EV_ABS, ABS_X, sc->sc_x);
  97         evdev_push_event(sc->sc_evdev, EV_ABS, ABS_Y, sc->sc_y);
  98         evdev_push_event(sc->sc_evdev, EV_KEY, BTN_TOUCH, sc->sc_pen_down);
  99         evdev_sync(sc->sc_evdev);
 100 }
 101 #endif /* EVDEV */
 102
 103 static void
 104 ti_adc_enable(struct ti_adc_softc *sc)
 105 {
 106         uint32_t reg;
 107
 108         TI_ADC_LOCK_ASSERT(sc);
 109
 110         if (sc->sc_last_state == 1)
 111                 return;
 112
 113         /* Enable the FIFO0 threshold and the end of sequence interrupt. */
 114         ADC_WRITE4(sc, ADC_IRQENABLE_SET,
 115             ADC_IRQ_FIFO0_THRES | ADC_IRQ_FIFO1_THRES | ADC_IRQ_END_OF_SEQ);
 116
 117         reg = ADC_CTRL_STEP_WP | ADC_CTRL_STEP_ID;
 118         if (sc->sc_tsc_wires > 0) {
 119                 reg |= ADC_CTRL_TSC_ENABLE;
 120                 switch (sc->sc_tsc_wires) {
 121                 case 4:
 122                         reg |= ADC_CTRL_TSC_4WIRE;
 123                         break;
 124                 case 5:
 125                         reg |= ADC_CTRL_TSC_5WIRE;
 126                         break;
 127                 case 8:
 128                         reg |= ADC_CTRL_TSC_8WIRE;
 129                         break;
 130                 default:
 131                         break;
 132                 }
 133         }
 134         reg |= ADC_CTRL_ENABLE;
 135         /* Enable the ADC.  Run thru enabled steps, start the conversions. */
 136         ADC_WRITE4(sc, ADC_CTRL, reg);
 137
 138         sc->sc_last_state = 1;
 139 }
 140
 141 static void
 142 ti_adc_disable(struct ti_adc_softc *sc)
 143 {
 144         int count;
 145         uint32_t data;
 146
 147         TI_ADC_LOCK_ASSERT(sc);
 148
 149         if (sc->sc_last_state == 0)
 150                 return;
 151
 152         /* Disable all the enabled steps. */
 153         ADC_WRITE4(sc, ADC_STEPENABLE, 0);
 154
 155         /* Disable the ADC. */
 156         ADC_WRITE4(sc, ADC_CTRL, ADC_READ4(sc, ADC_CTRL) & ~ADC_CTRL_ENABLE);
 157
 158         /* Disable the FIFO0 threshold and the end of sequence interrupt. */
 159         ADC_WRITE4(sc, ADC_IRQENABLE_CLR,
 160             ADC_IRQ_FIFO0_THRES | ADC_IRQ_FIFO1_THRES | ADC_IRQ_END_OF_SEQ);
 161
 162         /* ACK any pending interrupt. */
 163         ADC_WRITE4(sc, ADC_IRQSTATUS, ADC_READ4(sc, ADC_IRQSTATUS));
 164
 165         /* Drain the FIFO data. */
 166         count = ADC_READ4(sc, ADC_FIFO0COUNT) & ADC_FIFO_COUNT_MSK;
 167         while (count > 0) {
 168                 data = ADC_READ4(sc, ADC_FIFO0DATA);
 169                 count = ADC_READ4(sc, ADC_FIFO0COUNT) & ADC_FIFO_COUNT_MSK;
 170         }
 171
 172         count = ADC_READ4(sc, ADC_FIFO1COUNT) & ADC_FIFO_COUNT_MSK;
 173         while (count > 0) {
 174                 data = ADC_READ4(sc, ADC_FIFO1DATA);
 175                 count = ADC_READ4(sc, ADC_FIFO1COUNT) & ADC_FIFO_COUNT_MSK;
 176         }
 177
 178         sc->sc_last_state = 0;
 179 }
 180
 181 static int
 182 ti_adc_setup(struct ti_adc_softc *sc)
 183 {
 184         int ain, i;
 185         uint32_t enabled;
 186
 187         TI_ADC_LOCK_ASSERT(sc);
 188
 189         /* Check for enabled inputs. */
 190         enabled = sc->sc_tsc_enabled;
 191         for (i = 0; i < sc->sc_adc_nchannels; i++) {
 192                 ain = sc->sc_adc_channels[i];
 193                 if (ti_adc_inputs[ain].enable)
 194                         enabled |= (1U << (ain + 1));
 195         }
 196
 197         /* Set the ADC global status. */
 198         if (enabled != 0) {
 199                 ti_adc_enable(sc);
 200                 /* Update the enabled steps. */
 201                 if (enabled != ADC_READ4(sc, ADC_STEPENABLE))
 202                         ADC_WRITE4(sc, ADC_STEPENABLE, enabled);
 203         } else
 204                 ti_adc_disable(sc);
 205
 206         return (0);
 207 }
 208
 209 static void
 210 ti_adc_input_setup(struct ti_adc_softc *sc, int32_t ain)
 211 {
 212         struct ti_adc_input *input;
 213         uint32_t reg, val;
 214
 215         TI_ADC_LOCK_ASSERT(sc);
 216
 217         input = &ti_adc_inputs[ain];
 218         reg = input->stepconfig;
 219         val = ADC_READ4(sc, reg);
 220
 221         /* Set single ended operation. */
 222         val &= ~ADC_STEP_DIFF_CNTRL;
 223
 224         /* Set the negative voltage reference. */
 225         val &= ~ADC_STEP_RFM_MSK;
 226
 227         /* Set the positive voltage reference. */
 228         val &= ~ADC_STEP_RFP_MSK;
 229
 230         /* Set the samples average. */
 231         val &= ~ADC_STEP_AVG_MSK;
 232         val |= input->samples << ADC_STEP_AVG_SHIFT;
 233
 234         /* Select the desired input. */
 235         val &= ~ADC_STEP_INP_MSK;
 236         val |= ain << ADC_STEP_INP_SHIFT;
 237
 238         /* Set the ADC to one-shot mode. */
 239         val &= ~ADC_STEP_MODE_MSK;
 240
 241         ADC_WRITE4(sc, reg, val);
 242 }
 243
 244 static void
 245 ti_adc_reset(struct ti_adc_softc *sc)
 246 {
 247         int ain, i;
 248
 249         TI_ADC_LOCK_ASSERT(sc);
 250
 251         /* Disable all the inputs. */
 252         for (i = 0; i < sc->sc_adc_nchannels; i++) {
 253                 ain = sc->sc_adc_channels[i];
 254                 ti_adc_inputs[ain].enable = 0;
 255         }
 256 }
 257
 258 static int
 259 ti_adc_clockdiv_proc(SYSCTL_HANDLER_ARGS)
 260 {
 261         int error, reg;
 262         struct ti_adc_softc *sc;
 263
 264         sc = (struct ti_adc_softc *)arg1;
 265
 266         TI_ADC_LOCK(sc);
 267         reg = (int)ADC_READ4(sc, ADC_CLKDIV) + 1;
 268         TI_ADC_UNLOCK(sc);
 269
 270         error = sysctl_handle_int(oidp, &reg, sizeof(reg), req);
 271         if (error != 0 || req->newptr == NULL)
 272                 return (error);
 273
 274         /*
 275          * The actual written value is the prescaler setting - 1.
 276          * Enforce a minimum value of 10 (i.e. 9) which limits the maximum
 277          * ADC clock to ~2.4Mhz (CLK_M_OSC / 10).
 278          */
 279         reg--;
 280         if (reg < 9)
 281                 reg = 9;
 282         if (reg > USHRT_MAX)
 283                 reg = USHRT_MAX;
 284
 285         TI_ADC_LOCK(sc);
 286         /* Disable the ADC. */
 287         ti_adc_disable(sc);
 288         /* Update the ADC prescaler setting. */
 289         ADC_WRITE4(sc, ADC_CLKDIV, reg);
 290         /* Enable the ADC again. */
 291         ti_adc_setup(sc);
 292         TI_ADC_UNLOCK(sc);
 293
 294         return (0);
 295 }
 296
 297 static int
 298 ti_adc_enable_proc(SYSCTL_HANDLER_ARGS)
 299 {
 300         int error;
 301         int32_t enable;
 302         struct ti_adc_softc *sc;
 303         struct ti_adc_input *input;
 304
 305         input = (struct ti_adc_input *)arg1;
 306         sc = input->sc;
 307
 308         enable = input->enable;
 309         error = sysctl_handle_int(oidp, &enable, sizeof(enable),
 310             req);
 311         if (error != 0 || req->newptr == NULL)
 312                 return (error);
 313
 314         if (enable)
 315                 enable = 1;
 316
 317         TI_ADC_LOCK(sc);
 318         /* Setup the ADC as needed. */
 319         if (input->enable != enable) {
 320                 input->enable = enable;
 321                 ti_adc_setup(sc);
 322                 if (input->enable == 0)
 323                         input->value = 0;
 324         }
 325         TI_ADC_UNLOCK(sc);
 326
 327         return (0);
 328 }
 329
 330 static int
 331 ti_adc_open_delay_proc(SYSCTL_HANDLER_ARGS)
 332 {
 333         int error, reg;
 334         struct ti_adc_softc *sc;
 335         struct ti_adc_input *input;
 336
 337         input = (struct ti_adc_input *)arg1;
 338         sc = input->sc;
 339
 340         TI_ADC_LOCK(sc);
 341         reg = (int)ADC_READ4(sc, input->stepdelay) & ADC_STEP_OPEN_DELAY;
 342         TI_ADC_UNLOCK(sc);
 343
 344         error = sysctl_handle_int(oidp, &reg, sizeof(reg), req);
 345         if (error != 0 || req->newptr == NULL)
 346                 return (error);
 347
 348         if (reg < 0)
 349                 reg = 0;
 350
 351         TI_ADC_LOCK(sc);
 352         ADC_WRITE4(sc, input->stepdelay, reg & ADC_STEP_OPEN_DELAY);
 353         TI_ADC_UNLOCK(sc);
 354
 355         return (0);
 356 }
 357
 358 static int
 359 ti_adc_samples_avg_proc(SYSCTL_HANDLER_ARGS)
 360 {
 361         int error, samples, i;
 362         struct ti_adc_softc *sc;
 363         struct ti_adc_input *input;
 364
 365         input = (struct ti_adc_input *)arg1;
 366         sc = input->sc;
 367
 368         if (input->samples > nitems(ti_adc_samples))
 369                 input->samples = nitems(ti_adc_samples);
 370         samples = ti_adc_samples[input->samples];
 371
 372         error = sysctl_handle_int(oidp, &samples, 0, req);
 373         if (error != 0 || req->newptr == NULL)
 374                 return (error);
 375
 376         TI_ADC_LOCK(sc);
 377         if (samples != ti_adc_samples[input->samples]) {
 378                 input->samples = 0;
 379                 for (i = 0; i < nitems(ti_adc_samples); i++)
 380                         if (samples >= ti_adc_samples[i])
 381                                 input->samples = i;
 382                 ti_adc_input_setup(sc, input->input);
 383         }
 384         TI_ADC_UNLOCK(sc);
 385
 386         return (error);
 387 }
 388
 389 static void
 390 ti_adc_read_data(struct ti_adc_softc *sc)
 391 {
 392         int count, ain;
 393         struct ti_adc_input *input;
 394         uint32_t data;
 395
 396         TI_ADC_LOCK_ASSERT(sc);
 397
 398         /* Read the available data. */
 399         count = ADC_READ4(sc, ADC_FIFO0COUNT) & ADC_FIFO_COUNT_MSK;
 400         while (count > 0) {
 401                 data = ADC_READ4(sc, ADC_FIFO0DATA);
 402                 ain = (data & ADC_FIFO_STEP_ID_MSK) >> ADC_FIFO_STEP_ID_SHIFT;
 403                 input = &ti_adc_inputs[ain];
 404                 if (input->enable == 0)
 405                         input->value = 0;
 406                 else
 407                         input->value = (int32_t)(data & ADC_FIFO_DATA_MSK);
 408                 count = ADC_READ4(sc, ADC_FIFO0COUNT) & ADC_FIFO_COUNT_MSK;
 409         }
 410 }
 411
 412 static int
 413 cmp_values(const void *a, const void *b)
 414 {
 415         const uint32_t *v1, *v2;
 416         v1 = a;
 417         v2 = b;
 418         if (*v1 < *v2)
 419                 return -1;
 420         if (*v1 > *v2)
 421                 return 1;
 422
 423         return (0);
 424 }
 425
 426 static void
 427 ti_adc_tsc_read_data(struct ti_adc_softc *sc)
 428 {
 429         int count;
 430         uint32_t data[16];
 431         uint32_t x, y;
 432         int i, start, end;
 433
 434         TI_ADC_LOCK_ASSERT(sc);
 435
 436         /* Read the available data. */
 437         count = ADC_READ4(sc, ADC_FIFO1COUNT) & ADC_FIFO_COUNT_MSK;
 438         if (count == 0)
 439                 return;
 440
 441         i = 0;
 442         while (count > 0) {
 443                 data[i++] = ADC_READ4(sc, ADC_FIFO1DATA) & ADC_FIFO_DATA_MSK;
 444                 count = ADC_READ4(sc, ADC_FIFO1COUNT) & ADC_FIFO_COUNT_MSK;
 445         }
 446
 447         if (sc->sc_coord_readouts > 3) {
 448                 start = 1;
 449                 end = sc->sc_coord_readouts - 1;
 450                 qsort(data, sc->sc_coord_readouts,
 451                         sizeof(data[0]), &cmp_values);
 452                 qsort(&data[sc->sc_coord_readouts + 2],
 453                         sc->sc_coord_readouts,
 454                         sizeof(data[0]), &cmp_values);
 455         }
 456         else {
 457                 start = 0;
 458                 end = sc->sc_coord_readouts;
 459         }
 460
 461         x = y = 0;
 462         for (i = start; i < end; i++)
 463                 y += data[i];
 464         y /= (end - start);
 465
 466         for (i = sc->sc_coord_readouts + 2 + start; i < sc->sc_coord_readouts + 2 + end; i++)
 467                 x += data[i];
 468         x /= (end - start);
 469
 470 #ifdef DEBUG_TSC
 471         device_printf(sc->sc_dev, "touchscreen x: %d, y: %d\n", x, y);
 472 #endif
 473
 474 #ifdef EVDEV_SUPPORT
 475         if ((sc->sc_x != x) || (sc->sc_y != y)) {
 476                 sc->sc_x = x;
 477                 sc->sc_y = y;
 478                 ti_adc_ev_report(sc);
 479         }
 480 #endif
 481 }
 482
 483 static void
 484 ti_adc_intr_locked(struct ti_adc_softc *sc, uint32_t status)
 485 {
 486         /* Read the available data. */
 487         if (status & ADC_IRQ_FIFO0_THRES)
 488                 ti_adc_read_data(sc);
 489 }
 490
 491 static void
 492 ti_adc_tsc_intr_locked(struct ti_adc_softc *sc, uint32_t status)
 493 {
 494         /* Read the available data. */
 495         if (status & ADC_IRQ_FIFO1_THRES)
 496                 ti_adc_tsc_read_data(sc);
 497
 498 }
 499
 500 static void
 501 ti_adc_intr(void *arg)
 502 {
 503         struct ti_adc_softc *sc;
 504         uint32_t status, rawstatus;
 505
 506         sc = (struct ti_adc_softc *)arg;
 507
 508         TI_ADC_LOCK(sc);
 509
 510         rawstatus = ADC_READ4(sc, ADC_IRQSTATUS_RAW);
 511         status = ADC_READ4(sc, ADC_IRQSTATUS);
 512
 513         if (rawstatus & ADC_IRQ_HW_PEN_ASYNC) {
 514                 sc->sc_pen_down = 1;
 515                 status |= ADC_IRQ_HW_PEN_ASYNC;
 516                 ADC_WRITE4(sc, ADC_IRQENABLE_CLR,
 517                         ADC_IRQ_HW_PEN_ASYNC);
 518 #ifdef EVDEV_SUPPORT
 519                 ti_adc_ev_report(sc);
 520 #endif
 521         }
 522
 523         if (rawstatus & ADC_IRQ_PEN_UP) {
 524                 sc->sc_pen_down = 0;
 525                 status |= ADC_IRQ_PEN_UP;
 526 #ifdef EVDEV_SUPPORT
 527                 ti_adc_ev_report(sc);
 528 #endif
 529         }
 530
 531         if (status & ADC_IRQ_FIFO0_THRES)
 532                 ti_adc_intr_locked(sc, status);
 533
 534         if (status & ADC_IRQ_FIFO1_THRES)
 535                 ti_adc_tsc_intr_locked(sc, status);
 536
 537         if (status) {
 538                 /* ACK the interrupt. */
 539                 ADC_WRITE4(sc, ADC_IRQSTATUS, status);
 540         }
 541
 542         /* Start the next conversion ? */
 543         if (status & ADC_IRQ_END_OF_SEQ)
 544                 ti_adc_setup(sc);
 545
 546         TI_ADC_UNLOCK(sc);
 547 }
 548
 549 static void
 550 ti_adc_sysctl_init(struct ti_adc_softc *sc)
 551 {
 552         char pinbuf[3];
 553         struct sysctl_ctx_list *ctx;
 554         struct sysctl_oid *tree_node, *inp_node, *inpN_node;
 555         struct sysctl_oid_list *tree, *inp_tree, *inpN_tree;
 556         int ain, i;
 557
 558         /*
 559          * Add per-pin sysctl tree/handlers.
 560          */
 561         ctx = device_get_sysctl_ctx(sc->sc_dev);
 562         tree_node = device_get_sysctl_tree(sc->sc_dev);
 563         tree = SYSCTL_CHILDREN(tree_node);
 564         SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "clockdiv",
 565             CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_NEEDGIANT,  sc, 0,
 566             ti_adc_clockdiv_proc, "IU", "ADC clock prescaler");
 567         inp_node = SYSCTL_ADD_NODE(ctx, tree, OID_AUTO, "ain",
 568             CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "ADC inputs");
 569         inp_tree = SYSCTL_CHILDREN(inp_node);
 570
 571         for (i = 0; i < sc->sc_adc_nchannels; i++) {
 572                 ain = sc->sc_adc_channels[i];
 573
 574                 snprintf(pinbuf, sizeof(pinbuf), "%d", ain);
 575                 inpN_node = SYSCTL_ADD_NODE(ctx, inp_tree, OID_AUTO, pinbuf,
 576                     CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "ADC input");
 577                 inpN_tree = SYSCTL_CHILDREN(inpN_node);
 578
 579                 SYSCTL_ADD_PROC(ctx, inpN_tree, OID_AUTO, "enable",
 580                     CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_NEEDGIANT,
 581                     &ti_adc_inputs[ain], 0,
 582                     ti_adc_enable_proc, "IU", "Enable ADC input");
 583                 SYSCTL_ADD_PROC(ctx, inpN_tree, OID_AUTO, "open_delay",
 584                     CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_NEEDGIANT,
 585                     &ti_adc_inputs[ain], 0,
 586                     ti_adc_open_delay_proc, "IU", "ADC open delay");
 587                 SYSCTL_ADD_PROC(ctx, inpN_tree, OID_AUTO, "samples_avg",
 588                     CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_NEEDGIANT,
 589                     &ti_adc_inputs[ain], 0,
 590                     ti_adc_samples_avg_proc, "IU", "ADC samples average");
 591                 SYSCTL_ADD_INT(ctx, inpN_tree, OID_AUTO, "input",
 592                     CTLFLAG_RD, &ti_adc_inputs[ain].value, 0,
 593                     "Converted raw value for the ADC input");
 594         }
 595 }
 596
 597 static void
 598 ti_adc_inputs_init(struct ti_adc_softc *sc)
 599 {
 600         int ain, i;
 601         struct ti_adc_input *input;
 602
 603         TI_ADC_LOCK(sc);
 604         for (i = 0; i < sc->sc_adc_nchannels; i++) {
 605                 ain = sc->sc_adc_channels[i];
 606                 input = &ti_adc_inputs[ain];
 607                 input->sc = sc;
 608                 input->input = ain;
 609                 input->value = 0;
 610                 input->enable = 0;
 611                 input->samples = 0;
 612                 ti_adc_input_setup(sc, ain);
 613         }
 614         TI_ADC_UNLOCK(sc);
 615 }
 616
 617 static void
 618 ti_adc_tsc_init(struct ti_adc_softc *sc)
 619 {
 620         int i, start_step, end_step;
 621         uint32_t stepconfig, val;
 622
 623         TI_ADC_LOCK(sc);
 624
 625         /* X coordinates */
 626         stepconfig = ADC_STEP_FIFO1 | (4 << ADC_STEP_AVG_SHIFT) |
 627             ADC_STEP_MODE_HW_ONESHOT | sc->sc_xp_bit;
 628         if (sc->sc_tsc_wires == 4)
 629                 stepconfig |= ADC_STEP_INP(sc->sc_yp_inp) | sc->sc_xn_bit;
 630         else if (sc->sc_tsc_wires == 5)
 631                 stepconfig |= ADC_STEP_INP(4) |
 632                         sc->sc_xn_bit | sc->sc_yn_bit | sc->sc_yp_bit;
 633         else if (sc->sc_tsc_wires == 8)
 634                 stepconfig |= ADC_STEP_INP(sc->sc_yp_inp) | sc->sc_xn_bit;
 635
 636         start_step = ADC_STEPS - sc->sc_coord_readouts + 1;
 637         end_step = start_step + sc->sc_coord_readouts - 1;
 638         for (i = start_step; i <= end_step; i++) {
 639                 ADC_WRITE4(sc, ADC_STEPCFG(i), stepconfig);
 640                 ADC_WRITE4(sc, ADC_STEPDLY(i), STEPDLY_OPEN);
 641         }
 642
 643         /* Y coordinates */
 644         stepconfig = ADC_STEP_FIFO1 | (4 << ADC_STEP_AVG_SHIFT) |
 645             ADC_STEP_MODE_HW_ONESHOT | sc->sc_yn_bit |
 646             ADC_STEP_INM(8);
 647         if (sc->sc_tsc_wires == 4)
 648                 stepconfig |= ADC_STEP_INP(sc->sc_xp_inp) | sc->sc_yp_bit;
 649         else if (sc->sc_tsc_wires == 5)
 650                 stepconfig |= ADC_STEP_INP(4) |
 651                         sc->sc_xp_bit | sc->sc_xn_bit | sc->sc_yp_bit;
 652         else if (sc->sc_tsc_wires == 8)
 653                 stepconfig |= ADC_STEP_INP(sc->sc_xp_inp) | sc->sc_yp_bit;
 654
 655         start_step = ADC_STEPS - (sc->sc_coord_readouts*2 + 2) + 1;
 656         end_step = start_step + sc->sc_coord_readouts - 1;
 657         for (i = start_step; i <= end_step; i++) {
 658                 ADC_WRITE4(sc, ADC_STEPCFG(i), stepconfig);
 659                 ADC_WRITE4(sc, ADC_STEPDLY(i), STEPDLY_OPEN);
 660         }
 661
 662         /* Charge config */
 663         val = ADC_READ4(sc, ADC_IDLECONFIG);
 664         ADC_WRITE4(sc, ADC_TC_CHARGE_STEPCONFIG, val);
 665         ADC_WRITE4(sc, ADC_TC_CHARGE_DELAY, sc->sc_charge_delay);
 666
 667         /* 2 steps for Z */
 668         start_step = ADC_STEPS - (sc->sc_coord_readouts + 2) + 1;
 669         stepconfig = ADC_STEP_FIFO1 | (4 << ADC_STEP_AVG_SHIFT) |
 670             ADC_STEP_MODE_HW_ONESHOT | sc->sc_yp_bit |
 671             sc->sc_xn_bit | ADC_STEP_INP(sc->sc_xp_inp) |
 672             ADC_STEP_INM(8);
 673         ADC_WRITE4(sc, ADC_STEPCFG(start_step), stepconfig);
 674         ADC_WRITE4(sc, ADC_STEPDLY(start_step), STEPDLY_OPEN);
 675         start_step++;
 676         stepconfig |= ADC_STEP_INP(sc->sc_yn_inp);
 677         ADC_WRITE4(sc, ADC_STEPCFG(start_step), stepconfig);
 678         ADC_WRITE4(sc, ADC_STEPDLY(start_step), STEPDLY_OPEN);
 679
 680         ADC_WRITE4(sc, ADC_FIFO1THRESHOLD, (sc->sc_coord_readouts*2 + 2) - 1);
 681
 682         sc->sc_tsc_enabled = 1;
 683         start_step = ADC_STEPS - (sc->sc_coord_readouts*2 + 2) + 1;
 684         end_step = ADC_STEPS;
 685         for (i = start_step; i <= end_step; i++) {
 686                 sc->sc_tsc_enabled |= (1 << i);
 687         }
 688
 689
 690         TI_ADC_UNLOCK(sc);
 691 }
 692
 693 static void
 694 ti_adc_idlestep_init(struct ti_adc_softc *sc)
 695 {
 696         uint32_t val;
 697
 698         val = ADC_STEP_YNN_SW | ADC_STEP_INM(8) | ADC_STEP_INP(8) | ADC_STEP_YPN_SW;
 699
 700         ADC_WRITE4(sc, ADC_IDLECONFIG, val);
 701 }
 702
 703 static int
 704 ti_adc_config_wires(struct ti_adc_softc *sc, int *wire_configs, int nwire_configs)
 705 {
 706         int i;
 707         int wire, ai;
 708
 709         for (i = 0; i < nwire_configs; i++) {
 710                 wire = wire_configs[i] & 0xf;
 711                 ai = (wire_configs[i] >> 4) & 0xf;
 712                 switch (wire) {
 713                 case ORDER_XP:
 714                         sc->sc_xp_bit = ADC_STEP_XPP_SW;
 715                         sc->sc_xp_inp = ai;
 716                         break;
 717                 case ORDER_XN:
 718                         sc->sc_xn_bit = ADC_STEP_XNN_SW;
 719                         sc->sc_xn_inp = ai;
 720                         break;
 721                 case ORDER_YP:
 722                         sc->sc_yp_bit = ADC_STEP_YPP_SW;
 723                         sc->sc_yp_inp = ai;
 724                         break;
 725                 case ORDER_YN:
 726                         sc->sc_yn_bit = ADC_STEP_YNN_SW;
 727                         sc->sc_yn_inp = ai;
 728                         break;
 729                 default:
 730                         device_printf(sc->sc_dev, "Invalid wire config\n");
 731                         return (-1);
 732                 }
 733         }
 734         return (0);
 735 }
 736
 737 static int
 738 ti_adc_probe(device_t dev)
 739 {
 740
 741         if (!ofw_bus_is_compatible(dev, "ti,am3359-tscadc"))
 742                 return (ENXIO);
 743         device_set_desc(dev, "TI ADC controller");
 744
 745         return (BUS_PROBE_DEFAULT);
 746 }
 747
 748 static int
 749 ti_adc_attach(device_t dev)
 750 {
 751         int err, rid, i;
 752         struct ti_adc_softc *sc;
 753         uint32_t rev, reg;
 754         phandle_t node, child;
 755         pcell_t cell;
 756         int *channels;
 757         int nwire_configs;
 758         int *wire_configs;
 759
 760         sc = device_get_softc(dev);
 761         sc->sc_dev = dev;
 762
 763         node = ofw_bus_get_node(dev);
 764
 765         sc->sc_tsc_wires = 0;
 766         sc->sc_coord_readouts = 1;
 767         sc->sc_x_plate_resistance = 0;
 768         sc->sc_charge_delay = DEFAULT_CHARGE_DELAY;
 769         /* Read "tsc" node properties */
 770         child = ofw_bus_find_child(node, "tsc");
 771         if (child != 0 && OF_hasprop(child, "ti,wires")) {
 772                 if ((OF_getencprop(child, "ti,wires", &cell, sizeof(cell))) > 0)
 773                         sc->sc_tsc_wires = cell;
 774                 if ((OF_getencprop(child, "ti,coordinate-readouts", &cell,
 775                     sizeof(cell))) > 0)
 776                         sc->sc_coord_readouts = cell;
 777                 if ((OF_getencprop(child, "ti,x-plate-resistance", &cell,
 778                     sizeof(cell))) > 0)
 779                         sc->sc_x_plate_resistance = cell;
 780                 if ((OF_getencprop(child, "ti,charge-delay", &cell,
 781                     sizeof(cell))) > 0)
 782                         sc->sc_charge_delay = cell;
 783                 nwire_configs = OF_getencprop_alloc_multi(child,
 784                     "ti,wire-config", sizeof(*wire_configs),
 785                     (void **)&wire_configs);
 786                 if (nwire_configs != sc->sc_tsc_wires) {
 787                         device_printf(sc->sc_dev,
 788                             "invalid number of ti,wire-config: %d (should be %d)\n",
 789                             nwire_configs, sc->sc_tsc_wires);
 790                         OF_prop_free(wire_configs);
 791                         return (EINVAL);
 792                 }
 793                 err = ti_adc_config_wires(sc, wire_configs, nwire_configs);
 794                 OF_prop_free(wire_configs);
 795                 if (err)
 796                         return (EINVAL);
 797         }
 798
 799         /* Read "adc" node properties */
 800         child = ofw_bus_find_child(node, "adc");
 801         if (child != 0) {
 802                 sc->sc_adc_nchannels = OF_getencprop_alloc_multi(child,
 803                     "ti,adc-channels", sizeof(*channels), (void **)&channels);
 804                 if (sc->sc_adc_nchannels > 0) {
 805                         for (i = 0; i < sc->sc_adc_nchannels; i++)
 806                                 sc->sc_adc_channels[i] = channels[i];
 807                         OF_prop_free(channels);
 808                 }
 809         }
 810
 811         /* Sanity check FDT data */
 812         if (sc->sc_tsc_wires + sc->sc_adc_nchannels > TI_ADC_NPINS) {
 813                 device_printf(dev, "total number of chanels (%d) is larger than %d\n",
 814                     sc->sc_tsc_wires + sc->sc_adc_nchannels, TI_ADC_NPINS);
 815                 return (ENXIO);
 816         }
 817
 818         rid = 0;
 819         sc->sc_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
 820             RF_ACTIVE);
 821         if (!sc->sc_mem_res) {
 822                 device_printf(dev, "cannot allocate memory window\n");
 823                 return (ENXIO);
 824         }
 825
 826         /* Activate the ADC_TSC module. */
 827         err = ti_prcm_clk_enable(TSC_ADC_CLK);
 828         if (err)
 829                 return (err);
 830
 831         rid = 0;
 832         sc->sc_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 833             RF_ACTIVE);
 834         if (!sc->sc_irq_res) {
 835                 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res);
 836                 device_printf(dev, "cannot allocate interrupt\n");
 837                 return (ENXIO);
 838         }
 839
 840         if (bus_setup_intr(dev, sc->sc_irq_res, INTR_TYPE_MISC | INTR_MPSAFE,
 841             NULL, ti_adc_intr, sc, &sc->sc_intrhand) != 0) {
 842                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_irq_res);
 843                 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res);
 844                 device_printf(dev, "Unable to setup the irq handler.\n");
 845                 return (ENXIO);
 846         }
 847
 848         /* Check the ADC revision. */
 849         rev = ADC_READ4(sc, ADC_REVISION);
 850         device_printf(dev,
 851             "scheme: %#x func: %#x rtl: %d rev: %d.%d custom rev: %d\n",
 852             (rev & ADC_REV_SCHEME_MSK) >> ADC_REV_SCHEME_SHIFT,
 853             (rev & ADC_REV_FUNC_MSK) >> ADC_REV_FUNC_SHIFT,
 854             (rev & ADC_REV_RTL_MSK) >> ADC_REV_RTL_SHIFT,
 855             (rev & ADC_REV_MAJOR_MSK) >> ADC_REV_MAJOR_SHIFT,
 856             rev & ADC_REV_MINOR_MSK,
 857             (rev & ADC_REV_CUSTOM_MSK) >> ADC_REV_CUSTOM_SHIFT);
 858
 859         reg = ADC_READ4(sc, ADC_CTRL);
 860         ADC_WRITE4(sc, ADC_CTRL, reg | ADC_CTRL_STEP_WP | ADC_CTRL_STEP_ID);
 861
 862         /*
 863          * Set the ADC prescaler to 2400 if touchscreen is not enabled
 864          * and to 24 if it is.  This sets the ADC clock to ~10Khz and
 865          * ~1Mhz respectively (CLK_M_OSC / prescaler).
 866          */
 867         if (sc->sc_tsc_wires)
 868                 ADC_WRITE4(sc, ADC_CLKDIV, 24 - 1);
 869         else
 870                 ADC_WRITE4(sc, ADC_CLKDIV, 2400 - 1);
 871
 872         TI_ADC_LOCK_INIT(sc);
 873
 874         ti_adc_idlestep_init(sc);
 875         ti_adc_inputs_init(sc);
 876         ti_adc_sysctl_init(sc);
 877         ti_adc_tsc_init(sc);
 878
 879         TI_ADC_LOCK(sc);
 880         ti_adc_setup(sc);
 881         TI_ADC_UNLOCK(sc);
 882
 883 #ifdef EVDEV_SUPPORT
 884         if (sc->sc_tsc_wires > 0) {
 885                 sc->sc_evdev = evdev_alloc();
 886                 evdev_set_name(sc->sc_evdev, device_get_desc(dev));
 887                 evdev_set_phys(sc->sc_evdev, device_get_nameunit(dev));
 888                 evdev_set_id(sc->sc_evdev, BUS_VIRTUAL, 0, 0, 0);
 889                 evdev_support_prop(sc->sc_evdev, INPUT_PROP_DIRECT);
 890                 evdev_support_event(sc->sc_evdev, EV_SYN);
 891                 evdev_support_event(sc->sc_evdev, EV_ABS);
 892                 evdev_support_event(sc->sc_evdev, EV_KEY);
 893
 894                 evdev_support_abs(sc->sc_evdev, ABS_X, 0, 0,
 895                     ADC_MAX_VALUE, 0, 0, 0);
 896                 evdev_support_abs(sc->sc_evdev, ABS_Y, 0, 0,
 897                     ADC_MAX_VALUE, 0, 0, 0);
 898
 899                 evdev_support_key(sc->sc_evdev, BTN_TOUCH);
 900
 901                 err = evdev_register(sc->sc_evdev);
 902                 if (err) {
 903                         device_printf(dev,
 904                             "failed to register evdev: error=%d\n", err);
 905                         ti_adc_detach(dev);
 906                         return (err);
 907                 }
 908
 909                 sc->sc_pen_down = 0;
 910                 sc->sc_x = -1;
 911                 sc->sc_y = -1;
 912         }
 913 #endif /* EVDEV */
 914
 915         return (0);
 916 }
 917
 918 static int
 919 ti_adc_detach(device_t dev)
 920 {
 921         struct ti_adc_softc *sc;
 922
 923         sc = device_get_softc(dev);
 924
 925         /* Turn off the ADC. */
 926         TI_ADC_LOCK(sc);
 927         ti_adc_reset(sc);
 928         ti_adc_setup(sc);
 929
 930 #ifdef EVDEV_SUPPORT
 931         evdev_free(sc->sc_evdev);
 932 #endif
 933
 934         TI_ADC_UNLOCK(sc);
 935
 936         TI_ADC_LOCK_DESTROY(sc);
 937
 938         if (sc->sc_intrhand)
 939                 bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_intrhand);
 940         if (sc->sc_irq_res)
 941                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_irq_res);
 942         if (sc->sc_mem_res)
 943                 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res);
 944
 945         return (bus_generic_detach(dev));
 946 }
 947
 948 static device_method_t ti_adc_methods[] = {
 949         DEVMETHOD(device_probe,         ti_adc_probe),
 950         DEVMETHOD(device_attach,        ti_adc_attach),
 951         DEVMETHOD(device_detach,        ti_adc_detach),
 952
 953         DEVMETHOD_END
 954 };
 955
 956 static driver_t ti_adc_driver = {
 957         "ti_adc",
 958         ti_adc_methods,
 959         sizeof(struct ti_adc_softc),
 960 };
 961
 962 static devclass_t ti_adc_devclass;
 963
 964 DRIVER_MODULE(ti_adc, simplebus, ti_adc_driver, ti_adc_devclass, 0, 0);
 965 MODULE_VERSION(ti_adc, 1);
 966 MODULE_DEPEND(ti_adc, simplebus, 1, 1, 1);
 967 #ifdef EVDEV_SUPPORT
 968 MODULE_DEPEND(ti_adc, evdev, 1, 1, 1);
 969 #endif