drivers/gnss/sirf.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * SiRFstar GNSS receiver driver
   4  *
   5  * Copyright (C) 2018 Johan Hovold <johan@kernel.org>
   6  */
   7
   8 #include <linux/errno.h>
   9 #include <linux/gnss.h>
  10 #include <linux/gpio/consumer.h>
  11 #include <linux/init.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/of.h>
  16 #include <linux/pm.h>
  17 #include <linux/pm_runtime.h>
  18 #include <linux/regulator/consumer.h>
  19 #include <linux/sched.h>
  20 #include <linux/serdev.h>
  21 #include <linux/slab.h>
  22 #include <linux/wait.h>
  23
  24 #define SIRF_BOOT_DELAY                 500
  25 #define SIRF_ON_OFF_PULSE_TIME          100
  26 #define SIRF_ACTIVATE_TIMEOUT           200
  27 #define SIRF_HIBERNATE_TIMEOUT          200
  28 /*
  29  * If no data arrives for this time, we assume that the chip is off.
  30  * REVISIT: The report cycle is configurable and can be several minutes long,
  31  * so this will only work reliably if the report cycle is set to a reasonable
  32  * low value. Also power saving settings (like send data only on movement)
  33  * might things work even worse.
  34  * Workaround might be to parse shutdown or bootup messages.
  35  */
  36 #define SIRF_REPORT_CYCLE       2000
  37
  38 struct sirf_data {
  39         struct gnss_device *gdev;
  40         struct serdev_device *serdev;
  41         speed_t speed;
  42         struct regulator *vcc;
  43         struct regulator *lna;
  44         struct gpio_desc *on_off;
  45         struct gpio_desc *wakeup;
  46         int irq;
  47         bool active;
  48
  49         struct mutex gdev_mutex;
  50         bool open;
  51
  52         struct mutex serdev_mutex;
  53         int serdev_count;
  54
  55         wait_queue_head_t power_wait;
  56 };
  57
  58 static int sirf_serdev_open(struct sirf_data *data)
  59 {
  60         int ret = 0;
  61
  62         mutex_lock(&data->serdev_mutex);
  63         if (++data->serdev_count == 1) {
  64                 ret = serdev_device_open(data->serdev);
  65                 if (ret) {
  66                         data->serdev_count--;
  67                         goto out_unlock;
  68                 }
  69
  70                 serdev_device_set_baudrate(data->serdev, data->speed);
  71                 serdev_device_set_flow_control(data->serdev, false);
  72         }
  73
  74 out_unlock:
  75         mutex_unlock(&data->serdev_mutex);
  76
  77         return ret;
  78 }
  79
  80 static void sirf_serdev_close(struct sirf_data *data)
  81 {
  82         mutex_lock(&data->serdev_mutex);
  83         if (--data->serdev_count == 0)
  84                 serdev_device_close(data->serdev);
  85         mutex_unlock(&data->serdev_mutex);
  86 }
  87
  88 static int sirf_open(struct gnss_device *gdev)
  89 {
  90         struct sirf_data *data = gnss_get_drvdata(gdev);
  91         struct serdev_device *serdev = data->serdev;
  92         int ret;
  93
  94         mutex_lock(&data->gdev_mutex);
  95         data->open = true;
  96         mutex_unlock(&data->gdev_mutex);
  97
  98         ret = sirf_serdev_open(data);
  99         if (ret) {
 100                 mutex_lock(&data->gdev_mutex);
 101                 data->open = false;
 102                 mutex_unlock(&data->gdev_mutex);
 103                 return ret;
 104         }
 105
 106         ret = pm_runtime_get_sync(&serdev->dev);
 107         if (ret < 0) {
 108                 dev_err(&gdev->dev, "failed to runtime resume: %d\n", ret);
 109                 pm_runtime_put_noidle(&serdev->dev);
 110                 goto err_close;
 111         }
 112
 113         return 0;
 114
 115 err_close:
 116         sirf_serdev_close(data);
 117
 118         mutex_lock(&data->gdev_mutex);
 119         data->open = false;
 120         mutex_unlock(&data->gdev_mutex);
 121
 122         return ret;
 123 }
 124
 125 static void sirf_close(struct gnss_device *gdev)
 126 {
 127         struct sirf_data *data = gnss_get_drvdata(gdev);
 128         struct serdev_device *serdev = data->serdev;
 129
 130         sirf_serdev_close(data);
 131
 132         pm_runtime_put(&serdev->dev);
 133
 134         mutex_lock(&data->gdev_mutex);
 135         data->open = false;
 136         mutex_unlock(&data->gdev_mutex);
 137 }
 138
 139 static int sirf_write_raw(struct gnss_device *gdev, const unsigned char *buf,
 140                                 size_t count)
 141 {
 142         struct sirf_data *data = gnss_get_drvdata(gdev);
 143         struct serdev_device *serdev = data->serdev;
 144         int ret;
 145
 146         /* write is only buffered synchronously */
 147         ret = serdev_device_write(serdev, buf, count, MAX_SCHEDULE_TIMEOUT);
 148         if (ret < 0 || ret < count)
 149                 return ret;
 150
 151         /* FIXME: determine if interrupted? */
 152         serdev_device_wait_until_sent(serdev, 0);
 153
 154         return count;
 155 }
 156
 157 static const struct gnss_operations sirf_gnss_ops = {
 158         .open           = sirf_open,
 159         .close          = sirf_close,
 160         .write_raw      = sirf_write_raw,
 161 };
 162
 163 static int sirf_receive_buf(struct serdev_device *serdev,
 164                                 const unsigned char *buf, size_t count)
 165 {
 166         struct sirf_data *data = serdev_device_get_drvdata(serdev);
 167         struct gnss_device *gdev = data->gdev;
 168         int ret = 0;
 169
 170         if (!data->wakeup && !data->active) {
 171                 data->active = true;
 172                 wake_up_interruptible(&data->power_wait);
 173         }
 174
 175         mutex_lock(&data->gdev_mutex);
 176         if (data->open)
 177                 ret = gnss_insert_raw(gdev, buf, count);
 178         mutex_unlock(&data->gdev_mutex);
 179
 180         return ret;
 181 }
 182
 183 static const struct serdev_device_ops sirf_serdev_ops = {
 184         .receive_buf    = sirf_receive_buf,
 185         .write_wakeup   = serdev_device_write_wakeup,
 186 };
 187
 188 static irqreturn_t sirf_wakeup_handler(int irq, void *dev_id)
 189 {
 190         struct sirf_data *data = dev_id;
 191         struct device *dev = &data->serdev->dev;
 192         int ret;
 193
 194         ret = gpiod_get_value_cansleep(data->wakeup);
 195         dev_dbg(dev, "%s - wakeup = %d\n", __func__, ret);
 196         if (ret < 0)
 197                 goto out;
 198
 199         data->active = ret;
 200         wake_up_interruptible(&data->power_wait);
 201 out:
 202         return IRQ_HANDLED;
 203 }
 204
 205 static int sirf_wait_for_power_state_nowakeup(struct sirf_data *data,
 206                                                 bool active,
 207                                                 unsigned long timeout)
 208 {
 209         int ret;
 210
 211         /* Wait for state change (including any shutdown messages). */
 212         msleep(timeout);
 213
 214         /* Wait for data reception or timeout. */
 215         data->active = false;
 216         ret = wait_event_interruptible_timeout(data->power_wait,
 217                         data->active, msecs_to_jiffies(SIRF_REPORT_CYCLE));
 218         if (ret < 0)
 219                 return ret;
 220
 221         if (ret > 0 && !active)
 222                 return -ETIMEDOUT;
 223
 224         if (ret == 0 && active)
 225                 return -ETIMEDOUT;
 226
 227         return 0;
 228 }
 229
 230 static int sirf_wait_for_power_state(struct sirf_data *data, bool active,
 231                                         unsigned long timeout)
 232 {
 233         int ret;
 234
 235         if (!data->wakeup)
 236                 return sirf_wait_for_power_state_nowakeup(data, active, timeout);
 237
 238         ret = wait_event_interruptible_timeout(data->power_wait,
 239                         data->active == active, msecs_to_jiffies(timeout));
 240         if (ret < 0)
 241                 return ret;
 242
 243         if (ret == 0) {
 244                 dev_warn(&data->serdev->dev, "timeout waiting for active state = %d\n",
 245                                 active);
 246                 return -ETIMEDOUT;
 247         }
 248
 249         return 0;
 250 }
 251
 252 static void sirf_pulse_on_off(struct sirf_data *data)
 253 {
 254         gpiod_set_value_cansleep(data->on_off, 1);
 255         msleep(SIRF_ON_OFF_PULSE_TIME);
 256         gpiod_set_value_cansleep(data->on_off, 0);
 257 }
 258
 259 static int sirf_set_active(struct sirf_data *data, bool active)
 260 {
 261         unsigned long timeout;
 262         int retries = 3;
 263         int ret;
 264
 265         if (active)
 266                 timeout = SIRF_ACTIVATE_TIMEOUT;
 267         else
 268                 timeout = SIRF_HIBERNATE_TIMEOUT;
 269
 270         if (!data->wakeup) {
 271                 ret = sirf_serdev_open(data);
 272                 if (ret)
 273                         return ret;
 274         }
 275
 276         do {
 277                 sirf_pulse_on_off(data);
 278                 ret = sirf_wait_for_power_state(data, active, timeout);
 279         } while (ret == -ETIMEDOUT && retries--);
 280
 281         if (!data->wakeup)
 282                 sirf_serdev_close(data);
 283
 284         if (ret)
 285                 return ret;
 286
 287         return 0;
 288 }
 289
 290 static int sirf_runtime_suspend(struct device *dev)
 291 {
 292         struct sirf_data *data = dev_get_drvdata(dev);
 293         int ret2;
 294         int ret;
 295
 296         if (data->on_off)
 297                 ret = sirf_set_active(data, false);
 298         else
 299                 ret = regulator_disable(data->vcc);
 300
 301         if (ret)
 302                 return ret;
 303
 304         ret = regulator_disable(data->lna);
 305         if (ret)
 306                 goto err_reenable;
 307
 308         return 0;
 309
 310 err_reenable:
 311         if (data->on_off)
 312                 ret2 = sirf_set_active(data, true);
 313         else
 314                 ret2 = regulator_enable(data->vcc);
 315
 316         if (ret2)
 317                 dev_err(dev,
 318                         "failed to reenable power on failed suspend: %d\n",
 319                         ret2);
 320
 321         return ret;
 322 }
 323
 324 static int sirf_runtime_resume(struct device *dev)
 325 {
 326         struct sirf_data *data = dev_get_drvdata(dev);
 327         int ret;
 328
 329         ret = regulator_enable(data->lna);
 330         if (ret)
 331                 return ret;
 332
 333         if (data->on_off)
 334                 ret = sirf_set_active(data, true);
 335         else
 336                 ret = regulator_enable(data->vcc);
 337
 338         if (ret)
 339                 goto err_disable_lna;
 340
 341         return 0;
 342
 343 err_disable_lna:
 344         regulator_disable(data->lna);
 345
 346         return ret;
 347 }
 348
 349 static int __maybe_unused sirf_suspend(struct device *dev)
 350 {
 351         struct sirf_data *data = dev_get_drvdata(dev);
 352         int ret = 0;
 353
 354         if (!pm_runtime_suspended(dev))
 355                 ret = sirf_runtime_suspend(dev);
 356
 357         if (data->wakeup)
 358                 disable_irq(data->irq);
 359
 360         return ret;
 361 }
 362
 363 static int __maybe_unused sirf_resume(struct device *dev)
 364 {
 365         struct sirf_data *data = dev_get_drvdata(dev);
 366         int ret = 0;
 367
 368         if (data->wakeup)
 369                 enable_irq(data->irq);
 370
 371         if (!pm_runtime_suspended(dev))
 372                 ret = sirf_runtime_resume(dev);
 373
 374         return ret;
 375 }
 376
 377 static const struct dev_pm_ops sirf_pm_ops = {
 378         SET_SYSTEM_SLEEP_PM_OPS(sirf_suspend, sirf_resume)
 379         SET_RUNTIME_PM_OPS(sirf_runtime_suspend, sirf_runtime_resume, NULL)
 380 };
 381
 382 static int sirf_parse_dt(struct serdev_device *serdev)
 383 {
 384         struct sirf_data *data = serdev_device_get_drvdata(serdev);
 385         struct device_node *node = serdev->dev.of_node;
 386         u32 speed = 9600;
 387
 388         of_property_read_u32(node, "current-speed", &speed);
 389
 390         data->speed = speed;
 391
 392         return 0;
 393 }
 394
 395 static int sirf_probe(struct serdev_device *serdev)
 396 {
 397         struct device *dev = &serdev->dev;
 398         struct gnss_device *gdev;
 399         struct sirf_data *data;
 400         int ret;
 401
 402         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 403         if (!data)
 404                 return -ENOMEM;
 405
 406         gdev = gnss_allocate_device(dev);
 407         if (!gdev)
 408                 return -ENOMEM;
 409
 410         gdev->type = GNSS_TYPE_SIRF;
 411         gdev->ops = &sirf_gnss_ops;
 412         gnss_set_drvdata(gdev, data);
 413
 414         data->serdev = serdev;
 415         data->gdev = gdev;
 416
 417         mutex_init(&data->gdev_mutex);
 418         mutex_init(&data->serdev_mutex);
 419         init_waitqueue_head(&data->power_wait);
 420
 421         serdev_device_set_drvdata(serdev, data);
 422         serdev_device_set_client_ops(serdev, &sirf_serdev_ops);
 423
 424         ret = sirf_parse_dt(serdev);
 425         if (ret)
 426                 goto err_put_device;
 427
 428         data->vcc = devm_regulator_get(dev, "vcc");
 429         if (IS_ERR(data->vcc)) {
 430                 ret = PTR_ERR(data->vcc);
 431                 goto err_put_device;
 432         }
 433
 434         data->lna = devm_regulator_get(dev, "lna");
 435         if (IS_ERR(data->lna)) {
 436                 ret = PTR_ERR(data->lna);
 437                 goto err_put_device;
 438         }
 439
 440         data->on_off = devm_gpiod_get_optional(dev, "sirf,onoff",
 441                         GPIOD_OUT_LOW);
 442         if (IS_ERR(data->on_off)) {
 443                 ret = PTR_ERR(data->on_off);
 444                 goto err_put_device;
 445         }
 446
 447         if (data->on_off) {
 448                 data->wakeup = devm_gpiod_get_optional(dev, "sirf,wakeup",
 449                                 GPIOD_IN);
 450                 if (IS_ERR(data->wakeup)) {
 451                         ret = PTR_ERR(data->wakeup);
 452                         goto err_put_device;
 453                 }
 454
 455                 ret = regulator_enable(data->vcc);
 456                 if (ret)
 457                         goto err_put_device;
 458
 459                 /* Wait for chip to boot into hibernate mode. */
 460                 msleep(SIRF_BOOT_DELAY);
 461         }
 462
 463         if (data->wakeup) {
 464                 ret = gpiod_get_value_cansleep(data->wakeup);
 465                 if (ret < 0)
 466                         goto err_disable_vcc;
 467                 data->active = ret;
 468
 469                 ret = gpiod_to_irq(data->wakeup);
 470                 if (ret < 0)
 471                         goto err_disable_vcc;
 472                 data->irq = ret;
 473
 474                 ret = request_threaded_irq(data->irq, NULL, sirf_wakeup_handler,
 475                                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 476                                 "wakeup", data);
 477                 if (ret)
 478                         goto err_disable_vcc;
 479         }
 480
 481         if (data->on_off) {
 482                 if (!data->wakeup) {
 483                         data->active = false;
 484
 485                         ret = sirf_serdev_open(data);
 486                         if (ret)
 487                                 goto err_disable_vcc;
 488
 489                         msleep(SIRF_REPORT_CYCLE);
 490                         sirf_serdev_close(data);
 491                 }
 492
 493                 /* Force hibernate mode if already active. */
 494                 if (data->active) {
 495                         ret = sirf_set_active(data, false);
 496                         if (ret) {
 497                                 dev_err(dev, "failed to set hibernate mode: %d\n",
 498                                                 ret);
 499                                 goto err_free_irq;
 500                         }
 501                 }
 502         }
 503
 504         if (IS_ENABLED(CONFIG_PM)) {
 505                 pm_runtime_set_suspended(dev);  /* clear runtime_error flag */
 506                 pm_runtime_enable(dev);
 507         } else {
 508                 ret = sirf_runtime_resume(dev);
 509                 if (ret < 0)
 510                         goto err_free_irq;
 511         }
 512
 513         ret = gnss_register_device(gdev);
 514         if (ret)
 515                 goto err_disable_rpm;
 516
 517         return 0;
 518
 519 err_disable_rpm:
 520         if (IS_ENABLED(CONFIG_PM))
 521                 pm_runtime_disable(dev);
 522         else
 523                 sirf_runtime_suspend(dev);
 524 err_free_irq:
 525         if (data->wakeup)
 526                 free_irq(data->irq, data);
 527 err_disable_vcc:
 528         if (data->on_off)
 529                 regulator_disable(data->vcc);
 530 err_put_device:
 531         gnss_put_device(data->gdev);
 532
 533         return ret;
 534 }
 535
 536 static void sirf_remove(struct serdev_device *serdev)
 537 {
 538         struct sirf_data *data = serdev_device_get_drvdata(serdev);
 539
 540         gnss_deregister_device(data->gdev);
 541
 542         if (IS_ENABLED(CONFIG_PM))
 543                 pm_runtime_disable(&serdev->dev);
 544         else
 545                 sirf_runtime_suspend(&serdev->dev);
 546
 547         if (data->wakeup)
 548                 free_irq(data->irq, data);
 549
 550         if (data->on_off)
 551                 regulator_disable(data->vcc);
 552
 553         gnss_put_device(data->gdev);
 554 };
 555
 556 #ifdef CONFIG_OF
 557 static const struct of_device_id sirf_of_match[] = {
 558         { .compatible = "fastrax,uc430" },
 559         { .compatible = "linx,r4" },
 560         { .compatible = "wi2wi,w2sg0004" },
 561         { .compatible = "wi2wi,w2sg0008i" },
 562         { .compatible = "wi2wi,w2sg0084i" },
 563         {},
 564 };
 565 MODULE_DEVICE_TABLE(of, sirf_of_match);
 566 #endif
 567
 568 static struct serdev_device_driver sirf_driver = {
 569         .driver = {
 570                 .name           = "gnss-sirf",
 571                 .of_match_table = of_match_ptr(sirf_of_match),
 572                 .pm             = &sirf_pm_ops,
 573         },
 574         .probe  = sirf_probe,
 575         .remove = sirf_remove,
 576 };
 577 module_serdev_device_driver(sirf_driver);
 578
 579 MODULE_AUTHOR("Johan Hovold <johan@kernel.org>");
 580 MODULE_DESCRIPTION("SiRFstar GNSS receiver driver");
 581 MODULE_LICENSE("GPL v2");