Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
8949d2aa | 2 | * dscore.c |
1da177e4 | 3 | * |
a8018766 | 4 | * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net> |
8949d2aa | 5 | * |
1da177e4 LT |
6 | * |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with this program; if not, write to the Free Software | |
19 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
20 | */ | |
21 | ||
22 | #include <linux/module.h> | |
23 | #include <linux/kernel.h> | |
24 | #include <linux/mod_devicetable.h> | |
25 | #include <linux/usb.h> | |
5a0e3ad6 | 26 | #include <linux/slab.h> |
1da177e4 | 27 | |
81f6075e EP |
28 | #include "../w1_int.h" |
29 | #include "../w1.h" | |
30 | ||
31 | /* COMMAND TYPE CODES */ | |
32 | #define CONTROL_CMD 0x00 | |
33 | #define COMM_CMD 0x01 | |
34 | #define MODE_CMD 0x02 | |
35 | ||
36 | /* CONTROL COMMAND CODES */ | |
37 | #define CTL_RESET_DEVICE 0x0000 | |
38 | #define CTL_START_EXE 0x0001 | |
39 | #define CTL_RESUME_EXE 0x0002 | |
40 | #define CTL_HALT_EXE_IDLE 0x0003 | |
41 | #define CTL_HALT_EXE_DONE 0x0004 | |
42 | #define CTL_FLUSH_COMM_CMDS 0x0007 | |
43 | #define CTL_FLUSH_RCV_BUFFER 0x0008 | |
44 | #define CTL_FLUSH_XMT_BUFFER 0x0009 | |
45 | #define CTL_GET_COMM_CMDS 0x000A | |
46 | ||
47 | /* MODE COMMAND CODES */ | |
48 | #define MOD_PULSE_EN 0x0000 | |
49 | #define MOD_SPEED_CHANGE_EN 0x0001 | |
50 | #define MOD_1WIRE_SPEED 0x0002 | |
51 | #define MOD_STRONG_PU_DURATION 0x0003 | |
52 | #define MOD_PULLDOWN_SLEWRATE 0x0004 | |
53 | #define MOD_PROG_PULSE_DURATION 0x0005 | |
54 | #define MOD_WRITE1_LOWTIME 0x0006 | |
55 | #define MOD_DSOW0_TREC 0x0007 | |
56 | ||
57 | /* COMMUNICATION COMMAND CODES */ | |
58 | #define COMM_ERROR_ESCAPE 0x0601 | |
59 | #define COMM_SET_DURATION 0x0012 | |
60 | #define COMM_BIT_IO 0x0020 | |
61 | #define COMM_PULSE 0x0030 | |
62 | #define COMM_1_WIRE_RESET 0x0042 | |
63 | #define COMM_BYTE_IO 0x0052 | |
64 | #define COMM_MATCH_ACCESS 0x0064 | |
65 | #define COMM_BLOCK_IO 0x0074 | |
66 | #define COMM_READ_STRAIGHT 0x0080 | |
67 | #define COMM_DO_RELEASE 0x6092 | |
68 | #define COMM_SET_PATH 0x00A2 | |
69 | #define COMM_WRITE_SRAM_PAGE 0x00B2 | |
70 | #define COMM_WRITE_EPROM 0x00C4 | |
71 | #define COMM_READ_CRC_PROT_PAGE 0x00D4 | |
72 | #define COMM_READ_REDIRECT_PAGE_CRC 0x21E4 | |
73 | #define COMM_SEARCH_ACCESS 0x00F4 | |
74 | ||
75 | /* Communication command bits */ | |
76 | #define COMM_TYPE 0x0008 | |
77 | #define COMM_SE 0x0008 | |
78 | #define COMM_D 0x0008 | |
79 | #define COMM_Z 0x0008 | |
80 | #define COMM_CH 0x0008 | |
81 | #define COMM_SM 0x0008 | |
82 | #define COMM_R 0x0008 | |
83 | #define COMM_IM 0x0001 | |
84 | ||
85 | #define COMM_PS 0x4000 | |
86 | #define COMM_PST 0x4000 | |
87 | #define COMM_CIB 0x4000 | |
88 | #define COMM_RTS 0x4000 | |
89 | #define COMM_DT 0x2000 | |
90 | #define COMM_SPU 0x1000 | |
91 | #define COMM_F 0x0800 | |
19e7184f | 92 | #define COMM_NTF 0x0400 |
81f6075e EP |
93 | #define COMM_ICP 0x0200 |
94 | #define COMM_RST 0x0100 | |
95 | ||
96 | #define PULSE_PROG 0x01 | |
97 | #define PULSE_SPUE 0x02 | |
98 | ||
99 | #define BRANCH_MAIN 0xCC | |
100 | #define BRANCH_AUX 0x33 | |
101 | ||
81f6075e EP |
102 | /* Status flags */ |
103 | #define ST_SPUA 0x01 /* Strong Pull-up is active */ | |
104 | #define ST_PRGA 0x02 /* 12V programming pulse is being generated */ | |
105 | #define ST_12VP 0x04 /* external 12V programming voltage is present */ | |
106 | #define ST_PMOD 0x08 /* DS2490 powered from USB and external sources */ | |
107 | #define ST_HALT 0x10 /* DS2490 is currently halted */ | |
108 | #define ST_IDLE 0x20 /* DS2490 is currently idle */ | |
109 | #define ST_EPOF 0x80 | |
110 | ||
4b9cf1bc DF |
111 | /* Result Register flags */ |
112 | #define RR_DETECT 0xA5 /* New device detected */ | |
113 | #define RR_NRS 0x01 /* Reset no presence or ... */ | |
114 | #define RR_SH 0x02 /* short on reset or set path */ | |
115 | #define RR_APP 0x04 /* alarming presence on reset */ | |
116 | #define RR_VPP 0x08 /* 12V expected not seen */ | |
117 | #define RR_CMP 0x10 /* compare error */ | |
118 | #define RR_CRC 0x20 /* CRC error detected */ | |
119 | #define RR_RDP 0x40 /* redirected page */ | |
120 | #define RR_EOS 0x80 /* end of search error */ | |
121 | ||
81f6075e EP |
122 | #define SPEED_NORMAL 0x00 |
123 | #define SPEED_FLEXIBLE 0x01 | |
124 | #define SPEED_OVERDRIVE 0x02 | |
125 | ||
126 | #define NUM_EP 4 | |
127 | #define EP_CONTROL 0 | |
128 | #define EP_STATUS 1 | |
129 | #define EP_DATA_OUT 2 | |
130 | #define EP_DATA_IN 3 | |
131 | ||
132 | struct ds_device | |
133 | { | |
134 | struct list_head ds_entry; | |
135 | ||
136 | struct usb_device *udev; | |
137 | struct usb_interface *intf; | |
138 | ||
139 | int ep[NUM_EP]; | |
140 | ||
1f4ec2d7 DF |
141 | /* Strong PullUp |
142 | * 0: pullup not active, else duration in milliseconds | |
143 | */ | |
144 | int spu_sleep; | |
ade6d810 DF |
145 | /* spu_bit contains COMM_SPU or 0 depending on if the strong pullup |
146 | * should be active or not for writes. | |
147 | */ | |
148 | u16 spu_bit; | |
1f4ec2d7 | 149 | |
81f6075e EP |
150 | struct w1_bus_master master; |
151 | }; | |
152 | ||
153 | struct ds_status | |
154 | { | |
155 | u8 enable; | |
156 | u8 speed; | |
157 | u8 pullup_dur; | |
158 | u8 ppuls_dur; | |
159 | u8 pulldown_slew; | |
160 | u8 write1_time; | |
161 | u8 write0_time; | |
162 | u8 reserved0; | |
163 | u8 status; | |
164 | u8 command0; | |
165 | u8 command1; | |
166 | u8 command_buffer_status; | |
167 | u8 data_out_buffer_status; | |
168 | u8 data_in_buffer_status; | |
169 | u8 reserved1; | |
170 | u8 reserved2; | |
171 | ||
172 | }; | |
1da177e4 LT |
173 | |
174 | static struct usb_device_id ds_id_table [] = { | |
175 | { USB_DEVICE(0x04fa, 0x2490) }, | |
176 | { }, | |
177 | }; | |
178 | MODULE_DEVICE_TABLE(usb, ds_id_table); | |
179 | ||
8949d2aa EP |
180 | static int ds_probe(struct usb_interface *, const struct usb_device_id *); |
181 | static void ds_disconnect(struct usb_interface *); | |
1da177e4 | 182 | |
1da177e4 | 183 | static int ds_send_control(struct ds_device *, u16, u16); |
1da177e4 LT |
184 | static int ds_send_control_cmd(struct ds_device *, u16, u16); |
185 | ||
81f6075e | 186 | static LIST_HEAD(ds_devices); |
abd52a13 | 187 | static DEFINE_MUTEX(ds_mutex); |
1da177e4 LT |
188 | |
189 | static struct usb_driver ds_driver = { | |
1da177e4 LT |
190 | .name = "DS9490R", |
191 | .probe = ds_probe, | |
192 | .disconnect = ds_disconnect, | |
193 | .id_table = ds_id_table, | |
194 | }; | |
195 | ||
1da177e4 LT |
196 | static int ds_send_control_cmd(struct ds_device *dev, u16 value, u16 index) |
197 | { | |
198 | int err; | |
8949d2aa EP |
199 | |
200 | err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, dev->ep[EP_CONTROL]), | |
1da177e4 LT |
201 | CONTROL_CMD, 0x40, value, index, NULL, 0, 1000); |
202 | if (err < 0) { | |
8949d2aa | 203 | printk(KERN_ERR "Failed to send command control message %x.%x: err=%d.\n", |
1da177e4 LT |
204 | value, index, err); |
205 | return err; | |
206 | } | |
207 | ||
208 | return err; | |
209 | } | |
1f4ec2d7 | 210 | |
1da177e4 LT |
211 | static int ds_send_control_mode(struct ds_device *dev, u16 value, u16 index) |
212 | { | |
213 | int err; | |
8949d2aa EP |
214 | |
215 | err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, dev->ep[EP_CONTROL]), | |
1da177e4 LT |
216 | MODE_CMD, 0x40, value, index, NULL, 0, 1000); |
217 | if (err < 0) { | |
8949d2aa | 218 | printk(KERN_ERR "Failed to send mode control message %x.%x: err=%d.\n", |
1da177e4 LT |
219 | value, index, err); |
220 | return err; | |
221 | } | |
222 | ||
223 | return err; | |
224 | } | |
1f4ec2d7 | 225 | |
1da177e4 LT |
226 | static int ds_send_control(struct ds_device *dev, u16 value, u16 index) |
227 | { | |
228 | int err; | |
8949d2aa EP |
229 | |
230 | err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, dev->ep[EP_CONTROL]), | |
1da177e4 LT |
231 | COMM_CMD, 0x40, value, index, NULL, 0, 1000); |
232 | if (err < 0) { | |
8949d2aa | 233 | printk(KERN_ERR "Failed to send control message %x.%x: err=%d.\n", |
1da177e4 LT |
234 | value, index, err); |
235 | return err; | |
236 | } | |
237 | ||
238 | return err; | |
239 | } | |
240 | ||
8949d2aa EP |
241 | static int ds_recv_status_nodump(struct ds_device *dev, struct ds_status *st, |
242 | unsigned char *buf, int size) | |
1da177e4 LT |
243 | { |
244 | int count, err; | |
8949d2aa | 245 | |
e9b5a495 | 246 | memset(st, 0, sizeof(*st)); |
8949d2aa | 247 | |
1da177e4 LT |
248 | count = 0; |
249 | err = usb_bulk_msg(dev->udev, usb_rcvbulkpipe(dev->udev, dev->ep[EP_STATUS]), buf, size, &count, 100); | |
250 | if (err < 0) { | |
251 | printk(KERN_ERR "Failed to read 1-wire data from 0x%x: err=%d.\n", dev->ep[EP_STATUS], err); | |
252 | return err; | |
253 | } | |
8949d2aa | 254 | |
1da177e4 LT |
255 | if (count >= sizeof(*st)) |
256 | memcpy(st, buf, sizeof(*st)); | |
257 | ||
258 | return count; | |
259 | } | |
260 | ||
4b9cf1bc | 261 | static inline void ds_print_msg(unsigned char *buf, unsigned char *str, int off) |
1da177e4 | 262 | { |
4b9cf1bc DF |
263 | printk(KERN_INFO "%45s: %8x\n", str, buf[off]); |
264 | } | |
8949d2aa | 265 | |
4b9cf1bc DF |
266 | static void ds_dump_status(struct ds_device *dev, unsigned char *buf, int count) |
267 | { | |
268 | int i; | |
8949d2aa | 269 | |
4b9cf1bc | 270 | printk(KERN_INFO "0x%x: count=%d, status: ", dev->ep[EP_STATUS], count); |
1da177e4 LT |
271 | for (i=0; i<count; ++i) |
272 | printk("%02x ", buf[i]); | |
4b9cf1bc | 273 | printk(KERN_INFO "\n"); |
1da177e4 LT |
274 | |
275 | if (count >= 16) { | |
4b9cf1bc DF |
276 | ds_print_msg(buf, "enable flag", 0); |
277 | ds_print_msg(buf, "1-wire speed", 1); | |
278 | ds_print_msg(buf, "strong pullup duration", 2); | |
279 | ds_print_msg(buf, "programming pulse duration", 3); | |
280 | ds_print_msg(buf, "pulldown slew rate control", 4); | |
281 | ds_print_msg(buf, "write-1 low time", 5); | |
282 | ds_print_msg(buf, "data sample offset/write-0 recovery time", | |
283 | 6); | |
284 | ds_print_msg(buf, "reserved (test register)", 7); | |
285 | ds_print_msg(buf, "device status flags", 8); | |
286 | ds_print_msg(buf, "communication command byte 1", 9); | |
287 | ds_print_msg(buf, "communication command byte 2", 10); | |
288 | ds_print_msg(buf, "communication command buffer status", 11); | |
289 | ds_print_msg(buf, "1-wire data output buffer status", 12); | |
290 | ds_print_msg(buf, "1-wire data input buffer status", 13); | |
291 | ds_print_msg(buf, "reserved", 14); | |
292 | ds_print_msg(buf, "reserved", 15); | |
1da177e4 | 293 | } |
4b9cf1bc DF |
294 | for (i = 16; i < count; ++i) { |
295 | if (buf[i] == RR_DETECT) { | |
296 | ds_print_msg(buf, "new device detect", i); | |
297 | continue; | |
298 | } | |
299 | ds_print_msg(buf, "Result Register Value: ", i); | |
300 | if (buf[i] & RR_NRS) | |
301 | printk(KERN_INFO "NRS: Reset no presence or ...\n"); | |
302 | if (buf[i] & RR_SH) | |
303 | printk(KERN_INFO "SH: short on reset or set path\n"); | |
304 | if (buf[i] & RR_APP) | |
305 | printk(KERN_INFO "APP: alarming presence on reset\n"); | |
306 | if (buf[i] & RR_VPP) | |
307 | printk(KERN_INFO "VPP: 12V expected not seen\n"); | |
308 | if (buf[i] & RR_CMP) | |
309 | printk(KERN_INFO "CMP: compare error\n"); | |
310 | if (buf[i] & RR_CRC) | |
311 | printk(KERN_INFO "CRC: CRC error detected\n"); | |
312 | if (buf[i] & RR_RDP) | |
313 | printk(KERN_INFO "RDP: redirected page\n"); | |
314 | if (buf[i] & RR_EOS) | |
315 | printk(KERN_INFO "EOS: end of search error\n"); | |
1da177e4 | 316 | } |
1da177e4 LT |
317 | } |
318 | ||
ade6d810 DF |
319 | static void ds_reset_device(struct ds_device *dev) |
320 | { | |
321 | ds_send_control_cmd(dev, CTL_RESET_DEVICE, 0); | |
322 | /* Always allow strong pullup which allow individual writes to use | |
323 | * the strong pullup. | |
324 | */ | |
325 | if (ds_send_control_mode(dev, MOD_PULSE_EN, PULSE_SPUE)) | |
326 | printk(KERN_ERR "ds_reset_device: " | |
327 | "Error allowing strong pullup\n"); | |
328 | /* Chip strong pullup time was cleared. */ | |
329 | if (dev->spu_sleep) { | |
330 | /* lower 4 bits are 0, see ds_set_pullup */ | |
331 | u8 del = dev->spu_sleep>>4; | |
332 | if (ds_send_control(dev, COMM_SET_DURATION | COMM_IM, del)) | |
333 | printk(KERN_ERR "ds_reset_device: " | |
334 | "Error setting duration\n"); | |
335 | } | |
336 | } | |
337 | ||
1da177e4 LT |
338 | static int ds_recv_data(struct ds_device *dev, unsigned char *buf, int size) |
339 | { | |
340 | int count, err; | |
341 | struct ds_status st; | |
8949d2aa | 342 | |
e464af24 DF |
343 | /* Careful on size. If size is less than what is available in |
344 | * the input buffer, the device fails the bulk transfer and | |
345 | * clears the input buffer. It could read the maximum size of | |
346 | * the data buffer, but then do you return the first, last, or | |
347 | * some set of the middle size bytes? As long as the rest of | |
348 | * the code is correct there will be size bytes waiting. A | |
349 | * call to ds_wait_status will wait until the device is idle | |
350 | * and any data to be received would have been available. | |
351 | */ | |
1da177e4 | 352 | count = 0; |
8949d2aa | 353 | err = usb_bulk_msg(dev->udev, usb_rcvbulkpipe(dev->udev, dev->ep[EP_DATA_IN]), |
1da177e4 LT |
354 | buf, size, &count, 1000); |
355 | if (err < 0) { | |
4b9cf1bc DF |
356 | u8 buf[0x20]; |
357 | int count; | |
358 | ||
1da177e4 LT |
359 | printk(KERN_INFO "Clearing ep0x%x.\n", dev->ep[EP_DATA_IN]); |
360 | usb_clear_halt(dev->udev, usb_rcvbulkpipe(dev->udev, dev->ep[EP_DATA_IN])); | |
4b9cf1bc DF |
361 | |
362 | count = ds_recv_status_nodump(dev, &st, buf, sizeof(buf)); | |
363 | ds_dump_status(dev, buf, count); | |
1da177e4 LT |
364 | return err; |
365 | } | |
366 | ||
367 | #if 0 | |
368 | { | |
369 | int i; | |
370 | ||
371 | printk("%s: count=%d: ", __func__, count); | |
372 | for (i=0; i<count; ++i) | |
373 | printk("%02x ", buf[i]); | |
374 | printk("\n"); | |
375 | } | |
376 | #endif | |
377 | return count; | |
378 | } | |
379 | ||
380 | static int ds_send_data(struct ds_device *dev, unsigned char *buf, int len) | |
381 | { | |
382 | int count, err; | |
8949d2aa | 383 | |
1da177e4 LT |
384 | count = 0; |
385 | err = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, dev->ep[EP_DATA_OUT]), buf, len, &count, 1000); | |
386 | if (err < 0) { | |
95cfaebf DF |
387 | printk(KERN_ERR "Failed to write 1-wire data to ep0x%x: " |
388 | "err=%d.\n", dev->ep[EP_DATA_OUT], err); | |
1da177e4 LT |
389 | return err; |
390 | } | |
391 | ||
392 | return err; | |
393 | } | |
394 | ||
8949d2aa EP |
395 | #if 0 |
396 | ||
1da177e4 LT |
397 | int ds_stop_pulse(struct ds_device *dev, int limit) |
398 | { | |
399 | struct ds_status st; | |
400 | int count = 0, err = 0; | |
401 | u8 buf[0x20]; | |
8949d2aa | 402 | |
1da177e4 LT |
403 | do { |
404 | err = ds_send_control(dev, CTL_HALT_EXE_IDLE, 0); | |
405 | if (err) | |
406 | break; | |
407 | err = ds_send_control(dev, CTL_RESUME_EXE, 0); | |
408 | if (err) | |
409 | break; | |
410 | err = ds_recv_status_nodump(dev, &st, buf, sizeof(buf)); | |
411 | if (err) | |
412 | break; | |
413 | ||
414 | if ((st.status & ST_SPUA) == 0) { | |
415 | err = ds_send_control_mode(dev, MOD_PULSE_EN, 0); | |
416 | if (err) | |
417 | break; | |
418 | } | |
419 | } while(++count < limit); | |
420 | ||
421 | return err; | |
422 | } | |
423 | ||
424 | int ds_detect(struct ds_device *dev, struct ds_status *st) | |
425 | { | |
426 | int err; | |
8949d2aa | 427 | |
1da177e4 LT |
428 | err = ds_send_control_cmd(dev, CTL_RESET_DEVICE, 0); |
429 | if (err) | |
430 | return err; | |
431 | ||
432 | err = ds_send_control(dev, COMM_SET_DURATION | COMM_IM, 0); | |
433 | if (err) | |
434 | return err; | |
8949d2aa | 435 | |
1da177e4 LT |
436 | err = ds_send_control(dev, COMM_SET_DURATION | COMM_IM | COMM_TYPE, 0x40); |
437 | if (err) | |
438 | return err; | |
8949d2aa | 439 | |
1da177e4 LT |
440 | err = ds_send_control_mode(dev, MOD_PULSE_EN, PULSE_PROG); |
441 | if (err) | |
442 | return err; | |
443 | ||
4b9cf1bc | 444 | err = ds_dump_status(dev, st); |
1da177e4 LT |
445 | |
446 | return err; | |
447 | } | |
448 | ||
8949d2aa EP |
449 | #endif /* 0 */ |
450 | ||
451 | static int ds_wait_status(struct ds_device *dev, struct ds_status *st) | |
1da177e4 LT |
452 | { |
453 | u8 buf[0x20]; | |
454 | int err, count = 0; | |
455 | ||
456 | do { | |
457 | err = ds_recv_status_nodump(dev, st, buf, sizeof(buf)); | |
458 | #if 0 | |
8949d2aa | 459 | if (err >= 0) { |
1da177e4 LT |
460 | int i; |
461 | printk("0x%x: count=%d, status: ", dev->ep[EP_STATUS], err); | |
462 | for (i=0; i<err; ++i) | |
463 | printk("%02x ", buf[i]); | |
464 | printk("\n"); | |
465 | } | |
466 | #endif | |
19e7184f | 467 | } while (!(buf[0x08] & ST_IDLE) && !(err < 0) && ++count < 100); |
1da177e4 | 468 | |
4b9cf1bc DF |
469 | if (err >= 16 && st->status & ST_EPOF) { |
470 | printk(KERN_INFO "Resetting device after ST_EPOF.\n"); | |
ade6d810 | 471 | ds_reset_device(dev); |
4b9cf1bc DF |
472 | /* Always dump the device status. */ |
473 | count = 101; | |
474 | } | |
1da177e4 | 475 | |
4b9cf1bc DF |
476 | /* Dump the status for errors or if there is extended return data. |
477 | * The extended status includes new device detection (maybe someone | |
478 | * can do something with it). | |
479 | */ | |
480 | if (err > 16 || count >= 100 || err < 0) | |
481 | ds_dump_status(dev, buf, err); | |
482 | ||
483 | /* Extended data isn't an error. Well, a short is, but the dump | |
484 | * would have already told the user that and we can't do anything | |
485 | * about it in software anyway. | |
486 | */ | |
487 | if (count >= 100 || err < 0) | |
1da177e4 | 488 | return -1; |
4b9cf1bc | 489 | else |
1da177e4 | 490 | return 0; |
1da177e4 LT |
491 | } |
492 | ||
7a4b9706 | 493 | static int ds_reset(struct ds_device *dev) |
1da177e4 LT |
494 | { |
495 | int err; | |
496 | ||
19e7184f DF |
497 | /* Other potentionally interesting flags for reset. |
498 | * | |
499 | * COMM_NTF: Return result register feedback. This could be used to | |
500 | * detect some conditions such as short, alarming presence, or | |
501 | * detect if a new device was detected. | |
502 | * | |
503 | * COMM_SE which allows SPEED_NORMAL, SPEED_FLEXIBLE, SPEED_OVERDRIVE: | |
504 | * Select the data transfer rate. | |
505 | */ | |
506 | err = ds_send_control(dev, COMM_1_WIRE_RESET | COMM_IM, SPEED_NORMAL); | |
1da177e4 LT |
507 | if (err) |
508 | return err; | |
509 | ||
1da177e4 LT |
510 | return 0; |
511 | } | |
512 | ||
8949d2aa | 513 | #if 0 |
81f6075e | 514 | static int ds_set_speed(struct ds_device *dev, int speed) |
1da177e4 LT |
515 | { |
516 | int err; | |
bd529cfb | 517 | |
1da177e4 LT |
518 | if (speed != SPEED_NORMAL && speed != SPEED_FLEXIBLE && speed != SPEED_OVERDRIVE) |
519 | return -EINVAL; | |
520 | ||
521 | if (speed != SPEED_OVERDRIVE) | |
522 | speed = SPEED_FLEXIBLE; | |
523 | ||
524 | speed &= 0xff; | |
8949d2aa | 525 | |
1da177e4 LT |
526 | err = ds_send_control_mode(dev, MOD_1WIRE_SPEED, speed); |
527 | if (err) | |
528 | return err; | |
529 | ||
530 | return err; | |
531 | } | |
8949d2aa | 532 | #endif /* 0 */ |
1da177e4 | 533 | |
1f4ec2d7 | 534 | static int ds_set_pullup(struct ds_device *dev, int delay) |
1da177e4 | 535 | { |
ade6d810 | 536 | int err = 0; |
1da177e4 | 537 | u8 del = 1 + (u8)(delay >> 4); |
ade6d810 DF |
538 | /* Just storing delay would not get the trunication and roundup. */ |
539 | int ms = del<<4; | |
540 | ||
541 | /* Enable spu_bit if a delay is set. */ | |
542 | dev->spu_bit = delay ? COMM_SPU : 0; | |
543 | /* If delay is zero, it has already been disabled, if the time is | |
544 | * the same as the hardware was last programmed to, there is also | |
545 | * nothing more to do. Compare with the recalculated value ms | |
546 | * rather than del or delay which can have a different value. | |
547 | */ | |
548 | if (delay == 0 || ms == dev->spu_sleep) | |
549 | return err; | |
1da177e4 | 550 | |
ade6d810 | 551 | err = ds_send_control(dev, COMM_SET_DURATION | COMM_IM, del); |
1da177e4 LT |
552 | if (err) |
553 | return err; | |
554 | ||
ade6d810 | 555 | dev->spu_sleep = ms; |
8949d2aa | 556 | |
1da177e4 LT |
557 | return err; |
558 | } | |
559 | ||
81f6075e | 560 | static int ds_touch_bit(struct ds_device *dev, u8 bit, u8 *tbit) |
1da177e4 | 561 | { |
6e10f654 | 562 | int err; |
1da177e4 | 563 | struct ds_status st; |
8949d2aa | 564 | |
6e10f654 DF |
565 | err = ds_send_control(dev, COMM_BIT_IO | COMM_IM | (bit ? COMM_D : 0), |
566 | 0); | |
1da177e4 LT |
567 | if (err) |
568 | return err; | |
569 | ||
6e10f654 | 570 | ds_wait_status(dev, &st); |
1da177e4 LT |
571 | |
572 | err = ds_recv_data(dev, tbit, sizeof(*tbit)); | |
573 | if (err < 0) | |
574 | return err; | |
575 | ||
576 | return 0; | |
577 | } | |
578 | ||
a08e2d33 | 579 | #if 0 |
81f6075e | 580 | static int ds_write_bit(struct ds_device *dev, u8 bit) |
1da177e4 LT |
581 | { |
582 | int err; | |
583 | struct ds_status st; | |
8949d2aa | 584 | |
e1c86d22 DF |
585 | /* Set COMM_ICP to write without a readback. Note, this will |
586 | * produce one time slot, a down followed by an up with COMM_D | |
587 | * only determing the timing. | |
588 | */ | |
589 | err = ds_send_control(dev, COMM_BIT_IO | COMM_IM | COMM_ICP | | |
590 | (bit ? COMM_D : 0), 0); | |
1da177e4 LT |
591 | if (err) |
592 | return err; | |
593 | ||
594 | ds_wait_status(dev, &st); | |
595 | ||
596 | return 0; | |
597 | } | |
a08e2d33 | 598 | #endif |
1da177e4 | 599 | |
81f6075e | 600 | static int ds_write_byte(struct ds_device *dev, u8 byte) |
1da177e4 LT |
601 | { |
602 | int err; | |
603 | struct ds_status st; | |
604 | u8 rbyte; | |
8949d2aa | 605 | |
ade6d810 | 606 | err = ds_send_control(dev, COMM_BYTE_IO | COMM_IM | dev->spu_bit, byte); |
1da177e4 LT |
607 | if (err) |
608 | return err; | |
609 | ||
ade6d810 | 610 | if (dev->spu_bit) |
1f4ec2d7 DF |
611 | msleep(dev->spu_sleep); |
612 | ||
1da177e4 LT |
613 | err = ds_wait_status(dev, &st); |
614 | if (err) | |
615 | return err; | |
8949d2aa | 616 | |
1da177e4 LT |
617 | err = ds_recv_data(dev, &rbyte, sizeof(rbyte)); |
618 | if (err < 0) | |
619 | return err; | |
8949d2aa | 620 | |
1da177e4 LT |
621 | return !(byte == rbyte); |
622 | } | |
623 | ||
81f6075e | 624 | static int ds_read_byte(struct ds_device *dev, u8 *byte) |
1da177e4 LT |
625 | { |
626 | int err; | |
627 | struct ds_status st; | |
628 | ||
629 | err = ds_send_control(dev, COMM_BYTE_IO | COMM_IM , 0xff); | |
630 | if (err) | |
631 | return err; | |
632 | ||
633 | ds_wait_status(dev, &st); | |
8949d2aa | 634 | |
1da177e4 LT |
635 | err = ds_recv_data(dev, byte, sizeof(*byte)); |
636 | if (err < 0) | |
637 | return err; | |
638 | ||
639 | return 0; | |
640 | } | |
641 | ||
81f6075e | 642 | static int ds_read_block(struct ds_device *dev, u8 *buf, int len) |
1da177e4 LT |
643 | { |
644 | struct ds_status st; | |
645 | int err; | |
646 | ||
647 | if (len > 64*1024) | |
648 | return -E2BIG; | |
649 | ||
650 | memset(buf, 0xFF, len); | |
8949d2aa | 651 | |
1da177e4 LT |
652 | err = ds_send_data(dev, buf, len); |
653 | if (err < 0) | |
654 | return err; | |
8949d2aa | 655 | |
1f4ec2d7 | 656 | err = ds_send_control(dev, COMM_BLOCK_IO | COMM_IM, len); |
1da177e4 LT |
657 | if (err) |
658 | return err; | |
659 | ||
660 | ds_wait_status(dev, &st); | |
8949d2aa | 661 | |
1da177e4 LT |
662 | memset(buf, 0x00, len); |
663 | err = ds_recv_data(dev, buf, len); | |
664 | ||
665 | return err; | |
666 | } | |
667 | ||
81f6075e | 668 | static int ds_write_block(struct ds_device *dev, u8 *buf, int len) |
1da177e4 LT |
669 | { |
670 | int err; | |
671 | struct ds_status st; | |
8949d2aa | 672 | |
1da177e4 LT |
673 | err = ds_send_data(dev, buf, len); |
674 | if (err < 0) | |
675 | return err; | |
8949d2aa | 676 | |
ade6d810 | 677 | err = ds_send_control(dev, COMM_BLOCK_IO | COMM_IM | dev->spu_bit, len); |
1da177e4 LT |
678 | if (err) |
679 | return err; | |
680 | ||
ade6d810 | 681 | if (dev->spu_bit) |
1f4ec2d7 DF |
682 | msleep(dev->spu_sleep); |
683 | ||
1da177e4 LT |
684 | ds_wait_status(dev, &st); |
685 | ||
686 | err = ds_recv_data(dev, buf, len); | |
687 | if (err < 0) | |
688 | return err; | |
689 | ||
1da177e4 LT |
690 | return !(err == len); |
691 | } | |
692 | ||
8949d2aa EP |
693 | #if 0 |
694 | ||
81f6075e | 695 | static int ds_search(struct ds_device *dev, u64 init, u64 *buf, u8 id_number, int conditional_search) |
1da177e4 LT |
696 | { |
697 | int err; | |
698 | u16 value, index; | |
699 | struct ds_status st; | |
700 | ||
701 | memset(buf, 0, sizeof(buf)); | |
8949d2aa | 702 | |
1da177e4 LT |
703 | err = ds_send_data(ds_dev, (unsigned char *)&init, 8); |
704 | if (err) | |
705 | return err; | |
8949d2aa | 706 | |
1da177e4 LT |
707 | ds_wait_status(ds_dev, &st); |
708 | ||
709 | value = COMM_SEARCH_ACCESS | COMM_IM | COMM_SM | COMM_F | COMM_RTS; | |
710 | index = (conditional_search ? 0xEC : 0xF0) | (id_number << 8); | |
711 | err = ds_send_control(ds_dev, value, index); | |
712 | if (err) | |
713 | return err; | |
714 | ||
715 | ds_wait_status(ds_dev, &st); | |
716 | ||
717 | err = ds_recv_data(ds_dev, (unsigned char *)buf, 8*id_number); | |
718 | if (err < 0) | |
719 | return err; | |
720 | ||
721 | return err/8; | |
722 | } | |
723 | ||
81f6075e | 724 | static int ds_match_access(struct ds_device *dev, u64 init) |
1da177e4 LT |
725 | { |
726 | int err; | |
727 | struct ds_status st; | |
728 | ||
729 | err = ds_send_data(dev, (unsigned char *)&init, sizeof(init)); | |
730 | if (err) | |
731 | return err; | |
8949d2aa | 732 | |
1da177e4 LT |
733 | ds_wait_status(dev, &st); |
734 | ||
735 | err = ds_send_control(dev, COMM_MATCH_ACCESS | COMM_IM | COMM_RST, 0x0055); | |
736 | if (err) | |
737 | return err; | |
738 | ||
739 | ds_wait_status(dev, &st); | |
740 | ||
741 | return 0; | |
742 | } | |
743 | ||
81f6075e | 744 | static int ds_set_path(struct ds_device *dev, u64 init) |
1da177e4 LT |
745 | { |
746 | int err; | |
747 | struct ds_status st; | |
748 | u8 buf[9]; | |
749 | ||
750 | memcpy(buf, &init, 8); | |
751 | buf[8] = BRANCH_MAIN; | |
8949d2aa | 752 | |
1da177e4 LT |
753 | err = ds_send_data(dev, buf, sizeof(buf)); |
754 | if (err) | |
755 | return err; | |
8949d2aa | 756 | |
1da177e4 LT |
757 | ds_wait_status(dev, &st); |
758 | ||
759 | err = ds_send_control(dev, COMM_SET_PATH | COMM_IM | COMM_RST, 0); | |
760 | if (err) | |
761 | return err; | |
762 | ||
763 | ds_wait_status(dev, &st); | |
764 | ||
765 | return 0; | |
766 | } | |
767 | ||
8949d2aa EP |
768 | #endif /* 0 */ |
769 | ||
81f6075e EP |
770 | static u8 ds9490r_touch_bit(void *data, u8 bit) |
771 | { | |
772 | u8 ret; | |
773 | struct ds_device *dev = data; | |
774 | ||
775 | if (ds_touch_bit(dev, bit, &ret)) | |
776 | return 0; | |
777 | ||
778 | return ret; | |
779 | } | |
780 | ||
a08e2d33 | 781 | #if 0 |
81f6075e EP |
782 | static void ds9490r_write_bit(void *data, u8 bit) |
783 | { | |
784 | struct ds_device *dev = data; | |
785 | ||
786 | ds_write_bit(dev, bit); | |
787 | } | |
788 | ||
81f6075e EP |
789 | static u8 ds9490r_read_bit(void *data) |
790 | { | |
791 | struct ds_device *dev = data; | |
792 | int err; | |
793 | u8 bit = 0; | |
794 | ||
795 | err = ds_touch_bit(dev, 1, &bit); | |
796 | if (err) | |
797 | return 0; | |
798 | ||
799 | return bit & 1; | |
800 | } | |
a08e2d33 DF |
801 | #endif |
802 | ||
803 | static void ds9490r_write_byte(void *data, u8 byte) | |
804 | { | |
805 | struct ds_device *dev = data; | |
806 | ||
807 | ds_write_byte(dev, byte); | |
808 | } | |
81f6075e EP |
809 | |
810 | static u8 ds9490r_read_byte(void *data) | |
811 | { | |
812 | struct ds_device *dev = data; | |
813 | int err; | |
814 | u8 byte = 0; | |
815 | ||
816 | err = ds_read_byte(dev, &byte); | |
817 | if (err) | |
818 | return 0; | |
819 | ||
820 | return byte; | |
821 | } | |
822 | ||
823 | static void ds9490r_write_block(void *data, const u8 *buf, int len) | |
824 | { | |
825 | struct ds_device *dev = data; | |
826 | ||
827 | ds_write_block(dev, (u8 *)buf, len); | |
828 | } | |
829 | ||
830 | static u8 ds9490r_read_block(void *data, u8 *buf, int len) | |
831 | { | |
832 | struct ds_device *dev = data; | |
833 | int err; | |
834 | ||
835 | err = ds_read_block(dev, buf, len); | |
836 | if (err < 0) | |
837 | return 0; | |
838 | ||
839 | return len; | |
840 | } | |
841 | ||
842 | static u8 ds9490r_reset(void *data) | |
843 | { | |
844 | struct ds_device *dev = data; | |
81f6075e EP |
845 | int err; |
846 | ||
7a4b9706 | 847 | err = ds_reset(dev); |
81f6075e EP |
848 | if (err) |
849 | return 1; | |
850 | ||
851 | return 0; | |
852 | } | |
853 | ||
1f4ec2d7 DF |
854 | static u8 ds9490r_set_pullup(void *data, int delay) |
855 | { | |
856 | struct ds_device *dev = data; | |
857 | ||
858 | if (ds_set_pullup(dev, delay)) | |
859 | return 1; | |
860 | ||
861 | return 0; | |
862 | } | |
863 | ||
81f6075e EP |
864 | static int ds_w1_init(struct ds_device *dev) |
865 | { | |
866 | memset(&dev->master, 0, sizeof(struct w1_bus_master)); | |
867 | ||
e464af24 DF |
868 | /* Reset the device as it can be in a bad state. |
869 | * This is necessary because a block write will wait for data | |
870 | * to be placed in the output buffer and block any later | |
871 | * commands which will keep accumulating and the device will | |
872 | * not be idle. Another case is removing the ds2490 module | |
873 | * while a bus search is in progress, somehow a few commands | |
874 | * get through, but the input transfers fail leaving data in | |
875 | * the input buffer. This will cause the next read to fail | |
876 | * see the note in ds_recv_data. | |
877 | */ | |
ade6d810 | 878 | ds_reset_device(dev); |
e464af24 | 879 | |
81f6075e EP |
880 | dev->master.data = dev; |
881 | dev->master.touch_bit = &ds9490r_touch_bit; | |
a08e2d33 DF |
882 | /* read_bit and write_bit in w1_bus_master are expected to set and |
883 | * sample the line level. For write_bit that means it is expected to | |
884 | * set it to that value and leave it there. ds2490 only supports an | |
885 | * individual time slot at the lowest level. The requirement from | |
886 | * pulling the bus state down to reading the state is 15us, something | |
887 | * that isn't realistic on the USB bus anyway. | |
81f6075e EP |
888 | dev->master.read_bit = &ds9490r_read_bit; |
889 | dev->master.write_bit = &ds9490r_write_bit; | |
a08e2d33 | 890 | */ |
81f6075e EP |
891 | dev->master.read_byte = &ds9490r_read_byte; |
892 | dev->master.write_byte = &ds9490r_write_byte; | |
893 | dev->master.read_block = &ds9490r_read_block; | |
894 | dev->master.write_block = &ds9490r_write_block; | |
895 | dev->master.reset_bus = &ds9490r_reset; | |
1f4ec2d7 | 896 | dev->master.set_pullup = &ds9490r_set_pullup; |
81f6075e EP |
897 | |
898 | return w1_add_master_device(&dev->master); | |
899 | } | |
900 | ||
901 | static void ds_w1_fini(struct ds_device *dev) | |
902 | { | |
903 | w1_remove_master_device(&dev->master); | |
904 | } | |
905 | ||
8949d2aa EP |
906 | static int ds_probe(struct usb_interface *intf, |
907 | const struct usb_device_id *udev_id) | |
1da177e4 LT |
908 | { |
909 | struct usb_device *udev = interface_to_usbdev(intf); | |
910 | struct usb_endpoint_descriptor *endpoint; | |
911 | struct usb_host_interface *iface_desc; | |
81f6075e | 912 | struct ds_device *dev; |
1da177e4 LT |
913 | int i, err; |
914 | ||
81f6075e EP |
915 | dev = kmalloc(sizeof(struct ds_device), GFP_KERNEL); |
916 | if (!dev) { | |
1da177e4 LT |
917 | printk(KERN_INFO "Failed to allocate new DS9490R structure.\n"); |
918 | return -ENOMEM; | |
919 | } | |
1f4ec2d7 | 920 | dev->spu_sleep = 0; |
ade6d810 | 921 | dev->spu_bit = 0; |
81f6075e EP |
922 | dev->udev = usb_get_dev(udev); |
923 | if (!dev->udev) { | |
924 | err = -ENOMEM; | |
925 | goto err_out_free; | |
926 | } | |
927 | memset(dev->ep, 0, sizeof(dev->ep)); | |
1da177e4 | 928 | |
81f6075e | 929 | usb_set_intfdata(intf, dev); |
1da177e4 | 930 | |
81f6075e | 931 | err = usb_set_interface(dev->udev, intf->altsetting[0].desc.bInterfaceNumber, 3); |
1da177e4 LT |
932 | if (err) { |
933 | printk(KERN_ERR "Failed to set alternative setting 3 for %d interface: err=%d.\n", | |
934 | intf->altsetting[0].desc.bInterfaceNumber, err); | |
81f6075e | 935 | goto err_out_clear; |
1da177e4 LT |
936 | } |
937 | ||
81f6075e | 938 | err = usb_reset_configuration(dev->udev); |
1da177e4 LT |
939 | if (err) { |
940 | printk(KERN_ERR "Failed to reset configuration: err=%d.\n", err); | |
81f6075e | 941 | goto err_out_clear; |
1da177e4 | 942 | } |
8949d2aa | 943 | |
1da177e4 LT |
944 | iface_desc = &intf->altsetting[0]; |
945 | if (iface_desc->desc.bNumEndpoints != NUM_EP-1) { | |
946 | printk(KERN_INFO "Num endpoints=%d. It is not DS9490R.\n", iface_desc->desc.bNumEndpoints); | |
81f6075e EP |
947 | err = -EINVAL; |
948 | goto err_out_clear; | |
1da177e4 LT |
949 | } |
950 | ||
1da177e4 | 951 | /* |
8949d2aa | 952 | * This loop doesn'd show control 0 endpoint, |
1da177e4 LT |
953 | * so we will fill only 1-3 endpoints entry. |
954 | */ | |
955 | for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { | |
956 | endpoint = &iface_desc->endpoint[i].desc; | |
957 | ||
81f6075e EP |
958 | dev->ep[i+1] = endpoint->bEndpointAddress; |
959 | #if 0 | |
1da177e4 LT |
960 | printk("%d: addr=%x, size=%d, dir=%s, type=%x\n", |
961 | i, endpoint->bEndpointAddress, le16_to_cpu(endpoint->wMaxPacketSize), | |
962 | (endpoint->bEndpointAddress & USB_DIR_IN)?"IN":"OUT", | |
963 | endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK); | |
81f6075e | 964 | #endif |
1da177e4 | 965 | } |
8949d2aa | 966 | |
81f6075e EP |
967 | err = ds_w1_init(dev); |
968 | if (err) | |
969 | goto err_out_clear; | |
8949d2aa | 970 | |
abd52a13 | 971 | mutex_lock(&ds_mutex); |
81f6075e | 972 | list_add_tail(&dev->ds_entry, &ds_devices); |
abd52a13 | 973 | mutex_unlock(&ds_mutex); |
1da177e4 LT |
974 | |
975 | return 0; | |
81f6075e EP |
976 | |
977 | err_out_clear: | |
978 | usb_set_intfdata(intf, NULL); | |
979 | usb_put_dev(dev->udev); | |
980 | err_out_free: | |
981 | kfree(dev); | |
982 | return err; | |
1da177e4 LT |
983 | } |
984 | ||
8949d2aa | 985 | static void ds_disconnect(struct usb_interface *intf) |
1da177e4 LT |
986 | { |
987 | struct ds_device *dev; | |
8949d2aa | 988 | |
1da177e4 | 989 | dev = usb_get_intfdata(intf); |
81f6075e EP |
990 | if (!dev) |
991 | return; | |
1da177e4 | 992 | |
abd52a13 | 993 | mutex_lock(&ds_mutex); |
81f6075e | 994 | list_del(&dev->ds_entry); |
abd52a13 | 995 | mutex_unlock(&ds_mutex); |
1da177e4 | 996 | |
81f6075e EP |
997 | ds_w1_fini(dev); |
998 | ||
999 | usb_set_intfdata(intf, NULL); | |
1da177e4 LT |
1000 | |
1001 | usb_put_dev(dev->udev); | |
1002 | kfree(dev); | |
1da177e4 LT |
1003 | } |
1004 | ||
8949d2aa | 1005 | static int ds_init(void) |
1da177e4 LT |
1006 | { |
1007 | int err; | |
1008 | ||
1009 | err = usb_register(&ds_driver); | |
1010 | if (err) { | |
1011 | printk(KERN_INFO "Failed to register DS9490R USB device: err=%d.\n", err); | |
1012 | return err; | |
1013 | } | |
1014 | ||
1015 | return 0; | |
1016 | } | |
1017 | ||
8949d2aa | 1018 | static void ds_fini(void) |
1da177e4 LT |
1019 | { |
1020 | usb_deregister(&ds_driver); | |
1021 | } | |
1022 | ||
1023 | module_init(ds_init); | |
1024 | module_exit(ds_fini); | |
1025 | ||
1026 | MODULE_LICENSE("GPL"); | |
a8018766 | 1027 | MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>"); |
81f6075e | 1028 | MODULE_DESCRIPTION("DS2490 USB <-> W1 bus master driver (DS9490*)"); |