af9035.c 38 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560
  1. /*
  2. * Afatech AF9035 DVB USB driver
  3. *
  4. * Copyright (C) 2009 Antti Palosaari <crope@iki.fi>
  5. * Copyright (C) 2012 Antti Palosaari <crope@iki.fi>
  6. *
  7. * This program is free software; you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License as published by
  9. * the Free Software Foundation; either version 2 of the License, or
  10. * (at your option) any later version.
  11. *
  12. * This program is distributed in the hope that it will be useful,
  13. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15. * GNU General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU General Public License along
  18. * with this program; if not, write to the Free Software Foundation, Inc.,
  19. * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20. */
  21. #include "af9035.h"
  22. /* Max transfer size done by I2C transfer functions */
  23. #define MAX_XFER_SIZE 64
  24. DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  25. static u16 af9035_checksum(const u8 *buf, size_t len)
  26. {
  27. size_t i;
  28. u16 checksum = 0;
  29. for (i = 1; i < len; i++) {
  30. if (i % 2)
  31. checksum += buf[i] << 8;
  32. else
  33. checksum += buf[i];
  34. }
  35. checksum = ~checksum;
  36. return checksum;
  37. }
  38. static int af9035_ctrl_msg(struct dvb_usb_device *d, struct usb_req *req)
  39. {
  40. #define REQ_HDR_LEN 4 /* send header size */
  41. #define ACK_HDR_LEN 3 /* rece header size */
  42. #define CHECKSUM_LEN 2
  43. #define USB_TIMEOUT 2000
  44. struct state *state = d_to_priv(d);
  45. int ret, wlen, rlen;
  46. u16 checksum, tmp_checksum;
  47. mutex_lock(&d->usb_mutex);
  48. /* buffer overflow check */
  49. if (req->wlen > (BUF_LEN - REQ_HDR_LEN - CHECKSUM_LEN) ||
  50. req->rlen > (BUF_LEN - ACK_HDR_LEN - CHECKSUM_LEN)) {
  51. dev_err(&d->udev->dev, "%s: too much data wlen=%d rlen=%d\n",
  52. KBUILD_MODNAME, req->wlen, req->rlen);
  53. ret = -EINVAL;
  54. goto exit;
  55. }
  56. state->buf[0] = REQ_HDR_LEN + req->wlen + CHECKSUM_LEN - 1;
  57. state->buf[1] = req->mbox;
  58. state->buf[2] = req->cmd;
  59. state->buf[3] = state->seq++;
  60. memcpy(&state->buf[REQ_HDR_LEN], req->wbuf, req->wlen);
  61. wlen = REQ_HDR_LEN + req->wlen + CHECKSUM_LEN;
  62. rlen = ACK_HDR_LEN + req->rlen + CHECKSUM_LEN;
  63. /* calc and add checksum */
  64. checksum = af9035_checksum(state->buf, state->buf[0] - 1);
  65. state->buf[state->buf[0] - 1] = (checksum >> 8);
  66. state->buf[state->buf[0] - 0] = (checksum & 0xff);
  67. /* no ack for these packets */
  68. if (req->cmd == CMD_FW_DL)
  69. rlen = 0;
  70. ret = dvb_usbv2_generic_rw_locked(d,
  71. state->buf, wlen, state->buf, rlen);
  72. if (ret)
  73. goto exit;
  74. /* no ack for those packets */
  75. if (req->cmd == CMD_FW_DL)
  76. goto exit;
  77. /* verify checksum */
  78. checksum = af9035_checksum(state->buf, rlen - 2);
  79. tmp_checksum = (state->buf[rlen - 2] << 8) | state->buf[rlen - 1];
  80. if (tmp_checksum != checksum) {
  81. dev_err(&d->udev->dev,
  82. "%s: command=%02x checksum mismatch (%04x != %04x)\n",
  83. KBUILD_MODNAME, req->cmd, tmp_checksum,
  84. checksum);
  85. ret = -EIO;
  86. goto exit;
  87. }
  88. /* check status */
  89. if (state->buf[2]) {
  90. /* fw returns status 1 when IR code was not received */
  91. if (req->cmd == CMD_IR_GET || state->buf[2] == 1) {
  92. ret = 1;
  93. goto exit;
  94. }
  95. dev_dbg(&d->udev->dev, "%s: command=%02x failed fw error=%d\n",
  96. __func__, req->cmd, state->buf[2]);
  97. ret = -EIO;
  98. goto exit;
  99. }
  100. /* read request, copy returned data to return buf */
  101. if (req->rlen)
  102. memcpy(req->rbuf, &state->buf[ACK_HDR_LEN], req->rlen);
  103. exit:
  104. mutex_unlock(&d->usb_mutex);
  105. if (ret < 0)
  106. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  107. return ret;
  108. }
  109. /* write multiple registers */
  110. static int af9035_wr_regs(struct dvb_usb_device *d, u32 reg, u8 *val, int len)
  111. {
  112. u8 wbuf[MAX_XFER_SIZE];
  113. u8 mbox = (reg >> 16) & 0xff;
  114. struct usb_req req = { CMD_MEM_WR, mbox, sizeof(wbuf), wbuf, 0, NULL };
  115. if (6 + len > sizeof(wbuf)) {
  116. dev_warn(&d->udev->dev, "%s: i2c wr: len=%d is too big!\n",
  117. KBUILD_MODNAME, len);
  118. return -EOPNOTSUPP;
  119. }
  120. wbuf[0] = len;
  121. wbuf[1] = 2;
  122. wbuf[2] = 0;
  123. wbuf[3] = 0;
  124. wbuf[4] = (reg >> 8) & 0xff;
  125. wbuf[5] = (reg >> 0) & 0xff;
  126. memcpy(&wbuf[6], val, len);
  127. return af9035_ctrl_msg(d, &req);
  128. }
  129. /* read multiple registers */
  130. static int af9035_rd_regs(struct dvb_usb_device *d, u32 reg, u8 *val, int len)
  131. {
  132. u8 wbuf[] = { len, 2, 0, 0, (reg >> 8) & 0xff, reg & 0xff };
  133. u8 mbox = (reg >> 16) & 0xff;
  134. struct usb_req req = { CMD_MEM_RD, mbox, sizeof(wbuf), wbuf, len, val };
  135. return af9035_ctrl_msg(d, &req);
  136. }
  137. /* write single register */
  138. static int af9035_wr_reg(struct dvb_usb_device *d, u32 reg, u8 val)
  139. {
  140. return af9035_wr_regs(d, reg, &val, 1);
  141. }
  142. /* read single register */
  143. static int af9035_rd_reg(struct dvb_usb_device *d, u32 reg, u8 *val)
  144. {
  145. return af9035_rd_regs(d, reg, val, 1);
  146. }
  147. /* write single register with mask */
  148. static int af9035_wr_reg_mask(struct dvb_usb_device *d, u32 reg, u8 val,
  149. u8 mask)
  150. {
  151. int ret;
  152. u8 tmp;
  153. /* no need for read if whole reg is written */
  154. if (mask != 0xff) {
  155. ret = af9035_rd_regs(d, reg, &tmp, 1);
  156. if (ret)
  157. return ret;
  158. val &= mask;
  159. tmp &= ~mask;
  160. val |= tmp;
  161. }
  162. return af9035_wr_regs(d, reg, &val, 1);
  163. }
  164. static int af9035_i2c_master_xfer(struct i2c_adapter *adap,
  165. struct i2c_msg msg[], int num)
  166. {
  167. struct dvb_usb_device *d = i2c_get_adapdata(adap);
  168. struct state *state = d_to_priv(d);
  169. int ret;
  170. if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
  171. return -EAGAIN;
  172. /*
  173. * I2C sub header is 5 bytes long. Meaning of those bytes are:
  174. * 0: data len
  175. * 1: I2C addr << 1
  176. * 2: reg addr len
  177. * byte 3 and 4 can be used as reg addr
  178. * 3: reg addr MSB
  179. * used when reg addr len is set to 2
  180. * 4: reg addr LSB
  181. * used when reg addr len is set to 1 or 2
  182. *
  183. * For the simplify we do not use register addr at all.
  184. * NOTE: As a firmware knows tuner type there is very small possibility
  185. * there could be some tuner I2C hacks done by firmware and this may
  186. * lead problems if firmware expects those bytes are used.
  187. */
  188. if (num == 2 && !(msg[0].flags & I2C_M_RD) &&
  189. (msg[1].flags & I2C_M_RD)) {
  190. if (msg[0].len > 40 || msg[1].len > 40) {
  191. /* TODO: correct limits > 40 */
  192. ret = -EOPNOTSUPP;
  193. } else if ((msg[0].addr == state->af9033_config[0].i2c_addr) ||
  194. (msg[0].addr == state->af9033_config[1].i2c_addr)) {
  195. /* demod access via firmware interface */
  196. u32 reg = msg[0].buf[0] << 16 | msg[0].buf[1] << 8 |
  197. msg[0].buf[2];
  198. if (msg[0].addr == state->af9033_config[1].i2c_addr)
  199. reg |= 0x100000;
  200. ret = af9035_rd_regs(d, reg, &msg[1].buf[0],
  201. msg[1].len);
  202. } else {
  203. /* I2C */
  204. u8 buf[MAX_XFER_SIZE];
  205. struct usb_req req = { CMD_I2C_RD, 0, sizeof(buf),
  206. buf, msg[1].len, msg[1].buf };
  207. if (5 + msg[0].len > sizeof(buf)) {
  208. dev_warn(&d->udev->dev,
  209. "%s: i2c xfer: len=%d is too big!\n",
  210. KBUILD_MODNAME, msg[0].len);
  211. return -EOPNOTSUPP;
  212. }
  213. req.mbox |= ((msg[0].addr & 0x80) >> 3);
  214. buf[0] = msg[1].len;
  215. buf[1] = msg[0].addr << 1;
  216. buf[2] = 0x00; /* reg addr len */
  217. buf[3] = 0x00; /* reg addr MSB */
  218. buf[4] = 0x00; /* reg addr LSB */
  219. memcpy(&buf[5], msg[0].buf, msg[0].len);
  220. ret = af9035_ctrl_msg(d, &req);
  221. }
  222. } else if (num == 1 && !(msg[0].flags & I2C_M_RD)) {
  223. if (msg[0].len > 40) {
  224. /* TODO: correct limits > 40 */
  225. ret = -EOPNOTSUPP;
  226. } else if ((msg[0].addr == state->af9033_config[0].i2c_addr) ||
  227. (msg[0].addr == state->af9033_config[1].i2c_addr)) {
  228. /* demod access via firmware interface */
  229. u32 reg = msg[0].buf[0] << 16 | msg[0].buf[1] << 8 |
  230. msg[0].buf[2];
  231. if (msg[0].addr == state->af9033_config[1].i2c_addr)
  232. reg |= 0x100000;
  233. ret = af9035_wr_regs(d, reg, &msg[0].buf[3],
  234. msg[0].len - 3);
  235. } else {
  236. /* I2C */
  237. u8 buf[MAX_XFER_SIZE];
  238. struct usb_req req = { CMD_I2C_WR, 0, sizeof(buf), buf,
  239. 0, NULL };
  240. if (5 + msg[0].len > sizeof(buf)) {
  241. dev_warn(&d->udev->dev,
  242. "%s: i2c xfer: len=%d is too big!\n",
  243. KBUILD_MODNAME, msg[0].len);
  244. return -EOPNOTSUPP;
  245. }
  246. req.mbox |= ((msg[0].addr & 0x80) >> 3);
  247. buf[0] = msg[0].len;
  248. buf[1] = msg[0].addr << 1;
  249. buf[2] = 0x00; /* reg addr len */
  250. buf[3] = 0x00; /* reg addr MSB */
  251. buf[4] = 0x00; /* reg addr LSB */
  252. memcpy(&buf[5], msg[0].buf, msg[0].len);
  253. ret = af9035_ctrl_msg(d, &req);
  254. }
  255. } else if (num == 1 && (msg[0].flags & I2C_M_RD)) {
  256. if (msg[0].len > 40) {
  257. /* TODO: correct limits > 40 */
  258. ret = -EOPNOTSUPP;
  259. } else {
  260. /* I2C */
  261. u8 buf[5];
  262. struct usb_req req = { CMD_I2C_RD, 0, sizeof(buf),
  263. buf, msg[0].len, msg[0].buf };
  264. req.mbox |= ((msg[0].addr & 0x80) >> 3);
  265. buf[0] = msg[0].len;
  266. buf[1] = msg[0].addr << 1;
  267. buf[2] = 0x00; /* reg addr len */
  268. buf[3] = 0x00; /* reg addr MSB */
  269. buf[4] = 0x00; /* reg addr LSB */
  270. ret = af9035_ctrl_msg(d, &req);
  271. }
  272. } else {
  273. /*
  274. * We support only three kind of I2C transactions:
  275. * 1) 1 x read + 1 x write (repeated start)
  276. * 2) 1 x write
  277. * 3) 1 x read
  278. */
  279. ret = -EOPNOTSUPP;
  280. }
  281. mutex_unlock(&d->i2c_mutex);
  282. if (ret < 0)
  283. return ret;
  284. else
  285. return num;
  286. }
  287. static u32 af9035_i2c_functionality(struct i2c_adapter *adapter)
  288. {
  289. return I2C_FUNC_I2C;
  290. }
  291. static struct i2c_algorithm af9035_i2c_algo = {
  292. .master_xfer = af9035_i2c_master_xfer,
  293. .functionality = af9035_i2c_functionality,
  294. };
  295. static int af9035_identify_state(struct dvb_usb_device *d, const char **name)
  296. {
  297. struct state *state = d_to_priv(d);
  298. int ret;
  299. u8 wbuf[1] = { 1 };
  300. u8 rbuf[4];
  301. struct usb_req req = { CMD_FW_QUERYINFO, 0, sizeof(wbuf), wbuf,
  302. sizeof(rbuf), rbuf };
  303. ret = af9035_rd_regs(d, 0x1222, rbuf, 3);
  304. if (ret < 0)
  305. goto err;
  306. state->chip_version = rbuf[0];
  307. state->chip_type = rbuf[2] << 8 | rbuf[1] << 0;
  308. ret = af9035_rd_reg(d, 0x384f, &state->prechip_version);
  309. if (ret < 0)
  310. goto err;
  311. dev_info(&d->udev->dev,
  312. "%s: prechip_version=%02x chip_version=%02x chip_type=%04x\n",
  313. KBUILD_MODNAME, state->prechip_version,
  314. state->chip_version, state->chip_type);
  315. if (state->chip_type == 0x9135) {
  316. if (state->chip_version == 0x02)
  317. *name = AF9035_FIRMWARE_IT9135_V2;
  318. else
  319. *name = AF9035_FIRMWARE_IT9135_V1;
  320. state->eeprom_addr = EEPROM_BASE_IT9135;
  321. } else {
  322. *name = AF9035_FIRMWARE_AF9035;
  323. state->eeprom_addr = EEPROM_BASE_AF9035;
  324. }
  325. ret = af9035_ctrl_msg(d, &req);
  326. if (ret < 0)
  327. goto err;
  328. dev_dbg(&d->udev->dev, "%s: reply=%*ph\n", __func__, 4, rbuf);
  329. if (rbuf[0] || rbuf[1] || rbuf[2] || rbuf[3])
  330. ret = WARM;
  331. else
  332. ret = COLD;
  333. return ret;
  334. err:
  335. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  336. return ret;
  337. }
  338. static int af9035_download_firmware_old(struct dvb_usb_device *d,
  339. const struct firmware *fw)
  340. {
  341. int ret, i, j, len;
  342. u8 wbuf[1];
  343. struct usb_req req = { 0, 0, 0, NULL, 0, NULL };
  344. struct usb_req req_fw_dl = { CMD_FW_DL, 0, 0, wbuf, 0, NULL };
  345. u8 hdr_core;
  346. u16 hdr_addr, hdr_data_len, hdr_checksum;
  347. #define MAX_DATA 58
  348. #define HDR_SIZE 7
  349. /*
  350. * Thanks to Daniel Glöckner <daniel-gl@gmx.net> about that info!
  351. *
  352. * byte 0: MCS 51 core
  353. * There are two inside the AF9035 (1=Link and 2=OFDM) with separate
  354. * address spaces
  355. * byte 1-2: Big endian destination address
  356. * byte 3-4: Big endian number of data bytes following the header
  357. * byte 5-6: Big endian header checksum, apparently ignored by the chip
  358. * Calculated as ~(h[0]*256+h[1]+h[2]*256+h[3]+h[4]*256)
  359. */
  360. for (i = fw->size; i > HDR_SIZE;) {
  361. hdr_core = fw->data[fw->size - i + 0];
  362. hdr_addr = fw->data[fw->size - i + 1] << 8;
  363. hdr_addr |= fw->data[fw->size - i + 2] << 0;
  364. hdr_data_len = fw->data[fw->size - i + 3] << 8;
  365. hdr_data_len |= fw->data[fw->size - i + 4] << 0;
  366. hdr_checksum = fw->data[fw->size - i + 5] << 8;
  367. hdr_checksum |= fw->data[fw->size - i + 6] << 0;
  368. dev_dbg(&d->udev->dev,
  369. "%s: core=%d addr=%04x data_len=%d checksum=%04x\n",
  370. __func__, hdr_core, hdr_addr, hdr_data_len,
  371. hdr_checksum);
  372. if (((hdr_core != 1) && (hdr_core != 2)) ||
  373. (hdr_data_len > i)) {
  374. dev_dbg(&d->udev->dev, "%s: bad firmware\n", __func__);
  375. break;
  376. }
  377. /* download begin packet */
  378. req.cmd = CMD_FW_DL_BEGIN;
  379. ret = af9035_ctrl_msg(d, &req);
  380. if (ret < 0)
  381. goto err;
  382. /* download firmware packet(s) */
  383. for (j = HDR_SIZE + hdr_data_len; j > 0; j -= MAX_DATA) {
  384. len = j;
  385. if (len > MAX_DATA)
  386. len = MAX_DATA;
  387. req_fw_dl.wlen = len;
  388. req_fw_dl.wbuf = (u8 *) &fw->data[fw->size - i +
  389. HDR_SIZE + hdr_data_len - j];
  390. ret = af9035_ctrl_msg(d, &req_fw_dl);
  391. if (ret < 0)
  392. goto err;
  393. }
  394. /* download end packet */
  395. req.cmd = CMD_FW_DL_END;
  396. ret = af9035_ctrl_msg(d, &req);
  397. if (ret < 0)
  398. goto err;
  399. i -= hdr_data_len + HDR_SIZE;
  400. dev_dbg(&d->udev->dev, "%s: data uploaded=%zu\n",
  401. __func__, fw->size - i);
  402. }
  403. /* print warn if firmware is bad, continue and see what happens */
  404. if (i)
  405. dev_warn(&d->udev->dev, "%s: bad firmware\n", KBUILD_MODNAME);
  406. return 0;
  407. err:
  408. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  409. return ret;
  410. }
  411. static int af9035_download_firmware_new(struct dvb_usb_device *d,
  412. const struct firmware *fw)
  413. {
  414. int ret, i, i_prev;
  415. struct usb_req req_fw_dl = { CMD_FW_SCATTER_WR, 0, 0, NULL, 0, NULL };
  416. #define HDR_SIZE 7
  417. /*
  418. * There seems to be following firmware header. Meaning of bytes 0-3
  419. * is unknown.
  420. *
  421. * 0: 3
  422. * 1: 0, 1
  423. * 2: 0
  424. * 3: 1, 2, 3
  425. * 4: addr MSB
  426. * 5: addr LSB
  427. * 6: count of data bytes ?
  428. */
  429. for (i = HDR_SIZE, i_prev = 0; i <= fw->size; i++) {
  430. if (i == fw->size ||
  431. (fw->data[i + 0] == 0x03 &&
  432. (fw->data[i + 1] == 0x00 ||
  433. fw->data[i + 1] == 0x01) &&
  434. fw->data[i + 2] == 0x00)) {
  435. req_fw_dl.wlen = i - i_prev;
  436. req_fw_dl.wbuf = (u8 *) &fw->data[i_prev];
  437. i_prev = i;
  438. ret = af9035_ctrl_msg(d, &req_fw_dl);
  439. if (ret < 0)
  440. goto err;
  441. dev_dbg(&d->udev->dev, "%s: data uploaded=%d\n",
  442. __func__, i);
  443. }
  444. }
  445. return 0;
  446. err:
  447. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  448. return ret;
  449. }
  450. static int af9035_download_firmware(struct dvb_usb_device *d,
  451. const struct firmware *fw)
  452. {
  453. struct state *state = d_to_priv(d);
  454. int ret;
  455. u8 wbuf[1];
  456. u8 rbuf[4];
  457. u8 tmp;
  458. struct usb_req req = { 0, 0, 0, NULL, 0, NULL };
  459. struct usb_req req_fw_ver = { CMD_FW_QUERYINFO, 0, 1, wbuf, 4, rbuf };
  460. dev_dbg(&d->udev->dev, "%s:\n", __func__);
  461. /*
  462. * In case of dual tuner configuration we need to do some extra
  463. * initialization in order to download firmware to slave demod too,
  464. * which is done by master demod.
  465. * Master feeds also clock and controls power via GPIO.
  466. */
  467. ret = af9035_rd_reg(d, state->eeprom_addr + EEPROM_TS_MODE, &tmp);
  468. if (ret < 0)
  469. goto err;
  470. if (tmp == 1 || tmp == 3) {
  471. /* configure gpioh1, reset & power slave demod */
  472. ret = af9035_wr_reg_mask(d, 0x00d8b0, 0x01, 0x01);
  473. if (ret < 0)
  474. goto err;
  475. ret = af9035_wr_reg_mask(d, 0x00d8b1, 0x01, 0x01);
  476. if (ret < 0)
  477. goto err;
  478. ret = af9035_wr_reg_mask(d, 0x00d8af, 0x00, 0x01);
  479. if (ret < 0)
  480. goto err;
  481. usleep_range(10000, 50000);
  482. ret = af9035_wr_reg_mask(d, 0x00d8af, 0x01, 0x01);
  483. if (ret < 0)
  484. goto err;
  485. /* tell the slave I2C address */
  486. ret = af9035_rd_reg(d,
  487. state->eeprom_addr + EEPROM_2ND_DEMOD_ADDR,
  488. &tmp);
  489. if (ret < 0)
  490. goto err;
  491. if (state->chip_type == 0x9135) {
  492. ret = af9035_wr_reg(d, 0x004bfb, tmp);
  493. if (ret < 0)
  494. goto err;
  495. } else {
  496. ret = af9035_wr_reg(d, 0x00417f, tmp);
  497. if (ret < 0)
  498. goto err;
  499. /* enable clock out */
  500. ret = af9035_wr_reg_mask(d, 0x00d81a, 0x01, 0x01);
  501. if (ret < 0)
  502. goto err;
  503. }
  504. }
  505. if (fw->data[0] == 0x01)
  506. ret = af9035_download_firmware_old(d, fw);
  507. else
  508. ret = af9035_download_firmware_new(d, fw);
  509. if (ret < 0)
  510. goto err;
  511. /* firmware loaded, request boot */
  512. req.cmd = CMD_FW_BOOT;
  513. ret = af9035_ctrl_msg(d, &req);
  514. if (ret < 0)
  515. goto err;
  516. /* ensure firmware starts */
  517. wbuf[0] = 1;
  518. ret = af9035_ctrl_msg(d, &req_fw_ver);
  519. if (ret < 0)
  520. goto err;
  521. if (!(rbuf[0] || rbuf[1] || rbuf[2] || rbuf[3])) {
  522. dev_err(&d->udev->dev, "%s: firmware did not run\n",
  523. KBUILD_MODNAME);
  524. ret = -ENODEV;
  525. goto err;
  526. }
  527. dev_info(&d->udev->dev, "%s: firmware version=%d.%d.%d.%d",
  528. KBUILD_MODNAME, rbuf[0], rbuf[1], rbuf[2], rbuf[3]);
  529. return 0;
  530. err:
  531. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  532. return ret;
  533. }
  534. static int af9035_read_config(struct dvb_usb_device *d)
  535. {
  536. struct state *state = d_to_priv(d);
  537. int ret, i;
  538. u8 tmp;
  539. u16 tmp16, addr;
  540. /* demod I2C "address" */
  541. state->af9033_config[0].i2c_addr = 0x38;
  542. state->af9033_config[0].adc_multiplier = AF9033_ADC_MULTIPLIER_2X;
  543. state->af9033_config[1].adc_multiplier = AF9033_ADC_MULTIPLIER_2X;
  544. state->af9033_config[0].ts_mode = AF9033_TS_MODE_USB;
  545. state->af9033_config[1].ts_mode = AF9033_TS_MODE_SERIAL;
  546. /* eeprom memory mapped location */
  547. if (state->chip_type == 0x9135) {
  548. if (state->chip_version == 0x02) {
  549. state->af9033_config[0].tuner = AF9033_TUNER_IT9135_60;
  550. state->af9033_config[1].tuner = AF9033_TUNER_IT9135_60;
  551. tmp16 = 0x00461d;
  552. } else {
  553. state->af9033_config[0].tuner = AF9033_TUNER_IT9135_38;
  554. state->af9033_config[1].tuner = AF9033_TUNER_IT9135_38;
  555. tmp16 = 0x00461b;
  556. }
  557. /* check if eeprom exists */
  558. ret = af9035_rd_reg(d, tmp16, &tmp);
  559. if (ret < 0)
  560. goto err;
  561. if (tmp == 0x00) {
  562. dev_dbg(&d->udev->dev, "%s: no eeprom\n", __func__);
  563. goto skip_eeprom;
  564. }
  565. }
  566. /* check if there is dual tuners */
  567. ret = af9035_rd_reg(d, state->eeprom_addr + EEPROM_TS_MODE, &tmp);
  568. if (ret < 0)
  569. goto err;
  570. if (tmp == 1 || tmp == 3)
  571. state->dual_mode = true;
  572. dev_dbg(&d->udev->dev, "%s: ts mode=%d dual mode=%d\n", __func__,
  573. tmp, state->dual_mode);
  574. if (state->dual_mode) {
  575. /* read 2nd demodulator I2C address */
  576. ret = af9035_rd_reg(d,
  577. state->eeprom_addr + EEPROM_2ND_DEMOD_ADDR,
  578. &tmp);
  579. if (ret < 0)
  580. goto err;
  581. state->af9033_config[1].i2c_addr = tmp;
  582. dev_dbg(&d->udev->dev, "%s: 2nd demod I2C addr=%02x\n",
  583. __func__, tmp);
  584. }
  585. addr = state->eeprom_addr;
  586. for (i = 0; i < state->dual_mode + 1; i++) {
  587. /* tuner */
  588. ret = af9035_rd_reg(d, addr + EEPROM_1_TUNER_ID, &tmp);
  589. if (ret < 0)
  590. goto err;
  591. if (tmp == 0x00)
  592. dev_dbg(&d->udev->dev,
  593. "%s: [%d]tuner not set, using default\n",
  594. __func__, i);
  595. else
  596. state->af9033_config[i].tuner = tmp;
  597. dev_dbg(&d->udev->dev, "%s: [%d]tuner=%02x\n",
  598. __func__, i, state->af9033_config[i].tuner);
  599. switch (state->af9033_config[i].tuner) {
  600. case AF9033_TUNER_TUA9001:
  601. case AF9033_TUNER_FC0011:
  602. case AF9033_TUNER_MXL5007T:
  603. case AF9033_TUNER_TDA18218:
  604. case AF9033_TUNER_FC2580:
  605. case AF9033_TUNER_FC0012:
  606. state->af9033_config[i].spec_inv = 1;
  607. break;
  608. case AF9033_TUNER_IT9135_38:
  609. case AF9033_TUNER_IT9135_51:
  610. case AF9033_TUNER_IT9135_52:
  611. case AF9033_TUNER_IT9135_60:
  612. case AF9033_TUNER_IT9135_61:
  613. case AF9033_TUNER_IT9135_62:
  614. break;
  615. default:
  616. dev_warn(&d->udev->dev,
  617. "%s: tuner id=%02x not supported, please report!",
  618. KBUILD_MODNAME, tmp);
  619. }
  620. /* disable dual mode if driver does not support it */
  621. if (i == 1)
  622. switch (state->af9033_config[i].tuner) {
  623. case AF9033_TUNER_FC0012:
  624. case AF9033_TUNER_IT9135_38:
  625. case AF9033_TUNER_IT9135_51:
  626. case AF9033_TUNER_IT9135_52:
  627. case AF9033_TUNER_IT9135_60:
  628. case AF9033_TUNER_IT9135_61:
  629. case AF9033_TUNER_IT9135_62:
  630. case AF9033_TUNER_MXL5007T:
  631. break;
  632. default:
  633. state->dual_mode = false;
  634. dev_info(&d->udev->dev,
  635. "%s: driver does not support 2nd tuner and will disable it",
  636. KBUILD_MODNAME);
  637. }
  638. /* tuner IF frequency */
  639. ret = af9035_rd_reg(d, addr + EEPROM_1_IF_L, &tmp);
  640. if (ret < 0)
  641. goto err;
  642. tmp16 = tmp;
  643. ret = af9035_rd_reg(d, addr + EEPROM_1_IF_H, &tmp);
  644. if (ret < 0)
  645. goto err;
  646. tmp16 |= tmp << 8;
  647. dev_dbg(&d->udev->dev, "%s: [%d]IF=%d\n", __func__, i, tmp16);
  648. addr += 0x10; /* shift for the 2nd tuner params */
  649. }
  650. skip_eeprom:
  651. /* get demod clock */
  652. ret = af9035_rd_reg(d, 0x00d800, &tmp);
  653. if (ret < 0)
  654. goto err;
  655. tmp = (tmp >> 0) & 0x0f;
  656. for (i = 0; i < ARRAY_SIZE(state->af9033_config); i++) {
  657. if (state->chip_type == 0x9135)
  658. state->af9033_config[i].clock = clock_lut_it9135[tmp];
  659. else
  660. state->af9033_config[i].clock = clock_lut_af9035[tmp];
  661. }
  662. return 0;
  663. err:
  664. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  665. return ret;
  666. }
  667. static int af9035_tua9001_tuner_callback(struct dvb_usb_device *d,
  668. int cmd, int arg)
  669. {
  670. int ret;
  671. u8 val;
  672. dev_dbg(&d->udev->dev, "%s: cmd=%d arg=%d\n", __func__, cmd, arg);
  673. /*
  674. * CEN always enabled by hardware wiring
  675. * RESETN GPIOT3
  676. * RXEN GPIOT2
  677. */
  678. switch (cmd) {
  679. case TUA9001_CMD_RESETN:
  680. if (arg)
  681. val = 0x00;
  682. else
  683. val = 0x01;
  684. ret = af9035_wr_reg_mask(d, 0x00d8e7, val, 0x01);
  685. if (ret < 0)
  686. goto err;
  687. break;
  688. case TUA9001_CMD_RXEN:
  689. if (arg)
  690. val = 0x01;
  691. else
  692. val = 0x00;
  693. ret = af9035_wr_reg_mask(d, 0x00d8eb, val, 0x01);
  694. if (ret < 0)
  695. goto err;
  696. break;
  697. }
  698. return 0;
  699. err:
  700. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  701. return ret;
  702. }
  703. static int af9035_fc0011_tuner_callback(struct dvb_usb_device *d,
  704. int cmd, int arg)
  705. {
  706. int ret;
  707. switch (cmd) {
  708. case FC0011_FE_CALLBACK_POWER:
  709. /* Tuner enable */
  710. ret = af9035_wr_reg_mask(d, 0xd8eb, 1, 1);
  711. if (ret < 0)
  712. goto err;
  713. ret = af9035_wr_reg_mask(d, 0xd8ec, 1, 1);
  714. if (ret < 0)
  715. goto err;
  716. ret = af9035_wr_reg_mask(d, 0xd8ed, 1, 1);
  717. if (ret < 0)
  718. goto err;
  719. /* LED */
  720. ret = af9035_wr_reg_mask(d, 0xd8d0, 1, 1);
  721. if (ret < 0)
  722. goto err;
  723. ret = af9035_wr_reg_mask(d, 0xd8d1, 1, 1);
  724. if (ret < 0)
  725. goto err;
  726. usleep_range(10000, 50000);
  727. break;
  728. case FC0011_FE_CALLBACK_RESET:
  729. ret = af9035_wr_reg(d, 0xd8e9, 1);
  730. if (ret < 0)
  731. goto err;
  732. ret = af9035_wr_reg(d, 0xd8e8, 1);
  733. if (ret < 0)
  734. goto err;
  735. ret = af9035_wr_reg(d, 0xd8e7, 1);
  736. if (ret < 0)
  737. goto err;
  738. usleep_range(10000, 20000);
  739. ret = af9035_wr_reg(d, 0xd8e7, 0);
  740. if (ret < 0)
  741. goto err;
  742. usleep_range(10000, 20000);
  743. break;
  744. default:
  745. ret = -EINVAL;
  746. goto err;
  747. }
  748. return 0;
  749. err:
  750. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  751. return ret;
  752. }
  753. static int af9035_tuner_callback(struct dvb_usb_device *d, int cmd, int arg)
  754. {
  755. struct state *state = d_to_priv(d);
  756. switch (state->af9033_config[0].tuner) {
  757. case AF9033_TUNER_FC0011:
  758. return af9035_fc0011_tuner_callback(d, cmd, arg);
  759. case AF9033_TUNER_TUA9001:
  760. return af9035_tua9001_tuner_callback(d, cmd, arg);
  761. default:
  762. break;
  763. }
  764. return 0;
  765. }
  766. static int af9035_frontend_callback(void *adapter_priv, int component,
  767. int cmd, int arg)
  768. {
  769. struct i2c_adapter *adap = adapter_priv;
  770. struct dvb_usb_device *d = i2c_get_adapdata(adap);
  771. dev_dbg(&d->udev->dev, "%s: component=%d cmd=%d arg=%d\n",
  772. __func__, component, cmd, arg);
  773. switch (component) {
  774. case DVB_FRONTEND_COMPONENT_TUNER:
  775. return af9035_tuner_callback(d, cmd, arg);
  776. default:
  777. break;
  778. }
  779. return 0;
  780. }
  781. static int af9035_get_adapter_count(struct dvb_usb_device *d)
  782. {
  783. struct state *state = d_to_priv(d);
  784. /* disable 2nd adapter as we don't have PID filters implemented */
  785. if (d->udev->speed == USB_SPEED_FULL)
  786. return 1;
  787. else
  788. return state->dual_mode + 1;
  789. }
  790. static int af9035_frontend_attach(struct dvb_usb_adapter *adap)
  791. {
  792. struct state *state = adap_to_priv(adap);
  793. struct dvb_usb_device *d = adap_to_d(adap);
  794. int ret;
  795. dev_dbg(&d->udev->dev, "%s:\n", __func__);
  796. if (!state->af9033_config[adap->id].tuner) {
  797. /* unsupported tuner */
  798. ret = -ENODEV;
  799. goto err;
  800. }
  801. /* attach demodulator */
  802. adap->fe[0] = dvb_attach(af9033_attach, &state->af9033_config[adap->id],
  803. &d->i2c_adap);
  804. if (adap->fe[0] == NULL) {
  805. ret = -ENODEV;
  806. goto err;
  807. }
  808. /* disable I2C-gate */
  809. adap->fe[0]->ops.i2c_gate_ctrl = NULL;
  810. adap->fe[0]->callback = af9035_frontend_callback;
  811. return 0;
  812. err:
  813. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  814. return ret;
  815. }
  816. static struct tua9001_config af9035_tua9001_config = {
  817. .i2c_addr = 0x60,
  818. };
  819. static const struct fc0011_config af9035_fc0011_config = {
  820. .i2c_address = 0x60,
  821. };
  822. static struct mxl5007t_config af9035_mxl5007t_config[] = {
  823. {
  824. .xtal_freq_hz = MxL_XTAL_24_MHZ,
  825. .if_freq_hz = MxL_IF_4_57_MHZ,
  826. .invert_if = 0,
  827. .loop_thru_enable = 0,
  828. .clk_out_enable = 0,
  829. .clk_out_amp = MxL_CLKOUT_AMP_0_94V,
  830. }, {
  831. .xtal_freq_hz = MxL_XTAL_24_MHZ,
  832. .if_freq_hz = MxL_IF_4_57_MHZ,
  833. .invert_if = 0,
  834. .loop_thru_enable = 1,
  835. .clk_out_enable = 1,
  836. .clk_out_amp = MxL_CLKOUT_AMP_0_94V,
  837. }
  838. };
  839. static struct tda18218_config af9035_tda18218_config = {
  840. .i2c_address = 0x60,
  841. .i2c_wr_max = 21,
  842. };
  843. static const struct fc2580_config af9035_fc2580_config = {
  844. .i2c_addr = 0x56,
  845. .clock = 16384000,
  846. };
  847. static const struct fc0012_config af9035_fc0012_config[] = {
  848. {
  849. .i2c_address = 0x63,
  850. .xtal_freq = FC_XTAL_36_MHZ,
  851. .dual_master = true,
  852. .loop_through = true,
  853. .clock_out = true,
  854. }, {
  855. .i2c_address = 0x63 | 0x80, /* I2C bus select hack */
  856. .xtal_freq = FC_XTAL_36_MHZ,
  857. .dual_master = true,
  858. }
  859. };
  860. static int af9035_tuner_attach(struct dvb_usb_adapter *adap)
  861. {
  862. struct state *state = adap_to_priv(adap);
  863. struct dvb_usb_device *d = adap_to_d(adap);
  864. int ret;
  865. struct dvb_frontend *fe;
  866. struct i2c_msg msg[1];
  867. u8 tuner_addr;
  868. dev_dbg(&d->udev->dev, "%s:\n", __func__);
  869. /*
  870. * XXX: Hack used in that function: we abuse unused I2C address bit [7]
  871. * to carry info about used I2C bus for dual tuner configuration.
  872. */
  873. switch (state->af9033_config[adap->id].tuner) {
  874. case AF9033_TUNER_TUA9001:
  875. /* AF9035 gpiot3 = TUA9001 RESETN
  876. AF9035 gpiot2 = TUA9001 RXEN */
  877. /* configure gpiot2 and gpiot2 as output */
  878. ret = af9035_wr_reg_mask(d, 0x00d8ec, 0x01, 0x01);
  879. if (ret < 0)
  880. goto err;
  881. ret = af9035_wr_reg_mask(d, 0x00d8ed, 0x01, 0x01);
  882. if (ret < 0)
  883. goto err;
  884. ret = af9035_wr_reg_mask(d, 0x00d8e8, 0x01, 0x01);
  885. if (ret < 0)
  886. goto err;
  887. ret = af9035_wr_reg_mask(d, 0x00d8e9, 0x01, 0x01);
  888. if (ret < 0)
  889. goto err;
  890. /* attach tuner */
  891. fe = dvb_attach(tua9001_attach, adap->fe[0],
  892. &d->i2c_adap, &af9035_tua9001_config);
  893. break;
  894. case AF9033_TUNER_FC0011:
  895. fe = dvb_attach(fc0011_attach, adap->fe[0],
  896. &d->i2c_adap, &af9035_fc0011_config);
  897. break;
  898. case AF9033_TUNER_MXL5007T:
  899. if (adap->id == 0) {
  900. ret = af9035_wr_reg(d, 0x00d8e0, 1);
  901. if (ret < 0)
  902. goto err;
  903. ret = af9035_wr_reg(d, 0x00d8e1, 1);
  904. if (ret < 0)
  905. goto err;
  906. ret = af9035_wr_reg(d, 0x00d8df, 0);
  907. if (ret < 0)
  908. goto err;
  909. msleep(30);
  910. ret = af9035_wr_reg(d, 0x00d8df, 1);
  911. if (ret < 0)
  912. goto err;
  913. msleep(300);
  914. ret = af9035_wr_reg(d, 0x00d8c0, 1);
  915. if (ret < 0)
  916. goto err;
  917. ret = af9035_wr_reg(d, 0x00d8c1, 1);
  918. if (ret < 0)
  919. goto err;
  920. ret = af9035_wr_reg(d, 0x00d8bf, 0);
  921. if (ret < 0)
  922. goto err;
  923. ret = af9035_wr_reg(d, 0x00d8b4, 1);
  924. if (ret < 0)
  925. goto err;
  926. ret = af9035_wr_reg(d, 0x00d8b5, 1);
  927. if (ret < 0)
  928. goto err;
  929. ret = af9035_wr_reg(d, 0x00d8b3, 1);
  930. if (ret < 0)
  931. goto err;
  932. tuner_addr = 0x60;
  933. } else {
  934. tuner_addr = 0x60 | 0x80; /* I2C bus hack */
  935. }
  936. /* attach tuner */
  937. fe = dvb_attach(mxl5007t_attach, adap->fe[0], &d->i2c_adap,
  938. tuner_addr, &af9035_mxl5007t_config[adap->id]);
  939. break;
  940. case AF9033_TUNER_TDA18218:
  941. /* attach tuner */
  942. fe = dvb_attach(tda18218_attach, adap->fe[0],
  943. &d->i2c_adap, &af9035_tda18218_config);
  944. break;
  945. case AF9033_TUNER_FC2580:
  946. /* Tuner enable using gpiot2_o, gpiot2_en and gpiot2_on */
  947. ret = af9035_wr_reg_mask(d, 0xd8eb, 0x01, 0x01);
  948. if (ret < 0)
  949. goto err;
  950. ret = af9035_wr_reg_mask(d, 0xd8ec, 0x01, 0x01);
  951. if (ret < 0)
  952. goto err;
  953. ret = af9035_wr_reg_mask(d, 0xd8ed, 0x01, 0x01);
  954. if (ret < 0)
  955. goto err;
  956. usleep_range(10000, 50000);
  957. /* attach tuner */
  958. fe = dvb_attach(fc2580_attach, adap->fe[0],
  959. &d->i2c_adap, &af9035_fc2580_config);
  960. break;
  961. case AF9033_TUNER_FC0012:
  962. /*
  963. * AF9035 gpiot2 = FC0012 enable
  964. * XXX: there seems to be something on gpioh8 too, but on my
  965. * my test I didn't find any difference.
  966. */
  967. if (adap->id == 0) {
  968. /* configure gpiot2 as output and high */
  969. ret = af9035_wr_reg_mask(d, 0xd8eb, 0x01, 0x01);
  970. if (ret < 0)
  971. goto err;
  972. ret = af9035_wr_reg_mask(d, 0xd8ec, 0x01, 0x01);
  973. if (ret < 0)
  974. goto err;
  975. ret = af9035_wr_reg_mask(d, 0xd8ed, 0x01, 0x01);
  976. if (ret < 0)
  977. goto err;
  978. } else {
  979. /*
  980. * FIXME: That belongs for the FC0012 driver.
  981. * Write 02 to FC0012 master tuner register 0d directly
  982. * in order to make slave tuner working.
  983. */
  984. msg[0].addr = 0x63;
  985. msg[0].flags = 0;
  986. msg[0].len = 2;
  987. msg[0].buf = "\x0d\x02";
  988. ret = i2c_transfer(&d->i2c_adap, msg, 1);
  989. if (ret < 0)
  990. goto err;
  991. }
  992. usleep_range(10000, 50000);
  993. fe = dvb_attach(fc0012_attach, adap->fe[0], &d->i2c_adap,
  994. &af9035_fc0012_config[adap->id]);
  995. break;
  996. case AF9033_TUNER_IT9135_38:
  997. case AF9033_TUNER_IT9135_51:
  998. case AF9033_TUNER_IT9135_52:
  999. case AF9033_TUNER_IT9135_60:
  1000. case AF9033_TUNER_IT9135_61:
  1001. case AF9033_TUNER_IT9135_62:
  1002. /* attach tuner */
  1003. fe = dvb_attach(it913x_attach, adap->fe[0], &d->i2c_adap,
  1004. state->af9033_config[adap->id].i2c_addr,
  1005. state->af9033_config[0].tuner);
  1006. break;
  1007. default:
  1008. fe = NULL;
  1009. }
  1010. if (fe == NULL) {
  1011. ret = -ENODEV;
  1012. goto err;
  1013. }
  1014. return 0;
  1015. err:
  1016. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  1017. return ret;
  1018. }
  1019. static int af9035_init(struct dvb_usb_device *d)
  1020. {
  1021. struct state *state = d_to_priv(d);
  1022. int ret, i;
  1023. u16 frame_size = (d->udev->speed == USB_SPEED_FULL ? 5 : 87) * 188 / 4;
  1024. u8 packet_size = (d->udev->speed == USB_SPEED_FULL ? 64 : 512) / 4;
  1025. struct reg_val_mask tab[] = {
  1026. { 0x80f99d, 0x01, 0x01 },
  1027. { 0x80f9a4, 0x01, 0x01 },
  1028. { 0x00dd11, 0x00, 0x20 },
  1029. { 0x00dd11, 0x00, 0x40 },
  1030. { 0x00dd13, 0x00, 0x20 },
  1031. { 0x00dd13, 0x00, 0x40 },
  1032. { 0x00dd11, 0x20, 0x20 },
  1033. { 0x00dd88, (frame_size >> 0) & 0xff, 0xff},
  1034. { 0x00dd89, (frame_size >> 8) & 0xff, 0xff},
  1035. { 0x00dd0c, packet_size, 0xff},
  1036. { 0x00dd11, state->dual_mode << 6, 0x40 },
  1037. { 0x00dd8a, (frame_size >> 0) & 0xff, 0xff},
  1038. { 0x00dd8b, (frame_size >> 8) & 0xff, 0xff},
  1039. { 0x00dd0d, packet_size, 0xff },
  1040. { 0x80f9a3, state->dual_mode, 0x01 },
  1041. { 0x80f9cd, state->dual_mode, 0x01 },
  1042. { 0x80f99d, 0x00, 0x01 },
  1043. { 0x80f9a4, 0x00, 0x01 },
  1044. };
  1045. dev_dbg(&d->udev->dev,
  1046. "%s: USB speed=%d frame_size=%04x packet_size=%02x\n",
  1047. __func__, d->udev->speed, frame_size, packet_size);
  1048. /* init endpoints */
  1049. for (i = 0; i < ARRAY_SIZE(tab); i++) {
  1050. ret = af9035_wr_reg_mask(d, tab[i].reg, tab[i].val,
  1051. tab[i].mask);
  1052. if (ret < 0)
  1053. goto err;
  1054. }
  1055. return 0;
  1056. err:
  1057. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  1058. return ret;
  1059. }
  1060. #if IS_ENABLED(CONFIG_RC_CORE)
  1061. static int af9035_rc_query(struct dvb_usb_device *d)
  1062. {
  1063. int ret;
  1064. u32 key;
  1065. u8 buf[4];
  1066. struct usb_req req = { CMD_IR_GET, 0, 0, NULL, 4, buf };
  1067. ret = af9035_ctrl_msg(d, &req);
  1068. if (ret == 1)
  1069. return 0;
  1070. else if (ret < 0)
  1071. goto err;
  1072. if ((buf[2] + buf[3]) == 0xff) {
  1073. if ((buf[0] + buf[1]) == 0xff) {
  1074. /* NEC standard 16bit */
  1075. key = buf[0] << 8 | buf[2];
  1076. } else {
  1077. /* NEC extended 24bit */
  1078. key = buf[0] << 16 | buf[1] << 8 | buf[2];
  1079. }
  1080. } else {
  1081. /* NEC full code 32bit */
  1082. key = buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3];
  1083. }
  1084. dev_dbg(&d->udev->dev, "%s: %*ph\n", __func__, 4, buf);
  1085. rc_keydown(d->rc_dev, key, 0);
  1086. return 0;
  1087. err:
  1088. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  1089. return ret;
  1090. }
  1091. static int af9035_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
  1092. {
  1093. struct state *state = d_to_priv(d);
  1094. int ret;
  1095. u8 tmp;
  1096. ret = af9035_rd_reg(d, state->eeprom_addr + EEPROM_IR_MODE, &tmp);
  1097. if (ret < 0)
  1098. goto err;
  1099. dev_dbg(&d->udev->dev, "%s: ir_mode=%02x\n", __func__, tmp);
  1100. /* don't activate rc if in HID mode or if not available */
  1101. if (tmp == 5) {
  1102. ret = af9035_rd_reg(d, state->eeprom_addr + EEPROM_IR_TYPE,
  1103. &tmp);
  1104. if (ret < 0)
  1105. goto err;
  1106. dev_dbg(&d->udev->dev, "%s: ir_type=%02x\n", __func__, tmp);
  1107. switch (tmp) {
  1108. case 0: /* NEC */
  1109. default:
  1110. rc->allowed_protos = RC_BIT_NEC;
  1111. break;
  1112. case 1: /* RC6 */
  1113. rc->allowed_protos = RC_BIT_RC6_MCE;
  1114. break;
  1115. }
  1116. rc->query = af9035_rc_query;
  1117. rc->interval = 500;
  1118. /* load empty to enable rc */
  1119. if (!rc->map_name)
  1120. rc->map_name = RC_MAP_EMPTY;
  1121. }
  1122. return 0;
  1123. err:
  1124. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  1125. return ret;
  1126. }
  1127. #else
  1128. #define af9035_get_rc_config NULL
  1129. #endif
  1130. static int af9035_get_stream_config(struct dvb_frontend *fe, u8 *ts_type,
  1131. struct usb_data_stream_properties *stream)
  1132. {
  1133. struct dvb_usb_device *d = fe_to_d(fe);
  1134. dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, fe_to_adap(fe)->id);
  1135. if (d->udev->speed == USB_SPEED_FULL)
  1136. stream->u.bulk.buffersize = 5 * 188;
  1137. return 0;
  1138. }
  1139. /*
  1140. * FIXME: PID filter is property of demodulator and should be moved to the
  1141. * correct driver. Also we support only adapter #0 PID filter and will
  1142. * disable adapter #1 if USB1.1 is used.
  1143. */
  1144. static int af9035_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
  1145. {
  1146. struct dvb_usb_device *d = adap_to_d(adap);
  1147. int ret;
  1148. dev_dbg(&d->udev->dev, "%s: onoff=%d\n", __func__, onoff);
  1149. ret = af9035_wr_reg_mask(d, 0x80f993, onoff, 0x01);
  1150. if (ret < 0)
  1151. goto err;
  1152. return 0;
  1153. err:
  1154. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  1155. return ret;
  1156. }
  1157. static int af9035_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
  1158. int onoff)
  1159. {
  1160. struct dvb_usb_device *d = adap_to_d(adap);
  1161. int ret;
  1162. u8 wbuf[2] = {(pid >> 0) & 0xff, (pid >> 8) & 0xff};
  1163. dev_dbg(&d->udev->dev, "%s: index=%d pid=%04x onoff=%d\n",
  1164. __func__, index, pid, onoff);
  1165. ret = af9035_wr_regs(d, 0x80f996, wbuf, 2);
  1166. if (ret < 0)
  1167. goto err;
  1168. ret = af9035_wr_reg(d, 0x80f994, onoff);
  1169. if (ret < 0)
  1170. goto err;
  1171. ret = af9035_wr_reg(d, 0x80f995, index);
  1172. if (ret < 0)
  1173. goto err;
  1174. return 0;
  1175. err:
  1176. dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
  1177. return ret;
  1178. }
  1179. static int af9035_probe(struct usb_interface *intf,
  1180. const struct usb_device_id *id)
  1181. {
  1182. struct usb_device *udev = interface_to_usbdev(intf);
  1183. char manufacturer[sizeof("Afatech")];
  1184. memset(manufacturer, 0, sizeof(manufacturer));
  1185. usb_string(udev, udev->descriptor.iManufacturer,
  1186. manufacturer, sizeof(manufacturer));
  1187. /*
  1188. * There is two devices having same ID but different chipset. One uses
  1189. * AF9015 and the other IT9135 chipset. Only difference seen on lsusb
  1190. * is iManufacturer string.
  1191. *
  1192. * idVendor 0x0ccd TerraTec Electronic GmbH
  1193. * idProduct 0x0099
  1194. * bcdDevice 2.00
  1195. * iManufacturer 1 Afatech
  1196. * iProduct 2 DVB-T 2
  1197. *
  1198. * idVendor 0x0ccd TerraTec Electronic GmbH
  1199. * idProduct 0x0099
  1200. * bcdDevice 2.00
  1201. * iManufacturer 1 ITE Technologies, Inc.
  1202. * iProduct 2 DVB-T TV Stick
  1203. */
  1204. if ((le16_to_cpu(udev->descriptor.idVendor) == USB_VID_TERRATEC) &&
  1205. (le16_to_cpu(udev->descriptor.idProduct) == 0x0099)) {
  1206. if (!strcmp("Afatech", manufacturer)) {
  1207. dev_dbg(&udev->dev, "%s: rejecting device\n", __func__);
  1208. return -ENODEV;
  1209. }
  1210. }
  1211. return dvb_usbv2_probe(intf, id);
  1212. }
  1213. /* interface 0 is used by DVB-T receiver and
  1214. interface 1 is for remote controller (HID) */
  1215. static const struct dvb_usb_device_properties af9035_props = {
  1216. .driver_name = KBUILD_MODNAME,
  1217. .owner = THIS_MODULE,
  1218. .adapter_nr = adapter_nr,
  1219. .size_of_priv = sizeof(struct state),
  1220. .generic_bulk_ctrl_endpoint = 0x02,
  1221. .generic_bulk_ctrl_endpoint_response = 0x81,
  1222. .identify_state = af9035_identify_state,
  1223. .download_firmware = af9035_download_firmware,
  1224. .i2c_algo = &af9035_i2c_algo,
  1225. .read_config = af9035_read_config,
  1226. .frontend_attach = af9035_frontend_attach,
  1227. .tuner_attach = af9035_tuner_attach,
  1228. .init = af9035_init,
  1229. .get_rc_config = af9035_get_rc_config,
  1230. .get_stream_config = af9035_get_stream_config,
  1231. .get_adapter_count = af9035_get_adapter_count,
  1232. .adapter = {
  1233. {
  1234. .caps = DVB_USB_ADAP_HAS_PID_FILTER |
  1235. DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
  1236. .pid_filter_count = 32,
  1237. .pid_filter_ctrl = af9035_pid_filter_ctrl,
  1238. .pid_filter = af9035_pid_filter,
  1239. .stream = DVB_USB_STREAM_BULK(0x84, 6, 87 * 188),
  1240. }, {
  1241. .stream = DVB_USB_STREAM_BULK(0x85, 6, 87 * 188),
  1242. },
  1243. },
  1244. };
  1245. static const struct usb_device_id af9035_id_table[] = {
  1246. /* AF9035 devices */
  1247. { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_9035,
  1248. &af9035_props, "Afatech AF9035 reference design", NULL) },
  1249. { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1000,
  1250. &af9035_props, "Afatech AF9035 reference design", NULL) },
  1251. { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1001,
  1252. &af9035_props, "Afatech AF9035 reference design", NULL) },
  1253. { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1002,
  1254. &af9035_props, "Afatech AF9035 reference design", NULL) },
  1255. { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1003,
  1256. &af9035_props, "Afatech AF9035 reference design", NULL) },
  1257. { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK,
  1258. &af9035_props, "TerraTec Cinergy T Stick", NULL) },
  1259. { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835,
  1260. &af9035_props, "AVerMedia AVerTV Volar HD/PRO (A835)", NULL) },
  1261. { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_B835,
  1262. &af9035_props, "AVerMedia AVerTV Volar HD/PRO (A835)", NULL) },
  1263. { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_1867,
  1264. &af9035_props, "AVerMedia HD Volar (A867)", NULL) },
  1265. { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A867,
  1266. &af9035_props, "AVerMedia HD Volar (A867)", NULL) },
  1267. { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_TWINSTAR,
  1268. &af9035_props, "AVerMedia Twinstar (A825)", NULL) },
  1269. { DVB_USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3100MINI_PLUS,
  1270. &af9035_props, "Asus U3100Mini Plus", NULL) },
  1271. { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x00aa,
  1272. &af9035_props, "TerraTec Cinergy T Stick (rev. 2)", NULL) },
  1273. /* IT9135 devices */
  1274. #if 0
  1275. { DVB_USB_DEVICE(0x048d, 0x9135,
  1276. &af9035_props, "IT9135 reference design", NULL) },
  1277. { DVB_USB_DEVICE(0x048d, 0x9006,
  1278. &af9035_props, "IT9135 reference design", NULL) },
  1279. #endif
  1280. /* XXX: that same ID [0ccd:0099] is used by af9015 driver too */
  1281. { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x0099,
  1282. &af9035_props, "TerraTec Cinergy T Stick Dual RC (rev. 2)", NULL) },
  1283. { }
  1284. };
  1285. MODULE_DEVICE_TABLE(usb, af9035_id_table);
  1286. static struct usb_driver af9035_usb_driver = {
  1287. .name = KBUILD_MODNAME,
  1288. .id_table = af9035_id_table,
  1289. .probe = af9035_probe,
  1290. .disconnect = dvb_usbv2_disconnect,
  1291. .suspend = dvb_usbv2_suspend,
  1292. .resume = dvb_usbv2_resume,
  1293. .reset_resume = dvb_usbv2_reset_resume,
  1294. .no_dynamic_id = 1,
  1295. .soft_unbind = 1,
  1296. };
  1297. module_usb_driver(af9035_usb_driver);
  1298. MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
  1299. MODULE_DESCRIPTION("Afatech AF9035 driver");
  1300. MODULE_LICENSE("GPL");
  1301. MODULE_FIRMWARE(AF9035_FIRMWARE_AF9035);
  1302. MODULE_FIRMWARE(AF9035_FIRMWARE_IT9135_V1);
  1303. MODULE_FIRMWARE(AF9035_FIRMWARE_IT9135_V2);