drivers/parport/init.c

   1 /* Parallel-port initialisation code.
   2  *
   3  * Authors: David Campbell <campbell@torque.net>
   4  *          Tim Waugh <tim@cyberelk.demon.co.uk>
   5  *          Jose Renau <renau@acm.org>
   6  *
   7  * based on work by Grant Guenther <grant@torque.net>
   8  *              and Philip Blundell <Philip.Blundell@pobox.com>
   9  */
  10
  11 #include <linux/config.h>
  12 #include <linux/module.h>
  13 #include <linux/threads.h>
  14
  15 #include <linux/parport.h>
  16 #include <linux/errno.h>
  17 #include <linux/kernel.h>
  18 #include <linux/malloc.h>
  19 #include <linux/init.h>
  20
  21 #ifndef MODULE
  22 static int io[PARPORT_MAX+1] __initdata = { [0 ... PARPORT_MAX] = 0 };
  23 static int io_hi[PARPORT_MAX+1] __initdata = { [0 ... PARPORT_MAX] = 0 };
  24 static int irq[PARPORT_MAX] __initdata = { [0 ... PARPORT_MAX-1] = PARPORT_IRQ_PROBEONLY };
  25 static int dma[PARPORT_MAX] __initdata = { [0 ... PARPORT_MAX-1] = PARPORT_DMA_NONE };
  26
  27 extern int parport_pc_init(int *io, int *io_hi, int *irq, int *dma);
  28 extern int parport_ax_init(void);
  29
  30 static int parport_setup_ptr __initdata = 0;
  31
  32 __initfunc(void parport_setup(char *str, int *ints))
  33 {
  34         if (ints[0] == 0) {
  35                 if (str && !strncmp(str, "auto", 4)) {
  36                         irq[0] = PARPORT_IRQ_AUTO;
  37                         dma[0] = PARPORT_DMA_AUTO;
  38                 }
  39                 else if (str)
  40                         printk (KERN_ERR "parport: `%s': huh?\n", str);
  41                 else
  42                         printk (KERN_ERR "parport: parport=.. what?\n");
  43
  44                 return;
  45         }
  46         else if (ints[1] == 0) {
  47                 /* Disable parport if "parport=0" in cmdline */
  48                 io[0] = PARPORT_DISABLE;
  49                 return;
  50         }
  51
  52         if (parport_setup_ptr < PARPORT_MAX) {
  53                 char *sep;
  54                 io[parport_setup_ptr] = ints[1];
  55                 irq[parport_setup_ptr] = PARPORT_IRQ_NONE;
  56                 dma[parport_setup_ptr] = PARPORT_DMA_NONE;
  57                 if (ints[0] > 1) {
  58                         irq[parport_setup_ptr] = ints[2];
  59                         if (ints[0] > 2) {
  60                                 dma[parport_setup_ptr] = ints[3];
  61                                 goto done;
  62                         }
  63
  64                         if (str == NULL)
  65                                 goto done;
  66
  67                         goto dma_from_str;
  68                 }
  69                 else if (str == NULL)
  70                         goto done;
  71                 else if (!strncmp(str, "auto", 4))
  72                         irq[parport_setup_ptr] = PARPORT_IRQ_AUTO;
  73                 else if (strncmp(str, "none", 4) != 0) {
  74                         printk(KERN_ERR "parport: bad irq `%s'\n", str);
  75                         return;
  76                 }
  77
  78                 if ((sep = strchr(str, ',')) == NULL) goto done;
  79                 str = sep+1;
  80         dma_from_str:
  81                 if (!strncmp(str, "auto", 4))
  82                         dma[parport_setup_ptr] = PARPORT_DMA_AUTO;
  83                 else if (strncmp(str, "none", 4) != 0) {
  84                         char *ep;
  85                         dma[parport_setup_ptr] = simple_strtoul(str, &ep, 0);
  86                         if (ep == str) {
  87                                 printk(KERN_ERR "parport: bad dma `%s'\n",
  88                                        str);
  89                                 return;
  90                         }
  91                 }
  92         done:
  93                 parport_setup_ptr++;
  94         } else
  95                 printk(KERN_ERR "parport=%s ignored, too many ports\n", str);
  96 }
  97 #endif
  98
  99 #ifdef MODULE
 100 int init_module(void)
 101 {
 102 #ifdef CONFIG_SYSCTL
 103         parport_default_proc_register ();
 104 #endif
 105         return 0;
 106 }
 107
 108 void cleanup_module(void)
 109 {
 110 #ifdef CONFIG_SYSCTL
 111         parport_default_proc_unregister ();
 112 #endif
 113 }
 114
 115 #else
 116
 117 __initfunc(int parport_init(void))
 118 {
 119         if (io[0] == PARPORT_DISABLE)
 120                 return 1;
 121
 122 #ifdef CONFIG_SYSCTL
 123         parport_default_proc_register ();
 124 #endif
 125
 126 #ifdef CONFIG_PARPORT_PC
 127         parport_pc_init(io, io_hi, irq, dma);
 128 #endif
 129 #ifdef CONFIG_PARPORT_AX
 130         parport_ax_init();
 131 #endif
 132 #ifdef CONFIG_PARPORT_AMIGA
 133         parport_amiga_init();
 134 #endif
 135 #ifdef CONFIG_PARPORT_MFC3
 136         parport_mfc3_init();
 137 #endif
 138 #ifdef CONFIG_PARPORT_ATARI
 139         parport_atari_init();
 140 #endif
 141 #ifdef CONFIG_PARPORT_ARC
 142         parport_arc_init();
 143 #endif
 144         return 0;
 145 }
 146 #endif
 147
 148 /* Exported symbols for modules. */
 149
 150 EXPORT_SYMBOL(parport_claim);
 151 EXPORT_SYMBOL(parport_claim_or_block);
 152 EXPORT_SYMBOL(parport_release);
 153 EXPORT_SYMBOL(parport_register_port);
 154 EXPORT_SYMBOL(parport_announce_port);
 155 EXPORT_SYMBOL(parport_unregister_port);
 156 EXPORT_SYMBOL(parport_register_driver);
 157 EXPORT_SYMBOL(parport_unregister_driver);
 158 EXPORT_SYMBOL(parport_register_device);
 159 EXPORT_SYMBOL(parport_unregister_device);
 160 EXPORT_SYMBOL(parport_enumerate);
 161 EXPORT_SYMBOL(parport_negotiate);
 162 EXPORT_SYMBOL(parport_write);
 163 EXPORT_SYMBOL(parport_read);
 164 EXPORT_SYMBOL(parport_ieee1284_wakeup);
 165 EXPORT_SYMBOL(parport_wait_peripheral);
 166 EXPORT_SYMBOL(parport_wait_event);
 167 EXPORT_SYMBOL(parport_set_timeout);
 168 EXPORT_SYMBOL(parport_ieee1284_interrupt);
 169 EXPORT_SYMBOL(parport_ieee1284_ecp_write_data);
 170 EXPORT_SYMBOL(parport_ieee1284_ecp_read_data);
 171 EXPORT_SYMBOL(parport_ieee1284_ecp_write_addr);
 172 EXPORT_SYMBOL(parport_ieee1284_write_compat);
 173 EXPORT_SYMBOL(parport_ieee1284_read_nibble);
 174 EXPORT_SYMBOL(parport_ieee1284_read_byte);
 175 EXPORT_SYMBOL(parport_ieee1284_epp_write_data);
 176 EXPORT_SYMBOL(parport_ieee1284_epp_read_data);
 177 EXPORT_SYMBOL(parport_ieee1284_epp_write_addr);
 178 EXPORT_SYMBOL(parport_ieee1284_epp_read_addr);
 179 EXPORT_SYMBOL(parport_proc_register);
 180 EXPORT_SYMBOL(parport_proc_unregister);
 181 EXPORT_SYMBOL(parport_device_proc_register);
 182 EXPORT_SYMBOL(parport_device_proc_unregister);
 183 EXPORT_SYMBOL(parport_default_proc_register);
 184 EXPORT_SYMBOL(parport_default_proc_unregister);
 185 EXPORT_SYMBOL(parport_parse_irqs);
 186 EXPORT_SYMBOL(parport_parse_dmas);
 187 #ifdef CONFIG_PARPORT_1284
 188 EXPORT_SYMBOL(parport_open);
 189 EXPORT_SYMBOL(parport_close);
 190 EXPORT_SYMBOL(parport_device_id);
 191 EXPORT_SYMBOL(parport_device_num);
 192 EXPORT_SYMBOL(parport_device_coords);
 193 EXPORT_SYMBOL(parport_daisy_deselect_all);
 194 EXPORT_SYMBOL(parport_daisy_select);
 195 EXPORT_SYMBOL(parport_daisy_init);
 196 #endif
 197
 198 void inc_parport_count(void)
 199 {
 200 #ifdef MODULE
 201         MOD_INC_USE_COUNT;
 202 #endif
 203 }
 204
 205 void dec_parport_count(void)
 206 {
 207 #ifdef MODULE
 208         MOD_DEC_USE_COUNT;
 209 #endif
 210 }