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, ®, 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, ®, 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 970