Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/w1/masters/ds2490.c

  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 
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 module_usb_driver(ds_driver);
1006 
1007 MODULE_LICENSE("GPL");
1008 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
1009 MODULE_DESCRIPTION("DS2490 USB <-> W1 bus master driver (DS9490*)");
1010 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us