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