Merge tag 'nfc-next-4.13-1' of git://git.kernel.org/pub/scm/linux/kernel/git/sameo/nfc-next

+2 -8

Documentation/devicetree/bindings/net/nfc/trf7970a.txt

··· 13 13 - pinctrl-names: Contains only one value - "default". 14 14 - pintctrl-0: Specifies the pin control groups used for this controller. 15 15 - autosuspend-delay: Specify autosuspend delay in milliseconds. 16 - - vin-voltage-override: Specify voltage of VIN pin in microvolts. 17 16 - irq-status-read-quirk: Specify that the trf7970a being used has the 18 17 "IRQ Status Read" erratum. 19 18 - en2-rf-quirk: Specify that the trf7970a being used has the "EN2 RF" 20 19 erratum. 21 - - t5t-rmb-extra-byte-quirk: Specify that the trf7970a has the erratum 22 - where an extra byte is returned by Read Multiple Block commands issued 23 - to Type 5 tags. 24 20 - vdd-io-supply: Regulator specifying voltage for vdd-io 25 21 - clock-frequency: Set to specify that the input frequency to the trf7970a is 13560000Hz or 27120000Hz 26 22 ··· 33 37 spi-max-frequency = <2000000>; 34 38 interrupt-parent = <&gpio2>; 35 39 interrupts = <14 0>; 36 - ti,enable-gpios = <&gpio2 2 GPIO_ACTIVE_LOW>, 37 - <&gpio2 5 GPIO_ACTIVE_LOW>; 40 + ti,enable-gpios = <&gpio2 2 GPIO_ACTIVE_HIGH>, 41 + <&gpio2 5 GPIO_ACTIVE_HIGH>; 38 42 vin-supply = <&ldo3_reg>; 39 - vin-voltage-override = <5000000>; 40 43 vdd-io-supply = <&ldo2_reg>; 41 44 autosuspend-delay = <30000>; 42 45 irq-status-read-quirk; 43 46 en2-rf-quirk; 44 - t5t-rmb-extra-byte-quirk; 45 47 clock-frequency = <27120000>; 46 48 status = "okay"; 47 49 };

+8 -3

MAINTAINERS

··· 9082 9082 F: drivers/nfc/ 9083 9083 F: include/linux/platform_data/nfcmrvl.h 9084 9084 F: include/linux/platform_data/nxp-nci.h 9085 - F: include/linux/platform_data/pn544.h 9086 - F: include/linux/platform_data/st21nfca.h 9087 - F: include/linux/platform_data/st-nci.h 9088 9085 F: Documentation/devicetree/bindings/net/nfc/ 9089 9086 9090 9087 NFS, SUNRPC, AND LOCKD CLIENTS ··· 11415 11418 F: kernel/time/alarmtimer.c 11416 11419 F: kernel/time/ntp.c 11417 11420 F: tools/testing/selftests/timers/ 11421 + 11422 + TI TRF7970A NFC DRIVER 11423 + M: Mark Greer <mgreer@animalcreek.com> 11424 + L: linux-wireless@vger.kernel.org 11425 + L: linux-nfc@lists.01.org (moderated for non-subscribers) 11426 + S: Supported 11427 + F: drivers/nfc/trf7970a.c 11428 + F: Documentation/devicetree/bindings/net/nfc/trf7970a.txt 11418 11429 11419 11430 SC1200 WDT DRIVER 11420 11431 M: Zwane Mwaikambo <zwanem@gmail.com>

+1 -1

drivers/nfc/Kconfig

··· 7 7 8 8 config NFC_TRF7970A 9 9 tristate "Texas Instruments TRF7970a NFC driver" 10 - depends on SPI && NFC_DIGITAL 10 + depends on SPI && NFC_DIGITAL && GPIOLIB 11 11 help 12 12 This option enables the NFC driver for Texas Instruments' TRF7970a 13 13 device. Such device supports 5 different protocols: ISO14443A,

+4 -11

drivers/nfc/fdp/fdp.c

··· 749 749 u32 protocols; 750 750 int r; 751 751 752 - info = kzalloc(sizeof(struct fdp_nci_info), GFP_KERNEL); 753 - if (!info) { 754 - r = -ENOMEM; 755 - goto err_info_alloc; 756 - } 752 + info = devm_kzalloc(dev, sizeof(struct fdp_nci_info), GFP_KERNEL); 753 + if (!info) 754 + return -ENOMEM; 757 755 758 756 info->phy = phy; 759 757 info->phy_ops = phy_ops; ··· 773 775 tx_tailroom); 774 776 if (!ndev) { 775 777 nfc_err(dev, "Cannot allocate nfc ndev\n"); 776 - r = -ENOMEM; 777 - goto err_alloc_ndev; 778 + return -ENOMEM; 778 779 } 779 780 780 781 r = nci_register_device(ndev); ··· 789 792 790 793 err_regdev: 791 794 nci_free_device(ndev); 792 - err_alloc_ndev: 793 - kfree(info); 794 - err_info_alloc: 795 795 return r; 796 796 } 797 797 EXPORT_SYMBOL(fdp_nci_probe); ··· 802 808 803 809 nci_unregister_device(ndev); 804 810 nci_free_device(ndev); 805 - kfree(info); 806 811 } 807 812 EXPORT_SYMBOL(fdp_nci_remove); 808 813

+19 -19

drivers/nfc/fdp/i2c.c

··· 27 27 28 28 #define FDP_I2C_DRIVER_NAME "fdp_nci_i2c" 29 29 30 - #define FDP_DP_POWER_GPIO_NAME "power" 31 30 #define FDP_DP_CLOCK_TYPE_NAME "clock-type" 32 31 #define FDP_DP_CLOCK_FREQ_NAME "clock-freq" 33 32 #define FDP_DP_FW_VSC_CFG_NAME "fw-vsc-cfg" ··· 280 281 *clock_type, *clock_freq, *fw_vsc_cfg != NULL ? "yes" : "no"); 281 282 } 282 283 283 - static int fdp_nci_i2c_probe(struct i2c_client *client, 284 - const struct i2c_device_id *id) 284 + static const struct acpi_gpio_params power_gpios = { 0, 0, false }; 285 + 286 + static const struct acpi_gpio_mapping acpi_fdp_gpios[] = { 287 + { "power-gpios", &power_gpios, 1 }, 288 + {}, 289 + }; 290 + 291 + static int fdp_nci_i2c_probe(struct i2c_client *client) 285 292 { 286 293 struct fdp_i2c_phy *phy; 287 294 struct device *dev = &client->dev; ··· 309 304 return -ENODEV; 310 305 } 311 306 312 - phy = devm_kzalloc(dev, sizeof(struct fdp_i2c_phy), 313 - GFP_KERNEL); 307 + phy = devm_kzalloc(dev, sizeof(struct fdp_i2c_phy), GFP_KERNEL); 314 308 if (!phy) 315 309 return -ENOMEM; 316 310 ··· 317 313 phy->next_read_size = FDP_NCI_I2C_MIN_PAYLOAD; 318 314 i2c_set_clientdata(client, phy); 319 315 320 - r = request_threaded_irq(client->irq, NULL, fdp_nci_i2c_irq_thread_fn, 321 - IRQF_TRIGGER_RISING | IRQF_ONESHOT, 322 - FDP_I2C_DRIVER_NAME, phy); 316 + r = devm_request_threaded_irq(dev, client->irq, 317 + NULL, fdp_nci_i2c_irq_thread_fn, 318 + IRQF_TRIGGER_RISING | IRQF_ONESHOT, 319 + FDP_I2C_DRIVER_NAME, phy); 323 320 324 321 if (r < 0) { 325 322 nfc_err(&client->dev, "Unable to register IRQ handler\n"); 326 323 return r; 327 324 } 328 325 329 - /* Requesting the power gpio */ 330 - phy->power_gpio = devm_gpiod_get(dev, FDP_DP_POWER_GPIO_NAME, 331 - GPIOD_OUT_LOW); 326 + r = devm_acpi_dev_add_driver_gpios(dev, acpi_fdp_gpios); 327 + if (r) 328 + dev_dbg(dev, "Unable to add GPIO mapping table\n"); 332 329 330 + /* Requesting the power gpio */ 331 + phy->power_gpio = devm_gpiod_get(dev, "power", GPIOD_OUT_LOW); 333 332 if (IS_ERR(phy->power_gpio)) { 334 333 nfc_err(dev, "Power GPIO request failed\n"); 335 334 return PTR_ERR(phy->power_gpio); ··· 367 360 return 0; 368 361 } 369 362 370 - static struct i2c_device_id fdp_nci_i2c_id_table[] = { 371 - {"int339a", 0}, 372 - {} 373 - }; 374 - MODULE_DEVICE_TABLE(i2c, fdp_nci_i2c_id_table); 375 - 376 363 static const struct acpi_device_id fdp_nci_i2c_acpi_match[] = { 377 364 {"INT339A", 0}, 378 365 {} ··· 378 377 .name = FDP_I2C_DRIVER_NAME, 379 378 .acpi_match_table = ACPI_PTR(fdp_nci_i2c_acpi_match), 380 379 }, 381 - .id_table = fdp_nci_i2c_id_table, 382 - .probe = fdp_nci_i2c_probe, 380 + .probe_new = fdp_nci_i2c_probe, 383 381 .remove = fdp_nci_i2c_remove, 384 382 }; 385 383 module_i2c_driver(fdp_nci_i2c_driver);

+5 -2

drivers/nfc/nfcmrvl/fw_dnld.c

