/* -- ISP16 cdrom detection and configuration * * Copyright (c) 1995,1996 Eric van der Maarel <H.T.M.v.d.Maarel@marin.nl> * * Version 0.6 * * History: * 0.5 First release. * Was included in the sjcd and optcd cdrom drivers. * 0.6 First "stand-alone" version. * Removed sound configuration. * Added "module" support. * * 9 November 1999 -- Make kernel-parameter implementation work with 2.3.x * Removed init_module & cleanup_module in favor of * module_init & module_exit. * Torben Mathiasen <tmm@image.dk> * * 19 June 2004 -- check_region() converted to request_region() * and return statement cleanups. * - Jesper Juhl * * Detect cdrom interface on ISP16 sound card. * Configure cdrom interface. * * Algorithm for the card with OPTi 82C928 taken * from the CDSETUP.SYS driver for MSDOS, * by OPTi Computers, version 2.03. * Algorithm for the card with OPTi 82C929 as communicated * to me by Vadim Model and Leo Spiekman. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * */ #define ISP16_VERSION_MAJOR 0 #define ISP16_VERSION_MINOR 6 #include <linux/module.h> #include <linux/fs.h> #include <linux/kernel.h> #include <linux/string.h> #include <linux/ioport.h> #include <linux/init.h> #include <asm/io.h> #include "isp16.h" static short isp16_detect(void); static short isp16_c928__detect(void); static short isp16_c929__detect(void); static short isp16_cdi_config(int base, u_char drive_type, int irq, int dma); static short isp16_type; /* dependent on type of interface card */ static u_char isp16_ctrl; static u_short isp16_enable_port; static int isp16_cdrom_base = ISP16_CDROM_IO_BASE; static int isp16_cdrom_irq = ISP16_CDROM_IRQ; static int isp16_cdrom_dma = ISP16_CDROM_DMA; static char *isp16_cdrom_type = ISP16_CDROM_TYPE; module_param(isp16_cdrom_base, int, 0); module_param(isp16_cdrom_irq, int, 0); module_param(isp16_cdrom_dma, int, 0); module_param(isp16_cdrom_type, charp, 0); #define ISP16_IN(p) (outb(isp16_ctrl,ISP16_CTRL_PORT), inb(p)) #define ISP16_OUT(p,b) (outb(isp16_ctrl,ISP16_CTRL_PORT), outb(b,p)) #ifndef MODULE static int __init isp16_setup(char *str) { int ints[4]; (void) get_options(str, ARRAY_SIZE(ints), ints); if (ints[0] > 0) isp16_cdrom_base = ints[1]; if (ints[0] > 1) isp16_cdrom_irq = ints[2]; if (ints[0] > 2) isp16_cdrom_dma = ints[3]; if (str) isp16_cdrom_type = str; return 1; } __setup("isp16=", isp16_setup); #endif /* MODULE */ /* * ISP16 initialisation. * */ static int __init isp16_init(void) { u_char expected_drive; printk(KERN_INFO "ISP16: configuration cdrom interface, version %d.%d.\n", ISP16_VERSION_MAJOR, ISP16_VERSION_MINOR); if (!strcmp(isp16_cdrom_type, "noisp16")) { printk("ISP16: no cdrom interface configured.\n"); return 0; } if (!request_region(ISP16_IO_BASE, ISP16_IO_SIZE, "isp16")) { printk("ISP16: i/o ports already in use.\n"); goto out; } if ((isp16_type = isp16_detect()) < 0) { printk("ISP16: no cdrom interface found.\n"); goto cleanup_out; } printk(KERN_INFO "ISP16: cdrom interface (with OPTi 82C92%d chip) detected.\n", (isp16_type == 2) ? 9 : 8); if (!strcmp(isp16_cdrom_type, "Sanyo")) expected_drive = (isp16_type ? ISP16_SANYO1 : ISP16_SANYO0); else if (!strcmp(isp16_cdrom_type, "Sony")) expected_drive = ISP16_SONY; else if (!strcmp(isp16_cdrom_type, "Panasonic")) expected_drive = (isp16_type ? ISP16_PANASONIC1 : ISP16_PANASONIC0); else if (!strcmp(isp16_cdrom_type, "Mitsumi")) expected_drive = ISP16_MITSUMI; else { printk("ISP16: %s not supported by cdrom interface.\n", isp16_cdrom_type); goto cleanup_out; } if (isp16_cdi_config(isp16_cdrom_base, expected_drive, isp16_cdrom_irq, isp16_cdrom_dma) < 0) { printk ("ISP16: cdrom interface has not been properly configured.\n"); goto cleanup_out; } printk(KERN_INFO "ISP16: cdrom interface set up with io base 0x%03X, irq %d, dma %d," " type %s.\n", isp16_cdrom_base, isp16_cdrom_irq, isp16_cdrom_dma, isp16_cdrom_type); return 0; cleanup_out: release_region(ISP16_IO_BASE, ISP16_IO_SIZE); out: return -EIO; } static short __init isp16_detect(void) { if (isp16_c929__detect() >= 0) return 2; else return (isp16_c928__detect()); } static short __init isp16_c928__detect(void) { u_char ctrl; u_char enable_cdrom; u_char io; short i = -1; isp16_ctrl = ISP16_C928__CTRL; isp16_enable_port = ISP16_C928__ENABLE_PORT; /* read' and write' are a special read and write, respectively */ /* read' ISP16_CTRL_PORT, clear last two bits and write' back the result */ ctrl = ISP16_IN(ISP16_CTRL_PORT) & 0xFC; ISP16_OUT(ISP16_CTRL_PORT, ctrl); /* read' 3,4 and 5-bit from the cdrom enable port */ enable_cdrom = ISP16_IN(ISP16_C928__ENABLE_PORT) & 0x38; if (!(enable_cdrom & 0x20)) { /* 5-bit not set */ /* read' last 2 bits of ISP16_IO_SET_PORT */ io = ISP16_IN(ISP16_IO_SET_PORT) & 0x03; if (((io & 0x01) << 1) == (io & 0x02)) { /* bits are the same */ if (io == 0) { /* ...the same and 0 */ i = 0; enable_cdrom |= 0x20; } else { /* ...the same and 1 *//* my card, first time 'round */ i = 1; enable_cdrom |= 0x28; } ISP16_OUT(ISP16_C928__ENABLE_PORT, enable_cdrom); } else { /* bits are not the same */ ISP16_OUT(ISP16_CTRL_PORT, ctrl); return i; /* -> not detected: possibly incorrect conclusion */ } } else if (enable_cdrom == 0x20) i = 0; else if (enable_cdrom == 0x28) /* my card, already initialised */ i = 1; ISP16_OUT(ISP16_CTRL_PORT, ctrl); return i; } static short __init isp16_c929__detect(void) { u_char ctrl; u_char tmp; isp16_ctrl = ISP16_C929__CTRL; isp16_enable_port = ISP16_C929__ENABLE_PORT; /* read' and write' are a special read and write, respectively */ /* read' ISP16_CTRL_PORT and save */ ctrl = ISP16_IN(ISP16_CTRL_PORT); /* write' zero to the ctrl port and get response */ ISP16_OUT(ISP16_CTRL_PORT, 0); tmp = ISP16_IN(ISP16_CTRL_PORT); if (tmp != 2) /* isp16 with 82C929 not detected */ return -1; /* restore ctrl port value */ ISP16_OUT(ISP16_CTRL_PORT, ctrl); return 2; } static short __init isp16_cdi_config(int base, u_char drive_type, int irq, int dma) { u_char base_code; u_char irq_code; u_char dma_code; u_char i; if ((drive_type == ISP16_MITSUMI) && (dma != 0)) printk("ISP16: Mitsumi cdrom drive has no dma support.\n"); switch (base) { case 0x340: base_code = ISP16_BASE_340; break; case 0x330: base_code = ISP16_BASE_330; break; case 0x360: base_code = ISP16_BASE_360; break; case 0x320: base_code = ISP16_BASE_320; break; default: printk ("ISP16: base address 0x%03X not supported by cdrom interface.\n", base); return -1; } switch (irq) { case 0: irq_code = ISP16_IRQ_X; break; /* disable irq */ case 5: irq_code = ISP16_IRQ_5; printk("ISP16: irq 5 shouldn't be used by cdrom interface," " due to possible conflicts with the sound card.\n"); break; case 7: irq_code = ISP16_IRQ_7; printk("ISP16: irq 7 shouldn't be used by cdrom interface," " due to possible conflicts with the sound card.\n"); break; case 3: irq_code = ISP16_IRQ_3; break; case 9: irq_code = ISP16_IRQ_9; break; case 10: irq_code = ISP16_IRQ_10; break; case 11: irq_code = ISP16_IRQ_11; break; default: printk("ISP16: irq %d not supported by cdrom interface.\n", irq); return -1; } switch (dma) { case 0: dma_code = ISP16_DMA_X; break; /* disable dma */ case 1: printk("ISP16: dma 1 cannot be used by cdrom interface," " due to conflict with the sound card.\n"); return -1; break; case 3: dma_code = ISP16_DMA_3; break; case 5: dma_code = ISP16_DMA_5; break; case 6: dma_code = ISP16_DMA_6; break; case 7: dma_code = ISP16_DMA_7; break; default: printk("ISP16: dma %d not supported by cdrom interface.\n", dma); return -1; } if (drive_type != ISP16_SONY && drive_type != ISP16_PANASONIC0 && drive_type != ISP16_PANASONIC1 && drive_type != ISP16_SANYO0 && drive_type != ISP16_SANYO1 && drive_type != ISP16_MITSUMI && drive_type != ISP16_DRIVE_X) { printk ("ISP16: drive type (code 0x%02X) not supported by cdrom" " interface.\n", drive_type); return -1; } /* set type of interface */ i = ISP16_IN(ISP16_DRIVE_SET_PORT) & ISP16_DRIVE_SET_MASK; /* clear some bits */ ISP16_OUT(ISP16_DRIVE_SET_PORT, i | drive_type); /* enable cdrom on interface with 82C929 chip */ if (isp16_type > 1) ISP16_OUT(isp16_enable_port, ISP16_ENABLE_CDROM); /* set base address, irq and dma */ i = ISP16_IN(ISP16_IO_SET_PORT) & ISP16_IO_SET_MASK; /* keep some bits */ ISP16_OUT(ISP16_IO_SET_PORT, i | base_code | irq_code | dma_code); return 0; } static void __exit isp16_exit(void) { release_region(ISP16_IO_BASE, ISP16_IO_SIZE); printk(KERN_INFO "ISP16: module released.\n"); } module_init(isp16_init); module_exit(isp16_exit); MODULE_LICENSE("GPL");