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