1 /* 2 * Power capping class 3 * Copyright (c) 2013, Intel Corporation. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms and conditions of the GNU General Public License, 7 * version 2, as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 * 14 * You should have received a copy of the GNU General Public License along with 15 * this program; if not, write to the Free Software Foundation, Inc. 16 * 17 */ 18 19 #include <linux/module.h> 20 #include <linux/device.h> 21 #include <linux/err.h> 22 #include <linux/slab.h> 23 #include <linux/powercap.h> 24 25 #define to_powercap_zone(n) container_of(n, struct powercap_zone, dev) 26 #define to_powercap_control_type(n) \ 27 container_of(n, struct powercap_control_type, dev) 28 29 /* Power zone show function */ 30 #define define_power_zone_show(_attr) \ 31 static ssize_t _attr##_show(struct device *dev, \ 32 struct device_attribute *dev_attr,\ 33 char *buf) \ 34 { \ 35 u64 value; \ 36 ssize_t len = -EINVAL; \ 37 struct powercap_zone *power_zone = to_powercap_zone(dev); \ 38 \ 39 if (power_zone->ops->get_##_attr) { \ 40 if (!power_zone->ops->get_##_attr(power_zone, &value)) \ 41 len = sprintf(buf, "%lld\n", value); \ 42 } \ 43 \ 44 return len; \ 45 } 46 47 /* The only meaningful input is 0 (reset), others are silently ignored */ 48 #define define_power_zone_store(_attr) \ 49 static ssize_t _attr##_store(struct device *dev,\ 50 struct device_attribute *dev_attr, \ 51 const char *buf, size_t count) \ 52 { \ 53 int err; \ 54 struct powercap_zone *power_zone = to_powercap_zone(dev); \ 55 u64 value; \ 56 \ 57 err = kstrtoull(buf, 10, &value); \ 58 if (err) \ 59 return -EINVAL; \ 60 if (value) \ 61 return count; \ 62 if (power_zone->ops->reset_##_attr) { \ 63 if (!power_zone->ops->reset_##_attr(power_zone)) \ 64 return count; \ 65 } \ 66 \ 67 return -EINVAL; \ 68 } 69 70 /* Power zone constraint show function */ 71 #define define_power_zone_constraint_show(_attr) \ 72 static ssize_t show_constraint_##_attr(struct device *dev, \ 73 struct device_attribute *dev_attr,\ 74 char *buf) \ 75 { \ 76 u64 value; \ 77 ssize_t len = -ENODATA; \ 78 struct powercap_zone *power_zone = to_powercap_zone(dev); \ 79 int id; \ 80 struct powercap_zone_constraint *pconst;\ 81 \ 82 if (!sscanf(dev_attr->attr.name, "constraint_%d_", &id)) \ 83 return -EINVAL; \ 84 if (id >= power_zone->const_id_cnt) \ 85 return -EINVAL; \ 86 pconst = &power_zone->constraints[id]; \ 87 if (pconst && pconst->ops && pconst->ops->get_##_attr) { \ 88 if (!pconst->ops->get_##_attr(power_zone, id, &value)) \ 89 len = sprintf(buf, "%lld\n", value); \ 90 } \ 91 \ 92 return len; \ 93 } 94 95 /* Power zone constraint store function */ 96 #define define_power_zone_constraint_store(_attr) \ 97 static ssize_t store_constraint_##_attr(struct device *dev,\ 98 struct device_attribute *dev_attr, \ 99 const char *buf, size_t count) \ 100 { \ 101 int err; \ 102 u64 value; \ 103 struct powercap_zone *power_zone = to_powercap_zone(dev); \ 104 int id; \ 105 struct powercap_zone_constraint *pconst;\ 106 \ 107 if (!sscanf(dev_attr->attr.name, "constraint_%d_", &id)) \ 108 return -EINVAL; \ 109 if (id >= power_zone->const_id_cnt) \ 110 return -EINVAL; \ 111 pconst = &power_zone->constraints[id]; \ 112 err = kstrtoull(buf, 10, &value); \ 113 if (err) \ 114 return -EINVAL; \ 115 if (pconst && pconst->ops && pconst->ops->set_##_attr) { \ 116 if (!pconst->ops->set_##_attr(power_zone, id, value)) \ 117 return count; \ 118 } \ 119 \ 120 return -ENODATA; \ 121 } 122 123 /* Power zone information callbacks */ 124 define_power_zone_show(power_uw); 125 define_power_zone_show(max_power_range_uw); 126 define_power_zone_show(energy_uj); 127 define_power_zone_store(energy_uj); 128 define_power_zone_show(max_energy_range_uj); 129 130 /* Power zone attributes */ 131 static DEVICE_ATTR_RO(max_power_range_uw); 132 static DEVICE_ATTR_RO(power_uw); 133 static DEVICE_ATTR_RO(max_energy_range_uj); 134 static DEVICE_ATTR_RW(energy_uj); 135 136 /* Power zone constraint attributes callbacks */ 137 define_power_zone_constraint_show(power_limit_uw); 138 define_power_zone_constraint_store(power_limit_uw); 139 define_power_zone_constraint_show(time_window_us); 140 define_power_zone_constraint_store(time_window_us); 141 define_power_zone_constraint_show(max_power_uw); 142 define_power_zone_constraint_show(min_power_uw); 143 define_power_zone_constraint_show(max_time_window_us); 144 define_power_zone_constraint_show(min_time_window_us); 145 146 /* For one time seeding of constraint device attributes */ 147 struct powercap_constraint_attr { 148 struct device_attribute power_limit_attr; 149 struct device_attribute time_window_attr; 150 struct device_attribute max_power_attr; 151 struct device_attribute min_power_attr; 152 struct device_attribute max_time_window_attr; 153 struct device_attribute min_time_window_attr; 154 struct device_attribute name_attr; 155 }; 156 157 static struct powercap_constraint_attr 158 constraint_attrs[MAX_CONSTRAINTS_PER_ZONE]; 159 160 /* A list of powercap control_types */ 161 static LIST_HEAD(powercap_cntrl_list); 162 /* Mutex to protect list of powercap control_types */ 163 static DEFINE_MUTEX(powercap_cntrl_list_lock); 164 165 #define POWERCAP_CONSTRAINT_NAME_LEN 30 /* Some limit to avoid overflow */ 166 static ssize_t show_constraint_name(struct device *dev, 167 struct device_attribute *dev_attr, 168 char *buf) 169 { 170 const char *name; 171 struct powercap_zone *power_zone = to_powercap_zone(dev); 172 int id; 173 ssize_t len = -ENODATA; 174 struct powercap_zone_constraint *pconst; 175 176 if (!sscanf(dev_attr->attr.name, "constraint_%d_", &id)) 177 return -EINVAL; 178 if (id >= power_zone->const_id_cnt) 179 return -EINVAL; 180 pconst = &power_zone->constraints[id]; 181 182 if (pconst && pconst->ops && pconst->ops->get_name) { 183 name = pconst->ops->get_name(power_zone, id); 184 if (name) { 185 snprintf(buf, POWERCAP_CONSTRAINT_NAME_LEN, 186 "%s\n", name); 187 buf[POWERCAP_CONSTRAINT_NAME_LEN] = '\0'; 188 len = strlen(buf); 189 } 190 } 191 192 return len; 193 } 194 195 static int create_constraint_attribute(int id, const char *name, 196 int mode, 197 struct device_attribute *dev_attr, 198 ssize_t (*show)(struct device *, 199 struct device_attribute *, char *), 200 ssize_t (*store)(struct device *, 201 struct device_attribute *, 202 const char *, size_t) 203 ) 204 { 205 206 dev_attr->attr.name = kasprintf(GFP_KERNEL, "constraint_%d_%s", 207 id, name); 208 if (!dev_attr->attr.name) 209 return -ENOMEM; 210 dev_attr->attr.mode = mode; 211 dev_attr->show = show; 212 dev_attr->store = store; 213 214 return 0; 215 } 216 217 static void free_constraint_attributes(void) 218 { 219 int i; 220 221 for (i = 0; i < MAX_CONSTRAINTS_PER_ZONE; ++i) { 222 kfree(constraint_attrs[i].power_limit_attr.attr.name); 223 kfree(constraint_attrs[i].time_window_attr.attr.name); 224 kfree(constraint_attrs[i].name_attr.attr.name); 225 kfree(constraint_attrs[i].max_power_attr.attr.name); 226 kfree(constraint_attrs[i].min_power_attr.attr.name); 227 kfree(constraint_attrs[i].max_time_window_attr.attr.name); 228 kfree(constraint_attrs[i].min_time_window_attr.attr.name); 229 } 230 } 231 232 static int seed_constraint_attributes(void) 233 { 234 int i; 235 int ret; 236 237 for (i = 0; i < MAX_CONSTRAINTS_PER_ZONE; ++i) { 238 ret = create_constraint_attribute(i, "power_limit_uw", 239 S_IWUSR | S_IRUGO, 240 &constraint_attrs[i].power_limit_attr, 241 show_constraint_power_limit_uw, 242 store_constraint_power_limit_uw); 243 if (ret) 244 goto err_alloc; 245 ret = create_constraint_attribute(i, "time_window_us", 246 S_IWUSR | S_IRUGO, 247 &constraint_attrs[i].time_window_attr, 248 show_constraint_time_window_us, 249 store_constraint_time_window_us); 250 if (ret) 251 goto err_alloc; 252 ret = create_constraint_attribute(i, "name", S_IRUGO, 253 &constraint_attrs[i].name_attr, 254 show_constraint_name, 255 NULL); 256 if (ret) 257 goto err_alloc; 258 ret = create_constraint_attribute(i, "max_power_uw", S_IRUGO, 259 &constraint_attrs[i].max_power_attr, 260 show_constraint_max_power_uw, 261 NULL); 262 if (ret) 263 goto err_alloc; 264 ret = create_constraint_attribute(i, "min_power_uw", S_IRUGO, 265 &constraint_attrs[i].min_power_attr, 266 show_constraint_min_power_uw, 267 NULL); 268 if (ret) 269 goto err_alloc; 270 ret = create_constraint_attribute(i, "max_time_window_us", 271 S_IRUGO, 272 &constraint_attrs[i].max_time_window_attr, 273 show_constraint_max_time_window_us, 274 NULL); 275 if (ret) 276 goto err_alloc; 277 ret = create_constraint_attribute(i, "min_time_window_us", 278 S_IRUGO, 279 &constraint_attrs[i].min_time_window_attr, 280 show_constraint_min_time_window_us, 281 NULL); 282 if (ret) 283 goto err_alloc; 284 285 } 286 287 return 0; 288 289 err_alloc: 290 free_constraint_attributes(); 291 292 return ret; 293 } 294 295 static int create_constraints(struct powercap_zone *power_zone, 296 int nr_constraints, 297 const struct powercap_zone_constraint_ops *const_ops) 298 { 299 int i; 300 int ret = 0; 301 int count; 302 struct powercap_zone_constraint *pconst; 303 304 if (!power_zone || !const_ops || !const_ops->get_power_limit_uw || 305 !const_ops->set_power_limit_uw || 306 !const_ops->get_time_window_us || 307 !const_ops->set_time_window_us) 308 return -EINVAL; 309 310 count = power_zone->zone_attr_count; 311 for (i = 0; i < nr_constraints; ++i) { 312 pconst = &power_zone->constraints[i]; 313 pconst->ops = const_ops; 314 pconst->id = power_zone->const_id_cnt; 315 power_zone->const_id_cnt++; 316 power_zone->zone_dev_attrs[count++] = 317 &constraint_attrs[i].power_limit_attr.attr; 318 power_zone->zone_dev_attrs[count++] = 319 &constraint_attrs[i].time_window_attr.attr; 320 if (pconst->ops->get_name) 321 power_zone->zone_dev_attrs[count++] = 322 &constraint_attrs[i].name_attr.attr; 323 if (pconst->ops->get_max_power_uw) 324 power_zone->zone_dev_attrs[count++] = 325 &constraint_attrs[i].max_power_attr.attr; 326 if (pconst->ops->get_min_power_uw) 327 power_zone->zone_dev_attrs[count++] = 328 &constraint_attrs[i].min_power_attr.attr; 329 if (pconst->ops->get_max_time_window_us) 330 power_zone->zone_dev_attrs[count++] = 331 &constraint_attrs[i].max_time_window_attr.attr; 332 if (pconst->ops->get_min_time_window_us) 333 power_zone->zone_dev_attrs[count++] = 334 &constraint_attrs[i].min_time_window_attr.attr; 335 } 336 power_zone->zone_attr_count = count; 337 338 return ret; 339 } 340 341 static bool control_type_valid(void *control_type) 342 { 343 struct powercap_control_type *pos = NULL; 344 bool found = false; 345 346 mutex_lock(&powercap_cntrl_list_lock); 347 348 list_for_each_entry(pos, &powercap_cntrl_list, node) { 349 if (pos == control_type) { 350 found = true; 351 break; 352 } 353 } 354 mutex_unlock(&powercap_cntrl_list_lock); 355 356 return found; 357 } 358 359 static ssize_t name_show(struct device *dev, 360 struct device_attribute *attr, 361 char *buf) 362 { 363 struct powercap_zone *power_zone = to_powercap_zone(dev); 364 365 return sprintf(buf, "%s\n", power_zone->name); 366 } 367 368 static DEVICE_ATTR_RO(name); 369 370 /* Create zone and attributes in sysfs */ 371 static void create_power_zone_common_attributes( 372 struct powercap_zone *power_zone) 373 { 374 int count = 0; 375 376 power_zone->zone_dev_attrs[count++] = &dev_attr_name.attr; 377 if (power_zone->ops->get_max_energy_range_uj) 378 power_zone->zone_dev_attrs[count++] = 379 &dev_attr_max_energy_range_uj.attr; 380 if (power_zone->ops->get_energy_uj) { 381 if (power_zone->ops->reset_energy_uj) 382 dev_attr_energy_uj.attr.mode = S_IWUSR | S_IRUGO; 383 else 384 dev_attr_energy_uj.attr.mode = S_IRUGO; 385 power_zone->zone_dev_attrs[count++] = 386 &dev_attr_energy_uj.attr; 387 } 388 if (power_zone->ops->get_power_uw) 389 power_zone->zone_dev_attrs[count++] = 390 &dev_attr_power_uw.attr; 391 if (power_zone->ops->get_max_power_range_uw) 392 power_zone->zone_dev_attrs[count++] = 393 &dev_attr_max_power_range_uw.attr; 394 power_zone->zone_dev_attrs[count] = NULL; 395 power_zone->zone_attr_count = count; 396 } 397 398 static void powercap_release(struct device *dev) 399 { 400 bool allocated; 401 402 if (dev->parent) { 403 struct powercap_zone *power_zone = to_powercap_zone(dev); 404 405 /* Store flag as the release() may free memory */ 406 allocated = power_zone->allocated; 407 /* Remove id from parent idr struct */ 408 idr_remove(power_zone->parent_idr, power_zone->id); 409 /* Destroy idrs allocated for this zone */ 410 idr_destroy(&power_zone->idr); 411 kfree(power_zone->name); 412 kfree(power_zone->zone_dev_attrs); 413 kfree(power_zone->constraints); 414 if (power_zone->ops->release) 415 power_zone->ops->release(power_zone); 416 if (allocated) 417 kfree(power_zone); 418 } else { 419 struct powercap_control_type *control_type = 420 to_powercap_control_type(dev); 421 422 /* Store flag as the release() may free memory */ 423 allocated = control_type->allocated; 424 idr_destroy(&control_type->idr); 425 mutex_destroy(&control_type->lock); 426 if (control_type->ops && control_type->ops->release) 427 control_type->ops->release(control_type); 428 if (allocated) 429 kfree(control_type); 430 } 431 } 432 433 static ssize_t enabled_show(struct device *dev, 434 struct device_attribute *attr, 435 char *buf) 436 { 437 bool mode = true; 438 439 /* Default is enabled */ 440 if (dev->parent) { 441 struct powercap_zone *power_zone = to_powercap_zone(dev); 442 if (power_zone->ops->get_enable) 443 if (power_zone->ops->get_enable(power_zone, &mode)) 444 mode = false; 445 } else { 446 struct powercap_control_type *control_type = 447 to_powercap_control_type(dev); 448 if (control_type->ops && control_type->ops->get_enable) 449 if (control_type->ops->get_enable(control_type, &mode)) 450 mode = false; 451 } 452 453 return sprintf(buf, "%d\n", mode); 454 } 455 456 static ssize_t enabled_store(struct device *dev, 457 struct device_attribute *attr, 458 const char *buf, size_t len) 459 { 460 bool mode; 461 462 if (strtobool(buf, &mode)) 463 return -EINVAL; 464 if (dev->parent) { 465 struct powercap_zone *power_zone = to_powercap_zone(dev); 466 if (power_zone->ops->set_enable) 467 if (!power_zone->ops->set_enable(power_zone, mode)) 468 return len; 469 } else { 470 struct powercap_control_type *control_type = 471 to_powercap_control_type(dev); 472 if (control_type->ops && control_type->ops->set_enable) 473 if (!control_type->ops->set_enable(control_type, mode)) 474 return len; 475 } 476 477 return -ENOSYS; 478 } 479 480 static DEVICE_ATTR_RW(enabled); 481 482 static struct attribute *powercap_attrs[] = { 483 &dev_attr_enabled.attr, 484 NULL, 485 }; 486 ATTRIBUTE_GROUPS(powercap); 487 488 static struct class powercap_class = { 489 .name = "powercap", 490 .dev_release = powercap_release, 491 .dev_groups = powercap_groups, 492 }; 493 494 struct powercap_zone *powercap_register_zone( 495 struct powercap_zone *power_zone, 496 struct powercap_control_type *control_type, 497 const char *name, 498 struct powercap_zone *parent, 499 const struct powercap_zone_ops *ops, 500 int nr_constraints, 501 const struct powercap_zone_constraint_ops *const_ops) 502 { 503 int result; 504 int nr_attrs; 505 506 if (!name || !control_type || !ops || 507 nr_constraints > MAX_CONSTRAINTS_PER_ZONE || 508 (!ops->get_energy_uj && !ops->get_power_uw) || 509 !control_type_valid(control_type)) 510 return ERR_PTR(-EINVAL); 511 512 if (power_zone) { 513 if (!ops->release) 514 return ERR_PTR(-EINVAL); 515 memset(power_zone, 0, sizeof(*power_zone)); 516 } else { 517 power_zone = kzalloc(sizeof(*power_zone), GFP_KERNEL); 518 if (!power_zone) 519 return ERR_PTR(-ENOMEM); 520 power_zone->allocated = true; 521 } 522 power_zone->ops = ops; 523 power_zone->control_type_inst = control_type; 524 if (!parent) { 525 power_zone->dev.parent = &control_type->dev; 526 power_zone->parent_idr = &control_type->idr; 527 } else { 528 power_zone->dev.parent = &parent->dev; 529 power_zone->parent_idr = &parent->idr; 530 } 531 power_zone->dev.class = &powercap_class; 532 533 mutex_lock(&control_type->lock); 534 /* Using idr to get the unique id */ 535 result = idr_alloc(power_zone->parent_idr, NULL, 0, 0, GFP_KERNEL); 536 if (result < 0) 537 goto err_idr_alloc; 538 539 power_zone->id = result; 540 idr_init(&power_zone->idr); 541 power_zone->name = kstrdup(name, GFP_KERNEL); 542 if (!power_zone->name) 543 goto err_name_alloc; 544 dev_set_name(&power_zone->dev, "%s:%x", 545 dev_name(power_zone->dev.parent), 546 power_zone->id); 547 power_zone->constraints = kzalloc(sizeof(*power_zone->constraints) * 548 nr_constraints, GFP_KERNEL); 549 if (!power_zone->constraints) 550 goto err_const_alloc; 551 552 nr_attrs = nr_constraints * POWERCAP_CONSTRAINTS_ATTRS + 553 POWERCAP_ZONE_MAX_ATTRS + 1; 554 power_zone->zone_dev_attrs = kzalloc(sizeof(void *) * 555 nr_attrs, GFP_KERNEL); 556 if (!power_zone->zone_dev_attrs) 557 goto err_attr_alloc; 558 create_power_zone_common_attributes(power_zone); 559 result = create_constraints(power_zone, nr_constraints, const_ops); 560 if (result) 561 goto err_dev_ret; 562 563 power_zone->zone_dev_attrs[power_zone->zone_attr_count] = NULL; 564 power_zone->dev_zone_attr_group.attrs = power_zone->zone_dev_attrs; 565 power_zone->dev_attr_groups[0] = &power_zone->dev_zone_attr_group; 566 power_zone->dev_attr_groups[1] = NULL; 567 power_zone->dev.groups = power_zone->dev_attr_groups; 568 result = device_register(&power_zone->dev); 569 if (result) 570 goto err_dev_ret; 571 572 control_type->nr_zones++; 573 mutex_unlock(&control_type->lock); 574 575 return power_zone; 576 577 err_dev_ret: 578 kfree(power_zone->zone_dev_attrs); 579 err_attr_alloc: 580 kfree(power_zone->constraints); 581 err_const_alloc: 582 kfree(power_zone->name); 583 err_name_alloc: 584 idr_remove(power_zone->parent_idr, power_zone->id); 585 err_idr_alloc: 586 if (power_zone->allocated) 587 kfree(power_zone); 588 mutex_unlock(&control_type->lock); 589 590 return ERR_PTR(result); 591 } 592 EXPORT_SYMBOL_GPL(powercap_register_zone); 593 594 int powercap_unregister_zone(struct powercap_control_type *control_type, 595 struct powercap_zone *power_zone) 596 { 597 if (!power_zone || !control_type) 598 return -EINVAL; 599 600 mutex_lock(&control_type->lock); 601 control_type->nr_zones--; 602 mutex_unlock(&control_type->lock); 603 604 device_unregister(&power_zone->dev); 605 606 return 0; 607 } 608 EXPORT_SYMBOL_GPL(powercap_unregister_zone); 609 610 struct powercap_control_type *powercap_register_control_type( 611 struct powercap_control_type *control_type, 612 const char *name, 613 const struct powercap_control_type_ops *ops) 614 { 615 int result; 616 617 if (!name) 618 return ERR_PTR(-EINVAL); 619 if (control_type) { 620 if (!ops || !ops->release) 621 return ERR_PTR(-EINVAL); 622 memset(control_type, 0, sizeof(*control_type)); 623 } else { 624 control_type = kzalloc(sizeof(*control_type), GFP_KERNEL); 625 if (!control_type) 626 return ERR_PTR(-ENOMEM); 627 control_type->allocated = true; 628 } 629 mutex_init(&control_type->lock); 630 control_type->ops = ops; 631 INIT_LIST_HEAD(&control_type->node); 632 control_type->dev.class = &powercap_class; 633 dev_set_name(&control_type->dev, "%s", name); 634 result = device_register(&control_type->dev); 635 if (result) { 636 if (control_type->allocated) 637 kfree(control_type); 638 return ERR_PTR(result); 639 } 640 idr_init(&control_type->idr); 641 642 mutex_lock(&powercap_cntrl_list_lock); 643 list_add_tail(&control_type->node, &powercap_cntrl_list); 644 mutex_unlock(&powercap_cntrl_list_lock); 645 646 return control_type; 647 } 648 EXPORT_SYMBOL_GPL(powercap_register_control_type); 649 650 int powercap_unregister_control_type(struct powercap_control_type *control_type) 651 { 652 struct powercap_control_type *pos = NULL; 653 654 if (control_type->nr_zones) { 655 dev_err(&control_type->dev, "Zones of this type still not freed\n"); 656 return -EINVAL; 657 } 658 mutex_lock(&powercap_cntrl_list_lock); 659 list_for_each_entry(pos, &powercap_cntrl_list, node) { 660 if (pos == control_type) { 661 list_del(&control_type->node); 662 mutex_unlock(&powercap_cntrl_list_lock); 663 device_unregister(&control_type->dev); 664 return 0; 665 } 666 } 667 mutex_unlock(&powercap_cntrl_list_lock); 668 669 return -ENODEV; 670 } 671 EXPORT_SYMBOL_GPL(powercap_unregister_control_type); 672 673 static int __init powercap_init(void) 674 { 675 int result = 0; 676 677 result = seed_constraint_attributes(); 678 if (result) 679 return result; 680 681 result = class_register(&powercap_class); 682 683 return result; 684 } 685 686 device_initcall(powercap_init); 687 688 MODULE_DESCRIPTION("PowerCap sysfs Driver"); 689 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>"); 690 MODULE_LICENSE("GPL v2"); 691