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