1 /* -*- linux-c -*- 2 * Cypress USB Thermometer driver 3 * 4 * Copyright (c) 2004 Erik Rigtorp <erkki@linux.nu> <erik@rigtorp.com> 5 * 6 * This driver works with Elektor magazine USB Interface as published in 7 * issue #291. It should also work with the original starter kit/demo board 8 * from Cypress. 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License as 12 * published by the Free Software Foundation, version 2. 13 * 14 */ 15 16 17 #include <linux/config.h> 18 #include <linux/kernel.h> 19 #include <linux/errno.h> 20 #include <linux/init.h> 21 #include <linux/module.h> 22 #include <linux/usb.h> 23 24 #define DRIVER_VERSION "v1.0" 25 #define DRIVER_AUTHOR "Erik Rigtorp" 26 #define DRIVER_DESC "Cypress USB Thermometer driver" 27 28 #define USB_SKEL_VENDOR_ID 0x04b4 29 #define USB_SKEL_PRODUCT_ID 0x0002 30 31 static struct usb_device_id id_table [] = { 32 { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) }, 33 { } 34 }; 35 MODULE_DEVICE_TABLE (usb, id_table); 36 37 /* Structure to hold all of our device specific stuff */ 38 struct usb_cytherm { 39 struct usb_device *udev; /* save off the usb device pointer */ 40 struct usb_interface *interface; /* the interface for this device */ 41 int brightness; 42 }; 43 44 45 /* local function prototypes */ 46 static int cytherm_probe(struct usb_interface *interface, 47 const struct usb_device_id *id); 48 static void cytherm_disconnect(struct usb_interface *interface); 49 50 51 /* usb specific object needed to register this driver with the usb subsystem */ 52 static struct usb_driver cytherm_driver = { 53 .owner = THIS_MODULE, 54 .name = "cytherm", 55 .probe = cytherm_probe, 56 .disconnect = cytherm_disconnect, 57 .id_table = id_table, 58 }; 59 60 /* Vendor requests */ 61 /* They all operate on one byte at a time */ 62 #define PING 0x00 63 #define READ_ROM 0x01 /* Reads form ROM, value = address */ 64 #define READ_RAM 0x02 /* Reads form RAM, value = address */ 65 #define WRITE_RAM 0x03 /* Write to RAM, value = address, index = data */ 66 #define READ_PORT 0x04 /* Reads from port, value = address */ 67 #define WRITE_PORT 0x05 /* Write to port, value = address, index = data */ 68 69 70 /* Send a vendor command to device */ 71 static int vendor_command(struct usb_device *dev, unsigned char request, 72 unsigned char value, unsigned char index, 73 void *buf, int size) 74 { 75 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 76 request, 77 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER, 78 value, 79 index, buf, size, 80 USB_CTRL_GET_TIMEOUT); 81 } 82 83 84 85 #define BRIGHTNESS 0x2c /* RAM location for brightness value */ 86 #define BRIGHTNESS_SEM 0x2b /* RAM location for brightness semaphore */ 87 88 static ssize_t show_brightness(struct device *dev, char *buf) 89 { 90 struct usb_interface *intf = to_usb_interface(dev); 91 struct usb_cytherm *cytherm = usb_get_intfdata(intf); 92 93 return sprintf(buf, "%i", cytherm->brightness); 94 } 95 96 static ssize_t set_brightness(struct device *dev, const char *buf, 97 size_t count) 98 { 99 struct usb_interface *intf = to_usb_interface(dev); 100 struct usb_cytherm *cytherm = usb_get_intfdata(intf); 101 102 unsigned char *buffer; 103 int retval; 104 105 buffer = kmalloc(8, GFP_KERNEL); 106 if (!buffer) { 107 dev_err(&cytherm->udev->dev, "out of memory\n"); 108 return 0; 109 } 110 111 cytherm->brightness = simple_strtoul(buf, NULL, 10); 112 113 if (cytherm->brightness > 0xFF) 114 cytherm->brightness = 0xFF; 115 else if (cytherm->brightness < 0) 116 cytherm->brightness = 0; 117 118 /* Set brightness */ 119 retval = vendor_command(cytherm->udev, WRITE_RAM, BRIGHTNESS, 120 cytherm->brightness, buffer, 8); 121 if (retval) 122 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval); 123 /* Inform �C that we have changed the brightness setting */ 124 retval = vendor_command(cytherm->udev, WRITE_RAM, BRIGHTNESS_SEM, 125 0x01, buffer, 8); 126 if (retval) 127 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval); 128 129 kfree(buffer); 130 131 return count; 132 } 133 134 static DEVICE_ATTR(brightness, S_IRUGO | S_IWUSR | S_IWGRP, 135 show_brightness, set_brightness); 136 137 138 #define TEMP 0x33 /* RAM location for temperature */ 139 #define SIGN 0x34 /* RAM location for temperature sign */ 140 141 static ssize_t show_temp(struct device *dev, char *buf) 142 { 143 144 struct usb_interface *intf = to_usb_interface(dev); 145 struct usb_cytherm *cytherm = usb_get_intfdata(intf); 146 147 int retval; 148 unsigned char *buffer; 149 150 int temp, sign; 151 152 buffer = kmalloc(8, GFP_KERNEL); 153 if (!buffer) { 154 dev_err(&cytherm->udev->dev, "out of memory\n"); 155 return 0; 156 } 157 158 /* read temperature */ 159 retval = vendor_command(cytherm->udev, READ_RAM, TEMP, 0, buffer, 8); 160 if (retval) 161 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval); 162 temp = buffer[1]; 163 164 /* read sign */ 165 retval = vendor_command(cytherm->udev, READ_RAM, SIGN, 0, buffer, 8); 166 if (retval) 167 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval); 168 sign = buffer[1]; 169 170 kfree(buffer); 171 172 return sprintf(buf, "%c%i.%i", sign ? '-' : '+', temp >> 1, 173 5*(temp - ((temp >> 1) << 1))); 174 } 175 176 177 static ssize_t set_temp(struct device *dev, const char *buf, size_t count) 178 { 179 return count; 180 } 181 182 static DEVICE_ATTR(temp, S_IRUGO, show_temp, set_temp); 183 184 185 #define BUTTON 0x7a 186 187 static ssize_t show_button(struct device *dev, char *buf) 188 { 189 190 struct usb_interface *intf = to_usb_interface(dev); 191 struct usb_cytherm *cytherm = usb_get_intfdata(intf); 192 193 int retval; 194 unsigned char *buffer; 195 196 buffer = kmalloc(8, GFP_KERNEL); 197 if (!buffer) { 198 dev_err(&cytherm->udev->dev, "out of memory\n"); 199 return 0; 200 } 201 202 /* check button */ 203 retval = vendor_command(cytherm->udev, READ_RAM, BUTTON, 0, buffer, 8); 204 if (retval) 205 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval); 206 207 retval = buffer[1]; 208 209 kfree(buffer); 210 211 if (retval) 212 return sprintf(buf, "1"); 213 else 214 return sprintf(buf, "0"); 215 } 216 217 218 static ssize_t set_button(struct device *dev, const char *buf, size_t count) 219 { 220 return count; 221 } 222 223 static DEVICE_ATTR(button, S_IRUGO, show_button, set_button); 224 225 226 static ssize_t show_port0(struct device *dev, char *buf) 227 { 228 struct usb_interface *intf = to_usb_interface(dev); 229 struct usb_cytherm *cytherm = usb_get_intfdata(intf); 230 231 int retval; 232 unsigned char *buffer; 233 234 buffer = kmalloc(8, GFP_KERNEL); 235 if (!buffer) { 236 dev_err(&cytherm->udev->dev, "out of memory\n"); 237 return 0; 238 } 239 240 retval = vendor_command(cytherm->udev, READ_PORT, 0, 0, buffer, 8); 241 if (retval) 242 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval); 243 244 retval = buffer[1]; 245 246 kfree(buffer); 247 248 return sprintf(buf, "%d", retval); 249 } 250 251 252 static ssize_t set_port0(struct device *dev, const char *buf, size_t count) 253 { 254 struct usb_interface *intf = to_usb_interface(dev); 255 struct usb_cytherm *cytherm = usb_get_intfdata(intf); 256 257 unsigned char *buffer; 258 int retval; 259 int tmp; 260 261 buffer = kmalloc(8, GFP_KERNEL); 262 if (!buffer) { 263 dev_err(&cytherm->udev->dev, "out of memory\n"); 264 return 0; 265 } 266 267 tmp = simple_strtoul(buf, NULL, 10); 268 269 if (tmp > 0xFF) 270 tmp = 0xFF; 271 else if (tmp < 0) 272 tmp = 0; 273 274 retval = vendor_command(cytherm->udev, WRITE_PORT, 0, 275 tmp, buffer, 8); 276 if (retval) 277 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval); 278 279 kfree(buffer); 280 281 return count; 282 } 283 284 static DEVICE_ATTR(port0, S_IRUGO | S_IWUSR | S_IWGRP, show_port0, set_port0); 285 286 static ssize_t show_port1(struct device *dev, char *buf) 287 { 288 struct usb_interface *intf = to_usb_interface(dev); 289 struct usb_cytherm *cytherm = usb_get_intfdata(intf); 290 291 int retval; 292 unsigned char *buffer; 293 294 buffer = kmalloc(8, GFP_KERNEL); 295 if (!buffer) { 296 dev_err(&cytherm->udev->dev, "out of memory\n"); 297 return 0; 298 } 299 300 retval = vendor_command(cytherm->udev, READ_PORT, 1, 0, buffer, 8); 301 if (retval) 302 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval); 303 304 retval = buffer[1]; 305 306 kfree(buffer); 307 308 return sprintf(buf, "%d", retval); 309 } 310 311 312 static ssize_t set_port1(struct device *dev, const char *buf, size_t count) 313 { 314 struct usb_interface *intf = to_usb_interface(dev); 315 struct usb_cytherm *cytherm = usb_get_intfdata(intf); 316 317 unsigned char *buffer; 318 int retval; 319 int tmp; 320 321 buffer = kmalloc(8, GFP_KERNEL); 322 if (!buffer) { 323 dev_err(&cytherm->udev->dev, "out of memory\n"); 324 return 0; 325 } 326 327 tmp = simple_strtoul(buf, NULL, 10); 328 329 if (tmp > 0xFF) 330 tmp = 0xFF; 331 else if (tmp < 0) 332 tmp = 0; 333 334 retval = vendor_command(cytherm->udev, WRITE_PORT, 1, 335 tmp, buffer, 8); 336 if (retval) 337 dev_dbg(&cytherm->udev->dev, "retval = %d\n", retval); 338 339 kfree(buffer); 340 341 return count; 342 } 343 344 static DEVICE_ATTR(port1, S_IRUGO | S_IWUSR | S_IWGRP, show_port1, set_port1); 345 346 347 348 static int cytherm_probe(struct usb_interface *interface, 349 const struct usb_device_id *id) 350 { 351 struct usb_device *udev = interface_to_usbdev(interface); 352 struct usb_cytherm *dev = NULL; 353 int retval = -ENOMEM; 354 355 dev = kmalloc (sizeof(struct usb_cytherm), GFP_KERNEL); 356 if (dev == NULL) { 357 dev_err (&interface->dev, "Out of memory\n"); 358 goto error; 359 } 360 memset (dev, 0x00, sizeof (*dev)); 361 362 dev->udev = usb_get_dev(udev); 363 364 usb_set_intfdata (interface, dev); 365 366 dev->brightness = 0xFF; 367 368 device_create_file(&interface->dev, &dev_attr_brightness); 369 device_create_file(&interface->dev, &dev_attr_temp); 370 device_create_file(&interface->dev, &dev_attr_button); 371 device_create_file(&interface->dev, &dev_attr_port0); 372 device_create_file(&interface->dev, &dev_attr_port1); 373 374 dev_info (&interface->dev, 375 "Cypress thermometer device now attached\n"); 376 return 0; 377 378 error: 379 kfree(dev); 380 return retval; 381 } 382 383 static void cytherm_disconnect(struct usb_interface *interface) 384 { 385 struct usb_cytherm *dev; 386 387 dev = usb_get_intfdata (interface); 388 usb_set_intfdata (interface, NULL); 389 390 device_remove_file(&interface->dev, &dev_attr_brightness); 391 device_remove_file(&interface->dev, &dev_attr_temp); 392 device_remove_file(&interface->dev, &dev_attr_button); 393 device_remove_file(&interface->dev, &dev_attr_port0); 394 device_remove_file(&interface->dev, &dev_attr_port1); 395 396 usb_put_dev(dev->udev); 397 398 kfree(dev); 399 400 dev_info(&interface->dev, "Cypress thermometer now disconnected\n"); 401 } 402 403 404 static int __init usb_cytherm_init(void) 405 { 406 int result; 407 408 result = usb_register(&cytherm_driver); 409 if (result) 410 { 411 err("usb_register failed. Error number %d", result); 412 return result; 413 } 414 415 info(DRIVER_VERSION ":" DRIVER_DESC); 416 return 0; 417 } 418 419 static void __exit usb_cytherm_exit(void) 420 { 421 usb_deregister(&cytherm_driver); 422 } 423 424 425 module_init (usb_cytherm_init); 426 module_exit (usb_cytherm_exit); 427 428 MODULE_AUTHOR(DRIVER_AUTHOR); 429 MODULE_DESCRIPTION(DRIVER_DESC); 430 MODULE_LICENSE("GPL"); 431