1 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2 Programming gameport drivers
3 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4
5 A basic classic gameport
6 ~~~~~~~~~~~~~~~~~~~~~~~~
7
8 If the gameport doesn't provide more than the
9 the code needed to register it with the joysti
10
11 struct gameport gameport;
12
13 gameport.io = MY_IO_ADDRESS;
14 gameport_register_port(&gameport);
15
16 Make sure struct gameport is initialized to 0
17 gameport generic code will take care of the re
18
19 If your hardware supports more than one io add
20 choose which one to program the hardware to, s
21 addresses is preferred, because the likelihood
22 0x201 address is smaller.
23
24 E.g. if your driver supports addresses 0x200,
25 0x218 would be the address of first choice.
26
27 If your hardware supports a gameport address t
28 space (is above 0x1000), use that one, and don
29
30 Also, always request_region() on the whole io
31 gameport. Although only one ioport is really u
32 occupies from one to sixteen addresses in the
33
34 Please also consider enabling the gameport on
35 callback if the io is mapped to ISA space - th
36 space only when something really is using it.
37 ->close() callback. You also can select the io
38 callback, so that it doesn't fail if some of t
39 already occupied by other gameports.
40
41 Memory mapped gameport
42 ~~~~~~~~~~~~~~~~~~~~~~
43
44 When a gameport can be accessed through MMIO,
45 it is faster, allowing more reads per second.
46 isn't as easy as a basic IO one, but not so mu
47
48 struct gameport gameport;
49
50 void my_trigger(struct gameport *gamep
51 {
52 my_mmio = 0xff;
53 }
54
55 unsigned char my_read(struct gameport
56 {
57 return my_mmio;
58 }
59
60 gameport.read = my_read;
61 gameport.trigger = my_trigger;
62 gameport_register_port(&gameport);
63
64 .. _gameport_pgm_cooked_mode:
65
66 Cooked mode gameport
67 ~~~~~~~~~~~~~~~~~~~~
68
69 There are gameports that can report the axis v
70 the driver doesn't have to measure them the ol
71 the gameport. To register a cooked gameport::
72
73 struct gameport gameport;
74
75 int my_cooked_read(struct gameport *ga
76 {
77 int i;
78
79 for (i = 0; i < 4; i++)
80 axes[i] = my_mmio[i];
81 buttons[0] = my_mmio[4];
82 }
83
84 int my_open(struct gameport *gameport,
85 {
86 return -(mode != GAMEPORT_MODE
87 }
88
89 gameport.cooked_read = my_cooked_read;
90 gameport.open = my_open;
91 gameport.fuzz = 8;
92 gameport_register_port(&gameport);
93
94 The only confusing thing here is the fuzz valu
95 experimentation, it is the amount of noise in
96 gameports can set this to zero, most common ha
97 See analog.c and input.c for handling of fuzz
98 the size of a gaussian filter window that is u
99 in the data.
100
101 More complex gameports
102 ~~~~~~~~~~~~~~~~~~~~~~
103
104 Gameports can support both raw and cooked mode
105 examples 1+2 or 1+3. Gameports can support int
106 and also lightning.c and analog.c on how that
107 more than one gameport instance simultaneously
108 the gameport struct to point to your data.
109
110 Unregistering a gameport
111 ~~~~~~~~~~~~~~~~~~~~~~~~
112
113 Simple::
114
115 gameport_unregister_port(&gameport);
116
117 The gameport structure
118 ~~~~~~~~~~~~~~~~~~~~~~
119
120 ::
121
122 struct gameport {
123
124 void *port_data;
125
126 A private pointer for free use in the gameport
127 driver!)
128
129 ::
130
131 char name[32];
132
133 Driver's name as set by driver calling gamepor
134 purpose only.
135
136 ::
137
138 char phys[32];
139
140 gameport's physical name/description as set by
141 Informational purpose only.
142
143 ::
144
145 int io;
146
147 I/O address for use with raw mode. You have to
148 to some value if your gameport supports raw mo
149
150 ::
151
152 int speed;
153
154 Raw mode speed of the gameport reads in thousa
155
156 ::
157
158 int fuzz;
159
160 If the gameport supports cooked mode, this sho
161 represents the amount of noise in the data. Se
162 :ref:`gameport_pgm_cooked_mode`.
163
164 ::
165
166 void (*trigger)(struct gameport *);
167
168 Trigger. This function should trigger the ns55
169 outb(0xff, io) will be used.
170
171 ::
172
173 unsigned char (*read)(struct gameport
174
175 Read the buttons and ns558 oneshot bits. If se
176 used instead.
177
178 ::
179
180 int (*cooked_read)(struct gameport *,
181
182 If the gameport supports cooked mode, it shoul
183 read function. It should fill axes[0..3] with
184 and buttons[0] with four bits representing the
185
186 ::
187
188 int (*calibrate)(struct gameport *, in
189
190 Function for calibrating the ADC hardware. Whe
191 pre-filled by cooked data by the caller, max[0
192 expected maximums for each axis. The calibrate
193 sensitivity of the ADC hardware so that the ma
194 recompute the axes[] values to match the new s
195 the hardware so that they give valid values.
196
197 ::
198
199 int (*open)(struct gameport *, int mod
200
201 Open() serves two purposes. First a driver eit
202 in cooked mode, the open() callback can decide
203 Second, resource allocation can happen here. T
204 here. Prior to this call, other fields of the
205 member) need not to be valid.
206
207 ::
208
209 void (*close)(struct gameport *);
210
211 Close() should free the resources allocated by
212 gameport.
213
214 ::
215
216 struct timer_list poll_timer;
217 unsigned int poll_interval; /* in
218 spinlock_t timer_lock;
219 unsigned int poll_cnt;
220 void (*poll_handler)(struct gameport *
221 struct gameport *parent, *child;
222 struct gameport_driver *drv;
223 struct mutex drv_mutex; /* pro
224 struct device dev;
225 struct list_head node;
226
227 For internal use by the gameport layer.
228
229 ::
230
231 };
232
233 Enjoy!
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.