1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
32
33#define VENDOR 0x40
34
35
36#define CONTROL_CMD 0x00
37#define COMM_CMD 0x01
38#define MODE_CMD 0x02
39
40
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
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
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
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
107#define ST_SPUA 0x01
108#define ST_PRGA 0x02
109#define ST_12VP 0x04
110#define ST_PMOD 0x08
111#define ST_HALT 0x10
112#define ST_IDLE 0x20
113#define ST_EPOF 0x80
114
115#define ST_SIZE 0x20
116
117
118#define RR_DETECT 0xA5
119#define RR_NRS 0x01
120#define RR_SH 0x02
121#define RR_APP 0x04
122#define RR_VPP 0x08
123#define RR_CMP 0x10
124#define RR_CRC 0x20
125#define RR_RDP 0x40
126#define RR_EOS 0x80
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
138struct 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
148
149
150 int spu_sleep;
151
152
153
154 u16 spu_bit;
155
156 struct w1_bus_master master;
157};
158
159struct ds_status
160{
161 u8 enable;
162 u8 speed;
163 u8 pullup_dur;
164 u8 ppuls_dur;
165 u8 pulldown_slew;
166 u8 write1_time;
167 u8 write0_time;
168 u8 reserved0;
169 u8 status;
170 u8 command0;
171 u8 command1;
172 u8 command_buffer_status;
173 u8 data_out_buffer_status;
174 u8 data_in_buffer_status;
175 u8 reserved1;
176 u8 reserved2;
177
178};
179
180static struct usb_device_id ds_id_table [] = {
181 { USB_DEVICE(0x04fa, 0x2490) },
182 { },
183};
184MODULE_DEVICE_TABLE(usb, ds_id_table);
185
186static int ds_probe(struct usb_interface *, const struct usb_device_id *);
187static void ds_disconnect(struct usb_interface *);
188
189static int ds_send_control(struct ds_device *, u16, u16);
190static int ds_send_control_cmd(struct ds_device *, u16, u16);
191
192static LIST_HEAD(ds_devices);
193static DEFINE_MUTEX(ds_mutex);
194
195static struct usb_driver ds_driver = {
196 .name = "DS9490R",
197 .probe = ds_probe,
198 .disconnect = ds_disconnect,
199 .id_table = ds_id_table,
200};
201
202static int ds_send_control_cmd(struct ds_device *dev, u16 value, u16 index)
203{
204 int err;
205
206 err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, dev->ep[EP_CONTROL]),
207 CONTROL_CMD, VENDOR, value, index, NULL, 0, 1000);
208 if (err < 0) {
209 pr_err("Failed to send command control message %x.%x: err=%d.\n",
210 value, index, err);
211 return err;
212 }
213
214 return err;
215}
216
217static int ds_send_control_mode(struct ds_device *dev, u16 value, u16 index)
218{
219 int err;
220
221 err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, dev->ep[EP_CONTROL]),
222 MODE_CMD, VENDOR, value, index, NULL, 0, 1000);
223 if (err < 0) {
224 pr_err("Failed to send mode control message %x.%x: err=%d.\n",
225 value, index, err);
226 return err;
227 }
228
229 return err;
230}
231
232static int ds_send_control(struct ds_device *dev, u16 value, u16 index)
233{
234 int err;
235
236 err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, dev->ep[EP_CONTROL]),
237 COMM_CMD, VENDOR, value, index, NULL, 0, 1000);
238 if (err < 0) {
239 pr_err("Failed to send control message %x.%x: err=%d.\n",
240 value, index, err);
241 return err;
242 }
243
244 return err;
245}
246
247static int ds_recv_status_nodump(struct ds_device *dev, struct ds_status *st,
248 unsigned char *buf, int size)
249{
250 int count, err;
251
252 memset(st, 0, sizeof(*st));
253
254 count = 0;
255 err = usb_interrupt_msg(dev->udev, usb_rcvintpipe(dev->udev,
256 dev->ep[EP_STATUS]), buf, size, &count, 1000);
257 if (err < 0) {
258 pr_err("Failed to read 1-wire data from 0x%x: err=%d.\n",
259 dev->ep[EP_STATUS], err);
260 return err;
261 }
262
263 if (count >= sizeof(*st))
264 memcpy(st, buf, sizeof(*st));
265
266 return count;
267}
268
269static inline void ds_print_msg(unsigned char *buf, unsigned char *str, int off)
270{
271 pr_info("%45s: %8x\n", str, buf[off]);
272}
273
274static void ds_dump_status(struct ds_device *dev, unsigned char *buf, int count)
275{
276 int i;
277
278 pr_info("0x%x: count=%d, status: ", dev->ep[EP_STATUS], count);
279 for (i=0; i<count; ++i)
280 pr_info("%02x ", buf[i]);
281 pr_info("\n");
282
283 if (count >= 16) {
284 ds_print_msg(buf, "enable flag", 0);
285 ds_print_msg(buf, "1-wire speed", 1);
286 ds_print_msg(buf, "strong pullup duration", 2);
287 ds_print_msg(buf, "programming pulse duration", 3);
288 ds_print_msg(buf, "pulldown slew rate control", 4);
289 ds_print_msg(buf, "write-1 low time", 5);
290 ds_print_msg(buf, "data sample offset/write-0 recovery time",
291 6);
292 ds_print_msg(buf, "reserved (test register)", 7);
293 ds_print_msg(buf, "device status flags", 8);
294 ds_print_msg(buf, "communication command byte 1", 9);
295 ds_print_msg(buf, "communication command byte 2", 10);
296 ds_print_msg(buf, "communication command buffer status", 11);
297 ds_print_msg(buf, "1-wire data output buffer status", 12);
298 ds_print_msg(buf, "1-wire data input buffer status", 13);
299 ds_print_msg(buf, "reserved", 14);
300 ds_print_msg(buf, "reserved", 15);
301 }
302 for (i = 16; i < count; ++i) {
303 if (buf[i] == RR_DETECT) {
304 ds_print_msg(buf, "new device detect", i);
305 continue;
306 }
307 ds_print_msg(buf, "Result Register Value: ", i);
308 if (buf[i] & RR_NRS)
309 pr_info("NRS: Reset no presence or ...\n");
310 if (buf[i] & RR_SH)
311 pr_info("SH: short on reset or set path\n");
312 if (buf[i] & RR_APP)
313 pr_info("APP: alarming presence on reset\n");
314 if (buf[i] & RR_VPP)
315 pr_info("VPP: 12V expected not seen\n");
316 if (buf[i] & RR_CMP)
317 pr_info("CMP: compare error\n");
318 if (buf[i] & RR_CRC)
319 pr_info("CRC: CRC error detected\n");
320 if (buf[i] & RR_RDP)
321 pr_info("RDP: redirected page\n");
322 if (buf[i] & RR_EOS)
323 pr_info("EOS: end of search error\n");
324 }
325}
326
327static void ds_reset_device(struct ds_device *dev)
328{
329 ds_send_control_cmd(dev, CTL_RESET_DEVICE, 0);
330
331
332
333 if (ds_send_control_mode(dev, MOD_PULSE_EN, PULSE_SPUE))
334 pr_err("ds_reset_device: Error allowing strong pullup\n");
335
336 if (dev->spu_sleep) {
337
338 u8 del = dev->spu_sleep>>4;
339 if (ds_send_control(dev, COMM_SET_DURATION | COMM_IM, del))
340 pr_err("ds_reset_device: Error setting duration\n");
341 }
342}
343
344static int ds_recv_data(struct ds_device *dev, unsigned char *buf, int size)
345{
346 int count, err;
347 struct ds_status st;
348
349
350
351
352
353
354
355
356
357
358 count = 0;
359 err = usb_bulk_msg(dev->udev, usb_rcvbulkpipe(dev->udev, dev->ep[EP_DATA_IN]),
360 buf, size, &count, 1000);
361 if (err < 0) {
362 u8 buf[ST_SIZE];
363 int count;
364
365 pr_info("Clearing ep0x%x.\n", dev->ep[EP_DATA_IN]);
366 usb_clear_halt(dev->udev, usb_rcvbulkpipe(dev->udev, dev->ep[EP_DATA_IN]));
367
368 count = ds_recv_status_nodump(dev, &st, buf, sizeof(buf));
369 ds_dump_status(dev, buf, count);
370 return err;
371 }
372
373#if 0
374 {
375 int i;
376
377 printk("%s: count=%d: ", __func__, count);
378 for (i=0; i<count; ++i)
379 printk("%02x ", buf[i]);
380 printk("\n");
381 }
382#endif
383 return count;
384}
385
386static int ds_send_data(struct ds_device *dev, unsigned char *buf, int len)
387{
388 int count, err;
389
390 count = 0;
391 err = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, dev->ep[EP_DATA_OUT]), buf, len, &count, 1000);
392 if (err < 0) {
393 pr_err("Failed to write 1-wire data to ep0x%x: "
394 "err=%d.\n", dev->ep[EP_DATA_OUT], err);
395 return err;
396 }
397
398 return err;
399}
400
401#if 0
402
403int ds_stop_pulse(struct ds_device *dev, int limit)
404{
405 struct ds_status st;
406 int count = 0, err = 0;
407 u8 buf[ST_SIZE];
408
409 do {
410 err = ds_send_control(dev, CTL_HALT_EXE_IDLE, 0);
411 if (err)
412 break;
413 err = ds_send_control(dev, CTL_RESUME_EXE, 0);
414 if (err)
415 break;
416 err = ds_recv_status_nodump(dev, &st, buf, sizeof(buf));
417 if (err)
418 break;
419
420 if ((st.status & ST_SPUA) == 0) {
421 err = ds_send_control_mode(dev, MOD_PULSE_EN, 0);
422 if (err)
423 break;
424 }
425 } while(++count < limit);
426
427 return err;
428}
429
430int ds_detect(struct ds_device *dev, struct ds_status *st)
431{
432 int err;
433
434 err = ds_send_control_cmd(dev, CTL_RESET_DEVICE, 0);
435 if (err)
436 return err;
437
438 err = ds_send_control(dev, COMM_SET_DURATION | COMM_IM, 0);
439 if (err)
440 return err;
441
442 err = ds_send_control(dev, COMM_SET_DURATION | COMM_IM | COMM_TYPE, 0x40);
443 if (err)
444 return err;
445
446 err = ds_send_control_mode(dev, MOD_PULSE_EN, PULSE_PROG);
447 if (err)
448 return err;
449
450 err = ds_dump_status(dev, st);
451
452 return err;
453}
454
455#endif
456
457static int ds_wait_status(struct ds_device *dev, struct ds_status *st)
458{
459 u8 buf[ST_SIZE];
460 int err, count = 0;
461
462 do {
463 st->status = 0;
464 err = ds_recv_status_nodump(dev, st, buf, sizeof(buf));
465#if 0
466 if (err >= 0) {
467 int i;
468 printk("0x%x: count=%d, status: ", dev->ep[EP_STATUS], err);
469 for (i=0; i<err; ++i)
470 printk("%02x ", buf[i]);
471 printk("\n");
472 }
473#endif
474 } while (!(st->status & ST_IDLE) && !(err < 0) && ++count < 100);
475
476 if (err >= 16 && st->status & ST_EPOF) {
477 pr_info("Resetting device after ST_EPOF.\n");
478 ds_reset_device(dev);
479
480 count = 101;
481 }
482
483
484
485
486
487 if (err > 16 || count >= 100 || err < 0)
488 ds_dump_status(dev, buf, err);
489
490
491
492
493
494 if (count >= 100 || err < 0)
495 return -1;
496 else
497 return 0;
498}
499
500static int ds_reset(struct ds_device *dev)
501{
502 int err;
503
504
505
506
507
508
509
510
511
512
513 err = ds_send_control(dev, COMM_1_WIRE_RESET | COMM_IM, SPEED_NORMAL);
514 if (err)
515 return err;
516
517 return 0;
518}
519
520#if 0
521static int ds_set_speed(struct ds_device *dev, int speed)
522{
523 int err;
524
525 if (speed != SPEED_NORMAL && speed != SPEED_FLEXIBLE && speed != SPEED_OVERDRIVE)
526 return -EINVAL;
527
528 if (speed != SPEED_OVERDRIVE)
529 speed = SPEED_FLEXIBLE;
530
531 speed &= 0xff;
532
533 err = ds_send_control_mode(dev, MOD_1WIRE_SPEED, speed);
534 if (err)
535 return err;
536
537 return err;
538}
539#endif
540
541static int ds_set_pullup(struct ds_device *dev, int delay)
542{
543 int err = 0;
544 u8 del = 1 + (u8)(delay >> 4);
545
546 int ms = del<<4;
547
548
549 dev->spu_bit = delay ? COMM_SPU : 0;
550
551
552
553
554
555 if (delay == 0 || ms == dev->spu_sleep)
556 return err;
557
558 err = ds_send_control(dev, COMM_SET_DURATION | COMM_IM, del);
559 if (err)
560 return err;
561
562 dev->spu_sleep = ms;
563
564 return err;
565}
566
567static int ds_touch_bit(struct ds_device *dev, u8 bit, u8 *tbit)
568{
569 int err;
570 struct ds_status st;
571
572 err = ds_send_control(dev, COMM_BIT_IO | COMM_IM | (bit ? COMM_D : 0),
573 0);
574 if (err)
575 return err;
576
577 ds_wait_status(dev, &st);
578
579 err = ds_recv_data(dev, tbit, sizeof(*tbit));
580 if (err < 0)
581 return err;
582
583 return 0;
584}
585
586#if 0
587static int ds_write_bit(struct ds_device *dev, u8 bit)
588{
589 int err;
590 struct ds_status st;
591
592
593
594
595
596 err = ds_send_control(dev, COMM_BIT_IO | COMM_IM | COMM_ICP |
597 (bit ? COMM_D : 0), 0);
598 if (err)
599 return err;
600
601 ds_wait_status(dev, &st);
602
603 return 0;
604}
605#endif
606
607static int ds_write_byte(struct ds_device *dev, u8 byte)
608{
609 int err;
610 struct ds_status st;
611 u8 rbyte;
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, &rbyte, sizeof(rbyte));
625 if (err < 0)
626 return err;
627
628 return !(byte == rbyte);
629}
630
631static 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
649static 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
675static 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
700static void ds9490r_search(void *data, struct w1_master *master,
701 u8 search_type, w1_slave_found_callback callback)
702{
703
704
705
706
707
708
709
710
711 struct ds_device *dev = data;
712 int err;
713 u16 value, index;
714 struct ds_status st;
715 u8 st_buf[ST_SIZE];
716 int search_limit;
717 int found = 0;
718 int i;
719
720
721
722
723 const unsigned long jtime = msecs_to_jiffies(1000*8/75);
724
725
726
727 u64 buf[2*64/8];
728
729 mutex_lock(&master->bus_mutex);
730
731
732 if (ds_send_data(dev, (u8 *)&master->search_id, 8) < 0)
733 goto search_out;
734 master->search_id = 0;
735
736 value = COMM_SEARCH_ACCESS | COMM_IM | COMM_RST | COMM_SM | COMM_F |
737 COMM_RTS;
738 search_limit = master->max_slave_count;
739 if (search_limit > 255)
740 search_limit = 0;
741 index = search_type | (search_limit << 8);
742 if (ds_send_control(dev, value, index) < 0)
743 goto search_out;
744
745 do {
746 schedule_timeout(jtime);
747
748 if (ds_recv_status_nodump(dev, &st, st_buf, sizeof(st_buf)) <
749 sizeof(st)) {
750 break;
751 }
752
753 if (st.data_in_buffer_status) {
754
755
756
757
758
759
760
761 err = ds_recv_data(dev, (u8 *)buf, sizeof(buf));
762 if (err < 0)
763 break;
764 for (i = 0; i < err/8; ++i) {
765 ++found;
766 if (found <= search_limit)
767 callback(master, buf[i]);
768
769
770 if (found == search_limit)
771 master->search_id = buf[i];
772 }
773 }
774
775 if (test_bit(W1_ABORT_SEARCH, &master->flags))
776 break;
777 } while (!(st.status & (ST_IDLE | ST_HALT)));
778
779
780 if (found <= search_limit) {
781 master->search_id = 0;
782 } else if (!test_bit(W1_WARN_MAX_COUNT, &master->flags)) {
783
784
785
786
787
788
789
790 dev_info(&dev->udev->dev, "%s: max_slave_count %d reached, "
791 "will continue next search.\n", __func__,
792 master->max_slave_count);
793 set_bit(W1_WARN_MAX_COUNT, &master->flags);
794 }
795search_out:
796 mutex_unlock(&master->bus_mutex);
797}
798
799#if 0
800static int ds_match_access(struct ds_device *dev, u64 init)
801{
802 int err;
803 struct ds_status st;
804
805 err = ds_send_data(dev, (unsigned char *)&init, sizeof(init));
806 if (err)
807 return err;
808
809 ds_wait_status(dev, &st);
810
811 err = ds_send_control(dev, COMM_MATCH_ACCESS | COMM_IM | COMM_RST, 0x0055);
812 if (err)
813 return err;
814
815 ds_wait_status(dev, &st);
816
817 return 0;
818}
819
820static int ds_set_path(struct ds_device *dev, u64 init)
821{
822 int err;
823 struct ds_status st;
824 u8 buf[9];
825
826 memcpy(buf, &init, 8);
827 buf[8] = BRANCH_MAIN;
828
829 err = ds_send_data(dev, buf, sizeof(buf));
830 if (err)
831 return err;
832
833 ds_wait_status(dev, &st);
834
835 err = ds_send_control(dev, COMM_SET_PATH | COMM_IM | COMM_RST, 0);
836 if (err)
837 return err;
838
839 ds_wait_status(dev, &st);
840
841 return 0;
842}
843
844#endif
845
846static u8 ds9490r_touch_bit(void *data, u8 bit)
847{
848 u8 ret;
849 struct ds_device *dev = data;
850
851 if (ds_touch_bit(dev, bit, &ret))
852 return 0;
853
854 return ret;
855}
856
857#if 0
858static void ds9490r_write_bit(void *data, u8 bit)
859{
860 struct ds_device *dev = data;
861
862 ds_write_bit(dev, bit);
863}
864
865static u8 ds9490r_read_bit(void *data)
866{
867 struct ds_device *dev = data;
868 int err;
869 u8 bit = 0;
870
871 err = ds_touch_bit(dev, 1, &bit);
872 if (err)
873 return 0;
874
875 return bit & 1;
876}
877#endif
878
879static void ds9490r_write_byte(void *data, u8 byte)
880{
881 struct ds_device *dev = data;
882
883 ds_write_byte(dev, byte);
884}
885
886static u8 ds9490r_read_byte(void *data)
887{
888 struct ds_device *dev = data;
889 int err;
890 u8 byte = 0;
891
892 err = ds_read_byte(dev, &byte);
893 if (err)
894 return 0;
895
896 return byte;
897}
898
899static void ds9490r_write_block(void *data, const u8 *buf, int len)
900{
901 struct ds_device *dev = data;
902
903 ds_write_block(dev, (u8 *)buf, len);
904}
905
906static u8 ds9490r_read_block(void *data, u8 *buf, int len)
907{
908 struct ds_device *dev = data;
909 int err;
910
911 err = ds_read_block(dev, buf, len);
912 if (err < 0)
913 return 0;
914
915 return len;
916}
917
918static u8 ds9490r_reset(void *data)
919{
920 struct ds_device *dev = data;
921 int err;
922
923 err = ds_reset(dev);
924 if (err)
925 return 1;
926
927 return 0;
928}
929
930static u8 ds9490r_set_pullup(void *data, int delay)
931{
932 struct ds_device *dev = data;
933
934 if (ds_set_pullup(dev, delay))
935 return 1;
936
937 return 0;
938}
939
940static int ds_w1_init(struct ds_device *dev)
941{
942 memset(&dev->master, 0, sizeof(struct w1_bus_master));
943
944
945
946
947
948
949
950
951
952
953
954 ds_reset_device(dev);
955
956 dev->master.data = dev;
957 dev->master.touch_bit = &ds9490r_touch_bit;
958
959
960
961
962
963
964
965
966
967 dev->master.read_byte = &ds9490r_read_byte;
968 dev->master.write_byte = &ds9490r_write_byte;
969 dev->master.read_block = &ds9490r_read_block;
970 dev->master.write_block = &ds9490r_write_block;
971 dev->master.reset_bus = &ds9490r_reset;
972 dev->master.set_pullup = &ds9490r_set_pullup;
973 dev->master.search = &ds9490r_search;
974
975 return w1_add_master_device(&dev->master);
976}
977
978static void ds_w1_fini(struct ds_device *dev)
979{
980 w1_remove_master_device(&dev->master);
981}
982
983static int ds_probe(struct usb_interface *intf,
984 const struct usb_device_id *udev_id)
985{
986 struct usb_device *udev = interface_to_usbdev(intf);
987 struct usb_endpoint_descriptor *endpoint;
988 struct usb_host_interface *iface_desc;
989 struct ds_device *dev;
990 int i, err, alt;
991
992 dev = kzalloc(sizeof(struct ds_device), GFP_KERNEL);
993 if (!dev) {
994 pr_info("Failed to allocate new DS9490R structure.\n");
995 return -ENOMEM;
996 }
997 dev->udev = usb_get_dev(udev);
998 if (!dev->udev) {
999 err = -ENOMEM;
1000 goto err_out_free;
1001 }
1002 memset(dev->ep, 0, sizeof(dev->ep));
1003
1004 usb_set_intfdata(intf, dev);
1005
1006 err = usb_reset_configuration(dev->udev);
1007 if (err) {
1008 dev_err(&dev->udev->dev,
1009 "Failed to reset configuration: err=%d.\n", err);
1010 goto err_out_clear;
1011 }
1012
1013
1014 alt = 3;
1015 err = usb_set_interface(dev->udev,
1016 intf->altsetting[alt].desc.bInterfaceNumber, alt);
1017 if (err) {
1018 dev_err(&dev->udev->dev, "Failed to set alternative setting %d "
1019 "for %d interface: err=%d.\n", alt,
1020 intf->altsetting[alt].desc.bInterfaceNumber, err);
1021 goto err_out_clear;
1022 }
1023
1024 iface_desc = &intf->altsetting[alt];
1025 if (iface_desc->desc.bNumEndpoints != NUM_EP-1) {
1026 pr_info("Num endpoints=%d. It is not DS9490R.\n",
1027 iface_desc->desc.bNumEndpoints);
1028 err = -EINVAL;
1029 goto err_out_clear;
1030 }
1031
1032
1033
1034
1035
1036 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1037 endpoint = &iface_desc->endpoint[i].desc;
1038
1039 dev->ep[i+1] = endpoint->bEndpointAddress;
1040#if 0
1041 printk("%d: addr=%x, size=%d, dir=%s, type=%x\n",
1042 i, endpoint->bEndpointAddress, le16_to_cpu(endpoint->wMaxPacketSize),
1043 (endpoint->bEndpointAddress & USB_DIR_IN)?"IN":"OUT",
1044 endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
1045#endif
1046 }
1047
1048 err = ds_w1_init(dev);
1049 if (err)
1050 goto err_out_clear;
1051
1052 mutex_lock(&ds_mutex);
1053 list_add_tail(&dev->ds_entry, &ds_devices);
1054 mutex_unlock(&ds_mutex);
1055
1056 return 0;
1057
1058err_out_clear:
1059 usb_set_intfdata(intf, NULL);
1060 usb_put_dev(dev->udev);
1061err_out_free:
1062 kfree(dev);
1063 return err;
1064}
1065
1066static void ds_disconnect(struct usb_interface *intf)
1067{
1068 struct ds_device *dev;
1069
1070 dev = usb_get_intfdata(intf);
1071 if (!dev)
1072 return;
1073
1074 mutex_lock(&ds_mutex);
1075 list_del(&dev->ds_entry);
1076 mutex_unlock(&ds_mutex);
1077
1078 ds_w1_fini(dev);
1079
1080 usb_set_intfdata(intf, NULL);
1081
1082 usb_put_dev(dev->udev);
1083 kfree(dev);
1084}
1085
1086module_usb_driver(ds_driver);
1087
1088MODULE_LICENSE("GPL");
1089MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
1090MODULE_DESCRIPTION("DS2490 USB <-> W1 bus master driver (DS9490*)");
1091