··· 457 457 458 458 INIT_WORK(&priv->fw_dnld.rx_work, fw_dnld_rx_work); 459 459 snprintf(name, sizeof(name), "%s_nfcmrvl_fw_dnld_rx_wq", 460 - dev_name(priv->dev)); 460 + dev_name(&priv->ndev->nfc_dev->dev)); 461 461 priv->fw_dnld.rx_wq = create_singlethread_workqueue(name); 462 462 if (!priv->fw_dnld.rx_wq) 463 463 return -ENOMEM; ··· 494 494 { 495 495 struct nfcmrvl_private *priv = nci_get_drvdata(ndev); 496 496 struct nfcmrvl_fw_dnld *fw_dnld = &priv->fw_dnld; 497 + int res; 497 498 498 499 if (!priv->support_fw_dnld) 499 500 return -ENOTSUPP; ··· 510 509 */ 511 510 512 511 /* Retrieve FW binary */ 513 - if (request_firmware(&fw_dnld->fw, firmware_name, priv->dev) < 0) { 512 + res = request_firmware(&fw_dnld->fw, firmware_name, 513 + &ndev->nfc_dev->dev); 514 + if (res < 0) { 514 515 nfc_err(priv->dev, "failed to retrieve FW %s", firmware_name); 515 516 return -ENOENT; 516 517 }

+26 -22

drivers/nfc/nfcmrvl/main.c

··· 123 123 124 124 memcpy(&priv->config, pdata, sizeof(*pdata)); 125 125 126 - if (priv->config.reset_n_io) { 127 - rc = devm_gpio_request_one(dev, 128 - priv->config.reset_n_io, 129 - GPIOF_OUT_INIT_LOW, 130 - "nfcmrvl_reset_n"); 131 - if (rc < 0) 126 + if (gpio_is_valid(priv->config.reset_n_io)) { 127 + rc = gpio_request_one(priv->config.reset_n_io, 128 + GPIOF_OUT_INIT_LOW, 129 + "nfcmrvl_reset_n"); 130 + if (rc < 0) { 131 + priv->config.reset_n_io = -EINVAL; 132 132 nfc_err(dev, "failed to request reset_n io\n"); 133 + } 133 134 } 134 135 135 136 if (phy == NFCMRVL_PHY_SPI) { ··· 155 154 if (!priv->ndev) { 156 155 nfc_err(dev, "nci_allocate_device failed\n"); 157 156 rc = -ENOMEM; 158 - goto error; 157 + goto error_free_gpio; 159 158 } 160 - 161 - nci_set_drvdata(priv->ndev, priv); 162 - 163 - rc = nci_register_device(priv->ndev); 164 - if (rc) { 165 - nfc_err(dev, "nci_register_device failed %d\n", rc); 166 - goto error_free_dev; 167 - } 168 - 169 - /* Ensure that controller is powered off */ 170 - nfcmrvl_chip_halt(priv); 171 159 172 160 rc = nfcmrvl_fw_dnld_init(priv); 173 161 if (rc) { ··· 164 174 goto error_free_dev; 165 175 } 166 176 177 + nci_set_drvdata(priv->ndev, priv); 178 + 179 + rc = nci_register_device(priv->ndev); 180 + if (rc) { 181 + nfc_err(dev, "nci_register_device failed %d\n", rc); 182 + goto error_fw_dnld_deinit; 183 + } 184 + 185 + /* Ensure that controller is powered off */ 186 + nfcmrvl_chip_halt(priv); 187 + 167 188 nfc_info(dev, "registered with nci successfully\n"); 168 189 return priv; 169 190 191 + error_fw_dnld_deinit: 192 + nfcmrvl_fw_dnld_deinit(priv); 170 193 error_free_dev: 171 194 nci_free_device(priv->ndev); 172 - error: 195 + error_free_gpio: 196 + if (gpio_is_valid(priv->config.reset_n_io)) 197 + gpio_free(priv->config.reset_n_io); 173 198 kfree(priv); 174 199 return ERR_PTR(rc); 175 200 } ··· 199 194 200 195 nfcmrvl_fw_dnld_deinit(priv); 201 196 202 - if (priv->config.reset_n_io) 203 - devm_gpio_free(priv->dev, priv->config.reset_n_io); 197 + if (gpio_is_valid(priv->config.reset_n_io)) 198 + gpio_free(priv->config.reset_n_io); 204 199 205 200 nci_unregister_device(ndev); 206 201 nci_free_device(ndev); ··· 267 262 reset_n_io = of_get_named_gpio(node, "reset-n-io", 0); 268 263 if (reset_n_io < 0) { 269 264 pr_info("no reset-n-io config\n"); 270 - reset_n_io = 0; 271 265 } else if (!gpio_is_valid(reset_n_io)) { 272 266 pr_err("invalid reset-n-io GPIO\n"); 273 267 return reset_n_io;

+7 -4

drivers/nfc/nfcmrvl/uart.c

··· 84 84 ret = nfcmrvl_parse_dt(matched_node, pdata); 85 85 if (ret < 0) { 86 86 pr_err("Failed to get generic entries\n"); 87 + of_node_put(matched_node); 87 88 return ret; 88 89 } 89 90 ··· 98 97 else 99 98 pdata->break_control = 0; 100 99 100 + of_node_put(matched_node); 101 + 101 102 return 0; 102 103 } 103 104 ··· 112 109 struct nfcmrvl_private *priv; 113 110 struct nfcmrvl_platform_data *pdata = NULL; 114 111 struct nfcmrvl_platform_data config; 112 + struct device *dev = nu->tty->dev; 115 113 116 114 /* 117 115 * Platform data cannot be used here since usually it is already used ··· 120 116 * and check if DT entries were added. 121 117 */ 122 118 123 - if (nu->tty->dev->parent && nu->tty->dev->parent->of_node) 124 - if (nfcmrvl_uart_parse_dt(nu->tty->dev->parent->of_node, 125 - &config) == 0) 119 + if (dev && dev->parent && dev->parent->of_node) 120 + if (nfcmrvl_uart_parse_dt(dev->parent->of_node, &config) == 0) 126 121 pdata = &config; 127 122 128 123 if (!pdata) { ··· 134 131 } 135 132 136 133 priv = nfcmrvl_nci_register_dev(NFCMRVL_PHY_UART, nu, &uart_ops, 137 - nu->tty->dev, pdata); 134 + dev, pdata); 138 135 if (IS_ERR(priv)) 139 136 return PTR_ERR(priv); 140 137

+1 -3

drivers/nfc/nfcmrvl/usb.c

··· 341 341 init_usb_anchor(&drv_data->deferred); 342 342 343 343 priv = nfcmrvl_nci_register_dev(NFCMRVL_PHY_USB, drv_data, &usb_ops, 344 - &drv_data->udev->dev, &config); 344 + &intf->dev, &config); 345 345 if (IS_ERR(priv)) 346 346 return PTR_ERR(priv); 347 347 348 348 drv_data->priv = priv; 349 349 drv_data->priv->support_fw_dnld = false; 350 - 351 - priv->dev = &drv_data->udev->dev; 352 350 353 351 usb_set_intfdata(intf, drv_data); 354 352

+4 -2

drivers/nfc/nfcsim.c

··· 482 482 exit_err: 483 483 pr_err("Failed to initialize nfcsim driver (%d)\n", rc); 484 484 485 - nfcsim_link_free(link0); 486 - nfcsim_link_free(link1); 485 + if (link0) 486 + nfcsim_link_free(link0); 487 + if (link1) 488 + nfcsim_link_free(link1); 487 489 488 490 return rc; 489 491 }

+1 -2

drivers/nfc/pn544/i2c.c

··· 904 904 phy->i2c_dev = client; 905 905 i2c_set_clientdata(client, phy); 906 906 907 - r = acpi_dev_add_driver_gpios(ACPI_COMPANION(dev), acpi_pn544_gpios); 907 + r = devm_acpi_dev_add_driver_gpios(dev, acpi_pn544_gpios); 908 908 if (r) 909 909 dev_dbg(dev, "Unable to add GPIO mapping table\n"); 910 910 ··· 958 958 if (phy->powered) 959 959 pn544_hci_i2c_disable(phy); 960 960 961 - acpi_dev_remove_driver_gpios(ACPI_COMPANION(&client->dev)); 962 961 return 0; 963 962 } 964 963

+26 -138

drivers/nfc/st-nci/i2c.c

··· 19 19 20 20 #include <linux/module.h> 21 21 #include <linux/i2c.h> 22 - #include <linux/gpio.h> 23 22 #include <linux/gpio/consumer.h> 24 - #include <linux/of_irq.h> 25 - #include <linux/of_gpio.h> 26 23 #include <linux/acpi.h> 27 24 #include <linux/interrupt.h> 28 25 #include <linux/delay.h> 29 26 #include <linux/nfc.h> 30 - #include <linux/platform_data/st-nci.h> 27 + #include <linux/of.h> 31 28 32 29 #include "st-nci.h" 33 30 ··· 37 40 #define ST_NCI_I2C_MIN_SIZE 4 /* PCB(1) + NCI Packet header(3) */ 38 41 #define ST_NCI_I2C_MAX_SIZE 250 /* req 4.2.1 */ 39 42 43 + #define ST_NCI_DRIVER_NAME "st_nci" 40 44 #define ST_NCI_I2C_DRIVER_NAME "st_nci_i2c" 41 - 42 - #define ST_NCI_GPIO_NAME_RESET "reset" 43 45 44 46 struct st_nci_i2c_phy { 45 47 struct i2c_client *i2c_dev; ··· 46 50 47 51 bool irq_active; 48 52 49 - unsigned int gpio_reset; 50 - unsigned int irq_polarity; 53 + struct gpio_desc *gpiod_reset; 51 54 52 55 struct st_nci_se_status se_status; 53 56 }; ··· 55 60 { 56 61 struct st_nci_i2c_phy *phy = phy_id; 57 62 58 - gpio_set_value(phy->gpio_reset, 0); 63 + gpiod_set_value(phy->gpiod_reset, 0); 59 64 usleep_range(10000, 15000); 60 - gpio_set_value(phy->gpio_reset, 1); 65 + gpiod_set_value(phy->gpiod_reset, 1); 61 66 usleep_range(80000, 85000); 62 67 63 68 if (phy->ndlc->powered == 0 && phy->irq_active == 0) { ··· 203 208 .disable = st_nci_i2c_disable, 204 209 }; 205 210 206 - static int st_nci_i2c_acpi_request_resources(struct i2c_client *client) 207 - { 208 - struct st_nci_i2c_phy *phy = i2c_get_clientdata(client); 209 - struct gpio_desc *gpiod_reset; 210 - struct device *dev = &client->dev; 211 - u8 tmp; 211 + static const struct acpi_gpio_params reset_gpios = { 1, 0, false }; 212 212 213 - /* Get RESET GPIO from ACPI */ 214 - gpiod_reset = devm_gpiod_get_index(dev, ST_NCI_GPIO_NAME_RESET, 1, 215 - GPIOD_OUT_HIGH); 216 - if (IS_ERR(gpiod_reset)) { 217 - nfc_err(dev, "Unable to get RESET GPIO\n"); 218 - return -ENODEV; 219 - } 220 - 221 - phy->gpio_reset = desc_to_gpio(gpiod_reset); 222 - 223 - phy->irq_polarity = irq_get_trigger_type(client->irq); 224 - 225 - phy->se_status.is_ese_present = false; 226 - phy->se_status.is_uicc_present = false; 227 - 228 - if (device_property_present(dev, "ese-present")) { 229 - device_property_read_u8(dev, "ese-present", &tmp); 230 - phy->se_status.is_ese_present = tmp; 231 - } 232 - 233 - if (device_property_present(dev, "uicc-present")) { 234 - device_property_read_u8(dev, "uicc-present", &tmp); 235 - phy->se_status.is_uicc_present = tmp; 236 - } 237 - 238 - return 0; 239 - } 240 - 241 - static int st_nci_i2c_of_request_resources(struct i2c_client *client) 242 - { 243 - struct st_nci_i2c_phy *phy = i2c_get_clientdata(client); 244 - struct device_node *pp; 245 - int gpio; 246 - int r; 247 - 248 - pp = client->dev.of_node; 249 - if (!pp) 250 - return -ENODEV; 251 - 252 - /* Get GPIO from device tree */ 253 - gpio = of_get_named_gpio(pp, "reset-gpios", 0); 254 - if (gpio < 0) { 255 - nfc_err(&client->dev, 256 - "Failed to retrieve reset-gpios from device tree\n"); 257 - return gpio; 258 - } 259 - 260 - /* GPIO request and configuration */ 261 - r = devm_gpio_request_one(&client->dev, gpio, 262 - GPIOF_OUT_INIT_HIGH, ST_NCI_GPIO_NAME_RESET); 263 - if (r) { 264 - nfc_err(&client->dev, "Failed to request reset pin\n"); 265 - return r; 266 - } 267 - phy->gpio_reset = gpio; 268 - 269 - phy->irq_polarity = irq_get_trigger_type(client->irq); 270 - 271 - phy->se_status.is_ese_present = 272 - of_property_read_bool(pp, "ese-present"); 273 - phy->se_status.is_uicc_present = 274 - of_property_read_bool(pp, "uicc-present"); 275 - 276 - return 0; 277 - } 278 - 279 - static int st_nci_i2c_request_resources(struct i2c_client *client) 280 - { 281 - struct st_nci_nfc_platform_data *pdata; 282 - struct st_nci_i2c_phy *phy = i2c_get_clientdata(client); 283 - int r; 284 - 285 - pdata = client->dev.platform_data; 286 - if (pdata == NULL) { 287 - nfc_err(&client->dev, "No platform data\n"); 288 - return -EINVAL; 289 - } 290 - 291 - /* store for later use */ 292 - phy->gpio_reset = pdata->gpio_reset; 293 - phy->irq_polarity = pdata->irq_polarity; 294 - 295 - r = devm_gpio_request_one(&client->dev, 296 - phy->gpio_reset, GPIOF_OUT_INIT_HIGH, 297 - ST_NCI_GPIO_NAME_RESET); 298 - if (r) { 299 - pr_err("%s : reset gpio_request failed\n", __FILE__); 300 - return r; 301 - } 302 - 303 - phy->se_status.is_ese_present = pdata->is_ese_present; 304 - phy->se_status.is_uicc_present = pdata->is_uicc_present; 305 - 306 - return 0; 307 - } 213 + static const struct acpi_gpio_mapping acpi_st_nci_gpios[] = { 214 + { "reset-gpios", &reset_gpios, 1 }, 215 + {}, 216 + }; 308 217 309 218 static int st_nci_i2c_probe(struct i2c_client *client, 310 219 const struct i2c_device_id *id) 311 220 { 221 + struct device *dev = &client->dev; 312 222 struct st_nci_i2c_phy *phy; 313 - struct st_nci_nfc_platform_data *pdata; 314 223 int r; 315 224 316 225 dev_dbg(&client->dev, "%s\n", __func__); ··· 225 326 return -ENODEV; 226 327 } 227 328 228 - phy = devm_kzalloc(&client->dev, sizeof(struct st_nci_i2c_phy), 229 - GFP_KERNEL); 329 + phy = devm_kzalloc(dev, sizeof(struct st_nci_i2c_phy), GFP_KERNEL); 230 330 if (!phy) 231 331 return -ENOMEM; 232 332 ··· 233 335 234 336 i2c_set_clientdata(client, phy); 235 337 236 - pdata = client->dev.platform_data; 237 - if (!pdata && client->dev.of_node) { 238 - r = st_nci_i2c_of_request_resources(client); 239 - if (r) { 240 - nfc_err(&client->dev, "No platform data\n"); 241 - return r; 242 - } 243 - } else if (pdata) { 244 - r = st_nci_i2c_request_resources(client); 245 - if (r) { 246 - nfc_err(&client->dev, 247 - "Cannot get platform resources\n"); 248 - return r; 249 - } 250 - } else if (ACPI_HANDLE(&client->dev)) { 251 - r = st_nci_i2c_acpi_request_resources(client); 252 - if (r) { 253 - nfc_err(&client->dev, "Cannot get ACPI data\n"); 254 - return r; 255 - } 256 - } else { 257 - nfc_err(&client->dev, 258 - "st_nci platform resources not available\n"); 338 + r = devm_acpi_dev_add_driver_gpios(dev, acpi_st_nci_gpios); 339 + if (r) 340 + dev_dbg(dev, "Unable to add GPIO mapping table\n"); 341 + 342 + /* Get RESET GPIO */ 343 + phy->gpiod_reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); 344 + if (IS_ERR(phy->gpiod_reset)) { 345 + nfc_err(dev, "Unable to get RESET GPIO\n"); 259 346 return -ENODEV; 260 347 } 348 + 349 + phy->se_status.is_ese_present = 350 + device_property_read_bool(dev, "ese-present"); 351 + phy->se_status.is_uicc_present = 352 + device_property_read_bool(dev, "uicc-present"); 261 353 262 354 r = ndlc_probe(phy, &i2c_phy_ops, &client->dev, 263 355 ST_NCI_FRAME_HEADROOM, ST_NCI_FRAME_TAILROOM, ··· 260 372 phy->irq_active = true; 261 373 r = devm_request_threaded_irq(&client->dev, client->irq, NULL, 262 374 st_nci_irq_thread_fn, 263 - phy->irq_polarity | IRQF_ONESHOT, 375 + IRQF_ONESHOT, 264 376 ST_NCI_DRIVER_NAME, phy); 265 377 if (r < 0) 266 378 nfc_err(&client->dev, "Unable to register IRQ handler\n");

