diff options
author | Evgeniy Polyakov <johnpol@2ka.mipt.ru> | 2005-08-11 09:27:50 -0400 |
---|---|---|
committer | Greg Kroah-Hartman <gregkh@suse.de> | 2005-09-08 17:41:27 -0400 |
commit | 80895392c83e54653540e72e7d40573aac7ee690 (patch) | |
tree | 3fb57983caf779f0648baebf18672f232a3c8c58 /drivers/w1 | |
parent | 7c8f5703de91ade517d4fd6c3cc8e08dbba2b739 (diff) |
[PATCH] w1: Added DS2433 driver.
Work by Ben Gardner <bgardner@wabtec.com>.
Signed-off-by: Evgeniy Polyakov <johnpol@2ka.mipt.ru>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Diffstat (limited to 'drivers/w1')
-rw-r--r-- | drivers/w1/Kconfig | 7 | ||||
-rw-r--r-- | drivers/w1/Makefile | 1 | ||||
-rw-r--r-- | drivers/w1/w1_ds2433.c | 222 |
3 files changed, 230 insertions, 0 deletions
diff --git a/drivers/w1/Kconfig b/drivers/w1/Kconfig index 711b90903e7b..1d5d0872eb4d 100644 --- a/drivers/w1/Kconfig +++ b/drivers/w1/Kconfig | |||
@@ -54,4 +54,11 @@ config W1_SMEM | |||
54 | Say Y here if you want to connect 1-wire | 54 | Say Y here if you want to connect 1-wire |
55 | simple 64bit memory rom(ds2401/ds2411/ds1990*) to you wire. | 55 | simple 64bit memory rom(ds2401/ds2411/ds1990*) to you wire. |
56 | 56 | ||
57 | config W1_DS2433 | ||
58 | tristate "4kb EEPROM family support (DS2433)" | ||
59 | depends on W1 | ||
60 | help | ||
61 | Say Y here if you want to use a 1-wire | ||
62 | 4kb EEPROM family device (DS2433). | ||
63 | |||
57 | endmenu | 64 | endmenu |
diff --git a/drivers/w1/Makefile b/drivers/w1/Makefile index 80725c348e70..d894a9896b18 100644 --- a/drivers/w1/Makefile +++ b/drivers/w1/Makefile | |||
@@ -18,3 +18,4 @@ ds9490r-objs := dscore.o | |||
18 | 18 | ||
19 | obj-$(CONFIG_W1_DS9490_BRIDGE) += ds_w1_bridge.o | 19 | obj-$(CONFIG_W1_DS9490_BRIDGE) += ds_w1_bridge.o |
20 | 20 | ||
21 | obj-$(CONFIG_W1_DS2433) += w1_ds2433.o | ||
diff --git a/drivers/w1/w1_ds2433.c b/drivers/w1/w1_ds2433.c new file mode 100644 index 000000000000..9ec9163a0a9b --- /dev/null +++ b/drivers/w1/w1_ds2433.c | |||
@@ -0,0 +1,222 @@ | |||
1 | /* | ||
2 | * w1_ds2433.c - w1 family 23 (DS2433) driver | ||
3 | * | ||
4 | * Copyright (c) 2005 Ben Gardner <bgardner@wabtec.com> | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or modify | ||
7 | * it under the smems of the GNU General Public License as published by | ||
8 | * the Free Software Foundation; version 2 of the License. | ||
9 | */ | ||
10 | |||
11 | #include <linux/kernel.h> | ||
12 | #include <linux/module.h> | ||
13 | #include <linux/moduleparam.h> | ||
14 | #include <linux/device.h> | ||
15 | #include <linux/types.h> | ||
16 | #include <linux/delay.h> | ||
17 | |||
18 | #include "w1.h" | ||
19 | #include "w1_io.h" | ||
20 | #include "w1_int.h" | ||
21 | #include "w1_family.h" | ||
22 | |||
23 | MODULE_LICENSE("GPL"); | ||
24 | MODULE_AUTHOR("Ben Gardner <bgardner@wabtec.com>"); | ||
25 | MODULE_DESCRIPTION("w1 family 23 driver for DS2433, 4kb EEPROM"); | ||
26 | |||
27 | #define W1_EEPROM_SIZE 512 | ||
28 | #define W1_PAGE_SIZE 32 | ||
29 | #define W1_PAGE_BITS 5 | ||
30 | #define W1_PAGE_MASK 0x1F | ||
31 | |||
32 | #define W1_F23_READ_EEPROM 0xF0 | ||
33 | #define W1_F23_WRITE_SCRATCH 0x0F | ||
34 | #define W1_F23_READ_SCRATCH 0xAA | ||
35 | #define W1_F23_COPY_SCRATCH 0x55 | ||
36 | |||
37 | /** | ||
38 | * Check the file size bounds and adjusts count as needed. | ||
39 | * This may not be needed if the sysfs layer checks bounds. | ||
40 | */ | ||
41 | static inline size_t w1_f23_fix_count(loff_t off, size_t count, size_t size) | ||
42 | { | ||
43 | if (off > size) | ||
44 | return 0; | ||
45 | |||
46 | if ((off + count) > size) | ||
47 | return (size - off); | ||
48 | |||
49 | return count; | ||
50 | } | ||
51 | |||
52 | static ssize_t w1_f23_read_bin(struct kobject *kobj, char *buf, loff_t off, size_t count) | ||
53 | { | ||
54 | struct w1_slave *sl = kobj_to_w1_slave(kobj); | ||
55 | u8 wrbuf[3]; | ||
56 | |||
57 | if ((count = w1_f23_fix_count(off, count, W1_EEPROM_SIZE)) == 0) | ||
58 | return 0; | ||
59 | |||
60 | atomic_inc(&sl->refcnt); | ||
61 | if (down_interruptible(&sl->master->mutex)) { | ||
62 | count = 0; | ||
63 | goto out_dec; | ||
64 | } | ||
65 | |||
66 | /* read directly from the EEPROM */ | ||
67 | if (w1_reset_select_slave(sl)) { | ||
68 | count = -EIO; | ||
69 | goto out_up; | ||
70 | } | ||
71 | |||
72 | wrbuf[0] = W1_F23_READ_EEPROM; | ||
73 | wrbuf[1] = off & 0xff; | ||
74 | wrbuf[2] = off >> 8; | ||
75 | w1_write_block(sl->master, wrbuf, 3); | ||
76 | w1_read_block(sl->master, buf, count); | ||
77 | |||
78 | out_up: | ||
79 | up(&sl->master->mutex); | ||
80 | out_dec: | ||
81 | atomic_dec(&sl->refcnt); | ||
82 | |||
83 | return count; | ||
84 | } | ||
85 | |||
86 | /** | ||
87 | * Writes to the scratchpad and reads it back for verification. | ||
88 | * The master must be locked. | ||
89 | * | ||
90 | * @param sl The slave structure | ||
91 | * @param addr Address for the write | ||
92 | * @param len length must be <= (W1_PAGE_SIZE - (addr & W1_PAGE_MASK)) | ||
93 | * @param data The data to write | ||
94 | * @return 0=Success -1=failure | ||
95 | */ | ||
96 | static int w1_f23_write(struct w1_slave *sl, int addr, int len, const u8 *data) | ||
97 | { | ||
98 | u8 wrbuf[4]; | ||
99 | u8 rdbuf[W1_PAGE_SIZE + 3]; | ||
100 | u8 es = (addr + len - 1) & 0x1f; | ||
101 | |||
102 | /* Write the data to the scratchpad */ | ||
103 | if (w1_reset_select_slave(sl)) | ||
104 | return -1; | ||
105 | |||
106 | wrbuf[0] = W1_F23_WRITE_SCRATCH; | ||
107 | wrbuf[1] = addr & 0xff; | ||
108 | wrbuf[2] = addr >> 8; | ||
109 | |||
110 | w1_write_block(sl->master, wrbuf, 3); | ||
111 | w1_write_block(sl->master, data, len); | ||
112 | |||
113 | /* Read the scratchpad and verify */ | ||
114 | if (w1_reset_select_slave(sl)) | ||
115 | return -1; | ||
116 | |||
117 | w1_write_8(sl->master, W1_F23_READ_SCRATCH); | ||
118 | w1_read_block(sl->master, rdbuf, len + 3); | ||
119 | |||
120 | /* Compare what was read against the data written */ | ||
121 | if ((rdbuf[0] != wrbuf[1]) || (rdbuf[1] != wrbuf[2]) || | ||
122 | (rdbuf[2] != es) || (memcmp(data, &rdbuf[3], len) != 0)) | ||
123 | return -1; | ||
124 | |||
125 | /* Copy the scratchpad to EEPROM */ | ||
126 | if (w1_reset_select_slave(sl)) | ||
127 | return -1; | ||
128 | |||
129 | wrbuf[0] = W1_F23_COPY_SCRATCH; | ||
130 | wrbuf[3] = es; | ||
131 | w1_write_block(sl->master, wrbuf, 4); | ||
132 | |||
133 | /* Sleep for 5 ms to wait for the write to complete */ | ||
134 | msleep(5); | ||
135 | |||
136 | /* Reset the bus to wake up the EEPROM (this may not be needed) */ | ||
137 | w1_reset_bus(sl->master); | ||
138 | |||
139 | return 0; | ||
140 | } | ||
141 | |||
142 | static ssize_t w1_f23_write_bin(struct kobject *kobj, char *buf, loff_t off, | ||
143 | size_t count) | ||
144 | { | ||
145 | struct w1_slave *sl = kobj_to_w1_slave(kobj); | ||
146 | int addr, len, idx; | ||
147 | |||
148 | if ((count = w1_f23_fix_count(off, count, W1_EEPROM_SIZE)) == 0) | ||
149 | return 0; | ||
150 | |||
151 | atomic_inc(&sl->refcnt); | ||
152 | if (down_interruptible(&sl->master->mutex)) { | ||
153 | count = 0; | ||
154 | goto out_dec; | ||
155 | } | ||
156 | |||
157 | /* Can only write data to one page at a time */ | ||
158 | idx = 0; | ||
159 | while (idx < count) { | ||
160 | addr = off + idx; | ||
161 | len = W1_PAGE_SIZE - (addr & W1_PAGE_MASK); | ||
162 | if (len > (count - idx)) | ||
163 | len = count - idx; | ||
164 | |||
165 | if (w1_f23_write(sl, addr, len, &buf[idx]) < 0) { | ||
166 | count = -EIO; | ||
167 | goto out_up; | ||
168 | } | ||
169 | idx += len; | ||
170 | } | ||
171 | |||
172 | out_up: | ||
173 | up(&sl->master->mutex); | ||
174 | out_dec: | ||
175 | atomic_dec(&sl->refcnt); | ||
176 | |||
177 | return count; | ||
178 | } | ||
179 | |||
180 | static struct bin_attribute w1_f23_bin_attr = { | ||
181 | .attr = { | ||
182 | .name = "eeprom", | ||
183 | .mode = S_IRUGO | S_IWUSR, | ||
184 | .owner = THIS_MODULE, | ||
185 | }, | ||
186 | .size = W1_EEPROM_SIZE, | ||
187 | .read = w1_f23_read_bin, | ||
188 | .write = w1_f23_write_bin, | ||
189 | }; | ||
190 | |||
191 | static int w1_f23_add_slave(struct w1_slave *sl) | ||
192 | { | ||
193 | return sysfs_create_bin_file(&sl->dev.kobj, &w1_f23_bin_attr); | ||
194 | } | ||
195 | |||
196 | static void w1_f23_remove_slave(struct w1_slave *sl) | ||
197 | { | ||
198 | sysfs_remove_bin_file(&sl->dev.kobj, &w1_f23_bin_attr); | ||
199 | } | ||
200 | |||
201 | static struct w1_family_ops w1_f23_fops = { | ||
202 | .add_slave = w1_f23_add_slave, | ||
203 | .remove_slave = w1_f23_remove_slave, | ||
204 | }; | ||
205 | |||
206 | static struct w1_family w1_family_23 = { | ||
207 | .fid = W1_EEPROM_DS2433, | ||
208 | .fops = &w1_f23_fops, | ||
209 | }; | ||
210 | |||
211 | static int __init w1_f23_init(void) | ||
212 | { | ||
213 | return w1_register_family(&w1_family_23); | ||
214 | } | ||
215 | |||
216 | static void __exit w1_f23_fini(void) | ||
217 | { | ||
218 | w1_unregister_family(&w1_family_23); | ||
219 | } | ||
220 | |||
221 | module_init(w1_f23_init); | ||
222 | module_exit(w1_f23_fini); | ||