git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/pvrusb2/pvrusb2-i2c-core.c

   1 /*
   2  *
   3  *  $Id$
   4  *
   5  *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
   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
  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  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "pvrusb2-i2c-core.h"
  23 #include "pvrusb2-hdw-internal.h"
  24 #include "pvrusb2-debug.h"
  25
  26 #define trace_i2c(...) pvr2_trace(PVR2_TRACE_I2C,__VA_ARGS__)
  27
  28 /*
  29
  30   This module attempts to implement a compliant I2C adapter for the pvrusb2
  31   device.  By doing this we can then make use of existing functionality in
  32   V4L (e.g. tuner.c) rather than rolling our own.
  33
  34 */
  35
  36 static unsigned int i2c_scan = 0;
  37 module_param(i2c_scan, int, S_IRUGO|S_IWUSR);
  38 MODULE_PARM_DESC(i2c_scan,"scan i2c bus at insmod time");
  39
  40 static unsigned int pvr2_i2c_client_describe(struct pvr2_i2c_client *cp,
  41                                              unsigned int detail,
  42                                              char *buf,unsigned int maxlen);
  43
  44 static int pvr2_i2c_write(struct pvr2_hdw *hdw, /* Context */
  45                           u8 i2c_addr,      /* I2C address we're talking to */
  46                           u8 *data,         /* Data to write */
  47                           u16 length)       /* Size of data to write */
  48 {
  49         /* Return value - default 0 means success */
  50         int ret;
  51
  52
  53         if (!data) length = 0;
  54         if (length > (sizeof(hdw->cmd_buffer) - 3)) {
  55                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
  56                            "Killing an I2C write to %u that is too large"
  57                            " (desired=%u limit=%u)",
  58                            i2c_addr,
  59                            length,(unsigned int)(sizeof(hdw->cmd_buffer) - 3));
  60                 return -ENOTSUPP;
  61         }
  62
  63         LOCK_TAKE(hdw->ctl_lock);
  64
  65         /* Clear the command buffer (likely to be paranoia) */
  66         memset(hdw->cmd_buffer, 0, sizeof(hdw->cmd_buffer));
  67
  68         /* Set up command buffer for an I2C write */
  69         hdw->cmd_buffer[0] = 0x08;      /* write prefix */
  70         hdw->cmd_buffer[1] = i2c_addr;  /* i2c addr of chip */
  71         hdw->cmd_buffer[2] = length;    /* length of what follows */
  72         if (length) memcpy(hdw->cmd_buffer + 3, data, length);
  73
  74         /* Do the operation */
  75         ret = pvr2_send_request(hdw,
  76                                 hdw->cmd_buffer,
  77                                 length + 3,
  78                                 hdw->cmd_buffer,
  79                                 1);
  80         if (!ret) {
  81                 if (hdw->cmd_buffer[0] != 8) {
  82                         ret = -EIO;
  83                         if (hdw->cmd_buffer[0] != 7) {
  84                                 trace_i2c("unexpected status"
  85                                           " from i2_write[%d]: %d",
  86                                           i2c_addr,hdw->cmd_buffer[0]);
  87                         }
  88                 }
  89         }
  90
  91         LOCK_GIVE(hdw->ctl_lock);
  92
  93         return ret;
  94 }
  95
  96 static int pvr2_i2c_read(struct pvr2_hdw *hdw, /* Context */
  97                          u8 i2c_addr,       /* I2C address we're talking to */
  98                          u8 *data,          /* Data to write */
  99                          u16 dlen,          /* Size of data to write */
 100                          u8 *res,           /* Where to put data we read */
 101                          u16 rlen)          /* Amount of data to read */
 102 {
 103         /* Return value - default 0 means success */
 104         int ret;
 105
 106
 107         if (!data) dlen = 0;
 108         if (dlen > (sizeof(hdw->cmd_buffer) - 4)) {
 109                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 110                            "Killing an I2C read to %u that has wlen too large"
 111                            " (desired=%u limit=%u)",
 112                            i2c_addr,
 113                            dlen,(unsigned int)(sizeof(hdw->cmd_buffer) - 4));
 114                 return -ENOTSUPP;
 115         }
 116         if (res && (rlen > (sizeof(hdw->cmd_buffer) - 1))) {
 117                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 118                            "Killing an I2C read to %u that has rlen too large"
 119                            " (desired=%u limit=%u)",
 120                            i2c_addr,
 121                            rlen,(unsigned int)(sizeof(hdw->cmd_buffer) - 1));
 122                 return -ENOTSUPP;
 123         }
 124
 125         LOCK_TAKE(hdw->ctl_lock);
 126
 127         /* Clear the command buffer (likely to be paranoia) */
 128         memset(hdw->cmd_buffer, 0, sizeof(hdw->cmd_buffer));
 129
 130         /* Set up command buffer for an I2C write followed by a read */
 131         hdw->cmd_buffer[0] = 0x09;  /* read prefix */
 132         hdw->cmd_buffer[1] = dlen;  /* arg length */
 133         hdw->cmd_buffer[2] = rlen;  /* answer length. Device will send one
 134                                        more byte (status). */
 135         hdw->cmd_buffer[3] = i2c_addr;  /* i2c addr of chip */
 136         if (dlen) memcpy(hdw->cmd_buffer + 4, data, dlen);
 137
 138         /* Do the operation */
 139         ret = pvr2_send_request(hdw,
 140                                 hdw->cmd_buffer,
 141                                 4 + dlen,
 142                                 hdw->cmd_buffer,
 143                                 rlen + 1);
 144         if (!ret) {
 145                 if (hdw->cmd_buffer[0] != 8) {
 146                         ret = -EIO;
 147                         if (hdw->cmd_buffer[0] != 7) {
 148                                 trace_i2c("unexpected status"
 149                                           " from i2_read[%d]: %d",
 150                                           i2c_addr,hdw->cmd_buffer[0]);
 151                         }
 152                 }
 153         }
 154
 155         /* Copy back the result */
 156         if (res && rlen) {
 157                 if (ret) {
 158                         /* Error, just blank out the return buffer */
 159                         memset(res, 0, rlen);
 160                 } else {
 161                         memcpy(res, hdw->cmd_buffer + 1, rlen);
 162                 }
 163         }
 164
 165         LOCK_GIVE(hdw->ctl_lock);
 166
 167         return ret;
 168 }
 169
 170 /* This is the common low level entry point for doing I2C operations to the
 171    hardware. */
 172 static int pvr2_i2c_basic_op(struct pvr2_hdw *hdw,
 173                              u8 i2c_addr,
 174                              u8 *wdata,
 175                              u16 wlen,
 176                              u8 *rdata,
 177                              u16 rlen)
 178 {
 179         if (!rdata) rlen = 0;
 180         if (!wdata) wlen = 0;
 181         if (rlen || !wlen) {
 182                 return pvr2_i2c_read(hdw,i2c_addr,wdata,wlen,rdata,rlen);
 183         } else {
 184                 return pvr2_i2c_write(hdw,i2c_addr,wdata,wlen);
 185         }
 186 }
 187
 188 /* This is a special entry point that is entered if an I2C operation is
 189    attempted to a wm8775 chip on model 24xxx hardware.  Autodetect of this
 190    part doesn't work, but we know it is really there.  So let's look for
 191    the autodetect attempt and just return success if we see that. */
 192 static int i2c_hack_wm8775(struct pvr2_hdw *hdw,
 193                            u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
 194 {
 195         if (!(rlen || wlen)) {
 196                 // This is a probe attempt.  Just let it succeed.
 197                 return 0;
 198         }
 199         return pvr2_i2c_basic_op(hdw,i2c_addr,wdata,wlen,rdata,rlen);
 200 }
 201
 202 /* This is a special entry point that is entered if an I2C operation is
 203    attempted to a cx25840 chip on model 24xxx hardware.  This chip can
 204    sometimes wedge itself.  Worse still, when this happens msp3400 can
 205    falsely detect this part and then the system gets hosed up after msp3400
 206    gets confused and dies.  What we want to do here is try to keep msp3400
 207    away and also try to notice if the chip is wedged and send a warning to
 208    the system log. */
 209 static int i2c_hack_cx25840(struct pvr2_hdw *hdw,
 210                             u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
 211 {
 212         int ret;
 213         unsigned int subaddr;
 214         u8 wbuf[2];
 215         int state = hdw->i2c_cx25840_hack_state;
 216
 217         if (!(rlen || wlen)) {
 218                 // Probe attempt - always just succeed and don't bother the
 219                 // hardware (this helps to make the state machine further
 220                 // down somewhat easier).
 221                 return 0;
 222         }
 223
 224         if (state == 3) {
 225                 return pvr2_i2c_basic_op(hdw,i2c_addr,wdata,wlen,rdata,rlen);
 226         }
 227
 228         /* We're looking for the exact pattern where the revision register
 229            is being read.  The cx25840 module will always look at the
 230            revision register first.  Any other pattern of access therefore
 231            has to be a probe attempt from somebody else so we'll reject it.
 232            Normally we could just let each client just probe the part
 233            anyway, but when the cx25840 is wedged, msp3400 will get a false
 234            positive and that just screws things up... */
 235
 236         if (wlen == 0) {
 237                 switch (state) {
 238                 case 1: subaddr = 0x0100; break;
 239                 case 2: subaddr = 0x0101; break;
 240                 default: goto fail;
 241                 }
 242         } else if (wlen == 2) {
 243                 subaddr = (wdata[0] << 8) | wdata[1];
 244                 switch (subaddr) {
 245                 case 0x0100: state = 1; break;
 246                 case 0x0101: state = 2; break;
 247                 default: goto fail;
 248                 }
 249         } else {
 250                 goto fail;
 251         }
 252         if (!rlen) goto success;
 253         state = 0;
 254         if (rlen != 1) goto fail;
 255
 256         /* If we get to here then we have a legitimate read for one of the
 257            two revision bytes, so pass it through. */
 258         wbuf[0] = subaddr >> 8;
 259         wbuf[1] = subaddr;
 260         ret = pvr2_i2c_basic_op(hdw,i2c_addr,wbuf,2,rdata,rlen);
 261
 262         if ((ret != 0) || (*rdata == 0x04) || (*rdata == 0x0a)) {
 263                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 264                            "WARNING: Detected a wedged cx25840 chip;"
 265                            " the device will not work.");
 266                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 267                            "WARNING: Try power cycling the pvrusb2 device.");
 268                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 269                            "WARNING: Disabling further access to the device"
 270                            " to prevent other foul-ups.");
 271                 // This blocks all further communication with the part.
 272                 hdw->i2c_func[0x44] = NULL;
 273                 pvr2_hdw_render_useless(hdw);
 274                 goto fail;
 275         }
 276
 277         /* Success! */
 278         pvr2_trace(PVR2_TRACE_CHIPS,"cx25840 appears to be OK.");
 279         state = 3;
 280
 281  success:
 282         hdw->i2c_cx25840_hack_state = state;
 283         return 0;
 284
 285  fail:
 286         hdw->i2c_cx25840_hack_state = state;
 287         return -EIO;
 288 }
 289
 290 /* This is a very, very limited I2C adapter implementation.  We can only
 291    support what we actually know will work on the device... */
 292 static int pvr2_i2c_xfer(struct i2c_adapter *i2c_adap,
 293                          struct i2c_msg msgs[],
 294                          int num)
 295 {
 296         int ret = -ENOTSUPP;
 297         pvr2_i2c_func funcp = NULL;
 298         struct pvr2_hdw *hdw = (struct pvr2_hdw *)(i2c_adap->algo_data);
 299
 300         if (!num) {
 301                 ret = -EINVAL;
 302                 goto done;
 303         }
 304         if ((msgs[0].flags & I2C_M_NOSTART)) {
 305                 trace_i2c("i2c refusing I2C_M_NOSTART");
 306                 goto done;
 307         }
 308         if (msgs[0].addr < PVR2_I2C_FUNC_CNT) {
 309                 funcp = hdw->i2c_func[msgs[0].addr];
 310         }
 311         if (!funcp) {
 312                 ret = -EIO;
 313                 goto done;
 314         }
 315
 316         if (num == 1) {
 317                 if (msgs[0].flags & I2C_M_RD) {
 318                         /* Simple read */
 319                         u16 tcnt,bcnt,offs;
 320                         if (!msgs[0].len) {
 321                                 /* Length == 0 read.  This is a probe. */
 322                                 if (funcp(hdw,msgs[0].addr,NULL,0,NULL,0)) {
 323                                         ret = -EIO;
 324                                         goto done;
 325                                 }
 326                                 ret = 1;
 327                                 goto done;
 328                         }
 329                         /* If the read is short enough we'll do the whole
 330                            thing atomically.  Otherwise we have no choice
 331                            but to break apart the reads. */
 332                         tcnt = msgs[0].len;
 333                         offs = 0;
 334                         while (tcnt) {
 335                                 bcnt = tcnt;
 336                                 if (bcnt > sizeof(hdw->cmd_buffer)-1) {
 337                                         bcnt = sizeof(hdw->cmd_buffer)-1;
 338                                 }
 339                                 if (funcp(hdw,msgs[0].addr,NULL,0,
 340                                           msgs[0].buf+offs,bcnt)) {
 341                                         ret = -EIO;
 342                                         goto done;
 343                                 }
 344                                 offs += bcnt;
 345                                 tcnt -= bcnt;
 346                         }
 347                         ret = 1;
 348                         goto done;
 349                 } else {
 350                         /* Simple write */
 351                         ret = 1;
 352                         if (funcp(hdw,msgs[0].addr,
 353                                   msgs[0].buf,msgs[0].len,NULL,0)) {
 354                                 ret = -EIO;
 355                         }
 356                         goto done;
 357                 }
 358         } else if (num == 2) {
 359                 if (msgs[0].addr != msgs[1].addr) {
 360                         trace_i2c("i2c refusing 2 phase transfer with"
 361                                   " conflicting target addresses");
 362                         ret = -ENOTSUPP;
 363                         goto done;
 364                 }
 365                 if ((!((msgs[0].flags & I2C_M_RD))) &&
 366                     (msgs[1].flags & I2C_M_RD)) {
 367                         u16 tcnt,bcnt,wcnt,offs;
 368                         /* Write followed by atomic read.  If the read
 369                            portion is short enough we'll do the whole thing
 370                            atomically.  Otherwise we have no choice but to
 371                            break apart the reads. */
 372                         tcnt = msgs[1].len;
 373                         wcnt = msgs[0].len;
 374                         offs = 0;
 375                         while (tcnt || wcnt) {
 376                                 bcnt = tcnt;
 377                                 if (bcnt > sizeof(hdw->cmd_buffer)-1) {
 378                                         bcnt = sizeof(hdw->cmd_buffer)-1;
 379                                 }
 380                                 if (funcp(hdw,msgs[0].addr,
 381                                           msgs[0].buf,wcnt,
 382                                           msgs[1].buf+offs,bcnt)) {
 383                                         ret = -EIO;
 384                                         goto done;
 385                                 }
 386                                 offs += bcnt;
 387                                 tcnt -= bcnt;
 388                                 wcnt = 0;
 389                         }
 390                         ret = 2;
 391                         goto done;
 392                 } else {
 393                         trace_i2c("i2c refusing complex transfer"
 394                                   " read0=%d read1=%d",
 395                                   (msgs[0].flags & I2C_M_RD),
 396                                   (msgs[1].flags & I2C_M_RD));
 397                 }
 398         } else {
 399                 trace_i2c("i2c refusing %d phase transfer",num);
 400         }
 401
 402  done:
 403         if (pvrusb2_debug & PVR2_TRACE_I2C_TRAF) {
 404                 unsigned int idx,offs,cnt;
 405                 for (idx = 0; idx < num; idx++) {
 406                         cnt = msgs[idx].len;
 407                         printk(KERN_INFO
 408                                "pvrusb2 i2c xfer %u/%u:"
 409                                " addr=0x%x len=%d %s%s",
 410                                idx+1,num,
 411                                msgs[idx].addr,
 412                                cnt,
 413                                (msgs[idx].flags & I2C_M_RD ?
 414                                 "read" : "write"),
 415                                (msgs[idx].flags & I2C_M_NOSTART ?
 416                                 " nostart" : ""));
 417                         if ((ret > 0) || !(msgs[idx].flags & I2C_M_RD)) {
 418                                 if (cnt > 8) cnt = 8;
 419                                 printk(" [");
 420                                 for (offs = 0; offs < (cnt>8?8:cnt); offs++) {
 421                                         if (offs) printk(" ");
 422                                         printk("%02x",msgs[idx].buf[offs]);
 423                                 }
 424                                 if (offs < cnt) printk(" ...");
 425                                 printk("]");
 426                         }
 427                         if (idx+1 == num) {
 428                                 printk(" result=%d",ret);
 429                         }
 430                         printk("\n");
 431                 }
 432                 if (!num) {
 433                         printk(KERN_INFO
 434                                "pvrusb2 i2c xfer null transfer result=%d\n",
 435                                ret);
 436                 }
 437         }
 438         return ret;
 439 }
 440
 441 static int pvr2_i2c_control(struct i2c_adapter *adapter,
 442                             unsigned int cmd, unsigned long arg)
 443 {
 444         return 0;
 445 }
 446
 447 static u32 pvr2_i2c_functionality(struct i2c_adapter *adap)
 448 {
 449         return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C | I2C_FUNC_SMBUS_BYTE_DATA;
 450 }
 451
 452 static int pvr2_i2c_core_singleton(struct i2c_client *cp,
 453                                    unsigned int cmd,void *arg)
 454 {
 455         int stat;
 456         if (!cp) return -EINVAL;
 457         if (!(cp->driver)) return -EINVAL;
 458         if (!(cp->driver->command)) return -EINVAL;
 459         if (!try_module_get(cp->driver->driver.owner)) return -EAGAIN;
 460         stat = cp->driver->command(cp,cmd,arg);
 461         module_put(cp->driver->driver.owner);
 462         return stat;
 463 }
 464
 465 int pvr2_i2c_client_cmd(struct pvr2_i2c_client *cp,unsigned int cmd,void *arg)
 466 {
 467         int stat;
 468         if (pvrusb2_debug & PVR2_TRACE_I2C_CMD) {
 469                 char buf[100];
 470                 unsigned int cnt;
 471                 cnt = pvr2_i2c_client_describe(cp,PVR2_I2C_DETAIL_DEBUG,
 472                                                buf,sizeof(buf));
 473                 pvr2_trace(PVR2_TRACE_I2C_CMD,
 474                            "i2c COMMAND (code=%u 0x%x) to %.*s",
 475                            cmd,cmd,cnt,buf);
 476         }
 477         stat = pvr2_i2c_core_singleton(cp->client,cmd,arg);
 478         if (pvrusb2_debug & PVR2_TRACE_I2C_CMD) {
 479                 char buf[100];
 480                 unsigned int cnt;
 481                 cnt = pvr2_i2c_client_describe(cp,PVR2_I2C_DETAIL_DEBUG,
 482                                                buf,sizeof(buf));
 483                 pvr2_trace(PVR2_TRACE_I2C_CMD,
 484                            "i2c COMMAND to %.*s (ret=%d)",cnt,buf,stat);
 485         }
 486         return stat;
 487 }
 488
 489 int pvr2_i2c_core_cmd(struct pvr2_hdw *hdw,unsigned int cmd,void *arg)
 490 {
 491         struct list_head *item,*nc;
 492         struct pvr2_i2c_client *cp;
 493         int stat = -EINVAL;
 494
 495         if (!hdw) return stat;
 496
 497         mutex_lock(&hdw->i2c_list_lock);
 498         list_for_each_safe(item,nc,&hdw->i2c_clients) {
 499                 cp = list_entry(item,struct pvr2_i2c_client,list);
 500                 if (!cp->recv_enable) continue;
 501                 mutex_unlock(&hdw->i2c_list_lock);
 502                 stat = pvr2_i2c_client_cmd(cp,cmd,arg);
 503                 mutex_lock(&hdw->i2c_list_lock);
 504         }
 505         mutex_unlock(&hdw->i2c_list_lock);
 506         return stat;
 507 }
 508
 509
 510 static int handler_check(struct pvr2_i2c_client *cp)
 511 {
 512         struct pvr2_i2c_handler *hp = cp->handler;
 513         if (!hp) return 0;
 514         if (!hp->func_table->check) return 0;
 515         return hp->func_table->check(hp->func_data) != 0;
 516 }
 517
 518 #define BUFSIZE 500
 519
 520 void pvr2_i2c_core_sync(struct pvr2_hdw *hdw)
 521 {
 522         unsigned long msk;
 523         unsigned int idx;
 524         struct list_head *item,*nc;
 525         struct pvr2_i2c_client *cp;
 526
 527         if (!hdw->i2c_linked) return;
 528         if (!(hdw->i2c_pend_types & PVR2_I2C_PEND_ALL)) {
 529                 return;
 530         }
 531         mutex_lock(&hdw->i2c_list_lock); do {
 532                 pvr2_trace(PVR2_TRACE_I2C_CORE,"i2c: core_sync BEGIN");
 533                 if (hdw->i2c_pend_types & PVR2_I2C_PEND_DETECT) {
 534                         /* One or more I2C clients have attached since we
 535                            last synced.  So scan the list and identify the
 536                            new clients. */
 537                         char *buf;
 538                         unsigned int cnt;
 539                         unsigned long amask = 0;
 540                         buf = kmalloc(BUFSIZE,GFP_KERNEL);
 541                         pvr2_trace(PVR2_TRACE_I2C_CORE,"i2c: PEND_DETECT");
 542                         hdw->i2c_pend_types &= ~PVR2_I2C_PEND_DETECT;
 543                         list_for_each(item,&hdw->i2c_clients) {
 544                                 cp = list_entry(item,struct pvr2_i2c_client,
 545                                                 list);
 546                                 if (!cp->detected_flag) {
 547                                         cp->ctl_mask = 0;
 548                                         pvr2_i2c_probe(hdw,cp);
 549                                         cp->detected_flag = !0;
 550                                         msk = cp->ctl_mask;
 551                                         cnt = 0;
 552                                         if (buf) {
 553                                                 cnt = pvr2_i2c_client_describe(
 554                                                         cp,
 555                                                         PVR2_I2C_DETAIL_ALL,
 556                                                         buf,BUFSIZE);
 557                                         }
 558                                         trace_i2c("Probed: %.*s",cnt,buf);
 559                                         if (handler_check(cp)) {
 560                                                 hdw->i2c_pend_types |=
 561                                                         PVR2_I2C_PEND_CLIENT;
 562                                         }
 563                                         cp->pend_mask = msk;
 564                                         hdw->i2c_pend_mask |= msk;
 565                                         hdw->i2c_pend_types |=
 566                                                 PVR2_I2C_PEND_REFRESH;
 567                                 }
 568                                 amask |= cp->ctl_mask;
 569                         }
 570                         hdw->i2c_active_mask = amask;
 571                         if (buf) kfree(buf);
 572                 }
 573                 if (hdw->i2c_pend_types & PVR2_I2C_PEND_STALE) {
 574                         /* Need to do one or more global updates.  Arrange
 575                            for this to happen. */
 576                         unsigned long m2;
 577                         pvr2_trace(PVR2_TRACE_I2C_CORE,
 578                                    "i2c: PEND_STALE (0x%lx)",
 579                                    hdw->i2c_stale_mask);
 580                         hdw->i2c_pend_types &= ~PVR2_I2C_PEND_STALE;
 581                         list_for_each(item,&hdw->i2c_clients) {
 582                                 cp = list_entry(item,struct pvr2_i2c_client,
 583                                                 list);
 584                                 m2 = hdw->i2c_stale_mask;
 585                                 m2 &= cp->ctl_mask;
 586                                 m2 &= ~cp->pend_mask;
 587                                 if (m2) {
 588                                         pvr2_trace(PVR2_TRACE_I2C_CORE,
 589                                                    "i2c: cp=%p setting 0x%lx",
 590                                                    cp,m2);
 591                                         cp->pend_mask |= m2;
 592                                 }
 593                         }
 594                         hdw->i2c_pend_mask |= hdw->i2c_stale_mask;
 595                         hdw->i2c_stale_mask = 0;
 596                         hdw->i2c_pend_types |= PVR2_I2C_PEND_REFRESH;
 597                 }
 598                 if (hdw->i2c_pend_types & PVR2_I2C_PEND_CLIENT) {
 599                         /* One or more client handlers are asking for an
 600                            update.  Run through the list of known clients
 601                            and update each one. */
 602                         pvr2_trace(PVR2_TRACE_I2C_CORE,"i2c: PEND_CLIENT");
 603                         hdw->i2c_pend_types &= ~PVR2_I2C_PEND_CLIENT;
 604                         list_for_each_safe(item,nc,&hdw->i2c_clients) {
 605                                 cp = list_entry(item,struct pvr2_i2c_client,
 606                                                 list);
 607                                 if (!cp->handler) continue;
 608                                 if (!cp->handler->func_table->update) continue;
 609                                 pvr2_trace(PVR2_TRACE_I2C_CORE,
 610                                            "i2c: cp=%p update",cp);
 611                                 mutex_unlock(&hdw->i2c_list_lock);
 612                                 cp->handler->func_table->update(
 613                                         cp->handler->func_data);
 614                                 mutex_lock(&hdw->i2c_list_lock);
 615                                 /* If client's update function set some
 616                                    additional pending bits, account for that
 617                                    here. */
 618                                 if (cp->pend_mask & ~hdw->i2c_pend_mask) {
 619                                         hdw->i2c_pend_mask |= cp->pend_mask;
 620                                         hdw->i2c_pend_types |=
 621                                                 PVR2_I2C_PEND_REFRESH;
 622                                 }
 623                         }
 624                 }
 625                 if (hdw->i2c_pend_types & PVR2_I2C_PEND_REFRESH) {
 626                         const struct pvr2_i2c_op *opf;
 627                         unsigned long pm;
 628                         /* Some actual updates are pending.  Walk through
 629                            each update type and perform it. */
 630                         pvr2_trace(PVR2_TRACE_I2C_CORE,"i2c: PEND_REFRESH"
 631                                    " (0x%lx)",hdw->i2c_pend_mask);
 632                         hdw->i2c_pend_types &= ~PVR2_I2C_PEND_REFRESH;
 633                         pm = hdw->i2c_pend_mask;
 634                         hdw->i2c_pend_mask = 0;
 635                         for (idx = 0, msk = 1; pm; idx++, msk <<= 1) {
 636                                 if (!(pm & msk)) continue;
 637                                 pm &= ~msk;
 638                                 list_for_each(item,&hdw->i2c_clients) {
 639                                         cp = list_entry(item,
 640                                                         struct pvr2_i2c_client,
 641                                                         list);
 642                                         if (cp->pend_mask & msk) {
 643                                                 cp->pend_mask &= ~msk;
 644                                                 cp->recv_enable = !0;
 645                                         } else {
 646                                                 cp->recv_enable = 0;
 647                                         }
 648                                 }
 649                                 opf = pvr2_i2c_get_op(idx);
 650                                 if (!opf) continue;
 651                                 mutex_unlock(&hdw->i2c_list_lock);
 652                                 opf->update(hdw);
 653                                 mutex_lock(&hdw->i2c_list_lock);
 654                         }
 655                 }
 656                 pvr2_trace(PVR2_TRACE_I2C_CORE,"i2c: core_sync END");
 657         } while (0); mutex_unlock(&hdw->i2c_list_lock);
 658 }
 659
 660 int pvr2_i2c_core_check_stale(struct pvr2_hdw *hdw)
 661 {
 662         unsigned long msk,sm,pm;
 663         unsigned int idx;
 664         const struct pvr2_i2c_op *opf;
 665         struct list_head *item;
 666         struct pvr2_i2c_client *cp;
 667         unsigned int pt = 0;
 668
 669         pvr2_trace(PVR2_TRACE_I2C_CORE,"pvr2_i2c_core_check_stale BEGIN");
 670
 671         pm = hdw->i2c_active_mask;
 672         sm = 0;
 673         for (idx = 0, msk = 1; pm; idx++, msk <<= 1) {
 674                 if (!(msk & pm)) continue;
 675                 pm &= ~msk;
 676                 opf = pvr2_i2c_get_op(idx);
 677                 if (!opf) continue;
 678                 if (opf->check(hdw)) {
 679                         sm |= msk;
 680                 }
 681         }
 682         if (sm) pt |= PVR2_I2C_PEND_STALE;
 683
 684         list_for_each(item,&hdw->i2c_clients) {
 685                 cp = list_entry(item,struct pvr2_i2c_client,list);
 686                 if (!handler_check(cp)) continue;
 687                 pt |= PVR2_I2C_PEND_CLIENT;
 688         }
 689
 690         if (pt) {
 691                 mutex_lock(&hdw->i2c_list_lock); do {
 692                         hdw->i2c_pend_types |= pt;
 693                         hdw->i2c_stale_mask |= sm;
 694                         hdw->i2c_pend_mask |= hdw->i2c_stale_mask;
 695                 } while (0); mutex_unlock(&hdw->i2c_list_lock);
 696         }
 697
 698         pvr2_trace(PVR2_TRACE_I2C_CORE,
 699                    "i2c: types=0x%x stale=0x%lx pend=0x%lx",
 700                    hdw->i2c_pend_types,
 701                    hdw->i2c_stale_mask,
 702                    hdw->i2c_pend_mask);
 703         pvr2_trace(PVR2_TRACE_I2C_CORE,"pvr2_i2c_core_check_stale END");
 704
 705         return (hdw->i2c_pend_types & PVR2_I2C_PEND_ALL) != 0;
 706 }
 707
 708 static unsigned int pvr2_i2c_client_describe(struct pvr2_i2c_client *cp,
 709                                              unsigned int detail,
 710                                              char *buf,unsigned int maxlen)
 711 {
 712         unsigned int ccnt,bcnt;
 713         int spcfl = 0;
 714         const struct pvr2_i2c_op *opf;
 715
 716         ccnt = 0;
 717         if (detail & PVR2_I2C_DETAIL_DEBUG) {
 718                 bcnt = scnprintf(buf,maxlen,
 719                                  "ctxt=%p ctl_mask=0x%lx",
 720                                  cp,cp->ctl_mask);
 721                 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
 722                 spcfl = !0;
 723         }
 724         bcnt = scnprintf(buf,maxlen,
 725                          "%s%s @ 0x%x",
 726                          (spcfl ? " " : ""),
 727                          cp->client->name,
 728                          cp->client->addr);
 729         ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
 730         if ((detail & PVR2_I2C_DETAIL_HANDLER) &&
 731             cp->handler && cp->handler->func_table->describe) {
 732                 bcnt = scnprintf(buf,maxlen," (");
 733                 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
 734                 bcnt = cp->handler->func_table->describe(
 735                         cp->handler->func_data,buf,maxlen);
 736                 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
 737                 bcnt = scnprintf(buf,maxlen,")");
 738                 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
 739         }
 740         if ((detail & PVR2_I2C_DETAIL_CTLMASK) && cp->ctl_mask) {
 741                 unsigned int idx;
 742                 unsigned long msk,sm;
 743                 int spcfl;
 744                 bcnt = scnprintf(buf,maxlen," [");
 745                 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
 746                 sm = 0;
 747                 spcfl = 0;
 748                 for (idx = 0, msk = 1; msk; idx++, msk <<= 1) {
 749                         if (!(cp->ctl_mask & msk)) continue;
 750                         opf = pvr2_i2c_get_op(idx);
 751                         if (opf) {
 752                                 bcnt = scnprintf(buf,maxlen,"%s%s",
 753                                                  spcfl ? " " : "",
 754                                                  opf->name);
 755                                 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
 756                                 spcfl = !0;
 757                         } else {
 758                                 sm |= msk;
 759                         }
 760                 }
 761                 if (sm) {
 762                         bcnt = scnprintf(buf,maxlen,"%s%lx",
 763                                          idx != 0 ? " " : "",sm);
 764                         ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
 765                 }
 766                 bcnt = scnprintf(buf,maxlen,"]");
 767                 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
 768         }
 769         return ccnt;
 770 }
 771
 772 unsigned int pvr2_i2c_report(struct pvr2_hdw *hdw,
 773                              char *buf,unsigned int maxlen)
 774 {
 775         unsigned int ccnt,bcnt;
 776         struct list_head *item;
 777         struct pvr2_i2c_client *cp;
 778         ccnt = 0;
 779         mutex_lock(&hdw->i2c_list_lock); do {
 780                 list_for_each(item,&hdw->i2c_clients) {
 781                         cp = list_entry(item,struct pvr2_i2c_client,list);
 782                         bcnt = pvr2_i2c_client_describe(
 783                                 cp,
 784                                 (PVR2_I2C_DETAIL_HANDLER|
 785                                  PVR2_I2C_DETAIL_CTLMASK),
 786                                 buf,maxlen);
 787                         ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
 788                         bcnt = scnprintf(buf,maxlen,"\n");
 789                         ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
 790                 }
 791         } while (0); mutex_unlock(&hdw->i2c_list_lock);
 792         return ccnt;
 793 }
 794
 795 static int pvr2_i2c_attach_inform(struct i2c_client *client)
 796 {
 797         struct pvr2_hdw *hdw = (struct pvr2_hdw *)(client->adapter->algo_data);
 798         struct pvr2_i2c_client *cp;
 799         int fl = !(hdw->i2c_pend_types & PVR2_I2C_PEND_ALL);
 800         cp = kmalloc(sizeof(*cp),GFP_KERNEL);
 801         trace_i2c("i2c_attach [client=%s @ 0x%x ctxt=%p]",
 802                   client->name,
 803                   client->addr,cp);
 804         if (!cp) return -ENOMEM;
 805         memset(cp,0,sizeof(*cp));
 806         INIT_LIST_HEAD(&cp->list);
 807         cp->client = client;
 808         mutex_lock(&hdw->i2c_list_lock); do {
 809                 list_add_tail(&cp->list,&hdw->i2c_clients);
 810                 hdw->i2c_pend_types |= PVR2_I2C_PEND_DETECT;
 811         } while (0); mutex_unlock(&hdw->i2c_list_lock);
 812         if (fl) pvr2_hdw_poll_trigger_unlocked(hdw);
 813         return 0;
 814 }
 815
 816 static int pvr2_i2c_detach_inform(struct i2c_client *client)
 817 {
 818         struct pvr2_hdw *hdw = (struct pvr2_hdw *)(client->adapter->algo_data);
 819         struct pvr2_i2c_client *cp;
 820         struct list_head *item,*nc;
 821         unsigned long amask = 0;
 822         int foundfl = 0;
 823         mutex_lock(&hdw->i2c_list_lock); do {
 824                 list_for_each_safe(item,nc,&hdw->i2c_clients) {
 825                         cp = list_entry(item,struct pvr2_i2c_client,list);
 826                         if (cp->client == client) {
 827                                 trace_i2c("pvr2_i2c_detach"
 828                                           " [client=%s @ 0x%x ctxt=%p]",
 829                                           client->name,
 830                                           client->addr,cp);
 831                                 if (cp->handler &&
 832                                     cp->handler->func_table->detach) {
 833                                         cp->handler->func_table->detach(
 834                                                 cp->handler->func_data);
 835                                 }
 836                                 list_del(&cp->list);
 837                                 kfree(cp);
 838                                 foundfl = !0;
 839                                 continue;
 840                         }
 841                         amask |= cp->ctl_mask;
 842                 }
 843                 hdw->i2c_active_mask = amask;
 844         } while (0); mutex_unlock(&hdw->i2c_list_lock);
 845         if (!foundfl) {
 846                 trace_i2c("pvr2_i2c_detach [client=%s @ 0x%x ctxt=<unknown>]",
 847                           client->name,
 848                           client->addr);
 849         }
 850         return 0;
 851 }
 852
 853 static struct i2c_algorithm pvr2_i2c_algo_template = {
 854         .master_xfer   = pvr2_i2c_xfer,
 855         .algo_control  = pvr2_i2c_control,
 856         .functionality = pvr2_i2c_functionality,
 857 };
 858
 859 static struct i2c_adapter pvr2_i2c_adap_template = {
 860         .owner         = THIS_MODULE,
 861         .class     = I2C_CLASS_TV_ANALOG,
 862         .id            = I2C_HW_B_BT848,
 863         .client_register = pvr2_i2c_attach_inform,
 864         .client_unregister = pvr2_i2c_detach_inform,
 865 };
 866
 867 static void do_i2c_scan(struct pvr2_hdw *hdw)
 868 {
 869         struct i2c_msg msg[1];
 870         int i,rc;
 871         msg[0].addr = 0;
 872         msg[0].flags = I2C_M_RD;
 873         msg[0].len = 0;
 874         msg[0].buf = NULL;
 875         printk("%s: i2c scan beginning\n",hdw->name);
 876         for (i = 0; i < 128; i++) {
 877                 msg[0].addr = i;
 878                 rc = i2c_transfer(&hdw->i2c_adap,msg,
 879                                   sizeof(msg)/sizeof(msg[0]));
 880                 if (rc != 1) continue;
 881                 printk("%s: i2c scan: found device @ 0x%x\n",hdw->name,i);
 882         }
 883         printk("%s: i2c scan done.\n",hdw->name);
 884 }
 885
 886 void pvr2_i2c_core_init(struct pvr2_hdw *hdw)
 887 {
 888         unsigned int idx;
 889
 890         // The default action for all possible I2C addresses is just to do
 891         // the transfer normally.
 892         for (idx = 0; idx < PVR2_I2C_FUNC_CNT; idx++) {
 893                 hdw->i2c_func[idx] = pvr2_i2c_basic_op;
 894         }
 895
 896         // If however we're dealing with new hardware, insert some hacks in
 897         // the I2C transfer stack to let things work better.
 898         if (hdw->hdw_type == PVR2_HDW_TYPE_24XXX) {
 899                 hdw->i2c_func[0x1b] = i2c_hack_wm8775;
 900                 hdw->i2c_func[0x44] = i2c_hack_cx25840;
 901         }
 902
 903         // Configure the adapter and set up everything else related to it.
 904         memcpy(&hdw->i2c_adap,&pvr2_i2c_adap_template,sizeof(hdw->i2c_adap));
 905         memcpy(&hdw->i2c_algo,&pvr2_i2c_algo_template,sizeof(hdw->i2c_algo));
 906         strlcpy(hdw->i2c_adap.name,hdw->name,sizeof(hdw->i2c_adap.name));
 907         hdw->i2c_adap.algo = &hdw->i2c_algo;
 908         hdw->i2c_adap.algo_data = hdw;
 909         hdw->i2c_pend_mask = 0;
 910         hdw->i2c_stale_mask = 0;
 911         hdw->i2c_active_mask = 0;
 912         INIT_LIST_HEAD(&hdw->i2c_clients);
 913         mutex_init(&hdw->i2c_list_lock);
 914         hdw->i2c_linked = !0;
 915         i2c_add_adapter(&hdw->i2c_adap);
 916         if (i2c_scan) do_i2c_scan(hdw);
 917 }
 918
 919 void pvr2_i2c_core_done(struct pvr2_hdw *hdw)
 920 {
 921         if (hdw->i2c_linked) {
 922                 i2c_del_adapter(&hdw->i2c_adap);
 923                 hdw->i2c_linked = 0;
 924         }
 925 }
 926
 927 /*
 928   Stuff for Emacs to see, in order to encourage consistent editing style:
 929   *** Local Variables: ***
 930   *** mode: c ***
 931   *** fill-column: 75 ***
 932   *** tab-width: 8 ***
 933   *** c-basic-offset: 8 ***
 934   *** End: ***
 935   */