block/paride/paride.c

0001 /*
0002         paride.c  (c) 1997-8  Grant R. Guenther <grant@torque.net>
0003                               Under the terms of the GNU General Public License.
0004
0005     This is the base module for the family of device drivers
0006         that support parallel port IDE devices.
0007
0008 */
0009
0010 /* Changes:
0011
0012     1.01    GRG 1998.05.03  Use spinlocks
0013     1.02    GRG 1998.05.05  init_proto, release_proto, ktti
0014     1.03    GRG 1998.08.15  eliminate compiler warning
0015     1.04    GRG 1998.11.28  added support for FRIQ
0016     1.05    TMW 2000.06.06  use parport_find_number instead of
0017                 parport_enumerate
0018     1.06    TMW 2001.03.26  more sane parport-or-not resource management
0019 */
0020
0021 #define PI_VERSION      "1.06"
0022
0023 #include <linux/module.h>
0024 #include <linux/kmod.h>
0025 #include <linux/types.h>
0026 #include <linux/kernel.h>
0027 #include <linux/ioport.h>
0028 #include <linux/string.h>
0029 #include <linux/spinlock.h>
0030 #include <linux/wait.h>
0031 #include <linux/sched.h>    /* TASK_* */
0032 #include <linux/parport.h>
0033 #include <linux/slab.h>
0034
0035 #include "paride.h"
0036
0037 MODULE_LICENSE("GPL");
0038
0039 #define MAX_PROTOS  32
0040
0041 static struct pi_protocol *protocols[MAX_PROTOS];
0042
0043 static DEFINE_SPINLOCK(pi_spinlock);
0044
0045 void pi_write_regr(PIA * pi, int cont, int regr, int val)
0046 {
0047     pi->proto->write_regr(pi, cont, regr, val);
0048 }
0049
0050 EXPORT_SYMBOL(pi_write_regr);
0051
0052 int pi_read_regr(PIA * pi, int cont, int regr)
0053 {
0054     return pi->proto->read_regr(pi, cont, regr);
0055 }
0056
0057 EXPORT_SYMBOL(pi_read_regr);
0058
0059 void pi_write_block(PIA * pi, char *buf, int count)
0060 {
0061     pi->proto->write_block(pi, buf, count);
0062 }
0063
0064 EXPORT_SYMBOL(pi_write_block);
0065
0066 void pi_read_block(PIA * pi, char *buf, int count)
0067 {
0068     pi->proto->read_block(pi, buf, count);
0069 }
0070
0071 EXPORT_SYMBOL(pi_read_block);
0072
0073 static void pi_wake_up(void *p)
0074 {
0075     PIA *pi = (PIA *) p;
0076     unsigned long flags;
0077     void (*cont) (void) = NULL;
0078
0079     spin_lock_irqsave(&pi_spinlock, flags);
0080
0081     if (pi->claim_cont && !parport_claim(pi->pardev)) {
0082         cont = pi->claim_cont;
0083         pi->claim_cont = NULL;
0084         pi->claimed = 1;
0085     }
0086
0087     spin_unlock_irqrestore(&pi_spinlock, flags);
0088
0089     wake_up(&(pi->parq));
0090
0091     if (cont)
0092         cont();
0093 }
0094
0095 int pi_schedule_claimed(PIA * pi, void (*cont) (void))
0096 {
0097     unsigned long flags;
0098
0099     spin_lock_irqsave(&pi_spinlock, flags);
0100     if (pi->pardev && parport_claim(pi->pardev)) {
0101         pi->claim_cont = cont;
0102         spin_unlock_irqrestore(&pi_spinlock, flags);
0103         return 0;
0104     }
0105     pi->claimed = 1;
0106     spin_unlock_irqrestore(&pi_spinlock, flags);
0107     return 1;
0108 }
0109 EXPORT_SYMBOL(pi_schedule_claimed);
0110
0111 void pi_do_claimed(PIA * pi, void (*cont) (void))
0112 {
0113     if (pi_schedule_claimed(pi, cont))
0114         cont();
0115 }
0116
0117 EXPORT_SYMBOL(pi_do_claimed);
0118
0119 static void pi_claim(PIA * pi)
0120 {
0121     if (pi->claimed)
0122         return;
0123     pi->claimed = 1;
0124     if (pi->pardev)
0125         wait_event(pi->parq,
0126                !parport_claim((struct pardevice *) pi->pardev));
0127 }
0128
0129 static void pi_unclaim(PIA * pi)
0130 {
0131     pi->claimed = 0;
0132     if (pi->pardev)
0133         parport_release((struct pardevice *) (pi->pardev));
0134 }
0135
0136 void pi_connect(PIA * pi)
0137 {
0138     pi_claim(pi);
0139     pi->proto->connect(pi);
0140 }
0141
0142 EXPORT_SYMBOL(pi_connect);
0143
0144 void pi_disconnect(PIA * pi)
0145 {
0146     pi->proto->disconnect(pi);
0147     pi_unclaim(pi);
0148 }
0149
0150 EXPORT_SYMBOL(pi_disconnect);
0151
0152 static void pi_unregister_parport(PIA * pi)
0153 {
0154     if (pi->pardev) {
0155         parport_unregister_device((struct pardevice *) (pi->pardev));
0156         pi->pardev = NULL;
0157     }
0158 }
0159
0160 void pi_release(PIA * pi)
0161 {
0162     pi_unregister_parport(pi);
0163     if (pi->proto->release_proto)
0164         pi->proto->release_proto(pi);
0165     module_put(pi->proto->owner);
0166 }
0167
0168 EXPORT_SYMBOL(pi_release);
0169
0170 static int default_test_proto(PIA * pi, char *scratch, int verbose)
0171 {
0172     int j, k;
0173     int e[2] = { 0, 0 };
0174
0175     pi->proto->connect(pi);
0176
0177     for (j = 0; j < 2; j++) {
0178         pi_write_regr(pi, 0, 6, 0xa0 + j * 0x10);
0179         for (k = 0; k < 256; k++) {
0180             pi_write_regr(pi, 0, 2, k ^ 0xaa);
0181             pi_write_regr(pi, 0, 3, k ^ 0x55);
0182             if (pi_read_regr(pi, 0, 2) != (k ^ 0xaa))
0183                 e[j]++;
0184         }
0185     }
0186     pi->proto->disconnect(pi);
0187
0188     if (verbose)
0189         printk("%s: %s: port 0x%x, mode  %d, test=(%d,%d)\n",
0190                pi->device, pi->proto->name, pi->port,
0191                pi->mode, e[0], e[1]);
0192
0193     return (e[0] && e[1]);  /* not here if both > 0 */
0194 }
0195
0196 static int pi_test_proto(PIA * pi, char *scratch, int verbose)
0197 {
0198     int res;
0199
0200     pi_claim(pi);
0201     if (pi->proto->test_proto)
0202         res = pi->proto->test_proto(pi, scratch, verbose);
0203     else
0204         res = default_test_proto(pi, scratch, verbose);
0205     pi_unclaim(pi);
0206
0207     return res;
0208 }
0209
0210 int paride_register(PIP * pr)
0211 {
0212     int k;
0213
0214     for (k = 0; k < MAX_PROTOS; k++)
0215         if (protocols[k] && !strcmp(pr->name, protocols[k]->name)) {
0216             printk("paride: %s protocol already registered\n",
0217                    pr->name);
0218             return -1;
0219         }
0220     k = 0;
0221     while ((k < MAX_PROTOS) && (protocols[k]))
0222         k++;
0223     if (k == MAX_PROTOS) {
0224         printk("paride: protocol table full\n");
0225         return -1;
0226     }
0227     protocols[k] = pr;
0228     pr->index = k;
0229     printk("paride: %s registered as protocol %d\n", pr->name, k);
0230     return 0;
0231 }
0232
0233 EXPORT_SYMBOL(paride_register);
0234
0235 void paride_unregister(PIP * pr)
0236 {
0237     if (!pr)
0238         return;
0239     if (protocols[pr->index] != pr) {
0240         printk("paride: %s not registered\n", pr->name);
0241         return;
0242     }
0243     protocols[pr->index] = NULL;
0244 }
0245
0246 EXPORT_SYMBOL(paride_unregister);
0247
0248 static int pi_register_parport(PIA *pi, int verbose, int unit)
0249 {
0250     struct parport *port;
0251     struct pardev_cb par_cb;
0252
0253     port = parport_find_base(pi->port);
0254     if (!port)
0255         return 0;
0256     memset(&par_cb, 0, sizeof(par_cb));
0257     par_cb.wakeup = pi_wake_up;
0258     par_cb.private = (void *)pi;
0259     pi->pardev = parport_register_dev_model(port, pi->device, &par_cb,
0260                         unit);
0261     parport_put_port(port);
0262     if (!pi->pardev)
0263         return 0;
0264
0265     init_waitqueue_head(&pi->parq);
0266
0267     if (verbose)
0268         printk("%s: 0x%x is %s\n", pi->device, pi->port, port->name);
0269
0270     pi->parname = (char *) port->name;
0271
0272     return 1;
0273 }
0274
0275 static int pi_probe_mode(PIA * pi, int max, char *scratch, int verbose)
0276 {
0277     int best, range;
0278
0279     if (pi->mode != -1) {
0280         if (pi->mode >= max)
0281             return 0;
0282         range = 3;
0283         if (pi->mode >= pi->proto->epp_first)
0284             range = 8;
0285         if ((range == 8) && (pi->port % 8))
0286             return 0;
0287         pi->reserved = range;
0288         return (!pi_test_proto(pi, scratch, verbose));
0289     }
0290     best = -1;
0291     for (pi->mode = 0; pi->mode < max; pi->mode++) {
0292         range = 3;
0293         if (pi->mode >= pi->proto->epp_first)
0294             range = 8;
0295         if ((range == 8) && (pi->port % 8))
0296             break;
0297         pi->reserved = range;
0298         if (!pi_test_proto(pi, scratch, verbose))
0299             best = pi->mode;
0300     }
0301     pi->mode = best;
0302     return (best > -1);
0303 }
0304
0305 static int pi_probe_unit(PIA * pi, int unit, char *scratch, int verbose)
0306 {
0307     int max, s, e;
0308
0309     s = unit;
0310     e = s + 1;
0311
0312     if (s == -1) {
0313         s = 0;
0314         e = pi->proto->max_units;
0315     }
0316
0317     if (!pi_register_parport(pi, verbose, s))
0318         return 0;
0319
0320     if (pi->proto->test_port) {
0321         pi_claim(pi);
0322         max = pi->proto->test_port(pi);
0323         pi_unclaim(pi);
0324     } else
0325         max = pi->proto->max_mode;
0326
0327     if (pi->proto->probe_unit) {
0328         pi_claim(pi);
0329         for (pi->unit = s; pi->unit < e; pi->unit++)
0330             if (pi->proto->probe_unit(pi)) {
0331                 pi_unclaim(pi);
0332                 if (pi_probe_mode(pi, max, scratch, verbose))
0333                     return 1;
0334                 pi_unregister_parport(pi);
0335                 return 0;
0336             }
0337         pi_unclaim(pi);
0338         pi_unregister_parport(pi);
0339         return 0;
0340     }
0341
0342     if (!pi_probe_mode(pi, max, scratch, verbose)) {
0343         pi_unregister_parport(pi);
0344         return 0;
0345     }
0346     return 1;
0347
0348 }
0349
0350 int pi_init(PIA * pi, int autoprobe, int port, int mode,
0351     int unit, int protocol, int delay, char *scratch,
0352     int devtype, int verbose, char *device)
0353 {
0354     int p, k, s, e;
0355     int lpts[7] = { 0x3bc, 0x378, 0x278, 0x268, 0x27c, 0x26c, 0 };
0356
0357     s = protocol;
0358     e = s + 1;
0359
0360     if (!protocols[0])
0361         request_module("paride_protocol");
0362
0363     if (autoprobe) {
0364         s = 0;
0365         e = MAX_PROTOS;
0366     } else if ((s < 0) || (s >= MAX_PROTOS) || (port <= 0) ||
0367            (!protocols[s]) || (unit < 0) ||
0368            (unit >= protocols[s]->max_units)) {
0369         printk("%s: Invalid parameters\n", device);
0370         return 0;
0371     }
0372
0373     for (p = s; p < e; p++) {
0374         struct pi_protocol *proto = protocols[p];
0375         if (!proto)
0376             continue;
0377         /* still racy */
0378         if (!try_module_get(proto->owner))
0379             continue;
0380         pi->proto = proto;
0381         pi->private = 0;
0382         if (proto->init_proto && proto->init_proto(pi) < 0) {
0383             pi->proto = NULL;
0384             module_put(proto->owner);
0385             continue;
0386         }
0387         if (delay == -1)
0388             pi->delay = pi->proto->default_delay;
0389         else
0390             pi->delay = delay;
0391         pi->devtype = devtype;
0392         pi->device = device;
0393
0394         pi->parname = NULL;
0395         pi->pardev = NULL;
0396         init_waitqueue_head(&pi->parq);
0397         pi->claimed = 0;
0398         pi->claim_cont = NULL;
0399
0400         pi->mode = mode;
0401         if (port != -1) {
0402             pi->port = port;
0403             if (pi_probe_unit(pi, unit, scratch, verbose))
0404                 break;
0405             pi->port = 0;
0406         } else {
0407             k = 0;
0408             while ((pi->port = lpts[k++]))
0409                 if (pi_probe_unit
0410                     (pi, unit, scratch, verbose))
0411                     break;
0412             if (pi->port)
0413                 break;
0414         }
0415         if (pi->proto->release_proto)
0416             pi->proto->release_proto(pi);
0417         module_put(proto->owner);
0418     }
0419
0420     if (!pi->port) {
0421         if (autoprobe)
0422             printk("%s: Autoprobe failed\n", device);
0423         else
0424             printk("%s: Adapter not found\n", device);
0425         return 0;
0426     }
0427
0428     if (pi->parname)
0429         printk("%s: Sharing %s at 0x%x\n", pi->device,
0430                pi->parname, pi->port);
0431
0432     pi->proto->log_adapter(pi, scratch, verbose);
0433
0434     return 1;
0435 }
0436
0437 EXPORT_SYMBOL(pi_init);
0438
0439 static int pi_probe(struct pardevice *par_dev)
0440 {
0441     struct device_driver *drv = par_dev->dev.driver;
0442     int len = strlen(drv->name);
0443
0444     if (strncmp(par_dev->name, drv->name, len))
0445         return -ENODEV;
0446
0447     return 0;
0448 }
0449
0450 void *pi_register_driver(char *name)
0451 {
0452     struct parport_driver *parp_drv;
0453     int ret;
0454
0455     parp_drv = kzalloc(sizeof(*parp_drv), GFP_KERNEL);
0456     if (!parp_drv)
0457         return NULL;
0458
0459     parp_drv->name = name;
0460     parp_drv->probe = pi_probe;
0461     parp_drv->devmodel = true;
0462
0463     ret = parport_register_driver(parp_drv);
0464     if (ret) {
0465         kfree(parp_drv);
0466         return NULL;
0467     }
0468     return (void *)parp_drv;
0469 }
0470 EXPORT_SYMBOL(pi_register_driver);
0471
0472 void pi_unregister_driver(void *_drv)
0473 {
0474     struct parport_driver *drv = _drv;
0475
0476     parport_unregister_driver(drv);
0477     kfree(drv);
0478 }
0479 EXPORT_SYMBOL(pi_unregister_driver);