fix some issues and warnings seen on ctr build
[pcsx_rearmed.git] / plugins / dfinput / pad.c
1 /*
2  * Copyright (c) 2009, Wei Mingzhi <whistler@openoffice.org>.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, see <http://www.gnu.org/licenses>.
17  *
18  * this is only pure emulation code to handle analogs,
19  * extracted from dfinput.
20  */
21
22 #include <stdint.h>
23
24 #include "psemu_plugin_defs.h"
25 #include "main.h"
26
27 enum {
28         ANALOG_LEFT = 0,
29         ANALOG_RIGHT,
30
31         ANALOG_TOTAL
32 };
33
34 enum {
35         CMD_READ_DATA_AND_VIBRATE = 0x42,
36         CMD_CONFIG_MODE = 0x43,
37         CMD_SET_MODE_AND_LOCK = 0x44,
38         CMD_QUERY_MODEL_AND_MODE = 0x45,
39         CMD_QUERY_ACT = 0x46, // ??
40         CMD_QUERY_COMB = 0x47, // ??
41         CMD_QUERY_MODE = 0x4C, // QUERY_MODE ??
42         CMD_VIBRATION_TOGGLE = 0x4D,
43 };
44
45 #ifndef HAVE_LIBRETRO
46 static struct {
47         uint8_t PadMode;
48         uint8_t PadID;
49         uint8_t ConfigMode;
50         PadDataS pad;
51 } padstate[2];
52
53 static uint8_t stdpar[2][8] = {
54         {0xFF, 0x5A, 0xFF, 0xFF, 0x80, 0x80, 0x80, 0x80},
55         {0xFF, 0x5A, 0xFF, 0xFF, 0x80, 0x80, 0x80, 0x80}
56 };
57
58 static uint8_t unk46[2][8] = {
59         {0xFF, 0x5A, 0x00, 0x00, 0x01, 0x02, 0x00, 0x0A},
60         {0xFF, 0x5A, 0x00, 0x00, 0x01, 0x02, 0x00, 0x0A}
61 };
62
63 static uint8_t unk47[2][8] = {
64         {0xFF, 0x5A, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00},
65         {0xFF, 0x5A, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00}
66 };
67
68 static uint8_t unk4c[2][8] = {
69         {0xFF, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
70         {0xFF, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
71 };
72
73 static uint8_t unk4d[2][8] = { 
74         {0xFF, 0x5A, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
75         {0xFF, 0x5A, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
76 };
77
78 static uint8_t stdcfg[2][8]   = { 
79         {0xFF, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
80         {0xFF, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
81 };
82
83 static uint8_t stdmode[2][8]  = { 
84         {0xFF, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
85         {0xFF, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
86 };
87
88 static uint8_t stdmodel[2][8] = { 
89         {0xFF,
90          0x5A,
91          0x01, // 03 - dualshock2, 01 - dualshock
92          0x02, // number of modes
93          0x01, // current mode: 01 - analog, 00 - digital
94          0x02,
95          0x01,
96          0x00},
97         {0xFF, 
98          0x5A,
99          0x01, // 03 - dualshock2, 01 - dualshock
100          0x02, // number of modes
101          0x01, // current mode: 01 - analog, 00 - digital
102          0x02,
103          0x01,
104          0x00}
105 };
106
107 static uint8_t *buf;
108
109 static uint8_t do_cmd(void)
110 {
111         PadDataS *pad = &padstate[CurPad].pad;
112         int pad_num = CurPad;
113
114         CmdLen = 8;
115         switch (CurCmd) {
116                 case CMD_SET_MODE_AND_LOCK:
117                         buf = stdmode[pad_num];
118                         return 0xF3;
119
120                 case CMD_QUERY_MODEL_AND_MODE:
121                         buf = stdmodel[pad_num];
122                         buf[4] = padstate[pad_num].PadMode;
123                         return 0xF3;
124
125                 case CMD_QUERY_ACT:
126                         buf = unk46[pad_num];
127                         return 0xF3;
128
129                 case CMD_QUERY_COMB:
130                         buf = unk47[pad_num];
131                         return 0xF3;
132
133                 case CMD_QUERY_MODE:
134                         buf = unk4c[pad_num];
135                         return 0xF3;
136
137                 case CMD_VIBRATION_TOGGLE:
138                         buf = unk4d[pad_num];
139                         return 0xF3;
140
141                 case CMD_CONFIG_MODE:
142                         if (padstate[pad_num].ConfigMode) {
143                                 buf = stdcfg[pad_num];
144                                 return 0xF3;
145                         }
146                         // else FALLTHROUGH
147
148                 case CMD_READ_DATA_AND_VIBRATE:
149                 default:
150                         buf = stdpar[pad_num];
151
152                         buf[2] = pad->buttonStatus;
153                         buf[3] = pad->buttonStatus >> 8;
154
155                         if (padstate[pad_num].PadMode == 1) {
156                                 buf[4] = pad->rightJoyX;
157                                 buf[5] = pad->rightJoyY;
158                                 buf[6] = pad->leftJoyX;
159                                 buf[7] = pad->leftJoyY;
160                         } else {
161                                 CmdLen = 4;
162                         }
163
164                         return padstate[pad_num].PadID;
165         }
166 }
167
168 static void do_cmd2(unsigned char value)
169 {
170         switch (CurCmd) {
171                 case CMD_CONFIG_MODE:
172                         padstate[CurPad].ConfigMode = value;
173                         break;
174
175                 case CMD_SET_MODE_AND_LOCK:
176                         padstate[CurPad].PadMode = value;
177                         padstate[CurPad].PadID = value ? 0x73 : 0x41;
178                         break;
179
180                 case CMD_QUERY_ACT:
181                         switch (value) {
182                                 case 0: // default
183                                         buf[5] = 0x02;
184                                         buf[6] = 0x00;
185                                         buf[7] = 0x0A;
186                                         break;
187
188                                 case 1: // Param std conf change
189                                         buf[5] = 0x01;
190                                         buf[6] = 0x01;
191                                         buf[7] = 0x14;
192                                         break;
193                         }
194                         break;
195
196                 case CMD_QUERY_MODE:
197                         switch (value) {
198                                 case 0: // mode 0 - digital mode
199                                         buf[5] = PSE_PAD_TYPE_STANDARD;
200                                         break;
201
202                                 case 1: // mode 1 - analog mode
203                                         buf[5] = PSE_PAD_TYPE_ANALOGPAD;
204                                         break;
205                         }
206                         break;
207         }
208 }
209
210 static void do_vibration(unsigned char value)
211 {
212     int changed = 0;
213     int i;
214
215     switch (CurCmd) {
216         case CMD_READ_DATA_AND_VIBRATE:
217             for (i = 0; i < 2; i++) {
218                 if (padstate[CurPad].pad.Vib[i] == CurByte
219                      && padstate[CurPad].pad.VibF[i] != value) {
220                     padstate[CurPad].pad.VibF[i] = value;
221                     changed = 1;
222                 }
223             }
224
225             if (!in_enable_vibration || !changed)
226                 break;
227
228             plat_trigger_vibrate(CurPad,
229                                  padstate[CurPad].pad.VibF[0],
230                                  padstate[CurPad].pad.VibF[1]);
231             break;
232         case CMD_VIBRATION_TOGGLE:
233             for (i = 0; i < 2; i++) {
234                 if (padstate[CurPad].pad.Vib[i] == CurByte)
235                     buf[CurByte] = 0;
236             }
237             if (value < 2) {
238                 padstate[CurPad].pad.Vib[value] = CurByte;
239                 if((padstate[CurPad].PadID & 0x0f) < (CurByte - 1) / 2) {
240                     padstate[CurPad].PadID = (padstate[CurPad].PadID & 0xf0) + (CurByte - 1) / 2;
241                 }
242             }
243             break;
244     }
245 }
246 #endif
247
248 #if 0
249 #include <stdio.h>
250 unsigned char PADpoll_(unsigned char value);
251 unsigned char PADpoll(unsigned char value) {
252         unsigned char b = CurByte, r = PADpoll_(value);
253         printf("poll[%d] %02x %02x\n", b, value, r);
254         return r;
255 }
256 #define PADpoll PADpoll_
257 #endif
258
259 #ifndef HAVE_LIBRETRO
260 unsigned char PADpoll_pad(unsigned char value) {
261         if (CurByte == 0) {
262                 CurCmd = value;
263                 CurByte++;
264
265                 // Don't enable Analog/Vibration for a standard pad
266                 if (padstate[CurPad].pad.controllerType != PSE_PAD_TYPE_ANALOGPAD)
267                         CurCmd = CMD_READ_DATA_AND_VIBRATE;
268
269                 return do_cmd();
270         }
271
272         if (CurByte >= CmdLen)
273                 return 0xff;    // verified
274
275         if (CurByte == 2)
276                 do_cmd2(value);
277
278         if (padstate[CurPad].pad.controllerType == PSE_PAD_TYPE_ANALOGPAD)
279                 do_vibration(value);
280
281         return buf[CurByte++];
282 }
283
284 unsigned char PADstartPoll_pad(int pad) {
285         CurPad = pad - 1;
286         CurByte = 0;
287
288         if (pad == 1)
289                 PAD1_readPort1(&padstate[0].pad);
290         else
291                 PAD2_readPort2(&padstate[1].pad);
292
293         return 0xFF;
294 }
295
296 void pad_init(void)
297 {
298         int i;
299
300         PAD1_readPort1(&padstate[0].pad);
301         PAD2_readPort2(&padstate[1].pad);
302
303         for (i = 0; i < 2; i++) {
304                 padstate[i].PadID = padstate[i].pad.controllerType == PSE_PAD_TYPE_ANALOGPAD ? 0x73 : 0x41;
305                 padstate[i].PadMode = padstate[i].pad.controllerType == PSE_PAD_TYPE_ANALOGPAD;
306         }
307 }
308 #endif