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