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