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