Subversion Repositories planix.SVN

/*

 * Framework for USB devices.

 * Some of them may be embedded into usbd and some of

 * them may exist as /bin/usb/* binaries on their own.

 *

 * When embedded, devmain() is given a ref of an already

 * configured and open Dev. If devmain()

 * does not fail it should release this ref when done and

 * use incref to add further refs to it.

 */

#include <u.h>

#include <libc.h>

#include <thread.h>

#include "usb.h"

#include "usbd.h"

static Lock masklck;

extern Devtab devtab[];

static char* cputype;

int

getdevnb(uvlong *maskp)

{

	int i;

	lock(&masklck);

	for(i = 0; i < 8 * sizeof *maskp; i++)

		if((*maskp & (1ULL<<i)) == 0){

			*maskp |= 1ULL<<i;

			unlock(&masklck);

			return i;

		}

	unlock(&masklck);

	return -1;

}

void

putdevnb(uvlong *maskp, int id)

{

	lock(&masklck);

	if(id >= 0)

		*maskp &= ~(1ULL<<id);

	unlock(&masklck);

}

static int

cspmatch(Devtab *dt, int dcsp)

{

	int	i;

	int	csp;

	for(i = 0; i < nelem(dt->csps); i++)

		if((csp=dt->csps[i]) != 0)

		if(csp == dcsp)

			return 1;

		else if((csp&DCL) && (csp&~DCL) == Class(dcsp))

			return 1;

	return 0;

}

static int

devmatch(Devtab *dt, Usbdev *d)

{

	int i;

	int c;

	Conf *cp;

	if(dt->noauto)

		return 0;

	if(dt->vid != -1 && d->vid != dt->vid)

		return 0;

	if(dt->did != -1 && d->did != dt->did)

		return 0;

	if(cspmatch(dt, d->csp))

		return 1;

	for(c = 0; c < Nconf; c++)

		if((cp=d->conf[c]) != nil)

			for(i = 0; i < Niface; i++)

				if(cp->iface[i] != nil)

					if(cspmatch(dt, cp->iface[i]->csp))

						return 1;

	return 0;

}

/* We can't use procexec to execute drivers, because

 * procexec mounts #| at /mnt/temp and we do *not*

 * have /mnt/temp at boot time.

 * Instead, we use access to guess if we can execute the file.

 * and reply as procexec. Be careful that the child inherits

 * all the shared state of the thread library. It should run unnoticed.

 */

static void

xexec(Channel *c, char *nm, char *args[])

{

	int	pid;

	if(access(nm, AEXEC) == 0){

		pid = rfork(RFFDG|RFREND|RFPROC);

		switch(pid){

		case 0:

			exec(nm, args);

			_exits("exec");

		case -1:

			break;

		default:

			sendul(c, pid);

			threadexits(nil);

		}

	}

}

typedef struct Sarg Sarg;

struct Sarg{

	Port *pp;

	Devtab* dt;

	Channel*rc;

	char fname[80];

	char	args[128];

	char	*argv[40];

};

static void

startdevproc(void *a)

