1275970Scy/* 2275970Scy * Copyright (c) 2008, 2009 Michael Shalayeff 3275970Scy * Copyright (c) 2009, 2010 Hans-Joerg Hoexer 4275970Scy * All rights reserved. 5275970Scy * 6275970Scy * Permission to use, copy, modify, and distribute this software for any 7275970Scy * purpose with or without fee is hereby granted, provided that the above 8275970Scy * copyright notice and this permission notice appear in all copies. 9275970Scy * 10275970Scy * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11275970Scy * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12275970Scy * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13275970Scy * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14275970Scy * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER IN 15275970Scy * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 16275970Scy * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17275970Scy */ 18275970Scy 19275970Scy/* #define TPM_DEBUG */ 20275970Scy 21275970Scy#include <sys/cdefs.h> 22275970Scy__FBSDID("$FreeBSD$"); 23275970Scy 24275970Scy#include <sys/param.h> 25275970Scy#include <sys/systm.h> 26275970Scy#include <sys/kernel.h> 27275970Scy#include <sys/malloc.h> 28275970Scy#include <sys/proc.h> 29275970Scy 30275970Scy#ifdef __FreeBSD__ 31275970Scy#include <sys/module.h> 32275970Scy#include <sys/conf.h> 33275970Scy#include <sys/uio.h> 34275970Scy#include <sys/bus.h> 35275970Scy 36275970Scy#include <machine/bus.h> 37275970Scy#include <sys/rman.h> 38275970Scy#include <machine/resource.h> 39275970Scy 40275970Scy#include <machine/md_var.h> 41275970Scy 42275970Scy#include <isa/isareg.h> 43275970Scy#include <isa/isavar.h> 44275970Scy#else 45275970Scy#include <sys/device.h> 46275970Scy 47275970Scy#include <machine/cpu.h> 48275970Scy#include <machine/bus.h> 49275970Scy#include <machine/intr.h> 50275970Scy#include <machine/conf.h> 51275970Scy 52275970Scy#include <dev/isa/isareg.h> 53275970Scy#include <dev/isa/isavar.h> 54275970Scy#endif 55275970Scy#include <dev/tpm/tpmvar.h> 56275970Scy 57275970Scy#ifndef __FreeBSD__ 58275970Scy/* XXX horrible hack for tcsd (-lpthread) workaround on OpenBSD */ 59275970Scy#undef PCATCH 60275970Scy#define PCATCH 0 61275970Scy#endif 62275970Scy 63275970Scy#define TPM_BUFSIZ 1024 64275970Scy 65275970Scy#define TPM_HDRSIZE 10 66275970Scy 67275970Scy#define TPM_PARAM_SIZE 0x0001 68275970Scy 69275970Scy#ifdef __FreeBSD__ 70275970Scy#define IRQUNK -1 71275970Scy#endif 72275970Scy 73275970Scy#define TPM_ACCESS 0x0000 /* acess register */ 74275970Scy#define TPM_ACCESS_ESTABLISHMENT 0x01 /* establishment */ 75275970Scy#define TPM_ACCESS_REQUEST_USE 0x02 /* request using locality */ 76275970Scy#define TPM_ACCESS_REQUEST_PENDING 0x04 /* pending request */ 77275970Scy#define TPM_ACCESS_SEIZE 0x08 /* request locality seize */ 78275970Scy#define TPM_ACCESS_SEIZED 0x10 /* locality has been seized */ 79275970Scy#define TPM_ACCESS_ACTIVE_LOCALITY 0x20 /* locality is active */ 80275970Scy#define TPM_ACCESS_VALID 0x80 /* bits are valid */ 81275970Scy#define TPM_ACCESS_BITS \ 82275970Scy "\020\01EST\02REQ\03PEND\04SEIZE\05SEIZED\06ACT\010VALID" 83275970Scy 84275970Scy#define TPM_INTERRUPT_ENABLE 0x0008 85275970Scy#define TPM_GLOBAL_INT_ENABLE 0x80000000 /* enable ints */ 86275970Scy#define TPM_CMD_READY_INT 0x00000080 /* cmd ready enable */ 87275970Scy#define TPM_INT_EDGE_FALLING 0x00000018 88275970Scy#define TPM_INT_EDGE_RISING 0x00000010 89275970Scy#define TPM_INT_LEVEL_LOW 0x00000008 90275970Scy#define TPM_INT_LEVEL_HIGH 0x00000000 91275970Scy#define TPM_LOCALITY_CHANGE_INT 0x00000004 /* locality change enable */ 92275970Scy#define TPM_STS_VALID_INT 0x00000002 /* int on TPM_STS_VALID is set */ 93275970Scy#define TPM_DATA_AVAIL_INT 0x00000001 /* int on TPM_STS_DATA_AVAIL is set */ 94275970Scy#define TPM_INTERRUPT_ENABLE_BITS \ 95275970Scy "\020\040ENA\010RDY\03LOCH\02STSV\01DRDY" 96275970Scy 97275970Scy#define TPM_INT_VECTOR 0x000c /* 8 bit reg for 4 bit irq vector */ 98275970Scy#define TPM_INT_STATUS 0x0010 /* bits are & 0x87 from TPM_INTERRUPT_ENABLE */ 99275970Scy 100275970Scy#define TPM_INTF_CAPABILITIES 0x0014 /* capability register */ 101275970Scy#define TPM_INTF_BURST_COUNT_STATIC 0x0100 /* TPM_STS_BMASK static */ 102275970Scy#define TPM_INTF_CMD_READY_INT 0x0080 /* int on ready supported */ 103275970Scy#define TPM_INTF_INT_EDGE_FALLING 0x0040 /* falling edge ints supported */ 104275970Scy#define TPM_INTF_INT_EDGE_RISING 0x0020 /* rising edge ints supported */ 105275970Scy#define TPM_INTF_INT_LEVEL_LOW 0x0010 /* level-low ints supported */ 106275970Scy#define TPM_INTF_INT_LEVEL_HIGH 0x0008 /* level-high ints supported */ 107275970Scy#define TPM_INTF_LOCALITY_CHANGE_INT 0x0004 /* locality-change int (mb 1) */ 108275970Scy#define TPM_INTF_STS_VALID_INT 0x0002 /* TPM_STS_VALID int supported */ 109275970Scy#define TPM_INTF_DATA_AVAIL_INT 0x0001 /* TPM_STS_DATA_AVAIL int supported (mb 1) */ 110275970Scy#define TPM_CAPSREQ \ 111275970Scy (TPM_INTF_DATA_AVAIL_INT|TPM_INTF_LOCALITY_CHANGE_INT|TPM_INTF_INT_LEVEL_LOW) 112275970Scy#define TPM_CAPBITS \ 113275970Scy "\020\01IDRDY\02ISTSV\03ILOCH\04IHIGH\05ILOW\06IEDGE\07IFALL\010IRDY\011BCST" 114275970Scy 115275970Scy#define TPM_STS 0x0018 /* status register */ 116275970Scy#define TPM_STS_MASK 0x000000ff /* status bits */ 117275970Scy#define TPM_STS_BMASK 0x00ffff00 /* ro io burst size */ 118275970Scy#define TPM_STS_VALID 0x00000080 /* ro other bits are valid */ 119275970Scy#define TPM_STS_CMD_READY 0x00000040 /* rw chip/signal ready */ 120275970Scy#define TPM_STS_GO 0x00000020 /* wo start the command */ 121275970Scy#define TPM_STS_DATA_AVAIL 0x00000010 /* ro data available */ 122275970Scy#define TPM_STS_DATA_EXPECT 0x00000008 /* ro more data to be written */ 123275970Scy#define TPM_STS_RESP_RETRY 0x00000002 /* wo resend the response */ 124275970Scy#define TPM_STS_BITS "\020\010VALID\07RDY\06GO\05DRDY\04EXPECT\02RETRY" 125275970Scy 126275970Scy#define TPM_DATA 0x0024 127275970Scy#define TPM_ID 0x0f00 128275970Scy#define TPM_REV 0x0f04 129275970Scy#define TPM_SIZE 0x5000 /* five pages of the above */ 130275970Scy 131275970Scy#define TPM_ACCESS_TMO 2000 /* 2sec */ 132275970Scy#define TPM_READY_TMO 2000 /* 2sec */ 133275970Scy#define TPM_READ_TMO 120000 /* 2 minutes */ 134275970Scy#define TPM_BURST_TMO 2000 /* 2sec */ 135275970Scy 136275970Scy#define TPM_LEGACY_BUSY 0x01 137275970Scy#define TPM_LEGACY_ABRT 0x01 138275970Scy#define TPM_LEGACY_DA 0x02 139275970Scy#define TPM_LEGACY_RE 0x04 140275970Scy#define TPM_LEGACY_LAST 0x04 141275970Scy#define TPM_LEGACY_BITS "\020\01BUSY\2DA\3RE\4LAST" 142275970Scy#define TPM_LEGACY_TMO (2*60) /* sec */ 143275970Scy#define TPM_LEGACY_SLEEP 5 /* ticks */ 144275970Scy#define TPM_LEGACY_DELAY 100 145275970Scy 146275970Scy/* Set when enabling legacy interface in host bridge. */ 147275970Scyint tpm_enabled; 148275970Scy 149275970Scy 150275970Scy#ifdef __FreeBSD__ 151275970Scy#define TPMSOFTC(dev) \ 152275970Scy ((struct tpm_softc *)dev->si_drv1) 153275970Scy 154275970Scyd_open_t tpmopen; 155275970Scyd_close_t tpmclose; 156275970Scyd_read_t tpmread; 157275970Scyd_write_t tpmwrite; 158275970Scyd_ioctl_t tpmioctl; 159275970Scy 160275970Scystatic struct cdevsw tpm_cdevsw = { 161275970Scy .d_version = D_VERSION, 162275970Scy .d_flags = D_NEEDGIANT, 163275970Scy .d_open = tpmopen, 164275970Scy .d_close = tpmclose, 165275970Scy .d_read = tpmread, 166275970Scy .d_write = tpmwrite, 167275970Scy .d_ioctl = tpmioctl, 168275970Scy .d_name = "tpm", 169275970Scy}; 170275970Scy#else 171275970Scy#define TPMSOFTC(dev) \ 172275970Scy (struct tpm_softc *)device_lookup(&tpm_cd, minor(dev)) 173275970Scy 174275970Scystruct cfdriver tpm_cd = { 175275970Scy NULL, "tpm", DV_DULL 176275970Scy}; 177275970Scy 178275970Scyint tpm_match(struct device *, void *, void *); 179275970Scyvoid tpm_attach(struct device *, struct device *, void *); 180275970Scy 181275970Scystruct cfattach tpm_ca = { 182275970Scy sizeof(struct tpm_softc), tpm_match, tpm_attach 183275970Scy}; 184275970Scy#endif 185275970Scy 186275970Scyconst struct { 187275970Scy u_int32_t devid; 188275970Scy char name[32]; 189275970Scy int flags; 190275970Scy#define TPM_DEV_NOINTS 0x0001 191275970Scy} tpm_devs[] = { 192275970Scy { 0x000615d1, "IFX SLD 9630 TT 1.1", 0 }, 193275970Scy { 0x000b15d1, "IFX SLB 9635 TT 1.2", 0 }, 194275970Scy { 0x100214e4, "Broadcom BCM0102", TPM_DEV_NOINTS }, 195275970Scy { 0x00fe1050, "WEC WPCT200", 0 }, 196275970Scy { 0x687119fa, "SNS SSX35", 0 }, 197275970Scy { 0x2e4d5453, "STM ST19WP18", 0 }, 198275970Scy { 0x32021114, "ATML 97SC3203", TPM_DEV_NOINTS }, 199275970Scy { 0x10408086, "INTEL INTC0102", 0 }, 200275970Scy { 0, "", TPM_DEV_NOINTS }, 201275970Scy}; 202275970Scy 203275970Scyint tpm_tis12_irqinit(struct tpm_softc *, int, int); 204275970Scyint tpm_tis12_init(struct tpm_softc *, int, const char *); 205275970Scyint tpm_tis12_start(struct tpm_softc *, int); 206275970Scyint tpm_tis12_read(struct tpm_softc *, void *, int, size_t *, int); 207275970Scyint tpm_tis12_write(struct tpm_softc *, void *, int); 208275970Scyint tpm_tis12_end(struct tpm_softc *, int, int); 209275970Scy 210275970Scy#ifdef __FreeBSD__ 211275970Scyvoid tpm_intr(void *); 212275970Scy#else 213275970Scyint tpm_intr(void *); 214275970Scyvoid tpm_powerhook(int, void *); 215275970Scyint tpm_suspend(struct tpm_softc *, int); 216275970Scyint tpm_resume(struct tpm_softc *, int); 217275970Scy#endif 218275970Scy 219275970Scyint tpm_waitfor_poll(struct tpm_softc *, u_int8_t, int, void *); 220275970Scyint tpm_waitfor_int(struct tpm_softc *, u_int8_t, int, void *, int); 221275970Scyint tpm_waitfor(struct tpm_softc *, u_int8_t, int, void *); 222275970Scyint tpm_request_locality(struct tpm_softc *, int); 223275970Scyint tpm_getburst(struct tpm_softc *); 224275970Scyu_int8_t tpm_status(struct tpm_softc *); 225275970Scyint tpm_tmotohz(int); 226275970Scy 227275970Scyint tpm_legacy_probe(bus_space_tag_t, bus_addr_t); 228275970Scyint tpm_legacy_init(struct tpm_softc *, int, const char *); 229275970Scyint tpm_legacy_start(struct tpm_softc *, int); 230275970Scyint tpm_legacy_read(struct tpm_softc *, void *, int, size_t *, int); 231275970Scyint tpm_legacy_write(struct tpm_softc *, void *, int); 232275970Scyint tpm_legacy_end(struct tpm_softc *, int, int); 233275970Scy 234275970Scy#ifdef __FreeBSD__ 235275970Scy 236275970Scy/* 237275970Scy * FreeBSD specific code for probing and attaching TPM to device tree. 238275970Scy */ 239275970Scy#if 0 240275970Scystatic void 241275970Scytpm_identify(driver_t *driver, device_t parent) 242275970Scy{ 243275970Scy BUS_ADD_CHILD(parent, ISA_ORDER_SPECULATIVE, "tpm", 0); 244275970Scy} 245275970Scy#endif 246275970Scy 247275970Scy 248275970Scyint 249275970Scytpm_attach(device_t dev) 250275970Scy{ 251275970Scy struct tpm_softc *sc = device_get_softc(dev); 252275970Scy int irq; 253275970Scy 254275970Scy sc->mem_rid = 0; 255275970Scy sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->mem_rid, 256275970Scy RF_ACTIVE); 257275970Scy if (sc->mem_res == NULL) 258275970Scy return ENXIO; 259275970Scy 260275970Scy sc->sc_bt = rman_get_bustag(sc->mem_res); 261275970Scy sc->sc_bh = rman_get_bushandle(sc->mem_res); 262275970Scy 263275970Scy sc->irq_rid = 0; 264275970Scy sc->irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->irq_rid, 265275970Scy RF_ACTIVE | RF_SHAREABLE); 266275970Scy if (sc->irq_res != NULL) 267275970Scy irq = rman_get_start(sc->irq_res); 268275970Scy else 269275970Scy irq = IRQUNK; 270275970Scy 271275970Scy /* In case PnP probe this may contain some initialization. */ 272275970Scy tpm_tis12_probe(sc->sc_bt, sc->sc_bh); 273275970Scy 274275970Scy if (tpm_legacy_probe(sc->sc_bt, sc->sc_bh)) { 275275970Scy sc->sc_init = tpm_legacy_init; 276275970Scy sc->sc_start = tpm_legacy_start; 277275970Scy sc->sc_read = tpm_legacy_read; 278275970Scy sc->sc_write = tpm_legacy_write; 279275970Scy sc->sc_end = tpm_legacy_end; 280275970Scy } else { 281275970Scy sc->sc_init = tpm_tis12_init; 282275970Scy sc->sc_start = tpm_tis12_start; 283275970Scy sc->sc_read = tpm_tis12_read; 284275970Scy sc->sc_write = tpm_tis12_write; 285275970Scy sc->sc_end = tpm_tis12_end; 286275970Scy } 287275970Scy 288275970Scy printf("%s", device_get_name(dev)); 289275970Scy if ((sc->sc_init)(sc, irq, "tpm")) { 290275970Scy tpm_detach(dev); 291275970Scy return ENXIO; 292275970Scy } 293275970Scy 294275970Scy if (sc->sc_init == tpm_tis12_init && sc->irq_res != NULL && 295 bus_setup_intr(dev, sc->irq_res, INTR_TYPE_TTY, NULL, 296 tpm_intr, sc, &sc->intr_cookie) != 0) { 297 tpm_detach(dev); 298 printf(": cannot establish interrupt\n"); 299 return 1; 300 } 301 302 sc->sc_cdev = make_dev(&tpm_cdevsw, device_get_unit(dev), 303 UID_ROOT, GID_WHEEL, 0600, "tpm"); 304 sc->sc_cdev->si_drv1 = sc; 305 306 return 0; 307} 308 309int 310tpm_detach(device_t dev) 311{ 312 struct tpm_softc * sc = device_get_softc(dev); 313 314 if(sc->intr_cookie){ 315 bus_teardown_intr(dev, sc->irq_res, sc->intr_cookie); 316 } 317 318 if(sc->mem_res){ 319 bus_release_resource(dev, SYS_RES_MEMORY, 320 sc->mem_rid, sc->mem_res); 321 } 322 323 if(sc->irq_res){ 324 bus_release_resource(dev, SYS_RES_IRQ, 325 sc->irq_rid, sc->irq_res); 326 } 327 if(sc->sc_cdev){ 328 destroy_dev(sc->sc_cdev); 329 } 330 331 return 0; 332} 333 334 335#else 336/* 337 * OpenBSD specific code for probing and attaching TPM to device tree. 338 */ 339int 340tpm_match(struct device *parent, void *match, void *aux) 341{ 342 struct isa_attach_args *ia = aux; 343 struct cfdata *cf = match; 344 bus_space_tag_t bt = ia->ia_memt; 345 bus_space_handle_t bh; 346 int rv; 347 348 /* There can be only one. */ 349 if (cf->cf_unit) 350 return 0; 351 352 if (tpm_legacy_probe(ia->ia_iot, ia->ia_iobase)) { 353 ia->ia_iosize = 2; 354 return 1; 355 } 356 357 if (ia->ia_maddr == -1) 358 return 0; 359 360 if (bus_space_map(bt, ia->ia_maddr, TPM_SIZE, 0, &bh)) 361 return 0; 362 363 if ((rv = tpm_tis12_probe(bt, bh))) { 364 ia->ia_iosize = 0; 365 ia->ia_msize = TPM_SIZE; 366 } 367 368 bus_space_unmap(bt, bh, TPM_SIZE); 369 return rv; 370} 371 372void 373tpm_attach(struct device *parent, struct device *self, void *aux) 374{ 375 struct tpm_softc *sc = (struct tpm_softc *)self; 376 struct isa_attach_args *ia = aux; 377 bus_addr_t iobase; 378 bus_size_t size; 379 int rv; 380 381 if (tpm_legacy_probe(ia->ia_iot, ia->ia_iobase)) { 382 sc->sc_bt = ia->ia_iot; 383 iobase = ia->ia_iobase; 384 size = ia->ia_iosize; 385 sc->sc_batm = ia->ia_iot; 386 sc->sc_init = tpm_legacy_init; 387 sc->sc_start = tpm_legacy_start; 388 sc->sc_read = tpm_legacy_read; 389 sc->sc_write = tpm_legacy_write; 390 sc->sc_end = tpm_legacy_end; 391 } else { 392 sc->sc_bt = ia->ia_memt; 393 iobase = ia->ia_maddr; 394 size = TPM_SIZE; 395 sc->sc_init = tpm_tis12_init; 396 sc->sc_start = tpm_tis12_start; 397 sc->sc_read = tpm_tis12_read; 398 sc->sc_write = tpm_tis12_write; 399 sc->sc_end = tpm_tis12_end; 400 } 401 402 if (bus_space_map(sc->sc_bt, iobase, size, 0, &sc->sc_bh)) { 403 printf(": cannot map registers\n"); 404 return; 405 } 406 407 if ((rv = (sc->sc_init)(sc, ia->ia_irq, sc->sc_dev.dv_xname))) { 408 bus_space_unmap(sc->sc_bt, sc->sc_bh, size); 409 return; 410 } 411 412 /* 413 * Only setup interrupt handler when we have a vector and the 414 * chip is TIS 1.2 compliant. 415 */ 416 if (sc->sc_init == tpm_tis12_init && ia->ia_irq != IRQUNK && 417 (sc->sc_ih = isa_intr_establish(ia->ia_ic, ia->ia_irq, IST_EDGE, 418 IPL_TTY, tpm_intr, sc, sc->sc_dev.dv_xname)) == NULL) { 419 bus_space_unmap(sc->sc_bt, sc->sc_bh, TPM_SIZE); 420 printf("%s: cannot establish interrupt\n", 421 sc->sc_dev.dv_xname); 422 return; 423 } 424 425#ifdef __FreeBSD__ 426 sc->sc_suspend = 0; 427#else 428 sc->sc_suspend = PWR_RESUME; 429 sc->sc_powerhook = powerhook_establish(tpm_powerhook, sc); 430#endif 431} 432#endif 433 434/* Probe TPM using TIS 1.2 interface. */ 435int 436tpm_tis12_probe(bus_space_tag_t bt, bus_space_handle_t bh) 437{ 438 u_int32_t r; 439 u_int8_t save, reg; 440 441 r = bus_space_read_4(bt, bh, TPM_INTF_CAPABILITIES); 442 if (r == 0xffffffff) 443 return 0; 444 445#ifdef TPM_DEBUG 446 printf("tpm: caps=%b\n", r, TPM_CAPBITS); 447#endif 448 if ((r & TPM_CAPSREQ) != TPM_CAPSREQ || 449 !(r & (TPM_INTF_INT_EDGE_RISING | TPM_INTF_INT_LEVEL_LOW))) { 450#ifdef TPM_DEBUG 451 printf("tpm: caps too low (caps=%b)\n", r, TPM_CAPBITS); 452#endif 453 return 0; 454 } 455 456 save = bus_space_read_1(bt, bh, TPM_ACCESS); 457 bus_space_write_1(bt, bh, TPM_ACCESS, TPM_ACCESS_REQUEST_USE); 458 reg = bus_space_read_1(bt, bh, TPM_ACCESS); 459 if ((reg & TPM_ACCESS_VALID) && (reg & TPM_ACCESS_ACTIVE_LOCALITY) && 460 bus_space_read_4(bt, bh, TPM_ID) != 0xffffffff) 461 return 1; 462 463 bus_space_write_1(bt, bh, TPM_ACCESS, save); 464 return 0; 465} 466 467/* 468 * Setup interrupt vector if one is provided and interrupts are know to 469 * work on that particular chip. 470 */ 471int 472tpm_tis12_irqinit(struct tpm_softc *sc, int irq, int idx) 473{ 474 u_int32_t r; 475 476 if ((irq == IRQUNK) || (tpm_devs[idx].flags & TPM_DEV_NOINTS)) { 477 sc->sc_vector = IRQUNK; 478 return 0; 479 } 480 481 /* Ack and disable all interrupts. */ 482 bus_space_write_4(sc->sc_bt, sc->sc_bh, TPM_INTERRUPT_ENABLE, 483 bus_space_read_4(sc->sc_bt, sc->sc_bh, TPM_INTERRUPT_ENABLE) & 484 ~TPM_GLOBAL_INT_ENABLE); 485 bus_space_write_4(sc->sc_bt, sc->sc_bh, TPM_INT_STATUS, 486 bus_space_read_4(sc->sc_bt, sc->sc_bh, TPM_INT_STATUS)); 487 488 /* Program interrupt vector. */ 489 bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_INT_VECTOR, irq); 490 sc->sc_vector = irq; 491 492 /* Program interrupt type. */ 493 if (sc->sc_capabilities & TPM_INTF_INT_EDGE_RISING) 494 r = TPM_INT_EDGE_RISING; 495 else if (sc->sc_capabilities & TPM_INTF_INT_LEVEL_HIGH) 496 r = TPM_INT_LEVEL_HIGH; 497 else 498 r = TPM_INT_LEVEL_LOW; 499 bus_space_write_4(sc->sc_bt, sc->sc_bh, TPM_INTERRUPT_ENABLE, r); 500 501 return 0; 502} 503 504/* Setup TPM using TIS 1.2 interface. */ 505int 506tpm_tis12_init(struct tpm_softc *sc, int irq, const char *name) 507{ 508 u_int32_t r; 509 int i; 510 511 r = bus_space_read_4(sc->sc_bt, sc->sc_bh, TPM_INTF_CAPABILITIES); 512#ifdef TPM_DEBUG 513 printf(" caps=%b ", r, TPM_CAPBITS); 514#endif 515 if ((r & TPM_CAPSREQ) != TPM_CAPSREQ || 516 !(r & (TPM_INTF_INT_EDGE_RISING | TPM_INTF_INT_LEVEL_LOW))) { 517 printf(": capabilities too low (caps=%b)\n", r, TPM_CAPBITS); 518 return 1; 519 } 520 sc->sc_capabilities = r; 521 522 sc->sc_devid = bus_space_read_4(sc->sc_bt, sc->sc_bh, TPM_ID); 523 sc->sc_rev = bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_REV); 524 525 for (i = 0; tpm_devs[i].devid; i++) 526 if (tpm_devs[i].devid == sc->sc_devid) 527 break; 528 529 if (tpm_devs[i].devid) 530 printf(": %s rev 0x%x\n", tpm_devs[i].name, sc->sc_rev); 531 else 532 printf(": device 0x%08x rev 0x%x\n", sc->sc_devid, sc->sc_rev); 533 534 if (tpm_tis12_irqinit(sc, irq, i)) 535 return 1; 536 537 if (tpm_request_locality(sc, 0)) 538 return 1; 539 540 /* Abort whatever it thought it was doing. */ 541 bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_STS, TPM_STS_CMD_READY); 542 543 return 0; 544} 545 546int 547tpm_request_locality(struct tpm_softc *sc, int l) 548{ 549 u_int32_t r; 550 int to, rv; 551 552 if (l != 0) 553 return EINVAL; 554 555 if ((bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_ACCESS) & 556 (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) == 557 (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) 558 return 0; 559 560 bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_ACCESS, 561 TPM_ACCESS_REQUEST_USE); 562 563 to = tpm_tmotohz(TPM_ACCESS_TMO); 564 565 while ((r = bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_ACCESS) & 566 (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) != 567 (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY) && to--) { 568 rv = tsleep(sc->sc_init, PRIBIO | PCATCH, "tpm_locality", 1); 569 if (rv && rv != EWOULDBLOCK) { 570#ifdef TPM_DEBUG 571 printf("tpm_request_locality: interrupted %d\n", rv); 572#endif 573 return rv; 574 } 575 } 576 577 if ((r & (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) != 578 (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) { 579#ifdef TPM_DEBUG 580 printf("tpm_request_locality: access %b\n", r, TPM_ACCESS_BITS); 581#endif 582 return EBUSY; 583 } 584 585 return 0; 586} 587 588int 589tpm_getburst(struct tpm_softc *sc) 590{ 591 int burst, to, rv; 592 593 to = tpm_tmotohz(TPM_BURST_TMO); 594 595 burst = 0; 596 while (burst == 0 && to--) { 597 /* 598 * Burst count has to be read from bits 8 to 23 without 599 * touching any other bits, eg. the actual status bits 0 600 * to 7. 601 */ 602 burst = bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_STS + 1); 603 burst |= bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_STS + 2) 604 << 8; 605#ifdef TPM_DEBUG 606 printf("tpm_getburst: read %d\n", burst); 607#endif 608 if (burst) 609 return burst; 610 611 rv = tsleep(sc, PRIBIO | PCATCH, "tpm_getburst", 1); 612 if (rv && rv != EWOULDBLOCK) { 613 return 0; 614 } 615 } 616 617 return 0; 618} 619 620u_int8_t 621tpm_status(struct tpm_softc *sc) 622{ 623 u_int8_t status; 624 625 status = bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_STS) & 626 TPM_STS_MASK; 627 628 return status; 629} 630 631int 632tpm_tmotohz(int tmo) 633{ 634 struct timeval tv; 635 636 tv.tv_sec = tmo / 1000; 637 tv.tv_usec = 1000 * (tmo % 1000); 638 639 return tvtohz(&tv); 640} 641 642/* Save TPM state on suspend. */ 643int 644#ifdef __FreeBSD__ 645tpm_suspend(device_t dev) 646#else 647tpm_suspend(struct tpm_softc *sc, int why) 648#endif 649{ 650#ifdef __FreeBSD__ 651 struct tpm_softc *sc = device_get_softc(dev); 652 int why = 1; 653#endif 654 u_int8_t command[] = { 655 0, 193, /* TPM_TAG_RQU_COMMAND */ 656 0, 0, 0, 10, /* Length in bytes */ 657 0, 0, 0, 156 /* TPM_ORD_SaveStates */ 658 }; 659 660 /* 661 * Power down: We have to issue the SaveStates command. 662 */ 663 sc->sc_write(sc, &command, sizeof(command)); 664 sc->sc_read(sc, &command, sizeof(command), NULL, TPM_HDRSIZE); 665#ifdef TPM_DEBUG 666 printf("tpm_suspend: power down: %d -> %d\n", sc->sc_suspend, why); 667#endif 668 sc->sc_suspend = why; 669 670 return 0; 671} 672 673/* 674 * Handle resume event. Actually nothing to do as the BIOS is supposed 675 * to restore the previously saved state. 676 */ 677int 678#ifdef __FreeBSD__ 679tpm_resume(device_t dev) 680#else 681tpm_resume(struct tpm_softc *sc, int why) 682#endif 683{ 684#ifdef __FreeBSD__ 685 struct tpm_softc *sc = device_get_softc(dev); 686 int why = 0; 687#endif 688#ifdef TPM_DEBUG 689 printf("tpm_resume: resume: %d -> %d\n", sc->sc_suspend, why); 690#endif 691 sc->sc_suspend = why; 692 693 return 0; 694} 695 696/* Dispatch suspend and resume events. */ 697#ifndef __FreeBSD__ 698void 699tpm_powerhook(int why, void *self) 700{ 701 struct tpm_softc *sc = (struct tpm_softc *)self; 702 703 if (why != PWR_RESUME) 704 tpm_suspend(sc, why); 705 else 706 tpm_resume(sc, why); 707} 708#endif /* !__FreeBSD__ */ 709 710/* Wait for given status bits using polling. */ 711int 712tpm_waitfor_poll(struct tpm_softc *sc, u_int8_t mask, int tmo, void *c) 713{ 714 int rv; 715 716 /* 717 * Poll until either the requested condition or a time out is 718 * met. 719 */ 720 while (((sc->sc_stat = tpm_status(sc)) & mask) != mask && tmo--) { 721 rv = tsleep(c, PRIBIO | PCATCH, "tpm_poll", 1); 722 if (rv && rv != EWOULDBLOCK) { 723#ifdef TPM_DEBUG 724 printf("tpm_waitfor_poll: interrupted %d\n", rv); 725#endif 726 return rv; 727 } 728 } 729 730 return 0; 731} 732 733/* Wait for given status bits using interrupts. */ 734int 735tpm_waitfor_int(struct tpm_softc *sc, u_int8_t mask, int tmo, void *c, 736 int inttype) 737{ 738 int rv, to; 739 740 /* Poll and return when condition is already met. */ 741 sc->sc_stat = tpm_status(sc); 742 if ((sc->sc_stat & mask) == mask) 743 return 0; 744 745 /* 746 * Enable interrupt on tpm chip. Note that interrupts on our 747 * level (SPL_TTY) are disabled (see tpm{read,write} et al) and 748 * will not be delivered to the cpu until we call tsleep(9) below. 749 */ 750 bus_space_write_4(sc->sc_bt, sc->sc_bh, TPM_INTERRUPT_ENABLE, 751 bus_space_read_4(sc->sc_bt, sc->sc_bh, TPM_INTERRUPT_ENABLE) | 752 inttype); 753 bus_space_write_4(sc->sc_bt, sc->sc_bh, TPM_INTERRUPT_ENABLE, 754 bus_space_read_4(sc->sc_bt, sc->sc_bh, TPM_INTERRUPT_ENABLE) | 755 TPM_GLOBAL_INT_ENABLE); 756 757 /* 758 * Poll once more to remedy the race between previous polling 759 * and enabling interrupts on the tpm chip. 760 */ 761 sc->sc_stat = tpm_status(sc); 762 if ((sc->sc_stat & mask) == mask) { 763 rv = 0; 764 goto out; 765 } 766 767 to = tpm_tmotohz(tmo); 768#ifdef TPM_DEBUG 769 printf("tpm_waitfor_int: sleeping for %d ticks on %p\n", to, c); 770#endif 771 /* 772 * tsleep(9) enables interrupts on the cpu and returns after 773 * wake up with interrupts disabled again. Note that interrupts 774 * generated by the tpm chip while being at SPL_TTY are not lost 775 * but held and delivered as soon as the cpu goes below SPL_TTY. 776 */ 777 rv = tsleep(c, PRIBIO | PCATCH, "tpm_intr", to); 778 779 sc->sc_stat = tpm_status(sc); 780#ifdef TPM_DEBUG 781 printf("tpm_waitfor_int: woke up with rv %d stat %b\n", rv, 782 sc->sc_stat, TPM_STS_BITS); 783#endif 784 if ((sc->sc_stat & mask) == mask) 785 rv = 0; 786 787 /* Disable interrupts on tpm chip again. */ 788out: bus_space_write_4(sc->sc_bt, sc->sc_bh, TPM_INTERRUPT_ENABLE, 789 bus_space_read_4(sc->sc_bt, sc->sc_bh, TPM_INTERRUPT_ENABLE) & 790 ~TPM_GLOBAL_INT_ENABLE); 791 bus_space_write_4(sc->sc_bt, sc->sc_bh, TPM_INTERRUPT_ENABLE, 792 bus_space_read_4(sc->sc_bt, sc->sc_bh, TPM_INTERRUPT_ENABLE) & 793 ~inttype); 794 795 return rv; 796} 797 798/* 799 * Wait on given status bits, uses interrupts where possible, otherwise polls. 800 */ 801int 802tpm_waitfor(struct tpm_softc *sc, u_int8_t b0, int tmo, void *c) 803{ 804 u_int8_t b; 805 int re, to, rv; 806 807#ifdef TPM_DEBUG 808 printf("tpm_waitfor: b0 %b\n", b0, TPM_STS_BITS); 809#endif 810 811 /* 812 * If possible, use interrupts, otherwise poll. 813 * 814 * We use interrupts for TPM_STS_VALID and TPM_STS_DATA_AVAIL (if 815 * the tpm chips supports them) as waiting for those can take 816 * really long. The other TPM_STS* are not needed very often 817 * so we do not support them. 818 */ 819 if (sc->sc_vector != IRQUNK) { 820 b = b0; 821 822 /* 823 * Wait for data ready. This interrupt only occures 824 * when both TPM_STS_VALID and TPM_STS_DATA_AVAIL are asserted. 825 * Thus we don't have to bother with TPM_STS_VALID 826 * separately and can just return. 827 * 828 * This only holds for interrupts! When using polling 829 * both flags have to be waited for, see below. 830 */ 831 if ((b & TPM_STS_DATA_AVAIL) && (sc->sc_capabilities & 832 TPM_INTF_DATA_AVAIL_INT)) 833 return tpm_waitfor_int(sc, b, tmo, c, 834 TPM_DATA_AVAIL_INT); 835 836 /* Wait for status valid bit. */ 837 if ((b & TPM_STS_VALID) && (sc->sc_capabilities & 838 TPM_INTF_STS_VALID_INT)) { 839 rv = tpm_waitfor_int(sc, b, tmo, c, TPM_STS_VALID_INT); 840 if (rv != 0) 841 return rv; 842 else 843 b = b0 & ~TPM_STS_VALID; 844 } 845 846 /* 847 * When all flags are taken care of, return. Otherwise 848 * use polling for eg. TPM_STS_CMD_READY. 849 */ 850 if (b == 0) 851 return 0; 852 } 853 854 re = 3; 855restart: 856 /* 857 * If requested wait for TPM_STS_VALID before dealing with 858 * any other flag. Eg. when both TPM_STS_DATA_AVAIL and TPM_STS_VALID 859 * are requested, wait for the latter first. 860 */ 861 b = b0; 862 if (b0 & TPM_STS_VALID) 863 b = TPM_STS_VALID; 864 865 to = tpm_tmotohz(tmo); 866again: 867 if ((rv = tpm_waitfor_poll(sc, b, to, c)) != 0) 868 return rv; 869 870 if ((b & sc->sc_stat) == TPM_STS_VALID) { 871 /* Now wait for other flags. */ 872 b = b0 & ~TPM_STS_VALID; 873 to++; 874 goto again; 875 } 876 877 if ((sc->sc_stat & b) != b) { 878#ifdef TPM_DEBUG 879 printf("tpm_waitfor: timeout: stat=%b b=%b\n", 880 sc->sc_stat, TPM_STS_BITS, b, TPM_STS_BITS); 881#endif 882 if (re-- && (b0 & TPM_STS_VALID)) { 883 bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_STS, 884 TPM_STS_RESP_RETRY); 885 goto restart; 886 } 887 return EIO; 888 } 889 890 return 0; 891} 892 893/* Start transaction. */ 894int 895tpm_tis12_start(struct tpm_softc *sc, int flag) 896{ 897 int rv; 898 899 if (flag == UIO_READ) { 900 rv = tpm_waitfor(sc, TPM_STS_DATA_AVAIL | TPM_STS_VALID, 901 TPM_READ_TMO, sc->sc_read); 902 return rv; 903 } 904 905 /* Own our (0th) locality. */ 906 if ((rv = tpm_request_locality(sc, 0)) != 0) 907 return rv; 908 909 sc->sc_stat = tpm_status(sc); 910 if (sc->sc_stat & TPM_STS_CMD_READY) { 911#ifdef TPM_DEBUG 912 printf("tpm_tis12_start: UIO_WRITE status %b\n", sc->sc_stat, 913 TPM_STS_BITS); 914#endif 915 return 0; 916 } 917 918#ifdef TPM_DEBUG 919 printf("tpm_tis12_start: UIO_WRITE readying chip\n"); 920#endif 921 922 /* Abort previous and restart. */ 923 bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_STS, TPM_STS_CMD_READY); 924 if ((rv = tpm_waitfor(sc, TPM_STS_CMD_READY, TPM_READY_TMO, 925 sc->sc_write))) { 926#ifdef TPM_DEBUG 927 printf("tpm_tis12_start: UIO_WRITE readying failed %d\n", rv); 928#endif 929 return rv; 930 } 931 932#ifdef TPM_DEBUG 933 printf("tpm_tis12_start: UIO_WRITE readying done\n"); 934#endif 935 936 return 0; 937} 938 939int 940tpm_tis12_read(struct tpm_softc *sc, void *buf, int len, size_t *count, 941 int flags) 942{ 943 u_int8_t *p = buf; 944 size_t cnt; 945 int rv, n, bcnt; 946 947#ifdef TPM_DEBUG 948 printf("tpm_tis12_read: len %d\n", len); 949#endif 950 cnt = 0; 951 while (len > 0) { 952 if ((rv = tpm_waitfor(sc, TPM_STS_DATA_AVAIL | TPM_STS_VALID, 953 TPM_READ_TMO, sc->sc_read))) 954 return rv; 955 956 bcnt = tpm_getburst(sc); 957 n = MIN(len, bcnt); 958#ifdef TPM_DEBUG 959 printf("tpm_tis12_read: fetching %d, burst is %d\n", n, bcnt); 960#endif 961 for (; n--; len--) { 962 *p++ = bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_DATA); 963 cnt++; 964 } 965 966 if ((flags & TPM_PARAM_SIZE) == 0 && cnt >= 6) 967 break; 968 } 969#ifdef TPM_DEBUG 970 printf("tpm_tis12_read: read %zd bytes, len %d\n", cnt, len); 971#endif 972 973 if (count) 974 *count = cnt; 975 976 return 0; 977} 978 979int 980tpm_tis12_write(struct tpm_softc *sc, void *buf, int len) 981{ 982 u_int8_t *p = buf; 983 size_t cnt; 984 int rv, r; 985 986#ifdef TPM_DEBUG 987 printf("tpm_tis12_write: sc %p buf %p len %d\n", sc, buf, len); 988#endif 989 990 if ((rv = tpm_request_locality(sc, 0)) != 0) 991 return rv; 992 993 cnt = 0; 994 while (cnt < len - 1) { 995 for (r = tpm_getburst(sc); r > 0 && cnt < len - 1; r--) { 996 bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_DATA, *p++); 997 cnt++; 998 } 999 if ((rv = tpm_waitfor(sc, TPM_STS_VALID, TPM_READ_TMO, sc))) { 1000#ifdef TPM_DEBUG 1001 printf("tpm_tis12_write: failed burst rv %d\n", rv); 1002#endif 1003 return rv; 1004 } 1005 sc->sc_stat = tpm_status(sc); 1006 if (!(sc->sc_stat & TPM_STS_DATA_EXPECT)) { 1007#ifdef TPM_DEBUG 1008 printf("tpm_tis12_write: failed rv %d stat=%b\n", rv, 1009 sc->sc_stat, TPM_STS_BITS); 1010#endif 1011 return EIO; 1012 } 1013 } 1014 1015 bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_DATA, *p++); 1016 cnt++; 1017 1018 if ((rv = tpm_waitfor(sc, TPM_STS_VALID, TPM_READ_TMO, sc))) { 1019#ifdef TPM_DEBUG 1020 printf("tpm_tis12_write: failed last byte rv %d\n", rv); 1021#endif 1022 return rv; 1023 } 1024 if ((sc->sc_stat & TPM_STS_DATA_EXPECT) != 0) { 1025#ifdef TPM_DEBUG 1026 printf("tpm_tis12_write: failed rv %d stat=%b\n", rv, 1027 sc->sc_stat, TPM_STS_BITS); 1028#endif 1029 return EIO; 1030 } 1031 1032#ifdef TPM_DEBUG 1033 printf("tpm_tis12_write: wrote %d byte\n", cnt); 1034#endif 1035 1036 return 0; 1037} 1038 1039/* Finish transaction. */ 1040int 1041tpm_tis12_end(struct tpm_softc *sc, int flag, int err) 1042{ 1043 int rv = 0; 1044 1045 if (flag == UIO_READ) { 1046 if ((rv = tpm_waitfor(sc, TPM_STS_VALID, TPM_READ_TMO, 1047 sc->sc_read))) 1048 return rv; 1049 1050 /* Still more data? */ 1051 sc->sc_stat = tpm_status(sc); 1052 if (!err && ((sc->sc_stat & TPM_STS_DATA_AVAIL) == TPM_STS_DATA_AVAIL)) { 1053#ifdef TPM_DEBUG 1054 printf("tpm_tis12_end: read failed stat=%b\n", 1055 sc->sc_stat, TPM_STS_BITS); 1056#endif 1057 rv = EIO; 1058 } 1059 1060 bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_STS, 1061 TPM_STS_CMD_READY); 1062 1063 /* Release our (0th) locality. */ 1064 bus_space_write_1(sc->sc_bt, sc->sc_bh,TPM_ACCESS, 1065 TPM_ACCESS_ACTIVE_LOCALITY); 1066 } else { 1067 /* Hungry for more? */ 1068 sc->sc_stat = tpm_status(sc); 1069 if (!err && (sc->sc_stat & TPM_STS_DATA_EXPECT)) { 1070#ifdef TPM_DEBUG 1071 printf("tpm_tis12_end: write failed stat=%b\n", 1072 sc->sc_stat, TPM_STS_BITS); 1073#endif 1074 rv = EIO; 1075 } 1076 1077 bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_STS, 1078 err ? TPM_STS_CMD_READY : TPM_STS_GO); 1079 } 1080 1081 return rv; 1082} 1083 1084#ifdef __FreeBSD__ 1085void 1086#else 1087int 1088#endif 1089tpm_intr(void *v) 1090{ 1091 struct tpm_softc *sc = v; 1092 u_int32_t r; 1093#ifdef TPM_DEBUG 1094 static int cnt = 0; 1095#endif 1096 1097 r = bus_space_read_4(sc->sc_bt, sc->sc_bh, TPM_INT_STATUS); 1098#ifdef TPM_DEBUG 1099 if (r != 0) 1100 printf("tpm_intr: int=%b (%d)\n", r, TPM_INTERRUPT_ENABLE_BITS, 1101 cnt); 1102 else 1103 cnt++; 1104#endif 1105 if (!(r & (TPM_CMD_READY_INT | TPM_LOCALITY_CHANGE_INT | 1106 TPM_STS_VALID_INT | TPM_DATA_AVAIL_INT))) 1107#ifdef __FreeBSD__ 1108 return; 1109#else 1110 return 0; 1111#endif 1112 if (r & TPM_STS_VALID_INT) 1113 wakeup(sc); 1114 1115 if (r & TPM_CMD_READY_INT) 1116 wakeup(sc->sc_write); 1117 1118 if (r & TPM_DATA_AVAIL_INT) 1119 wakeup(sc->sc_read); 1120 1121 if (r & TPM_LOCALITY_CHANGE_INT) 1122 wakeup(sc->sc_init); 1123 1124 bus_space_write_4(sc->sc_bt, sc->sc_bh, TPM_INT_STATUS, r); 1125 1126#ifdef __FreeBSD__ 1127 return; 1128#else 1129 return 1; 1130#endif 1131} 1132 1133/* Read single byte using legacy interface. */ 1134static inline u_int8_t 1135tpm_legacy_in(bus_space_tag_t iot, bus_space_handle_t ioh, int reg) 1136{ 1137 bus_space_write_1(iot, ioh, 0, reg); 1138 return bus_space_read_1(iot, ioh, 1); 1139} 1140 1141/* Write single byte using legacy interface. */ 1142static inline void 1143tpm_legacy_out(bus_space_tag_t iot, bus_space_handle_t ioh, int reg, u_int8_t v) 1144{ 1145 bus_space_write_1(iot, ioh, 0, reg); 1146 bus_space_write_1(iot, ioh, 1, v); 1147} 1148 1149/* Probe for TPM using legacy interface. */ 1150int 1151tpm_legacy_probe(bus_space_tag_t iot, bus_addr_t iobase) 1152{ 1153 bus_space_handle_t ioh; 1154 u_int8_t r, v; 1155 int i, rv = 0; 1156 char id[8]; 1157 1158 if (!tpm_enabled || iobase == -1) 1159 return 0; 1160 1161 if (bus_space_map(iot, iobase, 2, 0, &ioh)) 1162 return 0; 1163 1164 v = bus_space_read_1(iot, ioh, 0); 1165 if (v == 0xff) { 1166 bus_space_unmap(iot, ioh, 2); 1167 return 0; 1168 } 1169 r = bus_space_read_1(iot, ioh, 1); 1170 1171 for (i = sizeof(id); i--; ) 1172 id[i] = tpm_legacy_in(iot, ioh, TPM_ID + i); 1173 1174#ifdef TPM_DEBUG 1175 printf("tpm_legacy_probe %.4s %d.%d.%d.%d\n", 1176 &id[4], id[0], id[1], id[2], id[3]); 1177#endif 1178 /* 1179 * The only chips using the legacy interface we are aware of are 1180 * by Atmel. For other chips more signature would have to be added. 1181 */ 1182 if (!bcmp(&id[4], "ATML", 4)) 1183 rv = 1; 1184 1185 if (!rv) { 1186 bus_space_write_1(iot, ioh, r, 1); 1187 bus_space_write_1(iot, ioh, v, 0); 1188 } 1189 bus_space_unmap(iot, ioh, 2); 1190 1191 return rv; 1192} 1193 1194/* Setup TPM using legacy interface. */ 1195int 1196tpm_legacy_init(struct tpm_softc *sc, int irq, const char *name) 1197{ 1198 char id[8]; 1199 u_int8_t ioh, iol; 1200 int i; 1201 1202 if ((i = bus_space_map(sc->sc_batm, tpm_enabled, 2, 0, &sc->sc_bahm))) { 1203 printf(": cannot map tpm registers (%d)\n", i); 1204 tpm_enabled = 0; 1205 return 1; 1206 } 1207 1208 for (i = sizeof(id); i--; ) 1209 id[i] = tpm_legacy_in(sc->sc_bt, sc->sc_bh, TPM_ID + i); 1210 1211 printf(": %.4s %d.%d @0x%x\n", &id[4], id[0], id[1], tpm_enabled); 1212 iol = tpm_enabled & 0xff; 1213 ioh = tpm_enabled >> 16; 1214 tpm_enabled = 0; 1215 1216 return 0; 1217} 1218 1219/* Start transaction. */ 1220int 1221tpm_legacy_start(struct tpm_softc *sc, int flag) 1222{ 1223 struct timeval tv; 1224 u_int8_t bits, r; 1225 int to, rv; 1226 1227 bits = flag == UIO_READ ? TPM_LEGACY_DA : 0; 1228 tv.tv_sec = TPM_LEGACY_TMO; 1229 tv.tv_usec = 0; 1230 to = tvtohz(&tv) / TPM_LEGACY_SLEEP; 1231 while (((r = bus_space_read_1(sc->sc_batm, sc->sc_bahm, 1)) & 1232 (TPM_LEGACY_BUSY|bits)) != bits && to--) { 1233 rv = tsleep(sc, PRIBIO | PCATCH, "legacy_tpm_start", 1234 TPM_LEGACY_SLEEP); 1235 if (rv && rv != EWOULDBLOCK) 1236 return rv; 1237 } 1238 1239#if defined(TPM_DEBUG) && !defined(__FreeBSD__) 1240 printf("%s: bits %b\n", sc->sc_dev.dv_xname, r, TPM_LEGACY_BITS); 1241#endif 1242 if ((r & (TPM_LEGACY_BUSY|bits)) != bits) 1243 return EIO; 1244 1245 return 0; 1246} 1247 1248int 1249tpm_legacy_read(struct tpm_softc *sc, void *buf, int len, size_t *count, 1250 int flags) 1251{ 1252 u_int8_t *p; 1253 size_t cnt; 1254 int to, rv; 1255 1256 cnt = rv = 0; 1257 for (p = buf; !rv && len > 0; len--) { 1258 for (to = 1000; 1259 !(bus_space_read_1(sc->sc_batm, sc->sc_bahm, 1) & 1260 TPM_LEGACY_DA); DELAY(1)) 1261 if (!to--) 1262 return EIO; 1263 1264 DELAY(TPM_LEGACY_DELAY); 1265 *p++ = bus_space_read_1(sc->sc_batm, sc->sc_bahm, 0); 1266 cnt++; 1267 } 1268 1269 *count = cnt; 1270 return 0; 1271} 1272 1273int 1274tpm_legacy_write(struct tpm_softc *sc, void *buf, int len) 1275{ 1276 u_int8_t *p; 1277 int n; 1278 1279 for (p = buf, n = len; n--; DELAY(TPM_LEGACY_DELAY)) { 1280 if (!n && len != TPM_BUFSIZ) { 1281 bus_space_write_1(sc->sc_batm, sc->sc_bahm, 1, 1282 TPM_LEGACY_LAST); 1283 DELAY(TPM_LEGACY_DELAY); 1284 } 1285 bus_space_write_1(sc->sc_batm, sc->sc_bahm, 0, *p++); 1286 } 1287 1288 return 0; 1289} 1290 1291/* Finish transaction. */ 1292int 1293tpm_legacy_end(struct tpm_softc *sc, int flag, int rv) 1294{ 1295 struct timeval tv; 1296 u_int8_t r; 1297 int to; 1298 1299 if (rv || flag == UIO_READ) 1300 bus_space_write_1(sc->sc_batm, sc->sc_bahm, 1, TPM_LEGACY_ABRT); 1301 else { 1302 tv.tv_sec = TPM_LEGACY_TMO; 1303 tv.tv_usec = 0; 1304 to = tvtohz(&tv) / TPM_LEGACY_SLEEP; 1305 while(((r = bus_space_read_1(sc->sc_batm, sc->sc_bahm, 1)) & 1306 TPM_LEGACY_BUSY) && to--) { 1307 rv = tsleep(sc, PRIBIO | PCATCH, "legacy_tpm_end", 1308 TPM_LEGACY_SLEEP); 1309 if (rv && rv != EWOULDBLOCK) 1310 return rv; 1311 } 1312 1313#if defined(TPM_DEBUG) && !defined(__FreeBSD__) 1314 printf("%s: bits %b\n", sc->sc_dev.dv_xname, r, TPM_LEGACY_BITS); 1315#endif 1316 if (r & TPM_LEGACY_BUSY) 1317 return EIO; 1318 1319 if (r & TPM_LEGACY_RE) 1320 return EIO; /* XXX Retry the loop? */ 1321 } 1322 1323 return rv; 1324} 1325 1326int 1327#ifdef __FreeBSD__ 1328tpmopen(struct cdev *dev, int flag, int mode, struct thread *td) 1329#else 1330tpmopen(dev_t dev, int flag, int mode, struct proc *p) 1331#endif 1332{ 1333 struct tpm_softc *sc = TPMSOFTC(dev); 1334 1335 if (!sc) 1336 return ENXIO; 1337 1338 if (sc->sc_flags & TPM_OPEN) 1339 return EBUSY; 1340 1341 sc->sc_flags |= TPM_OPEN; 1342 1343 return 0; 1344} 1345 1346int 1347#ifdef __FreeBSD__ 1348tpmclose(struct cdev *dev, int flag, int mode, struct thread *td) 1349#else 1350tpmclose(dev_t dev, int flag, int mode, struct proc *p) 1351#endif 1352{ 1353 struct tpm_softc *sc = TPMSOFTC(dev); 1354 1355 if (!sc) 1356 return ENXIO; 1357 1358 if (!(sc->sc_flags & TPM_OPEN)) 1359 return EINVAL; 1360 1361 sc->sc_flags &= ~TPM_OPEN; 1362 1363 return 0; 1364} 1365 1366int 1367#ifdef __FreeBSD__ 1368tpmread(struct cdev *dev, struct uio *uio, int flags) 1369#else 1370tpmread(dev_t dev, struct uio *uio, int flags) 1371#endif 1372{ 1373 struct tpm_softc *sc = TPMSOFTC(dev); 1374 u_int8_t buf[TPM_BUFSIZ], *p; 1375 size_t cnt; 1376 int n, len, rv, s; 1377 1378 if (!sc) 1379 return ENXIO; 1380 1381 s = spltty(); 1382 if ((rv = (sc->sc_start)(sc, UIO_READ))) { 1383 splx(s); 1384 return rv; 1385 } 1386 1387#ifdef TPM_DEBUG 1388 printf("tpmread: getting header\n"); 1389#endif 1390 if ((rv = (sc->sc_read)(sc, buf, TPM_HDRSIZE, &cnt, 0))) { 1391 (sc->sc_end)(sc, UIO_READ, rv); 1392 splx(s); 1393 return rv; 1394 } 1395 1396 len = (buf[2] << 24) | (buf[3] << 16) | (buf[4] << 8) | buf[5]; 1397#ifdef TPM_DEBUG 1398 printf("tpmread: len %d, io count %d\n", len, uio->uio_resid); 1399#endif 1400 if (len > uio->uio_resid) { 1401 rv = EIO; 1402 (sc->sc_end)(sc, UIO_READ, rv); 1403#ifdef TPM_DEBUG 1404 printf("tpmread: bad residual io count 0x%x\n", uio->uio_resid); 1405#endif 1406 splx(s); 1407 return rv; 1408 } 1409 1410 /* Copy out header. */ 1411 if ((rv = uiomove((caddr_t)buf, cnt, uio))) { 1412 (sc->sc_end)(sc, UIO_READ, rv); 1413 splx(s); 1414 return rv; 1415 } 1416 1417 /* Get remaining part of the answer (if anything is left). */ 1418 for (len -= cnt, p = buf, n = sizeof(buf); len > 0; p = buf, len -= n, 1419 n = sizeof(buf)) { 1420 n = MIN(n, len); 1421#ifdef TPM_DEBUG 1422 printf("tpmread: n %d len %d\n", n, len); 1423#endif 1424 if ((rv = (sc->sc_read)(sc, p, n, NULL, TPM_PARAM_SIZE))) { 1425 (sc->sc_end)(sc, UIO_READ, rv); 1426 splx(s); 1427 return rv; 1428 } 1429 p += n; 1430 if ((rv = uiomove((caddr_t)buf, p - buf, uio))) { 1431 (sc->sc_end)(sc, UIO_READ, rv); 1432 splx(s); 1433 return rv; 1434 } 1435 } 1436 1437 rv = (sc->sc_end)(sc, UIO_READ, rv); 1438 splx(s); 1439 return rv; 1440} 1441 1442int 1443#ifdef __FreeBSD__ 1444tpmwrite(struct cdev *dev, struct uio *uio, int flags) 1445#else 1446tpmwrite(dev_t dev, struct uio *uio, int flags) 1447#endif 1448{ 1449 struct tpm_softc *sc = TPMSOFTC(dev); 1450 u_int8_t buf[TPM_BUFSIZ]; 1451 int n, rv, s; 1452 1453 if (!sc) 1454 return ENXIO; 1455 1456 s = spltty(); 1457 1458#ifdef TPM_DEBUG 1459 printf("tpmwrite: io count %d\n", uio->uio_resid); 1460#endif 1461 1462 n = MIN(sizeof(buf), uio->uio_resid); 1463 if ((rv = uiomove((caddr_t)buf, n, uio))) { 1464 splx(s); 1465 return rv; 1466 } 1467 1468 if ((rv = (sc->sc_start)(sc, UIO_WRITE))) { 1469 splx(s); 1470 return rv; 1471 } 1472 1473 if ((rv = (sc->sc_write(sc, buf, n)))) { 1474 splx(s); 1475 return rv; 1476 } 1477 1478 rv = (sc->sc_end)(sc, UIO_WRITE, rv); 1479 splx(s); 1480 return rv; 1481} 1482 1483int 1484#ifdef __FreeBSD__ 1485tpmioctl(struct cdev *dev, u_long cmd, caddr_t data, int flags, 1486 struct thread *td) 1487#else 1488tpmioctl(dev_t dev, u_long cmd, caddr_t data, int flags, struct proc *p) 1489#endif 1490{ 1491 return ENOTTY; 1492} 1493