+25 -137

drivers/nfc/st-nci/spi.c

··· 19 19 20 20 #include <linux/module.h> 21 21 #include <linux/spi/spi.h> 22 - #include <linux/gpio.h> 23 22 #include <linux/gpio/consumer.h> 24 - #include <linux/of_irq.h> 25 - #include <linux/of_gpio.h> 26 23 #include <linux/acpi.h> 27 24 #include <linux/interrupt.h> 28 25 #include <linux/delay.h> 29 26 #include <linux/nfc.h> 27 + #include <linux/of.h> 30 28 #include <net/nfc/nci.h> 31 - #include <linux/platform_data/st-nci.h> 32 29 33 30 #include "st-nci.h" 34 31 ··· 38 41 #define ST_NCI_SPI_MIN_SIZE 4 /* PCB(1) + NCI Packet header(3) */ 39 42 #define ST_NCI_SPI_MAX_SIZE 250 /* req 4.2.1 */ 40 43 44 + #define ST_NCI_DRIVER_NAME "st_nci" 41 45 #define ST_NCI_SPI_DRIVER_NAME "st_nci_spi" 42 - 43 - #define ST_NCI_GPIO_NAME_RESET "reset" 44 46 45 47 struct st_nci_spi_phy { 46 48 struct spi_device *spi_dev; ··· 47 51 48 52 bool irq_active; 49 53 50 - unsigned int gpio_reset; 51 - unsigned int irq_polarity; 54 + struct gpio_desc *gpiod_reset; 52 55 53 56 struct st_nci_se_status se_status; 54 57 }; ··· 56 61 { 57 62 struct st_nci_spi_phy *phy = phy_id; 58 63 59 - gpio_set_value(phy->gpio_reset, 0); 64 + gpiod_set_value(phy->gpiod_reset, 0); 60 65 usleep_range(10000, 15000); 61 - gpio_set_value(phy->gpio_reset, 1); 66 + gpiod_set_value(phy->gpiod_reset, 1); 62 67 usleep_range(80000, 85000); 63 68 64 69 if (phy->ndlc->powered == 0 && phy->irq_active == 0) { ··· 218 223 .disable = st_nci_spi_disable, 219 224 }; 220 225 221 - static int st_nci_spi_acpi_request_resources(struct spi_device *spi_dev) 222 - { 223 - struct st_nci_spi_phy *phy = spi_get_drvdata(spi_dev); 224 - struct gpio_desc *gpiod_reset; 225 - struct device *dev = &spi_dev->dev; 226 - u8 tmp; 226 + static const struct acpi_gpio_params reset_gpios = { 1, 0, false }; 227 227 228 - /* Get RESET GPIO from ACPI */ 229 - gpiod_reset = devm_gpiod_get_index(dev, ST_NCI_GPIO_NAME_RESET, 1, 230 - GPIOD_OUT_HIGH); 231 - if (IS_ERR(gpiod_reset)) { 232 - nfc_err(dev, "Unable to get RESET GPIO\n"); 233 - return -ENODEV; 234 - } 235 - 236 - phy->gpio_reset = desc_to_gpio(gpiod_reset); 237 - 238 - phy->irq_polarity = irq_get_trigger_type(spi_dev->irq); 239 - 240 - phy->se_status.is_ese_present = false; 241 - phy->se_status.is_uicc_present = false; 242 - 243 - if (device_property_present(dev, "ese-present")) { 244 - device_property_read_u8(dev, "ese-present", &tmp); 245 - tmp = phy->se_status.is_ese_present; 246 - } 247 - 248 - if (device_property_present(dev, "uicc-present")) { 249 - device_property_read_u8(dev, "uicc-present", &tmp); 250 - tmp = phy->se_status.is_uicc_present; 251 - } 252 - 253 - return 0; 254 - } 255 - 256 - static int st_nci_spi_of_request_resources(struct spi_device *dev) 257 - { 258 - struct st_nci_spi_phy *phy = spi_get_drvdata(dev); 259 - struct device_node *pp; 260 - int gpio; 261 - int r; 262 - 263 - pp = dev->dev.of_node; 264 - if (!pp) 265 - return -ENODEV; 266 - 267 - /* Get GPIO from device tree */ 268 - gpio = of_get_named_gpio(pp, "reset-gpios", 0); 269 - if (gpio < 0) { 270 - nfc_err(&dev->dev, 271 - "Failed to retrieve reset-gpios from device tree\n"); 272 - return gpio; 273 - } 274 - 275 - /* GPIO request and configuration */ 276 - r = devm_gpio_request_one(&dev->dev, gpio, 277 - GPIOF_OUT_INIT_HIGH, ST_NCI_GPIO_NAME_RESET); 278 - if (r) { 279 - nfc_err(&dev->dev, "Failed to request reset pin\n"); 280 - return r; 281 - } 282 - phy->gpio_reset = gpio; 283 - 284 - phy->irq_polarity = irq_get_trigger_type(dev->irq); 285 - 286 - phy->se_status.is_ese_present = 287 - of_property_read_bool(pp, "ese-present"); 288 - phy->se_status.is_uicc_present = 289 - of_property_read_bool(pp, "uicc-present"); 290 - 291 - return 0; 292 - } 293 - 294 - static int st_nci_spi_request_resources(struct spi_device *dev) 295 - { 296 - struct st_nci_nfc_platform_data *pdata; 297 - struct st_nci_spi_phy *phy = spi_get_drvdata(dev); 298 - int r; 299 - 300 - pdata = dev->dev.platform_data; 301 - if (pdata == NULL) { 302 - nfc_err(&dev->dev, "No platform data\n"); 303 - return -EINVAL; 304 - } 305 - 306 - /* store for later use */ 307 - phy->gpio_reset = pdata->gpio_reset; 308 - phy->irq_polarity = pdata->irq_polarity; 309 - 310 - r = devm_gpio_request_one(&dev->dev, 311 - phy->gpio_reset, GPIOF_OUT_INIT_HIGH, 312 - ST_NCI_GPIO_NAME_RESET); 313 - if (r) { 314 - pr_err("%s : reset gpio_request failed\n", __FILE__); 315 - return r; 316 - } 317 - 318 - phy->se_status.is_ese_present = pdata->is_ese_present; 319 - phy->se_status.is_uicc_present = pdata->is_uicc_present; 320 - 321 - return 0; 322 - } 228 + static const struct acpi_gpio_mapping acpi_st_nci_gpios[] = { 229 + { "reset-gpios", &reset_gpios, 1 }, 230 + {}, 231 + }; 323 232 324 233 static int st_nci_spi_probe(struct spi_device *dev) 325 234 { 326 235 struct st_nci_spi_phy *phy; 327 - struct st_nci_nfc_platform_data *pdata; 328 236 int r; 329 237 330 238 dev_dbg(&dev->dev, "%s\n", __func__); ··· 249 351 250 352 spi_set_drvdata(dev, phy); 251 353 252 - pdata = dev->dev.platform_data; 253 - if (!pdata && dev->dev.of_node) { 254 - r = st_nci_spi_of_request_resources(dev); 255 - if (r) { 256 - nfc_err(&dev->dev, "No platform data\n"); 257 - return r; 258 - } 259 - } else if (pdata) { 260 - r = st_nci_spi_request_resources(dev); 261 - if (r) { 262 - nfc_err(&dev->dev, 263 - "Cannot get platform resources\n"); 264 - return r; 265 - } 266 - } else if (ACPI_HANDLE(&dev->dev)) { 267 - r = st_nci_spi_acpi_request_resources(dev); 268 - if (r) { 269 - nfc_err(&dev->dev, "Cannot get ACPI data\n"); 270 - return r; 271 - } 272 - } else { 273 - nfc_err(&dev->dev, 274 - "st_nci platform resources not available\n"); 275 - return -ENODEV; 354 + r = devm_acpi_dev_add_driver_gpios(&dev->dev, acpi_st_nci_gpios); 355 + if (r) 356 + dev_dbg(&dev->dev, "Unable to add GPIO mapping table\n"); 357 + 358 + /* Get RESET GPIO */ 359 + phy->gpiod_reset = devm_gpiod_get(&dev->dev, "reset", GPIOD_OUT_HIGH); 360 + if (IS_ERR(phy->gpiod_reset)) { 361 + nfc_err(&dev->dev, "Unable to get RESET GPIO\n"); 362 + return PTR_ERR(phy->gpiod_reset); 276 363 } 364 + 365 + phy->se_status.is_ese_present = 366 + device_property_read_bool(&dev->dev, "ese-present"); 367 + phy->se_status.is_uicc_present = 368 + device_property_read_bool(&dev->dev, "uicc-present"); 277 369 278 370 r = ndlc_probe(phy, &spi_phy_ops, &dev->dev, 279 371 ST_NCI_FRAME_HEADROOM, ST_NCI_FRAME_TAILROOM, ··· 276 388 phy->irq_active = true; 277 389 r = devm_request_threaded_irq(&dev->dev, dev->irq, NULL, 278 390 st_nci_irq_thread_fn, 279 - phy->irq_polarity | IRQF_ONESHOT, 391 + IRQF_ONESHOT, 280 392 ST_NCI_SPI_DRIVER_NAME, phy); 281 393 if (r < 0) 282 394 nfc_err(&dev->dev, "Unable to register IRQ handler\n");

+15 -47

drivers/nfc/st21nfca/i2c.c

