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