Annotation of sys/dev/pci/mbg.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: mbg.c,v 1.13 2007/03/22 16:55:31 deraadt Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2006 Marc Balmer <mbalmer@openbsd.org>
! 5: *
! 6: * Permission to use, copy, modify, and distribute this software for any
! 7: * purpose with or without fee is hereby granted, provided that the above
! 8: * copyright notice and this permission notice appear in all copies.
! 9: *
! 10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 17: */
! 18:
! 19: #include <sys/types.h>
! 20: #include <sys/param.h>
! 21: #include <sys/device.h>
! 22: #include <sys/kernel.h>
! 23: #include <sys/proc.h>
! 24: #include <sys/systm.h>
! 25: #include <sys/sensors.h>
! 26: #include <sys/syslog.h>
! 27: #include <sys/time.h>
! 28:
! 29: #include <machine/bus.h>
! 30:
! 31: #include <dev/pci/pcivar.h>
! 32: #include <dev/pci/pcireg.h>
! 33: #include <dev/pci/pcidevs.h>
! 34:
! 35: struct mbg_softc {
! 36: struct device sc_dev;
! 37: bus_space_tag_t sc_iot;
! 38: bus_space_handle_t sc_ioh;
! 39:
! 40: struct ksensor sc_timedelta;
! 41: struct ksensor sc_signal;
! 42: struct ksensordev sc_sensordev;
! 43: u_int8_t sc_status;
! 44:
! 45: int (*sc_read)(struct mbg_softc *, int cmd,
! 46: char *buf, size_t len,
! 47: struct timespec *tstamp);
! 48: };
! 49:
! 50: struct mbg_time {
! 51: u_int8_t hundreds;
! 52: u_int8_t sec;
! 53: u_int8_t min;
! 54: u_int8_t hour;
! 55: u_int8_t mday;
! 56: u_int8_t wday;
! 57: u_int8_t mon;
! 58: u_int8_t year;
! 59: u_int8_t status;
! 60: u_int8_t signal;
! 61: int8_t utc_off;
! 62: };
! 63:
! 64: /* mbg_time.status bits */
! 65: #define MBG_FREERUN 0x01 /* clock running on xtal */
! 66: #define MBG_DST_ENA 0x02 /* DST enabled */
! 67: #define MBG_SYNC 0x04 /* clock synced at least once */
! 68: #define MBG_DST_CHG 0x08 /* DST change announcement */
! 69: #define MBG_UTC 0x10 /* special UTC firmware is installed */
! 70: #define MBG_LEAP 0x20 /* announcement of a leap second */
! 71: #define MBG_IFTM 0x40 /* current time was set from host */
! 72: #define MBG_INVALID 0x80 /* time is invalid */
! 73:
! 74: /* AMCC S5933 registers */
! 75: #define AMCC_OMB1 0x00 /* outgoing mailbox 1 */
! 76: #define AMCC_IMB4 0x1c /* incoming mailbox 4 */
! 77: #define AMCC_FIFO 0x20 /* FIFO register */
! 78: #define AMCC_INTCSR 0x38 /* interrupt control/status register */
! 79: #define AMCC_MCSR 0x3c /* master control/status register */
! 80:
! 81: /* ASIC registers */
! 82: #define ASIC_CFG 0x00
! 83: #define ASIC_FEATURES 0x08 /* r/o */
! 84: #define ASIC_STATUS 0x10
! 85: #define ASIC_CTLSTATUS 0x14
! 86: #define ASIC_DATA 0x18
! 87: #define ASIC_RES1 0x1c
! 88: #define ASIC_ADDON 0x20
! 89:
! 90: /* commands */
! 91: #define MBG_GET_TIME 0x00
! 92: #define MBG_GET_SYNC_TIME 0x02
! 93: #define MBG_GET_HR_TIME 0x03
! 94: #define MBG_GET_FW_ID_1 0x40
! 95: #define MBG_GET_FW_ID_2 0x41
! 96: #define MBG_GET_SERNUM 0x42
! 97:
! 98: /* misc. constants */
! 99: #define MBG_FIFO_LEN 16
! 100: #define MBG_ID_LEN (2 * MBG_FIFO_LEN + 1)
! 101: #define MBG_BUSY 0x01
! 102: #define MBG_SIG_BIAS 55
! 103: #define MBG_SIG_MAX 68
! 104:
! 105: int mbg_probe(struct device *, void *, void *);
! 106: void mbg_attach(struct device *, struct device *, void *);
! 107: void mbg_task(void *);
! 108: int mbg_read_amcc_s5933(struct mbg_softc *, int cmd, char *buf, size_t len,
! 109: struct timespec *tstamp);
! 110: int mbg_read_asic(struct mbg_softc *, int cmd, char *buf, size_t len,
! 111: struct timespec *tstamp);
! 112:
! 113: struct cfattach mbg_ca = {
! 114: sizeof(struct mbg_softc), mbg_probe, mbg_attach
! 115: };
! 116:
! 117: struct cfdriver mbg_cd = {
! 118: NULL, "mbg", DV_DULL
! 119: };
! 120:
! 121: const struct pci_matchid mbg_devices[] = {
! 122: { PCI_VENDOR_MEINBERG, PCI_PRODUCT_MEINBERG_GPS170 },
! 123: { PCI_VENDOR_MEINBERG, PCI_PRODUCT_MEINBERG_PCI32 },
! 124: { PCI_VENDOR_MEINBERG, PCI_PRODUCT_MEINBERG_PCI511 }
! 125: };
! 126:
! 127: int
! 128: mbg_probe(struct device *parent, void *match, void *aux)
! 129: {
! 130: return pci_matchbyid((struct pci_attach_args *)aux, mbg_devices,
! 131: sizeof(mbg_devices) / sizeof(mbg_devices[0]));
! 132: }
! 133:
! 134: void
! 135: mbg_attach(struct device *parent, struct device *self, void *aux)
! 136: {
! 137: struct mbg_softc *sc = (struct mbg_softc *)self;
! 138: struct pci_attach_args *const pa = (struct pci_attach_args *)aux;
! 139: struct mbg_time tframe;
! 140: pcireg_t memtype;
! 141: bus_size_t iosize;
! 142: char fw_id[MBG_ID_LEN];
! 143: const char *desc;
! 144:
! 145: memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, PCI_MAPREG_START);
! 146: if (pci_mapreg_map(pa, PCI_MAPREG_START, memtype, 0, &sc->sc_iot,
! 147: &sc->sc_ioh, NULL, &iosize, 0)) {
! 148: printf(": PCI %s region not found\n",
! 149: memtype == PCI_MAPREG_TYPE_IO ? "I/O" : "memory");
! 150: return;
! 151: }
! 152:
! 153: if ((desc = pci_findproduct(pa->pa_id)) == NULL)
! 154: desc = "Radio clock";
! 155: strlcpy(sc->sc_timedelta.desc, desc, sizeof(sc->sc_timedelta.desc));
! 156:
! 157: switch (PCI_PRODUCT(pa->pa_id)) {
! 158: case PCI_PRODUCT_MEINBERG_PCI32:
! 159: sc->sc_read = mbg_read_amcc_s5933;
! 160: break;
! 161: case PCI_PRODUCT_MEINBERG_PCI511:
! 162: /* FALLTHROUGH */
! 163: case PCI_PRODUCT_MEINBERG_GPS170:
! 164: sc->sc_read = mbg_read_asic;
! 165: break;
! 166: default:
! 167: /* this can not normally happen, but then there is murphy */
! 168: panic(": unsupported product 0x%04x", PCI_PRODUCT(pa->pa_id));
! 169: break;
! 170: }
! 171: if (sc->sc_read(sc, MBG_GET_FW_ID_1, fw_id, MBG_FIFO_LEN, NULL) ||
! 172: sc->sc_read(sc, MBG_GET_FW_ID_2, &fw_id[MBG_FIFO_LEN], MBG_FIFO_LEN,
! 173: NULL))
! 174: printf(": firmware unknown, ");
! 175: else {
! 176: fw_id[MBG_ID_LEN - 1] = '\0';
! 177: printf(": firmware %s, ", fw_id);
! 178: }
! 179:
! 180: if (sc->sc_read(sc, MBG_GET_TIME, (char *)&tframe,
! 181: sizeof(struct mbg_time), NULL)) {
! 182: printf("unknown status\n");
! 183: sc->sc_status = 0;
! 184: } else {
! 185: if (tframe.status & MBG_FREERUN)
! 186: printf("free running on xtal\n");
! 187: else if (tframe.status & MBG_SYNC)
! 188: printf("synchronised\n");
! 189: else if (tframe.status & MBG_INVALID)
! 190: printf("invalid\n");
! 191: sc->sc_status = tframe.status;
! 192: }
! 193:
! 194: strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
! 195: sizeof(sc->sc_sensordev.xname));
! 196:
! 197: sc->sc_timedelta.type = SENSOR_TIMEDELTA;
! 198: sc->sc_timedelta.status = SENSOR_S_UNKNOWN;
! 199: sc->sc_timedelta.value = 0LL;
! 200: sc->sc_timedelta.flags = 0;
! 201: sensor_attach(&sc->sc_sensordev, &sc->sc_timedelta);
! 202:
! 203: sc->sc_signal.type = SENSOR_PERCENT;
! 204: sc->sc_signal.status = SENSOR_S_UNKNOWN;
! 205: sc->sc_signal.value = 0LL;
! 206: sc->sc_signal.flags = 0;
! 207: strlcpy(sc->sc_signal.desc, "Signal strength",
! 208: sizeof(sc->sc_signal.desc));
! 209: sensor_attach(&sc->sc_sensordev, &sc->sc_signal);
! 210:
! 211: sensor_task_register(sc, mbg_task, 10);
! 212: sensordev_install(&sc->sc_sensordev);
! 213: }
! 214:
! 215: void
! 216: mbg_task(void *arg)
! 217: {
! 218: struct mbg_softc *sc = (struct mbg_softc *)arg;
! 219: struct mbg_time tframe;
! 220: struct clock_ymdhms ymdhms;
! 221: struct timespec tstamp;
! 222: time_t trecv;
! 223: int signal;
! 224:
! 225: if (sc->sc_read(sc, MBG_GET_TIME, (char *)&tframe, sizeof(tframe),
! 226: &tstamp)) {
! 227: log(LOG_ERR, "%s: error reading time\n", sc->sc_dev.dv_xname);
! 228: return;
! 229: }
! 230: if (tframe.status & MBG_INVALID) {
! 231: log(LOG_INFO, "%s: invalid time, battery was disconnected\n",
! 232: sc->sc_dev.dv_xname);
! 233: return;
! 234: }
! 235: ymdhms.dt_year = tframe.year + 2000;
! 236: ymdhms.dt_mon = tframe.mon;
! 237: ymdhms.dt_day = tframe.mday;
! 238: ymdhms.dt_hour = tframe.hour;
! 239: ymdhms.dt_min = tframe.min;
! 240: ymdhms.dt_sec = tframe.sec;
! 241: trecv = clock_ymdhms_to_secs(&ymdhms) - tframe.utc_off * 3600;
! 242:
! 243: sc->sc_timedelta.value = (int64_t)((tstamp.tv_sec - trecv) * 100
! 244: - tframe.hundreds) * 10000000LL + tstamp.tv_nsec;
! 245: sc->sc_timedelta.status = SENSOR_S_OK;
! 246: sc->sc_timedelta.tv.tv_sec = tstamp.tv_sec;
! 247: sc->sc_timedelta.tv.tv_usec = tstamp.tv_nsec / 1000;
! 248:
! 249: signal = tframe.signal - MBG_SIG_BIAS;
! 250: if (signal < 0)
! 251: signal = 0;
! 252: else if (signal > MBG_SIG_MAX)
! 253: signal = MBG_SIG_MAX;
! 254:
! 255: sc->sc_signal.value = signal * 100000 / MBG_SIG_MAX;
! 256: sc->sc_signal.status = SENSOR_S_OK;
! 257: sc->sc_signal.tv.tv_sec = sc->sc_timedelta.tv.tv_sec;
! 258: sc->sc_signal.tv.tv_usec = sc->sc_timedelta.tv.tv_usec;
! 259:
! 260: if (tframe.status != sc->sc_status) {
! 261: if (tframe.status & MBG_SYNC)
! 262: log(LOG_INFO, "%s: clock is synchronized",
! 263: sc->sc_dev.dv_xname);
! 264: else if (tframe.status & MBG_FREERUN)
! 265: log(LOG_INFO, "%s: clock is free running on xtal",
! 266: sc->sc_dev.dv_xname);
! 267: sc->sc_status = tframe.status;
! 268: }
! 269: }
! 270:
! 271: /*
! 272: * send a command and read back results to an AMCC S5933 based card
! 273: * (i.e. the PCI32 DCF77 radio clock)
! 274: */
! 275: int
! 276: mbg_read_amcc_s5933(struct mbg_softc *sc, int cmd, char *buf, size_t len,
! 277: struct timespec *tstamp)
! 278: {
! 279: long timer, tmax;
! 280: size_t n;
! 281: u_int8_t status;
! 282:
! 283: /* reset inbound mailbox and clear FIFO status */
! 284: bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMCC_MCSR + 3, 0x0c);
! 285:
! 286: /* set FIFO */
! 287: bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMCC_INTCSR + 3, 0x3c);
! 288:
! 289: /* write the command, optionally taking a timestamp */
! 290: if (tstamp)
! 291: nanotime(tstamp);
! 292: bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMCC_OMB1, cmd);
! 293:
! 294: /* wait for the BUSY flag to go low (approx 70 us on i386) */
! 295: timer = 0;
! 296: tmax = cold ? 50 : hz / 10;
! 297: do {
! 298: if (cold)
! 299: delay(20);
! 300: else
! 301: tsleep(tstamp, 0, "mbg", 1);
! 302: status = bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 303: AMCC_IMB4 + 3);
! 304: } while ((status & MBG_BUSY) && timer++ < tmax);
! 305:
! 306: if (status & MBG_BUSY)
! 307: return -1;
! 308:
! 309: /* read data from the device FIFO */
! 310: for (n = 0; n < len; n++) {
! 311: if (bus_space_read_2(sc->sc_iot, sc->sc_ioh, AMCC_MCSR)
! 312: & 0x20) {
! 313: printf("%s: FIFO error\n", sc->sc_dev.dv_xname);
! 314: return -1;
! 315: }
! 316: buf[n] = bus_space_read_1(sc->sc_iot, sc->sc_ioh,
! 317: AMCC_FIFO + (n % 4));
! 318: }
! 319: return 0;
! 320: }
! 321:
! 322: /*
! 323: * send a command and read back results to an ASIC based card
! 324: * (i.e. the PCI511 DCF77 radio clock)
! 325: */
! 326: int
! 327: mbg_read_asic(struct mbg_softc *sc, int cmd, char *buf, size_t len,
! 328: struct timespec *tstamp)
! 329: {
! 330: long timer, tmax;
! 331: size_t n;
! 332: u_int32_t data;
! 333: char *p = buf;
! 334: u_int16_t port;
! 335: u_int8_t status;
! 336: int s;
! 337:
! 338: /* write the command, optionally taking a timestamp */
! 339: if (tstamp) {
! 340: s = splhigh();
! 341: nanotime(tstamp);
! 342: bus_space_write_4(sc->sc_iot, sc->sc_ioh, ASIC_DATA, cmd);
! 343: splx(s);
! 344: } else
! 345: bus_space_write_4(sc->sc_iot, sc->sc_ioh, ASIC_DATA, cmd);
! 346:
! 347: /* wait for the BUSY flag to go low */
! 348: timer = 0;
! 349: tmax = cold ? 50 : hz / 10;
! 350: do {
! 351: if (cold)
! 352: delay(20);
! 353: else
! 354: tsleep(tstamp, 0, "mbg", 1);
! 355: status = bus_space_read_1(sc->sc_iot, sc->sc_ioh, ASIC_STATUS);
! 356: } while ((status & MBG_BUSY) && timer++ < tmax);
! 357:
! 358: if (status & MBG_BUSY)
! 359: return -1;
! 360:
! 361: /* read data from the device FIFO */
! 362: port = ASIC_ADDON;
! 363: for (n = 0; n < len / 4; n++) {
! 364: data = bus_space_read_4(sc->sc_iot, sc->sc_ioh, port);
! 365: *(u_int32_t *)p = data;
! 366: p += sizeof(data);
! 367: port += sizeof(data);
! 368: }
! 369:
! 370: if (len % 4) {
! 371: data = bus_space_read_4(sc->sc_iot, sc->sc_ioh, port);
! 372: for (n = 0; n < len % 4; n++) {
! 373: *p++ = data & 0xff;
! 374: data >>= 8;
! 375: }
! 376: }
! 377: return 0;
! 378: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to mbg.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci