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/delay.h> 8 #include <linux/proc_fs.h> 9 #include <linux/capability.h> 10 #include <linux/init.h> 11 #include <linux/smp_lock.h> 12 13 #include <mach/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 int ds1620_open(struct inode *inode, struct file *file) 213 { 214 cycle_kernel_lock(); 215 return nonseekable_open(inode, file); 216 } 217 218 static ssize_t 219 ds1620_read(struct file *file, char __user *buf, size_t count, loff_t *ptr) 220 { 221 signed int cur_temp; 222 signed char cur_temp_degF; 223 224 cur_temp = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9)) >> 1; 225 226 /* convert to Fahrenheit, as per wdt.c */ 227 cur_temp_degF = (cur_temp * 9) / 5 + 32; 228 229 if (copy_to_user(buf, &cur_temp_degF, 1)) 230 return -EFAULT; 231 232 return 1; 233 } 234 235 static int 236 ds1620_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) 237 { 238 struct therm therm; 239 union { 240 struct therm __user *therm; 241 int __user *i; 242 } uarg; 243 int i; 244 245 uarg.i = (int __user *)arg; 246 247 switch(cmd) { 248 case CMD_SET_THERMOSTATE: 249 case CMD_SET_THERMOSTATE2: 250 if (!capable(CAP_SYS_ADMIN)) 251 return -EPERM; 252 253 if (cmd == CMD_SET_THERMOSTATE) { 254 if (get_user(therm.hi, uarg.i)) 255 return -EFAULT; 256 therm.lo = therm.hi - 3; 257 } else { 258 if (copy_from_user(&therm, uarg.therm, sizeof(therm))) 259 return -EFAULT; 260 } 261 262 therm.lo <<= 1; 263 therm.hi <<= 1; 264 265 ds1620_write_state(&therm); 266 break; 267 268 case CMD_GET_THERMOSTATE: 269 case CMD_GET_THERMOSTATE2: 270 ds1620_read_state(&therm); 271 272 therm.lo >>= 1; 273 therm.hi >>= 1; 274 275 if (cmd == CMD_GET_THERMOSTATE) { 276 if (put_user(therm.hi, uarg.i)) 277 return -EFAULT; 278 } else { 279 if (copy_to_user(uarg.therm, &therm, sizeof(therm))) 280 return -EFAULT; 281 } 282 break; 283 284 case CMD_GET_TEMPERATURE: 285 case CMD_GET_TEMPERATURE2: 286 i = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9)); 287 288 if (cmd == CMD_GET_TEMPERATURE) 289 i >>= 1; 290 291 return put_user(i, uarg.i) ? -EFAULT : 0; 292 293 case CMD_GET_STATUS: 294 i = ds1620_in(THERM_READ_CONFIG, 8) & 0xe3; 295 296 return put_user(i, uarg.i) ? -EFAULT : 0; 297 298 case CMD_GET_FAN: 299 i = netwinder_get_fan(); 300 301 return put_user(i, uarg.i) ? -EFAULT : 0; 302 303 case CMD_SET_FAN: 304 if (!capable(CAP_SYS_ADMIN)) 305 return -EPERM; 306 307 if (get_user(i, uarg.i)) 308 return -EFAULT; 309 310 netwinder_set_fan(i); 311 break; 312 313 default: 314 return -ENOIOCTLCMD; 315 } 316 317 return 0; 318 } 319 320 #ifdef THERM_USE_PROC 321 static int 322 proc_therm_ds1620_read(char *buf, char **start, off_t offset, 323 int len, int *eof, void *unused) 324 { 325 struct therm th; 326 int temp; 327 328 ds1620_read_state(&th); 329 temp = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9)); 330 331 len = sprintf(buf, "Thermostat: HI %i.%i, LOW %i.%i; " 332 "temperature: %i.%i C, fan %s\n", 333 th.hi >> 1, th.hi & 1 ? 5 : 0, 334 th.lo >> 1, th.lo & 1 ? 5 : 0, 335 temp >> 1, temp & 1 ? 5 : 0, 336 fan_state[netwinder_get_fan()]); 337 338 return len; 339 } 340 341 static struct proc_dir_entry *proc_therm_ds1620; 342 #endif 343 344 static const struct file_operations ds1620_fops = { 345 .owner = THIS_MODULE, 346 .open = ds1620_open, 347 .read = ds1620_read, 348 .ioctl = ds1620_ioctl, 349 }; 350 351 static struct miscdevice ds1620_miscdev = { 352 TEMP_MINOR, 353 "temp", 354 &ds1620_fops 355 }; 356 357 static int __init ds1620_init(void) 358 { 359 int ret; 360 struct therm th, th_start; 361 362 if (!machine_is_netwinder()) 363 return -ENODEV; 364 365 ds1620_out(THERM_RESET, 0, 0); 366 ds1620_out(THERM_WRITE_CONFIG, 8, CFG_CPU); 367 ds1620_out(THERM_START_CONVERT, 0, 0); 368 369 /* 370 * Trigger the fan to start by setting 371 * temperature high point low. This kicks 372 * the fan into action. 373 */ 374 ds1620_read_state(&th); 375 th_start.lo = 0; 376 th_start.hi = 1; 377 ds1620_write_state(&th_start); 378 379 msleep(2000); 380 381 ds1620_write_state(&th); 382 383 ret = misc_register(&ds1620_miscdev); 384 if (ret < 0) 385 return ret; 386 387 #ifdef THERM_USE_PROC 388 proc_therm_ds1620 = create_proc_entry("therm", 0, NULL); 389 if (proc_therm_ds1620) 390 proc_therm_ds1620->read_proc = proc_therm_ds1620_read; 391 else 392 printk(KERN_ERR "therm: unable to register /proc/therm\n"); 393 #endif 394 395 ds1620_read_state(&th); 396 ret = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9)); 397 398 printk(KERN_INFO "Thermostat: high %i.%i, low %i.%i, " 399 "current %i.%i C, fan %s.\n", 400 th.hi >> 1, th.hi & 1 ? 5 : 0, 401 th.lo >> 1, th.lo & 1 ? 5 : 0, 402 ret >> 1, ret & 1 ? 5 : 0, 403 fan_state[netwinder_get_fan()]); 404 405 return 0; 406 } 407 408 static void __exit ds1620_exit(void) 409 { 410 #ifdef THERM_USE_PROC 411 remove_proc_entry("therm", NULL); 412 #endif 413 misc_deregister(&ds1620_miscdev); 414 } 415 416 module_init(ds1620_init); 417 module_exit(ds1620_exit); 418 419 MODULE_LICENSE("GPL"); 420