··· 61 61 #define ST21NFCA_HCI_DRIVER_NAME "st21nfca_hci" 62 62 #define ST21NFCA_HCI_I2C_DRIVER_NAME "st21nfca_hci_i2c" 63 63 64 - #define ST21NFCA_GPIO_NAME_EN "enable" 65 - 66 64 struct st21nfca_i2c_phy { 67 65 struct i2c_client *i2c_dev; 68 66 struct nfc_hci_dev *hdev; ··· 499 501 .disable = st21nfca_hci_i2c_disable, 500 502 }; 501 503 502 - static int st21nfca_hci_i2c_acpi_request_resources(struct i2c_client *client) 503 - { 504 - struct st21nfca_i2c_phy *phy = i2c_get_clientdata(client); 505 - struct device *dev = &client->dev; 504 + static const struct acpi_gpio_params enable_gpios = { 1, 0, false }; 506 505 507 - /* Get EN GPIO from ACPI */ 508 - phy->gpiod_ena = devm_gpiod_get_index(dev, ST21NFCA_GPIO_NAME_EN, 1, 509 - GPIOD_OUT_LOW); 510 - if (IS_ERR(phy->gpiod_ena)) { 511 - nfc_err(dev, "Unable to get ENABLE GPIO\n"); 512 - return PTR_ERR(phy->gpiod_ena); 513 - } 514 - 515 - return 0; 516 - } 517 - 518 - static int st21nfca_hci_i2c_of_request_resources(struct i2c_client *client) 519 - { 520 - struct st21nfca_i2c_phy *phy = i2c_get_clientdata(client); 521 - struct device *dev = &client->dev; 522 - 523 - /* Get GPIO from device tree */ 524 - phy->gpiod_ena = devm_gpiod_get_index(dev, ST21NFCA_GPIO_NAME_EN, 0, 525 - GPIOD_OUT_HIGH); 526 - if (IS_ERR(phy->gpiod_ena)) { 527 - nfc_err(dev, "Failed to request enable pin\n"); 528 - return PTR_ERR(phy->gpiod_ena); 529 - } 530 - 531 - return 0; 532 - } 506 + static const struct acpi_gpio_mapping acpi_st21nfca_gpios[] = { 507 + { "enable-gpios", &enable_gpios, 1 }, 508 + {}, 509 + }; 533 510 534 511 static int st21nfca_hci_i2c_probe(struct i2c_client *client, 535 512 const struct i2c_device_id *id) 536 513 { 514 + struct device *dev = &client->dev; 537 515 struct st21nfca_i2c_phy *phy; 538 516 int r; 539 517 ··· 536 562 mutex_init(&phy->phy_lock); 537 563 i2c_set_clientdata(client, phy); 538 564 539 - if (client->dev.of_node) { 540 - r = st21nfca_hci_i2c_of_request_resources(client); 541 - if (r) { 542 - nfc_err(&client->dev, "No platform data\n"); 543 - return r; 544 - } 545 - } else if (ACPI_HANDLE(&client->dev)) { 546 - r = st21nfca_hci_i2c_acpi_request_resources(client); 547 - if (r) { 548 - nfc_err(&client->dev, "Cannot get ACPI data\n"); 549 - return r; 550 - } 551 - } else { 552 - nfc_err(&client->dev, "st21nfca platform resources not available\n"); 553 - return -ENODEV; 565 + r = devm_acpi_dev_add_driver_gpios(dev, acpi_st21nfca_gpios); 566 + if (r) 567 + dev_dbg(dev, "Unable to add GPIO mapping table\n"); 568 + 569 + /* Get EN GPIO from resource provider */ 570 + phy->gpiod_ena = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW); 571 + if (IS_ERR(phy->gpiod_ena)) { 572 + nfc_err(dev, "Unable to get ENABLE GPIO\n"); 573 + return PTR_ERR(phy->gpiod_ena); 554 574 } 555 575 556 576 phy->se_status.is_ese_present =

+183 -208

drivers/nfc/trf7970a.c

