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