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