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