1/* 2 * dscore.c 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/* 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 132struct 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 153struct 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 174static struct usb_device_id ds_id_table [] = { 175 { USB_DEVICE(0x04fa, 0x2490) }, 176 { }, 177}; 178MODULE_DEVICE_TABLE(usb, ds_id_table); 179 180static int ds_probe(struct usb_interface *, const struct usb_device_id *); 181static void ds_disconnect(struct usb_interface *); 182 183static int ds_send_control(struct ds_device *, u16, u16); 184static int ds_send_control_cmd(struct ds_device *, u16, u16); 185 186static LIST_HEAD(ds_devices); 187static DEFINE_MUTEX(ds_mutex); 188 189static struct usb_driver ds_driver = { 190 .name = "DS9490R", 191 .probe = ds_probe, 192 .disconnect = ds_disconnect, 193 .id_table = ds_id_table, 194}; 195 196static 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 211static 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 226static 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 241static 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 261static 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 266static 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 319static 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 338static 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 380static 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 397int 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 424int 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 451static 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 493static 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 514static 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 534static 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 560static 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 580static 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 600static 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 624static 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 642static 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 668static 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 695static 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 724static 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 744static 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 770static 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 782static void ds9490r_write_bit(void *data, u8 bit) 783{ 784 struct ds_device *dev = data; 785 786 ds_write_bit(dev, bit); 787} 788 789static 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 803static void ds9490r_write_byte(void *data, u8 byte) 804{ 805 struct ds_device *dev = data; 806 807 ds_write_byte(dev, byte); 808} 809 810static 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 823static 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 830static 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 842static 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 854static 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 864static 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 901static void ds_w1_fini(struct ds_device *dev) 902{ 903 w1_remove_master_device(&dev->master); 904} 905 906static 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 977err_out_clear: 978 usb_set_intfdata(intf, NULL); 979 usb_put_dev(dev->udev); 980err_out_free: 981 kfree(dev); 982 return err; 983} 984 985static 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 1005module_usb_driver(ds_driver); 1006 1007MODULE_LICENSE("GPL"); 1008MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>"); 1009MODULE_DESCRIPTION("DS2490 USB <-> W1 bus master driver (DS9490*)"); 1010