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/serdev.h>
  20 #include <linux/slab.h>
  21 #include <linux/wait.h>
  22
  23 #define SIRF_BOOT_DELAY                 500
  24 #define SIRF_ON_OFF_PULSE_TIME          100
  25 #define SIRF_ACTIVATE_TIMEOUT           200
  26 #define SIRF_HIBERNATE_TIMEOUT          200
  27
  28 struct sirf_data {
  29         struct gnss_device *gdev;
  30         struct serdev_device *serdev;
  31         speed_t speed;
  32         struct regulator *vcc;
  33         struct gpio_desc *on_off;
  34         struct gpio_desc *wakeup;
  35         int irq;
  36         bool active;
  37         wait_queue_head_t power_wait;
  38 };
  39
  40 static int sirf_open(struct gnss_device *gdev)
  41 {
  42         struct sirf_data *data = gnss_get_drvdata(gdev);
  43         struct serdev_device *serdev = data->serdev;
  44         int ret;
  45
  46         ret = serdev_device_open(serdev);
  47         if (ret)
  48                 return ret;
  49
  50         serdev_device_set_baudrate(serdev, data->speed);
  51         serdev_device_set_flow_control(serdev, false);
  52
  53         ret = pm_runtime_get_sync(&serdev->dev);
  54         if (ret < 0) {
  55                 dev_err(&gdev->dev, "failed to runtime resume: %d\n", ret);
  56                 pm_runtime_put_noidle(&serdev->dev);
  57                 goto err_close;
  58         }
  59
  60         return 0;
  61
  62 err_close:
  63         serdev_device_close(serdev);
  64
  65         return ret;
  66 }
  67
  68 static void sirf_close(struct gnss_device *gdev)
  69 {
  70         struct sirf_data *data = gnss_get_drvdata(gdev);
  71         struct serdev_device *serdev = data->serdev;
  72
  73         serdev_device_close(serdev);
  74
  75         pm_runtime_put(&serdev->dev);
  76 }
  77
  78 static int sirf_write_raw(struct gnss_device *gdev, const unsigned char *buf,
  79                                 size_t count)
  80 {
  81         struct sirf_data *data = gnss_get_drvdata(gdev);
  82         struct serdev_device *serdev = data->serdev;
  83         int ret;
  84
  85         /* write is only buffered synchronously */
  86         ret = serdev_device_write(serdev, buf, count, 0);
  87         if (ret < 0)
  88                 return ret;
  89
  90         /* FIXME: determine if interrupted? */
  91         serdev_device_wait_until_sent(serdev, 0);
  92
  93         return count;
  94 }
  95
  96 static const struct gnss_operations sirf_gnss_ops = {
  97         .open           = sirf_open,
  98         .close          = sirf_close,
  99         .write_raw      = sirf_write_raw,
 100 };
 101
 102 static int sirf_receive_buf(struct serdev_device *serdev,
 103                                 const unsigned char *buf, size_t count)
 104 {
 105         struct sirf_data *data = serdev_device_get_drvdata(serdev);
 106         struct gnss_device *gdev = data->gdev;
 107
 108         return gnss_insert_raw(gdev, buf, count);
 109 }
 110
 111 static const struct serdev_device_ops sirf_serdev_ops = {
 112         .receive_buf    = sirf_receive_buf,
 113         .write_wakeup   = serdev_device_write_wakeup,
 114 };
 115
 116 static irqreturn_t sirf_wakeup_handler(int irq, void *dev_id)
 117 {
 118         struct sirf_data *data = dev_id;
 119         struct device *dev = &data->serdev->dev;
 120         int ret;
 121
 122         ret = gpiod_get_value_cansleep(data->wakeup);
 123         dev_dbg(dev, "%s - wakeup = %d\n", __func__, ret);
 124         if (ret < 0)
 125                 goto out;
 126
 127         data->active = !!ret;
 128         wake_up_interruptible(&data->power_wait);
 129 out:
 130         return IRQ_HANDLED;
 131 }
 132
 133 static int sirf_wait_for_power_state(struct sirf_data *data, bool active,
 134                                         unsigned long timeout)
 135 {
 136         int ret;
 137
 138         ret = wait_event_interruptible_timeout(data->power_wait,
 139                         data->active == active, msecs_to_jiffies(timeout));
 140         if (ret < 0)
 141                 return ret;
 142
 143         if (ret == 0) {
 144                 dev_warn(&data->serdev->dev, "timeout waiting for active state = %d\n",
 145                                 active);
 146                 return -ETIMEDOUT;
 147         }
 148
 149         return 0;
 150 }
 151
 152 static void sirf_pulse_on_off(struct sirf_data *data)
 153 {
 154         gpiod_set_value_cansleep(data->on_off, 1);
 155         msleep(SIRF_ON_OFF_PULSE_TIME);
 156         gpiod_set_value_cansleep(data->on_off, 0);
 157 }
 158
 159 static int sirf_set_active(struct sirf_data *data, bool active)
 160 {
 161         unsigned long timeout;
 162         int retries = 3;
 163         int ret;
 164
 165         if (active)
 166                 timeout = SIRF_ACTIVATE_TIMEOUT;
 167         else
 168                 timeout = SIRF_HIBERNATE_TIMEOUT;
 169
 170         while (retries-- > 0) {
 171                 sirf_pulse_on_off(data);
 172                 ret = sirf_wait_for_power_state(data, active, timeout);
 173                 if (ret < 0) {
 174                         if (ret == -ETIMEDOUT)
 175                                 continue;
 176
 177                         return ret;
 178                 }
 179
 180                 break;
 181         }
 182
 183         if (retries == 0)
 184                 return -ETIMEDOUT;
 185
 186         return 0;
 187 }
 188
 189 static int sirf_runtime_suspend(struct device *dev)
 190 {
 191         struct sirf_data *data = dev_get_drvdata(dev);
 192
 193         if (!data->on_off)
 194                 return regulator_disable(data->vcc);
 195
 196         return sirf_set_active(data, false);
 197 }
 198
 199 static int sirf_runtime_resume(struct device *dev)
 200 {
 201         struct sirf_data *data = dev_get_drvdata(dev);
 202
 203         if (!data->on_off)
 204                 return regulator_enable(data->vcc);
 205
 206         return sirf_set_active(data, true);
 207 }
 208
 209 static int __maybe_unused sirf_suspend(struct device *dev)
 210 {
 211         struct sirf_data *data = dev_get_drvdata(dev);
 212         int ret = 0;
 213
 214         if (!pm_runtime_suspended(dev))
 215                 ret = sirf_runtime_suspend(dev);
 216
 217         if (data->wakeup)
 218                 disable_irq(data->irq);
 219
 220         return ret;
 221 }
 222
 223 static int __maybe_unused sirf_resume(struct device *dev)
 224 {
 225         struct sirf_data *data = dev_get_drvdata(dev);
 226         int ret = 0;
 227
 228         if (data->wakeup)
 229                 enable_irq(data->irq);
 230
 231         if (!pm_runtime_suspended(dev))
 232                 ret = sirf_runtime_resume(dev);
 233
 234         return ret;
 235 }
 236
 237 static const struct dev_pm_ops sirf_pm_ops = {
 238         SET_SYSTEM_SLEEP_PM_OPS(sirf_suspend, sirf_resume)
 239         SET_RUNTIME_PM_OPS(sirf_runtime_suspend, sirf_runtime_resume, NULL)
 240 };
 241
 242 static int sirf_parse_dt(struct serdev_device *serdev)
 243 {
 244         struct sirf_data *data = serdev_device_get_drvdata(serdev);
 245         struct device_node *node = serdev->dev.of_node;
 246         u32 speed = 9600;
 247
 248         of_property_read_u32(node, "current-speed", &speed);
 249
 250         data->speed = speed;
 251
 252         return 0;
 253 }
 254
 255 static int sirf_probe(struct serdev_device *serdev)
 256 {
 257         struct device *dev = &serdev->dev;
 258         struct gnss_device *gdev;
 259         struct sirf_data *data;
 260         int ret;
 261
 262         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 263         if (!data)
 264                 return -ENOMEM;
 265
 266         gdev = gnss_allocate_device(dev);
 267         if (!gdev)
 268                 return -ENOMEM;
 269
 270         gdev->type = GNSS_TYPE_SIRF;
 271         gdev->ops = &sirf_gnss_ops;
 272         gnss_set_drvdata(gdev, data);
 273
 274         data->serdev = serdev;
 275         data->gdev = gdev;
 276
 277         init_waitqueue_head(&data->power_wait);
 278
 279         serdev_device_set_drvdata(serdev, data);
 280         serdev_device_set_client_ops(serdev, &sirf_serdev_ops);
 281
 282         ret = sirf_parse_dt(serdev);
 283         if (ret)
 284                 goto err_put_device;
 285
 286         data->vcc = devm_regulator_get(dev, "vcc");
 287         if (IS_ERR(data->vcc)) {
 288                 ret = PTR_ERR(data->vcc);
 289                 goto err_put_device;
 290         }
 291
 292         data->on_off = devm_gpiod_get_optional(dev, "sirf,onoff",
 293                         GPIOD_OUT_LOW);
 294         if (IS_ERR(data->on_off))
 295                 goto err_put_device;
 296
 297         if (data->on_off) {
 298                 data->wakeup = devm_gpiod_get_optional(dev, "sirf,wakeup",
 299                                 GPIOD_IN);
 300                 if (IS_ERR(data->wakeup))
 301                         goto err_put_device;
 302
 303                 /*
 304                  * Configurations where WAKEUP has been left not connected,
 305                  * are currently not supported.
 306                  */
 307                 if (!data->wakeup) {
 308                         dev_err(dev, "no wakeup gpio specified\n");
 309                         ret = -ENODEV;
 310                         goto err_put_device;
 311                 }
 312         }
 313
 314         if (data->wakeup) {
 315                 ret = gpiod_to_irq(data->wakeup);
 316                 if (ret < 0)
 317                         goto err_put_device;
 318
 319                 data->irq = ret;
 320
 321                 ret = devm_request_threaded_irq(dev, data->irq, NULL,
 322                                 sirf_wakeup_handler,
 323                                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 324                                 "wakeup", data);
 325                 if (ret)
 326                         goto err_put_device;
 327         }
 328
 329         if (data->on_off) {
 330                 ret = regulator_enable(data->vcc);
 331                 if (ret)
 332                         goto err_put_device;
 333
 334                 /* Wait for chip to boot into hibernate mode */
 335                 msleep(SIRF_BOOT_DELAY);
 336         }
 337
 338         if (IS_ENABLED(CONFIG_PM)) {
 339                 pm_runtime_set_suspended(dev);  /* clear runtime_error flag */
 340                 pm_runtime_enable(dev);
 341         } else {
 342                 ret = sirf_runtime_resume(dev);
 343                 if (ret < 0)
 344                         goto err_disable_vcc;
 345         }
 346
 347         ret = gnss_register_device(gdev);
 348         if (ret)
 349                 goto err_disable_rpm;
 350
 351         return 0;
 352
 353 err_disable_rpm:
 354         if (IS_ENABLED(CONFIG_PM))
 355                 pm_runtime_disable(dev);
 356         else
 357                 sirf_runtime_suspend(dev);
 358 err_disable_vcc:
 359         if (data->on_off)
 360                 regulator_disable(data->vcc);
 361 err_put_device:
 362         gnss_put_device(data->gdev);
 363
 364         return ret;
 365 }
 366
 367 static void sirf_remove(struct serdev_device *serdev)
 368 {
 369         struct sirf_data *data = serdev_device_get_drvdata(serdev);
 370
 371         gnss_deregister_device(data->gdev);
 372
 373         if (IS_ENABLED(CONFIG_PM))
 374                 pm_runtime_disable(&serdev->dev);
 375         else
 376                 sirf_runtime_suspend(&serdev->dev);
 377
 378         if (data->on_off)
 379                 regulator_disable(data->vcc);
 380
 381         gnss_put_device(data->gdev);
 382 };
 383
 384 #ifdef CONFIG_OF
 385 static const struct of_device_id sirf_of_match[] = {
 386         { .compatible = "fastrax,uc430" },
 387         { .compatible = "linx,r4" },
 388         { .compatible = "wi2wi,w2sg0008i" },
 389         { .compatible = "wi2wi,w2sg0084i" },
 390         {},
 391 };
 392 MODULE_DEVICE_TABLE(of, sirf_of_match);
 393 #endif
 394
 395 static struct serdev_device_driver sirf_driver = {
 396         .driver = {
 397                 .name           = "gnss-sirf",
 398                 .of_match_table = of_match_ptr(sirf_of_match),
 399                 .pm             = &sirf_pm_ops,
 400         },
 401         .probe  = sirf_probe,
 402         .remove = sirf_remove,
 403 };
 404 module_serdev_device_driver(sirf_driver);
 405
 406 MODULE_AUTHOR("Johan Hovold <johan@kernel.org>");
 407 MODULE_DESCRIPTION("SiRFstar GNSS receiver driver");
 408 MODULE_LICENSE("GPL v2");