Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 1 | /* |
| 2 | * Panasonic MN88473 DVB-T/T2/C demodulator driver |
| 3 | * |
| 4 | * Copyright (C) 2014 Antti Palosaari <crope@iki.fi> |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | */ |
| 16 | |
| 17 | #include "mn88473_priv.h" |
| 18 | |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 19 | static int mn88473_get_tune_settings(struct dvb_frontend *fe, |
| 20 | struct dvb_frontend_tune_settings *s) |
| 21 | { |
| 22 | s->min_delay_ms = 1000; |
| 23 | return 0; |
| 24 | } |
| 25 | |
| 26 | static int mn88473_set_frontend(struct dvb_frontend *fe) |
| 27 | { |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 28 | struct i2c_client *client = fe->demodulator_priv; |
| 29 | struct mn88473_dev *dev = i2c_get_clientdata(client); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 30 | struct dtv_frontend_properties *c = &fe->dtv_property_cache; |
Antti Palosaari | c00a6b9 | 2014-09-30 17:52:03 -0300 | [diff] [blame] | 31 | int ret, i; |
Antti Palosaari | df810e8 | 2014-09-30 23:19:30 -0300 | [diff] [blame] | 32 | u32 if_frequency; |
| 33 | u8 delivery_system_val, if_val[3], bw_val[7]; |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 34 | |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 35 | dev_dbg(&client->dev, |
| 36 | "delivery_system=%u modulation=%u frequency=%u bandwidth_hz=%u symbol_rate=%u inversion=%d stream_id=%d\n", |
| 37 | c->delivery_system, c->modulation, |
Antti Palosaari | c00a6b9 | 2014-09-30 17:52:03 -0300 | [diff] [blame] | 38 | c->frequency, c->bandwidth_hz, c->symbol_rate, |
| 39 | c->inversion, c->stream_id); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 40 | |
| 41 | if (!dev->warm) { |
| 42 | ret = -EAGAIN; |
| 43 | goto err; |
| 44 | } |
| 45 | |
Antti Palosaari | c00a6b9 | 2014-09-30 17:52:03 -0300 | [diff] [blame] | 46 | switch (c->delivery_system) { |
Antti Palosaari | 6ebbe22 | 2014-09-30 19:56:22 -0300 | [diff] [blame] | 47 | case SYS_DVBT: |
Antti Palosaari | df810e8 | 2014-09-30 23:19:30 -0300 | [diff] [blame] | 48 | delivery_system_val = 0x02; |
Antti Palosaari | 6ebbe22 | 2014-09-30 19:56:22 -0300 | [diff] [blame] | 49 | break; |
Antti Palosaari | c00a6b9 | 2014-09-30 17:52:03 -0300 | [diff] [blame] | 50 | case SYS_DVBT2: |
Antti Palosaari | df810e8 | 2014-09-30 23:19:30 -0300 | [diff] [blame] | 51 | delivery_system_val = 0x03; |
Antti Palosaari | c00a6b9 | 2014-09-30 17:52:03 -0300 | [diff] [blame] | 52 | break; |
| 53 | case SYS_DVBC_ANNEX_A: |
Antti Palosaari | df810e8 | 2014-09-30 23:19:30 -0300 | [diff] [blame] | 54 | delivery_system_val = 0x04; |
| 55 | break; |
| 56 | default: |
| 57 | ret = -EINVAL; |
| 58 | goto err; |
| 59 | } |
| 60 | |
| 61 | switch (c->delivery_system) { |
| 62 | case SYS_DVBT: |
| 63 | case SYS_DVBT2: |
| 64 | if (c->bandwidth_hz <= 6000000) { |
| 65 | /* IF 3570000 Hz, BW 6000000 Hz */ |
| 66 | memcpy(if_val, "\x24\x8e\x8a", 3); |
| 67 | memcpy(bw_val, "\xe9\x55\x55\x1c\x29\x1c\x29", 7); |
| 68 | } else if (c->bandwidth_hz <= 7000000) { |
| 69 | /* IF 4570000 Hz, BW 7000000 Hz */ |
| 70 | memcpy(if_val, "\x2e\xcb\xfb", 3); |
| 71 | memcpy(bw_val, "\xc8\x00\x00\x17\x0a\x17\x0a", 7); |
| 72 | } else if (c->bandwidth_hz <= 8000000) { |
| 73 | /* IF 4570000 Hz, BW 8000000 Hz */ |
| 74 | memcpy(if_val, "\x2e\xcb\xfb", 3); |
| 75 | memcpy(bw_val, "\xaf\x00\x00\x11\xec\x11\xec", 7); |
| 76 | } else { |
| 77 | ret = -EINVAL; |
| 78 | goto err; |
| 79 | } |
| 80 | break; |
| 81 | case SYS_DVBC_ANNEX_A: |
| 82 | /* IF 5070000 Hz, BW 8000000 Hz */ |
| 83 | memcpy(if_val, "\x33\xea\xb3", 3); |
| 84 | memcpy(bw_val, "\xaf\x00\x00\x11\xec\x11\xec", 7); |
Antti Palosaari | c00a6b9 | 2014-09-30 17:52:03 -0300 | [diff] [blame] | 85 | break; |
| 86 | default: |
| 87 | ret = -EINVAL; |
| 88 | goto err; |
| 89 | } |
| 90 | |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 91 | /* program tuner */ |
| 92 | if (fe->ops.tuner_ops.set_params) { |
| 93 | ret = fe->ops.tuner_ops.set_params(fe); |
| 94 | if (ret) |
| 95 | goto err; |
| 96 | } |
| 97 | |
| 98 | if (fe->ops.tuner_ops.get_if_frequency) { |
| 99 | ret = fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency); |
| 100 | if (ret) |
| 101 | goto err; |
| 102 | |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 103 | dev_dbg(&client->dev, "get_if_frequency=%d\n", if_frequency); |
Antti Palosaari | df810e8 | 2014-09-30 23:19:30 -0300 | [diff] [blame] | 104 | } else { |
| 105 | if_frequency = 0; |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 106 | } |
| 107 | |
Antti Palosaari | c00a6b9 | 2014-09-30 17:52:03 -0300 | [diff] [blame] | 108 | switch (if_frequency) { |
Antti Palosaari | df810e8 | 2014-09-30 23:19:30 -0300 | [diff] [blame] | 109 | case 3570000: |
Antti Palosaari | c00a6b9 | 2014-09-30 17:52:03 -0300 | [diff] [blame] | 110 | case 4570000: |
| 111 | case 5070000: |
| 112 | break; |
| 113 | default: |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 114 | dev_err(&client->dev, "IF frequency %d not supported\n", |
| 115 | if_frequency); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 116 | ret = -EINVAL; |
| 117 | goto err; |
| 118 | } |
| 119 | |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 120 | ret = regmap_write(dev->regmap[2], 0x05, 0x00); |
| 121 | ret = regmap_write(dev->regmap[2], 0xfb, 0x13); |
| 122 | ret = regmap_write(dev->regmap[2], 0xef, 0x13); |
| 123 | ret = regmap_write(dev->regmap[2], 0xf9, 0x13); |
| 124 | ret = regmap_write(dev->regmap[2], 0x00, 0x18); |
| 125 | ret = regmap_write(dev->regmap[2], 0x01, 0x01); |
| 126 | ret = regmap_write(dev->regmap[2], 0x02, 0x21); |
| 127 | ret = regmap_write(dev->regmap[2], 0x03, delivery_system_val); |
| 128 | ret = regmap_write(dev->regmap[2], 0x0b, 0x00); |
Antti Palosaari | c00a6b9 | 2014-09-30 17:52:03 -0300 | [diff] [blame] | 129 | |
Antti Palosaari | df810e8 | 2014-09-30 23:19:30 -0300 | [diff] [blame] | 130 | for (i = 0; i < sizeof(if_val); i++) { |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 131 | ret = regmap_write(dev->regmap[2], 0x10 + i, if_val[i]); |
Antti Palosaari | df810e8 | 2014-09-30 23:19:30 -0300 | [diff] [blame] | 132 | if (ret) |
| 133 | goto err; |
| 134 | } |
| 135 | |
| 136 | for (i = 0; i < sizeof(bw_val); i++) { |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 137 | ret = regmap_write(dev->regmap[2], 0x13 + i, bw_val[i]); |
Antti Palosaari | c00a6b9 | 2014-09-30 17:52:03 -0300 | [diff] [blame] | 138 | if (ret) |
| 139 | goto err; |
| 140 | } |
| 141 | |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 142 | ret = regmap_write(dev->regmap[2], 0x2d, 0x3b); |
| 143 | ret = regmap_write(dev->regmap[2], 0x2e, 0x00); |
| 144 | ret = regmap_write(dev->regmap[2], 0x56, 0x0d); |
| 145 | ret = regmap_write(dev->regmap[0], 0x01, 0xba); |
| 146 | ret = regmap_write(dev->regmap[0], 0x02, 0x13); |
| 147 | ret = regmap_write(dev->regmap[0], 0x03, 0x80); |
| 148 | ret = regmap_write(dev->regmap[0], 0x04, 0xba); |
| 149 | ret = regmap_write(dev->regmap[0], 0x05, 0x91); |
| 150 | ret = regmap_write(dev->regmap[0], 0x07, 0xe7); |
| 151 | ret = regmap_write(dev->regmap[0], 0x08, 0x28); |
| 152 | ret = regmap_write(dev->regmap[0], 0x0a, 0x1a); |
| 153 | ret = regmap_write(dev->regmap[0], 0x13, 0x1f); |
| 154 | ret = regmap_write(dev->regmap[0], 0x19, 0x03); |
| 155 | ret = regmap_write(dev->regmap[0], 0x1d, 0xb0); |
| 156 | ret = regmap_write(dev->regmap[0], 0x2a, 0x72); |
| 157 | ret = regmap_write(dev->regmap[0], 0x2d, 0x00); |
| 158 | ret = regmap_write(dev->regmap[0], 0x3c, 0x00); |
| 159 | ret = regmap_write(dev->regmap[0], 0x3f, 0xf8); |
| 160 | ret = regmap_write(dev->regmap[0], 0x40, 0xf4); |
| 161 | ret = regmap_write(dev->regmap[0], 0x41, 0x08); |
| 162 | ret = regmap_write(dev->regmap[0], 0xd2, 0x29); |
| 163 | ret = regmap_write(dev->regmap[0], 0xd4, 0x55); |
| 164 | ret = regmap_write(dev->regmap[1], 0x10, 0x10); |
| 165 | ret = regmap_write(dev->regmap[1], 0x11, 0xab); |
| 166 | ret = regmap_write(dev->regmap[1], 0x12, 0x0d); |
| 167 | ret = regmap_write(dev->regmap[1], 0x13, 0xae); |
| 168 | ret = regmap_write(dev->regmap[1], 0x14, 0x1d); |
| 169 | ret = regmap_write(dev->regmap[1], 0x15, 0x9d); |
| 170 | ret = regmap_write(dev->regmap[1], 0xbe, 0x08); |
| 171 | ret = regmap_write(dev->regmap[2], 0x09, 0x08); |
| 172 | ret = regmap_write(dev->regmap[2], 0x08, 0x1d); |
| 173 | ret = regmap_write(dev->regmap[0], 0xb2, 0x37); |
| 174 | ret = regmap_write(dev->regmap[0], 0xd7, 0x04); |
| 175 | ret = regmap_write(dev->regmap[2], 0x32, 0x80); |
| 176 | ret = regmap_write(dev->regmap[2], 0x36, 0x00); |
| 177 | ret = regmap_write(dev->regmap[2], 0xf8, 0x9f); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 178 | if (ret) |
| 179 | goto err; |
| 180 | |
| 181 | dev->delivery_system = c->delivery_system; |
| 182 | |
| 183 | return 0; |
| 184 | err: |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 185 | dev_dbg(&client->dev, "failed=%d\n", ret); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 186 | return ret; |
| 187 | } |
| 188 | |
| 189 | static int mn88473_read_status(struct dvb_frontend *fe, fe_status_t *status) |
| 190 | { |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 191 | struct i2c_client *client = fe->demodulator_priv; |
| 192 | struct mn88473_dev *dev = i2c_get_clientdata(client); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 193 | int ret; |
| 194 | |
| 195 | *status = 0; |
| 196 | |
| 197 | if (!dev->warm) { |
| 198 | ret = -EAGAIN; |
| 199 | goto err; |
| 200 | } |
| 201 | |
| 202 | *status = FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | |
| 203 | FE_HAS_SYNC | FE_HAS_LOCK; |
| 204 | |
| 205 | return 0; |
| 206 | err: |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 207 | dev_dbg(&client->dev, "failed=%d\n", ret); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 208 | return ret; |
| 209 | } |
| 210 | |
| 211 | static int mn88473_init(struct dvb_frontend *fe) |
| 212 | { |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 213 | struct i2c_client *client = fe->demodulator_priv; |
| 214 | struct mn88473_dev *dev = i2c_get_clientdata(client); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 215 | int ret, len, remaining; |
| 216 | const struct firmware *fw = NULL; |
| 217 | u8 *fw_file = MN88473_FIRMWARE; |
| 218 | |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 219 | dev_dbg(&client->dev, "\n"); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 220 | |
| 221 | if (dev->warm) |
| 222 | return 0; |
| 223 | |
| 224 | /* request the firmware, this will block and timeout */ |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 225 | ret = request_firmware(&fw, fw_file, &client->dev); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 226 | if (ret) { |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 227 | dev_err(&client->dev, "firmare file '%s' not found\n", fw_file); |
Markus Elfring | 7194782 | 2014-12-01 19:15:20 -0300 | [diff] [blame] | 228 | goto err_request_firmware; |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 229 | } |
| 230 | |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 231 | dev_info(&client->dev, "downloading firmware from file '%s'\n", |
| 232 | fw_file); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 233 | |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 234 | ret = regmap_write(dev->regmap[0], 0xf5, 0x03); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 235 | if (ret) |
| 236 | goto err; |
| 237 | |
| 238 | for (remaining = fw->size; remaining > 0; |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 239 | remaining -= (dev->i2c_wr_max - 1)) { |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 240 | len = remaining; |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 241 | if (len > (dev->i2c_wr_max - 1)) |
| 242 | len = (dev->i2c_wr_max - 1); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 243 | |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 244 | ret = regmap_bulk_write(dev->regmap[0], 0xf6, |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 245 | &fw->data[fw->size - remaining], len); |
| 246 | if (ret) { |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 247 | dev_err(&client->dev, "firmware download failed=%d\n", |
| 248 | ret); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 249 | goto err; |
| 250 | } |
| 251 | } |
| 252 | |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 253 | ret = regmap_write(dev->regmap[0], 0xf5, 0x00); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 254 | if (ret) |
| 255 | goto err; |
| 256 | |
| 257 | release_firmware(fw); |
| 258 | fw = NULL; |
| 259 | |
| 260 | /* warm state */ |
| 261 | dev->warm = true; |
| 262 | |
| 263 | return 0; |
Markus Elfring | 7194782 | 2014-12-01 19:15:20 -0300 | [diff] [blame] | 264 | |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 265 | err: |
Markus Elfring | b591138 | 2014-12-01 18:55:29 -0300 | [diff] [blame] | 266 | release_firmware(fw); |
Markus Elfring | 7194782 | 2014-12-01 19:15:20 -0300 | [diff] [blame] | 267 | err_request_firmware: |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 268 | dev_dbg(&client->dev, "failed=%d\n", ret); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 269 | return ret; |
| 270 | } |
| 271 | |
| 272 | static int mn88473_sleep(struct dvb_frontend *fe) |
| 273 | { |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 274 | struct i2c_client *client = fe->demodulator_priv; |
| 275 | struct mn88473_dev *dev = i2c_get_clientdata(client); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 276 | int ret; |
| 277 | |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 278 | dev_dbg(&client->dev, "\n"); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 279 | |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 280 | ret = regmap_write(dev->regmap[2], 0x05, 0x3e); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 281 | if (ret) |
| 282 | goto err; |
| 283 | |
| 284 | dev->delivery_system = SYS_UNDEFINED; |
| 285 | |
| 286 | return 0; |
| 287 | err: |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 288 | dev_dbg(&client->dev, "failed=%d\n", ret); |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 289 | return ret; |
| 290 | } |
| 291 | |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 292 | static struct dvb_frontend_ops mn88473_ops = { |
Antti Palosaari | 6ebbe22 | 2014-09-30 19:56:22 -0300 | [diff] [blame] | 293 | .delsys = {SYS_DVBT, SYS_DVBT2, SYS_DVBC_ANNEX_AC}, |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 294 | .info = { |
| 295 | .name = "Panasonic MN88473", |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 296 | .caps = FE_CAN_FEC_1_2 | |
| 297 | FE_CAN_FEC_2_3 | |
| 298 | FE_CAN_FEC_3_4 | |
| 299 | FE_CAN_FEC_5_6 | |
| 300 | FE_CAN_FEC_7_8 | |
| 301 | FE_CAN_FEC_AUTO | |
| 302 | FE_CAN_QPSK | |
| 303 | FE_CAN_QAM_16 | |
| 304 | FE_CAN_QAM_32 | |
| 305 | FE_CAN_QAM_64 | |
| 306 | FE_CAN_QAM_128 | |
| 307 | FE_CAN_QAM_256 | |
| 308 | FE_CAN_QAM_AUTO | |
| 309 | FE_CAN_TRANSMISSION_MODE_AUTO | |
| 310 | FE_CAN_GUARD_INTERVAL_AUTO | |
| 311 | FE_CAN_HIERARCHY_AUTO | |
| 312 | FE_CAN_MUTE_TS | |
| 313 | FE_CAN_2G_MODULATION | |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 314 | FE_CAN_MULTISTREAM |
| 315 | }, |
| 316 | |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 317 | .get_tune_settings = mn88473_get_tune_settings, |
| 318 | |
| 319 | .init = mn88473_init, |
| 320 | .sleep = mn88473_sleep, |
| 321 | |
| 322 | .set_frontend = mn88473_set_frontend, |
| 323 | |
| 324 | .read_status = mn88473_read_status, |
| 325 | }; |
| 326 | |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 327 | static int mn88473_probe(struct i2c_client *client, |
| 328 | const struct i2c_device_id *id) |
| 329 | { |
| 330 | struct mn88473_config *config = client->dev.platform_data; |
| 331 | struct mn88473_dev *dev; |
| 332 | int ret; |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 333 | unsigned int utmp; |
| 334 | static const struct regmap_config regmap_config = { |
| 335 | .reg_bits = 8, |
| 336 | .val_bits = 8, |
| 337 | }; |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 338 | |
| 339 | dev_dbg(&client->dev, "\n"); |
| 340 | |
| 341 | /* Caller really need to provide pointer for frontend we create. */ |
| 342 | if (config->fe == NULL) { |
| 343 | dev_err(&client->dev, "frontend pointer not defined\n"); |
| 344 | ret = -EINVAL; |
| 345 | goto err; |
| 346 | } |
| 347 | |
| 348 | dev = kzalloc(sizeof(*dev), GFP_KERNEL); |
| 349 | if (dev == NULL) { |
| 350 | ret = -ENOMEM; |
| 351 | goto err; |
| 352 | } |
| 353 | |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 354 | dev->i2c_wr_max = config->i2c_wr_max; |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 355 | dev->client[0] = client; |
| 356 | dev->regmap[0] = regmap_init_i2c(dev->client[0], ®map_config); |
| 357 | if (IS_ERR(dev->regmap[0])) { |
| 358 | ret = PTR_ERR(dev->regmap[0]); |
| 359 | goto err_kfree; |
| 360 | } |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 361 | |
| 362 | /* check demod answers to I2C */ |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 363 | ret = regmap_read(dev->regmap[0], 0x00, &utmp); |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 364 | if (ret) |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 365 | goto err_regmap_0_regmap_exit; |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 366 | |
| 367 | /* |
| 368 | * Chip has three I2C addresses for different register pages. Used |
| 369 | * addresses are 0x18, 0x1a and 0x1c. We register two dummy clients, |
| 370 | * 0x1a and 0x1c, in order to get own I2C client for each register page. |
| 371 | */ |
| 372 | dev->client[1] = i2c_new_dummy(client->adapter, 0x1a); |
| 373 | if (dev->client[1] == NULL) { |
| 374 | ret = -ENODEV; |
| 375 | dev_err(&client->dev, "I2C registration failed\n"); |
| 376 | if (ret) |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 377 | goto err_regmap_0_regmap_exit; |
| 378 | } |
| 379 | dev->regmap[1] = regmap_init_i2c(dev->client[1], ®map_config); |
| 380 | if (IS_ERR(dev->regmap[1])) { |
| 381 | ret = PTR_ERR(dev->regmap[1]); |
| 382 | goto err_client_1_i2c_unregister_device; |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 383 | } |
| 384 | i2c_set_clientdata(dev->client[1], dev); |
| 385 | |
| 386 | dev->client[2] = i2c_new_dummy(client->adapter, 0x1c); |
| 387 | if (dev->client[2] == NULL) { |
| 388 | ret = -ENODEV; |
| 389 | dev_err(&client->dev, "2nd I2C registration failed\n"); |
| 390 | if (ret) |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 391 | goto err_regmap_1_regmap_exit; |
| 392 | } |
| 393 | dev->regmap[2] = regmap_init_i2c(dev->client[2], ®map_config); |
| 394 | if (IS_ERR(dev->regmap[2])) { |
| 395 | ret = PTR_ERR(dev->regmap[2]); |
| 396 | goto err_client_2_i2c_unregister_device; |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 397 | } |
| 398 | i2c_set_clientdata(dev->client[2], dev); |
| 399 | |
| 400 | /* create dvb_frontend */ |
| 401 | memcpy(&dev->fe.ops, &mn88473_ops, sizeof(struct dvb_frontend_ops)); |
| 402 | dev->fe.demodulator_priv = client; |
| 403 | *config->fe = &dev->fe; |
| 404 | i2c_set_clientdata(client, dev); |
| 405 | |
| 406 | dev_info(&dev->client[0]->dev, "Panasonic MN88473 successfully attached\n"); |
| 407 | return 0; |
| 408 | |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 409 | err_client_2_i2c_unregister_device: |
| 410 | i2c_unregister_device(dev->client[2]); |
| 411 | err_regmap_1_regmap_exit: |
| 412 | regmap_exit(dev->regmap[1]); |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 413 | err_client_1_i2c_unregister_device: |
| 414 | i2c_unregister_device(dev->client[1]); |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 415 | err_regmap_0_regmap_exit: |
| 416 | regmap_exit(dev->regmap[0]); |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 417 | err_kfree: |
| 418 | kfree(dev); |
| 419 | err: |
| 420 | dev_dbg(&client->dev, "failed=%d\n", ret); |
| 421 | return ret; |
| 422 | } |
| 423 | |
| 424 | static int mn88473_remove(struct i2c_client *client) |
| 425 | { |
| 426 | struct mn88473_dev *dev = i2c_get_clientdata(client); |
| 427 | |
| 428 | dev_dbg(&client->dev, "\n"); |
| 429 | |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 430 | regmap_exit(dev->regmap[2]); |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 431 | i2c_unregister_device(dev->client[2]); |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 432 | |
| 433 | regmap_exit(dev->regmap[1]); |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 434 | i2c_unregister_device(dev->client[1]); |
| 435 | |
Antti Palosaari | 97de6e8 | 2014-10-03 00:28:18 -0300 | [diff] [blame] | 436 | regmap_exit(dev->regmap[0]); |
| 437 | |
Antti Palosaari | 01b4be1 | 2014-10-02 22:41:26 -0300 | [diff] [blame] | 438 | kfree(dev); |
| 439 | |
| 440 | return 0; |
| 441 | } |
| 442 | |
| 443 | static const struct i2c_device_id mn88473_id_table[] = { |
| 444 | {"mn88473", 0}, |
| 445 | {} |
| 446 | }; |
| 447 | MODULE_DEVICE_TABLE(i2c, mn88473_id_table); |
| 448 | |
| 449 | static struct i2c_driver mn88473_driver = { |
| 450 | .driver = { |
| 451 | .owner = THIS_MODULE, |
| 452 | .name = "mn88473", |
| 453 | }, |
| 454 | .probe = mn88473_probe, |
| 455 | .remove = mn88473_remove, |
| 456 | .id_table = mn88473_id_table, |
| 457 | }; |
| 458 | |
| 459 | module_i2c_driver(mn88473_driver); |
| 460 | |
Antti Palosaari | dadb5bb | 2014-09-30 01:01:47 -0300 | [diff] [blame] | 461 | MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); |
| 462 | MODULE_DESCRIPTION("Panasonic MN88473 DVB-T/T2/C demodulator driver"); |
| 463 | MODULE_LICENSE("GPL"); |
| 464 | MODULE_FIRMWARE(MN88473_FIRMWARE); |