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