600 lines
14 KiB
C
600 lines
14 KiB
C
|
|
#include "inc.h"
|
|
|
|
#include <dev/pci/pciio.h>
|
|
|
|
#include <minix/fb.h>
|
|
#include <minix/i2c.h>
|
|
#include <minix/keymap.h>
|
|
#include <minix/sound.h>
|
|
|
|
#include <sys/fcntl.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/kbdio.h>
|
|
#include <sys/termios.h>
|
|
#include <sys/time.h>
|
|
|
|
const char *
|
|
char_ioctl_name(unsigned long req)
|
|
{
|
|
|
|
switch (req) {
|
|
NAME(MINIX_I2C_IOCTL_EXEC);
|
|
NAME(FBIOGET_VSCREENINFO);
|
|
NAME(FBIOPUT_VSCREENINFO);
|
|
NAME(FBIOGET_FSCREENINFO); /* TODO: print argument */
|
|
NAME(FBIOPAN_DISPLAY);
|
|
NAME(DSPIORATE);
|
|
NAME(DSPIOSTEREO);
|
|
NAME(DSPIOSIZE);
|
|
NAME(DSPIOBITS);
|
|
NAME(DSPIOSIGN);
|
|
NAME(DSPIOMAX);
|
|
NAME(DSPIORESET); /* no argument */
|
|
NAME(DSPIOFREEBUF);
|
|
NAME(DSPIOSAMPLESINBUF);
|
|
NAME(DSPIOPAUSE); /* no argument */
|
|
NAME(DSPIORESUME); /* no argument */
|
|
NAME(MIXIOGETVOLUME);
|
|
NAME(MIXIOGETINPUTLEFT);
|
|
NAME(MIXIOGETINPUTRIGHT);
|
|
NAME(MIXIOGETOUTPUT);
|
|
NAME(MIXIOSETVOLUME);
|
|
NAME(MIXIOSETINPUTLEFT);
|
|
NAME(MIXIOSETINPUTRIGHT);
|
|
NAME(MIXIOSETOUTPUT);
|
|
NAME(TIOCEXCL); /* no argument */
|
|
NAME(TIOCNXCL); /* no argument */
|
|
NAME(TIOCFLUSH);
|
|
NAME(TIOCGETA);
|
|
NAME(TIOCSETA);
|
|
NAME(TIOCSETAW);
|
|
NAME(TIOCSETAF);
|
|
NAME(TIOCGETD);
|
|
NAME(TIOCSETD);
|
|
NAME(TIOCGLINED);
|
|
NAME(TIOCSLINED);
|
|
NAME(TIOCSBRK); /* no argument */
|
|
NAME(TIOCCBRK); /* no argument */
|
|
NAME(TIOCSDTR); /* no argument */
|
|
NAME(TIOCCDTR); /* no argument */
|
|
NAME(TIOCGPGRP);
|
|
NAME(TIOCSPGRP);
|
|
NAME(TIOCOUTQ);
|
|
NAME(TIOCSTI);
|
|
NAME(TIOCNOTTY); /* no argument */
|
|
NAME(TIOCPKT);
|
|
NAME(TIOCSTOP); /* no argument */
|
|
NAME(TIOCSTART); /* no argument */
|
|
NAME(TIOCMSET); /* TODO: print argument */
|
|
NAME(TIOCMBIS); /* TODO: print argument */
|
|
NAME(TIOCMBIC); /* TODO: print argument */
|
|
NAME(TIOCMGET); /* TODO: print argument */
|
|
NAME(TIOCREMOTE);
|
|
NAME(TIOCGWINSZ);
|
|
NAME(TIOCSWINSZ);
|
|
NAME(TIOCUCNTL);
|
|
NAME(TIOCSTAT);
|
|
NAME(TIOCGSID);
|
|
NAME(TIOCCONS);
|
|
NAME(TIOCSCTTY); /* no argument */
|
|
NAME(TIOCEXT);
|
|
NAME(TIOCSIG); /* no argument */
|
|
NAME(TIOCDRAIN); /* no argument */
|
|
NAME(TIOCGFLAGS); /* TODO: print argument */
|
|
NAME(TIOCSFLAGS); /* TODO: print argument */
|
|
NAME(TIOCDCDTIMESTAMP); /* TODO: print argument */
|
|
NAME(TIOCRCVFRAME); /* TODO: print argument */
|
|
NAME(TIOCXMTFRAME); /* TODO: print argument */
|
|
NAME(TIOCPTMGET); /* TODO: print argument */
|
|
NAME(TIOCGRANTPT); /* no argument */
|
|
NAME(TIOCPTSNAME); /* TODO: print argument */
|
|
NAME(TIOCSQSIZE);
|
|
NAME(TIOCGQSIZE);
|
|
NAME(TIOCSFON); /* big IOCTL, not printing argument */
|
|
NAME(KIOCBELL);
|
|
NAME(KIOCSLEDS);
|
|
NAME(KIOCSMAP); /* not worth interpreting */
|
|
NAME(PCI_IOC_CFGREAD);
|
|
NAME(PCI_IOC_CFGWRITE);
|
|
NAME(PCI_IOC_BDF_CFGREAD);
|
|
NAME(PCI_IOC_BDF_CFGWRITE);
|
|
NAME(PCI_IOC_BUSINFO);
|
|
NAME(PCI_IOC_MAP);
|
|
NAME(PCI_IOC_UNMAP);
|
|
NAME(PCI_IOC_RESERVE);
|
|
NAME(PCI_IOC_RELEASE);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
put_i2c_op(struct trace_proc * proc, const char *name, i2c_op_t op)
|
|
{
|
|
const char *text = NULL;
|
|
|
|
if (!valuesonly) {
|
|
switch (op) {
|
|
TEXT(I2C_OP_READ);
|
|
TEXT(I2C_OP_READ_WITH_STOP);
|
|
TEXT(I2C_OP_WRITE);
|
|
TEXT(I2C_OP_WRITE_WITH_STOP);
|
|
TEXT(I2C_OP_READ_BLOCK);
|
|
TEXT(I2C_OP_WRITE_BLOCK);
|
|
}
|
|
}
|
|
|
|
if (text != NULL)
|
|
put_field(proc, name, text);
|
|
else
|
|
put_value(proc, name, "%d", op);
|
|
}
|
|
|
|
static void
|
|
put_sound_device(struct trace_proc * proc, const char * name, int device)
|
|
{
|
|
const char *text = NULL;
|
|
|
|
if (!valuesonly) {
|
|
switch (device) {
|
|
TEXT(Master);
|
|
TEXT(Dac);
|
|
TEXT(Fm);
|
|
TEXT(Cd);
|
|
TEXT(Line);
|
|
TEXT(Mic);
|
|
TEXT(Speaker);
|
|
TEXT(Treble);
|
|
TEXT(Bass);
|
|
}
|
|
}
|
|
|
|
if (text != NULL)
|
|
put_field(proc, name, text);
|
|
else
|
|
put_value(proc, name, "%d", device);
|
|
}
|
|
|
|
static void
|
|
put_sound_state(struct trace_proc * proc, const char * name, int state)
|
|
{
|
|
|
|
if (!valuesonly && state == ON)
|
|
put_field(proc, name, "ON");
|
|
else if (!valuesonly && state == OFF)
|
|
put_field(proc, name, "OFF");
|
|
else
|
|
put_value(proc, name, "%d", state);
|
|
}
|
|
|
|
static const struct flags flush_flags[] = {
|
|
FLAG(FREAD),
|
|
FLAG(FWRITE),
|
|
};
|
|
|
|
static const struct flags tc_iflags[] = {
|
|
FLAG(IGNBRK),
|
|
FLAG(BRKINT),
|
|
FLAG(IGNPAR),
|
|
FLAG(PARMRK),
|
|
FLAG(INPCK),
|
|
FLAG(ISTRIP),
|
|
FLAG(INLCR),
|
|
FLAG(IGNCR),
|
|
FLAG(ICRNL),
|
|
FLAG(IXON),
|
|
FLAG(IXOFF),
|
|
FLAG(IXANY),
|
|
FLAG(IMAXBEL),
|
|
};
|
|
|
|
static const struct flags tc_oflags[] = {
|
|
FLAG(OPOST),
|
|
FLAG(ONLCR),
|
|
FLAG(OXTABS),
|
|
FLAG(ONOEOT),
|
|
FLAG(OCRNL),
|
|
FLAG(ONOCR),
|
|
FLAG(ONLRET),
|
|
};
|
|
|
|
static const struct flags tc_cflags[] = {
|
|
FLAG(CIGNORE),
|
|
FLAG_MASK(CSIZE, CS5),
|
|
FLAG_MASK(CSIZE, CS6),
|
|
FLAG_MASK(CSIZE, CS7),
|
|
FLAG_MASK(CSIZE, CS8),
|
|
FLAG(CSTOPB),
|
|
FLAG(CREAD),
|
|
FLAG(PARENB),
|
|
FLAG(PARODD),
|
|
FLAG(HUPCL),
|
|
FLAG(CLOCAL),
|
|
FLAG(CRTSCTS),
|
|
FLAG(CDTRCTS),
|
|
FLAG(MDMBUF),
|
|
};
|
|
|
|
static const struct flags tc_lflags[] = {
|
|
FLAG(ECHOKE),
|
|
FLAG(ECHOE),
|
|
FLAG(ECHOK),
|
|
FLAG(ECHO),
|
|
FLAG(ECHONL),
|
|
FLAG(ECHOPRT),
|
|
FLAG(ECHOCTL),
|
|
FLAG(ISIG),
|
|
FLAG(ICANON),
|
|
FLAG(ALTWERASE),
|
|
FLAG(IEXTEN),
|
|
FLAG(EXTPROC),
|
|
FLAG(TOSTOP),
|
|
FLAG(FLUSHO),
|
|
FLAG(NOKERNINFO),
|
|
FLAG(PENDIN),
|
|
FLAG(NOFLSH),
|
|
};
|
|
|
|
static void
|
|
put_tty_disc(struct trace_proc * proc, const char * name, int disc)
|
|
{
|
|
const char *text = NULL;
|
|
|
|
if (!valuesonly) {
|
|
switch (disc) {
|
|
TEXT(TTYDISC);
|
|
TEXT(TABLDISC);
|
|
TEXT(SLIPDISC);
|
|
TEXT(PPPDISC);
|
|
TEXT(STRIPDISC);
|
|
TEXT(HDLCDISC);
|
|
}
|
|
}
|
|
|
|
if (text != NULL)
|
|
put_field(proc, name, text);
|
|
else
|
|
put_value(proc, name, "%d", disc);
|
|
}
|
|
|
|
static const struct flags kbd_leds[] = {
|
|
FLAG(KBD_LEDS_NUM),
|
|
FLAG(KBD_LEDS_CAPS),
|
|
FLAG(KBD_LEDS_SCROLL),
|
|
};
|
|
|
|
int
|
|
char_ioctl_arg(struct trace_proc * proc, unsigned long req, void * ptr,
|
|
int dir)
|
|
{
|
|
minix_i2c_ioctl_exec_t *iie;
|
|
struct fb_var_screeninfo *fbvs;
|
|
struct volume_level *level;
|
|
struct inout_ctrl *inout;
|
|
struct termios *tc;
|
|
struct ptmget *pm;
|
|
struct winsize *ws;
|
|
struct kio_bell *bell;
|
|
struct kio_leds *leds;
|
|
struct pciio_cfgreg *pci_cfgreg;
|
|
struct pciio_bdf_cfgreg *pci_bdf_cfgreg;
|
|
struct pciio_businfo *pci_businfo;
|
|
struct pciio_map *pci_iomap;
|
|
struct pciio_acl *pci_acl;
|
|
|
|
switch (req) {
|
|
case MINIX_I2C_IOCTL_EXEC:
|
|
if ((iie = (minix_i2c_ioctl_exec_t *)ptr) == NULL)
|
|
return IF_OUT; /* we print only the request for now */
|
|
|
|
put_i2c_op(proc, "iie_op", iie->iie_op);
|
|
put_value(proc, "iie_addr", "0x%04x", iie->iie_addr);
|
|
return 0; /* TODO: print command/data/result */
|
|
|
|
case FBIOGET_VSCREENINFO:
|
|
if ((fbvs = (struct fb_var_screeninfo *)ptr) == NULL)
|
|
return IF_IN;
|
|
|
|
put_value(proc, "xres", "%"PRIu32, fbvs->xres);
|
|
put_value(proc, "yres", "%"PRIu32, fbvs->yres);
|
|
put_value(proc, "xres_virtual", "%"PRIu32, fbvs->xres_virtual);
|
|
put_value(proc, "yres_virtual", "%"PRIu32, fbvs->yres_virtual);
|
|
put_value(proc, "xoffset", "%"PRIu32, fbvs->xoffset);
|
|
put_value(proc, "yoffset", "%"PRIu32, fbvs->yoffset);
|
|
put_value(proc, "bits_per_pixel", "%"PRIu32,
|
|
fbvs->bits_per_pixel);
|
|
return 0;
|
|
|
|
case FBIOPUT_VSCREENINFO:
|
|
case FBIOPAN_DISPLAY:
|
|
if ((fbvs = (struct fb_var_screeninfo *)ptr) == NULL)
|
|
return IF_OUT;
|
|
|
|
put_value(proc, "xoffset", "%"PRIu32, fbvs->xoffset);
|
|
put_value(proc, "yoffset", "%"PRIu32, fbvs->yoffset);
|
|
return 0;
|
|
|
|
case DSPIORATE:
|
|
case DSPIOSTEREO:
|
|
case DSPIOSIZE:
|
|
case DSPIOBITS:
|
|
case DSPIOSIGN:
|
|
case DSPIOMAX:
|
|
case DSPIOFREEBUF:
|
|
case DSPIOSAMPLESINBUF:
|
|
if (ptr == NULL)
|
|
return dir;
|
|
|
|
put_value(proc, NULL, "%u", *(unsigned int *)ptr);
|
|
return IF_ALL;
|
|
|
|
case MIXIOGETVOLUME:
|
|
if ((level = (struct volume_level *)ptr) == NULL)
|
|
return dir;
|
|
|
|
if (dir == IF_OUT)
|
|
put_sound_device(proc, "device", level->device);
|
|
else {
|
|
put_value(proc, "left", "%d", level->left);
|
|
put_value(proc, "right", "%d", level->right);
|
|
}
|
|
return IF_ALL;
|
|
|
|
case MIXIOSETVOLUME:
|
|
/* Print the corrected volume levels only with verbosity on. */
|
|
if ((level = (struct volume_level *)ptr) == NULL)
|
|
return IF_OUT | ((verbose > 0) ? IF_IN : 0);
|
|
|
|
if (dir == IF_OUT)
|
|
put_sound_device(proc, "device", level->device);
|
|
put_value(proc, "left", "%d", level->left);
|
|
put_value(proc, "right", "%d", level->right);
|
|
return IF_ALL;
|
|
|
|
case MIXIOGETINPUTLEFT:
|
|
case MIXIOGETINPUTRIGHT:
|
|
case MIXIOGETOUTPUT:
|
|
if ((inout = (struct inout_ctrl *)ptr) == NULL)
|
|
return dir;
|
|
|
|
if (dir == IF_OUT)
|
|
put_sound_device(proc, "device", inout->device);
|
|
else {
|
|
put_sound_state(proc, "left", inout->left);
|
|
put_sound_state(proc, "right", inout->right);
|
|
}
|
|
return IF_ALL;
|
|
|
|
case MIXIOSETINPUTLEFT:
|
|
case MIXIOSETINPUTRIGHT:
|
|
case MIXIOSETOUTPUT:
|
|
if ((inout = (struct inout_ctrl *)ptr) == NULL)
|
|
return IF_OUT;
|
|
|
|
put_sound_device(proc, "device", inout->device);
|
|
put_sound_state(proc, "left", inout->left);
|
|
put_sound_state(proc, "right", inout->right);
|
|
return IF_ALL;
|
|
|
|
case TIOCFLUSH:
|
|
if (ptr == NULL)
|
|
return IF_OUT;
|
|
|
|
put_flags(proc, NULL, flush_flags, COUNT(flush_flags), "0x%x",
|
|
*(int *)ptr);
|
|
return IF_ALL;
|
|
|
|
case TIOCGETA:
|
|
case TIOCSETA:
|
|
case TIOCSETAW:
|
|
case TIOCSETAF:
|
|
if ((tc = (struct termios *)ptr) == NULL)
|
|
return dir;
|
|
|
|
/*
|
|
* These are fairly common IOCTLs, so printing everything by
|
|
* default would create a lot of noise. By default we limit
|
|
* ourselves to printing the field that contains what I
|
|
* consider to be the most important flag: ICANON.
|
|
* TODO: see if we can come up with a decent format for
|
|
* selectively printing (relatively important) flags.
|
|
*/
|
|
if (verbose > 0) {
|
|
put_flags(proc, "c_iflag", tc_iflags, COUNT(tc_iflags),
|
|
"0x%x", tc->c_iflag);
|
|
put_flags(proc, "c_oflag", tc_oflags, COUNT(tc_oflags),
|
|
"0x%x", tc->c_oflag);
|
|
put_flags(proc, "c_cflag", tc_cflags, COUNT(tc_cflags),
|
|
"0x%x", tc->c_cflag);
|
|
}
|
|
put_flags(proc, "c_lflag", tc_lflags, COUNT(tc_lflags), "0x%x",
|
|
tc->c_lflag);
|
|
if (verbose > 0) {
|
|
put_value(proc, "c_ispeed", "%d", tc->c_ispeed);
|
|
put_value(proc, "c_ospeed", "%d", tc->c_ospeed);
|
|
}
|
|
return 0; /* TODO: print the c_cc fields */
|
|
|
|
case TIOCGETD:
|
|
case TIOCSETD:
|
|
if (ptr == NULL)
|
|
return dir;
|
|
|
|
put_tty_disc(proc, NULL, *(int *)ptr);
|
|
return IF_ALL;
|
|
|
|
case TIOCGLINED:
|
|
case TIOCSLINED:
|
|
if (ptr == NULL)
|
|
return dir;
|
|
|
|
put_buf(proc, NULL, PF_LOCADDR | PF_STRING, (vir_bytes)ptr,
|
|
sizeof(linedn_t));
|
|
return IF_ALL;
|
|
|
|
case TIOCGPGRP:
|
|
case TIOCSPGRP:
|
|
case TIOCOUTQ:
|
|
case TIOCPKT:
|
|
case TIOCREMOTE:
|
|
case TIOCUCNTL:
|
|
case TIOCSTAT: /* argument seems unused? */
|
|
case TIOCGSID:
|
|
case TIOCCONS: /* argument seems unused? */
|
|
case TIOCEXT:
|
|
case TIOCSQSIZE:
|
|
case TIOCGQSIZE:
|
|
/* Print a simple integer. */
|
|
if (ptr == NULL)
|
|
return dir;
|
|
|
|
put_value(proc, NULL, "%d", *(int *)ptr);
|
|
return IF_ALL;
|
|
|
|
case TIOCPTSNAME:
|
|
if ((pm = (struct ptmget *)ptr) == NULL)
|
|
return IF_IN;
|
|
|
|
put_buf(proc, "sn", PF_LOCADDR | PF_STRING, (vir_bytes)pm->sn,
|
|
sizeof(pm->sn));
|
|
return IF_ALL;
|
|
|
|
case TIOCSTI:
|
|
if (ptr == NULL)
|
|
return dir;
|
|
|
|
if (!valuesonly)
|
|
put_value(proc, NULL, "'%s'",
|
|
get_escape(*(char *)ptr));
|
|
else
|
|
put_value(proc, NULL, "%u", *(char *)ptr);
|
|
return IF_ALL;
|
|
|
|
case TIOCGWINSZ:
|
|
case TIOCSWINSZ:
|
|
if ((ws = (struct winsize *)ptr) == NULL)
|
|
return dir;
|
|
|
|
/* This is a stupid order, but we follow the struct layout. */
|
|
put_value(proc, "ws_row", "%u", ws->ws_row);
|
|
put_value(proc, "ws_col", "%u", ws->ws_col);
|
|
if (verbose > 0) {
|
|
put_value(proc, "ws_xpixel", "%u", ws->ws_xpixel);
|
|
put_value(proc, "ws_ypixel", "%u", ws->ws_ypixel);
|
|
}
|
|
return (verbose > 0) ? IF_ALL : 0;
|
|
|
|
case KIOCBELL:
|
|
if ((bell = (struct kio_bell *)ptr) == NULL)
|
|
return IF_OUT;
|
|
|
|
put_value(proc, "kb_pitch", "%u", bell->kb_pitch);
|
|
put_value(proc, "kb_volume", "%lu", bell->kb_volume);
|
|
put_struct_timeval(proc, "kb_duration", PF_LOCADDR,
|
|
(vir_bytes)&bell->kb_duration);
|
|
|
|
return IF_ALL;
|
|
|
|
case KIOCSLEDS:
|
|
if ((leds = (struct kio_leds *)ptr) == NULL)
|
|
return IF_OUT;
|
|
|
|
put_flags(proc, "kl_bits", kbd_leds, COUNT(kbd_leds), "0x%x",
|
|
leds->kl_bits);
|
|
return IF_ALL;
|
|
|
|
case PCI_IOC_CFGREAD:
|
|
if ((pci_cfgreg = (struct pciio_cfgreg *)ptr) == NULL)
|
|
return IF_IN;
|
|
|
|
put_ptr(proc, "reg", (vir_bytes)pci_cfgreg->reg);
|
|
put_value(proc, "val", "%08x", pci_cfgreg->val);
|
|
return IF_ALL;
|
|
|
|
case PCI_IOC_CFGWRITE:
|
|
if ((pci_cfgreg = (struct pciio_cfgreg *)ptr) == NULL)
|
|
return IF_OUT;
|
|
|
|
put_ptr(proc, "reg", (vir_bytes)pci_cfgreg->reg);
|
|
put_value(proc, "val", "%08x", pci_cfgreg->val);
|
|
return IF_ALL;
|
|
|
|
case PCI_IOC_BDF_CFGREAD:
|
|
if ((pci_bdf_cfgreg = (struct pciio_bdf_cfgreg *)ptr) == NULL)
|
|
return IF_IN;
|
|
|
|
put_value(proc, "bus", "%u", pci_bdf_cfgreg->bus);
|
|
put_value(proc, "device", "%u", pci_bdf_cfgreg->device);
|
|
put_value(proc, "function", "%u", pci_bdf_cfgreg->function);
|
|
put_ptr(proc, "cfgreg.reg", (vir_bytes)pci_bdf_cfgreg->cfgreg.reg);
|
|
put_value(proc, "cfgreg.val", "%08x", pci_bdf_cfgreg->cfgreg.val);
|
|
return IF_ALL;
|
|
|
|
case PCI_IOC_BDF_CFGWRITE:
|
|
if ((pci_bdf_cfgreg = (struct pciio_bdf_cfgreg *)ptr) == NULL)
|
|
return IF_OUT;
|
|
|
|
put_value(proc, "bus", "%u", pci_bdf_cfgreg->bus);
|
|
put_value(proc, "device", "%u", pci_bdf_cfgreg->device);
|
|
put_value(proc, "function", "%u", pci_bdf_cfgreg->function);
|
|
put_ptr(proc, "cfgreg.reg", (vir_bytes)pci_bdf_cfgreg->cfgreg.reg);
|
|
put_value(proc, "cfgreg.val", "%08x", pci_bdf_cfgreg->cfgreg.val);
|
|
return IF_ALL;
|
|
|
|
case PCI_IOC_BUSINFO:
|
|
if ((pci_businfo = (struct pciio_businfo *)ptr) == NULL)
|
|
return IF_IN;
|
|
|
|
put_value(proc, "busno", "%u", pci_businfo->busno);
|
|
put_value(proc, "maxdevs", "%u", pci_businfo->maxdevs);
|
|
return IF_ALL;
|
|
|
|
case PCI_IOC_MAP:
|
|
if ((pci_iomap = (struct pciio_map *)ptr) == NULL)
|
|
return IF_OUT|IF_IN;
|
|
|
|
put_value(proc, "flags", "%x", pci_iomap->flags);
|
|
put_value(proc, "phys_offset", "%08x", pci_iomap->phys_offset);
|
|
put_value(proc, "size", "%zu", pci_iomap->size);
|
|
put_value(proc, "readonly", "%x", pci_iomap->readonly);
|
|
|
|
if (IF_IN == dir)
|
|
put_ptr(proc, "vaddr_ret", (vir_bytes)pci_iomap->vaddr_ret);
|
|
|
|
return IF_ALL;
|
|
|
|
case PCI_IOC_UNMAP:
|
|
if ((pci_iomap = (struct pciio_map *)ptr) == NULL)
|
|
return IF_OUT;
|
|
|
|
put_ptr(proc, "vaddr", (vir_bytes)pci_iomap->vaddr);
|
|
|
|
return IF_ALL;
|
|
|
|
case PCI_IOC_RESERVE:
|
|
if ((pci_acl = (struct pciio_acl *)ptr) == NULL)
|
|
return IF_OUT;
|
|
|
|
put_value(proc, "domain", "%u", pci_acl->domain);
|
|
put_value(proc, "bus", "%u", pci_acl->bus);
|
|
put_value(proc, "device", "%u", pci_acl->device);
|
|
put_value(proc, "function", "%u", pci_acl->function);
|
|
|
|
return IF_ALL;
|
|
case PCI_IOC_RELEASE:
|
|
if ((pci_acl = (struct pciio_acl *)ptr) == NULL)
|
|
return IF_OUT;
|
|
|
|
put_value(proc, "domain", "%u", pci_acl->domain);
|
|
put_value(proc, "bus", "%u", pci_acl->bus);
|
|
put_value(proc, "device", "%u", pci_acl->device);
|
|
put_value(proc, "function", "%u", pci_acl->function);
|
|
|
|
return IF_ALL;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|