how to jump (c) from org-calendar to org-agenda showing whole day

You can do it in various ways. In the spirit of "teaching someone to fish", the first thing that you have to do is figure out what c in the calendar does. So open the calendar, place the cursor on a date and say C-h c c which will tell you that c in the calendar runs the command org-calendar-goto-agenda. So the next step is to do C-h f org-calendar-goto-agenda and read its documentation. Then click on the link in that documentation to go to the code and read it.

So here are three alternatives:

1. The code of the function is pretty simple:

(defun org-calendar-goto-agenda ()
  "Compute the Org agenda for the calendar date displayed at the cursor.
This is a command t        (org-agenda-span 1))hat has to be installed in `calendar-mode-map'."
  (interactive)
  ;; Temporarily disable sticky agenda since user clearly wants to
  ;; refresh view anyway.
  (let ((org-agenda-buffer-tmp-name "*Org Agenda(a)*")
        (org-agenda-sticky nil))
    (org-agenda-list nil (calendar-absolute-from-gregorian
                          (calendar-cursor-to-date))
                     nil)))

You can modify the function to make the agenda view to be just one day, by setting the variable org-agenda-span to 1 locally:

(defun org-calendar-goto-agenda ()
  "Compute the Org agenda for the calendar date displayed at the cursor.
This is a command t        (org-agenda-span 1))hat has to be installed in `calendar-mode-map'."
  (interactive)
  ;; Temporarily disable sticky agenda since user clearly wants to
  ;; refresh view anyway.
  (let ((org-agenda-buffer-tmp-name "*Org Agenda(a)*")
        (org-agenda-sticky nil)
        (org-agenda-span 1))
    (org-agenda-list nil (calendar-absolute-from-gregorian
                          (calendar-cursor-to-date))
                     nil)))

The trouble with this is that you have now forked the Org mode code and you will need to make this change to the code every time you update. That might be appropriate in some cases, but you should avoid it if at all possible.

2. You can define your own command and bind it to c in the calendar:

(defun my-org-calendar-goto-agenda ()
  (interactive)
  (let ((org-agenda-span 1))
    (org-calendar-goto-agenda)))

(define-key calendar-mode-map (kbd "c") #'my-org-calendar-goto-agenda)

That works pretty well. You have to remember to undo the keymap modification to restore the original state if you want to try the third method below:

(define-key calendar-mode-map (kbd "c") #'org-calendar-goto-agenda)

3. You can add an advice to the org-calendar-goto-agenda command. This is a formalization of the second option above: it is slightly more "advanced" but it is a powerful way of dealing with questions of this sort: you are given a function that does almost what you want and you want to customize it so that it does exactly what you want. This method cannot always be used, but it can be used in this case and it provides a simple example:

(defun org-calendar-goto-agenda-around (orig-fun &rest args)
  (let ((org-agenda-span 1))
    (apply orig-fun args)))

(advice-add 'org-calendar-goto-agenda :around #'org-calendar-goto-agenda-around)

The idea is that you define an around function that does something around the call of the original function (in this case, it let-binds org-agenda-span to 1, just like the other methods and then calls the original function in this new let-bound environment). Then we modify the original function by installing the advice. If you do C-h f org-calendar-goto-agenda now, you will see that there is some added information:

This function has :around advice: ‘org-calendar-goto-agenda-around’.

This is probably the cleanest way to do what you want. You can also easily remove the advice with

(advice-remove 'org-calendar-goto-agenda  #'org-calendar-goto-agenda-around)

so this method allows you to experiment fairly easily. This is my recommended solution.