[PATCH] USB: revert "fix" to usb_set_interface()
[linux-2.6] / drivers / w1 / dscore.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 "dscore.h"
28
29 static struct usb_device_id ds_id_table [] = {
30         { USB_DEVICE(0x04fa, 0x2490) },
31         { },
32 };
33 MODULE_DEVICE_TABLE(usb, ds_id_table);
34
35 int ds_probe(struct usb_interface *, const struct usb_device_id *);
36 void ds_disconnect(struct usb_interface *);
37
38 int ds_touch_bit(struct ds_device *, u8, u8 *);
39 int ds_read_byte(struct ds_device *, u8 *);
40 int ds_read_bit(struct ds_device *, u8 *);
41 int ds_write_byte(struct ds_device *, u8);
42 int ds_write_bit(struct ds_device *, u8);
43 int ds_start_pulse(struct ds_device *, int);
44 int ds_set_speed(struct ds_device *, int);
45 int ds_reset(struct ds_device *, struct ds_status *);
46 int ds_detect(struct ds_device *, struct ds_status *);
47 int ds_stop_pulse(struct ds_device *, int);
48 struct ds_device * ds_get_device(void);
49 void ds_put_device(struct ds_device *);
50
51 static inline void ds_dump_status(unsigned char *, unsigned char *, int);
52 static int ds_send_control(struct ds_device *, u16, u16);
53 static int ds_send_control_mode(struct ds_device *, u16, u16);
54 static int ds_send_control_cmd(struct ds_device *, u16, u16);
55
56
57 static struct usb_driver ds_driver = {
58         .owner =        THIS_MODULE,
59         .name =         "DS9490R",
60         .probe =        ds_probe,
61         .disconnect =   ds_disconnect,
62         .id_table =     ds_id_table,
63 };
64
65 static struct ds_device *ds_dev;
66
67 struct ds_device * ds_get_device(void)
68 {
69         if (ds_dev)
70                 atomic_inc(&ds_dev->refcnt);
71         return ds_dev;
72 }
73
74 void ds_put_device(struct ds_device *dev)
75 {
76         atomic_dec(&dev->refcnt);
77 }
78
79 static int ds_send_control_cmd(struct ds_device *dev, u16 value, u16 index)
80 {
81         int err;
82         
83         err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, dev->ep[EP_CONTROL]), 
84                         CONTROL_CMD, 0x40, value, index, NULL, 0, 1000);
85         if (err < 0) {
86                 printk(KERN_ERR "Failed to send command control message %x.%x: err=%d.\n", 
87                                 value, index, err);
88                 return err;
89         }
90
91         return err;
92 }
93
94 static int ds_send_control_mode(struct ds_device *dev, u16 value, u16 index)
95 {
96         int err;
97         
98         err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, dev->ep[EP_CONTROL]), 
99                         MODE_CMD, 0x40, value, index, NULL, 0, 1000);
100         if (err < 0) {
101                 printk(KERN_ERR "Failed to send mode control message %x.%x: err=%d.\n", 
102                                 value, index, err);
103                 return err;
104         }
105
106         return err;
107 }
108
109 static int ds_send_control(struct ds_device *dev, u16 value, u16 index)
110 {
111         int err;
112         
113         err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, dev->ep[EP_CONTROL]), 
114                         COMM_CMD, 0x40, value, index, NULL, 0, 1000);
115         if (err < 0) {
116                 printk(KERN_ERR "Failed to send control message %x.%x: err=%d.\n", 
117                                 value, index, err);
118                 return err;
119         }
120
121         return err;
122 }
123
124 static inline void ds_dump_status(unsigned char *buf, unsigned char *str, int off)
125 {
126         printk("%45s: %8x\n", str, buf[off]);
127 }
128
129 int ds_recv_status_nodump(struct ds_device *dev, struct ds_status *st, unsigned char *buf, int size)
130 {
131         int count, err;
132                 
133         memset(st, 0, sizeof(st));
134         
135         count = 0;
136         err = usb_bulk_msg(dev->udev, usb_rcvbulkpipe(dev->udev, dev->ep[EP_STATUS]), buf, size, &count, 100);
137         if (err < 0) {
138                 printk(KERN_ERR "Failed to read 1-wire data from 0x%x: err=%d.\n", dev->ep[EP_STATUS], err);
139                 return err;
140         }
141         
142         if (count >= sizeof(*st))
143                 memcpy(st, buf, sizeof(*st));
144
145         return count;
146 }
147
148 static int ds_recv_status(struct ds_device *dev, struct ds_status *st)
149 {
150         unsigned char buf[64];
151         int count, err = 0, i;
152         
153         memcpy(st, buf, sizeof(*st));
154                 
155         count = ds_recv_status_nodump(dev, st, buf, sizeof(buf));
156         if (count < 0)
157                 return err;
158         
159         printk("0x%x: count=%d, status: ", dev->ep[EP_STATUS], count);
160         for (i=0; i<count; ++i)
161                 printk("%02x ", buf[i]);
162         printk("\n");
163
164         if (count >= 16) {
165                 ds_dump_status(buf, "enable flag", 0);
166                 ds_dump_status(buf, "1-wire speed", 1);
167                 ds_dump_status(buf, "strong pullup duration", 2);
168                 ds_dump_status(buf, "programming pulse duration", 3);
169                 ds_dump_status(buf, "pulldown slew rate control", 4);
170                 ds_dump_status(buf, "write-1 low time", 5);
171                 ds_dump_status(buf, "data sample offset/write-0 recovery time", 6);
172                 ds_dump_status(buf, "reserved (test register)", 7);
173                 ds_dump_status(buf, "device status flags", 8);
174                 ds_dump_status(buf, "communication command byte 1", 9);
175                 ds_dump_status(buf, "communication command byte 2", 10);
176                 ds_dump_status(buf, "communication command buffer status", 11);
177                 ds_dump_status(buf, "1-wire data output buffer status", 12);
178                 ds_dump_status(buf, "1-wire data input buffer status", 13);
179                 ds_dump_status(buf, "reserved", 14);
180                 ds_dump_status(buf, "reserved", 15);
181         }
182
183         memcpy(st, buf, sizeof(*st));
184
185         if (st->status & ST_EPOF) {
186                 printk(KERN_INFO "Resetting device after ST_EPOF.\n");
187                 err = ds_send_control_cmd(dev, CTL_RESET_DEVICE, 0);
188                 if (err)
189                         return err;
190                 count = ds_recv_status_nodump(dev, st, buf, sizeof(buf));
191                 if (count < 0)
192                         return err;
193         }
194 #if 0
195         if (st->status & ST_IDLE) {
196                 printk(KERN_INFO "Resetting pulse after ST_IDLE.\n");
197                 err = ds_start_pulse(dev, PULLUP_PULSE_DURATION);
198                 if (err)
199                         return err;
200         }
201 #endif
202         
203         return err;
204 }
205
206 static int ds_recv_data(struct ds_device *dev, unsigned char *buf, int size)
207 {
208         int count, err;
209         struct ds_status st;
210         
211         count = 0;
212         err = usb_bulk_msg(dev->udev, usb_rcvbulkpipe(dev->udev, dev->ep[EP_DATA_IN]), 
213                                 buf, size, &count, 1000);
214         if (err < 0) {
215                 printk(KERN_INFO "Clearing ep0x%x.\n", dev->ep[EP_DATA_IN]);
216                 usb_clear_halt(dev->udev, usb_rcvbulkpipe(dev->udev, dev->ep[EP_DATA_IN]));
217                 ds_recv_status(dev, &st);
218                 return err;
219         }
220
221 #if 0
222         {
223                 int i;
224
225                 printk("%s: count=%d: ", __func__, count);
226                 for (i=0; i<count; ++i)
227                         printk("%02x ", buf[i]);
228                 printk("\n");
229         }
230 #endif
231         return count;
232 }
233
234 static int ds_send_data(struct ds_device *dev, unsigned char *buf, int len)
235 {
236         int count, err;
237         
238         count = 0;
239         err = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, dev->ep[EP_DATA_OUT]), buf, len, &count, 1000);
240         if (err < 0) {
241                 printk(KERN_ERR "Failed to read 1-wire data from 0x02: err=%d.\n", err);
242                 return err;
243         }
244
245         return err;
246 }
247
248 int ds_stop_pulse(struct ds_device *dev, int limit)
249 {
250         struct ds_status st;
251         int count = 0, err = 0;
252         u8 buf[0x20];
253         
254         do {
255                 err = ds_send_control(dev, CTL_HALT_EXE_IDLE, 0);
256                 if (err)
257                         break;
258                 err = ds_send_control(dev, CTL_RESUME_EXE, 0);
259                 if (err)
260                         break;
261                 err = ds_recv_status_nodump(dev, &st, buf, sizeof(buf));
262                 if (err)
263                         break;
264
265                 if ((st.status & ST_SPUA) == 0) {
266                         err = ds_send_control_mode(dev, MOD_PULSE_EN, 0);
267                         if (err)
268                                 break;
269                 }
270         } while(++count < limit);
271
272         return err;
273 }
274
275 int ds_detect(struct ds_device *dev, struct ds_status *st)
276 {
277         int err;
278         
279         err = ds_send_control_cmd(dev, CTL_RESET_DEVICE, 0);
280         if (err)
281                 return err;
282
283         err = ds_send_control(dev, COMM_SET_DURATION | COMM_IM, 0);
284         if (err)
285                 return err;
286         
287         err = ds_send_control(dev, COMM_SET_DURATION | COMM_IM | COMM_TYPE, 0x40);
288         if (err)
289                 return err;
290         
291         err = ds_send_control_mode(dev, MOD_PULSE_EN, PULSE_PROG);
292         if (err)
293                 return err;
294
295         err = ds_recv_status(dev, st);
296
297         return err;
298 }
299
300 int ds_wait_status(struct ds_device *dev, struct ds_status *st)
301 {
302         u8 buf[0x20];
303         int err, count = 0;
304
305         do {
306                 err = ds_recv_status_nodump(dev, st, buf, sizeof(buf));
307 #if 0
308                 if (err >= 0) { 
309                         int i;
310                         printk("0x%x: count=%d, status: ", dev->ep[EP_STATUS], err);
311                         for (i=0; i<err; ++i)
312                                 printk("%02x ", buf[i]);
313                         printk("\n");
314                 }
315 #endif
316         } while(!(buf[0x08] & 0x20) && !(err < 0) && ++count < 100);
317
318
319         if (((err > 16) && (buf[0x10] & 0x01)) || count >= 100 || err < 0) {
320                 ds_recv_status(dev, st);
321                 return -1;
322         }
323         else {
324                 return 0;
325         }
326 }
327
328 int ds_reset(struct ds_device *dev, struct ds_status *st)
329 {
330         int err;
331
332         //err = ds_send_control(dev, COMM_1_WIRE_RESET | COMM_F | COMM_IM | COMM_SE, SPEED_FLEXIBLE);
333         err = ds_send_control(dev, 0x43, SPEED_NORMAL);
334         if (err)
335                 return err;
336
337         ds_wait_status(dev, st);
338 #if 0
339         if (st->command_buffer_status) {
340                 printk(KERN_INFO "Short circuit.\n");
341                 return -EIO;
342         }
343 #endif
344         
345         return 0;
346 }
347
348 int ds_set_speed(struct ds_device *dev, int speed)
349 {
350         int err;
351         
352         if (speed != SPEED_NORMAL && speed != SPEED_FLEXIBLE && speed != SPEED_OVERDRIVE)
353                 return -EINVAL;
354
355         if (speed != SPEED_OVERDRIVE)
356                 speed = SPEED_FLEXIBLE;
357
358         speed &= 0xff;
359         
360         err = ds_send_control_mode(dev, MOD_1WIRE_SPEED, speed);
361         if (err)
362                 return err;
363
364         return err;
365 }
366
367 int ds_start_pulse(struct ds_device *dev, int delay)
368 {
369         int err;
370         u8 del = 1 + (u8)(delay >> 4);
371         struct ds_status st;
372         
373 #if 0
374         err = ds_stop_pulse(dev, 10);
375         if (err)
376                 return err;
377
378         err = ds_send_control_mode(dev, MOD_PULSE_EN, PULSE_SPUE);
379         if (err)
380                 return err;
381 #endif
382         err = ds_send_control(dev, COMM_SET_DURATION | COMM_IM, del);
383         if (err)
384                 return err;
385
386         err = ds_send_control(dev, COMM_PULSE | COMM_IM | COMM_F, 0);
387         if (err)
388                 return err;
389
390         mdelay(delay);
391
392         ds_wait_status(dev, &st);
393         
394         return err;
395 }
396
397 int ds_touch_bit(struct ds_device *dev, u8 bit, u8 *tbit)
398 {
399         int err, count;
400         struct ds_status st;
401         u16 value = (COMM_BIT_IO | COMM_IM) | ((bit) ? COMM_D : 0);
402         u16 cmd;
403         
404         err = ds_send_control(dev, value, 0);
405         if (err)
406                 return err;
407
408         count = 0;
409         do {
410                 err = ds_wait_status(dev, &st);
411                 if (err)
412                         return err;
413
414                 cmd = st.command0 | (st.command1 << 8);
415         } while (cmd != value && ++count < 10);
416
417         if (err < 0 || count >= 10) {
418                 printk(KERN_ERR "Failed to obtain status.\n");
419                 return -EINVAL;
420         }
421
422         err = ds_recv_data(dev, tbit, sizeof(*tbit));
423         if (err < 0)
424                 return err;
425
426         return 0;
427 }
428
429 int ds_write_bit(struct ds_device *dev, u8 bit)
430 {
431         int err;
432         struct ds_status st;
433         
434         err = ds_send_control(dev, COMM_BIT_IO | COMM_IM | (bit) ? COMM_D : 0, 0);
435         if (err)
436                 return err;
437
438         ds_wait_status(dev, &st);
439
440         return 0;
441 }
442
443 int ds_write_byte(struct ds_device *dev, u8 byte)
444 {
445         int err;
446         struct ds_status st;
447         u8 rbyte;
448         
449         err = ds_send_control(dev, COMM_BYTE_IO | COMM_IM | COMM_SPU, byte);
450         if (err)
451                 return err;
452
453         err = ds_wait_status(dev, &st);
454         if (err)
455                 return err;
456                 
457         err = ds_recv_data(dev, &rbyte, sizeof(rbyte));
458         if (err < 0)
459                 return err;
460         
461         ds_start_pulse(dev, PULLUP_PULSE_DURATION);
462
463         return !(byte == rbyte);
464 }
465
466 int ds_read_bit(struct ds_device *dev, u8 *bit)
467 {
468         int err;
469
470         err = ds_send_control_mode(dev, MOD_PULSE_EN, PULSE_SPUE);
471         if (err)
472                 return err;
473         
474         err = ds_send_control(dev, COMM_BIT_IO | COMM_IM | COMM_SPU | COMM_D, 0);
475         if (err)
476                 return err;
477         
478         err = ds_recv_data(dev, bit, sizeof(*bit));
479         if (err < 0)
480                 return err;
481
482         return 0;
483 }
484
485 int ds_read_byte(struct ds_device *dev, u8 *byte)
486 {
487         int err;
488         struct ds_status st;
489
490         err = ds_send_control(dev, COMM_BYTE_IO | COMM_IM , 0xff);
491         if (err)
492                 return err;
493
494         ds_wait_status(dev, &st);
495         
496         err = ds_recv_data(dev, byte, sizeof(*byte));
497         if (err < 0)
498                 return err;
499
500         return 0;
501 }
502
503 int ds_read_block(struct ds_device *dev, u8 *buf, int len)
504 {
505         struct ds_status st;
506         int err;
507
508         if (len > 64*1024)
509                 return -E2BIG;
510
511         memset(buf, 0xFF, len);
512         
513         err = ds_send_data(dev, buf, len);
514         if (err < 0)
515                 return err;
516         
517         err = ds_send_control(dev, COMM_BLOCK_IO | COMM_IM | COMM_SPU, len);
518         if (err)
519                 return err;
520
521         ds_wait_status(dev, &st);
522         
523         memset(buf, 0x00, len);
524         err = ds_recv_data(dev, buf, len);
525
526         return err;
527 }
528
529 int ds_write_block(struct ds_device *dev, u8 *buf, int len)
530 {
531         int err;
532         struct ds_status st;
533         
534         err = ds_send_data(dev, buf, len);
535         if (err < 0)
536                 return err;
537         
538         ds_wait_status(dev, &st);
539
540         err = ds_send_control(dev, COMM_BLOCK_IO | COMM_IM | COMM_SPU, len);
541         if (err)
542                 return err;
543
544         ds_wait_status(dev, &st);
545
546         err = ds_recv_data(dev, buf, len);
547         if (err < 0)
548                 return err;
549
550         ds_start_pulse(dev, PULLUP_PULSE_DURATION);
551         
552         return !(err == len);
553 }
554
555 int ds_search(struct ds_device *dev, u64 init, u64 *buf, u8 id_number, int conditional_search)
556 {
557         int err;
558         u16 value, index;
559         struct ds_status st;
560
561         memset(buf, 0, sizeof(buf));
562         
563         err = ds_send_data(ds_dev, (unsigned char *)&init, 8);
564         if (err)
565                 return err;
566         
567         ds_wait_status(ds_dev, &st);
568
569         value = COMM_SEARCH_ACCESS | COMM_IM | COMM_SM | COMM_F | COMM_RTS;
570         index = (conditional_search ? 0xEC : 0xF0) | (id_number << 8);
571         err = ds_send_control(ds_dev, value, index);
572         if (err)
573                 return err;
574
575         ds_wait_status(ds_dev, &st);
576
577         err = ds_recv_data(ds_dev, (unsigned char *)buf, 8*id_number);
578         if (err < 0)
579                 return err;
580
581         return err/8;
582 }
583
584 int ds_match_access(struct ds_device *dev, u64 init)
585 {
586         int err;
587         struct ds_status st;
588
589         err = ds_send_data(dev, (unsigned char *)&init, sizeof(init));
590         if (err)
591                 return err;
592         
593         ds_wait_status(dev, &st);
594
595         err = ds_send_control(dev, COMM_MATCH_ACCESS | COMM_IM | COMM_RST, 0x0055);
596         if (err)
597                 return err;
598
599         ds_wait_status(dev, &st);
600
601         return 0;
602 }
603
604 int ds_set_path(struct ds_device *dev, u64 init)
605 {
606         int err;
607         struct ds_status st;
608         u8 buf[9];
609
610         memcpy(buf, &init, 8);
611         buf[8] = BRANCH_MAIN;
612         
613         err = ds_send_data(dev, buf, sizeof(buf));
614         if (err)
615                 return err;
616         
617         ds_wait_status(dev, &st);
618
619         err = ds_send_control(dev, COMM_SET_PATH | COMM_IM | COMM_RST, 0);
620         if (err)
621                 return err;
622
623         ds_wait_status(dev, &st);
624
625         return 0;
626 }
627
628 int ds_probe(struct usb_interface *intf, const struct usb_device_id *udev_id)
629 {
630         struct usb_device *udev = interface_to_usbdev(intf);
631         struct usb_endpoint_descriptor *endpoint;
632         struct usb_host_interface *iface_desc;
633         int i, err;
634
635         ds_dev = kmalloc(sizeof(struct ds_device), GFP_KERNEL);
636         if (!ds_dev) {
637                 printk(KERN_INFO "Failed to allocate new DS9490R structure.\n");
638                 return -ENOMEM;
639         }
640
641         ds_dev->udev = usb_get_dev(udev);
642         usb_set_intfdata(intf, ds_dev);
643
644         err = usb_set_interface(ds_dev->udev, intf->altsetting[0].desc.bInterfaceNumber, 3);
645         if (err) {
646                 printk(KERN_ERR "Failed to set alternative setting 3 for %d interface: err=%d.\n",
647                                 intf->altsetting[0].desc.bInterfaceNumber, err);
648                 return err;
649         }
650
651         err = usb_reset_configuration(ds_dev->udev);
652         if (err) {
653                 printk(KERN_ERR "Failed to reset configuration: err=%d.\n", err);
654                 return err;
655         }
656         
657         iface_desc = &intf->altsetting[0];
658         if (iface_desc->desc.bNumEndpoints != NUM_EP-1) {
659                 printk(KERN_INFO "Num endpoints=%d. It is not DS9490R.\n", iface_desc->desc.bNumEndpoints);
660                 return -ENODEV;
661         }
662
663         atomic_set(&ds_dev->refcnt, 0);
664         memset(ds_dev->ep, 0, sizeof(ds_dev->ep));
665         
666         /*
667          * This loop doesn'd show control 0 endpoint, 
668          * so we will fill only 1-3 endpoints entry.
669          */
670         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
671                 endpoint = &iface_desc->endpoint[i].desc;
672
673                 ds_dev->ep[i+1] = endpoint->bEndpointAddress;
674                 
675                 printk("%d: addr=%x, size=%d, dir=%s, type=%x\n",
676                         i, endpoint->bEndpointAddress, le16_to_cpu(endpoint->wMaxPacketSize),
677                         (endpoint->bEndpointAddress & USB_DIR_IN)?"IN":"OUT",
678                         endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
679         }
680         
681 #if 0
682         {
683                 int err, i;
684                 u64 buf[3];
685                 u64 init=0xb30000002078ee81ull;
686                 struct ds_status st;
687                 
688                 ds_reset(ds_dev, &st);
689                 err = ds_search(ds_dev, init, buf, 3, 0);
690                 if (err < 0)
691                         return err;
692                 for (i=0; i<err; ++i)
693                         printk("%d: %llx\n", i, buf[i]);
694                 
695                 printk("Resetting...\n");       
696                 ds_reset(ds_dev, &st);
697                 printk("Setting path for %llx.\n", init);
698                 err = ds_set_path(ds_dev, init);
699                 if (err)
700                         return err;
701                 printk("Calling MATCH_ACCESS.\n");
702                 err = ds_match_access(ds_dev, init);
703                 if (err)
704                         return err;
705
706                 printk("Searching the bus...\n");
707                 err = ds_search(ds_dev, init, buf, 3, 0);
708
709                 printk("ds_search() returned %d\n", err);
710                 
711                 if (err < 0)
712                         return err;
713                 for (i=0; i<err; ++i)
714                         printk("%d: %llx\n", i, buf[i]);
715                 
716                 return 0;
717         }
718 #endif
719
720         return 0;
721 }
722
723 void ds_disconnect(struct usb_interface *intf)
724 {
725         struct ds_device *dev;
726         
727         dev = usb_get_intfdata(intf);
728         usb_set_intfdata(intf, NULL);
729
730         while (atomic_read(&dev->refcnt)) {
731                 printk(KERN_INFO "Waiting for DS to become free: refcnt=%d.\n",
732                                 atomic_read(&dev->refcnt));
733
734                 if (msleep_interruptible(1000))
735                         flush_signals(current);
736         }
737
738         usb_put_dev(dev->udev);
739         kfree(dev);
740         ds_dev = NULL;
741 }
742
743 int ds_init(void)
744 {
745         int err;
746
747         err = usb_register(&ds_driver);
748         if (err) {
749                 printk(KERN_INFO "Failed to register DS9490R USB device: err=%d.\n", err);
750                 return err;
751         }
752
753         return 0;
754 }
755
756 void ds_fini(void)
757 {
758         usb_deregister(&ds_driver);
759 }
760
761 module_init(ds_init);
762 module_exit(ds_fini);
763
764 MODULE_LICENSE("GPL");
765 MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
766
767 EXPORT_SYMBOL(ds_touch_bit);
768 EXPORT_SYMBOL(ds_read_byte);
769 EXPORT_SYMBOL(ds_read_bit);
770 EXPORT_SYMBOL(ds_read_block);
771 EXPORT_SYMBOL(ds_write_byte);
772 EXPORT_SYMBOL(ds_write_bit);
773 EXPORT_SYMBOL(ds_write_block);
774 EXPORT_SYMBOL(ds_reset);
775 EXPORT_SYMBOL(ds_get_device);
776 EXPORT_SYMBOL(ds_put_device);
777
778 /*
779  * This functions can be used for EEPROM programming, 
780  * when driver will be included into mainline this will 
781  * require uncommenting.
782  */
783 #if 0
784 EXPORT_SYMBOL(ds_start_pulse);
785 EXPORT_SYMBOL(ds_set_speed);
786 EXPORT_SYMBOL(ds_detect);
787 EXPORT_SYMBOL(ds_stop_pulse);
788 EXPORT_SYMBOL(ds_search);
789 #endif