drivers/cdrom/isp16.c

   1 /* -- ISP16 cdrom detection and configuration
   2  *
   3  *    Copyright (c) 1995,1996 Eric van der Maarel <H.T.M.v.d.Maarel@marin.nl>
   4  *
   5  *    Version 0.6
   6  *
   7  *    History:
   8  *    0.5 First release.
   9  *        Was included in the sjcd and optcd cdrom drivers.
  10  *    0.6 First "stand-alone" version.
  11  *        Removed sound configuration.
  12  *        Added "module" support.
  13  *
  14  *      9 November 1999 -- Make kernel-parameter implementation work with 2.3.x
  15  *                         Removed init_module & cleanup_module in favor of
  16  *                         module_init & module_exit.
  17  *                         Torben Mathiasen <tmm@image.dk>
  18  *
  19  *     19 June 2004     -- check_region() converted to request_region()
  20  *                         and return statement cleanups.
  21  *                          - Jesper Juhl
  22  *
  23  *    Detect cdrom interface on ISP16 sound card.
  24  *    Configure cdrom interface.
  25  *
  26  *    Algorithm for the card with OPTi 82C928 taken
  27  *    from the CDSETUP.SYS driver for MSDOS,
  28  *    by OPTi Computers, version 2.03.
  29  *    Algorithm for the card with OPTi 82C929 as communicated
  30  *    to me by Vadim Model and Leo Spiekman.
  31  *
  32  *    This program is free software; you can redistribute it and/or modify
  33  *    it under the terms of the GNU General Public License as published by
  34  *    the Free Software Foundation; either version 2 of the License, or
  35  *    (at your option) any later version.
  36  *
  37  *    This program is distributed in the hope that it will be useful,
  38  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  39  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  40  *    GNU General Public License for more details.
  41  *
  42  *    You should have received a copy of the GNU General Public License
  43  *    along with this program; if not, write to the Free Software
  44  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  45  *
  46  */
  47
  48 #define ISP16_VERSION_MAJOR 0
  49 #define ISP16_VERSION_MINOR 6
  50
  51 #include <linux/module.h>
  52
  53 #include <linux/fs.h>
  54 #include <linux/kernel.h>
  55 #include <linux/string.h>
  56 #include <linux/ioport.h>
  57 #include <linux/init.h>
  58 #include <asm/io.h>
  59 #include "isp16.h"
  60
  61 static short isp16_detect(void);
  62 static short isp16_c928__detect(void);
  63 static short isp16_c929__detect(void);
  64 static short isp16_cdi_config(int base, u_char drive_type, int irq,
  65                               int dma);
  66 static short isp16_type;        /* dependent on type of interface card */
  67 static u_char isp16_ctrl;
  68 static u_short isp16_enable_port;
  69
  70 static int isp16_cdrom_base = ISP16_CDROM_IO_BASE;
  71 static int isp16_cdrom_irq = ISP16_CDROM_IRQ;
  72 static int isp16_cdrom_dma = ISP16_CDROM_DMA;
  73 static char *isp16_cdrom_type = ISP16_CDROM_TYPE;
  74
  75 module_param(isp16_cdrom_base, int, 0);
  76 module_param(isp16_cdrom_irq, int, 0);
  77 module_param(isp16_cdrom_dma, int, 0);
  78 module_param(isp16_cdrom_type, charp, 0);
  79
  80 #define ISP16_IN(p) (outb(isp16_ctrl,ISP16_CTRL_PORT), inb(p))
  81 #define ISP16_OUT(p,b) (outb(isp16_ctrl,ISP16_CTRL_PORT), outb(b,p))
  82
  83 #ifndef MODULE
  84
  85 static int
  86 __init isp16_setup(char *str)
  87 {
  88         int ints[4];
  89
  90         (void) get_options(str, ARRAY_SIZE(ints), ints);
  91         if (ints[0] > 0)
  92                 isp16_cdrom_base = ints[1];
  93         if (ints[0] > 1)
  94                 isp16_cdrom_irq = ints[2];
  95         if (ints[0] > 2)
  96                 isp16_cdrom_dma = ints[3];
  97         if (str)
  98                 isp16_cdrom_type = str;
  99
 100         return 1;
 101 }
 102
 103 __setup("isp16=", isp16_setup);
 104
 105 #endif                          /* MODULE */
 106
 107 /*
 108  *  ISP16 initialisation.
 109  *
 110  */
 111 static int __init isp16_init(void)
 112 {
 113         u_char expected_drive;
 114
 115         printk(KERN_INFO
 116                "ISP16: configuration cdrom interface, version %d.%d.\n",
 117                ISP16_VERSION_MAJOR, ISP16_VERSION_MINOR);
 118
 119         if (!strcmp(isp16_cdrom_type, "noisp16")) {
 120                 printk("ISP16: no cdrom interface configured.\n");
 121                 return 0;
 122         }
 123
 124         if (!request_region(ISP16_IO_BASE, ISP16_IO_SIZE, "isp16")) {
 125                 printk("ISP16: i/o ports already in use.\n");
 126                 goto out;
 127         }
 128
 129         if ((isp16_type = isp16_detect()) < 0) {
 130                 printk("ISP16: no cdrom interface found.\n");
 131                 goto cleanup_out;
 132         }
 133
 134         printk(KERN_INFO
 135                "ISP16: cdrom interface (with OPTi 82C92%d chip) detected.\n",
 136                (isp16_type == 2) ? 9 : 8);
 137
 138         if (!strcmp(isp16_cdrom_type, "Sanyo"))
 139                 expected_drive =
 140                     (isp16_type ? ISP16_SANYO1 : ISP16_SANYO0);
 141         else if (!strcmp(isp16_cdrom_type, "Sony"))
 142                 expected_drive = ISP16_SONY;
 143         else if (!strcmp(isp16_cdrom_type, "Panasonic"))
 144                 expected_drive =
 145                     (isp16_type ? ISP16_PANASONIC1 : ISP16_PANASONIC0);
 146         else if (!strcmp(isp16_cdrom_type, "Mitsumi"))
 147                 expected_drive = ISP16_MITSUMI;
 148         else {
 149                 printk("ISP16: %s not supported by cdrom interface.\n",
 150                        isp16_cdrom_type);
 151                 goto cleanup_out;
 152         }
 153
 154         if (isp16_cdi_config(isp16_cdrom_base, expected_drive,
 155                              isp16_cdrom_irq, isp16_cdrom_dma) < 0) {
 156                 printk
 157                     ("ISP16: cdrom interface has not been properly configured.\n");
 158                 goto cleanup_out;
 159         }
 160         printk(KERN_INFO
 161                "ISP16: cdrom interface set up with io base 0x%03X, irq %d, dma %d,"
 162                " type %s.\n", isp16_cdrom_base, isp16_cdrom_irq,
 163                isp16_cdrom_dma, isp16_cdrom_type);
 164         return 0;
 165
 166 cleanup_out:
 167         release_region(ISP16_IO_BASE, ISP16_IO_SIZE);
 168 out:
 169         return -EIO;
 170 }
 171
 172 static short __init isp16_detect(void)
 173 {
 174
 175         if (isp16_c929__detect() >= 0)
 176                 return 2;
 177         else
 178                 return (isp16_c928__detect());
 179 }
 180
 181 static short __init isp16_c928__detect(void)
 182 {
 183         u_char ctrl;
 184         u_char enable_cdrom;
 185         u_char io;
 186         short i = -1;
 187
 188         isp16_ctrl = ISP16_C928__CTRL;
 189         isp16_enable_port = ISP16_C928__ENABLE_PORT;
 190
 191         /* read' and write' are a special read and write, respectively */
 192
 193         /* read' ISP16_CTRL_PORT, clear last two bits and write' back the result */
 194         ctrl = ISP16_IN(ISP16_CTRL_PORT) & 0xFC;
 195         ISP16_OUT(ISP16_CTRL_PORT, ctrl);
 196
 197         /* read' 3,4 and 5-bit from the cdrom enable port */
 198         enable_cdrom = ISP16_IN(ISP16_C928__ENABLE_PORT) & 0x38;
 199
 200         if (!(enable_cdrom & 0x20)) {   /* 5-bit not set */
 201                 /* read' last 2 bits of ISP16_IO_SET_PORT */
 202                 io = ISP16_IN(ISP16_IO_SET_PORT) & 0x03;
 203                 if (((io & 0x01) << 1) == (io & 0x02)) {        /* bits are the same */
 204                         if (io == 0) {  /* ...the same and 0 */
 205                                 i = 0;
 206                                 enable_cdrom |= 0x20;
 207                         } else {        /* ...the same and 1 *//* my card, first time 'round */
 208                                 i = 1;
 209                                 enable_cdrom |= 0x28;
 210                         }
 211                         ISP16_OUT(ISP16_C928__ENABLE_PORT, enable_cdrom);
 212                 } else {        /* bits are not the same */
 213                         ISP16_OUT(ISP16_CTRL_PORT, ctrl);
 214                         return i;       /* -> not detected: possibly incorrect conclusion */
 215                 }
 216         } else if (enable_cdrom == 0x20)
 217                 i = 0;
 218         else if (enable_cdrom == 0x28)  /* my card, already initialised */
 219                 i = 1;
 220
 221         ISP16_OUT(ISP16_CTRL_PORT, ctrl);
 222
 223         return i;
 224 }
 225
 226 static short __init isp16_c929__detect(void)
 227 {
 228         u_char ctrl;
 229         u_char tmp;
 230
 231         isp16_ctrl = ISP16_C929__CTRL;
 232         isp16_enable_port = ISP16_C929__ENABLE_PORT;
 233
 234         /* read' and write' are a special read and write, respectively */
 235
 236         /* read' ISP16_CTRL_PORT and save */
 237         ctrl = ISP16_IN(ISP16_CTRL_PORT);
 238
 239         /* write' zero to the ctrl port and get response */
 240         ISP16_OUT(ISP16_CTRL_PORT, 0);
 241         tmp = ISP16_IN(ISP16_CTRL_PORT);
 242
 243         if (tmp != 2)           /* isp16 with 82C929 not detected */
 244                 return -1;
 245
 246         /* restore ctrl port value */
 247         ISP16_OUT(ISP16_CTRL_PORT, ctrl);
 248
 249         return 2;
 250 }
 251
 252 static short __init
 253 isp16_cdi_config(int base, u_char drive_type, int irq, int dma)
 254 {
 255         u_char base_code;
 256         u_char irq_code;
 257         u_char dma_code;
 258         u_char i;
 259
 260         if ((drive_type == ISP16_MITSUMI) && (dma != 0))
 261                 printk("ISP16: Mitsumi cdrom drive has no dma support.\n");
 262
 263         switch (base) {
 264         case 0x340:
 265                 base_code = ISP16_BASE_340;
 266                 break;
 267         case 0x330:
 268                 base_code = ISP16_BASE_330;
 269                 break;
 270         case 0x360:
 271                 base_code = ISP16_BASE_360;
 272                 break;
 273         case 0x320:
 274                 base_code = ISP16_BASE_320;
 275                 break;
 276         default:
 277                 printk
 278                     ("ISP16: base address 0x%03X not supported by cdrom interface.\n",
 279                      base);
 280                 return -1;
 281         }
 282         switch (irq) {
 283         case 0:
 284                 irq_code = ISP16_IRQ_X;
 285                 break;          /* disable irq */
 286         case 5:
 287                 irq_code = ISP16_IRQ_5;
 288                 printk("ISP16: irq 5 shouldn't be used by cdrom interface,"
 289                        " due to possible conflicts with the sound card.\n");
 290                 break;
 291         case 7:
 292                 irq_code = ISP16_IRQ_7;
 293                 printk("ISP16: irq 7 shouldn't be used by cdrom interface,"
 294                        " due to possible conflicts with the sound card.\n");
 295                 break;
 296         case 3:
 297                 irq_code = ISP16_IRQ_3;
 298                 break;
 299         case 9:
 300                 irq_code = ISP16_IRQ_9;
 301                 break;
 302         case 10:
 303                 irq_code = ISP16_IRQ_10;
 304                 break;
 305         case 11:
 306                 irq_code = ISP16_IRQ_11;
 307                 break;
 308         default:
 309                 printk("ISP16: irq %d not supported by cdrom interface.\n",
 310                        irq);
 311                 return -1;
 312         }
 313         switch (dma) {
 314         case 0:
 315                 dma_code = ISP16_DMA_X;
 316                 break;          /* disable dma */
 317         case 1:
 318                 printk("ISP16: dma 1 cannot be used by cdrom interface,"
 319                        " due to conflict with the sound card.\n");
 320                 return -1;
 321                 break;
 322         case 3:
 323                 dma_code = ISP16_DMA_3;
 324                 break;
 325         case 5:
 326                 dma_code = ISP16_DMA_5;
 327                 break;
 328         case 6:
 329                 dma_code = ISP16_DMA_6;
 330                 break;
 331         case 7:
 332                 dma_code = ISP16_DMA_7;
 333                 break;
 334         default:
 335                 printk("ISP16: dma %d not supported by cdrom interface.\n",
 336                        dma);
 337                 return -1;
 338         }
 339
 340         if (drive_type != ISP16_SONY && drive_type != ISP16_PANASONIC0 &&
 341             drive_type != ISP16_PANASONIC1 && drive_type != ISP16_SANYO0 &&
 342             drive_type != ISP16_SANYO1 && drive_type != ISP16_MITSUMI &&
 343             drive_type != ISP16_DRIVE_X) {
 344                 printk
 345                     ("ISP16: drive type (code 0x%02X) not supported by cdrom"
 346                      " interface.\n", drive_type);
 347                 return -1;
 348         }
 349
 350         /* set type of interface */
 351         i = ISP16_IN(ISP16_DRIVE_SET_PORT) & ISP16_DRIVE_SET_MASK;      /* clear some bits */
 352         ISP16_OUT(ISP16_DRIVE_SET_PORT, i | drive_type);
 353
 354         /* enable cdrom on interface with 82C929 chip */
 355         if (isp16_type > 1)
 356                 ISP16_OUT(isp16_enable_port, ISP16_ENABLE_CDROM);
 357
 358         /* set base address, irq and dma */
 359         i = ISP16_IN(ISP16_IO_SET_PORT) & ISP16_IO_SET_MASK;    /* keep some bits */
 360         ISP16_OUT(ISP16_IO_SET_PORT, i | base_code | irq_code | dma_code);
 361
 362         return 0;
 363 }
 364
 365 static void __exit isp16_exit(void)
 366 {
 367         release_region(ISP16_IO_BASE, ISP16_IO_SIZE);
 368         printk(KERN_INFO "ISP16: module released.\n");
 369 }
 370
 371 module_init(isp16_init);
 372 module_exit(isp16_exit);
 373
 374 MODULE_LICENSE("GPL");