spinlock_t lock;
        unsigned int total_trans;
        unsigned long state;
-       unsigned long max_states;
        ktime_t last_time;
        ktime_t *time_in_state;
        unsigned int *trans_table;
                goto unlock;
 
        update_time_in_state(stats);
-       stats->trans_table[stats->state * stats->max_states + new_state]++;
+       stats->trans_table[stats->state * (cdev->max_state + 1) + new_state]++;
        stats->state = new_state;
        stats->total_trans++;
 
        spin_lock(&stats->lock);
        update_time_in_state(stats);
 
-       for (i = 0; i < stats->max_states; i++) {
+       for (i = 0; i <= cdev->max_state; i++) {
                len += sprintf(buf + len, "state%u\t%llu\n", i,
                               ktime_to_ms(stats->time_in_state[i]));
        }
 {
        struct thermal_cooling_device *cdev = to_cooling_device(dev);
        struct cooling_dev_stats *stats = cdev->stats;
-       int i, states = stats->max_states;
+       int i, states = cdev->max_state + 1;
 
        spin_lock(&stats->lock);
 
        memset(stats->trans_table, 0,
               states * states * sizeof(*stats->trans_table));
 
-       for (i = 0; i < stats->max_states; i++)
+       for (i = 0; i < states; i++)
                stats->time_in_state[i] = ktime_set(0, 0);
 
        spin_unlock(&stats->lock);
 
        len += snprintf(buf + len, PAGE_SIZE - len, " From  :    To\n");
        len += snprintf(buf + len, PAGE_SIZE - len, "       : ");
-       for (i = 0; i < stats->max_states; i++) {
+       for (i = 0; i <= cdev->max_state; i++) {
                if (len >= PAGE_SIZE)
                        break;
                len += snprintf(buf + len, PAGE_SIZE - len, "state%2u  ", i);
 
        len += snprintf(buf + len, PAGE_SIZE - len, "\n");
 
-       for (i = 0; i < stats->max_states; i++) {
+       for (i = 0; i <= cdev->max_state; i++) {
                if (len >= PAGE_SIZE)
                        break;
 
                len += snprintf(buf + len, PAGE_SIZE - len, "state%2u:", i);
 
-               for (j = 0; j < stats->max_states; j++) {
+               for (j = 0; j <= cdev->max_state; j++) {
                        if (len >= PAGE_SIZE)
                                break;
                        len += snprintf(buf + len, PAGE_SIZE - len, "%8u ",
-                               stats->trans_table[i * stats->max_states + j]);
+                               stats->trans_table[i * (cdev->max_state + 1) + j]);
                }
                if (len >= PAGE_SIZE)
                        break;
 {
        const struct attribute_group *stats_attr_group = NULL;
        struct cooling_dev_stats *stats;
-       unsigned long states;
+       /* Total number of states is highest state + 1 */
+       unsigned long states = cdev->max_state + 1;
        int var;
 
-       if (cdev->ops->get_max_state(cdev, &states))
-               goto out;
-
-       states++; /* Total number of states is highest state + 1 */
-
        var = sizeof(*stats);
        var += sizeof(*stats->time_in_state) * states;
        var += sizeof(*stats->trans_table) * states * states;
        stats->trans_table = (unsigned int *)(stats->time_in_state + states);
        cdev->stats = stats;
        stats->last_time = ktime_get();
-       stats->max_states = states;
 
        spin_lock_init(&stats->lock);