··· 20 20 #include <linux/nfc.h> 21 21 #include <linux/skbuff.h> 22 22 #include <linux/delay.h> 23 - #include <linux/gpio.h> 23 + #include <linux/gpio/consumer.h> 24 24 #include <linux/of.h> 25 - #include <linux/of_gpio.h> 26 25 #include <linux/spi/spi.h> 27 26 #include <linux/regulator/consumer.h> 28 27 ··· 122 123 NFC_PROTO_ISO14443_B_MASK | NFC_PROTO_FELICA_MASK | \ 123 124 NFC_PROTO_ISO15693_MASK | NFC_PROTO_NFC_DEP_MASK) 124 125 125 - #define TRF7970A_AUTOSUSPEND_DELAY 30000 /* 30 seconds */ 126 + #define TRF7970A_AUTOSUSPEND_DELAY 30000 /* 30 seconds */ 126 127 #define TRF7970A_13MHZ_CLOCK_FREQUENCY 13560000 127 128 #define TRF7970A_27MHZ_CLOCK_FREQUENCY 27120000 128 - 129 129 130 130 #define TRF7970A_RX_SKB_ALLOC_SIZE 256 131 131 ··· 150 152 */ 151 153 #define TRF7970A_QUIRK_IRQ_STATUS_READ BIT(0) 152 154 #define TRF7970A_QUIRK_EN2_MUST_STAY_LOW BIT(1) 153 - #define TRF7970A_QUIRK_T5T_RMB_EXTRA_BYTE BIT(2) 154 155 155 156 /* Direct commands */ 156 157 #define TRF7970A_CMD_IDLE 0x00 ··· 292 295 #define TRF7970A_REG_IO_CTRL_AUTO_REG BIT(7) 293 296 294 297 /* IRQ Status Register Bits */ 295 - #define TRF7970A_IRQ_STATUS_NORESP BIT(0) /* ISO15693 only */ 298 + #define TRF7970A_IRQ_STATUS_NORESP BIT(0) /* ISO15693 only */ 296 299 #define TRF7970A_IRQ_STATUS_NFC_COL_ERROR BIT(0) 297 300 #define TRF7970A_IRQ_STATUS_COL BIT(1) 298 301 #define TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR BIT(2) ··· 448 451 u8 md_rf_tech; 449 452 u8 tx_cmd; 450 453 bool issue_eof; 451 - bool adjust_resp_len; 452 - int en2_gpio; 453 - int en_gpio; 454 + struct gpio_desc *en_gpiod; 455 + struct gpio_desc *en2_gpiod; 454 456 struct mutex lock; 455 457 unsigned int timeout; 456 458 bool ignore_timeout; 457 459 struct delayed_work timeout_work; 458 460 }; 459 - 460 461 461 462 static int trf7970a_cmd(struct trf7970a *trf, u8 opcode) 462 463 { ··· 466 471 ret = spi_write(trf->spi, &cmd, 1); 467 472 if (ret) 468 473 dev_err(trf->dev, "%s - cmd: 0x%x, ret: %d\n", __func__, cmd, 469 - ret); 474 + ret); 470 475 return ret; 471 476 } 472 477 ··· 478 483 ret = spi_write_then_read(trf->spi, &addr, 1, val, 1); 479 484 if (ret) 480 485 dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr, 481 - ret); 486 + ret); 482 487 483 488 dev_dbg(trf->dev, "read(0x%x): 0x%x\n", addr, *val); 484 489 485 490 return ret; 486 491 } 487 492 488 - static int trf7970a_read_cont(struct trf7970a *trf, u8 reg, u8 *buf, size_t len) 493 + static int trf7970a_read_cont(struct trf7970a *trf, u8 reg, u8 *buf, 494 + size_t len) 489 495 { 490 496 u8 addr = reg | TRF7970A_CMD_BIT_RW | TRF7970A_CMD_BIT_CONTINUOUS; 491 497 struct spi_transfer t[2]; ··· 510 514 ret = spi_sync(trf->spi, &m); 511 515 if (ret) 512 516 dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr, 513 - ret); 517 + ret); 514 518 return ret; 515 519 } 516 520 ··· 524 528 ret = spi_write(trf->spi, buf, 2); 525 529 if (ret) 526 530 dev_err(trf->dev, "%s - write: 0x%x 0x%x, ret: %d\n", __func__, 527 - buf[0], buf[1], ret); 531 + buf[0], buf[1], ret); 528 532 529 533 return ret; 530 534 } ··· 546 550 547 551 if (ret) 548 552 dev_err(trf->dev, "%s - irqstatus: Status read failed: %d\n", 549 - __func__, ret); 553 + __func__, ret); 550 554 else 551 555 *status = buf[0]; 552 556 ··· 560 564 u8 addr; 561 565 562 566 addr = TRF79070A_NFC_TARGET_PROTOCOL | TRF7970A_CMD_BIT_RW | 563 - TRF7970A_CMD_BIT_CONTINUOUS; 567 + TRF7970A_CMD_BIT_CONTINUOUS; 564 568 565 569 ret = spi_write_then_read(trf->spi, &addr, 1, buf, 2); 566 570 if (ret) 567 571 dev_err(trf->dev, "%s - target_proto: Read failed: %d\n", 568 - __func__, ret); 572 + __func__, ret); 569 573 else 570 574 *target_proto = buf[0]; 571 575 ··· 596 600 break; 597 601 default: 598 602 dev_dbg(trf->dev, "%s - mode_detect: target_proto: 0x%x\n", 599 - __func__, target_proto); 603 + __func__, target_proto); 600 604 return -EIO; 601 605 } 602 606 ··· 612 616 613 617 if (trf->rx_skb && !IS_ERR(trf->rx_skb) && !trf->aborting) 614 618 print_hex_dump_debug("trf7970a rx data: ", DUMP_PREFIX_NONE, 615 - 16, 1, trf->rx_skb->data, trf->rx_skb->len, 616 - false); 619 + 16, 1, trf->rx_skb->data, trf->rx_skb->len, 620 + false); 617 621 618 622 trf->state = TRF7970A_ST_IDLE; 619 623 ··· 626 630 } 627 631 628 632 trf->aborting = false; 629 - } 630 - 631 - if (trf->adjust_resp_len) { 632 - if (trf->rx_skb) 633 - skb_trim(trf->rx_skb, trf->rx_skb->len - 1); 634 - 635 - trf->adjust_resp_len = false; 636 633 } 637 634 638 635 trf->cb(trf->ddev, trf->cb_arg, trf->rx_skb); ··· 646 657 } 647 658 648 659 static int trf7970a_transmit(struct trf7970a *trf, struct sk_buff *skb, 649 - unsigned int len, u8 *prefix, unsigned int prefix_len) 660 + unsigned int len, u8 *prefix, 661 + unsigned int prefix_len) 650 662 { 651 663 struct spi_transfer t[2]; 652 664 struct spi_message m; ··· 655 665 int ret; 656 666 657 667 print_hex_dump_debug("trf7970a tx data: ", DUMP_PREFIX_NONE, 658 - 16, 1, skb->data, len, false); 668 + 16, 1, skb->data, len, false); 659 669 660 670 spi_message_init(&m); 661 671 ··· 672 682 ret = spi_sync(trf->spi, &m); 673 683 if (ret) { 674 684 dev_err(trf->dev, "%s - Can't send tx data: %d\n", __func__, 675 - ret); 685 + ret); 676 686 return ret; 677 687 } 678 688 ··· 696 706 } 697 707 698 708 dev_dbg(trf->dev, "Setting timeout for %d ms, state: %d\n", timeout, 699 - trf->state); 709 + trf->state); 700 710 701 711 schedule_delayed_work(&trf->timeout_work, msecs_to_jiffies(timeout)); 702 712 ··· 764 774 765 775 if (fifo_bytes > skb_tailroom(skb)) { 766 776 skb = skb_copy_expand(skb, skb_headroom(skb), 767 - max_t(int, fifo_bytes, 768 - TRF7970A_RX_SKB_ALLOC_SIZE), 769 - GFP_KERNEL); 777 + max_t(int, fifo_bytes, 778 + TRF7970A_RX_SKB_ALLOC_SIZE), 779 + GFP_KERNEL); 770 780 if (!skb) { 771 781 trf7970a_send_err_upstream(trf, -ENOMEM); 772 782 return; ··· 777 787 } 778 788 779 789 ret = trf7970a_read_cont(trf, TRF7970A_FIFO_IO_REGISTER, 780 - skb_put(skb, fifo_bytes), fifo_bytes); 790 + skb_put(skb, fifo_bytes), fifo_bytes); 781 791 if (ret) { 782 792 trf7970a_send_err_upstream(trf, ret); 783 793 return; ··· 785 795 786 796 /* If received Type 2 ACK/NACK, shift right 4 bits and pass up */ 787 797 if ((trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T) && (skb->len == 1) && 788 - (trf->special_fcn_reg1 == 789 - TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX)) { 798 + (trf->special_fcn_reg1 == TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX)) { 790 799 skb->data[0] >>= 4; 791 800 status = TRF7970A_IRQ_STATUS_SRX; 792 801 } else { ··· 808 819 } 809 820 810 821 no_rx_data: 811 - if (status == TRF7970A_IRQ_STATUS_SRX) { /* Receive complete */ 822 + if (status == TRF7970A_IRQ_STATUS_SRX) { /* Receive complete */ 812 823 trf7970a_send_upstream(trf); 813 824 return; 814 825 } 815 826 816 827 dev_dbg(trf->dev, "Setting timeout for %d ms\n", 817 - TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT); 828 + TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT); 818 829 819 830 schedule_delayed_work(&trf->timeout_work, 820 - msecs_to_jiffies(TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT)); 831 + msecs_to_jiffies(TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT)); 821 832 } 822 833 823 834 static irqreturn_t trf7970a_irq(int irq, void *dev_id) ··· 840 851 } 841 852 842 853 dev_dbg(trf->dev, "IRQ - state: %d, status: 0x%x\n", trf->state, 843 - status); 854 + status); 844 855 845 856 if (!status) { 846 857 mutex_unlock(&trf->lock); ··· 865 876 case TRF7970A_ST_WAIT_FOR_TX_FIFO: 866 877 if (status & TRF7970A_IRQ_STATUS_TX) { 867 878 trf->ignore_timeout = 868 - !cancel_delayed_work(&trf->timeout_work); 879 + !cancel_delayed_work(&trf->timeout_work); 869 880 trf7970a_fill_fifo(trf); 870 881 } else { 871 882 trf7970a_send_err_upstream(trf, -EIO); ··· 875 886 case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT: 876 887 if (status & TRF7970A_IRQ_STATUS_SRX) { 877 888 trf->ignore_timeout = 878 - !cancel_delayed_work(&trf->timeout_work); 889 + !cancel_delayed_work(&trf->timeout_work); 879 890 trf7970a_drain_fifo(trf, status); 880 891 } else if (status & TRF7970A_IRQ_STATUS_FIFO) { 881 892 ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, 882 - &fifo_bytes); 893 + &fifo_bytes); 883 894 884 895 fifo_bytes &= ~TRF7970A_FIFO_STATUS_OVERFLOW; 885 896 ··· 888 899 else if (!fifo_bytes) 889 900 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET); 890 901 } else if ((status == TRF7970A_IRQ_STATUS_TX) || 891 - (!trf->is_initiator && 892 - (status == (TRF7970A_IRQ_STATUS_TX | 893 - TRF7970A_IRQ_STATUS_NFC_RF)))) { 902 + (!trf->is_initiator && 903 + (status == (TRF7970A_IRQ_STATUS_TX | 904 + TRF7970A_IRQ_STATUS_NFC_RF)))) { 894 905 trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET); 895 906 896 907 if (!trf->timeout) { 897 - trf->ignore_timeout = !cancel_delayed_work( 898 - &trf->timeout_work); 908 + trf->ignore_timeout = 909 + !cancel_delayed_work(&trf->timeout_work); 899 910 trf->rx_skb = ERR_PTR(0); 900 911 trf7970a_send_upstream(trf); 901 912 break; ··· 919 930 break; 920 931 case NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE: 921 932 ret = trf7970a_write(trf, 922 - TRF7970A_SPECIAL_FCN_REG1, 923 - TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL); 933 + TRF7970A_SPECIAL_FCN_REG1, 934 + TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL); 924 935 if (ret) 925 936 goto err_unlock_exit; 926 937 927 938 trf->special_fcn_reg1 = 928 - TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL; 939 + TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL; 929 940 break; 930 941 default: 931 942 break; ··· 933 944 934 945 if (iso_ctrl != trf->iso_ctrl) { 935 946 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, 936 - iso_ctrl); 947 + iso_ctrl); 937 948 if (ret) 938 949 goto err_unlock_exit; 939 950 ··· 950 961 case TRF7970A_ST_LISTENING: 951 962 if (status & TRF7970A_IRQ_STATUS_SRX) { 952 963 trf->ignore_timeout = 953 - !cancel_delayed_work(&trf->timeout_work); 964 + !cancel_delayed_work(&trf->timeout_work); 954 965 trf7970a_drain_fifo(trf, status); 955 966 } else if (!(status & TRF7970A_IRQ_STATUS_NFC_RF)) { 956 967 trf7970a_send_err_upstream(trf, -EIO); ··· 959 970 case TRF7970A_ST_LISTENING_MD: 960 971 if (status & TRF7970A_IRQ_STATUS_SRX) { 961 972 trf->ignore_timeout = 962 - !cancel_delayed_work(&trf->timeout_work); 973 + !cancel_delayed_work(&trf->timeout_work); 963 974 964 975 ret = trf7970a_mode_detect(trf, &trf->md_rf_tech); 965 976 if (ret) { ··· 974 985 break; 975 986 default: 976 987 dev_err(trf->dev, "%s - Driver in invalid state: %d\n", 977 - __func__, trf->state); 988 + __func__, trf->state); 978 989 } 979 990 980 991 err_unlock_exit: ··· 999 1010 trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA; 1000 1011 1001 1012 dev_dbg(trf->dev, "Setting timeout for %d ms, state: %d\n", 1002 - trf->timeout, trf->state); 1013 + trf->timeout, trf->state); 1003 1014 1004 1015 schedule_delayed_work(&trf->timeout_work, 1005 - msecs_to_jiffies(trf->timeout)); 1016 + msecs_to_jiffies(trf->timeout)); 1006 1017 } 1007 1018 1008 1019 static void trf7970a_timeout_work_handler(struct work_struct *work) 1009 1020 { 1010 1021 struct trf7970a *trf = container_of(work, struct trf7970a, 1011 - timeout_work.work); 1022 + timeout_work.work); 1012 1023 1013 1024 dev_dbg(trf->dev, "Timeout - state: %d, ignore_timeout: %d\n", 1014 - trf->state, trf->ignore_timeout); 1025 + trf->state, trf->ignore_timeout); 1015 1026 1016 1027 mutex_lock(&trf->lock); 1017 1028 ··· 1042 1053 goto err_out; 1043 1054 1044 1055 ret = trf7970a_write(trf, TRF7970A_REG_IO_CTRL, 1045 - trf->io_ctrl | TRF7970A_REG_IO_CTRL_VRS(0x1)); 1056 + trf->io_ctrl | TRF7970A_REG_IO_CTRL_VRS(0x1)); 1046 1057 if (ret) 1047 1058 goto err_out; 1048 1059 ··· 1055 1066 trf->chip_status_ctrl &= ~TRF7970A_CHIP_STATUS_RF_ON; 1056 1067 1057 1068 ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL, 1058 - trf->modulator_sys_clk_ctrl); 1069 + trf->modulator_sys_clk_ctrl); 1059 1070 if (ret) 1060 1071 goto err_out; 1061 1072 1062 1073 ret = trf7970a_write(trf, TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS, 1063 - TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 | 1064 - TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32); 1074 + TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 | 1075 + TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32); 1065 1076 if (ret) 1066 1077 goto err_out; 1067 1078 ··· 1082 1093 static void trf7970a_switch_rf_off(struct trf7970a *trf) 1083 1094 { 1084 1095 if ((trf->state == TRF7970A_ST_PWR_OFF) || 1085 - (trf->state == TRF7970A_ST_RF_OFF)) 1096 + (trf->state == TRF7970A_ST_RF_OFF)) 1086 1097 return; 1087 1098 1088 1099 dev_dbg(trf->dev, "Switching rf off\n"); ··· 1106 1117 1107 1118 pm_runtime_get_sync(trf->dev); 1108 1119 1109 - if (trf->state != TRF7970A_ST_RF_OFF) { /* Power on, RF off */ 1120 + if (trf->state != TRF7970A_ST_RF_OFF) { /* Power on, RF off */ 1110 1121 dev_err(trf->dev, "%s - Incorrect state: %d\n", __func__, 1111 - trf->state); 1122 + trf->state); 1112 1123 return -EINVAL; 1113 1124 } 1114 1125 ··· 1143 1154 break; 1144 1155 default: 1145 1156 dev_err(trf->dev, "%s - Invalid request: %d %d\n", 1146 - __func__, trf->state, on); 1157 + __func__, trf->state, on); 1147 1158 trf7970a_switch_rf_off(trf); 1148 1159 ret = -EINVAL; 1149 1160 } ··· 1154 1165 break; 1155 1166 default: 1156 1167 dev_err(trf->dev, "%s - Invalid request: %d %d\n", 1157 - __func__, trf->state, on); 1168 + __func__, trf->state, on); 1158 1169 ret = -EINVAL; 1159 1170 /* FALLTHROUGH */ 1160 1171 case TRF7970A_ST_IDLE: ··· 1179 1190 case NFC_DIGITAL_RF_TECH_106A: 1180 1191 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443A_106; 1181 1192 trf->modulator_sys_clk_ctrl = 1182 - (trf->modulator_sys_clk_ctrl & 0xf8) | 1183 - TRF7970A_MODULATOR_DEPTH_OOK; 1193 + (trf->modulator_sys_clk_ctrl & 0xf8) | 1194 + TRF7970A_MODULATOR_DEPTH_OOK; 1184 1195 trf->guard_time = TRF7970A_GUARD_TIME_NFCA; 1185 1196 break; 1186 1197 case NFC_DIGITAL_RF_TECH_106B: 1187 1198 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443B_106; 1188 1199 trf->modulator_sys_clk_ctrl = 1189 - (trf->modulator_sys_clk_ctrl & 0xf8) | 1190 - TRF7970A_MODULATOR_DEPTH_ASK10; 1200 + (trf->modulator_sys_clk_ctrl & 0xf8) | 1201 + TRF7970A_MODULATOR_DEPTH_ASK10; 1191 1202 trf->guard_time = TRF7970A_GUARD_TIME_NFCB; 1192 1203 break; 1193 1204 case NFC_DIGITAL_RF_TECH_212F: 1194 1205 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_212; 1195 1206 trf->modulator_sys_clk_ctrl = 1196 - (trf->modulator_sys_clk_ctrl & 0xf8) | 1197 - TRF7970A_MODULATOR_DEPTH_ASK10; 1207 + (trf->modulator_sys_clk_ctrl & 0xf8) | 1208 + TRF7970A_MODULATOR_DEPTH_ASK10; 1198 1209 trf->guard_time = TRF7970A_GUARD_TIME_NFCF; 1199 1210 break; 1200 1211 case NFC_DIGITAL_RF_TECH_424F: 1201 1212 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_424; 1202 1213 trf->modulator_sys_clk_ctrl = 1203 - (trf->modulator_sys_clk_ctrl & 0xf8) | 1204 - TRF7970A_MODULATOR_DEPTH_ASK10; 1214 + (trf->modulator_sys_clk_ctrl & 0xf8) | 1215 + TRF7970A_MODULATOR_DEPTH_ASK10; 1205 1216 trf->guard_time = TRF7970A_GUARD_TIME_NFCF; 1206 1217 break; 1207 1218 case NFC_DIGITAL_RF_TECH_ISO15693: 1208 1219 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648; 1209 1220 trf->modulator_sys_clk_ctrl = 1210 - (trf->modulator_sys_clk_ctrl & 0xf8) | 1211 - TRF7970A_MODULATOR_DEPTH_OOK; 1221 + (trf->modulator_sys_clk_ctrl & 0xf8) | 1222 + TRF7970A_MODULATOR_DEPTH_OOK; 1212 1223 trf->guard_time = TRF7970A_GUARD_TIME_15693; 1213 1224 break; 1214 1225 default: ··· 1235 1246 u8 rssi; 1236 1247 1237 1248 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL, 1238 - trf->chip_status_ctrl | TRF7970A_CHIP_STATUS_REC_ON); 1249 + trf->chip_status_ctrl | 1250 + TRF7970A_CHIP_STATUS_REC_ON); 1239 1251 if (ret) 1240 1252 return ret; 1241 1253 ··· 1251 1261 return ret; 1252 1262 1253 1263 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL, 1254 - trf->chip_status_ctrl); 1264 + trf->chip_status_ctrl); 1255 1265 if (ret) 1256 1266 return ret; 1257 1267 ··· 1318 1328 trf->iso_ctrl = iso_ctrl; 1319 1329 1320 1330 ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL, 1321 - trf->modulator_sys_clk_ctrl); 1331 + trf->modulator_sys_clk_ctrl); 1322 1332 if (ret) 1323 1333 return ret; 1324 1334 } 1325 1335 1326 1336 if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) { 1327 1337 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL, 1328 - trf->chip_status_ctrl | 1329 - TRF7970A_CHIP_STATUS_RF_ON); 1338 + trf->chip_status_ctrl | 1339 + TRF7970A_CHIP_STATUS_RF_ON); 1330 1340 if (ret) 1331 1341 return ret; 1332 1342 ··· 1339 1349 } 1340 1350 1341 1351 static int trf7970a_in_configure_hw(struct nfc_digital_dev *ddev, int type, 1342 - int param) 1352 + int param) 1343 1353 { 1344 1354 struct trf7970a *trf = nfc_digital_get_drvdata(ddev); 1345 1355 int ret; ··· 1351 1361 trf->is_initiator = true; 1352 1362 1353 1363 if ((trf->state == TRF7970A_ST_PWR_OFF) || 1354 - (trf->state == TRF7970A_ST_RF_OFF)) { 1364 + (trf->state == TRF7970A_ST_RF_OFF)) { 1355 1365 ret = trf7970a_switch_rf_on(trf); 1356 1366 if (ret) 1357 1367 goto err_unlock; ··· 1409 1419 * has to send an EOF in order to get a response. 1410 1420 */ 1411 1421 if ((trf->technology == NFC_DIGITAL_RF_TECH_106A) && 1412 - (trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T)) { 1422 + (trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T)) { 1413 1423 if (req[0] == NFC_T2T_CMD_READ) 1414 1424 special_fcn_reg1 = 0; 1415 1425 else ··· 1417 1427 1418 1428 if (special_fcn_reg1 != trf->special_fcn_reg1) { 1419 1429 ret = trf7970a_write(trf, TRF7970A_SPECIAL_FCN_REG1, 1420 - special_fcn_reg1); 1430 + special_fcn_reg1); 1421 1431 if (ret) 1422 1432 return ret; 1423 1433 ··· 1437 1447 iso_ctrl |= TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648; 1438 1448 break; 1439 1449 case (ISO15693_REQ_FLAG_SUB_CARRIER | 1440 - ISO15693_REQ_FLAG_DATA_RATE): 1450 + ISO15693_REQ_FLAG_DATA_RATE): 1441 1451 iso_ctrl |= TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669; 1442 1452 break; 1443 1453 } ··· 1450 1460 trf->iso_ctrl = iso_ctrl; 1451 1461 } 1452 1462 1453 - if (trf->framing == NFC_DIGITAL_FRAMING_ISO15693_T5T) { 1454 - if (trf7970a_is_iso15693_write_or_lock(req[1]) && 1455 - (req[0] & ISO15693_REQ_FLAG_OPTION)) 1456 - trf->issue_eof = true; 1457 - else if ((trf->quirks & 1458 - TRF7970A_QUIRK_T5T_RMB_EXTRA_BYTE) && 1459 - (req[1] == ISO15693_CMD_READ_MULTIPLE_BLOCK)) 1460 - trf->adjust_resp_len = true; 1461 - } 1463 + if ((trf->framing == NFC_DIGITAL_FRAMING_ISO15693_T5T) && 1464 + trf7970a_is_iso15693_write_or_lock(req[1]) && 1465 + (req[0] & ISO15693_REQ_FLAG_OPTION)) 1466 + trf->issue_eof = true; 1462 1467 } 1463 1468 1464 1469 return 0; 1465 1470 } 1466 1471 1467 1472 static int trf7970a_send_cmd(struct nfc_digital_dev *ddev, 1468 - struct sk_buff *skb, u16 timeout, 1469 - nfc_digital_cmd_complete_t cb, void *arg) 1473 + struct sk_buff *skb, u16 timeout, 1474 + nfc_digital_cmd_complete_t cb, void *arg) 1470 1475 { 1471 1476 struct trf7970a *trf = nfc_digital_get_drvdata(ddev); 1472 1477 u8 prefix[5]; ··· 1470 1485 u8 status; 1471 1486 1472 1487 dev_dbg(trf->dev, "New request - state: %d, timeout: %d ms, len: %d\n", 1473 - trf->state, timeout, skb->len); 1488 + trf->state, timeout, skb->len); 1474 1489 1475 1490 if (skb->len > TRF7970A_TX_MAX) 1476 1491 return -EINVAL; ··· 1478 1493 mutex_lock(&trf->lock); 1479 1494 1480 1495 if ((trf->state != TRF7970A_ST_IDLE) && 1481 - (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) { 1496 + (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) { 1482 1497 dev_err(trf->dev, "%s - Bogus state: %d\n", __func__, 1483 - trf->state); 1498 + trf->state); 1484 1499 ret = -EIO; 1485 1500 goto out_err; 1486 1501 } ··· 1494 1509 1495 1510 if (timeout) { 1496 1511 trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE, 1497 - GFP_KERNEL); 1512 + GFP_KERNEL); 1498 1513 if (!trf->rx_skb) { 1499 1514 dev_dbg(trf->dev, "Can't alloc rx_skb\n"); 1500 1515 ret = -ENOMEM; ··· 1531 1546 * That totals 5 bytes. 1532 1547 */ 1533 1548 prefix[0] = TRF7970A_CMD_BIT_CTRL | 1534 - TRF7970A_CMD_BIT_OPCODE(TRF7970A_CMD_FIFO_RESET); 1549 + TRF7970A_CMD_BIT_OPCODE(TRF7970A_CMD_FIFO_RESET); 1535 1550 prefix[1] = TRF7970A_CMD_BIT_CTRL | 1536 - TRF7970A_CMD_BIT_OPCODE(trf->tx_cmd); 1551 + TRF7970A_CMD_BIT_OPCODE(trf->tx_cmd); 1537 1552 prefix[2] = TRF7970A_CMD_BIT_CONTINUOUS | TRF7970A_TX_LENGTH_BYTE1; 1538 1553 1539 1554 if (trf->framing == NFC_DIGITAL_FRAMING_NFCA_SHORT) { 1540 1555 prefix[3] = 0x00; 1541 - prefix[4] = 0x0f; /* 7 bits */ 1556 + prefix[4] = 0x0f; /* 7 bits */ 1542 1557 } else { 1543 1558 prefix[3] = (len & 0xf00) >> 4; 1544 1559 prefix[3] |= ((len & 0xf0) >> 4); ··· 1572 1587 switch (tech) { 1573 1588 case NFC_DIGITAL_RF_TECH_106A: 1574 1589 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE | 1575 - TRF7970A_ISO_CTRL_NFC_CE | 1576 - TRF7970A_ISO_CTRL_NFC_CE_14443A; 1590 + TRF7970A_ISO_CTRL_NFC_CE | TRF7970A_ISO_CTRL_NFC_CE_14443A; 1577 1591 trf->modulator_sys_clk_ctrl = 1578 - (trf->modulator_sys_clk_ctrl & 0xf8) | 1579 - TRF7970A_MODULATOR_DEPTH_OOK; 1592 + (trf->modulator_sys_clk_ctrl & 0xf8) | 1593 + TRF7970A_MODULATOR_DEPTH_OOK; 1580 1594 break; 1581 1595 case NFC_DIGITAL_RF_TECH_212F: 1582 1596 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE | 1583 - TRF7970A_ISO_CTRL_NFC_NFCF_212; 1597 + TRF7970A_ISO_CTRL_NFC_NFCF_212; 1584 1598 trf->modulator_sys_clk_ctrl = 1585 - (trf->modulator_sys_clk_ctrl & 0xf8) | 1586 - TRF7970A_MODULATOR_DEPTH_ASK10; 1599 + (trf->modulator_sys_clk_ctrl & 0xf8) | 1600 + TRF7970A_MODULATOR_DEPTH_ASK10; 1587 1601 break; 1588 1602 case NFC_DIGITAL_RF_TECH_424F: 1589 1603 trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE | 1590 - TRF7970A_ISO_CTRL_NFC_NFCF_424; 1604 + TRF7970A_ISO_CTRL_NFC_NFCF_424; 1591 1605 trf->modulator_sys_clk_ctrl = 1592 - (trf->modulator_sys_clk_ctrl & 0xf8) | 1593 - TRF7970A_MODULATOR_DEPTH_ASK10; 1606 + (trf->modulator_sys_clk_ctrl & 0xf8) | 1607 + TRF7970A_MODULATOR_DEPTH_ASK10; 1594 1608 break; 1595 1609 default: 1596 1610 dev_dbg(trf->dev, "Unsupported rf technology: %d\n", tech); ··· 1606 1622 * here. 1607 1623 */ 1608 1624 if ((trf->framing == NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED) && 1609 - (trf->iso_ctrl_tech != trf->iso_ctrl)) { 1625 + (trf->iso_ctrl_tech != trf->iso_ctrl)) { 1610 1626 ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, 1611 - trf->iso_ctrl_tech); 1627 + trf->iso_ctrl_tech); 1612 1628 1613 1629 trf->iso_ctrl = trf->iso_ctrl_tech; 1614 1630 } ··· 1663 1679 trf->iso_ctrl = iso_ctrl; 1664 1680 1665 1681 ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL, 1666 - trf->modulator_sys_clk_ctrl); 1682 + trf->modulator_sys_clk_ctrl); 1667 1683 if (ret) 1668 1684 return ret; 1669 1685 } 1670 1686 1671 1687 if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) { 1672 1688 ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL, 1673 - trf->chip_status_ctrl | 1674 - TRF7970A_CHIP_STATUS_RF_ON); 1689 + trf->chip_status_ctrl | 1690 + TRF7970A_CHIP_STATUS_RF_ON); 1675 1691 if (ret) 1676 1692 return ret; 1677 1693 ··· 1682 1698 } 1683 1699 1684 1700 static int trf7970a_tg_configure_hw(struct nfc_digital_dev *ddev, int type, 1685 - int param) 1701 + int param) 1686 1702 { 1687 1703 struct trf7970a *trf = nfc_digital_get_drvdata(ddev); 1688 1704 int ret; ··· 1694 1710 trf->is_initiator = false; 1695 1711 1696 1712 if ((trf->state == TRF7970A_ST_PWR_OFF) || 1697 - (trf->state == TRF7970A_ST_RF_OFF)) { 1713 + (trf->state == TRF7970A_ST_RF_OFF)) { 1698 1714 ret = trf7970a_switch_rf_on(trf); 1699 1715 if (ret) 1700 1716 goto err_unlock; ··· 1718 1734 } 1719 1735 1720 1736 static int _trf7970a_tg_listen(struct nfc_digital_dev *ddev, u16 timeout, 1721 - nfc_digital_cmd_complete_t cb, void *arg, bool mode_detect) 1737 + nfc_digital_cmd_complete_t cb, void *arg, 1738 + bool mode_detect) 1722 1739 { 1723 1740 struct trf7970a *trf = nfc_digital_get_drvdata(ddev); 1724 1741 int ret; ··· 1727 1742 mutex_lock(&trf->lock); 1728 1743 1729 1744 if ((trf->state != TRF7970A_ST_IDLE) && 1730 - (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) { 1745 + (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) { 1731 1746 dev_err(trf->dev, "%s - Bogus state: %d\n", __func__, 1732 - trf->state); 1747 + trf->state); 1733 1748 ret = -EIO; 1734 1749 goto out_err; 1735 1750 } ··· 1742 1757 } 1743 1758 1744 1759 trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE, 1745 - GFP_KERNEL); 1760 + GFP_KERNEL); 1746 1761 if (!trf->rx_skb) { 1747 1762 dev_dbg(trf->dev, "Can't alloc rx_skb\n"); 1748 1763 ret = -ENOMEM; ··· 1750 1765 } 1751 1766 1752 1767 ret = trf7970a_write(trf, TRF7970A_RX_SPECIAL_SETTINGS, 1753 - TRF7970A_RX_SPECIAL_SETTINGS_HBT | 1754 - TRF7970A_RX_SPECIAL_SETTINGS_M848 | 1755 - TRF7970A_RX_SPECIAL_SETTINGS_C424 | 1756 - TRF7970A_RX_SPECIAL_SETTINGS_C212); 1768 + TRF7970A_RX_SPECIAL_SETTINGS_HBT | 1769 + TRF7970A_RX_SPECIAL_SETTINGS_M848 | 1770 + TRF7970A_RX_SPECIAL_SETTINGS_C424 | 1771 + TRF7970A_RX_SPECIAL_SETTINGS_C212); 1757 1772 if (ret) 1758 1773 goto out_err; 1759 1774 1760 1775 ret = trf7970a_write(trf, TRF7970A_REG_IO_CTRL, 1761 - trf->io_ctrl | TRF7970A_REG_IO_CTRL_VRS(0x1)); 1776 + trf->io_ctrl | TRF7970A_REG_IO_CTRL_VRS(0x1)); 1762 1777 if (ret) 1763 1778 goto out_err; 1764 1779 1765 1780 ret = trf7970a_write(trf, TRF7970A_NFC_LOW_FIELD_LEVEL, 1766 - TRF7970A_NFC_LOW_FIELD_LEVEL_RFDET(0x3)); 1781 + TRF7970A_NFC_LOW_FIELD_LEVEL_RFDET(0x3)); 1767 1782 if (ret) 1768 1783 goto out_err; 1769 1784 1770 1785 ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL, 1771 - TRF7970A_NFC_TARGET_LEVEL_RFDET(0x7)); 1786 + TRF7970A_NFC_TARGET_LEVEL_RFDET(0x7)); 1772 1787 if (ret) 1773 1788 goto out_err; 1774 1789 ··· 1793 1808 } 1794 1809 1795 1810 static int trf7970a_tg_listen(struct nfc_digital_dev *ddev, u16 timeout, 1796 - nfc_digital_cmd_complete_t cb, void *arg) 1811 + nfc_digital_cmd_complete_t cb, void *arg) 1797 1812 { 1798 1813 struct trf7970a *trf = nfc_digital_get_drvdata(ddev); 1799 1814 1800 1815 dev_dbg(trf->dev, "Listen - state: %d, timeout: %d ms\n", 1801 - trf->state, timeout); 1816 + trf->state, timeout); 1802 1817 1803 1818 return _trf7970a_tg_listen(ddev, timeout, cb, arg, false); 1804 1819 } 1805 1820 1806 1821 static int trf7970a_tg_listen_md(struct nfc_digital_dev *ddev, 1807 - u16 timeout, nfc_digital_cmd_complete_t cb, void *arg) 1822 + u16 timeout, nfc_digital_cmd_complete_t cb, 1823 + void *arg) 1808 1824 { 1809 1825 struct trf7970a *trf = nfc_digital_get_drvdata(ddev); 1810 1826 int ret; 1811 1827 1812 1828 dev_dbg(trf->dev, "Listen MD - state: %d, timeout: %d ms\n", 1813 - trf->state, timeout); 1829 + trf->state, timeout); 1814 1830 1815 1831 ret = trf7970a_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH, 1816 - NFC_DIGITAL_RF_TECH_106A); 1832 + NFC_DIGITAL_RF_TECH_106A); 1817 1833 if (ret) 1818 1834 return ret; 1819 1835 1820 1836 ret = trf7970a_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING, 1821 - NFC_DIGITAL_FRAMING_NFCA_NFC_DEP); 1837 + NFC_DIGITAL_FRAMING_NFCA_NFC_DEP); 1822 1838 if (ret) 1823 1839 return ret; 1824 1840 ··· 1831 1845 struct trf7970a *trf = nfc_digital_get_drvdata(ddev); 1832 1846 1833 1847 dev_dbg(trf->dev, "Get RF Tech - state: %d, rf_tech: %d\n", 1834 - trf->state, trf->md_rf_tech); 1848 + trf->state, trf->md_rf_tech); 1835 1849 1836 1850 *rf_tech = trf->md_rf_tech; 1837 1851 ··· 1894 1908 1895 1909 usleep_range(5000, 6000); 1896 1910 1897 - if (!(trf->quirks & TRF7970A_QUIRK_EN2_MUST_STAY_LOW)) { 1898 - if (gpio_is_valid(trf->en2_gpio)) { 1899 - gpio_set_value(trf->en2_gpio, 1); 1900 - usleep_range(1000, 2000); 1901 - } 1911 + if (trf->en2_gpiod && 1912 + !(trf->quirks & TRF7970A_QUIRK_EN2_MUST_STAY_LOW)) { 1913 + gpiod_set_value_cansleep(trf->en2_gpiod, 1); 1914 + usleep_range(1000, 2000); 1902 1915 } 1903 1916 1904 - gpio_set_value(trf->en_gpio, 1); 1917 + gpiod_set_value_cansleep(trf->en_gpiod, 1); 1905 1918 1906 1919 usleep_range(20000, 21000); 1907 1920 ··· 1920 1935 1921 1936 if (trf->state != TRF7970A_ST_RF_OFF) { 1922 1937 dev_dbg(trf->dev, "Can't power down - not RF_OFF state (%d)\n", 1923 - trf->state); 1938 + trf->state); 1924 1939 return -EBUSY; 1925 1940 } 1926 1941 1927 - gpio_set_value(trf->en_gpio, 0); 1928 - if (gpio_is_valid(trf->en2_gpio)) 1929 - gpio_set_value(trf->en2_gpio, 0); 1942 + gpiod_set_value_cansleep(trf->en_gpiod, 0); 1943 + 1944 + if (trf->en2_gpiod && !(trf->quirks & TRF7970A_QUIRK_EN2_MUST_STAY_LOW)) 1945 + gpiod_set_value_cansleep(trf->en2_gpiod, 0); 1930 1946 1931 1947 ret = regulator_disable(trf->regulator); 1932 1948 if (ret) 1933 1949 dev_err(trf->dev, "%s - Can't disable VIN: %d\n", __func__, 1934 - ret); 1950 + ret); 1935 1951 1936 1952 trf->state = TRF7970A_ST_PWR_OFF; 1937 1953 ··· 1989 2003 return autosuspend_delay; 1990 2004 } 1991 2005 1992 - static int trf7970a_get_vin_voltage_override(struct device_node *np, 1993 - u32 *vin_uvolts) 1994 - { 1995 - return of_property_read_u32(np, "vin-voltage-override", vin_uvolts); 1996 - } 1997 - 1998 2006 static int trf7970a_probe(struct spi_device *spi) 1999 2007 { 2000 2008 struct device_node *np = spi->dev.of_node; ··· 2018 2038 return ret; 2019 2039 } 2020 2040 2021 - if (of_property_read_bool(np, "t5t-rmb-extra-byte-quirk")) 2022 - trf->quirks |= TRF7970A_QUIRK_T5T_RMB_EXTRA_BYTE; 2023 - 2024 2041 if (of_property_read_bool(np, "irq-status-read-quirk")) 2025 2042 trf->quirks |= TRF7970A_QUIRK_IRQ_STATUS_READ; 2026 2043 2027 - /* There are two enable pins - both must be present */ 2028 - trf->en_gpio = of_get_named_gpio(np, "ti,enable-gpios", 0); 2029 - if (!gpio_is_valid(trf->en_gpio)) { 2044 + /* There are two enable pins - only EN must be present in the DT */ 2045 + trf->en_gpiod = devm_gpiod_get_index(trf->dev, "ti,enable", 0, 2046 + GPIOD_OUT_LOW); 2047 + if (IS_ERR(trf->en_gpiod)) { 2030 2048 dev_err(trf->dev, "No EN GPIO property\n"); 2031 - return trf->en_gpio; 2049 + return PTR_ERR(trf->en_gpiod); 2032 2050 } 2033 2051 2034 - ret = devm_gpio_request_one(trf->dev, trf->en_gpio, 2035 - GPIOF_DIR_OUT | GPIOF_INIT_LOW, "trf7970a EN"); 2036 - if (ret) { 2037 - dev_err(trf->dev, "Can't request EN GPIO: %d\n", ret); 2038 - return ret; 2039 - } 2040 - 2041 - trf->en2_gpio = of_get_named_gpio(np, "ti,enable-gpios", 1); 2042 - if (!gpio_is_valid(trf->en2_gpio)) { 2052 + trf->en2_gpiod = devm_gpiod_get_index_optional(trf->dev, "ti,enable", 1, 2053 + GPIOD_OUT_LOW); 2054 + if (!trf->en2_gpiod) { 2043 2055 dev_info(trf->dev, "No EN2 GPIO property\n"); 2044 - } else { 2045 - ret = devm_gpio_request_one(trf->dev, trf->en2_gpio, 2046 - GPIOF_DIR_OUT | GPIOF_INIT_LOW, "trf7970a EN2"); 2047 - if (ret) { 2048 - dev_err(trf->dev, "Can't request EN2 GPIO: %d\n", ret); 2049 - return ret; 2050 - } 2056 + } else if (IS_ERR(trf->en2_gpiod)) { 2057 + dev_err(trf->dev, "Error getting EN2 GPIO property: %ld\n", 2058 + PTR_ERR(trf->en2_gpiod)); 2059 + return PTR_ERR(trf->en2_gpiod); 2060 + } else if (of_property_read_bool(np, "en2-rf-quirk")) { 2061 + trf->quirks |= TRF7970A_QUIRK_EN2_MUST_STAY_LOW; 2051 2062 } 2052 2063 2053 2064 of_property_read_u32(np, "clock-frequency", &clk_freq); 2054 - if ((clk_freq != TRF7970A_27MHZ_CLOCK_FREQUENCY) || 2055 - (clk_freq != TRF7970A_13MHZ_CLOCK_FREQUENCY)) { 2065 + if ((clk_freq != TRF7970A_27MHZ_CLOCK_FREQUENCY) && 2066 + (clk_freq != TRF7970A_13MHZ_CLOCK_FREQUENCY)) { 2056 2067 dev_err(trf->dev, 2057 - "clock-frequency (%u Hz) unsupported\n", 2058 - clk_freq); 2068 + "clock-frequency (%u Hz) unsupported\n", clk_freq); 2059 2069 return -EINVAL; 2060 2070 } 2061 2071 2062 - if (of_property_read_bool(np, "en2-rf-quirk")) 2063 - trf->quirks |= TRF7970A_QUIRK_EN2_MUST_STAY_LOW; 2072 + if (clk_freq == TRF7970A_27MHZ_CLOCK_FREQUENCY) { 2073 + trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_27MHZ; 2074 + dev_dbg(trf->dev, "trf7970a configured for 27MHz crystal\n"); 2075 + } else { 2076 + trf->modulator_sys_clk_ctrl = 0; 2077 + } 2064 2078 2065 2079 ret = devm_request_threaded_irq(trf->dev, spi->irq, NULL, 2066 - trf7970a_irq, IRQF_TRIGGER_RISING | IRQF_ONESHOT, 2067 - "trf7970a", trf); 2080 + trf7970a_irq, 2081 + IRQF_TRIGGER_RISING | IRQF_ONESHOT, 2082 + "trf7970a", trf); 2068 2083 if (ret) { 2069 2084 dev_err(trf->dev, "Can't request IRQ#%d: %d\n", spi->irq, ret); 2070 2085 return ret; ··· 2081 2106 goto err_destroy_lock; 2082 2107 } 2083 2108 2084 - ret = trf7970a_get_vin_voltage_override(np, &uvolts); 2085 - if (ret) 2086 - uvolts = regulator_get_voltage(trf->regulator); 2087 - 2109 + uvolts = regulator_get_voltage(trf->regulator); 2088 2110 if (uvolts > 4000000) 2089 2111 trf->chip_status_ctrl = TRF7970A_CHIP_STATUS_VRS5_3; 2090 2112 ··· 2104 2132 } 2105 2133 2106 2134 trf->ddev = nfc_digital_allocate_device(&trf7970a_nfc_ops, 2107 - TRF7970A_SUPPORTED_PROTOCOLS, 2108 - NFC_DIGITAL_DRV_CAPS_IN_CRC | 2109 - NFC_DIGITAL_DRV_CAPS_TG_CRC, 0, 0); 2135 + TRF7970A_SUPPORTED_PROTOCOLS, 2136 + NFC_DIGITAL_DRV_CAPS_IN_CRC | 2137 + NFC_DIGITAL_DRV_CAPS_TG_CRC, 0, 2138 + 0); 2110 2139 if (!trf->ddev) { 2111 2140 dev_err(trf->dev, "Can't allocate NFC digital device\n"); 2112 2141 ret = -ENOMEM; ··· 2130 2157 ret = nfc_digital_register_device(trf->ddev); 2131 2158 if (ret) { 2132 2159 dev_err(trf->dev, "Can't register NFC digital device: %d\n", 2133 - ret); 2160 + ret); 2134 2161 goto err_shutdown; 2135 2162 } 2136 2163 ··· 2239 2266 static const struct dev_pm_ops trf7970a_pm_ops = { 2240 2267 SET_SYSTEM_SLEEP_PM_OPS(trf7970a_suspend, trf7970a_resume) 2241 2268 SET_RUNTIME_PM_OPS(trf7970a_pm_runtime_suspend, 2242 - trf7970a_pm_runtime_resume, NULL) 2269 + trf7970a_pm_runtime_resume, NULL) 2243 2270 }; 2244 2271 2245 2272 static const struct of_device_id trf7970a_of_match[] = { 2246 - { .compatible = "ti,trf7970a", }, 2247 - { /* sentinel */ }, 2273 + {.compatible = "ti,trf7970a",}, 2274 + {}, 2248 2275 }; 2276 + 2249 2277 MODULE_DEVICE_TABLE(of, trf7970a_of_match); 2250 2278 2251 2279 static const struct spi_device_id trf7970a_id_table[] = { 2252 - { "trf7970a", 0 }, 2253 - { } 2280 + {"trf7970a", 0}, 2281 + {} 2254 2282 }; 2283 + 2255 2284 MODULE_DEVICE_TABLE(spi, trf7970a_id_table); 2256 2285 2257 2286 static struct spi_driver trf7970a_spi_driver = { 2258 2287 .probe = trf7970a_probe, 2259 2288 .remove = trf7970a_remove, 2260 2289 .id_table = trf7970a_id_table, 2261 - .driver = { 2262 - .name = "trf7970a", 2263 - .of_match_table = of_match_ptr(trf7970a_of_match), 2264 - .pm = &trf7970a_pm_ops, 2290 + .driver = { 2291 + .name = "trf7970a", 2292 + .of_match_table = of_match_ptr(trf7970a_of_match), 2293 + .pm = &trf7970a_pm_ops, 2265 2294 }, 2266 2295 }; 2267 2296

