Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Driver for Epson's RTC module RX-8025 SA/NB
0004  *
0005  * Copyright (C) 2009 Wolfgang Grandegger <wg@grandegger.com>
0006  *
0007  * Copyright (C) 2005 by Digi International Inc.
0008  * All rights reserved.
0009  *
0010  * Modified by fengjh at rising.com.cn
0011  * <lm-sensors@lm-sensors.org>
0012  * 2006.11
0013  *
0014  * Code cleanup by Sergei Poselenov, <sposelenov@emcraft.com>
0015  * Converted to new style by Wolfgang Grandegger <wg@grandegger.com>
0016  * Alarm and periodic interrupt added by Dmitry Rakhchev <rda@emcraft.com>
0017  */
0018 #include <linux/bcd.h>
0019 #include <linux/bitops.h>
0020 #include <linux/i2c.h>
0021 #include <linux/kernel.h>
0022 #include <linux/module.h>
0023 #include <linux/rtc.h>
0024 
0025 /* Register definitions */
0026 #define RX8025_REG_SEC      0x00
0027 #define RX8025_REG_MIN      0x01
0028 #define RX8025_REG_HOUR     0x02
0029 #define RX8025_REG_WDAY     0x03
0030 #define RX8025_REG_MDAY     0x04
0031 #define RX8025_REG_MONTH    0x05
0032 #define RX8025_REG_YEAR     0x06
0033 #define RX8025_REG_DIGOFF   0x07
0034 #define RX8025_REG_ALWMIN   0x08
0035 #define RX8025_REG_ALWHOUR  0x09
0036 #define RX8025_REG_ALWWDAY  0x0a
0037 #define RX8025_REG_ALDMIN   0x0b
0038 #define RX8025_REG_ALDHOUR  0x0c
0039 /* 0x0d is reserved */
0040 #define RX8025_REG_CTRL1    0x0e
0041 #define RX8025_REG_CTRL2    0x0f
0042 
0043 #define RX8025_BIT_CTRL1_CT (7 << 0)
0044 /* 1 Hz periodic level irq */
0045 #define RX8025_BIT_CTRL1_CT_1HZ 4
0046 #define RX8025_BIT_CTRL1_TEST   BIT(3)
0047 #define RX8025_BIT_CTRL1_1224   BIT(5)
0048 #define RX8025_BIT_CTRL1_DALE   BIT(6)
0049 #define RX8025_BIT_CTRL1_WALE   BIT(7)
0050 
0051 #define RX8025_BIT_CTRL2_DAFG   BIT(0)
0052 #define RX8025_BIT_CTRL2_WAFG   BIT(1)
0053 #define RX8025_BIT_CTRL2_CTFG   BIT(2)
0054 #define RX8025_BIT_CTRL2_PON    BIT(4)
0055 #define RX8025_BIT_CTRL2_XST    BIT(5)
0056 #define RX8025_BIT_CTRL2_VDET   BIT(6)
0057 
0058 #define RX8035_BIT_HOUR_1224    BIT(7)
0059 
0060 /* Clock precision adjustment */
0061 #define RX8025_ADJ_RESOLUTION   3050 /* in ppb */
0062 #define RX8025_ADJ_DATA_MAX 62
0063 #define RX8025_ADJ_DATA_MIN -62
0064 
0065 enum rx_model {
0066     model_rx_unknown,
0067     model_rx_8025,
0068     model_rx_8035,
0069     model_last
0070 };
0071 
0072 static const struct i2c_device_id rx8025_id[] = {
0073     { "rx8025", model_rx_8025 },
0074     { "rx8035", model_rx_8035 },
0075     { }
0076 };
0077 MODULE_DEVICE_TABLE(i2c, rx8025_id);
0078 
0079 struct rx8025_data {
0080     struct rtc_device *rtc;
0081     enum rx_model model;
0082     u8 ctrl1;
0083     int is_24;
0084 };
0085 
0086 static s32 rx8025_read_reg(const struct i2c_client *client, u8 number)
0087 {
0088     return i2c_smbus_read_byte_data(client, number << 4);
0089 }
0090 
0091 static int rx8025_read_regs(const struct i2c_client *client,
0092                 u8 number, u8 length, u8 *values)
0093 {
0094     int ret = i2c_smbus_read_i2c_block_data(client, number << 4, length,
0095                         values);
0096     if (ret != length)
0097         return ret < 0 ? ret : -EIO;
0098 
0099     return 0;
0100 }
0101 
0102 static s32 rx8025_write_reg(const struct i2c_client *client, u8 number,
0103                 u8 value)
0104 {
0105     return i2c_smbus_write_byte_data(client, number << 4, value);
0106 }
0107 
0108 static s32 rx8025_write_regs(const struct i2c_client *client,
0109                  u8 number, u8 length, const u8 *values)
0110 {
0111     return i2c_smbus_write_i2c_block_data(client, number << 4,
0112                           length, values);
0113 }
0114 
0115 static int rx8025_is_osc_stopped(enum rx_model model, int ctrl2)
0116 {
0117     int xstp = ctrl2 & RX8025_BIT_CTRL2_XST;
0118     /* XSTP bit has different polarity on RX-8025 vs RX-8035.
0119      * RX-8025: 0 == oscillator stopped
0120      * RX-8035: 1 == oscillator stopped
0121      */
0122 
0123     if (model == model_rx_8025)
0124         xstp = !xstp;
0125 
0126     return xstp;
0127 }
0128 
0129 static int rx8025_check_validity(struct device *dev)
0130 {
0131     struct i2c_client *client = to_i2c_client(dev);
0132     struct rx8025_data *drvdata = dev_get_drvdata(dev);
0133     int ctrl2;
0134     int xstp;
0135 
0136     ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2);
0137     if (ctrl2 < 0)
0138         return ctrl2;
0139 
0140     if (ctrl2 & RX8025_BIT_CTRL2_VDET)
0141         dev_warn(dev, "power voltage drop detected\n");
0142 
0143     if (ctrl2 & RX8025_BIT_CTRL2_PON) {
0144         dev_warn(dev, "power-on reset detected, date is invalid\n");
0145         return -EINVAL;
0146     }
0147 
0148     xstp = rx8025_is_osc_stopped(drvdata->model, ctrl2);
0149     if (xstp) {
0150         dev_warn(dev, "crystal stopped, date is invalid\n");
0151         return -EINVAL;
0152     }
0153 
0154     return 0;
0155 }
0156 
0157 static int rx8025_reset_validity(struct i2c_client *client)
0158 {
0159     struct rx8025_data *drvdata = i2c_get_clientdata(client);
0160     int ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2);
0161 
0162     if (ctrl2 < 0)
0163         return ctrl2;
0164 
0165     ctrl2 &= ~(RX8025_BIT_CTRL2_PON | RX8025_BIT_CTRL2_VDET);
0166 
0167     if (drvdata->model == model_rx_8025)
0168         ctrl2 |= RX8025_BIT_CTRL2_XST;
0169     else
0170         ctrl2 &= ~(RX8025_BIT_CTRL2_XST);
0171 
0172     return rx8025_write_reg(client, RX8025_REG_CTRL2,
0173                 ctrl2);
0174 }
0175 
0176 static irqreturn_t rx8025_handle_irq(int irq, void *dev_id)
0177 {
0178     struct i2c_client *client = dev_id;
0179     struct rx8025_data *rx8025 = i2c_get_clientdata(client);
0180     int status, xstp;
0181 
0182     rtc_lock(rx8025->rtc);
0183     status = rx8025_read_reg(client, RX8025_REG_CTRL2);
0184     if (status < 0)
0185         goto out;
0186 
0187     xstp = rx8025_is_osc_stopped(rx8025->model, status);
0188     if (xstp)
0189         dev_warn(&client->dev, "Oscillation stop was detected,"
0190              "you may have to readjust the clock\n");
0191 
0192     if (status & RX8025_BIT_CTRL2_CTFG) {
0193         /* periodic */
0194         status &= ~RX8025_BIT_CTRL2_CTFG;
0195         rtc_update_irq(rx8025->rtc, 1, RTC_PF | RTC_IRQF);
0196     }
0197 
0198     if (status & RX8025_BIT_CTRL2_DAFG) {
0199         /* alarm */
0200         status &= RX8025_BIT_CTRL2_DAFG;
0201         if (rx8025_write_reg(client, RX8025_REG_CTRL1,
0202                      rx8025->ctrl1 & ~RX8025_BIT_CTRL1_DALE))
0203             goto out;
0204         rtc_update_irq(rx8025->rtc, 1, RTC_AF | RTC_IRQF);
0205     }
0206 
0207 out:
0208     rtc_unlock(rx8025->rtc);
0209 
0210     return IRQ_HANDLED;
0211 }
0212 
0213 static int rx8025_get_time(struct device *dev, struct rtc_time *dt)
0214 {
0215     struct i2c_client *client = to_i2c_client(dev);
0216     struct rx8025_data *rx8025 = dev_get_drvdata(dev);
0217     u8 date[7];
0218     int err;
0219 
0220     err = rx8025_check_validity(dev);
0221     if (err)
0222         return err;
0223 
0224     err = rx8025_read_regs(client, RX8025_REG_SEC, 7, date);
0225     if (err)
0226         return err;
0227 
0228     dev_dbg(dev, "%s: read %7ph\n", __func__, date);
0229 
0230     dt->tm_sec = bcd2bin(date[RX8025_REG_SEC] & 0x7f);
0231     dt->tm_min = bcd2bin(date[RX8025_REG_MIN] & 0x7f);
0232     if (rx8025->is_24)
0233         dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x3f);
0234     else
0235         dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x1f) % 12
0236             + (date[RX8025_REG_HOUR] & 0x20 ? 12 : 0);
0237 
0238     dt->tm_mday = bcd2bin(date[RX8025_REG_MDAY] & 0x3f);
0239     dt->tm_mon = bcd2bin(date[RX8025_REG_MONTH] & 0x1f) - 1;
0240     dt->tm_year = bcd2bin(date[RX8025_REG_YEAR]) + 100;
0241 
0242     dev_dbg(dev, "%s: date %ptRr\n", __func__, dt);
0243 
0244     return 0;
0245 }
0246 
0247 static int rx8025_set_time(struct device *dev, struct rtc_time *dt)
0248 {
0249     struct i2c_client *client = to_i2c_client(dev);
0250     struct rx8025_data *rx8025 = dev_get_drvdata(dev);
0251     u8 date[7];
0252     int ret;
0253 
0254     /*
0255      * Here the read-only bits are written as "0".  I'm not sure if that
0256      * is sound.
0257      */
0258     date[RX8025_REG_SEC] = bin2bcd(dt->tm_sec);
0259     date[RX8025_REG_MIN] = bin2bcd(dt->tm_min);
0260     if (rx8025->is_24)
0261         date[RX8025_REG_HOUR] = bin2bcd(dt->tm_hour);
0262     else
0263         date[RX8025_REG_HOUR] = (dt->tm_hour >= 12 ? 0x20 : 0)
0264             | bin2bcd((dt->tm_hour + 11) % 12 + 1);
0265 
0266     date[RX8025_REG_WDAY] = bin2bcd(dt->tm_wday);
0267     date[RX8025_REG_MDAY] = bin2bcd(dt->tm_mday);
0268     date[RX8025_REG_MONTH] = bin2bcd(dt->tm_mon + 1);
0269     date[RX8025_REG_YEAR] = bin2bcd(dt->tm_year - 100);
0270 
0271     dev_dbg(dev, "%s: write %7ph\n", __func__, date);
0272 
0273     ret = rx8025_write_regs(client, RX8025_REG_SEC, 7, date);
0274     if (ret < 0)
0275         return ret;
0276 
0277     return rx8025_reset_validity(client);
0278 }
0279 
0280 static int rx8025_init_client(struct i2c_client *client)
0281 {
0282     struct rx8025_data *rx8025 = i2c_get_clientdata(client);
0283     u8 ctrl[2], ctrl2;
0284     int need_clear = 0;
0285     int hour_reg;
0286     int err;
0287 
0288     err = rx8025_read_regs(client, RX8025_REG_CTRL1, 2, ctrl);
0289     if (err)
0290         goto out;
0291 
0292     /* Keep test bit zero ! */
0293     rx8025->ctrl1 = ctrl[0] & ~RX8025_BIT_CTRL1_TEST;
0294 
0295     if (ctrl[1] & (RX8025_BIT_CTRL2_DAFG | RX8025_BIT_CTRL2_WAFG)) {
0296         dev_warn(&client->dev, "Alarm was detected\n");
0297         need_clear = 1;
0298     }
0299 
0300     if (ctrl[1] & RX8025_BIT_CTRL2_CTFG)
0301         need_clear = 1;
0302 
0303     if (need_clear) {
0304         ctrl2 = ctrl[1];
0305         ctrl2 &= ~(RX8025_BIT_CTRL2_CTFG | RX8025_BIT_CTRL2_WAFG |
0306                RX8025_BIT_CTRL2_DAFG);
0307 
0308         err = rx8025_write_reg(client, RX8025_REG_CTRL2, ctrl2);
0309     }
0310 
0311     if (rx8025->model == model_rx_8035) {
0312         /* In RX-8035, 12/24 flag is in the hour register */
0313         hour_reg = rx8025_read_reg(client, RX8025_REG_HOUR);
0314         if (hour_reg < 0)
0315             return hour_reg;
0316         rx8025->is_24 = (hour_reg & RX8035_BIT_HOUR_1224);
0317     } else {
0318         rx8025->is_24 = (ctrl[1] & RX8025_BIT_CTRL1_1224);
0319     }
0320 out:
0321     return err;
0322 }
0323 
0324 /* Alarm support */
0325 static int rx8025_read_alarm(struct device *dev, struct rtc_wkalrm *t)
0326 {
0327     struct i2c_client *client = to_i2c_client(dev);
0328     struct rx8025_data *rx8025 = dev_get_drvdata(dev);
0329     u8 ald[2];
0330     int ctrl2, err;
0331 
0332     err = rx8025_read_regs(client, RX8025_REG_ALDMIN, 2, ald);
0333     if (err)
0334         return err;
0335 
0336     ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2);
0337     if (ctrl2 < 0)
0338         return ctrl2;
0339 
0340     dev_dbg(dev, "%s: read alarm 0x%02x 0x%02x ctrl2 %02x\n",
0341         __func__, ald[0], ald[1], ctrl2);
0342 
0343     /* Hardware alarms precision is 1 minute! */
0344     t->time.tm_sec = 0;
0345     t->time.tm_min = bcd2bin(ald[0] & 0x7f);
0346     if (rx8025->is_24)
0347         t->time.tm_hour = bcd2bin(ald[1] & 0x3f);
0348     else
0349         t->time.tm_hour = bcd2bin(ald[1] & 0x1f) % 12
0350             + (ald[1] & 0x20 ? 12 : 0);
0351 
0352     dev_dbg(dev, "%s: date: %ptRr\n", __func__, &t->time);
0353     t->enabled = !!(rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE);
0354     t->pending = (ctrl2 & RX8025_BIT_CTRL2_DAFG) && t->enabled;
0355 
0356     return err;
0357 }
0358 
0359 static int rx8025_set_alarm(struct device *dev, struct rtc_wkalrm *t)
0360 {
0361     struct i2c_client *client = to_i2c_client(dev);
0362     struct rx8025_data *rx8025 = dev_get_drvdata(dev);
0363     u8 ald[2];
0364     int err;
0365 
0366     ald[0] = bin2bcd(t->time.tm_min);
0367     if (rx8025->is_24)
0368         ald[1] = bin2bcd(t->time.tm_hour);
0369     else
0370         ald[1] = (t->time.tm_hour >= 12 ? 0x20 : 0)
0371             | bin2bcd((t->time.tm_hour + 11) % 12 + 1);
0372 
0373     dev_dbg(dev, "%s: write 0x%02x 0x%02x\n", __func__, ald[0], ald[1]);
0374 
0375     if (rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE) {
0376         rx8025->ctrl1 &= ~RX8025_BIT_CTRL1_DALE;
0377         err = rx8025_write_reg(client, RX8025_REG_CTRL1,
0378                        rx8025->ctrl1);
0379         if (err)
0380             return err;
0381     }
0382     err = rx8025_write_regs(client, RX8025_REG_ALDMIN, 2, ald);
0383     if (err)
0384         return err;
0385 
0386     if (t->enabled) {
0387         rx8025->ctrl1 |= RX8025_BIT_CTRL1_DALE;
0388         err = rx8025_write_reg(client, RX8025_REG_CTRL1,
0389                        rx8025->ctrl1);
0390         if (err)
0391             return err;
0392     }
0393 
0394     return 0;
0395 }
0396 
0397 static int rx8025_alarm_irq_enable(struct device *dev, unsigned int enabled)
0398 {
0399     struct i2c_client *client = to_i2c_client(dev);
0400     struct rx8025_data *rx8025 = dev_get_drvdata(dev);
0401     u8 ctrl1;
0402     int err;
0403 
0404     ctrl1 = rx8025->ctrl1;
0405     if (enabled)
0406         ctrl1 |= RX8025_BIT_CTRL1_DALE;
0407     else
0408         ctrl1 &= ~RX8025_BIT_CTRL1_DALE;
0409 
0410     if (ctrl1 != rx8025->ctrl1) {
0411         rx8025->ctrl1 = ctrl1;
0412         err = rx8025_write_reg(client, RX8025_REG_CTRL1,
0413                        rx8025->ctrl1);
0414         if (err)
0415             return err;
0416     }
0417     return 0;
0418 }
0419 
0420 /*
0421  * According to the RX8025 SA/NB application manual the frequency and
0422  * temperature characteristics can be approximated using the following
0423  * equation:
0424  *
0425  *   df = a * (ut - t)**2
0426  *
0427  *   df: Frequency deviation in any temperature
0428  *   a : Coefficient = (-35 +-5) * 10**-9
0429  *   ut: Ultimate temperature in degree = +25 +-5 degree
0430  *   t : Any temperature in degree
0431  */
0432 static int rx8025_read_offset(struct device *dev, long *offset)
0433 {
0434     struct i2c_client *client = to_i2c_client(dev);
0435     int digoff;
0436 
0437     digoff = rx8025_read_reg(client, RX8025_REG_DIGOFF);
0438     if (digoff < 0)
0439         return digoff;
0440 
0441     *offset = digoff >= 64 ? digoff - 128 : digoff;
0442     if (*offset > 0)
0443         (*offset)--;
0444     *offset *= RX8025_ADJ_RESOLUTION;
0445 
0446     return 0;
0447 }
0448 
0449 static int rx8025_set_offset(struct device *dev, long offset)
0450 {
0451     struct i2c_client *client = to_i2c_client(dev);
0452     u8 digoff;
0453 
0454     offset /= RX8025_ADJ_RESOLUTION;
0455     if (offset > RX8025_ADJ_DATA_MAX)
0456         offset = RX8025_ADJ_DATA_MAX;
0457     else if (offset < RX8025_ADJ_DATA_MIN)
0458         offset = RX8025_ADJ_DATA_MIN;
0459     else if (offset > 0)
0460         offset++;
0461     else if (offset < 0)
0462         offset += 128;
0463     digoff = offset;
0464 
0465     return rx8025_write_reg(client, RX8025_REG_DIGOFF, digoff);
0466 }
0467 
0468 static const struct rtc_class_ops rx8025_rtc_ops = {
0469     .read_time = rx8025_get_time,
0470     .set_time = rx8025_set_time,
0471     .read_alarm = rx8025_read_alarm,
0472     .set_alarm = rx8025_set_alarm,
0473     .alarm_irq_enable = rx8025_alarm_irq_enable,
0474     .read_offset = rx8025_read_offset,
0475     .set_offset = rx8025_set_offset,
0476 };
0477 
0478 static ssize_t rx8025_sysfs_show_clock_adjust(struct device *dev,
0479                           struct device_attribute *attr,
0480                           char *buf)
0481 {
0482     long adj;
0483     int err;
0484 
0485     dev_warn_once(dev, "clock_adjust_ppb is deprecated, use offset\n");
0486     err = rx8025_read_offset(dev, &adj);
0487     if (err)
0488         return err;
0489 
0490     return sprintf(buf, "%ld\n", -adj);
0491 }
0492 
0493 static ssize_t rx8025_sysfs_store_clock_adjust(struct device *dev,
0494                            struct device_attribute *attr,
0495                            const char *buf, size_t count)
0496 {
0497     long adj;
0498     int err;
0499 
0500     dev_warn_once(dev, "clock_adjust_ppb is deprecated, use offset\n");
0501     if (kstrtol(buf, 10, &adj) != 0)
0502         return -EINVAL;
0503 
0504     err = rx8025_set_offset(dev, -adj);
0505 
0506     return err ? err : count;
0507 }
0508 
0509 static DEVICE_ATTR(clock_adjust_ppb, S_IRUGO | S_IWUSR,
0510            rx8025_sysfs_show_clock_adjust,
0511            rx8025_sysfs_store_clock_adjust);
0512 
0513 static struct attribute *rx8025_attrs[] = {
0514     &dev_attr_clock_adjust_ppb.attr,
0515     NULL
0516 };
0517 
0518 static const struct attribute_group rx8025_attr_group = {
0519     .attrs  = rx8025_attrs,
0520 };
0521 
0522 static int rx8025_probe(struct i2c_client *client,
0523             const struct i2c_device_id *id)
0524 {
0525     struct i2c_adapter *adapter = client->adapter;
0526     struct rx8025_data *rx8025;
0527     int err = 0;
0528 
0529     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
0530                      | I2C_FUNC_SMBUS_I2C_BLOCK)) {
0531         dev_err(&adapter->dev,
0532             "doesn't support required functionality\n");
0533         return -EIO;
0534     }
0535 
0536     rx8025 = devm_kzalloc(&client->dev, sizeof(*rx8025), GFP_KERNEL);
0537     if (!rx8025)
0538         return -ENOMEM;
0539 
0540     i2c_set_clientdata(client, rx8025);
0541 
0542     if (id)
0543         rx8025->model = id->driver_data;
0544 
0545     err = rx8025_init_client(client);
0546     if (err)
0547         return err;
0548 
0549     rx8025->rtc = devm_rtc_allocate_device(&client->dev);
0550     if (IS_ERR(rx8025->rtc))
0551         return PTR_ERR(rx8025->rtc);
0552 
0553     rx8025->rtc->ops = &rx8025_rtc_ops;
0554     rx8025->rtc->range_min = RTC_TIMESTAMP_BEGIN_1900;
0555     rx8025->rtc->range_max = RTC_TIMESTAMP_END_2099;
0556 
0557     if (client->irq > 0) {
0558         dev_info(&client->dev, "IRQ %d supplied\n", client->irq);
0559         err = devm_request_threaded_irq(&client->dev, client->irq, NULL,
0560                         rx8025_handle_irq,
0561                         IRQF_ONESHOT,
0562                         "rx8025", client);
0563         if (err)
0564             clear_bit(RTC_FEATURE_ALARM, rx8025->rtc->features);
0565     }
0566 
0567     rx8025->rtc->max_user_freq = 1;
0568 
0569     set_bit(RTC_FEATURE_ALARM_RES_MINUTE, rx8025->rtc->features);
0570     clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, rx8025->rtc->features);
0571 
0572     err = rtc_add_group(rx8025->rtc, &rx8025_attr_group);
0573     if (err)
0574         return err;
0575 
0576     return devm_rtc_register_device(rx8025->rtc);
0577 }
0578 
0579 static struct i2c_driver rx8025_driver = {
0580     .driver = {
0581         .name = "rtc-rx8025",
0582     },
0583     .probe      = rx8025_probe,
0584     .id_table   = rx8025_id,
0585 };
0586 
0587 module_i2c_driver(rx8025_driver);
0588 
0589 MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
0590 MODULE_DESCRIPTION("RX-8025 SA/NB RTC driver");
0591 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!