{

	Sarg	*sa = a;

	Dev	*d;

	Devtab *dt;

	int	argc;

	char *args, *argse, **argv;

	char *fname;

	threadsetgrp(threadid());

	d = sa->pp->dev;

	dt = sa->dt;

	args = sa->args;

	argse = sa->args + sizeof sa->args;

	argv = sa->argv;

	fname = sa->fname;

	sa->pp->devmaskp = &dt->devmask;

	sa->pp->devnb = getdevnb(&dt->devmask);

	if(sa->pp->devnb < 0){

		sa->pp->devmaskp = nil;

		sa->pp->devnb = 0;

	}else

		args = seprint(args, argse, "-N %d", sa->pp->devnb);

	if(dt->args != nil)

		seprint(args, argse, " %s", dt->args);

	args = sa->args;

	dprint(2, "%s: start: %s %s\n", argv0, dt->name, args);

	argv[0] = dt->name;

	argc = 1;

	if(args[0] != 0)

		argc += tokenize(args, argv+1, nelem(sa->argv)-2);

	argv[argc] = nil;

	if(dt->init == nil){

		if(d->dfd > 0 ){

			close(d->dfd);

			d->dfd = -1;

		}

		rfork(RFCFDG);

		open("/dev/null", OREAD);

		open("/dev/cons", OWRITE);

		open("/dev/cons", OWRITE);

		xexec(sa->rc, argv[0], argv);

		snprint(fname, sizeof(sa->fname), "/bin/usb/%s", dt->name);

		xexec(sa->rc, fname, argv);

		snprint(fname, sizeof(sa->fname), "/boot/%s", dt->name);

		xexec(sa->rc, fname, argv);

		if(cputype == nil)

			cputype = getenv("cputype");

		if(cputype != nil){

			snprint(fname, sizeof(sa->fname), "/%s/bin/%s",

				cputype, dt->name);

			argv[0] = fname;

			xexec(sa->rc, fname, argv);

		}

		fprint(2, "%s: %s: not found. can't exec\n", argv0, dt->name);

		sendul(sa->rc, -1);

		threadexits("exec");

	}else{

		sa->pp->dev = opendev(d->dir);

		sendul(sa->rc, 0);

		if(dt->init(d, argc, argv) < 0)

			fprint(2, "%s: %s: %r\n", argv0, dt->name);

		closedev(d);

		free(sa);

	}

	threadexits(nil);

}

static void

writeinfo(Dev *d)

{

	char buf[128];

	char *s;

	char *se;

	Usbdev *ud;

	Conf *c;

	Iface *ifc;

	int i, j;

	ud = d->usb;

	s = buf;

	se = buf+sizeof(buf);

	s = seprint(s, se, "info %s csp %#08ulx", classname(ud->class), ud->csp);

	for(i = 0; i < ud->nconf; i++){

		c = ud->conf[i];

		if(c == nil)

			break;

		for(j = 0; j < nelem(c->iface); j++){

			ifc = c->iface[j];

			if(ifc == nil)

				break;

			if(ifc->csp != ud->csp)

				s = seprint(s, se, " csp %#08ulx", ifc->csp);

		}

	}

	s = seprint(s, se, " vid %06#x did %06#x", ud->vid, ud->did);

	seprint(s, se, " %q %q", ud->vendor, ud->product);

	devctl(d, "%s", buf);

}

int

startdev(Port *pp)

{

	Dev *d;

	Usbdev *ud;

	Devtab *dt;

	Sarg *sa;

	Channel *rc;

	d = pp->dev;

	assert(d);

	ud = d->usb;

	assert(ud != nil);

	writeinfo(d);

	if(ud->class == Clhub){

		/*

		 * Hubs are handled directly by this process avoiding

		 * concurrent operation so that at most one device

		 * has the config address in use.

		 * We cancel kernel debug for these eps. too chatty.

		 */

		pp->hub = newhub(d->dir, d);

		if(pp->hub == nil)

			fprint(2, "%s: %s: %r\n", argv0, d->dir);

		else

			fprint(2, "usb/hub... ");

		if(usbdebug > 1)

			devctl(d, "debug 0");	/* polled hubs are chatty */

		return pp->hub == nil ? -1 : 0;

	}

	for(dt = devtab; dt->name != nil; dt++)

		if(devmatch(dt, ud))

			break;

	/*

	 * From here on the device is for the driver.

	 * When we return pp->dev contains a Dev just for us

	 * with only the ctl open. Both devs are released on the last closedev:

	 * driver's upon I/O errors and ours upon port dettach.

	 */

	if(dt->name == nil){

		dprint(2, "%s: no configured entry for %s (csp %#08lx)\n",

			argv0, d->dir, ud->csp);

		close(d->dfd);

		d->dfd = -1;

		return 0;

	}

	sa = emallocz(sizeof(Sarg), 1);

	sa->pp = pp;

	sa->dt = dt;

	rc = sa->rc = chancreate(sizeof(ulong), 1);

	procrfork(startdevproc, sa, Stack, RFNOTEG);

	if(recvul(rc) != 0)

		free(sa);

	chanfree(rc);

	fprint(2, "usb/%s... ", dt->name);

	sleep(Spawndelay);		/* in case we re-spawn too fast */

	return 0;

}