tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
w1: format for DocBook and fixes
Switch the code documentation format style to DocBook format, enable
DocBook documentation generation, and fix some comments.
Signed-off-by: David Fries <David@Fries.net>
Acked-by: Evgeniy Polyakov <zbr@ioremap.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
authored by
David Fries
and committed by
Greg Kroah-Hartman
b3be177a
eb2c0da4
+315
-99
+1
-1
Documentation/DocBook/Makefile
+1
-1
Documentation/DocBook/Makefile
···
14
14
genericirq.xml s390-drivers.xml uio-howto.xml scsi.xml \
15
15
80211.xml debugobjects.xml sh.xml regulator.xml \
16
16
alsa-driver-api.xml writing-an-alsa-driver.xml \
17
-
tracepoint.xml drm.xml media_api.xml
17
+
tracepoint.xml drm.xml media_api.xml w1.xml
18
18
19
19
include $(srctree)/Documentation/DocBook/media/Makefile
20
20
+101
Documentation/DocBook/w1.tmpl
+101
Documentation/DocBook/w1.tmpl
···
1
+
<?xml version="1.0" encoding="UTF-8"?>
2
+
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
3
+
"http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" []>
4
+
5
+
<book id="w1id">
6
+
<bookinfo>
7
+
<title>W1: Dallas' 1-wire bus</title>
8
+
9
+
<authorgroup>
10
+
<author>
11
+
<firstname>David</firstname>
12
+
<surname>Fries</surname>
13
+
<affiliation>
14
+
<address>
15
+
<email>David@Fries.net</email>
16
+
</address>
17
+
</affiliation>
18
+
</author>
19
+
20
+
</authorgroup>
21
+
22
+
<copyright>
23
+
<year>2013</year>
24
+
<!--
25
+
<holder></holder>
26
+
-->
27
+
</copyright>
28
+
29
+
<legalnotice>
30
+
<para>
31
+
This documentation is free software; you can redistribute
32
+
it and/or modify it under the terms of the GNU General Public
33
+
License version 2.
34
+
</para>
35
+
36
+
<para>
37
+
This program is distributed in the hope that it will be
38
+
useful, but WITHOUT ANY WARRANTY; without even the implied
39
+
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
40
+
For more details see the file COPYING in the source
41
+
distribution of Linux.
42
+
</para>
43
+
</legalnotice>
44
+
</bookinfo>
45
+
46
+
<toc></toc>
47
+
48
+
<chapter id="w1_internal">
49
+
<title>W1 API internal to the kernel</title>
50
+
51
+
<sect1 id="w1_internal_api">
52
+
<title>W1 API internal to the kernel</title>
53
+
<sect2 id="w1.h">
54
+
<title>drivers/w1/w1.h</title>
55
+
<para>W1 core functions.</para>
56
+
!Idrivers/w1/w1.h
57
+
</sect2>
58
+
59
+
<sect2 id="w1.c">
60
+
<title>drivers/w1/w1.c</title>
61
+
<para>W1 core functions.</para>
62
+
!Idrivers/w1/w1.c
63
+
</sect2>
64
+
65
+
<sect2 id="w1_family.h">
66
+
<title>drivers/w1/w1_family.h</title>
67
+
<para>Allows registering device family operations.</para>
68
+
!Idrivers/w1/w1_family.h
69
+
</sect2>
70
+
71
+
<sect2 id="w1_family.c">
72
+
<title>drivers/w1/w1_family.c</title>
73
+
<para>Allows registering device family operations.</para>
74
+
!Edrivers/w1/w1_family.c
75
+
</sect2>
76
+
77
+
<sect2 id="w1_int.c">
78
+
<title>drivers/w1/w1_int.c</title>
79
+
<para>W1 internal initialization for master devices.</para>
80
+
!Edrivers/w1/w1_int.c
81
+
</sect2>
82
+
83
+
<sect2 id="w1_netlink.h">
84
+
<title>drivers/w1/w1_netlink.h</title>
85
+
<para>W1 external netlink API structures and commands.</para>
86
+
!Idrivers/w1/w1_netlink.h
87
+
</sect2>
88
+
89
+
<sect2 id="w1_io.c">
90
+
<title>drivers/w1/w1_io.c</title>
91
+
<para>W1 input/output.</para>
92
+
!Edrivers/w1/w1_io.c
93
+
!Idrivers/w1/w1_io.c
94
+
</sect2>
95
+
96
+
</sect1>
97
+
98
+
99
+
</chapter>
100
+
101
+
</book>
+4
-4
Documentation/w1/w1.netlink
+4
-4
Documentation/w1/w1.netlink
···
5
5
=============
6
6
7
7
There are three types of messages between w1 core and userspace:
8
-
1. Events. They are generated each time new master or slave device
9
-
found either due to automatic or requested search.
8
+
1. Events. They are generated each time a new master or slave device
9
+
is found either due to automatic or requested search.
10
10
2. Userspace commands.
11
11
3. Replies to userspace commands.
12
12
···
131
131
of the sizeof(struct w1_netlink_msg) and sizeof(struct w1_netlink_cmd).
132
132
If reply is generated for master or root command (which do not have
133
133
w1_netlink_cmd attached), reply will contain only cn_msg and w1_netlink_msg
134
-
structires.
134
+
structures.
135
135
136
136
w1_netlink_msg.status field will carry positive error value
137
137
(EINVAL for example) or zero in case of success.
···
160
160
Then all requested in w1_netlink_msg operations are performed one by one.
161
161
If command requires reply (like read command) it is sent on command completion.
162
162
163
-
When all commands (w1_netlink_cmd) are processed muster device is unlocked
163
+
When all commands (w1_netlink_cmd) are processed master device is unlocked
164
164
and next w1_netlink_msg header processing started.
165
165
166
166
+26
-4
drivers/w1/w1.c
+26
-4
drivers/w1/w1.c
···
50
50
int w1_max_slave_ttl = 10;
51
51
52
52
module_param_named(timeout, w1_timeout, int, 0);
53
+
MODULE_PARM_DESC(timeout, "time in seconds between automatic slave searches");
54
+
/* A search stops when w1_max_slave_count devices have been found in that
55
+
* search. The next search will start over and detect the same set of devices
56
+
* on a static 1-wire bus. Memory is not allocated based on this number, just
57
+
* on the number of devices known to the kernel. Having a high number does not
58
+
* consume additional resources. As a special case, if there is only one
59
+
* device on the network and w1_max_slave_count is set to 1, the device id can
60
+
* be read directly skipping the normal slower search process.
61
+
*/
53
62
module_param_named(max_slave_count, w1_max_slave_count, int, 0);
63
+
MODULE_PARM_DESC(max_slave_count,
64
+
"maximum number of slaves detected in a search");
54
65
module_param_named(slave_ttl, w1_max_slave_ttl, int, 0);
66
+
MODULE_PARM_DESC(slave_ttl,
67
+
"Number of searches not seeing a slave before it will be removed");
55
68
56
69
DEFINE_MUTEX(w1_mlock);
57
70
LIST_HEAD(w1_masters);
···
933
920
}
934
921
935
922
/**
936
-
* Performs a ROM Search & registers any devices found.
923
+
* w1_search() - Performs a ROM Search & registers any devices found.
924
+
* @dev: The master device to search
925
+
* @search_type: W1_SEARCH to search all devices, or W1_ALARM_SEARCH
926
+
* to return only devices in the alarmed state
927
+
* @cb: Function to call when a device is found
928
+
*
937
929
* The 1-wire search is a simple binary tree search.
938
930
* For each bit of the address, we read two bits and write one bit.
939
931
* The bit written will put to sleep all devies that don't match that bit.
···
948
930
*
949
931
* See "Application note 187 1-wire search algorithm" at www.maxim-ic.com
950
932
*
951
-
* @dev The master device to search
952
-
* @cb Function to call when a device is found
953
933
*/
954
934
void w1_search(struct w1_master *dev, u8 search_type, w1_slave_found_callback cb)
955
935
{
···
1006
990
else
1007
991
search_bit = ((last_rn >> i) & 0x1);
1008
992
1009
-
/** Read two bits and write one bit */
993
+
/* Read two bits and write one bit */
1010
994
triplet_ret = w1_triplet(dev, search_bit);
1011
995
1012
996
/* quit if no device responded */
···
1090
1074
w1_search_process_cb(dev, search_type, w1_slave_found);
1091
1075
}
1092
1076
1077
+
/**
1078
+
* w1_process_callbacks() - execute each dev->async_list callback entry
1079
+
* @dev: w1_master device
1080
+
*
1081
+
* Return: 1 if there were commands to executed 0 otherwise
1082
+
*/
1093
1083
int w1_process_callbacks(struct w1_master *dev)
1094
1084
{
1095
1085
int ret = 0;
+93
-43
drivers/w1/w1.h
+93
-43
drivers/w1/w1.h
···
22
22
#ifndef __W1_H
23
23
#define __W1_H
24
24
25
+
/**
26
+
* struct w1_reg_num - broken out slave device id
27
+
*
28
+
* @family: identifies the type of device
29
+
* @id: along with family is the unique device id
30
+
* @crc: checksum of the other bytes
31
+
*/
25
32
struct w1_reg_num
26
33
{
27
34
#if defined(__LITTLE_ENDIAN_BITFIELD)
···
67
60
#define W1_SLAVE_ACTIVE 0
68
61
#define W1_SLAVE_DETACH 1
69
62
63
+
/**
64
+
* struct w1_slave - holds a single slave device on the bus
65
+
*
66
+
* @owner: Points to the one wire "wire" kernel module.
67
+
* @name: Device id is ascii.
68
+
* @w1_slave_entry: data for the linked list
69
+
* @reg_num: the slave id in binary
70
+
* @refcnt: reference count, delete when 0
71
+
* @flags: bit flags for W1_SLAVE_ACTIVE W1_SLAVE_DETACH
72
+
* @ttl: decrement per search this slave isn't found, deatch at 0
73
+
* @master: bus which this slave is on
74
+
* @family: module for device family type
75
+
* @family_data: pointer for use by the family module
76
+
* @dev: kernel device identifier
77
+
*
78
+
*/
70
79
struct w1_slave
71
80
{
72
81
struct module *owner;
···
103
80
104
81
105
82
/**
83
+
* struct w1_bus_master - operations available on a bus master
84
+
*
85
+
* @data: the first parameter in all the functions below
86
+
*
87
+
* @read_bit: Sample the line level @return the level read (0 or 1)
88
+
*
89
+
* @write_bit: Sets the line level
90
+
*
91
+
* @touch_bit: the lowest-level function for devices that really support the
92
+
* 1-wire protocol.
93
+
* touch_bit(0) = write-0 cycle
94
+
* touch_bit(1) = write-1 / read cycle
95
+
* @return the bit read (0 or 1)
96
+
*
97
+
* @read_byte: Reads a bytes. Same as 8 touch_bit(1) calls.
98
+
* @return the byte read
99
+
*
100
+
* @write_byte: Writes a byte. Same as 8 touch_bit(x) calls.
101
+
*
102
+
* @read_block: Same as a series of read_byte() calls
103
+
* @return the number of bytes read
104
+
*
105
+
* @write_block: Same as a series of write_byte() calls
106
+
*
107
+
* @triplet: Combines two reads and a smart write for ROM searches
108
+
* @return bit0=Id bit1=comp_id bit2=dir_taken
109
+
*
110
+
* @reset_bus: long write-0 with a read for the presence pulse detection
111
+
* @return -1=Error, 0=Device present, 1=No device present
112
+
*
113
+
* @set_pullup: Put out a strong pull-up pulse of the specified duration.
114
+
* @return -1=Error, 0=completed
115
+
*
116
+
* @search: Really nice hardware can handles the different types of ROM search
117
+
* w1_master* is passed to the slave found callback.
118
+
* u8 is search_type, W1_SEARCH or W1_ALARM_SEARCH
119
+
*
106
120
* Note: read_bit and write_bit are very low level functions and should only
107
121
* be used with hardware that doesn't really support 1-wire operations,
108
122
* like a parallel/serial port.
109
123
* Either define read_bit and write_bit OR define, at minimum, touch_bit and
110
124
* reset_bus.
125
+
*
111
126
*/
112
127
struct w1_bus_master
113
128
{
114
-
/** the first parameter in all the functions below */
115
129
void *data;
116
130
117
-
/**
118
-
* Sample the line level
119
-
* @return the level read (0 or 1)
120
-
*/
121
131
u8 (*read_bit)(void *);
122
132
123
-
/** Sets the line level */
124
133
void (*write_bit)(void *, u8);
125
134
126
-
/**
127
-
* touch_bit is the lowest-level function for devices that really
128
-
* support the 1-wire protocol.
129
-
* touch_bit(0) = write-0 cycle
130
-
* touch_bit(1) = write-1 / read cycle
131
-
* @return the bit read (0 or 1)
132
-
*/
133
135
u8 (*touch_bit)(void *, u8);
134
136
135
-
/**
136
-
* Reads a bytes. Same as 8 touch_bit(1) calls.
137
-
* @return the byte read
138
-
*/
139
137
u8 (*read_byte)(void *);
140
138
141
-
/**
142
-
* Writes a byte. Same as 8 touch_bit(x) calls.
143
-
*/
144
139
void (*write_byte)(void *, u8);
145
140
146
-
/**
147
-
* Same as a series of read_byte() calls
148
-
* @return the number of bytes read
149
-
*/
150
141
u8 (*read_block)(void *, u8 *, int);
151
142
152
-
/** Same as a series of write_byte() calls */
153
143
void (*write_block)(void *, const u8 *, int);
154
144
155
-
/**
156
-
* Combines two reads and a smart write for ROM searches
157
-
* @return bit0=Id bit1=comp_id bit2=dir_taken
158
-
*/
159
145
u8 (*triplet)(void *, u8);
160
146
161
-
/**
162
-
* long write-0 with a read for the presence pulse detection
163
-
* @return -1=Error, 0=Device present, 1=No device present
164
-
*/
165
147
u8 (*reset_bus)(void *);
166
148
167
-
/**
168
-
* Put out a strong pull-up pulse of the specified duration.
169
-
* @return -1=Error, 0=completed
170
-
*/
171
149
u8 (*set_pullup)(void *, int);
172
150
173
-
/** Really nice hardware can handles the different types of ROM search
174
-
* w1_master* is passed to the slave found callback.
175
-
* u8 is search_type, W1_SEARCH or W1_ALARM_SEARCH
176
-
*/
177
151
void (*search)(void *, struct w1_master *,
178
152
u8, w1_slave_found_callback);
179
153
};
···
185
165
W1_WARN_MAX_COUNT = 1,
186
166
};
187
167
168
+
/**
169
+
* struct w1_master - one per bus master
170
+
* @w1_master_entry: master linked list
171
+
* @owner: module owner
172
+
* @name: dynamically allocate bus name
173
+
* @list_mutex: protect slist and async_list
174
+
* @slist: linked list of slaves
175
+
* @async_list: linked list of netlink commands to execute
176
+
* @max_slave_count: maximum number of slaves to search for at a time
177
+
* @slave_count: current number of slaves known
178
+
* @attempts: number of searches ran
179
+
* @slave_ttl: number of searches before a slave is timed out
180
+
* @initialized: prevent init/removal race conditions
181
+
* @id: w1 bus number
182
+
* @search_count: number of automatic searches to run, -1 unlimited
183
+
* @search_id: allows continuing a search
184
+
* @refcnt: reference count
185
+
* @priv: private data storage
186
+
* @priv_size: size allocated
187
+
* @enable_pullup: allows a strong pullup
188
+
* @pullup_duration: time for the next strong pullup
189
+
* @flags: one of w1_master_flags
190
+
* @thread: thread for bus search and netlink commands
191
+
* @mutex: protect most of w1_master
192
+
* @bus_mutex: pretect concurrent bus access
193
+
* @driver: sysfs driver
194
+
* @dev: sysfs device
195
+
* @bus_master: io operations available
196
+
* @seq: sequence number used for netlink broadcasts
197
+
* @portid: destination for the current netlink command
198
+
*/
188
199
struct w1_master
189
200
{
190
201
struct list_head w1_master_entry;
···
224
173
/* list_mutex protects just slist and async_list so slaves can be
225
174
* searched for and async commands added while the master has
226
175
* w1_master.mutex locked and is operating on the bus.
227
-
* lock order w1_mlock, w1_master.mutex, w1_master_list_mutex
176
+
* lock order w1_mlock, w1_master.mutex, w1_master.list_mutex
228
177
*/
229
178
struct mutex list_mutex;
230
179
struct list_head slist;
···
341
290
extern struct list_head w1_masters;
342
291
extern struct mutex w1_mlock;
343
292
344
-
/* returns 1 if there were commands to executed 0 otherwise */
345
293
extern int w1_process_callbacks(struct w1_master *dev);
346
294
extern int w1_process(void *);
347
295
+8
drivers/w1/w1_family.c
+8
drivers/w1/w1_family.c
···
31
31
DEFINE_SPINLOCK(w1_flock);
32
32
static LIST_HEAD(w1_families);
33
33
34
+
/**
35
+
* w1_register_family() - register a device family driver
36
+
* @newf: family to register
37
+
*/
34
38
int w1_register_family(struct w1_family *newf)
35
39
{
36
40
struct list_head *ent, *n;
···
63
59
return ret;
64
60
}
65
61
62
+
/**
63
+
* w1_unregister_family() - unregister a device family driver
64
+
* @fent: family to unregister
65
+
*/
66
66
void w1_unregister_family(struct w1_family *fent)
67
67
{
68
68
struct list_head *ent, *n;
+13
drivers/w1/w1_family.h
+13
drivers/w1/w1_family.h
···
48
48
49
49
struct w1_slave;
50
50
51
+
/**
52
+
* struct w1_family_ops - operations for a family type
53
+
* @add_slave: add_slave
54
+
* @remove_slave: remove_slave
55
+
* @groups: sysfs group
56
+
*/
51
57
struct w1_family_ops
52
58
{
53
59
int (* add_slave)(struct w1_slave *);
···
61
55
const struct attribute_group **groups;
62
56
};
63
57
58
+
/**
59
+
* struct w1_family - reference counted family structure.
60
+
* @family_entry: family linked list
61
+
* @fid: 8 bit family identifier
62
+
* @fops: operations for this family
63
+
* @refcnt: reference counter
64
+
*/
64
65
struct w1_family
65
66
{
66
67
struct list_head family_entry;
+8
drivers/w1/w1_int.c
+8
drivers/w1/w1_int.c
···
105
105
device_unregister(&dev->dev);
106
106
}
107
107
108
+
/**
109
+
* w1_add_master_device() - registers a new master device
110
+
* @master: master bus device to register
111
+
*/
108
112
int w1_add_master_device(struct w1_bus_master *master)
109
113
{
110
114
struct w1_master *dev, *entry;
···
231
227
w1_free_dev(dev);
232
228
}
233
229
230
+
/**
231
+
* w1_remove_master_device() - unregister a master device
232
+
* @bm: master bus device to remove
233
+
*/
234
234
void w1_remove_master_device(struct w1_bus_master *bm)
235
235
{
236
236
struct w1_master *dev, *found = NULL;
+57
-45
drivers/w1/w1_io.c
+57
-45
drivers/w1/w1_io.c
···
62
62
static u8 w1_read_bit(struct w1_master *dev);
63
63
64
64
/**
65
-
* Generates a write-0 or write-1 cycle and samples the level.
65
+
* w1_touch_bit() - Generates a write-0 or write-1 cycle and samples the level.
66
+
* @dev: the master device
67
+
* @bit: 0 - write a 0, 1 - write a 0 read the level
66
68
*/
67
69
static u8 w1_touch_bit(struct w1_master *dev, int bit)
68
70
{
···
79
77
}
80
78
81
79
/**
82
-
* Generates a write-0 or write-1 cycle.
80
+
* w1_write_bit() - Generates a write-0 or write-1 cycle.
81
+
* @dev: the master device
82
+
* @bit: bit to write
83
+
*
83
84
* Only call if dev->bus_master->touch_bit is NULL
84
85
*/
85
86
static void w1_write_bit(struct w1_master *dev, int bit)
···
107
102
}
108
103
109
104
/**
105
+
* w1_pre_write() - pre-write operations
106
+
* @dev: the master device
107
+
*
110
108
* Pre-write operation, currently only supporting strong pullups.
111
109
* Program the hardware for a strong pullup, if one has been requested and
112
110
* the hardware supports it.
113
-
*
114
-
* @param dev the master device
115
111
*/
116
112
static void w1_pre_write(struct w1_master *dev)
117
113
{
···
124
118
}
125
119
126
120
/**
121
+
* w1_post_write() - post-write options
122
+
* @dev: the master device
123
+
*
127
124
* Post-write operation, currently only supporting strong pullups.
128
125
* If a strong pullup was requested, clear it if the hardware supports
129
126
* them, or execute the delay otherwise, in either case clear the request.
130
-
*
131
-
* @param dev the master device
132
127
*/
133
128
static void w1_post_write(struct w1_master *dev)
134
129
{
···
143
136
}
144
137
145
138
/**
146
-
* Writes 8 bits.
147
-
*
148
-
* @param dev the master device
149
-
* @param byte the byte to write
139
+
* w1_write_8() - Writes 8 bits.
140
+
* @dev: the master device
141
+
* @byte: the byte to write
150
142
*/
151
143
void w1_write_8(struct w1_master *dev, u8 byte)
152
144
{
···
167
161
168
162
169
163
/**
170
-
* Generates a write-1 cycle and samples the level.
164
+
* w1_read_bit() - Generates a write-1 cycle and samples the level.
165
+
* @dev: the master device
166
+
*
171
167
* Only call if dev->bus_master->touch_bit is NULL
172
168
*/
173
169
static u8 w1_read_bit(struct w1_master *dev)
···
193
185
}
194
186
195
187
/**
196
-
* Does a triplet - used for searching ROM addresses.
188
+
* w1_triplet() - * Does a triplet - used for searching ROM addresses.
189
+
* @dev: the master device
190
+
* @bdir: the bit to write if both id_bit and comp_bit are 0
191
+
*
197
192
* Return bits:
198
193
* bit 0 = id_bit
199
194
* bit 1 = comp_bit
200
195
* bit 2 = dir_taken
201
196
* If both bits 0 & 1 are set, the search should be restarted.
202
197
*
203
-
* @param dev the master device
204
-
* @param bdir the bit to write if both id_bit and comp_bit are 0
205
-
* @return bit fields - see above
198
+
* Return: bit fields - see above
206
199
*/
207
200
u8 w1_triplet(struct w1_master *dev, int bdir)
208
201
{
···
235
226
}
236
227
237
228
/**
238
-
* Reads 8 bits.
229
+
* w1_read_8() - Reads 8 bits.
230
+
* @dev: the master device
239
231
*
240
-
* @param dev the master device
241
-
* @return the byte read
232
+
* Return: the byte read
242
233
*/
243
234
u8 w1_read_8(struct w1_master *dev)
244
235
{
···
256
247
EXPORT_SYMBOL_GPL(w1_read_8);
257
248
258
249
/**
259
-
* Writes a series of bytes.
260
-
*
261
-
* @param dev the master device
262
-
* @param buf pointer to the data to write
263
-
* @param len the number of bytes to write
250
+
* w1_write_block() - Writes a series of bytes.
251
+
* @dev: the master device
252
+
* @buf: pointer to the data to write
253
+
* @len: the number of bytes to write
264
254
*/
265
255
void w1_write_block(struct w1_master *dev, const u8 *buf, int len)
266
256
{
···
277
269
EXPORT_SYMBOL_GPL(w1_write_block);
278
270
279
271
/**
280
-
* Touches a series of bytes.
281
-
*
282
-
* @param dev the master device
283
-
* @param buf pointer to the data to write
284
-
* @param len the number of bytes to write
272
+
* w1_touch_block() - Touches a series of bytes.
273
+
* @dev: the master device
274
+
* @buf: pointer to the data to write
275
+
* @len: the number of bytes to write
285
276
*/
286
277
void w1_touch_block(struct w1_master *dev, u8 *buf, int len)
287
278
{
···
301
294
EXPORT_SYMBOL_GPL(w1_touch_block);
302
295
303
296
/**
304
-
* Reads a series of bytes.
305
-
*
306
-
* @param dev the master device
307
-
* @param buf pointer to the buffer to fill
308
-
* @param len the number of bytes to read
309
-
* @return the number of bytes read
297
+
* w1_read_block() - Reads a series of bytes.
298
+
* @dev: the master device
299
+
* @buf: pointer to the buffer to fill
300
+
* @len: the number of bytes to read
301
+
* Return: the number of bytes read
310
302
*/
311
303
u8 w1_read_block(struct w1_master *dev, u8 *buf, int len)
312
304
{
···
325
319
EXPORT_SYMBOL_GPL(w1_read_block);
326
320
327
321
/**
328
-
* Issues a reset bus sequence.
329
-
*
330
-
* @param dev The bus master pointer
331
-
* @return 0=Device present, 1=No device present or error
322
+
* w1_reset_bus() - Issues a reset bus sequence.
323
+
* @dev: the master device
324
+
* Return: 0=Device present, 1=No device present or error
332
325
*/
333
326
int w1_reset_bus(struct w1_master *dev)
334
327
{
···
388
383
}
389
384
390
385
/**
386
+
* w1_reset_select_slave() - reset and select a slave
387
+
* @sl: the slave to select
388
+
*
391
389
* Resets the bus and then selects the slave by sending either a skip rom
392
-
* or a rom match.
390
+
* or a rom match. A skip rom is issued if there is only one device
391
+
* registered on the bus.
393
392
* The w1 master lock must be held.
394
393
*
395
-
* @param sl the slave to select
396
-
* @return 0=success, anything else=error
394
+
* Return: 0=success, anything else=error
397
395
*/
398
396
int w1_reset_select_slave(struct w1_slave *sl)
399
397
{
···
417
409
EXPORT_SYMBOL_GPL(w1_reset_select_slave);
418
410
419
411
/**
412
+
* w1_reset_resume_command() - resume instead of another match ROM
413
+
* @dev: the master device
414
+
*
420
415
* When the workflow with a slave amongst many requires several
421
416
* successive commands a reset between each, this function is similar
422
417
* to doing a reset then a match ROM for the last matched ROM. The
···
431
420
* doesn't work of course, but the resume command is the next best thing.
432
421
*
433
422
* The w1 master lock must be held.
434
-
*
435
-
* @param dev the master device
436
423
*/
437
424
int w1_reset_resume_command(struct w1_master *dev)
438
425
{
···
444
435
EXPORT_SYMBOL_GPL(w1_reset_resume_command);
445
436
446
437
/**
438
+
* w1_next_pullup() - register for a strong pullup
439
+
* @dev: the master device
440
+
* @delay: time in milliseconds
441
+
*
447
442
* Put out a strong pull-up of the specified duration after the next write
448
443
* operation. Not all hardware supports strong pullups. Hardware that
449
444
* doesn't support strong pullups will sleep for the given time after the
···
455
442
* the next write, specifying zero will clear a previous request.
456
443
* The w1 master lock must be held.
457
444
*
458
-
* @param delay time in milliseconds
459
-
* @return 0=success, anything else=error
445
+
* Return: 0=success, anything else=error
460
446
*/
461
447
void w1_next_pullup(struct w1_master *dev, int delay)
462
448
{
+4
-2
drivers/w1/w1_netlink.h
+4
-2
drivers/w1/w1_netlink.h
···
27
27
28
28
#include "w1.h"
29
29
30
-
/** enum w1_netlink_message_types - message type
30
+
/**
31
+
* enum w1_netlink_message_types - message type
31
32
*
32
33
* @W1_SLAVE_ADD: notification that a slave device was added
33
34
* @W1_SLAVE_REMOVE: notification that a slave device was removed
···
64
63
__u8 data[0];
65
64
};
66
65
67
-
/** enum w1_commands - commands available for master or slave operations
66
+
/**
67
+
* enum w1_commands - commands available for master or slave operations
68
68
* @W1_CMD_READ: read len bytes
69
69
* @W1_CMD_WRITE: write len bytes
70
70
* @W1_CMD_SEARCH: initiate a standard search, returns only the slave