Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Copyright (c) 1999-2001 Vojtech Pavlik
0004  *
0005  *  Based on the work of:
0006  *  Andree Borrmann     Mats Sjövall
0007  */
0008 
0009 /*
0010  * Atari, Amstrad, Commodore, Amiga, Sega, etc. joystick driver for Linux
0011  */
0012 
0013 /*
0014  */
0015 
0016 #include <linux/kernel.h>
0017 #include <linux/module.h>
0018 #include <linux/delay.h>
0019 #include <linux/init.h>
0020 #include <linux/parport.h>
0021 #include <linux/input.h>
0022 #include <linux/mutex.h>
0023 #include <linux/slab.h>
0024 
0025 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
0026 MODULE_DESCRIPTION("Atari, Amstrad, Commodore, Amiga, Sega, etc. joystick driver");
0027 MODULE_LICENSE("GPL");
0028 
0029 struct db9_config {
0030     int args[2];
0031     unsigned int nargs;
0032 };
0033 
0034 #define DB9_MAX_PORTS       3
0035 static struct db9_config db9_cfg[DB9_MAX_PORTS];
0036 
0037 module_param_array_named(dev, db9_cfg[0].args, int, &db9_cfg[0].nargs, 0);
0038 MODULE_PARM_DESC(dev, "Describes first attached device (<parport#>,<type>)");
0039 module_param_array_named(dev2, db9_cfg[1].args, int, &db9_cfg[1].nargs, 0);
0040 MODULE_PARM_DESC(dev2, "Describes second attached device (<parport#>,<type>)");
0041 module_param_array_named(dev3, db9_cfg[2].args, int, &db9_cfg[2].nargs, 0);
0042 MODULE_PARM_DESC(dev3, "Describes third attached device (<parport#>,<type>)");
0043 
0044 #define DB9_ARG_PARPORT     0
0045 #define DB9_ARG_MODE        1
0046 
0047 #define DB9_MULTI_STICK     0x01
0048 #define DB9_MULTI2_STICK    0x02
0049 #define DB9_GENESIS_PAD     0x03
0050 #define DB9_GENESIS5_PAD    0x05
0051 #define DB9_GENESIS6_PAD    0x06
0052 #define DB9_SATURN_PAD      0x07
0053 #define DB9_MULTI_0802      0x08
0054 #define DB9_MULTI_0802_2    0x09
0055 #define DB9_CD32_PAD        0x0A
0056 #define DB9_SATURN_DPP      0x0B
0057 #define DB9_SATURN_DPP_2    0x0C
0058 #define DB9_MAX_PAD     0x0D
0059 
0060 #define DB9_UP          0x01
0061 #define DB9_DOWN        0x02
0062 #define DB9_LEFT        0x04
0063 #define DB9_RIGHT       0x08
0064 #define DB9_FIRE1       0x10
0065 #define DB9_FIRE2       0x20
0066 #define DB9_FIRE3       0x40
0067 #define DB9_FIRE4       0x80
0068 
0069 #define DB9_NORMAL      0x0a
0070 #define DB9_NOSELECT        0x08
0071 
0072 #define DB9_GENESIS6_DELAY  14
0073 #define DB9_REFRESH_TIME    HZ/100
0074 
0075 #define DB9_MAX_DEVICES     2
0076 
0077 struct db9_mode_data {
0078     const char *name;
0079     const short *buttons;
0080     int n_buttons;
0081     int n_pads;
0082     int n_axis;
0083     int bidirectional;
0084     int reverse;
0085 };
0086 
0087 struct db9 {
0088     struct input_dev *dev[DB9_MAX_DEVICES];
0089     struct timer_list timer;
0090     struct pardevice *pd;
0091     int mode;
0092     int used;
0093     int parportno;
0094     struct mutex mutex;
0095     char phys[DB9_MAX_DEVICES][32];
0096 };
0097 
0098 static struct db9 *db9_base[3];
0099 
0100 static const short db9_multi_btn[] = { BTN_TRIGGER, BTN_THUMB };
0101 static const short db9_genesis_btn[] = { BTN_START, BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_MODE };
0102 static const short db9_cd32_btn[] = { BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_TL, BTN_TR, BTN_START };
0103 static const short db9_abs[] = { ABS_X, ABS_Y, ABS_RX, ABS_RY, ABS_RZ, ABS_Z, ABS_HAT0X, ABS_HAT0Y, ABS_HAT1X, ABS_HAT1Y };
0104 
0105 static const struct db9_mode_data db9_modes[] = {
0106     { NULL,                  NULL,        0,  0,  0,  0,  0 },
0107     { "Multisystem joystick",        db9_multi_btn,   1,  1,  2,  1,  1 },
0108     { "Multisystem joystick (2 fire)",   db9_multi_btn,   2,  1,  2,  1,  1 },
0109     { "Genesis pad",             db9_genesis_btn, 4,  1,  2,  1,  1 },
0110     { NULL,                  NULL,        0,  0,  0,  0,  0 },
0111     { "Genesis 5 pad",           db9_genesis_btn, 6,  1,  2,  1,  1 },
0112     { "Genesis 6 pad",           db9_genesis_btn, 8,  1,  2,  1,  1 },
0113     { "Saturn pad",              db9_cd32_btn,    9,  6,  7,  0,  1 },
0114     { "Multisystem (0.8.0.2) joystick",  db9_multi_btn,   1,  1,  2,  1,  1 },
0115     { "Multisystem (0.8.0.2-dual) joystick", db9_multi_btn,   1,  2,  2,  1,  1 },
0116     { "Amiga CD-32 pad",             db9_cd32_btn,    7,  1,  2,  1,  1 },
0117     { "Saturn dpp",              db9_cd32_btn,    9,  6,  7,  0,  0 },
0118     { "Saturn dpp dual",             db9_cd32_btn,    9,  12, 7,  0,  0 },
0119 };
0120 
0121 /*
0122  * Saturn controllers
0123  */
0124 #define DB9_SATURN_DELAY 300
0125 static const int db9_saturn_byte[] = { 1, 1, 1, 2, 2, 2, 2, 2, 1 };
0126 static const unsigned char db9_saturn_mask[] = { 0x04, 0x01, 0x02, 0x40, 0x20, 0x10, 0x08, 0x80, 0x08 };
0127 
0128 /*
0129  * db9_saturn_write_sub() writes 2 bit data.
0130  */
0131 static void db9_saturn_write_sub(struct parport *port, int type, unsigned char data, int powered, int pwr_sub)
0132 {
0133     unsigned char c;
0134 
0135     switch (type) {
0136     case 1: /* DPP1 */
0137         c = 0x80 | 0x30 | (powered ? 0x08 : 0) | (pwr_sub ? 0x04 : 0) | data;
0138         parport_write_data(port, c);
0139         break;
0140     case 2: /* DPP2 */
0141         c = 0x40 | data << 4 | (powered ? 0x08 : 0) | (pwr_sub ? 0x04 : 0) | 0x03;
0142         parport_write_data(port, c);
0143         break;
0144     case 0: /* DB9 */
0145         c = ((((data & 2) ? 2 : 0) | ((data & 1) ? 4 : 0)) ^ 0x02) | !powered;
0146         parport_write_control(port, c);
0147         break;
0148     }
0149 }
0150 
0151 /*
0152  * gc_saturn_read_sub() reads 4 bit data.
0153  */
0154 static unsigned char db9_saturn_read_sub(struct parport *port, int type)
0155 {
0156     unsigned char data;
0157 
0158     if (type) {
0159         /* DPP */
0160         data = parport_read_status(port) ^ 0x80;
0161         return (data & 0x80 ? 1 : 0) | (data & 0x40 ? 2 : 0)
0162              | (data & 0x20 ? 4 : 0) | (data & 0x10 ? 8 : 0);
0163     } else {
0164         /* DB9 */
0165         data = parport_read_data(port) & 0x0f;
0166         return (data & 0x8 ? 1 : 0) | (data & 0x4 ? 2 : 0)
0167              | (data & 0x2 ? 4 : 0) | (data & 0x1 ? 8 : 0);
0168     }
0169 }
0170 
0171 /*
0172  * db9_saturn_read_analog() sends clock and reads 8 bit data.
0173  */
0174 static unsigned char db9_saturn_read_analog(struct parport *port, int type, int powered)
0175 {
0176     unsigned char data;
0177 
0178     db9_saturn_write_sub(port, type, 0, powered, 0);
0179     udelay(DB9_SATURN_DELAY);
0180     data = db9_saturn_read_sub(port, type) << 4;
0181     db9_saturn_write_sub(port, type, 2, powered, 0);
0182     udelay(DB9_SATURN_DELAY);
0183     data |= db9_saturn_read_sub(port, type);
0184     return data;
0185 }
0186 
0187 /*
0188  * db9_saturn_read_packet() reads whole saturn packet at connector
0189  * and returns device identifier code.
0190  */
0191 static unsigned char db9_saturn_read_packet(struct parport *port, unsigned char *data, int type, int powered)
0192 {
0193     int i, j;
0194     unsigned char tmp;
0195 
0196     db9_saturn_write_sub(port, type, 3, powered, 0);
0197     data[0] = db9_saturn_read_sub(port, type);
0198     switch (data[0] & 0x0f) {
0199     case 0xf:
0200         /* 1111  no pad */
0201         return data[0] = 0xff;
0202     case 0x4: case 0x4 | 0x8:
0203         /* ?100 : digital controller */
0204         db9_saturn_write_sub(port, type, 0, powered, 1);
0205         data[2] = db9_saturn_read_sub(port, type) << 4;
0206         db9_saturn_write_sub(port, type, 2, powered, 1);
0207         data[1] = db9_saturn_read_sub(port, type) << 4;
0208         db9_saturn_write_sub(port, type, 1, powered, 1);
0209         data[1] |= db9_saturn_read_sub(port, type);
0210         db9_saturn_write_sub(port, type, 3, powered, 1);
0211         /* data[2] |= db9_saturn_read_sub(port, type); */
0212         data[2] |= data[0];
0213         return data[0] = 0x02;
0214     case 0x1:
0215         /* 0001 : analog controller or multitap */
0216         db9_saturn_write_sub(port, type, 2, powered, 0);
0217         udelay(DB9_SATURN_DELAY);
0218         data[0] = db9_saturn_read_analog(port, type, powered);
0219         if (data[0] != 0x41) {
0220             /* read analog controller */
0221             for (i = 0; i < (data[0] & 0x0f); i++)
0222                 data[i + 1] = db9_saturn_read_analog(port, type, powered);
0223             db9_saturn_write_sub(port, type, 3, powered, 0);
0224             return data[0];
0225         } else {
0226             /* read multitap */
0227             if (db9_saturn_read_analog(port, type, powered) != 0x60)
0228                 return data[0] = 0xff;
0229             for (i = 0; i < 60; i += 10) {
0230                 data[i] = db9_saturn_read_analog(port, type, powered);
0231                 if (data[i] != 0xff)
0232                     /* read each pad */
0233                     for (j = 0; j < (data[i] & 0x0f); j++)
0234                         data[i + j + 1] = db9_saturn_read_analog(port, type, powered);
0235             }
0236             db9_saturn_write_sub(port, type, 3, powered, 0);
0237             return 0x41;
0238         }
0239     case 0x0:
0240         /* 0000 : mouse */
0241         db9_saturn_write_sub(port, type, 2, powered, 0);
0242         udelay(DB9_SATURN_DELAY);
0243         tmp = db9_saturn_read_analog(port, type, powered);
0244         if (tmp == 0xff) {
0245             for (i = 0; i < 3; i++)
0246                 data[i + 1] = db9_saturn_read_analog(port, type, powered);
0247             db9_saturn_write_sub(port, type, 3, powered, 0);
0248             return data[0] = 0xe3;
0249         }
0250         fallthrough;
0251     default:
0252         return data[0];
0253     }
0254 }
0255 
0256 /*
0257  * db9_saturn_report() analyzes packet and reports.
0258  */
0259 static int db9_saturn_report(unsigned char id, unsigned char data[60], struct input_dev *devs[], int n, int max_pads)
0260 {
0261     struct input_dev *dev;
0262     int tmp, i, j;
0263 
0264     tmp = (id == 0x41) ? 60 : 10;
0265     for (j = 0; j < tmp && n < max_pads; j += 10, n++) {
0266         dev = devs[n];
0267         switch (data[j]) {
0268         case 0x16: /* multi controller (analog 4 axis) */
0269             input_report_abs(dev, db9_abs[5], data[j + 6]);
0270             fallthrough;
0271         case 0x15: /* mission stick (analog 3 axis) */
0272             input_report_abs(dev, db9_abs[3], data[j + 4]);
0273             input_report_abs(dev, db9_abs[4], data[j + 5]);
0274             fallthrough;
0275         case 0x13: /* racing controller (analog 1 axis) */
0276             input_report_abs(dev, db9_abs[2], data[j + 3]);
0277             fallthrough;
0278         case 0x34: /* saturn keyboard (udlr ZXC ASD QE Esc) */
0279         case 0x02: /* digital pad (digital 2 axis + buttons) */
0280             input_report_abs(dev, db9_abs[0], !(data[j + 1] & 128) - !(data[j + 1] & 64));
0281             input_report_abs(dev, db9_abs[1], !(data[j + 1] & 32) - !(data[j + 1] & 16));
0282             for (i = 0; i < 9; i++)
0283                 input_report_key(dev, db9_cd32_btn[i], ~data[j + db9_saturn_byte[i]] & db9_saturn_mask[i]);
0284             break;
0285         case 0x19: /* mission stick x2 (analog 6 axis + buttons) */
0286             input_report_abs(dev, db9_abs[0], !(data[j + 1] & 128) - !(data[j + 1] & 64));
0287             input_report_abs(dev, db9_abs[1], !(data[j + 1] & 32) - !(data[j + 1] & 16));
0288             for (i = 0; i < 9; i++)
0289                 input_report_key(dev, db9_cd32_btn[i], ~data[j + db9_saturn_byte[i]] & db9_saturn_mask[i]);
0290             input_report_abs(dev, db9_abs[2], data[j + 3]);
0291             input_report_abs(dev, db9_abs[3], data[j + 4]);
0292             input_report_abs(dev, db9_abs[4], data[j + 5]);
0293             /*
0294             input_report_abs(dev, db9_abs[8], (data[j + 6] & 128 ? 0 : 1) - (data[j + 6] & 64 ? 0 : 1));
0295             input_report_abs(dev, db9_abs[9], (data[j + 6] & 32 ? 0 : 1) - (data[j + 6] & 16 ? 0 : 1));
0296             */
0297             input_report_abs(dev, db9_abs[6], data[j + 7]);
0298             input_report_abs(dev, db9_abs[7], data[j + 8]);
0299             input_report_abs(dev, db9_abs[5], data[j + 9]);
0300             break;
0301         case 0xd3: /* sankyo ff (analog 1 axis + stop btn) */
0302             input_report_key(dev, BTN_A, data[j + 3] & 0x80);
0303             input_report_abs(dev, db9_abs[2], data[j + 3] & 0x7f);
0304             break;
0305         case 0xe3: /* shuttle mouse (analog 2 axis + buttons. signed value) */
0306             input_report_key(dev, BTN_START, data[j + 1] & 0x08);
0307             input_report_key(dev, BTN_A, data[j + 1] & 0x04);
0308             input_report_key(dev, BTN_C, data[j + 1] & 0x02);
0309             input_report_key(dev, BTN_B, data[j + 1] & 0x01);
0310             input_report_abs(dev, db9_abs[2], data[j + 2] ^ 0x80);
0311             input_report_abs(dev, db9_abs[3], (0xff-(data[j + 3] ^ 0x80))+1); /* */
0312             break;
0313         case 0xff:
0314         default: /* no pad */
0315             input_report_abs(dev, db9_abs[0], 0);
0316             input_report_abs(dev, db9_abs[1], 0);
0317             for (i = 0; i < 9; i++)
0318                 input_report_key(dev, db9_cd32_btn[i], 0);
0319             break;
0320         }
0321     }
0322     return n;
0323 }
0324 
0325 static int db9_saturn(int mode, struct parport *port, struct input_dev *devs[])
0326 {
0327     unsigned char id, data[60];
0328     int type, n, max_pads;
0329     int tmp, i;
0330 
0331     switch (mode) {
0332     case DB9_SATURN_PAD:
0333         type = 0;
0334         n = 1;
0335         break;
0336     case DB9_SATURN_DPP:
0337         type = 1;
0338         n = 1;
0339         break;
0340     case DB9_SATURN_DPP_2:
0341         type = 1;
0342         n = 2;
0343         break;
0344     default:
0345         return -1;
0346     }
0347     max_pads = min(db9_modes[mode].n_pads, DB9_MAX_DEVICES);
0348     for (tmp = 0, i = 0; i < n; i++) {
0349         id = db9_saturn_read_packet(port, data, type + i, 1);
0350         tmp = db9_saturn_report(id, data, devs, tmp, max_pads);
0351     }
0352     return 0;
0353 }
0354 
0355 static void db9_timer(struct timer_list *t)
0356 {
0357     struct db9 *db9 = from_timer(db9, t, timer);
0358     struct parport *port = db9->pd->port;
0359     struct input_dev *dev = db9->dev[0];
0360     struct input_dev *dev2 = db9->dev[1];
0361     int data, i;
0362 
0363     switch (db9->mode) {
0364         case DB9_MULTI_0802_2:
0365 
0366             data = parport_read_data(port) >> 3;
0367 
0368             input_report_abs(dev2, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1));
0369             input_report_abs(dev2, ABS_Y, (data & DB9_DOWN  ? 0 : 1) - (data & DB9_UP   ? 0 : 1));
0370             input_report_key(dev2, BTN_TRIGGER, ~data & DB9_FIRE1);
0371             fallthrough;
0372 
0373         case DB9_MULTI_0802:
0374 
0375             data = parport_read_status(port) >> 3;
0376 
0377             input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1));
0378             input_report_abs(dev, ABS_Y, (data & DB9_DOWN  ? 0 : 1) - (data & DB9_UP   ? 0 : 1));
0379             input_report_key(dev, BTN_TRIGGER, data & DB9_FIRE1);
0380             break;
0381 
0382         case DB9_MULTI_STICK:
0383 
0384             data = parport_read_data(port);
0385 
0386             input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1));
0387             input_report_abs(dev, ABS_Y, (data & DB9_DOWN  ? 0 : 1) - (data & DB9_UP   ? 0 : 1));
0388             input_report_key(dev, BTN_TRIGGER, ~data & DB9_FIRE1);
0389             break;
0390 
0391         case DB9_MULTI2_STICK:
0392 
0393             data = parport_read_data(port);
0394 
0395             input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1));
0396             input_report_abs(dev, ABS_Y, (data & DB9_DOWN  ? 0 : 1) - (data & DB9_UP   ? 0 : 1));
0397             input_report_key(dev, BTN_TRIGGER, ~data & DB9_FIRE1);
0398             input_report_key(dev, BTN_THUMB,   ~data & DB9_FIRE2);
0399             break;
0400 
0401         case DB9_GENESIS_PAD:
0402 
0403             parport_write_control(port, DB9_NOSELECT);
0404             data = parport_read_data(port);
0405 
0406             input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1));
0407             input_report_abs(dev, ABS_Y, (data & DB9_DOWN  ? 0 : 1) - (data & DB9_UP   ? 0 : 1));
0408             input_report_key(dev, BTN_B, ~data & DB9_FIRE1);
0409             input_report_key(dev, BTN_C, ~data & DB9_FIRE2);
0410 
0411             parport_write_control(port, DB9_NORMAL);
0412             data = parport_read_data(port);
0413 
0414             input_report_key(dev, BTN_A,     ~data & DB9_FIRE1);
0415             input_report_key(dev, BTN_START, ~data & DB9_FIRE2);
0416             break;
0417 
0418         case DB9_GENESIS5_PAD:
0419 
0420             parport_write_control(port, DB9_NOSELECT);
0421             data = parport_read_data(port);
0422 
0423             input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1));
0424             input_report_abs(dev, ABS_Y, (data & DB9_DOWN  ? 0 : 1) - (data & DB9_UP   ? 0 : 1));
0425             input_report_key(dev, BTN_B, ~data & DB9_FIRE1);
0426             input_report_key(dev, BTN_C, ~data & DB9_FIRE2);
0427 
0428             parport_write_control(port, DB9_NORMAL);
0429             data = parport_read_data(port);
0430 
0431             input_report_key(dev, BTN_A,     ~data & DB9_FIRE1);
0432             input_report_key(dev, BTN_X,     ~data & DB9_FIRE2);
0433             input_report_key(dev, BTN_Y,     ~data & DB9_LEFT);
0434             input_report_key(dev, BTN_START, ~data & DB9_RIGHT);
0435             break;
0436 
0437         case DB9_GENESIS6_PAD:
0438 
0439             parport_write_control(port, DB9_NOSELECT); /* 1 */
0440             udelay(DB9_GENESIS6_DELAY);
0441             data = parport_read_data(port);
0442 
0443             input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1));
0444             input_report_abs(dev, ABS_Y, (data & DB9_DOWN  ? 0 : 1) - (data & DB9_UP   ? 0 : 1));
0445             input_report_key(dev, BTN_B, ~data & DB9_FIRE1);
0446             input_report_key(dev, BTN_C, ~data & DB9_FIRE2);
0447 
0448             parport_write_control(port, DB9_NORMAL);
0449             udelay(DB9_GENESIS6_DELAY);
0450             data = parport_read_data(port);
0451 
0452             input_report_key(dev, BTN_A, ~data & DB9_FIRE1);
0453             input_report_key(dev, BTN_START, ~data & DB9_FIRE2);
0454 
0455             parport_write_control(port, DB9_NOSELECT); /* 2 */
0456             udelay(DB9_GENESIS6_DELAY);
0457             parport_write_control(port, DB9_NORMAL);
0458             udelay(DB9_GENESIS6_DELAY);
0459             parport_write_control(port, DB9_NOSELECT); /* 3 */
0460             udelay(DB9_GENESIS6_DELAY);
0461             data=parport_read_data(port);
0462 
0463             input_report_key(dev, BTN_X,    ~data & DB9_LEFT);
0464             input_report_key(dev, BTN_Y,    ~data & DB9_DOWN);
0465             input_report_key(dev, BTN_Z,    ~data & DB9_UP);
0466             input_report_key(dev, BTN_MODE, ~data & DB9_RIGHT);
0467 
0468             parport_write_control(port, DB9_NORMAL);
0469             udelay(DB9_GENESIS6_DELAY);
0470             parport_write_control(port, DB9_NOSELECT); /* 4 */
0471             udelay(DB9_GENESIS6_DELAY);
0472             parport_write_control(port, DB9_NORMAL);
0473             break;
0474 
0475         case DB9_SATURN_PAD:
0476         case DB9_SATURN_DPP:
0477         case DB9_SATURN_DPP_2:
0478 
0479             db9_saturn(db9->mode, port, db9->dev);
0480             break;
0481 
0482         case DB9_CD32_PAD:
0483 
0484             data = parport_read_data(port);
0485 
0486             input_report_abs(dev, ABS_X, (data & DB9_RIGHT ? 0 : 1) - (data & DB9_LEFT ? 0 : 1));
0487             input_report_abs(dev, ABS_Y, (data & DB9_DOWN  ? 0 : 1) - (data & DB9_UP   ? 0 : 1));
0488 
0489             parport_write_control(port, 0x0a);
0490 
0491             for (i = 0; i < 7; i++) {
0492                 data = parport_read_data(port);
0493                 parport_write_control(port, 0x02);
0494                 parport_write_control(port, 0x0a);
0495                 input_report_key(dev, db9_cd32_btn[i], ~data & DB9_FIRE2);
0496             }
0497 
0498             parport_write_control(port, 0x00);
0499             break;
0500         }
0501 
0502     input_sync(dev);
0503 
0504     mod_timer(&db9->timer, jiffies + DB9_REFRESH_TIME);
0505 }
0506 
0507 static int db9_open(struct input_dev *dev)
0508 {
0509     struct db9 *db9 = input_get_drvdata(dev);
0510     struct parport *port = db9->pd->port;
0511     int err;
0512 
0513     err = mutex_lock_interruptible(&db9->mutex);
0514     if (err)
0515         return err;
0516 
0517     if (!db9->used++) {
0518         parport_claim(db9->pd);
0519         parport_write_data(port, 0xff);
0520         if (db9_modes[db9->mode].reverse) {
0521             parport_data_reverse(port);
0522             parport_write_control(port, DB9_NORMAL);
0523         }
0524         mod_timer(&db9->timer, jiffies + DB9_REFRESH_TIME);
0525     }
0526 
0527     mutex_unlock(&db9->mutex);
0528     return 0;
0529 }
0530 
0531 static void db9_close(struct input_dev *dev)
0532 {
0533     struct db9 *db9 = input_get_drvdata(dev);
0534     struct parport *port = db9->pd->port;
0535 
0536     mutex_lock(&db9->mutex);
0537     if (!--db9->used) {
0538         del_timer_sync(&db9->timer);
0539         parport_write_control(port, 0x00);
0540         parport_data_forward(port);
0541         parport_release(db9->pd);
0542     }
0543     mutex_unlock(&db9->mutex);
0544 }
0545 
0546 static void db9_attach(struct parport *pp)
0547 {
0548     struct db9 *db9;
0549     const struct db9_mode_data *db9_mode;
0550     struct pardevice *pd;
0551     struct input_dev *input_dev;
0552     int i, j, port_idx;
0553     int mode;
0554     struct pardev_cb db9_parport_cb;
0555 
0556     for (port_idx = 0; port_idx < DB9_MAX_PORTS; port_idx++) {
0557         if (db9_cfg[port_idx].nargs == 0 ||
0558             db9_cfg[port_idx].args[DB9_ARG_PARPORT] < 0)
0559             continue;
0560 
0561         if (db9_cfg[port_idx].args[DB9_ARG_PARPORT] == pp->number)
0562             break;
0563     }
0564 
0565     if (port_idx == DB9_MAX_PORTS) {
0566         pr_debug("Not using parport%d.\n", pp->number);
0567         return;
0568     }
0569 
0570     mode = db9_cfg[port_idx].args[DB9_ARG_MODE];
0571 
0572     if (mode < 1 || mode >= DB9_MAX_PAD || !db9_modes[mode].n_buttons) {
0573         printk(KERN_ERR "db9.c: Bad device type %d\n", mode);
0574         return;
0575     }
0576 
0577     db9_mode = &db9_modes[mode];
0578 
0579     if (db9_mode->bidirectional && !(pp->modes & PARPORT_MODE_TRISTATE)) {
0580         printk(KERN_ERR "db9.c: specified parport is not bidirectional\n");
0581         return;
0582     }
0583 
0584     memset(&db9_parport_cb, 0, sizeof(db9_parport_cb));
0585     db9_parport_cb.flags = PARPORT_FLAG_EXCL;
0586 
0587     pd = parport_register_dev_model(pp, "db9", &db9_parport_cb, port_idx);
0588     if (!pd) {
0589         printk(KERN_ERR "db9.c: parport busy already - lp.o loaded?\n");
0590         return;
0591     }
0592 
0593     db9 = kzalloc(sizeof(struct db9), GFP_KERNEL);
0594     if (!db9)
0595         goto err_unreg_pardev;
0596 
0597     mutex_init(&db9->mutex);
0598     db9->pd = pd;
0599     db9->mode = mode;
0600     db9->parportno = pp->number;
0601     timer_setup(&db9->timer, db9_timer, 0);
0602 
0603     for (i = 0; i < (min(db9_mode->n_pads, DB9_MAX_DEVICES)); i++) {
0604 
0605         db9->dev[i] = input_dev = input_allocate_device();
0606         if (!input_dev) {
0607             printk(KERN_ERR "db9.c: Not enough memory for input device\n");
0608             goto err_unreg_devs;
0609         }
0610 
0611         snprintf(db9->phys[i], sizeof(db9->phys[i]),
0612              "%s/input%d", db9->pd->port->name, i);
0613 
0614         input_dev->name = db9_mode->name;
0615         input_dev->phys = db9->phys[i];
0616         input_dev->id.bustype = BUS_PARPORT;
0617         input_dev->id.vendor = 0x0002;
0618         input_dev->id.product = mode;
0619         input_dev->id.version = 0x0100;
0620 
0621         input_set_drvdata(input_dev, db9);
0622 
0623         input_dev->open = db9_open;
0624         input_dev->close = db9_close;
0625 
0626         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
0627         for (j = 0; j < db9_mode->n_buttons; j++)
0628             set_bit(db9_mode->buttons[j], input_dev->keybit);
0629         for (j = 0; j < db9_mode->n_axis; j++) {
0630             if (j < 2)
0631                 input_set_abs_params(input_dev, db9_abs[j], -1, 1, 0, 0);
0632             else
0633                 input_set_abs_params(input_dev, db9_abs[j], 1, 255, 0, 0);
0634         }
0635 
0636         if (input_register_device(input_dev))
0637             goto err_free_dev;
0638     }
0639 
0640     db9_base[port_idx] = db9;
0641     return;
0642 
0643  err_free_dev:
0644     input_free_device(db9->dev[i]);
0645  err_unreg_devs:
0646     while (--i >= 0)
0647         input_unregister_device(db9->dev[i]);
0648     kfree(db9);
0649  err_unreg_pardev:
0650     parport_unregister_device(pd);
0651 }
0652 
0653 static void db9_detach(struct parport *port)
0654 {
0655     int i;
0656     struct db9 *db9;
0657 
0658     for (i = 0; i < DB9_MAX_PORTS; i++) {
0659         if (db9_base[i] && db9_base[i]->parportno == port->number)
0660             break;
0661     }
0662 
0663     if (i == DB9_MAX_PORTS)
0664         return;
0665 
0666     db9 = db9_base[i];
0667     db9_base[i] = NULL;
0668 
0669     for (i = 0; i < min(db9_modes[db9->mode].n_pads, DB9_MAX_DEVICES); i++)
0670         input_unregister_device(db9->dev[i]);
0671     parport_unregister_device(db9->pd);
0672     kfree(db9);
0673 }
0674 
0675 static struct parport_driver db9_parport_driver = {
0676     .name = "db9",
0677     .match_port = db9_attach,
0678     .detach = db9_detach,
0679     .devmodel = true,
0680 };
0681 
0682 static int __init db9_init(void)
0683 {
0684     int i;
0685     int have_dev = 0;
0686 
0687     for (i = 0; i < DB9_MAX_PORTS; i++) {
0688         if (db9_cfg[i].nargs == 0 || db9_cfg[i].args[DB9_ARG_PARPORT] < 0)
0689             continue;
0690 
0691         if (db9_cfg[i].nargs < 2) {
0692             printk(KERN_ERR "db9.c: Device type must be specified.\n");
0693             return -EINVAL;
0694         }
0695 
0696         have_dev = 1;
0697     }
0698 
0699     if (!have_dev)
0700         return -ENODEV;
0701 
0702     return parport_register_driver(&db9_parport_driver);
0703 }
0704 
0705 static void __exit db9_exit(void)
0706 {
0707     parport_unregister_driver(&db9_parport_driver);
0708 }
0709 
0710 module_init(db9_init);
0711 module_exit(db9_exit);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!