+1 -1

include/linux/platform_data/nfcmrvl.h

··· 23 23 */ 24 24 25 25 /* GPIO that is wired to RESET_N signal */ 26 - unsigned int reset_n_io; 26 + int reset_n_io; 27 27 /* Tell if transport is muxed in HCI one */ 28 28 unsigned int hci_muxed; 29 29

-31

include/linux/platform_data/st-nci.h

··· 1 - /* 2 - * Driver include for ST NCI NFC chip family. 3 - * 4 - * Copyright (C) 2014-2015 STMicroelectronics SAS. All rights reserved. 5 - * 6 - * This program is free software; you can redistribute it and/or modify it 7 - * under the terms and conditions of the GNU General Public License, 8 - * version 2, as published by the Free Software Foundation. 9 - * 10 - * This program is distributed in the hope that it will be useful, 11 - * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 - * GNU General Public License for more details. 14 - * 15 - * You should have received a copy of the GNU General Public License 16 - * along with this program; if not, see <http://www.gnu.org/licenses/>. 17 - */ 18 - 19 - #ifndef _ST_NCI_H_ 20 - #define _ST_NCI_H_ 21 - 22 - #define ST_NCI_DRIVER_NAME "st_nci" 23 - 24 - struct st_nci_nfc_platform_data { 25 - unsigned int gpio_reset; 26 - unsigned int irq_polarity; 27 - bool is_ese_present; 28 - bool is_uicc_present; 29 - }; 30 - 31 - #endif /* _ST_NCI_H_ */

