the PCI routing handling, and getting the Joliet stuff right for iso9660.
- final:
- Patrick Mochel: export the ACPI facs table in /proc too
- Brian Gerst: Video4Linux cleanup (named initializers)
- Linus: only use irq13 for FP errors for external FPU's. This
fixes the Atlon FP exception lockups.
- Linus: add a new intel signature to the PIRQ table matching logic.
Make the matching match both reported and actual device ID (with a
preference for the reported). Fixes PCMCIA on NEC Versa laptops.
- iso9660: fix Joliet filename argument order bug introduced in pre7
- Highmem: p_page -> b_page typo.
- Linus: don't allow pending FPU exceptions without an FPU context..
{ACPI_FACP, "facp", &acpi_facp, 0, 0644, NULL, &acpi_do_table},
{ACPI_DSDT, "dsdt", &acpi_dsdt, 0, 0644, NULL, &acpi_do_table},
+
+ {ACPI_FACS, "facs", &acpi_facs, 0, 0644, NULL, &acpi_do_table},
{ACPI_PM1_ENABLE, "pm1_enable",
NULL, 0,
if (!acpi_init_table(&acpi_facp, dt, 1)) {
struct acpi_facp *facp
= (struct acpi_facp*) acpi_facp.table;
+ struct acpi_table *facs;
// map DSDT if it exists
- dt = acpi_map_table(facp->dsdt);
- if (acpi_init_table(&acpi_dsdt, dt, 1))
- acpi_unmap_table(dt);
-
+ if ((dt = acpi_map_table(facp->dsdt))) {
+ if (acpi_init_table(&acpi_dsdt, dt, 1))
+ acpi_unmap_table(dt);
+ }
+
+ /*
+ * map FACS if it exists
+ */
+ if ((facs = acpi_map_table(facp->facs))) {
+ if (acpi_init_table(&acpi_facs,facs,1))
+ acpi_unmap_table(facs);
+ }
break;
}
else {
spin_unlock_irqrestore(&i8259A_lock, flags);
}
-#ifndef CONFIG_VISWS
/*
* Note that on a 486, we don't want to do a SIGFPE on an irq13
* as the irq is unreliable, and exception 16 works correctly
* New motherboards sometimes make IRQ 13 be a PCI interrupt,
* so allow interrupt sharing.
*/
-static struct irqaction irq13 = { math_error_irq, SA_SHIRQ, 0, "fpu", NULL, NULL };
+static struct irqaction irq13 = { math_error_irq, 0, 0, "fpu", NULL, NULL };
/*
* IRQ2 is cascade interrupt to second interrupt controller
*/
+#ifndef CONFIG_VISWS
static struct irqaction irq2 = { no_action, 0, 0, "cascade", NULL, NULL};
#endif
#ifndef CONFIG_VISWS
setup_irq(2, &irq2);
- setup_irq(13, &irq13);
#endif
+
+ /*
+ * External FPU? Set up irq13 if so, for
+ * original braindamaged IBM FERR coupling.
+ */
+ if (boot_cpu_data.hard_math && !cpu_has_fpu)
+ setup_irq(13, &irq13);
}
{ "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371FB_0, pirq_piix_get, pirq_piix_set },
{ "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371SB_0, pirq_piix_get, pirq_piix_set },
{ "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_0, pirq_piix_get, pirq_piix_set },
+ { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371MX, pirq_piix_get, pirq_piix_set },
{ "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82443MX_0, pirq_piix_get, pirq_piix_set },
+
{ "ALI", PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, pirq_ali_get, pirq_ali_set },
+
{ "VIA", PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C586_0, pirq_via_get, pirq_via_set },
{ "VIA", PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596, pirq_via_get, pirq_via_set },
{ "VIA", PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686, pirq_via_get, pirq_via_set },
+
{ "OPTI", PCI_VENDOR_ID_OPTI, PCI_DEVICE_ID_OPTI_82C700, pirq_opti_get, pirq_opti_set },
+
{ "NatSemi", PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5520, pirq_cyrix_get, pirq_cyrix_set },
+
{ "default", 0, 0, NULL, NULL }
};
static void __init pirq_find_router(void)
{
struct irq_routing_table *rt = pirq_table;
- u16 rvendor, rdevice;
struct irq_router *r;
#ifdef CONFIG_PCI_BIOS
return;
}
#endif
- if (!(pirq_router_dev = pci_find_slot(rt->rtr_bus, rt->rtr_devfn))) {
+ /* fall back to default router if nothing else found */
+ pirq_router = pirq_routers + sizeof(pirq_routers) / sizeof(pirq_routers[0]) - 1;
+
+ pirq_router_dev = pci_find_slot(rt->rtr_bus, rt->rtr_devfn);
+ if (!pirq_router_dev) {
DBG("PCI: Interrupt router not found at %02x:%02x\n", rt->rtr_bus, rt->rtr_devfn);
- /* fall back to default router */
- pirq_router = pirq_routers + sizeof(pirq_routers) / sizeof(pirq_routers[0]) - 1;
return;
}
- if (rt->rtr_vendor) {
- rvendor = rt->rtr_vendor;
- rdevice = rt->rtr_device;
- } else {
- /*
- * Several BIOSes forget to set the router type. In such cases, we
- * use chip vendor/device. This doesn't guarantee us semantics of
- * PIRQ values, but was found to work in practice and it's still
- * better than not trying.
- */
- DBG("PCI: Guessed interrupt router ID from %s\n", pirq_router_dev->slot_name);
- rvendor = pirq_router_dev->vendor;
- rdevice = pirq_router_dev->device;
- }
- for(r=pirq_routers; r->vendor; r++)
- if (r->vendor == rvendor && r->device == rdevice)
+
+ for(r=pirq_routers; r->vendor; r++) {
+ /* Exact match against router table entry? Use it! */
+ if (r->vendor == rt->rtr_vendor && r->device == rt->rtr_device) {
+ pirq_router = r;
break;
- pirq_router = r;
- printk("PCI: Using IRQ router %s [%04x/%04x] at %s\n", r->name,
- rvendor, rdevice, pirq_router_dev->slot_name);
+ }
+ /* Match against router device entry? Use it as a fallback */
+ if (r->vendor == pirq_router_dev->vendor && r->device == pirq_router_dev->device) {
+ pirq_router = r;
+ }
+ }
+ printk("PCI: Using IRQ router %s [%04x/%04x] at %s\n",
+ pirq_router->name,
+ pirq_router_dev->vendor,
+ pirq_router_dev->device,
+ pirq_router_dev->slot_name);
}
static struct irq_info *pirq_get_info(struct pci_dev *dev, int pin)
p += sprintf(p, "cache size\t: %d KB\n", c->x86_cache_size);
/* We use exception 16 if we have hardware math and we've either seen it or the CPU claims it is internal */
- fpu_exception = c->hard_math && (ignore_irq13 | test_bit(X86_FEATURE_FPU, &c->x86_capability));
+ fpu_exception = c->hard_math && (ignore_irq13 || cpu_has_fpu);
p += sprintf(p, "fdiv_bug\t: %s\n"
"hlt_bug\t\t: %s\n"
"f00f_bug\t: %s\n"
if (tsc_disable && cpu_has_tsc) {
printk("Disabling TSC...\n");
/**** FIX-HPA: DOES THIS REALLY BELONG HERE? ****/
- clear_bit(&boot_cpu_data.x86_capability, X86_FEATURE_TSC);
+ clear_bit(X86_FEATURE_TSC, boot_cpu_data.x86_capability);
set_in_cr4(X86_CR4_TSD);
}
#endif
static struct video_device rtrack_radio=
{
- "RadioTrack radio",
- VID_TYPE_TUNER,
- VID_HARDWARE_RTRACK,
- rt_open,
- rt_close,
- NULL, /* Can't read (no capture ability) */
- NULL, /* Can't write */
- NULL, /* No poll */
- rt_ioctl,
- NULL,
- NULL
+ name: "RadioTrack radio",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_RTRACK,
+ open: rt_open,
+ close: rt_close,
+ ioctl: rt_ioctl,
};
static int __init rtrack_init(void)
static struct video_device aztech_radio=
{
- "Aztech radio",
- VID_TYPE_TUNER,
- VID_HARDWARE_AZTECH,
- az_open,
- az_close,
- NULL, /* Can't read (no capture ability) */
- NULL, /* Can't write */
- NULL, /* No poll */
- az_ioctl,
- NULL,
- NULL
+ name: "Aztech radio",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_AZTECH,
+ open: az_open,
+ close: az_close,
+ ioctl: az_ioctl,
};
static int __init aztech_init(void)
static struct video_device cadet_radio=
{
- "Cadet radio",
- VID_TYPE_TUNER,
- VID_HARDWARE_CADET,
- cadet_open,
- cadet_close,
- cadet_read,
- NULL, /* Can't write */
- NULL, /* No poll */
- cadet_ioctl,
- NULL,
- NULL
+ name: "Cadet radio",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_CADET,
+ open: cadet_open,
+ close: cadet_close,
+ read: cadet_read,
+ ioctl: cadet_ioctl,
};
#ifdef CONFIG_ISAPNP
static struct video_device gemtek_radio=
{
- "GemTek radio",
- VID_TYPE_TUNER,
- VID_HARDWARE_GEMTEK,
- gemtek_open,
- gemtek_close,
- NULL, /* Can't read (no capture ability) */
- NULL, /* Can't write */
- NULL, /* Can't poll */
- gemtek_ioctl,
- NULL,
- NULL
+ name: "GemTek radio",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_GEMTEK,
+ open: gemtek_open,
+ close: gemtek_close,
+ ioctl: gemtek_ioctl,
};
static int __init gemtek_init(void)
static struct video_device maestro_radio=
{
- "Maestro radio",
- VID_TYPE_TUNER,
- VID_HARDWARE_SF16MI,
- radio_open,
- radio_close,
- NULL,
- NULL,
- NULL,
- radio_ioctl,
- NULL,
- NULL
+ name: "Maestro radio",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_SF16MI,
+ open: radio_open,
+ close: radio_close,
+ ioctl: radio_ioctl,
};
static struct radio_device
inline static __u16 radio_install(struct pci_dev *pcidev);
-#ifdef MODULE
MODULE_AUTHOR("Adam Tlalka, atlka@pg.gda.pl");
MODULE_DESCRIPTION("Radio driver for the Maestro PCI sound card radio.");
EXPORT_NO_SYMBOLS;
-void cleanup_module(void)
+void __exit maestro_radio_exit(void)
{
video_unregister_device(&maestro_radio);
}
-int init_module(void)
-#else
-int __init maestro_radio_init(struct video_init *v)
-#endif
+int __init maestro_radio_init(void)
{
register __u16 found=0;
struct pci_dev *pcidev = NULL;
return 0;
}
+module_init(maestro_radio_init);
+module_exit(maestro_radio_exit);
+
inline static __u16 radio_power_on(struct radio_device *dev)
{
register __u16 io=dev->io;
static struct video_device pcm20_radio=
{
- "Miro PCM 20 radio",
- VID_TYPE_TUNER,
- VID_HARDWARE_RTRACK,
- pcm20_open,
- pcm20_close,
- NULL, /* Can't read (no capture ability) */
- NULL, /* Can't write */
- NULL, /* Can't poll */
- pcm20_ioctl,
- NULL,
- NULL
+ name: "Miro PCM 20 radio",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_RTRACK,
+ open: pcm20_open,
+ close: pcm20_close,
+ ioctl: pcm20_ioctl,
};
static int __init pcm20_init(void)
static struct video_device rtrack2_radio=
{
- "RadioTrack II radio",
- VID_TYPE_TUNER,
- VID_HARDWARE_RTRACK2,
- rt_open,
- rt_close,
- NULL, /* Can't read (no capture ability) */
- NULL, /* Can't write */
- NULL, /* Can't poll */
- rt_ioctl,
- NULL,
- NULL
+ name: "RadioTrack II radio",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_RTRACK2,
+ open: rt_open,
+ close: rt_close,
+ ioctl: rt_ioctl,
};
static int __init rtrack2_init(void)
static struct video_device fmi_radio=
{
- "SF16FMx radio",
- VID_TYPE_TUNER,
- VID_HARDWARE_SF16MI,
- fmi_open,
- fmi_close,
- NULL, /* Can't read (no capture ability) */
- NULL, /* Can't write */
- NULL, /* Can't poll */
- fmi_ioctl,
- NULL,
- NULL
+ name: "SF16FMx radio",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_SF16MI,
+ open: fmi_open,
+ close: fmi_close,
+ ioctl: fmi_ioctl,
};
static int __init fmi_init(void)
static struct video_device terratec_radio=
{
- "TerraTec ActiveRadio",
- VID_TYPE_TUNER,
- VID_HARDWARE_TERRATEC,
- tt_open,
- tt_close,
- NULL, /* Can't read (no capture ability) */
- NULL, /* Can't write */
- NULL, /* No poll */
- tt_ioctl,
- NULL,
- NULL
+ name: "TerraTec ActiveRadio",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_TERRATEC,
+ open: tt_open,
+ close: tt_close,
+ ioctl: tt_ioctl,
};
static int __init terratec_init(void)
static struct video_device trust_radio=
{
- "Trust FM Radio",
- VID_TYPE_TUNER,
- VID_HARDWARE_TRUST,
- tr_open,
- tr_close,
- NULL, /* Can't read (no capture ability) */
- NULL, /* Can't write */
- NULL, /* No poll */
- tr_ioctl,
- NULL,
- NULL
+ name: "Trust FM Radio",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_TRUST,
+ open: tr_open,
+ close: tr_close,
+ ioctl: tr_ioctl,
};
static int __init trust_init(void)
static struct typhoon_device typhoon_unit =
{
- 0, /* users */
- CONFIG_RADIO_TYPHOON_PORT, /* iobase */
- 0, /* curvol */
- 0, /* muted */
- CONFIG_RADIO_TYPHOON_MUTEFREQ, /* curfreq */
- CONFIG_RADIO_TYPHOON_MUTEFREQ /* mutefreq */
+ iobase: CONFIG_RADIO_TYPHOON_PORT,
+ curfreq: CONFIG_RADIO_TYPHOON_MUTEFREQ,
+ mutefreq: CONFIG_RADIO_TYPHOON_MUTEFREQ,
};
static struct video_device typhoon_radio =
{
- "Typhoon Radio",
- VID_TYPE_TUNER,
- VID_HARDWARE_TYPHOON,
- typhoon_open,
- typhoon_close,
- NULL, /* Can't read (no capture ability) */
- NULL, /* Can't write */
- NULL, /* Can't poll */
- typhoon_ioctl,
- NULL,
- NULL
+ name: "Typhoon Radio",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_TYPHOON,
+ open: typhoon_open,
+ close: typhoon_close,
+ ioctl: typhoon_ioctl,
};
#ifdef CONFIG_RADIO_TYPHOON_PROC_FS
static struct video_device zoltrix_radio =
{
- "Zoltrix Radio Plus",
- VID_TYPE_TUNER,
- VID_HARDWARE_ZOLTRIX,
- zol_open,
- zol_close,
- NULL, /* Can't read (no capture ability) */
- NULL, /* Can't write */
- NULL,
- zol_ioctl,
- NULL,
- NULL
+ name: "Zoltrix Radio Plus",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_ZOLTRIX,
+ open: zol_open,
+ close: zol_close,
+ ioctl: zol_ioctl,
};
static int __init zoltrix_init(void)
return 0;
}
-static int bttv_init_done(struct video_device *dev)
-{
- return 0;
-}
-
/*
* This maps the vmalloced and reserved fbuffer to user space.
*
static struct video_device bttv_template=
{
- "UNSET",
- VID_TYPE_TUNER|VID_TYPE_CAPTURE|VID_TYPE_OVERLAY|VID_TYPE_TELETEXT,
- VID_HARDWARE_BT848,
- bttv_open,
- bttv_close,
- bttv_read,
- bttv_write,
- NULL,
- bttv_ioctl,
- bttv_mmap,
- bttv_init_done,
- NULL,
- 0,
- -1
+ name: "UNSET",
+ type: VID_TYPE_TUNER|VID_TYPE_CAPTURE|VID_TYPE_OVERLAY|VID_TYPE_TELETEXT,
+ hardware: VID_HARDWARE_BT848,
+ open: bttv_open,
+ close: bttv_close,
+ read: bttv_read,
+ write: bttv_write,
+ ioctl: bttv_ioctl,
+ mmap: bttv_mmap,
+ minor: -1,
};
static struct video_device vbi_template=
{
- "bttv vbi",
- VID_TYPE_CAPTURE|VID_TYPE_TELETEXT,
- VID_HARDWARE_BT848,
- vbi_open,
- vbi_close,
- vbi_read,
- bttv_write,
- vbi_poll,
- vbi_ioctl,
- NULL, /* no mmap yet */
- bttv_init_done,
- NULL,
- 0,
- -1
+ name: "bttv vbi",
+ type: VID_TYPE_CAPTURE|VID_TYPE_TELETEXT,
+ hardware: VID_HARDWARE_BT848,
+ open: vbi_open,
+ close: vbi_close,
+ read: vbi_read,
+ write: bttv_write,
+ poll: vbi_poll,
+ ioctl: vbi_ioctl,
+ minor: -1,
};
static struct video_device radio_template=
{
- "bttv radio",
- VID_TYPE_TUNER,
- VID_HARDWARE_BT848,
- radio_open,
- radio_close,
- radio_read, /* just returns -EINVAL */
- bttv_write, /* just returns -EINVAL */
- NULL, /* no poll */
- radio_ioctl,
- NULL, /* no mmap */
- bttv_init_done, /* just returns 0 */
- NULL,
- 0,
- -1
+ name: "bttv radio",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_BT848,
+ open: radio_open,
+ close: radio_close,
+ read: radio_read, /* just returns -EINVAL */
+ write: bttv_write, /* just returns -EINVAL */
+ ioctl: radio_ioctl,
+ minor: -1,
};
return 0;
}
-static int zoran_init_done(struct video_device *dev)
-{
- return 0;
-}
-
static struct video_device zoran_template =
{
- BUZ_NAME,
- VID_TYPE_CAPTURE | VID_TYPE_OVERLAY | VID_TYPE_CLIPPING | VID_TYPE_FRAMERAM |
- VID_TYPE_SCALES | VID_TYPE_SUBCAPTURE,
- VID_HARDWARE_ZR36067,
- zoran_open,
- zoran_close,
- zoran_read,
- zoran_write,
- NULL,
- zoran_ioctl,
- zoran_mmap,
- zoran_init_done,
- NULL,
- 0,
- 0
+ name: BUZ_NAME,
+ type: VID_TYPE_CAPTURE | VID_TYPE_OVERLAY | VID_TYPE_CLIPPING | VID_TYPE_FRAMERAM |
+ VID_TYPE_SCALES | VID_TYPE_SUBCAPTURE,
+ hardware: VID_HARDWARE_ZR36067,
+ open: zoran_open,
+ close: zoran_close,
+ read: zoran_read,
+ write: zoran_write,
+ ioctl: zoran_ioctl,
+ mmap: zoran_mmap,
};
static int zr36057_init(int i)
MOD_DEC_USE_COUNT;
}
-static int qcam_init_done(struct video_device *dev)
-{
- return 0;
-}
-
static long qcam_write(struct video_device *v, const char *buf, unsigned long count, int noblock)
{
return -EINVAL;
static struct video_device qcam_template=
{
- "Connectix Quickcam",
- VID_TYPE_CAPTURE,
- VID_HARDWARE_QCAM_BW,
- qcam_open,
- qcam_close,
- qcam_read,
- qcam_write,
- NULL,
- qcam_ioctl,
- NULL,
- qcam_init_done,
- NULL,
- 0,
- 0
+ name: "Connectix Quickcam",
+ type: VID_TYPE_CAPTURE,
+ hardware: VID_HARDWARE_QCAM_BW,
+ open: qcam_open,
+ close: qcam_close,
+ read: qcam_read,
+ write: qcam_write,
+ ioctl: qcam_ioctl,
};
#define MAX_CAMS 4
MOD_DEC_USE_COUNT;
}
-static int qcam_init_done(struct video_device *dev)
-{
- return 0;
-}
-
static long qcam_write(struct video_device *v, const char *buf, unsigned long count, int noblock)
{
return -EINVAL;
/* video device template */
static struct video_device qcam_template=
{
- "Colour QuickCam",
- VID_TYPE_CAPTURE,
- VID_HARDWARE_QCAM_C,
- qcam_open,
- qcam_close,
- qcam_read,
- qcam_write,
- NULL,
- qcam_ioctl,
- NULL,
- qcam_init_done,
- NULL,
- 0,
- 0
+ name: "Colour QuickCam",
+ type: VID_TYPE_CAPTURE,
+ hardware: VID_HARDWARE_QCAM_C,
+ open: qcam_open,
+ close: qcam_close,
+ read: qcam_read,
+ write: qcam_write,
+ ioctl: qcam_ioctl,
};
/* Initialize the QuickCam driver control structure. */
}
static struct video_device cpia_template = {
- "CPiA Camera",
- VID_TYPE_CAPTURE,
- VID_HARDWARE_CPIA, /* FIXME */
- cpia_open, /* open */
- cpia_close, /* close */
- cpia_read, /* read */
- NULL, /* no write */
- NULL, /* no poll */
- cpia_ioctl, /* ioctl */
- cpia_mmap, /* mmap */
- cpia_video_init, /* initialize */
- NULL, /* priv */
- 0, /* busy */
- -1 /* minor - unset */
+ name: "CPiA Camera",
+ type: VID_TYPE_CAPTURE,
+ hardware: VID_HARDWARE_CPIA, /* FIXME */
+ open: cpia_open,
+ close: cpia_close,
+ read: cpia_read,
+ ioctl: cpia_ioctl,
+ mmap: cpia_mmap,
+ initialize: cpia_video_init,
+ minor: -1,
};
/* initialise cam_data structure */
return 0;
}
-/* This gets called upon device registration */
-/* we could do some init here */
-static int planb_init_done(struct video_device *dev)
-{
- return 0;
-}
-
static struct video_device planb_template=
{
- PLANB_DEVICE_NAME,
- VID_TYPE_OVERLAY,
- VID_HARDWARE_PLANB,
- planb_open,
- planb_close,
- planb_read,
- planb_write,
-#if LINUX_VERSION_CODE >= 0x020100
- NULL, /* poll */
-#endif
- planb_ioctl,
- planb_mmap, /* mmap? */
- planb_init_done,
- NULL, /* pointer to private data */
- 0,
- 0
+ name: PLANB_DEVICE_NAME,
+ type: VID_TYPE_OVERLAY,
+ hardware: VID_HARDWARE_PLANB,
+ open: planb_open,
+ close: planb_close,
+ read: planb_read,
+ write: planb_write,
+ ioctl: planb_ioctl,
+ mmap: planb_mmap, /* mmap? */
};
static int init_planb(struct planb *pb)
MOD_DEC_USE_COUNT;
}
-static int pms_init_done(struct video_device *dev)
-{
- return 0;
-}
-
static long pms_write(struct video_device *v, const char *buf, unsigned long count, int noblock)
{
return -EINVAL;
struct video_device pms_template=
{
- "Mediavision PMS",
- VID_TYPE_CAPTURE,
- VID_HARDWARE_PMS,
- pms_open,
- pms_close,
- pms_read,
- pms_write,
- NULL, /* FIXME - we can use POLL on this board with the irq */
- pms_ioctl,
- NULL,
- pms_init_done,
- NULL,
- 0,
- 0
+ name: "Mediavision PMS",
+ type: VID_TYPE_CAPTURE,
+ hardware: VID_HARDWARE_PMS,
+ open: pms_open,
+ close: pms_close,
+ read: pms_read,
+ write: pms_write,
+ ioctl: pms_ioctl,
};
struct pms_device pms_device;
static struct video_device saa_template =
{
- IF_NAME,
- VID_TYPE_TELETEXT, /*| VID_TYPE_TUNER ?? */
- VID_HARDWARE_SAA5249,
- saa5249_open,
- saa5249_release,
- NULL, /* read */
- saa5249_write,
- NULL, /* poll */
- saa5249_ioctl,
- /* the rest are null */
+ name: IF_NAME,
+ type: VID_TYPE_TELETEXT, /*| VID_TYPE_TUNER ?? */
+ hardware: VID_HARDWARE_SAA5249,
+ open: saa5249_open,
+ close: saa5249_release,
+ write: saa5249_write,
+ ioctl: saa5249_ioctl,
};
return 0;
}
-static int saa_init_done(struct video_device *dev)
-{
- return 0;
-}
-
static int saa_mmap(struct video_device *dev, const char *adr,
unsigned long size)
{
/* template for video_device-structure */
static struct video_device saa_template =
{
- "SAA7146A",
- VID_TYPE_CAPTURE | VID_TYPE_OVERLAY,
- VID_HARDWARE_SAA7146,
- saa_open,
- saa_close,
- saa_read,
- saa_write,
- NULL, /* poll */
- saa_ioctl,
- saa_mmap,
- saa_init_done,
- NULL,
- 0,
- 0
+ name: "SAA7146A",
+ type: VID_TYPE_CAPTURE | VID_TYPE_OVERLAY,
+ hardware: VID_HARDWARE_SAA7146,
+ open: saa_open,
+ close: saa_close,
+ read: saa_read,
+ write: saa_write,
+ ioctl: saa_ioctl,
+ mmap: saa_mmap,
};
static int configure_saa7146(struct pci_dev *dev, int num)
}
static struct video_device vino_dev = {
- "Vino IndyCam/TV",
- VID_TYPE_CAPTURE,
- VID_HARDWARE_VINO,
- vino_open,
- vino_close,
- NULL, /* vino_read */
- NULL, /* vino_write */
- NULL, /* vino_poll */
- vino_ioctl,
- vino_mmap,
- NULL, /* vino_init */
- NULL,
- 0,
- 0
+ name: "Vino IndyCam/TV",
+ type: VID_TYPE_CAPTURE,
+ hardware: VID_HARDWARE_VINO,
+ open: vino_open,
+ close: vino_close,
+ ioctl: vino_ioctl,
+ mmap: vino_mmap,
};
int __init init_vino(struct video_device *dev)
static struct video_device zr36120_template=
{
- "UNSET",
- VID_TYPE_TUNER|VID_TYPE_CAPTURE|VID_TYPE_OVERLAY,
- VID_HARDWARE_ZR36120,
-
- zoran_open,
- zoran_close,
- zoran_read,
- zoran_write,
-#if LINUX_VERSION_CODE >= 0x020100
- zoran_poll, /* poll */
-#endif
- zoran_ioctl,
- zoran_mmap,
- NULL, /* initialize */
- NULL,
- 0,
- -1
+ name: "UNSET",
+ type: VID_TYPE_TUNER|VID_TYPE_CAPTURE|VID_TYPE_OVERLAY,
+ hardware: VID_HARDWARE_ZR36120,
+ open: zoran_open,
+ close: zoran_close,
+ read: zoran_read,
+ write: zoran_write,
+ poll: zoran_poll,
+ ioctl: zoran_ioctl,
+ mmap: zoran_mmap,
+ minor: -1,
};
static
static struct video_device vbi_template=
{
- "UNSET",
- VID_TYPE_CAPTURE|VID_TYPE_TELETEXT,
- VID_HARDWARE_ZR36120,
-
- vbi_open,
- vbi_close,
- vbi_read,
- zoran_write,
-#if LINUX_VERSION_CODE >= 0x020100
- vbi_poll, /* poll */
-#endif
- vbi_ioctl,
- NULL, /* no mmap */
- NULL, /* no initialize */
- NULL, /* priv */
- 0, /* busy */
- -1 /* minor */
+ name: "UNSET",
+ type: VID_TYPE_CAPTURE|VID_TYPE_TELETEXT,
+ hardware: VID_HARDWARE_ZR36120,
+ open: vbi_open,
+ close: vbi_close,
+ read: vbi_read,
+ write: zoran_write,
+ poll: vbi_poll,
+ ioctl: vbi_ioctl,
+ minor: -1,
};
/*
static struct video_device usb_dsbr100_radio=
{
- "D-Link DSB R-100 USB radio",
- VID_TYPE_TUNER,
- VID_HARDWARE_AZTECH,
- usb_dsbr100_open,
- usb_dsbr100_close,
- NULL, /* Can't read (no capture ability) */
- NULL, /* Can't write */
- NULL, /* No poll */
- usb_dsbr100_ioctl,
- NULL,
- NULL
+ name: "D-Link DSB R-100 USB radio",
+ type: VID_TYPE_TUNER,
+ hardware: VID_HARDWARE_AZTECH,
+ open: usb_dsbr100_open,
+ close: usb_dsbr100_close,
+ ioctl: usb_dsbr100_ioctl,
};
static int users = 0;
MOD_DEC_USE_COUNT;
}
-static int ibmcam_init_done(struct video_device *dev)
-{
- return 0;
-}
-
static long ibmcam_write(struct video_device *dev, const char *buf, unsigned long count, int noblock)
{
return -EINVAL;
}
static struct video_device ibmcam_template = {
- "CPiA USB Camera",
- VID_TYPE_CAPTURE,
- VID_HARDWARE_CPIA,
- ibmcam_open,
- ibmcam_close,
- ibmcam_read,
- ibmcam_write,
- NULL,
- ibmcam_ioctl,
- ibmcam_mmap,
- ibmcam_init_done,
- NULL,
- 0,
- 0
+ name: "CPiA USB Camera",
+ type: VID_TYPE_CAPTURE,
+ hardware: VID_HARDWARE_CPIA,
+ open: ibmcam_open,
+ close: ibmcam_close,
+ read: ibmcam_read,
+ write: ibmcam_write,
+ ioctl: ibmcam_ioctl,
+ mmap: ibmcam_mmap,
};
static void usb_ibmcam_configure_video(struct usb_ibmcam *ibmcam)
dpnt = tmpname;
#ifdef CONFIG_JOLIET
} else if (dir->i_sb->u.isofs_sb.s_joliet_level) {
- dlen = get_joliet_filename(de, dir, tmpname);
+ dlen = get_joliet_filename(de, tmpname, dir);
dpnt = tmpname;
#endif
} else if (dir->i_sb->u.isofs_sb.s_mapping == 'a') {
#define clear_fpu( tsk ) do { \
if ( tsk->flags & PF_USEDFPU ) { \
+ asm volatile("fwait"); \
tsk->flags &= ~PF_USEDFPU; \
stts(); \
} \
#define cpu_has_vme (test_bit(X86_FEATURE_VME, boot_cpu_data.x86_capability))
#define cpu_has_fxsr (test_bit(X86_FEATURE_FXSR, boot_cpu_data.x86_capability))
#define cpu_has_xmm (test_bit(X86_FEATURE_XMM, boot_cpu_data.x86_capability))
+#define cpu_has_fpu (test_bit(X86_FEATURE_FPU, boot_cpu_data.x86_capability))
extern char ignore_irq13;
{
ACPI_FACP = 1,
ACPI_DSDT,
+ ACPI_FACS,
ACPI_PM1_ENABLE,
ACPI_GPE_ENABLE,
ACPI_GPE_LEVEL,
__u32 __x = (x); \
((__u32)( \
(((__u32)(__x) & (__u32)0x00ff00ffUL) << 8) | \
- (((__u32)(__x) & (__u32)0xff00ff00UL) >> 8) )) \
+ (((__u32)(__x) & (__u32)0xff00ff00UL) >> 8) )); \
})
#define ___constant_swahw32(x) \
static inline char *bh_kmap(struct buffer_head *bh)
{
- return kmap(bh->p_page) + bh_offset(bh);
+ return kmap(bh->b_page) + bh_offset(bh);
}
static inline void bh_kunmap(struct buffer_head *bh)
};
#endif /* _STRUCT_TIMESPEC */
+#ifdef __KERNEL__
+
/*
* Change timeval to jiffies, trying to avoid the
* most obvious overflows..
)*60 + sec; /* finally seconds */
}
+#endif /* __KERNEL__ */
+
struct timeval {
time_t tv_sec; /* seconds */
projects / history.git / commitdiff