Lines Matching defs:drv_data
111 mv64xxx_i2c_fsm(struct mv64xxx_i2c_data *drv_data, u32 status)
118 if (drv_data->state == MV64XXX_I2C_STATE_IDLE) {
119 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
128 drv_data->action = MV64XXX_I2C_ACTION_SEND_ADDR_1;
129 drv_data->state = MV64XXX_I2C_STATE_WAITING_FOR_ADDR_1_ACK;
134 if (drv_data->msg->flags & I2C_M_TEN) {
135 drv_data->action = MV64XXX_I2C_ACTION_SEND_ADDR_2;
136 drv_data->state =
143 if ((drv_data->bytes_left == 0)
144 || (drv_data->aborting
145 && (drv_data->byte_posn != 0))) {
146 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
147 drv_data->state = MV64XXX_I2C_STATE_IDLE;
149 drv_data->action = MV64XXX_I2C_ACTION_SEND_DATA;
150 drv_data->state =
152 drv_data->bytes_left--;
158 if (drv_data->msg->flags & I2C_M_TEN) {
159 drv_data->action = MV64XXX_I2C_ACTION_SEND_ADDR_2;
160 drv_data->state =
166 if (drv_data->bytes_left == 0) {
167 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
168 drv_data->state = MV64XXX_I2C_STATE_IDLE;
174 drv_data->action = MV64XXX_I2C_ACTION_CONTINUE;
176 drv_data->action = MV64XXX_I2C_ACTION_RCV_DATA;
177 drv_data->bytes_left--;
179 drv_data->state = MV64XXX_I2C_STATE_WAITING_FOR_SLAVE_DATA;
181 if ((drv_data->bytes_left == 1) || drv_data->aborting)
182 drv_data->cntl_bits &= ~MV64XXX_I2C_REG_CONTROL_ACK;
186 drv_data->action = MV64XXX_I2C_ACTION_RCV_DATA_STOP;
187 drv_data->state = MV64XXX_I2C_STATE_IDLE;
194 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
195 drv_data->state = MV64XXX_I2C_STATE_IDLE;
196 drv_data->rc = -ENODEV;
200 dev_err(&drv_data->adapter.dev,
203 drv_data->state, status, drv_data->msg->addr,
204 drv_data->msg->flags);
205 drv_data->action = MV64XXX_I2C_ACTION_SEND_STOP;
206 drv_data->state = MV64XXX_I2C_STATE_IDLE;
207 drv_data->rc = -EIO;
212 mv64xxx_i2c_do_action(struct mv64xxx_i2c_data *drv_data)
214 switch(drv_data->action) {
216 writel(drv_data->cntl_bits,
217 drv_data->reg_base + MV64XXX_I2C_REG_CONTROL);
221 writel(drv_data->cntl_bits | MV64XXX_I2C_REG_CONTROL_START,
222 drv_data->reg_base + MV64XXX_I2C_REG_CONTROL);
226 writel(drv_data->addr1,
227 drv_data->reg_base + MV64XXX_I2C_REG_DATA);
228 writel(drv_data->cntl_bits,
229 drv_data->reg_base + MV64XXX_I2C_REG_CONTROL);
233 writel(drv_data->addr2,
234 drv_data->reg_base + MV64XXX_I2C_REG_DATA);
235 writel(drv_data->cntl_bits,
236 drv_data->reg_base + MV64XXX_I2C_REG_CONTROL);
240 writel(drv_data->msg->buf[drv_data->byte_posn++],
241 drv_data->reg_base + MV64XXX_I2C_REG_DATA);
242 writel(drv_data->cntl_bits,
243 drv_data->reg_base + MV64XXX_I2C_REG_CONTROL);
247 drv_data->msg->buf[drv_data->byte_posn++] =
248 readl(drv_data->reg_base + MV64XXX_I2C_REG_DATA);
249 writel(drv_data->cntl_bits,
250 drv_data->reg_base + MV64XXX_I2C_REG_CONTROL);
254 drv_data->msg->buf[drv_data->byte_posn++] =
255 readl(drv_data->reg_base + MV64XXX_I2C_REG_DATA);
256 drv_data->cntl_bits &= ~MV64XXX_I2C_REG_CONTROL_INTEN;
257 writel(drv_data->cntl_bits | MV64XXX_I2C_REG_CONTROL_STOP,
258 drv_data->reg_base + MV64XXX_I2C_REG_CONTROL);
259 drv_data->block = 0;
260 wake_up_interruptible(&drv_data->waitq);
265 dev_err(&drv_data->adapter.dev,
267 drv_data->action);
268 drv_data->rc = -EIO;
271 drv_data->cntl_bits &= ~MV64XXX_I2C_REG_CONTROL_INTEN;
272 writel(drv_data->cntl_bits | MV64XXX_I2C_REG_CONTROL_STOP,
273 drv_data->reg_base + MV64XXX_I2C_REG_CONTROL);
274 drv_data->block = 0;
275 wake_up_interruptible(&drv_data->waitq);
283 struct mv64xxx_i2c_data *drv_data = dev_id;
288 spin_lock_irqsave(&drv_data->lock, flags);
289 while (readl(drv_data->reg_base + MV64XXX_I2C_REG_CONTROL) &
291 status = readl(drv_data->reg_base + MV64XXX_I2C_REG_STATUS);
292 mv64xxx_i2c_fsm(drv_data, status);
293 mv64xxx_i2c_do_action(drv_data);
296 spin_unlock_irqrestore(&drv_data->lock, flags);
309 mv64xxx_i2c_prepare_for_io(struct mv64xxx_i2c_data *drv_data,
314 drv_data->msg = msg;
315 drv_data->byte_posn = 0;
316 drv_data->bytes_left = msg->len;
317 drv_data->aborting = 0;
318 drv_data->rc = 0;
319 drv_data->cntl_bits = MV64XXX_I2C_REG_CONTROL_ACK |
329 drv_data->addr1 = 0xf0 | (((u32)msg->addr & 0x300) >> 7) | dir;
330 drv_data->addr2 = (u32)msg->addr & 0xff;
332 drv_data->addr1 = ((u32)msg->addr & 0x7f) << 1 | dir;
333 drv_data->addr2 = 0;
338 mv64xxx_i2c_wait_for_completion(struct mv64xxx_i2c_data *drv_data)
344 time_left = wait_event_interruptible_timeout(drv_data->waitq,
345 !drv_data->block, msecs_to_jiffies(drv_data->adapter.timeout));
347 spin_lock_irqsave(&drv_data->lock, flags);
349 drv_data->rc = -ETIMEDOUT;
352 drv_data->rc = time_left; /* errno value */
356 if (abort && drv_data->block) {
357 drv_data->aborting = 1;
358 spin_unlock_irqrestore(&drv_data->lock, flags);
360 time_left = wait_event_timeout(drv_data->waitq,
361 !drv_data->block,
362 msecs_to_jiffies(drv_data->adapter.timeout));
364 if ((time_left <= 0) && drv_data->block) {
365 drv_data->state = MV64XXX_I2C_STATE_IDLE;
366 dev_err(&drv_data->adapter.dev,
368 "time_left: %d\n", drv_data->block,
372 spin_unlock_irqrestore(&drv_data->lock, flags);
376 mv64xxx_i2c_execute_msg(struct mv64xxx_i2c_data *drv_data, struct i2c_msg *msg)
380 spin_lock_irqsave(&drv_data->lock, flags);
381 mv64xxx_i2c_prepare_for_io(drv_data, msg);
384 if (drv_data->msg->flags & I2C_M_RD) {
386 drv_data->action = MV64XXX_I2C_ACTION_CONTINUE;
387 drv_data->state =
390 drv_data->action = MV64XXX_I2C_ACTION_SEND_DATA;
391 drv_data->state =
393 drv_data->bytes_left--;
396 drv_data->action = MV64XXX_I2C_ACTION_SEND_START;
397 drv_data->state = MV64XXX_I2C_STATE_WAITING_FOR_START_COND;
400 drv_data->block = 1;
401 mv64xxx_i2c_do_action(drv_data);
402 spin_unlock_irqrestore(&drv_data->lock, flags);
404 mv64xxx_i2c_wait_for_completion(drv_data);
405 return drv_data->rc;
424 struct mv64xxx_i2c_data *drv_data = i2c_get_adapdata(adap);
428 if ((rc = mv64xxx_i2c_execute_msg(drv_data, &msgs[i])) < 0)
447 mv64xxx_i2c_hw_init(struct mv64xxx_i2c_data *drv_data)
449 writel(0, drv_data->reg_base + MV64XXX_I2C_REG_SOFT_RESET);
450 writel((((drv_data->freq_m & 0xf) << 3) | (drv_data->freq_n & 0x7)),
451 drv_data->reg_base + MV64XXX_I2C_REG_BAUD);
452 writel(0, drv_data->reg_base + MV64XXX_I2C_REG_SLAVE_ADDR);
453 writel(0, drv_data->reg_base + MV64XXX_I2C_REG_EXT_SLAVE_ADDR);
455 drv_data->reg_base + MV64XXX_I2C_REG_CONTROL);
456 drv_data->state = MV64XXX_I2C_STATE_IDLE;
461 struct mv64xxx_i2c_data *drv_data)
467 drv_data->adapter.name)) {
469 drv_data->reg_base = ioremap(r->start,
471 drv_data->reg_base_p = r->start;
479 mv64xxx_i2c_unmap_regs(struct mv64xxx_i2c_data *drv_data)
481 if (drv_data->reg_base) {
482 iounmap(drv_data->reg_base);
483 release_mem_region(drv_data->reg_base_p,
487 drv_data->reg_base = NULL;
488 drv_data->reg_base_p = 0;
494 struct mv64xxx_i2c_data *drv_data;
501 drv_data = kzalloc(sizeof(struct mv64xxx_i2c_data), GFP_KERNEL);
502 if (!drv_data)
505 if (mv64xxx_i2c_map_regs(pd, drv_data)) {
510 strlcpy(drv_data->adapter.name, MV64XXX_I2C_CTLR_NAME " adapter",
511 sizeof(drv_data->adapter.name));
513 init_waitqueue_head(&drv_data->waitq);
514 spin_lock_init(&drv_data->lock);
516 drv_data->freq_m = pdata->freq_m;
517 drv_data->freq_n = pdata->freq_n;
518 drv_data->irq = platform_get_irq(pd, 0);
519 if (drv_data->irq < 0) {
523 drv_data->adapter.dev.parent = &pd->dev;
524 drv_data->adapter.id = I2C_HW_MV64XXX;
525 drv_data->adapter.algo = &mv64xxx_i2c_algo;
526 drv_data->adapter.owner = THIS_MODULE;
527 drv_data->adapter.class = I2C_CLASS_HWMON;
528 drv_data->adapter.timeout = pdata->timeout;
529 drv_data->adapter.retries = pdata->retries;
530 platform_set_drvdata(pd, drv_data);
531 i2c_set_adapdata(&drv_data->adapter, drv_data);
533 mv64xxx_i2c_hw_init(drv_data);
535 if (request_irq(drv_data->irq, mv64xxx_i2c_intr, 0,
536 MV64XXX_I2C_CTLR_NAME, drv_data)) {
537 dev_err(&drv_data->adapter.dev,
539 drv_data->irq);
542 } else if ((rc = i2c_add_adapter(&drv_data->adapter)) != 0) {
543 dev_err(&drv_data->adapter.dev,
551 free_irq(drv_data->irq, drv_data);
553 mv64xxx_i2c_unmap_regs(drv_data);
555 kfree(drv_data);
562 struct mv64xxx_i2c_data *drv_data = platform_get_drvdata(dev);
565 rc = i2c_del_adapter(&drv_data->adapter);
566 free_irq(drv_data->irq, drv_data);
567 mv64xxx_i2c_unmap_regs(drv_data);
568 kfree(drv_data);