Robert Watson wrote: > There's been some speculation that the PS/2 mouse problem could be due to > high interrupt latency for non-fast interrupt handlers (especially ones > not MPSAFE) in 5.x. I think it would make a lot of sense for us to push > Giant off both the PS/2 mouse and syscons interrupt handlers in the near > future. For syscons, this would also improve the reliability of dropping > into the debugger from a non-serial console. > > Robert N M Watson FreeBSD Core Team, TrustedBSD Projects > robert_at_fledge.watson.org Network Associates Laboratories Hi, I tried pushing Giant out of psm a while ago, a patch is attached. It did not help, but probably eases contention on Giant a bit. psm gets a lot of interrupts. I am still seeing occasional weirdness from the mouse. It freezes then goes berserk (moving and triggering events) for a few seconds. The kernel says: psmintr: delay too long; resetting byte count (I was wrong about the message in a previous mail) This actually happens more often in -stable than in -current. moused or not does not make a difference. The latest SCHED_ULE and interrupt changes, have not fixed this problem. Otherwise, FreeBSD 5-current is the best OS I have ever run. Morten Johansen --- psm-0.c Wed Nov 5 19:30:09 2003 +++ psm.c Wed Nov 5 20:23:41 2003 _at__at_ -129,6 +129,11 _at__at_ __FBSDID("$FreeBSD: src/sys/isa/psm.c,v #define PSM_NBLOCKIO(dev) (minor(dev) & 1) #define PSM_MKMINOR(unit,block) (((unit) << 1) | ((block) ? 0:1)) +#define PSM_MTX_INIT(_sc, name) mtx_init(&_sc->psm_mtx, name, NULL, MTX_DEF) +#define PSM_MTX_DESTROY(_sc) mtx_destroy(&_sc->psm_mtx) +#define PSM_LOCK(_sc) mtx_lock(&(_sc)->psm_mtx) +#define PSM_UNLOCK(_sc) mtx_unlock(&(_sc)->psm_mtx) + /* ring buffer */ typedef struct ringbuf { int count; /* # of valid elements in the buffer */ _at__at_ -160,9 +165,10 _at__at_ struct psm_softc { /* Driver status inf int syncerrors; struct timeval inputtimeout; int watchdog; /* watchdog timer flag */ - struct callout_handle callout; /* watchdog timer call out */ + struct callout callout; /* watchdog timer call out */ dev_t dev; dev_t bdev; + struct mtx psm_mtx; }; static devclass_t psm_devclass; #define PSM_SOFTC(unit) ((struct psm_softc*)devclass_get_softc(psm_devclass, unit)) _at__at_ -250,6 +256,7 _at__at_ static int doinitialize(struct psm_softc static int doopen(struct psm_softc *, int); static int reinitialize(struct psm_softc *, int); static char *model_name(int); +static void _psmintr(void *); static void psmintr(void *); static void psmtimeout(void *); _at__at_ -769,7 +776,7 _at__at_ doopen(struct psm_softc *sc, int command /* start the watchdog timer */ sc->watchdog = FALSE; - sc->callout = timeout(psmtimeout, (void *)(uintptr_t)sc, hz*2); + callout_reset(&sc->callout, hz*2, psmtimeout, (void *)(uintptr_t)sc); return (0); } _at__at_ -779,17 +786,16 _at__at_ reinitialize(struct psm_softc *sc, int d { int err; int c; - int s; /* don't let anybody mess with the aux device */ if (!kbdc_lock(sc->kbdc, TRUE)) return (EIO); - s = spltty(); + PSM_LOCK(sc); /* block our watchdog timer */ sc->watchdog = FALSE; - untimeout(psmtimeout, (void *)(uintptr_t)sc, sc->callout); - callout_handle_init(&sc->callout); + callout_stop(&sc->callout); + callout_init(&sc->callout, CALLOUT_MPSAFE); /* save the current controller command byte */ empty_both_buffers(sc->kbdc, 10); _at__at_ -804,7 +810,7 _at__at_ reinitialize(struct psm_softc *sc, int d KBD_DISABLE_KBD_PORT | KBD_DISABLE_KBD_INT | KBD_ENABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) { /* CONTROLLER ERROR */ - splx(s); + PSM_UNLOCK(sc); kbdc_lock(sc->kbdc, FALSE); log(LOG_ERR, "psm%d: unable to set the command byte (reinitialize).\n", sc->unit); _at__at_ -834,7 +840,7 _at__at_ reinitialize(struct psm_softc *sc, int d err = ENXIO; } } - splx(s); + PSM_UNLOCK(sc); /* restore the driver state */ if ((sc->state & PSM_OPEN) && (err == 0)) { _at__at_ -1225,9 +1231,10 _at__at_ psmattach(device_t dev) if (sc == NULL) /* shouldn't happen */ return (ENXIO); + PSM_MTX_INIT(sc, device_get_nameunit(dev)); /* Setup initial state */ sc->state = PSM_VALID; - callout_handle_init(&sc->callout); + callout_init(&sc->callout, CALLOUT_MPSAFE); /* Setup our interrupt handler */ rid = KBDC_RID_AUX; _at__at_ -1235,7 +1242,7 _at__at_ psmattach(device_t dev) RF_SHAREABLE | RF_ACTIVE); if (sc->intr == NULL) return (ENXIO); - error = bus_setup_intr(dev, sc->intr, INTR_TYPE_TTY, psmintr, sc, &sc->ih); + error = bus_setup_intr(dev, sc->intr, INTR_TYPE_TTY | INTR_MPSAFE, psmintr, sc, &sc->ih); if (error) { bus_release_resource(dev, SYS_RES_IRQ, rid, sc->intr); return (error); _at__at_ -1282,6 +1289,8 _at__at_ psmdetach(device_t dev) destroy_dev(sc->dev); destroy_dev(sc->bdev); + + PSM_MTX_DESTROY(sc); return 0; } _at__at_ -1293,7 +1302,6 _at__at_ psmopen(dev_t dev, int flag, int fmt, st struct psm_softc *sc; int command_byte; int err; - int s; /* Get device data */ sc = PSM_SOFTC(unit); _at__at_ -1334,7 +1342,7 _at__at_ psmopen(dev_t dev, int flag, int fmt, st return (EIO); /* save the current controller command byte */ - s = spltty(); + PSM_LOCK(sc); command_byte = get_controller_command_byte(sc->kbdc); /* enable the aux port and temporalily disable the keyboard */ _at__at_ -1344,8 +1352,8 _at__at_ psmopen(dev_t dev, int flag, int fmt, st KBD_DISABLE_KBD_PORT | KBD_DISABLE_KBD_INT | KBD_ENABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) { /* CONTROLLER ERROR; do you know how to get out of this? */ + PSM_UNLOCK(sc); kbdc_lock(sc->kbdc, FALSE); - splx(s); log(LOG_ERR, "psm%d: unable to set the command byte (psmopen).\n", unit); return (EIO); _at__at_ -1357,7 +1365,7 _at__at_ psmopen(dev_t dev, int flag, int fmt, st * but timeout routines will be blocked by the poll flag set * via `kbdc_lock()' */ - splx(s); + PSM_UNLOCK(sc); /* enable the mouse device */ err = doopen(sc, command_byte); _at__at_ -1376,18 +1384,17 _at__at_ psmclose(dev_t dev, int flag, int fmt, s struct psm_softc *sc = PSM_SOFTC(unit); int stat[3]; int command_byte; - int s; /* don't let timeout routines in the keyboard driver to poll the kbdc */ if (!kbdc_lock(sc->kbdc, TRUE)) return (EIO); /* save the current controller command byte */ - s = spltty(); + PSM_LOCK(sc); command_byte = get_controller_command_byte(sc->kbdc); if (command_byte == -1) { + PSM_UNLOCK(sc); kbdc_lock(sc->kbdc, FALSE); - splx(s); return (EIO); } _at__at_ -1405,11 +1412,11 _at__at_ psmclose(dev_t dev, int flag, int fmt, s * so long as the mouse will accept the DISABLE command. */ } - splx(s); + PSM_UNLOCK(sc); /* stop the watchdog timer */ - untimeout(psmtimeout, (void *)(uintptr_t)sc, sc->callout); - callout_handle_init(&sc->callout); + callout_stop(&sc->callout); + callout_init(&sc->callout, CALLOUT_MPSAFE); /* remove anything left in the output buffer */ empty_aux_buffer(sc->kbdc, 10); _at__at_ -1517,36 +1524,35 _at__at_ psmread(dev_t dev, struct uio *uio, int register struct psm_softc *sc = PSM_SOFTC(PSM_UNIT(dev)); unsigned char buf[PSM_SMALLBUFSIZE]; int error = 0; - int s; int l; if ((sc->state & PSM_VALID) == 0) return EIO; /* block until mouse activity occured */ - s = spltty(); + PSM_LOCK(sc); while (sc->queue.count <= 0) { if (PSM_NBLOCKIO(dev)) { - splx(s); + PSM_UNLOCK(sc); return EWOULDBLOCK; } sc->state |= PSM_ASLP; error = tsleep( sc, PZERO | PCATCH, "psmrea", 0); sc->state &= ~PSM_ASLP; if (error) { - splx(s); + PSM_UNLOCK(sc); return error; } else if ((sc->state & PSM_VALID) == 0) { /* the device disappeared! */ - splx(s); + PSM_UNLOCK(sc); return EIO; } } - splx(s); + PSM_UNLOCK(sc); /* copy data to the user land */ while ((sc->queue.count > 0) && (uio->uio_resid > 0)) { - s = spltty(); + PSM_LOCK(sc); l = imin(sc->queue.count, uio->uio_resid); if (l > sizeof(buf)) l = sizeof(buf); _at__at_ -1561,7 +1567,7 _at__at_ psmread(dev_t dev, struct uio *uio, int } sc->queue.count -= l; sc->queue.head = (sc->queue.head + l) % sizeof(sc->queue.buf); - splx(s); + PSM_UNLOCK(sc); error = uiomove(buf, l, uio); if (error) break; _at__at_ -1573,12 +1579,10 _at__at_ psmread(dev_t dev, struct uio *uio, int static int block_mouse_data(struct psm_softc *sc, int *c) { - int s; - if (!kbdc_lock(sc->kbdc, TRUE)) return EIO; - s = spltty(); + PSM_LOCK(sc); *c = get_controller_command_byte(sc->kbdc); if ((*c == -1) || !set_controller_command_byte(sc->kbdc, _at__at_ -1586,7 +1590,7 _at__at_ block_mouse_data(struct psm_softc *sc, i KBD_DISABLE_KBD_PORT | KBD_DISABLE_KBD_INT | KBD_ENABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) { /* this is CONTROLLER ERROR */ - splx(s); + PSM_UNLOCK(sc); kbdc_lock(sc->kbdc, FALSE); return EIO; } _at__at_ -1606,7 +1610,7 _at__at_ block_mouse_data(struct psm_softc *sc, i empty_aux_buffer(sc->kbdc, 0); /* flush the queue */ read_aux_data_no_wait(sc->kbdc); /* throw away data if any */ sc->inputbytes = 0; - splx(s); + PSM_UNLOCK(sc); return 0; } _at__at_ -1650,30 +1654,31 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t int stat[3]; int command_byte; int error = 0; - int s; - + + DROP_GIANT(); + /* Perform IOCTL command */ switch (cmd) { case OLD_MOUSE_GETHWINFO: - s = spltty(); + PSM_LOCK(sc); ((old_mousehw_t *)addr)->buttons = sc->hw.buttons; ((old_mousehw_t *)addr)->iftype = sc->hw.iftype; ((old_mousehw_t *)addr)->type = sc->hw.type; ((old_mousehw_t *)addr)->hwid = sc->hw.hwid & 0x00ff; - splx(s); + PSM_UNLOCK(sc); break; case MOUSE_GETHWINFO: - s = spltty(); + PSM_LOCK(sc); *(mousehw_t *)addr = sc->hw; if (sc->mode.level == PSM_LEVEL_BASE) ((mousehw_t *)addr)->model = MOUSE_MODEL_GENERIC; - splx(s); + PSM_UNLOCK(sc); break; case OLD_MOUSE_GETMODE: - s = spltty(); + PSM_LOCK(sc); switch (sc->mode.level) { case PSM_LEVEL_BASE: ((old_mousemode_t *)addr)->protocol = MOUSE_PROTO_PS2; _at__at_ -1688,11 +1693,11 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t ((old_mousemode_t *)addr)->rate = sc->mode.rate; ((old_mousemode_t *)addr)->resolution = sc->mode.resolution; ((old_mousemode_t *)addr)->accelfactor = sc->mode.accelfactor; - splx(s); + PSM_UNLOCK(sc); break; case MOUSE_GETMODE: - s = spltty(); + PSM_LOCK(sc); *(mousemode_t *)addr = sc->mode; ((mousemode_t *)addr)->resolution = MOUSE_RES_LOW - sc->mode.resolution; _at__at_ -1712,7 +1717,7 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t ((mousemode_t *)addr)->protocol = MOUSE_PROTO_PS2; break; } - splx(s); + PSM_UNLOCK(sc); break; case OLD_MOUSE_SETMODE: _at__at_ -1736,17 +1741,23 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t } /* adjust and validate parameters. */ - if (mode.rate > UCHAR_MAX) - return EINVAL; + if (mode.rate > UCHAR_MAX) { + error = EINVAL; + break; + } if (mode.rate == 0) mode.rate = sc->dflt_mode.rate; else if (mode.rate == -1) /* don't change the current setting */ ; - else if (mode.rate < 0) - return EINVAL; - if (mode.resolution >= UCHAR_MAX) - return EINVAL; + else if (mode.rate < 0) { + error = EINVAL; + break; + } + if (mode.resolution >= UCHAR_MAX) { + error = EINVAL; + break; + } if (mode.resolution >= 200) mode.resolution = MOUSE_RES_HIGH; else if (mode.resolution >= 100) _at__at_ -1765,18 +1776,22 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t if (mode.level == -1) /* don't change the current setting */ mode.level = sc->mode.level; - else if ((mode.level < PSM_LEVEL_MIN) || (mode.level > PSM_LEVEL_MAX)) - return EINVAL; + else if ((mode.level < PSM_LEVEL_MIN) || (mode.level > PSM_LEVEL_MAX)) { + error = EINVAL; + break; + } if (mode.accelfactor == -1) /* don't change the current setting */ mode.accelfactor = sc->mode.accelfactor; - else if (mode.accelfactor < 0) - return EINVAL; + else if (mode.accelfactor < 0) { + error = EINVAL; + break; + } /* don't allow anybody to poll the keyboard controller */ error = block_mouse_data(sc, &command_byte); if (error) - return error; + break; /* set mouse parameters */ if (mode.rate > 0) _at__at_ -1786,12 +1801,12 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t set_mouse_scaling(sc->kbdc, 1); get_mouse_status(sc->kbdc, stat, 0, 3); - s = spltty(); + PSM_LOCK(sc); sc->mode.rate = mode.rate; sc->mode.resolution = mode.resolution; sc->mode.accelfactor = mode.accelfactor; sc->mode.level = mode.level; - splx(s); + PSM_UNLOCK(sc); unblock_mouse_data(sc, command_byte); break; _at__at_ -1801,13 +1816,15 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t break; case MOUSE_SETLEVEL: - if ((*(int *)addr < PSM_LEVEL_MIN) || (*(int *)addr > PSM_LEVEL_MAX)) - return EINVAL; + if ((*(int *)addr < PSM_LEVEL_MIN) || (*(int *)addr > PSM_LEVEL_MAX)) { + error = EINVAL; + break; + } sc->mode.level = *(int *)addr; break; case MOUSE_GETSTATUS: - s = spltty(); + PSM_LOCK(sc); status = sc->status; sc->status.flags = 0; sc->status.obutton = sc->status.button; _at__at_ -1815,7 +1832,7 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t sc->status.dx = 0; sc->status.dy = 0; sc->status.dz = 0; - splx(s); + PSM_UNLOCK(sc); *(mousestatus_t *)addr = status; break; _at__at_ -1823,26 +1840,29 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t case MOUSE_GETVARS: var = (mousevar_t *)addr; bzero(var, sizeof(*var)); - s = spltty(); + PSM_LOCK(sc); var->var[0] = MOUSE_VARS_PS2_SIG; var->var[1] = sc->config; var->var[2] = sc->flags; - splx(s); + PSM_UNLOCK(sc); break; case MOUSE_SETVARS: - return ENODEV; + error = ENODEV; + break; #endif /* MOUSE_GETVARS */ case MOUSE_READSTATE: case MOUSE_READDATA: data = (mousedata_t *)addr; - if (data->len > sizeof(data->buf)/sizeof(data->buf[0])) - return EINVAL; + if (data->len > sizeof(data->buf)/sizeof(data->buf[0])) { + error = EINVAL; + break; + } error = block_mouse_data(sc, &command_byte); if (error) - return error; + break; if ((data->len = get_mouse_status(sc->kbdc, data->buf, (cmd == MOUSE_READDATA) ? 1 : 0, data->len)) <= 0) error = EIO; _at__at_ -1852,8 +1872,10 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t #if (defined(MOUSE_SETRESOLUTION)) case MOUSE_SETRESOLUTION: mode.resolution = *(int *)addr; - if (mode.resolution >= UCHAR_MAX) - return EINVAL; + if (mode.resolution >= UCHAR_MAX) { + error = EINVAL; + break; + } else if (mode.resolution >= 200) mode.resolution = MOUSE_RES_HIGH; else if (mode.resolution >= 100) _at__at_ -1871,7 +1893,7 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t error = block_mouse_data(sc, &command_byte); if (error) - return error; + break; sc->mode.resolution = set_mouse_resolution(sc->kbdc, mode.resolution); if (sc->mode.resolution != mode.resolution) error = EIO; _at__at_ -1882,8 +1904,10 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t #if (defined(MOUSE_SETRATE)) case MOUSE_SETRATE: mode.rate = *(int *)addr; - if (mode.rate > UCHAR_MAX) - return EINVAL; + if (mode.rate > UCHAR_MAX) { + error = EINVAL; + break; + } if (mode.rate == 0) mode.rate = sc->dflt_mode.rate; else if (mode.rate < 0) _at__at_ -1891,7 +1915,7 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t error = block_mouse_data(sc, &command_byte); if (error) - return error; + break; sc->mode.rate = set_mouse_sampling_rate(sc->kbdc, mode.rate); if (sc->mode.rate != mode.rate) error = EIO; _at__at_ -1901,12 +1925,14 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t #if (defined(MOUSE_SETSCALING)) case MOUSE_SETSCALING: - if ((*(int *)addr <= 0) || (*(int *)addr > 2)) - return EINVAL; + if ((*(int *)addr <= 0) || (*(int *)addr > 2)) { + error = EINVAL; + break; + } error = block_mouse_data(sc, &command_byte); if (error) - return error; + break; if (!set_mouse_scaling(sc->kbdc, *(int *)addr)) error = EIO; unblock_mouse_data(sc, command_byte); _at__at_ -1917,7 +1943,7 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t case MOUSE_GETHWID: error = block_mouse_data(sc, &command_byte); if (error) - return error; + break; sc->hw.hwid &= ~0x00ff; sc->hw.hwid |= get_aux_id(sc->kbdc); *(int *)addr = sc->hw.hwid & 0x00ff; _at__at_ -1926,9 +1952,11 _at__at_ psmioctl(dev_t dev, u_long cmd, caddr_t #endif /* MOUSE_GETHWID */ default: - return ENOTTY; + error = ENOTTY; } + PICKUP_GIANT(); + return error; } _at__at_ -1936,24 +1964,31 _at__at_ static void psmtimeout(void *arg) { struct psm_softc *sc; - int s; sc = (struct psm_softc *)arg; - s = spltty(); + PSM_LOCK(sc); if (sc->watchdog && kbdc_lock(sc->kbdc, TRUE)) { if (verbose >= 4) log(LOG_DEBUG, "psm%d: lost interrupt?\n", sc->unit); - psmintr(sc); + _psmintr(sc); kbdc_lock(sc->kbdc, FALSE); } sc->watchdog = TRUE; - splx(s); - sc->callout = timeout(psmtimeout, (void *)(uintptr_t)sc, hz); + PSM_UNLOCK(sc); + callout_reset(&sc->callout, hz, psmtimeout, (void *)(uintptr_t)sc); } static void psmintr(void *arg) { + PSM_LOCK((struct psm_softc *)arg); + _psmintr(arg); + PSM_UNLOCK((struct psm_softc *)arg); +} + +static void +_psmintr(void *arg) +{ /* * the table to turn PS/2 mouse button bits (MOUSE_PS2_BUTTON?DOWN) * into `mousestatus' button bits (MOUSE_BUTTON?DOWN). _at__at_ -2379,18 +2414,17 _at__at_ static int psmpoll(dev_t dev, int events, struct thread *td) { struct psm_softc *sc = PSM_SOFTC(PSM_UNIT(dev)); - int s; int revents = 0; /* Return true if a mouse event available */ - s = spltty(); + PSM_LOCK(sc); if (events & (POLLIN | POLLRDNORM)) { if (sc->queue.count > 0) revents |= events & (POLLIN | POLLRDNORM); else selrecord(td, &sc->rsel); } - splx(s); + PSM_UNLOCK(sc); return (revents); }Received on Wed Nov 05 2003 - 12:07:54 UTC
This archive was generated by hypermail 2.4.0 : Wed May 19 2021 - 11:37:27 UTC