1 /* 2 * linux/drivers/char/ds1620.c: Dallas Semiconductors DS1620 3 * thermometer driver (as used in the Rebel.com NetWinder) 4 */ 5 #include <linux/module.h> 6 #include <linux/miscdevice.h> 7 #include <linux/smp_lock.h> 8 #include <linux/delay.h> 9 #include <linux/proc_fs.h> 10 #include <linux/capability.h> 11 #include <linux/init.h> 12 13 #include <asm/hardware.h> 14 #include <asm/mach-types.h> 15 #include <asm/uaccess.h> 16 #include <asm/therm.h> 17 18 #ifdef CONFIG_PROC_FS 19 /* define for /proc interface */ 20 #define THERM_USE_PROC 21 #endif 22 23 /* Definitions for DS1620 chip */ 24 #define THERM_START_CONVERT 0xee 25 #define THERM_RESET 0xaf 26 #define THERM_READ_CONFIG 0xac 27 #define THERM_READ_TEMP 0xaa 28 #define THERM_READ_TL 0xa2 29 #define THERM_READ_TH 0xa1 30 #define THERM_WRITE_CONFIG 0x0c 31 #define THERM_WRITE_TL 0x02 32 #define THERM_WRITE_TH 0x01 33 34 #define CFG_CPU 2 35 #define CFG_1SHOT 1 36 37 static const char *fan_state[] = { "off", "on", "on (hardwired)" }; 38 39 /* 40 * Start of NetWinder specifics 41 * Note! We have to hold the gpio lock with IRQs disabled over the 42 * whole of our transaction to the Dallas chip, since there is a 43 * chance that the WaveArtist driver could touch these bits to 44 * enable or disable the speaker. 45 */ 46 extern spinlock_t gpio_lock; 47 extern unsigned int system_rev; 48 49 static inline void netwinder_ds1620_set_clk(int clk) 50 { 51 gpio_modify_op(GPIO_DSCLK, clk ? GPIO_DSCLK : 0); 52 } 53 54 static inline void netwinder_ds1620_set_data(int dat) 55 { 56 gpio_modify_op(GPIO_DATA, dat ? GPIO_DATA : 0); 57 } 58 59 static inline int netwinder_ds1620_get_data(void) 60 { 61 return gpio_read() & GPIO_DATA; 62 } 63 64 static inline void netwinder_ds1620_set_data_dir(int dir) 65 { 66 gpio_modify_io(GPIO_DATA, dir ? GPIO_DATA : 0); 67 } 68 69 static inline void netwinder_ds1620_reset(void) 70 { 71 cpld_modify(CPLD_DS_ENABLE, 0); 72 cpld_modify(CPLD_DS_ENABLE, CPLD_DS_ENABLE); 73 } 74 75 static inline void netwinder_lock(unsigned long *flags) 76 { 77 spin_lock_irqsave(&gpio_lock, *flags); 78 } 79 80 static inline void netwinder_unlock(unsigned long *flags) 81 { 82 spin_unlock_irqrestore(&gpio_lock, *flags); 83 } 84 85 static inline void netwinder_set_fan(int i) 86 { 87 unsigned long flags; 88 89 spin_lock_irqsave(&gpio_lock, flags); 90 gpio_modify_op(GPIO_FAN, i ? GPIO_FAN : 0); 91 spin_unlock_irqrestore(&gpio_lock, flags); 92 } 93 94 static inline int netwinder_get_fan(void) 95 { 96 if ((system_rev & 0xf000) == 0x4000) 97 return FAN_ALWAYS_ON; 98 99 return (gpio_read() & GPIO_FAN) ? FAN_ON : FAN_OFF; 100 } 101 102 /* 103 * End of NetWinder specifics 104 */ 105 106 static void ds1620_send_bits(int nr, int value) 107 { 108 int i; 109 110 for (i = 0; i < nr; i++) { 111 netwinder_ds1620_set_data(value & 1); 112 netwinder_ds1620_set_clk(0); 113 udelay(1); 114 netwinder_ds1620_set_clk(1); 115 udelay(1); 116 117 value >>= 1; 118 } 119 } 120 121 static unsigned int ds1620_recv_bits(int nr) 122 { 123 unsigned int value = 0, mask = 1; 124 int i; 125 126 netwinder_ds1620_set_data(0); 127 128 for (i = 0; i < nr; i++) { 129 netwinder_ds1620_set_clk(0); 130 udelay(1); 131 132 if (netwinder_ds1620_get_data()) 133 value |= mask; 134 135 mask <<= 1; 136 137 netwinder_ds1620_set_clk(1); 138 udelay(1); 139 } 140 141 return value; 142 } 143 144 static void ds1620_out(int cmd, int bits, int value) 145 { 146 unsigned long flags; 147 148 netwinder_lock(&flags); 149 netwinder_ds1620_set_clk(1); 150 netwinder_ds1620_set_data_dir(0); 151 netwinder_ds1620_reset(); 152 153 udelay(1); 154 155 ds1620_send_bits(8, cmd); 156 if (bits) 157 ds1620_send_bits(bits, value); 158 159 udelay(1); 160 161 netwinder_ds1620_reset(); 162 netwinder_unlock(&flags); 163 164 msleep(20); 165 } 166 167 static unsigned int ds1620_in(int cmd, int bits) 168 { 169 unsigned long flags; 170 unsigned int value; 171 172 netwinder_lock(&flags); 173 netwinder_ds1620_set_clk(1); 174 netwinder_ds1620_set_data_dir(0); 175 netwinder_ds1620_reset(); 176 177 udelay(1); 178 179 ds1620_send_bits(8, cmd); 180 181 netwinder_ds1620_set_data_dir(1); 182 value = ds1620_recv_bits(bits); 183 184 netwinder_ds1620_reset(); 185 netwinder_unlock(&flags); 186 187 return value; 188 } 189 190 static int cvt_9_to_int(unsigned int val) 191 { 192 if (val & 0x100) 193 val |= 0xfffffe00; 194 195 return val; 196 } 197 198 static void ds1620_write_state(struct therm *therm) 199 { 200 ds1620_out(THERM_WRITE_CONFIG, 8, CFG_CPU); 201 ds1620_out(THERM_WRITE_TL, 9, therm->lo); 202 ds1620_out(THERM_WRITE_TH, 9, therm->hi); 203 ds1620_out(THERM_START_CONVERT, 0, 0); 204 } 205 206 static void ds1620_read_state(struct therm *therm) 207 { 208 therm->lo = cvt_9_to_int(ds1620_in(THERM_READ_TL, 9)); 209 therm->hi = cvt_9_to_int(ds1620_in(THERM_READ_TH, 9)); 210 } 211 212 static ssize_t 213 ds1620_read(struct file *file, char __user *buf, size_t count, loff_t *ptr) 214 { 215 signed int cur_temp; 216 signed char cur_temp_degF; 217 218 cur_temp = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9)) >> 1; 219 220 /* convert to Fahrenheit, as per wdt.c */ 221 cur_temp_degF = (cur_temp * 9) / 5 + 32; 222 223 if (copy_to_user(buf, &cur_temp_degF, 1)) 224 return -EFAULT; 225 226 return 1; 227 } 228 229 static int 230 ds1620_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) 231 { 232 struct therm therm; 233 union { 234 struct therm __user *therm; 235 int __user *i; 236 } uarg; 237 int i; 238 239 uarg.i = (int __user *)arg; 240 241 switch(cmd) { 242 case CMD_SET_THERMOSTATE: 243 case CMD_SET_THERMOSTATE2: 244 if (!capable(CAP_SYS_ADMIN)) 245 return -EPERM; 246 247 if (cmd == CMD_SET_THERMOSTATE) { 248 if (get_user(therm.hi, uarg.i)) 249 return -EFAULT; 250 therm.lo = therm.hi - 3; 251 } else { 252 if (copy_from_user(&therm, uarg.therm, sizeof(therm))) 253 return -EFAULT; 254 } 255 256 therm.lo <<= 1; 257 therm.hi <<= 1; 258 259 ds1620_write_state(&therm); 260 break; 261 262 case CMD_GET_THERMOSTATE: 263 case CMD_GET_THERMOSTATE2: 264 ds1620_read_state(&therm); 265 266 therm.lo >>= 1; 267 therm.hi >>= 1; 268 269 if (cmd == CMD_GET_THERMOSTATE) { 270 if (put_user(therm.hi, uarg.i)) 271 return -EFAULT; 272 } else { 273 if (copy_to_user(uarg.therm, &therm, sizeof(therm))) 274 return -EFAULT; 275 } 276 break; 277 278 case CMD_GET_TEMPERATURE: 279 case CMD_GET_TEMPERATURE2: 280 i = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9)); 281 282 if (cmd == CMD_GET_TEMPERATURE) 283 i >>= 1; 284 285 return put_user(i, uarg.i) ? -EFAULT : 0; 286 287 case CMD_GET_STATUS: 288 i = ds1620_in(THERM_READ_CONFIG, 8) & 0xe3; 289 290 return put_user(i, uarg.i) ? -EFAULT : 0; 291 292 case CMD_GET_FAN: 293 i = netwinder_get_fan(); 294 295 return put_user(i, uarg.i) ? -EFAULT : 0; 296 297 case CMD_SET_FAN: 298 if (!capable(CAP_SYS_ADMIN)) 299 return -EPERM; 300 301 if (get_user(i, uarg.i)) 302 return -EFAULT; 303 304 netwinder_set_fan(i); 305 break; 306 307 default: 308 return -ENOIOCTLCMD; 309 } 310 311 return 0; 312 } 313 314 #ifdef THERM_USE_PROC 315 static int 316 proc_therm_ds1620_read(char *buf, char **start, off_t offset, 317 int len, int *eof, void *unused) 318 { 319 struct therm th; 320 int temp; 321 322 ds1620_read_state(&th); 323 temp = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9)); 324 325 len = sprintf(buf, "Thermostat: HI %i.%i, LOW %i.%i; " 326 "temperature: %i.%i C, fan %s\n", 327 th.hi >> 1, th.hi & 1 ? 5 : 0, 328 th.lo >> 1, th.lo & 1 ? 5 : 0, 329 temp >> 1, temp & 1 ? 5 : 0, 330 fan_state[netwinder_get_fan()]); 331 332 return len; 333 } 334 335 static struct proc_dir_entry *proc_therm_ds1620; 336 #endif 337 338 static const struct file_operations ds1620_fops = { 339 .owner = THIS_MODULE, 340 .open = nonseekable_open, 341 .read = ds1620_read, 342 .ioctl = ds1620_ioctl, 343 }; 344 345 static struct miscdevice ds1620_miscdev = { 346 TEMP_MINOR, 347 "temp", 348 &ds1620_fops 349 }; 350 351 static int __init ds1620_init(void) 352 { 353 int ret; 354 struct therm th, th_start; 355 356 if (!machine_is_netwinder()) 357 return -ENODEV; 358 359 ds1620_out(THERM_RESET, 0, 0); 360 ds1620_out(THERM_WRITE_CONFIG, 8, CFG_CPU); 361 ds1620_out(THERM_START_CONVERT, 0, 0); 362 363 /* 364 * Trigger the fan to start by setting 365 * temperature high point low. This kicks 366 * the fan into action. 367 */ 368 ds1620_read_state(&th); 369 th_start.lo = 0; 370 th_start.hi = 1; 371 ds1620_write_state(&th_start); 372 373 msleep(2000); 374 375 ds1620_write_state(&th); 376 377 ret = misc_register(&ds1620_miscdev); 378 if (ret < 0) 379 return ret; 380 381 #ifdef THERM_USE_PROC 382 proc_therm_ds1620 = create_proc_entry("therm", 0, NULL); 383 if (proc_therm_ds1620) 384 proc_therm_ds1620->read_proc = proc_therm_ds1620_read; 385 else 386 printk(KERN_ERR "therm: unable to register /proc/therm\n"); 387 #endif 388 389 ds1620_read_state(&th); 390 ret = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9)); 391 392 printk(KERN_INFO "Thermostat: high %i.%i, low %i.%i, " 393 "current %i.%i C, fan %s.\n", 394 th.hi >> 1, th.hi & 1 ? 5 : 0, 395 th.lo >> 1, th.lo & 1 ? 5 : 0, 396 ret >> 1, ret & 1 ? 5 : 0, 397 fan_state[netwinder_get_fan()]); 398 399 return 0; 400 } 401 402 static void __exit ds1620_exit(void) 403 { 404 #ifdef THERM_USE_PROC 405 remove_proc_entry("therm", NULL); 406 #endif 407 misc_deregister(&ds1620_miscdev); 408 } 409 410 module_init(ds1620_init); 411 module_exit(ds1620_exit); 412 413 MODULE_LICENSE("GPL"); 414