+18 -13

net/nfc/core.c

··· 982 982 kfree(se); 983 983 } 984 984 985 + ida_simple_remove(&nfc_index_ida, dev->idx); 986 + 985 987 kfree(dev); 986 988 } 987 989 ··· 1058 1056 int tx_headroom, int tx_tailroom) 1059 1057 { 1060 1058 struct nfc_dev *dev; 1059 + int rc; 1061 1060 1062 1061 if (!ops->start_poll || !ops->stop_poll || !ops->activate_target || 1063 1062 !ops->deactivate_target || !ops->im_transceive) ··· 1070 1067 dev = kzalloc(sizeof(struct nfc_dev), GFP_KERNEL); 1071 1068 if (!dev) 1072 1069 return NULL; 1070 + 1071 + rc = ida_simple_get(&nfc_index_ida, 0, 0, GFP_KERNEL); 1072 + if (rc < 0) 1073 + goto err_free_dev; 1074 + dev->idx = rc; 1075 + 1076 + dev->dev.class = &nfc_class; 1077 + dev_set_name(&dev->dev, "nfc%d", dev->idx); 1078 + device_initialize(&dev->dev); 1073 1079 1074 1080 dev->ops = ops; 1075 1081 dev->supported_protocols = supported_protocols; ··· 1102 1090 } 1103 1091 1104 1092 return dev; 1093 + 1094 + err_free_dev: 1095 + kfree(dev); 1096 + 1097 + return ERR_PTR(rc); 1105 1098 } 1106 1099 EXPORT_SYMBOL(nfc_allocate_device); 1107 1100 ··· 1120 1103 int rc; 1121 1104 1122 1105 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 1123 - 1124 - dev->idx = ida_simple_get(&nfc_index_ida, 0, 0, GFP_KERNEL); 1125 - if (dev->idx < 0) 1126 - return dev->idx; 1127 - 1128 - dev->dev.class = &nfc_class; 1129 - dev_set_name(&dev->dev, "nfc%d", dev->idx); 1130 - device_initialize(&dev->dev); 1131 1106 1132 1107 mutex_lock(&nfc_devlist_mutex); 1133 1108 nfc_devlist_generation++; ··· 1158 1149 */ 1159 1150 void nfc_unregister_device(struct nfc_dev *dev) 1160 1151 { 1161 - int rc, id; 1152 + int rc; 1162 1153 1163 1154 pr_debug("dev_name=%s\n", dev_name(&dev->dev)); 1164 - 1165 - id = dev->idx; 1166 1155 1167 1156 if (dev->rfkill) { 1168 1157 rfkill_unregister(dev->rfkill); ··· 1186 1179 nfc_devlist_generation++; 1187 1180 device_del(&dev->dev); 1188 1181 mutex_unlock(&nfc_devlist_mutex); 1189 - 1190 - ida_simple_remove(&nfc_index_ida, id); 1191 1182 } 1192 1183 EXPORT_SYMBOL(nfc_unregister_device); 1193 1184

+5 -7

net/nfc/digital_core.c

··· 240 240 { 241 241 struct digital_cmd *cmd; 242 242 243 - cmd = kzalloc(sizeof(struct digital_cmd), GFP_KERNEL); 243 + cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 244 244 if (!cmd) 245 245 return -ENOMEM; 246 246 ··· 287 287 { 288 288 struct digital_tg_mdaa_params *params; 289 289 290 - params = kzalloc(sizeof(struct digital_tg_mdaa_params), GFP_KERNEL); 290 + params = kzalloc(sizeof(*params), GFP_KERNEL); 291 291 if (!params) 292 292 return -ENOMEM; 293 293 ··· 706 706 struct digital_data_exch *data_exch; 707 707 int rc; 708 708 709 - data_exch = kzalloc(sizeof(struct digital_data_exch), GFP_KERNEL); 710 - if (!data_exch) { 711 - pr_err("Failed to allocate data_exch struct\n"); 709 + data_exch = kzalloc(sizeof(*data_exch), GFP_KERNEL); 710 + if (!data_exch) 712 711 return -ENOMEM; 713 - } 714 712 715 713 data_exch->cb = cb; 716 714 data_exch->cb_context = cb_context; ··· 762 764 !ops->switch_rf || (ops->tg_listen_md && !ops->tg_get_rf_tech)) 763 765 return NULL; 764 766 765 - ddev = kzalloc(sizeof(struct nfc_digital_dev), GFP_KERNEL); 767 + ddev = kzalloc(sizeof(*ddev), GFP_KERNEL); 766 768 if (!ddev) 767 769 return NULL; 768 770

+1 -1

net/nfc/digital_dep.c

··· 151 151 * 0 <= wt <= 14 (given by the target by the TO field of ATR_RES response) 152 152 */ 153 153 #define DIGITAL_NFC_DEP_IN_MAX_WT 14 154 - #define DIGITAL_NFC_DEP_TG_MAX_WT 8 154 + #define DIGITAL_NFC_DEP_TG_MAX_WT 14 155 155 static const u16 digital_rwt_map[DIGITAL_NFC_DEP_IN_MAX_WT + 1] = { 156 156 100, 101, 101, 102, 105, 157 157 110, 119, 139, 177, 255,

+2 -1

net/nfc/digital_technology.c

··· 27 27 28 28 #define DIGITAL_SDD_RES_CT 0x88 29 29 #define DIGITAL_SDD_RES_LEN 5 30 + #define DIGITAL_SEL_RES_LEN 1 30 31 31 32 #define DIGITAL_SEL_RES_NFCID1_COMPLETE(sel_res) (!((sel_res) & 0x04)) 32 33 #define DIGITAL_SEL_RES_IS_T2T(sel_res) (!((sel_res) & 0x60)) ··· 300 299 } 301 300 } 302 301 303 - if (!resp->len) { 302 + if (resp->len != DIGITAL_SEL_RES_LEN) { 304 303 rc = -EIO; 305 304 goto exit; 306 305 }

+5 -4

net/nfc/llcp_sock.c

··· 77 77 struct sockaddr_nfc_llcp llcp_addr; 78 78 int len, ret = 0; 79 79 80 - if (!addr || addr->sa_family != AF_NFC) 80 + if (!addr || alen < offsetofend(struct sockaddr, sa_family) || 81 + addr->sa_family != AF_NFC) 81 82 return -EINVAL; 82 83 83 84 pr_debug("sk %p addr %p family %d\n", sk, addr, addr->sa_family); ··· 152 151 struct sockaddr_nfc_llcp llcp_addr; 153 152 int len, ret = 0; 154 153 155 - if (!addr || addr->sa_family != AF_NFC) 154 + if (!addr || alen < offsetofend(struct sockaddr, sa_family) || 155 + addr->sa_family != AF_NFC) 156 156 return -EINVAL; 157 157 158 158 pr_debug("sk %p addr %p family %d\n", sk, addr, addr->sa_family); ··· 664 662 665 663 pr_debug("sock %p sk %p flags 0x%x\n", sock, sk, flags); 666 664 667 - if (!addr || len < sizeof(struct sockaddr_nfc) || 668 - addr->sa_family != AF_NFC) 665 + if (!addr || len < sizeof(*addr) || addr->sa_family != AF_NFC) 669 666 return -EINVAL; 670 667 671 668 if (addr->service_name_len == 0 && addr->dsap == 0)

+5 -7

net/nfc/nci/core.c

··· 73 73 if (conn_info->dest_type == dest_type) { 74 74 if (!params) 75 75 return conn_info->conn_id; 76 - if (conn_info) { 77 - if (params->id == conn_info->dest_params->id && 78 - params->protocol == conn_info->dest_params->protocol) 79 - return conn_info->conn_id; 80 - } 76 + 77 + if (params->id == conn_info->dest_params->id && 78 + params->protocol == conn_info->dest_params->protocol) 79 + return conn_info->conn_id; 81 80 } 82 81 } 83 82 ··· 1172 1173 return ndev; 1173 1174 1174 1175 free_nfc: 1175 - kfree(ndev->nfc_dev); 1176 - 1176 + nfc_free_device(ndev->nfc_dev); 1177 1177 free_nci: 1178 1178 kfree(ndev); 1179 1179 return NULL;

+3 -1

net/nfc/netlink.c

··· 907 907 u32 device_idx, target_idx, protocol; 908 908 int rc; 909 909 910 - if (!info->attrs[NFC_ATTR_DEVICE_INDEX]) 910 + if (!info->attrs[NFC_ATTR_DEVICE_INDEX] || 911 + !info->attrs[NFC_ATTR_TARGET_INDEX] || 912 + !info->attrs[NFC_ATTR_PROTOCOLS]) 911 913 return -EINVAL; 912 914 913 915 device_idx = nla_get_u32(info->attrs[NFC_ATTR_DEVICE_INDEX]);