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