tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

Input: convert obsolete strict_strtox to kstrtox

With commit 67d0a0754455f89ef3946946159d8ec9e45ce33a we mark strict_strtox
as obsolete. Convert all remaining such uses in drivers/input/.

Also change long to appropriate types, and return error conditions
from kstrtox separately, as Dmitry sugguests.

Signed-off-by: JJ Ding <dgdunix@gmail.com>
Signed-off-by: Dmitry Torokhov <dtor@mail.ru>

authored by

JJ Ding and committed by
Dmitry Torokhov 76496e7a 7cf801cf

+173 -104
+5 -3
drivers/input/input-polldev.c
··· 83 83 { 84 84 struct input_polled_dev *polldev = dev_get_drvdata(dev); 85 85 struct input_dev *input = polldev->input; 86 - unsigned long interval; 86 + unsigned int interval; 87 + int err; 87 88 88 - if (strict_strtoul(buf, 0, &interval)) 89 - return -EINVAL; 89 + err = kstrtouint(buf, 0, &interval); 90 + if (err) 91 + return err; 90 92 91 93 if (interval < polldev->poll_interval_min) 92 94 return -EINVAL;
+30 -10
drivers/input/keyboard/atkbd.c
··· 1305 1305 static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count) 1306 1306 { 1307 1307 struct input_dev *old_dev, *new_dev; 1308 - unsigned long value; 1308 + unsigned int value; 1309 1309 int err; 1310 1310 bool old_extra; 1311 1311 unsigned char old_set; ··· 1313 1313 if (!atkbd->write) 1314 1314 return -EIO; 1315 1315 1316 - if (strict_strtoul(buf, 10, &value) || value > 1) 1316 + err = kstrtouint(buf, 10, &value); 1317 + if (err) 1318 + return err; 1319 + 1320 + if (value > 1) 1317 1321 return -EINVAL; 1318 1322 1319 1323 if (atkbd->extra != value) { ··· 1393 1389 static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count) 1394 1390 { 1395 1391 struct input_dev *old_dev, *new_dev; 1396 - unsigned long value; 1392 + unsigned int value; 1397 1393 int err; 1398 1394 bool old_scroll; 1399 1395 1400 - if (strict_strtoul(buf, 10, &value) || value > 1) 1396 + err = kstrtouint(buf, 10, &value); 1397 + if (err) 1398 + return err; 1399 + 1400 + if (value > 1) 1401 1401 return -EINVAL; 1402 1402 1403 1403 if (atkbd->scroll != value) { ··· 1441 1433 static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count) 1442 1434 { 1443 1435 struct input_dev *old_dev, *new_dev; 1444 - unsigned long value; 1436 + unsigned int value; 1445 1437 int err; 1446 1438 unsigned char old_set; 1447 1439 bool old_extra; ··· 1449 1441 if (!atkbd->write) 1450 1442 return -EIO; 1451 1443 1452 - if (strict_strtoul(buf, 10, &value) || (value != 2 && value != 3)) 1444 + err = kstrtouint(buf, 10, &value); 1445 + if (err) 1446 + return err; 1447 + 1448 + if (value != 2 && value != 3) 1453 1449 return -EINVAL; 1454 1450 1455 1451 if (atkbd->set != value) { ··· 1496 1484 static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count) 1497 1485 { 1498 1486 struct input_dev *old_dev, *new_dev; 1499 - unsigned long value; 1487 + unsigned int value; 1500 1488 int err; 1501 1489 bool old_softrepeat, old_softraw; 1502 1490 1503 1491 if (!atkbd->write) 1504 1492 return -EIO; 1505 1493 1506 - if (strict_strtoul(buf, 10, &value) || value > 1) 1494 + err = kstrtouint(buf, 10, &value); 1495 + if (err) 1496 + return err; 1497 + 1498 + if (value > 1) 1507 1499 return -EINVAL; 1508 1500 1509 1501 if (atkbd->softrepeat != value) { ··· 1550 1534 static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count) 1551 1535 { 1552 1536 struct input_dev *old_dev, *new_dev; 1553 - unsigned long value; 1537 + unsigned int value; 1554 1538 int err; 1555 1539 bool old_softraw; 1556 1540 1557 - if (strict_strtoul(buf, 10, &value) || value > 1) 1541 + err = kstrtouint(buf, 10, &value); 1542 + if (err) 1543 + return err; 1544 + 1545 + if (value > 1) 1558 1546 return -EINVAL; 1559 1547 1560 1548 if (atkbd->softraw != value) {
+5 -6
drivers/input/keyboard/lm8323.c
··· 545 545 { 546 546 struct led_classdev *led_cdev = dev_get_drvdata(dev); 547 547 struct lm8323_pwm *pwm = cdev_to_pwm(led_cdev); 548 - int ret; 549 - unsigned long time; 548 + int ret, time; 550 549 551 - ret = strict_strtoul(buf, 10, &time); 550 + ret = kstrtoint(buf, 10, &time); 552 551 /* Numbers only, please. */ 553 552 if (ret) 554 - return -EINVAL; 553 + return ret; 555 554 556 555 pwm->fade_time = time; 557 556 ··· 612 613 { 613 614 struct lm8323_chip *lm = dev_get_drvdata(dev); 614 615 int ret; 615 - unsigned long i; 616 + unsigned int i; 616 617 617 - ret = strict_strtoul(buf, 10, &i); 618 + ret = kstrtouint(buf, 10, &i); 618 619 619 620 mutex_lock(&lm->lock); 620 621 lm->kp_enabled = !i;
+8 -8
drivers/input/misc/adxl34x.c
··· 451 451 const char *buf, size_t count) 452 452 { 453 453 struct adxl34x *ac = dev_get_drvdata(dev); 454 - unsigned long val; 454 + unsigned int val; 455 455 int error; 456 456 457 - error = strict_strtoul(buf, 10, &val); 457 + error = kstrtouint(buf, 10, &val); 458 458 if (error) 459 459 return error; 460 460 ··· 540 540 const char *buf, size_t count) 541 541 { 542 542 struct adxl34x *ac = dev_get_drvdata(dev); 543 - unsigned long val; 543 + unsigned char val; 544 544 int error; 545 545 546 - error = strict_strtoul(buf, 10, &val); 546 + error = kstrtou8(buf, 10, &val); 547 547 if (error) 548 548 return error; 549 549 ··· 575 575 const char *buf, size_t count) 576 576 { 577 577 struct adxl34x *ac = dev_get_drvdata(dev); 578 - unsigned long val; 578 + unsigned int val; 579 579 int error; 580 580 581 - error = strict_strtoul(buf, 10, &val); 581 + error = kstrtouint(buf, 10, &val); 582 582 if (error) 583 583 return error; 584 584 ··· 622 622 const char *buf, size_t count) 623 623 { 624 624 struct adxl34x *ac = dev_get_drvdata(dev); 625 - unsigned long val; 625 + unsigned int val; 626 626 int error; 627 627 628 628 /* 629 629 * This allows basic ADXL register write access for debug purposes. 630 630 */ 631 - error = strict_strtoul(buf, 16, &val); 631 + error = kstrtouint(buf, 16, &val); 632 632 if (error) 633 633 return error; 634 634
+11 -8
drivers/input/misc/ati_remote2.c
··· 41 41 const struct kernel_param *kp, 42 42 unsigned int max) 43 43 { 44 - unsigned long mask; 44 + unsigned int mask; 45 45 int ret; 46 46 47 47 if (!val) 48 48 return -EINVAL; 49 49 50 - ret = strict_strtoul(val, 0, &mask); 50 + ret = kstrtouint(val, 0, &mask); 51 51 if (ret) 52 52 return ret; 53 53 ··· 719 719 struct usb_device *udev = to_usb_device(dev); 720 720 struct usb_interface *intf = usb_ifnum_to_if(udev, 0); 721 721 struct ati_remote2 *ar2 = usb_get_intfdata(intf); 722 - unsigned long mask; 722 + unsigned int mask; 723 723 int r; 724 724 725 - if (strict_strtoul(buf, 0, &mask)) 726 - return -EINVAL; 725 + r = kstrtouint(buf, 0, &mask); 726 + if (r) 727 + return r; 727 728 728 729 if (mask & ~ATI_REMOTE2_MAX_CHANNEL_MASK) 729 730 return -EINVAL; ··· 769 768 struct usb_device *udev = to_usb_device(dev); 770 769 struct usb_interface *intf = usb_ifnum_to_if(udev, 0); 771 770 struct ati_remote2 *ar2 = usb_get_intfdata(intf); 772 - unsigned long mask; 771 + unsigned int mask; 772 + int err; 773 773 774 - if (strict_strtoul(buf, 0, &mask)) 775 - return -EINVAL; 774 + err = kstrtouint(buf, 0, &mask); 775 + if (err) 776 + return err; 776 777 777 778 if (mask & ~ATI_REMOTE2_MAX_MODE_MASK) 778 779 return -EINVAL;
+2 -5
drivers/input/mouse/elantech.c
··· 1031 1031 struct elantech_data *etd = psmouse->private; 1032 1032 struct elantech_attr_data *attr = data; 1033 1033 unsigned char *reg = (unsigned char *) etd + attr->field_offset; 1034 - unsigned long value; 1034 + unsigned char value; 1035 1035 int err; 1036 1036 1037 - err = strict_strtoul(buf, 16, &value); 1037 + err = kstrtou8(buf, 16, &value); 1038 1038 if (err) 1039 1039 return err; 1040 - 1041 - if (value > 0xff) 1042 - return -EINVAL; 1043 1040 1044 1041 /* Do we need to preserve some bits for version 2 hardware too? */ 1045 1042 if (etd->hw_version == 1) {
+12 -6
drivers/input/mouse/hgpk.c
··· 789 789 const char *buf, size_t count) 790 790 { 791 791 struct hgpk_data *priv = psmouse->private; 792 - unsigned long value; 792 + unsigned int value; 793 793 int err; 794 794 795 - err = strict_strtoul(buf, 10, &value); 796 - if (err || value > 1) 795 + err = kstrtouint(buf, 10, &value); 796 + if (err) 797 + return err; 798 + 799 + if (value > 1) 797 800 return -EINVAL; 798 801 799 802 if (value != priv->powered) { ··· 884 881 const char *buf, size_t count) 885 882 { 886 883 struct hgpk_data *priv = psmouse->private; 887 - unsigned long value; 884 + unsigned int value; 888 885 int err; 889 886 890 - err = strict_strtoul(buf, 10, &value); 891 - if (err || value != 1) 887 + err = kstrtouint(buf, 10, &value); 888 + if (err) 889 + return err; 890 + 891 + if (value != 1) 892 892 return -EINVAL; 893 893 894 894 /*
+7 -2
drivers/input/mouse/logips2pp.c
··· 155 155 static ssize_t ps2pp_attr_set_smartscroll(struct psmouse *psmouse, void *data, 156 156 const char *buf, size_t count) 157 157 { 158 - unsigned long value; 158 + unsigned int value; 159 + int err; 159 160 160 - if (strict_strtoul(buf, 10, &value) || value > 1) 161 + err = kstrtouint(buf, 10, &value); 162 + if (err) 163 + return err; 164 + 165 + if (value > 1) 161 166 return -EINVAL; 162 167 163 168 ps2pp_set_smartscroll(psmouse, value);
+15 -12
drivers/input/mouse/psmouse-base.c
··· 1558 1558 static ssize_t psmouse_set_int_attr(struct psmouse *psmouse, void *offset, const char *buf, size_t count) 1559 1559 { 1560 1560 unsigned int *field = (unsigned int *)((char *)psmouse + (size_t)offset); 1561 - unsigned long value; 1561 + unsigned int value; 1562 + int err; 1562 1563 1563 - if (strict_strtoul(buf, 10, &value)) 1564 - return -EINVAL; 1565 - 1566 - if ((unsigned int)value != value) 1567 - return -EINVAL; 1564 + err = kstrtouint(buf, 10, &value); 1565 + if (err) 1566 + return err; 1568 1567 1569 1568 *field = value; 1570 1569 ··· 1670 1671 1671 1672 static ssize_t psmouse_attr_set_rate(struct psmouse *psmouse, void *data, const char *buf, size_t count) 1672 1673 { 1673 - unsigned long value; 1674 + unsigned int value; 1675 + int err; 1674 1676 1675 - if (strict_strtoul(buf, 10, &value)) 1676 - return -EINVAL; 1677 + err = kstrtouint(buf, 10, &value); 1678 + if (err) 1679 + return err; 1677 1680 1678 1681 psmouse->set_rate(psmouse, value); 1679 1682 return count; ··· 1683 1682 1684 1683 static ssize_t psmouse_attr_set_resolution(struct psmouse *psmouse, void *data, const char *buf, size_t count) 1685 1684 { 1686 - unsigned long value; 1685 + unsigned int value; 1686 + int err; 1687 1687 1688 - if (strict_strtoul(buf, 10, &value)) 1689 - return -EINVAL; 1688 + err = kstrtouint(buf, 10, &value); 1689 + if (err) 1690 + return err; 1690 1691 1691 1692 psmouse->set_resolution(psmouse, value); 1692 1693 return count;
+32 -11
drivers/input/mouse/sentelic.c
··· 408 408 static ssize_t fsp_attr_set_setreg(struct psmouse *psmouse, void *data, 409 409 const char *buf, size_t count) 410 410 { 411 - unsigned long reg, val; 411 + int reg, val; 412 412 char *rest; 413 413 ssize_t retval; 414 414 ··· 416 416 if (rest == buf || *rest != ' ' || reg > 0xff) 417 417 return -EINVAL; 418 418 419 - if (strict_strtoul(rest + 1, 16, &val) || val > 0xff) 419 + retval = kstrtoint(rest + 1, 16, &val); 420 + if (retval) 421 + return retval; 422 + 423 + if (val > 0xff) 420 424 return -EINVAL; 421 425 422 426 if (fsp_reg_write_enable(psmouse, true)) ··· 452 448 const char *buf, size_t count) 453 449 { 454 450 struct fsp_data *pad = psmouse->private; 455 - unsigned long reg; 456 - int val; 451 + int reg, val, err; 457 452 458 - if (strict_strtoul(buf, 16, &reg) || reg > 0xff) 453 + err = kstrtoint(buf, 16, &reg); 454 + if (err) 455 + return err; 456 + 457 + if (reg > 0xff) 459 458 return -EINVAL; 460 459 461 460 if (fsp_reg_read(psmouse, reg, &val)) ··· 487 480 static ssize_t fsp_attr_set_pagereg(struct psmouse *psmouse, void *data, 488 481 const char *buf, size_t count) 489 482 { 490 - unsigned long val; 483 + int val, err; 491 484 492 - if (strict_strtoul(buf, 16, &val) || val > 0xff) 485 + err = kstrtoint(buf, 16, &val); 486 + if (err) 487 + return err; 488 + 489 + if (val > 0xff) 493 490 return -EINVAL; 494 491 495 492 if (fsp_page_reg_write(psmouse, val)) ··· 516 505 static ssize_t fsp_attr_set_vscroll(struct psmouse *psmouse, void *data, 517 506 const char *buf, size_t count) 518 507 { 519 - unsigned long val; 508 + unsigned int val; 509 + int err; 520 510 521 - if (strict_strtoul(buf, 10, &val) || val > 1) 511 + err = kstrtouint(buf, 10, &val); 512 + if (err) 513 + return err; 514 + 515 + if (val > 1) 522 516 return -EINVAL; 523 517 524 518 fsp_onpad_vscr(psmouse, val); ··· 545 529 static ssize_t fsp_attr_set_hscroll(struct psmouse *psmouse, void *data, 546 530 const char *buf, size_t count) 547 531 { 548 - unsigned long val; 532 + unsigned int val; 533 + int err; 549 534 550 - if (strict_strtoul(buf, 10, &val) || val > 1) 535 + err = kstrtouint(buf, 10, &val); 536 + if (err) 537 + return err; 538 + 539 + if (val > 1) 551 540 return -EINVAL; 552 541 553 542 fsp_onpad_hscr(psmouse, val);
+12 -5
drivers/input/mouse/trackpoint.c
··· 89 89 struct trackpoint_data *tp = psmouse->private; 90 90 struct trackpoint_attr_data *attr = data; 91 91 unsigned char *field = (unsigned char *)((char *)tp + attr->field_offset); 92 - unsigned long value; 92 + unsigned char value; 93 + int err; 93 94 94 - if (strict_strtoul(buf, 10, &value) || value > 255) 95 - return -EINVAL; 95 + err = kstrtou8(buf, 10, &value); 96 + if (err) 97 + return err; 96 98 97 99 *field = value; 98 100 trackpoint_write(&psmouse->ps2dev, attr->command, value); ··· 117 115 struct trackpoint_data *tp = psmouse->private; 118 116 struct trackpoint_attr_data *attr = data; 119 117 unsigned char *field = (unsigned char *)((char *)tp + attr->field_offset); 120 - unsigned long value; 118 + unsigned int value; 119 + int err; 121 120 122 - if (strict_strtoul(buf, 10, &value) || value > 1) 121 + err = kstrtouint(buf, 10, &value); 122 + if (err) 123 + return err; 124 + 125 + if (value > 1) 123 126 return -EINVAL; 124 127 125 128 if (attr->inverted)
+19 -15
drivers/input/tablet/aiptek.c
··· 1198 1198 store_tabletXtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1199 1199 { 1200 1200 struct aiptek *aiptek = dev_get_drvdata(dev); 1201 - long x; 1201 + int x; 1202 1202 1203 - if (strict_strtol(buf, 10, &x)) { 1203 + if (kstrtoint(buf, 10, &x)) { 1204 1204 size_t len = buf[count - 1] == '\n' ? count - 1 : count; 1205 1205 1206 1206 if (strncmp(buf, "disable", len)) ··· 1240 1240 store_tabletYtilt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1241 1241 { 1242 1242 struct aiptek *aiptek = dev_get_drvdata(dev); 1243 - long y; 1243 + int y; 1244 1244 1245 - if (strict_strtol(buf, 10, &y)) { 1245 + if (kstrtoint(buf, 10, &y)) { 1246 1246 size_t len = buf[count - 1] == '\n' ? count - 1 : count; 1247 1247 1248 1248 if (strncmp(buf, "disable", len)) ··· 1277 1277 store_tabletJitterDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1278 1278 { 1279 1279 struct aiptek *aiptek = dev_get_drvdata(dev); 1280 - long j; 1280 + int err, j; 1281 1281 1282 - if (strict_strtol(buf, 10, &j)) 1283 - return -EINVAL; 1282 + err = kstrtoint(buf, 10, &j); 1283 + if (err) 1284 + return err; 1284 1285 1285 - aiptek->newSetting.jitterDelay = (int)j; 1286 + aiptek->newSetting.jitterDelay = j; 1286 1287 return count; 1287 1288 } 1288 1289 ··· 1307 1306 store_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1308 1307 { 1309 1308 struct aiptek *aiptek = dev_get_drvdata(dev); 1310 - long d; 1309 + int err, d; 1311 1310 1312 - if (strict_strtol(buf, 10, &d)) 1313 - return -EINVAL; 1311 + err = kstrtoint(buf, 10, &d); 1312 + if (err) 1313 + return err; 1314 1314 1315 - aiptek->newSetting.programmableDelay = (int)d; 1315 + aiptek->newSetting.programmableDelay = d; 1316 1316 return count; 1317 1317 } 1318 1318 ··· 1559 1557 store_tabletWheel(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1560 1558 { 1561 1559 struct aiptek *aiptek = dev_get_drvdata(dev); 1562 - long w; 1560 + int err, w; 1563 1561 1564 - if (strict_strtol(buf, 10, &w)) return -EINVAL; 1562 + err = kstrtoint(buf, 10, &w); 1563 + if (err) 1564 + return err; 1565 1565 1566 - aiptek->newSetting.wheel = (int)w; 1566 + aiptek->newSetting.wheel = w; 1567 1567 return count; 1568 1568 } 1569 1569
+8 -8
drivers/input/touchscreen/ad7877.c
··· 487 487 const char *buf, size_t count) 488 488 { 489 489 struct ad7877 *ts = dev_get_drvdata(dev); 490 - unsigned long val; 490 + unsigned int val; 491 491 int error; 492 492 493 - error = strict_strtoul(buf, 10, &val); 493 + error = kstrtouint(buf, 10, &val); 494 494 if (error) 495 495 return error; 496 496 ··· 517 517 const char *buf, size_t count) 518 518 { 519 519 struct ad7877 *ts = dev_get_drvdata(dev); 520 - unsigned long val; 520 + unsigned int val; 521 521 int error; 522 522 523 - error = strict_strtoul(buf, 10, &val); 523 + error = kstrtouint(buf, 10, &val); 524 524 if (error) 525 525 return error; 526 526 ··· 547 547 const char *buf, size_t count) 548 548 { 549 549 struct ad7877 *ts = dev_get_drvdata(dev); 550 - unsigned long val; 550 + unsigned int val; 551 551 int error; 552 552 553 - error = strict_strtoul(buf, 10, &val); 553 + error = kstrtouint(buf, 10, &val); 554 554 if (error) 555 555 return error; 556 556 ··· 578 578 const char *buf, size_t count) 579 579 { 580 580 struct ad7877 *ts = dev_get_drvdata(dev); 581 - unsigned long val; 581 + unsigned int val; 582 582 int error; 583 583 584 - error = strict_strtoul(buf, 10, &val); 584 + error = kstrtouint(buf, 10, &val); 585 585 if (error) 586 586 return error; 587 587
+2 -2
drivers/input/touchscreen/ad7879.c
··· 339 339 const char *buf, size_t count) 340 340 { 341 341 struct ad7879 *ts = dev_get_drvdata(dev); 342 - unsigned long val; 342 + unsigned int val; 343 343 int error; 344 344 345 - error = strict_strtoul(buf, 10, &val); 345 + error = kstrtouint(buf, 10, &val); 346 346 if (error) 347 347 return error; 348 348
+5 -3
drivers/input/touchscreen/ads7846.c
··· 601 601 const char *buf, size_t count) 602 602 { 603 603 struct ads7846 *ts = dev_get_drvdata(dev); 604 - unsigned long i; 604 + unsigned int i; 605 + int err; 605 606 606 - if (strict_strtoul(buf, 10, &i)) 607 - return -EINVAL; 607 + err = kstrtouint(buf, 10, &i); 608 + if (err) 609 + return err; 608 610 609 611 if (i) 610 612 ads7846_disable(ts);